Utiliza Cloud SQL para MySQL

En esta página, se explica cómo conectarse a una instancia de segunda generación de Cloud SQL para MySQL desde una aplicación de App Engine y cómo realizar operaciones de lectura y escritura en Cloud SQL. Cloud SQL es una base de datos SQL que reside en la nube de Google.

Para obtener más información sobre Cloud SQL, consulta la documentación de Cloud SQL. Si deseas 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 GCP Console y asegúrate de que incluya una aplicación de App Engine y de que la facturación esté 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 tu app con la herramienta gcloud, debes descargar el SDK de Cloud, instalarlo y, por último, inicializarlo:
    Descarga el SDK

Configura la instancia de Cloud SQL

Para crear y configurar una instancia de Cloud SQL, sigue estos pasos:

  1. Crea una instancia de Cloud SQL de segunda generación.
  2. Si aún no lo has hecho, configura 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 conexión de la instancia:
    gcloud sql instances describe [INSTANCE_NAME]
    

    Por ejemplo:

    connectionName: project1:us-central1:instance1
    

    También encontrarás 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.

Configura el entorno local

Tras la implementación, tu aplicación utiliza el proxy de Cloud SQL integrado en el entorno de ejecución de App Engine para comunicarse con tu instancia de Cloud SQL. Sin embargo, para probar tu aplicación de manera local, debes instalar y utilizar 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 utilizar 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:
      chmod +x cloud_sql_proxy
      

    macOS de 32 bits

    1. Descarga el proxy:
      curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.386
      
    2. Haz que el proxy sea ejecutable:
      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…". Cámbiale el nombre 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…". Cámbiale el nombre 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:

    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 que aparece en la página Detalles de la instancia.

      Por ejemplo: myinstance:us-central1:myproject.

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

      Algunas strings posibles de invocación de proxy son:

      • Si utilizas 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, mediante un servidor de base de datos local.
      • Si utilizas 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> &
        

      Si deseas más información sobre las opciones de proxy, consulta Opciones para autenticar el proxy y Opciones de especificación de instancias.

    Sockets Unix

    1. Si utilizas 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 residirán los sockets:
      sudo mkdir /cloudsql; sudo chmod 777 /cloudsql
    3. Si utilizas una cuenta de servicio para autenticar el proxy, debes agregar en la máquina de tu cliente 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.

      Algunas strings posibles de invocación de proxy son:

      • Si utilizas 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 utilizas 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.

      Si deseas más información sobre las opciones de proxy, consulta Opciones para autenticar el proxy y Opciones de especificación de instancias.

  4. Para utilizar el cliente de administración, puedes instalar una copia local y conectarte mediante el proxy o 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 una dirección 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 muestra proporcionado:

    export SQL_USER=[YOUR_SQL_USER]
    export SQL_PASSWORD=[YOUR_SQL_PASSWORD]
    export SQL_DATABASE=[YOUR_SQL_DATABASE]
    npm install
    

    Según la configuración predeterminada, la app intenta conectarse a través de los sockets TCP cuando la ejecutas de forma local. Si configuraste el proxy para que utilice sockets Unix, configura esta variable de entorno adicional:

    export INSTANCE_CONNECTION_NAME=[YOUR_INSTANCE_CONNECTION_NAME]
    

    Estas variables de entorno se utilizan para crear la conexión:

    const config = {
      user: process.env.SQL_USER,
      password: process.env.SQL_PASSWORD,
      database: process.env.SQL_DATABASE,
    };
    
    if (
      process.env.INSTANCE_CONNECTION_NAME &&
      process.env.NODE_ENV === 'production'
    ) {
      config.socketPath = `/cloudsql/${process.env.INSTANCE_CONNECTION_NAME}`;
    }
    
    // Connect to the database
    const knex = Knex({
      client: 'mysql',
      connection: config,
    });

  2. Para permitir que la app se conecte a tu instancia de Cloud SQL durante la implementación, agrega las variables de usuario, contraseña, base de datos y nombre de conexión de la instancia de Cloud SQL a las variables correspondientes del entorno en el archivo app.standard.yaml. La aplicación implementada se conectará a través de los sockets Unix.

    # The following env variables may contain sensitive information that grants
    # anyone access to your database. Do not add this file to your source control.
    env_variables:
      SQL_USER: YOUR_SQL_USER
      SQL_PASSWORD: YOUR_SQL_PASSWORD
      SQL_DATABASE: YOUR_SQL_DATABASE
      # e.g. my-awesome-project:us-central1:my-cloud-sql-instance
      INSTANCE_CONNECTION_NAME: YOUR_INSTANCE_CONNECTION_NAME
  3. Agrega una biblioteca cliente MySQL de Node.js al package.json de la aplicación. Por ejemplo, el código de muestra proporcionado utiliza Knex.js con el paquete mysql como controlador:

    "dependencies": {
      "express": "4.16.4",
      "knex": "0.16.3",
      "mysql": "2.16.0",
      "prompt": "1.0.0"
    },

Ejecuta el código de muestra

En la muestra de server.js a continuación, se crea un registro de visitas en una instancia de Cloud SQL.

Antes de ejecutar la muestra, ejecuta createTables.js para crear las tablas necesarias y asegurarte de que la base de datos esté configurada de forma correcta:

const Knex = require('knex');
const prompt = require('prompt');

const FIELDS = ['user', 'password', 'database'];

prompt.start();

// Prompt the user for connection details
prompt.get(FIELDS, (err, config) => {
  if (err) {
    console.error(err);
    return;
  }

  // Connect to the database
  const knex = Knex({client: 'mysql', connection: config});

  // Create the "visits" table
  knex.schema
    .createTable('visits', table => {
      table.increments();
      table.timestamp('timestamp');
      table.string('userIp');
    })
    .then(() => {
      console.log(`Successfully created 'visits' table.`);
      return knex.destroy();
    })
    .catch(err => {
      console.error(`Failed to create 'visits' table:`, err);
      if (knex) {
        knex.destroy();
      }
    });
});
const express = require('express');
const Knex = require('knex');
const crypto = require('crypto');

const app = express();
app.enable('trust proxy');

const knex = connect();

function connect() {
  const config = {
    user: process.env.SQL_USER,
    password: process.env.SQL_PASSWORD,
    database: process.env.SQL_DATABASE,
  };

  if (
    process.env.INSTANCE_CONNECTION_NAME &&
    process.env.NODE_ENV === 'production'
  ) {
    config.socketPath = `/cloudsql/${process.env.INSTANCE_CONNECTION_NAME}`;
  }

  // Connect to the database
  const knex = Knex({
    client: 'mysql',
    connection: config,
  });

  return knex;
}

/**
 * Insert a visit record into the database.
 *
 * @param {object} knex The Knex connection object.
 * @param {object} visit The visit record to insert.
 * @returns {Promise}
 */
function insertVisit(knex, visit) {
  return knex('visits').insert(visit);
}

/**
 * Retrieve the latest 10 visit records from the database.
 *
 * @param {object} knex The Knex connection object.
 * @returns {Promise}
 */
function getVisits(knex) {
  return knex
    .select('timestamp', 'userIp')
    .from('visits')
    .orderBy('timestamp', 'desc')
    .limit(10)
    .then(results => {
      return results.map(
        visit => `Time: ${visit.timestamp}, AddrHash: ${visit.userIp}`
      );
    });
}

app.get('/', (req, res, next) => {
  // Create a visit record to be stored in the database
  const visit = {
    timestamp: new Date(),
    // Store a hash of the visitor's ip address
    userIp: crypto
      .createHash('sha256')
      .update(req.ip)
      .digest('hex')
      .substr(0, 7),
  };

  insertVisit(knex, visit)
    // Query the last 10 visits from the database.
    .then(() => getVisits(knex))
    .then(visits => {
      res
        .status(200)
        .set('Content-Type', 'text/plain')
        .send(`Last 10 visits:\n${visits.join('\n')}`)
        .end();
    })
    .catch(err => {
      next(err);
    });
});

const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
  console.log(`App listening on port ${PORT}`);
  console.log('Press Ctrl+C to quit.');
});

Implementa y realiza pruebas

  1. Para probar tu aplicación de manera local:

    npm start
    
  2. Después de la prueba local, implementa tu app en App Engine:

    gcloud app deploy app.standard.yaml
    

  3. Ejecuta el comando a continuación para iniciar el navegador y ver la app 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 utilizar una cuenta de servicio para permitir que la aplicación de App Engine acceda a Cloud SQL.

Esta cuenta de servicio representa tu aplicación de App Engine y se genera 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 Configura el 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. La cuenta de servicio de App Engine predeterminada recibe 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 continuar a la página Configura el entorno local.

    Las funciones Cloud SQL Client, Cloud SQL Editor y Cloud SQL Admin, y las funciones del proyecto heredadas Editor y Owner 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 la de lector).

    O bien, puedes seleccionar Proyecto > Editor para utilizar la función básica de editor, pero esta función requiere 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 debes ver que la cuenta de servicio aparece con la función especificada.

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

Enviar comentarios sobre...

Documentación del entorno estándar de App Engine para Node.js