Acerca de las opciones de conexión

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 psql?
  • ¿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.

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:

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 sqlcmd a una instancia de Cloud SQL mediante una IP pública, consulta Conéctate mediante un cliente de base de datos.

Cómo autorizar Cloud SQL

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:

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

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.

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 Crea y administra usuarios de SQL Server.

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
CLI de gcloud
Conectores de lenguaje de Cloud SQL
Cloud Shell
Cloud Code
Conéctate con herramientas de administración de bases de datos de terceros
SQL Server Management Studio
Explorador de objetos de SSMS
Visual Studio

Muestras de código

Puedes conectarte al proxy de autenticación de Cloud SQL desde cualquier lenguaje que permita conectarte a un socket de 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 SQL Server."""
    # 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. 1433

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

    return pool

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í. 


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

public class TcpConnectionPoolFactory 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 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();

    // Configure which instance and what database user to connect with.
    config.setJdbcUrl(
        String.format("jdbc:sqlserver://%s:%s;databaseName=%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "sqlserver"
    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 mssql = require('mssql');

// createTcpPool initializes a TCP connection pool for a Cloud SQL
// instance of SQL Server.
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 = {
    server: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
    port: parseInt(process.env.DB_PORT), // e.g. 1433
    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'
    options: {
      trustServerCertificate: true,
    },
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return mssql.connect(dbConfig);
};

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"
	"strings"

	_ "github.com/denisenkom/go-mssqldb"
)

// connectTCPSocket initializes a TCP connection pool for a Cloud SQL
// instance of SQL Server.
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.\n", 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'
		dbTCPHost = mustGetenv("INSTANCE_HOST") // e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
		dbPort    = mustGetenv("DB_PORT")       // e.g. '1433'
		dbName    = mustGetenv("DB_NAME")       // e.g. 'my-database'
	)

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


	// dbPool is the pool of database connections.
	dbPool, err := sql.Open("sqlserver", 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 Microsoft.Data.SqlClient;
using System;

namespace CloudSql
{
    public class SqlServerTcp
    {
        public static SqlConnectionStringBuilder NewSqlServerTCPConnectionString()
        {
            // Equivalent connection string:
            // "User Id=<DB_USER>;Password=<DB_PASS>;Server=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new SqlConnectionStringBuilder()
            {
                // 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.
                DataSource = 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'
                InitialCatalog = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'

                // The Cloud SQL proxy provides encryption between the proxy and instance
                Encrypt = false,
            };
            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: sqlserver
  # 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") { 1433 }%>

PHP

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

namespace Google\Cloud\Samples\CloudSQL\SQLServer;

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(
                'sqlsrv:server=%s;Database=%s',
                $instanceHost,
                $dbName
            );

            // 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/sqlserver/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:

¿Qué sigue?