Tous les produits
Search
Centre de documentation

Alibaba Cloud Service Mesh:Integrate ASM with Argo Rollouts to implement canary releases

Dernière mise à jour :Aug 11, 2026

Argo Rollouts est un contrôleur Kubernetes et un ensemble de définitions de ressources personnalisées (CRD) dédiés à la livraison progressive. L'intégration de Service Mesh (ASM) avec Argo Rollouts permet d'effectuer des déploiements canaris qui transfèrent progressivement le trafic d'une version stable vers une nouvelle version, selon des pourcentages de poids configurables.

Avec les mises à jour progressives natives de Kubernetes, le ratio de trafic dépend du nombre de réplicas : pour acheminer 1 % du trafic vers un déploiement canari, il faut maintenir 99 réplicas stables. Les déploiements canaris basés sur ASM dissocient le fractionnement du trafic du nombre de pods en s'appuyant sur les règles Istio VirtualService. Ainsi, le scaling automatique n'affecte pas le ratio de trafic et des pourcentages granulaires fonctionnent quel que soit le nombre de réplicas en cours d'exécution.

Fonctionnement

Un déploiement canari réalisé avec ASM et Argo Rollouts suit ce cycle de vie :

  1. Déployez une ressource Rollout définissant la stratégie canari : étapes de pondération du trafic, durées de pause et références au Istio VirtualService.

  2. Créez deux services Kubernetes — l'un pour la version stable, l'autre pour le canari — ainsi qu'un Istio VirtualService qui répartit le trafic entre eux.

  3. Lorsque vous mettez à jour l'image de la ressource Rollout, le contrôleur Argo Rollouts ajuste automatiquement les poids du VirtualService conformément aux étapes définies.

  4. À chaque étape, le contrôleur observe une pause pendant la durée spécifiée (ou attend une approbation manuelle) avant d'augmenter le poids du canari.

  5. Une fois toutes les étapes terminées, la version canari devient la nouvelle version stable.

En option, associez un AnalysisTemplate basé sur Prometheus afin de surveiller le taux de réussite de la version canari. Si ce taux descend sous un seuil donné, le contrôleur revient automatiquement à la version stable.

Ce guide illustre le fractionnement du trafic au niveau de l'hôte, où deux services distincts ( istio-rollout-stable et istio-rollout-canary ) assurent la distribution du trafic. Istio prend également en charge le fractionnement du trafic au niveau des sous-ensembles via une DestinationRule, approche mieux adaptée au trafic est-ouest (intra-cluster) car elle évite les complications DNS. Pour plus de détails, consultez Gestion du trafic Istio avec Argo Rollouts .

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Installer Argo Rollouts

Pour obtenir les détails complets de l'installation, consultez Installation d'Argo Rollouts.

  1. Installez le contrôleur Argo Rollouts :

    kubectl create namespace argo-rollouts
    kubectl apply -n argo-rollouts -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml
  2. Installez le plug-in kubectl d'Argo Rollouts pour gérer l'outil via CLI :

    brew install argoproj/tap/kubectl-argo-rollouts

Activer l'accès KubeAPI depuis le plan de données

Activez l'accès KubeAPI afin de gérer les ressources Istio (VirtualServices, Gateways, DestinationRules) directement depuis le cluster du plan de données à l'aide de kubectl.

  1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.

  2. Sur la page Mesh Management, cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez ASM Instance > Base Information.

  3. Cliquez sur Enable à droite de l'option Enable Data-plane KubeAPI access.

    Enable Data-plane KubeAPI access

  4. Dans la boîte de dialogue de confirmation, cliquez sur OK.

Mettre en œuvre un déploiement canari

Cette section détaille la mise en place complète d'un déploiement canari : déploiement d'une version stable (bleue), puis transfert progressif du trafic vers une version canari (jaune).

Étape 1 : Créer la ressource Rollout et les services

Créer la ressource Rollout

  1. Créez un fichier rollout.yaml contenant le code suivant :

    Afficher rollout.yaml

    apiVersion: argoproj.io/v1alpha1
    kind: Rollout
    metadata:
      name: istio-rollout
    spec:
      revisionHistoryLimit: 2               # Number of old ReplicaSets to retain
      selector:
        matchLabels:
          app: istio-rollout
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "true"  # Enable Istio sidecar injection
          labels:
            app: istio-rollout
        spec:
          containers:
          - name: istio-rollout
            image: argoproj/rollouts-demo:blue  # Initial stable version
            ports:
            - name: http
              containerPort: 8080
              protocol: TCP
            resources:
              requests:
                memory: 32Mi
                cpu: 5m
      strategy:
        canary:
          canaryService: istio-rollout-canary   # Service that targets canary pods
          stableService: istio-rollout-stable   # Service that targets stable pods
          trafficRouting:
            istio:
              virtualService:
                name: istio-rollout-vsvc        # VirtualService whose weights the controller updates
                routes:
                - primary                       # Route name inside the VirtualService
          steps:
          - setWeight: 10          # Route 10% of traffic to canary
          - pause: {}              # Wait for manual approval (kubectl argo rollouts promote)
          - setWeight: 20          # Route 20% of traffic to canary
          - pause: {duration: 20s} # Wait 20 seconds, then auto-advance
          - setWeight: 30
          - pause: {duration: 20s}
          - setWeight: 40
          - pause: {duration: 20s}
          - setWeight: 50
          - pause: {duration: 20s}
          - setWeight: 60
          - pause: {duration: 20s}
          - setWeight: 70
          - pause: {duration: 20s}
          - setWeight: 80
          - pause: {duration: 20s}
          - setWeight: 90
          - pause: {duration: 20s}

    Champs clés sous strategy.canary :

    Champ Description
    setWeight Pourcentage du trafic acheminé vers la version canari à cette étape
    pause: {} Pause indéfinie jusqu'à l'exécution de kubectl argo rollouts promote
    pause: {duration: 20s} Pause de 20 secondes, puis passage automatique à l'étape suivante
  2. Déployez la ressource Rollout dans le cluster ajouté à votre instance ASM :

    kubectl apply -f rollout.yaml

Créer les services

  1. Créez un fichier service.yaml contenant le code suivant :

    Les deux services utilisent le même sélecteur ( app: istio-rollout ). Argo Rollouts gère les pods ciblés par chaque service durant le déploiement canari.
    apiVersion: v1
    kind: Service
    metadata:
      name: istio-rollout-canary    # Canary Service -- Argo Rollouts maps this to canary pods
    spec:
      ports:
      - port: 80
        targetPort: http
        protocol: TCP
        name: http
      selector:
        app: istio-rollout
    
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: istio-rollout-stable    # Stable Service -- Argo Rollouts maps this to stable pods
    spec:
      ports:
      - port: 80
        targetPort: http
        protocol: TCP
        name: http
      selector:
        app: istio-rollout
  2. Déployez les services :

    kubectl apply -f service.yaml

Étape 2 : Créer les ressources Istio

L'accès KubeAPI depuis le plan de données étant activé, utilisez kubectl depuis le cluster du plan de données pour créer directement les ressources Istio. Vous pouvez également recourir à la console ASM ou au kubeconfig du plan de contrôle.

Créer le VirtualService

  1. Créez un fichier istio-rollout-vsvc.yaml contenant le code suivant :

    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
      name: istio-rollout-vsvc
    spec:
      gateways:
        - istio-rollout-gateway
      hosts:
        - '*'
      http:
        - match:
            - uri:
                prefix: /
          name: primary                   # Must match the route name in the Rollout
          route:
            - destination:
                host: istio-rollout-stable # All traffic goes to stable initially
              weight: 100
            - destination:
                host: istio-rollout-canary # Canary destination -- weight starts at 0
  2. Déployez le VirtualService :

    kubectl apply -f istio-rollout-vsvc.yaml

Créer la Gateway

  1. Créez un fichier istio-rollout-gateway.yaml contenant le code suivant :

    apiVersion: networking.istio.io/v1beta1
    kind: Gateway
    metadata:
      name: istio-rollout-gateway
    spec:
      selector:
        istio: ingressgateway            # Binds to the ASM ingress gateway
      servers:
        - hosts:
            - '*'
          port:
            name: http
            number: 80                   # Accept HTTP traffic on port 80
            protocol: HTTP
  2. Déployez la Gateway :

    kubectl apply -f istio-rollout-gateway.yaml

Étape 3 : Déployer une passerelle d'entrée

Créez une passerelle d'entrée ASM avec le port 80 activé pour permettre l'accès aux services.

  1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.

  2. Sur la page Mesh Management, cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez ASM Gateways > Ingress Gateway.

  3. Sur la page Ingress Gateway, cliquez sur Create et configurez les paramètres suivants. Pour les autres paramètres, consultez Créer une passerelle d'entrée.

    Paramètre Valeur
    Name ingressgateway
    Gateway types North-South IngressGateway
    Port Mapping Protocole : HTTP, Port de service : 80
  4. Cliquez sur Create.

Étape 4 : Vérifier l'état initial de la ressource Rollout

Exécutez la commande suivante pour vérifier que la ressource Rollout est opérationnelle :

kubectl argo rollouts get rollout istio-rollout

Résultat attendu :

Name:            istio-rollout
Namespace:       default
Status:           Healthy
Strategy:        Canary
  Step:          18/18
  SetWeight:     100
  ActualWeight:  100
Images:          argoproj/rollouts-demo:blue (stable)
Replicas:
  Desired:       1
  Current:       1
  Updated:       1
  Ready:         1
  Available:     1

NAME                                       KIND        STATUS     AGE  INFO
⟳ istio-rollout                            Rollout      Healthy  52s
└──# revision:1
└──⧉ istio-rollout-7f96d86486           ReplicaSet   Healthy  52s  stable
   └──□ istio-rollout-7f96d86486-vpqvb  Pod         Running  52s  ready:2/2

Un état Healthy avec l'image argoproj/rollouts-demo:blue (stable) confirme la réussite du déploiement initial.

Étape 5 : Tester le déploiement initial

  1. Récupérez l'adresse IP de la passerelle d'entrée :

    1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.

    2. Cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez ASM Gateways > Ingress Gateway.

    3. Copiez l'Service address de la passerelle d'entrée.

  2. Ouvrez http://<ingress-gateway-ip>/ dans un navigateur. La page effectue des appels simultanés vers /color et remplit la grille avec la couleur renvoyée. Comme la version stable utilise l'image blue et qu'aucun canari n'est en cours d'exécution, toutes les cases de la grille s'affichent en bleu.

    Initial blue grid display

Étape 6 : Effectuer le déploiement canari

Dans cet exemple, la couleur jaune représente la version canari. Au fur et à mesure de la progression du déploiement, la grille passe progressivement du bleu au jaune.

Mettre à jour l'image de la ressource Rollout

  1. Définissez la nouvelle version de l'image :

    kubectl argo rollouts set image istio-rollout "*=argoproj/istio-rollout:yellow"
  2. Vérifiez que les deux versions de pods sont en cours d'exécution :

    1. Connectez-vous à la console ACK et cliquez sur Clusters dans le volet de navigation de gauche.

    2. Cliquez sur le nom du cluster, puis sélectionnez Workloads > Pods.

    3. Dans la colonne Name, confirmez la présence des pods pour les versions bleue (stable) et jaune (canari).

    Both pod versions running

Observer le premier basculement de trafic

Ouvrez http://<ingress-gateway-ip>/ dans un navigateur. Environ 10 % des cases de la grille s'affichent désormais en jaune. Le contrôleur Argo Rollouts a mis à jour les poids du VirtualService : le poids de la version stable (bleue) est passé de 100 à 90, tandis que celui du canari (jaune) est passé de 0 à 10.

10% canary traffic

La première étape spécifie pause: {} sans durée définie, de sorte que la ressource Rollout attend une approbation manuelle avant de poursuivre.

Poursuivre le déploiement

  1. Approuvez la ressource Rollout pour franchir la pause manuelle :

    kubectl argo rollouts promote istio-rollout
  2. Ouvrez http://<ingress-gateway-ip>/ dans un navigateur. Les poids du VirtualService continuent de s'ajuster automatiquement au fil des étapes restantes (20 %, 30 %, ... 90 %), avec une pause de 20 secondes entre chaque étape.

    Progressive traffic shift

Vérifier l'achèvement du déploiement

  1. Une fois toutes les étapes terminées, ouvrez http://<ingress-gateway-ip>/ dans un navigateur. Toutes les cases de la grille s'affichent en jaune, confirmant que la version canari a entièrement remplacé la version stable.

    All yellow -- canary release complete

  2. Vérifiez l'état de la ressource Rollout. Résultat attendu : l'image affiche désormais argoproj/rollouts-demo:yellow (stable), ce qui confirme que la version canari a été promue.

    kubectl argo rollouts get rollout istio-rollout --watch
    Name:            istio-rollout
    Namespace:       default
    Status:           Healthy
    Strategy:        Canary
      Step:          18/18
      SetWeight:     100
      ActualWeight:  100
    Images:          argoproj/rollouts-demo:yellow (stable)
    Replicas:
      Desired:       1
      Current:       1
      Updated:       1
      Ready:         1
      Available:     1
    
    NAME                                       KIND        STATUS        AGE  INFO
    ⟳ istio-rollout                            Rollout      Healthy     48m
    ├──# revision:4
    │  └──⧉ istio-rollout-5fcf5864c4           ReplicaSet   Healthy     27m  stable
    │     └──□ istio-rollout-5fcf5864c4-vw6kh  Pod          Running     26m  ready:2/2
    ├──# revision:3
    │  └──⧉ istio-rollout-897cb5b6d            ReplicaSet  ScaledDown  27m
    └──# revision:1
       └──⧉ istio-rollout-7f96d86486           ReplicaSet  ScaledDown  48m

Configurer un retour arrière automatique avec Prometheus

Plutôt que de s'en remettre à une observation manuelle, configurez une analyse basée sur Prometheus pour revenir automatiquement en arrière lorsqu'un déploiement canari présente un taux de réussite inférieur à un seuil donné.

Pour effectuer manuellement un retour arrière à tout moment durant un déploiement canari, exécutez :
kubectl argo rollouts abort istio-rollout

Étape 1 : Activer Prometheus dans ASM

Activez la supervision Prometheus pour l'instance ASM. Pour plus d'informations, consultez :

Étape 2 : Créer un AnalysisTemplate

Le AnalysisTemplate définit une requête Prometheus calculant le taux de réussite des requêtes pour la version canari. Si le taux de réussite chute à 0,90 ou moins (ce qui signifie que plus de 10 % des requêtes renvoient des erreurs 5xx), la ressource Rollout est marquée comme Degraded et un retour arrière automatique est déclenché.

  1. Créez un fichier istio-success-rate.yaml contenant le code suivant. Remplacez <your-prometheus-endpoint> par le point de terminaison réel de votre instance Prometheus connectée à ASM.

    apiVersion: argoproj.io/v1alpha1
    kind: AnalysisTemplate
    metadata:
      name: istio-success-rate
    spec:
      args:
      - name: service                       # Service name, passed from the Rollout
      - name: namespace                     # Namespace, auto-resolved from the Rollout
      metrics:
      - name: success-rate
        initialDelay: 60s                   # Wait 60s for traffic to flow before first check
        interval: 20s                       # Re-evaluate every 20 seconds
        successCondition: result[0] > 0.90  # Pass if success rate > 90%; fail otherwise
        provider:
          prometheus:
            address: http://<your-prometheus-endpoint>:9090/api/v1/prometheus/
            query: >+
              sum(irate(istio_requests_total{
                reporter="source",
                destination_service=~"{{args.service}}.{{args.namespace}}.svc.cluster.local",
                response_code!~"5.*"}[40s])
              )
              /
              sum(irate(istio_requests_total{
                reporter="source",
                destination_service=~"{{args.service}}.{{args.namespace}}.svc.cluster.local"}[40s])
              )
  2. Déployez le AnalysisTemplate :

    kubectl apply -f istio-success-rate.yaml

Étape 3 : Associer le AnalysisTemplate à la ressource Rollout

Mettez à jour la ressource Rollout en y incluant une section analysis qui référence le AnalysisTemplate. L'analyse démarre à partir de la deuxième étape (startingStep: 1), laissant ainsi à la version canari le temps de recevoir du trafic avant l'évaluation des métriques.

  1. Créez un nouveau fichier rollout.yaml contenant le code suivant :

    Afficher rollout.yaml

    apiVersion: argoproj.io/v1alpha1
    kind: Rollout
    metadata:
      name: istio-rollout
    spec:
      revisionHistoryLimit: 2
      selector:
        matchLabels:
          app: istio-rollout
      template:
        metadata:
          annotations:
            sidecar.istio.io/inject: "true"
          labels:
            app: istio-rollout
        spec:
          containers:
          - name: istio-rollout
            image: argoproj/rollouts-demo:yellow   # Current stable version
            ports:
            - name: http
              containerPort: 8080
              protocol: TCP
            resources:
              requests:
                memory: 32Mi
                cpu: 5m
      strategy:
        canary:
          canaryService: istio-rollout-canary
          stableService: istio-rollout-stable
          analysis:
            startingStep: 1                        # Start analysis from the second step
            templates:
            - templateName: istio-success-rate     # Reference the AnalysisTemplate
            args:
            - name: service
              value: canary
            - name: namespace
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace    # Auto-resolve namespace
          trafficRouting:
            istio:
              virtualService:
                name: istio-rollout-vsvc
                routes:
                - primary
          steps:
          - setWeight: 10
          - pause: {}              # Wait for manual approval
          - setWeight: 20
          - pause: {duration: 20s}
          - setWeight: 30
          - pause: {duration: 20s}
          - setWeight: 40
          - pause: {duration: 20s}
          - setWeight: 50
          - pause: {duration: 20s}
          - setWeight: 60
          - pause: {duration: 20s}
          - setWeight: 70
          - pause: {duration: 20s}
          - setWeight: 80
          - pause: {duration: 20s}
          - setWeight: 90
          - pause: {duration: 20s}
  2. Mettez à jour la ressource Rollout :

    kubectl apply -f rollout.yaml

Étape 4 : Déclencher un déploiement canari avec analyse

  1. Mettez à jour l'image pour lancer un nouveau déploiement canari. Ouvrez http://<ingress-gateway-ip>/ dans un navigateur. Des cases oranges apparaissent au fur et à mesure que le trafic canari circule.

    kubectl argo rollouts set image istio-rollout "*=argoproj/rollouts-demo:orange"

    Orange canary traffic

  2. Approuvez la ressource Rollout pour démarrer la progression automatique du canari avec la supervision Prometheus :

    kubectl argo rollouts promote istio-rollout
  3. Surveillez l'état de la ressource Rollout :

    kubectl argo rollouts get rollout istio-rollout --watch

    Rollout status with analysis

Étape 5 : Tester le retour arrière automatique

Pour tester le comportement de retour arrière, augmentez le taux d'erreur de la version canari à l'aide du curseur dédié sur la page de l'application de démonstration. Lorsque le taux d'erreur dépasse 10 % (le taux de réussite chute en dessous de 0,90), le AnalysisTemplate marque la ressource Rollout comme Degraded et le contrôleur revient automatiquement à la version stable (jaune).

Canary release in progress with errors

Après un court délai, tout le trafic revient vers la version stable :

Automatic rollback to stable version

Étapes suivantes