Esercitazione: Creare una pipeline Jenkins usando GitHub e Docker

2025-05-08

Importante

Sebbene molti servizi di Azure dispongano di plug-in Jenkins, la maggior parte di questi plug-in termina il supporto a partire dal 29 febbraio 2024. L'interfaccia della riga di comando di Azure è il modo attualmente consigliato per integrare Jenkins con i servizi di Azure. Per altre informazioni, vedere l'articolo Plug-in Jenkins per Azure.

Per automatizzare la fase di compilazione e test dello sviluppo di applicazioni, è possibile usare una pipeline di integrazione e distribuzione continua (CI/CD). In questa esercitazione viene creata una pipeline CI/CD in una macchina virtuale di Azure, inclusa la procedura:

Creare una macchina virtuale Jenkins
Installare e configurare Jenkins
Creare l'integrazione di webhook tra GitHub e Jenkins
Creare e attivare processi di compilazione Jenkins da commit di GitHub
Creare un'immagine Docker per l'app
Verificare che i commit di GitHub creino una nuova immagine Docker e aggiornino l'app in esecuzione

Questa esercitazione usa l'interfaccia della riga di comando all'interno di Azure Cloud Shell, che viene costantemente aggiornata all'ultima versione. Per aprire Cloud Shell, selezionare Prova nella parte superiore di qualsiasi blocco di codice.

Se si sceglie di installare e usare l'interfaccia della riga di comando in locale, per questa esercitazione è necessario eseguire l'interfaccia della riga di comando di Azure versione 2.0.30 o successiva. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

Creare un'istanza di Jenkins

In un'esercitazione precedente su Come personalizzare una macchina virtuale Linux al primo avvio si è appreso come automatizzare la personalizzazione delle macchine virtuali con cloud-init. Questa esercitazione usa un file cloud-init per installare Jenkins e Docker in una macchina virtuale. Jenkins è un server di automazione open source diffuso che si integra perfettamente con Azure per abilitare l'integrazione continua (CI) e il recapito continuo (CD). Per altre esercitazioni su come usare Jenkins, vedere Jenkins nell'hub di Azure.

Nella shell corrente creare un file denominato cloud-init-jenkins.txt e incollare la configurazione seguente. Ad esempio, creare il file in Cloud Shell anziché nel computer locale. Immettere sensible-editor cloud-init-jenkins.txt per creare il file e visualizzare un elenco di editor disponibili. Assicurarsi che l'intero file cloud-init venga copiato correttamente, in particolare la prima riga:

#cloud-config
package_upgrade: true
write_files:
  - path: /etc/systemd/system/docker.service.d/docker.conf
    content: |
      [Service]
        ExecStart=
        ExecStart=/usr/bin/dockerd
  - path: /etc/docker/daemon.json
    content: |
      {
        "hosts": ["fd://","tcp://127.0.0.1:2375"]
      }
runcmd:
  - apt install openjdk-8-jre-headless -y
  - wget -q -O - https://pkg.jenkins.io/debian/jenkins-ci.org.key | sudo apt-key add -
  - sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
  - apt-get update && apt-get install jenkins -y
  - curl -sSL https://get.docker.com/ | sh
  - usermod -aG docker azureuser
  - usermod -aG docker jenkins
  - service jenkins restart

Per poter creare una macchina virtuale è prima necessario creare un gruppo di risorse con il comando az group create. L'esempio seguente crea un gruppo di risorse denominato myResourceGroupJenkins nella posizione eastus :

az group create --name myResourceGroupJenkins --location eastus

Ora crea una macchina virtuale con az vm create. Usare il parametro --custom-data per inserire il file di configurazione di cloud-init. Specificare il percorso completo per cloud-init-jenkins.txt se il file è stato salvato all'esterno della directory di lavoro corrente.

az vm create --resource-group myResourceGroupJenkins \
    --name myVM \
    --image UbuntuLTS \
    --admin-username azureuser \
    --generate-ssh-keys \
    --custom-data cloud-init-jenkins.txt

La creazione e la configurazione della macchina virtuale richiedono alcuni minuti.

Per consentire al traffico Web di raggiungere la macchina virtuale, usare az vm open-port per aprire la porta 8080 per il traffico Jenkins e la porta 1337 per l'app Node.js usata per eseguire un'app di esempio:

az vm open-port --resource-group myResourceGroupJenkins --name myVM --port 8080 --priority 1001
az vm open-port --resource-group myResourceGroupJenkins --name myVM --port 1337 --priority 1002

Configurare Jenkins

Per accedere all'istanza di Jenkins, ottenere l'indirizzo IP pubblico della macchina virtuale:

az vm show --resource-group myResourceGroupJenkins --name myVM -d --query [publicIps] --o tsv

Ai fini della sicurezza, è necessario immettere la password di amministratore iniziale archiviata in un file di testo nella macchina virtuale per avviare l'installazione di Jenkins. Usare l'indirizzo IP pubblico ottenuto nel passaggio precedente per connettersi tramite SSH alla macchina virtuale:

ssh azureuser@<publicIps>

Verificare che Jenkins sia in esecuzione usando il service comando :

$ service jenkins status
● jenkins.service - LSB: Start Jenkins at boot time
   Loaded: loaded (/etc/init.d/jenkins; generated)
   Active: active (exited) since Tue 2019-02-12 16:16:11 UTC; 55s ago
     Docs: man:systemd-sysv-generator(8)
    Tasks: 0 (limit: 4103)
   CGroup: /system.slice/jenkins.service

Feb 12 16:16:10 myVM systemd[1]: Starting LSB: Start Jenkins at boot time...
...

Visualizza il initialAdminPassword per l'installazione di Jenkins e copialo:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Se il file non è ancora disponibile, attendere un paio di minuti prima che cloud-init completi l'installazione di Jenkins e Docker.

Aprire un Web browser e passare a http://<publicIps>:8080. Completare la configurazione iniziale di Jenkins come indicato di seguito:

Scegliere Seleziona plug-in da installare
Cercare GitHub nella casella di testo nella parte superiore. Selezionare la casella per GitHub, quindi selezionare Installa
Creare il primo utente amministratore. Immettere un nome utente, ad esempio admin, quindi specificare la password sicura. Digitare infine un nome completo e un indirizzo di posta elettronica.
Selezionare Salva e Fine
Dopo aver pronto Jenkins, selezionare Inizia a usare Jenkins
- Se il Web browser visualizza una pagina vuota quando si inizia a usare Jenkins, riavviare il servizio Jenkins. Dalla sessione SSH digitare sudo service jenkins restart, quindi aggiornare il Web browser.
Se necessario, accedere a Jenkins con il nome utente e la password creati.

Creare un webhook GitHub

Per configurare l'integrazione con GitHub, aprire l'app di esempioNode.js Hello World dal repository di esempi di Azure. Per creare una copia tramite fork del repository nel proprio account GitHub, selezionare il pulsante Fork nell'angolo in alto a destra.

Creare un webhook all'interno del fork creato:

Selezionare Impostazioni, quindi selezionare Webhook sul lato sinistro.
Scegliere Aggiungi webhook, quindi immettere Jenkins nella casella di filtro.
Per l'URL del payload inserire http://<publicIps>:8080/github-webhook/. Assicurarsi di includere l'elemento finale/
In Tipo di contenuto selezionare application/x-www-form-urlencoded.
Per Quali eventi desideri utilizzare per attivare questo webhook?, selezionare Solo l'evento push.
Impostare Attivo su selezionato.
Fare clic su Aggiungi webhook.

Aggiungere il webhook GitHub al repository forkato

Creare un'attività Jenkins

Per fare in modo che Jenkins risponda a un evento in GitHub, ad esempio il commit del codice, creare un processo Jenkins. Usa gli URL per il tuo proprio fork GitHub.

Nel sito Web jenkins selezionare Crea nuovi processi nella home page:

Immettere HelloWorld come nome del job. Scegliere Progetto Freestyle, quindi selezionare OK.
Nella sezione Generale selezionare Progetto GitHub e immettere l'URL del repository con fork, ad esempio https://github.com/cynthn/nodejs-docs-hello-world
Nella sezione Gestione del codice sorgente selezionare Git, immettere l'URL git del repository con fork, ad esempio https://github.com/cynthn/nodejs-docs-hello-world.git
Nella sezione Build Triggers, selezionare GitHub hook trigger for GITscm polling.
Nella sezione Compilazione scegliere Aggiungi passaggio di compilazione. Selezionare Esegui shell e quindi immettere echo "Test" nella finestra di comando.
Selezionare Salva nella parte inferiore della finestra dei processi.

Testare l'integrazione di GitHub

Per testare l'integrazione di GitHub con Jenkins, eseguire il commit di una modifica nel fork.

Tornare all'interfaccia utente Web di GitHub, selezionare il repository con fork e quindi selezionare il file index.js . Selezionare l'icona a forma di matita per modificare il file in modo da leggere la riga 6:

response.end("Hello World!");

Per eseguire il commit delle modifiche, selezionare il pulsante Commit changes (Esegui commit modifiche ) nella parte inferiore.

In Jenkins una nuova compilazione viene avviata nella sezione Cronologia delle compilazioni in basso a sinistra nella pagina del processo. Scegliere il collegamento numero di build e selezionare Output della console sul lato sinistro. È possibile visualizzare i passaggi impiegato da Jenkins durante il pull del codice da GitHub e l'azione di compilazione restituisce il messaggio Test alla console. Ogni volta che viene eseguito un commit in GitHub, il webhook raggiunge Jenkins e attiva una nuova compilazione in questo modo.

Definire l'immagine di compilazione Docker

Per visualizzare l'app Node.js in esecuzione in base ai commit di GitHub, costruiamo un'immagine Docker per eseguire l'app. L'immagine viene compilata da un Dockerfile che definisce come configurare il contenitore che esegue l'app.

Dalla connessione SSH alla macchina virtuale, passare alla directory dell'area di lavoro di Jenkins denominata dal job creato in un passaggio precedente. In questo esempio, che è stato denominato HelloWorld.

cd /var/lib/jenkins/workspace/HelloWorld

Creare un file in questa directory dell'area di lavoro con sudo sensible-editor Dockerfile e incollare il contenuto seguente. Assicurarsi che l'intero Dockerfile venga copiato correttamente, in particolare la prima riga:

FROM node:alpine

EXPOSE 1337

WORKDIR /var/www
COPY package.json /var/www/
RUN npm install
COPY index.js /var/www/

Questo Dockerfile usa l'immagine di base Node.js usando Alpine Linux, espone la porta 1337 in cui viene eseguita l'app Hello World, quindi copia i file dell'app e la inizializza.

Creare regole di compilazione jenkins

In un passaggio precedente è stata creata una regola di compilazione Jenkins di base che restituisce un messaggio alla console. Creiamo la fase di build per utilizzare il Dockerfile ed eseguire l'app.

Tornare all'istanza di Jenkins e selezionare il processo creato in un passaggio precedente. Selezionare Configura sul lato sinistro e scorrere verso il basso fino alla sezione Compilazione:

Rimuovi il passaggio di compilazione esistente echo "Test". Selezionare la croce rossa nell'angolo superiore destro della casella di passaggio di compilazione esistente.
Scegliere Aggiungi passaggio di compilazione, quindi selezionare Esegui shell

Nella casella Comando immettere i comandi Docker seguenti e quindi selezionare Salva:

docker build --tag helloworld:$BUILD_NUMBER .
docker stop helloworld && docker rm helloworld
docker run --name helloworld -p 1337:1337 helloworld:$BUILD_NUMBER node /var/www/index.js &

I passaggi di compilazione di Docker creano un'immagine e la contrassegnano con il numero di build jenkins, in modo da poter mantenere una cronologia delle immagini. Tutti i contenitori esistenti che eseguono l'app vengono arrestati e quindi rimossi. Viene quindi avviato un nuovo contenitore utilizzando l'immagine, il quale esegue la tua app Node.js basata sugli ultimi commit in GitHub.

Testare la pipeline

Per visualizzare l'intera pipeline in azione, modificare una volta ancora il fileindex.js nel repository GitHub forkato e selezionare Conferma modifica. Un nuovo processo viene avviato in Jenkins in base al webhook per GitHub. La creazione dell'immagine Docker e l'avvio dell'app in un nuovo contenitore richiedono alcuni secondi.

Se necessario, ottenere di nuovo l'indirizzo IP pubblico della macchina virtuale:

az vm show --resource-group myResourceGroupJenkins --name myVM -d --query [publicIps] --o tsv

Aprire un Web browser e immettere http://<publicIps>:1337. L'app Node.js viene visualizzata e riflette i commit più recenti nel fork di GitHub come indicato di seguito:

Esecuzione dell'app Node.js

Apportare ora un'altra modifica al file index.js in GitHub ed eseguire il commit della modifica. Attendere alcuni secondi per il completamento del processo in Jenkins, quindi aggiornare il Web browser per visualizzare la versione aggiornata dell'app in esecuzione in un nuovo contenitore come indicato di seguito:

Esecuzione dell'app Node.js dopo un altro commit su GitHub

Passaggi successivi

In questa esercitazione GitHub è stato configurato per eseguire un processo di compilazione Jenkins in ogni commit del codice e quindi distribuire un contenitore Docker per testare l'app. Ecco cosa hai imparato a fare:

Creare una macchina virtuale Jenkins
Installare e configurare Jenkins
Creare l'integrazione di webhook tra GitHub e Jenkins
Creare e attivare processi di compilazione Jenkins da commit di GitHub
Creare un'immagine Docker per l'app
Verificare che i commit di GitHub creino una nuova immagine Docker e aggiornino l'app in esecuzione

Passare all'esercitazione successiva per altre informazioni su come integrare Jenkins con Azure DevOps Services.

Distribuire app con Jenkins e Azure DevOps Services

Condividi tramite