Strapi v4 : Comment intaller Strapi dans un conteneur docker

Sommaire

1 Introduction
2 Prérequis
3 Étape 1 : Créer un nouveau projet Strapi
4 Étape 2 : Créer le Dockerfile
5 Étape 3 : Configurer docker-compose
6 Étape 4 : Lancez le projet docker
7 Étape 5 : Configurez la base de données dans pgAdmin
8 Étape 6 : Résolution des problèmes

Introduction

Strapi est reconnu comme le CMS headless le plus populaire, il offre la possibilité de déployer rapidement une API. Il permet de réaliser toutes les tâches génériques “out the box”, ce qui en fait une solution particulièrement intéressante.

Ce guide vous accompagne dans l’installation de Strapi version 4.15.5 dans un conteneur Docker, en utilisant PostgreSQL comme base de données et TypeScript comme langage. Il propose également des instructions pour faciliter l’administration de votre projet Strapi.

Prérequis

Avant d’installer Strapi, les prérequis suivants doivent être installés sur votre ordinateur :

Étape 1 : Créer un nouveau projet Strapi

Exécutez la commande suivante dans un terminal pour créer un projet. Vous pouvez personnaliser le nom du projet “strapiProject”.

yarn create strapi-app strapiProject

La commande vous proposera quelques choix concernant le type d’installation :
Choisir “Custom (manual settings)” puis appuyez sur “Entrée”

Choose your installation type
  Quickstart (recommended)
> Custom (manual settings)

Pour le langage de programmation préféré, choisissez TypeScript puis appuyez sur “Entrée” .

Choose your preferred language (Use arrow keys)
  JavaScript
> TypeScript

Pour le type de base de données, choisissez Postgres puis appuyez sur “Entrée” .

Choose your default database client
  sqlite
> postgres
  mysql

Pour le nom de la base de données, appuyez sur “Entrée” pour choisir le nom suggéré (par défaut le nom du projet) ou définissez le nom que vous souhaitez.

Database name: (strapiProject)

Pour le “host” de la base de données, utilisez le nom de notre service de base de données que nous allons définir plus tard, “strapiDB” puis appuyez sur “Entrée”.

Host: strapiDB

Pour le port de la base de données, laissez le port par défaut suggéré et appuyez sur “Entrée”.

Port: (5432)

Renseignez le nom d’utilisateur de la base de données, ici nous choisissons “root”.

Username : root

Renseignez le mot de passe de la base de données, ici nous choisissons “letGo”.

Password: *****

Désactivez la connexion SSL à la base de données en toute sécurité, étant donné que nous sommes dans un environnement de développement en saisissant “N” puis appuyez sur “Entrée”

Enable SSL connection: (y/N) N

Étape 2 : Créer le Dockerfile

Ouvrez le dossier de votre projet dans votre IDE préféré, puis créez un fichier Dockerfile à la racine de celui-ci.

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"]

Le fichier Dockerfile installe les dépendances de Strapi, construit ensuite le projet en mode développement, et expose finalement le projet sur le port 1337.

Pour optimiser la taille de l’image Docker créée sur votre disque, ajoutez également le fichier “.dockerignore” à la racine du projet. Ce fichier permet de spécifier la liste des dossiers à exclure lors de la création de notre image.

.tmp/
.cache/
.git/
build/
node_modules/
data/

Étape 3 : Configurer docker-compose

Créez un fichier docker-compose.yml à la racine du projet et collez-y le contenu du code ci-dessous.

version: "3"
services:
  strapi:
    container_name: strapi
    command: /bin/sh -c "yarn strapi ts:generate-types && yarn develop"
    build: .
    image: strapi:latest
    restart: unless-stopped
    env_file: .env
    environment:
      DATABASE_CLIENT: ${DATABASE_CLIENT}
      DATABASE_HOST: strapiDB
      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}
    volumes:
      - ./config:/opt/app/config
      - ./src:/opt/app/src
      - ./types:/opt/app/types
      - ./package.json:/opt/package.json
      - ./.env:/opt/app/.env
      - ./public/uploads:/opt/app/public/uploads
    ports:
      - "1337:1337"
    networks:
      - strapi
    depends_on:
      - strapiDB

  strapiDB:
    container_name: strapiDB
    platform: linux/amd64 #for platform error on Apple M1 chips
    restart: unless-stopped
    env_file: .env
    image: postgres:12.0-alpine
    environment:
      POSTGRES_USER: ${DATABASE_USERNAME}
      POSTGRES_PASSWORD: ${DATABASE_PASSWORD}
      POSTGRES_DB: ${DATABASE_NAME}
    volumes:
      - strapi-data:/var/lib/postgresql/data/ #using a volume
      #- ./data:/var/lib/postgresql/data/ # if you want to use a bind folder
    ports:
      - "5432:5432"
    networks:
      - strapi

  pgadmin:
    image: dpage/pgadmin4:latest
    container_name: pgadmin
    environment:
      PGADMIN_DEFAULT_EMAIL: [email protected]
      PGADMIN_DEFAULT_PASSWORD: Password
    ports:
      - "8080:80"
    depends_on:
      - strapiDB
    networks:
      - strapi

volumes:
  strapi-data:

networks:
  strapi:
    name: Strapi
    driver: bridge

Ce fichier définit trois services :

strapi : Crée un conteneur à partir de l’image Docker construite avec notre fichier Dockerfile de l’étape précédente. Ce conteneur contient le code source du projet ainsi que tout son environnement d’exécution.
strapiDB : Crée un conteneur à partir de l’image officielle de PostgreSQL. Ce conteneur contient la base de données de notre projet Strapi.
pgadmin : Crée un conteneur à partir de l’image officielle de pgAdmin. Ce conteneur nous permet d’avoir une interface de visualisation de notre base de données PostgreSQL. N’hésitez pas à personnaliser les identifiants permettant de se connecter à pgAdmin ([email protected] et Password).

Étape 4 : Lancez le projet docker

Nous sommes prêts à lancer le projet. Pour ce faire, placez-vous à la racine du projet, là où se trouve notre fichier docker-compose.yml, et exécutez la commande ci-dessous. Cette commande permet de lancer le projet en mode attaché, c’est-à-dire que les logs de nos conteneurs seront affichés en temps réel dans le terminal.

docker-compose up

Pour exécuter le projet en mode détaché, tapez la commande ci-dessous :

docker-compose up -d

Pour accéder à notre backend Strapi, rendez-vous sur l’adresse :
http://localhost:1337/admin

Pour accéder à notre interface de visualisation de la base de données, rendez-vous sur l’adresse :
http://localhost:8080

Étape 5 : Configurez la base de données dans pgAdmin

1. Accédez à l’URL http://localhost:8080. Connectez-vous avec les identifiants configurés au niveau de notre service pgAdmin. Dans notre cas (“[email protected]” et “Password”). Choisissez comme langue le français.

2. Clique droit sur le menu de gauche “Serveurs” puis sur “Nouveau” et ensuite sur “Serveur”.

3. Donnez le nom de votre choix au serveur que nous ajoutons. Dans notre cas, nous choisissons “strapiProject”.

4. Appuyez sur l’onglet “Connexion”. Remplissez les informations de connexion à la base de données. N’oubliez pas d’adapter si vous avez personnalisé la configuration :

Nom d’hôte / Adresse : strapiDB (reprend le nom de notre service Docker Compose)
Port : 5432
Base de données de maintenance : Laissez la valeur par défaut
Nom d’utilisateur : root
Mot de passe : letGo

Enfin, appuyez sur “Enregistrer”.

Étape 6 : Résolution des problèmes

Pendant l’installation du projet, si vous rencontrez des erreurs et devez modifier le Dockerfile, il est nécessaire de reconstruire l’image en utilisant la commande ci-dessous au moment de relancer le projet.

docker-compose up --build

Lorsque vous modifiez le fichier docker-compose.yml, il est nécessaire de forcer la recréation des conteneurs au moment de lancer le projet pour la prise en compte des nouvelles configurations spécifiées. Pour ce faire, utilisez la commande suivante :

docker-compose up --force-recreate

Si vous modifiez le Dockerfile et le fichier docker-compose.yml, vous devez exécuter la commande ci-dessous lors du lancement du projet pour la prise en compte les modifications :

docker-compose up --force-recreate --build

Lorsque vous souhaitez partir sur une base de données vierge de Strapi et réinitialiser complètement le projet (en supprimant les conteneurs, les volumes et le réseau), exécutez les commande ci-dessous :

docker-compose down --volumes && docker-compose up -d

Si vous avez lancé le projet en mode détaché avec “docker-compose up -d” comme ci-dessus et que vous souhaitez consulter les logs des services en cours d’exécution, vous pouvez utiliser les commandes ci-dessous :

#Cette commande affiche les logs de tous les services
docker-compose logs

#Cette commande affiche les logs du service strapi uniquement
docker-compose logs strapi