GSP055

Panoramica

Docker è una piattaforma aperta per lo sviluppo, la distribuzione e l'esecuzione di applicazioni. Con Docker puoi separare le tue applicazioni dalla tua infrastruttura e trattare la tua infrastruttura come un'applicazione gestita. Docker ti aiuta a distribuire, testare ed eseguire il deployment del codice più velocemente e a ridurre il ciclo tra scrittura ed esecuzione del codice.

Per farlo combina le funzionalità di containerizzazione dei kernel con flussi di lavoro e strumenti che ti aiutano a gestire le tue applicazioni e a eseguirne il deployment.

I container Docker possono essere utilizzati direttamente in Kubernetes, il che consente di eseguirli facilmente in Kubernetes Engine. Dopo aver appreso gli elementi essenziali di Docker, avrai le competenze per iniziare a sviluppare applicazioni Kubernetes e containerizzate.

Obiettivi

In questo lab, imparerai a:

• Creare ed eseguire container Docker ed eseguirne il debug.
• Eseguire il pull delle immagini Docker da Docker Hub e Google Artifact Registry.
• Eseguire il push delle immagini Docker in Google Artifact Registry.

Prerequisiti

Si tratta di un lab di livello base. È adatto a chi ha poca o nessuna esperienza con Docker e i container. Suggeriamo, ma non è obbligatoria, esperienza con la riga di comando e Cloud Shell.

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 Avvia 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 prima persona, 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: utilizza una finestra del browser in incognito o privata per eseguire questo lab. Ciò evita eventuali 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: se hai già un account o un progetto Google Cloud personale, non utilizzarlo per questo lab per evitare addebiti aggiuntivi al tuo 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 apre una finestra popup per permetterti di selezionare il metodo di pagamento. A sinistra, trovi il riquadro Dettagli lab con le seguenti informazioni:

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

2. Fai clic su Apri console Google. 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.

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

3. Se necessario, copia il Nome utente dal riquadro Dettagli lab e incollalo nella finestra di dialogo di accesso. Fai clic su Avanti.

4. Copia la Password dal riquadro Dettagli lab e incollala nella finestra di dialogo di benvenuto. Fai clic su Avanti.

   Importante: devi utilizzare le credenziali presenti nel riquadro di sinistra. Non utilizzare le tue credenziali Google Cloud Skills Boost. Nota: utilizzare il tuo account Google Cloud per questo lab potrebbe comportare addebiti aggiuntivi.

5. 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: puoi visualizzare il menu con un elenco di prodotti e servizi Google Cloud facendo clic sul menu di navigazione in alto a sinistra.

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.

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 YOUR_PROJECT_ID

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

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

gcloud auth list

3. Fai clic su Autorizza.

4. L'output dovrebbe avere ora il seguente aspetto:

Output:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net 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_ID>

Output di esempio:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: per la documentazione completa di gcloud, in Google Cloud, fai riferimento alla Panoramica dell'interfaccia a riga di comando gcloud.

Attività 1: Hello World

1. In Cloud Shell inserisci questo comando per eseguire un container Hello World per iniziare:

docker run hello-world

(Output comando)

Unable to find image 'hello-world:latest' locally latest: Pulling from library/hello-world 9db2ca6ccae0: Pull complete Digest: sha256:4b8ff392a12ed9ea17784bd3c9a8b1fa3299cac44aca35a85c90c5e3c7afacdc Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly. ...

Questo semplice container restituisce Hello from Docker! sul tuo schermo. Sebbene il comando sia semplice, osserva nell'output il numero di passaggi eseguiti. Il daemon Docker ha cercato l'immagine Hello World, non l'ha trovata in locale, ha eseguito il pull dell'immagine da un registro pubblico chiamato Docker Hub, ha creato un container dall'immagine e ha eseguito il container per conto tuo.

2. Esegui questo comando per esaminare l'immagine container di cui è stato eseguito il pull da Docker Hub:

docker images

(Output comando)

REPOSITORY TAG IMAGE ID CREATED SIZE hello-world latest feb5d9fea6a5 14 months ago 13.3kB

Questa è l'immagine di cui è stato eseguito il pull dal registro pubblico Docker Hub. L'ID immagine è nel formato hash SHA256: questo campo specifica l'immagine Docker di cui è stato effettuato il provisioning. Quando il daemon Docker non riesce a trovare un'immagine in locale, per impostazione predefinita la cercherà nel registro pubblico.

3. Esegui di nuovo il container:

docker run hello-world

(Output comando)

Hello from Docker! This message shows that your installation appears to be working correctly. To generate this message, Docker took the following steps: ...

Nota che la seconda volta che esegui il comando, il daemon Docker trova l'immagine nel registro locale ed esegue il container da quell'immagine. Non è necessario eseguire il pull dell'immagine da Docker Hub.

4. Infine, esamina i container in esecuzione eseguendo questo comando:

docker ps

(Output comando)

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

Non ci sono container in esecuzione. Hai già effettuato l'uscita dai container Hello World eseguiti in precedenza.

5. Per vedere tutti i container, compresi quelli già eseguiti, utilizza il comando docker ps -a:

docker ps -a

(Output comando)

CONTAINER ID IMAGE COMMAND ... NAMES 6027ecba1c39 hello-world "/hello" ... elated_knuth 358d709b8341 hello-world "/hello" ... epic_lewin

Viene visualizzato Container ID, un UUID generato da Docker per identificare il container e altri metadati sull'esecuzione. Anche gli oggetti Names del container vengono generati in modo casuale, ma possono essere specificati con docker run --name [container-name] hello-world.

Attività 2: crea

In questa sezione creerai un'immagine Docker basata su un'applicazione node semplice.

1. Esegui questo comando per creare e passare a una cartella denominata test.

mkdir test && cd test

2. Crea un Dockerfile:

cat > Dockerfile <<EOF # Use an official Node runtime as the parent image FROM node:lts # Set the working directory in the container to /app WORKDIR /app # Copy the current directory contents into the container at /app ADD . /app # Make the container's port 80 available to the outside world EXPOSE 80 # Run app.js using node when the container launches CMD ["node", "app.js"] EOF

Questo file fornisce istruzioni al daemon Docker su come creare la tua immagine.

• La prima riga specifica l'immagine padre di base, che in questo caso è l'immagine Docker ufficiale per l'assistenza a lungo termine della versione di node (lts).
• Nella seconda, imposti la directory (attuale) di lavoro del container.
• Nella terza, aggiungi il contenuto della directory attuale (indicato da ".") al container.
• Quindi esponi la porta del container in modo che possa accettare connessioni su quella porta e infine esegui il comando node per avviare l'applicazione.

Nota: dedica un po' di tempo a rivedere i riferimenti dei comandi Dockerfile per comprendere ogni riga del Dockerfile.

Ora scriverai l'applicazione node e successivamente creerai l'immagine.

3. Esegui questo comando per creare l'applicazione node:

cat > app.js << EOF; const http = require("http"); const hostname = "0.0.0.0"; const port = 80; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader("Content-Type", "text/plain"); res.end("Hello World\n"); }); server.listen(port, hostname, () => { console.log("Server running at http://%s:%s/", hostname, port); }); process.on("SIGINT", function () { console.log("Caught interrupt signal and will exit"); process.exit(); }); EOF

Questo è un semplice server HTTP che ascolta sulla porta 80 e restituisce "Hello World".

Ora crea l'immagine.

4. Osserva di nuovo ".", che indica la directory attuale, quindi devi eseguire questo comando dalla directory che contiene il Dockerfile:

docker build -t node-app:0.1 .

L'esecuzione di questo comando potrebbe richiedere un paio di minuti. Al termine, l'output dovrebbe essere simile al seguente:

+] Building 0.7s (8/8) FINISHED docker:default => [internal] load .dockerignore 0.0s => => transferring context: 2B 0.0s => [internal] load build definition from Dockerfile 0.0s => => transferring dockerfile: 397B 0.0s => [internal] load metadata for docker.io/library/node:lts

-t serve per nominare e taggare un'immagine con la sintassi name:tag. Il nome dell'immagine è node-app e il tag è 0.1. Il tag è altamente consigliato durante la creazione di immagini Docker. Se non specifichi un tag, verrà impostato automaticamente latest e sarà più difficile distinguere le immagini più recenti da quelle più vecchie. Nota inoltre che ogni riga nel Dockerfile sopra genera livelli container intermedi man mano che l'immagine viene creata.

5. Ora esegui questo comando per esaminare le immagini che hai creato:

docker images

L'output dovrebbe essere simile al seguente:

REPOSITORY TAG IMAGE ID CREATED SIZE node-app 0.1 f166cd2a9f10 25 seconds ago 656.2 MB node lts 5a767079e3df 15 hours ago 656.2 MB hello-world latest 1815c82652c0 6 days ago 1.84 kB

Nota che node è l'immagine di base e node-app è l'immagine che hai creato. Non puoi rimuovere node senza prima rimuovere node-app. La dimensione dell'immagine è relativamente piccola rispetto alle VM. Altre versioni dell'immagine node come node:slim e node:alpine possono offrirti immagini ancora più piccole per una più facile portabilità. La riduzione delle dimensioni dei container viene approfondita in Argomenti avanzati. Puoi visualizzare tutte le versioni nel repository ufficiale nella sezione node.

Attività 3: esegui

1. Utilizza questo codice per eseguire container in base all'immagine che hai creato:

docker run -p 4000:80 --name my-app node-app:0.1

(Output comando)

Server running at http://0.0.0.0:80/

Il flag --name ti consente di assegnare un nome al container, se vuoi. -p indica a Docker di mappare la porta 4000 dell'host alla porta 80 del container. Ora puoi raggiungere il server all'indirizzo http://localhost:4000. Senza la mappatura della porta, non saresti in grado di raggiungere il container su localhost.

2. Apri un altro terminale (in Cloud Shell fai clic sull'icona +) e testa il server:

curl http://localhost:4000

(Output comando)

Hello World

Il container verrà eseguito finché è in esecuzione il terminale iniziale. Se vuoi che il container venga eseguito in background (non vincolato alla sessione del terminale), devi specificare il flag -d.

3. Chiudi il terminale iniziale ed esegui questo comando per arrestare e rimuovere il container:

docker stop my-app && docker rm my-app

4. Ora esegui questo comando per avviare il container in background:

docker run -p 4000:80 --name my-app -d node-app:0.1 docker ps

(Output comando)

CONTAINER ID IMAGE COMMAND CREATED ... NAMES xxxxxxxxxxxx node-app:0.1 "node app.js" 16 seconds ago ... my-app

5. Nota che il container è in esecuzione nell'output di docker ps. Puoi esaminare i log eseguendo docker logs [container_id].

Nota: non è necessario scrivere l'intero ID container, a condizione che i caratteri iniziali identifichino il container in modo univoco. Ad esempio, puoi eseguire docker logs 17b se l'ID container è 17bcaca6f.... docker logs [container_id]

(Output comando)

Server running at http://0.0.0.0:80/

Ora modifica l'applicazione.

1. In Cloud Shell apri la directory di test creata in precedenza nel lab:

cd test

2. Modifica app.js con un editor di testo di tua scelta (ad esempio nano o vim) e sostituisci "Hello World" con un'altra stringa:

.... const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Welcome to Cloud\n'); }); ....

3. Crea questa nuova immagine e taggala con 0.2:

docker build -t node-app:0.2 .

(Output comando)

[+] Building 0.7s (8/8) FINISHED docker:default => [internal] load .dockerignore 0.0s => => transferring context: 2B 0.0s => [internal] load build definition from Dockerfile 0.0s => => transferring dockerfile: 397B 0.0s => [internal] load metadata for docker.io/library/node:lts 0.5s

Nota nel passaggio 2 che stai utilizzando un livello di cache esistente. Dal passaggio 3 in poi, i livelli vengono modificati perché hai apportato una modifica in app.js.

4. Esegui un altro container con la nuova versione dell'immagine. Nota come viene mappata la porta 8080 dell'host anziché la porta 80. Non puoi utilizzare la porta 4000 dell'host perché è già in uso.

docker run -p 8080:80 --name my-app-2 -d node-app:0.2 docker ps

(Output comando)

CONTAINER ID IMAGE COMMAND CREATED xxxxxxxxxxxx node-app:0.2 "node app.js" 53 seconds ago ... xxxxxxxxxxxx node-app:0.1 "node app.js" About an hour ago ...

5. Testa i container:

curl http://localhost:8080

(Output comando)

Welcome to Cloud

6. E ora testa il primo container che hai creato:

curl http://localhost:4000

(Output comando)

Hello World

Attività 4: esegui il debug

Ora che hai familiarità con la creazione e l'esecuzione dei container, esamina alcune pratiche di debug.

1. Puoi esaminare i log di un container utilizzando docker logs [container_id]. Se vuoi seguire l'output del log mentre il container è in esecuzione, utilizza l'opzione -f.

docker logs -f [container_id]

(Output comando)

Server running at http://0.0.0.0:80/

A volte potresti voler avviare una sessione Bash interattiva all'interno del container in esecuzione.

2. Per farlo, puoi usare docker exec. Apri un altro terminale (in Cloud Shell fai clic sull'icona +) e testa il server:

docker exec -it [container_id] bash

I flag -it ti consentono di interagire con un container allocando uno pseudo-TTY e mantenendo stdin aperto. Nota che bash è stato eseguito nella directory (/app) WORKDIR specificata nel Dockerfile. Da qui, hai una sessione di shell interattiva all'interno del container di cui eseguire il debug.

(Output comando)

root@xxxxxxxxxxxx:/app#

3. Osserva la directory

ls

(Output comando)

Dockerfile app.js

4. Esci dalla sessione Bash:

exit

5. Puoi esaminare i metadati di un container in Docker utilizzando docker inspect:

docker inspect [container_id]

(Output comando)

[ { "Id": "xxxxxxxxxxxx....", "Created": "2017-08-07T22:57:49.261726726Z", "Path": "node", "Args": [ "app.js" ], ...

6. Utilizza --format per ispezionare campi specifici del file JSON restituito. Ad esempio:

docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' [container_id]

(Output di esempio)

192.168.9.3

Per ulteriori informazioni sul debug, consulta le seguenti risorse della documentazione di Docker:

• Riferimento di docker inspect
• Riferimento di docker exec

Attività 5: pubblica

Ora eseguirai il push della tua immagine in Google Artifact Registry. Dopodiché rimuoverai tutti i container e le immagini per simulare un nuovo ambiente, quindi eseguirai il pull dei container e li eseguirai. Ciò dimostrerà la portabilità dei container Docker.

Per eseguire il push delle immagini nel tuo registro privato ospitato da Artifact Registry, devi taggare le immagini con un nome di registro. Il formato è <regional-repository>-docker.pkg.dev/my-project/my-repo/my-image.

Crea il repository Docker di destinazione (utilizzando la console Cloud)

Prima di eseguire il push delle immagini, devi creare il repository di destinazione. Il push di un'immagine non può attivare la creazione di un repository e l'account di servizio Cloud Build non dispone delle autorizzazioni per creare repository.

1. Dal Menu di navigazione, sotto CI/CD vai ad Artifact Registry > Repository.

2. Fai clic sull'icona +CREA REPOSITORY accanto a Repository.

3. Specifica my-repository come nome del repository.

4. Scegli Docker come formato.

5. In Tipo di località, seleziona Regione, quindi scegli la località .

6. Fai clic su Crea.

Configura l'autenticazione

Prima di eseguire il push o il pull delle immagini, configura Docker in modo che utilizzi Google Cloud CLI per autenticare le richieste ad Artifact Registry.

1. Per configurare l'autenticazione nei repository Docker della regione , esegui questo comando in Cloud Shell:

gcloud auth configure-docker {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev

2. Quando richiesto, inserisci Y.

Il comando aggiorna la configurazione Docker. Ora puoi connetterti con Artifact Registry nel tuo progetto Google Cloud per eseguire il push e il pull delle immagini.

Nota: in alternativa, puoi utilizzare gcloud CLI per un approccio a riga di comando semplificato.

Crea un repository Artifact Registry (utilizzando l'interfaccia a riga di comando)

1. Esegui questi comandi per creare un repository Artifact Registry.

gcloud artifacts repositories create my-repository --repository-format=docker --location={{{ project_0.default_region | "REGION" }}} --description="Docker repository" Nota: quando effettui una chiamata API Google Cloud o utilizzi uno strumento a riga di comando che richiede credenziali (ad es. gcloud CLI, bq o gsutil) con Cloud Shell per la prima volta, Cloud Shell richiede di utilizzare la finestra di dialogo Autorizza Cloud Shell. Per consentire allo strumento di utilizzare le tue credenziali per effettuare chiamate, fai clic su Autorizza.

Esegui il push del container in Artifact Registry

1. Passa alla directory con il tuo Dockerfile.

cd ~/test

2. Esegui il comando per inserire il tag node-app:0.2.

docker build -t {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id | "PROJECT_ID" }}}/my-repository/node-app:0.2 .

3. Esegui questo comando per controllare le immagini Docker create.

docker images

(Output comando)

REPOSITORY TAG IMAGE ID CREATED node-app 0.2 76b3beef845e 22 hours {{{project_0.default_region | "REGION"}}}-....node-app:0.2 0.2 76b3beef845e 22 hours node-app 0.1 f166cd2a9f10 26 hours node lts 5a767079e3df 7 days hello-world latest 1815c82652c0 7 weeks

4. Esegui il push dell'immagine in Artifact Registry.

docker push {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id | "PROJECT_ID" }}}/my-repository/node-app:0.2

Output comando (il tuo potrebbe essere diverso):

The push refers to a repository [{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/{{{project_0.project_id | "PROJECT_ID"}}}/my-repository/node-app:0.2] 057029400a4a: Pushed 342f14cb7e2b: Pushed 903087566d45: Pushed 99dac0782a63: Pushed e6695624484e: Pushed da59b99bbd3b: Pushed 5616a6292c16: Pushed f3ed6cb59ab0: Pushed 654f45ecb7e3: Pushed 2c40c66f7667: Pushed 0.2: digest: sha256:25b8ebd7820515609517ec38dbca9086e1abef3750c0d2aff7f341407c743c46 size: 2419

5. Una volta completato il push, dal Menu di navigazione, sotto CI/CD vai ad Artifact Registry > Repository.

6. Fai clic su my-repository. Dovresti vedere il container Docker node-app creato:

Testa l'immagine

Potresti avviare una nuova VM, accedervi tramite SSH e installare gcloud. Per semplicità, rimuovi tutti i container e le immagini per simulare un nuovo ambiente.

1. Arresta e rimuovi tutti i container:

docker stop $(docker ps -q) docker rm $(docker ps -aq)

Devi rimuovere le immagini figlio (di node:lts) prima di rimuovere l'immagine node.

2. Esegui questo comando per rimuovere tutte le immagini Docker.

docker rmi {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id| "PROJECT_ID" }}}/my-repository/node-app:0.2 docker rmi node:lts docker rmi -f $(docker images -aq) # remove remaining images docker images

(Output comando)

REPOSITORY TAG IMAGE ID CREATED SIZE

A questo punto dovresti avere un ambiente pseudo-nuovo.

3. Esegui il pull dell'immagine, quindi eseguila.

docker run -p 4000:80 -d {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id| "PROJECT_ID" }}}/my-repository/node-app:0.2

4. Esegui un comando curl sul container in esecuzione.

curl http://localhost:4000

(Output comando)

Welcome to Cloud

Verifica l'attività completata

Fai clic su Controlla i miei progressi per verificare l'attività eseguita. Se hai pubblicato un'immagine container in Artifact Registry, vedrai un punteggio di valutazione.

Pubblica l'immagine container in Artifact Registry

Qui viene mostrata la portabilità dei container. Finché Docker è installato sull'host (on-premise o VM), può eseguire il pull delle immagini da registri pubblici o privati ed eseguire i container in base a questa immagine. Non ci sono dipendenze dell'applicazione che devono essere installate sull'host ad eccezione di Docker.

Complimenti!

Complimenti! In questo lab hai svolto varie attività pratiche, inclusa l'esecuzione di container in base a immagini pubbliche da Docker Hub. Hai anche creato immagini container e ne hai eseguito il push in Google Artifact Registry. Inoltre, il lab ti ha fornito le competenze per eseguire efficacemente il debug dei container in esecuzione. Infine, hai acquisito esperienza nell'esecuzione di container in base a immagini estratte da Google Artifact Registry, migliorando la tua comprensione e conoscenza di Docker.

Prossimi passi/Scopri di più

• Riferimento Dockerfile
• Docker Hub
• Scopri di più su Docker nella documentazione ufficiale
• Documentazione di Artifact Registry

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: 29 febbraio 2024

Ultimo test del lab: 29 febbraio 2024

Copyright 2024 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.