Buildbot auf CentOS 7 mit SSL und Nginx einrichten

Buildbot ist ein quelloffenes Automatisierungswerkzeug auf Basis von Python, das zur kontinuierlichen Integration eingesetzt wird. Es unterstützt den gesamten Prozess der Softwareentwicklung – von der Kompilierung über Tests bis zur Bereitstellung. Die Architektur basiert auf einem oder mehreren sogenannten Buildbot-Mastern sowie einer Anzahl von Workern. Der Buildmaster übernimmt dabei die zentrale Steuerung, verwaltet die Umgebung, weist Aufgaben zu und koordiniert die Worker. Sobald Änderungen im Quellcode erkannt werden, werden diese Aufgaben an die Worker übergeben. Nach Abschluss senden die Worker die Ergebnisse zurück an den Master, der wiederum Entwickler über verschiedene integrierte Benachrichtigungssysteme informiert. In dieser Anleitung zeigen wir die Installation von Buildbot Master und Worker auf CentOS 7 sowie die Absicherung über einen Nginx-Reverse-Proxy inklusive Authentifizierung.

Systemanforderungen

• Ein CentOS 7 Server mit mindestens 1 GB RAM
• Ein Benutzerkonto mit Sudo-Rechten
• Eine registrierte Domain, die auf die IP-Adresse des Servers zeigt

In diesem Leitfaden verwenden wir 192.168.1.1 als Beispiel-IP-Adresse und ci.example.com als Domainnamen. Ersetze diese Platzhalter mit den tatsächlichen Werten deines Systems.

Führe zuerst eine Systemaktualisierung gemäß der Anleitung How to Update CentOS 7 durch. Nach erfolgreichem Update kannst du mit der Installation von PostgreSQL fortfahren.

Python-Abhängigkeiten installieren

Installiere zuerst Pip, den Paketmanager für Python, sowie einige grundlegende Pakete, die für Buildbot erforderlich sind:

sudo yum -y install epel-release
sudo yum -y install python-pip gcc python-devel git
sudo pip install --upgrade pip

PostgreSQL installieren

Buildbot unterstützt verschiedene Datenbanksysteme wie MySQL, PostgreSQL und SQLite. In dieser Anleitung verwenden wir PostgreSQL als Backend-Datenbank für Buildbot.

PostgreSQL ist ein stabiles und leistungsstarkes objektrelationales Datenbanksystem. Da die Version im Standard-YUM-Repository von CentOS 7 veraltet ist, muss zunächst das offizielle PostgreSQL-Repository hinzugefügt werden:

sudo yum -y install https://download.postgresql.org/pub/repos/yum/10/redhat/rhel-7-x86_64/pgdg-centos10-10-1.noarch.rpm

Installiere anschließend den PostgreSQL-Datenbankserver:

sudo yum -y install postgresql10-server postgresql10-contrib postgresql10

Initialisiere die PostgreSQL-Datenbank:

sudo /usr/pgsql-10/bin/postgresql-10-setup initdb

Starte den PostgreSQL-Dienst und aktiviere ihn für den automatischen Start beim Booten:

sudo systemctl start postgresql-10
sudo systemctl enable postgresql-10

Setze ein neues Passwort für den Standardbenutzer postgres:

sudo passwd postgres

Wechsle zum Benutzer postgres:

sudo su - postgres

Erstelle einen neuen PostgreSQL-Benutzer für Buildbot:

createuser bb_user

Du kannst bei Bedarf auch einen anderen Benutzernamen wählen. Starte anschließend die PostgreSQL-Shell:

psql

Weise dem neu erstellten Benutzer ein Passwort zu:

ALTER USER bb_user WITH ENCRYPTED password 'DBPassword';

Ersetze DBPassword durch ein sicheres Passwort deiner Wahl.

Erstelle nun eine Datenbank für die spätere Buildbot-Installation:

CREATE DATABASE buildbot OWNER bb_user;

Verlasse die PostgreSQL-Shell:

\q

Wechsle zurück zum sudo-Benutzerkonto:

exit

Bearbeite die Datei pg_hba.conf, um die Authentifizierung auf MD5 umzustellen:

sudo nano /var/lib/pgsql/10/data/pg_hba.conf

Suche folgende Zeilen und ändere die Werte in der Spalte METHOD von peer und ident zu trust bzw. md5:

# TYPE  DATABASE        USER            ADDRESS                 METHOD
# "local" is for Unix domain socket connections only
local   all             all                                     peer
# IPv4 local connections:
host    all             all             127.0.0.1/32            ident
# IPv6 local connections:
host    all             all             ::1/128                 ident

PostgreSQL-Konfiguration aktualisieren

Nachdem du die Konfigurationsdatei pg_hba.conf angepasst hast, sollte sie wie folgt aussehen:

# TYPE  DATABASE        USER            ADDRESS                 METHOD
# "local" is for Unix domain socket connections only
local   all             all                                     trust
# IPv4 local connections:
host    all             all             127.0.0.1/32            md5
# IPv6 local connections:
host    all             all             ::1/128                 md5

Speichere die Änderungen und beende den Editor.

PostgreSQL-Adapter für Python installieren

Installiere psycopg2, den passenden Adapter für die Kommunikation zwischen Python und PostgreSQL:

sudo pip install psycopg2

Starte den PostgreSQL-Dienst neu, damit die vorgenommenen Änderungen übernommen werden:

sudo systemctl restart postgresql-10

Buildbot installieren

Installiere Buildbot zusammen mit der Weboberfläche und zusätzlichen Plugins über Pip:

sudo pip install 'buildbot[bundle]' pyopenssl service_identity

Dieser Befehl installiert Buildbot selbst sowie buildbot-www, buildbot-worker und mehrere Webansichten wie zum Beispiel buildbot-waterfall-view.

Überprüfe anschließend, ob die Installation erfolgreich war, indem du die Buildbot-Version abfragst:

buildbot --version

Die Ausgabe sollte wie folgt aussehen:

[user@centron~]$ buildbot --version
Buildbot version: 0.9.15.post1
Twisted version: 17.9.0

Firewall-Port für Buildbot-Weboberfläche freigeben

Damit Buildbot über das Web erreichbar ist, muss der Port 8010 in der Firewall geöffnet werden. Diesen Port nutzt Buildbot für seine Webschnittstelle:

sudo firewall-cmd --zone=public --add-port=8010/tcp --permanent
sudo firewall-cmd --reload

Buildbot Master einrichten

Erstelle zunächst einen neuen, nicht privilegierten Benutzer, der für den Betrieb der Buildbot-Dienste (Master und Worker) verantwortlich ist. Es ist nicht empfohlen, Buildbot als Root-Benutzer auszuführen:

sudo adduser buildbot
sudo passwd buildbot

Wechsle zum neu angelegten Benutzer buildbot:

sudo su - buildbot

Initialisiere den Buildbot-Master im Verzeichnis /home/buildbot/master. Dort werden Konfigurationsdateien, Logs und Statusdaten abgelegt:

buildbot create-master --db 'postgresql://bb_user:DBPassword@localhost/buildbot' ~/master

Ersetze die Datenbank-Zugangsdaten im Befehl durch deine echten Werte.

Hinweis: Wenn du SQLite anstelle von PostgreSQL nutzen möchtest, kannst du die Option --db einfach weglassen. Die SQLite-Datenbank wird dann automatisch im Master-Verzeichnis erstellt.

Dieser Befehl erzeugt das Verzeichnis ~/master, speichert dort die Buildmaster-Dateien und trägt alle Daten in die PostgreSQL-Datenbank ein. Die Ausgabe sollte in etwa so aussehen:

[buildbot@centron~]$ buildbot create-master --db 'postgresql://bb_user:DBPassword@localhost/buildbot' ~/master
mkdir /home/buildbot/master
creating /home/buildbot/master/master.cfg.sample
creating database (postgresql://bb_user:DBPassword@localhost/buildbot)
buildmaster configured in /home/buildbot/master

Kopiere die Beispielkonfiguration zur aktiven Konfigurationsdatei:

cp ~/master/master.cfg.sample ~/master/master.cfg

Bearbeite nun die Konfigurationsdatei entsprechend deinen Anforderungen:

nano ~/master/master.cfg

Suche nach den folgenden Konfigurationszeilen:

c['workers'] = [worker.Worker("example-worker", "pass")]
...
c['builders'].append(
    util.BuilderConfig(name="runtests", workernames=["example-worker"], factory=factory)
)
...
c['title'] = "Hello World CI"
c['titleURL'] = "https://buildbot.github.io/hello-world/"
...
c['buildbotURL'] = "http://localhost:8010/"
...
c['db'] = {
    'db_url' : "postgresql://bb_user:DBpassword@localhost/buildbot",
}

Diese Beispielkonfiguration enthält bereits einen vordefinierten Worker. Passe diese Einträge wie folgt an:

• Ersetze example-worker durch einen aussagekräftigen Namen für deinen lokalen Worker.
• Ändere pass in ein sicheres Passwort.
• Passe die Workernamen in der Liste der Builder entsprechend an.
• Trage einen passenden Namen und eine URL für dein eigenes Projekt ein.

Notiere dir den Workernamen und das Passwort, da du sie im weiteren Verlauf erneut benötigst.

Buildbot-URL anpassen und Konfiguration abschließen

Öffne die Konfigurationsdatei und ersetze im Parameter buildbotURL die Adresse localhost durch den tatsächlichen Domainnamen oder die öffentliche IP-Adresse deines Servers. Überprüfe zudem, ob die angegebenen Datenbank-Zugangsdaten mit deinen realen PostgreSQL-Zugangsdaten übereinstimmen.

Füge am Ende der Konfigurationsdatei die folgende Zeile ein, um die Übermittlung von Versions- und Plugin-Nutzungsdaten an die Buildbot-Entwickler zu deaktivieren:

c['buildbotNetUsageData'] = None

Wenn du die Nutzungsdaten freiwillig übermitteln möchtest, kannst du den Wert alternativ auf Full setzen.

Nach allen Anpassungen sollte deine Konfigurationsdatei in etwa so aussehen:

c['workers'] = [worker.Worker("localhost-worker", "Password123")]
...
c['builders'].append(
    util.BuilderConfig(name="runtests", workernames=["localhost-worker"], factory=factory)
)
...
c['title'] = "My Application CI"
c['titleURL'] = "https://example.com/my-app"
...
c['buildbotURL'] = "http://192.168.1.1:8010/"
...
c['db'] = {
    'db_url' : "postgresql://bb_user:DBpassword@localhost/buildbot",
}
...
c['buildbotNetUsageData'] = None

Speichere die Datei und verlasse den Editor.

Buildbot-Konfiguration überprüfen

Führe den folgenden Befehl aus, um die Buildbot-Konfiguration auf Fehler zu prüfen:

buildbot checkconfig ~/master

Wenn keine Fehler gefunden werden, erhältst du eine Ausgabe wie diese:

[buildbot@centron~]$ buildbot checkconfig ~/master
Config file is good!

Buildbot Master starten

Nachdem die Konfiguration erfolgreich geprüft wurde, kannst du den Buildbot Master mit folgendem Befehl starten:

buildbot start ~/master

Bei erfolgreichem Start wird eine ähnliche Ausgabe angezeigt:

[buildbot@centron~]$ buildbot start ~/master
Following twistd.log until startup finished..
The buildmaster appears to have (re)started correctly.

Wenn der Buildbot Master korrekt läuft, ist die Weboberfläche jetzt über folgende Adresse erreichbar:

http://192.168.1.1:8010

Die Benutzeroberfläche von Buildbot sollte nun im Browser angezeigt werden.

Buildbot Worker einrichten

Da die Konfiguration des Workers bereits in ~/master/master.cfg vorgenommen wurde, kannst du nun den Worker-Prozess erstellen:

buildbot-worker create-worker ~/worker localhost localhost-worker Password123

Stelle sicher, dass Benutzername und Passwort exakt mit den Angaben in der Datei ~/master/master.cfg übereinstimmen – andernfalls kann keine Verbindung zum Master hergestellt werden.

Nach erfolgreicher Ausführung des Befehls erscheint folgende Ausgabe:

[buildbot@centron~]$ buildbot-worker create-worker ~/worker localhost example-worker pass
mkdir /home/buildbot/worker
mkdir /home/buildbot/worker/info
Creating info/admin, you need to edit it appropriately.
Creating info/host, you need to edit it appropriately.
Not creating info/access_uri - add it if you wish
Please edit the files in /home/buildbot/worker/info appropriately.
worker configured in /home/buildbot/worker

Die Metadaten des Workers befinden sich im Verzeichnis /info. Aktualisiere dort die administrativen Informationen.

Bearbeite zunächst die Datei mit den Administratorangaben:

nano ~/worker/info/admin

Ersetze den Platzhalter durch deinen echten Namen und deine E-Mail-Adresse:

Your Name <mail@example.com>

Bearbeite anschließend die Datei mit den Systeminformationen:

nano ~/worker/info/host

Trage dort die tatsächlichen Informationen zum Hostsystem ein:

Localhost, CentOS 7

Diese Angaben dienen lediglich Informationszwecken und helfen bei der Identifikation des Systems. Optional kannst du auch Buildbot- und Twisted-Versionen hinzufügen.

Buildbot Worker starten

Starte den Worker-Dienst mit folgendem Befehl:

buildbot-worker start ~/worker

Bei erfolgreichem Start sollte die Ausgabe wie folgt aussehen:

[buildbot@centron~]$ buildbot-worker start ~/worker
Following twistd.log until startup finished..
The buildbot-worker appears to have (re)started correctly.

Registrierung des Workers prüfen

Um zu bestätigen, dass der Worker korrekt registriert wurde, öffne die Buildbot-Weboberfläche. Navigiere über das Menü auf der linken Seite zu Builds >> Workers. Dort sollte der Worker als aktiv gelistet sein und bereit für den Einsatz.

Testbuild ausführen

Um einen Probelauf durchzuführen, gehe in der Weboberfläche zu Builds >> Builders. Klicke auf den Eintrag runtests, um zur Builder-Seite zu gelangen. Klicke dann auf die Schaltfläche Force, um manuell einen Build zu starten.

Trage deinen Namen ein und bestätige mit Start Build. Der Testlauf dauert nur wenige Sekunden. Nach Abschluss erhältst du eine Erfolgsmeldung zusammen mit dem Ergebnis.

Buildbot als Systemd-Dienst einrichten

Auch wenn du den Buildbot Master und Worker manuell starten und stoppen kannst, empfiehlt es sich, beide Dienste als Systemd-Units zu konfigurieren. Dadurch werden sie automatisch beim Systemstart oder nach Abstürzen wieder gestartet.

Hinweis: Kehre mit exit oder su <benutzername> zum sudo-Benutzer zurück. Alle folgenden Befehle werden als sudo-User ausgeführt.

Laufende Buildbot-Dienste beenden

Stoppe zunächst die aktuell laufenden Master- und Worker-Dienste:

sudo su buildbot -c "buildbot stop /home/buildbot/master"
sudo su buildbot -c "buildbot-worker stop ~/worker"

Systemd-Dienstdatei für den Buildbot Master erstellen

Erstelle eine neue Unit-Datei für den Buildbot Master:

sudo nano /etc/systemd/system/buildbot.service

Füge den folgenden Inhalt ein:

[Unit]
Description=BuildBot master service
After=network.target

[Service]
Type=forking
User=buildbot
Group=buildbot
WorkingDirectory=/home/buildbot/master
ExecStart=/usr/bin/buildbot start
ExecStop=/usr/bin/buildbot stop
ExecReload=/usr/bin/buildbot restart

[Install]
WantedBy=multi-user.target

Starte den Master-Dienst und aktiviere ihn für den automatischen Systemstart:

sudo systemctl start buildbot
sudo systemctl enable buildbot

Systemd-Dienstdatei für den Buildbot Worker erstellen

Erstelle nun eine separate Dienstdatei für den Worker:

sudo nano /etc/systemd/system/buildbot-worker.service

Trage folgende Konfiguration ein:

[Unit]
Description=BuildBot worker service
After=network.target

[Service]
Type=forking
User=buildbot
Group=buildbot
WorkingDirectory=/home/buildbot/worker
ExecStart=/usr/bin/buildbot-worker start
ExecStop=/usr/bin/buildbot-worker stop
ExecReload=/usr/bin/buildbot-worker restart

[Install]
WantedBy=multi-user.target

Starte auch den Worker-Dienst und aktiviere den automatischen Start:

sudo systemctl start buildbot-worker
sudo systemctl enable buildbot-worker

Status der Buildbot-Dienste prüfen

Überprüfe abschließend, ob beide Dienste korrekt laufen:

sudo systemctl status buildbot buildbot-worker

Wenn alles korrekt läuft, sieht die Ausgabe ähnlich wie folgt aus:

[user@centron~]$ sudo systemctl status buildbot buildbot-worker
● buildbot.service - BuildBot master service
   ...
   Active: active (running) since Fri 2018-01-12 16:00:59 UTC; 1min 25s ago
   ...
   Jan 12 16:00:59 centron.guest systemd[1]: Started BuildBot master service.
● buildbot-worker.service - BuildBot worker service
   ...
   Active: active (running) since Fri 2018-01-12 16:02:00 UTC; 24s ago
   ...
   Jan 12 16:02:00 centron.guest systemd[1]: Started BuildBot worker service.

Authentifizierung in der Buildbot-Weboberfläche aktivieren

Standardmäßig ist die Buildbot-Weboberfläche ohne Authentifizierung zugänglich. Für öffentlich erreichbare Installationen wird dringend empfohlen, eine Zugangskontrolle zu aktivieren, sodass nur autorisierte Benutzer administrative Aktionen durchführen können.

Konfigurationsdatei des Buildbot Masters bearbeiten

Öffne die Konfigurationsdatei des Buildbot Masters zur Bearbeitung:

sudo su buildbot -c "nano /home/buildbot/master/master.cfg"

Füge am Ende der Datei folgenden Code ein, um die Benutzeranmeldung zu aktivieren:

c['www']['authz'] = util.Authz(
    allowRules = [
        util.AnyEndpointMatcher(role="admins")
    ],
    roleMatchers = [
        util.RolesFromUsername(roles=['admins'], usernames=['admin_user'])
    ]
)
c['www']['auth'] = util.UserPasswordAuth({'admin_user': 'AdminPassword'})

Ersetze admin_user durch einen Benutzernamen deiner Wahl und AdminPassword durch ein sicheres Kennwort.

Konfiguration prüfen

Überprüfe die Konfigurationsdatei auf eventuelle Syntaxfehler, bevor du die Änderungen übernimmst:

sudo su buildbot -c "buildbot checkconfig /home/buildbot/master"

Buildbot Master neu starten

Starte den Buildbot Master neu, damit die neuen Authentifizierungseinstellungen übernommen werden:

sudo systemctl restart buildbot

Authentifizierungsfunktion testen

Rufe die Weboberfläche von Buildbot im Browser auf. Anonyme Besucher sollten jetzt nur noch grundlegende Informationen über den Server sehen können. Um auf administrative Funktionen zuzugreifen, melde dich mit dem in der Datei master.cfg definierten Benutzernamen und Passwort an.

Nach der erfolgreichen Anmeldung stehen sämtliche Verwaltungsoptionen ausschließlich dem angemeldeten Admin-Benutzer zur Verfügung.

Buildbot mit Let's Encrypt SSL und Nginx absichern

Standardmäßig verwendet Buildbot eine ungesicherte HTTP-Verbindung auf Port 8010. Um die Übertragung zwischen Browser und Server abzusichern, empfiehlt es sich, die Buildbot-Weboberfläche mit HTTPS zu schützen. In diesem Abschnitt installieren und konfigurieren wir Nginx als Reverse Proxy mit einem kostenlosen SSL-Zertifikat von Let's Encrypt.

Nginx installieren und einrichten

Installiere den Nginx-Webserver:

sudo yum -y install nginx

Starte den Dienst und aktiviere den automatischen Start beim Bootvorgang:

sudo systemctl start nginx
sudo systemctl enable nginx

Certbot zur Zertifikatsverwaltung installieren

Installiere Certbot, den offiziellen Client für Let's Encrypt, zur Beantragung und Verwaltung von SSL-Zertifikaten:

sudo yum -y install certbot

Firewall-Regeln anpassen

Öffne die Ports 80 (HTTP) und 443 (HTTPS) für den Zugriff und entferne Port 8010, der nicht mehr benötigt wird:

sudo firewall-cmd --zone=public --add-service=http --permanent
sudo firewall-cmd --zone=public --add-service=https --permanent
sudo firewall-cmd --zone=public --remove-port=8010/tcp --permanent
sudo firewall-cmd --reload

Hinweis: Deine Domain muss bereits auf die IP-Adresse des Servers zeigen, bevor ein Zertifikat von Let's Encrypt beantragt werden kann. Falls nötig, passe die DNS-Einträge an und warte auf die vollständige Verbreitung.

Let's Encrypt SSL-Zertifikat generieren

Fordere ein SSL-Zertifikat für deine Domain an:

sudo certbot certonly --webroot -w /usr/share/nginx/html -d ci.example.com

Die Zertifikate werden in der Regel unter /etc/letsencrypt/live/ci.example.com/ gespeichert. Die Datei fullchain.pem enthält das Zertifikat, privkey.pem den privaten Schlüssel.

Automatische Verlängerung des SSL-Zertifikats einrichten

Öffne die Crontab-Konfiguration des Root-Benutzers:

sudo crontab -e

Füge folgenden Eintrag hinzu, damit Certbot täglich um 5:30 Uhr automatisch prüft und verlängert:

30 5 * * * /usr/bin/certbot renew --quiet

Nginx für HTTPS konfigurieren

Entferne die Direktive default_server aus der Standardkonfiguration von Nginx:

sudo sed -i 's/default_server//g' /etc/nginx/nginx.conf

Erstelle eine neue Konfigurationsdatei für die Buildbot-Weboberfläche:

sudo nano /etc/nginx/conf.d/buildbot.conf

Füge folgenden Inhalt in die Datei ein:

upstream buildbot {
    server 127.0.0.1:8010;
}

server {
    listen 80 default_server;
    server_name ci.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2 default_server;
    server_name ci.example.com;
    root html;
    index index.html index.htm;

    ssl on;
    ssl_certificate /etc/letsencrypt/live/ci.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/ci.example.com/privkey.pem;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1440m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4;
    ssl_prefer_server_ciphers on;
    add_header Strict-Transport-Security "max-age=31536000; includeSubdomains;";

    access_log /var/log/nginx/buildbot.access.log;

    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;
    proxy_set_header X-Forwarded-Server $host;
    proxy_set_header X-Forwarded-Host $host;

    location / {
        proxy_pass http://buildbot;
    }

    location /sse/ {
        proxy_buffering off;
        proxy_pass http://buildbot/sse/;
    }

    location /ws {
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_pass http://buildbot/ws;
        proxy_read_timeout 6000s;
    }
}

Nginx-Konfiguration testen und neu laden

Prüfe, ob die Konfiguration fehlerfrei ist:

sudo nginx -t

Wenn keine Fehler angezeigt werden, starte den Dienst neu:

sudo systemctl restart nginx

Buildbot-URL auf HTTPS umstellen

Öffne die Konfigurationsdatei des Buildbot Masters:

sudo su buildbot -c "nano /home/buildbot/master/master.cfg"

Suche nach folgender Zeile:

c['buildbotURL'] = "http://192.168.1.1:8010/"

Ersetze sie durch die gesicherte HTTPS-Adresse deiner Domain:

c['buildbotURL'] = "https://ci.example.com/"

Starte anschließend den Master-Dienst neu, damit die Änderung wirksam wird:

sudo systemctl restart buildbot

Buildbot-Weboberfläche aufrufen

Du kannst Buildbot nun über die verschlüsselte Adresse https://ci.example.com aufrufen. Melde dich mit deinen Admin-Zugangsdaten an, um deine Build-Prozesse zu verwalten.

Fazit

Mit dieser Anleitung hast du erfolgreich eine sichere Buildbot-Umgebung auf CentOS 7 eingerichtet. Du hast sowohl den Master als auch den Worker konfiguriert, PostgreSQL als Datenbank eingebunden und die Weboberfläche mit Nginx sowie einem SSL-Zertifikat von Let's Encrypt abgesichert. Zusätzlich hast du Benutzer-Authentifizierung aktiviert und Systemd-Dienste eingerichtet, damit alle Komponenten automatisch neu starten.

Mit dieser robusten und geschützten Umgebung bist du bereit, deine Software-Build- und Deployment-Prozesse effizient zu automatisieren. Du kannst die Konfiguration jederzeit erweitern, zusätzliche Worker einbinden und komplexe Workflows definieren, um dein CI/CD-System weiter zu optimieren.