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

Questo tutorial descrive come configurare una connessione da un'applicazione in esecuzione nel cluster Autopilot di Google Kubernetes Engine 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 il deployment, la scalabilità e la gestione automatica 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 i 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

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

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

    Go to project selector

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

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

    Go to project selector

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

  6. 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 modifiche.

    2. Nel passaggio Abilita API, fai clic su Abilita per attivare 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 dei 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.

  1. Vai alla console Google Cloud.

    Console Google Cloud

  2. Fai clic su Pulsante Attiva Cloud Shell Attiva Cloud Shell nella parte superiore della console Google Cloud.

  3. 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 è costituito da una serie 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 ai servizi privati 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

  1. In Cloud Shell, controlla se l'intervallo di indirizzi IP (IPv4) inutilizzati è già assegnato al peering di servizio:

    gcloud services vpc-peerings list --network=default

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

  2. (Salta se utilizzi il valore predefinito reservedPeeringRanges) Per allocare indirizzi IP inutilizzati nella 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.

  3. Per configurare l'accesso al servizio utilizzando l'intervallo IP allocato, esegui il seguente comando:

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

  4. Per eseguire il deployment del cluster AlloyDB, esegui il seguente 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 i server database del cluster siano compatibili. Scegli una delle opzioni seguenti:

      • 14: per la compatibilità con PostgreSQL 14

      • 15: per la compatibilità con PostgreSQL 15, che è la versione PostgreSQL predefinita supportata

      • 16: per la compatibilità con PostgreSQL 16 (anteprima)

        Per ulteriori informazioni sulle limitazioni che si applicano all'utilizzo di PostgreSQL 16 in anteprima, consulta la sezione Compatibilità di PostgreSQL 16 in anteprima.

    • CLUSTER_PASSWORD: la password da utilizzare per l'utente postgres predefinito.

    • PROJECT_ID: l'ID del tuo progetto Google Cloud dove vuoi posizionare il cluster.

    • REGION: il nome della regione in cui viene creato il cluster AlloyDB, ad esempio us-central1.

  5. Per eseguire il deployment dell'istanza principale di AlloyDB, esegui quanto segue:

    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 con 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

  1. Se non ti trovi nella pagina Panoramica del cluster appena creato, 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 CLUSTER_ID.

  3. Nel menu di navigazione, fai clic su AlloyDB Studio.

  4. 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). Il riquadro Explorer mostra un elenco degli oggetti nel database.

  5. 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 per il database AlloyDB, ad esempio tutorial.

    5. Fai clic su Esegui. Attendi che venga visualizzato il messaggio Statement executed successfully nel riquadro Risultati.

  6. Nel riquadro Explorer di AlloyDB Studio, fai clic su Cambia utente/database.

  7. 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). Il riquadro Explorer mostra un elenco degli oggetti nel database.

  8. 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 nello schema public:

      GRANT CREATE ON SCHEMA public TO "USERNAME";

    5. Fai clic su Esegui. Attendi che venga visualizzato il messaggio Statement executed successfully nel riquadro Risultati.

  9. Prendi nota del nome, del nome utente e della password del database. Utilizza queste informazioni in Creare un secret di Kubernetes.

Crea un cluster GKE Autopilot

Un cluster contiene almeno una macchina del piano di controllo 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

  1. Nella console Google Cloud, vai alla pagina Cluster Kubernetes.

    Vai ai cluster Kubernetes

  2. Fai clic su Crea.

  3. Specifica GKE_CLUSTER_ID per il cluster Autopilot nel campo Nome della pagina Nozioni di base sul cluster, ad esempio ap-cluster.

  4. Nel campo Regione, seleziona REGION, ad esempio us-central1.

  5. 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 è dipiegato il 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 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 contenitore sidecar. Il contenitore del proxy di autenticazione AlloyDB 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 concedi i ruoli agli account di servizio Google

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

Per eseguire AlloyDB Auth Proxy in Google Kubernetes Engine, devi creare 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

  1. Nella console Google Cloud, vai alla pagina IAM.

    Vai a IAM

  2. Nella pagina Autorizzazioni per il progetto "PROJECT_ID", individua la riga contenente l'account di servizio Compute Engine predefinito PROJECT_NUMBER-compute@developer.gserviceaccount.com e fai clic su Modifica entità nella riga.

    Per ottenere PROJECT_NUMBER, un identificatore univoco generato automaticamente per il 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.

  3. Fai clic su Aggiungi un altro ruolo.

  4. Per concedere il ruolo roles/artifactregistry.reader, fai clic su Seleziona un ruolo e scegli Artifact Registry in Per prodotto o servizio e Artifact Registry Reader in Ruoli.

  5. Fai clic su Salva. All'entità viene concesso il ruolo.

  6. Per creare un account di servizio per l'applicazione di esempio GKE, vai alla pagina Account di servizio. Vai ad Account di servizio

  7. Seleziona il progetto.

  8. Nella pagina Account di servizio per il progetto "PROJECT_ID", fai clic su Crea account di servizio.

  9. Nella sezione Dettagli account di servizio della pagina Crea account di servizio, inserisci GSA_NAME nel campo Nome account di servizio, ad esempio gke-alloydb-gsa.

  10. Fai clic su Crea e continua.

    Viene visualizzata la sezione (Facoltativo) Concedi a questo account di servizio l'accesso al progetto della pagina Crea account di servizio.

  11. Per concedere il ruolo roles/alloydb.client:

    1. Fai clic su Seleziona un ruolo.
    2. Scegli Cloud AlloyDB in Per prodotto o servizio.
    3. Scegli Cloud AlloyDB Client da Ruoli.

  12. Fai clic su Aggiungi un altro ruolo.

  13. Per concedere il ruolo roles/serviceusage.serviceUsageConsumer, fai clic su Seleziona un ruolo e scegli Service Usage in Per prodotto o servizio e Service Usage Consumer in Ruoli.

  14. Fai clic su Fine. All'account di servizio Google vengono concessi i ruoli.

gcloud

  1. Per concedere le autorizzazioni richieste all'account di servizio Google predefinito in modo che Compute Engine possa leggere da Artifact Registry, esegui quanto segue:

    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"

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

  3. Per concedere i ruoli alloydb.client e serviceusage.serviceUsageConsumer al gruppo di sicurezza 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 Workload Identity Federation for GKE per l'applicazione di esempio

Devi configurare GKE in modo da fornire l'account di servizio ad AlloyDB Auth Proxy utilizzando la funzionalità Workload Identity Federation for GKE. Questo metodo ti 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 l'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 lega un account di servizio Kubernetes a un account di servizio Google. Questo vincolo fa sì che tutti i deployment con l'account di servizio Kubernetes vengano autenticati come account di servizio Google nelle interazioni con Google Cloud.

gcloud

  1. Nella console Google Cloud, apri Cloud Shell.

    Apri Cloud Shell

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

  3. 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 dell'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.

  4. Crea un account di servizio Kubernetes per l'applicazione di esempio:

    kubectl apply -f service-account.yaml

  5. Concedi le autorizzazioni per consentire al tuo account di servizio Kubernetes di rubare l'identità dell'account di servizio Google creando un'associazione dei criteri IAM tra i due account di servizio:

    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

  6. Aggiungi l'annotazione iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID all'account di servizio Kubernetes utilizzando l'indirizzo email dell'account di servizio Google:

    kubectl annotate serviceaccount \
  KSA_NAME \
  iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com

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

gcloud

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

  2. 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 del progetto.
    • REPOSITORY_ID: il nome del repository, ad esempio gke-alloydb-sample-app.

  3. Nella finestra di dialogo Autorizza Cloud Shell, fai clic su Autorizza. Questo messaggio non viene visualizzato se hai già eseguito questo passaggio in precedenza.

  4. 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 del 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 dall'applicazione di esempio. I valori di ogni segreto 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, consulta Secrets.

gcloud

Utilizza un SECRET Kubernetes, ad esempio gke-alloydb-secret, per memorizzare 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 AlloyDB Proxy 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 che il traffico SQL venga esposto localmente. Il proxy AlloyDB fornisce la crittografia per le connessioni in uscita, ma devi limitare l'esposizione per le connessioni in entrata.
  • Impedisce un single point of failure. L'accesso di ogni applicazione al 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.
  • Ti consente di definire l'ambito delle richieste di risorse in modo più preciso. Poiché il proxy AlloyDB consuma risorse in modo lineare in base all'utilizzo, questo pattern ti consente di definire più accuratamente l'ambito e di richiedere risorse in base alle tue applicazioni man mano che si eseguono.
  • Ti consente di configurare l'applicazione in modo che si connetta utilizzando 127.0.0.1 su DB_PORT specificato nella sezione dei comandi.

Dopo aver creato un cluster GKE e aver 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 raccolta dei voti di esempio gke-alloydb-app, che utilizza AlloyDB come datastore.

  1. Ottieni la connessione dell'istanza INSTANCE_URI per l'istanza principale AlloyDB a cui vuoi connettere 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.

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

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

      nano proxy_sidecar_deployment.yaml

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

    3. Premi Control+O, premi Invio per salvare le modifiche e premi Control+X per uscire dall'editor.

  3. Per eseguire il deployment dell'applicazione gke-alloydb-app, applica il file di definizione gke-alloydb-app creato nel passaggio precedente:proxy_sidecar_deployment.yaml

    kubectl apply -f proxy_sidecar_deployment.yaml

  4. Verifica che lo stato di entrambi i contenitori nel pod sia running:

    kubectl get pods

    Esempio di output:

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

  5. 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 dell'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.

  6. Per eseguire il deployment dell'applicazione di servizio gke-alloydb-app, applica il file service.yaml:

     kubectl apply -f service.yaml

  7. Per ottenere i dettagli del servizio, incluso l'indirizzo IP esterno del servizio, 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

  8. Utilizza il valore dell'IP esterno del passaggio precedente per accedere all'applicazione di esempio all'URL seguente: 

    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 che hai creato per il tutorial.

Per eliminare il progetto:

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Gestire le risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.

  3. Nella finestra di dialogo, digita il tuo PROJECT_ID e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi