Connecter une application Go sur Cloud Run à une base de données Cloud SQL pour PostgreSQL

1. Présentation

Le connecteur Cloud SQL Go est le moyen le plus simple de connecter de façon sécurisée votre application Go à votre base de données Cloud SQL. Cloud Run est une plate-forme sans serveur entièrement gérée qui vous permet d'exécuter des conteneurs sans état accessibles via des requêtes HTTP. Dans cet atelier de programmation, vous allez découvrir comment connecter de façon sécurisée une application Go dans Cloud Run à une base de données Cloud SQL pour PostgreSQL à l'aide d'un compte de service à l'aide de l'authentification IAM.

Objectifs de l'atelier

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

  • Créer une base de données Cloud SQL pour PostgreSQL
  • Déployer une application Go dans Cloud Run
  • Connecter votre application à Cloud SQL à l'aide du connecteur Go

Prérequis

  • Pour cet atelier, nous partons du principe que vous connaissez la console Cloud et les environnements Cloud Shell.

2. Avant de commencer

Configuration du projet Cloud

  1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. Si vous n'avez pas encore de compte Google, vous devez en créer un.

b35bf95b8bf3d5d8.png

a99b7ace416376c4.png

bd84a6d3004737c5.png

  • Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pouvez le modifier à tout moment.
  • L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique. généralement, vous ne vous souciez pas de ce que c’est. Dans la plupart des ateliers de programmation, vous devrez référencer l'ID du projet (il est généralement identifié comme PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre au hasard. Vous pouvez également essayer la vôtre pour voir si elle est disponible. Il ne peut pas être modifié après cette étape et restera actif pendant toute la durée du projet.
  • Pour votre information, il existe une troisième valeur, le numéro de projet, utilisé par certaines API. Pour en savoir plus sur ces trois valeurs, consultez la documentation.
  1. Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour arrêter les ressources afin d'éviter que des frais ne vous soient facturés au-delà de ce tutoriel, vous pouvez supprimer les ressources que vous avez créées ou l'ensemble du projet. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai gratuit pour bénéficier d'un crédit de 300 $.

Configuration de l'environnement

Activez Cloud Shell en cliquant sur l'icône située à droite de la barre de recherche.

ecdc43ada29e91b.png

Dans Cloud Shell, activez les API:

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

Si vous êtes invité à donner votre autorisation, cliquez sur "Autoriser". pour continuer.

6356559df3eccdda.png

L'exécution de cette commande peut prendre quelques minutes, mais elle devrait générer un message de réussite semblable à celui-ci:

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

3. Configurer un compte de service

Créez et configurez un compte de service Google Cloud qui sera utilisé par Cloud Run afin qu'il dispose des autorisations nécessaires pour se connecter à Cloud SQL.

  1. Exécutez la commande gcloud iam service-accounts create comme suit pour créer un compte de service:
    gcloud iam service-accounts create quickstart-service-account \
  --display-name="Quickstart Service Account"
  2. Exécutez la commande gcloud projects add-iam-policy-binding comme suit pour ajouter le rôle Client Cloud SQL au compte de service Google Cloud que vous venez de créer. Dans Cloud Shell, l'expression ${GOOGLE_CLOUD_PROJECT} sera remplacée par le nom de votre projet. Vous pouvez également procéder à ce remplacement manuellement, si cela vous convient.
    gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
  --member="serviceAccount:quickstart-service-account@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.client"
  3. Exécutez la commande gcloud projects add-iam-policy-binding comme suit pour ajouter le rôle Utilisateur d'instance Cloud SQL au compte de service Google Cloud que vous venez de créer.
    gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
  --member="serviceAccount:quickstart-service-account@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.instanceUser"
  4. Exécutez la commande gcloud projects add-iam-policy-binding comme suit pour ajouter le rôle Rédacteur de journaux au compte de service Google Cloud que vous venez de créer.
    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. Configurer Cloud SQL

Exécutez la commande gcloud sql instances create pour créer une instance Cloud SQL.

  • –database-version: type et version du moteur de la base de données. Si aucune valeur n'est spécifiée, la valeur par défaut de l'API est utilisée. Reportez-vous à la documentation sur les versions de base de données gcloud pour connaître les versions actuellement disponibles.
  • –cpu: nombre de cœurs souhaité dans la machine
  • –memory: nombre entier indiquant la quantité de mémoire souhaitée dans la machine. Vous devez indiquer une unité de taille (par exemple, 3 072 Mo ou 9 Go). Si aucune unité n'est spécifiée, la valeur en Go est utilisée par défaut.
  • –region: emplacement régional de l'instance (par exemple: us-central1, asia-east1, us-east1)
  • –database-flags: permet de définir des indicateurs. Dans le cas présent, nous activons cloudsql.iam_authentication pour permettre à Cloud Run de se connecter à Cloud SQL à l'aide du compte de service que nous avons créé précédemment.
    gcloud sql instances create quickstart-instance \
  --database-version=POSTGRES_14 \
  --cpu=1 \
  --memory=4GB \
  --region=us-central1 \
  --database-flags=cloudsql.iam_authentication=on

L'exécution de cette commande peut prendre quelques minutes.

Exécutez la commande gcloud sql databases create pour créer une base de données Cloud SQL dans quickstart-instance.

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

Créez un utilisateur de base de données PostgreSQL pour le compte de service que vous avez créé précédemment afin d'accéder à la base de données.

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

5. Préparer la demande

Préparer une application Go qui répond aux requêtes HTTP

  1. Dans Cloud Shell, créez un répertoire nommé helloworld, puis accédez-y:
    mkdir helloworld
cd helloworld
  2. Exécutez go mod init pour initialiser une nouvelle application Go.
    go mod init github.com/GoogleCloudPlatform/golang-samples/run/helloworld
  3. Installez la dépendance du connecteur Cloud SQL Go.
    go get cloud.google.com/go/cloudsqlconn
go get cloud.google.com/go/cloudsqlconn/postgres/pgxv4
  4. Créez un fichier main.go avec le code de l'application. Ce code est capable d'effectuer les opérations suivantes:
    • Accepter les requêtes HTTP
    • Se connecter à la base de données
    • Stocker l'heure de la requête HTTP dans la base de données
    • Renvoyer les heures des cinq dernières requêtes
    Exécutez la commande suivante dans 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

Ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT. L'application est maintenant prête à être déployée.

6. Déployer une application Cloud Run

Exécutez la commande ci-dessous pour déployer votre application:

  • –region: emplacement régional de l'instance (par exemple: us-central1, asia-east1, us-east1)
  • –source: le code source à déployer. Dans ce cas, . fait référence au code source du dossier helloworld actuel.
  • –set-env-vars: définit les variables d'environnement utilisées par l'application pour diriger celle-ci vers la base de données Cloud SQL.
  • -service-account: associe le déploiement Cloud Run au compte de service autorisé à se connecter à la base de données Cloud SQL créée au début de cet atelier de programmation.
  • –allow-unauthenticated: autorise les requêtes non authentifiées afin que l'application soit accessible depuis 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

Si vous y êtes invité, appuyez sur y et Enter pour confirmer que vous souhaitez continuer:

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

Après quelques minutes, l'application devrait fournir une URL à laquelle vous pouvez accéder.

Accédez à l'URL pour voir votre application en action. Chaque fois que vous accédez à l'URL ou actualisez la page, les cinq visites les plus récentes sont renvoyées au format JSON.

7. Félicitations

Vous avez déployé sur Cloud Run une application Go capable de se connecter à une base de données PostgreSQL exécutée sur Cloud SQL.

Points abordés

  • Créer une base de données Cloud SQL pour PostgreSQL
  • Déployer une application Go sur Cloud Run
  • Connecter votre application à Cloud SQL à l'aide du connecteur Go

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez chaque ressource individuellement. Si vous souhaitez supprimer l'intégralité du projet, vous pouvez exécuter la commande suivante:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}