Membre :

BIKINGA Mouhammad Hassan

TRAORE Adama

Rôle :

BIKINGA Mouhammad Hassan : rédaction script , documentation,pdf,

réflexion sur les avantages de la containerisation dans le contexte du
cloud .

TRAORE Adama : installation docker, test script de Hassan et capture,

réflexion sur les avantages de la containerisation dans le contexte du
cloud .

Partie 1 : Installation et Configuration de Docker

Concepts de base : Image et Conteneur Docker

1. Image Docker :

Une image Docker est une sorte de modèle immuable qui contient tout ce
dont un logiciel a besoin pour fonctionner, y compris le code de
l’application, les bibliothèques, les dépendances et la configuration. C’est
une « photo » statique d’un environnement prêt à être utilisé. Les images
sont construites à partir d’instructions contenues dans un fichier
`Dockerfile`, qui définit chaque étape de la construction de l’image
(comme installer un package ou copier des fichiers).

En résumé, une image est un modèle inerte à partir duquel un conteneur

peut être lancé.

2. Conteneur Docker :

Un conteneur Docker est une instance en cours d’exécution d’une image

Docker. Une fois qu’une image est lancée, elle devient un conteneur actif,
avec son propre système de fichiers, son propre réseau, et ses propres
processus. Les conteneurs sont isolés du système hôte et des autres
conteneurs, mais ils partagent le noyau du système d’exploitation.
En résumé, un conteneur est une instance vivante d’une image avec son
propre environnement isolé.

Étapes pour manipuler les images Docker

1. Télécharger une image depuis Docker Hub

Docker Hub est le référentiel central où sont stockées les images Docker
publiques. Pour télécharger une image, utilise la commande `docker pull`.

Exemple pour télécharger une image Ubuntu :

```

Docker pull ubuntu

```

Cette commande récupère l’image Ubuntu la plus récente depuis Docker

Hub et la stocke localement sur ta machine.

2. Lister les images Docker disponibles localement

Une fois que tu as téléchargé des images, tu peux voir celles qui sont
disponibles localement avec la commande `docker images` :

```

Docker images

```

Cette commande affiche une liste de toutes les images stockées

localement, avec les informations suivantes :

- REPOSITORY : le nom de l’image (ex. : ubuntu)

- TAG : la version de l’image (par défaut, c’est souvent `latest`)

- IMAGE ID : l’identifiant unique de l’image

- CREATED : la date de création de l’image

- SIZE : la taille de l’image

Exemple de sortie :

```

REPOSITORY TAG IMAGE ID CREATED SIZE

Ubuntu latest 4e5021d210f6 2 weeks ago 72.8MB

Hello-world latest d1165f221234 3 months ago 13.3kB

```

3. Exécuter un conteneur à partir d’une image

Pour démarrer un conteneur à partir d’une image, tu utilises la commande

`docker run`. Par exemple, pour lancer un conteneur basé sur l’image
`ubuntu` :

```

Docker run -it ubuntu

```

Ici :

- `-it` indique que tu veux un terminal interactif (pour exécuter des

commandes).

- `ubuntu` est l’image à utiliser.

- `` est la commande à exécuter une fois que le conteneur est lancé.

Cela te donne accès à un terminal dans le conteneur Ubuntu.

Partie 2 : Premières Commandes Docker

Concepts d’Image et de Conteneur Docker

1. Image Docker

Une image Docker est un fichier statique, en lecture seule, qui contient
tous les fichiers nécessaires à l’exécution d’une application. Cela inclut le
code de l’application, les bibliothèques, les dépendances, les variables
d’environnement et les instructions pour démarrer l’application. Les
images sont basées sur des couches, ce qui signifie qu’elles peuvent
partager des parties communes pour économiser de l’espace disque.

- Construction : Les images sont souvent créées à partir d’un fichier

`Dockerfile`, qui contient les instructions sur comment construire l’image.

- Immutabilité : Une fois qu’une image est créée, elle ne peut plus être
modifiée. Pour apporter des changements, vous devez créer une nouvelle
image.

2. Conteneur Docker
Un conteneur Docker est une instance d’une image en cours d’exécution.
Contrairement aux images, les conteneurs sont des environnements isolés
et peuvent être modifiés. Les conteneurs utilisent le système de fichiers de
l’image, mais ils peuvent également écrire des fichiers et conserver des
données.

- Exécution : Lorsque vous exécutez une image, Docker crée un conteneur

basé sur cette image.

- Isolation : Chaque conteneur fonctionne dans son propre espace

d’exécution, ce qui permet d’exécuter plusieurs conteneurs sans
interférence.

Étape 2.1 : Manipulation des Images Docker

Télécharger une Image depuis Docker Hub

Docker Hub est un registre public où les utilisateurs peuvent partager et

télécharger des images Docker. Pour télécharger une image, utilisez la
commande `docker pull`.

Exemple : Télécharger l’image de PostgreSQL

Ouvrez un terminal et exécutez la commande suivante :

```

Docker pull postgres

```

Cette commande va télécharger la dernière version de l’image PostgreSQL

depuis Docker Hub.

Lister les Images Disponibles Localement

Pour voir toutes les images que vous avez téléchargées localement,
utilisez la commande suivante :

```

Docker images

```

Cette commande affichera une liste de toutes les images disponibles sur
votre machine, avec des informations comme l’ID de l’image, le nom, la
balise (tag), et la date de création.

Exemple de sortie :

```plaintext

REPOSITORY TAG IMAGE ID CREATED SIZE

Postgres latest abc123def456 2 days ago 300MB

Mywebapp latest def456abc123 3 days ago 100MB

```
Partie 3 : Création d’une Image Docker Personnalisée
Partie 4 : Gestion des Volumes et des Réseaux Docker
Partie 5 : Projet Final – Containerisation d’une Application Web Complète

Voici un guide étape par étape pour créer une application web simple en
utilisant Python avec Flask et PostgreSQL. Nous allons créer une API qui
permet d’ajouter et de récupérer des utilisateurs.

Étape 1 : Installation des outils nécessaires

1. Installer Python et pip : Assurez-vous d’avoir Python (version 3.x) et

pip installés sur votre machine.

2. Installer PostgreSQL : Téléchargez et installez PostgreSQL à partir de

[[Link]]([Link]

3. Installer les bibliothèques nécessaires :

```

Pip install Flask psycopg2

```

Étape 2 : Création de la base de données

1. Connectez-vous à PostgreSQL :

```
 Psql -U postgres

```

2. Créez une nouvelle base de données :

```sql

CREATE DATABASE mydatabase ;

```

3. Créez une table pour les utilisateurs :

```sql

\c mydatabase ; -- Se connecter à la base de données créée

CREATE TABLE users (

Id SERIAL PRIMARY KEY,

Name VARCHAR(100),

Email VARCHAR(100) UNIQUE NOT NULL

);

```

Étape 3 : Développement de l’application web

1. Créez un fichier `[Link]` et ajoutez le code suivant :

```python

From flask import Flask, request, jsonify

Import psycopg2

App = Flask(__name__)

Connexion à la base de données

 Def get_db_connection() :

Conn = [Link](

Host=’localhost’,

Database=’mydatabase’,

User=’postgres’,

Password=’your_password’ Remplacez par votre mot de passe

PostgreSQL

Return conn

@[Link](‘/users’, methods=[‘POST’])

Def create_user() :

Data = request.get_json()

Name = data[‘name’]

Email = data[‘email’]

Conn = get_db_connection()

Cur = [Link]()

[Link](‘INSERT INTO users (name, email) VALUES (%s, %s)’,

(name, email))

[Link]()

[Link]()

[Link]()

Return jsonify({‘status’ : ‘User created !’}), 201

@[Link](‘/users’, methods=[‘GET’])

Def get_users() :

Conn = get_db_connection()

Cur = [Link]()
 [Link](‘SELECT FROM users ;’)

Users = [Link]()

[Link]()

[Link]()

Return jsonify(users), 200

If __name__ == ‘__main__’ :

[Link](debug=True)

```

Étape 4 : Tester l’application localement

1. Démarrez l’application :

```

Python [Link]

```

2. Testez les endpoints :

- Pour ajouter un utilisateur :

Utilisez `curl` ou Postman pour faire une requête POST :

```

Curl -X POST [Link] -H « Content-Type:

application/json » -d’{« name » : « John Doe », « email » :
« john@[Link] »}’

```

- Pour récupérer les utilisateurs :

```
 Curl [Link]

```

Voici une documentation détaillée des étapes de développement de

l’application web simple en Python avec Flask et PostgreSQL.

Documentation du Projet : Application Web Simple avec Flask et

PostgreSQL

Objectif

Containeriser une application web simple qui interagit avec une base de
données PostgreSQL. L’application permet d’ajouter et de récupérer des
utilisateurs via une API REST.

Étape 1 : Installation des Outils Nécessaires

Prérequis

- Python 3.x : Assurez-vous que Python est installé sur votre machine. Vous
pouvez le télécharger à partir de [[Link]]
([Link]

- PostgreSQL : Téléchargez et installez PostgreSQL depuis [[Link]]

([Link]

Installation des Bibliothèques

Ouvrez un terminal et installez Flask et psycopg2 à l’aide de pip :

```
Pip install Flask psycopg2

```

Étape 2 : Création de la Base de Données

1. Connexion à PostgreSQL :

Ouvrez le terminal et connectez-vous à PostgreSQL :

```

Psql -U postgres

```

2. Création de la Base de Données :

Créez une nouvelle base de données nommée `mydatabase` :

```sql

CREATE DATABASE mydatabase ;

```

3. Création de la Table Utilisateurs :

Connectez-vous à la base de données et créez la table `users` :

```sql

\c mydatabase ; -- Se connecter à la base de données

CREATE TABLE users (

Id SERIAL PRIMARY KEY,

Name VARCHAR(100),

Email VARCHAR(100) UNIQUE NOT NULL

);
 ```

Étape 3 : Développement de l’Application Web

1. Création du Fichier `[Link]` :

Créez un fichier nommé `[Link]` et ajoutez le code suivant :

```python

From flask import Flask, request, jsonify

Import psycopg2

App = Flask(__name__)

Connexion à la base de données

Def get_db_connection() :

Conn = [Link](

Host=’localhost’,

Database=’mydatabase’,

User=’postgres’,

Password=’your_password’ Remplacez par votre mot de passe

PostgreSQL

Return conn

@[Link](‘/users’, methods=[‘POST’])

Def create_user() :

Data = request.get_json()

Name = data[‘name’]

Email = data[‘email’]
 Conn = get_db_connection()

Cur = [Link]()

[Link](‘INSERT INTO users (name, email) VALUES (%s, %s)’,

(name, email))

[Link]()

[Link]()

[Link]()

Return jsonify({‘status’ : ‘User created !’}), 201

@[Link](‘/users’, methods=[‘GET’])

Def get_users() :

Conn = get_db_connection()

Cur = [Link]()

[Link](‘SELECT FROM users ;’)

Users = [Link]()

[Link]()

[Link]()

Return jsonify(users), 200

If __name__ == ‘__main__’ :

[Link](debug=True)

```

Étape 4 : Tester l’Application Localement

1. Démarrage de l’Application :
 Exécutez l’application en lançant la commande suivante dans le
terminal :

```

Python [Link]

```

2. Tests des Endpoints :

- Ajouter un Utilisateur :

Utilisez `curl` ou Postman pour faire une requête POST. Par exemple :

```

Curl -X POST [Link] -H « Content-Type:

application/json » -d’{« name » : « John Doe », « email » :
« john@[Link] »}’

```

Réponse attendue :

```json

{« status » : « User created ! »}

```

- Récupérer les Utilisateurs :

Exécutez la commande suivante :

```

Curl [Link]

```
 Réponse attendue :

```json

[[1, « John Doe », « john@[Link] »]]

```

Étape 5 : Documentation Finale

Cette documentation couvre le développement d’une application web

simple utilisant Flask et PostgreSQL. Chaque étape a été détaillée pour
assurer une compréhension claire du processus.

Voici les étapes pour containeriser l’application web que nous avons
développée. Nous allons créer un `Dockerfile`, configurer un réseau
Docker et lancer les conteneurs pour l’application et la base de données.

Étape 1 : Créer un Dockerfile pour l’Application Web

1. Créer un fichier nommé `Dockerfile` dans le même répertoire que

votre fichier `[Link]` et ajoutez le contenu suivant :

```dockerfile

Utiliser une image de base Python

FROM python :3.9-slim

Définir le répertoire de travail

WORKDIR /app

Copier les fichiers nécessaires

COPY [Link] [Link]

RUN pip install –no-cache-dir -r [Link]

 COPY [Link] [Link]

Exposer le port sur lequel l’application va tourner

EXPOSE 5000

Commande pour exécuter l’application

CMD [« python », « [Link] »]

```

2. Créer un fichier `[Link]` pour spécifier les dépendances

Python :

```plaintext

Flask

Psycopg2

```

Étape 2 : Utiliser une Image Docker Officielle pour PostgreSQL

Nous allons utiliser l’image officielle de PostgreSQL disponible sur Docker

Hub.

Étape 3 : Configurer un Réseau Docker

Pour permettre à l’application web de communiquer avec la base de

données, nous allons créer un réseau Docker.

1. Ouvrez un terminal et créez un réseau Docker :

```bash
 Docker network create mynetwork

```

Étape 4 : Lancer les Conteneurs

1. Construire l’image Docker pour l’application web :

Dans le répertoire où se trouve votre `Dockerfile`, exécutez :

```bash

Docker build -t mywebapp .

```

2. Lancer le conteneur PostgreSQL :

Exécutez la commande suivante pour démarrer le conteneur de la base

de données :

```bash

Docker run –name mydb –network mynetwork -e

POSTGRES_USER=postgres -e POSTGRES_PASSWORD=your_password -e
POSTGRES_DB=mydatabase -d postgres

```

Remplacez `your_password` par le mot de passe de votre choix.

3. Lancer le conteneur de l’application web :

Maintenant, exécutez le conteneur de l’application web :

 ```bash

Docker run –name webapp –network mynetwork -p 5000 :5000 -e

DATABASE_URL=postgresql://postgres :your_password@mydb/mydatabase
-d mywebapp

```

Étape 5 : Vérifier l’Interaction

1. Vérifiez si les conteneurs sont en cours d’exécution :

Utilisez la commande suivante pour voir les conteneurs en cours

d’exécution :

```bash

Docker ps

```

2. Tester l’Application :

Vous pouvez maintenant tester votre application de la même manière

qu’auparavant. Par exemple, utilisez `curl` pour ajouter un utilisateur :

```bash

Curl -X POST [Link] -H « Content-Type:

application/json » -d’{« name » : « Jane Doe », « email » :
« jane@[Link] »}’

```

Pour récupérer les utilisateurs :

```bash
 Curl [Link]

```

Réflexion sur les Avantages de la Containerisation dans le Contexte du

Cloud

La containerisation, en particulier à travers des outils comme Docker,

représente une avancée significative dans le domaine du développement
logiciel et des déploiements cloud. Voici quelques-uns des principaux
avantages de cette technologie :

1. Portabilité et Consistance

Les conteneurs encapsulent une application et toutes ses dépendances,

assurant ainsi qu’elle s’exécute de manière cohérente sur n’importe quelle
plateforme ou environnement. Cela réduit le célèbre problème « Ça
fonctionne sur ma machine ! » en garantissant que le comportement de
l’application est le même, que ce soit en développement, en test ou en
production. En intégrant des conteneurs dans un environnement cloud, les
équipes peuvent déplacer facilement les applications entre différents
fournisseurs ou même entre des environnements cloud et locaux.

2. Scalabilité et Gestion des Ressources

Les conteneurs permettent de déployer plusieurs instances d’une même

application sur un même serveur sans les conflits habituels de
dépendances. Dans le contexte du cloud, cela se traduit par une meilleure
utilisation des ressources et une réduction des coûts. Les fournisseurs
cloud proposent souvent des services de mise à l’échelle automatique qui
fonctionnent de manière optimale avec des applications conteneurisées,
permettant de répondre à des pics de demande sans intervention
manuelle.
3. Isolation et Sécurité

Les conteneurs offrent un niveau d’isolation des processus qui améliore la

sécurité. Chaque conteneur fonctionne dans son propre environnement, ce
qui réduit le risque de conflits entre applications et d’accès non autorisé
aux ressources. Dans le cloud, cette isolation aide à limiter les impacts des
failles de sécurité, en empêchant un conteneur compromis d’affecter les
autres.

4. Déploiement et CI/CD Simplifiés

La containerisation facilite l’intégration continue et le déploiement continu

(CI/CD). Les équipes peuvent automatiser le processus de test, de
construction et de déploiement de leurs applications. Les conteneurs
permettent des mises à jour et des rollbacks rapides, rendant le cycle de
vie des applications plus agile. Cela s’intègre parfaitement aux pratiques
DevOps, qui sont souvent encouragées dans les environnements cloud.

5. Meilleure Gestion des Dépendances

Les conteneurs contiennent toutes les dépendances nécessaires pour

exécuter une application, éliminant ainsi les problèmes liés à la
configuration des environnements. Cela est particulièrement avantageux
dans le cloud, où les environnements peuvent changer rapidement. Les
développeurs peuvent se concentrer sur la création d’applications plutôt
que sur la gestion des environnements.

6. Économie de Temps et de Coûts

L’utilisation de conteneurs réduit le temps de mise en œuvre des

applications. Les environnements de développement et de production
peuvent être configurés rapidement, et le temps nécessaire pour résoudre
les problèmes liés à la configuration des environnements diminue. Cela se
traduit par des économies de coûts, tant en termes de ressources
humaines que de ressources matérielles dans le cloud.

Conclusion

En somme, la containerisation apporte une multitude d’avantages qui

améliorent non seulement le développement et le déploiement des
applications, mais qui s’intègrent également parfaitement avec les
environnements cloud modernes. Les entreprises qui adoptent cette
technologie peuvent bénéficier d’une plus grande agilité, d’une meilleure
sécurité et d’une efficacité accrue, leur permettant de rester compétitives
dans un marché en constante évolution. La synergie entre la
containerisation et le cloud représente une opportunité stratégique pour
les organisations cherchant à optimiser leurs opérations et à innover
rapidement.