Conéctate con el proxy de autenticación de AlloyDB

En esta página, se muestra cómo configurar y usar el proxy de autenticación de AlloyDB para establecer conexiones autorizadas y encriptadas a instancias de AlloyDB. Para obtener una descripción general conceptual del proxy de autenticación, consulta Acerca del proxy de autenticación de AlloyDB.

Para usar el proxy de autenticación de AlloyDB, debes realizar varios pasos de configuración únicos, iniciar el cliente de proxy de autenticación y, luego, conectarte a las bases de datos con él:

1. Pasos de configuración:
   1. Descarga el cliente del proxy de Auth en tu host cliente.
   2. Elige el principal de Identity and Access Management (IAM) que se usará para la autorización, asegúrate de que tenga los permisos necesarios y haz que sus credenciales estén disponibles en tu host de cliente.
   3. Recopila los URIs de conexión para las instancias de AlloyDB a las que deseas conectarte.
2. Inicia el cliente de Auth Proxy en tu host cliente.
3. Para conectar una aplicación a una base de datos, abre una conexión local al cliente de Auth Proxy.

Antes de comenzar

El host del cliente debe cumplir con los siguientes requisitos:

• Debe tener visibilidad de red a la red de nube privada virtual (VPC) en la que residen las instancias a las que deseas conectarte. Los hosts cliente (como las instancias de Compute Engine) en esta red de nube privada virtual (VPC) tienen esta visibilidad de forma inherente. Los hosts cliente en redes externas (redes locales o diferentes redes de VPC) tienen esta visibilidad si la red de VPC de la instancia de AlloyDB se conectó a la red externa a través de un túnel de Cloud VPN o un adjunto de VLAN para la interconexión dedicada o la interconexión de socio.

• Si el host cliente tiene una política de firewall saliente, debe permitir conexiones salientes al puerto 5433 en las direcciones IP de tus instancias de AlloyDB y permitir conexiones salientes al puerto 443 (el puerto HTTPS estándar) a todas las direcciones IP.

• Si usas una instancia de Compute Engine como host cliente, esta debe tener el permiso de acceso https://www.googleapis.com/auth/cloud-platform para poder usar la API de AlloyDB Admin. Si es necesario, cambia su permiso de acceso para incluir este permiso.

Descarga el cliente de Auth Proxy

La máquina a la que descargas el cliente de Auth Proxy depende de si quieres conectarte a tus instancias de AlloyDB desde dentro de su red de VPC o desde fuera de ella.

Si deseas conectarte a tu clúster con el acceso privado a servicios, puedes descargar el cliente de Auth Proxy en una instancia de máquina virtual (VM) de Compute Engine que se ejecute en la red de VPC que tiene acceso a servicios privados a tu clúster.

Si deseas conectarte a tu clúster desde fuera de la VPC, la máquina en la que lo instales dependerá de la estrategia de conexión externa que uses. Por ejemplo, puedes instalar el cliente de proxy de autenticación en una máquina macOS o Windows que sea local para tu aplicación y, luego, usar un servidor SOCKS que se ejecute dentro de tu red de VPC de AlloyDB como intermediario de conexión. Para obtener más información, consulta Cómo conectarse a un clúster desde fuera de su VPC.

Linux

64 bits (AMD)

1. Descarga el cliente de Auth Proxy:

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

2. Haz que el cliente del proxy de autenticación sea ejecutable:

   chmod +x alloydb-auth-proxy

32 bits (AMD)

1. Descarga el cliente de Auth Proxy:

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

2. Haz que el cliente del proxy de autenticación sea ejecutable:

   chmod +x alloydb-auth-proxy

64 bits (ARM)

1. Descarga el cliente de Auth Proxy:

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

2. Haz que el cliente del proxy de autenticación sea ejecutable:

   chmod +x alloydb-auth-proxy

32 bits (ARM)

1. Descarga el cliente de Auth Proxy:

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

2. Haz que el cliente del proxy de autenticación sea ejecutable:

   chmod +x alloydb-auth-proxy

macOS

M1

1. Descarga el cliente de Auth Proxy:

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

2. Haz que el cliente del proxy de autenticación sea ejecutable:

   chmod +x alloydb-auth-proxy

64 bits

1. Descarga el cliente de Auth Proxy:

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

2. Haz que el cliente del proxy de autenticación sea ejecutable:

   chmod +x alloydb-auth-proxy

32 bits

1. Descarga el cliente de Auth Proxy:

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

2. Haz que el cliente del proxy de autenticación sea ejecutable:

   chmod +x alloydb-auth-proxy

Windows

64 bits

Haz clic con el botón derecho en https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x64.exe y selecciona Guardar vínculo como para descargar el cliente de proxy de autenticación. Cambia el nombre del archivo por alloydb-auth-proxy.exe.

32 bits

Haz clic con el botón derecho en https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x86.exe y selecciona Guardar vínculo como para descargar el cliente de proxy de autenticación. Cambia el nombre del archivo por alloydb-auth-proxy.exe.

Imagen de Docker

Para mayor comodidad, varias imágenes de contenedor que contienen el cliente de proxy de autenticación están disponibles en Container Registry.

Puedes extraer la última imagen a tu máquina local usando Docker mediante el siguiente comando:

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

Otro SO

Para otros sistemas operativos que no se incluyen aquí, puedes compilar el cliente de proxy de Auth desde la fuente.

Elige el principal de IAM y prepáralo para la autorización

El proxy de autenticación de AlloyDB admite el uso de estos tipos de principales de IAM para autorizar conexiones entre tu cliente y una instancia de AlloyDB:

• Una cuenta de servicio administrada por el usuario Puedes crear una cuenta de servicio de IAM para tu aplicación y, luego, autorizar conexiones con ella.

  Google recomienda que uses una cuenta de servicio para la autorización en entornos de producción.

• Tu cuenta de usuario. Puedes usar tu propia cuenta de usuario de IAM para autorizar conexiones.

  Usar tu propia cuenta de usuario es conveniente en entornos de desarrollo en los que administras recursos de AlloyDB con la CLI de gcloud, desarrollas la base de datos con una herramienta como psql y desarrollas el código de la aplicación en el mismo host.

• La cuenta de servicio predeterminada de Compute Engine. Si el host cliente es una instancia de Compute Engine, puedes usar la cuenta de servicio predeterminada de Compute Engine para autorizar las conexiones.

Después de elegir qué principal de IAM usar, debes asegurarte de que tenga los permisos de IAM necesarios y de que sus credenciales estén disponibles en tu host cliente.

Permisos de IAM obligatorios

El principal de IAM que usas para autorizar conexiones debe tener los permisos que proporcionan los roles predefinidos roles/alloydb.client (cliente de Cloud AlloyDB) y roles/serviceusage.serviceUsageConsumer (consumidor de Service Usage).

Nota: El rol roles/alloydb.admin (administrador de Cloud AlloyDB) también proporciona los permisos necesarios.

Para asignar el rol de cliente de Cloud AlloyDB a un principal de IAM, haz lo siguiente:

• La API de Cloud Resource Manager debe estar habilitada en el proyecto de Google Cloud.

• Debes tener el rol de IAM básico roles/owner (propietario) en el proyecto de Google Cloud o un rol que otorgue estos permisos:

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

  Para obtener estos permisos y seguir el principio de privilegio mínimo, pídele a tu administrador que te otorgue el rol de roles/resourcemanager.projectIamAdmin (administrador de IAM del proyecto).

Cómo hacer que las credenciales de IAM estén disponibles en el host del cliente

La forma en que pones las credenciales de IAM a disposición del host cliente depende del tipo de principal de IAM que uses para autorizar las conexiones:

• Cuenta de servicio administrada por el usuario

  Para proporcionar credenciales de IAM para una cuenta de servicio administrada por el usuario, crea una clave de cuenta de servicio en formato JSON y descárgala en tu host de cliente. Cuando inicies el cliente de Auth Proxy, especifica la ubicación del archivo de claves con la marca --credentials-file.

• Tu cuenta de usuario

  Para proporcionar credenciales de IAM para tu cuenta de usuario, instala Google Cloud CLI en tu host cliente y, luego, ejecuta el comando gcloud init para inicializarlo con tu cuenta de usuario. Cuando inicias el cliente de Auth Proxy, este descubre y usa automáticamente las credenciales de tu cuenta de usuario si no proporcionas credenciales de cuenta de servicio administradas por el usuario.

• Cuenta de servicio predeterminada de Compute Engine

  Si usas una instancia de Compute Engine como tu host cliente, las credenciales de la cuenta de servicio predeterminada de Compute Engine ya están en el host. Cuando inicias el cliente de Auth Proxy, este descubre y usa automáticamente estas credenciales si las credenciales de la cuenta de servicio y de la cuenta de usuario administradas por el usuario no están disponibles.

Recopila los URIs de conexión para las instancias de AlloyDB

Cuando inicias el cliente de proxy de autenticación, identificas la instancia o las instancias de AlloyDB con las que deseas conectarte con este formato de URI de conexión:

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

Para ver una lista de todos los URIs de conexión de tus instancias, usa el comando alloydb instances list de la CLI de gcloud.

Recopila el URI de conexión de la instancia para cada instancia a la que deseas conectarte.

Inicia el cliente de proxy de autenticación

Cuando inicias el cliente de proxy de autenticación, le proporcionas información sobre a qué instancias de AlloyDB conectarse y, si es necesario, la información de credenciales que se usará para autorizar estas conexiones.

Cuando se inicia, el cliente de Auth Proxy hace lo siguiente:

• Otorga autorización para las conexiones a instancias de AlloyDB con las credenciales y los permisos de IAM del principal de IAM que configuraste. Para buscar credenciales, sigue una secuencia específica de pasos.
• Otorga autorización automática a las conexiones de IP pública a la red de origen si la instancia tiene habilitada la IP pública.
• Configura una conexión privada TLS 1.3 al servidor de proxy de autenticación de cada instancia.
• Comienza a escuchar las solicitudes de conexión de clientes locales.

De forma predeterminada, el cliente de Auth Proxy escucha conexiones TCP en la dirección IP 127.0.0.1, comenzando en el puerto 5432 y aumentando en un número de puerto para cada instancia de AlloyDB después de la primera. Puedes especificar una dirección de objeto de escucha y puertos diferentes cuando inicias el cliente de proxy de autenticación.

Advertencia: Ten cuidado cuando vincules el cliente de Auth Proxy a una interfaz externa. Cualquier persona con acceso a esa interfaz o puerto estará autorizada a conectarse a tu instancia.

Nota: Google recomienda que ejecutes el cliente de proxy de autenticación como un servicio persistente en entornos de producción.

Línea de comandos

./alloydb-auth-proxy INSTANCE_URI... \
    [ --credentials-file PATH_TO_KEY_FILE \ ]
    [ --token OAUTH_ACCESS_TOKEN \ ]
    [ --port INITIAL_PORT_NUMBER \ ]
    [ --address LOCAL_LISTENER_ADDRESS \ ]
    [ --auto-iam-authn ] \
    [ --psc] \
    [ --public-ip]

Reemplaza lo siguiente:

• INSTANCE_URI: Es el URI de conexión de la instancia de una instancia de AlloyDB a la que te conectas, especificado con este formato:

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

  Para anular el puerto de objeto de escucha local predeterminado que usará el cliente de proxy de autenticación para la instancia, agrega el parámetro de consulta port al URI:

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

• Opcional: PATH_TO_KEY_FILE: Es la ruta de acceso al archivo de claves JSON de la cuenta de servicio administrada por el usuario que se usará para la autorización de conexión.

• Opcional: OAUTH_ACCESS_TOKEN: Es un valor de token de OAuth2 que se usará para la autorización de conexión.

• Opcional: INITIAL_PORT_NUMBER: Es el número de puerto de inicio que se usará en lugar del puerto predeterminado 5432 cuando se detecten conexiones TCP locales.

• Opcional: LOCAL_LISTENER_ADDRESS: Es la dirección del objeto de escucha que se usará en lugar del 127.0.0.1 predeterminado cuando se detecten conexiones TCP locales.

La marca opcional --auto-iam-authn permite la autenticación automática en la instancia. Esto solo funciona para el usuario de la base de datos asociado con la cuenta de IAM que ejecuta el cliente de proxy de autenticación. Para obtener más información, consulta Cómo autenticar automáticamente con el proxy de autenticación.

La marca --psc opcional permite que el proxy de autenticación se conecte a una instancia con Private Service Connect habilitado. Para obtener más información sobre cómo configurar el DNS con Private Service Connect, consulta Configura una zona administrada de DNS y un registro de DNS.

La marca opcional --public-ip permite que el proxy de autenticación se conecte a una instancia con la IP pública habilitada mediante la dirección IP pública de la instancia. Para obtener más información sobre la IP pública, consulta Cómo conectarse con una IP pública.

Contenedor de Docker

Inicia el cliente de Auth Proxy con el comando docker run.

Si usas las credenciales que proporciona tu instancia de Compute Engine, puedes usar un comando similar al siguiente:

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

Reemplaza lo siguiente:

• PORT: Es el puerto que se usará para las conexiones locales al cliente de Auth Proxy. El valor predeterminado es 5432.

• INSTANCE_URI: Es el URI de conexión de la instancia de una instancia de AlloyDB a la que te conectas, especificado con el siguiente formato:

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

  Para anular el puerto de objeto de escucha local predeterminado que usa el cliente de proxy de autenticación para la instancia, agrega el parámetro de consulta port al URI:

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

Especifica siempre el prefijo 127.0.0.1 en la marca --publish para que el cliente de proxy de Auth no se exponga fuera del host local.

El valor 0.0.0.0 en la marca --address es necesario para que se pueda acceder al objeto de escucha desde fuera del contenedor de Docker.

Para proporcionar credenciales que almacenaste en un archivo JSON local, incluye las marcas --volume y --credentials-file cuando ejecutes el 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

Reemplaza PATH_TO_KEY_FILE por la ruta de acceso al archivo de claves JSON de la cuenta de servicio administrada por el usuario que se usará para la autorización de conexión.

Ejemplos de inicio

En los siguientes ejemplos, se muestran varias formas de iniciar el cliente de Auth Proxy. Usan estos URIs de conexión de instancias de ejemplo:

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

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

Inicio básico

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

En este ejemplo, el cliente de Auth Proxy autoriza la conexión siguiendo su secuencia normal de pasos de autorización y, luego, comienza a escuchar conexiones locales a la instancia de myprimary en 127.0.0.1:5432.

Inicio con una cuenta de servicio administrada por el usuario

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

En este ejemplo, el cliente de proxy de autenticación autoriza la conexión con la clave JSON de la cuenta de servicio administrada por el usuario almacenada en myappaccount/key.json y, luego, comienza a escuchar conexiones locales a la instancia de myprimary en 127.0.0.1:5432.

Inicio de la conexión a varias instancias

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

En este ejemplo, el cliente de proxy de autenticación autoriza la conexión siguiendo su secuencia normal de pasos de autorización y, luego, comienza a escuchar conexiones locales a la instancia de myprimary en 127.0.0.1:5432 y a la instancia de myreadpool en 127.0.0.1:5433.

Inicio de la escucha en puertos personalizados

El uso de puertos personalizados para el cliente de proxy de autenticación puede ser útil cuando necesitas reservar el puerto 5432 para otras conexiones de 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"

En este ejemplo, el cliente de proxy de autenticación autoriza la conexión siguiendo su secuencia normal de pasos de autorización y, luego, comienza a escuchar conexiones locales a la instancia de myprimary en 127.0.0.1:5000 y a la instancia de myreadpool en 127.0.0.1:5001.

Debido a que estos puertos personalizados son secuenciales, se puede lograr el mismo efecto con este comando de inicio:

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

Cómo iniciar la escucha en una dirección IP personalizada

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

En este ejemplo, el cliente de Auth Proxy autoriza la conexión siguiendo su secuencia normal de pasos de autorización y, luego, comienza a escuchar conexiones locales a la instancia de myprimary en 0.0.0.0:5432.

Cómo conectar una aplicación a una base de datos con el proxy de autenticación de AlloyDB

En los siguientes ejemplos, se muestra cómo puedes conectar una aplicación a una base de datos con el proxy de autenticación de AlloyDB.

El ejemplo de psql proporciona un ejemplo de cómo conectar una herramienta de línea de comandos.

En varios lenguajes de programación, conectarse a una instancia de AlloyDB con el proxy de autenticación de AlloyDB es idéntico a conectarse a una instancia de Cloud SQL para PostgreSQL con el proxy de autenticación de Cloud SQL, por lo que los ejemplos de lenguaje aquí son los mismos que los de Cloud SQL para PostgreSQL.

Estos ejemplos se basan en un inicio predeterminado del cliente de proxy de Auth para que escuche las conexiones TCP locales en 127.0.0.1:5432.

Nota: Con un clúster nuevo, puedes conectarte como el usuario postgres con la contraseña que especificaste cuando creaste el clúster.

psql

psql -h 127.0.0.1 -p 5432 -U DB_USER

Reemplaza DB_USER por el usuario de la base de datos con el que deseas conectarte, por ejemplo, postgres.

Se te pedirá que ingreses la contraseña del usuario 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

Para ver este fragmento en el contexto de una aplicación web, consulta el archivo README en GitHub.

package alloydb

import (
	"database/sql"
	"fmt"
	"log"
	"os"

	// Note: If connecting using the App Engine Flex Go runtime, use
	// "github.com/jackc/pgx/stdlib" instead, since v4 requires
	// Go modules which are not supported by App Engine Flex.
	_ "github.com/jackc/pgx/v5/stdlib"
)

// connectTCPSocket initializes a TCP connection pool for an AlloyDB cluster.
func connectTCPSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Warning: %s environment variable not set.", k)
		}
		return v
	}
	// Note: Saving credentials in environment variables is convenient, but not
	// secure - consider a more secure solution such as
	// Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
	// keep secrets safe.
	var (
		dbUser    = mustGetenv("DB_USER")       // e.g. 'my-db-user'
		dbPwd     = mustGetenv("DB_PASS")       // e.g. 'my-db-password'
		dbTCPHost = mustGetenv("INSTANCE_HOST") // e.g. '127.0.0.1' or IP Address of Cluster
		dbPort    = mustGetenv("DB_PORT")       // e.g. '5432'
		dbName    = mustGetenv("DB_NAME")       // e.g. 'my-database'
	)

	dbURI := fmt.Sprintf("host=%s user=%s password=%s port=%s database=%s",
		dbTCPHost, dbUser, dbPwd, dbPort, dbName)

	// dbPool is the pool of database connections.
	dbPool, err := sql.Open("pgx", dbURI)
	if err != nil {
		return nil, fmt.Errorf("sql.Open: %v", err)
	}

	// ...

	return dbPool, nil
}

C#

Para ver este fragmento en el contexto de una aplicación web, consulta el archivo README en GitHub.

using Npgsql;
using System;

namespace CloudSql
{
    public class PostgreSqlTcp
    {
        public static NpgsqlConnectionStringBuilder NewPostgreSqlTCPConnectionString()
        {
            // Equivalent connection string:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new NpgsqlConnectionStringBuilder()
            {
                // Note: Saving credentials in environment variables is convenient, but not
                // secure - consider a more secure solution such as
                // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
                // keep secrets safe.
                Host = Environment.GetEnvironmentVariable("INSTANCE_HOST"),     // e.g. '127.0.0.1'
                // Set Host to 'cloudsql' when deploying to App Engine Flexible environment
                Username = Environment.GetEnvironmentVariable("DB_USER"), // e.g. 'my-db-user'
                Password = Environment.GetEnvironmentVariable("DB_PASS"), // e.g. 'my-db-password'
                Database = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'

                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = SslMode.Disable,
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Ruby

Para ver este fragmento en el contexto de una aplicación web, consulta el archivo README en GitHub.

development:
  adapter: postgresql
  # Configure additional properties here.
  username: <%= ENV["DB_USER"] %>  # e.g. "my-database-user"
  password: <%= ENV["DB_PASS"] %> # e.g. "my-database-password"
  database: <%= ENV.fetch("DB_NAME") { "vote_development" } %>
  host: <%= ENV.fetch("DB_HOST") { "127.0.0.1" }%> # '172.17.0.1' if deployed to GAE Flex
  port: <%= ENV.fetch("DB_PORT")  { 5432 }%>

PHP

Para ver este fragmento en el contexto de una aplicación web, consulta el archivo README en 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);