---
title: "Superviser ses conteneurs Docker avec Prometheus/Grafana et \"stressons\" la solution avec une API Symfony et Postman"
excerpt: "Aujourd'hui nous allons nous intéresser à la mise en place d'une solution de supervision pour nos conteneurs Docker avec Prometheus et Grafana. L'idée c'est de disposer d'un tableau de bord simple mais efficace pour pouvoir suivre les \"metrics\" de nos conteneurs et de s'assurer de la bonne santé de l'hôte."
publishDate: 2020-11-30T00:00:00.000Z
tags: ["docker", "symfony", "api", "postman", "grafana", "prometheus", "supervision"]
canonical: "https://yoandev.co/superviser-ses-conteneurs-docker-avec-prometheus-grafana-et-stressons-la-solution-avec-une-api-symfony-et-postman"
---

<YouTube id="_UD181Kf4E0" />

### Introduction

Aujourd'hui nous allons nous intéresser à la mise en place d'une solution de supervision pour nos conteneurs Docker avec Prometheus et Grafana. L'idée c'est de disposer d'un tableau de bord simple mais efficace pour pouvoir suivre les "metrics" de nos conteneurs et de s'assurer de la bonne santé de l'hôte.

C'est typiquement le genre d'outil qui peut vous être d'une grande aide lors de la mise en production de conteneurs Docker, afin de suivre et d'assurer le bon fonctionnement de votre infrastructure.

Pour nous simplifier la vie, nous allons utiliser une solution déjà packagée pour nous dans un docker-compose : [la solution Dockprom](https://github.com/stefanprodan/dockprom) !

### Mise en place de Dockprom

La mise en place de Dockprom est vraiment très simple. On commence par récupérer le projet.

```shell
git clone https://github.com/stefanprodan/dockprom.git
cd dockprom
```

Et sans attendre, on lance le docker-compose.

```shell
docker-compose up -d
```

On peut vérifier que dockprom à bien démarré ses conteneurs avec la commande suivante.

```shell
docker-compose ps
    Name                  Command                  State                                                   Ports                                             
-------------------------------------------------------------------------------------------------------------------------------------------------------------
alertmanager   /bin/alertmanager --config ...   Up             9093/tcp                                                                                      
caddy          /sbin/tini -- caddy -agree ...   Up             0.0.0.0:3000->3000/tcp, 0.0.0.0:9090->9090/tcp, 0.0.0.0:9091->9091/tcp, 0.0.0.0:9093->9093/tcp
cadvisor       /usr/bin/cadvisor -logtostderr   Up (healthy)   8080/tcp                                                                                      
grafana        /run.sh                          Up             3000/tcp                                                                                      
nodeexporter   /bin/node_exporter --path. ...   Up             9100/tcp                                                                                      
prometheus     /bin/prometheus --config.f ...   Up             9090/tcp                                                                                      
pushgateway    /bin/pushgateway                 Up             9091/tcp  
```

### Découverte de Grafana

Une fois que dockprom à bien démarré l'ensemble de ses conteneurs, il est possible d'ouvrir une session sur Grafana, à l'adresse [http://127.0.0.1:3000/](http://127.0.0.1:3000/).

![](./images/image-25-1024x522.png)

Par défaut, les identifiants sont "admin/admin" (la doc vous précise comment modifier cela). Une fois connecté, dockprom vous propose directement deux tableaux de bord :

- Docker Containers : Tableau de bord pour monitorer vos conteneurs Docker
- Docker Host: Tableau de bord de l'hôte de vos conteneurs Docker

![](./images/image-26.png)

![](./images/2020-11-30_09-49-1024x497.png)
    
![](./images/2020-11-30_09-50-1024x522.png)
    
    

### Générons de l'activité avec une API Symfony et Postman

Histoire d'avoir un peu d'activité à observer, je vous propose de mettre en place une petite API que nous allons "stresser" avec Postman. Créons donc un projet Symfony qui nous ferons fonctionner dans un conteneur Docker.

Récupérons un environnement de Dev Docker pour Symfony, renommons le répertoire et lançons le docker-compose.

```shell
git clone  https://gitlab.com/yoandev.co/environnement-de-developpement-symfony-5-avec-docker-et-docker-compose.git
mv environnement-de-developpement-symfony-5-avec-docker-et-docker-compose/ apidockprom
cd apidockprom
docker-compose up -d
```

Créons un nouveau projet Symfony (Pour aller plus vite, nous prendrons le website-skeleton).

```shell
docker exec www_docker_symfony composer create-project symfony/website-skeleton project
sudo chown -R $USER ./
```

Modifions-le .env pour pouvoir utiliser la base de données.

```yaml
DATABASE_URL=mysql://root:@db:3306/db_name?serverVersion=5.7
```

Entrons dans le conteneur Apache, **pour la suite des manipulations.**

```shell
docker exec -it www_docker_symfony bash
cd project
```

Créons la base de données.

```shell
php bin/console doctrine:database:create
```

Installons ApiPlatform.

```shell
composer require api
```

Et vérifions dans un navigateur que tout est ok à l'adresse [http://127.0.0.1:8741/api](http://127.0.0.1:8741/api).

![](./images/image-27-1024x521.png)

Créons une entité de démo.

```shell
php bin/console make:entity
Class name: Demo
Mark this class as an API Platform resource : yes
New property name: demo
String / 255 / Nullable: no
```

Et mettons à jour la base de données via les migrations.

```shell
php bin/console make:migration
php bin/console doctrine:migrations:migrate
```

Et vérifions que notre API est à jour à l'adresse [http://127.0.0.1:8741/api](http://127.0.0.1:8741/api)

![](./images/image-29-1024x522.png)

Lançons l'application Postman et créons une collection "dockprom".

![](./images/image-30.png)

Ajoutons-y une requête de type **POST**.

![](./images/image-31-1024x385.png)

Et une requête de type **GET**.

![](./images/image-32-1024x385.png)

Et lançons **10 000** fois les requêtes POST et GET via le **Runner de Postman** ;-)

![](./images/image-34-1024x665.png)

En nous reconnectant à Grafana, nous devrions être en mesure de constatée cette activité.

![](./images/image-35-1024x521.png)

### Mettons en place une Alerte

L'un des objectifs de l'utilisation d'un outil comme dockprom c'est de nous aider dans la supervision de notre infrastructure, profitons de cette activité sur notre API pour explorer la mise en place d'une alerte !

Nous allons mettre en place une alerte sur l'utilisation du CPU par nos conteneurs. Le moyen le plus simple c'est d'éditer le graphique CPU du tableau de bord "Docker Containers".

![](./images/image-36-1024x520.png)

Ouvrons l'onglet Alert et ajoutons une alerte.

![](./images/image-37-1024x496.png)

Et déclenchons une alerte dès que le CPU dépasse 3% d'utilisation pendant 10 secondes (à ne pas faire en conditions réelles !).

![](./images/image-38-1024x498.png)

Dans la section "Alerting", nous retrouvons l'alerte que nous venons de mettre en place.

![](./images/image-39.png)

Et si nous patientons quelques secondes, l'alerte va changer de statut (puisque nous stressons notre API en parallèle).

![](./images/image-40.png)

Coupons notre "stress test" dans Postman, et constatons que quelques secondes plus tard l'alerte change à nouveau de statut.

![](./images/image-41.png)

Nous pourrions aller plus loin, et voir comment déclencher l'envoie d'une notification, mais je vous laisse explorer la documentation ;-)

### Conclusions

Nous venons de voir à qu'elle point la solution Dockprom peut nous permettre de mettre en place simplement et rapidement un outil complet et performant de supervision d'une infrastructure Docker. Évidemment, impossible d'aborder dans le détail toutes les possibilités offertes, mais considérez cet article comme une introduction, voir une invitation à approfondir le sujet.
