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
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
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!
- Allez dans/etc/default folder -> Ouvrez le fichier "jenkins"
- Modifiez la ligne HTTP_PORT = 8080 sous la forme HTTP_PORT = 80
- Démarrez Jenkins en tant que root en utilisant la commande: Sudo /etc/init.d/jenkins start
- Ouvrez un navigateur et naviguez en tant qu’hôte local: 80
c'est tout
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>
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
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 .
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)
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
Vous pouvez y parvenir en utilisant les méthodes suivantes.
- Une règle de transfert de table IP.
- Utiliser un proxy inverse comme Nginx.
- 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.
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
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