Acerca de las conexiones de Cloud SQL

MySQL   |  PostgreSQL   |  SQL Server

En esta página, se proporciona una descripción general de las formas en que puedes conectarte a tu instancia de Cloud SQL y se describen las opciones de autenticación y autorización disponibles.

Descripción general

Cuando consideres cómo conectarte a tu instancia de Cloud SQL, debes tener en cuenta muchas opciones, incluidas las siguientes:

• ¿Quieres que se pueda acceder a tu instancia de Cloud SQL desde Internet, mantenerla privada en una red de nube privada virtual (VPC) o hacer que se pueda acceder a ella de forma pública y privada?
• ¿Planeas escribir tu propio código de conexión o conectarte mediante herramientas disponibles públicamente, como el proxy de autenticación de Cloud SQL o un cliente mysql?
• ¿Quieres solicitar encriptación mediante SSL/TLS o permitir el tráfico sin encriptar?

En las siguientes secciones, analizaremos las opciones que Cloud SQL proporciona para conectar, autorizar y autenticar en tu base de datos.

• Cómo conectarse: Se refiere a qué ruta de red usas para llegar a la instancia:
  • Una dirección IP interna, solo de VPC (privada).
  • Una dirección IP externa, accesible a través de Internet (Pública).
• Cómo autenticar: Se refiere a qué conexiones están autorizadas y pueden conectarse a la instancia de Cloud SQL.
  • El proxy de autenticación de Cloud SQL y las bibliotecas de conectores de Cloud SQL para Java y Python proporcionan acceso basado en IAM.
  • Certificados SSL/TLS autoadministrados: Estos solo permiten conexiones basadas en claves públicas específicas.
  • Redes autorizadas: Una lista de direcciones IP permitidas para conectarse.
• Cómo realizar la autenticación: El método para acceder a tu base de datos.
  • Autenticación de base de datos integrada: Accede con un nombre de usuario o una contraseña configurados en el motor de base de datos.

Usa la siguiente información para decidir qué opciones de conexión, autorización y autenticación te resultan más útiles.

Puedes crear una cuenta para evaluar el rendimiento de Cloud SQL en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para utilizarlos en Cloud SQL a fin de ejecutar, probar e implementar cargas de trabajo. No te cobraremos hasta que actualices.

Regístrate para probar Cloud SQL gratis.

Antes de comenzar

Si se otorga acceso a una aplicación, esto no significa que se habilite de forma automática una cuenta de usuario de base de datos para conectarse a la instancia. Antes de que puedas conectarte a una instancia, debes tener una cuenta de usuario de base de datos con la que te puedas conectar. Para instancias nuevas, debes tener configurada la cuenta de usuario predeterminada. Para obtener más información, consulta Administra usuarios con autenticación integrada.

Cómo conectarse a Cloud SQL

Las conexiones de bases de datos consumen recursos en el servidor y en la aplicación de conexión. Usa siempre prácticas adecuadas de administración de conexión para minimizar el espacio de tu aplicación y reducir la posibilidad de superar los límites de conexión de Cloud SQL. Para obtener más información, consulta la página sobre cómo administrar conexiones de bases de datos.

IP pública y privada

En Cloud SQL, la IP pública significa que se puede acceder a la instancia a través de la Internet pública. Por el contrario, las instancias que usan solo IP privadas no son accesibles a través de la Internet pública, pero se puede acceder a ellas a través de una nube privada virtual (VPC). Las instancias de Cloud SQL pueden tener una dirección IP pública y una privada.

IP privada

Una IP privada es una dirección IPv4 a la que se puede acceder en una nube privada virtual (VPC).

Puedes usar esta dirección para conectarte desde otros recursos con acceso a la VPC. Las conexiones mediante IP privadas suelen proporcionar una latencia más baja y vectores de ataque limitados porque no requieren atravesar Internet. De forma opcional, puedes solicitar que todas las conexiones usen el proxy de Cloud SQL o los certificados SSL autoadministrados.

Es preferible configurar tu instancia con una IP privada cuando te conectas desde un cliente en un recurso con acceso a una VPC. Para obtener más información sobre qué recursos pueden usar una IP privada, consulta Requisitos de IP privada.

En el caso de las rutas de IP privadas, los siguientes servicios y aplicaciones se conectan directamente a tu instancia a través del Acceso a VPC sin servidores:

• Entorno estándar de App Engine
• Entorno flexible de App Engine
• Funciones de Cloud Run
• Cloud Run

Obtén más información sobre el uso de IP privada con Cloud SQL.

A fin de obtener instrucciones para agregar una IP privada a la instancia, consulta una de las siguientes opciones:

• Configura la conectividad de IP privada.
• Conéctate a una instancia mediante Private Service Connect

IP pública

Una IP pública es una dirección IPv4 que está disponible de forma externa en la Internet pública. Esta dirección puede recibir conexiones de dispositivos dentro y fuera de la red de Google, incluso desde ubicaciones como una oficina o tu casa.

Para contribuir a la seguridad de tu instancia, cualquier conexión a una instancia de Cloud SQL mediante una IP pública debe autorizarse mediante el uso del proxy de Cloud SQL o las redes autorizadas.

La configuración de tu instancia con una IP pública es mejor cuando te conectas desde un cliente que no cumple con los requisitos de una VPC.

Si deseas obtener instrucciones para agregar una IP pública a una instancia, consulta Configura la conectividad de IP pública.

Para obtener más información sobre cómo conectar un cliente mysql a una instancia de Cloud SQL mediante una IP pública, consulta Conéctate mediante un cliente de base de datos.

Direcciones IP asignadas de forma dinámica

Algunas aplicaciones necesitan conectarse a tu instancia de Cloud SQL con una dirección IP asignada de forma dinámica o efímera. Este es el caso de las aplicaciones de plataforma como servicio (PaaS), entre otras.

La mejor solución para estas aplicaciones es conectarse mediante el proxy de autenticación de Cloud SQL. Esta solución proporciona el mejor control de acceso para la instancia.

Opciones de conexión para instancias

En esta sección, se incluyen las funciones que admite Cloud SQL para conectarse a instancias. La sección también contiene opciones de conexión compatibles para crear, deactivar y habilitar instancias.

Funciones admitidas

En la siguiente tabla, se enumeran las funciones que admite Cloud SQL para conectarse a instancias mediante conexiones privadas.

Atributo	Instancia con acceso privado a servicios únicamente	Instancia solo con Private Service Connect	Instancia con acceso a servicios privados y Private Service Connect
Conéctate desde varias VPC	No compatible.	Compatible.	Se admite mediante el extremo de Private Service Connect.
Réplicas externas	Compatible.	No compatible.	Se admite mediante el uso de conectividad saliente para el acceso a servicios privados.
Escribe el extremo	Compatible.	No compatible.	Se admite para el acceso a servicios privados.
Cambia la red de VPC asociada para el acceso a servicios privados	Compatible.	No aplicable	No se admite para el acceso a servicios privados porque la instancia tiene habilitado Private Service Connect. No se aplica a Private Service Connect.
Visibilidad de la dirección IP del cliente para Cloud SQL	Compatible.	No compatible.	Se admite mediante el uso de la dirección IP de acceso a servicios privados. No se admite el uso del extremo de Private Service Connect.

Opciones de conexión para crear instancias

Cloud SQL admite configuraciones de IP privada y pública. Puedes elegir las opciones de conexión según los requisitos de tu aplicación.

Puedes configurar una IP privada para mantener la privacidad de tus instancias de Cloud SQL dentro de una red de VPC. Se admiten los siguientes tipos de conexiones privadas:

• Acceso privado a servicios: Conéctate a instancias de Cloud SQL desde una sola red de VPC.
• Private Service Connect: Conéctate a instancias de Cloud SQL desde varias redes de VPC que pertenezcan a organizaciones, grupos, equipos o proyectos diferentes.

Si deseas que tu instancia acceda a conexiones de clientes dentro y fuera de la red de Google Cloud a través de Internet público, configura una IP pública para la instancia.

Cloud SQL admite las siguientes opciones de conexión para crear instancias:

• Acceso privado a servicios únicamente
• Solo Private Service Connect
• Solo IP pública
• Acceso a servicios privados y Private Service Connect
• Acceso a IP pública y servicios privados
• IP pública, acceso a servicios privados y Private Service Connect

Cómo desactivar las opciones de conexión

Cloud SQL admite la desactivación de las siguientes opciones de conexión para las instancias:

• IP pública en una instancia con acceso a servicios privados y IP pública
• IP pública en una instancia con IP pública, acceso a servicios privados y Private Service Connect
• Private Service Connect en una instancia con Private Service Connect y acceso privado a servicios
• Private Service Connect en una instancia con Private Service Connect, acceso a servicios privados y IP pública

Habilita las opciones de conexión

Cloud SQL admite la habilitación de las siguientes opciones de conexión para las instancias:

• Acceso a servicios privados en una instancia con solo IP pública
• Private Service Connect en una instancia con solo acceso a servicios privados
• Private Service Connect en una instancia con acceso a servicios privados y IP pública
• IP pública en una instancia con acceso privado a servicios únicamente

Limitaciones

• No se admite la creación de una instancia con IP pública y Private Service Connect.
• No se admite desactivar el acceso a servicios privados en una instancia con acceso a servicios privados y Private Service Connect.
• No se admite desactivar el acceso a servicios privados en una instancia que tenga acceso a servicios privados y una IP pública.
• Si tienes una instancia que solo usa IP pública, no se admite habilitar el acceso privado a servicios y Private Service Connect juntos. Primero, habilita el acceso privado a servicios y, luego, habilita Private Service Connect.
• No se admite la lista de entidades permitidas basadas en IP mediante redes autorizadas para las instancias que tienen Private Service Connect habilitado.

Cómo autorizar en Cloud SQL

Nota: Estas opciones solo te permiten controlar qué conexiones pueden conectarse a tu instancia. Aún debes proporcionar un nombre de usuario y una contraseña para la base de datos a fin de autenticarte con el motor de base de datos.

Conectores de lenguaje de Cloud SQL

Los conectores de lenguaje de Cloud SQL son bibliotecas cliente que proporcionan encriptación y autorización de IAM cuando se conectan a una instancia de Cloud SQL. Cloud SQL recomienda usar los conectores de lenguaje de Cloud SQL para conectarte a tu instancia de Cloud SQL a través de otras opciones de conexión.

Puedes usar estas bibliotecas directamente desde su lenguaje de programación compatible. Proporcionan la misma autenticación que el proxy de autenticación de Cloud SQL sin la necesidad de un proceso externo. Esto proporciona una seguridad mejorada y requisitos de configuración reducidos para conectarse a Cloud SQL. Los conectores de lenguaje de Cloud SQL también usan el mismo código cuando se conectan mediante una dirección IP pública o privada.

Para comenzar, consulta Acerca de los conectores de lenguaje de Cloud SQL.

Proxy de Cloud SQL Auth

El proxy de autenticación de Cloud SQL te permite autorizar y proteger tus conexiones mediante los permisos de Identity and Access Management (IAM). El proxy de autenticación de Cloud SQL valida las conexiones mediante credenciales para un usuario o una cuenta de servicio y une la conexión en una capa SSL/TLS autorizada para una instancia de Cloud SQL. Para obtener más detalles sobre cómo funciona el proxy de autenticación de Cloud SQL, consulta Información sobre el proxy de autenticación de Cloud SQL.

El uso del proxy de autenticación de Cloud SQL es el método recomendado para autenticar conexiones a una instancia de Cloud SQL porque es el más seguro.

El proxy de autenticación de Cloud SQL es una biblioteca de código abierto que se distribuye como un objeto binario ejecutable. El proxy de autenticación de Cloud SQL actúa como un servidor intermediario que escucha las conexiones entrantes, las une en SSL/TLS y, luego, las pasa a una instancia de Cloud SQL.

Algunos entornos proporcionan un mecanismo que se conecta mediante el proxy de autenticación de Cloud SQL. A fin de obtener instrucciones para conectarte mediante estos entornos, consulta una de las siguientes páginas:

• Conéctate desde Cloud Run
• Conéctate desde funciones de Cloud Run
• Conéctate desde el entorno estándar de App Engine
• Conéctate desde el entorno flexible de App Engine
• Conéctate desde Google Kubernetes Engine

Certificados SSL/TLS autoadministrados

En lugar de usar el proxy de Cloud SQL Auth para encriptar las conexiones, es posible configurar certificados SSL/TLS de cliente o servidor que sean específicos de una instancia de Cloud SQL. Estos certificados se usan para validar el cliente y el servidor entre sí, y encriptar las conexiones entre ellos.

Se recomienda usar certificados SSL/TLS autoadministrados para proporcionar encriptación cuando no se usa el proxy de Cloud SQL Auth. Si no lo haces, tus datos se transmiten de forma insegura, y un tercero podría interceptarlos o inspeccionarlos.

Para comenzar a usar los certificados SSL/TLS autoadministrados, consulta Autoriza con certificados SSL/TLS.

Redes autorizadas

Nota: Se recomienda usar siempre certificados SSL/TLS autoadministrados cuando se usan redes autorizadas para autenticar conexiones. A menos que esté encriptado, el tráfico será vulnerable a la intercepción por parte de terceros.

A menos que uses el proxy de autenticación de Cloud SQL, las conexiones a la dirección IP pública de una instancia solo se permiten si la conexión proviene de una red autorizada. Las redes autorizadas son direcciones IP o rangos a los que el usuario especificó que tiene permiso para conectarse.

Advertencia: Ten cuidado cuando agregues redes autorizadas. Debido a que todos los dispositivos en una red a menudo comparten la misma dirección IP externa, autorizar una sola dirección puede provocar la autorización de todos los dispositivos en la misma red, en lugar de la autorización de un solo cliente.

Para comenzar a usar las redes autorizadas, consulta Autoriza con redes autorizadas.

Cómo autenticar Cloud SQL

La autenticación proporciona control de acceso mediante la verificación de la identidad de un usuario. Para los usuarios finales, la autenticación se logra cuando el usuario ingresa credenciales (nombre de usuario y contraseña). Para las aplicaciones, la autenticación se logra cuando se asignan las credenciales de un usuario a una cuenta de servicio.

Cloud SQL usa la autenticación integrada de la base de datos que se autentica con un nombre de usuario y una contraseña. Para obtener más información, consulta cómo crear y administrar usuarios de MySQL.

Herramientas para conectarse a Cloud SQL

En la siguiente tabla, se muestran algunas opciones para conectarse a Cloud SQL:

Opción de conexión	Más información
Proxy de Cloud SQL Auth	Acerca del proxy de Cloud SQL Auth Conexión con el proxy de autenticación de Cloud SQL Conéctate con la imagen de Docker del proxy de autenticación de Cloud SQL
CLI de gcloud	gcloud sql connect
Conectores de lenguaje de Cloud SQL	Conéctate mediante conectores de Cloud SQL para Java, Python y Go.
Cloud Shell	Conéctate mediante Cloud Shell
Apps Script	Conexiones externas mediante Apps Script Página de muestra de GitHub de Apps Script
Cloud Code	Conéctate con Cloud Code en el IDE de JetBrains
Conéctate con herramientas de administración de bases de datos de terceros
MySQL Workbench	Conéctate con MySQL Workbench
Toad para MySQL	Cómo conectarse con Toad para MySQL
SQuirreL SQL	Cómo conectarse con SQuirreL SQL
phpMyAdmin	Usa phpMyAdmin con Cloud SQL en App Engine

Muestras de código

Puedes conectarte al proxy de autenticación de Cloud SQL desde cualquier lenguaje que permita conectarte a un socket Unix o TCP. A continuación, se incluyen algunos fragmentos de código de ejemplos completos en GitHub para ayudarte a comprender cómo funcionan juntos en tu aplicación.

Conéctate con TCP

Instrucción de invocación del proxy de autenticación de Cloud SQL:

./cloud-sql-proxy INSTANCE_CONNECTION_NAME &

Python

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

import os

import sqlalchemy


def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    """Initializes a TCP connection pool for a Cloud SQL instance of MySQL."""
    # Note: Saving credentials in environment variables is convenient, but not
    # secure - consider a more secure solution such as
    # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
    # keep secrets safe.
    db_host = os.environ[
        "INSTANCE_HOST"
    ]  # e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
    db_user = os.environ["DB_USER"]  # e.g. 'my-db-user'
    db_pass = os.environ["DB_PASS"]  # e.g. 'my-db-password'
    db_name = os.environ["DB_NAME"]  # e.g. 'my-database'
    db_port = os.environ["DB_PORT"]  # e.g. 3306

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # mysql+pymysql://<db_user>:<db_pass>@<db_host>:<db_port>/<db_name>
        sqlalchemy.engine.url.URL.create(
            drivername="mysql+pymysql",
            username=db_user,
            password=db_pass,
            host=db_host,
            port=db_port,
            database=db_name,
        ),
        # ...
    )
    return pool

Java

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

Nota:

• INSTANCE_CONNECTION_NAME se debe representar 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í.

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class TcpConnectionPoolFactory extends ConnectionPoolFactory {

  // Saving credentials in environment variables is convenient, but not secure - consider a more
  // secure solution such as https://cloud.google.com/secret-manager/ to help keep secrets safe.
  private static final String DB_USER = System.getenv("DB_USER");
  private static final String DB_PASS = System.getenv("DB_PASS");
  private static final String DB_NAME = System.getenv("DB_NAME");

  private static final String INSTANCE_HOST = System.getenv("INSTANCE_HOST");
  private static final String DB_PORT = System.getenv("DB_PORT");


  public static DataSource createConnectionPool() {
    // 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:mysql://<INSTANCE_HOST>:<DB_PORT>/<DB_NAME>?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:mysql://%s:%s/%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "mysql"
    config.setPassword(DB_PASS); // e.g. "my-password"


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

    // Initialize the connection pool using the configuration object.
    return new HikariDataSource(config);
  }
}

Node.js

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

const mysql = require('promise-mysql');
const fs = require('fs');

// createTcpPool initializes a TCP connection pool for a Cloud SQL
// instance of MySQL.
const createTcpPool = async config => {
  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  const dbConfig = {
    host: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
    port: process.env.DB_PORT, // e.g. '3306'
    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'
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return mysql.createPool(dbConfig);
};

Go

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

package cloudsql

import (
	"crypto/tls"
	"crypto/x509"
	"database/sql"
	"errors"
	"fmt"
	"log"
	"os"

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

// connectTCPSocket initializes a TCP connection pool for a Cloud SQL
// instance of MySQL.
func connectTCPSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Fatal Error in connect_tcp.go: %s environment variable not set.", k)
		}
		return v
	}
	// Note: Saving credentials in environment variables is convenient, but not
	// secure - consider a more secure solution such as
	// Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
	// keep secrets safe.
	var (
		dbUser    = mustGetenv("DB_USER")       // e.g. 'my-db-user'
		dbPwd     = mustGetenv("DB_PASS")       // e.g. 'my-db-password'
		dbName    = mustGetenv("DB_NAME")       // e.g. 'my-database'
		dbPort    = mustGetenv("DB_PORT")       // e.g. '3306'
		dbTCPHost = mustGetenv("INSTANCE_HOST") // e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
	)

	dbURI := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true",
		dbUser, dbPwd, dbTCPHost, dbPort, dbName)


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

	// ...

	return dbPool, nil
}

C#

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

using MySql.Data.MySqlClient;
using System;

namespace CloudSql
{
    public class MySqlTcp
    {
        public static MySqlConnectionStringBuilder NewMysqlTCPConnectionString()
        {
            // Equivalent connection string:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new MySqlConnectionStringBuilder()
            {
                // Note: Saving credentials in environment variables is convenient, but not
                // secure - consider a more secure solution such as
                // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
                // keep secrets safe.
                Server = Environment.GetEnvironmentVariable("INSTANCE_HOST"),   // e.g. '127.0.0.1'
                // Set Host to 'cloudsql' when deploying to App Engine Flexible environment
                UserID = 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'

                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = MySqlSslMode.Disabled,
            };
            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.

tcp: &tcp
  adapter: mysql2
  # Configure additional properties here
  # Note: Saving credentials in environment variables is convenient, but not
  # secure - consider a more secure solution such as
  # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  # keep secrets safe.
  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("INSTANCE_HOST") { "127.0.0.1" }%>" # '172.17.0.1' if deployed to GAE Flex
  port: <%= ENV.fetch("DB_PORT") { 3306 }%>

PHP

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

namespace Google\Cloud\Samples\CloudSQL\MySQL;

use PDO;
use PDOException;
use RuntimeException;
use TypeError;

class DatabaseTcp
{
    public static function initTcpDatabaseConnection(): PDO
    {
        try {
            // Note: Saving credentials in environment variables is convenient, but not
            // secure - consider a more secure solution such as
            // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
            // keep secrets safe.
            $username = getenv('DB_USER'); // e.g. 'your_db_user'
            $password = getenv('DB_PASS'); // e.g. 'your_db_password'
            $dbName = getenv('DB_NAME'); // e.g. 'your_db_name'
            $instanceHost = getenv('INSTANCE_HOST'); // e.g. '127.0.0.1' ('172.17.0.1' for GAE Flex)

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

            // Connect to the database
            $conn = new PDO(
                $dsn,
                $username,
                $password,
                # ...
            );
        } catch (TypeError $e) {
            throw new RuntimeException(
                sprintf(
                    'Invalid or missing configuration! Make sure you have set ' .
                        '$username, $password, $dbName, and $instanceHost (for TCP mode). ' .
                        'The PHP error was %s',
                    $e->getMessage()
                ),
                $e->getCode(),
                $e
            );
        } catch (PDOException $e) {
            throw new RuntimeException(
                sprintf(
                    'Could not connect to the Cloud SQL Database. Check that ' .
                        'your username and password are correct, that the Cloud SQL ' .
                        'proxy is running, and that the database exists and is ready ' .
                        'for use. For more assistance, refer to %s. The PDO error was %s',
                    'https://cloud.google.com/sql/docs/mysql/connect-external-app',
                    $e->getMessage()
                ),
                $e->getCode(),
                $e
            );
        }

        return $conn;
    }
}

Conéctate con sockets Unix

Instrucción de invocación del proxy de autenticación de Cloud SQL:

./cloud-sql-proxy --unix-socket /cloudsql INSTANCE_CONNECTION_NAME &

Python

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

import os

import sqlalchemy


def connect_unix_socket() -> sqlalchemy.engine.base.Engine:
    """Initializes a Unix socket connection pool for a Cloud SQL instance of MySQL."""
    # Note: Saving credentials in environment variables is convenient, but not
    # secure - consider a more secure solution such as
    # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
    # keep secrets safe.
    db_user = os.environ["DB_USER"]  # e.g. 'my-database-user'
    db_pass = os.environ["DB_PASS"]  # e.g. 'my-database-password'
    db_name = os.environ["DB_NAME"]  # e.g. 'my-database'
    unix_socket_path = os.environ[
        "INSTANCE_UNIX_SOCKET"
    ]  # e.g. '/cloudsql/project:region:instance'

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # mysql+pymysql://<db_user>:<db_pass>@/<db_name>?unix_socket=<socket_path>/<cloud_sql_instance_name>
        sqlalchemy.engine.url.URL.create(
            drivername="mysql+pymysql",
            username=db_user,
            password=db_pass,
            database=db_name,
            query={"unix_socket": unix_socket_path},
        ),
        # ...
    )
    return pool

Java

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

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class ConnectorConnectionPoolFactory extends ConnectionPoolFactory {

  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  private static final String INSTANCE_CONNECTION_NAME =
      System.getenv("INSTANCE_CONNECTION_NAME");
  private static final String INSTANCE_UNIX_SOCKET = System.getenv("INSTANCE_UNIX_SOCKET");
  private static final String DB_USER = System.getenv("DB_USER");
  private static final String DB_PASS = System.getenv("DB_PASS");
  private static final String DB_NAME = System.getenv("DB_NAME");

  public static DataSource createConnectionPool() {
    // 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:mysql:///<DB_NAME>?cloudSqlInstance=<INSTANCE_CONNECTION_NAME>&
    // socketFactory=com.google.cloud.sql.mysql.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:mysql:///%s", DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "mysql"
    config.setPassword(DB_PASS); // e.g. "my-password"

    config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.mysql.SocketFactory");
    config.addDataSourceProperty("cloudSqlInstance", INSTANCE_CONNECTION_NAME);

    // Unix sockets are not natively supported in Java, so it is necessary to use the Cloud SQL
    // Java Connector to connect. When setting INSTANCE_UNIX_SOCKET, the connector will 
    // call an external package that will enable Unix socket connections.
    // Note: For Java users, the Cloud SQL Java Connector can provide authenticated connections
    // which is usually preferable to using the Cloud SQL Proxy with Unix sockets.
    // See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.
    if (INSTANCE_UNIX_SOCKET != null) {
      config.addDataSourceProperty("unixSocketPath", INSTANCE_UNIX_SOCKET);
    }


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

    // Initialize the connection pool using the configuration object.
    return new HikariDataSource(config);
  }
}

Node.js

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

const mysql = require('promise-mysql');

// createUnixSocketPool initializes a Unix socket connection pool for
// a Cloud SQL instance of MySQL.
const createUnixSocketPool = async config => {
  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  return 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'
    socketPath: process.env.INSTANCE_UNIX_SOCKET, // e.g. '/cloudsql/project:region:instance'
    // Specify additional properties here.
    ...config,
  });
};

C#

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

using MySql.Data.MySqlClient;
using System;

namespace CloudSql
{
    public class MySqlUnix
    {
        public static MySqlConnectionStringBuilder NewMysqlUnixSocketConnectionString()
        {
            // Equivalent connection string:
            // "Server=<INSTANCE_UNIX_SOCKET>;Uid=<DB_USER>;Pwd=<DB_PASS>;Database=<DB_NAME>;Protocol=unix"
            var connectionString = new MySqlConnectionStringBuilder()
            {
                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = MySqlSslMode.Disabled,

                // Note: Saving credentials in environment variables is convenient, but not
                // secure - consider a more secure solution such as
                // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
                // keep secrets safe.
                Server = Environment.GetEnvironmentVariable("INSTANCE_UNIX_SOCKET"), // e.g. '/cloudsql/project:region:instance'
                UserID = 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'
                ConnectionProtocol = MySqlConnectionProtocol.UnixSocket
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Go

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

package cloudsql

import (
	"database/sql"
	"fmt"
	"log"
	"os"

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

// connectUnixSocket initializes a Unix socket connection pool for
// a Cloud SQL instance of MySQL.
func connectUnixSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Fatal Error in connect_unix.go: %s environment variable not set.", k)
		}
		return v
	}
	// Note: Saving credentials in environment variables is convenient, but not
	// secure - consider a more secure solution such as
	// Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
	// keep secrets safe.
	var (
		dbUser         = mustGetenv("DB_USER")              // e.g. 'my-db-user'
		dbPwd          = mustGetenv("DB_PASS")              // e.g. 'my-db-password'
		dbName         = mustGetenv("DB_NAME")              // e.g. 'my-database'
		unixSocketPath = mustGetenv("INSTANCE_UNIX_SOCKET") // e.g. '/cloudsql/project:region:instance'
	)

	dbURI := fmt.Sprintf("%s:%s@unix(%s)/%s?parseTime=true",
		dbUser, dbPwd, unixSocketPath, dbName)

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

	// ...

	return dbPool, nil
}

Ruby

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

unix: &unix
  adapter: mysql2
  # Configure additional properties here.
  # Note: Saving credentials in environment variables is convenient, but not
  # secure - consider a more secure solution such as
  # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  # keep secrets safe.
  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" } %>
  # Specify the Unix socket path as host
  socket: "<%= ENV["INSTANCE_UNIX_SOCKET"] %>"

PHP

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

namespace Google\Cloud\Samples\CloudSQL\MySQL;

use PDO;
use PDOException;
use RuntimeException;
use TypeError;

class DatabaseUnix
{
    public static function initUnixDatabaseConnection(): PDO
    {
        try {
            // Note: Saving credentials in environment variables is convenient, but not
            // secure - consider a more secure solution such as
            // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
            // keep secrets safe.
            $username = getenv('DB_USER'); // e.g. 'your_db_user'
            $password = getenv('DB_PASS'); // e.g. 'your_db_password'
            $dbName = getenv('DB_NAME'); // e.g. 'your_db_name'
            $instanceUnixSocket = getenv('INSTANCE_UNIX_SOCKET'); // e.g. '/cloudsql/project:region:instance'

            // Connect using UNIX sockets
            $dsn = sprintf(
                'mysql:dbname=%s;unix_socket=%s',
                $dbName,
                $instanceUnixSocket
            );

            // Connect to the database.
            $conn = new PDO(
                $dsn,
                $username,
                $password,
                # ...
            );
        } catch (TypeError $e) {
            throw new RuntimeException(
                sprintf(
                    'Invalid or missing configuration! Make sure you have set ' .
                        '$username, $password, $dbName, ' .
                        'and $instanceUnixSocket (for UNIX socket mode). ' .
                        'The PHP error was %s',
                    $e->getMessage()
                ),
                (int) $e->getCode(),
                $e
            );
        } catch (PDOException $e) {
            throw new RuntimeException(
                sprintf(
                    'Could not connect to the Cloud SQL Database. Check that ' .
                        'your username and password are correct, that the Cloud SQL ' .
                        'proxy is running, and that the database exists and is ready ' .
                        'for use. For more assistance, refer to %s. The PDO error was %s',
                    'https://cloud.google.com/sql/docs/mysql/connect-external-app',
                    $e->getMessage()
                ),
                (int) $e->getCode(),
                $e
            );
        }

        return $conn;
    }
}

Solucionar problemas

Si tienes problemas de conexión, revisa las siguientes páginas para obtener ayuda con la depuración o la solución de problemas conocidos:

• Depura problemas de conexión
• Errores de conectividad conocidos
• Soluciona problemas de conexión del proxy de autenticación de Cloud SQL
• Problemas comunes de conexión

¿Qué sigue?

• Obtén información para conectarte con la Guía de inicio rápido de Cloud SQL para MySQL.
• Conoce las prácticas recomendadas para administrar conexiones de bases de datos.
• Obtén información sobre la autenticación de la base de datos de IAM.
• Obtén más información para conectarte mediante un cliente sqlcmd desde una máquina local o Compute Engine.
• Obtén más información sobre cómo configurar la conectividad IP.
• Obtén más información sobre cómo conectarse mediante otras herramientas de MySQL.
• Obtén más información sobre conectores de MySQL.
• Obtén más información sobre el proxy de autenticación de Cloud SQL.
• Obtén información sobre opciones de asistencia.