Visão geral da conexão

Nesta página, você encontra um resumo das opções para se conectar à instância do Cloud SQL.

Introdução

Usar o proxy do Cloud SQL Auth é o método recomendado para se conectar a uma instância do Cloud SQL. O proxy do Cloud SQL Auth:

  • Funciona com endpoints de IP público e particular
  • Valida conexões usando credenciais de um usuário ou conta de serviço
  • Encapsula a conexão em uma camada SSL/TLS autorizada para uma instância do Cloud SQL

Alguns serviços e aplicativos do Google Cloud fornecem conexões para caminhos de IP público com criptografia e autorização usando o proxy do Cloud SQL Auth, incluindo:

Para caminhos de IP particular, esses serviços e aplicativos se conectam diretamente à instância por meio de acesso VPC sem servidor.

Os aplicativos em execução no Google Kubernetes Engine podem se conectar usando o Cloud SQL Auth Proxy.

Consulte o Guia de início rápido para usar o proxy do Cloud SQL Auth para uma introdução básica ao uso.

Também é possível se conectar, com ou sem o proxy do Cloud SQL Auth, usando um cliente sqlcmd de uma máquina local ou do Compute Engine.

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 fique acessível pela Internet ou seja particular em uma rede de nuvem privada virtual (VPC, na sigla em inglês)?
  • Você planeja escrever seu próprio código de conexão ou se conectar usando ferramentas disponíveis publicamente, como o proxy do Cloud SQL Auth ou um cliente sqlcmd?
  • Você quer exigir criptografia usando SSL/TLS ou permitir tráfego não criptografado?

Nas seções abaixo, discutimos as opções que o Cloud SQL fornece para conectar, autorizar e autenticar no seu banco de dados.

  • Como se conectar: qual caminho de rede você usa para acessar a instância:
    • Um endereço IP interno somente VPC (Particular).
    • 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:
    • Conectores de linguagem do proxy do Cloud SQL Auth e do Cloud SQL: 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 nativo: login com um nome de usuário/senha definido no mecanismo de banco de dados.

Use as informações abaixo 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. Saiba mais.

Opções de conexão

IP particular

Um IP particular é um endereço IPv4 ou IPv6 acessível em uma nuvem privada virtual (VPC, na sigla em inglês).

Considerações sobre segurança

Use esse endereço para se conectar a partir de outros recursos com acesso à VPC. As conexões por IP particular normalmente fornecem menor latência e vetores de ataque limitados, já que 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 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 particular, consulte Requisitos para IP particular.

Saiba mais

Saiba mais sobre como usar IP particular com o Cloud SQL

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

IP público

Um IP público é um endereço IPv4 ou IPv6 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.

Considerações sobre segurança

Para ajudar a manter a instância segura, todas as conexões a uma instância do Cloud SQL que usam um IP público precisam ser autorizadas com o proxy do Cloud SQL Auth ou com as 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.

Saiba mais

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

Opções de autorização

Conectores do Cloud SQL

Considerações sobre segurança

O proxy do Cloud SQL Auth permite autorizar e proteger as conexões usando as permissões do gerenciamento de identidade e acesso (IAM, na sigla em inglês). O proxy valida as conexões com as credenciais de um usuário ou uma conta de serviço e encapsula a conexão em uma camada SSL/TLS autorizada para uma instância do Cloud SQL. Para mais detalhes sobre como o proxy do Cloud SQL Auth funciona, consulte Sobre o proxy do Cloud SQL Auth.

Por ser o método mais seguro, é recomendável usar o proxy Cloud SQL Auth para autenticar conexões a uma instância do Cloud SQL.

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

Além disso, algumas linguagens têm a opção de usar uma biblioteca de cliente. Use essas bibliotecas diretamente no ambiente da linguagem. Elas fornecem a mesma autenticação que o proxy do Cloud SQL Auth sem exigir um processo externo. Para começar, consulte Como se conectar usando os conectores do Cloud SQL.

Alguns ambientes fornecem um mecanismo que se conecta usando o proxy do Cloud SQL Auth. 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 do Cloud SQL Auth para criptografar suas 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 não estiver usando o proxy do Cloud SQL Auth. 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 seja usado o proxy do Cloud SQL Auth, as conexões com o endereço IP público de uma instância só serão permitidas se a conexão vier 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 gerenciar conexões de banco de dados

As conexões do banco de dados consomem recursos no servidor e no aplicativo conectado. Sempre use boas práticas de gerenciamento de conexão 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.

Opções de autenticação

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

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
gcloud
Conectores de linguagem do Cloud SQL
Cloud Shell
Conecte-se usando ferramentas de administração de banco de dados de terceiros
SQL Server Management Studio
Explorador de objetos SMSS
Visual Studio

Amostras de código

É possível se conectar ao proxy do Cloud SQL Auth por qualquer linguagem que permita se conectar a 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 do Cloud SQL Auth:

./cloud_sql_proxy -instances=INSTANCE_CONNECTION_NAME=tcp:1433 &

Python

Para ver esse snippet no contexto de um aplicativo da Web, consulte o README no GitHub.

# Remember - storing secrets in plaintext is potentially unsafe. Consider using
# something like https://cloud.google.com/secret-manager/docs/overview to help keep
# secrets secret.
db_user = os.environ["DB_USER"]
db_pass = os.environ["DB_PASS"]
db_name = os.environ["DB_NAME"]
db_host = os.environ["DB_HOST"]

# Extract host and port from environment variable DB_HOST
host_args = db_host.split(":")
db_hostname, db_port = host_args[0], int(host_args[1])

# SQL Server drivers don't account for this
if db_hostname == "localhost":
    db_hostname = "127.0.0.1"

# The SQLAlchemy engine will help manage interactions, including automatically
# managing a pool of connections to your database
pool = sqlalchemy.create_engine(
    # Equivalent URL:
    # mssql+pytds://<db_user>:<db_pass>@/<host>:<port>/<db_name>?driver=ODBC+Driver+17+for+SQL+Server
    sqlalchemy.engine.url.URL.create(
        "mssql+pytds",
        username=db_user,
        password=db_pass,
        database=db_name,
        host=db_hostname,
        port=db_port,
    ),
    **db_config
)

Java

Para ver esse snippet no contexto de um aplicativo da Web, consulte o README no GitHub (em inglês).

Observação:

  • CLOUD_SQL_CONNECTION_NAME precisa ser representado como <MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME>
  • 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.

// Note: For Java users, the Cloud SQL JDBC Socket Factory can provide authenticated connections
// which is preferred to using the Cloud SQL Proxy with Unix sockets.
// See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.

// 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=<CLOUD_SQL_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", CLOUD_SQL_CONNECTION_NAME);

// ... Specify additional connection properties here.

// ...

// Initialize the connection pool using the configuration object.
DataSource pool = new HikariDataSource(config);

Node.js

Para ver esse snippet no contexto de um aplicativo da Web, consulte o README no GitHub.

const createPool = async () => {
  const config = {pool: {}, options: {}};
  config.user = process.env.DB_USER; // e.g. 'my-db-user'
  config.password = process.env.DB_PASS; // e.g. 'my-db-password'
  config.database = process.env.DB_NAME; // e.g. 'my-database'
  // set the server to '172.17.0.1' when connecting from App Engine Flex
  config.server = process.env.DEPLOYED ? '172.17.0.1' : '127.0.0.1';
  config.port = 1433;

  // ...
  config.options.trustServerCertificate = true;
  return await mssql.connect(config);
};

Go

Para ver esse snippet no contexto de um aplicativo da Web, consulte o README no GitHub.

var (
	dbUser    = mustGetenv("DB_USER") // e.g. 'my-db-user'
	dbPwd     = mustGetenv("DB_PASS") // e.g. 'my-db-password'
	dbTCPHost = mustGetenv("DB_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'
)

var dbURI string
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("mssql", dbURI)
if err != nil {
	return nil, fmt.Errorf("sql.Open: %v", err)
}

// ...

return dbPool, nil

C#

Para ver esse snippet no contexto de um aplicativo da Web, consulte o README no GitHub (em inglês).

            // Equivalent connection string:
            // "User Id=<DB_USER>;Password=<DB_PASS>;Server=<DB_HOST>;Database=<DB_NAME>;"
            var connectionString = new SqlConnectionStringBuilder()
            {
                // Remember - storing secrets in plain text is potentially unsafe. Consider using
                // something like https://cloud.google.com/secret-manager/docs/overview to help keep
                // secrets secret.
                DataSource = Environment.GetEnvironmentVariable("DB_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;
            // ...
            return connectionString;

Ruby

Para ver esse snippet no contexto de um aplicativo da Web, consulte o README no GitHub.

development:
  adapter: sqlserver
  # Configure additional properties here.
  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("DB_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.

// $username = 'your_db_user';
// $password = 'yoursupersecretpassword';
// $dbName = 'your_db_name';
// $dbHost = "127.0.0.1";

// Connect using TCP
$dsn = sprintf('sqlsrv:server=%s;Database=%s', $dbHost, $dbName);

// Connect to the database
$conn = new PDO($dsn, $username, $password, $connConfig);

Solução de 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