Connettiti utilizzando il proxy di autenticazione AlloyDB

Questa pagina mostra come configurare e utilizzare il proxy di autenticazione AlloyDB per effettuare connessioni autorizzate e criptate alle istanze AlloyDB. Per una panoramica concettuale del proxy di autenticazione, consulta Informazioni sul proxy di autenticazione AlloyDB.

Per utilizzare il proxy di autenticazione AlloyDB, devi eseguire diversi passaggi di configurazione una tantum, quindi avviare il client del proxy di autenticazione e connetterti ai database utilizzandolo:

1. Passaggi di configurazione:
   1. Scarica il client Auth Proxy sull'host client.
   2. Scegli l'entità IAM (Identity and Access Management) da utilizzare per l'autorizzazione, assicurati che disponga delle autorizzazioni richieste e che le sue credenziali siano disponibili sull'host client.
   3. Raccogli gli URI di connessione per le istanze AlloyDB a cui vuoi connetterti.
2. Avvia il client Auth Proxy sull'host client.
3. Collega un'applicazione a un database aprendo una connessione locale al client proxy di autenticazione.

Prima di iniziare

L'host client deve soddisfare i seguenti requisiti:

• Deve avere visibilità di rete alla rete Virtual Private Cloud (VPC) dove si trovano le istanze a cui vuoi connetterti. Gli host client (come le istanze Compute Engine) in questa rete VPC (Virtual Private Cloud) hanno intrinsecamente questa visibilità. Gli host client nelle reti esterne (in reti on-premise o in reti VPC diverse) dispongono di questa visibilità se la rete VPC dell'istanza AlloyDB è stata connessa alla rete esterna utilizzando un tunnel Cloud VPN o un collegamento VLAN per Dedicated Interconnect o Partner Interconnect.

• Se l'host client ha un criterio 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 per poter utilizzare l'API AlloyDB Admin. Se necessario, modificane l'ambito di accesso per includere questo ambito.

Scarica il client Auth Proxy

La macchina su cui scarichi il client Auth Proxy dipende dal fatto che tu voglia connetterti alle tue istanze AlloyDB dall'interno o dall'esterno della rete VPC.

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

Se intendi connetterti al cluster dall'esterno del VPC, la macchina su cui lo installi dipende dalla strategia di connessione esterna utilizzata. Ad esempio, puoi installare il client proxy di autenticazione su una macchina macOS o Windows locale per la tua applicazione e poi utilizzare un server SOCKS in esecuzione nella rete VPC di AlloyDB come intermediario di connessione. Per ulteriori informazioni, consulta Connettersi a un cluster dall'esterno del relativo VPC.

Linux

64 bit (AMD)

1. Scarica il client Auth Proxy:

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

2. Rendi eseguibile il client Auth Proxy:

   chmod +x alloydb-auth-proxy

32 bit (AMD)

1. Scarica il client Auth Proxy:

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

2. Rendi eseguibile il client Auth Proxy:

   chmod +x alloydb-auth-proxy

64 bit (ARM)

1. Scarica il client Auth Proxy:

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

2. Rendi eseguibile il client Auth Proxy:

   chmod +x alloydb-auth-proxy

32 bit (ARM)

1. Scarica il client Auth Proxy:

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

2. Rendi eseguibile il client Auth Proxy:

   chmod +x alloydb-auth-proxy

macOS

M1

1. Scarica il client Auth Proxy:

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

2. Rendi eseguibile il client Auth Proxy:

   chmod +x alloydb-auth-proxy

64 bit

1. Scarica il client Auth Proxy:

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

2. Rendi eseguibile il client Auth Proxy:

   chmod +x alloydb-auth-proxy

32 bit

1. Scarica il client Auth Proxy:

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

2. Rendi eseguibile il client Auth Proxy:

   chmod +x alloydb-auth-proxy

Windows

64 bit

Fai clic con il tasto destro del mouse su https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x64.exe e seleziona Salva link come per scaricare il client Auth Proxy. Rinomina il file in alloydb-auth-proxy.exe.

32 bit

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

Immagine Docker

Per comodità, diverse immagini container contenenti il client Auth Proxy sono disponibili in Container Registry.

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

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

Altro sistema operativo

Per altri sistemi operativi non inclusi qui, puoi compilare il client Auth Proxy 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 account di servizio gestito dall'utente. Puoi creare un account di servizio IAM per la tua applicazione e poi autorizzare le connessioni utilizzandolo.

  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 è pratico negli ambienti di sviluppo in cui gestisci le risorse AlloyDB utilizzando l'interfaccia a riga di comando gcloud, sviluppi il database utilizzando uno strumento come psql e sviluppi il codice dell'applicazione tutto sullo stesso host.

• L'account di servizio predefinito Compute Engine. Se l'host client è un'istanza Compute Engine, puoi utilizzare l'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 sue credenziali siano disponibili sull'host client.

Autorizzazioni IAM richieste

L'entità IAM utilizzata per autorizzare le connessioni deve disporre delle autorizzazioni fornite dai ruoli predefiniti roles/alloydb.client (client Cloud AlloyDB) e roles/serviceusage.serviceUsageConsumer (consumatore di utilizzo del servizio).

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

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

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

• Devi disporre del ruolo IAM di base roles/owner (Proprietario) nel progetto Google Cloud o di un ruolo che conceda le seguenti 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

Il modo in cui rendi disponibili le credenziali IAM sull'host client dipende dal tipo di entità IAM che utilizzi per autorizzare le connessioni:

• Account di servizio gestito dall'utente

  Per fornire le credenziali IAM per un account di servizio gestito dall'utente, crea una chiave dell'account di servizio in formato JSON e scaricala nell'host client. Quando avvii il client Auth Proxy, 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 poi esegui il comando gcloud init per inizializzalo utilizzando il tuo account utente. Quando avvii il client Auth Proxy, questo rileva e utilizza automaticamente le credenziali del tuo account utente se non fornisci le credenziali dell'account di servizio gestite dall'utente.

• Account di servizio predefinito Compute Engine

  Se utilizzi un'istanza Compute Engine come host client, le credenziali per l'account di servizio predefinito di Compute Engine sono già presenti sull'host. Quando avvii il client Auth Proxy, vengono rilevate e utilizzate automaticamente queste credenziali se le credenziali dell'account utente e dell'account di servizio gestite dall'utente non sono disponibili.

Raccogliere gli URI di connessione per le istanze AlloyDB

Quando avvii il client Auth Proxy, identifica l'istanza o le istanze AlloyDB a cui vuoi connetterti utilizzando questo formato dell'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 tue istanze, utilizza il comando alloydb instances list gcloud CLI.

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

Avvia il client Auth Proxy

Quando avvii il client Auth Proxy, 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 Auth Proxy:

• 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 con IP pubblico alla rete di origine, se l'istanza ha l'IP pubblico abilitato.
• Configura una connessione TLS 1.3 privata al server proxy di autenticazione di ogni istanza.
• Inizia a monitorare le richieste di connessione dei client locali.

Per impostazione predefinita, il client Auth Proxy ascolta le connessioni TCP sull'indirizzo IP 127.0.0.1, a partire dalla porta 5432 e incrementando il numero di porta per ogni istanza AlloyDB successiva alla prima. Puoi specificare un indirizzo di listener e porte diverse quando avvii il client Auth Proxy.

Avviso: fai attenzione quando leghi il client Auth Proxy a un'interfaccia esterna. Chiunque abbia accesso a quell'interfaccia o porta è autorizzato a connettersi all'istanza.

Nota: Google consiglia di eseguire il client Auth Proxy come servizio persistente 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]

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 Auth Proxy 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 dell'account di servizio gestito dall'utente da utilizzare per l'autorizzazione di connessione.

• Facoltativo: OAUTH_ACCESS_TOKEN: un valore del token OAuth2 da utilizzare per l'autorizzazione della connessione.

• (Facoltativo) INITIAL_PORT_NUMBER: il numero di porta iniziale da utilizzare invece della porta predefinita 5432 quando si ascoltano le connessioni TCP locali.

• (Facoltativo) LOCAL_LISTENER_ADDRESS: l'indirizzo del listener da utilizzare invece del valore predefinito 127.0.0.1 quando si ascoltano le connessioni TCP locali.

Il flag facoltativo --auto-iam-authn consente l'autenticazione automatica all'istanza. Questo funziona solo per l'utente del database associato all'account IAM su cui è in esecuzione il client Auth Proxy. Per maggiori informazioni, vedi Eseguire l'autenticazione automaticamente utilizzando Auth Proxy.

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

Il flag facoltativo --public-ip consente al proxy di autenticazione di connettersi a un'istanza con l'IP pubblico abilitato utilizzando l'indirizzo IP pubblico dell'istanza. Per ulteriori informazioni sull'IP pubblico, consulta Eseguire la connessione utilizzando l'IP pubblico.

Container Docker

Avvia il client Auth Proxy 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 Auth Proxy. 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 utilizzata dal client Auth Proxy 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 Auth Proxy non sia esposto all'esterno dell'host locale.

Il valore 0.0.0.0 nel flag --address è obbligatorio per rendere il listener accessibile dall'esterno del contenitore 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 dell'account di servizio gestito dall'utente da utilizzare per l'autorizzazione di connessione.

Esempi di avvio

Gli esempi seguenti mostrano vari modi per avviare il client Auth Proxy. Utilizzano questi URI di connessione all'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 proxy di autenticazione autorizza la connessione seguendo la normale sequenza di passaggi di autenticazione e poi 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 proxy di autenticazione autorizza la connessione utilizzando la chiave JSON dell'account di servizio gestito dall'utente archiviata in myappaccount/key.json e poi 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 proxy di autenticazione autorizza la connessione seguendo la normale sequenza di passaggi di autenticazione e poi inizia a monitorare 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 proxy di autenticazione può essere utile quando devi prenotare 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 proxy di autenticazione autorizza la connessione seguendo la normale sequenza di passaggi di autenticazione e poi inizia a monitorare 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

Avviare l'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 proxy di autenticazione autorizza la connessione seguendo la normale sequenza di passaggi di autenticazione e poi inizia ad ascoltare le connessioni locali all'istanza myprimary su 0.0.0.0:5432.

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

Gli esempi riportati di seguito mostrano come collegare 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.

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

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

Nota: con un nuovo cluster, puoi connetterti come utente postgres utilizzando la password specificata 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);