GSP051

Panoramica

In questo lab imparerai a configurare una pipeline di distribuzione continua con Jenkins su Kubernetes Engine. Jenkins è il server di automazione affidabile utilizzato dagli sviluppatori che integrano spesso il proprio codice in un repository condiviso. La soluzione che creerai in questo lab sarà simile al seguente diagramma:

Nel Cloud Architecture Center, consulta Jenkins su Kubernetes Engine per scoprire di più sull'esecuzione di Jenkins su Kubernetes.

Obiettivi didattici

In questo lab, completerai le seguenti attività per scoprire come eseguire Jenkins su Kubernetes:

• Eseguire il provisioning di un'applicazione Jenkins in un cluster Kubernetes Engine
• Configurare l'applicazione Jenkins utilizzando il gestore di pacchetti Helm
• Esplorare le funzionalità di un'applicazione Jenkins
• Creare ed eseguire una pipeline Jenkins

Prerequisiti

Si tratta di un lab di livello avanzato. Prima di iniziare, dovresti acquisire familiarità almeno con i concetti di base di Jenkins, Kubernetes e della programmazione della shell. Ecco alcuni lab che possono esserti d'aiuto:

• Introduzione a Docker
• Hello Node Kubernetes
• Gestione dei deployment utilizzando Kubernetes Engine
• Configurazione di Jenkins su Kubernetes Engine

Una volta affinate le tue conoscenze, scorri verso il basso per saperne di più su Kubernetes, Jenkins e sulla distribuzione continua.

Che cos'è Kubernetes Engine?

Kubernetes Engine è la versione ospitata di Kubernetes di Google Cloud, un potente sistema di gestione e orchestrazione dei cluster per i container. Kubernetes è un progetto open source eseguibile in molti ambienti diversi, dai laptop ai cluster multinodo ad alta affidabilità, dalle macchine virtuali al bare metal. Come accennato in precedenza, le app Kubernetes si basano sui container, ovvero applicazioni leggere abbinate a tutte le dipendenze e librerie necessarie per eseguirle. Questa struttura sottostante rende le applicazioni Kubernetes ad alta affidabilità e sicure e ne consente il deployment rapido: un framework ideale per gli sviluppatori cloud.

Che cos'è Jenkins?

Jenkins è un server di automazione open source che ti consente di orchestrare in modo flessibile le tue pipeline di build, test e deployment. Jenkins consente agli sviluppatori di eseguire rapidamente l'iterazione dei progetti senza preoccuparsi di problemi generali che possono derivare dalla distribuzione continua.

Che cosa sono la distribuzione continua e il deployment continuo?

Se devi configurare una pipeline di distribuzione continua (CD), il deployment di Jenkins su Kubernetes Engine offre importanti vantaggi rispetto a un deployment standard basato su VM.

Quando il processo di compilazione utilizza i container, un host virtuale può eseguire i job su più sistemi operativi. Kubernetes Engine fornisce esecutori di build temporanei, che vengono utilizzati solo quando le build sono attivamente in esecuzione, lasciando così libere risorse per altre attività del cluster, come i job di elaborazione batch. Un altro vantaggio degli esecutori di build temporanei è la velocità, poiché vengono avviati in pochi secondi.

Kubernetes Engine è inoltre preconfigurato con il bilanciatore del carico globale di Google, che puoi utilizzare per automatizzare il routing del traffico web alle istanze. Il bilanciatore del carico gestisce la terminazione SSL e utilizza un indirizzo IP globale configurato con la rete backbone di Google. Insieme al frontend web, questo bilanciatore del carico imposterà sempre gli utenti sul percorso più veloce possibile verso un'istanza di applicazione.

Ora che hai appreso le prime nozioni su Kubernetes, Jenkins e su come entrambi interagiscono in una pipeline CD, è il momento di crearne una.

Configurazione e requisiti

Prima di fare clic sul pulsante Avvia lab

Leggi le seguenti istruzioni. I lab sono a tempo e non possono essere messi in pausa. Il timer si avvia quando fai clic su Inizia il lab e ti mostra per quanto tempo avrai a disposizione le risorse Google Cloud.

Con questo lab pratico avrai la possibilità di completare le attività in un ambiente cloud reale e non di simulazione o demo. Riceverai delle nuove credenziali temporanee che potrai utilizzare per accedere a Google Cloud per la durata del lab.

Per completare il lab, avrai bisogno di:

• Accesso a un browser internet standard (Chrome è il browser consigliato).

Nota: per eseguire questo lab, utilizza una finestra del browser in modalità di navigazione in incognito (consigliata) o privata. Ciò evita conflitti tra il tuo account personale e l'account studente, che potrebbero causare addebiti aggiuntivi sul tuo account personale.

• È ora di completare il lab: ricorda che, una volta iniziato, non puoi metterlo in pausa.

Nota: utilizza solo l'account studente per questo lab. Se utilizzi un altro account Google Cloud, potrebbero essere addebitati costi su quell'account.

Come avviare il lab e accedere alla console Google Cloud

1. Fai clic sul pulsante Avvia lab. Se devi effettuare il pagamento per il lab, si aprirà una finestra di dialogo per permetterti di selezionare il metodo di pagamento. A sinistra, trovi il riquadro Dettagli lab con le seguenti informazioni:

   • Il pulsante Apri la console Google Cloud
   • Tempo rimanente
   • Credenziali temporanee da utilizzare per il lab
   • Altre informazioni per seguire questo lab, se necessario

2. Fai clic su Apri console Google Cloud (o fai clic con il tasto destro del mouse e seleziona Apri link in finestra di navigazione in incognito se utilizzi il browser Chrome).

   Il lab avvia le risorse e apre un'altra scheda con la pagina di accesso.

   Suggerimento: disponi le schede in finestre separate posizionate fianco a fianco.

   Nota: se visualizzi la finestra di dialogo Scegli un account, fai clic su Usa un altro account.

3. Se necessario, copia il Nome utente di seguito e incollalo nella finestra di dialogo di accesso.

   {{{user_0.username | "Username"}}}

   Puoi trovare il Nome utente anche nel riquadro Dettagli lab.

4. Fai clic su Avanti.

5. Copia la Password di seguito e incollala nella finestra di dialogo di benvenuto.

   {{{user_0.password | "Password"}}}

   Puoi trovare la Password anche nel riquadro Dettagli lab.

6. Fai clic su Avanti.

   Importante: devi utilizzare le credenziali fornite dal lab. Non utilizzare le credenziali del tuo account Google Cloud. Nota: utilizzare il tuo account Google Cloud per questo lab potrebbe comportare addebiti aggiuntivi.

7. Fai clic nelle pagine successive:

   • Accetta i termini e le condizioni.
   • Non inserire opzioni di recupero o l'autenticazione a due fattori, perché si tratta di un account temporaneo.
   • Non registrarti per le prove gratuite.

Dopo qualche istante, la console Google Cloud si apre in questa scheda.

Nota: per accedere ai prodotti e ai servizi Google Cloud, fai clic sul menu di navigazione o digita il nome del servizio o del prodotto nel campo Cerca.

Attiva Cloud Shell

Cloud Shell è una macchina virtuale in cui sono caricati strumenti per sviluppatori. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud. Cloud Shell fornisce l'accesso da riga di comando alle risorse Google Cloud.

1. Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud.

2. Fai clic nelle seguenti finestre:

   • Continua nella finestra delle informazioni di Cloud Shell.
   • Autorizza Cloud Shell a utilizzare le tue credenziali per effettuare chiamate API Google Cloud.

Quando la connessione è attiva, l'autenticazione è già avvenuta e il progetto è impostato sul tuo Project_ID, . L'output contiene una riga che dichiara il Project_ID per questa sessione:

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

gcloud è lo strumento a riga di comando di Google Cloud. È preinstallato su Cloud Shell e supporta il completamento tramite tasto Tab.

3. (Facoltativo) Puoi visualizzare il nome dell'account attivo con questo comando:

gcloud auth list

4. Fai clic su Autorizza.

Output:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facoltativo) Puoi elencare l'ID progetto con questo comando:

gcloud config list project

Output:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Nota: per la documentazione completa di gcloud, in Google Cloud, fai riferimento alla guida Panoramica dell'interfaccia a riga di comando gcloud.

Attività 1: scarica il codice sorgente

In questa attività scaricherai il codice sorgente per questo lab.

1. Per eseguire la configurazione, apri una nuova sessione in Cloud Shell ed esegui il comando seguente per impostare la tua zona :

gcloud config set compute/zone {{{project_0.default_zone}}}

2. Quindi copia il codice campione del lab:

gsutil cp gs://spls/gsp051/continuous-deployment-on-kubernetes.zip . unzip continuous-deployment-on-kubernetes.zip

3. Ora passa alla directory corretta:

cd continuous-deployment-on-kubernetes

Attività 2: esegui il provisioning di Jenkins

Crea un cluster Kubernetes e consenti a Jenkins di accedere al repository GitHub e a Google Container Registry.

Crea un cluster Kubernetes

1. Ora esegui il comando seguente per eseguire il provisioning di un cluster Kubernetes:

gcloud container clusters create jenkins-cd \ --num-nodes 2 \ --machine-type e2-standard-2 \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform"

Il completamento di questo passaggio può richiedere diversi minuti. Gli ambiti aggiuntivi consentono a Jenkins di accedere al repository GitHub e a Google Container Registry.

Fai clic su Controlla i miei progressi per verificare l'attività eseguita. Se hai creato correttamente un cluster Kubernetes, visualizzerai un punteggio di valutazione.

Crea un cluster Kubernetes (zona: )

2. Prima di continuare, verifica che il tuo cluster sia in esecuzione eseguendo questo comando:

gcloud container clusters list

Aggiungi le credenziali del cluster

1. Recupera le credenziali per il tuo cluster:

gcloud container clusters get-credentials jenkins-cd

2. Kubernetes Engine utilizza queste credenziali per accedere al cluster di cui è stato eseguito il provisioning di recente: verifica di poterti connettere al cluster eseguendo questo comando:

kubectl cluster-info

Attività 3: configura Helm

Helm è un gestore di pacchetti che semplifica la configurazione e il deployment delle applicazioni Kubernetes. Dopo aver installato Jenkins, puoi configurare la pipeline CI/CD.

In questa attività utilizzerai Helm per installare Jenkins dal repository Charts.

1. Aggiungi il repository di grafici stabile di Helm:

helm repo add jenkins https://charts.jenkins.io

2. Assicurati che il repository sia aggiornato:

helm repo update

Attività 4: installa e configura Jenkins

Durante l'installazione di Jenkins, è possibile utilizzare un file values come modello per fornire i valori necessari per la configurazione.

Utilizzerai un file values personalizzato per configurare automaticamente il tuo cloud Kubernetes e aggiungere i seguenti plug-in necessari:

• Kubernetes:latest
• Workflow-multibranch:latest
• Git:latest
• Configuration-as-code:latest
• Google-oauth-plugin:latest
• Google-source-plugin:latest
• Google-storage-plugin:latest

In questo modo, Jenkins può connettersi al tuo cluster e al tuo progetto Google Cloud.

1. Utilizza l'interfaccia a riga di comando di Helm per eseguire il deployment del grafico con le impostazioni di configurazione:

helm install cd jenkins/jenkins -f jenkins/values.yaml --wait

Il completamento di questo comando potrebbe richiedere un paio di minuti.

Fai clic su Controlla i miei progressi per verificare l'attività eseguita. Se hai configurato correttamente un grafico Jenkins, vedrai un punteggio di valutazione.

Configura e installa Jenkins

2. Una volta completato il comando, assicurati che il pod Jenkins passi allo stato Running e che il container sia nello stato PRONTO:

kubectl get pods

Output di esempio:

NAME READY STATUS RESTARTS AGE cd-jenkins-7c786475dd-vbhg4 2/2 Running 0 1m

3. Configura il service account Jenkins per poter eseguire il deployment nel cluster.

kubectl create clusterrolebinding jenkins-deploy --clusterrole=cluster-admin --serviceaccount=default:cd-jenkins

Dovrebbe essere restituito questo output:

clusterrolebinding.rbac.authorization.k8s.io/jenkins-deploy created

4. Esegui il comando seguente per configurare il port forwarding alla UI di Jenkins da Cloud Shell:

export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/component=jenkins-master" -l "app.kubernetes.io/instance=cd" -o jsonpath="{.items[0].metadata.name}") kubectl port-forward $POD_NAME 8080:8080 >> /dev/null &

5. Ora, controlla che il servizio Jenkins sia stato creato correttamente:

kubectl get svc

Output di esempio:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE cd-jenkins 10.35.249.67 8080/TCP 3h cd-jenkins-agent 10.35.248.1 50000/TCP 3h kubernetes 10.35.240.1 443/TCP 9h

Stai utilizzando il plug-in Kubernetes in modo che i nodi del builder vengano avviati automaticamente, se necessario, quando il master Jenkins li richiede. Al termine del loro lavoro, i nodi del builder vengono automaticamente disattivati e le relative risorse vengono aggiunte di nuovo al pool di risorse del cluster.

Tieni presente che questo servizio espone le porte 8080 e 50000 per tutti i pod corrispondenti a selector. In questo modo verranno esposte la UI web di Jenkins e le porte di registrazione del builder/agente all'interno del cluster Kubernetes. Inoltre, il servizio jenkins-ui viene esposto utilizzando un servizio ClusterIP in modo che quest'ultimo non sia accessibile dall'esterno del cluster.

Attività 5: collegati a Jenkins

Recupera la password amministratore e accedi all'interfaccia di Jenkins.

1. Il grafico di Jenkins crea automaticamente una password amministratore per te. Per recuperarla, esegui questo comando:

printf $(kubectl get secret cd-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

2. Per accedere all'interfaccia utente di Jenkins, fai clic su Anteprima web () Anteprima sulla porta 8080 nella barra delle azioni di Cloud Shell:

3. Se richiesto, accedi con il nome utente admin e la password generata automaticamente.

Ora Jenkins è configurato nel cluster Kubernetes. Jenkins gestisce le tue pipeline CI/CD automatizzate nelle sezioni successive.

Attività 6: comprendi l'applicazione

In questa attività, eseguirai il deployment dell'applicazione di esempio gceme nella pipeline di deployment continuo. L'applicazione è scritta nel linguaggio Go e si trova nella directory dell'app di esempio del repository. Quando esegui il programma binario gceme su un'istanza di Compute Engine, l'app visualizza i metadati dell'istanza in una scheda informativa.

L'applicazione imita un microservizio supportando due modalità operative.

• In modalità backend: gceme è in ascolto sulla porta 8080 e restituisce i metadati dell'istanza di Compute Engine in formato JSON.
• In modalità frontend: gceme esegue una query sul servizio gceme di backend ed esegue il rendering del JSON risultante nell'interfaccia utente.

Attività 7: esegui il deployment dell'applicazione

Esegui il deployment dell'applicazione in due ambienti diversi:

• Produzione: il sito pubblicato a cui gli utenti accedono.
• Canary: un sito con capacità inferiore che riceve solo una percentuale del traffico dei tuoi utenti. Utilizza questo ambiente per convalidare il software con il traffico in tempo reale prima che venga rilasciato a tutti gli utenti.

1. In Google Cloud Shell, vai alla directory dell'applicazione di esempio:

cd sample-app

2. Crea lo spazio dei nomi Kubernetes per isolare logicamente il deployment:

kubectl create ns production

3. Crea i deployment di produzione e canary e i servizi utilizzando i comandi kubectl apply:

kubectl apply -f k8s/production -n production kubectl apply -f k8s/canary -n production kubectl apply -f k8s/services -n production

Fai clic su Controlla i miei progressi per verificare l'attività eseguita. Se hai creato correttamente i deployment, vedrai un punteggio di valutazione.

Crea i deployment di produzione e canary

Per impostazione predefinita, viene eseguito il deployment di una sola replica del frontend. Usa il comando kubectl scale per assicurarti che siano in esecuzione almeno 4 repliche in ogni momento.

4. Fai lo scale up dei front-end dell'ambiente di produzione eseguendo il comando seguente:

kubectl scale deployment gceme-frontend-production -n production --replicas 4

5. Ora verifica di avere 5 pod in esecuzione per il frontend, 4 per il traffico di produzione e 1 per le versioni canary (le modifiche alla versione canary riguardano solo 1 utente su 5 (20%)):

kubectl get pods -n production -l app=gceme -l role=frontend

6. Conferma anche di avere 2 pod per il backend, 1 per la produzione e 1 per la versione canary:

kubectl get pods -n production -l app=gceme -l role=backend

7. Recupera l'IP esterno per i servizi di produzione:

kubectl get service gceme-frontend -n production Nota: potrebbero essere necessari diversi minuti prima che tu possa visualizzare l'indirizzo IP esterno del bilanciatore del carico.

Output di esempio:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE gceme-frontend LoadBalancer 10.79.241.131 104.196.110.46 80/TCP 5h

Incolla l'IP esterno in un browser per vedere la scheda informativa visualizzata su una scheda. Dovresti ottenere una pagina simile:

8. Ora, archivia l'IP del bilanciatore del carico del servizio frontend in una variabile di ambiente da utilizzare in seguito:

export FRONTEND_SERVICE_IP=$(kubectl get -o jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend)

9. Verifica che entrambi i servizi funzionino aprendo l'indirizzo IP esterno del frontend nel tuo browser

10. Controlla l'output della versione del servizio eseguendo il seguente comando (dovrebbe riportare 1.0.0):

curl http://$FRONTEND_SERVICE_IP/version

Hai eseguito il deployment dell'applicazione di esempio. Ora configurerai una pipeline per il deployment delle modifiche in modo continuo e affidabile.

Attività 8: crea la pipeline Jenkins

In questa attività, crea la pipeline Jenkins come segue:

• Crea un repository per ospitare il codice sorgente
• Aggiungi le credenziali per concedere a Jenkins l'accesso al repository di codice
• Configura Jenkins Cloud per Kubernetes
• Autentica Jenkins con il repository privato GitHub
• Crea il job Jenkins

Crea un repository per ospitare il codice sorgente dell'app di esempio

1. Crea una copia dell'app di esempio gceme ed eseguine il push in un repository GitHub:

In Cloud Shell, esegui questi comandi per configurare Git e GitHub:

curl -sS https://webi.sh/gh | sh gh auth login gh api user -q ".login" GITHUB_USERNAME=$(gh api user -q ".login") git config --global user.name "${GITHUB_USERNAME}" git config --global user.email "${USER_EMAIL}" echo ${GITHUB_USERNAME} echo ${USER_EMAIL}

• Premi INVIO per accettare le opzioni predefinite.
• Leggi le istruzioni nell'output comando per accedere a GitHub con un browser web.

Una volta eseguito l'accesso, il tuo nome utente GitHub viene visualizzato nell'output di Cloud Shell.

gh repo create default --private

Puoi ignorare l'avviso perché non ti viene addebitato alcun importo per questo repository.

git init

2. Inizializza la directory dell'app di esempio come suo repository Git:

git config credential.helper gcloud.sh

3. Esegui questo comando:

git remote add origin https://github.com/${GITHUB_USERNAME}/default

4. Aggiungi, esegui il commit e il push dei file:

git add . git commit -m "Initial commit" git push origin master

Aggiungi le credenziali del service account

Configura le tue credenziali per consentire a Jenkins di accedere al repository di codice. Jenkins utilizza le credenziali del service account del tuo cluster per scaricare il codice dal repository GitHub.

1. Nell'interfaccia utente di Jenkins, fai clic su Gestisci Jenkins nel riquadro di navigazione a sinistra, quindi fai clic su Sicurezza > Credenziali.

2. Fai clic su Sistema.

3. Fai clic su Credenziali globali (senza restrizioni).

4. Fai clic su Aggiungi credenziali nell'angolo in alto a destra.

5. Seleziona Service account Google da metadati dal menu a discesa Tipo.

6. Sotto il campo ID, inserisci l'ID progetto e fai clic su Crea.

Nota: "ID progetto" disponibile nella sezione dei dettagli della connessione del lab.

Le credenziali globali sono state aggiunte.

Configura Jenkins Cloud per Kubernetes

1. Nell'interfaccia utente di Jenkins, seleziona Gestisci Jenkins > Nodi.
2. Fai clic su Cloud nel riquadro di navigazione a sinistra.
3. Fai clic su Nuovo cloud.
4. Digita un nome in Nome cloud e seleziona Kubernetes per Tipo.
5. Fai clic su Crea.
6. Nel campo URL di Jenkins, inserisci il seguente valore: http://cd-jenkins:8080
7. Nel campo Tunnel Jenkins, inserisci il seguente valore: cd-jenkins-agent:50000
8. Fai clic su Salva.

Autentica Jenkins con un repository privato GitHub utilizzando una chiave SSH

Per autenticare Jenkins con un repository privato GitHub utilizzando una chiave SSH, segui questi passaggi:

a. Genera la chiave SSH

1. Crea una nuova chiave SSH GitHub, dove github-email è il tuo indirizzo email GitHub:

ssh-keygen -t rsa -b 4096 -N '' -f id_github -C [your-github-email]

2. Per scaricare la chiave privata(id_github) e la chiave pubblica(id_github.pub) dalla tua macchina locale, fai clic su Altro () nella barra delle azioni di Cloud Shell e seleziona la cartella continuous-deployment-on-kubernetes/sample-app.

b. Aggiungi la chiave pubblica a GitHub

Dopo aver generato la chiave SSH, devi aggiungere la chiave pubblica a GitHub in modo che Jenkins possa accedere ai tuoi repository.

1. Vai al tuo account GitHub. Fai clic sul tuo profilo GitHub e vai a Impostazioni.

2. Nel menu laterale, seleziona Chiavi SSH e GPG.

3. Fai clic su Nuova chiave SSH.

4. Inserisci il titolo SSH_KEY_LAB.

5. Incolla i contenuti della chiave pubblica (id_github.pub) scaricata dal percorso (~/continuous-deployment-on-kubernetes/sample-app/id_github.pub) nel campo Chiave. Puoi anche aggiungere un nome descrittivo nel campo Titolo.

6. Fai clic su Aggiungi chiave SSH.

c. Configura Jenkins per l'utilizzo della chiave SSH

1. Vai a Jenkins e seleziona Gestisci Jenkins dalla dashboard principale.

2. Seleziona l'opzione Credenziali.

3. In Archivio con ambito limitato a Jenkins, fai clic su Sistema.

4. Fai clic su Credenziali globali (senza restrizioni).

5. Fai clic su Aggiungi credenziali.

6. Nel menu a discesa Tipo, seleziona Nome utente SSH con chiave privata.

7. Per l'ID, inserisci _ssh_key.

8. In Nome utente, digita [il tuo nome utente GitHub].

9. Scegli Inserisci direttamente per la chiave privata e fai clic su Aggiungi. Incolla il contenuto del file id_github (scaricato da ~/continuous-deployment-on-kubernetes/sample-app/id_github).

10. Fai clic su Crea.

d. Aggiungi la chiave SSH pubblica agli host noti

In Cloud Shell, crea un file denominato known_hosts.github e aggiungi la chiave SSH pubblica a questo file.

ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github cat known_hosts.github Nota: se visualizzi errori in Cloud Shell, premi CTRL+C ed esegui il comando riportato sopra.

e. Configura la chiave dell'host nota

1. Fai clic su Dashboard > Gestisci Jenkins nel riquadro a sinistra.

2. Nella sezione Sicurezza. Fai clic su Sicurezza.

3. In Configurazione della verifica della chiave GitHost, per Strategia di verifica della chiave host, seleziona Chiavi fornite manualmente dal menu a discesa.

4. Incolla i contenuti del file known hosts.github in Chiavi host approvate.

5. Fai clic su Salva.

Crea il job Jenkins

Accedi all'interfaccia utente di Jenkins e segui questi passaggi per configurare un job di pipeline.

1. Fai clic su Dashboard > Nuovo elemento nel riquadro a sinistra.

2. Assegna al progetto il nome sample-app, quindi scegli l'opzione Pipeline multi-branch e fai clic su Ok.

3. Nella pagina successiva, nella sezione Origini branch, seleziona Git dal menu a discesa Aggiungi origine.

4. Incolla l'URL clone HTTPS del repository dell'app di esempio nel campo Repository progetto. Sostituisci ${GITHUB_USERNAME} con il tuo nome utente GitHub:

git@github.com:${GITHUB_USERNAME}/default.git

5. Dalle opzioni di menu Credenziali, seleziona il nome delle credenziali GitHub.

6. Nella sezione Trigger scansione della pipeline multi-branch seleziona Eseguita periodicamente se non altrimenti e imposta il valore Intervallo su 1 minute.

7. Lascia invariate le impostazioni predefinite per tutte le altre opzioni e fai clic su Salva.

Dopo aver completato questi passaggi, viene eseguito un job denominato Branch indexing. Questo meta-job identifica i rami nel tuo repository e garantisce che le modifiche non siano avvenute nei rami esistenti. Se fai clic su sample-app in alto a sinistra, dovresti vedere il job master.

Nota: la prima esecuzione del job master potrebbe non riuscire finché non si apportano alcune modifiche al codice nel passaggio successivo.

Hai creato una pipeline Jenkins. Ora creerai l'ambiente di sviluppo per l'integrazione continua.

Attività 9: crea l'ambiente di sviluppo

I rami di sviluppo sono un insieme di ambienti utilizzati dagli sviluppatori per testare le modifiche al codice prima di inviarle per l'integrazione nel sito pubblicato. Questi ambienti sono versioni dell'applicazione di cui è stato fatto lo scale down, ma di cui è necessario eseguire il deployment utilizzando gli stessi meccanismi dell'ambiente live.

Crea un branch di sviluppo

Per creare un ambiente di sviluppo da un branch di funzionalità, puoi eseguire il push del ramo al server Git e consentire a Jenkins di eseguire il deployment del tuo ambiente.

Nota: se visualizzi errori in Cloud Shell, premi Ctrl+C ed esegui il comando riportato di seguito.

• Crea un ramo di sviluppo ed eseguine il push al server Git:

git checkout -b new-feature

Modifica la definizione della pipeline

Il file Jenkinsfile che definisce la pipeline viene scritto utilizzando la sintassi Groovy per la pipeline Jenkins. L'utilizzo di un file Jenkinsfile consente di esprimere un'intera pipeline di build in un unico file che si trova insieme al codice sorgente. Le pipeline supportano funzionalità avanzate come il caricamento in contemporanea e richiedono l'approvazione manuale dell'utente.

Affinché la pipeline funzioni come previsto, devi modificare il file Jenkinsfile per impostare l'ID progetto.

1. Apri il file Jenkinsfile nell'editor del terminale, ad esempio vi:

vi Jenkinsfile

2. Avvia l'editor:

i

3. Aggiungi PROJECT_ID al valore REPLACE_WITH_YOUR_PROJECT_ID. PROJECT_ID è l'ID del tuo progetto disponibile nella sezione CONNECTION DETAILS del lab. Puoi inoltre eseguire il comando gcloud config get-value project per trovarlo.

4. Modifica il valore di CLUSTER_ZONE in . Puoi ottenere questo valore eseguendo gcloud config get compute/zone.

PROJECT = "REPLACE_WITH_YOUR_PROJECT_ID" APP_NAME = "gceme" FE_SVC_NAME = "${APP_NAME}-frontend" CLUSTER = "jenkins-cd" CLUSTER_ZONE = "{{{project_0.default_zone}}}" IMAGE_TAG = "gcr.io/${PROJECT}/${APP_NAME}:${env.BRANCH_NAME}.${env.BUILD_NUMBER}" JENKINS_CRED = "${PROJECT}"

5. Salva il file Jenkinsfile: poi premi Esc (per gli utenti vi):

:wq

Modifica il sito

Per dimostrare la modifica dell'applicazione, cambierai le schede gceme da blu ad arancione.

1. Apri html.go:

vi html.go

2. Avvia l'editor:

i

3. Modifica le due istanze di <div class="card blue"> nel seguente modo:

<div class="card orange">

4. Salva il file html.go: premi Esc, quindi:

:wq

5. Apri main.go:

vi main.go

6. Avvia l'editor:

i

7. La versione è definita in questa riga:

const version string = "1.0.0"

Aggiornala come segue:

const version string = "2.0.0"

8. Salva il file main.go ancora una volta: Esc, quindi:

:wq

Attività 10: avvia il deployment

In questa attività eseguirai il deployment dell'ambiente di sviluppo.

1. Esegui il commit e il push delle modifiche:

git add Jenkinsfile html.go main.go git commit -m "Version 2.0.0" git push origin new-feature

In questo modo viene avviata una build del tuo ambiente di sviluppo.

Dopo il push della modifica al repository Git, vai all'interfaccia utente di Jenkins dove puoi vedere che la tua build è stata avviata per il ramo new-feature. L'acquisizione delle modifiche può richiedere fino a un minuto.

2. Una volta che la build è in esecuzione, fai clic sulla freccia giù accanto alla build nel riquadro di navigazione a sinistra e seleziona Output console:

3. Tieni traccia dell'output della build per alcuni minuti e osserva i messaggi kubectl --namespace=new-feature apply... per iniziare. Il deployment del branch new-feature è stato eseguito nel cluster.

Nota: in uno scenario di sviluppo, non utilizzeresti un bilanciatore del carico rivolto al pubblico. Per proteggere la tua applicazione, puoi utilizzare kubectl proxy. Il proxy si autentica con l'API Kubernetes e indirizza le richieste dalla tua macchina locale al servizio nel cluster senza esporre il tuo servizio a internet.

Se non hai visto nulla in Build Executor, non preoccuparti. Vai alla home page di Jenkins > app di esempio. Verifica che la pipeline new-feature sia stata creata.

4. Una volta che tutto è risolto, avvia il proxy in background:

kubectl proxy &

5. Se si blocca, premi Ctrl + C per uscire. Verifica che la tua applicazione sia accessibile inviando una richiesta a localhost e lasciando che il proxy kubectl la inoltri al tuo servizio:

curl \ http://localhost:8001/api/v1/namespaces/new-feature/services/gceme-frontend:80/proxy/version

Dovresti vedere la risposta con 2.0.0, che è la versione attualmente in esecuzione.

Se ricevi un errore simile:

{ "kind": "Status", "apiVersion": "v1", "metadata": { }, "status": "Failure", "message": "no endpoints available for service \"gceme-frontend:80\"", "reason": "ServiceUnavailable", "code": 503

6. Significa che il tuo endpoint frontend non si è ancora propagato, aspetta un po' e prova il comando curl di nuovo. Vai avanti quando ottieni il seguente output:

2.0.0

Hai configurato l'ambiente di sviluppo. Ora metterai in pratica ciò che hai imparato nel modulo precedente eseguendo il deployment di una versione canary per testare una nuova funzionalità.

Fai clic su Controlla i miei progressi per verificare l'attività eseguita. Se hai avviato correttamente la compilazione per il branch new-feature, visualizzerai un punteggio di valutazione.

Crea per il branch new-feature

Attività 11: esegui il deployment di una versione canary

Hai verificato che nella tua app sia in esecuzione il codice più recente nell'ambiente di sviluppo, quindi ora puoi eseguire il deployment di quel codice nell'ambiente canary.

1. Crea un branch canary ed eseguine il push al server Git:

git checkout -b canary git push origin canary

2. In Jenkins, dovresti vedere che la pipeline canary è stata avviata. Al termine, puoi controllare l'URL del servizio per assicurarti che la nuova versione gestisca parte del traffico. Dovresti vedere che circa una richiesta su cinque (senza un ordine particolare) restituisce la versione 2.0.0.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Se vedi ancora 1.0.0, prova a eseguire nuovamente i comandi riportati sopra. Dopo aver verificato che quanto sopra funziona, termina il comando con Ctrl + C.

Ecco fatto. Hai eseguito il deployment di una versione canary. Ora eseguirai il deployment della nuova versione in produzione.

Fai clic su Controlla i miei progressi per verificare l'attività eseguita. Se hai eseguito correttamente il deployment della versione canary, visualizzerai un punteggio di valutazione.

Esegui il deployment di una versione canary

Attività 12: esegui il deployment in produzione

Ora che la versione canary è andata a buon fine e non hai ricevuto reclami da parte dei clienti, esegui il deployment del resto del parco risorse di produzione.

1. Crea un branch canary ed eseguine il push al server Git:

git checkout master git merge canary git push origin master

In Jenkins, dovresti vedere che la pipeline principale è stata avviata.

Fai clic su Controlla i miei progressi per verificare l'attività eseguita. Se hai avviato correttamente la pipeline principale, visualizzerai un punteggio di valutazione.

Esegui il deployment in produzione

2. Al termine (l'operazione potrebbe richiedere alcuni minuti), puoi controllare l'URL del servizio per assicurarti che la nuova versione 2.0.0 gestisca tutto il traffico.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Ancora una volta, se vedi istanze 1.0.0, prova a eseguire nuovamente i comandi riportati sopra. Per interrompere questo comando, premi Ctrl+C.

Output di esempio:

gcpstaging9854_student@qwiklabs-gcp-df93aba9e6ea114a:~/continuous-deployment-on-kubernetes/sample-app$ while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 ^C

Puoi anche accedere al sito in cui l'applicazione gceme visualizza le schede informative. Il colore della scheda è cambiato da blu ad arancione.

4. Ecco di nuovo il comando per recuperare l'indirizzo IP esterno. Incolla l'IP esterno in una nuova scheda per visualizzare la scheda informativa:

kubectl get service gceme-frontend -n production

Output di esempio:

Attività 13: verifica le tue conoscenze

Di seguito, sono riportate alcune domande a scelta multipla che servono a consolidare la tua conoscenza dei concetti di questo lab. Rispondi alle domande al meglio delle tue capacità.

È tutto.

Ottimo lavoro, hai eseguito il deployment dell'applicazione in produzione.

Complimenti!

Il lab relativo al deployment e all'utilizzo di Jenkins su Kubernetes Engine per abilitare una pipeline di distribuzione continua/deployment continuo è terminato. Hai avuto l'opportunità di eseguire il deployment di uno strumento DevOps significativo in Kubernetes Engine e di configurarlo per l'uso in produzione. Hai lavorato con lo strumento a riga di comando kubectl e con le configurazioni di deployment nei file YAML, oltre ad aver imparato qualcosa sulla configurazione delle pipeline Jenkins per un processo di sviluppo/deployment. Grazie a questa esperienza pratica, dovresti sentirti a tuo agio nell'utilizzare questi strumenti nel tuo ambiente DevOps.

Prossimi passi/Scopri di più

• Scopri di più sulla soluzione Jenkins in Kubernetes Engine.
• Scopri come utilizzare Jenkins per abilitare la distribuzione continua su Kubernetes Engine.
• Scopri di più sulle guide e soluzioni DevOps nella documentazione di Google Cloud.
• Connettiti con la community di Jenkins.

Formazione e certificazione Google Cloud

… per utilizzare al meglio le tecnologie Google Cloud. I nostri corsi ti consentono di sviluppare competenze tecniche e best practice per aiutarti a metterti subito al passo e avanzare nel tuo percorso di apprendimento. Offriamo vari livelli di formazione, dal livello base a quello avanzato, con opzioni di corsi on demand, dal vivo e virtuali, in modo da poter scegliere il più adatto in base ai tuoi impegni. Le certificazioni ti permettono di confermare e dimostrare le tue abilità e competenze relative alle tecnologie Google Cloud.

Ultimo aggiornamento del manuale: 10 giugno 2024

Ultimo test del lab: 10 giugno 2024

Copyright 2025 Google LLC. Tutti i diritti riservati. Google e il logo Google sono marchi di Google LLC. Tutti gli altri nomi di società e prodotti sono marchi delle rispettive società a cui sono associati.