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:

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

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.

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.

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:

• 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. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   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.

   

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

• 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 tentang 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.