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

MySQL   |  PostgreSQL   |  SQL Server

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 te ayuda a configurar, mantener, controlar y administrar tus 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 frameworks populares 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 a pedido.

Configura una instancia de Cloud SQL

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

   Habilita la API

2. Crea una instancia de Cloud SQL para PostgreSQL.

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

Configura el entorno estándar de 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, sigue estos pasos:

• Asegúrate de que la instancia creada anteriormente tenga una dirección IP pública. Puedes verificarlo en la página Descripción general de tu instancia en Google Cloud Console. Si necesitas agregar una, consulta la página Configura IP públicas para obtener instrucciones.
• Obtén el INSTANCE_CONNECTION_NAME de tu instancia. Puedes encontrarlo en la página Descripción general de la instancia en Google Cloud Console o mediante la ejecución del 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 (opción recomendada)
    • 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 la sección sobre cómo asignar funciones a cuentas de servicio.

  De forma predeterminada, tu app autorizará las conexiones mediante una cuenta de servicio de App Engine. La identidad de la cuenta de servicio tiene el formato [e-mail].

  Si la cuenta de servicio de autorización pertenece a un proyecto distinto que la instancia de Cloud SQL, se deberán agregar los permisos de IAM y de 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 que creaste antes tenga una dirección IP privada. Si necesitas agregar una, consulta la página sobre cómo configurar IP privadas para obtener instrucciones.
2. Crea un conector de Acceso a VPC sin servidores en la misma red de VPC en la que se encuentra tu instancia de Cloud SQL.

A menos que uses la VPC compartida, un conector debe estar en el mismo proyecto y región que el recurso que lo usa, pero puede enviar tráfico a recursos en diferentes regiones.

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 es compatible con las redes heredadas.

3. Conéctate mediante la IP privada y el puerto 5432 de tu instancia.

Conéctate a Cloud SQL

Después de configurar el entorno estándar de App Engine, puedes conectarte a tu instancia de Cloud SQL.

IP pública (predeterminada)

Para las rutas de IP públicas, el entorno estándar de App Engine proporciona encriptación y conexiones mediante el proxy de autorización de Cloud SQL a través de sockets Unix.

Conéctate con sockets Unix

Una vez que el servicio esté configurado de forma correcta, puedes conectarlo al socket del dominio Unix de la instancia de Cloud SQL al que se accede a través del sistema de archivos del entorno en la siguiente ruta de acceso: /cloudsql/INSTANCE_CONNECTION_NAME.

Se puede encontrar al objeto INSTANCE_CONNECTION_NAME en la página on the Descripción general de la instancia en Google Cloud Console o mediante la ejecución del siguiente comando:

gcloud sql instances describe [INSTANCE_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.

Nota: El estándar de PostgreSQL requiere un sufijo .s.PGSQL.5432 en la ruta del socket. Algunas bibliotecas aplican este sufijo de forma automática, pero otras requieren que especifiques la ruta del socket de la siguiente manera: /cloudsql/INSTANCE_CONNECTION_NAME/.s.PGSQL.5432.

Advertencia: Los sistemas operativos basados en Linux tienen una longitud máxima de ruta del socket de 108 caracteres. Si la longitud total de la ruta excede este límite, no podrás conectarte con un socket desde el entorno estándar de App Engine.

Python

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

cloud-sql/postgres/sqlalchemy/main.py

Ver en GitHub

# Remember - storing secrets in plaintext is potentially unsafe. Consider using
# something like https://cloud.google.com/secret-manager/docs/overview to help keep
# secrets secret.
db_user = os.environ["DB_USER"]
db_pass = os.environ["DB_PASS"]
db_name = os.environ["DB_NAME"]
db_socket_dir = os.environ.get("DB_SOCKET_DIR", "/cloudsql")
cloud_sql_connection_name = os.environ["CLOUD_SQL_CONNECTION_NAME"]

pool = sqlalchemy.create_engine(

    # Equivalent URL:
    # postgresql+pg8000://<db_user>:<db_pass>@/<db_name>
    #                         ?unix_sock=<socket_path>/<cloud_sql_instance_name>/.s.PGSQL.5432
    sqlalchemy.engine.url.URL.create(
        drivername="postgresql+pg8000",
        username=db_user,  # e.g. "my-database-user"
        password=db_pass,  # e.g. "my-database-password"
        database=db_name,  # e.g. "my-database-name"
        query={
            "unix_sock": "{}/{}/.s.PGSQL.5432".format(
                db_socket_dir,  # e.g. "/cloudsql"
                cloud_sql_connection_name)  # i.e "<PROJECT-NAME>:<INSTANCE-REGION>:<INSTANCE-NAME>"
        }
    ),
    **db_config
)

Java

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

cloud-sql/postgres/servlet/src/main/java/com/example/cloudsql/ConnectionPoolContextListener.java

Ver en GitHub

// Note: For Java users, the Cloud SQL JDBC Socket Factory can provide authenticated connections
// which is preferred to using the Cloud SQL Proxy with Unix sockets.
// See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.

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

// The following URL is equivalent to setting the config options below:
// jdbc:postgresql:///<DB_NAME>?cloudSqlInstance=<CLOUD_SQL_CONNECTION_NAME>&
// socketFactory=com.google.cloud.sql.postgres.SocketFactory&user=<DB_USER>&password=<DB_PASS>
// See the link below for more info on building a JDBC URL for the Cloud SQL JDBC Socket Factory
// https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory#creating-the-jdbc-url

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

config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.postgres.SocketFactory");
config.addDataSourceProperty("cloudSqlInstance", CLOUD_SQL_CONNECTION_NAME);

// The ipTypes argument can be used to specify a comma delimited list of preferred IP types
// for connecting to a Cloud SQL instance. The argument ipTypes=PRIVATE will force the
// SocketFactory to connect with an instance's associated private IP.
config.addDataSourceProperty("ipTypes", "PUBLIC,PRIVATE");

// ... 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 el archivo README en GitHub.

cloud-sql/postgres/knex/server.js

Ver en GitHub

const createUnixSocketPool = async config => {
  const dbSocketPath = process.env.DB_SOCKET_PATH || '/cloudsql';

  // Establish a connection to the database
  return Knex({
    client: 'pg',
    connection: {
      user: process.env.DB_USER, // e.g. 'my-user'
      password: process.env.DB_PASS, // e.g. 'my-user-password'
      database: process.env.DB_NAME, // e.g. 'my-database'
      host: `${dbSocketPath}/${process.env.CLOUD_SQL_CONNECTION_NAME}`,
    },
    // ... Specify additional properties here.
    ...config,
  });
};

C#

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

cloud-sql/postgres/Startup.cs

Ver en GitHub

// Equivalent connection string:
// "Server=<dbSocketDir>/<INSTANCE_CONNECTION_NAME>;Uid=<DB_USER>;Pwd=<DB_PASS>;Database=<DB_NAME>"
String dbSocketDir = Environment.GetEnvironmentVariable("DB_SOCKET_PATH") ?? "/cloudsql";
String instanceConnectionName = Environment.GetEnvironmentVariable("INSTANCE_CONNECTION_NAME");
var connectionString = new NpgsqlConnectionStringBuilder()
{
    // The Cloud SQL proxy provides encryption between the proxy and instance.
    SslMode = SslMode.Disable,
    // Remember - storing secrets in plain text is potentially unsafe. Consider using
    // something like https://cloud.google.com/secret-manager/docs/overview to help keep
    // secrets secret.
    Host = String.Format("{0}/{1}", dbSocketDir, instanceConnectionName),
    Username = Environment.GetEnvironmentVariable("DB_USER"), // e.g. 'my-db-user
    Password = Environment.GetEnvironmentVariable("DB_PASS"), // e.g. 'my-db-password'
    Database = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'
};
connectionString.Pooling = true;
// Specify additional properties here.
return connectionString;

Comienza a usarlo

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

cloudsql/postgres/database-sql/cloudsql.go

Ver en GitHub

var (
	dbUser                 = mustGetenv("DB_USER")                  // e.g. 'my-db-user'
	dbPwd                  = mustGetenv("DB_PASS")                  // e.g. 'my-db-password'
	instanceConnectionName = mustGetenv("INSTANCE_CONNECTION_NAME") // e.g. 'project:region:instance'
	dbName                 = mustGetenv("DB_NAME")                  // e.g. 'my-database'
)

socketDir, isSet := os.LookupEnv("DB_SOCKET_DIR")
if !isSet {
	socketDir = "/cloudsql"
}

dbURI := fmt.Sprintf("user=%s password=%s database=%s host=%s/%s", dbUser, dbPwd, dbName, socketDir, instanceConnectionName)

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

// ...

return dbPool, nil

Ruby

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

cloud-sql/postgres/activerecord/config/database.yml

Ver en GitHub

production:
  adapter: postgresql
  # Configure additional properties here.
  username: <%= ENV["DB_USER"] %>  # e.g. "my-database-user"
  password: <%= ENV["DB_PASS"] %> # e.g. "my-database-password"
  database: <%= ENV.fetch("DB_NAME") { "vote_production" } %>
  # If connecting via unix domain socket, specify the socket path as host
  host:  "<%= ENV.fetch("DB_SOCKET_DIR") { '/cloudsql' } %>/<%= ENV["INSTANCE_CONNECTION_NAME"] %>"

PHP

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

cloud_sql/postgres/pdo/src/DBInitializer.php

Ver en GitHub

// $username = 'your_db_user';
// $password = 'yoursupersecretpassword';
// $dbName = 'your_db_name';
// $connectionName = getenv("CLOUD_SQL_CONNECTION_NAME");
// $socketDir = getenv('DB_SOCKET_DIR') ?: '/cloudsql';

// Connect using UNIX sockets
$dsn = sprintf(
    'pgsql:dbname=%s;host=%s/%s',
    $dbName,
    $socketDir,
    $connectionName
);

// Connect to the database.
$conn = new PDO($dsn, $username, $password, $connConfig);

IP privada

Para las rutas IP privadas, tu aplicación se conectará directamente a la instancia a través del Acceso a VPC sin servidores. En este método, se usa TCP para conectarse directamente a la instancia de Cloud SQL sin usar el proxy de autenticación de Cloud SQL.

Conéctate con TCP

Conéctate directamente con la dirección IP privada y el puerto 5432 de la instancia.

Python

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

cloud-sql/postgres/sqlalchemy/main.py

Ver en GitHub

# Remember - storing secrets in plaintext is potentially unsafe. Consider using
# something like https://cloud.google.com/secret-manager/docs/overview to help keep
# secrets secret.
db_user = os.environ["DB_USER"]
db_pass = os.environ["DB_PASS"]
db_name = os.environ["DB_NAME"]
db_host = os.environ["DB_HOST"]

# Extract host and port from db_host
host_args = db_host.split(":")
db_hostname, db_port = host_args[0], int(host_args[1])

pool = sqlalchemy.create_engine(
    # Equivalent URL:
    # postgresql+pg8000://<db_user>:<db_pass>@<db_host>:<db_port>/<db_name>
    sqlalchemy.engine.url.URL.create(
        drivername="postgresql+pg8000",
        username=db_user,  # e.g. "my-database-user"
        password=db_pass,  # e.g. "my-database-password"
        host=db_hostname,  # e.g. "127.0.0.1"
        port=db_port,  # e.g. 5432
        database=db_name  # e.g. "my-database-name"
    ),
    **db_config
)

Java

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

Nota:

• CLOUD_SQL_CONNECTION_NAME debe representarse como <MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME>
• Con el argumento ipTypes=PRIVATE, se forzará a SocketFactory a la conexión con la IP privada asociada de una instancia
• Consulta los requisitos de la versión de fábrica de los sockets de JDBC para el archivo pom.xml aquí.

cloud-sql/postgres/servlet/src/main/java/com/example/cloudsql/ConnectionPoolContextListener.java

Ver en GitHub

// Note: For Java users, the Cloud SQL JDBC Socket Factory can provide authenticated connections
// which is preferred to using the Cloud SQL Proxy with Unix sockets.
// See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.

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

// The following URL is equivalent to setting the config options below:
// jdbc:postgresql:///<DB_NAME>?cloudSqlInstance=<CLOUD_SQL_CONNECTION_NAME>&
// socketFactory=com.google.cloud.sql.postgres.SocketFactory&user=<DB_USER>&password=<DB_PASS>
// See the link below for more info on building a JDBC URL for the Cloud SQL JDBC Socket Factory
// https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory#creating-the-jdbc-url

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

config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.postgres.SocketFactory");
config.addDataSourceProperty("cloudSqlInstance", CLOUD_SQL_CONNECTION_NAME);

// The ipTypes argument can be used to specify a comma delimited list of preferred IP types
// for connecting to a Cloud SQL instance. The argument ipTypes=PRIVATE will force the
// SocketFactory to connect with an instance's associated private IP.
config.addDataSourceProperty("ipTypes", "PUBLIC,PRIVATE");

// ... 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 el archivo README en GitHub.

cloud-sql/postgres/knex/server.js

Ver en GitHub

const createTcpPool = async config => {
  // Extract host and port from socket address
  const dbSocketAddr = process.env.DB_HOST.split(':'); // e.g. '127.0.0.1:5432'

  // Establish a connection to the database
  return Knex({
    client: 'pg',
    connection: {
      user: process.env.DB_USER, // e.g. 'my-user'
      password: process.env.DB_PASS, // e.g. 'my-user-password'
      database: process.env.DB_NAME, // e.g. 'my-database'
      host: dbSocketAddr[0], // e.g. '127.0.0.1'
      port: dbSocketAddr[1], // e.g. '5432'
    },
    // ... Specify additional properties here.
    ...config,
  });
};

Comienza a usarlo

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

cloudsql/postgres/database-sql/cloudsql.go

Ver en GitHub

var (
	dbUser    = mustGetenv("DB_USER") // e.g. 'my-db-user'
	dbPwd     = mustGetenv("DB_PASS") // e.g. 'my-db-password'
	dbTCPHost = mustGetenv("DB_HOST") // e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
	dbPort    = mustGetenv("DB_PORT") // e.g. '5432'
	dbName    = mustGetenv("DB_NAME") // e.g. 'my-database'
)

dbURI := fmt.Sprintf("host=%s user=%s password=%s port=%s database=%s", dbTCPHost, dbUser, dbPwd, dbPort, dbName)

// ...

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

// ...

return dbPool, nil

C#

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

cloud-sql/postgres/Startup.cs

Ver en GitHub

            // Equivalent connection string:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<DB_HOST>;Database=<DB_NAME>;"
            var connectionString = new NpgsqlConnectionStringBuilder()
            {
                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = SslMode.Disable,

                // Remember - storing secrets in plain text is potentially unsafe. Consider using
                // something like https://cloud.google.com/secret-manager/docs/overview to help keep
                // secrets secret.
                Host = Environment.GetEnvironmentVariable("DB_HOST"),     // e.g. '127.0.0.1'
                // Set Host to 'cloudsql' when deploying to App Engine Flexible environment
                Username = Environment.GetEnvironmentVariable("DB_USER"), // e.g. 'my-db-user'
                Password = Environment.GetEnvironmentVariable("DB_PASS"), // e.g. 'my-db-password'
                Database = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;

Ruby

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

cloud-sql/postgres/activerecord/config/database.yml

Ver en GitHub

development:
  adapter: postgresql
  # Configure additional properties here.
  username: <%= ENV["DB_USER"] %>  # e.g. "my-database-user"
  password: <%= ENV["DB_PASS"] %> # e.g. "my-database-password"
  database: <%= ENV.fetch("DB_NAME") { "vote_development" } %>
  host: <%= ENV.fetch("DB_HOST") { "127.0.0.1" }%> # '172.17.0.1' if deployed to GAE Flex
  port: <%= ENV.fetch("DB_PORT")  { 5432 }%>

PHP

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

cloud_sql/postgres/pdo/src/DBInitializer.php

Ver en GitHub

// $username = 'your_db_user';
// $password = 'yoursupersecretpassword';
// $dbName = 'your_db_name';
// $dbHost = "127.0.0.1";

// Connect using TCP
$dsn = sprintf('pgsql:dbname=%s;host=%s', $dbName, $dbHost);

// Connect to the database
$conn = new PDO($dsn, $username, $password, $connConfig);

Prácticas recomendadas y más información

Puedes usar el Proxy de autenticación de Cloud SQL cuando pruebes tu aplicación de forma local. Consulta la guía de inicio rápido para usar el proxy de autenticación de Cloud SQL a fin de obtener instrucciones detalladas.

Grupos de conexiones

Es posible que las conexiones a bases de datos subyacentes se interrumpan debido al mismo servidor de la base de datos o a la infraestructura subyacente. Para mitigar este problema, te recomendamos que uses una biblioteca cliente que admita grupos de conexiones y reconexiones automáticas.

Límites de conexión

Cada instancia de App Engine que se ejecuta en un entorno estándar no puede tener más de 100 conexiones simultáneas en una instancia. En el caso de las apps en PHP 5.5, el límite es de 60 conexiones simultáneas. Este límite se aplica por instancia de aplicación. Esto significa que cada instancia de la aplicación de App Engine puede tener esa cantidad de conexiones a la base de datos. A medida que aumenta la escala, puede aumentar el total de conexiones por implementación. Si quieres obtener más información, consulta la sección Elementos de escalamiento.

Puedes limitar la cantidad máxima de conexiones de cada instancia mediante un grupo de conexiones. Para obtener ejemplos más detallados sobre cómo limitar la cantidad de conexiones, consulta la página Administra conexiones de bases de datos.

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 del entorno estándar de App Engine.

Límites de cuota de la API

App Engine proporciona un mecanismo que se conecta mediante el proxy de autenticación de Cloud SQL, que usa la API de Cloud SQL. Los límites de cuota de la API se aplican al proxy de Cloud SQL. La cuota de la API de Cloud SQL Admin usada es aproximadamente dos veces la cantidad de instancias de Cloud SQL configuradas por la cantidad de instancias de App Engine de un servicio particular implementado a la vez. Las aplicaciones de App Engine también están sujetas a las cuotas y los límites adicionales que se describen en la página Cuotas de App Engine.