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

# Lettura da un'API REST
<a name="rest-api-reading"></a>

 Dopo aver registrato un'API REST ConnectionType e creato una AWS Glue connessione, puoi leggere i dati dall'API REST nei tuoi job ETL. AWS Glue Con questa connessione, puoi elaborare dati API REST esterni insieme ad altre fonti nello stesso processo. Sono necessari il nome della connessione e il nome dell'entità per leggere i dati. 

L'esempio seguente mostra come leggere da un'origine dati API REST usando Python:

```
rest_read = glueContext.create_dynamic_frame.from_options(
    connection_type="rest",
    connection_options={
        "connectionName": "{{connection-name}}",
        "ENTITY_NAME": "{{entity-name}}",
        "CONNECTION_TYPE": "{{REST-connection-type}}"
    }
)
```

## Filtro dei dati
<a name="rest-api-filtering"></a>

 È possibile inviare i predicati del filtro all'API REST di origine per ridurre la quantità di dati trasferiti. Il connettore API REST supporta due modalità di filtro: 
+ **QUERY\_PARAMS**: ogni filtro diventa un parametro di query URL separato. Ad esempio: `?created[gte]=1704067200&created[lte]=1717200000`
+ **FILTER\_STRING ** — Tutti i filtri si combinano in un unico parametro di interrogazione. Ad esempio: `?search=status eq "ACTIVE" and lastUpdated gt "2024-01-01"`

 Per applicare un predicato di filtro nel processo AWS Glue ETL, utilizzate l'opzione di connessione: `FILTER_PREDICATE` 

```
rest_read = glueContext.create_dynamic_frame.from_options(
    connection_type="rest",
    connection_options={
        "connectionName": "{{connection-name}}",
        "ENTITY_NAME": "{{entity-name}}",
        "CONNECTION_TYPE": "{{REST-connection-type}}",
        "FILTER_PREDICATE": "status = \"ACTIVE\" AND lastUpdated >= \"2024-01-01T00:00:00.000Z\""
    }
)
```

**FilterConfiguration proprietà**  
 Configura il comportamento di filtro nella ConnectionType registrazione utilizzando l'`FilterConfiguration`oggetto. La tabella seguente descrive le proprietà disponibili: 


| Proprietà | Tipo | Description | 
| --- | --- | --- | 
| `FilterMode` | Stringa | Obbligatoria. `QUERY_PARAMS`o`FILTER_STRING`. | 
| `OperatorMappings` | Eseguire la mappatura | Associa gli operatori logici alla API-specific sintassi. | 
| `DateTimeFormat` | Stringa | DateTime modello di formato o`EPOCH_SECONDS`/`EPOCH_MILLIS`. | 
| `StripQuotes` | Booleano | Specifica se rimuovere le virgolette circostanti dai valori di input. Default: `true`. | 
| `BetweenConfiguration` | Oggetto | Configurazione di gestione predefinita BETWEEN. | 
| `FilterStringConfiguration` | Oggetto | Impostazioni specifiche per la `FILTER_STRING` modalità. | 

**FilterStringConfiguration proprietà**  
La tabella seguente descrive le proprietà della `FILTER_STRING` modalità:


| Proprietà | Tipo | Description | 
| --- | --- | --- | 
| `FilterStringKey` | Stringa | Obbligatorio. Chiave del parametro di interrogazione (ad esempio, «ricerca» o «filtro»). | 
| `QuoteStringValues` | Booleano | Specifica se racchiudere String e DateTime valori tra virgolette. | 
| `QuoteCharacter` | Stringa | Carattere tra virgolette. Impostazione predefinita: `"` | 

**BetweenConfiguration proprietà**  
La tabella seguente descrive le proprietà di gestione BETWEEN:


| Proprietà | Modalità | Description | 
| --- | --- | --- | 
| `LowBoundKey` | QUERY\_PARAMS | Modello di chiave per il limite basso. Supporta `{FIELD}` segnaposto. | 
| `HighBoundKey` | QUERY\_PARAMS | Modello di chiave per il limite alto. Ometti di eliminare il limite massimo. | 
| `Template` | FILTER\_STRING | Modello con `{FIELD}` segnaposto`{LOW}`, `{HIGH}` | 

**Operatori supportati**  
 I seguenti operatori sono supportati nei predicati dei filtri:`EQUAL_TO`,,,`GREATER_THAN`,`LESS_THAN`,`GREATER_THAN_OR_EQUAL_TO`,`LESS_THAN_OR_EQUAL_TO`,, `NOT_EQUAL_TO``CONTAINS`,`BETWEEN`. `AND` `OR` 

**Field-level sostituisce**  
 È possibile configurare il comportamento del filtro per campo utilizzando `FilterOverrides` la definizione dello schema. Sono disponibili le seguenti proprietà di sostituzione: 
+ `FieldName`— Sostituisci il nome del campo utilizzato nell'output del filtro.
+ `OperatorMappings`— Field-level l'operatore sovrascrive.
+ `BetweenConfiguration`— BETWEEN Per-field override.
+ `DateTimeFormat`— sostituzione Per-field DateTime del formato.

**Esempio: modalità QUERY\_PARAMS**  
 L'esempio seguente mostra una `FilterConfiguration` API REST che utilizza parametri di interrogazione con notazione tra parentesi per gli operatori e timestamp di epoca per i valori di data: 

```
"FilterConfiguration": {
    "FilterMode": "QUERY_PARAMS",
    "OperatorMappings": {
        "EQUAL_TO": "{FIELD}",
        "GREATER_THAN_OR_EQUAL_TO": "{FIELD}[gte]",
        "LESS_THAN_OR_EQUAL_TO": "{FIELD}[lte]"
    },
    "DateTimeFormat": "EPOCH_SECONDS",
    "BetweenConfiguration": {
        "LowBoundKey": "{FIELD}[gte]",
        "HighBoundKey": "{FIELD}[lte]"
    }
}
```

 Con questa configurazione, un filtro di input di `created >= 2024-01-01 AND created <= 2024-06-01` produce la stringa di query dell'URL: `?created[gte]=1704067200&created[lte]=1717200000` 

**Esempio: modalità FILTER\_STRING**  
 L'esempio seguente mostra una `FilterConfiguration` API REST che utilizza un singolo parametro di stringa di filtro con operatori riempiti di spazi: 

```
"FilterConfiguration": {
    "FilterMode": "FILTER_STRING",
    "OperatorMappings": {
        "EQUAL_TO": " eq ",
        "GREATER_THAN": " gt ",
        "GREATER_THAN_OR_EQUAL_TO": " ge ",
        "LESS_THAN": " lt ",
        "AND": " and ",
        "OR": " or "
    },
    "DateTimeFormat": "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
    "BetweenConfiguration": {
        "Template": "{FIELD} ge {LOW} and {FIELD} le {HIGH}"
    },
    "FilterStringConfiguration": {
        "FilterStringKey": "search",
        "QuoteStringValues": true,
        "QuoteCharacter": "\""
    }
}
```

 Con questa configurazione, un filtro di input di `status = "ACTIVE" AND lastUpdated > 2024-01-01T00:00:00.000Z` produce la stringa di query URL: `?search=status eq "ACTIVE" and lastUpdated gt "2024-01-01T00:00:00.000Z"` 

## Query di partizionamento
<a name="rest-api-partitioning"></a>

 È possibile suddividere le letture dei dati in partizioni parallele tra Spark i lavoratori per migliorare la produttività. Il connettore API REST supporta il partizionamento basato sul campo, che divide i dati in intervalli in base a un campo specificato. 

**Spark parametri di lavoro**  
Le seguenti opzioni di connessione controllano il comportamento del partizionamento:
+ `PARTITION_FIELD`— Campo su cui partizionare. Deve essere contrassegnato `IsPartitionable: true` nello schema.
+ `LOWER_BOUND`— Limite inferiore incluso per l'intervallo delle partizioni.
+ `UPPER_BOUND`— Limite superiore per l'intervallo di partizioni. Le partizioni intermedie escludono questo valore. L'ultima partizione lo include.
+ `NUM_PARTITIONS`— Numero di partizioni parallele.

**Field-based - partizionamento**  
 Field-based il partizionamento divide i dati in intervalli in base a un campo specificato. L'esempio seguente partiziona i dati sul campo: `lastUpdated` 

```
rest_read = glueContext.create_dynamic_frame.from_options(
    connection_type="rest",
    connection_options={
        "connectionName": "{{connection-name}}",
        "ENTITY_NAME": "{{entity-name}}",
        "CONNECTION_TYPE": "{{REST-connection-type}}",
        "PARTITION_FIELD": "lastUpdated",
        "LOWER_BOUND": "2024-01-01T00:00:00.000Z",
        "UPPER_BOUND": "2024-12-31T00:00:00.000Z",
        "NUM_PARTITIONS": "4"
    }
)
```

Con 4 partizioni sul `lastUpdated` campo, il lavoro è distribuito come segue:
+ Lavoratore 1: `lastUpdated >= "2024-01-01" AND lastUpdated < "2024-04-01"`
+ Lavoratore 2: `lastUpdated >= "2024-04-01" AND lastUpdated < "2024-07-01"`
+ Lavoratore 3: `lastUpdated >= "2024-07-01" AND lastUpdated < "2024-10-01"`
+ Lavoratore 4: `lastUpdated >= "2024-10-01" AND lastUpdated <= "2024-12-31"`

**Configurazione del supporto per le partizioni in RegisterConnectionType**  
 Per abilitare il partizionamento basato sui campi, contrassegna i campi come partizionabili nella definizione dello schema: 

```
"Schema": {
    "lastUpdated": {
        "FieldDataType": "TIMESTAMP",
        "IsPartitionable": true
    }
}
```

I seguenti valori sono supportati per il partizionamento: `FieldDataType`
+ `TIMESTAMP`— DateTime partizionamento. Suddivide l'intervallo in finestre temporali.
+ `INTEGER`— Partizionamento di numeri interi. Divide l'intervallo in finestre numeriche.

**Nota**  
 Il connettore combina i filtri di partizione con i filtri utente utilizzando AND. Se il filtro contiene una clausola LIMIT, il connettore salta il partizionamento. Se la generazione della partizione non riesce, il connettore torna a una singola partizione e il lavoro viene comunque completato.