MISE EN PLACE D’UN ENVIRONEMENT DEV ODOO

Contexte et Objectifs

Pourquoi l’environnement de développement et Odoo ERP ?

Les enjeux des logiciels de nos jours sont nombreux et complexes. Les entreprises doivent s’assurer que leurs logiciels sont sécurisés, fiables, performants, évolutifs afin de répondre à la satisfaction du client. Cette évolutivité constante exige la mise en place des processus de livraisons logiciels rapides. Et ce processus commence avec la mise en place d’un environnement de développement efficient ; D’où l’importance d’appliquer la pratique du IaC (Infrastructure as Code) ; Aussi les entreprises sont de plus en plus intéressées par des solutions logicielles qui permettent d’automatiser les actions de plusieurs de leur département d’où le choix des ERP comme Odoo.

Durée de mise en place : 20 min

Etapes

Alors pour mettre en place un environnement de développement pour Odoo nous allons :

Installer Git ;

Installer Docker ;

Configurer un Dockerfile et un docker-compose.yml ;

Utiliser les routines pour lancer, mettre à jour, arrêter et nettoyer notre environnement ;

Environnement

Pour la mise en place de notre environnement nous allons travailler avec :

CentOS 7.9

Odoo 15 (Community Edition)

PostgreSQL 13

Git 1.8.3.1

Docker 24.0.6

Docker Compose v2.21.0

Qu’est-ce que CentOS ?

CentOS est l’acronyme de Community ENTerprise Operating System, c’est un projet Open Source qui produit deux distributions Linux distinctes : CentOS Stream et CentOS Linux. Dans cet article nous utilisons CentOS Linux qui est une distribution en aval de Red Hat Enterprise Linux. Elle est le plus souvent utilisée pour le développement et le déploiement.

Pour plus d’information consulter : CentOS, qu’est-ce que c’est ? (redhat.com)

Qu’est-ce que Git ?

Git est un système de contrôle de version distribué, libre et gratuit, conçu pour gérer rapidement et efficacement tous les projets, des plus petits aux plus grands. Git est facile à apprendre et facilite la collaboration entre plusieurs développeurs communicants à distance à l’aide du repository. Il surpasse les outils SCM grâce à des fonctionnalités telles que le branchement local peu coûteux, des zones de stockage pratiques et de multiples flux de travail.

Pour plus d’information consulter : Git (git-scm.com)

Qu’est-ce que Docker ?

Docker est une plateforme ouverte pour le développement, l’expédition et l’exécution d’applications. Docker vous permet de séparer vos applications de votre infrastructure afin de fournir rapidement des logiciels. Avec Docker, vous pouvez gérer votre infrastructure de la même manière que vos applications. En tirant parti des méthodologies de Docker pour la livraison, le test et le déploiement du code, vous pouvez réduire considérablement le délai entre l’écriture du code et son exécution en production.

Pour plus d’information consulter : Docker overview | Docker Docs

Qu’est-ce que Docker Compose ?

Docker Compose est un outil permettant de définir et d’exécuter des applications Docker multi-conteneurs. Avec Docker Compose, vous utilisez un fichier YAML pour configurer les services de votre application. Il fonctionne dans tous les environnements : production, staging, développement, tests, ainsi que dans le flux de travail CI.

Pour plus d’information consulter : Docker Compose overview | Docker Docs

Rédaction

Installation de Git

Le plus simple est d’installer Git sur CentOS en utilisant le gestionnaire de paquets yum. Comme suit :

sudo yum install git

Vérifier si l’installation a réussi :

Pour plus d’information consulter : Git (git-scm.com)

Installation de Docker et Docker Compose

Pour installer Docker et Docker Compose sur CentOS 7 nous allons éxecuter plusieurs étapes. Pour une première installation sur notre machine nous allons configurer le référentiel Docker en tant que super utilisateur avant d’installer Docker et Docker Compose comme suit :

Installez le paquet yum-utils qui vous fournira l’utilitaire yum-config-manager et configurez le dépôt.

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

• Installez la version spécifique de Docker et Docker Compose comme suit :

sudo yum install docker-ce-24.0.6 docker-ce-cli-24.0.6 containerd.io docker-buildx-plugin docker-compose-plugin

• Activez Docker au démarrage du système, ensuite démarrer le service comme suit :

sudo systemctl enable docker
sudo systemctl start docker

• Attribuez les droits d’exécution du daemon Docker à votre utilisateur dans mon cas centos comme suit :

sudo usermod –aG docker centos

• Vérifiez que l’installation a réussi comme suit :

docker --version
docker compose version

• Vérifiez que la version retournée par Docker est 24.0.6 et vérifier que Docker Compose est aussi installé

Pour plus d’information consulter : Install Docker Engine on CentOS | Docker Docs

Installation et configuration de Jenkins
Pour l’installation de Jenkins nous allons utiliser Docker. Afin de le faire, exécutez les étapes suivantes :

• Créez le répertoire setup_jenkins et créez à l’intérieur de ce dernier le fichier docker-compose.yml

mkdir setup_jenkins
cd setup_jenkins && touch docker-compose.yml

• Récupérez le chemin de la commande docker

• Ajoutez le contenu suivant dans le fichier docker-compose.yml (remplacez path_daemon_docker par le chemin de la commande docker)

version: '4'
services:
  jenkins:
    privileged: true
    user: root
    container_name: jenkins-launch1
    image: jenkins/jenkins:2.454-jdk17
    restart: always
    ports:
      - 80:8080
      - 50000:50000
    volumes:
      - :/usr/bin/docker
      - jenkins_launch1/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock

• Lancez votre conteneur Jenkins


docker compose up –d

• Vérifiez que votre conteneur est en cours d’exécution

• Récupérez le mot de passe admin

docker exec -i jenkins-launch1 cat /var/jenkins_home/secrets/initialAdminPassword

Installez la version spécifique de Docker et Docker Compose comme suit :

sudo yum install docker-ce-24.0.6 docker-ce-cli-24.0.6 containerd.io docker-buildx-plugin docker-compose-plugin

Activez Docker au démarrage du système, ensuite démarrer le service comme suit :

sudo systemctl enable docker
sudo systemctl start docker

Vérifier que l’installation a réussi comme suit :

sudo docker --version
sudo docker compose version

Vérifier la version retournée par Docker est 24.0.6 et vérifier que Docker Compose est aussi installé

Pour plus d’information consulter : Install Docker Engine on CentOS | Docker Docs

Configuration de Dockerfile

Sachant que nous sommes dans un cadre de développement, il est important de rappeler quelques notions avant de passer à l’implémentation :

Pour que des fonctionnalités ajoutées à Odoo soient prises en compte par ce dernier, elles doivent être développées en modules (ou chaque module est un répertoire contenant au minimum les fichiers __manifest__.py et __init__ .py) contenus dans un répertoire costum_addons ;
Pour configurer Odoo nous utilisons un fichier odoo.conf ;

Notre configuration est la suivante :

odoo.conf

[options]
# chemin dans notre image vers le répertoire contenant les modules personnalisés
addons_path = /mnt/extra-addons/custom-addons

Pour plus d’information sur les paramètres du fichier odoo.conf consulter : Source — Documentation Odoo 15.0

Dockerfile

# Nous construisons notre image a partir de l'image officielle Odoo Community version 15 accessible sur le Docker Hub
FROM odoo:15


# Nous nous mettons en utilisateur root  
USER root


# En tant que root nous ajoutons les permissions de lecture et d'exécution pour tous les utilisateurs (autres) sur tous les fichiers et dossiers dans le répertoire /mnt/extra-addons/custom-addons.
RUN mkdir -p /mnt/extra-addons/custom-addons && chmod -R o+rX /mnt/extra-addons/custom-addons


# Nous copions nos modules personnalisés implémentés dans le répertoire contenant les modules personnalisés dans notre image
COPY costum_addons/ /mnt/extra-addons/custom-addons/


# Nous copions nos configurations dans l'image afin qu'elles soient prises en compte au lancement d'Odoo
COPY odoo.conf /etc/odoo


# Nous nous mettons en utilisateur odoo
USER odoo

Configuration de docker-compose.yml

Odoo a une architecture multiniveau, ce qui signifie que la présentation (basée sur NodeJS, HTML, CSS), la logique métier (basée sur python) et le stockage des données (basé sur PostgreSQL) sont séparés. L’instance de l’image officiel d’Odoo sur laquelle nous avons construit notre image nous fournit seulement la couche métier et présentation d’Odoo ; Raison pour laquelle nous devons la connectée à un autre conteneur qui va servir de stockage de données à Odoo. Pour cela on l’on va utiliser l’orchestrateur des conteneurs Docker à savoir Docker Compose que l’on va configurer comme suit :

docker-compose.yml

# Version de la syntaxe que l'on souhaite utilisée pour décrire nos services et réseaux
version: '3'


# Configuration de nos services odoo et postgres 
services:
  odoo: # Configuration de notre service Odoo
    image: eazy-odoo:1.0.0 # Nom de notre image personnalisée
    build: # Nous construisons notre image à partir de notre Dockerfile 
      dockerfile: ./Dockerfile
      context: .
    env_file: .env # Nous utilisons le fichier .env pour définir nos variables d'environnements pour connecter Odoo a la base de données ; Nb nous pouvons le faire dans le fichier odoo.conf, mais nous choisissons de le faire ici car ces valeurs change en fonction de l’environnement (dev, staging ou prod)d’exécution de notre service 
    depends_on: 
      - postgres # L'exécution de notre service dépend de celui de postgres
    ports:
      - "8069:8069" # Le port 8069 est exposé pour accéder à l'application Odoo 
    networks:
      - eazycnet # Définition du réseau dans lequel notre service communiquera
    volumes:
      - data:/var/lib/odoo # Définition d'un volume pour persister nos logs lors de l'exécution de l'application Odoo 
  postgres: # Configuration de notre service PostgreSQL
    image: postgres:13 # Image postgres 13 récupérée dans le Docker hub
    env_file: .env # Nous utilisons le fichier .env pour définir nos variables d'environnements pour définir l’utilisateur de connexion à la base de données
    ports:
      - "5432:5432" # Le port 5432 est exposé pour accéder à notre base de données
    networks:
      - eazycnet # Définition du réseau dans lequel notre service communiquera
    volumes:
      - db:/var/lib/postgresql/data # Définition d'un volume pour persister nos données sauvegardées
volumes: # Création de nos volumes
  data:
  db:
networks: # Création du réseau
  eazycnet:

Pour terminer cette configuration définissons nos variables d’environnements :

.env

# postgresql variables d'environnement
POSTGRES_DB=postgres
POSTGRES_PASSWORD=QAtM4jiGkNKGYbCEMIuAQ25TcOSwcGFeF5B
POSTGRES_USER=odoo
PGDATA=/var/lib/postgresql/data/pgdata


# odoo variables d'environnement
HOST=postgres
USER=odoo
PASSWORD=QAtM4jiGkNKGYbCEMIuAQ25TcOSwcGFeF5B
PORT=5432

Configuration des routines

Lors du développement nous devons souvent mettre à jour notre code à partir de notre base de code avant de lancer notre environnement ou lancer tout simplement notre environnement ou visualiser les journaux notre application ou encore vouloir nettoyer notre environnement. Une bonne pratique pour effectuer ces actions qui représentent des routines pour un développeur est d’écrire un script dans lequel ces actions seront exécutées. C’est ainsi que nous avons définir le script suivant :

run.sh

#!/bin/sh


# Récupérons le chemin absolu vers notre fichier docker compose.yml
export COMPOSE_FILE_PATH="${PWD}/docker compose.yml"

# Permet de lancer notre application
start() {
    sudo docker compose -f "$COMPOSE_FILE_PATH" up --build -d
}

# Permet d'arrêter notre application
down() {
    sudo docker compose -f "$COMPOSE_FILE_PATH" down
}

# Permet de visualiser les logs de notre application en cours d'exécution
tail() {
    sudo docker compose -f "$COMPOSE_FILE_PATH" logs -f
}

# Permet de supprimer nos volumes
delete() {
    sudo docker volume rm -f data
    sudo docker volume rm -f db
}

# Permet de mettre à jour notre code à partir de notre repository
pull() {
    sudo git pull origin develop
}

# Permet de choisir l'action à faire
case "$1" in
  build_start)
   pull
    start
    tail
    ;;
  start)
    start
    tail
    ;;
  stop)
    down
    ;;
  purge)
    down
    purge
    ;;
  *)
    echo "Usage: $0 {buil_start|start|stop|purge}"
esac

La configuration étant terminée, effectuons les actions suivantes :