Da perimetro a mesh: esegui il deployment delle applicazioni mesh di servizi tramite il gateway GKE

Last reviewed 2024-01-31 UTC

Questo deployment mostra come combinare Anthos Service Mesh con Cloud Load Balancing per esporre le applicazioni in un mesh di servizi ai client internet.

Puoi esporre un'applicazione ai client in molti modi, a seconda della posizione del client. Questo deployment mostra come esporre un'applicazione ai client combinando Cloud Load Balancing con Anthos Service Mesh per integrare i bilanciatori del carico con un mesh di servizi. Questo deployment è destinato ai professionisti avanzati che eseguono Anthos Service Mesh, ma funziona anche per Istio su Google Kubernetes Engine.

Architettura

Il seguente diagramma mostra come utilizzare i gateway mesh in entrata per integrare i bilanciatori del carico con un mesh di servizi:

Nota: per le applicazioni in Anthos Service Mesh, il tipo di esposizione predefinito è il deployment del bilanciatore del carico TCP/UDP esterno. Il deployment del bilanciatore del carico avviene tramite il servizio Kubernetes, che seleziona i pod dei proxy in entrata del mesh.

Nella topologia del diagramma precedente, il livello cloud in entrata, programmato tramite il gateway GKE, genera il traffico dall'esterno del mesh di servizi e lo indirizza al livello mesh in entrata. Il livello mesh in entrata indirizza quindi il traffico ai backend delle applicazioni ospitati dal mesh.

La topologia precedente contiene le seguenti considerazioni:

• In entrata nel cloud: in questa architettura di riferimento, configurerai il bilanciatore del carico Google Cloud tramite il gateway GKE per verificare l'integrità dei proxy in entrata mesh sulle porte per il controllo di integrità esposte.
• Ingresso mesh: nell'applicazione mesh, esegui controlli di integrità direttamente sui backend per poter eseguire il bilanciamento del carico e la gestione del traffico localmente.

Il diagramma precedente mostra la crittografia HTTPS dal client al bilanciatore del carico Google Cloud, dal bilanciatore del carico al proxy in entrata del mesh e dal proxy in entrata al proxy sidecar.

Obiettivi

• Eseguire il deployment di un cluster Google Kubernetes Engine (GKE) su Google Cloud.
• Esegui il deployment di un Anthos Service Mesh basato su Istio sul tuo cluster GKE.
• Configura il gateway GKE per terminare il traffico HTTPS pubblico e indirizzarlo alle applicazioni in hosting su mesh di servizi.
• Esegui il deployment dell'applicazione Online Boutique nel cluster GKE che esponi ai client su internet.

Ottimizzazione dei costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

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

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

1. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

2. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

3. Nella console Google Cloud, attiva Cloud Shell.

   Attiva Cloud Shell

   Esegui tutti i comandi del terminale per questo deployment da Cloud Shell.

4. Esegui l'upgrade alla versione più recente di Google Cloud CLI:

   gcloud components update
   

5. Imposta il tuo progetto Google Cloud predefinito:

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

   Sostituisci PROJECT con l'ID progetto che vuoi utilizzare per questo deployment.

6. Crea una directory di lavoro:

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

   Al termine del deployment, puoi eliminare la directory di lavoro.

crea cluster GKE

Le funzionalità descritte in questo deployment richiedono un cluster GKE 1.16 o versioni successive.

1. In Cloud Shell, crea un nuovo file kubeconfig. Questo passaggio garantisce di non creare un conflitto con il file kubeconfig esistente (predefinito).

   touch edge2mesh_kubeconfig
   export KUBECONFIG=${WORKDIR}/edge2mesh_kubeconfig
   

2. Definisci le variabili di ambiente per il cluster GKE:

   export CLUSTER_NAME=edge-to-mesh
   export CLUSTER_LOCATION=us-central1
   

3. Abilita l'API Google Kubernetes Engine:

   gcloud services enable container.googleapis.com
   

4. Crea un cluster GKE Autopilot:

   gcloud container --project ${PROJECT} clusters create-auto 
   ${CLUSTER_NAME} --region ${CLUSTER_LOCATION} --release-channel rapid
   

5. Assicurati che il cluster sia in esecuzione:

   gcloud container clusters list
   

   L'output è simile al seguente:

   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
   

Installa un mesh di servizi

In questa sezione configurerai l'API Anthos Service Mesh gestito con l'API del parco risorse.

1. In Cloud Shell, abilita le API richieste:

   gcloud services enable mesh.googleapis.com
   

2. Abilita Anthos Service Mesh nel parco risorse:

   gcloud container fleet mesh enable
   

3. Registra il cluster nel parco risorse:

   gcloud container fleet memberships register ${CLUSTER_NAME} \
     --gke-cluster ${CLUSTER_LOCATION}/${CLUSTER_NAME}
   

4. Applica l'etichetta mesh_id al cluster edge-to-mesh:

   gcloud container clusters update ${CLUSTER_NAME} --project ${PROJECT} --region ${CLUSTER_LOCATION} --update-labels mesh_id=proj-${PROJECT_NUMBER}
   

5. Abilita la gestione automatica del piano di controllo e il piano dati gestito:

   gcloud container fleet mesh update \
     --management automatic \
     --memberships ${CLUSTER_NAME}
   

6. Dopo qualche minuto, verifica che lo stato del piano di controllo sia ACTIVE:

   gcloud container fleet mesh describe
   

   L'output è simile al seguente:

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

Esegui il deployment del gateway GKE

Nei passaggi seguenti, eseguirai il deployment del bilanciatore del carico delle applicazioni esterno tramite il controller gateway GKE. La risorsa gateway GKE automatizza il provisioning del bilanciatore del carico e il controllo di integrità del backend. Inoltre, puoi utilizzare Gestore certificati per eseguire il provisioning e gestire un certificato TLS ed Endpoints per eseguire il provisioning automatico di un nome DNS pubblico per l'applicazione.

Installa un gateway in entrata mesh di servizi

Come best practice per la sicurezza, ti consigliamo di eseguire il deployment del gateway in entrata in uno spazio dei nomi diverso dal piano di controllo.

1. In Cloud Shell, crea uno spazio dei nomi asm-ingress dedicato:

   kubectl create namespace asm-ingress
   

2. Aggiungi un'etichetta dello spazio dei nomi allo spazio dei nomi asm-ingress:

   kubectl label namespace asm-ingress istio-injection=enabled
   

   L'output è simile al seguente:

   namespace/asm-ingress labeled
   

   L'etichettatura dello spazio dei nomi asm-ingress con istio-injection=enabled indica ad Anthos Service Mesh di inserire automaticamente i proxy collaterali di Envoy quando viene eseguito il deployment di un'applicazione.

3. Crea un certificato autofirmato utilizzato dal gateway in entrata per terminare le connessioni TLS tra il bilanciatore del carico Google Cloud (da configurare in seguito tramite il controller gateway GKE) e il gateway in entrata, quindi archivia il certificato autofirmato come secret di 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
   

   Per ulteriori dettagli sui requisiti per il certificato del gateway in entrata, consulta la guida alle considerazioni sul protocollo di backend sicuro.

4. Esegui i comandi seguenti per creare la risorsa YAML del gateway in entrata:

   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. Applica i CRD del gateway in entrata:

   kubectl apply -k ${WORKDIR}/asm-ig/variant
   

6. Assicurati che tutti i deployment siano in esecuzione:

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

   L'output è simile al seguente:

   deployment.apps/asm-ingressgateway condition met
   

Applica un controllo di integrità del gateway in entrata del mesh di servizi

Quando integri un gateway in entrata del mesh di servizi in un bilanciatore del carico dell'applicazione Google Cloud, il bilanciatore del carico dell'applicazione deve essere configurato per eseguire controlli di integrità sui pod del gateway in entrata. Il CRD HealthCheckPolicy fornisce un'API per configurare il controllo di integrità.

1. In Cloud Shell, crea il 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. Applica il HealthCheckPolicy:

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

Definire i criteri di sicurezza

Google Cloud Armor fornisce difesa DDoS e criteri di sicurezza personalizzabili che puoi collegare a un bilanciatore del carico tramite le risorse Ingress. Nei passaggi seguenti, creerai un criterio di sicurezza che utilizza regole preconfigurate per bloccare gli attacchi cross-site scripting (XSS). Questa regola consente di bloccare il traffico che corrisponde alle firme degli attacchi noti, ma consente tutto il resto del traffico. Il tuo ambiente potrebbe utilizzare regole diverse a seconda del carico di lavoro.

1. In Cloud Shell, crea un criterio di sicurezza denominato edge-fw-policy:

   gcloud compute security-policies create edge-fw-policy \
     --description "Block XSS attacks"
   

2. Crea una regola del criterio di sicurezza che utilizzi i filtri XSS preconfigurati:

   gcloud compute security-policies rules create 1000 \
       --security-policy edge-fw-policy \
       --expression "evaluatePreconfiguredExpr('xss-stable')" \
       --action "deny-403" \
       --description "XSS attack filtering"
   

3. Crea il file GCPBackendPolicy.yaml da allegare al servizio gateway in entrata:

   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. Applica il file GCPBackendPolicy.yaml:

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

Configura gli indirizzi IP e il DNS

1. In Cloud Shell, crea un indirizzo IP statico globale per il bilanciatore del carico Google Cloud:

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

   Questo indirizzo IP statico viene utilizzato dalla risorsa gateway GKE e consente all'indirizzo IP di rimanere invariato, anche in caso di modifica del bilanciatore del carico esterno.

2. Ottieni l'indirizzo IP statico:

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

   Per creare una mappatura stabile e di facile utilizzo all'indirizzo IP statico del bilanciatore del carico dell'applicazione, devi avere un record DNS pubblico. Puoi usare qualsiasi provider DNS e l'automazione che vuoi. Questo deployment utilizza endpoint anziché creare una zona DNS gestita. Endpoints fornisce un record DNS gestito da Google gratuito per un indirizzo IP pubblico.

3. Esegui questo comando per creare il file della specifica YAML denominato 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
   

   La specifica YAML definisce il record DNS pubblico nel formato frontend.endpoints.${PROJECT}.cloud.goog, dove ${PROJECT} è l'identificatore univoco del tuo progetto.

4. Esegui il deployment del file dns-spec.yaml nel tuo progetto Google Cloud:

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

   L'output è simile al seguente:

   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]
   

   Ora che l'indirizzo IP e il DNS sono configurati, puoi generare un certificato pubblico per proteggere il frontend. Per l'integrazione con il gateway GKE, utilizza i certificati TLS di Gestore certificati.

Eseguire il provisioning di un certificato TLS

In questa sezione creerai un certificato TLS utilizzando Certificate Manager e lo associ a una mappa di certificati tramite una voce della mappa. Il bilanciatore del carico dell'applicazione, configurato tramite il gateway GKE, utilizza il certificato per fornire comunicazioni sicure tra il client e Google Cloud. Una volta creata, la voce della mappa dei certificati fa riferimento alla risorsa gateway GKE.

1. In Cloud Shell, abilita l'API Certificate Manager:

   gcloud services enable certificatemanager.googleapis.com --project=${PROJECT}
   

2. Crea il certificato TLS:

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

3. Crea la mappa di certificati:

   gcloud --project=${PROJECT} certificate-manager maps create edge2mesh-cert-map
   

4. Collega il certificato alla mappa di certificati con una voce:

   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"
   

Esegui il deployment del gateway GKE e di HTTPRoute risorse

In questa sezione configurerai la risorsa gateway GKE che esegue il provisioning del bilanciatore del carico dell'applicazione Google Cloud utilizzando gke-l7-global-external-managed gatewayClass. Inoltre, configuri le risorse HTTPRoute che eseguono il routing delle richieste all'applicazione e i reindirizzamenti da HTTP a HTTP(S).

1. In Cloud Shell, esegui questo comando per creare il manifest Gateway come 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. Applica il manifest Gateway per creare un Gatewaydi nome external-http:

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

3. Crea il file HTTPRoute.yaml predefinito:

   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. Applica il valore predefinito HTTPRoute:

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

5. Crea un file HTTPRoute.yaml aggiuntivo per eseguire reindirizzamenti da HTTP a 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. Applica il reindirizzamento HTTPRoute:

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

   La riconciliazione richiede tempo. Utilizza il seguente comando fino al giorno programmed=true:

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

Installa l'app di esempio Online Boutique

1. In Cloud Shell, crea uno spazio dei nomi onlineboutique dedicato:

   kubectl create namespace onlineboutique
   

2. Aggiungi un'etichetta allo spazio dei nomi onlineboutique:

   kubectl label namespace onlineboutique istio-injection=enabled
   

   L'etichettatura dello spazio dei nomi onlineboutique con istio-injection=enabled indica ad Anthos Service Mesh di inserire automaticamente i proxy collaterali di Envoy quando viene eseguito il deployment di un'applicazione.

3. Scarica i file YAML di Kubernetes per l'app di esempio Online Boutique:

   curl -LO \
   https://raw.githubusercontent.com/GoogleCloudPlatform/microservices-demo/main/release/kubernetes-manifests.yaml
   

4. Distribuisci l'app Online Boutique:

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

   L'output è simile al seguente (inclusi avvisi sull'impostazione di richieste e limiti predefiniti per le risorse):

   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. Assicurati che tutti i deployment siano in esecuzione:

   kubectl get pods -n onlineboutique
   

   L'output è simile al seguente:

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

   Attendi qualche minuto che il cluster GKE Autopilot esegua il provisioning dell'infrastruttura di computing necessaria per supportare l'applicazione.

6. Esegui questo comando per creare il manifest VirtualService come 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 viene creato nello spazio dei nomi dell'applicazione (onlineboutique). In genere, il proprietario dell'applicazione decide e configura come e quale traffico deve essere instradato all'applicazione frontend, quindi il deployment di VirtualService viene eseguito dal proprietario dell'app.

7. Esegui il deployment di frontend-virtualservice.yaml nel cluster:

   kubectl apply -f frontend-virtualservice.yaml
   

8. Accedi al seguente link:

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

   Viene visualizzato il frontend della tua boutique online.

   

   Nota: potresti visualizzare un errore ERR_SSL_VERSION_OR_CIPHER_MISMATCH. Questo errore si verifica quando i certificati non sono ancora stati propagati a tutti i Google Front End (GFE) a livello globale. Attendi qualche minuto, quindi riprova a collegare il link.

9. Per visualizzare i dettagli del certificato, fai clic su Visualizza informazioni sul sito nella barra degli indirizzi del browser, quindi su Certificato (valido).

   Il visualizzatore certificati mostra i dettagli del certificato gestito, tra cui la data di scadenza e l'autore.

Ora hai un bilanciatore del carico HTTPS globale che funge da frontend per l'applicazione ospitata nel mesh di servizio.

Esegui la pulizia

Dopo aver completato il deployment, puoi eseguire la pulizia delle risorse che hai creato in Google Cloud in modo che non ti vengano addebitati costi in futuro. Puoi eliminare completamente il progetto o le risorse del cluster, per poi eliminare il cluster.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:
• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.
1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le singole risorse

Se vuoi mantenere il progetto Google Cloud utilizzato in questo deployment, elimina le singole risorse:

1. In Cloud Shell, elimina HTTPRoute risorsa:

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

2. Elimina la risorsa gateway GKE:

   kubectl delete -f ${WORKDIR}/gke-gateway.yaml
   

3. Elimina le risorse del certificato TLS (inclusa la voce della mappa di certificati e la relativa mappa dei certificati padre):

   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. Elimina la voce DNS di Endpoints:

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

   L'output è simile al seguente:

   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. Quando ti viene chiesto di continuare, digita Y.

   L'output è simile al seguente:

   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. Elimina l'indirizzo IP statico:

   gcloud compute addresses delete ingress-ip --global
   

   L'output è simile al seguente:

   The following global addresses will be deleted:
   
    - [ingress-ip]
   

7. Quando ti viene chiesto di continuare, digita Y.

   L'output è simile al seguente:

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

8. Elimina il cluster GKE:

   gcloud container clusters delete $CLUSTER_NAME --zone $CLUSTER_LOCATION
   

   L'output è simile al seguente:

   The following clusters will be deleted.
   - [edge-to-mesh] in [us-central1]
   

9. Quando ti viene chiesto di continuare, digita Y.

   Dopo alcuni minuti, l'output è simile al seguente:

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

Passaggi successivi

• Scopri le altre funzionalità offerte da GKE Ingress che puoi utilizzare con il tuo mesh di servizi.
• Scopri di più sui diversi tipi di bilanciamento del carico cloud disponibili per GKE.
• Scopri di più sulle caratteristiche e funzionalità offerte da Anthos Service Mesh.
• Scopri come eseguire il deployment di Ingress su più cluster GKE per il bilanciamento del carico multiregionale.
• Per altre architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.