

# Creare e gestire i record
<a name="registry-create-manage-records"></a>

**Prossima migrazione del namespace**  
 AWS Agent Registry è attualmente disponibile in anteprima pubblica nel namespace bedrock-agentcore. A partire dal 6 agosto 2026, il servizio passerà allo spazio dei nomi agent-registry. Se utilizzi AWS Agent Registry, devi aggiornare gli endpoint, le policy IAM, i client SDK, gli script CLI e i dati del registro. [Per ulteriori informazioni sulla migrazione dall'anteprima pubblica, consulta la Guida completa alla migrazione del registro.](registry-faq.md)

## Creare un record di registro
<a name="registry-create-record"></a>

### Console
<a name="registry-create-record-console"></a>

1. Apri la pagina dei dettagli del registro.

1. Nella sezione **Record del registro**, scegli **Crea record**.

1. Scegli un tipo di fonte:

   1.  **Sincronizzazione dall'endpoint**: fornisci un URL dell'endpoint e credenziali opzionali per richiamare l'endpoint e il registro recupererà i metadati dalla fonte. Disponibile solo per i tipi di record MCP e Agent. Per aggiornare il record dopo la modifica dell'origine, è necessario attivare manualmente la sincronizzazione. Per ulteriori informazioni, consulta [Sincronizzare i record da fonti esterne](registry-sync-records.md).

   1.  **Manuale**: configura manualmente i dettagli del record e la configurazione del protocollo.

 **Sincronizzazione dall'endpoint** 

1. **In **Dettagli del record**, selezionare il tipo di record: **MCP** o Agente.**
**Nota**  
La sincronizzazione è supportata solo per i tipi di record MCP e Agent. I tipi di record Agent Skills e Custom non supportano la sincronizzazione: utilizzate invece il tipo di sorgente Manual.

1. Inserisci l'URL dell'**endpoint**. Deve essere un URL HTTPS valido.

1. In **Tipo di credenziale**, scegli in che modo il registro autorizza l'endpoint:

   1.  **IAM**: fornisce un **ARN di ruolo** per la firma di SIGv4 e un nome di **servizio** (ad es.,,`bedrock-agentcore`). `execute-api` `lambda` **Facoltativamente, specifica una regione per la firma.**

   1.  **OAuth**: seleziona o inserisci un **ARN del provider di credenziali** da Identity. AgentCore **Facoltativamente, configura **gli ambiti** e i parametri personalizzati in Configurazione aggiuntiva.**

   1.  **Nessuna: nessuna** autorizzazione (per gli endpoint pubblici).

1. Scegli **Crea record**.

   Il record viene creato nello stato CREATING. Il registro si connette all'endpoint, estrae i metadati e compila i descrittori del record. Al termine della sincronizzazione, il record passa a DRAFT. Se la sincronizzazione fallisce, il record passa allo stato CREATE\_FAILED con i dettagli dell'errore disponibili nel campo Status Reason nella pagina dei dettagli del record. [Per la risoluzione dei problemi, vedere Registrare gli errori di sincronizzazione.](registry-troubleshooting.md#registry-troubleshooting-sync-errors) Per aggiornare il record quando la fonte cambia, usa il pulsante **Sincronizza** nella pagina dei dettagli del record o seleziona **Re-sync dall'endpoint** durante la modifica.

Per esempi di creazione di record con sincronizzazione tramite AWS CLI e SDK, consulta [Sincronizzare i record da fonti](registry-sync-records.md) esterne.

 **Manuale** 

1. In **Dettagli del record**, inserisci:

   1.  **Nome**: deve iniziare con una lettera o una cifra. I caratteri validi sono a-z, 0-9 A-Z, \_ (trattino basso), - (trattino),. (punto) e/(barra). Il nome può contenere fino a 255 caratteri.

   1.  **Descrizione** (opzionale): da 1 a 4.096 caratteri.

   1.  **Versione del record**: specificare la versione di questo record (ad esempio, 1.0.0, v2.1).

1. **In **Tipo di record**, selezionare una delle seguenti opzioni: **MCP**, **Agent, Agent** **Skills** o Custom.**

1. Viene visualizzato un editor specifico per tipo. Inserisci la configurazione del protocollo in formato JSON.

   1. Per i tipi **Agent** e **MCP**, attiva **Mostra schema ufficiale per visualizzare lo schema** di riferimento fianco a fianco come guida.

   1. La console convalida il tuo JSON rispetto allo schema ufficiale e mostra gli errori in linea (ad esempio, «Nome della proprietà mancante») con un pulsante **Diagnostica con Amazon Q.**

1. Scegli una delle seguenti opzioni:

   1.  **Crea come bozza**: crea il record con lo stato Bozza.

   1.  **Crea e invia per l'approvazione**: crea il record e lo invia immediatamente per l'approvazione.

### AWS CLI
<a name="registry-create-record-cli"></a>

```
aws bedrock-agentcore-control create-registry-record \
  --registry-id <registryId> \
  --name "MyMCPServer" \
  --descriptor-type MCP \
  --descriptors '{"mcp": {"server": {"inlineContent": "{\"name\": \"my/mcp-server\", \"description\": \"My MCP server\", \"version\": \"1.0.0\"}"}}}' \
  --record-version "1.0" \
  --region us-east-1
```

### AWS SDK
<a name="registry-create-record-sdk"></a>

```
import boto3
import json

client = boto3.client('bedrock-agentcore-control')

server_content = json.dumps({
    "name": "my/mcp-server",
    "description": "My MCP server",
    "version": "1.0.0"
})

response = client.create_registry_record(
    registryId='<registryId>',
    name='MyMCPServer',
    descriptorType='MCP',
    descriptors={
        'mcp': {
            'server': {
                'inlineContent': server_content
            }
        }
    },
    recordVersion='1.0'
)
print(f"Record ARN: {response['recordArn']}")
print(f"Status: {response['status']}")  # CREATING
```

## Elenca i record del registro
<a name="registry-list-records"></a>

### Console
<a name="registry-list-records-console"></a>

1. Apri la pagina dei dettagli del registro.

1. La sezione **Record del registro** mostra:

   1.  **Contatori di riepilogo dello stato**: totale inviato, in attesa di approvazione, approvato, obsoleto, rifiutato.

   1.  **Tabella dei record** con colonne: Nome, Descrizione, Stato, Tipo di record, ARN del record, Ultimo aggiornamento.

1. Utilizza la barra dei **record di ricerca** per filtrare in base al nome.

1. Utilizza il menu a discesa **Aggiorna stato** per apportare modifiche di stato in blocco ai record selezionati.

### AWS CLI
<a name="registry-list-records-cli"></a>

```
aws bedrock-agentcore-control list-registry-records \
  --registry-id "<registryId>" \
  --region us-east-1
```

### AWS SDK
<a name="registry-list-records-sdk"></a>

```
import boto3

client = boto3.client('bedrock-agentcore-control')

response = client.list_registry_records(
    registryId='<registryId>'
)
for record in response['registryRecords']:
    print(f"{record['name']} - {record['status']} - {record['descriptorType']}")
```

## Visualizza i dettagli dei record
<a name="registry-view-record"></a>

### Console
<a name="registry-view-record-console"></a>

1. Dalla pagina dei dettagli del registro, scegli un nome di record dalla tabella dei record.

1. La pagina dei dettagli del record mostra:

   1.  Sezione dei **dettagli del record**: nome, descrizione, ARN del record, stato (visualizzato come badge accanto al nome del record), versione, data dell'ultimo aggiornamento, tipo di record, ID record, data di creazione.

   1.  Sezione di **configurazione della sincronizzazione** (se configurata): tipo di sincronizzazione, URL di origine e dettagli del provider di credenziali (ARN del ruolo IAM, servizio, regione o ARN del provider OAuth, tipo di concessione, ambiti, parametri personalizzati).

   1.  Sezione di **configurazione del protocollo**: il contenuto del descrittore visualizzato come JSON in formato JSON (ad esempio, «Agent card» per i record A2A, «Server» e «Tools» per i record MCP).

1. Azioni disponibili:

   1.  Pulsante di **sincronizzazione** (solo record MCP e Agent): attiva una nuova sincronizzazione dall'endpoint configurato. Apre una finestra di dialogo di conferma prima di procedere. Il record passa allo stato UPDATING durante la sincronizzazione.

   1.  Elenco a discesa **dello stato di aggiornamento**: invia per approvazione, approva, rifiuta o depreca.

   1.  **Three-dot menu (⋮)** — Modifica o Elimina.

### AWS CLI
<a name="registry-view-record-cli"></a>

```
aws bedrock-agentcore-control get-registry-record \
  --registry-id "<registryId>" \
  --record-id "<recordId>" \
  --region us-east-1
```

### AWS SDK
<a name="registry-view-record-sdk"></a>

```
import boto3

client = boto3.client('bedrock-agentcore-control')

response = client.get_registry_record(
    registryId='<registryId>',
    recordId='<recordId>'
)
print(f"Name: {response['name']}")
print(f"Description: {response['description']}")
print(f"Status: {response['status']}")
print(f"Descriptor Type: {response['descriptorType']}")
print(f"Version: {response['recordVersion']}")
```

## Aggiornare un record di registro
<a name="registry-update-record"></a>

### Console
<a name="registry-update-record-console"></a>

1. Dalla pagina dei dettagli del record, scegli il menu a tre punti (⋮), quindi scegli **Modifica**.

1. Nella pagina **Modifica record**, aggiorna uno dei seguenti elementi:

   1.  **Nome**, **Descrizione**, **Versione del record** in Dettagli del record.

   1.  **Tipo di record**: se necessario, modificare il tipo di protocollo.

1. (Solo record MCP e Agent) In **Sincronizza dall'endpoint, configura facoltativamente la sincronizzazione**:

   È possibile aggiornare i record tramite la sincronizzazione indipendentemente dal fatto che siano stati originariamente creati con la sincronizzazione. Quando la sincronizzazione viene attivata durante un aggiornamento, il record passa allo stato UPDATING. Se l'operazione ha esito positivo, viene creata una nuova versione del record con lo stato DRAFT. Se fallisce, il record passa allo stato UPDATE\_FAILED con i dettagli dell'errore nel campo Status Reason. I dati sincronizzati sovrascrivono il nome, la descrizione, la versione, le definizioni degli strumenti e le definizioni del server del record con i valori trovati all'origine, ma non modificano i campi che l'origine non fornisce. Un amministratore o un curatore deve esaminare e approvare la nuova bozza affinché diventi visibile nella ricerca. Fino ad allora, l'eventuale revisione approvata precedente rimane ricercabile. [Per ulteriori informazioni sul comportamento della doppia revisione, consulta Record lifecycle.](registry-record-lifecycle.md)

   1. Inserisci un URL dell'**endpoint** per abilitare la sincronizzazione. I campi del tipo di credenziali vengono visualizzati quando viene fornito un endpoint. Se nel record è già configurata la sincronizzazione, i campi dell'endpoint e del provider di credenziali sono precompilati con la configurazione esistente.

   1. Scegli un **tipo di credenziale** (IAM, OAuth o Nessuno) e compila i campi obbligatori. Se il record è stato precedentemente configurato con un provider di credenziali, i valori esistenti sono precompilati.

   1. Seleziona **Re-sync da endpoint** per attivare una nuova sincronizzazione durante il salvataggio. Il record passa allo stato UPDATING durante la sincronizzazione.

   1. Per rimuovere la sincronizzazione, scegli il pulsante Cancella accanto al campo dell'endpoint. Ciò ripristina l'endpoint e tutti i campi delle credenziali.

1. In **Configurazione del record**, aggiorna le definizioni del record nell'editor JSON.

   1. È possibile configurare entrambi gli endpoint per la sincronizzazione e modificare manualmente le definizioni del record. Quando viene attivata la sincronizzazione, il registro recupera i metadati più recenti dall'endpoint e aggiorna il nome, la descrizione, la versione, le definizioni degli strumenti e le definizioni del server del record con i valori trovati all'origine, avendo la precedenza su qualsiasi modifica manuale a tali campi. I campi che l'origine non fornisce non vengono modificati.

1. La console convalida il tuo JSON rispetto allo schema ufficiale e mostra gli errori in linea con un pulsante **Diagnostica con Amazon Q.**

1. Scegli una delle seguenti opzioni:

   1.  **Salva le modifiche**: salva il record come bozza.

   1.  **Salva e invia per l'approvazione**: salva e invia in un unico passaggio.

Un banner di successo conferma: «[Nome] è stato aggiornato e inviato per l'approvazione con successo».

### AWS CLI
<a name="registry-update-record-cli"></a>

```
aws bedrock-agentcore-control update-registry-record \
  --registry-id "<registryId>" \
  --record-id "<recordId>" \
  --description "Updated description" \
  --region us-east-1
```

### AWS SDK
<a name="registry-update-record-sdk"></a>

```
import boto3

client = boto3.client('bedrock-agentcore-control')

response = client.update_registry_record(
    registryId='<registryId>',
    recordId='<recordId>',
    description='Updated description'
)
print(f"Updated: {response['name']} - Status: {response['status']}")
```

## Invia un record per l'approvazione
<a name="registry-submit-record"></a>

### Console
<a name="registry-submit-record-console"></a>

Dalla pagina dei dettagli del record -

1. Scegli il menu a discesa **Aggiorna stato**

1. Quindi, scegli **Invia per approvazione**.

   1. In alternativa, usa **Crea e invia per l'approvazione** o **Salva e invia per l'approvazione** durante la creazione o la modifica.

**Nota**  
Se la Auto-Approval configurazione del Registro è impostata su TRUE, l'invio di un record per l'approvazione lo approva automaticamente. Altrimenti, se la Auto-Approval configurazione è impostata su FALSE, il record passa allo stato «In attesa di approvazione» e attende che il curatore lo approvi o lo rifiuti. Inoltre, viene attivata una EventBridge notifica Amazon che indica che è stata richiesta l'approvazione di un nuovo record.

### AWS CLI
<a name="registry-submit-record-cli"></a>

```
aws bedrock-agentcore-control submit-registry-record-for-approval \
  --registry-id "<registryId>" \
  --record-id "<recordId>" \
  --region us-east-1
```

### AWS SDK
<a name="registry-submit-record-sdk"></a>

```
import boto3

client = boto3.client('bedrock-agentcore-control')

response = client.submit_registry_record_for_approval(
    registryId='<registryId>',
    recordId='<recordId>'
)
print(f"Status: {response['status']}")  # PENDING_APPROVAL or APPROVED
```

## Eliminare un record di registro
<a name="registry-delete-record"></a>

### Console
<a name="registry-delete-record-console"></a>

1. Dalla pagina dei dettagli del record, scegli il menu a tre punti (⋮), quindi scegli **Elimina**.

1. Conferma l'eliminazione digitando «elimina» quando richiesto

L'eliminazione è permanente e non può essere annullata.

### AWS CLI
<a name="registry-delete-record-cli"></a>

```
aws bedrock-agentcore-control delete-registry-record \
  --registry-id "<registryId>" \
  --record-id "<recordId>" \
  --region us-east-1
```

### AWS SDK
<a name="registry-delete-record-sdk"></a>

```
import boto3

client = boto3.client('bedrock-agentcore-control')

response = client.delete_registry_record(
    registryId='<registryId>',
    recordId='<recordId>'
)
print("Record deleted successfully")
```

## Convalida dello schema
<a name="registry-schema-validation"></a>

Quando crei o modifichi un record, la console e l'API convalidano la configurazione del protocollo rispetto allo schema ufficiale per il tipo di record selezionato. Maggiori dettagli sulle convalide sono disponibili in Tipi di [record supportati](registry-supported-record-types.md).