Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo della CLI di automazione Amazon Bedrock dei dati
La funzionalità Amazon Bedrock Data Automation (BDA) fornisce un flusso di lavoro CLI semplificato per l'elaborazione dei dati. Per tutte le modalità, questo flusso di lavoro consiste in tre fasi principali: creazione di un progetto, creazione di blueprint per output personalizzati ed elaborazione dei documenti. In questa guida vengono illustrati i comandi della CLI chiave per l’utilizzo con BDA.
## Creazione del primo progetto Data Automation
Per iniziare a lavorare con BDA, crea prima un progetto utilizzando il comando `create-data-automation-project`.
Considera questo passaporto di esempio che elaboreremo:
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/bda/passport2.png)
Quando si crea un progetto, è necessario definire le impostazioni di configurazione per il tipo di file che si intende elaborare. Il comando seguente rappresenta un esempio minimo funzionante per la creazione di un progetto di elaborazione delle immagini:
```
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"
}
}
}'
```
Il comando convalida la configurazione di input e crea un nuovo progetto con un ARN univoco. Una risposta deve includere l’ARN e la fase del progetto:
```
{
"projectArn": "Amazon Resource Name (ARN)",
"projectStage": "DEVELOPMENT",
"status": "IN_PROGRESS"
}
```
Se un progetto viene creato senza parametri, vengono applicate le impostazioni predefinite. Ad esempio, durante l’elaborazione delle immagini, la sintesi delle immagini e il rilevamento del testo saranno abilitati per impostazione predefinita.
## Riferimento completo ai parametri
La tabella seguente mostra tutti i parametri disponibili per il comando `create-data-automation-project`:
**Parametri per create-data-automation-project**
| Parametro | Obbligatorio | Predefinita | Description |
| --- | --- | --- | --- |
| --project-name | Sì | N/D | Nome del progetto Data Automation |
| --project-type | No | Il tipo di progetto definisce con quale API di elaborazione in fase di esecuzione può essere utilizzato. ASYNCi progetti possono essere utilizzati solo con l'invoke-bedrock-data-automation-asyncAPI, mentre SYNC i progetti possono essere utilizzati solo con l'invoke-bedrock-data-automationAPI. |
| --project-stage | No | LIVE | Fase del progetto (DEVELOPMENT o LIVE) |
| --standard-output-configuration | Sì | N/D | Configurazione JSON per l’elaborazione dell’output standard |
| --custom-output-configuration | No | N/D | Configurazione JSON per l’elaborazione personalizzata dell’output |
| --encryption-configuration | No | N/D | Impostazioni di crittografia per il progetto |
| --client-token | No | Generato automaticamente | Identificatore univoco per l’idempotenza della richiesta |
## Creazione di blueprint
Dopo aver creato un progetto, puoi creare un blueprint per definire la struttura dell’elaborazione dei dati utilizzando il comando `create-blueprint`.
Ecco un esempio minimo funzionante per creare un blueprint su misura per l’elaborazione del passaporto:
```
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"
}
}
}'
```
Il comando crea un nuovo blueprint con lo schema specificato. Puoi quindi utilizzare questo blueprint durante l’elaborazione dei documenti per estrarre dati strutturati in base allo schema definito.
## Utilizzo di un blueprint
### Aggiunta di un blueprint a un progetto
Per aggiungere un blueprint al progetto, utilizza il 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"
}
]
}'
```
### Verifica dell’integrazione del blueprint
Puoi verificare l’integrazione di blueprint utilizzando il comando `get-data-automation-project`.
```
aws bedrock-data-automation get-data-automation-project \
--project-arn "Amazon Resource Name (ARN)"
```
### Gestione di più blueprint
Utilizza il comando `list-blueprints` per visualizzare tutti i blueprint:
```
aws bedrock-data-automation list-blueprints
```
## Elabora i documenti in modo asincrono
Prima di elaborare i documenti con BDA, devi prima caricare i documenti in un bucket S3. Una volta impostato un progetto, puoi elaborare i documenti utilizzando il 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)"
```
Il comando restituisce un ARN di invocazione che puoi usare per controllare lo stato di elaborazione:
```
{
"invocationArn": "Amazon Resource Name (ARN)"
}
```
## Verifica dello stato di elaborazione
Per verificare lo stato della creazione del progetto, utilizza il comando `get-data-automation-status`.
```
aws bedrock-data-automation-runtime get-data-automation-status \
--invocation-arn "Amazon Resource Name (ARN)"
```
Il comando restituisce lo stato corrente del processo di elaborazione:
```
{
"status": "COMPLETED",
"creationTime": "2025-07-09T12:34:56.789Z",
"lastModifiedTime": "2025-07-09T12:45:12.345Z",
"outputLocation": "s3://my-bda-documents/output/efgh5678/"
}
```
I valori di stato possibili includono:
+ `IN_PROGRESS`: il processo di elaborazione è attualmente in esecuzione.
+ `COMPLETED`: il processo di elaborazione è stato correttamente completato.
+ `FAILED`: il processo di elaborazione non è andato a buon fine. Controlla la risposta per i dettagli dell’errore.
+ `STOPPED`: il processo di elaborazione è stato interrotto manualmente.
## Recupero dei risultati
Una volta completata l’elaborazione, puoi elencare i file di output nel bucket S3:
```
aws s3 ls s3://my-bda-documents/output/efgh5678/
```
Come scaricare i risultati nella macchina locale:
```
aws s3 cp s3://my-bda-documents/output/efgh5678/ ~/Downloads/bda-results/ --recursive
```
L’output include dati strutturati basati sulla configurazione del progetto e su eventuali blueprint applicati.
## Elabora documenti in modo sincrono
Prima di elaborare i documenti con BDA, devi prima caricare i documenti in un bucket S3. L'API di sincronizzazione supporta sia l'input tramite bucket S3 che i byte di immagine (ad esempio l'elaborazione di documenti senza S3). Il comando restituisce dati strutturati in base alla configurazione del progetto e a qualsiasi Blueprint applicato:
```
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)"
```
## Elabora immagini in modo sincrono
Il comando restituisce dati strutturati in base alla configurazione del progetto e a qualsiasi progetto applicato:
```
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 delle operazioni blueprint
Questa guida descrive le operazioni Blueprint disponibili tramite l'interfaccia a riga di comando (CLI) di AWS Amazon Bedrock per l'automazione dei dati (BDA).
## Creazione di blueprint
I blueprint definiscono la struttura e le proprietà dei dati da estrarre da documenti, immagini, file audio o video. Per definire un nuovo blueprint, utilizza il comando create-blueprint.
Il comando seguente crea un nuovo blueprint personalizzato per estrarre dati da un’immagine del passaporto.
**Sintassi**
```
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"
}
}
}'
```
## Riferimento completo ai parametri
La tabella seguente mostra tutti i parametri disponibili per il comando `create-blueprint`:
**Parametri per create-blueprint**
| Parametro | Obbligatorio | Predefinita | Description |
| --- | --- | --- | --- |
| --blueprint-name | Sì | N/D | Nome per il blueprint |
| --type | Sì | N/D | Tipo di contenuto (IMMAGINE, DOCUMENTO, AUDIO, VIDEO) |
| --blueprint-stage | No | LIVE | Fase del blueprint (DEVELOPMENT o LIVE) |
| --schema | Sì | N/D | Schema JSON che definisce la struttura blueprint |
| --client-token | No | Generato automaticamente | Identificatore univoco per l’idempotenza della richiesta |
## Visualizzazione delle configurazioni blueprint
**Elencare tutti i blueprint**
Usa il comando list-blueprints per recuperare un elenco di tutti i blueprint associati al tuo account.
**Sintassi**
```
aws bedrock-data-automation list-blueprints
```
**Visualizzare i dettagli del blueprint**
Per visualizzare informazioni dettagliate su uno specifico blueprint, inclusi lo schema e la configurazione, utilizza il comando get-blueprint.
**Sintassi**
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)"
```
**Ispezionare una versione specifica**
Quando lavori con blueprint con versioni, usa il comando get-blueprint con l’opzione --blueprint-version per visualizzare una versione particolare.
**Sintassi**
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-version "version-number"
```
**Ispezionare una fase specifica**
Per visualizzare i progetti in fase di DEVELOPMENT o LIVE, usa:
```
aws bedrock-data-automation get-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-stage "LIVE"
```
## Modificare le specifiche del blueprint
**Aggiornare le impostazioni del blueprint**
Per modificare lo schema o le proprietà di un blueprint esistente, usa il comando update-blueprint.
**Sintassi**
```
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:** quando aggiorni un blueprint, devi fornire lo schema completo, anche per i campi che non stai modificando.
**Promuovere a LIVE**
Per spostare un blueprint dalla fase DEVELOPMENT alla fase LIVE per la produzione, usa il comando update-blueprint con l’opzione --blueprint-stage.
**Sintassi**
```
aws bedrock-data-automation update-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)" \
--blueprint-stage "LIVE"
```
**Controllo delle versioni del blueprint**
Crea una nuova versione del tuo Blueprint per preservarne lo stato attuale prima di apportare modifiche significative utilizzando il comando. create-blueprint-version
**Sintassi**
```
aws bedrock-data-automation create-blueprint-version \
--blueprint-arn "Amazon Resource Name (ARN)"
```
## Gestione dei tag del blueprint
I tag aiutano gli utenti a organizzare e classificare i blueprint per una gestione semplificata.
**Aggiungere tag**
Applica i metadati al blueprint aggiungendo tag.
**Sintassi**
```
aws bedrock-data-automation tag-resource \
--resource-arn "Amazon Resource Name (ARN)" \
--tags '{"Department":"Finance","Project":"PassportProcessing"}'
```
**Rimuovere i tag**
Rimuovi tag specifici dal blueprint con il comando untag-resource.
**Sintassi**
```
aws bedrock-data-automation untag-resource \
--resource-arn "Amazon Resource Name (ARN)" \
--tag-keys '["Department","Project"]'
```
**Visualizzare i tag**
Elenca tutti i tag associati al tuo Blueprint usando il list-tags-for-resource comando.
**Sintassi**
```
aws bedrock-data-automation list-tags-for-resource \
--resource-arn "Amazon Resource Name (ARN)"
```
## Eliminazione di blueprint
**Eliminare un intero blueprint**
Usa il comando delete-blueprint per rimuovere definitivamente un blueprint e tutte le relative versioni.
**Sintassi**
```
aws bedrock-data-automation delete-blueprint \
--blueprint-arn "Amazon Resource Name (ARN)"
```
**Attenzione:** questo comando elimina definitivamente un blueprint e non può ripristinarlo.
**Importante:** non è possibile eliminare un blueprint attualmente in uso da parte di un progetto. Prima dell’eliminazione, assicurati che il blueprint non sia referenziato nella configurazione di output personalizzata di alcun progetto.
## Ottimizzazione del progetto
### Richiamo dell'ottimizzazione del blueprint
Avvia un lavoro asincrono di ottimizzazione del blueprint per migliorare le istruzioni del blueprint per ciascuno dei campi del blueprint e la precisione dei risultati.
**Sintassi**
```
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"
```
### Verifica dello stato di ottimizzazione del blueprint
Monitora lo stato di avanzamento e i risultati di un lavoro di ottimizzazione del blueprint.
**Sintassi**
```
aws bedrock-data-automation get-blueprint-optimization-status \
--invocation-arn "arn:aws:bedrock:::blueprint-optimization-invocation/opt-12345abcdef"
```
Utilizzate questo comando per tenere traccia dello stato del processo di ottimizzazione. La risposta include lo stato corrente (Creato InProgress, Operato con successo o ClientError) e i dettagli della configurazione dell'output una volta completata. ServiceError
### Copiare le fasi del blueprint
Copiare un blueprint da una fase all'altra
**Sintassi**
```
aws bedrock-data-automation copy-blueprint-stage \
--blueprint-arn "arn:aws:bedrock:::blueprint/" \
--source-stage "DEVELOPMENT" \
--target-stage "LIVE"
```
**Attenzione:** questo comando copia l'intera configurazione di Blueprint dalla fase di origine alla fase di destinazione, sovrascrivendo qualsiasi configurazione esistente nella fase di destinazione.
**Importante:** assicurati che Blueprint sia accuratamente testato nella fase di origine prima di copiarlo nella fase di produzione (LIVE). Questa operazione non può essere annullata facilmente.
# Elaborazione tramite CLI
Prima di elaborare i documenti con BDA, è necessario caricarli in un bucket S3:
**Sintassi**
```
aws s3 cp [--options]
```
Esempio:
```
aws s3 cp /local/path/document.pdf s3://my-bda-bucket/input/document.pdf
```
------
#### [ Async ]
**Struttura dei comandi di elaborazione di base**
Utilizzare il comando `invoke-data-automation-async` per elaborare i file:
```
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)"
```
**Struttura avanzata dei comandi di elaborazione**
**Elaborazione video con segmenti di tempo**
Per i file video, è possibile specificare i segmenti di tempo da elaborare:
```
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)"
```
**Utilizzo di blueprint personalizzati**
È possibile specificare blueprint personalizzati direttamente nel 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)"
```
**Aggiunta della configurazione della crittografia**
Per maggiore sicurezza, è possibile aggiungere una configurazione di crittografia:
```
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)"
```
**Notifiche eventi**
Abilita EventBridge le notifiche per il completamento dell'elaborazione:
```
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)"
```
**Verifica dello stato dell'elaborazione**
Per verificare lo stato dell’elaborazione del processo, utilizzare il comando `get-data-automation-status`.
```
aws bedrock-data-automation-runtime get-data-automation-status \
--invocation-arn "Amazon Resource Name (ARN)"
```
La risposta includerà lo stato attuale:
```
{
"status": "COMPLETED",
"creationTime": "2025-07-24T12:34:56.789Z",
"lastModifiedTime": "2025-07-24T12:45:12.345Z",
"outputLocation": "s3://my-bucket/output/abcd1234/"
}
```
**Recupera i risultati dell'elaborazione**
**Individuazione dei file di output in S3**
Elencare i file di output nel bucket S3:
```
aws s3 ls s3://amzn-s3-demo-bucket/output/
```
Scaricare i risultati nella macchina locale:
```
aws s3 cp s3://amzn-s3-demo-bucket/output/ ~/Downloads/bda-results/ --recursive
```
**Comprendere la struttura di output**
In genere l’output include:
+ `standard-output.json`: contiene risultati di estrazione standard
+ `custom-output.json`: contiene risultati di blueprint personalizzati
+ `metadata.json`: contiene i metadati di elaborazione e i punteggi di attendibilità
**Campi di risposta comuni**
In genere l’output standard include:
+ `extractedData`: le principali informazioni estratte
+ `confidence`: punteggi di attendibilità per ogni campo estratto
+ `metadata`: informazioni sull’elaborazione tra cui timestamp e dettagli del modello
+ `boundingBoxes`: informazioni sulla posizione degli elementi rilevati (se abilitata)
**Gestione e risoluzione degli errori**
Scenari di errore comuni e soluzioni:
+ **URI S3 non valido**: assicurarsi che il bucket S3 esista e di disporre delle autorizzazioni appropriate
+ **Mancante data-automation-profile-arn**: questo parametro è obbligatorio per tutte le richieste di elaborazione
+ **Progetto non trovato**: verificare che l’ARN del progetto sia corretto e che il progetto esista
+ **Formato di file non supportato**: verificare che il formato di file sia supportato da BDA
**Aggiungere tag ai processi di elaborazione**
È possibile aggiungere tag per organizzare e tenere traccia dei processi di elaborazione:
```
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 ]
**Struttura dei comandi di elaborazione di base**
Utilizzare il comando `invoke-data-automation` per elaborare i file:
```
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"
```
**Struttura avanzata dei comandi di elaborazione**
Uscita su 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
```
Usa l'input in byte
```
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**
**Byte**
Un blob di byte di documento con codifica Base64. La dimensione massima di un documento fornito in un blob di byte è di 50 MB. Il tipo deve essere un oggetto di dati binari con codifica Base64.
**Usa progetti personalizzati (solo per l'immagine)**
```
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"
```
------
# Elaborazione di casi d’uso
Amazon Bedrock Data Automation consente di elaborare documenti, immagini, audio e video tramite l’interfaccia a riga di comando (CLI). Per ogni modalità, il flusso di lavoro consiste nel creare un progetto, invocare l’analisi e recuperare il risultato.
Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ Documents ]
**Estrazione di dati da un W2**
![\[Esempio di modulo W2 con campi standard che mostra il layout e i campi dati che verranno estratti.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/bda/W2.png)
Durante l’elaborazione di un modulo W2, uno schema di esempio potrebbe essere il seguente:
```
{
"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"
}
}
}
```
Il comando per invocare l’elaborazione del W2 sarà simile al seguente:
```
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 esempio di output previsto è:
```
{
"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 ]
**Esempio di pubblicità di viaggi**
![\[Immagine di esempio che dimostra come gli utenti possono estrarre informazioni dalle pubblicità.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/bda/TravelAdvertisement.jpg)
Uno schema di esempio per le pubblicità di viaggi può essere il seguente:
```
{
"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.)"
}
}
}
```
Il comando per invocare l’elaborazione della pubblicità di viaggi sarà simile al seguente:
```
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 esempio di output previsto è:
```
{
"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 ]
**Trascrivere una telefonata**
Uno schema di esempio per una telefonata sarà il seguente:
```
{
"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"
}
}
}
```
Il comando per invocare l’elaborazione di una telefonata sarà simile al seguente:
```
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 esempio di output previsto è:
```
{
"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 ]
**Elaborazione di un video**
Uno schema di esempio per i video sarà il seguente:
```
{
"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"
}
}
}
```
Il comando per invocare l’elaborazione del video sarà simile al seguente:
```
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 esempio di output previsto è:
```
{
"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
]
}
}
```
------