# Déployer Dockercoins sur Swarm

**Dockercoins** est une application conçue pour démontrer l'utilisation de services interconnectés dans un cluster Docker Swarm. Chaque service collabore pour simuler la génération de "Dockercoins". Suivez ces étapes pour configurer et exploiter cette application efficacement.

***

## 🌐 **Créer un Réseau**

Pour permettre la communication entre les services Dockercoins, nous devons créer un réseau **overlay**.

{% stepper %}
{% step %}
**Réinitialisez l’environnement Docker local** :

```bash
eval $(docker-machine env host1)
```

{% endstep %}

{% step %}
**Créez le réseau overlay** :

```bash
docker network create --driver overlay dockercoins
```

{% endstep %}

{% step %}
**Vérifiez la création du réseau** :

```bash
docker network ls
```

**Exemple de sortie** :

```sql
NETWORK ID     NAME              DRIVER    SCOPE
7525d41e5c7d   bridge            bridge    local
abd253a47efb   docker_gwbridge   bridge    local
qqmlaabbqfsf   dockercoins       overlay   swarm
d939e61b94ce   host              host      local
qqvrzl7qm5bj   ingress           overlay   swarm
0fbd7326ecdf   none              null      local
```

{% endstep %}
{% endstepper %}

***

## 🛠️ Déployer les Services

### 🗄️ **Déploiement de Redis**

Redis est utilisé comme base de données pour stocker les informations nécessaires à l’application.

{% stepper %}
{% step %}

#### **Créez le service Redis** :

```bash
docker service create --network dockercoins --name redis redis:5
```

{% endstep %}

{% step %}

#### **Vérifiez que Redis est en état `Running`** :

```bash
docker service ps redis
```

Exemple de sortie :

```
ID             NAME      IMAGE     NODE      DESIRED STATE   CURRENT STATE           ERROR     PORTS
offw8coloofw   redis.1   redis:5   host2     Running         Running 9 seconds ago
```

{% endstep %}
{% endstepper %}

### ⚙️ Déploiement des Services rng, hasher et worker

Ces services fonctionnent ensemble pour générer des Dockercoins.

{% stepper %}
{% step %}
**Déployez les services** :

```bash
docker service create --network dockercoins --name rng humboldtux/dockercoins_rng:0.1
docker service create --network dockercoins --name hasher humboldtux/dockercoins_hasher:0.1
docker service create --network dockercoins --name worker humboldtux/dockercoins_worker:0.1
```

{% endstep %}

{% step %}
**Surveillez l’état des services** :

```bash
docker service ps rng
docker service ps hasher
docker service ps worker
```

Exemple de sortie :&#x20;

```
ID             NAME      IMAGE                            NODE      DESIRED STATE   CURRENT STATE                ERROR     PORTS
6bcmhoyszwce   rng.1     humboldtux/dockercoins_rng:0.1   host3     Running         Running about a minute ago

ID             NAME       IMAGE                               NODE      DESIRED STATE   CURRENT STATE            ERROR     PORTS
hihafyns7zuf   hasher.1   humboldtux/dockercoins_hasher:0.1   host1     Running         Running 34 seconds ago

ID             NAME       IMAGE                               NODE      DESIRED STATE   CURRENT STATE            ERROR     PORTS
snzn423gl8wy   worker.1   humboldtux/dockercoins_worker:0.1   host3     Running         Running 14 seconds ago
```

{% endstep %}
{% endstepper %}

### 🌐 Déploiement de l’Interface Web

{% stepper %}
{% step %}
**Créez le service `webui`** :

```bash
docker service create --name webui --network dockercoins --publish 8000:80 humboldtux/dockercoins_webui:0.1
```

{% endstep %}

{% step %}
**Vérifiez que le service est en état `Running`** :

```bash
docker service ps webui
```

{% endstep %}

{% step %}
**Accédez à l’interface WebUI** :

Ouvrez un navigateur et accédez à l’URL :

```bash
http://192.168.253.150:8000
```

`192.168.253.150` étant l'adresse IP du host1.
{% endstep %}
{% endstepper %}

***

## 📈 Augmenter la Performance du Service Worker

Pour augmenter les performances, passez le service **worker** à l’échelle en augmentant le nombre de réplicas.

{% stepper %}
{% step %}
**Passez à 8 réplicas** :

```bash
docker service update worker --replicas 8
```

{% endstep %}

{% step %}
**Surveillez les réplicas** :

```bash
docker service ps worker
```

Exemple de sortie :

```
ID             NAME       IMAGE                               NODE      DESIRED STATE   CURRENT STATE            ERROR     PORTS
nr7qo7w0cbk5   worker.1   humboldtux/dockercoins_worker:0.1   host3     Running         Running 17 seconds ago
18e2ap4iwmlf   worker.2   humboldtux/dockercoins_worker:0.1   host3     Running         Running 6 seconds ago
5q35x45ug6t8   worker.3   humboldtux/dockercoins_worker:0.1   host1     Running         Running 6 seconds ago
o0472iimxq3g   worker.4   humboldtux/dockercoins_worker:0.1   host1     Running         Running 6 seconds ago
uwzfq4phi93l   worker.5   humboldtux/dockercoins_worker:0.1   host2     Running         Running 6 seconds ago
3f3ddzidz1yv   worker.6   humboldtux/dockercoins_worker:0.1   host3     Running         Running 6 seconds ago
cu2w0h6yb6tt   worker.7   humboldtux/dockercoins_worker:0.1   host1     Running         Running 6 seconds ago
mznflmvzgs6s   worker.8   humboldtux/dockercoins_worker:0.1   host2     Running         Running 6 seconds ago
```

{% endstep %}

{% step %}
**Vérifiez le taux de génération dans la WebUI**.
{% endstep %}
{% endstepper %}

***

## 🌍 Déployer `rng` avec Global Scheduling

Pour garantir qu’un conteneur `rng` soit exécuté sur chaque nœud du cluster, utilisez le mode **global scheduling**.

{% stepper %}
{% step %}
**Supprimez le service existant `rng`** :

```bash
docker service rm rng
```

{% endstep %}

{% step %}
**Recréez `rng` en mode global** :

```bash
docker service create --name rng --network dockercoins --mode global humboldtux/dockercoins_rng:0.1
```

{% endstep %}

{% step %}
**Vérifiez que chaque nœud exécute une instance `rng`** :

```bash
docker service ps rng
```

Exemple de sortie :&#x20;

```
ID             NAME                            IMAGE                            NODE      DESIRED STATE   CURRENT STATE            ERROR     PORTS
suksd8xbpsl7   rng.2bmiiswoenlqj4sn3vbbp0caa   humboldtux/dockercoins_rng:0.1   host2     Running         Running 15 seconds ago
jh8y3qeurqe3   rng.3jiespj24sq06wuspfksvfttv   humboldtux/dockercoins_rng:0.1   host3     Running         Running 15 seconds ago
46klojjxpyh0   rng.q8rpf08cgvuteweoywuvanf40   humboldtux/dockercoins_rng:0.1   host1     Running         Running 12 seconds ago
```

{% endstep %}

{% step %}
**Accédez à la WebUI** pour observer l’impact sur le taux de génération.
{% endstep %}
{% endstepper %}

***

## 🔄 Mise à Jour Progressive d’un Service (Rolling Update)

Un **rolling update** met à jour progressivement les instances du service pour éviter les interruptions.

* **Surveillez les mises à jour dans une fenêtre** :

  ```bash
  while true; do docker service ps worker | grep -v "Shutdown.*Shutdown"; sleep 1; done
  ```
* <mark style="color:orange;">**Dans une autre fenêtre**</mark>**&#x20;mettez à jour l’image du service worker** :

  ```bash
  docker service update worker --image humboldtux/dockercoins_worker:0.2
  ```

<figure><img src="https://3132389590-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FTgr1ZiAmgAVmZcVjYedk%2Fuploads%2FnrRbp0RiB2zdqjjXBNEZ%2FBI8tzzSTPX.gif?alt=media&#x26;token=b6228383-f25b-47d1-b452-29640cb34521" alt=""><figcaption></figcaption></figure>

***

## ⚙️ Ajuster les Paramètres des Rolling Updates

Pour ajuster la vitesse des mises à jour, configurez les paramètres **`update-parallelism`** et **`update-delay`**.

{% stepper %}
{% step %}
**Configurez 2 mises à jour en parallèle avec un délai de 5 secondes** :

```bash
docker service update worker --update-parallelism 2 --update-delay 5s
```

{% endstep %}

{% step %}
**Testez un downgrade en revenant à la version précédente** :

```bash
docker service update worker --image humboldtux/dockercoins_worker:0.1
```

{% endstep %}

{% step %}
**Surveillez la mise à jour** :

```bash
docker service ps worker
```

Exemple de sortie :

```
ID             NAME           IMAGE                               NODE      DESIRED STATE   CURRENT STATE                 ERROR     PORTS
krxuawysibd7   worker.1       humboldtux/dockercoins_worker:0.1   host2     Running         Running 43 seconds ago
wum9e7v5fdu3    \_ worker.1   humboldtux/dockercoins_worker:0.2   host2     Shutdown        Shutdown 43 seconds ago
nr7qo7w0cbk5    \_ worker.1   humboldtux/dockercoins_worker:0.1   host3     Shutdown        Shutdown 7 minutes ago
nso7dtq90jy1   worker.2       humboldtux/dockercoins_worker:0.1   host3     Running         Running 6 seconds ago
wqcu5j3qsjsm    \_ worker.2   humboldtux/dockercoins_worker:0.2   host3     Shutdown        Shutdown 6 seconds ago
18e2ap4iwmlf    \_ worker.2   humboldtux/dockercoins_worker:0.1   host3     Shutdown        Shutdown 6 minutes ago
wmslwvk9rsne   worker.3       humboldtux/dockercoins_worker:0.1   host3     Running         Running about a minute ago
c2s4cu6fbv0r    \_ worker.3   humboldtux/dockercoins_worker:0.2   host2     Shutdown        Shutdown about a minute ago
5q35x45ug6t8    \_ worker.3   humboldtux/dockercoins_worker:0.1   host1     Shutdown        Shutdown 7 minutes ago
0swg7rhc15dt   worker.4       humboldtux/dockercoins_worker:0.1   host1     Running         Running 43 seconds ago
xgwf61d2eatk    \_ worker.4   humboldtux/dockercoins_worker:0.2   host1     Shutdown        Shutdown 43 seconds ago
o0472iimxq3g    \_ worker.4   humboldtux/dockercoins_worker:0.1   host1     Shutdown        Shutdown 6 minutes ago
wou3bh32pfct   worker.5       humboldtux/dockercoins_worker:0.1   host2     Running         Running 24 seconds ago
rmn062o0u110    \_ worker.5   humboldtux/dockercoins_worker:0.2   host2     Shutdown        Shutdown 25 seconds ago
uwzfq4phi93l    \_ worker.5   humboldtux/dockercoins_worker:0.1   host2     Shutdown        Shutdown 6 minutes ago
p4pdwk7vbjfd   worker.6       humboldtux/dockercoins_worker:0.1   host3     Running         Running 5 seconds ago
npi8lqudjt37    \_ worker.6   humboldtux/dockercoins_worker:0.2   host3     Shutdown        Shutdown 6 seconds ago
3f3ddzidz1yv    \_ worker.6   humboldtux/dockercoins_worker:0.1   host3     Shutdown        Shutdown 6 minutes ago
anghdvzu46ql   worker.7       humboldtux/dockercoins_worker:0.1   host1     Running         Running 24 seconds ago
0gnfg37xbh6l    \_ worker.7   humboldtux/dockercoins_worker:0.2   host1     Shutdown        Shutdown 24 seconds ago
cu2w0h6yb6tt    \_ worker.7   humboldtux/dockercoins_worker:0.1   host1     Shutdown        Shutdown 7 minutes ago
l6jwzqz8jhho   worker.8       humboldtux/dockercoins_worker:0.1   host2     Running         Running about a minute ago
5wt7qa2ziu7s    \_ worker.8   humboldtux/dockercoins_worker:0.2   host1     Shutdown        Shutdown about a minute ago
mznflmvzgs6s    \_ worker.8   humboldtux/dockercoins_worker:0.1   host2     Shutdown        Shutdown 7 minutes ago
```

{% endstep %}
{% endstepper %}

***

## 🔩 Ajuster la Configuration des Rolling Updates

Pour améliorer la rapidité et l’efficacité des mises à jour, configurez le service `worker` avec des paramètres spécifiques :&#x20;

{% stepper %}
{% step %}
**Configurer pour 3 mises à jour en parallèle avec un délai de 2 secondes** :

```bash
docker service update worker --update-parallelism 3 --update-delay 2s
```

{% endstep %}

{% step %}
**Repassez à la dernière version mise à jour** :

```bash
docker service update worker --image humboldtux/dockercoins_worker:0.2
```

{% endstep %}
{% endstepper %}

***

## 🔧 **Astuces pour Dépannage**

### ⚠️ **Service qui échoue à démarrer (Exemple : Redis, rng, worker ou webui)**

* **Problème** : Le service ne passe pas en état `Running`.
* **Solution** :
  1. **Vérifiez l’état des services** :

     ```bash
     docker service ps <nom_service>
     ```
  2. **Analysez les logs des conteneurs en échec** :

     ```bash
     docker logs <container_id>
     ```
  3. **Vérifiez les ressources des nœuds** :
     * Redis et Elasticsearch nécessitent une mémoire suffisante.
     * Assurez-vous que chaque nœud dispose d’au moins **2 Go de mémoire**.

### 🌐 **Problème de réseau entre les services**

* **Problème** : Les services ne communiquent pas correctement.
* **Solution** :
  1. **Vérifiez que le réseau overlay existe** :

     ```bash
     docker network ls
     ```
  2. **Inspectez le réseau** pour confirmer que les services y sont connectés :

     ```bash
     docker network inspect dockercoins
     ```

### 🔄 **Mauvais équilibrage des conteneurs**

* **Problème** : Les services comme `worker` ou `rng` ne sont pas répartis correctement sur les nœuds.
* **Solution** :
  1. Assurez-vous que les nœuds sont actifs et prêts :

     ```bash
     docker node ls
     ```
  2. Utilisez le mode **global** pour `rng` pour forcer une instance sur chaque nœud :

     ```bash
     docker service update --mode global rng
     ```

### 🛑 **Erreur pendant un Rolling Update**

* **Problème** : Certaines instances échouent après une mise à jour.
* **Solution** :
  1. Réduisez la parallélisation des mises à jour :

     ```bash
     docker service update worker --update-parallelism 1 --update-delay 10s
     ```
  2. Surveillez les mises à jour avec :

     ```bash
     docker service ps worker
     ```

***

## 📝 **Résumé des Commandes**

| **Commande**                           | **Description**                                      |
| -------------------------------------- | ---------------------------------------------------- |
| `docker network create`                | Crée un réseau overlay pour la communication.        |
| `docker service create`                | Déploie un service dans le cluster Swarm.            |
| `docker service update --replicas`     | Met à l’échelle le nombre de réplicas d’un service.  |
| `docker service rm`                    | Supprime un service existant.                        |
| `docker service ps <nom_service>`      | Affiche l’état des tâches d’un service.              |
| `docker service update --mode global`  | Force un service à s’exécuter sur chaque nœud.       |
| `docker service update --update-delay` | Configure le délai entre les mises à jour des tasks. |
| `docker logs <container_id>`           | Affiche les logs des conteneurs déployés.            |
| `docker network inspect <nom_reseau>`  | Inspecte un réseau pour voir les connexions actives. |

***

## 🎯 **Conclusion**

L’application **Dockercoins** est un exemple idéal pour explorer l’orchestration de services interconnectés dans un cluster Docker Swarm. Vous avez commencé par créer un réseau overlay avec **docker network create** pour assurer la communication entre les services. Ensuite, vous avez déployé des services critiques comme **Redis** (base de données), **rng** (générateur aléatoire), **hasher** (calculateur de hash) et **worker** (simulateur de travail distribué). Enfin, vous avez exposé l’interface Web avec **webui** pour suivre en temps réel la génération des Dockercoins.

En augmentant le nombre de réplicas du service `worker` via **docker service update --replicas**, vous avez optimisé les performances de l’application et observé une augmentation notable du taux de génération de hashes. Grâce au **Global Scheduling**, vous avez assuré l’exécution uniforme de `rng` sur tous les nœuds du cluster, améliorant ainsi la résilience du déploiement. De plus, l’implémentation des **Rolling Updates** a permis de mettre à jour progressivement les services sans interruption, tout en ajustant les paramètres de mise à jour pour un contrôle plus précis.
