Conéctate mediante conectores de lenguaje de Cloud SQL

Los conectores de Cloud SQL son bibliotecas que proporcionan encriptación y autorización basada en Identity and Access Management (IAM) cuando se conectan a una instancia de Cloud SQL. No pueden proporcionar una ruta de red a una instancia de Cloud SQL, si aún no hay una.

Otras formas de conectarse a una instancia de Cloud SQL son el uso de un cliente de base de datos o el proxy de autenticación de Cloud SQL. Consulta la página Opciones de conexión para obtener más información sobre cómo conectarte a una instancia de Cloud SQL.

En esta página, se analizan los siguientes conectores de Cloud SQL:

  • El conector de Java de Cloud SQL
  • El conector de Python de Cloud SQL (Abrir en Colab)
  • El conector de Go de Cloud SQL
  • El conector de Node.js para Cloud SQL

Ventajas

El uso de un conector de Cloud SQL proporciona los siguientes beneficios:

  • Autorización de IAM: Usa permisos de IAM para controlar quién o qué puede conectarse a tus instancias de Cloud SQL.
  • Conveniencia: Quita el requisito de administrar certificados SSL, configurar reglas de firewall o habilitar redes autorizadas.

Antes de comenzar

  • Habilita la API de Administrador de Cloud SQL

    Habilita la API

  • Crea una instancia de Cloud SQL y configura el usuario predeterminado.

    Para obtener más información sobre la creación de instancias, consulta Crea instancias.

    Para obtener más información sobre la configuración del usuario predeterminado, consulta Configura la contraseña de la cuenta de usuario predeterminada.

  • Configura las funciones y permisos necesarios para conectarte a una instancia de Cloud SQL.

Crear

Java

El conector de Java de Cloud SQL es una biblioteca que proporciona encriptación y autorización basadas en IAM cuando se conecta a una instancia de Cloud SQL. No puede proporcionar una ruta de red a una instancia de Cloud SQL si aún no hay una.

Instalación

Si deseas obtener instrucciones para desarrollar y usar los controladores para JDBC y R2DBC con el conector de Java de Cloud SQL, consulta los siguientes vínculos:

Para ver ejemplos de esta biblioteca que se usa en el contexto de una aplicación, consulta estas aplicaciones de muestra.

Authentication

Esta biblioteca usa las credenciales predeterminadas de la aplicación para autenticar la conexión con el servidor de Cloud SQL.

Para activar las credenciales de forma local, usa el siguiente comando de gcloud:

    gcloud auth application-default login

Conéctate con IntelliJ

Para conectar IntelliJ a tu instancia de Cloud SQL, debes agregar la biblioteca como un JAR con dependencias en la sección Archivos adicionales en la página de configuración del controlador. Por ejemplo, los archivos de fat JAR precompilados se pueden encontrar en la página Versiones del conector de Java de Cloud SQL para este propósito.

Python

El conector de Python de Cloud SQL es una biblioteca que se puede usar junto con un controlador de base de datos para permitir a los usuarios con permisos suficientes conectarse a una base de datos de Cloud SQL sin tener que incluir IPs en la lista de entidades permitidas ni administrar certificados SSL de forma manual.

Si deseas ver ejemplos interactivos sobre el uso del conector de Python de Cloud SQL, abre el notebook de conectores de Python de Cloud SQL.

El controlador compatible actual para SQL Server es pytds.

Instalación

Para instalar la actualización más reciente, sigue estas instrucciones.

Authentication

Esta biblioteca usa las credenciales predeterminadas de la aplicación para autenticar la conexión con el servidor de Cloud SQL.

Para activar las credenciales de forma local, usa el siguiente comando de gcloud:

    gcloud auth application-default login

Go

El conector de Cloud SQL para Go es un conector de Cloud SQL diseñado para usarse con el lenguaje Go. Para mejorar la seguridad, este conector usa la encriptación sólida TLS 1.3 autenticada de forma manual entre el conector del cliente y el proxy del servidor, independientemente del protocolo de base de datos.

Instalación

Puedes instalar este repositorio con go get:

    go get cloud.google.com/go/cloudsqlconn

Node.js

El conector de Node.js es una biblioteca diseñada para usarse con el entorno de ejecución de Node.js que te permite conectarte de manera segura a tu instancia de Cloud SQL.

Instalación

Puedes instalar la biblioteca con npm install:

    npm install @google-cloud/cloud-sql-connector

Uso

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 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 is equivalent to setting the config options below:
    // jdbc:sqlserver://;user=<DB_USER>;password=<DB_PASS>;databaseName=<DB_NAME>;
    // socketFactoryClass=com.google.cloud.sql.sqlserver.SocketFactory;
    // socketFactoryConstructorArg=<INSTANCE_CONNECTION_NAME>

    // 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
        .setDataSourceClassName("com.microsoft.sqlserver.jdbc.SQLServerDataSource");
    config.setUsername(DB_USER); // e.g. "root", "sqlserver"
    config.setPassword(DB_PASS); // e.g. "my-password"
    config.addDataSourceProperty("databaseName", DB_NAME);

    config.addDataSourceProperty("socketFactoryClass",
        "com.google.cloud.sql.sqlserver.SocketFactory");
    config.addDataSourceProperty("socketFactoryConstructorArg", INSTANCE_CONNECTION_NAME);

    // The Java Connector provides SSL encryption, so it should be disabled
    // at the driver level.
    config.addDataSourceProperty("encrypt", "false");

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

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

Python

Consulta Cómo usar este conector para obtener instrucciones detalladas sobre cómo usar la biblioteca. Consulta el ejemplo de código de prueba de conexión en GitHub.

import os

from google.cloud.sql.connector import Connector, IPTypes
import pytds

import sqlalchemy

def connect_with_connector() -> sqlalchemy.engine.base.Engine:
    """
    Initializes a connection pool for a Cloud SQL instance of SQL Server.

    Uses the Cloud SQL Python Connector package.
    """
    # 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.

    instance_connection_name = os.environ[
        "INSTANCE_CONNECTION_NAME"
    ]  # e.g. 'project:region:instance'
    db_user = os.environ.get("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'

    ip_type = IPTypes.PRIVATE if os.environ.get("PRIVATE_IP") else IPTypes.PUBLIC

    connector = Connector(ip_type)

    connect_args = {}
    # If your SQL Server instance requires SSL, you need to download the CA
    # certificate for your instance and include cafile={path to downloaded
    # certificate} and validate_host=False. This is a workaround for a known issue.
    if os.environ.get("DB_ROOT_CERT"):  # e.g. '/path/to/my/server-ca.pem'
        connect_args = {
            "cafile": os.environ["DB_ROOT_CERT"],
            "validate_host": False,
        }

    def getconn() -> pytds.Connection:
        conn = connector.connect(
            instance_connection_name,
            "pytds",
            user=db_user,
            password=db_pass,
            db=db_name,
            **connect_args
        )
        return conn

    pool = sqlalchemy.create_engine(
        "mssql+pytds://",
        creator=getconn,
        # ...
    )
    return pool

Go

Consulta Uso para obtener instrucciones detalladas sobre el uso de la biblioteca. Consulta el ejemplo de código de prueba de conexión en GitHub.

package cloudsql

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

	"cloud.google.com/go/cloudsqlconn"
	mssql "github.com/denisenkom/go-mssqldb"
)

type csqlDialer struct {
	dialer     *cloudsqlconn.Dialer
	connName   string
	usePrivate bool
}

// DialContext adheres to the mssql.Dialer interface.
func (c *csqlDialer) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
	var opts []cloudsqlconn.DialOption
	if c.usePrivate {
		opts = append(opts, cloudsqlconn.WithPrivateIP())
	}
	return c.dialer.Dial(ctx, c.connName, opts...)
}

func connectWithConnector() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Fatal Error in connect_connector.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'
		dbName                 = mustGetenv("DB_NAME")                  // e.g. 'my-database'
		instanceConnectionName = mustGetenv("INSTANCE_CONNECTION_NAME") // e.g. 'project:region:instance'
		usePrivate             = os.Getenv("PRIVATE_IP")
	)

	dbURI := fmt.Sprintf("user id=%s;password=%s;database=%s;", dbUser, dbPwd, dbName)
	c, err := mssql.NewConnector(dbURI)
	if err != nil {
		return nil, fmt.Errorf("mssql.NewConnector: %w", err)
	}
	dialer, err := cloudsqlconn.NewDialer(context.Background())
	if err != nil {
		return nil, fmt.Errorf("cloudsqlconn.NewDailer: %w", err)
	}
	c.Dialer = &csqlDialer{
		dialer:     dialer,
		connName:   instanceConnectionName,
		usePrivate: usePrivate != "",
	}

	dbPool := sql.OpenDB(c)
	if err != nil {
		return nil, fmt.Errorf("sql.Open: %w", err)
	}
	return dbPool, nil
}

Node.js

Para obtener instrucciones detalladas sobre el uso de la biblioteca, consulta Uso.

const {Connection} = require('tedious');
const {Connector} = require('@google-cloud/cloud-sql-connector');

// In case the PRIVATE_IP environment variable is defined then we set
// the ipType=PRIVATE for the new connector instance, otherwise defaults
// to public ip type.
const getIpType = () =>
  process.env.PRIVATE_IP === '1' || process.env.PRIVATE_IP === 'true'
    ? 'PRIVATE'
    : 'PUBLIC';

// connectWithConnector initializes a TCP connection
// to a Cloud SQL instance of SQL Server.
const connectWithConnector = 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 connector = new Connector();
  const clientOpts = await connector.getTediousOptions({
    instanceConnectionName: process.env.INSTANCE_CONNECTION_NAME,
    ipType: getIpType(),
  });
  const dbConfig = {
    // Please note that the `server` property here is not used and is only
    // defined due to a bug in the tedious driver
    // (ref: https://github.com/tediousjs/tedious/issues/1541)
    // With that in mind, do not try to change this value since it will have no
    // impact in how the connector works, this sample will be updated to remove
    // this property declaration as soon as the tedious driver bug is fixed
    server: '0.0.0.0', // e.g. '127.0.0.1'
    authentication: {
      type: 'default',
      options: {
        userName: process.env.DB_USER, // e.g. 'my-db-user'
        password: process.env.DB_PASS, // e.g. 'my-db-password'
      },
    },
    options: {
      ...clientOpts,
      // Please note that the `port` property here is not used and is only
      // defined due to a bug in the tedious driver
      // (ref: https://github.com/tediousjs/tedious/issues/1541)
      // With that in mind, do not try to change this value since it will have
      // no impact in how the connector works, this sample will be updated to
      // remove this property declaration as soon as the tedious driver bug is
      // fixed
      port: 9999,
      database: process.env.DB_NAME, // e.g. 'my-database'
      useColumnNames: true,
    },
    // ... Specify additional properties here.
    ...config,
  };

  // Establish a connection to the database.
  return new Connection(dbConfig);
};

Solución de problemas

Versiones del controlador

Asegúrate de usar la versión más reciente de los conectores de Cloud SQL y el controlador de base de datos para evitar incompatibilidades. Algunas versiones anteriores de controladores no son compatibles.

Rutas de conexión

Los conectores de Cloud SQL proporcionan autorización para las conexiones, pero no proporcionan rutas de acceso nuevas a la conectividad. Por ejemplo, para conectarte a una instancia de Cloud SQL mediante una dirección IP privada, tu aplicación ya debe tener acceso a VPC.

Depurar problemas de conexión

Para obtener más ayuda sobre problemas de conexión, consulta las páginas Soluciona problemas y Depura problemas de conexión.

¿Qué sigue?