Tester la performance de votre réseau avec Iperf

Ensuite, sur une des deux machines de test, nous allons lancer le serveur grâce à la commande suivante :

# iperf -s

Sur le client, il ne reste plus qu'à lancer le client en précisant l'adresse du serveur :

# iperf -c <adresse IP du serveur>

Vous devriez avoir le rapport qui s'affiche après dix secondes de test.

------------------------------------------------------------
Client connecting to 192.168.29.1, TCP port 5001
TCP window size: 65.0 KByte (default)
------------------------------------------------------------
[ 3] local 192.168.29.157 port 50675 connected with 192.168.29.1 port 5001
[ ID] Interval Transfer Bandwidth
[ 3] 0.0-10.0 sec 110 MBytes 92.6 Mbits/sec

Avec les options par défaut, le test est fait en TCP sur une durée de dix secondes. Sur un réseau local vous devriez donc obtenir une valeur proche de la capacité de commutation de vos équipements (par exemple 92.6 Mbit/sec qui est une valeur proche de 100 Mbit/sec).

Pour afficher des rapports intermédiaires (par exemple toutes les secondes), il suffit d'ajouter l'option (-i 1) sur le client et/ou le serveur.

# iperf -s -i 1
------------------------------------------------------------
Server listening on TCP port 5001
TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 6] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 50692
[ 6] 0.0- 1.0 sec 10.1 MBytes 84.8 Mbits/sec
[ 6] 1.0- 2.0 sec 11.1 MBytes 93.0 Mbits/sec
[ 6] 2.0- 3.0 sec 11.2 MBytes 93.8 Mbits/sec
[ 6] 3.0- 4.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 4.0- 5.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 5.0- 6.0 sec 11.2 MBytes 93.8 Mbits/sec
[ 6] 6.0- 7.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 7.0- 8.0 sec 11.2 MBytes 93.8 Mbits/sec
[ 6] 8.0- 9.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 9.0-10.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 0.0-10.0 sec 111 MBytes 92.9 Mbits/sec

Une autre option de base est (-t) qui permet de fixer au niveau du client le temps du test (en secondes). Par exemple pour effectuer un test pendant une minute :

# ipert -c <adresse IP du serveur> -t 60

Iperf permet également de générer un trafic de type UDP (-u). Dans ce cas-là, il faut penser à fixer la bande passante cible (contrairement au protocole TCP, UDP ne peut pas faire de contrôle de flux). On utilise pour cela l'argument -b au niveau du client :

Sur le serveur :

# iperf -s -u

Sur le client :

# ipert -c <adresse IP du serveur> -u -b 512k

Ce couple de commandes va générer un test avec un flux réseau UDP de 512 kbit/sec.

Comme vous pouvez le voir, Iperf est également un bon outil de génération de flux. Je l'ai déjà testé pour générer un flux UDP constant pendant plusieurs jours.

Iperf peut fonctionner en mode multicast (-B). Il faut le lancer de la manière suivante :

Sur le serveur :

# iperf -s -u -B 226.10.11.12

Sur le/les clients :

# iperf -c 226.10.11.12 -u -T 32 -b 512k

Ce couple de commandes génère un flux multicast UDP (sur l'adresse 226.10.11.12, avec un TTL de 32) de 512 kbit/sec.

Nouveau : les paragraphes suivants donneront une description des options avancées de Iperf.

Et bien entendu, il reste la fameuse commande :

# iperf --help

…pour avoir la liste complète des options. Si vous avez des questions, n'hésitez pas !

Attention, cette méthode mesure la bande passante au moment du test. Ce dernier dure par défaut dix secondes et utilise le protocole TCP sur le port 5001.

Sur la machine S : # iperf -s
Sur la machine C : # iperf -c IPS

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Server listening on TCP port 5001TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 6] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 54334
[ 6] 0.0-10.0 sec 112 MBytes 93.7 Mbits/sec

On génère ici un flux en utilisant le protocole UDP et en fixant la bande passante à 1 Megabit par seconde. Le test dure par défaut dix secondes.

Il est possible de choisir l'unité de mesure de débit avec l'option -b et en collant les lettres suivantes aux débits :

• b : bits par seconde ;
• k : kilobits par seconde ;
• m : mégabits par seconde ;
• g : gigabits par seconde.

Pour un débit en octets par seconde, il faut utiliser ces lettres en majuscules)

Sur la machine S : # iperf -s -u
Sur la machine C : # iperf -c IPS -u -b 4m

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Server listening on UDP port 5001
Receiving 1470 byte datagrams
UDP buffer size: 41.1 KByte (default)
------------------------------------------------------------
[ 5] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 49617
[ 5] 0.0-10.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ 3403 (0%)

Il peut être utile de générer un flux réseau plus long pour tester par exemple une liaison Internet pendant les heures d'utilisation. Nous allons donc utiliser l'option -t pour fixer la durée du test précédent à dix heures (10*3600=36000 secondes).

Sur la machine S : # iperf -s -u
Sur la machine C : # iperf -c IPS -u -b 4m -t 36000

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Server listening on UDP port 5001
Receiving 1470 byte datagrams
UDP buffer size: 41.1 KByte (default)
------------------------------------------------------------
[ 5] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 49617
[ 5] 0.0-36000.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ 999403 (0%)

Il est également possible d'ajouter l'option -i 3600 pour avoir un rapport intermédiaire toutes les heures (1*3600=3600 secondes).

Sur la machine S : # iperf -s -u
Sur la machine C : # iperf -c IPS -u -b 4m -t 3600

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Server listening on UDP port 5001
Receiving 1470 byte datagrams
UDP buffer size: 41.1 KByte (default)
------------------------------------------------------------
[ 5] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 49617
[ 5] 0.0-3600.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ - (0%)
[ 5] 3600.0-7200.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ - (0%)...
[ 5] 0.0-36000.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ 999403 (0%)

Il est parfois utile de générer plusieurs flux UDP simultanément pour simuler une application. IPerf permet cela grâce à l'option -P et en donnant le nombre de flux à générer. L'exemple suivant génère quatre flux TCP entre S et C (simulation d'un serveur Web par exemple).

Sur la machine S : # iperf -s
Sur la machine C : # iperf -c IPS -P 4

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Server listening on TCP port 5001
TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 6] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 64978
[ 7] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 64979
[ 8] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 64980
[ 9] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 64981
[ 7] 0.0-10.0 sec 28.0 MBytes 23.5 Mbits/sec
[ 8] 0.0-10.0 sec 28.0 MBytes 23.4 Mbits/sec
[ 9] 0.0-10.0 sec 28.1 MBytes 23.5 Mbits/sec
[ 6] 0.0-10.0 sec 28.1 MBytes 23.5 Mbits/sec
[SUM] 0.0-10.0 sec 112 MBytes 93.8 Mbits/sec

Le protocole TCP, bien que capable de s'adapter aux réseaux large bande, a été conçu lorsque les débits étaient beaucoup moins importants. Les valeurs par défaut des fenêtres TCP (taille des paquets envoyés dans des trames TCP) ne sont pas forcément adaptées aux réseaux actuels. IPerf permet de jouer avec la taille de ces fenêtres avec l'option -w. L'exemple suivant génère un flux TCP avec une taille de fenêtre de 130 kilooctets.

Sur la machine S : # iperf -s
Sur la machine C : # iperf -c IPS -w 128k

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Client connecting to 192.168.29.1, TCP port 5001
TCP window size: 128 KByte (WARNING: requested 130 KByte)
------------------------------------------------------------
[ 3] local 192.168.29.157 port 65066 connected with 192.168.29.1 port 5001
[ 3] 0.0-10.0 sec 112 MBytes 93.5 Mbits/sec

Le MTU est la taille maximale du paquet pouvant être transmis sur la couche réseau sans être segmenté. La découverte de cette valeur peut être utile à l'optimisation de votre réseau et des applications qui tournent dessus. IPerf permet d'obtenir cette valeur grâce à l'option -m (à lancer sur le serveur).

Sur la machine S : # iperf -s -m
Sur la machine C : # iperf -c IPS

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Client connecting to 192.168.29.1, TCP port 5001
TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 3] local 192.168.29.157 port 65066 connected with 192.168.29.1 port 5001
[ 3] 0.0-10.0 sec 112 MBytes 93.5 Mbits/sec[ 3] MSS size 1448 bytes (MTU 1500 bytes, ethernet)

Les paquets de type voix sur IP ont les caractéristiques suivantes : protocole UDp et taille des paquets petite (bien inférieures au MTU). Le meilleur moyen de tester un flux de type VoIP avec IPerf est d'utiliser les options -l (taille du datagram) et -w (taille maximale du buffer recevant les datagras) en fixant une valeur de datagram inférieure à celle du buffer.

Sur la machine S : # iperf -s -u -l 32 -w 128k -i 1
Sur la machine C : # iperf -c IPS -u -b 1m -l 32 -w 128k

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Server listening on UDP port 5001
Receiving 32 byte datagrams
UDP buffer size: 128 KByte
------------------------------------------------------------
[ 3] local 192.168.29.157 port 5001 connected with 192.168.29.125 port 32778
[ 3] 0.0- 1.0 sec 96.0 KBytes 786 Kbits/sec 0.003 ms 0/ 3 (0%)
[ 3] 1.0- 2.0 sec 128 KBytes 1.05 Mbits/sec 0.008 ms 0/ 4 (0%)
[ 3] 2.0- 3.0 sec 128 KBytes 1.05 Mbits/sec 0.017 ms 0/ 4 (0%)
[ 3] 3.0- 4.0 sec 128 KBytes 1.05 Mbits/sec 0.021 ms 0/ 4 (0%)
[ 3] 4.0- 5.0 sec 128 KBytes 1.05 Mbits/sec 0.023 ms 0/ 4 (0%)
[ 3] 5.0- 6.0 sec 96.0 KBytes 786 Kbits/sec 0.022 ms 0/ 3 (0%)
[ 3] 6.0- 7.0 sec 128 KBytes 1.05 Mbits/sec 0.152 ms 0/ 4 (0%)
[ 3] 7.0- 8.0 sec 128 KBytes 1.05 Mbits/sec 0.142 ms 0/ 4 (0%)
[ 3] 8.0- 9.0 sec 128 KBytes 1.05 Mbits/sec 0.115 ms 0/ 4 (0%)
[ 3] 9.0-10.0 sec 128 KBytes 1.05 Mbits/sec 0.098 ms 0/ 4 (0%)
[ 3] 0.0-10.5 sec 1.25 MBytes 1.00 Mbits/sec 0.116 ms 0/ 40 (0%)

Remarque : bien que Iperf soit disponible sur de nombreuses plates-formes (Linux, BSD, Mac, Windows), l'option -l ne fonctionne pas toujours quand vous utilisez des OS différents entre le client et le serveur.

Par défaut, Iperf utilise le numéro de port 5001 (TCP et/ou UDP). Selon votre configuration (notamment au niveau des ACL des routeurs/firewalls), il peut être utile d'utiliser un autre port, pour cela, il faut passer par l'option -p. L'exemple suivant permet de générer un flux réseau TCP entre S et C sur le port 80 (port Web standard).

Sur la machine S : # iperf -s -p 80
Sur la machine C : # iperf -c IPS -p 80

Résultat (à lire sur la machine S) :

------------------------------------------------------------
Server listening on TCP port 80
TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 6] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 54334
[ 6] 0.0-10.0 sec 112 MBytes 93.7 Mbits/sec

Voici donc quelques exemples d'utilisation d'Iperf, si vous en avez d'autres, les commentaires sont ouverts !

Par défaut, les buffers d'écriture et de lecture sont de 8 000 octets. On peut utiliser la fonction '-l' pour modifier cette taille (taille minimum : 12 octets).

Par exemple, pour générer des paquets UDP (mais cela fonctionne aussi avec le protocole TCP) avec des buffers (in/out) de 40 octets.

Serveur :

# iperf -s -u -l 40

Client :

# iperf -c <adresse IP client> -u -l 40

Remarque : cela a pour effet de produire sur le réseau des paquets UDP de 40 octets (en-tête UDp inclus), ce qui correspond à la moyenne de la taille des paquets utilisés avec les protocoles de VoIP de type SIP ou H.323).

Il est parfois utile de connaître la taille du MTU sur un chemin réseau (par exemple pour personnaliser son stack IP en fonction de sa connexion Internet). Iperf permet, grâce à l'option '-m', d'afficher cette valeur dans le rapport.

Serveur :

# iperf -s -m

Client :

# iperf -c <adresse IP client> -m

------------------------------------------------------------
Client connecting to 192.168.29.1, TCP port 5001
TCP window size: 65.0 KByte (default)
------------------------------------------------------------
[ 3] local 192.168.29.157 port 51850 connected with 192.168.29.1 port 5001
[ ID] Interval Transfer Bandwidth
[ 3] 0.0-10.0 sec 111 MBytes 93.0 Mbits/sec
[ 3] MSS size 1448 bytes (MTU 1500 bytes, ethernet)

Il est alors possible de tester le réseau en fixant cette valeur avec l'option '-M' :

Serveur :

# iperf -s -M 40

Client :

# iperf -c <adresse IP client> -M 40

Par défaut, lorsque l'on utilise le protocole UDP (option '-u'), les flux vont du client vers le serveur. Pour faire un test bidirectionnel (c'est-à-dire avec deux flux simultanés, client->serveur et serveur->client), il suffit d'utiliser l'option '-d' au niveau du client. Si vous souhaitez que ce test se fasse de manière non simultanée, il faut utiliser l'option '-r' en lieu et place de l'option '-d'.

# iperf -s -u

Client :

# iperf -c <adresse client> -u -d
... Client report:
[ 5] 0.0-10.0 sec 1.25 MBytes 1.05 Mbits/sec 13.697 ms 0/ 893 (0%)
[ 7] Server Report:
[ 7] 0.0-10.0 sec 1.25 MBytes 1.05 Mbits/sec 0.027 ms 0/ 891 (0%)

Si vous souhaitez que Iperf génère non pas un seul flux réseau entre le client et le serveur, mais plusieurs. Il faut fixer le nombre avec l'option '-P'. Par exemple pour générer cinq flux UDP simultanés entre le client et le serveur, il faut utiliser les commandes suivantes :

Serveur :

# iperf -s -u

Client :

# iperf -c <adresse IP client> -u -P 5

Si votre réseau est compatible avec la QoS Diffserv, vous pouvez taguer le champ DSCP des paquets générés par Iperf  en utilisant l'option -S :

# iperf -c <adresse IP client> -u -S 0x99

Par défaut, le port d'écoute du serveur est le 5001 (UDP ou TCP). Pour le modifier (par exemple si vous devez traverser un Firewall ou vous n'avez pas la main, il faut utiliser l'option '-p' sur le serveur et le client.

Par exemple pour utiliser le port HTTP (80) :

Serveur :

# iperf -s -p 80

Client :

# iperf -c <adresse IP client> -p 80

C'est assez simple, je l'ai mis à disposition dans ce répertoire. Vous pouvez également suivre cette procédure :

cd /tmp
wget http://svn.nicolargo.com/iperfit/trunk/iperfit.pl
chmod a+rx /tmp/iperfit.pl
cp /tmp/iperfit.pl /usr/local/bin

Pour un simple test TCP de cinq minutes (300 secondes) vers la machine 192.168.0.100 (login SSH nicolargo) avec une taille MSS de 1200 octets :

iperfit.pl -c 192.168.0.100 -n nicolargo -t 300 -m 1200

Pour lancer un test entre votre machine et la machine d'adresse IP 192.168.0.100 (login SSH nicolargo) en UDP avec une taille de buffer de 170 octets sur une durée de 60 secondes et avec un débit de 64 kb/s, il suffit de saisir la ligne suivante :

iperfit.pl -c 192.168.0.100 -n nicolargo -u -l 170 -t 60 -b 64

Si vous avez le message suivant au lancement du programme :

Can't locate Net/IPv4Addr.pm in @INC (@INC contains: /etc/perl /usr/local/lib/perl/5.10.1 /usr/local/share/perl/5.10.1 /usr/lib/perl5 /usr/share/perl5 /usr/lib/perl/5.10 /usr/share/perl/5.10 /usr/local/lib/site_perl .) at ./iperfit.pl line 33.BEGIN failed--compilation aborted at ./iperfit.pl line 33.

C'est que vous n'avez pas la bibliothèque Perl IPv4Addr qui est installée, sous Ubuntu/Debian pour remédier à cela il faut saisir la commande suivante :

sudo aptitude install libnetwork-ipv4addr-perl

Si vous avez des améliorations à proposer à ce script, je suis à votre écoute !