introDockeR.Rmd

---
title: "Introduction à Docker"
author: "FinistR"
date: '2022-08-23'
output: html_document
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

### Sources

- [La documentation officielle](https://docs.docker.com/get-started/)
- [Le tuto de Colin Fay](https://colinfay.me/docker-r-reproducibility/)
- Le blog [Putain de Code](https://putaindecode.io/articles/introduction-a-docker/)

### Objectif

Le principe est de créer un **environnement contrôlé** (appelé container). On entend par environnement 

- le système d'exploitation (Linux dans une version donnée), 
- la version du language (R 2.3.0 par exemple)
- les packages utiles dans une version donnée
- peut également contenir des scripts, données, ...

### Quand cela est-il utile? 

C'est utile si j'ai écrit des codes/packages/scripts et que je veux 

- les faire tourner sur une autre machine mais ayant les mêmes caractéristiques que les miennes (si tant est que je ne sois pas sous Windows)
- tester mes programmes sur d'autres versions de Linux/R.
- cristalliser une analyse pour la partager et/ou y revenir dans plusieurs années

### Installation


D'abord il faut installer docker, c'est à dire le programme qui va nous service à créer le conteneur. 

 - Sous Linux, l'instruction `sudo snap install docker`  fonctionne. 
 Des instructions plus détaillées sont fournies [ici](https://www.simplilearn.com/tutorials/docker-tutorial/how-to-install-docker-on-ubuntu).
 Avec cette installation, aucune interface n'est fournie. Il faudrait lancer docker en ligne de commande et éditer les fichiers dans un éditeur quelconque. 

 - Sous Windows, il faut installer Docker Desktop sur le site éponyme, [https://www.docker.com/products/docker-desktop/].
 Ensuite, à l'ouverture de l'application, vous serez invités à installer la mise à jour pour le kernel Linux, disponible [ici](https://aka.ms/wsl2kernel) en cliquant sur `WSL2 Linux kernel update package for x64 machines`, nécessaire pour le bon fonctionnement de Docker Desktop.
 Des intructions détaillées sont disponibles [ici](https://docs.docker.com/desktop/install/windows-install/).

### Créer son docker

Créer un docker consiste à créer un fichier texte (sans extension) nommé Dockerfile contenant la "recette" de l'image. Cette recette commence généralement par faire appel à une image déjà prête puis à la modifier. L'appel à l'image existante se fait via l'instruction FROM, les modifications se feront via des instructions RUN. Un exemple (tiré du blog de Colin Fay) :

```
FROM rocker/r-ver:3.4.4
RUN mkdir /home/analysis
RUN R -e "options(repos = \
  list(CRAN = 'http://mran.revolutionanalytics.com/snapshot/2019-01-06/')); \
  install.packages('tidystringdist')"
```

La première ligne fait appel à une image qui va contenir la version 3.4.4 de R (dans un environnement linux). Cette image se trouve dans un catalogue d'images disponibles en ligne, cf le paragraphe suivant. La deuxième ligne permet, dans l'environnement virtuel (le container), de créer un répertoire *analysis* à la racine, et la troisième d'installer le package R "tydistringdist" dans la version disponible à la date 2019-01-06 dans R.    

## Où trouver un Docker déjà prêt

[Docker Hub](https://hub.docker.com/) est un dépôt distant similaire à GitHub pour le partage des images Docker (voir par exemple le dépôt de [``stateofther''](https://hub.docker.com/u/stateofther)).

Pour importer une image Docker, il suffit d'utiliser la commande `docker pull USERNAME/IMAGENAME:TAG` correspondant à l'image `USERNAME/IMAGENAME:TAG` que l'on souhaite importer.

Pour déposer une image sur Docker Hub, il faut d'abord créer son compte pour créer son propre dépôt.
Ensuite, il faut s'assurer que son image possède un nom de la forme `USERNAME/IMAGENAME`.
Si besoin, il est possible de créer une copie de l'image avec un nom adéquat via `docker tag IMAGENAME USERNAME/IMAGENAME`.
Ensuite, l'image peut être déposée sur Docker Hub via `docker push USERNAME/IMAGENAME:TAG`.

Le `TAG` qui est ajouté en fin de nom permet de spécifier la version de l'image déposée ou de l'image à importer, par exemple `stateofther/r-finistr2021:0.7`.

Lors de l'écriture d'un fichier `Dockerfile` pour la création d'une image Docker, au lieu de partir de rien, on récupère en général une image pré-existante à partir de laquelle commencer, via la commande  `FROM` (cf la section suivante).
En pratique, `FROM` récupère l'image sur Docker Hub, dans le dépôt correspondant.

## Différences entre  RUN et CMD

Les commandes RUN et CMD permettent de modifier une image existante en rajpoutant des instructions (créer des objets dans l'environnement virtuel, rajouter des packages, installer d'autres logiciels, créer un pont entre l'environnement virtuel et son répertoire local pour récupérer des objets créés dans l'environnement virtuel). La différence entre les deux instructions est que RUN sera exécutée lors de la construction de l'image (i.e. lorsque l'on exécute la commande `docker build`), tandis que CMD sera exécutée lors de l'instanciation (ie lorsque l'on exécute la commande `docker run`)  
Exemple : supposons que l'on souhaite lancer un script R (contenu dans le fichier Script.R) dans l'environnement virtuel, et que ce script génère un tirage aléatoire. L'instruction  `RUN R -e "source('/home/analysis/ScriptR.R')"` réalisera le tirage lors de la création de l'image, tous les conteneurs générés à partir de cette image contiendront donc la même réalisation du tirage. A l'inverse la commande `CMD R -e "source('/home/analysis/ScriptR.R')"` réalisera le tirage lors de la création du conteneur, et chaque exécution de la commande `docker run` génerera un tirage différent.  

## Variables d'environnement
Comme RUN et CMD il y a deux moyens de définir des variables d'environnement: celles qui seront disponible au build et celles qui seront disponibles dans le container. 

Dans le Dockerfile du site on trouve 

```{r env_build, echo = TRUE, eval = FALSE}
RUN export DEBIAN_FRONTEND=noninteractive
```
Cette commande définit une variable d'environnement pour construire l'image (d'où l'utilisation de la commande RUN).

On a besoin pour construire ce site de définir une variable d'environnement `R_CRAN_WEB` pour une fonction utilisée dans R. C'est possible grâce à la commande ENV, et c'est fait dans la recette à la ligne 

```{r env_run, echo = TRUE, eval = FALSE}
ENV R_CRAN_WEB="https://cran.rstudio.com/" 
```

## Autres instructions utiles à inclure dans un docker file:

`COPY` : permet de copier un fichier de son disque local sur l'environnement virtuel (eg pour passer un fichier de données)

`ARG` : permet de passer des arguments qui seront utilisés dans l'exécution du dockerfile (eg la version de R qui doit être montée)

`WORKDIR` : espace de travail courant lors de l'exécution de l'image

`EXPOSE` : gestion des ports


## Schéma récapitulatif

![](docker.drawio.png)