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

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!

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

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>

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

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 .

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)

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

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.

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

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.

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