Da dispositivi periferici a mesh: esegui il deployment delle applicazioni di mesh di servizi tramite GKE Gateway

Last reviewed 2024-01-31 UTC

Questo deployment mostra come combinare Cloud 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 Cloud Service Mesh per integrare i bilanciatori del carico con un service mesh. Questo deployment è destinato a professionisti avanzati che eseguono Cloud Service Mesh, ma funziona anche per Istio su Google Kubernetes Engine.

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

Un bilanciatore del carico esterno instrada i client esterni al mesh tramite i proxy del gateway di ingresso.

L'ingresso cloud funge da gateway per il traffico esterno al mesh tramite la rete VPC.

Nella topologia del diagramma precedente, il livello di ingresso cloud, programmato tramite GKE Gateway, raccoglie il traffico dall'esterno del mesh di servizi e lo indirizza al livello di ingresso del mesh. Il livello di ingresso del mesh indirizza quindi il traffico ai backend delle applicazioni ospitate nel mesh.

L'ingresso cloud controlla l'integrità dell'ingresso del mesh, che a sua volta controlla l'integrità dei backend dell'applicazione.

La topologia precedente presenta le seguenti considerazioni:

  • Ingresso cloud: in questa architettura di riferimento, configuri il bilanciatore del caricoGoogle Cloud tramite GKE Gateway per controllare l'integrità dei proxy di ingresso mesh sulle porte di controllo dell'integrità esposte.
  • Ingresso del mesh: nell'applicazione mesh, esegui i controlli di integrità direttamente sui backend in modo da poter eseguire il bilanciamento del carico e la gestione del traffico localmente.

La sicurezza viene implementata utilizzando certificati gestiti all'esterno del mesh e certificati interni all'interno del mesh.

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

Obiettivi

  • Esegui il deployment di un cluster Google Kubernetes Engine (GKE) su Google Cloud.
  • Esegui il deployment di Cloud Service Mesh basato su Istio sul tuo cluster GKE.
  • Configura GKE Gateway in modo che termini il traffico HTTPS pubblico e indirizzi questo traffico alle applicazioni ospitate nel mesh di servizi.
  • Esegui il deployment dell'applicazione Online Boutique sul cluster GKE esposto ai clienti su internet.

Ottimizzazione dei costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

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

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

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

    gcloud components update
    
  5. Imposta il 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 dispiegamento.

  6. Crea una directory di lavoro:

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

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

Creare cluster GKE

Le funzionalità descritte in questo deployment richiedono un cluster GKE versione 1.16 o successiva.

  1. In Cloud Shell, crea un nuovo file kubeconfig. Questo passaggio garantisce che non venga creato 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. Attiva 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, configuri Cloud Service Mesh gestito con l'API Fleet.

  1. In Cloud Shell, abilita le API richieste:

    gcloud services enable mesh.googleapis.com
    
  2. Attiva Cloud 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. Attiva la gestione automatica del piano di controllo e del piano di dati gestito:

    gcloud container fleet mesh update \
      --management automatic \
      --memberships ${CLUSTER_NAME}
    
  6. Dopo alcuni minuti, 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 di GKE Gateway

Nei passaggi successivi, esegui il deployment dell'Application Load Balancer esterno tramite il controller GKE Gateway. La risorsa GKE Gateway automatizza il provisioning del bilanciatore del carico e del controllo di integrità del backend. Inoltre, utilizzi Gestore dei certificati per eseguire il provisioning e la gestione di un certificato TLS e Endpoint per eseguire automaticamente il provisioning di un nome DNS pubblico per l'applicazione.

Installa un gateway di ingresso del mesh di servizi

Come best practice per la sicurezza, ti consigliamo di eseguire il deployment del gateway in ingresso in un distinto spazio dei nomi rispetto al 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 incarica Cloud Service Mesh di iniettare automaticamente i proxy sidecar Envoy quando viene eseguito il deployment di un'applicazione.

  3. Crea un certificato autofirmato utilizzato dal gateway di ingresso per terminare le connessioni TLS tra il bilanciatore del carico Google Cloud (da configurare in un secondo momento tramite il controller GKE Gateway) e il gateway di ingresso, quindi memorizza il certificato autofirmato come segreto 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 di ingresso, consulta la guida alle considerazioni sul protocollo di backend sicuro.

  4. Esegui i seguenti comandi per creare il file YAML della risorsa gateway di ingresso:

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

    kubectl apply -k ${WORKDIR}/asm-ig/variant
    
  6. Assicurati che tutti i deployment siano attivi e 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 di ingresso del mesh di servizi

Quando integri un gateway di ingresso del servizio mesh in un Google Cloud bilanciatore del carico delle applicazioni, il bilanciatore del carico delle applicazioni deve essere configurato per eseguire controlli di integrità sui pod del gateway di ingresso. Il CRD HealthCheckPolicy fornisce un'API per configurare questo 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 offre difesa contro gli attacchi DDoS e criteri di sicurezza personalizzabili che puoi collegare a un bilanciatore del carico tramite le risorse Ingress. Nei passaggi seguenti, crei 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 a firme di attacchi note, 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 di ingresso:

    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 l'indirizzamento 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 GKE Gateway e consente di mantenere invariato l'indirizzo IP anche se il bilanciatore del carico esterno cambia.

  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 leggibile per l'indirizzo IP statico del bilanciatore del carico delle applicazioni, devi disporre di un record DNS pubblico. Puoi utilizzare qualsiasi provider DNS e automazione che preferisci. Questo deployment utilizza gli endpoint anziché creare una zona DNS gestita. Endpoints fornisce un record DNS gestito da Google gratuito per un indirizzo IP pubblico.

  3. Esegui il comando seguente per creare il file delle specifiche 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 sotto forma di frontend.endpoints.${PROJECT}.cloud.goog, dove ${PROJECT} è il identificatore univoco del 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 GKE Gateway, utilizza i certificati TLS di Certificate Manager.

Esegui il provisioning di un certificato TLS

In questa sezione, crei un certificato TLS utilizzando Gestione certificati e lo associ a una mappa dei certificati tramite una voce della mappa dei certificati. Il bilanciatore del carico delle applicazioni, configurato tramite GKE Gateway, utilizza il certificato per fornire comunicazioni sicure tra il client e Google Cloud. Una volta creata, la voce della mappa dei certificati viene richiamata dalla risorsa GKE Gateway.

  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 dei certificati:

    gcloud --project=${PROJECT} certificate-manager maps create edge2mesh-cert-map
    
  4. Collega il certificato alla mappa di certificati con una voce della mappa di certificati:

    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 delle risorse GKE Gateway e HTTPRoute

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

  1. In Cloud Shell, esegui il seguente comando per creare il manifest Gateway come 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. Applica il manifest Gateway per creare un Gateway denominato 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/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. Applica il valore predefinito HTTPRoute:

    kubectl apply -f ${WORKDIR}/default-httproute.yaml
    
  5. Crea un file HTTPRoute.yaml aggiuntivo per eseguire i reindirizzamenti da HTTP a 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. Applica il reindirizzamento HTTPRoute:

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

    La riconciliazione richiede tempo. Utilizza il seguente comando fino a 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 incarica Cloud Service Mesh di iniettare automaticamente i proxy sidecar 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. Esegui il deployment dell'app Online Boutique:

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

    L'output è simile al seguente (inclusi gli avvisi relativi all'impostazione di richieste e limiti delle risorse predefinite di 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. Assicurati che tutti i deployment siano attivi e 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 per consentire al cluster GKE Autopilot di eseguire il provisioning dell'infrastruttura di calcolo necessaria per supportare l'applicazione.

  6. Esegui il comando seguente 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 viene instradato all'applicazione frontend, pertanto VirtualService viene implementato dal proprietario dell'app.

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

    kubectl apply -f frontend-virtualservice.yaml
    
  8. Accedi al seguente link:

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

    Viene visualizzato il frontend di Online Boutique.

    Prodotti mostrati nella home page della boutique online.

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

    Il visualizzatore dei certificati mostra i dettagli del certificato gestito, tra cui la data di scadenza e chi lo ha emesso.

Ora hai un bilanciatore del carico HTTPS globale che funge da frontend per la tua applicazione ospitata in un servizio mesh.

Esegui la pulizia

Al termine del deployment, puoi eliminare le risorse che hai creato su Google Cloud in modo che non ti vengano addebitate in futuro. Puoi eliminare completamente il progetto o eliminare le risorse del cluster e poi il cluster stesso.

Elimina il progetto

  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.

Elimina le singole risorse

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

  1. In Cloud Shell, elimina le risorse HTTPRoute:

    kubectl delete -f ${WORKDIR}/default-httproute-redirect.yaml
    kubectl delete -f ${WORKDIR}/default-httproute.yaml
    
  2. Elimina la risorsa GKE Gateway:

    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 di certificati principale):

    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 degli endpoint:

    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