Cloud Service Mesh tramite esempi: deployment canary

Esegui il deployment di Online Boutique

1. Imposta il contesto attuale per kubectl sul cluster in cui hai eseguito il deployment di Online Boutique:

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

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 inserire automaticamente i proxy Envoy. Segui i passaggi su come attivare l'inserimento automatico di sidecar.

4. Esegui il deployment dell'app di esempio. Per questo tutorial, eseguirai 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 un'etichetta version=v1 al deployment productcatalog eseguendo questo 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
   

   Output 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
   

   Tutti i pod per la tua applicazione devono essere in esecuzione, con un 2/2 nella colonna READY. Ciò indica che il proxy sidecar Envoy è stato inserito correttamente nei pod.

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 dell'ingresso:

   kubectl get services -n GATEWAY_NAMESPACE
   

Nella sezione successiva verrà illustrata la UI di Cloud Service Mesh e verrà mostrato come visualizzare le metriche.

Esegui il deployment e visualizza i tuoi servizi nella console Google Cloud

1. Nella console Google Cloud , vai alla pagina Servizi GKE Enterprise.

   Vai a GKE Enterprise Services

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

   La panoramica della tabella ti consente di osservare tutti i tuoi servizi, nonché 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 reciproca.

   Puoi espandere i servizi e visualizzare le richieste al secondo per ciascuno di essi passando il cursore sopra.

   

4. Torna alla visualizzazione tabella.

5. Nella tabella Servizi, seleziona productcatalogservice. Verrà visualizzata una panoramica del servizio.

6. Sul lato sinistro dello schermo, fai clic su Traffico.

7. Assicurati che il 100% del traffico in entrata a productcatalogservice venga indirizzato al servizio del workload.

   

La sezione successiva illustrerà la creazione di una versione 2 del servizio productcatalog.

Esegui il deployment della versione 2 di un servizio

1. Per questo tutorial, productcatalogservice-v2 introdurrà una latenza di 3 secondi nelle richieste con il campo EXTRA_LATENCY.

   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
   

   Output 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. DestinationRule è il modo per specificare i sottoinsiemi di un servizio. In questo scenario, esiste un sottoinsieme per la v1 e per la v2 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 viene indirizzato da VirtualService.

   Applica DestinationRule:

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

Suddividi il traffico tra v1 e v2

1. Un VirtualService è il modo in cui introduci 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, mentre il campo ponderazione indica la percentuale di suddivisione del traffico. Il 75% del traffico verrà indirizzato alla versione 1 di productcatalog e il 25% alla versione 2.

   Applica VirtualService:

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

Se visiti l'EXTERNAL_IP dell'ingresso del cluster, dovresti notare che periodicamente il caricamento del frontend è più lento.

Nella sezione successiva, esplorerai la suddivisione del traffico nella console GKE Enterprise 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 Servizi GKE Enterprise

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

   Espandi il carico di lavoro productcatalogservice. Vedrai i deployment di productcatalogservice e productcatalogservice-v2.

   

3. Torna alla visualizzazione tabella. Fai clic su productcatalogservice nella tabella Servizi. Torna a Traffico nella barra di navigazione a sinistra.

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

   Sul lato destro dello schermo, vedrai le metriche Richieste, Tasso di errore e Latenza. Con Cloud Service Mesh, ogni servizio avrà queste metriche delineate per fornirti l'osservabilità.

   

Eseguire il rollout o il rollback a una versione

Dopo aver osservato le metriche durante un deployment canary, puoi eseguire il rollout del nuovo servizio o il rollback del servizio precedente utilizzando la risorsa VirtualService.

Implementazione

Una volta soddisfatto del comportamento di un servizio v2, aumenta gradualmente il comportamento del traffico verso il servizio v2. Alla fine, il traffico può essere indirizzato al 100% al nuovo servizio.

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

Esegui il rollback

Se devi eseguire il rollback al servizio v1, applica semplicemente destination-vs-v1.yaml precedente. In questo modo il traffico verrà indirizzato 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