Connettiti utilizzando il proxy di autenticazione AlloyDB

Per stabilire connessioni autorizzate e criptate alle istanze AlloyDB, puoi utilizzare il proxy di autenticazione AlloyDB. Per saperne di più, consulta Informazioni sul proxy di autenticazione AlloyDB.

Per utilizzare il proxy di autenticazione AlloyDB, esegui diversi passaggi di configurazione una tantum, quindi avvia il client del proxy di autenticazione e utilizzalo per connetterti a un database.

Prima di iniziare

L'host client deve soddisfare questi requisiti:

• Il client deve avere visibilità di rete sulla rete Virtual Private Cloud (VPC) in cui risiedono le istanze a cui vuoi connetterti. Gli host client (come le istanze Compute Engine) in questa rete Virtual Private Cloud (VPC) hanno intrinsecamente questa visibilità di rete.

  Gli host client nelle reti esterne (reti on-premise o reti VPC diverse) hanno questa visibilità di rete se la rete VPC dell'istanza AlloyDB è connessa alla rete esterna utilizzando un tunnel Cloud VPN o un collegamento VLAN per Dedicated Interconnect o Partner Interconnect.

• Se l'host client ha una policy del firewall in uscita, deve consentire le connessioni in uscita alla porta 5433 sugli indirizzi IP delle istanze AlloyDB e le connessioni in uscita alla porta 443 (la porta HTTPS standard) a tutti gli indirizzi IP.

• Se utilizzi un'istanza Compute Engine come host client, deve avere l'ambito di accesso https://www.googleapis.com/auth/cloud-platform in modo da poter utilizzare l'API AlloyDB. Se necessario, modifica l'ambito di accesso in modo da includerlo.

Scarica il client del proxy di autenticazione

La macchina su cui scarichi il client del proxy di autenticazione dipende dal fatto che tu voglia connetterti alle istanze AlloyDB dall'interno o dall'esterno della rete VPC.

Se vuoi connetterti al cluster utilizzando l'accesso privato ai servizi, puoi scaricare il client del proxy di autenticazione su un'istanza di macchina virtuale (VM) Compute Engine in esecuzione all'interno della rete VPC che ha accesso privato ai servizi al tuo cluster.

Se intendi connetterti al cluster dall'esterno della rete VPC, la macchina su cui lo installi dipende dalla strategia di connessione esterna che utilizzi. Ad esempio, puoi installare il client del proxy di autenticazione su una macchina macOS o Windows locale per la tua applicazione, quindi utilizzare un server SOCKS in esecuzione all'interno della rete VPC AlloyDB come intermediario di connessione. Per saperne di più, consulta Connettersi a un cluster dall' esterno della rete VPC.

Nota: assicurati di utilizzare la versione più recente del client del proxy di autenticazione. Google rilascia nuove versioni del client del proxy di autenticazione ogni mese. Puoi trovare la versione attuale controllando la pagina delle release del client del proxy di autenticazione su GitHub.

Linux

64 bit (AMD)

1. Scarica il client del proxy di autenticazione:

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

2. Rendi eseguibile il client del proxy di autenticazione:

   chmod +x alloydb-auth-proxy

3. Aggiungi il client del proxy di autenticazione al tuo PATH:

   mkdir -p ~/.local/bin
   mv alloydb-auth-proxy ~/.local/bin/
   export PATH="$HOME/.local/bin:$PATH"

   Per rendere permanenti queste modifiche tra le sessioni, aggiungi export PATH="$HOME/.local/bin:$PATH" al file ~/.bashrc o ~/.zshrc.

32 bit (AMD)

1. Scarica il client del proxy di autenticazione:

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

2. Rendi eseguibile il client del proxy di autenticazione:

   chmod +x alloydb-auth-proxy

3. Aggiungi il client del proxy di autenticazione al tuo PATH:

   mkdir -p ~/.local/bin
   mv alloydb-auth-proxy ~/.local/bin/
   export PATH="$HOME/.local/bin:$PATH"

   Per rendere permanenti queste modifiche tra le sessioni, aggiungi export PATH="$HOME/.local/bin:$PATH" al file ~/.bashrc o ~/.zshrc.

64 bit (ARM)

1. Scarica il client del proxy di autenticazione:

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

2. Rendi eseguibile il client del proxy di autenticazione:

   chmod +x alloydb-auth-proxy

3. Aggiungi il client del proxy di autenticazione al tuo PATH:

   mkdir -p ~/.local/bin
   mv alloydb-auth-proxy ~/.local/bin/
   export PATH="$HOME/.local/bin:$PATH"

   Per rendere permanenti queste modifiche tra le sessioni, aggiungi export PATH="$HOME/.local/bin:$PATH" al file ~/.bashrc o ~/.zshrc.

32 bit (ARM)

1. Scarica il client del proxy di autenticazione:

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

2. Rendi eseguibile il client del proxy di autenticazione:

   chmod +x alloydb-auth-proxy

3. Aggiungi il client del proxy di autenticazione al tuo PATH:

   mkdir -p ~/.local/bin
   mv alloydb-auth-proxy ~/.local/bin/
   export PATH="$HOME/.local/bin:$PATH"

   Per rendere permanenti queste modifiche tra le sessioni, aggiungi export PATH="$HOME/.local/bin:$PATH" al file ~/.bashrc o ~/.zshrc.

macOS

ARM64

1. Scarica il client del proxy di autenticazione:

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

2. Rendi eseguibile il client del proxy di autenticazione:

   chmod +x alloydb-auth-proxy

3. Aggiungi il client del proxy di autenticazione al tuo PATH:

   mkdir -p ~/.local/bin
   mv alloydb-auth-proxy ~/.local/bin/
   export PATH="$HOME/.local/bin:$PATH"

   Per rendere permanenti queste modifiche tra le sessioni, aggiungi export PATH="$HOME/.local/bin:$PATH" al file ~/.bashrc o ~/.zshrc.

AMD64

1. Scarica il client del proxy di autenticazione:

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

2. Rendi eseguibile il client del proxy di autenticazione:

   chmod +x alloydb-auth-proxy

3. Aggiungi il client del proxy di autenticazione al tuo PATH:

   mkdir -p ~/.local/bin
   mv alloydb-auth-proxy ~/.local/bin/
   export PATH="$HOME/.local/bin:$PATH"

   Per rendere permanenti queste modifiche tra le sessioni, aggiungi export PATH="$HOME/.local/bin:$PATH" al file ~/.bashrc o ~/.zshrc.

Windows

64 bit

1. Fai clic con il tasto destro del mouse su https://storage.googleapis.com/alloydb-auth-proxy/v1.16.0/alloydb-auth-proxy-x64.exe e seleziona Salva link con nome per scaricare il client del proxy di autenticazione. Rinomina il file in alloydb-auth-proxy.exe.

2. Aggiungi il client del proxy di autenticazione al tuo PATH:

   New-Item -ItemType Directory -Force -Path "$HOME\bin"
   Move-Item -Path .\alloydb-auth-proxy.exe -Destination "$HOME\bin"
   $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
   [Environment]::SetEnvironmentVariable("Path", "$userPath;$HOME\bin", "User")
   

32 bit

1. Fai clic con il tasto destro del mouse su https://storage.googleapis.com/alloydb-auth-proxy/v1.16.0/alloydb-auth-proxy-x86.exe e seleziona Salva link con nome per scaricare il client del proxy di autenticazione. Rinomina il file in alloydb-auth-proxy.exe.

2. Aggiungi il client del proxy di autenticazione al tuo PATH:

   New-Item -ItemType Directory -Force -Path "$HOME\bin"
   Move-Item -Path .\alloydb-auth-proxy.exe -Destination "$HOME\bin"
   $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
   [Environment]::SetEnvironmentVariable("Path", "$userPath;$HOME\bin", "User")
   

Immagine Docker

Per comodità, in Artifact Registry sono disponibili diverse immagini container che contengono il client del proxy di autenticazione.

Puoi eseguire il pull dell'ultima immagine sulla tua macchina locale utilizzando Docker con il seguente comando:

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

Altri sistemi operativi

Per altri sistemi operativi non inclusi qui, puoi compilare il client del proxy di autenticazione dal codice sorgente.

Scegli l'entità IAM e preparala per l'autorizzazione

Il proxy di autenticazione AlloyDB supporta l'utilizzo di questi tipi di entità IAM per autorizzare le connessioni tra il client e un'istanza AlloyDB:

• Un service account gestito dall'utente. Puoi creare un service account IAM per la tua applicazione e poi autorizzare le connessioni utilizzando questo account.

  Google consiglia vivamente di utilizzare un account di servizio per l'autorizzazione negli ambienti di produzione.

• Il tuo account utente. Puoi utilizzare il tuo account utente IAM per autorizzare le connessioni.

  L'utilizzo del tuo account utente è comodo negli ambienti di sviluppo in cui gestisci le risorse AlloyDB utilizzando gcloud CLI, sviluppi il database utilizzando uno strumento come psql e sviluppi il codice dell'applicazione sullo stesso host.

• Il service account predefinito di Compute Engine. Se l'host client è un'istanza Compute Engine, puoi utilizzare il account di servizio predefinito di Compute Engine per autorizzare le connessioni.

Dopo aver scelto l'entità IAM da utilizzare, devi assicurarti che disponga delle autorizzazioni IAM richieste e che le relative credenziali siano disponibili sull'host client.

Autorizzazioni IAM obbligatorie

L'entità IAM che utilizzi per autorizzare le connessioni deve disporre delle autorizzazioni fornite dai ruoli predefiniti roles/alloydb.client (Client AlloyDB) e roles/serviceusage.serviceUsageConsumer (Service Usage Consumer).

Nota: il ruolo roles/alloydb.admin (Amministratore AlloyDB) fornisce anche le autorizzazioni richieste.

Per assegnare il ruolo Client AlloyDB a un'entità IAM:

• L'API Cloud Resource Manager deve essere abilitata nel Google Cloud progetto.

• Devi disporre del ruolo IAM di base roles/owner (Proprietario) nel Google Cloud progetto o di un ruolo che conceda queste autorizzazioni:

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

  Per ottenere queste autorizzazioni rispettando il principio del privilegio minimo, chiedi all'amministratore di concederti il ruolo roles/resourcemanager.projectIamAdmin (Amministratore IAM progetto).

Rendi disponibili le credenziali IAM sull'host client

La modalità di rendere disponibili le credenziali IAM sull'host client dipende dal tipo di entità IAM che utilizzi per autorizzare le connessioni:

• Service account gestito dall'utente

  Per fornire le credenziali IAM per un account di servizio gestito dall'utente, crea una chiave account di servizio in formato JSON e scaricala sull'host client. Quando avvii il client del proxy di autenticazione, specifica la posizione del file della chiave utilizzando il flag --credentials-file.

• Il tuo account utente

  Per fornire le credenziali IAM per il tuo account utente, installa Google Cloud CLI sull'host client e quindi esegui il gcloud auth application-default login comando per generare il file delle credenziali predefinite dell'applicazione (ADC):

  gcloud auth application-default login

  Quando avvii il client del proxy di autenticazione, questo rileva e utilizza automaticamente le credenziali del tuo account utente se non fornisci le credenziali del account di servizio gestito dall'utente.

• Service account predefinito di Compute Engine

  Se utilizzi un'istanza Compute Engine come host client, le credenziali del service account predefinito di Compute Engine sono già presenti sull'host. Quando avvii il client del proxy di autenticazione, questo rileva e utilizza automaticamente queste credenziali se le credenziali del account di servizio gestito dall'utente e dell'account utente non sono disponibili.

Raccogli gli URI di connessione per le istanze AlloyDB

Quando avvii il client del proxy di autenticazione, identifichi l'istanza o le istanze AlloyDB a cui vuoi connetterti utilizzando questo formato di URI di connessione:

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

Per visualizzare un elenco di tutti gli URI di connessione delle istanze, utilizza il comando gcloud CLI alloydb instances list.

Raccogli l'URI di connessione dell'istanza per ogni istanza a cui vuoi connetterti.

Avvia il client del proxy di autenticazione

Quando avvii il client del proxy di autenticazione, fornisci informazioni sulle istanze AlloyDB a cui connetterti e, se necessario, le informazioni sulle credenziali da utilizzare per autorizzare queste connessioni.

All'avvio, il client del proxy di autenticazione:

• Autorizza le connessioni alle istanze AlloyDB utilizzando le credenziali e le autorizzazioni IAM dell'entità IAM che hai configurato. Cerca le credenziali seguendo una sequenza specifica di passaggi.
• Autorizza automaticamente le connessioni IP pubbliche alla rete di origine, se l'istanza ha l'IP pubblico abilitato.
• Configura una connessione mTLS 1.3 privata al server del proxy di autenticazione di ogni istanza.
• Inizia ad ascoltare le richieste di connessione del client locale.

Per impostazione predefinita, il client del proxy di autenticazione rimane in ascolto delle connessioni TCP sull'indirizzo IP 127.0.0.1, a partire dalla porta 5432 e incrementando di un numero di porta per ogni istanza AlloyDB oltre la prima. Puoi specificare un indirizzo di ascolto e porte diversi quando avvii il client del proxy di autenticazione.

Avviso: fai attenzione quando associ il client del proxy di autenticazione a un'interfaccia esterna. Chiunque abbia accesso a questa interfaccia o porta è autorizzato a connettersi all'istanza.

Nota: Google consiglia di eseguire il client del proxy di autenticazione come servizio permanente negli ambienti di produzione.

Riga di 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 \ ]
    [ --disable-built-in-telemetry ]

Sostituisci quanto segue:

• INSTANCE_URI: l'URI di connessione dell'istanza di un'istanza AlloyDB a cui connetterti, specificato utilizzando questo formato:

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

  Puoi sostituire la porta di ascolto locale predefinita che il client del proxy di autenticazione utilizzerà per l'istanza aggiungendo il parametro di query port all'URI:

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

• (Facoltativo) PATH_TO_KEY_FILE: il percorso del file della chiave JSON del account di servizio gestito dall'utente da utilizzare per l'autorizzazione della connessione.

• (Facoltativo) OAUTH_ACCESS_TOKEN: un valore del token OAuth 2 da utilizzare per l'autorizzazione della connessione.

• (Facoltativo) INITIAL_PORT_NUMBER: il numero di porta iniziale da utilizzare al posto della porta predefinita 5432 quando si è in ascolto delle connessioni TCP locali.

• (Facoltativo) LOCAL_LISTENER_ADDRESS: l'indirizzo di ascolto da utilizzare al posto del valore predefinito 127.0.0.1 quando si è in ascolto delle connessioni TCP locali.

Il flag facoltativo --auto-iam-authn consente di eseguire automaticamente l'autenticazione all'istanza. Funziona solo per l'utente del database associato all'account IAM che esegue il client del proxy di autenticazione. Per saperne di più, consulta Eseguire l'autenticazione automaticamente utilizzando il proxy di autenticazione.

Il flag facoltativo --psc consente al proxy di autenticazione di connettersi a un'istanza con Private Service Connect abilitato. Per saperne di più sulla configurazione del DNS con Private Service Connect, consulta Configurare una zona gestita DNS e un record DNS.

Il flag facoltativo --public-ip consente al proxy di autenticazione di connettersi a un'istanza con IP pubblico abilitato utilizzando l'indirizzo IP pubblico dell'istanza. Per saperne di più sull'IP pubblico, consulta Connettersi utilizzando l'IP pubblico.

Il flag facoltativo --disable-built-in-telemetry disabilita il reporter di metriche interno utilizzato dal proxy di autenticazione per segnalare l'integrità della connessione e della rete. Per impostazione predefinita, il proxy di autenticazione segnala le sue operazioni interne al prefisso della metrica di sistema alloydb.googleapis.com. Queste metriche aiutano AlloyDB a migliorare le prestazioni e a identificare i problemi di connettività del client. Questa opzione è utile per le applicazioni che operano in ambienti in cui l'esportazione delle metriche in uscita è limitata. Per disattivare questa telemetria, utilizza questo flag.

Container Docker

Avvia il client del proxy di autenticazione utilizzando il comando docker run.

Se utilizzi le credenziali fornite dall'istanza Compute Engine, puoi utilizzare un comando simile al seguente:

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

Sostituisci quanto segue:

• PORT: la porta da utilizzare per le connessioni locali al client del proxy di autenticazione. Il valore predefinito è 5432.

• INSTANCE_URI: l'URI di connessione dell'istanza di un'istanza AlloyDB a cui connetterti, specificato utilizzando il seguente formato:

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

  Puoi sostituire la porta di ascolto locale predefinita che il client del proxy di autenticazione utilizza per l'istanza aggiungendo il parametro di query port all'URI:

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

Specifica sempre il prefisso 127.0.0.1 nel flag --publish in modo che il client del proxy di autenticazione non sia esposto all'esterno dell'host locale.

Il valore 0.0.0.0 nel flag --address è necessario per rendere l'ascoltatore accessibile dall'esterno del container Docker.

Per fornire le credenziali che hai archiviato in un file JSON locale, includi i flag --volume e --credentials-file quando esegui il 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

Sostituisci PATH_TO_KEY_FILE con il percorso del file della chiave JSON del account di servizio gestito dall'utente da utilizzare per l'autorizzazione della connessione.

Esempi di avvio

I seguenti esempi mostrano vari modi per avviare il client del proxy di autenticazione. Utilizzano questi URI di connessione dell'istanza di esempio:

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

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

Avvio di base

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

In questo esempio, il client del proxy di autenticazione autorizza la connessione seguendo la normale sequenza di passaggi di autorizzazione, quindi inizia ad ascoltare le connessioni locali all'istanza myprimary su 127.0.0.1:5432.

Avvio utilizzando un account di servizio gestito dall'utente

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

In questo esempio, il client del proxy di autenticazione autorizza la connessione utilizzando la chiave JSON del account di servizio gestito dall'utente archiviata in myappaccount/key.json, quindi inizia ad ascoltare le connessioni locali all'istanza myprimary su 127.0.0.1:5432.

Avvio della connessione a più istanze

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

In questo esempio, il client del proxy di autenticazione autorizza la connessione seguendo la normale sequenza di passaggi di autorizzazione, quindi inizia ad ascoltare le connessioni locali all'istanza myprimary su 127.0.0.1:5432 e all'istanza myreadpool su 127.0.0.1:5433.

Avvio dell'ascolto su porte personalizzate

L'utilizzo di porte personalizzate per il client del proxy di autenticazione può essere utile quando devi riservare la porta 5432 per altre connessioni 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"

In questo esempio, il client del proxy di autenticazione autorizza la connessione seguendo la normale sequenza di passaggi di autorizzazione , quindi inizia ad ascoltare le connessioni locali all'istanza myprimary su 127.0.0.1:5000 e all'istanza myreadpool su 127.0.0.1:5001.

Poiché queste porte personalizzate sono sequenziali, lo stesso effetto può essere ottenuto utilizzando questo comando di avvio:

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

Avvio dell'ascolto su un indirizzo IP personalizzato

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

In questo esempio, il client del proxy di autenticazione autorizza la connessione seguendo la normale sequenza di passaggi di autorizzazione, quindi inizia ad ascoltare le connessioni locali all'istanza myprimary su 0.0.0.0:5432.

Connetti un'applicazione a un database utilizzando il proxy di autenticazione AlloyDB

I seguenti esempi mostrano come connettere un'applicazione a un database utilizzando il proxy di autenticazione AlloyDB.

L'esempio psql fornisce un esempio di connessione di uno strumento a riga di comando.

Per diversi linguaggi di programmazione, la connessione a un'istanza AlloyDB utilizzando il proxy di autenticazione è identica alla connessione a Cloud SQL per PostgreSQL utilizzando il proxy di autenticazione Cloud SQL, quindi gli esempi di linguaggio sono gli stessi di quelli per Cloud SQL per PostgreSQL.

Questi esempi si basano su un avvio predefinito del client del proxy di autenticazione in modo che sia in ascolto delle connessioni TCP locali su 127.0.0.1:5432.

Nota: con un nuovo cluster, puoi connetterti come utente postgres utilizzando la password che hai specificato durante la creazione del cluster.

psql

psql -h 127.0.0.1 -p 5432 -U DB_USER

Sostituisci DB_USER con l'utente del database con cui vuoi connetterti, ad esempio postgres.

Ti verrà chiesto di inserire la password dell'utente 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);
};

Vai

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su 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#

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su 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

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su 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

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su 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);