Questa pagina è stata tradotta dall'API Cloud Translation.

Come connettere un'applicazione Go su Cloud Run a un database Cloud SQL per PostgreSQL

1. Panoramica

Il connettore Cloud SQL Go è il modo più semplice per connettere in modo sicuro l'applicazione Go al database Cloud SQL. Cloud Run è una piattaforma serverless completamente gestita che consente di eseguire container stateless richiamabili tramite richieste HTTP. Questo codelab dimostrerà come connettere un'applicazione Go su Cloud Run a un database Cloud SQL per PostgreSQL in modo sicuro con un account di servizio utilizzando l'autenticazione IAM.

Cosa imparerai a fare

In questo lab imparerai a:

Crea un database Cloud SQL per PostgreSQL
Esegui il deployment di un'applicazione Go in Cloud Run
Collega la tua applicazione a Cloud SQL utilizzando Go Connector

Prerequisiti

In questo lab si presuppone che tu abbia familiarità con gli ambienti della console Cloud e Cloud Shell.

2. Prima di iniziare

Configurazione del progetto Cloud

Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non disponi già di un Account Google, devi crearne uno.

Il Nome progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi aggiornarla in qualsiasi momento.
L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. di solito non ti importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere è identificato come PROJECT_ID). Se l'ID generato non ti soddisfa, puoi generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimarrà per tutta la durata del progetto.
Per informazione, c'è un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. Eseguire questo codelab non dovrebbe costare molto. Per arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial, puoi eliminare le risorse che hai creato o eliminare l'intero progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Configurazione dell'ambiente

Attiva Cloud Shell facendo clic sull'icona a destra della barra di ricerca.

Da Cloud Shell, abilita le API:

gcloud services enable compute.googleapis.com sqladmin.googleapis.com \
  run.googleapis.com artifactregistry.googleapis.com \
  cloudbuild.googleapis.com servicenetworking.googleapis.com

Se ti viene richiesta l'autorizzazione, fai clic su "Autorizza". per continuare.

Il completamento di questo comando potrebbe richiedere alcuni minuti, ma alla fine dovrebbe generare un messaggio di operazione riuscita simile a questo:

Operation "operations/acf.p2-327036483151-73d90d00-47ee-447a-b600-a6badf0eceae" finished successfully.

3. Configurare un account di servizio

Creare e configurare un account di servizio Google Cloud che verrà utilizzato da Cloud Run in modo che disponga delle autorizzazioni corrette per connettersi a Cloud SQL.

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

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

Esegui il comando gcloud projects add-iam-policy-binding come segue per aggiungere il ruolo Client Cloud SQL all'account di servizio Google Cloud che hai appena creato. In Cloud Shell, l'espressione ${GOOGLE_CLOUD_PROJECT} verrà sostituita dal nome del tuo progetto. Puoi anche effettuare la sostituzione manualmente se preferisci.
```
gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
  --member="serviceAccount:quickstart-service-account@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.client"
```

Esegui il comando gcloud projects add-iam-policy-binding come segue per aggiungere il ruolo Utente istanza Cloud SQL all'account di servizio Google Cloud appena creato.

gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
  --member="serviceAccount:quickstart-service-account@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.instanceUser"

Esegui il comando gcloud projects add-iam-policy-binding come segue per aggiungere il ruolo Writer log all'account di servizio Google Cloud che hai appena creato.

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

4. Configurare Cloud SQL

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

–database-version: il tipo e la versione del motore del database. Se questo valore non è specificato, viene utilizzato il valore predefinito dell'API. Consulta la documentazione delle versioni del database gcloud per vedere le versioni attualmente disponibili.
-cpu: il numero di core desiderato nella macchina.
-memory: valore numerico intero che indica la quantità di memoria desiderata nella macchina. Deve essere indicata un'unità di dimensione (ad esempio, 3072 MB o 9 GB). Se non viene specificata alcuna unità, viene usato il valore GB.
–region: località regionale dell'istanza (ad esempio: us-central1, asia-east1, us-east1).
–database-flags: consente di impostare i flag. In questo caso, attiveremo cloudsql.iam_authentication per consentire a Cloud Run di connettersi a Cloud SQL utilizzando l'account di servizio che abbiamo creato in precedenza.
```
gcloud sql instances create quickstart-instance \
  --database-version=POSTGRES_14 \
  --cpu=1 \
  --memory=4GB \
  --region=us-central1 \
  --database-flags=cloudsql.iam_authentication=on
```

Il completamento di questo comando potrebbe richiedere alcuni minuti.

Esegui il comando gcloud sql databases create per creare un database Cloud SQL all'interno di quickstart-instance.

gcloud sql databases create quickstart_db \
  --instance=quickstart-instance

Crea un utente del database PostgreSQL per l'account di servizio che hai creato in precedenza al fine di accedere al database.

gcloud sql users create quickstart-service-account@${GOOGLE_CLOUD_PROJECT}.iam \
  --instance=quickstart-instance \
  --type=cloud_iam_service_account

5. Prepara la richiesta

Prepara un'applicazione Go che risponda alle richieste HTTP.

In Cloud Shell crea una nuova directory denominata helloworld, quindi passa a quella directory:
```
mkdir helloworld
cd helloworld
```

Esegui go mod init per inizializzare una nuova applicazione Go.

go mod init github.com/GoogleCloudPlatform/golang-samples/run/helloworld

Installa la dipendenza del connettore Cloud SQL Go.

go get cloud.google.com/go/cloudsqlconn
go get cloud.google.com/go/cloudsqlconn/postgres/pgxv4

Crea un file main.go con il codice dell'applicazione. Questo codice è in grado di:

Accetta richieste HTTP
Connettiti al database
Archiviare l'ora della richiesta HTTP nel database
Restituisce gli orari delle ultime cinque richieste

di Gemini Advanced. Esegui questo comando in Cloud Shell:

cat > main.go << "EOF"
package main

import (
  "database/sql"
  "encoding/json"
  "fmt"
  "log"
  "net/http"
  "os"
  "time"

  "cloud.google.com/go/cloudsqlconn"
  "cloud.google.com/go/cloudsqlconn/postgres/pgxv4"
)

// visitData is used to pass data to the HTML template.
type visitData struct {
  RecentVisits []visit
}

// visit contains a single row from the visits table in the database.
// Each visit includes a timestamp.
type visit struct {
  VisitTime time.Time
}

// getDB creates a connection to the database
// based on environment variables.
func getDB() (*sql.DB, func() error) {
  cleanup, err := pgxv4.RegisterDriver("cloudsql-postgres", cloudsqlconn.WithIAMAuthN())
  if err != nil {
    log.Fatalf("Error on pgxv4.RegisterDriver: %v", err)
  }

  dsn := fmt.Sprintf("host=%s user=%s dbname=%s sslmode=disable", os.Getenv("INSTANCE_CONNECTION_NAME"), os.Getenv("DB_USER"), os.Getenv("DB_NAME"))
  db, err := sql.Open("cloudsql-postgres", dsn)
  if err != nil {
    log.Fatalf("Error on sql.Open: %v", err)
  }

  createVisits := `CREATE TABLE IF NOT EXISTS visits (
    id SERIAL NOT NULL,
    created_at timestamp NOT NULL,
    PRIMARY KEY (id)
  );`
  _, err = db.Exec(createVisits)
  if err != nil {
    log.Fatalf("unable to create table: %s", err)
  }

  return db, cleanup
}

func main() {
  port := os.Getenv("PORT")
  if port == "" {
    port = "8080"
  }
  log.Printf("Listening on port %s", port)
  db, cleanup := getDB()
  defer cleanup()

  http.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
    // Insert current visit
    _, err := db.Exec("INSERT INTO visits(created_at) VALUES(NOW())")
    if err != nil {
      log.Fatalf("unable to save visit: %v", err)
    }

    // Get the last 5 visits
    rows, err := db.Query("SELECT created_at FROM visits ORDER BY created_at DESC LIMIT 5")
    if err != nil {
      log.Fatalf("DB.Query: %v", err)
    }
    defer rows.Close()

    var visits []visit
    for rows.Next() {
      var visitTime time.Time
      err := rows.Scan(&visitTime)
      if err != nil {
        log.Fatalf("Rows.Scan: %v", err)
      }
      visits = append(visits, visit{VisitTime: visitTime})
    }
    response, err := json.Marshal(visitData{RecentVisits: visits})
    if err != nil {
      log.Fatalf("renderIndex: failed to parse totals with json.Marshal: %v", err)
    }
    w.Write(response)
  })
  if err := http.ListenAndServe(":"+port, nil); err != nil {
    log.Fatal(err)
  }
}

EOF

Questo codice crea un server web di base in ascolto sulla porta definita dalla variabile di ambiente PORT. L'applicazione è ora pronta per il deployment.

6. Esegui il deployment dell'applicazione Cloud Run

Esegui questo comando per eseguire il deployment della tua applicazione:

–region: località regionale dell'istanza (ad esempio: us-central1, asia-east1, us-east1).
–source: il codice sorgente di cui eseguire il deployment. In questo caso, . si riferisce al codice sorgente nella cartella corrente helloworld.
–set-env-vars: imposta le variabili di ambiente utilizzate dall'applicazione per indirizzarla al database Cloud SQL.
–service-account: collega il deployment di Cloud Run all'account di servizio con le autorizzazioni per connettersi al database Cloud SQL creato all'inizio di questo codelab.
–allow-unauthenticated: consente le richieste non autenticate in modo che l'applicazione sia accessibile da internet.

gcloud run deploy helloworld \
  --region=us-central1 \
  --source=. \
  --set-env-vars INSTANCE_CONNECTION_NAME="${GOOGLE_CLOUD_PROJECT}:us-central1:quickstart-instance" \
  --set-env-vars DB_NAME="quickstart_db" \
  --set-env-vars DB_USER="quickstart-service-account@${GOOGLE_CLOUD_PROJECT}.iam" \
  --service-account="quickstart-service-account@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \
  --allow-unauthenticated

Se richiesto, premi y e Enter per confermare che vuoi continuare:

Do you want to continue (Y/n)? y

Dopo alcuni minuti, l'applicazione dovrebbe fornirti un URL da visitare.

Vai all'URL per vedere la tua applicazione in azione. Ogni volta che visiti l'URL o aggiorni la pagina, vedrai le cinque visite più recenti restituite in formato JSON.

7. Complimenti

Hai eseguito il deployment di un'applicazione Go su Cloud Run in grado di connettersi a un database PostgreSQL in esecuzione su Cloud SQL.

Argomenti trattati:

Creazione di un database Cloud SQL per PostgreSQL
Deployment di un'applicazione Go in Cloud Run
Connessione dell'applicazione a Cloud SQL mediante Go Connector

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse. Se vuoi eliminare l'intero progetto, puoi eseguire:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}