ubuntu - Cómo configurar Jenkins para ejecutar en el puerto 80

continuous-integration hudson

Question

Estoy ejecutando Ubuntu 11.10 y he ejecutado sudo apt-get install jenkins para instalar Jenkins en este sistema.

He visto algunos tutoriales sobre cómo configurar un proxy inverso (Apache, Nginx, etc.), sin embargo, esta es una VM dedicada solo a jenkins y me gustaría mantenerla lo más ajustada posible mientras jenkins se ejecuta en el puerto 80.

Encontré la configuración upstart en /etc/init/jenkins.conf y modifiqué el puerto a 80 env HTTP_PORT=80

Cuando comienzo jenkins a través del service jenkins start , ps revela que se ejecuta durante unos segundos y luego finaliza.

¿Esto es porque Jenkins se está ejecutando como el usuario jenkins en un puerto privilegiado? Si es así, ¿cómo puedo arreglar esto? Cualquier otra idea bienvenida

Aquí está la configuración advenediza:

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

Answer 1

1. Ir a la carpeta / etc / default -> Abrir el archivo "jenkins"
2. Modifique la línea HTTP_PORT = 8080 como HTTP_PORT = 80
3. Inicie jenkins como root utilizando el comando: sudo /etc/init.d/jenkins start
4. Abra un navegador y navegue como localhost: 80

Eso es

Answer 2

Desde que utilicé el docker . Puede usarlo para ejecutar jenkins en el puerto 80, de aquí en adelante un fragmento de mi script:

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

Answer 3

En Ubuntu 16.04, este wiki explica cómo hacerlo.

sudo nano /etc/rc.local

A continuación, agregue lo siguiente justo antes de la salida 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

Ahora reinicie o ejecute sudo /etc/rc.local para habilitar el reenvío de puertos

Answer 4

Ninguna de las respuestas dice cómo simplemente redirigir 80 a 8080 con iptables.
Afortunadamente, ¡el comentario de dskrvk sí lo hace!

También hay un wiki de Jenkins que documenta esto

Solo tuve que copiar / pegar esas líneas en mi terminal para que funcionara la redirección:

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

Por cierto, no te olvides de incluirlo en los scripts de inicio de tu servidor una vez probados, o perderás la redirección después de reiniciar. Probado en Debian 8.2 (Jessie)

Answer 5

Otra solución es simplemente usar iptables para redirigir el tráfico entrante de 80 a 8080. Las reglas se verían así:

-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

Reformateado como un archivo 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

La ventaja de un archivo iptable.rules es que las reglas pueden persistir después del reinicio. ¡Solo asegúrate de integrar cualquier otra regla de iptable actual en el mismo archivo!

En Redhat / CentOS este archivo puede ir en /etc/sysconfig/iptables .

En los sistemas Debian / Ubuntu, se pueden guardar en /etc/iptables/rules.v4 utilizando el paquete iptables-persistent . O se puede invocar iptable.rules modificando /etc/network/interfaces o conectando scripts if-up / if-down . El wiki de la Comunidad Ubuntu tiene una gran página que explica estos métodos.

Como suele ser el caso con las redes, hay muchas formas diferentes de lograr el mismo resultado. ¡Usa lo que funcione mejor para ti!

Answer 6

Prueba a '' 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

A continuación, modifique la secuencia de comandos anterior para tener (agregar authbind antes de la parte $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

Para instalaciones más recientes de Jenkins (1.598) en instalaciones Ubuntu más recientes (14.04), edite /etc/init.d/jenkins y agregue authbind antes de $JAVA

$SU -l $JENKINS_USER --shell=/bin/bash -c "$DAEMON $DAEMON_ARGS -- authbind $JAVA $JAVA_ARGS -jar $JENKINS_WAR $JENKINS_ARGS" || return 2

Como lo mencionó Alan (ver comentario más abajo) si necesita IPv6 y su sistema es más bajo que Quantal, en lugar de usar apt-get para instalar authbind descargue una versión superior. Asegúrate de tener instalados libc6 y libc6-udeb . Aquí está la versión authbind 2.1.1 de Ubuntu:

• amd64
• i386

Luego ejecuta:

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

Answer 7

Sugeriría usar apache y mod_proxy. Esto es lo que hago, y mi configuración de vhost se ve así (también redirecciono para SSL, pero puedes omitir eso):

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

Answer 8

cambiar / etc / default / jenkins no funciona en mi configuración ubunutu 16.-4 Jenkins 2.89.4 y la solución para usar rutas iptables 80 a 8080 whis lo contrario del resultado requerido de ejecutar jenkins en 80

Answer 9

la forma de firewalld para reenviar el puerto 8080 a 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