Terhubung menggunakan Proxy Auth AlloyDB

Halaman ini menunjukkan cara menyiapkan dan menggunakan Proxy Auth AlloyDB untuk membuat koneksi yang terotorisasi dan terenkripsi ke instance AlloyDB. Untuk ringkasan konseptual Proxy Auth, lihat Tentang Proxy Auth AlloyDB.

Untuk menggunakan Proxy Auth AlloyDB, Anda harus melakukan beberapa langkah penyiapan satu kali, lalu memulai klien Proxy Auth, lalu terhubung ke database menggunakan klien tersebut:

  1. Langkah penyiapan:
    1. Download klien Proxy Autentikasi ke host klien Anda.
    2. Pilih akun utama Identity and Access Management (IAM) yang akan digunakan untuk otorisasi, pastikan akun utama tersebut memiliki izin yang diperlukan, dan pastikan kredensialnya tersedia di host klien Anda.
    3. Kumpulkan URI koneksi untuk instance AlloyDB yang ingin Anda hubungkan.
  2. Mulai klien Proxy Auth di host klien Anda.
  3. Hubungkan aplikasi ke database dengan membuka koneksi lokal ke klien Proxy Auth.

Sebelum memulai

    Host klien harus memenuhi persyaratan berikut:

    • Cloud Router harus memiliki visibilitas jaringan ke jaringan Virtual Private Cloud (VPC) tempat instance yang ingin Anda hubungkan berada. Host klien (seperti instance Compute Engine) di jaringan Virtual Private Cloud (VPC) ini secara inheren memiliki visibilitas ini. Host klien di jaringan eksternal (jaringan lokal atau jaringan VPC yang berbeda) memiliki visibilitas ini jika jaringan VPC instance AlloyDB telah terhubung ke jaringan eksternal menggunakan tunnel Cloud VPN atau lampiran VLAN untuk Dedicated Interconnect atau Partner Interconnect.

    • Jika host klien memiliki kebijakan firewall keluar, host tersebut harus mengizinkan koneksi keluar ke port 5433 di alamat IP instance AlloyDB Anda dan mengizinkan koneksi keluar ke port 443 (port HTTPS standar) ke semua alamat IP.

    • Jika Anda menggunakan instance Compute Engine sebagai host klien, instance tersebut harus memiliki cakupan akses https://www.googleapis.com/auth/cloud-platform agar dapat menggunakan AlloyDB Admin API. Jika perlu, ubah cakupan aksesnya untuk menyertakan cakupan ini.

Mendownload klien Auth Proxy

Komputer tempat Anda mendownload klien Proxy Auth bergantung pada apakah Anda ingin terhubung ke instance AlloyDB dari dalam jaringan VPC-nya, atau dari luarnya.

Jika ingin terhubung ke cluster menggunakan akses layanan pribadi, Anda dapat mendownload klien Auth Proxy ke instance virtual machine (VM) Compute Engine yang berjalan dalam jaringan VPC yang memiliki akses layanan pribadi ke cluster Anda.

Jika Anda ingin terhubung ke cluster dari luar VPC, komputer tempat Anda menginstalnya bergantung pada strategi koneksi eksternal yang Anda gunakan. Misalnya, Anda dapat menginstal klien Proxy Auth ke mesin macOS atau Windows yang bersifat lokal untuk aplikasi Anda, lalu menggunakan server SOCKS yang berjalan dalam jaringan VPC AlloyDB sebagai perantara koneksi. Untuk mengetahui informasi selengkapnya, lihat Menghubungkan ke cluster dari di luar VPC-nya.

Linux

64-bit (AMD)

  1. Download klien Auth Proxy:

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

  2. Buat klien Auth Proxy dapat dieksekusi:

    chmod +x alloydb-auth-proxy

32-bit (AMD)

  1. Download klien Auth Proxy:

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

  2. Buat klien Auth Proxy dapat dieksekusi:

    chmod +x alloydb-auth-proxy

64-bit (ARM)

  1. Download klien Auth Proxy:

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

  2. Buat klien Auth Proxy dapat dieksekusi:

    chmod +x alloydb-auth-proxy

32-bit (ARM)

  1. Download klien Auth Proxy:

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

  2. Buat klien Auth Proxy dapat dieksekusi:

    chmod +x alloydb-auth-proxy

macOS

M1

  1. Download klien Auth Proxy:

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

  2. Buat klien Auth Proxy dapat dieksekusi:

    chmod +x alloydb-auth-proxy

64-bit

  1. Download klien Auth Proxy:

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

  2. Buat klien Auth Proxy dapat dieksekusi:

    chmod +x alloydb-auth-proxy

32-bit

  1. Download klien Auth Proxy:

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

  2. Buat klien Auth Proxy dapat dieksekusi:

    chmod +x alloydb-auth-proxy

Windows

64-bit

Klik kanan https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x64.exe dan pilih Simpan Link Sebagai untuk mendownload klien Auth Proxy. Ganti nama file menjadi alloydb-auth-proxy.exe.

32-bit

Klik kanan https://storage.googleapis.com/alloydb-auth-proxy/v1.12.2/alloydb-auth-proxy-x86.exe dan pilih Simpan Link Sebagai untuk mendownload klien Auth Proxy. Ganti nama file menjadi alloydb-auth-proxy.exe.

Gambar docker

Guna mempermudah, beberapa image container yang berisi klien Auth Proxy tersedia di Container Registry.

Anda dapat menarik image terbaru ke mesin lokal menggunakan Docker dengan perintah berikut:

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

OS Lainnya

Untuk sistem operasi lain yang tidak disertakan di sini, Anda dapat mengompilasi klien Auth Proxy dari sumber.

Memilih akun utama IAM dan menyiapkannya untuk otorisasi

Proxy Auth AlloyDB mendukung penggunaan jenis akun utama IAM ini untuk memberikan otorisasi koneksi antara klien Anda dan instance AlloyDB:

  • Akun layanan yang dikelola pengguna. Anda dapat membuat akun layanan IAM untuk aplikasi, lalu mengizinkan koneksi menggunakan akun tersebut.

    Google sangat menyarankan agar Anda menggunakan akun layanan untuk otorisasi di lingkungan produksi.

  • Akun pengguna Anda. Anda dapat menggunakan akun pengguna IAM Anda sendiri untuk memberikan otorisasi ke koneksi.

    Menggunakan akun pengguna Anda sendiri akan memudahkan Anda di lingkungan pengembangan tempat Anda mengelola resource AlloyDB menggunakan gcloud CLI, mengembangkan database menggunakan alat seperti psql, dan mengembangkan kode aplikasi di host yang sama.

  • Akun layanan default Compute Engine. Jika host klien adalah instance Compute Engine, Anda dapat menggunakan akun layanan default Compute Engine untuk memberikan otorisasi koneksi.

Setelah memilih akun utama IAM yang akan digunakan, Anda harus memastikannya memiliki izin IAM yang diperlukan dan membuat kredensialnya tersedia di host klien.

Izin IAM yang diperlukan

Akun utama IAM yang Anda gunakan untuk memberikan otorisasi koneksi harus memiliki izin yang disediakan oleh peran yang telah ditentukan sebelumnya roles/alloydb.client (Klien Cloud AlloyDB) dan roles/serviceusage.serviceUsageConsumer (Konsumen Penggunaan Layanan).

Untuk menetapkan peran Klien Cloud AlloyDB ke akun utama IAM:

  • Cloud Resource Manager API harus diaktifkan di project Google Cloud.

  • Anda harus memiliki peran IAM dasar roles/owner (Pemilik) di project Google Cloud, atau peran yang memberikan izin berikut:

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

    Untuk mendapatkan izin ini sekaligus mengikuti prinsip hak istimewa minimum, minta administrator untuk memberi Anda peran roles/resourcemanager.projectIamAdmin (Project IAM Admin).

Menyediakan kredensial IAM di host klien

Cara Anda menyediakan kredensial IAM di host klien bergantung pada jenis akun utama IAM yang Anda gunakan untuk memberikan otorisasi koneksi:

  • Akun layanan yang dikelola pengguna

    Untuk memberikan kredensial IAM bagi akun layanan yang dikelola pengguna, buat kunci akun layanan format JSON dan download ke host klien Anda. Saat memulai klien Proxy Autentikasi, tentukan lokasi file kunci menggunakan flag --credentials-file.

  • Akun pengguna Anda

    Untuk memberikan kredensial IAM untuk akun pengguna Anda, instal Google Cloud CLI di host klien, lalu jalankan perintah gcloud init untuk melakukan inisialisasi menggunakan akun pengguna Anda. Saat Anda memulai klien Auth Proxy, klien tersebut akan otomatis menemukan dan menggunakan kredensial akun pengguna Anda jika Anda tidak menyediakan kredensial akun layanan yang dikelola pengguna.

  • Compute Engine default service account

    Jika Anda menggunakan instance Compute Engine sebagai host klien, kredensial untuk akun layanan default Compute Engine sudah ada di host. Saat Anda memulai klien Auth Proxy, klien akan otomatis menemukan dan menggunakan kredensial ini jika kredensial akun layanan dan akun pengguna yang dikelola pengguna tidak tersedia.

Mengumpulkan URI koneksi untuk instance AlloyDB

Saat memulai klien Proxy Auth, Anda mengidentifikasi instance AlloyDB yang ingin dihubungkan menggunakan format URI koneksi ini:

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

Untuk melihat daftar semua URI koneksi instance Anda, gunakan perintah alloydb instances list gcloud CLI.

Kumpulkan URI koneksi instance untuk setiap instance yang ingin Anda hubungkan.

Memulai klien Auth Proxy

Saat memulai klien Proxy Auth, Anda memberikan informasi tentang instance AlloyDB yang akan dihubungkan dan, jika perlu, informasi kredensial yang akan digunakan saat memberikan otorisasi untuk koneksi ini.

Saat dimulai, klien Proxy Autentikasi:

  • Memberi otorisasi koneksi ke instance AlloyDB menggunakan kredensial dan izin IAM akun utama IAM yang telah Anda konfigurasi. Alat ini mencari kredensial dengan mengikuti urutan langkah-langkah tertentu.
  • Memberi otorisasi koneksi IP publik ke jaringan sumber secara otomatis, jika instance mengaktifkan IP Publik.
  • Mengonfigurasi koneksi TLS 1.3 pribadi ke server Proxy Auth setiap instance.
  • Mulai memproses permintaan koneksi klien lokal.

Secara default, klien Auth Proxy memproses koneksi TCP di alamat IP 127.0.0.1, dimulai dari port 5432 dan bertambah satu nomor port untuk setiap instance AlloyDB di luar yang pertama. Anda dapat menentukan alamat pemroses yang berbeda dan port yang berbeda saat memulai klien Auth Proxy.

Command line

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

Ganti kode berikut:

  • INSTANCE_URI: URI koneksi instance instance AlloyDB yang akan dihubungkan, yang ditentukan menggunakan format ini:

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

    Anda dapat mengganti port pemroses lokal default yang akan digunakan oleh klien Auth Proxy untuk instance dengan menambahkan parameter kueri port ke URI:

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

  • Opsional: PATH_TO_KEY_FILE: Jalur ke file kunci JSON akun layanan yang dikelola pengguna untuk digunakan dalam otorisasi koneksi.

  • Opsional: OAUTH_ACCESS_TOKEN: Nilai token OAuth2 yang akan digunakan untuk otorisasi koneksi.

  • Opsional: INITIAL_PORT_NUMBER: Nomor port awal yang akan digunakan, bukan port default 5432 saat memproses koneksi TCP lokal.

  • Opsional: LOCAL_LISTENER_ADDRESS: Alamat pemroses yang akan digunakan, bukan 127.0.0.1 default saat memproses koneksi TCP lokal.

Flag --auto-iam-authn opsional memungkinkan autentikasi otomatis ke instance. Hal ini hanya berfungsi untuk pengguna database yang terkait dengan akun IAM yang menjalankan klien Auth Proxy. Untuk mengetahui informasi selengkapnya, lihat Mengautentikasi secara otomatis menggunakan Proxy Autentikasi.

Flag --psc opsional memungkinkan Proxy Auth terhubung ke instance dengan Private Service Connect yang diaktifkan. Untuk mengetahui informasi selengkapnya tentang cara menyiapkan DNS dengan Private Service Connect, lihat Mengonfigurasi zona terkelola DNS dan data DNS.

Flag --public-ip opsional memungkinkan Proxy Auth terhubung ke instance dengan IP Publik yang diaktifkan menggunakan alamat IP Publik instance. Untuk informasi selengkapnya tentang IP Publik, lihat Menghubungkan menggunakan IP Publik.

Penampung Docker

Mulai klien Auth Proxy menggunakan perintah docker run.

Jika menggunakan kredensial yang disediakan oleh instance Compute Engine, Anda dapat menggunakan perintah yang mirip dengan berikut ini:

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

Ganti kode berikut:

  • PORT: Port yang akan digunakan untuk koneksi lokal ke klien Auth Proxy. Defaultnya adalah 5432.

  • INSTANCE_URI: URI koneksi instance instance AlloyDB yang akan dihubungkan, yang ditentukan menggunakan format berikut:

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

    Anda dapat mengganti port pemroses lokal default yang digunakan klien Auth Proxy untuk instance dengan menambahkan parameter kueri port ke URI:

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

Selalu tentukan awalan 127.0.0.1 dalam tanda --publish sehingga klien Auth Proxy tidak diekspos di luar host lokal.

Nilai 0.0.0.0 dalam flag --address diperlukan agar pemroses dapat diakses dari luar penampung Docker.

Untuk memberikan kredensial yang telah Anda simpan dalam file JSON lokal, sertakan flag --volume dan --credentials-file saat menjalankan perintah 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

Ganti PATH_TO_KEY_FILE dengan jalur ke file kunci JSON akun layanan yang dikelola pengguna untuk digunakan dalam otorisasi koneksi.

Contoh Startup

Contoh berikut menunjukkan berbagai cara untuk memulai klien Auth Proxy. Contoh ini menggunakan URI koneksi instance berikut:

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

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

Startup dasar

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

Dalam contoh ini, klien Proxy Auth memberikan otorisasi koneksi dengan mengikuti urutan langkah otorisasi normalnya, lalu mulai memproses koneksi lokal ke instance myprimary di 127.0.0.1:5432.

Memulai menggunakan akun layanan yang dikelola pengguna

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

Dalam contoh ini, klien Auth Proxy memberikan otorisasi koneksi menggunakan kunci JSON akun layanan yang dikelola pengguna yang disimpan di myappaccount/key.json, lalu mulai memproses koneksi lokal ke instance myprimary di 127.0.0.1:5432.

Startup yang terhubung ke beberapa instance

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

Dalam contoh ini, klien Proxy Auth memberikan otorisasi koneksi dengan mengikuti urutan langkah otorisasi yang normal, lalu mulai memproses koneksi lokal ke instance myprimary di 127.0.0.1:5432 dan ke instance myreadpool di 127.0.0.1:5433.

Memulai pemrosesan di port kustom

Menggunakan port kustom untuk klien Proxy Auth dapat berguna saat Anda perlu mencadangkan port 5432 untuk koneksi PostgreSQL lainnya.

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

Dalam contoh ini, klien Auth Proxy memberikan otorisasi koneksi dengan mengikuti urutan langkah otorisasi normalnya, lalu mulai memproses koneksi lokal ke instance myprimary di 127.0.0.1:5000 dan ke instance myreadpool di 127.0.0.1:5001.

Karena port kustom ini bersifat berurutan, efek yang sama dapat dicapai menggunakan perintah startup ini:

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

Memulai pemrosesan di alamat IP kustom

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

Dalam contoh ini, klien Proxy Auth memberikan otorisasi koneksi dengan mengikuti urutan langkah otorisasi yang normal, lalu mulai memproses koneksi lokal ke instance myprimary di 0.0.0.0:5432.

Menghubungkan aplikasi ke database menggunakan Proxy Auth AlloyDB

Contoh berikut menunjukkan cara menghubungkan aplikasi ke database menggunakan Proxy Auth AlloyDB.

Contoh psql memberikan contoh cara menghubungkan alat command line.

Untuk beberapa bahasa pemrograman, menghubungkan ke instance AlloyDB menggunakan Proxy Auth AlloyDB sama dengan menghubungkan ke Cloud SQL untuk PostgreSQL menggunakan proxy Auth Cloud SQL, sehingga contoh bahasa di sini sama dengan contoh untuk Cloud SQL untuk PostgreSQL.

Contoh ini didasarkan pada startup default klien Proxy Auth sehingga klien memproses koneksi TCP lokal di 127.0.0.1:5432.

psql

psql -h 127.0.0.1 -p 5432 -U DB_USER

Ganti DB_USER dengan pengguna database yang ingin Anda hubungkan—misalnya, postgres.

Tindakan ini akan meminta Anda memasukkan sandi pengguna 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

Untuk melihat cuplikan ini dalam konteks aplikasi web, lihat README di 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#

Untuk melihat cuplikan ini dalam konteks aplikasi web, lihat README di 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

Untuk melihat cuplikan ini dalam konteks aplikasi web, lihat README di 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

Untuk melihat cuplikan ini dalam konteks aplikasi web, lihat README di 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);