Comment installer et surveiller les services à l’aide de l’outil de surveillance Netdata sur Rocky Linux 8

Netdata est un système de surveillance open-source pour les systèmes d’exploitation basés sur Linux. Il fournit des performances et une surveillance en temps réel à l’aide de tableaux de bord magnifiques et détaillés. Il propose des centaines d’outils pour surveiller les serveurs, le processeur, l’utilisation de la mémoire, les processus système, l’utilisation du disque, les réseaux IPv4 et IPv6, le pare-feu du système et les applications comme Nginx, MySQL, MongoDB, Redis, ElasticSearch, PostgreSQL, PHP-FPM, etc. Il s’intègre à d’autres outils de surveillance tels que Prometheus, Graphite, Kafka, Grafana, et plus encore.

Dans ce tutoriel, tu apprendras à installer et à surveiller divers services à l’aide de Netdata Tool sur un serveur Rocky Linux 8. Nous utiliserons Netdata pour suivre les métriques d’une pile LEMP et d’un moteur Docker.

Conditions préalables

  • Un serveur exécutant Rocky Linux 8.
  • Un utilisateur non-root avec des privilèges sudo.
  • Un nom de domaine entièrement qualifié (FQDN) comme netdata.example.com pointant vers ton serveur.
  • Un compte Slack et un espace de travail pour recevoir les notifications.
  • Un compte SMTP avec un service de messagerie comme Amazon SES ou Mailgun.
  • Désactive SELinux.

Étape 1 – Configurer le pare-feu

La première étape consiste à configurer le pare-feu. Rocky Linux utilise le pare-feu Firewalld. Vérifie l’état du pare-feu.

$ sudo firewall-cmd --state
running

Le pare-feu fonctionne avec différentes zones, et la zone publique est celle que nous utiliserons par défaut. Fais la liste de tous les services et ports actifs sur le pare-feu.

$ sudo firewall-cmd --permanent --list-services

Il devrait afficher la sortie suivante.

cockpit dhcpv6-client ssh

Autorise les ports HTTP et HTTPS.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

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

$ sudo firewall-cmd --permanent --list-services

Tu devrais voir une sortie similaire.

cockpit dhcpv6-client http https ssh

Recharge le pare-feu pour activer les modifications.

$ sudo firewall-cmd --reload

Étape 2 – Installe NetData

Netdata est livré avec un script d’installation qui peut fonctionner sur n’importe quelle distribution Linux. Exécute la commande suivante pour télécharger et exécuter le script d’installation.

$ bash <(curl -Ss https://my-netdata.io/kickstart.sh)

Il te sera demandé ton mot de passe sudo pour activer les privilèges sudo. Saisis Y pour confirmer l’ajout du référentiel Netdata et son installation sur ton serveur.

Le programme d’installation de Netdata active et démarre automatiquement le service. Vérifie l’état du service.

$ sudo systemctl status netdata
? netdata.service - Real time performance monitoring
   Loaded: loaded (/usr/lib/systemd/system/netdata.service; enabled; vendor preset: disabled)
   Active: active (running) since Mon 2022-04-11 12:09:12 UTC; 13s ago
 Main PID: 19443 (netdata)
    Tasks: 32 (limit: 11412)
   Memory: 52.0M
   CGroup: /system.slice/netdata.service
           ??19443 /usr/sbin/netdata -P /var/run/netdata/netdata.pid -D
           ??19448 /usr/sbin/netdata --special-spawn-server
           ??19937 /usr/libexec/netdata/plugins.d/apps.plugin 1
           ??19944 /usr/libexec/netdata/plugins.d/go.d.plugin 1

Apr 11 12:09:12 netdata systemd[1]: Started Real time performance monitoring.
.......

Si ton service n’est pas démarré ou activé, tu peux le faire à l’aide de la commande suivante.

$ sudo systemctl enable netdata --now

Exécute la commande suivante pour vérifier les ports ouverts et le processus qui les utilise.

$ sudo ss -plnt

Tu devrais obtenir un résultat similaire. Netdata utilise le port 19999 pour son tableau de bord, vu dans la sortie ci-dessous. Netdata utilise le port 8125 pour recevoir les statistiques d’autres applications.

State            Recv-Q           Send-Q                     Local Address:Port                      Peer Address:Port           Process
LISTEN           0                128                            127.0.0.1:8125                           0.0.0.0:*               users:(("netdata",pid=22496,fd=29))
LISTEN           0                128                              0.0.0.0:19999                          0.0.0.0:*               users:(("netdata",pid=22496,fd=6))
......
LISTEN           0                128                                [::1]:8125                              [::]:*               users:(("netdata",pid=22496,fd=28))
LISTEN           0                128                                 [::]:19999                             [::]:*               users:(("netdata",pid=22496,fd=7))

Étape 3 – Installer SSL

Pour installer un certificat SSL à l’aide de Let’s Encrypt, nous devons installer l’outil Certbot.

Tout d’abord, tu dois télécharger et installer le référentiel EPEL.

$ sudo dnf install epel-release

Exécute les commandes suivantes pour installer Certbot.

$ sudo dnf install certbot

Génère le certificat SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d netdata.example.com

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

Génère un certificat de groupe Diffie-Hellman.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048

Crée un répertoire racine web de défi pour le renouvellement automatique de Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Crée une tâche Cron pour renouveler le SSL. Elle s’exécutera tous les jours pour vérifier le certificat et le renouveler si nécessaire. Pour cela, commence par créer le fichier /etc/cron.daily/certbot-renew et ouvre-le pour le modifier.

$ sudo nano /etc/cron.daily/certbot-renew

Colle le code suivant.

#!/bin/sh
certbot renew --cert-name netdata.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Change les autorisations sur le fichier de tâches pour le rendre exécutable.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Étape 4 – Installe et configure Nginx

Nous allons installer la dernière version de Nginx. Crée et ouvre le fichier /etc/yum.repos.d/nginx.repo pour le modifier.

$ sudo nano /etc/yum.repos.d/nginx.repo

Colle les lignes suivantes dans ce fichier.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Installe Nginx et les outils HTTPD.

$ sudo dnf install nginx httpd-tools

Vérifie l’installation.

$ nginx -v
nginx version: nginx/1.20.2

Active et démarre le service Nginx.

$ sudo systemctl enable nginx --now

Crée et ouvre le fichier /etc/nginx/conf.d/netdata.conf pour le modifier.

$ sudo nano /etc/nginx/conf.d/netdata.conf

Colle le code suivant dans ce fichier.

# Define netdata upstream
upstream netdata {
    server 127.0.0.1:19999;
    keepalive 64;
}

# Redirect all non-encrypted to encrypted
server {
    listen 80;
    listen [::]:80;
    server_name netdata.example.com;
    return 301 https://netdata.example.com$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    
    server_name netdata.example.com;

    ssl_certificate     /etc/letsencrypt/live/netdata.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/netdata.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/netdata.example.com/chain.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_prefer_server_ciphers off;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;
    resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
    resolver_timeout 2s;
    
    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;

    access_log /var/log/nginx/netdata.example.com.access.log main;
    error_log  /var/log/nginx/netdata.example.com.error.log;

    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Server $host;
    	proxy_pass http://netdata;
    	proxy_http_version 1.1;
        proxy_pass_request_headers on;
        proxy_set_header Connection "keep-alive";
        proxy_store off;
        auth_basic "NetData Private Area";
	    auth_basic_user_file /etc/nginx/.htpasswd;
    }
}

Une fois terminé, enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Ouvre le fichier /etc/nginx/nginx.conf pour le modifier.

$ sudo nano /etc/nginx/nginx.conf

Ajoute la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Exécute la commande suivante pour générer un fichier de mots de passe afin d’activer l’authentification HTTP.

$ sudo htpasswd -c /etc/nginx/.htpasswd netadmin
New password: 
Re-type new password: 
Adding password for user netadmin

Vérifie la syntaxe du fichier de configuration de Nginx.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Redémarre le service Nginx pour activer la nouvelle configuration.

$ sudo systemctl restart nginx

Étape 5 – Accéder et utiliser Netdata Dashboard

Tu devrais pouvoir accéder à Netdata via l’URL https://netdata.example.com. La première fois que tu y accèdes, tu seras invité à saisir tes détails d’authentification HTTP.

Authentification HTTP de Netdata

Tu obtiendras le tableau de bord suivant.

Tableau de bord Netdata First Time

Coche la case Se souvenir de mon choix et clique sur le bouton Plus tard, reste sur le tableau de bord de l’agent pour rejeter la popup.

Tu peux mettre en pause, arrêter et démarrer la surveillance à tout moment en utilisant le bouton Lecture du tableau de bord.

Bouton Lecture/Pause de Netdata

Tu peux accéder à divers tableaux de bord en cliquant sur les options de la barre latérale droite. Clique sur le bouton UTC et sélectionne le bon fuseau horaire pour le modifier.

Changement de fuseau horaire de Netdata

Étape 6 – Configure NetData

Netdata enregistre sa configuration principale dans le fichier /etc/netdata/netdata.conf. Tu peux consulter ces paramètres en visitant l’URL https://netdata.example.com/netdata.conf dans ton navigateur.

Fichier de configuration Netdata dans le navigateur

Le fichier est divisé en plusieurs sections, telles que [global], [web], [registre], et plus encore. La configuration par défaut est suffisante pour nous permettre de commencer. Netdata collecte les données à l’aide de deux types de plugins :

  1. Les pluginsinternes sont écrits en langage C et s’exécutent sous forme de threads à l’intérieur du démon netdata.
  2. Les pluginsexternes sont écrits dans différents langages, notamment Python, Go, etc. et sont lancés comme des processus indépendants à long terme par le démon netdata. Ils communiquent avec le démon Netdata en utilisant pipes.

Configurer l’utilisation de la mémoire de NetData

L’utilisation de la RAM de NetData est décidée en fonction de la durée pendant laquelle tu veux conserver les données graphiques enregistrées avant qu’elles ne soient perdues.

  • 3600 secondes ou 1 heure de conservation des données graphiques utilisent 15 Mo de RAM.
  • 7200 secondes ou 2 heures de conservation des données graphiques utilisent 30 Mo de RAM.
  • 14400 secondes ou 4 heures de conservation des données graphiques utilisent 60 Mo de RAM.

Chaque fois que tu doubles la durée de conservation des données graphiques, les besoins en RAM doublent également. Ces besoins en RAM sont basés sur le nombre de graphiques utilisés par le tableau de bord des actions. L’ajout d’autres graphiques et applications modifiera ces estimations.

Ouvre le fichier de configuration de Netdata.

$ sudo nano /etc/netdata/netdata.conf

Saisis la ligne history = 14400 sous la section [global].

[global]
..
        history = 14400
..

Enregistre le fichier en appuyant sur Ctrl + X et en entrant Y lorsque tu y es invité.

Désactiver la télémétrie

Par défaut, Netdata collecte des informations d’utilisation anonymes à l’aide d’une plateforme d’analyse de produits, Posthog. Chaque fois que le démon Netdata est démarré ou arrêté, Netdata utilise le script de statistiques anonymes pour collecter les informations système suivantes et se les envoyer.

  • Version de Netdata
  • Nom du système d’exploitation, version, id, id_like
  • Nom du noyau, version, architecture
  • Technologie de virtualisation
  • Technologie de conteneurisation
  • Informations supplémentaires sur les échecs des clients Netdata.

Heureusement, tu peux choisir de ne pas le faire. Crée un fichier vide appelé .opt-out-from-anonymous-statistics dans le répertoire Netdata.

$ sudo touch /etc/netdata/.opt-out-from-anonymous-statistics

Redémarre Netdata pour activer la modification.

$ sudo systemctl restart netdata

Stockage à long terme

Par défaut, Netdata utilise la RAM et le disque de ton système pour stocker les données historiques. Le processus Netdata par défaut collecte environ 2000 métriques par seconde, ce qui signifie que la configuration par défaut stockera environ deux jours de métriques dans la RAM et sur le disque.

Pour stocker plus de métriques, tu as les deux options suivantes :

  1. Configurer Netdata pour utiliser plus de RAM et d’espace disque.
  2. Archiver les métriques dans une base de données externe

Nous n’aborderons que la première option dans ce tutoriel. Pour la deuxième option, tu dois te référer à la documentation officielle de Netdata.

Configure Netdata pour utiliser plus de RAM et d’espace disque

Ouvre le fichier /etc/netdata/netdata.conf pour le modifier.

$ sudo nano /etc/netdata/netdata.conf

Colle les lignes suivantes sous la section [global].

[global]
...
    memory mode = dbengine
    page cache size = 32
    dbengine disk space = 256

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

La taille du cache de la page détermine la quantité de RAM utilisée, et le site dbengine disk space détermine l’utilisation du disque. Par défaut, Netdata utilise 32 Mo de RAM et 256 Mo d’espace disque. Tu peux décommenter ces valeurs et modifier l’une des deux valeurs à ton goût.

Tu peux utiliser le calculateur de métrique de stockage de Netdata pour décider de la quantité de RAM et d’espace disque dont tu as besoin.

Réduis la fréquence de collecte

Tu peux optimiser les performances de Netdata en augmentant le temps entre les collectes de métriques. Par défaut, Netdata collecte les métriques toutes les secondes.

Pour changer cela, ouvre le fichier de configuration de Netdata pour le modifier.

$ sudo nano /etc/netdata/netdata.conf

Saisis la ligne suivante dans la section [global]. Cela augmente la fréquence à 5 secondes.

[global]
...
    update every = 5

Enregistre le fichier en appuyant sur Ctrl + X et en entrant Y lorsque tu y es invité.

Étape 7 – Configurer les notifications Slack

La première étape consiste à créer une application Slack et à la connecter à un canal spécifique de ton espace de travail pour configurer les notifications Slack.

Visite la page de l’API de Slack et clique sur le bouton Créer une application pour commencer à créer une application.

Applications API de Slack

Clique sur le lien From Scratch pour créer l’application.

Slack Create App Popup

Sélectionne un nom pour ton application et choisis l’espace de travail dans lequel tu veux que ton application apparaisse. Si tu ne veux pas associer ton application à l’espace de travail existant, tu peux en créer un autre et revenir à cette étape.

Popup du nom de l'application Slack

Ouvre la page Webhook entrant en sélectionnant l’option sous le menu Caractéristiques dans la barre latérale gauche, puis active le webhook.

Slack Apps WebHooks entrants

Clique sur le bouton Ajouter un nouveau Webhook à l’espace de travail en bas de la page et sélectionne ton espace de travail et le canal cible pour les notifications.

Ajoute l'application Netdata Slack à WorkSpace

Clique sur le bouton Autoriser pour continuer. Retourne à la page des Webhooks entrants et copie l’URL du Webhook.

URL du Webhook de Slack

Retourne au terminal et passe dans le répertoire /etc/netdata.

$ cd /etc/netdata

Netdata fournit un script edit-config pour modifier et créer des fichiers de configuration Netdata. Exécute le fichier suivant pour créer et ouvrir le fichier health_alarm_notify.conf en utilisant l’éditeur par défaut de ton système.

$ sudo ./edit-config health_alarm_notify.conf

Fais défiler le texte jusqu’à la section suivante.

# Enable slack notification
SEND_SLACK="YES"

# Select the slack webhook
SLACK_WEBHOOK_URL="https://hooks.slack.com/services/xxxxxxx"

# Default channel for notification
DEFAULT_RECIPIENT_SLACK="notifications"

Assure-toi que la variable SEND_SLACK est définie sur oui. Colle l’URL du webhook copié dans la variable SLACK_WEBHOOK_URL. Saisis le nom de ton canal pour la variable DEFAULT_RECIPIENT_SLACK.

Si ton éditeur est Vim, appuie sur la touche Echap pour quitter l’édition, tape 😡 et appuie sur la touche Entrée pour enregistrer le fichier et quitter l’éditeur.

Si ton éditeur est Nano, enregistre le fichier en appuyant sur Ctrl + X et en entrant Y lorsque tu y es invité.

Redémarre Netdata pour appliquer les modifications.

$ sudo systemctl restart netdata

Configurer les notifications par e-mail

Netdata utilise par défaut sendmail pour envoyer des notifications par email mais la gestion d’un serveur d’email n’est pas une tâche facile. Netdata ne prend pas en charge SMTP, mais tu peux installer un paquet appelé msmtp client. Il te permet d’envoyer du courrier à un serveur SMTP.

Installe msmtp.

$ sudo dnf install msmtp

Crée et ouvre le fichier de configuration de msmtp.

$ sudo nano /etc/msmtprc

Colle le code suivant dans ce fichier.

# Set default values for all following accounts.
defaults

# Use the mail submission port 587 instead of the SMTP port 25.
port 587

# Always use TLS.
tls on

# The SMTP server of your ISP
account ses
host email-smtp.<location>.amazonaws.com
from [email protected]
auth on
user <yoursesusername>
password <yoursespassword>

# Set default account to isp
account default: ses

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Ouvre le fichier /etc/netdata/health_alarm_notify.conf pour le modifier.

$ sudo nano /etc/netdata/health_alarm_notify.conf

Descends jusqu’à la section suivante et saisis le chemin d’accès au site msmtp.

# external commands

# The full path to the sendmail command.
# If empty, the system $PATH will be searched for it.
# If not found, email notifications will be disabled (silently).
sendmail="/usr/bin/msmtp"

Trouve la section suivante et entre les détails de l’expéditeur et du destinataire et assure-toi que l’envoi d’emails est activé.

# email global notification options

# multiple recipients can be given like this:
#              "[email protected] [email protected] ..."

# the email address sending email notifications
# the default is the system user netdata runs as (usually: netdata)
# The following formats are supported:
# EMAIL_SENDER="[email protected]"
# EMAIL_SENDER="User Name <[email protected]>"
# EMAIL_SENDER="'User Name' <[email protected]>"
# EMAIL_SENDER="\"User Name\" <[email protected]>"
EMAIL_SENDER="Server Admin <[email protected]>"

# enable/disable sending emails
SEND_EMAIL="YES"

# if a role recipient is not configured, an email will be send to:
DEFAULT_RECIPIENT_EMAIL="[email protected]"
# to receive only critical alarms, set it to "root|critical"

Enregistre le fichier en appuyant sur Ctrl + X et en entrant Y lorsque tu y es invité.

Étape 8 – Tester les canaux de notification

Testons si les notifications Slack fonctionnent.

Connecte-toi en tant qu’utilisateur système netdata créé pendant l’installation.

$ sudo su -s /bin/bash netdata

Exécute le script de notification d’alarme pour envoyer une notification de test.

$ /usr/libexec/netdata/plugins.d/alarm-notify.sh test

Quitte l’utilisateur.

$ exit.

Ouvre ton application Slack et tu devrais avoir reçu les alertes suivantes.

Notifications de test Netdata Slack

Tu devrais également recevoir trois courriels concernant les avertissements de test.

Notifications de test Netdata par courriel

Étape 9 – Configure la surveillance du système

Maintenant que nous avons configuré et testé les notifications, configurons et testons les notifications pour le système, comme l’utilisation du CPU.

Exécute les commandes suivantes pour créer et ouvrir le fichier de configuration du CPU.

$ cd /etc/netdata
$ sudo ./edit-config health.d/cpu.conf

Modifie les valeurs des options warn et crit sous l’option 10min_cpu_usage comme indiqué ci-dessous.

warn: $this > (($status >= $WARNING)  ? (60) : (70))
crit: $this > (($status == $CRITICAL) ? (75) : (85))

Enregistre le fichier et quitte l’éditeur.

Le paramètre ci-dessus enverra un avertissement si l’utilisation du CPU se situe entre 60 et 70 % et un avertissement critique si l’utilisation du CPU se situe entre 75 et 85 %.

Redémarre le service Netdata.

$ sudo systemctl restart netdata

Testons le paramètre en installant l’application Stress.

$ sudo dnf install stress

Exécute la commande suivante pour faire monter en flèche l’utilisation du CPU de ton serveur.

$ stress --cpu 2

Laisse la commande fonctionner pendant 5 à 10 minutes et tu recevras des messages d’utilisation élevée du CPU. Une fois que tu as reçu ces messages, retourne au terminal et quitte la commande en appuyant sur Ctrl + Z.

Après avoir arrêté le service, tu recevras une notification de récupération de CPU sur Slack.

Notifications d'utilisation du CPU de Slack

Étape 10 – Configurer la surveillance de Nginx

L’une des applications les plus couramment surveillées à l’aide de Netdata est le serveur et les paquets SQL. Surveillons le serveur Nginx à l’aide de Netdata.

Pour activer la surveillance du serveur Nginx, nous devons utiliser le module ngx_http_stub_status_module. Il est généralement préinstallé avec Nginx. Tu peux vérifier si le module est présent.

$ nginx -V 2>&1 | grep -o with-http_stub_status_module
with-http_stub_status_module

Si tu n’obtiens aucune réponse, cela signifie que ton installation de Nginx ne prend pas en charge la fonctionnalité. Dans ce cas, tu devras compiler Nginx.

Ouvre le fichier de configuration par défaut de Nginx /etc/nginx/conf.d/default.conf pour le modifier. L’emplacement du fichier est différent car nous avons installé Nginx à partir de son dépôt officiel. Si tu installes Nginx à partir du référentiel du système d’exploitation, l’emplacement du fichier sera /etc/nginx/nginx.conf.

$ sudo nano /etc/nginx/conf.d/default.conf

Saisis le code suivant à l’intérieur du bloc serveur avant la dernière accolade de fermeture.

# Enable module stub_status
location /stub_status {
	stub_status;
    allow 127.0.0.1;        #only allow requests from localhost
    deny all;               #deny all other hosts
}

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Vérifie la configuration de Nginx.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Redémarre le serveur Nginx.

$ sudo systemctl restart nginx

Redémarre le service Netdata.

$ sudo systemctl restart netdata

Tu devrais voir les détails de la connexion Nginx dans ton tableau de bord Netdata.

Détails de la connexion Netdata Nginx

Surveiller les journaux Nginx

Netdata peut aussi surveiller les journaux d’accès Nginx. Pour ce faire, passe dans le répertoire Netdata.

$ cd /etc/netdata

Exécute la commande suivante pour générer un fichier de configuration pour la surveillance des journaux d’accès.

$ sudo ./edit-config python.d/web_log.conf

Fais défiler jusqu’au bas du fichier et trouve la section suivante.

# -------------------------------------------
# nginx log on various distros

# debian, arch
nginx_log:
  name: 'nginx'
  path: '/var/log/nginx/access.log'

# gentoo
nginx_log2:
  name: 'nginx_site'
  path: '/var/log/nginx/localhost.access_log'

Change le chemin pour surveiller les fichiers journaux respectifs. Tu peux ajouter autant de sections pour surveiller autant d’hôtes et leurs fichiers journaux d’accès. Notre fichier de configuration ressemble à ce qui suit.

# -------------------------------------------
# nginx log on various distros

# debian, arch
nginx_log:
  name: 'nginx'
  path: '/var/log/nginx/access.log'

nginx_log2:
  name: 'nginx_site1'
  path: '/var/log/nginx/site1.access_log'

nginx_log3:
  name: 'nginx_site2'
  path: '/var/log/nginx/site2.access_log'

nginx_log4:
  name: 'nginx_site3'
  path: '/var/log/nginx/site3.access_log'

Sauvegarde et quitte l’éditeur.

Pour accéder aux fichiers journaux, Netdata a besoin de permissions pour accéder au répertoire. Par défaut, le groupe système adm a l’autorisation d’accéder aux fichiers journaux. Pour donner l’accès à Netdata, nous devons ajouter l’utilisateur netdata au groupe adm.

$ sudo usermod -aG adm netdata

Redémarre Nginx et le service Netdata.

$ sudo systemctl restart nginx netdata

Recharge le tableau de bord Netdata pour voir les données de ton fichier journal.

Tableau de bord du journal d'accès Netdata

Étape 11 – Configure la surveillance de MySQL/MariaDB

Nous allons installer MariaDB pour notre tutoriel. Les étapes restent les mêmes si tu utilises un serveur MySQL.

Ajoute le référentiel pour MariaDB 10.6.

$ sudo nano /etc/yum.repos.d/MariaDB.repo

Colle le code suivant dans celui-ci.

# MariaDB 10.6 CentOS repository list - created 2022-04-12 11:12 UTC
# https://mariadb.org/download/
[mariadb]
name = MariaDB
baseurl = https://download.nus.edu.sg/mirror/mariadb/yum/10.6/centos8-amd64
module_hotfixes=1
gpgkey=https://download.nus.edu.sg/mirror/mariadb/yum/RPM-GPG-KEY-MariaDB
gpgcheck=1

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Installe MariaDB.

$ sudo dnf install MariaDB-server

Active le serveur MariaDB.

$ sudo systemctl enable mariadb

Lance le script d’installation sécurisée de MySQL. Le nom du fichier est différent dans le cas de MariaDB.

$ sudo mariadb-secure-installation
....
Enter current password for root (enter for none): (Press Enter)
....
Switch to unix_socket authentication [Y/n] Y (Type Y and Press Enter)
....
Change the root password? [Y/n] Y (Type Y and Press Enter)
New password: 
Re-enter new password: 
Password updated successfully!
....
Remove anonymous users? [Y/n] Y (Type Y and Press Enter)
....
Disallow root login remotely? [Y/n] Y (Type Y and Press Enter)
....
Remove test database and access to it? [Y/n] Y (Type Y and Press Enter)
....
Reload privilege tables now? [Y/n] Y (Type Y and Press Enter)
....
All done!  If you've completed all of the above steps, your MariaDB
installation should now be secure.

Thanks for using MariaDB!

Ouvre le fichier /etc/my.cnf.d/server.cnf pour le modifier.

$ sudo nano /etc/my.cnf.d/server.cnf

Trouve la section [mariadb] dans le fichier et colle la ligne suivante comme indiqué ci-dessous pour activer le plugin Userstats. Ce paramètre ne fonctionne que sur MariaDB et pas sur le serveur MySQL.

[mariadb]
userstat = 1

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Démarre le serveur MariaDB.

$ sudo systemctl start mariadb

Redémarre le service Netdata.

$ sudo systemctl restart netdata

Le tableau de bord MariaDB/MySQL devrait commencer à apparaître dans le tableau de bord Netdata.

Tableau de bord NetData MySQL/MariaDB

Étape 12 – Configurer la surveillance de PHP-FPM

Tu peux surveiller une ou plusieurs instances PHP-FPM à l’aide de Netdata. Pour notre tutoriel, nous allons installer PHP 8.0 puis activer sa surveillance.

Nous installerons PHP à l’aide du référentiel Remi. Nous avons déjà installé le dépôt EPEL à l’étape 3. Installe le référentiel Remi.

$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-8.rpm

Vérifie les flux PHP disponibles.

$ dnf module list php -y
Last metadata expiration check: 0:00:12 ago on Fri 03 Dec 2021 09:39:32 AM UTC.
Rocky Linux 8 - AppStream
Name                Stream                 Profiles                                 Summary
php                 7.2 [d]                common [d], devel, minimal               PHP scripting language
php                 7.3                    common [d], devel, minimal               PHP scripting language
php                 7.4                    common [d], devel, minimal               PHP scripting language

Remi's Modular repository for Enterprise Linux 8 - x86_64
Name                Stream                 Profiles                                 Summary
php                 remi-7.2               common [d], devel, minimal               PHP scripting language
php                 remi-7.3               common [d], devel, minimal               PHP scripting language
php                 remi-7.4               common [d], devel, minimal               PHP scripting language
php                 remi-8.0               common [d], devel, minimal               PHP scripting language
php                 remi-8.1               common [d], devel, minimal               PHP scripting language

Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled

La version par défaut est 7.2. Active le référentiel PHP 8.0 de Remi.

$ sudo dnf module reset php -y
$ sudo dnf module enable php:remi-8.0

Ensuite, installe PHP et ses extensions requises par Firefly III. Le paquet php contient plusieurs dépendances dont Firefly III a besoin, alors assure-toi de les inclure.

$ sudo dnf install php php-fpm php-mbstring php-xml php-curl php-mysqlnd php-zip php-intl php-bcmath php-gd php-ldap php-cli

Vérifie l’installation.

$ php --version
PHP 8.0.16 (cli) (built: Feb 15 2022 21:34:32) ( NTS gcc x86_64 )
Copyright (c) The PHP Group
Zend Engine v4.0.16, Copyright (c) Zend Technologies
    with Zend OPcache v8.0.16, Copyright (c), by Zend Technologies

Configure PHP

Ouvre le fichier /etc/php-fpm.d/www.conf.

$ sudo nano /etc/php-fpm.d/www.conf

Nous devons définir l’utilisateur/groupe Unix des processus PHP sur nginx. Trouve les lignes user=www-data et group=www-data dans le fichier et change-les en nginx.

...
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
; RPM: apache user chosen to provide access to the same directories as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
group = nginx
...

Fais défiler le fichier vers le bas pour trouver l’option ;pm.status_path = /status. Décommente la ligne en supprimant le point-virgule qui la précède, comme indiqué ci-dessous.

; Note: There is a real-time FPM status monitoring sample web page available
;       It's available in: @[email protected]/fpm/status.html
;
; Note: The value must start with a leading slash (/). The value can be
;       anything, but it may not be a good idea to use the .php extension or it
;       may conflict with a real PHP file.
; Default Value: not set
pm.status_path = /status

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Active et démarre le service PHP.

$ sudo systemctl enable php-fpm --now

Ajoute les paramètres PHP à Nginx

Ouvre le fichier de configuration par défaut de Nginx /etc/nginx/conf.d/default.conf pour le modifier.

$ sudo nano /etc/nginx/conf.d/default.conf

Saisis le code suivant à l’intérieur du bloc serveur avant la dernière accolade de fermeture.

# define PHP-FPM monitoring
location ~ ^/(status|ping)$ {
    allow 127.0.0.1;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    fastcgi_index index.php;
    include fastcgi_params;
    fastcgi_pass   unix:/run/php-fpm/.sock; # Depends on the PHP Version and OS Distro
}

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Vérifie la configuration de Nginx.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Redémarre le serveur Nginx.

$ sudo systemctl restart nginx

Redémarre le service Netdata.

$ sudo systemctl restart netdata

Recharge le tableau de bord Netdata, et tu devrais voir les statistiques de PHP-FPM.

Tableau de bord des statistiques de NetData PHP-FPM

Étape 13 – Configure le moteur Docker et la surveillance des conteneurs

Netdata peut surveiller à la fois le moteur Docker et les conteneurs Docker. Il peut aussi surveiller les applications qui s’exécutent dans ces conteneurs, mais nous ne le couvrirons pas dans ce tutoriel.

Commençons par installer Docker.

$ sudo dnf install yum-utils
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
$ sudo dnf install docker-ce docker-ce-cli containerd.io

Active et démarre le service Docker.

$ sudo systemctl enable docker --now

Pour surveiller le moteur Docker, tu dois activer la fonction de métrique de Docker.

Crée et ouvre le fichier /etc/docker/daemon.json pour le modifier.

$ sudo nano /etc/docker/daemon.json

Colle le code suivant dans ce fichier.

{
  "metrics-addr" : "127.0.0.1:9323",
  "experimental" : true
}

Enregistre le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque tu y es invité.

Redémarre les services Netdata et Docker.

$ sudo systemctl restart docker netdata

Charge à nouveau le tableau de bord Netdata, et tu peux voir les statistiques de Docker.

Statistiques du conteneur Docker de NetData

Tu verras une autre entrée nommée Prometheus Metrics sur ton tableau de bord parce que l’option métriques a été faite pour le tableau de bord Prometheus.

NetData Container Docker Prometheus Stats

L’étape suivante consiste à surveiller le conteneur Docker. Netdata utilise des groupes de contrôle, appelés cgroups pour surveiller les conteneurs Docker. Les groupes de contrôle sont une fonctionnalité de Linux qui limite et suit l’utilisation des ressources d’une collection de processus, dans ce cas, les conteneurs. Si tu as des conteneurs Docker en cours d’exécution lorsque tu installes Netdata, ils sont automatiquement suivis. Cependant, si tu exécutes un conteneur après avoir installé Netdata, tu dois le redémarrer.

Exécute un conteneur de test.

$ docker container run -d nginx

Vérifie l’état du conteneur.

$ docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
938b2cf30927   nginx     "/docker-entrypoint.…"   3 seconds ago   Up 2 seconds   80/tcp    pensive_lovelace

Le nom du conteneur est tender_murdock comme indiqué. Comme le conteneur a été lancé après l’installation de Netdata, redémarre le service.

$ sudo systemctl restart netdata

Charge le tableau de bord, et tu devrais pouvoir voir les statistiques du conteneur.

Statistiques des conteneurs individuels NetData Docker

Conclusion

Ceci conclut notre tutoriel sur l’installation et l’utilisation du système de surveillance Netdata pour surveiller diverses applications comme Nginx, MySQL, PHP-FPM et Docker sur un serveur Rocky Linux. Si tu as des questions, poste-les dans les commentaires ci-dessous.

Vous aimerez aussi...