Introduction à Docker

A la fin de ce TP, vous serez capable d’installer Docker, de comprendre son fonctionnement, de créer des images Docker, de les déployer, de les utiliser et de les publier sur Docker Hub.

Partie 1: Comprendre Docker (30 minutes)

Docker est une plateforme open source qui permet d’automatiser le déploiement, la mise à l’échelle et la gestion des applications dans des conteneurs. Les conteneurs Docker sont des unités standardisées qui peuvent être créées sur la machine de l’utilisateur et qui contiennent tout ce dont une application a besoin pour fonctionner, y compris le code, les runtimes, les bibliothèques et les variables système. Cela permet d’assurer que l’application fonctionnera sur n’importe quelle autre machine Linux, indépendamment des configurations de la machine hôte qui peuvent différer de celles de la machine sur laquelle le code a été écrit.

Pour plus d’informations sur Docker, vous pouvez consulter les sites suivants:

– Documentation officielle de Docker : https://docs.docker.com/get-started/overview/
– Guide de démarrage rapide de Docker: https://www.docker.com/get-started
– Introduction à Docker par DigitalOcean : https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-18-04

Partie 2: Installation de Docker (30 minutes)

1. Allez sur le site officiel de Docker et téléchargez Docker Desktop pour Windows: https://www.docker.com/products/docker-desktop

2. Suivez les instructions d’installation.

3. Une fois l’installation terminée, ouvrez le terminal (PowerShell par exemple) et tapez `docker –version` pour vérifier que Docker est bien installé. Vous devriez voir quelque chose comme: `Docker version 20.10.7, build f0df350`

Partie 3: Utiliser Docker (1 heure)

1. Ouvrez votre terminal et tapez `docker run hello-world`. Cela téléchargera et exécutera l’image “hello-world” de Docker. Vous devriez voir un message vous disant que votre installation de Docker fonctionne correctement.

2. Apprenez les commandes de base de Docker. Voici quelques-unes des plus importantes:

– `docker images`: liste les images Docker disponibles localement
– `docker ps`: liste les conteneurs Docker en cours d’exécution
– `docker ps -a`: liste tous les conteneurs Docker, y compris ceux qui sont arrêtés
– `docker run [image]`: lance un conteneur à partir d’une image
– `docker stop [container]`: arrête un conteneur en cours d’exécution
– `docker rm [container]`: supprime un conteneur
– `docker rmi [image]`: supprime une image

Partie 4: Création d’une image Docker (1 heure)

Avant de créer votre image Docker, assurez-vous d’avoir Node.js et npm (le gestionnaire de paquets de Node.js) installés sur votre machine. Si ce n’est pas le cas, vous pouvez les installer à partir de https://nodejs.org.

1. Créez un nouveau dossier pour votre projet Docker et naviguez-y dans votre terminal.

2. Créez un nouveau fichier `package.json` avec le contenu suivant:

{
  "name": "docker-node-demo",
  "version": "1.0.0",
  "description": "Node.js on Docker",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.16.1"
  }
}

3. Dans le terminal, naviguez dans le répertoire du projet et exécutez `npm install` pour installer les dépendances du projet.

4. Créez un fichier `server.js` dans le même dossier avec le contenu suivant:

const express = require('express');

const app = express();
const port = 8080;

app.get('/', (req, res) => {
  res.send('Hello World! This is my Dockerized Node.js app.');
});

app.listen(port, () => {
  console.log(`App running on http://localhost:${port}`);
});

5. Vous pouvez tester votre application en exécutant `npm start` dans votre terminal. Vous devriez pouvoir accéder à votre application en ouvrant un navigateur et en allant à `http://localhost:8080`.

6. Maintenant, nous allons Dockeriser cette application. Créez un fichier `Dockerfile` dans le même dossier avec le contenu suivant:

# Utilisez une image de base (dans ce cas, une version légère de Node.js)
FROM node:14-alpine

# Définit le répertoire de travail dans le conteneur
WORKDIR /app

# Copiez package.json et package-lock.json
COPY package*.json ./

# Installez les dépendances
RUN npm install

# Copiez le reste des fichiers de l'application
COPY . .

# Exposez le port sur lequel votre application s'exécutera
EXPOSE 8080

# Démarrez l'application
CMD [ "npm", "start" ]

7. Dans le terminal, naviguez dans le répertoire du projet et exécutez `docker build -t my-node-app .` pour créer l’image Docker.

8. Une fois l’image créée, exécutez `docker run -p 8080:8080 -d my-node-app` pour démarrer un conteneur basé sur votre nouvelle image. Vous devriez pouvoir accéder à votre application en allant à `http://localhost:8080` dans votre navigateur.

Note: Si vous rencontrez des problèmes de permissions lors de l’installation des dépendances de Node.js, vous pouvez ajouter un argument de l’utilisateur à votre Dockerfile (`USER node`) ou exécuter npm avec un drapeau global (`npm install –global`).

 Partie 5: Gestion des conteneurs Docker (30 minutes)

1. Lancer un nouveau conteneur à partir de votre image avec le nom de votre choix: `docker run –name my-container -p 8080:8080 -d my-node-app`.

2. Affichez la liste des conteneurs en cours d’exécution avec `docker ps`.

3. Arrêtez le conteneur en cours d’exécution avec `docker stop my-container`.

4. Vérifiez que le conteneur a bien été arrêté avec `docker ps -a`.

5. Redémarrez le conteneur avec `docker start my-container`.

6. Supprimez le conteneur avec `docker rm my-container`.

 Partie 6: Création d’une image multi-services avec Docker Compose (1 heure)

Docker Compose est un outil pour définir et exécuter des applications Docker multi-conteneurs. Il utilise des fichiers YAML pour configurer les services de l’application.

1. Installez Docker Compose en suivant les instructions de la [documentation officielle](https://docs.docker.com/compose/install/).

2. Créez un nouveau dossier pour ce projet et naviguez-y dans votre terminal.

3. Créez un fichier `docker-compose.yml` avec le contenu suivant:

version: '3'
services:
  web:
    build: .
    ports:
     - "5000:5000"
  redis:
    image: "redis:alpine"

4. Ce fichier définit deux services: `web` et `redis`. Le service `web` utilise l’image Docker que nous avons précédemment construite (la configuration de build est indiquée par le `.`). Le service `redis` utilise une image prédéfinie de Redis.

5. Pour lancer votre application avec Docker Compose, tapez `docker-compose up` dans votre terminal.

6. Vous pouvez arrêter votre application en tapant `docker-compose down` dans votre terminal.

Partie 7: Publication de votre image sur Docker Hub (30 minutes)

1. Créez un compte sur [Docker Hub](https://hub.docker.com/) si vous n’en avez pas déjà un.

2. Connectez-vous à Docker Hub dans votre terminal avec la commande `docker login`.

3. Taguez votre image avec votre nom d’utilisateur Docker Hub et le nom de votre choix pour le dépôt. Par exemple, si votre nom d’utilisateur est `myusername` et que vous voulez nommer votre dépôt `my-node-app`, vous pouvez taper `docker tag my-node-app myusername/my-node-app`.

4. Poussez votre image sur Docker Hub avec la commande `docker push myusername/my-node-app`.

5. Allez sur Docker Hub et vérifiez que votre image est bien apparue dans vos dépôts. Vous pouvez maintenant la tirer sur n’importe quelle machine avec Docker installé en utilisant la commande `docker pull myusername/my-node-app`.

 Introduction à Kubernetes

Durée: 1 heure

À la fin de ce TP, vous serez capable de comprendre les principes de base de Kubernetes, et vous saurez comment déployer une application sur un cluster Kubernetes.

 Partie 1: Comprendre Kubernetes (15 minutes)

Kubernetes, également connu sous le nom de K8s, est un système open source qui permet d’automatiser le déploiement, la mise à l’échelle et la gestion des applications conteneurisées. Il regroupe les conteneurs qui composent une application en unités logiques pour faciliter leur gestion et leur découverte.

Ressources utiles pour la lecture :

– Documentation officielle de Kubernetes : https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/
– Introduction à Kubernetes : https://www.redhat.com/fr/topics/containers/what-is-kubernetes

 Partie 2: Installation de Minikube (15 minutes)

Minikube est un outil qui permet de faire fonctionner Kubernetes localement, ce qui peut être très utile pour apprendre et tester.

1. Allez sur le site officiel de Minikube et suivez les instructions d’installation pour Windows: https://minikube.sigs.k8s.io/docs/start/

2. Une fois Minikube installé, ouvrez un terminal et tapez `minikube start` pour lancer le cluster.

3. Vérifiez que tout fonctionne correctement en tapant `minikube status`. Vous devriez voir que votre cluster est en cours d’exécution.

 Partie 3: Déploiement d’une application sur Kubernetes (30 minutes)

1. Nous allons déployer une application simple pour ce TP. Pour cela, nous allons utiliser l’image Docker `my-node-app` que vous avez créée et publiée sur Docker Hub.

2. Pour déployer l’application, nous allons créer un déploiement Kubernetes. Un déploiement est une ressource Kubernetes qui gère un ou plusieurs pods (les unités les plus petites de Kubernetes, qui exécutent vos conteneurs). Créez un fichier nommé `my-node-app-deployment.yaml` avec le contenu suivant:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-node-app-deployment
  labels:
    app: my-node-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-node-app
  template:
    metadata:
      labels:
        app: my-node-app
    spec:
      containers:
      - name: my-node-app
        image: myusername/my-node-app
        ports:
        - containerPort: 8080

3. Ce déploiement créera deux pods exécutant votre application. Pour créer le déploiement, tapez `kubectl apply -f my-node-app-deployment.yaml` dans votre terminal.

4. Vérifiez que votre déploiement a été créé avec succès en tapant `kubectl get deployments`.

5. Pour que votre application soit accessible depuis l’extérieur du cluster, vous devez créer un service. Un service est une autre ressource Kubernetes qui fournit un point d’accès stable à un ou plusieurs pods. Créez un fichier nommé `my-node-app-service.yaml` avec le contenu suivant:

apiVersion: v1
kind: Service
metadata:
  name: my-node-app-service
spec:
  selector:
    app: my-node-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

6. Créez le service en tapant `kubectl apply -f my-node-app-service.yaml` dans votre terminal.

7. Vérifiez que votre service a été créé avec succès en tapant `kubectl get services`.

8. Pour accéder à votre application, tapez `minikube service my-node-app-service` dans votre terminal. Cela devrait ouvrir votre application dans un navigateur.