Tutoriels Linux

Comment installer le CMS Ghost avec Docker sur Ubuntu 20.04

novembre 11, 2021

Ghost est une plateforme de blogging open-source pour t’aider à créer un blog d’apparence professionnelle. Elle a été lancée en 2013 comme une alternative à WordPress, qui devenait trop complexe. Ghost est écrit en JavaScript et est alimenté par Node.js.

Dans ce tutoriel, nous allons explorer comment installer le CMS Ghost à l’aide de Docker sur un serveur alimenté par Ubuntu 20.04. Nous utiliserons également Nginx comme proxy et le certificat SSL de Let’s Encrypt pour sécuriser notre installation.

Conditions préalables

Un serveur fonctionnant sous Ubuntu 20.04.
Un utilisateur sudo non-root.
Assure-toi que tout est mis à jour.
```
$ sudo apt update 
$ sudo apt upgrade
```

`Étape 1 - Configurer le pare-feu UFW`

La première étape consiste à configurer le pare-feu. Ubuntu est livré avec ufw (Uncomplicated Firewall) par défaut.

Vérifie si le pare-feu est en cours d'exécution.

$ sudo ufw status

Tu devrais obtenir la sortie suivante.

Status: inactive

Autorise le port SSH pour que le pare-feu ne rompe pas la connexion en cours en l'activant.

$ sudo ufw allow OpenSSH

Autorise également les ports HTTP et HTTPS.

$ sudo ufw allow 80
$ sudo ufw allow 443

Active le pare-feu

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Vérifie à nouveau l'état du pare-feu.

$ sudo ufw status

Tu devrais voir un résultat similaire.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80                         ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80 (v6)                    ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

`Étape 2 - Installe Certbot et obtiens le certificat SSL`

Avant de continuer, nous devons installer l'outil Certbot et installer un certificat SSL pour notre domaine.

Pour installer Certbot, nous allons utiliser l'installateur de paquets Snapd. Le dépôt officiel de Certbot a été déprécié et le paquet Certbot d'Ubuntu a plus d'un an. Snapd propose toujours la dernière version stable de Certbot et tu devrais l'utiliser. Heureusement, Ubuntu 20.04 est livré avec Snapd préinstallé.

Assure-toi que ta version de Snapd est à jour.

$ sudo snap install core 
$ sudo snap refresh core

Supprime toutes les anciennes versions de Certbot.

$ sudo apt remove certbot

Installe Certbot.

$ sudo snap install --classic certbot

Utilise la commande suivante pour t'assurer que la commande Certbot peut être exécutée en créant un lien symbolique vers le répertoire /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Génère un certificat SSL.

$ sudo certbot certonly --standalone -d example.com

La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/example.com sur ton serveur.

`Étape 3 - Installer Docker et Docker Compose`

La première étape consiste à installer le moteur Docker et Docker Compose. Tout d'abord, désinstalle toutes les anciennes versions de Docker.

$ sudo apt remove docker docker-engine docker.io containerd runc

Installe certains paquets nécessaires au fonctionnement de Docker.

$ sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release

Ajoute la clé GPG officielle de Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Ajoute le dépôt officiel de Docker.

$ echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Mets à jour les dépôts du système.

$ sudo apt update

Installe la dernière version de Docker Engine.

$ sudo apt install docker-ce docker-ce-cli containerd.io

Vérifie que Docker Engine fonctionne et est installé correctement.

$ sudo docker run hello-world

Par défaut, Docker nécessite sudo pour s'exécuter. Pour contourner cela, nous pouvons ajouter le compte utilisateur actuel au groupe d'utilisateurs docker.

$ sudo usermod -aG docker ${USER}

Pour appliquer la nouvelle appartenance au groupe, déconnecte-toi et reconnecte-toi ou utilise la commande suivante.

$ su - ${USER}

Maintenant, tu peux exécuter les commandes docker sans utiliser sudo.

Ensuite, télécharge la version stable actuelle de Docker compose.

sudo curl -L "https://github.com/docker/compose/releases/download/1.28.6/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Au moment de la rédaction de ce tutoriel, 1.28.6 est la dernière version de Docker compose. Tu peux toujours changer ou choisir une version différente dans la commande en vérifiant sur la page des versions Github de Docker compose.

Applique la permission d'exécuter à la version installée de Docker compose.

$ sudo chmod +x /usr/local/bin/docker-compose

Teste l'installation.

$ docker-compose --version
docker-compose version 1.28.6, build 5db8d86f

`Étape 4 - Installer Ghost`

L'installation de Ghost comprendra trois composants - le pack Ghost, un serveur de base de données tel que MySQL et un serveur Web (Nginx). Tous ces services peuvent être installés à l'aide d'un seul fichier Docker compose.

`Créer le fichier Docker Compose`

Tout d'abord, crée un répertoire pour stocker et lancer ton fichier Docker compose à partir de celui-ci.

$ mkdir ghost && cd ghost

Crée un fichier nommé docker-compose.yml et ouvre-le avec l'éditeur Nano.

$ nano docker-compose.yml

Colle le code suivant dans le fichier. Remplace example.com par ton domaine et insère un mot de passe de base de données à la place de la valeur your_password. Garde les mêmes valeurs pour database__connection__password et MYSQL_ROOT_PASSWORD. Remplace <username> par le nom d'utilisateur de ton serveur.

version: '3.3'
services:

  ghost:
    image: ghost:latest
    restart: always
    depends_on:
      - db
    environment:
      url: https://example.com
      database__client: mysql
      database__connection__host: db
      database__connection__user: ghost
      database__connection__password: ghostdbpass
      database__connection__database: ghostdb
      mail__transport: SMTP
      mail__options__host: {Your Mail Service host}
      mail__options__port: {Your Mail Service port}
      mail__options__secureConnection: {true/false}
      mail__options__service: {Your Mail Service}
      mail__options__auth__user: {Your User Name}
      mail__options__auth__pass: {Your Password}
    volumes:
      - /home/<username>/ghost/content:/var/lib/ghost/content

  db:
    image: mariadb:latest
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
	  MYSQL_USER: ghost
      MYSQL_PASSWORD: ghostdbpass
      MYSQL_DATABASE: ghostdb
    volumes:
      - /home/<username>/ghost/mysql:/var/lib/mysql

  nginx:
    build:
      context: ./nginx
      dockerfile: Dockerfile
    restart: always
    depends_on:
      - ghost
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /etc/letsencrypt/:/etc/letsencrypt/
      - /usr/share/nginx/html:/usr/share/nginx/html

Le fichier Docker compose crée quelques points de montage, c'est-à-dire qu'il mappe certains répertoires sur le serveur à des répertoires à l'intérieur du conteneur.

Les répertoires /var/lib/ghost/content et /var/lib/mysql à l'intérieur de tes conteneurs sont mappés à /home/<username>/ghost/content et /home/<username>/ghost/mysql sur le serveur.
Nginx utilise le lien /etc/letsencrypt/ pour accéder aux certificats Let's Encrypt du serveur.
Nginx doit également avoir accès au répertoire utilisateur /usr/share/nginx/html pour pouvoir accéder aux fichiers de défi Let's Encrypt pour le certificat.

Dans le fichier ci-dessus, nous avons également inclus des options pour configurer le courrier. Si tu utilises un service de messagerie SMTP populaire comme Mailgun, Mailjet, Mandrill, Postmark, Sendgrid, SendCloud, SES, Zoho ou Gmail, tu peux simplement ajouter le nom du service ainsi que ton nom d'utilisateur et ton mot de passe SMTP et supprimer le reste des champs. Sinon, remplis toutes les autres options et supprime le nom du service et cela devrait quand même fonctionner. Tu peux consulter d'autres options de messagerie sur la documentation de Ghost sur les options de messagerie.

Crée des répertoires pour tous les montages bind décrits ci-dessus (sauf pour /etc/letsencrypt, qui a déjà été créé lorsque nous avons créé le certificat auparavant).

$ cd ~/ghost
$ mkdir content
$ mkdir mysql
$ sudo mkdir -p /usr/share/nginx/html

`Crée l'image Docker de Nginx`

Le fichier Docker compose que nous avons créé repose sur l'image Docker Nginx. Pour qu'il fonctionne, nous devons inclure un fichier de configuration personnalisé pour Nginx qui fonctionnera avec Ghost.

Crée un répertoire pour cette image dans le répertoire actuel.

$ mkdir nginx

Crée un fichier nommé Dockerfile dans ce répertoire.

$ touch nginx/Dockerfile

Colle le code suivant dans le fichier Dockerfile.

FROM nginx:latest
RUN rm /etc/nginx/conf.d/default.conf
COPY ghost.conf /etc/nginx/conf.d

Le code ci-dessus indique à Docker d'utiliser la dernière image Nginx. Il supprime également le fichier de configuration Nginx par défaut et copie le fichier de configuration personnalisé que nous avons créé pour notre CMS Ghost.

Crée un fichier nommé ghost.conf dans le répertoire nginx.

$ touch nginx/ghost.conf

Colle le code suivant dans le fichier ghost.conf. Remplace toutes les instances de example.com par ton domaine.

server {
  listen 80;
  listen [::]:80;
  server_name example.com;
  # Useful for Let's Encrypt
  location /.well-known/acme-challenge/ { root /usr/share/nginx/html; allow all; }
  location / { return 301 https://$server_name$request_uri; }
}

server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  server_name example.com;
    
  access_log /var/log/nginx/ghost.access.log;
  error_log /var/log/nginx/ghost.error.log;
  client_max_body_size 20m;

  ssl_protocols TLSv1.2 TLSv1.3;
  ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
  ssl_prefer_server_ciphers on;
  ssl_session_timeout 1d;
  ssl_session_cache shared:SSL:10m;

  ssl_certificate     /etc/letsencrypt/live/example.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

  location / {
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto https;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass http://ghost:2368;
  }
}

La configuration ci-dessus redirigera toutes les demandes HTTP vers HTTPS et servira de proxy au service Ghost pour le servir via ton domaine.

`Étape 5 - Exécute le site`

Exécute la commande suivante depuis le répertoire ghost pour lancer le service Ghost.

$ docker-compose up -d

Tu peux maintenant vérifier ton installation en ouvrant https://example.com dans ton navigateur Web. Cela peut prendre plusieurs minutes pour que le Docker mette en marche tous les services, alors tu devras peut-être rafraîchir si tu ne vois pas ton blog tout de suite.

Si ton site ne s'affiche pas dans le navigateur, tu dois consulter les journaux de Docker. Pour ce faire, ferme d'abord ton conteneur.

$ cd ghost
$ docker-compose down

Exécute Docker compose dans un état attaché pour voir les journaux générés par chaque conteneur.

$ docker-compose up

Pour éteindre le conteneur et revenir à l'invite bash, appuie sur CTRL+C. Une fois que tu as terminé le dépannage, tu peux relancer le conteneur et ton blog devrait être visible cette fois-ci.

`Étape 6 - Terminer la configuration`

Pour terminer la configuration de ton blog Ghost, visite https://example.com/ghost dans ton navigateur. L'extra /ghost à la fin du domaine de ton blog te redirige vers le panneau d'administration de Ghost ou, dans ce cas, la configuration puisque tu y accèdes pour la première fois.

Ici, tu devras créer ton compte d'administrateur et choisir un titre de blog.

Tu peux également inviter des membres du personnel ou des collaborateurs supplémentaires pour ton blog, ce que tu pourras également faire plus tard si tu choisis de sauter maintenant.

À la fin de l'installation, tu seras accueilli par le panneau d'administration de Ghost.

Si tu veux passer en mode sombre, tu peux le faire en cliquant sur l'interrupteur à bascule à côté du bouton de l'engrenage des paramètres en bas de la page des paramètres.

Tu verras déjà quelques posts par défaut qui sont essentiellement des guides pour t'aider à naviguer et à utiliser Ghost. Tu peux les dépublier ou les supprimer et commencer à poster.

`Étape 7 - Mets à jour Ghost`

Dans notre fichier Docker compose, nous tirons la dernière version de Ghost disponible au moment de l'installation, ce qui facilite la mise à jour de ton blog Ghost.

Pour mettre à jour, tu dois éteindre ton conteneur, tirer les dernières images et relancer le conteneur.

$ docker-compose down
$ docker-compose pull && docker-compose up -d

`Étape 8 - Renouvelle ton certificat SSL Let's Encrypt`

Les certificats Let's Encrypt ne sont valables que pendant 90 jours. Par conséquent, nous devons configurer un cronjob qui renouvellera le certificat automatiquement.

Ouvre Crontab dans ton éditeur.

$ sudo crontab -e

Colle la ligne suivante à la fin qui exécutera Certbot à 23 heures tous les jours. Remplace example.com par ton domaine.

0 23 * * *   certbot certonly -n --webroot -w /usr/share/nginx/html -d example.com --deploy-hook='docker exec ghost_nginx_1 nginx -s reload'

L'exécution à 23 heures tous les jours ne signifie pas que ton certificat sera renouvelé tous les jours puisque Certbot ne renouvellera ton certificat que si sa date d'expiration est dans les 30 jours. Exécuter cette commande chaque nuit donne au script un certain nombre de chances d'essayer avant l'expiration.

La commande ci-dessus redémarrera également le serveur Nginx à l'intérieur du conteneur Docker après un renouvellement réussi.

Tu peux tester le cronjob en utilisant l'option --dry-run de Certbot.

$ sudo bash -c "certbot certonly -n --webroot --dry-run -w /usr/share/nginx/html -d example.com --deploy-hook='docker exec ghost_nginx_1 nginx -s reload'"

`Conclusion`

Ceci conclut notre tutoriel sur la façon de configurer Ghost CMS sur ton serveur basé sur Ubuntu 20.04 en utilisant Docker. Si tu as des questions ou des commentaires, partage-les dans les commentaires ci-dessous.

`Vous aimerez aussi...`

 Article suivant Le serveur parfait – Ubuntu 20.04 avec Apache, PHP, MariaDB, PureFTPD, BIND, Postfix, Dovecot et ISPConfig 3.2
Article précédent Comment installer PostGIS PostgreSQL Geographic Information Systems sur Debian 10
  Rechercher :   
Articles récents
 Comment installer le serveur HTTP Git avec Nginx sur Debian 11
 Tutoriel de la commande tail de Linux pour les débutants (5 exemples)
 Comment installer vyOS RouterOS avec KVM
 Comment installer le noyau Linux 6.0 sur Ubuntu 22.04
 Comment installer ERPNext 14 sur Debian 11

Comment installer le CMS Ghost avec Docker sur Ubuntu 20.04

Conditions préalables

Étape 1 - Configurer le pare-feu UFW

Étape 2 - Installe Certbot et obtiens le certificat SSL

Étape 3 - Installer Docker et Docker Compose

Étape 4 - Installer Ghost

Créer le fichier Docker Compose

Crée l'image Docker de Nginx

Étape 5 - Exécute le site

Étape 6 - Terminer la configuration

Étape 7 - Mets à jour Ghost

Étape 8 - Renouvelle ton certificat SSL Let's Encrypt

Conclusion

Vous aimerez aussi...

Comment mettre à jour la version Docker de ONLYOFFICE Docs sur Ubuntu

Comment installer WonderCMS avec Nginx sur Debian 9

Comment installer le serveur FTP vsftpd et le sécuriser avec TLS sur Debian 11

Articles récents