Principe de Docker

La containerisation est réalisée par l'intermédiaire d'un processus qui isole les éléments de la plateforme matérielle et qui offre un moyen d'exécuter des programmes ou environnements complets en parfaite isolation les uns des autres. Il se base sur un daemon (sous linux) utilisant les namespaces et les cgroups de linux pour réaliser cette isolation et offrir le maximum de performances à l'ensemble des containers installés sur la machine. Les containers sont disponibles par défaut sur le hub public https://hub.docker.com avec un choix important sur l'ensemble des problématiques informatiques : serveurs web, serveurs linux, serveurs de bases de données et bien d'autres encore.

Le lancement d'un container par la commande

$ docker container run -ti <nom du conteneur>

Exemples d'usage des containers :

 Pour démarrer le conteneur de python : docker container run -ti python:3
 Cela va démarrer un container avec le tag 3 de Python à savoir donc la version 3 du langage
 
 Pour démarrer un container Ruby : docker container run -ti ruby:2.5.1
 Même chose que précédemment avec cette fois un interpréteur Ruby en version 2.5.1
 
 Pour démarrer un container NodeJS : docker container run -ti node:8.12-alpine
 Pour Node, la subtilité au niveau du tag indique également la distribution alpine linux pour cette gestion
 de conteneur Node car Alpine Linux est très impliqué dans la mise en place de Node sur Docker et reste le meilleur
 support pour NodeJS.
 
 Pour démarrer une base MongoDB : docker container run -p 27017:27017 -d mongo:4.0
 Cela démarre un conteneur qui écoute sur le port 27017 et qui route le port externe sur le port interne 27017.
 Pour utiliser Mongo, le plus simple est de faire appel à Compass qui offre une interface Web d'administration.
 L'utilisation du flag -d pour détacher le processus demande à Docker de nous afficher clairement l'ID du processus.
 C'est une suite de chiffres et lettres qui identifie de manière unique le processus en écoute (pour le killer par
 exemple).
 
 Pour démarrer un container Redmine : docker container run -p 3000:3000 redmine:3
 L'accès à Redmine s'effectue via le port 3000 et sur la version 3 (tag :3)
 Connexion par défaut par admin/admin.s
 

• -ti : démarrer un conteneur en mode intéractif
• -p : permet de rediriger un port externe vers un port interne d'un conteneur qui a vocation d'être accédé à travers le réseau local.
• -d : démarre le conteneur en mode daemon ou détaché

Installer Docker sous Windows Pro

Sous Windows Pro, Docker requiert au minimum Windows 10 build 18362 et supérieur, ainsi que de la technologie VT-x activée dans le BIOS et d'Hyper-V ou WSL (Windows Subsystem for Linux). Docker fonctionnera sur les deux systèmes Hyper-V ou WSL, même si la préférence va à WSL.

Consultez la documentation officielle Docker pour l'installation des éléments pour Windows. https://docs.docker.com/desktop/install/windows-install

ATTENTION : Docker Desktop ne fonctionne pas sur les versions Serveur de Windows.

Installer Docker sous Windows Serveur

Avec Windows Serveur, pour exécuter des conteneurs Docker, il faut passer par un runtime supporté par la machine. Il en existe actuellement 3 :

• containerd : Efficace mais un peu compliqué à prendre en main
• Moby Project / Docker CE : OpenSource et Communautaire
• Mirantis : payant mais reprenant les éléments de Docker EE (Entreprise Edition)

Pour installer Docker, nous allons utiliser Docker CE qui fournit un environnement standard pour les conteneurs avec une API et une gestion par ligne de commande. Un script de mise en place existe sur le github de la communauté Moby :

PS> Invoke-WebRequest -UseBasicParsing "https://raw.githubusercontent.com/microsoft/Windows-Containers/Main/helpful_tools/Install-DockerCE/install-docker-ce.ps1" -OutFile install-docker-ce.ps1
PS> .\install-docker-ce.ps1

Exécuter des conteneurs sous Windows Serveur

Les conteneurs sont créés à partir d'images de conteneurs. Une série de conteneurs de base sont disponibles à l'installation et fournis par Microsoft, sur la base de 4 versions de Windows Serveur :

• Windows Sever Core : Supporte les applications .Net traditionnelles
• Windows Nano Server : Conçu pour les applications .Net Core
• Windows : Fournit l'ensemble des API Windows
• Windows Server : Fournit l'ensemble de l'environnement Windows

PS> docker pull mcr.microsoft.com/windows/nanoserver:ltsc2022

PS> docker images

Maintenant que nous disposons d'une image, utilisons-la pour exécuter un simple 'hello world' en mode console.

PS> docker run -it mcr.microsoft.com/windows/nanoserver:ltsc2022 cmd.exe

echo "Hello World" > c:\hello\hello.txt

Vous pouvez obtenir l'état des machines conteneurisées par la commande

PS> docker ps -a

Maintenant que nous avons une image modifiée (suite à l'ajout d'un fichier) nous allons procéder à une duplication de cette image par

PS> docker commit <container_id> helloworld

PS> docker run --rm helloworld cmd.exe /s /c type c:\hello\hello.txt

Packager une application .Net en tant que conteneur Docker

Le comportement d'un conteneur Docker est généralement lié à l'usage d'un fichier de configuration que l'on nomme le Dockerfile. Ce Dockerfile est à considérer comme un makefile (pour ceux qui viennent du monde C) pour définir comment sera construite l'image.

Pour prendre un exemple, obtenu depuis Microsoft Learn, nous allons étudier la génération de code .Net à travers un Dockerfile afin que ce soit Docker qui compile le code. Voici le contenu du Dockerfile :

# Déclare à partir de quelle image nous allons construire le conteneur.
# Si le système local ne dispose pas de l'image, alors celle-ci sera récupérée depuis le
# lien donné dans le Docker Hub.
# Le tag 2.1 signale que le sdk 2.1 est déjà installé dans l'image.
# Le WORKDIR /app provoque le changement du dossier courant vers /app dans le conteneur
FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build-env
WORKDIR /app

# Les instructions suivantes copient les fichiers *.csproj dans le dossier /app 
du container.
# La commande dotnet va générer les dépendances requises pour le projet.
COPY *.csproj ./
RUN dotnet restore

# Copie des fichiers sources dans le container.
COPY . ./

# On informe .NET  afin qu'il publie notre application en mode Release
RUN dotnet publish -c Release -o out

# L'application construite est basée sur .Net. Nous téléchargeons donc une image
# incluant par défaut le runtime.
FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
WORKDIR /app
# Copie de tous les fichiers depuis le container temporaire dans le conteneur final.
COPY --from=build-env /epp/out .
ENTRYPOINT ["dotnet", "asp-net-getting-started.dll"]

Commandes Docker sous Windows

# Installation de Docker
PS> Install-Module -Name DockerMsftProvider -Repository PSGallery -Force
PS> Install-Package -Name Docker -ProviderName DockerMsftProvider -Verbose
PS> Restart-Computer -Force

# Affiche l'état du service Docker
PS> Get-Service Docker

# Si le service est noté comme Stopped, vous pouvez le démarrer en faisant
PS> Start-Service Docker

PS> docker version
Cela nous affiche la version des différents modules client et serveur de docker.
Si nous obtenons une réponse cela veut bien dire que nous communiquons avec notre service docker.

Le site  https://docs.docker.com/engine/reference/commandline/dockerd/  nous donne une
multitude d'informations sur le service docker et son démon dockerd. Nous pouvons y trouver
bon nombre de paramètres pour contrôler son fonctionnement, et notamment la façon dont le
service docker va démarrer ou bien la gestion de ses cartes réseau (bridge, ...)

Le fichier de configuration par défaut de docker se situe dans c:\programdata\docker\config\daemon.json.
Ce fichier n'existe pas. Il faut le créer par
PS> New-item -ItemType file c:\programdata\docker\config\daemon.json

Il faut ensuite préciser à docker que son port d'écoute sera le 2375 (par exemple) en ajoutant
les informations suivantes 
PS> Add-Content 'c:\programdata\docker\config\daemon.json' '{"hosts":["tcp://0.0.0.0:2375","npipe://"]}'

Redémarrez le service docker
PS> Restart-service docker

Un petit netstat -aon|findstr "2375" pour être sûr que le port a bien été généré.
N'oublions pas de configurer le port du firewall pour la communication sur le nouveau port
PS> netsh advfirewall firewall add rule name="Docker daemon" dir=in action=allow protocol=TCP localport=2375


Le container le plus simple à exécuter est hello-world. Il s'exécute comme suit :
PS> docker run hello-world
Le container va se télécharger pour s'exécuter et simplement écrire "hello from Docker!"

A la fin le container s'arrête et se décharge de la mémoire du serveur. Nous pouvons le constater
en faisant docker ps pour afficher les conteneurs en cours de fonctionnement.

Si on lance la commande 
PS> docker run -it hello-world powershell
cela va exécuter le conteneur hello-world en mode interactif et lancer un powershell dans ce
conteneur. Il est ainsi possible de faire cat ./hello.txt pour afficher le message que nous
avions reçu lorsque nous avons fait docker run hello-world.

Accès docker depuis poste windows 10 ou autre serveur

Nous allons procéder à l'installation de docker sur poste de travail en téléchargeant la version qui correspond à celle du serveur en cours d'exécution (la 17.06 actuellement).

PS> $package = “https://download.docker.com/win/static/stable/x86_64/docker-17.06.0-ce.zip";
PS> Invoke-WebRequest $package -OutFile “$env:Temp\docker-17.06.0-ce.zip” -UseBasicParsing
PS> Expand-Archive -Path “$env:TEMP\docker-17.06.0-ce.zip” -DestinationPath $env:ProgramFiles

PS> ii $env:ProgramFiles

Container Linux

Un container est un processus qui tourne sur le système isolé des autres processus. Il dispose de sa propre vision du système sur lequel il tourne (NameSpace) Il est limité dans les ressources qu'il peut utiliser avec les Control Groups (cgroups) Partage le kernel de la machine hôte avec les autres containers. Types de namespaces : pid : isolation de l'espace des processus net : donne une stack de réseau privé mount : système de fichiers privé uts : nom du host ipc : isole les communications inter processus user : mapping UID/GID entre hôte et containers Les control groups permettent de limiter les ressources utilisées par un processus : RAM, IO, Network, CPU

$ sudo apt-get update
$ sudo apt-get upgrade

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the repository to Apt sources:
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

$ sudo docker run hello-world

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the repository to Apt sources:
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

$ apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

$ docker run hello-world

$ sudo systemctl enable --now docker

$ docker volume create portainer_data

docker run -d \
--name portainer \
-p 8000:8000 \
-p 9443:9443 \
-v /var/run/docker.sock:/var/run/docker.sock \
-v portainer_data:/data \
--restart=unless-stopped \
portainer/portainer-ce:latest

DOCKER_APP
  |- app
    |- templates
      |- index.html
    |- main.py
  |- Dockerfile
  |- requirements.txt
      

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
EXPOSE 6874
CMD ["python", "app/main.py"]
    

$ docker build -t mon_container .

$ docker image ls

$ docker run -p 6874:6874 mon_container