GitLab CI/CD è un sistema integrato di Continuous Integration e Continuous Deployment che permette di automatizzare il ciclo di sviluppo software attraverso pipeline definite in codice. Questa guida fornisce una panoramica tecnica dei componenti fondamentali e un tutorial pratico per l’implementazione.
Introduzione
Architettura GitLab CI/CD
GitLab CI/CD implementa un modello di automazione basato su pipeline dichiarative definite tramite file YAML. Il sistema è composto da:
- GitLab Server: Coordina l’esecuzione delle pipeline e gestisce il repository
- GitLab Runners: Agenti di esecuzione che processano i job in ambienti isolati
- Pipeline: Sequenze di stage contenenti job paralleli o sequenziali
- Artifacts: Output persistenti dei job utilizzabili in fasi successive
Continuous Integration (CI)
L’integrazione continua automatizza la validazione del codice ad ogni commit attraverso:
- Compilazione automatica del codice sorgente
- Esecuzione di test suite (unit, integration, end-to-end)
- Analisi statica del codice e controlli di sicurezza
- Generazione di report di copertura e qualità
Continuous Deployment (CD)
Il deployment continuo gestisce la distribuzione automatica del software attraverso:
- Build di artifact e container per deployment
- Gestione di ambienti multipli (staging, production)
- Strategie di deployment (blue-green, canary, rolling)
- Monitoring post-deployment e rollback automatici
Componenti Tecnici del Sistema
Declarative Pipeline: Le pipeline sono definite come codice nel file .gitlab-ci.yml utilizzando sintassi YAML standard.
Container-based Execution: Ogni job viene eseguito in un container Docker isolato con immagini configurabili.
Parallel Execution: I job all’interno dello stesso stage vengono eseguiti in parallelo per ottimizzare i tempi.
Artifact Management: Sistema di storage temporaneo per condividere file e report tra job e stage differenti.
Variable Interpolation: Gestione di variabili d’ambiente, segreti e configurazioni attraverso un sistema di scope gerarchico.
Casi d’Uso Tipici
- Build Automation: Compilazione di applicazioni multi-linguaggio (Node.js, Python, Java, Go)
- Testing Pipeline: Esecuzione automatica di test suite con report di copertura
- Quality Gates: Controlli automatici di code quality, security scanning, dependency checking
- Multi-Environment Deployment: Gestione di deployment su staging e production
- Infrastructure as Code: Provisioning automatico di infrastruttura cloud
- Notification Systems: Integrazione con sistemi di alerting e comunicazione team
Requisiti Tecnici
Per implementare pipeline GitLab CI/CD sono necessari:
- Repository GitLab: Progetto su GitLab.com o istanza self-hosted con permessi di scrittura
- GitLab Runner: Executor disponibile (shared runner o dedicato)
- Conoscenze YAML: Sintassi base per la definizione delle pipeline
- Ambiente di sviluppo: Applicazione con build system configurato
- Docker Knowledge: Comprensione base di container per l’esecuzione dei job
Teoria: Fondamenti della Pipeline Gitlab
Come Funziona il File .gitlab-ci.yml: La Base di Tutto
Il cuore di ogni pipeline GitLab CI/CD è il file .gitlab-ci.yml. Questo file, scritto in formato YAML, deve essere posizionato nella directory root del tuo repository e contiene tutte le istruzioni per automatizzare il tuo progetto.
Struttura Base del File .gitlab-ci.yml
Ecco la struttura fondamentale che ogni file .gitlab-ci.yml dovrebbe avere:
# Definizione degli stage (fasi) della pipeline
stages:
- build
- test
- deploy
# Variabili globali
variables:
NODE_VERSION: "18"
# Job di build
build_job:
stage: build
image: node:18
script:
- npm install
- npm run build
artifacts:
paths:
- dist/
expire_in: 1 hour
# Job di test
test_job:
stage: test
image: node:18
script:
- npm install
- npm run test
coverage: '/Lines\s*:\s*(\d+\.\d+)%/'
# Job di deploy
deploy_job:
stage: deploy
script:
- echo "Deploying to production"
- # Comandi di deployment
only:
- main
Componenti Principali della Pipeline GitLab CI/CD
1. Stages (Fasi): L’Ordine di Esecuzione
Gli stages definiscono le fasi sequenziali della tua pipeline. Ogni stage viene eseguito dopo il completamento con successo del precedente.
stages:
- validate # Validazione del codice (linting, format check)
- build # Compilazione e creazione degli artifact
- test # Esecuzione dei test automatici
- security # Controlli di sicurezza e vulnerability scanning
- deploy # Deployment negli ambienti target
Come Funzionano gli Stages:
- I job all’interno dello stesso stage vengono eseguiti in parallelo
- Se un job fallisce, gli stage successivi non vengono eseguiti
- È possibile personalizzare questo comportamento con
allow_failure: true
2. Jobs: Le Singole Operazioni
I jobs sono le singole operazioni eseguite all’interno di ogni stage. Ogni job viene eseguito in un ambiente isolato (container Docker).
lint_code:
stage: validate # A quale stage appartiene
image: node:18 # Immagine Docker da utilizzare
before_script: # Comandi da eseguire prima dello script principale
- npm install
script: # Comandi principali del job
- npm run lint
- npm run format:check
after_script: # Comandi da eseguire dopo lo script (sempre)
- echo "Linting completed"
allow_failure: false # Il job deve avere successo per continuare
Elementi Chiave di un Job:
- stage: Definisce in quale fase viene eseguito
- image: Specifica l’ambiente di esecuzione (Docker image)
- script: Contiene i comandi da eseguire
- before_script/after_script: Comandi pre e post esecuzione
3. Variables: Parametrizzazione della Pipeline
Le variables permettono di parametrizzare la configurazione e riutilizzare valori in tutta la pipeline.
# Variabili globali (disponibili in tutti i job)
variables:
DATABASE_URL: "postgres://user:pass@localhost/db"
API_VERSION: "v1"
NODE_ENV: "production"
# Variabili specifiche di un job
build_app:
stage: build
variables:
BUILD_ENV: "staging" # Disponibile solo in questo job
script:
- echo "Building for $BUILD_ENV environment"
- echo "API Version: $API_VERSION"
Tipi di Variabili:
- Variabili di progetto: Configurate nell’interfaccia GitLab
- Variabili di gruppo: Ereditate da tutti i progetti del gruppo
- Variabili predefinite: Fornite automaticamente da GitLab (es.
$CI_COMMIT_SHA) - Variabili protette: Disponibili solo su branch/tag protetti
4. Artifacts: Condivisione di File tra Job
Gli artifacts sono file generati dai job che possono essere utilizzati in stage successivi o scaricati dall’interfaccia GitLab.
build_app:
stage: build
script:
- npm run build # Genera file nella cartella dist/
- npm run test:unit # Genera report di copertura
artifacts:
paths:
- dist/ # Cartella con i file compilati
- coverage/ # Report di copertura
reports:
coverage_report:
coverage_format: cobertura
path: coverage/cobertura-coverage.xml
expire_in: 1 week # Gli artifact vengono eliminati dopo 1 settimana
when: on_success # Salva solo se il job ha successo
# Job successivo che utilizza gli artifacts
deploy_app:
stage: deploy
dependencies:
- build_app # Specifica da quale job prendere gli artifacts
script:
- ls dist/ # I file di build_app sono disponibili
- rsync -av dist/ /var/www/html/
Configurazioni Avanzate degli Artifacts:
- expire_in: Durata di conservazione (es.
1 hour,1 day,1 week) - when: Quando salvare (
on_success,on_failure,always) - reports: Integrazione con report specifici (copertura, test, sicurezza)
Come creare la tua prima pipeline
Tutorial Step-by-Step: Pipeline Semplice
Passo 1: Creare il File .gitlab-ci.yml
- Naviga nella root del tuo repository GitLab
- Crea un nuovo file chiamato
.gitlab-ci.yml - Inizia con questa configurazione base:
stages:
- test
- build
hello_world:
stage: test
script:
- echo "Hello, GitLab CI/CD!"
- echo "Current date: $(date)"
- echo "Repository: $CI_PROJECT_NAME"
simple_build:
stage: build
script:
- echo "Building application..."
- mkdir -p build
- echo "Build completed at $(date)" > build/info.txt
- echo "Git commit: $CI_COMMIT_SHA" >> build/info.txt
artifacts:
paths:
- build/
expire_in: 1 hour
Passo 2: Commit e Push
git add .gitlab-ci.yml
git commit -m "Add basic GitLab CI/CD pipeline"
git push origin main
Passo 3: Verificare l’Esecuzione
- Vai su CI/CD → Pipelines nel tuo progetto GitLab
- Dovresti vedere la pipeline in esecuzione automaticamente
- Clicca sulla pipeline per vedere il dettaglio di ogni job
- Monitora i log cliccando sui singoli job
- Verifica che gli artifacts siano stati creati nella sezione “Job artifacts”
Conclusioni
In questo articolo abbiamo esplorato i componenti fondamentali delle pipeline GitLab CI/CD e la loro implementazione pratica. Abbiamo analizzato l’architettura del sistema, dai concetti base di stages e jobs fino alla gestione di artifacts e variabili.
La parte teorica ha coperto la struttura del file .gitlab-ci.yml e i quattro pilastri delle pipeline: stages per l’organizzazione sequenziale, jobs per l’esecuzione parallela, variables per la parametrizzazione e artifacts per la persistenza dei dati tra fasi.
Il tutorial pratico ha dimostrato l’implementazione step-by-step di una pipeline funzionale, dalla creazione del file di configurazione alla verifica dell’esecuzione tramite interfaccia GitLab. L’esempio ha illustrato come configurare job di test e build con artifacts, fornendo una base solida per pipeline più complesse.
La configurazione delle variabili di progetto ha completato il quadro tecnico, mostrando come gestire parametri sensibili e ambiente-specifici attraverso l’interfaccia GitLab.
Questo framework fornisce le basi per implementare automazione CI/CD scalabile, permettendo l’estensione verso deployment multi-ambiente, test automation avanzati e integrazione con sistemi esterni.