Sobre as opções de conexão

MySQL | PostgreSQL | SQL Server

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 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 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 (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:
- As bibliotecas de conectores do proxy do Cloud SQL Auth e 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. Saiba mais.

Opções de conexão

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.

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

IP privado

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

É 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 particular, consulte Requisitos para IP particular.

Para caminhos de IP particular, 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
Cloud Functions
Cloud Run

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.

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 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 mysql a uma instância do Cloud SQL usando um IP público, consulte Como se conectar usando um cliente de banco de dados.

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.

Opções de autorização

Proxy do Cloud SQL Auth

O proxy do Cloud SQL Auth permite autorizar e proteger as conexões usando as permissões do gerenciamento de identidade e acesso (IAM). O proxy do Cloud SQL Auth valida as conexões usando credenciais para 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 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 do Cloud SQL Auth para autenticar conexões em 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.

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:

Bibliotecas de conectores do Cloud SQL para Java e Python

O Cloud SQL oferece bibliotecas de cliente que fornecem criptografia e autorização baseada em IAM ao se conectar a uma instância do Cloud SQL usando conectores Java e Python.

É possível usar 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.

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 não ser que o proxy do Cloud SQL Auth seja usado, 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.

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

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:

INSTANCE_CONNECTION_NAME deve 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")
instance_connection_name = os.environ["INSTANCE_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"
                instance_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.INSTANCE_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("INSTANCE_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);

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

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.