Diese Seite wurde von der Cloud Translation API übersetzt.

Jobs mithilfe von Protokollen analysieren

In diesem Dokument wird beschrieben, wie Sie Logs aus Cloud Logging für einen Batchjob aktivieren, generieren und aufrufen.

Anhand von Protokollen können Sie Informationen abrufen, die für die Analyse Ihrer Jobs nützlich sind. Protokolle können Ihnen beispielsweise bei der Fehlerbehebung bei fehlgeschlagenen Jobs helfen.

Logs werden erst nach dem Start eines Jobs generiert und nur, wenn die Protokollierung für den Job aktiviert wurde. Wenn Sie einen Job ohne Protokolle analysieren möchten, rufen Sie stattdessen Statusereignisse auf.

Hinweise

Wenn Sie Batch noch nicht verwendet haben, lesen Sie den Hilfeartikel Batch-Dateien erstellen und ausführen und aktivieren Sie Batch, indem Sie die Voraussetzungen für Projekte und Nutzer erfüllen.
Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Analysieren eines Jobs mithilfe von Protokollen benötigen:
- So erstellen Sie einen Job:
  - Batch-Job-Bearbeiter (roles/batch.jobsEditor) für das Projekt
  - Dienstkontonutzer (roles/iam.serviceAccountUser) im Dienstkonto des Jobs, das standardmäßig das Compute Engine-Standarddienstkonto ist
- So rufen Sie Logs auf: Loganzeige (roles/logging.viewer) für das Projekt
Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Logging für einen Job aktivieren

Wenn Sie Logs für einen Job generieren möchten, aktivieren Sie beim Erstellen des Jobs Logs aus Cloud Logging:

Wenn Sie einen Job mit der Google Cloud -Console erstellen, sind Logs aus Cloud Logging immer aktiviert.
Wenn Sie einen Job mit der gcloud CLI oder der Batch API erstellen, sind Logs aus Cloud Logging standardmäßig deaktiviert. Wenn Sie Logs aus Cloud Logging aktivieren möchten, fügen Sie beim Erstellen des Jobs die folgende Konfiguration für das Feld logsPolicy hinzu:
```
{
    ...
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
    ...
}
```

Protokolle für einen Job schreiben und generieren

Wenn Logs aus Cloud Logging für einen Job aktiviert sind, werden alle Logs, die für den Job geschrieben werden, automatisch in Cloud Logging generiert. Insbesondere können Batchjobs die folgenden Protokolltypen haben:

Agent-Logs (batch_agent_logs): Logs für Aktivitäten des Batch-Dienst-Agents.

Batch schreibt automatisch Agentenprotokolle für jeden Job, für den das Logging aktiviert ist.
Aufgabenprotokolle (batch_task_logs): Protokolle für alle Daten, die Sie so konfiguriert haben, dass sie vom Job in den Standardausgabe- (stdout) oder Standardfehlerstream (stderr) geschrieben werden.

Optional können Sie für jeden Job, für den das Logging aktiviert ist, Aufgabenprotokolle schreiben.

Logs für einen Job ansehen

Sie können die Logs eines Jobs über die Google Cloud -Konsole, die gcloud CLI, die Logging API, Go, Java, Python oder C++ aufrufen.

Console

So rufen Sie die Logs eines Jobs mit der Google Cloud -Console auf:

Rufen Sie in der Google Cloud -Console die Seite Aufgabenliste auf.

Jobliste aufrufen
Klicken Sie in der Spalte Jobname auf den Namen eines Jobs. Die Seite Jobdetails wird geöffnet.
Klicken Sie auf den Tab Logs. Unter „Batch“ werden alle Logs angezeigt, die mit dem Job verknüpft sind.
Optional: Sie haben folgende Möglichkeiten, die Protokolle zu filtern:
- Geben Sie im Feld Filter einen Filter ein.
- Wählen Sie in der Liste Schweregrad einen Schweregrad aus.
- Klicken Sie auf Im Log-Explorer ansehen, um im Log-Explorer mithilfe der Batch-Filterparameter eine Abfrage zu erstellen.

gcloud

Wenn Sie Logs mit der gcloud CLI aufrufen möchten, verwenden Sie den Befehl gcloud logging read:

gcloud logging read "QUERY"

Dabei ist QUERY eine Abfrage für Batch-Protokolle, die Batch-Filterparameter enthält.

API

Wenn Sie Logs mithilfe der Logging API aufrufen möchten, verwenden Sie die Methode entries.list:

POST https://logging.googleapis.com/v2/entries:list
{
    "resourceNames": [
        "projects/PROJECT_ID"
    ],
    "filter": "QUERY"
    "orderBy": "timestamp desc"
}

Ersetzen Sie Folgendes:

PROJECT_ID: die Projekt-ID Ihres Projekts.
QUERY: Eine Abfrage für Batch-Protokolle, die Batch-Filterparameter enthält.

Go

Weitere Informationen finden Sie in der Referenzdokumentation zur Batch Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Batch zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	"cloud.google.com/go/logging"
	"cloud.google.com/go/logging/logadmin"
	"google.golang.org/api/iterator"
)

// Retrieve the logs written by the given job to Cloud Logging
func printJobLogs(w io.Writer, projectID string, job *batchpb.Job) error {
	// projectID := "your_project_id"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	adminClient, err := logadmin.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("Failed to create logadmin client: %w", err)
	}
	defer adminClient.Close()

	const name = "batch_task_logs"

	iter := adminClient.Entries(ctx,
		// Only get entries from the "batch_task_logs" log for the job with the given UID
		logadmin.Filter(fmt.Sprintf(`logName = "projects/%s/logs/%s" AND labels.job_uid=%s`, projectID, name, job.Uid)),
	)

	var entries []*logging.Entry

	for {
		logEntry, err := iter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("unable to fetch log entry: %w", err)
		}
		entries = append(entries, logEntry)
		fmt.Fprintf(w, "%s\n", logEntry.Payload)
	}

	fmt.Fprintf(w, "Successfully fetched %d log entries\n", len(entries))

	return nil
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur Batch Java API.

import com.google.cloud.batch.v1.Job;
import com.google.cloud.logging.v2.LoggingClient;
import com.google.logging.v2.ListLogEntriesRequest;
import com.google.logging.v2.LogEntry;
import java.io.IOException;

public class ReadJobLogs {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project hosting the job.
    String projectId = "YOUR_PROJECT_ID";

    // The job which logs you want to print.
    Job job = Job.newBuilder().build();

    readJobLogs(projectId, job);
  }

  // Prints the log messages created by given job.
  public static void readJobLogs(String projectId, Job job) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `loggingClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (LoggingClient loggingClient = LoggingClient.create()) {

      ListLogEntriesRequest request = ListLogEntriesRequest.newBuilder()
          .addResourceNames(String.format("projects/%s", projectId))
          .setFilter(String.format("labels.job_uid=%s", job.getUid()))
          .build();

      for (LogEntry logEntry : loggingClient.listLogEntries(request).iterateAll()) {
        System.out.println(logEntry.getTextPayload());
      }
    }
  }
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Batch Python API.

from __future__ import annotations

from typing import NoReturn

from google.cloud import batch_v1
from google.cloud import logging


def print_job_logs(project_id: str, job: batch_v1.Job) -> NoReturn:
    """
    Prints the log messages created by given job.

    Args:
        project_id: name of the project hosting the job.
        job: the job which logs you want to print.
    """
    # Initialize client that will be used to send requests across threads. This
    # client only needs to be created once, and can be reused for multiple requests.
    log_client = logging.Client(project=project_id)
    logger = log_client.logger("batch_task_logs")

    for log_entry in logger.list_entries(filter_=f"labels.job_uid={job.uid}"):
        print(log_entry.payload)

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Batch C++ API.

#include "google/cloud/batch/v1/batch_client.h"
#include "google/cloud/logging/v2/logging_service_v2_client.h"
#include "google/cloud/location.h"
#include "google/cloud/project.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id) {
    auto const project = google::cloud::Project(project_id);
    auto const location = google::cloud::Location(project, location_id);
    auto const name = location.FullName() + "/jobs/" + job_id;
    auto batch = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto job = batch.GetJob(name);
    if (!job) throw std::move(job).status();

    auto logging = google::cloud::logging_v2::LoggingServiceV2Client(
        google::cloud::logging_v2::MakeLoggingServiceV2Connection());
    auto const log_name = project.FullName() + "/logs/batch_task_logs";
    google::logging::v2::ListLogEntriesRequest request;
    request.mutable_resource_names()->Add(project.FullName());
    request.set_filter("logName=\"" + log_name +
                       "\" labels.job_uid=" + job->uid());
    for (auto l : logging.ListLogEntries(request)) {
      if (!l) throw std::move(l).status();
      std::cout << l->text_payload() << "\n";
    }
  }

Batch-Logs filtern

Sie können nach Batch-Protokollen filtern, indem Sie eine Abfrage mit einem oder mehreren der folgenden Filterparameter und null oder mehr booleschen Operatoren (AND, OR und NOT) schreiben.

Wenn Sie nach Logs für einen bestimmten Job filtern möchten, geben Sie die eindeutige ID (UID) des Jobs an:
```
labels.job_uid=JOB_UID
```
Dabei ist JOB_UID die UID des Jobs. Die UID eines Jobs finden Sie in den Jobdetails.
Wenn Sie nach einem bestimmten Typ von Batch-Logs filtern möchten, geben Sie den Logtyp an:
```
logName=projects/PROJECT_ID/logs/BATCH_LOG_TYPE
```
Ersetzen Sie Folgendes:
- PROJECT_ID: die Projekt-ID des Projekts, für das Sie Protokolle aufrufen möchten.
- BATCH_LOG_TYPE: Der Typ der Batch-Protokolle, die Sie aufrufen möchten. Geben Sie dazu entweder batch_task_logs für Aufgabenprotokolle oder batch_agent_logs für Agentenprotokolle ein.
Wenn Sie nach Logs mit benutzerdefinierten Statusereignissen filtern möchten, geben Sie an, dass das Feld jsonPayload.batch/custom/event im Log definiert sein muss:
```
jsonPayload.batch"/"custom"/"event!=NULL_VALUE
```
Wenn Sie nach Protokollen mit einem oder mehreren bestimmten Schweregraden filtern möchten, geben Sie den folgenden Vergleich an:
```
severityCOMPARISON_OPERATORSEVERITY_ENUM
```
Ersetzen Sie Folgendes:
- COMPARISON_OPERATOR: ein Vergleichsoperator, z. B. >=.
- SEVERITY_ENUM: ein LogSeverity-Enum, das die Schwere eines Logs beschreibt, z. B. ERROR.

Weitere Filteroptionen finden Sie in der Dokumentation zur Cloud Logging-Abfragesprache.

Jobs mithilfe von Protokollen analysieren

Hinweise

Logging für einen Job aktivieren

Protokolle für einen Job schreiben und generieren

Logs für einen Job ansehen

Console

gcloud

API

Go

Go

Java

Java

Python

Python

C++

C++

Batch-Logs filtern

Nächste Schritte