Fortinet VPN SSL Vous souhaitez que vos utilisateurs nomades aient toujours accès aux applications présentes au sein de votre entreprise au travers d’un navigateur web? Dans ce tutoriel, je vais vous montrer comment configurer un Firewall Fortinet (Fortigate) [...]
Configurer et vérifier NTP dans le mode client et le mode server
Configurer et vérifier NTP dans le mode client et le mode serverSynchronisation temporelle NTP1. Network Time Protocol (NTP)Network Time Protocol (NTP) est un protocole TCP/IP qui permet de synchroniser à travers le réseau l’horloge locale des ordinateurs sur une date et une heure de référence. Le projet NTP propose u[...]
Création d’une règle de pare-feu avec un Fortigate
Création d’une règle de pare-feu avec un Fortigate I. Présentation Après avoir découvert ce qu’est un Fortinet dans un premier article, je voudrais vous montrer comment mettre en place une règle de Firewall avec quelques-unes des options de sécurité les plus utilisées pour la sécurité ou l’optimisation de n[...]
Qu’est-ce qu’un système PBX?
Qu’est-ce qu’un système PBX? Le terme PBX revient souvent dans les offres des fournisseurs téléphoniques, parfois sous la forme de PBX hébergé, PBX IP ou Cloud PBX. Pour ceux qui connaissent moins leur lexique téléphonique, l’offre d’un système PBX avec des fonctionnalités quelconque[...]
Le JavaScript++
TypeScript est un langage très récent (février 2012) qui a été conçu par Anders Hejlsberg, également concepteur du langage C#. Le but premier de TypeScript est de rendre plus facile et plus fiable l'écriture de code en JavaScript pour des applications de grande ampleur. Cet article présentera de fa[...]
De la téléphonie IP très facilement avec Asterisk
De la téléphonie IP très facilement avec Asterisk Je vous propose en ce début d’année un tuto assez simple sur Asterisk. Si vous ne le connaissez pas, c’est un logiciel libre qui permet de faire de la téléphonie par IP, c’est assez sympa à faire ! Le tutorial a été réalisé sur une Debian 7.3 64bits m[...]
Qu’est ce que la Voix sur IP (VoIP)?
Qu’est ce que la Voix sur IP (VoIP)? La Voix sur IP, raccourci de voix par le protocole internet, est aussi connue sous le terme de VoIP. La voix sur IP se réfère à la diffusion du flux de la voix sur les réseaux Internet, au lieu des réseaux téléphoniques RTC traditionnels. Le protocole Internet (IP) a ét[...]
Quelques astuces pour assurer la sécurité de vos données informatiques
Quelques astuces pour assurer la sécurité de vos données informatiques Sécurité informatique Chaque année, de nombreux utilisateurs et entreprises se font malheureusement piratés leurs données informatiques qu’elles soient personnelles ou professionnelles. Pour éviter e[...]
Installer une VM Linux sur ESXi
VMware vSphere ESXi Hypervisor comment configurer ESXi, le plus célèbre des virtualiseurs dit "barre métal" ou encore "hyperviseur type 1" (système dédié à la virtualisation) qui à une version gratuite limitée, mais largement utilisable pour un usage perso. Il a la particularité d'être extrêmement fiab[...]
VMware vSphere ESXi Hypervisor
VMware vSphere ESXi Hypervisor comment configurer ESXi, le plus célèbre des virtualiseurs dit "barre métal" ou encore "hyperviseur type 1" (système dédié à la virtualisation) qui à une version gratuite limitée, mais largement utilisable pour un usage perso. Il a la particularité d'être extrêmement fiable, [...]
Iperf
mardi 9 février 2016|
ali
IPerf: des exemples…
Nous commençons l'année 2008 avec un billet regroupant des exemples d'utilisation d'IPerf, l'outil en ligne de commande indispensable pour tester un réseau informatique.
Pour rappel, IPerf est un logiciel client/serveur, il faut donc deux machines positionner aux deux extremités du réseau à tester pour fonctionner (pour l'installation et une rapide introduction, vous pouvez consulter ce billet).
Dans les exemples ci-dessous, nous allons considérer que nous allons utiliser deux machines nommées C (avec comme adresse IP: IPC) et S (avec comme adresse IP: IPS).
Exemple pour mesurer la bande passante disponible entre S et C
Attention, cette méthode mesure la bande passante au moment du test. Ce dernier dure par défaut 10 secondes et utilise le protocole TCP sur le port 5001.
Sur la machine S: # iperf -sSur 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
Exemple pour générer un débit réseau entre C et S
On génère ici un flux en utilisant le protocole UDP et en fixant la bande passante à 1 Megabits par seconde. Le test dure par défaut 10 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: megabits par seconde
- g: gigabits parseconde
pour un débit en octets par seconde, il faut utiliser ces lettres en majuscule)
Sur la machine S: # iperf -s -uSur la machine C: # iperf -c IPS -u -b 4m
Résultat (à lire sur la machine S):
------------------------------------------------------------Server listening on UDP port 5001Receiving 1470 byte datagramsUDP 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%)
Exemple pour générer un débit réseau entre C et S pendant 10 heures
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 à 10 heures (10*3600=36000 secondes).
Sur la machine S: # iperf -s -uSur la machine C: # iperf -c IPS -u -b 4m -t 36000
Résultat (à lire sur la machine S):
------------------------------------------------------------Server listening on UDP port 5001Receiving 1470 byte datagramsUDP 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 -uSur la machine C: # iperf -c IPS -u -b 4m -t 3600
Résultat (à lire sur la machine S):
------------------------------------------------------------Server listening on UDP port 5001Receiving 1470 byte datagramsUDP 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%)
Exemple pour générer 2 flux réseau entre S et C
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 4 flux TCP entre S et C (simulation d'un serveur Web par exemple).
Sur la machine S: # iperf -sSur la machine C: # iperf -c IPS -P 4
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 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
Exemple pour optimiser une connexion TCP entre S et C
Le protocole TCP, bien que capable pour s'adapter aux réseaux large bande, a été conçu lorsque les débits étaient beaucoup moins important. Les valeurs par défaut des fenêtres TCP (taille des paquets envoyé dans des trames TCP) ne sont pas forcement adapté 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 kilo octets.
Sur la machine S: # iperf -sSur la machine C: # iperf -c IPS -w 128k
Résultat (à lire sur la machine S):
------------------------------------------------------------Client connecting to 192.168.29.1, TCP port 5001TCP 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
Exemple pour découvrir la taille du MTU entre S et C
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 tourne dessus. IPerf permet d'obtenir cette valeur grâce à l'option -m (à lancer sur le serveur).
Sur la machine S: # iperf -s -mSur la machine C: # iperf -c IPS
Résultat (à lire sur la machine S):
------------------------------------------------------------Client connecting to 192.168.29.1, TCP port 5001TCP 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)
Exemple pour tester un flux de type VoIP entre C et S
Les paquets de type voix sur IP on les caractéristiques suivantes: protocole UDp et taille des paquets petites (bien inférieure 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 1Sur 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 5001Receiving 32 byte datagramsUDP 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 plate-forme (Linux, BSD, Mac, Windows), l'option -l ne fonctionne pas toujours quand vous utiliser des OS différents entre le client et le serveur.
Exemple pour utiliser IPerf sur un port différent
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 80Sur la machine C: # iperf -c IPS -p 80
Résultat (à lire sur la machine S):
------------------------------------------------------------Server listening on TCP port 80TCP 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
Tester la performance de votre réseau avec Iperf
Iperf est un des outils indispensable pout tout administrateur réseau qui se respecte. En effet, ce logiciel de mesure de performance réseau, diponible sur de nombreuses plateformes (Linux, BSD, Mac, Windows...), se présente sous la forme d'une ligne de commande à executer sur deux machines disposées aux extrémités du réseau à tester.
Iperf fonctionne comme un client/serveur selon le diagramme suivant:
Iperf doit être lancé sur deux machines se trouvant de part et d'autre du réseau à tester. La première machine lance Iperf en "mode serveur" (avec l'option -s), la seconde en "mode client" (option -c). Par défaut le test réseau se fait en utilsant le protocole TCP (mais il est également possible d'utiliser le mode UDP avec l'option -u).
Nous allons commencer par installer iperf en utilisant la commande suivante (sous Fedora):
# yum install iperf
Pour les autres système d"exploitation, vous pouvez vous rendre sur cette page.
Premier exemple d'utilisation
Ensuite, sur une des deux machines de test, nous allon slancer le serveur grâce à la commande suivante:
# iperf -s
Sur le client, il ne reste plus qu'a 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 10 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 10 secondes. Sur un réseau local vous devriez donc obtenir un valeur proche de la capacité de commutation de vos équipements (par exemple 92.6 Mbits/sec qui est une valeur proche de 100 Mbits/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 1 minute:
# ipert -c <adresse IP du serveur> -t 60
Exemple de test en utilisant le protocole UDP
Iperf permet également de générer un traffic 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 Kbits/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.
Exemple de test en multicast (UDP)
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 Kbits/sec.
Autres options
NOUVEAU: Consultez cet autre article (cliquez ici) pour une description des options avancés 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 !
Sur le même sujet
Pour mes propres besoins, j'ai ecrit un programme nommé SJitter permettant, comme le fait Iperf (c'est à dire sous la forme d'un client/serveur), de mesurer la gigue réseau (ou jitter en anglais). Paramètre très important si vous souhaitez mettre en place de la voie sur IP sur votre réseau.
Utilisation avancée de Iperf
Suite à ce premier article décrivant les fonctions de base, voici un complément d'informations sur l'utilisation du logiciel Iperf.
Changement de la taille des buffers
Par défaut, les buffer d'écriture et de lecture sont the 8000 octets. On peut utiliser la fonction '-l' pour modifier cette taille (taille minimum: 12 octets).
Par exemple, pour generer 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).
Afficher la taille du MTU
Il est parfois utile de connaître la taille du MTU sur un chemin réseau (par l'exemple pour customize son stack IP en fonction de sa connection 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)
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
Faire un test bi-directionnel en UDP
Par défaut, lorsque l'on utilise le protocole UDP (option '-u'), les flux vont du client vers le serveur. Pour faire un test bi-directionnel (c'est à dire avec 2 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é, 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%)
Faire un test avec plusieurs flux
Si vous souhaitez que Iperf génére non pas 1 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énerer 5 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
Taguer le champs Diffserv
Si votre réseau est compatible avec la QoS Diffserv, vous pouvez taguer le champs DSCP les paquets générés par Iperf en utilisant l'option -S:
# iperf -c <adresse IP client> -u -S 0x99
Changer le port d'écoute par défaut
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
IperfiT, un petit script pour les fans de Iperf
J'utilise actuellement Iperf (voir la liste des billets sur le sujet ici) dans le cadre de tests de performances de réseaux divers et variés. Bien que très simple à utiliser pour une personne avertie, Iperf n'est pas conçu pour automatiser des benchs en faisant varier les cibles et les paramètres.
J'ai donc développé, sous licence LGPL, un script Perl nommé IperfiT qui fait "grosso modo" les choses suivantes lors d'un test entre les machines A (sur lequel le script sera lancé) et B (qui se trouve de l'autre coté du réseau à tester et qui accepte les connexions SSH venant de A):
- Test de la connectivité avec la machine B (A ping B)
- Connexion automatiquement en SSH vers la machine B
- Lancement du serveur IPerf sur la machine B
- Lancement du client sur la machine A
- Affichage du rapport venant de l'IPerf de la machine B
- Arrêt de l'Iperf de la machine B
Les options de la version 0.1 de IperfiT sont les suivantes:
-h: Print the command line help-v: Print the program version-q: Quiet mode (no display)-s <ip>: Server IP address-n <user>: SSH user name used to connect to the server-u: Use UDP protocol (default is TCP)-b: Target bitrate for UDP flow-t <time>: Test duration, default is 30 sec-m <mss>: Set the TCP Maximum Segment Size (MTU-40), default 1400 bytes-w <wsize>: Set the TCP Window Size, default 128 Kbytes-l <bsize>: Set the R/W Buffer Size, default 8000 bytes-d <tos>: Set the TOS field (Diffserv), default is 0
Installation de IperfiT
C'est assez simple, je l'ai mis à disposition dans ce répertoire. Vous pouvez également suivre cette procédure:
cd /tmpwget https://raw.githubusercontent.com/nicolargo/iperfit/master/iperfit.plchmod a+rx /tmp/iperfit.plcp /tmp/iperfit.pl /usr/local/bin
Utilisation de iperfiT en quelques exemples
Pour un simple test TCP de 5 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 Kbps, il suffit de saisir la ligne suivante:
iperfit.pl -c 192.168.0.100 -n nicolargo -u -l 170 -t 60 -b 64
Remarque
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 librairie Perl IPv4Addr qui est installé, 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 !
XJperf une interface Java pour Iperf
Si vous utilisez Iperf pour calculer les performances de votre réseau, le programme XJperf vous intéressera sûrement. Reprenant une interface existante (Jperf), l'auteur du programme a considérablement améliorer les fonctionnalités et la stabilité de cette interface utilisateur.
XJperf permet donc de prendre en main très rapidement l'application Iperf, sans avoir à en connaître par coeur les (nombreuses) options. C'est un moyen idéal pour connaître la bande passante, le délais de transit et la gigue entre deux équipements réseaux.
Posted in
réseaux IP
0 commentaires pour ce poste
Leave a reply