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à.
# Tipi e opzioni di connessione per ETL in AWS Glue per Spark
In AWS Glue Spark, vari metodi e trasformazioni PySpark e Scala specificano il tipo di connessione utilizzando un `connectionType` parametro. Specificano le opzioni di connessione utilizzando un parametro `connectionOptions` o `options`.
Il parametro `connectionType` può assumere i valori indicati nella tabella seguente. I valori dei parametri associati `connectionOptions` (o `options`) per ciascun tipo sono documentati nelle sezioni seguenti. Salvo indicazione contraria, i parametri si applicano quando la connessione viene utilizzata come sorgente o sink.
Per il codice di esempio che illustra l'impostazione e l'utilizzo delle opzioni di connessione, consulta la home page per ogni tipo di connessione.
| `connectionType` | Si connette a |
| --- | --- |
| [dynamodb](aws-glue-programming-etl-connect-dynamodb-home.md) | [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) database |
| [kinesis](aws-glue-programming-etl-connect-kinesis-home.md) | [Flusso di dati Amazon Kinesis](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) |
| [s3](aws-glue-programming-etl-connect-s3-home.md) | [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/) |
| [documentdb](aws-glue-programming-etl-connect-documentdb-home.md#aws-glue-programming-etl-connect-documentdb) | [Amazon DocumentDB (compatibile con MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/) database |
| [opensearch](aws-glue-programming-etl-connect-opensearch-home.md) | [ OpenSearch Servizio Amazon](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). |
| [redshift](aws-glue-programming-etl-connect-redshift-home.md) | Database [Amazon Redshift](https://aws.amazon.com/redshift/) |
| [kafka](aws-glue-programming-etl-connect-kafka-home.md) | [Kafka](https://kafka.apache.org/) o [Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) |
| [azurecosmos](aws-glue-programming-etl-connect-azurecosmos-home.md) | Azure Cosmos per NoSQL. |
| [azuresql](aws-glue-programming-etl-connect-azuresql-home.md) | Azure SQL. |
| [bigquery](aws-glue-programming-etl-connect-bigquery-home.md) | Google BigQuery. |
| [mongodb](aws-glue-programming-etl-connect-mongodb-home.md) | Database [MongoDB](https://www.mongodb.com/what-is-mongodb), incluso MongoDB Atlas. |
| [sqlserver](aws-glue-programming-etl-connect-jdbc-home.md) | Microsoft SQL Server database (vedere [Connessioni JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [mysql](aws-glue-programming-etl-connect-jdbc-home.md) | [MySQL](https://www.mysql.com/) database (vedere [Connessioni JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [oracle](aws-glue-programming-etl-connect-jdbc-home.md) | [Oracle](https://www.oracle.com/database/) database (vedere [Connessioni JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [postgresql](aws-glue-programming-etl-connect-jdbc-home.md) | [PostgreSQL](https://www.postgresql.org/) database (vedere [Connessioni JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [saphana](aws-glue-programming-etl-connect-saphana-home.md) | SAP HANA. |
| [snowflake](aws-glue-programming-etl-connect-snowflake-home.md) | Data lake [Snowflake](https://www.snowflake.com/) |
| [teradata](aws-glue-programming-etl-connect-teradata-home.md) | Teradata Vantage. |
| [vertica](aws-glue-programming-etl-connect-vertica-home.md) | Vertica. |
| [personalizzato.\$1](#aws-glue-programming-etl-connect-market) | Archivi dati Spark, Athena o JDBC (consulta [Valori Custom e Marketplace AWS ConnectionType](#aws-glue-programming-etl-connect-market) |
| [marketplace.\$1](#aws-glue-programming-etl-connect-market) | Archivi dati Spark, Athena o JDBC (consulta [Valori Custom e Marketplace AWS ConnectionType](#aws-glue-programming-etl-connect-market)) |
# Connessioni a DynamoDB
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in DynamoDB in Glue. AWS Ti connetti a DynamoDB utilizzando le autorizzazioni IAM allegate al tuo job Glue. AWS AWS Gluesupporta la scrittura di dati nella tabella DynamoDB di un altro AWS account. Per ulteriori informazioni, consulta [Accesso multi-account in più regioni alle tabelle DynamoDB](aws-glue-programming-etl-dynamo-db-cross-account.md).
Il connettore DynamoDB originale utilizza oggetti DynamicFrame Glue per lavorare con i dati estratti da DynamoDB. AWS Glue 5.0\$1 introduce una novità [Connettore DynamoDB con supporto Spark DataFrame](aws-glue-programming-etl-connect-dynamodb-dataframe-support.md) che fornisce il supporto nativo per Spark. DataFrame
[Oltre al connettore AWS Glue DynamoDB ETL, puoi leggere da DynamoDB utilizzando il connettore di esportazione DynamoDB, che richiama una richiesta DynamoDB e la archivia in una posizione Amazon S3 da te `ExportTableToPointInTime` fornita, nel formato DynamoDB JSON.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html) AWS Gluequindi crea un DynamicFrame oggetto leggendo i dati dalla posizione di esportazione di Amazon S3.
Il writer DynamoDB è disponibile nella versione 1.0 di AWS Glue Glue o nelle versioni successive. Il connettore di esportazione DynamoDB per AWS Glue è disponibile nella versione 2.0 di AWS Glue o nelle versioni successive. Il nuovo connettore DynamoDB DataFrame basato su DynamoDB è disponibile nella versione AWS Glue 5.0 o successive.
Per ulteriori informazioni su DynamoDB, consulta la documentazione di [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/).
**Nota**
Il lettore DynamoDB ETL non supporta filtri o predicati pushdown.
## Configurazione delle connessioni a MongoDB
Per connetterti a DynamoDB AWS da Glue, concedi al ruolo IAM associato al AWS tuo job Glue l'autorizzazione a interagire con DynamoDB. Per ulteriori informazioni sulle autorizzazioni necessarie per leggere o scrivere da DynamoDB, consulta [Operazioni, risorse e chiavi di condizione per Amazon DynamoDB](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html) nella documentazione di IAM.
Nelle seguenti situazioni, potresti aver bisogno di una configurazione aggiuntiva:
+ Quando utilizzi il connettore di esportazione DynamoDB, devi configurare IAM in modo che il processo possa richiedere l'esportazione di tabelle DynamoDB. Inoltre, dovrai identificare un bucket Amazon S3 per l'esportazione e fornire le autorizzazioni appropriate in IAM affinché DynamoDB possa scrivervi e che il tuo job Glue possa leggerlo. AWS Per ulteriori informazioni, consulta [Richiesta di esportazione di una tabella in DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/S3DataExport_Requesting.html).
+ Se il tuo job AWS Glue ha requisiti di connettività Amazon VPC specifici, usa il tipo di connessione `NETWORK` AWS Glue per fornire opzioni di rete. Poiché l'accesso a DynamoDB è autorizzato da IAM, non è necessario un tipo di connessione AWS Glue DynamoDB.
## Lettura e scrittura su DynamoDB
Gli esempi di codice seguenti mostrano come leggere (tramite il connettore ETL) e scrivere tabelle DynamoDB. Mostrano la lettura da una tabella e la scrittura su un'altra tabella.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame.from_options(
connection_type="dynamodb",
connection_options={"dynamodb.input.tableName": test_source,
"dynamodb.throughput.read.percent": "1.0",
"dynamodb.splits": "100"
}
)
print(dyf.getNumPartitions())
glue_context.write_dynamic_frame_from_options(
frame=dyf,
connection_type="dynamodb",
connection_options={"dynamodb.output.tableName": test_sink,
"dynamodb.throughput.write.percent": "1.0"
}
)
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.input.tableName" -> test_source,
"dynamodb.throughput.read.percent" -> "1.0",
"dynamodb.splits" -> "100"
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
val dynamoDbSink: DynamoDbDataSink = glueContext.getSinkWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.output.tableName" -> test_sink,
"dynamodb.throughput.write.percent" -> "1.0"
))
).asInstanceOf[DynamoDbDataSink]
dynamoDbSink.writeDynamicFrame(dynamicFrame)
Job.commit()
}
}
```
------
## Utilizzo del connettore di esportazione DynamoDB
Il connettore di esportazione ha prestazioni migliori rispetto al connettore ETL quando le dimensioni della tabella DynamoDB sono superiori a 80 GB. Inoltre, dato che la richiesta di esportazione è condotta al di fuori dei processi Spark in un processo AWS Glue, puoi abilitare [Scalabilità automatica di processi Glue AWS](https://docs.aws.amazon.com/glue/latest/dg/auto-scaling.html) per salvare l'utilizzo della DPU durante la richiesta di esportazione. Con il connettore di esportazione, non è inoltre necessario configurare il numero di divisioni per il parallelismo dell'esecutore Spark o la percentuale di lettura del throughput DynamoDB.
**Nota**
DynamoDB ha requisiti specifici per richiamare le richieste `ExportTableToPointInTime`. Per ulteriori informazioni, consulta [Richiesta di esportazione di una tabella in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Requesting.html). Ad esempio, è necessario abilitare Point-in-Time-Restore (PITR) sulla tabella per utilizzare questo connettore. Il connettore DynamoDB supporta anche la AWS KMS crittografia per le esportazioni DynamoDB verso Amazon S3. L'indicazione della configurazione di sicurezza nella configurazione del job AWS Glue abilita la AWS KMS crittografia per un'esportazione DynamoDB. La chiave KMS deve essere nella stessa regione del bucket Amazon S3.
Tieni presente che si applicano costi aggiuntivi per l'esportazione DynamoDB e i costi di storage Amazon S3. I dati esportati in Amazon S3 persistono al termine dell'esecuzione di un processo in modo da poterli riutilizzare senza ulteriori esportazioni DynamoDB. Un requisito per l'utilizzo di questo connettore è che il point-in-time ripristino (PITR) sia abilitato per la tabella.
Il connettore ETL DynamoDB o il connettore di esportazione non supportano filtri o predicati pushdown da applicare all'origine DynamoDB.
Gli esempi di codice seguenti mostrano come leggere (tramite il connettore di esportazione) e stampare il numero di partizioni.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame.from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.export": "ddb",
"dynamodb.tableArn": test_source,
"dynamodb.s3.bucket": bucket_name,
"dynamodb.s3.prefix": bucket_prefix,
"dynamodb.s3.bucketOwner": account_id_of_bucket,
}
)
print(dyf.getNumPartitions())
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> test_source,
"dynamodb.s3.bucket" -> bucket_name,
"dynamodb.s3.prefix" -> bucket_prefix,
"dynamodb.s3.bucketOwner" -> account_id_of_bucket,
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
Job.commit()
}
}
```
------
Questi esempi mostrano come eseguire la lettura da (tramite il connettore di esportazione) e stampare il numero di partizioni da una tabella AWS Glue Data Catalog con una `dynamodb` classificazione:
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dynamicFrame = glue_context.create_dynamic_frame.from_catalog(
database=catalog_database,
table_name=catalog_table_name,
additional_options={
"dynamodb.export": "ddb",
"dynamodb.s3.bucket": s3_bucket,
"dynamodb.s3.prefix": s3_bucket_prefix
}
)
print(dynamicFrame.getNumPartitions())
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getCatalogSource(
database = catalog_database,
tableName = catalog_table_name,
additionalOptions = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.s3.bucket" -> s3_bucket,
"dynamodb.s3.prefix" -> s3_bucket_prefix
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
)
```
------
## Semplificazione dell'utilizzo del JSON di esportazione DynamoDB
Le esportazioni di DynamoDB con il connettore di esportazione DynamoDB AWS Glue possono risultare in file JSON con specifiche strutture annidate. Per ulteriori informazioni, consulta [Oggetti dati](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). AWS Gluefornisce una DynamicFrame trasformazione che può trasformare tali strutture in una easier-to-use forma per le applicazioni a valle.
La trasformazione può essere invocata in uno dei due modi possibili. Puoi impostare l'opzione di connessione `"dynamodb.simplifyDDBJson"` sul valore `"true"` quando effettui una chiamata a un metodo per leggere da DynamoDB. Puoi anche chiamare la trasformazione come metodo disponibile indipendentemente nella libreria AWS Glue.
Prendi in considerazione lo schema seguente generato da un'esportazione DynamoDB:
```
root
|-- Item: struct
| |-- parentMap: struct
| | |-- M: struct
| | | |-- childMap: struct
| | | | |-- M: struct
| | | | | |-- appName: struct
| | | | | | |-- S: string
| | | | | |-- packageName: struct
| | | | | | |-- S: string
| | | | | |-- updatedAt: struct
| | | | | | |-- N: string
| |-- strings: struct
| | |-- SS: array
| | | |-- element: string
| |-- numbers: struct
| | |-- NS: array
| | | |-- element: string
| |-- binaries: struct
| | |-- BS: array
| | | |-- element: string
| |-- isDDBJson: struct
| | |-- BOOL: boolean
| |-- nullValue: struct
| | |-- NULL: boolean
```
La trasformazione `simplifyDDBJson` semplificherà questo processo in:
```
root
|-- parentMap: struct
| |-- childMap: struct
| | |-- appName: string
| | |-- packageName: string
| | |-- updatedAt: string
|-- strings: array
| |-- element: string
|-- numbers: array
| |-- element: string
|-- binaries: array
| |-- element: string
|-- isDDBJson: boolean
|-- nullValue: null
```
**Nota**
`simplifyDDBJson`è disponibile in AWS Glue 3.0 e versioni successive. Per semplificare il JSON di esportazione DynamoDB è disponibile anche la trasformazione `unnestDDBJson`. Incoraggiamo gli utenti a passare da `unnestDDBJson` a `simplifyDDBJson`.
## Configurazione del parallelismo nelle operazioni DynamoDB
Per migliorare le prestazioni, è possibile regolare alcuni parametri disponibili per il connettore DynamoDB. Il vostro obiettivo quando regolate i parametri di paralleismo è massimizzare l'uso dei Glue worker forniti. AWS Quindi, se hai bisogno di maggiori prestazioni, ti consigliamo di ampliare il tuo lavoro aumentando il numero di. DPUs
Puoi modificare il parallelismo in un'operazione di lettura di DynamoDB con il parametro `dynamodb.splits` quando utilizzi il connettore ETL. La lettura con il connettore di esportazione non richiede la configurazione del numero di divisioni per il parallelismo dell'esecutore Spark. Puoi modificare il parallelismo in un'operazione di scrittura DynamoDB con `dynamodb.output.numParallelTasks`.
**Lettura con il connettore ETL per DynamoDB**
Ti consigliamo di calcolare `dynamodb.splits` in base al numero massimo di worker impostato nella configurazione del lavoro e al seguente calcolo `numSlots`. In caso di dimensionamento automatico, il numero effettivo di worker disponibili potrebbe variare al di sotto di tale limite. Per ulteriori informazioni sull'impostazione del numero massimo di worker, consulta **Numero di worker** (`NumberOfWorkers`) in [Configurazione delle proprietà dei job per i job Spark in AWS Glue](add-job.md).
+ `numExecutors = NumberOfWorkers - 1`
Per il contesto, un esecutore è riservato per il driver Spark; altri esecutori sono utilizzati per elaborare i dati.
+ `numSlotsPerExecutor =`
------
#### [ AWS Glue 3.0 and later versions ]
+ `4`: se `WorkerType` è `G.1X`.
+ `8`: se `WorkerType` è `G.2X`.
+ `16`: se `WorkerType` è `G.4X`.
+ `32`: se `WorkerType` è `G.8X`.
------
#### [ AWS Glue 2.0 and legacy versions ]
+ `8`: se `WorkerType` è `G.1X`.
+ `16`: se `WorkerType` è `G.2X`.
------
+ `numSlots = numSlotsPerExecutor * numExecutors`
Ti consigliamo di impostare `dynamodb.splits` sul numero di slot disponibili, `numSlots`.
**Scrittura su DynamoDB**
Il parametro `dynamodb.output.numParallelTasks` viene utilizzato per determinare il valore WCU per ogni attività Spark, utilizzando il seguente calcolo:
`permittedWcuPerTask = ( TableWCU * dynamodb.throughput.write.percent ) / dynamodb.output.numParallelTasks`
Il writer DynamoDB funzionerà al meglio se la configurazione rappresenta accuratamente il numero di attività Spark che scrivono su DynamoDB. In alcuni casi, potrebbe essere necessario sovrascrivere il calcolo predefinito per migliorare le prestazioni di scrittura. Se questo parametro non viene specificato, il valore WCU consentito per i processi Spark verrà calcolato automaticamente mediante la seguente formula:
+
+ `numPartitions = dynamicframe.getNumPartitions()`
+ `numSlots` (come definito in precedenza in questa sezione)
+ `numParallelTasks = min(numPartitions, numSlots)`
+ Esempio 1: DPU=10, =Standard. WorkerType L'input DynamicFrame ha 100 partizioni RDD.
+ `numPartitions = 100`
+ `numExecutors = (10 - 1) * 2 - 1 = 17`
+ `numSlots = 4 * 17 = 68`
+ `numParallelTasks = min(100, 68) = 68`
+ Esempio 2: DPU=10, =Standard. WorkerType L'ingresso DynamicFrame ha 20 partizioni RDD.
+ `numPartitions = 20`
+ `numExecutors = (10 - 1) * 2 - 1 = 17`
+ `numSlots = 4 * 17 = 68`
+ `numParallelTasks = min(20, 68) = 20`
**Nota**
I lavori sulle versioni precedenti di AWS Glue e quelli che utilizzano Standard worker richiedono metodi diversi per calcolare il numero di slot. Se hai bisogno di ottimizzare le prestazioni di questi lavori, ti consigliamo di passare alle versioni supportate di AWS Glue.
## Indicazioni di riferimento per le opzioni di connessione a DynamoDB
Indica una connessione ad Amazon DynamoDB.
Le opzioni di connessione differiscono per una connessione sorgente e una connessione sink.
### "connectionType": "dynamodb" con il connettore ETL come origine
Usa le seguenti opzioni di connessione `"connectionType": "dynamodb"` come sorgente, quando usi il connettore AWS Glue DynamoDB ETL:
+ `"dynamodb.input.tableName"`: (Obbligatorio) la tabella DynamoDB da cui leggere.
+ `"dynamodb.throughput.read.percent"`: (Facoltativo) percentuale di unità di capacità di lettura (RCU) da usare. Il valore predefinito è "0,5". I valori accettabili vanno da "0,1" a "1,5", inclusi.
+ `0.5` rappresenta la velocità di lettura di default, il che significa che AWS Glue cercherà di consumare metà della capacità di lettura della tabella. Se si aumenta il valore sopra `0.5`, AWS Glue aumenterà il tasso di richiesta; diminuendo il valore al di sotto di `0.5`, riduce la frequenza di richiesta di lettura. La velocità di lettura effettiva varia in base a fattori come la presenza di una distribuzione uniforme delle chiavi nella tabella DynamoDB.
+ Quando la tabella DynamoDB è in modalità on demand, AWS Glue gestisce la capacità di lettura della tabella a 40000. Per esportare una tabella di grandi dimensioni, si consiglia di passare alla modalità su richiesta della tabella DynamoDB.
+ `"dynamodb.splits"`: (Facoltativo) Definisce il numero di partizioni applicate a questa tabella DynamoDB durante la lettura. Il valore predefinito è "1". I valori accettabili vanno da "1" a "1,000,000", inclusi.
`1` indica che non c'è parallelismo. Si consiglia vivamente di specificare un valore maggiore per migliorare le prestazioni utilizzando la formula riportata di seguito. Per ulteriori informazioni sull'impostazione corretta di un valore, consulta [Configurazione del parallelismo nelle operazioni DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.sts.roleArn"`: (Facoltativo) il ruolo IAM ARN da assumere per l'accesso multi-account. Questo parametro è disponibile in AWS Glue 1.0 o versione successiva.
+ `"dynamodb.sts.roleSessionName"`: (Facoltativo) nome della sessione STS. L'impostazione predefinita è "glue-dynamodb-read-sts-session». Questo parametro è disponibile in AWS Glue 1.0 o versione successiva.
### "connectionType": "dynamodb" con il connettore di esportazione DynamoDB AWS Glue come sorgente
Utilizzare le seguenti opzioni di connessione con «connectionType»: «dynamodb» come origine, quando utilizzi il Connettore di esportazione DynamoDB AWS Glue, disponibile solo per la versione AWS Glue 2.0 in poi:
+ `"dynamodb.export"`: (Richiesto) Un valore stringa:
+ Se impostato su `ddb` abilita il Connettore di esportazione DynamoDB AWS Glue dove un nuovo `ExportTableToPointInTimeRequest` verrà invocato durante il processo AWS Glue. Verrà generata una nuova esportazione con la posizione passata da `dynamodb.s3.bucket` e `dynamodb.s3.prefix`.
+ Se impostato su `s3` abilita il Connettore di esportazione DynamoDB AWS Glue ma salta la creazione di una nuova esportazione DynamoDB e utilizza invece il `dynamodb.s3.bucket` e il `dynamodb.s3.prefix` come posizione di Amazon S3 di un'esportazione precedente di quella tabella.
+ `"dynamodb.tableArn"`: (Obbligatorio) la tabella DynamoDB da cui leggere.
+ `"dynamodb.unnestDDBJson"`: false per impostazione predefinita (facoltativo). Valori validi: booleani. Se impostato su true, esegue una trasformazione non nidificata della struttura JSON DynamoDB presente nelle esportazioni. È un errore impostare contemporaneamente `"dynamodb.unnestDDBJson"` e `"dynamodb.simplifyDDBJson"` su true. In AWS Glue 3.0 e versioni successive, si consiglia di utilizzare `"dynamodb.simplifyDDBJson"` per un comportamento migliore durante la semplificazione dei tipi di mappe DynamoDB. Per ulteriori informazioni, consulta [Semplificazione dell'utilizzo del JSON di esportazione DynamoDB](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.simplifyDDBJson"`: false per impostazione predefinita (facoltativo). Valori validi: booleani. Se impostato su true, esegue una trasformazione per semplificare la struttura JSON DynamoDB presente nelle esportazioni. Questa opzione ha lo stesso scopo di `"dynamodb.unnestDDBJson"`, ma fornisce un supporto migliore per i tipi di mappe DynamoDB o per i tipi di mappe annidate nella tabella DynamoDB. Questa opzione è disponibile in AWS Glue 3.0 e versioni successive. È un errore impostare contemporaneamente `"dynamodb.unnestDDBJson"` e `"dynamodb.simplifyDDBJson"` su true. Per ulteriori informazioni, consulta [Semplificazione dell'utilizzo del JSON di esportazione DynamoDB](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.s3.bucket"`: (facoltativo) indica la posizione del bucket Amazon S3 in cui deve essere condotto il processo DynamoDB `ExportTableToPointInTime`. Il formato del file per l'esportazione è DynamoDB JSON.
+ `"dynamodb.s3.prefix"`: (facoltativo) indica la posizione del prefisso di Amazon S3 all'interno del bucket Amazon S3 in cui devono essere archiviati i carichi `ExportTableToPointInTime` di DynamoDB. Se non si specificano i valori `dynamodb.s3.prefix` e `dynamodb.s3.bucket`, per impostazione predefinita sarà utilizzata la posizione della directory temporanea specificata nella configurazione del processo AWS Glue. Per ulteriori informazioni, vedere [Parametri speciali utilizzati da AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html).
+ `"dynamodb.s3.bucketOwner"`: indica il proprietario del bucket necessario per l'accesso di Amazon S3 tra account.
+ `"dynamodb.sts.roleArn"`: (Facoltativo) L'ARN del ruolo IAM da assumere per l'accesso tra account e più and/or regioni per la tabella DynamoDB. Nota: lo stesso ARN del ruolo IAM verrà utilizzato per accedere alla posizione Amazon S3 specificata per la richiesta `ExportTableToPointInTime`.
+ `"dynamodb.sts.roleSessionName"`: (Facoltativo) nome della sessione STS. L'impostazione predefinita è "-session». glue-dynamodb-read-sts
+ `"dynamodb.exportTime"` (facoltativo). Valori validi: stringhe che rappresentano istanti ISO-8601. point-in-timeA in cui deve essere effettuata l'esportazione.
+ `"dynamodb.sts.region"`: la regione che ospita la tabella DynamoDB da leggere (obbligatorio se si effettua una chiamata tra regioni utilizzando un endpoint regionale).
### "connectionType": "dynamodb" con il connettore ETL come sink
Utilizzare le seguenti opzioni di connessione con `"connectionType": "dynamodb"` come sink:
+ `"dynamodb.output.tableName"`: (Obbligatorio) la tabella DynamoDB su cui scrivere.
+ `"dynamodb.throughput.write.percent"`: (Facoltativo) percentuale di unità di capacità di scrittura (WCU) da usare. Il valore predefinito è "0,5". I valori accettabili vanno da "0,1" a "1,5", inclusi.
+ `0.5` rappresenta la velocità di scrittura di default, il che significa che AWS Glue cercherà di consumare metà della capacità di scrittura della tabella. Se si aumenta il valore sopra 0,5, AWS Glue aumenterà il tasso di richiesta; diminuendo il valore al di sotto di 0,5, riduce la frequenza di richiesta di scrittura. (La velocità di scrittura effettiva varia in base a fattori come la presenza di una distribuzione uniforme delle chiavi nella tabella DynamoDB).
+ Quando la tabella DynamoDB è in modalità on demand, AWS Glue gestisce la capacità di lettura della tabella come `40000`. Per importare una tabella di grandi dimensioni, si consiglia di passare alla modalità su richiesta della tabella DynamoDB.
+ `"dynamodb.output.numParallelTasks"`: (Facoltativo) definisce il numero di attività parallele scritte contemporaneamente in DynamoDB. Utilizzato per calcolare WCU permissivo per i processi Spark. Nella maggior parte dei casi, AWS Glue calcolerà un valore predefinito ragionevole per questo valore. Per ulteriori informazioni, consulta [Configurazione del parallelismo nelle operazioni DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.output.retry"`: (Facoltativo) definisce il numero di tentativi eseguiti quando esiste una `ProvisionedThroughputExceededException` da DynamoDB. Il valore predefinito è "10".
+ `"dynamodb.sts.roleArn"`: (facoltativo) il ruolo IAM ARN da assumere per l'accesso multi-account.
+ `"dynamodb.sts.roleSessionName"`: (Facoltativo) nome della sessione STS. L'impostazione predefinita è "glue-dynamodb-write-sts-session».
# Accesso multi-account in più regioni alle tabelle DynamoDB
I processi ETL AWS Glue supportano sia l'accesso multi-account che in più regioni alle tabelle DynamoDB. I processi ETL AWS Glue I job ETL supportano sia la lettura di dati dalla tabella DynamoDB di un altro AWS account, sia la scrittura di dati nella tabella DynamoDB di un altro AWS account. AWS Gluesupporta anche la lettura da una tabella DynamoDB in un'altra regione e la scrittura in una tabella DynamoDB in un'altra regione. Questa sezione fornisce istruzioni su come configurare l'accesso e fornisce uno script di esempio.
Le procedure descritte in questa sezione fanno riferimento a un tutorial IAM per la creazione di un ruolo IAM e la concessione dell'accesso al ruolo. Il tutorial discute anche l'assunzione di un ruolo, ma qui si utilizzerà invece uno script di processo per assumere il ruolo in AWS Glue. Questo tutorial contiene anche informazioni sulle pratiche generali multi-account. *Per ulteriori informazioni, consulta [Tutorial: Delegare l'accesso tra AWS account utilizzando i ruoli IAM nella Guida per l'utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html).*
## Creare un ruolo
Segui il [passaggio 1 del tutorial](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-1) per creare un ruolo IAM nell'account A. Quando definisci le autorizzazioni del ruolo, puoi scegliere di allegare policy esistenti come `AmazonDynamoDBReadOnlyAccess` o di consentire il ruolo `AmazonDynamoDBFullAccess` a read/write DynamoDB. L'esempio seguente mostra la creazione di un ruolo denominato `DynamoDBCrossAccessRole`, con la policy di autorizzazione `AmazonDynamoDBFullAccess`.
## Concedi autorizzazione per l'accesso al ruolo
Segui la [fase 2 del tutorial](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-2) nella *Guida per l'utente di IAM* per consentire all'account B di passare al ruolo appena creato. L'esempio seguente crea una nuova policy con l'istruzione riportata di seguito:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/DynamoDBCrossAccessRole"
}
}
```
------
Quindi, puoi allegare questa policy a quella group/role/user che desideri utilizzare per accedere a DynamoDB.
## Assumi il ruolo nello script di processo AWS Glue
Ora è possibile accedere all'account B e creare un processo AWS Glue. Per creare un processo, fai riferimento alle istruzioni in [Configurazione delle proprietà dei job per i job Spark in AWS Glue](add-job.md).
Nello script del processo è necessario utilizzare il parametro `dynamodb.sts.roleArn` per assumere il ruolo `DynamoDBCrossAccessRole`. Supponendo che questo ruolo consenta di ottenere le credenziali temporanee, che devono essere utilizzate per accedere a DynamoDB nell'account B, esamina questi script di esempio.
Per una lettura multi-account tra regioni (connettore ETL):
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-east-1",
"dynamodb.input.tableName": "test_source",
"dynamodb.sts.roleArn": ""
}
)
dyf.show()
job.commit()
```
Per una lettura multi-account tra regioni (connettore ELT):
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.export": "ddb",
"dynamodb.tableArn": "",
"dynamodb.sts.roleArn": ""
}
)
dyf.show()
job.commit()
```
Per una lettura e scrittura multi-account tra regioni:
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-east-1",
"dynamodb.input.tableName": "test_source"
}
)
dyf.show()
glue_context.write_dynamic_frame_from_options(
frame=dyf,
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-west-2",
"dynamodb.output.tableName": "test_sink",
"dynamodb.sts.roleArn": ""
}
)
job.commit()
```
# Connettore DynamoDB con supporto Spark DataFrame
Il connettore DynamoDB con supporto DataFrame Spark consente di leggere e scrivere su tabelle in DynamoDB utilizzando Spark. DataFrame APIs [I passaggi di configurazione dei connettori sono gli stessi del connettore DynamicFrame basato e sono disponibili qui.](aws-glue-programming-etl-connect-dynamodb-home.md#aws-glue-programming-etl-connect-dynamodb-configure)
Per caricare la libreria di connettori DataFrame basata, assicurati di collegare una connessione DynamoDB al job Glue.
**Nota**
L'interfaccia utente della console Glue attualmente non supporta la creazione di una connessione DynamoDB. Puoi usare Glue CLI ([CreateConnection](https://docs.aws.amazon.com/cli/latest/reference/glue/create-connection.html)) per creare una connessione DynamoDB:
```
aws glue create-connection \
--connection-input '{ \
"Name": "my-dynamodb-connection", \
"ConnectionType": "DYNAMODB", \
"ConnectionProperties": {}, \
"ValidateCredentials": false, \
"ValidateForComputeEnvironments": ["SPARK"] \
}'
```
Dopo aver creato la connessione DynamoDB, puoi collegarla al tuo lavoro Glue tramite CLI [CreateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/create-job.html)([UpdateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/update-job.html),) o direttamente nella pagina «Dettagli del lavoro»:
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/dynamodb-dataframe-connector.png)
Dopo esserti assicurato che una connessione con DYNAMODB Type sia collegata al tuo lavoro Glue, puoi utilizzare le seguenti operazioni di lettura, scrittura ed esportazione dal DataFrame connettore basato.
## Lettura e scrittura su DynamoDB con il connettore basato DataFrame
I seguenti esempi di codice mostrano come leggere e scrivere su tabelle DynamoDB tramite DataFrame il connettore basato. Mostrano la lettura da una tabella e la scrittura su un'altra tabella.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
spark = glueContext.spark_session
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
# Read from DynamoDB
df = spark.read.format("dynamodb") \
.option("dynamodb.input.tableName", "test-source") \
.option("dynamodb.throughput.read.ratio", "0.5") \
.option("dynamodb.consistentRead", "false") \
.load()
print(df.rdd.getNumPartitions())
# Write to DynamoDB
df.write \
.format("dynamodb") \
.option("dynamodb.output.tableName", "test-sink") \
.option("dynamodb.throughput.write.ratio", "0.5") \
.option("dynamodb.item.size.check.enabled", "true") \
.save()
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val spark = glueContext.getSparkSession
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val df = spark.read
.format("dynamodb")
.option("dynamodb.input.tableName", "test-source")
.option("dynamodb.throughput.read.ratio", "0.5")
.option("dynamodb.consistentRead", "false")
.load()
print(df.rdd.getNumPartitions)
df.write
.format("dynamodb")
.option("dynamodb.output.tableName", "test-sink")
.option("dynamodb.throughput.write.ratio", "0.5")
.option("dynamodb.item.size.check.enabled", "true")
.save()
job.commit()
}
}
```
------
## Utilizzo dell'esportazione DynamoDB tramite il connettore basato DataFrame
L'operazione di esportazione è preferita all'operazione di lettura per tabelle DynamoDB di dimensioni superiori a 80 GB. I seguenti esempi di codice mostrano come leggere da una tabella, esportare in S3 e stampare il numero di partizioni tramite il connettore basato. DataFrame
**Nota**
La funzionalità di esportazione DynamoDB è disponibile tramite l'oggetto Scala. `DynamoDBExport` Gli utenti Python possono accedervi tramite l'interoperabilità JVM di Spark o utilizzare l'SDK AWS per Python (boto3) con l'API DynamoDB. `ExportTableToPointInTime`
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.{GlueArgParser, Job}
import org.apache.spark.SparkContext
import glue.spark.dynamodb.DynamoDBExport
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val spark = glueContext.getSparkSession
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val options = Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> "arn:aws:dynamodb:us-east-1:123456789012:table/my-table",
"dynamodb.s3.bucket" -> "my-s3-bucket",
"dynamodb.s3.prefix" -> "my-s3-prefix",
"dynamodb.simplifyDDBJson" -> "true"
)
val df = DynamoDBExport.fullExport(spark, options)
print(df.rdd.getNumPartitions)
df.count()
Job.commit()
}
}
```
------
## Opzioni di configurazione
### Opzioni di lettura
| Opzione | Description | Predefinita |
| --- | --- | --- |
| dynamodb.input.tableName | Nome della tabella DynamoDB (obbligatorio) | - |
| dynamodb.throughput.read | Le unità di capacità di lettura (RCU) da utilizzare. Se non specificato, dynamodb.throughput.read.ratio viene utilizzato per il calcolo. | - |
| dynamodb.throughput.read.ratio | Il rapporto tra unità di capacità di lettura (RCU) da utilizzare | 0,5 |
| dynamodb.table.read.capacity | La capacità di lettura della tabella su richiesta utilizzata per il calcolo della velocità effettiva. Questo parametro è valido solo nelle tabelle di capacità su richiesta. L'impostazione predefinita sono le unità di lettura a throughput caldo. | - |
| dynamodb.splits | Definisce il numero di segmenti utilizzati nelle operazioni di scansione parallela. Se non viene fornito, il connettore calcolerà un valore predefinito ragionevole. | - |
| dynamodb.consistentRead | Se utilizzare letture fortemente coerenti | FALSE |
| dynamodb.input.retry | Definisce quanti tentativi eseguiamo quando esiste un'eccezione riprovabile. | 10 |
### Opzioni di scrittura
| Opzione | Description | Predefinita |
| --- | --- | --- |
| dynamodb.output.tableName | Nome della tabella DynamoDB (obbligatorio) | - |
| dynamodb.throughput.write | Le unità di capacità di scrittura (WCU) da utilizzare. Se non specificato, dynamodb.throughput.write.ratio viene utilizzato per il calcolo. | - |
| dynamodb.throughput.write.ratio | Il rapporto tra unità di capacità di scrittura (WCU) da utilizzare | 0,5 |
| dynamodb.table.write.capacity | La capacità di scrittura della tabella su richiesta utilizzata per il calcolo della velocità effettiva. Questo parametro è valido solo nelle tabelle di capacità su richiesta. L'impostazione predefinita sono le unità di scrittura con throughput caldo. | - |
| dynamodb.item.size.check.enabled | Se vero, il connettore calcola la dimensione dell'elemento e interrompe l'operazione se la dimensione supera la dimensione massima, prima di scrivere nella tabella DynamoDB. | TRUE |
| dynamodb.output.retry | Definisce il numero di tentativi da eseguire in presenza di un'eccezione riutilizzabile. | 10 |
### Opzioni di esportazione
| Opzione | Description | Predefinita |
| --- | --- | --- |
| dynamodb.export | Se impostato su, ddb abilita il connettore di esportazione AWS Glue DynamoDB dove verrà richiamato un ExportTableToPointInTimeRequet nuovo connettore durante il AWS processo Glue. Verrà generata una nuova esportazione con la posizione passata da dynamodb.s3.bucket e dynamodb.s3.prefix. Se impostato su, s3 abilita il connettore di esportazione AWS Glue, DynamoDB, ma salta la creazione di una nuova esportazione DynamoDB e utilizza invece l'and dynamodb.s3.bucket come posizione Amazon S3 dynamodb.s3.prefix del passato esportato da quella tabella. | ddb |
| dynamodb.tableArn | La tabella DynamoDB da cui leggere. Obbligatorio se dynamodb.export è impostato su ddb. | |
| dynamodb.simplifyDDBJson | Se impostato sutrue, esegue una trasformazione per semplificare lo schema della struttura JSON di DynamoDB presente nelle esportazioni. | FALSE |
| dynamodb.s3.bucket | Il bucket S3 per archiviare i dati temporanei durante l'esportazione in DynamoDB (obbligatorio) | |
| dynamodb.s3.prefix | Il prefisso S3 per archiviare dati temporanei durante l'esportazione in DynamoDB | |
| dynamodb.s3.bucketOwner | Indicare il proprietario del bucket necessario per l'accesso ad Amazon S3 su più account | |
| dynamodb.s3.sse.algorithm | Tipo di crittografia utilizzato nel bucket in cui verranno archiviati i dati temporanei. I valori validi sono AES256 e KMS. | |
| dynamodb.s3.sse.kmsKeyId | L'ID della chiave AWS KMS gestita utilizzata per crittografare il bucket S3 in cui verranno archiviati i dati temporanei (se applicabile). | |
| dynamodb.exportTime | point-in-timeA in cui deve essere effettuata l'esportazione. Valori validi: stringhe che rappresentano istanti ISO-8601. | |
### Opzioni generali
| Opzione | Description | Predefinita |
| --- | --- | --- |
| dynamodb.sts.roleArn | Il ruolo IAM (ARN) da assumere per l'accesso tra account diversi | - |
| dynamodb.sts.roleSessionName | Nome della sessione STS | glue-dynamodb-sts-session |
| dynamodb.sts.region | Regione per il client STS (per l'assunzione di ruoli interregionali) | Uguale all'opzione region |
# Connessioni Kinesis
È possibile usare una connessione Kinesis per leggere e scrivere su flussi di dati Amazon Kinesis utilizzando le informazioni archiviate in una tabella del Catalogo dati o fornendo informazioni per accedere direttamente al flusso di dati. Puoi leggere le informazioni da Kinesis in Spark DataFrame, quindi convertirle in un Glue. AWS DynamicFrame Puoi DynamicFrames scrivere su Kinesis in formato JSON. Se accedi direttamente al flusso di dati, utilizza queste opzioni per fornire le informazioni su come accedere al flusso di dati.
Se si utilizza `getCatalogSource` o `create_data_frame_from_catalog` per consumare i registri da una sorgente di streaming Kinesis, il processo avrà le informazioni sul database catalogo dati e sul nome della tabella, e potrà usarle per ottenere alcuni parametri di base per la lettura dalla sorgente di streaming Kinesis. Se si utilizza `getSource`, `getSourceWithFormat`, `createDataFrameFromOptions` o `create_data_frame_from_options`, dovrai specificare questi parametri di base utilizzando le opzioni di connessione descritte qui.
È possibile specificare le opzioni di connessione per Kinesis utilizzando i seguenti argomenti per i metodi specificati nella classe `GlueContext`.
+ Scala
+ `connectionOptions`: utilizza con `getSource`, `createDataFrameFromOptions` e `getSink`
+ `additionalOptions`: utilizza con `getCatalogSource`, `getCatalogSink`
+ `options`: utilizza con `getSourceWithFormat`, `getSinkWithFormat`
+ Python
+ `connection_options`: utilizza con `create_data_frame_from_options`, `write_dynamic_frame_from_options`
+ `additional_options`: utilizza con `create_data_frame_from_catalog`, `write_dynamic_frame_from_catalog`
+ `options`: utilizza con `getSource`, `getSink`
Per osservazioni e restrizioni sui processi ETL dei flussi di dati, consultare la pagina [Streaming di note e restrizioni ETL](add-job-streaming.md#create-job-streaming-restrictions).
## Configurazione di Kinesis
Per connetterti a un flusso di dati Kinesis in un job AWS Glue Spark, avrai bisogno di alcuni prerequisiti:
+ In caso di lettura, il job AWS Glue deve disporre delle autorizzazioni IAM di livello di accesso Read per il flusso di dati Kinesis.
+ In fase di scrittura, il job AWS Glue deve disporre delle autorizzazioni IAM di livello di accesso Write per il flusso di dati Kinesis.
In alcuni casi, è necessario configurare ulteriori prerequisiti:
+ Se il tuo job AWS Glue è configurato con **connessioni di rete aggiuntive** (in genere per connettersi ad altri set di dati) e una di queste connessioni offre opzioni di **rete Amazon VPC**, questo indirizzerà il tuo lavoro a comunicare tramite Amazon VPC. In questo caso, per comunicare tramite Amazon VPC dovrai configurare anche il flusso di dati Kinesis. È possibile farlo creando un endpoint VPC di interfaccia tra l'Amazon VPC e il flusso di dati Kinesis. Per ulteriori informazioni, consulta la pagina [Using Amazon Kinesis Data Streams with Interface VPC Endpoints](https://docs.aws.amazon.com//streams/latest/dev/vpc.html).
+ Quando si specifica un flusso di dati Amazon Kinesis in un altro account, è necessario impostare i ruoli e le policy per consentire l'accesso multi-account. Per ulteriori informazioni, consultare [ Esempio: lettura da un flusso Kinesis in un account diverso](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html).
Per ulteriori informazioni sui prerequisiti dei processi ETL dei flussi di dati, consultare la pagina [Aggiunta di processi di streaming ETL in AWS Glue](add-job-streaming.md).
## Esempio: lettura da flussi Kinesis
### Esempio: lettura da flussi Kinesis
Usato in combinazione con [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Esempio per l'origine di streaming Amazon Kinesis:
```
kinesis_options =
{ "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream",
"startingPosition": "TRIM_HORIZON",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options)
```
## Esempio: scrittura su flussi Kinesis
### Esempio: lettura da flussi Kinesis
Usato in combinazione con [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Esempio per l'origine di streaming Amazon Kinesis:
```
kinesis_options =
{ "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream",
"startingPosition": "TRIM_HORIZON",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options)
```
## Indicazioni di riferimento alle opzioni di connessione a Kinesis
Indica le opzioni di connessione ad Amazon Kinesis Data Streams.
Utilizza le seguenti opzioni di connessione per le origini dati in streaming Kinesis:
+ `"streamARN"`: (obbligatorio) utilizzato per la lettura/scrittura. L'ARN del flusso di dati di Kinesis.
+ `"classification"`: (obbligatorio per la lettura) utilizzato per la lettura. Il formato di file utilizzato dai dati nel record. Obbligatorio, a meno che non sia fornito tramite Catalogo dati.
+ `"streamName"`: (facoltativo) utilizzato per la lettura. Il nome di un flusso di dati Kinesis da cui leggere. Usato con `endpointUrl`.
+ `"endpointUrl"`: (facoltativo) utilizzato per la lettura. Predefinito: "». https://kinesis.us-east-1.amazonaws.com L' AWS endpoint del flusso Kinesis. Non è necessario modificarlo a meno che non ci si stia connettendo a una regione speciale.
+ `"partitionKey"`: (facoltativo) utilizzato per la scrittura. La chiave di partizione di Kinesis utilizzata per la produzione dei record.
+ `"delimiter"`: (facoltativo) utilizzato per la lettura. Il separatore di valori utilizzato quando `classification` è CSV. Il valore predefinito è “`,`”.
+ `"startingPosition"`: (opzionale) utilizzato per la lettura. La posizione di partenza nel flusso dei dati Kinesis da cui leggere i dati. I valori possibili sono `"latest"`, `"trim_horizon"`, `"earliest"` o una stringa di timestamp in formato UTC con il modello `yyyy-mm-ddTHH:MM:SSZ`, dove `Z` rappresenta uno scostamento del fuso orario UTC con un \$1/- (ad esempio: "2023-04-04T08:00:00-04:00"). Il valore predefinito è `"latest"`. Nota: la stringa Timestamp in formato UTC per `"startingPosition"` è supportata solo per AWS Glue versione 4.0 o successiva.
+ `"failOnDataLoss"`: (facoltativo) non è possibile eseguire il processo se una partizione attiva è mancante o scaduta. Il valore predefinito è `"false"`.
+ `"awsSTSRoleARN"`: (facoltativo) utilizzato per la lettura/scrittura. L'Amazon Resource Name (ARN) del ruolo da assumere utilizzando AWS Security Token Service (AWS STS). Questo ruolo deve disporre delle autorizzazioni per descrivere o leggere le operazioni dei registri per il flusso di dati Kinesis. Quando si accede a un flusso di dati in un altro account, è necessario utilizzare questo parametro. Usato in combinazione con `"awsSTSSessionName"`.
+ `"awsSTSSessionName"`: (facoltativo) utilizzato per la lettura/scrittura. Un identificatore della sessione che assume il ruolo usando AWS STS. Quando si accede a un flusso di dati in un altro account, è necessario utilizzare questo parametro. Usato in combinazione con `"awsSTSRoleARN"`.
+ `"awsSTSEndpoint"`: (Facoltativo) L' AWS STS endpoint da utilizzare quando ci si connette a Kinesis con un ruolo presunto. Ciò consente di utilizzare l' AWS STS endpoint regionale in un VPC, cosa non possibile con l'endpoint globale predefinito.
+ `"maxFetchTimeInMs"`: (opzionale) utilizzato per la lettura. Il tempo massimo impiegato affinché l'esecutore del processo legga i record della batch attuale dal flusso di dati Kinesis, specificato in millisecondi (ms). Entro questo periodo è possibile effettuate più chiamate API `GetRecords`. Il valore predefinito è `1000`.
+ `"maxFetchRecordsPerShard"`: (opzionale) utilizzato per la lettura. Il numero massimo di record da recuperare per shard nel flusso di dati Kinesis per microbatch. Nota: il client può superare questo limite se il processo di streaming ha già letto i record aggiuntivi da Kinesis (nella stessa chiamata get-records). Se `maxFetchRecordsPerShard` deve essere rigoroso, allora deve essere un multiplo di `maxRecordPerRead`. Il valore predefinito è `100000`.
+ `"maxRecordPerRead"`: (opzionale) utilizzato per la lettura. Il numero massimo di record da recuperare nel flusso di dati Kinesis in ciascuna operazione `getRecords`. Il valore predefinito è `10000`.
+ `"addIdleTimeBetweenReads"`: (opzionale) utilizzato per la lettura. Aggiunge un ritardo tra due operazioni consecutive `getRecords`. Il valore predefinito è `"False"`. Questa opzione è configurabile solo per Glue versione 2.0 e successive.
+ `"idleTimeBetweenReadsInMs"`: (opzionale) utilizzato per la lettura. Il ritardo minimo tra due operazioni consecutive `getRecords`, specificato in ms. Il valore predefinito è `1000`. Questa opzione è configurabile solo per Glue versione 2.0 e successive.
+ `"describeShardInterval"`: (opzionale) utilizzato per la lettura. L'intervallo di tempo minimo tra due chiamate API `ListShards` affinché lo script consideri il resharding. Per ulteriori informazioni, consultare [Strategie per il resharding](https://docs.aws.amazon.com//streams/latest/dev/kinesis-using-sdk-java-resharding-strategies.html) nella *Guida per gli sviluppatori di Amazon Kinesis Data Streams*. Il valore predefinito è `1s`.
+ `"numRetries"`: (opzionale) utilizzato per la lettura. Il numero massimo di tentativi per le richieste API Kinesis Data Streams. Il valore predefinito è `3`.
+ `"retryIntervalMs"`: (opzionale) utilizzato per la lettura. Il periodo di raffreddamento (specificato in ms) prima di riprovare la chiamata API Kinesis Data Streams. Il valore predefinito è `1000`.
+ `"maxRetryIntervalMs"`: (opzionale) utilizzato per la lettura. Il periodo di raffreddamento (specificato in ms) tra due tentativi di chiamata API Kinesis Data Streams. Il valore predefinito è `10000`.
+ `"avoidEmptyBatches"`: (opzionale) utilizzato per la lettura. Impedisce la creazione di un processo microbatch vuoto controllando la presenza di dati non letti nel flusso dei dati Kinesis prima che il batch venga avviato. Il valore predefinito è `"False"`.
+ `"schema"`: (obbligatorio quando inferSchema è impostato su falso) utilizzato per la lettura. Lo schema da utilizzare per elaborare il payload. Se la classificazione è `avro`, lo schema fornito dovrà essere nel formato dello schema Avro. Se la classificazione è `avro`, lo schema fornito dovrà essere nel formato dello schema DDL.
Di seguito sono riportati alcuni esempi di schema.
------
#### [ Example in DDL schema format ]
```
`column1` INT, `column2` STRING , `column3` FLOAT
```
------
#### [ Example in Avro schema format ]
```
{
"type":"array",
"items":
{
"type":"record",
"name":"test",
"fields":
[
{
"name":"_id",
"type":"string"
},
{
"name":"index",
"type":
[
"int",
"string",
"float"
]
}
]
}
}
```
------
+ `"inferSchema"`: (opzionale) utilizzato per la lettura. Il valore predefinito è "false". Se impostato su "true", lo schema verrà rilevato in fase di runtime dal payload all'interno di `foreachbatch`.
+ `"avroSchema"`: (obsoleto) utilizzato per la lettura. Parametro utilizzato per specificare uno schema di dati Avro quando viene utilizzato il formato Avro. Questo parametro è obsoleto. Utilizzo del parametro `schema`.
+ `"addRecordTimestamp"`: (opzionale) utilizzato per la lettura. Quando questa opzione è impostata su "true", l'output dei dati conterrà una colonna aggiuntiva denominata "\$1\$1src\$1timestamp" che indica l'ora in cui il record corrispondente è stato ricevuto dal flusso. Il valore predefinito è "false". Questa opzione è supportata in AWS Glue versione 4.0 o successive.
+ `"emitConsumerLagMetrics"`: (opzionale) utilizzato per la lettura. Quando l'opzione è impostata su «true», per ogni batch emette le metriche relative alla durata compresa tra il record più vecchio ricevuto dallo stream e il momento in cui arriva a. AWS Glue CloudWatch Il nome della metrica è «glue.driver.streaming. maxConsumerLagInMs». Il valore predefinito è "false". Questa opzione è supportata in AWS Glue versione 4.0 o successive.
+ `"fanoutConsumerARN"`: (opzionale) utilizzato per la lettura. L'ARN di un consumatore di un flusso Kinesis per il flusso specificato in `streamARN`. Utilizzato per abilitare la modalità di fan-out avanzato per la connessione Kinesis. Per ulteriori informazioni sull'utilizzo di un flusso Kinesis con fan-out avanzato, consultare la pagina [Utilizzo del fan-out avanzato nei processi di flussi di dati Kinesis](aws-glue-programming-etl-connect-kinesis-efo.md).
+ `"recordMaxBufferedTime"`: (opzionale) utilizzato per la scrittura. Predefinito: 1000 (ms). Tempo massimo di memorizzazione nel buffer di un record in attesa di essere scritto.
+ `"aggregationEnabled"`: (opzionale) utilizzato per la scrittura. Default: true. Speciifica se i record devono essere aggregati prima di inviarli a Kinesis.
+ `"aggregationMaxSize"`: (opzionale) utilizzato per la scrittura. Impostazione predefinita: 51200 (byte). Se un record è superiore a questo limite, ignorerà l'aggregatore. Ricorda che Kinesis impone un limite di 50 KB alla dimensione del record. Se imposti questo valore oltre i 50 KB, i record di grandi dimensioni verranno rifiutati da Kinesis.
+ `"aggregationMaxCount"`: (facoltativo) utilizzato per la scrittura. Predefinito: 4294967295. Numero massimo di voci da inserire in un record aggregato.
+ `"producerRateLimit"`: (facoltativo) utilizzato per la scrittura. Predefinito: 150 (%). Limita la velocità di trasmissione effettiva per partizione inviata da un singolo produttore (ad esempio, il tuo processo), come percentuale del limite di backend.
+ `"collectionMaxCount"`: (facoltativo) utilizzato per la scrittura. Predefinito: 500. Numero massimo di articoli da imballare in una PutRecords richiesta.
+ `"collectionMaxSize"`: (facoltativo) utilizzato per la scrittura. Impostazione predefinita: 5242880 (byte). Quantità massima di dati da inviare con una PutRecords richiesta.
# Utilizzo del fan-out avanzato nei processi di flussi di dati Kinesis
Un consumatore con fan-out avanzato è in grado di ricevere i record da un flusso Kinesis con una velocità di trasmissione effettiva dedicata che può essere superiore a quella dei consumatori tipici. Questo viene fatto ottimizzando il protocollo di trasferimento utilizzato per fornire dati a un consumatore Kinesis, ad esempio il tuo processo. Per ulteriori informazioni sul fan-out avanzato di Kinesis, consulta [la documentazione di Kinesis](https://docs.aws.amazon.com//streams/latest/dev/enhanced-consumers.html).
Nella modalità fan-out avanzato, le opzioni di connessione `maxRecordPerRead` e `idleTimeBetweenReadsInMs` non sono più valide, poiché tali parametri non sono configurabili quando si utilizza il fan-out avanzato. Le opzioni di configurazione per i nuovi tentativi funzionano come descritto.
Utilizza le seguenti procedure per abilitare e disabilitare il fan-out avanzato per il tuo processo di flussi di dati. Devi registrare un consumatore del flusso per ogni processo che consumerà i dati del flusso.
**Per abilitare il consumo con fan-out avanzato nel processo:**
1. Registra un consumatore del flusso per il tuo processo utilizzando l'API Kinesis. Segui le istruzioni per *registrare un consumatore con fan-out avanzato utilizzando l'API Flusso di dati Kinesis* riportate nella [documentazione di Kinesis](https://docs.aws.amazon.com//streams/latest/dev/building-enhanced-consumers-api). Dovrai solo seguire il primo passo: chiamare [RegisterStreamConsumer](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RegisterStreamConsumer.html). La tua richiesta dovrebbe restituire un ARN,. *consumerARN*
1. Imposta l'opzione di connessione `fanoutConsumerARN` su *consumerARN* negli argomenti del metodo di connessione.
1. Riavvia il processo.
**Per disabilitare il consumo con fan-out avanzato nel processo:**
1. Rimuovi l'opzione di connessione `fanoutConsumerARN` dalla chiamata al metodo.
1. Riavvia il processo.
1. Segui le istruzioni per *annullare la registrazione di un consumatore* riportate nella [documentazione di Kinesis](https://docs.aws.amazon.com/streams/latest/dev/building-enhanced-consumers-console.html). Queste istruzioni si applicano alla console, ma possono essere utilizzate anche per l'API Kinesis. Per ulteriori informazioni sulla cancellazione della registrazione dei consumatori in streaming tramite l'API Kinesis, consulta la documentazione di Kinesis. [DeregisterStreamConsumer](https://docs.aws.amazon.com//kinesis/latest/APIReference/API_DeregisterStreamConsumer.html)
# Connessioni Amazon S3
Puoi usare AWS Glue for Spark per leggere e scrivere file in Amazon S3. AWS Glue for Spark supporta immediatamente molti formati di dati comuni archiviati in Amazon S3, tra cui CSV, Avro, JSON, Orc e Parquet. Per ulteriori informazioni sui formati di dati supportati, consulta la pagina [Opzioni del formato dati per input e output in AWS Glue per Spark](aws-glue-programming-etl-format.md). Ogni formato di dati può supportare un set diverso di funzionalità AWS Glue. Consulta la pagina relativa al formato dei dati per le specifiche del supporto delle funzionalità. Inoltre, puoi leggere e scrivere file con versioni diverse archiviati nei framework di data lake Hudi, Iceberg e Delta Lake. Per ulteriori informazioni sui framework di data lake, consulta la pagina [Utilizzo di framework di data lake con AWS Glue processi ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Con AWS Glue puoi partizionare i tuoi oggetti Amazon S3 in una struttura di cartelle durante la scrittura, quindi recuperarli per partizione per migliorare le prestazioni utilizzando una semplice configurazione. È inoltre possibile impostare la configurazione per raggruppare file di piccole dimensioni durante la trasformazione dei dati per migliorare le prestazioni. In Amazon S3 è possibile leggere e scrivere archivi `bzip2` e `gzip`.
**Topics**
+ [Configurazione delle connessioni S3](#aws-glue-programming-etl-connect-s3-configure)
+ [Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](#aws-glue-programming-etl-connect-s3)
+ [Sintassi di connessione obsolete per i formati di dati](#aws-glue-programming-etl-connect-legacy-format)
+ [Esclusione delle classi di storage Amazon S3](aws-glue-programming-etl-storage-classes.md)
+ [Gestione delle partizioni per l'output ETL in AWS Glue](aws-glue-programming-etl-partitions.md)
+ [Lettura di file di input in gruppi di grandi dimensioni](grouping-input-files.md)
+ [Endpoint Amazon VPC per Amazon S3](vpc-endpoints-s3.md)
## Configurazione delle connessioni S3
Per connetterti ad Amazon S3 con un job AWS Glue with Spark, avrai bisogno di alcuni prerequisiti:
+ Il job AWS Glue deve disporre delle autorizzazioni IAM per i bucket Amazon S3 pertinenti.
In alcuni casi, è necessario configurare ulteriori prerequisiti:
+ Quando configuri l'accesso multi-account, configura i controlli dell'accesso appropriati nel bucket Amazon S3.
+ Per motivi di sicurezza, è possibile scegliere di instradare le richieste Amazon S3 tramite un Amazon VPC. Questo approccio può introdurre problematiche relative alla larghezza di banda e alla disponibilità. Per ulteriori informazioni, consulta [Endpoint Amazon VPC per Amazon S3](vpc-endpoints-s3.md).
## Indicazioni di riferimento alle opzioni di connessione ad Amazon S3
Indica una connessione ad Amazon S3.
Poiché Amazon S3 gestisce i file anziché le tabelle, oltre a specificare le proprietà di connessione fornite in questo documento, dovrai specificare una configurazione aggiuntiva sul tipo di file. Queste informazioni vengono specificate tramite le opzioni di formato dei dati. Per ulteriori informazioni sulle opzioni di formato, consulta la pagina [Opzioni del formato dati per input e output in AWS Glue per Spark](aws-glue-programming-etl-format.md). È inoltre possibile specificare queste informazioni mediante l'integrazione con Catalogo dati AWS Glue.
Per un esempio della distinzione tra opzioni di connessione e opzioni di formato, prendi in considerazione come il metodo [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) recepisce `connection_type`, `connection_options`, `format` e `format_options`. Questa sezione illustra in modo specifico i parametri forniti a `connection_options`.
Utilizzare le seguenti opzioni di connessione con `"connectionType": "s3"`:
+ `"paths"`: (Obbligatorio) un elenco dei percorsi Amazon S3 da cui leggere.
+ `"exclusions"`: (facoltativo) una stringa contenente un elenco di JSON di modelli glob in stile Unix da escludere. Ad esempio `"[\"**.pdf\"]"` esclude tutti i file PDF. Per ulteriori informazioni sulla sintassi glob supportata da AWS Glue, vedere [Modelli di inclusione e di esclusione](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude).
+ `"compressionType"`: o "`compression`": (facoltativo) specifica il modo in cui i dati sono compressi. Utilizza `"compressionType"` per origini Amazon S3 e `"compression"` per destinazioni Amazon S3. In genere questo non è necessario se i dati hanno un'estensione del file standard. I valori possibili sono `"gzip"` e `"bzip2"`). È possibile che vengano supportati formati di compressione aggiuntivi per formati specifici. Per i dettagli sul supporto delle varie funzionalità, consulta la pagina relativa al formato dei dati.
+ `"groupFiles"`: (facoltativo) il raggruppamento di file è attivato per impostazione predefinita quando l'input contiene più di 50.000 file. Per attivare il raggruppamento con meno di 50.000 file, imposta questo parametro su `"inPartition"`. Per disabilitare il raggruppamento in presenza di più di 50.000 file, imposta il parametro su `"none"`.
+ `"groupSize"`: (facoltativo) dimensione del gruppo target in byte. Il valore di default viene calcolato in base alla dimensione dei dati di input e alle dimensioni del cluster. Quando sono presenti meno di 50.000 file di input, `"groupFiles"` deve essere impostato su `"inPartition"` per rendere effettiva la modifica.
+ `"recurse"`: (facoltativo) se è impostato su "true", legge i file in modo ricorsivo in tutte le sottodirectory dei percorsi specificati.
+ `"maxBand"`: (facoltativo, avanzato) questa opzione controlla la durata in millisecondi dopo la quale è probabile che l'elenco `s3` sia coerente. I file con timestamp di modifica che rientrano negli ultimi `maxBand` secondi, vengono tracciati in modo specifico quando si usano `JobBookmarks` per verificare la consistenza finale in Amazon S3. Per la maggior parte degli utenti non è necessario impostare questa opzione. Il valore di default è 900.000 millisecondi o 15 minuti.
+ `"maxFilesInBand"`: (Facoltativo, avanzato) questa opzione specifica il numero massimo di file da salvare negli ultimi `maxBand` secondi. Se si supera questo valore, i file aggiuntivi vengono saltati e solo elaborati nella successiva esecuzione del processo. Per la maggior parte degli utenti non è necessario impostare questa opzione.
+ `"isFailFast"`: (Facoltativo) questa opzione determina se un processo ETL AWS Glue generi eccezioni di analisi del lettore. Se impostato su `true`, i processi non riescono rapidamente se quattro tentativi del processo Spark non riescono a analizzare correttamente i dati.
+ `"catalogPartitionPredicate"`: (facoltativo) utilizzato per la lettura. Il contenuto di una clausola `WHERE` in SQL. Utilizzato per la lettura dalle tabelle di Catalogo dati con una quantità molto elevata di partizioni. Recupera le partizioni corrispondenti dagli indici di Catalogo dati. Utilizzato con `push_down_predicate`, un'opzione sul metodo [create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog) (e altri metodi simili). Per ulteriori informazioni, consulta [Filtraggio lato server utilizzando predicati delle partizioni di catalogo](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
+ `"partitionKeys"`: (facoltativo) utilizzato per la scrittura. Una matrice di stringhe di etichette di colonna. AWS Glue partizionerà i dati come specificato da questa configurazione. Per ulteriori informazioni, consulta [Scrittura delle partizioni](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-writing).
+ `"excludeStorageClasses"`: (facoltativo) utilizzato per la lettura. Una serie di stringhe che specificano le classi di storage Amazon S3. AWS Glue escluderà gli oggetti Amazon S3 in base a questa configurazione. Per ulteriori informazioni, consulta [Esclusione delle classi di storage Amazon S3](aws-glue-programming-etl-storage-classes.md).
## Sintassi di connessione obsolete per i formati di dati
È possibile accedere a determinati formati di dati utilizzando una sintassi specifica per il tipo di connessione. Questa sintassi è obsoleta. Pertanto, si consiglia di specificare i formati utilizzando il tipo di connessione `s3` e le opzioni di formato fornite in [Opzioni del formato dati per input e output in AWS Glue per Spark](aws-glue-programming-etl-format.md).
### "connectionType": "Orc"
Indica una connessione a file archiviati in Amazon S3 nel formato [Apache Hive Optimized Row Columnar (ORC)](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC).
Utilizzare le seguenti opzioni di connessione con `"connectionType": "orc"`:
+ `paths`: (Obbligatorio) un elenco dei percorsi Amazon S3 da cui leggere.
+ *(Altre name/value coppie di opzioni)*: tutte le opzioni aggiuntive, incluse le opzioni di formattazione, vengono passate direttamente a SparkSQL`DataSource`.
### "connectionType": "parquet"
Indica una connessione a file archiviati in Amazon S3 nel formato di file [Apache Parquet](https://parquet.apache.org/docs/).
Utilizzare le seguenti opzioni di connessione con `"connectionType": "parquet"`:
+ `paths`: (Obbligatorio) un elenco dei percorsi Amazon S3 da cui leggere.
+ *(Altre name/value coppie di opzioni)*: tutte le opzioni aggiuntive, incluse le opzioni di formattazione, vengono passate direttamente a SparkSQL`DataSource`.
# Esclusione delle classi di storage Amazon S3
Se esegui processi ETL AWS Glue che leggono file o partizioni da Amazon Simple Storage Service (Amazon S3), puoi escludere alcuni tipi di classe di archiviazione Amazon S3.
Le seguenti classi di storage sono disponibili in Amazon S3:
+ `STANDARD`: per lo storage generico dei dati a cui si accede di frequente.
+ `INTELLIGENT_TIERING`: per i dati di lunga durata con modelli di accesso sconosciuti o modificati.
+ `STANDARD_IA` e `ONEZONE_IA`: per i dati esistenti da molto tempo a cui si accede meno frequentemente.
+ `GLACIER`, `DEEP_ARCHIVE` e `REDUCED_REDUNDANCY`: per l'archiviazione a lungo termine e la conservazione digitale.
Per ulteriori informazioni, consulta [Classi di storage Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) nella *Guida per gli sviluppatori di Amazon S3*.
Gli esempi in questa sezione mostrano come escludere le classi di storage `DEEP_ARCHIVE` e `GLACIER`. Queste classi consentono di elencare i file, ma non di leggere i file a meno che non vengano ripristinati. (Per ulteriori informazioni, consulta [Ripristino di oggetti archiviati](https://docs.aws.amazon.com/AmazonS3/latest/dev/restoring-objects.html) nella *Guida per gli sviluppatori di Amazon S3*).
Utilizzando le esclusioni della classe di archiviazione, puoi assicurarti che i processi AWS Glue funzionino su tabelle che dispongono di partizioni tra questi livelli di classi di archiviazione. Senza esclusioni, i processi che leggono i dati da questi livelli hanno esito negativo con il seguente errore: AmazonS3Exception: l'operazione non è valida per la classe di storage dell'oggetto.
Esistono diversi modi per filtrare le classi di archiviazione Amazon S3 in AWS Glue.
**Topics**
+ [Esclusione delle classi di storage Amazon S3 durante la creazione di un frame dinamico](#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [Esclusione delle classi di storage Amazon S3 in una tabella del catalogo dati](#aws-glue-programming-etl-storage-classes-table)
## Esclusione delle classi di storage Amazon S3 durante la creazione di un frame dinamico
Per escludere le classi di archiviazione Amazon S3 durante la creazione di un frame dinamico, utilizza `excludeStorageClasses` in `additionalOptions`. AWS Glue utilizza automaticamente la propria implementazione Amazon S3 `Lister` per elencare ed escludere i file corrispondenti alle classi di archiviazione specificate.
I seguenti esempi Python e Scala mostrano come escludere le classi di storage `GLACIER` e `DEEP_ARCHIVE` durante la creazione di un frame dinamico.
Esempio di Python:
```
glueContext.create_dynamic_frame.from_catalog(
database = "my_database",
tableName = "my_table_name",
redshift_tmp_dir = "",
transformation_ctx = "my_transformation_context",
additional_options = {
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
```
Esempio di Scala:
```
val* *df = glueContext.getCatalogSource(
nameSpace, tableName, "", "my_transformation_context",
additionalOptions = JsonOptions(
Map("excludeStorageClasses" -> List("GLACIER", "DEEP_ARCHIVE"))
)
).getDynamicFrame()
```
## Esclusione delle classi di storage Amazon S3 in una tabella del catalogo dati
È possibile specificare le esclusioni delle classi di archiviazione da utilizzare da un processo AWS Glue ETL come parametro di tabella nel AWS Glue Data Catalog. È possibile includere questo parametro nell'`CreateTable`operazione utilizzando AWS Command Line Interface (AWS CLI) o utilizzando l'API a livello di codice. Per ulteriori informazioni, vedere [Struttura della tabella](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-Table) e. [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)
Puoi anche specificare classi di storage escluse nella console AWS Glue.
**Per escludere classi di storage Amazon S3 (console)**
1. Accedi a Console di gestione AWS e apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel riquadro di navigazione a sinistra, scegliere **Tables (Tabelle)**.
1. Scegliere il nome della tabella nell'elenco, quindi selezionare **Edit table (Modifica tabella)**.
1. In **Table properties (Proprietà tabella)**, aggiungere **excludeStorageClasses** come una chiave e **[\$1"GLACIER\$1",\$1"DEEP\$1ARCHIVE\$1"]** come un valore.
1. Scegli **Applica**.
# Gestione delle partizioni per l'output ETL in AWS Glue
Il partizionamento è una tecnica importante per organizzare i set di dati in modo da poterne eseguire query efficaci. I dati sono organizzati in una struttura gerarchica di directory basata su valori distinti di una o più colonne.
Ad esempio, puoi decidere di partizionare i log di un'applicazione in Amazon Simple Storage Service (Amazon S3) per data, suddivisi per anno, mese e giorno. I file che corrispondono ai dati di un solo giorno vengono quindi posti sotto un prefisso, ad esempio `s3://my_bucket/logs/year=2018/month=01/day=23/`. Sistemi come Amazon Athena, Amazon Redshift Spectrum e ora AWS Glue possono usare queste partizioni per filtrare i dati in base al valore di partizione senza dover leggere tutti i dati sottostanti da Amazon S3.
I crawler non solo deducono i tipi e gli schemi di file, ma identificano anche automaticamente la struttura delle partizioni del set di dati quando popolano il Glue Data Catalog. AWS Le colonne di partizione risultanti sono disponibili per le query nei processi ETL AWS Glue o per motori di query come Amazon Athena.
Dopo aver eseguito il crawling di una tabella, puoi visualizzare le partizioni create dal crawler. Nella console AWS Glue, scegli **Applications** (Applicazioni) nel pannello di navigazione sinistro. Scegli la tabella creata dal crawler, quindi scegli **View Partitions** (Visualizza partizioni).
Per i percorsi partizionati di tipo Apache Hive nello stile `key=val`, i crawler popolano automaticamente il nome della colonna usando il nome della chiave. Altrimenti, utilizzano i nomi predefiniti, ad esempio `partition_0`, `partition_1` e così via. È possibile modificare i nomi predefiniti sulla console. A tale scopo, accedi alla tabella. Controlla se gli indici esistono nella scheda **Indici**. In tal caso, è necessario eliminarli per procedere; potrai ricrearli in seguito utilizzando i nuovi nomi di colonna. Quindi, scegli **Modifica schema** e modifica i nomi delle colonne delle partizioni.
Negli script ETL, puoi applicare un filtro alle colonne di partizione. Poiché le informazioni sulla partizione sono memorizzate nel catalogo dati, utilizza le chiamate API `from_catalog` per includere le colonne delle partizioni nel `DynamicFrame`. Ad esempio, utilizza `create_dynamic_frame.from_catalog` anziché `create_dynamic_frame.from_options`.
Il partizionamento è una tecnica di ottimizzazione che riduce la scansione dei dati. Per ulteriori informazioni sul processo di identificazione di quando questa tecnica è appropriata, consulta [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/reduce-data-scan.html) nella guida *Best practices for performance tuning AWS Glue for Apache Spark jobs* su AWS Prescriptive Guidance.
## Prefiltraggio con i predicati pushdown
In molti casi, puoi utilizzare un predicato pushdown per filtrare le partizioni senza dover elencare e leggere tutti i file del set di dati. Invece di leggere l'intero set di dati e quindi filtrarlo in un file DynamicFrame, puoi applicare il filtro direttamente sui metadati della partizione nel Data Catalog. Quindi elenchi e leggi solo ciò di cui hai effettivamente bisogno in un. DynamicFrame
Ad esempio, in Python puoi scrivere quanto segue.
```
glue_context.create_dynamic_frame.from_catalog(
database = "my_S3_data_set",
table_name = "catalog_data_table",
push_down_predicate = my_partition_predicate)
```
Questo crea un file DynamicFrame che carica solo le partizioni nel Data Catalog che soddisfano l'espressione del predicato. A seconda di quanto piccolo sia il sottoinsieme di dati che stai caricando, questo può far risparmiare moltissimo tempo nell'elaborazione.
L'espressione del predicato può essere qualsiasi espressione booleana supportata da Spark SQL. Funziona tutto ciò che puoi inserire in una clausola `WHERE` in una query Spark SQL. Ad esempio, l'espressione del predicato `pushDownPredicate = "(year=='2017' and month=='04')"` carica solo le partizioni in nel catalogo dati che hanno sia `year` uguale a 2017 che `month` uguale a 04. Per ulteriori informazioni, consulta la [documentazione di Apache Spark SQL](https://spark.apache.org/docs/2.1.1/sql-programming-guide.html), in particolare il [riferimento alle funzioni SQL Scala](https://spark.apache.org/docs/2.1.1/api/scala/index.html#org.apache.spark.sql.functions$).
## Filtraggio lato server utilizzando predicati delle partizioni di catalogo
L'opzione `push_down_predicate` viene applicata dopo aver elencato tutte le partizioni dal catalogo e prima di pubblicare i file da Amazon S3 per tali partizioni. Se per una tabella ci sono molte partizioni, l'elenco delle partizioni del catalogo può comunque essere soggetto a un sovraccarico di tempo aggiuntivo. Per ovviare a questo sovraccarico, puoi utilizzare il partizionamento lato server con l'`catalogPartitionPredicate`opzione che utilizza gli [indici di partizione](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) nel Glue Data Catalog. AWS Questo rende il filtraggio delle partizioni molto più veloce quando sono presenti milioni di partizioni in una tabella. Puoi utilizzare sia `push_down_predicate` che `catalogPartitionPredicate` insieme in `additional_options` se il `catalogPartitionPredicate` richiede sintassi del predicato che non è ancora supportata con gli indici delle partizioni del catalogo.
Python:
```
dynamic_frame = glueContext.create_dynamic_frame.from_catalog(
database=dbname,
table_name=tablename,
transformation_ctx="datasource0",
push_down_predicate="day>=10 and customer_id like '10%'",
additional_options={"catalogPartitionPredicate":"year='2021' and month='06'"}
)
```
Scala:
```
val dynamicFrame = glueContext.getCatalogSource(
database = dbname,
tableName = tablename,
transformationContext = "datasource0",
pushDownPredicate="day>=10 and customer_id like '10%'",
additionalOptions = JsonOptions("""{
"catalogPartitionPredicate": "year='2021' and month='06'"}""")
).getDynamicFrame()
```
**Nota**
`push_down_predicate` e `catalogPartitionPredicate` usano sintassi diverse. Il primo utilizza la sintassi standard Spark SQL e il secondo utilizza il parser JSQL.
## Scrittura delle partizioni
Per impostazione predefinita, a non è partizionato quando viene scritto DynamicFrame . Tutti i file di output vengono scritti nel livello principale del percorso di output specificato. Fino a poco tempo fa, l'unico modo per scrivere un file DynamicFrame nelle partizioni era convertirlo in un SQL Spark prima di scriverlo. DataFrame
Tuttavia, DynamicFrames ora supporta il partizionamento nativo utilizzando una sequenza di chiavi, utilizzando l'`partitionKeys`opzione quando si crea un sink. Ad esempio, il codice Python seguente scrive un set di dati in Amazon S3 in formato Parquet, in directory partizionate in base al campo type. Da qui puoi elaborare le partizioni usando altri sistemi, ad esempio Amazon Athena.
```
glue_context.write_dynamic_frame.from_options(
frame = projectedEvents,
connection_type = "s3",
connection_options = {"path": "$outpath", "partitionKeys": ["type"]},
format = "parquet")
```
# Lettura di file di input in gruppi di grandi dimensioni
Puoi impostare le proprietà delle tabelle per permettere a un processo ETL AWS Glue di raggruppare i file quando vengono letti da un datastore Amazon S3. Queste proprietà permettono a ogni attività ETL di leggere un gruppo di file di input in una singola partizione in memoria. Ciò è particolarmente utile quando è presente un numero elevato di file di piccole dimensioni nel datastore Amazon S3. Quando imposti determinate proprietà, indichi ad AWS Glue di raggruppare i file in una partizione dati Amazon S3 e di impostare la dimensione dei gruppi da leggere. Puoi anche impostare queste opzioni durante la lettura da un datastore Amazon S3 con il metodo `create_dynamic_frame.from_options`.
Per abilitare il raggruppamento di file in una tabella, devi impostare coppie di valore chiave nel campo parametri della struttura della tabella. Utilizza la notazione JSON per impostare un valore per il campo parametri della tabella. Per ulteriori informazioni sulle modifiche delle proprietà di una tabella, consulta [Visualizzazione e gestione dei dettagli della tabella](tables-described.md#console-tables-details).
Puoi usare questo metodo per abilitare il raggruppamento per le tabelle nel catalogo dati con i datastore Amazon S3.
**groupFiles**
Imposta **groupFiles** su `inPartition` per abilitare il raggruppamento dei file all'interno di una partizione dati Amazon S3. AWS Glue abilita automaticamente il raggruppamento se ci sono più di 50.000 file di input, come nel seguente esempio.
```
'groupFiles': 'inPartition'
```
**groupSize**
Imposta **groupSize** (Dimensione gruppo) alla dimensione target dei gruppi in byte. La proprietà **groupSize** è facoltativa e se non è presente AWS Glue calcola una dimensione per usare tutti i core della CPU nel cluster, riducendo comunque il numero complessivo di attività ETL e di partizioni in memoria.
Ad esempio, di seguito viene impostata la dimensione del gruppo su 1 MB.
```
'groupSize': '1048576'
```
È necessario impostare `groupsize` con il risultato di un calcolo. Ad esempio 1024 \$1 1024 = 1048576.
**recurse**
Imposta **recurse** su `True` per leggere in modo ricorsivo i file in tutte le sottodirectory quando si specifica `paths` come una matrice di percorsi. Non è necessario impostare **recurse** se `paths` è una matrice di chiavi di oggetti in Amazon S3 o se il formato di input è parquet/orc, come nell'esempio seguente.
```
'recurse':True
```
Se leggi da Amazon S3 utilizzando direttamente il metodo `create_dynamic_frame.from_options`, aggiungi queste opzioni di connessione. Ad esempio, i seguenti tentativi di raggruppare file in gruppi da 1 MB.
```
df = glueContext.create_dynamic_frame.from_options("s3", {'paths': ["s3://s3path/"], 'recurse':True, 'groupFiles': 'inPartition', 'groupSize': '1048576'}, format="json")
```
**Nota**
`groupFiles`è supportato se DynamicFrames creato dai seguenti formati di dati: csv, ion, GrokLog, json e xml. Questa opzione non è supportata per avro, parquet e orc.
# Endpoint Amazon VPC per Amazon S3
Per motivi di sicurezza, molti AWS clienti eseguono le proprie applicazioni all'interno di un ambiente Amazon Virtual Private Cloud (Amazon VPC). Con Amazon VPC, puoi avviare EC2 istanze Amazon in un cloud privato virtuale, logicamente isolato da altre reti, inclusa la rete Internet pubblica. Con un Amazon VPC, puoi controllarne l'intervallo di indirizzi IP, le sottoreti, le tabelle di routing e i gateway di rete, nonché le impostazioni di sicurezza.
**Nota**
Se hai creato il tuo AWS account dopo il 04/12/2013, hai già un VPC predefinito in ogni regione. AWS Puoi iniziare a utilizzare il tuo VPC predefinito subito, senza ulteriori configurazioni.
Per ulteriori informazioni, consulta [VPC e sottoreti predefiniti](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) nella Guida per l'utente di Amazon VPC.
Molti clienti esprimono legittime preoccupazioni in materia di sicurezza e di privacy quando si tratta di inviare e ricevere dati tramite la rete Internet pubblica. I clienti possono risolvere questi problemi usando una rete privata virtuale (VPN) per instradare tutto il traffico di rete Amazon S3 tramite la propria infrastruttura di rete aziendale. Questo approccio tuttavia può introdurre problematiche relative alla larghezza di banda e alla disponibilità.
Gli endpoint VPC per Amazon S3 possono mitigare queste difficoltà. Un endpoint VPC per Amazon S3 permette a AWS Glue di usare indirizzi IP privati per accedere ad Amazon S3 senza esposizione nella rete Internet pubblica. AWS Glue non richiede indirizzi IP pubblici e non è necessario disporre di un gateway Internet, un dispositivo NAT o un gateway virtuale privato all'interno del VPC. Puoi utilizzare policy endpoint per controllare l'accesso ad Amazon S3. Il traffico tra il tuo VPC e il AWS servizio non esce dalla rete Amazon.
Quando crei un endpoint VPC per Amazon S3, qualsiasi richiesta a un endpoint Amazon S3 all'interno della regione (ad esempio *s3.us-west-2.amazonaws.com*) viene instradata verso un endpoint Amazon S3 privato all'interno della rete Amazon. Non è necessario modificare le applicazioni in esecuzione su EC2 istanze Amazon nel tuo VPC: il nome dell'endpoint rimane lo stesso, ma il percorso verso Amazon S3 rimane interamente all'interno della rete Amazon e non accede alla rete Internet pubblica.
Per ulteriori informazioni sugli endpoint VPC, consulta [Endpoint VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) nella Guida per l'utente di Amazon VPC.
Il diagramma seguente mostra in che modo AWS Glue può usare un endpoint VPC per accedere ad Amazon S3.
![\[Flusso del traffico di rete che mostra la connessione VPC ad Amazon S3.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/PopulateCatalog-vpc-endpoint.png)
**Per configurare l'accesso ad Amazon S3**
1. Accedi Console di gestione AWS e apri la console Amazon VPC all'indirizzo. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. Nel riquadro di navigazione a sinistra, scegli **Endpoints** (Endpoint).
1. Scegli **Create Endpoint (Crea endpoint)** e segui la procedura per creare un endpoint VPC Amazon S3 di tipo Gateway.
# Connessioni ad Amazon DocumentDB
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in Amazon DocumentDB. Puoi connetterti ad Amazon DocumentDB utilizzando le credenziali archiviate tramite Gestione dei segreti AWS una connessione AWS Glue.
Per ulteriori informazioni su Amazon DocumentDB, consulta la [documentazione di Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/what-is.html).
**Nota**
I cluster elastici di Amazon DocumentDB non sono attualmente supportati quando si utilizza il connettore AWS Glue. Per ulteriori informazioni sui cluster elastici, consulta la pagina [Using Amazon DocumentDB elastic clusters](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html).
## Lettura e scrittura nelle raccolte Amazon DocumentDB
**Nota**
Quando crei un processo ETL a cui si connette Amazon DocumentDB, per la proprietà del processo `Connections`, devi designare un oggetto connessione che specifica il cloud privato virtuale (VPC) in cui Amazon DocumentDB è in esecuzione. Per l'oggetto connessione, il tipo di connessione deve essere `JDBC`, e `JDBC URL` deve essere `mongo://:27017`.
**Nota**
Questi esempi di codice sono stati sviluppati per AWS Glue 3.0. Per migrare a AWS Glue 4.0, consulta[MongoDB](migrating-version-40.md#migrating-version-40-connector-driver-migration-mongodb). Il parametro `uri` è cambiato.
**Nota**
Quando si utilizza Amazon DocumentDB, `retryWrites` deve essere impostato su false in determinate situazioni, ad esempio quando il documento scritto specifica `_id`. Per ulteriori informazioni, consulta [Differenze funzionali con MongoDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/functional-differences.html#functional-differences.retryable-writes) nella documentazione di Amazon DocumentDB.
Il seguente script Python dimostra l'utilizzo di tipi e opzioni di connessione per la lettura e la scrittura su Amazon DocumentDB.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
documentdb_uri = "mongodb://:27017"
documentdb_write_uri = "mongodb://:27017"
read_docdb_options = {
"uri": documentdb_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "1234567890",
"ssl": "true",
"ssl.domain_match": "false",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"
}
write_documentdb_options = {
"retryWrites": "false",
"uri": documentdb_write_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "pwd"
}
# Get DynamicFrame from DocumentDB
dynamic_frame2 = glueContext.create_dynamic_frame.from_options(connection_type="documentdb",
connection_options=read_docdb_options)
# Write DynamicFrame to MongoDB and DocumentDB
glueContext.write_dynamic_frame.from_options(dynamic_frame2, connection_type="documentdb",
connection_options=write_documentdb_options)
job.commit()
```
Il seguente script Scala dimostra l'utilizzo di tipi e opzioni di connessione per la lettura e la scrittura su Amazon DocumentDB.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DOC_URI: String = "mongodb://:27017"
val DOC_WRITE_URI: String = "mongodb://:27017"
lazy val documentDBJsonOption = jsonOptions(DOC_URI)
lazy val writeDocumentDBJsonOption = jsonOptions(DOC_WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from DocumentDB
val resultFrame2: DynamicFrame = glueContext.getSource("documentdb", documentDBJsonOption).getDynamicFrame()
// Write DynamicFrame to DocumentDB
glueContext.getSink("documentdb", writeJsonOption).writeDynamicFrame(resultFrame2)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"test",
|"collection":"coll",
|"username": "username",
|"password": "pwd",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
## Indicazioni di riferimento alle opzioni di connessione ad Amazon DocumentDB
Indica una connessione ad Amazon DocumentDB (con compatibilità MongoDB).
Le opzioni di connessione differiscono per una connessione sorgente e una connessione sink.
### "connectionType": "documentdb" come sorgente
Utilizzare le seguenti opzioni di connessione con `"connectionType": "documentdb"` come origine:
+ `"uri"`: (obbligatorio) l'host Amazon DocumentDB da cui leggere, formattato come `mongodb://:`.
+ `"database"`: (Obbligatorio) il database di Amazon DocumentDB da cui leggere.
+ `"collection"`: (Obbligatorio) la raccolta di Amazon DocumentDB da cui leggere.
+ `"username"`: (Obbligatorio) il nome utente di Amazon DocumentDB.
+ `"password"`: (Obbligatorio) la password di Amazon DocumentDB.
+ `"ssl"`: (Obbligatorio se si utilizza SSL) se la connessione utilizza SSL, è necessario includere questa opzione con il valore `"true"`.
+ `"ssl.domain_match"`: (Obbligatorio se si utilizza SSL) se la connessione utilizza SSL, è necessario includere questa opzione con il valore `"false"`.
+ `"batchSize"`: (Facoltativo): il numero di documenti da restituire per ogni batch, utilizzato all'interno del cursore dei batch interni.
+ `"partitioner"`: (Facoltativo): il nome della classe del partizionatore per la lettura dei dati di input da Amazon DocumentDB. Il connettore fornisce i seguenti partizionatori:
+ `MongoDefaultPartitioner`(impostazione predefinita) (non supportato in AWS Glue 4.0)
+ `MongoSamplePartitioner`(Non supportato in AWS Glue 4.0)
+ `MongoShardedPartitioner`
+ `MongoSplitVectorPartitioner`
+ `MongoPaginateByCountPartitioner`
+ `MongoPaginateBySizePartitioner`(Non supportato in AWS Glue 4.0)
+ `"partitionerOptions"` ( Facoltativo): opzioni per il partizionatore designato. Per ogni partizionatore sono supportate le seguenti opzioni:
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner`: `partitionKey`, partitionSizeMB
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner`: `partitionKey`, partitionSizeMB
Per ulteriori informazioni su queste opzioni, vedere [Partitioner Configuration (Configurazione partizionatore)](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) nella documentazione di MongoDB.
### "connectionType": "documentdb" come sink
Utilizzare le seguenti opzioni di connessione con `"connectionType": "documentdb"` come sink:
+ `"uri"`: (Obbligatorio) l'host Amazon DocumentDB su cui scrivere, formattato come `mongodb://:`.
+ `"database"`: (Obbligatorio) il database di Amazon DocumentDB su cui scrivere.
+ `"collection"`: (Obbligatorio) la raccolta di Amazon DocumentDB su cui scrivere.
+ `"username"`: (Obbligatorio) il nome utente di Amazon DocumentDB.
+ `"password"`: (Obbligatorio) la password di Amazon DocumentDB.
+ `"extendedBsonTypes"`: (Facoltativo) se il valore è `true`, abilita i tipi BSON estesi durante la scrittura dei dati su Amazon DocumentDB. Il valore predefinito è `true`.
+ `"replaceDocument"`: (Facoltativo) Se il valore è `true`, sostituisce l'intero documento quando si salvano set di dati che contengono un campo `_id`. Se il valore è `false`, vengono aggiornati solo i campi del documento che corrispondono ai campi del set di dati. Il valore predefinito è `true`.
+ `"maxBatchSize"`: (Facoltativo): la dimensione massima del batch per le operazioni in blocco durante il salvataggio dei dati. Il valore predefinito è 512.
+ `"retryWrites"`: (Facoltativo): Riprova automaticamente alcune operazioni di scrittura una sola volta se AWS Glue rileva un errore di rete.
# OpenSearch Connessioni di servizio
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in OpenSearch Service in AWS Glue 4.0 e versioni successive. Puoi definire cosa leggere dal OpenSearch Servizio con una OpenSearch query. Ti connetti al OpenSearch servizio utilizzando le credenziali di autenticazione di base HTTP archiviate Gestione dei segreti AWS tramite una connessione AWS Glue. Questa funzionalità non è compatibile con OpenSearch Service serverless.
Per ulteriori informazioni su Amazon OpenSearch Service, consulta la [documentazione OpenSearch di Amazon Service](https://docs.aws.amazon.com/opensearch-service/).
## Configurazione delle connessioni OpenSearch al servizio
Per connetterti a OpenSearch Service da AWS Glue, dovrai creare e archiviare le tue credenziali OpenSearch Service in modo Gestione dei segreti AWS segreto, quindi associare quel segreto a una connessione OpenSearch Service AWS Glue.
**Prerequisiti:**
+ Identifica l'endpoint *aosEndpoint* e la porta del dominio da *aosPort* cui desideri leggere o crea la risorsa seguendo le istruzioni nella documentazione di Amazon OpenSearch Service. Per ulteriori informazioni sulla creazione di un dominio, consulta [Creazione e gestione di domini Amazon OpenSearch Service](https://docs.aws.amazon.com//opensearch-service/latest/developerguide/createupdatedomains.html) nella documentazione di Amazon OpenSearch Service.
Un endpoint OpenSearch di dominio Amazon Service avrà il seguente modulo predefinito, https://search - *domainName* -*unstructuredIdContent*. *region*.es.amazonaws.com. Per ulteriori informazioni sull'identificazione dell'endpoint del tuo dominio, consulta [Creazione e gestione dei domini Amazon OpenSearch Service](https://docs.aws.amazon.com//opensearch-service/latest/developerguide/createupdatedomains.html) nella documentazione di Amazon OpenSearch Service.
Identifica o genera credenziali di autenticazione HTTP di base *aosUser* e *aosPassword* per il tuo dominio.
**Per configurare una connessione al OpenSearch servizio:**
1. In Gestione dei segreti AWS, crea un segreto utilizzando le tue credenziali OpenSearch di servizio. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `USERNAME` con il valore. *aosUser*
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `PASSWORD` con il valore. *aosPassword*
1. Nella console AWS Glue, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione*connectionName*, per utilizzi futuri in AWS Glue.
+ Quando selezioni un **tipo di connessione**, seleziona OpenSearch Servizio.
+ Quando selezioni un endpoint di dominio, fornisci*aosEndpoint*.
+ Quando selezioni una porta, fornisci*aosPort*.
+ Quando selezioni un **AWS segreto**, fornisci*secretName*.
Dopo aver creato una connessione OpenSearch al servizio AWS Glue, dovrai eseguire i seguenti passaggi prima di eseguire il lavoro AWS Glue:
+ Concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*.
+ Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
## Lettura dagli indici OpenSearch dei servizi
**Prerequisiti:**
+ Un indice dei OpenSearch servizi da cui desideri leggere,*aosIndex*.
+ Una connessione AWS Glue OpenSearch Service configurata per fornire informazioni di autenticazione e posizione di rete. Per acquisirla, completa i passaggi della procedura precedente, *Per configurare una connessione al OpenSearch servizio*. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Questo esempio legge un indice da Amazon OpenSearch Service. Dovrai fornire il parametro `pushdown`.
Esempio:
```
opensearch_read = glueContext.create_dynamic_frame.from_options(
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
"pushdown": "true",
}
)
```
Puoi anche fornire una stringa di query per filtrare i risultati restituiti nel tuo DynamicFrame. Sarà necessario configurare `opensearch.query`.
`opensearch.query`può accettare una stringa di parametri di query URL *queryString* o un oggetto JSON DSL di query. *queryObject* Per ulteriori informazioni sulla query DSL, vedere [Query DSL](https://opensearch.org/docs/latest/query-dsl/index/) nella documentazione. OpenSearch Per fornire una stringa di parametri di query URL, anteponi `?q=` alla query, come faresti con un URL completo. Per fornire un oggetto di query DSL, la stringa evita l'oggetto JSON prima di fornirlo.
Esempio:
```
queryObject = "{ "query": { "multi_match": { "query": "Sample", "fields": [ "sample" ] } } }"
queryString = "?q=queryString"
opensearch_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
"opensearch.query": queryString,
"pushdown": "true",
}
)
```
Per ulteriori informazioni su come creare una query al di fuori della relativa sintassi specifica, vedi Sintassi della [stringa di query nella documentazione](https://opensearch.org/docs/latest/query-dsl/full-text/query-string/#query-string-syntax). OpenSearch
Quando si leggono da OpenSearch raccolte che contengono dati di tipo array, è necessario specificare quali campi sono di tipo array nella chiamata al metodo utilizzando il `opensearch.read.field.as.array.include` parametro.
Ad esempio, durante la lettura del documento seguente incontrerai i campi di array `genre` e `actor`:
```
{
"_index": "movies",
"_id": "2",
"_version": 1,
"_seq_no": 0,
"_primary_term": 1,
"found": true,
"_source": {
"director": "Frankenheimer, John",
"genre": [
"Drama",
"Mystery",
"Thriller",
"Crime"
],
"year": 1962,
"actor": [
"Lansbury, Angela",
"Sinatra, Frank",
"Leigh, Janet",
"Harvey, Laurence",
"Silva, Henry",
"Frees, Paul",
"Gregory, James",
"Bissell, Whit",
"McGiver, John",
"Parrish, Leslie",
"Edwards, James",
"Flowers, Bess",
"Dhiegh, Khigh",
"Payne, Julie",
"Kleeb, Helen",
"Gray, Joe",
"Nalder, Reggie",
"Stevens, Bert",
"Masters, Michael",
"Lowell, Tom"
],
"title": "The Manchurian Candidate"
}
}
```
In questo caso, dovrai includere i nomi dei campi in questione nella chiamata al metodo. Esempio:
```
"opensearch.read.field.as.array.include": "genre,actor"
```
Se il campo dell'array è annidato all'interno della struttura del documento, fai riferimento a esso utilizzando la notazione a punti: `"genre,actor,foo.bar.baz"`. Ciò specificherebbe un array `baz` incluso nel documento di origine tramite il documento incorporato `foo` contenente il documento incorporato `bar`.
## Scrittura nelle tabelle OpenSearch dei servizi
Questo esempio scrive informazioni da un servizio esistente DynamicFrame *dynamicFrame* a OpenSearch Service. Se l'indice contiene già informazioni, AWS Glue aggiungerà i dati dal tuo DynamicFrame. Dovrai fornire il parametro `pushdown`.
**Prerequisiti:**
+ Una tabella dei OpenSearch servizi su cui scrivere. Avrai bisogno delle informazioni di identificazione per la tabella. Chiamiamo questo*tableName*.
+ Una connessione AWS Glue OpenSearch Service configurata per fornire informazioni di autenticazione e posizione di rete. Per acquisirla, completa i passaggi della procedura precedente, *Per configurare una connessione al OpenSearch servizio*. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
},
)
```
## OpenSearch Riferimento all'opzione di connessione al servizio
+ `connectionName`: obbligatorio. Utilizzato per la lettura/scrittura. Il nome di una connessione al AWS Glue OpenSearch Service configurata per fornire informazioni di autenticazione e posizione di rete al metodo di connessione utilizzato.
+ `opensearch.resource`: obbligatorio. Utilizzato per la lettura/scrittura. Valori validi: nomi degli OpenSearch indici. Il nome dell'indice con cui interagirà il metodo di connessione.
+ `opensearch.query`: utilizzato per la lettura. Valori validi: stringa con escape JSON o, quando inizia con `?`, la parte di ricerca di un URL. Una OpenSearch query che filtra ciò che deve essere recuperato durante la lettura. Per ulteriori informazioni sull'utilizzo di questo parametro, consulta la sezione precedente [Lettura dagli indici OpenSearch dei servizi](#aws-glue-programming-etl-connect-opensearch-read).
+ `pushdown` — Richiesto se. Utilizzato per la lettura. Valori validi: booleani. Indica a Spark di passare le query di lettura in OpenSearch modo che il database restituisca solo i documenti pertinenti.
+ `opensearch.read.field.as.array.include`: richiesto se si leggono dati di tipo array. Utilizzato per la lettura. Valori validi: elenchi di nomi di campi separati da virgole. Specifica i campi da leggere come matrici dai documenti. OpenSearch Per ulteriori informazioni sull'utilizzo di questo parametro, consulta la sezione precedente [Lettura dagli indici OpenSearch dei servizi](#aws-glue-programming-etl-connect-opensearch-read).
# Connessioni Redshift
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle nei database Amazon Redshift. Quando si connette ai database Amazon Redshift, AWS Glue sposta i dati tramite Amazon S3 per ottenere il massimo throughput, utilizzando SQL e comandi Amazon Redshift. `COPY` `UNLOAD` In AWS Glue 4.0 e versioni successive, puoi utilizzare l'[integrazione Amazon Redshift per Apache Spark per](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) leggere e scrivere con ottimizzazioni e funzionalità specifiche di Amazon Redshift oltre a quelle disponibili durante la connessione tramite versioni precedenti.
Scopri come AWS Glue sta semplificando più che mai per gli utenti di Amazon Redshift la migrazione a AWS Glue per l'integrazione dei dati senza server e l'ETL.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/ZapycBq8TKU)
## Configurazione delle connessioni Redshift
Per utilizzare i cluster Amazon Redshift in AWS Glue, sono necessari alcuni prerequisiti:
+ Una directory Amazon S3 da utilizzare per l'archiviazione temporanea durante la lettura e la scrittura sul database.
+ Un Amazon VPC che consente la comunicazione tra il cluster Amazon Redshift, il job AWS Glue e la directory Amazon S3.
+ Autorizzazioni IAM appropriate sul job AWS Glue e sul cluster Amazon Redshift.
### Configurazione dei ruoli IAM
**Configurazione del ruolo per il cluster Amazon Redshift**
Il tuo cluster Amazon Redshift deve essere in grado di leggere e scrivere su Amazon S3 per integrarsi con AWS Glue jobs. Per consentire ciò, puoi associare i ruoli IAM al cluster Amazon Redshift a cui desideri connetterti. Il tuo ruolo dovrebbe disporre di una policy che consenta la lettura e la scrittura nella tua directory temporanea di Amazon S3. Il tuo ruolo dovrebbe avere un rapporto di fiducia che consenta al servizio `redshift.amazonaws.com` di `AssumeRole`.
**Associazione di un ruolo IAM ad Amazon Redshift**
1. **Prerequisiti:** un bucket o una directory Amazon S3 utilizzato per l'archiviazione temporanea dei file.
1. Identifica le autorizzazioni Amazon S3 che occorreranno al cluster Amazon Redshift. Quando spostano dati da e verso un cluster Amazon Redshift, i job AWS Glue emettono istruzioni COPY e UNLOAD su Amazon Redshift. Se il tuo job modifica una tabella in Amazon Redshift, AWS Glue emetterà anche istruzioni CREATE LIBRARY. Per informazioni sulle autorizzazioni specifiche di Amazon S3 necessarie ad Amazon Redshift per eseguire queste istruzioni, consulta la documentazione di Amazon Redshift: Amazon Redshift: Permissions to access other [Resources](https://docs.aws.amazon.com/redshift/latest/dg/copy-usage_notes-access-permissions.html). AWS
1. Nella console IAM, crea una policy IAM con le autorizzazioni necessarie. Per ulteriori informazioni sulla creazione di una policy, consulta la pagina [Creazione di policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
1. Da IAM, crea un ruolo e un rapporto di fiducia che consenta ad Amazon Redshift di assumere il ruolo. Segui le istruzioni nella documentazione IAM [Per creare un ruolo per un servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console) (console) AWS
+ Quando ti viene chiesto di scegliere un caso d'uso del AWS servizio, scegli «Redshift - Personalizzabile».
+ Quando ti viene chiesto di collegare una policy, scegli la policy che hai definito in precedenza.
**Nota**
Per ulteriori informazioni sulla configurazione dei ruoli per Amazon Redshift, [consulta Autorizzazione di Amazon Redshift ad AWS accedere ad altri servizi per tuo conto nella documentazione di Amazon](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) Redshift.
1. Da Amazon Redshift, associa il ruolo al tuo cluster Amazon Redshift. Segui le istruzioni nella [documentazione di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html).
Seleziona l'opzione evidenziata nella console Amazon Redshift per configurare questa impostazione:
![\[Un esempio di dove gestire le autorizzazioni IAM nella console Amazon Redshift.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/RS-role-config.png)
**Nota**
Per impostazione predefinita, i lavori AWS Glue passano le credenziali temporanee di Amazon Redshift create utilizzando il ruolo specificato per eseguire il lavoro. Non è consigliabile utilizzare queste credenziali. Per motivi di sicurezza, queste credenziali scadono dopo 1 ora.
**Imposta il ruolo per il lavoro AWS Glue**
Il job AWS Glue richiede un ruolo per accedere al bucket Amazon S3. Non sono necessarie le autorizzazioni IAM per il cluster Amazon Redshift, il tuo accesso è controllato dalla connettività in Amazon VPC e dalle credenziali del database.
### Configurazione di Amazon VPC
**Per configurare l'accesso ai datastore Amazon Redshift**
1. Accedi Console di gestione AWS e apri la console Amazon Redshift all'indirizzo. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)
1. Nel pannello di navigazione a sinistra, seleziona **Cluster**.
1. Seleziona il nome del cluster al quale desideri accedere da AWS Glue.
1. Nella sezione **Proprietà cluster** scegli un gruppo di sicurezza in **Gruppi di sicurezza VPC** per permettere l'uso a AWS Glue. Registra il nome del gruppo di sicurezza scelto per riferimenti futuri. La scelta del gruppo di sicurezza apre l'elenco **Gruppi di sicurezza** della console Amazon EC2.
1. Scegli il gruppo di sicurezza da modificare e passa alla scheda **In entrata**.
1. Aggiungi una regola autoreferenziale per permettere ai componenti di AWS Glue di comunicare tra loro. In particolare, aggiungi o verifica che sia presente una regola con **Tipo** `All TCP`, **Protocollo** `TCP`, **Intervallo porte** che include tutte le porte e **Origine** corrispondente al nome del gruppo di sicurezza indicato da **ID gruppo**.
La regola in entrata è simile alla seguente:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Esempio:
![\[Esempio di regola autoreferenziale per il traffico in entrata.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/SetupSecurityGroup-Start.png)
1. Aggiungi una regola anche per il traffico in uscita. Quindi, apri il traffico in uscita per tutte le porte, ad esempio:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
In alternativa, crea una regola autoreferenziale in cui **Tipo** `All TCP`, **Protocollo** sta per `TCP` e **Intervallo porte** include tutte le porte, la cui **Destinazione** ha lo stesso nome del gruppo di sicurezza dell'**ID gruppo**. Se usi un endpoint VPC Amazon S3, aggiungi anche una regola HTTPS per l'accesso di Amazon S3. *s3-prefix-list-id*È necessario nella regola del gruppo di sicurezza per consentire il traffico dal VPC all'endpoint VPC Amazon S3.
Esempio:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
### Configura AWS Glue
Dovrai creare una connessione AWS Glue Data Catalog che fornisca informazioni sulla connessione Amazon VPC.
**Per configurare la connettività Amazon Redshift (Amazon VPC) a AWS Glue nella console:**
1. Crea una connessione a Catalogo dati seguendo i passaggi indicati nella sezione [Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione per *connectionName* il passaggio successivo.
+ Quando selezioni un **Tipo di connessione**, seleziona **Amazon Redshift**.
+ Quando selezioni un **Cluster Redshift**, seleziona il tuo cluster in base al nome.
+ Fornisci informazioni di connessione predefinite per un utente Amazon Redshift sul tuo cluster.
+ Le impostazioni di Amazon VPC verranno configurate automaticamente.
**Nota**
Quando crei una connessione **Amazon Redshift** tramite l'SDK AWS , dovrai fornire manualmente il valore `PhysicalConnectionRequirements` per il tuo Amazon VPC.
1. Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
## Esempio: lettura da tabelle Amazon Redshift
È possibile leggere da cluster Amazon Redshift e ambienti Amazon Redshift serverless.
**Prerequisiti:** una tabella Amazon Redshift da cui desideri leggere. Segui i passaggi della sezione precedente, [Configurazione delle connessioni Redshift](#aws-glue-programming-etl-connect-redshift-configure) dopodiché dovresti avere l'URI Amazon S3 per una directory temporanea *temp-s3-dir* e un ruolo IAM,*rs-role-name*, (nell'account*role-account-id*).
------
#### [ Using the Data Catalog ]
**Prerequisiti aggiuntivi**: un database Catalogo dati e una tabella dai quali desideri che la tabella Amazon Redshift legga. Per ulteriori informazioni su Catalogo dati, consultare la pagina [Scoperta e catalogazione dei dati in AWS Glue](catalog-and-crawler.md). Dopo aver creato una voce per la tabella Amazon Redshift, identificherai la tua connessione con un *redshift-dc-database-name* segno e. *redshift-table-name*
**Configurazione:** nelle opzioni della funzione identificherai la tabella di Catalogo dati con i parametri `database` e `table_name`. Identificherai la directory temporanea Amazon S3 con `redshift_tmp_dir`. Dovrai inoltre fornire *rs-role-name* l'utilizzo della `aws_iam_role` chiave nel `additional_options` parametro.
```
glueContext.create_dynamic_frame.from_catalog(
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"})
```
------
#### [ Connecting directly ]
**Prerequisiti aggiuntivi:** è necessario il nome della tabella Amazon Redshift (. *redshift-table-name* Avrai bisogno delle informazioni di connessione JDBC per il cluster Amazon Redshift in cui è archiviata quella tabella. Fornirai le informazioni di connessione con*host*, *port**redshift-database-name*, *username* e. *password*
Quando lavori con i cluster Amazon Redshift, puoi recuperare le informazioni di connessione dalla console Amazon Redshift. Se utilizzi Amazon Redshift serverless, consulta la sezione [Connecting to Amazon Redshift Serverless](https://docs.aws.amazon.com//redshift/latest/mgmt/serverless-connecting.html) nella documentazione di Amazon Redshift.
**Configurazione:** nelle opzioni della funzione identificherai i parametri di connessione con `url`, `dbtable`, `user` e `password`. Identificherai la tua directory temporanea Amazon S3 con `redshift_tmp_dir`. Quando utilizzi `from_options`, puoi specificare il tuo ruolo IAM utilizzando `aws_iam_role`. La sintassi è simile alla connessione tramite Catalogo dati, ma è necessario inserire i parametri nella mappa `connection_options`.
È una cattiva pratica codificare le password negli script AWS Glue. Valuta la possibilità di archiviare le password Gestione dei segreti AWS e recuperarle nello script con SDK for Python (Boto3).
```
my_conn_options = {
"url": "jdbc:redshift://host:port/redshift-database-name",
"dbtable": "redshift-table-name",
"user": "username",
"password": "password",
"redshiftTmpDir": args["temp-s3-dir"],
"aws_iam_role": "arn:aws:iam::account id:role/rs-role-name"
}
df = glueContext.create_dynamic_frame.from_options("redshift", my_conn_options)
```
------
## Esempio: scrittura su tabelle Amazon Redshift
È possibile scrivere su cluster Amazon Redshift e ambienti Amazon Redshift serverless.
**Prerequisiti:** un cluster Amazon Redshift e segui i passaggi della [Configurazione delle connessioni Redshift](#aws-glue-programming-etl-connect-redshift-configure) sezione precedente, dopodiché dovresti avere l'URI Amazon S3 per una directory temporanea e un ruolo *rs-role-name* IAM*temp-s3-dir*,, (nell'account). *role-account-id* Avrai anche bisogno di un `DynamicFrame` del quale desideri scrivere il contenuto nel database.
------
#### [ Using the Data Catalog ]
**Prerequisiti aggiuntivi**: un database Catalogo dati sul quale desideri che scrivano il cluster e la tabella Amazon Redshift. Per ulteriori informazioni su Catalogo dati, consulta la pagina [Scoperta e catalogazione dei dati in AWS Glue](catalog-and-crawler.md). Identificherai la tua connessione con *redshift-dc-database-name* e la tabella di destinazione con. *redshift-table-name*
**Configurazione:** nelle opzioni della funzione identificherai il database di Catalogo dati con il parametro `database`, quindi fornirai la tabella con `table_name`. Identificherai la tua directory temporanea Amazon S3 con `redshift_tmp_dir`. Fornirai anche *rs-role-name* l'utilizzo della `aws_iam_role` chiave nel `additional_options` parametro.
```
glueContext.write_dynamic_frame.from_catalog(
frame = input dynamic frame,
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::account-id:role/rs-role-name"})
```
------
#### [ Connecting through a AWS Glue connection ]
È possibile connettersi ad Amazon Redshift direttamente utilizzando il metodo `write_dynamic_frame.from_options`. Tuttavia, anziché inserire i dettagli di connessione direttamente nello script, puoi fare riferimento ai dettagli di connessione archiviati in una connessione a Catalogo dati con il metodo `from_jdbc_conf`. È possibile eseguire questa operazione senza effettuare il crawling o creare tabelle di Catalogo dati per il database. Per ulteriori informazioni sulle connessioni a Catalogo dati, consulta la pagina [Connessione ai dati](glue-connections.md).
**Prerequisiti aggiuntivi:** una connessione a Catalogo dati per il database, una tabella Amazon Redshift da cui desideri leggere
**Configurazione:** identificherai la tua connessione al Data Catalog con*dc-connection-name*. Identificherai il database e la tabella Amazon Redshift con *redshift-table-name* e. *redshift-database-name* Fornirai le informazioni di connessione a Catalogo dati con `catalog_connection` e le informazioni relative ad Amazon Redshift con `dbtable` e `database`. La sintassi è simile alla connessione tramite Catalogo dati, ma è necessario inserire i parametri nella mappa `connection_options`.
```
my_conn_options = {
"dbtable": "redshift-table-name",
"database": "redshift-database-name",
"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"
}
glueContext.write_dynamic_frame.from_jdbc_conf(
frame = input dynamic frame,
catalog_connection = "dc-connection-name",
connection_options = my_conn_options,
redshift_tmp_dir = args["temp-s3-dir"])
```
------
## Indicazioni di riferimento alle opzione di connessione ad Amazon Redshift
Le opzioni di connessione di base utilizzate per tutte le connessioni JDBC AWS Glue per configurare informazioni come `url` `user` e `password` sono coerenti per tutti i tipi JDBC. Per ulteriori informazioni sui parametri JDBC standard, consulta la pagina [Indicazioni di riferimento alle opzioni di connessione a JDBC](aws-glue-programming-etl-connect-jdbc-home.md#aws-glue-programming-etl-connect-jdbc).
Il tipo di connessione Amazon Redshift richiede alcune opzioni di connessione aggiuntive:
+ `"redshiftTmpDir"`: (obbligatorio) il percorso Amazon S3 in cui i dati temporanei possono essere caricati durante la copia dal database.
+ `"aws_iam_role"`: (facoltativo) l'ARN di un ruolo IAM. Il job AWS Glue passerà questo ruolo al cluster Amazon Redshift per concedere al cluster le autorizzazioni necessarie per completare le istruzioni del job.
### Opzioni di connessione aggiuntive disponibili in AWS Glue 4.0\$1
Puoi anche passare le opzioni per il nuovo connettore Amazon Redshift tramite le opzioni di connessione AWS Glue. Per un elenco completo delle opzioni di connettori supportate, consulta la sezione *Parametri SQL Spark* in [Integrazione di Amazon Redshift per Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html).
Per comodità, ribadiamo di seguito alcune nuove opzioni:
| Name | Obbligatorio | Predefinita | Description |
| --- | --- | --- | --- |
| autopushdown | No | TRUE | Applica il pushdown di predicati e query acquisendo e analizzando i piani logici di Spark per le operazioni SQL. Le operazioni vengono tradotte in una query SQL e quindi eseguite in Amazon Redshift per migliorare le prestazioni. |
| autopushdown.s3\$1result\$1cache | No | FALSE | Memorizza nella cache la query SQL per scaricare i dati sulla mappatura dei percorsi di Amazon S3 in memoria, in modo che la stessa query non debba essere eseguita nuovamente nella stessa sessione di Spark. Supportato solo quando `autopushdown` è abilitato. |
| unload\$1s3\$1format | No | PARQUET | PARQUET: scarica i risultati della query in formato Parquet. TESTO: scarica i risultati della query in formato testo delimitato da barra verticale. |
| sse\$1kms\$1key | No | N/D | La chiave AWS SSE-KMS da utilizzare per la crittografia durante `UNLOAD` le operazioni anziché la crittografia predefinita per. AWS |
| extracopyoptions | No | N/D | Un elenco di opzioni ulteriori da aggiungere al comando `COPY` di Amazon Redshift durante il caricamento dei dati, come `TRUNCATECOLUMNS` o `MAXERROR n` (per altre opzioni, consulta [COPY: parametri facoltativi](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax-overview-optional-parameters)). È importante notare che, poiché queste opzioni vengono aggiunte alla fine del comando `COPY`, è possibile utilizzare solo le opzioni rilevanti alla fine del comando. Questo dovrebbe coprire la maggior parte dei casi d'uso possibili. |
| cvsnullstring (sperimentale) | No | NULL | Il valore di stringa da scrivere per i valori null quando si utilizza il `tempformat` CSV. Dovrebbe trattarsi di un valore che non è presente nei dati effettivi. |
Questi nuovi parametri possono essere utilizzati nei seguenti modi.
**Nuove opzioni per il miglioramento delle prestazioni**
Il nuovo connettore introduce alcune nuove opzioni di miglioramento delle prestazioni:
+ `autopushdown`: abilitato per impostazione predefinita.
+ `autopushdown.s3_result_cache`: disabilitato per impostazione predefinita.
+ `unload_s3_format`: `PARQUET` per impostazione predefinita.
Per informazioni sull'utilizzo di queste opzioni, consultare [Integrazione di Amazon Redshift per Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Si consiglia di non attivare ` autopushdown.s3_result_cache` quando si eseguono operazioni di lettura e scrittura miste perché i risultati memorizzati nella cache potrebbero contenere informazioni obsolete. L'opzione `unload_s3_format` è impostata su `PARQUET` per impostazione predefinita per il comando `UNLOAD` per migliorare le prestazioni e ridurre i costi di archiviazione. Per utilizzare il comportamento predefinito del comando `UNLOAD`, reimposta l'opzione su `TEXT`.
**Nuova opzione di crittografia per la lettura**
Per impostazione predefinita, i dati nella cartella temporanea utilizzata da AWS Glue durante la lettura dei dati dalla tabella Amazon Redshift vengono crittografati tramite la crittografia `SSE-S3`. Per utilizzare le chiavi gestite dal cliente di AWS Key Management Service (AWS KMS) per crittografare i dati, puoi impostare da `("sse_kms_key" → kmsKey)` dove KSMKey [proviene l'ID](https://docs.aws.amazon.com/kms/latest/developerguide/find-cmk-id-arn.html) della chiave AWS KMS, anziché l'opzione di impostazione precedente nella versione 3.0. `("extraunloadoptions" → s"ENCRYPTED KMS_KEY_ID '$kmsKey'")` AWS Glue
```
datasource0 = glueContext.create_dynamic_frame.from_catalog(
database = "database-name",
table_name = "table-name",
redshift_tmp_dir = args["TempDir"],
additional_options = {"sse_kms_key":""},
transformation_ctx = "datasource0"
)
```
**Supporto dell'URL JDBC basato su IAM**
Il nuovo connettore supporta un URL JDBC basato su IAM, quindi non è necessario inserire un segreto or. user/password Con un URL JDBC basato su IAM, il connettore utilizza il ruolo di runtime del processo per accedere all'origine dati Amazon Redshift.
Fase 1: collegamento della seguente politica minima obbligatoria al ruolo di runtime del processo AWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "redshift:GetClusterCredentials",
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:dbgroup:/*",
"arn:aws:redshift:*:111122223333:dbuser:*/*",
"arn:aws:redshift:us-east-1:111122223333:dbname:/"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "redshift:DescribeClusters",
"Resource": "*"
}
]
}
```
------
Fase 2: uso dell'URL JDBC basato su IAM come segue. Specifica una nuova opzione `DbUser` con il nome utente Amazon Redshift con cui ti stai connettendo.
```
conn_options = {
// IAM-based JDBC URL
"url": "jdbc:redshift:iam://:/",
"dbtable": dbtable,
"redshiftTmpDir": redshiftTmpDir,
"aws_iam_role": aws_iam_role,
"DbUser": "" // required for IAM-based JDBC URL
}
redshift_write = glueContext.write_dynamic_frame.from_options(
frame=dyf,
connection_type="redshift",
connection_options=conn_options
)
redshift_read = glueContext.create_dynamic_frame.from_options(
connection_type="redshift",
connection_options=conn_options
)
```
**Nota**
Un `DynamicFrame` al momento supporta un URL JDBC basato su IAM solo con un ` DbUser` nel flusso di lavoro `GlueContext.create_dynamic_frame.from_options`.
## Migrazione da AWS Glue versione 3.0 alla versione 4.0
In AWS Glue 4.0, i job ETL hanno accesso a un nuovo connettore Amazon Redshift Spark e a un nuovo driver JDBC con diverse opzioni e configurazioni. Il nuovo connettore e driver Amazon Redshift sono stati progettati per le prestazioni e garantiscono la coerenza transazionale dei dati. Questi prodotti sono illustrati nella documentazione di Amazon Redshift. Per ulteriori informazioni, consulta:
+ [Integrazione di Amazon Redshift per Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html)
+ [Driver JDBC Amazon Redshift, versione 2.1](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-download-driver.html)
**Restrizione dei nomi e degli identificatori di tabelle/colonne**
Il nuovo connettore e il driver Amazon Redshift Spark hanno un requisito più limitato per il nome della tabella Redshift. Per ulteriori informazioni, consulta [Nomi e identificatori](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) per definire il nome della tabella Amazon Redshift. Il flusso di lavoro relativo ai segnalibri del processo potrebbe non funzionare con un nome di tabella che non corrisponde alle regole e con determinati caratteri, ad esempio uno spazio.
Se hai tabelle legacy con nomi non conformi alle regole dei [nomi e degli identificatori](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) e riscontri problemi con i segnalibri (processi che rielaborano i vecchi dati delle tabelle Amazon Redshift), ti consigliamo di rinominare le tabelle. Per ulteriori informazioni, consultare [Esempi di ALTER TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_TABLE_examples_basic.html).
**Modifica del formato temporale predefinito in Dataframe**
Il connettore Spark di AWS Glue versione 3.0 imposta automaticamente `tempformat` su CSV durante la scrittura su Amazon Redshift. Per continuità, in AWS Glue versione 3.0, ` DynamicFrame` è ancora impostato su `tempformat` per l'uso di `CSV`. Se in precedenza hai utilizzato Spark Dataframe APIs direttamente con il connettore Amazon Redshift Spark, puoi impostarlo in modo esplicito su CSV nelle `tempformat` opzioni/. `DataframeReader` `Writer` Altrimenti, `tempformat` è impostato su `AVRO` nel nuovo connettore Spark.
**Modifica di comportamento: associazione del tipo di dati Amazon Redshift REAL al tipo di dati Spark FLOAT anziché DOUBLE**
In AWS Glue versione 3.0, Amazon Redshift `REAL` viene convertito in un tipo ` DOUBLE` Spark. Il nuovo connettore Amazon Redshift Spark ha aggiornato il comportamento in modo che il tipo ` REAL` Amazon Redshift venga viene convertito e di nuovo dal tipo `FLOAT` Spark. Se si dispone di un caso d'uso precedente in cui si desidera ancora che il tipo `REAL` Amazon Redshift sia mappato a un tipo `DOUBLE` Spark, è possibile utilizzare la seguente soluzione alternativa:
+ Per un `DynamicFrame`, mappa il tipo `Float` a un tipo `Double` con `DynamicFrame.ApplyMapping`. Per un `Dataframe`, è necessario usare `cast`.
Esempio di codice:
```
dyf_cast = dyf.apply_mapping([('a', 'long', 'a', 'long'), ('b', 'float', 'b', 'double')])
```
**Gestione del tipo di dati VARBYTE**
Quando si lavora con tipi di dati AWS Glue 3.0 e Amazon Redshift, AWS Glue 3.0 converte Amazon `VARBYTE` Redshift in tipo Spark. `STRING` Tuttavia, il connettore Spark Amazon Redshift più recente non supporta il tipo di dati `VARBYTE`. Per aggirare questa limitazione, è possibile [creare una vista Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW.html) che trasformi le colonne `VARBYTE` in un tipo di dati supportato. In seguito, è possibile utilizzare il nuovo connettore per caricare i dati da questa vista anziché dalla tabella originale, in modo da garantire la compatibilità pur mantenendo l'accesso ai dati `VARBYTE`.
Esempio di query Redshift:
```
CREATE VIEW view_name AS SELECT FROM_VARBYTE(varbyte_column, 'hex') FROM table_name
```
# Connessioni Kafka
È possibile usare una connessione Kafka per leggere e scrivere su flussi di dati Kafka utilizzando le informazioni archiviate in una tabella del Catalogo dati o fornendo informazioni per accedere direttamente al flusso di dati. La connessione supporta un cluster Kafka o un cluster Streaming gestito da Amazon per Apache Kafka. Puoi leggere le informazioni di Kafka in uno Spark DataFrame, quindi convertirle in un Glue. AWS DynamicFrame Puoi scrivere su Kafka DynamicFrames in formato JSON. Se si accede direttamente al flusso di dati, utilizzare queste opzioni per fornire le informazioni su come accedere al flusso di dati.
Se si utilizza `getCatalogSource` o `create_data_frame_from_catalog` per consumare i record da una sorgente di streaming Kafka oppure `getCatalogSink` o `write_dynamic_frame_from_catalog` per scrivere i record su Kafka, il processo avrà le informazioni sul database del Catalogo dati e sul nome della tabella, e potrà usarle per ottenere alcuni parametri di base per la lettura dall'origine di streaming Kafka. Se si utilizza `getSource`, `getCatalogSink`, `getSourceWithFormat`, `getSinkWithFormat`, `createDataFrameFromOptions`, `create_data_frame_from_options` o `write_dynamic_frame_from_catalog`, sarà necessario specificare questi parametri di base utilizzando le opzioni di connessione descritte qui.
È possibile specificare le opzioni di connessione per Kafka utilizzando gli argomenti per i metodi specificati nella classe `GlueContext` descritti di seguito.
+ Scala
+ `connectionOptions`: utilizza con `getSource`, `createDataFrameFromOptions` e `getSink`
+ `additionalOptions`: utilizza con `getCatalogSource`, `getCatalogSink`
+ `options`: utilizza con `getSourceWithFormat`, `getSinkWithFormat`
+ Python
+ `connection_options`: utilizza con `create_data_frame_from_options`, `write_dynamic_frame_from_options`
+ `additional_options`: utilizza con `create_data_frame_from_catalog`, `write_dynamic_frame_from_catalog`
+ `options`: utilizza con `getSource`, `getSink`
Per osservazioni e restrizioni sui processi ETL dei flussi di dati, consultare la pagina [Streaming di note e restrizioni ETL](add-job-streaming.md#create-job-streaming-restrictions).
**Topics**
+ [Configurazione di Kafka](#aws-glue-programming-etl-connect-kafka-configure)
+ [Esempio: lettura di flussi da Kafka](#aws-glue-programming-etl-connect-kafka-read)
+ [Esempio: scrittura in flussi Kafka](#aws-glue-programming-etl-connect-kafka-write)
+ [Indicazioni di riferimento alle opzioni di connessione a Kafka](#aws-glue-programming-etl-connect-kafka)
## Configurazione di Kafka
Non ci sono AWS prerequisiti per la connessione agli stream di Kafka disponibili su Internet.
Puoi creare una connessione AWS Glue Kafka per gestire le tue credenziali di connessione. Per ulteriori informazioni, consulta [Creazione di una connessione AWS Glue per un flusso di dati Apache Kafka](add-job-streaming.md#create-conn-streaming). Nella configurazione del processo AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**, quindi, nella chiamata *connectionName* al metodo, fornisci il `connectionName` parametro.
In alcuni casi, è necessario configurare ulteriori prerequisiti:
+ Se utilizzi Streaming gestito da Amazon per Apache Kafka con l'autenticazione IAM, avrai bisogno di una configurazione appropriata di IAM.
+ Se utilizzi Streaming gestito da Amazon per Apache Kafka con un Amazon VPC, avrai bisogno di una configurazione appropriata di Amazon VPC. Dovrai creare una connessione AWS Glue che fornisca informazioni sulla connessione Amazon VPC. È necessaria la configurazione del lavoro per includere la connessione AWS Glue come **connessione di rete aggiuntiva**.
Per ulteriori informazioni sui prerequisiti dei processi ETL dei flussi di dati, consulta la pagina [Aggiunta di processi di streaming ETL in AWS Glue](add-job-streaming.md).
## Esempio: lettura di flussi da Kafka
Usato in combinazione con [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Esempio per l'origine di streaming Kafka:
```
kafka_options =
{ "connectionName": "ConfluentKafka",
"topicName": "kafka-auth-topic",
"startingOffsets": "earliest",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kafka", connection_options=kafka_options)
```
## Esempio: scrittura in flussi Kafka
Esempi di scrittura in Kafka:
Esempio con il metodo `getSink`:
```
data_frame_datasource0 =
glueContext.getSink(
connectionType="kafka",
connectionOptions={
JsonOptions("""{
"connectionName": "ConfluentKafka",
"classification": "json",
"topic": "kafka-auth-topic",
"typeOfData": "kafka"}
""")},
transformationContext="dataframe_ApacheKafka_node1711729173428")
.getDataFrame()
```
Esempio con il metodo `write_dynamic_frame.from_options`:
```
kafka_options =
{ "connectionName": "ConfluentKafka",
"topicName": "kafka-auth-topic",
"classification": "json"
}
data_frame_datasource0 = glueContext.write_dynamic_frame.from_options(connection_type="kafka", connection_options=kafka_options)
```
## Indicazioni di riferimento alle opzioni di connessione a Kafka
Per la lettura, utilizzare le seguenti opzioni di connessione con `"connectionType": "kafka"`:
+ `"bootstrap.servers"`(Obbligatorio) Un elenco di server di bootstrap URLs, ad esempio, come`b-1.vpc-test-2.o4q88o.c6.kafka.us-east-1.amazonaws.com:9094`. Questa opzione deve essere specificata nella chiamata API o definita nei metadati della tabella in catalogo dati.
+ `"security.protocol"`: (obbligatorio) Il protocollo utilizzato per comunicare con i broker. I valori possibili sono `"SSL"` o `"PLAINTEXT"`.
+ `"topicName"`: (obbligatorio) un elenco separato da virgole di argomenti a cui iscriversi. Devi specificare solo uno tra `"topicName"`, `"assign"` o `"subscribePattern"`.
+ `"assign"`: (obbligatorio) una stringa JSON che specifica il `TopicPartitions` specifico da utilizzare. Devi specificare solo uno tra `"topicName"`, `"assign"` o `"subscribePattern"`.
Esempio: '\$1"topicA":[0,1],"topicB":[2,4]\$1'
+ `"subscribePattern"`: (obbligatorio) una stringa regex Java che identifichi l'elenco degli argomenti a cui effettuare la sottoscrizione. Devi specificare solo uno tra `"topicName"`, `"assign"` o `"subscribePattern"`.
Esempio: 'topic.\$1'
+ `"classification"` (obbligatorio): il formato di file utilizzato dai dati nel record. Obbligatorio, a meno che non sia fornito tramite Catalogo dati.
+ `"delimiter"` (opzionale): il separatore di valori utilizzato quando `classification` è CSV. Il valore predefinito è “`,`”.
+ `"startingOffsets"`: (opzionale) la posizione di partenza nell'argomento Kafka da cui leggere i dati. I valori possibili sono `"earliest"` o `"latest"`. Il valore predefinito è `"latest"`.
+ `"startingTimestamp"`: (Facoltativo, supportato solo per AWS Glue versione 4.0 o successiva) Il timestamp del record nell'argomento Kafka da cui leggere i dati. Il valore possibile è una stringa timestamp in formato UTC nel modello `yyyy-mm-ddTHH:MM:SSZ`, dove `Z` rappresenta un offset del fuso orario UTC con un segno \$1/- (ad esempio: "2023-04-04T08:00:00-04:00").
Nota: nell'elenco delle opzioni di connessione dello script di streaming AWS Glue può essere presente solo uno tra 'startingOffsets' o 'startingTimestamp', l'inclusione di entrambe queste proprietà comporterà un errore del lavoro.
+ `"endingOffsets"`: (opzionale) il punto di fine di una query batch. I valori possibili sono `"latest"` o una stringa JSON che specifica un offset finale per ogni `TopicPartition`.
Per la stringa JSON, il formato è `{"topicA":{"0":23,"1":-1},"topicB":{"0":-1}}`. Il valore `-1` come offset rappresenta `"latest"`.
+ `"pollTimeoutMs"`: (opzionale) il timeout in millisecondi per il polling dei dati da Kafka negli executor del processo Spark. Il valore predefinito è `600000`.
+ `"numRetries"`: (opzionale) i numero di tentativi prima di non riuscire a recuperare gli offset Kafka. Il valore predefinito è `3`.
+ `"retryIntervalMs"`: (opzionale) il tempo di attesa in millisecondi prima di riprovare a recuperare gli offset Kafka. Il valore predefinito è `10`.
+ `"maxOffsetsPerTrigger"`: (opzionale) il limite di velocità sul numero massimo di offset elaborati per intervallo di trigger. Il numero totale di offset specificato viene suddiviso proporzionalmente tra `topicPartitions` di diversi volumi. Il valore di default è null, il che significa che il consumer legge tutti gli offset fino all'ultimo offset noto.
+ `"minPartitions"`: (opzionale) il numero minimo desiderato di partizioni da leggere da Kafka. Il valore di default è null, il che significa che il numero di partizioni Spark è uguale al numero di partizioni Kafka.
+ `"includeHeaders"`: (opzionale) indica se includere le intestazioni Kafka. Quando l'opzione è impostata su "true", l'output dei dati conterrà una colonna aggiuntiva denominata "glue\$1streaming\$1kafka\$1headers" con tipo `Array[Struct(key: String, value: String)]`. Il valore di default è "false". Questa opzione è disponibile in AWS Glue versione 3.0 o successive.
+ `"schema"`: (obbligatorio quando inferSchema è impostato su false) lo schema da utilizzare per elaborare il payload. Se la classificazione è `avro`, lo schema fornito dovrà essere nel formato dello schema Avro. Se la classificazione è `avro`, lo schema fornito dovrà essere nel formato dello schema DDL.
Di seguito sono riportati alcuni esempi di schema.
------
#### [ Example in DDL schema format ]
```
'column1' INT, 'column2' STRING , 'column3' FLOAT
```
------
#### [ Example in Avro schema format ]
```
{
"type":"array",
"items":
{
"type":"record",
"name":"test",
"fields":
[
{
"name":"_id",
"type":"string"
},
{
"name":"index",
"type":
[
"int",
"string",
"float"
]
}
]
}
}
```
------
+ `"inferSchema"`: (facoltativo) il valore di default è "false". Se impostato su "true", lo schema verrà rilevato in fase di runtime dal payload all'interno di `foreachbatch`.
+ `"avroSchema"`: (obsoleto) parametro utilizzato per specificare uno schema di dati Avro quando viene utilizzato il formato Avro. Questo parametro è obsoleto. Utilizzo del parametro `schema`.
+ `"addRecordTimestamp"`: (opzionale) Quando questa opzione è impostata su "true", l'output dei dati conterrà una colonna aggiuntiva denominata "\$1\$1src\$1timestamp" che indica l'ora in cui il record corrispondente è stato ricevuto dall'argomento. Il valore predefinito è "false". Questa opzione è supportata in AWS Glue versione 4.0 o successive.
+ `"emitConsumerLagMetrics"`: (Facoltativo) Quando l'opzione è impostata su «true», per ogni batch, emette le metriche relative alla durata compresa tra il record più vecchio ricevuto dall'argomento e l'ora in cui arriva. AWS Glue CloudWatch Il nome della metrica è «glue.driver.streaming. maxConsumerLagInMs». Il valore predefinito è "false". Questa opzione è supportata in AWS Glue versione 4.0 o successive.
Per la scrittura, utilizzare le seguenti opzioni di connessione con `"connectionType": "kafka"`:
+ `"connectionName"`(Obbligatorio) Nome della connessione AWS Glue utilizzata per connettersi al cluster Kafka (simile al sorgente Kafka).
+ `"topic"` (obbligatorio) Se esiste una colonna di argomento, il relativo valore viene utilizzato come argomento quando si scrive la riga specifica in Kafka, a meno che non sia impostata l'opzione di configurazione dell'argomento. In altre parole, l'opzione di configurazione `topic` sovrascrive la colonna dell'argomento.
+ `"partition"` (opzionale) Se viene specificato un numero di partizione valido, `partition` verrà utilizzato per l'invio del record.
Se non viene specificata alcuna partizione ma è presente `key`, verrà scelta una partizione utilizzando un hash della chiave.
Se non sono presenti né `key` né `partition`, verrà scelta una partizione in base al partizionamento permanente delle modifiche quando nella partizione vengono prodotti almeno batch.size byte.
+ `"key"` (opzionale) Utilizzato per il partizionamento se `partition` è null.
+ `"classification"` (opzionale) Il formato di file utilizzato dai dati nel record. Supportiamo solo JSON, CSV e Avro.
Con il formato Avro, possiamo fornire un AvroSchema personalizzato con cui serializzare, ma bisogna considerare che tale schema deve essere fornito anche nell'origine per la deserializzazione. Altrimenti, per impostazione predefinita utilizza Apache per la serializzazione. AvroSchema
Inoltre, è possibile eseguire il fine-tuning del sink Kafka in base alle esigenze aggiornando i [parametri di configurazione del produttore di Kafka](https://kafka.apache.org/documentation/#producerconfigs). Da notare che non esiste un elenco delle opzioni di connessione consentite, tutte le coppie chiave-valore vengono mantenute nel sink così come sono.
Tuttavia, esiste un piccolo elenco di opzioni di rifiuto che non avranno effetto. Per ulteriori informazioni, consultare le [configurazioni specifiche di Kafka](https://spark.apache.org/docs/latest/structured-streaming-kafka-integration.html).
# Connessioni Azure Cosmos DB
Puoi usare AWS Glue for Spark per leggere e scrivere su contenitori esistenti in Azure Cosmos DB usando l'API NoSQL in Glue 4.0 e versioni successive. AWS È possibile definire cosa leggere da Azure Cosmos DB con una query SQL. Ti connetti ad Azure Cosmos DB usando una chiave di Azure Cosmos DB archiviata tramite Gestione dei segreti AWS una connessione Glue. AWS
Per altre informazioni su Azure Cosmos DB per NoSQL, consulta [la documentazione di Azure](https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/).
## Configurazione delle connessioni Azure Cosmos DB
Per connetterti ad Azure Cosmos DB da AWS Glue, dovrai creare e archiviare la tua chiave Azure Cosmos DB in un luogo Gestione dei segreti AWS segreto, quindi associare quel segreto a una connessione Azure Cosmos DB Glue. AWS
**Prerequisiti:**
+ In Azure, dovrai identificare o generare una chiave di Azure Cosmos DB da usare con AWS Glue,. `cosmosKey` Per altre informazioni, consulta [Accesso sicuro ai dati in Azure Cosmos DB](https://learn.microsoft.com/en-us/azure/cosmos-db/secure-access-to-data?tabs=using-primary-key) nella documentazione di Azure.
**Per configurare una connessione ad Azure Cosmos DB:**
1. Nel Gestione dei segreti AWS, crea un segreto usando la tua chiave Azure Cosmos DB. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `spark.cosmos.accountKey` con il valore. *cosmosKey*
1. Nella console AWS Glue, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione*connectionName*, per utilizzi futuri in AWS Glue.
+ In **Tipo di connessione**, seleziona Azure Cosmos DB.
+ Quando selezioni un **AWS segreto**, fornisci*secretName*.
Dopo aver creato una connessione AWS Glue Azure Cosmos DB, dovrai eseguire i seguenti passaggi prima di eseguire il lavoro AWS Glue:
+ Concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*.
+ Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
## Lettura da container Azure Cosmos DB per NoSQL
**Prerequisiti:**
+ Un container Azure Cosmos DB per NoSQL da cui desideri leggere. Avrai bisogno delle informazioni di identificazione per il container.
Un container Azure Cosmos per NoSQL è identificato dal database e dal container. È necessario fornire i nomi del database e del contenitore quando ci si connette all'API di Azure Cosmos for NoSQL. *cosmosDBName* *cosmosContainerName*
+ Una connessione AWS Glue Azure Cosmos DB configurata per fornire informazioni di autenticazione e posizione della rete. Per l'acquisizione, completa i passaggi della procedura precedente, *Per configurare una connessione ad Azure Cosmos DB*. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
azurecosmos_read = glueContext.create_dynamic_frame.from_options(
connection_type="azurecosmos",
connection_options={
"connectionName": connectionName,
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName,
}
)
```
Puoi anche fornire una query SQL SELECT per filtrare i risultati restituiti al tuo DynamicFrame. Sarà necessario configurare `query`.
Esempio:
```
azurecosmos_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="azurecosmos",
connection_options={
"connectionName": "connectionName",
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName,
"spark.cosmos.read.customQuery": "query"
}
)
```
## Scrittura su container Azure Cosmos DB per NoSQL
Questo esempio scrive informazioni da un database esistente DynamicFrame *dynamicFrame* ad Azure Cosmos DB. Se il contenitore contiene già informazioni, AWS Glue aggiungerà i dati dal tuo DynamicFrame. Se le informazioni nel contanier hanno uno schema diverso da quello scritto, si verificheranno degli errori.
**Prerequisiti:**
+ Una tabella di Azure Cosmos DB su cui scrivere. Avrai bisogno delle informazioni di identificazione per il container. **È necessario creare il container prima di chiamare il metodo di connessione.**
Un container Azure Cosmos per NoSQL è identificato dal database e dal container. È necessario fornire i nomi del database e del contenitore quando ci si connette all'API di Azure Cosmos for NoSQL. *cosmosDBName* *cosmosContainerName*
+ Una connessione AWS Glue Azure Cosmos DB configurata per fornire informazioni di autenticazione e posizione della rete. Per l'acquisizione, completa i passaggi della procedura precedente, *Per configurare una connessione ad Azure Cosmos DB*. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
azurecosmos_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="azurecosmos",
connection_options={
"connectionName": connectionName,
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName
)
```
## Indicazioni di riferimento alle opzioni di connessione ad Azure Cosmos DB
+ `connectionName`: obbligatorio. Utilizzato per la lettura/scrittura. Il nome di una connessione AWS Glue Azure Cosmos DB configurata per fornire informazioni di autenticazione e posizione di rete al metodo di connessione.
+ `spark.cosmos.database`: obbligatorio. Utilizzato per la lettura/scrittura. Valori validi: nomi di database. Nome del database di Azure Cosmos DB per NoSQL.
+ `spark.cosmos.container`: obbligatorio. Utilizzato per la lettura/scrittura. Valori validi: nomi dei contanier. Nome del contanier di Azure Cosmos DB per NoSQL.
+ `spark.cosmos.read.customQuery`: utilizzato per la lettura. Valori validi: query SELECT SQL. Query personalizzata per selezionare i documenti da leggere.
# Connessioni Azure SQL
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle su istanze gestite di Azure SQL in AWS Glue 4.0 e versioni successive. È possibile definire cosa leggere da Azure SQL con una query SQL. Ti connetti ad Azure SQL usando le credenziali utente e password archiviate Gestione dei segreti AWS tramite una connessione AWS Glue.
Per altre informazioni su Azure SQL, consulta [la documentazione di Azure SQL](https://azure.microsoft.com/en-us/products/azure-sql).
## Configurazione delle connessioni Azure SQL
Per connetterti ad Azure SQL da AWS Glue, dovrai creare e archiviare le tue credenziali SQL di Azure in un Gestione dei segreti AWS segreto, quindi associare quel segreto a una connessione Azure SQL AWS Glue.
**Per configurare una connessione ad Azure SQL:**
1. Nel Gestione dei segreti AWS, crea un segreto usando le tue credenziali SQL di Azure. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `user` con il valore. *azuresqlUsername*
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `password` con il valore. *azuresqlPassword*
1. Nella console AWS Glue, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione*connectionName*, per utilizzi futuri in AWS Glue.
+ In **Tipo di connessione**, seleziona Azure SQL.
+ Quando fornisci l'**URL SQL di Azure**, fornisci un URL di endpoint JDBC.
L'elenco deve essere nel seguente formato: `jdbc:sqlserver://databaseServerName:databasePort;databaseName=azuresqlDBname;`.
AWS Glue richiede le seguenti proprietà URL:
+ `databaseName`: un database predefinito in Azure SQL a cui connettersi.
[Per altre informazioni su JDBC URLs for Azure SQL Managed Instances, consulta la documentazione di Microsoft.](https://learn.microsoft.com/en-us/sql/connect/jdbc/building-the-connection-url?view=azuresqldb-mi-current)
+ **Quando selezioni un AWS segreto, fornisci.** *secretName*
Dopo aver creato una connessione SQL di AWS Glue Azure, dovrai eseguire i seguenti passaggi prima di eseguire il lavoro AWS Glue:
+ Concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*.
+ Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
## Lettura da tabelle SQL di Azure
**Prerequisiti:**
+ Una tabella Azure SQL da cui si desidera leggere. Avrai bisogno delle informazioni di identificazione per la tabella *databaseName* e*tableIdentifier*.
Una tabella SQL di Azure è identificata dal database, dallo schema e dal nome. È necessario fornire il nome del database e della tabella durante la connessione ad Azure SQL. È inoltre necessario fornire lo schema se diverso da quello predefinito, "pubblico". Il database viene fornito tramite una proprietà URL in*connectionName*, lo schema e il nome della tabella tramite`dbtable`.
+ Una connessione AWS Glue Azure SQL configurata per fornire informazioni di autenticazione. Completa i passaggi della procedura precedente, *Per configurare una connessione ad Azure SQL* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
azuresql_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier"
}
)
```
Puoi anche fornire una query SQL SELECT per filtrare i risultati restituiti al tuo DynamicFrame. Sarà necessario configurare `query`.
Esempio:
```
azuresql_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Scrittura su tabelle SQL di Azure
Questo esempio scrive informazioni da un SQL esistente DynamicFrame *dynamicFrame* ad Azure. Se la tabella contiene già informazioni, AWS Glue aggiungerà i dati dal tuo DynamicFrame.
**Prerequisiti:**
+ Una tabella di Azure SQL su cui scrivere. Avrai bisogno delle informazioni di identificazione per la tabella, *databaseName* e*tableIdentifier*.
Una tabella SQL di Azure è identificata dal database, dallo schema e dal nome. È necessario fornire il nome del database e della tabella durante la connessione ad Azure SQL. È inoltre necessario fornire lo schema se diverso da quello predefinito, "pubblico". Il database viene fornito tramite una proprietà URL in*connectionName*, lo schema e il nome della tabella tramite`dbtable`.
+ Informazioni di autenticazione SQL di Azure. Completa i passaggi della procedura precedente, *Per configurare una connessione ad Azure SQL* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
azuresql_write = glueContext.write_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier"
}
)
```
## Indicazioni di riferimento alle opzioni di connessione ad Azure SQL
+ `connectionName`: obbligatorio. Utilizzato per la lettura/scrittura. Il nome di una connessione SQL di AWS Glue Azure configurata per fornire informazioni di autenticazione al metodo di connessione.
+ `databaseName`: utilizzato per la lettura/scrittura. Valori validi: nomi di database di Azure SQL. Il nome del database in Azure SQL a cui connettersi.
+ `dbtable` — Richiesto per la scrittura, richiesto per la lettura a meno che non `query` sia fornito. Usato per le combinazioni di Read/Write. Valid Values: Names of Azure SQL tables, or period separated schema/table nomi. Utilizzato per specificare la tabella e lo schema che identificano la tabella a cui connettersi. Lo schema predefinito è "pubblico". Se la tabella rientra in uno schema non predefinito, fornisci queste informazioni nel modulo `schemaName.tableName`.
+ `query`: utilizzato per la lettura. Una query Transact-SQL SELECT che definisce cosa recuperare durante la lettura da Azure SQL. Per ulteriori informazioni, consulta la [documentazione di Microsoft](https://learn.microsoft.com/en-us/sql/t-sql/queries/select-transact-sql?view=azuresqldb-mi-current).
# BigQuery connessioni
Puoi utilizzare AWS Glue for Spark per leggere e scrivere su tabelle in Google BigQuery in AWS Glue 4.0 e versioni successive. Puoi leggere da BigQuery una query SQL di Google. Ti connetti BigQuery utilizzando le credenziali archiviate Gestione dei segreti AWS tramite una connessione AWS Glue.
Per ulteriori informazioni su Google BigQuery, consulta il [ BigQuery sito Web di Google Cloud](https://cloud.google.com/bigquery).
## Configurazione delle connessioni BigQuery
Per connetterti a Google BigQuery da AWS Glue, dovrai creare e archiviare le tue credenziali di Google Cloud Platform in modo Gestione dei segreti AWS segreto, quindi associare quel segreto a una connessione Google BigQuery AWS Glue.
**Per configurare una connessione a BigQuery:**
1. In Google Cloud Platform, crea e identifica le risorse pertinenti:
+ Crea o identifica un progetto GCP contenente BigQuery le tabelle a cui desideri connetterti.
+ Abilita l' BigQuery API. Per ulteriori informazioni, consulta [Utilizzare l'API BigQuery Storage Read per leggere i dati delle tabelle](https://cloud.google.com/bigquery/docs/reference/storage/#enabling_the_api).
1. In Google Cloud Platform, crea ed esporta le credenziali dell'account del servizio:
[È possibile utilizzare la procedura guidata per le BigQuery credenziali per velocizzare questo passaggio: Creazione di credenziali.](https://console.cloud.google.com/apis/credentials/wizard?api=bigquery.googleapis.com)
Per creare un account di servizio in GCP, segui il tutorial disponibile in [Creazione di account di servizio](https://cloud.google.com/iam/docs/service-accounts-create).
+ Quando selezionate il **progetto, selezionate il progetto** contenente la tabella. BigQuery
+ Quando selezioni i ruoli GCP IAM per il tuo account di servizio, aggiungi o crea un ruolo che conceda le autorizzazioni appropriate per eseguire BigQuery lavori di lettura, scrittura o creazione BigQuery di tabelle.
Per creare le credenziali per il tuo account di servizio, segui il tutorial disponibile in [Creazione della chiave di un account di servizio](https://cloud.google.com/iam/docs/keys-create-delete#creating).
+ Quando selezioni il tipo di chiave, seleziona **JSON**.
Ora dovresti avere scaricato un file JSON con le credenziali per il tuo account di servizio. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"type": "service_account",
"project_id": "*****",
"private_key_id": "*****",
"private_key": "*****",
"client_email": "*****",
"client_id": "*****",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "*****",
"universe_domain": "googleapis.com"
}
```
1. Carica il file JSON delle credenziali in una posizione Amazon S3 adeguatamente sicura. Conserva il percorso del file, *s3secretpath* per le fasi future.
1. Nel Gestione dei segreti AWS, crea un segreto utilizzando le tue credenziali di Google Cloud Platform. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
Quando create Key/value coppie, specificate chiavi e valori come segue:
+ Per le `client_id` chiavi `token_uri` `client_x509_cert_url``private_key_id`,`project_id`,`universe_domain`,,`auth_provider_x509_cert_url`,`auth_uri`,`client_email`,`private_key`,`type`,, specificate i valori corrispondenti nel file JSON scaricato.
+ Per `spark.hadoop.google.cloud.auth.service.account.json.keyfile` chiave, specificare il. *s3secretpath*
1. Nel AWS Glue Data Catalog, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, conservate il nome della connessione per il passaggio successivo. *connectionName*
+ Quando selezioni un **tipo di connessione**, seleziona Google BigQuery.
+ Quando selezioni un **AWS segreto**, fornisci*secretName*.
1. Concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*.
1. Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
## Leggere dalle BigQuery tabelle
**Prerequisiti:**
+ Una BigQuery tabella da cui vorresti leggere. Avrai bisogno dei nomi delle BigQuery tabelle e dei set di dati, nel modulo`[dataset].[table]`. Chiamiamo questo*tableName*.
+ Il progetto di fatturazione per il BigQuery tavolo. Avrai bisogno del nome del progetto,*parentProject*. Se non esiste un progetto padre di fatturazione, utilizza il progetto contenente la tabella.
+ BigQuery informazioni di autenticazione. Completa i passaggi *per gestire le credenziali di connessione con AWS Glue* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
bigquery_read = glueContext.create_dynamic_frame.from_options(
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"sourceType": "table",
"table": "tableName",
}
```
Puoi anche fornire una query, per filtrare i risultati restituiti al tuo DynamicFrame. Sarà necessario configurare `query`, `sourceType`, `viewsEnabled` e `materializationDataset`.
Esempio:
**Prerequisiti aggiuntivi:**
Dovrai creare o identificare un BigQuery set di dati*materializationDataset*, in cui BigQuery scrivere viste materializzate per le tue query.
Dovrai concedere le autorizzazioni GCP IAM appropriate al tuo account di servizio per creare tabelle. *materializationDataset*
```
glueContext.create_dynamic_frame.from_options(
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"materializationDataset": materializationDataset,
"parentProject": "parentProject",
"viewsEnabled": "true",
"sourceType": "query",
"query": "select * from bqtest.test"
}
)
```
## Scrittura su tabelle BigQuery
Questo esempio scrive direttamente sul BigQuery servizio. BigQuery supporta anche il metodo di scrittura «indiretto». Per ulteriori informazioni sulla configurazione di scritture indirette, consulta la pagina [Utilizzo della scrittura indiretta con Google BigQuery](#aws-glue-programming-etl-connect-bigquery-indirect-write).
**Prerequisiti:**
+ Una BigQuery tabella su cui desideri scrivere. Avrai bisogno dei nomi delle BigQuery tabelle e dei set di dati, nel modulo`[dataset].[table]`. È possibile anche fornire un nuovo nome di tabella che verrà creato automaticamente. Chiamiamo questo*tableName*.
+ Il progetto di fatturazione per il BigQuery tavolo. Avrai bisogno del nome del progetto,*parentProject*. Se non esiste un progetto padre di fatturazione, utilizza il progetto contenente la tabella.
+ BigQuery informazioni di autenticazione. Completa i passaggi *per gestire le credenziali di connessione con AWS Glue* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
bigquery_write = glueContext.write_dynamic_frame.from_options(
frame=frameToWrite,
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"writeMethod": "direct",
"table": "tableName",
}
)
```
## BigQuery riferimento all'opzione di connessione
+ `project`: Predefinita: impostazione predefinita dell'account del servizio Google Cloud. Utilizzato per la lettura/scrittura. Il nome di un progetto Google Cloud associato alla tua tabella.
+ `table`: (obbligatorio) utilizzato per la lettura/scrittura. Il nome della BigQuery tabella nel formato`[[project:]dataset.]`.
+ `dataset`: obbligatorio quando non è definito tramite l'opzione `table`. Utilizzato per la lettura/scrittura. Il nome del set di dati contenente la BigQuery tabella.
+ `parentProject`: Predefinita: impostazione predefinita dell'account del servizio Google Cloud. Utilizzato per la lettura/scrittura. Il nome di un progetto Google Cloud associato al `project` utilizzato per la fatturazione.
+ `sourceType`: utilizzato per la lettura. Richiesto durante la lettura. Valori validi:`table`, `query` Indica a AWS Glue se leggerai per tabella o per query.
+ `materializationDataset`: utilizzato per la lettura. Valori validi: stringhe. Il nome di un BigQuery set di dati utilizzato per memorizzare le materializzazioni per le viste.
+ `viewsEnabled`: utilizzato per la lettura. Valore predefinito: false. Valori validi: vero, falso. Configura se BigQuery utilizzerà le viste.
+ `query`: utilizzato per la lettura. Usato quando `viewsEnabled` è vero. Una query DQL di GoogleSQL.
+ `temporaryGcsBucket`: utilizzato per la scrittura. Obbligatorio quando `writeMethod` è impostato sull'impostazione predefinita (`indirect`). Nome di un bucket di Google Cloud Storage utilizzato per archiviare una forma intermedia dei dati durante la scrittura su. BigQuery
+ `writeMethod`: valore predefinito: `indirect`. Valori validi: `direct`, `indirect`. Utilizzato per la scrittura. Specifica il metodo utilizzato per scrivere i dati.
+ Se impostato su`direct`, il connettore scriverà utilizzando l'API BigQuery Storage Write.
+ Se impostato su`indirect`, il connettore scriverà su Google Cloud Storage, quindi lo trasferirà su BigQuery Using a Load. L'account del servizio Google Cloud avrà bisogno delle autorizzazioni GCS appropriate.
## Utilizzo della scrittura indiretta con Google BigQuery
Questo esempio utilizza la scrittura indiretta, che scrive i dati su Google Cloud Storage e li copia su Google BigQuery.
**Prerequisiti:**
Avrai bisogno di un bucket temporaneo di Google Cloud Storage,*temporaryBucket*.
Il ruolo GCP IAM per l'account di servizio GCP di AWS Glue richiederà le autorizzazioni GCS appropriate per l'accesso. *temporaryBucket*
**Configurazione aggiuntiva:**
**Per configurare la scrittura indiretta con: BigQuery**
1. Valuta [Configurazione delle connessioni BigQuery](#aws-glue-programming-etl-connect-bigquery-configure) e individua o scarica nuovamente il file JSON delle credenziali GCP. *secretName*Identify, il Gestione dei segreti AWS segreto della connessione Google BigQuery AWS Glue utilizzata nel tuo lavoro.
1. Carica il file JSON delle credenziali in una posizione Amazon S3 adeguatamente sicura. Conserva il percorso del file, *s3secretpath* per le fasi future.
1. Modifica*secretName*, aggiungendo la `spark.hadoop.google.cloud.auth.service.account.json.keyfile` chiave. Impostare il valore su *s3secretpath*.
1. Concedi al tuo lavoro AWS Glue Job le autorizzazioni di accesso ad Amazon S3 IAM. *s3secretpath*
Ora puoi fornire la posizione temporanea del bucket GCS al tuo metodo di scrittura. Non è necessario fornire il `writeMethod`, poiché `indirect` in passato è stata l'impostazione predefinita.
```
bigquery_write = glueContext.write_dynamic_frame.from_options(
frame=frameToWrite,
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"temporaryGcsBucket": "temporaryBucket",
"table": "tableName",
}
)
```
# Connessioni JDBC
Alcuni tipi di database, tipicamente relazionali, supportano la connessione tramite lo standard JDBC. Per ulteriori informazioni su JDBC, consulta la documentazione dell'API [Java JDBC](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/). AWS Glue supporta nativamente la connessione a determinati database tramite i relativi connettori JDBC: le librerie JDBC sono fornite nei job Glue Spark. AWS Quando ci si connette a questi tipi di database utilizzando le librerie do AWS Glue, si ha accesso a un set standard di opzioni.
I valori JDBC connectionType includono quanto segue:
+ `"connectionType": "sqlserver"`: designa una connessione a un database Microsoft SQL Server.
+ `"connectionType": "mysql"`: designa una connessione al database MySQL.
+ `"connectionType": "oracle"`: designa una connessione a un database Oracle.
+ `"connectionType": "postgresql"`: designa una connessione al database PostgreSQL.
+ `"connectionType": "redshift"`: designa una connessione a un database Amazon Redshift. Per ulteriori informazioni, consulta [Connessioni Redshift](aws-glue-programming-etl-connect-redshift-home.md).
La tabella seguente elenca le versioni dei driver JDBC supportate da AWS Glue.
| Prodotto | Versioni dei driver JDBC per Glue 5.1 | Versioni dei driver JDBC per Glue 5.0 | Versioni del driver JDBC per Glue 4.0 | Versioni del driver JDBC per Glue 3.0 | Versioni del driver JDBC per Glue 0.9, 1.0, 2.0 |
| --- | --- | --- | --- | --- | --- |
| Microsoft SQL Server | 10.2.0 | 10.2,0 | 9,40 | 7.x | 6.x |
| MySQL | 8,0,33 | 8,0,33 | 8.0.23 | 8.0.23 | 5.1 |
| Banca dati Oracle | 23.3.0.23.09 | 23,3,023,09 | 21,7 | 21,1 | 11.2 |
| PostgreSQL | 42,7,3 | 42,7,3 | 42,36 | 4,2,18 | 42.1.x |
| Amazon Redshift\$1 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
\$1 Per il tipo di connessione Amazon Redshift, tutte le altre name/value coppie di opzioni incluse nelle opzioni di connessione per una connessione JDBC, incluse le opzioni di formattazione, vengono passate direttamente allo SparkSQL sottostante. DataSource Nei lavori AWS Glue with Spark in AWS Glue 4.0 e versioni successive, il connettore nativo AWS Glue per Amazon Redshift utilizza l'integrazione Amazon Redshift per Apache Spark. Per ulteriori informazioni, consulta la pagina [Integrazione di Amazon Redshift per Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Nelle versioni precedenti, consulta la sezione [Amazon Redshift data source for Spark](https://github.com/databricks/spark-redshift).
Per configurare Amazon VPC per la connessione ai datastore Amazon RDS tramite JDBC, consulta la pagina [Impostazione di Amazon VPC per le connessioni JDBC ai data store Amazon RDS su JDBC da AWS Glue](setup-vpc-for-glue-access.md).
**Nota**
AWS I Glue job vengono associati solo a una sottorete durante un'esecuzione. Ciò potrebbe influire sulla capacità di connettersi a più origini dati tramite lo stesso processo. Questo comportamento non è limitato alle origini JDBC.
**Topics**
+ [Indicazioni di riferimento alle opzioni di connessione a JDBC](#aws-glue-programming-etl-connect-jdbc)
+ [Utilizzo di sampleQuery](#aws-glue-programming-etl-jdbc-samplequery)
+ [Utilizzo di un driver JDBC personalizzato](#aws-glue-programming-etl-jdbc-custom-driver)
+ [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md)
+ [Impostazione di Amazon VPC per le connessioni JDBC ai data store Amazon RDS su JDBC da AWS Glue](setup-vpc-for-glue-access.md)
## Indicazioni di riferimento alle opzioni di connessione a JDBC
Se hai già definito una connessione AWS JDBC Glue, puoi riutilizzare le proprietà di configurazione in essa definite, come: url, user e password; quindi non devi specificarle nel codice come opzioni di connessione. Questa funzionalità è disponibile in AWS Glue 3.0 e versioni successive. A tale scopo, utilizza le seguenti proprietà di connessione:
+ `"useConnectionProperties"`: impostare su “true” per indicare che si desidera utilizzare la configurazione da una connessione.
+ `"connectionName"`: inserire il nome della connessione da cui recuperare la configurazione; la connessione deve essere definita nella stessa regione del processo.
Utilizzare queste opzioni di connessione con connessioni JDBC:
+ `"url"`: (obbligatorio) l'URL JDBC per il database.
+ `"dbtable"`: (obbligatorio) la tabella database da cui leggere. Per gli archivi dati JDBC che supportano schemi all'interno di un database, specificare `schema.table-name`. Se non viene fornito alcuno schema, viene usato lo schema “pubblico” predefinito.
+ `"user"`: (obbligatorio) il nome utente da usare per la connessione.
+ `"password"`: (obbligatorio) la password da usare per la connessione.
+ (Opzionale) Le seguenti opzioni consentono di fornire un driver JDBC personalizzato. Usa queste opzioni se devi usare un driver che AWS Glue non supporta nativamente.
I processi ETL possono utilizzare versioni di driver JDBC diverse per l'origine dati e la destinazione, anche se l'origine e la destinazione sono lo stesso prodotto di database. In questo modo è possibile eseguire la migrazione dei dati tra database di origine e di destinazione con versioni diverse. Per utilizzare queste opzioni, è necessario innanzitutto caricare il file JAR del driver JDBC su Amazon S3.
+ `"customJdbcDriverS3Path"`: il percorso Amazon S3 del driver JDBC personalizzato.
+ `"customJdbcDriverClassName"`: il nome della classe del driver JDBC.
+ `"bulkSize"`: (opzionale) utilizzato per configurare inserti paralleli per accelerare i carichi di massa nelle destinazioni JDBC. Specifica un valore intero per il grado di parallelismo da utilizzare durante la scrittura o l'inserimento di dati. Questa opzione è utile per migliorare le prestazioni delle scritture in database come Arch User Repository (AUR).
+ `"hashfield"`: (opzionale) una stringa utilizzata per specificare il nome di una colonna nella tabella JDBC da utilizzare per dividere i dati in partizioni durante la lettura da tabelle JDBC in parallelo. Fornire “hashfield” O “hashexpression”. Per ulteriori informazioni, consultare [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md).
+ `"hashexpression"`: (opzionale) una clausola SQL select che restituisce un numero intero. Utilizzata per suddividere i dati presenti in una tabella JDBC in partizioni durante la lettura da tabelle JDBC in parallelo. Fornire “hashfield” O “hashexpression”. Per ulteriori informazioni, consultare [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md).
+ `"hashpartitions"`: (opzionale) un numero intero positivo. Utilizzato per specificare il numero di letture parallele della tabella JDBC durante la lettura da tabelle JDBC in parallelo. Impostazione predefinita: 7. Per ulteriori informazioni, consultare [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md).
+ `"sampleQuery"`: (opzionale) un'istruzione di query SQL personalizzata. Utilizzata per specificare un sottoinsieme di informazioni in una tabella per recuperare un campione del contenuto della tabella. **Se configurato indipendentemente dai dati, può essere meno efficiente dei DynamicFrame metodi e causare timeout o errori di esaurimento della memoria.** Per ulteriori informazioni, consulta [Utilizzo di sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
+ `"enablePartitioningForSampleQuery"`: (opzionale) un valore booleano. Valore predefinito: false. Utilizzato per abilitare la lettura da tabelle JDBC in parallelo durante la specificazione della `sampleQuery`. **Se impostato su true, `sampleQuery` deve terminare con «where» o «and» affinché AWS Glue aggiunga le condizioni di partizionamento.** Per ulteriori informazioni, consulta [Utilizzo di sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
+ `"sampleSize"`: (opzionale) un numero intero positivo. Limita il numero di righe restituite dalla query di esempio. Funziona solo quando `enablePartitioningForSampleQuery` è true. Se il partizionamento non è abilitato, è invece necessario aggiungere direttamente `"limit x"` nella `sampleQuery` per limitare le dimensioni. Per ulteriori informazioni, consultare [Utilizzo di sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
## Utilizzo di sampleQuery
Questa sezione illustra come utilizzare `sampleQuery`, `sampleSize` e `enablePartitioningForSampleQuery`.
`sampleQuery` può essere un modo efficace per campionare alcune righe del set di dati. Per impostazione predefinita, la query viene eseguita da un singolo esecutore. Se configurato indipendentemente dai dati, può essere meno efficiente dei DynamicFrame metodi e causare timeout o errori di esaurimento della memoria. Nelle pipeline ETL, l'esecuzione diretta di query SQL sul database sottostante è in genere necessaria solo per ottimizzare le prestazioni. Se si sta cercando di visualizzare in anteprima alcune righe del tuo set di dati, prendere in considerazione l'utilizzo di [show](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show). Se stai cercando di trasformare il tuo set di dati utilizzando SQL, prendi in considerazione l'utilizzo [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) per definire una trasformazione SparkSQL rispetto ai tuoi dati in DataFrame un modulo.
Anche se la query può manipolare diverse tabelle, `dbtable` resta obbligatoria.
**Utilizzo di SampleQuery per recuperare un campione della tabella**
Quando si utilizza il comportamento SampleQuery predefinito per recuperare un campione dei dati, AWS Glue non prevede un throughput sostanziale, quindi esegue la query su un singolo esecutore. Per limitare i dati forniti e non causare problemi di prestazioni, consigliamo di fornire a SQL una clausola `LIMIT`.
**Example Usare SampleQuery senza partizionamento**
Il codice di esempio seguente mostra come utilizzare `sampleQuery` senza partizionamento.
```
//A full sql query statement.
val query = "select name from $tableName where age > 0 limit 1"
val connectionOptions = JsonOptions(Map(
"url" -> url,
"dbtable" -> tableName,
"user" -> user,
"password" -> password,
"sampleQuery" -> query ))
val dyf = glueContext.getSource("mysql", connectionOptions)
.getDynamicFrame()
```
**Utilizzo di SampleQuery con set di dati più grandi**
Se si sta leggendo un set di dati di grandi dimensioni, potrebbe essere necessario abilitare il partizionamento JDBC per interrogare una tabella in parallelo. Per ulteriori informazioni, consultare [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md). Per utilizzare `sampleQuery` con partizionamento JDBC, impostare `enablePartitioningForSampleQuery` su true. L'attivazione di questa funzionalità richiede di apportare alcune modifiche alla `sampleQuery`.
Quando si utilizza il partizionamento JDBC con`sampleQuery`, la query deve terminare con «where» o «and» affinché AWS Glue possa aggiungere le condizioni di partizionamento.
Se si desidera limitare i risultati di SampleQuery durante la lettura da tabelle JDBC in parallelo, impostare il parametro `"sampleSize"` anziché specificare una clausola `LIMIT`.
**Example Usare SampleQuery con partizionamento JDBC**
Il codice di esempio seguente mostra come utilizzare `sampleQuery` con partizionamento JDBC.
```
//note that the query should end with "where" or "and" if use with JDBC partitioning.
val query = "select name from $tableName where age > 0 and"
//Enable JDBC partitioning by setting hashfield.
//to use sampleQuery with partitioning, set enablePartitioningForSampleQuery.
//use sampleSize to limit the size of returned data.
val connectionOptions = JsonOptions(Map(
"url" -> url,
"dbtable" -> tableName,
"user" -> user,
"password" -> password,
"hashfield" -> primaryKey,
"sampleQuery" -> query,
"enablePartitioningForSampleQuery" -> true,
"sampleSize" -> "1" ))
val dyf = glueContext.getSource("mysql", connectionOptions)
.getDynamicFrame()
```
**Note e restrizioni:**
Le query di esempio non possono essere utilizzate insieme ai segnalibri del processo. Lo stato del segnalibro verrà ignorato quando viene fornita la configurazione per entrambi.
## Utilizzo di un driver JDBC personalizzato
Negli esempi di codice riportati di seguito viene illustrato come leggere e scrivere nei database JDBC con driver JDBC personalizzati. Essi dimostrano la lettura da una versione di un prodotto di database e la scrittura a una versione successiva dello stesso prodotto.
------
#### [ Python ]
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
from pyspark.sql.types import StructType, StructField, IntegerType, StringType
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Construct JDBC connection options
connection_mysql5_options = {
"url": "jdbc:mysql://:3306/db",
"dbtable": "test",
"user": "admin",
"password": "pwd"}
connection_mysql8_options = {
"url": "jdbc:mysql://:3306/db",
"dbtable": "test",
"user": "admin",
"password": "pwd",
"customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar",
"customJdbcDriverClassName": "com.mysql.cj.jdbc.Driver"}
connection_oracle11_options = {
"url": "jdbc:oracle:thin:@//:1521/ORCL",
"dbtable": "test",
"user": "admin",
"password": "pwd"}
connection_oracle18_options = {
"url": "jdbc:oracle:thin:@//:1521/ORCL",
"dbtable": "test",
"user": "admin",
"password": "pwd",
"customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/ojdbc10.jar",
"customJdbcDriverClassName": "oracle.jdbc.OracleDriver"}
# Read from JDBC databases with custom driver
df_mysql8 = glueContext.create_dynamic_frame.from_options(connection_type="mysql",
connection_options=connection_mysql8_options)
# Read DynamicFrame from MySQL 5 and write to MySQL 8
df_mysql5 = glueContext.create_dynamic_frame.from_options(connection_type="mysql",
connection_options=connection_mysql5_options)
glueContext.write_from_options(frame_or_dfc=df_mysql5, connection_type="mysql",
connection_options=connection_mysql8_options)
# Read DynamicFrame from Oracle 11 and write to Oracle 18
df_oracle11 = glueContext.create_dynamic_frame.from_options(connection_type="oracle",
connection_options=connection_oracle11_options)
glueContext.write_from_options(frame_or_dfc=df_oracle11, connection_type="oracle",
connection_options=connection_oracle18_options)
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val MYSQL_5_URI: String = "jdbc:mysql://:3306/db"
val MYSQL_8_URI: String = "jdbc:mysql://:3306/db"
val ORACLE_11_URI: String = "jdbc:oracle:thin:@//:1521/ORCL"
val ORACLE_18_URI: String = "jdbc:oracle:thin:@//:1521/ORCL"
// Construct JDBC connection options
lazy val mysql5JsonOption = jsonOptions(MYSQL_5_URI)
lazy val mysql8JsonOption = customJDBCDriverJsonOptions(MYSQL_8_URI, "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar", "com.mysql.cj.jdbc.Driver")
lazy val oracle11JsonOption = jsonOptions(ORACLE_11_URI)
lazy val oracle18JsonOption = customJDBCDriverJsonOptions(ORACLE_18_URI, "s3://amzn-s3-demo-bucket/ojdbc10.jar", "oracle.jdbc.OracleDriver")
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Read from JDBC database with custom driver
val df_mysql8: DynamicFrame = glueContext.getSource("mysql", mysql8JsonOption).getDynamicFrame()
// Read DynamicFrame from MySQL 5 and write to MySQL 8
val df_mysql5: DynamicFrame = glueContext.getSource("mysql", mysql5JsonOption).getDynamicFrame()
glueContext.getSink("mysql", mysql8JsonOption).writeDynamicFrame(df_mysql5)
// Read DynamicFrame from Oracle 11 and write to Oracle 18
val df_oracle11: DynamicFrame = glueContext.getSource("oracle", oracle11JsonOption).getDynamicFrame()
glueContext.getSink("oracle", oracle18JsonOption).writeDynamicFrame(df_oracle11)
Job.commit()
}
private def jsonOptions(url: String): JsonOptions = {
new JsonOptions(
s"""{"url": "${url}",
|"dbtable":"test",
|"user": "admin",
|"password": "pwd"}""".stripMargin)
}
private def customJDBCDriverJsonOptions(url: String, customJdbcDriverS3Path: String, customJdbcDriverClassName: String): JsonOptions = {
new JsonOptions(
s"""{"url": "${url}",
|"dbtable":"test",
|"user": "admin",
|"password": "pwd",
|"customJdbcDriverS3Path": "${customJdbcDriverS3Path}",
|"customJdbcDriverClassName" : "${customJdbcDriverClassName}"}""".stripMargin)
}
}
```
------
# Lettura in parallelo dalle tabelle JDBC
Puoi impostare le proprietà della tabella JDBC per permettere a AWS Glue di leggere i dati in parallelo. Quando imposti determinate proprietà, indichi a AWS Glue di eseguire query SQL parallele su partizioni logiche dei dati. Puoi controllare il partizionamento impostando un campo hash o un'espressione hash. Puoi anche controllare il numero di operazioni di lettura parallele usate per accedere ai dati.
La lettura delle tabelle JDBC in parallelo è una tecnica di ottimizzazione che può migliorare le prestazioni. Per ulteriori informazioni sul processo di identificazione di quando questa tecnica è appropriata, consulta [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/parallelize-tasks.html) nella guida *sulle migliori pratiche per l'ottimizzazione delle prestazioni per i lavori di Apache Spark su AWS Glue AWS Prescriptive* Guidance.
Per abilitare le letture parallele, puoi impostare coppie chiave/valore nel campo dei parametri della struttura della tabella. Utilizza la notazione JSON per impostare un valore per il campo parametri della tabella. Per ulteriori informazioni sulle modifiche delle proprietà di una tabella, consulta [Visualizzazione e gestione dei dettagli della tabella](tables-described.md#console-tables-details). Puoi anche abilitare le letture parallele chiamando i metodi ETL (Extract, Transform and Load, estrazione, trasformazione e caricamento) `create_dynamic_frame_from_options` e `create_dynamic_frame_from_catalog`. Per ulteriori informazioni sulla definizione delle opzioni in questi metodi, consulta [from\$1options](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_options) e [from\$1catalog](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog).
Puoi usare questo metodo per le tabelle JDBC, ovvero la maggior parte delle tabelle i cui dati dai base costituiscono un datastore JDBC. Queste proprietà vengono ignorate quando viene eseguita la lettura delle tabelle Amazon Redshift e Amazon S3.
**hashfield**
Imposta `hashfield` sul nome di una colonna nella tabella JDBC da usare per dividere i dati in partizioni. Per ottenere risultati ottimali, questa colonna deve avere una distribuzione uniforme dei valori per distribuire i dati tra le partizioni. Questa colonna può contenere qualsiasi tipo di dati. AWS Glue genera query non sovrapposte eseguite in parallelo per leggere i dati partizionati in base a questa colonna. Ad esempio, se i dati sono distribuiti in modo uniforme in base al mese, è possibile usare la colonna `month` per leggere ogni mese di dati in parallelo.
```
'hashfield': 'month'
```
AWS Glue crea una query per l'hashing del valore di campo a un numero di partizione ed esegue la query per tutte le partizioni in parallelo. Per usare la query personalizzata per partizionare la lettura di una tabella, fornisci un oggetto `hashexpression` al posto di un oggetto `hashfield`.
**hashexpression**
Imposta `hashexpression` su un'espressione SQL (conforme alla grammatica del motore di database JDBC) che restituisce un numero intero. Un'espressione semplice è il nome di qualsiasi colonna numerica nella tabella. AWS Glue genera query SQL per leggere i dati JDBC in parallelo usando `hashexpression` nella clausola `WHERE` per partizionare i dati.
Ad esempio, è possibile usare la colonna numerica `customerID` per leggere i dati partizionati in base a un numero cliente.
```
'hashexpression': 'customerID'
```
Per fare in modo che AWS Glue controlli il partizionamento, fornisci un oggetto `hashfield` al posto di un oggetto `hashexpression`.
**hashpartitions**
Imposta `hashpartitions` sul numero di letture parallele della tabella JDBC. Se questa proprietà non viene impostata, il valore predefinito è 7.
Imposta, ad esempio, il numero di letture parallele su `5`, in modo che AWS Glue legga i dati con cinque query (o meno).
```
'hashpartitions': '5'
```
# Impostazione di Amazon VPC per le connessioni JDBC ai data store Amazon RDS su JDBC da AWS Glue
Quando si utilizza JDBC per connettersi ai database in Amazon RDS, è necessario eseguire una configurazione aggiuntiva. Per permettere la comunicazione tra i componenti AWS Glue e Amazon RDS, è necessario configurare l'accesso ai datastore Amazon RDS in Amazon VPC. Per permettere la comunicazione dei componenti di AWS Glue, specifica un gruppo di sicurezza con una regola per il traffico in entrata autoreferenziale per tutte le porte TCP. Creando una regola autoreferenziale, si può limitare l'origine allo stesso gruppo di sicurezza nel VPC. Una regola autoreferenziale non aprirà il VPC a tutte le reti. Il gruppo di sicurezza predefinito per il tuo VPC potrebbe già avere una regola autoreferenziata in entrata per ALL Traffic.
**Per configurare l'accesso tra AWS Glue e gli archivi dati Amazon RDS**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nella console Amazon RDS, identificare i gruppi di sicurezza utilizzati per controllare l'accesso al database Amazon RDS.
Nel riquadro di navigazione a sinistra, scegliere **Database**, poi selezionare l'istanza a cui ci si desidera connettersi dall'elenco nel riquadro principale.
Nella pagina dei dettagli del database, individuare i **gruppi di sicurezza di VPC** nella scheda **Connettività e sicurezza**.
1. In base all'architettura di rete, identificate quale gruppo di sicurezza associato è meglio modificare per consentire l'accesso al servizio AWS Glue. Salva il suo nome, *database-security-group* per riferimenti futuri. Se non esiste un gruppo di sicurezza appropriato, seguire le istruzioni per [Fornire l'accesso all'istanza DB nel VPC creando un gruppo di sicurezza](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) nella documentazione relativa ad Amazon RDS.
1. Accedi a Console di gestione AWS e apri la console Amazon VPC all'indirizzo. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. Nella console Amazon VPC, identifica come eseguire l'aggiornamento. *database-security-group*
Nel riquadro di navigazione a sinistra, scegli **Gruppi di sicurezza**, quindi seleziona *database-security-group* dall'elenco nel riquadro principale.
1. Identifica l'ID del gruppo di sicurezza per*database-security-group*,*database-sg-id*. Salvarlo per utilizzarlo in futuro.
Nella pagina dei dettagli del gruppo di sicurezza, individuare l'**ID del gruppo di sicurezza**.
1. Modifica le regole in entrata per*database-security-group*, aggiungi una regola di autoreferenziazione per consentire ai AWS Glue componenti di comunicare. **In particolare, aggiungi o conferma l'esistenza di una regola in cui **Type** è`All TCP`, **Protocol** è`TCP`, **Port Range** include tutte le porte e Source è.** *database-sg-id* Verificare che il gruppo di sicurezza inserito per **Origine** sia lo stesso del gruppo di sicurezza in fase di modifica.
Nella pagina dei dettagli del gruppo di sicurezza, selezionare **Modifica regole in entrata**.
La regola in entrata è simile alla seguente:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/setup-vpc-for-glue-access.html)
1. Aggiungere le regole per il traffico in uscita.
Nella pagina dei dettagli del gruppo di sicurezza, selezionare **Modifica regole in uscita**.
Se il gruppo di sicurezza abilita tutto il traffico in uscita, non sono necessarie regole separate. Esempio:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/setup-vpc-for-glue-access.html)
Se l'architettura di rete è progettata per limitare il traffico in uscita, creare le seguenti regole in uscita:
Crea una regola autoreferenziale in cui **Type** è`All TCP`, **Protocol** è`TCP`, **Port Range** include tutte le porte e **Destination** è. *database-sg-id* Verificare che il gruppo di sicurezza inserito per **Destinazione** sia lo stesso del gruppo di sicurezza in fase di modifica.
Se si utilizza un endpoint VPC Amazon S3, aggiungere una regola HTTPS per permettere il traffico dal VPC verso Amazon S3. Crea una regola in cui **Type** è`HTTPS`, **Protocol** is`TCP`, **Port Range** è `443` e **Destination** è l'ID dell'elenco di prefissi gestiti per l'endpoint gateway Amazon S3,. *s3-prefix-list-id* Per ulteriori informazioni sugli elenchi di prefissi e sugli endpoint gateway Amazon S3, consultare [Endpoint gateway per Amazon S3](https://docs.aws.amazon.com//vpc/latest/privatelink/vpc-endpoints-s3.html) nella documentazione di Amazon VPC.
Ad esempio:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/setup-vpc-for-glue-access.html)
# Connessioni MongoDB
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in MongoDB e MongoDB Atlas in Glue 4.0 e versioni successive AWS . È possibile connettersi a MongoDB utilizzando le credenziali di nome utente e password archiviate tramite una connessione Glue. Gestione dei segreti AWS AWS
Per ulteriori informazioni su MongoDB, consulta [la documentazione di MongoDB](https://www.mongodb.com/docs/).
## Configurazione delle connessioni MongoDB
Per connetterti a MongoDB AWS da Glue, avrai bisogno delle tue credenziali MongoDB e. *mongodbUser* *mongodbPass*
Per connetterti a MongoDB AWS da Glue, potresti aver bisogno di alcuni prerequisiti:
+ Se la tua istanza MongoDB si trova in un Amazon VPC, configura Amazon VPC per consentire al job Glue di comunicare con l'istanza MongoDB senza che AWS il traffico attraversi la rete Internet pubblica.
In Amazon VPC, identifica o crea un **VPC**, una **sottorete** e un **gruppo di sicurezza che** AWS Glue utilizzerà durante l'esecuzione del lavoro. Inoltre, assicurati che Amazon VPC sia configurato per consentire il traffico di rete tra l'istanza MongoDB e questa posizione. In base al layout della rete, ciò potrebbe richiedere modifiche alle regole del gruppo di sicurezza, alla rete ACLs, ai gateway NAT e alle connessioni peering.
Puoi quindi procedere alla configurazione di AWS Glue per l'uso con MongoDB.
**Per configurare una connessione a MongoDB:**
1. Facoltativamente Gestione dei segreti AWS, crea un segreto usando le tue credenziali MongoDB. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `username` con il valore. *mongodbUser*
Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `password` con il valore. *mongodbPass*
1. Nella console AWS Glue, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione*connectionName*, per utilizzi futuri in AWS Glue.
+ Quando selezioni un **tipo di connessione**, seleziona **MongoDB** o **MongoDB Atlas**.
+ Quando selezioni l'**URL MongoDB** o **URL MongoDB Atlas**, fornisci il nome host dell'istanza MongoDB.
Un URL MongoDB viene fornito nel formato `mongodb://mongoHost:mongoPort/mongoDBname`.
Un URL MongoDB Atlas viene fornito nel formato `mongodb+srv://mongoHost/mongoDBname`.
+ Se hai scelto di creare un segreto di Secrets Manager, scegli il **tipo di Gestione dei segreti AWS credenziale**.
Quindi, in **AWS Secret** fornisci*secretName*.
+ Se scegli di fornire **nome utente e password**, fornisci *mongodbUser* e*mongodbPass*.
1. Nelle seguenti situazioni, potresti aver bisogno di una configurazione aggiuntiva:
+
Per le istanze MongoDB ospitate su AWS un Amazon VPC
+ Dovrai fornire le informazioni di connessione Amazon VPC alla connessione AWS Glue che definisce le tue credenziali di sicurezza MongoDB. Durante la creazione o l'aggiornamento della connessione, imposta **VPC**, **sottorete** e **Gruppi di sicurezza** nelle **opzioni di rete**.
Dopo aver creato una connessione AWS Glue MongoDB, dovrai eseguire le seguenti azioni prima di chiamare il tuo metodo di connessione:
+ Se hai scelto di creare un segreto di Secrets Manager, concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*.
+ Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
Per utilizzare la tua connessione AWS Glue MongoDB in AWS Glue for Spark, fornisci `connectionName` l'opzione nella chiamata al metodo di connessione. In alternativa, puoi seguire i passaggi [Lavorare con le connessioni MongoDB nei processi ETL](integrate-with-mongo-db.md) per utilizzare la connessione insieme al AWS Glue Data Catalog.
## Lettura da MongoDB utilizzando una connessione Glue AWS
**Prerequisiti:**
+ Una raccolta MongoDB da cui desideri leggere. Avrai bisogno delle informazioni di identificazione per la raccolta.
Una raccolta MongoDB è identificata da un nome di database e da un nome di raccolta,,. *mongodbName* *mongodbCollection*
+ Una connessione AWS Glue MongoDB configurata per fornire informazioni di autenticazione. Completa i passaggi della procedura precedente, *Per configurare una connessione a MongoDB* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
mongodb_read = glueContext.create_dynamic_frame.from_options(
connection_type="mongodb",
connection_options={
"connectionName": "connectionName",
"database": "mongodbName",
"collection": "mongodbCollection",
"partitioner": "com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id",
"disableUpdateUri": "false",
}
)
```
## Scrittura su tabelle MongoDB
Questo esempio scrive informazioni da un file esistente DynamicFrame *dynamicFrame* a MongoDB.
**Prerequisiti:**
+ Una raccolta MongoDB su cui desideri scrivere. Avrai bisogno delle informazioni di identificazione per la raccolta.
Una raccolta MongoDB è identificata da un nome di database e da un nome di raccolta,,. *mongodbName* *mongodbCollection*
+ Una connessione AWS Glue MongoDB configurata per fornire informazioni di autenticazione. Completa i passaggi della procedura precedente, *Per configurare una connessione a MongoDB* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="mongodb",
connection_options={
"connectionName": "connectionName",
"database": "mongodbName",
"collection": "mongodbCollection",
"disableUpdateUri": "false",
"retryWrites": "false",
},
)
```
## Lettura e scrittura in tabelle su tabelle MongoDB
Questo esempio scrive informazioni da un file esistente DynamicFrame *dynamicFrame* a MongoDB.
**Prerequisiti:**
+ Una raccolta MongoDB da cui desideri leggere. Avrai bisogno delle informazioni di identificazione per la raccolta.
Una raccolta MongoDB su cui desideri scrivere. Avrai bisogno delle informazioni di identificazione per la raccolta.
Una raccolta MongoDB è identificata da un nome di database e da un nome di raccolta,,. *mongodbName* *mongodbCollection*
+ Informazioni di autenticazione MongoDB e. *mongodbUser* *mongodbPassword*
Esempio:
------
#### [ Python ]
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
mongo_uri = "mongodb://:27017"
mongo_ssl_uri = "mongodb://:27017"
write_uri = "mongodb://:27017"
read_mongo_options = {
"uri": mongo_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"username": "mongodbUsername",
"password": "mongodbPassword",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"}
ssl_mongo_options = {
"uri": mongo_ssl_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"ssl": "true",
"ssl.domain_match": "false"
}
write_mongo_options = {
"uri": write_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"username": "mongodbUsername",
"password": "mongodbPassword",
}
# Get DynamicFrame from MongoDB
dynamic_frame = glueContext.create_dynamic_frame.from_options(connection_type="mongodb",
connection_options=read_mongo_options)
# Write DynamicFrame to MongoDB
glueContext.write_dynamic_frame.from_options(dynamicFrame, connection_type="mongodb", connection_options=write_mongo_options)
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DEFAULT_URI: String = "mongodb://:27017"
val WRITE_URI: String = "mongodb://:27017"
lazy val defaultJsonOption = jsonOptions(DEFAULT_URI)
lazy val writeJsonOption = jsonOptions(WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from MongoDB
val dynamicFrame: DynamicFrame = glueContext.getSource("mongodb", defaultJsonOption).getDynamicFrame()
// Write DynamicFrame to MongoDB
glueContext.getSink("mongodb", writeJsonOption).writeDynamicFrame(dynamicFrame)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"mongodbName",
|"collection":"mongodbCollection",
|"username": "mongodbUsername",
|"password": "mongodbPassword",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
------
## Indicazioni di riferimento alle opzioni di connessione a MongoDB
Designa una connessione a MongoDB. Le opzioni di connessione differiscono per una connessione sorgente e una connessione sink.
Queste proprietà di connessione sono condivise tra le connessioni di origine e sink:
+ `connectionName`: utilizzato per la lettura/scrittura. Il nome di una connessione AWS Glue MongoDB configurata per fornire informazioni di autenticazione e di rete al metodo di connessione. Quando una connessione AWS Glue è configurata come descritto nella sezione precedente[Configurazione delle connessioni MongoDB](#aws-glue-programming-etl-connect-mongodb-configure), la fornitura `connectionName` sostituirà la necessità di fornire le `"uri"` opzioni di `"password"` connessione `"username"` e.
+ `"uri"`: (Obbligatorio) L'host MongoDB da cui leggere, formattato come `mongodb://:`. Utilizzato nelle versioni AWS Glue precedenti a AWS Glue 4.0.
+ `"connection.uri"`: (Obbligatorio) L'host MongoDB da cui leggere, formattato come `mongodb://:`. Utilizzato in AWS Glue 4.0 e versioni successive.
+ `"username"`: (Obbligatorio) Il nome utente MongoDB.
+ `"password"`: (Obbligatorio) La password di MongoDB.
+ `"database"`: (Obbligatorio) Il database MongoDB da cui leggere. Questa opzione può anche essere trasmessa in `additional_options` quando si chiama `glue_context.create_dynamic_frame_from_catalog` nello script di processo.
+ `"collection"`: (Obbligatorio) La raccolta MongoDB da cui leggere. Questa opzione può anche essere trasmessa in `additional_options` quando si chiama `glue_context.create_dynamic_frame_from_catalog` nello script di processo.
### "connectionType": "mongodb" come sorgente
Utilizzare le seguenti opzioni di connessione con `"connectionType": "mongodb"` come origine:
+ `"ssl"`: (Facoltativo) Se il valore è `true`, avvia una connessione SSL. Il valore predefinito è `false`.
+ `"ssl.domain_match"`: (Facoltativo) Se i valori `true` e `ssl` sono `true`, viene eseguito il controllo della corrispondenza del dominio. Il valore predefinito è `true`.
+ `"batchSize"`: (Facoltativo): il numero di documenti da restituire per ogni batch, utilizzato all'interno del cursore dei batch interni.
+ `"partitioner"`: (Facoltativo): il nome della classe del partizionatore per la lettura dei dati di input da MongoDB. Il connettore fornisce i seguenti partizionatori:
+ `MongoDefaultPartitioner`(impostazione predefinita) (non supportato in AWS Glue 4.0)
+ `MongoSamplePartitioner`(Richiede MongoDB 3.2 o successivo) (non supportato in AWS Glue 4.0)
+ `MongoShardedPartitioner`(Non supportato in AWS Glue 4.0)
+ `MongoSplitVectorPartitioner`(Non supportato in AWS Glue 4.0)
+ `MongoPaginateByCountPartitioner`(Non supportato in AWS Glue 4.0)
+ `MongoPaginateBySizePartitioner`(Non supportato in AWS Glue 4.0)
+ `com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner`
+ `com.mongodb.spark.sql.connector.read.partitioner.ShardedPartitioner`
+ `com.mongodb.spark.sql.connector.read.partitioner.PaginateIntoPartitionsPartitioner`
+ `"partitionerOptions"` ( Facoltativo): opzioni per il partizionatore designato. Per ogni partizionatore sono supportate le seguenti opzioni:
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner`: `partitionKey`, `partitionSizeMB`
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner`: `partitionKey`, `partitionSizeMB`
Per ulteriori informazioni su queste opzioni, vedere [Partitioner Configuration (Configurazione partizionatore)](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) nella documentazione di MongoDB.
### "connectionType": "mongodb" come sink
Utilizzare le seguenti opzioni di connessione con `"connectionType": "mongodb"` come sink:
+ `"ssl"`: (Facoltativo) Se il valore è `true`, avvia una connessione SSL. Il valore predefinito è `false`.
+ `"ssl.domain_match"`: (Facoltativo) Se i valori `true` e `ssl` sono `true`, viene eseguito il controllo della corrispondenza del dominio. Il valore predefinito è `true`.
+ `"extendedBsonTypes"`: (Facoltativo) Se il valore è`true`, permette i tipi BSON estesi durante la scrittura di dati su MongoDB. Il valore predefinito è `true`.
+ `"replaceDocument"`: (Facoltativo) Se il valore è `true`, sostituisce l'intero documento quando si salvano set di dati che contengono un campo `_id`. Se il valore è `false`, vengono aggiornati solo i campi del documento che corrispondono ai campi del set di dati. Il valore predefinito è `true`.
+ `"maxBatchSize"`: (Facoltativo): la dimensione massima del batch per le operazioni in blocco durante il salvataggio dei dati. Il valore predefinito è 512.
+ `"retryWrites"`: (Facoltativo): Riprova automaticamente alcune operazioni di scrittura una sola volta se AWS Glue rileva un errore di rete.
# Connessioni SAP HANA
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in SAP HANA in AWS Glue 4.0 e versioni successive. È possibile definire cosa leggere da SAP HANA con una query SQL. Ti connetti a SAP HANA utilizzando le credenziali JDBC archiviate tramite Gestione dei segreti AWS una connessione AWS Glue SAP HANA.
Per ulteriori informazioni sulle porte SAP HANA JDBC, consulta la [documentazione SAP HANA](https://help.sap.com/docs/SAP_HANA_PLATFORM/0eec0d68141541d1b07893a39944924e/ff15928cf5594d78b841fbbe649f04b4.html).
## Configurazione delle connessioni SAP HANA
Per connetterti a SAP HANA da AWS Glue, dovrai creare e archiviare le tue credenziali SAP HANA in un Gestione dei segreti AWS segreto, quindi associare quel segreto a una connessione SAP HANA Glue. AWS Dovrai configurare la connettività di rete tra il tuo servizio SAP HANA e AWS Glue.
Per connetterti a SAP HANA, potrebbero essere necessari alcuni prerequisiti:
+ Se il tuo servizio SAP HANA si trova in un Amazon VPC, configura Amazon VPC per consentire al job AWS Glue di comunicare con il servizio SAP HANA senza che il traffico attraversi la rete Internet pubblica.
In Amazon VPC, identifica o crea un **VPC**, una **sottorete** e un **gruppo di sicurezza che** AWS Glue utilizzerà durante l'esecuzione del lavoro. Inoltre, assicurati che Amazon VPC sia configurato per consentire il traffico di rete tra l'endpoint SAP HANA e questa posizione. Il tuo processo dovrà stabilire una connessione TCP con la tua porta SAP HANA JDBC. Per ulteriori informazioni sulle porte SAP HANA, consulta la [documentazione SAP HANA.](https://help.sap.com/docs/HANA_SMART_DATA_INTEGRATION/7952ef28a6914997abc01745fef1b607/88e2e8bded9e4041ad3ad87dc46c7b55.html?locale=en-US) In base al layout della rete, ciò potrebbe richiedere modifiche alle regole del gruppo di sicurezza, alla rete ACLs, ai gateway NAT e alle connessioni peering.
+ Non ci sono prerequisiti aggiuntivi se l'endpoint SAP HANA è accessibile a Internet.
**Per configurare una connessione a SAP HANA:**
1. Nel Gestione dei segreti AWS, crea un segreto utilizzando le tue credenziali SAP HANA. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `username/USERNAME` con il valore. *saphanaUsername*
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `password/PASSWORD` con il valore. *saphanaPassword*
1. Nella console AWS Glue, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione*connectionName*, per utilizzi futuri in AWS Glue.
+ In **Tipo di connessione**, seleziona SAP HANA.
+ Quando fornisci l'**URL SAP HANA**, fornisci l'URL per la tua istanza.
SAP HANA JDBC URLs sono nel formato `jdbc:sap://saphanaHostname:saphanaPort/?databaseName=saphanaDBname,ParameterName=ParameterValue`
AWS Glue richiede i seguenti parametri URL JDBC:
+ `databaseName`: un database predefinito in SAP HANA a cui connettersi.
+ Quando selezioni un **AWS segreto, fornisci**. *secretName*
Dopo aver creato una connessione AWS Glue SAP HANA, dovrai eseguire i seguenti passaggi prima di eseguire il lavoro AWS Glue:
+ Concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*.
+ Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
## Lettura da tabelle SAP HANA
**Prerequisiti:**
+ Una tabella SAP HANA da cui si desidera leggere. Avrai bisogno delle informazioni di identificazione per la tabella.
Una tabella può essere specificata con un nome di tabella SAP HANA e di schema, nel modulo `schemaName.tableName`. Il nome dello schema e il separatore "." non sono necessari se la tabella si trova nello schema predefinito, "pubblico". Chiama questo*tableIdentifier*. Il database viene fornito come parametro URL JDBC in `connectionName`.
+ Una connessione AWS Glue SAP HANA configurata per fornire informazioni di autenticazione. Completa i passaggi della procedura precedente, *Per configurare una connessione a SAP HANA* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
saphana_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="saphana",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier",
}
)
```
Puoi anche fornire una query SQL SELECT per filtrare i risultati restituiti al tuo DynamicFrame. Sarà necessario configurare `query`.
Esempio:
```
saphana_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="saphana",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Scrittura su tabelle SAP HANA
Questo esempio scrive informazioni da un sistema esistente DynamicFrame *dynamicFrame* a SAP HANA. Se la tabella contiene già informazioni, AWS Glue genererà un errore.
**Prerequisiti:**
+ Una tabella SAP HANA su cui scrivere.
Una tabella può essere specificata con un nome di tabella SAP HANA e di schema, nel modulo `schemaName.tableName`. Il nome dello schema e il separatore "." non sono necessari se la tabella si trova nello schema predefinito, "pubblico". Chiama questo*tableIdentifier*. Il database viene fornito come parametro URL JDBC in `connectionName`.
+ Informazioni di autenticazione SAP HANA. Completa i passaggi della procedura precedente, *Per configurare una connessione a SAP HANA* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
options = {
"connectionName": "connectionName",
"dbtable": 'tableIdentifier'
}
saphana_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="saphana",
connection_options=options
)
```
## Indicazioni di riferimento alle opzioni di connessione a SAP HANA
+ `connectionName`: obbligatorio. Utilizzato per la lettura/scrittura. Il nome di una connessione AWS Glue SAP HANA configurata per fornire informazioni di autenticazione e di rete al metodo di connessione.
+ `databaseName`: utilizzato per la lettura/scrittura. Valori validi: nomi dei database in SAP HANA. Nome del database a cui connettersi.
+ `dbtable` — Richiesto per la scrittura, richiesto per la lettura a meno che non `query` sia fornito. Utilizzato per la lettura/scrittura. Valori validi: contenuto di una clausola SAP HANA SQL FROM. Identifica una tabella in SAP HANA a cui connettersi. È inoltre possibile fornire un codice SQL diverso dal nome della tabella, ad esempio una sottoquery. Per ulteriori informazioni, consulta la [clausola From](https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/20fcf24075191014a89e9dc7b8408b26.html#loio20fcf24075191014a89e9dc7b8408b26__from_clause) nella documentazione di SAP HANA.
+ `query`: utilizzato per la lettura. Una query SAP HANA SQL SELECT che definisce cosa recuperare durante la lettura da SAP HANA.
# Connessioni Snowflake
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in Snowflake in AWS Glue 4.0 e versioni successive. È possibile leggere da Snowflake con una query SQL. È possibile connettersi a Snowflake utilizzando un utente e una password. Puoi fare riferimento alle credenziali Snowflake archiviate nel AWS Glue Gestione dei segreti AWS Data Catalog. Le credenziali Data Catalog Snowflake per AWS Glue for Spark vengono archiviate separatamente dalle credenziali Data Catalog Snowflake per i crawler. È necessario scegliere un tipo di connessione `SNOWFLAKE` e non un tipo di connessione `JDBC`configurato per la connessione a Snowflake.
Per ulteriori informazioni su Snowflake, consulta il [sito Web di Snowflake](https://www.snowflake.com/). Per ulteriori informazioni su Snowflake on AWS, consulta [Snowflake Data Warehouse on Amazon Web Services](https://aws.amazon.com/financial-services/partner-solutions/snowflake/).
## Configurazione delle connessioni Snowflake
Non ci sono AWS prerequisiti per la connessione ai database Snowflake disponibili tramite Internet.
Facoltativamente, puoi eseguire la seguente configurazione per gestire le credenziali di connessione con AWS Glue.
**Per gestire le credenziali di connessione con AWS Glue**
1. In Snowflake, genera un utente *snowflakeUser* e una password,. *snowflakePassword*
1. Nel Gestione dei segreti AWS, crea un segreto usando le tue credenziali Snowflake. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html#create_secret_cli) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezionate **coppie chiave/valore**, create una coppia per *snowflakeUser* con la chiave. `USERNAME`
+ Quando selezionate **coppie chiave/valore**, create una coppia per *snowflakePassword* con la chiave. `PASSWORD`
+ Quando si selezionano le **coppie chiave/valore**, è possibile fornire la chiave `sfWarehouse` al proprio warehouse Snowflake.
+ Quando si selezionano **coppie chiave/valore**, è possibile indicare proprietà di connessione Snowflake aggiuntive utilizzando i nomi delle proprietà Spark corrispondenti come chiavi. Tra le proprietà supportate vi sono:
+ `sfDatabase`: nome del database Snowflake
+ `sfSchema`: nome dello schema Snowflake
+ `sfRole`: nome del ruolo Snowflake
+ `pem_private_key`: chiave privata per l'autenticazione chiave-coppia
1. Nel AWS Glue Data Catalog, crea una connessione scegliendo **Connessioni**, quindi **Crea connessione**. Seguire la procedura guidata di connessione per completare il processo:
+ Al momento di scegliere un'**Origine dati**, selezionare Snowflake, poi **Avanti**.
+ Inserire i dettagli della connessione, come l'host e la porta. Al momento di inserire l'**URL Snowflake** dell'host, indicare l'URL dell'istanza Snowflake. Generalmente, l'URL utilizza un nome host nel modulo `account_identifier.snowflakecomputing.com`. Tuttavia, il formato dell'URL può variare a seconda del tipo di account Snowflake (ad esempio AWS, Azure o Snowflake-hosted).
+ Al momento di selezionare il ruolo di servizio IAM, scegliere un'opzione dal menu a discesa. Questo è il ruolo IAM del tuo account che verrà utilizzato per accedere Gestione dei segreti AWS e assegnare l'IP se viene specificato VPC.
+ Quando selezioni un **AWS segreto, fornisci**. *secretName*
1. Nel passaggio successivo della procedura guidata, impostare le proprietà della connessione Snowflake.
1. Nel passaggio finale della procedura guidata, rivedere le impostazioni e completare il processo per creare la connessione.
Nelle seguenti situazioni, potrebbe essere necessario quanto segue:
+
Per Snowflake ospitato su un AWS Amazon VPC
+ Per Snowflake è necessaria una configurazione Amazon VPC appropriata. Per ulteriori informazioni su come configurare il tuo Amazon VPC, consultare la sezione [AWS PrivateLink & Snowflake](https://docs.snowflake.com/en/user-guide/admin-security-privatelink) nella documentazione di Snowflake.
+ Avrai bisogno di una configurazione Amazon VPC appropriata per AWS Glue. [Configurazione degli endpoint VPC (AWS PrivateLink) per AWS Glue (AWS PrivateLink)](vpc-interface-endpoints.md).
+ Dovrai creare una connessione AWS Glue Data Catalog che fornisca le informazioni di connessione Amazon VPC (oltre all'ID di un Gestione dei segreti AWS segreto che definisce le tue credenziali di sicurezza Snowflake). L'URL cambierà durante l'utilizzo AWS PrivateLink, come descritto nella documentazione Snowflake collegata in un elemento precedente.
+ È necessario che la configurazione del processo includa la connessione a Catalogo dati come **Connessione di rete aggiuntiva**.
## Lettura dalle tabelle Snowflake
**Prerequisiti:** una tabella Snowflake da cui desideri leggere. Avrai bisogno del nome della tabella Snowflake,. *tableName* Avrai bisogno dell'URL*snowflakeUrl*, del nome utente e della password di Snowflake. *snowflakeUser* *snowflakePassword* Se il tuo utente Snowflake non dispone di uno spazio dei nomi predefinito, avrai bisogno del nome del database Snowflake e del nome dello schema. *databaseName* *schemaName* Inoltre, se il tuo utente Snowflake non dispone di un set di warehouse predefinito, avrai bisogno di un nome di warehouse. *warehouseName*
Esempio:
**Prerequisiti aggiuntivi:** completa i passaggi *per gestire le credenziali di connessione con AWS Glue* per configurare*snowflakeUrl*, *snowflakeUsername* e. *snowflakePassword* Per esaminare questi passaggi, consulta [Configurazione delle connessioni Snowflake](#aws-glue-programming-etl-connect-snowflake-configure), la sezione precedente. Per selezionare la **connessione di rete aggiuntiva** con la quale connettersi, utilizzeremo il parametro `connectionName`.
```
snowflake_read = glueContext.create_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
}
)
```
Inoltre, puoi utilizzare i parametri `autopushdown` e `query` per leggere una parte di una tabella Snowflake. Questo può essere molto più efficiente rispetto al filtraggio dei risultati dopo che sono stati caricati in Spark. Prendiamo in esame un esempio in cui tutte le vendite sono archiviate nella stessa tabella, ma è necessario analizzare solo le vendite di un determinato negozio nei giorni festivi. Se tali informazioni sono archiviate nella tabella, è possibile utilizzare il predicato pushdown per recuperare i risultati come segue:
```
snowflake_node = glueContext.create_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"autopushdown": "on",
"query": "select * from sales where store='1' and IsHoliday='TRUE'",
"connectionName": "snowflake-glue-conn",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
}
)
```
## Scrittura su tabelle Snowflake
**Prerequisiti:** un database Snowflake su cui scrivere. Avrai bisogno di un nome di tabella attuale o desiderato,. *tableName* Avrai bisogno dell'URL*snowflakeUrl*, del nome utente *snowflakeUser* e della password di Snowflake. *snowflakePassword* Se il tuo utente Snowflake non dispone di uno spazio dei nomi predefinito, avrai bisogno del nome del database Snowflake e del nome dello schema. *databaseName* *schemaName* Inoltre, se il tuo utente Snowflake non dispone di un set di warehouse predefinito, avrai bisogno di un nome di warehouse. *warehouseName*
Esempio:
**Prerequisiti aggiuntivi:** completa i passaggi *per gestire le credenziali di connessione con AWS Glue* per configurare*snowflakeUrl*, *snowflakeUsername* e. *snowflakePassword* Per esaminare questi passaggi, consulta [Configurazione delle connessioni Snowflake](#aws-glue-programming-etl-connect-snowflake-configure), la sezione precedente. Per selezionare la **connessione di rete aggiuntiva** con la quale connettersi, utilizzeremo il parametro `connectionName`.
```
glueContext.write_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
},
)
```
## Indicazioni di riferimento alle opzioni di connessione a Snowflake
Il tipo di connessione Snowflake accetta le seguenti opzioni di connessione:
È possibile recuperare alcuni dei parametri di questa sezione da una connessione a Catalogo dati (`sfUrl`, `sfUser` e `sfPassword`), nel qual caso non è necessario fornirli. È possibile farlo fornendo il parametro `connectionName`.
È possibile recuperare i parametri di connessione dai Gestione dei segreti AWS segreti utilizzando il parametro. `secretId` Quando si utilizza Secrets Manager, è possibile recuperare automaticamente le seguenti proprietà Spark, se presenti nel segreto:
+ `sfUser` (utilizzando la chiave `USERNAME` o `sfUser`)
+ `sfPassword` (utilizzando la chiave `PASSWORD` o `sfPassword`)
+ `sfWarehouse` (utilizzando la chiave `sfWarehouse`)
+ `sfDatabase` (utilizzando la chiave `sfDatabase`)
+ `sfSchema` (utilizzando la chiave `sfSchema`)
+ `sfRole` (utilizzando la chiave `sfRole`)
+ `pem_private_key` (utilizzando la chiave `pem_private_key`)
**Ordine di precedenza delle proprietà:** quando la stessa proprietà viene specificata in più posizioni, AWS Glue utilizza il seguente ordine di precedenza (dal più alto al più basso):
1. Opzioni di connessione indicate esplicitamente nel codice del processo
1. Proprietà di connessione del Catalogo dati
1. Gestione dei segreti AWS valori segreti (quando `secretId` viene specificato)
1. Impostazioni predefinite dell'utente Snowflake
Per la connessione a Snowflake generalmente vengono utilizzati i seguenti parametri.
+ `sfDatabase`: obbligatorio se in Snowflake non è impostato un valore predefinito per l'utente. Utilizzato per la lettura/scrittura. Il database da utilizzare per la sessione dopo la connessione.
+ `sfSchema`: obbligatorio se in Snowflake non è impostato un valore predefinito per l'utente. Utilizzato per la lettura/scrittura. Lo schema da utilizzare per la sessione dopo la connessione.
+ `sfWarehouse`: obbligatorio se in Snowflake non è impostato un valore predefinito per l'utente. Utilizzato per la lettura/scrittura. Il warehouse virtuale predefinito da utilizzare per la sessione dopo la connessione.
+ `sfRole`: obbligatorio se in Snowflake non è impostato un valore predefinito per l'utente. Utilizzato per la lettura/scrittura. Il ruolo di sicurezza predefinito da utilizzare per la sessione dopo la connessione.
+ `sfUrl`: (obbligatorio) utilizzato per la lettura/scrittura. Specifica il nome host del tuo account nel seguente formato: `account_identifier.snowflakecomputing.com`. Per ulteriori informazioni sugli identificatori di account, consulta la pagina [Account Identifiers](https://docs.snowflake.com/en/user-guide/admin-account-identifier) nella documentazione di Snowflake.
+ `sfUser`: (obbligatorio) utilizzato per la lettura/scrittura. Il nome di accesso per l'utente Snowflake.
+ `sfPassword` (obbligatorio se non viene fornito `pem_private_key`). Utilizzato per lettura/scrittura. La password per l'utente Snowflake.
+ `dbtable`: obbligatorio quando si lavora con tabelle complete. Utilizzato per la lettura/scrittura. Il nome della tabella da leggere o la tabella in cui vengono scritti i dati. Durante la lettura, vengono recuperate tutte le colonne e i record.
+ `pem_private_key`: utilizzato per la lettura/scrittura. Una stringa di chiave privata non crittografata con codifica b64. La chiave privata per l'utente Snowflake. È comune copiare tale chiave da un file PEM. Per ulteriori informazioni, consulta [Autenticazione e rotazione delle coppie di chiavi](https://docs.snowflake.com/en/user-guide/key-pair-auth) nella documentazione di Snowflake.
+ `query`: obbligatorio durante la lettura con una query. Utilizzato per la lettura. La query esatta (istruzione `SELECT`) da eseguire
Le seguenti opzioni vengono utilizzate per configurare comportamenti specifici durante il processo di connessione a Snowflake.
+ `preactions`: utilizzato per la lettura/scrittura. Valori validi: elenco di istruzioni SQL separato da punto e virgola in formato stringa. Le istruzioni SQL vengono eseguite prima del trasferimento dei dati tra AWS Glue e Snowflake. Se un'istruzione contiene `%s`, `%s` viene sostituito con il nome della tabella a cui si fa riferimento per l'operazione.
+ `postactions`: utilizzato per la lettura/scrittura. Le istruzioni SQL vengono eseguite dopo il trasferimento dei dati tra AWS Glue e Snowflake. Se un'istruzione contiene `%s`, `%s` viene sostituito con il nome della tabella a cui si fa riferimento per l'operazione.
+ `autopushdown`: valore predefinito: `"on"`. Valori validi: `"on"`, `"off"`. Questo parametro controlla se il pushdown automatico delle query è abilitato. Se il pushdown è abilitato, quando su Spark viene eseguita una query, se una parte di essa può essere "trasferita" al server Snowflake, viene sottoposta a pushdown. Ciò migliora le prestazioni di alcune query. Per sapere se la tua query può essere spostata verso il basso, consulta la sezione [Pushdown](https://docs.snowflake.com/en/user-guide/spark-connector-use#pushdown) nella documentazione di Snowflake.
Inoltre, alcune delle opzioni disponibili sul connettore Snowflake Spark potrebbero essere supportate in Glue. AWS Per ulteriori informazioni sulle opzioni disponibili sul connettore Snowflake Spark, consulta la sezione [Setting Configuration Options for the Connector](https://docs.snowflake.com/en/user-guide/spark-connector-use#setting-configuration-options-for-the-connector) nella documentazione di Snowflake.
## Metodi di autenticazione per Snowflake
AWS Glue supporta i seguenti metodi di autenticazione per la connessione a Snowflake:
+ **Autenticazione con nome utente e password:** fornire i parametri `sfUser` e `sfPassword`.
+ **Autenticazione chiave-coppia:** fornire i parametri `sfUser` e `pem_private_key`. Quando si utilizza l'autenticazione chiave-coppia, il parametro `sfPassword` non è richiesto.
Entrambi i metodi di autenticazione sono completamente supportati e possono essere configurati utilizzando qualsiasi combinazione di opzioni di connessione, connessioni Data Catalog o Gestione dei segreti AWS segreti.
## Limitazioni del connettore Snowflake
La connessione a Snowflake con AWS Glue for Spark è soggetta alle seguenti limitazioni.
+ Questo connettore non supporta i segnalibri di processo. Per ulteriori informazioni sui segnalibri di processo, consultare [Monitoraggio dei dati elaborati mediante segnalibri di processo](monitor-continuations.md).
+ Questo connettore non supporta la lettura e la scrittura di Snowflake tramite tabelle nel AWS Glue Data Catalog utilizzando i `create_dynamic_frame.from_catalog` metodi and. `write_dynamic_frame.from_catalog`
+ Questo connettore supporta l' username/password autenticazione e l'autenticazione tramite coppia di chiavi. Altri metodi di autenticazione (come OAuth o SAML) non sono attualmente supportati.
+ Questo connettore non è supportato nei processi di flussi di dati.
+ Questo connettore supporta le query basate su istruzioni `SELECT` per il recupero di informazioni, ad esempio con il parametro `query`. Altri tipi di query (ad esempio istruzioni DML, `SHOW` o `DESC`) non sono supportati.
+ Snowflake limita la dimensione del testo della query (ad esempio istruzioni SQL) inviato tramite i client Snowflake a 1 MB per istruzione. Per ulteriori informazioni, consulta la pagina [Limits on Query Text Size](https://docs.snowflake.com/en/user-guide/query-size-limits).
# Connessioni Teradata Vantage
È possibile utilizzare AWS Glue for Spark per leggere e scrivere su tabelle esistenti in Teradata Vantage in AWS Glue 4.0 e versioni successive. È possibile definire cosa leggere da Teradata con una query SQL. È possibile connettersi a Teradata utilizzando le credenziali di nome utente e password memorizzate tramite Gestione dei segreti AWS una connessione AWS Glue.
Per ulteriori informazioni su Teradata, consulta la [documentazione di Teradata](https://docs.teradata.com/).
## Configurazione delle connessioni Teradata
Per connetterti a Teradata da AWS Glue, dovrai creare e archiviare le tue credenziali Teradata in un luogo Gestione dei segreti AWS segreto, quindi associare quel segreto a una connessione Glue Teradata. AWS Se la tua istanza Teradata si trova in un Amazon VPC, dovrai anche fornire opzioni di rete alla tua connessione AWS Glue Teradata.
Per connettersi a Teradata da AWS Glue, potrebbero essere necessari alcuni prerequisiti:
+ Se accedi al tuo ambiente Teradata tramite Amazon VPC, configura Amazon VPC per consentire al tuo job AWS Glue di comunicare con l'ambiente Teradata. Sconsigliamo l'accesso all'ambiente Teradata tramite la rete Internet pubblica.
In Amazon VPC, identifica o crea un **VPC**, una **sottorete** e un **gruppo di sicurezza che** AWS Glue utilizzerà durante l'esecuzione del lavoro. Inoltre, assicurati che Amazon VPC sia configurato per consentire il traffico di rete tra l'istanza Teradata e questa posizione. Il tuo processo dovrà stabilire una connessione TCP con la tua porta del client Teradata. Per ulteriori informazioni sulle porte Teradata, consulta la [documentazione di Teradata](https://docs.teradata.com/r/Teradata-VantageTM-on-AWS-DIY-Installation-and-Administration-Guide/April-2020/Before-Deploying-Vantage-on-AWS-DIY/Security-Groups-and-Ports).
In base al layout di rete, la connettività VPC sicura potrebbe richiedere modifiche ad Amazon VPC e ad altri servizi di rete. Per ulteriori informazioni sulla AWS connettività, consulta le [opzioni di AWS connettività nella documentazione di Teradata](https://docs.teradata.com/r/Teradata-VantageCloud-Enterprise/Get-Started/Connecting-Your-Environment/AWS-Connectivity-Options).
**Per configurare una connessione AWS Glue Teradata:**
1. Nella configurazione Teradata, identifica o crea un utente e una password con cui AWS Glue si connetterà, *teradataUser* e. *teradataPassword* Per ulteriori informazioni, consulta [Vantage Security Overview](https://docs.teradata.com/r/Configuring-Teradata-VantageTM-After-Installation/January-2021/Security-Overview/Vantage-Security-Overview) nella documentazione di Teradata.
1. Nel Gestione dei segreti AWS, crea un segreto usando le tue credenziali Teradata. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `user` con il valore. *teradataUsername*
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `password` con il valore. *teradataPassword*
1. Nella console AWS Glue, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione per il passaggio successivo. *connectionName*
+ In **Tipo di connessione**, seleziona Snowflake.
+ Quando fornisci **JDBC URL**, fornisci l'URL per la tua istanza. Puoi anche codificare determinati parametri di connessione, separati da virgole, nel tuo URL JDBC. L'URL deve rispettare il seguente formato: `jdbc:teradata://teradataHostname/ParameterName=ParameterValue,ParameterName=ParameterValue`
I parametri URL supportati includono:
+ `DATABASE`: nome del database sull'host a cui accedere per impostazione predefinita.
+ `DBS_PORT`: la porta del database, utilizzata con una porta non standard.
+ Quando selezioni un **tipo di credenziale**, seleziona **Gestione dei segreti AWS**, quindi imposta **AWS Segreto** *secretName* su.
1. Nelle seguenti situazioni, potresti aver bisogno di una configurazione aggiuntiva:
+
Per le istanze Teradata ospitate su AWS un Amazon VPC
+ Dovrai fornire le informazioni di connessione Amazon VPC alla connessione AWS Glue che definisce le tue credenziali di sicurezza Teradata. Durante la creazione o l'aggiornamento della connessione, imposta **VPC**, **sottorete** e **Gruppi di sicurezza** nelle **opzioni di rete**.
Dopo aver creato una connessione AWS Glue Teradata, dovrai eseguire i seguenti passaggi prima di chiamare il metodo di connessione.
+ Concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*.
+ Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
## Lettura da Teradata
**Prerequisiti:**
+ Una tabella Teradata da cui si desidera leggere. Avrai bisogno del nome della tabella,*tableName*.
+ Una connessione AWS Glue Teradata configurata per fornire informazioni di autenticazione. Completa i passaggi *Per configurare una connessione a Teradata* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
Esempio:
```
teradata_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName"
}
)
```
Puoi anche fornire una query SQL SELECT per filtrare i risultati restituiti al tuo DynamicFrame. Sarà necessario configurare `query`.
Esempio:
```
teradata_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Scrittura su tabelle Teradata
**Prerequisiti:** una tabella Teradata su cui scrivere,. *tableName* **È necessario creare la tabella prima di chiamare il metodo di connessione.**
Esempio:
```
teradata_write = glueContext.write_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName"
}
)
```
## Indicazioni di riferimento alle opzioni di connessione a Teradata
+ `connectionName`: obbligatorio. Utilizzato per la lettura/scrittura. Il nome di una connessione AWS Glue Teradata configurata per fornire informazioni di autenticazione e di rete al metodo di connessione utilizzato.
+ `dbtable` — Richiesto per la scrittura, richiesto per la lettura a meno che non `query` sia fornito. Utilizzato per la lettura/scrittura. Il nome di una tabella con cui interagirà il metodo di connessione.
+ `query`: utilizzato per la lettura. Una query SELECT SQL che definisce cosa recuperare durante la lettura da Teradata.
# Connessioni Teradata Vantage NOS
La connessione Teradata NOS (Native Object Store) è una nuova connessione per Teradata Vantage che sfrutta la query Teradata WRITE\$1NOS per leggere dalle tabelle esistenti e la query READ\$1NOS per scrivere nelle tabelle. Queste query usano Amazon S3 come directory di staging e, pertanto, il connettore Teradata NOS è più veloce del connettore Teradata esistente (basato su JDBC), specialmente nella gestione di grandi quantità di dati.
È possibile utilizzare la connessione Teradata NOS in Spark AWS Glue per leggere e scrivere su tabelle esistenti in Teradata Vantage nella versione 5.0 e successive. AWS Glue È possibile definire cosa leggere da Teradata con una query SQL. È possibile connettersi a Teradata utilizzando le credenziali di nome utente e password memorizzate tramite una connessione. Gestione dei segreti AWS AWS Glue
Per ulteriori informazioni su Teradata, consulta la [documentazione di Teradata](https://docs.teradata.com/).
**Topics**
+ [Creazione di una connessione Teradata NOS](#creating-teradata-nos-connection)
+ [Lettura da tabelle Teradata](#reading-from-teradata-nos-tables)
+ [Scrittura su tabelle Teradata](#writing-to-teradata-nos-tables)
+ [Indicazioni di riferimento alle opzioni di connessione a Teradata](#teradata-nos-connection-option-reference)
+ [Fornisci opzioni nell'interfaccia utente di AWS Glue Visual ETL](#teradata-nos-connection-option-visual-etl-ui)
## Creazione di una connessione Teradata NOS
Per connettersi a Teradata NOS da AWS Glue, è necessario creare e archiviare le credenziali Teradata in un luogo Gestione dei segreti AWS segreto, quindi associare tale segreto a una connessione Teradata NOS. AWS Glue Se l'istanza Teradata si trova in un Amazon VPC, sarà inoltre necessario fornire opzioni di rete alla connessione Teradata NOS. AWS Glue
**Prerequisiti:**
+ Se accedi al tuo ambiente Teradata tramite Amazon VPC, configura Amazon VPC per consentire al tuo AWS Glue job di comunicare con l'ambiente Teradata. Sconsigliamo l'accesso all'ambiente Teradata tramite la rete Internet pubblica.
+ In Amazon VPC, identifica o crea un VPC, una sottorete e un gruppo di sicurezza da utilizzare durante l'esecuzione del AWS Glue lavoro. Inoltre, assicurati che Amazon VPC sia configurato per consentire il traffico di rete tra l'istanza Teradata e questa posizione. Il tuo processo dovrà stabilire una connessione TCP con la tua porta del client Teradata. Per maggiori informazioni sulle porte Teradata, consulta i [Gruppi di sicurezza per Teradata Vantage](https://docs.teradata.com/r/Teradata-VantageTM-on-AWS-DIY-Installation-and-Administration-Guide/April-2020/Before-Deploying-Vantage-on-AWS-DIY/Security-Groups-and-Ports).
+ In base al layout di rete, la connettività VPC sicura potrebbe richiedere modifiche ad Amazon VPC e ad altri servizi di rete. Per ulteriori informazioni sulla AWS connettività, consulta [Opzioni di AWS connettività nella documentazione di Teradata](https://docs.teradata.com/r/Teradata-VantageCloud-Enterprise/Get-Started/Connecting-Your-Environment/AWS-Connectivity-Options).
### Per configurare una connessione AWS Glue Teradata NOS:
1. Nella configurazione Teradata, identifica o crea un *teradataUsername* e *teradataPassword* AWS Glue con cui ti connetterai. Per ulteriori informazioni, consulta [Panoramica sulla sicurezza di Vantage](https://docs.teradata.com/r/Configuring-Teradata-VantageTM-After-Installation/January-2021/Security-Overview/Vantage-Security-Overview) nella documentazione di Teradata.
1. Nel Gestione dei segreti AWS, crea un segreto usando le tue credenziali Teradata. Per creare un segreto in Gestione dei segreti AWS, segui il tutorial disponibile in [Creare un Gestione dei segreti AWS segreto nella documentazione](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html). Gestione dei segreti AWS Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezioni Key/value le coppie, crea una coppia per la chiave USERNAME con il valore*teradataUsername*.
+ Quando selezionate Key/value le coppie, create una coppia per la chiave PASSWORD con il valore*teradataPassword*.
1. Nella AWS Glue console, crea una connessione seguendo i passaggi descritti in [Aggiungere una AWS Glue connessione](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html). Dopo aver creato la connessione, mantieni il nome della connessione per il passaggio successivo. *connectionName*
+ In **Tipo di connessione**, seleziona Teradata Vantage NOS.
+ Quando fornisci JDBC URL, fornisci l'URL per la tua istanza. Puoi anche codificare determinati parametri di connessione, separati da virgole, nel tuo URL JDBC. L'URL deve essere conforme al seguente formato:` jdbc:teradata://teradataHostname/ParameterName=ParameterValue,ParameterName=ParameterValue `.
+ I parametri URL supportati includono:
+ `DATABASE`: nome del database sull'host a cui accedere per impostazione predefinita.
+ `DBS_PORT`: la porta del database, utilizzata con una porta non standard.
+ Quando selezioni un **tipo di credenziale**, seleziona Gestione dei segreti AWS, quindi imposta ** AWS Segreto** su. *secretName*
1. Nelle seguenti situazioni, potresti aver bisogno di una configurazione aggiuntiva:
+ Per le istanze Teradata ospitate su AWS un Amazon VPC, dovrai fornire le informazioni di connessione Amazon VPC alla connessione che definisce le tue credenziali di sicurezza Teradata AWS Glue . Durante la creazione o l'aggiornamento della connessione, imposta **VPC**, **sottorete** e **Gruppi di sicurezza** nelle **opzioni di rete**.
Dopo aver creato una connessione AWS Glue Teradata Vantage NOS, dovrai eseguire i seguenti passaggi prima di chiamare il metodo di connessione.
1. Concedi il permesso di lettura al ruolo IAM associato al tuo AWS Glue lavoro. *secretName*
1. Nella configurazione del tuo AWS Glue lavoro, fornisci *connectionName* come connessione di **rete aggiuntiva in **Connessioni****.
## Lettura da tabelle Teradata
### Prerequisiti:
+ Una tabella Teradata da cui si desidera leggere. Avrai bisogno del nome della tabella,*tableName*.
+ L'ambiente Teradata ha accesso in scrittura al percorso Amazon S3 specificato `staging_fs_url` dall'opzione,. *stagingFsUrl*
+ Il ruolo IAM associato al AWS Glue job ha accesso in scrittura alla posizione Amazon S3 specificata dall'`staging_fs_url`opzione.
+ Una connessione AWS Glue Teradata NOS configurata per fornire informazioni di autenticazione. Completa i passaggi descritti in [Per configurare una connessione AWS Glue Teradata NOS:](#creating-teradata-nos-connection-procedure) per configurare le tue informazioni di autenticazione. Avrai bisogno del nome della connessione,. AWS Glue *connectionName*
Esempio:
```
teradata_read_table = glueContext.create_dynamic_frame.from_options(
connection_type= "teradatanos",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"staging_fs_url": "stagingFsUrl"
}
)
```
Puoi anche fornire una query SQL SELECT, per filtrare i risultati restituiti al tuo DynamicFrame. Dovrai configurare la query. Se configuri sia dbTable che la query, il connettore non riesce a leggere i dati. Esempio:
```
teradata_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="teradatanos",
connection_options={
"connectionName": "connectionName",
"query": "query",
"staging_fs_url": "stagingFsUrl"
}
)
```
Inoltre, è possibile utilizzare l' DataFrame API Spark per leggere le tabelle Teradata. Esempio:
```
options = {
"url": "JDBC_URL",
"dbtable": "tableName",
"user": "teradataUsername", # or use "username" as key here
"password": "teradataPassword",
"staging_fs_url": "stagingFsUrl"
}
teradata_read_table = spark.read.format("teradatanos").option(**options).load()
```
## Scrittura su tabelle Teradata
### Prerequisiti
+ Una tabella Teradata su cui desideri scrivere:. *tableName*
+ L'ambiente Teradata ha accesso in lettura alla posizione Amazon S3 specificata `staging_fs_url` dall'opzione,. * stagingFsUrl *
+ Il ruolo IAM associato al AWS Glue job ha accesso in scrittura alla posizione Amazon S3 specificata dall'`staging_fs_url`opzione.
+ Una connessione AWS Glue Teradata configurata per fornire informazioni di autenticazione. Completa i passaggi descritti in [Per configurare una connessione AWS Glue Teradata NOS:](#creating-teradata-nos-connection-procedure) per configurare le tue informazioni di autenticazione. Avrai bisogno del nome della connessione,. AWS Glue *connectionName*
Esempio:
```
teradata_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type= "teradatanos",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"staging_fs_url": "stagingFsUrl"
}
)
```
## Indicazioni di riferimento alle opzioni di connessione a Teradata
**Opzioni di connessione e funzionamento:**
+ `connectionName`: obbligatorio. Utilizzato per la lettura/scrittura. Il nome di una connessione AWS Glue Teradata configurata per fornire informazioni di autenticazione e di rete al metodo di connessione utilizzato.
+ `staging_fs_url`: obbligatorio. Utilizzato per la lettura/scrittura. Una posizione scrivibile in Amazon S3, da usare per i dati scaricati durante la lettura da Teradata e per i dati Parquet da caricare in Redshift durante la scrittura su Teradata. Il bucket S3 deve trovarsi nella stessa regione della regione dei lavori. AWS Glue
+ `dbtable` — Richiesto per la scrittura, richiesto per la lettura a meno che non `query` sia fornito. Utilizzato per la lettura/scrittura. Il nome di una tabella con cui interagirà il metodo di connessione.
+ `query`: utilizzato per la lettura. Una query SELECT SQL che definisce cosa recuperare durante la lettura da Teradata. Non è possibile passare se è specificata l'opzione `dbtable`.
+ `clean_staging_s3_dir`— Facoltativo. Utilizzato per la lettura/scrittura. Se impostato su true, pulisce gli oggetti Amazon S3 di staging dopo una lettura o una scrittura. Il valore di default è true.
+ `pre_actions`— Facoltativo. Utilizzato per la scrittura. Elenco separato da punti e virgola dei comandi SQL eseguiti prima del trasferimento dei dati tra Spark e Teradata Vantage.
+ `post_actions`— Facoltativo. Utilizzato per la scrittura. Elenco separato da punti e virgola dei comandi SQL eseguiti dopo il trasferimento dei dati tra Spark e Teradata Vantage.
+ `truncate`— Facoltativo. Utilizzato per la scrittura. Se è impostato su true, il connettore tronca la tabella durante la scrittura in modalità di sovrascrittura. Se è impostato su false, il connettore elimina la tabella durante la scrittura in modalità di sovrascrittura. Il valore predefinito è false.
+ `create_table_script`— Facoltativo. Utilizzato per la scrittura. Istruzione SQL per creare una tabella durante la scrittura su Teradata Vantage. Utile quando si vuole creare una tabella con metadati personalizzati (ad esempio tabella SET o CREATE MULTISET o modificare l'indice primario). Notare che il nome della tabella utilizzato nello script di creazione della tabella deve corrispondere al nome della tabella specificato nell'opzione `dbtable`.
+ `partition_size_in_mb`— Facoltativo. Utilizzato per la lettura. Dimensione massima di una partizione Spark in megabyte durante la lettura di oggetti Amazon S3 di staging. Il valore predefinito è 128.
È possibile fornire opzioni avanzate durante la creazione di un nodo Teradata. Queste opzioni sono le stesse disponibili durante la programmazione AWS Glue per gli script Spark.
Per informazioni, consulta [Connessioni Teradata Vantage](aws-glue-programming-etl-connect-teradata-home.md).
**Opzioni di autorizzazione:**
Di seguito sono elencate le opzioni utilizzate per fornire le credenziali dell' AWS account utilizzate dal connettore per accedere al bucket di staging Amazon S3. Puoi scegliere di (1) non fornire alcuna opzione di autorizzazione e utilizzare credenziali temporanee generate dal tuo ruolo di AWS Glue esecuzione; oppure (2) fornire un oggetto di autorizzazione creato da `auth_object` te; oppure (3) specificare se si utilizzano credenziali a lungo termine oppure fornire e `aws_access_key_id and aws_secret_access_key` se si utilizzano credenziali temporanee. `aws_access_key` `aws_secret_access_key` `aws_session_token`
+ `auth_object` : Opzionale. Usata per l'accesso al bucket Amazon S3 di staging Amazon S3. Una stringa di oggetti di autorizzazione creata nell'istanza Teradata. Se fornita, il connettore userà questo oggetto di autorizzazione per accedere al bucket Amazon S3 di staging. Se non viene fornita `aws_access_key_id` e `aws_secret_access_key` inoltre non viene fornita, una credenziale temporanea verrà recuperata dal ruolo di AWS Glue esecuzione e utilizzata dal connettore. L' AWS account associato a questo oggetto di autorizzazione deve trovarsi nella stessa regione dei tuoi AWS Glue job e del tuo bucket di staging Amazon S3 o deve essere configurato con cross-account trust.
+ `aws_access_key_id` : Opzionale. Usata per l'accesso al bucket Amazon S3 di staging Amazon S3. Parte di una credenziale di sicurezza dell' AWS account. Se `auth_object` non viene fornito e `aws_access_key_id` viene fornito con `aws_secret_access_key`, il connettore li userà per accedere al bucket Amazon S3 di staging. L' AWS account associato a questa chiave di accesso deve trovarsi nella stessa regione in cui AWS Glue lavori e nel bucket di staging Amazon S3 o deve essere configurato con cross-account trust.
+ `aws_secret_access_key` : Opzionale. Usata per l'accesso al bucket Amazon S3 di staging Amazon S3. Parte di una credenziale di sicurezza dell' AWS account. Se `auth_object` non viene fornito e `aws_secret_access_key` viene fornito con `aws_access_key_id`, il connettore li userà per accedere al bucket Amazon S3 di staging. L' AWS account associato a questa chiave segreta deve trovarsi nella stessa regione del tuo AWS Glue job e del tuo bucket di staging Amazon S3 o deve essere configurato con cross-account trust.
+ `aws_session_token` : Opzionale. Usata per l'accesso al bucket Amazon S3 di staging Amazon S3. Parte di una credenziale di sicurezza temporanea AWS dell'account. Dovrebbe essere fornita con `aws_access_key_id` e `aws_secret_access_key`.
## Fornisci opzioni nell'interfaccia utente di AWS Glue Visual ETL
È possibile fornire tutte le opzioni sopra indicate nell'interfaccia utente del processo ETL visivo. Per quanto riguarda l'opzione ConnectionName, è necessario selezionarla dall'elenco a discesa delle connessioni Teradata Vantage NOS. Per tutte le altre opzioni, bisogna fornirle tramite le proprietà personalizzate di Teradata Vantage NOS come coppie chiave-valore.
![\[Il riquadro della finestra mostra che è selezionata la connessione Teradata NOS Vantage.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/teradata-nos-vantage-connection-options.png)
# Connessioni Vertica
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in Vertica in AWS Glue 4.0 e versioni successive. È possibile definire cosa leggere da Vertica con una query SQL. Ti connetti a Vertica utilizzando le credenziali di nome utente e password memorizzate Gestione dei segreti AWS tramite una connessione AWS Glue.
Per ulteriori informazioni su Vertica, consulta la [documentazione di Vertica](https://www.vertica.com/docs/9.3.x/HTML/Content/Authoring/UsingVerticaOnAWS/UsingVerticaOnAWS.htm).
## Configurazione delle connessioni Vertica
Per connetterti a Vertica da AWS Glue, dovrai creare e archiviare le tue credenziali Vertica in un luogo Gestione dei segreti AWS segreto, quindi associare quel segreto a una connessione Vertica Glue. AWS Se la tua istanza Vertica si trova in un Amazon VPC, dovrai anche fornire opzioni di rete alla tua connessione AWS Glue Vertica. Ti servirà un bucket o una cartella Amazon S3 da utilizzare per l'archiviazione temporanea durante la lettura e la scrittura sul database.
Per connetterti a Vertica da AWS Glue, avrai bisogno di alcuni prerequisiti:
+ Un bucket o una cartella Amazon S3 da utilizzare per l'archiviazione temporanea durante la lettura e la scrittura sul database, a cui si fa riferimento da. *tempS3Path*
**Nota**
Quando si utilizza Vertica nelle anteprime dei dati di lavoro di AWS Glue, i file temporanei potrebbero non essere rimossi automaticamente da. *tempS3Path* Per garantire la rimozione dei file temporanei, interrompi direttamente la sessione di anteprima dei dati scegliendo **Termina sessione** nel riquadro **Anteprima dei dati**.
Se non sei in grado di terminare direttamente la sessione di anteprima dei dati, valuta la possibilità di impostare la configurazione del ciclo di vita di Amazon S3 per rimuovere i dati obsoleti. Consigliamo di rimuovere i dati più vecchi di 49 ore, in base al runtime massimo del processo in aggiunta a un margine. Per ulteriori informazioni sulla configurazione del ciclo di vita di Amazon S3, consulta [Gestione del ciclo di vita dello storage](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) nella documentazione di Amazon S3.
+ Una policy IAM con le autorizzazioni appropriate per il tuo percorso Amazon S3 che puoi associare al tuo ruolo lavorativo in AWS Glue.
+ Se la tua istanza Vertica si trova in un Amazon VPC, configura Amazon VPC per consentire al job AWS Glue di comunicare con l'istanza Vertica senza che il traffico attraversi la rete Internet pubblica.
In Amazon VPC, identifica o crea un **VPC**, una **sottorete** e un **gruppo di sicurezza che** AWS Glue utilizzerà durante l'esecuzione del lavoro. Inoltre, assicurati che Amazon VPC sia configurato per consentire il traffico di rete tra l'istanza Vertica e questa posizione. Il tuo processo dovrà stabilire una connessione TCP con la tua porta del client Vertica, (per impostazione predefinita, 5433). In base al layout della rete, ciò potrebbe richiedere modifiche alle regole del gruppo di sicurezza, alla rete ACLs, ai gateway NAT e alle connessioni peering.
È quindi possibile procedere alla configurazione di AWS Glue per l'uso con Vertica.
**Per configurare una connessione a Vertica:**
1. Nel Gestione dei segreti AWS, crea un segreto utilizzando le tue credenziali Vertica, e. *verticaUsername* *verticaPassword* Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo.
+ Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `user` con il valore. *verticaUsername*
+ Quando selezionate **coppie chiave/valore**, create una coppia per la chiave `password` con il valore. *verticaPassword*
1. Nella console AWS Glue, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione per il passaggio successivo. *connectionName*
+ In **Tipo di connessione**, seleziona Vertica.
+ In **Host Vertica**, fornisci il nome host dell'installazione Vertica.
+ In **Porta Vertica**, indica la porta tramite cui è disponibile l'installazione di Vertica.
+ Quando selezioni un **AWS segreto**, fornisci*secretName*.
1. Nelle seguenti situazioni, potresti aver bisogno di una configurazione aggiuntiva:
+
Per le istanze Vertica ospitate su un AWS Amazon VPC
+ Fornisci le informazioni di connessione Amazon VPC alla connessione AWS Glue che definisce le tue credenziali di sicurezza Vertica. Durante la creazione o l'aggiornamento della connessione, imposta **VPC**, **sottorete** e **Gruppi di sicurezza** nelle **opzioni di rete**.
Dopo aver creato una connessione AWS Glue Vertica, dovrai eseguire i seguenti passaggi prima di chiamare il tuo metodo di connessione.
+ Concedi le autorizzazioni per il ruolo IAM associato al tuo lavoro AWS Glue a*tempS3Path*.
+ Concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*.
+ Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**.
## Lettura da Vertica
**Prerequisiti:**
+ Una tabella Vertica da cui si desidera leggere. Avrai bisogno del nome del database Vertica *dbName* e del nome della tabella,*tableName*.
+ Una connessione AWS Glue Vertica configurata per fornire informazioni di autenticazione. Completa i passaggi della procedura precedente, *Per configurare una connessione a Vertica* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
+ Un bucket o una cartella Amazon S3 da utilizzare per lo storage temporaneo, menzionato in precedenza. Avrai bisogno del nome,*tempS3Path*. Dovrai connetterti a questa posizione utilizzando il protocollo `s3a`.
Esempio:
```
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"table": "tableName",
}
)
```
Puoi anche fornire una query SQL SELECT, per filtrare i risultati restituiti DynamicFrame o per accedere a un set di dati da più tabelle.
Esempio:
```
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"query": "select * FROM tableName",
},
)
```
## Scrittura su tabelle Vertica
Questo esempio scrive informazioni da un file esistente DynamicFrame *dynamicFrame* a Vertica. Se la tabella contiene già informazioni, AWS Glue aggiungerà i dati dal tuo DynamicFrame.
**Prerequisiti:**
+ Un nome di tabella attuale o desiderato su cui scrivere. *tableName* Avrai anche bisogno del nome del database Vertica corrispondente,*dbName*.
+ Una connessione AWS Glue Vertica configurata per fornire informazioni di autenticazione. Completa i passaggi della procedura precedente, *Per configurare una connessione a Vertica* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*.
+ Un bucket o una cartella Amazon S3 da utilizzare per lo storage temporaneo, menzionato in precedenza. Avrai bisogno del nome,*tempS3Path*. Dovrai connetterti a questa posizione utilizzando il protocollo `s3a`.
Esempio:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"table": "tableName",
}
)
```
## Indicazioni di riferimento alle opzioni di connessione a Vertica
+ `connectionName`: obbligatorio. Utilizzato per la lettura/scrittura. Il nome di una connessione AWS Glue Vertica configurata per fornire informazioni di autenticazione e di rete al metodo di connessione utilizzato.
+ `db`: obbligatorio. Utilizzato per la lettura/scrittura. Il nome dell'indice in Vertica con cui interagirà il metodo di connessione.
+ `dbSchema` — Obbligatorio se necessario per identificare la tabella. Utilizzato per la lettura/scrittura. Default: `public`. Il nome di uno schema con cui interagirà il metodo di connessione.
+ `table` — Richiesto per la scrittura, richiesto per la lettura a meno che non `query` sia fornito. Utilizzato per la lettura/scrittura. Il nome di una tabella con cui interagirà il metodo di connessione.
+ `query`: utilizzato per la lettura. Una query SELECT SQL che definisce cosa recuperare durante la lettura da Teradata.
+ `staging_fs_url`: obbligatorio. Utilizzato per la lettura/scrittura. Valori validi:. `s3a` URLs L'URL di un bucket o di una cartella Amazon S3 da utilizzare per l'archiviazione temporanea.
## DataFrame opzioni per ETL in AWS Glue 5.0 for Spark
A DataFrame è un set di dati organizzato in colonne denominate simili a una tabella e supporta operazioni in stile funzionale (map/reduce/filter/etc.) e operazioni SQL (select, project, aggregate).
Per creare un file DataFrame per un'origine dati supportata da Glue, sono necessari i seguenti requisiti:
+ Connettore dell'origine dati `ClassName`
+ Connessione dell'origine dati `Options`
Allo stesso modo, per scrivere DataFrame a su un data sink supportato da Glue, sono necessari gli stessi:
+ Connettore del data sink `ClassName`
+ Connessione del data sink `Options`
Tieni presente che le funzionalità di AWS Glue come i segnalibri di lavoro e DynamicFrame le opzioni come non `connectionName` sono supportate in DataFrame. Per maggiori dettagli sulle operazioni supportate DataFrame e sulle operazioni supportate, consulta la documentazione di Spark per. [DataFrame](https://spark.apache.org/docs/3.5.2/api/python/reference/pyspark.sql/dataframe.html)
### Specificare il connettore ClassName
Per specificare il connettore `ClassName` di un'origine dati o di un data sink, utilizzare l'opzione `.format` per indicare il connettore `ClassName` corrispondente che definisce l'origine dati o il data sink.
**Connettori JDBC**
Per i connettori JDBC, specificare `jdbc` come valore dell'opzione `.format` e indicare il driver JDBC `ClassName` nell'opzione `driver`.
```
df = spark.read.format("jdbc").option("driver", "")...
df.write.format("jdbc").option("driver", "")...
```
La tabella seguente elenca il driver JDBC `ClassName` dell'origine dati supportata in AWS Glue for. DataFrames
| Origine dati | Autista ClassName |
| --- |--- |
| PostgreSQL | org.PostgreSQL.Driver |
| Oracle | oracle.jdbc.driver. OracleDriver |
| SQLServer | com.microsoft.sqlserver.jdbc. SQLServerAutista |
| MySQL | driver com.mysql.jdbc |
| SAPHana | com.sap.db.jdbc.Driver |
| Teradata | com.teradata.jdbc. TeraDriver |
**Connettori Spark**
Per i connettori Spark, specificare il `ClassName` del connettore come valore dell'opzione `.format`.
```
df = spark.read.format("")...
df.write.format("")...
```
La tabella seguente elenca il connettore Spark `ClassName` dell'origine dati supportata in AWS Glue for DataFrames.
| Origine dati | ClassName |
| --- |--- |
| MongoDB/DocumentDB | glue.spark.mongodb |
| Redshift | io.github.spark\$1redshift\$1community.spark.redshift |
| AzureCosmos | cosmos.oltp |
| AzureSQL | com.microsoft.sqlserver.jdbc.spark |
| BigQuery | com.google.cloud.spark.bigquery |
| OpenSearch | org.opensearch.spark.sql |
| Snowflake | net.snowflake.spark.snowflake |
| Vertica | com.vertica.spark.datasource. VerticaSource |
### Specificare le opzioni di connessione
Per specificare le `Options` della connessione a un'origine dati o a un data sink, utilizzare `.option(, )` per indicare singole opzioni oppure `.options(