227 lines
6.9 KiB
Markdown
227 lines
6.9 KiB
Markdown
# TP 1
|
|
|
|
# TP 2
|
|
|
|
# TP 4
|
|
|
|
**Étape 1** : Créer deux dossiers : "web" et "nginx"
|
|
|
|
**Étape 2** : Mettre le fichier ``index.php`` dans le dossier web et le fichier ``default.conf`` dans le dossier nginx
|
|
|
|
**Étape 3** : Pour déployer le server REDIS il faut ajouter ceci dans le fichier ``docker-compose.yml``
|
|
|
|
```yaml
|
|
services:
|
|
redis:
|
|
image: redis/redis-stack
|
|
ports:
|
|
- "6379:6379"
|
|
volumes:
|
|
- redis_data:/data
|
|
restart: always
|
|
```
|
|
|
|
**Étape 4** : Pour déployer le server REDISINSIGHT il faut ajouter ceci dans le fichier ``docker-compose.yml``
|
|
|
|
```yml
|
|
services:
|
|
redisinsight:
|
|
image: redis/redisinsight
|
|
ports:
|
|
- "5540:5540"
|
|
restart: always
|
|
volumes:
|
|
- redisinsight_data:/db
|
|
```
|
|
|
|
> [!CAUTION]
|
|
> Ne pas oublier de mettre à la fin du ficher un bloc volumes
|
|
|
|
```yml
|
|
volumes:
|
|
redis_data:
|
|
redisinsight_data:
|
|
```
|
|
|
|
**Étape 5** : Pour déployer le server PHP il faut ajouter ceci dans le fichier ``docker-compose.yml``
|
|
```yml
|
|
services:
|
|
php:
|
|
image: windok/php-redis
|
|
restart: always
|
|
volumes:
|
|
- ./web:/usr/share/nginx/html
|
|
environment:
|
|
NOM : "moguljak"
|
|
PRENOM : "tom"
|
|
deploy:
|
|
replicas: 2
|
|
```
|
|
|
|
> Attention !
|
|
> Il n'y a qu'un seul `services` par dockercompose
|
|
|
|
**Étape 6** : Pour déployer le server NGINX il faut ajouter ceci dans le fichier ``docker-compose.yml``
|
|
```yml
|
|
services:
|
|
nginx :
|
|
image: nginx
|
|
restart: always
|
|
ports:
|
|
- "80:80"
|
|
- "443:443"
|
|
volumes:
|
|
- ./web:/usr/share/nginx/html
|
|
- ./nginx:/etc/nginx/conf.d
|
|
```
|
|
|
|
**Étape 7** : Pour initialiser la base de données deux méthodes s'offrent à nous. La première en se connectant directement au serveur REDIS et la deuxième en utilisant l'interface REDISINSIGHT.
|
|
- **Première solution**
|
|
- Démarrer docker avec la commande ``docker compose up -d``
|
|
- Effectuer la commande ``docker ps`` afin de lister tous conteneurs
|
|
- Maintenant qu'on sait sur quel docker on veut se connecter (celui de REDIS) on peut effectuer la commande suivante nous permettant d'ouvrir un Shell directement dans le docker. ``docker exec -it tp4-redis-1 /bin/bash``
|
|
- Maintenant effectuer cette commande ``redis-cli`` elle va nous permettre de définir la clef
|
|
- Et ensuite pour définir la clef on effectue ``set code 12345``
|
|
- Maintenant vous pouvez voir les changements en allant sur la page
|
|
"http://localhost/index.php"
|
|
|
|
- **Deuxième solution**
|
|
# TP 5/6
|
|
|
|
**Étape 1** : Il faut utiliser de nouveau ce qu'on a fait lors du TP4 afin de faire la mise en réseau.
|
|
Pour cela nous allons tout d'abord ajouter ceci :
|
|
```yml
|
|
networks:
|
|
- back
|
|
```
|
|
Sur le service REDIS, REDISINSIGHT
|
|
```yml
|
|
networks:
|
|
- front
|
|
```
|
|
Sur le service NGINX
|
|
```yml
|
|
networks:
|
|
- front
|
|
- back
|
|
```
|
|
Sur le service PHP
|
|
Et un bloc networks à la fin du fichier :
|
|
```yml
|
|
networks:
|
|
front:
|
|
back:
|
|
```
|
|
|
|
**Étape 2** : On va commencer par faire un docker compose contenant les services de cadvisor et de node exporter.
|
|
Pour la partie cadvisor on va mettre
|
|
```yml
|
|
services:
|
|
cadvisor:
|
|
image: google/cadvisor:latest
|
|
ports:
|
|
- "8080:8080"
|
|
restart: unless-stopped
|
|
volumes:
|
|
- /:/rootfs:ro
|
|
- /var/run:/var/run:rw
|
|
- /sys:/sys:ro
|
|
- /var/lib/docker/:/var/lib/docker:ro*
|
|
```
|
|
|
|
Et pour la partie node exporter
|
|
```yml
|
|
services:
|
|
node-exporter:
|
|
image: prom/node-exporter:latest
|
|
ports:
|
|
- "9100:9100"
|
|
restart: unless-stopped
|
|
```
|
|
|
|
**Étape 3** : Maintenant on va faire un docker compose pour le service de prometheus
|
|
```yml
|
|
services:
|
|
prometheus:
|
|
image: prom/prometheus:latest
|
|
restart: unless-stopped
|
|
volumes:
|
|
- ./prometheus/:/etc/prometheus/
|
|
ports:
|
|
- "9090:9090"
|
|
```
|
|
|
|
> Attention !
|
|
> Il ne faut pas oublier de faire le fichier de configuration de prometheus (prometheus.yml) et ensuite de la mettre dans un dossier prometheus
|
|
|
|
```yml
|
|
global:
|
|
scrape_interval: 1m
|
|
evaluation_interval: 1m
|
|
|
|
scrape_configs:
|
|
- job_name: 'prometheus'
|
|
|
|
scrape_interval: 1m
|
|
|
|
static_configs:
|
|
- targets: ['localhost:9090']
|
|
|
|
- job_name: 'node'
|
|
static_configs:
|
|
- targets: ['node-exporter:9100']
|
|
|
|
- job_name: 'cadvisor'
|
|
static_configs:
|
|
- targets: ['cadvisor:8080']
|
|
```
|
|
|
|
Ce fichier de configuration va nous permettre de faire le lien entre le service prometheus et les services cadvisor et node exporter
|
|
|
|
**Étape 4** : Maintenant il ne reste plus qu'à faire le docker compose pour le service Grafana.
|
|
```yml
|
|
services:
|
|
grafana:
|
|
image: grafana/grafana:latest
|
|
ports:
|
|
- "3000:3000"
|
|
restart: unless-stopped
|
|
```
|
|
|
|
<<<<<<< HEAD
|
|
**Étape 5** : Ensuite nous devons nous connecter à grafana afin de créer la connection entre prometheus et grafana.
|
|
Pour ce connecter on peut utiliser un compte par défaut, on doit juste mettre "admin" comme nom d'utilisateur et comme mot de passe.
|
|
On peut skip aussi la demande de changer le mot de passe juste après.
|
|
|
|
**Étape 6** : Une fois sur la page d'accueil, on va aller sur l'onglet "Connections" et appuyer sur "add new connection"
|
|
|
|
**Étape 7** : Dans la barre de recherche on écrit prometheus, on clique ensuite sur Prometheus et enfin "Add new data source" en haut à droite
|
|
|
|
**Étape 8** : Maintenant on doit configurer la configuration de la connection avec prometheus. Il suffit juste de mettre le lien "http://prometheus:9090" dans la catégorie Connection et ensuite appuyer sur "Save & Test" à la fin de la page.
|
|
|
|
**Étape 9** : Il faut ensuite cliquer sur "Data sources", on peut alors voir qu'on a bien réussi à connecter prometheus. Dorénavant il faut cliquer sur "Build a dashboard" et ensuite sur
|
|
=======
|
|
**Étape 5** : Il faut ensuite configurer Grafana, tout d'abord en liant une source de données Prometheus, puis en créant des dashboard pour consulter les données fournies par les exporter.
|
|
|
|
Pour lier une source de données Prometheus :
|
|
1. Chercher `Data source` dans le champ de recherche Grafana
|
|
2. Cliquer sur `Add new data source`
|
|
3. Choisir Prometheus
|
|
4. Dans le champ `Connection > Prometheus serveur URL`, entrer `http://...:9090` en remplaçant les ... par le nom donné au service prometheus dans le docker compose (ici, 'prometheus')
|
|
5. Descendre en bas de la page et cliquer sur `Save & test`
|
|
|
|
|
|
Pour créer un dashboard :
|
|
1. Cliquer sur `Dashboard` dans le menu à gauche
|
|
2. Cliquer sur `New`, `New dashboard`
|
|
3. Cliquer sur `Import dashboard`
|
|
4. Cliquer sur le lien `grafana.com/dashboards` et chercher un dashboard Grafana pour cAdvisor (ou node-exporter). Récupérer son ID (j'ai trouvé 1860 pour node-exporter et 14282 pour cAdvisor)
|
|
5. Revenir sur le Grafana en localhost, entrer l'ID dans le champ et cliquer sur `Load`
|
|
6. Dans le champ tout en bas, choisir la data source Prometheus créée auparavant
|
|
7. Cliquer sur `import`
|
|
|
|
Il faut créer un dashboard pou cAdvisor et un autre pour node-exporter.
|
|
On peut consulter les dashboards dans le menu dashboard (à gauche).
|
|
On doit voir les noms des conteneurs dans le dashboard cAdvisor, mais pas dans le node-exporter.
|
|
>>>>>>> 710fc970fcaa49175535803baa2bdb4df5ed8d05
|