Tous les produits
Search

Ce produit

    Alibaba Cloud Service Mesh:Configure traffic lanes in permissive mode with ASMHeaderPropagation

    Centre de documentation

    Alibaba Cloud Service Mesh:Configure traffic lanes in permissive mode with ASMHeaderPropagation

    Dernière mise à jour :Aug 11, 2026

    Les voies de trafic acheminent les requêtes vers des versions spécifiques d'un service sur l'ensemble d'une chaîne d'appels. Par exemple, toutes les requêtes portant le tag v2 atteignent l'instance v2 de chaque service dans la chaîne. En mode permissif, si une version correspondante n'existe pas pour un service donné, le trafic bascule automatiquement vers la version de référence au lieu d'échouer. Cette approche permet des déploiements canaris sécurisés et des tests basés sur la version dans des architectures multi-services sans exiger que chaque service dispose de toutes les versions déployées.

    Fonctionnement

    Quatre types de ressources travaillent conjointement pour mettre en œuvre les voies de trafic :

    Ressource Rôle
    OpenTelemetry Instrumentation Propage automatiquement les en-têtes baggage entre les appels de service sans modification du code
    ASMHeaderPropagation CRD spécifique à ASM qui extrait les en-têtes spécifiés (tels que version) du contexte baggage et les joint comme en-têtes de requête tout au long de la chaîne d'appels
    DestinationRule Définit des sous-ensembles de services (v1, v2, v3) en fonction des étiquettes des pods
    VirtualService Achemine les requêtes vers le sous-ensemble correct en faisant correspondre l'en-tête version propagé, avec un basculement vers le sous-ensemble de référence lorsque la version cible ne possède aucun point de terminaison sain

    Flux de trafic :

    Client request
    |
    v
Ingress Gateway (sets version header, distributes traffic by weight)
    |
    v
mocka (version matched via header) --> mockb (version matched) --> mockc (version matched)
    |                                      |                           |
    v                                      v                           v
If no matching version exists,       Same fallback logic          Same fallback logic
falls back to v1 (baseline)
    Le champ fallback utilisé dans les routes VirtualService est une extension spécifique à ASM de l'API Istio VirtualService standard. Il se déclenche lorsque le sous-ensemble cible ne comporte aucun point de terminaison sain, en acheminant le trafic vers le sous-ensemble de secours spécifié au lieu de renvoyer une erreur. Ce champ n'est pas disponible dans Istio upstream.

    En-têtes baggage

    Baggage est un mécanisme OpenTelemetry permettant de propager un contexte clé-valeur entre les processus dans une trace distribuée. Il utilise un en-tête HTTP :

    baggage: userId=alice,serverNode=DF%2028,isProduction=false

    Les en-têtes baggage transportent des données contextuelles telles que les ID de locataire, les ID de trace et les identifiants de sécurité, ce qui permet l'analyse des traces et la corrélation des journaux sans modification du code.

    Pour plus d'informations sur les voies de trafic, consultez Présentation des voies de trafic.

    Prérequis

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

    Étape 1 : Déployer l'opérateur OpenTelemetry et configurer l'instrumentation automatique

    L'opérateur OpenTelemetry instrumente automatiquement les pods de service pour propager les en-têtes baggage entre les appels sans modification du code.

    Déployer l'opérateur OpenTelemetry

    1. Connectez-vous au cluster Kubernetes avec kubectl. Créez l'espace de noms opentelemetry-operator-system :

      kubectl create namespace opentelemetry-operator-system

    2. Installez l'opérateur OpenTelemetry avec Helm :

      helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
helm install  \
    --namespace=opentelemetry-operator-system \
    --version=0.46.0 \
    --set admissionWebhooks.certManager.enabled=false \
    --set admissionWebhooks.certManager.autoGenerateCert=true \
    --set manager.image.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/opentelemetry-operator" \
    --set manager.image.tag="0.92.1" \
    --set kubeRBACProxy.image.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/kube-rbac-proxy" \
    --set kubeRBACProxy.image.tag="v0.13.1" \
    --set manager.collectorImage.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/opentelemetry-collector" \
    --set manager.collectorImage.tag="0.97.0" \
    --set manager.opampBridgeImage.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/operator-opamp-bridge" \
    --set manager.opampBridgeImage.tag="0.97.0" \
    --set manager.targetAllocatorImage.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/target-allocator" \
    --set manager.targetAllocatorImage.tag="0.97.0" \
    --set manager.autoInstrumentationImage.java.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/autoinstrumentation-java" \
    --set manager.autoInstrumentationImage.java.tag="1.32.1" \
    --set manager.autoInstrumentationImage.nodejs.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/autoinstrumentation-nodejs" \
    --set manager.autoInstrumentationImage.nodejs.tag="0.49.1" \
    --set manager.autoInstrumentationImage.python.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/autoinstrumentation-python" \
    --set manager.autoInstrumentationImage.python.tag="0.44b0" \
    --set manager.autoInstrumentationImage.dotnet.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/autoinstrumentation-dotnet" \
    --set manager.autoInstrumentationImage.dotnet.tag="1.2.0" \
    --set manager.autoInstrumentationImage.go.repository="registry-cn-hangzhou.ack.aliyuncs.com/acs/opentelemetry-go-instrumentation" \
    --set manager.autoInstrumentationImage.go.tag="v0.10.1.alpha-2-aliyun" \
    opentelemetry-operator open-telemetry/opentelemetry-operator

    3. Vérifiez que le pod de l'opérateur est en cours d'exécution. Sortie attendue :

      kubectl get pod -n opentelemetry-operator-system
      NAME                                      READY   STATUS    RESTARTS   AGE
opentelemetry-operator-854fb558b5-pvllj   2/2     Running   0          1m

    Configurer l'instrumentation automatique

    Créez un fichier instrumentation.yaml pour déclarer le propagateur baggage. Choisissez la configuration en fonction du déploiement ou non d'un collecteur OpenTelemetry dans votre environnement.

    Sans collecteur OpenTelemetry -- Désactive l'exportation des métriques et le traçage pour éviter les erreurs lorsqu'aucun point de terminaison de collecteur n'est disponible :

    apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata:
  name: demo-instrumentation
spec:
  env:
  - name: OTEL_METRICS_EXPORTER
    value: none
  propagators:
  - baggage
  sampler:
    argument: "1"
    type: always_off

    Avec un collecteur OpenTelemetry -- Active le traçage complet avec un échantillonnage basé sur le parent :

    apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata:
  name: demo-instrumentation
spec:
  propagators:
    - baggage
  sampler:
    type: parentbased_traceidratio
    argument: "1"

    Appliquez la ressource d'instrumentation à l'espace de noms default :

    kubectl apply -f instrumentation.yaml
    Le déploiement d'un collecteur OpenTelemetry pour recueillir les données d'observabilité constitue une bonne pratique. Pour plus de détails sur la collecte des données de traçage ASM, consultez Collecter les données de traçage ASM vers Managed Service for OpenTelemetry .

    Étape 2 : Déployer des exemples de services

    Cette étape déploie trois services -- mocka, mockb et mockc -- chacun avec trois versions (v1, v2, v3). Les services forment une chaîne d'appels : mocka -> mockb -> mockc. Chaque pod est annoté pour l'instrumentation automatique Java, de sorte que les en-têtes baggage sont propagés automatiquement.

    1. Activez l'injection automatique de proxy sidecar pour l'espace de noms default. Consultez Gérer les espaces de noms globaux.

      Pour plus d'informations sur l'injection de sidecar, consultez Activer l'injection automatique de proxy sidecar .

    2. Créez un fichier mock.yaml avec le contenu suivant.

      Afficher mock.yaml

      apiVersion: v1
kind: Service
metadata:
  name: mocka
  labels:
    app: mocka
    service: mocka
spec:
  ports:
  - port: 8000
    name: http
  selector:
    app: mocka
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mocka-v1
  labels:
    app: mocka
    version: v1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mocka
      version: v1
      ASM_TRAFFIC_TAG: v1
  template:
    metadata:
      labels:
        app: mocka
        version: v1
        ASM_TRAFFIC_TAG: v1
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v1
        - name: app
          value: mocka
        - name: upstream_url
          value: "http://mockb:8000/"
        ports:
        - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: mockb
  labels:
    app: mockb
    service: mockb
spec:
  ports:
  - port: 8000
    name: http
  selector:
    app: mockb
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mockb-v1
  labels:
    app: mockb
    version: v1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mockb
      version: v1
      ASM_TRAFFIC_TAG: v1
  template:
    metadata:
      labels:
        app: mockb
        version: v1
        ASM_TRAFFIC_TAG: v1
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v1
        - name: app
          value: mockb
        - name: upstream_url
          value: "http://mockc:8000/"
        ports:
        - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: mockc
  labels:
    app: mockc
    service: mockc
spec:
  ports:
  - port: 8000
    name: http
  selector:
    app: mockc
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mockc-v1
  labels:
    app: mockc
    version: v1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mockc
      version: v1
      ASM_TRAFFIC_TAG: v1
  template:
    metadata:
      labels:
        app: mockc
        version: v1
        ASM_TRAFFIC_TAG: v1
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v1
        - name: app
          value: mockc
        ports:
        - containerPort: 8000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mocka-v2
  labels:
    app: mocka
    version: v2
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mocka
      version: v2
      ASM_TRAFFIC_TAG: v2
  template:
    metadata:
      labels:
        app: mocka
        version: v2
        ASM_TRAFFIC_TAG: v2
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v2
        - name: app
          value: mocka
        - name: upstream_url
          value: "http://mockb:8000/"
        ports:
        - containerPort: 8000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mockb-v2
  labels:
    app: mockb
    version: v2
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mockb
      version: v2
      ASM_TRAFFIC_TAG: v2
  template:
    metadata:
      labels:
        app: mockb
        version: v2
        ASM_TRAFFIC_TAG: v2
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v2
        - name: app
          value: mockb
        - name: upstream_url
          value: "http://mockc:8000/"
        ports:
        - containerPort: 8000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mockc-v2
  labels:
    app: mockc
    version: v2
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mockc
      version: v2
      ASM_TRAFFIC_TAG: v2
  template:
    metadata:
      labels:
        app: mockc
        version: v2
        ASM_TRAFFIC_TAG: v2
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v2
        - name: app
          value: mockc
        ports:
        - containerPort: 8000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mocka-v3
  labels:
    app: mocka
    version: v3
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mocka
      version: v3
      ASM_TRAFFIC_TAG: v3
  template:
    metadata:
      labels:
        app: mocka
        version: v3
        ASM_TRAFFIC_TAG: v3
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v3
        - name: app
          value: mocka
        - name: upstream_url
          value: "http://mockb:8000/"
        ports:
        - containerPort: 8000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mockb-v3
  labels:
    app: mockb
    version: v3
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mockb
      version: v3
      ASM_TRAFFIC_TAG: v3
  template:
    metadata:
      labels:
        app: mockb
        version: v3
        ASM_TRAFFIC_TAG: v3
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v3
        - name: app
          value: mockb
        - name: upstream_url
          value: "http://mockc:8000/"
        ports:
        - containerPort: 8000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mockc-v3
  labels:
    app: mockc
    version: v3
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mockc
      version: v3
      ASM_TRAFFIC_TAG: v3
  template:
    metadata:
      labels:
        app: mockc
        version: v3
        ASM_TRAFFIC_TAG: v3
      annotations:
        instrumentation.opentelemetry.io/inject-java: "true"
        instrumentation.opentelemetry.io/container-names: "default"
    spec:
      containers:
      - name: default
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/asm-mock:v0.1-java
        imagePullPolicy: IfNotPresent
        env:
        - name: version
          value: v3
        - name: app
          value: mockc
        ports:
        - containerPort: 8000

      Points clés concernant les manifestes YAML :

      Configuration Objectif
      Étiquette ASM_TRAFFIC_TAG Identifie chaque pod avec sa version (v1, v2 ou v3) pour le routage des voies de trafic
      instrumentation.opentelemetry.io/inject-java: "true" Déclenche l'instrumentation automatique OpenTelemetry pour le conteneur Java
      instrumentation.opentelemetry.io/container-names: "default" Spécifie le conteneur à instrumenter
      Variable d'environnement upstream_url Définit la chaîne d'appels : mocka -> mockb -> mockc

    3. Déployez les services. L'instrumentation automatique étant en place, les pods propagent automatiquement les en-têtes baggage tout au long de la chaîne d'appels.

      kubectl apply -f mock.yaml

    Étape 3 : Créer des règles de routage pour les voies de trafic

    Cette étape crée des règles de destination, un CRD ASMHeaderPropagation, des services virtuels et des règles de passerelle d'entrée. Ensemble, ces ressources acheminent les requêtes vers la version de service correcte en fonction de l'en-tête version propagé, avec un basculement vers v1 lorsqu'une version n'existe pas.

    Créer des règles de destination

    Les règles de destination définissent des sous-ensembles de services en fonction des étiquettes des pods. Tous les services ne disposent pas des trois versions ; ceci est intentionnel et illustre le comportement de basculement en mode permissif.

    Service Sous-ensembles disponibles
    mocka v1, v2, v3
    mockb v1, v3
    mockc v1, v2

    1. Créez un fichier dr-mock.yaml avec le contenu suivant.

      Afficher dr-mock.yaml

      apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: dr-mock-default-mocka
spec:
  host: mocka.default.svc.cluster.local
  subsets:
    - labels:
        version: v1
      name: v1
    - labels:
        version: v2
      name: v2
    - labels:
        version: v3
      name: v3
---
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: dr-mock-default-mockb
spec:
  host: mockb.default.svc.cluster.local
  subsets:
    - labels:
        version: v1
      name: v1
    - labels:
        version: v3
      name: v3
---
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: dr-mock-default-mockc
spec:
  host: mockc.default.svc.cluster.local
  subsets:
    - labels:
        version: v1
      name: v1
    - labels:
        version: v2
      name: v2

    2. Connectez-vous à l'instance ASM avec kubectl et appliquez les règles de destination :

      kubectl apply -f dr-mock.yaml

    Créer un CRD ASMHeaderPropagation

    Le CRD ASMHeaderPropagation indique à ASM quels en-têtes extraire du contexte baggage et propager tout au long de la chaîne d'appels. Dans cet exemple, l'en-tête version est extrait afin que les services en aval reçoivent le contexte de routage approprié.

    1. Créez un fichier propagation.yaml :

      Champ Description
      apiVersion istio.alibabacloud.com/v1beta1 -- Groupe d'API spécifique à ASM
      kind ASMHeaderPropagation -- CRD pour la propagation des en-têtes depuis le contexte baggage
      spec.headers Liste des noms d'en-têtes à extraire du contexte baggage et à propager en tant qu'en-têtes de requête 
      apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMHeaderPropagation
metadata:
  name: version-propagation
spec:
  headers:
    - version

    2. Connectez-vous à l'instance ASM avec kubectl et appliquez le CRD :

      kubectl apply -f propagation.yaml

    Créer des services virtuels

    Les services virtuels acheminent les requêtes vers le sous-ensemble correct en faisant correspondre l'en-tête version. Chaque règle inclut une cible fallback pointant vers v1 (la version de référence). En mode permissif, lorsqu'une requête cible une version inexistante (par exemple, mockb ne possède pas de v2), ASM achemine vers le sous-ensemble de secours au lieu de renvoyer une erreur.

    1. Créez un fichier vs-mock.yaml avec le contenu suivant.

      Afficher vs-mock.yaml

      apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: vs-mock-default-mocka
spec:
  hosts:
    - mocka.default.svc.cluster.local
  http:
    - match:
        - headers:
            version:
              exact: v1
      route:
        - destination:
            host: mocka.default.svc.cluster.local
            subset: v1
          fallback:
            target:
              host: mocka.default.svc.cluster.local
              subset: v1
    - match:
        - headers:
            version:
              exact: v2
      route:
        - destination:
            host: mocka.default.svc.cluster.local
            subset: v2
          fallback:
            target:
              host: mocka.default.svc.cluster.local
              subset: v1
    - match:
        - headers:
            version:
              exact: v3
      route:
        - destination:
            host: mocka.default.svc.cluster.local
            subset: v3
          fallback:
            target:
              host: mocka.default.svc.cluster.local
              subset: v1
---
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: vs-mock-default-mockb
spec:
  hosts:
    - mockb.default.svc.cluster.local
  http:
    - match:
        - headers:
            version:
              exact: v1
      route:
        - destination:
            host: mockb.default.svc.cluster.local
            subset: v1
          fallback:
            target:
              host: mockb.default.svc.cluster.local
              subset: v1
    - match:
        - headers:
            version:
              exact: v2
      route:
        - destination:
            host: mockb.default.svc.cluster.local
            subset: v2
          fallback:
            target:
              host: mockb.default.svc.cluster.local
              subset: v1
    - match:
        - headers:
            version:
              exact: v3
      route:
        - destination:
            host: mockb.default.svc.cluster.local
            subset: v3
          fallback:
            target:
              host: mockb.default.svc.cluster.local
              subset: v1
---
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: vs-mock-default-mockc
spec:
  hosts:
    - mockc.default.svc.cluster.local
  http:
    - match:
        - headers:
            version:
              exact: v1
      route:
        - destination:
            host: mockc.default.svc.cluster.local
            subset: v1
          fallback:
            target:
              host: mockc.default.svc.cluster.local
              subset: v1
    - match:
        - headers:
            version:
              exact: v2
      route:
        - destination:
            host: mockc.default.svc.cluster.local
            subset: v2
          fallback:
            target:
              host: mockc.default.svc.cluster.local
              subset: v1
    - match:
        - headers:
            version:
              exact: v3
      route:
        - destination:
            host: mockc.default.svc.cluster.local
            subset: v3
          fallback:
            target:
              host: mockc.default.svc.cluster.local
              subset: v1

      Le modèle de routage pour chaque service suit cette structure :

      # For each version match, specify a primary destination and a fallback
- match:
    - headers:
        version:
          exact: v2        # Match the propagated version header
  route:
    - destination:
        host: <service>.default.svc.cluster.local
        subset: v2         # Primary: route to matching version
      fallback:
        target:
          host: <service>.default.svc.cluster.local
          subset: v1       # Fallback: route to baseline when v2 has no healthy endpoints

    2. Connectez-vous à l'instance ASM avec kubectl et appliquez les services virtuels :

      kubectl apply -f vs-mock.yaml

    Créer des règles de passerelle d'entrée

    La passerelle d'entrée distribue le trafic entrant entre les versions de service par pondération et définit l'en-tête version sur chaque requête pour correspondre à la version cible.

    1. Créez un fichier gw-mock.yaml avec le contenu suivant.

      Afficher gw-mock.yaml

      apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: mockgw
  namespace: default
spec:
  selector:
    istio: ingressgateway
  servers:
    - hosts:
        - '*'
      port:
        name: http
        number: 80
        protocol: HTTP
---
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: swimlane-ingress-vs-weighted-mock
  namespace: default
spec:
  gateways:
    - default/mockgw
  hosts:
    - '*'
  http:
    - name: mock-weighted
      route:
        - destination:
            host: mocka.default.svc.cluster.local
            subset: v1
          headers:
            request:
              set:
                version: v1
          weight: 40
        - destination:
            host: mocka.default.svc.cluster.local
            subset: v2
          headers:
            request:
              set:
                version: v2
          weight: 30
        - destination:
            host: mocka.default.svc.cluster.local
            subset: v3
          headers:
            request:
              set:
                version: v3
          weight: 30

      Cette configuration distribue le trafic vers les versions v1, v2 et v3 de mocka selon un ratio de 40:30:30. Pour chaque requête, la passerelle définit l'en-tête version sur la version cible afin que les services en aval de la chaîne d'appels reçoivent le contexte de routage approprié grâce à la propagation baggage.

    2. Connectez-vous à l'instance ASM avec kubectl et appliquez les règles de passerelle :

      kubectl apply -f gw-mock.yaml

    Étape 4 : Vérifier le routage des voies de trafic

    1. Obtenez l'adresse IP publique de la passerelle d'entrée. Consultez Obtenir l'adresse IP de la passerelle d'entrée ASM.

    2. Définissez l'IP de la passerelle en tant que variable d'environnement. Remplacez <gateway-ip> par l'adresse IP réelle.

      export ASM_GATEWAY_IP=<gateway-ip>

    3. Envoyez des requêtes répétées pour observer la distribution du trafic. Exemple de sortie :

      for i in {1..100}; do curl http://${ASM_GATEWAY_IP}; echo ''; sleep 1; done
      -> mocka(version: v1, ip: 192.168.1.27)-> mockb(version: v1, ip: 192.168.1.30)-> mockc(version: v1, ip: 192.168.1.14)
-> mocka(version: v2, ip: 192.168.1.28)-> mockb(version: v1, ip: 192.168.1.30)-> mockc(version: v2, ip: 192.168.1.1)
-> mocka(version: v3, ip: 192.168.1.26)-> mockb(version: v3, ip: 192.168.1.29)-> mockc(version: v1, ip: 192.168.1.14)

    4. Vérifiez les résultats. La sortie confirme deux comportements : Distribution basée sur la pondération : le trafic est réparti entre v1, v2 et v3 selon un ratio d'environ 40:30:30. Basculement en mode permissif : lorsqu'une version n'existe pas pour un service, le trafic bascule vers v1 :

      • Voie v2 : mocka-v2 -> mockb-v1 (mockb-v2 n'existe pas, donc le trafic bascule vers v1) -> mockc-v2

      • Voie v3 : mocka-v3 -> mockb-v3 -> mockc-v1 (mockc-v3 n'existe pas, donc le trafic bascule vers v1)

      Voie mocka mockb mockc
      v1 v1 v1 v1
      v2 v2 v1 (pas de v2, basculement) v2
      v3 v3 v3 v1 (pas de v3, basculement)