Analyser les journaux en temps réel à l'aide de Fluentd et BigQuery

Ce tutoriel montre comment enregistrer le trafic du navigateur et l’analyser en temps réel. Cela est utile lorsque vous recevez un volume important de journalisation à partir de différentes sources et que vous souhaitez déboguer des problèmes ou générer des statistiques à jour à partir des journaux.

Le tutoriel décrit comment envoyer les informations de journal générées par un serveur Web NGINX vers BigQuery à l'aide de Fluentd, puis comment utiliser BigQuery pour analyser les informations du journal. Cela suppose que vous maîtrisiez les bases de Google Cloud Platform (GCP), des lignes de commande Linux, de la collecte de journaux d'applications et de l'analyse des journaux.

Présentation

Les journaux constituent un outil puissant permettant de visualiser la performance des systèmes et des applications à grande échelle. Cependant, à mesure que l’échelle et la complexité de ces systèmes augmentent, il devient difficile de gérer plusieurs journaux distribués sur un parc de ressources informatiques.

Fluentd est un collecteur de journaux Open Source populaire qui vise à unifier la collecte de journaux de nombreuses sources de données et de nombreux systèmes et à les rassembler dans une couche de journalisation unifiée. Comme il est difficile de savoir à l’avance quelles données peuvent être utiles pour l'analyse, une approche courante consiste à les enregistrer toutes et à les trier par la suite. Cependant, la collecte et le stockage de toutes ces données peuvent devenir difficiles à manier, ce qui rend l'obtention des réponses que vous attendez lente et difficile.

C’est là que les atouts de BigQuery entrent en jeux en matière d'utilisation des données relatives aux journaux. BigQuery est le moteur d'analyse et d'entrepôt de données cloud entièrement géré et hautement évolutif de Google. Il peut effectuer des requêtes sur des téraoctets de journaux en quelques dizaines de secondes. Cette performance vous permet d'obtenir rapidement les réponses dont vous avez besoin pour réparer ou améliorer vos systèmes.

Par défaut, vous pouvez diffuser 100 000 lignes de données de journal par seconde dans BigQuery et vous pouvez augmenter cette limite en demandant un quota supplémentaire.

Fluentd dispose d'un plug-in de sortie qui peut utiliser BigQuery comme destination pour stocker les journaux collectés. En utilisant le plug-in, vous pouvez charger directement les journaux dans BigQuery pratiquement en temps réel pour beaucoup de serveurs. Vous pouvez ainsi aisément visualiser ces données en créant un tableau de bord qui est régulièrement mis à jour dans Google Sheets ou Google Data Studio.

Objectifs

  • Exécuter un serveur Web NGINX sur une instance Compute Engine.
  • Installer un agent de collection de journaux Fluentd.
  • Configurer Fluentd afin qu'il exécute les opérations suivantes :
    • Collecter les journaux de trafic NGINX.
    • Transférer les journaux à BigQuery.
  • Effectuer une requête sur les messages de journaux à l'aide de l'interface utilisateur Web de BigQuery.
  • Exécuter une requête d'analyse sur les journaux à l'aide de BigQuery.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud Platform, dont :

  • Instance
  • BigQuery

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

Une fois que vous avez terminé ce tutoriel, évitez de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez Effectuer un nettoyage.

Créer une VM webserver NGINX

Dans ce tutoriel, vous utilisez GCP Marketplace pour créer une instance Compute Engine préconfigurée pour exécuter le serveur Web NGINX.

  1. Dans la console GCP, accédez à la page d'informations de Marketplace de l'image Nginx (Google Click to Deploy) :

    Accéder à la page d'informations NGINX

  2. Cliquez sur Lancer sur Compute Engine.

  3. Si vous y êtes invité, sélectionnez le projet GCP à utiliser.

  4. Attendez l'activation des API requises.

  5. Nommez le déploiement nginx.

  6. Sélectionnez une zone qui se trouve dans une région américaine ou européenne.

  7. Sous Pare-feu dans la section Mise en réseau, assurez-vous que l'option Autoriser le trafic HTTP est activée.

  8. Lisez les conditions répertoriées dans les Conditions d'utilisation.

  9. Si vous acceptez les conditions, cliquez sur Déployer.

    L'écran comprenant les informations sur le déploiement affiche une VM créée dans la zone spécifiée et le serveur Web NGINX installé.

  10. Attendez la fin du déploiement avant de continuer.

Ajouter des autorisations

La machine virtuelle nécessite des autorisations supplémentaires afin d'écrire dans BigQuery. Pour modifier les autorisations relatives à la VM, vous devez d'abord l'arrêter.

  1. Dans la console GCP, accédez à la page des instances Compute Engine.

    Accéder à la page Instances de VM

    Vous voyez une nouvelle instance de VM nommée nginx-vm.

  2. Pour ouvrir la page d'informations de la VM, cliquez sur son nom.

  3. Cliquez sur le bouton Arrêter en haut de la page.

    L'arrêt de la VM prend quelques instants.

  4. Cliquez sur Modifier en haut de la page.

  5. Faites défiler vers le bas et spécifiez l'accès à BigQuery sur Activé.

  6. Cliquez sur Enregistrer au bas de la page.

  7. Cliquez sur Commencer en haut de la page pour redémarrer la VM avec les autorisations.

Ne fermez pas encore cette page, elle est utile pour la section suivante.

Installer le connecteur de Fluentd pour BigQuery

Dans cette section du tutoriel, vous installez le collecteur de journaux Fluentd et le plug-in de sortie Fluentd pour BigQuery sur la VM.

  1. Dans la page de détails de l'instance de VM, cliquez sur le bouton SSH pour ouvrir une connexion à l'instance.
  2. Dans la fenêtre shell de la VM, vérifiez la version de Debian :

    lsb_release -rdc
    

    Le résultat affiche la version de Debian en cours d'exécution sur la VM et son nom de code :

    Description:    Debian GNU/Linux 9.6 (stretch)
    Release:        9.6
    Codename:       stretch
    
  3. Accédez à la page de téléchargement de Fluentd pour Debian et recherchez la ligne de commande de l’installation pour la version du nom de code Debian.

    Par exemple, pour Debian Stretch, vous trouvez la commande suivante :

    curl -L
       https://toolbelt.treasuredata.com/sh/install-debian-stretch-td-agent3.sh
       | sh
    
  4. Copiez la commande dans la fenêtre shell de votre VM.

    Cette commande installe le package td-agent sur votre VM. Le package contient la distribution Fluentd.

  5. Installez le plug-in Fluentd-to-BigQuery :

    sudo /usr/sbin/td-agent-gem install fluent-plugin-bigquery
    

Créer un ensemble de données et une table BigQuery en tant que destination de journal

Fluentd fonctionne en utilisant des plug-ins d’entrée pour collecter les journaux générés par d’autres applications et services. Il range ces données dans des enregistrements JSON structurés, qui sont ensuite transmis à tous les plug-ins de sortie configurés.

L'analyseur de journal d'accès Fluentd NGINX lit les fichiers access.log. La liste suivante montre un exemple d'enregistrement avec des champs et des exemples de valeurs.

time: 1362020400
record:
{
  "remote"              : "127.0.0.1",
  "host"                : "192.168.0.1",
  "user"                : "-",
  "method"              : "GET",
  "path"                : "/",
  "code"                : "200",
  "size"                : "777",
  "referer"             : "-",
  "agent"               : "Opera/12.0",
  "http_x_forwarded_for": "-"
}

Lorsque vous créez une table de destination de journal dans BigQuery, les noms de colonne doivent correspondre exactement aux noms de champ de l'enregistrement de journal. Dans la procédure suivante, veillez à utiliser les noms suggérés pour que les noms des colonnes de la table soient corrects pour une utilisation ultérieure.

  1. Ouvrez l'interface utilisateur Web BigQuery :

    Accéder à l'UI Web de BigQuery

  2. Dans le panneau de navigation, sous Ressources, cliquez sur le nom de votre projet.

  3. Dans le panneau de détails situé sous l'éditeur de requête, cliquez sur Créer un ensemble de données.

  4. Pour l'ID de l'ensemble de données, saisissez fluentd.

  5. Pour l'emplacement des données, sélectionnez l'emplacement multirégional (États-Unis ou Europe) où vous avez créé l'instance NGINX.

  6. Cliquez sur Créer un ensemble de données.

  7. Dans le panneau de navigation, sous Ressources, cliquez sur l'ensemble de données fluentd.

  8. Dans le panneau de détails situé sous l'éditeur de requête, cliquez sur Créer une table.

  9. Pour le nom de la table, saisissez nginx_access.

  10. Sélectionnez l'option Modifier sous forme de texte.

  11. Copiez la définition de colonne JSON suivante dans la zone de texte.

    [  { "type": "TIMESTAMP", "name": "time" },
       { "type": "STRING",    "name": "remote" },
       { "type": "STRING",    "name": "host" },
       { "type": "STRING",    "name": "user" },
       { "type": "STRING",    "name": "method" },
       { "type": "STRING",    "name": "path" },
       { "type": "STRING",    "name": "code" },
       { "type": "INTEGER",   "name": "size" },
       { "type": "STRING",    "name": "referer" },
       { "type": "STRING",    "name": "agent" },
       { "type": "STRING",    "name": "http_x_forwarded_for" } ]
    

    Notez que les noms de colonne correspondent exactement aux noms de champ de l'enregistrement de journal Fluentd. La valeur de la colonne time est ajoutée à l'enregistrement en convertissant l'horodatage d'enregistrement du journal en une chaîne d'horodatage compatible BigQuery.

  12. Dans la liste Partitionnement, sélectionnez Partitionner par champ : heure.

    Les tables partitionnées divisent les grandes tables en segments plus petits afin d'améliorer les performances de la requête et de contrôler les coûts en réduisant la quantité de données lues par une requête. Pour plus d'informations, consultez la présentation des tables partitionnées dans la documentation de référence BigQuery.

  13. Cliquez sur Créer une table en bas.

    La table BigQuery nommée fluentd.nginx_access est maintenant disponible pour recevoir des enregistrements de journal.

  14. Pour afficher les détails de la table, sous Ressources > Détails, cliquez sur le nom de la table.

    Les détails vous permettent de voir des informations telles que le nombre de lignes et la quantité de stockage utilisée par la table.

Configurer la collecte de journaux et leur transfert vers BigQuery

Le fichier de configuration Fluentd /etc/td-agent/td-agent.conf définit les sources à partir desquelles les données de journal sont collectées, les sorties des journaux collectés et les filtres éventuels. Il vous permet également d’appliquer des tags aux journaux collectés pour définir le mode de traitement et le plug-in de sortie auquel ils doivent être envoyés.

Dans la procédure suivante, vous configurez Fluentd pour effectuer les opérations suivantes :

Pour configurer la collecte et le transfert des journaux, procédez comme suit :

  1. Utilisez SSH pour vous connecter à la VM sur laquelle NGINX est installé.
  2. Dans la fenêtre shell, ouvrez un éditeur de texte en tant qu'utilisateur racine (par exemple, ouvrez Vim ou Nano) et modifiez le fichier de configuration de l'agent Fluentd /etc/td-agent/td-agent.conf. Par exemple, utilisez la commande suivante pour ouvrir le fichier dans Vim :

    sudo vim /etc/td-agent/td-agent.conf
    
  3. Au bas du fichier, ajoutez les lignes suivantes pour configurer le plug-in d'entrée tail afin de lire les journaux NGINX, les analyser avec l’analyseur NGINX et les étiqueter avec nginx.access :

    <source>
      @type tail
      @id input_tail
      <parse>
        @type nginx
      </parse>
      path /var/log/nginx/access.log
      pos_file /var/log/td-agent/httpd-access.log.pos
      tag nginx.access
    </source>
    
  4. Ajoutez les lignes suivantes pour configurer le plug-in de sortie BigQuery. Remplacez [MY_PROJECT_NAME] par le nom de votre projet GCP.

    <match nginx.access>
      @type bigquery_insert
    
      # Authenticate with BigQuery using the VM's service account.
      auth_method compute_engine
      project [MY_PROJECT_NAME]
      dataset fluentd
      table nginx_access
      fetch_schema true
    
      <inject>
        # Convert fluentd timestamp into TIMESTAMP string
        time_key time
        time_type string
        time_format %Y-%m-%dT%H:%M:%S.%NZ
      </inject>
    </match>
    

    Ceci configure Fluentd pour effectuer les opérations suivantes :

    • Pour chaque entrée de journal portant le tag nginx.access, Fluentd doit utiliser le plug-in bigquery_insert pour écrire l'enregistrement dans la table BigQuery.
    • L'authentification est effectuée à l'aide du compte de service de la VM.
    • L'horodatage d'origine est ajouté à l'enregistrement en tant que chaîne formatée de manière à ce que BigQuery puisse le convertir en horodatage.
  5. Enregistrez le fichier et quittez l'éditeur.

  6. Redémarrez l'agent Fluentd pour appliquer la nouvelle configuration.

    sudo systemctl restart td-agent
    

Pour plus d'informations sur ces paramètres de fichier de configuration, y compris d'autres méthodes d'authentification, consultez le site du plug-in BigQuery Fluentd et la documentation de référence du plug-in Fluentd.

Afficher les journaux dans BigQuery

Maintenant que Fluentd est configuré, vous pouvez générer des données de journal NGINX log data et les afficher à l'aide de BigQuery.

  1. Dans la console GCP, accédez à la page d'instances de VM Compute Engine :

    Accéder à la page Instances de VM

  2. Copiez l'adresse IP externe de l'instance de VM nginx-vm.

  3. Dans un autre onglet de navigation, collez l'adresse IP dans la barre d'adresse.

    La page par défaut Bienvenue à nginx ! est affichée.

  4. Dans la console GCP, accédez à la page BigQuery.

  5. Copiez la requête suivante dans le volet de l'éditeur de requête, puis cliquez sur Exécuter :

    SELECT * FROM `fluentd.nginx_access`
    

    Vous voyez une ligne dans le panneau Résultats de la requête qui affiche l'enregistrement du journal d'accès à partir de votre navigateur. Étant donné que votre VM est accessible à partir d'Internet, vous pouvez également voir les lignes de journal d'accès d'autres hôtes distants.

Simuler la charge et calculer les statistiques à partir des journaux

Dans cette section, vous exécutez des exemples de charges, puis affichez les métriques pour ces charges à l'aide de BigQuery. Ces étapes vous montrent que BigQuery peut être utilisé non seulement pour lire les journaux, mais également pour exécuter une analyse.

  1. Dans la console GCP, démarrez Cloud Shell.
  2. Installez l'outil d'analyse comparative de serveur Web ApacheBench (ab) et les outils associés :

     sudo apt install -y apache2-utils
    
  3. Dans Cloud Shell, générez une charge de test à exécuter sur le serveur NGINX. Remplacez [IP_ADDRESS] par l'adresse IP de votre VM.

    ab -t 20 -c 1 http://[IP_ADDRESS]/
    

    Cette commande utilise l'outil ApacheBench pour générer 20 secondes de charge sur votre serveur NGINX.

  4. Dans la console GCP, accédez à la page BigQuery.

    Accéder à la page BigQuery

  5. Obtenez une liste de requêtes ApacheBench en effectuant la requête suivante dans le volet Éditeur de requête :

    SELECT * FROM `fluentd.nginx_access` limit 100
    
  6. Exécutez la commande SQL suivante pour calculer le nombre de requêtes pour chaque code de réponse par seconde :

    SELECT
      time_sec, code, COUNT(*) as count
    FROM (
      SELECT
        TIMESTAMP_TRUNC(time, SECOND)AS time_sec, code
      FROM
        `fluentd.nginx_access`)
    GROUP BY
      time_sec, code
    ORDER BY
      time_sec DESC
    

    Les valeurs par seconde doivent être approximativement égales à la ligne Requêtes par seconde de la sortie ApacheBench consultée plus tôt.

Facultatif : Utiliser le chargement par lots pour un volume important de journaux

Comme précédemment indiqué, les insertions en flux continu BigQuery (comme utilisées dans ce tutoriel) rendent les données disponibles afin qu'elle puissent être soumises aux requêtes en quelques secondes. Des frais modérés sont facturés pour cette méthode et des limites sont appliquées à la taille et à la fréquence des insertions.

Pour les volumes de journalisation plus importants, vous pouvez utiliser le chargement par lots BigQuery. Comme son nom l'indique, les données sont chargées à l'aide d'une tâche par lots de priorité inférieure. Avec le chargement par lots, le chargement et la disponibilité des données prennent plus de temps qu'avec les insertions en flux continu. Cependant, le chargement par lots est gratuit.

Comme pour les insertions en flux continu, la fréquence des tâches de chargement par lots est limitée à 1 000 tâches par table et par jour et 50 000 tâches par projet et par jour.

Pour implémenter le chargement par lots, vous utilisez le plug-in Fluentd bigquery_load. Ce plug-in utilise un tampon Fluentd pour rassembler un ensemble de journaux en fichiers jusqu'à une certaine limite de temps ou de taille avant de les envoyer en lots à BigQuery.

Pour utiliser le chargement par lots, procédez comme suit :

  1. Spécifiez le fichier de configuration Fluentd /etc/td-agent/td-agent.conf comme utilisateur racine.
  2. Remplacez la configuration du plug-in de sortie BigQuery spécifié précédemment par les lignes suivantes. Remplacez [MY_PROJECT_NAME] par le nom de votre projet GCP.

    <match nginx.access>
      @type bigquery_load
    
      <buffer>
        @type file
        path /var/log/bigquery_nginx_access.*.buffer
        flush_at_shutdown true
        timekey_use_utc
        total_limit_size 1g
        flush_interval 3600
      </buffer>
    
      # Authenticate with BigQuery using the VM's service account.
      auth_method compute_engine
      project [MY_PROJECT_NAME]
      dataset fluentd
      table nginx_access
      fetch_schema true
    
      <inject>
        # Convert fluentd timestamp into TIMESTAMP string
        time_key time
        time_type string
        time_format %Y-%m-%dT%H:%M:%S.%NZ
      </inject>
    </match>
    

    Cette configuration spécifie que le plug-in de sortie bigquery_load doit être utilisé à la place du plug-in bigquery_insert.

    La section buffer spécifie que les données de journal sont mises en mémoire tampon dans la VM jusqu'à ce que 1 Go de journaux ait été collecté ou qu'une heure se soit écoulée. Les données mises en mémoire tampon sont ensuite chargées dans BigQuery. Pour plus d'informations sur les paramètres de configuration, consultez la documentation de référence du plug-in.

Dépannage

Si, à un moment quelconque, vous soupçonnez que l'agent ne collecte ni ne livre de journaux, vous pouvez vérifier son état en exécutant la commande suivante dans la fenêtre shell de la VM Fluentd :

sudo systemctl status td-agent

Le résultat indique l'état actif du service et les dernières lignes de journalisation du service :

Active: active (running) since [DATE]

Si l'agent ne démarre pas, l'erreur se trouve sûrement dans le fichier de configuration Fluentd. Ceci apparaît dans le fichier journal Fluentd que vous pouvez afficher en utilisant la commande suivante dans la fenêtre shell de la VM :

sudo less /var/log/td-agent/td-agent.log

Par exemple, le résultat suivant affiche une erreur lorsque le nom du plug-in est incorrect :

[info]: parsing config file is succeeded path="/etc/td-agent/td-agent.conf"
[error]: config error file="/etc/td-agent/td-agent.conf" error_class=Fluent::ConfigError error="Unknown output plugin 'bad_plugin'. Run 'gem search -rd fluent-plugin' to find plugins"

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

  1. Dans la console GCP, accédez à la page Projets.

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer delete.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…