Esta página se ha traducido con Cloud Translation API.

Analizar un trabajo mediante registros

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

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

Es importante destacar que los registros solo se generan después de que se inicie una tarea y solo si se ha habilitado el registro para esa tarea. Si necesitas analizar un trabajo sin registros, consulta los eventos de estado.

Antes de empezar

Si no has usado Batch antes, consulta el artículo Empezar a usar Batch y habilita Batch completando los requisitos previos para proyectos y usuarios.
Para obtener los permisos que necesitas para analizar un trabajo mediante registros, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos:
- Para crear un trabajo, sigue estos pasos:
  - Editor de trabajos por lotes (roles/batch.jobsEditor) en el proyecto
  - Usuario de 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, sigue estos pasos: Visualizador de registros (roles/logging.viewer) del proyecto
Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Habilitar el registro de un trabajo

Para permitir que se generen registros de una tarea, habilita los registros de Cloud Logging al crear la tarea:

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

Escribir y generar registros de una tarea

Cuando se habilitan los registros de Cloud Logging en un trabajo, Cloud Logging genera automáticamente los registros que se escriben en el trabajo. En concreto, las tareas por lotes pueden tener los siguientes tipos de registros:

Registros del agente (batch_agent_logs): registros de las actividades del agente del servicio Batch.

Batch escribe automáticamente los registros del agente de cada trabajo que tenga habilitado el registro.
Registros de tareas (batch_task_logs): registros de los datos que hayas configurado para que los elementos ejecutables de un trabajo se escriban en el flujo de salida estándar (stdout) o en el flujo de error estándar (stderr).

También puedes escribir registros de tareas para cada trabajo que tenga habilitado el registro.

Ver los registros de un trabajo

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

Consola

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

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

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

gcloud

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

gcloud logging read "QUERY"

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

API

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

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

Haz los cambios siguientes:

PROJECT_ID: el ID de proyecto de tu proyecto.
QUERY: una consulta de 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 Batch Go.

Para autenticarte en Batch, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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 Batch Java.

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 Batch Python.

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 Batch C++.

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

Filtrar registros de Batch

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

Para filtrar los registros de un trabajo específico, especifica el ID único (UID) del trabajo:
```
labels.job_uid=JOB_UID
```
donde JOB_UID es el UID del trabajo. Para obtener el UID de un trabajo, consulta los detalles del trabajo.
Para filtrar por un tipo específico de registros de lote, especifica el tipo de registro:
```
logName=projects/PROJECT_ID/logs/BATCH_LOG_TYPE
```
Haz los cambios siguientes:
- PROJECT_ID: el ID del proyecto del proyecto cuyos registros quieres ver.
- BATCH_LOG_TYPE: el tipo de registros por lotes que quieras ver. Elige batch_task_logs para ver los registros de tareas o batch_agent_logs para ver los registros de agentes.
Para filtrar los 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 los registros de una o varias gravedades específicas, especifica la siguiente comparación:
```
severityCOMPARISON_OPERATORSEVERITY_ENUM
```
Haz los cambios siguientes:
- COMPARISON_OPERATOR: un operador de comparación; por ejemplo, >=.
- SEVERITY_ENUM: un LogSeverity enum, que describe la gravedad de un registro (por ejemplo, ERROR).

Para ver más opciones de filtro, consulta la documentación sobre el lenguaje de consultas de Cloud Logging.

Siguientes pasos

Más información sobre cómo solucionar problemas
Consulta más información sobre Cloud Logging.
Consulta cómo escribir registros de tareas.
Consulta cómo exportar información de los puestos.
Consulta cómo eliminar trabajos.

Analizar un trabajo mediante registros Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Habilitar el registro de un trabajo

Escribir y generar registros de una tarea

Ver los registros de un trabajo

Consola

gcloud

API

Go

Go

Java

Java

Python

Python

C++

C++

Filtrar registros de Batch

Siguientes pasos

Analizar un trabajo mediante registros