Dari edge ke mesh: Deploy aplikasi mesh layanan melalui GKE Gateway

Last reviewed 2024-01-31 UTC

Deployment ini menunjukkan cara menggabungkan Anthos Service Mesh dengan Cloud Load Balancing untuk mengekspos aplikasi dalam mesh layanan ke klien internet.

Anda dapat mengekspos aplikasi ke klien dengan berbagai cara, bergantung pada lokasi klien. Deployment ini menunjukkan cara mengekspos aplikasi ke klien dengan menggabungkan Cloud Load Balancing dengan Anthos Service Mesh untuk mengintegrasikan load balancer dengan mesh layanan. Deployment ini ditujukan bagi praktisi tingkat lanjut yang menjalankan Anthos Service Mesh, tetapi juga dapat digunakan untuk Istio di Google Kubernetes Engine.

Arsitektur

Diagram berikut menunjukkan cara menggunakan gateway traffic masuk mesh untuk mengintegrasikan load balancer dengan mesh layanan:

Load balancer eksternal mengarahkan klien eksternal ke mesh melalui proxy gateway traffic masuk.

Traffic masuk cloud berfungsi sebagai gateway untuk traffic eksternal ke mesh melalui network VPC.

Dalam topologi diagram sebelumnya, lapisan cloud ingress, yang diprogram melalui GKE Gateway, mengambil traffic dari luar mesh layanan dan mengarahkan traffic tersebut ke lapisan masuk mesh. Lapisan traffic masuk mesh kemudian mengarahkan traffic ke backend aplikasi yang dihosting mesh.

Traffic masuk cloud memeriksa kondisi traffic masuk mesh, dan traffic masuk mesh akan memeriksa kondisi backend aplikasi.

Topologi sebelumnya memiliki pertimbangan berikut:

  • Cloud ingress: Dalam arsitektur referensi ini, Anda mengonfigurasi load balancer Google Cloud melalui Gateway GKE untuk memeriksa kondisi proxy ingress mesh pada port health check yang terekspos.
  • Traffic masuk mesh: Dalam aplikasi mesh, Anda menjalankan health check pada backend secara langsung untuk menjalankan load balancing dan pengelolaan traffic secara lokal.

Keamanan diimplementasikan menggunakan sertifikat terkelola di luar mesh dan sertifikat internal di dalam mesh.

Diagram sebelumnya mengilustrasikan enkripsi HTTPS dari klien ke load balancer Google Cloud, dari load balancer ke proxy traffic masuk mesh, dan dari proxy traffic masuk ke proxy sidecar.

Tujuan

  • Men-deploy cluster Google Kubernetes Engine (GKE) di Google Cloud.
  • Men-deploy Anthos Service Mesh berbasis Istio di cluster GKE Anda.
  • Mengonfigurasi Gateway GKE untuk menghentikan traffic HTTPS publik dan mengarahkan traffic tersebut ke aplikasi yang dihosting di mesh layanan.
  • Men-deploy aplikasi Butik Online di cluster GKE yang Anda ekspos kepada klien di internet.

Pengoptimalan biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

  1. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

    Buka pemilih project

  2. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

  3. Di konsol Google Cloud, aktifkan Cloud Shell.

    Aktifkan Cloud Shell

    Anda menjalankan semua perintah terminal untuk deployment ini dari Cloud Shell.

  4. Upgrade Google Cloud CLI ke versi terbaru:

    gcloud components update
    
  5. Setel project Google Cloud default Anda:

    export PROJECT=PROJECT
    export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT} --format="value(projectNumber)")
    gcloud config set project ${PROJECT}
    

    Ganti PROJECT dengan project ID yang ingin Anda gunakan untuk deployment ini.

  6. Buat direktori kerja:

    mkdir -p ${HOME}/edge-to-mesh
    cd ${HOME}/edge-to-mesh
    export WORKDIR=`pwd`
    

    Setelah menyelesaikan deployment ini, Anda dapat menghapus direktori kerja.

Membuat cluster GKE

Fitur yang dijelaskan dalam deployment ini memerlukan cluster GKE versi 1.16 atau yang lebih baru.

  1. Di Cloud Shell, buat file kubeconfig baru. Langkah ini memastikan Anda tidak membuat konflik dengan file kubeconfig yang sudah ada (default).

    touch edge2mesh_kubeconfig
    export KUBECONFIG=${WORKDIR}/edge2mesh_kubeconfig
    
  2. Tentukan variabel lingkungan untuk cluster GKE:

    export CLUSTER_NAME=edge-to-mesh
    export CLUSTER_LOCATION=us-central1
    
  3. Mengaktifkan Google Kubernetes Engine API:

    gcloud services enable container.googleapis.com
    
  4. Buat cluster Autopilot GKE:

    gcloud container --project ${PROJECT} clusters create-auto 
    ${CLUSTER_NAME} --region ${CLUSTER_LOCATION} --release-channel rapid
    
  5. Pastikan cluster berjalan:

    gcloud container clusters list
    

    Outputnya mirip dengan hal berikut ini:

    NAME          LOCATION    MASTER_VERSION    MASTER_IP      MACHINE_TYPE   NODE_VERSION      NUM_NODES  STATUS
    edge-to-mesh  us-central1  1.27.3-gke.1700   34.122.84.52  e2-medium  1.27.3-gke.1700   3          RUNNING
    

Menginstal mesh layanan

Di bagian ini, Anda akan mengonfigurasi Anthos Service Mesh terkelola dengan fleet API.

  1. Di Cloud Shell, aktifkan API yang diperlukan:

    gcloud services enable mesh.googleapis.com
    
  2. Aktifkan Anthos Service Mesh di fleet:

    gcloud container fleet mesh enable
    
  3. Daftarkan cluster ke fleet:

    gcloud container fleet memberships register ${CLUSTER_NAME} \
      --gke-cluster ${CLUSTER_LOCATION}/${CLUSTER_NAME}
    
  4. Terapkan label mesh_id ke cluster edge-to-mesh:

    gcloud container clusters update ${CLUSTER_NAME} --project ${PROJECT} --region ${CLUSTER_LOCATION} --update-labels mesh_id=proj-${PROJECT_NUMBER}
    
  5. Mengaktifkan pengelolaan bidang kontrol otomatis dan bidang data terkelola:

    gcloud container fleet mesh update \
      --management automatic \
      --memberships ${CLUSTER_NAME}
    
  6. Setelah beberapa menit, verifikasi bahwa status bidang kontrol adalah ACTIVE:

    gcloud container fleet mesh describe
    

    Outputnya mirip dengan hal berikut ini:

    ...
    membershipSpecs:
      projects/892585880385/locations/us-central1/memberships/edge-to-mesh:
        mesh:
          management: MANAGEMENT_AUTOMATIC
    membershipStates:
      projects/892585880385/locations/us-central1/memberships/edge-to-mesh:
        servicemesh:
          controlPlaneManagement:
            details:
            - code: REVISION_READY
              details: 'Ready: asm-managed-rapid'
            state: ACTIVE
          dataPlaneManagement:
            details:
            - code: OK
              details: Service is running.
            state: ACTIVE
        state:
          code: OK
          description: 'Revision(s) ready for use: asm-managed-rapid.'
          updateTime: '2023-08-04T02:54:39.495937877Z'
    name: projects/e2m-doc-01/locations/global/features/servicemesh
    resourceState:
      state: ACTIVE
    ...
    

Men-deploy Gateway GKE

Pada langkah-langkah berikut, Anda akan men-deploy Load Balancer Aplikasi eksternal melalui pengontrol Gateway GKE. Resource Gateway GKE mengotomatiskan penyediaan load balancer dan health check backend. Selain itu, Anda dapat menggunakan Certificate Manager untuk menyediakan dan mengelola sertifikat TLS, serta menggunakan Endpoint untuk menyediakan nama DNS publik bagi aplikasi secara otomatis.

Menginstal gateway masuk mesh layanan

Sebagai praktik terbaik keamanan, sebaiknya Anda men-deploy gateway traffic masuk di namespace yang berbeda dari bidang kontrol.

  1. Di Cloud Shell, buat namespace asm-ingress khusus:

    kubectl create namespace asm-ingress
    
  2. Tambahkan label namespace ke namespace asm-ingress:

    kubectl label namespace asm-ingress istio-injection=enabled
    

    Outputnya mirip dengan hal berikut ini:

    namespace/asm-ingress labeled
    

    Pelabelan namespace asm-ingress dengan istio-injection=enabled akan memerintahkan Anthos Service Mesh untuk otomatis memasukkan proxy sidecar Envoy saat aplikasi di-deploy.

  3. Buat sertifikat yang ditandatangani sendiri dan digunakan oleh gateway ingress untuk menghentikan koneksi TLS antara load balancer Google Cloud (untuk dikonfigurasi nanti melalui pengontrol Gateway GKE) dan gateway masuk, serta menyimpan sertifikat yang ditandatangani sendiri sebagai rahasia Kubernetes:

    openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 \
     -subj "/CN=frontend.endpoints.${PROJECT}.cloud.goog/O=Edge2Mesh Inc" \
     -keyout frontend.endpoints.${PROJECT}.cloud.goog.key \
     -out frontend.endpoints.${PROJECT}.cloud.goog.crt
    
    kubectl -n asm-ingress create secret tls edge2mesh-credential \
     --key=frontend.endpoints.${PROJECT}.cloud.goog.key \
     --cert=frontend.endpoints.${PROJECT}.cloud.goog.crt
    

    Untuk mengetahui detail selengkapnya tentang persyaratan sertifikat gateway masuk, lihat panduan pertimbangan protokol backend yang aman.

  4. Jalankan perintah berikut untuk membuat YAML resource gateway masuk:

    mkdir -p ${WORKDIR}/asm-ig/base
    cat <<EOF > ${WORKDIR}/asm-ig/base/kustomization.yaml
    resources:
      - github.com/GoogleCloudPlatform/anthos-service-mesh-samples/docs/ingress-gateway-asm-manifests/base
    EOF
    
    mkdir ${WORKDIR}/asm-ig/variant
    cat <<EOF > ${WORKDIR}/asm-ig/variant/role.yaml
    apiVersion: rbac.authorization.k8s.io/v1
    kind: Role
    metadata:
      name: asm-ingressgateway
      namespace: asm-ingress
    rules:
    - apiGroups: [""]
      resources: ["secrets"]
      verbs: ["get", "watch", "list"]
    EOF
    
    cat <<EOF > ${WORKDIR}/asm-ig/variant/rolebinding.yaml
    apiVersion: rbac.authorization.k8s.io/v1
    kind: RoleBinding
    metadata:
      name: asm-ingressgateway
      namespace: asm-ingress
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: Role
      name: asm-ingressgateway
    subjects:
      - kind: ServiceAccount
        name: asm-ingressgateway
    EOF
    
    cat <<EOF > ${WORKDIR}/asm-ig/variant/service-proto-type.yaml
    apiVersion: v1
    kind: Service
    metadata:
      name: asm-ingressgateway
    spec:
      ports:
      - name: status-port
        port: 15021
        protocol: TCP
        targetPort: 15021
      - name: http
        port: 80
        targetPort: 8080
      - name: https
        port: 443
        targetPort: 8443
        appProtocol: HTTP2
      type: ClusterIP
    EOF
    
    cat <<EOF > ${WORKDIR}/asm-ig/variant/gateway.yaml
    apiVersion: networking.istio.io/v1beta1
    kind: Gateway
    metadata:
      name: asm-ingressgateway
    spec:
      servers:
      - port:
          number: 443
          name: https
          protocol: HTTPS
        hosts:
        - "*" # IMPORTANT: Must use wildcard here when using SSL, see note below
        tls:
          mode: SIMPLE
          credentialName: edge2mesh-credential
    EOF
    
    cat <<EOF > ${WORKDIR}/asm-ig/variant/kustomization.yaml
    namespace: asm-ingress
    resources:
    - ../base
    - role.yaml
    - rolebinding.yaml
    patches:
    - path: service-proto-type.yaml
      target:
        kind: Service
    - path: gateway.yaml
      target:
        kind: Gateway
    EOF
    
  5. Terapkan CRD gateway masuk:

    kubectl apply -k ${WORKDIR}/asm-ig/variant
    
  6. Pastikan semua deployment aktif dan berjalan:

    kubectl wait --for=condition=available --timeout=600s deployment --all -n asm-ingress
    

    Outputnya mirip dengan hal berikut ini:

    deployment.apps/asm-ingressgateway condition met
    

Menerapkan health check gateway masuk mesh layanan

Saat mengintegrasikan gateway masuk mesh layanan ke load balancer aplikasi Google Cloud, load balancer aplikasi harus dikonfigurasi untuk melakukan health check terhadap Pod gateway masuk. CRD HealthCheckPolicy menyediakan API untuk mengonfigurasi health check tersebut.

  1. Di Cloud Shell, buat file HealthCheckPolicy.yaml:

    cat <<EOF >${WORKDIR}/ingress-gateway-healthcheck.yaml
    apiVersion: networking.gke.io/v1
    kind: HealthCheckPolicy
    metadata:
      name: ingress-gateway-healthcheck
      namespace: asm-ingress
    spec:
      default:
        checkIntervalSec: 20
        timeoutSec: 5
        #healthyThreshold: HEALTHY_THRESHOLD
        #unhealthyThreshold: UNHEALTHY_THRESHOLD
        logConfig:
          enabled: True
        config:
          type: HTTP
          httpHealthCheck:
            #portSpecification: USE_NAMED_PORT
            port: 15021
            portName: status-port
            #host: HOST
            requestPath: /healthz/ready
            #response: RESPONSE
            #proxyHeader: PROXY_HEADER
        #requestPath: /healthz/ready
        #port: 15021
      targetRef:
        group: ""
        kind: Service
        name: asm-ingressgateway
    EOF
    
  2. Terapkan HealthCheckPolicy:

    kubectl apply -f ${WORKDIR}/ingress-gateway-healthcheck.yaml
    

Menentukan kebijakan keamanan

Google Cloud Armor menyediakan pertahanan DDoS dan kebijakan keamanan yang dapat disesuaikan yang dapat Anda pasang ke load balancer melalui resource Ingress. Dalam langkah-langkah berikut, Anda membuat kebijakan keamanan yang menggunakan aturan yang telah dikonfigurasi sebelumnya untuk memblokir serangan pembuatan skrip lintas situs (XSS). Aturan ini membantu memblokir traffic yang cocok dengan tanda tangan serangan yang diketahui, tetapi mengizinkan semua traffic lainnya. Lingkungan Anda mungkin menggunakan aturan yang berbeda, bergantung pada beban kerja Anda.

  1. Di Cloud Shell, buat kebijakan keamanan yang disebut edge-fw-policy:

    gcloud compute security-policies create edge-fw-policy \
      --description "Block XSS attacks"
    
  2. Buat aturan kebijakan keamanan yang menggunakan filter XSS yang telah dikonfigurasi sebelumnya:

    gcloud compute security-policies rules create 1000 \
        --security-policy edge-fw-policy \
        --expression "evaluatePreconfiguredExpr('xss-stable')" \
        --action "deny-403" \
        --description "XSS attack filtering"
    
  3. Buat file GCPBackendPolicy.yaml untuk dilampirkan ke layanan ingress gateway:

    cat <<EOF > ${WORKDIR}/cloud-armor-backendpolicy.yaml
    apiVersion: networking.gke.io/v1
    kind: GCPBackendPolicy
    metadata:
      name: cloud-armor-backendpolicy
      namespace: asm-ingress
    spec:
      default:
        securityPolicy: edge-fw-policy
      targetRef:
        group: ""
        kind: Service
        name: asm-ingressgateway
    EOF
    
  4. Terapkan file GCPBackendPolicy.yaml:

    kubectl apply -f ${WORKDIR}/cloud-armor-backendpolicy.yaml
    

Mengonfigurasi alamat IP dan DNS

  1. Di Cloud Shell, buat alamat IP statis global untuk load balancer Google Cloud:

    gcloud compute addresses create e2m-gclb-ip --global
    

    Alamat IP statis ini digunakan oleh resource Gateway GKE dan memungkinkan alamat IP tetap sama, meskipun jika load balancer eksternal berubah.

  2. Dapatkan alamat IP statis:

    export GCLB_IP=$(gcloud compute addresses describe e2m-gclb-ip 
    --global --format "value(address)")
    echo ${GCLB_IP}
    

    Untuk membuat pemetaan yang stabil dan ramah manusia ke alamat IP statis load balancer aplikasi, Anda harus memiliki data DNS publik. Anda dapat menggunakan penyedia DNS dan otomatisasi apa pun yang Anda inginkan. Deployment ini menggunakan Endpoint, bukan membuat zona DNS terkelola. Endpoint menyediakan data DNS yang dikelola Google gratis untuk alamat IP publik.

  3. Jalankan perintah berikut untuk membuat file spesifikasi YAML bernama dns-spec.yaml:

    cat <<EOF > ${WORKDIR}/dns-spec.yaml
    swagger: "2.0"
    info:
      description: "Cloud Endpoints DNS"
      title: "Cloud Endpoints DNS"
      version: "1.0.0"
    paths: {}
    host: "frontend.endpoints.${PROJECT}.cloud.goog"
    x-google-endpoints:
    - name: "frontend.endpoints.${PROJECT}.cloud.goog"
      target: "${GCLB_IP}"
    EOF
    

    Spesifikasi YAML menentukan data DNS publik dalam bentuk frontend.endpoints.${PROJECT}.cloud.goog, dengan ${PROJECT} sebagai ID project unik Anda.

  4. Deploy file dns-spec.yaml di project Google Cloud Anda:

    gcloud endpoints services deploy ${WORKDIR}/dns-spec.yaml
    

    Outputnya mirip dengan hal berikut ini:

    project [e2m-doc-01]...
    Operation "operations/acat.p2-892585880385-fb4a01ad-821d-4e22-bfa1-a0df6e0bf589" finished successfully.
    
    Service Configuration [2023-08-04r0] uploaded for service [frontend.endpoints.e2m-doc-01.cloud.goog]
    

    Setelah alamat IP dan DNS dikonfigurasi, Anda dapat membuat sertifikat publik untuk mengamankan frontend. Untuk berintegrasi dengan GKE Gateway, gunakan sertifikat TLS Certificate Manager.

Menyediakan sertifikat TLS

Di bagian ini, Anda akan membuat sertifikat TLS menggunakan Certificate Manager, dan mengaitkannya dengan peta sertifikat melalui entri peta sertifikat. Load balancer aplikasi, yang dikonfigurasi melalui Gateway GKE, menggunakan sertifikat tersebut untuk menyediakan komunikasi yang aman antara klien dan Google Cloud. Setelah dibuat, entri peta sertifikat akan direferensikan oleh resource Gateway GKE.

  1. Di Cloud Shell, aktifkan Certificate Manager API:

    gcloud services enable certificatemanager.googleapis.com --project=${PROJECT}
    
  2. Buat sertifikat TLS:

    gcloud --project=${PROJECT} certificate-manager certificates create edge2mesh-cert \
        --domains="frontend.endpoints.${PROJECT}.cloud.goog"
    
  3. Buat peta sertifikat:

    gcloud --project=${PROJECT} certificate-manager maps create edge2mesh-cert-map
    
  4. Lampirkan sertifikat ke peta sertifikat dengan entri peta sertifikat:

    gcloud --project=${PROJECT} certificate-manager maps entries create edge2mesh-cert-map-entry \
        --map="edge2mesh-cert-map" \
        --certificates="edge2mesh-cert" \
        --hostname="frontend.endpoints.${PROJECT}.cloud.goog"
    

Men-deploy Gateway GKE dan resource HTTPRoute

Di bagian ini, Anda akan mengonfigurasi resource Gateway GKE yang menyediakan load balancer aplikasi Google Cloud menggunakan gke-l7-global-external-managed gatewayClass. Selain itu, Anda harus mengonfigurasi resource HTTPRoute yang mengarahkan permintaan ke aplikasi dan melakukan pengalihan HTTP ke HTTP(S).

  1. Di Cloud Shell, jalankan perintah berikut untuk membuat manifes Gateway sebagai gke-gateway.yaml:

    cat <<EOF > ${WORKDIR}/gke-gateway.yaml
    kind: Gateway
    apiVersion: gateway.networking.k8s.io/v1beta1
    metadata:
      name: external-http
      namespace: asm-ingress
      annotations:
        networking.gke.io/certmap: edge2mesh-cert-map
    spec:
      gatewayClassName: gke-l7-global-external-managed # gke-l7-gxlb
      listeners:
      - name: http # list the port only so we can redirect any incoming http requests to https
        protocol: HTTP
        port: 80
      - name: https
        protocol: HTTPS
        port: 443
      addresses:
      - type: NamedAddress
        value: e2m-gclb-ip # reference the static IP created earlier
    EOF
    
  2. Terapkan manifes Gateway untuk membuat Gateway yang disebut external-http:

    kubectl apply -f ${WORKDIR}/gke-gateway.yaml
    
  3. Buat file HTTPRoute.yaml default:

    cat << EOF > ${WORKDIR}/default-httproute.yaml
    apiVersion: gateway.networking.k8s.io/v1beta1
    kind: HTTPRoute
    metadata:
      name: default-httproute
      namespace: asm-ingress
    spec:
      parentRefs:
      - name: external-http
        namespace: asm-ingress
        sectionName: https
      rules:
      - matches:
        - path:
            value: /
        backendRefs:
        - name: asm-ingressgateway
          port: 443
    EOF
    
  4. Terapkan HTTPRoute default:

    kubectl apply -f ${WORKDIR}/default-httproute.yaml
    
  5. Buat file HTTPRoute.yaml tambahan untuk melakukan pengalihan HTTP ke HTTP(S):

    cat << EOF > ${WORKDIR}/default-httproute-redirect.yaml
    kind: HTTPRoute
    apiVersion: gateway.networking.k8s.io/v1beta1
    metadata:
      name: http-to-https-redirect-httproute
      namespace: asm-ingress
    spec:
      parentRefs:
      - name: external-http
        namespace: asm-ingress
        sectionName: http
      rules:
      - filters:
        - type: RequestRedirect
          requestRedirect:
            scheme: https
            statusCode: 301
    EOF
    
  6. Terapkan pengalihan HTTPRoute:

    kubectl apply -f ${WORKDIR}/default-httproute-redirect.yaml
    

    Rekonsiliasi membutuhkan waktu. Gunakan perintah berikut hingga programmed=true:

    kubectl get gateway external-http -n asm-ingress -w
    

Menginstal aplikasi contoh Butik Online

  1. Di Cloud Shell, buat namespace onlineboutique khusus:

    kubectl create namespace onlineboutique
    
  2. Tambahkan label ke namespace onlineboutique:

    kubectl label namespace onlineboutique istio-injection=enabled
    

    Pelabelan namespace onlineboutique dengan istio-injection=enabled akan memerintahkan Anthos Service Mesh untuk otomatis memasukkan proxy sidecar Envoy saat aplikasi di-deploy.

  3. Download file YAML Kubernetes untuk aplikasi contoh Butik Online:

    curl -LO \
    https://raw.githubusercontent.com/GoogleCloudPlatform/microservices-demo/main/release/kubernetes-manifests.yaml
    
  4. Deploy aplikasi Butik Online:

    kubectl apply -f kubernetes-manifests.yaml -n onlineboutique
    

    Outputnya serupa dengan berikut ini (termasuk peringatan tentang Autopilot GKE menetapkan permintaan dan batas resource default):

    Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/emailservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources)
    deployment.apps/emailservice created
    service/emailservice created
    Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/checkoutservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources)
    deployment.apps/checkoutservice created
    service/checkoutservice created
    Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/recommendationservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources)
    deployment.apps/recommendationservice created
    service/recommendationservice created
    ...
    
  5. Pastikan semua deployment aktif dan berjalan:

    kubectl get pods -n onlineboutique
    

    Outputnya mirip dengan hal berikut ini:

    NAME                                     READY   STATUS    RESTARTS   AGE
    adservice-64d8dbcf59-krrj9               2/2     Running   0          2m59s
    car