Menyiapkan mesh layanan multi-cluster

Konfigurasi ini didukung untuk pelanggan Pratinjau tetapi kami tidak merekomendasikan untuk pengguna Cloud Service Mesh baru. Untuk 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 Persiapan untuk men-deploy dengan GKE Gateway API, termasuk Aktifkan Layanan Multi-cluster.

Membuat cluster GKE baru

  1. Buat cluster baru 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
    
  2. Beralihlah ke cluster yang baru saja Anda buat dengan menjalankan perintah berikut:

    gcloud container clusters get-credentials gke-2 --zone us-west1-a
    
  3. Ganti nama konteks cluster:

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

Daftarkan cluster ke Fleet

  1. Setelah cluster dibuat, daftarkan cluster tersebut ke Armada:

    gcloud alpha container hub memberships register gke-2 \
      --gke-cluster us-west1-a/gke-2 \
      --enable-workload-identity \
      --project=PROJECT_ID
    
  2. Pastikan cluster sudah terdaftar di Armada:

    gcloud alpha container hub memberships list --project=PROJECT_ID
    

    Armada menyertakan 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 layanan untuk menyertakan layanan payments yang berjalan di cluster gke-2. Mesh resource sudah ada di cluster konfigurasi, jadi Anda tidak perlu membuat Mesh resource di cluster baru.

Men-deploy layanan payments

  1. 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
    
  2. 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 di Fleet harus diekspor agar Gateway API resource di cluster gke-1 dapat mereferensikannya saat Anda mengonfigurasi perilaku jaringan mesh layanan.

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

  1. Buat namespace payments di cluster gke-1. Layanan payments di cluster gke-1 diekspor ke semua cluster di Fleet yang berada di namespace yang sama.

    kubectl create namespace payments --context gke-1
    
  2. Dalam file export-payments.yaml, simpan manifes berikut:

    kind: ServiceExport
    apiVersion: net.gke.io/v1
    metadata:
      name: payments
      namespace: payments
    
  3. Terapkan manifes ServiceExport di cluster gke-2:

    kubectl apply --context gke-2 -f export-payments.yaml
    
  4. Setelah beberapa menit, jalankan perintah berikut untuk memverifikasi bahwa serviceImports yang menyertainya dibuat oleh Layanan multi-cluster pengontrol 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

  1. 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
    
  2. Terapkan manifes rute ke gke-1:

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

Memvalidasi deployment

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

  1. 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
    
  2. Untuk memverifikasi deployment, deploy Pod klien ke salah satu cluster. Di kolom File client.yaml, simpan berikut ini:

    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
    
  3. Terapkan manifes:

    kubectl apply -f client.yaml --context $CLUSTER
    

    Injector sespan yang berjalan di cluster secara otomatis menginjeksikan Envoy container ke Pod klien.

  4. Untuk memverifikasi bahwa container Envoy sudah 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:
    ...
    
  5. 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 menyalurkan permintaan:

    {
      "cluster_name": "gke-1",
      "zone": "us-central1-a",
      "host_header": "example.com",
    ...
    }
    
  6. 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 dalam gke-2 menyalurkan permintaan:

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

Langkah selanjutnya