Questa pagina è stata tradotta dall'API Cloud Translation.

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

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

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

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

Abilita le API Cloud necessarie per creare e connetterti ad AlloyDB per PostgreSQL.

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

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

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.

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 for PostgreSQL dall'esterno del VPC configurato, configura l'accesso privato al servizio 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.

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, che è la versione PostgreSQL predefinita supportata.
  - 17: per la compatibilità con PostgreSQL 17
- 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

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

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 viene 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 in base all'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.
L'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. Al 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 Google, 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. L'account di servizio Google diventa quindi accessibile alle applicazioni che utilizzano il service account 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 questo account di servizio Kubernetes eseguano l'autenticazione come account di servizio Google nelle loro interazioni con Google Cloud.

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

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 tuo 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 tuo 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 su quelli specificati nel passaggio Connettiti all'istanza principale e crea un database e un utente AlloyDB di questo tutorial. Per ulteriori informazioni, vedi Secret.

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

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 principale 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 INSTANCE_URI che specifichi 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, 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

Avvia Cloud Shell

Console

Crea un cluster AlloyDB e la relativa istanza principale

gcloud

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

Console

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

gcloud

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

gcloud

Crea un secret Kubernetes

gcloud

Esegui il deployment ed esegui il proxy AlloyDB in un pattern sidecar

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