Comment configurer Jenkins pour qu'il tourne sur le port 80

je lance Ubuntu 11.10 et j'ai lancé sudo apt-get install jenkins pour installer Jenkins sur ce système.

j'ai vu quelques tutoriels sur la façon de configurer un mandataire inversé (Apache, Nginx, etc), mais c'est une VM dédiée à jenkins et j'aimerais la garder aussi allégée que possible tout en ayant jenkins tournant sur le port 80.

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

quand je commence jenkins via service jenkins start , ps révèle qu'il court pendant quelques secondes puis se termine.

est-ce parce que jenkins est l'utilisateur jenkins sur un port privilégié? Si oui, comment puis-je arranger cela? Toutes les autres idées de bienvenue.

Voici la config upstart: 

description "jenkins: Jenkins Continuous Integration Server"
author "James Page <james.page@ubuntu.com>"

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
40
demandé sur hafichuk 2012-02-17 18:54:17

9 réponses

Donner un essai à 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

modifier ensuite le script ci-dessus pour avoir (ajouter authbind avant la $JAVA_HOME/bin/java partie): 

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 nouveaux Jenkins installations (1.598) sur les nouveaux Ubuntu installations (14.04) edit /etc/init.d/jenkins et d'ajouter 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 commentaire ci-dessous)) si vous avez besoin D'IPv6 et que votre système est inférieur à Quantal, vous pouvez télécharger une version plus élevée au lieu d'utiliser apt-get pour installer authbind . Assurez-vous d'avoir installé libc6 et libc6-udeb . Voici authbind version 2.1.1 de Ubuntu:

puis exécuter: 

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
répondu JScoobyCed 2017-05-23 10:30:55

une autre solution consiste simplement à utiliser iptables pour réacheminer le trafic entrant de 80 à 8080. Les règles ressembleraient à: 

-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 iptables.fichier de règles: 

*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 iptable.fichier de règles est la règle peut persister après redémarrage. Assurez-vous juste d'intégrer toutes les autres règles iptable 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 sauvegardés dans /etc/iptables/rules.v4 en utilisant le paquet iptables-persistent . Ou la iptable.les règles peuvent être appelées en modifiant /etc/network/interfaces ou en se raccordant aux scripts if-up / if-down . Le Ubuntu Community wiki a une grande page expliquant ces méthodes.

comme c'est habituellement le cas avec le réseautage, il y a beaucoup de façons différentes d'accomplir le même résultat. Utilisez ce qui fonctionne le mieux pour vous!

41
répondu Chris Laskey 2013-01-15 22:19:57
  1. Allez à /etc/default dossier --> Ouvrir le fichier "jenkins"
  2. modifier la ligne HTTP_PORT = 8080 comme HTTP_PORT = 80
  3. lancer jenkins comme root en utilisant la commande: sudo / etc / init.d/jenkins démarrer
  4. ouvrir un navigateur et naviguer comme localhost: 80

que c'est

34
répondu Ripon Al Wasim 2017-06-19 07:53:23

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 aussi pour SSL mais vous pouvez omettre cela): 

<VirtualHost *:443>
ServerAdmin webmaster@example.com
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
répondu regulatethis 2012-04-24 17:07:20

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
répondu Ali SAID OMAR 2015-05-13 13:06:54

la firewalld moyen de rediriger le port 8080 à 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
répondu Greg 2014-11-24 23:25:02

aucune des réponses ne dit comment rediriger simplement 80 à 8080 avec iptables.

Heureusement, le commentaire de dskrvk le fait !

il y a aussi un Jenkins wiki documentant ce



J'ai juste dû 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

Btw, n'oubliez pas de l'inclure à votre serveur scripts d'initialisation une fois testé, ou vous perdrez la redirection après un redémarrage. testé sur Debian 8.2 (Jessie)

0
répondu Balmipour 2017-01-05 17:33:47

dans Ubuntu 16.04, ce wiki explique comment le faire.

sudo nano /etc/rc.local

puis ajouter 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

redémarrez maintenant ou lancez sudo /etc/rc.local pour activer le réacheminement de port

0
répondu Katu 2018-03-20 09:08:31

modification 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 whis le contraire du résultat requis de jenkins sur 80

0
répondu Barak 2018-05-13 17:19:42