Co je kontinuální integrace (CI)?

Kontinuální integrace je dalším logickým krokem poté, co budete mít systém pro správu verzí jako Git a vzdálený systém pro správu verzí jako GitLab nebo GitHub pro společné úsilí. Problém, kterému velké projekty čelí, je tento - Jak přicházejí nové požadavky na vyžádání, je třeba je otestovat a poté integrovat do hlavní větve a toto úsilí může snadno trvat kdekoli od několika hodin do několika týdnů v závislosti na velikosti projektu, umístění členů týmu atd.

Jako každý takový problém je logickým krokem automatizace celé řady testů. Děláme to tak, že nastavíme spouštěč tak, aby při každém sloučení novějších revizí do větve agent (například GitLab Runner) automaticky vytvořil prostředí a kód, spustil proti němu všechny testy jednotek a integrační testy. Pokud dojde k nějaké chybě, zobrazí varování a zprávu o selhání, jinak dostanete zelený signál, že vše funguje.

Samozřejmě, vezmeme-li to do logického extrému, můžete také automatizovat nasazení, nastavit automatické testování A / B a úplně odstranit lidský zásah z procesu. To se nazývá Continuous Delivery nebo Continuous Deployment v závislosti na úrovni automatizace. V tomto kurzu bychom se ale zaměřili pouze na kontinuální integraci.

Předpoklady

Zaměříme se na nastavení jednoduchého toku CI v kurzu pomocí instance GitLab přes HTTPS, kterou jsme popsali v předchozím příspěvku.

Dále předpokládáme, že jste v této instanci GitLab nastavili uživatelský účet a máte úložiště (klonováno na místním počítači) spravováno pod vaším uživatelským jménem. Právě toto úložiště použijeme k předvedení pracovního postupu CI. V tutoriálu bude jeho název můj projekt.

Seznam všech:

1. Instance GitLab
2. Prázdné úložiště s názvem my-project
3. Místní klon tohoto úložiště
4. Vaše místní instance Git nakonfigurovaná tak, aby do ní odesílala změny dálkový.

Vytvoření jednoduché aplikace

V tomto úložišti vytvořme jednoduchý uzel.aplikace js. Tato aplikace je jednoduchý Express.js server, který má být nasazen v kontejneru Docker. Server ve vašem prohlížeči zobrazí užitečné zatížení HTTP s nápisem „Hello World“.

V kořenovém adresáři místního úložiště vytvořte soubor aplikace.js a přidejte následující řádky:

'use strict';
const express = require ('express');
// Konstanty
const PORT = 8080;
const HOST = '0.0.0.0 ';
// Aplikace
const app = express ();
aplikace.get ('/', (req, res) =>
res.send ('Hello world \ n');
);
aplikace.poslouchat (PORT, HOST);
řídicí panel.log ('Spuštěno na http: // $ HOST: $ PORT');

Pak vytvořte další soubor balík.JSON a přidejte k tomu následující:

"name": "docker_web_app",
"version": "1.0.0 ",
"description": "Uzel.js na Dockeru “,
"author": "John Doe",
"main": "server.js ",
"skripty":
"start": "uzlový server.js "
,
"dependencies":
"express": "^ 4.16.1 "

Nakonec vytvořte Dockerfile a přidejte k němu následující obsah:

Z uzlu: 8
# Vytvořte adresář aplikace
WORKDIR / usr / src / aplikace
# Nainstalujte si závislosti aplikací
# K zajištění obou balíků se používá zástupný znak.json AND balíček-zámek.JSON jsou zkopírovány
KOPÍROVAT balíček *.JSON ./
SPUŠTĚNÍ instalace za minutu
# Pokud vytváříte svůj kód pro produkci
# RUN npm install --only = production
# Zdroj balíčku aplikace
KOPÍROVAT…
VYSTAVTE 8080
CMD ["uzel", "aplikace"]

Proces sestavení pro tuto aplikaci by zahrnoval vytvoření kontejneru uzlu a instalaci závislostí (například Express.modul js). Tento proces by měl proběhnout bez chyb. Pro zjednodušení nebudeme v tomto tutoriálu diskutovat o žádném testování.

GitLab Runner Pipeline

Nyní bychom do našeho úložiště přidali další soubor, který by byl volán .gitlab-ci.yml . Tento soubor obsahuje pokyny k sestavení našeho projektu. Nyní, kdykoli stiskneme potvrzení naší instance GitLab, GitLab vyvolá Runnera, aby sestavil a otestoval projekt.

Přiřadili jsme tomuto kanálu různé pracovní místa které mohou běžet všechny běžet nezávisle na sobě, čímž je proces sestavování flexibilnější. Pro výše uvedené repo je toto platné .gitlab-ci.yml vytvořte tento soubor v kořenovém adresáři svého úložiště:

image: node: latest
etapy:
- stavět
mezipaměti:
cesty:
- uzel_moduly /
install_dependencies:
fáze: stavět
skript:
- NPM instalace

Máme jen jednu fázi stavět a má právě NPM instalace jako scénář. Toto je příkaz, který byste museli ručně spustit pokaždé, když v projektu dojde ke změně. Běžec GitLab by to udělal za vás. Runner could be installed in a Kubernetes cluster, a VPS in the cloud or in your local workstation and if it's active, it will be waiting for instructions from the GitLab server to execute a build.

Instalovali bychom a nakonfigurovali Runner lokálně, abychom jej automatizovali.

Získání runner tokenu

Otevřete úložiště na GitLabu a navštivte jeho nastavení CD / CI. To je Nastavení → CD / CI uvnitř vašeho testovacího úložiště.

Ponechte nastavení Auto DevOps na výchozí a klikněte na ROZŠÍŘIT rozbalte nastavení General Pipeline a zobrazí se vám Runner Token. Zkopírujte jeho hodnotu a samozřejmě, pokud si vážíte svého projektu, uchovávejte jej v soukromí.

Pomocí tohoto tokenu se váš místní spustitelný soubor GitLab Runner bude moci bezpečně zaregistrovat u vaší instance GitLab.

Instalace GitLab Runner

GitLab-Runner je malý odlehčený program napsaný v Go, který spouští CI pracovní místa na místním počítači a odešle výsledky GitLabu, aby zvážil změny. Jedná se o jeden spustitelný binární soubor, který lze nainstalovat na jakýkoli hlavní operační systém. Postupujte podle pokynů pro váš konkrétní operační systém. Tyto instalace se divoce liší, takže seznam všech je nemožný.

Alternativně můžete použít Runner jako službu Docker, ale pojďme se držet tradiční instalace, protože příkazy jsou čitelnější a čitelnější pro čtenáře. Jakmile ji máte nainstalovanou na místní pracovní stanici, musíte provést příkaz:

$ gitlab-runner register

To vám položí několik otázek počínaje vaším koordinátorem GitLab-CI, který by byl vaší instancí GitLab:

$ gitlab-runner register
Zadejte adresu URL koordinátora gitlab-ci (např.G. https: // gitlab.com /):
https: // gitlab.příklad.com

Poté by požádal o váš běžecký token, který jsme získali v předchozí části:

Zadejte token gitlab-ci pro tohoto běžce:

Your_Secret_Token

Pak pro nějaký identifikační popis a můžete jednoduše přeskočit přidání libovolných značek stisknutím :

Zadejte popis gitlab-ci tohoto běžce:

[Název hostitele]: Ukázka nastavení CI pomocí nástroje Runner

Zadejte značky gitlab-ci pro tohoto běžce (oddělené čárkami):

Registrace běžce ... proběhla úspěšně

Nejdůležitější je, že vás požádá o exekutora (více o tom za okamžik), pro příklad si zvolíme Dockera.

Zadejte prosím exekutora: docker-ssh + machine, kubernetes, parallels, shell, ssh, virtualbox, docker + machine, docker, docker-ssh:

přístavní dělník

Poté je třeba zadat obrázek ukotvitelného pole Base, ve kterém by se sestavení uskutečnilo, naše ukázková aplikace používá uzel, takže určíme obrázek uzlu:

Zadejte výchozí obrázek Dockeru (např.G. rubín: 2.1):

uzel: nejnovější

Běžec se úspěšně zaregistroval. Neváhejte jej spustit, ale pokud již běží, měla by se konfigurace automaticky znovu načíst!

Nyní je něco, co zde potřebuje malé vysvětlení, přesně to, co přesně je exekutoři? Způsob, jakým pracovní toky CI fungují, spočívá v tom, že vytváření modulů, jejich testování atd. Jsou známy jako pracovní místa a exekutoři vykonávají tyto úlohy. Pokud jste si vybrali VirtualBox jako exekutora, pak by se běžec GitLab integroval s místně nainstalovaným VirtualBoxem a spustil úlohy CI ve virtuálním počítači, pokud vyberete kubernetes, pak by se to stalo ve vašem klastru Kubernetes, v cloudu, pokud vyberete ssh můžete delegovat úkoly CI na vzdálený server.

Náš ukázkový projekt je založen na Dockeru, takže má smysl používat Dockera jako našeho exekutora. Musíte mít Docker nainstalován místně pro tohle.

Díky více možnostem pro exekutory je Runner flexibilnější. Možná budete chtít stavět lokálně, protože soubory projektu jsou příliš velké, nebo budete chtít provádět na vzdáleném serveru s 20 jádry a polovinou terabajtu paměti RAM, protože proces sestavení je výpočetně náročný, zadání možnosti prováděcího nástroje vám poskytne tuto flexibilitu.

Nakonec byste ve svém shellu chtěli spustit službu Runner:

$ gitlab-runner start

Vidění .gitlab-ci.yml v akci

Nyní jsme provedli všechny tyto změny v našem místním repo vytvořili celou aplikaci.js, balíček.json, Dockerfile a .gitlab-ci.yml soubory. Pravděpodobně jste provedli změny v místním úložišti spuštěním:

$ git fáze název_souboru
$ git commit -m „Commit Message“

Pojďme posunout změny do našeho vzdáleného GitLabu.

$ git push -u původ

Poté můžete svůj projekt otevřít v GitLabu, přejděte na můj projekt → Potrubí a uvidíte značku označující „prošel“ vedle provedeného potvrzení. Následné závazky budou mít také značky.

To jsou základy CI používající GitLab a Runner. Doufám, že se vám příspěvek líbil a naučili jste se z něj něco nového.