Connettiti utilizzando il proxy di autenticazione AlloyDB

Questa pagina mostra come configurare e utilizzare il proxy di autenticazione AlloyDB per stabilire 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 proxy di autenticazione sull'host client.
   2. Scegli l'entità Identity and Access Management (IAM) da utilizzare per l'autorizzazione, assicurati che disponga delle autorizzazioni richieste e che le relative credenziali siano disponibili sull'host client.
   3. Raccogli gli URI di connessione per le istanze AlloyDB a cui vuoi connetterti.
2. Avvia il client proxy di autenticazione sull'host client.
3. Connetti 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 sulla rete Virtual Private Cloud (VPC) in cui si trovano 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à. Gli host client in reti esterne (reti on-premise o reti VPC diverse) hanno 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 firewall in uscita, deve consentire connessioni in uscita alla porta 5433 sugli indirizzi IP delle tue istanze AlloyDB e consentire 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 per includerlo.

Scarica il client proxy di autenticazione

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

Se vuoi connetterti al cluster utilizzando l'accesso privato ai servizi, puoi scaricare il client proxy di autenticazione su un'istanza di macchina virtuale (VM) Compute Engine in esecuzione all'interno della rete VPC che dispone dell'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 che utilizzi. Ad esempio, puoi installare il client 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 del relativo VPC.

Nota :assicurati di utilizzare la versione più recente del client Auth Proxy. Google rilascia nuove versioni del client proxy di autenticazione mensilmente. Puoi trovare la versione attuale controllando la pagina Release di GitHub del client Auth Proxy.

Linux

64 bit (AMD)

1. Scarica il client proxy di autenticazione:

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

2. Rendi eseguibile il client proxy di autenticazione:

   chmod +x alloydb-auth-proxy

32 bit (AMD)

1. Scarica il client proxy di autenticazione:

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

2. Rendi eseguibile il client proxy di autenticazione:

   chmod +x alloydb-auth-proxy

64 bit (ARM)

1. Scarica il client proxy di autenticazione:

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

2. Rendi eseguibile il client proxy di autenticazione:

   chmod +x alloydb-auth-proxy

32 bit (ARM)

1. Scarica il client proxy di autenticazione:

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

2. Rendi eseguibile il client proxy di autenticazione:

   chmod +x alloydb-auth-proxy

macOS

M1

1. Scarica il client proxy di autenticazione:

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

2. Rendi eseguibile il client proxy di autenticazione:

   chmod +x alloydb-auth-proxy

64 bit

1. Scarica il client proxy di autenticazione:

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

2. Rendi eseguibile il client proxy di autenticazione:

   chmod +x alloydb-auth-proxy

32 bit

1. Scarica il client proxy di autenticazione:

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

2. Rendi eseguibile il client proxy di autenticazione:

   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.13.6/alloydb-auth-proxy-x64.exe e seleziona Salva link con nome 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.13.6/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à, in Artifact Registry sono disponibili diverse immagini container che contengono il client Auth Proxy.

Puoi eseguire il pull dell'ultima immagine sulla tua macchina locale utilizzando Docker con questo 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 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 service account gestito dall'utente. Puoi creare un service account 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 è 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 ilaccount di serviziot 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 richieste

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

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

Per assegnare il ruolo Client Cloud AlloyDB 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 progettoGoogle Cloud o di un ruolo che conceda queste autorizzazioni:

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

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

Rendere 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:

• 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 Auth Proxy, specifica la posizione del file delle chiavi 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 gcloud init comando per inizializzarlo utilizzando il tuo account utente. Quando avvii il client Auth Proxy, 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 Compute Engine

  Se utilizzi un'istanza Compute Engine come host client, le credenziali per il service account Compute Engine predefinito sono già presenti sull'host. Quando avvii il client Auth Proxy, rileva e utilizza automaticamente queste credenziali se le credenziali deaccount di serviziont gestito dall'utente e dell'account utente non sono disponibili.

Raccogli gli URI di connessione per le istanze AlloyDB

Quando avvii il client 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 tue 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 proxy di autenticazione

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

All'avvio, il client 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 TLS 1.3 privata a ogni server proxy di autenticazione dell'istanza.
• Inizia ad ascoltare le richieste di connessione dei client locali.

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

Avviso: fai attenzione quando associ il client Auth Proxy a un'interfaccia esterna. Chiunque abbia accesso a questa interfaccia o porta è autorizzato a connettersi alla tua istanza.

Nota: Google consiglia di eseguire il client Auth Proxy 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 connettersi, specificato utilizzando questo formato:

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

  Puoi sostituire la porta del listener 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 della 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 anziché la porta predefinita 5432 durante l'ascolto delle connessioni TCP locali.

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

Il flag facoltativo --auto-iam-authn consente l'autenticazione automatica all'istanza. Funziona solo per l'utente del database associato all'account IAM che esegue il client Auth Proxy. Per maggiori informazioni, vedi 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 ulteriori informazioni 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 ulteriori informazioni sull'IP pubblico, consulta Connessione tramite IP pubblico.

Il flag facoltativo --disable-built-in-telemetry disattiva lo strumento di reporting delle metriche interno utilizzato dal proxy di autenticazione per generare report sullo stato della connessione e della rete. Per impostazione predefinita, Auth Proxy segnala le proprie 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à dei client. Questa opzione è utile per le applicazioni che operano in ambienti in cui l'esportazione delle metriche in uscita è limitata. Se preferisci disattivare questa telemetria, utilizza questo flag.

Container Docker

Avvia il client 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 Auth Proxy. Il valore predefinito è 5432.

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

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

  Puoi sostituire la porta del listener 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 è necessario 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 della connessione.

Esempi di startup

I seguenti esempi mostrano vari modi per avviare il client proxy di autenticazione. 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 sua normale sequenza di passaggi di autorizzazione 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 sua normale sequenza di passaggi di autorizzazione e poi 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 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 proxy di autenticazione autorizza la connessione seguendo la sua normale sequenza di passaggi di autorizzazione e poi 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, è possibile ottenere lo stesso effetto 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 proxy di autenticazione autorizza la connessione seguendo la sua normale sequenza di passaggi di autorizzazione 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 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.

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

Questi esempi si basano su un avvio predefinito del client 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 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 a cui vuoi connetterti, ad esempio postgres.

Ti viene 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);