So hosten Sie ein Docker-Image-Repository und erstellen Docker-Images mit einer selbstverwalteten GitLab-Instanz auf Ubuntu 20.04

Containerisierungstechnologie hat sich im Bereich der Softwareentwicklungstechnologie als die am weitesten akzeptierte Methode zur Paketierung und Bereitstellung von Anwendungen in Cloud-Umgebungen stark weiterentwickelt. Dies wurde durch die Notwendigkeit von Continuous Integration (CI) und Continuous Deployment (CD) erforderlich, die definierende Aspekte von DevOps sind. Softwareentwickler und -ingenieure nutzen Container, um den CI/CD-Aspekt der Softwarearchitektur zu realisieren. Ein Container ist im Wesentlichen eine vollständig paketierte, portable und eigenständige Computing-Plattform. Obwohl es im Web verschiedene Container-Plattformen gibt, ist Docker die am weitesten verbreitete.

Docker ist eine Open-Source-Container-Plattform, die die Entwicklung effizient und vorhersagbar macht. Docker bietet ein öffentliches Docker-Image-Repository an, das unter Docker Hub verfügbar ist. Es enthält viele Open-Source-Docker-Images für die gängigsten Implementierungen, die Sie herunterladen und verwenden können. Da es sich um ein öffentliches Repository handelt, steht es Ihnen auch frei, Ihre eigenen Docker-Images hinzuzufügen, um sie mit der Öffentlichkeit zu teilen. Wenn Sie jedoch über privaten/proprietären Code verfügen, müssen Sie möglicherweise für ein privates Image-Repository bezahlen oder Ihren eigenen Image-Repository-Dienst aufbauen. Hier kommt GitLab ins Spiel.

GitLab ist ein webbasiertes Git-Repository, das mehr als nur ein Versionskontrollwerkzeug ist. Es bietet DevOps-Tools für kontinuierliche Integration und Bereitstellung, Issue-Tracking, Docker-Image-Registries und mehr. Es bietet drei Optionen: GitLab Community Edition (CE), GitLab Enterprise Edition (EE) und GitLab SaaS. GitLab CE und GitLab EE sind selbstverwaltete Lösungen, mit denen Sie die GitLab-Instanz selbst herunterladen, installieren und verwalten können. GitLab SaaS wird von GitLab Inc. gehostet, und Sie müssen sich keine Gedanken über die Installation machen, um es zu nutzen.

In einem früheren Tutorial haben wir Ihnen gezeigt, wie Sie eine GitLab-Instanz auf einem CloudSigma-Server einrichten und Ihr eigenes Git-Repository hosten. Wir haben Ihnen auch gezeigt, wie Sie Continuous-Integration-Pipelines mit dem GitLab-Runner implementieren, um Ihre Tests automatisch zu erstellen und auszuführen, wann immer es einen neuen Commit gibt. Wenn Sie die genannten Tutorials noch nicht durchgearbeitet haben, holen Sie dies bitte nach, da sie die Bausteine für dieses Tutorial bilden.

In diesem Tutorial zeigen wir Ihnen, wie Sie ein einfaches Docker-Image erstellen und es auf einer selbstgehosteten GitLab-Instanz hosten (unabhängig davon, ob Sie die Community Edition oder die Enterprise Edition verwenden – der Ablauf der Schritte ist derselbe).

Voraussetzungen

Um jedem Schritt dieses Tutorials folgen zu können, stellen Sie bitte sicher, dass Sie über einen GitLab-CI-Runner und einen selbstgehosteten GitLab-Server verfügen, wie unten beschrieben.

1. Ein sicherer GitLab-Server

Wir werden diesen verwenden, um den Quellcode zu speichern, CI/CD-Aufgaben auszuführen und die Docker-Image-Registry zu hosten. Sie sollten über einen Server mit mindestens 2 CPU-Kernen und 4GB an RAM verfügen, wie von GitLab für die Installation einer selbstverwalteten GitLab-Instanz empfohlen. Sie benötigen außerdem einen registrierten Domainnamen, der auf den Server verweist, da wir diesen verwenden werden, um ein SSL-Zertifikat von Let’s Encrypt zu erhalten, um den Server zu sichern. Unten finden Sie einige Links, denen Sie folgen können, um eine selbstgehostete GitLab-Instanz einzurichten.

• Registrieren Sie einen Domainnamen bei einem beliebigen Domain-Registrar Ihrer Wahl und verweisen Sie ihn auf CloudSigma.
• Folgen Sie diesem Tutorial für die Ersteinrichtung des Ubuntu-Servers, einen Nicht-Root-Benutzer hinzufügen und die UFW-Firewall von Ubuntu aktivieren.
• Folgen Sie schließlich diesem Tutorial zur Installation und Konfiguration einer selbstgehosteten GitLab-Instanz.

2. Ein GitLab-CI-Runner

Ein GitLab-CI-Runner ist erforderlich, um automatisierte Jobs für Ihre Testfälle auszuführen. Das Tutorial über die Einrichtung von GitLab Continuous Integration Pipelines auf Ubuntu 20.04 gibt Ihnen einen Überblick über den GitLab-CI-Server und zeigt Ihnen, wie Sie Jobs auslösen. Folgen Sie den Schritten im Tutorial, um den GitLab-CI-Runner-Dienst einzurichten, falls Sie dies noch nicht getan haben. Das Tutorial enthält eine Node.js-Demo-App mit Testfällen – wir werden sie in diesem Tutorial verwenden.

Jetzt legen wir los!

Schritt 1: Konfigurieren eines privilegierten GitLab-CI-Runners

Im Tutorial zur Einrichtung eines GitLab-CI-Runners haben wir einen GitLab-Runner mit dem Befehl sudo gitlab-runner register-Befehl, der es uns ermöglichte, die erforderlichen Parameter interaktiv hinzuzufügen. Dies funktionierte zwar für unseren vorherigen Anwendungsfall, nämlich das Ausführen von Builds und Tests in isolierten Docker-Containern, ist aber für das Erstellen von Docker-Images möglicherweise nicht geeignet. Das Erstellen von Docker-Images erfordert, dass der Runner vollen Zugriff auf den Docker-Dienst hat. Sie können diese Konfiguration erreichen, indem Sie das offizielle docker-in-docker-Image verwenden, um die Jobs auszuführen. Eine solche Konfiguration beinhaltet, dem Runner einen privilegierten Ausführungsmodus zu gewähren.

Obwohl die Gewährung des privilegierten Ausführungsmodus für das Erstellen von Docker-Images erforderlich ist, bringt dies Sicherheitsrisiken mit sich. Das liegt daran, dass die Sicherheitsvorteile von Containern damit aufgehoben werden. Sie denken vielleicht, dass die anderen Docker-Runner sicher sind, aber sie weisen dieselben Probleme auf, wie in der offiziellen Docker-Dokumentation erklärt.

Wir werden einen weiteren Runner mit dem privilegierten Ausführungsmodus erstellen. Aufgrund der oben genannten Sicherheitsimplikationen wird dies ein projektspezifischer Runner sein. Er wird Jobs aus dem Node Pipeline-Projekt akzeptieren, das wir im Tutorial über wie man kontinuierliche CI-Pipelines mit GitLab einrichtet.

Als Erstes sollten Sie überprüfen, ob Shared Runners für das Projekt deaktiviert sind. Klicken Sie auf der Projektseite des Node Pipeline-Projekts auf Settings im Menü unten links und wählen Sie CI/CD im Untermenü:

Suchen Sie die Schaltfläche Expand im Bereich Runners und klicken Sie darauf, um Details zu den verfügbaren Runnern anzuzeigen:

Klicken Sie auf den Schalter Shared Runners deaktivieren für dieses Projekt. Wenn Sie im vorherigen Abschnitt einen projektspezifischen Runner hinzugefügt haben, deaktivieren Sie diesen ebenfalls. Wir werden einen privilegierten projektspezifischen Runner hinzufügen, um Jobs für dieses Projekt auszuführen. Dies stellt sicher, dass wir keine Build-Fehler erhalten, falls GitLab Jobs zufällig Runnern zuweist, die nicht mit einem privilegierten Ausführungsmodus registriert wurden. Im obigen Screenshot sehen Sie unter der Registerkarte Specific runners das Registrierungs token Ihres Projekts. Notieren Sie es sich, da Sie es unten verwenden werden.

Hinweis: Ein projektspezifischer Runner kann auch anderen Projekten aus dem Bereich Admin-Bereich > Runners zugewiesen werden. Wenn Sie einen Runner aus der Liste der Runner auswählen, gelangen Sie zur Konfigurationsseite des Runners. Scrollen Sie nach unten, um den Abschnitt Restrict projects for this runner:

Es ist an der Zeit, Ihr Terminal zu öffnen. Wenn Sie die Schritte im Tutorial wie man GitLab Continuous Integration Pipelines auf Ubuntu 20.04 einrichtet noch nicht durchgeführt haben, machen Sie eine Pause von diesem Tutorial und befolgen Sie diese Schritte, damit Sie einen Server mit dem GitLab CI-Runner-Dienst haben. Andernfalls stellen Sie eine SSH-Verbindung zum GitLab CI-Runner-Server mit Ihrem sudo user für die nächsten Schritte her.

Um den privilegierten projektspezifischen Runner einzurichten, geben Sie den folgenden Befehl in Ihrem Terminal ein und ersetzen Sie Ihren Domainnamen und das oben kopierte Registrierungstoken:

Diese Ausgabe zeigt eine erfolgreiche Registrierung:

Um zu überprüfen, ob Ihre GitLab-Instanz den Runner erkannt hat, gehen Sie zurück zum Browser und aktualisieren Sie die Seite Settings > CI/CD. Erweitern Sie den Bereich Runners und Sie sollten Ihren Runner unter Specific Runners:

Optional können Sie, wenn Sie zum Admin-Bereich gehen (indem Sie auf die Schaltfläche Menu in der oberen Leiste klicken und Admin auswählen), dort Runners in den Menüoptionen auswählen:

Sie sollten auf dieser Seite landen, die alle verfügbaren Runner anzeigt, die mit Ihrer GitLab-Instanz verbunden sind, sowohl Shared als auch projektspezifische Runner:

Bis zu diesem Punkt haben Sie erfolgreich einen Runner eingerichtet, der Docker-Images erstellen kann.

Schritt 2: Konfigurieren der Docker-Registry von GitLab

Einige entscheidende Workflows erfordern Unabhängigkeit von externen Diensten. Hier kommt GitLabs selbstverwaltete Docker Registry ins Spiel. Sie ist nicht nur sicher, sondern stellt auch sicher, dass Sie die Flexibilität haben, Ihre Jobs und Pipelines an Ihre Bedürfnisse anzupassen. Um die Docker Registry einzurichten, werden Sie die Konfigurationsdatei von GitLab ändern. Stellen Sie zunächst eine SSH-Verbindung zur GitLab-Instanz her und öffnen Sie dann die Datei mit dem folgenden Befehl:

Scrollen Sie nach unten, bis Sie die Container Registry Settings:

sehen. Heben Sie die Auskommentierung der Zeile mit der registry_external_url auf und setzen Sie sie auf den Domainnamen Ihrer GitLab-Instanz, wobei Sie am Ende den Port 8888 angeben:

Als Nächstes müssen wir angeben, wo die Registry die Let’s Encrypt-Zertifikate findet, indem wir die folgenden Zeilen hinzufügen. Denken Sie daran, diese mit Ihrem tatsächlichen Domainnamen der GitLab-Instanz anzupassen:

Sobald Sie fertig sind, speichern und schließen Sie die Datei. Geben Sie den folgenden Befehl in Ihrem Terminal ein, um GitLab neu zu konfigurieren:

Warten Sie anschließend einige Sekunden, bis die Ausführung des Befehls abgeschlossen ist. Bei Erfolg sollten Sie die folgende Ausgabe sehen:

Als Nächstes müssen wir sicherstellen, dass die Firewall (ufw) Datenverkehr zu dem von uns zugewiesenen Registry-Port über den folgenden Befehl zulässt:

Anschließend müssen Sie testen, ob die Docker Registry läuft, indem Sie sich von einem anderen Rechner, auf dem Docker installiert ist, mit dem Befehl docker login anmelden. Wenn Sie Docker in Ihrer lokalen Umgebung noch nicht eingerichtet haben, können Sie sich per SSH auf dem GitLab-CI-Runner-Server anmelden, da dort Docker bereits installiert ist. Führen Sie als Nächstes den folgenden Befehl aus, wobei Sie natürlich den Domainnamen Ihrer GitLab-Instanz angeben:

Ihre Ausgabe zeigt die Meldung Login Succeeded wie folgt an:

Dies bedeutet, dass die Registry erfolgreich konfiguriert wurde und funktioniert. Wenn Sie Images erstellen, werden diese lokal im Dateisystem des GitLab-Servers gespeichert. Für eine private Unternehmens-Registry ist das in Ordnung. Wenn Sie jedoch planen, Ihre Registry für die Öffentlichkeit freizugeben, benötigen Sie möglicherweise größeren Speicherplatz. Glücklicherweise bietet GitLab Optionen zur Anbindung an Storage Buckets. Mehr dazu können Sie in der offiziellen GitLab container registry docs lesen, um zu erfahren, wie Sie einen Storage Bucket für Ihre GitLab-Instanz konfigurieren können.

Step 3: Modify the gitlab-ci.yml file and Build a Docker Image

Um mit diesem Schritt fortzufahren, sollten Sie das Projekt Node Pipeline auf Ihrer GitLab-Instanz haben. Hier ist die Ansicht des Projekts auf GitLab:

Wir haben über die gitlab-ci.yml als die Datei gesprochen, die der GitLab-CI-Runner liest, wenn er ausgelöst wird, um zu wissen, wie Ihre Anwendung erstellt und automatisierte Tests durchgeführt werden sollen. Wir müssen diese Datei ändern, um Anweisungen zum Erstellen von Docker-Images hinzuzufügen. Sie können diese Datei direkt in der GitLab-Benutzeroberfläche bearbeiten. Sie können sie auch auf Ihren lokalen Rechner klonen, mit Ihrem bevorzugten Editor bearbeiten, dann einen Commit durchführen und per Git Push zurück an GitLab senden. Der Kürze halber werden wir die GitLab-Instanz verwenden.

Klicken Sie auf die Datei, um sie zu öffnen, und klicken Sie dann auf die Bearbeiten-Schaltfläche:

Dies öffnet die Datei zur Bearbeitung. Löschen Sie alles aus der Datei und fügen Sie den folgenden Code hinzu:

Während Sie das obige Code-Snippet hinzufügen, denken Sie daran, den hervorgehobenen Teil mit Ihren tatsächlichen Details zu aktualisieren. Wenn Sie fertig sind, speichern Sie die Änderungen, indem Sie auf die Schaltfläche Änderungen committen klicken. Wenn Sie außerhalb von GitLab gearbeitet haben, committen und pushen Sie Ihre Änderungen.

Lassen Sie uns verstehen, was der Code, den wir der Datei .gitlab-ci.yml hinzugefügt haben, tut. Die erste Zeile weist GitLab an, das offizielle Docker-in-Docker-Image zu verwenden und es an den Docker-in-Docker-Dienst (docker:dind) anzubinden. Wir definieren dann die Phasen für build, test und release. Die build-Phase erstellt das Image anhand der Anweisungen in der Dockerfile und lädt es dann in die Docker-Registry hoch, die wir in einem vorherigen Schritt eingerichtet haben.

Wenn die build-Phase erfolgreich ist, lädt die test-Phase das Image herunter, führt es als Container aus und führt den Befehl npm test aus, um automatisierte Tests darin durchzuführen. Wenn die test-Phase erfolgreich ist, übernimmt die release-Phase. In der Release-Phase wird das Image heruntergeladen und als node_pipeline:latest getaggt. Anschließend wird es wieder in die Registry gepusht.

Dies ist nur eine grundlegende Konfiguration für ein Demoprojekt. Für Ihre realen Projekte könnten Sie andere Phasen haben, zum Beispiel staging, production usw. Wenn Sie die Datei nach dem Bearbeiten speichern, wird eine Pipeline ausgelöst. Sie beginnt dann mit der Ausführung der Jobs. Kehren Sie zur Seite Node Pipeline zurück. Sie sollten sehen, dass der Job derzeit ausgeführt wird:

Klicken Sie auf das CI-Indikatorsymbol, um die verschiedenen Phasen des Jobs anzuzeigen:

Wie Sie auf dem Screenshot oben sehen können, waren alle Phasen gemäß den grünen Häkchen-Symbolen erfolgreich. Sie können auf jede Phase klicken, um die Jobausgabe anzuzeigen:

Klicken Sie im linken Menü auf Packages & Registries und wählen Sie Container Registry:

Dadurch wird eine Seite geöffnet, auf der die verfügbaren Docker-Images für das ausgewählte Projekt aufgelistet sind. Das von uns erstellte und veröffentlichte Image sollte in der Liste mit dem Tag zugewiesen:

Klicken Sie hier, um die verschiedenen Tags für das Image anzuzeigen:

Wenn Sie Docker in Ihrer lokalen Umgebung installiert haben, können Sie das Image herunterladen und testen, ob es wie erwartet läuft. Klicken Sie auf das Kopieren-Symbol neben dem Namen des Image-Tags. Dadurch wird der vollständige Image-Name in Ihre Zwischenablage kopiert, den Sie mit dem Befehl docker pull verwenden können:

Die obigen Befehle laden das Image herunter und führen es in einem Container aus:

Die App wird nun auf Port 8090. Wenn Sie Ihren Browser öffnen und zu your-IP-address:8090 navigieren, sollten Sie die angezeigte Seite sehen:

Wenn Sie eine solche Seite in Ihrem Browser sehen können, haben Sie erfolgreich ein Docker-Image erstellt und es auf einer privaten Docker-Registry freigegeben. Wenn Sie in Zukunft Änderungen am master-Branch vornehmen, werden die in der .gitlab-ci.yml-Datei definierten Phasen ausgeführt, und wenn sie erfolgreich sind, wird ein neues Docker-Image mit dem Tag latest neu erstellt und in die Registry gepusht.

Fazit

In diesem Projekt haben Sie gelernt, wie Sie einen privilegierten GitLab-Runner zu Ihrer selbstverwalteten GitLab-Instanz hinzufügen, um Docker-Images zu erstellen. Sie haben außerdem eine private Docker-Image-Registry konfiguriert, um Ihre Images zu hosten. Mit dem Node-Pipeline-Projekt konnten Sie jede Komponente des Setups testen und sicherstellen, dass sie wie erwartet verbunden sind und kommunizieren. Sobald Ihr Image in der Registry verfügbar war, konnten Sie es herunterladen und bestätigen, dass es in einem Container ausgeführt wird.

Dies ist ein einführendes Tutorial, das Ihnen die Grundlagen vermittelt, auf denen Sie aufbauen können. Bitte folgen Sie der offiziellen GitLab-Dokumentation, um mehr über GitLab zu erfahren. Dieser Link bietet Informationen über die GitLab Container Registry.

Weitere Ressourcen zur Nutzung von Docker finden Sie in den Tutorials auf unserem Blog:

• Daten zwischen Docker-Containern teilen
• Einrichten einer privaten Docker-Registry auf Ubuntu 18.04
• So teilen Sie Daten zwischen einem Docker-Container und einem Host
• Docker-Ressourcen bereinigen – Images, Container und Volumes

Viel Spaß beim Computing!