Buildbot Master und Worker unter CentOS 7 mit Nginx Reverse Proxy installieren
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.
