

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à.

# API DynamoDB di basso livello
<a name="Programming.LowLevelAPI"></a>

L'*API di basso livello* di Amazon DynamoDB è l'interfaccia a livello di protocollo per DynamoDB. A questo livello, ogni richiesta HTTP(S) deve essere formattata correttamente e contenere una firma digitale valida.

Creano AWS SDKs richieste API DynamoDB di basso livello per tuo conto ed elaborano le risposte di DynamoDB. Ciò ti consente di concentrarti sulla logica dell'applicazione, anziché sui dettagli di basso livello. Tuttavia, può essere comunque utile sapere in grandi linee come funziona l'API di livello basso di DynamoDB.

Per ulteriori informazioni sull'API DynamoDB di basso livello, consulta[Documentazione di riferimento dell'API Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/).

**Nota**  
DynamoDB Streams dispone di una propria API di basso livello, che è separata da quella di DynamoDB ed è completamente supportata da. AWS SDKs  
Per ulteriori informazioni, consulta [Acquisizione dei dati di modifica per DynamoDB Streams](Streams.md). Per informazioni sull'API DynamoDB Streams di basso livello, consulta la documentazione[Riferimento API Amazon DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Operations_Amazon_DynamoDB_Streams.html).

L'API DynamoDB di basso livello JavaScript utilizza Object Notation (JSON) come formato di protocollo wire. Con il formato JSON, i dati vengono presentati secondo una gerarchia che consente di trasmettere simultaneamente i valori dei dati e la struttura corrispondente. Le coppie nome-valore sono definite nel formato `name:value`. La gerarchia dei dati viene definita tramite parentesi annidate di coppie nome-valore.

DynamoDB usa JSON solo come protocollo di trasporto e non come formato di archiviazione. AWS SDKs Utilizzano JSON per inviare dati a DynamoDB e DynamoDB risponde con JSON. DynamoDB non memorizza i dati in modo persistente in formato JSON.

**Nota**  
Per ulteriori informazioni su JSON, consulta [Presentazione di JSON](http://json.org) nel sito Web `JSON.org`.

**Topics**
+ [

## Formato della richiesta
](#Programming.LowLevelAPI.RequestFormat)
+ [

## Formato della risposta
](#Programming.LowLevelAPI.ResponseFormat)
+ [

## Descrittori del tipo di dati
](#Programming.LowLevelAPI.DataTypeDescriptors)
+ [

## Dati numerici
](#Programming.LowLevelAPI.Numbers)
+ [

## Dati binari
](#Programming.LowLevelAPI.Binary)

![\[API di basso livello di DynamoDB e AWS SDKs come gestire le richieste e le risposte a livello di protocollo.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/SDKSupport.DDBLowLevelAPI.png)


## Formato della richiesta
<a name="Programming.LowLevelAPI.RequestFormat"></a>

L'API di basso livello di DynamoDB accetta le richieste HTTP(S) `POST` come input. Quindi AWS SDKs costruiscono queste richieste per te.

Supponiamo di avere una tabella denominata `Pets` con uno schema di chiave costituito da `AnimalType` (chiave di partizione) e `Name` (chiave di ordinamento). Entrambi questi attributi sono di tipo `string`. Per recuperare un elemento da`Pets`, l' AWS SDK costruisce la seguente richiesta.

```
POST / HTTP/1.1
Host: dynamodb.<region>.<domain>;
Accept-Encoding: identity
Content-Length: <PayloadSizeBytes>
User-Agent: <UserAgentString>
Content-Type: application/x-amz-json-1.0
Authorization: AWS4-HMAC-SHA256 Credential=<Credential>, SignedHeaders=<Headers>, Signature=<Signature>
X-Amz-Date: <Date> 
X-Amz-Target: DynamoDB_20120810.GetItem

{
    "TableName": "Pets",
    "Key": {
        "AnimalType": {"S": "Dog"},
        "Name": {"S": "Fido"}
    }
}
```

Tieni presente le seguenti considerazioni sulla richiesta:
+ L'intestazione `Authorization` contiene le informazioni necessarie per l'autenticazione della richiesta da parte di DynamoDB. Per ulteriori informazioni, consulta [Signing AWS API request](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) e [Signature Version 4 Procedura di firma](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in. *Riferimenti generali di Amazon Web Services*
+ L'intestazione `X-Amz-Target` contiene il nome di un'operazione DynamoDB: `GetItem`. Il nome è accompagnato dalla versione API di basso livello, in questo caso `20120810`.
+ Il payload (corpo) della richiesta contiene i parametri per l'operazione in formato JSON. Per l'operazione `GetItem`, i parametri sono `TableName` e `Key`.

## Formato della risposta
<a name="Programming.LowLevelAPI.ResponseFormat"></a>

Al ricevimento della richiesta, DynamoDB la elabora e restituisce una risposta. Per la richiesta mostrata in precedenza, il payload della risposta HTTP(S) contiene i risultati dell'operazione, come mostrato nell'esempio seguente:

```
HTTP/1.1 200 OK
x-amzn-RequestId: <RequestId>
x-amz-crc32: <Checksum>
Content-Type: application/x-amz-json-1.0
Content-Length: <PayloadSizeBytes>
Date: <Date>
{
    "Item": {
        "Age": {"N": "8"},
        "Colors": {
            "L": [
                {"S": "White"},
                {"S": "Brown"},
                {"S": "Black"}
            ]
        },
        "Name": {"S": "Fido"},
        "Vaccinations": {
            "M": {
                "Rabies": {
                    "L": [
                        {"S": "2009-03-17"},
                        {"S": "2011-09-21"},
                        {"S": "2014-07-08"}
                    ]
                },
                "Distemper": {"S": "2015-10-13"}
            }
        },
        "Breed": {"S": "Beagle"},
        "AnimalType": {"S": "Dog"}
    }
}
```

A questo punto, l' AWS SDK restituisce i dati di risposta all'applicazione per un'ulteriore elaborazione.

**Nota**  
Se l'esecuzione della richiesta non riesce, DynamoDB restituisce un codice di errore HTTP e un messaggio di errore. L'SDK AWS propaga la risposta all'applicazione sotto forma di eccezione. Per ulteriori informazioni, consulta [Gestione degli errori con DynamoDB](Programming.Errors.md).

## Descrittori del tipo di dati
<a name="Programming.LowLevelAPI.DataTypeDescriptors"></a>

Il protocollo API di basso livello di DynamoDB richiede che ogni attributo sia accompagnato da un descrittore del tipo di dati. I *descrittori del tipo di dati* sono token che indicano a DynamoDB come interpretare ogni attributo.

Gli esempi in [Formato della richiesta](#Programming.LowLevelAPI.RequestFormat) e [Formato della risposta](#Programming.LowLevelAPI.ResponseFormat) mostrano come vengono usati i descrittori del tipo di dati. La richiesta `GetItem` specifica `S` per gli attributi dello schema della chiave `Pets` (`AnimalType` e `Name`) che sono di tipo `string`. La risposta `GetItem` contiene un item *Pets* con attributi di tipo `string` (`S`), `number` (`N`), `map` (`M`) e `list` (`L`).

Di seguito è riportato un elenco completo dei descrittori del tipo di dati di DynamoDB:
+ **`S`**: String
+ **`N`**: Number
+ **`B`**: binario
+ **`BOOL`**: Boolean
+ **`NULL`**: null
+ **`M`**: Map
+ **`L`**: list
+ **`SS`**: set string
+ **`NS`**: set numerico
+ **`BS`**: set binario

La tabella seguente mostra il formato JSON corretto per ogni descrittore di tipo di dati. Nota che i numeri sono rappresentati come stringhe per preservare la precisione, mentre i valori booleani e nulli utilizzano i loro tipi JSON nativi.


| Descrittore | Formato JSON | Note | 
| --- | --- | --- | 
| S | \$1"S": "Hello"\$1 | Il valore è una stringa JSON. | 
| N | \$1"N": "123.45"\$1 | Il valore è una stringa, non un numero JSON. Ciò consente di preservare la precisione in tutte le lingue. | 
| B | \$1"B": "dGhpcyBpcyBhIHRlc3Q="\$1 | Il valore è una stringa codificata in base64. | 
| BOOL | \$1"BOOL": true\$1 | Il valore è un booleano JSON (or), non una stringa. true false | 
| NULL | \$1"NULL": true\$1 | Il valore è il true booleano JSON che indica null. | 
| M | \$1"M": \$1"Name": \$1"S": "Joe"\$1\$1\$1 | Il valore è un oggetto JSON composto da coppie nome-valore dell'attributo. | 
| L | \$1"L": [\$1"S": "Red"\$1, \$1"N": "5"\$1]\$1 | Il valore è una matrice JSON di valori di attributo. | 
| SS | \$1"SS": ["Red", "Blue"]\$1 | Il valore è un array di stringhe JSON. | 
| NS | \$1"NS": ["1", "2.5"]\$1 | Il valore è una matrice JSON di stringhe numeriche. | 
| BS | \$1"BS": ["U3Vubnk=", "UmFpbnk="]\$1 | Il valore è un array JSON di stringhe con codifica base64. | 

**Nota**  
 Per una descrizione dettagliata dei tipi di dati di DynamoDB, consulta [Tipi di dati](HowItWorks.NamingRulesDataTypes.md#HowItWorks.DataTypes).

## Dati numerici
<a name="Programming.LowLevelAPI.Numbers"></a>

I vari linguaggi di programmazione offrono diversi livelli di supporto per JSON. In alcuni casi, potresti decidere di utilizzare una libreria di terze parti per convalidare e analizzare i documenti JSON.

Alcune librerie di terze parti si basano sul tipo di numero JSON, fornendo i propri tipi come `int`, `long` o `double`. Tuttavia, dal momento che il tipo di dati numerico nativo in DynamoDB non viene esattamente mappato a questi altri tipi di dati, pertanto queste distinzioni tra tipi possono causare conflitti. Inoltre, molte librerie JSON non gestiscono valori numerici a precisione fissa e deducono automaticamente un doppio tipo di dati per le sequenze di cifre che contengono una virgola decimale.

Per risolvere questi problemi, DynamoDB fornisce un singolo tipo numerico senza perdita di dati. Per evitare conversioni implicite indesiderate a un valore double, DynamoDB usa le stringhe per il trasferimento dei dati di valori numerici. Questo approccio fornisce flessibilità per l'aggiornamento dei valori degli attributi pur mantenendo una corretta semantica di ordinamento, ad esempio mettendo i valori "01", "2" e "03" nella sequenza corretta.

Se la precisione del numero è importante per l'applicazione, sarà necessario convertire i valori numerici in stringhe prima di passarli a DynamoDB.

## Dati binari
<a name="Programming.LowLevelAPI.Binary"></a>

 supporta gli attributi binari. Tuttavia, JSON non supporta in modo nativo la codifica dei dati binari. Per inviare dati binari in una richiesta, è necessario codificarli nel formato Base64. Dopo aver ricevuto la richiesta, DynamoDB decodifica i dati Base64 nuovamente in binario. 

Lo schema di codifica base64 utilizzato da DynamoDB è descritto in [RFC 4648](http://tools.ietf.org/html/rfc4648) sul sito Web Internet Engineering Task Force (IETF).