Costruisci la tua prima Pipeline Dichiarativa Jenkins per CI/CD
Jenkins è lo standard de facto per i server di automazione open-source, fungendo da spina dorsale per le pipeline di integrazione e distribuzione continua (CI/CD) in migliaia di organizzazioni. Sebbene Jenkins offra due tipi di sintassi per le pipeline — Scripted e Dichiarativa — la sintassi della Pipeline Dichiarativa è l'approccio consigliato per la maggior parte degli utenti grazie al suo DSL Groovy più semplice, strutturato e leggibile.
Questa guida fornisce un tutorial completo, passo dopo passo, per costruire la tua prima Pipeline Dichiarativa Jenkins funzionante. Copriremo l'integrazione della gestione del codice sorgente (SCM), la definizione dell'ambiente di build, l'esecuzione dei test e l'implementazione di una fase di deployment di esempio, offrendoti una solida base per automatizzare il ciclo di vita della tua consegna software.
Comprensione della Struttura della Pipeline Dichiarativa
La Pipeline Dichiarativa definisce l'intero flusso di lavoro in un file chiamato Jenkinsfile, che viene archiviato insieme al codice della tua applicazione nel tuo repository SCM (ad esempio, Git). Questa pratica è nota come Pipeline as Code.
Elementi Fondamentali di una Pipeline Dichiarativa
Una Pipeline Dichiarativa deve contenere i seguenti blocchi di primo livello:
pipeline: Il blocco esterno obbligatorio che definisce il contenuto della pipeline.agent: Specifica dove verrà eseguita la pipeline o una fase specifica (ad esempio,any,none, o etichette specifiche).stages: Contiene uno o più blocchistagesequenziali.stage: Definisce un blocco concettuale di lavoro (ad esempio, Build, Test, Deploy).steps: Contiene uno o più comandi o funzioni eseguiti all'interno di unstage.
pipeline {
agent any
environment { // Opzionale: Definisce le variabili d'ambiente
APP_VERSION = '1.0.0'
}
stages {
stage('Build') {
steps {
// I comandi vanno qui
}
}
}
post { // Opzionale: Azioni eseguite dopo il completamento della pipeline
always {
echo 'Pipeline terminata.'
}
}
}
Passaggio 1: Configurazione del Job Jenkins
Per eseguire una Pipeline dal codice, è necessario configurare un job Jenkins per leggere il Jenkinsfile dal tuo repository.
- Naviga nella tua dashboard Jenkins e seleziona New Item.
- Inserisci un nome per la tua pipeline (ad esempio,
my-first-ci-pipeline). - Seleziona il tipo di elemento Pipeline e fai clic su OK.
- Nella pagina di configurazione, scorri verso il basso fino alla sezione Pipeline.
- Cambia la definizione da Pipeline script a Pipeline script from SCM.
- Seleziona il tuo SCM (ad esempio, Git).
- Inserisci l'URL del Repository e configura le tue credenziali se necessario.
- Assicurati che il Script Path sia impostato su
Jenkinsfile(l'impostazione predefinita).
Passaggio 2: Definizione del Jenkinsfile per CI/CD
Creeremo un Jenkinsfile completo che simula un semplice flusso di lavoro CI/CD, integrando fasi standard per un deployment di successo.
Supponi di avere una struttura di repository contenente il codice sorgente della tua applicazione (ad esempio, un semplice progetto Python o Java) e il Jenkinsfile alla radice.
L'Esempio Completo della Pipeline Dichiarativa
Questa pipeline utilizza l'agente node (se configurato) e utilizza semplici passi shell (sh) per simulare un lavoro reale. La fase di deployment è condizionale, eseguita solo al completamento con successo delle fasi precedenti.
// Jenkinsfile
pipeline {
// 1. Definizione dell'Agente: Specifica dove viene eseguita l'intera pipeline
agent {
label 'my-build-agent' // Usa un'etichetta specifica se disponibile, o 'any'
}
// 2. Variabili d'Ambiente: Definisci variabili utilizzabili in tutta la pipeline
environment {
CONTAINER_REGISTRY = 'registry.example.com'
IMAGE_NAME = 'myapp'
}
stages {
// Fase 1: Checkout (Gestione Codice Sorgente)
stage('Checkout Source') {
steps {
// Il passo 'checkout scm' esegue automaticamente il checkout del codice
// in base alla configurazione definita nelle impostazioni del job Jenkins.
checkout scm
sh 'echo "Source code successfully checked out."
}
}
// Fase 2: Build degli Artefatti
stage('Build Artifact') {
steps {
sh 'echo "Starting build for $IMAGE_NAME:$BUILD_ID"'
// Simulazione: Costruisci un'immagine Docker o compila un file jar/war
sh "docker build -t ${IMAGE_NAME}:${BUILD_ID} ."
}
}
// Fase 3: Test e Quality Gates
stage('Run Tests') {
steps {
sh './run_unit_tests.sh'
sh 'echo "Running integration tests..."'
// Esempio di raccolta dei risultati dei test (richiede plugin appropriati)
// junit '**/target/surefire-reports/*.xml'
}
}
// Fase 4: Deployment (Condizionale)
stage('Deploy to Staging') {
// La direttiva 'when' garantisce che la fase venga eseguita solo in condizioni specifiche
when {
branch 'main'
}
steps {
sh "docker push ${CONTAINER_REGISTRY}/${IMAGE_NAME}:${BUILD_ID}"
sh 'kubectl apply -f k8s/deployment-staging.yaml'
script {
// I blocchi Script consentono la logica Groovy tradizionale all'interno dei passi Dichiarativi
echo "Deployment successful to Staging environment."
}
}
}
}
// 3. Azioni Post: Definisci azioni in base allo stato finale della pipeline
post {
success {
echo 'Pipeline completed successfully. Notifying team via Slack...'
// slackSend channel: '#devops-alerts', message: 'CI/CD Success!'
}
failure {
echo 'Pipeline failed. Review logs for errors.'
}
cleanup {
sh 'docker rmi -f $(docker images -aq --filter label=build_id=$BUILD_ID)'
}
}
}
Passaggio 3: Esecuzione e Monitoraggio della Pipeline
Una volta che il Jenkinsfile è stato committato e inviato al branch configurato nel tuo job Jenkins:
- Nella pagina del job Jenkins, fai clic su Build Now (o attendi l'attivazione del polling SCM/webhook).
- Monitora la build nel pannello Build History.
- Fai clic sul numero della build in esecuzione e seleziona Console Output per visualizzare i dettagli dell'esecuzione passo dopo passo.
- Puoi anche utilizzare la visualizzazione Stage View (se il plugin è installato) per vedere graficamente il progresso delle fasi
Checkout,Build,TesteDeploy.
Best Practices e Funzionalità Avanzate
Utilizzo di Librerie e Codice Condiviso
Per passi complessi o altamente ripetitivi, evita di scrivere codice Groovy verboso direttamente nel Jenkinsfile. Utilizza invece le Shared Libraries. Queste librerie esterne ti consentono di definire funzioni comuni (come routine di deployment standard o funzioni di notifica) che possono essere chiamate da più pipeline, rendendo il tuo Jenkinsfile più pulito.
// Chiamata a un passo della libreria condivisa
stage('Custom Setup') {
steps {
customLibrary.initializeEnvironment(env: 'prod')
}
}
Lavorare con le Credenziali
Non inserire mai informazioni sensibili (password, token, chiavi API) direttamente nel Jenkinsfile. Utilizza il sistema di gestione delle credenziali integrato di Jenkins.
Il passo withCredentials ti consente di accedere in modo sicuro ai segreti memorizzati:
stage('Authenticate Registry') {
steps {
withCredentials([usernamePassword(credentialsId: 'docker-registry-creds',
passwordVariable: 'PASS',
usernameVariable: 'USER')]) {
sh "docker login -u ${USER} -p ${PASS} ${CONTAINER_REGISTRY}"
}
}
}
Attenzione: Selezione dell'Agente
Suggerimento: Definisci sempre il tuo
agentspecificamente utilizzando unlabelanzichéagent any. L'uso diagent anysignifica che la pipeline potrebbe essere eseguita sul nodo controller Jenkins, il che rappresenta un rischio per la sicurezza e può influire sulle prestazioni del controller. Assicurati di aver configurato correttamente agenti Jenkins (nodi) con gli strumenti necessari (Docker, Maven, Node.js) installati.
Conclusione
La Pipeline Dichiarativa Jenkins offre un framework potente, leggibile e manutenibile per implementare l'Integrazione Continua e la Distribuzione Continua. Definendo la struttura del flusso di lavoro — inclusi agenti, variabili d'ambiente, fasi sequenziali e azioni post-build — ottieni visibilità e controllo completi sul tuo processo di automazione software. Con questo Jenkinsfile di base stabilito, sei ora pronto a integrare passi più complessi, come la scansione automatizzata della sicurezza, la pubblicazione degli artefatti e le promozioni multi-ambiente.