init

docker/.envrc

@@ -0,0 +1 @@
+use flake

docker/docker.md

@@ -0,0 +1,182 @@
+---
+title: le cours de docker avec des schémas et des commandes interactives pour
+  les gens largués qui ont besoin d'explications détailées et qui mangent du
+  terminal
+sub_title: et les titres à rallonge aussi
+author: lelu awen
+options:
+  command_prefix: "pr:"
+theme:
+  override:
+    code:
+      alignment: center
+---
+<!-- LTeX: language=fr -->
+Sommaire
+===
+<!-- pr:font_size: 2 -->
+- Avant-propos
+- Les conteneurs en bref
+  - À quoi que ça sert
+  - Open Container Initiative (OCI)
+- Docker
+  - Présentation générale
+  - Fonctionnement
+    - Conteneurs
+    - Images
+    - Volumes
+    - Ports
+    - Networks
+- Glossaire
+<!-- end_slide -->
+Avant-propos
+===
+Le but de ce document est de fournir une base synthétique sur le sujet de
+l'utilisation de docker dans le cadre de la manipulation de conteneur de façon
+impérative. Ainsi, les sujets suivants ne serons pas aborder:
+- Docker compose
+  - un outil de permettant de définir un ensemble de conteneur (projet) de façon
+    déclarative.
+- Dockerfile
+  - Mécanisme de docker permettant de créer des **Images**[^1]
+
+Ce Guide par du principe que vous avez **docker**[^2] d'installer sur votre ordinateur
+afin d'exécuter les différentes commandes que ce dernier comprend.  
+De plus, nous n'allons pas revenir en détail sur le fonctionnement d'un terminal,
+des diverses commandes non liées à docker et nous survolerons les services utilisés
+comme exemple.  
+De plus, ce guide vise à voir les fondamentaux de docker, de ce fait, il ne sera
+pas fait mention de **docker desktop** et de **lazydocker**, car bien que pratique,
+je juge qu'il est fondamental de bien connaître le fonctionnement interne de docker
+avant de se faire assister par des outils externes.
+
+Pour toute question, merci de me contacter au mail suivant: `lelu.awen@proton.me`
+<!-- end_slide -->
+Les conteneurs en bref
+===
+# À quoi ça sert
+<!-- pr:column_layout: [2,1] -->
+<!-- pr:column: 0 -->
+Avez vous déjà eu le problème suivant:  
+Imaginez que vous êtes étudiant, vous avez un cours sur de l'intégration continue,
+à tout hasard, *jenkins*[^3], Le Professeur vous demande donc d'installer Jenkins
+sur votre ordinateur et là, le drame, l'horreur, vous devez installer *java*[^4].
+Bien sur, vous allez voir sur la documentation d'installation de *Jenkins* et vous
+voyez que ce dernier demande la version 21 de Java, hors, vous avez la version 25
+d'installer pour vos projets ! Que faire ? Passer vos projets sur java 21 ?
+Désinstaller java 25 et le réinstaller après le cours ? Dans tous les cas, c'est
+pas vraiment pratique. Maintenant, imaginez en plus que vous êtes sur Windows
+et que vos partenaires de groupe sont sur *Linux* et *MacOS*, ils ont chaqu'un des
+modalités d'installation différente.  
+Si seulement on pouvait avoir un système qui permet de faire en sorte que tout
+notre projet et ses dépendances soit toutes regrouper dans un paquet, et que vous
+ayez juste à télécharger ce paquet pour le lancer... Oh l'idée de génie vite faut
+que je lance ma startup avant qu'on me pique l'idée et on pourra même utiliser
+une IA pour.. Oh, c'est le sujet de la diapo, c'est ça ?
+
+Et oui, un des buts des conteneurs c'est ça, pouvoir mettre ensemble tout les
+composants d'une application dans une boite, et pouvoir lancer cette boite de
+façon isolée du reste du système, un peu comme son propre petit ordinateur.
+de cette manière on gagne plusieurs avantages:
+- ne pas avoir à gérer plusieurs versions des dépendences
+  - comme par exempleflake_schema avoir 2 version de node d'installer, ou deux version de
+    java
+- ne pas risquer d'oublier des trucs qu'on à installer juste pour un projet
+  - Car il est installer que au seins de notre conteneur, et si on supprime celui-ci,
+    on supprime aussi les programmes associé.
+- Pouvoir lancer des trucs "juste pour tester"
+  - Chaque conteneur est isolé de notre système, donc il risque pas de casser
+    des trucs, et vu qu'on peut le supprimer après, on risque pas d'oublier de
+    le désinstaller
+- Partager un environnement
+  - quel que sois le système d'exploitation, maintenant tout le monde peut faire
+    les même commande pour avoir strictement le même environnement de travail
+    que le voisin, finis les "Ah mais ton truc il marche pas parce que j'ai
+    java 11 d'installer"
+<!-- pr:column: 1 -->
+![](./pictures/why_docker.jpeg)
+<!-- pr:end_slide -->
+Les conteneurs en bref
+===
+# Open Container Initiative (OCI)
+Populariser par Docker, l'utilisation de conteneur n'est pourtant pas une
+exclusivité de ce dernier. Ainsi il existe d'autres outils permettant d'utiliser
+des conteneurs, comme par exemple Podman. Afin de standardiser la définition de
+ce qu'est unn conteneur, Docker ainsi que d'autres acteurs ont mis en place
+**l'Open Containuer Initiative** ou OCI, une structure ouverte servant d'autorité
+pour définir les standards régissant les conteneurs dits "**OCI**[^5]", un peu à
+la manière du *Système de mesure International* (SI) définissant par exemple le
+mètre, le gramme, ect...  
+Ces standards étant ouverts, n'importe qui peut les implémenter afin de construire
+son propre engine et pouvoir tout de même utiliser les systèmes existants.  
+Ainsi, bien que **Docker** et **Podman** sois deux implémentation différentes de
+ce standard, une image construite avec **Docker** peut parfaitement être utiliser
+avec **Podman** et vis-versa.  
+On parlera ainsi de **Conteneur OCI** pour parler d'un conteneur construit celons
+ce standard.
+![](./pictures/oci_definition.png)
+<!-- pr:end_slide -->
+Docker
+===
+# Présentation générale
+<!-- pr:column_layout: [1, 1] -->
+<!-- pr:column: 0 -->
+Maintenant qu'on a passé la partie ennuyante, rentrons dans le vif du sujet:
+Docker c'est quoi ?  
+Fondamentalement, Docker est un programme permettant de créer, lancer et gérer des
+**conteneurs**, des **volumes**, des **network** et des **images** respectant
+le standard OCI.  
+Il est formé de principalement deux composants :
+- Docker daemon
+  - Son rôle est de fonctionner en arrière plan de votre ordinateur et de chapeauté
+    l'exécution des conteneurs, le routage des requêtes entre ces derniers via
+    les *networks*[^6] ainsi que l'accès aux fichiers de l'ordinateur via les
+    *volumes*[^7]
+- Docker CLI
+  - Ce composant fournis les commandes qui vont être utilisées pour manipuler le
+    daemon, en pratique, lui demander de lancer un conteneur, créer une **image**,
+    un **volume** ou un **network**.
+
+En effet, pour rentrer vaguement dans les détails plus techniques, docker fonctionne
+avec une architecture client / serveur. Le daemon fonctionne en arrière-plan et
+est le "cœur" de Docker, tendis que les commandes servent juste à envoyer des
+requêtes à ce dernier.
+<!-- pr:column: 1 -->
+![](./pictures/cli-daemon-commmunication.png)
+<!-- pr:end_slide -->
+Docker -- fonctionnement
+===
+# Images
+<!-- pr:column_layout: [1, 1] -->
+<!-- pr:column: 0 -->
+```bash +exec
+# lance moi avec ctrl+e
+# reset avec ctrl+r
+docker image pull grycap/cowsay:latest
+```
+<!-- pr:column: 1 -->
+![](./pictures/gateau.png)
+<!-- pr:end_slide -->
+Docker -- fonctionnement
+===
+# Conteneurs
+```bash +exec
+docker run --rm rancher/cowsay:latest "test"
+```
+<!-- pr:end_slide -->
+Docker -- fonctionnement
+===
+# Volumes
+<!-- pr:end_slide -->
+Docker -- fonctionnement
+===
+# Networks
+<!-- pr:end_slide -->
+# Glossaire
+[^1]: image docker: 
+[^2]: docker engine:
+[^3]: jenkins:
+[^4]: java:
+[^5]: Conteneur OCI:
+[^6]: docker networks:
+[^7]: docker volumes: 

docker/flake.lock

@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1766201043,
+        "narHash": "sha256-eplAP+rorKKd0gNjV3rA6+0WMzb1X1i16F5m5pASnjA=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "b3aad468604d3e488d627c0b43984eb60e75e782",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-25.11",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "utils": "utils"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

docker/flake.nix

@@ -0,0 +1,18 @@
+{
+  inputs = {
+    utils.url = "github:numtide/flake-utils";
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-25.11";
+  };
+  outputs = { self, nixpkgs, utils }: utils.lib.eachDefaultSystem (system:
+    let
+      pkgs = nixpkgs.legacyPackages.${system};
+    in
+    {
+      devShell = pkgs.mkShell {
+        buildInputs = with pkgs; [
+          presenterm
+        ];
+      };
+    }
+  );
+}