Panoramica

In questo lab creerai un'immagine container Docker a partire dal codice fornito e un Dockerfile utilizzando Cloud Build. Successivamente, caricherai il container su Artifact Registry.

Obiettivi

In questo lab imparerai a:

• Utilizzare Cloud Build per creare container ed eseguirne il push
• Utilizzare Artifact Registry per archiviare container ed eseguirne il deployment

Configurazione del lab

Accedi al lab

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. Fai clic sul pulsante Avvia lab. Se devi effettuare il pagamento per il lab, si apre una finestra popup per permetterti di selezionare il metodo di pagamento. A sinistra, trovi il riquadro Dettagli lab con le seguenti informazioni:

   • Il pulsante Apri 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 visualizzare un menu con un elenco di prodotti e servizi Google Cloud, fai clic sul menu di navigazione in alto a sinistra oppure digita il nome del servizio o del prodotto nel campo di ricerca.

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: verifica che le API necessarie siano abilitate

1. Prendi nota del nome del tuo progetto Google Cloud. Questo valore è visualizzato nella barra superiore della console Google Cloud nel formato qwiklabs-gcp- seguito da numeri esadecimali.

2. Nel menu di navigazione () della console Google Cloud, fai clic su API e servizi.

3. Fai clic su Raccolta.

4. Nella casella Cerca API e servizi, digita Cloud Build.

5. Se nella scheda restituita, che mostra l'API Cloud Build, non viene visualizzato un messaggio che conferma che l'API Cloud Build è abilitata, fai clic sul pulsante Abilita.

6. Utilizza il pulsante Indietro per tornare alla schermata precedente in cui è visualizzata la casella di ricerca. Nella casella di ricerca, digita Artifact Registry.

7. Se nella scheda restituita, che mostra l'API Google Artifact Registry, non visualizzi un messaggio che conferma che l'API Artifact Registry è abilitata, fai clic sul pulsante Abilita.

Attività 2: crea dei container con DockerFile e Cloud Build

Puoi scrivere file di configurazione di compilazione per fornire istruzioni a Cloud Build su quali attività eseguire durante la creazione di un container. Questi file di build possono recuperare dipendenze, eseguire test delle unità, analisi e molto altro. In questa attività dovrai creare un Dockerfile e utilizzarlo come script di configurazione di compilazione con Cloud Build. Inoltre, creerai un semplice script shell (quickstart.sh) che rappresenta un'applicazione all'interno del container.

1. Nella barra del titolo della console Google Cloud, fai clic su Attiva Cloud Shell.

2. Quando richiesto, fai clic su Autorizza.

Cloud Shell si aprirà nella parte inferiore della finestra della console Google Cloud.

3. Utilizzando l'editor di testo nano, crea un file vuoto denominato quickstart.sh:

nano quickstart.sh

4. Aggiungi le righe seguenti al file quickstart.sh:

#!/bin/sh echo "Hello, world! The time is $(date)."

5. Salva il file e chiudi nano premendo Ctrl+X, Y e, infine, Invio.

6. Utilizzando l'editor di testo nano, crea un file Dockerfile vuoto:

nano Dockerfile

7. Aggiungi il seguente comando Dockerfile:

FROM alpine

Questa istruzione fa in modo che la build utilizzi l'immagine di base di Alpine Linux.

8. Aggiungi il seguente comando Dockerfile alla fine del Dockerfile:

COPY quickstart.sh /

Questo comando aggiunge lo script quickstart.sh alla directory / dell'immagine.

9. Aggiungi il seguente comando Dockerfile alla fine del Dockerfile:

CMD ["/quickstart.sh"]

Questo comando configura l'immagine in modo che esegua lo script /quickstart.sh quando viene creato ed eseguito il contenitore associato.

A questo punto, il Dockerfile dovrebbe avere il seguente aspetto:

FROM alpine COPY quickstart.sh / CMD ["/quickstart.sh"]

10. Salva il file e chiudi nano premendo Ctrl+X, Y e, infine, Invio.

11. In Cloud Shell, esegui questo comando per rendere eseguibile lo script quickstart.sh:

chmod +x quickstart.sh

12. Crea un nuovo repository Docker denominato quickstart-docker-repo nella località con la descrizione "Repository Docker"

gcloud artifacts repositories create quickstart-docker-repo --repository-format=docker \ --location={{{project_0.default_region | "REGION"}}} --description="Docker repository"

13. In Cloud Shell, esegui questo comando per creare l'immagine container Docker in Cloud Build:

gcloud builds submit --tag {{{project_0.default_region | "REGION"}}}-docker.pkg.dev/${DEVSHELL_PROJECT_ID}/quickstart-docker-repo/quickstart-image:tag1

Al completamento della build, l'immagine Docker viene creata e ne viene eseguito il push su Artifact Registry.

14. Nella barra di ricerca situata nella parte superiore della finestra della console Google Cloud, cerca Artifact Registry.

Nota: se non vedi una casella di ricerca, fai clic sull'icona a forma di lente d'ingrandimento. Nota: potresti visualizzare un messaggio popup che indica Se lasci questa pagina, la vista verrà reimpostata. Fai clic sul pulsante Ok per continuare.

15. Fai clic sul repository denominato quickstart-docker-repo.

L'immagine Docker quickstart-image viene visualizzata nell'elenco.

Attività 3: crea dei container con un file di configurazione di compilazione e Cloud Build

Cloud Build supporta anche i file di configurazione di compilazione personalizzati. In questa attività dovrai incorporare un container Docker esistente utilizzando un file di build YAML personalizzato con Cloud Build.

Creiamo un file di configurazione di Cloud Build personalizzato di esempio denominato cloudbuild.yaml.

1. Crea e apri un file denominato cloudbuild.yaml con nano utilizzando questo comando:

nano cloudbuild.yaml

2. Una volta aperto nano, incolla il seguente codice nel file cloudbuild.yaml:

steps: - name: 'gcr.io/cloud-builders/docker' args: [ 'build', '-t', 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1', '.' ] images: - 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1'

3. Premi Ctrl+O e poi Invio per salvare il file modificato.

4. Premi Ctrl+X per uscire dall'editor di testo nano.

5. Esegui il comando seguente per impostare la nostra variabile di regione e inserire questo valore nel file yaml.

export REGION={{{project_0.default_region | "REGION"}}} sed -i "s/YourRegionHere/$REGION/g" cloudbuild.yaml

6. In Cloud Shell, esegui questo comando per visualizzare il contenuto di cloudbuild.yaml:

cat cloudbuild.yaml

Verrà visualizzato l'output seguente:

steps: - name: 'gcr.io/cloud-builders/docker' args: [ 'build', '-t', '{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1', '.' ] images: - '{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1'

Le istruzioni contenute in questo file fanno in modo che Cloud Build utilizzi Docker per creare un'immagine mediante la specifica Dockerfile che si trova nella directory locale corrente, che aggiunga all'immagine il tag gcr.io/$PROJECT_ID/quickstart-image ($PROJECT_ID è una variabile di sostituzione a cui Cloud Build assegna automaticamente il valore dell'ID progetto del progetto associato) e, infine, che esegua il push dell'immagine su Artifact Registry.

7. In Cloud Shell, esegui questo comando per avviare Cloud Build utilizzando cloudbuild.yaml come file di configurazione di compilazione:

gcloud builds submit --config cloudbuild.yaml

L'output della build in Cloud Shell dovrebbe essere lo stesso di prima. Una volta completata la build, viene eseguito il push di una nuova versione della stessa immagine su Artifact Registry.

8. Nella barra di ricerca situata nella parte superiore della finestra della console Google Cloud, cerca Artifact Registry.

9. Nei risultati di ricerca, fai clic su Artifact Registry.

10. Fai clic sul repository denominato quickstart-docker-repo > quickstart-image.

Nell'elenco sono ora presenti due versioni di quickstart-image.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea due immagini container in Cloud Build

11. Nella barra di ricerca situata nella parte superiore della finestra della console Google Cloud, cerca Cloud Build.

12. Nei risultati di ricerca, fai clic su Cloud Build.

13. In Cloud Build, fai clic su Cronologia. Nell'elenco sono presenti due build.

14. Fai clic sull'ID della build in cima all'elenco. Vengono visualizzati i dettagli della build, incluso il log.

Attività 4: crea e sottoponi a test dei container con un file di configurazione di compilazione e Cloud Build

Il potenziale dei file di configurazione di compilazione personalizzati è rappresentato dalla loro capacità di eseguire altre azioni, in parallelo o in sequenza, oltre alla semplice creazione di container: l'esecuzione di test sui container appena creati, l'esecuzione del push su vari tipi di destinazioni e anche il loro deployment in Kubernetes Engine.

In questa attività esamineremo un semplice esempio: un file di configurazione di compilazione che verifica il container che ha creato e restituisce il risultato al suo ambiente di chiamata. Il primo passaggio prevede la modifica del file quickstart.sh.

1. In Cloud Shell, apri quickstart.sh in nano.

   nano quickstart.sh

2. Sostituisci quello esistente con il seguente:

#!/bin/sh if [ -z "$1" ] then echo "Hello, world! The time is $(date)." exit 0 else exit 1 fi

3. Premi Ctrl+O e poi Invio per salvare il file modificato.

4. Premi Ctrl+X per uscire dall'editor di testo nano.

Creiamo un nuovo file di configurazione di Cloud Build personalizzato denominato cloudbuild2.yaml. Questo elemento è stato leggermente modificato per dimostrare la capacità di Cloud Build di eseguire test sui container che ha creato.

1. Crea e apri un file denominato cloudbuild2.yaml con nano utilizzando questo comando:

nano cloudbuild2.yaml

2. Una volta aperto nano, incolla il seguente codice nel file cloudbuild2.yaml:

steps: - name: 'gcr.io/cloud-builders/docker' args: [ 'build', '-t', 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1', '.' ] - name: 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1' args: ['fail'] images: - 'YourRegionHere-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1'

3. Premi Ctrl+O e poi Invio per salvare il file modificato.

4. Premi Ctrl+X per uscire dall'editor di testo nano.

5. Esegui il comando seguente per inserire il valore della nostra regione nel file YAML.

sed -i "s/YourRegionHere/$REGION/g" cloudbuild2.yaml

6. In Cloud Shell, esegui questo comando per visualizzare il contenuto di cloudbuild2.yaml:

cat cloudbuild2.yaml

Verrà visualizzato l'output seguente:

steps: - name: 'gcr.io/cloud-builders/docker' args: [ 'build', '-t', '{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1', '.' ] - name: 'gcr.io/$PROJECT_ID/quickstart-image' args: ['fail'] images: - '{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/$PROJECT_ID/quickstart-docker-repo/quickstart-image:tag1'

Oltre alle azioni precedenti, questo file di configurazione di compilazione esegue l'immagine quickstart-image creata. In questa attività, lo script quickstart.sh è stato modificato in modo da simulare un test non riuscito quando viene passato l'argomento ['fail'].

7. In Cloud Shell, esegui questo comando per avviare Cloud Build utilizzando cloudbuild.yaml come file di configurazione di compilazione:

gcloud builds submit --config cloudbuild2.yaml

Verrà visualizzato l'output del comando, che termina con il seguente testo:

Output

BUILD FAILURE: Build step failure: build step 1 "us-east1-docker.pkg.dev/qwiklabs-gcp-02-1c7ba5c697a0/quickstart-docker-repo/quickstart-image:tag1" failed: starting step container failed: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "fail": executable file not found in $PATH: unknown ERROR: (gcloud.builds.submit) build 96c4a454-be06-4010-aa7c-da57c14165f4 completed with status "FAILURE"

8. Verifica che l'errore della build sia confermato dalla shell dei comandi:

echo $?

Il comando restituirà un valore diverso da zero. Se avessi incorporato questa build in uno script, lo script sarebbe in grado di intervenire sull'errore della build.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea e sottoponi a test container con un file di configurazione di compilazione e Cloud Build

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