Accelerate pod-to-pod network performance in ASM with eRDMA - Alibaba Cloud Service Mesh

Alibaba Cloud Linux 3 fournit Shared Memory Communication (SMC), une pile de protocole réseau du noyau haute performance compatible avec la couche socket. Cette technologie utilise Remote Direct Memory Access (RDMA) pour optimiser de manière transparente les performances réseau des applications TCP. Toutefois, lorsque vous utilisez SMC pour optimiser les performances réseau dans un environnement ECS natif, vous devez maintenir avec soin la liste blanche et les configurations SMC dans les espaces de noms réseau des conteneurs afin d'éviter qu'SMC ne rétrograde de manière inattendue vers TCP. ASM offre un environnement contrôlé (au sein du cluster) pour l'optimisation SMC. Il optimise automatiquement le trafic entre les pods du service mesh, ce qui vous dispense de gérer des configurations SMC spécifiques.

Prérequis

Le cluster est ajouté à l'instance ASM.

Limites

Les nœuds doivent être des instances ECS prenant en charge eRDMA. Pour plus d'informations, consultez la rubrique Activer eRDMA pour les instances de niveau entreprise.
Les nœuds doivent exécuter Alibaba Cloud Linux 3. Pour plus d'informations, consultez la rubrique Alibaba Cloud Linux 3.
L'instance ASM doit être en version 1.23 ou ultérieure. Pour savoir comment mettre à jour une instance, consultez la rubrique Mettre à jour une instance ASM.
Le cluster ACK doit utiliser le plug-in réseau Terway. Pour plus d'informations, consultez la rubrique Utiliser le plug-in réseau Terway.
Le cluster ACK doit autoriser l'accès Internet au serveur API. Pour plus d'informations, consultez la rubrique Contrôler l'accès Internet au serveur API.

Procédure

Étape 1 : Initialiser l'environnement des nœuds

SMC utilise l'interface RDMA élastique pour accélérer les performances réseau. Avant d'activer SMC, initialisez les nœuds.

Assurez-vous que la version du noyau d'Alibaba Cloud Linux 3 est 5.10.134-17.3 ou ultérieure. Pour savoir comment mettre à jour le noyau, consultez la rubrique Modifier la version du noyau.
Installez le composant erdma-controller sur les nœuds et activez l'accélération transparente pour SMC-R. Pour plus d'informations, consultez la rubrique Utiliser eRDMA pour accélérer la mise en réseau des conteneurs.

Étape 2 : Déployer l'application de test

Activez l'injection automatique de proxy sidecar pour le namespace default utilisé pour les tests. Pour plus d'informations, consultez la section Activer l'injection automatique de sidecar.

Créez un fichier nommé fortioserver.yaml avec le contenu suivant.

fortioserver.yaml

---
apiVersion: v1
kind: Service
metadata:
  name: fortioserver
spec:
  ports:
  - name: http-echo
    port: 8080
    protocol: TCP
  - name: tcp-echoa
    port: 8078
    protocol: TCP
  - name: grpc-ping
    port: 8079
    protocol: TCP
  selector:
    app: fortioserver
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: fortioserver
  name: fortioserver
spec:
  replicas: 1
  selector:
    matchLabels:
      app: fortioserver
  template:
    metadata:
      labels:
        app: fortioserver
      annotations:
        sidecar.istio.io/inject: "true"
        sidecar.istio.io/proxyCPULimit: 2000m
        proxy.istio.io/config: |
          concurrency: 2 
    spec:
      shareProcessNamespace: true
      containers:
      - name: captured
        image: fortio/fortio:latest_release
        ports:
        - containerPort: 8080
          protocol: TCP
        - containerPort: 8078
          protocol: TCP
        - containerPort: 8079
          protocol: TCP
      - name: anolis
        securityContext:
          runAsUser: 0
        image: openanolis/anolisos:latest
        args:
        - /bin/sleep
        - 3650d
---
apiVersion: v1
kind: Service
metadata:
  annotations:
      service.beta.kubernetes.io/alibaba-cloud-loadbalancer-health-check-switch: "off"
  name: fortioclient
spec:
  ports:
  - name: http-report
    port: 8080
    protocol: TCP
  selector:
    app: fortioclient
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: fortioclient
  name: fortioclient
spec:
  replicas: 1
  selector:
    matchLabels:
      app: fortioclient
  template:
    metadata:
      annotations:
        sidecar.istio.io/inject: "true"
        sidecar.istio.io/proxyCPULimit: 4000m
        proxy.istio.io/config: |
           concurrency: 4
      labels:
        app: fortioclient
    spec:
      shareProcessNamespace: true
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values:
                - fortioserver
            topologyKey: "kubernetes.io/hostname"
      containers:
      - name: captured
        volumeMounts:
        - name: shared-data
          mountPath: /var/lib/fortio
        image: fortio/fortio:latest_release
        ports:
        - containerPort: 8080
          protocol: TCP
      - name: anolis
        securityContext:
          runAsUser: 0
        image: openanolis/anolisos:latest
        args:
        - /bin/sleep
        - 3650d
      volumes:
      - name: shared-data
        emptyDir: {}

À l'aide du fichier kubeconfig du cluster ACK, exécutez la commande suivante pour déployer l'application de test :
```
kubectl apply -f fortioserver.yaml
```

Exécutez la commande suivante pour vérifier l'état de l'application de test.

kubectl get pods | grep fortio

Résultat attendu :

NAME                            READY   STATUS    RESTARTS      
fortioclient-8569b98544-9qqbj   3/3     Running   0
fortioserver-7cd5c46c49-mwbtq   3/3     Running   0

Ce résultat confirme que les deux applications sont en cours d'exécution.

Étape 3 : Exécuter un test de référence

Une fois l'application Fortio démarrée, elle écoute sur le port 8080. Vous pouvez accéder à ce port pour ouvrir la console web Fortio. Pour générer du trafic de test, utilisez le transfert de port (port-forwarding) afin de mapper le port du service fortioclient sur votre machine locale. Vous pourrez alors ouvrir la console Fortio.

Utilisez le kubeconfig du cluster ACK pour exécuter la commande suivante afin de transférer le port 8080 du service fortioclient vers le port 8080 de votre machine locale.
```
kubectl port-forward service/fortioclient 8080:8080
```

Dans votre navigateur, accédez à http://localhost:8080/fortio pour ouvrir la console client Fortio et modifier les paramètres de test.

Après avoir configuré les paramètres, cliquez sur Start en bas de la page de la console Fortio pour commencer le test de charge.

Modifiez les paramètres de la page comme indiqué dans le tableau suivant.

Paramètre	Valeur
URL	http://fortioserver:8080/echo
QPS	100000
Durée	30s
Threads/connexions simultanées	64
Payload	Saisissez la chaîne de 128 octets suivante : xhsyL4ELNoUUbC3WEyvaz0qoHcNYUh0j2YHJTpltJueyXlSgf7xkGqc5RcSJBtqUENNjVHNnGXmoMyILWsrZL1O2uordH6nLE7fY6h5TfTJCZtff3Wib8YgzASha8T8g

Une fois la configuration terminée, cliquez sur Start en bas de la page pour lancer le test. Attendez que la barre de progression se termine.

Une fois le test terminé, les résultats s'affichent sur la page. La figure ci-dessous est fournie à titre indicatif uniquement. Les résultats réels peuvent varier selon votre environnement.

Le graphique des résultats affiche la latence des requêtes sur l'axe des x et le nombre de requêtes terminées sur l'axe des y. La distribution des barres illustre la répartition de la latence, tandis que la courbe violette indique le nombre de requêtes achevées dans des plages de temps de réponse spécifiques. Le graphique répertorie également les données de latence P50, P75, P90, P99 et P99,9. Après avoir obtenu ces données de référence, vous activerez SMC pour mesurer l'amélioration des performances apportée par l'accélération.

Étape 4 : Activer l'accélération SMC

Utilisez le kubeconfig du service mesh pour modifier la configuration du mesh. Ajoutez smcEnabled: true pour activer la fonctionnalité d'accélération SMC.

$ kubectl edit asmmeshconfig
apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMMeshConfig
metadata:
  name: default
spec:
  ambientConfiguration:
    redirectMode: ""
    waypoint: {}
    ztunnel: {}
  cniConfiguration:
    enabled: true
    repair: {}
  smcEnabled: true

Utilisez le kubeconfig du cluster ACK pour exécuter les commandes suivantes afin de modifier les déploiements fortioserver et fortioclient et ajouter une annotation aux pods.

Après avoir activé l'accélération pour l'instance ASM, vous devez également l'activer pour les charges de travail. Pour ce faire, ajoutez l'annotation smc.asm.alibabacloud.com/enabled: "true" aux pods. Vous devez activer l'accélération pour les charges de travail aux deux extrémités de la communication que vous souhaitez optimiser.
1. Modifiez la définition du déploiement fortioclient.
```
$ kubectl edit deployment fortioclient
apiVersion: apps/v1
kind: Deployment
metadata:
  ......
  name: fortioclient
spec:
  ......
  template:
    metadata:
      ......
      annotations:
        smc.asm.alibabacloud.com/enabled: "true"
        
```
2. Modifiez la définition du déploiement fortioserver.
```
$ kubectl edit deployment fortioserver
apiVersion: apps/v1
kind: Deployment
metadata:
  ......
  name: fortioserver
spec:
  ......
  template:
    metadata:
      ......
      annotations:
        smc.asm.alibabacloud.com/enabled: "true"
        
```

Étape 5 : Exécuter le test accéléré

La modification du déploiement entraîne le redémarrage des charges de travail. Rétablissez le transfert de port pour le service fortioclient comme décrit à l'étape Étape 3, puis relancez le test. Attendez la fin du test et consultez les résultats.

Une comparaison avec les données de référence montre que l'activation de l'accélération SMC dans ASM réduit la latence et augmente considérablement le QPS.

FAQ

Pourquoi l'accès à certains services de base de données reste-t-il bloqué et échoue-t-il à établir une connexion après l'activation de SMC ?

Ce problème survient car le trafic vers les services de base de données passe souvent par un équilibreur de charge. Certaines implémentations d'équilibreurs de charge ne respectent pas strictement les normes des options TCP et gèrent incorrectement l'option TCP de type 254 spécifiée dans le protocole SMC. Cela provoque des échecs de connexion et empêche l'accès au service.

Pour diagnostiquer ce problème, suivez les étapes ci-dessous :
1. Installez la boîte à outils aliyun-smc-extensions sur le nœud :
```
sudo yum install -y aliyun-smc-extensions
```
2. Utilisez aliyunsmc-check pour vérifier le lien de communication vers l'URL de destination :
```
aliyunsmc-check syn_check --url <url>
```
  La commande aliyunsmc-check vérifie la répétition des options TCP, les conflits et les problèmes de longueur excessive sur le chemin d'accès à l'URL de destination. Voici un exemple de sortie :
```
The check results mean:
PASS: pass the test or meet the requirement.
SKIP: encounter some problems when running the check.
FAIL: test failed or requirements are not met.
XXXX: information, e.g. smcr_tcp2smc config, ipv6_disable config,.
Check: syn_check
Begin to run syn checks. Please make sure scapy have been installed(python3 -m pip install scapy).
        Name              Result                          Desc                                       result info
---------------------- -------------------- ---------------------------------------------------- -------------------------------------------
 syn_option_replay          PASS             check whether smc option is replayed
 syn_option_conflict        PASS             check whether smc option kind is conflict
 syn_option_long            PASS             check whether syn options is overly long
```
Si la vérification confirme une gestion non standard des options TCP sur le chemin d'accès au service, désactivez l'accélération SMC pour le pod qui accède à ce service.