Contoh: Konektivitas pribadi untuk instance Cloud SQL

Halaman ini menjelaskan cara menggunakan Private Service Connect (PSC) untuk membuat koneksi antara instance Cloud SQL yang mendukung Private Service Access (PSA) dan runtime Integration Connectors. Instance Cloud SQL Anda dapat berupa salah satu jenis berikut:

Pertimbangan

Saat Anda membuat lampiran layanan PSC, pertimbangkan poin-poin penting berikut:

Lampiran layanan PSC dan load balancer dibuat di subnet yang berbeda dalam VPC yang sama. Dan secara khusus, lampiran layanan selalu dibuat di subnet NAT.
Server proxy SOCKS5 harus terikat dengan alamat IP 0.0.0.0:<port> karena hal ini diperlukan untuk traffic masuk dari load balancer dan pemeriksaan health check. Untuk mengetahui informasi selengkapnya, lihat Health check.
Traffic dari load balancer dan pemeriksaan health check harus dikirim ke port yang sama.
Konfigurasikan aturan firewall untuk memfasilitasi alur traffic.
Aturan masuk
- Traffic dari subnet lampiran layanan PSC akan mencapai subnet ILB.
- Dalam subnet ILB, ILB harus dapat mengirim traffic ke server proxy SOCKS5.
- Pemeriksaan health check harus dapat mengakses server proxy SOCKS5. Pemeriksaan health check Google Cloud memiliki rentang IP tetap (35.191.0.0/16, 130.211.0.0/22). Jadi, IP ini dapat diizinkan untuk mengirim traffic ke server proxy SOCKS.
Aturan keluar

Traffic keluar diaktifkan secara default dalam project Google Cloud, kecuali jika aturan penolakan tertentu dikonfigurasi.
Semua komponen Google Cloud Anda, seperti lampiran layanan PSC dan load balancer, harus berada di region yang sama.
Sistem backend Anda tidak boleh terbuka untuk jaringan publik, karena ini bisa menjadi masalah keamanan. Namun, pastikan server proxy SOCKS5 Anda menerima traffic dalam skenario berikut:
- Load balancer pass-through (L4 TCP/UDP ILB): Permintaan dari IP NAT lampiran layanan PSC harus dapat menjangkau server proxy SOCKS5 Anda. IP NAT ini dihasilkan secara otomatis. Oleh karena itu, Anda harus mengizinkan seluruh rentang IP subnet NAT tempat lampiran layanan Anda berada. Untuk mengetahui informasi selengkapnya, lihat Subnet Private Service Connect.
- Load balancer berbasis proxy/HTTP(s) (proxy L4 ILB, L7 ILB): Semua permintaan baru berasal dari load balancer. Oleh karena itu, server proxy SOCKS5 Anda harus menerima permintaan dari subnet proxy jaringan VPC Anda. Untuk mengetahui informasi selengkapnya, lihat Subnet khusus proxy untuk load balancer berbasis Envoy.

Menyiapkan PSC untuk instance Cloud SQL

Integration Connectors menggunakan proxy Cloud SQL Auth untuk terhubung ke instance Cloud SQL. Proxy Auth Cloud SQL mendukung perantaian melalui proxy SOCKS5, yang memungkinkan Anda meneruskan traffic terenkripsi dari proxy Auth Cloud SQL ke instance Cloud SQL tujuan. Oleh karena itu, Anda memerlukan server proxy SOCKS5 untuk terhubung ke instance Cloud SQL pribadi.

Diagram berikut menunjukkan tampilan project Google Cloud Anda setelah lampiran layanan PSC dikonfigurasi untuk contoh penyiapan instance Cloud SQL.

Dalam contoh ini, server proxy SOCKS5 diekspos melalui lampiran layanan sehingga PSC dapat terhubung dengan aman ke instance Cloud SQL. Server proxy SOCKS memiliki akses ke instance Cloud SQL melalui Akses Layanan Pribadi. Server proxy SOCKS5 berada dalam grup instance Compute Engine yang tidak dikelola, dan Anda dapat menentukan jumlah instance proxy berdasarkan traffic masuk yang diharapkan.

Bagaimana arus lalu lintas dalam contoh?

Integration Connectors mengirim permintaan ke lampiran layanan.
Lampiran layanan meneruskan permintaan ke ILB L4.
L4 ILB mengirim permintaan ke server proxy SOCKS5.
ILB memiliki aturan penerusan dan melakukan penerusan port. Secara default, proxy SOCKS5 memantau port 1080. Namun, jika server proxy SOCKS5 memproses port lain, port tersebut juga harus dibuka untuk memproses ILB.
Server proxy SOCKS5 meneruskan permintaan ke instance Cloud SQL.

Sebelum memulai

Sebelum membuat lampiran layanan PSC untuk contoh skenario, lakukan tugas berikut:

Instal gcloud CLI.
Aktifkan Compute Engine API dan Service Networking API untuk project Google Cloud Anda.
Agar perintah CLI lebih sederhana, Anda dapat menetapkan nilai untuk PROJECT_ID, WILAYAH, dan ZONE menggunakan perintah berikut:
```
gcloud config set project PROJECT_ID
gcloud config set compute/region REGION
gcloud config set compute/zone ZONE
```
Untuk perintah dalam tutorial ini, ganti BACKEND_SERVER_PORT dengan 1080 yang merupakan port default tempat server proxy SOCKS5 dijalankan.
Sebaiknya buat jaringan VPC baru dan gunakan jaringan tersebut saat mencoba contoh skenario ini. Setelah menguji skenario, Anda dapat menghapus jaringan VPC dan resource lainnya.
Setidaknya harus ada satu koneksi yang telah Anda buat. Koneksi dapat berupa jenis apa pun. Jika sudah memiliki koneksi, Anda dapat mengambil project ID direktori layanan dari runtime Integration Connectors. Project ID ini diperlukan untuk membuat lampiran layanan PSC.

Membuat lampiran layanan PSC

Untuk membuat lampiran layanan PSC sebagai contoh skenario, lakukan tugas berikut:

Buat jaringan VPC dan subnet yang diperlukan.
1. Buat jaringan VPC.
```
gcloud compute networks create VPC_NETWORK \
--project=PROJECT_ID --subnet-mode=custom --mtu=1460 \
--bgp-routing-mode=regional
```
2. Tambahkan Subnet-1.
```
gcloud compute networks subnets create SUBNET_NAME_1 \
--network=VPC_NETWORK --range=SUBNET_RANGE_1 \
--purpose=PRIVATE_SERVICE_CONNECT
```
  Perintah ini membuat Subnet-1 sebagai subnet NAT yang akan digunakan secara eksklusif untuk menghosting lampiran layanan PSC. Anda tidak dapat menghosting layanan lain di subnet NAT ini.
3. Tambahkan Subnet-2.
```
gcloud compute networks subnets create SUBNET_NAME_2 \
--network=VPC_NETWORK --range=SUBNET_RANGE_2
```
Catatan: Lampiran layanan PSC tidak boleh ada di subnet yang sama dengan load balancer. Oleh karena itu, Anda memerlukan dua subnet.
Membuat instance Cloud SQL pribadi.
1. Konfigurasi akses layanan pribadi.
  1. Alokasikan rentang alamat IP.
```
gcloud compute addresses create google-managed-services-VPC_NETWORK \
--global --purpose=VPC_PEERING --prefix-length=16 \
--network=projects/PROJECT_ID/global/networks/VPC_NETWORK
```
  2. Membuat koneksi pribadi
```
gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=google-managed-services-VPC_NETWORK \
--network=VPC_NETWORK \
--project=PROJECT_ID
```
2. Buat instance Cloud SQL dengan IP pribadi.
```
gcloud beta sql instances create \
INSTANCE_NAME \
--database-version=DATABASE_VERSION \
--cpu=NUMBER_OF_CPUs \
--memory=MEMORY \
--zone=ZONE \
--root-password=ROOT_PASSWORD \
--network=projects/PROJECT_ID/global/networks/VPC_NETWORK \
--no-assign-ip \
--allocated-ip-range-name=google-managed-services-VPC_NETWORK
```
  Tentukan DATABASE_VERSION berdasarkan jenis instance yang ingin Anda buat. Anda dapat membuat instance jenis MySQL, PostgreSQL, atau SQL Server. Untuk daftar semua versi database yang didukung, lihat Versi Database SQL.
  
  Perintah ini akan membuat pengguna default untuk instance Cloud SQL Anda. Berikut adalah pengguna default yang akan dibuat untuk berbagai instance Cloud SQL *:
  - Cloud SQL untuk MySQL - root
  - Cloud SQL untuk SQL Server - sqlserver
  - Cloud SQL untuk PostgreSQL - postgres
3. (Opsional) Jika Anda tidak ingin menggunakan pengguna default, buat pengguna baru untuk instance Cloud SQL yang baru dibuat.
```
gcloud sql users create USER --host=% --instance=INSTANCE_NAME \
--password=PASSWORD
```
  Pastikan pengguna memiliki semua izin yang diperlukan untuk mengakses database yang akan Anda buat pada langkah berikutnya.
4. Buat database di instance Cloud SQL yang baru dibuat.
```
gcloud sql databases create DATABASE_NAME \
--instance=INSTANCE_NAME
```

Konfigurasikan Cloud NAT.

Membuat router sederhana.

gcloud compute routers create NAT_ROUTER_NAME \
    --network=VPC_NETWORK

Konfigurasikan penafsiran alamat jaringan.

gcloud compute routers nats create NAT_GATEWAY_NAME \
    --router=NAT_ROUTER_NAME \
    --auto-allocate-nat-external-ips \
    --nat-all-subnet-ip-ranges

Buat instance VM Compute Engine untuk menjalankan server proxy SOCKS5.
1. Membuat instance proxy 1.
```
gcloud compute instances create PROXY_INSTANCE_1 \
--project=PROJECT_ID \
--network-interface=network-tier=PREMIUM,subnet=SUBNET_NAME_2,no-address
```
Berdasarkan kebutuhan, Anda dapat membuat instance VM sebanyak yang diperlukan.

Buat aturan firewall untuk mengizinkan SSH ke instance VM Anda.

gcloud compute firewall-rules create FIREWALL_RULE_NAME_SSH \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK --allow=tcp:22

Instal proxy SOCKS5.

Langkah-langkah mendetail untuk menginstal dan mengonfigurasi server proxy SOCKS5 tidak termasuk dalam cakupan dokumen ini, dan Anda dapat menginstal proxy SOCKS5 apa pun pilihan Anda. Langkah berikut menunjukkan cara menginstal dan mengonfigurasi server proxy Dante SOCKS5.

SSH ke instance VM Anda.

gcloud compute ssh \
    --tunnel-through-iap \
    PROXY_INSTANCE_1

Instal server proxy Dante SOCKS5.

sudo apt update
sudo apt install dante-server

Periksa antarmuka server.
```
sudo ip a
```

Membuat cadangan konfigurasi Dante.

sudo mv /etc/danted.conf /etc/danted.conf.bak

Membuat file konfigurasi Dante baru.
```
sudo nano /etc/danted.conf
```

Salin konfigurasi berikut ke file konfigurasi:

logoutput: /var/log/socks.log
# Bind the server to the 0.0.0.0 IP address to allow traffic
# traffic from the load balancer and the health check probes.
internal: 0.0.0.0 port = 1080
external: ens4
clientmethod: none
socksmethod: none
user.privileged: root
user.notprivileged: nobody
client pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: error connect disconnect
}
client block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
}
socks pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: error connect disconnect
}
socks block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
}

Mulai ulang server Dante dan periksa statusnya.

sudo systemctl restart danted
sudo systemctl status danted

Keluar dari instance VM.
```
exit
```

Siapkan grup instance yang tidak dikelola.
1. Membuat grup instance yang tidak dikelola.
```
gcloud compute instance-groups unmanaged create INSTANCE_GROUP_NAME
```
  Catatan: Tutorial ini menggunakan grup instance yang tidak dikelola. Anda dapat membuat grup instance terkelola untuk keandalan yang lebih baik.
2. Tambahkan instance VM yang dibuat di langkah 3 ke grup.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME \
--instances=PROXY_INSTANCE_1
```

Buat pemeriksaan health check dan izinkan traffic dari pemeriksaan.

Membuat pemeriksaan health check.
```
gcloud compute health-checks create tcp HEALTH_CHECK_NAME \
--port BACKEND_SERVER_PORT --region=REGION
```
Dalam perintah ini, tetapkan BACKEND_SERVER_PORT ke 1080 yang merupakan port default tempat server proxy SOCKS5 dijalankan.

Buat aturan firewall untuk mengizinkan traffic dari pemeriksaan.

gcloud compute firewall-rules create FIREWALL_RULE_NAME_HEALTHCHECK \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK --allow=tcp:BACKEND_SERVER_PORT \
--source-ranges=35.191.0.0/16,130.211.0.0/22

Membuat load balancer internal L4 lalu mengizinkan traffic dari load balancer.

Buat layanan backend.

gcloud compute backend-services create BACKEND_SERVICE \
--load-balancing-scheme=internal --protocol=tcp --health-checks=HEALTH_CHECK_NAME \
--health-checks-region=REGION

Tambahkan grup instance ke layanan backend.

gcloud compute backend-services add-backend BACKEND_SERVICE \
--instance-group=INSTANCE_GROUP_NAME \
--instance-group-zone=ZONE

Membuat aturan penerusan.

gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
--load-balancing-scheme=internal --network=VPC_NETWORK --subnet=SUBNET_NAME_2 \
--ip-protocol=TCP --ports=BACKEND_SERVER_PORT --backend-service=BACKEND_SERVICE \
--backend-service-region=REGION

Buat aturan firewall untuk mengizinkan traffic internal dari load-balancer ke grup instance.

gcloud compute firewall-rules create FIREWALL_RULE_NAME_INTERNAL \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK \
--action=ALLOW --rules=all --source-ranges=SUBNET_RANGE_2

Buat lampiran layanan PSC.
1. Buat aturan firewall untuk mengizinkan traffic dari lampiran layanan PSC ke load balancer internal yang dibuat pada langkah sebelumnya.
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME_SA \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK \
--allow=tcp:BACKEND_SERVER_PORT --source-ranges=SUBNET_RANGE_1
```
2. Buat lampiran layanan dengan persetujuan eksplisit.
```
gcloud compute service-attachments create SERVICE_ATTACHMENT_NAME \
--producer-forwarding-rule=FORWARDING_RULE_NAME  \
--connection-preference=ACCEPT_MANUAL \
--consumer-accept-list=SERVICE_DIRECTORY_PROJECT_ID=LIMIT \
--nat-subnets=SUBNET_NAME_1
```
  Dalam perintah ini, LIMIT adalah batas koneksi untuk project. Batas koneksi adalah jumlah endpoint Private Service Connect konsumen yang dapat terhubung ke layanan ini. Untuk memahami cara mendapatkan SERVICE_DIRECTORY_PROJECT_ID, lihat Mendapatkan project ID direktori layanan.
Buat lampiran endpoint.
Anda dapat menganggap lampiran endpoint sebagai antarmuka ke lampiran layanan PSC. Anda tidak dapat menggunakan lampiran layanan PSC secara langsung untuk mengonfigurasi konektivitas pribadi. Lampiran layanan PSC hanya dapat diakses melalui lampiran endpoint. Anda juga dapat membuat lampiran endpoint sebagai alamat IP atau nama host. Setelah membuat lampiran endpoint, Anda dapat menggunakannya saat mengonfigurasi konektor untuk konektivitas pribadi. Untuk mengetahui informasi selengkapnya, lihat Membuat lampiran endpoint.

Catatan: Anda harus menggunakan alamat IP atau nama host lampiran endpoint sebagai alamat proxy SOCKS5 saat membuat koneksi.
Verifikasi penyiapan PSC.
Anda dapat memverifikasi konektivitas pribadi dengan membuat koneksi Cloud SQL dan menyiapkan server proxy SOCKS5 seperti yang ditunjukkan dalam tutorial ini. Untuk mengetahui langkah-langkah mendetail tentang cara membuat koneksi, lihat dokumentasi konektor (Cloud SQL untuk MySQL, Cloud SQL untuk PostgreSQL, atau Cloud SQL untuk SQL Server). Saat membuat koneksi, di bagian Destinations (pada langkah 5), pilih Destination type sebagai Host address, lalu masukkan alamat IP atau nama host lampiran endpoint untuk detail server proxy SOCKS5. Tetapkan nilai port ke 1080, kecuali jika Anda telah mengonfigurasi port yang berbeda untuk server proxy SOCKS5. Jika pembuatan koneksi berhasil, status koneksi yang baru dibuat adalah Active di halaman Koneksi Anda di Cloud Console.

Mendapatkan project ID direktori layanan

Sebagai praktik terbaik, Anda dapat membuat lampiran layanan PSC sehingga hanya menerima permintaan dari project Google Cloud yang ditentukan. Namun, untuk melakukannya, Anda memerlukan project ID dari direktori layanan yang terkait dengan project Google Cloud Anda. Untuk mendapatkan project ID direktori layanan, Anda dapat menggunakan List Connections API seperti yang ditunjukkan dalam contoh berikut.

Sintaksis

curl -X GET \
    -H "authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://connectors.googleapis.com/v1/projects/CONNECTORS_PROJECT_ID/locations/-/connections"

Ganti kode berikut:

CONNECTORS_PROJECT_ID: ID project Google Cloud tempat Anda membuat koneksi.

Contoh

Contoh ini mendapatkan project ID dari direktori layanan untuk project Google Cloud connectors-test.

curl -X GET \
    -H "authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://connectors.googleapis.com/v1/projects/connectors-test/locations/-/connections"

Menjalankan perintah ini di terminal akan menampilkan output yang mirip dengan berikut ini:

.....
{
  "connections": [
    {
      "name": "projects/connectors-test/locations/asia-northeast1/connections/big-query-iam-invalid-sa",
      "createTime": "2022-10-07T09:02:31.905048520Z",
      "updateTime": "2022-10-07T09:22:39.993778690Z",
      "connectorVersion": "projects/connectors-test/locations/global/providers/gcp/connectors/bigquery/versions/1",
      "status": {
        "state": "ACTIVE"
      },
      "configVariables": [
        {
          "key": "project_id",
          "stringValue": "connectors-test"
        },
        {
          "key": "dataset_id",
          "stringValue": "testDataset"
        }
      ],
      "authConfig": {},
      "serviceAccount": "564332356444-compute@developer.gserviceaccount.com",
      "serviceDirectory": "projects/abcdefghijk-tp/locations/asia-northeast1/namespaces/connectors/services/runtime",
      "nodeConfig": {
        "minNodeCount": 2,
        "maxNodeCount": 50
      }
    },
....

Dalam contoh output, untuk project Google Cloud connectors-test, project ID direktori layanan adalah abcdefghijk-tp.