vuminh224/tlc_tp1_docker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update README.md

Browse Source 
Adding hello.c
This commit is contained in:
karsalan
2025-01-27 19:17:18 +01:00
parent af0934f813
commit 1ac8652176
2 changed files with 91 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
README.md
View File

@@ -34,7 +34,7 @@ Il est fortement conseillé de dérouler ce TP sur une machine Linux (Ubuntu, Fe
1. Installez Docker dans votre environnement de développement. 1. Installez Docker dans votre environnement de développement.
2. Clonez ce dépot. 2. Clonez ce dépot.
## [PARTIE 1] Dockerisation de l'Application ## [PARTIE 1] Dockeriser une application
### Commandes Utiles ### Commandes Utiles
@@ -61,43 +61,28 @@ Il est fortement conseillé de dérouler ce TP sur une machine Linux (Ubuntu, Fe
D'autres commandes sont disponibles [ici](https://docs.docker.com/reference/cli/docker/). D'autres commandes sont disponibles [ici](https://docs.docker.com/reference/cli/docker/).
<details> ### Tâche 1 : Créer une Image Docker à partir de `scratch`
<summary>Étape 1 : version scratch À EFFACER SI NON RETENU</summary>
### Étape 1: Créer une Image Docker à partir de `scratch` > Créez un `Dockerfile` à partir d'une image vierge :
> Pour la syntaxe du Dockerfile, vous pouvez consulter la documentation officielle de Docker, lien ci-dessous. > - Compilez le fichier `hello.c` (dans le dossier **step1.1**) avec `gcc -o hello_dyn hello.c`
> - Créez un Dockerfile et utilisez `scratch` comme image de base.
> - Ajoutez le fichier binaire `hello_dyn` et définissez la commande de démarrage.
> - Build et exécutez l'image. Est-ce que le conteneur démarre correctement ?
1. Création d'un `Dockerfile` à partir d'une image vierge: > Compilez maintenant le fichier `hello.c` avec `gcc -static -o hello hello.c` et utilisez ce binaire au lieu de `hello_dyn`.
- Utilisez une image de base `scratch`. > - Quelle est la différence entre les deux commandes de compilation ?
- Ajoutez le binaire `hello` en commande de démarrage.
- Build, run et vérifiez que tout fonctionne correctement.
2. Ici on va étendre l'image scratch avec l'application Java. ### Tâche 2 : Containériser une application existante
- Installez les dépendances nécessaires pour OpenCV.
- Ajoutez les fichiers sources et compilez l'application.
- Assurez d'avoir la bonne commande de démarrage du conteneur.
</details>
<details> > Maintenant, on va utiliser comme image de base quelque chose de plus traditionnel, par exemple `ubuntu:18.04` (ou voir d'autres images pertinentes dans le Docker Hub).
<summary>Étape 1 : version non scratch À EFFACER SI NON RETENUE</summary> > - Installez les dépendances nécessaires pour OpenCV.
> - Ajoutez les fichiers sources (dans le dossier **step1.2**) et compilez l'application.
### Étape 1: Premiers pas avec Docker > - Assurez-vous d'avoir la bonne commande de démarrage du conteneur.
> Pour la syntaxe du Dockerfile, vous pouvez consulter la documentation officielle de Docker, lien ci-dessous.
1. Création d'un `Dockerfile` à partir d'une image de base:
- Utilisez une image de base de votre choix (debian, ubuntu, etc.).
- Ajoutez `echo "Hello World"` en commande de démarrage.
- Build, run et vérifiez que tout fonctionne correctement.
2. Ici on va étendre l'image de base avec l'application Java.
- Installez les dépendances nécessaires pour OpenCV.
- Ajoutez les fichiers sources et compilez l'application.
- Assurez d'avoir la bonne commande de démarrage du conteneur.
</details>
<details> <details>
<summary>Cliquer pour des liens utiles</summary> <summary>Cliquer pour des liens utiles</summary>
- [Dockerhub - repo images](https://hub.docker.com/)
- [Dockerfile Reference](https://docs.docker.com/reference/dockerfile) - [Dockerfile Reference](https://docs.docker.com/reference/dockerfile)
</details> </details>
@@ -118,11 +103,11 @@ D'autres commandes sont disponibles [ici](https://docs.docker.com/reference/cli/
- L'application est accessible sur le port 8080. Assurez-vous d'exposer ce port ou de le bind à un port de votre choix au démarrage du conteneur. Si tout est correct, http://localhost:8080 devrait être ouvert depuis votre navigateur. - L'application est accessible sur le port 8080. Assurez-vous d'exposer ce port ou de le bind à un port de votre choix au démarrage du conteneur. Si tout est correct, http://localhost:8080 devrait être ouvert depuis votre navigateur.
</details> </details>
### Étape 2: Créer une version _Light_ de l'Image ### Tâche 3 : Améliorer le Dockerfile pour une image plus _light_
Maintenant que vous avez une image fonctionnelle, vous allez essayer de la rendre plus légère. >Maintenant que vous avez une image fonctionnelle, vous allez essayer de la rendre plus légère.
>
1. Proposez un nouveau fichier Dockerfile qui permet de créer une image de taille réduite. >Proposez un nouveau fichier Dockerfile qui permet de créer une image de taille réduite.
<details> <details>
<summary>Cliquer pour des liens utiles</summary> <summary>Cliquer pour des liens utiles</summary>
@@ -132,11 +117,8 @@ Maintenant que vous avez une image fonctionnelle, vous allez essayer de la rendr
</details> </details>
## [PARTIE 2] Configuration d'un reverse proxy sous Docker ## [PARTIE 2] Configurer un reverse proxy sous Docker
### Tâche 1 : Simple reverse proxy avec ligne de commande `docker`
### Étape 1: Simple reverse proxy avec ligne de commande `docker`
<details> <details>
<summary> Cliquer pour des liens utiles</summary> <summary> Cliquer pour des liens utiles</summary>
@@ -148,64 +130,64 @@ L'explication du fonctionnement est disponible [ici](http://jasonwilder.com/blog
> Si vous n'avez pas la tête à lire ça, la version abrégée est que le reverse proxy vous permet tout un tas de choses, y compris de gérer le fait que les containers ont des adresses IP (un peu) trop dynamiques, ce qui fait qu'à chaque changement/lancement de container, il y aurait des problèmes de binding de port. Le reverse proxy va vous permettre de cacher ces aspects-là, puisqu'ils seront gérés par ce composant. Ainsi, les chargements de versions modifiées de votre service n'auront pas besoin d'une gestion fine à la main des connexions, les différents utilisateurs qui voudront envoyer des requêtes simultanées au même service ne seront pas embêtés par des ports qui ne sont pas accessibles, etc. > Si vous n'avez pas la tête à lire ça, la version abrégée est que le reverse proxy vous permet tout un tas de choses, y compris de gérer le fait que les containers ont des adresses IP (un peu) trop dynamiques, ce qui fait qu'à chaque changement/lancement de container, il y aurait des problèmes de binding de port. Le reverse proxy va vous permettre de cacher ces aspects-là, puisqu'ils seront gérés par ce composant. Ainsi, les chargements de versions modifiées de votre service n'auront pas besoin d'une gestion fine à la main des connexions, les différents utilisateurs qui voudront envoyer des requêtes simultanées au même service ne seront pas embêtés par des ports qui ne sont pas accessibles, etc.
1. Lancement de nginx en reverse proxy : - Lancement de nginx en reverse proxy :
>
> ```bash
> docker run -d -p 8080:80 -v /var/run/docker.sock:/tmp/docker.sock -t jwilder/nginx-proxy
> ```
>
> ⚠️ Pour certaines installations comme sur la dernière édition de Fedora, les règles de sécurité par défaut ont évolué. Pour que le container puisse accéder à la socket Docker, il faut ajouter l'option suivante :
>
> ```bash
> docker run --security-opt=label:type:docker_t -d -p 8080:80 -v /var/run/docker.sock:/tmp/docker.sock -t jwilder/nginx-proxy
> ```
>
- Si vous êtes sur votre propre portable, modifiez votre fichier `/etc/hosts` pour faire correspondre **m** vers localhost. Ce serait à faire sur votre gestionnaire de nom de domaine en temps normal.
> Vous devez avoir une ligne qui ressemble à cela :
>
> ```txt
> 127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain m
> ```
>
> Pour ceux qui n'ont pas les droits root, exécutez les commandes suivantes :
>
> ```bash
> echo 'm localhost' >> ~/.hosts
> export HOSTALIASES=~/.hosts
> curl m:8080
> ```
>
- Puis créez plusieurs fenêtres dans votre terminal. Ce seront vos différentes machines host émulées. Vous pouvez en créer au moins 3 ou 4. Dans ces terminaux, lancez la commande suivante pour tester votre reverse proxy :
>
> ```bash
> docker run -e VIRTUAL_HOST=m -t -i nginx
> ```
>
- Testez votre reverse proxy en lançant la commande suivante dans votre terminal originel :
>
> ```bash
> curl m:8080
> ```
>
> En l'exécutant plusieurs fois et suffisamment rapidement, vous devriez voir tantôt une fenêtre terminator se mettre à jour, tantôt une autre. C'est l'effet du load balancer (un autre service qui est géré par votre nginx).
>
> En tapant la commande suivante, vous pouvez regarder le fichier de configuration nginx qui sera généré à l'adresse suivante `/etc/nginx/conf.d/default.conf`.
>
> (N'oubliez pas de remplacer `865c1e67a00e` par l'id de votre nginx en reverse proxy (`docker ps`) pour récupérer la liste des containers en cours d'exécution) :
> ```bash
> docker exec -it 865c1e67a00e bash
> ```
>
```bash > ️️⚠️ N'oubliez pas de tuer les conteneurs lancés pour libérer des ressources :
docker run -d -p 8080:80 -v /var/run/docker.sock:/tmp/docker.sock -t jwilder/nginx-proxy >
``` > ```bash
> docker ps # pour avoir la liste
⚠️ Pour certaines installations comme sur la dernière édition de Fedora, les règles de sécurité par défaut ont évolué. Pour que le container puisse accéder à la socket Docker, il faut ajouter l'option suivante : > docker kill "IDDOCKER" # pour tuer un docker
> ```
```bash
docker run --security-opt=label:type:docker_t -d -p 8080:80 -v /var/run/docker.sock:/tmp/docker.sock -t jwilder/nginx-proxy
```
2. Si vous êtes sur votre propre portable, modifiez votre fichier `/etc/hosts` pour faire correspondre **m** vers localhost. Ce serait à faire sur votre gestionnaire de nom de domaine en temps normal.
Vous devez avoir une ligne qui ressemble à cela :
```txt
127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain m
```
Pour ceux qui n'ont pas les droits root, exécutez les commandes suivantes :
```bash
echo 'm localhost' >> ~/.hosts
export HOSTALIASES=~/.hosts
curl m:8080
```
3. Puis créez plusieurs fenêtres dans votre terminal. Ce seront vos différentes machines host émulées. Vous pouvez en créer au moins 3 ou 4. Dans ces terminaux, lancez la commande suivante pour tester votre reverse proxy :
```bash
docker run -e VIRTUAL_HOST=m -t -i nginx
```
4. Testez votre reverse proxy en lançant la commande suivante dans votre terminal originel :
```bash
curl m:8080
```
En l'exécutant plusieurs fois et suffisamment rapidement, vous devriez voir tantôt une fenêtre terminator se mettre à jour, tantôt une autre. C'est l'effet du load balancer (un autre service qui est géré par votre nginx).
En tapant la commande suivante, vous pouvez regarder le fichier de configuration nginx qui sera généré à l'adresse suivante `/etc/nginx/conf.d/default.conf`.
(N'oubliez pas de remplacer `865c1e67a00e` par l'id de votre nginx en reverse proxy (`docker ps`) pour récupérer la liste des containers en cours d'exécution) :
```bash
docker exec -it 865c1e67a00e bash
```
️️⚠️ N'oubliez pas de tuer les conteneurs lancés : ### Tâche 2 : Configurer le reverse proxy dans un fichier Docker Compose
```bash
docker ps # pour avoir la liste
docker kill "IDDOCKER" # pour tuer un docker
```
### Étape 2: Configuration du reverse proxy avec Docker Compose
<details> <details>
<summary>pour interagir avec un deploiement compose</summary> <summary>pour interagir avec un deploiement compose</summary>
@@ -215,7 +197,7 @@ docker kill "IDDOCKER" # pour tuer un docker
- D'autres commandes sont disponibles [ici](https://docs.docker.com/reference/cli/docker/compose/). - D'autres commandes sont disponibles [ici](https://docs.docker.com/reference/cli/docker/compose/).
</details> </details>
1. Créez un fichier **docker-compose.yml** avec `jwilder/nginx-proxy` > - Créez un fichier **docker-compose.yml** avec `jwilder/nginx-proxy`
<details> <details>
<summary>Cliquer pour un exemple</summary> <summary>Cliquer pour un exemple</summary>
@@ -249,9 +231,9 @@ docker kill "IDDOCKER" # pour tuer un docker
</details> </details>
2. Ajoutez un service nginx classique qui utiliserait le reverse proxy et donnez lui un nom vhost. > - Ajoutez un service nginx classique qui utiliserait le reverse proxy et donnez lui un nom vhost.
3. Assurez-vous que votre fichier **/etc/hosts** contient une entrée pour le nom de domaine que vous avez choisi (vhost). > - Assurez-vous que votre fichier **/etc/hosts** contient une entrée pour le nom de domaine que vous avez choisi (vhost).
4. Vérifiez que tout fonctionne correctement en accédant à l'URL du vhost. > - Vérifiez que tout fonctionne correctement en accédant à l'URL du vhost.
<details> <details>
@@ -261,10 +243,10 @@ docker kill "IDDOCKER" # pour tuer un docker
- [Repo officiel jwilder/nginx-proxy](https://hub.docker.com/r/jwilder/nginx-proxy/) - [Repo officiel jwilder/nginx-proxy](https://hub.docker.com/r/jwilder/nginx-proxy/)
</details> </details>
### Étape 3: Docker Compose avec 4 Instances ### Tâche 3 : Docker Compose avec 4 Instances
1. Maintenant que vous avez familiarisé avec Docker Compose et le reverse proxy, remplacez le service nginx par votre application Java en veillant à bien configurer les fichiers nécessaires. > Maintenant que vous avez familiarisé avec Docker Compose et le reverse proxy, ajoutez au **docker-compose.yaml** votre application Java en veillant à bien configurer le service.
2. Vérifiez que l'application fonctionne correctement en accédant à l'URL du vhost. > - Vérifiez que l'application fonctionne correctement en accédant à l'URL du vhost.
3. Créez un fichier `docker-compose-inst.yml` qui permet de deployer 4 instances de l'application. > - Modifiez le fichier compose pour permettre l'exécution de 4 instances de l'application.
<details> <details>
<summary>Cliquer pour des liens utiles</summary> <summary>Cliquer pour des liens utiles</summary>
@@ -277,13 +259,11 @@ docker kill "IDDOCKER" # pour tuer un docker
## Rendu TP Docker ## Rendu TP Docker
- Un fichier `Dockerfile` pour l'application Java. - Un fichier `Dockerfile` pour l'application Java.
- Un fichier `Dockerfile` pour l'application Java version light. - Un fichier `Dockerfile` pour l'application Java version light.
- Un fichier `docker-compose.yml` avec le reverse proxy et un service web simple. - Un fichier `docker-compose.yml` avec le reverse proxy, un service web simple et 4 instances de l'application Java.
- Un fichier `docker-compose-inst.yml` avec 4 instances de l'application Java.
# Annexes # Annexes
<details> <details>
<summary>Annexe 1: Description de l'Application Java</summary> <summary>Annexe 1 : Description de l'Application Java</summary>
# How to compile this application # How to compile this application

5
step1.1/hello.c Normal file
View File

@@ -0,0 +1,5 @@
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}