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.

Menyiapkan mesh layanan multi-cluster

Konfigurasi ini didukung untuk pelanggan Pratinjau, tetapi kami tidak merekomendasikannya untuk pengguna Cloud Service Mesh baru. Untuk mengetahui informasi selengkapnya, lihat ringkasan Cloud Service Mesh.

Panduan ini menunjukkan cara menambahkan cluster GKE baru ke mesh layanan yang ada.

Sebelum memulai

Sebelum menambahkan cluster, pastikan Anda menyelesaikan petunjuk di Menyiapkan deployment dengan GKE Gateway API, termasuk Mengaktifkan Multi-cluster Services.

Membuat cluster GKE baru

Buat cluster baru dengan menggunakan perintah berikut:

gcloud container clusters create gke-2 \
  --zone=us-west1-a \
  --enable-ip-alias \
  --workload-pool=PROJECT_ID.svc.id.goog \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --release-channel regular \
  --project=PROJECT_ID

Beralihlah ke cluster yang baru saja Anda buat dengan memberikan perintah berikut:
```
gcloud container clusters get-credentials gke-2 --zone us-west1-a
```

Ganti nama konteks cluster:

kubectl config rename-context gke_PROJECT_ID_us-west1-a_gke-2 gke-2

Mendaftarkan cluster ke Armada

Setelah cluster dibuat, daftarkan cluster ke Perangkat Anda:

gcloud alpha container hub memberships register gke-2 \
  --gke-cluster us-west1-a/gke-2 \
  --enable-workload-identity \
  --project=PROJECT_ID

Pastikan cluster terdaftar di Fleet:

gcloud alpha container hub memberships list --project=PROJECT_ID

Armada mencakup cluster yang baru saja Anda buat dan cluster yang Anda buat sebelumnya:

NAME          EXTERNAL_ID
gke-1  657e835d-3b6b-4bc5-9283-99d2da8c2e1b
gke-2  f3727836-9cb0-4ffa-b0c8-d51001742f19

Men-deploy injektor file bantuan Envoy ke cluster GKE baru

Ikuti petunjuk untuk men-deploy injektor file bantuan Envoy dan men-deploy injektor ke cluster gke-2.

Perluas mesh layanan Anda ke cluster GKE baru

Men-deploy mesh layanan file bantuan Envoy menunjukkan cara mengonfigurasi mesh layanan di cluster gke-1, tempat layanan store berjalan. Bagian ini menunjukkan cara memperluas mesh layanan untuk menyertakan layanan payments yang berjalan di cluster gke-2. Resource Mesh sudah ada di cluster konfigurasi, jadi Anda tidak perlu membuat resource Mesh di cluster baru.

Men-deploy layanan `payments`

Dalam file payments.yaml, simpan manifes berikut:

kind: Namespace
apiVersion: v1
metadata:
  name: payments
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payments
  namespace: payments
spec:
  replicas: 2
  selector:
    matchLabels:
      app: payments
      version: v1
  template:
    metadata:
      labels:
        app: payments
        version: v1
    spec:
      containers:
      - name: whereami
        image: us-docker.pkg.dev/google-samples/containers/gke/whereami:v1.2.20
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: payments
  namespace: payments
spec:
  selector:
    app: payments
  ports:
  - port: 8080
    targetPort: 8080

Terapkan manifes ke cluster gke-2:

kubectl apply --context gke-2 -f payments.yaml

Mengekspor layanan `payments`

Semua resource Gateway API disimpan secara terpusat di cluster konfigurasi gke-1. Layanan di cluster lain dalam Armada harus diekspor sehingga resource Gateway API dalam cluster gke-1 dapat mereferensikannya saat Anda mengonfigurasi perilaku jaringan mesh layanan.

Untuk mengetahui penjelasan mendetail tentang cara kerja ServiceExport dan ServiceImport, baca Layanan Multi-cluster.

Buat namespace payments dalam cluster gke-1. Layanan payments di cluster gke-1 diekspor ke semua cluster di Armada yang berada di namespace yang sama.
```
kubectl create namespace payments --context gke-1
```

Dalam file export-payments.yaml, simpan manifes berikut:

kind: ServiceExport
apiVersion: net.gke.io/v1
metadata:
  name: payments
  namespace: payments

Terapkan manifes ServiceExport di cluster gke-2:

kubectl apply --context gke-2 -f export-payments.yaml

Setelah beberapa menit, jalankan perintah berikut untuk memverifikasi bahwa serviceImports yang menyertainya telah dibuat oleh pengontrol Layanan multi-cluster di gke-1:
```
kubectl get serviceimports --context gke-1 --namespace payments
```
Output-nya akan terlihat seperti berikut:
```
NAME           TYPE           IP                  AGE
payments       ClusterSetIP   ["10.112.31.15"]    6m54s
```

Mengonfigurasi resource `HTTPRoute` untuk layanan `payments`

Dalam file payments-route.yaml, simpan manifes HTTPRoute berikut:

apiVersion: gateway.networking.k8s.io/v1alpha2
kind: HTTPRoute
metadata:
  name: payments-route
  namespace: payments
spec:
  parentRefs:
  - name: td-mesh
    namespace: default
    group: net.gke.io
    kind: TDMesh
  hostnames:
  - "example.com"
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /payments
    backendRefs:
    - group: net.gke.io
      kind: ServiceImport
      namespace: payments
      name: payments
      port: 8080

Terapkan manifes rute ke gke-1:

kubectl apply --context gke-1 -f payments-route.yaml

Memvalidasi deployment

Periksa status dan peristiwa Mesh untuk memastikan Mesh dan HTTPRoute berhasil di-deploy.

Jalankan perintah berikut:

kubectl describe tdmesh td-mesh -–context gke-1

Outputnya akan mirip dengan berikut ini:

...
Status:
  Conditions:
    Last Transition Time:  2022-04-14T22:49:56Z
    Message:
    Reason:                MeshReady
    Status:                True
    Type:                  Ready
    Last Transition Time:  2022-04-14T22:27:17Z
    Message:
    Reason:                Scheduled
    Status:                True
    Type:                  Scheduled
Events:
  Type    Reason  Age                From                Message
  ----    ------  ----               ----                -------
  Normal  ADD     23m                mc-mesh-controller  Processing mesh default/td-mesh
  Normal  UPDATE  23m                mc-mesh-controller  Processing mesh default/td-mesh
  Normal  SYNC    23m                mc-mesh-controller  Processing mesh default/td-mesh
  Normal  SYNC    71s                mc-mesh-controller  SYNC on default/td-mesh was a success

Untuk memverifikasi deployment, deploy Pod klien ke salah satu cluster. Dalam file client.yaml, simpan hal berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: client
  name: client
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: client
  template:
    metadata:
      labels:
        run: client
    spec:
      containers:
      - name: client
        image: curlimages/curl
        command:
        - sh
        - -c
        - while true; do sleep 1; done

Terapkan manifes:
```
kubectl apply -f client.yaml --context $CLUSTER
```
Injektor file bantuan yang berjalan di cluster secara otomatis memasukkan container Envoy ke dalam Pod klien.

Untuk memastikan container Envoy telah dimasukkan, jalankan perintah berikut:

kubectl describe pods -l run=client --context $CLUSTER

Outputnya mirip dengan hal berikut ini:

...
Init Containers:
  # Istio-init sets up traffic interception for the Pod.
  istio-init:
...
  # td-bootstrap-writer generates the Envoy bootstrap file for the Envoy container
  td-bootstrap-writer:
...
Containers:
# client is the client container that runs application code.
  client:
...
# Envoy is the container that runs the injected Envoy proxy.
  envoy:
...

Setelah mesh dan Pod klien disediakan, kirim permintaan dari Pod klien ke layanan store:

# Get the name of the client Pod.
CLIENT_POD=$(kubectl get pod --context $CLUSTER -l run=client -o=jsonpath='{.items[0].metadata.name}')

# The VIP where the following request will be sent. Because requests from the
# Busybox container are redirected to the Envoy proxy, the IP address can
# be any other address, such as 10.0.0.2 or 192.168.0.1.
VIP='10.0.0.1'

# Command to send a request to store.
TEST_CMD="curl -v -H 'Host: example.com' $VIP/store"

# Execute the test command in the client container.
kubectl exec -it $CLIENT_POD -c client --context $CLUSTER -- /bin/sh -c "$TEST_CMD"

Output akan menunjukkan bahwa salah satu Pod store di gke-1 menayangkan permintaan:

{
  "cluster_name": "gke-1",
  "zone": "us-central1-a",
  "host_header": "example.com",
...
}

Kirim permintaan ke layanan payments:

# Command to send a request to payments.
TEST_CMD="curl -v -H 'host: example.com' $VIP/payments"

# Execute the test command in the client container.
kubectl exec -it $CLIENT_POD -c client -- /bin/sh -c "$TEST_CMD"

Output akan menunjukkan bahwa salah satu Pod payments di gke-2 menayangkan permintaan:

{
  "cluster_name": "gke-2",
  "zone": "us-west1-a",
  "host_header": "example.com",
...
}

Langkah selanjutnya

Pelajari cara memecahkan masalah terkait deployment.