Conectar usando o proxy de autenticação do AlloyDB

Esta página mostra como configurar e usar o proxy de autenticação do AlloyDB para fazer conexões autorizadas e criptografadas com instâncias do AlloyDB. Para uma visão geral conceitual do proxy de autenticação, consulte Sobre o proxy de autenticação do AlloyDB.

Para usar o proxy de autenticação do AlloyDB, você precisa realizar várias etapas de configuração únicas, iniciar o cliente do proxy de autenticação e se conectar a bancos de dados usando ele:

  1. Etapas de configuração:
    1. Faça o download do cliente do proxy de autenticação para o host do cliente.
    2. Escolha o principal do Identity and Access Management (IAM) a ser usado para autorização, verifique se ele tem as permissões necessárias e disponibilize as credenciais dele no host do cliente.
    3. Reúna URIs de conexão para as instâncias do AlloyDB com que você quer se conectar.
  2. Inicie o cliente do proxy de autenticação no host do cliente.
  3. Conecte um aplicativo a um banco de dados abrindo uma conexão local com o cliente do proxy de autenticação.

Antes de começar

    O host do cliente precisa atender a estes requisitos:

    • Ele precisa ter visibilidade de rede para a rede de nuvem privada virtual (VPC, na sigla em inglês) em que as instâncias que você quer conectar residem. Os hosts de cliente (como instâncias do Compute Engine) nessa rede de nuvem privada virtual (VPC) têm essa visibilidade de forma inerente. Os hosts de cliente em redes externas (redes locais ou diferentes redes VPC) têm essa visibilidade se a rede VPC da instância do AlloyDB tiver sido conectada à rede externa usando um Túnel do Cloud VPN ou um anexo de VLAN para Interconexão dedicada ou Interconexão por parceiro.

    • Se o host do cliente tiver uma política de firewall de saída, ela precisará permitir conexões de saída para a porta 5433 nos endereços IP das instâncias do AlloyDB e permitir conexões de saída para a porta 443 (a porta HTTPS padrão) para todos os endereços IP.

    • Se você estiver usando uma instância do Compute Engine como host do cliente, ela precisará ter o escopo de acesso https://www.googleapis.com/auth/cloud-platform para poder usar a API AlloyDB Admin. Se necessário, mude o escopo de acesso para incluir esse escopo.

Fazer o download do cliente do proxy de autenticação

A máquina para a qual você faz o download do cliente do proxy de autenticação depende se você quer se conectar às instâncias do AlloyDB dentro da rede VPC ou fora dela.

Se você quiser se conectar ao cluster usando o acesso a serviços particulares, faça o download do cliente do Auth Proxy em uma instância de máquina virtual (VM) do Compute Engine executada na rede VPC que tenha acesso a serviços particulares no cluster.

Se você pretende se conectar ao cluster de fora da VPC, a máquina em que ele será instalado depende da estratégia de conexão externa usada. Por exemplo, é possível instalar o cliente do proxy de autenticação em uma máquina do macOS ou Windows que seja local para o aplicativo e, em seguida, usar um servidor SOCKS em execução na rede VPC do AlloyDB como um intermediário de conexão. Para mais informações, consulte Conectar-se a um cluster de fora da VPC.

Linux

64 bits (AMD)

  1. Faça o download do cliente do proxy de autenticação:

    wget https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy.linux.amd64 -O alloydb-auth-proxy
  2. Torne o cliente do proxy de autenticação executável:

    chmod +x alloydb-auth-proxy

32 bits (AMD)

  1. Faça o download do cliente do proxy de autenticação:

    wget https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy.linux.386 -O alloydb-auth-proxy
  2. Torne o cliente do proxy de autenticação executável:

    chmod +x alloydb-auth-proxy

64 bits (ARM)

  1. Faça o download do cliente do proxy de autenticação:

    wget https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy.linux.arm64 -O alloydb-auth-proxy
  2. Torne o cliente do proxy de autenticação executável:

    chmod +x alloydb-auth-proxy

32 bits (ARM)

  1. Faça o download do cliente do proxy de autenticação:

    wget https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy.linux.arm -O alloydb-auth-proxy
  2. Torne o cliente do proxy de autenticação executável:

    chmod +x alloydb-auth-proxy

macOS

M1

  1. Faça o download do cliente do proxy de autenticação:

    curl -o alloydb-auth-proxy https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy.darwin.arm64
  2. Torne o cliente do proxy de autenticação executável:

    chmod +x alloydb-auth-proxy

64 bits

  1. Faça o download do cliente do proxy de autenticação:

    curl -o alloydb-auth-proxy https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy.darwin.amd64
  2. Torne o cliente do proxy de autenticação executável:

    chmod +x alloydb-auth-proxy

32 bits

  1. Faça o download do cliente do proxy de autenticação:

    curl -o alloydb-auth-proxy https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy.darwin.386
  2. Torne o cliente do proxy de autenticação executável:

    chmod +x alloydb-auth-proxy

Windows

64 bits

Clique com o botão direito do mouse em https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x64.exe e selecione Salvar link como para fazer o download do cliente do proxy de autenticação. Renomeie o arquivo para alloydb-auth-proxy.exe.

32 bits

Clique com o botão direito do mouse em https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x86.exe e selecione Salvar link como para fazer o download do cliente do proxy de autenticação. Renomeie o arquivo para alloydb-auth-proxy.exe.

Imagem do Docker

Por conveniência, várias imagens de contêiner que contêm o cliente do proxy de autenticação estão disponíveis no Container Registry.

É possível extrair a imagem mais recente na sua máquina local usando o Docker com o seguinte comando:

docker pull gcr.io/alloydb-connectors/alloydb-auth-proxy:latest

Outros SOs

Para outros sistemas operacionais não incluídos aqui, compile o cliente do proxy de autenticação a partir da origem.

Escolha o principal do IAM e prepare-o para a autorização

O proxy de autenticação do AlloyDB oferece suporte ao uso desses tipos de entidades principais do IAM para autorizar conexões entre o cliente e uma instância do AlloyDB:

  • Uma conta de serviço gerenciada pelo usuário. Você pode criar uma conta de serviço do IAM para seu aplicativo e, em seguida, autorizar conexões usando essa conta.

    O Google recomenda que você use uma conta de serviço para autorização em ambientes de produção.

  • Sua conta de usuário. Você pode usar sua própria conta de usuário do IAM para autorizar conexões.

    Usar sua própria conta de usuário é conveniente em ambientes de desenvolvimento em que você está gerenciando recursos do AlloyDB usando a CLI gcloud, desenvolvendo o banco de dados usando uma ferramenta como psql e desenvolvendo o código do aplicativo no mesmo host.

  • A conta de serviço padrão do Compute Engine. Se o host do cliente for uma instância do Compute Engine, use a conta de serviço padrão do Compute Engine para autorizar as conexões.

Depois de escolher qual principal do IAM usar, verifique se ele tem as permissões necessárias do IAM e se as credenciais dele estão disponíveis no host do cliente.

Permissões do IAM obrigatórias

O participante do IAM usado para autorizar conexões precisa ter as permissões fornecidas pelos papéis predefinidos roles/alloydb.client (cliente do Cloud AlloyDB) e roles/serviceusage.serviceUsageConsumer (consumidor do Service Usage).

Para atribuir a função de cliente do Cloud AlloyDB a um princípio do IAM:

  • A API Cloud Resource Manager precisa estar ativada no projeto do Google Cloud.

  • Você precisa ter o papel básico do IAM roles/owner (proprietário) no projeto do Google Cloud ou um papel que conceda estas permissões:

    • resourcemanager.projects.get
    • resourcemanager.projects.getIamPolicy
    • resourcemanager.projects.setIamPolicy

    Para receber essas permissões seguindo o princípio do menor privilégio, peça ao administrador para conceder a você o papel roles/resourcemanager.projectIamAdmin (Administrador do IAM do projeto).

Disponibilizar credenciais do IAM no host do cliente

A forma de disponibilizar as credenciais do IAM no host do cliente depende do tipo de principal do IAM que você está usando para autorizar as conexões:

  • Conta de serviço gerenciada pelo usuário

    Para fornecer credenciais do IAM a uma conta de serviço gerenciada pelo usuário, crie uma chave de conta de serviço em formato JSON e faça o download dela no host do cliente. Ao iniciar o cliente do proxy de autenticação, especifique o local do arquivo de chave usando a flag --credentials-file.

  • Sua conta de usuário

    Para fornecer credenciais do IAM à sua conta de usuário, instale a CLI do Google Cloud no host do cliente e execute o comando gcloud init para inicializá-lo usando sua conta de usuário. Quando você inicia o cliente do Auth Proxy, ele detecta e usa automaticamente as credenciais da conta de usuário se você não fornecer credenciais de conta de serviço gerenciadas pelo usuário.

  • Conta de serviço padrão do Compute Engine

    Se você estiver usando uma instância do Compute Engine como host do cliente, as credenciais da conta de serviço padrão do Compute Engine já estarão no host. Quando você inicia o cliente do proxy de autenticação, ele descobre e usa automaticamente essas credenciais se as credenciais da conta de serviço e da conta de usuário gerenciadas pelo usuário estiverem indisponíveis.

Coletar URIs de conexão para as instâncias do AlloyDB

Ao iniciar o cliente do proxy de autenticação, você identifica a instância do AlloyDB a que quer se conectar usando este formato de URI de conexão:

projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID

Para conferir uma lista de todos os URIs de conexão das instâncias, use o comando alloydb instances list da CLI gcloud.

Colete o URI de conexão de cada instância com que você quer se conectar.

Iniciar o cliente do proxy de autenticação

Ao iniciar o cliente do proxy de autenticação, você fornece informações sobre a quais instâncias do AlloyDB se conectar e, se necessário, informações de credenciais para usar ao autorizar essas conexões.

Ao iniciar, o cliente do proxy de autenticação:

  • Autoriza conexões a instâncias do AlloyDB usando as credenciais e as permissões do IAM do principal do IAM que você configurou. Ele procura credenciais seguindo uma sequência específica de etapas.
  • Autoriza conexões de IP público à rede de origem automaticamente, se a instância tiver o IP público ativado.
  • Configura uma conexão TLS 1.3 privada com o servidor de proxy de autenticação de cada instância.
  • Começa a detectar solicitações de conexão de clientes locais.

Por padrão, o cliente do proxy de autenticação detecta conexões TCP no endereço IP 127.0.0.1, começando na porta 5432 e incrementando por um número de porta para cada instância do AlloyDB além da primeira. É possível especificar um endereço de listener e portas diferentes ao iniciar o cliente do proxy de autenticação.

Linha de comando

./alloydb-auth-proxy INSTANCE_URI... \
    [ --credentials-file PATH_TO_KEY_FILE \ ]
    [ --token OAUTH_ACCESS_TOKEN \ ]
    [ --port INITIAL_PORT_NUMBER \ ]
    [ --address LOCAL_LISTENER_ADDRESS \ ]
    [ --auto-iam-authn ] \
    [ --psc] \
    [ --public-ip]

Substitua:

  • INSTANCE_URI: o URI de conexão de instância de uma instância do AlloyDB para se conectar, especificado usando este formato:

    projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID

    É possível substituir a porta de listener local padrão que o cliente do proxy de autenticação vai usar para a instância adicionando o parâmetro de consulta port ao URI:

    "projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID?port=PORT"

  • Opcional: PATH_TO_KEY_FILE: o caminho para o arquivo de chave JSON da conta de serviço gerenciada pelo usuário a ser usada para autorização de conexão.

  • Opcional: OAUTH_ACCESS_TOKEN: um valor de token OAuth2 a ser usado para autorização de conexão.

  • Opcional: INITIAL_PORT_NUMBER: o número da porta inicial a ser usado em vez da porta padrão 5432 ao detectar conexões TCP locais.

  • Opcional: LOCAL_LISTENER_ADDRESS: o endereço do listener a ser usado em vez do 127.0.0.1 padrão ao detectar conexões TCP locais.

A flag --auto-iam-authn opcional permite a autenticação automática na instância. Isso funciona apenas para o usuário do banco de dados associado à conta do IAM que está executando o cliente do proxy de autenticação. Para mais informações, consulte Autenticar automaticamente usando o Auth Proxy.

A flag --psc opcional permite que o proxy de autenticação se conecte a uma instância com o Private Service Connect ativado. Para mais informações sobre como configurar o DNS com o Private Service Connect, consulte Configurar uma zona gerenciada de DNS e um registro de DNS.

A flag opcional --public-ip permite que o proxy de autenticação se conecte a uma instância com o IP público ativado usando o endereço IP público da instância. Para mais informações sobre o IP público, consulte Conectar usando IP público.

Contêiner do Docker

Inicie o cliente do proxy de autenticação usando o comando docker run.

Se você estiver usando as credenciais fornecidas pela instância do Compute Engine, use um comando semelhante ao seguinte:

docker run \
  --publish 127.0.0.1:PORT:PORT \
  gcr.io/alloydb-connectors/alloydb-auth-proxy:latest \
  --address 0.0.0.0 \
  --port PORT \
  INSTANCE_URI

Substitua:

  • PORT: a porta a ser usada para conexões locais com o cliente do proxy de autenticação. O padrão é 5432.

  • INSTANCE_URI: o URI de conexão de instância de uma instância do AlloyDB a ser conectada, especificado usando o seguinte formato:

    projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID

    É possível substituir a porta de listener local padrão que o cliente do proxy de autenticação usa para a instância adicionando o parâmetro de consulta port ao URI:

    "projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID?port=PORT"

Sempre especifique o prefixo 127.0.0.1 na flag --publish para que o cliente do proxy de autenticação não seja exposto fora do host local.

O valor 0.0.0.0 na flag --address é necessário para tornar o listener acessível de fora do contêiner do Docker.

Para fornecer credenciais armazenadas em um arquivo JSON local, inclua as flags --volume e --credentials-file ao executar o comando docker run:

docker run \
  --volume PATH_TO_KEY_FILE:/key.json \
  --publish 127.0.0.1:PORT:PORT \
  gcr.io/alloydb-connectors/alloydb-auth-proxy:latest \
  --address 0.0.0.0 \
  --port PORT \
  --credentials-file=/key.json \
  INSTANCE_URI

Substitua PATH_TO_KEY_FILE pelo caminho do arquivo de chave JSON da conta de serviço gerenciada pelo usuário a ser usada para autorização de conexão.

Exemplos de inicialização

Os exemplos a seguir mostram várias maneiras de iniciar o cliente do Auth Proxy. Eles usam estes URIs de conexão de exemplo:

projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary
projects/myproject/locations/us-central1/clusters/mycluster/instances/myreadpool

Inicialização básica

./alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary"

Neste exemplo, o cliente do proxy de autenticação autoriza a conexão seguindo a sequência normal de etapas de autorização e, em seguida, começa a detectar conexões locais para a instância myprimary em 127.0.0.1:5432.

Inicialização usando uma conta de serviço gerenciada pelo usuário

./alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary" \\
  --credentials-file "myappaccount/key.json"

Neste exemplo, o cliente do proxy de autenticação autoriza a conexão usando a chave JSON da conta de serviço gerenciada pelo usuário armazenada em myappaccount/key.json e começa a detectar conexões locais para a instância myprimary em 127.0.0.1:5432.

Startup se conectando a várias instâncias

./alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary" \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myreadpool"

Neste exemplo, o cliente do proxy de autenticação autoriza a conexão seguindo a sequência normal de etapas de autorização e, em seguida, começa a detectar conexões locais para a instância myprimary em 127.0.0.1:5432 e para a instância myreadpool em 127.0.0.1:5433.

Como a inicialização ouve em portas personalizadas

O uso de portas personalizadas para o cliente do proxy de autenticação pode ser útil quando você precisa reservar a porta 5432 para outras conexões do PostgreSQL.

./alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary?port=5000" \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myreadpool?port=5001"

Neste exemplo, o cliente do proxy de autenticação autoriza a conexão seguindo a sequência normal de etapas de autorização e, em seguida, começa a detectar conexões locais para a instância myprimary em 127.0.0.1:5000 e para a instância myreadpool em 127.0.0.1:5001.

Como essas portas personalizadas são sequenciais, o mesmo efeito pode ser alcançado usando este comando de inicialização:

./alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary" \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myreadpool" \
  --port 5000

Ativação da escuta em um endereço IP personalizado

./alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary" \
  --address "0.0.0.0"

Neste exemplo, o cliente do proxy de autenticação autoriza a conexão seguindo a sequência normal de etapas de autorização e, em seguida, começa a detectar conexões locais para a instância myprimary em 0.0.0.0:5432.

Conectar um aplicativo a um banco de dados usando o proxy de autenticação do AlloyDB

Os exemplos a seguir mostram como conectar um aplicativo a um banco de dados usando o proxy de autenticação do AlloyDB.

O exemplo psql mostra como conectar uma ferramenta de linha de comando.

Para várias linguagens de programação, a conexão com uma instância do AlloyDB usando o proxy de autenticação do AlloyDB é idêntica à conexão com um Cloud SQL para PostgreSQL usando o proxy do Cloud SQL Auth. Portanto, os exemplos de linguagem aqui são os mesmos do Cloud SQL para PostgreSQL.

Esses exemplos são baseados em uma inicialização padrão do cliente do proxy de autenticação para que ele detecte conexões TCP locais em 127.0.0.1:5432.

psql

psql -h 127.0.0.1 -p 5432 -U DB_USER

Substitua DB_USER pelo usuário do banco de dados com o qual você quer se conectar, por exemplo, postgres.

Você vai receber uma solicitação para inserir a senha do usuário DB_USER.

Python

import os

import sqlalchemy


# connect_tcp_socket initializes a TCP connection pool
# for an AlloyDB instance.
def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    # 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.
    INSTANCE_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. 5432

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # postgresql+pg8000://<db_user>:<db_pass>@<INSTANCE_HOST>:<db_port>/<db_name>
        sqlalchemy.engine.url.URL.create(
            drivername="postgresql+pg8000",
            username=db_user,
            password=db_pass,
            host=INSTANCE_HOST,
            port=db_port,
            database=db_name,
        ),
        # ...
    )
    return pool

Java


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();

    // The following URL is equivalent to setting the config options below:
    // jdbc:postgresql://<INSTANCE_HOST>:<DB_PORT>/<DB_NAME>?user=<DB_USER>&password=<DB_PASS>l

    // Configure which instance and what database user to connect with.
    config.setJdbcUrl(String.format("jdbc:postgresql://%s:%s/%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "postgres"
    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

const Knex = require('knex');
const fs = require('fs');

// createTcpPool initializes a TCP connection pool for an AlloyDB cluster.
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 = {
    client: 'pg',
    connection: {
      host: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
      port: process.env.DB_PORT, // e.g. '5432'
      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'
    },
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return Knex(dbConfig);
};

Go

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

package alloydb

import (
	"database/sql"
	"fmt"
	"log"
	"os"

	// Note: If connecting using the App Engine Flex Go runtime, use
	// "github.com/jackc/pgx/stdlib" instead, since v4 requires
	// Go modules which are not supported by App Engine Flex.
	_ "github.com/jackc/pgx/v5/stdlib"
)

// connectTCPSocket initializes a TCP connection pool for an AlloyDB cluster.
func connectTCPSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Warning: %s environment variable not set.", 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' or IP Address of Cluster
		dbPort    = mustGetenv("DB_PORT")       // e.g. '5432'
		dbName    = mustGetenv("DB_NAME")       // e.g. 'my-database'
	)

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

using Npgsql;
using System;

namespace CloudSql
{
    public class PostgreSqlTcp
    {
        public static NpgsqlConnectionStringBuilder NewPostgreSqlTCPConnectionString()
        {
            // Equivalent connection string:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new NpgsqlConnectionStringBuilder()
            {
                // 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.
                Host = Environment.GetEnvironmentVariable("INSTANCE_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'

                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = SslMode.Disable,
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Ruby

Para conferir 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 conferir 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('pgsql:dbname=%s;host=%s', $dbName, $dbHost);

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