# Docker

# Installation

**YOU NEED A LINUX**


Sous Linux (Ubuntu), installer docker (`sudo apt-get install docker`), les droits
root sont nécessaires pour installer et utiliser docker). 
Sous Fedora, c’est podman (pas besoin de droits root pour utiliser podman).


# Dockerfile

Create a file `Dockerfile` **in the folder `session-1`**.



```docker
FROM ubuntu:22.10

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update 
RUN apt install --no-install-recommends -y libgtest-dev libgmock-dev lcov

ADD . /media/tp-qlog
```


Le `FROM` indique quelle image Docker de base est à utiliser. Le `RUN` exécute une commande dans l'instance docker lors de sa création (ici on installe des paquets). `ADD` permet à aux instances docker de cette image d'accéder à votre dossier courant (par défaut votre instance docker n'accède à rien de la machine hôte). Le `ENV` permet de définir une variable d'environnement.

Lancer: 

`sudo docker build -t tp-qlog .` 

pour créer votre image docker *tp-qlog* (n'oubliez pas le `.` après `tp-qlog` !). La commande `sudo docker image ls` permet de voir les images stockées sur votre machine.


# Lancer une instance docker de votre image

`sudo docker run -it --name qlog-instance tp-qlog`

L'option `name` donne un nom à l'instance créée.
`tp-qlog` est l'image docker à instancier.
L'option `t` permet de lancer un terminal dans l'instance.
L'option `i` permet de rendre l'instance interactive (sinon c'est un processus lancé en tâche de fond).


# Utiliser l'instance docker

Une fois lancé, votre terminal est dans l'instance docker.

`cd /media/tp-qlog/`

Lancer le fichier `compilerun.sh`.
Vous devriez avoir un message d'erreur (il ne connait pas `g++`). C'est bien la preuve qu'il n'utilise pas les ressources de votre Linux mais celles de l'instance lancée.

# Modifications de l'image docker

Vous allez modifier l'image docker pour y ajouter g++.

`exit`

pour former votre instance Docker.

`sudo docker rm qlog-instance`



pour la supprimer (on ne peut pas avoir plusieurs instances docker du même nom).

Dans le *dockerfile*, ajoutez `g++` à la ligne du `apt install` et recréez l'image. Relancez une instance et retentez de compiler.

Pour information, il est possible de partager une image docker en la déposant sur certains sites (https://hub.docker.com/, ou sur des registres d'instances Gitlab : https://gitlab.inria.fr/diverse/docker/container_registry).


# Intégration continue (CI)

Mettre en place l'intégration continue avec le gitlab de l'INSA (https://gitlab.insa-rennes.fr). Aidez-vous du document https://moodleng.insa-rennes.fr/mod/resource/view.php?id=37258.

Votre projet contient déjà un fichier de configuration pour la CI : `.gitlab-ci.yaml`

Pour brancher votre projet au runner gitlab, envoyez-moi le token de votre projet car seuls les INFO peuvent accéder aux serveurs BOO.

# Dépôts image docker sur gitlab

Comme indiqué précédemment, vous pouvez fabriquer et déposer vos images docker sur votre projet gitlab.

## Configuration

Assurez-vous que des les *settings* du projet l'option `container registry` soit activée, ce qui doit permettre l'affichage d'un menu `Packages & Registries > Container registry` à gauche.

Voici un exemple de configuration à ajouter dans le `.gitlab-ci.yaml` pour la fabrication d'images docker.

## Création d'un programme

Créer et commiter un programme `Hello World` quelconque dans un nouveau dossier `hello`. Le binaire produit à la compilation devra s'appeller `main`.


## Compiler le *Hello World* avec la CI

Regardez le fichier `.gitlab-ci.yaml` pour y ajouter une nouvelle rubrique `build-tp-docker` en vous inspirant de celle `build-gtest`.

Cette nouvelle rubrique devra se terminer par :

```yaml
artifacts:
paths:
    - hello/main
expire_in: 1 hour
```

Cela permet à cette rubrique d'exporter le résultat de la compilation, à savoir l'exécutable `main`.


## Le dockerfile du *Hello World*

Créer un dockerfile dans le dossier *hello* avec le code suivant :

```dockerfile
FROM ubuntu:22.10

RUN mkdir -p /usr/src/qlog
COPY main /usr/src/qlog

CMD ["/usr/src/qlog/main"]
```

Nous copions l'exécutable `main` dans le dossier `/usr/src/qlog` de l'image docker.

Créer l'image docker en utilisant les commandes docker du début.




## Créer l'image docker de *Hello World* avec la CI


```yaml
docker-tp1-qlog:
  image:
    name: gcr.io/kaniko-project/executor:v1.5.1-debug
    entrypoint: [""]
  stage: deploy
  dependencies:
    - build-tp-docker
  script:
    - mkdir -p /kaniko/.docker
    - echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json
    - /kaniko/executor --context $CI_PROJECT_DIR/hello/ --dockerfile $CI_PROJECT_DIR/hello/Dockerfile --destination $CI_REGISTRY_IMAGE/hello:latest
```

## Utiliser l'image créée et stockée sur Gitlab

L'étape précédent construit et stocke l'image Docker.
Vous pouvez la télécharger à partir de n'importe quel PC:

`sudo docker pull gitlab.insa-rennes.fr:5050/votrelogin/qlog/hello`

Pour connaitre le chemin de l'image, allez sur votre projet gitlab. *Container Registry* devrait lister un élément : différentes versions de votre image `hello`. Utilisez le bouton *Copy Image Path*.

Vous pouvez alors instancier cette image :

`sudo docker run -it --name hello-instance hello`


**Quels sont les intérets de créer de telles images ?**


## Nettoyage

Les images créées prennent de la place sur le Gitlab de l'INSA : 

Allez dans *Container Registry* et cliquer sur la poubelle rouge à droite pour supprimer toutes les images.