Guida rapida per GitLab Continuous Integration

All'interno di un progetto vengono gestiti vari componenti come il tuo codebase, la configurazione CI, la pianificazione, l'analisi e i membri del team. In questa guida creeremo un nuovo progetto completamente vuoto, contenente solo un file readme.

• Crea un nuovo progetto cliccando sull'icona più sul lato destro della barra superiore e selezionando Nuovo progetto/repository
• Seleziona Crea progetto vuoto. Sotto Nome progetto digita my-project.
• Clicca Crea progetto.
• Congratulazioni! Hai creato con successo il tuo primo progetto.

In GitLab, la configurazione CI è definita nel codice utilizzando la sintassi YAML. Questa configurazione specifica le istruzioni per la macchina runner riguardo all'esecuzione dei job, l'ordine dei job, le condizioni dei job e altro ancora. Per definire la configurazione CI, devi creare un file chiamato .gitlab-ci.yml, che dovrebbe essere posizionato alla radice del tuo repository. In questa guida utilizzeremo il Web IDE per creare e modificare questo file.

Per accedere al Web IDE, clicca semplicemente sul pulsante rapido Web IDE situato nel tuo progetto. Una volta all'interno del Web IDE, naviga nell'esploratore file sul lato sinistro. Fai clic destro nell'esploratore file e scegli l'opzione Nuovo File. Assegna al file appena creato il nome .gitlab-ci.yml.

L'ordine di esecuzione dei job è determinato dagli stage definiti nella configurazione. In questa guida definiremo tre stage: build, test e package, in questo ordine specifico. Copia e incolla il seguente codice nel file .gitlab-ci.yml:

  stages:
    - build
    - test
    - package

Immagina uno scenario in cui ti viene chiesto di creare due file di testo. È di fondamentale importanza che la concatenazione di questi file includa la frase "Hello world." Il nostro obiettivo è costruire, testare e impacchettare questo requisito utilizzando i job della pipeline.

Specificheremo un job di build che esegue le seguenti attività: creare un file di testo con la parola "Hello,", creare un altro file di testo con la parola "World," e generare un terzo file che memorizza il contenuto combinato dei due file. Salveremo il terzo file come artifact, così i job successivi negli stage di test e package potranno accedervi. Inserisci il codice fornito sotto il blocco stages:

  build-job:
    stage: build
    script:
      - echo "Hello " | tr -d "\n" > file1.txt
      - echo "world" > file2.txt
      - cat file1.txt file2.txt > compiled.txt
    artifacts:
    paths:
      - compiled.txt

Per validare l'integrità del nostro build, incorporeremo un job di test. Questo job esaminerà se il file compiled.txt contiene effettivamente la frase attesa "Hello world". Inserisci il seguente codice sotto il job di build:

  test:
    stage: test
    script: cat compiled.txt | grep -q 'Hello world '

Al completamento con successo del test, il nostro prossimo obiettivo è generare un package per il nostro codice. Per raggiungere questo obiettivo, includeremo un job di package. È importante notare che se il test fallisce, l'intera pipeline sarà considerata non riuscita e non procederà. Inserisci il codice fornito sotto il job di test:

  package:
    stage: package
    script: cat compiled.txt | gzip > packaged.gz
    artifacts:
      paths:
        - packaged.gz

  stages:          # Lista degli stage per i job e il loro ordine di esecuzione
    - build
    - test
    - package

  build-job:
    stage: build
    script:
      - echo "Hello " | tr -d "\n" > file1.txt
      - echo "world" > file2.txt
      - cat file1.txt file2.txt > compiled.txt
    artifacts:
      paths:
        - compiled.txt

  test:
    stage: test
    script: cat compiled.txt | grep -q 'Hello world'

  package:
    stage: package
    script: cat compiled.txt | gzip > packaged.gz
    artifacts:
      paths:
        - packaged.gz

Ecco un link al file di configurazione nel nostro progetto di esempio.

Congratulazioni!! Hai costruito la tua prima pipeline CI.

Per attivare la continuous integration (CI) all'interno del nostro progetto, dobbiamo fare il push del file .gitlab-ci.yml nel repository. Una volta che questo file si trova alla radice del repository, ogni commit fatto al progetto avvierà automaticamente una pipeline CI. La pipeline iniziale inizierà immediatamente dopo aver fatto il push di questo file al server.

• Clicca sull'icona Merge situata a sinistra dell'esploratore file.
• Fornisci un messaggio di commit come "Aggiunta configurazione CI."
• Clicca su Commit & Push.
• Quando richiesto con "Commit su un nuovo branch?" seleziona "No, Usa il branch corrente main".
• Per tornare al tuo progetto, clicca il pulsante Vai al progetto situato in basso a sinistra.

Congratulazioni! Il tuo progetto è ora configurato con successo per avviare automaticamente una pipeline CI per ogni commit del codice.

Mentre la pipeline è in esecuzione, puoi monitorare il suo stato nella scheda CI/CD. Questa funzionalità ti permette di tracciare facilmente il progresso dei tuoi job, incluso il loro stato di esecuzione (come se sono iniziati, passati, falliti, ecc.), così come qualsiasi output generato dai tuoi script di job.

• Naviga al progetto GitLab e individua il menu di sinistra.
• Clicca su CI/CD nel menu, clicca Pipelines.
• Nella pagina Pipelines, individua il pulsante della pipeline nella colonna Stato. Cliccaci sopra per aprire il grafico della pipeline.
• Ora puoi osservare i job e i loro rispettivi stati all'interno del grafico della pipeline.
• Per esplorare un job specifico, cliccaci sopra per aprire la console del job. Questa console mostra tutti i passaggi eseguiti sulla macchina Runner.
• Apri la console del job package per visualizzare i passaggi che sono stati elaborati dal runner.
• Il job package genera un artifact, puoi scaricarlo cliccando il pulsante download situato sul lato destro.
• Seguendo questi passaggi, puoi tracciare efficacemente lo stato della pipeline, ispezionare i dettagli dei job e recuperare qualsiasi artifact o package rilevante prodotto durante l'esecuzione della pipeline.

Congratulazioni per aver eseguito con successo la tua prima pipeline. La pipeline è riuscita! Hai ora visualizzato i risultati e scaricato l'artifact del job.

Cambieremo il valore atteso nel job di test, il job di test fallirà così come l'intera pipeline fallirà.

• Modifica il job test cambiando la frase "Hello World" in "hello world" (con lettere minuscole).
• Fai il commit delle modifiche al codice e procedi a visualizzare la pipeline, simile al Passaggio 4.
• Ispezionando la pipeline, osserverai che il job di test è fallito. Inoltre, il job package successivo non è iniziato, e la pipeline stessa è fallita come previsto.

Nel passaggio 5 abbiamo visto che il fallimento del job ha fatto fallire l'intera pipeline. Puoi introdurre logica nella tua pipeline che determina quando un fallimento del job causerà il fallimento dell'intera pipeline con i seguenti passaggi:

• Valuta le condizioni sotto le quali vuoi che un fallimento del job risulti nel fallimento della pipeline. Ad esempio, potresti voler imporre il fallimento della pipeline se un job fallisce sul branch main o predefinito, mentre permetti ai fallimenti dei job su altri branch di procedere con la pipeline.
• Definisci regole che governano il comportamento di fallimento. Puoi sfruttare variabili come $CI_COMMIT_BRANCH per controllare il branch corrente e prendere decisioni basate su di esso.
• Imposta le condizioni appropriate e specifica se il job dovrebbe essere marcato come allow_failure: false o allow_failure: true.

• Aggiungi condizioni rules/if al tuo job di test.
• Usa la parola chiave allow_failure impostata su true o false basata sul branch.

  test:
    stage: test
    script: cat compiled.txt | grep -q 'Hello world'
    rules:
      - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
        allow_failure: false
      - if: $CI_COMMIT_BRANCH
        allow_failure: true

Per semplificare la configurazione della pipeline, puoi sfruttare i template di pipeline integrati forniti da GitLab. Questi template offrono configurazioni predefinite per casi d'uso comuni, come scansioni di sicurezza, deployment AWS, ecc.

Segui questi passaggi per utilizzare i template di pipeline integrati:

• Esplora i template di pipeline disponibili offerti da GitLab per vari scenari come building, testing, deployment e altro. Questi template possono essere trovati qui.
• Seleziona il template che si allinea con i tuoi requisiti.
• Incorpora il template nella tua configurazione di pipeline facendovi riferimento nel tuo file .gitlab-ci.yml. Puoi tipicamente farlo importando il template usando la parola chiave include e specificando il percorso o URL al file template.

In questa guida aggiungeremo una scansione Code Quality alla nostra configurazione usando il template Code-Quality.

Includi il template code quality nel tuo .gitlab-ci.yml aggiungendo questo codice sotto il blocco stages.

  include:
    - template: Jobs/Code-Quality.gitlab-ci.yml

Fai il commit e push di questa modifica.

Noterai che un job Code quality è stato aggiunto alla tua pipeline. Lo scanner Code Quality analizzerà accuratamente qualsiasi modifica al codice committata in questo repository e fornirà feedback prezioso, evidenziando qualsiasi problema di qualità del codice che richiede attenzione e miglioramento. Questa preziosa intuizione ti permette di migliorare la qualità complessiva del tuo codebase e ottimizzarne le prestazioni.

Ecco fatto! Con questi passaggi, dovresti essere in grado di iniziare con GitLab CI e automatizzare i processi di build e testing del tuo progetto.