Acerca de las opciones de conexión

Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Esta página proporciona una descripción general de las formas en que puede conectarse a su instancia de Cloud SQL y describe las opciones de autenticación y autorización disponibles.

Descripción general

Al considerar cómo conectarse a su instancia de Cloud SQL, hay muchas opciones a tener en cuenta, entre ellas:

• ¿Quiere que su instancia de Cloud SQL sea accesible desde Internet, se mantenga privada dentro de una red de nube privada virtual (VPC) o sea accesible tanto pública como privadamente?
• ¿Está planeando escribir su propio código de conexión o conectarse utilizando herramientas disponibles públicamente, como Cloud SQL Auth Proxy o un cliente sqlcmd ?
• ¿Quieres requerir cifrado a través de SSL/TLS o permitir tráfico sin cifrar?

En las siguientes secciones, analizamos las opciones que ofrece Cloud SQL para conectarse, autorizar y autenticarse en su base de datos.

• Cómo conectarse : qué ruta de red utiliza para llegar a su instancia:
  • Una dirección IP interna, solo para VPC ( privada ).
  • Una dirección IP externa, accesible a través de Internet ( pública ).
• Cómo autorizar : qué conexiones están autorizadas y tienen permiso para conectarse a su instancia de Cloud SQL:
  • Bibliotecas de conector Cloud SQL Auth Proxy y Cloud SQL para Java y Python: proporcionan acceso basado en IAM.
  • Certificados SSL/TLS autogestionados: solo permiten conexiones basadas en claves públicas específicas.
  • Redes autorizadas: una lista de direcciones IP permitidas para conectarse.
• Cómo autenticarse : el método para iniciar sesión en su base de datos.
  • Autenticación de base de datos incorporada: inicie sesión con un nombre de usuario y una contraseña configurados en el motor de base de datos.

Utilice la siguiente información para decidir qué opciones de conexión, autorización y autenticación funcionan mejor para usted.

Antes de empezar

Otorgar acceso a una aplicación no habilita automáticamente una cuenta de usuario de base de datos para conectarse a la instancia. Para poder conectarse a una instancia, debe tener una cuenta de usuario de base de datos con la que pueda conectarse. Para instancias nuevas, esto significa que debe haber configurado la cuenta de usuario predeterminada. Para obtener más información, consulte Administrar usuarios con autenticación integrada .

Cómo conectarse a Cloud SQL

Las conexiones a bases de datos consumen recursos del servidor y de la aplicación que se conecta. Utilice siempre buenas prácticas de gestión de conexiones para minimizar el impacto de su aplicación y reducir la probabilidad de superar los límites de conexión de Cloud SQL. Para obtener más información, consulte Administrar conexiones a bases de datos .

IP pública y privada

En Cloud SQL, una IP pública significa que la instancia es accesible a través de la red pública de internet. Por el contrario, las instancias que usan solo una IP privada no son accesibles a través de la red pública de internet, sino a través de una nube virtual privada (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).

Puede usar esta dirección para conectarse desde otros recursos con acceso a la VPC. Las conexiones mediante IP privada suelen ofrecer menor latencia y vectores de ataque limitados, ya que no requieren internet. Opcionalmente, puede exigir que todas las conexiones usen el proxy de Cloud SQL o certificados SSL autogestionados .

Se recomienda configurar la instancia con una IP privada al conectarse desde un cliente a un recurso con acceso a una VPC. Para obtener más información sobre qué recursos pueden usar una IP privada, consulte Requisitos para IP privada .

Para las rutas de IP privadas, los siguientes servicios y aplicaciones se conectan directamente a su instancia a través del acceso a VPC sin servidor :

• Entorno estándar de App Engine
• Entorno flexible de App Engine
• Funciones de Cloud Run
• Carrera en la nube

Obtenga más información sobre el uso de IP privada con Cloud SQL

Para obtener instrucciones sobre cómo agregar una IP privada a su instancia, consulte una de las siguientes opciones:

• Configuración de conectividad IP privada .
• Conectarse a una instancia mediante Conexión de servicio privado

IP pública

Una IP pública es una dirección IPv4 disponible externamente en la internet pública. Esta dirección puede recibir conexiones de dispositivos tanto dentro como fuera de la red de Google, incluso desde ubicaciones como tu casa u oficina.

Para ayudar a mantener su instancia segura, cualquier conexión a una instancia de Cloud SQL que use una IP pública debe estar autorizada mediante el proxy de autenticación de Cloud SQL o redes autorizadas .

Es mejor configurar su instancia con una IP pública cuando se conecta desde un cliente que no cumple con los requisitos para una VPC.

Para obtener instrucciones sobre cómo agregar una IP pública a su instancia, consulte Configurar la conectividad de IP pública .

Para obtener información sobre cómo conectar un cliente sqlcmd a una instancia de Cloud SQL mediante IP pública, consulte Conectarse mediante un cliente de base de datos .

Opciones de conexión para instancias

Esta sección contiene las funciones compatibles con Cloud SQL para conectarse a instancias. También incluye las opciones de conexión compatibles para crear, desactivar y habilitar instancias.

Funciones compatibles

En la siguiente tabla se enumeran las características que Cloud SQL admite para conectarse a instancias mediante conexiones privadas.

Opciones de conexión para crear instancias

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

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

• Acceso a servicios privados : conéctese a instancias de Cloud SQL desde una única red VPC
• Conexión de servicio privado : conéctese a instancias de Cloud SQL desde múltiples redes VPC que pertenecen a diferentes grupos, equipos, proyectos u organizaciones

Si desea que su instancia acceda a conexiones de clientes tanto dentro como fuera de ella Google Cloudla red de a través de Internet público, luego configure la IP pública para la instancia.

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

• Acceso solo a servicios privados
• Servicio privado Solo conexión
• Solo IP pública
• Tanto el acceso a servicios privados como la Conexión a Servicios Privados
• Acceso tanto a servicios IP públicos como privados
• IP pública, acceso a servicios privados y conexión de servicio privado

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 e IP pública
• IP pública en una instancia con IP pública, acceso a servicios privados y conexión de servicio privado
• Conexión de servicio privado en una instancia con Conexión de servicio privado y acceso a servicios privados
• Conexión de servicio privado en una instancia con Conexión de servicio privado, acceso a servicios privados e IP pública

Habilitar opciones de conexión

Cloud SQL permite habilitar las siguientes opciones de conexión para instancias:

• Acceso a servicios privados en una instancia con IP pública únicamente
• Servicio privado Conéctese a una instancia con acceso solo a servicios privados
• Conexión de servicio privado en una instancia con acceso a servicios privados e IP pública
• IP pública en una instancia con acceso solo a servicios privados

Limitaciones

• No se admite la creación de una instancia con IP pública y conexión de servicio privada.
• No se admite la desactivación del acceso a servicios privados en una instancia con acceso a servicios privados y Conexión de servicio privado.
• No se admite la desactivación del acceso a servicios privados en una instancia con acceso a servicios privados y una IP pública.
• Si tiene una instancia que usa solo una IP pública, no es posible habilitar el acceso a servicios privados ni la Conexión a Servicios Privados simultáneamente. Primero, habilite el acceso a servicios privados y luego la Conexión a Servicios Privados.
• La inclusión en listas blancas basadas en IP mediante el uso de redes autorizadas no es compatible con instancias que tienen habilitada la Conexión de servicio privado.

Cómo autorizarse en Cloud SQL

Conectores de lenguaje de Cloud SQL

Los conectores de lenguaje de Cloud SQL son bibliotecas cliente que proporcionan cifrado y autorización de IAM al conectarse a una instancia de Cloud SQL. Cloud SQL recomienda usar los conectores de lenguaje de Cloud SQL para conectarse a su instancia de Cloud SQL en lugar de otras opciones de conexión.

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

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

Proxy de autenticación de Cloud SQL

El proxy de autenticación de Cloud SQL le permite autorizar y proteger sus conexiones mediante permisos de administración de identidades y accesos (IAM) . Valida las conexiones mediante credenciales de usuario o cuenta de servicio y encapsula la conexión en una capa SSL/TLS autorizada para una instancia de Cloud SQL. Para obtener más información sobre el funcionamiento del proxy de autenticación de Cloud SQL, consulte Acerca del 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étodo más seguro.

El proxy de autenticación de Cloud SQL es una biblioteca de código abierto distribuida como un binario ejecutable. Actúa como un servidor intermediario que escucha las conexiones entrantes, las encapsula en SSL/TLS y las transfiere a una instancia de Cloud SQL.

Algunos entornos ofrecen un mecanismo de conexión mediante el proxy de autenticación de Cloud SQL. Para obtener instrucciones sobre cómo conectarse mediante estos entornos, consulte uno de los siguientes:

• Conexión desde Cloud Run
• Conexión desde funciones de Cloud Run
• Conexión desde el entorno estándar de App Engine
• Conexión desde el entorno flexible de App Engine
• Conexión desde Google Kubernetes Engine

Certificados SSL/TLS autogestionados

En lugar de usar el proxy de autenticación de Cloud SQL para cifrar las conexiones, es posible configurar certificados SSL/TLS cliente/servidor específicos para cada instancia de Cloud SQL. Estos certificados se utilizan para validar la conexión entre el cliente y el servidor y para cifrar las conexiones entre ellos.

Se recomienda encarecidamente usar certificados SSL/TLS autogestionados para proporcionar cifrado cuando no se utiliza el proxy de autenticación de Cloud SQL. De lo contrario, sus datos se transmitirán de forma insegura y podrían ser interceptados o inspeccionados por terceros.

Para comenzar a utilizar certificados SSL/TLS autoadministrados, consulte Autorización con certificados SSL/TLS .

Redes autorizadas

A menos que se utilice el proxy de autenticación de Cloud SQL, las conexiones a la dirección IP pública de una instancia solo se permiten si provienen de una red autorizada . Las redes autorizadas son direcciones IP o rangos que el usuario ha especificado con permiso para conectarse.

Para comenzar a utilizar redes autorizadas, consulte Autorización con redes autorizadas .

Cómo autenticarse en Cloud SQL

La autenticación proporciona control de acceso verificando la identidad del usuario. Para los usuarios finales, la autenticación se logra al introducir sus credenciales (nombre de usuario y contraseña). Para las aplicaciones, la autenticación se logra al asignar las credenciales del usuario a una cuenta de servicio.

Cloud SQL utiliza la autenticación integrada de la base de datos, que se autentica mediante nombre de usuario y contraseña. Para obtener más información, consulte "Crear y administrar usuarios de SQL Server" .

Herramientas para conectarse a Cloud SQL

La siguiente tabla contiene algunas opciones para conectarse a Cloud SQL:

Ejemplos de código

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

./cloud-sql-proxy INSTANCE_CONNECTION_NAME &

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

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);
  }
}

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);
};

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
}

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;
        }
    }
}

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 }%> 

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 tiene problemas para conectarse, consulte las siguientes páginas para obtener ayuda para depurar o encontrar soluciones a problemas conocidos:

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

¿Qué sigue?

• Descubra cómo conectarse con el inicio rápido de Cloud SQL para sqlserver .
• Conozca las mejores prácticas para administrar conexiones de bases de datos .
• Obtenga más información sobre la autenticación de la base de datos IAM .
• Obtenga información sobre cómo conectarse mediante un cliente sqlcmd desde una máquina local o Compute Engine .
• Obtenga información sobre cómo configurar la conectividad IP .
• Obtenga más información sobre el proxy de autenticación de Cloud SQL .
• Conozca las opciones de soporte .