Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Logs abfragen und ansehen

Auf dieser Seite finden Sie eine detaillierte Anleitung zum Abfragen und Visualisieren Ihrer Logs mit der Grafana-Benutzeroberfläche und der Log Query API, um Einblicke in Ihre Dienstereignisse und -aktivitäten zu erhalten.

Nachdem Sie Logs von Ihren bereitgestellten Arbeitslasten und Diensten in Google Distributed Cloud (GDC) mit Air Gap erfasst haben, können Sie mit der Analyse beginnen. Zum Analysieren von Logs können Sie sie in informativen Grafana-Bereichen visualisieren und filtern oder direkt über die Log Query API mit HTTP- oder gRPC-Aufrufen für den programmatischen Zugriff darauf zugreifen.

Sie können auf zwei Arten auf Ihre Logs zugreifen:

Grafana-Panels: Im Log-Panel Ihrer Grafana-Instanz können Sie sich den Aktivitätsverlauf Ihres Projekts ansehen. In diesem Bereich können Sie bestimmte Logs abfragen und lokalisieren. So erhalten Sie eine detaillierte Datenbeobachtbarkeit, die auf Ihre Anforderungen zugeschnitten ist. Grafana bietet eine nutzerfreundliche Oberfläche zum Filtern und Analysieren Ihrer Arbeitslastdaten sowie zum Erstellen benutzerdefinierter Dashboards und Bereiche für eine umfassende Visualisierung.
Log Query API: Für den programmatischen Zugriff können Sie Logs direkt über die Log Query API Ihres Projekts abfragen. Die Log Query API ist eine Nicht-Kubernetes-API, die HTTP und gRPC unterstützt und eigene Endpunkte bereitstellt. Greifen Sie nur innerhalb einer bestimmten Organisation in Distributed Cloud auf diese API zu, indem Sie die Standardmethoden für den API-Zugriff verwenden.

Hinweis

Zum Abfragen und Visualisieren von Logs benötigen Sie die erforderlichen Berechtigungen.

IAM-Organisationsrollen anfordern

Wenden Sie sich an den IAM-Administrator Ihrer Organisation, um die folgenden Rollen anzufordern:

Organization Grafana Viewer (organization-grafana-viewer): Visualisieren Sie organisationsbezogene Beobachtbarkeitsdaten auf Dashboards der Grafana-Monitoring-Instanz.
Log Querier (log-query-api-querier-pa): Zugriff auf die Log Query API, um Plattformlogs im Projekt platform-obs abzufragen.

IAM-Projektrollen anfordern

Wenden Sie sich an den IAM-Administrator Ihres Projekts, um die folgenden Rollen anzufordern:

Project Grafana Viewer (project-grafana-viewer): Visualisieren Sie projektbezogene Observability-Daten in Dashboards der Grafana-Monitoring-Instanz im Projekt-Namespace.
Log Querier (log-query-api-querier): Zugriff auf die Log Query API, um Anwendungslogs im Projekt-Namespace abzufragen.

In der folgenden Tabelle sind die Role-Anforderungen für die PA- und AO-Personas zusammengefasst:

Persona	Objekt	Cluster	Rolle	Namespace	Gruppe/Nutzer
PA	`grafana`	Management API-Server	`project-grafana-viewer`	`platform-obs`	Gruppe
PA	`log-query-api`	Management API-Server	`log-query-api-querier-pa`	`platform-obs`	Gruppe
PA	`grafana`	Management API-Server	`project-grafana-viewer`	`platform-obs`	Nutzer
PA	`log-query-api`	Management API-Server	`log-query-api-querier-pa`	`platform-obs`	Nutzer
AO	`grafana`	Management API-Server	`project-grafana-viewer`	`PROJECT_NAMESPACE`	Gruppe
AO	`log-query-api`	Management API-Server	`log-query-api-querier`	`PROJECT_NAMESPACE`	Gruppe
AO	`grafana`	Management API-Server	`project-grafana-viewer`	`PROJECT_NAMESPACE`	Nutzer
AO	`log-query-api`	Management API-Server	`log-query-api-querier`	`PROJECT_NAMESPACE`	Nutzer

Wählen Sie eine der folgenden Konfigurationen aus, um Grafana Zugriff auf eine Nutzergruppe (Config 1) oder einen einzelnen Nutzer (Config 2) auf dem Management API-Server zu gewähren. Für jede Konfiguration können Sie entweder den Befehl kubectl ausführen, um die RoleBinding direkt zu erstellen, oder das RoleBinding-YAML-Manifest im angegebenen Infrastructure as Code-Dateipfad (IaC) speichern, um es über GitOps anzuwenden:

Konfiguration 1

Mit dieser Konfiguration werden einer Nutzergruppe Berechtigungen für den Zugriff auf PA- und AO-Grafana auf dem Verwaltungs-API-Server gewährt. Nachdem Sie diese Konfiguration eingerichtet haben, finden Sie im Abschnitt Grafana-Dashboards dieses Dokuments Informationen zum Aufrufen von Logs in Grafana.

kubectl-Befehl

Führen Sie den folgenden Befehl aus, um die RoleBinding direkt zu erstellen:

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

Beispiel:

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

IaC-Dateipfad

Alternativ können Sie die YAML-Datei im folgenden Pfad erstellen, um die RoleBinding mit IaC zu verwalten:
```
/infrastructure/zonal/zones/ZONE/org-admin/rolebindings/GROUP_NAME/YAML_FILE
```

YAML-Datei

Speichern Sie das folgende RoleBinding-Manifest in der YAML-Datei im IaC-Dateipfad:

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

Konfiguration 2

Mit dieser Konfiguration werden einem Nutzer Berechtigungen für den Zugriff auf PA- und AO-Grafana auf dem Verwaltungs-API-Server gewährt. Nachdem Sie diese Konfiguration eingerichtet haben, finden Sie im Abschnitt Grafana-Dashboards dieses Dokuments Informationen zum Aufrufen von Logs in Grafana.

kubectl-Befehl

Führen Sie den folgenden Befehl aus, um die RoleBinding direkt zu erstellen:

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

Beispiel:

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

IaC-Dateipfad

Alternativ können Sie die YAML-Datei im folgenden Pfad erstellen, um die RoleBinding mit IaC zu verwalten:
```
/infrastructure/zonal/zones/ZONE/org-admin/rolebindings/EMAIL_ADDRESS/YAML_FILE
```

YAML-Datei

Speichern Sie das folgende RoleBinding-Manifest in der YAML-Datei im IaC-Dateipfad:

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

Ersetzen Sie Folgendes:

KUBECONFIG: Der Pfad zur kubeconfig-Datei für den spezifischen Cluster, der die NAMESPACE enthält, auf die diese RoleBinding angewendet wird.
KUBECONFIG_PATH: Der Pfad zur kubeconfig-Datei in den Beispielbefehlen.
RULE_NAME: Der eindeutige Name für diese RoleBinding-Ressource im Namespace, z. B. pa-project-grafana-viewer.
NAMESPACE: der Kubernetes-Namespace, in dem diese RoleBinding erstellt und angewendet wird. Suchen Sie in der vorherigen Tabelle nach der Spalte Namespace.
EMAIL_ADDRESS: die Kennung für den Nutzer, dem die Rolle zugewiesen wird, z. B. application-operator@example.com.
ROLE: der Name der Role, die die Berechtigungen enthält, die Sie dem Nutzer gewähren möchten. Suchen Sie nach den Rollen, die in der vorherigen Tabelle aufgeführt sind.
GROUP_NAME: der Name des Group, zu dem der PA-Nutzer gehört, z. B. pa-group.
ZONE: der Name der Zone.
YAML_FILE: Der Name der YAML-Datei für die RoleBinding-Ressource.

Weitere Informationen zu diesen Rollen finden Sie unter IAM-Berechtigungen vorbereiten.

Logs abfragen und filtern

Wählen Sie eine der folgenden Methoden aus, um Abfragen zu erstellen und Logs aus Ihren Projektarbeitslasten zu filtern:

Grafana-Logbereich

In diesem Abschnitt wird beschrieben, wie Sie über das Log-Panel in Grafana auf Ihre Logs zugreifen.

Grafana-Endpunkt identifizieren

Die folgende URL ist der Endpunkt der Grafana-Instanz Ihres Projekts:

  https://GDC_URL/PROJECT_NAMESPACE/grafana

Ersetzen Sie Folgendes:

GDC_URL: die URL Ihrer Organisation in GDC.
PROJECT_NAMESPACE: Ihr Projekt-Namespace.

Der Grafana-Endpunkt für das Projekt platform-obs in der Organisation org-1 lautet beispielsweise https://org-1/platform-obs/grafana.

Logs in der Grafana-Benutzeroberfläche ansehen

Logs in der Grafana-Benutzeroberfläche abfragen:

Wählen Sie in der GDC Console Ihr Projekt aus.
Wählen Sie im Navigationsmenü Vorgänge > Logging aus.
Klicken Sie auf Alle in Grafana Loki ansehen.

Auf einer neuen Seite wird der Grafana-Endpunkt geöffnet und die Benutzeroberfläche angezeigt.
Klicken Sie auf der Benutzeroberfläche im Navigationsmenü auf Expl. Datenanalyse Expl. Datenanalyse, um die Seite Expl. Datenanalyse zu öffnen.
Wählen Sie im Menü in der Leiste Erkunden eine Datenquelle aus, um Logs entsprechend Ihrem Universumstyp abzurufen:
- Universen mit einer Zone: Wählen Sie eine der folgenden Datenquellen aus, um Protokolldaten aus der einzelnen Zone Ihres Universums aufzurufen:
  - Betriebslogs: Betriebslogs anzeigen.
  - Audit-Logs: Audit-Logs anzeigen.
- Universen mit mehreren Zonen: Grafana kann eine Verbindung zu verschiedenen Zonen herstellen und zonenübergreifende Daten anzeigen. Wählen Sie eine der folgenden Datenquellen aus, um Logging-Daten aus einer beliebigen Zone Ihres Universums anzuzeigen, unabhängig davon, in welcher Zone Sie angemeldet sind:
  - Betriebslogs ZONE_NAME: Betriebslogs aus einer bestimmten Zone anzeigen.
  - Audit-Logs ZONE_NAME: Hier werden Audit-Logs aus einer bestimmten Zone angezeigt.
  Wenn Sie zonenübergreifende Datenvisualisierungen in einem einzigen Dashboard anzeigen und Ihrer Abfrage mehrere Zonen hinzufügen möchten, wählen Sie Gemischt als Datenquelle aus.
  
  Hinweis :Audit-Logs sind nur für Plattformadministratoren verfügbar, auch wenn sie keine Audit-Logging-Ziele erstellen oder konfigurieren können. Anwendungsoperatoren können nur auf Betriebslogs zugreifen.
Geben Sie eine Abfrage ein, um im Logbereich mithilfe von LogQL-Ausdrücken (Log Query Language) nach Logs zu suchen. Sie können diesen Schritt über eine der beiden folgenden Methoden ausführen:
- Verwenden Sie die interaktive Query Builder-Oberfläche. Klicken Sie dann auf Abfrage ausführen.
- Geben Sie die Abfrage direkt in das Textfeld ein und drücken Sie Umschalttaste + Eingabetaste, um die Abfrage auszuführen.
Auf der Seite werden die Logs angezeigt, die Ihrer Abfrage entsprechen. Nachdem Sie Logs abgefragt haben, können Sie sie exportieren. Klicken Sie auf Exportieren, um Logs im Nur-Text- oder CSV-Format herunterzuladen. Sie können auch einen Zeitraum für Ihre Protokolle auswählen.

Abbildung 1. Menüoption zum Abfragen von Audit-Logs über die Grafana-Benutzeroberfläche.

In Abbildung 1 wird mit der Option Audit-Logs die Oberfläche angezeigt, über die Sie Abfragen in Grafana erstellen können, um Audit-Logs abzurufen.

Beispiele für Labels und Werte zum Abfragen verschiedener Logs finden Sie unter Beispielabfragen und ‑labels.

Zeitraum für Ihre Logs auswählen

So fragen Sie Logs in einem Zeitraum ab:

Klicken Sie in Grafana auf das Menü Time Picker (Zeitauswahl).
Führen Sie im Menü eine der folgenden Aktionen aus:
- Wählen Sie Optionen für relative Zeiträume aus, z. B. die letzten 30 Minuten.
- Sie können benutzerdefinierte absolute Zeiträume festlegen, indem Sie bestimmte Datumsangaben und Uhrzeiten im Kalender auswählen und auf Zeitraum anwenden klicken.
Optional: Klicken Sie auf Zeiteinstellungen ändern, um die Einstellungen für Zeitzone und Geschäftsjahr über die Steuerelemente für den Zeitraum zu ändern.

Zeiteinstellungen werden für jedes Dashboard einzeln gespeichert. Weitere Informationen zu Abfragen über einen bestimmten Zeitraum finden Sie unter https://grafana.com/docs/loki/latest/reference/api/#query-loki-over-a-range-of-time.

Log Query API

In diesem Abschnitt wird beschrieben, wie Sie mit der Log Query API auf Ihre Logs zugreifen.

Log Query API-Endpunkt ermitteln

Die Log Query API stellt die folgenden beiden Endpunkte zum Abfragen von Audit- und Betriebslogs bereit:

Audit-Log-Endpunkt:
```
audit-log-query-api.ORG_DOMAIN
```
Hinweis: Audit-Logs sind nur für Plattformadministratoren verfügbar, auch wenn sie keine Audit-Logging-Ziele erstellen oder konfigurieren können. Anwendungsoperatoren können nur auf Betriebslogs zugreifen.
Endpunkt für Betriebsprotokolle:
```
operational-log-query-api.ORG_DOMAIN
```

Ersetzen Sie ORG_DOMAIN durch den Domainnamen der Organisation. Sie können dieses Attribut mit dem Befehl gdcloud config list aufrufen. Der Domainname muss der Syntax org-name.zone.google.gdch.com entsprechen. Eine Organisation mit dem Namen org-1 in der Zone zone1 und in einer Testumgebung hat beispielsweise eine Domain wie org-1.zone1.google.gdch.test.

Die Log Query API bietet die folgenden drei Endpunktoptionen:

labels: Listet alle Labels für ein Projekt auf.
labels/labels/LABEL/values: Listet bestimmte Labelwerte für ein Projekt auf.
logs: Listet Logs für ein bestimmtes Projekt auf.

Weitere Informationen finden Sie in der API-Dokumentation.

Abfrage senden

Senden Sie eine Abfrage an den Log Query API-Endpunkt mithilfe von HTTP- oder gRPC-Clients.

HTTP

Folgen Sie der Anleitung, um mit einem HTTP-Client direkt auf die API zuzugreifen. Sie können die Authentifizierung von kubectl verwalten lassen oder selbst übernehmen.

Fragen Sie die Log Query API mit HTTP-Clients wie curl, wget oder einem von Ihnen erstellten und verwalteten HTTP-Client ab. Im folgenden Beispiel wird das Tool curl verwendet, um die API abzufragen. Sie können ein ähnliches Format für wget-Befehle verwenden:

Authentifizieren Sie die cURL-Anfrage:
1. Laden Sie die gdcloud CLI herunter und installieren Sie sie.
2. Legen Sie das gdcloud-Attribut core/organization_console_url fest:
```
gdcloud config set core/organization_console_url https://GDC_URL
```
  Ersetzen Sie GDC_URL durch die URL einer Organisation in GDC.
3. Mit dem konfigurierten Identitätsanbieter anmelden:
```
gdcloud auth login
```
4. Verwenden Sie Ihren Nutzernamen und Ihr Passwort, um sich zu authentifizieren und anzumelden.
5. Exportieren Sie das Identitätstoken für das angegebene Konto in eine Umgebungsvariable:
```
export TOKEN="$($HOME/gdcloud auth print-identity-token --audiences=https://LOG_QUERY_API_ENDPOINT)"
```
  Ersetzen Sie LOG_QUERY_API_ENDPOINT durch den Log Query API-Endpunkt, von dem aus Sie Logs abfragen möchten, und die Domain, zu der Sie eine Verbindung herstellen möchten. Der Wert für das Flag audiences kann daher beispielsweise https://operational-log-query-api.org-1.zone1.google.gdch.test sein.
  
  Wenn die Anmeldung erfolgreich ist, können Sie den Autorisierungsheader in Ihrer cURL-Anfrage mit dem Befehl gdcloud auth print-identity-token verwenden. Weitere Informationen finden Sie unter gdcloud auth print-identity-token.
Wenn Sie alle Labels für ein Projekt auflisten möchten, senden Sie die folgende Abfrage:
```
curl -H "Authorization: Bearer ${TOKEN}" \
https://LOG_QUERY_API_ENDPOINT/v1/projects/PROJECT_NAMESPACE/labels \
-H "Content-Type: application/json" -v
```
Ersetzen Sie Folgendes:
- LOG_QUERY_API_ENDPOINT: Der Log Query API-Endpunkt, von dem aus Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projekt-Namespace.
Wenn Sie bestimmte Labelwerte für ein Projekt auflisten möchten, senden Sie die folgende Abfrage:
```
curl -H "Authorization: Bearer ${TOKEN}" \
https://LOG_QUERY_API_ENDPOINT/v1/projects/PROJECT_NAMESPACE/labels/labels/LABEL/values \
-H "Content-Type: application/json" -v
```
Ersetzen Sie Folgendes:
- LOG_QUERY_API_ENDPOINT: Der Log Query API-Endpunkt, von dem aus Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projekt-Namespace.
- LABEL: Das spezifische Label, dessen Wert Sie abfragen möchten.
Wenn Sie Logs für ein bestimmtes Projekt abfragen möchten, erstellen Sie eine logs_filter-Abfrage und fügen Sie sie in den Text der Anfrage ein:
```
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
```
Ersetzen Sie Folgendes:
- LOG_QUERY_API_ENDPOINT: der Log Query API-Endpunkt, von dem Sie Logs abfragen möchten.
- PROJECT_NAMESPACE: Ihr Projekt-Namespace.
- LABEL: Das spezifische Label, für das Sie Logs abfragen möchten.
- LABEL_VALUE: Der Labelwert, für den Sie Logs abfragen möchten.
In der API-Dokumentation finden Sie alle Optionen zum Erstellen einer logs_filter-Abfrage.

gRPC

gRPC wird von vielen Programmiersprachen unterstützt und bietet eine effizientere Kommunikationsmethode als HTTP-Clients.

Wenn Sie Logs mit gRPC abfragen möchten, müssen die folgenden Voraussetzungen erfüllt sein:

Erstellen Sie Ihre eigene Clientbibliothek auf Grundlage der von Google bereitgestellten Protocol Buffers.
Authentifizierung im Client implementieren
Wiederholungsversuche implementieren

Informationen zu den Protokollzwischenspeichern finden Sie in der API-Dokumentation.

Im folgenden Beispiel wird gezeigt, wie Sie Logs aus einem Go-Programm mit einem nicht authentifizierten gRPC-Client abfragen. In diesem Beispiel wird davon ausgegangen, dass Sie ein Golang-Paket erstellt haben, das eine Bazel-Build-Datei zum Importieren von Codeabhängigkeiten enthält:

Speichern Sie den folgenden Code in einem Go-Programm mit dem Namen 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
}

Führen Sie das Go-Programm aus:
```
go run PATH_TO_API/client.go -server=LOG_QUERY_API_ENDPOINT:443
```
Ersetzen Sie Folgendes:
- PATH_TO_API: der Pfad zur API-Datei.
- LOG_QUERY_API_ENDPOINT: der Log Query API-Endpunkt, von dem Sie Logs abfragen möchten.
Wenn das Server-Flag nicht angegeben ist, wird die Standardanfrage an localhost gesendet.

Beispielabfragen und ‑Labels

Im Folgenden finden Sie einige der Standardlabels, die Sie zum Abfragen von Logs verwenden können:

cluster ist der Name des Clusters.
namespace: Ihr Projekt-Namespace.
node: der Knotenname.
pod: der Podname.
container: der Containername.

Die folgenden Codebeispiele zeigen die Verwendung von Labels und Werten zum Abfragen verschiedener Logs:

Server-Logs auswählen:

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

Wählen Sie Cluster-Audit-Logs aus:

{cluster="admin", resources="k8s_audit"}