web-dev-qa-db-fra.com

Comment configurer Jenkins pour qu'il s'exécute sur le port 80

J'utilise Ubuntu 11.10 et ai exécuté Sudo apt-get install jenkins pour installer Jenkins sur ce système.

J'ai vu des tutoriels sur la configuration d'un proxy inverse (Apache, Nginx, etc.), mais il s'agit d'un VM dédié à Jenkins et j'aimerais qu'il soit aussi léger que possible tout en permettant à Jenkins de fonctionner port 80.

J'ai trouvé la configuration upstart dans /etc/init/jenkins.conf et modifié le port à 80 env HTTP_PORT=80

Lorsque je lance jenkins via service jenkins start, ps révèle qu'il s'exécute pendant quelques secondes, puis se termine.

Est-ce parce que jenkins est exécuté en tant qu'utilisateur jenkins sur un port privilégié? Si oui, comment puis-je résoudre ce problème? Toute autre idée est la bienvenue.

Voici la configuration parvenue:

description "jenkins: Jenkins Continuous Integration Server"
author "James Page <[email protected]>"

start on (local-filesystems and net-device-up IFACE!=lo)
stop on runlevel [!2345]

env USER="jenkins"
env GROUP="jenkins"
env JENKINS_LOG="/var/log/jenkins"
env JENKINS_ROOT="/usr/share/jenkins"
env JENKINS_HOME="/var/lib/jenkins"
env JENKINS_RUN="/var/run/jenkins"
env HTTP_PORT=80
env AJP_PORT=-1
env Java_OPTS=""
env Java_HOME="/usr/lib/jvm/default-Java"

limit nofile 8192 8192

pre-start script
    test -f $JENKINS_ROOT/jenkins.war || { stop ; exit 0; }
    $JENKINS_ROOT/bin/maintain-plugins.sh   
    mkdir $JENKINS_RUN > /dev/null 2>&1  || true
    chown -R $USER:$GROUP $JENKINS_RUN || true
end script

script
    JENKINS_ARGS="--webroot=$JENKINS_RUN/war --httpPort=$HTTP_PORT --ajp13Port=$AJP_PORT"
    exec daemon --name=jenkins --inherit --output=$JENKINS_LOG/jenkins.log --user=$USER \
        -- $Java_HOME/bin/Java $Java_OPTS -jar $JENKINS_ROOT/jenkins.war $JENKINS_ARGS \
        --preferredClassLoader=Java.net.URLClassLoader
end script
45
hafichuk

Essayez de ' authbind ':

Sudo apt-get install authbind
Sudo touch /etc/authbind/byport/80
Sudo chmod 500 /etc/authbind/byport/80 
Sudo chown jenkins /etc/authbind/byport/80

Puis modifiez le script ci-dessus pour avoir (ajoutez authbind avant la partie $Java_HOME/bin/Java):

exec daemon --name=jenkins --inherit --output=$JENKINS_LOG/jenkins.log \
--user=$USER -- authbind $Java_HOME/bin/Java $Java_OPTS \
-jar $JENKINS_ROOT/jenkins.war $JENKINS_ARGS \
--preferredClassLoader=Java.net.URLClassLoader

Pour les nouvelles installations Jenkins (1.598) sur les nouvelles installations Ubuntu (14.04), éditez /etc/init.d/jenkins et ajoutez authbind avant $Java

$SU -l $JENKINS_USER --Shell=/bin/bash -c "$DAEMON $DAEMON_ARGS -- authbind $Java $Java_ARGS -jar $JENKINS_WAR $JENKINS_ARGS" || return 2

Comme mentionné par Alan (voir le commentaire ci-dessous), si vous avez besoin d’IPv6 et que votre système est inférieur à Quantal, vous pouvez utiliser apt-get pour installer authbind et télécharger une version plus récente. Assurez-vous d’avoir installé libc6 et libc6-udeb. Voici authbind version 2.1.1 d'Ubuntu:

Puis exécutez:

Sudo dpkg -i authbind_2.1.1_AMD64.deb
# or Sudo dpkg -i authbind_2.1.1_i386.deb

Sudo touch /etc/authbind/byport/80
Sudo chmod 500 /etc/authbind/byport/80 
Sudo chown jenkins /etc/authbind/byport/80
29
JScoobyCed

Une autre solution consiste simplement à utiliser iptables pour rediriger le trafic entrant de 80 à 8080. Les règles ressemblent à ceci:

-A INPUT -i eth0 -p tcp --dport 80 -j ACCEPT
-A INPUT -i eth0 -p tcp --dport 8080 -j ACCEPT
-A PREROUTING -t nat -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080

Reformaté en tant que fichier iptables.rules:

*filter
:INPUT ACCEPT [100:100000]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [95:9000]
-A INPUT -i eth0 -p tcp --dport 80 -j ACCEPT
-A INPUT -i eth0 -p tcp --dport 8080 -j ACCEPT
COMMIT

*nat
-A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080
COMMIT

L'avantage d'un fichier iptable.rules est que les règles peuvent persister après un redémarrage. Assurez-vous simplement d’intégrer toutes les autres règles iptables actuelles dans le même fichier!

Sur Redhat/CentOS, ce fichier peut aller dans /etc/sysconfig/iptables.

Sur les systèmes Debian/Ubuntu, ils peuvent être enregistrés dans /etc/iptables/rules.v4 à l’aide du paquet iptables-persistent. Vous pouvez également appeler iptable.rules en modifiant /etc/network/interfaces ou en vous connectant à des scripts if-up/if-down. Le wiki de la communauté Ubuntu a une excellente page expliquant ces méthodes.

Comme c'est généralement le cas avec les réseaux, il y a beaucoup de façons différentes d'atteindre le même résultat. Utilisez ce qui vous convient le mieux!

42
Chris Laskey
  1. Allez dans/etc/default folder -> Ouvrez le fichier "jenkins"
  2. Modifiez la ligne HTTP_PORT = 8080 sous la forme HTTP_PORT = 80
  3. Démarrez Jenkins en tant que root en utilisant la commande: Sudo /etc/init.d/jenkins start
  4. Ouvrez un navigateur et naviguez en tant qu’hôte local: 80

c'est tout

32
Ripon Al Wasim

Je suggère d'utiliser Apache et mod_proxy. C’est ce que je fais, et ma configuration vhost ressemble un peu à ceci (je redirige également pour SSL mais vous pouvez l’omettre):

<VirtualHost *:443>
ServerAdmin [email protected]
ServerName ci.example.com

ProxyRequests Off
<Proxy *>
    Order deny,allow
    Allow from all
</Proxy>
ProxyPreservehost on
ProxyPass / http://localhost:8080/

Header edit Location ^http://ci.example.com/ https://ci.example.com/

SSLEngine on
SSLCertificateFile /etc/Apache2/keys/Apache.pem
</VirtualHost>
7
regulatethis

Depuis que j'ai utilisé docker . Vous pouvez l'utiliser pour exécuter Jenkins sur le port 80, ci-après un extrait de mon script:

JENKINS_PORT=80
JENKINS_HOME=/home/jenkins
/usr/bin/docker run -d -p $JENKINS_PORT:8080 -v $JENKINS_HOME jenkins
1
Ali SAID OMAR

J'ai eu le même problème et j'ai trouvé la meilleure solution en utilisant iptables.

Par défaut, Jenkins fonctionne sur les ports 8080 ou 8443. Et les serveurs HTTP/HTTPS s'exécutent sur les ports 80 et 443.

Mais ce sont les ports spéciaux et le processus les utilisant doit appartenir à root. 

Mais exécuter Jenkins en tant que root n'est pas la meilleure solution (il devrait être exécuté en tant que son propre utilisateur) et il en va de même d'exécuter Jenkins avec un serveur Web tel qu'Apache et de lui laisser des requêtes proxy à Jenkins

La meilleure solution consiste à utiliser iptables sur Linux pour transférer le trafic.

1) Utilisez cette commande pour lister la configuration actuelle d’iptables: 

$ iptables -L -n

target     prot opt source               destination
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:8443
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:8080
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:443
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:80

2) Si vous ne voyez pas les entrées ci-dessus, vous devez exécuter les commandes ci-dessous:

Sudo iptables -I INPUT 1 -p tcp --dport 8443 -j ACCEPT

Sudo iptables -I INPUT 1 -p tcp --dport 8080 -j ACCEPT

Sudo iptables -I INPUT 1 -p tcp --dport 443 -j ACCEPT

Sudo iptables -I INPUT 1 -p tcp --dport 80 -j ACCEPT

3) Maintenant, relancez la commande $ iptables -L -n et vérifiez que vous voyez bien la 1ère étape o/p.

4) La dernière étape consiste à exécuter les commandes ci-dessous pour transférer le trafic du port 80 vers 8080 et le trafic du port 443 vers 8443 (si vous utilisez HTTPS).

Sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080

Sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8443

5) Votre URL devrait maintenant rester sur le port 80

Vous pouvez trouver plus de détails ici .

1
Pratik Patel

Aucune des réponses n'indique comment rediriger simplement 80 vers 8080 avec iptables.
Heureusement, le commentaire de dskrvk le fait!

Il y a aussi un Jenkins wiki documentant ceci


Il me suffisait de copier/coller ces lignes dans mon terminal pour que la redirection fonctionne:

Sudo iptables -I INPUT 1 -p tcp --dport 8443 -j ACCEPT
Sudo iptables -I INPUT 1 -p tcp --dport 8080 -j ACCEPT
Sudo iptables -I INPUT 1 -p tcp --dport 443 -j ACCEPT
Sudo iptables -I INPUT 1 -p tcp --dport 80 -j ACCEPT
Sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080
Sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8443

En passant, n'oubliez pas de l'inclure dans les scripts d'initialisation de votre serveur une fois testé, sinon vous perdrez la redirection après un redémarrage .Testé sur Debian 8.2 (Jessie)

0
Balmipour

le moyen firewalld pour transférer le port 8080 au port 80

yum install firewalld
systemctl start firewalld
chkconfig firewalld on
firewall-cmd --permanent --zone=external --change-interface=eth0
firewall-cmd --permanent --zone=external --add-forward-port=port=80:proto=tcp:toport=8080
0
Greg

Vous pouvez y parvenir en utilisant les méthodes suivantes.

  1. Une règle de transfert de table IP. 
  2. Utiliser un proxy inverse comme Nginx.
  3. Lancer Jenkins derrière un équilibreur de charge.

Méthode 1: Exécution de Jenkins sur 80 à l'aide de la règle de transfert de table IP

Sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-ports 8080

Maintenant, vous devez enregistrer ces règles afin qu’elles persistent même après une IPtable ou un redémarrage du système.

Pour les systèmes basés sur Redhat, exécutez ce qui suit.

Sudo iptables-save > /etc/sysconfig/iptables

Pour les systèmes Debian, exécutez la commande suivante.

Sudo sh -c "iptables-save > /etc/iptables.rules"

Maintenant, si vous accédez à Jenkins sur le port 80, la table IP transférera automatiquement les demandes à 8080.

Méthode 2: Exécution de Jenkins derrière le proxy inverse de Nginx

Étape 1: Installez Nginx

Sudo yum install nginx

Étape 2: Ouvrez le fichier de configuration Nginx.

Sudo vi /etc/nginx/nginx.conf

Étape 3: Recherchez le fragment de code suivant dans le fichier nginx.conf.

location / {
}

Étape 4: Ajoutez les lignes suivantes entre les accolades.

proxy_pass http://127.0.0.1:8080;
proxy_redirect off;
proxy_set_header Host $Host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;

Étape 5: Exécutez la commande SELinux pour le proxy inverse Nginx.

Sudo setsebool httpd_can_network_connect 1 -P

Étape 6: redémarrez le serveur Nginx.

Sudo systemctl restart nginx

Maintenant, si vous pourrez accéder à Jenkins sur le port 80.

Méthode 3: Jenkins derrière un équilibreur de charge

L'ajout d'un équilibreur de charge entraînera des coûts supplémentaires pour la configuration de Jenkins. Si vous êtes sur un nuage, vous pouvez opter pour un équilibreur de charge spécifique au nuage qui enverra tout le trafic de son port 80 au port principal Jenkins 8080.

0
Subhash

changer de/etc/default/jenkins ne fonctionne pas sur ma configuration ubunutu 16.-4 Jenkins 2.89.4 et la solution pour utiliser les routes iptables 80 à 8080 qui est le contraire du résultat requis pour exécuter jenkins sur 80

0
Barak

Dans Ubuntu 16.04, ce wiki explique comment le faire.

Sudo nano /etc/rc.local

Puis ajoutez ce qui suit juste avant la sortie 0

#Requests from outside
iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-ports 8080
#Requests from localhost
iptables -t nat -I OUTPUT -p tcp -d 127.0.0.1 --dport 80 -j REDIRECT --to-ports 8080

Maintenant, redémarrez ou exécutez Sudo /etc/rc.local pour activer le transfert de port

0
Katu