As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usando a CLI Amazon Bedrock de automação de dados
O recurso Amazon Bedrock Data Automation (BDA) fornece um fluxo de trabalho CLI simplificado para processar seus dados. Para todas as modalidades, esse fluxo de trabalho consiste em três etapas principais: criar um projeto, criar esquemas para saída personalizada e processar documentos. Este guia mostra os principais comandos da CLI para trabalhar com a BDA.
## Criar seu primeiro projeto de automação de dados
Para começar a trabalhar com a BDA, primeiro crie um projeto usando o comando `create-data-automation-project`.
Considere este exemplo de passaporte que processaremos:
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/passport2.png)
Ao criar um projeto, é necessário definir as configurações para o tipo de arquivo que você tende a processar. O seguinte comando representa um exemplo prático mínimo para criar um projeto de processamento de imagem:
```
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"
}
}
}'
```
O comando valida a configuração de entrada e cria um projeto com um ARN exclusivo. Uma resposta inclui o ARN do projeto e o estágio:
```
{
"projectArn": "Amazon Resource Name (ARN)",
"projectStage": "DEVELOPMENT",
"status": "IN_PROGRESS"
}
```
Se um projeto for criado sem parâmetros, serão aplicadas as configurações padrão. Por exemplo, ao processar imagens, o resumo de imagens e a detecção de texto serão habilitados por padrão.
## Referência de parâmetro completa
A seguinte tabela mostra todos os parâmetros disponíveis para o comando `create-data-automation-project`:
**Parâmetros para create-data-automation-project**
| Parâmetro | Obrigatório | Padrão | Description |
| --- | --- | --- | --- |
| --project-name | Sim | N/D | Nome do projeto de automação de dados |
| --project-type | Não | O tipo do projeto define com qual API de processamento de tempo de execução ele pode ser usado. ASYNCprojetos só podem ser usados com a invoke-bedrock-data-automation-async API, enquanto SYNC projetos só podem ser usados com a invoke-bedrock-data-automation API. |
| --project-stage | Não | AO VIVO | Estágio do esquema (DEVELOPMENT ou LIVE) |
| --standard-output-configuration | Sim | N/D | Configuração JSON para processamento de saída padrão |
| --custom-output-configuration | Não | N/D | Configuração JSON para processamento de saída personalizada |
| --encryption-configuration | Não | N/D | Configurações de criptografia para o projeto |
| --client-token | Não | Gerado automaticamente | Identificador exclusivo de idempotência da solicitação |
## Criar um esquema
Depois de criar um projeto, você pode criar um esquema para definir a estrutura do processamento de dados usando o comando `create-blueprint`.
Veja aqui um exemplo prático mínimo para criar um esquema personalizado para o processamento de passaportes:
```
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"
}
}
}'
```
O comando cria um esquema com o esquema especificado. Em seguida, você pode usar esse esquema ao processar documentos para extrair dados estruturados de acordo com o esquema definido.
## Usar seu esquema
### Adicionar um esquema a um projeto
Para adicionar um esquema ao seu projeto, use o 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"
}
]
}'
```
### Verificar a integração do esquema
É possível verificar a integração do esquema usando o comando `get-data-automation-project`:
```
aws bedrock-data-automation get-data-automation-project \
--project-arn "Amazon Resource Name (ARN)"
```
### Gerenciar vários esquemas
Use o comando `list-blueprints` para visualizar todos os seus esquemas:
```
aws bedrock-data-automation list-blueprints
```
## Processar documentos de forma assíncrona
Antes de processar documentos com o BDA, você deve primeiro carregar seus documentos em um bucket do S3. Depois de configurar um projeto, você pode processar documentos usando o 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)"
```
O comando exibe um ARN de invocação que você pode usar para verificar o status do processamento:
```
{
"invocationArn": "Amazon Resource Name (ARN)"
}
```
## Verificar o status do processamento
Para verificar o status do trabalho de processamento, use o comando `get-data-automation-status`.
```
aws bedrock-data-automation-runtime get-data-automation-status \
--invocation-arn "Amazon Resource Name (ARN)"
```
O comando exibe o status atual de um trabalho de processamento:
```
{
"status": "COMPLETED",
"creationTime": "2025-07-09T12:34:56.789Z",
"lastModifiedTime": "2025-07-09T12:45:12.345Z",
"outputLocation": "s3://my-bda-documents/output/efgh5678/"
}
```
Os valores de status possíveis incluem:
+ `IN_PROGRESS`: o trabalho de processamento está sendo executado no momento.
+ `COMPLETED`: o trabalho de processamento foi concluído com êxito.
+ `FAILED`: o trabalho de processamento falhou. Verifique a resposta para ver os detalhes do erro.
+ `STOPPED`: o trabalho de processamento foi interrompido manualmente.
## Recuperar resultados
Quando o processamento for concluído, será possível listar os arquivos de saída no bucket do S3:
```
aws s3 ls s3://my-bda-documents/output/efgh5678/
```
Para fazer download dos resultados sua máquina local:
```
aws s3 cp s3://my-bda-documents/output/efgh5678/ ~/Downloads/bda-results/ --recursive
```
A saída inclui dados estruturados com base na configuração do projeto e em todos os esquemas que você aplicou.
## Processar documentos de forma síncrona
Antes de processar documentos com o BDA, você deve primeiro carregar seus documentos em um bucket do S3. A API de sincronização interrompe a entrada via bucket do S3 ou bytes de imagem (ou seja, o processamento de documentos sem o S3). O comando retorna dados estruturados com base na configuração do seu projeto e em todos os Blueprints que você aplicou:
```
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)"
```
## Processar imagens de forma síncrona
O comando retorna dados estruturados com base na configuração do seu projeto e em todos os Blueprints que você aplicou:
```
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 operações do esquema
Este guia aborda as operações do Blueprint disponíveis por meio da AWS Command Line Interface (CLI) Amazon Bedrock para automação de dados (BDA).
## Criar esquemas
Os esquemas definem a estrutura e as propriedades dos dados que você deseja extrair de arquivos de documentos, imagens, áudio ou vídeo. Use o comando create-blueprint para definir um novo esquema.
O comando a seguir cria um esquema personalizado para extrair dados de uma imagem de passaporte.
**Sintaxe**
```
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"
}
}
}'
```
## Referência de parâmetro completa
A seguinte tabela mostra todos os parâmetros disponíveis para o comando `create-blueprint`:
**Parâmetros de create-blueprint**
| Parâmetro | Obrigatório | Padrão | Description |
| --- | --- | --- | --- |
| --blueprint-name | Sim | N/D | Nome do esquema |
| --type | Sim | N/D | Tipo de conteúdo (IMAGE, DOCUMENT, AUDIO, VIDEO) |
| --blueprint-stage | Não | AO VIVO | Etapa do esquema (DEVELOPMENT ou LIVE) |
| --schema | Sim | N/D | Esquema JSON definindo a estrutura do esquema |
| --client-token | Não | Gerado automaticamente | Identificador exclusivo de idempotência da solicitação |
## Visualizar configurações do esquema
**Listar todos os esquemas**
Use o comando list-blueprints para recuperar uma lista de todos os esquemas associados à sua conta.
**Sintaxe**
```
aws bedrock-data-automation list-blueprints
```
**Visualizar detalhes do esquema**
Para ver informações detalhadas sobre um esquema específico, inclusive o respectivo esquema e configuração, use o comando get-blueprint.
**Sintaxe**
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)"
```
**Inspecionar uma versão específica**
Ao trabalhar com esquemas versionados, use o comando get-blueprint com a opção --blueprint-version para visualizar uma versão específica.
**Sintaxe**
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-version "version-number"
```
**Inspecionar um estágio específico**
Para visualizar os esquemas no estágio DEVELOPMENT ou LIVE, use:
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-stage "LIVE"
```
## Editar especificações do esquema
**Atualizar configurações do esquema**
Para modificar o esquema ou as propriedades de um esquema existente, use o comando update-blueprint.
**Sintaxe**
```
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"
}
}
}'
```
**Observação:** ao atualizar um esquema, você deve fornecer o esquema completo, mesmo para campos que não estão sendo alterados.
**Promover para LIVE**
Para mover um esquema do estágio DEVELOPMENT para o estágio LIVE para produção, use o comando update-blueprint com a opção --blueprint-stage.
**Sintaxe**
```
aws bedrock-data-automation update-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-stage "LIVE"
```
**Controlar a versão do esquema**
Crie uma nova versão do seu Blueprint para preservar seu estado atual antes de fazer alterações significativas usando o create-blueprint-version comando.
**Sintaxe**
```
aws bedrock-data-automation create-blueprint-version \
--blueprint-arn "Amazon Resource Name (ARN)"
```
## Gerenciar as tags do esquema
As tags ajudam os usuários a organizar e categorizar os esquemas para simplificar o gerenciamento.
**Adicionar tags**
Aplique metadados ao esquema adicionando tags.
**Sintaxe**
```
aws bedrock-data-automation tag-resource \
--resource-arn "Amazon Resource Name (ARN)" \
--tags '{"Department":"Finance","Project":"PassportProcessing"}'
```
**Remover etiquetas**
Remova tags específicas do esquema com o comando untag-resource.
**Sintaxe**
```
aws bedrock-data-automation untag-resource \
--resource-arn "Amazon Resource Name (ARN)" \
--tag-keys '["Department","Project"]'
```
**Exibir tags**
Liste todas as tags associadas ao seu Blueprint usando o list-tags-for-resource comando.
**Sintaxe**
```
aws bedrock-data-automation list-tags-for-resource \
--resource-arn "Amazon Resource Name (ARN)"
```
## Excluir esquemas
**Excluir um esquema inteiro**
Use o comando delete-blueprint para remover permanentemente um esquema e todas as respectivas versões.
**Sintaxe**
```
aws bedrock-data-automation delete-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)"
```
**Cuidado:** esse comando exclui permanentemente um esquema e não é possível recuperá-lo.
**Importante:** não é possível excluir um esquema que esteja sendo usado no momento por algum projeto. Antes de excluir, verifique se não há referência ao esquema na configuração de saída personalizada de algum projeto.
## Otimização do blueprint
### Invocando a otimização do Blueprint
Inicie um trabalho assíncrono de otimização do blueprint para melhorar as instruções do blueprint de cada um dos campos do blueprint e a precisão dos resultados.
**Sintaxe**
```
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"
```
### Verificando o status de otimização do Blueprint
Monitore o progresso e os resultados de um trabalho de otimização do plano.
**Sintaxe**
```
aws bedrock-data-automation get-blueprint-optimization-status \
--invocation-arn "arn:aws:bedrock:::blueprint-optimization-invocation/opt-12345abcdef"
```
Use esse comando para rastrear o status do trabalho de otimização. A resposta inclui o status atual (Criado InProgress ServiceError, Sucesso ou ClientError) e os detalhes da configuração de saída quando concluída.
### Copiando estágios do Blueprint
Copiar um blueprint de um estágio para outro
**Sintaxe**
```
aws bedrock-data-automation copy-blueprint-stage \
--blueprint-arn "arn:aws:bedrock:::blueprint/" \
--source-stage "DEVELOPMENT" \
--target-stage "LIVE"
```
**Cuidado:** esse comando copia toda a configuração do Blueprint do estágio de origem para o estágio de destino, substituindo qualquer configuração existente no estágio de destino.
**Importante:** Certifique-se de que o Blueprint seja completamente testado no estágio de origem antes de copiar para o estágio de produção (AO VIVO). Essa operação não pode ser desfeita com facilidade.
# Processar por meio da CLI
Antes de processar documentos com a BDA, você deve primeiro fazer upload dos documentos em um bucket do S3:
**Sintaxe**
```
aws s3 cp [--options]
```
Exemplo:
```
aws s3 cp /local/path/document.pdf s3://my-bda-bucket/input/document.pdf
```
------
#### [ Async ]
**Estrutura básica de comando de processamento**
Use o comando `invoke-data-automation-async` para processar arquivos:
```
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)"
```
**Estrutura avançada de comando de processamento**
**Processamento de vídeo com segmentos de tempo**
Para arquivos de vídeo, você pode especificar segmentos de tempo a serem processados:
```
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)"
```
**Usar esquemas personalizados**
É possível especificar esquemas personalizados diretamente no 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)"
```
**Adicionar configuração de criptografia**
Para aumentar a segurança, você pode adicionar a configuração de criptografia:
```
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)"
```
**Notificações de eventos**
Ative EventBridge as notificações para a conclusão do processamento:
```
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)"
```
**Verificando o status do processamento**
Use o comando `get-data-automation-status` para verificar o status do trabalho de processamento:
```
aws bedrock-data-automation-runtime get-data-automation-status \
--invocation-arn "Amazon Resource Name (ARN)"
```
A resposta incluirá o status atual:
```
{
"status": "COMPLETED",
"creationTime": "2025-07-24T12:34:56.789Z",
"lastModifiedTime": "2025-07-24T12:45:12.345Z",
"outputLocation": "s3://my-bucket/output/abcd1234/"
}
```
**Recupere os resultados do processamento**
**Localizar arquivos de saída no S3**
Liste os arquivos de saída no bucket do S3:
```
aws s3 ls s3://amzn-s3-demo-bucket/output/
```
Faça download dos resultados sua máquina local:
```
aws s3 cp s3://amzn-s3-demo-bucket/output/ ~/Downloads/bda-results/ --recursive
```
**Noções básicas sobre a estrutura de saída**
A saída normalmente inclui:
+ `standard-output.json`: contém resultados de extração padrão.
+ `custom-output.json`: contém resultados de esquemas personalizados.
+ `metadata.json`: contém metadados de processamento e pontuações de confiança.
**Campos de resposta comuns**
A saída padrão normalmente inclui:
+ `extractedData`: as principais informações extraídas.
+ `confidence`: pontuações de confiança para cada campo extraído.
+ `metadata`: processamento de informações, como carimbos de data/hora e detalhes do modelo.
+ `boundingBoxes`: informações de localização dos elementos detectados (se habilitado).
**Tratamento de erros e solução de problemas**
Cenários e soluções de erro comuns:
+ **URI inválido do S3**: verifique se o bucket do S3 existe e se você tem as permissões adequadas.
+ **Ausente data-automation-profile-arn**: esse parâmetro é obrigatório para todas as solicitações de processamento
+ **Projeto não encontrado**: verifique se o ARN do projeto está correto e se o projeto existe.
+ **Formato de arquivo não compatível**: verifique se o formato do arquivo é compatível com a BDA.
**Adicionar tags às tarefas de processamento**
Você pode adicionar tags para ajudar a organizar e rastrear seus trabalhos de processamento:
```
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 ]
**Estrutura básica de comando de processamento**
Use o comando `invoke-data-automation` para processar arquivos:
```
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"
```
**Estrutura avançada de comando de processamento**
Saída para o 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
```
Use 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**
Um blob de bytes de documentos codificados em base64. O tamanho máximo de um documento fornecido em um blob de bytes é de 50 MB. O tipo deve ser um objeto de dados binários codificado em Base64.
**Use plantas personalizadas (somente para imagem)**
```
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"
```
------
# Processar casos de uso
A Automação de Dados do Amazon Bedrock permite que você processe documentos, imagens, áudio e vídeo por meio da interface de linha de comandos (CLI). Para cada modalidade, o fluxo de trabalho consiste em criar um projeto, invocar a análise e recuperar o resultado.
Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ Documents ]
**Extrair dados de um W2**
![\[Exemplo do formulário W2 com campos padrão, demonstrando o layout e os campos de dados que serão extraídos.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/W2.png)
Ao processar um formulário W2, um exemplo de esquema seria o seguinte:
```
{
"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"
}
}
}
```
O comando para invocar o processamento do W2 seria semelhante ao seguinte:
```
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"
```
Um exemplo da saída esperada é:
```
{
"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 ]
**Exemplo de anúncio de viagem**
![\[Imagem de exemplo, demonstrando como os usuários podem extrair informações de anúncios.\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/bda/TravelAdvertisement.jpg)
Um exemplo de esquema para anúncios de viagens seria o seguinte:
```
{
"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.)"
}
}
}
```
O comando para invocar o processamento do anúncio de viagem seria semelhante ao seguinte:
```
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"
```
Um exemplo da saída esperada é:
```
{
"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 ]
**Transcrever uma chamada telefônica**
Um exemplo de esquema para uma chamada telefônica seria o seguinte:
```
{
"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"
}
}
}
```
O comando para invocar o processamento de uma chamada telefônica seria semelhante ao seguinte:
```
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"
```
Um exemplo da saída esperada é:
```
{
"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 ]
**Processar um vídeo**
Um exemplo de esquema para vídeos seria o seguinte:
```
{
"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"
}
}
}
```
O comando para invocar o processamento do vídeo seria semelhante ao seguinte:
```
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"
```
Um exemplo da saída esperada é:
```
{
"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
]
}
}
```
------