Was ist Continuous Integration (CI)??

Continuous Integration ist der nächste logische Schritt nach einem Versionskontrollsystem wie Git und einem Remote-Versionskontrollsystem wie GitLab oder GitHub für kollaborative Bemühungen. Das Problem, mit dem große Projekte konfrontiert sind, ist folgendes - Wenn neue Pull-Requests kommen, müssen sie getestet und dann in den Master-Branch integriert werden, und dieser Aufwand kann je nach Größe des Projekts leicht zwischen einigen Stunden und einigen Wochen dauern. der Standort der Teammitglieder usw.

Wie bei jedem solchen Problem besteht der logische Schritt darin, das gesamte Testsystem zu automatisieren. Wir tun dies, indem wir einen Trigger so einrichten, dass immer dann, wenn neuere Commits in einen Branch zusammengeführt werden, ein Agent (z. B. GitLab Runner) automatisch die Umgebung und den Code erstellt und alle Komponententests und Integrationstests dafür ausführt. Wenn ein Fehler auftritt, wird eine Warnung und ein Absturzbericht ausgegeben, andernfalls erhalten Sie ein grünes Signal, das besagt, dass alles funktioniert.

Natürlich können Sie im logischen Extrem auch die Bereitstellung automatisieren, automatisierte A/B-Tests einrichten und menschliche Eingriffe vollständig aus dem Prozess entfernen. Dies wird je nach Automatisierungsgrad als Continuous Delivery und/oder Continuous Deployment bezeichnet. Aber wir würden uns in diesem Tutorial nur auf Continuous Integration konzentrieren.

Voraussetzungen

Wir konzentrieren uns im Tutorial auf die Einrichtung eines einfachen CI-Flows mit einer GitLab-Instanz über HTTPS, die wir in einem vorherigen Beitrag behandelt haben.

Außerdem gehen wir davon aus, dass Sie in dieser GitLab-Instanz ein Benutzerkonto eingerichtet haben und and ein Repository (auf Ihrem lokalen Computer geklont) unter Ihrem Benutzernamen verwaltet. Es ist dieses Repository, das wir verwenden werden, um den CI-Workflow zu demonstrieren. Im Tutorial wird sein Name sein Mein Projekt.

Um alles aufzulisten:

1. GitLab-Instanz
2. Leeres Repository namens my-project
3. Lokaler Klon dieses Repositorys
4. Ihre lokale Git-Instanz, die so konfiguriert ist, dass Änderungen in Fernbedienung.

Erstellen einer einfachen App

Erstellen wir in diesem Repository einen einfachen Node.js-App. Diese App ist ein einfacher Express.js-Server, der in einem Docker-Container bereitgestellt werden soll. Der Server gibt eine HTTP-Nutzlast mit der Aufschrift „Hello World“ in Ihrem Browser aus.

Erstellen Sie im Stammverzeichnis Ihres lokalen Repositorys eine Datei App.js und füge die folgenden Zeilen hinzu:

'streng verwenden';
const express = require('express');
// Konstanten
const PORT = 8080;
const HOST = '0.0.0.0';
// App
const app = express();
App.get('/', (req, res) =>
res.send('Hallo Welt\n');
);
App.hören (PORT, HOST);
Konsole.log('Läuft auf http://$HOST:$PORT');

Dann eine andere Datei erstellen Paket.json und füge folgendes hinzu:

"name": "docker_web_app",
"Version 1.0.0",
"description": "Knoten.js auf Docker",
"Autor": "John Doe",
"main": "server.js",
"Skripte":
"start": "Knotenserver.js"
,
"Abhängigkeiten":
"ausdrücken": "^4.16.1"

Erstellen Sie schließlich a Dockerfile und fügen Sie folgende Inhalte hinzu:

VON Knoten:8
# App-Verzeichnis erstellen
ARBEITSVERZEICHNIS /usr/src/app
# App-Abhängigkeiten installieren
# Ein Platzhalter wird verwendet, um sicherzustellen, dass beide Pakete.json UND Paketsperre.json werden kopiert
Paket KOPIEREN*.json ./
npm-Installation ausführen
# Wenn Sie Ihren Code für die Produktion erstellen
# RUN npm install --only=production
# Bundle-App-Quelle
KOPIEREN…
AUSSETZEN 8080
CMD [ "Knoten", "App"]

Der Build-Prozess für diese App umfasst das Erstellen eines Knotencontainers und das Installieren der Abhängigkeiten (wie Express (.js-Modul). Dieser Vorgang sollte fehlerfrei ablaufen. Der Einfachheit halber werden wir in diesem Tutorial keine Tests besprechen.

GitLab Runner-Pipeline

Jetzt würden wir unserem Repository eine weitere Datei hinzufügen, die aufgerufen würde: .gitlab-ci.yml . Diese Datei würde die Anweisungen zum Erstellen unseres Projekts enthalten. Jedes Mal, wenn wir einen Commit an unsere GitLab-Instanz senden, ruft GitLab einen Runner auf, um das Projekt zu erstellen und zu testen.

Wir weisen dieser Pipeline verschiedene zu Arbeitsplätze die alle unabhängig voneinander laufen können, was den Build-Prozess flexibler macht. Für das obige Repo ist dies ein gültiges .gitlab-ci.yml Erstellen Sie diese Datei im Stammverzeichnis Ihres Repositorys:

Bild: Knoten: neuestes
Stufen:
- bauen
Zwischenspeicher:
Pfade:
- node_modules/
install_dependencies:
Stufe: bauen
Skript:
- npm installieren

Wir haben nur eine Stufe bauen und es hat nur npm installieren als Skript. Dies ist ein Befehl, den Sie jedes Mal manuell ausführen müssen, wenn eine Änderung an Ihrem Projekt eintritt. Der GitLab-Runner würde dies für Sie tun. Runner kann in einem Kubernetes-Cluster, einem VPS in der Cloud oder auf Ihrer lokalen Workstation installiert werden und wartet, wenn er aktiv ist, auf Anweisungen vom GitLab-Server, um einen Build auszuführen.

Wir würden einen Runner lokal installieren und konfigurieren, um ihn zu automatisieren.

Das Runner-Token erhalten

Öffnen Sie Ihr Repository auf GitLab und besuchen Sie die CD/CI-Einstellungen. Das ist Einstellungen → CD/CI in Ihrem Test-Repository.

Belassen Sie die Auto DevOps-Einstellung auf den Standardeinstellungen und klicken Sie auf ERWEITERN um die allgemeinen Pipeline-Einstellungen zu erweitern und dir wird ein Runner-Token angezeigt. Kopieren Sie seinen Wert und halten Sie ihn natürlich privat, wenn Sie Ihr Projekt schätzen.

Mit diesem Token kann sich Ihre lokale ausführbare GitLab Runner-Datei sicher bei Ihrer GitLab-Instanz registrieren.

GitLab Runner installieren

GitLab-Runner ist ein kleines, leichtgewichtiges, in Go geschriebenes Programm, das CI-bezogen ausführt Arbeitsplätze auf Ihrem lokalen Computer und sendet die Ergebnisse an GitLab, damit es die Änderungen berücksichtigt. Es ist eine einzelne ausführbare Binärdatei, die auf jedem gängigen Betriebssystem installiert werden kann. Befolgen Sie die Anweisungen hier für Ihr spezielles Betriebssystem. Diese Installationen variieren stark, daher ist es unmöglich, sie alle aufzulisten.

Alternativ können Sie Runner als Docker-Dienst verwenden, aber bleiben wir einfach bei der traditionellen Installation, da die Befehle für den Leser einfacher zu lesen und zu verstehen sind. Sobald Sie es auf Ihrer lokalen Workstation installiert haben, müssen Sie den Befehl ausführen:

$ gitlab-runner registrieren

Dies stellt Ihnen mehrere Fragen, beginnend mit Ihrem GitLab-CI-Koordinator, der Ihre GitLab-Instanz wäre:

$ gitlab-runner registrieren
Bitte geben Sie die gitlab-ci-Koordinator-URL ein (e.G. https://gitlab.com/):
https://gitlab.Beispiel.com

Es würde dann nach Ihrem Runner Token fragen, den wir im vorherigen Abschnitt erhalten haben:

Bitte geben Sie das gitlab-ci-Token für diesen Runner ein:

Your_Secret_Token

Dann für eine identifizierende Beschreibung und Sie können das Hinzufügen von Tags einfach überspringen, indem Sie auf klicken :

Bitte geben Sie die gitlab-ci-Beschreibung für diesen Läufer ein:

[Hostname]: Demo zum Einrichten von CI mit Runner

Bitte geben Sie die gitlab-ci-Tags für diesen Läufer ein (durch Kommas getrennt):

Läufer registrieren… erfolgreich

Am wichtigsten ist, dass Sie nach einem Executor gefragt werden (dazu gleich mehr), wir wählen Docker für unser Beispiel.

Bitte geben Sie den Executor ein: docker-ssh+machine, kubernetes, parallels, shell, ssh, virtualbox, docker+machine, docker, docker-ssh:

Docker

Das Base-Docker-Image, in dem der Build stattfinden würde, muss dann angegeben werden. Unsere Beispiel-App verwendet Node, sodass wir ein Node-Image angeben:

Bitte geben Sie das Standard-Docker-Image ein (z.G. Rubin: 2.1):

Knoten: neueste

Läufer erfolgreich registriert. Fühlen Sie sich frei, es zu starten, aber wenn es bereits läuft, sollte die Konfiguration automatisch neu geladen werden!

Nun, etwas, das hier einer kleinen Erklärung bedarf, ist, was genau sind Vollstrecker? Der CI-Workflow ist so, dass das Erstellen von Modulen, ihr Testen usw. alle als . bekannt sind Arbeitsplätze und Ausführende führen diese Jobs aus. Wenn Sie VirtualBox als Executor wählen, würde sich der GitLab-Runner in die lokal installierte VirtualBox integrieren und die CI-Jobs in einer VM ausführen. Wenn Sie Kubernetes auswählen, geschieht dies in Ihrem Kubernetes-Cluster in der Cloud, wenn Sie ssh auswählen, können Sie delegieren Sie die CI-Aufgaben an einen Remote-Server.

Unser Beispielprojekt basiert auf Docker, daher ist es sinnvoll, Docker als unseren Executor zu verwenden. Du brauchst Docker lokal installiert dafür.

Mehrere Optionen für Executoren machen Runner flexibler. Möglicherweise möchten Sie lokal erstellen, weil die Projektdateien zu groß sind, oder Sie möchten möglicherweise auf einem Remote-Server mit 20 Kernen und einem halben Terabyte RAM ausführen, da der Erstellungsprozess rechenintensiv ist. Die Angabe einer Executor-Option bietet Ihnen diese Flexibilität.

Schließlich möchten Sie in Ihrer Shell den Runner-Dienst starten:

$ gitlab-runner start

Sehen .gitlab-ci.yml in Aktion

Jetzt haben wir all diese Änderungen in unserem lokalen Repository vorgenommen und die gesamte App erstellt.js, Paket.json, Dockerfile und .gitlab-ci.yml-Dateien. Vermutlich haben Sie die Änderungen in Ihr lokales Repository übertragen, indem Sie Folgendes ausgeführt haben:

$ git stage file_name
$ git commit -m „Commit-Nachricht“

Übertragen wir die Änderungen auf unser entferntes GitLab.

$ git push -u origin

Sie können Ihr Projekt dann in GitLab öffnen, gehen Sie zu mein-projekt → Pipeline und du siehst neben dem Commit, das du gemacht hast, ein Tag mit der Aufschrift "bestanden". Nachfolgende Commits haben auch Tags.

Das sind die Grundlagen von CI mit GitLab und Runner. Hoffe dir hat der Beitrag gefallen und du hast etwas Neues daraus gelernt.