Guide de script Linux : Comment vérifier l’état du stockage des noeuds Proxmox ?

La gestion efficace du stockage est un élément crucial pour conserver une infrastructure informatique performante et efficace. Pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP), disposer d’outils fournissant des informations détaillées sur l’état du stockage peut considérablement améliorer leur efficacité opérationnelle.

L’un de ces outils est le script bash conçu pour récupérer et afficher les détails du stockage des noeuds Proxmox. Cet article explore les fonctionnalités du script, son importance et son application dans divers scénarios.

Contexte

Dans un environnement virtualisé comme Proxmox, la vérification de l’état du stockage des nœuds est essentielle pour l’optimisation des performances, le dépannage et la planification de la capacité. Proxmox VE (Virtual Environment) est une solution open-source de gestion de la virtualisation des serveurs qui fournit une plateforme puissante pour gérer les VM, les conteneurs, le stockage et le réseau.

Le script fourni exploite l’API de Proxmox et l’outil d’interface de ligne de commande (CLI) de NinjaOne pour recueillir et présenter des informations de stockage détaillées, qui peuvent ensuite être enregistrées dans des champs personnalisés en vue d’une analyse ou d’une documentation plus poussée. Ce script est particulièrement utile pour les entreprises MSP qui doivent surveiller plusieurs environnements clients et garantir des performances ainsi qu’une disponibilité optimales.

Le script PowerShell :

#!/usr/bin/env bash

# Description: Get the details of a Proxmox Node Storage and save it to a multiline and/or WYSIWYG custom field
#
# Release Notes: Fixed 10% width bug.
# By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
# Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
# Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
# Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
# Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
# Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
# Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
# EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).

# Command line arguments, swap the numbers if you want the multiline custom field to be the second argument
multiline_custom_field=$1 # First argument is the multiline custom field name
wysiwyg_custom_field=$2   # Second argument is the WYSIWYG custom field name

# Check if the multilineCustomField and wysiwygCustomField are set
if [[ -n "${multilineCustomField}" && "${multilineCustomField}" != "null" ]]; then
    multiline_custom_field=$multilineCustomField
fi
if [[ -n "${wysiwygCustomField}" && "${wysiwygCustomField}" != "null" ]]; then
    wysiwyg_custom_field=$wysiwygCustomField
fi

# Check if the multiline_custom_field and wysiwyg_custom_field are the same
if [[ -n "${multiline_custom_field}" && "${multiline_custom_field}" == "${wysiwyg_custom_field}" ]]; then
    echo "[Error] multilineCustomField and wysiwygCustomField cannot be the same custom field."
    exit 1
fi

# Check if the multiline_custom_field and wysiwyg_custom_field are set
if [[ -z "${multiline_custom_field}" ]]; then
    echo "[Info] multilineCustomField is not set."
fi
if [[ -z "${wysiwyg_custom_field}" ]]; then
    echo "[Info] wysiwygCustomField is not set."
fi

# Check that we have the required tools
if ! command -v pvesh &>/dev/null; then
    echo "[Error] The Proxmox VE API tool 'pvesh' is required."
    exit 1
fi

# Check that we are running as root
if [[ $EUID -ne 0 ]]; then
    echo "[Error] This script must be run as root."
    exit 1
fi

# Check if ninjarmm-cli command exists
ninjarmm_cli="/opt/NinjaRMMAgent/programdata/ninjarmm-cli"
if [[ -z $ninjarmm_cli ]]; then
    echo "[Error] The ninjarmm-cli command does not exist in the default path. Please ensure the NinjaRMM agent is installed before running this script."
    exit 1
else
    # ninjarmm-cli command exists in the default path
    echo -n
fi

function GetThisNodeName() {
    # Get the node name
    if ! node_name=$(pvesh get /cluster/status --noborder | awk '$6 == 1 {print $2}'); then
        echo "[Error] Failed to get the node name."
        echo "$node_name"
        exit 1
    fi
    echo "$node_name"
}

# Run the pvesh command to get the status information
if ! storages=$(pvesh get /storage --noborder | tail +2); then
    echo "[Error] Failed to get the list of storages."
    echo "$storages"
    exit 1
fi
# Example Output:
# local
# local-zfs
# storage-nas

function formatStorage() {
    echo ""
    echo "Storage Status:"
    # Loop though the storages and get the status of each
    for storage in $storages; do
        # Get the status of the storage
        if ! storage_status=$(pvesh get /storage/"$storage" --noborder); then
            echo "[Error] Failed to get the Storage Status of $storage."
            echo "$storage_status"
            exit 1
        fi
        storage_node=$(GetThisNodeName)
        # Get the storage name
        storage_name=$(echo "$storage_status" | grep -P 'storage\s+' | awk '{print $2}')
        # Get the free space
        # "$storage_name " is used to avoid matching "local-zfs" when searching for "local"
        storage_free_space=$(pvesh get "/nodes/$storage_node/storage" --noborder | grep -P "$storage_name " | awk '{print $5" "$6}')
        # Get the total space
        storage_total_space=$(pvesh get "/nodes/$storage_node/storage" --noborder | grep -P "$storage_name " | awk '{print $9" "$10}')
        echo -n
        echo ""
        echo "$storage"
        echo "-------------"
        # Take the output of $storage_status, skip the first line, then use a colon as a separator between the key and value
        echo "$storage_status" | tail +2 | awk '{print $1 ": " $2}'
        echo "Free: $storage_free_space"
        echo "Total: $storage_total_space"
    done
}
multiline_output=$(formatStorage)

# Create Storage Status label
storage_table="<h2>Storage Status</h2>"
# Create the Storage Status table
storage_table+="<table style='white-space:nowrap;'><tr><th>Storage Name</th><th>Type</th><th>Path/File System</th><th>Free Space</th><th>Total Space</th><th>Content</th></tr>"

# Loop though the storages and get the status of each
for storage in $storages; do
    if ! storage_status=$(pvesh get /storage/"$storage" --noborder); then
        echo "[Error] Failed to get the Storage Status of $storage."
        echo "$storage_status"
        exit 1
    fi
    # Example Output:
    # key     value
    # content images,rootdir
    # digest  c14cb4c9bbcf9a062fa8a82b10afe01cb1ed5b8d
    # pool    rpool/data
    # sparse  1
    # storage local-zfs
    # type    zfspool
    storage_node=$(GetThisNodeName)
    # Get the storage name
    storage_name=$(echo "$storage_status" | grep -P 'storage\s+' | awk '{print $2}')
    # Get the storage type
    storage_type=$(echo "$storage_status" | grep -P 'type\s+' | awk '{print $2}')
    # Get the storage pool/path
    storage_pool=$(echo "$storage_status" | grep -P 'pool\s+' | awk '{print $2}')
    if [[ -z "${storage_pool}" ]]; then
        storage_pool=$(echo "$storage_status" | grep -P 'path\s+' | awk '{print $2}')
    fi
    # Get the storage content
    storage_content=$(echo "$storage_status" | grep -P 'content\s+' | awk '{print $2}')
    # Get the free space
    # "$storage_name " is used to avoid matching "local-zfs" when searching for "local"
    storage_free_space=$(pvesh get "/nodes/$storage_node/storage" --noborder | grep -P "$storage_name " | awk '{print $5" "$6}')
    # Get the total space
    storage_total_space=$(pvesh get "/nodes/$storage_node/storage" --noborder | grep -P "$storage_name " | awk '{print $9" "$10}')

    # Add to the Storage Status table
    storage_table+="<tr><td>$storage_name</td><td>$storage_type</td><td>$storage_pool</td><td>$storage_free_space</td><td>$storage_total_space</td><td>$storage_content</td></tr>"
done

# Close the Storage Status table
storage_table+="</table>"

# Save the results
result_table="$storage_table"

_exit_code=0
# Save the result to the custom field
if [[ -n "$wysiwyg_custom_field" ]]; then
    if [[ -x "$ninjarmm_cli" ]]; then
        if hideOutput=$(echo "$result_table" | "$ninjarmm_cli" set --stdin "$wysiwyg_custom_field" 2>&1); then
            echo "[Info] Successfully set custom field: $wysiwyg_custom_field"
        else
            echo "[Error] Failed to set custom field: $wysiwyg_custom_field. Custom Field does not exit or does not have write permissions."
            _exit_code=1
        fi
    else
        echo "[Error] NinjaRMM CLI not found or not executable"
        _exit_code=1
    fi
fi

if [[ -n "$multiline_custom_field" ]]; then
    if [[ -x "$ninjarmm_cli" ]]; then
        if hideOutput=$(echo "$multiline_output" | "$ninjarmm_cli" set --stdin "$multiline_custom_field" 2>&1); then
            echo "[Info] Successfully set custom field: $multiline_custom_field"
        else
            echo "[Error] Failed to set custom field: $multiline_custom_field. Custom Field does not exit or does not have write permissions."
            _exit_code=1
        fi
    else
        echo "[Error] NinjaRMM CLI not found or not executable"
        _exit_code=1
    fi
fi

# Output the result if no custom fields are set
if [[ -z "${wysiwyg_custom_field}" ]] && [[ -z "${multiline_custom_field}" ]]; then
    # Output the result to the Activity Feed
    echo "${multiline_output}"
fi

if [[ $_exit_code -eq 1 ]]; then
    exit 1
fi

 

Description détaillée

Nous allons nous plonger dans le script pour en comprendre le fonctionnement étape par étape.

1. Initialisation et analyse des arguments Le script commence par analyser les arguments de la ligne de commande afin de déterminer les noms des champs personnalisés dans lesquels les données de stockage seront enregistrées. Il accepte deux arguments : un pour un champ personnalisé multiligne et un autre pour un champ personnalisé WYSIWYG. Ces champs sont utilisés pour stocker des informations formatées afin de faciliter la lecture et l’analyse.
2. Validation des champs personnalisés Le script vérifie si les champs personnalisés sont définis par des variables d’environnement ou des arguments de ligne de commande. Il s’assure que les deux champs ne sont pas identiques afin d’éviter les conflits.
3. Vérification de la disponibilité de l’outil et des autorisations Le script vérifie la disponibilité de la commande pvesh, qui est utilisée pour interagir avec l’API Proxmox, et s’assure qu’elle est exécutée avec le privilège d’administrateur.
4. Validation de l’interface CLI de NinjaOne Le script vérifie l’existence de l’outil NinjaOne CLI, qui est nécessaire pour mettre à jour les champs personnalisés.
5. Récupération du nom du nœud Le script définit une fonction permettant de récupérer le nom du nœud Proxmox, qui est nécessaire pour demander des informations spécifiques sur le stockage.
6. Récupération des informations de stockage et formatage Le script récupère la liste de stockage et passe en revue chaque élément de stockage pour recueillir des informations détaillées sur son état, notamment l’espace libre et l’espace total. Ces informations sont formatées pour les champs personnalisés multilignes et WYSIWYG.
7. Création d’un tableau HTML Le script construit un tableau HTML pour le champ personnalisé WYSIWYG, et présente l’état du stockage sous forme de tableau.
8. Enregistrement des résultats Enfin, le script enregistre les informations de stockage formatées dans les champs personnalisés spécifiés à l’aide de l’outil CLI de NinjaOne.

Cas d’utilisation potentiels

Imaginez une entreprise MSP qui gère plusieurs environnements clients avec Proxmox. Elle doit vérifier régulièrement l’état du stockage pour s’assurer qu’il y a suffisamment d’espace libre pour les sauvegardes et le fonctionnement des machines virtuelles. Grâce à ce script, l’entreprise MSP peut automatiser la récupération des informations de stockage et les enregistrer dans des champs personnalisés pour chaque client, ce qui permet un accès rapide aux données importantes sans aucune intervention manuelle. Cette automatisation réduit le risque d’erreur humaine et garantit des mises à jour en temps voulu sur l’état du stockage.

Comparaisons

Bien que ce script offre une solution adaptée aux environnements Proxmox intégrés à NinjaOne, d’autres méthodes pour récupérer les informations de stockage incluent l’utilisation d’outils Proxmox natifs tels que l’interface web ou des scripts personnalisés sans intégration de NinjaOne.

Toutefois, ces méthodes peuvent ne pas offrir les fonctionnalités d’automatisation et de gestion centralisée fournies par la combinaison de ce script et de NinjaOne, ce qui les rend moins efficaces pour les MSP qui gèrent plusieurs environnements.

FAQ

Qu’est-ce que Proxmox VE ?

Proxmox VE est une plateforme open-source de gestion de la virtualisation des serveurs qui permet de gérer les VM, les conteneurs, le stockage et le réseau.

Qu’est-ce que NinjaOne ?

NinjaOne est un outil de surveillance et de gestion à distance (RMM) qui aide les MSP et les professionnels de l’informatique à gérer les environnements de leurs clients à partir d’une plateforme centralisée.

Ai-je besoin d’un accès root pour exécuter ce script ?

Oui, l’accès root est nécessaire pour récupérer les informations de stockage des nœuds Proxmox.

Ce script peut-il être utilisé sans NinjaOne ?

Le script est conçu pour s’intégrer à NinjaOne afin de stocker les données des champs personnalisés. Sans NinjaOne, il peut toujours récupérer et afficher les informations de stockage, mais ne les enregistre pas dans les champs personnalisés.

Implications

L’automatisation de la récupération et de la documentation de l’état du stockage améliore l’efficacité opérationnelle et réduit le risque que des problèmes liés au stockage passent inaperçus. Cette approche proactive de la gestion du stockage permet d’éviter les temps d’arrêt et de garantir que l’infrastructure informatique reste saine et performante.

Recommandations

• Assurez-vous que l’outil Proxmox API (pvesh) et l’outil NinjaOne CLI sont correctement installés et configurés avant d’exécuter le script.
• Examinez et mettez à jour régulièrement les champs personnalisés pour que les informations de stockage soient à jour et exactes.
• Testez le script dans un environnement de non-production pour vous assurer qu’il répond à vos besoins et qu’il s’intègre parfaitement à vos processus existants.

Conclusion

L’utilisation de scripts d’automatisation comme celui-ci peut considérablement améliorer l’efficacité des opérations informatiques, en particulier pour les MSP qui gèrent plusieurs environnements clients. NinjaOne, avec ses puissantes capacités de RMM, fournit une excellente plateforme pour intégrer de tels scripts, offrant une approche centralisée et optimisée de la gestion informatique. En utilisant ces outils, les professionnels de l’informatique peuvent s’assurer que leur infrastructure fonctionne toujours de manière optimale et être mieux préparés à relever les défis liés au stockage.