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

⚠️ Attention 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
```

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