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

Gestionar versiones de procesadores

Se lanzan nuevas versiones por varios motivos, como mejorar la precisión, aumentar la disponibilidad y admitir nuevos elementos de documentos, como las marcas de selección.

Dado que Document AI se basa en la IA generativa, las versiones futuras usarán nuevos modelos básicos para que puedas beneficiarte de las mejoras de la IA generativa.

A medida que mejoramos los modelos fundacionales, los modelos fundacionales anteriores se retiran. Del mismo modo, las versiones del procesador dejan de estar disponibles seis meses después de que se publiquen las nuevas versiones.

Un procesador puede tener una de las siguientes versiones:

Versión estable
Versión candidata (RC)
Versión personalizada y su versión base

En esta página se describe cómo se versionan los procesadores y cómo se puede ver y seleccionar una versión concreta.

managing-processor-versions-1

Información general sobre las versiones de procesadores

Hay dos categorías de versiones de procesador:

Las versiones de Google son estables (para casos prácticos de producción) o candidatas a lanzamiento (experimentales con las funciones más recientes).
Tú creas las versiones de usuario para personalizar las predicciones de tus documentos y tienen IDs de versión alfanuméricos.

Versiones de Google

Cada versión de Google se identifica con un ID de versión, por ejemplo, pretrained-TYPE-vX.X-YYYY-MM-DD. Cada versión del procesador que ofrece Google se denomina Google Stable o Google Release Candidate (RC).

Versiones estables de Google

Las versiones estables tienen calidad de producción y están listas para usarse.

Google da prioridad a la estabilidad del comportamiento del procesador, pero sigue incluyendo correcciones críticas.
Las versiones estables anteriores de Google dejan de estar disponibles seis meses después de que se lance la versión estable más reciente, como se muestra en la siguiente figura.

managing-processor-versions-2

Versiones candidatas para lanzamiento de Google

Las versiones candidatas son experimentales y se actualizan periódicamente con las funciones más recientes. No son versiones de calidad de producción y su estabilidad puede variar.

Versiones personalizadas

Las versiones personalizadas son las versiones del procesador que puedes crear a partir de tus documentos para personalizar las predicciones. Las versiones personalizadas tienen el icono Type, que muestra el tipo de modelo usado para las predicciones. Si creas una versión con un modelo básico (ya sea creando una versión o ajustando el modelo), el tipo será IA generativa. Si creas una versión de procesador entrenando un modelo personalizado más pequeño (basado en un modelo o en una plantilla), el tipo será Personalizado. Si creas versiones de procesador, tú decides el nombre y el ID.

Versiones base

Si crea una versión del procesador, la "versión base" muestra qué versión de Google es la que usa su versión de usuario personalizada. La versión base determina el ciclo de vida de la versión de usuario. Debes tomar decisiones sobre cómo gestionar el ciclo de vida de tu versión de usuario personalizada.

Versiones estables disponibles del procesador

Puedes consultar las versiones estables de procesador disponibles para los distintos tipos de procesador en las siguientes tablas.

Extractor personalizado	Fecha de lanzamiento	Fecha de desactivación
`pretrained-foundation-model-v1.4-2025-02-05`	5 de febrero del 2025	No aplicable
`pretrained-foundation-model-v1.5-2025-05-05`	5 de mayo del 2025	No aplicable
`pretrained-foundation-model-v1.5-pro-2025-06-20`	20 de junio del 2025	No aplicable

Analizador de formularios	Fecha de lanzamiento	Fecha de desactivación
`pretrained-form-parser-v1.0-2020-09-23`	23 de septiembre del 2020	No aplicable
`pretrained-form-parser-v2.0-2022-11-10`	10 de noviembre del 2022	No aplicable

Analizador de diseños	Fecha de lanzamiento	Fecha de desactivación
`pretrained-layout-parser-v1.0-2024-06-03`	3 de junio del 2024	No aplicable

Analizador de extractos bancarios	Fecha de lanzamiento	Fecha de desactivación
`pretrained-bankstatement-v1.0-2021-08-08`	8 de agosto del 2021	No aplicable
`pretrained-bankstatement-v1.1-2021-08-13`	13 de agosto del 2021	No aplicable
`pretrained-bankstatement-v2.0-2021-12-10`	10 de diciembre del 2021	No aplicable
`pretrained-bankstatement-v3.0-2022-05-16`	16 de mayo del 2022	No aplicable

Analizador W2	Fecha de lanzamiento	Fecha de desactivación
`pretrained-w2-v1.0-2020-10-01`	1 de octubre del 2020	31 de marzo del 2024
`pretrained-w2-v1.1-2022-01-27`	27 de enero del 2022	31 de marzo del 2024
`pretrained-w2-v1.2-2022-01-28`	28 de enero del 2022	No aplicable
`pretrained-w2-v2.1-2022-06-08`	8 de junio del 2022	No aplicable

Analizador de pasaportes de EE. UU.	Fecha de lanzamiento	Fecha de desactivación
`pretrained-us-passport-v1.0-2021-06-14`	14 de junio del 2021	No aplicable

Analizador de utilidades	Fecha de lanzamiento	Fecha de desactivación
`pretrained-utility-v1.1-2021-04-09`	9 de abril del 2021	No aplicable

Analizador de verificación de documentos de identidad	Fecha de lanzamiento	Fecha de desactivación
`pretrained-id-proofing-v1.0-2022-10-03`	3 de octubre del 2022	No aplicable

Analizador de nóminas	Fecha de lanzamiento	Fecha de desactivación
`pretrained-paystub-v1.0-2021-03-19`	19 de marzo del 2021	No aplicable
`pretrained-paystub-v1.1-2021-08-13`	13 de agosto del 2021	No aplicable
`pretrained-paystub-v1.2-2021-12-10`	10 de diciembre del 2021	No aplicable
`pretrained-paystub-v2.0-2022-07-22`	22 de julio del 2022	No aplicable

Analizador de carnés de conducir de EE. UU.	Fecha de lanzamiento	Fecha de desactivación
`pretrained-us-driver-license-v1.0-2021-06-14`	14 de junio del 2021	No aplicable

Analizador de gastos	Fecha de lanzamiento	Fecha de desactivación
`pretrained-expense-v1.1-2021-04-09`	9 de abril del 2024	No aplicable

Analizador de facturas	Fecha de lanzamiento	Fecha de desactivación
`pretrained-invoice-v1.1-2021-04-09`	9 de abril del 2024	No aplicable
`pretrained-invoice-v1.2-2022-02-18`	18 de febrero del 2022	No aplicable
`pretrained-invoice-v1.3-2022-07-15`	15 de julio del 2022	No aplicable

Resumidor	Fecha de lanzamiento	Fecha de desactivación
`pretrained-foundation-model-v1.0-2023-08-22`	22 de agosto del 2023	No aplicable

OCR (reconocimiento óptico de caracteres) de documentos para empresas	Fecha de lanzamiento	Fecha de desactivación
`pretrained-ocr-v1.2-2022-11-10`	10 de noviembre del 2022	No aplicable
`pretrained-ocr-v2.0-2023-06-02`	2 de junio del 2023	No aplicable
`pretrained-ocr-v2.1-2024-08-07`	7 de agosto del 2024	No aplicable

managing-processor-versions-3

Ciclo de vida de las versiones del procesador

En cuanto esté disponible una nueva versión de Google, debes crear y evaluar nuevas versiones de usuario con la nueva versión base. A continuación, implementa la nueva versión y desimplanta (o elimina) las versiones de usuario anteriores que usen la versión estable anterior como base. Las versiones estables se discontinuarán cuando se lance una nueva. Google te avisa con al menos seis meses de antelación cuando esto ocurre.

¿Qué ocurre cuando se deja de usar una versión base?

Las versiones de usuario que dependen de versiones base anteriores dejan de devolver predicciones cuando la versión base queda obsoleta.

¿Cómo se seleccionan las versiones del procesador para tus solicitudes?

Cuando llamas a un endpoint de procesador sin especificar la versión del procesador, se usa la versión predeterminada. Cuando cambie la versión predeterminada del procesador, es posible que tengas que actualizar el código.

Endpoint usado	Experiencia
Si no especifica un ID de versión del procesador	Solicitudes procesadas con una nueva versión predeterminada del procesador. Si tu versión predeterminada del procesador está obsoleta, se actualizará a la versión estable de Google más reciente cuando la versión predeterminada anterior quede obsoleta.
Si especifica el ID de la versión del procesador	La respuesta falla si llamas a un endpoint de procesador y especificas un ID de versión que se ha retirado.

Ejemplo de discontinuación de una versión personalizada

Veamos la siguiente situación, que describe la secuencia de eventos en una versión personalizada obsoleta:

Como desarrollador, estás usando un extractor personalizado para obtener datos de documentos. Dada la complejidad y el volumen de los documentos que procesas, has ajustado el modelo base para crear una versión llamada fine-tune-A. Puedes definir la versión de fine-tune-A como la versión predeterminada de tu procesador y usarla para procesar documentos. La versión base que usa el modelo fine-tune-A es la versión estable pretrained-foundation-model-v1.0-2023-08-22 (v1.0).
Google publicó una nueva versión estable llamada pretrained-foundation-model-v1.2-2024-05-10 (v1.2) y anunció que la versión estable v1.0 se retirará el 9 de abril del 2025.
Como has conservado los documentos de entrenamiento y de prueba en el conjunto de datos de tu procesador, puedes ajustar otra versión basada en la versión estable más reciente de Google, v1.2, y llamarla fine-tune-B. Después de evaluar su rendimiento, puedes definir la versión fine-tune-B como la nueva versión predeterminada de tu procesador y retirar la versión fine-tune-A. La nueva versión ahora usa la versión estable de Google compatible más reciente.

Por otro lado, si no hubieras creado ni evaluado la versión personalizada, fine-tune-B Google habría actualizado la versión predeterminada de tu procesador a v1.2 el 9 de abril del 2025. Como estás llamando al endpoint del procesador y no especificas una versión del procesador, se usa la nueva versión v1.2 como valor predeterminado para procesar tus solicitudes.

Recursos de retirada y migración

Para ver los analizadores y procesadores obsoletos, consulta la página sobre obsolescencias de Document AI.

Consulta los siguientes recursos sobre migraciones:

Para crear y entrenar un nuevo Expense Parser, puedes consultar el artículo sobre entrenar un procesador preentrenado.
Para crear y ajustar un nuevo procesador de extractor personalizado, consulta el artículo Extractor personalizado con IA generativa.

Selecciona una versión del procesador

Hay tres formas de especificar qué versión del procesador se va a usar para el procesamiento online y por lotes:

Si no especifica una versión, se usará la predeterminada del procesador.
- Ejemplo: projects/my-proj/locations/us/processors/my-processor:process
Si especificas una versión, se usará esa versión concreta. Si la versión específica no existe, la solicitud falla y se produce un error.
- Ejemplo: projects/my-proj/locations/us/processors/my-processor/processorVersions/pretrained-invoice-v1.2-2022-02-18:process
Si especificas un canal, se usará la versión más reciente de ese canal. (Opciones: stable, rc)
- Ejemplo: projects/my-proj/locations/us/processors/my-processor/processorVersions/stable:process

Ver versión disponible

Consola

En la consola de Google Cloud , en la sección Document AI, ve a la página Procesadores.

Ir a Procesadores
En la lista de procesadores, haz clic en el nombre del procesador del que quieras ver los detalles.
Seleccione la pestaña Gestionar versiones (o Implementar y usar), donde se mostrarán todas las versiones del procesador disponibles.

REST

En este ejemplo se muestra cómo enumerar las versiones de procesador disponibles para tu procesador mediante el método processorVersions.list.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION: la ubicación de tu procesador, por ejemplo:
- us - Estados Unidos
- eu - Unión Europea
PROJECT_ID: tu ID de proyecto Google Cloud .
PROCESSOR_ID: el ID de tu procesador personalizado.

Método HTTP y URL:

GET https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions

Para enviar tu solicitud, elige una de estas opciones:

curl

Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Ejecuta el comando siguiente:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions"

PowerShell

Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions" | Select-Object -Expand Content

La respuesta contiene una lista de ProcessorVersions, que incluye información sobre cada versión del procesador, como su name, state y otros detalles.

{
  "processorVersions": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/pretrained-ocr-v1.1-2022-09-12",
      "displayName": "Google Release Candidate",
      "state": "DEPLOYED",
      "createTime": "2022-09-13T23:39:12.156648Z",
      "googleManaged": true
    },
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/pretrained-ocr-v1.0-2020-09-23",
      "displayName": "Google Stable",
      "state": "DEPLOYED",
      "createTime": "2022-09-12T23:35:09.829557Z",
      "googleManaged": true,
      "deprecationInfo": {
        "deprecationTime": "1970-01-01T00:00:00Z"
      }
    }
  ]
}

C#

Para obtener más información, consulta la documentación de referencia de la API C# de Document AI.

Para autenticarte en Document AI, 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.

using Google.Api.Gax;
using Google.Cloud.DocumentAI.V1;
using System;

public sealed partial class GeneratedDocumentProcessorServiceClientSnippets
{
    /// <summary>Snippet for ListProcessorVersions</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void ListProcessorVersionsRequestObject()
    {
        // Create client
        DocumentProcessorServiceClient documentProcessorServiceClient = DocumentProcessorServiceClient.Create();
        // Initialize request argument(s)
        ListProcessorVersionsRequest request = new ListProcessorVersionsRequest
        {
            ParentAsProcessorName = ProcessorName.FromProjectLocationProcessor("[PROJECT]", "[LOCATION]", "[PROCESSOR]"),
        };
        // Make the request
        PagedEnumerable<ListProcessorVersionsResponse, ProcessorVersion> response = documentProcessorServiceClient.ListProcessorVersions(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (ProcessorVersion item in response)
        {
            // Do something with each item
            Console.WriteLine(item);
        }

        // Or iterate over pages (of server-defined size), performing one RPC per page
        foreach (ListProcessorVersionsResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (ProcessorVersion item in page)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
        }

        // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
        int pageSize = 10;
        Page<ProcessorVersion> singlePage = response.ReadPage(pageSize);
        // Do something with the page of items
        Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
        foreach (ProcessorVersion item in singlePage)
        {
            // Do something with each item
            Console.WriteLine(item);
        }
        // Store the pageToken, for when the next page is required.
        string nextPageToken = singlePage.NextPageToken;
    }
}

Go

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


package main

import (
	"context"

	documentai "cloud.google.com/go/documentai/apiv1"
	documentaipb "cloud.google.com/go/documentai/apiv1/documentaipb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := documentai.NewDocumentProcessorClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &documentaipb.ListProcessorVersionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/documentai/apiv1/documentaipb#ListProcessorVersionsRequest.
	}
	it := c.ListProcessorVersions(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*documentaipb.ListProcessorVersionsResponse)
	}
}

Java

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

import com.google.cloud.documentai.v1.DocumentProcessorServiceClient;
import com.google.cloud.documentai.v1.ListProcessorVersionsRequest;
import com.google.cloud.documentai.v1.ProcessorName;
import com.google.cloud.documentai.v1.ProcessorVersion;

public class SyncListProcessorVersions {

  public static void main(String[] args) throws Exception {
    syncListProcessorVersions();
  }

  public static void syncListProcessorVersions() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DocumentProcessorServiceClient documentProcessorServiceClient =
        DocumentProcessorServiceClient.create()) {
      ListProcessorVersionsRequest request =
          ListProcessorVersionsRequest.newBuilder()
              .setParent(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .build();
      for (ProcessorVersion element :
          documentProcessorServiceClient.listProcessorVersions(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Python

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


from google.api_core.client_options import ClientOptions
from google.cloud import documentai  # type: ignore

# TODO(developer): Uncomment these variables before running the sample.
# project_id = 'YOUR_PROJECT_ID'
# location = 'YOUR_PROCESSOR_LOCATION' # Format is 'us' or 'eu'
# processor_id = 'YOUR_PROCESSOR_ID' # Create processor before running sample


def list_processor_versions_sample(
    project_id: str, location: str, processor_id: str
) -> None:
    # You must set the `api_endpoint` if you use a location other than "us".
    opts = ClientOptions(api_endpoint=f"{location}-documentai.googleapis.com")

    client = documentai.DocumentProcessorServiceClient(client_options=opts)

    # The full resource name of the processor
    # e.g.: projects/project_id/locations/location/processors/processor_id
    parent = client.processor_path(project_id, location, processor_id)

    # Make ListProcessorVersions request
    processor_versions = client.list_processor_versions(parent=parent)

    # Print the processor version information
    for processor_version in processor_versions:
        processor_version_id = client.parse_processor_version_path(
            processor_version.name
        )["processor_version"]

        print(f"Processor Version: {processor_version_id}")
        print(f"Display Name: {processor_version.display_name}")
        print(f"DEPLOYED: {processor_version.state}")
        print("")

Ruby

Para obtener más información, consulta la documentación de referencia de la API Ruby de Document AI.

require "google/cloud/document_ai/v1"

##
# Snippet for the list_processor_versions call in the DocumentProcessorService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client#list_processor_versions.
#
def list_processor_versions
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DocumentAI::V1::ListProcessorVersionsRequest.new

  # Call the list_processor_versions method.
  result = client.list_processor_versions request

  # The returned object is of type Gapic::PagedEnumerable. You can iterate
  # over elements, and API calls will be issued to fetch pages as needed.
  result.each do |item|
    # Each element is of type ::Google::Cloud::DocumentAI::V1::ProcessorVersion.
    p item
  end
end

Ver los detalles de una versión

Consola

En la consola de Google Cloud , en la sección Document AI, ve a la página Procesadores.

Ir a Procesadores
En la lista de procesadores, haz clic en el nombre del procesador del que quieras ver los detalles.
Seleccione la pestaña Gestionar versiones (o Implementar y usar), donde se mostrarán todas las versiones disponibles del procesador y sus detalles.

REST

En este ejemplo se muestra cómo obtener detalles sobre una versión de un procesador mediante el método processorVersions.get de su procesador.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION: la ubicación de tu procesador, por ejemplo:
- us - Estados Unidos
- eu - Unión Europea
PROJECT_ID: tu ID de proyecto Google Cloud .
PROCESSOR_ID: el ID de tu procesador personalizado.
PROCESSOR_VERSION: identificador de la versión del procesador. Consulta Seleccionar una versión del procesador para obtener más información. Por ejemplo:
- pretrained-TYPE-vX.X-YYYY-MM-DD
- stable
- rc

Método HTTP y URL:

GET https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el comando siguiente:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION"

PowerShell

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION" | Select-Object -Expand Content

La respuesta es un elemento ProcessorVersion, que contiene información sobre la versión del procesador, como su name, state y otros detalles.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/pretrained-ocr-v1.1-2022-09-12",
  "displayName": "Google Release Candidate",
  "state": "DEPLOYED",
  "createTime": "2022-09-13T23:39:12.156648Z",
  "googleManaged": true
}

C#

Para obtener más información, consulta la documentación de referencia de la API C# de Document AI.

using Google.Cloud.DocumentAI.V1;

public sealed partial class GeneratedDocumentProcessorServiceClientSnippets
{
    /// <summary>Snippet for GetProcessorVersion</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void GetProcessorVersionRequestObject()
    {
        // Create client
        DocumentProcessorServiceClient documentProcessorServiceClient = DocumentProcessorServiceClient.Create();
        // Initialize request argument(s)
        GetProcessorVersionRequest request = new GetProcessorVersionRequest
        {
            ProcessorVersionName = ProcessorVersionName.FromProjectLocationProcessorProcessorVersion("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]"),
        };
        // Make the request
        ProcessorVersion response = documentProcessorServiceClient.GetProcessorVersion(request);
    }
}

Go

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


package main

import (
	"context"

	documentai "cloud.google.com/go/documentai/apiv1"
	documentaipb "cloud.google.com/go/documentai/apiv1/documentaipb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := documentai.NewDocumentProcessorClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &documentaipb.GetProcessorVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/documentai/apiv1/documentaipb#GetProcessorVersionRequest.
	}
	resp, err := c.GetProcessorVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

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

import com.google.cloud.documentai.v1.DocumentProcessorServiceClient;
import com.google.cloud.documentai.v1.GetProcessorVersionRequest;
import com.google.cloud.documentai.v1.ProcessorVersion;
import com.google.cloud.documentai.v1.ProcessorVersionName;

public class SyncGetProcessorVersion {

  public static void main(String[] args) throws Exception {
    syncGetProcessorVersion();
  }

  public static void syncGetProcessorVersion() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DocumentProcessorServiceClient documentProcessorServiceClient =
        DocumentProcessorServiceClient.create()) {
      GetProcessorVersionRequest request =
          GetProcessorVersionRequest.newBuilder()
              .setName(
                  ProcessorVersionName.of(
                          "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
                      .toString())
              .build();
      ProcessorVersion response = documentProcessorServiceClient.getProcessorVersion(request);
    }
  }
}

Python

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


from google.api_core.client_options import ClientOptions
from google.cloud import documentai  # type: ignore

# TODO(developer): Uncomment these variables before running the sample.
# project_id = 'YOUR_PROJECT_ID'
# location = 'YOUR_PROCESSOR_LOCATION' # Format is 'us' or 'eu'
# processor_id = 'YOUR_PROCESSOR_ID' # Create processor before running sample
# processor_version_id = 'YOUR_PROCESSOR_VERSION_ID'


def get_processor_version_sample(
    project_id: str, location: str, processor_id: str, processor_version_id: str
) -> None:
    # You must set the api_endpoint if you use a location other than 'us'.
    opts = ClientOptions(api_endpoint=f"{location}-documentai.googleapis.com")

    client = documentai.DocumentProcessorServiceClient(client_options=opts)

    # The full resource name of the processor version
    # e.g.: projects/project_id/locations/location/processors/processor_id/processorVersions/processor_version_id
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version_id
    )

    # Make GetProcessorVersion request
    processor_version = client.get_processor_version(name=name)

    # Print the processor version information
    print(f"Processor Version: {processor_version_id}")
    print(f"Display Name: {processor_version.display_name}")
    print(f"DEPLOYED: {processor_version.state}")

Ruby

Para obtener más información, consulta la documentación de referencia de la API Ruby de Document AI.

require "google/cloud/document_ai/v1"

##
# Snippet for the get_processor_version call in the DocumentProcessorService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client#get_processor_version.
#
def get_processor_version
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DocumentAI::V1::GetProcessorVersionRequest.new

  # Call the get_processor_version method.
  result = client.get_processor_version request

  # The returned object is of type Google::Cloud::DocumentAI::V1::ProcessorVersion.
  p result
end

Cambiar la versión predeterminada

La versión predeterminada de un procesador especifica la versión que se usa para procesar documentos cuando no se especifica una versión concreta. Cuando crea un procesador, la versión predeterminada inicial es la más reciente del canal estable.

Si cambia la versión predeterminada, las solicitudes entrantes se procesarán con la versión que haya seleccionado. Si cambia la versión predeterminada mientras el procesador está en medio de una solicitud, la solicitud seguirá usando la versión seleccionada anteriormente.

Para cambiar la versión predeterminada, sigue estos pasos:

Consola

En la consola de Google Cloud , en la sección Document AI, ve a la página Procesadores.

Ir a la página Procesadores
En la lista de procesadores, haz clic en el nombre del procesador del que quieras ver los detalles.
En la pestaña Gestionar versiones (o Implementar y usar) del procesador, en el menú desplegable Versión predeterminada, elige la versión del procesador que quieras usar como versión predeterminada.

REST

En este ejemplo se muestra cómo definir la versión predeterminada del procesador para tu procesador mediante el método processors.setDefaultProcessorVersion.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION: la ubicación de tu procesador, por ejemplo:
- us - Estados Unidos
- eu - Unión Europea
PROJECT_ID: tu ID de proyecto Google Cloud .
PROCESSOR_ID: el ID de tu procesador personalizado.
PROCESSOR_VERSION: identificador de la versión del procesador. Consulta Seleccionar una versión del procesador para obtener más información. Por ejemplo:
- pretrained-TYPE-vX.X-YYYY-MM-DD
- stable
- rc

Método HTTP y URL:

POST https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID:setDefaultProcessorVersion

Cuerpo JSON de la solicitud:

{
  "defaultProcessorVersion": "PROCESSOR_VERSION"
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID:setDefaultProcessorVersion"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID:setDefaultProcessorVersion" | Select-Object -Expand Content

La respuesta es una operación de larga duración. Para sondear la operación de larga duración, llama a operations.get.

El SetDefaultProcessorVersionMetadata de la respuesta indica el estado de la operación.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.documentai.v1.SetDefaultProcessorVersionMetadata",
    "commonMetadata": {
      "state": "SUCCEEDED",
      "createTime": "2022-03-02T22:52:49.957096Z",
      "updateTime": "2022-03-02T22:52:50.175976Z",
      "resource": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION"
    }
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.documentai.v1.SetDefaultProcessorVersionResponse"
  }
}

C#

Para obtener más información, consulta la documentación de referencia de la API C# de Document AI.

using Google.Cloud.DocumentAI.V1;
using Google.LongRunning;

public sealed partial class GeneratedDocumentProcessorServiceClientSnippets
{
    /// <summary>Snippet for SetDefaultProcessorVersion</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void SetDefaultProcessorVersionRequestObject()
    {
        // Create client
        DocumentProcessorServiceClient documentProcessorServiceClient = DocumentProcessorServiceClient.Create();
        // Initialize request argument(s)
        SetDefaultProcessorVersionRequest request = new SetDefaultProcessorVersionRequest
        {
            ProcessorAsProcessorName = ProcessorName.FromProjectLocationProcessor("[PROJECT]", "[LOCATION]", "[PROCESSOR]"),
            DefaultProcessorVersionAsProcessorVersionName = ProcessorVersionName.FromProjectLocationProcessorProcessorVersion("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]"),
        };
        // Make the request
        Operation<SetDefaultProcessorVersionResponse, SetDefaultProcessorVersionMetadata> response = documentProcessorServiceClient.SetDefaultProcessorVersion(request);

        // Poll until the returned long-running operation is complete
        Operation<SetDefaultProcessorVersionResponse, SetDefaultProcessorVersionMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        SetDefaultProcessorVersionResponse result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<SetDefaultProcessorVersionResponse, SetDefaultProcessorVersionMetadata> retrievedResponse = documentProcessorServiceClient.PollOnceSetDefaultProcessorVersion(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            SetDefaultProcessorVersionResponse retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

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


package main

import (
	"context"

	documentai "cloud.google.com/go/documentai/apiv1"
	documentaipb "cloud.google.com/go/documentai/apiv1/documentaipb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := documentai.NewDocumentProcessorClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &documentaipb.SetDefaultProcessorVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/documentai/apiv1/documentaipb#SetDefaultProcessorVersionRequest.
	}
	op, err := c.SetDefaultProcessorVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

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

import com.google.cloud.documentai.v1.DocumentProcessorServiceClient;
import com.google.cloud.documentai.v1.ProcessorName;
import com.google.cloud.documentai.v1.ProcessorVersionName;
import com.google.cloud.documentai.v1.SetDefaultProcessorVersionRequest;
import com.google.cloud.documentai.v1.SetDefaultProcessorVersionResponse;

public class SyncSetDefaultProcessorVersion {

  public static void main(String[] args) throws Exception {
    syncSetDefaultProcessorVersion();
  }

  public static void syncSetDefaultProcessorVersion() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DocumentProcessorServiceClient documentProcessorServiceClient =
        DocumentProcessorServiceClient.create()) {
      SetDefaultProcessorVersionRequest request =
          SetDefaultProcessorVersionRequest.newBuilder()
              .setProcessor(ProcessorName.of("[PROJECT]", "[LOCATION]", "[PROCESSOR]").toString())
              .setDefaultProcessorVersion(
                  ProcessorVersionName.of(
                          "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
                      .toString())
              .build();
      SetDefaultProcessorVersionResponse response =
          documentProcessorServiceClient.setDefaultProcessorVersionAsync(request).get();
    }
  }
}

Python

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


from google.api_core.client_options import ClientOptions
from google.api_core.exceptions import NotFound
from google.cloud import documentai  # type: ignore

# TODO(developer): Uncomment these variables before running the sample.
# project_id = 'YOUR_PROJECT_ID'
# location = 'YOUR_PROCESSOR_LOCATION' # Format is 'us' or 'eu'
# processor_id = 'YOUR_PROCESSOR_ID' # Create processor before running sample
# processor_version_id = 'YOUR_PROCESSOR_VERSION_ID'


def set_default_processor_version_sample(
    project_id: str, location: str, processor_id: str, processor_version_id: str
) -> None:
    # You must set the api_endpoint if you use a location other than 'us'.
    opts = ClientOptions(api_endpoint=f"{location}-documentai.googleapis.com")

    client = documentai.DocumentProcessorServiceClient(client_options=opts)

    # The full resource name of the processor
    # e.g.: projects/project_id/locations/location/processors/processor_id
    processor = client.processor_path(project_id, location, processor_id)

    # The full resource name of the processor version
    # e.g.: projects/project_id/locations/location/processors/processor_id/processorVersions/processor_version_id
    processor_version = client.processor_version_path(
        project_id, location, processor_id, processor_version_id
    )

    request = documentai.SetDefaultProcessorVersionRequest(
        processor=processor, default_processor_version=processor_version
    )

    # Make SetDefaultProcessorVersion request
    try:
        operation = client.set_default_processor_version(request)
        # Print operation details
        print(operation.operation.name)
        # Wait for operation to complete
        operation.result()
    except NotFound as e:
        print(e.message)

Ruby

Para obtener más información, consulta la documentación de referencia de la API Ruby de Document AI.

require "google/cloud/document_ai/v1"

##
# Snippet for the set_default_processor_version call in the DocumentProcessorService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client#set_default_processor_version.
#
def set_default_processor_version
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DocumentAI::V1::SetDefaultProcessorVersionRequest.new

  # Call the set_default_processor_version method.
  result = client.set_default_processor_version request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Desplegar una versión de un procesador

Después de crear una nueva versión del procesador con Document AI, tendrás que implementarla para poder procesar documentos con esta versión.

Consola

En la consola de Google Cloud , en la sección Document AI, ve a la página Procesadores.

Ir a la página Procesadores
En la lista de procesadores, haz clic en el nombre del procesador del que quieras ver los detalles.
En la pestaña Gestionar versiones (o Implementar y usar) del procesador, selecciona la casilla situada junto a la versión del procesador que quieras implementar.
Haz clic en Desplegar y, a continuación, vuelve a hacer clic en Desplegar en la ventana de diálogo. Este proceso tarda unos minutos.

REST

En este ejemplo se muestra cómo desplegar una versión de un procesador mediante el método processorVersions.deploy.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION: la ubicación de tu procesador, por ejemplo:
- us - Estados Unidos
- eu - Unión Europea
PROJECT_ID: tu ID de proyecto Google Cloud .
PROCESSOR_ID: el ID de tu procesador personalizado.
PROCESSOR_VERSION: identificador de la versión del procesador.

Método HTTP y URL:

POST https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:deploy

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el comando siguiente:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d "" \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:deploy"

PowerShell

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:deploy" | Select-Object -Expand Content

La respuesta es una operación de larga duración. Para sondear la operación de larga duración, llama a operations.get.

El DeployProcessorVersionMetadata de la respuesta indica el estado de la operación.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.documentai.v1.DeployProcessorVersionMetadata",
    "commonMetadata": {
      "state": "SUCCEEDED",
      "createTime": "2022-08-29T16:27:00.195539Z",
      "updateTime": "2022-08-29T16:32:01.963962Z",
      "resource": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION"
    }
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.documentai.v1.DeployProcessorVersionResponse"
  }
}

C#

Para obtener más información, consulta la documentación de referencia de la API C# de Document AI.

using Google.Cloud.DocumentAI.V1;
using Google.LongRunning;

public sealed partial class GeneratedDocumentProcessorServiceClientSnippets
{
    /// <summary>Snippet for DeployProcessorVersion</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void DeployProcessorVersionRequestObject()
    {
        // Create client
        DocumentProcessorServiceClient documentProcessorServiceClient = DocumentProcessorServiceClient.Create();
        // Initialize request argument(s)
        DeployProcessorVersionRequest request = new DeployProcessorVersionRequest
        {
            ProcessorVersionName = ProcessorVersionName.FromProjectLocationProcessorProcessorVersion("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]"),
        };
        // Make the request
        Operation<DeployProcessorVersionResponse, DeployProcessorVersionMetadata> response = documentProcessorServiceClient.DeployProcessorVersion(request);

        // Poll until the returned long-running operation is complete
        Operation<DeployProcessorVersionResponse, DeployProcessorVersionMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DeployProcessorVersionResponse result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DeployProcessorVersionResponse, DeployProcessorVersionMetadata> retrievedResponse = documentProcessorServiceClient.PollOnceDeployProcessorVersion(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DeployProcessorVersionResponse retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

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


package main

import (
	"context"

	documentai "cloud.google.com/go/documentai/apiv1"
	documentaipb "cloud.google.com/go/documentai/apiv1/documentaipb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := documentai.NewDocumentProcessorClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &documentaipb.DeployProcessorVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/documentai/apiv1/documentaipb#DeployProcessorVersionRequest.
	}
	op, err := c.DeployProcessorVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

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

import com.google.cloud.documentai.v1.DeployProcessorVersionRequest;
import com.google.cloud.documentai.v1.DeployProcessorVersionResponse;
import com.google.cloud.documentai.v1.DocumentProcessorServiceClient;
import com.google.cloud.documentai.v1.ProcessorVersionName;

public class SyncDeployProcessorVersion {

  public static void main(String[] args) throws Exception {
    syncDeployProcessorVersion();
  }

  public static void syncDeployProcessorVersion() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DocumentProcessorServiceClient documentProcessorServiceClient =
        DocumentProcessorServiceClient.create()) {
      DeployProcessorVersionRequest request =
          DeployProcessorVersionRequest.newBuilder()
              .setName(
                  ProcessorVersionName.of(
                          "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
                      .toString())
              .build();
      DeployProcessorVersionResponse response =
          documentProcessorServiceClient.deployProcessorVersionAsync(request).get();
    }
  }
}

Python

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


from google.api_core.client_options import ClientOptions
from google.api_core.exceptions import FailedPrecondition
from google.cloud import documentai  # type: ignore

# TODO(developer): Uncomment these variables before running the sample.
# project_id = 'YOUR_PROJECT_ID'
# location = 'YOUR_PROCESSOR_LOCATION' # Format is 'us' or 'eu'
# processor_id = 'YOUR_PROCESSOR_ID'
# processor_version_id = 'YOUR_PROCESSOR_VERSION_ID'


def deploy_processor_version_sample(
    project_id: str, location: str, processor_id: str, processor_version_id: str
) -> None:
    # You must set the api_endpoint if you use a location other than 'us'.
    opts = ClientOptions(api_endpoint=f"{location}-documentai.googleapis.com")

    client = documentai.DocumentProcessorServiceClient(client_options=opts)

    # The full resource name of the processor version
    # e.g.: projects/project_id/locations/location/processors/processor_id/processorVersions/processor_version_id
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version_id
    )

    # Make DeployProcessorVersion request
    try:
        operation = client.deploy_processor_version(name=name)
        # Print operation details
        print(operation.operation.name)
        # Wait for operation to complete
        operation.result()
    # Deploy request will fail if the
    # processor version is already deployed
    except FailedPrecondition as e:
        print(e.message)

Ruby

Para obtener más información, consulta la documentación de referencia de la API Ruby de Document AI.

require "google/cloud/document_ai/v1"

##
# Snippet for the deploy_processor_version call in the DocumentProcessorService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client#deploy_processor_version.
#
def deploy_processor_version
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DocumentAI::V1::DeployProcessorVersionRequest.new

  # Call the deploy_processor_version method.
  result = client.deploy_processor_version request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Anular el despliegue de una versión de procesador

Después de crear una nueva versión del procesador con Document AI e implementarla, puedes dejar de implementarla si no quieres que la versión del procesador pueda gestionar solicitudes de procesamiento.

Consola

En la consola de Google Cloud , en la sección Document AI, ve a la página Procesadores.

Ir a la página Procesadores
En la lista de procesadores, haz clic en el nombre del procesador del que quieras ver los detalles.
En la pestaña Gestionar versiones (o Implementar y usar) del procesador, selecciona la casilla situada junto a la versión del procesador que quieras retirar.
Haz clic en Desplegar y, a continuación, vuelve a hacer clic en Desplegar en la ventana de diálogo. Este proceso tarda unos minutos.

REST

En este ejemplo se muestra cómo retirar una versión de un procesador de tu procesador mediante el método processorVersions.undeploy.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION: la ubicación de tu procesador, por ejemplo:
- us - Estados Unidos
- eu - Unión Europea
PROJECT_ID: tu ID de proyecto Google Cloud .
PROCESSOR_ID: el ID de tu procesador personalizado.
PROCESSOR_VERSION: identificador de la versión del procesador.

Método HTTP y URL:

POST https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:undeploy

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el comando siguiente:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d "" \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:undeploy"

PowerShell

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:undeploy" | Select-Object -Expand Content

La respuesta es una operación de larga duración. Para sondear la operación de larga duración, llama a operations.get.

El UndeployProcessorVersionMetadata de la respuesta indica el estado de la operación.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.documentai.v1.UndeployProcessorVersionMetadata",
    "commonMetadata": {
      "state": "SUCCEEDED",
      "createTime": "2022-08-29T16:27:00.195539Z",
      "updateTime": "2022-08-29T16:32:01.963962Z",
      "resource": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION"
    }
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.documentai.v1.UndeployProcessorVersionResponse"
  }
}

C#

Para obtener más información, consulta la documentación de referencia de la API C# de Document AI.

using Google.Cloud.DocumentAI.V1;
using Google.LongRunning;

public sealed partial class GeneratedDocumentProcessorServiceClientSnippets
{
    /// <summary>Snippet for UndeployProcessorVersion</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void UndeployProcessorVersionRequestObject()
    {
        // Create client
        DocumentProcessorServiceClient documentProcessorServiceClient = DocumentProcessorServiceClient.Create();
        // Initialize request argument(s)
        UndeployProcessorVersionRequest request = new UndeployProcessorVersionRequest
        {
            ProcessorVersionName = ProcessorVersionName.FromProjectLocationProcessorProcessorVersion("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]"),
        };
        // Make the request
        Operation<UndeployProcessorVersionResponse, UndeployProcessorVersionMetadata> response = documentProcessorServiceClient.UndeployProcessorVersion(request);

        // Poll until the returned long-running operation is complete
        Operation<UndeployProcessorVersionResponse, UndeployProcessorVersionMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        UndeployProcessorVersionResponse result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<UndeployProcessorVersionResponse, UndeployProcessorVersionMetadata> retrievedResponse = documentProcessorServiceClient.PollOnceUndeployProcessorVersion(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            UndeployProcessorVersionResponse retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

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


package main

import (
	"context"

	documentai "cloud.google.com/go/documentai/apiv1"
	documentaipb "cloud.google.com/go/documentai/apiv1/documentaipb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := documentai.NewDocumentProcessorClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &documentaipb.UndeployProcessorVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/documentai/apiv1/documentaipb#UndeployProcessorVersionRequest.
	}
	op, err := c.UndeployProcessorVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

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

import com.google.cloud.documentai.v1.DocumentProcessorServiceClient;
import com.google.cloud.documentai.v1.ProcessorVersionName;
import com.google.cloud.documentai.v1.UndeployProcessorVersionRequest;
import com.google.cloud.documentai.v1.UndeployProcessorVersionResponse;

public class SyncUndeployProcessorVersion {

  public static void main(String[] args) throws Exception {
    syncUndeployProcessorVersion();
  }

  public static void syncUndeployProcessorVersion() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DocumentProcessorServiceClient documentProcessorServiceClient =
        DocumentProcessorServiceClient.create()) {
      UndeployProcessorVersionRequest request =
          UndeployProcessorVersionRequest.newBuilder()
              .setName(
                  ProcessorVersionName.of(
                          "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
                      .toString())
              .build();
      UndeployProcessorVersionResponse response =
          documentProcessorServiceClient.undeployProcessorVersionAsync(request).get();
    }
  }
}

Python

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


from google.api_core.client_options import ClientOptions
from google.api_core.exceptions import FailedPrecondition
from google.api_core.exceptions import InvalidArgument
from google.cloud import documentai  # type: ignore

# TODO(developer): Uncomment these variables before running the sample.
# project_id = 'YOUR_PROJECT_ID'
# location = 'YOUR_PROCESSOR_LOCATION' # Format is 'us' or 'eu'
# processor_id = 'YOUR_PROCESSOR_ID' # Create processor before running sample
# processor_version_id = 'YOUR_PROCESSOR_VERSION_ID'


def undeploy_processor_version_sample(
    project_id: str, location: str, processor_id: str, processor_version_id: str
) -> None:
    # You must set the api_endpoint if you use a location other than 'us'.
    opts = ClientOptions(api_endpoint=f"{location}-documentai.googleapis.com")

    client = documentai.DocumentProcessorServiceClient(client_options=opts)

    # The full resource name of the processor version
    # e.g.: projects/project_id/locations/location/processors/processor_id/processorVersions/processor_version_id
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version_id
    )

    # Make UndeployProcessorVersion request
    try:
        operation = client.undeploy_processor_version(name=name)
        # Print operation details
        print(operation.operation.name)
        # Wait for operation to complete
        operation.result()
    # Undeploy request will fail if the
    # processor version is already undeployed
    # or if a request is made on a pretrained processor version
    except (FailedPrecondition, InvalidArgument) as e:
        print(e.message)

Ruby

Para obtener más información, consulta la documentación de referencia de la API Ruby de Document AI.

require "google/cloud/document_ai/v1"

##
# Snippet for the undeploy_processor_version call in the DocumentProcessorService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client#undeploy_processor_version.
#
def undeploy_processor_version
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DocumentAI::V1::UndeployProcessorVersionRequest.new

  # Call the undeploy_processor_version method.
  result = client.undeploy_processor_version request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Eliminar una versión de un procesador

Después de crear una nueva versión de un procesador con Document AI, puedes eliminarla si ya no la necesitas.

Consola

En la consola de Google Cloud , en la sección Document AI, ve a la página Procesadores.

Ir a la página Procesadores
En la lista de procesadores, haz clic en el nombre del procesador del que quieras ver los detalles.
En la pestaña Gestionar versiones (o Implementar y usar) del procesador, haz clic en el menú de acciones situado junto a la versión del procesador que quieras eliminar.
Haz clic en Eliminar y, a continuación, vuelve a hacer clic en Eliminar en la ventana del cuadro de diálogo.

REST

En este ejemplo se muestra cómo eliminar una versión de un procesador mediante el método processorVersions.delete.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION: la ubicación de tu procesador, por ejemplo:
- us - Estados Unidos
- eu - Unión Europea
PROJECT_ID: tu ID de proyecto Google Cloud .
PROCESSOR_ID: el ID de tu procesador personalizado.
PROCESSOR_VERSION: identificador de la versión del procesador.

Método HTTP y URL:

DELETE https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el comando siguiente:

curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION"

PowerShell

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method DELETE `
    -Headers $headers `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION" | Select-Object -Expand Content

La respuesta es una operación de larga duración. Para sondear la operación de larga duración, llama a operations.get.

El DeleteProcessorVersionMetadata de la respuesta indica el estado de la operación.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.documentai.v1.DeleteProcessorVersionMetadata",
    "commonMetadata": {
      "state": "SUCCEEDED",
      "createTime": "2022-08-29T16:27:00.195539Z",
      "updateTime": "2022-08-29T16:32:01.963962Z",
      "resource": "projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION"
    }
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

C#

Para obtener más información, consulta la documentación de referencia de la API C# de Document AI.

using Google.Cloud.DocumentAI.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDocumentProcessorServiceClientSnippets
{
    /// <summary>Snippet for DeleteProcessorVersion</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void DeleteProcessorVersionRequestObject()
    {
        // Create client
        DocumentProcessorServiceClient documentProcessorServiceClient = DocumentProcessorServiceClient.Create();
        // Initialize request argument(s)
        DeleteProcessorVersionRequest request = new DeleteProcessorVersionRequest
        {
            ProcessorVersionName = ProcessorVersionName.FromProjectLocationProcessorProcessorVersion("[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]"),
        };
        // Make the request
        Operation<Empty, DeleteProcessorVersionMetadata> response = documentProcessorServiceClient.DeleteProcessorVersion(request);

        // Poll until the returned long-running operation is complete
        Operation<Empty, DeleteProcessorVersionMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        Empty result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<Empty, DeleteProcessorVersionMetadata> retrievedResponse = documentProcessorServiceClient.PollOnceDeleteProcessorVersion(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            Empty retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

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


package main

import (
	"context"

	documentai "cloud.google.com/go/documentai/apiv1"
	documentaipb "cloud.google.com/go/documentai/apiv1/documentaipb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := documentai.NewDocumentProcessorClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &documentaipb.DeleteProcessorVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/documentai/apiv1/documentaipb#DeleteProcessorVersionRequest.
	}
	op, err := c.DeleteProcessorVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

Java

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

import com.google.cloud.documentai.v1.DeleteProcessorVersionRequest;
import com.google.cloud.documentai.v1.DocumentProcessorServiceClient;
import com.google.cloud.documentai.v1.ProcessorVersionName;
import com.google.protobuf.Empty;

public class SyncDeleteProcessorVersion {

  public static void main(String[] args) throws Exception {
    syncDeleteProcessorVersion();
  }

  public static void syncDeleteProcessorVersion() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DocumentProcessorServiceClient documentProcessorServiceClient =
        DocumentProcessorServiceClient.create()) {
      DeleteProcessorVersionRequest request =
          DeleteProcessorVersionRequest.newBuilder()
              .setName(
                  ProcessorVersionName.of(
                          "[PROJECT]", "[LOCATION]", "[PROCESSOR]", "[PROCESSOR_VERSION]")
                      .toString())
              .build();
      documentProcessorServiceClient.deleteProcessorVersionAsync(request).get();
    }
  }
}

Python

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


from google.api_core.client_options import ClientOptions
from google.api_core.exceptions import FailedPrecondition
from google.api_core.exceptions import InvalidArgument
from google.cloud import documentai  # type: ignore

# TODO(developer): Uncomment these variables before running the sample.
# project_id = 'YOUR_PROJECT_ID'
# location = 'YOUR_PROCESSOR_LOCATION' # Format is 'us' or 'eu'
# processor_id = 'YOUR_PROCESSOR_ID' # Create processor before running sample
# processor_version_id = 'YOUR_PROCESSOR_VERSION_ID'


def delete_processor_version_sample(
    project_id: str, location: str, processor_id: str, processor_version_id: str
) -> None:
    # You must set the api_endpoint if you use a location other than 'us'.
    opts = ClientOptions(api_endpoint=f"{location}-documentai.googleapis.com")

    client = documentai.DocumentProcessorServiceClient(client_options=opts)

    # The full resource name of the processor version
    # e.g.: projects/project_id/locations/location/processors/processor_id/processorVersions/processor_version_id
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version_id
    )

    # Make DeleteProcessorVersion request
    try:
        operation = client.delete_processor_version(name=name)
        # Print operation details
        print(operation.operation.name)
        # Wait for operation to complete
        operation.result()
    # Delete request will fail if the
    # processor version doesn't exist
    # or if a request is made on a pretrained processor version
    # or the default processor version
    except (FailedPrecondition, InvalidArgument) as e:
        print(e.message)

Ruby

Para obtener más información, consulta la documentación de referencia de la API Ruby de Document AI.

require "google/cloud/document_ai/v1"

##
# Snippet for the delete_processor_version call in the DocumentProcessorService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client#delete_processor_version.
#
def delete_processor_version
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DocumentAI::V1::DocumentProcessorService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DocumentAI::V1::DeleteProcessorVersionRequest.new

  # Call the delete_processor_version method.
  result = client.delete_processor_version request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Importar una versión de procesador

Después de crear un procesador con Document AI, puedes importar una versión del procesador del mismo proyecto o de otro.

En destination project es donde se inicia la importación y donde la versión del procesador estará disponible después de la importación.

El source project es la versión del procesador de origen.

Los procesadores de origen o de destino deben cumplir los siguientes requisitos para poder importar:

Los tipos de procesador deben coincidir. Ejemplos: CUSTOM_EXTRACTION_PROCESSOR o INVOICE_PROCESSOR
Los esquemas de procesador no deben entrar en conflicto.
El procesador de destino puede tener conjuntos de datos y versiones.
El procesador de destino debe estar en estado ENABLED.
La versión del procesador de origen debe tener uno de los siguientes estados:
- DEPLOYED
- DEPLOYING
- UNDEPLOYED
- UNDEPLOYING

Debe conceder el permiso Editor de Documentos IA al agente de servicios principales de Documentos IA del proyecto de destino en el proyecto de origen para evitar un error de permiso denegado.

En el caso de las versiones del procesador basadas en Gemini 1.5 y versiones posteriores, como los extractores personalizados pretrained-foundation-model-v1.2-2024-05-10, puedes importar versiones del procesador ajustadas.

Siga estos pasos para configurar los permisos antes de importar una versión de procesador:

Consola

Busca Agente de servicios principales de Documentos IA y rellena el número de tu proyecto de destino. El agente de servicios principales de Documentos IA tiene el formato de una dirección de correo electrónico. Por ejemplo: service-123@gcp-sa-prod-dai-core.iam.gserviceaccount.com
Abre la página de IAM en la Google Cloud consola.

Abre la página de gestión de identidades y accesos.
Selecciona el proyecto de origen.
Haz clic en Conceder acceso.
Añade el agente de servicio principal de Documentos IA del proyecto de destino como un nuevo principal y asigna el rol Editor de Documentos IA.

gcloud

Usa el siguiente comando gcloud para conceder los permisos necesarios:

gcloud projects add-iam-policy-binding SOURCE_PROJECT \
    --member=serviceAccount:service-DESTINATION_PROJECT NUMBER@gcp-sa-prod-dai-core.iam.gserviceaccount.com \
    --role=roles/documentai.editor

Proporciona los siguientes valores:

SOURCE_PROJECT: número o ID del proyecto de origen.
DESTINATION_PROJECT NUMBER: el número del proyecto de destino.

Después de actualizar los permisos, siga estos pasos para importar una versión del procesador:

Consola

En la consola de Google Cloud , en la sección Document AI, ve a la página Procesadores.

Ir a la página Procesadores
En la lista de procesadores, haz clic en el nombre del procesador al que quieras importar una versión como procesador de destino.
Ve a la pestaña Gestionar versiones (o Implementar y usar) y haz clic en Importar.
Elige el proyecto, el procesador y la versión del procesador de origen en la ventana.
Haz clic en el botón IMPORT de la ventana para iniciar la importación.

REST

En este ejemplo se muestra cómo usar el método processorVersions.importProcessorVersion para importar una versión de un procesador.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

Proyecto de destino
- DESTINATION_PROJECT_ID: el ID de tu proyecto de destino. Google Cloud
- DESTINATION_LOCATION: la ubicación del procesador de destino.
- DESTINATION_PROCESSOR_ID: el ID de tu procesador de destino.
Proyecto de origen
- SOURCE_PROJECT_ID: el ID de tu proyecto de origen. Google Cloud
- SOURCE_LOCATION: la ubicación del procesador de origen.
- SOURCE_PROCESSOR_ID: el ID de tu procesador de origen.
- SOURCE_PROCESSOR_VERSION: la versión del procesador de origen que se va a importar.

Método HTTP y URL:

POST https://DESTINATION_LOCATION-documentai.googleapis.com/v1beta3/projects/DESTINATION_PROJECT_ID/locations/DESTINATION_LOCATION/processors/DESTINATION_PROCESSOR_ID/processorVersions:importProcessorVersion

Cuerpo JSON de la solicitud:

{
  "processorVersionSource": "projects/SOURCE_PROJECT_ID/locations/SOURCE_LOCATION/processors/SOURCE_PROCESSOR_ID/processorVersions/SOURCE_PROCESSOR_VERSION"
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://DESTINATION_LOCATION-documentai.googleapis.com/v1beta3/projects/DESTINATION_PROJECT_ID/locations/DESTINATION_LOCATION/processors/DESTINATION_PROCESSOR_ID/processorVersions:importProcessorVersion"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://DESTINATION_LOCATION-documentai.googleapis.com/v1beta3/projects/DESTINATION_PROJECT_ID/locations/DESTINATION_LOCATION/processors/DESTINATION_PROCESSOR_ID/processorVersions:importProcessorVersion" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "name": "projects/DESTINATION_PROJECT_ID/locations/DESTINATION_LOCATION/operations/OPERATION_ID"
}

Si vas a importar datos a través de un perímetro de Controles de Servicio de la nube privada virtual (VPC-SC), consulta cómo configurar políticas de entrada y salida y configurar un perímetro de Controles de Servicio de VPC. A continuación, define las siguientes reglas.

Proporciona los siguientes valores para ingress:

DESTINATION_PROJECT: número del proyecto de destino.
SOURCE_PROJECT: número del proyecto de origen.

- ingressFrom:
    identities:
    - ANY_SERVICE_ACCOUNT
    sources:
    - resource: DESTINATION_PROJECT
  ingressTo:
    operations:
    - serviceName: aiplatform.googleapis.com
      methodSelectors:
      - method: all actions
    - serviceName: documentai.googleapis.com
      methodSelectors:
      - method: all actions
    resources:
    - projects/SOURCE_PROJECT

Proporciona los siguientes valores para egress:

- egressTo:
    operations:
    - serviceName: storage.googleapis.com
      methodSelectors:
      - method: google.storage.objects.create
      - method: google.storage.buckets.testIamPermissions
    resources:
    - projects/DESTINATION_PROJECT
  egressFrom:
    identities:
    - ANY_SERVICE_ACCOUNT

Configura un perímetro de destino de VPC con los siguientes valores.

- egressTo:
    operations:
    - serviceName: aiplatform.googleapis.com
      methodSelectors:
      - method: all actions
    - serviceName: documentai.googleapis.com
      methodSelectors:
      - method: all actions
    - serviceName: storage.googleapis.com
      methodSelectors:
      - method: google.storage.buckets.testIamPermissions
      - method: google.storage.objects.get
      - method: google.storage.objects.create
    resources:
    - projects/SOURCE_PROJECT
  egressFrom:
    identities:
    - ANY_SERVICE_ACCOUNT
    sourceRestriction: DISABLED

Siguientes pasos

Consulta cómo configurar Document AI.
Consulta la lista de procesadores.

Crear un flujo de procesamiento de documentos con Workflows

Migrar versiones de procesadores y conjuntos de datos

Gestionar versiones de procesadores Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Información general sobre las versiones de procesadores

Versiones de Google

Versiones estables de Google

Versiones candidatas para lanzamiento de Google

Versiones personalizadas

Versiones base

Versiones estables disponibles del procesador

Ciclo de vida de las versiones del procesador

¿Qué ocurre cuando se deja de usar una versión base?

¿Cómo se seleccionan las versiones del procesador para tus solicitudes?

Ejemplo de discontinuación de una versión personalizada

Recursos de retirada y migración

Selecciona una versión del procesador

Ver versión disponible

Consola

REST

curl

PowerShell

C#

Go

Java

Python

Ruby

Ver los detalles de una versión

Consola

REST

curl

PowerShell

C#

Go

Java

Python

Ruby

Cambiar la versión predeterminada

Consola

REST

curl

PowerShell

C#

Go

Java

Python

Ruby

Desplegar una versión de un procesador

Consola

REST

curl

PowerShell

C#

Go

Java

Python

Ruby

Anular el despliegue de una versión de procesador

Consola

REST

curl

PowerShell

C#

Go

Java

Python

Ruby

Eliminar una versión de un procesador

Consola

REST

curl

PowerShell

C#

Go

Java

Python

Ruby

Importar una versión de procesador

Consola

gcloud

Consola

REST

curl

Gestionar versiones de procesadores