Se connecter à l'aide du proxy d'authentification AlloyDB

Cette page explique comment configurer et utiliser le proxy d'authentification AlloyDB pour établir des connexions autorisées et chiffrées aux instances AlloyDB. Pour obtenir une présentation conceptuelle du proxy d'authentification, consultez la page À propos du proxy d'authentification AlloyDB.

Pour utiliser le proxy d'authentification AlloyDB, vous devez effectuer plusieurs étapes de configuration uniques, puis démarrer le client du proxy d'authentification, puis vous connecter aux bases de données à l'aide de celui-ci:

  1. Étapes de configuration :
    1. Téléchargez le client du proxy d'authentification sur votre hôte client.
    2. Choisissez le compte principal IAM à utiliser pour l'autorisation, assurez-vous qu'il dispose des autorisations requises et vérifiez que ses identifiants sont disponibles sur votre hôte client.
    3. Récupérez les URI de connexion pour les instances AlloyDB auxquelles vous souhaitez vous connecter.
  2. Démarrez le client du proxy d'authentification sur votre hôte client.
  3. Connectez une application à une base de données en ouvrant une connexion locale au client du proxy d'authentification.

Avant de commencer

    L'hôte client doit respecter les conditions suivantes:

    • Il doit avoir une visibilité réseau sur le réseau cloud privé virtuel (VPC) sur lequel résident les instances auxquelles vous souhaitez vous connecter. Les hôtes clients (comme les instances Compute Engine) de ce réseau cloud privé virtuel (VPC) disposent de cette visibilité par nature. Les hôtes clients sur les réseaux externes (réseaux sur site ou différents réseaux VPC) bénéficient de cette visibilité si le réseau VPC de l'instance AlloyDB a été connecté au réseau externe à l'aide d'un tunnel Cloud VPN ou d'un rattachement VLAN pour Dedicated Interconnect ou Partner Interconnect.

    • Si l'hôte client dispose d'une règle de pare-feu sortante, il doit autoriser les connexions sortantes sur le port 5433 sur les adresses IP de vos instances AlloyDB et autoriser les connexions sortantes sur le port 443 (port HTTPS standard) vers toutes les adresses IP.

    • Si vous utilisez une instance Compute Engine comme hôte client, elle doit disposer du niveau d'accès https://www.googleapis.com/auth/cloud-platform pour pouvoir utiliser l'API AlloyDB Admin. Si nécessaire, modifiez son champ d'application pour inclure ce champ.

Télécharger le client du proxy d'authentification

La machine sur laquelle vous téléchargez le client du proxy d'authentification dépend de votre choix de vous connecter à vos instances AlloyDB depuis le réseau VPC ou en dehors de celui-ci.

Si vous souhaitez vous connecter à votre cluster à l'aide de l'accès aux services privés, vous pouvez télécharger le client du proxy d'authentification sur une instance de machine virtuelle (VM) Compute Engine exécutée sur le réseau VPC disposant d'un accès aux services privés à votre cluster.

Si vous souhaitez vous connecter à votre cluster en dehors du VPC, la machine sur laquelle vous l'installez dépend de la stratégie de connexion externe que vous utilisez. Par exemple, vous pouvez installer le client du proxy d'authentification sur une machine macOS ou Windows locale pour votre application, puis utiliser un serveur SOCKS exécuté sur votre réseau VPC AlloyDB comme intermédiaire de connexion. Pour en savoir plus, consultez Se connecter à un cluster en dehors de son VPC.

Linux

64 bits (AMD)

  1. Téléchargez le client du proxy d'authentification:

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

  2. Rendez le client du proxy d'authentification exécutable:

    chmod +x alloydb-auth-proxy

32 bits (AMD)

  1. Téléchargez le client du proxy d'authentification:

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

  2. Rendez le client du proxy d'authentification exécutable:

    chmod +x alloydb-auth-proxy

64 bits (ARM)

  1. Téléchargez le client du proxy d'authentification:

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

  2. Rendez le client du proxy d'authentification exécutable:

    chmod +x alloydb-auth-proxy

32 bits (ARM)

  1. Téléchargez le client du proxy d'authentification:

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

  2. Rendez le client du proxy d'authentification exécutable:

    chmod +x alloydb-auth-proxy

macOS

M1

  1. Téléchargez le client du proxy d'authentification:

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

  2. Rendez le client du proxy d'authentification exécutable:

    chmod +x alloydb-auth-proxy

64 bits

  1. Téléchargez le client du proxy d'authentification:

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

  2. Rendez le client du proxy d'authentification exécutable:

    chmod +x alloydb-auth-proxy

32 bits

  1. Téléchargez le client du proxy d'authentification:

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

  2. Rendez le client du proxy d'authentification exécutable:

    chmod +x alloydb-auth-proxy

Windows

64 bits

Effectuez un clic droit sur https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x64.exe et sélectionnez Enregistrer le lien sous pour télécharger le client du proxy d'authentification. Renommez le fichier en alloydb-auth-proxy.exe.

32 bits

Effectuez un clic droit sur https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x86.exe et sélectionnez Enregistrer le lien sous pour télécharger le client du proxy d'authentification. Renommez le fichier en alloydb-auth-proxy.exe.

Image Docker

Pour plus de commodité, plusieurs images de conteneur contenant le client du proxy d'authentification sont disponibles dans Container Registry.

Vous pouvez extraire la dernière image sur votre ordinateur local en utilisant Docker avec la commande suivante :

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

Autres systèmes d'exploitation

Pour les autres systèmes d'exploitation non inclus ici, vous pouvez compiler le client du proxy d'authentification à partir de la source.

Choisir le compte principal IAM et le préparer à l'autorisation

Le proxy d'authentification AlloyDB accepte l'utilisation de ces types de principes IAM pour autoriser les connexions entre votre client et une instance AlloyDB:

  • Un compte de service géré par l'utilisateur Vous pouvez créer un compte de service IAM pour votre application, puis autoriser les connexions à l'aide de celui-ci.

    Google vous recommande vivement d'utiliser un compte de service pour l'autorisation dans les environnements de production.

  • Votre compte utilisateur Vous pouvez utiliser votre propre compte utilisateur IAM pour autoriser les connexions.

    L'utilisation de votre propre compte utilisateur est pratique dans les environnements de développement où vous gérez les ressources AlloyDB à l'aide de la CLI gcloud, développez la base de données à l'aide d'un outil tel que psql et développez le code d'application sur le même hôte.

  • Compte de service Compute Engine par défaut Si l'hôte client est une instance Compute Engine, vous pouvez utiliser le compte de service par défaut de Compute Engine pour autoriser les connexions.

Après avoir choisi le principal IAM à utiliser, vous devez vous assurer qu'il dispose des autorisations IAM requises et que ses identifiants sont disponibles sur votre hôte client.

Autorisations IAM requises

Le compte principal IAM que vous utilisez pour autoriser les connexions doit disposer des autorisations fournies par les rôles prédéfinis roles/alloydb.client (client Cloud AlloyDB) et roles/serviceusage.serviceUsageConsumer (consommateur d'utilisation des services).

Pour attribuer le rôle de client Cloud AlloyDB à un principal IAM:

  • L'API Cloud Resource Manager doit être activée dans le projet Google Cloud.

  • Vous devez disposer du rôle IAM de base roles/owner (Propriétaire) dans le projet Google Cloud ou d'un rôle qui accorde les autorisations suivantes:

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

    Pour obtenir ces autorisations tout en suivant le principe du moindre privilège, demandez à votre administrateur de vous attribuer le rôle roles/resourcemanager.projectIamAdmin (administrateur IAM du projet).

Rendre les identifiants IAM disponibles sur l'hôte client

La façon dont vous mettez à disposition les identifiants IAM sur l'hôte client dépend du type de compte principal IAM que vous utilisez pour autoriser les connexions:

  • Compte de service géré par l'utilisateur

    Pour fournir des identifiants IAM pour un compte de service géré par l'utilisateur, créez une clé de compte de service au format JSON et téléchargez-la sur votre hôte client. Lorsque vous démarrez le client du proxy d'authentification, spécifiez l'emplacement du fichier de clé à l'aide de l'indicateur --credentials-file.

  • Votre compte utilisateur

    Pour fournir des identifiants IAM pour votre compte utilisateur, installez Google Cloud CLI sur votre hôte client, puis exécutez la commande gcloud init pour l'initialiser à l'aide de votre compte utilisateur. Lorsque vous démarrez le client Auth Proxy, il détecte et utilise automatiquement les identifiants de votre compte utilisateur si vous ne fournissez pas d'identifiants de compte de service gérés par l'utilisateur.

  • Compte de service Compute Engine par défaut

    Si vous utilisez une instance Compute Engine comme hôte client, les identifiants du compte de service Compute Engine par défaut sont déjà sur l'hôte. Lorsque vous démarrez le client Auth Proxy, il détecte et utilise automatiquement ces identifiants si les identifiants du compte de service et du compte utilisateur gérés par l'utilisateur ne sont pas disponibles.

Récupérer les URI de connexion des instances AlloyDB

Lorsque vous démarrez le client du proxy d'authentification, vous identifiez l'instance ou les instances AlloyDB auxquelles vous souhaitez vous connecter à l'aide de ce format d'URI de connexion:

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

Pour afficher la liste de tous les URI de connexion de vos instances, utilisez la commande alloydb instances list de la gcloud CLI.

Rassemblez l'URI de connexion de l'instance pour chaque instance à laquelle vous souhaitez vous connecter.

Démarrer le client du proxy d'authentification

Lorsque vous démarrez le client du proxy d'authentification, vous lui fournissez des informations sur les instances AlloyDB auxquelles vous souhaitez vous connecter et, si nécessaire, des informations d'identification à utiliser lors de l'autorisation de ces connexions.

Au démarrage, le client du proxy d'authentification:

  • Autorise les connexions aux instances AlloyDB à l'aide des identifiants et des autorisations IAM du principal IAM que vous avez configuré. Il recherche des identifiants en suivant une séquence spécifique d'étapes.
  • Autorise automatiquement les connexions par adresse IP publique au réseau source, si l'adresse IP publique est activée pour l'instance.
  • Configure une connexion TLS 1.3 privée au serveur de proxy d'authentification de chaque instance.
  • Commence à écouter les requêtes de connexion des clients locaux.

Par défaut, le client du proxy d'authentification écoute les connexions TCP sur l'adresse IP 127.0.0.1, à partir du port 5432 et en incrémentant d'un numéro de port pour chaque instance AlloyDB au-delà de la première. Vous pouvez spécifier une adresse d'écouteur et des ports différents lorsque vous démarrez le client du proxy d'authentification.

Ligne de commande

./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]

Remplacez les éléments suivants :

  • INSTANCE_URI: URI de connexion d'une instance AlloyDB à laquelle se connecter, spécifié à l'aide du format suivant:

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

    Vous pouvez remplacer le port d'écouteur local par défaut que le client du proxy d'authentification utilisera pour l'instance en ajoutant le paramètre de requête port à l'URI:

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

  • Facultatif: PATH_TO_KEY_FILE: chemin d'accès au fichier de clé JSON du compte de service géré par l'utilisateur à utiliser pour l'autorisation de connexion.

  • Facultatif: OAUTH_ACCESS_TOKEN: valeur du jeton OAuth2 à utiliser pour l'autorisation de la connexion.

  • Facultatif: INITIAL_PORT_NUMBER: numéro de port de départ à utiliser au lieu du port par défaut 5432 lors de l'écoute des connexions TCP locales.

  • Facultatif: LOCAL_LISTENER_ADDRESS: adresse de l'écouteur à utiliser au lieu de 127.0.0.1 par défaut lors de l'écoute des connexions TCP locales.

L'indicateur --auto-iam-authn facultatif permet une authentification automatique à l'instance. Cette méthode ne fonctionne que pour l'utilisateur de la base de données associé au compte IAM qui exécute le client du proxy d'authentification. Pour en savoir plus, consultez la section S'authentifier automatiquement à l'aide du proxy d'authentification.

L'option --psc facultative permet au proxy d'authentification de se connecter à une instance sur laquelle Private Service Connect est activé. Pour en savoir plus sur la configuration du DNS avec Private Service Connect, consultez Configurer une zone DNS gérée et un enregistrement DNS.

L'indicateur --public-ip facultatif permet au proxy d'authentification de se connecter à une instance dont l'adresse IP publique est activée à l'aide de l'adresse IP publique de l'instance. Pour en savoir plus sur les adresses IP publiques, consultez Se connecter à l'aide d'une adresse IP publique.

Conteneur Docker

Démarrez le client du proxy Auth à l'aide de la commande docker run.

Si vous utilisez les identifiants fournis par votre instance Compute Engine, vous pouvez utiliser une commande semblable à celle-ci:

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

Remplacez les éléments suivants :

  • PORT: port à utiliser pour les connexions locales au client du proxy d'authentification. La valeur par défaut est 5432.

  • INSTANCE_URI: URI de connexion d'une instance AlloyDB à laquelle se connecter, spécifié au format suivant:

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

    Vous pouvez remplacer le port d'écouteur local par défaut que le client du proxy d'authentification utilise pour l'instance en ajoutant le paramètre de requête port à l'URI:

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

Spécifiez toujours le préfixe 127.0.0.1 dans l'indicateur --publish afin que le client du proxy d'authentification ne soit pas exposé en dehors de l'hôte local.

La valeur 0.0.0.0 dans l'indicateur --address est requise pour rendre l'écouteur accessible de l'extérieur du conteneur Docker.

Pour fournir des identifiants que vous avez stockés dans un fichier JSON local, incluez les indicateurs --volume et --credentials-file lorsque vous exécutez la commande 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

Remplacez PATH_TO_KEY_FILE par le chemin d'accès au fichier de clé JSON du compte de service géré par l'utilisateur à utiliser pour l'autorisation de connexion.

Exemples de démarrage

Les exemples suivants présentent différentes manières de démarrer le client Auth Proxy. Ils utilisent les exemples d'URI de connexion d'instance suivants:

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

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

Démarrage de base

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

Dans cet exemple, le client du proxy d'authentification autorise la connexion en suivant sa séquence normale d'étapes d'autorisation, puis commence à écouter les connexions locales à l'instance myprimary sur 127.0.0.1:5432.

Démarrage à l'aide d'un compte de service géré par l'utilisateur

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

Dans cet exemple, le client du proxy d'authentification autorise la connexion à l'aide de la clé JSON du compte de service géré par l'utilisateur stockée dans myappaccount/key.json, puis commence à écouter les connexions locales à l'instance myprimary sur 127.0.0.1:5432.

Démarrage de la connexion à plusieurs instances

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

Dans cet exemple, le client du proxy d'authentification autorise la connexion en suivant sa séquence normale d'étapes d'autorisation, puis commence à écouter les connexions locales à l'instance myprimary sur 127.0.0.1:5432 et à l'instance myreadpool sur 127.0.0.1:5433.

Écoute au démarrage sur des ports personnalisés

L'utilisation de ports personnalisés pour le client du proxy d'authentification peut être utile lorsque vous devez réserver le port 5432 pour d'autres connexions 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"

Dans cet exemple, le client du proxy d'authentification autorise la connexion en suivant sa séquence normale d'étapes d'autorisation, puis commence à écouter les connexions locales à l'instance myprimary sur 127.0.0.1:5000 et à l'instance myreadpool sur 127.0.0.1:5001.

Étant donné que ces ports personnalisés sont séquentiels, le même effet peut être obtenu à l'aide de la commande de démarrage suivante:

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

Écoute de démarrage sur une adresse IP personnalisée

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

Dans cet exemple, le client du proxy d'authentification autorise la connexion en suivant sa séquence normale d'étapes d'autorisation, puis commence à écouter les connexions locales à l'instance myprimary sur 0.0.0.0:5432.

Connecter une application à une base de données à l'aide du proxy d'authentification AlloyDB

Les exemples suivants montrent comment connecter une application à une base de données à l'aide du proxy d'authentification AlloyDB.

L'exemple psql illustre la connexion d'un outil de ligne de commande.

Pour plusieurs langages de programmation, la connexion à une instance AlloyDB à l'aide du proxy d'authentification AlloyDB est identique à la connexion à une instance Cloud SQL pour PostgreSQL à l'aide du proxy d'authentification Cloud SQL. Par conséquent, les exemples de langages présentés ici sont les mêmes que ceux pour Cloud SQL pour PostgreSQL.

Ces exemples sont basés sur un démarrage par défaut du client du proxy d'authentification afin qu'il écoute les connexions TCP locales sur 127.0.0.1:5432.

psql

psql -h 127.0.0.1 -p 5432 -U DB_USER

Remplacez DB_USER par l'utilisateur de la base de données avec lequel vous souhaitez vous connecter (par exemple, postgres).

Vous êtes alors invité à saisir le mot de passe de l'utilisateur DB_USER.

Python

import os

import sqlalchemy


# connect_tcp_socket initializes a TCP connection pool
# for an AlloyDB instance.
def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    # Note: Saving credentials in environment variables is convenient, but not
    # secure - consider a more secure solution such as
    # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
    # keep secrets safe.
    INSTANCE_HOST = os.environ[
        "INSTANCE_HOST"
    ]  # e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
    db_user = os.environ["DB_USER"]  # e.g. 'my-db-user'
    db_pass = os.environ["DB_PASS"]  # e.g. 'my-db-password'
    db_name = os.environ["DB_NAME"]  # e.g. 'my-database'
    db_port = os.environ["DB_PORT"]  # e.g. 5432

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

Java


import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class TcpConnectionPoolFactory extends ConnectionPoolFactory {

  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  private static final String DB_USER = System.getenv("DB_USER");
  private static final String DB_PASS = System.getenv("DB_PASS");
  private static final String DB_NAME = System.getenv("DB_NAME");

  private static final String INSTANCE_HOST = System.getenv("INSTANCE_HOST");
  private static final String DB_PORT = System.getenv("DB_PORT");


  public static DataSource createConnectionPool() {
    // The configuration object specifies behaviors for the connection pool.
    HikariConfig config = new HikariConfig();

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

    // Configure which instance and what database user to connect with.
    config.setJdbcUrl(String.format("jdbc:postgresql://%s:%s/%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "postgres"
    config.setPassword(DB_PASS); // e.g. "my-password"



    // ... Specify additional connection properties here.
    // ...

    // Initialize the connection pool using the configuration object.
    return new HikariDataSource(config);
  }
}

Node.js

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

// createTcpPool initializes a TCP connection pool for an AlloyDB cluster.
const createTcpPool = async config => {
  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  const dbConfig = {
    client: 'pg',
    connection: {
      host: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
      port: process.env.DB_PORT, // e.g. '5432'
      user: process.env.DB_USER, // e.g. 'my-user'
      password: process.env.DB_PASS, // e.g. 'my-user-password'
      database: process.env.DB_NAME, // e.g. 'my-database'
    },
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return Knex(dbConfig);
};

Go

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur 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#

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur 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

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur 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

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur 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);