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

Questo tutorial descrive come configurare una connessione da un'applicazione in esecuzione in un cluster Google Kubernetes Engine Autopilot a un'istanza AlloyDB.

AlloyDB è un servizio di database completamente gestito e compatibile con PostgreSQL in Google Cloud.

Google Kubernetes Engine ti aiuta a eseguire automaticamente il deployment, la scalabilità e la gestione di Kubernetes.

Obiettivi

Crea un'immagine Docker per AlloyDB.
Esegui 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

Nel passaggio Conferma progetto, fai clic su Avanti per confermare il nome del progetto a cui apporterai le modifiche.
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

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 raccolta voti di esempio 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 cluster Kubernetes Engine (roles/container.clusterAdmin)
Project IAM Admin (roles/resourcemanager.projectIamAdmin)
Amministratore service account(roles/iam.serviceAccountAdmin)
Amministratore Kubernetes Engine(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 su Google Cloud.

Cloud Shell include gli strumenti a riga di comando Google Cloud CLI e 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 .

Google Cloud console
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 il tuo 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 il tuo ID progetto.

Abilita le API Cloud necessarie per creare e connetterti 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) 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 a internet pubblico.

Per connetterti a un cluster AlloyDB per PostgreSQL dall'esterno del VPC configurato, configura Private Service Access nel VPC per AlloyDB e utilizza la rete VPC predefinita per eseguire query da un'applicazione di cui è stato eseguito il deployment su 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 il CLUSTER_PASSWORD da utilizzare per l'utente del database postgres predefinito durante la creazione del cluster.
Nel campo Versione del database, seleziona la versione principale POSTGRES_VERSION per il nuovo cluster AlloyDB.
Seleziona un REGION per il 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 accesso privato ai servizi (PSA):
  1. Nell'elenco Rete, seleziona default.
  2. Se un intervallo IP come default-ip-range è già riservato, 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 configurare la connessione.
Fai clic su Crea cluster.

Attendi la creazione dell'istanza AlloyDB. L'operazione può richiedere diversi minuti.

gcloud

In Cloud Shell, controlla se l'intervallo di indirizzi IP (IPv4) inutilizzati è già assegnato al peering dei 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 quando 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 tuo nome per gli indirizzi IP interni disponibili all'interno di una subnet AlloyDB, ad esempio alloydb-gke-psa-01.

Per configurare l'accesso al servizio 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 Google Cloud progetto 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 viene creato il cluster AlloyDB, ad esempio us-central1.
Attendi la creazione dell'istanza AlloyDB. 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:
1. Nell'elenco Database, seleziona postgres.
2. Nell'elenco Utente, seleziona postgres.
3. Nel campo Password, inserisci CLUSTER_PASSWORD che hai creato in Creare un cluster AlloyDB e la relativa istanza principale.
4. Fai clic su Authenticate (Autentica). Nel riquadro Explorer viene visualizzato 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 il messaggio Statement executed successfully venga visualizzato nel riquadro Risultati.
3. Fai clic su Cancella.
4. Crea un utente di database AlloyDB e una password:
```
CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';
```
  Sostituisci quanto segue:
  - USERNAME: il nome dell'utente AlloyDB, ad esempio tutorial_user.
  - DATABASE_PASSWORD: la password per il database AlloyDB, ad esempio tutorial.
5. Fai clic su Esegui. Attendi che il messaggio Statement executed successfully venga visualizzato nel riquadro Risultati.
Nel riquadro Explorer di AlloyDB Studio, fai clic su Cambia utente/database.
Nella pagina Accedi ad AlloyDB Studio:
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 Creare un cluster AlloyDB e la relativa istanza principale.
4. Fai clic su Authenticate (Autentica). Nel riquadro Explorer viene visualizzato 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 il messaggio Statement executed successfully venga visualizzato nel riquadro Risultati.
3. Fai clic su Cancella.
4. Concedi le autorizzazioni all'utente del database AlloyDB nello schema pubblico:
```
GRANT CREATE ON SCHEMA public TO "USERNAME";
```
5. Fai clic su Esegui. Attendi che il messaggio Statement executed successfully venga visualizzato nel riquadro Risultati.
Prendi nota del nome del database, del nome utente e della password. Utilizza 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 per il database AlloyDB, ad esempio tutorial.
Per creare un database e concedere le autorizzazioni, devi connetterti al cluster ed eseguire 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 connesso 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. Utilizza queste informazioni in Crea un secret di Kubernetes.

Crea un cluster GKE Autopilot

Un cluster contiene almeno una macchina 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 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 il proxy di autenticazione AlloyDB per connetterti ad AlloyDB. AlloyDB Auth Proxy fornisce una crittografia e un'autenticazione avanzate utilizzando Identity and Access Management (IAM), il che può contribuire a proteggere il tuo database.

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

Crea e assegna ruoli agli account di servizio Google

In Google Cloud, le applicazioni utilizzano i service account per effettuare chiamate API autorizzate autenticandosi come account di servizio stesso. Quando un'applicazione esegue l'autenticazione come account di servizio, ha accesso a tutte le risorse a cui il account di servizio ha l'autorizzazione di accedere.

Per eseguire AlloyDB Auth Proxy in Google Kubernetes Engine, crea un account di servizio Google per rappresentare la tua applicazione. Ti consigliamo di creare un account di servizio univoco per ogni applicazione, anziché utilizzare lo stesso account di servizio ovunque. Questo modello è più sicuro perché ti consente di limitare le autorizzazioni per ogni applicazione.

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 predefinito di Compute PROJECT_NUMBER-compute@developer.gserviceaccount.com e fai clic su Modifica entità in quella riga.

Per ottenere l'PROJECT_NUMBER, un identificatore univoco generato automaticamente per il tuo progetto:
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 visualizzata, seleziona il tuo progetto.
Il 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 e Artifact Registry Reader da Ruoli.
Fai clic su Salva. All'entità viene concesso il ruolo.
Per creare un account di servizio per l'applicazione di esempio GKE, vai alla pagina Service account. Vai a Service account
Seleziona il progetto.
Nella pagina Account di servizio per il progetto "PROJECT_ID", fai clic su Crea service account.
Nella sezione Dettagli service account della pagina Crea service account, inserisci GSA_NAME nel campo Nome service account, ad esempio gke-alloydb-gsa.
Fai clic su Crea e continua.

Viene visualizzata la sezione Concedi a questo account di servizio l'accesso al progetto (facoltativo) della pagina Crea service account.
Per concedere il ruolo roles/alloydb.client:
1. Fai clic su Seleziona un ruolo.
2. Scegli Cloud AlloyDB da Per prodotto o servizio.
3. Scegli Cloud AlloyDB Client da Ruoli.
Fai clic su Aggiungi un altro ruolo.
Per concedere il ruolo roles/serviceusage.serviceUsageConsumer, fai clic su Seleziona un ruolo e scegli Service Usage da Per prodotto o servizio e Service Usage Consumer da Ruoli.
Fai clic su Fine. All'account di servizio Google vengono concessi i ruoli.

gcloud

Per concedere le autorizzazioni richieste al account di servizio Google predefinito in modo che Compute Engine possa leggere da Artifact Registry, esegui il comando seguente:

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

Per creare un account di servizio Google per la tua applicazione, crea un account di servizio IAM:
```
gcloud iam service-accounts create GSA_NAME \
--display-name="gke-tutorial-service-account"
```
Sostituisci GSA_NAME con il nome del nuovo account di servizio IAM, ad esempio gke-alloydb-gsa.

Per concedere i ruoli alloydb.client e serviceusage.serviceUsageConsumer al tuo account di servizio dell'applicazione, utilizza i seguenti comandi:

gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/alloydb.client"
gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/serviceusage.serviceUsageConsumer"

Configura la federazione delle identità per i workload per GKE per l'applicazione di esempio

Devi configurare GKE per fornire il account di servizio al proxy di autenticazione AlloyDB utilizzando la funzionalità Workload Identity Federation for GKE. Questo metodo consente di associare un account di servizio Kubernetes a un account di servizio Google. Il account di servizio Google diventa quindi accessibile alle applicazioni che utilizzano il account di servizio Kubernetes corrispondente.

Un account di servizio Google è un'identità IAM che rappresenta la tua applicazione in Google Cloud. Un account di servizio Kubernetes è un'identità che rappresenta la tua applicazione in un cluster Google Kubernetes Engine.

Workload Identity Federation for GKE associa un account di servizio Kubernetes a account di servizio Google. Questa associazione fa sì che tutti i deployment con quel account di servizio Kubernetes eseguano l'autenticazione come account di servizio Google nelle loro interazioni con Google Cloud.

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 per utilizzare 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 seguenti contenuti:
```
  apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: KSA_NAME
```
  Sostituisci KSA_NAME con il nome del account di servizio, ad esempio ksa-alloydb.
3. Premi Control+O, premi Invio per salvare le modifiche e premi Control+X per uscire dall'editor.
Crea un account di servizio Kubernetes per l'applicazione di esempio:
```
kubectl apply -f service-account.yaml
```
Per associare il account di servizio Kubernetes al account di servizio Google, completa i seguenti passaggi nella console Google Cloud :
1. Nella Google Cloud console, vai alla pagina Service account.
  
  Vai ad Account di servizio
2. Seleziona il progetto.
3. Fai clic sul nome del account di servizio Google GSA_NAME.
4. Fai clic sulla scheda Autorizzazioni.
5. Fai clic su Concedi l'accesso.
6. Nel campo Nuove entità, inserisci quanto segue:
  
  serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]
7. Nell'elenco Seleziona un ruolo, seleziona IAM > Utente identità del workload.
8. Fai clic su Salva.
In Cloud Shell, aggiungi l'annotazione iam.gke.io/gcp-service-account al account di servizio Kubernetes utilizzando l'indirizzo email del account di servizio Google:
```
kubectl annotate serviceaccount \
  KSA_NAME \
  iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
```

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 per utilizzare 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 seguenti contenuti:
```
  apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: KSA_NAME
```
  Sostituisci KSA_NAME con il nome del account di servizio, ad esempio ksa-alloydb.
3. Premi Control+O, premi Invio per salvare le modifiche e premi Control+X per uscire dall'editor.
Crea un account di servizio Kubernetes per l'applicazione di esempio:
```
kubectl apply -f service-account.yaml
```

Concedi le autorizzazioni al account di servizio Kubernetes per rappresentare il account di servizio Google creando un'associazione dei criteri IAM tra i due service account:

gcloud iam service-accounts add-iam-policy-binding \
   --role="roles/iam.workloadIdentityUser" \
   --member="serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]" \
   GSA_NAME@PROJECT_ID.iam.gserviceaccount.com

Aggiungi l'annotazione iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID al account di servizio Kubernetes utilizzando l'indirizzo email del account di servizio Google:
```
kubectl annotate serviceaccount \
  KSA_NAME \
  iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
```

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

Per creare un'immagine container dell'applicazione di esempio e inviarla a 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 di esempio gke-alloydb-app 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 prompt non viene visualizzato se hai già eseguito questo passaggio.
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 di esempio gke-alloydb-app 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 prompt non viene visualizzato se hai già eseguito questo passaggio.
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 Kubernetes

Crea i secret di Kubernetes per il database, l'utente e la password dell'utente da utilizzare nell'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 SECRET, 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 ed esegui il proxy AlloyDB in un pattern sidecar

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

Impedisce l'esposizione locale del traffico SQL. AlloyDB Proxy fornisce la crittografia per le connessioni in uscita, ma devi limitare l'esposizione per le connessioni in entrata.
Impedisce un singolo punto di errore. L'accesso di ogni applicazione al tuo database è indipendente dalle altre, 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é AlloyDB Proxy consuma risorse in modo lineare rispetto all'utilizzo, questo pattern ti consente di definire e richiedere le risorse in modo più accurato in base alle tue applicazioni man mano che vengono scalate.
Consente di configurare l'applicazione per la connessione tramite 127.0.0.1 su DB_PORT specificato nella sezione dei comandi.

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

Console

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

Recupera la stringa di connessione istanza INSTANCE_URI per l'istanza principale 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.
3. Nella tabella Istanze, fai clic sul nome dell'istanza primaria.
4. Nel campo URI istanza della pagina Panoramica, fai clic su Copia negli appunti.
Specifichi questo INSTANCE_URI nel file di definizione proxy_sidecar_deployment.yaml nel passaggio 2.b di questa sezione.

Nella sessione di Cloud Shell aperta, 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 seguenti contenuti:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KSA_NAME 
      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 INSTANCE_URI con il percorso che hai copiato nel passaggio 1.

Premi Control+O, premi Invio per salvare le modifiche e premi Control+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 di 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 dell'applicazione, ad esempio gke-alloydb-app.
3. Salva ed esci dall'editor, poi 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, esegui il deployment dell'applicazione web di esempio per la raccolta di voti, gke-alloydb-app, che utilizza AlloyDB come datastore.

Recupera la stringa di connessione dell'istanza INSTANCE_URI per l'istanza primaria AlloyDB 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 seguenti contenuti:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KSA_NAME
      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 INSTANCE_URI con il percorso dell'istanza principale di AlloyDB del passaggio 1, ad esempio projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_ID/instances/INSTANCE_ID.

Premi Control+O, premi Invio per salvare le modifiche e premi Control+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 Control+O, premi Invio per salvare le modifiche e premi Control+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 del servizio, utilizza questo 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

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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:5342"
        - 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

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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

Crea e assegna ruoli agli account di servizio Google

Console

gcloud

Configura la federazione delle identità per i workload per GKE per l'applicazione di esempio

Console

gcloud

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

Console

gcloud

Crea un secret Kubernetes

Console

gcloud

Esegui il deployment ed esegui il 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