Connettiti a Cloud SQL per MySQL da Google Kubernetes Engine

Questa pagina mostra come eseguire il deployment di un'app di esempio su Google Kubernetes Engine (GKE) connessa a un'istanza MySQL utilizzando la console Google Cloud e un'applicazione client. Le risorse create in questa guida rapida in genere costano meno di un dollaro (USD), se completi i passaggi, inclusa la pulizia, in modo tempestivo.

Prima di iniziare

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

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

    Go to project selector

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

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

    Go to project selector

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

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

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

    Abilita le API

    Vengono abilitate le seguenti API:

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

    Fai clic sul pulsante seguente per aprire Cloud Shell, che fornisce l'accesso da riga di comando alle tue 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 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 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
Consolegcloud

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 per ID istanza.
  5. Inserisci una password per l'utente root. 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 l'inizializzazione e l'avvio dell'istanza.

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

(Facoltativo) 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 la documentazione sulle versioni del database gcloud per visualizzare le versioni attualmente disponibili.
  • --cpu: il numero di core desiderati nella macchina.
  • --memory: valore numerico intero che indica la quantità di memoria desiderata nella macchina. Deve essere fornita un'unità di misura delle dimensioni (ad esempio, 3072 MB o 9 GB). Se non sono specificate unità, viene utilizzato il GB.
  • --region: posizione 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 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

Consolegcloud

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 per ID istanza.
  5. Inserisci una password per l'utente root. 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 su Mostra opzioni di configurazione ed espandile.
  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 con il messaggio È 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 Alloca 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 l'inizializzazione e l'avvio dell'istanza.
  14. Fai clic su 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 e poi attendi il riavvio dell'istanza.

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

    4. (Facoltativo) 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 la quantità di memoria da includere nella macchina. È possibile fornire un'unità di dimensione (ad esempio 3072 MB o 9 GB). Se non sono specificate unità, viene utilizzato il 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=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 connessioni SSL per l'istanza. 

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

Crea un database

Consolegcloud

  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.

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

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

Crea un utente

Consolegcloud

  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. Prendi nota di questo valore per utilizzarlo in un passaggio successivo di questa guida rapida.
      • Nella sezione Nome host, il valore predefinito è Consenti qualsiasi host, il che significa che l'utente può connettersi da qualsiasi indirizzo IP.

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

  5. Fai clic su Aggiungi.

Prima di eseguire il comando come segue, sostituisci DB_PASS con una password per l'utente del database. Prendi nota di questo valore 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 del nome utente sono gli stessi per Cloud SQL e per MySQL on-premise: 32 caratteri per MySQL 8.0 e versioni successive, 16 caratteri per le versioni precedenti.

Crea un cluster GKE

Consolegcloud

  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.

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.

VaiJavaNode.jsPython

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

Attiva il cluster GKE che hai appena creato come cluster predefinito da utilizzare per i comandi rimanenti di 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 service account da utilizzare con GKE in modo che disponga del ruolo Client Cloud SQL con le autorizzazioni per connettersi a Cloud SQL. Google Cloud
  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 al service account 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 la registrazione, quindi esegui il comando gcloud projects add-iam-policy-binding come segue per aggiungere il ruolo Writer log al service account 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 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 al service account Google Cloud utilizzando la federazione delle identità per i workload per GKE.
  1. Crea un service account 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 del service account Google Cloud e del service account Kubernetes. Esegui 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'associazione IAM al service account Kubernetes. Esegui 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 nell'app di esempio. I valori di ogni secret si basano sui valori specificati nei passaggi precedenti di questa guida rapida. Sostituisci DB_PASS con la password di quickstart-user che hai creato nel passaggio precedente della guida rapida Crea 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

VaiJavaNode.jsPython
  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 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 .
  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 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
  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 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 .
  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 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

Con la configurazione dell'app di esempio in posizione, ora puoi eseguire il deployment dell'app di esempio.

VaiJavaNode.jsPython

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando Cloud SQL Proxy in esecuzione in un pattern sidecar Kubernetes. Il pattern sidecar viene implementato 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 all'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. Esegui 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 di 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: "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 davanti al 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 una volta disponibile nei dettagli del servizio, il che 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.

    Visualizzare l&#39;app di esempio di cui è stato eseguito il deployment

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

  1. Recupera il nome della connessione all'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. Esegui 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 di 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: "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 davanti al 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 una volta disponibile nei dettagli del servizio, il che 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.

    Visualizzare l&#39;app di esempio di cui è stato eseguito il deployment

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando Cloud SQL Proxy in esecuzione in un pattern sidecar Kubernetes. Il pattern sidecar viene implementato 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 all'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. Esegui 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 di 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"
        - 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 davanti al 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 una volta disponibile nei dettagli del servizio, il che 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.

    Visualizzare l&#39;app di esempio di cui è stato eseguito il deployment

cloud-sql/mysql/mysql/deployment.yaml

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando Cloud SQL Proxy in esecuzione in un pattern sidecar Kubernetes. Il pattern sidecar viene implementato 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 all'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. Esegui 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 di 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 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 davanti al 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 una volta disponibile nei dettagli del servizio, il che 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.

    Visualizzare l&#39;app di esempio di cui è stato eseguito il deployment

Con la configurazione dell'app di esempio in posizione, ora puoi eseguire il deployment dell'app di esempio.

VaiJavaNode.jsPython

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando Cloud SQL Proxy in esecuzione in un pattern sidecar Kubernetes. Il pattern sidecar viene implementato 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 all'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. Il nome di connessione 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 "-ip_address_types=PRIVATE" rimuovendo il simbolo di commento # e lo spazio vuoto finale. Il flag senza commento 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 davanti al 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 una volta disponibile nei dettagli del servizio, il che 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.

    Visualizzare l&#39;app di esempio di cui è stato eseguito il deployment

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

  1. Recupera il nome della connessione all'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. Esegui 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 di 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: "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 davanti al 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 una volta disponibile nei dettagli del servizio, il che 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.

    Visualizzare l&#39;app di esempio di cui è stato eseguito il deployment

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando Cloud SQL Proxy in esecuzione in un pattern sidecar Kubernetes. Il pattern sidecar viene implementato 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 all'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. Il nome di connessione 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 "-ip_address_types=PRIVATE" rimuovendo il simbolo di commento # e lo spazio vuoto finale. Il flag senza commento 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 davanti al 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 una volta disponibile nei dettagli del servizio, il che 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.

    Visualizzare l&#39;app di esempio di cui è stato eseguito il deployment

cloud-sql/mysql/mysql/deployment.yaml

L'app di esempio di cui è stato eseguito il deployment si connette all'istanza Cloud SQL utilizzando Cloud SQL Proxy in esecuzione in un pattern sidecar Kubernetes. Il pattern sidecar viene implementato 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 all'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. Il nome di connessione 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 "-ip_address_types=PRIVATE" rimuovendo il simbolo di commento # e lo spazio vuoto finale. Il flag senza commento 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 davanti al 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 una volta disponibile nei dettagli del servizio, il che 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.

    Visualizzare l&#39;app di esempio di cui è stato eseguito il deployment

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 e poi 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' Google Cloud account di servizio 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 per l'account IAM denominato gke-quickstart-service-account.
  3. Fai clic su Rimuovi e conferma la rimozione.

Se non utilizzi le API attivate nell'ambito di questa guida rapida, puoi disattivarle.

  • 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 le API che vuoi disattivare, poi 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 MySQL e database per la tua istanza Cloud SQL.

Consulta anche le informazioni sui prezzi di Cloud SQL.

Scopri di più su:

Inoltre, puoi scoprire di più sulla connessione a un'istanza Cloud SQL da altre applicazioni Google Cloud: