Cloud Service Mesh dan Traffic Director kini bergabung menjadi Cloud Service Mesh. Untuk mengetahui informasi selengkapnya, lihat ringkasan Cloud Service Mesh.

Halaman ini diterjemahkan oleh Cloud Translation API.

Mengonfigurasi Cloud Service Mesh untuk Cloud Run

Halaman ini menunjukkan cara mengonfigurasi Cloud Service Mesh agar berjalan di berbagai infrastruktur komputasi untuk layanan Cloud Run.

Cloud Service Mesh memungkinkan Anda mengaktifkan kemampuan pengelolaan traffic lanjutan mesh, seperti pemisahan traffic berbobot dan load balancing global, serta kebijakan observasi dan keamanan untuk traffic dari satu layanan Cloud Run ke layanan lainnya. Solusi ini juga memberi Anda solusi bidang data terkelola sepenuhnya yang menghilangkan beban operasional dalam memelihara sidecar 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:
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
```

Batasan

Layanan Cloud Run yang menggunakan Cloud Service Mesh mungkin mengalami peningkatan latensi cold start. Lihat bagian Tips pengembangan umum dalam dokumentasi Cloud Run untuk mendapatkan saran tentang cara meningkatkan waktu mulai.

Peran yang diperlukan

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

Cloud Run Developer (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 perutean layanan
Cloud Trace Agent (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 layanan Cloud Run Anda berinteraksi 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 antar-layanan Cloud Run menggunakan Cloud Service Mesh

Cloud Run menggunakan API perutean layanan Cloud Service Mesh. API ini memungkinkan layanan Cloud Run memanggil layanan Cloud Run lainnya menggunakan URL yang disesuaikan, bukan URL run.app yang disediakan. Selain itu, Cloud Run otomatis mengautentikasi ke layanan Cloud Run tujuan sehingga Anda tidak perlu mengonfigurasi autentikasi sendiri untuk melampirkan kredensial permintaan ke layanan Cloud Run lainnya.

Untuk melakukan panggilan dari satu layanan Cloud Run ke layanan Cloud Run lainnya menggunakan Cloud Service Mesh, ikuti langkah-langkah berikut:

Menyiapkan Cloud Service Mesh
Menyiapkan Cloud DNS
Buat layanan Cloud Run tujuan
Buat NEG tanpa server
Buat layanan Cloud Run klien
Memanggil layanan dari klien mesh

Menyiapkan Cloud Service Mesh

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

Menyiapkan Cloud DNS

Anda dapat melewati penyiapan Cloud DNS dan membuka bagian berikutnya jika Anda menggunakan endpoint Private Service Connect dengan alamat URL run.app lengkap sebagai nama host karena hanya alamat IP pribadi yang diambil.

Saat klien mesh memanggil layanan tujuan, nama host yang digunakan dalam permintaan harus dapat di-resolve melalui DNS. Alamat IP RFC 1918 yang valid dapat diterima karena sidecar mengambil semua traffic IP ke rentang alamat IP ini dan mengalihkannya dengan tepat.

Contoh berikut menunjukkan cara membuat entri * wildcard di zona Cloud DNS yang diselesaikan ke satu alamat IP. Jika Anda tidak ingin menggunakan zona Cloud DNS eksklusif, buat entri Cloud DNS untuk setiap nama host yang sesuai dengan layanan Cloud Run yang ingin Anda buat dapat diakses dari mesh.

Untuk membuat data Cloud DNS di zona eksklusif, jalankan perintah berikut:
1. Buat zona DNS terkelola pribadi di Cloud DNS untuk mesh layanan.
```
gcloud dns managed-zones create MESH_NAME \
--description="Domain for DOMAIN_NAME service mesh routes" \
--dns-name=DOMAIN_NAME. \
--networks=VPC_NETWORK_NAME \
--visibility=private
```
2. Buat data DNS dalam zona terkelola pribadi yang baru dibuat. 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 jaringan VPC Anda; misalnya, "default".

Mengakses layanan internal dengan Cloud Service Mesh

Cloud Run memungkinkan Anda membatasi traffic jaringan masuk ke "internal". Jika layanan Anda mengaktifkan pembatasan ingress ini, traffic yang berasal dari mesh Anda melalui jaringan Virtual Private Cloud dapat ditetapkan sebagai "internal" 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 data DNS kustom.
Lampirkan endpoint Private Service Connect ke Cloud Service Mesh. Tindakan ini memerlukan penyiapan data DNS kustom untuk URL *.run.app default agar menggunakan alamat endpoint Private Service Connect.

Buat layanan Cloud Run tujuan

Perhatikan bahwa tujuan Cloud Run tidak boleh menonaktifkan URL default.

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 layanan Cloud Run tujuan.
- REGION: nama region.
- IMAGE_URL: referensi ke image container, seperti us-docker.pkg.dev/cloudrun/container/hello:latest.

Buat grup endpoint jaringan (NEG) tanpa server

Buat NEG tujuan dengan menjalankan perintah berikut:

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

Ganti kode berikut:

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

Buat layanan backend internal yang dikelola sendiri yang mereferensikan NEG serverless.

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 region.

Tambahkan backend tanpa server ke layanan backend:

gcloud compute backend-services add-backend DESTINATION_SERVICE_NAME-REGION \
--global \
--network-endpoint-group=DESTINATION_SERVICE_NAME-neg \
--network-endpoint-group-region=REGION

Ganti DESTINATION_SERVICE_NAME dengan nama layanan tujuan dan REGION dengan nama region.

Buat rute HTTP yang mereferensikan layanan backend.

Resource dan layanan Mesh dikonfigurasi. Hubungkan dengan resource HTTPRoute yang mengaitkan nama host dengan layanan backend.
1. Buat spesifikasi HTTPRoute dan simpan 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"
```
  Tetapkan nama host ke nama yang ingin Anda gunakan untuk memanggil layanan. Semua klien dalam service mesh yang sama dapat memanggil layanan ini menggunakan URL http://<HOSTNAME>, terlepas dari region dan project pemanggil. Jika Anda telah menyiapkan Cloud DNS untuk menggunakan alamat IP pribadi, nama host rute juga dapat berupa alamat URL run.app lengkap. Dalam hal ini, Anda dapat melewati langkah penyiapan Cloud DNS.
  
  Ganti kode berikut:
  - DESTINATION_SERVICE_NAME: nama layanan Cloud Run tujuan.
  - DOMAIN_NAME: nama domain DNS.
  - PROJECT_ID: ID project.
  - MESH_NAME: nama mesh.
  - REGION: nama region.
2. Buat resource HTTPRoute menggunakan spesifikasi dalam file http_route.yaml:
```
gcloud network-services http-routes import DESTINATION_SERVICE_NAME-route \
--source=http_route.yaml \
--location=global
```
3. Berikan peran Cloud Run Invoker (roles/iam.invoker) pada 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@ \
--role=roles/run.invoker
```
  Ganti kode berikut:
  - DESTINATION_SERVICE_NAME: nama layanan Cloud Run tujuan.
  - REGION: nama region.
  - PROJECT_NUMBER: nomor project.

Buat layanan Cloud Run klien

Membuat layanan Cloud Run klien akan membuat Envoy sidecar yang resource-nya terkait dengan QPS dan ukuran konfigurasi total Anda. Sebagian besar waktu, penggunaan CPU kurang dari 1 persen vCPU dan penggunaan memori kurang dari 50 MB.

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

Untuk membuat layanan klien untuk 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 layanan Cloud Run klien.
- REGION: nama wilayah Anda.
- VPC_NETWORK_NAME: nama jaringan VPC Anda; misalnya, "default".
- SUBNET_NAME: nama subnet Anda; misalnya, "default".
- PROJECT_ID: ID project Anda.
- MESH_NAME: nama resource mesh.
Catatan:
Jika penampung Anda 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@ --role=roles/trafficdirector.client
```

Memanggil layanan dari klien mesh

Untuk meneruskan permintaan ke rute tujuan menggunakan aplikasi pengujian fortio dari bagian Buat layanan klien sebelumnya:

Ambil URL layanan klien Cloud Run yang Anda buat 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 layanan Cloud Run klien.
- REGION: nama wilayah Anda.
- PROJECT_ID: ID project Anda.
Gunakan perintah curl untuk mengirim permintaan ke tujuan rute 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 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, konfigurasi server HTTP berbasis Compute Engine di Cloud Service Mesh. Dengan demikian, klien Cloud Run dapat menggunakan rute layanan backend ini untuk mengirim permintaan langsung ke instance Compute Engine.