DEV Community: Ismael GALEKWA

Gérer les utilisateurs avec les droits sudo en SSH via MobaXterm

Ismael GALEKWA — Sun, 18 May 2025 21:26:41 +0000

Lorsque vous administrez un serveur Linux à distance depuis un PC Windows, MobaXterm est un outil très pratique qui combine terminal, client SSH, SFTP et bien plus encore. Dans cet article, je vous montre comment gérer les utilisateurs avec droits sudo sur un serveur distant en utilisant une connexion SSH via MobaXterm.

Prérequis
Avant de commencer, assurez-vous d’avoir :

Un PC sous Windows avec MobaXterm installé (lien officiel)

L’accès à un serveur Linux via SSH (Ubuntu, Debian, CentOS, etc.)

Les identifiants d’un utilisateur ayant les droits sudo (ou root)

Étape 1 : Connexion SSH via MobaXterm
Lancez MobaXterm.

Cliquez sur Session > SSH.

Renseignez l’adresse IP ou le nom de domaine du serveur distant.

Saisissez le nom d’utilisateur (ex. root ou un utilisateur sudo).

Cliquez sur OK pour ouvrir une session SSH.

Une fois connecté, vous avez un accès en ligne de commande à votre serveur distant.

Étape 2 : Lister les utilisateurs avec droits sudo
Selon la distribution de votre serveur :

Sur Ubuntu/Debian :

getent group sudo
Sur CentOS/RHEL :

getent group wheel
Cette commande affiche tous les utilisateurs membres du groupe sudo (ou wheel).

Étape 3 : Ajouter un utilisateur au groupe sudo
Si vous souhaitez accorder les droits sudo à un utilisateur existant, utilisez la commande suivante :

sudo usermod -aG sudo nom_utilisateur
Remplacez nom_utilisateur par le nom réel de l’utilisateur concerné.

Pour CentOS/RHEL :
sudo usermod -aG wheel nom_utilisateur
Étape 4 : Créer un nouvel utilisateur avec droits sudo
Si vous voulez créer un utilisateur directement avec des droits sudo :

sudo adduser nouvel_utilisateur
sudo passwd nouvel_utilisateur
sudo usermod -aG sudo nouvel_utilisateur
Pour CentOS/RHEL :
sudo usermod -aG wheel nouvel_utilisateur
Étape 5 : Modifier les privilèges sudo via visudo (avancé)
Pour accorder des droits sudo personnalisés à un utilisateur, utilisez la commande :

sudo visudo
Ajoutez une ligne comme celle-ci à la fin du fichier :

nom_utilisateur ALL=(ALL:ALL) ALL
Utilisez toujours visudo pour éviter de casser la configuration du système en cas d’erreur de syntaxe.

Étape 6 : Vérifier que l’utilisateur a bien les droits sudo
Reconnectez-vous avec le nouvel utilisateur (ou ouvrez un nouveau terminal dans MobaXterm), puis tapez :

sudo whoami
Si la commande retourne root, tout fonctionne correctement.

Avec MobaXterm, gérer les utilisateurs sudo sur un serveur Linux à distance devient simple et rapide. En suivant les étapes ci-dessus, vous pouvez créer des utilisateurs, leur accorder ou révoquer les droits sudo, et sécuriser l’accès à vos serveurs. Que vous soyez un développeur, un sysadmin ou un passionné de Linux, maîtriser cette compétence est essentiel.

Automatiser l’envoi d’un message WhatsApp quotidien avec Python et Cron

Ismael GALEKWA — Thu, 15 May 2025 08:13:28 +0000

Objectif
Dans cet article, nous allons créer un petit script Python qui s’exécute automatiquement chaque jour à 6h00 du matin pour envoyer un message WhatsApp automatique à un coach. Le message est simple :

"Bonjour Coach "

Ce projet allie automatisation système (cron) et API de messagerie (WhatsApp via Twilio). Parfait pour un usage personnel, professionnel ou pédagogique.

Prérequis
Avant de commencer, voici ce dont vous avez besoin :

Un compte gratuit Twilio

Python 3 installé sur votre machine

pip pour installer les bibliothèques

Accès au crontab sur un système Linux/macOS

🛠️ Étape 1 : Créer un compte Twilio et activer WhatsApp
Allez sur https://www.twilio.com/ et créez un compte.

Accédez à la console WhatsApp Sandbox ici :
https://www.twilio.com/console/sms/whatsapp/learn

Envoyez le code de vérification (join xxxx) au numéro WhatsApp fourni par Twilio pour activer votre numéro personnel.

Copiez votre Account SID et Auth Token depuis la console.

Étape 2 : Installer les dépendances Python
Dans un terminal, exécutez :

bash
Copier
Modifier
pip install twilio
Étape 3 : Écrire le script Python
Créez un fichier whatsapp_message.py :

python
Copier
Modifier
from twilio.rest import Client

--- Vos identifiants Twilio ---

account_sid = 'ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
auth_token = 'your_auth_token'
from_whatsapp_number = 'whatsapp:+14155238886' # Numéro sandbox Twilio
to_whatsapp_number = 'whatsapp:+243xxxxxxxxx' # Numéro WhatsApp du Coach

---------------------------------

client = Client(account_sid, auth_token)

message = client.messages.create(
body='Bonjour Coach ',
from_=from_whatsapp_number,
to=to_whatsapp_number
)

print(f" Message envoyé ! SID : {message.sid}")
Remplace les valeurs account_sid, auth_token et to_whatsapp_number par les tiennes.

Étape 4 : Automatiser avec Cron (Linux/macOS)
Ouvrir l’éditeur crontab
bash
Copier
Modifier
crontab -e
Ajouter cette ligne pour exécuter le script chaque jour à 6h00 :
bash
Copier
Modifier
0 6 * * * /usr/bin/python3 /chemin/vers/whatsapp_message.py >> /home/ismael/logs/whatsapp.log 2>&1
0 6 * * * = tous les jours à 6h00 du matin

Remplace /usr/bin/python3 par le chemin de ton interpréteur (which python3)

Crée le dossier /home/ismael/logs s’il n’existe pas

Étape 5 : Test manuel du script
Avant de dépendre du cron, teste ton script manuellement :

bash
Copier
Modifier
python3 whatsapp_message.py
Tu devrais recevoir le message "Bonjour Coach " sur ton WhatsApp personnel via la sandbox Twilio.

(Optionnel) Sécuriser les identifiants avec .env
Pour éviter de stocker tes identifiants en clair :

Installe python-dotenv :

bash
Copier
Modifier
pip install python-dotenv
Crée un fichier .env :

ini
Copier
Modifier
TWILIO_SID=ACxxxxxxxxxxxxxxxxxxxxxx
TWILIO_TOKEN=your_auth_token
TO_NUMBER=whatsapp:+243xxxxxxxxx
Modifie ton script Python :

python
Copier
Modifier
from twilio.rest import Client
from dotenv import load_dotenv
import os

load_dotenv()

account_sid = os.getenv("TWILIO_SID")
auth_token = os.getenv("TWILIO_TOKEN")
from_whatsapp_number = 'whatsapp:+14155238886'
to_whatsapp_number = os.getenv("TO_NUMBER")

client = Client(account_sid, auth_token)

message = client.messages.create(
body='Bonjour Coach ',
from_=from_whatsapp_number,
to=to_whatsapp_number
)

print(f" Message envoyé ! SID : {message.sid}")
Résultat final
Grâce à cette solution, votre coach (ou n’importe quel contact autorisé via Twilio) recevra un message WhatsApp personnalisé tous les jours à 6h00.

Conclusion
Ce projet est une belle démonstration de ce qu’on peut faire avec un peu de Python, des APIs simples et une tâche planifiée. Vous pouvez aller encore plus loin en :

Envoyant des alertes système ou météo

Intégrant des rappels personnalisés

Utilisant un vrai numéro WhatsApp Twilio (payant)

Automatiser l'Envoi de Rapports Système au SysAdmin Chaque Minute avec Python & Cron

Ismael GALEKWA — Thu, 15 May 2025 07:57:34 +0000

Introduction

Dans cet article, nous allons apprendre à automatiser un script Python qui surveille les performances d'un serveur et envoie un rapport par email toutes les minutes. Ce rapport comprend :
L'utilisation du processeur (CPU)
La consommation de mémoire (RAM)
L'espace disque disponible
Et même l'adresse IP publique du serveur

C'est un excellent exercice de sysadmin et un outil utile en production.
Prérequis
Avant de commencer, assure-toi d'avoir :
Un serveur Linux ou une machine virtuelle
Python 3 installé (python3 --version)
Un accès à crontab
Un compte email pour l'envoi (ex. : Gmail)

Étape 1 : Installer les dépendances

Ouvre ton terminal et exécute :
pip3 install psutil requests
Ces bibliothèques permettent de récupérer les stats système (psutil) et de connaître l'IP publique (requests).

Étape 2 : Le Script Python
Crée un fichier server_report.py :
import psutil
import smtplib
import socket
import requests
from email.mime.text import MIMEText
from datetime import datetime

Configuration

TO_EMAIL = "sysadmin_aws_cdkin4@mtech-rdc.org"
FROM_EMAIL = "your_email@example.com" # Remplace avec ton email
EMAIL_PASSWORD = "your_password" # Mot de passe d'application si Gmail
SMTP_SERVER = "smtp.gmail.com"
SMTP_PORT = 587
def get_server_stats():
mem = psutil.virtual_memory()
disk = psutil.disk_usage('/')
cpu = psutil.cpu_percent(interval=1)
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
public_ip = requests.get("https://ifconfig.me").text.strip()
return f"""
RAPPORT DU SERVEUR - {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
IP publique : {public_ip}
IP locale : {local_ip}
Hostname : {hostname}
CPU utilisé : {cpu} %
RAM utilisée : {mem.percent} %
Disque utilisé : {disk.percent} %
Espace libre : {round(disk.free / (1024**3), 2)} Go
-- Fin du rapport --
"""
def send_email(subject, body):
msg = MIMEText(body)
msg['Subject'] = subject
msg['From'] = FROM_EMAIL
msg['To'] = TO_EMAIL
try:
server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)
server.starttls()
server.login(FROM_EMAIL, EMAIL_PASSWORD)
server.send_message(msg)
server.quit()
print(" Rapport envoyé.")
except Exception as e:
print(f" Erreur : {e}")
if name == "main":
stats = get_server_stats()
send_email(" Rapport Automatique du Serveur", stats)
Astuce sécurité : utiliser un mot de passe d'application
Si tu utilises Gmail, crée un mot de passe d'application (dans tes paramètres de sécurité) pour ne pas exposer ton mot de passe principal.
Étape 3 : Tester le script
python3 server_report.py
Tu devrais recevoir un email avec les stats du serveur dans ta boîte de réception.
Étape 4 : Automatiser avec cron
Ouvre l'éditeur de tâches planifiées :
crontab -e
Ajoute cette ligne pour exécuter le script chaque minute :

* * * * /usr/bin/python3 /chemin/vers/server_report.py

⚠️ Vérifie le chemin exact de Python avec which python3
⚠️ Mets le chemin complet de ton script

Étape 5 : Visualiser les logs en temps réel
Si tu veux voir les sorties du script (comme les erreurs ou confirmations) :
tail -f /var/log/syslog # ou /var/log/cron.log selon ta distro
Tu peux aussi rediriger la sortie du script vers un fichier de log

* * * * /usr/bin/python3 /chemin/vers/server_report.py >> /home/ismael/logs/server.log 2>&1

Conclusion
En combinant Python et Cron, tu peux créer un outil de monitoring système minimaliste, mais puissant. Tu es maintenant capable de surveiller l'état de n'importe quel serveur et d'envoyer des alertes automatiquement à ton SysAdmin.
Cette solution est idéale pour
Les petits projets auto-hébergés
Le monitoring d'urgence
L'apprentissage de l'administration système