Attività 2: fai il provisioning di Jenkins

Crea un cluster Kubernetes e abilita Jenkins per accedere ai servizi Google Cloud e a Google Artifact 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 potrebbe richiedere alcuni minuti. Gli ambiti aggiuntivi consentono a Jenkins di accedere ai servizi Google Cloud e a Google Artifact 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 ai servizi Google Cloud e a Google Artifact 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 fatto 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 template 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 fare 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 fare 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 questo comando 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à, farai 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 fa una query sul servizio gceme di backend ed mostra il JSON risultante nell'interfaccia utente.

Attività 7: fai il deployment dell'applicazione

Fai 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 fatto 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 questo comando:

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 questo comando (dovrebbe riportare 1.0.0):

curl http://$FRONTEND_SERVICE_IP/version

Hai fatto 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à, configurerai un repository Git sul tuo server Git dedicato e creerai la pipeline Jenkins:

• Invia il codice sorgente dell'applicazione di esempio al server Git
• Aggiungi le credenziali dell'account di servizio a Jenkins
• Configura Jenkins Cloud per Kubernetes
• Crea il job di pipeline multibranch di Jenkins

Invia il codice sorgente dell'app di esempio al server Git

1. In Cloud Shell, recupera l'indirizzo IP esterno del tuo server Git:

export GIT_SERVER_IP=$(gcloud compute instances describe git-server --zone={{{project_0.default_zone}}} --format='get(networkInterfaces[0].accessConfigs[0].natIP)') echo "Git Server IP: ${GIT_SERVER_IP}"

2. Inizializza la directory sample-app come repository Git:

cd ~/continuous-deployment-on-kubernetes/sample-app git init git config --global user.email "student@qwiklabs.net" git config --global user.name "Student" git branch -m master

3. Aggiungi il repository remoto che punta al tuo server Git self-hosted:

git remote add origin http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/sample-app.git

4. Aggiungi, esegui il commit e invia i file al branch master:

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

Aggiungi le credenziali dell'account di servizio

Configura le tue credenziali per consentire a Jenkins di accedere al cluster ed eseguire il deployment delle risorse.

1. Nell'interfaccia utente di Jenkins, fai clic su Manage Jenkins nel riquadro a sinistra, quindi su Credentials (in Security).

2. In Stores scoped to Jenkins, fai clic su System.

3. Fai clic su Global credentials (unrestricted).

4. Fai clic su Add Credentials.

5. Per Kind, seleziona Google Service Account from metadata e fai clic su Next.

6. Nel campo ID, inserisci il tuo ID progetto () e fai clic su Create.

Nota: Il tuo ID progetto è indicato nel riquadro DETTAGLI CONNESSIONE del lab.

Le credenziali globali sono state aggiunte.

Configura Jenkins Cloud per Kubernetes

1. Nell'interfaccia utente di Jenkins, seleziona Manage Jenkins > Clouds (o System > Clouds).
2. Fai clic su New cloud.
3. Nel campo Cloud name, digita kubernetes, seleziona Kubernetes per Type e fai clic su Create.
4. Nel campo Jenkins URL, inserisci il seguente valore: http://cd-jenkins:8080.
5. Nel campo Jenkins tunnel, inserisci il seguente valore: cd-jenkins-agent:50000.
6. Fai clic su Save.

Crea il job Jenkins

Accedi all'interfaccia utente di Jenkins e procedi come segue per configurare un job di pipeline multibranch:

1. Fai clic su Jenkins > New Item nel riquadro a sinistra.

2. Inserisci il nome dell'elemento sample-app, scegli l'opzione Multibranch Pipeline e fai clic su OK.

3. Nella pagina successiva, nella sezione Branch Sources, seleziona Git dal menu a discesa Add source.

4. Nel campo Project Repository, inserisci l'URL di clonazione del tuo repository:

http://{{{project_0.startup_script.git_server_ip}}}:3000/giteaadmin/sample-app.git Nota: Se la variabile non viene completata automaticamente, puoi inserire http://[GIT_SERVER_IP]:3000/giteaadmin/sample-app.git sostituendo [GIT_SERVER_IP] con l'IP del tuo server Git.

5. In Credentials, lascia impostato - none -.

6. Nella sezione Scan Multibranch Pipeline Triggers, seleziona la casella Periodically if not otherwise run e imposta il valore di Interval su 1 minute.

7. Lascia tutte le altre opzioni sui valori predefiniti e fai clic su Save.

Al termine di questi passaggi viene eseguito un job denominato Branch indexing. Questo meta-job individua i branch nel repository e verifica che non siano state apportate modifiche a quelli esistenti. Se fai clic su sample-app nel riquadro di navigazione, dovresti visualizzare il job master.

Nota: La prima esecuzione del job master potrebbe non riuscire finché non avrai apportato alcune modifiche al codice nel passaggio successivo.

Hai creato una pipeline Jenkins. Ora creerai l'ambiente di sviluppo per la continuous integration.

Attività 9: crea l'ambiente di sviluppo

I branch 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 fare 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 fare il push del branch al server Git e consentire a Jenkins di fare il deployment del tuo ambiente.

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

• Crea un branch di sviluppo e fanne 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: premi Esc, quindi:

:wq

Attività 10: avvia il deployment

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

1. Fai 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 branch 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 facendo 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: fai 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 fare il deployment di quel codice nell'ambiente canary.

1. Crea un branch canary e fanne 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 fatto il deployment di una versione canary. Ora farai il deployment della nuova versione in produzione.

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

Deployment di una versione canary

Attività 12: fai il deployment in produzione

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

1. Crea un branch canary e fanne 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.

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 fatto 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 fare 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: 20 maggio 2026

Ultimo test del lab: 26 febbraio 2026

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