TKO
Mon CV
Back to blog
Jun 11, 2025
8 min read

Projet : Tests de Performance Réseau avec iPerf3 et Automatisation en Python

Découvrez comment j'ai mis en place un projet de tests de performance réseau en utilisant iPerf3 et automatisé ces tests avec un script Python.

Dans cet article, je vais vous présenter en détail mon projet de tests de performance réseau, réalisé avec iPerf3 et automatisé à l’aide d’un script Python. Cet article est conçu pour ceux qui, comme moi, souhaitent démontrer leurs compétences techniques aux recruteurs, même si vous n’avez pas encore une grande expérience en réseau. Vous découvrirez ce qu’est iPerf3, comment interpréter ses résultats, et comment j’ai automatisé les tests pour surveiller régulièrement l’état de mon réseau.

1. Qu’est-ce qu’iPerf3 ?

iPerf3 est un outil en ligne de commande open source qui me permet de mesurer la performance de ma connexion réseau. Voici quelques points clés :

  • Mesure de la bande passante : iPerf3 teste la vitesse à laquelle les données peuvent être transférées entre deux machines.
  • Architecture client-serveur :
    • Mode Serveur : Je lance iPerf3 en mode serveur sur une machine (dans mon cas, mon PC hôte sous Windows). Le serveur écoute sur le port par défaut (5201) et attend des connexions.
    • Mode Client : Je lance iPerf3 en mode client sur une autre machine (ma VM Ubuntu). Le client se connecte au serveur pour envoyer des données et mesurer la bande passante.
  • Tests TCP et UDP : iPerf3 peut tester des connexions en mode TCP (transmission fiable) et en mode UDP (transmission sans garantie de livraison), me permettant ainsi d’analyser différents aspects de la performance réseau.

2. Comment lire les résultats d’un test iPerf3 ?

Lorsque j’exécute un test iPerf3 dans mon terminal, j’obtiens une sortie qui ressemble à ceci (exemple pour un test TCP) :

[  5]   0.00-1.00   sec   112 MBytes   934 Mbits/sec    0    356 KBytes       
[  5]   1.00-2.00   sec   150 MBytes  1.26 Gbits/sec    0    356 KBytes       
[  5]   2.00-3.00   sec   196 MBytes  1.64 Gbits/sec    0    356 KBytes       
[  5]   3.00-4.00   sec   184 MBytes  1.54 Gbits/sec    0    356 KBytes

Voici comment j’interprète ces informations :

  • Intervalle de temps (ex. 0.00-1.00 sec) : Il indique la durée de la mesure.
  • Transfert (ex. 112 MBytes) : C’est la quantité de données envoyées durant cet intervalle.
  • Bitrate (ex. 934 Mbits/sec) : Cela représente la vitesse moyenne de transmission, c’est-à-dire la bande passante.
  • Retransmissions (ex. 0) : Le nombre de paquets qui ont dû être renvoyés. Un nombre élevé peut signaler des problèmes de congestion ou de qualité de connexion.
  • Cwnd (congestion window) (ex. 356 KBytes) : Indique la quantité de données que le protocole TCP peut envoyer avant de recevoir un accusé de réception, donnant une idée de l’état de congestion du réseau.

Pour un test UDP, la sortie est similaire, mais se concentre sur le débit, le jitter (variation de délai) et la perte de paquets. L’analyse de ces paramètres m’aide à comprendre la stabilité et la fiabilité de la connexion.

3. Automatisation des tests avec Python

Pour simplifier la surveillance de ma connexion, j’ai développé un script Python qui réalise les actions suivantes :

  • Exécuter un test TCP avec iPerf3 toutes les heures, en limitant la bande passante à 100 Mbps.
  • Exécuter un test UDP toutes les heures.
  • Sauvegarder les résultats des tests dans un fichier log.txt.
  • Analyser les résultats pour détecter d’éventuels problèmes (par exemple, une bande passante trop faible).
  • Enregistrer l’analyse dans un fichier analyse-logs.txt :
    • Si tout est en ordre, j’inscris une ligne du type test-<timestamp> passé avec succès. RAS.
    • Si un problème est détecté, une copie détaillée des logs est enregistrée dans un dossier problemes/ sous le nom probleme-<timestamp>.txt.
  • Nettoyer les logs : Si aucun problème n’est détecté, le fichier log.txt est supprimé pour que les tests suivants soient réalisés sur une base propre.

Le script Python en détail

Voici le script complet que j’utilise, avec des commentaires pour expliquer chaque étape :

import subprocess
import time
import os
from datetime import datetime

# Définir les adresses IP du serveur et du client
SERVER_IP = "192.168.1.81"  # L'IP de mon PC hôte sous Windows (serveur iPerf3)
CLIENT_IP = "192.168.1.57"  # L'IP de ma VM Ubuntu (client iPerf3)

# Seuils de bande passante minimale pour détecter un problème (en Mbits/sec)
MIN_BANDWIDTH_THRESHOLD_TCP = 100  # Pour le test TCP
MIN_BANDWIDTH_THRESHOLD_UDP = 1    # Pour le test UDP

# Fonction pour exécuter un test iPerf3 et récupérer les résultats
def run_iperf3_test(mode, bandwidth=None):
    cmd = ["iperf3", "-c", SERVER_IP]
    if mode == "udp":
        cmd.append("-u")  # Option pour le mode UDP
    if bandwidth:
        cmd.extend(["-b", bandwidth])  # Exemple : "-b 100M" pour limiter le débit en TCP
    cmd.append("-t")
    cmd.append("10")  # Durée du test en secondes

    # Exécuter la commande iPerf3 et capturer la sortie
    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.stdout

# Fonction pour analyser le contenu des logs et détecter d'éventuels problèmes
def analyze_logs(log_content):
    problems = []

    # Analyser les lignes contenant "bitrate" pour le test TCP
    if "bitrate" in log_content:
        lines = log_content.split("\n")
        for line in lines:
            if "bitrate" in line.lower():
                parts = line.split()
                try:
                    # Extraire le débit (valeur en Mbits/sec se trouve généralement dans la 5ème colonne)
                    bandwidth = float(parts.replace("Mbits/sec", "").strip())
                    if bandwidth < MIN_BANDWIDTH_THRESHOLD_TCP:
                        problems.append(f"Problème TCP : bande passante trop faible ({bandwidth} Mbits/sec)")
                except (ValueError, IndexError):
                    continue

    # Analyser de manière similaire les résultats pour le test UDP
    if "bitrate" in log_content:
        lines = log_content.split("\n")
        for line in lines:
            if "bitrate" in line.lower():
                parts = line.split()
                try:
                    bandwidth = float(parts.replace("Mbits/sec", "").strip())
                    if bandwidth < MIN_BANDWIDTH_THRESHOLD_UDP:
                        problems.append(f"Problème UDP : bande passante trop faible ({bandwidth} Mbits/sec)")
                except (ValueError, IndexError):
                    continue

    return problems

# Fonction principale pour exécuter les tests, analyser les résultats et gérer les logs
def run_tests_and_analyze():
    log_file = "log.txt"
    # Obtenir un timestamp pour nommer les fichiers et les enregistrements
    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    log_analysis_file = "analyse-logs.txt"
    problem_folder = "problemes"

    # Créer le dossier "problemes" s'il n'existe pas déjà
    if not os.path.exists(problem_folder):
        os.makedirs(problem_folder)

    # --- Exécution des tests ---
    print("Lancement du test TCP...")
    tcp_result = run_iperf3_test("tcp", "100M")
    print(tcp_result)

    print("Lancement du test UDP...")
    udp_result = run_iperf3_test("udp")
    print(udp_result)

    # Sauvegarder les résultats bruts dans log.txt
    with open(log_file, "a") as file:
        file.write(f"Résultats du test TCP:\n{tcp_result}\n")
        file.write(f"Résultats du test UDP:\n{udp_result}\n")

    # --- Analyse des résultats ---
    problems = analyze_logs(tcp_result + udp_result)

    # Préparer la ligne d'analyse à enregistrer dans analyse-logs.txt
    analysis_line = f"test-{timestamp} passé avec succès. RAS\n"
    if problems:
        analysis_line = f"test-{timestamp} échec. Problèmes détectés :\n" + "\n".join(problems) + "\n"
        # Enregistrer une copie détaillée des logs dans un fichier dans le dossier "problemes"
        with open(os.path.join(problem_folder, f"probleme-{timestamp}.txt"), "w") as problem_file:
            problem_file.write(f"Résultats du test TCP:\n{tcp_result}\n")
            problem_file.write(f"Résultats du test UDP:\n{udp_result}\n")
            problem_file.write("\nProblèmes détectés :\n" + "\n".join(problems))

    # Enregistrer l'analyse dans analyse-logs.txt
    with open(log_analysis_file, "a") as analysis_file:
        analysis_file.write(analysis_line)

    # Si aucun problème n'est détecté, supprimer log.txt pour que le prochain test soit propre
    if not problems:
        os.remove(log_file)

# Boucle principale pour exécuter les tests toutes les heures
while True:
    run_tests_and_analyze()
    time.sleep(3600)  # Attendre 3600 secondes (1 heure) avant de relancer les tests

Explications détaillées

  • Configuration Initiale : Je définis d’abord les adresses IP du serveur (mon PC hôte) et du client (ma VM Ubuntu), ainsi que les seuils de bande passante qui déclencheront une alerte en cas de problème.
  • Exécution des Tests : La fonction run_iperf3_test() construit la commande iPerf3 en fonction du mode (TCP ou UDP) et exécute le test pendant 10 secondes. Les résultats sont capturés et retournés sous forme de texte.
  • Analyse des Résultats : La fonction analyze_logs() parcourt les résultats du test pour rechercher les lignes contenant “bitrate”. Elle extrait la valeur de la bande passante et la compare aux seuils définis. Si le débit est insuffisant, un message d’alerte est généré.
  • Gestion des Logs et Analyses :
    • Les résultats bruts sont enregistrés dans un fichier log.txt.
    • Ensuite, une analyse est effectuée et le résultat est inscrit dans analyse-logs.txt.
    • Si des problèmes sont détectés, une copie détaillée des logs est enregistrée dans un dossier problemes/ avec un nom de fichier incluant le timestamp.
    • Si aucun problème n’est détecté, le fichier log.txt est supprimé pour préparer le prochain test.
  • Automatisation : Le script s’exécute dans une boucle infinie et lance ces tests toutes les heures (grâce à time.sleep(3600)), ce qui me permet de surveiller en continu l’état de mon réseau.

Conclusion

Grâce à iPerf3, j’ai pu mesurer précisément la performance de mon réseau et détecter d’éventuels problèmes comme une bande passante insuffisante ou des retransmissions. En automatisant ces tests avec Python, je peux désormais surveiller ma connexion de manière régulière, enregistrer les résultats et recevoir des alertes en cas de problème.

Ce projet démontre non seulement ma capacité à utiliser des outils de diagnostic réseau, mais aussi à concevoir des solutions automatisées pour améliorer la qualité et la fiabilité des infrastructures. Je suis convaincu que cette approche proactive est un atout majeur que je mets en avant dans mon parcours professionnel.

J’espère que cet article vous aura éclairé sur le fonctionnement d’iPerf3 et sur la manière dont j’ai automatisé mes tests réseau. N’hésitez pas à me contacter pour toute question ou pour échanger sur ce sujet !

Prev
Ma revanche sur C# et .NET : créer un raccourcisseur d'URL
Next
Le Modèle OSI (pour les nuls)