TOC

So erstellen Sie Docker-Images und hosten ein Docker-Image-Repository mit GitLab

Einführung

Die Containerisierung wird schnell zur gängigsten Methode zum Packen und Bereitstellen von Anwendungen in Cloud-Umgebungen. Die Standardisierung, die es bietet, sowie die Ressourceneffizienz (im Vergleich zu vollständigen virtuellen Maschinen) und die Flexibilität machen es zu einem wichtigen Faktor für die moderne DevOps-Denkweise. Viele interessante cloud native Bereitstellungs-, Orchestrierungs- und Überwachungsstrategien werden möglich, wenn Ihre Anwendungen und Microservices vollständig containerisiert sind.

Docker -Container sind heutzutage mit Abstand der gebräuchlichste Containertyp. Obwohl öffentliche Docker-Image-Repositorys wie Docker Hub voll von Open-Source-Software-Images sind, die Sie "+ docker pull +" und heute verwenden können, müssen Sie für privaten Code entweder bezahlen ein Dienst zum Erstellen und Speichern Ihrer Bilder oder zum Ausführen Ihrer eigenen Software, um dies zu tun.

GitLab Community Edition ist eine selbst gehostete Software-Suite, die unter anderem Git-Repository-Hosting, Projektverfolgung, CI / CD-Dienste und eine Docker-Image-Registrierung bietet. In diesem Tutorial verwenden wir den Continuous Integration Service von GitLab, um Docker-Images aus einer Beispiel-Node.js-App zu erstellen. Diese Bilder werden dann getestet und in unsere private Docker-Registrierung hochgeladen.

Voraussetzungen

Bevor wir beginnen, müssen wir * einen sicheren GitLab-Server * und * einen GitLab-CI-Runner * einrichten, um fortlaufende Integrationsaufgaben auszuführen. In den folgenden Abschnitten finden Sie Links und weitere Details.

Ein mit SSL gesicherter GitLab-Server

Um unseren Quellcode zu speichern, CI / CD-Aufgaben auszuführen und die Docker-Registrierung zu hosten, muss eine GitLab-Instanz auf einem Ubuntu 16.04-Server installiert sein. GitLab empfiehlt derzeit * einen Server mit mindestens 2 CPU-Kernen und 4 GB RAM *. Außerdem sichern wir den Server mit SSL-Zertifikaten von Let’s Encrypt. Dazu benötigen Sie einen Domainnamen, der auf den Server verweist.

Sie können diese Voraussetzungen mit den folgenden Lernprogrammen erfüllen:

Ein GitLab CI Runner

How To Set Up Continuous Integration Pipelines with GitLab CI unter Ubuntu 16.04 gibt Ihnen einen Überblick über den CI-Dienst von GitLab und zeigt Ihnen, wie Sie einen CI-Runner zum Verarbeiten von Jobs einrichten. Wir werden auf der in diesem Tutorial erstellten Demo-App und Runner-Infrastruktur aufbauen.

Schritt 1 - Einrichten eines privilegierten GitLab CI-Läufers

Im vorausgesetzten Tutorial zur kontinuierlichen GitLab-Integration haben wir einen GitLab-Runner mit dem Befehl "+ sudo gitlab-runner register +" und seinem interaktiven Konfigurationsprozess eingerichtet. Dieser Runner kann Builds und Tests von Software in isolierten Docker-Containern ausführen.

Um Docker-Images erstellen zu können, benötigt unser Runner jedoch vollständigen Zugriff auf einen Docker-Dienst. Die empfohlene Methode zum Konfigurieren besteht darin, das offizielle Docker-in-Docker-Image von Docker zu verwenden, um die Jobs auszuführen. Hierfür muss dem Läufer ein spezieller "+ privilegierter +" Ausführungsmodus zugewiesen werden. Daher erstellen wir einen zweiten Läufer mit diesem aktivierten Modus.

Da die Verwendung eines privilegierten Läufers sicherheitsrelevante Auswirkungen hat, erstellen wir einen projektspezifischen Läufer, der nur Docker-Jobs in unserem + hello_hapi + - Projekt akzeptiert (GitLab-Administratoren können diesen Läufer zu einem späteren Zeitpunkt jederzeit manuell zu anderen Projekten hinzufügen ). Klicken Sie auf Ihrer + hello_hapi + - Projektseite unten im linken Menü auf * Einstellungen * und dann im Untermenü auf * CI / CD *:

Bild: https://assets.digitalocean.com/articles/gitlab-docker/settings-ci.png [GitLab-Projekteinstellungsmenü]

Klicken Sie nun auf die Schaltfläche * Erweitern * neben dem Abschnitt * Läufereinstellungen *:

image: https: //assets.digitalocean.com/articles/gitlab-docker/runner-expand.png [GitLab "Runners settings" expand button]

Es werden einige Informationen zum Einrichten eines * bestimmten Läufers * angezeigt, einschließlich eines Registrierungstokens. Beachten Sie dieses Token. Wenn wir damit einen neuen Läufer registrieren, wird der Läufer nur für dieses Projekt gesperrt.

Bild: https://assets.digitalocean.com/articles/gitlab-docker/runner-token.png [GitLab-Projektspezifische Läuferoptionen]

Klicken Sie auf dieser Seite auf die Schaltfläche "Gemeinsam genutzte Läufer deaktivieren". Wir möchten sicherstellen, dass unsere Docker-Jobs immer auf unserem privilegierten Runner ausgeführt werden. Wenn ein nicht privilegierter freigegebener Läufer verfügbar ist, wählt GitLab möglicherweise diesen aus, was zu Erstellungsfehlern führen würde.

Melden Sie sich bei dem Server an, auf dem sich Ihr aktueller CI-Runner befindet. Wenn Sie noch keine Maschine mit Läufern eingerichtet haben, führen Sie die folgenden Schritte aus: https://www.digitalocean.com/community/tutorials/how-to-set-up-continuous-integration-pipelines-with-gitlab -ci-on-ubuntu-16-04 # installieren-des-gitlab-ci-runner-dienstes [Installieren des GitLab CI Runner-Dienstes +] des vorausgesetzten Tutorials, bevor Sie fortfahren.

Führen Sie nun den folgenden Befehl aus, um den privilegierten projektspezifischen Runner einzurichten:

sudo gitlab-runner register -n \
 --url https:/// \
 --registration-token  \
 --executor docker \
 --description "" \
 --docker-image "docker:latest" \
 --docker-privileged
OutputRegistering runner... succeeded                     runner=61SR6BwV
Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!

Stellen Sie sicher, dass Sie Ihre eigenen Daten ersetzen. Wir stellen alle unsere Runner-Optionen in der Befehlszeile ein, anstatt die interaktiven Eingabeaufforderungen zu verwenden, da wir in den Eingabeaufforderungen nicht den Modus "+ - Docker-privilegiert +" angeben können.

Ihr Läufer ist jetzt eingerichtet, registriert und läuft. Zur Überprüfung wechseln Sie zurück zu Ihrem Browser. Klicken Sie auf das Schraubenschlüsselsymbol in der Hauptmenüleiste von GitLab und dann im linken Menü auf * Läufer *. Deine Läufer werden aufgelistet:

Bild: https://assets.digitalocean.com/articles/gitlab-docker/runner-list.png [GitLab-Läuferliste]

Nachdem wir nun einen Runner haben, der Docker-Images erstellen kann, richten wir eine private Docker-Registrierung ein, in die Images übertragen werden können.

Schritt 2 - Einrichten der Docker-Registrierung von GitLab

Durch das Einrichten einer eigenen Docker-Registrierung können Sie Bilder von Ihrem eigenen privaten Server übertragen und abrufen, wodurch die Sicherheit erhöht und die Abhängigkeiten Ihres Workflows von externen Diensten verringert werden.

GitLab wird mit wenigen Konfigurationsaktualisierungen eine private Docker-Registrierung einrichten. Zuerst richten wir die URL ein, unter der sich die Registrierung befinden wird. Anschließend konfigurieren wir die Registrierung (optional) so, dass ein S3-kompatibler Objektspeicherdienst zum Speichern der Daten verwendet wird.

SSH in Ihren GitLab-Server ein und öffnen Sie dann die GitLab-Konfigurationsdatei:

sudo nano /etc/gitlab/gitlab.rb

Scrollen Sie nach unten zum Abschnitt * Einstellungen für die Containerregistrierung *. Wir werden die Zeile "+ registry_external_url " auskommentieren und sie auf unseren GitLab-Hostnamen mit der Portnummer " 5555 +" setzen:

/etc/gitlab/gitlab.rb

registry_external_url 'https://:5555'

Fügen Sie als Nächstes die folgenden zwei Zeilen hinzu, um der Registrierung mitzuteilen, wo sich unsere Let’s Encrypt-Zertifikate befinden:

/etc/gitlab/gitlab.rb

registry_nginx['ssl_certificate'] = "/etc/letsencrypt/live//fullchain.pem"
registry_nginx['ssl_certificate_key'] = "/etc/letsencrypt/live//privkey.pem"

Speichern und schließen Sie die Datei und konfigurieren Sie GitLab neu:

sudo gitlab-ctl reconfigure
Output. . .
gitlab Reconfigured!

Aktualisieren Sie die Firewall, um Datenverkehr zum Registrierungsport zuzulassen:

sudo ufw allow 5555

Wechseln Sie nun zu einem anderen Computer, auf dem Docker installiert ist, und melden Sie sich bei der privaten Docker-Registrierung an. Wenn Sie Docker nicht auf Ihrem lokalen Entwicklungscomputer installiert haben, können Sie den für die Ausführung Ihrer GitLab CI-Jobs eingerichteten Server verwenden, da Docker bereits installiert ist:

docker login :5555

Sie werden aufgefordert, Ihren Benutzernamen und Ihr Passwort einzugeben. Verwenden Sie Ihre GitLab-Anmeldeinformationen, um sich anzumelden.

OutputLogin Succeeded

Erfolg! Die Registrierung ist eingerichtet und funktioniert. Derzeit werden Dateien im lokalen Dateisystem des GitLab-Servers gespeichert. Wenn Sie stattdessen einen Objektspeicherdienst verwenden möchten, fahren Sie mit diesem Abschnitt fort. Wenn nicht, fahren Sie mit Schritt 3 fort.

Um ein Objektspeicher-Backend für die Registrierung einzurichten, benötigen wir die folgenden Informationen zu unserem Objektspeicher-Service:

  • Zugangsschlüssel

  • Geheimer Schlüssel

  • * Region * (+ us-east-1 +) zum Beispiel bei Verwendung von Amazon S3 oder * Region Endpoint * bei Verwendung eines S3-kompatiblen Dienstes (+ https: // nyc.digitaloceanspaces.com +)

  • * Bucket Name *

Wenn Sie DigitalOcean Spaces verwenden, erfahren Sie unter https://www.digitalocean.com/community/tutorials/how-to-create-a-digitalocean-, wie Sie einen neuen Space einrichten und obige Informationen abrufen können. space-and-api-key [So erstellen Sie einen DigitalOcean Space- und API-Schlüssel].

Wenn Sie Ihre Objektspeicherinformationen haben, öffnen Sie die GitLab-Konfigurationsdatei:

sudo nano /etc/gitlab/gitlab.rb

Scrollen Sie erneut nach unten zum Abschnitt mit der Containerregistrierung. Suchen Sie nach dem + registry ['storage'] + -Block, kommentieren Sie ihn aus und aktualisieren Sie ihn auf den folgenden Stand, wobei Sie gegebenenfalls Ihre eigenen Informationen ersetzen müssen:

/etc/gitlab/gitlab.rb

registry['storage'] = {
 's3' => {
   'accesskey' => '',
   'secretkey' => '',
   'bucket' => '',
   'region' => '',
   'regionendpoint' => ''
 }
}

Wenn Sie Amazon S3 verwenden, benötigen Sie nur "+ region " und nicht " regionendpoint ". Wenn Sie einen S3-kompatiblen Dienst wie Spaces verwenden, benötigen Sie " regionendpoint ". In diesem Fall konfiguriert " region +" eigentlich nichts und der eingegebene Wert spielt keine Rolle, muss jedoch vorhanden und nicht leer sein.

Speichern und schließen Sie die Datei.

Konfigurieren Sie GitLab noch einmal neu:

sudo gitlab-ctl reconfigure

Melden Sie sich auf Ihrem anderen Docker-Computer erneut bei der Registrierung an, um sicherzustellen, dass alles in Ordnung ist:

docker login :5555

Sie sollten eine Meldung erhalten, die besagt, dass die Anmeldung erfolgreich war.

Nachdem wir unsere Docker-Registrierung eingerichtet haben, aktualisieren wir die CI-Konfiguration unserer Anwendung, um unsere App zu erstellen und zu testen, und übertragen Docker-Images in unsere private Registrierung.

Schritt 3 - Aktualisieren von + gitlab-ci.yaml + und Erstellen eines Docker-Images

Um unsere App in Docker zu erstellen, müssen wir die Datei + .gitlab-ci.yml + aktualisieren. Sie können diese Datei direkt in GitLab bearbeiten, indem Sie auf der Hauptprojektseite darauf klicken und dann auf die Schaltfläche * Bearbeiten * klicken. Alternativ können Sie das Repo auf Ihren lokalen Computer klonen, die Datei bearbeiten und dann mit "+ git push +" an GitLab zurückschicken. Das würde so aussehen:

git clone [email protected]:sammy/hello_hapi.git
cd hello_hapi
# edit the file w/ your favorite editor
git commit -am "updating ci configuration"
git push

Löschen Sie zuerst alles in der Datei und fügen Sie dann die folgende Konfiguration ein:

gitlab-ci.yml
image: docker:latest
services:
- docker:dind

stages:
- build
- test
- release

variables:
 TEST_IMAGE: //hello_hapi:$CI_COMMIT_REF_NAME
 RELEASE_IMAGE: //hello_hapi:latest

before_script:
 - docker login -u gitlab-ci-token -p $CI_JOB_TOKEN

build:
 stage: build
 script:
   - docker build --pull -t $TEST_IMAGE .
   - docker push $TEST_IMAGE

test:
 stage: test
 script:
   - docker pull $TEST_IMAGE
   - docker run $TEST_IMAGE npm test

release:
 stage: release
 script:
   - docker pull $TEST_IMAGE
   - docker tag $TEST_IMAGE $RELEASE_IMAGE
   - docker push $RELEASE_IMAGE
 only:
   - master

Stellen Sie sicher, dass Sie die hervorgehobenen URLs und Benutzernamen mit Ihren eigenen Informationen aktualisieren und dann mit der Schaltfläche "Änderungen übernehmen" in GitLab speichern. Wenn Sie die Datei außerhalb von GitLab aktualisieren, übernehmen Sie die Änderungen und drücken Sie "+ git push +" zurück zu GitLab.

Diese neue Konfigurationsdatei weist GitLab an, das neueste Docker-Image (+ image: docker: latest +) zu verwenden und es mit dem Docker-in-Docker-Dienst (docker: dind) zu verknüpfen. Anschließend werden die Stufen "+ Build", "+ Test" und "+ Release" definiert. In der Phase "+ build" wird das Docker-Image mit der im Repo enthaltenen "+ Docker-Datei" erstellt und dann in unsere Docker-Image-Registrierung hochgeladen. Wenn dies erfolgreich ist, lädt die Stufe "+ test" das soeben erstellte Image herunter und führt den darin enthaltenen Befehl "+ npm test" aus. Wenn die Testphase erfolgreich ist, ruft die Phase "+ release " das Bild ab, markiert es als " hello_hapi: latest +" und schiebt es zurück in die Registrierung.

Abhängig von Ihrem Workflow können Sie auch zusätzliche Testphasen oder sogar Bereitstellungsphasen hinzufügen, die die App in eine Staging- oder Produktionsumgebung verschieben.

Das Aktualisieren der Konfigurationsdatei sollte einen neuen Build ausgelöst haben. Kehren Sie in GitLab zum Projekt + hello_hapi + zurück und klicken Sie auf die CI-Statusanzeige für das Commit:

image: https://assets.digitalocean.com/articles/gitlab-docker/commit-widget.png [GitLab-Commit-Benachrichtigung mit Pipeline-Statussymbol]

Auf der daraufhin angezeigten Seite können Sie auf eine der Phasen klicken, um deren Fortschritt anzuzeigen:

Bild: https://assets.digitalocean.com/articles/gitlab-docker/commit-pipeline.png [GitLab-Pipeline-Detail]

Bild: https://assets.digitalocean.com/articles/gitlab-docker/stage-detail.png [Fortschritt der GitLab-Pipeline-Phase]

Letztendlich sollten alle Phasen anzeigen, dass sie erfolgreich waren, indem grüne Häkchensymbole angezeigt werden. Wir können die Docker-Images finden, die gerade erstellt wurden, indem wir im linken Menü auf den Eintrag * Registry * klicken:

image: https: //assets.digitalocean.com/articles/gitlab-docker/docker-list.png [GitLab-Containerregistrierungs-Image-Liste]

Wenn Sie auf das kleine "Dokument" -Symbol neben dem Bildnamen klicken, wird der entsprechende "+ Docker Pull …​ +" - Befehl in Ihre Zwischenablage kopiert. Sie können dann Ihr Bild ziehen und ausführen:

docker pull
docker run -it --rm -p 3000:3000
Output> [email protected] start /usr/src/app
> node app.js

Server running at: http://56fd5df5ddd3:3000

Das Image wurde aus der Registrierung entfernt und in einem Container gestartet. Wechseln Sie zu Ihrem Browser und stellen Sie eine Verbindung zur App auf Port 3000 her, um sie zu testen. In diesem Fall wird der Container auf unserem lokalen Computer ausgeführt, sodass wir über * localhost * unter der folgenden URL darauf zugreifen können:

http://localhost:3000/hello/test
OutputHello, test!

Erfolg! Sie können den Container mit + CTRL-C + stoppen. Von nun an erstellen und testen wir jedes Mal, wenn wir neuen Code in den Zweig "+ master " unseres Repositorys verschieben, automatisch ein neues " hello_hapi: latest +" - Image.

Fazit

In diesem Tutorial haben wir einen neuen GitLab-Runner zum Erstellen von Docker-Images eingerichtet, eine private Docker-Registrierung zum Speichern erstellt und eine Node.js-App aktualisiert, die in Docker-Containern erstellt und getestet werden soll.

Weitere Informationen zu den verschiedenen in diesem Setup verwendeten Komponenten finden Sie in der offiziellen Dokumentation von GitLab CE, https://docs.gitlab.com/ee /administration/container_registry.html[GitLab Container Registry] und Docker.

Related