Se usó la API de Cloud Translation para traducir esta página.

Cómo conectar una aplicación de Go en Cloud Run a una base de datos de Cloud SQL para PostgreSQL

1. Descripción general

El conector de Go de Cloud SQL es la forma más fácil de conectar de manera segura tu aplicación de Go a tu base de datos de Cloud SQL. Cloud Run es una plataforma sin servidores completamente administrada que te permite ejecutar contenedores sin estado que se pueden invocar a través de solicitudes HTTP. En este codelab, se demostrará cómo conectar una aplicación de Go en Cloud Run a una base de datos de Cloud SQL para PostgreSQL de forma segura con una cuenta de servicio a través de la autenticación de IAM.

Qué aprenderás

En este lab, aprenderás a realizar las siguientes tareas:

Crea una base de datos de Cloud SQL para PostgreSQL
Implementa una aplicación de Go en Cloud Run
Conecta tu aplicación a Cloud SQL con el conector de Go

Requisitos previos

Para este lab, se da por sentado que el usuario tiene conocimientos previos sobre los entornos de la consola de Cloud y Cloud Shell.

2. Antes de comenzar

Configuración del proyecto de Cloud

Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una Cuenta de Google, debes crear una.

El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla en cualquier momento.
El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. por lo general, no te importa qué es. En la mayoría de los codelabs, deberás hacer referencia al ID del proyecto (por lo general, se identifica como PROJECT_ID). Si no te gusta el ID generado, puedes generar otro aleatorio. También puedes probar el tuyo propio y ver si está disponible. No se puede cambiar después de este paso y se mantendrá mientras dure el proyecto.
Para tu información, hay un tercer valor, un número de proyecto que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.

A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no debería costar mucho, tal vez nada. Para cerrar recursos y evitar que se te facture más allá de este instructivo, puedes borrar los recursos que creaste o borrar todo el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de USD 300.

Configuración del entorno

Para activar Cloud Shell, haz clic en el ícono que se encuentra a la derecha de la barra de búsqueda.

En Cloud Shell, habilita las APIs:

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

Si se te solicita que autorices, haz clic en “Autorizar”. para continuar.

Este comando puede tardar unos minutos en completarse, pero, con el tiempo, debería generar un mensaje de éxito similar a este:

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

3. Configura una cuenta de servicio

Crear y configurar una cuenta de servicio de Google Cloud para que Cloud Run la use, de manera que tenga los permisos correctos para conectarse a Cloud SQL

Ejecuta el comando gcloud iam service-accounts create como se muestra a continuación para crear una cuenta de servicio nueva:
```
gcloud iam service-accounts create quickstart-service-account \
  --display-name="Quickstart Service Account"
```
Ejecuta el comando gcloud projects add-iam-policy-binding como se indica a continuación para agregar el rol Cliente de Cloud SQL a la cuenta de servicio de Google Cloud que acabas de crear. En Cloud Shell, la expresión ${GOOGLE_CLOUD_PROJECT} se reemplazará por el nombre de tu proyecto. También puedes hacer este reemplazo de forma manual si te sientes más a gusto con él.
```
gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
  --member="serviceAccount:quickstart-service-account@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.client"
```

Ejecuta el comando gcloud projects add-iam-policy-binding como se indica a continuación para agregar el rol Usuario de instancia de Cloud SQL a la cuenta de servicio de Google Cloud que acabas de crear.

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

Ejecuta el comando gcloud projects add-iam-policy-binding como se indica a continuación para agregar el rol de Escritor de registros a la cuenta de servicio de Google Cloud que acabas de crear.

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. Configura Cloud SQL

Ejecuta el comando gcloud sql instances create para crear una instancia de Cloud SQL.

–database-version: Es el tipo y la versión del motor de base de datos. Si no se especifica, se usa la configuración predeterminada de API. Consulta la documentación de las versiones de la base de datos de gcloud para ver las versiones disponibles actuales.
–cpu: Es la cantidad de núcleos deseados en la máquina.
–memory: Es un valor de número entero que indica cuánta memoria se desea en la máquina. Se debe proporcionar una unidad de tamaño (por ejemplo, 3,072 MB o 9 GB). Si no se especifican unidades, se supone que es GB.
–region: Es la ubicación regional de la instancia (por ejemplo: us-central1, asia-east1, us-east1).
–database-flags: Permite establecer marcas. En este caso, activaremos cloudsql.iam_authentication para permitir que Cloud Run se conecte a Cloud SQL con la cuenta de servicio que creamos antes.
```
gcloud sql instances create quickstart-instance \
  --database-version=POSTGRES_14 \
  --cpu=1 \
  --memory=4GB \
  --region=us-central1 \
  --database-flags=cloudsql.iam_authentication=on
```

Este comando puede tardar unos minutos en completarse.

Ejecuta el comando gcloud sql databases create para crear una base de datos de Cloud SQL dentro de quickstart-instance.

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

Crea un usuario de base de datos de PostgreSQL para la cuenta de servicio que creaste antes para acceder a la base de datos.

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

5. Preparar aplicación

Preparar una aplicación de Go que responda a las solicitudes HTTP

En Cloud Shell, crea un directorio nuevo llamado helloworld y, luego, cambia a ese directorio:
```
mkdir helloworld
cd helloworld
```

Ejecuta go mod init para inicializar una nueva aplicación de Go.

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

Instala la dependencia del conector de Cloud SQL para Go.

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

Crea un archivo main.go con el código de la aplicación. Este código puede hacer lo siguiente:

Acepta solicitudes HTTP
Conéctate a la base de datos
Almacenar la hora de la solicitud HTTP en la base de datos
Muestra los horarios de las últimas cinco solicitudes

Ejecuta el siguiente comando en 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

Con este código, se crea un servidor web básico que escucha en el puerto definido por la variable de entorno PORT. La aplicación ya está lista para implementarse.

6. Implementa la aplicación de Cloud Run

Ejecuta el siguiente comando para implementar tu aplicación:

–region: Es la ubicación regional de la instancia (por ejemplo: us-central1, asia-east1, us-east1).
–source: Es el código fuente que se implementará. En este caso, . hace referencia al código fuente de la carpeta actual helloworld.
–set-env-vars: Establece las variables de entorno que usa la aplicación para dirigirla a la base de datos de Cloud SQL.
–service-account: Une la implementación de Cloud Run con la cuenta de servicio con permisos para conectarse a la base de datos de Cloud SQL creada al comienzo de este codelab.
–allow-unauthenticated: Permite solicitudes no autenticadas para que se pueda acceder a la aplicación desde 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 se te solicita, presiona y y Enter para confirmar que deseas continuar:

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

Luego de unos minutos, la aplicación debería proporcionarte una URL para que la visites.

Navega a la URL para ver tu aplicación en acción. Cada vez que visites la URL o actualices la página, verás que las cinco visitas más recientes se muestran en formato JSON.

7. Felicitaciones

Implementaste una aplicación de Go en Cloud Run que puede conectarse a una base de datos de PostgreSQL que se ejecuta en Cloud SQL.

Temas abordados:

Crea una base de datos de Cloud SQL para PostgreSQL
Implementa una aplicación de Go en Cloud Run
Conecta tu aplicación a Cloud SQL mediante el conector de Go

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales. Si quieres borrar todo el proyecto, puedes ejecutar lo siguiente:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}