Conéctate desde el entorno estándar de App Engine a Cloud SQL

En esta página, se muestran información y ejemplos para conectarse a una instancia de Cloud SQL desde un servicio que se ejecuta en el entorno estándar de App Engine.

Cloud SQL es un servicio de base de datos completamente administrado que facilita la configuración, el mantenimiento, y la administración de las bases de datos relacionales en la nube.

App Engine es una plataforma sin servidores completamente administrada para desarrollar y alojar aplicaciones web a gran escala. Puedes elegir entre varios lenguajes, bibliotecas y framework para desarrollar tu aplicación. Luego, deja que App Engine se encargue del aprovisionamiento de servidores y del escalamiento de las instancias de tu aplicación según demanda.

Configura una instancia de Cloud SQL

  1. Habilita la API de Administrador de Cloud SQL en el proyecto desde el que te conectas, si aún no lo hiciste:

    Habilita la API

  2. Crea una instancia de Cloud SQL para MySQL

    De forma predeterminada, Cloud SQL asigna una dirección IP pública a una instancia nueva. También tienes la opción de asignar una dirección IP privada. Para obtener más información sobre las opciones de conectividad, consulta la página Descripción general de las conexiones.

Configura App Engine

Los pasos para configurar el entorno estándar de App Engine dependen del tipo de dirección IP que asignaste a tu instancia de Cloud SQL.

IP pública (predeterminada)

Para configurar el entorno estándar de App Engine a fin de habilitar las conexiones a una instancia de Cloud SQL mediante una IP pública:

  • Asegúrate de que la instancia creada anteriormente tenga una dirección IP pública. Puedes verificar esto en la página Descripción general de tu instancia en Google Cloud Console. Si necesitas agregar una, consulta la página de Configuración de IP pública para obtener instrucciones.
  • Obtén INSTANCE_CONNECTION_NAME para tu instancia. Puedes encontrarlo en la página Descripción general de tu instancia en Google Cloud Console o si ejecutas el siguiente comando: gcloud sql instances describe [INSTANCE_NAME].
  • Asegúrate de que la cuenta de servicio que usa tu app para autenticar llamadas a Cloud SQL tenga las funciones y permisos de Cloud SQL adecuados.
    • La cuenta de servicio para tu servicio necesita una de las siguientes funciones de IAM:
      • Cloud SQL Client (recomendado)
      • Cloud SQL Editor
      • Cloud SQL Admin
      O bien, puedes asignar los siguientes permisos de IAM de forma manual:
      • cloudsql.instances.connect
      • cloudsql.instances.get
      Para obtener instrucciones detalladas sobre cómo agregar funciones de IAM a una cuenta de servicio, consulta Otorga funciones a cuentas de servicio.

    De forma predeterminada, tu app autorizará tus conexiones con la cuenta de servicio del entorno estándar de App Engine. La cuenta de servicio tiene el formato service-PROJECT_NUMBER@gae-api-prod.google.com.iam.gserviceaccount.com.

    Si la cuenta de servicio de autorización pertenece a un proyecto distinto al de la instancia de Cloud SQL, se deberán agregar los permisos de IAM y la API de Administrador de Cloud SQL para ambos proyectos.

IP privada

El conector de acceso a VPC sin servidores controla la comunicación con la red de VPC. Para conectarte directamente con una IP privada, debes hacer lo siguiente:

  1. Asegúrate de que la instancia de Cloud SQL creada anteriormente tenga una dirección IP privada. Si necesitas agregar una, consulta la página Configura una IP privada para obtener instrucciones.
  2. Crea y configura un conector de acceso a VPC sin servidores en la misma red de VPC que tu instancia de Cloud SQL.
  3. El conector debe estar en el mismo proyecto y la misma región que los recursos que lo usan, pero puede enviar tráfico a recursos de regiones diferentes.

    El acceso a VPC sin servidores admite la comunicación con las redes de VPC conectadas a través de Cloud VPN y el intercambio de tráfico entre redes de VPC.

    El acceso a VPC sin servidores no admite redes heredadas ni VPC compartida.

  4. Conéctate mediante la IP privada y el puerto 3306 de tu instancia según las instrucciones de la siguiente sección.

Conéctate a Cloud SQL

Después de configurar el entorno estándar de App Engine, puedes conectarte a tu instancia de Cloud SQL. App Engine proporciona un mecanismo que se conecta mediante el proxy de Cloud SQL.

IP pública (predeterminada)

Conéctate con Sockets Unix

Una vez que el servicio esté configurado de forma correcta, puedes conectarlo al socket de dominio Unix de la instancia de Cloud SQL con este formato: /cloudsql/INSTANCE_CONNECTION_NAME.

Estas conexiones se encriptan de forma automática sin ninguna configuración adicional. Las muestras de código que aparecen a continuación son extractos de ejemplos más completos que aparecen en el sitio de GitHub. Haz clic en View on GitHub para obtener más información.

Python

Para ver este fragmento en el contexto de una aplicación web, consulta README en GitHub.

# The SQLAlchemy engine will help manage interactions, including automatically
# managing a pool of connections to your database
db = sqlalchemy.create_engine(
    # Equivalent URL:
    # mysql+pymysql://<db_user>:<db_pass>@/<db_name>?unix_socket=/cloudsql/<cloud_sql_instance_name>
    sqlalchemy.engine.url.URL(
        drivername="mysql+pymysql",
        username=db_user,
        password=db_pass,
        database=db_name,
        query={"unix_socket": "/cloudsql/{}".format(cloud_sql_connection_name)},
    ),
    # ... Specify additional properties here.
    # ...
)

Java

Para ver este fragmento en el contexto de una aplicación web, consulta README en GitHub.

// The configuration object specifies behaviors for the connection pool.
HikariConfig config = new HikariConfig();

// Configure which instance and what database user to connect with.
config.setJdbcUrl(String.format("jdbc:mysql:///%s", DB_NAME));
config.setUsername(DB_USER); // e.g. "root", "postgres"
config.setPassword(DB_PASS); // e.g. "my-password"

// For Java users, the Cloud SQL JDBC Socket Factory can provide authenticated connections.
// See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.
config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.mysql.SocketFactory");
config.addDataSourceProperty("cloudSqlInstance", CLOUD_SQL_CONNECTION_NAME);

// ... Specify additional connection properties here.
// ...

// Initialize the connection pool using the configuration object.
DataSource pool = new HikariDataSource(config);

Node.js

Para ver este fragmento en el contexto de una aplicación web, consulta README en GitHub.

const createUnixSocketPool = async (config) => {
  const dbSocketPath = process.env.DB_SOCKET_PATH || "/cloudsql"

  // Establish a connection to the database
  return await mysql.createPool({
    user: process.env.DB_USER, // e.g. 'my-db-user'
    password: process.env.DB_PASS, // e.g. 'my-db-password'
    database: process.env.DB_NAME, // e.g. 'my-database'
    // If connecting via unix domain socket, specify the path
    socketPath: `${dbSocketPath}/${process.env.INSTANCE_CONNECTION_NAME}`,
    // Specify additional properties here.
    ...config
  });
}

PHP

Para ver este fragmento en el contexto de una aplicación web, consulta README en GitHub.

// // $username = 'your_db_user';
// // $password = 'yoursupersecretpassword';
// // $dbName = 'your_db_name';
// // $cloud_sql_connection_name = getenv("CLOUD_SQL_CONNECTION_NAME");
// // $hostname = "127.0.0.1"; // Only used in TCP mode.

if ($hostname) {
    // Connect using TCP
    $dsn = sprintf('mysql:dbname=%s;host=%s', $dbName, $hostname);
} else {
    // Connect using UNIX sockets
    $dsn = sprintf(
        'mysql:dbname=%s;unix_socket=/cloudsql/%s',
        $dbName,
        $cloud_sql_connection_name
    );
}

// Connect to the database.
// Here we set the connection timeout to five seconds and ask PDO to
// throw an exception if any errors occur.
$conn = new PDO($dsn, $username, $password, [
    PDO::ATTR_TIMEOUT => 5,
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
]);

C#

Para ver este fragmento en el contexto de una aplicación web, consulta README en GitHub.

var connectionString = new MySqlConnectionStringBuilder(
    Configuration["CloudSql:ConnectionString"])
// ConnectionString is set in appsettings.json formatted as follows
// depending upon where your app is running:
// Running Locally ConnectionString:
// "Uid=aspnetuser;Pwd=;Host=127.0.0.1;Database=votes"
// Cloud Run ConnectionString:
// "Server=/cloudsql/your-project-id:us-central1:instance-name;Database=votes;User=;Password=;Protocol=unix"
// App Engine ConnectionString:
// "Uid=aspnetuser;Pwd=;Host=cloudsql;Database=votes"
{
    // Connecting to a local proxy that does not support ssl.
    SslMode = MySqlSslMode.None,
};
connectionString.Pooling = true;
// ...
DbConnection connection =
    new MySqlConnection(connectionString.ConnectionString);

Ruby

Para ver este fragmento en el contexto de una aplicación web, consulta README en GitHub.

development:
  adapter: mysql2
  # ...
  username: <%= ENV["MYSQL_USERNAME"] %>
  password: <%= ENV["MYSQL_PASSWORD"] %>
  database: <%= ENV.fetch("MYSQL_DATABASE") { "vote_development" } %>
  socket:   "/cloudsql/<%= ENV["INSTANCE_CONNECTION_NAME"] %>"

Go

Para ver este fragmento en el contexto de una aplicación web, consulta README en GitHub.

var (
	dbUser                 = mustGetenv("DB_USER")
	dbPwd                  = mustGetenv("DB_PASS")
	instanceConnectionName = mustGetenv("INSTANCE_CONNECTION_NAME")
	dbName                 = mustGetenv("DB_NAME")
)

var dbURI string
dbURI = fmt.Sprintf("%s:%s@unix(/cloudsql/%s)/%s", dbUser, dbPwd, instanceConnectionName, dbName)

// dbPool is the pool of database connections.
dbPool, err := sql.Open("mysql", dbURI)
if err != nil {
	return nil, fmt.Errorf("sql.Open: %v", err)
}

// ...

return dbPool, nil

IP privada

Conexión con TCP

Conéctate directamente mediante la dirección IP privada y el puerto 3306 de tu instancia.

Prácticas recomendadas y más información

Puedes usar el proxy de Cloud SQL cuando pruebes tu aplicación de forma local. Consulta Inicio rápido para usar el proxy para pruebas locales si quieres obtener instrucciones detalladas.

Grupos de conexiones

Las conexiones a bases de datos subyacentes pueden interrumpirse, ya sea por el servidor de la base de datos o por la infraestructura subyacente. Para mitigar este problema, te recomendamos que uses una biblioteca cliente que admita grupos de conexiones y reconexiones automáticas.

Para obtener ejemplos más detallados sobre el uso de los grupos de conexiones, consulta Administra conexiones de bases de datos.

Límites de conexión

Cloud SQL impone un límite máximo en las conexiones simultáneas. Estos límites pueden variar según el motor de base de datos que se eligió (consulta Cuotas y límites de Cloud SQL).

App Engine tiene la capacidad de crear más instancias de forma automática a medida que aumenta la carga, lo que puede causar que excedas estos límites. Para evitar este problema, limita la cantidad máxima de instancias de App Engine. Si deseas obtener más información, consulta Elementos de escalamiento.

Cada instancia de App Engine ejecutada en un entorno estándar no puede tener más de 100 conexiones simultáneas. En el caso de las apps en PHP 5.5, el límite es de 60 conexiones simultáneas.

Las aplicaciones de App Engine están sujetas a los límites de tiempo de las solicitudes según el uso y el entorno. Para obtener más información, consulta cómo se administran las instancias en entornos estándar y flexibles de App Engine.

Las aplicaciones de App Engine también están sujetas a las cuotas y los límites adicionales de App Engine que se describen en la página Cuotas de App Engine.

Límites de cuota de la API

App Engine proporciona un mecanismo que se conecta mediante el proxy de Cloud SQL, que usa la API de Administrador de Cloud SQL. Los límites de cuota de la API se aplican al proxy de Cloud SQL.