使用 AlloyDB Auth Proxy 連線

本頁面說明如何設定及使用 AlloyDB Auth Proxy，與 AlloyDB 執行個體建立已授權的加密連線。如需 Auth Proxy 的概念總覽，請參閱「AlloyDB Auth Proxy 簡介」。

如要使用 AlloyDB Auth Proxy，請執行幾個一次性設定步驟，然後啟動 Auth Proxy 用戶端，並使用該用戶端連線至資料庫：

  1. 設定步驟：
    1. 將驗證 Proxy 用戶端下載至用戶端主機。
    2. 選擇要用於授權的 Identity and Access Management (IAM) 主體，確認該主體具備必要權限，且其憑證可在用戶端主機上使用。
    3. 收集要連線的 AlloyDB 執行個體連線 URI。
  2. 在用戶端主機上啟動 Auth Proxy 用戶端。
  3. 將應用程式連線至資料庫：開啟與驗證 Proxy 用戶端的本機連線。

事前準備

    用戶端主機必須符合下列條件：

    • 必須具備虛擬私有雲 (VPC) 網路的網路可視性，才能連線至所需執行個體。這個虛擬私有雲 (VPC) 網路中的用戶端主機 (例如 Compute Engine 執行個體) 本身就具有這項可見度。如果 AlloyDB 執行個體的虛擬私有雲網路已使用 Cloud VPN 通道或 VLAN 附件 (適用於專屬互連或合作夥伴互連) 連線至外部網路，外部網路 (內部部署網路或不同虛擬私有雲網路) 中的用戶端主機就會具有這項可見度。

    • 如果用戶端主機有輸出防火牆政策，則必須允許連線至 AlloyDB 執行個體 IP 位址的通訊埠 5433，以及連線至所有 IP 位址的通訊埠 443 (標準 HTTPS 通訊埠)。

    • 如果您使用 Compute Engine 執行個體做為用戶端主機，該執行個體必須具備 https://www.googleapis.com/auth/cloud-platform 存取範圍，才能使用 AlloyDB API。如有需要，請變更存取權範圍，加入這個範圍。

下載驗證 Proxy 用戶端

下載 Auth Proxy 用戶端的機器，取決於您要從 AlloyDB 執行個體的虛擬私有雲網路內，還是從外部連線。

如要使用私人服務存取權連線至叢集，您可以將 Auth Proxy 用戶端下載至 Compute Engine 虛擬機器 (VM) 執行個體，該執行個體在虛擬私有雲網路中執行，且具有叢集的私人服務存取權。

如果您打算從虛擬私有雲外部連線至叢集，安裝的機器取決於您使用的外部連線策略。舉例來說，您可以將 Auth Proxy 用戶端安裝到應用程式本機的 macOS 或 Windows 電腦，然後使用 AlloyDB 虛擬私有雲網路中執行的 SOCKS 伺服器做為連線中介。詳情請參閱「從虛擬私有雲外部連線至叢集」。

Linux

64 位元 (AMD)

  1. 下載 Auth Proxy 用戶端：

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

  2. 將驗證 Proxy 用戶端設為可執行檔：

    chmod +x alloydb-auth-proxy

32 位元 (AMD)

  1. 下載 Auth Proxy 用戶端：

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

  2. 將驗證 Proxy 用戶端設為可執行檔：

    chmod +x alloydb-auth-proxy

64 位元 (ARM)

  1. 下載 Auth Proxy 用戶端：

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

  2. 將驗證 Proxy 用戶端設為可執行檔：

    chmod +x alloydb-auth-proxy

32 位元 (ARM)

  1. 下載 Auth Proxy 用戶端：

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

  2. 將驗證 Proxy 用戶端設為可執行檔：

    chmod +x alloydb-auth-proxy

macOS

M1

  1. 下載 Auth Proxy 用戶端：

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

  2. 將驗證 Proxy 用戶端設為可執行檔：

    chmod +x alloydb-auth-proxy

64 位元

  1. 下載 Auth Proxy 用戶端：

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

  2. 將驗證 Proxy 用戶端設為可執行檔：

    chmod +x alloydb-auth-proxy

32 位元

  1. 下載 Auth Proxy 用戶端：

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

  2. 將驗證 Proxy 用戶端設為可執行檔：

    chmod +x alloydb-auth-proxy

Windows

64 位元

在 https://storage.googleapis.com/alloydb-auth-proxy/v1.13.5/alloydb-auth-proxy-x64.exe 上按一下滑鼠右鍵，然後選取「另存連結為」，即可下載 Auth Proxy 用戶端。 將檔案重新命名為 alloydb-auth-proxy.exe。

32 位元

在 https://storage.googleapis.com/alloydb-auth-proxy/v1.13.5/alloydb-auth-proxy-x86.exe 上按一下滑鼠右鍵，然後選取「另存連結為」，即可下載 Auth Proxy 用戶端。將檔案重新命名為 alloydb-auth-proxy.exe。

Docker 映像檔

為方便起見，Artifact Registry 提供多個包含 Auth Proxy 用戶端的容器映像檔。

您可以使用 Docker 和下列指令，將最新映像檔提取至本機電腦：

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

其他 OS

如果您的作業系統不在上述說明內，可以從原始碼編譯 Auth Proxy 用戶端。

選擇 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 (服務使用消費者) 預先定義角色提供的權限。

如要將 Cloud AlloyDB 用戶端角色指派給 IAM 主體，請按照下列步驟操作：

  • 必須在 Google Cloud 專案中啟用 Cloud Resource Manager API。

  • 您必須在Google Cloud 專案中具備 roles/owner (擁有者) 基本 IAM 角色，或是具備可授予下列權限的角色：

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

    如要在遵循最低權限原則的情況下取得這些權限，請要求管理員授予 roles/resourcemanager.projectIamAdmin (專案 IAM 管理員) 角色。

在用戶端主機上提供 IAM 憑證

在用戶端主機上提供 IAM 憑證的方式，取決於您用來授權連線的 IAM 主體類型：

  • 使用者管理的服務帳戶

    如要為使用者管理的服務帳戶提供 IAM 憑證，請建立 JSON 格式的服務帳戶金鑰，然後下載到用戶端主機。啟動 Auth Proxy 用戶端時，請使用 --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 執行個體相關資訊，以及授權這些連線時要使用的憑證資訊 (如有必要)。

啟動後，驗證 Proxy 用戶端會執行下列動作：

  • 使用您設定的 IAM 主體憑證和 IAM 權限，授權連線至 AlloyDB 執行個體。系統會按照特定步驟順序尋找憑證。
  • 如果執行個體已啟用公開 IP，系統會自動授權公開 IP 連線至來源網路。
  • 設定與每個執行個體驗證 Proxy 伺服器的私密 TLS 1.3 連線。
  • 開始監聽本機用戶端連線要求。

根據預設，Auth Proxy 用戶端會監聽 IP 位址 127.0.0.1 的 TCP 連線，從通訊埠 5432 開始，每個 AlloyDB 執行個體會遞增一個通訊埠號碼。啟動 Auth Proxy 用戶端時，您可以指定其他接聽程式位址和通訊埠。

指令列

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

更改下列內容：

  • INSTANCE_URI：要連線的 AlloyDB 執行個體執行個體連線 URI，格式如下：

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

    您可以將 port 查詢參數新增至 URI，覆寫 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 Proxy 用戶端的 IAM 帳戶相關聯的資料庫使用者。詳情請參閱使用 Auth Proxy 自動驗證。

選用的 --psc 旗標可讓 Auth Proxy 連線至已啟用 Private Service Connect 的執行個體。如要進一步瞭解如何透過 Private Service Connect 設定 DNS，請參閱「設定 DNS 受管理區域和 DNS 記錄」。

選用的 --public-ip 標記可讓 Auth Proxy 使用執行個體的公開 IP 位址，連線至已啟用公開 IP 的執行個體。如要進一步瞭解公開 IP，請參閱「使用公開 IP 連線」。

選用的 --disable-built-in-telemetry 旗標會停用 Auth Proxy 用於回報連線和網路健康狀態的內部指標回報工具。根據預設，Auth Proxy 會向 alloydb.googleapis.com 系統指標前置字元回報內部作業。這些指標有助於 AlloyDB 提升效能，並找出用戶端連線問題。如果應用程式運作的環境限制匯出指標，這個選項就非常實用。如要停用這項遙測功能，請使用這個標記。

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 Proxy 用戶端的通訊埠。預設值為 5432。

  • INSTANCE_URI：要連線的 AlloyDB 執行個體執行個體連線 URI，格式如下：

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

    您可以將 port 查詢參數新增至 URI，覆寫 Auth Proxy 用於執行個體的預設本機接聽埠：

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

請一律在 --publish 旗標中指定 127.0.0.1 前置字串，以防 Auth Proxy 用戶端暴露到本機主機之外。

--address 標記中的 0.0.0.0 值必須讓接聽程式可從 Docker 容器外部存取。

如要提供儲存在本機 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 Proxy 用戶端會按照正常的授權步驟順序授權連線，然後開始監聽 127.0.0.1:5432 上 myprimary 執行個體的本機連線。

使用使用者代管的服務帳戶啟動

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

在本範例中，Auth Proxy 用戶端會使用儲存在 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 Proxy 用戶端會按照正常的授權步驟順序授權連線，然後開始監聽 127.0.0.1:5432 上 myprimary 執行個體和 127.0.0.1:5433 上 myreadpool 執行個體的本機連線。

在自訂通訊埠上啟動監聽

如果您需要保留通訊埠 5432，供其他 PostgreSQL 連線使用，則可為驗證 Proxy 用戶端使用自訂通訊埠。

./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 Proxy 用戶端會按照正常的授權步驟順序授權連線，然後開始監聽 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 Proxy 用戶端會按照正常的授權步驟順序授權連線，然後開始監聽 0.0.0.0:5432 上 myprimary 執行個體的本機連線。

使用 AlloyDB Auth Proxy 將應用程式連線至資料庫

以下範例說明如何使用 AlloyDB Auth Proxy，將應用程式連線至資料庫。

psql 範例提供連線指令列工具的範例。

使用 AlloyDB 驗證 Proxy 連線至 AlloyDB 執行個體時，對於多種程式設計語言而言，與使用 Cloud SQL 驗證 Proxy 連線至 PostgreSQL 適用的 Cloud SQL 相同，因此這裡的語言範例與 PostgreSQL 適用的 Cloud SQL 相同。

這些範例是以驗證 Proxy 用戶端的預設啟動方式為基礎，因此會監聽 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

如要查看網頁應用程式中的程式碼片段，請參閱 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#

如要查看網頁應用程式中的程式碼片段，請參閱 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

如要查看網頁應用程式中的程式碼片段，請參閱 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

如要查看網頁應用程式中的程式碼片段，請參閱 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);