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 mysql 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 mysql?
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.

Caso de uso recomendado

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

Caso de uso recomendado

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.

Caso de uso recomendado

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

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	Sobre o proxy do Cloud SQL Auth Como se conectar pelo proxy do Cloud SQL Auth Como se conectar usando a imagem do Docker do proxy do Cloud SQL Auth
gcloud	`gcloud sql connect`
Conectores de linguagem do Cloud SQL	Como se conectar usando conectores do Cloud SQL para Java, Python e Go.
Cloud Shell	Como se conectar usando o Cloud Shell
Apps Script	Conexões externas com o Apps Script (em inglês) Página de amostra do Apps Script no GitHub (em inglês)

Conectar-se usando ferramentas de administração de banco de dados de terceiros
MySQL Workbench	Conexão com o MySQL Workbench
Toad para MySQL	Conexão com o Toad for MySQL
SQuirrel para SQL	Conexão com SQuirrel SQL
phpAdmin	Como usar o phpMyAdmin com o Cloud SQL no App Engine

Como conectar aplicativos com endereços IP atribuídos dinamicamente

Alguns aplicativos precisam se conectar à instância do Cloud SQL usando um endereço IP atribuído dinamicamente (temporário). Esse é o caso dos aplicativos Platform as a Service (PaaS), entre outros.

A melhor solução para esses aplicativos é se conectar usando o proxy do Cloud SQL Auth. Essa solução oferece o melhor controle de acesso para a instância.

Amostras de código

Você pode se conectar ao proxy do Cloud SQL Auth por qualquer linguagem que permita se conectar a um soquete Unix ou 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:3306 &

Python

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

cloud-sql/mysql/sqlalchemy/main.py

Ver 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 port from db_host if present,
# otherwise use DB_PORT environment variable.
host_args = db_host.split(":")
if len(host_args) == 1:
    db_hostname = db_host
    db_port = os.environ["DB_PORT"]
elif len(host_args) == 2:
    db_hostname, db_port = host_args[0], int(host_args[1])

pool = sqlalchemy.create_engine(
    # Equivalent URL:
    # mysql+pymysql://<db_user>:<db_pass>@<db_host>:<db_port>/<db_name>
    sqlalchemy.engine.url.URL.create(
        drivername="mysql+pymysql",
        username=db_user,  # e.g. "my-database-user"
        password=db_pass,  # e.g. "my-database-password"
        host=db_hostname,  # e.g. "127.0.0.1"
        port=db_port,  # e.g. 3306
        database=db_name,  # e.g. "my-database-name"
    ),
    **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.

cloud-sql/mysql/servlet/src/main/java/com/example/cloudsql/ConnectionPoolContextListener.java

Ver no GitHub

// 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 URL is equivalent to setting the config options below:
// jdbc:mysql:///<DB_NAME>?cloudSqlInstance=<INSTANCE_CONNECTION_NAME>&
// socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=<DB_USER>&password=<DB_PASS>
// 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.setJdbcUrl(String.format("jdbc:mysql:///%s", DB_NAME));
config.setUsername(DB_USER); // e.g. "root", "mysql"
config.setPassword(DB_PASS); // e.g. "my-password"

config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.mysql.SocketFactory");
config.addDataSourceProperty("cloudSqlInstance", INSTANCE_CONNECTION_NAME);

// The ipTypes argument can be used to specify a comma delimited list of preferred IP types
// for connecting to a Cloud SQL instance. The argument ipTypes=PRIVATE will force the
// SocketFactory to connect with an instance's associated private IP.
config.addDataSourceProperty("ipTypes", "PUBLIC,PRIVATE");

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

cloud-sql/mysql/mysql/server.js

Ver no GitHub

const createTcpPool = async config => {
  // Extract host and port from socket address
  const dbSocketAddr = process.env.DB_HOST.split(':');

  // Establish a connection to the database
  return mysql.createPool({
    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'
    host: dbSocketAddr[0], // e.g. '127.0.0.1'
    port: dbSocketAddr[1], // e.g. '3306'
    // ... Specify additional properties here.
    ...config,
  });
};

Go

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

cloudsql/mysql/database-sql/cloudsql.go

Ver 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. '3306'
	dbName    = mustGetenv("DB_NAME") // e.g. 'my-database'
)

dbURI := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true", dbUser, dbPwd, dbTCPHost, dbPort, dbName)

// ...

// dbPool is the pool of database connections.
dbPool, err := sql.Open("mysql", 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).

cloud-sql/mysql/Startup.cs

Ver no GitHub

            // Equivalent connection string:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<DB_HOST>;Database=<DB_NAME>;"
            var connectionString = new MySqlConnectionStringBuilder()
            {
                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = MySqlSslMode.None,

                // 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.
                Server = 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'
                Database = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'
            };
            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.

cloud-sql/mysql/activerecord/config/database.yml

Ver no GitHub

development:
  adapter: mysql2
  # 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") { 3306 }%>
  socket: "<%= ENV.fetch("DB_SOCKET_DIR") { '/cloudsql' } %>/<%= ENV["INSTANCE_CONNECTION_NAME"] %>"

PHP

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

cloud_sql/mysql/pdo/src/DBInitializer.php

Ver no GitHub

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

// Connect using TCP
$dsn = sprintf('mysql:dbname=%s;host=%s', $dbName, $dbHost);

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

Como se conectar com soquetes Unix

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

./cloud_sql_proxy -instances=INSTANCE_CONNECTION_NAME -dir=/cloudsql &

Python

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

cloud-sql/mysql/sqlalchemy/main.py

Ver 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_socket_dir = os.environ.get("DB_SOCKET_DIR", "/cloudsql")
cloud_sql_connection_name = os.environ["CLOUD_SQL_CONNECTION_NAME"]

pool = sqlalchemy.create_engine(
    # Equivalent URL:
    # mysql+pymysql://<db_user>:<db_pass>@/<db_name>?unix_socket=<socket_path>/<cloud_sql_instance_name>
    sqlalchemy.engine.url.URL.create(
        drivername="mysql+pymysql",
        username=db_user,  # e.g. "my-database-user"
        password=db_pass,  # e.g. "my-database-password"
        database=db_name,  # e.g. "my-database-name"
        query={
            "unix_socket": "{}/{}".format(
                db_socket_dir,  # e.g. "/cloudsql"
                cloud_sql_connection_name)  # i.e "<PROJECT-NAME>:<INSTANCE-REGION>:<INSTANCE-NAME>"
        }
    ),
    **db_config
)

Java

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

cloud-sql/mysql/servlet/src/main/java/com/example/cloudsql/ConnectionPoolContextListener.java

Ver no GitHub

// 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 URL is equivalent to setting the config options below:
// jdbc:mysql:///<DB_NAME>?cloudSqlInstance=<INSTANCE_CONNECTION_NAME>&
// socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=<DB_USER>&password=<DB_PASS>
// 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.setJdbcUrl(String.format("jdbc:mysql:///%s", DB_NAME));
config.setUsername(DB_USER); // e.g. "root", "mysql"
config.setPassword(DB_PASS); // e.g. "my-password"

config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.mysql.SocketFactory");
config.addDataSourceProperty("cloudSqlInstance", INSTANCE_CONNECTION_NAME);

// The ipTypes argument can be used to specify a comma delimited list of preferred IP types
// for connecting to a Cloud SQL instance. The argument ipTypes=PRIVATE will force the
// SocketFactory to connect with an instance's associated private IP.
config.addDataSourceProperty("ipTypes", "PUBLIC,PRIVATE");

// ... 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 (em inglês).

cloud-sql/mysql/mysql/server.js

Ver no GitHub

const createUnixSocketPool = async config => {
  const dbSocketPath = process.env.DB_SOCKET_PATH || '/cloudsql';

  // Establish a connection to the database
  return mysql.createPool({
    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'
    // If connecting via unix domain socket, specify the path
    socketPath: `${dbSocketPath}/${process.env.CLOUD_SQL_CONNECTION_NAME}`,
    // Specify additional properties here.
    ...config,
  });
};

C#

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

cloud-sql/mysql/Startup.cs

Ver no GitHub

// Equivalent connection string:
// "Server=<dbSocketDir>/<INSTANCE_CONNECTION_NAME>;Uid=<DB_USER>;Pwd=<DB_PASS>;Database=<DB_NAME>;Protocol=unix"
String dbSocketDir = Environment.GetEnvironmentVariable("DB_SOCKET_PATH") ?? "/cloudsql";
String instanceConnectionName = Environment.GetEnvironmentVariable("INSTANCE_CONNECTION_NAME");
var connectionString = new MySqlConnectionStringBuilder()
{
    // The Cloud SQL proxy provides encryption between the proxy and instance.
    SslMode = MySqlSslMode.None,
    // 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.
    Server = String.Format("{0}/{1}", dbSocketDir, instanceConnectionName),
    UserID = Environment.GetEnvironmentVariable("DB_USER"),   // e.g. 'my-db-user
    Password = Environment.GetEnvironmentVariable("DB_PASS"), // e.g. 'my-db-password'
    Database = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'
    ConnectionProtocol = MySqlConnectionProtocol.UnixSocket
};
connectionString.Pooling = true;
// Specify additional properties here.
return connectionString;

Go

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

cloudsql/mysql/database-sql/cloudsql.go

Ver no GitHub

var (
	dbUser                 = mustGetenv("DB_USER")                  // e.g. 'my-db-user'
	dbPwd                  = mustGetenv("DB_PASS")                  // e.g. 'my-db-password'
	instanceConnectionName = mustGetenv("INSTANCE_CONNECTION_NAME") // e.g. 'project:region:instance'
	dbName                 = mustGetenv("DB_NAME")                  // e.g. 'my-database'
)

socketDir, isSet := os.LookupEnv("DB_SOCKET_DIR")
if !isSet {
	socketDir = "/cloudsql"
}

dbURI := fmt.Sprintf("%s:%s@unix(/%s/%s)/%s?parseTime=true", dbUser, dbPwd, socketDir, instanceConnectionName, dbName)

// dbPool is the pool of database connections.
dbPool, err := sql.Open("mysql", dbURI)
if err != nil {
	return nil, fmt.Errorf("sql.Open: %v", err)
}

// ...

return dbPool, nil

Ruby

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

cloud-sql/mysql/activerecord/config/database.yml

Ver no GitHub

production:
  adapter: mysql2
  # 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_production" } %>
  socket: "<%= ENV.fetch("DB_SOCKET_DIR") { '/cloudsql' } %>/<%= ENV["INSTANCE_CONNECTION_NAME"] %>"

PHP

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

cloud_sql/mysql/pdo/src/DBInitializer.php

Ver no GitHub

// $username = 'your_db_user';
// $password = 'yoursupersecretpassword';
// $dbName = 'your_db_name';
// $connectionName = getenv("CLOUD_SQL_CONNECTION_NAME");
// $socketDir = getenv('DB_SOCKET_DIR') ?: '/cloudsql';

// Connect using UNIX sockets
$dsn = sprintf(
    'mysql:dbname=%s;unix_socket=%s/%s',
    $dbName,
    $socketDir,
    $connectionName
);

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

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

Aprenda a se conectar com o Guia de início rápido do Cloud SQL para MySQL.
Conheça as práticas recomendadas para gerenciar conexões de banco de dados.
Saiba mais sobre a autenticação do banco de dados do IAM.
Saiba mais sobre como se conectar usando um cliente mysql em uma máquina local ou no Compute Engine.
Saiba mais sobre configurar a conectividade IP.
Saiba como conectar com outras ferramentas MySQL.
Conheça os conectores MySQL.
Saiba mais sobre o proxy do Cloud SQL Auth.
Conheça as opções de suporte.