Che cos'è l'integrazione continua (CI)?

L'integrazione continua è il prossimo passo logico dopo avere un sistema di controllo della versione come Git e un sistema di controllo della versione remoto come GitLab o GitHub per sforzi collaborativi. Il problema che devono affrontare i progetti di grandi dimensioni è questo: quando arrivano nuove richieste pull, devono essere testate e quindi integrate nel ramo principale e questo sforzo può facilmente richiedere da poche ore a poche settimane a seconda delle dimensioni del progetto, la posizione dei membri del team, ecc.

Come ogni problema del genere, il passaggio logico è automatizzare l'intera trafila dei test. Lo facciamo impostando un trigger in modo tale che ogni volta che i commit più recenti vengono uniti in un ramo un agente (GitLab Runner, ad esempio) crea automaticamente l'ambiente e il codice, esegue tutti gli unit test e i test di integrazione contro di esso. Se si verifica un errore, viene visualizzato un avviso e un rapporto di arresto anomalo, altrimenti viene visualizzato un segnale verde che dice che tutto funziona.

Ovviamente, portato al suo estremo logico, puoi anche automatizzare l'implementazione, impostare test A/B automatizzati e rimuovere completamente l'intervento umano dal processo. Questo è definito come Continuous Delivery e/o Continuous Deployment a seconda del livello di automazione. Ma ci concentreremo solo sull'integrazione continua in questo tutorial.

Prerequisiti

Ci concentreremo sulla configurazione di un semplice flusso CI nel tutorial utilizzando un'istanza GitLab su HTTPS di cui abbiamo parlato in un post precedente.

Inoltre, supponiamo anche che tu abbia impostato un account utente in questa istanza di GitLab e che tu abbia un deposito (clonato sul tuo computer locale) gestito con il tuo nome utente. È questo repository che utilizzeremo per dimostrare il flusso di lavoro CI. Nel tutorial, il suo nome sarà il mio progetto.

Per elencare tutto:

1. Istanza GitLab
2. Repository vuoto, chiamato mio-progetto
3. Clone locale di questo repository
4. La tua istanza Git locale configurata per trasferire le modifiche in a distanza.

Creazione di un'app semplice

In questo repository, creiamo un semplice Nodo.js app. Questa app è un semplice Express.js che è pensato per essere distribuito in un container Docker. Il server fornisce un payload HTTP che dice "Hello World" nel tuo browser.

Nella radice del tuo repository locale, crea un file app.js e aggiungi le seguenti righe:

'usa rigoroso';
const express = require('express');
// Costanti
const PORTA = 8080;
const HOST = '0.0.0.0';
// App
const app = express();
app.get('/', (req, res) =>
res.send('Ciao mondo\n');
);
app.ascolta(PORTA, HOST);
console.log('In esecuzione su http://$HOST:$PORT');

Quindi crea un altro file pacchetto.json e aggiungi quanto segue:

"nome": "docker_web_app",
"versione": "1.0.0",
"descrizione": "Nodo.js su Docker",
"autore": "John Doe",
"principale": "server.js",
"script":
"start": "server nodo.js"
,
"dipendenze":
"espresso": "^4.16.1"

Infine, crea un Dockerfile e aggiungi i seguenti contenuti:

DA nodo:8
# Crea la directory dell'app
WORKDIR /usr/src/app
# Installa le dipendenze dell'app
# Viene utilizzato un carattere jolly per garantire entrambi i pacchetti.json AND pacchetto-blocco.json sono copiati
COPIA pacchetto*.json ./
ESEGUI installazione npm
# Se stai costruendo il tuo codice per la produzione
# ESEGUI npm install --only=produzione
# Sorgente app bundle
COPIA…
ESPORRE 8080
CMD [ "nodo", "app"]

Il processo di compilazione per questa app implicherebbe la creazione di un contenitore di nodi e l'installazione delle dipendenze (come Express.js modulo). Questo processo dovrebbe avvenire senza errori. Per semplicità, non discuteremo di alcun test in questo tutorial.

GitLab Runner Pipeline

Ora aggiungeremmo un altro file al nostro repository che verrebbe chiamato .gitlab-ci.yml . Questo file conterrebbe le istruzioni per costruire il nostro progetto. Ora, ogni volta che inseriamo un commit sulla nostra istanza GitLab, GitLab invocherà un Runner per compilare e testare il progetto.

Assegniamo questa pipeline in vari modi lavori che possono essere eseguiti tutti indipendentemente l'uno dall'altro, rendendo il processo di compilazione più flessibile. Per il repository di cui sopra, questo è un valido .gitlab-ci.yml crea questo file nella radice del tuo repository:

immagine: nodo: più recente
fasi:
- costruire
cache:
percorsi:
- node_modules/
install_dipendenze:
fase: build
sceneggiatura:
- installazione npm

Abbiamo solo una fase costruire e ha appena installazione npm come un copione. Questo è un comando che dovresti eseguire manualmente ogni volta che viene apportata una modifica al tuo progetto. Il runner GitLab lo farebbe per te. Runner può essere installato in un cluster Kubernetes, un VPS nel cloud o nella tua workstation locale e se è attivo, aspetterà istruzioni dal server GitLab per eseguire una build.

Installeremmo e configureremo un Runner localmente per automatizzarlo.

Ottenere il gettone corridore

Apri il tuo repository su GitLab e visita le sue impostazioni CD/CI. Quello è Impostazioni → CD/CI all'interno del tuo repository di test.

Lascia l'impostazione Auto DevOps sui valori predefiniti e fai clic su ESPANDERE per espandere le impostazioni generali della pipeline e ti verrà mostrato un token corridore. Copia il suo valore e, naturalmente, mantienilo privato se apprezzi il tuo progetto.

Usando questo token, il tuo eseguibile GitLab Runner locale sarà in grado di registrarsi in modo sicuro con la tua istanza GitLab.

Installazione di GitLab Runner

GitLab-Runner è un piccolo programma leggero scritto in Go che esegue CI correlati lavori sul tuo computer locale e invia i risultati a GitLab affinché consideri le modifiche. È un singolo binario eseguibile che può essere installato su qualsiasi sistema operativo principale. Segui le istruzioni qui, per il tuo particolare sistema operativo. Queste installazioni variano notevolmente, quindi elencarle tutte è impossibile.

In alternativa puoi usare Runner come servizio Docker, ma atteniamoci all'installazione tradizionale, perché i comandi sono più semplici da leggere e capire per il lettore. Una volta installato sulla workstation locale, è necessario eseguire il comando:

$ gitlab-runner registrati

Questo ti farà diverse domande a partire dal tuo coordinatore GitLab-CI che sarebbe la tua istanza GitLab:

$ gitlab-runner registrati
Inserisci l'URL del coordinatore gitlab-ci (e.g. https://gitlab.com/):
https://gitlab.esempio.come

Quindi chiederà il tuo Runner Token, che abbiamo ottenuto nella sezione precedente:

Inserisci il token gitlab-ci per questo corridore:

Your_Secret_Token

Quindi per una descrizione identificativa e puoi semplicemente saltare l'aggiunta di tag premendo :

Inserisci la descrizione gitlab-ci per questo corridore:

[Nome host]: demo per la configurazione della CI utilizzando Runner

Inserisci i tag gitlab-ci per questo corridore (separati da virgole):

Registrazione corridore... riuscita

Soprattutto, ti chiederà un esecutore (più su questo tra un momento), sceglieremo Docker per il nostro esempio.

Inserisci l'executor: docker-ssh+machine, kubernetes, parallels, shell, ssh, virtualbox, docker+machine, docker, docker-ssh:

docker

L'immagine docker di base all'interno della quale dovrebbe avvenire la build deve quindi essere specificata, la nostra app di esempio utilizza node, quindi specificheremo un'immagine del nodo:

Inserisci l'immagine Docker predefinita (e.g. rubino: 2.1):

nodo: più recente

Corridore registrato con successo. Sentiti libero di avviarlo, ma se è già in esecuzione la configurazione dovrebbe essere ricaricata automaticamente!

Ora qualcosa che ha bisogno di una piccola spiegazione ecco cosa sono esattamente exactly esecutori? Il modo in cui i flussi di lavoro di CI è che la costruzione di moduli, il loro test, ecc. sono tutti noti come lavori e gli esecutori eseguono quei lavori. Se scegli VirtualBox come executor, allora GitLab runner si integrerà con VirtualBox installato localmente ed eseguirà i lavori CI in una VM, se selezioni kubernetes allora accadrebbe nel tuo cluster Kubernetes, nel cloud, se selezioni ssh puoi delegare le attività CI a un server remoto.

Il nostro progetto di esempio è basato su Docker, quindi ha senso usare Docker come nostro esecutore. devi avere Docker installato localmente per questo.

Avere più opzioni per gli esecutori rende Runner più flessibile. Potresti voler creare localmente perché i file di progetto sono troppo grandi o potresti voler eseguire in un server remoto con 20 core e mezzo terabyte di RAM perché il processo di compilazione è intensivo dal punto di vista computazionale, specificare un'opzione executor ti dà quella flessibilità.

Infine, nella tua shell vorresti avviare il servizio Runner:

$ gitlab-runner start

Vedendo .gitlab-ci.yml in azione

Ora abbiamo apportato tutte queste modifiche nel nostro repository locale creato tutte le app.js, pacchetto.json, Dockerfile e .gitlab-ci.file yml. Presumibilmente, hai commesso le modifiche al tuo repository locale eseguendo:

$ git stage nome_file
$ git commit -m "Commit messaggio"

Inviamo le modifiche al nostro GitLab remoto.

$ git push -u origine

Puoi quindi aprire il tuo progetto in GitLab, vai a mio-progetto → Pipeline e vedrai questo un tag che dice "passato" accanto al commit che hai fatto. Anche i commit successivi avranno tag.

Quindi queste sono le basi della CI utilizzando GitLab e Runner. Spero che il post ti sia piaciuto e che tu abbia imparato qualcosa di nuovo.