Road-to-DevOps/Pepiniere/docker/travaux-pratiques/slides/swarm/tp-traefik.md

# TP Traefik

Intégrer Traefik dans le cluster Swarm.

Utiliser les labels Traefik pour accéder aux applications.



* Déployer Traefik en tant que service dans le cluster sur un réseau personnalisé.

* Se rendre sur l'interface web de Traefik.

<small>[Documentation officielle : https://docs.traefik.io/](https://docs.traefik.io/)</small>


<!-- .slide: data-background="#2E2E2E" data-state="small-table small-code" -->
```none
$ docker network create --driver overlay traefik_net
```

```none
$ docker service create \
    --name traefik \
    --constraint=node.role==manager \
     --publish 80:80 --publish 8080:8080 \
    --mount type=bind,source=/var/run/docker.sock,target=/var/run/docker.sock \
    --network traefik_net \
    traefik --docker --docker.swarmmode --docker.domain=traefik --docker.watch --web
```

|Option                           |Description|
|-                                |-|
|`--publish 80:80...`             |we publish port 80 and 8080 on the cluster.|
|`--constraint=node.role==manager`|we ask docker to schedule Træfik on a manager node.|
|`--mount type=bind,source=...`   |we bind mount the docker socket where Traefik is scheduled to be able to speak to the daemon.|
|`--network traefik_net`          |we attach the Traefik service (and thus the underlying container) to the traefik_net network.|
|`--docker`                       |enable docker backend.|
|`--docker.swarmmode`             |to enable the swarm mode on Traefik.|
|`--web`                          |activate the webUI on port 8080.|


<!-- .slide: data-background="#2E2E2E" data-state="small-code" -->
Alternativement on peut aussi lancer Traefik avec `docker stack` et le docker-compose suivant :

`traefik/docker-compose-traefik.yml`
```yaml
version: "3"
services:
  traefik:
    image: traefik:tetedemoine
    ports:
      - 80:80
      - 8080:8080
    networks:
      - traefik_net
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: ["--docker", "--docker.swarmmode", "--docker.domain=traefik", "--docker.watch", "--web"]
    deploy:
      placement:
        constraints: [node.role == manager]
networks:
  traefik_net:
    driver: overlay

# si le réseau traefik_net existe déjà on peut l'utiliser comme ceci :
#networks:
#  traefik_net:
#    external: true
```


<!-- .slide: data-background="#2E2E2E" data-state="small-code" -->
Lancer la stack :
```none
$ docker stack deploy -c docker-compose-traefik.yml traefik
Creating network traefik_traefik_net
Creating service traefik_traefik

```


* Adapter le `docker-compose.yml` de notre application (partie 3 du TP Swarm) en ajoutant des labels pour Traefik :
    * Placer les services `web` et `db` sur le réseau `formation_net`.
    * Placer le service `web` sur le réseau `traefik_net`.
    * Ajouter des labels `traefik.*` sur le service `web` pour :
        - le port de l'application
        - l'url sur laquelle l'application doit répondre
        - le réseau swarm traefik
* Lancer la stack.


<!-- .slide: data-background="#2E2E2E" data-state="medium-code" -->
`traefik/docker-compose-formation-app-with-traefik.yml`
```yaml
version: "3"
services:
  web:
    image: web:1
    environment:
      - MYSQL_HOST=db
      - MYSQL_DATABASE=docker
      - MYSQL_USER=docker
      - MYSQL_PASSWORD=docker
    networks:
      - formation_net
      #- traefik_net             # si Traefik lancé avec service
      - traefik_traefik_net      # si Traefik lancé avec stack
    deploy:
      labels:
        #traefik.docker.network: "traefik_net"        # si Traefik lancé avec service
        traefik.docker.network: "traefik_traefik_net" # si Traefik lancé avec stack
        traefik.port: "80"
        traefik.frontend.rule: "Host:web.traefik"
  db:
    image: mariadb:10.7.1
    environment:
      - MYSQL_ROOT_PASSWORD=docker
      - MYSQL_DATABASE=docker
      - MYSQL_USER=docker
      - MYSQL_PASSWORD=docker
    networks:
      - formation_net
networks:
  #traefik_net:            # si Traefik lancé avec service
  traefik_traefik_net:     # si Traefik lancé avec stack
    external: true
  formation_net:
    driver: overlay
```


<!-- .slide: data-background="#2E2E2E" data-state="small-code" -->
Lancer la stack :
```none
$ docker stack deploy -c docker-compose-formation-app-with-traefik.yml formation
Creating network formation_formation_net
Creating service formation_web
Creating service formation_db
```


* Vérifier si Traefik détecte correctement l'application `web`.

* Accéder à l'application `web` :  comment ?

* Mettre à l'échelle le service `web` et constater le load balancing effectué par Traefik.


<!-- .slide: data-background="#2E2E2E" -->
Pour accéder à notre application web il faut ajouter l'entrée suivante dans le fichier `/etc/hosts` de l'hôte :

```none
127.0.0.1 web.traefik
```

Puis dans le navigateur, taper sur l'adresse :

```none
http://web.traefik/cgi-bin/index.sh
```


<!-- .slide: data-background="#2E2E2E" -->
Créer trois instance du service `web` :

```none
$ docker service scale formation_web=3
formation_web scaled to 3
```