Ligue-se através do proxy Auth do AlloyDB

Esta página mostra como configurar e usar o proxy Auth do AlloyDB para estabelecer ligações autorizadas e encriptadas a instâncias do AlloyDB. Para uma vista geral conceptual do proxy Auth, consulte o artigo Acerca do proxy Auth do AlloyDB.

Para usar o proxy Auth do AlloyDB, tem de executar vários passos de configuração únicos. Em seguida, inicia o cliente do proxy Auth e, depois, liga-se às bases de dados através dele:

1. Passos de configuração:
   1. Transfira o cliente do proxy de autorização para o anfitrião do cliente.
   2. Escolha o principal do Identity and Access Management (IAM) a usar para autorização, certifique-se de que tem as autorizações necessárias e que as respetivas credenciais estão disponíveis no seu anfitrião cliente.
   3. Recolha URIs de ligação para as instâncias do AlloyDB às quais quer estabelecer ligação.
2. Inicie o cliente do proxy de autorização no anfitrião do cliente.
3. Associe uma aplicação a uma base de dados abrindo uma ligação local ao cliente do proxy Auth.

Antes de começar

O anfitrião do cliente tem de cumprir os seguintes requisitos:

• Tem de ter visibilidade da rede para a rede de nuvem virtual privada (VPC) onde residem as instâncias às quais quer estabelecer ligação. Os anfitriões do cliente (como instâncias do Compute Engine) nesta rede da nuvem virtual privada (VPC) têm inerentemente esta visibilidade. Os anfitriões de clientes em redes externas (redes nas instalações ou redes VPC diferentes) têm esta visibilidade se a rede VPC da instância do AlloyDB tiver sido ligada à rede externa através de um túnel do Cloud VPN ou de uma associação de VLAN para a Interligação dedicada ou a Interligação de parceiro.

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

• Se estiver a usar uma instância do Compute Engine como anfitrião do cliente, tem de ter o âmbito de acesso https://www.googleapis.com/auth/cloud-platform para poder usar a API AlloyDB. Se necessário, altere o âmbito de acesso para incluir este âmbito.

Transfira o cliente do proxy Auth

A máquina na qual transfere o cliente do proxy Auth depende de querer estabelecer ligação às suas instâncias do AlloyDB a partir da respetiva rede VPC ou de fora desta.

Se quiser estabelecer ligação ao cluster através do acesso privado aos serviços, pode transferir o cliente do proxy de autenticação para uma instância de máquina virtual (VM) do Compute Engine em execução na rede VPC que tenha acesso privado aos serviços do cluster.

Se pretender estabelecer ligação ao cluster a partir de fora da VPC, a máquina na qual o instala depende da estratégia de ligação externa que usa. Por exemplo, pode instalar o cliente do proxy de autenticação numa máquina macOS ou Windows local para a sua aplicação e, em seguida, usar um servidor SOCKS em execução na sua rede VPC do AlloyDB como um intermediário de ligação. Para mais informações, consulte o artigo Estabeleça ligação a um cluster a partir de fora da respetiva VPC.

Nota: certifique-se de que está a usar a versão mais recente do cliente do proxy de autorização. A Google lança novas versões do cliente do proxy de autorização mensalmente. Pode encontrar a versão atual na página Auth Proxy client GitHub releases.

Linux

64 bits (AMD)

1. Transfira o cliente do proxy Auth:

   wget https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy.linux.amd64 -O alloydb-auth-proxy

2. Torne o cliente executável do proxy Auth:

   chmod +x alloydb-auth-proxy

32 bits (AMD)

1. Transfira o cliente do proxy Auth:

   wget https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy.linux.386 -O alloydb-auth-proxy

2. Torne o cliente executável do proxy Auth:

   chmod +x alloydb-auth-proxy

64 bits (ARM)

1. Transfira o cliente do proxy Auth:

   wget https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy.linux.arm64 -O alloydb-auth-proxy

2. Torne o cliente executável do proxy Auth:

   chmod +x alloydb-auth-proxy

32 bits (ARM)

1. Transfira o cliente do proxy Auth:

   wget https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy.linux.arm -O alloydb-auth-proxy

2. Torne o cliente executável do proxy Auth:

   chmod +x alloydb-auth-proxy

macOS

M1

1. Transfira o cliente do proxy Auth:

   curl -o alloydb-auth-proxy https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy.darwin.arm64

2. Torne o cliente executável do proxy Auth:

   chmod +x alloydb-auth-proxy

64 bits

1. Transfira o cliente do proxy Auth:

   curl -o alloydb-auth-proxy https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy.darwin.amd64

2. Torne o cliente executável do proxy Auth:

   chmod +x alloydb-auth-proxy

32 bits

1. Transfira o cliente do proxy Auth:

   curl -o alloydb-auth-proxy https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy.darwin.386

2. Torne o cliente executável do proxy Auth:

   chmod +x alloydb-auth-proxy

Windows

64 bits

Clique com o botão direito do rato em https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy-x64.exe e selecione Guardar link como para transferir o cliente do Auth Proxy. Mude o nome do ficheiro para alloydb-auth-proxy.exe.

32 bits

Clique com o botão direito do rato em https://storage.googleapis.com/alloydb-auth-proxy/v1.13.6/alloydb-auth-proxy-x86.exe e selecione Guardar link como para transferir o cliente do Auth Proxy. Mude o nome do ficheiro para alloydb-auth-proxy.exe.

Imagem de Docker

Para sua conveniência, estão disponíveis várias imagens de contentores que contêm o cliente do proxy de autorização no Artifact Registry.

Pode transferir a imagem mais recente para a sua máquina local através do Docker com o seguinte comando:

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

Outro SO

Para outros sistemas operativos não incluídos aqui, pode compilar o cliente do proxy de autorização a partir da origem.

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

O proxy Auth do AlloyDB suporta a utilização destes tipos de principais da IAM para autorizar ligações entre o seu cliente e uma instância do AlloyDB:

• Uma conta de serviço gerida pelo utilizador. Pode criar uma conta de serviço da IAM para a sua aplicação e, em seguida, autorizar ligações através da mesma.

  A Google recomenda vivamente que use uma conta de serviço para autorização em ambientes de produção.

• A sua conta de utilizador. Pode usar a sua própria conta de utilizador do IAM para autorizar ligações.

  A utilização da sua própria conta de utilizador é conveniente em ambientes de desenvolvimento onde está a gerir recursos do AlloyDB através da CLI gcloud, a desenvolver a base de dados com uma ferramenta como o psql e a desenvolver código de aplicação, tudo no mesmo anfitrião.

• A conta de serviço predefinida do Compute Engine. Se o anfitrião do cliente for uma instância do Compute Engine, pode usar a conta de serviço predefinida do Compute Engine para autorizar ligações.

Depois de escolher o principal de IAM a usar, tem de se certificar de que tem as autorizações de IAM necessárias e de que as respetivas credenciais estão disponíveis no seu anfitrião cliente.

Autorizações de IAM necessárias

O principal do IAM que usa para autorizar ligações tem de ter as autorizações fornecidas pelas funções predefinidas roles/alloydb.client (cliente do AlloyDB na nuvem) e roles/serviceusage.serviceUsageConsumer (consumidor de utilização de serviços).

Nota: a função roles/alloydb.admin (administrador do AlloyDB na nuvem) também fornece as autorizações necessárias.

Para atribuir a função de cliente do AlloyDB no Google Cloud a um principal do IAM:

• A API Cloud Resource Manager tem de estar ativada no Google Cloud projeto.

• Tem de ter a função de IAM básica roles/owner (proprietário) no projetoGoogle Cloud ou uma função que conceda estas autorizações:

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

  Para obter estas autorizações seguindo o princípio do menor privilégio, peça ao administrador para lhe conceder a função roles/resourcemanager.projectIamAdmin (administrador de IAM do projeto).

Disponibilize as credenciais da IAM no anfitrião do cliente

A forma como disponibiliza as credenciais do IAM no anfitrião do cliente depende do tipo de principal do IAM que está a usar para autorizar as ligações:

• Conta de serviço gerida pelo utilizador

  Para fornecer credenciais do IAM para uma conta de serviço gerida pelo utilizador, crie uma chave de conta de serviço no formato JSON e transfira-a para o anfitrião do cliente. Quando iniciar o cliente do proxy de autenticação, especifique a localização do ficheiro de chave através da flag --credentials-file.

• A sua conta de utilizador

  Para fornecer credenciais da IAM para a sua conta de utilizador, instale a CLI Google Cloud no seu anfitrião cliente e, de seguida, execute o comando gcloud init para inicializá-lo com a sua conta de utilizador. Quando inicia o cliente do proxy de autorização, este descobre e usa automaticamente as credenciais da sua conta de utilizador se não fornecer credenciais da conta de serviço geridas pelo utilizador.

• Conta de serviço predefinida do Compute Engine

  Se estiver a usar uma instância do Compute Engine como anfitrião do cliente, as credenciais da conta de serviço predefinida do Compute Engine já estão no anfitrião. Quando inicia o cliente do proxy de autenticação, este descobre e usa automaticamente estas credenciais se as credenciais da conta de serviço gerida pelo utilizador e da conta de utilizador não estiverem disponíveis.

Recolha URIs de ligação para as instâncias do AlloyDB

Quando inicia o cliente do proxy Auth, identifica a instância ou as instâncias do AlloyDB às quais quer estabelecer ligação através deste formato de URI de ligação:

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

Para ver uma lista de todos os URIs de ligação das suas instâncias, use o comando gcloud CLI alloydb instances list.

Recolha o URI de ligação da instância para cada instância à qual quer estabelecer ligação.

Inicie o cliente do proxy Auth

Quando inicia o cliente do proxy de autenticação, fornece-lhe informações sobre as instâncias do AlloyDB às quais se ligar e, se necessário, informações de credenciais a usar ao autorizar estas ligações.

Quando é iniciado, o cliente do proxy de autorização:

• Autoriza ligações a instâncias do AlloyDB através das credenciais e das autorizações da IAM do principal da IAM que configurou. Procura credenciais seguindo uma sequência específica de passos.
• Autoriza automaticamente as ligações IP públicas à rede de origem se a instância tiver o IP público ativado.
• Configura uma ligação privada TLS 1.3 ao servidor do proxy Auth de cada instância.
• Começa a ouvir pedidos de ligação de clientes locais.

Por predefinição, o cliente do proxy de autorização escuta as ligações TCP no endereço IP 127.0.0.1, começando na porta 5432 e incrementando um número de porta para cada instância do AlloyDB além da primeira. Pode especificar um endereço de ouvinte diferente e portas diferentes quando iniciar o cliente do proxy de autorização.

Aviso: tenha cuidado ao associar o cliente do proxy de autorização a uma interface externa. Qualquer pessoa com acesso a essa interface ou porta está autorizada a estabelecer ligação à sua instância.

Nota: a Google recomenda que execute o cliente do proxy de autorização como um serviço persistente em ambientes de produção.

Linha de comandos

./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 \ ]
    [ --disable-built-in-telemetry ]

Substitua o seguinte:

• INSTANCE_URI: o URI de ligação da instância de uma instância do AlloyDB à qual se ligar, especificado através deste formato:

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

  Pode substituir a porta do ouvinte local predefinida que o cliente do Auth Proxy 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 ficheiro de chave JSON da conta de serviço gerida pelo utilizador a usar para autorização da ligação.

• Opcional: OAUTH_ACCESS_TOKEN: um valor de token OAuth2 a usar para autorização de ligação.

• Opcional: INITIAL_PORT_NUMBER: o número da porta inicial a usar em vez da porta predefinida 5432 quando estiver a ouvir ligações TCP locais.

• Opcional: LOCAL_LISTENER_ADDRESS: o endereço do ouvinte a usar em vez da predefinição 127.0.0.1 quando estiver a ouvir ligações TCP locais.

A flag --auto-iam-authn opcional permite a autenticação automática na instância. Isto só funciona para o utilizador da base de dados associado à conta do IAM que está a executar o cliente do Auth Proxy. Para mais informações, consulte o artigo Autentique automaticamente através do proxy de autorização.

A flag --psc opcional permite que o proxy Auth se ligue a uma instância com o Private Service Connect ativado. Para mais informações sobre a configuração do DNS com o Private Service Connect, consulte o artigo Configure uma zona gerida de DNS e um registo de DNS.

A flag --public-ip opcional permite que o proxy Auth se ligue a uma instância com o IP público ativado através do endereço IP público da instância. Para mais informações sobre o IP público, consulte o artigo Estabeleça ligação através do IP público.

A flag --disable-built-in-telemetry opcional desativa o repórter de métricas interno que o proxy de autorização usa para criar relatórios sobre o estado de funcionamento da ligação e da rede. Por predefinição, o proxy de autorização envia relatórios sobre as respetivas operações internas para o prefixo de métricas do sistema alloydb.googleapis.com. Estas métricas ajudam o AlloyDB a melhorar o desempenho e a identificar problemas de conetividade do cliente. Esta opção é útil para aplicações que funcionam em ambientes onde a exportação de métricas de saída é restrita. Se preferir desativar esta telemetria, use esta flag.

Contentor Docker

Inicie o cliente do proxy de autorização com o comando docker run.

Se estiver a usar as credenciais fornecidas pela sua instância do Compute Engine, pode usar 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 o seguinte:

• PORT: a porta a usar para ligações locais ao cliente do proxy de autorização. A predefinição é 5432.

• INSTANCE_URI: O URI de ligação da instância de uma instância do AlloyDB à qual se ligar, especificado através do seguinte formato:

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

  Pode substituir a porta do ouvinte local predefinida que o cliente do Auth Proxy 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"

Especifique sempre o prefixo 127.0.0.1 no sinalizador --publish para que o cliente do proxy de autorização não seja exposto fora do anfitrião local.

O valor 0.0.0.0 na flag --address é necessário para tornar o ouvinte acessível a partir do exterior do contentor do Docker.

Para fornecer credenciais que armazenou num ficheiro JSON local, inclua as flags --volume e --credentials-file quando 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 para o ficheiro de chave JSON da conta de serviço gerida pelo utilizador a usar para a autorização da ligação.

Exemplos de arranque

Os exemplos seguintes mostram várias formas de iniciar o cliente do proxy de autorização. Usam estes URIs de ligação de instância de exemplo:

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

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

Início básico

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

Neste exemplo, o cliente do proxy de autorização autoriza a ligação seguindo a sua sequência normal de passos de autorização e, em seguida, começa a ouvir as ligações locais à instância myprimary em 127.0.0.1:5432.

Inicie com uma conta de serviço gerida pelo utilizador

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

Neste exemplo, o cliente do proxy de autorização autoriza a ligação através da chave JSON da conta de serviço gerida pelo utilizador armazenada em myappaccount/key.json e, em seguida, começa a ouvir as ligações locais à instância myprimary em 127.0.0.1:5432.

Início da ligação 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 autorização autoriza a ligação seguindo a sua sequência de passos de autorização normal e, em seguida, começa a ouvir as ligações locais à instância myprimary em 127.0.0.1:5432 e à instância myreadpool em 127.0.0.1:5433.

Inicie a escuta em portas personalizadas

A utilização de portas personalizadas para o cliente do proxy Auth pode ser útil quando precisa de reservar a porta 5432 para outras ligações 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 autorização autoriza a ligação seguindo a sua sequência de passos de autorização normal e, em seguida, começa a ouvir as ligações locais à instância myprimary em 127.0.0.1:5000 e à instância myreadpool em 127.0.0.1:5001.

Uma vez que estas portas personalizadas são sequenciais, pode conseguir o mesmo efeito usando este comando de arranque:

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

Inicie a escuta num 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 autorização autoriza a ligação seguindo a sua sequência normal de passos de autorização e, em seguida, começa a ouvir as ligações locais à instância myprimary em 0.0.0.0:5432.

Associe uma aplicação a uma base de dados através do proxy Auth do AlloyDB

Os exemplos seguintes mostram como pode ligar uma aplicação a uma base de dados usando o proxy Auth do AlloyDB.

O exemplo psql fornece um exemplo de ligação de uma ferramenta de linha de comandos.

A ligação a uma instância do AlloyDB através do proxy Auth do AlloyDB é, para várias linguagens de programação, idêntica à ligação a um Cloud SQL for PostgreSQL através do proxy Auth do Cloud SQL. Por isso, os exemplos de linguagem aqui são os mesmos que os do Cloud SQL for PostgreSQL.

Estes exemplos baseiam-se num início predefinido do cliente do proxy de autorização para que esteja a ouvir ligações TCP locais em 127.0.0.1:5432.

Nota: com um novo cluster, pode estabelecer ligação como utilizador postgres, usando a palavra-passe que especificou quando criou o cluster.

psql

psql -h 127.0.0.1 -p 5432 -U DB_USER

Substitua DB_USER pelo utilizador da base de dados ao qual quer estabelecer ligação, por exemplo, postgres.

Isto pede-lhe que introduza a palavra-passe do utilizador 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);
};

Ir

Para ver este fragmento no contexto de uma app Web, consulte o ficheiro 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 ver este fragmento no contexto de uma app Web, consulte o ficheiro 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 ver este fragmento no contexto de uma app Web, consulte o ficheiro 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 este fragmento no contexto de uma app Web, consulte o ficheiro 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);