Mi a folyamatos integráció (CI)?

A folyamatos integráció a következő logikus lépés, miután egy verziókezelő rendszer, például a Git, és egy távoli verzióvezérlő rendszer, például a GitLab vagy a GitHub lesz az együttműködési törekvésekhez. Ez a probléma, amellyel a nagy projektek szembesülnek - ez az új kérések érkezésekor tesztelni kell őket, majd integrálni kell őket a fő ágba, és ez az erőfeszítés a projekt méretétől függően könnyen eltarthat néhány órától néhány hétig, a csapattagok helye stb.

Mint minden ilyen probléma, a logikai lépés a tesztelés egészének automatizálása. Teszünk egy olyan trigger beállításával, amely lehetővé teszi, hogy amikor újabb elkötelezettségeket egyesítenek egy ágba, egy ügynök (például a GitLab Runner) automatikusan felépíti a környezetet és a kódot, futtatja az összes egységtesztet és az integrációs tesztet. Ha bármilyen hibát észlel, figyelmeztetést és összeomlási jelentést ad, különben zöld jelzést kap, amely szerint minden működik.

Természetesen logikai végletig véve automatizálhatja a telepítést, beállíthatja az automatikus A / B tesztelést, és teljes mértékben eltávolíthatja az emberi beavatkozást a folyamatból. Ezt az automatizálás szintjétől függően folyamatos kézbesítésnek és / vagy folyamatos telepítésnek nevezzük. De ebben a bemutatóban csak a folyamatos integrációra összpontosítanánk.

Előfeltételek

Arra fogunk összpontosítani, hogy egy egyszerű CI-folyamatot állítsunk be az oktatóanyagban egy GitLab-példány használatával HTTPS-en keresztül, amelyet egy előző bejegyzésünkben ismertettünk.

Feltételezzük továbbá, hogy beállított egy felhasználói fiókot ebben a GitLab példányban, és megtette egy adattár (a helyi gépen klónozva) a felhasználónév alatt kezelhető. Ezt az adattárat fogjuk használni a CI munkafolyamat bemutatására. Az oktatóanyagban annak neve lesz az én projektem.

Az összes felsorolásához:

1. GitLab példány
2. Üres adattár, úgynevezett my-project
3. A tároló helyi klónja
4. A helyi Git-példány úgy van beállítva, hogy a változásokat belenyomja távoli.

Egyszerű alkalmazás létrehozása

Ebben a lerakatban hozzunk létre egy egyszerű Node-ot.js kb. Ez az alkalmazás egy egyszerű Express.js szerver, amelyet egy Docker-tárolóban kell telepíteni. A szerver egy HTTP hasznos terhelést ad a „Hello World” felirattal a böngészőben.

Hozzon létre egy fájlt a helyi adattár gyökerében kb.js és adja hozzá a következő sorokat:

„szigorúan használja”;
const express = igényel ('express');
Konstansok
const PORT = 8080;
const HOST = '0.0.0.0 ';
// App
const app = express ();
kb.get ('/', (req, res) =>
res.send ('Hello világ \ n');
);
kb.hallgatni (PORT, HOST);
konzol.napló ('Futás: http: // $ HOST: $ PORT');

Ezután hozzon létre egy másik fájlt csomag.json és adja hozzá a következőket:

"name": "docker_web_app",
"verzió": "1.0.0 ",
"description": "Csomópont.js on Docker ",
"szerző": "John Doe",
"main": "szerver.js ",
"szkriptek":
"start": "csomópont szerver.js "
,
"függőségek":
"express": "^ 4.16.1 "

Végül hozzon létre egy Dockerfile és adja hozzá a következő tartalmat:

FROM csomópont: 8
# Alkalmazáskönyvtár létrehozása
WORKDIR / usr / src / kb
# Telepítse az alkalmazásfüggőségeket
# Helyettesítő karaktert használunk mindkét csomag biztosításához.json ÉS csomag-zár.json másolva vannak
MÁSOLÁS csomag *.json ./
RUN npm telepítés
# Ha gyártási kódot építesz
# RUN npm telepítés - csak = gyártás
# Csomag alkalmazásforrás
MÁSOLAT…
8080-as expozíció
CMD ["csomópont", "alkalmazás"]

Az alkalmazás felépítési folyamata csomópont-tároló létrehozását és a függőségek (például az Express.js modul). Ennek a folyamatnak hiba nélkül kell megtörténnie. Az egyszerűség kedvéért nem fogunk tárgyalni semmilyen tesztelésről ebben az oktatóanyagban.

GitLab Runner Pipeline

Most felvennénk egy másik fájlt a tárunkba, amelyet hívunk .gitlab-ci.yml . Ez a fájl tartalmazza az utasításokat a projekt felépítéséhez. Bármikor, amikor elkötelezzük magunkat a GitLab példány iránt, a GitLab egy Runnert hív fel a projekt felépítésére és tesztelésére.

Ezt a csővezetéket különféle módon rendeljük hozzá munkahelyek amelyek képesek egymástól függetlenül futni, rugalmasabbá téve az összeállítási folyamatot. A fenti repo esetében ez érvényes .gitlab-ci.yml hozza létre ezt a fájlt az adattár gyökerében:

kép: csomópont: legújabb
szakasz:
- épít
gyorsítótár:
utak:
- csomópont_modulok /
install_dependencies:
szakasz: épít
forgatókönyv:
- npm telepítés

Csak egy szakaszunk van épít és csak van npm telepítés mint forgatókönyv. Ez egy olyan parancs, amelyet manuálisan kell futtatnia minden alkalommal, amikor a projekten változás történik. A GitLab futó ezt megtenné helyetted. A Runner telepíthető egy Kubernetes-fürtbe, egy VPS-be a felhőben vagy a helyi munkaállomáson, és ha aktív, akkor a GitLab kiszolgálótól várja az utasításokat egy build futtatásához.

Helyileg telepítenénk és konfigurálnánk a Runnert az automatizálás érdekében.

A Runner Token megszerzése

Nyissa meg az adattárat a GitLab-on, és keresse fel annak CD / CI-beállításait. Ez az Beállítások → CD / CI a teszttárban.

Hagyja az Auto DevOps beállítást az alapértelmezettre, és kattintson a gombra KITERJED az általános csővezeték beállításainak kibővítéséhez, és megjelenik egy Runner token. Másolja át az értékét, és természetesen tartsa magán, ha értékeli a projektjét.

A token használatával a helyi GitLab Runner futtatható fájl biztonságosan regisztrálhat a GitLab példányban.

A GitLab Runner telepítése

GitLab-Runner egy kis, Go-ban írt, könnyű program, amely CI-t futtat munkahelyek és elküldi az eredményeket a GitLab-nak, hogy mérlegelje a változásokat. Ez egyetlen futtatható bináris fájl, amely bármely nagyobb operációs rendszerre telepíthető. Kövesse az adott operációs rendszerre vonatkozó utasításokat. Ezek a telepítések nagyon változatosak, ezért felsorolni nem lehet.

Alternatív megoldásként használhatja a Runnert Docker szolgáltatásként, de maradjunk csak a hagyományos telepítésnél, mert a parancsokat egyszerűbb elolvasni és megérteni az olvasó számára. Miután telepítette a helyi munkaállomásra, végre kell hajtania a parancsot:

$ gitlab-runner regisztráció

Ez több kérdést tesz fel neked, kezdve a GitLab-CI koordinátoroddal, amely a GitLab példányod lenne:

$ gitlab-runner regisztráció
Kérjük, írja be a gitlab-ci koordinátor URL-jét (pl.g. https: // gitlab.com /):
https: // gitlab.példa.com

Ezután kéri a Runner Tokent, amelyet az előző szakaszban szereztünk be:

Kérjük, adja meg ennek a futónak a gitlab-ci tokent:

Titkos_beszélt

Ezután néhány azonosító leírást talál, és egyszerűen kihagyhatja a címkék hozzáadását :

Kérjük, adja meg a futó gitlab-ci leírását:

[Hostname]: Demó a CI beállításához a Runner használatával

Kérjük, írja be a futó gitlab-ci címkéit (vesszővel elválasztva):

A futó regisztrálása ... sikerült

Ami a legfontosabb, hogy végrehajtót fog kérni tőled (erről egy pillanat alatt bővebben), a példánk kedvéért a Dockert választjuk.

Kérjük, adja meg a végrehajtót: docker-ssh + gép, kubernetes, párhuzamok, shell, ssh, virtualbox, docker + gép, docker, docker-ssh:

dokkmunkás

Ezután meg kell adni azt az alap dokkoló képet, amelyen belül a felépítés megtörténne, mintaalkalmazásunk csomópontot használ, így megadunk egy csomópont képet:

Kérjük, adja meg az alapértelmezett Docker képet (pl.g. rubin: 2.1):

csomópont: legújabb

A futó regisztrálása sikeres volt. Indítsa el nyugodtan, de ha már fut, akkor a konfigurációt automatikusan újra kell tölteni!

Most valami, amire itt egy kis magyarázatra van szükség, az az, hogy pontosan mi is az végrehajtók? A CI munkafolyamata az, hogy a modulok felépítését, tesztelését stb munkahelyek a végrehajtók pedig elvégzik ezeket a munkákat. Ha a VirtualBox-ot választotta végrehajtóként, akkor a GitLab runner integrálódna a helyileg telepített VirtualBox-szal, és a virtuális gépen futtatná a CI-feladatokat, ha kuberneteket választ, akkor ez a Kubernetes-fürtben, a felhőben történik, ha az ssh-t választja, akkor delegálja a CI feladatokat egy távoli kiszolgálóra.

Mintaprojektünk a Docker-re épül, ezért van értelme a Docker-t végrehajtóként használni. Meg kell A Docker telepítése helyben történt ezért.

Ha a végrehajtóknak több lehetősége van, a Runner rugalmasabbá válik. Érdemes lokálisan felépíteni, mert a projektfájlok túl nagyok, vagy távoli kiszolgálón kell végrehajtani 20 maggal és fél terabájt RAM-mal, mert a felépítési folyamat számításigényes, a végrehajtó opció megadása ezt a rugalmasságot biztosítja.

Végül a héjban szeretné elindítani a Runner szolgáltatást:

$ gitlab-runner rajt

Látás .gitlab-ci.yml akcióban

Most ezeket a változtatásokat elvégeztük a helyi repóban, amely létrehozta az összes alkalmazást.js, csomag.json, Dockerfile és .gitlab-ci.yml fájlokat. Feltehetőleg a következő módosítások végrehajtásával hajtotta végre a helyi adattárat:

$ git szakasz fájlneve
$ git elkötelezettség -m “Kötelező üzenet”

Nyomjuk meg a távoli GitLab változásait.

$ git push -u eredetű

Ezután megnyithatja a projektjét a GitLab-ban, és lépjen a következőre: saját projektem → Csővezeték és látni fogja ezt a címkét, amely azt írja, hogy „telt” a tett kötelezettségvállalás mellett. Az ezt követő elkötelezettségek szintén címkékkel rendelkeznek.

Tehát ezek a CI alapjai a GitLab és a Runner használatával. Remélem, tetszett a bejegyzés, és valami újat tanultál belőle.