:Personnaliser le RSS pour les ENI

Prérequis

• Le déploiement du RSS personnalisé s'effectue par phases. Il est disponible dans les régions suivantes :

  Nom de la région	ID de région
  Chine (Hong Kong)	cn-hongkong

• Seules certaines familles d'instances à files d'attente multiples prennent en charge le RSS personnalisé, notamment la famille d'instances à usage général g9i et la famille d'instances optimisées pour la mémoire r9i.

  Appelez l'opération API DescribeInstanceTypes pour vérifier la prise en charge. RssSupport=true indique que la fonctionnalité est prise en charge.

• L'image Alibaba Cloud Linux 3.2104 LTS 64 bits est recommandée.

  • Si vous utilisez d'autres images publiques, la version du noyau doit être 6,12 ou ultérieure.

  • Si vous utilisez la fonctionnalité de RSS personnalisé dans une application DPDK, la version de DPDK doit être 21,11 ou ultérieure.

Procédure d'activation ou de désactivation

Le RSS personnalisé est désactivé par défaut. Vous pouvez l'activer ou le désactiver lors de la création d'une ENI ou après sa création.

• Lors de l'appel à CreateNetworkInterface, définissez EnableRss dans EnhancedNetwork sur true ou false.

  Le RSS personnalisé prend effet après l'attachement de l'ENI à une instance.

• Appelez ModifyNetworkInterfaceAttribute et définissez EnableRss dans EnhancedNetwork sur true ou false. Après l'activation ou la désactivation, la modification prend effet lorsque l'ENI est rattachée :

  • Pour une ENI secondaire attachée à une instance, vous devez détacher l'ENI puis attacher l'ENI pour que la modification prenne effet.

  • Pour l'ENI principale, redémarrez l'instance pour que la modification prenne effet.

• Appelez DescribeNetworkInterfaceAttribute avec Attribute défini sur enhancedNetwork pour savoir si le RSS personnalisé est activé. EnableRSS=true signifie qu'il est activé ; false signifie qu'il est désactivé.

  Si le RSS n'a pas été modifié pour l'ENI, cette opération ne renvoie pas le paramètre EnableRSS, ce qui signifie que la fonctionnalité n'est pas activée.

Configurer la clé de hachage

Regénérez la clé de hachage RSS si le trafic est réparti de manière inégale (par exemple, si rx_packets de certaines files est nettement supérieur à celui d'autres files), ou pour empêcher les attaquants de déduire les modèles de trafic en effectuant une ingénierie inverse de la valeur de hachage.

1. Affichez la clé de hachage actuelle de l'ENI.

   Le pilote de l'ENI génère une clé de hachage par défaut de 40 octets lors du chargement de l'ENI.

   ethtool -x eth0

   

2. Générez une nouvelle clé aléatoire à l'aide d'OpenSSL.

   openssl rand -hex 40 | fold -w2 | paste -sd: -

3. Appliquez la nouvelle clé à l'ENI.

   Important

   Il s'agit d'un paramètre temporaire. Il devient invalide après le redémarrage de l'instance ou le rattachement de l'ENI. Le pilote de l'ENI initialise automatiquement une configuration par défaut aléatoire.

   ethtool -X eth0 hkey <hash key>

   Remplacez <hash key> par la nouvelle clé que vous avez générée à l'étape précédente.

4. Vérifiez que la nouvelle clé a pris effet.

   ethtool -x eth0

   La sortie indique que la nouvelle clé a pris effet :

   

Configurer la table d'indirection

Le mode de distribution de la table d'indirection RSS constitue le mécanisme central qui associe les valeurs de hachage à des files d'attente de réception spécifiques. Grâce à une table d'indirection prédéfinie, le résultat du calcul de hachage est converti en un index de file d'attente. Cette approche permet une répartition flexible du trafic sur plusieurs cœurs.

Les différents modes de distribution, tels que la distribution uniforme et la distribution pondérée, influencent directement la manière dont le trafic est réparti entre les cœurs CPU. Cela a un impact immédiat sur le débit du système, la latence, l'utilisation des ressources et les performances des services.

Choisissez un mode de distribution adapté à votre scénario.

• Mode de distribution uniforme : Les N premières files d'attente remplissent les compartiments de hachage de manière cyclique. Ce mode convient aux scénarios de forte concurrence générale.

  ethtool -X eth0 equal <Number of queues N>

  Si la valeur est définie sur 64, la table d'indirection est remplie cycliquement avec 0,1,2,...,63,0,1,2...63,.

  

• Distribution pondérée : Allouez les compartiments de hachage selon des ratios de poids. Cette méthode est adaptée aux scénarios présentant des priorités métier différenciées (par exemple, la file d'attente 0 traite le trafic en temps réel et la file d'attente 1 gère les tâches en arrière-plan) ou des performances CPU mixtes.

  ethtool -X eth0 weight <queue 0 weight> <queue 1 weight> ...

  Dans l'exemple suivant, la file d'attente 0 reçoit 60 % et la file d'attente 1 reçoit 40 % :

  Remarque

  S'il y a quatre files d'attente au total, mais que vous ne définissez des poids que pour deux d'entre elles, la table d'indirection générera uniquement des mappages pour les files d'attente 0 et 1.

  ethtool -X eth0 weight 6 4

  

• Distribution partielle des files d'attente : À partir d'une file d'attente spécifiée, utilisez des files d'attente consécutives pour remplir les compartiments de hachage de manière cyclique. Cette option est recommandée pour diriger le trafic vers une plage CPU spécifique, telle qu'un nœud NUMA.

  ethtool -X eth0 start <start queue> equal <number of queues>

  Dans l'exemple ci-dessous, les files d'attente 2 à 41 (40 files d'attente à partir de la file d'attente 2) remplissent les compartiments de hachage :

  ethtool -X eth0 start 2 equal 40

  

Prérequis

Achetez deux instances ECS avec les configurations suivantes :

• Instance ECS émettrice (10.0.0.252) : Une instance sur laquelle hping3 est installé pour générer du trafic avec différentes caractéristiques.

• Instance ECS réceptrice : Une instance dont le type prend en charge les files d'attente multiples pour les ENI, avec une ENI secondaire attachée (10.0.0.5) et le RSS personnalisé activé sur l'ENI secondaire eth1.

  Remarque

  • Cet exemple utilise quatre files d'attente pour les tests.

  • Pour éliminer l'impact du trafic de connexion SSH sur l'ENI principale, le RSS personnalisé est activé sur l'ENI secondaire eth1 pour les tests.

• Connectivité réseau : Les deux instances ECS se trouvent dans le même groupe de sécurité et peuvent communiquer entre elles via le réseau interne.

Procédure

1. Connectez-vous à l'instance ECS réceptrice, vérifiez la configuration RSS de l'ENI secondaire et confirmez la distribution de trafic attendue. Consultez la section Afficher la configuration RSS d'une ENI.

   

2. Connectez-vous à l'instance ECS émettrice et installez hping3.

   yum install -y hping3

3. Sur l'instance ECS réceptrice, surveillez les compteurs de paquets des files d'attente en temps réel.

   watch -n 1 "ethtool -S eth1 | grep rx[0,1,2,3]_packets"

   Remplacez la configuration du numéro de file d'attente par la configuration réelle de l'ENI réceptrice.

4. Connectez-vous à l'instance ECS émettrice et simulez différents modèles de trafic.

   • Scénario 1 : Envoyez 10 000 paquets SYN à haute vitesse vers l'adresse IP du récepteur avec des ports de destination aléatoires. Cela garantit que le hachage du trafic est dispersé et permet de vérifier l'équilibrage du hachage.

     sudo hping3 10.0.0.5 -S -a 10.0.0.252 --rand-dest -p 0 --baseport 10000 -c 10000 -i u100 -I eth0

     • rand-dest : Port de destination aléatoire

     • -p 0 : Utilisé conjointement avec rand-dest

     • --baseport 10000 : Valeur de départ pour le port source.

     • -c 10000 : Envoie 10 000 paquets

     • -i u100 : Spécifie un intervalle de 100 microsecondes entre les paquets pour un envoi à haute vitesse.

     • -I eth0 : Utilisé conjointement avec rand-dest pour spécifier l'interface réseau de l'émetteur

     Sur l'instance réceptrice, les compteurs de paquets des quatre files d'attente doivent augmenter de manière uniforme :

     

   • Scénario 2 : Envoyez du trafic avec une adresse IP source et un port fixes. Ce test permet de vérifier si le même trafic est mappé sur la même file d'attente et de confirmer la cohérence du hachage.

     La commande suivante envoie 10 000 paquets TCP SYN vers la cible 10.0.0.5:80, avec l'IP source fixée sur 10.0.0.252 et le port source fixé sur 12345.

     sudo hping3 10.0.0.5 -S -p 80 -c 10000 -s 12345 -a 10.0.0.252 --keep -i u100

     • La valeur d'index de hachage est calculée en fonction du script RSS. Le trafic devrait être traité par la file d'attente 0 :

       

     • Résultat d'observation réel sur l'instance ECS réceptrice (10.0.0.5) :

       

5. Si la distribution du trafic ne répond pas aux attentes (par exemple, si une file d'attente présente une charge significativement plus élevée), optimisez la configuration en ajustant la clé de hachage ou en configurant la table d'indirection.

Installer et configurer DPDK sur une instance ECS

Configurer RSS à l'aide de testpmd

Testpmd est un outil de test DPDK permettant de vérifier les fonctionnalités du pilote ENI et de déboguer les applications du plan de données. Consultez Testpmd Runtime Functions.

1. Se connecter à une instance via VNC.

2. Démarrez l'outil de test de transmission de paquets DPDK testpmd.

   dpdk-testpmd -a 0000:00:05.0 --socket-mem 1024 -- -i --portmask=0x1 --rxq=64 --txq=64  --forward-mode=rxonly

   • -a 0000:00:05.0 : attache l'ENI à l'adresse PCI 0000:00:05.0 à DPDK. Exécutez dpdk-devbind.py --status pour trouver l'adresse PCI.

   • --socket-mem 1024 : pré-alloue 1 024 Mo de mémoire de pages géantes par nœud NUMA.

   • -i : démarre le mode de ligne de commande interactif pour ajuster dynamiquement la configuration et afficher les statistiques. Saisissez quit pour quitter.

   • --portmask=0x1 : active le masque de port 0x1 (binaire 0001), en utilisant uniquement la première ENI (adresse PCI 0000:00:05.0).

     • Chaque bit binaire de portmask correspond à un port (0x1 active le port 0, 0x3 active les ports 0 et 1).

     • Un seul périphérique (0000:00:05.0) étant attaché, son numéro de port DPDK est 0.

   • --rxq=64 / --txq=64 : définit le nombre de files d'attente RX et TX par port à 64 pour le traitement multi-files. Remplacez 64 par le nombre de files d'attente ENI réel.

   • --forward-mode=rxonly : mode réception uniquement (les paquets sont reçus et ignorés). Utilisé pour tester les performances de réception de l'ENI ou pour la capture de paquets.

3. Accédez au mode interactif et interrogez la configuration RSS actuelle.

   • Interroger les informations de configuration de hachage : show port info <port_id>

     port_id : le port. Dans cet exemple, le port 0.

     Cliquez pour afficher l'exemple de sortie

     

   • Interroger la clé de hachage : show port <port_id> rss-hash key

     

   • Interroger la configuration de la table d'indirection : show port <port_id> rss reta <size> <mask0, mask1...>

     • size : le nombre d'entrées de la table d'indirection à interroger. La valeur est fixée à 128.

     • mask0, mask1 : les masques utilisés pour filtrer la plage d'index de hachage à afficher, spécifiés au format hexadécimal. Par exemple, mask0=0xff indique que les entrées pour les index de hachage 0 à 7 sont affichées.

       La taille de la table d'indirection est fixée à 128. Deux masques sont requis, chacun couvrant 64 blocs d'index. Exécutez show port 0 rss reta 128 (0xffffffffffffffff,0xffffffffffffffff) pour renvoyer les 128 mappages index-vers-file d'attente :

       Cliquez pour afficher l'exemple de sortie

       

4. Configurez RSS selon vos besoins.

   • Configurez une nouvelle clé de hachage.

     Générer une nouvelle clé aléatoire avec OpenSSL.

     port config <port_id> rss-hash-key (ipv4|ipv4-frag|\
                       ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|\
                       ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|\
                       ipv6-other|l2-payload|ipv6-ex|ipv6-tcp-ex|\
                       ipv6-udp-ex <string of hex digits \
                       (variable length, NIC dependent)>)

     Pour TCP sur IPv4, exécutez port config 0 rss-hash-key ipv4 6D5A56DA255B0EC24167253D43A38FB0D0CA2BCBAE7B30B477CB2DA38030F20C6A42B73BBEAC01FC pour configurer la clé de hachage et vérifier :

     

   • Configurez la table d'indirection RSS pour mapper les valeurs de hachage aux files d'attente spécifiées.

     port config all rss reta <hash,queue>,<hash,queue>..

     Effectuez la configuration en fonction du nombre réel de files d'attente :

     • hash : l'index de hachage. La plage dépend de la taille de la table d'indirection (par exemple, 0-63 pour 64 entrées).

     • queue : le numéro de la file d'attente de réception cible.

Appliquer RSS dans l3fwd

Pour activer RSS dans une application DPDK, implémentez la configuration de la clé de hachage et de la table d'indirection dans votre code. L'exemple suivant utilise L3FWD.

L3FWD (Layer 3 Forwarding) est un exemple d'application DPDK qui illustre le routage de paquets basé sur IP haute performance utilisant le zéro copie et les pilotes en mode polling (PMD).

1. Modifiez le code source L3FWD dans DPDK (examples/l3fwd/main.c).

   • Modifiez la section d'initialisation du port static struct rte_eth_conf port_conf dans l'exemple de code L3FWD.

     Cliquez pour afficher la modification du code

     #define RSS_HASH_KEY_LENGTH 	40
     #define RSS_RETA_SIZE 			128
     
     static uint8_t hash_key[RSS_HASH_KEY_LENGTH] = {
         0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
         0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
         0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
         0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A, 0x6D, 0x5A,
     };
     
     static struct rte_eth_conf port_conf = {
     	.rxmode = {
     		.mq_mode = RTE_ETH_MQ_RX_RSS,
     		.offloads = RTE_ETH_RX_OFFLOAD_UDP_CKSUM | RTE_ETH_RX_OFFLOAD_TCP_CKSUM,
     	},
     	.rx_adv_conf = {
     		.rss_conf = {
     			.rss_key = hash_key,
     			.rss_hf = RTE_ETH_RSS_IP,
     			.rss_key_len = RSS_HASH_KEY_LENGTH,
     		},
     	},
     	.txmode = {
     		.mq_mode = RTE_ETH_MQ_TX_NONE,
     	},
     };

   • Ajoutez des fonctions pour configurer la table d'indirection de hachage et la clé de hachage.

     Cliquez pour afficher le code ajouté

     /**
      * @brief Configure the RSS RETA (Redirection Table Array) for a given port.
      * 
      * @param port_id The ID of the port to configure.
      */
     
     void configure_rss_reta(uint16_t port_id) {
         struct rte_eth_rss_reta_entry64 reta_conf[RSS_RETA_SIZE / RTE_ETH_RETA_GROUP_SIZE];
         unsigned int i;
         uint16_t reta_size;
     	uint16_t nb_queues;
     	struct rte_eth_dev_info dev_info;
     
     	if (port_id >= RTE_MAX_ETHPORTS) {
             printf("port_id %d exceed max eth ports\n", port_id);
             return;
         }
     
         if (rte_eth_dev_info_get(port_id, &dev_info) != 0) {
     		printf("Failed to get device info for port %d\n", port_id);
     		return;
     	}
     
         reta_size = dev_info.reta_size;
         if (reta_size == 0) {
             printf("Device does not support RSS RETA configuration.\n");
             return;
         }
     
     	nb_queues = dev_info.nb_rx_queues;
     	if (nb_queues == 0) {
     		printf("port %d RX queues = 0\n", port_id);
     		return;
     	}
     
         // Initialize RETA table
         memset(reta_conf, 0, sizeof(reta_conf));
         for (i = 0; i < reta_size; i++) {
             reta_conf[i / RTE_ETH_RETA_GROUP_SIZE].reta[i % RTE_ETH_RETA_GROUP_SIZE] = (uint16_t)(i % nb_queues);
         }
     
         // Configure RETA table mask
         for (i = 0; i < reta_size; i += RTE_ETH_RETA_GROUP_SIZE) {
             reta_conf[i / RTE_ETH_RETA_GROUP_SIZE].mask = UINT64_MAX;
         }
     
     	// Update RSS RETA table to device
     	if (rte_eth_dev_rss_reta_update(port_id, reta_conf, reta_size) != 0) {
     		printf("Failed to update RSS RETA table for port %u\n", port_id);
     		return;
     	}
     }
     
     /**
      * @brief Configure the RSS hash key for a given port.
      * 
      * @param port_id The ID of the port to configure.
      */
     void configure_rss_hash_key(uint16_t port_id) {
         struct rte_eth_rss_conf rss_conf;
     
     	if (port_id >= RTE_MAX_ETHPORTS) {
             printf("port_id %d exceed max eth ports\n", port_id);
             return;
         }
     
         memset(&rss_conf, 0, sizeof(rss_conf));
         rss_conf.rss_key = hash_key;
         rss_conf.rss_key_len = sizeof(hash_key);
         
         // Update RSS hash key to device
         if (rte_eth_dev_rss_hash_update(port_id, &rss_conf) != 0) {
             printf("Failed to update RSS hash key for port %u\n", port_id);
     		return;
         }
     }

   • Après rte_eth_dev_start, appelez les nouvelles fonctions de configuration.

     Cliquez pour afficher le code d'appel dans main

     @@ -1472,12 +1576,15 @@ main(int argc, char **argv)
                     /* Start device */
     		ret = rte_eth_dev_start(portid);
     		if (ret < 0)
     			rte_exit(EXIT_FAILURE,
     				"rte_eth_dev_start: err=%d, port=%d\n",
     				ret, portid);
     				
     		configure_rss_reta(portid);
     		configure_rss_hash_key(portid);

2. Recompilez L3FWD après avoir modifié le code source.

   cd ~/dpdk-stable-22.11.3/
   rm -rf build
   # Initialize the build directory and configure project options, specifying to build the l3fwd Layer 3 forwarding example.
   meson setup -Dexamples=l3fwd build
   cd build
   # Compile.
   ninja
   # Install the compiled files to the system directory.
   sudo ninja install
   # Update the system's shared library cache.
   sudo ldconfig

3. Spécifiez les liaisons port-file-cœur et démarrez L3FWD.

   cd ~/dpdk-stable-22.11.3/build/examples
   ./dpdk-l3fwd --legacy-mem -a 0000:00:05.0 --socket-mem 1024 -- -p 0x1 --config="(PORT_ID, QUEUE_ID, LCORE_ID), (PORT_ID, QUEUE_ID, LCORE_ID), ..." --parse-ptype

   • --config : chaque triplet spécifie :

     • PORT_ID : l'ID du port (commence à 0).

     • QUEUE_ID : l'ID de la file d'attente de réception (commence à 0).

     • LCORE_ID : l'ID du cœur logique (commence à 0).

   • L'exemple suivant utilise deux cœurs et deux files d'attente :

     ./dpdk-l3fwd --legacy-mem -a 0000:00:05.0 --socket-mem 1024 -- -p 0x1 --config="(0,0,0),(0,1,1)"  --parse-ptype

     • Le premier triplet (0,0,0) : le cœur logique 0 (lcore0) traite la file d'attente 0 du port 0.

     • Le deuxième triplet (0,1,1) : le cœur logique 1 (lcore1) traite la file d'attente 1 du port 0.

     

L'exemple suivant utilise la configuration RSS d'une ENI avec 64 files d'attente :

Calculez la valeur de hachage RSS à l'aide du script avec les informations de quintuplet suivantes (modifiez les valeurs si nécessaire).

• Adresse IP de destination (-r) : 10.0.0.1, qui est l'adresse IP de l'ENI de l'instance réceptrice configurée avec RSS.

• Adresse IP source (-t) : 10.0.0.251, qui est l'adresse IP de l'ENI de l'expéditeur.

• Port de destination (-R) : 26000

• Port source (-T) : 18042

• Clé de hachage : obtenez-la à partir de la configuration de la table d'indirection RSS.

python ali_ecs_rss_calc.py -r 10.0.0.1 -t 10.0.0.251 -R 26000 -T 18042 -k 69:e8:7c:56:bf:03:9f:63:d7:c5:e5:96:b3:00:36:93:02:8c:d2:8f:cc:a9:00:65:fd:c8:94:71:5f:fd:c8:de:7a:30:a9:73:b3:33:0c:c6

Le script calcule le hachage à l'aide de l'algorithme toeplitz. Dans le résultat ci-dessous, le système utilise une longueur de table d'indirection de 128. Un index de hachage de 117 signifie que le paquet est mappé à la file d'attente à l'index 117.

Consultez la table d'indirection : l'index 117 est mappé à la file d'attente 53, donc les paquets sont traités par la file d'attente 53.