Configure global rate limiting for an ingress gateway - Alibaba Cloud Service Mesh

Pour gérer les pics de trafic, la surcharge des services, l'épuisement des ressources ou les attaques malveillantes, configurez une limitation de débit globale sur des routes de passerelle spécifiques. Cela permet un contrôle précis du trafic afin de protéger les services backend, de réduire les coûts et d'améliorer l'expérience utilisateur.

Prérequis

Vous avez ajouté un cluster ACK managé à une instance ASM de version 1.18.0.131 ou ultérieure. Pour plus d'informations, consultez la rubrique Ajouter un cluster à une instance ASM.
Vous avez activé l'injection automatique pour le namespace default dans le cluster Kubernetes. Pour plus d'informations, consultez la rubrique Activer l'injection automatique du proxy sidecar.
Vous avez créé une passerelle d'entrée nommée ingressgateway, avec le port 80 activé. Pour plus d'informations, consultez la rubrique Créer une passerelle d'entrée.

Avant de commencer

Déployer le service de limitation de débit

Créez un fichier nommé ratelimit-svc.yaml avec le contenu suivant.

Ratelimit-svc.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: redis
---
apiVersion: v1
kind: Service
metadata:
  name: redis
  labels:
    app: redis
spec:
  ports:
  - name: redis
    port: 6379
  selector:
    app: redis
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
   metadata:
      labels:
        app: redis
        sidecar.istio.io/inject: "false"
   spec:
      containers:
      - image: registry-cn-hangzhou.ack.aliyuncs.com/dev/redis:alpine
        imagePullPolicy: Always
        name: redis
        ports:
        - name: redis
          containerPort: 6379
      restartPolicy: Always
      serviceAccountName: redis
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: ratelimit-config
data:
  config.yaml: |
    {}
---
apiVersion: v1
kind: Service
metadata:
  name: ratelimit
  labels:
    app: ratelimit
spec:
  ports:
  - name: http-port
    port: 8080
    targetPort: 8080
    protocol: TCP
  - name: grpc-port
    port: 8081
    targetPort: 8081
    protocol: TCP
  - name: http-debug
    port: 6070
    targetPort: 6070
    protocol: TCP
  selector:
    app: ratelimit
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ratelimit
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ratelimit
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: ratelimit
        sidecar.istio.io/inject: "false"
    spec:
      containers:
        # Latest image from https://hub.docker.com/r/envoyproxy/ratelimit/tags
      - image: registry-cn-hangzhou.ack.aliyuncs.com/dev/envoyproxy/ratelimit:e059638d
        imagePullPolicy: Always
        name: ratelimit
        command: ["/bin/ratelimit"]
        env:
        - name: LOG_LEVEL
          value: debug
        - name: REDIS_SOCKET_TYPE
          value: tcp
        - name: REDIS_URL
          value: redis.default.svc.cluster.local:6379
        - name: USE_STATSD
          value: "false"
        - name: RUNTIME_ROOT
          value: /data
        - name: RUNTIME_SUBDIRECTORY
          value: ratelimit
        - name: RUNTIME_WATCH_ROOT
          value: "false"
        - name: RUNTIME_IGNOREDOTFILES
          value: "true"
        ports:
        - containerPort: 8080
        - containerPort: 8081
        - containerPort: 6070
        volumeMounts:
        - name: config-volume
          # $RUNTIME_ROOT/$RUNTIME_SUBDIRECTORY/$RUNTIME_APPDIRECTORY/config.yaml
          mountPath: /data/ratelimit/config
      volumes:
      - name: config-volume
        configMap:
          name: ratelimit-config

Dans l'environnement kubeconfig de votre cluster ACK, exécutez la commande suivante pour créer le service de limitation de débit ainsi que le service Redis requis.

Pour savoir comment se connecter à un cluster à l'aide de kubectl, consultez la rubrique Obtenir le fichier kubeconfig d'un cluster et utiliser kubectl pour s'y connecter.
```
kubectl apply -f ratelimit-svc.yaml
```

Déployer l'exemple d'application Bookinfo

Téléchargez le manifeste YAML de l'application Bookinfo (bookinfo.yaml) depuis le dépôt du projet Istio sur GitHub.

Dans l'environnement kubeconfig de votre cluster ACK, exécutez la commande suivante pour déployer l'application Bookinfo dans le cluster associé à l'instance ASM.
```
kubectl apply -f bookinfo.yaml
```

Créez le fichier bookinfo-gateway.yaml avec le contenu suivant.

Bookinfo-gateway.yaml

apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: bookinfo-gateway
  namespace: default
spec:
  selector:
    istio: ingressgateway
  servers:
    - hosts:
        - bf2.example.com
      port:
        name: http
        number: 80
        protocol: http
---
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: bookinfo
  namespace: default
spec:
  gateways:
    - bookinfo-gateway
  hosts:
    - bf2.example.com
  http:
    - match:
        - uri:
            exact: /productpage
        - uri:
            prefix: /static
        - uri:
            exact: /login
        - uri:
            exact: /logout
        - uri:
            prefix: /api/v1/products
      name: productpage-route-name1
      route:
        - destination:
            host: productpage
            port:
              number: 9080

Dans l'environnement kubeconfig de votre instance ASM, exécutez la commande suivante pour créer une règle de routage pour l'application Bookinfo sur la passerelle d'entrée.

La règle de routage est nommée productpage-route-name1 et correspond aux requêtes pour le domaine bf2.example.com. Pour savoir comment se connecter à une instance ASM à l'aide de kubectl, consultez la rubrique Accéder aux ressources Istio à l'aide de kubectl du plan de contrôle.
```
kubectl apply -f bookinfo-gateway.yaml
```

Scénario 1 : Configurer une limitation de débit globale sur une route de passerelle

Ce scénario montre comment configurer une règle de limitation de débit pour la route productpage-route-name1, qui s'applique à la combinaison nom de domaine et port bf2.example.com:80. productpage-route-name1 est une entrée de route dans le VirtualService bookinfo que vous avez créé dans la section Avant de commencer. Cette route correspond aux requêtes pour les chemins tels que /productpage, /static, /login et /logout, et les transfère vers le service productpage. Une fois la règle configurée, la limitation de débit spécifiée s'applique à toutes les requêtes pour ces chemins.

Créez un fichier nommé global-ratelimit-gw.yaml avec le contenu suivant.

global-ratelimit-gw.yaml

apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  workloadSelector:
    labels:
      istio: ingressgateway
  rateLimitService: # Configuration for the rate limit service deployed in the prerequisites.
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  isGateway: true
  configs:
  - name: productpage
    limit:
      unit: MINUTE
      quota: 1
    match:
      vhost:
        name: bf2.example.com # This name must match the domain name in the VirtualService.
        port: 80 # This port must match the ASM gateway port.
        route:
          name_match: productpage-route-name1  # This name must match the name of the route in the VirtualService.

Le tableau suivant décrit les champs clés. Pour plus de détails, consultez la rubrique Référence CRD ASMGlobalRateLimiter.

Paramètre	Description
`workloadSelector`	Sélectionne la charge de travail pour la limitation de débit. Dans cet exemple, la limitation de débit globale s'applique à la charge de travail de la passerelle d'entrée, sélectionnée par le libellé `istio: ingressgateway`.
`isGateway`	Indique si la règle s'applique à une passerelle. Définissez ce paramètre sur `true` pour cet exemple.
`rateLimitService`	Spécifie le nom de domaine, le port et le délai de connexion pour le service de limitation de débit. Sur la base du service déployé dans la section Avant de commencer, la configuration est la suivante : `host: ratelimit.default.svc.cluster.local port: 8081 timeout: seconds: 5`
`limit`	Les paramètres de limitation de débit. Le champ `unit` spécifie l'intervalle de temps, et `quota` spécifie le nombre de requêtes autorisées par intervalle. Dans cet exemple, `unit` est défini sur `MINUTE` et `quota` est défini sur `1`. Cela n'autorise qu'une seule requête par minute pour la route correspondante. Le système rejette les requêtes suivantes.
`vhost`	Les conditions de correspondance pour le nom de domaine et la route. Le champ `name` doit correspondre au nom de domaine dans le VirtualService, et le champ `port` doit correspondre au port de la passerelle d'entrée. Le nom de route spécifié dans `route.name_match` doit correspondre au nom de l'entrée de route dans le VirtualService.

Dans l'environnement kubeconfig de votre instance ASM, exécutez la commande suivante pour créer la règle de limitation de débit globale pour la route productpage-route-name1 sur la passerelle.
```
kubectl apply -f global-ratelimit-gw.yaml
```

Exécutez la commande suivante pour obtenir la configuration de la règle de limitation de débit globale réconciliée.

kubectl get asmglobalratelimiter global-test -n istio-system -o yaml

Sortie attendue

apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  configs:
  - limit:
      quota: 1
      unit: MINUTE
    match:
      vhost:
        name: bf2.example.com
        port: 80
        route:
          name_match: productpage-route-name1
    name: productpage
  isGateway: true
  rateLimitService:
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  workloadSelector:
    labels:
      app: istio-ingressgateway
status:
  config.yaml: |
    descriptors:
    - key: generic_key
      rate_limit:
        requests_per_unit: 1
        unit: MINUTE
      value: RateLimit[global-test.istio-system]-Id[597770312]
    domain: ratelimit.default.svc.cluster.local
  message: ok
  status: successful

Collez le contenu de config.yaml issu du champ status de la ressource ASMGlobalRateLimiter obtenue à l'étape précédente dans le fichier ratelimit-config.yaml pour générer la configuration du service de limitation de débit global.

Le contenu textuel du champ config.yaml situé sous le champ status de ASMGlobalRateLimiter doit être collé tel quel dans le champ config.yaml du champ data de la ConfigMap.
ratelimit-config.yaml
apiVersion: v1 kind: ConfigMap metadata: name: ratelimit-config data: config.yaml: | descriptors: - key: generic_key rate_limit: requests_per_unit: 1 unit: MINUTE value: RateLimit[global-test.istio-system]-Id[597770312] domain: ratelimit.default.svc.cluster.local
Dans l'environnement kubeconfig de votre cluster ACK, exécutez la commande suivante pour appliquer la nouvelle configuration au service de limitation de débit global.
```
kubectl apply -f ratelimit-config.yaml
```
Exécutez la commande suivante deux fois de suite pour accéder à l'application Bookinfo.

Remplacez <ASM_GATEWAY_IP> par l'adresse IP de votre passerelle ASM. Pour savoir comment obtenir l'adresse IP de la passerelle, consultez la rubrique Obtenir l'adresse IP d'une passerelle d'entrée.
```
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
```
La sortie attendue pour la deuxième requête est la suivante :
```
< HTTP/1.1 429 Too Many Requests
< x-envoy-ratelimited: true
< x-ratelimit-limit: 1, 1;w=60
< x-ratelimit-remaining: 0
< x-ratelimit-reset: 48
< date: Thu, 26 Oct 2023 04:10:11 GMT
< server: istio-envoy
< content-length: 0
< 
* Connection #0 to host 116.62.XXX.XXX left intact
```
La limitation de débit globale est configurée pour n'autoriser qu'une seule requête par minute. Lorsque vous envoyez deux requêtes consécutives, la première aboutit, mais la passerelle rejette la seconde avec un statut 429 Too Many Requests. Cela confirme que la limitation de débit globale pour la route est effective.

Scénario 2 : Limitation de débit globale sur une passerelle d'entrée

Ce scénario explique comment configurer une règle de limitation de débit globale pour la combinaison domaine et port bf2.example.com:80. Une fois la règle appliquée, toutes les requêtes envoyées à cette combinaison domaine et port sont soumises à la limite de débit spécifiée.

Créez un fichier nommé global-ratelimit-gw.yaml avec le contenu suivant.

Global-ratelimit-gw.yaml

apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  workloadSelector:
    labels:
      istio: ingressgateway
  rateLimitService: # Configuration for the rate limiting service deployed in the preparation step.
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  isGateway: true
  configs:
  - name: productpage
    limit:
      unit: MINUTE
      quota: 1
    match:
      vhost:
        name: bf2.example.com # This name must match the domain in the VirtualService.
        port: 80 # This port must match the ASM gateway port.

Le tableau suivant décrit les champs clés. Pour plus d'informations, consultez la section Référence CRD ASMGlobalRateLimiter.

Paramètre	Description
`workloadSelector`	Spécifie la charge de travail cible pour la règle de limitation de débit. Dans cet exemple, la règle cible la charge de travail de la passerelle d'entrée, identifiée par le libellé `istio: ingressgateway`.
`isGateway`	Indique si la règle s'applique à une passerelle. Définissez ce paramètre sur `true` pour cet exemple.
`rateLimitService`	Spécifie le domaine, le port et le délai d'expiration de la connexion pour le service de limitation de débit. Sur la base du service déployé lors de l'étape de Préparation, la configuration est la suivante : `host: ratelimit.default.svc.cluster.local port: 8081 timeout: seconds: 5`
`limit`	Définit la limite de débit. Le champ `unit` spécifie l'intervalle de temps et le champ `quota` spécifie le nombre de requêtes autorisées par intervalle. Dans cet exemple, `unit` est défini sur `MINUTE` et `quota` sur `1`. Ce paramètre n'autorise qu'une seule requête par minute pour la route correspondante. Les requêtes suivantes envoyées durant cette minute sont rejetées.
`vhost`	Spécifie le domaine et la route à faire correspondre. Les champs `name` et `port` doivent correspondre respectivement au domaine du VirtualService et au port de la passerelle d'entrée.

Dans l'environnement kubeconfig de votre instance ASM, exécutez la commande suivante pour appliquer la règle de limitation de débit globale à la route productpage sur la passerelle.
```
kubectl apply -f global-ratelimit-gw.yaml
```

Exécutez la commande suivante pour obtenir la configuration de la règle de limitation de débit globale réconciliée.

kubectl get asmglobalratelimiter global-test -n istio-system -o yaml

Résultat attendu

apiVersion: istio.alibabacloud.com/v1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  configs:
  - limit:
      quota: 1
      unit: MINUTE
    match:
      vhost:
        name: bf2.example.com
        port: 80
    name: productpage
  isGateway: true
  rateLimitService:
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  workloadSelector:
    labels:
      istio: ingressgateway
status:
  config.yaml: |
    descriptors:
    - key: generic_key
      rate_limit:
        requests_per_unit: 1
        unit: MINUTE
      value: RateLimit[global-test.istio-system]-Id[2100900480]
    domain: ratelimit.default.svc.cluster.local
  message: ok
  status: successful

Copiez le contenu de la clé config.yaml du champ status dans la sortie précédente, puis collez-le dans un fichier nommé ratelimit-config.yaml pour configurer le service de limitation de débit global.

Le contenu sous forme de chaîne du champ config.yaml situé dans le champ status de l'ASMGlobalRateLimiter doit être collé tel quel dans le champ config.yaml du même nom, au sein du champ data du ConfigMap.
Ratelimit-config.yaml
apiVersion: v1 kind: ConfigMap metadata: name: ratelimit-config data: config.yaml: | descriptors: - key: generic_key rate_limit: requests_per_unit: 1 unit: MINUTE value: RateLimit[global-test.istio-system]-Id[2100900480] domain: ratelimit.default.svc.cluster.local
Dans l'environnement kubeconfig de votre cluster ACK, exécutez la commande suivante pour mettre à jour la configuration du service de limitation de débit global.
```
kubectl apply -f ratelimit-config.yaml
```
Exécutez la commande suivante deux fois de suite pour accéder à l'application Bookinfo.

Remplacez <ASM_GATEWAY_IP> par l'adresse IP de votre passerelle ASM. Pour savoir comment obtenir l'adresse IP de la passerelle, consultez la section Obtenir l'adresse IP d'une passerelle d'entrée.
```
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
```
Le résultat attendu pour la deuxième requête est le suivant :
```
< HTTP/1.1 429 Too Many Requests
< x-envoy-ratelimited: true
< x-ratelimit-limit: 1, 1;w=60
< x-ratelimit-remaining: 0
< x-ratelimit-reset: 48
< date: Thu, 26 Oct 2023 04:10:11 GMT
< server: istio-envoy
< content-length: 0
< 
* Connection #0 to host 116.62.XXX.XXX left intact
```
La règle de limitation de débit globale restreint l'accès à la combinaison domaine et port bf2.example.com:80 à une requête par minute. Lorsque vous envoyez deux requêtes consécutives, la première aboutit, mais la seconde est rejetée. Cela confirme que la règle de limitation de débit sur la passerelle d'entrée fonctionne correctement.

Cas d'utilisation 3 : Limitation de débit conditionnelle sur une route de passerelle

Remarque

Ce cas d'utilisation nécessite une instance ASM de version 1.19.0 ou ultérieure. Pour les instructions de mise à jour, consultez la section Mettre à jour une instance ASM.

Configurez une règle de limitation de débit pour la route productpage-route-name1 sur le domaine et le port bf2.example.com:80. La règle s'applique uniquement aux requêtes contenant l'en-tête de requête ratelimit: "true" et le paramètre de requête ratelimit=enabled. Les autres requêtes sur cette route ne sont pas affectées par la règle de limitation de débit. La route correspond aux requêtes pour des chemins tels que /productpage, /static, /login et /logout, et transfère les requêtes correspondantes vers le service productpage. Une fois la règle de limitation de débit configurée, les requêtes envoyées à ces chemins et répondant aux conditions spécifiées seront limitées en débit.

Créez un fichier nommé global-ratelimit-gw.yaml avec le contenu suivant.

global-ratelimit-gw.yaml

apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  workloadSelector:
    labels:
      app: istio-ingressgateway
  rateLimitService:
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  isGateway: true
  configs:
  - name: productpage
    limit:
      unit: SECOND
      quota: 100000
    match:
      vhost:
        name: bf2.example.com
        port: 80
        route:
          name_match: productpage-route-name1  # This name must match the route name in the virtual service.
    limit_overrides:
    - request_match:
        header_match:
        - name: ratelimit
          exact_match: "true"
        query_match:
        - name: ratelimit
          exact_match: "enabled"
      limit:
        unit: MINUTE
        quota: 1

Le tableau suivant décrit les champs clés. Pour plus d'informations, consultez la section Référence CRD ASMGlobalRateLimiter.

Paramètre	Description
`workloadSelector`	Spécifie les charges de travail soumises à la limitation de débit. Dans cet exemple, la limitation de débit globale s'applique à la passerelle d'entrée et est définie sur `istio: ingressgateway`.
`isGateway`	Indique si cela s'applique à la passerelle. Dans cet exemple, la valeur est définie sur `true`.
`rateLimitService`	Spécifie le nom de domaine, le port et le délai d'expiration de la connexion pour le service de limitation de débit. Sur la base du service déployé lors de l'étape de Préparation, la configuration est la suivante : `host: ratelimit.default.svc.cluster.local port: 8081 timeout: seconds: 5`
`limit`	Définit les paramètres de base de limitation de débit pour la route du service virtuel. Le champ `unit` spécifie l'intervalle de temps et `quota` spécifie le nombre de requêtes autorisées par intervalle. Cet exemple définit `unit` sur `SECOND` et `quota` sur `100000`, ce qui autorise 100 000 requêtes par seconde. Cette limite élevée désactive efficacement la limitation de débit pour les requêtes qui ne correspondent pas à une substitution plus spécifique, garantissant ainsi qu'elles ne soient pas limitées.
`vhost`	Spécifie les conditions de correspondance pour le domaine et la route. Les champs `name` et `port` doivent correspondre respectivement au domaine du service virtuel et au port de la passerelle d'entrée. Le nom de la route dans `route.name_match` doit correspondre au nom de la route dans le service virtuel.
`limit_overrides`	Remplace la limite de débit par défaut. Utilisez ce champ pour appliquer une limite de débit plus spécifique à certaines requêtes. Dans cet exemple : Sous `limit_overrides`, le champ `request_match` fait correspondre les requêtes contenant à la fois l'en-tête de requête `ratelimit: "true"` et le paramètre de requête `ratelimit=enabled`. Dans le champ `limit` de `limit_overrides`, définir `unit` sur `MINUTE` et `quota` sur `1` limite les requêtes répondant aux conditions spécifiées par `request_match` à une par minute.

Dans l'environnement kubeconfig de l'instance ASM correspondante, exécutez la commande suivante pour créer une règle de limitation de débit globale pour la route productpage-route-name1 sur la passerelle.
```
kubectl apply -f global-ratelimit-gw.yaml
```

Exécutez la commande suivante pour obtenir la configuration réconciliée de la règle de limitation de débit globale.

kubectl get asmglobalratelimiter global-test -n istio-system -o yaml

Résultat attendu

apiVersion: istio.alibabacloud.com/v1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  configs:
  - limit:
      quota: 100000
      unit: SECOND
    limit_overrides:
    - limit:
        quota: 1
        unit: MINUTE
      request_match:
        header_match:
        - exact_match: "true"
          name: ratelimit
        query_match:
        - exact_match: enabled
          name: ratelimit
    match:
      vhost:
        name: bf2.example.com
        port: 80
        route:
          name_match: productpage-route-name1
    name: productpage
  isGateway: true
  rateLimitService:
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  workloadSelector:
    labels:
      app: istio-ingressgateway
status:
  config.yaml: |
    descriptors:
    - descriptors:
      - descriptors:
        - key: query_match
          rate_limit:
            requests_per_unit: 1
            unit: MINUTE
          value: RateLimit[global-test.istio-system]-Id[1102463266]
        key: header_match
        value: RateLimit[global-test.istio-system]-Id[1102463266]
      key: generic_key
      rate_limit:
        requests_per_unit: 100000
        unit: SECOND
      value: RateLimit[global-test.istio-system]-Id[1102463266]
    domain: ratelimit.default.svc.cluster.local
  message: ok
  status: successful

Collez le contenu de config.yaml issu du champ status de la ressource ASMGlobalRateLimiter (à partir du résultat attendu de l'étape précédente) dans le fichier ratelimit-config.yaml pour générer la configuration du service de limitation de débit global.

Le contenu sous forme de chaîne du champ status situé sous le champ config.yaml de ASMGlobalRateLimiter doit être collé tel quel dans le champ config.yaml du même nom, sous le champ data du ConfigMap.

ratelimit-config.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: ratelimit-config
data:
  config.yaml: |
    descriptors:
    - descriptors:
      - descriptors:
        - key: query_match
          rate_limit:
            requests_per_unit: 1
            unit: MINUTE
          value: RateLimit[global-test.istio-system]-Id[1102463266]
        key: header_match
        value: RateLimit[global-test.istio-system]-Id[1102463266]
      key: generic_key
      rate_limit:
        requests_per_unit: 100000
        unit: SECOND
      value: RateLimit[global-test.istio-system]-Id[1102463266]
    domain: ratelimit.default.svc.cluster.local

Depuis votre environnement kubeconfig pour le cluster ACK, exécutez la commande suivante pour mettre à jour la configuration du service de limitation de débit global dans le cluster.
```
kubectl apply -f ratelimit-config.yaml
```
Exécutez la commande suivante deux fois de suite pour accéder à l'application Bookinfo.

Remplacez <ASM_GATEWAY_IP> par l'adresse IP de votre passerelle. Pour savoir comment obtenir l'adresse IP de la passerelle, consultez la section Obtenir l'adresse IP d'une passerelle d'entrée.
```
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
```
Le résultat attendu pour la deuxième requête adressée à l'application Bookinfo est le suivant :
```
< HTTP/1.1 429 Too Many Requests
< x-envoy-ratelimited: true
< x-ratelimit-limit: 1, 1;w=60
< x-ratelimit-remaining: 0
< x-ratelimit-reset: 48
< date: Thu, 26 Oct 2023 04:10:11 GMT
< server: istio-envoy
< content-length: 0
< 
* Connection #0 to host 116.62.XXX.XXX left intact
```
Dans la configuration de limitation de débit globale, les requêtes adressées à l'application bookinfo sont limitées à une par minute si elles contiennent l'en-tête de requête ratelimit: "true" et le paramètre de requête ratelimit=enabled. Lorsque vous effectuez deux requêtes consécutives vers l'application bookinfo avec cet en-tête et ce paramètre de requête, vous constatez que la première requête aboutit et que la seconde est limitée en débit, ce qui indique que la configuration de limitation de débit globale pour la correspondance de requêtes spécifiques sur la passerelle d'entrée est réussie.
Exécutez la commande suivante pour accéder à nouveau à l'application bookinfo sans l'en-tête de requête ratelimit: "true" ni le paramètre de requête ratelimit=enabled.
```
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
```
La sortie montre que l'application Bookinfo est accessible avec succès et qu'aucun code d'état 429 n'est renvoyé. Cela confirme que la règle de limitation de débit n'affecte pas les autres requêtes sur la route.

Scénario 4 : Configurer la limitation basée sur l'adresse IP pour une route de service virtuel

Remarque

Ce scénario nécessite une instance ASM version 1.19.0 ou ultérieure. Pour les instructions de mise à niveau, consultez Mettre à jour une instance ASM.
Pour configurer la limitation de débit pour des adresses IP client spécifiques sur une passerelle d'entrée ASM, vous devez d'abord vous assurer que la stratégie de trafic externe de la passerelle d'entrée est définie sur Local. Pour savoir comment créer une passerelle d'entrée et connaître ses options de configuration, consultez Créer une passerelle d'entrée.
Vous pouvez trouver l'adresse IP client des requêtes adressées à la passerelle dans le champ downstream_remote_address du journal d'accès de la passerelle. Dans cet exemple, configurez la règle en utilisant l'adresse IP client que vous souhaitez limiter.

Ce scénario montre comment configurer une règle de limitation de débit pour la route de service virtuel productpage-route-name1, associée à la combinaison domaine et port bf2.example.com:80. La règle est conçue pour s'appliquer uniquement aux requêtes provenant d'adresses IP client spécifiques, sans affecter les autres requêtes sur la même route.

Créez un fichier nommé global-ratelimit-gw.yaml avec le contenu suivant.

global-ratelimit-gw.yaml

apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  workloadSelector:
    labels:
      app: istio-ingressgateway
  rateLimitService:
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  isGateway: true
  configs:
  - name: productpage
    limit:
      unit: SECOND
      quota: 100000
    match:
      vhost:
        name: bf2.example.com
        port: 80
        route:
          name_match: productpage-route-name1  # This name must match the route name in the virtual service.
    limit_overrides:
    - request_match:
        remote_address:
          address: xxx.xxx.xxx.xxx # The client IP address.
          v4_prefix_mask_len: xx # The subnet mask for the client IP range.
      limit:
        unit: MINUTE
        quota: 1

Le tableau suivant décrit les champs clés. Pour plus de détails sur ces champs, consultez Référence CRD ASMGlobalRateLimiter.

Paramètre	Description
`workloadSelector`	Sélectionne la charge de travail à laquelle la limitation de débit s'applique. Cet exemple applique la limitation de débit globale à la charge de travail de la passerelle d'entrée, sélectionnée à l'aide du libellé `app: istio-ingressgateway`.
`isGateway`	Indique si la règle s'applique à une passerelle. Dans cet exemple, la valeur est définie sur `true`.
`rateLimitService`	Le domaine, le port et le délai d'expiration de la connexion pour le service de limitation de débit. Selon le service de limitation de débit déployé dans les prérequis, la configuration est la suivante : `host: ratelimit.default.svc.cluster.local port: 8081 timeout: seconds: 5`
`limit`	Les paramètres de base de limitation de débit pour la route de service virtuel. Le champ `unit` spécifie l'intervalle de temps, et `quota` spécifie le nombre de requêtes autorisées par intervalle. Cet exemple définit `unit` sur `SECOND` et `quota` sur `100000`, ce qui autorise 100 000 requêtes par seconde. Cette limite élevée désactive efficacement la limitation de débit pour les requêtes qui ne correspondent pas à une substitution spécifique.
`vhost`	Les conditions de correspondance pour le domaine et la route. Les champs `name` et `port` doivent correspondre respectivement au domaine du service virtuel et au port de la passerelle d'entrée. Le nom de route spécifié dans `route.name_match` doit correspondre au nom de la route dans le service virtuel.
`limit_overrides`	Définit un seuil de limitation de débit plus spécifique pour certaines requêtes. Dans cet exemple : Le champ `request_match` fait correspondre les requêtes en fonction de l'adresse IP source du client à l'aide de `remote_address.address`. Vous pouvez également spécifier une plage d'adresses IP facultative en définissant une longueur de masque de sous-réseau dans le champ `remote_address.v4_prefix_mask_len`. Dans le champ `limit_overrides`, le champ `limit` est configuré avec `unit` défini sur `MINUTE` et `quota` défini sur `1`, ce qui signifie que pour les requêtes correspondant aux conditions spécifiées par `request_match`, une seule requête est autorisée par minute.

À l'aide du fichier kubeconfig de votre instance ASM, exécutez la commande suivante pour créer la règle de limitation de débit globale pour la route productpage-route-name1 sur la passerelle d'entrée.
```
kubectl apply -f global-ratelimit-gw.yaml
```

Exécutez la commande suivante pour récupérer la configuration réconciliée de la règle de limitation de débit globale.

kubectl get asmglobalratelimiter global-test -n istio-system -o yaml

Sortie attendue

apiVersion: istio.alibabacloud.com/v1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  configs:
  - limit:
      quota: 100000
      unit: SECOND
    limit_overrides:
    - limit:
        quota: 1
        unit: MINUTE
      request_match:
        remote_address:
          address: 106.11.XX.XX
          v4_prefix_mask_len: 24
    match:
      vhost:
        name: bf2.example.com
        port: 80
        route:
          name_match: productpage-route-name1
    name: productpage
  isGateway: true
  rateLimitService:
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  workloadSelector:
    labels:
      app: istio-ingressgateway
status:
  config.yaml: |
    descriptors:
    - descriptors:
      - key: masked_remote_address
        rate_limit:
          requests_per_unit: 1
          unit: MINUTE
        value: xxxxxx
      key: generic_key
      rate_limit:
        requests_per_unit: 100000
        unit: SECOND
      value: RateLimit[global-test.istio-system]-Id[1102463266]
    domain: ratelimit.default.svc.cluster.local
  message: ok
  status: successful

Copiez le contenu de config.yaml depuis le champ status de la sortie de la ressource ASMGlobalRateLimiter à l'étape précédente, et collez-le dans ratelimit-config.yaml pour configurer le service de limitation de débit global.

Le contenu textuel du champ config.yaml, situé sous le champ status de la ressource ASMGlobalRateLimiter, doit être collé tel quel dans le champ config.yaml sous le champ data du ConfigMap.

ratelimit-config.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: ratelimit-config
data:
  config.yaml: |
    descriptors:
    - descriptors:
      - key: masked_remote_address
        rate_limit:
          requests_per_unit: 1
          unit: MINUTE
        value: xxxxxx
      key: generic_key
      rate_limit:
        requests_per_unit: 100000
        unit: SECOND
      value: RateLimit[global-test.istio-system]-Id[1102463266]
    domain: ratelimit.default.svc.cluster.local

À l'aide du fichier kubeconfig de votre cluster ACK, exécutez la commande suivante pour mettre à jour la configuration du service de limitation de débit global.
```
kubectl apply -f ratelimit-config.yaml
```
Depuis un client disposant de l'adresse IP spécifiée, exécutez les commandes suivantes deux fois de suite pour accéder à l'application bookinfo.

Remplacez <ASM_GATEWAY_IP> par votre adresse IP de passerelle réelle. Pour savoir comment obtenir l'adresse IP de la passerelle, consultez Obtenir l'adresse IP d'une passerelle d'entrée.
```
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
```
La sortie attendue pour la deuxième requête est la suivante :
```
< HTTP/1.1 429 Too Many Requests
< x-envoy-ratelimited: true
< x-ratelimit-limit: 1, 1;w=60
< x-ratelimit-remaining: 0
< x-ratelimit-reset: 48
< date: Thu, 26 Oct 2023 04:10:11 GMT
< server: istio-envoy
< content-length: 0
< 
* Connection #0 to host 116.62.XXX.XXX left intact
```
La configuration de limitation de débit globale limite les requêtes provenant de l'adresse IP (ou de la plage) spécifiée à une requête par minute. Lorsque vous envoyez deux requêtes consécutives depuis un client disposant de cette adresse IP, la première aboutit, mais la seconde est limitée. Cela confirme que la règle de limitation de débit globale pour la passerelle d'entrée fonctionne comme prévu.
Depuis un client disposant d'une adresse IP différente, exécutez la commande suivante pour accéder à nouveau à l'application bookinfo.
```
curl -H 'host: bf2.example.com'  http://<ASM_GATEWAY_IP>/productpage -v
```
La requête aboutit et aucun code d'état HTTP 429 n'est renvoyé. Cela indique que les autres requêtes sur la route ne sont pas affectées par la règle de limitation de débit globale.

Scénario 5 : Configurer la limitation de débit par adresse IP client sur une route

Remarque

Ce scénario nécessite une instance ASM version 1.25.0 ou ultérieure. Pour les instructions de mise à niveau, consultez Mettre à niveau une instance ASM.
Dans ce scénario, vous devez définir la stratégie de trafic externe de la passerelle d'entrée ASM sur Local. Cela permet de conserver l'adresse IP client d'origine. Pour plus d'informations sur la création d'une passerelle d'entrée et ses options de configuration, consultez Créer une passerelle d'entrée.
Vous pouvez trouver l'adresse IP client d'une requête adressée à la passerelle dans le champ downstream_remote_address du journal d'accès. Dans cet exemple, la règle de limitation de débit est configurée en fonction de l'adresse IP client réelle.

Dans ce scénario, vous allez configurer une règle de limitation de débit pour la route de service virtuel productpage-route-name1 à l'adresse bf2.example.com:80 afin de limiter chaque adresse IP client unique à une requête par minute.

Créez un fichier nommé global-ratelimit-gw.yaml.

apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMGlobalRateLimiter
metadata:
  name: global-test
  namespace: istio-system
spec:
  workloadSelector:
    labels:
      app: istio-ingressgateway
  rateLimitService:
    host: ratelimit.default.svc.cluster.local
    port: 8081
    timeout:
      seconds: 5
  isGateway: true
  configs:
  - name: productpage
    limit:
      unit: SECOND
      quota: 100000
    target_services:
    - name: bookinfo
      namespace: default
      kind: VirtualService
      port: 80
      section_name: productpage-route-name1
    limit_overrides:
    - request_match:
        remote_address:
          distinct: true # Apply rate limiting to each client IP address individually.
      limit:
        unit: MINUTE
        quota: 1

Le tableau suivant décrit les champs clés. Pour plus d'informations sur les champs, consultez Référence CRD ASMGlobalRateLimiter.

Paramètre	Description
`workloadSelector`	Sélectionne la charge de travail à laquelle la règle de limitation de débit s'applique. Dans cet exemple, la limitation de débit globale est appliquée à la passerelle d'entrée, sélectionnée par le libellé `app: istio-ingressgateway`.
`isGateway`	Indique si la règle s'applique à une passerelle. Dans cet exemple, la valeur est définie sur `true`.
`rateLimitService`	Les paramètres de domaine, de port et de délai d'expiration de la connexion pour le service de limitation de débit. Selon le service de limitation de débit déployé dans la section Prérequis, la configuration est la suivante : `host: ratelimit.default.svc.cluster.local port: 8081 timeout: seconds: 5`
`limit`	Les paramètres de limitation de débit qui s'appliquent à la route de service virtuel. Il comprend les champs suivants : `unit` : L'intervalle de temps pour les vérifications de limitation de débit. `quota` : Le nombre de requêtes autorisées par intervalle de temps. Dans cet exemple, `unit` est défini sur `SECOND` et `quota` est défini sur `100000`. Cette limite élevée désactive efficacement la limitation de débit pour les requêtes non couvertes par une substitution spécifique, garantissant que les autres trafics restent inchangés.
`limit_overrides`	Remplace la limite de débit par défaut pour des requêtes spécifiques. Dans cet exemple : Le champ `request_match` spécifie les conditions de la substitution : Le champ `remote_address` fait correspondre les requêtes par adresse IP client. Le paramètre `distinct` défini sur `true` applique cette limite à chaque client individuellement. `remote_addess.v4_prefix_mask_len` correspond au masque de sous-réseau pour la plage d'adresses IP source du client (facultatif). Le champ `limit` dans `limit_overrides` définit `unit` sur `MINUTE` et `quota` sur `1`. Cela limite les requêtes correspondant aux conditions `request_match` à une par minute.
`target_services`	Spécifie la route de service virtuel à laquelle la règle de limitation de débit s'applique. `kind` spécifie que la règle cible un service virtuel. `namespace` et `name` spécifient le namespace et le nom du service virtuel. `port` restreint la règle au trafic sur le port 80. `section_name` spécifie que la règle s'applique à la route nommée `productpage-route-name1` au sein du service virtuel.

Appliquez la règle de limitation de débit globale.
```
kubectl apply -f global-ratelimit-gw.yaml
```

Consultez la configuration réconciliée de la règle de limitation de débit globale.

kubectl get asmglobalratelimiter global-test -n istio-system -o yaml |grep status: -A 50

Sortie attendue :

status:
  config.yaml: |
    descriptors:
    - descriptors:
      - key: remote_address
        rate_limit:
          requests_per_unit: 1
          unit: MINUTE
      key: generic_key
      rate_limit:
        requests_per_unit: 100000
        unit: SECOND
      value: RateLimit[global-test.istio-system]-Id[537612397]
    domain: ratelimit.default.svc.cluster.local
  message: ok
  status: successful

Modifiez le ConfigMap ratelimit-config de la section Prérequis, en remplaçant la valeur de la clé config.yaml par la sortie d'état de l'étape précédente.

kubectl edit ConfigMap ratelimit-config

Contenu mis à jour :

apiVersion: v1
kind: ConfigMap
metadata:
  name: ratelimit-config
data:
  config.yaml: |
    descriptors:
    - descriptors:
      - key: remote_address
        rate_limit:
          requests_per_unit: 1
          unit: MINUTE
      key: generic_key
      rate_limit:
        requests_per_unit: 100000
        unit: SECOND
      value: RateLimit[global-test.istio-system]-Id[537612397]
    domain: ratelimit.default.svc.cluster.local

Depuis un client, accédez deux fois de suite à l'application bookinfo.

export GATEWAY_URL=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
curl -H 'host: bf2.example.com' http://$GATEWAY_URL:80/productpage -v
curl -H 'host: bf2.example.com' http://$GATEWAY_URL:80/productpage -v

Sortie attendue pour la deuxième requête :

< HTTP/1.1 429 Too Many Requests
< x-envoy-ratelimited: true
< x-ratelimit-limit: 1, 1;w=60
< x-ratelimit-remaining: 0
< x-ratelimit-reset: 48
< date: Thu, 26 Jul 2025 04:10:11 GMT
< server: istio-envoy
< content-length: 0
< 
* Connection #0 to host 116.62.XXX.XXX left intact

La sortie montre que la deuxième requête est limitée, confirmant que la règle de limitation de débit globale pour la passerelle d'entrée est correctement configurée.

Documents connexes

Utilisez la limitation de débit locale ASM pour une méthode économe en ressources qui ne dépend pas d'un service de limitation de débit. Pour les instructions, consultez Configurer la limitation de débit locale dans ASM.
Utilisez la limitation de débit globale pour limiter le trafic entrant d'un service d'application avec un sidecar injecté. Pour les instructions, consultez Configurer la limitation de débit globale pour le trafic entrant d'un service d'application.