Se usó la API de Cloud Translation para traducir esta página.

Cómo analizar una tarea con registros

En este documento, se describe cómo habilitar, generar y ver los registros de Cloud Logging para un trabajo por lotes.

Puedes usar los registros para obtener información útil para analizar tus trabajos. Por ejemplo, los registros pueden ayudarte a depurar trabajos que fallaron.

En particular, los registros solo se generan después de que un trabajo comienza a ejecutarse y solo si se habilitó el registro para el trabajo. Si necesitas analizar un trabajo sin registros, consulta los eventos de estado.

Antes de comenzar

Si nunca usaste Batch, consulta Cómo comenzar a usar Batch y habilita Batch completando los requisitos previos para proyectos y usuarios.
Para obtener los permisos que necesitas para analizar un trabajo con registros, pídele a tu administrador que te otorgue los siguientes roles de IAM:
- Para crear un trabajo, sigue estos pasos:
  - Editor de trabajos por lotes (roles/batch.jobsEditor) en el proyecto
  - Usuario de la cuenta de servicio (roles/iam.serviceAccountUser) en la cuenta de servicio del trabajo, que de forma predeterminada es la cuenta de servicio predeterminada de Compute Engine
- Para ver los registros, usa el Visualizador de registros (roles/logging.viewer) en el proyecto.
Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Habilita el registro de un trabajo

Para permitir que se generen registros para un trabajo, habilita los registros desde Cloud Logging cuando lo crees:

Si creas un trabajo con la consola de Google Cloud, los registros de Cloud Logging siempre estarán habilitados.
Si creas un trabajo con la CLI de gcloud o la API de Batch, los registros de Cloud Logging se inhabilitan de forma predeterminada. Para habilitar los registros de Cloud Logging, incluye la siguiente configuración para el campo logsPolicy cuando crees el trabajo:
```
{
    ...
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
    ...
}
```

Cómo escribir y generar registros para un trabajo

Cuando se habilitan los registros de Cloud Logging para un trabajo, este servicio genera automáticamente cualquiera de los registros que se escriben para el trabajo. Específicamente, los trabajos por lotes pueden tener los siguientes tipos de registros:

Registros del agente (batch_agent_logs): Son registros de las actividades del agente de servicio por lotes.

El procesamiento por lotes escribe automáticamente registros de agentes para cada trabajo que habilitó el registro.
Registros de tareas (batch_task_logs): Registros de los datos para los que configuraste los elementos ejecutables de un trabajo para escribir en la cadena de salida estándar (stdout) o de error estándar (stderr).

De manera opcional, puedes escribir registros de tareas para cada trabajo que haya habilitado el registro.

Visualiza los registros de un trabajo

Puedes ver los registros de un trabajo con la consola de Google Cloud, la CLI de gcloud, la API de Logging, Go, Java, Python o C++.

Console

Para ver los registros de un trabajo con la consola de Google Cloud, haz lo siguiente:

En la consola de Google Cloud, ve a la página Lista de trabajos.

Ir a la lista de trabajos
En la columna Nombre del trabajo, haz clic en el nombre de un trabajo. Se abrirá la página Detalles del trabajo.
Haz clic en la pestaña Registros (Logs). Batch muestra todos los registros asociados con el trabajo.
Opcional: Para filtrar los registros, haz lo siguiente:
- Ingresa un filtro en el campo Filtro.
- En la lista Gravedad, selecciona una gravedad.
- Haz clic en Ver en el Explorador de registros para crear una consulta en el Explorador de registros con los parámetros del filtro por lotes.

gcloud

Para ver los registros con la CLI de gcloud, usa el comando gcloud logging read:

gcloud logging read "QUERY"

donde QUERY es una consulta para los registros de lotes que contiene parámetros de filtro de lotes.

API

Para ver los registros con la API de Logging, usa el método entries.list:

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

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto de tu proyecto.
QUERY: Una consulta para los registros de lotes que contiene parámetros de filtro de lotes.

Go

Para obtener más información, consulta la documentación de referencia de la API de Go de lotes.

Para autenticarte en Batch, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para obtener más información, consulta la documentación de referencia de la API de Java de lotes.

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

Para obtener más información, consulta la documentación de referencia de la API de Python de lotes.

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++

Para obtener más información, consulta la documentación de referencia de la API de C++ de lotes.

#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";
    }
  }

Cómo filtrar registros por lotes

Para filtrar los registros por lotes, escribe una consulta que incluya uno o más de los siguientes parámetros de filtro y cero o más operadores booleanos (AND, OR y NOT).

Para filtrar registros de un trabajo específico, especifica el ID único (UID) del trabajo:
```
labels.job_uid=JOB_UID
```
en el que JOB_UID es el UID de la tarea. Para obtener el UID de un trabajo, consulta los detalles del trabajo.
Para filtrar un tipo específico de registros de lotes, especifica el tipo de registro:
```
logName=projects/PROJECT_ID/logs/BATCH_LOG_TYPE
```
Reemplaza lo siguiente:
- PROJECT_ID: el ID del proyecto del proyecto para el que deseas ver los registros.
- BATCH_LOG_TYPE: Es el tipo de registros de lotes que deseas ver, ya sea batch_task_logs para los registros de tareas o batch_agent_logs para los registros de agentes.
Para filtrar registros con eventos de estado personalizados, especifica que el registro debe definir el campo jsonPayload.batch/custom/event:
```
jsonPayload.batch"/"custom"/"event!=NULL_VALUE
```
Para filtrar registros de una o más gravedades específicas, especifica la siguiente comparación:
```
severityCOMPARISON_OPERATORSEVERITY_ENUM
```
Reemplaza lo siguiente:
- COMPARISON_OPERATOR: Un operador de comparación, por ejemplo, >=.
- SEVERITY_ENUM: Una enumeración LogSeverity que describe la gravedad de un registro, por ejemplo, ERROR.

Para obtener más opciones de filtro, consulta la documentación del lenguaje de consulta de Cloud Logging.

¿Qué sigue?

Obtén más información para solucionar problemas.
Obtén más información sobre Cloud Logging.
Obtén más información para escribir registros de tareas.
Obtén información para exportar información de trabajos.
Obtén más información para borrar trabajos.