Jani Subhana Borthaire

Création d’un réseau localement sur ma machine

En formation on à vu comment créer des conteneurs séparés avec DOCKER et sa commande docker compose, puis la manière de procéder pour les faire interagir entre eux.

Cette simulation m’a permis de comprendre le fonctionnement de la communication des conteneurs localement.

Objectif :

Arriver à déployer un conteneur MySQL qui communique avec un conteneur WordPress, et un autre conteneur Projeqtor.

Puis faire un second réseau en local pour accueillir l’outil PIA ainsi que sa base de donnée Postgres.

À noter que séparer les deux réseaux n’est pas une nécessité mais, j’ai préféré en faire deux différents.

Enfin, on ajoute Portainer qui est une interface web qui sert à gérer Docker facilement sans taper de commandes.

Puis avec l’aide de Portainer on a créer un diagramme qui représente le réseau et les conteneurs ainsi que les ports grâce auxquels ils communiquent entre eux.

La procédure :

Création du premier réseau

La première étape est de créer un docker compose pour la base de données puis d’y ajouter le réseau :

version: "3" 
services:
  db:
    image: mysql:latest
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: wdp1
      MYSQL_USER: wdpuser
      MYSQL_PASSWORD: wdppassword
    networks:
      - frontend
  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    restart: always
    ports:
      - "8080:80"
    environment:
      PMA_HOST: db
      PMA_USER: root
      PMA_PASSWORD: rootpassword
    networks:
      - frontend
volumes:
  mysql: {}
networks:
  frontend: 
    name: wordpress 
    driver_opts:    
      com.docker.network.bridge.host_binding_ipv4: 127.0.0.1

Ici networks est la clé de docker compose qui défini les réseaux personnalisés, frontend est donc le nom logique de ce réseau, wordpress est le nom que docker va donner à mon réseau, puis la commande driver_opts:com.docker.network.bridge.host_binding_ipv4: 127.0.0.1 est tout simplement une option avancée qui indique que tous les ports publiés seront liés à l’adresse IP 127.0.0.1.

Puis il s’agit de faire la même chose sur le WordPress et le Projeqtor pour qu’ils puissent communiquer avec.

Par exemple pour WordPress :

version: "3" 
services:
  wordpress:
    image: wordpress:latest
    restart: always
    ports:
      - "80:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wdpuser
      WORDPRESS_DB_PASSWORD: wdppassword
      WORDPRESS_DB_NAME: wdp1
    volumes:
      - "./:/var/www/html"
    networks:
      - frontend
networks:
  frontend: 
    name: wordpress 
    driver_opts:    
      com.docker.network.bridge.host_binding_ipv4: 127.0.0.1

Et pour Projeqtor :

---
services:
  projeqtor:
    image: mraber/projeqtor:12.2.3-1
    restart: always
    environment:
      PJQ_PHP_MAX_INPUT_VARS: 4000
      PJQ_PHP_REQUEST_TERMINATE_TIMEOUT: 0
      PJQ_PHP_MAX_EXECUTION_TIME: 30
      PJQ_PHP_MEMORY_LIMIT: "512M"
      PJQ_PHP_MAX_UPLOAD_SIZE: "512M"
      PJQ_DB_TYPE: "mysql"
      PJQ_DB_HOST: "db:3306"
      PJQ_DB_NAME: "projeqtor"
      PJQ_DB_USER: "wdpuser"
      PJQ_DB_PASSWORD: "wdppassword"
      PJQ_DB_DISPLAY_NAME: "Projeqtor"
      PJQ_DB_COLLATION: "utf8mb4_general_ci"
      PJQ_DIR_ATTACHMENTS: "/var/data/projeqtor/attachments"
      PJQ_DIR_DOCUMENTS: "/var/data/projeqtor/documents"
      PJQ_LOG_FILE: "/var/data/projeqtor/logs/projeqtor_$${date}.log"
      # Levels : debug (4) -> info (2)
      PJQ_LOG_LEVEL: 2
    volumes:
      - prj_attachments:/var/data/projeqtor/attachments
      - prj_documents:/var/data/projeqtor/documents
      - prj_logs:/var/data/projeqtor/logs
    ports:
      - 8096:80
    logging:
      # Do not fill disk with logs!
      driver: "json-file"
      options:
        max-size: "10M"
        max-file: "5"
        compress: "true"
    networks:
      - frontend
volumes:
  prj_db_data: {}
  prj_attachments: {}
  prj_documents: {}
  prj_logs: {}
networks:
  frontend: 
    name: wordpress 
    driver_opts:    
      com.docker.network.bridge.host_binding_ipv4: 127.0.0.1

Maintenant, mon serveur est configuré et mon WordPress communique bien avec ma base de données MySQL et de même pour Projeqtor.

*PS : Pour Projeqtor j’ai du créer manuellement ma base de données et donner tous les droits à l’utilisateur wduser pour qu’il puisse avoir accès à la base de données. Sinon il aurait fallu que j’ajoute la commande : « GRANT ALL PRIVILEGES ON  `Projeqtor`.* TO ‘wdpuser’@’%’; ALTER USER ‘wdpuser’@’%’ ; » sur mon docker compose.

Création d’un second réseau

Maintenant je souhaite ajouter l’outil PIA ainsi que sa base de données Postgres.

On va créer un second réseau puis les ajouter les deux conteneurs sur celui-ci.

Le docker compose de la base de données Postgres est donc :

version: "3" 
services:
  database:
    restart: always
    image: postgres:10.1
    environment:
      POSTGRES_PASSWORD: 'somepassword'
    networks:
      - dbpg1
  adminer:
    image: adminer
    restart: always
    ports:
      - 8084:8080
    networks:
      - dbpg1
networks:
  dbpg1: 
    name: piadb 
    driver_opts:    
      com.docker.network.bridge.host_binding_ipv4: 127.0.0.1

Ici, le nom logique du réseau est donc dbpg1 et le nom attribué par docker est piadb.

Ici j’ai ajouté Adminer qui sert à gérer les bases de données de Postgres.

Et le docker compose de PIA sera :

version: '3'
services:
  cnil-pia-back:
    image: lrqdo/cnil-pia-back
    restart: always
    environment:
      DATABASE_HOST: 'database'
      DATABASE_USERNAME: 'postgres'
      DATABASE_PASSWORD: 'somepassword'
      SECRET_KEY_BASE: 'somesecret'
    ports:
      - 3000:3000
    networks:
      - dbpg1

  cnil-pia-front:
    image: lrqdo/cnil-pia-front
    restart: always
    ports:  
    - 81:80
    networks:
      - dbpg1

networks:
  dbpg1: 
    name: piadb 
    driver_opts:    
      com.docker.network.bridge.host_binding_ipv4: 127.0.0.1

Comme vu ci-dessus, le nom du réseau est le même.

Ajout de Portainer

Portainer va nous servir à surveiller l’activité de chaque conteneurs et les ports par lesquels ils communiquent.

Voici le docker compose de Portainer :

services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    restart: always
    ports:
      - "9000:9000"   # Web UI access (HTTP)
      - "9443:9443"   # Web UI access (HTTPS)
      - "8000:8000"   # Edge Agent port
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data
    networks:
      - portainer_network

  agent:
    image: portainer/agent:latest
    container_name: portainer_agent
    restart: always
    environment:
      AGENT_CLUSTER_ADDR: tasks.agent
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /var/lib/docker/volumes:/var/lib/docker/volumes
    networks:
      - portainer_network
networks:
  portainer_network:
volumes:
  portainer_data:

Comme on le voit, Portainer n’est pas connecté aux autres réseaux. Il n’en a pas besoin.

Diagramme des réseaux :

J’ai donc fais un diagramme qui schématise mon réseau. Avec les IPs de chaque conteneurs :

Ici en orange, on y retrouve mon ordinateur et son adresse IP. Puis mes deux réseaux créés localement : piadb et WordPress. Ils sont tous les deux sur l’adresse 127.0.0.1 qui est le localhost, l’adresse qui pointe vers ma propre machine. Cela veut dire qu’ils seront visibles uniquement par moi.

Enfin on y retrouve les adresses IPs interne de chaque conteneurs, ainsi que les ports par lesquels ils communiquent.

Par exemple pour « Projeqtor », on voit que le port 8096 de l’ordinateur est connecté au port 80 du conteneur.

On peut voir que chaque conteneur est connecté avec un port de l’ordinateur différent. C’est pour éviter les conflits, si deux conteneurs sont connectés sur le même port, la machine ne saura pas sur lequel des deux sites il devra accéder.