使用 AlloyDB Auth 代理连接

本页介绍了如何设置和使用 AlloyDB Auth Proxy 来建立与 AlloyDB 实例的经过授权的加密连接。如需从概念上大致了解 Auth 代理，请参阅 AlloyDB Auth 代理简介。

如需使用 AlloyDB Auth Proxy，您需要执行几个一次性设置步骤，然后启动 Auth Proxy 客户端，最后使用该客户端连接到数据库：

  1. 设置步骤：
    1. 将 Auth 代理客户端下载到客户端主机。
    2. 选择要用于授权的 Identity and Access Management (IAM) 主账号，确保其具有所需的权限，并确保其凭据在客户端主机上可用。
    3. 为您要连接的 AlloyDB 实例收集连接 URI。
  2. 在客户端主机上启动 Auth 代理客户端。
  3. 打开与 Auth Proxy 客户端的本地连接，以将应用连接到数据库。

准备工作

    客户端主机必须满足以下要求：

    • 它必须能够看到您要连接到的虚拟私有云 (VPC) 网络。此 Virtual Private Cloud (VPC) 网络中的客户端主机（例如 Compute Engine 实例）本身就具有此可见性。如果 AlloyDB 实例的 VPC 网络已使用 Cloud VPN 隧道或用于专用互连或合作伙伴互连的 VLAN 连接来连接到外部网络，则外部网络（本地网络或其他 VPC 网络）中的客户端主机具有此可见性。

    • 如果客户端主机具有出站防火墙政策，则必须允许与 AlloyDB 实例 IP 地址上的端口 5433 的传出连接，并允许与所有 IP 地址的端口 443（标准 HTTPS 端口）的传出连接。

    • 如果您将 Compute Engine 实例用作客户端主机，则该实例必须具有 https://www.googleapis.com/auth/cloud-platform 访问权限范围，才能使用 AlloyDB Admin API。如有必要，请更改其访问权限范围以包含此范围。

下载 Auth 代理客户端

您下载 Auth Proxy 客户端的计算机取决于您是想从 AlloyDB 实例的 VPC 网络内还是外部连接到 AlloyDB 实例。

如果您想使用专用服务访问连接到集群，则可以将 Auth 代理客户端下载到在 VPC 网络中运行且对集群具有专用服务访问权限的 Compute Engine 虚拟机 (VM) 实例。

如果您打算从 VPC 外部连接到集群，则安装集群的机器取决于您使用的外部连接策略。例如，您可以将 Auth Proxy 客户端安装到应用本地的 macOS 或 Windows 计算机上，然后使用在 AlloyDB VPC 网络中运行的 SOCKS 服务器作为连接中介。如需了解详情，请参阅从集群 VPC 外部连接到集群。

Linux

64 位 (AMD)

  1. 下载 Auth 代理客户端：

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

  2. 使 Auth 代理客户端可执行：

    chmod +x alloydb-auth-proxy

32 位 (AMD)

  1. 下载 Auth 代理客户端：

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

  2. 使 Auth 代理客户端可执行：

    chmod +x alloydb-auth-proxy

64 位 (ARM)

  1. 下载 Auth 代理客户端：

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

  2. 使 Auth 代理客户端可执行：

    chmod +x alloydb-auth-proxy

32 位 (ARM)

  1. 下载 Auth 代理客户端：

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

  2. 使 Auth 代理客户端可执行：

    chmod +x alloydb-auth-proxy

macOS

M1

  1. 下载 Auth 代理客户端：

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

  2. 使 Auth 代理客户端可执行：

    chmod +x alloydb-auth-proxy

64 位

  1. 下载 Auth 代理客户端：

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

  2. 使 Auth 代理客户端可执行：

    chmod +x alloydb-auth-proxy

32 位

  1. 下载 Auth 代理客户端：

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

  2. 使 Auth 代理客户端可执行：

    chmod +x alloydb-auth-proxy

Windows

64 位

右键点击 https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x64.exe，然后选择链接另存为以下载 Auth Proxy 客户端。 将文件重命名为 alloydb-auth-proxy.exe。

32 位

右键点击 https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x86.exe，然后选择链接另存为以下载 Auth Proxy 客户端。将文件重命名为 alloydb-auth-proxy.exe。

Docker 映像

为方便起见，Container Registry 中提供了多个包含 Auth Proxy 客户端的容器映像。

您可以通过 Docker 使用以下命令将最新映像拉取到本地机器：

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

其他操作系统

对于此处未列出的其他操作系统，您可以通过源代码编译 Auth 代理客户端。

选择 IAM 主账号并为其做好授权准备

AlloyDB Auth Proxy 支持使用以下类型的 IAM 正文来授权客户端与 AlloyDB 实例之间的连接：

  • 用户管理的服务账号。您可以为应用创建 IAM 服务账号，然后使用该账号授权连接。

    Google 强烈建议您在生产环境中使用服务账号进行授权。

  • 您的用户账号。您可以使用自己的 IAM 用户账号授权关联。

    在开发环境中，使用自己的用户账号非常方便，因为您可以在同一主机上使用 gcloud CLI 管理 AlloyDB 资源、使用 psql 等工具开发数据库，以及开发应用代码。

  • Compute Engine 默认服务账号。如果客户端主机是 Compute Engine 实例，您可以使用 Compute Engine 默认服务账号来授权连接。

选择要使用的 IAM 正文后，您需要确保该正文具有所需的 IAM 权限，并确保其凭据在客户端主机上可用。

必需的 IAM 权限

您用于授权连接的 IAM 正文必须具有 roles/alloydb.client（Cloud AlloyDB 客户端）和 roles/serviceusage.serviceUsageConsumer（服务使用情况使用方）预定义角色提供的权限。

如需向 IAM 正文分配 Cloud AlloyDB Client 角色，请执行以下操作：

  • 必须在 Google Cloud 项目中启用 Cloud Resource Manager API。

  • 您必须拥有 Google Cloud 项目中的 roles/owner（Owner）基本 IAM 角色，或者具有以下权限的角色：

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

    如需获得这些权限，同时遵循最小权限原则，请让管理员向您授予 roles/resourcemanager.projectIamAdmin（项目 IAM 管理员）角色。

在客户端主机上提供 IAM 凭据

如何在客户端主机上提供 IAM 凭据取决于您用于授权连接的 IAM 正文类型：

  • 用户管理的服务账号

    如需为用户管理的服务账号提供 IAM 凭据，请创建 JSON 格式的服务账号密钥，并将其下载到客户端主机。启动身份验证代理客户端时，请使用 --credentials-file 标志指定密钥文件的位置。

  • 您的用户账号

    如需为您的用户账号提供 IAM 凭据，请在客户端主机上安装 Google Cloud CLI，然后运行 gcloud init 命令，使用您的用户账号对其进行初始化。当您启动 Auth Proxy 客户端时，如果您未提供用户管理的服务账号凭据，它会自动发现并使用您的用户账号凭据。

  • Compute Engine 默认服务账号

    如果您将 Compute Engine 实例用作客户端主机，则 Compute Engine 默认服务账号的凭据已在主机上。当您启动 Auth Proxy 客户端时，如果用户管理的服务账号和用户账号凭据不可用，它会自动发现并使用这些凭据。

收集 AlloyDB 实例的连接 URI

启动 Auth Proxy 客户端时，您可以使用以下连接 URI 格式标识要连接到的 AlloyDB 实例：

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

如需查看所有实例的连接 URI 的列表，请使用 gcloud CLI alloydb instances list 命令。

收集您要连接到的每个实例的实例连接 URI。

启动 Auth Proxy 客户端

启动 Auth Proxy 客户端时，您需要向其提供有关要连接到的 AlloyDB 实例的信息，以及在授权这些连接时要使用的凭据信息（如果有）。

启动后，Auth Proxy 客户端会执行以下操作：

  • 使用您配置的 IAM 正文的凭据和 IAM 权限授权连接到 AlloyDB 实例。它会按照特定的步骤顺序查找凭据。
  • 如果实例启用了公共 IP，则自动授权公共 IP 连接到来源网络。
  • 配置到每个实例的 Auth 代理服务器的私有 TLS 1.3 连接。
  • 开始监听本地客户端连接请求。

默认情况下，Auth 代理客户端会监听 IP 地址 127.0.0.1 上的 TCP 连接，从端口 5432 开始，每个 AlloyDB 实例的端口号都比上一个实例多 1 个。您可以在启动 Auth 代理客户端时指定其他监听器地址和其他端口。

命令行

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

替换以下内容：

  • INSTANCE_URI：要连接到的 AlloyDB 实例的实例连接 URI，使用以下格式指定：

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

    您可以通过向 URI 添加 port 查询参数来替换 Auth Proxy 客户端将为实例使用的默认本地监听器端口：

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

  • 可选：PATH_TO_KEY_FILE：要用于连接授权的用户管理型服务账号的 JSON 密钥文件的路径。

  • 可选：OAUTH_ACCESS_TOKEN：用于连接授权的 OAuth2 令牌值。

  • 可选：INITIAL_PORT_NUMBER：监听本地 TCP 连接时要使用的起始端口号（而不是默认端口 5432）。

  • 可选：LOCAL_LISTENER_ADDRESS：监听本地 TCP 连接时要使用的监听器地址（而不是默认的 127.0.0.1）。

可选的 --auto-iam-authn 标志允许自动对实例进行身份验证。这仅适用于与运行 Auth 代理客户端的 IAM 账号关联的数据库用户。如需了解详情，请参阅使用身份验证代理自动进行身份验证。

可选的 --psc 标志可让 Auth 代理连接到启用了 Private Service Connect 的实例。如需详细了解如何使用 Private Service Connect 设置 DNS，请参阅配置 DNS 托管式区域和 DNS 记录。

可选的 --public-ip 标志允许 Auth 代理使用实例的公共 IP 地址连接到启用了公共 IP 地址的实例。如需详细了解公共 IP，请参阅使用公共 IP 进行连接。

Docker 容器

使用 docker run 命令启动 Auth Proxy 客户端。

如果您使用的是 Compute Engine 实例提供的凭据，则可以使用类似于以下命令的命令：

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

替换以下内容：

  • PORT：用于与 Auth 代理客户端进行本地连接的端口。默认值为 5432。

  • INSTANCE_URI：要连接到的 AlloyDB 实例的实例连接 URI，使用以下格式指定：

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

    您可以通过向 URI 添加 port 查询参数来替换 Auth Proxy 客户端为实例使用的默认本地监听器端口：

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

请务必在 --publish 标志中指定 127.0.0.1 前缀，以免 Auth Proxy 客户端在本地主机外部公开。

如需确保可从 Docker 容器外部访问监听器，需要在 --address 标志中指定 0.0.0.0 值。

如需提供存储在本地 JSON 文件中的凭据，请在运行 docker run 命令时添加 --volume 和 --credentials-file 标志：

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

将 PATH_TO_KEY_FILE 替换为要用于连接授权的用户管理型服务账号的 JSON 密钥文件的路径。

启动示例

以下示例展示了启动 Auth Proxy 客户端的各种方式。它们使用以下示例实例连接 URI：

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

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

基本启动

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

在此示例中，Auth 代理客户端会按照其正常的授权步骤序列授权连接，然后开始监听 127.0.0.1:5432 上与 myprimary 实例的本地连接。

使用用户管理的服务账号启动

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

在此示例中，Auth 代理客户端使用存储在 myappaccount/key.json 的用户管理的服务账号的 JSON 密钥授权连接，然后开始监听对 127.0.0.1:5432 上 myprimary 实例的本地连接。

启动时连接到多个实例

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

在此示例中，Auth 代理客户端会按照其正常的授权步骤序列授权连接，然后开始监听到 127.0.0.1:5432 上的 myprimary 实例和 127.0.0.1:5433 上的 myreadpool 实例的本地连接。

在自定义端口上启动监听

当您需要为其他 PostgreSQL 连接预留端口 5432 时，为 Auth 代理客户端使用自定义端口会很有用。

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

在此示例中，Auth 代理客户端会按照其正常的授权步骤序列授权连接，然后开始监听到 127.0.0.1:5000 上的 myprimary 实例和 127.0.0.1:5001 上的 myreadpool 实例的本地连接。

由于这些自定义端口是顺序的，因此可以使用以下启动命令实现相同的效果：

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

在自定义 IP 地址上启动监听

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

在此示例中，Auth 代理客户端会按照其正常的授权步骤序列授权连接，然后开始监听 0.0.0.0:5432 上与 myprimary 实例的本地连接。

使用 AlloyDB Auth 代理将应用连接到数据库

以下示例展示了如何使用 AlloyDB Auth 代理将应用连接到数据库。

psql 示例提供了连接命令行工具的示例。

对于某些编程语言，使用 AlloyDB Auth 代理连接到 AlloyDB 实例与使用 Cloud SQL Auth 代理连接到 Cloud SQL for PostgreSQL 完全相同，因此此处的语言示例与 Cloud SQL for PostgreSQL 的示例相同。

这些示例基于 Auth 代理客户端的默认启动，因此它会监听 127.0.0.1:5432 上的本地 TCP 连接。

psql

psql -h 127.0.0.1 -p 5432 -U DB_USER

将 DB_USER 替换为您要以哪个数据库用户身份进行连接，例如 postgres。

系统会提示您输入 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

如需了解 Web 应用环境下的此代码段，请查看 GitHub 上的 README。

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#

如需了解 Web 应用环境下的此代码段，请查看 GitHub 上的 README。

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

如需了解 Web 应用环境下的此代码段，请查看 GitHub 上的 README。

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

如需了解 Web 应用环境下的此代码段，请查看 GitHub 上的 README。

// $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);