Linux on slash-root.fr

Libérez votre swap !

Sun, 01 Dec 2024 06:09:15 +0100

Préambule

Envie de libérer Britney ? Ou plutôt... votre swap ? 🎵

Si vous cherchez à optimiser l'utilisation de votre mémoire virtuelle sur une machine Debian, vous êtes au bon endroit !

Le `swappiness`, c’est quoi ?

Le swappiness est un paramètre du kernel Linux qui contrôle la "proportion" du système à utiliser le swap. Une valeur faible favorise l'utilisation de la RAM, tandis qu'une valeur élevée incite à swapper rapidement sur le disque.

Quelques commandes essentielles

1. Vérifier la valeur actuelle du `swappiness`

cat /proc/sys/vm/swappiness

2. Modifier dynamiquement le `swappiness`

sudo sysctl vm.swappiness=20

⚠️ Cette modification n'est pas persistante et sera perdue au redémarrage.

3. Rendre la configuration persistante

Ajoutez ou modifiez la ligne suivante dans /etc/sysctl.conf :

vm.swappiness=20

Appliquez ensuite la configuration :

sudo sysctl -p

4. Comprendre les valeurs du `swappiness`

100 : Le système swap intensément.
0 : Swap uniquement en cas de RAM complètement saturée.
Défaut : Généralement 60 sur Debian.

5. Désactiver et réactiver le swap

sudo swapoff -a && sudo swapon -a

⚠️ Assurez-vous que la RAM disponible est suffisante pour accueillir les données du swap avant de désactiver ce dernier.

6. Identifier les processus utilisant le swap

Pour examiner les processus gourmands en swap, utilisez cette commande :

for file in /proc/*/status ; do \
 awk '/VmSwap|Name/{printf $2 " " $3}END{ print ""}' $file; \
 done | \
sort -k 2 -n -r | less

Automatisation avec un script Bash

Pour simplifier la gestion du swap, voici un script bash prêt à l'emploi :

Script : `free-swap.sh`

#!/bin/bash

check_command() {
 if [[ $? -ne 0 ]]; then
 echo "Erreur lors de l'exécution de la commande: $1"
 exit 1
 fi
}

free_data=$(free)
check_command "free"
mem_data=$(echo "$free_data" | grep 'Mem:')
free_mem=$(echo "$mem_data" | awk '{print $4}')
buffers=$(echo "$mem_data" | awk '{print $6}')
cache=$(echo "$mem_data" | awk '{print $7}')
total_free=$((free_mem + buffers + cache))

if echo "$free_data" | grep -q 'Échange:'; then
 used_swap=$(echo "$free_data" | grep 'Échange:' | awk '{print $3}')
else
 used_swap=$(echo "$free_data" | grep 'Swap:' | awk '{print $3}')
fi

echo -e "Free memory:\t$total_free kB ($((total_free / 1024)) MB)\nUsed swap:\t$used_swap kB ($((used_swap / 1024)) MB)"

if [[ $used_swap -eq 0 ]]; then
 echo "Félicitations ! Aucun swap n'est utilisé."
elif [[ $used_swap -lt $total_free ]]; then
 echo "Libération du swap..."
 sudo swapoff -a
 check_command "swapoff"
 sudo swapon -a
 check_command "swapon"
else
 echo "Pas assez de mémoire libre pour libérer le swap. Arrêt."
 exit 1
fi

Instructions :

Enregistrez le script dans un fichier, par exemple : free-swap.sh.
Rendez-le exécutable :

chmod u+x free-swap.sh

Exécutez-le :

./free-swap.sh

⚠️ Ne pas utiliser ce script si ZRAM est activé sur votre système, car cela pourrait entraîner des comportements inattendus.

Conclusion

Vous venez de découvrir comment optimiser la gestion du swap sous Debian. Que ce soit via des commandes ou un script Bash, vous êtes désormais armé pour reprendre le contrôle de votre mémoire virtuelle.

Et surtout, souvenez-vous : le swap, c'est bien... mais la RAM, c'est mieux ! 😉

OneDrive : Client Linux OpenSource

Fri, 14 Jan 2022 14:56:22 +0100

Contexte

Dans le cadre de mon travail, j'ai récement migré sur Pop!_OS pour mon environnement du quotidien. Etant un utilisateur de plusieurs comptes OneDrive (perso & pro), il me fallait pouvoir synchroniser ceux-ci dans des dossiers différents de mon système.

Par exemple :

Mon compte OneDrive perso dans ~/OneDrive_Perso
Mon compte OneDrive pro dans ~/OneDrive_Pro

Bien evidément, cela doit fonctionner en tant que service.

Je suis tombé sur ce projet : https://github.com/skilion/onedrive

Update 07/12/2023 :
Le projet utilisé dans cet article est stoppé.
Utiliser / Adapter avec celui-ci : https://github.com/abraunegg/onedrive.git

C'est un outil sous licence GPL3 permettant d'intéragir avec OneDrive sous Linux.

Les fonctionnalités sont les suivantes :

State caching
Real-Time file monitoring with Inotify
Resumable uploads
Support OneDrive for Business (part of Office 365)
Shared folders (only OneDrive Personal)

J'ajouterai également qu'il est possible de faire du multi-comptes.

C'est parfait car c'est mon besoin 🙂

Installation

Pour information, j'ai réalisé cette installation sous Pop!_OS 21.10 mais celle-ci devrait fonctionner à partir des dérivés d'Ubuntu 18+. Pour Fedora, CentOS, ArchLinux, se référer directement à la page du projet cité plus haut.

Tout d'abord l'installation des pré-requis :

sudo apt install git libcurl4-openssl-dev libsqlite3-dev snap snapd
sudo snap install --classic dmd

Puis le clonage du projet et l'installation de l'outil :

git clone https://github.com/skilion/onedrive.git
cd onedrive
make
sudo make install

Configuration

La configuration est optionnelle. Par défaut, tous les fichiers seront stockés dans ~/OneDrive et les fichiers/dossiers commençant par . et ~ seront ignorés.

3 directives sont définissables :

sync_dir : Le répertoire où seront stockés les données.
skip_file : Les fichiers / dossiers à ne pas synchroniser. L'utilisation des wildcards * et ? sont autorisés. Le | peut être employé pour séparer différents patterns.

L'outil doit être relancé avec l'argument --resync après une modification de la directive skip_file.
sync_list : Spécifier les fichiers / dossiers à synchroniser. J'en parlerai dans un prochain article.

L'outil doit être relancé avec l'argument --resync après une modification de la directive skip_file.

Comme je veux utiliser 2 configurations différentes (une perso et une pro), j'ai créé 1 répertoire pour chaque compte où seront stockés mes données respectives :

mkdir -p ~/{OneDrive_Perso,OneDrive_Pro}

Ensuite, j'ai créé 2 dossiers de configuration (un dossier par compte) :

mkdir -p ~/.config/{onedrive_perso,onedrive_pro}

J'ai ensuite créé mes 2 fichiers de configurations (un fichier par compte).

OneDrive perso :

cat > ~/.config/onedrive_perso/config << EOF
# Directory where the files will be synced
sync_dir = "~/OneDrive_Perso"
# Skip files and directories that match this pattern
skip_file = ".*|~*"
EOF

OneDrive pro :

cat > ~/.config/onedrive_pro/config << EOF
# Directory where the files will be synced
sync_dir = "~/OneDrive_Pro"
# Skip files and directories that match this pattern
skip_file = ".*|~*"
EOF

Initialisation

L'étape suivante que j'ai réalisé a été de lier chaque configuration (perso et pro) à un compte OneDrive. Pour se faire j'ai exécuté dans un 1er temps la synchronisation de mon OneDrive perso :

onedrive --monitor --confdir="~/.config/onedrive_perso"

Un lien est généré :

Authorize this app visiting:

https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id=22c49a0d-d21c-4792-aed1-8f163c982546&scope=files.readwrite%20files.readwrite.all%20offline_access&response_type=code&redirect_uri=https://login.microsoftonline.com/common/oauth2/nativeclient

Enter the response uri:

En visitant cette URL, une authentification sur le compte OneDrive désiré est demandé. Puis, viens une page blanche (ou noire suivant votre thème) :

J'ai copié l'URI de cette page en réponse à mon prompt Enter the response uri:

La synchro démarre (oui, j'aime bien watch dogs legion...) :

Ensuite, je teste mon compte OneDrive_Pro :

onedrive --monitor --confdir="~/.config/onedrive_pro"

Il est important de libèrer le token office avant. J'étais, au préalablement, identifié sur mon compte perso.

Pour cela, je me suis déconnecté avec mon navigateur internet de mon compte office perso précédement connecté à l'aide de l'URL suivante : https://www.office.com/?auth=2

5. Services

Lors de l'installation de l'outil un service a été créé : /usr/lib/systemd/user/onedrive.service.

J'ai décidé de garder ce service pour mon compte perso et d'en créer un second pour mon compte pro :

cp /usr/lib/systemd/user/onedrive.service /usr/lib/systemd/user/onedrive_pro.service

J'ai ensuite édité mon 1er service (onedrive perso) pour correspondre à sa configuration :

vi /usr/lib/systemd/user/onedrive.service

Puis, j'ai modifié la ligne ExecStart :

ExecStart=/usr/local/bin/onedrive --monitor --confdir="~/.config/onedrive_perso"

Et enfin la même modification pour mon serive OneDrive pro :

vi /usr/lib/systemd/user/onedrive_pro.service

Cette fois-ci, j'ai modifié comme suit :

ExecStart=/usr/local/bin/onedrive --monitor --confdir="~/.config/onedrive_pro"

Pour terminer, j'ai activé mes 2 services :

systemctl --user enable onedrive.service
systemctl --user enable onedrive_pro.service
systemctl --user start onedrive.service
systemctl --user start onedrive_pro.service

6. Vérifications / Logs

Pour vérifier le bon fonctionnement des services, j'utilise ces 2 commandes :

journalctl --user-unit onedrive -f
journalctl --user-unit onedrive_pro -f

7. Désinstallation

sudo make uninstall
rm -rf ~/.config/onedrive*

Supervision et autodiscover: Open Centreon Discovery

Tue, 14 Dec 2021 11:03:02 +0100

Présentation

Open Centreon Discover est un module indépendant qui permet l'autodiscover des équipements SNMP, de les ajouter à la plateforme Centreon à l'aide de CLAPI.

OCD permet également un scan des réseaux en tâche de fond, et cerise sur la gateau, il est possible d'affecter automatiquement les templates en fonction de l'OS détecté.

Source: L'atelier de Kermith et Github du créateur

Installation

Téléchargement du module

Créer un dossier:

mkdir /usr/share/discovery

Récupérer le dépôt:

git clone https://github.com/romnvll/Open-Centreon-Discovery.git

Configuration d’Apache

Pour qu'Apache reconnaisse OCD, il faut créer le fichier de configuration:

vim /etc/httpd/conf.d/discovery.conf

Copiez ces lignes dans le fichier:

###########################################
Alias /discovery /usr/share/discovery/
<LocationMatch ^/discovery/(.*\.php(/.*)?)$>
 ProxyPassMatch fcgi://127.0.0.1:9042/usr/share/discovery/$1
</LocationMatch>
ProxyTimeout 300
<Directory "/usr/share/discovery">
 DirectoryIndex index.php
 Options Indexes
 AllowOverride all
 Order allow,deny
 Allow from all
 Require all granted
 <IfModule mod_php5.c>
 php_admin_value engine Off
 </IfModule>
 AddType text/plain hbs

</Directory>

RedirectMatch ^/$ /discovery
###########################################

En fonction de votre configuration vous devrez modifier le port d'écoute de php-fpm (904x). Pour savoir quel port est utilisé: netstat -paunt | grep php

Redémarrez Apache:

systemctl restart httpd

Installation des fichiers

Déplacez vous dans le dossier téléchargé au préalable et copiez les fichiers dans son répertoire dédié:

cd Open-Centreon-Discovery
cp -r * /usr/share/discovery

Pour que le scan en tâche de fond puisse être réalisé, Apache nécessite les permissions sur ce dossier:

chown -R apache: /usr/share/discovery

Modifiez le fichier de configuration d'OCD. Un fichier d'exemple de configuration existe déjà, je vous suggère de l'utiliser (vous pouvez utiliser le fichier d'exemple déjà présent mais il faudra le renommer):

mv /usr/share/discovery/config{php.example,php}

vim /usr/share/config.php

Placez y le login/password d'un utilisateur ayant les droits de modification avec CLAPI, ainsi que le chemin de CLAPI (admin dispose des droits, mais vous pouvez créer un utilisateur de service dédié à cela) :

//Vos identifiants centreon
$config['centreon']['user'] = 'user';
$config['centreon']['password'] = 'password';

//chemin de clapi
$config['centreon']['clapi'] = '/usr/share/centreon/bin/centreon';

Scanner manuellement le réseau

Connexion à l’interface du module

Connectez vous à l'interface web d'OCD avec l'url http://ip-centreon-central/discovery avec l'utilisateur que vous avez déclaré dans le fichier config.php

Vous arriverez alors sur la page suivante:

Si à ce moment vous tombez sur une page blanche, il se peut que vous identifiants soient incorrects.

La découverte SNMP avec ce module ne prend en charge que la v1 et la v2c.

Nous reviendrons plus tard sur le message concernant le scan en tâche de fond.

Configuration du réseau à scanner

Pour lancer votre premier scan afin de trouver des hôtes qui ne seraient pas intégrés à votre plateforme Centreon, vous devez entrer manuellement les informations nécessaires au scan: le réseau, la communauté snmp, la version et le timeout.

Une fois ces paramètres rentrés, cliquez sur le bouton Scan.

Le réseau

Il s'agit du sous-réseau en notation CIDR sur lequel vous voulez détecter des hôtes.

La communauté

Il n'est pas forcément nécessaire de configurer le fichier de configuration snmpd.conf si vous utilisez la communauté public avec ses paramètres par défaut, mais dans le cas où vous souhaiteriez utiliser une communauté personnalisé avec vos propres vues et ouvertures de MIB, petit rappel :

Déplacez le fichier de conf par défaut et créez le votre:

mv /etc/snmp/snmpd.{conf,conf.default}

Il est toujours utile de garder de côté ce fichier par défaut.

vim /etc/snmp/snmpd.conf

agentAddress udp:161
# sec.name source community
com2sec masecu ip.srv.centreon macommu

# groupname securityModel securityName
group groupdesecu v1 masecu
group groupdesecu v2c masecu

# name incl/excl subtree mask(optional)
view mavue included .1.3.6.1.2.1.1
view mavue included .1.3.6.1.2.1.25.1.1

# group context sec.model sec.level prefix read write notif
access groupedesecu "" any noauth exact mavue none none

Redémarrez snmpd:

systemctl restart snmpd

La version

Il s'agit tout simplement de la version utilisée pour

Le timeout

Si le scan est trop long vous pouvez redescendre ce timeout à des valeurs inférieures. Attention toutefois, un timeout trop court peut empêcher la découverte de certains équipements.

Le résultat du scan

Après avoir cliqué sur Scan, au bout de quelques secondes vous arriverez sur cette page:

Cette liste affiche les hôtes découvrables (voir config snmp) et qui ne sont pas encore intégrés à Centreon.

Vous pouvez cliquer sur le bouton Magie et celui-ci affectera automatiquement le template d'hôte associé à l'os détecté.

Il sera également possible de rajouter manuellement deux autres templates supplémentaires.

Veillez également à sélectionner le bon poller, cochez le ou les équipement(s) à exporter puis cliquez sur Valider.

Deux choix s'offrent alors à vous:

Soit la configuration actuelle vous suffit, et vous pouvez cliquer sur Appliquer et redémarrer le moteur ce qui revient à faire l'export de la nouvelle configuration dans l'interface Centreon;
Soit vous cliquez sur Appliquer dans centreon ce qui vous permet d'intégrer ces hôtes dans Centreon, sans pour autant appliquer de suite la nouvelle configuration. Libre à vous ensuite d'affiner selon vos besoins la configuration de vos hôtes dans l'interface web Centreon.

Par acquis de conscience vérifiez l'intégralité des hôtes et services déployés.

Background autodiscover

Le scan manuel reste un outil pratique pour des besoins ponctuels ou une petite structure, mais lorsque vos besoins couvrent un large panel d'équipements, réseaux et communautés différentes, Open Centreon Discovery embarque un autre outil qui va vous simplifier la vie et vous faire gagner du temps: la découverte SNMP en tâche de fond.

Ajout de réseaux à scanner

Il faut au préalable venir écrire les réseaux à scanner dans le fichier de configuration d'OCD:

vim /usr/share/discovery/config.php

La variable $config['backGroundScanUse'] est activé par défaut. C'est elle qui défini l'activation ou l'arrêt du processus.

La variable $config['backGroundRoot'] permet de déclarer le chemin où viendra s'enregistrer le fichier de résultat du scan ( resultScan ).

Attention: si vous modifiez ce chemin, veillez à bien donner les droits nécessaires au fonctionnement du backgroundScan:

L'application de tâche de fond doit avoir les droits en lecture/écriture.

L'application web nécessite les droits en lecture.

//pour le scan BackGround

//activation du scan backGround pour les /16 et plus : true or false
$config['backGroundScanUse'] = true ;
//chemin de l'executable scanBackGround

$config['backGroundRoot'] = '/usr/share/discovery';

$config['backGroundScan'][0] = array("network" => "192.168.1.0/24",
 "community"=>"public",
 "version"=>"2" );

$config['backGroundScan'][1] = array("network" => "192.168.4.0/24",
 "community"=>"macommuperso",
 "version"=>"2" );

Planifier la tâche

Après avoir configuré vos réseaux, il est temps de planifier vos scans.

Tout d'abord, tester la commande qui exécute le scan:

cd /usr/share/discovery && /usr/bin/php -q backGroundScan.php

Le cd ici est indispensable. Le code php étant rédigé avec des chemins relatifs il est nécessaire de se placer dans le dossier discovery.

ATTENTION: après avoir testé manuellement la commande il se peut que les droits du fichier resulScan soit attribué à l'utilisateur qui a lancé la commande. Il est indispensable de rendre apache propriétaire du fichier!!!
chown apache: resulScan

Au bout de quelques secondes vous devriez voir apparaitre vos hôtes sur l'interface web d'OCD

Cliquez ensuite sur Go.

Vous arriverez alors sur la même page que le scan manuel où vos hôtes seront listés, avec le bouton magie pour associer vos templates.

Merci à romnvll, qui a créé ce module et qui m'a aidé à sa mise en place, et merci à Kermith pour ses tutos très éclairés qui m'ont inspiré.

Supervision: tour d’horizon avec CentCTL pour Centreon Open Source.

Fri, 26 Nov 2021 14:51:09 +0100

Historique

CentCTL est un exécutable indépendant créé en 2020 par Mélissa Bertin au sein de la société YPSI. Tout comme CLAPI, il utilise l'API pour réaliser la majeure partie des tâches sur Centreon en ligne de commande. CLAPI nécessite d'être exécuté localement sur le serveur Centreon Central. Vous aurez donc besoin d'une connexion SSH pour pouvoir l'administrer depuis votre poste de travail. De plus, les commandes nécessitent systématiquement une authentification avec mot de passe en clair, et a parfois une syntaxe de commande peu intuitive.

CentCTL utilise l'API REST v1 pour opérer les différentes tâches d'administration. En ayant seulement accès à l'API, on peut administrer notre solution de supervision sans connexion SSH. Aucunement besoin d'interface web, seul un utilisateur avec les droits d'accès à l'API est nécessaire. Le module est développé en langage Go, ce qui le rend multiplateforme et plaira donc à la fois à nos amis pingouins comme aux croqueurs de pommes et aux afficionados des solutions Microsoft.

Centreon & CentCTL: l’importance de la convention de nommage.

Il est très important d'adopter une convention de nommage précise et de s'y tenir!!! Il est très facile de filtrer les éléments dont vous avez besoin grâce à des regex dans CentCTL. Mais pour cela, il faut adopter une convention assez précise.

Ci-dessous je détaille une proposition de convention de nommage.

Les commandes

ChC = Check Command
NoC = Notification Command
DiC = Discovery Command
MiC = Miscellaneous Command
CoC = Connectors Command

Puis ajoutez le nom de la commande. Prenez soit l'objet utilisé par le plugin Centreon, Nagios ou autre pour les commandes de check (par exemple check_ping), soit un descriptif très succinct comme nous pouvons l'avoir de base dans les commandes de notification déjà intégrées à Centreon (host-notify-by-email).

Le résultat donnera quelque chose comme:

ChC_CHECK_PING
NoC_HOST_EMAIL

Si votre commande est spécifiquement adapté à un seul type d'OS, alors il faudra le préciser avant le nom:

ChC_OS_ORACLE8_DISK_SPACE_VAR
ChC_OS_WINSRV16_DISK_SPACE_D

Ect... Libre à vous d'imaginer le plus parlant.

Les templates

Les templates de configuration

Une bonne pratique est de créer, pour les services et pour les hôtes, des templates de configuration (pour configurer d'autres templates).

Exemple: template de configuration de notifications.

Lors de la création d'un modèle d'hôte ou de service, liez directement le Template de configuration de notifications, et vous n'aurez pas à configurer les notifications pour ce template. Ce qui, grâce aux relations avec les modèles d'hôte ou de service fonctionnels, évitera les manipulations trop lourdes et trop contraignantes dans leurs nombres pour venir modifier un paramètre concernant les notifications. Vous changez votre paramètre directement dans le template de configuration de notification et cela s'applique absolument à tout les templates liés, se répercutant donc sur les hôtes et services.

Lors de la création de ce template, ne configurez que les paramètres notifications (ce qui correspond à l'onglet du même nom dans l'interface web).

Par exemple, ces templates se nommeront ainsi:

Nom => STC_NOTIF = Service Template Configuration
Nom => HTC_NOTIF = Host Template Configuration

Vous pouvez mettre la même chose dans l'alias.

Libre à vous de créer les template de configuration de votre choix, par exemple plusieurs templates de configuration pour vos différentes communautés snmp, etc... Adaptez selon vos besoins.

Les templates de service

Ces templates de baseront sur le nom de la commande qu'ils représentent:

Nom => ST_ChC_OS_DEB10_DISK_SPACE_VAR (ST pour Service Template)
- Alias => SFT_ChC_OS_DEB10_DISK_SPACE_VAR (SFT pour Service From Template)

Ici, définir un alias correctement peut vous permettre de différencier sur la page des services par hôtes, les services hérités d'un modèle de service, et ceux créés manuellement sans passer par un template.

Les templates d’hôte

Décrivez succinctement l'OS et la fonction de l'hôte en question:

Nom => HT_OS_WINSRV19_WEB_SRV (HT pour Host Template)
- Alias => HFT_OS_WINSRV19_WEB_SRV (HFT pour Host From Template)

Les hôtes

Le nom de l'hôte supervisé sera basé sur le nom de la société et/ou sa localisation (si vous supervisez plusieurs entreprises ou sites), son os, sa fonction, éventuellement le service auquel il est affecté et un numéro (utile si vous supervisez de très nombreux postes de travail ou une ferme de serveurs)

Nom: Aukfood_Linux_Server_Web_001
- ou encore: CrdAgr_RSY-PlaceVendee_Win10_Direction_001

Pour l'alias, inscrivez simplement son FQDN.

Les services

Si vous créez un service automatiquement lors de la création d'un hôte en relation avec un template d'hote et des templates de service alors celui ci portera le nom de l'alias donné au template de service:

SFT_ChC_CHECK_PING

Si vous créez un service manuellement sans passer par un template:

S_ChC_CHECK_PING

Pourquoi tout ça?

Et bien, lorsque vous allez utiliser des commandes CentCTL par la suite pour créer des listes à utiliser dans un script pour automatiser un déploiement par exemple, vous n'aurez qu'à filtrer avec un peu de regex des ensembles d'éléments, rediriger le flux de sortie dans un fichier, un peu de substitution massive par de la regex (encore) dans vim et le tour est joué. J'y reviendrai plus tard.

Préparer le poste de travail

Le reste de cet article décrit des procédures qui ont été réalisées sous Rocky Linux 8.4.

Téléchargement de CentCTL

Créer un dossier dans lequel récupérer CentCTL puis télécharger la dernière version:

mkdir $HOME/centctl
cd $HOME/centctl
wget https://github.com/YPSI-SAS/centctl/releases/download/v2.5/centctl_linux_amd64 -O centctl

Rendre ce fichier exécutable:

chmod +x centctl

Préparation de la commande

Configurer la variable d'environnement CENTCTL_CONF avec le chemin et le nom du fichier de configuration nommé centctl.yaml. Modifier le .bashrc de l'utilisateur qui utilisera CentCTL avec la ligne suivante en bas du fichier:

export CENTCTL_CONF=/home/USER/centctl/centctl.yaml

USER étant votre nom d'utilisateur, bien entendu !

Configurer l'auto-complétion :

Si le paquet n'est pas installé:

dnf install bash-completion

Puis exécuter les commandes:

source ~/.bashrc
type _init_completion

Si la commande réussi, on peut passer à la suite, sinon:

Dans le .bashrc, écrivez cette ligne de commande en bas du fichier:
```
source /usr/share/bash-compltion/bash_completion
```
Rechargez votre shell avec source .bashrc puis vérifiez que la complétion et correctement installée avec la commande type _init_completion.

Pour terminer, ajouter le script de complétion dans le répertoire /etc/bash_completion.d:

sudo su
/home/USER/centctl/centctl completion bash > /etc/bash_completion.d/centctl

Configuration de CentCTL

Il faut maintenant construire de fichier de configuration centctl.yaml.

vim centctl.yaml

Pour déclarer un serveur, utilisez la configuration ci-dessous en remplaçant les mots en MAJUSCULE.

NAMESERVER c'est le nom du serveur à utiliser avec le flag --server. ATTENTION: le nom du serveur doit être unique.
URL: c'est l'adresse utilisée pour l'accès à l'interface web de Centreon au format: https://monserveurcentreon.fr (ou avec l'IP). ATTENTION: si l'url n'est pas sécurisée, mettre http.
insecure est utilisé quand l'URL du server est en https. Le flag est le même ( --insecure) pour forcer la connexion.
LOGIN est le login avec les droits d'accès RestAPI utilisé pour la connexion au serveur. CONSEIL: utiliser admin qui est automatiquement autorisé pour l'API Rest.
PASSWORD est le mot de passe de l'utilisateur
VERSION est la version du Rest API (v1 ou v2)
default défini le server par défaut auquel se connecter

Exemple de fichier de configuration:

servers:
 - server: "centreon-centos"
 url: "https://centreon21.aukfood.fr"
 insecure: true
 login: "admin"
 password: "Pa55word"
 version: "v1"
 default: true
 - server: "centreon-rocky"
 url: "http://192.168.1.222/centreon"
 login: "admin"
 password: "azerty666"
 version: "v1"

Pour rappel CentCTL utilise la V1 de Rest API.

Tester la configuration

Pour exécuter les commandes ./centctl, se placer dans le répertoire centctl

Un test tout simple qui permet de voir si la configuration est bonne:

./centctl --server=centreon-centos list host

Voici le résultat, au format json par défaut:

{
 "server": {
 "name": "centreon-centos",
 "hosts": [
 {
 "id": "23",
 "name": "Aukfood_Rocky_Client_001",
 "alias": "RockyLinux.aukfood.fr",
 "address": "192.168.1.148",
 "activate": "1"
 }
 ]
 }
}

D'autres formats sont disponibles avec le flag --output en fin de commande:

./centctl --server=centreon-centos list host --output yaml
./centctl --server=centreon-centos list host --output csv
./centctl --server=centreon-centos list host --output text

D'autres options sont disponibles, comme filtrer avec des regex... Rendez-vous sur la page d'aide /.centctl --help

Exporter les configurations

La migration de la configuration de la plateforme Centreon est possible avec CentCTL, même par exemple depuis la 20.10 vers une version supérieure comme la 21.10.

Personnellement je préfère éviter d'exporter toute la configuration d'un coup surtout si celle-ci est importante, j'ai été confronté à certains problèmes lors de test. Je préfère être méticuleux et catégoriser.

La configuration du moteur Centreon

J'utilise le flag -r ^.* pour tout selectionner mais le flag --all marche très bien aussi.

./centctl --server=centreon-centos export engineCFG -r ^.* -f engine.csv

Les ressources du poller

./centctl --server=centreon-centos export resourceCFG -r ^.* -f ressources.csv

Les contacts/utilisateurs

./centctl --server=centreon-centos export contact -r ^.* -f contacts.csv

Les paramètres de notification ne seront pas exportés, attention lors de l'importation à les configurer de nouveau à la main. En effet, l'API REST v1 ne prend pas en charge ces paramètres et la v2 ne supporte pas les contacts.

Les commandes

Exportez les commandes:

./centctl --server=centreon-centos export commands -r ^ChC -f check_commands.csv
./centctl --server=centreon-centos export commands -r ^NoC -f notification_commands.csv
(etc...)

Les Templates

Les templates de notification

Exportez les templates de notifications des services et des hôtes à part du reste des templates:

./centctl --server=centreon-centos export template service -r ^STC -f conf_serv_temp.csv
./centctl --server=centreon-centos export template host -r ^HTC -f conf_host_temp.csv

Les templates d’hôte

./centctl --server=centreon-centos export template host -r ^HT -f host_temp.csv

Les templates de service

./centctl --server=centreon-centos export template service -r ^ST -f serv_temp.csv

Les hôtes

./centctl --server=centreon-centos export host -r ^.* -f hosts.csv

Les services

 ./centctl --server=centreon-centos export service -r ^*$ -f services.csv

Importer vos configurations

Cet ordre d'importation me parait le plus logique en fonction des dépendances/héritages qu'il peut y avoir.

La configuration du moteur
Les ressources du poller
Les templates de configuration
Les commandes
Les utilisateurs
Les templates d'hôtes
Les templates de services
Les hôtes
Les services

Si différents éléments n'ont pas tous les paramètres renseignés car ceux-ci sont hérités de templates, alors de nombreux messages de warning apparaitront, mais ne gêneront pas le processus.

./centctl --server=centreon-rocky import -f engine.csv 
./centctl --server=centreon-rocky import -f ressources.csv 
./centctl --server=centreon-rocky import -f contacts.csv
./centctl --server=centreon-rocky import -f check_commands.csv

(ect... pour les commandes)

./centctl --server=centreon-rocky import -f conf_host_temp.csv
./centctl --server=centreon-rocky import -f conf_serv_temp.csv
./centctl --server=centreon-rocky import -f host_temp.csv
./centctl --server=centreon-rocky import -f serv_temp.csv
./centctl --server=centreon-rocky import -f hosts.csv
./centctl --server=centreon-rocky import -f services.csv

Déployer la configuration

./centctl --server=centreon-rocky import -f engine.csv

Il peut être préférable de vérifier la configuration dans l'interface web plutot que d'appliquer directement lors d'une grosse importation.

CentCTL: de la commande à l’hôte.

Les manipulations qui vont suivre peuvent paraitre longues et fastidieuses comparé à la simplicité d'utilisation de l'interface web Centreon. En effet, pour un besoin ponctuel, il est préférable de passer par l'interface.

Mais ces commandes sont nécessaires dans le cadre de la réalisation d'un script pour automatiser et accélérer la configuration de nombreux éléments.

Créer une commande

./centctl --server=centreon-rocky add command -l "\$USER1$/check_ping -H \$HOSTADDRESS$ -w \$_SERVICEWARNING$ \$_SERVICECRITICAL$ -p \$_SERVICENBPACKETS$ -4" -n ChC_CHECK_PING -t check

Il est impératif de banaliser le premier $ des macros avec un antislash sinon le shell va interpréter comme une variable vide et ça ne va pas correctement s'implanter dans Centreon.

Créer un template de service:

Exemple avec la commande check_ping:

./centctl --server=centreon-rocky add template service -a SFT_ChC_CHECK_PING -n ST_ChC_CHECK_PING -t CST_NOTIF

Configurer les paramètres généraux:

./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p macro --value="WARNING|3,40%|0|seuil d'alerte 1"
./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p macro --value="CRITICAL|5,60%|0|seuil d'alerte 2"
./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p macro --value="NBPACKETS|5|0|nombre de paquets"
./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p check_period -v 24x7
./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p normal_check_interval -v 5
./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p retry_check_interval -v 5
./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p active_checks_enabled -v 1
./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p passive_checks_enabled -v 0
./centctl --server=centreon-rocky modify template service -n ST_ChC_CHECK_PING -p is_volatile -v 0

Configurer les paramètres de notification:

Nous allons utiliser un autre template, dédié à la configuration des notifications

./centctl --server=centreon-rocky modify template service -n STC_NOTIF -p notifications_enabled -v 1
./centctl --server=centreon-rocky modify template service -n STC_NOTIF -p contact -v "admin"
/centctl --server=centreon-rocky modify template service -n STC_NOTIF -p contactgroup -v "Supervisors"
/centctl --server=centreon-rocky modify template service -n STC_NOTIF -p notification_interval -v 10
./centctl --server=centreon-rocky modify template service -n STC_NOTIF -p notification_period -v 24x7
./centctl --server=centreon-rocky modify template service -n STC_NOTIF -p notification_options -v "w,u,c,r,f,s"
./centctl --server=centreon-rocky modify template service -n STC_NOTIF -p recovery_notification_delay -v 0

Pour les temps définis à zero il n'est pas utile de taper la commande

Créer un template d’hôte

./centctl --server=centreon-rocky add template host -a HFT_DEBIAN_WEB_SERVER -n HT_DEBIAN_WEB_SERVER -t HTC_NOTIF

./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p snmp_community -v public
./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p snmp_version -v 2c
./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p timezone -v Europe/Paris
./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p check_command -v ChC_HOSTALIVE
./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p max_check_attempts -v 5
./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p check_interval -v 1
./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p retry_check_interval -v 1
./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p active_checks_enabled -v 1
./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p passive_checks_enabled -v 0

Ici la commande ChC_HOSTALIVE liée au template ne comporte pas de macros perso ni d'arguments. Dans le cas où vous auriez des macros à configurer, les valeurs de celles-ci se déclarent de la même manière que pour les macros des templates de service.

Les commandes pour les paramètres de notifications sont les mêmes que pour les templates de service.

Pour lier des templates de service:

./centctl --server=centreon-rocky modify template host -n HT_DEBIAN_WEB_SERVER -p linkedservice -v ST_ChC_CHECK_PING

Répéter la commande autant de fois qu'il y a de templates de service à lier.

Créer un hôte

./centctl --server=centreon-rocky add host -i 192.168.1.148 -a websrv01.aukfood.fr -n Aukfood_Debian_Web_Server_001 -p Central -t HT_DEBIAN_WEB_SERVER

Par défaut, l'ajout de l'hôte par CentCTL créé automatiquement les services liés aux templates.

Pour définir d'autres paramètres (soit non définis dans un template d'hôte ou volonté de le changer, soit pour configurer l'hôte manuellement sans relation avec un template), se référer aux commandes listées plus haut.

./centctl --server=centreon-rocky modify host -n Aukfood_Debian_Web_Server_001 -p .....

Créer un service

./centctl --server=centreon-rocky add service -n Aukfood_Debian_Web_Server_001 -t ST_ChC_CHECK_PING -d SFT_ChC_CHECK_PING

-n nom de l'hôte, -t template de service, -d description (nom du service/alias du template de service)

Pour aller plus loin

De nombreux autres paramètres n'ont pas été abordés! Pour en découvrir d'autres, c'est par ici !!!

Exemple pratique: automatiser le déploiement d’un nouveau service sur tout un parc

Afin d'éviter de devoir faire une myriade de clics pour déployer un nouveau service sur des centaines de machines, nous pouvons à l'aide d'un petit script très basique déployer en un temps record la nouvelle sonde.

Contexte

Nous avons correctement créé nos hôtes, hérités d'un Template d'hôte, qui est en relation avec un ou plusieurs Template de service qui contiennent une commande.

Extraire une liste d’hôtes

./centctl --server=centreon-rocky list host -r ^.* --output csv > hosts.csv

vim hosts.csv

La liste se présente sous ce format:

ID,Name,Alias,Address,Activate
5,Aukfood_Debian_Web_Server_001,websrv01.aukfood.fr,192.168.1.148,1
6,Aukfood_Debian_Web_Server_002,websrv02.aukfood.fr,192.168.1.149,1
7,Aukfood_Win19srv_Dns_Server_001,dnssrv01.aukfood.fr,192.168.1.253,1

Quelques petites manips avec vim:

Ôter la premiere ligne en plaçant le curseur en début de ligne et appuyez 2 fois rapidement sur d
Entrez ces commandes:
```
:g/^\d*,/s///
:g/,.*$/s///
```
> Selon les préférences, la commande sed ira très bien aussi!

Après manipulation nous obtennons une liste ne contenant que les noms d'hôtes.

Aukfood_Debian_Web_Server_001
Aukfood_Debian_Web_Server_002
Aukfood_Win19srv_Dns_Server_001

Créer le script

vim autodeploy.sh

#!/bin/bash

#Déclare la liste d'hôte
listhost="$(<hosts.csv)"

#Boucle sur tout les hôtes
for host in $listhost; do
./centctl --server=centreon-rocky add service -n $host -t ST_ChC_CHECK_PING -d SFT_ChC_CHECK_PING
done

#Exporte la configuration sur le poller selectionné et le recharge
./centctl --server=centreon-rocky apply -n Central

echo "Wouah, c'était long! Tu as bien travaillé, vas te reposer maintenant ;)"

Maintenant, vous pouvez grâce à toutes les commandes CentCTL vues précédemment vous amuser à scripter dans tout les sens...

Sources

L'atelier de Kermith qui est une vraie pépite pleine de bonne choses!
Github de CentCTL dans lequel j'ai trouvé nombreuses réponses.
Mes cours sur la supervision lors de ma formation TSSR à l'ENI de St-Herblain ( coucou Fred 🙂 )

Merci

Merci de m'avoir lu, et soyez indulgent pour mon 1er article dans le monde de l'IT !!! (et du monde libre, une pierre deux coups, tant qu'à faire)

Charles, stagiaire TSSR.

Uptime Kuma : Une alternative à Uptime Robot !

Wed, 24 Nov 2021 09:51:40 +0100

Cet article a été écrit par la société AukFood, n'hésitez pas à les contacter pour la mise en place d'un tel outil.

Vous connaissez certainement UptimeRobot, qui est une solution qui permet de monitorer un ou plusieurs sites web et d'être alerté le plus rapidement possible. C'est un outil de monitoring extrêmement simple, qui surveille une URL donnée. 👀

Cependant ce service est payant, la version gratuite étant limitée à 50 URLs. C'est pour cela que je vais vous présenter à travers cet article, la solution Uptime Kuma, qui offre les mêmes features. C'est évidemment un projet open-source. ✌️

Le projet est assez jeune, mais compte 24 releases à ce jour, et près de 9k d'étoiles sur GitHub. Les fonctionnalités sont les suivantes :

Surveillance des protocoles HTTP(s), TCP, Ping, DNS ;
Notifications via Telegram, Discord, Slack, Rocket.Chat, Pushover, Email, etc... ;
Surveillance des certificats SSL ;
Mais également un thème sombre ! 🌙

La surveillance des services s'effectue sur une intervalle de 20 secondes.

Uptime Kuma s'installe sur un serveur, principalement en conteneur Docker (une version autonome est possible également). Nous allons voir dans cet article l'installation avec Docker. 🐳

Premièrement, créer un volume :

$ docker volume create uptime_kuma_storage

Puis créer le conteneur :

$ docker run -d --restart=always -p 3001:3001 -v uptime-kuma_storage:/app/data --name uptime-kuma louislam/uptime-kuma:1

Comme vous pouvez le constater sur la deuxième commande, Uptime Kuma écoute sur le port 3001.

Allez sur l'interface web (par défaut : http://localhost:3001), vous pouvez configurer une écoute distante, à travers un reverse-proxy par exemple.

Vous voici sur la page d'inscription. L'utiliseateur qui sera créé sera de type administrateur. Après avoir rempli le formulaire, vous vous trouverez sur le tableau de bord par défaut :

Dans le cadre de notre article, nous allons ajouter notre site web en supervision. Pour cela, cliquez sur "Ajouter une nouvelle sonde".

Vous avez différentes options possibles, dans notre cas on restera sur celles de base (URL, protocole, intervalle de vérification...) mais vous pouvez paramétrer par exemple les codes HTTP acceptés (par défaut compris entre 200 et 299, le 404 par exemple sera considéré) comme un downtime.

Quelques secondes plus tard, le résultat est déjà affiché !

Faisons la même chose avec le DNS :

Les notifications sont paramétrables, ce qui fera l'objet d'un article prochainement.

En résumé, Uptime Kuma est un outil très simple d'utilisation, dont l'interface est intuitive, attractive, et accessible à un public non technique.

Il se concentre sur son but principal, à savoir vérifier si un service est UP ou DOWN, ni plus ni moins. On va droit à l'essentiel, et c'est très bien comme cela.

Cet article a été écrit par la société AukFood, n'hésitez pas à les contacter pour la mise en place d'un tel outil.

Linux on slash-root.fr

Libérez votre swap !

Préambule

Le swappiness, c’est quoi ?

Quelques commandes essentielles

1. Vérifier la valeur actuelle du swappiness

2. Modifier dynamiquement le swappiness

3. Rendre la configuration persistante

4. Comprendre les valeurs du swappiness

5. Désactiver et réactiver le swap

6. Identifier les processus utilisant le swap

Automatisation avec un script Bash

Script : free-swap.sh

Instructions :

Conclusion

OneDrive : Client Linux OpenSource

Contexte

Installation

Configuration

Initialisation

5. Services

6. Vérifications / Logs

7. Désinstallation

Supervision et autodiscover: Open Centreon Discovery

Présentation

Installation

Téléchargement du module

Configuration d’Apache

Installation des fichiers

Scanner manuellement le réseau

Connexion à l’interface du module

Configuration du réseau à scanner

Le réseau

La communauté

La version

Le timeout

Le résultat du scan

Background autodiscover

Ajout de réseaux à scanner

Planifier la tâche

Supervision: tour d’horizon avec CentCTL pour Centreon Open Source.

Historique

Centreon & CentCTL: l’importance de la convention de nommage.

Les commandes

Les templates

Les templates de configuration

Les templates de service

Les templates d’hôte

Les hôtes

Les services

Pourquoi tout ça?

Préparer le poste de travail

Téléchargement de CentCTL

Préparation de la commande

Configuration de CentCTL

Tester la configuration

Exporter les configurations

La configuration du moteur Centreon

Les ressources du poller

Les contacts/utilisateurs

Les commandes

Les Templates

Les templates de notification

Les templates d’hôte

Les templates de service

Les hôtes

Les services

Importer vos configurations

Déployer la configuration

CentCTL: de la commande à l’hôte.

Créer une commande

Créer un template de service:

Créer un template d’hôte

Créer un hôte

Créer un service

Pour aller plus loin

Exemple pratique: automatiser le déploiement d’un nouveau service sur tout un parc

Contexte

Extraire une liste d’hôtes

Créer le script

Le `swappiness`, c’est quoi ?

1. Vérifier la valeur actuelle du `swappiness`

2. Modifier dynamiquement le `swappiness`

4. Comprendre les valeurs du `swappiness`

Script : `free-swap.sh`