Panoramica

In questo lab realizzerai una pipeline CI/CD che crea automaticamente un'immagine container dal codice dopo il commit, archivia l'immagine in Container Registry, aggiorna un manifest Kubernetes in un repository Git ed esegue il deployment dell'applicazione in Google Kubernetes Engine utilizzando questo manifest.

Per questo lab creerai 2 repository Git:

• Repository app: contiene il codice sorgente dell'applicazione stessa
• Repository env: contiene i file manifest per il deployment in Kubernetes

Quando esegui il push di una modifica nel repository app, la pipeline di Cloud Build esegue i test, crea un'immagine container e la invia ad Artifact Registry. Dopo aver eseguito il push dell'immagine, Cloud Build aggiorna il manifest del deployment e lo invia al repository env. Questo attiva un'altra pipeline di Cloud Build che applica il manifest al cluster GKE e, se l'operazione ha esito positivo, lo archivia in un altro ramo del repository env.

Manteniamo separati i repository app ed env perché hanno cicli di vita e utilizzi diversi. Gli utenti principali del repository app sono persone reali e questo repository è dedicato a un'applicazione specifica. Gli utenti principali del repository env sono sistemi automatici (come Cloud Build) e questo repository potrebbe essere condiviso da diverse applicazioni. Il repository env può avere vari rami, ciascuno con mappatura su un ambiente specifico (in questo lab utilizzi solo l'ambiente di produzione) e con riferimento a una specifica immagine container, al contrario del repository app.

Al termine del lab avrai un sistema in cui è facile:

• distinguere i deployment non riusciti e quelli riusciti esaminando la cronologia di Cloud Build;
• accedere al manifest attualmente in uso esaminando il ramo production del repository env;
• eseguire il rollback a qualsiasi versione precedente mediante una nuova esecuzione della build di Cloud Build corrispondente.

Nota: questo lab utilizza Cloud Build per eseguire le pipeline, ma esistono altri strumenti di automazione diffusi che potrebbero servire come alternative, come Spinnaker e Jenkins. Al momento, alcuni di questi altri strumenti offrono un supporto superiore per deployment blu/verde, analisi canary e funzionalità simili che potrebbero essere necessarie nelle implementazioni CI/CD più avanzate.

Obiettivi

In questo lab imparerai a:

• creare cluster Kubernetes Engine;
• creare Cloud Source Repositories;
• attivare Cloud Build da Cloud Source Repositories;
• automatizzare i test e pubblicare un'immagine container di cui è possibile eseguire il deployment tramite Cloud Build;
• gestire le risorse di cui è stato eseguito il deployment in un cluster Kubernetes Engine mediante Cloud Build.

Configurazione e requisiti

Accedi a Qwiklabs

Per ciascun lab, riceverai un nuovo progetto Google Cloud e un insieme di risorse per un periodo di tempo limitato senza alcun costo aggiuntivo.

1. Accedi a Qwiklabs utilizzando una finestra di navigazione in incognito.

2. Tieni presente la durata dell'accesso al lab (ad esempio, 1:15:00) e assicurati di finire entro quell'intervallo di tempo.
   Non è disponibile una funzionalità di pausa. Se necessario, puoi riavviare il lab ma dovrai ricominciare dall'inizio.

3. Quando è tutto pronto, fai clic su Inizia lab.

4. Annota le tue credenziali del lab (Nome utente e Password). Le userai per accedere a Google Cloud Console.

5. Fai clic su Apri console Google.

6. Fai clic su Utilizza un altro account e copia/incolla le credenziali per questo lab nei prompt.
   Se utilizzi altre credenziali, compariranno errori oppure ti verranno addebitati dei costi.

7. Accetta i termini e salta la pagina di ripristino delle risorse.

Una volta completati i passaggi di accesso iniziali, viene visualizzata la dashboard del progetto.

Attiva Google Cloud Shell

Google 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.

Google Cloud Shell fornisce l'accesso da riga di comando alle risorse Google Cloud.

1. Nella barra degli strumenti in alto a destra della console Cloud, fai clic sul pulsante Apri Cloud Shell.

   

2. Fai clic su Continua.

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Quando la connessione è attiva, l'autenticazione è già avvenuta e il progetto è impostato sul tuo PROJECT_ID. Ad esempio:

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

• Puoi visualizzare il nome dell'account attivo con questo comando:

gcloud auth list

Output:

Credentialed accounts: - @.com (active)

Output di esempio:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Puoi elencare l'ID progetto con questo comando:

gcloud config list project

Output:

[core] project =

Output di esempio:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: la documentazione completa di gcloud è disponibile nella guida Panoramica dell'interfaccia a riga di comando gcloud .

Attività 1: inizializza il lab

In questa attività preparerai il progetto Google Cloud per l'utilizzo. Dovrai abilitare le API richieste, inizializzare la configurazione Git in Cloud Shell e scaricare il codice campione utilizzato nel lab in un secondo momento.

1. In Cloud Shell, esegui questo comando per abilitare le API per GKE, Cloud Build, Cloud Source Repositories e Container Analysis:

gcloud services enable container.googleapis.com \ cloudbuild.googleapis.com \ sourcerepo.googleapis.com \ containeranalysis.googleapis.com

2. Crea un repository Docker in Artifact Registry denominato my-repository nella regione per archiviare le tue immagini container:

gcloud artifacts repositories create my-repository \ --repository-format=docker \ --location={{{project_0.default_region | REGION}}}

3. In Cloud Shell, crea un cluster GKE che utilizzerai per eseguire il deployment dell'applicazione di esempio di questo lab:

gcloud container clusters create hello-cloudbuild \ --num-nodes 1 --region {{{project_0.default_region | REGION}}}

4. Se non hai mai utilizzato Git in Cloud Shell, configuralo con il tuo nome e indirizzo email:

git config --global user.email "you@example.com" git config --global user.name "Your Name"

Git li utilizzerà per identificarti come autore dei commit che creerai in Cloud Shell.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Inizializza il lab

Attività 2: crea i repository Git in Cloud Source Repositories

In questa attività creerai i due repository Git (hello-cloudbuild-app e hello-cloudbuild-env) utilizzati nel lab e inizializzerai hello-cloudbuild-app con del codice campione.

1. In Cloud Shell, crea i due repository Git:

gcloud source repos create hello-cloudbuild-app gcloud source repos create hello-cloudbuild-env

2. Clona il repository hello-cloudbuild-app.

PROJECT_ID=$(gcloud config get-value project) gcloud source repos clone hello-cloudbuild-app --project=$PROJECT_ID

3. Per copiare il codice campione da Cloud Storage ed estrarre i contenuti dall'archivio nella tua home directory, esegui questi comandi:

cd ~ gcloud storage cp gs://cloud-training/gke-gitops/hello-cloudbuild-app.zip ~ && unzip ~/hello-cloudbuild-app.zip -d ~ && rm ~/hello-cloudbuild-app.zip

3. Configura Cloud Source Repositories come repository remoto:

cd ~/hello-cloudbuild-app REGION={{{project_0.default_region | REGION}}} sed -i s/us-central1/$REGION/g cloudbuild.yaml sed -i s/us-central1/$REGION/g cloudbuild-trigger-cd.yaml sed -i s/us-central1/$REGION/g cloudbuild-delivery.yaml sed -i s/us-central1/$REGION/g kubernetes.yaml.tpl git init git add . git commit -m "first commit" git remote add google \ "https://source.developers.google.com/p/${PROJECT_ID}/r/hello-cloudbuild-app"

Il codice appena clonato contiene una semplice applicazione "Hello World":

from flask import Flask app = Flask('hello-cloudbuild') @app.route('/') def hello(): return "Hello World!\n" if __name__ == '__main__': app.run(host = '0.0.0.0', port = 8080)

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea i repository Git in Cloud Source Repositories

Attività 3: crea un'immagine container con Cloud Build

Il codice clonato contiene già il Dockerfile seguente:

FROM python:3.7-slim RUN pip install flask WORKDIR /app COPY app.py /app/app.py ENTRYPOINT ["python"] CMD ["/app/app.py"]

Con questo Dockerfile puoi creare un'immagine container con Cloud Build e archiviarla in Container Registry.

1. In Cloud Shell, crea una build di Cloud Build basata sull'ultimo commit con il comando seguente:

cd ~/hello-cloudbuild-app COMMIT_ID="$(git rev-parse --short=7 HEAD)" gcloud builds submit --tag="{{{project_0.default_region | REGION}}}-docker.pkg.dev/${PROJECT_ID}/my-repository/hello-cloudbuild:${COMMIT_ID}" .

Quando esegui questo comando, Cloud Build trasmette il flusso dei log generati dalla creazione dell'immagine container al tuo terminale.

2. Al termine della build, nella console Google Cloud vai ad Artifact Registry > Repository e verifica che la nuova immagine container sia effettivamente disponibile in Artifact Registry.

3. Fai clic su Il mio repository.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea un'immagine container con Cloud Build

Attività 4: crea la pipeline di integrazione continua (CI)

In questa attività configurerai Cloud Build in modo che esegua automaticamente un piccolo test delle unità, crei l'immagine container e quindi ne esegua il push in Container Registry. Il push di un nuovo commit in Cloud Source Repositories avvia automaticamente questa pipeline. Il file cloudbuild.yaml già incluso nel codice è la configurazione della pipeline.

1. Nella console Google Cloud, vai a Cloud Build > Trigger.
2. Fai clic su Crea trigger.
3. Nel campo Nome, digita hello-cloudbuild.
4. In Evento, seleziona Push al ramo.
5. In Origine, seleziona hello-cloudbuild-app come Repository e digita ^master$ come Ramo.
6. In Configurazione build, seleziona File di configurazione di Cloud Build.
7. Nel campo Posizione file di configurazione Cloud Build, digita cloudbuild.yaml dopo il carattere /.
8. Per Service account, seleziona il service account che inizia con il tuo ID progetto e dall'aspetto simile a (@.iam.gserviceaccount.com).
9. Fai clic su Crea.

Dopo aver creato il trigger, torna a Cloud Shell. Ora devi eseguire il push del codice dell'applicazione in Cloud Source Repositories per attivare la pipeline CI in Cloud Build.

10. Per avviare il trigger, esegui questo comando:

cd ~/hello-cloudbuild-app git push google master

11. Nella console Google Cloud, vai a Cloud Build > Dashboard.

Dovresti vedere una build in esecuzione o completata di recente.

Puoi fare clic sulla build per seguirne l'esecuzione ed esaminare i relativi log.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea la pipeline di integrazione continua (CI)

Attività 5: crea l'ambiente di test e la pipeline CD

Cloud Build viene utilizzato anche per la pipeline di distribuzione continua. La pipeline viene eseguita per ogni push di un commit al ramo candidate del repository __hello-cloudbuild-env__. La pipeline applica la nuova versione del manifest al cluster Kubernetes e, in caso di esito positivo, copia il manifest nel ramo production. Questo processo ha le seguenti proprietà:

• Il ramo candidate rappresenta una cronologia dei tentativi di deployment.
• Il ramo production rappresenta una cronologia dei deployment riusciti.
• Puoi visualizzare i deployment riusciti e non riusciti in Cloud Build.
• Puoi eseguire il rollback a qualsiasi deployment precedente eseguendo di nuovo la build corrispondente in Cloud Build. Un rollback aggiorna anche il ramo production in modo che riporti fedelmente la cronologia dei deployment.

Dovrai modificare la pipeline di integrazione continua per aggiornare il ramo candidate del repository hello-cloudbuild-env e attivare così la pipeline di distribuzione continua.

Concedi a Cloud Build l'accesso a GKE

Per eseguire il deployment dell'applicazione nel cluster Kubernetes, Cloud Build deve disporre del ruolo Kubernetes Engine Developer di Identity and Access Management.

• In Cloud Shell, esegui questo comando:

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} --format='get(projectNumber)')" gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com \ --role=roles/container.developer

Inizializza il repository hello-cloudbuild-env

Devi inizializzare il repository hello-cloudbuild-env con due rami (production e candidate) e un file di configurazione di Cloud Build che descrive il processo di deployment.

Il primo passaggio consiste nel clonare il repository hello-cloudbuild-env e creare il ramo production. È ancora vuoto.

1. In Cloud Shell, esegui questo comando:

cd ~ gcloud source repos clone hello-cloudbuild-env cd ~/hello-cloudbuild-env git checkout -b production

2. Successivamente, devi copiare il file cloudbuild-delivery.yaml disponibile nel repository hello-cloudbuild-app ed eseguire il commit della modifica:

cd ~/hello-cloudbuild-env cp ~/hello-cloudbuild-app/cloudbuild-delivery.yaml ~/hello-cloudbuild-env/cloudbuild.yaml git add . git commit -m "Create cloudbuild.yaml for deployment" Nota: il file cloudbuild-delivery.yaml descrive il processo di deployment da eseguire in Cloud Build.

Prevede due passaggi:

• Cloud Build applica il manifest al cluster GKE.
• In caso di esito positivo, Cloud Build copia il manifest nel ramo production.

3. Crea un ramo candidate ed esegui il push di entrambi i rami per renderli disponibili in Cloud Source Repositories:

git checkout -b candidate git push origin production git push origin candidate

4. Concedi il ruolo IAM Source Repository Writer al service account Cloud Build per il repository hello-cloudbuild-env:

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} \ --format='get(projectNumber)')" cat >/tmp/hello-cloudbuild-env-policy.yaml <<EOF bindings: - members: - serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com role: roles/source.writer EOF gcloud source repos set-iam-policy \ hello-cloudbuild-env /tmp/hello-cloudbuild-env-policy.yaml

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Concedi i ruoli IAM Kubernetes Engine Developer e Source Repository Writer a Cloud Build

Crea il trigger per la pipeline di distribuzione continua

1. Nella console Google Cloud, vai a Cloud Build > Trigger.
2. Fai clic su Crea trigger.
3. Nel campo Nome, digita hello-cloudbuild-deploy.
4. In Evento, seleziona Push al ramo.
5. In Origine, seleziona hello-cloudbuild-env come Repository e ^candidate$ come Ramo.
6. In Configurazione build, seleziona File di configurazione di Cloud Build.
7. Nel campo Posizione file di configurazione Cloud Build, digita cloudbuild.yaml dopo il carattere /.
8. Per Service account, seleziona il service account che inizia con il tuo ID progetto e dall'aspetto simile a (@.iam.gserviceaccount.com).
9. Fai clic su Crea.

Modifica la pipeline di integrazione continua per attivare la pipeline di distribuzione continua

In questa sezione aggiungerai alla pipeline di integrazione continua alcuni passaggi che genereranno una nuova versione del manifest Kubernetes e ne eseguiranno il push al repository __hello-cloudbuild-env__ per attivare la pipeline di distribuzione continua.

1. Copia la versione estesa del file cloudbuild.yaml per il repository app:

cd ~/hello-cloudbuild-app cp cloudbuild-trigger-cd.yaml cloudbuild.yaml

cloudbuild-trigger-cd.yaml è una versione estesa del file cloudbuild.yaml. Aggiunge i passaggi seguenti, che generano il nuovo manifest Kubernetes e attivano la pipeline di distribuzione continua.

Nota: questa pipeline utilizza un semplice comando sed per eseguire il rendering del template di manifest. In realtà, potrai trarre vantaggio dall'utilizzo di uno strumento dedicato, come kustomize o skaffold, che offre un maggiore controllo sul rendering dei template di manifest.

2. Esegui il commit delle modifiche e inviale a Cloud Source Repositories:

cd ~/hello-cloudbuild-app git add cloudbuild.yaml git commit -m "Trigger CD pipeline" git push google master

In questo modo viene attivata la pipeline di integrazione continua in Cloud Build.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea il trigger per la pipeline di distribuzione continua

Attività 6: esamina la pipeline di Cloud Build

1. Nella console Google Cloud, vai a Cloud Build > Dashboard.
2. Fai clic sul trigger hello-cloudbuild-app per seguirne l'esecuzione ed esaminare i relativi log.

L'ultimo passaggio di questa pipeline esegue il push del nuovo manifest al repository hello-cloudbuild-env, attivando la pipeline di distribuzione continua.

3. Torna alla Dashboard principale.
4. Dovresti vedere una build in esecuzione o terminata di recente per il repository hello-cloudbuild-env. Puoi fare clic sulla build per seguirne l'esecuzione ed esaminare i relativi log.

Attività 7: testa la pipeline completa

La pipeline CI/CD completa è ora configurata. In questa sezione, dovrai eseguirne il test dall'inizio alla fine.

1. Nella console Google Cloud, vai a Kubernetes Engine > Gateway, servizi e Ingress.

2. Seleziona Servizi nel menu in alto

Nell'elenco dovrebbe essere presente un solo servizio chiamato hello-cloudbuild. È stato creato dalla build di distribuzione continua appena eseguita.

3. Fai clic sull'endpoint per il servizio hello-cloudbuild.

Dovrebbe essere visualizzato "Hello World!". In assenza di un endpoint o se visualizzi un errore del bilanciatore del carico, potresti dover attendere qualche minuto per l'inizializzazione completa del bilanciatore del carico. Se necessario, fai clic su Aggiorna per aggiornare la pagina.

4. In Cloud Shell, sostituisci "Hello World" con "Hello Cloud Build", sia nell'applicazione sia nel test delle unità:

cd ~/hello-cloudbuild-app sed -i 's/Hello World/Hello Cloud Build/g' app.py sed -i 's/Hello World/Hello Cloud Build/g' test_app.py

5. Esegui il commit e il push della modifica in Cloud Source Repositories:

git add app.py test_app.py git commit -m "Hello Cloud Build" git push google master

6. Questo attiva la pipeline CI/CD completa.

Dopo qualche minuto, ricarica l'applicazione nel browser. A questo punto dovresti vedere "Hello Cloud Build!".

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Testa la pipeline completa

Attività 8: testa il rollback

In questa attività eseguirai il rollback alla versione dell'applicazione che visualizzava "Hello World!".

1. Nella console Google Cloud, vai a Cloud Build > Dashboard.

2. Fai clic sul link Visualizza tutto in Cronologia build per il repository hello-cloudbuild-env.

3. Fai clic sulla penultima delle build disponibili.

4. Fai clic su Riprova a eseguire la build.

5. Al termine della build, ricarica l'applicazione nel browser.

Ora dovresti vedere di nuovo "Hello World!".

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Testa il rollback

Termina il lab

Una volta completato il lab, fai clic su Termina lab. Google Cloud Skills Boost rimuove le risorse che hai utilizzato ed esegue la pulizia dell'account.

Avrai la possibilità di inserire una valutazione in merito alla tua esperienza. Seleziona il numero di stelle applicabile, inserisci un commento, quindi fai clic su Invia.

Il numero di stelle corrisponde alle seguenti valutazioni:

• 1 stella = molto insoddisfatto
• 2 stelle = insoddisfatto
• 3 stelle = esperienza neutra
• 4 stelle = soddisfatto
• 5 stelle = molto soddisfatto

Se non vuoi lasciare un feedback, chiudi la finestra di dialogo.

Per feedback, suggerimenti o correzioni, utilizza la scheda Assistenza.

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.