Anda sedang melihat dokumentasi Service Mesh v1.22.

Versi yang tersedia

Cloud Service Mesh
arsip 1.22
arsip 1.21
arsip 1.20
arsip 1.19
arsip 1.18

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 keamanan dan observasi untuk traffic dari satu layanan Cloud Run ke layanan lainnya. Solusi ini juga memberi Anda solusi bidang data terkelola sepenuhnya yang menghilangkan beban operasional untuk mengelola 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:
- Cloud DNS API
- Network Services API
- Network Security API
- Traffic Director API
- Serverless VPC Access API jika Anda menggunakan konektor Akses VPC Serverless, 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 diperlukan guna mengonfigurasi dan men-deploy layanan Cloud Run, minta administrator untuk memberi Anda peran IAM berikut:

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

Akun layanan klien Cloud Run juga harus memiliki peran berikut:

Klien Traffic Director (roles/trafficdirector.client) untuk mengakses API pemilihan rute 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 antarlayanan Cloud Run menggunakan Cloud Service Mesh

Cloud Run menggunakan API pemilihan rute 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 melakukan autentikasi ke layanan Cloud Run tujuan sehingga Anda tidak perlu mengonfigurasi autentikasi Anda sendiri untuk melampirkan kredensial permintaan ke layanan Cloud Run lainnya.

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

Menyiapkan Cloud Service Mesh
Menyiapkan Cloud DNS
Membuat layanan Cloud Run tujuan
Membuat NEG tanpa server
Membuat 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 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. Semua alamat IP RFC 1918 yang valid dapat diterima karena sidecar menangkap semua traffic IP ke rentang alamat IP ini dan mengalihkan traffic tersebut dengan tepat.

Contoh berikut menunjukkan cara membuat entri * karakter pengganti di zona Cloud DNS yang me-resolve 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 alamatkan 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. \
--network=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 masuk ini, traffic yang berjalan dari mesh 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:

Mengonfigurasi 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 dapat menggunakan alamat endpoint Private Service Connect.

Membuat layanan Cloud Run tujuan

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

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

Membuat grup endpoint jaringan (NEG) tanpa server

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 layanan Cloud Run tujuan.

Buat layanan backend internal yang dikelola sendiri 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 region.
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 region.
Buat rute HTTP yang mereferensikan layanan backend.

Resource dan layanan Mesh dikonfigurasi. Hubungkan keduanya 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 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 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) 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 layanan Cloud Run tujuan.
  - REGION: nama region.
  - PROJECT_NUMBER: nomor project.

Membuat layanan Cloud Run klien

Membuat layanan Cloud Run klien akan membuat sidecar Envoy yang resource-nya terkait dengan QPS dan total ukuran konfigurasi 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 region 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 gagal dimulai, pastikan Anda telah mengaktifkan semua API. Anda mungkin juga perlu memberi akun layanan 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
```

Menelepon layanan dari klien mesh

Untuk meneruskan permintaan ke rute tujuan menggunakan aplikasi pengujian fortio dari bagian Membuat 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 region 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 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. Hal ini memungkinkan klien Cloud Run menggunakan rute layanan backend ini untuk mengirim permintaan langsung ke instance Compute Engine.

Langkah berikutnya

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