Kaj je stalna integracija (CI)?

Neprekinjena integracija je naslednji logični korak, potem ko imamo sistem za nadzor različic, kot je Git, in sistem za oddaljeni nadzor različic, kot je GitLab ali GitHub, za skupna prizadevanja. Težava, s katero se srečujejo veliki projekti, je ta - ko prihajajo nove zahteve za vlečenje, jih je treba preizkusiti in nato integrirati v glavno vejo, kar lahko traja od nekaj ur do nekaj tednov, odvisno od velikosti projekta, lokacija članov ekipe itd.

Kot katera koli taka težava je tudi logičen korak avtomatizacija celotnega preizkušanja. To naredimo tako, da nastavimo sprožilec, tako da agent, ki združi novejše zaveze v vejo, samodejno zgradi okolje in kodo, naredi vse preskuse enot in integracijske teste, kadar je to potrebno. Če pride do kakršne koli napake, potem izda opozorilo in poročilo o zrušitvi, sicer dobite zeleni signal, ki pravi, da vse deluje.

Seveda, pripeljani do svoje logične skrajnosti, lahko nato tudi avtomatizirate uvajanje, nastavite samodejno A / B testiranje in v celoti odstranite človekovo posredovanje iz procesa. To se imenuje neprekinjena dostava in / ali neprekinjena uvajanje, odvisno od stopnje avtomatizacije. Toda v tej vadnici bi se osredotočili le na nenehno integracijo.

Pogoji

Osredotočili se bomo na nastavitev preprostega toka CI v vadnici z uporabo primerka GitLab prek HTTPS, ki smo ga obravnavali v prejšnjem prispevku.

Poleg tega predvidevamo tudi, da ste v tem primerku GitLab nastavili uporabniški račun in ste ga že skladišče (klonirano na vašem lokalnem računalniku), upravljano pod vašim uporabniškim imenom. Prav to skladišče bomo uporabili za predstavitev poteka dela CI. V vadnici bo njegovo ime moj projekt.

Če želite našteti vse:

1. Primer GitLab
2. Prazno repozitorij, imenovan moj projekt
3. Lokalni klon tega skladišča
4. Lokalni primerek Git je konfiguriran za potiskanje sprememb v na daljavo.

Ustvarjanje preproste aplikacije

V tem repozitoriju ustvarimo preprosto vozlišče.js app. Ta aplikacija je preprost Express.js, ki naj bi bil nameščen v vsebniku Docker. Strežnik v svojem brskalniku poda koristni tovor HTTP, ki pravi »Hello World«.

V korenu lokalnega repozitorija ustvarite datoteko app.js in dodajte naslednje vrstice:

'uporabljaj strogo';
const express = require ('express');
// Konstante
const PORT = 8080;
const HOST = '0.0.0.0 ';
// App
const app = express ();
app.get ('/', (req, res) =>
res.send ('Pozdravljeni, svet \ n');
);
app.poslušaj (PORT, HOST);
konzola.log ('Izvaja se na http: // $ HOST: $ PORT');

Nato ustvarite drugo datoteko paket.json in mu dodajte naslednje:

"name": "docker_web_app",
"version": "1.0.0 ",
"description": "Vozlišče.js na Dockerju ",
"avtor": "John Doe",
"main": "strežnik.js ",
"skripte":
"start": "strežnik vozlišča.js "
,
"odvisnosti":
"express": "^ 4.16.1 "

Nazadnje ustvarite Dockerfile in mu dodajte naslednjo vsebino:

OD vozlišča: 8
# Ustvari imenik aplikacij
WORKDIR / usr / src / app
# Namestite odvisnosti aplikacij
# Nadomestni znak se uporablja za zagotovitev obeh paketov.json IN zaklepanje paketov.json se kopirajo
COPY paket *.json ./
RUN npm namestitev
# Če gradite svojo kodo za proizvodnjo
# RUN npm install --only = production
# Vir aplikacije bundle
KOPIRATI…
IZPOSTAVITE 8080
CMD ["vozlišče", "aplikacija"]

Postopek gradnje te aplikacije bi vključeval ustvarjanje vsebnika vozlišča in namestitev odvisnosti (na primer Express.js modul). Ta postopek se mora zgoditi brez napak. Zaradi poenostavitve v tej vadnici ne bomo razpravljali o nobenem testiranju.

Cevovod GitLab Runner

Zdaj bi v naše skladišče dodali še eno datoteko, ki bi jo poklicali .gitlab-ci.yml . Ta datoteka bi vsebovala navodila za izdelavo našega projekta. Zdaj, vsakič, ko potisnemo zavezo v naš primerek GitLab, bi GitLab poklical Runner za izdelavo in preizkus projekta.

Ta cevovod dodeljujemo različnim službe ki se lahko izvajajo vse teče neodvisno drug od drugega, zaradi česar je postopek izdelave bolj prilagodljiv. Za zgornji repo je to veljavno .gitlab-ci.yml ustvari to datoteko v korenu vašega skladišča:

slika: vozlišče: najnovejše
obdobja:
- graditi
predpomnilnik:
poti:
- node_modules /
odvisno od namestitve:
stopnja: graditi
scenarij:
- npm namestite

Imamo samo eno stopnjo graditi in je pravkar npm namestite kot scenarij. To je ukaz, ki bi ga morali zagnati ročno vsakič, ko pride sprememba v vaš projekt. Tekač GitLab bi to naredil namesto vas. Runner bi lahko namestili v gručo Kubernetes, VPS v oblaku ali na vaši lokalni delovni postaji in če je aktiven, bo čakal na navodila s strežnika GitLab za izvedbo gradnje.

Runner bi namestili in konfigurirali lokalno za njegovo avtomatizacijo.

Pridobivanje žetona tekača

Odprite svoje skladišče v GitLabu in obiščite njegove nastavitve CD / CI. To je Nastavitve → CD / CI v testnem repozitoriju.

Nastavitev Auto DevOps pustite privzeto in kliknite na RAZŠIRI za razširitev splošnih nastavitev cevovoda in prikazal se vam bo žeton tekača. Kopirajte njegovo vrednost in jo seveda obdržite zasebno, če cenite svoj projekt.

Z uporabo tega žetona se bo vaš lokalni izvršni program GitLab Runner lahko varno registriral v vašem primerku GitLab.

Namestitev GitLab Runnerja

GitLab-Runner je majhen lahek program, napisan v programu Go, ki izvaja CI službe na vašem lokalnem računalniku in rezultate pošlje GitLabu, da preuči spremembe. To je en izvršljiv binarni program, ki ga lahko namestite v kateri koli večji operacijski sistem. Sledite navodilom za vaš operacijski sistem. Te naprave se zelo razlikujejo, zato je naštevanje vseh njih neizvedljivo.

Lahko pa tudi Runner uporabite kot Dockerjevo storitev, vendar se držimo tradicionalne namestitve, saj so ukazi enostavnejši za branje in razumevanje za bralca. Ko ga namestite na lokalno delovno postajo, morate izvesti ukaz:

$ gitlab-runner register

To vam bo postavilo več vprašanj, začenši z vašim koordinatorjem GitLab-CI, ki bi bil vaš primerek GitLab:

$ gitlab-runner register
Vnesite URL koordinatorja gitlab-ci (npr.g. https: // gitlab.com /):
https: // gitlab.primer.com

Nato vas bo vprašal za vaš Runner Token, ki smo ga dobili v prejšnjem poglavju:

Vnesite žeton gitlab-ci za tega tekača:

Vaš_Secret_Token

Nato za nekaj identifikacijskega opisa lahko preprosto preskočite dodajanje kakršnih koli oznak tako, da pritisnete :

Vnesite opis gitlab-ci za tega tekača:

[Ime gostitelja]: Predstavitev za nastavitev vmesnika vmesnika s programom Runner

Vnesite oznake gitlab-ci za tega tekača (ločene z vejico):

Registracija tekača… uspela

Najpomembneje pa je, da vas bo prosil za izvršitelja (več o tem v trenutku), za primer bomo izbrali Docker.

Vnesite izvršitelja: docker-ssh + stroj, kubernetes, vzporednice, lupina, ssh, virtualbox, docker + stroj, docker, docker-ssh:

docker

Nato je treba določiti sliko osnovnega priklopnika, znotraj katere bi potekala gradnja, naša vzorčna aplikacija uporablja vozlišče, zato bomo določili sliko vozlišča:

Vnesite privzeto sliko Dockerja (npr.g. rubin: 2.1):

vozlišče: najnovejše

Tekač se je uspešno registriral. Začnite ga, če pa se program že izvaja, ga je treba samodejno znova naložiti!

Zdaj je treba nekaj pojasniti, kaj točno so izvršitelji? Način dela CI poteka tako, da so gradnja modulov, njihovo testiranje itd službe in izvršitelji izvajajo ta dela. Če ste za izvršitelja izbrali VirtualBox, se bo zaganjalnik GitLab integriral z lokalno nameščenim VirtualBoxom in zagnal opravila CI v VM-ju, če izberete kubernetes, bi se to zgodilo v vaši gruči Kubernetes v oblaku, če izberete ssh, lahko prenese naloge CI na oddaljeni strežnik.

Naš vzorčni projekt temelji na Dockerju, zato je smiselno uporabiti Docker kot našega izvršitelja. Morate imeti Docker nameščen lokalno za to.

Če imate več možnosti za izvršitelje, je Runner bolj prilagodljiv. Morda boste želeli graditi lokalno, ker so projektne datoteke prevelike, ali pa jih boste morda želeli zagnati v oddaljenem strežniku z 20 jedri in pol terabajta RAM-a, ker je postopek gradnje računsko intenziven.

Nazadnje bi v svoji lupini želeli zagnati storitev Runner:

$ gitlab-runner start

Videti .gitlab-ci.yml v akciji

Zdaj smo naredili vse te spremembe v našem lokalnem skladišču, kjer smo ustvarili vso aplikacijo.js, paket.json, Dockerfile in .gitlab-ci.yml datoteke. Verjetno ste spremembe prevzeli v lokalnem repozitoriju tako, da ste zagnali:

$ git fazi ime_datoteke
$ git commit -m “Sporočilo sporočila”

Potisnimo spremembe v naš oddaljeni GitLab.

$ git push -u izvor

Nato lahko odprete svoj projekt v GitLab, pojdite na moj projekt → Cevovod in videli boste to oznako z napisom »mimo« poleg zaveze, ki ste jo naredili. Nadaljnje zaveze bodo imele tudi oznake.

To je torej osnova CI z uporabo GitLab in Runner. Upam, da ste uživali v objavi in ​​se iz nje naučili kaj novega.