Partager la bande passante et prioriser le trafic en temps réel via HTB, quel scénario fonctionne mieux?

10

Je voudrais ajouter une sorte de gestion du trafic à notre ligne Internet. Après avoir lu beaucoup de documentation, je pense que HFSC est trop compliqué pour moi (je ne comprends pas tous les trucs de courbes, je crains de ne jamais bien faire les choses), CBQ n'est pas recommandé, et fondamentalement HTB est le moyen de allez pour la plupart des gens.

Notre réseau interne comporte trois «segments» et je voudrais partager la bande passante plus ou moins également entre ceux-ci (au moins au début). De plus, je dois prioriser le trafic en fonction d'au moins trois types de trafic (trafic en temps réel, trafic standard et trafic en vrac). Le partage de la bande passante n'est pas aussi important que le fait que le trafic en temps réel doit toujours être traité comme du trafic premium dans la mesure du possible, mais bien sûr aucune autre classe de trafic ne peut mourir de faim non plus.

La question est de savoir ce qui a plus de sens et garantit également un meilleur débit en temps réel:

  1. Création d'une classe par segment, chacune ayant le même taux (la priorité n'a pas d'importance pour les classes sans feuilles selon le développeur HTB) et chacune de ces classes a trois sous-classes (feuilles) pour les 3 niveaux de priorité (avec des priorités différentes et différents tarifs).

  2. Avoir une classe par niveau de priorité au sommet, chacune ayant un taux différent (encore une fois, la priorité n'aura pas d'importance) et chacune ayant 3 sous-classes, une par segment, tandis que les 3 de la classe en temps réel ont le prio le plus élevé, le prio le plus bas en vrac classe, etc.

Je vais essayer de rendre cela plus clair avec l'image d'art ASCII suivante:

Case 1:

root --+--> Segment A
       |       +--> High Prio
       |       +--> Normal Prio
       |       +--> Low Prio
       |
       +--> Segment B
       |       +--> High Prio
       |       +--> Normal Prio
       |       +--> Low Prio
       |
       +--> Segment C
               +--> High Prio
               +--> Normal Prio
               +--> Low Prio

Case 2:

root --+--> High Prio
       |        +--> Segment A
       |        +--> Segment B
       |        +--> Segment C
       |
       +--> Normal Prio
       |        +--> Segment A
       |        +--> Segment B
       |        +--> Segment C
       |
       +--> Low Prio
                +--> Segment A
                +--> Segment B
                +--> Segment C

Cas 1 Il semble que la plupart des gens le feraient, mais à moins que je ne lise pas correctement les détails d'implémentation HTB, le cas 2 peut offrir une meilleure hiérarchisation.

Le manuel HTB dit que si une classe a atteint son taux, elle peut emprunter à son parent et lors de l'emprunt, les classes avec une priorité plus élevée obtiennent toujours la bande passante en premier. Cependant, il indique également que les classes ayant une bande passante disponible à un niveau d'arbre inférieur sont toujours préférées à celles d'un niveau d'arbre supérieur, quelle que soit la priorité .

Supposons la situation suivante: le segment C n'envoie aucun trafic. Le segment A envoie uniquement du trafic en temps réel, aussi vite qu'il le peut (assez pour saturer le lien seul) et le segment B n'envoie que du trafic en vrac, aussi vite qu'il le peut (encore une fois, assez pour saturer le lien complet seul). Que va-t-il se passer?

Cas 1:
Le segment A-> High Prio et le segment B-> Low Prio ont tous deux des paquets à envoyer, car A-> High Prio a la priorité la plus élevée, il sera toujours programmé en premier, jusqu'à ce qu'il atteigne son taux. Maintenant, il essaie d'emprunter au segment A, mais comme le segment A est à un niveau supérieur et que le segment B-> Faible Prio n'a pas encore atteint son taux, cette classe est désormais servie en premier, jusqu'à ce qu'elle atteigne également le taux et souhaite emprunter à Segment B. Une fois que les deux ont atteint leur taux, les deux sont à nouveau au même niveau et maintenant le segment A-> High Prio va gagner à nouveau, jusqu'à ce qu'il atteigne le taux du segment A. Maintenant, il essaie d'emprunter à la racine (qui a beaucoup de trafic disponible, car le segment C n'utilise aucun de son trafic garanti), mais encore une fois, il doit attendre que le segment B-> Low Prio atteigne également le niveau racine. Une fois que cela se produit,

Cas 2:
High Prio-> Segment A et Low Prio-> Segment B ont tous deux des paquets à envoyer, encore une fois High Prio-> Segment A va gagner car il a la priorité la plus élevée. Une fois qu'il atteint son taux, il essaie d'emprunter à High Prio, qui dispose d'une bande passante de plus, mais étant à un niveau supérieur, il doit attendre à nouveau que Low Prio-> Segment B atteigne également son taux. Une fois que les deux ont atteint leur taux et que les deux doivent emprunter, High Prio-> Segment A gagnera à nouveau jusqu'à ce qu'il atteigne le taux de la classe High Prio. Une fois que cela se produit, il essaie d'emprunter à la racine, qui a encore beaucoup de bande passante (toute la bande passante de Normal Prio n'est pas utilisée pour le moment), mais il doit attendre à nouveau jusqu'à ce que Low Prio-> Segment B atteigne la limite de débit de la Classe Prio faible et essaie également d'emprunter à la racine. Enfin, les deux classes essaient d'emprunter à la racine, la priorité est prise en compte et High Prio->

Les deux cas semblent sous-optimaux, car dans les deux cas, le trafic en temps réel doit parfois attendre le trafic en vrac, même s'il reste beaucoup de bande passante qu'il pourrait emprunter. Cependant, dans le cas 2, il semble que le trafic en temps réel doive attendre moins que dans le cas 1, car il n'a qu'à attendre que le taux de trafic en vrac soit atteint, ce qui est très probablement inférieur au taux d'un segment entier (et dans le cas 1 c'est le taux qu'il doit attendre). Ou je me trompe totalement ici?

J'ai pensé à des configurations encore plus simples, en utilisant un qdisc prioritaire. Mais les files d'attente prioritaires ont le gros problème qu'elles provoquent la famine si elles ne sont pas en quelque sorte limitées. La famine n'est pas acceptable. Bien sûr, on peut mettre un TBF (Token Bucket Filter) dans chaque classe de priorité pour limiter le taux et ainsi éviter la famine, mais ce faisant, une seule classe de priorité ne peut plus saturer le lien seule, même si toutes les autres classes de priorité sont vides, le TBF empêchera que cela se produise. Et cela est également sous-optimal, car pourquoi une classe n'obtiendrait-elle pas 100% de la bande passante de la ligne si aucune autre classe n'en a besoin pour le moment?

Des commentaires ou des idées concernant cette configuration? Cela semble si difficile à faire en utilisant des qdisc tc standard. En tant que programmeur, c'était une tâche si facile si je pouvais simplement écrire mon propre ordonnanceur (ce que je ne suis pas autorisé à faire).

Mecki
la source

Réponses:

1

Si je comprends bien le htb, alors le tarif est "garanti". Cela signifie que vous avez des idées sur le taux de trafic "en temps réel". Seulement si ce taux est dépassé, il empruntera. Si plusieurs classes veulent emprunter, le prio devrait entrer en jeu. Les taux garantis devraient additionner la limite physique. Sinon, c'est trop compliqué.

À mon humble avis, le cas A ne fonctionnera jamais vraiment, car vous devez avoir une priorité ou une limitation de débit au niveau racine. Les priorités / taux dans les différents segments ne se connaissent pas et seront traités de manière égale.

La chose que vous voulez probablement est la suivante: Mettez le "taux" pour un prio faible et normal à 0 ou près de celui-ci et ajoutez "plafond" pour le reste de la bande passante, pour un prio élevé, vous garantissez un taux de 100% du physique.

AndreasM
la source