Strapi v4 : Infrastructure pour déployer strapi dans un serveur Ubuntu avec Docker Compose

Mise à jour le 04 Sep 2024

Introduction

Pour simplifier le déploiement de Strapi 4, nous prévoyons de mettre en œuvre une infrastructure de déploiement en utilisant Docker Compose. Cette approche est idéale pour les environnements de test, assurant une gestion efficace des conteneurs et simplifiant le processus de configuration. Pour les déploiements en production, nous privilégierons des outils tels que Kubernetes.

Prérequis

Un projet Strapi 4 prêt à être déployé.
Comprendre le fonctionnement de Docker
Avoir une instance gitlab privé fonctionnelle

Afin de rendre la lecture de l’article plus accessible et compréhensible, partons du principe que nous disposons d’un projet nommé strapi-project hébergé sur notre GitLab privé à l’adresse gitlab.kata.ovh. De plus, notre instance GitLab est équipée d’un registre permettant de stocker nos images Docker, accessible via l’URL registry.kata.ovh.

Préparation du projet

Créez un fichier Dockerfile.prod à la racine de votre projet avec le contenu suivant.

FROM node:18-alpine
# Installing libvips-dev for sharp Compatibility
RUN apk update && apk add --no-cache build-base gcc autoconf automake zlib-dev libpng-dev nasm bash vips-dev git
ARG NODE_ENV=development
ENV NODE_ENV=${NODE_ENV}

WORKDIR /opt/
COPY package.json yarn.lock ./
RUN yarn global add node-gyp
RUN yarn config set network-timeout 600000 -g && yarn install
ENV PATH /opt/node_modules/.bin:$PATH

WORKDIR /opt/app
COPY . .
RUN chown -R node:node /opt/app
USER node
RUN ["yarn", "build"]
EXPOSE 1337
CMD ["yarn", "develop"]

Ce fichier Dockerfile.prod est utilisé pour construire une image légère de notre projet spécialement conçue pour les environnements de production et de préproduction.

Création de l’image Docker

Dans cette section, nous allons générer l’image de notre projet Strapi v4 et la téléverser vers le registre de notre GitLab privé. Cela permettra de la rendre accessible depuis notre serveur Ubuntu.

Assurez-vous d’être connecté à GitLab Container Registry. Vous pouvez vous connecter en utilisant la commande suivante dans votre terminal :

docker login registry.kata.ovh

La commande vous demandera de saisir votre username gitlab

Username: [email protected]

Puis votre mot de passe

Password: ********

Exécutez la commande suivante pour générer l’image Docker en utilisant le fichier Dockerfile.prod précédemment créé.

docker build -f Dockerfile.prod -t registry.kata.ovh/strapi-project/api:v1.0.2 .

Ensuite, poussez l’image générée vers le registre GitLab registry.kata.ovh en utilisant la commande suivante

docker push registry.kata.ovh/strapi-project/api:v1.0.2

Mise en place de l’Infrastructure de Déploiement

Créer le dépôt git

Pour la configuration de notre infrastructure de déploiement Strapi v4, nous allons créer un groupe “deploy” dans GitLab, ainsi qu’un dépôt au sein de ce groupe, que nous nommerons “strapi4-dc”. L’acronyme “dc” est utilisé ici pour Docker Compose, parce que d’autres technologies comme Helm auraient également pu être employées pour le déploiement. Cette approche vise à isoler notre infrastructure de déploiement de notre projet, favorisant ainsi une meilleure réutilisation.

Pour créer le dossier strapi4-dc sur votre ordinateur, utilisez les commandes suivantes dans votre terminal :

# Création du dossier
mkdir strapi4-dc

# Déplacement dans le dossier
cd strapi4-dc

Créer le fichier docker-compose.yml

Ensuite, créez le fichier docker-compose.yml et ajoutez le contenu suivant :

version: "3.7"

services:
  strapi:
    image: $APP_IMAGE
    restart: unless-stopped
    env_file: .env
    environment:
      DATABASE_CLIENT: ${DATABASE_CLIENT}
      DATABASE_HOST: postgres
      DATABASE_PORT: ${DATABASE_PORT}
      DATABASE_NAME: ${DATABASE_NAME}
      DATABASE_USERNAME: ${DATABASE_USERNAME}
      DATABASE_PASSWORD: ${DATABASE_PASSWORD}
      JWT_SECRET: ${JWT_SECRET}
      ADMIN_JWT_SECRET: ${ADMIN_JWT_SECRET}
      APP_KEYS: ${APP_KEYS}
      NODE_ENV: ${NODE_ENV}
    ports:
      - "${STRAPI_HOST_PORT}:1337"
    volumes:
      - ./uploads:/opt/app/public/uploads
      - ./.env:/opt/app/.env:ro
    networks:
      - strapi

  postgres:
    image: postgres:12.0-alpine
    env_file: .env
    environment:
      POSTGRES_DB: ${DATABASE_NAME}
      POSTGRES_USER: ${DATABASE_USERNAME}
      POSTGRES_PASSWORD: ${DATABASE_PASSWORD}
    volumes:
      - ./postgres:/var/lib/postgresql/data
    networks:
      - strapi

  pgadmin:
    image: dpage/pgadmin4:8.0
    environment:
      PGADMIN_DEFAULT_EMAIL: ${POSTGRES_EMAIL}
      PGADMIN_DEFAULT_PASSWORD: ${POSTGRES_PASSWORD}
      PGADMIN_CONFIG_WTF_CSRF_CHECK_DEFAULT: 'False'
      PGADMIN_CONFIG_WTF_CSRF_ENABLED: 'False'
    ports:
      - "${PGADMIN_HOST_PORT}:80"
    depends_on:
      - postgres
    networks:
      - strapi

networks:
  strapi:

Notre fichier docker-compose.yml configure trois services (Strapi, PostgreSQL, et PgAdmin) dans un réseau nommé “strapi”. Il utilise des variables d’environnement provenant d’un fichier .env pour configurer les services.

Service Strapi (strapi)

Utilise l’image définie par la variable $APP_IMAGE.
Redémarre automatiquement en cas de crash sauf s’il est explicitement arrêté.
Charge les variables d’environnement à partir du fichier .env.
Expose le port défini par la variable ${STRAPI_PORT}.
Monte les volumes pour stocker les téléchargements et le fichier .env.
Connecté au réseau “strapi”.

Service PostgreSQL (postgres)

Utilise l’image PostgreSQL version 12.0 sur Alpine Linux.
Charge les variables d’environnement à partir du fichier .env.
Crée la base de données et l’utilisateur avec les informations fournies.
Monte un volume pour stocker les données PostgreSQL.
Connecté au réseau “strapi”.

Service PgAdmin (pgadmin)

Utilise l’image PgAdmin (Outils de gestion et d’administration de bases de données PostgreSQL)
Configure PgAdmin avec les informations d’identification spécifiées dans le fichier .env.
Expose le port défini par la variable ${PGADMIN_PORT}.
Dépend du service PostgreSQL.
Connecté au réseau “strapi”.

Créer le fichier .env

Créer le fichier .env et ajoutez le contenu suivant :

# STRAPI Configuration
PORT=1337
APP_KEYS=JpYqnzFjgj75EeyDrxA==,gja6Uamtx6TqtvyW5RgMKA==,PyP+zTK7gVbhstSpMOuSmQ==,iU88W5ElOt5LdhhRjZfiBw==
API_TOKEN_SALT=m1Lz5r48wYr83910MXOe3Q==
ADMIN_JWT_SECRET=AYCUcsY76554Ev5yP5w==
TRANSFER_TOKEN_SALT=zPUEUfD67HjFAQ4Dv0Q==
DATABASE_CLIENT=postgres
DATABASE_HOST=postgres
DATABASE_PORT=5432
DATABASE_NAME=kata
DATABASE_USERNAME=kata
DATABASE_PASSWORD=3Mvg64c62hB567EVVe
DATABASE_SSL=false
JWT_SECRET=kLRX4354GAhQI578nLSH4ZQ==
NODE_ENV=development
STRAPI_HOST_PORT=80
APP_IMAGE_FALLBACK=registry.kata.ovh/strapi-project/api:v1.0.2

# PGADMIN Configuration
[email protected]
POSTGRES_PASSWORD=3Mvg64c62hB567EVVe
PGADMIN_HOST_PORT=1378

# GITLAB REGISTRY Configuration
[email protected]
REGISTRY_PASSWORD=glpat-R9k3iYciZGG2QbWQLg7F
REGISTRY=registry.kata.ovh

Il contient les informations nécessaires pour configurer notre environnement Docker Compose pour Strapi et PgAdmin. N’oubliez pas de personnaliser les valeurs en fonction de la configuration souhaitée.

Gestion de l’état de notre infrastructure

Notre service Strapi au niveau de notre fichier docker-compose utilise un volume pour assurer la persistance des téléchargements de fichier. Il faut alors créer le volume ./uploads monté dans le répertoire /opt/app/public/uploads, garantissant que les téléchargements de l’application Strapi sont stockés de manière persistante.

mkdir uploads

Idem pour notre service PostgreSQL, pour assurer la persistance de notre base de données il faut créer le volume ./postgres qui est lié au chemin /var/lib/postgresql/data à l’intérieur du conteneur PostgreSQL.

mkdir postgres

Créer également un fichier .gitignore pour ignorer le contenu de nos volumes ainsi que notre fichier de configuration .env lors de la gestion de version avec Git.

uploads/*
postgres/*
.env

Créer le fichier deploy.sh

Pour finir nous allons créer le fichier deploy.sh qui permet de lancer notre déploiement :

#!/bin/bash

# Chargement des variables d'environnement depuis le fichier .env
if [ -f .env ]; then
  source .env
else
  echo "Erreur : Le fichier .env n'est pas trouvé."
  exit 1
fi

# Si aucun paramètre n'est fourni, utilise la valeur de APP_IMAGE_FALLBACK du fichier .env
if [ $# -eq 0 ]; then
  export APP_IMAGE="$APP_IMAGE_FALLBACK"
else
  # Si un paramètre est fourni, utilise la valeur fournie
  export APP_IMAGE="$1"
fi

# connexion au registre
docker login -u $REGISTRY_USER -p $REGISTRY_PASSWORD $REGISTRY

# Ajouter /snap/bin au PATH si necessaire
# export PATH=$PATH:/snap/bin

docker-compose down
docker-compose pull
docker-compose up -d

Le script deploy.sh permet le déploiement de notre application Strapi. Ce script prend en paramètre le tag d’image de notre projet qui a été envoyé au registre. Si aucun tag d’image n’est spécifié en tant que paramètre, il utilise le tag par défaut défini dans la variable APP_IMAGE_FALLBACK.

En adoptant cette approche, le script deploy.sh peut être utilisé dans des processus d’intégration continue (CI) ou de déploiement continu (CD) sans nécessiter de changements dans le script lui-même. Ainsi, en modifiant simplement le tag d’image lors de l’exécution du script, on peut déployer différentes versions de l’application dynamiquement.

Envoyer les fichiers dans le dépôt distant

Pour pousser votre infrastructure dans le dépôt distant à l’adresse https://gitlab.kata.ovh/deploy/strapi4-dc.git, executez les commandes ci dessous :

#Initialisation du dépôt local
git init

#Ajout des fichiers au suivi de Git
git add .

#Validation des modifications locales
git commit -m "Initial commit - Ajout de l'infrastructure Docker Compose"

#Ajout du dépôt distant (origin)
git remote add origin https://gitlab.kata.ovh/deploy/strapi4-dc.git

# Pousser vers le dépôt distant (branche principale main)
git push origin main

Déploiement

Dans cette étape nous allons déployer l’application au niveau de notre serveur Ubuntu

Création d’un utilisateur de déploiement

Connectez-vous à votre serveur Ubuntu en tant que root à l’aide de la commande.

# Saisissez la commande puis suivez les instructions
ssh [email protected]

# connexion avec clé RSA
ssh -i id_rsa_kata [email protected]

Créer un utilisateur spécifique dédié au déploiement de l’application pour des raisons de sécurité. Utilisons le nom d’utilisateur deploy comme suit :

sudo adduser deploy

Suivez les instructions pour définir le mot de passe et les informations supplémentaires de l’utilisateur.

Ajoutez l’utilisateur au groupe sudo pour lui donner les privilèges nécessaires :

sudo usermod -aG sudo deploy

Déploiement

# Connexion avec l'utilisateur de deploiement
ssh [email protected]

# Créer le dossier dans le répertoire personnel de l'utilisateur de déploiement
mkdir ~/strapi-project

# Se deplacer dans le dossier
cd ~/strapi-project

# cloner notre infrastructure au niveau de notre serveur Ubuntu
git clone https://gitlab.kata.ovh/deploy/strapi4-dc.git .

# Créer le fichier .env et renseigner les informations 
# Pour sauvegarder, Ctrl + O puis appuyer sur "Enter"
# Pour quitter, Ctrl + X
nano .env

# rendre deploy.sh exécutable
chmod +x deploy.sh

# Executer la version par defaut de notre projet Strapi
# deploy.sh deploiera le tag APP_IMAGE_FALLBACK dans .env
./deploy.sh

Pour déployer une nouvelle version (v1.0.3) de l’application à partir d’une pipeline, par exemple, sans avoir à modifier les fichiers de notre infrastructure, vous pouvez utiliser la commande suivante :

# Executer une nouvelle version de notre projet Strapi
./deploy.sh "registry.kata.ovh/strapi-project/api:v1.0.3"

Conclusion

Notre exploration a permis de construire une infrastructure robuste et adaptable pour le déploiement de Strapi 4, soulignant l’efficacité et la simplicité offertes par Docker Compose dans la gestion des applications conteneurisées. Ces connaissances peuvent servir de guide pour d’autres projets similaires et faciliter la compréhension des principes fondamentaux de déploiement avec Docker sur un serveur Linux.

Mamadou Diagne

Architecte logiciel & CTO * Plus de publications

Architecte logiciel, Développeur d'application diplomé d'ETNA, la filière d'alternance d'Epitech, j'ai acquis une expertise solide dans le développement d'applications, travaillant sur des projets complexes et techniquement diversifiés. Mon expérience englobe l'utilisation de divers frameworks et langages, notamment Symfony, Api Platform, Drupal, Zend, React Native, Angular, Vue.js, Shell, Pro*C...