Fonctions de contrôle dynamique

Les fonctions de contrôle dynamique implémentent un processus de prise de décision en cours d’exécution (at runtime). En effet, ces fonctions permettent aux administrateurs de remonter des informations à partir de l’infrastructure physique, de les analyser, puis de générer des nouvelles politiques qui seront installées sur l’infrastructure physique. Par ailleurs, il est à noter que les fonctions de contrôle dynamique sont exécutées au niveau de l’hyperviseur d’AirNet (qui est lui même exécuté au-dessus d’un contrôleur SDN) et non pas au niveau du plan de données. Dans le chapitre5nous allons revenir plus en détails sur l’exécution et l’implémentation de ces fonctions de contrôle dynamique.

Pour mettre en œuvre ce concept, AirNet fournit une primitive sous la forme d’une annotation (patron de conception «décorateur»). Cette dernière transforme une simple fonction en une politique dynamique qui peut être composée et installée sur les contrôleurs SDN. La figure 30 expose les deux structures possibles pour un décorateur de fonction dynamique, suivant si l’administrateur souhaite remonter des paquets réseau complets (data="packet") ou uniquement des statistiques (data="stat") sur un flux.

@DynamicControlFct_{( data="p a c k e t " , l i m i t=i n t , s p l i t =[h ] )} @DynamicControlFct( data=" s t a t " , every=i n t , s p l i t =[h ] )

FIGURE30. Décorateur d’une fonction de contrôle dynamique

4.4.1.1 Collecte des paquets

Dans le cas où l’administrateur souhaite remonter un paquet réseau complet, il doit aussi spécifier deux autres paramètres. Le premier estlimitet il permet d’indiquer le nombre de paquets qu’on souhaite remonter vers la fonction réseau. Le deuxième, quant à lui, estsplit

et il permet de discriminer les différents paquets qui sont envoyés vers la fonction réseau. Le paramètre splitreprésente concrètement une liste de champs d’en-tête (par exemple split=["nw_src","tp_dst"]) qui est utilisée par l’hyperviseur d’AirNet comme une clé afin

d’identifier les sous-flux de paquets sur lesquels le paramètrelimits’applique. Si la valeur du paramètresplitest positionnée àNone, cela signifie que le paramètrelimitcomptabilisera

Chapitre 4 : AirNet : langage et modèle de programmation

paramètrelimitest positionné àNone, cela équivaut à dire que tous les paquets du flux doivent

passer par cette fonction et qu’aucune limite n’est fixée.

Afin de mieux appréhender le concept de fonction dynamique, nous allons considérer un exemple qui consiste en la définition d’un service de contrôle d’accès dynamique. Pour ce faire, nous allons réutiliser la topologie virtuelle illustrée à la figure28.

@DynamicControlFct( data="p a c k e t " , l i m i t =1, s p l i t =["nw_src " ] ) d e f a u t h e n t i c a t e ( p a c k e t ) :

i p = p a c k e t . f i n d ( ’ ipv4 ’ ) h o s t I P = i p . s r c i p . t o S t r ( ) i f w h i t e l i s t . has_key ( h o s t I P ) :

fwd_policy = ( match ( edge =’IO ’ , nw_src=hostIP , tp_dst =80) >> t a g_{(" authFlows ") >> forward (" Fab ") )}

r e t u r n fwd_policy e l s e:

r e j e c t _ p o l i c y = ( match ( edge =’IO ’ , nw_src=h o s t I P ) >> drop ( ) ) r e t u r n r e j e c t _ p o l i c y

L’extrait ci-dessus représente la définition d’une fonction de contrôle dynamique, sachant que chaque définition inclut trois parties : le décorateur, le traitement effectué à l’intérieur de la fonction et en dernier la nouvelle politique qui est retournée. Ainsi, pour la partie décorateur, nous avons spécifié ces trois paramètres :

• data=’packet’: on souhaite que l’hyperviseur remonte des paquets réseau entiers et

non pas des statistiques.

• limit=1: on est intéressé uniquement par le premier paquet de chaque flux.

• split=["nw_src"] : on veut que l’hyperviseur applique une discrimination entre les paquets remontés en se basant sur leur adresse IP source.

En conséquence, le décorateur ci-dessus signifie que la fonction authenticate va être appelée pour le premier paquet provenant de chaque nouvelle adresse IP source. Par la suite, la fonction authenticate teste si l’adresse source de ce paquet est autorisée ou non (elle

appartient à une liste blanche ou non). Si oui, une nouvelle politique de relayage est renvoyée pour cette nouvelle source (fwd_policy), sinon, une politique qui va bloquer les paquets de

cette source est renvoyée (reject_policy).

La définition de la fonction dynamique étant terminée, on peut maintenant la composer avec d’autres politiques d’AirNet, comme cela est montré dans l’extrait de programme ci-dessous où on souhaite contrôler l’accès de tous les clients qui veulent accéder au serveur web :

match( edge =’IO ’ , nw_dst=PUBLIC_IP , tp_dst=HTTP) >> a u t h e n t i c a t e ( )

4.4.1.2 Collecte des statistiques

Les fonctions de contrôle dynamique permettent aussi de remonter des statistiques sur les flux traités. Pour ce faire, l’administrateur doit positionner la valeur du paramètre du décorateur data à stat. Par ailleurs, dans le cas des statistiques il n’existe pas de paramètre limit, celui-là étant remplacé par un paramètre everyqui permet de définir la

actuellement des informations sur le nombre et la taille des paquets traités par une règle particulière.

A titre d’exemple, nous allons considérer la politique suivante dont l’objectif est de surveiller la consommation de données des utilisateurs du réseauNet.A. Pour ce faire, nous

utilisons une fonction dynamique appelée checkDataCap qui vérifie que chaque hôte ne peut télécharger (réceptionner) au maximum que 10 méga octets toutes les trente secondes (seuil spécifié dans le programme ci-dessous par la variabledata_threshold). S’il dépasse

ce quota, ses communications seront bloquées pour les prochaines trente secondes, puis il sera à nouveau autorisé à communiquer. Les détails d’implémentation de cette fonction sont donnés dans l’extrait de programme ci-dessous :

@DynamicControlFct( data=" s t a t " , every =30, s p l i t =["nw_dst " ] ) d e f checkDataCap ( s t a t ) :

i f s t a t . nw_dst i n h o s t s _ p e r m i s s i o n . k e y s ( ) :

data_amount = s t a t . byte_count − hosts_data_amount [ s t a t . nw_dst ]

hosts_data_amount [ s t a t . nw_dst ] = s t a t . byte_count i f h o s t s _ p e r m i s s i o n [ s t a t . nw_dst ] == " a l l o w " :

i f data_amount > d a t a _ t h r e s h o l d :

h o s t s _ p e r m i s s i o n [ s t a t . nw_dst ] = " deny "

r e t u r n ( match ( edge="IO " , nw_dst=s t a t . nw_dst ) >> drop ) e l s e:

h o s t s _ p e r m i s s i o n [ s t a t . nw_dst ] = " a l l o w "

r e t u r n _{( match ( edge="IO " , nw_dst=s t a t . nw_dst ) >> forward (" Net . A") )} e l s e:

hosts_data_amount [ s t a t . nw_dst ] = s t a t . byte_count i f s t a t . byte_count > d a t a _ t h r e s h o l d :

h o s t s _ p e r m i s s i o n [ s t a t . nw_dst ] = " deny "

r e t u r n ( match ( edge="IO " , nw_dst=s t a t . nw_dst ) >> drop ) e l s e:

h o s t s _ p e r m i s s i o n [ s t a t . nw_dst ] ="a l l o w "

Considérant les paramètres qui ont été passés au décorateur de la fonctioncheckDataCap, cette dernière va recevoir toutes les trente secondes des statistiques pour chaque destination distincte du flux de paquets qui est redirigé vers cette fonction (every=30 et

split=["nw_dst"]). Dans un premier temps, la fonctioncheckDataCapteste si la destination est déjà identifiée (stat.nw_dst in hosts_permission.keys()), si non, elle initialise ses

paramètres de consommation, si oui, elle commence à tester si la consommation de la source dépasse la limite fixée ou non. Dans le cas ou l’hôte a dépassée la limite fixée, une politique qui rejette (drop) les communications de l’hôte en question est installée, sinon

aucune modification n’est effectuée sur la politique de contrôle globale.

Afin de remonter uniquement des statistiques sur la quantité de données que consomme les utilisateurs du réseauNet.A, nous composons cette fonction dynamique avec un filtre

AirNet, comme cela est montré dans l’extrait ci-dessous. Aussi, nous avons composé, de manière parallèle, une action de commutation (forward) avec la fonction dynamique afin

d’assurer le relayage des paquets tout en implémentant une fonction de surveillance de consommation pour tous les hôtes du réseauNet.A.

Chapitre 4 : AirNet : langage et modèle de programmation