Sobre as opções de conexão

Nesta página, você encontra uma visão geral das maneiras de se conectar à instância do Cloud SQL e a descrição das opções de autenticação e autorização disponíveis.

Visão geral

Ao se conectar à instância do Cloud SQL, há muitas escolhas a serem consideradas, incluindo:

  • Você quer que sua instância do Cloud SQL seja acessível pela Internet, mantida em uma rede de nuvem privada virtual (VPC) ou que seja acessível como pública e privada?
  • Você planeja escrever seu próprio código de conexão ou se conectar usando ferramentas disponíveis publicamente, como o proxy de autenticação do Cloud SQL ou um cliente sqlcmd?
  • Você quer exigir criptografia usando SSL/TLS ou permitir tráfego não criptografado?

Nas seções a seguir, discutiremos as opções que o Cloud SQL oferece para conectar, autorizar e autenticar no banco de dados.

  • Como se conectar: qual caminho de rede você usa para acessar a instância:
    • Um endereço IP interno somente VPC (Privado).
    • Um endereço IP externo acessível pela Internet (Público).
  • Como autorizar: quais conexões são autorizadas e têm permissão para se conectar à instância do Cloud SQL:
    • As bibliotecas de proxy de autenticação do Cloud SQL e de conectores do Cloud SQL para Java e Python fornecem acesso com base no IAM.
    • Certificados SSL/TLS autogerenciados: permitem apenas conexões com base em chaves públicas específicas.
    • Redes autorizadas: uma lista de endereços IP com permissão para se conectar.
  • Como autenticar: o método para fazer login no seu banco de dados.
    • Autenticação de banco de dados integrada: faça login com um nome de usuário/senha definido no mecanismo de banco de dados.

Use as informações a seguir para decidir quais opções de conexão, autorização e autenticação funcionam melhor para você.

Antes de começar

A concessão de acesso a um aplicativo não permite automaticamente que uma conta de usuário do banco de dados se conecte à instância. Para se conectar a uma instância, é necessário ter uma conta de usuário do banco de dados com que possa se conectar. Para novas instâncias, isso significa que é preciso configurar a conta de usuário padrão. Para mais informações, consulte Gerenciar usuários com a autenticação integrada.

Como se conectar ao Cloud SQL

As conexões do banco de dados consomem recursos no servidor e no aplicativo conectado. Sempre use boas práticas de gerenciamento de conexões para minimizar o espaço ocupado pelo seu aplicativo e reduzir a probabilidade de exceder os limites de conexão do Cloud SQL. Para mais informações, consulte Como gerenciar conexões de banco de dados.

IP público e privado

No Cloud SQL, IP público significa que a instância é acessível pela Internet pública. Por outro lado, as instâncias que usam apenas IP privado não são acessíveis pela Internet pública, mas podem ser acessadas por uma nuvem privada virtual (VPC, na sigla em inglês). As instâncias do Cloud SQL podem ter um endereço IP público e um privado.

IP privado

O IP privado é um endereço IPv4 acessível em uma nuvem privada virtual (VPC).

É possível usar esse endereço para se conectar a partir de outros recursos com acesso à VPC. As conexões por IP privado geralmente fornecem menor latência e vetores de ataque limitados porque não exigem a passagem da Internet. Outra opção é exigir que todas as conexões usem o proxy do Cloud SQL ou os certificados de SSL autogerenciados.

É preferível configurar sua instância com um IP privado ao se conectar a partir de um cliente em um recurso com acesso a uma VPC. Para mais informações sobre quais recursos podem usar IP privado, consulte Requisitos para IP privado.

Para caminhos de IP privado, os seguintes serviços e aplicativos se conectam diretamente à instância pelo acesso VPC sem servidor:

  • Ambiente padrão do App Engine
  • Ambiente flexível do App Engine
  • Funções do Cloud Run
  • Cloud Run

Saiba mais sobre como usar IP privado com o Cloud SQL

Para instruções sobre como adicionar um IP privado à instância, consulte uma das seguintes opções:

IP público

Um IP público é um endereço IPv4 disponível externamente na Internet pública. Esse endereço pode receber conexões de dispositivos dentro e fora da rede do Google, inclusive de locais como sua casa ou seu escritório.

Para ajudar a manter as instâncias seguras, todas as conexões com uma instância do Cloud SQL que usam um IP público precisam ser autorizadas com o proxy de autenticação do Cloud SQL ou redes autorizadas.

A configuração da instância com um IP público é melhor quando você se conecta a partir de um cliente que não atende aos requisitos de uma VPC.

Para instruções sobre como adicionar um IP público à instância, consulte Como configurar a conectividade de IP público.

Para informações sobre como conectar um cliente sqlcmd a uma instância do Cloud SQL usando um IP público, consulte Como se conectar usando um cliente de banco de dados.

Opções de conexão para instâncias

Esta seção contém recursos compatíveis com o Cloud SQL para conexão a instâncias. A seção também contém opções de conexão com suporte para criar, desativar e ativar instâncias.

Recursos compatíveis

A tabela a seguir lista os recursos compatíveis com o Cloud SQL para conexões privadas.

Recurso Instância com acesso apenas a serviços particulares Instância com o Private Service Connect Instância com acesso a serviços particulares e o Private Service Connect
Conectar-se de várias VPCs Incompatível. Compatível. Suporte ao uso do endpoint do Private Service Connect.
Réplicas externas Compatível. Incompatível. Suporte ao uso da conectividade de saída para acesso a serviços particulares.
Endpoint de gravação Compatível. Incompatível. Suporte para acesso a serviços particulares.
Mude a rede VPC associada para o acesso a serviços particulares Compatível. Não relevante. Não é compatível com o acesso a serviços particulares porque a instância tem o Private Service Connect ativado. Não se aplica ao Private Service Connect.
Visibilidade do endereço IP do cliente para o Cloud SQL Compatível. Incompatível. Suporte ao uso do endereço IP de acesso a serviços privados. Não é compatível com o uso do endpoint do Private Service Connect.
Servidores vinculados Compatível. Incompatível. Suporte ao uso do endereço IP de acesso a serviços privados.
Active Directory gerenciado Compatível. Incompatível. Suporte para acesso a serviços particulares.

Opções de conexão para criar instâncias

O Cloud SQL oferece suporte a configurações de IP particular e público. Você pode escolher as opções de conexão com base nos requisitos do aplicativo.

É possível configurar o IP particular para manter as instâncias do Cloud SQL particulares em uma rede VPC. Os seguintes tipos de conexões privadas são aceitos:

Se você quiser que a instância acesse conexões de clientes dentro e fora da rede do Google Cloud pela Internet pública, configure o IP público para a instância.

O Cloud SQL oferece suporte às seguintes opções de conexão para criar instâncias:

Desativar as opções de conexão

O Cloud SQL oferece suporte para desativar as seguintes opções de conexão para instâncias:

  • IP público em uma instância com acesso a serviços privados e IP público
  • IP público em uma instância com IP público, acesso a serviços particulares e Private Service Connect
  • Private Service Connect em uma instância com o Private Service Connect e o acesso a serviços particulares
  • Private Service Connect em uma instância com o Private Service Connect, o acesso a serviços particulares e o IP público

Ativar as opções de conexão

O Cloud SQL oferece suporte para ativar as seguintes opções de conexão para instâncias:

  • Acesso a serviços privados em uma instância com apenas IP público
  • Private Service Connect em uma instância com acesso apenas a serviços particulares
  • Private Service Connect em uma instância com acesso a serviços particulares e IP público
  • IP público em uma instância com acesso apenas a serviços privados

Limitações

  • Não é possível criar uma instância com IP público e o Private Service Connect.
  • Não é possível desativar o acesso a serviços particulares em uma instância com o acesso a serviços particulares e o Private Service Connect.
  • Não é possível desativar o acesso a serviços particulares em uma instância com acesso a serviços particulares e IP público.
  • Se você tiver uma instância que usa apenas IP público, não será possível ativar o Acesso a serviços particulares e o Private Service Connect juntos. Primeiro, ative o acesso a serviços particulares e, em seguida, o Private Service Connect.
  • Não há suporte para a lista de permissões baseada em IP usando redes autorizadas em instâncias com o Private Service Connect ativado.

Como autorizar o Cloud SQL

Conectores de linguagem do Cloud SQL

Os conectores de linguagem do Cloud SQL são bibliotecas de cliente que fornecem criptografia e autorização do IAM ao se conectar com uma instância do Cloud SQL. O Cloud SQL recomenda o uso dos conectores de linguagem do Cloud SQL para a conexão com a instância do Cloud SQL, em vez de outras opções de conexão.

Essas bibliotecas podem ser usadas diretamente na linguagem de programação compatível. Elas fornecem a mesma autenticação que o proxy de autenticação do Cloud SQL, sem exigir um processo externo. Isso proporciona maior segurança e requisitos de configuração reduzidos para a conexão com o Cloud SQL. Os conectores do Cloud SQL também usam o mesmo código ao se conectar por meio de um endereço IP público ou privado.

Para começar, consulte Sobre os conectores de linguagem do Cloud SQL.

Proxy do Cloud SQL Auth

O proxy de autenticação do Cloud SQL permite autorizar e proteger conexões usando as permissões do Identity and Access Management (IAM). Ele valida as conexões usando as credenciais de um usuário ou conta de serviço e unindo a conexão em uma camada SSL/TLS autorizada para uma instância do Cloud SQL. Para mais detalhes sobre como o proxy de autenticação do Cloud SQL funciona, consulte Sobre o proxy de autenticação do Cloud SQL.

Por ser o método mais seguro, é recomendável usar o proxy de autenticação do Cloud SQL para autenticar conexões com uma instância do Cloud SQL.

O proxy de autenticação do Cloud SQL é uma biblioteca de código aberto distribuída como um binário executável. O proxy de autenticação do Cloud SQL funciona como um servidor intermediário que detecta conexões de entrada, une essas conexões em SSL/TLS e as transmite para uma instância do Cloud SQL.

Alguns ambientes fornecem um mecanismo que se conecta usando o proxy de autenticação do Cloud SQL. Para instruções sobre como se conectar usando esses ambientes, consulte uma das seguintes opções:

Certificados SSL/TLS autogerenciados

Em vez de usar o proxy de autenticação do Cloud SQL para criptografar as conexões, é possível configurar certificados SSL/TLS de cliente/servidor específicos para uma instância do Cloud SQL. Esses certificados são usados para validar o cliente/servidor e criptografar conexões entre eles.

É altamente recomendável usar certificados SSL/TLS autogerenciados para fornecer criptografia quando o proxy de autenticação do Cloud SQL não estiver sendo usado. Deixar de fazer isso significa que seus dados estão sendo transmitidos sem segurança e podem ser interceptados ou inspecionados por terceiros.

Para começar a usar certificados SSL/TLS autogerenciados, consulte Como autorizar com certificados SSL/TLS.

Redes autorizadas

A menos que o proxy de autenticação do Cloud SQL seja usado, as conexões com o endereço IP público de uma instância só serão permitidas se forem provenientes de uma rede autorizada. As redes autorizadas são endereços IP ou intervalos que o usuário especificou como tendo permissão para se conectar.

Para começar a usar as redes autorizadas, consulte Como autorizar com redes autorizadas.

Como autenticar no Cloud SQL

A autenticação fornece controle de acesso verificando a identidade de um usuário. Para usuários finais, a autenticação é realizada quando o usuário insere credenciais (um nome de usuário e uma senha). Para aplicativos, a autenticação é realizada quando as credenciais de um usuário são atribuídas a uma conta de serviço.

O Cloud SQL usa a autenticação integrada do banco de dados que autentica usando um nome de usuário e uma senha. Para mais informações, consulte Como criar e gerenciar usuários do SQL Server.

Ferramentas para se conectar ao Cloud SQL

A tabela a seguir contém algumas opções para se conectar ao Cloud SQL:

Opção de conexão Mais informações
Proxy do Cloud SQL Auth
CLI gcloud
Conectores de linguagem do Cloud SQL
Cloud Shell
Cloud Code
Conecte-se usando ferramentas de administração de banco de dados de terceiros
SQL Server Management Studio
Pesquisador de objetos do SSMS
Visual Studio

Amostras de código

É possível se conectar ao proxy de autenticação do Cloud SQL por meio de qualquer linguagem que permita a conexão com um soquete TCP. Veja abaixo alguns snippets de código de exemplos completos no GitHub para ajudar você a entender como eles funcionam em conjunto no aplicativo.

Como se conectar com TCP

Instrução de invocação do proxy de autenticação do Cloud SQL:

./cloud-sql-proxy INSTANCE_CONNECTION_NAME &

Python

Para ver esse snippet no contexto de um aplicativo da Web, consulte o README no 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 conferir esse snippet no contexto de um aplicativo da Web, consulte o README no GitHub.

Observação:

  • CLOUD_SQL_CONNECTION_NAME precisa ser representado como <MEU-PROJETO>:<REGIÃO-DA-INSTÂNCIA>:<NOME-DA-INSTÂNCIA>
  • O uso do argumento ipTypes=PRIVATE forçará o SocketFactory a se conectar ao IP privado associado de uma instância
  • Consulte os requisitos de versão de fábrica do soquete JDBC para o arquivo pom.xml aqui. 


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 esse snippet no contexto de um aplicativo da Web, consulte o README no 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 esse snippet no contexto de um aplicativo da Web, consulte o README no 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 esse snippet no contexto de um aplicativo da Web, consulte o README no GitHub (em inglês).

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 esse snippet no contexto de um aplicativo da Web, consulte o README no 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 esse snippet no contexto de um aplicativo da Web, consulte o README no 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;
    }
}

Resolver problemas

Se você tiver problemas de conexão, consulte as páginas a seguir para receber ajuda na depuração ou localização de soluções para problemas conhecidos:

A seguir