Dari edge ke mesh: Men-deploy aplikasi mesh layanan melalui GKE Gateway

Last reviewed 2024-01-31 UTC

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

Anda dapat mengekspos aplikasi kepada klien dengan berbagai cara, bergantung pada lokasi klien. 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 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:

Catatan: Untuk aplikasi di Cloud Service Mesh, deployment load balancer TCP/UDP eksternal adalah jenis eksposur default. Anda men-deploy load balancer melalui Layanan Kubernetes, yang memilih Pod proxy traffic masuk mesh.

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

Topologi sebelumnya memiliki pertimbangan berikut:

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

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 Cloud Service Mesh berbasis Istio di cluster GKE Anda.
• Mengonfigurasi GKE Gateway untuk menghentikan traffic 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 akan menggunakan komponen Google Cloud yang dapat ditagih berikut:

• Google Kubernetes Engine
• Compute Engine
• Cloud Load Balancing
• Certificate Manager
• Cloud Service Mesh
• Google Cloud Armor
• Cloud Endpoints

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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Make sure that billing is enabled for your Google Cloud project.

3. In the Google Cloud console, activate Cloud Shell.

   Activate 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 Cloud Service Mesh terkelola 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 GKE Gateway

Pada langkah berikut, Anda akan men-deploy Load Balancer Aplikasi eksternal melalui pengontrol GKE Gateway. Resource GKE Gateway mengotomatiskan penyediaan load balancer dan pemeriksaan kondisi backend. Selain itu, Anda menggunakan Pengelola Sertifikat untuk menyediakan dan mengelola sertifikat TLS, dan Endpoints untuk menyediakan nama DNS publik secara otomatis untuk aplikasi.

Menginstal gateway traffic 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 Cloud Service Mesh untuk otomatis memasukkan proxy sidecar Envoy saat aplikasi di-deploy.

3. Buat sertifikat yang ditandatangani sendiri yang digunakan oleh gateway ingress untuk menghentikan koneksi TLS antara load balancer Google Cloud (yang akan dikonfigurasi nanti melalui pengontrol GKE Gateway) dan gateway ingress, serta simpan sertifikat yang ditandatangani sendiri sebagai secret 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 untuk sertifikat gateway traffic masuk, lihat panduan pertimbangan protokol backend aman.

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

   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, as SNI isn't passed from GFE
       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 sudah 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 traffic masuk mesh layanan

Saat mengintegrasikan gateway traffic masuk mesh layanan ke load balancer aplikasi Google Cloud, load balancer aplikasi harus dikonfigurasi untuk melakukan health check terhadap Pod gateway traffic 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. Pada langkah-langkah berikut, Anda akan 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 workload Anda.

1. Di Cloud Shell, buat kebijakan keamanan yang bernama 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 gateway ingress:

   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 GKE Gateway dan memungkinkan alamat IP tetap sama, meskipun 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 mudah dipahami ke alamat IP statis load balancer aplikasi, Anda harus memiliki data DNS publik. Anda dapat menggunakan penyedia dan otomatisasi DNS 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, Anda menggunakan 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 GKE Gateway, menggunakan sertifikat untuk menyediakan komunikasi yang aman antara klien dan Google Cloud. Setelah dibuat, entri peta sertifikat direferensikan oleh resource GKE Gateway.

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 resource GKE Gateway dan HTTPRoute

Di bagian ini, Anda akan mengonfigurasi resource GKE Gateway yang menyediakan load balancer aplikasi Google Cloud menggunakan gke-l7-global-external-managed gatewayClass. Selain itu, Anda mengonfigurasi resource HTTPRoute yang merutekan 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/v1
   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/v1
   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/v1
   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 memerlukan 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 Cloud 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
   

   Output-nya mirip dengan berikut ini (termasuk peringatan tentang penetapan permintaan dan batas resource default GKE Autopilot):

   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 sudah 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 hingga 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 dalam namespace aplikasi (onlineboutique). Biasanya, pemilik aplikasi memutuskan dan mengonfigurasi cara dan traffic apa yang dirutekan ke aplikasi frontend, sehingga 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.

   

   Catatan: Anda mungkin mendapatkan error ERR_SSL_VERSION_OR_CIPHER_MISMATCH. Error ini terjadi saat sertifikat belum diterapkan ke semua Google Front End (GFE) secara global. Tunggu beberapa menit, lalu coba link lagi.

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

Perhatian: Menghapus project memiliki efek berikut:
• Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
• Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the 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 GKE Gateway:

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

• Pelajari fitur-fitur lain yang ditawarkan oleh GKE Ingress yang dapat Anda gunakan dengan mesh layanan Anda.
• Pelajari berbagai jenis cloud load balancing yang tersedia untuk GKE.
• Pelajari fitur dan fungsi yang ditawarkan oleh Cloud Service Mesh.
• Pelajari cara men-deploy Ingress di beberapa cluster GKE untuk load balancing multi-regional.
• Untuk arsitektur referensi, diagram, dan praktik terbaik lainnya, jelajahi Cloud Architecture Center.