Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Interrogation et affichage des journaux

Cette page fournit des instructions détaillées sur la façon d'interroger et de visualiser vos journaux à l'aide de l'interface utilisateur Grafana et de l'API Log Query pour obtenir des insights sur les événements et l'activité de votre service.

Après avoir collecté les journaux de vos charges de travail et services déployés dans Google Distributed Cloud (GDC) air-gapped, vous pouvez commencer à les analyser. Pour analyser les journaux, vous pouvez les visualiser et les filtrer dans des panneaux Grafana informatifs ou y accéder directement depuis l'API Log Query à l'aide d'appels HTTP ou gRPC pour un accès par programmation.

Vous pouvez accéder à vos journaux de l'une des deux manières suivantes :

Panneaux Grafana : obtenez des insights sur l'enregistrement d'activité de votre projet via le panneau "Log" de votre instance Grafana. Ce panneau vous permet d'interroger et d'identifier des journaux spécifiques, en fournissant une observabilité des données granulaires adaptée à vos besoins. Grafana fournit une interface conviviale pour filtrer et analyser les données de votre charge de travail, en créant des tableaux de bord et des panneaux personnalisés pour une visualisation complète.
API Log Query : pour un accès par programmation, interrogez les journaux directement à partir de l' API Log Query de votre projet. L' API Log Query est une API non Kubernetes qui accepte HTTP et gRPC, et qui vous expose ses propres points de terminaison. N'accédez à cette API que dans une organisation spécifique de Distributed Cloud en suivant les méthodes d'accès à l'API standards.

Avant de commencer

Pour obtenir les autorisations nécessaires pour interroger et visualiser les journaux dans l'interface utilisateur Grafana, demandez à votre administrateur IAM de l'organisation ou administrateur IAM du projet de vous accorder l'un des rôles prédéfinis de lecteur Grafana de l'organisation ou lecteur Grafana du projet. Selon le niveau d'accès et les autorisations dont vous avez besoin, vous pouvez obtenir des rôles Grafana dans une organisation ou un projet.

Vous pouvez également demander à votre administrateur IAM du projet de vous accorder le rôle d'interrogateur de l'API Log Query dans l'espace de noms de votre projet pour obtenir les autorisations nécessaires pour interroger les journaux à partir de l'API Log Query.

Pour en savoir plus sur ces rôles, consultez Préparer les autorisations IAM.

Interroger et filtrer vos journaux

Sélectionnez l'une des méthodes suivantes pour créer des requêtes et filtrer les journaux de vos charges de travail de projet :

Panneau "Log" de Grafana

Cette section explique comment accéder à vos journaux à l'aide du panneau "Log" de Grafana.

Identifier votre point de terminaison Grafana

L'URL suivante correspond au point de terminaison de l'instance Grafana de votre projet :

  https://GDC_URL/PROJECT_NAMESPACE/grafana

Remplacez les éléments suivants :

GDC_URL: URL de votre organisation dans GDC.
PROJECT_NAMESPACE : espace de noms de votre projet.

Par exemple, le point de terminaison Grafana du projet platform-obs dans l' org-1 organisation est https://org-1/platform-obs/grafana.

Afficher les journaux dans l'interface utilisateur Grafana

Interrogez les journaux dans l'interface utilisateur Grafana :

Dans la console GDC, sélectionnez votre projet.
Dans le menu de navigation, sélectionnez Operations > Logging (Opérations > Journalisation).
Cliquez sur View all in Grafana Loki (Tout afficher dans Grafana Loki).

Une nouvelle page s'ouvre sur votre point de terminaison Grafana et affiche l'interface utilisateur.
Dans l'interface utilisateur, cliquez sur explore Explore dans le menu de navigation pour ouvrir la page Explore.
Dans le menu de la barre Explore (Explorer), sélectionnez une source de données pour récupérer les journaux, en fonction du type d'univers :
- Univers à une seule zone : sélectionnez l'une des sources de données suivantes pour afficher les données de journalisation de la zone unique de votre univers :
  - Operational logs (Journaux opérationnels) : affiche les journaux opérationnels.
  - Audit logs (Journaux d'audit) : affiche les journaux d'audit.
- Univers multizones : Grafana peut se connecter à différentes zones et afficher des données interzones. Sélectionnez l'une des sources de données suivantes pour afficher les données de journalisation de n'importe quelle zone de votre univers, quelle que soit la zone dans laquelle vous êtes connecté :
  - Operational logs ZONE_NAME (Journaux opérationnels ZONE_NAME) : affiche les journaux opérationnels d'une zone spécifique.
  - Audit logs ZONE_NAME (Journaux d'audit) : affiche les journaux d'audit d'une zone spécifique.
  De plus, pour afficher des visualisations de données interzones dans un seul tableau de bord et ajouter plusieurs zones à votre requête, sélectionnez Mixed (Mixte) comme source de données.
  
  Remarque : Les journaux d'audit ne sont disponibles que pour les administrateurs de plate-forme, même s'ils ne peuvent pas créer ni configurer de cibles de journalisation d'audit. Les opérateurs d'application ne peuvent accéder qu'aux journaux opérationnels.
Saisissez une requête pour rechercher des journaux à partir du panneau "Log" à l'aide de LogQL (langage de requête Logging) expressions. Vous pouvez effectuer cette étape de l'une des deux manières suivantes :
- Utilisez l'interface interactive du générateur de requêtes. Cliquez ensuite sur Run query (Exécuter la requête).
- Saisissez votre requête directement dans le champ de texte, puis appuyez sur Maj+Entrée pour l'exécuter.
La page affiche les journaux correspondant à votre requête. Après avoir interrogé les journaux, vous pouvez les exporter. Cliquez sur Export (Exporter) pour télécharger les journaux au format texte brut ou CSV. Vous pouvez également sélectionner une période pour vos journaux.

Figure 1 : Option de menu permettant d'interroger les journaux d'audit à partir de l'interface utilisateur Grafana.

Dans la figure 1, l'option Audit logs (Journaux d'audit) affiche l'interface qui vous permet de créer des requêtes à partir de Grafana pour récupérer les journaux d'audit.

Pour obtenir des exemples de libellés et de valeurs permettant d'interroger différents journaux, consultez Exemples de requêtes et de libellés.

Sélectionner une période pour vos journaux

Pour interroger les journaux sur une période donnée, procédez comme suit :

Cliquez sur le menu Time Picker (Sélecteur de période) dans Grafana.
Dans le menu, effectuez l'une des actions suivantes :
- Sélectionnez des options de période relative, par exemple les 30 dernières minutes.
- Définissez des périodes absolues personnalisées en choisissant des dates et heures spécifiques dans le calendrier, puis en cliquant sur Apply time range (Appliquer la période).
Vous pouvez également cliquer sur Change time settings (Modifier les paramètres de période) pour modifier les paramètres Timezone (Fuseau horaire) et Fiscal year (Exercice fiscal) à partir des commandes de période.

Les paramètres de période sont enregistrés par tableau de bord. Pour en savoir plus sur les requêtes sur une période donnée, consultez https://grafana.com/docs/loki/latest/reference/api/#query-loki-over-a-range-of-time.

API Log Query

Cette section explique comment accéder à vos journaux à l'aide de l'API Log Query.

Identifier votre point de terminaison de l'API Log Query

L'API Log Query expose les deux points de terminaison suivants pour interroger les journaux d'audit et opérationnels :

Point de terminaison des journaux d'audit :
```
audit-log-query-api.ORG_DOMAIN
```
Remarque : Les journaux d'audit ne sont disponibles que pour les administrateurs de plate-forme, même si ils ne peuvent pas créer ni configurer de cibles de journalisation d'audit. Les opérateurs d'application ne peuvent accéder qu'aux journaux opérationnels.
Point de terminaison des journaux opérationnels :
```
operational-log-query-api.ORG_DOMAIN
```

Remplacez ORG_DOMAIN par le nom de domaine de l'organisation. Vous pouvez afficher cette propriété à l'aide de la commande gdcloud config list. Le nom de domaine doit suivre la syntaxe org-name.zone.google.gdch.com. Par exemple, une organisation nommée org-1, dans la zone zone1 et dans un environnement de test, possède un domaine tel que org-1.zone1.google.gdch.test.

L'API Log Query propose les trois options de point de terminaison suivantes :

labels : répertorie tous les libellés d'un projet.
labels/labels/LABEL/values : répertorie les valeurs de libellé spécifiques d'un projet.
logs : répertorie les journaux d'un projet spécifique.

Pour plus d'informations, consultez la section documentation de l'API.

Envoyer une requête

Envoyez une requête au point de terminaison de l'API Log Query à l'aide de clients HTTP ou gRPC.

HTTP

Suivez les instructions pour accéder directement à l'API avec un client HTTP. Vous pouvez vous appuyer sur kubectl pour gérer l'authentification ou la gérer vous-même.

Interrogez l'API Log Query à l'aide de clients HTTP tels que curl, wget ou un client HTTP que vous créez et gérez. L'exemple suivant utilise l'outil curl pour interroger l'API. Vous pouvez utiliser un format semblable pour les commandes wget :

Authentifiez la requête cURL :
1. Téléchargez et installez la gcloud CLI.
2. Définissez la propriété gdcloud core/organization_console_url :
```
gdcloud config set core/organization_console_url https://GDC_URL
```
  Remplacez GDC_URL par l'URL d'une organisation dans GDC.
3. Connectez-vous avec le fournisseur d'identité configuré :
```
gdcloud auth login
```
4. Utilisez votre nom d'utilisateur et votre mot de passe pour vous authentifier et vous connecter.
5. Exportez le jeton d'identité du compte spécifié vers une variable d'environnement :
```
export TOKEN="$($HOME/gdcloud auth print-identity-token --audiences=https://LOG_QUERY_API_ENDPOINT)"
```
  Remplacez LOG_QUERY_API_ENDPOINT par le point de terminaison de l'API Log Query à partir duquel vous souhaitez interroger les journaux et le domaine auquel vous souhaitez vous connecter. Par conséquent, la valeur de l'option audiences peut être, par exemple, https://operational-log-query-api.org-1.zone1.google.gdch.test.
  
  Une fois la connexion établie, vous pouvez utiliser l'en-tête d'autorisation dans votre requête cURL à l'aide de la commande gdcloud auth print-identity-token. Pour en savoir plus, consultez gdcloud auth print-identity-token.
Si vous souhaitez répertorier tous les libellés d'un projet, envoyez la requête suivante :
```
curl -H "Authorization: Bearer ${TOKEN}" \
https://LOG_QUERY_API_ENDPOINT/v1/projects/PROJECT_NAMESPACE/labels \
-H "Content-Type: application/json" -v
```
Remplacez les éléments suivants :
- LOG_QUERY_API_ENDPOINT : point de terminaison de l'API Log Query à partir duquel vous souhaitez interroger les journaux.
- PROJECT_NAMESPACE : espace de noms de votre projet.
Si vous souhaitez répertorier des valeurs de libellé spécifiques pour un projet, envoyez la requête suivante :
```
curl -H "Authorization: Bearer ${TOKEN}" \
https://LOG_QUERY_API_ENDPOINT/v1/projects/PROJECT_NAMESPACE/labels/labels/LABEL/values \
-H "Content-Type: application/json" -v
```
Remplacez les éléments suivants :
- LOG_QUERY_API_ENDPOINT : point de terminaison de l'API Log Query à partir duquel vous souhaitez interroger les journaux.
- PROJECT_NAMESPACE : espace de noms de votre projet.
- LABEL: libellé spécifique pour lequel vous souhaitez interroger sa valeur.
Si vous souhaitez interroger les journaux d'un projet spécifique, créez une requête logs_filter et incluez-la dans le corps de la requête :
```
curl -X GET -H "Authorization: Bearer ${TOKEN}" \
https://LOG_QUERY_API_ENDPOINT/v1/projects/PROJECT_NAMESPACE/logs \
-H "Content-Type: application/json" -d \
'{"logs_filter": {"labels_equal": {"LABEL": "LABEL_VALUE"}}}' -v
```
Remplacez les éléments suivants :
- LOG_QUERY_API_ENDPOINT : point de terminaison de l'API Log Query à partir duquel vous souhaitez interroger les journaux.
- PROJECT_NAMESPACE : espace de noms de votre projet.
- LABEL: libellé spécifique pour lequel vous souhaitez interroger les journaux.
- LABEL_VALUE: valeur de libellé pour laquelle vous souhaitez interroger les journaux.
Consultez la documentation de l'API pour afficher toutes les options permettant de créer une requête logs_filter.

gRPC

gRPC est largement compatible avec les langages de programmation et fournit une méthode de communication plus efficace que les clients HTTP.

Pour interroger les journaux à l'aide de gRPC, vous devez répondre aux prérequis suivants :

Créez votre propre bibliothèque cliente basée sur les buffers de protocole fournis par Google.
Implémentez l'authentification dans le client.
Implémentez les nouvelles tentatives.

Pour en savoir plus sur les buffers de protocole, consultez la documentation de l'API.

L'exemple suivant montre comment interroger les journaux à partir d'un programme Go à l'aide d'un client gRPC non authentifié. L'exemple suppose que vous avez créé un package golang qui inclut un fichier de compilation Bazel pour importer les dépendances de code :

Enregistrez le code suivant dans un programme Go nommé client.go :

package main
import (
        "context"
        "crypto/tls"
        "flag"
        "fmt"
        "google.golang.org/grpc/credentials"
        "google.golang.org/grpc/metadata"
        pb "<import path to generated log query api protos>/pkg/apis/public/logging/v1/proto"
        "google.golang.org/grpc"
)

var serverAddr = flag.String("server", "localhost:8080", "server address")

func main() {
        flag.Parse()
        tc := credentials.NewTLS(&tls.Config{InsecureSkipVerify: true})
        conn, err := grpc.Dial(*serverAddr, grpc.WithTransportCredentials(tc))

        if err != nil {
                panic(error.Error(fmt.Errorf("create client connection failed: %v", err)))
        }
        defer conn.Close()

        c := pb.NewLogsClient(conn)
        md := metadata.Pairs("clienttest", "test")
        ctx := metadata.NewOutgoingContext(context.Background(), md)

        err = listLabels(ctx, c, "project-foo")
        if err != nil {
                panic(error.Error(err))
        }

        if err := listLabelValues(ctx, c, "project-foo", "resource-bar"); err != nil {
                panic(error.Error(err))
        }

        if err := listLogs(ctx, c, "project-foo", &pb.ListLogsFilter{
                LabelsEqual:    map[string]string{"resource-bar": "resource-bar-value"},
                OrderAscending: true,
        }); err != nil {
                panic(error.Error(err))
        }
}

// List all labels for a project.

func listLabels(ctx context.Context, c pb.LogsClient, project string) error {
        lbr := &pb.ListLabelsRequest{
                Parent:   project,
                PageSize: 1000, // PageSize can be configured to limit the number of responses per page.
        }
        resp, err := c.ListLabels(ctx, lbr)
        if err != nil {
                return fmt.Errorf("list labels: %v", err)
        }
        fmt.Printf("%v", resp)
        return nil
}

// List specific label values for a project.

func listLabelValues(ctx context.Context, c pb.LogsClient, project string, label string) error {
        lbr := &pb.ListLabelValuesRequest{
                Parent:   project,
                Label:    label,
                PageSize: 1000, // PageSize can be configured to limit the number of responses per page.
        }
        resp, err := c.ListLabelValues(ctx, lbr)
        if err != nil {
                return fmt.Errorf("list label values: %v", err)
        }
        fmt.Printf("%v", resp)
        return nil
}

// List logs for a specific project.

func listLogs(ctx context.Context, c pb.LogsClient, project string, lf *pb.ListLogsFilter) error {
        lbr := &pb.ListLogsRequest{
                Parent:     project,
                LogsFilter: lf,
                PageSize:   5, // PageSize can be configured to limit the number of responses per page.
        }
        resp, err := c.ListLogs(ctx, lbr)
        if err != nil {
                return fmt.Errorf("list logs: %v", err)
        }
        fmt.Printf("logs: %v", resp)
        return nil
}

Exécutez le programme Go :
```
go run PATH_TO_API/client.go -server=LOG_QUERY_API_ENDPOINT:443
```
Remplacez les éléments suivants :
- PATH_TO_API : chemin d'accès au fichier API.
- LOG_QUERY_API_ENDPOINT : point de terminaison de l'API Log Query à partir duquel vous souhaitez interroger les journaux.
Si l'option de serveur n'est pas spécifiée, la requête par défaut est envoyée à localhost.

Exemples de requêtes et de libellés

Voici quelques-uns des libellés par défaut que vous pouvez utiliser pour interroger les journaux :

cluster : nom du cluster.
namespace : espace de noms de votre projet.
node : nom du nœud.
pod : nom du pod.
container : nom du conteneur.

Les exemples de code suivants montrent l'utilisation de libellés et de valeurs pour interroger différents journaux :

Sélectionnez les journaux du serveur :

{cluster="admin", namespace="kube-system", resources="k8s_container", container="kube-apiserver"}

Sélectionnez les journaux d'audit du cluster :
```
{cluster="admin", resources="k8s_audit"}
```