it-swarm.com.de

So konfigurieren Sie Jenkins für die Ausführung an Port 80

Ich verwende Ubuntu 11.10 und habe Sudo apt-get install jenkins ausgeführt, um Jenkins auf diesem System zu installieren.

Ich habe einige Tutorials gesehen, wie man einen Reverse Proxy (Apache, Nginx, usw.) einrichtet. Dies ist jedoch ein VM, der nur für Jenkins gedacht ist Port 80.

Ich habe die Upstart-Konfiguration in /etc/init/jenkins.conf gefunden und den Port auf 80 env HTTP_PORT=80 geändert.

Wenn ich jenkins über service jenkins start starte, wird ps angezeigt, dass es einige Sekunden läuft und dann beendet wird.

Liegt das daran, dass jenkins als jenkins-Benutzer an einem privilegierten Port ausgeführt wird? Wenn ja, wie kann ich das beheben? Alle anderen Ideen sind willkommen.

Hier ist die Upstart-Konfiguration:

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

Versuchen Sie es mit ' 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

Dann modifizieren Sie das obige Skript (fügen Sie authbind vor dem $Java_HOME/bin/Java-Teil hinzu):

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

Für neuere Jenkins-Installationen (1.598) auf neueren Ubuntu-Installationen (14.04) bearbeiten Sie /etc/init.d/jenkins und fügen Sie authbind vor $Java hinzu.

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

Wie von Alan (siehe Kommentar unten) erwähnt, wenn Sie IPv6 benötigen und Ihr System niedriger als Quantal ist, können Sie anstelle von apt-get eine authbind-Version installieren. Stellen Sie sicher, dass Sie libc6 und libc6-udeb installiert haben. Hier ist authbind Version 2.1.1 von Ubuntu:

Dann führe aus:

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

Eine andere Lösung besteht darin, einfach iptables zu verwenden, um eingehenden Datenverkehr von 80 auf 8080 umzuleiten. Die Regeln würden folgendermaßen aussehen:

-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

Umformatiert als iptables.rules-Datei:

*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

Der Vorteil einer iptable.rules-Datei ist, dass die Regeln nach dem Neustart bestehen bleiben können. Stellen Sie sicher, dass Sie alle anderen aktuellen iptable-Regeln in dieselbe Datei integrieren!

Auf Redhat/CentOS kann diese Datei in /etc/sysconfig/iptables abgelegt werden.

Auf Debian/Ubuntu-Systemen können sie mithilfe des Pakets /etc/iptables/rules.v4 in iptables-persistent gespeichert werden. Die iptable.rules können auch durch Ändern von /etc/network/interfaces oder durch Einhängen in if-up/if-down-Skripts aufgerufen werden. Das Ubuntu Community-Wiki hat eine großartige Seite, die diese Methoden erklärt.

Wie beim Networking üblich, gibt es viele verschiedene Möglichkeiten, um dasselbe Ergebnis zu erzielen. Verwenden Sie, was für Sie am besten funktioniert!

42
Chris Laskey
  1. Gehe in den Ordner/etc/default -> Öffne die Datei "jenkins"
  2. Ändern Sie die Zeile HTTP_PORT = 8080 als HTTP_PORT = 80
  3. Starten Sie jenkins als root mit dem Befehl: Sudo /etc/init.d/jenkins start
  4. Öffnen Sie einen Browser und suchen Sie als localhost: 80

das ist es

32
Ripon Al Wasim

Ich würde vorschlagen, Apache und mod_proxy zu verwenden. Das ist was ich mache und meine vhost config sieht irgendwie so aus (ich leite auch für SSL um, aber Sie können das weglassen):

<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

Da habe ich docker verwendet. Sie können es verwenden, um Jenkins auf Port 80 auszuführen, im Folgenden ein Ausschnitt meines Skripts:

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

Ich hatte das gleiche Problem und fand mit iptables die beste Lösung dafür.

Standardmäßig wird Jenkins auf den Ports 8080 oder 8443 ausgeführt HTTP/HTTPS-Server werden auf den Ports 80 und 443 ausgeführt.

Dies sind jedoch die speziellen Ports, und der Prozess, der sie verwendet, muss im Besitz von root sein. 

Jenkins als root auszuführen ist jedoch nicht die beste Lösung (es sollte als eigener Benutzer ausgeführt werden). Jenkins kann daher auch mit einem Webserver wie Apache ausgeführt werden, und es sollten Anfragen an Jenkins gestellt werden

Die beste Lösung ist die Verwendung von iptables unter Linux zur Weiterleitung des Datenverkehrs.

1) Verwenden Sie diesen Befehl, um die aktuelle Konfiguration von iptables aufzulisten: 

$ 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) Wenn Sie die obigen Einträge nicht sehen, müssen Sie die folgenden Befehle ausführen:

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) Führen Sie den Befehl $ iptables -L -n erneut aus und vergewissern Sie sich, dass der erste Schritt o/p angezeigt wird.

4) Der letzte Schritt besteht darin, die folgenden Befehle auszuführen, um Port 80-Datenverkehr an 8080 und Port 443 an 8443 weiterzuleiten (falls Sie HTTPS verwenden).

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) Jetzt sollte Ihre URL auf Port 80 bleiben

Die Details finden Sie hier .

1
Pratik Patel

Keine der Antworten gibt an, wie man 80 mit iptables einfach auf 8080 umleitet.
Zum Glück ist der Kommentar von dskrvk richtig!

Es gibt auch ein Jenkins wiki dokumentiert dies


Ich musste nur diese Zeilen in mein Terminal kopieren/einfügen, damit die Umleitung funktioniert:

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

Vergessen Sie übrigens nicht, es in die Init-Skripte Ihres Servers aufzunehmen, wenn Sie es einmal getestet haben. Andernfalls geht die Umleitung nach einem Neustart verloren. Getestet unter Debian 8.2 (Jessie)

0
Balmipour

die Firewall-Art, Port 8080 an 80 weiterzuleiten:

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

Sie können dies mit den folgenden Methoden erreichen.

  1. Eine IP-Tabellenweiterleitungsregel. 
  2. Verwendung eines Reverse-Proxys wie Nginx.
  3. Jenkins hinter einem Load Balancer laufen lassen.

Methode 1: Ausführen von Jenkins unter Verwendung der IP-Tabellenweiterleitungsregel

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

Speichern Sie diese Regeln jetzt, damit sie auch nach einer IP-Tabelle oder einem Systemneustart erhalten bleiben.

Führen Sie für Redhat-basierte Systeme die folgenden aus.

Sudo iptables-save > /etc/sysconfig/iptables

Führen Sie für Debian-basierte Systeme den folgenden Befehl aus.

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

Wenn Sie jetzt auf Port 80 auf Jenkins zugreifen, leitet die IP-Tabelle die Anforderungen automatisch an 8080 weiter.

Methode 2: Ausführen von Jenkins hinter Nginx Reverse Proxy

Schritt 1: Installieren Sie Nginx

Sudo yum install nginx

Schritt 2: Öffnen Sie die Nginx-Konfigurationsdatei.

Sudo vi /etc/nginx/nginx.conf

Schritt 3: Suchen Sie das folgende Snippet in der Datei nginx.conf.

location / {
}

Schritt 4: Fügen Sie die folgenden Zeilen zwischen den geschweiften Klammern ein.

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;

Schritt 5: Führen Sie den SELinux-Befehl für den Nginx-Reverse-Proxy aus.

Sudo setsebool httpd_can_network_connect 1 -P

Schritt 6: Starten Sie den Nginx-Server neu.

Sudo systemctl restart nginx

Nun, wenn Sie über Port 80 auf Jenkins zugreifen können.

Methode 3: Jenkins hinter einem Load Balancer

Durch das Hinzufügen eines Lastausgleichs werden die Jenkins-Einstellungen mit zusätzlichen Kosten verbunden. Wenn Sie sich in einer Cloud befinden, können Sie sich für einen Cloud-spezifischen Load Balancer entscheiden, der den gesamten Port 80-Datenverkehr an den Backend-Jenkins 8080-Port sendet.

0
Subhash

das Ändern von/etc/default/jenkins funktioniert nicht in meinem Setup ubunutu 16.-4 Jenkins 2.89.4 und die Lösung für die Verwendung der iptable-Routen 80 bis 8080, die das Gegenteil des erforderlichen Ergebnisses beim Ausführen von Jenkins auf 80 darstellen

0
Barak

Führen Sie diese Codezeilen einzeln aus:

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

Wenn Ihr System auf Debian basiert, führen Sie Folgendes aus:

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

Wenn Ihr System RedHat-basiert ist:

Sudo iptables-save > /etc/sysconfig/iptables

Durch diesen Vorgang wird Ihr Standard-Jenkins-Port von 8080 auf 80 geändert.

0
Fatema H. Kazi

In Ubuntu 16.04 erklärt dieses Wiki wie es geht.

Sudo nano /etc/rc.local

Fügen Sie dann kurz vor dem Ausgang 0 Folgendes hinzu

#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

Starten Sie jetzt neu oder führen Sie Sudo /etc/rc.local aus, um die Portweiterleitung zu aktivieren

0
Katu