Connettiti a Cloud SQL per MySQL da Google Kubernetes Engine

Connettiti a Cloud SQL per MySQL 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) connessa a un'istanza MySQL tramite la console Google Cloud e un'applicazione client. Le risorse create in questa guida rapida costano in genere meno di un dollaro (USD), supponendo che tu completi i passaggi, inclusa la pulizia, in modo tempestivo.

Prima di iniziare

Nota: il nome che utilizzi per il tuo progetto deve essere compreso tra 4 e 30 caratteri. Quando digiti 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. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

   Abilita le API

   Questa operazione 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 pulsante seguente per aprire Cloud Shell, che fornisce l'accesso tramite riga di comando alle risorse Google Cloud direttamente dal browser. Puoi usare Cloud Shell 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 necessarie per questa guida rapida:

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

   Questo comando abilita le API seguenti:

   • 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

Crea 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 MySQL.
4. Inserisci quickstart-instance in ID istanza.
5. Inserisci una password per l'utente root. Salva questa password per uso futuro.
6. Fai clic sull'opzione Zona singola per Scegli la disponibilità a livello di 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 che l'istanza venga inizializzata e avviata.

gcloud

Crea un'istanza con un indirizzo IP pubblico

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

Se vuoi, puoi modificare i valori dei seguenti parametri:

• --database_version: il tipo e la versione del motore del database. Se non specificati, viene utilizzato il valore predefinito dell'API. Consulta la documentazione relativa alle versioni dei database gcloud per vedere le versioni attualmente disponibili.
• --cpu: il numero di core desiderati nella macchina.
• --memory: un numero intero che indica la quantità di memoria desiderata nella macchina. È necessario specificare un'unità di dimensione (ad esempio, 3072 MB o 9 GB). Se non vengono specificate unità, si presume il valore GB.
• --region: località regionale dell'istanza (ad esempio asia-east1, us-east1). Se non specificato, viene utilizzato il valore predefinito us-central. Consulta l'elenco completo delle regioni.

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

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

IP privato

Console

Crea 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 MySQL.
4. Inserisci quickstart-instance in ID istanza.
5. Inserisci una password per l'utente root. Salva questa password per uso futuro.
6. Fai clic sull'opzione Zona singola per Scegli la disponibilità a livello di regione e zona.
7. Fai clic ed espandi Mostra opzioni di configurazione.
8. In 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 che indica È richiesta una connessione di accesso privato ai servizi, fai clic sul pulsante Configura connessione.
• Nella finestra di dialogo Abilita API Service Networking, fai clic sul pulsante Abilita API.
• Nella finestra di dialogo Assegna un intervallo IP, seleziona Utilizza un intervallo IP allocato automaticamente 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 Abilita SSL, fai clic su Abilita e riavvia, quindi attendi il riavvio dell'istanza.

gcloud

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

La creazione di un'istanza con un indirizzo IP privato richiede solo la configurazione dell'accesso privato ai servizi per abilitare 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 tuo database.

Se vuoi, puoi modificare i valori dei seguenti parametri:

• --database_version: il tipo e la versione del motore del database. Se non specificati, viene utilizzato il valore predefinito dell'API. Vedi le versioni dei database gcloud per un elenco delle versioni attualmente disponibili.
• --cpu: il numero di core nella macchina.
• --memory: un numero intero che indica la quantità di memoria da includere nella macchina. È possibile fornire un'unità di dimensione (ad esempio, 3072 MB o 9 GB). Se non vengono specificate unità, si presume il valore GB.
• --region: la località 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=MYSQL_8_0 \
--cpu=1 \
--memory=4GB \
--region=us-central1 \
--root-password=DB_ROOT_PASSWORD \
--no-assign-ip \
--network=default

4. Esegui il comando 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 Crea un database, inserisci quickstart-db. Lascia i valori per il set di caratteri e le regole di confronto.
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 Utenti dal menu di navigazione SQL.
4. Fai clic su Aggiungi account utente.
• 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. Annotalo per utilizzarlo in un passaggio successivo di questa guida rapida.
  • Nella sezione Nome host, l'impostazione predefinita è Consenti qualsiasi host, il che significa che l'utente può connettersi da qualsiasi indirizzo IP.

    (Facoltativo) Seleziona Limita l'host in base all'indirizzo IP o all'intervallo di indirizzi e inserisci un indirizzo o un intervallo di indirizzi IP nella sezione Host. L'utente può quindi connettersi solo dall'indirizzo IP o dagli indirizzi specificati.

5. 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 un 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 dei nomi utente sono gli stessi per Cloud SQL e per MySQL on-premise; 32 caratteri per MySQL 8.0, 16 caratteri per le versioni precedenti.

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 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 Cloud SQL di esempio 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 la connessione 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.

Go

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.

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 scaricare il codice dell'app di esempio e aprire 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 scaricare il codice dell'app di esempio e aprire la directory dell'app di esempio nell'editor di Cloud Shell.

Abilita il cluster GKE

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

Esegui il comando 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

Crea e configura un account di servizio Google Cloud che deve essere utilizzato da GKE in modo che abbia il ruolo Client Cloud SQL con le 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 il comando gcloud projects add-iam-policy-binding come segue per aggiungere il ruolo Client Cloud SQL 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/cloudsql.client"

3. L'app di esempio utilizza il logging, perciò esegui il comando gcloud projects add-iam-policy-binding come segue per aggiungere il ruolo Writer 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"

Crea un account di servizio Kubernetes configurato per avere accesso a Cloud SQL associandolo all'account di servizio Google Cloud tramite Workload Identity.

1. Creare un account di servizio Kubernetes.
   1. Aggiorna il file 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 il comando gcloud iam service-accounts add-iam-policy-binding come segue per abilitare l'associazione IAM dell'account di servizio Google Cloud e dell'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 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 secret Kubernetes per il database, l'utente e la password utente che verranno utilizzati dall'app di esempio. I valori di ciascun secret si basano sui valori specificati nei passaggi precedenti di questa guida rapida. Sostituisci DB_PASS con la password dell'account quickstart-user 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

Go

1. Esegui il comando gcloud artifacts repositories create seguente in Cloud Shell per creare un repository in Artifact Registry denominato gke-cloud-sql-repo nella stessa regione del 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 .

Java

1. Esegui il comando gcloud artifacts repositories create seguente in Cloud Shell per creare un repository in Artifact Registry denominato gke-cloud-sql-repo nella stessa regione del 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 comando gcloud artifacts repositories create seguente in Cloud Shell per creare un repository in Artifact Registry denominato gke-cloud-sql-repo nella stessa regione del 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 comando gcloud artifacts repositories create seguente in Cloud Shell per creare un repository in Artifact Registry denominato gke-cloud-sql-repo nella stessa regione del 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 .

Esegui il deployment dell'app di esempio

IP pubblico

Dopo aver definito la configurazione dell'app di esempio, ora puoi eseguire il deployment dell'app di esempio.

Go

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 un pattern collaterale Kubernetes. Il pattern collaterale si ottiene 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. Per ottenere il nome di connessione dell'istanza Cloud SQL, esegui 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 dell'istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Il nome della connessione dell'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: "3306"
           # 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=3306"
             - "<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 prima del deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando 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.

   

Java

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

1. Per ottenere il nome di connessione dell'istanza Cloud SQL, esegui 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 dell'istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Il nome della connessione dell'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: "3306"
           - 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 prima del deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando 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 un pattern collaterale Kubernetes. Il pattern collaterale si ottiene 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. Per ottenere il nome di connessione dell'istanza Cloud SQL, esegui 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 dell'istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Il nome della connessione dell'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"
           - name: INSTANCE_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "3306"
           - 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
         - 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=3306"
             - "<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 prima del deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando 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.

   

cloud-sql/mysql/mysql/deployment.yaml

Python

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 un pattern collaterale Kubernetes. Il pattern collaterale si ottiene 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. Per ottenere il nome di connessione dell'istanza Cloud SQL, esegui 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 dell'istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Il nome della connessione dell'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 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: "3306"
           # 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=3306"
             - "<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 prima del deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando 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.

   

IP privato

Dopo aver definito la configurazione dell'app di esempio, ora puoi eseguire il deployment dell'app di esempio.

Go

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 un pattern collaterale Kubernetes. Il pattern collaterale si ottiene 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. Per ottenere il nome di connessione dell'istanza Cloud SQL, esegui 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. Il nome della connessione dell'istanza è visibile anche nella pagina Panoramica dell'istanza Cloud SQL.
   • Abilita il proxy di autenticazione Cloud SQL per connetterti all'istanza Cloud SQL utilizzando il relativo indirizzo IP privato. Rimuovi il commento dal flag "-ip_address_types=PRIVATE" rimuovendo il simbolo del commento # e lo spazio vuoto finale. La segnalazione per i contenuti non commentati 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: "3306"
           # 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=3306"
             - "<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 prima del deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando 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.

   

Java

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

1. Per ottenere il nome di connessione dell'istanza Cloud SQL, esegui 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 dell'istanza Cloud SQL recuperato dal comando gcloud nel passaggio precedente. Il formato è project_id:region:instance_name. Il nome della connessione dell'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: "3306"
           - 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 prima del deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando 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 un pattern collaterale Kubernetes. Il pattern collaterale si ottiene 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. Per ottenere il nome di connessione dell'istanza Cloud SQL, esegui 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. Il nome della connessione dell'istanza è visibile anche nella pagina Panoramica dell'istanza Cloud SQL.
   • Abilita il proxy di autenticazione Cloud SQL per connetterti all'istanza Cloud SQL utilizzando il relativo indirizzo IP privato. Rimuovi il commento dal flag "-ip_address_types=PRIVATE" rimuovendo il simbolo del commento # e lo spazio vuoto finale. La segnalazione per i contenuti non commentati 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"
           - name: INSTANCE_HOST
             value: "127.0.0.1"
           - name: DB_PORT
             value: "3306"
           - 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
         - 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=3306"
             - "<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 prima del deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando 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.

   

cloud-sql/mysql/mysql/deployment.yaml

Python

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 un pattern collaterale Kubernetes. Il pattern collaterale si ottiene 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. Per ottenere il nome di connessione dell'istanza Cloud SQL, esegui 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. Il nome della connessione dell'istanza è visibile anche nella pagina Panoramica dell'istanza Cloud SQL.
   • Abilita il proxy di autenticazione Cloud SQL per connetterti all'istanza Cloud SQL utilizzando il relativo indirizzo IP privato. Rimuovi il commento dal flag "-ip_address_types=PRIVATE" rimuovendo il simbolo del commento # e lo spazio vuoto finale. La segnalazione per i contenuti non commentati 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: "3306"
           # 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=3306"
             - "<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 prima del deployment, in modo da potervi accedere tramite internet:

   kubectl apply -f service.yaml

5. Esegui il comando 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.

   

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 la pagina 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 Google Kubernetes Engine.

Passaggi di pulizia facoltativi

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

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

   Vai a IAM

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

Se non utilizzi le API che sono state abilitate in questa guida rapida, puoi disabilitarle.

• API 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 un'API che vuoi disabilitare e fai clic sul pulsante Disabilita API.

Passaggi successivi

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

Puoi inoltre scoprire di più sulla creazione di utenti MySQL e database 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.
• Configurazione dell'istanza Cloud SQL con un indirizzo IP pubblico.
• Configurazione dell'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
• Da Cloud Functions
• Da Cloud Run