Menerima peristiwa Pub/Sub di endpoint HTTP pribadi dalam cluster GKE pribadi

Pratinjau

Fitur ini tunduk kepada "Persyaratan Penawaran Pra-GA" di bagian Persyaratan Layanan Umum dari Persyaratan Khusus Layanan. Fitur pra-GA tersedia "sebagaimana adanya" dan mungkin memiliki dukungan terbatas. Untuk mengetahui informasi selengkapnya, lihat deskripsi tahap peluncuran.

Tutorial ini menunjukkan cara membuat endpoint HTTP pribadi di cluster Google Kubernetes Engine (GKE) pribadi yang menerima peristiwa pesan Pub/Sub menggunakan Eventarc. Untuk mempelajari lebih lanjut tujuan peristiwa ini, lihat artikel Merutekan peristiwa ke endpoint HTTP internal dalam jaringan VPC.

Cluster GKE pribadi adalah jenis cluster native Virtual Private Cloud (VPC) yang node-nya hanya memiliki alamat IP internal, yang berarti node dan Pod diisolasi dari internet secara default. Anda dapat memilih untuk tidak memiliki akses klien, akses terbatas, atau akses tidak terbatas ke bidang kontrol. Anda tidak dapat mengonversi cluster non-pribadi yang ada menjadi cluster pribadi. Untuk mengetahui informasi selengkapnya, lihat Tentang cluster pribadi.

Anda dapat menjalankan perintah berikut menggunakan Google Cloud CLI di terminal atau Cloud Shell.

Buat subnet khusus proxy

Kecuali jika Anda membuat kebijakan organisasi yang melarangnya, project baru dimulai dengan jaringan default (jaringan VPC mode otomatis) yang memiliki satu subnetwork (subnet) di setiap region. Setiap jaringan VPC terdiri dari satu atau beberapa rentang alamat IP yang disebut subnet. Subnet adalah resource regional, dan memiliki rentang alamat IP yang terkait dengannya.

1. Gunakan perintah gcloud compute networks subnets create untuk membuat subnet khusus proxy di jaringan default.

   gcloud compute networks subnets create proxy-only-subnet \
       --purpose=REGIONAL_MANAGED_PROXY \
       --role=ACTIVE \
       --region=us-central1 \
       --network=default \
       --range=10.10.10.0/24
   

   Perhatikan bahwa subnet dengan purpose=REGIONAL_MANAGED_PROXY dicadangkan untuk load balancer berbasis Envoy dan range harus menyediakan 64 alamat IP atau lebih.

2. Buat aturan firewall yang cocok dengan rentang subnet khusus proxy dan yang mengizinkan traffic di port TCP 8080.

   gcloud compute firewall-rules create allow-proxy-connection \
       --allow tcp:8080 \
       --source-ranges 10.10.10.0/24 \
       --network=default
   

Membuat cluster GKE pribadi

Gunakan perintah gcloud container clusters create-auto untuk membuat cluster GKE pribadi dalam mode Autopilot yang memiliki node pribadi dan tidak memiliki akses klien ke endpoint publik.

Contoh berikut membuat cluster GKE pribadi bernama private-cluster dan juga membuat subnet bernama my-subnet:

gcloud container clusters create-auto private-cluster \
    --create-subnetwork name=my-subnet \
    --enable-master-authorized-networks \
    --enable-private-nodes \
    --enable-private-endpoint \
    --region=us-central1

Perhatikan hal berikut:

• --enable-master-authorized-networks menentukan bahwa akses ke endpoint publik dibatasi untuk rentang alamat IP yang Anda otorisasi.
• --enable-private-nodes menunjukkan bahwa node cluster tidak memiliki alamat IP eksternal.
• --enable-private-endpoint menunjukkan bahwa cluster dikelola menggunakan alamat IP internal endpoint API bidang kontrol.

Mungkin perlu waktu beberapa menit hingga pembuatan cluster selesai. Setelah cluster dibuat, output akan menunjukkan bahwa status cluster adalah RUNNING.

Membuat instance VM di subnet yang ditentukan

Instance VM Compute Engine adalah virtual machine yang dihosting di infrastruktur Google. Istilah instance Compute Engine, instance VM, dan VM merupakan istilah yang sama dan dapat digunakan secara bergantian. Instance VM mencakup cluster GKE, instance lingkungan fleksibel App Engine, dan produk lainnya yang dibangun di VM Compute Engine. Google Cloud

Gunakan perintah gcloud compute instances create untuk membuat instance VM Compute Engine di subnet yang Anda buat sebelumnya. Pasang akun layanan dan tetapkan cakupan akses VM ke cloud-platform.

gcloud compute instances create my-vm \
    --service-account=[e-mail] \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --zone=us-central1-a \
    --subnet=my-subnet

Untuk mengetahui informasi selengkapnya, lihat Membuat dan memulai instance VM.

Men-deploy penerima peristiwa di VM

Dengan menggunakan image bawaan, us-docker.pkg.dev/cloudrun/container/hello, deploy layanan di VM yang memproses di port 80, serta menerima dan mencatat peristiwa.

1. Buat koneksi SSH ke instance VM Anda dengan menjalankan perintah berikut:

   gcloud compute ssh my-vm --project=PROJECT_ID --zone=us-central1-a
   

   Setelah koneksi ke server SSH dibuat, jalankan perintah yang tersisa di instance VM Anda.

2. Jika perlu, instal kubectl dan plugin yang diperlukan.

3. Dari instance VM, gunakan perintah get-credentials agar kubectl dapat berfungsi dengan cluster yang telah Anda buat.

   gcloud container clusters get-credentials private-cluster \
       --region=us-central1 \
       --internal-ip
   

4. Gunakan perintah Kubernetes, kubectl create deployment, untuk men-deploy aplikasi ke cluster.

   kubectl create deployment hello-app \
       --image=us-docker.pkg.dev/cloudrun/container/hello
   

   Tindakan ini akan membuat Deployment bernama hello-app. Pod Deployment akan menjalankan image container hello.

5. Setelah men-deploy aplikasi, Anda dapat mengekspos aplikasi ke traffic dengan membuat Layanan Kubernetes. Jalankan perintah kubectl expose berikut:

   kubectl expose deployment hello-app \
       --type ClusterIP \
       --port 80 \
       --target-port 8080
   

   Anda akan melihat service/hello-app exposed dalam output.

   Anda dapat mengabaikan pesan apa pun yang mirip dengan berikut ini:

   E0418 14:15:33.970933    1129 memcache.go:287] couldn't get resource list for metrics.k8s.io/v1beta1: the server is currently unable to handle the request
   

Mengonfigurasi perutean traffic Kubernetes

Resource Gateway merepresentasikan bidang data yang merutekan traffic di Kubernetes. Gateway dapat merepresentasikan berbagai jenis load balancing dan pemilihan rute, bergantung pada GatewayClass tempat gateway berasal. Untuk mengetahui informasi selengkapnya, lihat Men-deploy Gateway. Manifes HTTPRoute di-deploy untuk membuat Rute dan mengirim traffic ke backend aplikasi.

1. Deploy Gateway di cluster Anda.

   kubectl apply -f - <<EOF
   kind: Gateway
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: internal-http
   spec:
     gatewayClassName: gke-l7-rilb
     listeners:
     - name: http
       protocol: HTTP
       port: 80
   EOF
   

   Perhatikan hal berikut:

   • gatewayClassName: gke-l7-rilb menentukan GatewayClass asal Gateway ini. gke-l7-rilb sesuai dengan Load Balancer Aplikasi internal.
   • port: 80 menentukan bahwa Gateway hanya mengekspos port 80 untuk memproses traffic HTTP.

2. Validasi bahwa Gateway telah di-deploy dengan benar. Mungkin diperlukan waktu beberapa menit untuk men-deploy semua resource-nya.

   kubectl describe gateways.gateway.networking.k8s.io internal-http
   

   Outputnya mirip dengan hal berikut ini:

   Name:         internal-http
   Namespace:    default
   ...
   API Version:  gateway.networking.k8s.io/v1beta1
   Kind:         Gateway
   ...
   Spec:
     Gateway Class Name:  gke-l7-rilb
     Listeners:
       Allowed Routes:
         Namespaces:
           From:  Same
       Name:      http
       Port:      80
       Protocol:  HTTP
   Status:
     Addresses:
       Type:   IPAddress
       Value:  10.36.172.5
   ...
   Events:
     Type    Reason  Age                From                   Message
     ----    ------  ----               ----                   -------
     Normal  ADD     80s                sc-gateway-controller  default/internal-http
     Normal  UPDATE  20s (x3 over 80s)  sc-gateway-controller  default/internal-http
     Normal  SYNC    20s                sc-gateway-controller  SYNC on default/internal-http was a success
   

3. Deploy manifes HTTPRoute untuk merutekan traffic HTTP ke layanan hello-app di port 80.

   kubectl apply -f - <<EOF
   kind: HTTPRoute
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: hello-app-route
   spec:
     parentRefs:
     - kind: Gateway
       name: internal-http
     rules:
     - backendRefs:
       - name: hello-app
         port: 80
   EOF
   

Membuat lampiran jaringan

Lampiran jaringan adalah resource yang memungkinkan jaringan VPC produsen memulai koneksi ke jaringan VPC konsumen melalui antarmuka Private Service Connect.

Untuk memublikasikan peristiwa, Eventarc menggunakan lampiran jaringan untuk membuat koneksi ke endpoint HTTP internal yang dihosting di jaringan VPC.

Catatan: Eventarc mencadangkan rentang IP CIDR subnet 240.0.0.0/20. Subnet yang digunakan untuk lampiran jaringan tidak boleh tumpang-tindih dengan rentang ini.

Anda dapat membuat lampiran jaringan yang otomatis menerima koneksi dari antarmuka Private Service Connect mana pun yang merujuk ke lampiran jaringan. Buat lampiran jaringan di jaringan dan region yang sama dengan layanan tujuan HTTP.

gcloud compute network-attachments create my-network-attachment \
    --region=us-central1 \
    --subnets=my-subnet\
    --connection-preference=ACCEPT_AUTOMATIC

Untuk mengetahui informasi selengkapnya, lihat Tentang lampiran jaringan.

Membuat pemicu Eventarc

Buat pemicu Eventarc yang membuat topik Pub/Sub baru dan merutekan peristiwa ke penerima peristiwa yang di-deploy di VM saat pesan dipublikasikan ke topik Pub/Sub.

1. Ambil alamat Gateway.

   GATEWAY_ADDRESS=$(kubectl get gateways.gateway.networking.k8s.io internal-http -o=jsonpath="{.status.addresses[0].value}")
   

2. Buat pemicu.

   gcloud eventarc triggers create my-trigger \
       --location=us-central1 \
       --destination-http-endpoint-uri="http://$GATEWAY_ADDRESS:80/" \
       --network-attachment="projects/PROJECT_ID/regions/us-central1/networkAttachments/my-network-attachment" \
       --event-filters="type=google.cloud.pubsub.topic.v1.messagePublished" \
       --service-account=[e-mail]
   

   Ganti PROJECT_NUMBER dengan Google Cloud nomor project Anda. Anda dapat menemukan nomor project di halaman Selamat Datang di konsol Google Cloud atau dengan menjalankan perintah berikut:

   gcloud projects describe PROJECT_ID --format='value(projectNumber)'
   

Untuk mengetahui informasi selengkapnya tentang cara mengonfigurasi pemicu, lihat Merutekan peristiwa ke endpoint HTTP internal dalam jaringan VPC.

Catatan: Pembuatan pemicu mungkin memerlukan waktu beberapa menit, dan kemudian diperlukan waktu hingga dua menit agar pemicu berfungsi sepenuhnya.

Membuat dan melihat peristiwa topik Pub/Sub

Anda dapat membuat peristiwa dengan memublikasikan pesan ke topik Pub/Sub.

1. Cari dan tetapkan topik Pub/Sub sebagai variabel lingkungan.

   export MY_TOPIC=$(gcloud eventarc triggers describe my-trigger \
       --location=us-central1 \
       --format='value(transport.pubsub.topic)')
   

2. Publikasikan pesan ke topik Pub/Sub untuk membuat peristiwa.

   gcloud pubsub topics publish $MY_TOPIC --message "Hello World"
   

   Pemicu Eventarc merutekan peristiwa ke endpoint HTTP internal di cluster GKE pribadi.

3. Periksa log Pod aplikasi dan verifikasi pengiriman peristiwa.

   POD_NAME=$(kubectl get pod --selector app=hello-app --output=name)
   kubectl logs $POD_NAME
   

   Isi peristiwa harus serupa dengan berikut ini:

   2024/04/18 20:31:43 Hello from Cloud Run! The container started successfully and is listening for HTTP requests on $PORT
   {"severity":"INFO","eventType":"google.cloud.pubsub.topic.v1.messagePublished","message":"Received event of type google.cloud.pubsub.topic.v1.messagePublished.
   Event data: Hello World","event":{"specversion":"1.0","id":"10935738681111260","source":"//pubsub.googleapis.com/projects/my-project/topics/eventarc-us-central1-my-trigger-224","type":"google.cloud.pubsub.topic.v1.messagePublished","datacontenttype":"application/json","time":"2024-04-18T20:40:03Z","data":
   {"message":{"data":"SGVsbG8gV29ybGQ=","messageId":"10935738681111260","publishTime":"2024-04-18T20:40:03Z"}}}}
   

Anda telah berhasil men-deploy layanan penerima peristiwa ke endpoint HTTP internal dalam cluster GKE pribadi, membuat pemicu Eventarc, membuat peristiwa dari Pub/Sub, dan mengonfirmasi bahwa peristiwa dirutekan seperti yang diharapkan oleh pemicu ke endpoint target.