Ad esempio, Cloud Service Mesh: deployment canary


In questo tutorial viene illustrato un caso d'uso comune: l'implementazione di un deployment canary con Cloud Service Mesh utilizzando le API Istio.

Che cos'è un deployment canary?

Un deployment canary indirizza una piccola percentuale di traffico a una nuova versione di un microservice, quindi aumenta gradualmente questa percentuale durante il ritiro della vecchia versione. Se qualcosa va storto durante questa procedura, il traffico può essere riportato alla versione precedente. Con Cloud Service Mesh, puoi: indirizzare il traffico per garantire che i nuovi servizi vengano introdotti in modo sicuro.

Costi

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

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Al termine di questo tutorial, puoi evitare costi continui eliminando le risorse che hai creato. Per maggiori informazioni, vedi Pulizia.

Prima di iniziare

Deployment di Boutique online

  1. Imposta il contesto corrente per kubectl sul cluster in cui prevedi di eseguire il deployment di Online Boutique. Il comando dipende dal fatto che tu abbia eseguito il provisioning di Cloud Service Mesh su un cluster GKE o su un cluster Kubernetes esterno a GKE:

    GKE su Google Cloud

    gcloud container clusters get-credentials CLUSTER_NAME  \
        --project=PROJECT_ID \
        --zone=CLUSTER_LOCATION 
    

    GKE al di fuori di Google Cloud

    kubectl config use-context CLUSTER_NAME 
    
  2. Crea lo spazio dei nomi per l'applicazione di esempio e il gateway in entrata:

    kubectl create namespace onlineboutique
    
  3. Etichetta lo spazio dei nomi onlineboutique per iniettare automaticamente i proxy Envoy. Segui i passaggi su come attivare l'inserimento automatico del file collaterale.

  4. Esegui il deployment dell'app di esempio. Per questo tutorial, esegui il deployment di Online Boutique, un'app demo di microservizi.

    kubectl apply \
    -n onlineboutique \
    -f https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-service-mesh-samples/main/docs/shared/online-boutique/kubernetes-manifests.yaml
    
  5. Aggiungi l'etichetta version=v1 al deployment productcatalog eseguendo seguente comando:

    kubectl patch deployments/productcatalogservice -p '{"spec":{"template":{"metadata":{"labels":{"version":"v1"}}}}}' \
    -n onlineboutique
    

    Visualizza i servizi di cui hai eseguito il deployment:

    kubectl get pods -n onlineboutique
    

    Risultato previsto:

    NAME                                     READY   STATUS    RESTARTS   AGE
    adservice-85598d856b-m84m6               2/2     Running   0          2m7s
    cartservice-c77f6b866-m67vd              2/2     Running   0          2m8s
    checkoutservice-654c47f4b6-hqtqr         2/2     Running   0          2m10s
    currencyservice-59bc889674-jhk8z         2/2     Running   0          2m8s
    emailservice-5b9fff7cb8-8nqwz            2/2     Running   0          2m10s
    frontend-77b88cc7cb-mr4rp                2/2     Running   0          2m9s
    loadgenerator-6958f5bc8b-55q7w           2/2     Running   0          2m8s
    paymentservice-68dd9755bb-2jmb7          2/2     Running   0          2m9s
    productcatalogservice-84f95c95ff-c5kl6   2/2     Running   0          114s
    recommendationservice-64dc9dfbc8-xfs2t   2/2     Running   0          2m9s
    redis-cart-5b569cd47-cc2qd               2/2     Running   0          2m7s
    shippingservice-5488d5b6cb-lfhtt         2/2     Running   0          2m7s
    

    Un 2/2 nella colonna READY indica che un pod è attivo e funzionante con un proxy Envoy iniettato correttamente.

  6. Esegui il deployment di VirtualService e DestinationRule per la versione 1 di productcatalog:

     kubectl apply -f destination-vs-v1.yaml -n onlineboutique
    
    apiVersion: networking.istio.io/v1beta1
    kind: DestinationRule
    metadata:
      name: productcatalogservice
    spec:
      host: productcatalogservice
      subsets:
      - labels:
          version: v1
        name: v1
    ---
    apiVersion: networking.istio.io/v1beta1
    kind: VirtualService
    metadata:
      name: productcatalogservice
    spec:
      hosts:
      - productcatalogservice
      http:
      - route:
        - destination:
            host: productcatalogservice
            subset: v1

    Tieni presente che nelle risorse è presente solo v1.

  7. Visita l'applicazione nel browser utilizzando l'indirizzo IP esterno del tuo gateway in entrata:

    kubectl get services -n GATEWAY_NAMESPACE
    

La sezione successiva illustra l'interfaccia utente di Cloud Service Mesh e mostra come visualizzare le metriche.

Visualizzare i servizi nella console Google Cloud

  1. Nella console Google Cloud, vai alla pagina Servizi Google Kubernetes Engine (GKE) Enterprise Edition.

    Vai ai servizi della versione Google Kubernetes Engine (GKE) Enterprise

  2. Per impostazione predefinita, i servizi vengono visualizzati nella visualizzazione Elenco.

    La panoramica della tabella ti consente di osservare tutti i servizi e le metriche importanti a colpo d'occhio.

  3. In alto a destra, fai clic su Topologia. Qui puoi visualizzare i tuoi servizi e la loro interazione tra loro.

    Puoi espandere Servizi e visualizzare le Richieste al secondo per ciascuno dei tuoi servizi passando il mouse sopra i servizi.

  4. Torna alla visualizzazione tabella.

  5. Nella tabella dei servizi, seleziona productcatalogservice. In questo modo a una panoramica del servizio.

  6. Nella parte sinistra dello schermo, fai clic su Traffico.

  7. Assicurati che il 100% del traffico in entrata su productcatalogservice venga indirizzato al servizio di carico di lavoro.

La sezione successiva illustra la creazione della versione 2 del servizio productcatalog.

Esegui il deployment della versione 2 di un servizio

  1. Per questo tutorial, productcatalogservice-v2 introduce una latenza di 3 secondi nelle richieste con il campo EXTRA_LATENCY. Questo simula regressione lineare nella nuova versione del servizio.

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: productcatalogservice-v2
    spec:
      selector:
        matchLabels:
          app: productcatalogservice
      template:
        metadata:
          labels:
            app: productcatalogservice
            version: v2
        spec:
          containers:
          - env:
            - name: PORT
              value: '3550'
            - name: EXTRA_LATENCY
              value: 3s
            name: server
            image: gcr.io/google-samples/microservices-demo/productcatalogservice:v0.3.6
            livenessProbe:
              exec:
                command: ["/bin/grpc_health_probe", "-addr=:3550"]
            ports:
            - containerPort: 3550
            readinessProbe:
              exec:
                command: ["/bin/grpc_health_probe", "-addr=:3550"]
            resources:
              limits:
                cpu: 200m
                memory: 128Mi
              requests:
                cpu: 100m
                memory: 64Mi
          terminationGracePeriodSeconds: 5

    Applica questa risorsa allo spazio dei nomi onlineboutique.

    kubectl apply -f productcatalog-v2.yaml -n onlineboutique
    
  2. Controlla i pod dell'applicazione.

    kubectl get pods -n onlineboutique
    

    Risultato previsto:

    NAME                                     READY   STATUS    RESTARTS   AGE
    adservice-85598d856b-8wqfd                  2/2     Running   0          25h
    cartservice-c77f6b866-7jwcr                 2/2     Running   0          25h
    checkoutservice-654c47f4b6-n8c6x            2/2     Running   0          25h
    currencyservice-59bc889674-l5xw2            2/2     Running   0          25h
    emailservice-5b9fff7cb8-jjr89               2/2     Running   0          25h
    frontend-77b88cc7cb-bwtk4                   2/2     Running   0          25h
    loadgenerator-6958f5bc8b-lqmnw              2/2     Running   0          25h
    paymentservice-68dd9755bb-dckrj             2/2     Running   0          25h
    productcatalogservice-84f95c95ff-ddhjv      2/2     Running   0          25h
    productcatalogservice-v2-6df4cf5475-9lwjb   2/2     Running   0          8s
    recommendationservice-64dc9dfbc8-7s7cx      2/2     Running   0          25h
    redis-cart-5b569cd47-vw7lw                  2/2     Running   0          25h
    shippingservice-5488d5b6cb-dj5gd            2/2     Running   0          25h
    

    Tieni presente che ora sono elencati due productcatalogservices.

  3. Usa DestinationRule per specificare i sottoinsiemi di un servizio. In questo scenario, esiste un sottoinsieme per la versione 1 e un sottoinsieme separato per la versione 2 di productcatalogservice.

    apiVersion: networking.istio.io/v1beta1
    kind: DestinationRule
    metadata:
      name: productcatalogservice
    spec:
      host: productcatalogservice
      subsets:
      - labels:
          version: v1
        name: v1
      - labels:
          version: v2
        name: v2

    Prendi nota del campo labels. Le versioni di productcatalogservice si distinguono dopo che il traffico è instradato da VirtualService.

    Applica i DestinationRule:

    kubectl apply -f destination-v1-v2.yaml -n onlineboutique
    

Suddividi il traffico tra la versione 1 e la versione 2

  1. Utilizza VirtualService per definire una piccola percentuale di traffico da indirizzare alla versione 2 di productcatalogservice.

    apiVersion: networking.istio.io/v1beta1
    kind: VirtualService
    metadata:
      name: productcatalogservice
    spec:
      hosts:
      - productcatalogservice
      http:
      - route:
        - destination:
            host: productcatalogservice
            subset: v1
          weight: 75
        - destination:
            host: productcatalogservice
            subset: v2
          weight: 25

    Il campo sottoinsieme indica la versione e il campo ponderazione indica la suddivisione percentuale del traffico. Il 75% del traffico viene indirizzato alla versione 1 di productcatalog e il 25% alla versione 2.

    Applica i VirtualService:

    kubectl apply -f vs-split-traffic.yaml -n onlineboutique
    

Se visiti EXTERNAL_IP del traffico in entrata del cluster, noterai che periodicamente il caricamento del frontend è più lento.

Nella sezione successiva, esplora la suddivisione del traffico nella console Google Cloud.

Osserva la suddivisione del traffico nella console Google Cloud

  1. Torna alla console Google Cloud e vai alla pagina Servizi GKE Enterprise. Vai a GKE Enterprise Services

  2. In alto a destra, fai clic su Topologia.

    Espandi il carico di lavoro productcatalogservice e prendi nota dei deployment di productcatalogservice e productcatalogservice-v2.

  3. Torna alla Visualizzazione tabella.

  4. Fai clic su productcatalogservice nella tabella Servizi.

  5. Torna a Traffico nella barra di navigazione a sinistra.

  6. Tieni presente che il traffico in entrata è suddiviso tra v1 e v2 in base alla percentuale specificata nel file VirtualService e che esistono due carichi di lavoro del servizio di catalogo prodotti.

    Sul lato destro della pagina, vedrai Richieste, Tasso di errore e Metriche sulla latenza. Con Cloud Service Mesh, ogni servizio presenta queste metriche per fornirti metriche di osservabilità.

Eseguire l'implementazione o il rollback a una versione

Dopo aver osservato le metriche durante un deployment canary, puoi completare il deployment della nuova versione del servizio o eseguire il rollback alla versione originale del servizio utilizzando la risorsa VirtualService.

Implementazione

Quando il comportamento di un servizio v2 ti soddisfa, puoi aumentare gradualmente la percentuale di traffico indirizzato al servizio v2. In seguito il traffico può essere indirizzato al 100% al nuovo servizio nella risorsa VirtualService creato in precedenza rimuovendo la suddivisione del traffico da quella risorsa.

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: productcatalogservice
spec:
  hosts:
  - productcatalogservice
  http:
  - route:
    - destination:
        host: productcatalogservice
        subset: v2

Per indirizzare tutto il traffico alla versione 2 di productcatalogservice:

kubectl apply -f vs-v2.yaml -n onlineboutique

Rollback

Se devi eseguire il rollback al servizio v1, applica il valore destination-vs-v1.yaml precedente. Questo indirizza il traffico solo alla versione 1 di productcatalogservice.

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: productcatalogservice
spec:
  hosts:
  - productcatalogservice
  http:
  - route:
    - destination:
        host: productcatalogservice
        subset: v1

Per indirizzare tutto il traffico alla versione 1 di productcatalogservice:

kubectl apply -f vs-v1.yaml -n onlineboutique

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Per evitare che al tuo account Google Cloud vengano addebitati costi continui per le risorse usate in questo tutorial, puoi eliminare il progetto le singole risorse.

Elimina il progetto

In Cloud Shell, elimina il progetto:

gcloud projects delete PROJECT_ID

Elimina le risorse

Se vuoi evitare addebiti aggiuntivi, elimina il cluster:

gcloud container clusters delete  CLUSTER_NAME  \
  --project=PROJECT_ID \
  --zone=CLUSTER_LOCATION 

Se hai registrato il cluster con il parco risorse utilizzando gcloud container fleet memberships (anziché --enable-fleet o --fleet-project durante la creazione del cluster) quindi rimuovi l'abbonamento inattivo:

gcloud container fleet memberships delete  MEMBERSHIP  \
  --project=PROJECT_ID

Se vuoi mantenere il cluster configurato per Cloud Service Mesh, ma rimuovi l'esempio di Online Boutique:

  1. Elimina gli spazi dei nomi dell'applicazione:

    kubectl delete -f namespace onlineboutique
    

    Output previsto:

    namespace "onlineboutique" deleted
    
  2. Elimina le voci del servizio:

    kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/microservices-demo/main/istio-manifests/frontend.yaml -n onlineboutique
    kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/microservices-demo/main/istio-manifests/frontend-gateway.yaml -n onlineboutique
    

    Risultato previsto:

    serviceentry.networking.istio.io "allow-egress-googleapis" deleted
    serviceentry.networking.istio.io "allow-egress-google-metadata" deleted
    

Passaggi successivi