ajout dossier, cours, images sur le routage et algorithme de routage

Routage/README.md

@@ -0,0 +1,207 @@
+## Réseaux et algorithmes de routage
+
+> Processus fondamental des réseaux informatiques, le routage  permet d’acheminer les paquets de données d’une source à une destination à travers un réseau.
+
+### Le Programme
+
+<img src="assets/bo.png" alt="bo_routage" style="zoom:50%;" />
+
+
+
+<img src="assets/bo_2.png" alt="bo_graphe" style="zoom:50%;" />
+
+
+
+Et oui, encore des graphes !
+
+--------------
+
+### Le routage, pourquoi faire ?
+
+Lorsqu’un ordinateur envoie des données à un autre ordinateur situé sur un réseau différent, ces données doivent transiter par plusieurs équipements intermédiaires, appelés routeurs, qui déterminent le meilleur chemin à suivre.
+
+L’acheminement efficace des données est crucial pour garantir la rapidité, la fiabilité et l’optimisation des ressources réseau. Sans un bon algorithme de routage, les réseaux seraient sujets à des retards importants, des congestions et des interruptions de communication.
+
+
+
+<img src="assets/filius.png" alt="routage_filius" style="zoom: 67%;" />
+
+
+
+### Mais dis moi Jamy, qu'est ce qu'un routeur ?
+
+
+
+<img src="assets/allo.jpg" alt="allo" style="zoom:67%;" />
+
+
+
+Un routeur est en quelque chose un hôte, un ordinateur, qui possède deux périphériques réseau, qui disposent d'une adresse IP chacun.
+
+Lorsque des données transitent sur le réseau, chaque routeur va en recevoir, et pourra décider de les transmettre à telle ou telle machine. 
+Pour ne pas se tromper et faire le bon choix, le routeur se servira de **tables de routage.**
+
+Celles-ci peuvent être définies de manière **statique**, de manière **dynamique** ou tout simplement mises en place par défaut.
+
+- **Routage statique** : Les routes sont définies manuellement par l’administrateur réseau et restent inchangées, sauf en cas d’intervention humaine.
+- **Routage dynamique** : Les routes sont déterminées automatiquement grâce à des protocoles de routage qui s’adaptent aux changements du réseau.
+- **Routage par défaut** : Utilisation d’une route unique lorsqu’aucune autre route spécifique n’est définie.
+
+
+
+<img src="assets/yo.jpg" alt="yo" style="zoom:67%;" />
+
+
+
+### Mais alors, ces tables de routage ?
+
+Supposons un réseau représenté par ce graphe :
+
+![reseau_exemple](assets/reseau_exemple.jpg)
+
+
+
+
+
+Certaines tables de routage pourraient être celles-ci :
+
+### Table de routage du routeur A
+| Destination | Routeur suivant | Distance |
+| ----------- | --------------- | -------- |
+| B           | B               | 1        |
+| C           | C               | 1        |
+| D           | D               | 1        |
+| E           | C               | 2        |
+| F           | C               | 2        |
+| G           | C               | 3        |
+
+### Table de routage du routeur B
+| Destination | Routeur suivant | Distance |
+| ----------- | --------------- | -------- |
+| A           | A               | 1        |
+| C           | A               | 2        |
+| D           | D               | 1        |
+| E           | D               | 2        |
+| F           | A               | 3        |
+| G           | D               | 3        |
+
+
+
+Comme on peut le voir, on dispose de plusieurs informations : 
+
+Depuis le routeur X, pour atteindre une destination, on va indiquer par quel routeur on passera, et la distance / le coût pour atteindre notre destination.
+
+On parle alors de **passerelle** quand un routeur permet d'accéder à un sous-réseau différent du notre. 
+
+
+
+### Les algorithmes de routage
+
+Il paraît évident qu'un réseau aussi grand qu'internet ne peut pas reposer sur des tables de routages manuelles. On a donc décidé d'automatiser cette tâche à l'aide d'algorithmes.
+Ainsi, ceux-ci permettent aux routeurs de choisir le chemin optimal pour transmettre les données. On distingue deux grandes catégories :
+
+- **Les algorithmes à état de liens (Link-State)** : Chaque routeur construit une carte du réseau et calcule les meilleurs chemins avec des algorithmes comme **Dijkstra**.
+- **Les algorithmes à vecteur de distance (Distance-Vector)** : Chaque routeur échange des informations avec ses voisins et met à jour ses routes selon l’algorithme de **Bellman-Ford.**
+
+#### RIP (Routing Information Protocol)
+
+Ici, chaque routeur va attribuer une distance la plus courte possible à chaque destination accessible.
+Cette distance sera indiquée en unité de sauts (hop), avec un saut = un routeur traversé.
+
+Pour commencer, chaque routeur va écrire dans sa table les plus proches voisins, c'est à dire les routeurs accessibles à 0 de distance.
+
+Puis, toutes les 30 secondes, chaque routeur va propager les informations de  sa table vers ses voisins immédiats, qui mettront leur propre table à jour avec ces informations, notamment si un chemin plus court vers une destination existe !
+
+Puis que l'on dispose d'un routeur comme **direction**, et d'une **distance**, on a donc un **vecteur**.
+
+**Attention** ! 
+
+Si un routeur (et donc un réseau) n'est plus accessible passé 3 minutes, il sera supprimé des tables de routages.
+
+
+
+À retenir : 
+
+- Distance en terme de sauts (ou hop en anglais)
+- Chaque routeur ne possède les informations que sur son voisinnage direct. On parle de ***routing by rumor*** : aucune vision globale du réseau, on fait confiance aux voisins pour savoir ce qu'il en est.
+- Au delà de 15 sauts, on considère un routeur inaccessible.
+- Utilise l’algorithme à vecteur de distance de Bellman-Ford et est simple à configurer, mais limité en performance.
+- Convient aux petits réseaux
+- Premiere algorithme de routage de l'histoire
+
+
+
+
+
+<img src="assets/Vector_Distance.png" alt="resume_rip"  />
+
+
+
+
+
+#### OSPF (Open Shortest Path First)
+
+Basé sur l’algorithme de Dijkstra, il est plus rapide et plus efficace que RIP. 
+
+Mis au point pour combler les lacunes du RIP, il est plus complet mais également plus complexe.
+
+- Tous les routeurs ont une vision globale du réseau.
+- Les distances sont mesurées en termes de coûts d'une liaison ou de débit d'une liaison.
+- Le coût d'une liaison en OSPF est donné par la formule : 
+
+
+$$
+\text{coût} = \frac{10^8}{d}
+$$
+
+
+où d est le débit nominal.
+
+- Chaque réseau pourra être représenté sous forme de graphe.
+- On recherchera les routes les moins couteuses, et sans cycle.
+- Chaque routeur devient alors la racine d'un arbre contenant les meilleurs routes.
+
+
+
+<img src="assets/Dijkstra_Animation.gif" alt="dijikstra" style="zoom:150%;" />
+
+
+
+
+
+
+
+Enfin, il reste un algorithme :
+
+**BGP (Border Gateway Protocol)** : Utilisé pour l’échange de routes entre différents fournisseurs d’accès à Internet (FAI).
+
+Que nous ne verrons pas cette année.
+
+Merci jamy ! 
+
+![merci jamy](assets/jamy.png)
+
+
+
+
+
+-----------
+
+### Sources
+
+- Hatier prépabac
+- [Site d'Olivier Duranton](https://www.duranton.net/?darkmode=non&niveau=terminaleNSI&chapitre=11)
+- Leçon réseau et algorithme de routage préparée lors du Capes  (et j'ai eu une bonne note, eh oui)
+
+--------------
+
+
+
+Auteur : Florian Mathieu
+
+Licence CC BY NC
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
+
+
+

Routage/animation_djikstra.py

@@ -0,0 +1,55 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+
+# Création du graphe
+G = nx.DiGraph()
+edges = [
+    (0, 1, 4), (0, 2, 1),
+    (2, 1, 2), (1, 3, 1),
+    (2, 3, 5), (3, 4, 3)
+]
+G.add_weighted_edges_from(edges)
+
+# Position des nœuds pour affichage
+pos = nx.spring_layout(G, seed=42)
+labels = {n: str(n) for n in G.nodes()}
+
+# Initialisation de la figure
+fig, ax = plt.subplots(figsize=(6, 6))
+
+# Algorithme de Dijkstra avec animation
+def dijkstra_animation(start_node=0):
+    distances = {node: float('inf') for node in G.nodes()}
+    distances[start_node] = 0
+    visited = set()
+    steps = []
+    
+    while len(visited) < len(G.nodes()):
+        min_node = min((node for node in distances if node not in visited), key=lambda x: distances[x])
+        visited.add(min_node)
+        
+        for neighbor in G.neighbors(min_node):
+            new_distance = distances[min_node] + G[min_node][neighbor]["weight"]
+            if new_distance < distances[neighbor]:
+                distances[neighbor] = new_distance
+        
+        steps.append((visited.copy(), [(min_node, v) for v in G.neighbors(min_node)]))
+    
+    return steps
+
+steps = dijkstra_animation()
+
+def update(frame):
+    ax.clear()
+    visited, edges = steps[frame]
+    node_colors = ["green" if n in visited else "lightblue" for n in G.nodes()]
+    edge_colors = ["red" if (u, v) in edges else "black" for u, v in G.edges()]
+    
+    nx.draw(G, pos, with_labels=True, labels=labels, node_size=800, 
+            node_color=node_colors, edge_color=edge_colors, font_size=14, font_weight="bold", ax=ax)
+    edge_labels = {(u, v): G[u][v]["weight"] for u, v in G.edges()}
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=12, ax=ax)
+
+ani = animation.FuncAnimation(fig, update, frames=len(steps), repeat=False, interval=1000)
+plt.show()

Routage/dijkstra.py

@@ -0,0 +1,44 @@
+G = (["A","B","C","D","E","F","G"],
+     [("A","B",1),("A","D",2),("A","C",3),
+      ("B","D",5),("B","E",1),("C","D",4),
+      ("C","F",1),("D","E",1),("D","F",1),
+      ("D","G",2),("E","G",3),("F","G",4)])
+
+IND = {"A":0,
+       "B":1,
+       "C":2,
+       "D":3,
+       "E":4,
+       "F":5,
+       "G":6}
+
+def select_min(t1, t2):
+    mini = IND[t2[0]]
+    for s in t2[1:]:
+        if t1[mini] > t1[IND[s]]:
+            mini = IND[s]
+    return mini
+
+def dijkstra(g, s):
+    res = [float('inf') for _ in g[0]]
+    res[IND[s]] = 0
+    a_faire = [e for e in g[0]]
+    while a_faire != []:
+        ind_courrant = select_min(res, a_faire)
+        sommet_courrant = g[0][ind_courrant]
+        a_faire.remove(sommet_courrant)
+        cout_courrant = res[ind_courrant]
+        for l in g[1]:
+            if l[0]==sommet_courrant:
+                cout_tmp=l[2]+cout_courrant
+                if res[IND[l[1]]]>=cout_tmp:
+                    res[IND[l[1]]] = cout_tmp
+    return res
+            
+G2 = (["A","B","C","D","E"],
+      [("A","B",4),("A","C",3),("A","D",2),
+       ("B","E",1),("C","D",1),("C","E",1),("D","E",1)])   
+    
+    
+    
+