Installation · 9 min read · Oct 26, 2025
Comment installer Statping sur Ubuntu 22.04
Statping est un moniteur de disponibilité open-source qui suit les sites Web et les applications hébergés sur plusieurs serveurs. Il peut générer une belle page de statut en récupérant des données en temps réel à partir de diverses sources. Il peut fonctionner avec plusieurs systèmes de base de données, y compris SQLite, MySQL et Postgres. Pour notre tutoriel, nous utiliserons le fork de Statping, appelé Statping-ng puisque l’application originale n’est plus développée.
Dans ce tutoriel, vous apprendrez comment installer Statping sur un serveur Ubuntu 22.04 en utilisant Docker et Nginx comme proxy.
Prérequis
- Un serveur exécutant Ubuntu 22.04.
- Un utilisateur non-root avec des privilèges sudo.
- Le pare-feu uncomplicated (UFW) est activé et en cours d’exécution.
- Un nom de domaine complètement qualifié (FQDN) pointant vers le serveur comme,
status.example.com. - Tout est à jour.
$ sudo apt update && sudo apt upgrade
Étape 1 - Configurer le pare-feu
Avant d’installer des paquets, la première étape consiste à configurer le pare-feu pour autoriser les connexions HTTP et HTTPS.
Vérifiez l’état du pare-feu.
$ sudo ufw status
Vous devriez voir quelque chose comme ce qui suit.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Autorisez les ports HTTP et HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Vérifiez à nouveau l’état pour confirmer.
$ sudo ufw status
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443 ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
80/tcp (v6) ALLOW Anywhere (v6)
443 (v6) ALLOW Anywhere (v6)
Étape 2 - Installer Docker
Ajoutez la clé GPG officielle de Docker.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
Exécutez la commande suivante pour ajouter le dépôt Docker.
$ echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Mettez à jour le système pour inclure le dépôt de Docker.
$ sudo apt update
Installez Docker et le plugin Docker compose.
$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin
Ce tutoriel utilisera le plugin Docker Compose v2 au lieu de l’ancien binaire hérité. Par conséquent, la commande pour l’exécuter a changé de docker-compose à docker compose et cela est reflété ici.
Docker fonctionne avec des privilèges élevés, vous devrez donc utiliser sudo fréquemment pour exécuter des commandes. La meilleure option est d’ajouter votre compte utilisateur Linux au groupe d’utilisateurs docker.
$ sudo usermod -aG docker ${USER}
La variable ${USER} prend le compte système actuellement connecté. Si vous n’êtes pas connecté avec l’utilisateur auquel vous souhaitez donner des privilèges, remplacez ${USER} par le nom d’utilisateur.
Pour appliquer le nouveau membre du groupe, déconnectez-vous du serveur et reconnectez-vous, ou utilisez la commande suivante. Vous serez invité à entrer le mot de passe de l’utilisateur.
$ su - ${USER}
Étape 3 - Installer Nginx
Ubuntu 22.04 est livré avec une version plus ancienne de Nginx. Pour installer la dernière version, vous devez télécharger le dépôt officiel de Nginx.
Importez la clé de signature de Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Ajoutez le dépôt pour la version stable de Nginx.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Mettez à jour les dépôts du système.
$ sudo apt update
Installez Nginx.
$ sudo apt install nginx
Vérifiez l’installation.
$ nginx -v
nginx version: nginx/1.22.0
Étape 4 - Installer SSL
Nous devons installer Certbot pour générer le certificat SSL. Vous pouvez soit installer Certbot en utilisant le dépôt d’Ubuntu, soit obtenir la dernière version en utilisant l’outil Snapd. Nous allons utiliser la version Snapd.
Ubuntu 22.04 est livré avec Snapd installé par défaut. Exécutez les commandes suivantes pour vous assurer que votre version de Snapd est à jour.
$ sudo snap install core
Installez Certbot.
$ sudo snap install --classic certbot
Utilisez la commande suivante pour vous 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
Exécutez la commande suivante pour générer un certificat SSL.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d status.example.com
La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/status.example.com sur votre serveur.
Générez un certificat de groupe Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Ouvrez le fichier /etc/letsencrypt/renewal/status.example.com.conf pour l’éditer.
$ sudo nano /etc/letsencrypt/renewal/status.example.com.conf
Collez le code suivant en bas.
pre_hook = systemctl stop nginx
post_hook = systemctl start nginx
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Nous avons généré le certificat SSL en utilisant l’option autonome de Certbot. Il exécute son serveur Web pour créer le certificat, ce qui signifie que Nginx doit être arrêté pendant le renouvellement. Les commandes pre_hook et post_hook s’exécutent avant et après le renouvellement pour arrêter et redémarrer automatiquement le serveur Nginx, nécessitant ainsi aucune intervention manuelle.
Pour vérifier si le renouvellement SSL fonctionne correctement, effectuez un essai à sec du processus.
$ sudo certbot renew --dry-run
Si vous ne voyez pas d’erreurs, vous êtes prêt. Votre certificat se renouvellera automatiquement.
Étape 5 - Configurer le fichier Docker Compose
Créez un répertoire pour le fichier Docker compose.
$ mkdir ~/statping
Accédez au répertoire.
$ cd ~/statping
Créez et ouvrez le fichier docker compose pour l’éditer.
$ nano docker-compose.yml
Collez le code suivant dedans.
services:
statping:
container_name: statping
image: adamboutcher/statping-ng
restart: always
ports:
- 8080:8080
volumes:
- ./statping_data:/app
links:
- postgres
depends_on:
- postgres
environment:
DB_CONN: postgres
DB_HOST: postgres
DB_PORT: 5432
DB_DATABASE: statping
DB_USER: root
DB_PASS: password123
NAME: 'Page Statping de Howtoforge'
DESCRIPTION: 'Page de démonstration Statping'
USE_ASSETS: 'true'
SAMPLE_DATA: 'false'
ALLOW_REPORTS: 'false'
ADMIN_USER: navjot
ADMIN_PASSWORD: yourpassword
postgres:
container_name: postgres
image: postgres:14-alpine
ports:
- 5432:5432
volumes:
- ./pg_data:/var/lib/postgresql/data/pg_data
environment:
POSTGRES_PASSWORD: password123
POSTGRES_DB: statping
POSTGRES_USER: root
POSTGRES_PORT: 5432
PGDATA: /var/lib/postgresql/data/pg_data
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Nous configurons les images Docker Statping et Postgres. La plupart du fichier docker est facile à suivre. Nous utilisons des sauvegardes sur disque local pour stocker les données de l’application et la base de données Postgres. Nous avons également configuré plusieurs variables d’environnement pour configurer l’application et la base de données. Jetons un coup d’œil à celles-ci. Pour obtenir une liste complète des variables d’environnement que vous pouvez définir, consultez la liste officielle du dépôt GitHub de Statping.
- La variable USE_ASSETS permet à l’application d’utiliser les actifs du dossier
assets. - La variable SAMPLE_DATA est définie sur false pour désactiver les moniteurs par défaut que Statping configure lors de l’installation.
- La variable ALLOW_REPORTS est définie sur false pour désactiver les rapports d’erreur anonymes que Statping envoie.
- Les variables ADMIN_USER et ADMIN_PASSWORD sont utilisées pour définir les informations de connexion pour l’utilisateur par défaut.
- Les variables DB_ sont utilisées pour définir les informations d’identification de la base de données qui doivent correspondre aux variables définies pour le conteneur Postgres.
Étape 6 - Configurer Nginx
Ouvrez le fichier /etc/nginx/nginx.conf pour l’éditer.
$ sudo nano /etc/nginx/nginx.conf
Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Créez et ouvrez le fichier /etc/nginx/conf.d/statusping.conf pour l’éditer.
$ sudo nano /etc/nginx/conf.d/statusping.conf
Collez le code suivant dedans. Remplacez status.example.com par votre nom de domaine.
upstream backend {
server 127.0.0.1:8080;
keepalive 32;
}
server {
listen 80 default_server;
server_name status.example.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name status.example.com;
http2_push_preload on; # Activer le HTTP/2 Server Push
ssl_certificate /etc/letsencrypt/live/status.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/status.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/status.example.com/chain.pem;
ssl_session_timeout 1d;
# Activer les versions TLS (TLSv1.3 est requis pour le prochain HTTP/3 QUIC).
ssl_protocols TLSv1.2 TLSv1.3;
# Activer le 0-RTT de TLSv1.3. Utilisez $ssl_early_data lors du reverse proxy pour
# prévenir les attaques de rejeu.
#
# @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
ssl_early_data on;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-GCM-SHA384';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:50m;
# OCSP Stapling --- récupérez les enregistrements OCSP à partir de l'URL dans ssl_certificate et mettez-les en cache
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
add_header X-Early-Data $tls1_3_early_data;
access_log /var/log/nginx/statusping.access.log main;
error_log /var/log/nginx/statusping.error.log;
location / {
client_max_body_size 50M;
proxy_set_header Connection "";
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Frame-Options SAMEORIGIN;
proxy_set_header X-Client-Verify SUCCESS;
proxy_set_header X-Client-DN $ssl_client_s_dn;
proxy_set_header X-SSL-Subject $ssl_client_s_dn;
proxy_set_header X-SSL-Issuer $ssl_client_i_dn;
proxy_buffers 256 16k;
proxy_buffer_size 16k;
proxy_read_timeout 1800s;
proxy_connect_timeout 1800s;
proxy_http_version 1.1;
proxy_pass http://backend;
}
}
# Ce bloc est utile pour déboguer TLS v1.3. N'hésitez pas à le supprimer
# et à utiliser la variable `$ssl_early_data` exposée par NGINX directement si vous
# souhaitez le faire.
map $ssl_early_data $tls1_3_early_data {
"~." $ssl_early_data;
default "";
}
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Vérifiez votre configuration Nginx.
$ sudo nginx -t
Redémarrez le serveur Nginx.
$ sudo systemctl restart nginx
Étape 7 - Exécuter Statping
Accédez au répertoire Statping.
$ cd ~/statping
Créez et lancez le conteneur Docker.
$ docker compose up -d
Vérifiez l’état du conteneur.
$ docker compose ps
Vous verrez la sortie suivante.
NAME COMMAND SERVICE STATUS PORTS
postgres "docker-entrypoint.s…" postgres running 0.0.0.0:5432->5432/tcp
statping "/bin/sh -c 'statpin…" statping running (healthy) 0.0.0.0:8080->8080/tcp
Vous pouvez également utiliser la commande docker ps pour obtenir un état plus détaillé. Pour vérifier les journaux du conteneur, utilisez la commande docker logs .
Étape 8 - Configurer Statping
Maintenant que votre conteneur fonctionne, lancez l’URL https://status.example.com dans votre navigateur et vous verrez une page de statut vide. Si vous omettez la variable SAMPLE_DATA dans le fichier docker compose, vous verrez une page complète avec différents services prédéfinis.
Cliquez sur le lien Dashboard en bas pour accéder à l’écran de connexion.
Remplissez admin comme nom d’utilisateur et mot de passe par défaut. Assurez-vous de taper le nom d’utilisateur même s’il semble pré-rempli. Cliquez sur le bouton Sign in pour accéder au tableau de bord Statping.
Pour ajouter un nouveau service, cliquez sur le bouton Create et remplissez les valeurs requises.
Cliquez sur le bouton Create service en bas pour terminer. Pour configurer les e-mails et autres notifications, visitez la page des paramètres. Vous pouvez également donner un nouveau nom à votre page de statistiques.
Étape 9 - Mettre à jour Statping
Mettre à jour Statping est une étape simple. Accédez au répertoire Docker compose de Statping.
$ cd ~/statping
Ensuite, arrêtez et supprimez le conteneur existant. Vos données seront conservées.
$ docker compose down --remove-orphans
Tirez la dernière version de l’image Docker Statping.
$ docker compose pull
Démarrez à nouveau les conteneurs.
$ docker compose up -d
Votre installation de Statping est mise à jour et redémarrée.
Conclusion
Cela conclut le tutoriel où vous avez appris comment installer Statping sur un serveur Ubuntu 22.04. Si vous avez des questions, postez-les dans les commentaires ci-dessous.
Recevez de nouveaux articles dans votre boîte de réception.
Aucun spam. Désabonnez-vous à tout moment.