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

Last reviewed 2024-01-31 UTC

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

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

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 masuk cloud, yang diprogram melalui Gateway GKE, traffic dari luar mesh layanan dan mengarahkan traffic tersebut ke mesh lapisan masuk. 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 {i>proxy ingress <i}mesh di porta health check terbuka mereka.
  • Mesh ingress: Di aplikasi mesh, Anda melakukan health check pada backend secara langsung sehingga Anda dapat menjalankan load balancing dan 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 Mesh Layanan Cloud berbasis Istio di cluster GKE.
  • Mengonfigurasi Gateway GKE untuk menghentikan HTTPS publik dan mengarahkan traffic tersebut ke aplikasi yang dihosting 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. Membuat GKE Cluster Autopilot:

    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 Cloud Service Mesh yang dikelola dengan fleet API.

  1. Di Cloud Shell, aktifkan API yang diperlukan:

    gcloud services enable mesh.googleapis.com
    
  2. Aktifkan Cloud 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 menggunakan {i>Certificate Manager<i} untuk menyediakan dan mengelola sertifikat TLS, dan Endpoint untuk secara otomatis menyediakan nama DNS publik untuk aplikasi.

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
    

    Memberi label namespace asm-ingress dengan istio-injection=enabled menginstruksikan Cloud Service Mesh agar otomatis memasukkan proxy file bantuan Envoy saat aplikasi di-deploy.

  3. Membuat sertifikat yang ditandatangani sendiri yang digunakan oleh gateway masuk untuk menghentikan koneksi TLS di antara load balancer Google Cloud (untuk yang dikonfigurasi nanti melalui pengontrol Gateway GKE) dan gateway masuk, serta menyimpan sertifikat yang ditandatangani sendiri 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 detail selengkapnya tentang persyaratan sertifikat gateway masuk, lihat panduan pertimbangan protokol backend 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 aplikasi Google Cloud load balancer aplikasi, harus dikonfigurasi agar dapat menjalankan 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 perlindungan DDoS dan kebijakan keamanan yang dapat disesuaikan yang dapat dipasang ke load balancer melalui resource Ingress. Di kolom langkah berikut, Anda akan membuat kebijakan keamanan yang menggunakan aturan standar untuk memblokir serangan {i> Cross-site scripting<i} (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 tergantung 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 traffic masuk gateway service:

    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 mengizinkan alamat IP 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 dan otomatisasi DNS mana pun yang Anda inginkan. Deployment ini menggunakan Endpoint alih-alih membuat zona DNS terkelola. Endpoint menyediakan gratis Data DNS yang dikelola Google 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 mendefinisikan pencatatan DNS publik dalam bentuk frontend.endpoints.${PROJECT}.cloud.goog, dengan ${PROJECT} adalah ID project unik.

  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 untuk mengamankan frontend. Untuk berintegrasi dengan Gateway GKE, Anda menggunakan Pengelola Sertifikat TLS.

Menyediakan sertifikat TLS

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

  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 mengonfigurasi HTTPRoute resource yang mengarahkan permintaan ke aplikasi dan menjalankan HTTP Pengalihan 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 menjalankan HTTP ke HTTP(S) pengalihan:

    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 sampai 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
    

    Memberi label namespace onlineboutique dengan istio-injection=enabled menginstruksikan Cloud Service Mesh agar otomatis memasukkan proxy file bantuan Envoy saat sebuah 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
    

    Output-nya serupa dengan berikut ini (termasuk peringatan tentang Autopilot GKE menyetel 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
    cartservice-6b77b89c9b-9qptn             2/2     Running   0          2m59s
    checkoutservice-7668b7fc99-5bnd9         2/2     Running   0          2m58s
    ...
    

    Tunggu beberapa menit sampai cluster GKE Autopilot menyediakan infrastruktur komputasi yang diperlukan untuk mendukung aplikasi.

  6. Jalankan perintah berikut untuk membuat manifes VirtualService sebagai frontend-virtualservice.yaml:

    cat <<EOF > frontend-virtualservice.yaml
    apiVersion: networking.istio.io/v1beta1
    kind: VirtualService
    metadata:
      name: frontend-ingress
      namespace: onlineboutique
    spec:
      hosts:
      - "frontend.endpoints.${PROJECT}.cloud.goog"
      gateways:
      - asm-ingress/asm-ingressgateway
      http:
      - route:
        - destination:
            host: frontend
            port:
              number: 80
    EOF
    

    VirtualService dibuat di namespace aplikasi (onlineboutique). Biasanya, pemilik aplikasi memutuskan dan mengonfigurasi bagaimana dan apa lalu lintas yang dirutekan ke aplikasi frontend, jadi VirtualService di-deploy oleh pemilik aplikasi.

  7. Deploy frontend-virtualservice.yaml di cluster Anda:

    kubectl apply -f frontend-virtualservice.yaml
    
  8. Akses link berikut:

    echo "https://frontend.endpoints.${PROJECT}.cloud.goog"
    

    Frontend Butik Online Anda akan ditampilkan.

    Produk yang ditampilkan di halaman beranda Butik Online.

  9. Untuk menampilkan detail sertifikat, klik Lihat informasi situs di kolom URL browser Anda, lalu klik Sertifikat (Valid).

    Penampil sertifikat akan menampilkan detail sertifikat yang dikelola, termasuk tanggal habis masa berlaku dan siapa yang menerbitkan sertifikat.

Sekarang Anda memiliki load balancer HTTPS global yang berfungsi sebagai frontend untuk aplikasi yang dihosting di mesh layanan.

Pembersihan

Setelah menyelesaikan deployment, Anda dapat menghapus resource yang dibuat di Google Cloud sehingga Anda tidak akan ditagih di masa mendatang. Anda dapat menghapus project sepenuhnya atau menghapus resource cluster, lalu menghapus cluster tersebut.

Menghapus project

  1. Di konsol Google Cloud, buka halaman Manage resource.

    Buka Manage resource

  2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
  3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Menghapus resource satu per satu

Jika ingin mempertahankan project Google Cloud yang Anda gunakan dalam deployment ini, hapus masing-masing resource:

  1. Di Cloud Shell, hapus resource HTTPRoute:

    kubectl delete -f ${WORKDIR}/default-httproute-redirect.yaml
    kubectl delete -f ${WORKDIR}/default-httproute.yaml
    
  2. Hapus resource Gateway GKE:

    kubectl delete -f ${WORKDIR}/gke-gateway.yaml
    
  3. Hapus resource sertifikat TLS (termasuk entri peta sertifikat dan peta sertifikat induknya):

    gcloud --project=${PROJECT} certificate-manager maps entries delete edge2mesh-cert-map-entry --map="edge2mesh-cert-map" --quiet
    gcloud --project=${PROJECT} certificate-manager maps delete edge2mesh-cert-map --quiet
    gcloud --project=${PROJECT} certificate-manager certificates delete edge2mesh-cert --quiet
    
  4. Hapus entri DNS Endpoint:

    gcloud endpoints services delete "frontend.endpoints.${PROJECT}.cloud.goog"
    

    Outputnya mirip dengan yang berikut ini:

    Are you sure? This will set the service configuration to be deleted, along
    with all of the associated consumer information. Note: This does not
    immediately delete the service configuration or data and can be undone using
    the undelete command for 30 days. Only after 30 days will the service be
    purged from the system.
    
  5. Jika Anda diminta untuk melanjutkan, tekan Y.

    Outputnya mirip dengan yang berikut ini:

    Waiting for async operation operations/services.frontend.endpoints.edge2mesh.cloud.goog-5 to complete...
    Operation finished successfully. The following command can describe the Operation details:
     gcloud endpoints operations describe operations/services.frontend.endpoints.edge2mesh.cloud.goog-5
    
  6. Hapus alamat IP statis:

    gcloud compute addresses delete ingress-ip --global
    

    Outputnya mirip dengan yang berikut ini:

    The following global addresses will be deleted:
    
     - [ingress-ip]
    
  7. Jika Anda diminta untuk melanjutkan, tekan Y.

    Outputnya mirip dengan yang berikut ini:

    Deleted
    [https://www.googleapis.com/compute/v1/projects/edge2mesh/global/addresses/ingress-ip].
    
  8. Hapus cluster GKE:

    gcloud container clusters delete $CLUSTER_NAME --zone $CLUSTER_LOCATION
    

    Outputnya mirip dengan hal berikut ini:

    The following clusters will be deleted.
    - [edge-to-mesh] in [us-central1]
    
  9. Jika Anda diminta untuk melanjutkan, tekan Y.

    Setelah beberapa menit, output-nya akan mirip dengan berikut ini:

    Deleting cluster edge-to-mesh...done.
    Deleted
    [https://container.googleapis.com/v1/projects/e2m-doc-01/zones/us-central1/clusters/edge-to-mesh].
    

Langkah selanjutnya