QoS, Qualité de Service, limite de débit

Définition générale

Quest-ce que la QoS?

Sous l'acronyme QoS se cache "Quality Of Service" en anglais, soit Qualité de Service en français. Vous comprenez bien que QoS est un terme tres large. Pour préciser un peu, généralement, on entend par QoS, en réseau, "traffic shapping" (limite de débit), et gestion des diverses prioritées concernant l'envoi de paquet (nous allons revenir la dessus dans un chapitre dédié).

Dans quelles mesures faire de la QoS ?

Pourquoi faire de la QoS ?

Pourquoi la QoS, tout simplement pour a moindre coût (nul si un routeur de type PC est déja en place sur le réseau!), améliorer fortement les performances d'un réseau (notament sur des liens asynchrones de type ADSL).

Qui peut faire de la QoS ?

Tout le monde peut faire de la QoS, a partir du moment ou vous possédez un équipement réseau permettant d'en faire. Cet article ne présentera pour l'instant que la QoS que l'on peut effectuer avec un routeur GNU/Linux PC (en effet, il est possible de faire de la QoS avec des "gros" routeurs managables, comme les cisco moyen et haut de gamme). Peut être si on me le demande je ferais une section sur la QoS sous OpenBSD, FreeBSD (AltQ).

Les concepts théoriques

Première chose à savoir: on ne fais de la QoS QUE sur les liens sortants. En effet, prenez l'exemple d'une boite aux lettres (celles qui est devant chez vous, ou en bas de vôtre immeuble, pas l'electronique ;)), vous ne controlez absolument pas ce qui est mi dedans. Le facteur peut tres bien la charger au maximum jusqua que ça déborde, vous ne pourrez rien y faire, avant de la vider! En QoS, c'est exactement la même chose. Ceci dit, on peut arriver a trouver un moyen de faire de la QoS en "entrant" en bidouillant le noyau linux (ou BSD :p). On verra les moyens à notre disposition pour faire du traffic shapping (limiter le débit) sur le traffic entrant d'un lien ADSL, par exemple, plus loin dans l'article.

En QoS, on peut faire du traffic shapping, et de la gestion de prioritization de paquets. Et c'est a peu pres tout! (mais vous verrez, c'est déja assez costau!)

Un exemple concret, chez moi !

Plan simplifié du réseau

Pour ammorcer l'approche "pratique" de la chose, je vous propose tout d'abord une vision de mon réseau.

  |---------|        |-------------------|
  | A D S L |--ppp0--| Gateway GNU/Linux |
  |---------|        |-------------------|
                         |   |         |
                         )   (         (
                        /     \         \
                       /       \         \
          |----tun*----| |----eth0----| |----------eth1-----------|
          | VPN(s)     | | Serveurs   | | Réseau Local (stations) |
          |------------| |------------| |-------------------------|

Ce que je veux faire

Tout d'abord, ce que je veux, c'est avoir un latence relativement bas, quoi qu'il se passe sur mon réseau. Pourquoi avoir un latence bas me direz vous? Et bien tout simplement parceque quand je suis au travail, ou a l'école, il m'arrive fréquement de devoir faire une maintenance, de me connecter a mon client IRC depuis chez moi, de récupérer un document que je n'ai pas mi sur mon serveur web, ... Enfin, il y a plein de raison.

Premier problème: l'hébergement web !
Effectivement, cela pose problème parceque pour avoir des latences bas, si quelqu'un télécharge une photo depuis mon serveur web, et bien c'est rappé! Typiquement, on se retrouve aux alentours de 2000 ms de ping (temps de réponse entre 2 points sur internet). Pour faire mon IRC depuis l'école, c'est raté! Et bien non !

La solution: limiter le débit provenant du serveur web , et donner une prioritée faible a ce type de traffic.

Deuxième problème: hébergement web et FTP !
Ah et oui, imaginons, quelqu'un télécharge sur mon serveur web, mais un autre télécharge sur mon FTP! Aie, je me retrouve encore avec un ping de 2000ms... Si je dois partir dans le match de tout les services, je suis pas rendu !!

La solution «ultime»: la classe par défaut !
Ce que j'entend par classe, c'est un peu comme un "toyau" que l'on crée en QoS pour faire des limites de débit. Je crée un tuyau qui peut contenir un flux de disons 100kbps (je suis en ADSL 512/128, et comme on travail sur le débit montant pour l'instant, cela fais 100 kbps et non plus 128). (Attention, on parle en kilobits par seconde, et non pas en kilo Bytes par seconde (1kB = 8kb)) Dans cette classe, on va faire passer tout le traffic sortant vers internet, uniquement si il n'est pas déja dans une autre classe.

Un point sur ce que l'on a

Ce qu'on a défini à ce point de l'article, c'est que le traffic sortant web a droit a X kilobit (disons 80 kilobits par seconde), avec une prioritée faible. On a une classe par défaut, dans laquelle le débit est limité a 100 kilobits par seconde.
Il reste un problème: si un utilisateur telecharge en meme temps sur le serveur web et le ftp cela fais 100 + 80 kbps, soit 180kbps, or je n'ai que 128kbps, on se retrouve encore en saturation.
L'idée pour palier a ce probleme, c'est de créer une hiérarchie dans les classe. C'est a dire que nous aurons une classe parent, qui contiendra nos 2 classes filles: web et ftp.
Sous GNU/Linux, HTB3 permet de faire ça, mais pas CBQ. Ce qui nous amenne au chapitre suivant.

De la théorie a la pratique

Choix du scheduler (ordonanceur)

Sous GNU/Linux, il existe une multitude d'ordonanceur, nous n'allons pas tous les passer en revue, cela prendrais bien évidement bien trop de temps. Si vous voulez faire le tour de tout les ordonanceurs, les tester, libre a vous de le faire!
CBQ est un ordonanceur assez basique, il permet de limiter les débits, de définir des prioritées sur les paquets qui passent par lui, mais ne gere pas de hiérarchie de classe. C'est a dire que vous ne pourrez pas définir une classe, dans laquelle, d'autre classes pourront se greffer.
Pour mieux comprendre, on va reprendre l'image du tuyau. Imaginez un gros tuyau, ma classe mère, et d'autre petits tuyaux, qui viendrons s'insérer dans le gros tuyau. HTB3 permet de faire ça.

Comment faire savoir a l'ordonanceur quel paquet doit aller dans quelle classe ?

Il existe plusieurs moyens techniques pour ça: soit avec tc, l'outil compris dans le package iproute2, soit avec iptables, via le marquage des paquets. Il est nettement plus facile de faire avec iptables, il permet une plus grande souplesse. Il faudra néanmoins utiliser tc pour rediriger les paquets marqués par iptables, vers la classe HTB qui correspond.

Passons a la pratique

Script QoS avec HTB3

Je vais vous présenter le script que j'utilise chez moi, qui est un peu plus complexe que ce que j'ai pu aborder juste auparavant, mais les explications vont venir dans les chapitres juste après.

#!/bin/sh

INET_DEVICE="ppp0"
LOCAL_DEVICE="eth0"

# Vitesse max de la conex inet en Kbit/s
MAX_UPLOAD="128"
MAX_DOWNLOAD="480"

FTP="50"
WEB="100"
SMTP="40"
POP="60"
DEFAULT="100"
SPEED=${MAX_UPLOAD}
SLOW="10"

# Un peu de config
TC="/sbin/tc"
IPTABLES=`which iptables`
echo "TC: ${TC}"

# Netoyage
${TC} qdisc del dev ${INET_DEVICE} root    >/dev/null 2>&1
${TC} qdisc del dev ${INET_DEVICE} ingress >/dev/null 2>&1
${TC} qdisc del dev ${LOCAL_DEVICE} root    >/dev/null 2>&1
${TC} qdisc del dev ${LOCAL_DEVICE} ingress >/dev/null 2>&1

# Création de la classe parent:
${TC} qdisc add dev ${INET_DEVICE} root handle 1: htb default 20
${TC} class add dev ${INET_DEVICE} parent 1: classid 1:1 htb rate ${MAX_UPLOAD}kbit ceil ${MAX_UPLOAD}kbit burst 6k

# Download
${TC} qdisc add dev ${LOCAL_DEVICE} root handle 2: htb
${TC} class add dev ${LOCAL_DEVICE} parent 2: classid 2:1 htb rate ${MAX_DOWNLOAD}kbit ceil ${MAX_DOWNLOAD}kbit burst 6k

# Classe Download LIMIT
${TC} class add dev ${LOCAL_DEVICE} parent 2:1 classid 2:10 htb rate ${MAX_DOWNLOAD}kbit ceil ${MAX_DOWNLOAD}kbit burst 6k prio 9
${TC} filter add dev ${LOCAL_DEVICE} parent 2:0 protocol ip prio 9 handle 100 fw flowid 2:10
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.3      -j MARK --set-mark 100
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.4      -j MARK --set-mark 100
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.5      -j MARK --set-mark 100
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.12      -j MARK --set-mark 100
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.209      -j MARK --set-mark 100


# Classe par défaut
${TC} class add dev ${INET_DEVICE} parent 1:1 classid 1:20 htb rate ${DEFAULT}kbit ceil ${MAX_UPLOAD}kbit burst 6k prio 3

# Classe rapide
${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:10 htb rate ${SPEED}kbit ceil ${MAX_UPLOAD}kbit burst 6k prio 1
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 1 handle 10 fw flowid 1:10
${IPTABLES} -t mangle -A OUTPUT  -p tcp --dport 6667 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --dport 6667 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --sport 6667 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --sport 7000 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --sport 6668 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --sport 6669 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p icmp             -j MARK --set-mark 10
${IPTABLES} -t mangle -A OUTPUT  -p icmp             -j MARK --set-mark 10
${IPTABLES} -t mangle -A OUTPUT  -p tcp --dport 22   -j MARK --set-mark 10
${IPTABLES} -t mangle -A OUTPUT  -p tcp --sport 22   -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --dport 22   -j MARK --set-mark 10
# cs
${IPTABLES} -t mangle -A FORWARD -p udp --sport 27005 -j MARK --set-mark 10

# Classe LENTE
${TC} class add dev ${INET_DEVICE} parent 1:1 classid 1:30 htb rate ${SLOW}kbit prio 5
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 5 handle 30 fw flowid 1:30
#${IPTABLES} -t mangle -A FORWARD -p tcp --sport 4662   -j MARK --set-mark 30
#${IPTABLES} -t mangle -A FORWARD -p udp --sport 4665   -j MARK --set-mark 30
#${IPTABLES} -t mangle -A FORWARD -p tcp --dport 4662   -j MARK --set-mark 30
#${IPTABLES} -t mangle -A FORWARD -p udp --dport 4665   -j MARK --set-mark 30

# Classe WEB
${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:21 htb rate ${WEB}kbit prio 2
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 2 handle 21 fw flowid 1:21
${IPTABLES} -t mangle -A OUTPUT  -p tcp --sport 80   -j MARK --set-mark 21
${IPTABLES} -t mangle -A FORWARD  -p tcp --sport 80   -j MARK --set-mark 21

# Classe FTP
${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:22 htb rate ${FTP}kbit prio 4
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 3 handle 22 fw flowid 1:22
${IPTABLES} -t mangle -A OUTPUT  -p tcp --sport 21   -j MARK --set-mark 22
${IPTABLES} -t mangle -A FORWARD  -p tcp --dport 21   -j MARK --set-mark 22

# Classe SMTP
${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:23 htb rate ${SMTP}kbit prio 4
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 4 handle 23 fw flowid 1:23
${IPTABLES} -t mangle -A OUTPUT  -p tcp --sport 25   -j MARK --set-mark 23
${IPTABLES} -t mangle -A OUTPUT  -p tcp --dport 25   -j MARK --set-mark 23
${IPTABLES} -t mangle -A FORWARD  -p tcp --dport 25   -j MARK --set-mark 23
${IPTABLES} -t mangle -A FORWARD  -p tcp --sport 25   -j MARK --set-mark 23

${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:210 htb rate ${POP}kbit prio 4
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 4 handle 210 fw flowid 1:210

${IPTABLES} -t mangle -A FORWARD  -p tcp --sport 110   -j MARK --set-mark 210

Les explications

INET_DEVICE="ppp0"
LOCAL_DEVICE="eth0"

Ici, je défini les interfaces que mon script va utiliser pour créer ses classes, et les rattacher a la bonne interface réseau.

MAX_UPLOAD="128"
MAX_DOWNLOAD="480"

FTP="50"
WEB="100"
SMTP="40"
POP="60"
DEFAULT="100"
SPEED=${MAX_UPLOAD}
SLOW="10"

Je défini ici les débits maximums de mon interface ppp0, lien vers internet. Possédant une ligne ADSL 512/128, j'ai défini 128kbps pour le traffic montant (upload), et 480 pour le traffic descendant (download). Vous verrez par la suite pourquoi j'ai choisi de prendre 480 kbps, et non pas 512 comme me le permet ma ligne.

Je défini ensuite les débits maximums, pour le serveur FTP, le serveur WEB, le serveur SMTP (mail), le serveur POP3 (mail), le débit maximum de ma classe par défaut, et le débit maximum pour une classe dite "lente".

${TC} qdisc add dev ${INET_DEVICE} root handle 1: htb default 20
${TC} class add dev ${INET_DEVICE} parent 1: classid 1:1 htb rate ${MAX_UPLOAD}kbit ceil ${MAX_UPLOAD}kbit burst 6k

Avec cette regle, on crée la classe parent, ayant un débit de 128Kbps (MAX_UPLOAD), que l'on identifie par l'id 1:1. On défini aussi quelle sera la classe fille par défaut: ça sera la classe idéntifiée par l'id 20.

${TC} qdisc add dev ${LOCAL_DEVICE} root handle 2: htb
${TC} class add dev ${LOCAL_DEVICE} parent 2: classid 2:1 htb rate ${MAX_DOWNLOAD}kbit ceil ${MAX_DOWNLOAD}kbit burst 6k

On fais la meme chose que ci dessus, mais cette fois, on ne défini pas de classe par défaut, l'id de classe est 2:1. C'est cette classe qui servira a limiter les débits entrant (en fait, on limite sur la sortie de l'interface locale, car on ne peut faire de la QoS que sur le traffic sortant!

${TC} class add dev ${LOCAL_DEVICE} parent 2:1 classid 2:10 htb rate ${MAX_DOWNLOAD}kbit ceil ${MAX_DOWNLOAD}kbit burst 6k prio 9
${TC} filter add dev ${LOCAL_DEVICE} parent 2:0 protocol ip prio 9 handle 100 fw flowid 2:10
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.3      -j MARK --set-mark 100
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.4      -j MARK --set-mark 100
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.5      -j MARK --set-mark 100
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.12      -j MARK --set-mark 100
${IPTABLES} -t mangle -A FORWARD -d 192.168.1.209      -j MARK --set-mark 100

On crée une classe fille de la classe 2:1 (donc pour le traffic entrant par internet, et sortant sur l'interface locale). On donne une prioritée basse (poids 9, plus le poids est élevé, moins le traffic est priviligié.) On défini a l'aide de "tc filter add" que cette classe prendra tout les paquets ayant la marque 100. Les regles iptables marquent les paquets arrivant par la table FORWARD (routage) et a destination des ip respectives 192.168.1.3, .4, .5, ... Cela permet de brider le téléchargement depuis ces adresses.

${TC} class add dev ${INET_DEVICE} parent 1:1 classid 1:20 htb rate ${DEFAULT}kbit ceil ${MAX_UPLOAD}kbit burst 6k prio 3

On crée la classe par défaut, sur l'upload via ppp0 cette fois ci. (et non plus via eth0). La prioritée choisie est moyenne (3). On défini aussi un petit truc assez sympatique:
Si personne n'utilise l'upload, alors on utilisera un "ceil" de 128kbps, et non pas uniquement 100 comme défini dans les variables de début du script. Par contre, si quelque chose est déja en cours d'upload, alors la limite sera bien de 100kbps. Tres pratique pour ne pas se "bousiller" les quelques kilobits qui sont a notre disposition!

${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:10 htb rate ${SPEED}kbit ceil ${MAX_UPLOAD}kbit burst 6k prio 1
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 1 handle 10 fw flowid 1:10
${IPTABLES} -t mangle -A OUTPUT  -p tcp --dport 6667 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --dport 6667 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --sport 6667 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --sport 7000 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --sport 6668 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --sport 6669 -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p icmp             -j MARK --set-mark 10
${IPTABLES} -t mangle -A OUTPUT  -p icmp             -j MARK --set-mark 10
${IPTABLES} -t mangle -A OUTPUT  -p tcp --dport 22   -j MARK --set-mark 10
${IPTABLES} -t mangle -A OUTPUT  -p tcp --sport 22   -j MARK --set-mark 10
${IPTABLES} -t mangle -A FORWARD -p tcp --dport 22   -j MARK --set-mark 10
# cs
${IPTABLES} -t mangle -A FORWARD -p udp --sport 27005 -j MARK --set-mark 10

La classe la plus importante pour moi! Celle qui permet d'avoir des latences tres faibles sur les protocoles dynamiques (ssh, irc, ping, jeux). Ces lignes créent donc une classe dite "rapide" ayant une prioritée tres haute (1), limitée a 128kbps.
Les différentes regles iptables permettent de matcher les paquets dits "dynamiques" par moi meme: soit les paquets en routage (FORWARD) a destination des ports par défaut d'IRC, de ssh, en source, d'IRC (j'ai un serveur irc), et d'ssh.

${TC} class add dev ${INET_DEVICE} parent 1:1 classid 1:30 htb rate ${SLOW}kbit prio 5
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 5 handle 30 fw flowid 1:30
#${IPTABLES} -t mangle -A FORWARD -p tcp --sport 4662   -j MARK --set-mark 30
#${IPTABLES} -t mangle -A FORWARD -p udp --sport 4665   -j MARK --set-mark 30
#${IPTABLES} -t mangle -A FORWARD -p tcp --dport 4662   -j MARK --set-mark 30
#${IPTABLES} -t mangle -A FORWARD -p udp --dport 4665   -j MARK --set-mark 30

Une regle tres pratique anti p2p, ou pour limiter, sans couper nimporte quel traffic que vous ne voulez pas. Il vous suffira pour l'utiliser de marquer les paquets avec iptables de la marque "30".
Je ne l'utilise plus chez moi, ne faisant pas de p2p.

${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:21 htb rate ${WEB}kbit prio 2
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 2 handle 21 fw flowid 1:21
${IPTABLES} -t mangle -A OUTPUT  -p tcp --sport 80   -j MARK --set-mark 21
${IPTABLES} -t mangle -A FORWARD  -p tcp --sport 80   -j MARK --set-mark 21

La classe permetant de limiter le traffic provenant de mon serveur web. La classe a une prioritée haute (2), ce qui donne de bons résultats au niveau des temps de réponse du serveur web, depuis l'extérieur.
Si vous utilisez du https, il faudra que vous marquiez le port 443 avec la marque 21, grace a iptables.

${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:22 htb rate ${FTP}kbit prio 4
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 3 handle 22 fw flowid 1:22
${IPTABLES} -t mangle -A OUTPUT  -p tcp --sport 21   -j MARK --set-mark 22
${IPTABLES} -t mangle -A FORWARD  -p tcp --dport 21   -j MARK --set-mark 22

Comme la classe web, voici la classe permettant de limiter le traffic provenant du serveur FTP. Cette fois ci, on ne donne qu'une prioritée "faible" (4) aux paquets. Le temps de réponse sur un serveur FTP n'étant pas un probleme.

${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:23 htb rate ${SMTP}kbit prio 4
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 4 handle 23 fw flowid 1:23
${IPTABLES} -t mangle -A OUTPUT  -p tcp --sport 25   -j MARK --set-mark 23
${IPTABLES} -t mangle -A OUTPUT  -p tcp --dport 25   -j MARK --set-mark 23
${IPTABLES} -t mangle -A FORWARD  -p tcp --dport 25   -j MARK --set-mark 23
${IPTABLES} -t mangle -A FORWARD  -p tcp --sport 25   -j MARK --set-mark 23

Comme la classe FTP et web, voici la classe SMTP, effectivement, emetre un email depuis mon serveur mail, n'est pas quelque chose qui doit être accompli dans la seconde, ainsi, j'ai donné une prioritée faible, et une limite de débit assez basse. Les mails partent donc assez "lentement".

${TC} class add dev ${INET_DEVICE} parent 1:20 classid 1:210 htb rate ${POP}kbit prio 4
${TC} filter add dev ${INET_DEVICE} parent 1:0 protocol ip prio 4 handle 210 fw flowid 1:210

${IPTABLES} -t mangle -A FORWARD  -p tcp --sport 110   -j MARK --set-mark 210

Et pour finir, des personnes utilisent mon systeme de mail directement depuis chez eux, ils récuperent donc leur emails depuis mon serveur pop.

Pour aller plus loin

Comment fonctionne la gestion de la prioritée ?

Lorsque le systeme doit envoyer un paquet, il les place dans une file d'attente, puis des que le paquet arrive a la fin de la liste, il est envoyé.
Les scheduleurs permettent de ne pas utiliser bettement cette file: Quand des paquets non prioritaires, ou ayant une prioritée plus faible qu'un nouveau paquet arrivant, le paquet ayant la prioritée la plus élevée passe devant tout le monde.

Mais il reste un problème: sur un lien ADSL, l'émission d'un paquet peut prendre du temps, et uniquement un seul paquet peut passer a la fois. (un peu comme dans un portillon)
Le problème étant que si un paquet "non" prioritaire est en cours d'émission, et un paquet prioritaire arrive a ce moment la, on est obligé de finir le transfert!
Voilà pourquoi vous pouvez arrivez a des sortes de yoyo (entre 70 et 350ms chez moi), lors d'émission de gros paquets!

Crédits

Je vous remercie d'avoir lu cet article, j'espere qu'il vous aura un peu éclairé sur le fonctionnement de la QoS, ses avantages, et ses limites. Si vous utilisez mon script de QoS, j'aprécierais un mail me racontant votre degré de satisfaction, on d'insatisfaction! Si il ne vous conviens pas dutout, ou si vous avez des remarques, n'hésitez pas, j'aurais plaisir a vous répondre, et modifier mon article si je me suis trompé quelque part!
Mon email: ed@debian-fr.net

Liens

Cet article sera également publié sur le site Coredump.


XHTML 1.1 strict. Design & code par Laurent Coustet (générée en 0.049879s )