Usa Cloud SQL para MySQL

En esta página se muestra cómo conectarse a una instancia de Cloud SQL para MySQL de segunda generación desde una aplicación de App Engine y cómo leer y escribir en Cloud SQL, que es una base de datos de SQL que existe en la nube de Google.

Para obtener más información sobre Cloud SQL, consulta la Documentación de Cloud SQL. Para obtener información sobre los precios y límites de Cloud SQL, consulta la página de Precios de Cloud SQL. Las aplicaciones de App Engine también están sujetas a las cuotas de App Engine.

Antes de comenzar

  1. Crea o selecciona un proyecto de GCP en la GCP Console y asegúrate de que incluya una aplicación de App Engine y de que la facturación se encuentre habilitada:
    Ir a App Engine

    El panel se abrirá si ya existe una aplicación de App Engine en tu proyecto y si la facturación está habilitada. De lo contrario, sigue las instrucciones para seleccionar una región y habilitar la facturación.

  2. Habilita las Cloud SQL API necesarias.

    Habilita las API

  3. Para implementar la aplicación con la herramienta gcloud debes descargar, instalar y luego inicializar el SDK de Cloud:
    Descargar el SDK

    Si ya tienes instalada la herramienta gcloud y deseas configurarla para usar un ID del proyecto de GCP distinto del que empleaste durante la inicialización, consulta Administra las configuraciones del SDK de Cloud.

Configura la instancia de Cloud SQL

Para crear y configurar una instancia de Cloud SQL, debes hacer lo siguiente:

  1. Crea una instancia de Cloud SQL de segunda generación.
  2. Si aún no lo hiciste, establece la contraseña para el usuario predeterminado en tu instancia de Cloud SQL.
    gcloud sql users set-password root --host=% --instance [INSTANCE_NAME] --password [PASSWORD]
    
  3. Si no deseas utilizar el usuario predeterminado para conectarte, crea un usuario.
  4. Registra el nombre de la conexión para la instancia con el siguiente comando:
    gcloud sql instances describe [INSTANCE_NAME]
    

    Por ejemplo:

    connectionName: project1:us-central1:instance1
    

    También puedes encontrar este valor en la página Detalles de la instancia de Google Cloud Platform Console.

  5. Crea una base de datos en tu instancia de Cloud SQL.
    gcloud sql databases create [DATABASE_NAME] --instance=[INSTANCE_NAME]
    
    Para obtener más información sobre cómo crear y administrar bases de datos, consulta la documentación de Cloud SQL.

Cómo configurar tu entorno local

Una vez implementada, la aplicación usa el proxy de Cloud SQL integrado en el entorno de ejecución de App Engine para comunicarse con la instancia de Cloud SQL. Sin embargo, para probar tu aplicación de manera local, debes instalar y usar una copia local del proxy de Cloud SQL en tu entorno de desarrollo.

Para realizar tareas administrativas básicas en tu instancia de Cloud SQL, puedes usar el cliente de administración de tu base de datos, o GCP Console.

  1. Autentica la herramienta gcloud para conectarte desde tu máquina local a través del proxy:

    gcloud auth application-default login
    
  2. Instala el proxy de Cloud SQL:

    Linux de 64 bits

    1. Descarga el proxy:
      wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.amd64 -O cloud_sql_proxy
      
    2. Haz que el proxy sea ejecutable:
      chmod +x cloud_sql_proxy
      

    Linux de 32 bits

    1. Descarga el proxy:
      wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.386 -O cloud_sql_proxy
      
    2. Haz que el proxy sea ejecutable:
      chmod +x cloud_sql_proxy
      

    macOS de 64 bits

    1. Descarga el proxy:
      curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.amd64
      
    2. Haz que el proxy sea ejecutable con el siguiente comando:
      chmod +x cloud_sql_proxy
      

    macOS de 32 bits

    1. Descarga el proxy con el siguiente comando:
      curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.386
      
    2. Haz que el proxy sea ejecutable con el siguiente comando:
      chmod +x cloud_sql_proxy
      

    Windows de 64 bits

    Para descargar el proxy, haz clic derecho en https://dl.google.com/cloudsql/cloud_sql_proxy_x64.exe y selecciona Guardar vínculo como. Cambia el nombre del archivo a cloud_sql_proxy.exe.

    Windows de 32 bits

    Para descargar el proxy, haz clic derecho en https://dl.google.com/cloudsql/cloud_sql_proxy_x86.exe y selecciona Guardar vínculo como. Cambia el nombre del archivo a cloud_sql_proxy.exe.
    Si tu sistema operativo no se incluye aquí, también puedes compilar el proxy desde la fuente.
  3. Ejecuta el proxy de la siguiente manera:

    Según tu lenguaje y entorno, puedes iniciar el proxy con sockets TCP o con sockets Unix.

    Sockets TCP

    1. Copia el nombre de conexión de tu instancia desde la página Detalles de la instancia.

      Por ejemplo: myproject:us-central1:myinstance.

    2. Si usas una cuenta de servicio para autenticar el proxy toma nota, en la máquina cliente, de la ubicación del archivo de claves privadas que se generó cuando creaste la cuenta de servicio.
    3. Inicia el proxy.

      Estas son algunas strings posibles de invocación del proxy:

      • Si usas la autenticación del SDK de Cloud:
        ./cloud_sql_proxy -instances=<INSTANCE_CONNECTION_NAME>=tcp:3306
        
        El puerto especificado no debe estar en uso, por ejemplo, por un servidor de base de datos local.
      • Si usas una cuenta de servicio y una especificación de instancia explícita (recomendado para entornos de producción):
        ./cloud_sql_proxy -instances=<INSTANCE_CONNECTION_NAME>=tcp:3306 \
                          -credential_file=<PATH_TO_KEY_FILE> &
        

      Para obtener más información sobre las opciones del proxy, consulta Opciones para autenticar el proxy y Opciones para especificar instancias.

    Sockets Unix

    1. Si usas una especificación de instancia explícita, copia el nombre de conexión de tu instancia que aparece en la página Detalles de la instancia.
    2. Crea el directorio donde se alojarán los sockets del proxy:
      sudo mkdir /cloudsql; sudo chmod 777 /cloudsql
    3. Si usas una cuenta de servicio para autenticar el proxy toma nota, en la máquina cliente, de la ubicación del archivo de claves privadas que se generó cuando creaste la cuenta de servicio.
    4. Abre una ventana de terminal nueva y, luego, inicia el proxy.

      Estas son algunas strings posibles de invocación del proxy:

      • Si usas una cuenta de servicio y una especificación de instancia explícita (recomendado para entornos de producción):
        ./cloud_sql_proxy -dir=/cloudsql -instances=<INSTANCE_CONNECTION_NAME> \
                          -credential_file=<PATH_TO_KEY_FILE> &
      • Si usas la autenticación del SDK de Cloud y la detección automática de instancia:
        ./cloud_sql_proxy -dir=/cloudsql &

      Se recomienda iniciar el proxy en su propia terminal para que puedas supervisar los resultados sin que se mezclen con los de otros programas.

      Para obtener más información sobre las opciones del proxy, consulta Opciones para autenticar el proxy y Opciones para especificar instancias.

  4. Para usar el cliente de administración, puedes instalar una copia local y conectarte a través del proxy o de direcciones IP.

    Para obtener más información, consulta Conecta un cliente MySQL mediante el proxy de Cloud SQL y Conecta un cliente MySQL mediante las direcciones IP.

Configura strings de conexión y agrega una biblioteca

  1. Configura el entorno local a fin de que sea compatible con conexiones para realizar pruebas locales.

    Por ejemplo, para el código de ejemplo de más abajo:

    export MYSQL_CONNECTION="[USER_NAME]:[PASSWORD]@tcp(127.0.0.1:3306)/[DATABASE_NAME]"
    

  2. Para permitir que la aplicación se conecte a tu instancia de Cloud SQL cuando la aplicación se implementa, agrega las variables de usuario, contraseña, base de datos y nombre de la conexión con la instancia desde Cloud SQL hasta las variables del entorno relacionadas en el archivo app.yaml:

    env_variables:
      # See https://github.com/go-sql-driver/mysql
      #
      # Replace INSTANCE_CONNECTION_NAME with the same value as in the
      # beta_settings section below.
      MYSQL_CONNECTION: user:password@unix(/cloudsql/INSTANCE_CONNECTION_NAME)/dbname
      #
      # If you're testing locally using the Cloud SQL proxy with TCP,
      # instead use the "tcp" dialer by setting the environment variable:
      # MYSQL_CONNECTION=user:password@tcp(127.0.0.1:3306)/dbname

  3. Agrega la sección beta_settings a tu app.yaml mediante el nombre de conexión de tu instancia de Cloud SQL.

    # Replace INSTANCE_CONNECTION_NAME with the value obtained when configuring your
    # Cloud SQL instance, available from the Google Cloud Console or from the Cloud SDK.
    # For SQL v2 instances, this should be in the form of "project:region:instance".
    # Cloud SQL v1 instances are not supported.
    beta_settings:
      cloud_sql_instances: INSTANCE_CONNECTION_NAME
  4. Descarga un paquete MySQL en tu máquina local mediante la línea de comandos. Por ejemplo:

    go get -u github.com/go-sql-driver/mysql
    

Cómo ejecutar el código de muestra

El siguiente ejemplo escribe la información de visitas en Cloud SQL y, luego, lee y muestra las últimas diez visitas:

// Sample cloudsql demonstrates usage of Cloud SQL from App Engine flexible environment.
package main

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

	"google.golang.org/appengine"

	_ "github.com/go-sql-driver/mysql"
)

var db *sql.DB

func main() {
	// Set this in app.yaml when running in production.
	datastoreName := os.Getenv("MYSQL_CONNECTION")

	var err error
	db, err = sql.Open("mysql", datastoreName)
	if err != nil {
		log.Fatal(err)
	}

	// Ensure the table exists.
	// Running an SQL query also checks the connection to the MySQL server
	// is authenticated and valid.
	if err := createTable(); err != nil {
		log.Fatal(err)
	}

	http.HandleFunc("/", handle)
	appengine.Main()
}

func createTable() error {
	stmt := `CREATE TABLE IF NOT EXISTS visits (
			timestamp  BIGINT,
			userip     VARCHAR(255)
		)`
	_, err := db.Exec(stmt)
	return err
}

func handle(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}

	// Get a list of the most recent visits.
	visits, err := queryVisits(10)
	if err != nil {
		msg := fmt.Sprintf("Could not get recent visits: %v", err)
		http.Error(w, msg, http.StatusInternalServerError)
		return
	}

	// Record this visit.
	if err := recordVisit(time.Now().UnixNano(), r.RemoteAddr); err != nil {
		msg := fmt.Sprintf("Could not save visit: %v", err)
		http.Error(w, msg, http.StatusInternalServerError)
		return
	}

	fmt.Fprintln(w, "Previous visits:")
	for _, v := range visits {
		fmt.Fprintf(w, "[%s] %s\n", time.Unix(0, v.timestamp), v.userIP)
	}
	fmt.Fprintln(w, "\nSuccessfully stored an entry of the current request.")
}

type visit struct {
	timestamp int64
	userIP    string
}

func recordVisit(timestamp int64, userIP string) error {
	stmt := "INSERT INTO visits (timestamp, userip) VALUES (?, ?)"
	_, err := db.Exec(stmt, timestamp, userIP)
	return err
}

func queryVisits(limit int64) ([]visit, error) {
	rows, err := db.Query("SELECT timestamp, userip FROM visits ORDER BY timestamp DESC LIMIT ?", limit)
	if err != nil {
		return nil, fmt.Errorf("Could not get recent visits: %v", err)
	}
	defer rows.Close()

	var visits []visit
	for rows.Next() {
		var v visit
		if err := rows.Scan(&v.timestamp, &v.userIP); err != nil {
			return nil, fmt.Errorf("Could not get timestamp/user IP out of row: %v", err)
		}
		visits = append(visits, v)
	}

	return visits, rows.Err()
}

Ejecuta pruebas y realiza la implementación

  1. Para realizar pruebas en tu aplicación de manera local, sigue estos pasos:

    go run cloudsql.go
    
  2. Después de la prueba local, implementa tu aplicación en App Engine:

    gcloud app deploy
    

  3. Ejecuta el siguiente comando para iniciar el navegador y ver la aplicación en http://[YOUR_PROJECT_ID].appspot.com:

    gcloud app browse
    

Ejecuta Cloud SQL y App Engine en proyectos diferentes

Si la aplicación de App Engine y la instancia de Cloud SQL se encuentran en distintos proyectos de Google Cloud Platform, debes usar una cuenta de servicio para permitir el acceso de la aplicación de App Engine a Cloud SQL.

Esta cuenta de servicio representa a tu aplicación de App Engine y se crea de forma predeterminada cuando creas un proyecto de Google Cloud Platform.

  1. Si tu aplicación de App Engine está en el mismo proyecto que tu instancia de Cloud SQL, puedes omitir esta sección y dirigirte a la página Cómo configurar tu entorno local. De lo contrario, continúa con el paso siguiente.
  2. Identifica la cuenta de servicio asociada a tu aplicación de App Engine. A la cuenta de servicio de App Engine predeterminada se le asigna el nombre [PROJECT-ID]@appspot.gserviceaccount.com.

    Puedes verificar la cuenta de servicio de App Engine en la página Permisos de IAM. Asegúrate de seleccionar el proyecto para tu aplicación de App Engine, no tu instancia de Cloud SQL.

    Ir a la página Permisos de IAM

  3. Ve a la página IAM y proyectos del administrador en Google Cloud Platform Console.

    Ir a la página IAM y proyectos del administrador

  4. Selecciona el proyecto que contiene la instancia de Cloud SQL.
  5. Busca el nombre de la cuenta de servicio.
  6. Si ya existe la cuenta de servicio, y tiene una función que incluye el permiso cloudsql.instances.connect, puedes proceder a la página Configura tu entorno local.

    Las funciones Cloud SQL Client, Cloud SQL Editor y Cloud SQL Admin, y las funciones del proyecto heredadas Editor y Owner, todas otorgan los permisos necesarios.

  7. De lo contrario, haz clic en Agregar para incluir la cuenta de servicio.
  8. En el diálogo Agregar miembros, ingresa el nombre de la cuenta de servicio y selecciona una función que incluya el permiso cloudsql.instances.connect (cualquier función predefinida de Cloud SQL funcionará, excepto Visualizador).

    O bien, puedes seleccionar Proyecto > Editor para usar la función básica de editor, pero esta incluye permisos en Google Cloud Platform.

    Si no ves estas funciones, es posible que tu usuario de Google Cloud Platform no tenga el permiso resourcemanager.projects.setIamPolicy. Puedes verificar tus permisos en la página IAM en Google Cloud Platform Console y buscar tu ID de usuario.

  9. Haz clic en Agregar.

    Ahora deberías ver que la cuenta de servicio aparece con la función especificada.

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Entorno flexible de App Engine para Go