Wat is continue integratie (CI)?

Continue integratie is de volgende logische stap na het hebben van een versiebeheersysteem zoals Git en een versiebeheersysteem op afstand zoals GitLab of GitHub voor gezamenlijke inspanningen. Het probleem waarmee grote projecten worden geconfronteerd is dit - Als er nieuwe pull-verzoeken komen, moeten ze worden getest en vervolgens worden geïntegreerd in de master-branch en deze inspanning kan gemakkelijk een paar uur tot een paar weken duren, afhankelijk van de grootte van het project, de locatie van teamleden, enz.

Zoals bij elk dergelijk probleem, is de logische stap om de hele rompslomp van testen te automatiseren. We doen dit door een trigger zo in te stellen dat wanneer nieuwere commits in een branch worden samengevoegd, een agent (bijvoorbeeld GitLab Runner) automatisch de omgeving en de code bouwt, alle unit-tests en integratietests ertegen uitvoert. Als er een fout is opgetreden, geeft het een waarschuwing en een crashrapport, anders krijg je een groen signaal dat zegt dat alles werkt.

Natuurlijk, tot het logische uiterste doorgevoerd, kunt u vervolgens de implementatie automatiseren, geautomatiseerde A/B-testen instellen en menselijke tussenkomst volledig uit het proces verwijderen. Dat wordt continue levering en/of continue implementatie genoemd, afhankelijk van het automatiseringsniveau. Maar we zouden ons in deze tutorial alleen concentreren op continue integratie.

Vereisten

We gaan ons concentreren op het opzetten van een eenvoudige CI-stroom in de zelfstudie met behulp van een GitLab-instantie via HTTPS die we in een vorig bericht hebben behandeld.

Bovendien gaan we er ook van uit dat u een gebruikersaccount hebt ingesteld in deze GitLab-instantie en dat u: een opslagplaats (gekloond op uw lokale computer) beheerd onder uw gebruikersnaam. Het is deze repository die we zullen gebruiken om de CI-workflow te demonstreren. In de tutorial zal de naam zijn mijn project.

Om alles op een rijtje te zetten:

1. GitLab-instantie
2. Lege repository, genaamd mijn-project
3. Lokale kloon van deze repository
4. Uw lokale Git-instantie die is geconfigureerd om wijzigingen door te voeren naar afstandsbediening.

Een eenvoudige app maken

Laten we in deze repository een eenvoudige Node maken.js-app. Deze app is een eenvoudige Express.js-server die bedoeld is om te worden geïmplementeerd in een Docker-container. De server geeft een HTTP-payload met de tekst "Hello World" in uw browser.

Maak een bestand in de hoofdmap van uw lokale repository app.js en voeg de volgende regels toe:

'gebruik strikt';
const express = vereisen('express');
// Constanten
const POORT = 8080;
const HOST = '0.0.0.0';
// App
const-app = express();
app.get('/', (req, res) =>
onderzoek.send('Hallo wereld\n');
);
app.luister (POORT, HOST);
troosten.log('Lopend op http://$HOST:$PORT');

Maak dan een ander bestand pakket.json en voeg er het volgende aan toe:

"name": "docker_web_app",
"versie 1.0.0",
"description": "Knooppunt.js op Docker",
"auteur": "John Doe",
"main": "server.js",
"scripts":
"start": "node server.js"
,
"afhankelijkheden":
"express": "^4.16.1"

Maak tot slot een Dockerbestand en voeg er de volgende inhoud aan toe:

VAN knooppunt: 8
# Maak app-map
WORKDIR /usr/src/app
# Installeer app-afhankelijkheden
# Er wordt een jokerteken gebruikt om ervoor te zorgen dat beide pakketten.json EN pakketvergrendeling.json zijn gekopieerd
KOPIE pakket*.json ./
RUN npm install
# Als u uw code voor productie aan het maken bent
# RUN npm install --only=production
# Bundel app-bron
KOPIËREN…
BLOOT 8080
CMD [ "knooppunt", "app"]

Het bouwproces voor deze app omvat het maken van een knooppuntcontainer en het installeren van de afhankelijkheden (zoals Express.js-module). Dit proces zou zonder fouten moeten gebeuren. Omwille van de eenvoud gaan we in deze tutorial geen testen bespreken.

GitLab Runner-pijplijn

Nu zouden we een ander bestand aan onze repository toevoegen dat . zou heten .gitlab-ci.yml . Dit bestand zou de instructies bevatten om ons project te bouwen. Nu, elke keer dat we een commit pushen naar de onze GitLab-instantie, zou GitLab een Runner aanroepen om het project te bouwen en te testen.

We wijzen deze pijplijn verschillende toe: banen die allemaal onafhankelijk van elkaar kunnen draaien, waardoor het bouwproces flexibeler wordt. Voor de bovenstaande repo is dit een geldige .gitlab-ci.yml maak dit bestand in de root van je repository:

afbeelding: knooppunt: laatste
stadia:
- bouwen
cache:
paden:
- node_modules/
install_dependencies:
fase: bouwen
script:
- npm installeren

We hebben maar één podium bouwen en het heeft net npm installeren als een script. Dit is een opdracht die u handmatig moet uitvoeren telkens wanneer er een wijziging in uw project komt. De GitLab-runner zou dit voor je doen. Runner kan worden geïnstalleerd in een Kubernetes-cluster, een VPS in de cloud of op uw lokale werkstation en als het actief is, wacht het op instructies van de GitLab-server om een ​​build uit te voeren.

We zouden een Runner lokaal installeren en configureren om het te automatiseren.

Het Runner-token krijgen

Open uw repository op GitLab en bezoek de CD/CI-instellingen. dat is Instellingen → CD/CI in uw testrepository.

Laat de Auto DevOps-instelling op de standaardwaarde staan ​​en klik op UITBREIDEN om de algemene pijplijninstellingen uit te breiden en je krijgt een Runner-token te zien. Kopieer de waarde ervan en houd het natuurlijk privé als u uw project waardeert.

Met behulp van dit token kan uw lokale GitLab Runner-uitvoerbaar bestand zich veilig registreren bij uw GitLab-instantie.

GitLab Runner installeren

GitLab-runner is een klein lichtgewicht programma geschreven in Go dat CI-gerelateerd draait banen op uw lokale computer en stuurt de resultaten naar GitLab zodat het de wijzigingen kan overwegen. Het is een enkel uitvoerbaar binair bestand dat op elk belangrijk besturingssysteem kan worden geïnstalleerd. Volg de instructies hier, voor uw specifieke besturingssysteem. Deze installaties variëren enorm, dus het is onhaalbaar om ze allemaal op te sommen.

Als alternatief kunt u Runner gebruiken als een Docker-service, maar laten we het bij de traditionele installatie houden, want de opdrachten zijn eenvoudiger te lezen en te begrijpen voor de lezer. Zodra u het op uw lokale werkstation hebt geïnstalleerd, moet u de opdracht uitvoeren:

$ gitlab-runner register

Dit zal u verschillende vragen stellen, te beginnen met uw GitLab-CI-coördinator, wat uw GitLab-instantie zou zijn:

$ gitlab-runner register
Voer de gitlab-ci-coördinator-URL in (e.g. https://gitlab.com/):
https://gitlab.voorbeeld.com

Het zou dan om uw Runner Token vragen, die we in de vorige sectie hebben verkregen:

Voer het gitlab-ci-token voor deze hardloper in:

Uw_Geheim_Token

Dan voor een identificerende beschrijving en je kunt het toevoegen van tags gewoon overslaan door op . te drukken :

Voer de gitlab-ci-beschrijving voor deze hardloper in:

[Hostnaam]: Demo voor het instellen van CI met Runner

Voer de gitlab-ci-tags voor deze runner in (gescheiden door komma's):

Hardloper registreren… geslaagd

Het belangrijkste is dat het u om een ​​uitvoerder zal vragen (meer hierover in een oogwenk), we zullen Docker kiezen omwille van ons voorbeeld.

Voer de uitvoerder in: docker-ssh+machine, kubernetes, parallels, shell, ssh, virtualbox, docker+machine, docker, docker-ssh:

havenarbeider

De Base docker-afbeelding waarbinnen de build zou plaatsvinden, moet dan worden opgegeven, onze voorbeeld-app gebruikt een knooppunt, dus we zullen een knooppunt-afbeelding specificeren:

Voer de standaard Docker-afbeelding in (e.g. robijn:2.1):

knoop: laatste

Runner succesvol geregistreerd. Voel je vrij om het te starten, maar als het al actief is, zou de configuratie automatisch opnieuw moeten worden geladen!

Iets dat hier een beetje uitleg nodig heeft, is wat het precies is uitvoerders? De manier waarop CI werkt, is dat het bouwen van modules, het testen ervan, enz. allemaal bekend staan ​​als: banen en uitvoerders voeren die taken uit. Als je VirtualBox als uitvoerder kiest, dan zou GitLab Runner integreren met de lokaal geïnstalleerde VirtualBox en de CI-taken in een VM uitvoeren. delegeer de CI-taken naar een externe server.

Ons voorbeeldproject is gebaseerd op Docker, dus het is logisch om Docker als onze uitvoerder te gebruiken. Je moet hebben Docker lokaal geïnstalleerd voor deze.

Het hebben van meerdere opties voor uitvoerders maakt Runner flexibeler. Misschien wil je lokaal bouwen omdat de projectbestanden te groot zijn of je wilt misschien uitvoeren op een externe server met 20 cores en een halve terabyte RAM omdat het bouwproces rekenintensief is, het specificeren van een uitvoerder geeft je die flexibiliteit.

Ten slotte zou je in je shell de Runner-service willen starten:

$ gitlab-runner start

zien .gitlab-ci.yml in actie

Nu hebben we al deze wijzigingen aangebracht in onze lokale repo die de hele app heeft gemaakt.js, pakket.json, Dockerfile en .gitlab-ci.yml-bestanden. Vermoedelijk heb je de wijzigingen doorgevoerd in je lokale repository door het volgende uit te voeren:

$ git stage bestandsnaam
$ git commit -m "Bericht vastleggen"

Laten we de wijzigingen doorvoeren in ons externe GitLab.

$ git push -u oorsprong

U kunt uw project dan openen in GitLab, ga naar mijn-project → Pijplijn en je zult dit een tag zien met de tekst "geslaagd" naast de commit die je hebt gemaakt. Volgende commits zullen ook tags hebben.

Dus dat is de basis van CI met GitLab en Runner. Ik hoop dat je genoten hebt van de post en er iets nieuws van hebt geleerd.