Comment vérifier si un service existe dans Bash sur CentOS et Ubuntu ?

Utilisation de la commande systemctl

La commande systemctl vérifie l'état des services sur les systèmes Linux utilisant systemd. Pour vérifier si un service existe, utilisez cette syntaxe :

systemctl list-units --full -all | grep -Fq "nomduservice.service"

Cette commande liste toutes les unités et recherche le service. Si elle renvoie un statut de sortie zéro, le service existe. Vous pouvez vérifier le code de sortie :

if [ $? -eq 0 ]; then
    echo "Le service existe"
else
    echo "Le service n'existe pas"
fi

systemctl list-units --full -all | grep -Fq "nom du service avec espaces.service"

Utilisation de la commande service

La commande service fonctionne à la fois sur les systèmes systemd et SysV init. Pour vérifier si un service existe :

service nomduservice status

Cette commande obtient l'état du service. S'il existe, elle renvoie des informations sur son état. Sinon, vous verrez un message d'erreur. Dans un script :

if service nomduservice status >/dev/null 2>&1; then
    echo "Le service existe"
else
    echo "Le service n'existe pas"
fi

La commande service fonctionne avec CentOS et Ubuntu, ce qui la rend utile pour les scripts qui s'exécutent sur différentes distributions.

Vérification des fichiers et répertoires système

Vous pouvez vérifier l'existence d'un service en examinant les fichiers et répertoires système :

1. Examen du répertoire /etc/init.d : Pour les systèmes SysV init, vérifiez si un script de service existe dans le répertoire /etc/init.d :

   if [ -f "/etc/init.d/nomduservice" ]; then
      echo "Le service existe"
   else
      echo "Le service n'existe pas"
   fi

2. Recherche de fichiers d'unité de service dans systemd : Pour systemd, vérifiez les fichiers d'unité de service dans les répertoires systemd :

   if [ -f "/etc/systemd/system/nomduservice.service" ] || [ -f "/usr/lib/systemd/system/nomduservice.service" ]; then
      echo "Le service existe"
   else
      echo "Le service n'existe pas"
   fi

Ces méthodes offrent différentes façons de vérifier l'existence d'un service, chacune avec des avantages selon la distribution Linux et le système d'init utilisé.

verifier_service() {
    if systemctl list-units --full -all | grep -Fq "$1.service"; then
        return 0
    elif service "$1" status >/dev/null 2>&1; then
        return 0
    elif [ -f "/etc/init.d/$1" ] || [ -f "/etc/systemd/system/$1.service" ] || [ -f "/usr/lib/systemd/system/$1.service" ]; then
        return 0
    else
        return 1
    fi
}

if verifier_service "apache2"; then
    echo "Le service Apache2 existe"
else
    echo "Le service Apache2 n'existe pas"
fi

Commande simple en une ligne utilisant systemctl

Une commande en une ligne pour vérifier si un service existe en utilisant systemctl est :

systemctl list-units --full -all | grep -Fq "$nom_du_service.service"

Cette commande liste toutes les unités, y compris celles inactives, et recherche le service spécifié. L'option -q rend grep silencieux, supprimant sa sortie. La commande renvoie un statut de sortie zéro si le service est trouvé.

Pour l'utiliser dans un script bash :

#!/bin/bash

nom_du_service="apache2"
if systemctl list-units --full -all | grep -Fq "$nom_du_service.service"; then
    echo "$nom_du_service existe"
else
    echo "$nom_du_service n'existe pas"
fi

Ce script vérifie l'existence du service Apache2 et affiche un message basé sur le résultat.

#!/bin/bash

nom_du_service="apache2"
if command -v systemctl >/dev/null 2>&1; then
    if systemctl list-units --full -all | grep -Fq "$nom_du_service.service"; then
        echo "$nom_du_service existe"
    else
        echo "$nom_du_service n'existe pas"
    fi
elif command -v service >/dev/null 2>&1; then
    if service --status-all | grep -Fq "$nom_du_service"; then
        echo "$nom_du_service existe"
    else
        echo "$nom_du_service n'existe pas"
    fi
else
    echo "Impossible de vérifier l'état du service"
fi

Création d'une fonction personnalisée pour les vérifications de service

Voici un guide pour écrire une fonction de vérification de service :

1. Définir la fonction :

verifier_service() {
    local nom_du_service="$1"

    # Vérification avec systemctl
    if systemctl list-units --full -all | grep -Fq "$nom_du_service.service"; then
        return 0
    fi

    # Vérification avec la commande service
    if service "$nom_du_service" status >/dev/null 2>&1; then
        return 0
    fi

    # Vérification dans /etc/init.d et les répertoires systemd
    if [ -f "/etc/init.d/$nom_du_service" ] || \
       [ -f "/etc/systemd/system/$nom_du_service.service" ] || \
       [ -f "/usr/lib/systemd/system/$nom_du_service.service" ]; then
        return 0
    fi

    # Service non trouvé
    return 1
}

2. Ajouter la gestion des erreurs :

verifier_service() {
    if [ -z "$1" ]; then
        echo "Erreur : Aucun nom de service fourni" >&2
        return 2
    fi

    local nom_du_service="$1"

    # ... (reste de la fonction comme ci-dessus)
}

3. Utiliser la fonction dans votre script :

#!/bin/bash

service_a_verifier="apache2"

if verifier_service "$service_a_verifier"; then
    echo "$service_a_verifier existe"
else
    case $? in
        1) echo "$service_a_verifier n'existe pas" ;;
        2) echo "Une erreur s'est produite lors de la vérification du service" ;;
    esac
fi

Cette fonction vérifie le service en utilisant plusieurs méthodes, la rendant compatible avec différentes distributions Linux. Elle renvoie différents codes de sortie pour différents scénarios :

• 0 : Le service existe
• 1 : Le service n'existe pas
• 2 : Erreur dans l'utilisation de la fonction (aucun nom de service fourni)

En utilisant cette fonction, vous pouvez effectuer des vérifications de service sur divers systèmes Linux.