Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment di un'app utilizzando GKE Autopilot e Spanner

Autopilot

Questo tutorial descrive come eseguire il deployment di un'applicazione web containerizzata in un cluster GKE Autopilot e come utilizzare un database Google Spanner nel backend per archiviare i dati. L'applicazione di esempio gestisce una tabella di giocatori. Puoi aggiungere ed eliminare giocatori tramite l'interfaccia utente (GUI) dell'app.

Spanner è un servizio di database relazionale completamente gestito, scalabile orizzontalmente e distribuito a livello globale che fornisce transazioni ACID e semantica SQL senza compromettere le prestazioni e l'alta disponibilità.

Prima di leggere questa pagina, assicurati di conoscere Kubernetes.

Perché GKE e Spanner

In qualità di sviluppatore, potresti non voler perdere tempo a capire la quantità di risorse di archiviazione e di calcolo di cui ha bisogno la tua applicazione, a prevedere il consumo di RAM e CPU durante i periodi di domanda fluttuante o a preoccuparti del malfunzionamento dell'applicazione in caso di picco di carico.

Utilizzando GKE Autopilot come servizio Kubernetes completamente gestito e Spanner come servizio di database completamente gestito, puoi sviluppare e implementare le app più velocemente su un'infrastruttura stabile che semplifica la configurazione e la gestione delle risorse. GKE Autopilot gestisce la configurazione e la scalabilità dell'infrastruttura per l'hosting della tua app aggiungendo o rimuovendo nodi dal cluster in base ai requisiti di runtime. Analogamente, Spanner può eseguire la scalabilità dinamica in entrata e in uscita con un intervento manuale minimo, man mano che i requisiti di archiviazione o di calcolo cambiano.

Ad esempio, immagina di lanciare il prossimo gioco di successo che prevedi di far diventare virale e, di conseguenza, di attirare un intenso traffico web durante la settimana del lancio. Spanner può aiutarti ad adattarti a questo aumento della velocità effettiva offrendo la possibilità di aumentare, diminuire o riallocare istantaneamente le risorse di calcolo, mantenendo al contempo la massima disponibilità dell'applicazione con GKE Autopilot.

Obiettivi

In questo tutorial imparerai a:

Crea un database Spanner che memorizzi un registry di giocatori.
Esegui il deployment di un'app web di esempio chiamata hello-app-cloud-spanner con un'interfaccia utente grafica.

La tabella seguente descrive le Google Cloud risorse che crei o utilizzi, le variabili con cui sono identificate e i valori prescritti per esse ai fini di questo tutorial:

Risorsa	Variabile	Valore
Google Cloud ID progetto	`PROJECT_ID`	L'ID progetto generato quando crei un progetto. Esempio: `my-gcp-project`
Regione di calcolo	`COMPUTE_REGION`	La regione Compute Engine in cui vuoi creare l'istanza Spanner e il cluster GKE. Ti consigliamo di scegliere una regione più vicina alla posizione geografica dei tuoi clienti, ma per questo tutorial utilizza `us-west1`.
Istanza Spanner	-	`hello-instance`
Database Spanner	-	`hello-database`
Cluster GKE Autopilot	`CLUSTER_NAME`	`hello-cluster`
Spazio dei nomi Kubernetes	`NAMESPACE`	`hello-namespace`
Service account Kubernetes	`KSA_NAME`	`ksa-helloapp`
Service account IAM	`GSA_NAME`	`gsa-helloapp`
ID progetto dell'account di servizio IAM	`GSA_PROJECT`	Il tuo Google Cloud `PROJECT_ID`.

Ai fini di questo tutorial, ti consigliamo di creare nuove risorse, in modo da poterle eliminare facilmente e senza rischi dopo aver disegnato l'app di esempio. Tuttavia, se disponi di spazi dei nomi, account di servizio IAM e account di servizio Kubernetes esistenti, puoi utilizzarli.

Costi

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

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

Assicurati di completare i seguenti prerequisiti:

Seleziona o crea un progetto

Puoi utilizzare un progetto esistente o crearne uno nuovo per questo tutorial.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

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

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

Go to project selector

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

Abilita le API

Enable the Artifact Registry, Compute Engine, GKE, and IAM Service Account Credentials APIs.

Enable the APIs

Configura Cloud Shell

In questo tutorial utilizzerai Cloud Shell per eseguire i comandi gcloud e kubectl. Cloud Shell è un ambiente shell per la gestione delle risorse ospitate su Google Cloud. È preinstallato con lo strumento a riga di comando Google Cloud CLI e kubectl.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Una sessione di Cloud Shell si apre in un frame nella parte inferiore della console.

Prima di eseguire i comandi in questo tutorial, assicurati che il progetto predefinito sia impostato sull'ID progetto in cui vuoi eseguire il deployment dell'app di esempio. Se non è già impostato, esegui il seguente comando in Cloud Shell:

gcloud config set project PROJECT_ID

Sostituisci PROJECT_ID con il tuo ID progetto.

Concedi ruoli IAM

Assicurati che il tuo Google Cloud account disponga dei ruoli IAM richiesti per questo tutorial.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/iam.serviceAccountAdmin, roles/serviceusage.serviceUsageConsumer, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/spanner.admin, roles/container.admin

gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

Replace PROJECT_ID with your project ID.
Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
Replace ROLE with each individual role.

Configura Spanner

Per configurare Spanner, devi creare un'istanza Spanner e un database Spanner.

Creazione di un'istanza di Spanner

Un'istanza Spanner è un'allocazione di risorse utilizzata dai database Spanner creati in quell'istanza.

Crea un'istanza Spanner denominata hello-instance con una configurazione regionale e una capacità di calcolo di 100 unità di elaborazione.

gcloud spanner instances create hello-instance \
    --config=regional-COMPUTE_REGION \
    --description="Spanner sample instance" \
    --processing-units=100

Sostituisci COMPUTE_REGION con us-west1 per questo tutorial.

Creazione di un database Spanner

Un database Spanner include tabelle, visualizzazioni e indici. Un database eredita le proprietà dall'istanza principale, ad esempio la configurazione (regionale o multiregionale), la capacità di calcolo e lo spazio di archiviazione disponibili.

Crea un database Spanner denominato hello-database con una tabella denominata Players utilizzando il dialetto GoogleSQL. Esegui la seguente query in Cloud Shell:

gcloud spanner databases create hello-database \
    --instance=hello-instance \
    --database-dialect=GOOGLE_STANDARD_SQL \
    --ddl="CREATE TABLE Players (
        PlayerUuid STRING(36) NOT NULL,
        FirstName STRING(1024),
        LastName STRING(1024),
        BirthDate DATE) PRIMARY KEY(PlayerUuid)"

Crea un cluster GKE Autopilot

Dopo aver configurato Spanner, crea un cluster Autopilot e utilizza la federazione delle identità dei carichi di lavoro per GKE per accedere al database in modo sicuro e gestibile.

Crea un cluster Autopilot denominato hello-cluster. Nei cluster Autopilot la federazione delle identità per i carichi di lavoro per GKE è abilitata per impostazione predefinita.

gcloud container clusters create-auto CLUSTER_NAME \
  --region=COMPUTE_REGION

Sostituisci quanto segue:

CLUSTER_NAME: hello-cluster
COMPUTE_REGION: la regione Compute Engine del tuo cluster. Per questo tutorial, utilizza la stessa regione, us-west1, in cui hai creato l'istanza Spanner. Per ridurre la latenza, ti consigliamo di creare l'istanza Spanner e il cluster GKE Autopilot nella stessa regione.

La creazione del cluster può richiedere fino a 8-10 minuti.

L'output è simile al seguente:

NAME: hello-cluster
LOCATION: us-west1
MASTER_VERSION: 1.26.5-gke.1200
MASTER_IP: 192.0.2.1
MACHINE_TYPE: e2-medium
NODE_VERSION: 1.26.5-gke.1200
NUM_NODES: 3
STATUS: RUNNING

Configura il cluster in modo che utilizzi Workload Identity Federation for GKE

Configura il cluster per l'autenticazione Google Cloud utilizzando Workload Identity Federation for GKE prima di eseguire il deployment dell'app.

Recupero delle credenziali per accedere al cluster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
  --region=COMPUTE_REGION
```
Sostituisci quanto segue:
- CLUSTER_NAME: hello-cluster
- COMPUTE_REGION: us-west1
In questo modo viene aggiornato un file kubeconfig con le credenziali e le informazioni sull'endpoint appropriate per fare in modo che kubectl indichi il tuo cluster.
Crea uno spazio dei nomi da utilizzare per l'account di servizio Kubernetes. Puoi anche utilizzare lo spazio dei nomi predefinito o qualsiasi spazio dei nomi esistente.
```
kubectl create namespace NAMESPACE
```
Sostituisci NAMESPACE con hello-namespace, il nome per il nuovo spazio dei nomi che stai creando.
Crea un account di servizio Kubernetes da utilizzare per la tua applicazione:
```
kubectl create serviceaccount KSA_NAME \
  --namespace NAMESPACE
```
Sostituisci quanto segue:
- KSA_NAME: ksa-helloapp, il nome del nuovo account di servizio Kubernetes che stai creando.
- NAMESPACE: hello-namespace
Crea un account di servizio IAM per la tua applicazione:
```
gcloud iam service-accounts create GSA_NAME \
  --project=GSA_PROJECT
```
Sostituisci quanto segue:
- GSA_NAME: gsa-helloapp, il nome del nuovo account di servizio IAM che stai creando.
- GSA_PROJECT: il tuo Google Cloud ID progetto. In questo tutorial, crei l'account servizio IAM nello stesso Google Cloud progetto in cui esegui il deployment dell'app di esempio. Pertanto, GSA_PROJECT e Google Cloud PROJECT_ID sono gli stessi.

Aggiungi un'associazione di criteri IAM per l'account di servizio IAM in modo che possa leggere e scrivere in Spanner:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member "serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Sostituisci quanto segue:

PROJECT_ID: il tuo Google Cloud ID progetto
GSA_NAME: gsa-helloapp

Esempio:

gcloud projects add-iam-policy-binding my-gcp-project \
  --member "serviceAccount:gsa-helloapp@my-gcp-project.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Consenti all'account di servizio Kubernetes di simulare l'account di servizio IAM aggiungendo un'associazione dei criteri IAM tra i due account di servizio. Questa associazione consente all'account di servizio Kubernetes di agire come account di servizio IAM, in modo che possa leggere e scrivere in Spanner.
```
gcloud iam service-accounts add-iam-policy-binding GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"
```
Sostituisci quanto segue:
- GSA_NAME: gsa-helloapp
- GSA_PROJECT: il tuo Google Cloud ID progetto
- PROJECT_ID: il tuo Google Cloud ID progetto
- NAMESPACE: hello-namespace
- KSA_NAME: ksa-helloapp
Esempio:
```
gcloud iam service-accounts add-iam-policy-binding gsa-helloapp@my-gcp-project.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:my-gcp-project.svc.id.goog[hello-namespace/ksa-helloapp]"
```
Annota l'account di servizio Kubernetes con l'indirizzo email dell'account di servizio IAM. In questo modo, l'app di esempio saprà quale account di servizio utilizzare per accedere ai servizi Google Cloud . Pertanto, quando l'app utilizza qualsiasi libreria client API di Google standard per accedere ai servizi Google Cloud , utilizza quell'account di servizio IAM.
```
kubectl annotate serviceaccount KSA_NAME \
  --namespace NAMESPACE \
  iam.gke.io/gcp-service-account=GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com
```
Sostituisci quanto segue:
- KSA_NAME: ksa-helloapp
- NAMESPACE: hello-namespace
- GSA_NAME: gsa-helloapp
- GSA_PROJECT: il tuo Google Cloud ID progetto
Esempio:
```
kubectl annotate serviceaccount ksa-helloapp \
  --namespace hello-namespace \
  iam.gke.io/gcp-service-account=gsa-helloapp@my-gcp-project.iam.gserviceaccount.com
```
Nota: se l'associazione IAM non esiste, questa annotazione da sola non concede al pod l'accesso per rubare l'identità dell'account di servizio IAM.

Esegui il deployment dell'app di esempio nel cluster

Ora che hai configurato GKE e Spanner con i servizi e l'autenticazione necessari, puoi eseguire il deployment dell'app di esempiohello-app-cloud-spanner.

Clona l'app di esempio dal repository GitHub in Cloud Shell:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

Avvia l'editor di Cloud Shell facendo clic su Apri editor nella barra degli strumenti della finestra del terminale.

Per ulteriori informazioni, consulta la panoramica dell'interfaccia dell'editor di Cloud Shell.
Apri il riquadro Esplora dell'editor di Cloud Shell e vai alla directory kubernetes-engine-samples/databases/hello-app-cloud-spanner/k8s.
Apri il file deployment.yaml e aggiorna il campo serviceAccountName sostituendo <KSA_NAME> con ksa-helloapp, il nome del tuo account di servizio Kubernetes.

Figura 1. Aggiorna il nome dell'account di servizio Kubernetes nel file di deployment.
Chiudi l'editor di Cloud Shell e torna al terminale Cloud Shell.
Nel terminale Cloud Shell, vai alla directory hello-app-cloud-spanner:
```
cd kubernetes-engine-samples/databases/hello-app-cloud-spanner
```
Esegui il deployment dell'applicazione:
```
kubectl apply -f k8s/deployment.yaml -n=NAMESPACE
```
Sostituisci NAMESPACE con hello-namespace.

Attendi che venga eseguito il deployment dell'applicazione con STATUS come Running:

kubectl get pods -n=NAMESPACE --watch

Sostituisci NAMESPACE con hello-namespace.

L'output è simile al seguente:

NAME                                       READY   STATUS              RESTARTS   AGE
hello-app-cloud-spanner-765c9b8779-lfcrc   0/1     ContainerCreating   0          87s
hello-app-cloud-spanner-765c9b8779-lfcrc   1/1     Running             0          3m15s

Premi Ctrl+C sulla tastiera per tornare al prompt dei comandi ed eseguire altri comandi.

Esporre l'app di esempio a internet

Per esporre un servizio Kubernetes all'esterno del cluster, crea un servizio di tipo LoadBalancer. Questo tipo di servizio genera un indirizzo IP del bilanciatore del carico esterno per i tuoi pod, raggiungibile tramite internet.

Esegui il deployment del bilanciatore del carico:
```
kubectl apply -f k8s/service.yaml -n=NAMESPACE
```
Sostituisci NAMESPACE con hello-namespace.
Attendi che venga assegnato un indirizzo IP esterno:
```
kubectl get service -n=NAMESPACE --watch
```
Sostituisci NAMESPACE con hello-namespace.
Una volta assegnato, copia il EXTERNAL-IP (ad esempio 203.0.113.0) e apri lo in un browser. Si apre un'interfaccia web che mostra e gestisce il database di giocatori.

Puoi utilizzare la GUI dell'app per creare o eliminare i record dei giocatori, che vengono salvati nel database Spanner.

Aggiungere o eliminare giocatori. — **Figura 2.** Creare o eliminare giocatori nel registry.

Esegui la seguente query per verificare se il database Spanner è stato aggiornato con le tue voci:

gcloud spanner databases execute-sql hello-database \
  --instance=hello-instance \
  --sql="SELECT * FROM Players LIMIT 10"

L'output è simile al seguente:

PlayerUuid: a1f34bbf-929c-498d-8b16-39bbb29d70e3
FirstName: John
LastName: Smith
BirthDate: 1997-07-12

PlayerUuid: d634e157-96ea-45f2-be3f-fb907ced188e
FirstName: Jane
LastName: Doe
BirthDate: 2013-07-12

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Il modo più semplice per evitare la fatturazione è eliminare il progetto che hai creato per questo tutorial.

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Se hai eliminato il progetto, la pulizia è completata. Se non hai eliminato il progetto, procedi con l'eliminazione delle risorse GKE e Spanner.

Elimina risorse GKE

Elimina il servizio. Questa operazione annulla l'assegnazione del Google Cloud bilanciatore del carico creato per il tuo servizio:
```
kubectl delete service hello-app-cloud-spanner -n=NAMESPACE
```
Sostituisci NAMESPACE con hello-namespace.
Elimina il cluster GKE. Vengono eliminate le risorse che costituiscono un cluster, ad esempio le istanze di calcolo, i dischi e le risorse di rete:
```
gcloud container clusters delete CLUSTER_NAME --region=COMPUTE_REGION
```
Sostituisci quanto segue:
- CLUSTER_NAME: hello-cluster
- COMPUTE_REGION: us-west1

Eliminare le risorse Spanner

Elimina il database Spanner:

gcloud spanner databases delete hello-database --instance=hello-instance

Elimina l'istanza di Spanner:

Attenzione: l'eliminazione di un'istanza rimuove definitivamente l'istanza e tutti i relativi database.
```
gcloud spanner instances delete hello-instance
```

Passaggi successivi

Scopri come creare un cluster GKE per l'installazione di Agones.
Scopri le best practice per l'utilizzo di Spanner come database per i videogiochi.
Scopri come eseguire il deployment di un database PostgreSQL ad alta disponibilità su GKE.
Scopri le best practice per il deployment dei database su GKE.