Versi 1.20

Versi yang tersedia

1.20 (terbaru)
1.19
1.18
1.17
1.16
1.15
1.14
1.13
1.12
1.12

219}

Halaman ini diterjemahkan oleh Cloud Translation API.

Mengonfigurasi Cloud Service Mesh untuk Cloud Run

Halaman ini menunjukkan cara mengonfigurasi Cloud Service Mesh untuk dijalankan pada infrastruktur komputasi untuk layanan Cloud Run.

Cloud Service Mesh memungkinkan Anda mengaktifkan mesh kemampuan pengelolaan traffic lanjutan, seperti pemisahan traffic berbobot dan load balancing global, serta kebijakan keamanan dan kemampuan observasi untuk traffic dari satu Cloud Run layanan ke layanan lain. Ini juga memberi Anda solusi bidang data yang terkelola sepenuhnya yang menghilangkan beban operasional pengelolaan file bantuan mesh layanan Anda sendiri.

Sebelum memulai

Memahami Cloud Service Mesh.

Tetapkan project Anda:

gcloud config set core/project PROJECT_ID

Di Konsol Google Cloud, aktifkan API berikut untuk project Anda:
- Cloud DNS API
- API Layanan Jaringan
- API Keamanan Jaringan
- Traffic Director API
- API Akses VPC Serverless jika Anda menggunakan konektor Akses VPC Serverless dan bukan VPC Langsung untuk traffic keluar jaringan.
Update komponen gcloud ke versi terbaru (488.0.0 atau yang lebih baru):
```
gcloud components update
```

Peran yang diperlukan

Untuk mendapatkan izin yang Anda perlukan untuk mengonfigurasi dan men-deploy Cloud Run layanan, minta administrator untuk memberi Anda IAM berikut peran:

Developer Cloud Run (roles/run.developer) di layanan Cloud Run
Service Account User (roles/iam.serviceAccountUser) pada identitas layanan

Akun layanan klien Cloud Run juga harus memiliki peran berikut:

Klien Traffic Director (roles/trafficdirector.client) untuk mengakses API pemilihan rute layanan
Agen Cloud Trace (roles/cloudtrace.agent) untuk mengaktifkan pelacakan

Untuk mengetahui daftar peran dan izin IAM yang terkait dengan Cloud Run, lihat Peran IAM Cloud Run dan Izin IAM Cloud Run. Jika antarmuka layanan Cloud Run Anda dengan Google Cloud API, seperti Library Klien Cloud, lihat panduan konfigurasi identitas layanan. Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat izin deployment dan mengelola akses.

Panggilan antara layanan Cloud Run menggunakan Cloud Service Mesh

Cloud Run menggunakan Cloud Service Mesh API perutean layanan. API ini memungkinkan layanan Cloud Run memanggil Layanan Cloud Run menggunakan URL yang disesuaikan, bukan memberikan run.app URL. Selain itu, Cloud Run otomatis melakukan otentikasi ke layanan Cloud Run tujuan, sehingga Anda tidak perlu mengkonfigurasi otentikasi Anda sendiri untuk melampirkan kredensial permintaan ke layanan Cloud Run lainnya.

Untuk memanggil dari satu layanan Cloud Run ke layanan lain menggunakan Cloud Service Mesh, ikuti langkah-langkah berikut:

Menyiapkan Cloud Service Mesh
Menyiapkan Cloud DNS
Membuat layanan Cloud Run tujuan
Buat NEG serverless
Membuat layanan Cloud Run klien
Memanggil layanan dari klien mesh

Menyiapkan Cloud Service Mesh

Untuk membuat rute layanan menggunakan URL default, simpan Mesh spesifikasi dalam file bernama mesh.yaml:
```
name: MESH_NAME
```
Ganti MESH_NAME dengan resource mesh nama.
Impor resource Mesh dari spesifikasi dengan menjalankan perintah berikut berikut:
```
gcloud network-services meshes import MESH_NAME \
  --source=mesh.yaml \
  --location=global
```
Ganti MESH_NAME dengan resource mesh nama.

Menyiapkan Cloud DNS

Anda dapat melewati penyiapan Cloud DNS dan masuk ke bagian berikutnya jika Anda menggunakan endpoint Private Service Connect dengan alamat URL run.app lengkap sebagai nama host karena hanya IP pribadi alamat IP eksternal tersebut dicatat.

Saat klien mesh memanggil layanan tujuan, nama host yang digunakan dalam permintaan harus dapat diselesaikan melalui DNS. Semua RFC 1918 yang valid Alamat IP dapat diterima karena file bantuan merekam semua traffic IP ke IP ini rentang alamat IP dan mengalihkannya dengan benar.

Contoh berikut menunjukkan cara membuat entri * karakter pengganti di Cloud DNS zona yang di-resolve menjadi satu alamat IP. Jika Anda tidak ingin menggunakan Zona Cloud DNS, buat entri Cloud DNS untuk setiap nama host sesuai dengan layanan Cloud Run yang ingin Anda yang dapat ditangani dari jala.

Untuk membuat data Cloud DNS di zona eksklusif, jalankan perintah berikut berikut:
1. Membuat zona DNS terkelola pribadi di Cloud DNS untuk layanan {i>mesh.<i}
```
gcloud dns managed-zones create MESH_NAME \
--description="Domain for DOMAIN_NAME service mesh routes" \
--dns-name=DOMAIN_NAME. \
--network=VPC_NETWORK_NAME \
--visibility=private
```
2. Buat data DNS dalam zona terkelola pribadi yang baru dibuat. Merek pastikan alamat IP 10.0.0.1 tidak digunakan.
```
gcloud dns record-sets create "*.DOMAIN_NAME." \
--type=A \
--zone="MESH_NAME" \
--rrdatas=10.0.0.1 \
--ttl=3600
```
  Ganti kode berikut:
  - DOMAIN_NAME: nama domain DNS.
  - MESH_NAME: nama resource mesh.
  - VPC_NETWORK_NAME: nama VPC Anda jaringan: misalnya, "default".

Mengakses layanan internal dengan Cloud Service Mesh

Cloud Run memungkinkan Anda membatasi traffic jaringan yang masuk ke "internal". Jika layanan Anda mengaktifkan pembatasan masuk data, traffic yang yang dikirim dari mesh Anda melalui jaringan Virtual Private Cloud dapat ditetapkan sebagai saat Anda mengaktifkan jalur akses ke Cloud Run.

Untuk mengakses layanan internal dengan Cloud Service Mesh, gunakan salah satu metode berikut:

Konfigurasi Akses Google Pribadi untuk jaringan VPC Anda. Anda tidak perlu menyiapkan catatan DNS kustom.
Melampirkan endpoint Private Service Connect ke Cloud Service Mesh. Hal ini memerlukan penyiapan data DNS kustom untuk URL *.run.app default agar dapat menggunakan Alamat endpoint Private Service Connect.

Membuat layanan Cloud Run tujuan

Perhatikan bahwa tujuan Cloud Run tidak boleh memiliki URL default dinonaktifkan.

Deploy layanan Cloud Run baru atau yang sudah ada:
```
gcloud run deploy DESTINATION_SERVICE_NAME \
--no-allow-unauthenticated \
--region=REGION \
--image=IMAGE_URL 
```
Ganti kode berikut:
- DESTINATION_SERVICE_NAME: nama ke layanan Cloud Run tujuan.
- REGION: nama region.
- IMAGE_URL: referensi ke image container, seperti us-docker.pkg.dev/cloudrun/container/hello:latest.

Membuat grup endpoint jaringan serverless (NEG)

Buat NEG tujuan dengan menjalankan perintah berikut:

gcloud compute network-endpoint-groups create destination-neg \
--region=REGION \
--network-endpoint-type=serverless \
--cloud-run-service=DESTINATION_SERVICE_NAME

Ganti kode berikut:

REGION: nama region.
DESTINATION_SERVICE_NAME: nama ke layanan Cloud Run tujuan.

Buat layanan backend yang dikelola sendiri secara internal yang mereferensikan NEG serverless.
1. Buat layanan backend:
```
gcloud compute backend-services create DESTINATION_SERVICE_NAME-REGION \
--global \
--load-balancing-scheme=INTERNAL_SELF_MANAGED
```
  Ganti DESTINATION_SERVICE_NAME dengan nama layanan tujuan dan REGION dengan nama wilayah.
2. Tambahkan backend serverless ke layanan backend:
```
gcloud compute backend-services add-backend DESTINATION_SERVICE_NAME-REGION \
--global \
--network-endpoint-group=destination-neg \
--network-endpoint-group-region=REGION
```
  Ganti DESTINATION_SERVICE_NAME dengan nama layanan tujuan dan REGION dengan nama wilayah.
Membuat rute HTTP yang merujuk ke layanan backend.

Resource dan layanan Mesh dikonfigurasi. Hubungkan mereka dengan Resource HTTPRoute yang mengaitkan nama host dengan layanan backend.
1. Membuat spesifikasi HTTPRoute dan menyimpannya ke file bernama http_route.yaml:
```
name: "DESTINATION_SERVICE_NAME-route"
hostnames:
- "DESTINATION_SERVICE_NAME.DOMAIN_NAME"
meshes:
- "projects/PROJECT_ID/locations/global/meshes/MESH_NAME"
rules:
- action:
   destinations:
   - serviceName: "projects/PROJECT_ID/locations/global/backendServices/DESTINATION_SERVICE_NAME-REGION"
```
  Setel nama host ke nama yang ingin Anda gunakan untuk menangani layanan. Semua klien dalam mesh layanan yang sama dapat memanggil layanan ini menggunakan URL http://<HOSTNAME>, terlepas dari region dan project pemanggil. Jika Anda telah menyiapkan Cloud DNS untuk menggunakan IP pribadi alamat, nama host rute juga dapat berupa URL run.app lengkap —dalam hal ini, Anda dapat melewati langkah penyiapan Cloud DNS.
  
  Ganti kode berikut:
  - DESTINATION_SERVICE_NAME: nama ke layanan Cloud Run tujuan.
  - DOMAIN_NAME: nama domain DNS.
  - PROJECT_ID: ID project.
  - MESH_NAME: nama mesh.
  - REGION: nama region.
2. Buat resource HTTPRoute dengan menggunakan spesifikasi dalam File http_route.yaml:
```
gcloud network-services http-routes import DESTINATION_SERVICE_NAME-route \
--source=http_route.yaml \
--location=global
```
3. Memberikan peran Cloud Run Invoker (roles/iam.invoker) di layanan tujuan Cloud Run dengan menjalankan perintah berikut:
```
gcloud run services add-iam-policy-binding DESTINATION_SERVICE_NAME \
--region REGION \
--member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
--role=roles/run.invoker
```
  Ganti kode berikut:
  - DESTINATION_SERVICE_NAME: nama ke layanan Cloud Run tujuan.
  - REGION: nama region.
  - PROJECT_NUMBER: nomor project.

Membuat layanan Cloud Run klien

Membuat layanan Cloud Run klien akan membuat file bantuan Envoy yang sumber dayanya terkait dengan QPS dan ukuran konfigurasi total Anda. Sebagian besar lain waktu, penggunaan CPU kurang dari 1 persen dari vCPU dan penggunaan memori kurang dari 50 MB.

Anda harus memiliki akses keluar jaringan ke jaringan Virtual Private Cloud.

Untuk membuat layanan klien bagi pengujian, deploy aplikasi fortio di Cloud Run untuk mengizinkan penerusan traffic ke rute HTTP:
```
gcloud beta run deploy CLIENT_SERVICE_NAME \
--region=REGION \
--image=fortio/fortio \
--network=VPC_NETWORK_NAME \
--subnet=SUBNET_NAME \
--mesh="projects/PROJECT_ID/locations/global/meshes/MESH_NAME"
```
Ganti kode berikut:
- CLIENT_SERVICE_NAME: nama klien Cloud Run.
- REGION: nama wilayah Anda.
- VPC_NETWORK_NAME: nama Jaringan VPC; misalnya, "default".
- SUBNET_NAME: nama subnet Anda; misalnya, "default".
- PROJECT_ID: ID project Anda.
- MESH_NAME: resource mesh nama.
Catatan:
Jika penampung gagal dimulai, pastikan Anda telah mengaktifkan semua API. Anda mungkin juga perlu memberi akun layanan Anda akses ke Traffic Director dengan menjalankan perintah berikut:
```
gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com --role=roles/trafficdirector.client
```

Memanggil layanan dari klien mesh

Untuk meneruskan permintaan ke rute tujuan dengan menggunakan aplikasi pengujian fortio dari bagian Create client service sebelumnya:

Ambil URL layanan klien Cloud Run yang Anda dibuat dengan menjalankan perintah berikut:
```
TEST_SERVICE_URL=$(gcloud run services describe CLIENT_SERVICE_NAME \
--region=REGION --format="value(status.url)" \
--project=PROJECT_ID)
```
Ganti kode berikut:
- CLIENT_SERVICE_NAME: nama klien layanan Cloud Run.
- REGION: nama wilayah Anda.
- PROJECT_ID: ID project Anda.
Gunakan perintah curl untuk mengirim permintaan ke rute tujuan endpoint fortio dari langkah sebelumnya:
```
curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" "$TEST_SERVICE_URL/fortio/fetch/DESTINATION_SERVICE_NAME.DOMAIN_NAME"
```
Ganti kode berikut:
- DESTINATION_SERVICE_NAME: nama ke layanan Cloud Run tujuan.
- DOMAIN_NAME: nama domain DNS.

Memanggil backend Compute Engine dari Cloud Run

Untuk men-deploy rute layanan Compute Engine dan Cloud Service Mesh menggunakan grup instance terkelola sebagai backend, mengonfigurasi server HTTP berbasis Compute Engine di Cloud Service Mesh. Ini memungkinkan klien Cloud Run menggunakan rute layanan backend ini untuk mengirim permintaan langsung ke instance Compute Engine.

Langkah berikutnya

Mempelajari konfigurasi jaringan Cloud Run umum untuk jaringan publik dan pribadi
Mengonfigurasi jaringan pribadi untuk Cloud Run
Menyiapkan proxy Envoy dengan layanan HTTP