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