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 afin d'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) avec isolation physique, vous pouvez commencer à les analyser. Pour analyser les journaux, vous pouvez les visualiser et les filtrer sur 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 programmatique.

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 "Journaux" de votre instance Grafana. Ce panneau vous permet d'interroger et d'identifier des journaux spécifiques, ce qui vous offre une observabilité précise des données, adaptée à vos besoins. Grafana fournit une interface conviviale pour filtrer et analyser les données de vos charges de travail, et créer des tableaux de bord et des panneaux personnalisés pour une visualisation complète.
API Log Query : pour un accès programmatique, 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. Accédez à cette API uniquement au sein d'une organisation spécifique dans Distributed Cloud en suivant les méthodes d'accès aux API standards.

Avant de commencer

Pour interroger et visualiser les journaux, vous devez disposer des autorisations nécessaires.

Demander des rôles IAM au niveau de l'organisation

Contactez l'administrateur IAM de votre organisation pour demander les rôles suivants :

Lecteur Grafana de l'organisation (organization-grafana-viewer) : permet de visualiser les données d'observabilité liées à l'organisation sur les tableaux de bord de l'instance de surveillance Grafana.
Demandeur de journaux (log-query-api-querier-pa) : accède à l'API Log Query pour interroger les journaux de la plate-forme dans le projet platform-obs.

Demander des rôles IAM au niveau du projet

Contactez l'administrateur IAM de votre projet pour demander les rôles suivants :

Lecteur Grafana du projet (project-grafana-viewer) : permet de visualiser les données d'observabilité liées au projet sur les tableaux de bord de l'instance de surveillance Grafana dans l'espace de noms du projet.
Lecteur de journaux (log-query-api-querier) : accède à l'API Log Query pour interroger les journaux d'application dans l'espace de noms du projet.

Le tableau suivant récapitule les exigences de Role pour les personas PA et AO :

Persona	Objet	Cluster	Rôle	Espace de noms	Groupe/Utilisateur
PA	`grafana`	serveur d'API de gestion	`project-grafana-viewer`	`platform-obs`	Groupe
PA	`log-query-api`	serveur d'API de gestion	`log-query-api-querier-pa`	`platform-obs`	Groupe
PA	`grafana`	serveur d'API de gestion	`project-grafana-viewer`	`platform-obs`	Utilisateur
PA	`log-query-api`	serveur d'API de gestion	`log-query-api-querier-pa`	`platform-obs`	Utilisateur
AO	`grafana`	serveur d'API de gestion	`project-grafana-viewer`	`PROJECT_NAMESPACE`	Groupe
AO	`log-query-api`	serveur d'API de gestion	`log-query-api-querier`	`PROJECT_NAMESPACE`	Groupe
AO	`grafana`	serveur d'API de gestion	`project-grafana-viewer`	`PROJECT_NAMESPACE`	Utilisateur
AO	`log-query-api`	serveur d'API de gestion	`log-query-api-querier`	`PROJECT_NAMESPACE`	Utilisateur

Sélectionnez l'une des configurations suivantes pour accorder à Grafana l'accès à un groupe d'utilisateurs (Config 1) ou à un utilisateur individuel (Config 2) sur le serveur de l'API de gestion. Pour chaque configuration, vous pouvez exécuter la commande kubectl pour créer directement le RoleBinding, ou enregistrer le fichier manifeste YAML RoleBinding dans le chemin d'accès au fichier Infrastructure as Code (IaC) spécifié pour l'appliquer via GitOps :

Configuration 1

Cette configuration accorde à un groupe d'utilisateurs les autorisations d'accès à PA et AO Grafana sur le serveur de l'API de gestion. Après avoir défini cette configuration, reportez-vous à la section Tableaux de bord Grafana de ce document pour afficher les journaux sur Grafana.

Commande kubectl

Exécutez la commande suivante pour créer directement le RoleBinding :

kubectl --kubeconfig KUBECONFIG create rolebinding RULE_NAME -n platform-obs --group=GROUP_NAME --role=project-grafana-viewer

Exemple :

kubectl --kubeconfig KUBECONFIG_PATH create rolebinding project-grafana-viewers-binding --role=project-grafana-viewer --group=my-team --namespace=platform-obs

Chemin d'accès au fichier IaC

Vous pouvez également créer le fichier YAML pour gérer RoleBinding à l'aide d'IaC. Pour ce faire, créez le fichier YAML au chemin d'accès suivant :
```
/infrastructure/zonal/zones/ZONE/org-admin/rolebindings/GROUP_NAME/YAML_FILE
```

Fichier YAML

Enregistrez le fichier manifeste RoleBinding suivant dans le fichier YAML au chemin d'accès du fichier IaC :

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: RULE_NAME
  namespace: platform-obs
subjects:
- kind: Group
  name: GROUP_NAME
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: project-grafana-viewer
  apiGroup: rbac.authorization.k8s.io

Configuration 2

Cette configuration accorde à un utilisateur les autorisations nécessaires pour accéder à PA et AO Grafana sur le serveur de l'API de gestion. Après avoir configuré cette configuration, consultez la section Tableaux de bord Grafana de ce document pour afficher les journaux sur Grafana.

Commande kubectl

Exécutez la commande suivante pour créer directement le RoleBinding :

kubectl --kubeconfig KUBECONFIG create rolebinding RULE_NAME -n platform-obs --user=EMAIL_ADDRESS --role=project-grafana-viewer

Exemple :

kubectl --kubeconfig KUBECONFIG_PATH create rolebinding project-grafana-viewers-binding --role=project-grafana-viewer --user=my-email@example.com --namespace=platform-obs

Chemin d'accès au fichier IaC

Vous pouvez également créer le fichier YAML pour gérer RoleBinding à l'aide d'IaC. Pour ce faire, créez le fichier YAML au chemin d'accès suivant :
```
/infrastructure/zonal/zones/ZONE/org-admin/rolebindings/EMAIL_ADDRESS/YAML_FILE
```

Fichier YAML

Enregistrez le fichier manifeste RoleBinding suivant dans le fichier YAML au chemin d'accès du fichier IaC :

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: RULE_NAME
  namespace: platform-obs
subjects:
- kind: User
  name: EMAIL_ADDRESS
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: project-grafana-viewer
  apiGroup: rbac.authorization.k8s.io

Remplacez les éléments suivants :

KUBECONFIG : chemin d'accès au fichier kubeconfig du cluster spécifique contenant le NAMESPACE auquel ce RoleBinding est appliqué.
KUBECONFIG_PATH : chemin d'accès au fichier kubeconfig dans les exemples de commandes.
RULE_NAME : nom unique de cette ressource RoleBinding dans l'espace de noms, tel que pa-project-grafana-viewer.
NAMESPACE : espace de noms Kubernetes dans lequel ce RoleBinding est créé et appliqué. Recherchez la colonne Namespace dans le tableau précédent.
EMAIL_ADDRESS : identifiant de l'utilisateur auquel le rôle est accordé, par exemple application-operator@example.com.
ROLE : nom du Role contenant les autorisations que vous souhaitez accorder à l'utilisateur. Recherchez les rôles disponibles dans le tableau précédent.
GROUP_NAME : nom du Group auquel appartient l'utilisateur de l'AP, par exemple pa-group.
ZONE : nom de la zone.
YAML_FILE : nom du fichier YAML pour la ressource RoleBinding.

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 des charges de travail de votre projet :

Panneau de journaux Grafana

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

Identifier votre point de terminaison Grafana

L'URL suivante est le 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 pour le projet platform-obs dans l'organisation org-1 est https://org-1/platform-obs/grafana.

Afficher les journaux dans l'interface utilisateur de Grafana

Interrogez les journaux dans l'interface utilisateur de Grafana :

Dans la console GDC, sélectionnez votre projet.
Dans le menu de navigation, sélectionnez Opérations > Journalisation.
Cliquez sur Tout afficher dans Grafana Loki.

Une nouvelle page ouvre votre point de terminaison Grafana et affiche l'interface utilisateur.
Dans l'interface utilisateur, cliquez sur Explorer Explorer dans le menu de navigation pour ouvrir la page Explorer.
Dans le menu de la barre Explorer, sélectionnez une source de données pour récupérer les journaux, en fonction de votre type d'univers :
- Univers à zone unique : sélectionnez l'une des sources de données suivantes pour afficher les données de journalisation de la zone unique de votre univers :
  - Journaux opérationnels : affichez les journaux opérationnels.
  - 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 à laquelle vous êtes connecté :
  - Journaux opérationnels ZONE_NAME : affichez les journaux opérationnels d'une zone particulière.
  - Journaux d'audit ZONE_NAME : affichez les journaux d'audit d'une zone spécifique.
  De plus, pour obtenir des visualisations de données interzones dans un seul tableau de bord et ajouter plusieurs zones à votre requête, sélectionnez 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 dans le panneau "Journaux" à l'aide d'expressions LogQL (Log Query Language). 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 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 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 de Grafana.

Dans la figure 1, l'option 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 d'étiquettes et de valeurs permettant d'interroger différents journaux, consultez Exemples de requêtes et d'étiquettes.

Sélectionnez une période pour vos journaux

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

Cliquez sur le menu 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 plages de temps absolues personnalisées en choisissant des dates et heures spécifiques dans le calendrier, puis en cliquant sur Appliquer la période.
Vous pouvez également cliquer sur Modifier les paramètres de temps pour modifier les paramètres Fuseau horaire et Exercice dans les commandes de période.

Les paramètres temporels sont enregistrés pour chaque 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 le 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 du journal 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 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.
Point de terminaison du journal opérationnel :
```
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 respecter 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 : liste tous les libellés d'un projet.
labels/labels/LABEL/values : liste les valeurs d'un libellé spécifique pour un projet.
logs : liste les journaux d'un projet spécifique.

Pour en savoir plus, consultez la 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 compter 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 similaire pour les commandes wget :

Authentifiez la requête cURL :
1. Téléchargez et installez la CLI gdcloud.
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 du signalement 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 lister toutes les étiquettes 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 lister des valeurs d'étiquettes 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 : étiquette spécifique pour laquelle 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 d'étiquette pour laquelle vous souhaitez interroger les journaux.
Consultez la documentation de l'API pour découvrir toutes les options permettant de créer une requête logs_filter.

gRPC

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

Pour interroger des journaux à l'aide de gRPC, vous devez remplir les conditions préalables suivantes :

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

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

L'exemple suivant montre comment interroger des 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 d'étiquettes

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

cluster : nom du cluster.
namespace : l'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 comment utiliser des étiquettes et des valeurs pour interroger différents journaux :

Sélectionnez les journaux de 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"}
```