Hva er kontinuerlig integrasjon (CI)?

Kontinuerlig integrasjon er det neste logiske trinnet etter å ha et versjonskontrollsystem som Git og et eksternt versjonskontrollsystem som GitLab eller GitHub for samarbeid. Problemet som store prosjekter står overfor er dette - Etter hvert som nye pull-forespørsler kommer, må de testes og deretter integreres i mastergrenen, og denne innsatsen kan lett ta alt fra noen få timer til noen få uker, avhengig av prosjektets størrelse, plasseringen av teammedlemmer osv.

Som ethvert slikt problem, er det logiske trinnet å automatisere hele testmargen. Vi gjør det ved å sette opp en utløser slik at når nyere forpliktelser slås sammen i en gren, bygger en agent (for eksempel GitLab Runner) automatisk miljøet og koden, kjører alle enhetstester og integrasjonstester mot det. Hvis det oppstår feil, gir det en advarsel og en krasjrapport, ellers får du et grønt signal om at alt fungerer.

Selvfølgelig, tatt til det logiske ekstreme, kan du også automatisere distribusjonen, sette opp automatisert A / B-testing og fjerne menneskelig inngripen fra prosessen. Dette kalles kontinuerlig levering og / eller kontinuerlig distribusjon avhengig av automatiseringsnivået. Men vi vil bare fokusere på kontinuerlig integrasjon i denne opplæringen.

Forutsetninger

Vi skal fokusere på å sette opp en enkel CI-flyt i opplæringen ved hjelp av en GitLab-forekomst over HTTPS som vi dekket i et forrige innlegg.

I tillegg antar vi også at du har opprettet en brukerkonto i denne GitLab-forekomsten og har et depot (klonet på din lokale maskin) administrert under brukernavnet ditt. Det er dette depotet vi skal bruke for å demonstrere CI-arbeidsflyt. I opplæringen kommer navnet til å være mitt prosjekt.

For å liste opp alt:

1. GitLab-forekomst
2. Tomt depot, kalt my-project
3. Lokal klone av dette depotet
4. Din lokale Git-forekomst konfigurert til å presse endringene inn fjernkontroll.

Opprette en enkel app

I dette depotet, la oss lage en enkel node.js app. Denne appen er en enkel Express.js-server som er ment å distribueres i en Docker-container. Serveren gir en HTTP-nyttelast som sier "Hello World" i nettleseren din.

Opprett en fil i roten til det lokale depotet app.js og legg til følgende linjer:

'bruk streng';
const express = krever ('express');
// Konstanter
const PORT = 8080;
const HOST = '0.0.0.0 ';
// App
const app = express ();
app.get ('/', (req, res) =>
res.send ('Hei verden \ n');
);
app.lytte (PORT, HOST);
konsoll.logg ('Kjører på http: // $ HOST: $ PORT');

Opprett deretter en annen fil pakke.json og legg til følgende:

"name": "docker_web_app",
"versjon": "1.0.0 ",
"description": "Node.js på Docker ",
"author": "John Doe",
"main": "server.js ",
"skript":
"start": "node-server.js "
,
"avhengigheter":
"express": "^ 4.16.1"

Til slutt, opprett en Dockerfil og legg til følgende innhold i den:

FRA node: 8
# Opprett appkatalog
WORKDIR / usr / src / app
# Installer appavhengigheter
# Et jokertegn brukes for å sikre begge pakker.json OG pakkelås.json kopieres
KOPIER pakke *.json ./
KJØR npm installasjon
# Hvis du bygger koden din for produksjon
# KJØR npm install - bare = produksjon
# Pakke appkilde
KOPIERE…
EKSPONER 8080
CMD ["node", "app"]

Byggeprosessen for denne appen vil innebære å opprette en nodebeholder og installere avhengighetene (som Express.js-modul). Denne prosessen skal skje uten feil. For enkelhets skyld skal vi ikke diskutere noen tester i denne opplæringen.

GitLab Runner-rørledning

Nå vil vi legge til en annen fil i depotet vårt som vil bli kalt .gitlab-ci.yml . Denne filen inneholder instruksjonene for å bygge prosjektet vårt. Hver gang vi legger opp til GitLab-forekomsten, vil GitLab påkalle en Runner for å bygge og teste prosjektet.

Vi tildeler denne rørledningen forskjellige arbeidsplasser som kan kjøre alle kjøre uavhengig av hverandre, noe som gjør byggeprosessen mer fleksibel. For ovennevnte repo er dette en gyldig .gitlab-ci.yml opprett denne filen i roten til depotet ditt:

image: node: siste
stadier:
- bygge
hurtigbuffer:
stier:
- node_modules /
installasjonsavhengigheter:
scene: bygge
manus:
- npm installere

Vi har bare ett trinn bygge og det har bare npm installere som manus. Dette er en kommando du må kjøre manuelt hver gang en endring kommer til prosjektet ditt. GitLab-løperen ville gjort dette for deg. Runner kan installeres i en Kubernetes-klynge, en VPS i skyen eller i din lokale arbeidsstasjon, og hvis den er aktiv, vil den vente på instruksjoner fra GitLab-serveren for å utføre en build.

Vi installerer og konfigurerer en Runner lokalt for å automatisere den.

Få Runner Token

Åpne depotet ditt på GitLab, og besøk CD / CI-innstillingene. Det er det Innstillinger → CD / CI inne i testregisteret.

La innstillingen Auto DevOps være standard, og klikk på UTVIDE for å utvide innstillingene for generelle rørledninger, og du får vist et Runner-token. Kopier verdien og hold den selvfølgelig privat hvis du verdsetter prosjektet ditt.

Ved å bruke dette tokenet vil din lokale GitLab Runner-kjørbar kunne registrere seg sikkert med din GitLab-forekomst.

Installere GitLab Runner

GitLab-Runner er et lite lettvektsprogram skrevet i Go som kjører CI-relatert arbeidsplasser på din lokale maskin og sender resultatene til GitLab for at den skal vurdere endringene. Det er en enkelt kjørbar binær som kan installeres på alle større operativsystemer. Følg instruksjonene her for ditt spesifikke operativsystem. Disse installasjonene varierer veldig, så det er lite mulig å liste dem alle.

Alternativt kan du bruke Runner som en Docker-tjeneste, men la oss bare holde oss til tradisjonell installasjon, for kommandoene er enklere å lese og forstå for leseren. Når du har installert den på din lokale arbeidsstasjon, må du utføre kommandoen:

$ gitlab-runner register

Dette vil stille deg flere spørsmål som begynner med din GitLab-CI-koordinator som vil være din GitLab-forekomst:

$ gitlab-runner register
Vennligst skriv inn gitlab-ci koordinator URL (e.g. https: // gitlab.com /):
https: // gitlab.eksempel.com

Det vil da be om ditt Runner-token, som vi fikk i forrige avsnitt:

Vennligst skriv inn gitlab-ci-token for denne løperen:

Your_Secret_Token

Så for noen identifiserende beskrivelse, og du kan bare hoppe over å legge til tagger ved å trykke :

Vennligst skriv inn gitlab-ci beskrivelsen for denne løperen:

[Vertsnavn]: Demo for å sette opp CI ved hjelp av Runner

Vennligst skriv inn gitlab-ci-kodene for denne løperen (kommaseparert):

Registrering av løper ... lyktes

Viktigst, det vil be deg om en eksekutor (mer om dette på et øyeblikk), vi vil velge Docker av hensyn til vårt eksempel.

Vennligst skriv inn utføreren: docker-ssh + maskin, kubernetes, paralleller, shell, ssh, virtualbox, docker + maskin, docker, docker-ssh:

docker

Base docker-bildet der byggingen skal foregå, må da spesifiseres, vår prøve-app bruker node så vi vil spesifisere et nodebilde:

Angi standard Docker-bilde (f.eks.g. rubin: 2.1):

node: siste

Runner registrert. Start den gjerne, men hvis den allerede er i gang, skal konfigurasjonen automatisk lastes inn på nytt!

Noe som trenger litt forklaring her er hva som er utførere? Måten CI-arbeid flyter på er at bygging av moduler, testing av dem osv. Alle er kjent som arbeidsplasser og utførere utfører disse jobbene. Hvis du valgte VirtualBox som utfører, vil GitLab-løper integreres med den lokalt installerte VirtualBox og kjøre CI-jobbene i en virtuell maskin. Hvis du velger kubernetes, vil det skje i Kubernetes-klyngen din, i skyen, hvis du velger ssh kan du delegere CI-oppgavene til en ekstern server.

Eksempelprosjektet vårt er basert på Docker, så det er fornuftig å bruke Docker som vår eksekutor. Du må ha Docker installert lokalt for dette.

Å ha flere alternativer for utførere gjør Runner mer fleksibel. Det kan være lurt å bygge lokalt fordi prosjektfilene er for store, eller du vil kanskje utføre på en ekstern server med 20 kjerner og en halv terabyte RAM fordi byggeprosessen er beregningsintensiv. Å spesifisere et eksekveringsalternativ gir deg den fleksibiliteten.

Til slutt, i skallet ditt, vil du starte Runner-tjenesten:

$ gitlab-runner start

Ser .gitlab-ci.yml i aksjon

Nå har vi gjort alle disse endringene i vårt lokale repo opprettet hele appen.js, pakke.json, Dockerfile og .gitlab-ci.yml-filer. Antagelig begikk du endringene i det lokale depotet ditt ved å kjøre:

$ git scenen filnavn
$ git commit -m “Commit Message”

La oss presse endringene til vår eksterne GitLab.

$ git push -u opprinnelse

Deretter kan du åpne prosjektet i GitLab, gå til mitt prosjekt → Rørledning og du vil se dette en merkelapp som sier “bestått” ved siden av forpliktelsen du gjorde. Senere forpliktelser vil også ha koder.

Så det er det grunnleggende om CI ved bruk av GitLab og Runner. Håper du likte innlegget og lærte noe nytt av det.