Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Uso de la CLI de automatización de Amazon Bedrock datos
La función Amazon Bedrock de automatización de datos (BDA) proporciona un flujo de trabajo de CLI optimizado para procesar los datos. Para todas las modalidades, este flujo de trabajo consta de tres pasos principales: crear un proyecto, crear esquemas para una salida personalizada y procesar documentos. En esta guía se explican los comandos principales de la CLI para trabajar con BDA.
## Creación de su primer proyecto de Automatización de Datos
Para empezar a trabajar con BDA, cree primero un proyecto con el comando `create-data-automation-project`.
Considere este ejemplo de pasaporte que procesaremos:
![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/bda/passport2.png)
Al crear un proyecto, debe definir los ajustes de configuración para el tipo de archivo que va a procesar. El siguiente comando representa un ejemplo funcional mínimo para crear un proyecto de procesamiento de imágenes:
```
aws bedrock-data-automation create-data-automation-project \
--project-name "ImageProcessingProject" \
--standard-output-configuration '{
"image": {
"extraction": {
"category": {
"state": "ENABLED",
"types": ["TEXT_DETECTION"]
},
"boundingBox": {
"state": "ENABLED"
}
},
"generativeField": {
"state": "ENABLED"
}
}
}'
```
El comando valida la configuración de entrada y crea un nuevo proyecto con un ARN único. Una respuesta incluiría el ARN y la etapa del proyecto:
```
{
"projectArn": "Amazon Resource Name (ARN)",
"projectStage": "DEVELOPMENT",
"status": "IN_PROGRESS"
}
```
Si se crea un proyecto sin parámetros, se aplicará la configuración predeterminada. Por ejemplo, al procesar imágenes, el resumen de imágenes y la detección de texto estarán habilitadas de forma predeterminada.
## Referencia de parámetros completa
El ejemplo de código siguiente muestra todos los parámetros disponibles para el comando `create-data-automation-project`:
**Parámetros para create-data-automation-project**
| Parámetro | Obligatorio | Predeterminado | Description (Descripción) |
| --- | --- | --- | --- |
| --project-name | Sí | N/A | Nombre del proyecto de Automatización de Datos |
| --project-type | No | El tipo de proyecto define con qué API de procesamiento en tiempo de ejecución se puede usar. ASYNClos proyectos solo se pueden usar con la invoke-bedrock-data-automation-async API, mientras que SYNC los proyectos solo se pueden usar con la invoke-bedrock-data-automation API. |
| --project-stage | No | ACTIVA | Etapa del proyecto (EN DESARROLLO o EN DIRECTO) |
| --standard-output-configuration | Sí | N/A | Configuración JSON para el procesamiento de salida estándar |
| --custom-output-configuration | No | N/A | Configuración JSON para el procesamiento de salida personalizada |
| --encryption-configuration | No | N/A | Configuración de cifrado para el proyecto |
| --client-token | No | Generado automáticamente | Identificador único para la idempotencia de la solicitud |
## Creación de un esquema
Tras crear un proyecto, puede crear un esquema para definir la estructura del procesamiento de datos mediante el comando `create-blueprint`.
Este es un ejemplo funcional mínimo para crear un esquema adaptado al procesamiento de pasaportes:
```
aws bedrock-data-automation create-blueprint \
--blueprint-name "passport-blueprint" \
--type "IMAGE" \
--blueprint-stage "DEVELOPMENT" \
--schema '{
"class": "Passport",
"description": "Blueprint for processing passport images",
"properties": {
"passport_number": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport identification number"
},
"full_name": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The full name of the passport holder"
}
}
}'
```
El comando crea un nuevo esquema con la estructura especificada. A continuación, puede utilizar este esquema al procesar documentos para extraer datos estructurados de acuerdo con la estructura que haya definido.
## Uso del esquema
### Adición de un esquema a un proyecto
Para añadir un esquema a su proyecto, utilice el comando `update-data-automation-project`:
```
aws bedrock-data-automation update-data-automation-project \
--project-arn "Amazon Resource Name (ARN)" \
--standard-output-configuration '{
"image": {
"extraction": {
"category": {
"state": "ENABLED",
"types": ["TEXT_DETECTION"]
},
"boundingBox": {
"state": "ENABLED"
}
},
"generativeField": {
"state": "ENABLED",
"types": ["IMAGE_SUMMARY"]
}
}
}' \
--custom-output-configuration '{
"blueprints": [
{
"blueprintArn": "Amazon Resource Name (ARN)",
"blueprintVersion": "1",
"blueprintStage": "LIVE"
}
]
}'
```
### Verificación de la integración del esquema
Puede verificar la integración del esquema mediante el comando `get-data-automation-project`:
```
aws bedrock-data-automation get-data-automation-project \
--project-arn "Amazon Resource Name (ARN)"
```
### Administración de varios esquemas
Use el comando `list-blueprints` para ver todos tus esquemas:
```
aws bedrock-data-automation list-blueprints
```
## Procesa documentos de forma asíncrona
Antes de procesar documentos con BDA, primero debe cargarlos en un depósito de S3. Una vez que haya configurado un proyecto, podrá procesar los documentos mediante el comando: `invoke-data-automation-async`
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bda-documents/invoices/invoice-123.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bda-documents/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
El comando devuelve un ARN de invocación que puede utilizar para comprobar el estado del procesamiento:
```
{
"invocationArn": "Amazon Resource Name (ARN)"
}
```
## Comprobación de estado de procesamiento
Para comprobar el estado del trabajo de procesamiento, utilice el comando `get-data-automation-status`:
```
aws bedrock-data-automation-runtime get-data-automation-status \
--invocation-arn "Amazon Resource Name (ARN)"
```
El comando devuelve el estado actual del trabajo de procesamiento:
```
{
"status": "COMPLETED",
"creationTime": "2025-07-09T12:34:56.789Z",
"lastModifiedTime": "2025-07-09T12:45:12.345Z",
"outputLocation": "s3://my-bda-documents/output/efgh5678/"
}
```
Los valores de estado posibles son:
+ `IN_PROGRESS`: el trabajo de procesamiento se está ejecutando actualmente.
+ `COMPLETED`: el trabajo de procesamiento se ha completado correctamente.
+ `FAILED`: el trabajo de procesamiento ha fallado. Compruebe la respuesta para ver los detalles del error.
+ `STOPPED`: el trabajo de procesamiento se ha detenido manualmente.
## Recuperación de los resultados
Una vez finalizado el procesamiento, puede mostrar los archivos de salida en su bucket de S3:
```
aws s3 ls s3://my-bda-documents/output/efgh5678/
```
Cómo descargar los resultados en el equipo local:
```
aws s3 cp s3://my-bda-documents/output/efgh5678/ ~/Downloads/bda-results/ --recursive
```
La salida incluye datos estructurados basados en la configuración del proyecto y en los esquemas que haya aplicado.
## Procese los documentos de forma sincrónica
Antes de procesar documentos con BDA, primero debe cargarlos en un bucket de S3. La API de sincronización admite tanto la entrada mediante un depósito de S3 como la de bytes de imagen (es decir, el procesamiento de documentos sin S3). El comando devuelve datos estructurados en función de la configuración del proyecto y de los planos que haya aplicado:
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://my-bda-documents/invoices/invoice-123.pdf"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
## Procesa imágenes de forma sincrónica
El comando devuelve datos estructurados en función de la configuración del proyecto y de los planos que haya aplicado:
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://my-bda-documents/invoices/advertisement_latest.jpeg"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
# CLI de operaciones con esquemas
En esta guía se describen las operaciones de blueprint disponibles a través de la interfaz de línea de comandos (CLI) de AWS para la automatización de Amazon Bedrock datos (BDA).
## Creación de esquemas
Los esquemas definen la estructura y las propiedades de los datos que desea extraer de sus documentos, imágenes, archivos de audio o vídeo. Utilice el comando create-blueprint para definir un nuevo esquema.
El siguiente comando crea un nuevo esquema adaptado para extraer datos de la imagen de un pasaporte.
**Sintaxis**
```
aws bedrock-data-automation create-blueprint \
--blueprint-name "passport-blueprint" \
--type "IMAGE" \
--blueprint-stage "DEVELOPMENT" \
--schema '{
"class": "Passport",
"description": "Blueprint for processing passport images",
"properties": {
"passport_number": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport identification number"
},
"full_name": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The full name of the passport holder"
},
"expiration_date": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport expiration date"
}
}
}'
```
## Referencia de parámetros completa
El ejemplo de código siguiente muestra todos los parámetros disponibles para el comando `create-blueprint`:
**Parámetros de create-blueprint**
| Parámetro | Obligatorio | Predeterminado | Description (Descripción) |
| --- | --- | --- | --- |
| --blueprint-name | Sí | N/A | Nombre del esquema |
| --type | Sí | N/A | Tipo de contenido (IMAGEN, DOCUMENTO, AUDIO, VÍDEO) |
| --blueprint-stage | No | ACTIVA | Etapa del esquema (EN DESARROLLO o EN DIRECTO) |
| --schema | Sí | N/A | Esquema JSON que define la estructura del esquema |
| --client-token | No | Generado automáticamente | Identificador único para la idempotencia de la solicitud |
## Consulta de las configuraciones de esquemas
**Enumeración de todos los esquemas**
Utilice el comando list-blueprints para recuperar una lista de todos los esquemas asociados a su cuenta.
**Sintaxis**
```
aws bedrock-data-automation list-blueprints
```
**Consulta de los detalles del esquema**
Para ver información detallada sobre un esquema específico, incluidos su estructura y configuración, utilice el comando get-blueprint.
**Sintaxis**
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)"
```
**Inspección de una versión específica**
Cuando trabaje con esquemas con control de versiones, utilice el comando get-blueprint con la opción --blueprint-version para ver una versión concreta.
**Sintaxis**
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-version "version-number"
```
**Inspección de una etapa específica**
Para ver los esquemas en la etapa EN DESARROLLO o EN DIRECTO, utilice:
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-stage "LIVE"
```
## Edición de especificaciones del esquema
**Actualización de la configuración del esquema**
Para modificar la estructura o las propiedades de un esquema existente, utilice el comando update-blueprint.
**Sintaxis**
```
aws bedrock-data-automation update-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--schema '{
"class": "Passport",
"description": "Updated blueprint for processing passport images",
"properties": {
"passport_number": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport identification number"
},
"full_name": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The full name of the passport holder"
},
"expiration_date": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The passport expiration date"
}
}
}'
```
**Nota:** Al actualizar un esquema, debe proporcionar la estructura completa, incluso para los campos que no vaya a cambiar.
**Promoción a EN DIRECTO**
Para pasar un esquema de la etapa EN DESARROLLO a EN DIRECTO, utilice el comando update-blueprint con la opción --blueprint-stage.
**Sintaxis**
```
aws bedrock-data-automation update-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-stage "LIVE"
```
**Control de versiones del esquema**
Cree una nueva versión de su Blueprint para conservar su estado actual antes de realizar cambios importantes mediante el create-blueprint-version comando.
**Sintaxis**
```
aws bedrock-data-automation create-blueprint-version \
--blueprint-arn "Amazon Resource Name (ARN)"
```
## Administración de etiquetas de esquemas
Las etiquetas ayudan a los usuarios a organizar y clasificar los esquemas para simplificar la administración.
**Añada etiquetas**
Aplique metadatos a su esquema añadiendo etiquetas.
**Sintaxis**
```
aws bedrock-data-automation tag-resource \
--resource-arn "Amazon Resource Name (ARN)" \
--tags '{"Department":"Finance","Project":"PassportProcessing"}'
```
**Eliminar etiquetas**
Elimine etiquetas específicas de su esquema con el comando untag-resource.
**Sintaxis**
```
aws bedrock-data-automation untag-resource \
--resource-arn "Amazon Resource Name (ARN)" \
--tag-keys '["Department","Project"]'
```
**Consulta de etiquetas**
Haz una lista de todas las etiquetas asociadas a tu Blueprint mediante el list-tags-for-resource comando.
**Sintaxis**
```
aws bedrock-data-automation list-tags-for-resource \
--resource-arn "Amazon Resource Name (ARN)"
```
## Creación de esquemas
**Eliminación de un esquema completo**
Utilice el comando delete-blueprint para eliminar permanentemente un esquema y todas sus versiones.
**Sintaxis**
```
aws bedrock-data-automation delete-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)"
```
**Precaución:** Este comando elimina un esquema de forma permanente y no lo puede recuperar.
**Importante:** No puede eliminar un esquema que esté siendo utilizado actualmente en algún proyecto. Antes de eliminarlo, asegúrese de que no se haga referencia al esquema en la configuración de salida personalizada de ningún proyecto.
## Optimización del plano
### Invocando la optimización de planos
Inicie un trabajo de optimización asíncrona del plan para mejorar las instrucciones del plano para cada uno de los campos del plan y la precisión de los resultados.
**Sintaxis**
```
aws bedrock-data-automation invoke-blueprint-optimization-async \
--blueprint blueprintArn="arn:aws:bedrock:::blueprint/",stage="DEVELOPMENT" \
--samples '[
{
"assetS3Object": {
"s3Uri": "s3://my-optimization-bucket/samples/document1.pdf"
},
"groundTruthS3Object": {
"s3Uri": "s3://my-optimization-bucket/ground-truth/document1-expected.json"
}
}
]' \
--output-configuration s3Object='{s3Uri="s3://my-optimization-bucket/results/optimization-output"}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
### Comprobación del estado de la optimización del plano
Supervise el progreso y los resultados de un trabajo de optimización de planos.
**Sintaxis**
```
aws bedrock-data-automation get-blueprint-optimization-status \
--invocation-arn "arn:aws:bedrock:::blueprint-optimization-invocation/opt-12345abcdef"
```
Utilice este comando para realizar un seguimiento del estado del trabajo de optimización. La respuesta incluye el estado actual (Creado InProgress ServiceError, Éxito o ClientError) y los detalles de la configuración de salida una vez completada.
### Copiar las etapas del plano
Copie un plano de una etapa a otra
**Sintaxis**
```
aws bedrock-data-automation copy-blueprint-stage \
--blueprint-arn "arn:aws:bedrock:::blueprint/" \
--source-stage "DEVELOPMENT" \
--target-stage "LIVE"
```
**Precaución:** Este comando copia toda la configuración del blueprint desde la etapa de origen a la etapa de destino y sobrescribe cualquier configuración existente en la etapa de destino.
**Importante:** Asegúrese de que el blueprint se haya probado exhaustivamente en la fase de origen antes de copiarlo a la fase de producción (LIVE). Esta operación no se puede deshacer fácilmente.
# Procesamiento mediante la CLI
Antes de procesar documentos con BDA, primero debe cargar los documentos en un bucket de S3:
**Sintaxis**
```
aws s3 cp [--options]
```
Ejemplo:
```
aws s3 cp /local/path/document.pdf s3://my-bda-bucket/input/document.pdf
```
------
#### [ Async ]
**Estructura básica de comandos de procesamiento**
Utilice el comando `invoke-data-automation-async` para procesar archivos:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/sample-images/sample-image.jpg"
}' \
--output-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Estructura de comandos de procesamiento avanzada**
**Procesamiento de vídeo con segmentos de tiempo**
Para los archivos de vídeo, puede especificar los segmentos de tiempo que se van a procesar:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/video.mp4",
"assetProcessingConfiguration": {
"video": {
"segmentConfiguration": {
"timestampSegment": {
"startTimeMillis": 0,
"endTimeMillis": 300000
}
}
}
}
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Uso de esquemas personalizados**
Puede especificar esquemas personalizados directamente en el comando:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/document.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--blueprints '[
{
"blueprintArn": "Amazon Resource Name (ARN)",
"version": "1",
"stage": "LIVE"
}
]' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Adición de configuración de cifrado**
Para mejorar la seguridad, puede añadir una configuración de cifrado:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/document.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--encryption-configuration '{
"kmsKeyId": "Amazon Resource Name (ARN)",
"kmsEncryptionContext": {
"Department": "Finance",
"Project": "DocumentProcessing"
}
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Notificaciones de eventos**
Habilite EventBridge las notificaciones para completar el procesamiento:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/document.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--notification-configuration '{
"eventBridgeConfiguration": {
"eventBridgeEnabled": true
}
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
**Comprobar el estado del procesamiento**
Para comprobar el estado del trabajo de procesamiento, utilice el comando `get-data-automation-status`:
```
aws bedrock-data-automation-runtime get-data-automation-status \
--invocation-arn "Amazon Resource Name (ARN)"
```
La respuesta incluirá el estado actual:
```
{
"status": "COMPLETED",
"creationTime": "2025-07-24T12:34:56.789Z",
"lastModifiedTime": "2025-07-24T12:45:12.345Z",
"outputLocation": "s3://my-bucket/output/abcd1234/"
}
```
**Recupera los resultados del procesamiento**
**Localización de los archivos de salida en S3**
Muestre los archivos de salida en su bucket de S3:
```
aws s3 ls s3://amzn-s3-demo-bucket/output/
```
Descargue los resultados en el equipo local:
```
aws s3 cp s3://amzn-s3-demo-bucket/output/ ~/Downloads/bda-results/ --recursive
```
**Descripción de la estructura de salida**
La salida suele incluir lo siguiente:
+ `standard-output.json`: contiene los resultados de extracción estándar
+ `custom-output.json`: contiene los resultados de esquemas personalizados
+ `metadata.json`: contiene los metadatos de procesamiento y las puntuaciones de confianza
**Campos de respuesta comunes**
La salida estándar suele incluir lo siguiente:
+ `extractedData`: la información principal extraída
+ `confidence`: puntuaciones de confianza para cada campo extraído
+ `metadata`: información de procesamiento, incluidas las marcas de tiempo y los detalles del modelo
+ `boundingBoxes`: información de ubicación de los elementos detectados (si se ha activado)
**Manejo de errores y solución de problemas**
Escenarios y soluciones de error comunes:
+ **Invalid S3 URI**: asegúrese de que su bucket de S3 existe y de que tiene los permisos adecuados
+ **Falta data-automation-profile-arn**: este parámetro es obligatorio para todas las solicitudes de procesamiento
+ **Project not found**: compruebe que el ARN de su proyecto sea correcto y que el proyecto exista
+ **Unsupported file format**: compruebe que el formato de archivo sea compatible con BDA
**Añadir etiquetas a los trabajos de procesamiento**
Puede añadir etiquetas para facilitar la organización y el seguimiento de los trabajos de procesamiento:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://my-bucket/document.pdf"
}' \
--output-configuration '{
"s3Uri": "s3://my-bucket/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--tags '[
{
"key": "Department",
"value": "Finance"
},
{
"key": "Project",
"value": "InvoiceProcessing"
}
]' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
```
------
#### [ Sync ]
**Estructura básica de comandos de procesamiento**
Utilice el comando `invoke-data-automation` para procesar archivos:
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/sample-images/sample-image.jpg"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
--region "aws-region"
```
**Estructura de comandos de procesamiento avanzada**
Salida a un bucket S3
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/sample-images/sample-image.jpg"
}' \
--output-configuration '{"s3Uri": "s3://amzn-s3-demo-bucket/output/" }' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
--region "aws-region" //document only
```
Utilice la entrada de bytes
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"bytes": #blob input
}' \
--output-configuration '{"s3Uri": "s3://amzn-s3-demo-bucket/output/" }' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
--region "aws-region"
```
**nota**
**Bytes**
Un bloque de bytes de documento codificados en base64. El tamaño máximo de un documento que se proporciona en un bloque de bytes es de 50 MB. El tipo debe ser un objeto de datos binarios codificado en Base64.
**Utilice planos personalizados (solo para imágenes)**
```
aws bedrock-data-automation-runtime invoke-data-automation \
--input-configuration '{
"s3Uri": "s3://amzn-s3-demo-bucket/sample-images/sample-image.jpg"
}' \
--blueprints '[{"blueprintArn": "Amazon Resource Name (ARN)", "version": "1", "stage": "LIVE" } ]' \
--data-automation-profile-arn "Amazon Resource Name (ARN)"
--region "aws-region"
```
------
# Casos de uso de procesamiento
Automatización de Datos de Amazon Bedrock le permite procesar documentos, imágenes, audio y vídeo a través de la interfaz de la línea de comandos (CLI). Para todas las modalidades, este flujo de trabajo consta de los siguientes pasos: crear un proyecto, invocar el análisis y recuperar el resultado.
Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ Documents ]
**Extracción de datos de un formulario W2**
![\[Ejemplo de formulario W2 con campos estándar, que muestra el diseño y los campos de datos que se extraerán.\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/bda/W2.png)
Al procesar un formulario W2, un ejemplo de esquema sería el siguiente:
```
{
"class": "W2TaxForm",
"description": "Simple schema for extracting key information from W2 tax forms",
"properties": {
"employerName": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The employer's company name"
},
"employeeSSN": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The employee's Social Security Number (SSN)"
},
"employeeName": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The employee's full name"
},
"wagesAndTips": {
"type": "number",
"inferenceType": "explicit",
"instruction": "Wages, tips, other compensation (Box 1)"
},
"federalIncomeTaxWithheld": {
"type": "number",
"inferenceType": "explicit",
"instruction": "Federal income tax withheld (Box 2)"
},
"taxYear": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The tax year for this W2 form"
}
}
}
```
El comando para invocar el procesamiento del formulario W2 debería ser similar al siguiente:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://w2-processing-bucket-301678011486/input/W2.png"
}' \
--output-configuration '{
"s3Uri": "s3://w2-processing-bucket-301678011486/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
Un ejemplo de la salida esperada es:
```
{
"documentType": "W2TaxForm",
"extractedData": {
"employerName": "The Big Company",
"employeeSSN": "123-45-6789",
"employeeName": "Jane Doe",
"wagesAndTips": 48500.00,
"federalIncomeTaxWithheld": 6835.00,
"taxYear": "2014"
},
"confidence": {
"employerName": 0.99,
"employeeSSN": 0.97,
"employeeName": 0.99,
"wagesAndTips": 0.98,
"federalIncomeTaxWithheld": 0.97,
"taxYear": 0.99
},
"metadata": {
"processingTimestamp": "2025-07-23T23:15:30Z",
"documentId": "w2-12345",
"modelId": "amazon.titan-document-v1",
"pageCount": 1
}
}
```
------
#### [ Images ]
**Ejemplo de anuncio de viajes**
![\[Imagen de ejemplo que muestra cómo los usuarios pueden extraer información de los anuncios.\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/bda/TravelAdvertisement.jpg)
Un ejemplo de esquema para anuncios de viajes sería el siguiente:
```
{
"class": "TravelAdvertisement",
"description": "Schema for extracting information from travel advertisement images",
"properties": {
"destination": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The name of the travel destination being advertised"
},
"tagline": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The main promotional text or tagline in the advertisement"
},
"landscapeType": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The type of landscape shown (e.g., mountains, beach, forest, etc.)"
},
"waterFeatures": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Description of any water features visible in the image (ocean, lake, river, etc.)"
},
"dominantColors": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The dominant colors present in the image"
},
"advertisementType": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The type of travel advertisement (e.g., destination promotion, tour package, etc.)"
}
}
}
```
El comando para invocar el procesamiento del anuncio de viajes debería ser similar al siguiente:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://travel-ads-bucket-301678011486/input/TravelAdvertisement.jpg"
}' \
--output-configuration '{
"s3Uri": "s3://travel-ads-bucket-301678011486/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
Un ejemplo de la salida esperada es:
```
{
"documentType": "TravelAdvertisement",
"extractedData": {
"destination": "Kauai",
"tagline": "Travel to KAUAI",
"landscapeType": "Coastal mountains with steep cliffs and valleys",
"waterFeatures": "Turquoise ocean with white surf along the coastline",
"dominantColors": "Green, blue, turquoise, brown, white",
"advertisementType": "Destination promotion"
},
"confidence": {
"destination": 0.98,
"tagline": 0.99,
"landscapeType": 0.95,
"waterFeatures": 0.97,
"dominantColors": 0.96,
"advertisementType": 0.92
},
"metadata": {
"processingTimestamp": "2025-07-23T23:45:30Z",
"documentId": "travel-ad-12345",
"modelId": "amazon.titan-image-v1",
"imageWidth": 1920,
"imageHeight": 1080
}
}
```
------
#### [ Audio ]
**Transcripción de una llamada telefónica**
Un ejemplo de esquema para una llamada telefónica sería el siguiente:
```
{
"class": "AudioRecording",
"description": "Schema for extracting information from AWS customer call recordings",
"properties": {
"callType": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The type of call (e.g., technical support, account management, consultation)"
},
"participants": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The number and roles of participants in the call"
},
"mainTopics": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The main topics or AWS services discussed during the call"
},
"customerIssues": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Any customer issues or pain points mentioned during the call"
},
"actionItems": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Action items or next steps agreed upon during the call"
},
"callDuration": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The duration of the call"
},
"callSummary": {
"type": "string",
"inferenceType": "explicit",
"instruction": "A brief summary of the entire call"
}
}
}
```
El comando para invocar el procesamiento de una llamada telefónica debería ser similar al siguiente:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://audio-analysis-bucket-301678011486/input/AWS_TCA-Call-Recording-2.wav"
}' \
--output-configuration '{
"s3Uri": "s3://audio-analysis-bucket-301678011486/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
Un ejemplo de la salida esperada es:
```
{
"documentType": "AudioRecording",
"extractedData": {
"callType": "Technical consultation",
"participants": "3 participants: AWS Solutions Architect, AWS Technical Account Manager, and Customer IT Director",
"mainTopics": "AWS Bedrock implementation, data processing pipelines, model fine-tuning, and cost optimization",
"customerIssues": "Integration challenges with existing ML infrastructure, concerns about latency for real-time processing, questions about data security compliance",
"actionItems": [
"AWS team to provide documentation on Bedrock data processing best practices",
"Customer to share their current ML architecture diagrams",
"Schedule follow-up meeting to review implementation plan",
"AWS to provide cost estimation for proposed solution"
],
"callDuration": "45 minutes and 23 seconds",
"callSummary": "Technical consultation call between AWS team and customer regarding implementation of AWS Bedrock for their machine learning workloads. Discussion covered integration approaches, performance optimization, security considerations, and next steps for implementation planning."
},
"confidence": {
"callType": 0.94,
"participants": 0.89,
"mainTopics": 0.92,
"customerIssues": 0.87,
"actionItems": 0.85,
"callDuration": 0.99,
"callSummary": 0.93
},
"metadata": {
"processingTimestamp": "2025-07-24T00:30:45Z",
"documentId": "audio-12345",
"modelId": "amazon.titan-audio-v1",
"audioDuration": "00:45:23",
"audioFormat": "WAV",
"sampleRate": "44.1 kHz"
},
"transcript": {
"segments": [
{
"startTime": "00:00:03",
"endTime": "00:00:10",
"speaker": "Speaker 1",
"text": "Hello everyone, thank you for joining today's call about implementing AWS Bedrock for your machine learning workloads."
},
{
"startTime": "00:00:12",
"endTime": "00:00:20",
"speaker": "Speaker 2",
"text": "Thanks for having us. We're really interested in understanding how Bedrock can help us streamline our document processing pipeline."
},
{
"startTime": "00:00:22",
"endTime": "00:00:35",
"speaker": "Speaker 3",
"text": "Yes, and specifically we'd like to discuss integration with our existing systems and any potential latency concerns for real-time processing requirements."
}
// Additional transcript segments would continue here
]
}
}
```
------
#### [ Video ]
**Procesamiento de un vídeo**
Un ejemplo de esquema para vídeos sería el siguiente:
```
{
"class": "VideoContent",
"description": "Schema for extracting information from video content",
"properties": {
"title": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The title or name of the video content"
},
"contentType": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The type of content (e.g., tutorial, competition, documentary, advertisement)"
},
"mainSubject": {
"type": "string",
"inferenceType": "explicit",
"instruction": "The main subject or focus of the video"
},
"keyPersons": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Key people appearing in the video (hosts, participants, etc.)"
},
"keyScenes": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Description of important scenes or segments in the video"
},
"audioElements": {
"type": "string",
"inferenceType": "explicit",
"instruction": "Description of notable audio elements (music, narration, dialogue)"
},
"summary": {
"type": "string",
"inferenceType": "explicit",
"instruction": "A brief summary of the video content"
}
}
}
```
El comando para invocar el procesamiento del vídeo debería ser similar al siguiente:
```
aws bedrock-data-automation-runtime invoke-data-automation-async \
--input-configuration '{
"s3Uri": "s3://video-analysis-bucket-301678011486/input/MakingTheCut.mp4",
"assetProcessingConfiguration": {
"video": {
"segmentConfiguration": {
"timestampSegment": {
"startTimeMillis": 0,
"endTimeMillis": 300000
}
}
}
}
}' \
--output-configuration '{
"s3Uri": "s3://video-analysis-bucket-301678011486/output/"
}' \
--data-automation-configuration '{
"dataAutomationProjectArn": "Amazon Resource Name (ARN)",
"stage": "LIVE"
}' \
--data-automation-profile-arn "Amazon Resource Name (ARN):data-automation-profile/default"
```
Un ejemplo de la salida esperada es:
```
{
"documentType": "VideoContent",
"extractedData": {
"title": "Making the Cut",
"contentType": "Fashion design competition",
"mainSubject": "Fashion designers competing to create the best clothing designs",
"keyPersons": "Heidi Klum, Tim Gunn, and various fashion designer contestants",
"keyScenes": [
"Introduction of the competition and contestants",
"Design challenge announcement",
"Designers working in their studios",
"Runway presentation of designs",
"Judges' critique and elimination decision"
],
"audioElements": "Background music, host narration, contestant interviews, and design feedback discussions",
"summary": "An episode of 'Making the Cut' fashion competition where designers compete in a challenge to create innovative designs. The episode includes the challenge announcement, design process, runway presentation, and judging."
},
"confidence": {
"title": 0.99,
"contentType": 0.95,
"mainSubject": 0.92,
"keyPersons": 0.88,
"keyScenes": 0.90,
"audioElements": 0.87,
"summary": 0.94
},
"metadata": {
"processingTimestamp": "2025-07-24T00:15:30Z",
"documentId": "video-12345",
"modelId": "amazon.titan-video-v1",
"videoDuration": "00:45:23",
"analyzedSegment": "00:00:00 - 00:05:00",
"resolution": "1920x1080"
},
"transcript": {
"segments": [
{
"startTime": "00:00:05",
"endTime": "00:00:12",
"speaker": "Heidi Klum",
"text": "Welcome to Making the Cut, where we're searching for the next great global fashion brand."
},
{
"startTime": "00:00:15",
"endTime": "00:00:25",
"speaker": "Tim Gunn",
"text": "Designers, for your first challenge, you'll need to create a look that represents your brand and can be sold worldwide."
}
// Additional transcript segments would continue here
]
}
}
```
------