.. include:: special.rst

Docker
++++++

A quoi sert Docker ?
--------------------

Docker est un logiciel qui permet de créer, déployer et exécuter des applications dans des conteneurs logiciels. Les conteneurs sont des environnements isolés qui permettent de faire fonctionner une application dans un environnement prévisible, indépendamment de l'environnement d'hébergement.

Comment l'installer ?
---------------------

Version Linux
_____________

Tout d'abord commencez par executer :

.. code :: bash

	sudo apt-get update

Ensuite récuperer la clé GPG de Docker afin de vous assurer que les paquets sont signés par la source officielle. 

.. code :: bash

	curl - fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
	
Continuez ensuite en ajoutant le dépôt Docker à votre système pour pouvoir installer Docker à partir de celui-ci .

.. code :: bash 

	sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
	

Une fois cela fait vous pouvez installer et lancer Docker : 

.. code :: bash 
	
		sudo apt-get install -y docker-ce
		sudo systemctl start docker 
		

	

Si tout est bon vous devriez avoir l'application Docker  d'installer ! 


.. image:: image/DesktopDocker.png

.. warning ::
	Lors de notre installation l'interface graphique de Docker ( donc l'application Docker Desktop ) ne fonctionné pas . Nous avons donc réalisé tout notre projet via l'invite de commande . La version graphique n'est donc pas obligatoire .
	
Afin de totalement être sûre de la bonne installation de Docker , vous pouvez effectué un ``docker -v`` .

.. note :: 
	Vous pouvez passez par ce lien officiel : https://docs.docker.com/desktop/install/linux-install/ vous aurez alors par la suite différentes commandes à executer afin d'installer Docker .
	
Version Windows
_______________

Pour installer Docker via Windows c'est assez simple :

Pour commencer recuperer l'installateur de docker sur le site officiel :https://www.docker.com/products/docker-desktop .

Il vous suffira d'installer le fichier executeur afin de l'installer sur votre machine .

Docker devrait donc demarrer automatiquement ( sinon vous pouvez le rechercher dans le menu Démarrer) .

Afin de totalement être sûre de la bonne installation de Docker , vous pouvez effectué un ``docker -v`` .

.. warning :: 
	Il se peut que Docker vous affiche l'erreur ``Docker Desktop requires a newer WSL kernel version`` . Si c'est le cas , il suffit d'éxécuter la commande ``wsl --update`` dans un invite de commande . Une fois fait relancé Docker et celui-ci devrait fonctionner .

Version Mac 
___________

Tout comme Windows , l'installation de Docker se réalise via l'installateur disponible sur : https://www.docker.com/products/docker-desktop .

Il vous suffira d'installer le fichier executeur afin de l'installer sur votre machine .

Docker devrait donc demarrer automatiquement ( sinon vous pouvez le rechercher dans le dossier Applications) .

Afin de totalement être sûre de la bonne installation de Docker , vous pouvez effectué un ``docker -v`` .

.. warning ::
	Il est important de noter que pour utiliser Docker sur mac il faut que votre système possède une version de macOS Sierra 10.12.3 ou supérieure.
	
Fonctionnement et utilité de Docker
-----------------------------------

Docker utilise des images pour créer des conteneurs. Les images sont des instantanés d'un environnement d'application qui peuvent être utilisés pour créer des conteneurs. 

Les conteneurs sont des instances d'images qui peuvent être démarrées, arrêtées et supprimées. Les conteneurs permettent de faire tourner une application dans un environnement prévisible, indépendamment de l'environnement d'hébergement.

A quoi sert un Dockerfile ?
---------------------------

Un Dockerfile est un fichier texte qui contient des instructions pour créer une image Docker. 

Il décrit les étapes nécessaires pour configurer l'environnement d'application et installer les dépendances nécessaires pour faire fonctionner l'application. 

Il permet de créer une image reproductible et facilement déployable.

Les commandes les + utiles
--------------------------


.. glossary :: 
	``docker run (-it) (--name ) (-p) [nom]``
		Utilisée pour exécuter une commande dans un conteneur.
		``-it`` Permet de lancer un terminal interractif du conteneur ciblé .
		``--name`` Permet de renommée le conteneur en même temps que  son exécution .
		``-p`` permet de definir le port
		
	``docker start``
		Utilisée pour démarrer un ou plusieurs conteneurs .
		
	``docker stop``  
		Utilisée pour arrêter un ou plusieurs conteneurs.
	
	``docker version``
		Permet de verifier la version de Docker
	
	``docker build (-t)``  
		Utilisée pour construire une image à partir d'un Dockerfile.
		``-t`` Pour nommée l'image à construire
	
	``docker pull``  
		Utilisée pour télécharger une image depuis un registre Docker.
	
	``docker push``  
		Utilisée pour envoyer une image vers un registre Docker.
	
	``docker exec``  
		Utilisée pour exécuter une commande dans un conteneur en cours d'exécution.
	
	``docker rm [conteneur]`` 
		Utilisée pour supprimer un ou plusieurs conteneurs.
	
	``docker rmi``  
		Utilisée pour supprimer une ou plusieurs images.
	
	``docker images (-a)``  
		Utilisée pour lister les images sur l'ordinateur local.
		
		``-a`` Permet de voir les images intermédiaires .  
		
	``docker ps (-a)``
		Utilisée pour lister les conteneurs en cours d'exécution sur l'ordinateur local. 
		
		``-a`` permet de voir les conteneur stoppés .
	
	``docker inspect`` 
		Utilisée pour afficher les informations détaillées sur un conteneur ou une image.
    	
    	``docker logs``
    		Utilisée pour afficher les logs d'un conteneur.
    	
    	``docker network (ls)`` 
    		Utilisée pour gérer les réseaux Docker.
    		
    		``ls`` permet de lister les différent réseaux
    	
    	``docker volume``  
    		Utilisée pour gérer les volumes Docker.

Fonctionnement d'un Dockerfile
------------------------------

Dans un Dockerfile , il existe plusieurs commandes qui permettent de définir les étapes nécessaires pour créer une image Docker. Les commandes les plus couramment utilisées sont les suivantes :

.. glossary ::
	``FROM``
		Indique l'image de base à partir de laquelle la nouvelle image sera construite. Cette commande doit toujours être la première dans un Dockerfile .
	
	``RUN``  
		Permet d'exécuter une commande dans le contexte de l'image en cours de construction. Cette commande est utilisée pour installer des dépendances, configurer l'environnement, etc.

	``CMD``
		Indique la commande à exécuter lorsque le conteneur est démarré à partir de l'image. Il peut y avoir plusieurs CMD dans un Dockerfile, mais seul le dernier sera pris en compte.

	``ENV``  
		Permet de définir des variables d'environnement pour l'image en cours de construction. Ces variables peuvent être utilisées dans les commandes suivantes du Dockerfile.

	``COPY``  
		Permet de copier des fichiers ou des dossiers depuis le système hôte vers l'image en cours de construction.

	``EXPOSE`` 
		Indique les ports sur lesquels le conteneur écoutera lorsqu'il sera démarré à partir de l'image.

	``WORKDIR``
		Permet de définir le répertoire de travail pour les commandes suivantes du Dockerfile.

	``LABEL`` 
		Permet de définir des métadonnées pour l'image en cours de construction.
    	
    	``ADD``  
    		Permet de copier des fichiers ou des dossiers depuis le système hôte vers l'image en cours de construction, similaire à COPY. Il permet également de décompresser automatiquement les fichiers compressés comme .tar,.tar.gz, .zip.

    	``SHELL``
    		Permet de changer le shell utilisé pour exécuter les commandes dans un Dockerfile. Par défaut, le shell utilisé est /bin/sh mais il est possible de changer pour un autre shell comme /bin/bash. Il permet de changer l'interpréteur de commande pour les commandes suivantes dans le Dockerfile.
    		
    	``ARG``
    		Permet de définir des variables d'argument pour un Dockerfile. Ces variables peuvent être utilisées pour paramétrer la construction de l'image à l'aide de la commande ``--build-arg`` . Les variables d'arguments peuvent être utilisées dans les commandes ``FROM`` , ``ENV`` , ``COPY`` , ``CMD`` et ``RUN``.
    		

    		
Exemple d'utilisation de Docker
-------------------------------

Dans la suite de cette page nous allons vous présentez un exemple de l'utilisation de Docker pour construire un environnement JupyterLab dans un conteneur Ubuntu via un Dockerfile .

Tout d'abord nous aurons besoin de deux fichier sur la machine  qui sont ici :

- Le fichier d'environnement pour linux "deepLearning.yml" .

- Un fichier test kernel ici "first_look_dl_with_mnist_ok.ipynb" .

Une fois cela fait nous pouvons creer notre dockerfile au même endroit que ces deux documents.

Voici le dockerfile fonctionnant pour ce projet : 

.. code :: docker

	# Recupère le système d'exploitation ubuntu , la version 22.04
	
	FROM ubuntu:22.04
	ENV PATH="/root/miniconda3/bin:${PATH}"
	ARG PATH="/root/miniconda3/bin:${PATH}"
	
	# Installe Python , pip et wget

	RUN apt-get update && apt-get install -y python3 python3-pip
	RUN apt-get install -y wget

	# Configure le shell proprement pour docker .
	SHELL ["/bin/bash", "--login", "-c"]

	# Ajoute les fichiers d'environnement et Kernel dans le conteneur .
	COPY deepLearning.yml .
	COPY first_look_dl_with_mnist_ok.ipynb .
	
	# Installe miniconda
	RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
	RUN mkdir /root/.conda
	RUN bash Miniconda3-latest-Linux-x86_64.sh -b
	RUN rm -f Miniconda3-latest-Linux-x86_64.sh  
	
	# Met a jour conda
	RUN conda update -y -n base -c defaults conda
	
	# Creer l'environnement deepLearning à partir du fichier deepLearning.yml
	RUN conda env create -f deepLearning.yml
	
	# Installe la librairie pour jupyter
	RUN conda install -c conda-forge jupyterlab
	
	# Active l'environnement deepLearning afin de pouvoir executer des commandes à l'interieur
	RUN echo "source activate deepLearning_cpu" > ~/.bashrc
	
	# Se place dans le dossier d'environnement de conda
	ENV PATH /opt/conda/envs/env/bin:$PATH
	
	# Execute l'environnement nommée deepLearning_cpu via kernel 
	RUN ipython kernel install --name "deepLearning_cpu" --user
	
	# Change de port afin d'avoir accès au lien que nous fournis la commande jupyter lab pour pouvoir consulter le notebook
	EXPOSE 9999
	CMD ["jupyter", "lab", "--ip='0.0.0.0'", "--port=8888", "--no-browser", "--allow-root"]

Placez vous dans le document contenant "deepLearning.yml" et "first_look_dl_with_mnist_ok.ipynb" ainsi que le dockerfile et exécuter cela : 

.. code :: bash

	docker build -t jupyterlab .
	docker run -p 8888:8888 jupyterlab