inetdoc.net

Tout d'abord, nous allons configurer des gestionnaires de mise en file d'attente dans lesquels nous allons classifier le trafic. Nous créons un gestionnaire htb composé de 6 classes avec des priorités croissantes. Nous avons alors des classes qui obtiendront le débit alloué et qui pourront, de plus, utiliser la bande passante dont les autres classes n'ont pas besoin. Rappelons que les classes de plus hautes priorités (correspondant aux nombres prio les plus faibles) obtiendront en premier l'excès de bande passante. Notre liaison ADSL à un flux descendant de 2Mbits/s et un flux montant de 300 kbits/s. J'utilise un débit de seuil (ceil rate) de 240 kbits/s car, au-delà de cette limite, les problèmes de latence commence à prendre de l'ampleur. Ceci est dû au remplissage d'un tampon placé quelque part entre nous et les hôtes distants.

Ajuster la variable CEIL à 75% de votre bande passante montante maximum et ajuster le nom de l'interface (eth0 dans la suite) à celle qui a l'adresse publique Internet. Exécutez ce qui suit dans un shell root :

CEIL=240
tc qdisc add dev eth0 root handle 1: htb default 15
tc class add dev eth0 parent 1: classid 1:1 htb rate ${CEIL}kbit ceil ${CEIL}kbit
tc class add dev eth0 parent 1:1 classid 1:10 htb rate 80kbit ceil 80kbit prio 0
tc class add dev eth0 parent 1:1 classid 1:11 htb rate 80kbit ceil ${CEIL}kbit prio 1
tc class add dev eth0 parent 1:1 classid 1:12 htb rate 20kbit ceil ${CEIL}kbit prio 2
tc class add dev eth0 parent 1:1 classid 1:13 htb rate 20kbit ceil ${CEIL}kbit prio 2
tc class add dev eth0 parent 1:1 classid 1:14 htb rate 10kbit ceil ${CEIL}kbit prio 3
tc class add dev eth0 parent 1:1 classid 1:15 htb rate 30kbit ceil ${CEIL}kbit prio 3
tc qdisc add dev eth0 parent 1:12 handle 120: sfq perturb 10
tc qdisc add dev eth0 parent 1:13 handle 130: sfq perturb 10
tc qdisc add dev eth0 parent 1:14 handle 140: sfq perturb 10
tc qdisc add dev eth0 parent 1:15 handle 150: sfq perturb 10

Nous avons juste créé une arborescence htb avec un seul niveau de profondeur. Quelque chose comme ceci :

+-----------+
| racine 1: |
+-----------+
      |
+---------------------------------------+
| classe 1:1                            |
+---------------------------------------+
  |      |      |      |      |      |
+----+ +----+ +----+ +----+ +----+ +----+
|1:10| |1:11| |1:12| |1:13| |1:14| |1:15|
+----+ +----+ +----+ +----+ +----+ +----+

Nous avons configuré le gestionnaire de mise en file d'attente, mais aucune classification de paquets n'a encore été faite. Pour l'instant, tous les paquets sortants passent par la classe 1:15 (car, nous avons utilisé : tc qdisc add dev eth0 root handle 1: htb default 15). Nous devons donc maintenant indiquer où doivent aller les paquets. Ceci est la partie la plus importante.

Nous allons maintenant configurer les filtres de tel sorte que nous puissions classifier les paquets avec iptables. Je préfère vraiment le faire avec iptables car celui-ci est très souple et que nous avons un compteur de paquets pour chaque règle. De plus, avec la cible RETURN, les paquets n'ont pas besoin de traverser toutes les règles. Nous exécutons les commandes suivantes :

tc filter add dev eth0 parent 1:0 protocol ip prio 1 handle 1 fw classid 1:10
tc filter add dev eth0 parent 1:0 protocol ip prio 2 handle 2 fw classid 1:11
tc filter add dev eth0 parent 1:0 protocol ip prio 3 handle 3 fw classid 1:12
tc filter add dev eth0 parent 1:0 protocol ip prio 4 handle 4 fw classid 1:13
tc filter add dev eth0 parent 1:0 protocol ip prio 5 handle 5 fw classid 1:14
tc filter add dev eth0 parent 1:0 protocol ip prio 6 handle 6 fw classid 1:15

Nous indiquons simplement au noyau que les paquets qui ont une valeur FWMARK spécifique (handle x fw) vont dans la classe spécifiée (classid x:x). Voyons maintenant comment marquer les paquets avec iptables.

Tout d'abord, nous devons comprendre comment les paquets traversent les filtres avec iptables :

        +------------+                +---------+               +-------------+
Paquets-| PREROUTING |--- Décision----| FORWARD |-------+-------| POSTROUTING |- Paquets
entrant +------------+   de routage   +-­-------+       |       +-------------+  sortants
                             |                          |
                        +-------+                    +--------+
                        | INPUT |-- Processus locaux-| OUTPUT |
                        +-------+                    +--------+

Je suppose que toutes vos tables ont leur politique par défaut configurée à ACCEPT (-P ACCEPT), ce qui devrait être le cas si vous n'avez pas encore touché à iptables. Notre réseau privé est une classe B avec l'adresse 172.17.0.0/16 et notre adresse publique est 212.170.21.172.

Nous indiquons au noyau de faire de la traduction d'adresse NAT; les clients du réseau privé peuvent alors commencer à dialoguer avec l'extérieur.

echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -s 172.17.0.0/255.255.0.0 -o eth0 -j SNAT --to-source 212.170.21.172

Vérifions maintenant que les paquets transitent bien à travers 1:15 :

tc -s class show dev eth0

Vous pouvez commencer à marquer les paquets en ajoutant les règles dans la chaîne PREROUTING de la table mangle.

iptables -t mangle -A PREROUTING -p icmp -j MARK --set-mark 0x1
iptables -t mangle -A PREROUTING -p icmp -j RETURN

Vous devriez maintenant être capable de voir l'évolution du compteur de paquets quand vous pinguez des sites sur Internet depuis les machines du réseau privé. Vérifiez que le compteur de paquets augmente dans 1:10 :

tc -s class show dev eth0

Nous avons mis -j RETURN de manière à ce que les paquets ne traversent pas toutes les règles. Les paquets icmp ne scruteront pas les autres règles définies sous RETURN. Gardez ceci à l'esprit. Nous commençons maintenant à ajouter d'autres règles pour gérer les champs TOS :

iptables -t mangle -A PREROUTING -m tos --tos Minimize-Delay -j MARK --set-mark 0x1
iptables -t mangle -A PREROUTING -m tos --tos Minimize-Delay -j RETURN
iptables -t mangle -A PREROUTING -m tos --tos Minimize-Cost -j MARK --set-mark 0x5
iptables -t mangle -A PREROUTING -m tos --tos Minimize-Cost -j RETURN
iptables -t mangle -A PREROUTING -m tos --tos Maximize-Throughput -j MARK --set-mark 0x6
iptables -t mangle -A PREROUTING -m tos --tos Maximize-Throughput -j RETURN

Donnons la priorité aux paquets SSH :

iptables -t mangle -A PREROUTING -p tcp -m tcp --sport 22 -j MARK --set-mark 0x1
iptables -t mangle -A PREROUTING -p tcp -m tcp --sport 22 -j RETURN

Une bonne idée est de donner la priorité aux paquets initiant une connexion tcp, à savoir ceux qui ont le bit SYN activé :

iptables -t mangle -I PREROUTING -p tcp -m tcp --tcp-flags SYN,RST,ACK SYN -j MARK --set-mark 0x1
iptables -t mangle -I PREROUTING -p tcp -m tcp --tcp-flags SYN,RST,ACK SYN -j RETURN

Et ainsi de suite. Après la mise en place des règles dans la chaîne PREROUTING de la table "mangle", nous terminons par :

iptables -t mangle -A PREROUTING -j MARK --set-mark 0x6

Ainsi, le trafic non marqué est dirigé vers 1:15. En fait, cette dernière étape n'est pas nécessaire puisque la classe par défaut est 1:15. Un marquage est quand même réalisé de manière à avoir une cohérence pour l'ensemble de la configuration. De plus, il est utile d'avoir une comptabilité pour cette règle.

C'est une bonne idée de faire de même avec la chaîne OUTPUT. Répétez ces commandes avec -A OUTPUT à la place de PREROUTING (s/PREROUTING/OUTPUT/). Le trafic généré localement (sur le routeur Linux) sera alors également classifié. Je termine la chaîne OUTPUT par -j MARK --set-mark 0x3 de tel sorte que le trafic local ait une priorité plus grande.

Toute notre configuration est maintenant opérationnelle. Prenez du temps pour regarder les graphes et observer où votre bande passante est la plus utilisée et cela correspond à vos souhaits. J'ai fait ceci pendant de nombreuses heures, ce qui m'a permis d'avoir une connexion Internet fonctionnant très bien. Autrement, vous serez confronté en permanence à des "timeout" et des allocations de bande passante presque nulles pour les nouvelles connexions tcp.

Si vous repérez des classes qui sont pleines la plupart du temps, ce peut être une bonne idée de leur attacher un autre gestionnaire de mise en file d'attente de manière à ce que le partage de la bande passante soit plus équitable :

tc qdisc add dev eth0 parent 1:13 handle 130: sfq perturb 10
tc qdisc add dev eth0 parent 1:14 handle 140: sfq perturb 10
tc qdisc add dev eth0 parent 1:15 handle 150: sfq perturb 10

Il est certain que ceci peut être fait de différentes façons. Dans mon cas, j'ai un shell script /etc/init.d/packetfilter qui accepte les arguments [start | stop | stop-tables | start-tables | reload-tables]. Celui-ci configure les gestionnaires de mise en file d'attente et charge les modules du noyau nécessaires et se comporte donc comme une démon. Le même script charge les règles iptables à partir de /etc/network/iptables-rules. Je vais l'embellir un peu et le rendrait disponible sur ma page web ici