Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Connettiti da Google Kubernetes Engine (GKE) ad AlloyDB per PostgreSQL

Per connettere in modo sicuro un'applicazione containerizzata in un cluster Google Kubernetes Engine Autopilot a un'istanza AlloyDB per PostgreSQL, puoi eseguire il deployment del proxy di autenticazione AlloyDB come container sidecar su una connessione di rete con IP privato.

AlloyDB è un servizio di database completamente gestito e compatibile con PostgreSQL in Google Cloud, mentre Google Kubernetes Engine ti aiuta a eseguire automaticamente il deployment, la scalabilità e la gestione dei workload Kubernetes.

Obiettivi

Crea un'immagine Docker per AlloyDB.
Eseguire un'applicazione in Google Kubernetes Engine.
Connettiti a un'istanza AlloyDB utilizzando il proxy di autenticazione AlloyDB e l'IP interno.

Costi

Questo tutorial utilizza componenti fatturabili di Google Cloud, tra cui:

AlloyDB
Google Kubernetes Engine
Artifact Registry

Utilizza il Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.

Prima di iniziare

Console

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Verifica di disporre delle autorizzazioni necessarie per completare questo tutorial.
Abilita le API Cloud necessarie per creare e connetterti ad AlloyDB.

Abilita le API
1. Nel passaggio Conferma progetto, fai clic su Avanti per confermare il nome del progetto a cui apporterai le modifiche.
2. Nel passaggio Abilita API, fai clic su Abilita per abilitare quanto segue:
  - API AlloyDB
  - API Artifact Registry
  - API Compute Engine
  - API Cloud Resource Manager
  - API Cloud Build
  - API Container Registry
  - API Kubernetes Engine
  - API Service Networking
Nota: se hai già abilitato alcune o tutte queste API, non le vedrai elencate qui.

gcloud

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Verifica di disporre delle autorizzazioni necessarie per completare questo tutorial.

Ai fini di questo tutorial, utilizza l'applicazione web di esempio per la raccolta dei voti denominata gke-alloydb-app.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare le attività di questo tutorial, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

Databases Admin (roles/iam.databasesAdmin)
Amministratore di cluster Kubernetes Engine (roles/container.clusterAdmin)
Project IAM Admin (roles/resourcemanager.projectIamAdmin)
Kubernetes Engine Admin (roles/container.admin)
Artifact Registry Administrator (roles/artifactregistry.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Avvia Cloud Shell

Cloud Shell è un ambiente shell per la gestione delle risorse ospitate suGoogle Cloud.

Cloud Shell include Google Cloud CLI e gli strumenti a riga di comando kubectl preinstallati. gcloud CLI fornisce l'interfaccia a riga di comando principale per Google Cloud. kubectl fornisce l'interfaccia a riga di comando principale per l'esecuzione di comandi sui cluster Kubernetes.

Console

Per avviare Cloud Shell, completa i seguenti passaggi.

Vai alla console Google Cloud .

ConsoleGoogle Cloud
Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud .
Nella finestra di dialogo Autorizza Cloud Shell, fai clic su Autorizza.

Una sessione di Cloud Shell si apre in un frame nella parte inferiore della console. Utilizza questa shell per eseguire i comandi gcloud e kubectl.
1. Prima di eseguire i comandi, imposta il progetto predefinito in Google Cloud CLI utilizzando il seguente comando:
```
gcloud config set project PROJECT_ID
```
  Sostituisci PROJECT_ID con l'ID progetto.

gcloud

Per avviare Cloud Shell, completa i seguenti passaggi.
Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud , viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

Per inizializzare l'ambiente, imposta il progetto predefinito in Google Cloud CLI utilizzando il seguente comando:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con l'ID progetto.

Abilitare le API Cloud necessarie per creare e connettersi ad AlloyDB per PostgreSQL.

gcloud services enable alloydb.googleapis.com \
    compute.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudbuild.googleapis.com \
    containerregistry.googleapis.com \
    servicenetworking.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com

Crea un cluster AlloyDB e la relativa istanza principale

Il cluster AlloyDB è composto da un numero di nodi all'interno di un Virtual Private Cloud (VPC) di Google. Quando crei un cluster, configuri anche l'accesso privato ai servizi tra uno dei tuoi VPC e il VPC gestito da Google contenente il nuovo cluster. Ti consigliamo di utilizzare un accesso IP interno per evitare l'esposizione del database alla rete internet pubblica.

Per connetterti a un cluster AlloyDB per PostgreSQL dall'esterno del VPC configurato, configura l'accesso privato ai servizi nel VPC per AlloyDB e utilizza la rete VPC predefinita per eseguire query da un'applicazione di cui è stato eseguito il deployment in un cluster GKE.

Console

Vai alla pagina Cluster.

Vai a Cluster
Nella sezione Configura il cluster, nel campo ID cluster, inserisci un ID per il cluster. Deve iniziare con una lettera minuscola e può contenere lettere minuscole, numeri e trattini, ad esempio alloydb-cluster.
Nel campo Password, inserisci la CLUSTER_PASSWORD da utilizzare per l'utente del database postgres predefinito durante la creazione del cluster.
Nel campo Versione database, seleziona la versione principale di POSTGRES_VERSION per il nuovo cluster AlloyDB.
Seleziona un REGION per il tuo cluster, ad esempio us-central1.
Nella sezione Configura l'istanza principale, segui questi passaggi:
1. Nel campo ID istanza, inserisci INSTANCE_ID per l'istanza principale, ad esempio alloydb-primary.
2. Seleziona una serie di macchine, ad esempio N2.
3. Seleziona un tipo di macchina e specifica il numero di unità di elaborazione virtuali NUM_CPU, ad esempio 2.
4. Per assicurarti che un intervallo IP sia assegnato al peering di servizi, configura la connessione di accesso privato ai servizi (PSA):
  1. Nell'elenco Rete, seleziona default.
  2. Se un intervallo IP come default-ip-range è già prenotato, selezionalo dall'elenco Intervallo IP allocato.
  3. Se non è assegnato alcun intervallo IP, fai clic su Alloca intervallo IP personalizzato per allocare un nuovo IP_RANGE_NAME interno e configura la connessione.
Fai clic su Crea cluster.

Attendi che l'istanza AlloyDB venga creata. L'operazione può richiedere diversi minuti.

gcloud

In Cloud Shell, verifica se l'intervallo di indirizzi IP (IPv4) inutilizzati è già assegnato al peering di servizi:
```
gcloud services vpc-peerings list --network=default
```
Salta il passaggio successivo se l'output è simile al seguente:
```
network: projects/493573376485/global/networks/default
peering: servicenetworking-googleapis-com
reservedPeeringRanges:
- default-ip-range
service: services/servicenetworking.googleapis.com
```
In questo output, il valore di reservedPeeringRanges è default-ip-range, che puoi utilizzare come IP_RANGE_NAME per creare una connessione privata nel passaggio 3.
(Salta se utilizzi il valore predefinito di reservedPeeringRanges) Per allocare indirizzi IP inutilizzati nel VPC, utilizza il seguente comando:
```
gcloud compute addresses create IP_RANGE_NAME \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=16 \
    --description="VPC private service access" \
    --network=default
```
Sostituisci IP_RANGE_NAME con il nome degli indirizzi IP interni disponibili all'interno di una subnet AlloyDB, ad esempio alloydb-gke-psa-01.

Per configurare l'accesso ai servizi utilizzando l'intervallo IP allocato, esegui questo comando:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=IP_RANGE_NAME \
    --network=default

Per eseguire il deployment del cluster AlloyDB, esegui questo comando:
```
gcloud alloydb clusters create CLUSTER_ID \
    --database-version=POSTGRES_VERSION \
    --password=CLUSTER_PASSWORD \
    --network=default \
    --region=REGION \
    --project=PROJECT_ID
```
Sostituisci quanto segue:
- CLUSTER_ID: l'ID del cluster che stai creando. Deve iniziare con una lettera minuscola e può contenere lettere minuscole, numeri e trattini, ad esempio alloydb-cluster.
- VERSION: la versione principale di PostgreSQL con cui vuoi che siano compatibili i server di database del cluster. Scegli una delle opzioni seguenti:
  - 14: per la compatibilità con PostgreSQL 14
  - 15: per la compatibilità con PostgreSQL 15
  - 16: per la compatibilità con PostgreSQL 16
  - 17: per la compatibilità con PostgreSQL 17, che è la versione predefinita supportata di PostgreSQL
  - 18, per la compatibilità con PostgreSQL 18
- CLUSTER_PASSWORD: la password da utilizzare per l'utente postgres predefinito.
- PROJECT_ID: l'ID del tuo progetto Google Cloud in cui vuoi posizionare il cluster.
- REGION: il nome della regione in cui viene creato il cluster AlloyDB, ad esempio us-central1.
Per eseguire il deployment dell'istanza principale di AlloyDB, esegui questo comando:
```
gcloud alloydb instances create INSTANCE_ID \
    --instance-type=PRIMARY \
    --cpu-count=NUM_CPU \
    --region=REGION \
    --cluster=CLUSTER_ID \
    --project=PROJECT_ID
```
Sostituisci quanto segue:
- INSTANCE_ID con il nome dell'istanza AlloyDB che preferisci, ad esempio alloydb-primary.
- CLUSTER_ID con il nome del cluster AlloyDB, ad esempio alloydb-cluster.
- NUM_CPU con il numero di unità di elaborazione virtuali, ad esempio 2.
- PROJECT_ID: l'ID del tuo progetto Google Cloud .
- REGION con il nome della regione in cui è stato creato il cluster AlloyDB, ad esempio us-central1.
Attendi che l'istanza AlloyDB venga creata. L'operazione può richiedere diversi minuti.

Connettiti all'istanza principale e crea un database e un utente AlloyDB

Per creare un database e un utente del database nell'istanza principale, completa i seguenti passaggi:

Console

Se non ti trovi nella pagina Panoramica del cluster appena creato, nella console Google Cloud , vai alla pagina Cluster.

Vai a Cluster
Per visualizzare la pagina Panoramica del cluster, fai clic sul nome del cluster CLUSTER_ID.
Nel menu di navigazione, fai clic su AlloyDB Studio.
Nella pagina Accedi ad AlloyDB Studio, segui questi passaggi:
1. Nell'elenco Database, seleziona postgres.
2. Nell'elenco Utente, seleziona postgres.
3. Nel campo Password, inserisci CLUSTER_PASSWORD che hai creato in Crea un cluster AlloyDB e la relativa istanza principale.
4. Fai clic su Authenticate (Autentica). Il riquadro Explorer mostra un elenco degli oggetti nel database.
Nella scheda Editor 1, completa quanto segue:
1. Crea un database AlloyDB:
```
CREATE DATABASE DATABASE_NAME;
```
  Sostituisci DATABASE_NAME con il nome che preferisci, ad esempio tutorial_db.
2. Fai clic su Esegui. Attendi che venga visualizzato il messaggio Statement executed successfully nel riquadro Risultati.
3. Fai clic su Cancella.
4. Crea un utente e una password del database AlloyDB:
```
CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';
```
  Sostituisci quanto segue:
  - USERNAME: il nome dell'utente AlloyDB, ad esempio tutorial_user.
  - DATABASE_PASSWORD: la password del database AlloyDB, ad esempio tutorial.
5. Fai clic su Esegui. Attendi che venga visualizzato il messaggio Statement executed successfully nel riquadro Risultati.
Nel riquadro Explorer di AlloyDB Studio, fai clic su Cambia utente/database.
Nella pagina Accedi ad AlloyDB Studio, segui questi passaggi:
1. Nell'elenco Database, seleziona DATABASE_NAME, ad esempio tutorial_db.
2. Nell'elenco Utente, seleziona postgres.
3. Nel campo Password, inserisci CLUSTER_PASSWORD che hai creato in Crea un cluster AlloyDB e la relativa istanza principale.
4. Fai clic su Authenticate (Autentica). Il riquadro Explorer mostra un elenco degli oggetti nel database.
Nella scheda Editor 1, completa quanto segue:
1. Concedi tutte le autorizzazioni all'utente del database AlloyDB:
```
GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";
```
2. Fai clic su Esegui. Attendi che venga visualizzato il messaggio Statement executed successfully nel riquadro Risultati.
3. Fai clic su Cancella.
4. Concedi le autorizzazioni all'utente del database AlloyDB sullo schema pubblico:
```
GRANT CREATE ON SCHEMA public TO "USERNAME";
```
5. Fai clic su Esegui. Attendi che venga visualizzato il messaggio Statement executed successfully nel riquadro Risultati.
Prendi nota del nome del database, del nome utente e della password. Utilizzerai queste informazioni in Crea un secret di Kubernetes.

gcloud

Per creare un utente del database AlloyDB, esegui questo comando in Cloud Shell:
```
gcloud alloydb users create USERNAME \
    --cluster=CLUSTER_ID \
    --region=REGION \
    --password=DATABASE_PASSWORD
```
Sostituisci quanto segue:
- USERNAME: il nome dell'utente AlloyDB, ad esempio tutorial_user.
- CLUSTER_ID: l'ID del cluster, ad esempio alloydb-cluster.
- REGION: la regione in cui si trova il cluster, ad esempio us-central1.
- DATABASE_PASSWORD: la password del database AlloyDB, ad esempio tutorial.
Per creare un database e concedere le autorizzazioni, devi connetterti al cluster ed eseguire i comandi SQL. In Cloud Shell, utilizza il client psql per connetterti all'istanza.

Nota: per connetterti a un'istanza AlloyDB da Cloud Shell, devi utilizzare il proxy di autenticazione AlloyDB. Per una configurazione più semplice, puoi eseguire questi passaggi utilizzando AlloyDB Studio nella console Google Cloud .
Una volta stabilita la connessione all'istanza come utente postgres, crea il database:
```
CREATE DATABASE DATABASE_NAME;
```
Sostituisci DATABASE_NAME con il nome che preferisci, ad esempio tutorial_db.
Concedi tutte le autorizzazioni all'utente del database AlloyDB sul nuovo database:
```
GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";
```
Connettiti al nuovo database e concedi le autorizzazioni per lo schema public:
```
\c DATABASE_NAME
GRANT CREATE ON SCHEMA public TO "USERNAME";
```
Prendi nota del nome del database, del nome utente e della password. Utilizzerai queste informazioni in Crea un secret di Kubernetes.

Crea un cluster GKE Autopilot

Un cluster contiene almeno una macchina del control plane del cluster e più macchine worker denominate nodi. I nodi sono istanze di macchine virtuali (VM) Compute Engine che eseguono i processi Kubernetes necessari per renderle parte del cluster. Puoi eseguire il deployment delle applicazioni sui cluster e le applicazioni vengono eseguite sui nodi.

Console

Nella console Google Cloud , vai alla pagina Cluster Kubernetes.

Vai ai cluster Kubernetes
Fai clic su Crea.
Specifica GKE_CLUSTER_ID per il tuo cluster Autopilot nel campo Nome della pagina Impostazioni di base del cluster, ad esempio ap-cluster.
Nel campo Regione, seleziona REGION, ad esempio us-central1.
Fai clic su Crea.

Attendi la creazione del cluster GKE. L'operazione può richiedere diversi minuti.

gcloud

Crea un cluster Autopilot:

gcloud container clusters create-auto GKE_CLUSTER_ID \
    --location=REGION

Sostituisci quanto segue:

GKE_CLUSTER_ID: il nome del cluster Autopilot, ad esempio ap-cluster.
REGION: il nome della regione in cui è stato eseguito il deployment del cluster GKE, ad esempio us-central1.

Attendi la creazione del cluster GKE. L'operazione può richiedere diversi minuti.

Connettiti ad AlloyDB utilizzando il proxy di autenticazione AlloyDB

Ti consigliamo di utilizzare AlloyDB Auth Proxy per connetterti ad AlloyDB. Il proxy di autenticazione AlloyDB fornisce crittografia e autenticazione efficaci utilizzando Identity and Access Management (IAM), che può contribuire a proteggere il database.

Quando ti connetti utilizzando il proxy di autenticazione AlloyDB, questo viene aggiunto al pod utilizzando il pattern del container sidecar. Il container del proxy di autenticazione AlloyDB si trova nello stesso pod della tua applicazione, il che consente all'applicazione di connettersi al proxy di autenticazione AlloyDB utilizzando localhost, aumentando la sicurezza e le prestazioni.

Concedi ad Artifact Registry l'accesso al account di servizio Compute Engine predefinito

Concedi il ruolo Artifact Registry Reader (roles/artifactregistry.reader) al account di servizio Compute Engine predefinito in modo che i nodi Google Kubernetes Engine possano eseguire il pull delle immagini container da Artifact Registry.

Console

Nella console Google Cloud vai alla pagina IAM.

Vai a IAM
Nella pagina Autorizzazioni per il progetto "PROJECT_ID", individua la riga contenente il account di servizio Compute predefinito PROJECT_NUMBER-compute@developer.gserviceaccount.com e fai clic su Modifica entità in quella riga.

Per ottenere il PROJECT_NUMBER, ovvero un identificatore univoco generato automaticamente per il tuo progetto, segui questi passaggi:
1. Vai alla pagina Dashboard nella console Google Cloud .
  
  Vai alla Dashboard
2. Fai clic sull'elenco a discesa Seleziona da nella parte superiore della pagina. Nella finestra Seleziona da che compare, seleziona il tuo progetto.
PROJECT_NUMBER viene visualizzato nella scheda Informazioni sul progetto della dashboard del progetto.
Fai clic su Aggiungi un altro ruolo.
Per concedere il ruolo roles/artifactregistry.reader, fai clic su Seleziona un ruolo e scegli Artifact Registry da Per prodotto o servizio, quindi scegli Artifact Registry Reader da Ruoli.
Fai clic su Salva. All'entità viene concesso il ruolo.

gcloud

Concedi il ruolo Artifact Registry Reader (roles/artifactregistry.reader) sul progetto al account di servizio Compute Engine predefinito:

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

Sostituisci PROJECT_ID con l'ID progetto.

Configura Workload Identity Federation for GKE per l'applicazione di esempio

Configura Google Kubernetes Engine per autenticare il proxy di autenticazione AlloyDB utilizzando Workload Identity Federation for GKE. Con Workload Identity Federation for GKE, crei un ServiceAccount Kubernetes per la tua applicazione nel cluster Google Kubernetes Engine e concedi i ruoli IAM a quel ServiceAccount Kubernetes. Crea un ServiceAccount Kubernetes univoco per ogni applicazione in modo da poter limitare le autorizzazioni in base all'applicazione.

Console

Per avviare Cloud Shell, completa i seguenti passaggi.
Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud , viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

In Cloud Shell, recupera le credenziali per il tuo cluster:
```
gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID
```
Questo comando configura kubectl in modo che utilizzi il cluster GKE che hai creato.
Nell'editor che preferisci, completa i seguenti passaggi:
1. Apri service-account.yaml utilizzando nano, ad esempio:
```
nano service-account.yaml
```
2. Nell'editor, incolla i contenuti seguenti:
```
apiVersion: v1
kind: ServiceAccount
metadata:
  name: KUBERNETES_SERVICEACCOUNT
```
  Sostituisci KUBERNETES_SERVICEACCOUNT con il nome del ServiceAccount Kubernetes, ad esempio alloydb-sa.
3. Premi Ctrl+O, poi Invio per salvare le modifiche e infine Ctrl+X per uscire dall'editor.
Crea un ServiceAccount Kubernetes per la tua applicazione di esempio:
```
kubectl apply -f service-account.yaml
```
Per concedere i ruoli IAM al ServiceAccount Kubernetes, completa i seguenti passaggi nella console Google Cloud :
1. Nella console Google Cloud vai alla pagina IAM.
  
  Vai a IAM
2. Seleziona il progetto.
3. Fai clic su Concedi l'accesso.
4. Nel campo Nuove entità, inserisci quanto segue:
  
  principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/default/sa/KUBERNETES_SERVICEACCOUNT
  
  Sostituisci quanto segue:
  - PROJECT_NUMBER: il numero del progetto.
  - PROJECT_ID: il tuo ID progetto.
  - KUBERNETES_SERVICEACCOUNT: il nome del ServiceAccount Kubernetes, ad esempio alloydb-sa.
5. Per concedere il ruolo roles/alloydb.client, nell'elenco Seleziona un ruolo, scegli AlloyDB per PostgreSQL > Client AlloyDB.
6. Fai clic su Aggiungi un altro ruolo.
7. Per concedere il ruolo roles/serviceusage.serviceUsageConsumer, nell'elenco Seleziona un ruolo, scegli Service Usage > Service Usage Consumer.
8. Fai clic su Salva.

gcloud

Nella console Google Cloud , apri Cloud Shell.

Apri Cloud Shell
In Cloud Shell, recupera le credenziali per il tuo cluster:
```
gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID
```
Questo comando configura kubectl in modo che utilizzi il cluster GKE che hai creato.
Nell'editor che preferisci, completa i seguenti passaggi:
1. Apri service-account.yaml utilizzando nano, ad esempio:
```
nano service-account.yaml
```
2. Nell'editor, incolla i contenuti seguenti:
```
apiVersion: v1
kind: ServiceAccount
metadata:
  name: KUBERNETES_SERVICEACCOUNT
```
  Sostituisci KUBERNETES_SERVICEACCOUNT con il nome del ServiceAccount Kubernetes, ad esempio alloydb-sa.
3. Premi Ctrl+O, poi Invio per salvare le modifiche e infine Ctrl+X per uscire dall'editor.
Crea un ServiceAccount Kubernetes per la tua applicazione di esempio:
```
kubectl apply -f service-account.yaml
```

Concedi i ruoli AlloyDB Client (roles/alloydb.client) e Service Usage Consumer (roles/serviceusage.serviceUsageConsumer) nel progetto al ServiceAccount Kubernetes:

PROJECT_ID="PROJECT_ID"
KUBERNETES_SERVICEACCOUNT="KUBERNETES_SERVICEACCOUNT"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/$KUBERNETES_SERVICEACCOUNT" \
    --role="roles/alloydb.client" \
    --condition=None
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/$KUBERNETES_SERVICEACCOUNT" \
    --role="roles/serviceusage.serviceUsageConsumer" \
    --condition=None

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto.
KUBERNETES_SERVICEACCOUNT: il nome del ServiceAccount Kubernetes, ad esempio alloydb-sa.

Compila Artifact Registry con un'immagine dell'applicazione di esempio

Per creare un'immagine container dell'applicazione di esempio ed eseguirne il push in un repository, completa i seguenti passaggi.

Console

Nella console Google Cloud , vai alla pagina Artifact Registry.

Vai ad Artifact Registry
Per creare un repository, fai clic su .
Nel campo Nome, inserisci REPOSITORY_ID, ad esempio gke-alloydb-sample-app.
Nella sezione Formato, seleziona Docker.
Nella sezione Tipo di località, seleziona Regione e scegli REGION, ad esempio us-central1.
Fai clic su Crea.
Per creare l'immagine dell'applicazione di esempio, avvia Cloud Shell e completa i seguenti passaggi.
Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud , viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

In Cloud Shell, clona il repository con il codice dell'applicazione gke-alloydb-app di esempio da GitHub:

  git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go

Nella finestra di dialogo Autorizza Cloud Shell, fai clic su Autorizza. Questo messaggio non viene visualizzato se hai già eseguito questo passaggio in precedenza.
Per creare il container Docker e pubblicarlo in Artifact Registry, esegui questo comando:
```
  gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID
```
Sostituisci quanto segue:
- PROJECT_ID: l'ID progetto.
- REPOSITORY_ID: il nome del repository, ad esempio gke-alloydb-sample-app.
- SAMPLE_APPLICATION: il nome dell'applicazione web di esempio, ad esempio gke-alloydb-app.

gcloud

In Cloud Shell, utilizza il seguente comando per clonare il repository con il codice dell'applicazione gke-alloydb-app di esempio da GitHub:
```
 git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go
```
Crea un repository in Artifact Registry per le immagini Docker:
```
gcloud artifacts repositories create REPOSITORY_ID --location REGION --repository-format=docker --project PROJECT_ID
```
Sostituisci quanto segue:
- PROJECT_ID: l'ID progetto.
- REPOSITORY_ID: il nome del repository, ad esempio gke-alloydb-sample-app.
Nella finestra di dialogo Autorizza Cloud Shell, fai clic su Autorizza. Questo messaggio non viene visualizzato se hai già eseguito questo passaggio in precedenza.
Per creare un container Docker e pubblicarlo in Artifact Registry, utilizza il seguente comando:
```
 gcloud builds submit --tag  REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID
```
Sostituisci quanto segue:
- PROJECT_ID: l'ID progetto.
- REPOSITORY_ID: il nome del repository, ad esempio gke-alloydb-sample-app.
- SAMPLE_APPLICATION: il nome dell'applicazione web di esempio, ad esempio gke-alloydb-app.

Crea un secret di Kubernetes

Crea secret di Kubernetes per il database, l'utente e la password utente che verranno utilizzati dall'applicazione di esempio. I valori di ogni secret si basano sui valori specificati nel passaggio Connettiti all'istanza principale e crea un database e un utente AlloyDB di questo tutorial. Per saperne di più, consulta Secret.

Console

In Cloud Shell aperto, utilizza un SECRET Kubernetes, ad esempio gke-alloydb-secret, per archiviare le informazioni di connessione:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

gcloud

Utilizza un SECRET Kubernetes, ad esempio gke-alloydb-secret, per archiviare le informazioni di connessione:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

Esegui il deployment e l'esecuzione del proxy AlloyDB in un pattern sidecar

Ti consigliamo di eseguire il proxy AlloyDB in un pattern sidecar come container aggiuntivo che condivide un pod con la tua applicazione per i seguenti motivi:

Impedisce che il traffico SQL venga esposto localmente. Il proxy AlloyDB fornisce la crittografia sulle connessioni in uscita, ma devi limitare l'esposizione per le connessioni in entrata.
Previene un single point of failure. L'accesso di ogni applicazione al tuo database è indipendente dagli altri, il che lo rende più resiliente.
Limita l'accesso al proxy AlloyDB, consentendoti di utilizzare le autorizzazioni IAM per applicazione anziché esporre il database all'intero cluster.
Consente di definire l'ambito delle richieste di risorse in modo più accurato. Poiché il proxy AlloyDB consuma risorse in modo lineare rispetto all'utilizzo, questo pattern ti consente di definire l'ambito e richiedere le risorse in modo più accurato per adattarle alle tue applicazioni man mano che scalano.
Consente di configurare l'applicazione per la connessione utilizzando 127.0.0.1 su DB_PORT specificato nella sezione dei comandi.

Dopo aver creato un cluster GKE e un'immagine container per la tua applicazione, esegui il deployment dell'applicazione containerizzata nel cluster GKE.

Console

In questo tutorial eseguirai il deployment dell'applicazione web di esempio per la raccolta dei voti, gke-alloydb-app, che utilizza AlloyDB come datastore.

Recupera l'URI di connessione (INSTANCE_URI) per l'istanza principale di AlloyDB:
1. Nella console Google Cloud , vai alla pagina Cluster.
  
  Vai a Cluster
2. Per visualizzare la pagina Panoramica del cluster, fai clic sul nome del cluster nella colonna Nome risorsa.
3. Nella sezione Istanze nel cluster, individua l'istanza principale e vai alla sezione Connettività (o fai clic su Visualizza configurazione della connettività).
4. Nel campo URI di connessione, fai clic sul pulsante Copia negli appunti.
Specifica questo INSTANCE_URI nel file di definizione proxy_sidecar_deployment.yaml nel passaggio 2.b di questa sezione.

In Cloud Shell, segui questi passaggi:

Apri proxy_sidecar_deployment.yaml utilizzando l'editor che preferisci, ad esempio nano:
```
nano proxy_sidecar_deployment.yaml
```

Nell'editor, incolla i contenuti seguenti:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KUBERNETES_SERVICEACCOUNT
      containers:
      - name: SAMPLE_APPLICATION
        # Replace <PROJECT_ID> and <REGION> with your project ID and region.
        image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
        imagePullPolicy: Always
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: username
        - name: DB_PASS
          valueFrom:
           secretKeyRef:
              name: SECRET
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: database
      - name: alloydb-proxy
        # This uses the latest version of the AlloyDB Auth proxy
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        command:
          - "/alloydb-auth-proxy"
          #AlloyDB instance name as parameter for the AlloyDB proxy
          - "INSTANCE_URI"
        securityContext:
          runAsNonRoot: true
        resources:
          requests:
            memory: "2Gi"
            cpu:    "1"

Sostituisci KUBERNETES_SERVICEACCOUNT con il nome del tuo ServiceAccount Kubernetes e INSTANCE_URI con il percorso che hai copiato nel passaggio 1.

Premi Ctrl+O, poi Invio per salvare le modifiche e infine Ctrl+X per uscire dall'editor.

Per eseguire il deployment dell'applicazione gke-alloydb-app, applica il file di definizione:
```
kubectl apply -f proxy_sidecar_deployment.yaml
```
Per verificare che l'applicazione sia in esecuzione, vai alla pagina Workload nella console Google Cloud :

Vai a Carichi di lavoro

Verifica che lo stato del deployment gke-alloydb sia OK.
Per connetterti all'applicazione di esempio utilizzando un bilanciatore del carico esterno, completa i seguenti passaggi in Cloud Shell:
1. Apri service.yaml:
```
nano service.yaml
```
2. Incolla i seguenti contenuti:
```
apiVersion: v1
kind: Service
metadata:
  name: SAMPLE_APPLICATION
spec:
  type: LoadBalancer
  selector:
    app: SAMPLE_APPLICATION
  ports:
  - port: 80
    targetPort: 8080
```
  Sostituisci SAMPLE_APPLICATION con il nome della tua applicazione, ad esempio gke-alloydb-app.
3. Salva ed esci dall'editor, quindi applica il servizio:
```
kubectl apply -f service.yaml
```
Per ottenere l'indirizzo IP esterno della tua applicazione, vai alla pagina Servizi e Ingress nella console Google Cloud :

Vai a Servizi e Ingress
Utilizza il valore nella colonna Endpoint esterni per accedere all'applicazione al seguente URL:

http://EXTERNAL_IP

gcloud

In questo tutorial eseguirai il deployment dell'applicazione web di esempio per la raccolta dei voti, gke-alloydb-app, che utilizza AlloyDB come datastore.

Recupera la connessione dell'istanza INSTANCE_URI per l'istanza AlloyDB principale a cui vuoi che si connetta il proxy AlloyDB:
```
   gcloud alloydb instances describe INSTANCE_ID \
   --cluster=CLUSTER_ID \
   --region=REGION \
   --format="value(name)"
```
Sostituisci quanto segue:
- INSTANCE_ID: il nome dell'istanza, ad esempio alloydb-primary.
- CLUSTER_ID: il nome del cluster, ad esempio alloydb-cluster.
L'output contiene il INSTANCE_URI specificato nel file di definizione proxy_sidecar_deployment.yaml nel passaggio 2.b di questa sezione.

Nell'editor che preferisci, ad esempio nano, completa i seguenti passaggi:

Apri proxy_sidecar_deployment.yaml utilizzando l'editor che preferisci, ad esempio nano:
```
nano proxy_sidecar_deployment.yaml
```

Nell'editor, incolla i contenuti seguenti:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KUBERNETES_SERVICEACCOUNT
      containers:
      - name: SAMPLE_APPLICATION
        # Replace <PROJECT_ID> and <REGION> with your project ID and region.
        image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
        imagePullPolicy: Always
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        # This project uses environment variables to determine
        # how you would like to run your application
        # To use the Go connector (recommended) - use INSTANCE NAME
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        # To use Automatic IAM Authentication (recommended)
        # use DB_IAM_USER instead of DB_USER
        # you may also remove the DB_PASS environment variable
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: username
        - name: DB_PASS
          valueFrom:
           secretKeyRef:
              name: SECRET
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: database
     # If you are using the Go connector (recommended), you can
      # remove alloydb-proxy (everything below this line)
      - name: alloydb-proxy
        # This uses the latest version of the AlloyDB Auth proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/alloydb-auth-proxy
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        command:
          - "/alloydb-auth-proxy"
          #AlloyDB instance name as parameter for the AlloyDB proxy
          # Use <INSTANCE_URI>
          - "INSTANCE_URI"
        securityContext:
          # The default AlloyDB Auth proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

Sostituisci KUBERNETES_SERVICEACCOUNT con il nome del tuo ServiceAccount Kubernetes e sostituisci INSTANCE_URI con il percorso dell'istanza principale AlloyDB del passaggio 1, ad esempio projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_ID/instances/INSTANCE_ID.

Premi Ctrl+O, poi Invio per salvare le modifiche e infine Ctrl+X per uscire dall'editor.

Per eseguire il deployment dell'applicazione gke-alloydb-app, applica il file di definizione proxy_sidecar_deployment.yaml che hai creato nel passaggio precedente:
```
kubectl apply -f proxy_sidecar_deployment.yaml
```

Verifica che lo stato di entrambi i container nel pod sia running:

kubectl get pods

Esempio di output:

 NAME                          READY   STATUS    RESTARTS   AGE
 gke-alloydb-8d59bb4cc-62xgh   2/2     Running   0          2m53s

Per connetterti all'applicazione gke-alloydb-app di esempio, utilizza un servizio, ad esempio un bilanciatore del carico HTTP esterno. Nell'editor che preferisci, segui questi passaggi:
1. Apri service.yaml utilizzando nano, ad esempio:
```
nano service.yaml
```
2. Nell'editor nano, incolla i seguenti contenuti:
```
apiVersion: v1
kind: Service
metadata:
  name: SAMPLE_APPLICATION
spec:
  type: LoadBalancer
  selector:
    app: SAMPLE_APPLICATION
  ports:
  - port: 80
    targetPort: 8080
```
  Sostituisci SAMPLE_APPLICATION con il nome della tua applicazione web di esempio, ad esempio gke-alloydb-app.
3. Premi Ctrl+O, poi Invio per salvare le modifiche e infine Ctrl+X per uscire dall'editor.
Per eseguire il deployment dell'applicazione del servizio gke-alloydb-app, applica il file service.yaml:
```
 kubectl apply -f service.yaml
```

Per ottenere i dettagli del servizio, incluso l'indirizzo IP esterno, utilizza il seguente comando:

kubectl get service

Esempio di output:

NAME              TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
gke-alloydb-app   LoadBalancer   34.118.229.246   35.188.16.172   80:32712/TCP   45s
kubernetes        ClusterIP      34.118.224.1     <none>          443/TCP        85m

Utilizza il valore dell'IP esterno del passaggio precedente per accedere all'applicazione di esempio al seguente URL:
```
http://EXTERNAL-IP
```

File di configurazione di esempio

proxy_sidecar_deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <YOUR-DEPLOYMENT-NAME>
spec:
  selector:
    matchLabels:
      app: <YOUR-APPLICATION-NAME>
  template:
    metadata:
      labels:
        app: <YOUR-APPLICATION-NAME>
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      # Your application container goes here.
      - name: <YOUR-APPLICATION-NAME>
        image: <YOUR-APPLICATION-IMAGE-URL>
        env:
        - name: DB_HOST
          # The port value here (5432) should match the --port flag below.
          value: "localhost:5432"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: username
        - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: database
      # The Auth Proxy sidecar goes here.
      - name: alloydb-auth-proxy
        # Make sure you have automation that upgrades this version regularly.
        # A new version of the Proxy is released monthly with bug fixes,
        # security updates, and new features.
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        args:
          # If you're connecting over public IP, enable this flag.
          # - "--public-ip"

          # If you're connecting with PSC, enable this flag:
          # - "--psc"

          # If you're using auto IAM authentication, enable this flag:
          # - "--auto-iam-authn"

          # Enable structured logging with Google's LogEntry format:
          - "--structured-logs"

          # Listen on localhost:5432 by default.
          - "--port=5432"
          # Specify your instance URI, e.g.,
          # "projects/myproject/locations/us-central1/clusters/mycluster/instances/myinstance"
          - "<INSTANCE-URI>"

        securityContext:
          # The default AlloyDB Auth Proxy image runs as the "nonroot" user and
          # group (uid: 65532) by default.
          runAsNonRoot: true
        # You should use resource requests/limits as a best practice to prevent
        # pods from consuming too many resources and affecting the execution of
        # other pods. You should adjust the following values based on what your
        # application needs. For details, see
        # https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

service.yaml

apiVersion: v1
kind: Service
metadata:
  name: <YOUR-SERVICE-NAME>
spec:
  type: LoadBalancer
  selector:
    app: <YOUR-APPLICATION-NAME>
  ports:
  - port: 80
    targetPort: 8080

service-account.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: <YOUR-KSA-NAME> # TODO(developer): replace this value

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 eliminare la fatturazione è eliminare il progetto creato per il tutorial.

Per eliminare il progetto:

Nella console Google Cloud , vai alla pagina Gestisci risorse.

Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita il tuo PROJECT_ID, quindi fai clic su Chiudi per eliminare il progetto.

Connettiti da Google Kubernetes Engine (GKE) ad AlloyDB per PostgreSQL Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Console

gcloud

Ruoli obbligatori

Avvia Cloud Shell

Console

gcloud

Crea un cluster AlloyDB e la relativa istanza principale

Console

gcloud

Connettiti all'istanza principale e crea un database e un utente AlloyDB

Console

gcloud

Crea un cluster GKE Autopilot

Console

gcloud

Connettiti ad AlloyDB utilizzando il proxy di autenticazione AlloyDB

Concedi ad Artifact Registry l'accesso al account di servizio Compute Engine predefinito

Console

gcloud

Configura Workload Identity Federation for GKE per l'applicazione di esempio

Console

gcloud

Compila Artifact Registry con un'immagine dell'applicazione di esempio

Console

gcloud

Crea un secret di Kubernetes

Console

gcloud

Esegui il deployment e l'esecuzione del proxy AlloyDB in un pattern sidecar

Console

gcloud

File di configurazione di esempio

proxy_sidecar_deployment.yaml

service.yaml

service-account.yaml

Esegui la pulizia

Elimina il progetto

Passaggi successivi

Connettiti da Google Kubernetes Engine (GKE) ad AlloyDB per PostgreSQL