Connettiti a Cloud SQL per PostgreSQL da Google Kubernetes Engine

Connettiti a Cloud SQL per PostgreSQL da Google Kubernetes Engine

MySQL   |  PostgreSQL   |  SQL Server

Questa pagina mostra come eseguire il deployment di un'app di esempio su Google Kubernetes Engine (GKE) collegata a un'istanza PostgreSQL utilizzando la console Google Cloud e un'applicazione client. Le risorse create in questa guida rapida in genere costano meno di uno a patto che tu completi i passaggi, inclusa la pulizia, in tempi brevi in modo adeguato.

Prima di iniziare

Nota: Il nome che utilizzi per il progetto deve essere compreso tra 4 e 30 caratteri. Quando digita il nome, il modulo suggerisce un ID progetto che puoi modificare. L'ID progetto deve essere compreso tra 6 e 30 caratteri, con una lettera minuscola come primo carattere. Puoi utilizzare un trattino, una lettera minuscola o una cifra per i caratteri rimanenti, ma l'ultimo carattere non può essere un trattino.

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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

6. Abilita le API Google Cloud necessarie per eseguire un'app di esempio Cloud SQL su GKE.

   Console

   Fai clic su Abilita API per abilitare le API richieste per questa guida introduttiva.

   Abilita le API

   Ciò abilita le seguenti API:

   • API Compute Engine
   • API Cloud SQL Admin
   • API Google Kubernetes Engine
   • API Artifact Registry
   • API Cloud Build

   gcloud

   Fai clic sul seguente pulsante per aprire Cloud Shell, che fornisce accesso da riga di comando alle risorse Google Cloud direttamente dal browser. Cloud Shell può essere utilizzato per eseguire i comandi gcloud presentati in questa guida rapida.

   Apri Cloud Shell

   Esegui il comando gcloud services enable come segue utilizzando Cloud Shell per abilitare le API richieste per questo Quickstart:

   gcloud services enable compute.googleapis.com sqladmin.googleapis.com \
        container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com

   Questo comando abilita le seguenti API:

   • API Compute Engine
   • API Cloud SQL Admin
   • API GKE
   • API Artifact Registry
   • API Cloud Build

Configura Cloud SQL

Crea un'istanza Cloud SQL

IP pubblico

Console

Creare un'istanza con un indirizzo IP pubblico

1. Nella console Google Cloud, vai alla pagina Istanze Cloud SQL.

   Vai a Istanze Cloud SQL

2. Fai clic su Crea istanza.
3. Fai clic su PostgreSQL.
4. Inserisci quickstart-instance nel campo ID istanza.
5. Inserisci una password per l'utente postgres. Salva questa password per un uso futuro.
6. Fai clic sull'opzione Zona singola per Scegli la disponibilità per regione e zona.
7. Fai clic ed espandi la sezione Mostra configurazioni.
8. Nel menu a discesa Tipo di macchina, seleziona Leggera.

9. Fai clic su Crea istanza e attendi fino all'inizializzazione e all'avvio dell'istanza.

gcloud

Creare un'istanza con un indirizzo IP pubblico

Prima di eseguire il comando gcloud sql instances create come indicato di seguito, sostituisci DB_ROOT_PASSWORD con la password dell'utente del database.

Facoltativamente, modifica i valori dei seguenti parametri:

• --database_version: il tipo e la versione del motore del database. Se questo valore non è specificato, viene utilizzato il valore predefinito dell'API. Consulta la documentazione sulle versioni del database gcloud per conoscere le versioni attualmente disponibili.
• --cpu: il numero di core desiderato nella macchina.
• --memory: il valore numerico intero che indica come desiderata nella macchina. Deve essere fornita una unità di misura (ad es. 3072 MB o 9 GB). Se non vengono specificate unità di misura, viene assunto il valore GB.
• --region: posizione regionale dell'istanza (ad esempio asia-east1, us-east1). Se non specificato, il valore predefinito È in uso us-central. Consulta l'elenco completo delle regioni.

Esegui il comando gcloud sql instances create per creare un'istanza Cloud SQL.

gcloud sql instances create quickstart-instance \
--database-version=POSTGRES_13 \
--cpu=1 \
--memory=4GB \
--region=us-central \
--root-password=DB_ROOT_PASSWORD

IP privato

Console

Creare un'istanza con un indirizzo IP privato e SSL abilitato

1. Nella console Google Cloud, vai alla pagina Istanze Cloud SQL.

   Vai a Istanze Cloud SQL

2. Fai clic su Crea istanza.
3. Fai clic su PostgreSQL.
4. Inserisci quickstart-instance nel campo ID istanza.
5. Inserisci una password per l'utente postgres. Salva questa password per un uso futuro.
6. Fai clic sull'opzione Zona singola per Scegli la disponibilità per regione e zona.
7. Fai clic ed espandi Mostra opzioni di configurazione.
8. Per Tipo di macchina, seleziona Leggera.
9. In Connessioni, seleziona IP privato.
10. Seleziona predefinita nel menu a discesa Rete.
11. Se viene visualizzata una finestra di dialogo Connessione di accesso privato ai servizi obbligatorio, fai clic sul pulsante Configura connessione.
• Nella finestra di dialogo Abilita l'API Service Networking, fai clic sul pulsante Abilita API.
• Nella finestra di dialogo Alloca un intervallo IP, seleziona Utilizza un intervallo IP nell'intervallo IP allocato e fai clic su Continua.
• Nella finestra di dialogo Crea una connessione, fai clic su Crea connessione.
12. Deseleziona la casella di controllo IP pubblico per creare un'istanza solo con un IP privato.
13. Fai clic su Crea istanza, quindi attendi che l'istanza venga inizializzata e avviata.
14. Fai clic su Connections (Connessioni).
15. Nella sezione Sicurezza, seleziona Consenti solo connessioni SSL per attivare le connessioni SSL.
16. Nella finestra di dialogo Consenti solo connessioni SSL, fai clic su Salva. e attenderemo il riavvio dell'istanza.

gcloud

Creare un'istanza con un indirizzo IP privato e SSL abilitato

Per creare un'istanza con un indirizzo IP privato è sufficiente configurare l'accesso privato ai servizi per attivare le connessioni da altri servizi Google Cloud, come GKE.

1. Esegui il comando gcloud compute addresses create per allocare un intervallo IP per una connessione di accesso privato ai servizi:

gcloud compute addresses create google-managed-services-default \
--global \
--purpose=VPC_PEERING \
--prefix-length=16 \
--description="peering range for Google" \
--network=default

2. Esegui il comando gcloud services vpc-peerings connect per creare la connessione di accesso privato ai servizi:

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

3. Prima di eseguire il comando gcloud sql instances create per creare un'istanza come segue, sostituisci DB_ROOT_PASSWORD con la password dell'utente del database.

Facoltativamente, modifica i valori dei seguenti parametri:

• --database_version: il tipo e la versione del motore del database. Se non viene specificato, viene utilizzato il valore predefinito dell'API. Consulta Versioni del database gcloud per un elenco delle versioni attualmente disponibili.
• --cpu: il numero di core nella macchina.
• --memory: un numero intero che indica come da includere nella macchina. L'unità di misura può essere forniti (ad esempio, 3072 MB o 9 GB). Se non viene specificata alcuna unità, si presume GB.
• --region: la posizione regionale dell'istanza (ad esempio asia-east1, us-east1). Se non specificato, viene utilizzato il valore predefinito us-central1. Consulta l'elenco completo delle regioni.

Esegui il comando gcloud sql instances create per creare un'istanza Cloud SQL con un indirizzo IP privato.

gcloud beta sql instances create quickstart-instance \
--database-version=POSTGRES_13 \
 --cpu=1 \
 --memory=4GB \
 --region=us-central \
 --root-password=DB_ROOT_PASSWORD \
 --no-assign-ip \
--network=default

4. Esegui gcloud sql instances patch. per consentire solo le connessioni SSL per l'istanza.

gcloud sql instances patch quickstart-instance --require-ssl

Crea un database

Console

1. Nella console Google Cloud, vai alla pagina Istanze Cloud SQL.

   Vai a Istanze Cloud SQL

2. Seleziona quickstart-instance.
3. Dal menu di navigazione SQL, seleziona Database.
4. Fai clic su Crea database.
1. Nel campo Nome database della finestra di dialogo Nuovo database, inserisci quickstart-db.
2. Fai clic su Crea.

gcloud

Esegui il comando gcloud sql databases create per creare un database.

gcloud sql databases create quickstart-db --instance=quickstart-instance

Crea un utente

Console

1. Nella console Google Cloud, vai alla pagina Istanze Cloud SQL.

   Vai a Istanze Cloud SQL

2. Per aprire la pagina Panoramica di un'istanza, fai clic sul nome dell'istanza.
3. Seleziona Users (Utenti) dal menu di navigazione SQL.
4. Fai clic su Aggiungi account utente.
5. Nella pagina Aggiungi un account utente all'istanza instance_name, aggiungi le seguenti informazioni:
   • Nome utente: impostato su quickstart-user
   • Password: specifica una password per l'utente del database. Conservalo per utilizzarlo in un passaggio successivo di questa guida rapida.
6. Fai clic su Aggiungi.

gcloud

Prima di eseguire il comando come segue, sostituisci DB_PASS con una password per l'utente del database. Annotalo per utilizzarlo in una passaggio successivo di questa guida rapida.

Esegui il comando gcloud sql users create per creare l'utente.

gcloud sql users create quickstart-user \
--instance=quickstart-instance \
--password=DB_PASS

I limiti di lunghezza del nome utente sono gli stessi per Cloud SQL e per PostgreSQL on-premise.

Crea un cluster GKE

Console

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

   Vai a Google Kubernetes Engine

2. Fai clic su Crea.
3. Fai clic su Configura per GKE Autopilot.
4. In Nome, specifica il nome del cluster come gke-cloud-sql-quickstart.
5. Fai clic su Crea.

gcloud

Esegui il comando gcloud container clusters create-auto per creare il cluster.

gcloud container clusters create-auto gke-cloud-sql-quickstart \
    --region us-central1

Clona un'app di esempio Cloud SQL nell'editor di Cloud Shell

Con un'istanza Cloud SQL, un database e un cluster GKE, ora puoi clonare e configurare un'applicazione di esempio per connetterti alla tua istanza Cloud SQL. I passaggi rimanenti di questa guida rapida richiedono l'utilizzo degli strumenti a riga di comando gcloud e kubectl. Entrambi gli strumenti sono preinstallati in Cloud Shell.

Vai

1. Nell'editor di Cloud Shell, apri il codice sorgente dell'app di esempio.
   Apri l'editor di Cloud Shell
2. Nella finestra di dialogo Open in Cloud Shell, fai clic su Conferma per scarica il codice dell'app di esempio e apri la directory dell'app di esempio nell'editor di Cloud Shell.

Java

1. Nell'editor di Cloud Shell, apri il codice sorgente dell'app di esempio.
   Apri l'editor di Cloud Shell
2. Nella finestra di dialogo Open in Cloud Shell, fai clic su Conferma per scarica il codice dell'app di esempio e apri la directory dell'app di esempio nell'editor di Cloud Shell.

Node.js

1. Nell'editor di Cloud Shell, apri il codice sorgente dell'app di esempio.
   Apri l'editor di Cloud Shell
2. Nella finestra di dialogo Open in Cloud Shell, fai clic su Conferma per scaricare il codice dell'app di esempio e aprire la directory dell'app di esempio nell'editor di Cloud Shell.

Python

1. Nell'editor di Cloud Shell, apri il codice sorgente dell'app di esempio.
   Apri l'editor di Cloud Shell
2. Nella finestra di dialogo Open in Cloud Shell, fai clic su Conferma per scarica il codice dell'app di esempio e apri la directory dell'app di esempio nell'editor di Cloud Shell.

Abilita il cluster GKE

Abilita il cluster GKE appena creato come cluster predefinito da utilizzare per i comandi rimanenti in questa guida rapida.

Esegui gcloud container clusters get-credentials come segue per abilitare il cluster GKE.

gcloud container clusters get-credentials gke-cloud-sql-quickstart \
  --region us-central1

Configurare un account di servizio

Creare e configurare un account di servizio Google Cloud che deve essere utilizzato da GKE in modo che abbia Ruolo Client Cloud SQL con autorizzazioni per la connessione a Cloud SQL.

1. Esegui il comando gcloud iam service-accounts create come segue per creare un nuovo account di servizio:

   gcloud iam service-accounts create gke-quickstart-service-account \
     --display-name="GKE Quickstart Service Account"

2. Esegui gcloud projects add-iam-policy-binding. come segue per aggiungere il ruolo Client Cloud SQL al Account di servizio Google Cloud che hai appena creato. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
     --member="serviceAccount:gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/cloudsql.client"

3. L'app di esempio utilizza la registrazione, quindi esegui il comando gcloud projects add-iam-policy-binding come segue per aggiungere il ruolo Scrittore di log all'account di servizio Google Cloud appena creato. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
     --member="serviceAccount:gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter"

4. L'account di servizio deve essere in grado di estrarre le immagini dal repository Artifactory, quindi esegui il comando
   gcloud projects add-iam-policy-binding come segue per aggiungere il ruolo Lettore Artifact Registry all'account di servizio. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
     --member="serviceAccount:gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/artifactregistry.reader"

Crea un account di servizio Kubernetes configurato per avere accesso a Cloud SQL associandolo all'account di servizio Google Cloud tramite Federazione delle identità per carichi di lavoro per GKE.

1. Crea un account di servizio Kubernetes.
   1. Aggiorna il service-account.yaml nell'editor di Cloud Shell. Sostituisci <YOUR-KSA-NAME> con ksa-cloud-sql.
   2. Esegui il comando kubectl apply come segue in Cloud Shell:

      kubectl apply -f service-account.yaml

2. Esegui gcloud iam service-accounts add-iam-policy-binding. come segue per abilitare l'associazione IAM dell'account di servizio Google Cloud e l'account di servizio Kubernetes. Effettua le seguenti sostituzioni:
   • YOUR_PROJECT_ID con l'ID progetto.
   • YOUR_K8S_NAMESPACE con default, che è lo spazio dei nomi predefinito per i cluster creati in GKE.
   • YOUR_KSA_NAME con ksa-cloud-sql.

   gcloud iam service-accounts add-iam-policy-binding \
     --role="roles/iam.workloadIdentityUser" \
     --member="serviceAccount:YOUR_PROJECT_ID.svc.id.goog[YOUR_K8S_NAMESPACE/YOUR_KSA_NAME]" \
     gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com

3. Esegui il comando kubectl annotate come segue per annotare l'account di servizio Kubernetes con l'associazione IAM. Effettua le seguenti sostituzioni:
   • YOUR_KSA_NAME con ksa-cloud-sql.
   • YOUR_PROJECT_ID con l'ID progetto.

   kubectl annotate serviceaccount \
     YOUR_KSA_NAME  \
     iam.gke.io/gcp-service-account=gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com

Configura i secret

Esegui il comando kubectl create secret generic come segue per creare i secret di Kubernetes per il database, l'utente e la password utente da utilizzare dall'app di esempio. I valori di ogni secret si basano sui valori specificati nei passaggi precedenti di questa guida introduttiva. Sostituisci DB_PASS con la password del quickstart-user che hai creato nel passaggio precedente della guida rapida Creare un utente.

kubectl create secret generic gke-cloud-sql-secrets \
  --from-literal=database=quickstart-db \
  --from-literal=username=quickstart-user \
  --from-literal=password=DB_PASS

Crea l'app di esempio

Vai

1. Esegui il seguente gcloud artifacts repositories create in Cloud Shell per creare un repository in Artifact Registry denominato gke-cloud-sql-repo nella stessa regione del tuo cluster. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud artifacts repositories create gke-cloud-sql-repo \
     --project=YOUR_PROJECT_ID \
     --repository-format=docker \
     --location=us-central1 \
     --description="GKE Quickstart sample app"

2. Esegui il comando gcloud builds submit come indicato di seguito in Cloud Shell per creare un container Docker e pubblicarlo in Artifact Registry. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud builds submit \
     --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .

Java

1. Esegui il seguente gcloud artifacts repositories create in Cloud Shell per creare un repository in Artifact Registry denominato gke-cloud-sql-repo nella stessa regione del tuo cluster. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud artifacts repositories create gke-cloud-sql-repo \
     --project=YOUR_PROJECT_ID \
     --repository-format=docker \
     --location=us-central1 \
     --description="GKE Quickstart sample app"

2. Esegui il comando mvn come segue in Cloud Shell per creare un container Docker e pubblicarlo in Artifact Registry. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   mvn clean package com.google.cloud.tools:jib-maven-plugin:2.8.0:build \
     -Dimage=us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql \
     -DskipTests -Djib.to.credHelper=gcloud

Node.js

1. Esegui il seguente comando gcloud artifacts repositories create in Cloud Shell per creare un repository in Artifact Registry denominato gke-cloud-sql-repo nella stessa regione del tuo cluster. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud artifacts repositories create gke-cloud-sql-repo \
     --project=YOUR_PROJECT_ID \
     --repository-format=docker \
     --location=us-central1 \
     --description="GKE Quickstart sample app"

2. Esegui il comando gcloud builds submit come segue in Cloud Shell per creare un container Docker e pubblicarlo in Artifact Registry. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud builds submit \
     --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .

Python

1. Esegui il seguente comando gcloud artifacts repositories create in Cloud Shell per creare un repository in Artifact Registry denominato gke-cloud-sql-repo nella stessa regione del tuo cluster. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud artifacts repositories create gke-cloud-sql-repo \
     --project=YOUR_PROJECT_ID \
     --repository-format=docker \
     --location=us-central1 \
     --description="GKE Quickstart sample app"

2. Esegui il comando gcloud builds submit come indicato di seguito in Cloud Shell per creare un container Docker e pubblicarlo in Artifact Registry. Sostituisci YOUR_PROJECT_ID con l'ID progetto.

   gcloud builds submit \
     --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .

Esegui il deployment dell'app di esempio

IP pubblico

Una volta configurata l'app di esempio, puoi eseguirne il deployment.

Vai

L'app di esempio di cui è stato eseguito il deployment si connette alla tua istanza Cloud SQL utilizzando il proxy Cloud SQL in esecuzione in una Pattern collaterale di Kubernetes. Il pattern collaterale si ottiene eseguendo il deployment un carico di lavoro con un container aggiuntivo che condivide lo stesso pod Kubernetes del container dell'app di esempio.

1. Esegui il recupero del nome della connessione dell'istanza Cloud SQL Il comando gcloud sql instances describe:

   gcloud sql instances describe quickstart-instance --format='value(connectionName)'

2. Aggiorna il file deployment.yaml nell'editor di Cloud Shell. Apporta le seguenti sostituzioni:
   • <YOUR_KSA_NAME> con ksa-cloud-sql.
   • <LOCATION> con us-central1.
   • <YOUR_PROJECT_ID> con l'ID progetto.
   • <YOUR-DB-SECRET> con gke-cloud-sql-secrets.
   • <INSTANCE_CONNECTION_NAME> con Cloud SQL nome della connessione all'istanza recuperato da gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Il nome della connessione istanza è visibile anche nella pagina Panoramica dell'istanza Cloud SQL.
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gke-cloud-sql-quickstart
   spec:
     selector:
       matchLabels:
         app: gke-cloud-sql-app
     template:
       metadata:
         labels:
           app: gke-cloud-sql-app
       spec:
         serviceAccountName: <YOUR-KSA-NAME>
         containers:
         - name: gke-cloud-sql-app
           # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
           # Replace <YOUR_PROJECT_ID> with your project ID.
           image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
           # 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_CONNECTION_NAME (proj:region:instance)
           # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
           # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
           - name: INSTANCE_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "5432"
           # For Automatic IAM Authentication with the Go Connector
           # use DB_IAM_USER instead of DB_USER (recommended)
           # You may also remove the DB_PASS environment variable if
           # you use Automatic IAM Authentication
           - 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
         # If you are using the Go Connector (recommended), you can
         # remove cloud-sql-proxy (everything below this line)
         - name: cloud-sql-proxy
           # This uses the latest version of the Cloud SQL Proxy
           # It is recommended to use a specific version for production environments.
           # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy
           image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
           args:
             # If connecting from a VPC-native GKE cluster, you can use the
             # following flag to have the proxy connect over private IP
             # - "--private-ip"
   
             # If you are not connecting with Automatic IAM, you can delete
             # the following flag.
             - "--auto-iam-authn"
   
             # tcp should be set to the port the proxy should listen on
             # and should match the DB_PORT value set above.
             # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
             - "--port=5432"
             - "<INSTANCE_CONNECTION_NAME>"
           securityContext:
             # The default Cloud SQL proxy image runs as the
             # "nonroot" user and group (uid: 65532) by default.
             runAsNonRoot: true
   

3. Esegui kubectl apply. come segue in Cloud Shell per eseguire il deployment dell'app di esempio:

   kubectl apply -f deployment.yaml

4. Esegui il comando kubectl apply come segue per aggiungere un bilanciatore del carico davanti al deployment in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui kubectl get. come segue per ottenere i dettagli del servizio:

   kubectl get services

6. Copia l'indirizzo IP esterno quando diventa disponibile nei dettagli del servizio. L'operazione potrebbe richiedere alcuni minuti.
7. Visualizza l'app di esempio di cui è stato eseguito il deployment. Apri una finestra del browser e vai all'indirizzo IP esterno del servizio.

   

Java

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando il connettore Java Cloud SQL.

1. Recupera il nome della connessione dell'istanza Cloud SQL eseguendo il comando gcloud sql instances describe:

   gcloud sql instances describe quickstart-instance --format='value(connectionName)'

2. Aggiorna il file deployment.yaml nell'editor di Cloud Shell. Effettua le seguenti sostituzioni:
   • <YOUR_KSA_NAME> con ksa-cloud-sql.
   • <LOCATION> con us-central1.
   • <YOUR_PROJECT_ID> con l'ID progetto.
   • <YOUR-DB-SECRET> con gke-cloud-sql-secrets.
   • <INSTANCE_CONNECTION_NAME> con il nome di connessione istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Il nome della connessione istanza è visibile anche nella pagina Panoramica dell'istanza Cloud SQL.
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gke-cloud-sql-quickstart
   spec:
     selector:
       matchLabels:
         app: gke-cloud-sql-app
     template:
       metadata:
         labels:
           app: gke-cloud-sql-app
       spec:
         # For more information about using Kubernetes service accounts see: 
         # https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts
         serviceAccountName: <YOUR-KSA-NAME> # TODO(developer): replace this value.
         containers:
         - name: gke-cloud-sql-app
           # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
           # Replace <YOUR_PROJECT_ID> with your project ID.
           image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
           # This app listens on port 8080 for web traffic by default.
           ports:
           - containerPort: 8080
           env:
           - name: PORT
             value: "8080"
           - name: INSTANCE_CONNECTION_NAME
             value: <INSTANCE_CONNECTION_NAME>
           - name: DB_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "5432"  
           - name: DB_USER
             valueFrom:
               secretKeyRef:
                 name: <YOUR-DB-SECRET>
                 key: username
           - name: DB_PASS
             valueFrom:
               secretKeyRef:
                 name: <YOUR-DB-SECRET>
                 key: password
           - name: DB_NAME
             valueFrom:
               secretKeyRef:
                 name: <YOUR-DB-SECRET>
                 key: database
   

3. Esegui kubectl apply. come segue in Cloud Shell per eseguire il deployment dell'app di esempio:

   kubectl apply -f deployment.yaml

4. Esegui kubectl apply. come segue per aggiungere un bilanciatore del carico davanti al deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui kubectl get. come segue per ottenere i dettagli del servizio:

   kubectl get services

6. Copia l'indirizzo IP esterno non appena diventa disponibile nei dettagli del servizio. L'operazione potrebbe richiedere alcuni minuti.
7. Visualizza l'app di esempio di cui è stato eseguito il deployment. Apri una finestra del browser e vai all'indirizzo IP esterno del servizio.

   

Node.js

L'app di esempio di cui è stato eseguito il deployment si connette alla tua istanza Cloud SQL utilizzando il proxy Cloud SQL in esecuzione in una Pattern collaterale di Kubernetes. Il pattern collaterale si ottiene eseguendo il deployment un carico di lavoro con un container aggiuntivo che condivide lo stesso pod Kubernetes del container dell'app di esempio.

1. Esegui il recupero del nome della connessione dell'istanza Cloud SQL Il comando gcloud sql instances describe:

   gcloud sql instances describe quickstart-instance --format='value(connectionName)'

2. Aggiorna il file deployment.yaml nell'editor di Cloud Shell. Apporta le seguenti sostituzioni:
   • <YOUR_KSA_NAME> con ksa-cloud-sql.
   • <LOCATION> con us-central1.
   • <YOUR_PROJECT_ID> con l'ID progetto.
   • <YOUR-DB-SECRET> con gke-cloud-sql-secrets.
   • <INSTANCE_CONNECTION_NAME> con Cloud SQL nome della connessione all'istanza recuperato da gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Anche il nome di connessione istanza è visibile nella pagina Panoramica dell'istanza Cloud SQL.
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gke-cloud-sql-quickstart
   spec:
     selector:
       matchLabels:
         app: gke-cloud-sql-app
     template:
       metadata:
         labels:
           app: gke-cloud-sql-app
       spec:
         serviceAccountName: <YOUR-KSA-NAME>
         containers:
         - name: gke-cloud-sql-app
           # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
           # Replace <YOUR_PROJECT_ID> with your project ID.
           image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
           # 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 Node.js connector (recommended) - use INSTANCE_CONNECTION_NAME (proj:region:instance)
           # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
           # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
           - name: INSTANCE_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "5432"
           # For Automatic IAM Authentication with the Node.js Connector
           # use DB_IAM_USER instead of DB_USER (recommended)
           # You may also remove the DB_PASS environment variable if
           # you use Automatic IAM Authentication
           - 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
         # If you are using the Node.js Connector (recommended), you can
         # remove cloud-sql-proxy (everything below this line)
         - name: cloud-sql-proxy
           # This uses the latest version of the Cloud SQL proxy
           # It is recommended to use a specific version for production environments.
           # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy 
           image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
           args:
             # If connecting from a VPC-native GKE cluster, you can use the
             # following flag to have the proxy connect over private IP
             # - "--private-ip"
   
             # If you are not connecting with Automatic IAM, you can delete
             # the following flag.
             - "--auto-iam-authn"
   
             # tcp should be set to the port the proxy should listen on
             # and should match the DB_PORT value set above.
             # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
             - "--port=5432"
             - "<INSTANCE_CONNECTION_NAME>"
           securityContext:
             # The default Cloud SQL proxy image runs as the
             # "nonroot" user and group (uid: 65532) by default.
             runAsNonRoot: true
   

3. Esegui kubectl apply. come segue in Cloud Shell per eseguire il deployment dell'app di esempio:

   kubectl apply -f deployment.yaml

4. Esegui il comando kubectl apply come segue per aggiungere un bilanciatore del carico davanti al deployment in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui kubectl get. come segue per ottenere i dettagli del servizio:

   kubectl get services

6. Copia l'indirizzo IP esterno quando diventa disponibile nei dettagli del servizio. L'operazione potrebbe richiedere alcuni minuti.
7. Visualizza l'app di esempio di cui è stato eseguito il deployment. Apri una finestra del browser e vai all'indirizzo IP esterno del servizio.

   

Python

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando il proxy Cloud SQL in esecuzione in un pattern sidecar Kubernetes. Il pattern sidecar viene eseguito eseguendo il deployment di un carico di lavoro con un container aggiuntivo che condivide lo stesso pod Kubernetes del container dell'app di esempio.

1. Esegui il recupero del nome della connessione dell'istanza Cloud SQL Il comando gcloud sql instances describe:

   gcloud sql instances describe quickstart-instance --format='value(connectionName)'

2. Aggiorna il file deployment.yaml nell'editor di Cloud Shell. Apporta le seguenti sostituzioni:
   • <YOUR_KSA_NAME> con ksa-cloud-sql.
   • <LOCATION> con us-central1.
   • <YOUR_PROJECT_ID> con l'ID progetto.
   • <YOUR-DB-SECRET> con gke-cloud-sql-secrets.
   • <INSTANCE_CONNECTION_NAME> con il nome di connessione istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Anche il nome di connessione istanza è visibile nella pagina Panoramica dell'istanza Cloud SQL.
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gke-cloud-sql-quickstart
   spec:
     selector:
       matchLabels:
         app: gke-cloud-sql-app
     template:
       metadata:
         labels:
           app: gke-cloud-sql-app
       spec:
         serviceAccountName: <YOUR-KSA-NAME>
         containers:
         - name: gke-cloud-sql-app
           # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
           # Replace <YOUR_PROJECT_ID> with your project ID.
           image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
           # 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 Python Connector (recommended) - use INSTANCE_CONNECTION_NAME (proj:region:instance)
           # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
           # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
           - name: INSTANCE_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "5432"
           # For Automatic IAM Authentication with the Python Connector
           # use DB_IAM_USER instead of DB_USER (recommended)
           # You may also remove the DB_PASS environment variable if
           # you use Automatic IAM Authentication
           - 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
         # If you are using the Python Connector (recommended), you can
         # remove cloud-sql-proxy (everything below this line)
         - name: cloud-sql-proxy
           # This uses the latest version of the Cloud SQL proxy
           # It is recommended to use a specific version for production environments.
           # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy 
           image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
           args:
             # If connecting from a VPC-native GKE cluster, you can use the
             # following flag to have the proxy connect over private IP
             # - "--private-ip"
   
             # If you are not connecting with Automatic IAM, you can delete
             # the following flag.
             - "--auto-iam-authn"
   
             # tcp should be set to the port the proxy should listen on
             # and should match the DB_PORT value set above.
             # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
             - "--port=5432"
             - "<INSTANCE_CONNECTION_NAME>"
           securityContext:
             # The default Cloud SQL proxy image runs as the
             # "nonroot" user and group (uid: 65532) by default.
             runAsNonRoot: true
   

3. Esegui kubectl apply. come segue in Cloud Shell per eseguire il deployment dell'app di esempio:

   kubectl apply -f deployment.yaml

4. Esegui il comando kubectl apply come segue per aggiungere un bilanciatore del carico davanti al deployment in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui kubectl get. come segue per ottenere i dettagli del servizio:

   kubectl get services

6. Copia l'indirizzo IP esterno quando diventa disponibile nei dettagli del servizio. L'operazione potrebbe richiedere alcuni minuti.
7. Visualizza l'app di esempio di cui è stato eseguito il deployment. Apri una finestra del browser e vai all'indirizzo IP esterno del servizio.

   

IP privato

Una volta configurata l'app di esempio, puoi eseguirne il deployment.

Vai

L'app di esempio di cui è stato eseguito il deployment si connette alla tua istanza Cloud SQL utilizzando il proxy Cloud SQL in esecuzione in una Pattern collaterale di Kubernetes. Il pattern collaterale si ottiene eseguendo il deployment un carico di lavoro con un container aggiuntivo che condivide lo stesso pod Kubernetes del container dell'app di esempio.

1. Esegui il recupero del nome della connessione dell'istanza Cloud SQL Il comando gcloud sql instances describe:

   gcloud sql instances describe quickstart-instance --format='value(connectionName)'

2. Aggiorna il file deployment.yaml nell'editor di Cloud Shell. Apporta le seguenti sostituzioni e modifiche:
   • Sostituisci <YOUR_KSA_NAME> con ksa-cloud-sql.
   • Sostituisci <LOCATION> con us-central1.
   • Sostituisci <YOUR_PROJECT_ID> con l'ID progetto.
   • Sostituisci <YOUR-DB-SECRET> con gke-cloud-sql-secrets.
   • Sostituisci <INSTANCE_CONNECTION_NAME> con il nome della connessione dell'istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Anche il nome di connessione istanza è visibile nella pagina Panoramica dell'istanza Cloud SQL.
   • Abilita il proxy di autenticazione Cloud SQL per connetterti a Cloud SQL utilizzando il proprio indirizzo IP privato. Rimuovi il commento dal flag "-ip_address_types=PRIVATE" rimuovendo il simbolo di commento # e lo spazio vuoto finale. Il flag senza commenti dovrebbe avere il seguente aspetto:

     - "-ip_address_types=PRIVATE"

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gke-cloud-sql-quickstart
   spec:
     selector:
       matchLabels:
         app: gke-cloud-sql-app
     template:
       metadata:
         labels:
           app: gke-cloud-sql-app
       spec:
         serviceAccountName: <YOUR-KSA-NAME>
         containers:
         - name: gke-cloud-sql-app
           # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
           # Replace <YOUR_PROJECT_ID> with your project ID.
           image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
           # 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_CONNECTION_NAME (proj:region:instance)
           # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
           # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
           - name: INSTANCE_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "5432"
           # For Automatic IAM Authentication with the Go Connector
           # use DB_IAM_USER instead of DB_USER (recommended)
           # You may also remove the DB_PASS environment variable if
           # you use Automatic IAM Authentication
           - 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
         # If you are using the Go Connector (recommended), you can
         # remove cloud-sql-proxy (everything below this line)
         - name: cloud-sql-proxy
           # This uses the latest version of the Cloud SQL Proxy
           # It is recommended to use a specific version for production environments.
           # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy
           image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
           args:
             # If connecting from a VPC-native GKE cluster, you can use the
             # following flag to have the proxy connect over private IP
             # - "--private-ip"
   
             # If you are not connecting with Automatic IAM, you can delete
             # the following flag.
             - "--auto-iam-authn"
   
             # tcp should be set to the port the proxy should listen on
             # and should match the DB_PORT value set above.
             # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
             - "--port=5432"
             - "<INSTANCE_CONNECTION_NAME>"
           securityContext:
             # The default Cloud SQL proxy image runs as the
             # "nonroot" user and group (uid: 65532) by default.
             runAsNonRoot: true
   

3. Esegui il comando kubectl apply come segue in Cloud Shell per eseguire il deployment dell'app di esempio:

   kubectl apply -f deployment.yaml

4. Esegui il comando kubectl apply come segue per aggiungere un bilanciatore del carico davanti al deployment in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando kubectl get come segue per recuperare i dettagli del servizio:

   kubectl get services

6. Copia l'indirizzo IP esterno non appena diventa disponibile nei dettagli del servizio. L'operazione potrebbe richiedere alcuni minuti.
7. Visualizza l'app di esempio di cui è stato eseguito il deployment. Apri una finestra del browser e vai all'indirizzo IP esterno del servizio.

   

Java

L'app di esempio di cui è stato eseguito il deployment si connette alla tua istanza Cloud SQL utilizzando Connettore Java Cloud SQL.

1. Recupera il nome della connessione dell'istanza Cloud SQL eseguendo il comando gcloud sql instances describe:

   gcloud sql instances describe quickstart-instance --format='value(connectionName)'

2. Aggiorna il file deployment.yaml nell'editor di Cloud Shell. Apporta le seguenti sostituzioni:
   • <YOUR_KSA_NAME> con ksa-cloud-sql.
   • <LOCATION> con us-central1.
   • <YOUR_PROJECT_ID> con l'ID progetto.
   • <YOUR-DB-SECRET> con gke-cloud-sql-secrets.
   • <INSTANCE_CONNECTION_NAME> con Cloud SQL nome della connessione all'istanza recuperato da gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Anche il nome di connessione istanza è visibile nella pagina Panoramica dell'istanza Cloud SQL.
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gke-cloud-sql-quickstart
   spec:
     selector:
       matchLabels:
         app: gke-cloud-sql-app
     template:
       metadata:
         labels:
           app: gke-cloud-sql-app
       spec:
         # For more information about using Kubernetes service accounts see: 
         # https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts
         serviceAccountName: <YOUR-KSA-NAME> # TODO(developer): replace this value.
         containers:
         - name: gke-cloud-sql-app
           # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
           # Replace <YOUR_PROJECT_ID> with your project ID.
           image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
           # This app listens on port 8080 for web traffic by default.
           ports:
           - containerPort: 8080
           env:
           - name: PORT
             value: "8080"
           - name: INSTANCE_CONNECTION_NAME
             value: <INSTANCE_CONNECTION_NAME>
           - name: DB_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "5432"  
           - name: DB_USER
             valueFrom:
               secretKeyRef:
                 name: <YOUR-DB-SECRET>
                 key: username
           - name: DB_PASS
             valueFrom:
               secretKeyRef:
                 name: <YOUR-DB-SECRET>
                 key: password
           - name: DB_NAME
             valueFrom:
               secretKeyRef:
                 name: <YOUR-DB-SECRET>
                 key: database
   

3. Esegui il comando kubectl apply come segue in Cloud Shell per eseguire il deployment dell'app di esempio:

   kubectl apply -f deployment.yaml

4. Esegui il comando kubectl apply come segue per aggiungere un bilanciatore del carico davanti al deployment in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui kubectl get. come segue per ottenere i dettagli del servizio:

   kubectl get services

6. Copia l'indirizzo IP esterno quando diventa disponibile nei dettagli del servizio. L'operazione potrebbe richiedere alcuni minuti.
7. Visualizza l'app di esempio di cui è stato eseguito il deployment. Apri una finestra del browser e vai all'indirizzo IP esterno del servizio.

   

Node.js

L'app di esempio di cui è stato eseguito il deployment si connette alla tua istanza Cloud SQL utilizzando il proxy Cloud SQL in esecuzione in una Pattern collaterale di Kubernetes. Il pattern sidecar viene eseguito eseguendo il deployment di un carico di lavoro con un container aggiuntivo che condivide lo stesso pod Kubernetes del container dell'app di esempio.

1. Recupera il nome della connessione dell'istanza Cloud SQL eseguendo il comando gcloud sql instances describe:

   gcloud sql instances describe quickstart-instance --format='value(connectionName)'

2. Aggiorna il file deployment.yaml nell'editor di Cloud Shell. Apporta le seguenti sostituzioni e modifiche:
   • Sostituisci <YOUR_KSA_NAME> con ksa-cloud-sql.
   • Sostituisci <LOCATION> con us-central1.
   • Sostituisci <YOUR_PROJECT_ID> con l'ID progetto.
   • Sostituisci <YOUR-DB-SECRET> con gke-cloud-sql-secrets.
   • Sostituisci <INSTANCE_CONNECTION_NAME> con il nome della connessione dell'istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Anche il nome di connessione istanza è visibile nella pagina Panoramica dell'istanza Cloud SQL.
   • Consenti al proxy di autenticazione Cloud SQL di connettersi all'istanza Cloud SQL utilizzando il relativo indirizzo IP privato. Rimuovi il commento dal flag "-ip_address_types=PRIVATE" rimuovendo il simbolo di commento # e lo spazio vuoto finale. Il flag senza commenti dovrebbe avere il seguente aspetto:

     - "-ip_address_types=PRIVATE"

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gke-cloud-sql-quickstart
   spec:
     selector:
       matchLabels:
         app: gke-cloud-sql-app
     template:
       metadata:
         labels:
           app: gke-cloud-sql-app
       spec:
         serviceAccountName: <YOUR-KSA-NAME>
         containers:
         - name: gke-cloud-sql-app
           # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
           # Replace <YOUR_PROJECT_ID> with your project ID.
           image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
           # 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 Node.js connector (recommended) - use INSTANCE_CONNECTION_NAME (proj:region:instance)
           # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
           # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
           - name: INSTANCE_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "5432"
           # For Automatic IAM Authentication with the Node.js Connector
           # use DB_IAM_USER instead of DB_USER (recommended)
           # You may also remove the DB_PASS environment variable if
           # you use Automatic IAM Authentication
           - 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
         # If you are using the Node.js Connector (recommended), you can
         # remove cloud-sql-proxy (everything below this line)
         - name: cloud-sql-proxy
           # This uses the latest version of the Cloud SQL proxy
           # It is recommended to use a specific version for production environments.
           # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy 
           image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
           args:
             # If connecting from a VPC-native GKE cluster, you can use the
             # following flag to have the proxy connect over private IP
             # - "--private-ip"
   
             # If you are not connecting with Automatic IAM, you can delete
             # the following flag.
             - "--auto-iam-authn"
   
             # tcp should be set to the port the proxy should listen on
             # and should match the DB_PORT value set above.
             # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
             - "--port=5432"
             - "<INSTANCE_CONNECTION_NAME>"
           securityContext:
             # The default Cloud SQL proxy image runs as the
             # "nonroot" user and group (uid: 65532) by default.
             runAsNonRoot: true
   

3. Esegui il comando kubectl apply come segue in Cloud Shell per eseguire il deployment dell'app di esempio:

   kubectl apply -f deployment.yaml

4. Esegui il comando kubectl apply come segue per aggiungere un bilanciatore del carico davanti al deployment in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando kubectl get come segue per recuperare i dettagli del servizio:

   kubectl get services

6. Copia l'indirizzo IP esterno non appena diventa disponibile nei dettagli del servizio. L'operazione potrebbe richiedere alcuni minuti.
7. Visualizza l'app di esempio di cui è stato eseguito il deployment. Apri una finestra del browser e vai all'indirizzo IP esterno del servizio.

   

Python

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando il proxy Cloud SQL in esecuzione in un pattern sidecar Kubernetes. Il pattern sidecar viene eseguito eseguendo il deployment di un carico di lavoro con un container aggiuntivo che condivide lo stesso pod Kubernetes del container dell'app di esempio.

1. Recupera il nome della connessione dell'istanza Cloud SQL eseguendo il comando gcloud sql instances describe:

   gcloud sql instances describe quickstart-instance --format='value(connectionName)'

2. Aggiorna il file deployment.yaml nell'editor di Cloud Shell. Apporta le seguenti sostituzioni e modifiche:
   • Sostituisci <YOUR_KSA_NAME> con ksa-cloud-sql.
   • Sostituisci <LOCATION> con us-central1.
   • Sostituisci <YOUR_PROJECT_ID> con l'ID progetto.
   • Sostituisci <YOUR-DB-SECRET> con gke-cloud-sql-secrets.
   • Sostituisci <INSTANCE_CONNECTION_NAME> con il nome della connessione dell'istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Anche il nome di connessione istanza è visibile nella pagina Panoramica dell'istanza Cloud SQL.
   • Abilita il proxy di autenticazione Cloud SQL per connetterti a Cloud SQL utilizzando il proprio indirizzo IP privato. Rimuovi il commento dal flag "-ip_address_types=PRIVATE" rimuovendo il simbolo di commento # e lo spazio vuoto finale. Il flag non commentato dovrebbe avere il seguente aspetto:

     - "-ip_address_types=PRIVATE"

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gke-cloud-sql-quickstart
   spec:
     selector:
       matchLabels:
         app: gke-cloud-sql-app
     template:
       metadata:
         labels:
           app: gke-cloud-sql-app
       spec:
         serviceAccountName: <YOUR-KSA-NAME>
         containers:
         - name: gke-cloud-sql-app
           # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
           # Replace <YOUR_PROJECT_ID> with your project ID.
           image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
           # 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 Python Connector (recommended) - use INSTANCE_CONNECTION_NAME (proj:region:instance)
           # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
           # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
           - name: INSTANCE_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "5432"
           # For Automatic IAM Authentication with the Python Connector
           # use DB_IAM_USER instead of DB_USER (recommended)
           # You may also remove the DB_PASS environment variable if
           # you use Automatic IAM Authentication
           - 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
         # If you are using the Python Connector (recommended), you can
         # remove cloud-sql-proxy (everything below this line)
         - name: cloud-sql-proxy
           # This uses the latest version of the Cloud SQL proxy
           # It is recommended to use a specific version for production environments.
           # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy 
           image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
           args:
             # If connecting from a VPC-native GKE cluster, you can use the
             # following flag to have the proxy connect over private IP
             # - "--private-ip"
   
             # If you are not connecting with Automatic IAM, you can delete
             # the following flag.
             - "--auto-iam-authn"
   
             # tcp should be set to the port the proxy should listen on
             # and should match the DB_PORT value set above.
             # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
             - "--port=5432"
             - "<INSTANCE_CONNECTION_NAME>"
           securityContext:
             # The default Cloud SQL proxy image runs as the
             # "nonroot" user and group (uid: 65532) by default.
             runAsNonRoot: true
   

3. Esegui kubectl apply. come segue in Cloud Shell per eseguire il deployment dell'app di esempio:

   kubectl apply -f deployment.yaml

4. Esegui kubectl apply. come segue per aggiungere un bilanciatore del carico davanti al deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui kubectl get. come segue per ottenere i dettagli del servizio:

   kubectl get services

6. Copia l'indirizzo IP esterno quando diventa disponibile nei dettagli del servizio. L'operazione potrebbe richiedere alcuni minuti.
7. Visualizza l'app di esempio di cui è stato eseguito il deployment. Apri una finestra del browser e vai all'indirizzo IP esterno del servizio.

   

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

1. Nella console Google Cloud, vai alla pagina Istanze Cloud SQL.

   Vai a Istanze Cloud SQL

2. Seleziona l'istanza quickstart-instance per aprire Dettagli istanza .
3. Nella barra delle icone nella parte superiore della pagina, fai clic su Elimina.
4. Nella finestra di dialogo Elimina istanza, digita quickstart-instance, quindi fai clic su Elimina per eliminare l'istanza.

5. Nella console Google Cloud, vai alla pagina Google Kubernetes Engine.

   Vai a Google Kubernetes Engine

6. Fai clic sulla casella di controllo accanto al nome del servizio gke-cloud-sql-quickstart.
7. Fai clic sul pulsante Elimina nella parte superiore della pagina di Google Kubernetes Engine.

Passaggi facoltativi per la pulizia

Se non utilizzi l'account di servizio Google Cloud che hai creato rapida, puoi rimuoverlo.

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

   Vai a IAM

2. Seleziona la casella di controllo per l'account IAM denominato gke-quickstart-service-account.
3. Fai clic su Rimuovi e conferma la rimozione.

Se non utilizzi le API abilitate in questa guida rapida, puoi disattivarle.

• API che sono state abilitate in questa guida rapida:
  • API Compute Engine
  • API Cloud SQL Admin
  • API Google Kubernetes Engine
  • API Artifact Registry
  • API Cloud Build

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

   Vai alle API

2. Seleziona l'API che vuoi disattivare e fai clic sul pulsante Disattiva API.

Passaggi successivi

In base alle tue esigenze, puoi scoprire di più sulla creazione di istanze Cloud SQL.

Puoi anche scoprire come creare utenti e database PostgreSQL per la tua istanza Cloud SQL.

Consulta anche le informazioni sui prezzi di Cloud SQL.

Scopri di più su:

• Tutte le opzioni di connettività in Cloud SQL.
• Configurare l'istanza Cloud SQL con un indirizzo IP pubblico.
• Configura l'istanza Cloud SQL con un indirizzo IP privato.

Inoltre, puoi scoprire come connetterti a un'istanza Cloud SQL da altre applicazioni Google Cloud:

• Da un'applicazione in esecuzione nell'ambiente standard di App Engine
• Da un'applicazione in esecuzione su Compute Engine
• Da un'applicazione in esecuzione su GKE
• Dalle funzioni Cloud Run
• Da Cloud Run