Systèmes d'exploitation et virtualisation

Un Système d'Exploitation (SE), ou Operating System (OS) en anglais, est un logiciel fondamental qui gère les ressources matérielles et logicielles d'un ordinateur. Il agit comme un intermédiaire entre l'utilisateur (ou les applications) et le matériel.

Ses fonctions principales sont :

• Gestion des ressources : Le SE alloue et désalloue les ressources du système, telles que le processeur (CPU), la mémoire vive (RAM), les périphériques d'entrée/sortie (clavier, souris, écran, disque dur), et le réseau. Il s'assure que ces ressources sont utilisées de manière efficace et équitable entre les différents programmes.
• Interface utilisateur : Il fournit une interface permettant à l'utilisateur d'interagir avec l'ordinateur. Cela peut être une interface graphique (GUI, comme Windows, macOS, Ubuntu) ou une interface en ligne de commande (CLI, comme MS-DOS, certains shells Unix).
• Abstraction matérielle : Le SE masque la complexité du matériel aux applications et aux utilisateurs. Par exemple, un programme n'a pas besoin de savoir comment écrire directement sur un disque dur ; il utilise les services du SE qui se charge des opérations de bas niveau.
• Ordonnancement des tâches : Il décide quel programme doit s'exécuter sur le CPU et pendant combien de temps. C'est crucial dans les systèmes multitâches pour donner l'impression que plusieurs programmes s'exécutent simultanément.
• Gestion des fichiers : Il organise et gère le stockage des données sur les disques, offrant des services pour créer, lire, écrire et supprimer des fichiers et des répertoires.
• Gestion de la mémoire : Il gère l'allocation de la mémoire aux programmes, s'assurant qu'ils ne se chevauchent pas et qu'ils ont suffisamment d'espace pour fonctionner.

En résumé, le SE est le chef d'orchestre de l'ordinateur, garantissant son bon fonctionnement et facilitant son utilisation.

L'histoire des systèmes d'exploitation est intrinsèquement liée à l'évolution du matériel informatique.

• Années 1940-1950 : Pas de SE Les premiers ordinateurs n'avaient pas de système d'exploitation. Les programmes étaient chargés manuellement par des opérateurs, souvent via des cartes perforées, et s'exécutaient un à la fois.
• Années 1950-1960 : Systèmes Batch (par lots) Pour optimiser l'utilisation des machines coûteuses, les programmes similaires étaient regroupés et exécutés en "lots" (batch). Un moniteur résident (un précurseur du SE) automatisait le passage d'une tâche à l'autre. L'interaction directe avec l'ordinateur était limitée.
• Années 1960-1970 : Temps Partagé (Time-Sharing) L'objectif était de permettre à plusieurs utilisateurs d'interagir simultanément avec l'ordinateur via des terminaux. Le SE alloue de petits "quanta" de temps CPU à chaque utilisateur, donnant l'illusion d'une utilisation exclusive. C'est l'ère d'UNIX.
• Années 1970-1980 : Systèmes d'exploitation pour micro-ordinateurs Avec l'avènement des micro-ordinateurs, des SE plus simples ont vu le jour, comme CP/M puis MS-DOS. Ils étaient souvent mono-utilisateur et mono-tâche.
• Années 1980-1990 : Interfaces graphiques et Multitâche Le Macintosh d'Apple (1984) et Windows de Microsoft (1985) ont popularisé les interfaces graphiques (GUI). Les SE sont devenus multitâches, permettant l'exécution simultanée de plusieurs applications.
• Années 1990-2000 : Systèmes Réseaux et Distribués Avec la croissance d'Internet, les SE ont intégré de plus en plus de fonctionnalités réseau. Les Systèmes distribués permettent à plusieurs ordinateurs de travailler ensemble comme un seul système, partageant des ressources et des calculs.
• Années 2000-présent : Systèmes Embarqués et Mobiles Les SE sont désormais partout : dans les smartphones (Android, iOS), les tablettes, les montres connectées, les voitures, les appareils électroménagers (IoT). Ce sont des Systèmes embarqués, souvent optimisés pour des ressources limitées et des tâches spécifiques. La virtualisation et la conteneurisation sont aussi devenues des tendances majeures.

Les systèmes d'exploitation peuvent être classés selon plusieurs critères :

• Monotâche / Multitâche
  • Monotâche : Ne peut exécuter qu'un seul programme à la fois. Ex: MS-DOS.
  • Multitâche : Peut exécuter plusieurs programmes "simultanément" en alternant très rapidement entre eux (ce qui donne l'impression de simultanéité). C'est le cas de la majorité des SE modernes (Windows, macOS, Linux).
• Monoutilisateur / Multiutilisateur
  • Monoutilisateur : Ne peut être utilisé que par une seule personne à la fois. Ex: Anciennes versions de Windows 95.
  • Multiutilisateur : Permet à plusieurs utilisateurs d'accéder au système et d'exécuter des programmes en même temps, chacun avec son propre environnement et ses propres droits. Ex: Linux, Windows Server.
• Temps Réel Ces SE sont conçus pour garantir que certaines opérations s'exécuteront dans des délais stricts et prévisibles. Ils sont cruciaux pour les systèmes où la réactivité est critique.
  • Temps réel strict (Hard Real-Time) : Le non-respect d'un délai peut avoir des conséquences catastrophiques (systèmes de contrôle industriel, aéronautique, médical).
  • Temps réel souple (Soft Real-Time) : Le non-respect d'un délai est indésirable mais pas fatal (systèmes multimédia, jeux vidéo).
• Mobile Optimisés pour les appareils mobiles (smartphones, tablettes), ils sont caractérisés par une gestion de l'énergie poussée, des interfaces tactiles et une connectivité permanente. Ex: Android, iOS.

Le choix du type de SE dépend fortement de l'usage et des contraintes du système informatique.

Définition d'un processus

Un processus est une instance d'un programme en cours d'exécution. Lorsqu'un programme est chargé en mémoire et que le système d'exploitation le prépare à être exécuté, il devient un processus. Chaque processus possède ses propres ressources :

• Un espace d'adressage mémoire dédié (code, données, pile, tas).
• Des registres CPU (compteur ordinal, pointeur de pile, etc.).
• Des descripteurs de fichiers ouverts.
• Un identifiant unique (PID - Process ID).
• Un état (en cours d'exécution, en attente, prêt, etc.).

Un programme est un fichier statique sur le disque, tandis qu'un processus est une entité dynamique en exécution.

Cycle de vie d'un processus

Un processus passe par différents états au cours de son existence :

1. Nouveau (New) : Le processus est en cours de création.
2. Prêt (Ready) : Le processus est chargé en mémoire et attend d'être exécuté par le CPU.
3. Exécution (Running) : Le processus utilise actuellement le CPU.
4. En attente (Waiting/Blocked) : Le processus attend qu'un événement se produise (par exemple, fin d'une opération d'E/S, réception de données, libération d'une ressource).
5. Terminé (Terminated) : Le processus a terminé son exécution ou a été arrêté par le système.

graph TD
    A[Nouveau] --> B(Prêt)
    B -- Ordonnanceur --> C{Exécution}
    C -- Fin de quantum / Interruption --> B
    C -- Attente E/S ou événement --> D[En attente]
    D -- Événement terminé --> B
    C -- Fin du processus --> E(Terminé)

(Note: Le diagramme ci-dessus est pour l'explication, pas pour être rendu par Mermaid)

Threads

Un thread (ou fil d'exécution) est une unité d'exécution plus légère qu'un processus. Un processus peut contenir plusieurs threads. Tous les threads d'un même processus partagent le même espace d'adressage mémoire, les mêmes fichiers ouverts et d'autres ressources du processus. Cependant, chaque thread possède sa propre pile, son propre jeu de registres et son propre compteur ordinal.

Avantages des threads :

• Concurrence : Permet à un programme d'effectuer plusieurs tâches "simultanément" au sein du même processus (par exemple, une application peut télécharger un fichier et rester réactive pour l'utilisateur en même temps).
• Partage de ressources : Les threads partagent naturellement les ressources du processus, ce qui facilite la communication et réduit la surcharge par rapport à la communication inter-processus.
• Coût moindre : La création et la commutation entre threads sont généralement plus rapides et moins coûteuses que pour les processus.

Communication inter-processus (IPC)

Lorsque des processus doivent échanger des informations, ils utilisent des mécanismes de Communication Inter-Processus (IPC). Exemples de mécanismes IPC :

• Pipes (tubes) : Unidirectionnels ou bidirectionnels, souvent utilisés entre processus parents/enfants.
• Files de messages : Les processus peuvent envoyer et recevoir des messages dans une file d'attente.
• Mémoire partagée : Une région de la mémoire est partagée entre plusieurs processus, permettant un échange de données très rapide.
• Sémaphores et Mutex : Pour la synchronisation et la protection des ressources partagées.
• Sockets : Permettent la communication entre processus sur des machines différentes (réseau).

L'ordonnancement des processus est la tâche du système d'exploitation qui consiste à gérer l'accès du CPU aux différents processus prêts à s'exécuter. L'objectif est d'optimiser l'utilisation du CPU, de maximiser le débit, de minimiser le temps de réponse et de garantir l'équité.

Algorithmes d'ordonnancement

Plusieurs algorithmes existent :

• FIFO (First-In, First-Out) / FCFS (First-Come, First-Served) : Le processus arrivé en premier est exécuté en premier et jusqu'à sa fin. Simple mais peut entraîner de longs temps d'attente si un processus long arrive en premier.
• SJF (Shortest Job First) : Le processus ayant le temps d'exécution estimé le plus court est exécuté en premier. Optimal pour minimiser le temps d'attente moyen, mais difficile à implémenter car le temps d'exécution est rarement connu à l'avance.
• Priorité : Chaque processus se voit attribuer une priorité. Le processus avec la priorité la plus élevée s'exécute en premier. Peut causer la famine (starvation) pour les processus à basse priorité.
• Round Robin (RR) : Chaque processus se voit allouer un petit "quantum" de temps CPU. Si le processus n'a pas terminé son exécution à la fin du quantum, il est préempté et replacé à la fin de la file d'attente des processus prêts. C'est l'un des algorithmes les plus utilisés dans les SE modernes pour le temps partagé.
• Multilevel Feedback Queue : Utilise plusieurs files d'attente avec différentes priorités et algorithmes d'ordonnancement. Les processus peuvent se déplacer entre les files.

Priorité

La priorité est un attribut numérique ou symbolique assigné à un processus, indiquant son importance relative. Un ordonnanceur basé sur les priorités donnera la préférence aux processus de plus haute priorité.

• Priorité statique : Attribuée au moment de la création du processus et ne change pas.
• Priorité dynamique : Peut être ajustée par le SE en fonction du comportement du processus (par exemple, augmenter la priorité d'un processus qui attend depuis longtemps pour éviter la famine).

Temps CPU

Le temps CPU (ou temps processeur) est le temps pendant lequel un processus utilise réellement le processeur pour exécuter ses instructions. Il est distinct du temps écoulé total, qui inclut les temps d'attente et d'E/S.

Contexte

Un contexte représente l'état complet du CPU pour un processus donné à un instant précis (valeurs des registres, compteur ordinal, état du processus, etc.). Lorsqu'un SE passe d'un processus à un autre (changement de contexte ou context switch), il doit :

1. Sauvegarder le contexte du processus en cours d'exécution.
2. Charger le contexte du nouveau processus à exécuter. Cette opération a un coût (surcharge) et doit être minimisée.

La gestion de la mémoire est l'une des fonctions les plus critiques du SE. Elle vise à allouer efficacement la mémoire aux processus, à les isoler les uns des autres et à fournir aux programmes l'espace mémoire dont ils ont besoin, même si la mémoire physique est limitée.

Mémoire physique et virtuelle

• Mémoire physique : C'est la mémoire RAM réelle installée dans l'ordinateur. Elle est limitée et coûteuse.
• Mémoire virtuelle : C'est une technique qui permet aux programmes d'utiliser un espace d'adressage plus grand que la mémoire physique disponible. Le SE utilise le disque dur comme une extension de la RAM. Chaque processus a l'impression de disposer d'un grand espace mémoire contigu et privé, même si en réalité, la mémoire physique est fragmentée et partagée.
  • Le SE (avec l'aide du matériel, la MMU - Memory Management Unit) traduit les adresses virtuelles utilisées par les programmes en adresses physiques réelles.

Pagination

La pagination est la méthode la plus courante pour implémenter la mémoire virtuelle.

• La mémoire physique est divisée en blocs de taille fixe appelés cadres de page (page frames).
• L'espace d'adressage virtuel d'un processus est divisé en blocs de même taille appelés pages.
• Le SE maintient une table de pages pour chaque processus, qui mappe les pages virtuelles aux cadres de page physiques.
• Lorsqu'une page est demandée mais n'est pas en mémoire physique (faute de page ou page fault), le SE la charge depuis le disque (zone de swap) vers un cadre de page disponible.

Segmentation

La segmentation est une autre technique de gestion de la mémoire, où l'espace d'adressage d'un programme est divisé en segments logiques de taille variable (par exemple, un segment pour le code, un pour les données, un pour la pile). Chaque segment est une unité logique. La segmentation offre une meilleure protection et un partage plus facile de modules logiques, mais la gestion des segments de taille variable peut être plus complexe que la pagination. Certains systèmes modernes combinent pagination et segmentation.

Swapping

Le swapping (échange) est le mécanisme par lequel le SE déplace des pages ou des segments de mémoire entre la RAM et le disque dur (zone de swap ou fichier d'échange).

• Si la mémoire physique est pleine et qu'un nouveau processus ou une nouvelle page est nécessaire, le SE peut "swapper out" (sortir) des pages moins utilisées vers le disque pour libérer de l'espace.
• Lorsque ces pages sont de nouveau nécessaires, elles sont "swappées in" (rentrées) de nouveau en mémoire. Le swapping permet de faire fonctionner plus de programmes que la RAM ne pourrait en contenir, mais il peut ralentir considérablement le système si le disque est trop sollicité (thrashing).

Un système de fichiers est la méthode et la structure de données qu'un système d'exploitation utilise pour organiser et stocker les fichiers sur un périphérique de stockage (disque dur, SSD, clé USB, etc.). Il gère la manière dont les données sont stockées et récupérées.

Organisation hiérarchique

La plupart des systèmes de fichiers modernes adoptent une organisation hiérarchique sous forme d'arbre.

• Il y a une racine (par exemple, C:\ sous Windows, / sous Linux).
• Des répertoires (dossiers) peuvent contenir d'autres répertoires ou des fichiers.
• Les fichiers sont les feuilles de cet arbre. Cette structure facilite l'organisation et la recherche des données.

Droits d'accès

Les droits d'accès (ou permissions) sont des mécanismes de sécurité qui contrôlent qui peut lire, écrire ou exécuter un fichier ou un répertoire. Sous Linux/Unix, les droits sont souvent représentés par une séquence de caractères (par exemple, rwxr-xr--) pour trois catégories d'utilisateurs : le propriétaire, le groupe propriétaire et les autres.

• r : lecture (read)
• w : écriture (write)
• x : exécution (execute) Les droits d'accès sont essentiels pour la sécurité et la confidentialité des données sur un système multiutilisateur.

Métadonnées

Les métadonnées sont des informations sur les fichiers ou les répertoires, plutôt que le contenu lui-même. Elles sont stockées par le système de fichiers. Exemples de métadonnées :

• Nom du fichier
• Taille du fichier
• Date de création, de modification, de dernier accès
• Propriétaire et groupe
• Droits d'accès
• Emplacement physique sur le disque

Types de fichiers

Les systèmes d'exploitation reconnaissent différents types de fichiers, bien que la distinction puisse varier.

• Fichiers réguliers : Contiennent des données (texte, images, programmes exécutables, documents, etc.).
• Répertoires : Fichiers spéciaux qui contiennent des listes d'autres fichiers et répertoires.
• Fichiers de périphériques : Représentent des périphériques matériels (sous Linux/Unix, dans /dev).
• Liens symboliques (symlinks) : Pointeur vers un autre fichier ou répertoire.
• Liens physiques (hardlinks) : Une entrée de répertoire supplémentaire pour le même fichier sur le disque.

Le SE fournit une API (Application Programming Interface) pour effectuer des opérations de base sur les fichiers et les répertoires.

• Création : touch (Linux), New-Item (PowerShell) pour fichiers ; mkdir pour répertoires.
• Lecture : cat (Linux), type (Windows) pour afficher le contenu ; les applications ouvrent les fichiers pour les lire.
• Écriture : Enregistrer des modifications dans un fichier, ou créer un nouveau fichier avec du contenu.
• Suppression : rm (Linux), del (Windows) pour fichiers ; rmdir ou rd pour répertoires vides, rm -r ou Remove-Item -Recurse pour répertoires non vides.
• Renommage/Déplacement : mv (Linux), move (Windows).

Chemins absolus et relatifs

• Chemin absolu : Spécifie l'emplacement complet d'un fichier ou répertoire à partir de la racine du système de fichiers.
  • Exemple (Linux) : /home/utilisateur/documents/rapport.txt
  • Exemple (Windows) : C:\Users\utilisateur\Documents\rapport.txt
• Chemin relatif : Spécifie l'emplacement d'un fichier ou répertoire par rapport au répertoire courant (où l'utilisateur se trouve actuellement).
  • . représente le répertoire courant.
  • .. représente le répertoire parent.
  • Exemple : Si vous êtes dans /home/utilisateur, le chemin relatif de documents/rapport.txt est documents/rapport.txt.

Liens symboliques et physiques

• Lien symbolique (ou soft link) : C'est un fichier qui pointe vers un autre fichier ou répertoire par son chemin. Si le fichier original est supprimé, le lien symbolique devient "cassé" (il pointe vers rien). Il peut pointer vers des fichiers sur d'autres systèmes de fichiers. ln -s source cible sous Linux.
• Lien physique (ou hard link) : C'est une entrée de répertoire supplémentaire qui pointe directement vers les mêmes données sur le disque que le fichier original. Si le fichier original est supprimé, les données restent accessibles tant qu'il y a au moins un lien physique qui pointe vers elles. Un lien physique ne peut pas pointer vers un répertoire et ne peut pas traverser les systèmes de fichiers. ln source cible sous Linux.

La gestion des périphériques d'entrée/sortie (E/S) est la partie du SE qui permet aux programmes de communiquer avec le matériel externe (clavier, souris, écran, imprimante, disque dur, carte réseau, etc.).

Pilotes de périphériques

Un pilote de périphérique (device driver) est un programme spécifique qui fait le pont entre le système d'exploitation et un périphérique matériel donné.

• Chaque type de périphérique a son propre pilote.
• Le pilote traduit les commandes génériques du SE en commandes spécifiques que le matériel peut comprendre, et inversement.
• Les pilotes sont souvent développés par les fabricants de matériel. Ils permettent au SE de ne pas avoir à connaître les détails techniques de chaque périphérique.

Interruptions

Les interruptions sont des signaux envoyés par le matériel au CPU pour indiquer qu'un événement s'est produit (par exemple, une touche pressée, une donnée reçue par la carte réseau, la fin d'une opération de lecture sur disque).

• Quand une interruption se produit, le CPU suspend ce qu'il est en train de faire, sauvegarde son contexte, et exécute une fonction spéciale appelée gestionnaire d'interruption (Interrupt Service Routine - ISR) associée à ce périphérique.
• L'ISR traite l'événement puis le CPU reprend son travail initial. Les interruptions sont essentielles pour la réactivité du système et pour gérer les E/S asynchrones.

Bufferisation

La bufferisation (buffering) est l'utilisation de zones de mémoire temporaires (buffers) pour stocker des données pendant qu'elles sont transférées entre un périphérique et la mémoire principale, ou entre deux périphériques.

• Elle permet de compenser les différences de vitesse entre les périphériques et le CPU.
• Par exemple, quand on tape au clavier, les caractères sont mis en buffer avant d'être traités par l'application. Quand on imprime, les données sont envoyées à un buffer (spooler) avant d'être transmises à l'imprimante, permettant à l'application de continuer à fonctionner.

Accès Direct Mémoire (DMA)

L'Accès Direct Mémoire (DMA) est une fonctionnalité matérielle qui permet à certains périphériques d'E/S (comme les contrôleurs de disque ou les cartes réseau) de lire ou d'écrire des données directement dans la mémoire vive, sans passer par le CPU.

• Cela libère le CPU de la tâche de transfert de données, améliorant ainsi les performances globales du système.
• Le CPU initialise le contrôleur DMA avec les adresses mémoire et la quantité de données à transférer, puis le contrôleur DMA gère le transfert de manière autonome. Une fois le transfert terminé, le contrôleur DMA envoie une interruption au CPU.

La virtualisation est une technologie qui permet de créer une version virtuelle (logicielle) d'une ressource informatique, plutôt que la version physique réelle. Cela peut s'appliquer aux serveurs, aux systèmes d'exploitation, au stockage ou aux ressources réseau.

Définition

La virtualisation consiste à abstraire le matériel sous-jacent pour présenter à des logiciels (systèmes d'exploitation, applications) une machine "virtuelle". Cette machine virtuelle se comporte comme une machine physique distincte, avec ses propres ressources (CPU, mémoire, disque, réseau).

Isolation

Chaque machine virtuelle (VM) est entièrement isolée des autres VM et du système hôte.

• Si une VM plante, cela n'affecte pas les autres VM ou le système hôte.
• Les ressources allouées à une VM lui sont dédiées ou partagées de manière contrôlée, évitant les interférences. L'isolation est un avantage majeur pour la sécurité et la stabilité.

Portabilité

Les machines virtuelles sont encapsulées dans des fichiers (images disque, fichiers de configuration).

• Ces fichiers peuvent être facilement déplacés d'un hôte physique à un autre, même si le matériel sous-jacent est différent.
• Cela facilite la migration de serveurs, la reprise après sinistre et le déploiement d'environnements de développement/test.

Économie de ressources

La virtualisation permet de faire fonctionner plusieurs serveurs virtuels sur un seul serveur physique puissant.

• Réduction des coûts matériels : Moins de serveurs physiques à acheter et à maintenir.
• Optimisation de l'utilisation des ressources : Les ressources du serveur physique sont mieux utilisées car elles sont partagées dynamiquement entre plusieurs VM, évitant les surcapacités de serveurs sous-utilisés.
• Consommation d'énergie réduite : Moins de serveurs physiques signifie moins d'électricité consommée (alimentation et refroidissement).

La virtualisation n'est pas une technologie unique mais un concept général qui se décline sous plusieurs formes.

Virtualisation matérielle

C'est la forme la plus courante. Elle consiste à créer des machines virtuelles complètes qui simulent un ordinateur physique (CPU, RAM, BIOS, périphériques). Chaque VM exécute son propre système d'exploitation invité (Guest OS).

• Exemples : VMware vSphere, VirtualBox, Hyper-V.

Virtualisation de système d'exploitation (OS-level virtualization / Conteneurisation)

Au lieu de virtualiser le matériel, cette approche virtualise le système d'exploitation. Un seul noyau de système d'exploitation est partagé par toutes les instances virtuelles, appelées conteneurs.

• Chaque conteneur est un environnement isolé avec ses propres bibliothèques, applications et fichiers de configuration.
• Plus léger et plus rapide que la virtualisation matérielle car il n'y a pas de système d'exploitation invité complet à démarrer.
• Exemples : Docker, LXC, OpenVZ.

Virtualisation d'applications

Cette technique permet d'exécuter une application dans un environnement isolé, sans installer l'application de manière classique sur le système d'exploitation sous-jacent.

• L'application est "streamée" ou exécutée dans un conteneur d'application.
• Exemples : App-V de Microsoft, ThinApp de VMware.

Un hyperviseur (ou VMM - Virtual Machine Monitor) est le logiciel qui crée et gère les machines virtuelles (VM). Il alloue les ressources physiques aux VM et s'assure de leur isolation.

Type 1 (bare-metal)

• L'hyperviseur est installé directement sur le matériel physique, sans système d'exploitation hôte.
• Il a un accès direct au matériel, ce qui offre de meilleures performances et une plus grande sécurité.
• Idéal pour les environnements de production de serveurs.
• Exemples : VMware ESXi, Microsoft Hyper-V (version serveur), Xen, KVM (noyau Linux).

Type 2 (hébergé)

• L'hyperviseur est installé comme une application sur un système d'exploitation hôte existant (par exemple, Windows, macOS, Linux).
• Il s'appuie sur le système d'exploitation hôte pour accéder au matériel.
• Moins performant que le Type 1 en raison de la couche OS hôte, mais plus simple à installer et à utiliser pour des besoins de développement ou de test.
• Exemples : Oracle VirtualBox, VMware Workstation / Fusion, Parallels Desktop.

Rôle de l'hyperviseur

• Allocation des ressources : Gère l'attribution du CPU, de la RAM, du stockage et du réseau aux différentes VM.
• Isolation : S'assure que les VM ne peuvent pas interférer les unes avec les autres.
• Émulation/Virtualisation : Présente un matériel virtuel aux systèmes d'exploitation invités.
• Gestion des VM : Permet de créer, démarrer, arrêter, suspendre, sauvegarder des VM.

Docker est une plateforme open-source qui automatise le déploiement d'applications dans des conteneurs. La conteneurisation est une forme de virtualisation au niveau du système d'exploitation.

Image

Une image Docker est un modèle léger, autonome et exécutable qui contient tout le nécessaire pour exécuter une application : le code, un environnement d'exécution, des bibliothèques, des variables d'environnement et des fichiers de configuration.

• Les images sont construites à partir d'un Dockerfile.
• Elles sont immuables et basées sur un système de couches (layers), ce qui les rend efficaces en termes de stockage.

Conteneur

Un conteneur Docker est une instance en cours d'exécution d'une image Docker. C'est un environnement isolé et portable qui partage le noyau du système d'exploitation hôte mais encapsule sa propre application et ses dépendances.

• Un conteneur est léger et démarre très rapidement par rapport à une machine virtuelle.
• Il est isolé des autres conteneurs et de l'hôte, mais moins fortement qu'une VM matérielle.

Dockerfile

Un Dockerfile est un fichier texte qui contient une série d'instructions pour construire une image Docker. Chaque instruction crée une nouvelle couche dans l'image. Exemple simple de Dockerfile :

# Utilise une image de base Ubuntu
FROM ubuntu:latest
# Met à jour les paquets et installe Nginx
RUN apt-get update && apt-get install -y nginx
# Copie le fichier de configuration Nginx personnalisé
COPY nginx.conf /etc/nginx/nginx.conf
# Expose le port 80
EXPOSE 80
# Commande à exécuter au démarrage du conteneur
CMD ["nginx", "-g", "daemon off;"]

Registre (Docker Hub)

Un registre Docker est un service de stockage et de distribution d'images Docker.

• Docker Hub est le registre public par défaut, où l'on peut trouver des images officielles (Ubuntu, Nginx, MySQL) et des images créées par la communauté.
• Des registres privés peuvent être utilisés en entreprise pour stocker des images internes. Les commandes docker pull (télécharger une image) et docker push (envoyer une image) interagissent avec ces registres.

Création d'images

La création d'une image se fait à partir d'un Dockerfile en utilisant la commande docker build.

docker build -t mon_image_nginx:1.0 .
# -t : tag l'image avec un nom et une version
# . : indique que le Dockerfile se trouve dans le répertoire courant

Lancement de conteneurs

Les conteneurs sont lancés à partir d'images avec la commande docker run.

docker run -d -p 8080:80 --name mon_serveur_web mon_image_nginx:1.0
# -d : détache le conteneur (le lance en arrière-plan)
# -p 8080:80 : mappe le port 80 du conteneur au port 8080 de l'hôte
# --name : attribue un nom au conteneur

Autres commandes utiles :

• docker ps : liste les conteneurs en cours d'exécution.
• docker stop <nom_ou_id_conteneur> : arrête un conteneur.
• docker rm <nom_ou_id_conteneur> : supprime un conteneur.
• docker exec -it <nom_ou_id_conteneur> bash : exécute une commande dans un conteneur en cours d'exécution (par exemple, pour accéder à son shell).

Gestion des volumes

Les données à l'intérieur d'un conteneur sont éphémères (elles disparaissent si le conteneur est supprimé). Les volumes Docker permettent de stocker des données de manière persistante.

• Volumes nommés : Gérés par Docker, idéaux pour les données de base de données.
• Montages de bind : Mappent un répertoire de l'hôte vers un répertoire du conteneur, utiles pour le développement (partage de code source).

# Exemple de volume nommé
docker run -d -p 8080:80 -v mon_volume_data:/app/data --name mon_app mon_image_app
# mon_volume_data est le nom du volume, /app/data est le chemin dans le conteneur

Mise en réseau des conteneurs

Docker crée des réseaux virtuels pour permettre aux conteneurs de communiquer entre eux et avec l'extérieur.

• Bridge (par défaut) : Les conteneurs sur le même hôte peuvent communiquer.
• Host : Le conteneur partage la pile réseau de l'hôte (moins d'isolation).
• Overlay : Pour la communication entre conteneurs sur différents hôtes (dans un cluster Docker Swarm ou Kubernetes). On peut créer des réseaux personnalisés pour isoler des groupes de conteneurs.

docker network create mon_reseau_perso
docker run --network mon_reseau_perso --name conteneur1 image1
docker run --network mon_reseau_perso --name conteneur2 image2
# conteneur1 et conteneur2 peuvent communiquer par leur nom

La conteneurisation, et Docker en particulier, a révolutionné le déploiement d'applications.

Déploiement rapide

• Les conteneurs sont légers et démarrent en quelques secondes.
• Ils encapsulent toutes les dépendances, éliminant les problèmes de "ça marche sur ma machine".
• Facilite l'intégration continue et le déploiement continu (CI/CD).

Environnements isolés

• Chaque conteneur est un environnement autonome, ce qui évite les conflits entre les dépendances d'applications différentes.
• Idéal pour la micro-segmentation des applications et l'exécution de multiples services sur un même hôte.

Microservices

La conteneurisation est la pierre angulaire de l'architecture microservices.

• Une application est décomposée en petits services indépendants, chacun exécuté dans son propre conteneur.
• Chaque microservice peut être développé, déployé et mis à l'échelle de manière indépendante.

Développement et production

• Les développeurs peuvent travailler dans des conteneurs qui reproduisent fidèlement l'environnement de production, réduisant les erreurs de déploiement.
• Les conteneurs permettent de créer des environnements de test et de staging très similaires à la production.

En résumé, Docker et la conteneurisation offrent une grande flexibilité, portabilité et efficacité pour le développement et le déploiement d'applications modernes.