Construire un tableau de bord d'audit de santé de site dans Drupal 10/11 : Guide complet pour la surveillance proactive de site

Voici comment construire un tableau de bord d'audit de santé personnalisé qui surveille la sécurité, la performance et la configuration de votre site Drupal—le tout depuis une seule page.

Pourquoi construire votre propre tableau de bord de surveillance de santé Drupal?

Les sites Drupal échouent de manières prévisibles. Le cron arrête de fonctionner. Les mises à jour de sécurité s'accumulent. Les fichiers se corrompent. La mémoire s'épuise. Quand les utilisateurs se plaignent, vous êtes déjà en mode crise.

Un tableau de bord de santé détecte ces problèmes tôt. Au lieu de combattre les feux de manière réactive, vous obtenez une surveillance proactive. De plus, vous pouvez le personnaliser pour vérifier les éléments spécifiques qui comptent pour votre site.

Ce que nous allons construire : Solution complète de surveillance de santé de site

Notre tableau de bord vérifiera :

• État des mises à jour de sécurité
• Santé des tâches cron
• Permissions du système de fichiers
• Intégrité de la base de données
• Goulots d'étranglement de performance
• Erreurs de configuration

Le résultat final : une seule page d'administration qui affiche un statut rouge, jaune ou vert pour chaque vérification, avec des détails sur comment corriger les problèmes.

Prérequis pour construire le tableau de bord de santé Drupal

Vous aurez besoin de :

• Drupal 10 ou 11 fonctionnant localement ou sur un serveur
• Connaissances de base en PHP
• Accès pour créer des modules personnalisés
• Drush installé (optionnel mais utile)

Étape 1 : Créer la structure du module personnalisé

D'abord, créez votre répertoire de module :

modules/custom/site_health_dashboard/

Créez le fichier info à site_health_dashboard.info.yml :

name: 'Site Health Dashboard'
type: module
description: 'Surveille la santé du site avec des vérifications personnalisables'
core_version_requirement: ^10 || ^11
package: Custom
dependencies:
  - drupal:system
  - drupal:update

Ceci informe Drupal de votre module et assure qu'il fonctionne avec Drupal 10 et 11.

Étape 2 : Configurer le routage et la configuration du contrôleur

Créez site_health_dashboard.routing.yml :

site_health_dashboard.dashboard:
  path: '/admin/reports/site-health'
  defaults:
    _controller: '\Drupal\site_health_dashboard\Controller\DashboardController::dashboard'
    _title: 'Tableau de bord de santé du site'
  requirements:
    _permission: 'administer site configuration'

Maintenant créez le contrôleur à src/Controller/DashboardController.php :

dateFormatter = $date_formatter;
  }

  public static function create(ContainerInterface $container) {
    return new static(
      $container->get('date.formatter')
    );
  }

  public function dashboard() {
    $checks = $this->runHealthChecks();
    
    return [
      '#theme' => 'site_health_dashboard',
      '#checks' => $checks,
      '#attached' => [
        'library' => ['site_health_dashboard/dashboard'],
      ],
    ];
  }

  private function runHealthChecks() {
    return [
      'cron' => $this->checkCronStatus(),
      'updates' => $this->checkSecurityUpdates(),
      'database' => $this->checkDatabaseHealth(),
      'files' => $this->checkFileSystem(),
    ];
  }

  private function checkCronStatus() {
    $last_run = \Drupal::state()->get('system.cron_last');
    
    if (!$last_run) {
      return [
        'status' => 'error',
        'message' => 'Le cron n\'a jamais été exécuté',
        'details' => 'Exécutez le cron manuellement ou configurez des tâches cron automatisées.',
      ];
    }

    $hours_since = (time() - $last_run) / 3600;
    
    if ($hours_since > 24) {
      return [
        'status' => 'warning',
        'message' => 'Le cron a été exécuté il y a ' . round($hours_since) . ' heures',
        'details' => 'Le cron devrait fonctionner au moins quotidiennement.',
      ];
    }

    return [
      'status' => 'ok',
      'message' => 'Le cron a été exécuté ' . $this->dateFormatter->formatTimeDiffSince($last_run) . '',
      'details' => 'Le cron fonctionne normalement.',
    ];
  }

  private function checkSecurityUpdates() {
    $available = update_get_available(TRUE);
    $project_data = update_calculate_project_data($available);
    
    $security_updates = 0;
    foreach ($project_data as $project) {
      if (isset($project['security updates'])) {
        $security_updates  = count($project['security updates']);
      }
    }

    if ($security_updates > 0) {
      return [
        'status' => 'error',
        'message' => $security_updates . ' mises à jour de sécurité disponibles',
        'details' => 'Appliquez les mises à jour de sécurité immédiatement.',
      ];
    }

    return [
      'status' => 'ok',
      'message' => 'Aucune mise à jour de sécurité nécessaire',
      'details' => 'Tous les modules sont à jour.',
    ];
  }

  private function checkDatabaseHealth() {
    try {
      $database = \Drupal::database();
      $result = $database->query("SELECT COUNT(*) FROM {users}")->fetchField();
      
      return [
        'status' => 'ok',
        'message' => 'Connexion à la base de données fonctionnelle',
        'details' => 'Trouvé ' . $result . ' enregistrements d\'utilisateurs.',
      ];
    }
    catch (\Exception $e) {
      return [
        'status' => 'error',
        'message' => 'Échec de la connexion à la base de données',
        'details' => $e->getMessage(),
      ];
    }
  }

  private function checkFileSystem() {
    $public_path = \Drupal::service('file_system')->realpath('public://');
    $private_path = \Drupal::service('file_system')->realpath('private://');
    
    $issues = [];
    
    if (!is_writable($public_path)) {
      $issues[] = 'Répertoire de fichiers publics non inscriptible';
    }
    
    if ($private_path && !is_writable($private_path)) {
      $issues[] = 'Répertoire de fichiers privés non inscriptible';
    }

    if (!empty($issues)) {
      return [
        'status' => 'error',
        'message' => 'Problèmes de système de fichiers détectés',
        'details' => implode(', ', $issues),
      ];
    }

    return [
      'status' => 'ok',
      'message' => 'Système de fichiers en santé',
      'details' => 'Tous les répertoires sont inscriptibles.',
    ];
  }
}

Étape 3 : Créer le gabarit du tableau de bord

Créez templates/site-health-dashboard.html.twig :

  
État de santé du site
  
  

    {% for check_name, check in checks %}
      

        

          
{{ check_name|title }}
          {{ check.status|upper }}
        
        

          
{{ check.message }}
          
{{ check.details }}
        
      
    {% endfor %}
  

Étape 4 : Ajouter un style professionnel au tableau de bord

Créez site_health_dashboard.libraries.yml :

dashboard:
  css:
    theme:
      css/dashboard.css: {}

Créez css/dashboard.css :

.site-health-dashboard {
  max-width: 1200px;
}

.health-checks {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
  gap: 1rem;
  margin-top: 1rem;
}

.health-check {
  border: 2px solid #ddd;
  border-radius: 8px;
  padding: 1rem;
  background: #fff;
}

.health-check--ok {
  border-color: #28a745;
  background-color: #f8fff9;
}

.health-check--warning {
  border-color: #ffc107;
  background-color: #fffdf0;
}

.health-check--error {
  border-color: #dc3545;
  background-color: #fff8f8;
}

.health-check__header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 0.5rem;
}

.health-check__status {
  font-weight: bold;
  padding: 0.25rem 0.5rem;
  border-radius: 4px;
  font-size: 0.75rem;
}

.health-check--ok .health-check__status {
  background-color: #28a745;
  color: white;
}

.health-check--warning .health-check__status {
  background-color: #ffc107;
  color: black;
}

.health-check--error .health-check__status {
  background-color: #dc3545;
  color: white;
}

.health-check__message {
  font-weight: bold;
  margin-bottom: 0.5rem;
}

.health-check__details {
  color: #666;
  font-size: 0.9rem;
}

Étape 5 : Enregistrer le hook de thème

Créez ou modifiez site_health_dashboard.module :

 [
      'variables' => ['checks' => NULL],
      'template' => 'site-health-dashboard',
    ],
  ];
}

Étape 6 : Activer et tester votre tableau de bord de santé Drupal

Activez votre module :

drush en site_health_dashboard

Ou par l'interface d'administration à /admin/modules.

Visitez /admin/reports/site-health pour voir votre tableau de bord en action.

Rendre votre tableau de bord de santé de site plus puissant

Le tableau de bord de base n'est que le début. Voici des façons de l'étendre :

Ajouter des vérifications de surveillance de santé avancées

Créez des vérifications de santé supplémentaires en ajoutant des méthodes à votre contrôleur :

private function checkMemoryUsage() {
  $memory_limit = ini_get('memory_limit');
  $memory_usage = memory_get_peak_usage(true);
  
  // Convertir memory_limit en octets pour la comparaison
  $limit_bytes = $this->convertToBytes($memory_limit);
  $usage_percent = ($memory_usage / $limit_bytes) * 100;
  
  if ($usage_percent > 80) {
    return [
      'status' => 'warning',
      'message' => 'Utilisation mémoire élevée : ' . round($usage_percent) . '%',
      'details' => 'Considérez augmenter memory_limit ou optimiser le code.',
    ];
  }
  
  return [
    'status' => 'ok',
    'message' => 'Utilisation mémoire : ' . round($usage_percent) . '%',
    'details' => 'L\'utilisation mémoire est dans les limites normales.',
  ];
}

Mettre en cache les résultats pour une meilleure performance

Pour les vérifications coûteuses, ajoutez la mise en cache :

private function checkSecurityUpdates() {
  $cache = \Drupal::cache()->get('site_health_dashboard.security_updates');
  
  if ($cache && (time() - $cache->created) < 3600) {
    return $cache->data;
  }
  
  // Exécuter la vérification actuelle...
  $result = [/* vos résultats de vérification */];
  
  \Drupal::cache()->set('site_health_dashboard.security_updates', $result, time()   3600);
  
  return $result;
}

Ajouter des options de configuration administratives

Laissez les administrateurs choisir quelles vérifications exécuter en créant un formulaire de configuration.

Problèmes courants et solutions de dépannage

Le tableau de bord affiche "Accès refusé"
Vérifiez que votre utilisateur a la permission "Administrer la configuration du site".

Les vérifications affichent toujours "OK" même quand il y a des problèmes
Assurez-vous de tester les conditions réelles. Ajoutez du débogage avec \Drupal::logger('site_health_dashboard')->info() pour voir ce qui se passe.

Le style semble incorrect
Videz votre cache après avoir ajouté des changements CSS : drush cr

Le module ne s'active pas
Vérifiez les erreurs de syntaxe dans vos fichiers PHP. Exécutez php -l filename.php pour vérifier.

Optimisation de performance pour la surveillance de santé de site

Les vérifications de santé peuvent ralentir votre tableau de bord si elles sont coûteuses. Voici des façons de le garder rapide :

• Mettre en cache les résultats pour les vérifications qui ne changent pas souvent
• Exécuter les vérifications lourdes via cron et stocker les résultats
• Utiliser AJAX pour charger les vérifications individuelles après le chargement de la page
• Limiter la fréquence des vérifications - certaines choses n'ont besoin d'être vérifiées que quotidiennement

Prochaines étapes pour la surveillance avancée de santé de site

Votre tableau de bord de santé fonctionne maintenant et détecte les problèmes de base. Pour le rendre prêt pour la production :

• Ajoutez des vérifications plus spécifiques pour les fonctions critiques de votre site
• Configurez des alertes courriel pour les problèmes critiques
• Créez une version compatible mobile pour la surveillance en déplacement
• Intégrez avec des services de surveillance externes
• Ajoutez un suivi historique pour détecter les tendances

Construire ce tableau de bord vous donne la fondation pour une gestion proactive de site. Au lieu d'attendre que les problèmes vous trouvent, vous les détecterez tôt et garderez votre site Drupal fonctionnant en douceur.

Les exemples de code ici couvrent la structure essentielle. Personnalisez les vérifications de santé selon vos besoins spécifiques, et vous aurez un outil puissant pour garder votre site en santé.