docker_TP/README.md

# 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
```

**É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.