Como se conectar do ambiente padrão do App Engine ao Cloud SQL

Esta página contém informações e exemplos para se conectar a uma instância do Cloud SQL a partir de um serviço em execução no ambiente padrão do App Engine.

O Cloud SQL é um serviço de banco de dados totalmente gerenciado que ajuda a configurar, manter, gerenciar e administrar seus bancos de dados relacionais na nuvem.

O App Engine é uma plataforma sem servidor totalmente gerenciada para desenvolver e hospedar aplicativos da Web em escala. É possível escolher entre várias linguagens, frameworks e bibliotecas conhecidos para desenvolver seus apps e, em seguida, permitir que o App Engine provisione os servidores e escalone as instâncias de app com base na demanda.

Como configurar uma instância do Cloud SQL

  1. Ative a API Cloud SQL Admin no projeto do qual você está se conectando, caso ainda não tenha feito isso:

    Ative a API

  2. Crie uma instância do Cloud SQL para PostgreSQL.

    Por padrão, o Cloud SQL atribui um endereço IP público a uma nova instância. Você também tem a opção de atribuir um endereço IP particular. Para mais informações sobre as opções de conectividade de ambos, consulte a página Visão geral da conexão .

Como configurar o App Engine

As etapas para configurar o ambiente padrão do App Engine dependem do tipo de endereço IP atribuído à instância do Cloud SQL.

IP público (padrão)

Para configurar o ambiente padrão do App Engine para ativar conexões com uma instância do Cloud SQL usando IP público:

  • Verifique se a instância criada acima tem um endereço IP público. Você pode verificar isso na página Visão geral da sua instância no Console do Google Cloud. Se precisar adicionar um, consulte a página Como configurar o IP público para ver instruções.
  • Receba o INSTANCE_CONNECTION_NAME da instância. Isso pode ser encontrado na página Visão geral da instância no Console do Google Cloud ou executando o seguinte comando: gcloud sql instances describe [INSTANCE_NAME].
  • Verifique se a conta de serviço usada pelo app para autenticar chamadas para o Cloud SQL tem o papel e as permissões apropriados do Cloud SQL.
    • A conta de serviço do seu serviço precisa de um dos seguintes papéis do IAM:
      • Cloud SQL Client (recomendável)
      • Cloud SQL Editor
      • Cloud SQL Admin
      Também é possível atribuir manualmente as seguintes permissões do IAM:
      • cloudsql.instances.connect
      • cloudsql.instances.get
      Para receber instruções detalhadas sobre como adicionar papéis do IAM a uma conta de serviço, consulte Como conceder papéis a contas de serviço.

    Por padrão, o app autoriza as conexões usando uma conta de serviço do App Engine. A identidade da conta de serviço está no formato PROJECT_ID@appspot.gserviceaccount.com.

    Se a conta de serviço de autorização pertencer a um projeto diferente da instância do Cloud SQL, as permissões da API Cloud SQL Admin e do IAM precisarão ser adicionadas aos dois projetos.

IP privado

Um conector de acesso VPC sem servidor processa a comunicação com sua rede VPC. Para se conectar diretamente com IP particular, você precisa:

  1. Verifique se a instância do Cloud SQL criada acima tem um endereço IP particular. Se você precisar adicionar um, consulte a página Como configurar o IP particular para ver instruções.
  2. Crie um conector de acesso VPC sem servidor na mesma rede VPC da sua instância do Cloud SQL.
  3. A menos que você esteja usando a VPC compartilhada, é necessário que um conector esteja no mesmo projeto e na mesma região do recurso que o utiliza, mas o conector pode enviar tráfego para recursos em regiões diferentes.

    O acesso VPC sem servidor é compatível com a comunicação com redes VPC conectadas por meio do Cloud VPN e de peering de rede VPC.

    O acesso VPC sem servidor não é compatível com redes legadas.

  4. Configure o App Engine para usar o conector.
  5. Conecte-se usando o IP particular e a porta 5432 da instância.

Como se conectar ao Cloud SQL

Depois de configurar o ambiente padrão do App Engine, conecte-se à instância do Cloud SQL. O App Engine fornece um mecanismo que se conecta usando o Cloud SQL Proxy.

IP público (padrão)

IP particular

Como se conectar com TCP

Conecte-se diretamente usando o endereço IP particular e a porta 5432 da instância.

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 db_host
host_args = db_host.split(":")
db_hostname, db_port = host_args[0], int(host_args[1])

pool = sqlalchemy.create_engine(
    # Equivalent URL:
    # postgres+pg8000://<db_user>:<db_pass>@<db_host>:<db_port>/<db_name>
    sqlalchemy.engine.url.URL(
        drivername="postgres+pg8000",
        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. 5432
        database=db_name  # e.g. "my-database-name"
    ),
    # ... Specify additional properties here.
)

Node.js

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

const connectWithTcp = config => {
  // Extract host and port from socket address
  const dbSocketAddr = process.env.DB_HOST.split(':'); // e.g. '127.0.0.1:5432'

  // Establish a connection to the database
  return Knex({
    client: 'pg',
    connection: {
      user: process.env.DB_USER, // e.g. 'my-user'
      password: process.env.DB_PASS, // e.g. 'my-user-password'
      database: process.env.DB_NAME, // e.g. 'my-database'
      host: dbSocketAddr[0], // e.g. '127.0.0.1'
      port: dbSocketAddr[1], // e.g. '5432'
    },
    // ... Specify additional properties here.
    ...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_TCP_HOST") // e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
	dbPort    = mustGetenv("DB_PORT")     // e.g. '5432'
	dbName    = mustGetenv("DB_NAME")     // e.g. 'my-database'
)

var dbURI string
dbURI = fmt.Sprintf("host=%s user=%s password=%s port=%s database=%s", dbTcpHost, dbUser, dbPwd, dbPort, dbName)

// dbPool is the pool of database connections.
dbPool, err := sql.Open("pgx", 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:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<DB_HOST>;Database=<DB_NAME>;"
            var connectionString = new NpgsqlConnectionStringBuilder()
            {
                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = SslMode.Disable,

                // 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.
                Host = Environment.GetEnvironmentVariable("DB_HOST"),     // e.g. '127.0.0.1'
                // Set Host to 'cloudsql' when deploying to App Engine Flexible environment
                Username = 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.
            // ...
            NpgsqlConnection connection =
                new NpgsqlConnection(connectionString.ConnectionString);

Ruby

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

development:
  adapter: postgresql
  # 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")  { 5432 }%> 

PHP

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

// $username = 'your_db_user';
// $password = 'yoursupersecretpassword';
// $db_name = 'your_db_name';
// $host = "127.0.0.1";

// Connect using TCP
$dsn = sprintf('pgsql:dbname=%s;host=%s', $db_name, $host);

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

Práticas recomendadas e outras informações

É possível usar o Cloud SQL Proxy ao testar seu aplicativo localmente. Acesse o guia de início rápido sobre como usar o proxy para testes locais e veja instruções detalhadas.

Pools de conexões

As conexões aos bancos de dados subjacentes podem ser descartadas pelo próprio servidor de banco de dados ou pela infraestrutura subjacente. Para atenuar isso, recomendamos que você use uma biblioteca de cliente que ofereça suporte a pools de conexão e à reconexão automática.

Para exemplos mais detalhados sobre como usar pools de conexão, consulte Como gerenciar conexões de banco de dados.

Limites de conexão

O Cloud SQL impõe um limite máximo de conexões simultâneas e esses limites podem variar dependendo do mecanismo de banco de dados escolhido (consulte a página "Cotas e limites" do Cloud SQL).

O App Engine pode criar automaticamente mais instâncias conforme o aumento da carga. Isso pode fazer com que você exceda esses limites. Para evitar esse problema, limite o número máximo de instâncias do App Engine. Para mais informações, consulte os Elementos de dimensionamento.

Cada instância do App Engine executada em um ambiente padrão não pode ter mais de 100 conexões simultâneas com uma instância. Nos apps em PHP 5.5, o limite é de 60 conexões simultâneas.

Os aplicativos do App Engine estão sujeitos a limites de tempo de solicitação, dependendo do uso e do ambiente. Para mais informações, veja como as instâncias são gerenciadas nos ambientes padrão e flexível do App Engine.

Os aplicativos do App Engine também estão sujeitos a outras cotas e limites, conforme descrito na página Cotas do App Engine.

Limites de cota da API

O App Engine fornece um mecanismo que se conecta usando o Cloud SQL Proxy, que usa a API Cloud SQL Admin. Os limites de cota da API se aplicam ao Cloud SQL Proxy.