Altq est un outil permettant de faire de la réservation de bande
passante.
Attention on ne peut réserver que dans le sens machine vers
internet. Altq ne permet pas de faire de la réservation sur les paquets
entrants.
On peut par contre réserver, pour un protocole donné (par exemple je veux
allouer 20 % de ma bande passante à SSH) , pour une machine se trouvant dans
votre réseau local une certaine quantité de la bande passante disponible
(dans ce cas je veux permettre à ma machine personnelle de conserver 90% de la
bande passante par rapport aux autres machines de mon réseau local... j'ai le
droit non ;-)).
Un usage pratique actuellement peut être de limiter la bande passante pour le
téléchargement sur votre machine de fichiers partagés (Kaaza,.....).
N'essayez pas cela avec un modem RTC, cela risque de ne pas marcher.
Ainsi si vous utilisez une machine OpenBSD comme passerelle, altq sera installé
par défaut. Il se trouve dans les sources dans /usr/src/usr.sbin/altq
Vous trouverez aussi un grand nombre de fichiers d'exemple dans /usr/share/altq.
Tout alq est géré par /etc/pf.conf à partir
de la 3.3.
Pour lancer altq au démarrage de la machine modifier dans /etc/rc.conf la ligne
altqd_flags=NO en altqd_flags="".
Comprendre
Pour comprendre le principe, voilà de façon très simplifié, ce qu'il faut
retenir. Altq va gérer des paquets et les placer dans des queues en attente de
leur tour avant d'être envoyés. Suivant l'algorithme la façon de définir les
priorités va changer.
Il en existe un certain nombre qui ne sont pas toutes implémentées dans altq
d'OpenBSD. La plus utilisée étant CBQ.
FIFOQ (First In First Out Queuing) : La plus basique, le premier paquet
arrivé dans la queue unique est le premier dehors.
PQ ( Priority Queuing) : Gére plusieurs queues, et place les paquets
dans les queues correspondant à l'ordre de priorité. On vide donc en premier
la queue qui a un ordre de priorité important. Le problème posé est que
lorsque le trafic devient important la queue la moins prioritaire risque de ne
plus être vidée.
WFQ (Weighted Fair Queuing) : On gère ici plusieurs queue en fonction du
flux puis on utilise un coefficient de pondération. Cela permet à tous les
paquets de finir par partir, même si la priorité qui est la leur est faible. Cette
méthode semble la mieux, mais complexe à mettre en oeuvre.
SFQ (Stochastic Fairness Queuing) : Une version simplifié de WFQ.
CBQ (Class Based Queuing) : Le plus utilisé. Cela est géré par Classe.
Chaque classe ayant sa propre queue et dispose d'une partie de la bande passante
qui doit être indiquée. On peut créer des classes filles qui vont alors se
partager la bande passante de la classe mère.
RED (Random Early Detection) : Méthode qui permet de jeter des paquets
de manière aléatoire et préventive afin d'éviter la congestion. Cette
méthode peut être associé à CBQ.
Il en existe d'autres. En fait si vous ne faites rien le week-end prochain vous
pouvez mettre au point la votre. Mais cela est loin d'être un sujet simple.
Exemple
Comme je l'ai déjà dit vous disposez d'exemples dans le répertoire /usr/share/altq.
Mais pour l'occasion nous allons en détailler un ou deux.
Nous souhaitons dans cet exemple limiter la bande passante de 1 M au profit
d'une machine de notre réseau.
Cela se fait en trois temps :
1 - Je crée la classe racine en indiquant le nom de la carte réseau, la taille
de mon lien, et la méthode que je souhaite utiliser.
2 - Je crée les "sous-classes", une pour ma machine, une pour les
autres en donnant un nom et en indiquant la bande passante que je souhaite
donner à chacun.
3 - Je crée le filtre, en indiquant qui est moi (adresse IP, port), les autres
ayant droit à la classe par défaut.
# Définir l'interface et la taille de la bande passante utilisable, ainsi que
la méthode utilisée, ici cbq. bandwidth pour indiquer la taille.
interface fxp0 bandwidth 1M cbq
# Pour cbq nous créons des classes. Ici la classe racine. 100 indique 100% de
la bande passante pour la classe racine (pbandwidth).
class cbq fxp0 class_root NULL pbandwidth 100
# Puis on coupe en deux parties. Une pour ma machine (95% du trafic), une pour
les autres machines de mon réseau (4%... je comprends pas
# pourquoi avec cela ils se plaignent ;-)).
class cbq fxp0 class_moi class_root pbandwidth 95
class cbq fxp0 class_lesautres class_root pbandwidth 4 default
# On a terminé, reste à indiquer ou est ma machine
filter fxp0 class_moi 0 0 172.16.0.10 0 0 #
172.16.0.10 est l'adresse IP de la machine de moi.
Les options possibles après class sont :
cbq : pour une cbq class
fxp0 : Le nom de ma carte réseau
class_moi : le nom de cette classe. class_moi est une classe fille de la classe
mère class_root. Vous pouvez donner le nom que vous voulez.
class_root : le nom de la classe mère
priority : indiquer priority 3 par exemple pour donner une priorité. Par
défaut, si vous ne mettez rien, la priorité est égale à 1. Plus elle est
haute, plus la priorité est importante. 7 est le maximum, 0 le minimum.
pbandwidth : indique le pourcentage de réservation de la bande passante.
bandwidth indique la valeur.
borrow : Indique que cette classe peut utiliser la bande de sa classe parente
lorsque elle a elle même dépassé sa valeur limite. Lorsque borrow n'est pas
indiqué alors, les paquets sont rejetés lorsque la valeur limite est
dépassée.
default : Spécifie la classe par défaut à utiliser lorsque aucune classe
n'est définie.
controle : Définie la classe permettant le passage des paquets de contrôle (ICMP
RSVP IGMP).
Les options possibles après filter sont les suivantes :
fxp0 : Le nom de ma carte réseau
class_moi : le nom de la classe que j'ai crée plus haut
0 0 172.16.0.10 0 0 indique dans l'ordre : l'adresse de destination avec le
masque si nécessaire, le port de destination, l'adresse source plus le masque,
le port source, et le protocole (6 pour tcp, 17 pour udp)
Exemple plus complexe
On cherche ici à limiter le débit sur un protocole donnné.
# Définir l'interface et la taille de la bande passante utilisable, ainsi que
la méthode utilisée, ici cbq. bandwidth pour indiquer la taille.
interface fxp0 bandwidth 1M cbq
class cbq fxp0 class_root NULL pbandwidth 100
# On crée les sous classes, une pour les paquets de service avec la classe
réservée ctl_class et l'option control.
# Une pour tous les autres paquets, en lui indiquant en cas de problème de
pouvoir augmenter ses besoins (borrow).
class cbq fxp0 ctl_class class_root pbandwidth 5 control
class cbq fxp0 class_pricipale class_root borrow pbandwidth 95 default
# On veut limiter le ftp, on recrée donc plusieurs sous classes de
class_principale
# La première pour les paquets tcp non définis plus loin.
class cbq fxp0 class_tcp class_principale borrow pbandwidth 10 red
filter cbq fxp0 class_tcp 0 0 0 0 6
# La deuxième pour les paquets des data ftp
class cbq fxp0 class_ftp class_principale borrow pbandwidth 20 red
filter fxp0 class_ftp 0 0 0 20 6
filter fxp0 class_ftp 0 20 0 0 6
# La troisième pour les paquets ssh
class cbq fxp0 class_ssh class_principale borrow pbandwidth 50 red
filter fxp0 class_ssh 0 0 195.9.12.2 22
6 # Vers la machine 195.9.12.2 (6 pour indiquer
des paquets tcp)
filter fxp0 class_ssh 0 22 0 0 6
# La quatrième pour les paquets dns donc udp et tcp
class cbq fxp0 class_dns class_principale borrow pbandwidth 20 red
filter fxp0 class_dns 0 0 0 53 6
filter fxp0 class_dns 0 20 0 53 17
Documentation