Utiliser des journaux exportés

Cette page explique comment localiser et utiliser vos entrées de journal exportées dans Cloud Storage, BigQuery et Cloud Pub/Sub.

Pour en savoir plus sur l'exportation des journaux, consultez la section Présentation des exportations de journaux.

Pour savoir comment exporter vos journaux, consultez les ressources suivantes :

Cloud Storage

Pour afficher vos journaux exportés dans Cloud Storage, procédez comme suit :

  1. Accédez au navigateur Cloud Storage dans la console GCP :

    Navigateur Cloud Storage

    1. Sélectionnez le bucket que vous utilisez pour l'exportation des journaux.

Consultez la section relative à l'organisation de Cloud Storage pour plus de détails sur la façon dont les journaux sont organisés dans le bucket.

Disponibilité des journaux exportés

Si vous ne voyez aucun journal exporté, vérifiez les métriques système relatives à l'exportation. Ces dernières peuvent vous indiquer le nombre d'entrées de journal exportées ou supprimées en raison d'erreurs. Si elles indiquent qu'aucune entrée de journal n'a été exportée, vérifiez votre filtre d'exportation pour vous assurer que les entrées correspondant à votre filtre ont récemment été reçues dans Stackdriver Logging :

Accéder à la page des exportations de journaux

Les entrées de journal sont enregistrées toutes les heures et sous forme de lots dans des buckets Cloud Storage. L'affichage des premières entrées peut prendre 2 à 3 heures.

Organisation des journaux exportés

Lorsque vous exportez des journaux vers un bucket Cloud Storage, Stackdriver Logging crée un ensemble de fichiers au sein du bucket. Les fichiers sont organisés en hiérarchies de répertoires classées par type de journal et par date. Le type de journal peut correspondre à un nom simple tel que syslog, ou à un nom composé comme appengine.googleapis.com/request_log. Si ces journaux sont stockés dans un bucket appelé my-gcs-bucket, les répertoires sont alors nommés comme dans l'exemple suivant :

my-gcs-bucket/syslog/YYYY/MM/DD/
my-gcs-bucket/appengine.googleapis.com/request_log/YYYY/MM/DD/

Un bucket peut contenir des journaux provenant de plusieurs types de ressources.

Stackdriver Logging ne garantit pas la déduplication des entrées de journal des récepteurs contenant des filtres identiques ou se chevauchant. Les entrées de journal de ces récepteurs peuvent être écrites plusieurs fois dans un bucket Cloud Storage.

Les répertoires feuilles (DD/) comportent plusieurs fichiers conservant chacun les entrées de journal exportées pendant une période spécifiée dans le nom de fichier. Les fichiers sont partitionnés et leur nom se termine par un numéro de partition, Sn ou An (n=0, 1, 2, etc.). Voici par exemple deux fichiers qui pourraient être stockés dans le répertoire my-gcs-bucket/syslog/2015/01/13/ :

08:00:00_08:59:59_S0.json
08:00:00_08:59:59_S1.json

Ces deux fichiers contiennent les entrées de journal de syslog pour toutes les instances entre 8 et 9 heures (UTC). Les horodatages d'entrée de journal utilisent l'heure UTC (temps universel coordonné).

Pour obtenir toutes les entrées de journal, vous devez consulter l'ensemble des partitions pour chaque période (dans le cas présent, les partitions de fichiers 0 et 1). Le nombre de partitions de fichiers rédigées peut varier pour chaque période en fonction du volume d'entrées de journal.

Dans les fichiers partitionnés individuels, les entrées de journal sont stockées sous la forme d'une liste d'objets LogEntry. Pour obtenir un exemple d'entrée de syslog, reportez-vous à la section relative au type LogEntry de cette page.

Notez que l'ordre de tri des entrées de journal dans les fichiers n'est ni uniforme, ni garanti.

BigQuery

Si vous souhaitez afficher vos journaux exportés dans BigQuery, procédez comme suit :

  1. Accédez à l'interface utilisateur de BigQuery dans la console GCP :

    Accéder à l'interface utilisateur de BigQuery

  2. Sélectionnez l'ensemble de données servant de destination à votre récepteur.

  3. Sélectionnez une table de l'ensemble de données. Les entrées de journal sont visibles dans l'onglet Détails. Vous pouvez également interroger la table pour qu'elle renvoie vos données.

Pour en savoir plus sur la façon dont les tables sont organisées, consultez la section Organisation des tables. Pour découvrir comment les champs des entrées de journal exportées sont nommés, consultez la section Schéma BigQuery des journaux exportés.

Disponibilité dans BigQuery

Si vous ne voyez aucun journal exporté, vérifiez les métriques système relatives à l'exportation. Ces dernières peuvent vous indiquer le nombre d'entrées de journal exportées ou supprimées en raison d'erreurs. Si elles indiquent qu'aucune entrée de journal n'a été exportée, vérifiez votre filtre d'exportation pour vous assurer que les entrées correspondant à votre filtre ont récemment été reçues dans Stackdriver Logging :

Accéder à la page des exportations de journaux

Les entrées de journal sont enregistrées dans BigQuery sous forme de lots. Les premières entrées peuvent mettre quelques minutes à apparaître.

Organisation des tables

Lorsque vous exportez des journaux vers un ensemble de données BigQuery, Stackdriver Logging crée des tables datées qui conservent les entrées de journal exportées. Le nom de ces tables est basé sur le nom des entrées de journal et sur leur horodatage1. Le tableau suivant vous explique la façon dont les noms des journaux et les horodatages sont mappés au nom des tables :

Nom du journal Horodatage d'entrée de journal1 Nom de la table BigQuery
syslog 2017-05-23T18:19:22.135Z syslog_20170523
apache-access 2017-01-01T00:00:00.000Z apache_access_20170101
compute.googleapis.com/activity_log 2017-12-31T23:59:59.999Z compute_googleapis_com_activity_log_20171231

1 : Les horodatages d'entrée de journal utilisent l'heure UTC (temps universel coordonné).

Schémas et champs

Les schémas de table BigQuery pour les journaux exportés se basent sur la structure du type LogEntry et sur le contenu des charges utiles des journaux. Vous pouvez afficher un schéma depuis l'interface utilisateur Web de BigQuery en sélectionnant une table comportant des entrées de journal exportées.

Le schéma de table BigQuery utilisé pour représenter les charges utiles d'entrée de journal complexes peut être source de confusion. Dans le cas des journaux d'audit exportés, certaines règles de dénomination spéciales sont utilisées. Pour en savoir plus, consultez la section Schéma BigQuery des journaux exportés.

Requêtes

Pour obtenir des exemples de requêtes impliquant des journaux d'audit exportés dans BigQuery, reportez-vous à la section relative aux requêtes sur les journaux d'audit BigQuery.

Pour en savoir plus sur les requêtes BigQuery, consultez la documentation de référence sur les requêtes. Les fonctions de caractères génériques de table sont particulièrement utiles et offrent la possibilité d'exécuter des requêtes sur plusieurs tables. L'opérateur FLATTEN est également très pratique, car il permet d'afficher des données à partir de champs répétés.

Exemple de requête concernant les journaux Compute Engine

La requête BigQuery suivante récupère les entrées de journal de plusieurs jours et de différents types de journaux :

  • La requête recherche les trois derniers jours des journaux syslog et apache-access. Elle a été exécutée le 23 février 2015 et couvre toutes les entrées de journal reçues les 21 et 22 février, ainsi que les entrées reçues le 23 février jusqu'à la création de la requête.

  • La requête récupère les résultats d'une seule instance de Compute Engine : 1554300700000000000.

  • La requête ignore le trafic provenant du vérificateur d'état du point de terminaison Stackdriver Monitoring, Stackdriver_terminus_bot.

SELECT
  timestamp AS Time,
  logName as Log,
  textPayload AS Message
FROM
  (TABLE_DATE_RANGE(my_bq_dataset.syslog_,
    DATE_ADD(CURRENT_TIMESTAMP(), -2, 'DAY'), CURRENT_TIMESTAMP())),
  (TABLE_DATE_RANGE(my_bq_dataset.apache_access_,
    DATE_ADD(CURRENT_TIMESTAMP(), -2, 'DAY'), CURRENT_TIMESTAMP()))
WHERE
  resource.type == 'gce_instance'
  AND resource.labels.instance_id == '1554300700000000000'
  AND NOT (textPayload CONTAINS 'Stackdriver_terminus_bot')
ORDER BY time;

Voici quelques exemples de lignes de sortie :

Row | Time                    | Log                                         | Message
--- | ----------------------- | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------
 5  | 2015-02-21 03:40:14 UTC | projects/project-id/logs/syslog             | Feb 21 03:40:14 my-gce-instance collectd[24281]: uc_update: Value too old: name = 15543007601548826368/df-tmpfs/df_complex-used; value time = 1424490014.269; last cache update = 1424490014.269;
 6  | 2015-02-21 04:17:01 UTC | projects/project-id/logs/syslog             | Feb 21 04:17:01 my-gce-instance /USR/SBIN/CRON[8082]: (root) CMD ( cd / && run-parts --report /etc/cron.hourly)
 7  | 2015-02-21 04:49:58 UTC | projects/project-id/logs/apache-access      | 128.61.240.66 - - [21/Feb/2015:04:49:58 +0000] "GET / HTTP/1.0" 200 536 "-" "masscan/1.0 (https://github.com/robertdavidgraham/masscan)"
 8  | 2015-02-21 05:17:01 UTC | projects/project-id/logs/syslog             | Feb 21 05:17:01 my-gce-instance /USR/SBIN/CRON[9104]: (root) CMD ( cd / && run-parts --report /etc/cron.hourly)
 9  | 2015-02-21 05:30:50 UTC | projects/project-id/log/syslogapache-access | 92.254.50.61 - - [21/Feb/2015:05:30:50 +0000] "GET /tmUnblock.cgi HTTP/1.1" 400 541 "-" "-"

Exemple de requête concernant les journaux App Engine

La requête BigQuery suivante récupère les requêtes App Engine du mois dernier qui n'ont pas abouti :

SELECT
  timestamp AS Time,
  protoPayload.host AS Host,
  protoPayload.status AS Status,
  protoPayload.resource AS Path
FROM
  (TABLE_DATE_RANGE(my_bq_dataset.appengine_googleapis_com_request_log_,
    DATE_ADD(CURRENT_TIMESTAMP(), -1, 'MONTH'), CURRENT_TIMESTAMP()))
WHERE
  protoPayload.status != 200
ORDER BY time

Voici une partie des résultats :

Row | Time                    | Host                                  | Status | Path
--- | ----------------------- | ------------------------------------- | ------ | ------
 6  | 2015-02-12 19:35:02 UTC | default.my-gcp-project-id.appspot.com |    404 | /foo?thud=3
 7  | 2015-02-12 19:35:21 UTC | default.my-gcp-project-id.appspot.com |    404 | /foo
 8  | 2015-02-16 20:17:19 UTC | my-gcp-project-id.appspot.com         |    404 | /favicon.ico
 9  | 2015-02-16 20:17:34 UTC | my-gcp-project-id.appspot.com         |    404 | /foo?thud=%22what???%22

Cloud Pub/Sub

Pour afficher vos journaux exportés au fur et à mesure qu'ils sont diffusés via Cloud Pub/Sub, procédez comme suit :

  1. Accédez à la page Cloud Pub/Sub dans la console GCP :

    Accéder à Cloud Pub/Sub

  2. Recherchez ou créez un abonnement au sujet utilisé pour l'exportation des journaux, puis extrayez une entrée de journal. Vous devrez peut-être attendre la publication d'une nouvelle entrée.

Consultez la section Organisation des journaux exportés pour en savoir plus sur l'organisation des journaux.

Disponibilité des journaux exportés

Si vous ne voyez aucun journal exporté, vérifiez les métriques système relatives à l'exportation. Ces dernières peuvent vous indiquer le nombre d'entrées de journal exportées ou supprimées en raison d'erreurs. Si elles indiquent qu'aucune entrée de journal n'a été exportée, vérifiez votre filtre d'exportation pour vous assurer que les entrées correspondant à votre filtre ont récemment été reçues dans Stackdriver Logging :

Accéder à la page des exportations de journaux

Lorsque vous exportez des journaux dans un sujet Cloud Pub/Sub, Stackdriver Logging publie chaque entrée de journal en tant que message Cloud Pub/Sub dès qu'il la reçoit.

Organisation des journaux exportés

Le champ data de chaque message correspond à un objet LogEntry encodé en base64. Un abonné Cloud Pub/Sub peut par exemple extraire l'objet suivant d'un sujet qui reçoit des entrées de journal. L'objet affiché contient une liste qui ne comprend qu'un seul message. Notez toutefois que Cloud Pub/Sub peut renvoyer plusieurs messages lorsque plusieurs entrées de journal sont disponibles. Nous avons raccourci les valeurs data (d'environ 600 caractères) et ackId (d'environ 200 caractères) pour rendre l'exemple plus lisible :

{
 "receivedMessages": [
  {
   "ackId": "dR1JHlAbEGEIBERNK0EPKVgUWQYyODM...QlVWBwY9HFELH3cOAjYYFlcGICIjIg",
   "message": {
    "data": "eyJtZXRhZGF0YSI6eyJzZXZ0eSI6Il...Dk0OTU2G9nIjoiaGVsbG93b3JsZC5sb2cifQ==",
    "attributes": {
     "compute.googleapis.com/resource_type": "instance",
     "compute.googleapis.com/resource_id": "123456"
    },
    "messageId": "43913662360"
   }
  }
 ]
}

Si vous décodez le champ data et le mettez en forme, vous obtenez l'objet LogEntry suivant :

{
  "log": "helloworld.log",
  "insertId": "2015-04-15|11:41:00.577447-07|10.52.166.198|-1694494956",
  "textPayload": "Wed Apr 15 20:40:51 CEST 2015 Hello, world!",
  "timestamp": "2015-04-15T18:40:56Z",
  "labels": {
    "compute.googleapis.com\/resource_type": "instance",
    "compute.googleapis.com\/resource_id": "123456"
  },
  "severity": "WARNING"
  }
}

Objets d'entrées de journal

Les entrées de journal de Stackdriver Logging correspondent à des objets de type LogEntry. Les champs les plus importants de l'entrée de journal sont indiqués dans le tableau suivant :

Toutes les entrées de journal ayant un [LOG_ID] particulier partagent généralement le même format. Chaque type de journal documente le contenu du champ de charge utile lui étant associé. Consultez l'index des journaux Stackdriver Logging pour obtenir des exemples. Voici quelques exemples d'entrées de journal :

syslog

Le journal syslog de Compute Engine est un type de journal personnalisé produit par l'agent de journalisation google-fluentd qui s'exécute sur des instances de machine virtuelle :

{
  logName: "projects/my-gcp-project-id/logs/syslog",
  timestamp: "2015-01-13T19:17:01Z",
  resource: {
    type: "gce_instance",
    labels: {
      instance_id: "12345",
      zone: "us-central1-a",
      project_id: "my-gcp-project-id"
    }
  },
  insertId: "abcde12345",
  textPayload: "Jan 13 19:17:01 my-gce-instance /USR/SBIN/CRON[29980]: (root) CMD (   cd / && run-parts --report /etc/cron.hourly)"
}

request_log

Le journal request_log d'App Engine contient des entrées comportant des champs protoPayload qui incluent des objets de type RequestLog :

{
  logName: "projects/my-gcp-project-id/logs/appengine.googleapis.com%2Frequest_log",
  timestamp: "2015-01-13T19:00:39.796169Z",
  resource: {
    type: "gae_app",
    labels: {
      module_id: "default",
      zone: "us6",
      project_id: "my-gcp-project-id",
      version_id: "20150925t173233"
    }
  }
  httpRequest: {
    status: 200
  }
  insertId: "abcde12345",
  operation: {
    id: "abc123",
    producer: "appengine.googleapis.com/request_id",
    first: true,
    last: true
  }
  protoPayload: {
    @type: "type.googleapis.com/google.appengine.logging.v1.RequestLog"
    versionId: "20150925t173233",
    status: 200,
    startTime: "2017-01-13T19:00:39.796169Z",
    # ...
    appId: "s~my-gcp-project-id",
    appEngineRelease: "1.9.17",
  }
}

activity

Le journal activity est un journal d'audit pour les activités d'administration. Sa charge utile est une représentation JSON de type AuditLog :

{
 logName: "projects/my-gcp-project-id/logs/cloudaudit.googleapis.com%2Factivity"
 timestamp: "2017-04-22T13:41:32.245Z"
 severity: "NOTICE"
 resource: {
  type: "gce_instance"
  labels: {
   instance_id: "2403273232180765234"
   zone: "us-central1-b"
   project_id: "my-gcp-project-id"
  }
 }
 insertId: "54DC1882F4B49.A4996C2.6A02F4C1"
 operation: {
  id: "operation-1492868454262-54dc185e9a4f0-249fe233-f73d472a"
  producer: "compute.googleapis.com"
  last: true
 }
 protoPayload: {
  @type: "type.googleapis.com/google.cloud.audit.AuditLog"
  authenticationInfo: {
   principalEmail: "649517127304@cloudservices.gserviceaccount.com"
  }
  requestMetadata: {…}
  serviceName: "compute.googleapis.com"
  methodName: "v1.compute.instances.delete"
  resourceName: "projects/my-gcp-project-id/zones/us-central1-b/instances/abc123"
 }
}

Entrées de journal tardives

Les entrées de journal exportées sont enregistrées par lots toutes les heures dans des buckets Cloud Storage. L'affichage des premières entrées peut prendre 2 à 3 heures. Les partitions de fichiers journaux exportés qui possèdent le suffixe An ("Append", ajout) contiennent les entrées de journal arrivées en retard.

En outre, lorsque la requête générant l'activité de journalisation est exécutée, App Engine combine plusieurs sous-entrées de type google.appengine.logging.v1.LogLine (également appelées AppLog ou AppLogLine) sous une entrée de journal principale de type google.appengine.logging.v1.RequestLog. Les lignes de journal possèdent chacune un "ID de requête" qui identifie l'entrée principale. La visionneuse de journaux affiche les lignes de journal avec l'entrée de journal de la requête. Stackdriver Logging tente alors de placer toutes les lignes de journal dans le lot avec la requête d'origine, même si leur horodatage les placerait normalement dans le lot suivant. En cas d'impossibilité, il peut manquer certaines lignes à l'entrée de journal de la requête, et le lot suivant peut contenir des lignes de journal "orphelines" sans requête. Si vous souhaitez éviter ceci, préparez-vous à reconstituer les éléments de la requête lorsque vous traitez vos journaux.

Intégration de Cloud Pub/Sub avec des services tiers

Stackdriver Logging autorise l'intégration de la journalisation avec des services tiers. Consultez la documentation sur les intégrations Stackdriver pour obtenir une liste actualisée des intégrations.

Exportez vos journaux via un sujet Cloud Pub/Sub. Le service tiers les recevra en s'abonnant au même sujet.

Pour effectuer l'intégration, attendez-vous à effectuer une démarche semblable à la suivante :

  1. Demandez au service tiers de vous fournir un nom de compte de service Google Cloud Platform (GCP) créé à partir de son projet GCP. Par exemple, 12345-xyz@developer.gserviceaccount.com. Ce nom vous permet ensuite d'autoriser le service tiers à recevoir vos journaux.

  2. Accédez au projet contenant les journaux :

    Activer l'API.

  3. Créer un sujet Pub/Sub Vous pouvez effectuer cette opération lors de la configuration d'un récepteur de journaux ou en procédant comme suit :

    1. Accédez à la liste des sujets Pub/Sub.
    2. Sélectionnez Créer un sujet et saisissez un nom de sujet. Par exemple, projects/my-project-id/topics/my-pubsub-topic. Exportez vos journaux vers ce sujet.
    3. Sélectionnez Créer.
    4. Autorisez Stackdriver Logging à exporter les journaux vers le sujet. Pour en savoir plus, consultez la section Définir des autorisations pour Cloud Pub/Sub.
  4. Autorisez le service tiers à s'abonner à votre sujet :

    1. Restez sur la liste des sujets Pub/Sub pour votre projet dans la console GCP.
    2. Sélectionnez votre nouveau sujet.
    3. Sélectionnez Autorisations.
    4. Saisissez le nom du compte de service du service tiers.
    5. Dans le menu Sélectionner un rôle, sélectionnez Abonné Pub/Sub.
    6. Sélectionnez Ajouter.
  5. Fournissez le nom de votre sujet Cloud Pub/Sub au service tiers. Par exemple, projects/my-project-number/topics/my-pubsub-topic. Le service tiers doit d'abord s'abonner au sujet pour que vous puissiez exporter des journaux.

  6. Une fois le service tiers abonné à votre sujet, vous pouvez commencer à exporter des journaux.

    1. Dans votre projet contenant les journaux que vous souhaitez exporter, cliquez sur Créer une exportation au-dessus du champ de filtres de recherche. Le panneau Edit Export (Modifier l'exportation) s'affiche :

      Panneau "Modifier l'exportation"

    2. Indiquez un nom sous Sink Name (Nom de récepteur).

    3. Dans le menu Sink Service (Service du récepteur), sélectionnez Cloud Pub/Sub.

    4. Dans le menu Sink Destination (Destination du récepteur), sélectionnez le sujet Cloud Pub/Sub auquel le service tiers est abonné.

    5. Sélectionnez Create Sink (Créer un récepteur) pour commencer l'exportation.

    6. Une boîte de dialogue Récepteur créé s'affiche. Elle vous indique que votre récepteur d'exportation a bien été créé et qu'il dispose des autorisations nécessaires pour écrire les entrées de futurs journaux correspondants dans la destination que vous avez sélectionnée.

Le service tiers devrait commencer à recevoir immédiatement les entrées de journal.

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

Envoyer des commentaires concernant…

Stackdriver Logging
Besoin d'aide ? Consultez notre page d'assistance.