Sviluppare ed eseguire il deployment di app containerizzate utilizzando una pipeline CI/CD

Last reviewed 2022-11-18 UTC

Questa guida al deployment descrive come configurare e utilizzare un sistema di sviluppo, integrazione continua (CI) e distribuzione continua (CD) utilizzando un insieme integrato di strumenti Google Cloud. Puoi utilizzare questo sistema per sviluppare ed eseguire il deployment di applicazioni in Google Kubernetes Engine (GKE).

Questa guida illustra come creare l'architettura descritta nella pipeline di deployment per lo sviluppo e la distribuzione di app containerizzate.

Questa guida al deployment è rivolta sia agli sviluppatori software sia agli operatori. e, man mano che la completi, svolgi i seguenti ruoli:

  • Innanzitutto, agisci come operatore per configurare la pipeline CI/CD. I componenti principali di questa pipeline sono Cloud Build, Artifact Registry e Cloud Deploy.
  • Poi agisci come sviluppatore per modificare un'applicazione utilizzando Cloud Code. Quando agisci in qualità di sviluppatore, vedi l'esperienza integrata offerta da questa pipeline.
  • Infine, agisci come operatore ed esegui i passaggi per eseguire il deployment di un'applicazione in produzione.

Questa guida al deployment presuppone che tu abbia dimestichezza con l'esecuzione di comandi gcloud su Google Cloud e con il deployment di container di applicazioni in GKE.

Architettura

Il seguente diagramma mostra le risorse utilizzate in questa guida al deployment:

Sviluppare ed eseguire il deployment di un sistema con Cloud Code, Cloud Build, Artifact Registry, Cloud Deploy e GKE

Per informazioni dettagliate sui componenti utilizzati in questa architettura, consulta la pipeline di deployment per lo sviluppo e l'implementazione di app containerizzate.

Obiettivi

In qualità di operatore, svolgi le seguenti operazioni:

  • Configura la pipeline CI e la pipeline CD. Questa configurazione include quanto segue:
    • Configura le autorizzazioni richieste.
    • Crea i cluster GKE per gli ambienti di staging e produzione.
    • Crea un repository in Cloud Source Repositories per il codice sorgente.
    • Crea un repository in Artifact Registry per il contenitore dell'applicazione.
    • Crea un trigger di Cloud Build nel repository GitHub principale.
    • Crea una pipeline di distribuzione e i target di Cloud Deploy. I target sono l'ambiente di gestione temporanea e di produzione.
  • Avvia il processo CI/CD per eseguire il deployment nell'ambiente di staging e poi la promozione in produzione.

In qualità di sviluppatore, apporti una modifica all'applicazione. Per farlo, segui questi passaggi:

  • Clona il repository per lavorare con un ambiente di sviluppo preconfigurato.
  • Apporta una modifica all'applicazione all'interno dell'area di lavoro dello sviluppatore.
  • Crea e testa la modifica. I test includono un test di convalida per la governance.
  • Visualizza e convalida la modifica in un cluster di sviluppo. Questo cluster viene eseguito su minikube.
  • Esegui il commit della modifica nel repository principale.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Make sure that billing is enabled for your Google Cloud project.

  3. Enable the Artifact Registry, Cloud Build, Cloud Deploy, Cloud Source Repositories, Google Kubernetes Engine, Resource Manager, and Service Networking APIs.

    Enable the APIs

  4. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

prepara l'ambiente

In questa sezione, agisci come operatore dell'applicazione ed esegui le seguenti operazioni:

  • Configura le autorizzazioni richieste.
  • Crea i cluster GKE per gli ambienti di staging e produzione.
  • Clona il repository di codice sorgente.
  • Crea un repository in Cloud Source Repositories per il codice sorgente.
  • Crea un repository in Artifact Registry per l'applicazione contenitore.

Configurare le autorizzazioni

In questa sezione, concedi le autorizzazioni necessarie per configurare la pipeline CI/CD.

  1. Se stai lavorando in una nuova istanza di Cloud Shell Editor, specifica il progetto da utilizzare per questa guida al deployment:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con l'ID del progetto selezionato o creato per questa guida all'implementazione.

    Se viene visualizzata una finestra di dialogo, fai clic su Autorizza.

  2. Assicurati che l'account di servizio Compute Engine predefinito disponga delle autorizzazioni sufficienti per eseguire job in Cloud Deploy e estrarre i contenitori da Artifact Registry. Cloud Build e Cloud Deploy utilizzano questo account di servizio predefinito.

    Questo account di servizio potrebbe già disporre delle autorizzazioni necessarie. Questo passaggio garantisce che le autorizzazioni necessarie vengano concesse per i progetti che disattivano la concessione automatica dei ruoli per gli account di servizio predefiniti.

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/clouddeploy.jobRunner"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/artifactregistry.reader"

  3. Concedi al privilegio dell'account di servizio Cloud Build di invocare i deployment con Cloud Deploy e di aggiornare la pipeline di importazione e le definizioni di destinazione:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")@cloudbuild.gserviceaccount.com \
    --role="roles/clouddeploy.operator"

    Per ulteriori informazioni su questo ruolo IAM, consulta il ruolo clouddeploy.operator.

  4. Concedi al servizio Cloud Build e Cloud Deploy il privilegio di account per eseguire il deployment in GKE:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/container.admin"

    Per maggiori dettagli su questo ruolo IAM, consulta il ruolo container.admin.

  5. Concedi all'account di servizio Cloud Build le autorizzazioni necessarie per invocare le operazioni di Cloud Deploy:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")@cloudbuild.gserviceaccount.com \
    --role="roles/iam.serviceAccountUser"

    Quando Cloud Build invoca Cloud Deploy, utilizza un account di servizio Compute Engine per creare una release, motivo per cui è necessaria questa autorizzazione.

    Per ulteriori dettagli su questo ruolo IAM, consulta il ruolo iam.serviceAccountUser.

Ora hai concesso le autorizzazioni necessarie per la pipeline CI/CD.

Crea i cluster GKE

In questa sezione crei gli ambienti di staging e di produzione, entrambi cluster GKE. Non è necessario configurare il cluster di sviluppo qui, perché utilizza minikube.

  1. Crea i cluster GKE di staging e di produzione:

    gcloud container clusters create-auto staging \
    --region us-central1 \
    --project=$(gcloud config get-value project) \
    --async

gcloud container clusters create-auto prod \
    --region us-central1 \
    --project=$(gcloud config get-value project) \
    --async

    Il cluster di staging è il luogo in cui testi le modifiche al codice. Dopo aver verificato che il deployment in gestione temporanea non ha influito negativamente sull'applicazione, esegui il deployment in produzione.

  2. Esegui il seguente comando e assicurati che l'output contenga STATUS: RUNNING per i cluster di staging e di produzione:

    gcloud container clusters list

  3. Recupera le credenziali nei file kubeconfig per i cluster di staging e produzione.

    gcloud container clusters get-credentials staging --region us-central1

gcloud container clusters get-credentials prod --region us-central1

    Utilizzi queste credenziali per interagire con i cluster GKE, ad esempio per verificare che un'applicazione funzioni correttamente.

Ora hai creato i cluster GKE per l'ambiente di staging e di produzione.

Apri l'IDE e clona il repository

Per clonare il repository e visualizzare l'applicazione nell'ambiente di sviluppo, procedi nel seguente modo:

  1. Clona il repository GitHub in Cloud Shell.

    Apri in Cloud Shell

  2. Fai clic su Conferma.

    L'editor di Cloud Shell apre e clona il repository di esempio.

    Ora puoi visualizzare il codice dell'applicazione nell'editor di Cloud Shell.

  3. Specifica il progetto da utilizzare per questa guida al deployment:

    gcloud config set project PROJECT_ID

    Se viene visualizzata una finestra di dialogo, fai clic su Autorizza.

Ora hai il codice sorgente dell'applicazione nel tuo ambiente di sviluppo.

Questo repository di origine include i file Cloud Build e Cloud Deploy necessari per la pipeline CI/CD.

Crea repository per il codice sorgente e per i contenitori

In questa sezione configuri un repository in Cloud Source Repositories per il codice sorgente e un repository in Artifact Registry per archiviare i contenitori creati dalla pipeline CI/CD.

  1. Crea un repository in Cloud Source Repositories per archiviare il codice sorgente e collegarlo al processo CI/CD:

    gcloud source repos create cicd-sample

  2. Assicurati che le configurazioni di Cloud Deploy abbiano come target il progetto corretto:

    sed -i s/project-id-placeholder/$(gcloud config get-value project)/g deploy/*
git config --global credential.https://source.developers.google.com.helper gcloud.sh
git remote add google https://source.developers.google.com/p/$(gcloud config get-value project)/r/cicd-sample

  3. Esegui il push del codice sorgente nel repository:

    git push --all google

  4. Crea un repository di immagini in Artifact Registry:

    gcloud artifacts repositories create cicd-sample-repo \
    --repository-format=Docker \
    --location us-central1

Ora hai un repository per il codice sorgente in Cloud Source Repositories e un altro per il contenitore dell'applicazione in Artifact Registry. Il repository Cloud Source Repositories consente di clonare il codice sorgente e collegarlo alla pipeline CI/CD.

Configura la pipeline CI/CD

In questa sezione, agisci come operatore dell'applicazione e configuri la pipeline CI/CD. La pipeline utilizza Cloud Build per CI e Cloud Deploy per CD. I passaggi della pipeline sono definiti nell'trigger di Cloud Build.

  1. Crea un bucket Cloud Storage per Cloud Build per archiviare il file artifacts.json (che tiene traccia degli artefatti generati da Skaffold per ogni build):

    gcloud storage buckets create gs://$(gcloud config get-value project)-gceme-artifacts/

    Conservare il file artifacts.json di ogni build in un unico posto è una buona prassi perché garantisce la tracciabilità, semplificando la risoluzione dei problemi.

  2. Esamina il file cloudbuild.yaml, che definisce l'attivatore Cloud Build ed è già configurato nel repository di origine che hai clonato.

    Questo file definisce l'attivatore invocato ogni volta che viene eseguito un nuovo push al ramo principale del repository del codice sorgente.

    I seguenti passaggi per la pipeline CI/CD sono definiti nel cloudbuild.yaml file:

    • Cloud Build utilizza Skaffold per creare il container dell'applicazione.

    • Cloud Build inserisce il file artifacts.json della build nel bucket Cloud Storage.

    • Cloud Build inserisce il contenitore dell'applicazione in Artifact Registry.

    • Cloud Build esegue i test sul contenitore dell'applicazione.

    • Il comando gcloud deploy apply registra i seguenti file con il servizio Cloud Deploy:

      • deploy/pipeline.yaml, ovvero la pipeline di distribuzione
      • deploy/staging.yaml e deploy/prod.yaml, che sono i file di destinazione

      Quando i file vengono registrati, Cloud Deploy crea la pipeline e i target se non esistono ancora oppure li ricrea se la configurazione è cambiata. I target sono gli ambienti di gestione temporanea e produzione.

    • Cloud Deploy crea una nuova release per la pipeline di distribuzione.

      Questa release fa riferimento al contenitore dell'applicazione compilato e provato nel processo di CI.

    • Cloud Deploy esegue il deployment della release nell'ambiente di gestione temporanea.

    La pipeline di distribuzione e i target sono gestiti da Cloud Deploy e sono disaccoppiati dal codice sorgente. Questo disaccoppiamento significa che non è necessario aggiornare la pipeline di importazione e i file di destinazione quando viene apportata una modifica al codice sorgente dell'applicazione.

  3. Crea l'trigger di Cloud Build:

    gcloud beta builds triggers create cloud-source-repositories \
    --name="cicd-sample-main" \
    --repo="cicd-sample" \
    --branch-pattern="main" \
    --build-config="cloudbuild.yaml"

    Questo trigger indica a Cloud Build di monitorare il repository di origine e di utilizzare il file cloudbuild.yaml per reagire a eventuali modifiche al repository. Questo trigger viene invocato ogni volta che viene eseguito un nuovo push nel ramo principale.

  4. Vai alla pagina Cloud Build nella console Google Cloud.

    Vai a Cloud Build

    Noterai che non sono presenti build per la tua applicazione.

Ora hai configurato le pipeline CI e CD e hai creato un attivatore nel ramo principale del repository.

Apportare una modifica all'applicazione all'interno dello spazio di lavoro dello sviluppatore

In questa sezione, agisci come sviluppatore dell'applicazione.

Durante lo sviluppo dell'applicazione, apporti e verifichi modifiche iterative all'applicazione utilizzando Cloud Code come spazio di lavoro di sviluppo:

  • Apporta una modifica all'applicazione.
  • Compila e testa il nuovo codice.
  • Esegui il deployment dell'applicazione nel cluster minikube e verifica le modifiche rivolte agli utenti.
  • Invia la modifica al repository principale.

Quando questa modifica viene committata nel repository principale, l'trigger Cloud Build avvia la pipeline CI/CD.

Crea, testa ed esegui l'applicazione

In questa sezione crei, testi, esegui il deployment e accedi alla tua applicazione.

Utilizza la stessa istanza di Cloud Shell Editor utilizzata nella sezione precedente. Se hai chiuso l'editor, apri Cloud Shell Editor nel browser andando su ide.cloud.google.com.

  1. Nel terminale, avvia minikube:

    minikube start

    minikube configura un cluster Kubernetes locale in Cloud Shell. L'esecuzione di questa configurazione richiede alcuni minuti. Al termine, il processo minikube viene eseguito in background nell'istanza Cloud Shell.

  2. Nel riquadro in fondo all'editor di Cloud Shell, seleziona Cloud Code.

  3. Nel riquadro sottile visualizzato tra il terminale e l'editor, seleziona Esegui su Kubernetes.

    Se viene visualizzato il messaggio Use current context (minikube) to run the app?, fai clic su Sì.

    Questo comando compila il codice sorgente ed esegue i test. L'operazione può richiedere alcuni minuti. I test includono test di unità e un passaggio di convalida preconfigurato che controlla le regole impostate per l'ambiente di deployment. In questo modo, riceverai un avviso in caso di problemi di deployment anche mentre lavori nell'ambiente di sviluppo.

    La scheda Output mostra lo stato di avanzamento di Skaffold durante la creazione e il deployment della tua applicazione.

    Tieni aperta questa scheda per tutta la durata della sezione.

    Al termine della compilazione e dei test, nella scheda Output viene visualizzato il messaggio Update succeeded e vengono mostrati due URL.

    Durante la creazione e il test dell'app, Cloud Code restituisce in streaming i log e gli URL nella scheda Output. Mentre apporti modifiche ed esegui test nel tuo ambiente di sviluppo, puoi vedere la versione dell'app dell'ambiente di sviluppo e verificare che funzioni correttamente.

    L'output indica anche Watching for changes..., il che significa che la modalità smartwatch è attivata. Quando Cloud Code è in modalità di monitoraggio, il servizio rileva eventuali modifiche salvate nel repository e ricostruisce e ridistribuisce automaticamente l'app con le modifiche più recenti.

  4. Nel terminale Cloud Code, tieni premuto il puntatore del mouse sul primo URL nell'output (http://localhost:8080).

  5. Nella descrizione comando visualizzata, seleziona Apri anteprima web.

    In background, Cloud Code esegue automaticamente il port forwarding del traffico al servizio cicd-sample in esecuzione su minikube.

  6. Nel browser, aggiorna la pagina.

    Il numero accanto a Contatore aumenta, a indicare che l'app risponde all'aggiornamento.

    Nel browser, tieni aperta questa pagina per visualizzare l'applicazione man mano che apporti modifiche nell'ambiente locale.

Ora hai creato e testato l'applicazione nell'ambiente di sviluppo. Hai eseguito il deployment dell'applicazione nel cluster di sviluppo in esecuzione su minikube e hai visualizzato il comportamento dell'applicazione rivolto agli utenti.

apporta una modifica

In questa sezione apporti una modifica all'applicazione e la visualizzi mentre l'app viene eseguita nel cluster di sviluppo.

  1. Nell'editor di Cloud Shell, apri il file index.html.

  2. Cerca la stringa Sample App Info e modificala in sample app info, in modo che il titolo utilizzi lettere minuscole.

    Il file viene salvato automaticamente, attivando una ricostruzione del contenitore dell'applicazione.

    Cloud Code rileva la modifica e la esegue di nuovo automaticamente. La scheda Output mostra Update initiated. L'esecuzione di questo nuovo deployment richiede alcuni minuti.

    Questa funzionalità di redeployment automatico è disponibile per qualsiasi applicazione in esecuzione su un cluster Kubernetes.

  3. Al termine della compilazione, apri l'app nel browser e aggiorna la pagina.

    Quando aggiorni la pagina, vedrai che il testo ora utilizza lettere minuscole.

Questa configurazione consente il ricaricamento automatico per qualsiasi architettura e con qualsiasi componente. Quando utilizzi Cloud Code e minikube, qualsiasi cosa in esecuzione in Kubernetes dispone di questa funzionalità di ricarica del codice a caldo.

Puoi eseguire il debug delle applicazioni di cui è stato eseguito il deployment in un cluster Kubernetes in Cloud Code. Questi passaggi non sono trattati in questa guida al deployment, ma per maggiori dettagli, consulta Eseguire il debug di un'applicazione Kubernetes.

Esegui il commit del codice

Ora che hai apportato una modifica all'applicazione, puoi eseguire il commit del codice.

  1. Configura la tua identità git:

    git config --global user.email "YOU@EXAMPLE.COM"
git config --global user.name "NAME"

    Sostituisci quanto segue:

    • YOU@EXAMPLE.COM: l'indirizzo email collegato al tuo account GitHub.
    • NAME: il nome collegato al tuo account GitHub.

  2. Dal terminale, esegui il commit del codice:

    git add .
git commit -m "use lowercase for: sample app info"

    Non è necessario eseguire il comando git push qui. Ne parleremo più avanti.

Nell'ambiente di sviluppo, hai apportato una modifica all'applicazione, l'hai creata e testata e hai verificato il comportamento di queste modifiche per gli utenti. I test nell'ambiente di sviluppo includono controlli di governance che ti consentono di correggere i problemi che causano problemi nell'ambiente di produzione.

In questa guida al deployment, quando esegui il commit del codice nel repository principale, non esegui una revisione del codice. Tuttavia, una revisione del codice o l'approvazione delle modifiche è una procedura consigliata per lo sviluppo software.

Per ulteriori informazioni sulle best practice per l'approvazione delle modifiche, consulta Semplificazione dell'approvazione delle modifiche.

Esegui il deployment di una modifica in produzione

In questa sezione, agisci come operatore dell'applicazione ed esegui le seguenti operazioni:

  • Attiva la pipeline CI/CD, che esegue il deployment della release nell'ambiente di staging.
  • Promuovi e approva la release in produzione.

Avvia la pipeline CI/CD ed esegui il deployment nell'area di staging

In questa sezione, avvii la pipeline CI/CD richiamando l'attivatore Cloud Build. Questo trigger viene richiamato ogni volta che viene eseguito il commit di una modifica nel repository principale. Puoi anche avviare il sistema CI con un attivatore manuale.

  1. Nell'editor di Cloud Shell, esegui il seguente comando per attivare una compilazione:

    git push google

    Questa build include la modifica apportata a cicd-sample.

  2. Torna alla dashboard di Cloud Build e verifica che sia stata creata una build.

  3. Fai clic su In esecuzione: cicd-sample - cicd-sample-main nel log di compilazione a destra e cerca il testo blu che indica l'inizio e la fine di ogni passaggio.

    Il passaggio 0 mostra l'output delle istruzioni skaffold build e skaffold test del file cloudbuild.yaml. Le attività di compilazione e test nel passaggio 0 (la parte CI della pipeline) sono passate, quindi ora vengono eseguite le attività di deployment del passaggio 1 (la parte CD della pipeline).

    Questo passaggio termina con il seguente messaggio:

    Created Cloud Deploy rollout ROLLOUT_NAME in target staging

  4. Apri la pagina Pipeline di distribuzione Cloud Deploy e fai clic sulla pipeline cicd-sample delivery.

    L'applicazione è di staging, ma non di produzione.

  5. Verifica che l'applicazione funzioni correttamente nello staging:

    kubectl proxy --port 8001 --context gke_$(gcloud config get-value project)_us-central1_staging

    Questo comando configura un proxy kubectl per accedere all'applicazione.

  6. Accedi all'applicazione da Cloud Shell:

    1. Nell'editor di Cloud Shell, apri una nuova scheda del terminale.

    2. Invia una richiesta a localhost per incrementare un contatore:

      curl -s http://localhost:8001/api/v1/namespaces/default/services/cicd-sample:8080/proxy/ | grep -A 1 Counter

      Puoi eseguire questo comando più volte e osservare ogni volta l'incremento del valore del contatore.

      Quando visualizzi l'app, noterai che il testo modificato è presente nella versione dell'applicazione di cui hai eseguito il deployment nell'ambiente di staging.

    3. Chiudi questa seconda scheda.

    4. Nella prima scheda, premi Control+C per interrompere il proxy.

Ora hai invocato l'attivatore Cloud Build per avviare il processo CI, che include la creazione dell'applicazione, il deployment nell'ambiente di staging ed l'esecuzione di test per verificare che l'applicazione funzioni in questo ambiente.

La procedura CI ha esito positivo quando la compilazione e i test del codice vengono superati nell'ambiente di gestione temporanea. Se il processo di CI ha esito positivo, viene avviato il sistema di CD in Cloud Deploy.

Promuovi la release in produzione

In questa sezione, promuovi la release dalla versione temporanea alla produzione. Il target di produzione è preconfigurato per richiedere l'approvazione, quindi devi approvarlo manualmente.

Per la tua pipeline CI/CD, ti consigliamo di utilizzare una strategia di implementazione che avvii l'implementazione gradualmente prima di eseguire un'implementazione completa in produzione. Il lancio graduale del deployment può semplificare il rilevamento dei problemi e, se necessario, il ripristino di una release precedente.

Per promuovere la release in produzione:

  1. Apri la panoramica delle pipeline di distribuzione Cloud Deploy e seleziona la pipeline cicd-sample.

  2. Esegui il passaggio del deployment dalla versione temporanea alla produzione. Per farlo:

    1. Nel diagramma della pipeline nella parte superiore della pagina, fai clic sul pulsante blu Promuovi nella casella di staging.

    2. Nella finestra visualizzata, fai clic sul pulsante Promuovi in basso.

    Il deployment non è ancora in esecuzione in produzione. È in attesa dell'approvazione manuale obbligatoria.

  3. Approva manualmente il deployment:

    1. Nella visualizzazione della pipeline, fai clic sul pulsante Esamina tra le caselle di staging e di produzione.

    2. Nella finestra visualizzata, fai clic sul pulsante Esamina.

    3. Nella finestra successiva, fai clic su Approva.

    4. Torna alla panoramica delle pipeline di distribuzione di Cloud Deploy e seleziona la pipeline cicd-sample.

  4. Dopo che la visualizzazione della pipeline mostra la casella di produzione in verde (ovvero un deployment riuscito), verifica che l'applicazione funzioni in produzione configurando un proxy kubectl da utilizzare per accedere all'applicazione:

    kubectl proxy --port 8002 --context gke_$(gcloud config get-value project)_us-central1_prod

  5. Accedi all'applicazione da Cloud Shell:

    1. Nell'editor di Cloud Shell, apri una nuova scheda del terminale.

    2. Aumenta il contatore:

      curl -s http://localhost:8002/api/v1/namespaces/default/services/cicd-sample:8080/proxy/ | grep -A 1 Counter

      Puoi eseguire questo comando più volte e osservare ogni volta l'incremento del valore del contatore.

    3. Chiudi questa seconda scheda del terminale.

    4. Nella prima scheda, premi Control+C per interrompere il proxy.

Ora hai promosso e approvato il deployment di produzione. L'applicazione con la modifica recente è ora in produzione.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa guida all'implementazione, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Opzione 1: elimina il progetto

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Opzione 2: elimina le singole risorse

  1. Elimina la pipeline Cloud Deploy:

    gcloud deploy delivery-pipelines delete cicd-sample --region=us-central1 --force

  2. Elimina il trigger di Cloud Build:

    gcloud beta builds triggers delete cicd-sample-main

  3. Elimina i cluster di staging e di produzione:

    gcloud container clusters delete staging

gcloud container clusters delete prod

  4. Elimina il repository in Cloud Source Repositories:

    gcloud source repos delete cicd-sample

  5. Elimina i bucket Cloud Storage:

    gcloud storage rm -r gs://$(gcloud config get-value project)-gceme-artifacts/

gcloud storage rm -r gs://$(gcloud config get-value project)_clouddeploy/

  6. Elimina il repository in Artifact Registry:

    gcloud artifacts repositories delete cicd-sample-repo \
    --location us-central1

Passaggi successivi