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à.
# Utilizza Amazon Athena Federated Query
Se disponi di dati in origini diverse da Amazon S3, puoi utilizzare Athena Federated Query per eseguire query locali sui dati o compilare pipeline che estraggono i dati da più origini dati e archiviarli in Amazon S3. Con Athena Federated Query, puoi eseguire query SQL su dati archiviati in origini dati relazionali, non relazionali, oggetto e personalizzate.
Athena utilizza *connettori di origine dati* che funzionano AWS Lambda per eseguire query federate. Un connettore origine dati è una parte di codice in grado di effettuare la conversione tra l'origine dati di destinazione e Athena. Puoi pensare a un connettore come a un'estensione del motore di query di Athena. Esistono connettori di origine dati Athena predefiniti per fonti di dati come Amazon Logs, CloudWatch Amazon DynamoDB, Amazon DocumentDB e Amazon RDS e fonti di dati relazionali conformi a JDBC come MySQL e PostgreSQL con licenza Apache 2.0. Puoi inoltre utilizzare l'SDK Athena Query Federation per scrivere connettori personalizzati. Per scegliere, configurare e distribuire un connettore origine dati nell'account, puoi utilizzare le console Athena e Lambda o AWS Serverless Application Repository. Dopo aver distribuito i connettori origine dati, il connettore è associato a un catalogo che puoi specificare nelle query SQL. Puoi combinare istruzioni SQL di più cataloghi ed estendere più origini dati con una singola query.
Quando una query viene inviata rispetto a un'origine dati, Athena richiama il connettore corrispondente per identificare le parti delle tabelle che devono essere lette, gestisce il parallelismo ed esegue il push down dei predicati del filtro. In base all'utente che invia la query, i connettori possono fornire o limitare l'accesso a elementi di dati specifici. I connettori utilizzano Apache Arrow come il formato per restituire i dati richiesti in una query, che consente l'implementazione dei connettori in linguaggi quali C, C\$1\$1, Java, Python e Rust. Poiché i connettori vengono elaborati in Lambda, possono essere utilizzati per accedere ai dati da qualsiasi origine dati sul cloud o in locale che sia accessibile da Lambda.
Per scrivere il tuo connettore origine dati, puoi utilizzare l'SDK Athena Query Federation per personalizzare uno dei connettori precompilati forniti e gestiti da Amazon Athena. [https://github.com/awslabs/aws-athena-query-federation/wiki/Available-Connectors](https://github.com/awslabs/aws-athena-query-federation/wiki/Available-Connectors) AWS Serverless Application Repository
**Nota**
Sviluppatori di terze parti potrebbero aver utilizzato Athena Query Federation SDK per scrivere connettori di origini dati. Per problemi di supporto o di licenza relativi a questi connettori di origini dati, contattare il provider di connettori. Questi connettori non sono testati o supportati da AWS.
Per un elenco dei connettori origine dati scritti e testati da Athena, consulta [Connettori di origine dati disponibili](connectors-available.md).
Per informazioni sulla scrittura di un connettore di origine dati personalizzato, vedi [Esempio di connettore Athena attivo](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-example). GitHub
## Considerazioni e limitazioni
+ **Versioni del motore**: Athena Federated Query è supportato solo dalla versione 2 del motore Athena e successive. Per ulteriori informazioni sulle versioni del motore Athena, consulta [Controllo delle versioni del motore di Athena](engine-versions.md).
+ **Visualizzazioni**: puoi creare ed eseguire query sulle viste su origini dati federate. Le viste federate vengono archiviate nell' AWS Glue origine dati sottostante e non nella stessa. Per ulteriori informazioni, consulta [Eseguire query su visualizzazioni federate](running-federated-queries.md#running-federated-queries-federated-views).
+ **Identificatori delimitati**: gli (conosciuti anche come identificatori tra virgolette) iniziano e terminano con le virgolette doppie ("). Per adesso, gli identificatori delimitati non sono supportati per le query federate in Athena.
+ **Operazioni di scrittura**: le operazioni di scrittura come [INSERT INTO](insert-into.md) non sono supportate. Il tentativo di eseguire questa operazione potrebbe generare il messaggio di errore This operation is currently not supported for external catalogs (Questa operazione non è attualmente supportata per i cataloghi esterni).
+ **Prezzi** — Per informazioni sui prezzi, consulta [Prezzi di Amazon Athena](https://aws.amazon.com/athena/pricing/).
+ **Driver JDBC** — Per utilizzare il driver JDBC con query federate o un [metastore Hive esterno](connect-to-data-source-hive.md), includere `MetadataRetrievalMethod=ProxyAPI` nella stringa di connessione JDBC. Per informazioni sul driver JDBC, consulta [Connettersi ad Amazon Athena con JDBC](connect-with-jdbc.md).
+ **Secrets Manager** – Per utilizzare la funzione Query federata Athena con Gestione dei segreti AWS, devi configurare un endpoint privato Amazon VPC per Secrets Manager. Per ulteriori informazioni, consulta [Creare un endpoint privato Secrets Manager VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html#vpc-endpoint-create) nella *Guida dell'utente di Gestione dei segreti AWS *.
## Autorizzazioni richieste
I connettori origine dati potrebbero richiedere l'accesso alle risorse seguenti per funzionare correttamente. Se utilizzi un connettore precompilato, controlla le informazioni relative al connettore per assicurarti di aver configurato correttamente il VPC. Inoltre, assicurati che i principali IAM che eseguono le query e creano i connettori dispongano dei privilegi per le operazioni richieste. Per ulteriori informazioni, consulta [Consenti l’accesso alla query federata Athena](federated-query-iam-access.md).
+ **Amazon S3** — Oltre a scrivere i risultati delle query nella posizione dei risultati della query Athena in Amazon S3, i connettori di dati scrivono anche in un bucket di spill in Amazon S3. Sono richieste connettività e autorizzazioni a questa posizione Amazon S3. Ti consigliamo di utilizzare la crittografia spill to disk per ogni connettore e la [configurazione del ciclo di vita di S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) per far scadere i dati spill che non sono più necessari.
+ **Athena** — Le origini dati necessitano di connettività ad Athena e viceversa per controllare lo stato delle query e prevenire l'overscan.
+ **AWS Glue Data Catalog** — Sono necessarie connettività e autorizzazioni se il connettore utilizza il catalogo dati per metadati supplementari o primari.
+ **Amazon ECR**: Le funzioni Lambda del connettore di origine dati utilizzano un'immagine Amazon ECR da un repository Amazon ECR. L’utente che distribuisce il connettore deve disporre delle autorizzazioni `ecr:BatchGetImage` e `ecr:GetDownloadUrlForLayer`. Per ulteriori informazioni, consulta [Autorizzazioni ECR](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html#gettingstarted-images-permissions) nella *Guida per gli sviluppatori di AWS Lambda *.
## Video
Guarda i video seguenti per sapere di più sull'utilizzo di Athena Federated Query.
**Video: analisi rapida dei risultati di una query federata in Amazon Athena**
Il video seguente mostra come analizzare i risultati di una query federata Athena in Quick.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/HyM5d0TmwAQ)
**Video: Game Analytics Pipeline**
Il video seguente mostra come distribuire una Data Pipeline scalabile serverless per l'acquisizione, l'archiviazione e l'analisi dei dati di telemetria da giochi e servizi utilizzando le query federate di Amazon Athena.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/xcS-flUMVbs)
# Connettori di origine dati disponibili
In questa sezione sono elencati connettori origine dati Athena precompilati che puoi utilizzare per eseguire query su diverse origini dati esterne ad Amazon S3. Per utilizzare un connettore nelle query Athena, configurarlo e distribuirlo nell'account.
## Considerazioni e limitazioni
+ Alcuni connettori predefiniti richiedono la creazione di un VPC e un gruppo di sicurezza prima di poterli utilizzare. Per informazioni sulla creazione VPCs, vedere[Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
+ Per utilizzare la funzionalità Athena Federated Query con Gestione dei segreti AWS, devi configurare un endpoint privato Amazon VPC per Secrets Manager. Per ulteriori informazioni, consulta [Creare un endpoint privato Secrets Manager VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html#vpc-endpoint-create) nella *Guida dell’utente di Gestione dei segreti AWS *.
+ Per i connettori che non supportano il pushdown del predicato, le query che includono un predicato richiedono un tempo di esecuzione più lungo. Per i set di dati di piccole dimensioni, vengono scansionati pochissimi dati e le query richiedono in media circa 2 minuti. Tuttavia, nel caso dei set di dati di grandi dimensioni, molte query possono andare in timeout.
+ Alcune origini dati federati utilizzano una terminologia diversa da Athena per riferirsi a oggetti di dati. Per ulteriori informazioni, consulta [Comprendere i qualificatori di nomi di tabella federati](tables-qualifiers.md).
+ Aggiorniamo periodicamente i nostri connettori in base agli aggiornamenti del database o del fornitore dell’origine dati. Non supportiamo fonti di dati disponibili per l'assistenza. end-of-life
+ Per i connettori che non supportano l'impaginazione quando si elencano le tabelle, il servizio web può scadere se il database contiene molte tabelle e metadati. I seguenti connettori forniscono il supporto dell'impaginazione per l'elencazione delle tabelle:
+ DocumentDB
+ DynamoDB
+ MySQL
+ OpenSearch
+ Oracle
+ PostgreSQL
+ Redshift
+ SQL Server
## Modalità di risoluzione dei casi in Federazione SDK
La Federazione SDK supporta le seguenti modalità standardizzate di risoluzione dei casi per i nomi di schemi e tabelle:
+ `NONE`: non modifica le maiuscole e minuscole dello schema e dei nomi delle tabelle specificati.
+ `LOWER`: tutti i nomi di schemi e tabelle specificati in minuscolo.
+ `UPPER`: tutti i nomi di schemi e tabelle indicati in maiuscolo.
+ `ANNOTATION`: questa modalità viene mantenuta solo per motivi di compatibilità con le versioni precedenti ed è supportata esclusivamente dai connettori Snowflake e SAP HANA esistenti.
+ `CASE_INSENSITIVE_SEARCH`: esegue ricerche senza distinzione tra maiuscole e minuscole tra nomi di schemi e tabelle.
## Supporto del connettore per le modalità di risoluzione dei casi
### Supporto della modalità di base
Tutti i connettori JDBC supportano le seguenti modalità base:
+ `NONE`
+ `LOWER`
+ `UPPER`
### Supporto della modalità annotazioni
Solo i seguenti connettori supportano la modalità `ANNOTATION`:
+ Snowflake
+ SAP HANA
**Nota**
Si consiglia di utilizzare CASE\$1INSENSITIVE\$1SEARCH anziché ANNOTATION.
### Supporto della ricerca senza distinzione tra maiuscole e minuscole
I seguenti connettori supportano `CASE_INSENSITIVE_SEARCH`:
+ DataLake Gen2
+ Snowflake
+ Oracle
+ Synapse
+ MySQL
+ PostgreSQL
+ Redshift
+ ClickHouse
+ SQL Server
+ DB2
## Limitazioni del risolutore del casing
Quando si utilizza la funzione di risoluzione del casing, tenere presente le seguenti limitazioni:
+ Quando si utilizza la modalità `LOWER`, il nome dello schema e tutte le tabelle all’interno dello schema devono essere in minuscolo.
+ Quando si utilizza la modalità `UPPER`, il nome dello schema e tutte le tabelle all’interno dello schema devono essere in maiuscolo.
+ Quando utilizzi `CASE_INSENSITIVE_SEARCH`:
+ I nomi degli schemi devono essere univoci
+ I nomi delle tabelle all’interno di uno schema devono essere univoci (ad esempio, non è possibile avere sia "Apple" che "APPLE")
+ Limitazioni all’integrazione di Glue:
+ Glue supporta solo nomi minuscoli
+ Solo `NONE` le nostre `LOWER` modalità funzioneranno quando si registra la funzione Lambda con/ GlueDataCatalogLakeFormation
## Informazioni aggiuntive
+ Per informazioni sulla distribuzione di un connettore origine dati Athena, consulta [Utilizza Amazon Athena Federated Query](federated-queries.md).
+ Per informazioni sulle query che utilizzano connettori di origine dati Athena, consulta [Eseguire query federate](running-federated-queries.md).
**Topics**
+ [Considerazioni e limitazioni](#connectors-available-considerations)
+ [Modalità di risoluzione dei casi in Federazione SDK](#case-resolver-modes)
+ [Supporto del connettore per le modalità di risoluzione dei casi](#connector-support-matrix)
+ [Limitazioni del risolutore del casing](#case-resolver-limitations)
+ [Informazioni aggiuntive](#connectors-available-additional-resources)
+ [Archiviazione Azure Data Lake](connectors-adls-gen2.md)
+ [Azure Synapse](connectors-azure-synapse.md)
+ [Cloudera Hive](connectors-cloudera-hive.md)
+ [Cloudera Impala](connectors-cloudera-impala.md)
+ [CloudWatch](connectors-cloudwatch.md)
+ [CloudWatch metriche](connectors-cwmetrics.md)
+ [CMDB](connectors-cmdb.md)
+ [Db2](connectors-ibm-db2.md)
+ [Db2 iSeries](connectors-ibm-db2-as400.md)
+ [DocumentDB](connectors-docdb.md)
+ [DynamoDB](connectors-dynamodb.md)
+ [Google BigQuery](connectors-bigquery.md)
+ [Google Cloud Storage](connectors-gcs.md)
+ [HBase](connectors-hbase.md)
+ [Hortonworks](connectors-hortonworks.md)
+ [Kafka](connectors-kafka.md)
+ [MSK](connectors-msk.md)
+ [MySQL](connectors-mysql.md)
+ [Neptune](connectors-neptune.md)
+ [OpenSearch](connectors-opensearch.md)
+ [Oracle](connectors-oracle.md)
+ [PostgreSQL](connectors-postgresql.md)
+ [Redis OSS](connectors-redis.md)
+ [Redshift](connectors-redshift.md)
+ [SAP HANA](connectors-sap-hana.md)
+ [Snowflake](connectors-snowflake.md)
+ [SQL Server](connectors-microsoft-sql-server.md)
+ [Teradata](connectors-teradata.md)
+ [Timestream](connectors-timestream.md)
+ [TPC-DS](connectors-tpcds.md)
+ [Vertica](connectors-vertica.md)
**Nota**
La [AthenaJdbcConnector](https://serverlessrepo.aws.amazon.com/applications/us-east-1/292517598671/AthenaJdbcConnector)(ultima versione 2022.4.1) è stata obsoleta. In alternativa, utilizza un connettore specifico per il database come quelli per [MySQL](connectors-mysql.md), [Redshift](connectors-redshift.md) o [PostgreSQL](connectors-postgresql.md).
# Connettore Amazon Athena Azure Data Lake Storage (ADLS) Gen2
Il connettore Amazon Athena per [Azure Data Lake Storage (ADLS) Gen2](https://docs.microsoft.com/en-us/azure/databricks/data/data-sources/azure/adls-gen2/) consente ad Amazon Athena di eseguire query SQL sui dati archiviati in ADLS. Athena non può accedere direttamente ai file archiviati nel data lake.
Questo connettore può essere registrato con il Catalogo Dati Glue Data come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
+ **Flusso di lavoro**: il connettore implementa l'interfaccia JDBC, che utilizza il driver `com.microsoft.sqlserver.jdbc.SQLServerDriver`. Il connettore passa le query al motore Azure Synapse, che quindi accede al data lake.
+ **Gestione dei dati e S3**: normalmente il connettore Lambda esegue query sui dati direttamente senza trasferirli ad Amazon S3. Tuttavia, quando i dati restituiti dalla funzione Lambda superano i limiti Lambda, i dati vengono scritti nel bucket di spill di Amazon S3 specificato in modo che Athena possa leggere il superamento.
+ **Autenticazione AAD**: AAD può essere usato come metodo di autenticazione per il connettore Azure Synapse. Per utilizzare AAD, la stringa di connessione JDBC utilizzata dal connettore deve contenere i parametri URL `authentication=ActiveDirectoryServicePrincipal`, `AADSecurePrincipalId` e `AADSecurePrincipalSecret`. Questi parametri possono essere passati direttamente o tramite Secrets Manager.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Nelle condizioni di filtro, è necessario impostare i tipi di dati date e timestamp sul tipo di dati appropriato.
## Termini
I seguenti termini si riferiscono al connettore Azure Data Lake Storage Gen2.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizza i parametri illustrati in questa sezione per configurare il connettore Azure Data Lake Storage Gen2.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Azure Data Lake Storage Gen2 utilizzando un oggetto di connessioni Glue. Per fare ciò, impostare la variabile di ambiente `glue_connection` del connettore Azure Data Lake Storage Gen2 Lambda sul nome della connessione Glue da usare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type DATALAKEGEN2
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Azure Data Lake Storage Gen2 creato usando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore Azure Data Lake Storage Gen2 creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
datalakegentwo://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | DataLakeGen2MuxCompositeHandler |
| Gestore dei metadati | DataLakeGen2MuxMetadataHandler |
| Gestore dei record | DataLakeGen2MuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mydatalakegentwocatalog, il nome della variabile di ambiente è mydatalakegentwocatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio riguardano una funzione Lambda a DataLakeGen 2 MUX che supporta due istanze di database`datalakegentwo1`: (impostazione predefinita) e. `datalakegentwo2`
****
| Proprietà | Valore |
| --- | --- |
| default | datalakegentwo://jdbc:sqlserver://adlsgentwo1.hostname:port;databaseName=database\$1name;\$1\$1secret1\$1name\$1 |
| datalakegentwo\$1catalog1\$1connection\$1string | datalakegentwo://jdbc:sqlserver://adlsgentwo1.hostname:port;databaseName=database\$1name;\$1\$1secret1\$1name\$1 |
| datalakegentwo\$1catalog2\$1connection\$1string | datalakegentwo://jdbc:sqlserver://adlsgentwo2.hostname:port;databaseName=database\$1name;\$1\$1secret2\$1name\$1 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti hardcoded in Gestione dei segreti AWS, consultate [Move hardcoded](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) secret in nella Guida per l'utente. Gestione dei segreti AWSGestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${secret1_name}`.
```
datalakegentwo://jdbc:sqlserver://hostname:port;databaseName=database_name;${secret1_name}
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
datalakegentwo://jdbc:sqlserver://hostname:port;databaseName=database_name;user=user_name;password=password
```
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza di Azure Data Lake Storage Gen2.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | DataLakeGen2CompositeHandler |
| Gestore dei metadati | DataLakeGen2MetadataHandler |
| Gestore dei record | DataLakeGen2RecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Azure Data Lake Storage Gen2 supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | datalakegentwo://jdbc:sqlserver://hostname:port;databaseName=;\$1\$1secret\$1name\$1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per ADLS Gen2 e Arrow.
****
| ADLS Gen2 | Arrow |
| --- | --- |
| bit | TINYINT |
| tinyint | SMALLINT |
| smallint | SMALLINT |
| int | INT |
| bigint | BIGINT |
| decimal | DECIMAL |
| numeric | FLOAT8 |
| smallmoney | FLOAT8 |
| money | DECIMAL |
| float[24] | FLOAT4 |
| float[53] | FLOAT8 |
| real | FLOAT4 |
| datetime | Date(MILLISECOND) |
| datetime2 | Date(MILLISECOND) |
| smalldatetime | Date(MILLISECOND) |
| data | Date(DAY) |
| time | VARCHAR |
| datetimeoffset | Date(MILLISECOND) |
| char[n] | VARCHAR |
| varchar[n/max] | VARCHAR |
## Partizioni e suddivisioni
Azure Data Lake Storage Gen2 utilizza l'archiviazione blob Gen2 compatibile con Hadoop per l'archiviazione dei file di dati. I dati di questi file vengono interrogati dal motore Azure Synapse. Il motore Azure Synapse tratta i dati Gen2 archiviati nei file system come tabelle esterne. Le partizioni vengono implementate in base al tipo di dati. Se i dati sono già stati partizionati e distribuiti all'interno del sistema di archiviazione Gen2, il connettore recupera i dati come singola suddivisione.
## Performance
Il connettore Azure Data Lake Storage Gen2 mostra prestazioni più lente quando si eseguono più query contemporaneamente ed è soggetto alla limitazione della larghezza di banda della rete.
Il connettore Athena Azure Data Lake Storage Gen2 esegue il pushdown dei predicati per ridurre la quantità di dati scansionati dalla query. I predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati scansionati e ridurre il tempo di esecuzione delle query.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Athena Azure Data Lake Storage Gen2 può combinare queste espressioni e inviarle direttamente ad Azure Data Lake Storage Gen2 per funzionalità avanzate e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena Azure Data Lake Storage Gen2 supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Query passthrough
Il connettore Azure Data Lake Storage Gen2 supporta le [query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare la query completa all’origine dati per l’esecuzione.
Per usare le query passthrough con Azure Data Lake Storage Gen2, è possibile usare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un’origine dati in Azure Data Lake Storage Gen2. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, riconosci l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-datalakegen2/pom.xml) relativo a questo connettore, e accetti i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-datalakegen2/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, vedi il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-datalakegen2/pom.xml) per il connettore Azure Data Lake Storage Gen2 all'indirizzo .com. GitHub
Per ulteriori informazioni su questo connettore, visita il sito [corrispondente all'indirizzo .com](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-datalakegen2). GitHub
# Connettore Amazon Athena per Azure Synapse
Il connettore Amazon Athena per [Azure Synapse Analytics](https://docs.microsoft.com/en-us/azure/synapse-analytics/overview-what-is) consente ad Amazon Athena di eseguire query SQL sui database Azure Synapse utilizzando JDBC.
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Nelle condizioni di filtro, è necessario impostare i tipi di dati `Date` e `Timestamp` sul tipo di dati appropriato.
+ Per cercare valori negativi del tipo `Real` e `Float`, utilizza l'operatore `<=` o `>=`.
+ I tipi di dati `binary`, `varbinary`, `image` e `rowversion` non sono supportati.
## Termini
I seguenti termini si riferiscono al connettore Synapse.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizzate i parametri di questa sezione per configurare il connettore Synapse.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Synapse utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore Synapse Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type SYNAPSE
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Synapse creato utilizzando le connessioni Glue non supporta l’uso di un gestore di multiplexing.
Il connettore Synapse creato utilizzando le connessioni Glue supporta `ConnectionSchemaVersion` solo 2.
### Connessioni legacy (consigliate)
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
synapse://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | SynapseMuxCompositeHandler |
| Gestore dei metadati | SynapseMuxMetadataHandler |
| Gestore dei record | SynapseMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mysynapsecatalog, il nome della variabile di ambiente è mysynapsecatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Synapse MUX che supporta due istanze del database: `synapse1` (il valore predefinito) e `synapse2`.
****
| Proprietà | Valore |
| --- | --- |
| default | synapse://jdbc:synapse://synapse1.hostname:port;databaseName=;\$1\$1secret1\$1name\$1 |
| synapse\$1catalog1\$1connection\$1string | synapse://jdbc:synapse://synapse1.hostname:port;databaseName=;\$1\$1secret1\$1name\$1 |
| synapse\$1catalog2\$1connection\$1string | synapse://jdbc:synapse://synapse2.hostname:port;databaseName=;\$1\$1secret2\$1name\$1 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto \$1\$1secret\$1name\$1.
```
synapse://jdbc:synapse://hostname:port;databaseName=;${secret_name}
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
synapse://jdbc:synapse://hostname:port;databaseName=;user=;password=
```
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Synapse.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | SynapseCompositeHandler |
| Gestore dei metadati | SynapseMetadataHandler |
| Gestore dei record | SynapseRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Synapse supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | synapse://jdbc:sqlserver://hostname:port;databaseName=;\$1\$1secret\$1name\$1 |
#### Configurazione dell'autenticazione Active Directory
Il connettore Azure Synapse di Amazon Athena supporta l'autenticazione Microsoft Active Directory. Prima di iniziare, è necessario configurare un utente amministrativo nel portale di Microsoft Azure e quindi Gestione dei segreti AWS utilizzarlo per creare un segreto.
**Impostazione dell'utente amministrativo di Active Directory**
1. [Utilizzando un account con privilegi amministrativi, accedi al portale Microsoft Azure all'indirizzohttps://portal.azure.com/.](https://portal.azure.com/)
1. Nella casella di ricerca, inserisci **Azure Synapse Analytics** quindi seleziona **Azure Synapse Analytics**.
![\[Seleziona Azure Synapse Analytics.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-azure-synapse-1.png)
1. Apri il menu a sinistra.
![\[Seleziona il menu del portale Azure.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-azure-synapse-2.png)
1. Nel riquadro di navigazione, seleziona **Azure Active Directory**.
1. Nella scheda **Imposta admin**, imposta **Adim di Active Directory** su un utente nuovo o esistente.
![\[Utilizza la scheda Imposta admin\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-azure-synapse-3.png)
1. In Gestione dei segreti AWS, memorizza il nome utente e la password dell'amministratore. Per informazioni sulla creazione di un segreto in Secrets Manager, consulta la pagina [Crea un segreto Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).
**Visualizzazione del segreto in Gestione dei segreti**
1. Apri la console Secrets Manager all'indirizzo [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Nel riquadro di navigazione, scegli **Secrets** (Segreti).
1. Nella pagina **Secrets** (Segreti), scegli il collegamento al tuo segreto.
1. Nella pagina dei dettagli del segreto, scegli **Retrieve secret value** (Recupera il valore di un segreto).
![\[Visualizzazione dei segreti in Gestione dei segreti AWS.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-azure-synapse-4.png)
##### Modifica della stringa di connessione
Per abilitare l'autenticazione Active Directory del connettore, modifica la stringa di connessione utilizzando la seguente sintassi:
```
synapse://jdbc:synapse://hostname:port;databaseName=database_name;authentication=ActiveDirectoryPassword;{secret_name}
```
##### Usando ActiveDirectoryServicePrincipal
Il connettore Azure Synapse di Amazon Athena supporta anche `ActiveDirectoryServicePrincipal`. Per l'abilitazione, modifica la stringa di connessione come segue.
```
synapse://jdbc:synapse://hostname:port;databaseName=database_name;authentication=ActiveDirectoryServicePrincipal;{secret_name}
```
Per `secret_name`, specificare l'ID dell'applicazione o del client come nome utente e il segreto di un'identità principale di servizio nella password.
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per Synapse e Apache Arrow.
****
| Synapse | Arrow |
| --- | --- |
| bit | TINYINT |
| tinyint | SMALLINT |
| smallint | SMALLINT |
| int | INT |
| bigint | BIGINT |
| decimal | DECIMAL |
| numeric | FLOAT8 |
| smallmoney | FLOAT8 |
| money | DECIMAL |
| float[24] | FLOAT4 |
| float[53] | FLOAT8 |
| real | FLOAT4 |
| datetime | Date(MILLISECOND) |
| datetime2 | Date(MILLISECOND) |
| smalldatetime | Date(MILLISECOND) |
| data | Date(DAY) |
| time | VARCHAR |
| datetimeoffset | Date(MILLISECOND) |
| char[n] | VARCHAR |
| varchar[n/max] | VARCHAR |
| nchar[n] | VARCHAR |
| nvarchar[n/max] | VARCHAR |
## Partizioni e suddivisioni
Una partizione è rappresentata da una singola colonna di partizione di tipo `varchar`. Synapse supporta il partizionamento a intervalli, quindi il partizionamento viene implementato estraendo la colonna della partizione e l'intervallo della stessa dalle tabelle dei metadati di Synapse. Questi valori di intervallo vengono utilizzati per creare le suddivisioni.
## Performance
La selezione di un sottoinsieme di colonne rallenta notevolmente l'esecuzione delle query. Il connettore presenta una significativa limitazione della larghezza di banda della rete dovuta alla simultaneità.
Il connettore Athena Synapse esegue il pushdown del predicato per ridurre la quantità di dati scansionati dalla query. I predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati scansionati e ridurre il tempo di esecuzione delle query.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Synapse di Athena può combinare queste espressioni e inviarle direttamente a Synapse per migliorare le funzionalità e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Synapse di Athena supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Query passthrough
[Il connettore Synapse supporta le query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Synapse, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un’origine dati in Synapse. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
[Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-synapse/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file LICENSE.txt su .com.](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-synapse/LICENSE.txt) GitHub
## Risorse aggiuntive
+ *Per un articolo che mostra come usare Quick e Amazon Athena Federated Query per creare dashboard e visualizzazioni sui dati archiviati nei database Synapse di Microsoft Azure, consulta Eseguire [analisi multi-cloud usando Quick, Amazon Athena Federated](https://aws.amazon.com/blogs/business-intelligence/perform-multi-cloud-analytics-using-amazon-quicksight-amazon-athena-federated-query-and-microsoft-azure-synapse/) Query e Microsoft Azure Synapse nel Big Data Blog.AWS *
+ [Per le informazioni sulla versione più recente del driver JDBC, consulta il file pom.xml per il connettore Synapse su .com.](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-synapse/pom.xml) GitHub
+ Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-synapse) su .com. GitHub
# Connettore Amazon Athena per Cloudera Hive
Il connettore Amazon Athena per Cloudera Hive consente ad Athena di eseguire query SQL sulla distribuzione Hadoop [Cloudera Hive](https://www.cloudera.com/products/open-source/apache-hadoop/apache-hive.html). Il connettore trasforma le query SQL di Athena nella sintassi HiveQL equivalente.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
+ Prima di utilizzare questo connettore, configura un VPC e un gruppo di sicurezza. Per ulteriori informazioni, consulta [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
## Termini
I seguenti termini si riferiscono al connettore Cloudera Hive.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizza i parametri illustrati in questa sezione per configurare il connettore Cloudera Hive.
### Connessioni Glue (consigliate)
Consigliamo di configurare un connettore Cloudera Hive utilizzando un oggetto di connessioni Glue. Per fare ciò, imposta la variabile di ambiente `glue_connection` del connettore Cloudera Hive Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type CLOUDERAHIVE
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Cloudera Hive creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore Cloudera Hive creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
hive://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | HiveMuxCompositeHandler |
| Gestore dei metadati | HiveMuxMetadataHandler |
| Gestore dei record | HiveMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è myhivecatalog, il nome della variabile di ambiente è myhivecatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Hive MUX che supporta due istanze del database: `hive1` (il valore predefinito) e `hive2`.
****
| Proprietà | Valore |
| --- | --- |
| default | hive://jdbc:hive2://hive1:10000/default;\$1\$1Test/RDS/hive1\$1 |
| hive2\$1catalog1\$1connection\$1string | hive://jdbc:hive2://hive1:10000/default;\$1\$1Test/RDS/hive1\$1 |
| hive2\$1catalog2\$1connection\$1string | hive://jdbc:hive2://hive2:10000/default;UID=sample&PWD=sample |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, il connettore Cloudera Hive richiede un nome segreto da. Gestione dei segreti AWS[Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
Inserisci il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/RDS/hive1}`.
```
hive://jdbc:hive2://hive1:10000/default;...&${Test/RDS/hive1}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
hive://jdbc:hive2://hive1:10000/default;...&UID=sample2&PWD=sample2&...
```
Attualmente, il connettore Cloudera Hive riconosce le proprietà JDBC `UID` e `PWD`.
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Cloudera Hive.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | HiveCompositeHandler |
| Gestore dei metadati | HiveMetadataHandler |
| Gestore dei record | HiveRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Cloudera Hive supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | hive://jdbc:hive2://hive1:10000/default;secret=\$1\$1Test/RDS/hive1\$1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC, Cloudera Hive e Arrow.
****
| JDBC | Cloudera Hive | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Numero intero | TINYINT | Tiny |
| Breve | SMALLINT | Smallint |
| Numero intero | INT | Int |
| Long | BIGINT | Bigint |
| virgola mobile | float4 | Float4 |
| Double | float8 | Float8 |
| Data | date | DateDay |
| Time stamp | timestamp | DateMilli |
| Stringa | VARCHAR | Varchar |
| Byte | bytes | Varbinary |
| BigDecimal | Decimale | Decimale |
| ARRAY | N/D (vedi nota) | List |
**Nota**
Attualmente, Cloudera Hive non supporta i tipi di aggregati `ARRAY`, `MAP`, `STRUCT` e `UNIONTYPE`. Le colonne dei tipi di aggregati vengono trattate come colonne `VARCHAR` in SQL.
## Partizioni e suddivisioni
Le partizioni vengono utilizzate per determinare come generare suddivisioni per il connettore. Athena costruisce una colonna sintetica di tipo `varchar` che rappresenta lo schema di partizionamento della tabella per aiutare il connettore a generare suddivisioni. Il connettore non modifica la definizione effettiva della tabella.
## Performance
Cloudera Hive supporta le partizioni statiche. Il connettore Cloudera Hive di Athena può recuperare dati da queste partizioni in parallelo. Se desideri interrogare set di dati molto grandi con una distribuzione uniforme delle partizioni, ti consigliamo vivamente il partizionamento statico. Il connettore Cloudera Hive è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
Il connettore Athena Cloudera Hive esegue il pushdown dei predicati per ridurre i dati analizzati dalla query. Per ridurre la quantità di dati analizzati e ridurre il tempo di esecuzione delle query le clausole `LIMIT`, i predicati semplici e le espressioni complesse vengono inviate al connettore.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Athena Cloudera Hive può combinare queste espressioni e inviarle direttamente a Cloudera Hive per funzionalità avanzate e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena Cloudera Hive supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Query passthrough
Il connettore Cloudera Hive supporta le [query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Cloudera Hive, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in Cloudera Hive. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, riconosci l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-hive/pom.xml) relativo a questo connettore, e accetti i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-hive/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-hive/pom.xml) per il connettore Cloudera Hive su .com. GitHub
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudera-hive) su .com. GitHub
# Connettore Amazon Athena per Cloudera Impala
Il connettore Amazon Athena per Cloudera Hive consente ad Athena di eseguire query SQL sulla distribuzione [Cloudera Impala](https://docs.cloudera.com/cdw-runtime/cloud/impala-overview/topics/impala-overview.html). Il connettore trasforma le query SQL di Athena nella sintassi HiveQL equivalente.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
+ Prima di utilizzare questo connettore, configura un VPC e un gruppo di sicurezza. Per ulteriori informazioni, consulta [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
## Termini
I seguenti termini si riferiscono al connettore Cloudera Impala.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizza i parametri illustrati in questa sezione per configurare il connettore Cloudera Impala.
### Connessioni Glue (consigliate)
Consigliamo di configurare un connettore Cloudera Impala utilizzando un oggetto di connessioni Glue. Per fare ciò, imposta la variabile di ambiente `glue_connection` del connettore Lambda Cloudera Impala sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type CLOUDERAIMPALA
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Cloudera Impala creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore Cloudera Impala creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un cluster Impala.
```
impala://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | ImpalaMuxCompositeHandler |
| Gestore dei metadati | ImpalaMuxMetadataHandler |
| Gestore dei record | ImpalaMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione al cluster Impala per un catalogo Athena. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è myimpalacatalog, il nome della variabile di ambiente è myimpalacatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Impala MUX che supporta due istanze del database: `impala1` (il valore predefinito) e `impala2`.
****
| Proprietà | Valore |
| --- | --- |
| default | impala://jdbc:impala://some.impala.host.name:21050/?\$1\$1Test/impala1\$1 |
| impala\$1catalog1\$1connection\$1string | impala://jdbc:impala://someother.impala.host.name:21050/?\$1\$1Test/impala1\$1 |
| impala\$1catalog2\$1connection\$1string | impala://jdbc:impala://another.impala.host.name:21050/?UID=sample&PWD=sample |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/impala1host}`.
```
impala://jdbc:impala://Impala1host:21050/?...&${Test/impala1host}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
impala://jdbc:impala://Impala1host:21050/?...&UID=sample2&PWD=sample2&...
```
Attualmente, Cloudera Impala riconosce le proprietà JDBC `UID` e `PWD`.
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Cloudera Impala.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | ImpalaCompositeHandler |
| Gestore dei metadati | ImpalaMetadataHandler |
| Gestore dei record | ImpalaRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Cloudera Impala supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | impala://jdbc:impala://Impala1host:21050/?secret=\$1\$1Test/impala1host\$1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC, Cloudera Impala e Arrow.
****
| JDBC | Cloudera Impala | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Numero intero | TINYINT | Tiny |
| Breve | SMALLINT | Smallint |
| Numero intero | INT | Int |
| Long | BIGINT | Bigint |
| virgola mobile | float4 | Float4 |
| Double | float8 | Float8 |
| Data | date | DateDay |
| Time stamp | timestamp | DateMilli |
| Stringa | VARCHAR | Varchar |
| Byte | bytes | Varbinary |
| BigDecimal | Decimale | Decimale |
| ARRAY | N/D (vedi nota) | List |
**Nota**
Attualmente, Cloudera Impala non supporta i tipi di aggregati `ARRAY`, `MAP`, `STRUCT` e `UNIONTYPE`. Le colonne dei tipi di aggregati vengono trattate come colonne `VARCHAR` in SQL.
## Partizioni e suddivisioni
Le partizioni vengono utilizzate per determinare come generare suddivisioni per il connettore. Athena costruisce una colonna sintetica di tipo `varchar` che rappresenta lo schema di partizionamento della tabella per aiutare il connettore a generare suddivisioni. Il connettore non modifica la definizione effettiva della tabella.
## Performance
Cloudera Impala supporta le partizioni statiche. Il connettore Cloudera Impala di Athena può recuperare dati da queste partizioni in parallelo. Se desideri interrogare set di dati molto grandi con una distribuzione uniforme delle partizioni, ti consigliamo vivamente il partizionamento statico. Il connettore Cloudera Impala è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
Il connettore Athena Cloudera Impala esegue il pushdown dei predicati per ridurre i dati scansionati dalla query. Le clausole `LIMIT`, i predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati analizzati e il tempo di esecuzione delle query.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Athena Cloudera Impala può combinare queste espressioni e inviarle direttamente a Cloudera Impala per funzionalità avanzate e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena Cloudera Impala supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Query passthrough
Il connettore Cloudera Impala supporta le [query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Cloudera Impala, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in Cloudera Impala. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, riconosci l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-impala/pom.xml) relativo a questo connettore, e accetti i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-impala/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml per il connettore](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudera-impala/pom.xml) Cloudera Impala su .com. GitHub
Per ulteriori informazioni su questo connettore, visita [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudera-impala) su .com. GitHub
# Connettore Amazon Athena CloudWatch
Il CloudWatch connettore Amazon Athena consente la comunicazione CloudWatch con Amazon Athena in modo da poter interrogare i dati di log con SQL.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
Il connettore mappa i tuoi schemi LogGroups AS e ciascuno LogStream come tabella. Il connettore mappa anche una `all_log_streams` vista speciale che contiene tutto LogStreams in. LogGroup Questa visualizzazione consente di interrogare tutti i log in una sola LogGroup volta invece di cercarli LogStream singolarmente.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Parameters
Utilizzate i parametri di questa sezione per configurare il CloudWatch connettore.
### Connessioni Glue (consigliate)
Si consiglia di configurare un CloudWatch connettore utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del CloudWatch connettore Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type CLOUDWATCH
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il CloudWatch connettore creato utilizzando le connessioni Glue non supporta l'uso di un gestore di multiplexing.
Il CloudWatch connettore creato utilizzando le connessioni Glue supporta solo `ConnectionSchemaVersion` 2.
### Connessioni legacy
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
Il connettore supporta anche il [controllo della congestione AIMD per la](https://en.wikipedia.org/wiki/Additive_increase/multiplicative_decrease) gestione degli eventi di limitazione tramite il costrutto CloudWatch Amazon Athena Query Federation [SDK](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk). `ThrottlingInvoker` Puoi modificare il comportamento di limitazione predefinito impostando una delle seguenti variabili di ambiente facoltative:
+ **throttle\$1initial\$1delay\$1ms**: il ritardo iniziale della chiamata applicato dopo il primo evento di congestione. Il valore predefinito è 10 millisecondi.
+ **throttle\$1max\$1delay\$1ms**: il ritardo massimo tra le chiamate. Puoi derivare il TPS dividendolo per 1.000 ms. Il valore predefinito è 1000 millisecondi.
+ **throttle\$1decrease\$1factor**: il fattore in base al quale Athena riduce la frequenza delle chiamate. Il valore predefinito è 0.5
+ **throttle\$1increase\$1ms**: la velocità con cui Athena riduce il ritardo della chiamata. Il valore predefinito è 10 millisecondi.
## Database e tabelle
Il CloudWatch connettore Athena mappa gli schemi LogGroups AS (ovvero i database) e ciascuno LogStream come tabella. Il connettore mappa anche una `all_log_streams` vista speciale che contiene tutto LogStreams in. LogGroup Questa visualizzazione consente di interrogare tutti i log in una sola LogGroup volta invece di cercarli LogStream singolarmente.
Ogni tabella mappata dal connettore CloudWatch Athena ha lo schema seguente. Questo schema corrisponde ai campi forniti da CloudWatch Logs.
+ **log\$1stream** — Un `VARCHAR` che contiene il nome da LogStream cui proviene la riga.
+ **time**: un `INT64` che contiene l'ora epoch in cui è stata generata la riga del log.
+ **message**: un `VARCHAR` che contiene il messaggio di log.
**Esempi**
L'esempio seguente mostra come eseguire un'`SELECT`interrogazione su un oggetto specificato. LogStream
```
SELECT *
FROM "lambda:cloudwatch_connector_lambda_name"."log_group_path"."log_stream_name"
LIMIT 100
```
L'esempio seguente mostra come utilizzare la `all_log_streams` vista per eseguire un'interrogazione su tutti i dati LogStreams in uno specifico LogGroup.
```
SELECT *
FROM "lambda:cloudwatch_connector_lambda_name"."log_group_path"."all_log_streams"
LIMIT 100
```
## Autorizzazioni richieste
Consulta la sezione `Policies` del file [athena-cloudwatch.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudwatch/athena-cloudwatch.yaml) per i dettagli completi delle policy IAM richieste da questo connettore. L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **CloudWatch Lettura/scrittura dei registri**: il connettore utilizza questa autorizzazione per leggere i dati di registro e scrivere i registri di diagnostica.
## Performance
Il CloudWatch connettore Athena tenta di ottimizzare le query CloudWatch parallelizzando le scansioni dei flussi di log necessari per la query. Per determinati filtri temporali, il pushdown dei predicati viene eseguito sia all'interno della funzione Lambda che all'interno di Logs. CloudWatch
Per prestazioni ottimali, utilizza solo lettere minuscole per i nomi di gruppi di log e dei flussi di log. L'utilizzo di caratteri misti tra maiuscole e minuscole fa sì che il connettore esegua una ricerca senza distinzione tra maiuscole e minuscole, più impegnativa dal punto di vista computazionale.
**Nota**
Il CloudWatch connettore non supporta nomi di database in maiuscolo.
## Query passthrough
Il CloudWatch connettore supporta le query [passthrough che utilizzano la sintassi delle query](federated-query-passthrough.md) di [CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html) Insights. Per ulteriori informazioni su CloudWatch Logs Insights, consulta [Analyzing log data with CloudWatch Logs Insights nella *Amazon CloudWatch Logs*](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) User Guide.
Per creare query passthrough con CloudWatch, utilizza la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
STARTTIME => 'start_time',
ENDTIME => 'end_time',
QUERYSTRING => 'query_string',
LOGGROUPNAMES => 'log_group-names',
LIMIT => 'max_number_of_results'
))
```
Il seguente esempio di query CloudWatch passthrough filtra per il `duration` campo quando questo non è uguale a 1000.
```
SELECT * FROM TABLE(
system.query(
STARTTIME => '1710918615308',
ENDTIME => '1710918615972',
QUERYSTRING => 'fields @duration | filter @duration != 1000',
LOGGROUPNAMES => '/aws/lambda/cloudwatch-test-1',
LIMIT => '2'
))
```
## Informazioni sulla licenza
[Il progetto Amazon Athena CloudWatch Connector è concesso in licenza con licenza Apache-2.0.](https://www.apache.org/licenses/LICENSE-2.0.html)
## Risorse aggiuntive
[Per ulteriori informazioni su questo connettore, visita il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch) GitHub
# Connettore Amazon Athena Metrics CloudWatch
Il connettore Amazon Athena CloudWatch Metrics consente CloudWatch ad Amazon Athena di interrogare i dati di Metrics con SQL.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
Per informazioni sulla pubblicazione delle metriche delle query CloudWatch da Athena stessa, consulta. [Utilizza CloudWatch e monitora EventBridge le interrogazioni e controlla i costi](workgroups-control-limits.md)
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Parameters
Utilizza i parametri in questa sezione per configurare il connettore CloudWatch Metrics.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore CloudWatch Metrics utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore CloudWatch Metrics Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type CLOUDWATCHMETRICS
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore CloudWatch Metrics creato utilizzando le connessioni Glue non supporta l'uso di un gestore di multiplexing.
Il connettore CloudWatch Metrics creato utilizzando le connessioni Glue supporta solo `ConnectionSchemaVersion` 2.
### Connessioni legacy
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
Il connettore supporta anche il [controllo della congestione AIMD per la](https://en.wikipedia.org/wiki/Additive_increase/multiplicative_decrease) gestione degli eventi di limitazione tramite il costrutto CloudWatch Amazon Athena Query Federation [SDK](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk). `ThrottlingInvoker` Puoi modificare il comportamento di limitazione predefinito impostando una delle seguenti variabili di ambiente facoltative:
+ **throttle\$1initial\$1delay\$1ms**: il ritardo iniziale della chiamata applicato dopo il primo evento di congestione. Il valore predefinito è 10 millisecondi.
+ **throttle\$1max\$1delay\$1ms**: il ritardo massimo tra le chiamate. Puoi derivare il TPS dividendolo per 1.000 ms. Il valore predefinito è 1000 millisecondi.
+ **throttle\$1decrease\$1factor**: il fattore in base al quale Athena riduce la frequenza delle chiamate. Il valore predefinito è 0.5
+ **throttle\$1increase\$1ms**: la velocità con cui Athena riduce il ritardo della chiamata. Il valore predefinito è 10 millisecondi.
## Database e tabelle
Il connettore Athena CloudWatch Metrics mappa i namespace, le dimensioni, le metriche e i valori delle metriche in due tabelle in un unico schema chiamato. `default`
### La tabella metrics (parametri)
La tabella `metrics` contiene i parametri disponibili definiti in modo univoco da una combinazione di spazio del nome, set e nome. La tabella `metrics` contiene le colonne seguenti.
+ **namespace**: un `VARCHAR` contenente lo spazio del nome.
+ **metric\$1name**: un `VARCHAR` contenente il nome del parametro.
+ **dimensions**: un `LIST` di oggetti `STRUCT` composti da `dim_name (VARCHAR)` e `dim_value (VARCHAR)`.
+ **statistic**: un `LIST` di statistiche `VARCH` (ad esempio, `p90`, `AVERAGE`...) disponibili per il parametro.
### La tabella metric\$1samples (campioni dei parametri)
La tabella `metric_samples` contiene i campioni del parametro disponibili per ciascun parametro all'interno della tabella `metrics`. La tabella `metric_samples` contiene le colonne seguenti.
+ **namespace**: un `VARCHAR` contenente lo spazio del nome.
+ **metric\$1name**: un `VARCHAR` contenente il nome del parametro.
+ **dimensions**: un `LIST` di oggetti `STRUCT` composti da `dim_name (VARCHAR)` e `dim_value (VARCHAR)`.
+ **dim\$1name**: un campo di cortesia `VARCHAR` che puoi utilizzare per filtrare facilmente in base al nome di una singola dimensione.
+ **dim\$1value**: un campo di cortesia `VARCHAR` che puoi utilizzare per filtrare facilmente in base al valore di una singola dimensione.
+ **period**: un campo `INT` che rappresenta il "periodo" del parametro in secondi (ad esempio, il parametro può avere un valore di 60 secondi).
+ **timestamp**: un campo `BIGINT` che rappresenta l'ora epoch, espressa in secondi, alla quale il campione del parametro fa riferimento.
+ **value**: un campo `FLOAT8` che contiene il valore del campione.
+ **statistic**: un `VARCHAR` che contiene il tipo di statistica del campione (ad esempio, `AVERAGE` o `p90`).
## Autorizzazioni richieste
[Per tutti i dettagli sulle politiche IAM richieste da questo connettore, consulta la sezione del file.yaml. `Policies` athena-cloudwatch-metrics](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-cloudwatch-metrics/athena-cloudwatch-metrics.yaml) L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **CloudWatch Metriche ReadOnly**: il connettore utilizza questa autorizzazione per interrogare i dati delle metriche.
+ **CloudWatch Scrittura dei registri**: il connettore utilizza questo accesso per scrivere i registri di diagnostica.
## Performance
Il connettore Athena CloudWatch Metrics tenta di ottimizzare le query rispetto a CloudWatch Metrics parallelizzando le scansioni dei flussi di log necessari per la query. Per determinati filtri temporali, metrici, namespace e dimensioni, il pushdown dei predicati viene eseguito sia all'interno della funzione Lambda che all'interno dei log. CloudWatch
## Informazioni sulla licenza
[Il progetto Amazon Athena CloudWatch Metrics connector è concesso in licenza con la licenza Apache-2.0.](https://www.apache.org/licenses/LICENSE-2.0.html)
## Risorse aggiuntive
[Per ulteriori informazioni su questo connettore, visita il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch-metrics) GitHub
# Connettore Amazon Athena CMDB AWS
Il connettore Amazon Athena AWS CMDB consente ad Athena di comunicare con vari AWS servizi in modo da poterli interrogare con SQL.
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Parameters
Utilizza i parametri in questa sezione per configurare il AWS connettore CMDB.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore AWS CMDB utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore AWS CMDB Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type CMDB
```
**Proprietà dell’ambiente Lambda**
**glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore AWS CMDB creato utilizzando le connessioni Glue non supporta l'uso di un gestore di multiplexing.
Il connettore AWS CMDB creato utilizzando le connessioni Glue supporta solo `ConnectionSchemaVersion` 2.
### Connessioni legacy
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
**Proprietà dell’ambiente**
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **default\$1ec2\$1image\$1owner — (Facoltativo) Se impostato, controlla il proprietario** [predefinito dell'immagine Amazon EC2 che filtra Amazon Machine Images (AMI).](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) Se non imposti questo valore e la tua query nella tabella delle EC2 immagini non include un filtro per il proprietario, i risultati includeranno tutte le immagini pubbliche.
## Database e tabelle
Il connettore Athena AWS CMDB rende disponibili i seguenti database e tabelle per interrogare l'inventario delle risorse. AWS Per ulteriori informazioni sulle colonne disponibili in ogni tabella, esegui un'istruzione `DESCRIBE database.table` utilizzando la console o l'API Athena.
+ **ec2** — Questo database contiene risorse EC2 relative ad Amazon, tra cui le seguenti.
+ **ebs\$1volumes**: contiene i dettagli dei tuoi volumi Amazon EBS.
+ **ec2\$1instances: contiene i dettagli delle tue istanze**. EC2
+ **ec2\$1images — Contiene i dettagli delle immagini delle istanze**. EC2
+ **routing\$1tables**: contiene i dettagli delle tue tabelle di instradamento del VPC.
+ **security\$1groups**: contiene i dettagli dei tuoi gruppi di sicurezza.
+ **subnets**: contiene i dettagli delle tue sottoreti VPC.
+ **vpcs** — Contiene i dettagli del tuo. VPCs
+ **emr**: questo database contiene risorse correlate ad Amazon EMR, tra cui le seguenti.
+ **emr\$1clusters**: contiene i dettagli dei tuoi cluster EMR.
+ **rds**: questo database contiene risorse correlate ad Amazon RDS, tra cui le seguenti.
+ **rds\$1instances**: contiene i dettagli delle tue istanze RDS.
+ **s3**: questo database contiene risorse correlate a RDS, tra cui le seguenti.
+ **bucket**: contiene i dettagli dei tuoi bucket Amazon S3.
+ **objects**: contiene i dettagli dei tuoi oggetti Amazon S3, escluso il loro contenuto.
## Autorizzazioni richieste
Per tutti i dettagli sulle politiche IAM richieste da questo connettore, consulta la `Policies` sezione del [athena-aws-cmdbfile.yaml.](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-aws-cmdb/athena-aws-cmdb.yaml) L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **S3 List**: il connettore utilizza questa autorizzazione per elencare bucket e oggetti di Amazon S3.
+ **EC2 Descrivi**: il connettore utilizza questa autorizzazione per descrivere risorse come le EC2 istanze Amazon, i gruppi di sicurezza e i volumi Amazon EBS. VPCs
+ **EMR Describe / List**: il connettore utilizza questa autorizzazione per descrivere i cluster EMR.
+ **RDS Describe**: il connettore utilizza questa autorizzazione per descrivere le istanze RDS.
## Performance
Attualmente, il connettore Athena AWS CMDB non supporta le scansioni parallele. Il pushdown dei predicati viene eseguito all'interno della funzione Lambda. Ove possibile, i predicati parziali vengono inviati ai servizi interrogati. Ad esempio, una query per i dettagli di una specifica EC2 istanza Amazon richiama l' EC2 API con l'ID dell'istanza specifico per eseguire un'operazione di descrizione mirata.
## Informazioni sulla licenza
[Il progetto del connettore Amazon Athena AWS CMDB è concesso in licenza con licenza Apache-2.0.](https://www.apache.org/licenses/LICENSE-2.0.html)
## Risorse aggiuntive
[Per ulteriori informazioni su questo connettore, visita il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-aws-cmdb) GitHub
# Connettore IBM Db2 di Amazon Athena
Il connettore Amazon Athena per Db2 consente ad Amazon Athena di eseguire query SQL sui database IBM Db2 utilizzando JDBC.
Questo connettore può essere registrato con il Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
+ Prima di utilizzare questo connettore, configura un VPC e un gruppo di sicurezza. Per ulteriori informazioni, consulta [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Nelle condizioni di filtro, è necessario impostare i tipi di dati date e timestamp sul tipo di dati appropriato.
## Termini
I seguenti termini si riferiscono al connettore Db2.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizza i parametri illustrati in questa sezione per configurare il connettore Db2.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Db2 utilizzando un oggetto di connessioni Glue. Per fare ciò, imposta la variabile di ambiente`glue_connection` del connettore Lambda Db2 sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type DB2
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Db2 creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore Db2 creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
dbtwo://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | Db2MuxCompositeHandler |
| Gestore dei metadati | Db2MuxMetadataHandler |
| Gestore dei record | Db2MuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mydbtwocatalog, il nome della variabile di ambiente è mydbtwocatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Db2 MUX che supporta due istanze del database: `dbtwo1` (il valore predefinito) e `dbtwo2`.
****
| Proprietà | Valore |
| --- | --- |
| default | dbtwo://jdbc:db2://dbtwo1.hostname:port/database\$1name:\$1\$1secret1\$1name\$1 |
| dbtwo\$1catalog1\$1connection\$1string | dbtwo://jdbc:db2://dbtwo1.hostname:port/database\$1name:\$1\$1secret1\$1name\$1 |
| dbtwo\$1catalog2\$1connection\$1string | dbtwo://jdbc:db2://dbtwo2.hostname:port/database\$1name:\$1\$1secret2\$1name\$1 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${secret_name}`.
```
dbtwo://jdbc:db2://hostname:port/database_name:${secret_name}
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
dbtwo://jdbc:db2://hostname:port/database_name:user=user_name;password=password;
```
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Db2.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | Db2CompositeHandler |
| Gestore dei metadati | Db2MetadataHandler |
| Gestore dei record | Db2RecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Db2 supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | dbtwo: //jdbc:db2: //hostname:port/: \$1 \$1secret\$1name\$1 database\$1name |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC e Arrow.
****
| Db2 | Arrow |
| --- | --- |
| CHAR | VARCHAR |
| VARCHAR | VARCHAR |
| DATE | DATEDAY |
| TIME | VARCHAR |
| TIMESTAMP | DATEMILLI |
| DATETIME | DATEMILLI |
| BOOLEAN | BOOL |
| SMALLINT | SMALLINT |
| INTEGER | INT |
| BIGINT | BIGINT |
| DECIMAL | DECIMAL |
| REAL | FLOAT8 |
| DOUBLE | FLOAT8 |
| DECFLOAT | FLOAT8 |
## Partizioni e suddivisioni
Una partizione è rappresentata da una o più colonne di partizione di tipo `varchar`. Il connettore Db2 crea partizioni utilizzando i seguenti schemi organizzativi.
+ Distribuzione per hash
+ Partizione per intervallo
+ Organizzazione per dimensioni
Il connettore recupera i dettagli delle partizioni come il numero di partizioni e il nome della colonna da una o più tabelle di metadati Db2. Le suddivisioni vengono create in base al numero di partizioni distinte ricevute.
## Performance
Il connettore Athena Db2 esegue il pushdown dei predicati per ridurre i dati analizzati dalla query. Le clausole `LIMIT`, i predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati analizzati e per ridurre il tempo di esecuzione delle query.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Athena Db2 può combinare queste espressioni e inviarle direttamente a Db2 per migliorare le funzionalità e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena Db2 supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Ugualglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Query passthrough
Il connettore Db2 supporta le [query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Db2, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un’origine dati in Db2. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, riconosci l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2/pom.xml) relativo a questo connettore, e accetti i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consultate il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2/pom.xml) per il connettore Db2 su .com. GitHub
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-db2) su .com. GitHub
# Connettore Amazon Athena IBM Db2 AS/400 (Db2 iSeries)
Il connettore Amazon Athena per Db2 AS/400 consente ad Amazon Athena di eseguire query SQL sui database IBM Db2 AS/400 (Db2 iSeries) utilizzando JDBC.
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
+ Prima di utilizzare questo connettore, configura un VPC e un gruppo di sicurezza. Per ulteriori informazioni, consulta [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Nelle condizioni di filtro, è necessario impostare i tipi di dati date e timestamp sul tipo di dati appropriato.
## Termini
I seguenti termini si riferiscono al connettore Db2 AS/400.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizza i parametri illustrati in questa sezione per configurare il connettore Db2 AS/400.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Db2 AS/400 utilizzando un oggetto di connessioni Glue. Per fare ciò, impostare la variabile di ambiente `glue_connection` del connettore Db2 AS/400 Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type DB2AS400
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Db2 AS/400 creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore Db2 AS/400 creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
db2as400://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | Db2MuxCompositeHandler |
| Gestore dei metadati | Db2MuxMetadataHandler |
| Gestore dei record | Db2MuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mydb2as400catalog, il nome della variabile di ambiente è mydb2as400catalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Db2 MUX che supporta due istanze del database: `db2as4001` (il valore predefinito) e `db2as4002`.
****
| Proprietà | Valore |
| --- | --- |
| default | db2as400://jdbc:as400://;;:\$1\$1\$1; |
| db2as400\$1catalog1\$1connection\$1string | db2as400://jdbc:as400://db2as4001.hostname/:\$1\$1secret1\$1name\$1 |
| db2as400\$1catalog2\$1connection\$1string | db2as400://jdbc:as400://db2as4002.hostname/:\$1\$1secret2\$1name\$1 |
| db2as400\$1catalog3\$1connection\$1string | db2as400://jdbc:as400://;user=;password=;; |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${secret_name}`.
```
db2as400://jdbc:as400://;;:${};
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
db2as400://jdbc:as400://;user=;password=;;
```
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Db2 AS/400.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | Db2CompositeHandler |
| Gestore dei metadati | Db2MetadataHandler |
| Gestore dei record | Db2RecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Db2 AS/400 supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | db2as400://jdbc:as400://;;:\$1\$1\$1; |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC e Apache Arrow.
****
| Db2 AS/400 | Arrow |
| --- | --- |
| CHAR | VARCHAR |
| VARCHAR | VARCHAR |
| DATE | DATEDAY |
| TIME | VARCHAR |
| TIMESTAMP | DATEMILLI |
| DATETIME | DATEMILLI |
| BOOLEAN | BOOL |
| SMALLINT | SMALLINT |
| INTEGER | INT |
| BIGINT | BIGINT |
| DECIMAL | DECIMAL |
| REAL | FLOAT8 |
| DOUBLE | FLOAT8 |
| DECFLOAT | FLOAT8 |
## Partizioni e suddivisioni
Una partizione è rappresentata da una o più colonne di partizione di tipo `varchar`. Il connettore Db2 AS/400 crea partizioni utilizzando i seguenti schemi organizzativi.
+ Distribuzione per hash
+ Partizione per intervallo
+ Organizzazione per dimensioni
Il connettore recupera i dettagli delle partizioni come il numero di partizioni e il nome della colonna da una o più tabelle di metadati Db2 AS/400. Le suddivisioni vengono create in base al numero di partizioni distinte ricevute.
## Performance
Per prestazioni migliorate, utilizzare il pushdown del predicato per eseguire query su Athena, come negli esempi seguenti.
```
SELECT * FROM "lambda:"."".""
WHERE integercol = 2147483647
```
```
SELECT * FROM "lambda: "."".""
WHERE timestampcol >= TIMESTAMP '2018-03-25 07:30:58.878'
```
## Query passthrough
Il connettore Db2 AS/400 supporta le [query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Db2 AS/400, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un’origine dati in Db2 AS/400. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, riconosci l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2-as400/pom.xml) relativo a questo connettore, e accetti i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2-as400/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consultate il file [pom.xml per il connettore](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-db2-as400/pom.xml) Db2 AS/400 su .com. GitHub
[Per ulteriori informazioni su questo connettore, visitate il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-db2-as400) GitHub
# Connettore Amazon Athena DocumentDB
Il connettore DocumentDB per Amazon Athena consente ad Amazon Athena di comunicare con le istanze DocumentDB in modo da poter eseguire query sui dati DocumentDB con SQL. Il connettore funziona anche con qualsiasi endpoint compatibile con MongoDB.
A differenza dei tradizionali archivi di dati relazionali, le raccolte Amazon DocumentDB non hanno uno schema prestabilito. DocumentDB non dispone di un archivio dei metadati. Ogni voce in una raccolta DocumentDB può avere campi e tipi di dati diversi.
Il connettore DocumentDB supporta due meccanismi per la generazione di informazioni sullo schema della tabella: inferenza dello schema di base e metadati. AWS Glue Data Catalog
L'inferenza dello schema è l'impostazione predefinita. Questa opzione esegue la scansione di un numero limitato di documenti della raccolta, forma un'unione di tutti i campi e forza i campi che hanno tipi di dati non sovrapposti. Questa opzione funziona bene per le raccolte che hanno voci per lo più uniformi.
Per le raccolte con una maggiore varietà di tipi di dati, il connettore supporta il recupero dei metadati da AWS Glue Data Catalog. Se il connettore vede un AWS Glue database e una tabella che corrispondono al database DocumentDB e ai nomi delle raccolte, ottiene le informazioni sullo schema dalla tabella corrispondente AWS Glue . Quando crei la AWS Glue tabella, ti consigliamo di renderla un superset di tutti i campi a cui potresti voler accedere dalla tua raccolta DocumentDB.
Se hai abilitato Lake Formation nel tuo account, il ruolo IAM per il tuo connettore Lambda federato Athena che hai distribuito nell'accesso in lettura deve avere accesso in lettura in AWS Serverless Application Repository Lake Formation a. AWS Glue Data Catalog
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore DocumentDB.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore DocumentDB utilizzando un oggetto di connessioni Glue. Per fare ciò, impostare la variabile di ambiente `glue_connection` del connettore Lambda DocumentDB sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type DOCUMENTDB
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore DocumentDB creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore DocumentDB creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue** — (Facoltativo) Se presente e impostato su true, il connettore non tenta di recuperare metadati supplementari da. AWS Glue
+ **glue\$1catalog**: (facoltativo) utilizza questa opzione per specificare un [catalogo AWS Glue multi-account](data-sources-glue-cross-account.md). Per impostazione predefinita, il connettore tenta di ottenere metadati dal proprio account. AWS Glue
+ **default\$1docdb**: se presente, specifica una stringa di connessione DocumentDB da utilizzare quando non esiste alcuna variabile di ambiente specifica del catalogo.
+ **disable\$1projection\$1and\$1casing**: (facoltativo) disabilita la proiezione e la formattazione delle maiuscole. Usa questa opzione se desideri eseguire query sulle tabelle Amazon DocumentDB che utilizzano nomi di colonna con distinzione tra maiuscole e minuscole. Il parametro `disable_projection_and_casing` utilizza i seguenti valori per specificare il comportamento di formattazione di maiuscole e minuscole e della mappatura delle colonne:
+ **false**: si tratta dell'impostazione di default. La proiezione è abilitata e il connettore prevede che tutti i nomi delle colonne siano in minuscolo.
+ **true**: disabilita la proiezione e la combinazione di maiuscole e minuscole. Quando utilizzi il parametro `disable_projection_and_casing`, tieni presente i seguenti punti:
+ L'utilizzo del parametro può comportare un consumo maggiore di larghezza di banda. Inoltre, se la funzione Lambda non si trova nella stessa Regione AWS dell'origine dati, i costi di trasferimento standard tra Regioni AWS saranno più elevati a causa del maggiore utilizzo della larghezza di banda. Per ulteriori informazioni sui costi di trasferimento tra regioni, consulta la sezione Costi di [trasferimento AWS dei dati per le architetture server e serverless](https://aws.amazon.com/blogs/apn/aws-data-transfer-charges-for-server-and-serverless-architectures/) nel blog di Partner Network. AWS
+ Dato che viene trasferito un numero maggiore di byte e poiché un numero maggiore di byte richiede un tempo di deserializzazione maggiore, la latenza complessiva può aumentare.
+ **enable\$1case\$1insensitive\$1match**: (Facoltativo) quando `true`, esegue ricerche senza distinzione tra maiuscole e minuscole su nomi di schemi e tabelle in Amazon DocumentDB. Il valore predefinito è `false`. Utilizzalo se la tua query contiene nomi di schemi o tabelle in maiuscolo.
#### Specifica delle stringhe di connessione
Puoi specificare una o più proprietà che definiscono i dettagli di connessione DocumentDB per le istanze DocumentDB utilizzate con il connettore. A tale scopo, imposta una variabile di ambiente Lambda che corrisponda al nome del catalogo che desideri utilizzare in Athena. Ad esempio, supponiamo di voler utilizzare le seguenti query per interrogare due diverse istanze DocumentDB da Athena:
```
SELECT * FROM "docdb_instance_1".database.table
```
```
SELECT * FROM "docdb_instance_2".database.table
```
Prima di poter utilizzare queste due istruzioni SQL, devi aggiungere due variabili di ambiente alla funzione Lambda: `docdb_instance_1` e `docdb_instance_2`. Il valore di ciascuno deve essere una stringa di connessione DocumentDB nel formato seguente:
```
mongodb://:@:/?ssl=true&ssl_ca_certs=rds-combined-ca-bundle.pem&replicaSet=rs0
```
##### Utilizzo dei segreti
Facoltativamente, puoi utilizzare in parte o in tutto il valore Gestione dei segreti AWS per i dettagli della stringa di connessione. Per utilizzare la funzione Athena Federated Query con Secrets Manager, il VPC collegato alla funzione Lambda dovrebbe disporre dell'[accesso a Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) o di un [endpoint VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) per connettersi a Secrets Manager.
Se si utilizza la sintassi `${my_secret}` per inserire il nome di un segreto di Secrets Manager nella stringa di connessione, il connettore sostituisce esattamente `${my_secret}` con il valore di testo semplice di Secrets Manager. I segreti devono essere archiviati come segreti di testo semplice con valore `:`. I segreti memorizzati come `{username:,password:}` non verranno passati correttamente alla stringa di connessione.
I segreti possono essere utilizzati esclusivamente anche per l'intera stringa di connessione e il nome utente e la password possono essere definiti all'interno del segreto.
Ad esempio, supponiamo di impostare la variabile di ambiente Lambda per `docdb_instance_1` sul seguente valore:
```
mongodb://${docdb_instance_1_creds}@myhostname.com:123/?ssl=true&ssl_ca_certs=rds-combined-ca-bundle.pem&replicaSet=rs0
```
L'SDK Athena Query Federation tenta automaticamente di recuperare un segreto denominato `docdb_instance_1_creds` da Secrets Manager e inietta quel valore al posto di `${docdb_instance_1_creds}`. Qualsiasi parte della stringa di connessione racchiusa entro la combinazione di caratteri `${ }` viene interpretata come un segreto da Secrets Manager. Se specifichi un nome del segreto che il connettore non riesce a trovare in Secrets Manager, il connettore non sostituisce il testo.
## Recupero dei metadati supplementari
Per recuperare metadati supplementari, seguire questi passaggi per configurare il database e la tabella Glue.
### Configurazione del database Glue
1. Crea un database Glue con lo stesso nome della tua raccolta DocumentDB.
1. Nel campo Location URI, immettete `docdb-metadata-flag`.
### Configurazione della tabella Glue
Aggiungere i seguenti parametri alla tabella Glue:
+ `docdb-metadata-flag = true`
+ `columnMapping = apple=APPLE`
In questo esempio, `apple` rappresenta il nome della colonna in minuscolo in Glue e `APPLE` rappresenta il nome effettivo della colonna con distinzione tra maiuscole e minuscole nella raccolta DocumentDB.
### Verifica del recupero dei metadati
1. Eseguire la query.
1. Controlla i CloudWatch log della funzione Lambda per il corretto recupero dei metadati. Un recupero riuscito mostrerà la seguente voce di registro:
```
doGetTable: Retrieved schema for table[TableName{schemaName=test, tableName=profiles}] from AWS Glue.
```
**Nota**
Se la tabella ha già un campo `columnMapping` configurato, è sufficiente aggiungere il parametro `docdb-metadata-flag = true` alle proprietà della tabella.
## Configurazione di database e tabelle in AWS Glue
Poiché la funzionalità di inferenza dello schema integrata nel connettore esegue la scansione di un numero limitato di documenti e supporta solo un sottoinsieme di tipi di dati, è consigliabile utilizzarla invece AWS Glue per i metadati.
Per abilitare una AWS Glue tabella da utilizzare con Amazon DocumentDB, devi disporre di un database e di una tabella per il AWS Glue database e la raccolta DocumentDB per i quali desideri fornire metadati supplementari.
**Per utilizzare una tabella per metadati supplementari AWS Glue**
1. Usa la AWS Glue console per creare un AWS Glue database con lo stesso nome del database Amazon DocumentDB.
1. Imposta la proprietà URI del database da includere **docdb-metadata-flag**.
1. (Facoltativo) Aggiungi la proprietà della tabella **sourceTable**. Questa proprietà definisce il nome della tabella di origine in Amazon DocumentDB. Usa questa proprietà se la AWS Glue tabella ha un nome diverso dal nome della tabella in Amazon DocumentDB. Le differenze nelle regole di denominazione tra Amazon DocumentDB AWS Glue e Amazon DocumentDB possono renderlo necessario. Ad esempio, le lettere maiuscole non sono consentite nei nomi AWS Glue delle tabelle, ma sono consentite nei nomi delle tabelle di Amazon DocumentDB.
1. (Facoltativo) Aggiungi la proprietà della tabella **columnMapping**. Questa proprietà definisce le mappature dei nomi delle colonne. Utilizza questa proprietà se le regole di denominazione delle AWS Glue colonne impediscono di creare una AWS Glue tabella con gli stessi nomi di colonna di quelli della tabella Amazon DocumentDB. Ciò può essere utile perché le lettere maiuscole sono consentite nei nomi delle colonne Amazon DocumentDB, ma non sono permesse nei nomi delle colonne AWS Glue .
Il valore della proprietà `columnMapping` dovrebbe essere un insieme di mappature nel formato `col1=Col1,col2=Col2`.
**Nota**
Il mapping di colonne si applica solo ai nomi delle colonne di primo livello e non ai campi annidati.
Dopo aver aggiunto la proprietà AWS Glue `columnMapping` table, puoi rimuovere la variabile di ambiente `disable_projection_and_casing` Lambda.
1. Assicurati di utilizzare i tipi di dati AWS Glue appropriati elencati in questo documento.
## Supporto dei tipi di dati
Questa sezione elenca i tipi di dati utilizzati dal connettore DocumentDB per l'inferenza dello schema e i tipi di dati quando vengono utilizzati i AWS Glue metadati.
### Tipi di dati di inferenza dello schema
La funzionalità di inferenza dello schema del connettore DocumentDB tenta di dedurre i valori come appartenenti a uno dei seguenti tipi di dati. Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per Amazon DocumentDB, Java e Apache Arrow.
****
| Apache Arrow | Java o DocDB |
| --- | --- |
| VARCHAR | Stringa |
| INT | Numero intero |
| BIGINT | Long |
| BIT | Booleano |
| FLOAT4 | Float |
| FLOAT8 | Double |
| TIMESTAMPSEC | Data |
| VARCHAR | ObjectId |
| LIST | List |
| STRUCT | Documento |
### AWS Glue tipi di dati
Se si utilizzano AWS Glue metadati supplementari, è possibile configurare i seguenti tipi di dati. La tabella mostra i tipi di dati corrispondenti per AWS Glue e Apache Arrow.
****
| AWS Glue | Apache Arrow |
| --- | --- |
| int | INT |
| bigint | BIGINT |
| virgola mobile a doppia precisione | FLOAT8 |
| virgola mobile | FLOAT4 |
| booleano | BIT |
| binary | VARBINARY |
| stringa | VARCHAR |
| List | LIST |
| Struct | STRUCT |
## Autorizzazioni richieste
Consulta la sezione `Policies` del file [athena-docdb.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-docdb/athena-docdb.yaml) per i dettagli completi delle policy IAM richieste da questo connettore. L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **AWS Glue Data Catalog**— Il connettore DocumentDB richiede l'accesso in sola lettura per AWS Glue Data Catalog ottenere informazioni sullo schema.
+ **CloudWatch Registri**: il connettore richiede l'accesso ai CloudWatch registri per l'archiviazione dei registri.
+ **Gestione dei segreti AWS accesso in lettura**: se si sceglie di archiviare i dettagli degli endpoint di DocumentDB in Secrets Manager, è necessario concedere al connettore l'accesso a tali segreti.
+ **Accesso VPC**: il connettore richiede la capacità di collegare e scollegare le interfacce al VPC in modo che possa connettersi ad esso e comunicare con le istanze DocumentDB.
## Performance
Il connettore Amazon DocumentDB per Athena al momento non supporta le scansioni in parallelo, ma tenta di eseguire il pushdown dei predicati come parte delle query DocumentDB e i predicati sugli indici della raccolta DocumentDB risultano in una quantità di dati scansionati significativamente inferiore.
La funzione Lambda esegue il pushdown dei predicati per ridurre la quantità di dati scansionati dalla query. Tuttavia, la selezione di un sottoinsieme di colonne a volte comporta un runtime delle query più lungo. Le clausole `LIMIT` riducono la quantità di dati scansionati, ma se non viene fornito un predicato, le query `SELECT` con una clausola `LIMIT` eseguiranno la scansione di almeno 16 MB di dati.
## Query passthrough
Il connettore Amazon DocumentDB Athenasupporta le [query passthrough](federated-query-passthrough.md) ed è basato su NoSQL. Per ulteriori informazioni sull’esecuzione di query in Amazon DocumentDB, consultare [Esecuzione query](https://docs.aws.amazon.com/documentdb/latest/developerguide/querying.html) nella *Guida per gli sviluppatori Amazon DocumentDB.*
Per utilizzare query passthrough con Amazon DocumentDB, utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
database => 'database_name',
collection => 'collection_name',
filter => '{query_syntax}'
))
```
L’esempio seguente interroga il database `example` all’interno della raccolta`TPCDS`, filtrando tutti i libri con il titolo *Bill of Rights*.
```
SELECT * FROM TABLE(
system.query(
database => 'example',
collection => 'tpcds',
filter => '{title: "Bill of Rights"}'
))
```
## Risorse aggiuntive
+ *Per un articolo sull'utilizzo di [Amazon Athena Federated Query per connettere un database MongoDB a Quick](federated-queries.md) per creare dashboard e visualizzazioni, consulta Visualizzare i dati [MongoDB da [Quick](https://aws.amazon.com/quicksight/) utilizzando Amazon Athena Federated Query nel Big Data Blog](https://aws.amazon.com/blogs/big-data/visualize-mongodb-data-from-amazon-quicksight-using-amazon-athena-federated-query/).AWS *
+ [Per ulteriori informazioni su questo connettore, visita il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-docdb) GitHub
# Connettore Amazon Athena DynamoDB
Il connettore Amazon Athena DynamoDB consente ad Amazon Athena di comunicare con DynamoDB in modo da poter eseguire query sulle tabelle con SQL. Operazioni di scrittura come [INSERT INTO](insert-into.md) non sono supportate.
Questo connettore può essere registrato con il Catalogo Dati Glue Data come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
Se hai abilitato Lake Formation nel tuo account, il ruolo IAM per il tuo connettore Lambda federato Athena che hai distribuito nell'accesso in lettura deve avere accesso in lettura in AWS Serverless Application Repository Lake Formation a. AWS Glue Data Catalog
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
Se migri le tue connessioni DynamoDB a Catalogo Glue e Lake Formation, verranno riconosciuti solo i nomi minuscoli di tabelle e colonne.
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore DynamoDB.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore DynamoDB utilizzando un oggetto di connessioni Glue. Per fare ciò, imposta la variabile di ambiente `glue_connection` del connettore DynamoDB Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type DYNAMODB
```
**Proprietà dell’ambiente Lambda**
**glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore DynamoDB creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore DynamoDB creato utilizzando le connessioni Glue supporta solo 2m`ConnectionSchemaVersion`.
### Connessioni legacy
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
**Proprietà dell’ambiente**
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue** — (Facoltativo) Se presente e impostato su true, il connettore non tenta di recuperare metadati supplementari da. AWS Glue
+ **glue\$1catalog**: (facoltativo) utilizza questa opzione per specificare un [catalogo AWS Glue multi-account](data-sources-glue-cross-account.md). Per impostazione predefinita, il connettore tenta di ottenere metadati dal proprio account. AWS Glue
+ **disable\$1projection\$1and\$1casing**: (facoltativo) disabilita la proiezione e la formattazione delle maiuscole. Puoi utilizzarlo se desideri interrogare le tabelle DynamoDB che contengono lettere maiuscole e minuscole nei nomi delle colonne e non desideri specificare una proprietà `columnMapping` nella tua tabella AWS Glue .
Il parametro `disable_projection_and_casing` utilizza i seguenti valori per specificare il comportamento di formattazione di maiuscole e minuscole e della mappatura delle colonne:
+ **auto**: disabilita la proiezione e la formattazione di maiuscole e minuscole quando viene rilevato un tipo precedentemente non supportato e la mappatura dei nomi delle colonne non è impostata sulla tabella. Questa è l'impostazione predefinita.
+ **always**: disabilita la proiezione e la formattazione di maiuscole e minuscole in modo incondizionato. È utile quando i nomi delle colonne DynamoDB contengono lettere maiuscole e minuscole ma non desideri specificare alcuna mappatura dei nomi delle colonne.
Quando utilizzi il parametro `disable_projection_and_casing`, tieni presente i seguenti punti:
+ L'utilizzo del parametro può comportare un consumo maggiore di larghezza di banda. Inoltre, se la funzione Lambda non si trova nella stessa Regione AWS dell'origine dati, i costi di trasferimento standard tra Regioni AWS saranno più elevati a causa del maggiore utilizzo della larghezza di banda. Per ulteriori informazioni sui costi di trasferimento tra regioni, consulta la sezione Costi di [trasferimento AWS dei dati per le architetture server e serverless](https://aws.amazon.com/blogs/apn/aws-data-transfer-charges-for-server-and-serverless-architectures/) nel blog di Partner Network. AWS
+ Dato che viene trasferito un numero maggiore di byte e poiché un numero maggiore di byte richiede un tempo di deserializzazione maggiore, la latenza complessiva può aumentare.
## Configurazione di database e tabelle in AWS Glue
Poiché la capacità di inferenza dello schema integrata nel connettore è limitata, potresti volerla utilizzare AWS Glue per i metadati. A tale scopo, è necessario disporre di un database e di una tabella. AWS Glue Per abilitarli all'uso con DynamoDB, è necessario modificarne le proprietà.
**Per modificare le proprietà del database nella AWS Glue console**
1. Accedere a Console di gestione AWS e aprire la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel riquadro di navigazione, espandi **Data Catalog** (Catalogo dati), quindi seleziona **Databases** (Database).
Nella pagina **Databases** (Database), puoi modificare un database esistente oppure scegliere **Add database** (Aggiungi database) per crearne uno.
1. Nell'elenco dei database, scegli il link del database da modificare.
1. Scegli **Modifica**.
1. Nella pagina **Update a database** (Aggiorna un database), alla voce **Database settings** (Impostazioni database, in **Location** (Posizione), aggiungi la stringa **dynamo-db-flag**. Questa parola chiave indica che il database contiene tabelle che il connettore Athena DynamoDB utilizza per metadati supplementari ed è necessaria per database diversi da. AWS Glue `default` La proprietà `dynamo-db-flag` è utile per filtrare i database negli account che hanno numerosi database.
1. Scegli **Update Database** (Aggiorna database).
**Per modificare le proprietà delle tabelle nella console AWS Glue**
1. Accedere a Console di gestione AWS e aprire la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel riquadro di navigazione, espandi **Data Catalog** (Catalogo dati), quindi seleziona **Tables** (Tabelle).
1. Nella pagine **Tables** (Tabelle), nell’elenco delle tabelle, seleziona il link della tabella che intendi modificare.
1. Scegli **Actions** (Operazioni), **Edit** (Modifica).
1. Nella pagina **Edit table** (Modifica tabella), nella sezione **Table properties** (Proprietà della tabella), aggiungi le seguenti proprietà della tabella in base alle necessità. Se si utilizza il crawler AWS Glue DynamoDB, queste proprietà vengono impostate automaticamente.
+ **DynamoDB**: stringa che indica al connettore DynamoDB per Athena che la tabella può essere utilizzata per metadati supplementari. Inserisci la stringa `dynamodb` nelle proprietà della tabella in un campo denominato **classification** (classificazione), con una corrispondenza esatta.
**Nota**
**La pagina **Imposta le proprietà della tabella** che fa parte del processo di creazione della tabella nella AWS Glue console contiene una sezione **Formato dati con un campo Classificazione**.** Qui non puoi immettere o scegliere `dynamodb`. Invece, dopo aver creato la tabella, completa le operazioni per modificare la tabella e inserire `classification` e `dynamodb` come coppia chiave-valore nella sezione **Proprietà della tabella**.
+ **sourceTable**: proprietà facoltativa della tabella che definisce il nome della tabella di origine in DynamoDB. Usalo se le regole di denominazione delle AWS Glue tabelle ti impediscono di creare una AWS Glue tabella con lo stesso nome della tabella DynamoDB. Ad esempio, le lettere maiuscole non sono consentite nei nomi delle AWS Glue tabelle, ma sono consentite nei nomi delle tabelle DynamoDB.
+ **columnMapping**: proprietà facoltativa della tabella che definisce le mappature dei nomi delle colonne. Usalo se le regole di denominazione delle AWS Glue colonne ti impediscono di creare una AWS Glue tabella con gli stessi nomi di colonna della tabella DynamoDB. Ad esempio, le lettere maiuscole non sono consentite nei nomi delle AWS Glue colonne, ma sono consentite nei nomi delle colonne di DynamoDB. Il valore della proprietà dovrebbe essere nel formato col1=Col1,col2=Col2. Il mapping di colonne si applica solo ai nomi delle colonne di primo livello e non ai campi nidificati.
+ **defaultTimeZone**— Proprietà opzionale della tabella che viene applicata a `datetime` valori `date` o valori che non hanno un fuso orario esplicito. L'impostazione di questo valore è una buona pratica per evitare discrepanze tra il fuso orario predefinito dell'origine dei dati e il fuso orario della sessione Athena.
+ **datetimeFormatMapping**— Proprietà opzionale della tabella che specifica il `datetime` formato `date` or da utilizzare per l'analisi dei dati da una colonna del tipo di dati AWS Glue `date` or`timestamp`. Se questa proprietà non viene specificata, il connettore tenta di [dedurre](https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/time/DateFormatUtils.html) un formato ISO-8601. Se il connettore non è in grado di dedurre il formato di `date` o `datetime` oppure di analizzare la stringa non elaborata, il valore viene omesso dal risultato.
Il valore `datetimeFormatMapping` deve essere nel formato `col1=someformat1,col2=someformat2`. Di seguito sono riportati alcuni formati di esempio:
```
yyyyMMdd'T'HHmmss
ddMMyyyy'T'HH:mm:ss
```
Se la tua colonna ha valori `date` o `datetime` senza fuso orario e desideri utilizzare la colonna nella clausola `WHERE`, imposta la proprietà `datetimeFormatMapping` per la colonna.
1. Se definisci le colonne in modalità manuale, assicurati di utilizzare i tipi di dati appropriati. Se hai usato un crawler, convalida le colonne e i tipi rilevati dal crawler.
1. Scegli **Save** (Salva).
## Autorizzazioni richieste
Consulta la sezione `Policies` del file [athena-dynamodb.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-dynamodb/athena-dynamodb.yaml) per i dettagli completi delle policy IAM richieste da questo connettore. L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **AWS Glue Data Catalog**— Il connettore DynamoDB richiede l'accesso in sola lettura per ottenere informazioni sullo AWS Glue Data Catalog schema.
+ **CloudWatch Registri**: il connettore richiede l'accesso ai CloudWatch registri per l'archiviazione dei log.
+ **Accesso in lettura a DynamoDB**: il connettore utilizza le operazioni API `DescribeTable`, `ListSchemas`, `ListTables`, `Query` e `Scan`.
## Performance
Il connettore DynamoDB per Athena supporta le scansioni in parallelo e tenta di eseguire il pushdown dei predicati come parte delle query DynamoDB. Un predicato hash key con valori `X` distinti genera `X` chiamate di query a DynamoDB. Tutti gli altri scenari di predicato danno come risultato un numero `Y` di chiamate di scansione, dove `Y` viene determinato euristicamente in base alla dimensione della tabella e alla velocità di trasmissione effettiva allocata. Tuttavia, la selezione di un sottoinsieme di colonne comporta un runtime di esecuzione delle query più lungo.
Viene eseguito il pushdown delle clausole `LIMIT` e dei predicati semplici, il che può ridurre la quantità di dati scansionati e, di conseguenza, il runtime di esecuzione delle query.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Per migliorare le funzionalità e ridurre la quantità di dati scansionati, il connettore Athena DynamoDB può combinare queste espressioni e inviarle direttamente a DynamoDB.
I seguenti operatori del connettore DynamoDB di Athena supportano il pushdown dei predicati:
+ **Boolean: **AND
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1NULL
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10 and col_b < 10
LIMIT 10
```
Per un articolo sull'utilizzo del pushdown del predicato per migliorare le prestazioni nelle query federate, incluso DynamoDB, consulta [Come migliorare le query federate con il pushdown del predicato in Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-federated-queries-with-predicate-pushdown-in-amazon-athena/) nel *Blog sui Big Data di AWS *.
## Query passthrough
Il connettore DynamoDB supporta le [query passthrough](federated-query-passthrough.md) e utilizza la sintassi PartiQL. L'operazione API [GetItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html)DynamoDB non è supportata. Per informazioni sull’interrogazione di DynamoDB utilizzando PartiQL, consulta [Istruzioni selezionate PartiQL per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) nella *Guida per sviluppatori Amazon DynamoDB.*
Per utilizzare le query passthrough con DynamoDB, utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query_string'
))
```
Il seguente esempio di query passthrough DynamoDB utilizza PartiQL per restituire un elenco di dispositivi Fire TV Stick che hanno una proprietà `DateWatched` successiva al 24/12/22.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT Devices
FROM WatchList
WHERE Devices.FireStick.DateWatched[0] > '12/24/22''
))
```
## Risoluzione dei problemi
### Filtri multipli su una colonna con chiave di ordinamento
**Messaggio di errore**: KeyConditionExpressionsdeve contenere solo una condizione per chiave
**Causa**: questo problema può verificarsi nella versione 3 del motore Athena nelle query che hanno un filtro con limite sia inferiore sia superiore su una colonna con chiave di ordinamento DynamoDB. Poiché DynamoDB non supporta più di una condizione di filtro su una chiave di ordinamento, quando il connettore tenta di inviare una query a cui sono applicate entrambe le condizioni, viene generato un errore.
**Soluzione**: aggiorna il connettore alla versione 2023.11.1 o successiva. Per istruzioni sull'aggiornamento di un connettore, consulta [Aggiornare un connettore di origine dati](connectors-updating.md).
## Costi
I costi di utilizzo del connettore dipendono dalle AWS risorse sottostanti utilizzate. Poiché le query che utilizzano scansioni possono consumare un gran numero di [unità di capacità di lettura (RCUs)](https://aws.amazon.com/dynamodb/pricing/provisioned/), considera attentamente le informazioni relative ai prezzi di [Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
## Risorse aggiuntive
+ Per un'introduzione all'utilizzo del connettore Amazon Athena DynamoDB, consulta [Accesso, esecuzione di query e join di tabelle Amazon DynamoDB con Athena](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/access-query-and-join-amazon-dynamodb-tables-using-athena.html) nella guida *AWS Prescriptive Guidance Patterns*.
+ [Per un articolo su come utilizzare il connettore Athena DynamoDB per interrogare i dati in DynamoDB con SQL e visualizzare approfondimenti in Quick, consulta il *post del AWS blog Big Data Visualizza le informazioni di Amazon DynamoDB in Quick usando il connettore Amazon Athena DynamoDB* e. AWS Glue](https://aws.amazon.com/blogs/big-data/visualize-amazon-dynamodb-insights-in-amazon-quicksight-using-the-amazon-athena-dynamodb-connector-and-aws-glue/)
+ [Per un articolo sull'utilizzo del connettore Amazon Athena DynamoDB con Amazon DynamoDB, Athena e Quick per creare una dashboard di governance semplice, consulta il post sul blog Big *AWS Data Interroga tabelle Amazon DynamoDB cross-account usando Amazon Athena Federated Query*.](https://aws.amazon.com/blogs/big-data/query-cross-account-amazon-dynamodb-tables-using-amazon-athena-federated-query/)
+ [Per ulteriori informazioni su questo connettore, visita il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-dynamodb) GitHub
# Connettore Google Amazon Athena BigQuery
Il connettore Amazon Athena per Google [BigQuery](https://cloud.google.com/bigquery/)consente ad Amazon Athena di eseguire query SQL sui tuoi dati Google. BigQuery
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le funzioni Lambda hanno un valore di timeout massimo di 15 minuti. Ogni split esegue una query su BigQuery e deve terminare con un tempo sufficiente per memorizzare i risultati da consentire ad Athena di leggerli. Se la funzione Lambda scade, la query ha esito negativo.
+ Google distingue tra maiuscole e BigQuery minuscole. Il connettore tenta di correggere le maiuscole e minuscole dei nomi dei set di dati, dei nomi delle tabelle e del progetto IDs. Ciò è necessario perché Athena applica la formattazione minuscola a tutti i metadati. Queste correzioni effettuano molte chiamate aggiuntive a Google. BigQuery
+ I tipi di dati binari non sono supportati.
+ A causa della BigQuery concorrenza e dei limiti di quota di Google, il connettore potrebbe riscontrare problemi con i limiti di quota di Google. Per evitare questi problemi, imponi a Google BigQuery il maggior numero possibile di vincoli. Per informazioni sulle BigQuery quote, consulta Quote [e limiti nella documentazione di Google](https://cloud.google.com/bigquery/quotas). BigQuery
## Parameters
Utilizza i parametri di questa sezione per configurare il connettore Google BigQuery .
### Connessioni Glue (consigliate)
Ti consigliamo di configurare un BigQuery connettore Google utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del BigQuery connettore Google Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type BIGQUERY
```
**Proprietà dell’ambiente Lambda**
**glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il BigQuery connettore Google creato utilizzando le connessioni Glue non supporta l'uso di un gestore di multiplexing.
Il BigQuery connettore Google creato utilizzando le connessioni Glue supporta solo `ConnectionSchemaVersion` 2.
### Connessioni legacy
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
**Proprietà dell’ambiente**
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **gcp\$1project\$1id**: l'ID del progetto (non il nome del progetto) che contiene i set di dati da cui il connettore deve leggere (ad esempio, `semiotic-primer-1234567`).
+ **secret\$1manager\$1gcp\$1creds\$1name — Il nome del segreto all'interno Gestione dei segreti AWS del quale sono contenute le credenziali** in formato JSON (ad esempio,). BigQuery `GoogleCloudPlatformCredentials`
+ **big\$1query\$1endpoint** — (Facoltativo) L'URL di un endpoint privato. BigQuery Utilizza questo parametro quando desideri accedere tramite un endpoint privato. BigQuery
## Suddivisioni e visualizzazioni
Poiché il BigQuery connettore utilizza l'API BigQuery Storage Read per interrogare le tabelle e l'API BigQuery Storage non supporta le visualizzazioni, il connettore utilizza il BigQuery client con un'unica suddivisione per le viste.
## Performance
Per interrogare le tabelle, il BigQuery connettore utilizza l'API BigQuery Storage Read, che utilizza un protocollo basato su RPC che fornisce un accesso rapido allo storage BigQuery gestito. Per ulteriori informazioni sull'API BigQuery Storage Read, consulta [Utilizzare l'API BigQuery Storage Read per leggere i dati delle tabelle](https://cloud.google.com/bigquery/docs/reference/storage) nella documentazione di Google Cloud.
La selezione di un sottoinsieme di colonne velocizza notevolmente il runtime delle query e riduce i dati scansionati. Il connettore è soggetto a errori di query all'aumentare della simultaneità e generalmente è lento.
Il BigQuery connettore Google Athena esegue il pushdown dei predicati per ridurre i dati scansionati dalla query. `LIMIT`clausole, `ORDER BY` clausole, predicati semplici ed espressioni complesse vengono inserite nel connettore per ridurre la quantità di dati analizzati e ridurre il tempo di esecuzione delle query.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Query top N
Una query top `N` principale specifica un ordinamento dei set di risultati e un limite al numero di righe restituite. Puoi utilizzare questo tipo di query per determinare i valori massimi top `N` o i valori minimi top `N` per i set di dati. Con il pushdown top `N`, il connettore restituisce solo le righe ordinate `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il BigQuery connettore Google Athena può combinare queste espressioni e inviarle direttamente a Google BigQuery per funzionalità avanzate e ridurre la quantità di dati scansionati.
I seguenti operatori del BigQuery connettore Google Athena supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
ORDER BY col_a DESC
LIMIT 10;
```
## Query passthrough
[Il BigQuery connettore Google supporta le query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Google BigQuery, puoi utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a una fonte di dati in Google. BigQuery La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
[Il progetto Amazon Athena Google BigQuery Connector è concesso in licenza con la licenza Apache-2.0.](https://www.apache.org/licenses/LICENSE-2.0.html)
[Utilizzando questo connettore, riconosci l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-google-bigquery/pom.xml) relativo a questo connettore, e accetti i termini delle rispettive licenze di terze parti fornite nel file LICENSE.txt su .com.](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-google-bigquery/LICENSE.txt) GitHub
## Risorse aggiuntive
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-google-bigquery) su GitHub .com.
# Connettore Google Cloud Storage per Amazon Athena
Il connettore Google Cloud Storage di Amazon Athena consente ad Amazon Athena di eseguire query su file Parquet e CSV archiviati in un bucket Google Cloud Storage (GCS). Dopo aver raggruppato uno o più file Parquet o CSV in una cartella partizionata o non partizionata in un bucket GCS, sarà possibile organizzarli in una tabella di database [AWS Glue](https://aws.amazon.com/glue/).
Questo connettore può essere registrato con il Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
Se hai abilitato Lake Formation nel tuo account, il ruolo IAM per il tuo connettore Lambda federato Athena che hai distribuito nell'accesso in lettura deve avere accesso in lettura in AWS Serverless Application Repository Lake Formation a. AWS Glue Data Catalog
Per un articolo che mostra come utilizzare Athena per eseguire query su file Parquet o CSV in un bucket GCS, consulta il post sul blog AWS Big Data Use Amazon [Athena per interrogare i dati archiviati in Google Cloud Platform](https://aws.amazon.com/blogs/big-data/use-amazon-athena-to-query-data-stored-in-google-cloud-platform/).
## Prerequisiti
+ Configura un AWS Glue database e una tabella che corrispondano al tuo bucket e alle tue cartelle in Google Cloud Storage. Per i passaggi, consulta [Configurazione di database e tabelle in AWS Glue](#connectors-gcs-setting-up-databases-and-tables-in-glue) più avanti in questo documento.
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Attualmente, il connettore supporta solo il `VARCHAR` tipo per le colonne di partizione (`string`o `varchar` in uno schema AWS Glue tabellare). Altri tipi di campi di partizione generano errori quando vengono interrogati in Athena.
## Termini
I seguenti termini si riferiscono al connettore GCS.
+ **Gestore**: un gestore Lambda che accede al bucket GCS. Un gestore può gestire i metadati o i record di dati.
+ **Metadata handler** (Gestore dei metadati): un gestore Lambda che recupera i metadati dal bucket GCS.
+ **Record handler** (Gestore dei record): un gestore Lambda che recupera i record di dati dal bucket GCS.
+ **Composite handler** (Gestore composito): un gestore Lambda che recupera sia i metadati sia i record di dati dal bucket GCS.
## Tipi di file supportati
Il connettore GCS supporta i tipi di file Parquet e CSV.
**Nota**
Assicurati di non inserire entrambi i file CSV e Parquet nello stesso bucket o percorso GCS. Ciò potrebbe causare un errore di runtime quando si prova a leggere i file Parquet come CSV o viceversa.
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore GCS.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore GCS utilizzando un oggetto di connessioni Glue. Per fare ciò, imposta la variabile di ambiente `glue_connection` del connettore GCS Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type GOOGLECLOUDSTORAGE
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore GCS creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore GCS creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **secret\$1manager\$1gcp\$1creds\$1name — Il nome del segreto Gestione dei segreti AWS che contiene le tue credenziali** GCS in formato JSON (ad esempio,). `GoogleCloudPlatformCredentials`
## Configurazione di database e tabelle in AWS Glue
Poiché la funzionalità integrata di inferenza dello schema del connettore GCS è limitata, si consiglia di utilizzarla AWS Glue per i metadati. Le procedure seguenti mostrano come creare un database e una tabella a AWS Glue cui è possibile accedere da Athena.
### Creazione di un database in AWS Glue
È possibile utilizzare la AWS Glue console per creare un database da utilizzare con il connettore GCS.
**Per creare un database in AWS Glue**
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 pannello di navigazione seleziona **Databases** (Database).
1. Scegli **Aggiungi database**.
1. In **Name** (Nome) immetti un nome per il database che desideri utilizzare con il connettore GCS.
1. Per **Location**, specificare`google-cloud-storage-flag`. Questa posizione indica al connettore GCS che il AWS Glue database contiene tabelle per i dati GCS da interrogare in Athena. Il connettore riconosce i database in Athena che hanno questo flag e ignora quelli che non lo hanno.
1. Scegliere **Crea database**.
### Creazione di una tabella in AWS Glue
Ora puoi creare una tabella per il database. Quando si crea una AWS Glue tabella da utilizzare con il connettore GCS, è necessario specificare metadati aggiuntivi.
**Per creare una tabella nella console AWS Glue**
1. Nella AWS Glue console, dal pannello di navigazione, scegli **Tabelle**.
1. Nella pagina **Tables** (Tabelle), scegli **Add table** (Aggiungi tabella).
1. Nella pagina **Set table properties** (Imposta proprietà tabella) immetti le seguenti informazioni.
+ **Name** (Nome): un nome univoco per la tabella.
+ **Database**: scegli il database AWS Glue creato per il connettore GCS.
+ **Include path** (Includi percorso): nella sezione **Data store** (Archivio dati), in **Include path** (Includi percorso), inserisci la posizione URI per GCS preceduta da `gs://` (ad esempio, `gs://gcs_table/data/`). Se disponi di una o più cartelle di partizione, non includerle nel percorso.
**Nota**
Quando si immette il percorso di tabella non `s3://`, la console AWS Glue riporta un errore. Puoi ignorare questo errore. La tabella verrà creata correttamente.
+ **Data format** (Formato dati): per **Classification** (Classificazione), seleziona **CSV** o **Parquet**.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Choose or define schema** (Scegli o definisci schema), la definizione di uno schema di tabella è altamente consigliata, ma non obbligatoria. Se non viene definito uno schema, il connettore GCS prova a dedurne uno per tuo conto.
Esegui una delle seguenti operazioni:
+ Se desideri che il connettore GCS provi a dedurre uno schema per tuo conto, scegli **Next** (Successivo), quindi **Create** (Crea).
+ Per definire uno schema personale, seguire la procedura descritta nella sezione successiva.
### Definizione di uno schema di tabella in AWS Glue
La definizione di uno schema di tabella in AWS Glue richiede più passaggi, ma offre un maggiore controllo sul processo di creazione della tabella.
**Per definire uno schema per la tabella in AWS Glue**
1. Nella pagina **Choose or define schema** (Scegli o definisci schema), seleziona **Add** (Aggiungi).
1. Utilizza la finestra di dialogo **Add schema entry** (Aggiungi voce allo schema) per fornire un nome di colonna e un tipo di dati.
1. Per designare la colonna come colonna di partizione, seleziona l'opzione **Set as partition key** (Imposta come chiave di partizione).
1. Seleziona **Save** (Salva) per salvare la colonna.
1. Scegli **Add** (Aggiungi) per aggiungere un'altra colonna.
1. Dopo aver aggiunto le colonne, seleziona **Next** (Successivo).
1. Nella pagina **Review and create** (Rivedi e crea), verifica la tabella, quindi scegli **Create** (Crea).
1. Se lo schema contiene informazioni sulle partizioni, completa la procedura descritta nella sezione successiva per aggiungere un modello di partizione alle proprietà della tabella in AWS Glue.
### Aggiungere uno schema di partizione alle proprietà della tabella in AWS Glue
Se i bucket GCS hanno delle partizioni, è necessario aggiungere il modello di partizione alle proprietà della tabella in AWS Glue.
**Per aggiungere informazioni sulle partizioni alle proprietà della tabella AWS Glue**
1. Nella pagina dei dettagli della tabella in cui hai creato AWS Glue, scegli **Azioni**, **Modifica tabella.**
1. Nella pagina **Edit table** (Modifica tabella), scorri verso il basso fino alla sezione **Table properties** (Proprietà della tabella).
1. Scegli **Add** (Aggiungi) per aggiungere una chiave di partizione.
1. In **Chiave**, inserire **partition.pattern**. Questa chiave definisce il modello del percorso della cartella.
1. In **Value** (Valore), inserisci un modello di percorso della cartella come **StateName=\$1\$1statename\$1/ZipCode=\$1\$1zipcode\$1/**, dove **statename** e **zipcode** racchiusi tra **\$1\$1\$1** sono i nomi delle colonne delle partizioni. Il connettore GCS supporta schemi di partizione Hive e non Hive.
1. Quando hai terminato, seleziona **Save** (Salva).
1. Per visualizzare le proprietà della tabella appena creata, scegli la scheda **Advanced properties** (Proprietà avanzate).
A questo punto, è possibile passare alla console Athena. Il database e la tabella in cui hai creato AWS Glue sono disponibili per l'interrogazione in Athena.
## Supporto dei tipi di dati
Le tabelle seguenti mostrano i tipi di dati supportati per CSV e Parquet.
### CSV
****
| **Natura dei dati** | **Tipo di dati dedotto** |
| --- | --- |
| I dati hanno l'aspetto di un numero | BIGINT |
| I dati hanno l'aspetto di una stringa | VARCHAR |
| I dati hanno l'aspetto di una virgola mobile (mobile, doppia o decimale) | DOUBLE |
| I dati hanno l'aspetto di una data | Time stamp |
| Dati che contengono valori true/false | BOOL |
### Parquet
****
| **PARQUET** | **Athena (freccia)** |
| --- | --- |
| BINARY | VARCHAR |
| BOOLEAN | BOOL |
| DOUBLE | DOUBLE |
| ENUM | VARCHAR |
| FIXED\$1LEN\$1BYTE\$1ARRAY | DECIMAL |
| FLOAT | FLOAT (32 bit) |
| INT32 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-gcs.html) |
| INT64 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-gcs.html) |
| INT96 | Time stamp |
| MAP | MAP |
| STRUCT | STRUCT |
| LIST | LIST |
## Autorizzazioni richieste
Consulta la sezione `Policies` del file [athena-gcs.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-gcs/athena-gcs.yaml) per i dettagli completi delle policy IAM richieste da questo connettore. L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **AWS Glue Data Catalog**— Il connettore GCS richiede l'accesso in sola lettura per ottenere informazioni sullo schema. AWS Glue Data Catalog
+ **CloudWatch Registri**: il connettore richiede l'accesso ai CloudWatch registri per l'archiviazione dei registri.
## Performance
Quando lo schema della tabella contiene campi di partizione e la proprietà della tabella `partition.pattern` è configurata correttamente, è possibile includere il campo di partizione nella clausola `WHERE` delle query. Per tali query, il connettore GCS utilizza le colonne delle partizioni per perfezionare il percorso della cartella GCS ed evitare la scansione di file non necessari nelle cartelle GCS.
Per i set di dati Parquet, la selezione di un sottoinsieme di colonne comporta un minor numero di dati da scansionare. Ciò si traduce in genere in un runtime di esecuzione delle query più breve quando viene applicata la proiezione di colonne.
Per i set di dati CSV, la proiezione di colonne non è supportata e non riduce la quantità di dati da scansionare.
Le clausole `LIMIT` riducono la quantità di dati scansionati, ma se non viene fornito un predicato, le query `SELECT` con una clausola `LIMIT` eseguiranno la scansione di almeno 16 MB di dati. Il connettore GCS esegue la scansione di un maggior numero di dati per i set di dati più grandi rispetto ai set di dati più piccoli indipendentemente dalla clausola `LIMIT` applicata. Ad esempio, la query `SELECT * LIMIT 10000` esegue la scansione di un maggior numero di dati per un set di dati sottostante più grande rispetto a uno più piccolo.
### Informazioni sulla licenza
Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-gcs/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-gcs/LICENSE.txt) su .com. GitHub
### Risorse aggiuntive
Per ulteriori informazioni su questo connettore, visita [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-gcs) su GitHub .com.
# Connettore Amazon Athena HBase
Il HBase connettore Amazon Athena consente ad Amazon Athena di comunicare con le tue istanze HBase Apache in modo da poter interrogare i dati con SQL. HBase
A differenza degli archivi di dati relazionali tradizionali, HBase le raccolte non hanno uno schema prestabilito. HBasenon dispone di un archivio di metadati. Ogni voce di una HBase raccolta può avere campi e tipi di dati diversi.
Il HBase connettore supporta due meccanismi per la generazione di informazioni sullo schema delle tabelle: inferenza di base dello schema e AWS Glue Data Catalog metadati.
L'inferenza dello schema è l'impostazione predefinita. Questa opzione esegue la scansione di un numero limitato di documenti della raccolta, forma un'unione di tutti i campi e forza i campi che hanno tipi di dati non sovrapposti. Questa opzione funziona bene per le raccolte che hanno voci per lo più uniformi.
Per le raccolte con una maggiore varietà di tipi di dati, il connettore supporta il recupero dei metadati da AWS Glue Data Catalog. Se il connettore rileva un AWS Glue database e una tabella che corrispondono al HBase namespace e ai nomi delle raccolte, ottiene le informazioni sullo schema dalla tabella corrispondente. AWS Glue Quando crei la AWS Glue tabella, ti consigliamo di renderla un superset di tutti i campi a cui potresti voler accedere dalla tua raccolta. HBase
Se hai abilitato Lake Formation nel tuo account, il ruolo IAM per il tuo connettore Lambda federato Athena che hai distribuito nell'accesso in lettura deve avere accesso in lettura in AWS Serverless Application Repository Lake Formation a. AWS Glue Data Catalog
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Parameters
Usa i parametri in questa sezione per configurare il connettore. HBase
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un HBase connettore utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del HBase connettore Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type HBASE
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il HBase connettore creato utilizzando le connessioni Glue non supporta l'uso di un gestore di multiplexing.
Il HBase connettore creato utilizzando le connessioni Glue supporta solo `ConnectionSchemaVersion` 2.
### Connessioni legacy
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue** — (Facoltativo) Se presente e impostato su true, il connettore non tenta di recuperare metadati supplementari da. AWS Glue
+ **glue\$1catalog**: (facoltativo) utilizza questa opzione per specificare un [catalogo AWS Glue multi-account](data-sources-glue-cross-account.md). Per impostazione predefinita, il connettore tenta di ottenere metadati dal proprio account. AWS Glue
+ **default\$1hbase** — Se presente, specifica una stringa di HBase connessione da utilizzare quando non esiste alcuna variabile di ambiente specifica del catalogo.
+ **enable\$1case\$1insensitive\$1match — (Facoltativo) When, esegue ricerche senza distinzione tra maiuscole e minuscole nei nomi delle tabelle** in. `true` HBase Il valore predefinito è `false`. Usalo se la tua query contiene nomi di tabella in maiuscolo.
#### Specifica delle stringhe di connessione
È possibile fornire una o più proprietà che definiscono i dettagli di connessione per le istanze utilizzate con il connettore HBase . HBase A tale scopo, imposta una variabile di ambiente Lambda che corrisponda al nome del catalogo che desideri utilizzare in Athena. Ad esempio, supponete di voler utilizzare le seguenti query per interrogare due diverse HBase istanze di Athena:
```
SELECT * FROM "hbase_instance_1".database.table
```
```
SELECT * FROM "hbase_instance_2".database.table
```
Prima di poter utilizzare queste due istruzioni SQL, devi aggiungere due variabili di ambiente alla funzione Lambda: `hbase_instance_1` e `hbase_instance_2`. Il valore per ciascuna deve essere una stringa di HBase connessione nel formato seguente:
```
master_hostname:hbase_port:zookeeper_port
```
##### Utilizzo dei segreti
Facoltativamente, è possibile utilizzare Gestione dei segreti AWS per intero o in parte il valore per i dettagli della stringa di connessione. Per utilizzare la funzione Athena Federated Query con Secrets Manager, il VPC collegato alla funzione Lambda dovrebbe disporre dell'[accesso a Internet](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) o di un [endpoint VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html) per connettersi a Secrets Manager.
Se si utilizza la sintassi `${my_secret}` per inserire il nome di un segreto di Secrets Manager nella stringa di connessione, il connettore sostituisce il nome del segreto con i valori del nome utente e della password di Secrets Manager.
Ad esempio, supponiamo di impostare la variabile di ambiente Lambda per `hbase_instance_1` sul seguente valore:
```
${hbase_host_1}:${hbase_master_port_1}:${hbase_zookeeper_port_1}
```
L'SDK Athena Query Federation tenta automaticamente di recuperare un segreto denominato `hbase_instance_1_creds` da Secrets Manager e inietta quel valore al posto di `${hbase_instance_1_creds}`. Qualsiasi parte della stringa di connessione racchiusa entro la combinazione di caratteri `${ }` viene interpretata come un segreto da Secrets Manager. Se specifichi un nome del segreto che il connettore non riesce a trovare in Secrets Manager, il connettore non sostituisce il testo.
## Configurazione di database e tabelle in AWS Glue
L'inferenza dello schema integrata nel connettore supporta solo i valori serializzati HBase come stringhe (ad esempio,). `String.valueOf(int)` Poiché la capacità integrata di inferenza dello schema del connettore è limitata, in alternativa potresti voler usare AWS Glue per i metadati. Per abilitare una AWS Glue tabella da utilizzare con HBase, è necessario disporre di un AWS Glue database e di una tabella con nomi che corrispondano allo spazio dei HBase nomi e alla tabella per i quali si desidera fornire metadati supplementari. L'uso delle convenzioni di denominazione delle famiglie di HBase colonne è facoltativo ma non obbligatorio.
**Per utilizzare una AWS Glue tabella per metadati supplementari**
1. Quando modifichi la tabella e il database nella AWS Glue console, aggiungi le seguenti proprietà della tabella:
+ **hbase-metadata-flag**— Questa proprietà indica al HBase connettore che il connettore può utilizzare la tabella per metadati supplementari. Puoi fornire qualsiasi valore per `hbase-metadata-flag`, purché la proprietà `hbase-metadata-flag` sia presente nell'elenco delle proprietà della tabella.
+ **hbase-native-storage-flag**— Utilizzate questo flag per attivare o disattivare le due modalità di serializzazione dei valori supportate dal connettore. Per impostazione predefinita, quando questo campo non è presente, il connettore presuppone che tutti i valori siano memorizzati come stringhe. HBase Pertanto, tenterà di analizzare tipi di dati come `INT``BIGINT`, e `DOUBLE` da HBase come stringhe. Se questo campo è impostato con qualsiasi valore nella tabella in AWS Glue, il connettore passa alla modalità di archiviazione «nativa» e tenta di leggere `INT` `BIGINT``BIT`, e `DOUBLE` come byte utilizzando le seguenti funzioni:
```
ByteBuffer.wrap(value).getInt()
ByteBuffer.wrap(value).getLong()
ByteBuffer.wrap(value).get()
ByteBuffer.wrap(value).getDouble()
```
1. Assicurati di utilizzare i tipi di dati appropriati elencati AWS Glue in questo documento.
### Modellazione delle famiglie di colonne
Il HBase connettore Athena supporta due modi per modellare famiglie di HBase colonne: denominazione completamente qualificata (appiattita) o utilizzo di oggetti. `family:column` `STRUCT`
Nel modello `STRUCT`, il nome del campo `STRUCT` dovrebbe corrispondere alla famiglia della colonna, mentre i figli di `STRUCT` dovrebbero corrispondere ai nomi delle colonne della famiglia. Tuttavia, poiché le letture colonnari e il pushdown dei predicati non sono ancora completamente supportati per tipi complessi come `STRUCT`, l'utilizzo di `STRUCT` al momento non è consigliato.
L'immagine seguente mostra una tabella configurata in AWS Glue che utilizza una combinazione dei due approcci.
![\[Modellazione di famiglie di colonne in AWS Glue Apache Hbase.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-hbase-1.png)
## Supporto dei tipi di dati
Il connettore recupera tutti i HBase valori come tipo di byte di base. Quindi, in base a come hai definito le tabelle in AWS Glue Data Catalog, mappa i valori in uno dei tipi di dati Apache Arrow nella tabella seguente.
****
| AWS Glue tipo di dati | Tipo di dati Apache Arrow |
| --- | --- |
| int | INT |
| bigint | BIGINT |
| virgola mobile a doppia precisione | FLOAT8 |
| virgola mobile | FLOAT4 |
| booleano | BIT |
| binary | VARBINARY |
| stringa | VARCHAR |
**Nota**
Se non si utilizza AWS Glue per integrare i metadati, l'inferenza dello schema del connettore utilizza solo i tipi di `BIGINT` dati e. `FLOAT8` `VARCHAR`
## Autorizzazioni richieste
Consulta la sezione `Policies` del file [athena-hbase.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-hbase/athena-hbase.yaml) per i dettagli completi delle policy IAM richieste da questo connettore. L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **AWS Glue Data Catalog**— Il HBase connettore richiede l'accesso in sola lettura a per ottenere informazioni sullo schema. AWS Glue Data Catalog
+ **CloudWatch Registri**: il connettore richiede l'accesso ai CloudWatch registri per l'archiviazione dei registri.
+ **Gestione dei segreti AWS accesso in lettura**: se si sceglie di archiviare i dettagli HBase degli endpoint in Secrets Manager, è necessario concedere al connettore l'accesso a tali segreti.
+ **Accesso VPC**: il connettore richiede la possibilità di collegare e scollegare interfacce al VPC in modo che possa connettersi ad esso e comunicare con le istanze. HBase
## Performance
Il HBase connettore Athena tenta di parallelizzare le query sull' HBase istanza leggendo ogni server regionale in parallelo. Il HBase connettore Athena esegue il pushdown dei predicati per ridurre i dati scansionati dalla query.
La funzione Lambda esegue inoltre il pushdown delle *proiezioni* per ridurre la quantità di dati scansionati dalla query. Tuttavia, la selezione di un sottoinsieme di colonne a volte comporta un runtime delle query più lungo. Le clausole `LIMIT` riducono la quantità di dati scansionati, ma se non viene fornito un predicato, le query `SELECT` con una clausola `LIMIT` eseguiranno la scansione di almeno 16 MB di dati.
HBase è soggetto a errori di interrogazione e a tempi di esecuzione variabili. Potrebbe essere necessario ritentare più volte affinché le query abbiano esito positivo. Il HBase connettore è resistente alle limitazioni dovute alla concorrenza.
## Query passthrough
Il HBase connettore supporta [le query passthrough](federated-query-passthrough.md) ed è basato su NoSQL. [Per informazioni su come interrogare Apache HBase utilizzando i filtri, consulta Filter language nella documentazione di Apache.](https://hbase.apache.org/book.html#thrift.filter_language)
Per utilizzare le query passthrough con HBase, utilizzate la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
database => 'database_name',
collection => 'collection_name',
filter => '{query_syntax}'
))
```
Il seguente esempio di filtri di query HBase passthrough per i dipendenti di 24 o 30 anni all'interno della `employee` raccolta del database. `default`
```
SELECT * FROM TABLE(
system.query(
DATABASE => 'default',
COLLECTION => 'employee',
FILTER => 'SingleColumnValueFilter(''personaldata'', ''age'', =, ''binary:30'')' ||
' OR SingleColumnValueFilter(''personaldata'', ''age'', =, ''binary:24'')'
))
```
## Informazioni sulla licenza
[Il progetto Amazon Athena HBase Connector è concesso in licenza con licenza Apache-2.0.](https://www.apache.org/licenses/LICENSE-2.0.html)
## Risorse aggiuntive
[Per ulteriori informazioni su questo connettore, visita il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-hbase) GitHub
# Connettore Amazon Athena per Hortonworks
Il connettore Amazon Athena per Hortonworks consente ad Amazon Athena di eseguire query SQL sulla piattaforma dati Cloudera [Hortonworks](https://www.cloudera.com/products/hdp.html). Il connettore trasforma le query SQL di Athena nella sintassi HiveQL equivalente.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
## Termini
I seguenti termini si riferiscono al connettore Hortonworks Hive.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizza i parametri illustrati in questa sezione per configurare il connettore Hortonworks Hive.
### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
hive://${jdbc_connection_string}
```
### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | HiveMuxCompositeHandler |
| Gestore dei metadati | HiveMuxMetadataHandler |
| Gestore dei record | HiveMuxRecordHandler |
#### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è myhivecatalog, il nome della variabile di ambiente è myhivecatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è. lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME \$1 |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Hive MUX che supporta due istanze del database: `hive1` (il valore predefinito) e `hive2`.
****
| Proprietà | Valore |
| --- | --- |
| default | hive://jdbc:hive2://hive1:10000/default?\$1\$1Test/RDS/hive1\$1 |
| hive\$1catalog1\$1connection\$1string | hive://jdbc:hive2://hive1:10000/default?\$1\$1Test/RDS/hive1\$1 |
| hive\$1catalog2\$1connection\$1string | hive://jdbc:hive2://hive2:10000/default?UID=sample&PWD=sample |
#### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/RDS/hive1host}`.
```
hive://jdbc:hive2://hive1host:10000/default?...&${Test/RDS/hive1host}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
hive://jdbc:hive2://hive1host:10000/default?...&UID=sample2&PWD=sample2&...
```
Attualmente, il connettore Hortonworks Hive riconosce le proprietà JDBC `UID` e `PWD`.
### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Hortonworks Hive.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | HiveCompositeHandler |
| Gestore dei metadati | HiveMetadataHandler |
| Gestore dei record | HiveRecordHandler |
#### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Hortonworks Hive supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | hive://jdbc:hive2://hive1host:10000/default?secret=\$1\$1Test/RDS/hive1host\$1 |
### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC, Hortonworks Hive e Arrow.
****
| JDBC | Hortonworks Hive | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Numero intero | TINYINT | Tiny |
| Breve | SMALLINT | Smallint |
| Numero intero | INT | Int |
| Long | BIGINT | Bigint |
| virgola mobile | float4 | Float4 |
| Double | float8 | Float8 |
| Data | date | DateDay |
| Time stamp | timestamp | DateMilli |
| Stringa | VARCHAR | Varchar |
| Byte | bytes | Varbinary |
| BigDecimal | Decimale | Decimale |
| ARRAY | N/D (vedi nota) | List |
**Nota**
Attualmente, Hortonworks Hive non supporta i tipi di aggregati `ARRAY`, `MAP`, `STRUCT` e `UNIONTYPE`. Le colonne dei tipi di aggregati vengono trattate come colonne `VARCHAR` in SQL.
## Partizioni e suddivisioni
Le partizioni vengono utilizzate per determinare come generare suddivisioni per il connettore. Athena costruisce una colonna sintetica di tipo `varchar` che rappresenta lo schema di partizionamento della tabella per aiutare il connettore a generare suddivisioni. Il connettore non modifica la definizione effettiva della tabella.
## Performance
Hortonworks Hive supporta le partizioni statiche. Il connettore Hortonworks Hive di Athena può recuperare dati da queste partizioni in parallelo. Se desideri interrogare set di dati molto grandi con una distribuzione uniforme delle partizioni, ti consigliamo vivamente il partizionamento statico. La selezione di un sottoinsieme di colonne velocizza notevolmente il runtime delle query e riduce i dati scansionati. Il connettore Hortonworks Hive è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
Il connettore Athena Hortonworks Hive esegue il pushdown dei predicati per ridurre i dati scansionati dalla query. Le clausole `LIMIT`, i predicati semplici e le espressioni complesse vengono inviate al connettore per ridurre la quantità di dati scansionati e ridurre il tempo di esecuzione delle query.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Athena Hortonworks Hive può combinare queste espressioni e inviarle direttamente a Hortonworks Hive per funzionalità avanzate e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena Hortonworks Hive supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Query passthrough
Il connettore Hortonworks Hive supporta le [query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Hortonworks Hive, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un’origine dati in Hortonworks Hive. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, riconosci l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-hortonworks-hive/pom.xml) relativo a questo connettore, e accetti i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-hortonworks-hive/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml per il connettore](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-hortonworks-hive/pom.xml) Hortonworks Hive su .com. GitHub
[Per ulteriori informazioni su questo connettore, visita il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-hortonworks-hive) GitHub
# Connettore Apache Kafka di Amazon Athena
Il connettore Amazon Athena per Apache Kafka consente ad Amazon Athena di eseguire query SQL sui tuoi argomenti di Apache Kafka. Utilizza questo connettore per visualizzare gli argomenti di [Apache Kafka](https://kafka.apache.org/) come tabelle e i messaggi come righe in Athena.
Questo connettore non utilizza Connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
## Prerequisiti
Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Nelle condizioni di filtro, è necessario impostare i tipi di dati date e timestamp sul tipo di dati appropriato.
+ I tipi di dati data e ora non sono supportati per il tipo di file CSV e vengono trattati come valori varchar.
+ La mappatura in campi JSON annidati non è supportata. Il connettore mappa solo i campi di primo livello.
+ Il connettore non supporta tipi complessi. I tipi complessi vengono interpretati come stringhe.
+ Per estrarre o lavorare con valori JSON complessi, utilizza le funzioni relative a JSON disponibili in Athena. Per ulteriori informazioni, consulta [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md).
+ Il connettore non supporta l'accesso ai metadati dei messaggi Kafka.
## Termini
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Endpoint Kafka**: una stringa di testo che stabilisce una connessione a un'istanza Kafka.
## Compatibilità dei cluster
Il connettore Kafka può essere utilizzato con i seguenti tipi di cluster.
+ **Kafka standalone**: una connessione diretta a Kafka (autenticata o non autenticata).
+ **Confluent:** una connessione diretta a Confluent Kafka. *Per informazioni sull'utilizzo di Athena con i dati di Confluent Kafka, consulta [Visualizza i dati Confluent in Quick using Amazon Athena nel Business](https://aws.amazon.com/blogs/business-intelligence/visualize-confluent-data-in-amazon-quicksight-using-amazon-athena/) Intelligence Blog.AWS *
### Connessione a Confluent
Per la connessione a Confluent sono necessari i seguenti passaggi:
1. Genera una chiave API da Confluent.
1. Memorizza il nome utente e la password per la chiave API di Confluent in Gestione dei segreti AWS.
1. Fornisci il nome del segreto per la variabile di ambiente `secrets_manager_secret` nel connettore Kafka.
1. Segui la procedura nella sezione [Configurazione del connettore Kafka](#connectors-kafka-setup) di questo documento.
## Metodi di autenticazione di supportati
Il connettore supporta i seguenti metodi di autenticazione.
+ [SSL](https://kafka.apache.org/documentation/#security_ssl)
+ [SASL/SCRAM](https://kafka.apache.org/documentation/#security_sasl_scram)
+ SASL/PLAIN
+ SASL/PLAINTEXT
+ NO\$1AUTH
+ Piattaforma Kafka e Confluent autogestita: SSL, **NO\$1AUTH** SASL/SCRAM, SASL/PLAINTEXT
+ **Kafka e Confluent Cloud autogestiti**: SASL/PLAIN
Per ulteriori informazioni, consulta [Configurazione dell'autenticazione del connettore Kafka di Athena](#connectors-kafka-setup-configuring-authentication).
## Formati di dati di input supportati
Il connettore supporta i seguenti formati di dati di input.
+ JSON
+ CSV
+ AVRO
+ PROTOBUF (BUFFER DI PROTOCOLLO)
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore Kafka di Athena.
+ **auth\$1type**: specifica il tipo di autenticazione del cluster. Il connettore supporta i seguenti tipi di autenticazione:
+ **NO\$1AUTH**: connettiti direttamente a Kafka (ad esempio, a un cluster Kafka implementato su un'istanza EC2 che non utilizza l'autenticazione).
+ **SASL\$1SSL\$1PLAIN** — Questo metodo utilizza il protocollo di `SASL_SSL` sicurezza e il meccanismo SASL. `PLAIN` Per ulteriori informazioni, consulta [Configurazione SASL](https://kafka.apache.org/documentation/#security_sasl_config) nella documentazione Kafka di Apache.
+ **SASL\$1PLAINTEXT\$1PLAIN** — Questo metodo utilizza il protocollo di `SASL_PLAINTEXT` sicurezza e il `PLAIN` meccanismo SASL. Per ulteriori informazioni, consulta [Configurazione SASL](https://kafka.apache.org/documentation/#security_sasl_config) nella documentazione Kafka di Apache.
+ **SASL\$1SSL\$1SCRAM\$1 SHA512** — È possibile utilizzare questo tipo di autenticazione per controllare l'accesso ai cluster Apache Kafka. Questo metodo memorizza il nome utente e la password in. Gestione dei segreti AWS Il segreto deve essere associato al cluster Kafka. Per ulteriori informazioni, consulta [Autenticazione tramite SASL/SCRAM](https://kafka.apache.org/documentation/#security_sasl_scram) nella documentazione di Apache Kafka.
+ **SASL\$1PLAINTEXT\$1SCRAM\$1 SHA512** — Questo metodo utilizza il protocollo di `SASL_PLAINTEXT` sicurezza e il meccanismo. `SCRAM_SHA512 SASL` Questo metodo utilizza il nome utente e la password memorizzati in. Gestione dei segreti AWS Per ulteriori informazioni, consulta la sezione [Configurazione SASL](https://kafka.apache.org/documentation/#security_sasl_config) nella documentazione Apache Kafka.
+ **SSL**: l'autenticazione SSL utilizza i file archivio delle chiavi e di archivio di trust per connettersi al cluster Apache Kafka. Devi generare i file del trust store e del key store, caricarli in un bucket Amazon S3 e fornire il riferimento ad Amazon S3 quando implementi il connettore. Il key store, il trust store e la chiave SSL sono archiviati in Gestione dei segreti AWS. Il client deve fornire la chiave AWS segreta quando il connettore viene distribuito. Per ulteriori informazioni, consulta [Crittografia e autenticazione tramite SSL](https://kafka.apache.org/documentation/#security_ssl) nella documentazione di Apache Kafka.
Per ulteriori informazioni, consulta [Configurazione dell'autenticazione del connettore Kafka di Athena](#connectors-kafka-setup-configuring-authentication).
+ **certificates\$1s3\$1reference**: la posizione Amazon S3 che contiene i certificati (i file key store e trust store).
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **kafka\$1endpoint**: i dettagli dell'endpoint da fornire a Kafka.
+ **schema\$1registry\$1url**: l’indirizzo URL per il registro dello schema (ad esempio, `http://schema-registry.example.org:8081`). Si applica ai formati di dati `AVRO` e `PROTOBUF`. Athena supporta solo il registro degli schemi Confluent.
+ **secrets\$1manager\$1secret**: il nome del segreto AWS in cui vengono salvate le credenziali.
+ **Parametri di spill**: le funzioni Lambda archiviano temporaneamente ("riversano") i dati che non rientrano nella memoria di Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione. Utilizza i parametri nella tabella seguente per specificare la posizione di spill.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-kafka.html)
+ **Subnet IDs**: una o più sottoreti IDs che corrispondono alla sottorete che la funzione Lambda può utilizzare per accedere all'origine dati.
+ **Cluster di Kafka pubblico o cluster standard di Confluent Cloud**: associa il connettore a una sottorete privata dotata di un gateway NAT.
+ **Cluster Confluent Cloud con connettività privata**: associa il connettore a una sottorete privata che abbia un percorso diretto al cluster Confluent Cloud.
+ Per [AWS Transit Gateway](https://docs.confluent.io/cloud/current/networking/aws-transit-gateway.html), le sottoreti devono trovarsi in un VPC collegato allo stesso gateway di transito utilizzato da Confluent Cloud.
+ Per il [Peering VPC](https://docs.confluent.io/cloud/current/networking/peering/aws-peering.html), le sottoreti devono trovarsi in un VPC in peering con Confluent Cloud VPC.
+ Per [AWS PrivateLink](https://docs.confluent.io/cloud/current/networking/private-links/aws-privatelink.html), le sottoreti devono trovarsi in un VPC con un percorso verso gli endpoint VPC che si connettono a Confluent Cloud.
**Nota**
Se si implementa il connettore in un VPC per accedere a risorse private e si desidera connettersi anche a un servizio accessibile al pubblico come Confluent, è necessario associare il connettore a una sottorete privata con un gateway NAT. Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella Guida per l'utente di Amazon VPC.
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti supportati per Kafka e Apache Arrow.
****
| Kafka | Arrow |
| --- | --- |
| CHAR | VARCHAR |
| VARCHAR | VARCHAR |
| TIMESTAMP | MILLISECOND |
| DATE | GIORNO |
| BOOLEAN | BOOL |
| SMALLINT | SMALLINT |
| INTEGER | INT |
| BIGINT | BIGINT |
| DECIMAL | FLOAT8 |
| DOUBLE | FLOAT8 |
## Partizioni e suddivisioni
Gli argomenti di Kafka sono suddivisi in partizioni. Ogni partizione è ordinata. Ogni messaggio in una partizione ha un ID incrementale chiamato *offset*. Ogni partizione Kafka è ulteriormente suddivisa in più suddivisioni per l'elaborazione in parallelo. I dati sono disponibili per il periodo di conservazione configurato nei cluster Kafka.
## Best practice
Come procedura consigliata, utilizza il pushdown del predicato quando esegui query su Athena, come negli esempi seguenti.
```
SELECT *
FROM "kafka_catalog_name"."glue_schema_registry_name"."glue_schema_name"
WHERE integercol = 2147483647
```
```
SELECT *
FROM "kafka_catalog_name"."glue_schema_registry_name"."glue_schema_name"
WHERE timestampcol >= TIMESTAMP '2018-03-25 07:30:58.878'
```
## Configurazione del connettore Kafka
Prima di poter utilizzare il connettore, è necessario configurare il cluster Apache Kafka, utilizzare il [registro degli schemi di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html) per definire lo schema e configurare l'autenticazione del connettore.
Quando utilizzate AWS Glue lo Schema Registry, tenete presente i seguenti punti:
+ Assicurati che il testo nel campo **Description** (Descrizione) del registro degli schemi di AWS Glue includa la stringa `{AthenaFederationKafka}`. Questa stringa di marker è obbligatoria per i AWS Glue registri utilizzati con il connettore Amazon Athena Kafka.
+ Per prestazioni ottimali, utilizza solo lettere minuscole per i nomi dei database e delle tabelle. L'utilizzo di caratteri misti tra maiuscole e minuscole fa sì che il connettore esegua una ricerca senza distinzione tra maiuscole e minuscole, più impegnativa dal punto di vista computazionale.
**Per configurare l'ambiente Apache Kafka e lo Schema Registry AWS Glue**
1. Configurazione dell'ambiente Apache Kafka.
1. Carica il file di descrizione dell'argomento di Kafka (ovvero il relativo schema) in formato JSON nel registro degli schemi. AWS Glue Per ulteriori informazioni, consulta [Integrating with AWS Glue Schema Registry](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-integrations.html) nella Developer Guide. AWS Glue
1. Per utilizzare il formato di dati `AVRO` o `PROTOBUF` quando definisci lo schema nel registro degli schemi AWS Glue:
+ Per **Schema name** (Nome schema), inserire il nome dell’argomento Kafka nella stesso casing dell’originale.
+ Per il **Formato dei dati**, scegli **Apache Avro** o **Protocol Buffers**.
Per schemi di esempio, consulta la sezione seguente.
### Esempi di schemi per lo AWS Glue Schema Registry
Utilizza il formato degli esempi in questa sezione quando carichi lo schema nel [registro degli schemi di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html).
#### Esempio di schema di tipo JSON
Nell'esempio seguente, lo schema da creare nel registro degli AWS Glue schemi viene specificato `json` come valore `dataFormat` e da utilizzare `datatypejson` per`topicName`.
**Nota**
Il valore di `topicName` deve utilizzare le stesse maiuscole e minuscole del nome dell'argomento in Kafka.
```
{
"topicName": "datatypejson",
"message": {
"dataFormat": "json",
"fields": [
{
"name": "intcol",
"mapping": "intcol",
"type": "INTEGER"
},
{
"name": "varcharcol",
"mapping": "varcharcol",
"type": "VARCHAR"
},
{
"name": "booleancol",
"mapping": "booleancol",
"type": "BOOLEAN"
},
{
"name": "bigintcol",
"mapping": "bigintcol",
"type": "BIGINT"
},
{
"name": "doublecol",
"mapping": "doublecol",
"type": "DOUBLE"
},
{
"name": "smallintcol",
"mapping": "smallintcol",
"type": "SMALLINT"
},
{
"name": "tinyintcol",
"mapping": "tinyintcol",
"type": "TINYINT"
},
{
"name": "datecol",
"mapping": "datecol",
"type": "DATE",
"formatHint": "yyyy-MM-dd"
},
{
"name": "timestampcol",
"mapping": "timestampcol",
"type": "TIMESTAMP",
"formatHint": "yyyy-MM-dd HH:mm:ss.SSS"
}
]
}
}
```
#### Esempio di schema di tipo CSV
Nell'esempio seguente, lo schema da creare nel registro degli AWS Glue schemi viene specificato `csv` come valore `dataFormat` e da utilizzare `datatypecsvbulk` per. `topicName` Il valore di `topicName` deve utilizzare le stesse maiuscole e minuscole del nome dell'argomento in Kafka.
```
{
"topicName": "datatypecsvbulk",
"message": {
"dataFormat": "csv",
"fields": [
{
"name": "intcol",
"type": "INTEGER",
"mapping": "0"
},
{
"name": "varcharcol",
"type": "VARCHAR",
"mapping": "1"
},
{
"name": "booleancol",
"type": "BOOLEAN",
"mapping": "2"
},
{
"name": "bigintcol",
"type": "BIGINT",
"mapping": "3"
},
{
"name": "doublecol",
"type": "DOUBLE",
"mapping": "4"
},
{
"name": "smallintcol",
"type": "SMALLINT",
"mapping": "5"
},
{
"name": "tinyintcol",
"type": "TINYINT",
"mapping": "6"
},
{
"name": "floatcol",
"type": "DOUBLE",
"mapping": "7"
}
]
}
}
```
#### Esempio di schema di tipo AVRO
L’esempio seguente viene utilizzato per creare uno schema basato su AVRO nel registro degli schemi AWS Glue . **Quando si definisce lo schema nel registro degli AWS Glue schemi, per **Nome schema**, si immette il nome dell'argomento Kafka nello stesso maiuscolo dell'originale e per **Formato dati** si sceglie Apache Avro.** Poiché queste informazioni vengono specificate direttamente nel registro, i campi `dataformat` e `topicName` non sono obbligatori.
```
{
"type": "record",
"name": "avrotest",
"namespace": "example.com",
"fields": [{
"name": "id",
"type": "int"
},
{
"name": "name",
"type": "string"
}
]
}
```
#### Esempio di schema di tipo PROTOBUF
L’esempio seguente viene utilizzato per creare uno schema basato su PROTOBUF nel registro degli schemi AWS Glue . ****Quando si definisce lo schema nel registro degli schemi, in Nome AWS Glue schema, si immette **il nome** dell'argomento Kafka nello stesso maiuscolo dell'originale e per il formato dei dati si sceglie Protocol Buffers.**** Poiché queste informazioni vengono specificate direttamente nel registro, i campi `dataformat` e `topicName` non sono obbligatori. La prima riga definisce lo schema come PROTOBUF.
```
syntax = "proto3";
message protobuftest {
string name = 1;
int64 calories = 2;
string colour = 3;
}
```
Per ulteriori informazioni sull'aggiunta di un registro e di schemi nel registro degli schemi, vedi [Guida introduttiva a AWS Glue Schema Registry nella documentazione](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-gs.html). AWS Glue
### Configurazione dell'autenticazione del connettore Kafka di Athena
È possibile utilizzare diversi metodi per l'autenticazione nel cluster Apache Kafka, incluso SSL,. SASL/SCRAM, SASL/PLAIN, and SASL/PLAINTEXT
La tabella seguente mostra i tipi di autenticazione per il connettore, il protocollo di sicurezza e il meccanismo SASL per ciascuno di questi metodi. Per ulteriori informazioni, consulta la sezione [Sicurezza](https://kafka.apache.org/documentation/#security) nella documentazione di Apache Kafka.
****
| auth\$1type | security.protocol | sasl.mechanism | Compatibilità con tipo di cluster |
| --- | --- | --- | --- |
| SASL\$1SSL\$1PLAIN | SASL\$1SSL | PLAIN | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-kafka.html) |
| SASL\$1PLAINTEXT\$1PLAIN | SASL\$1PLAINTEXT | PLAIN | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-kafka.html) |
| SASL\$1SSL\$1SCRAM\$1SHA512 | SASL\$1SSL | SCRAM-SHA-512 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-kafka.html) |
| SASL\$1PLAINTEXT\$1SCRAM\$1SHA512 | SASL\$1PLAINTEXT | SCRAM-SHA-512 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-kafka.html) |
| SSL | SSL | N/D | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-kafka.html) |
#### SSL
Se il cluster è autenticato tramite SSL, devi generare i file del trust store e del key store e caricarli nel bucket Amazon S3. È necessario fornire questo riferimento Amazon S3 quando implementi il connettore. Il key store, il trust store e la chiave SSL sono archiviati in Gestione dei segreti AWS. La chiave AWS segreta viene fornita al momento della distribuzione del connettore.
Per informazioni sulla creazione di un segreto in Secrets Manager, consulta la pagina [Crea un segreto Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).
Per utilizzare questo tipo di autenticazione, è necessario impostare le variabili di ambiente come illustrato nella tabella seguente.
****
| Parametro | Valore |
| --- | --- |
| auth\$1type | SSL |
| certificates\$1s3\$1reference | La posizione di Amazon S3 contenente i certificati. |
| secrets\$1manager\$1secret | Il nome della tua chiave AWS segreta. |
Dopo avere creato un segreto in Gestione dei segreti, puoi visualizzarlo nella console Gestione dei segreti.
**Visualizzazione del segreto in Gestione dei segreti**
1. Apri la console Secrets Manager all'indirizzo [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Nel riquadro di navigazione, scegli **Secrets** (Segreti).
1. Nella pagina **Secrets** (Segreti), scegli il collegamento al tuo segreto.
1. Nella pagina dei dettagli del segreto, scegli **Retrieve secret value** (Recupera il valore di un segreto).
L'immagine seguente mostra un esempio di segreto con tre coppie chiave/valore: `keystore_password`, `truststore_password` e `ssl_key_password`.
![\[Recupero di un segreto SSL in Gestione dei segreti\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-kafka-setup-1.png)
Per ulteriori informazioni sull'utilizzo di SSL con Kafka, consulta [Crittografia e autenticazione tramite SSL](https://kafka.apache.org/documentation/#security_ssl) nella documentazione di Apache Kafka.
#### SASL/SCRAM
Se il cluster utilizza l'autenticazione SCRAM, fornisci la chiave Gestione dei segreti associata al cluster quando implementi il connettore. Le credenziali AWS dell'utente (chiave segreta e chiave di accesso) vengono utilizzate per autenticarsi al cluster.
Imposta le variabili di ambiente come illustrato nella tabella seguente.
****
| Parametro | Valore |
| --- | --- |
| auth\$1type | SASL\$1SSL\$1SCRAM\$1SHA512 |
| secrets\$1manager\$1secret | Il nome della tua chiave AWS segreta. |
L'immagine seguente mostra un esempio di segreto nella console Secrets Manager con due key/value coppie: una per `username` e una per`password`.
![\[Recupero di un segreto SCRAM in Gestione dei segreti\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-kafka-setup-2.png)
Per ulteriori informazioni sull'utilizzo SASL/SCRAM con Kafka, vedere [Autenticazione tramite SASL/SCRAM](https://kafka.apache.org/documentation/#security_sasl_scram) nella documentazione di Apache Kafka.
## Informazioni sulla licenza
[Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-kafka/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file LICENSE.txt su .com.](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-kafka/LICENSE.txt) GitHub
## Risorse aggiuntive
Per ulteriori informazioni su questo connettore, visita [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-kafka) su GitHub .com.
# Connettore MSK di Amazon Athena
Il connettore Amazon Athena per [Amazon MSK](https://aws.amazon.com/msk/) consente ad Amazon Athena di eseguire query SQL sui tuoi argomenti di Apache Kafka. Utilizza questo connettore per visualizzare gli argomenti di [Apache Kafka](https://kafka.apache.org/) come tabelle e i messaggi come righe in Athena. Per ulteriori informazioni, consulta [Analizzare i dati di streaming in tempo reale in Amazon MSK con Amazon](https://aws.amazon.com/blogs/big-data/analyze-real-time-streaming-data-in-amazon-msk-with-amazon-athena/) Athena AWS nel blog Big Data.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
## Prerequisiti
Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Nelle condizioni di filtro, è necessario impostare i tipi di dati date e timestamp sul tipo di dati appropriato.
+ I tipi di dati data e ora non sono supportati per il tipo di file CSV e vengono trattati come valori varchar.
+ La mappatura in campi JSON annidati non è supportata. Il connettore mappa solo i campi di primo livello.
+ Il connettore non supporta tipi complessi. I tipi complessi vengono interpretati come stringhe.
+ Per estrarre o lavorare con valori JSON complessi, utilizza le funzioni relative a JSON disponibili in Athena. Per ulteriori informazioni, consulta [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md).
+ Il connettore non supporta l'accesso ai metadati dei messaggi Kafka.
## Termini
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Endpoint Kafka**: una stringa di testo che stabilisce una connessione a un'istanza Kafka.
## Compatibilità dei cluster
Il connettore MSK può essere utilizzato con i seguenti tipi di cluster.
+ **Cluster fornito da MSK**: la capacità del cluster viene specificata, monitorata e dimensionata manualmente.
+ **Cluster MSK Serverless**: fornisce capacità su richiesta che si ridimensiona automaticamente in base alla scalabilità dell'applicazione. I/O
+ **Kafka standalone**: una connessione diretta a Kafka (autenticata o non autenticata).
## Metodi di autenticazione di supportati
Il connettore supporta i seguenti metodi di autenticazione.
+ [SASL/IAM](https://docs.aws.amazon.com/msk/latest/developerguide/iam-access-control.html)
+ [SSL](https://docs.aws.amazon.com/msk/latest/developerguide/msk-authentication.html)
+ [SASL/SCRAM](https://docs.aws.amazon.com/msk/latest/developerguide/msk-password.html)
+ SASL/PLAIN
+ SASL/PLAINTEXT
+ NO\$1AUTH
Per ulteriori informazioni, consulta [Configurazione dell'autenticazione per il connettore Athena MSK](#connectors-msk-setup-configuring-authentication).
## Formati di dati di input supportati
Il connettore supporta i seguenti formati di dati di input.
+ JSON
+ CSV
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore Athena MSK.
+ **auth\$1type**: specifica il tipo di autenticazione del cluster. Il connettore supporta i seguenti tipi di autenticazione:
+ **NO\$1AUTH**: connettiti direttamente a Kafka senza autenticazione (ad esempio, a un cluster Kafka implementato su un'istanza EC2 che non utilizza l'autenticazione).
+ **SASL\$1SSL\$1PLAIN** — Questo metodo utilizza il protocollo di `SASL_SSL` sicurezza e il meccanismo SASL. `PLAIN`
+ **SASL\$1PLAINTEXT\$1PLAIN** — Questo metodo utilizza il protocollo di `SASL_PLAINTEXT` sicurezza e il `PLAIN` meccanismo SASL.
**Nota**
I tipi di autenticazione `SASL_SSL_PLAIN` e `SASL_PLAINTEXT_PLAIN` sono supportati da Apache Kafka ma non da Amazon MSK.
+ **SASL\$1SSL\$1 AWS\$1MSK \$1IAM** — Il controllo degli accessi IAM per Amazon MSK consente di gestire sia l'autenticazione che l'autorizzazione per il cluster MSK. AWS Le credenziali dell'utente (chiave segreta e chiave di accesso) vengono utilizzate per connettersi al cluster. Per ulteriori informazioni, consulta la pagina [IAM access control](https://docs.aws.amazon.com/msk/latest/developerguide/iam-access-control.html) (Controllo degli accessi IAM) nella Guida per gli sviluppatori di Amazon Managed Streaming per Apache Kafka.
+ **SASL\$1SSL\$1SCRAM\$1 SHA512** — Puoi utilizzare questo tipo di autenticazione per controllare l'accesso ai tuoi cluster Amazon MSK. Questo metodo memorizza il nome utente e la password su. Gestione dei segreti AWS Il segreto deve essere associato al cluster Amazon MSK. Per ulteriori informazioni, consulta [Configurazione dell' SASL/SCRAM autenticazione per un cluster Amazon MSK nella Amazon](https://docs.aws.amazon.com/msk/latest/developerguide/msk-password.html#msk-password-tutorial) Managed Streaming for Apache Kafka Developer Guide.
+ **SSL**: l'autenticazione SSL utilizza i file di key store e trust store per connettersi al cluster Amazon MSK. Devi generare i file del trust store e del key store, caricarli in un bucket Amazon S3 e fornire il riferimento ad Amazon S3 quando implementi il connettore. Il key store, il trust store e la chiave SSL sono archiviati in Gestione dei segreti AWS. Il client deve fornire la chiave AWS segreta quando il connettore viene distribuito. Per ulteriori informazioni, consulta la pagina [Mutual TLS authentication](https://docs.aws.amazon.com/msk/latest/developerguide/msk-authentication.html) (Autenticazione TLS reciproca) nella Guida per gli sviluppatori di Amazon Managed Streaming per Apache Kafka.
Per ulteriori informazioni, consulta [Configurazione dell'autenticazione per il connettore Athena MSK](#connectors-msk-setup-configuring-authentication).
+ **certificates\$1s3\$1reference**: la posizione Amazon S3 che contiene i certificati (i file key store e trust store).
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **kafka\$1endpoint**: i dettagli dell'endpoint da fornire a Kafka. Ad esempio, per un cluster Amazon MSK, fornisci un [URL di bootstrap](https://docs.aws.amazon.com/msk/latest/developerguide/msk-get-bootstrap-brokers.html) per il cluster.
+ **secrets\$1manager\$1secret**: il nome del segreto AWS in cui vengono salvate le credenziali. Questo parametro non è obbligatorio per l'autenticazione IAM.
+ **Parametri di spill**: le funzioni Lambda archiviano temporaneamente ("riversano") i dati che non rientrano nella memoria di Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione. Utilizza i parametri nella tabella seguente per specificare la posizione di spill.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/connectors-msk.html)
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti supportati per Kafka e Apache Arrow.
****
| Kafka | Arrow |
| --- | --- |
| CHAR | VARCHAR |
| VARCHAR | VARCHAR |
| TIMESTAMP | MILLISECOND |
| DATE | GIORNO |
| BOOLEAN | BOOL |
| SMALLINT | SMALLINT |
| INTEGER | INT |
| BIGINT | BIGINT |
| DECIMAL | FLOAT8 |
| DOUBLE | FLOAT8 |
## Partizioni e suddivisioni
Gli argomenti di Kafka sono suddivisi in partizioni. Ogni partizione è ordinata. Ogni messaggio in una partizione ha un ID incrementale chiamato *offset*. Ogni partizione Kafka è ulteriormente suddivisa in più suddivisioni per l'elaborazione in parallelo. I dati sono disponibili per il periodo di conservazione configurato nei cluster Kafka.
## Best practice
Come procedura consigliata, utilizza il pushdown del predicato quando esegui query su Athena, come negli esempi seguenti.
```
SELECT *
FROM "msk_catalog_name"."glue_schema_registry_name"."glue_schema_name"
WHERE integercol = 2147483647
```
```
SELECT *
FROM "msk_catalog_name"."glue_schema_registry_name"."glue_schema_name"
WHERE timestampcol >= TIMESTAMP '2018-03-25 07:30:58.878'
```
## Configurazione del connettore MSK
Prima di poter utilizzare il connettore, è necessario configurare il cluster Amazon MSK, utilizzare il [registro degli schemi di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html) per definire lo schema e configurare l'autenticazione per il connettore.
**Nota**
Se si implementa il connettore in un VPC per accedere a risorse private e si desidera connettersi anche a un servizio accessibile al pubblico come Confluent, è necessario associare il connettore a una sottorete privata con un gateway NAT. Per ulteriori informazioni, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) nella Guida per l'utente di Amazon VPC.
Quando lavori con lo AWS Glue Schema Registry, tieni presente i seguenti punti:
+ Assicurati che il testo nel campo **Description** (Descrizione) del registro degli schemi di AWS Glue includa la stringa `{AthenaFederationMSK}`. Questa stringa di marker è obbligatoria per AWS Glue i registri utilizzati con il connettore Amazon Athena MSK.
+ Per prestazioni ottimali, utilizza solo lettere minuscole per i nomi dei database e delle tabelle. L'utilizzo di caratteri misti tra maiuscole e minuscole fa sì che il connettore esegua una ricerca senza distinzione tra maiuscole e minuscole, più impegnativa dal punto di vista computazionale.
**Per configurare l'ambiente Amazon MSK e il registro AWS Glue degli schemi**
1. Configura il tuo ambiente Amazon MSK. Per ulteriori informazioni e per conoscere la procedura, consulta le sezioni [Setting up Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/before-you-begin.html) (Configurazione di Amazon MSK) e [Getting started using Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html) (Nozioni di base sull'utilizzo di Amazon MSK) nella Guida per gli sviluppatori di Amazon Managed Streaming for Apache Kafka.
1. Carica il file di descrizione dell'argomento di Kafka (ovvero il relativo schema) in formato JSON nel registro degli schemi. AWS Glue Per ulteriori informazioni, consulta [Integrating with AWS Glue Schema Registry](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-integrations.html) nella Developer Guide. AWS Glue Per schemi di esempio, consulta la sezione seguente.
### Esempi di schemi per lo AWS Glue Schema Registry
Utilizza il formato degli esempi in questa sezione quando carichi lo schema nel [registro degli schemi di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html).
#### Esempio di schema di tipo JSON
Nell'esempio seguente, lo schema da creare nel registro degli AWS Glue schemi viene specificato `json` come valore `dataFormat` e da utilizzare `datatypejson` per`topicName`.
**Nota**
Il valore di `topicName` deve utilizzare le stesse maiuscole e minuscole del nome dell'argomento in Kafka.
```
{
"topicName": "datatypejson",
"message": {
"dataFormat": "json",
"fields": [
{
"name": "intcol",
"mapping": "intcol",
"type": "INTEGER"
},
{
"name": "varcharcol",
"mapping": "varcharcol",
"type": "VARCHAR"
},
{
"name": "booleancol",
"mapping": "booleancol",
"type": "BOOLEAN"
},
{
"name": "bigintcol",
"mapping": "bigintcol",
"type": "BIGINT"
},
{
"name": "doublecol",
"mapping": "doublecol",
"type": "DOUBLE"
},
{
"name": "smallintcol",
"mapping": "smallintcol",
"type": "SMALLINT"
},
{
"name": "tinyintcol",
"mapping": "tinyintcol",
"type": "TINYINT"
},
{
"name": "datecol",
"mapping": "datecol",
"type": "DATE",
"formatHint": "yyyy-MM-dd"
},
{
"name": "timestampcol",
"mapping": "timestampcol",
"type": "TIMESTAMP",
"formatHint": "yyyy-MM-dd HH:mm:ss.SSS"
}
]
}
}
```
#### Esempio di schema di tipo CSV
Nell'esempio seguente, lo schema da creare nel registro degli AWS Glue schemi viene specificato `csv` come valore `dataFormat` e da utilizzare `datatypecsvbulk` per. `topicName` Il valore di `topicName` deve utilizzare le stesse maiuscole e minuscole del nome dell'argomento in Kafka.
```
{
"topicName": "datatypecsvbulk",
"message": {
"dataFormat": "csv",
"fields": [
{
"name": "intcol",
"type": "INTEGER",
"mapping": "0"
},
{
"name": "varcharcol",
"type": "VARCHAR",
"mapping": "1"
},
{
"name": "booleancol",
"type": "BOOLEAN",
"mapping": "2"
},
{
"name": "bigintcol",
"type": "BIGINT",
"mapping": "3"
},
{
"name": "doublecol",
"type": "DOUBLE",
"mapping": "4"
},
{
"name": "smallintcol",
"type": "SMALLINT",
"mapping": "5"
},
{
"name": "tinyintcol",
"type": "TINYINT",
"mapping": "6"
},
{
"name": "floatcol",
"type": "DOUBLE",
"mapping": "7"
}
]
}
}
```
### Configurazione dell'autenticazione per il connettore Athena MSK
Puoi utilizzare diversi metodi per l'autenticazione al cluster Amazon MSK, tra cui IAM, SSL, SCRAM e Kafka standalone.
La tabella seguente mostra i tipi di autenticazione per il connettore, il protocollo di sicurezza e il meccanismo SASL per ciascuno di questi metodi. Per ulteriori informazioni, consulta [Autenticazione e autorizzazione per Apache Kafka APIs nella Amazon Managed Streaming for Apache Kafka Developer Guide](https://docs.aws.amazon.com/msk/latest/developerguide/kafka_apis_iam.html).
****
| auth\$1type | security.protocol | sasl.mechanism |
| --- | --- | --- |
| SASL\$1SSL\$1PLAIN | SASL\$1SSL | PLAIN |
| SASL\$1PLAINTEXT\$1PLAIN | SASL\$1PLAINTEXT | PLAIN |
| SASL\$1SSL\$1AWS\$1MSK\$1IAM | SASL\$1SSL | AWS\$1MSK\$1IAM |
| SASL\$1SSL\$1SCRAM\$1SHA512 | SASL\$1SSL | SCRAM-SHA-512 |
| SSL | SSL | N/D |
**Nota**
I tipi di autenticazione `SASL_SSL_PLAIN` e `SASL_PLAINTEXT_PLAIN` sono supportati da Apache Kafka ma non da Amazon MSK.
#### SASL/IAM
Se il cluster utilizza l'autenticazione IAM, è necessario configurare la policy IAM per l'utente al momento della configurazione del cluster. Per ulteriori informazioni, consulta la pagina [IAM access control](https://docs.aws.amazon.com/msk/latest/developerguide/IAM-access-control.html) (Controllo degli accessi IAM) nella Guida per gli sviluppatori di Amazon Managed Streaming per Apache Kafka.
Per utilizzare questo tipo di autenticazione, imposta la variabile di ambiente Lambda `auth_type` per il connettore su `SASL_SSL_AWS_MSK_IAM`.
#### SSL
Se il cluster è autenticato tramite SSL, devi generare i file del trust store e del key store e caricarli nel bucket Amazon S3. È necessario fornire questo riferimento Amazon S3 quando implementi il connettore. Il key store, il trust store e la chiave SSL sono archiviati in Gestione dei segreti AWS. Fornisci la chiave AWS segreta quando distribuisci il connettore.
Per informazioni sulla creazione di un segreto in Secrets Manager, consulta la pagina [Crea un segreto Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).
Per utilizzare questo tipo di autenticazione, è necessario impostare le variabili di ambiente come illustrato nella tabella seguente.
****
| Parametro | Valore |
| --- | --- |
| auth\$1type | SSL |
| certificates\$1s3\$1reference | La posizione di Amazon S3 contenente i certificati. |
| secrets\$1manager\$1secret | Il nome della tua chiave AWS segreta. |
Dopo avere creato un segreto in Gestione dei segreti, puoi visualizzarlo nella console Gestione dei segreti.
**Visualizzazione del segreto in Gestione dei segreti**
1. Apri la console Secrets Manager all'indirizzo [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Nel riquadro di navigazione, scegli **Secrets** (Segreti).
1. Nella pagina **Secrets** (Segreti), scegli il collegamento al tuo segreto.
1. Nella pagina dei dettagli del segreto, scegli **Retrieve secret value** (Recupera il valore di un segreto).
L'immagine seguente mostra un esempio di segreto con tre coppie chiave/valore: `keystore_password`, `truststore_password` e `ssl_key_password`.
![\[Recupero di un segreto SSL in Gestione dei segreti\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-msk-setup-1.png)
#### SASL/SCRAM
Se il cluster utilizza l'autenticazione SCRAM, fornisci la chiave Gestione dei segreti associata al cluster quando implementi il connettore. Le credenziali AWS dell'utente (chiave segreta e chiave di accesso) vengono utilizzate per autenticarsi al cluster.
Imposta le variabili di ambiente come illustrato nella tabella seguente.
****
| Parametro | Valore |
| --- | --- |
| auth\$1type | SASL\$1SSL\$1SCRAM\$1SHA512 |
| secrets\$1manager\$1secret | Il nome della tua chiave AWS segreta. |
L'immagine seguente mostra un esempio di segreto nella console Secrets Manager con due key/value coppie: una per `username` e una per`password`.
![\[Recupero di un segreto SCRAM in Gestione dei segreti\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-msk-setup-2.png)
## Informazioni sulla licenza
Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-msk/pom.xml) di questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-msk/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per ulteriori informazioni su questo connettore, visita [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-msk) su GitHub .com.
# Connettore MySQL di Amazon Athena
Il connettore Lambda MySQL di Amazon Athena consente ad Amazon Athena di accedere ai database MySQL.
Questo connettore può essere registrato con il Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
+ Prima di utilizzare questo connettore, configura un VPC e un gruppo di sicurezza. Per ulteriori informazioni, consulta [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Poiché Athena converte le query in lettere minuscole, i nomi delle tabelle MySQL devono essere in minuscolo. Ad esempio, le query di Athena su una tabella denominata `myTable` avranno esito negativo.
+ Se migri le tue connessioni MySQL al Catalogo Glue e a Lake Formation, verranno riconosciuti solo i nomi minuscoli di tabelle e colonne.
## Termini
I seguenti termini si riferiscono al connettore MySQL.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore MySQL.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore MySQL utilizzando un oggetto di connessione Glue.
Per fare ciò, imposta la variabile di ambiente `glue_connection` del connettore MySQL Lambda sul nome della connessione Glue da utilizzare.
Utilizzare il seguente comando per ottenere lo schema per un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type MYSQL
```
**Proprietà dell’ambiente Lambda**
**glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore MySQL creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore MySQL creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
mysql://${jdbc_connection_string}
```
**Nota**
Se viene visualizzato l'errore java.sql. SQLException: Valore di data zero proibito quando si esegue una `SELECT` query su una tabella MySQL, aggiungi il seguente parametro alla stringa di connessione:
```
zeroDateTimeBehavior=convertToNull
```
Per ulteriori informazioni, consulta [Errore «Valore di data zero proibito» durante il tentativo di selezione dalla tabella MySQL](https://github.com/awslabs/aws-athena-query-federation/issues/760) su .com. GitHub
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | MySqlMuxCompositeHandler |
| Gestore dei metadati | MySqlMuxMetadataHandler |
| Gestore dei record | MySqlMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mymysqlcatalog, il nome della variabile di ambiente è mymysqlcatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è. lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME \$1 |
Le seguenti proprietà di esempio riguardano una funzione Lambda MySql MUX che supporta due istanze di database`mysql1`: (impostazione predefinita) e. `mysql2`
****
| Proprietà | Valore |
| --- | --- |
| default | mysql://jdbc:mysql://mysql2.host:3333/default?user=sample2&password=sample2 |
| mysql\$1catalog1\$1connection\$1string | mysql://jdbc:mysql://mysql1.host:3306/default?\$1\$1Test/RDS/MySql1\$1 |
| mysql\$1catalog2\$1connection\$1string | mysql://jdbc:mysql://mysql2.host:3333/default?user=sample2&password=sample2 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti hardcoded in Gestione dei segreti AWS, consultate [Move hardcoded](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) secret in nella Guida per l'utente. Gestione dei segreti AWSGestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/RDS/MySql1}`.
```
mysql://jdbc:mysql://mysql1.host:3306/default?...&${Test/RDS/MySql1}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
mysql://jdbc:mysql://mysql1host:3306/default?...&user=sample2&password=sample2&...
```
Attualmente, il connettore MySQL riconosce le proprietà JDBC `user` e `password`.
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza MySQL.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | MySqlCompositeHandler |
| Gestore dei metadati | MySqlMetadataHandler |
| Gestore dei record | MySqlRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza MySQL supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | mysql://mysql1.host:3306/default?secret=Test/RDS/MySql1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC e Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Numero intero | Tiny |
| Breve | Smallint |
| Numero intero | Int |
| Long | Bigint |
| virgola mobile | Float4 |
| Double | Float8 |
| Data | DateDay |
| Time stamp | DateMilli |
| Stringa | Varchar |
| Byte | Varbinary |
| BigDecimal | Decimale |
| ARRAY | List |
## Partizioni e suddivisioni
Le partizioni vengono utilizzate per determinare come generare suddivisioni per il connettore. Athena costruisce una colonna sintetica di tipo `varchar` che rappresenta lo schema di partizionamento della tabella per aiutare il connettore a generare suddivisioni. Il connettore non modifica la definizione effettiva della tabella.
## Performance
MySQL supporta le partizioni native. Il connettore MySQL di Athena può recuperare dati da queste partizioni in parallelo. Se desideri interrogare set di dati molto grandi con una distribuzione uniforme delle partizioni, ti consigliamo vivamente il partizionamento nativo.
Il connettore Athena MySQL esegue il pushdown dei predicati per ridurre i dati analizzati dalla query. Le clausole `LIMIT`, i predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati analizzati e per ridurre il tempo di esecuzione delle query.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Athena MySQL può combinare queste espressioni e inviarle direttamente a MySQL per migliorare le funzionalità e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena MySQL supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
Per un articolo sull'utilizzo del pushdown del predicato per migliorare le prestazioni nelle query federate, incluso MySQL, consulta [Come migliorare le query federate con il pushdown del predicato in Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-federated-queries-with-predicate-pushdown-in-amazon-athena/) nel *Blog sui Big Data di AWS *.
## Query passthrough
Il connettore MySQL supporta le [query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con MySQL, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in MySQL. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, riconosci l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-mysql/pom.xml) relativo a questo connettore, e accetti i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-mysql/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-mysql/pom.xml) per il connettore MySQL su .com. GitHub
Per ulteriori informazioni su questo connettore, visita [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-mysql) su .com. GitHub
# Connettore Amazon Athena Neptune
Amazon Neptune è un servizio di database a grafo gestito rapido e affidabile che rende più semplice la creazione e l'esecuzione di applicazioni che funzionano con set di dati altamente connessi. Il motore di database a grafo dedicato e a prestazioni elevate di Neptune archivia miliardi di relazioni e invia query al grafo con una latenza di millisecondi. Per ulteriori informazioni, consulta la [Guida per l'utente di Neptune](https://docs.aws.amazon.com/neptune/latest/userguide/intro.html).
Il connettore Amazon Athena Neptune consente ad Athena di comunicare con l'istanza del database a grafo Neptune, rendendo i dati del grafico Neptune accessibili tramite query SQL.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
Se hai abilitato Lake Formation nel tuo account, il ruolo IAM per il tuo connettore Lambda federato Athena che hai distribuito nell'accesso in lettura deve avere accesso in lettura in AWS Serverless Application Repository Lake Formation a. AWS Glue Data Catalog
## Prerequisiti
L'utilizzo del connettore Neptune richiede i seguenti tre passaggi.
+ Configurazione di un cluster Neptune
+ Configurare un AWS Glue Data Catalog
+ Implementazione del connettore sul tuo Account AWS. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md). Per ulteriori dettagli specifici sulla distribuzione del connettore Neptune, consulta [Distribuire il connettore Amazon Athena Neptune su](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-neptune/docs/neptune-connector-setup) .com. GitHub
## Limitazioni
Il connettore Neptune presenta attualmente i seguenti limiti.
+ La proiezione di colonne, inclusa la chiave primaria (ID), non è supportata.
## Configurazione di un cluster Neptune
Se non disponi di un cluster Amazon Neptune esistente e di un set di dati con grafici delle proprietà che desideri utilizzare, devi configurarne uno.
Assicurati che siano disponibili un gateway Internet e un gateway NAT nel VPC che ospita il cluster Neptune. Le sottoreti private utilizzate dalla funzione Lambda del connettore Neptune devono avere un instradamento verso Internet tramite questo gateway NAT. La funzione Lambda del connettore Neptune utilizza il gateway NAT per comunicare. AWS Glue
Per istruzioni su come configurare un nuovo cluster Neptune e caricarlo con un set di dati di esempio, consulta [Sample Neptune](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-neptune/docs/neptune-cluster-setup) Cluster Setup su .com. GitHub
## Configurare un AWS Glue Data Catalog
A differenza dei tradizionali archivi di dati relazionali, gli edge e i nodi DB dei grafici di Neptune non utilizzano uno schema prestabilito. Ogni voce può avere campi e tipi di dati diversi. Tuttavia, poiché il connettore Neptune recupera i metadati da AWS Glue Data Catalog, è necessario creare AWS Glue un database con tabelle con lo schema richiesto. Dopo aver creato il database e le tabelle AWS Glue , il connettore può compilare l'elenco delle tabelle disponibili per le query da Athena.
### Come abilitare la corrispondenza delle colonne senza distinzione tra maiuscole
Per risolvere i nomi delle colonne della tabella Neptune con l'uso corretto delle maiuscole e delle minuscole, puoi configurare il connettore Neptune per la corrispondenza senza distinzione AWS Glue tra maiuscole e minuscole.
Per abilitare questa funzionalità, imposta la variabile di ambiente `enable_caseinsensitivematch` su `true` nella funzione Lambda del connettore Neptune.
### Specificazione del parametro glabel per i nomi delle tabelle con maiuscole e minuscole AWS Glue
Poiché AWS Glue supporta solo nomi di tabella minuscoli, è importante specificare il parametro `glabel` AWS Glue table quando si crea una tabella per Neptune e il nome della AWS Glue tabella Neptune include il maiuscolo.
Nella definizione della AWS Glue tabella, includete il `glabel` parametro e impostate il suo valore sul nome della tabella con l'involucro originale. Ciò garantisce che l'involucro corretto venga preservato quando AWS Glue interagisce con il tavolo Neptune. Nell'esempio seguente il valore di `glabel` è impostato sul nome della tabella `Airport`.
```
glabel = Airport
```
![\[Impostazione della proprietà glabel AWS Glue table per preservare l'indicizzazione del nome della tabella per una tabella di Neptune\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-neptune-1.png)
Per ulteriori informazioni sulla configurazione di un dispositivo AWS Glue Data Catalog per l'utilizzo con Neptune, [consulta AWS Glue Configurare](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-neptune/docs/aws-glue-sample-scripts) il catalogo su .com. GitHub
## Performance
Il connettore Athena Neptune esegue il pushdown del predicato per ridurre la quantità di dati scansionati dalla query. Tuttavia, i predicati che utilizzano la chiave primaria comportano un errore di query. Le clausole `LIMIT` riducono la quantità di dati scansionati, ma se non viene fornito un predicato, le query `SELECT` con una clausola `LIMIT` eseguiranno la scansione di almeno 16 MB di dati. Il connettore Neptune è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
## Query passthrough
Il connettore Neptune supporta le [query passthrough.](federated-query-passthrough.md) È possibile utilizzare questa funzionalità per eseguire query Gremlin sui grafici delle proprietà e per eseguire query SPARQL sui dati RDF.
Per creare query passthrough con Neptune, utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
DATABASE => 'database_name',
COLLECTION => 'collection_name',
QUERY => 'query_string'
))
```
Nell’esempio seguente la query passthrough di Neptune filtra per gli aeroporti con il codice `ATL`. Le virgolette singole raddoppiate servono per eseguire l’escape.
```
SELECT * FROM TABLE(
system.query(
DATABASE => 'graph-database',
COLLECTION => 'airport',
QUERY => 'g.V().has(''airport'', ''code'', ''ATL'').valueMap()'
))
```
## Risorse aggiuntive
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente su GitHub .com](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-neptune).
# Connettore Amazon Athena OpenSearch
OpenSearch Servizio
Il OpenSearch connettore Amazon Athena consente ad Amazon Athena di comunicare con le OpenSearch tue istanze in modo da poter utilizzare SQL per interrogare i tuoi dati. OpenSearch
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
**Nota**
A causa di un problema noto, il OpenSearch connettore non può essere utilizzato con un VPC.
Se hai abilitato Lake Formation nel tuo account, il ruolo IAM per il tuo connettore Lambda federato Athena che hai distribuito nell'accesso in lettura deve avere accesso in lettura in AWS Serverless Application Repository Lake Formation a. AWS Glue Data Catalog
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Termini
I seguenti termini si riferiscono al connettore. OpenSearch
+ **Dominio**: un nome che questo connettore associa all'endpoint dell'istanza. OpenSearch Il dominio viene utilizzato anche come nome del database. Per OpenSearch le istanze definite all'interno del OpenSearch servizio Amazon, il dominio è individuabile automaticamente. Per altre istanze, devi fornire una mappatura tra il nome di dominio e l'endpoint.
+ **Indice**: una tabella di database definita nell'istanza. OpenSearch
+ **Mappatura**: se un indice è una tabella del database, la mappatura è il relativo schema (ossia le definizioni dei campi e degli attributi).
Questo connettore supporta sia il recupero dei metadati dall' OpenSearch istanza che da. AWS Glue Data Catalog Se il connettore trova un AWS Glue database e una tabella che corrispondono ai nomi di OpenSearch dominio e di indice, tenta di utilizzarli per la definizione dello schema. Ti consigliamo di creare la AWS Glue tabella in modo che sia un superset di tutti i campi dell' OpenSearch indice.
+ **Documento**: un record all'interno di una tabella del database.
+ **Flusso di dati**: dati basati su tempo composti da più indici di supporto. Per ulteriori informazioni, consulta [Data stream](https://opensearch.org/docs/latest/dashboards/im-dashboards/datastream/) nella OpenSearch documentazione e [Introduzione ai flussi di dati](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/data-streams.html#data-streams-example) nella *Amazon OpenSearch Service Developer* Guide.
**Nota**
Poiché gli indici dei flussi di dati sono creati e gestiti internamente da open search, il connettore sceglie dal primo indice disponibile la mappatura dello schema. Per questo motivo, consigliamo vivamente di configurare una AWS Glue tabella come fonte di metadati supplementare. Per ulteriori informazioni, consulta [Configurazione di database e tabelle in AWS Glue](#connectors-opensearch-setting-up-databases-and-tables-in-aws-glue).
## Parameters
Utilizzate i parametri di questa sezione per configurare il OpenSearch connettore.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un OpenSearch connettore utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del OpenSearch connettore Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type OPENSEARCH
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il OpenSearch connettore creato utilizzando le connessioni Glue non supporta l'uso di un gestore di multiplexing.
Il OpenSearch connettore creato utilizzando le connessioni Glue supporta solo `ConnectionSchemaVersion` 2.
### Connessioni legacy
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue** — (Facoltativo) Se presente e impostato su true, il connettore non tenta di recuperare metadati supplementari da. AWS Glue
+ **query\$1timeout\$1cluster**: il periodo di timeout, in secondi, per le query sullo stato del cluster utilizzate nella generazione di scansioni in parallelo.
+ **query\$1timeout\$1search**: il periodo di timeout, in secondi, per le query di ricerca utilizzate per il recupero di documenti da un indice.
+ **auto\$1discover\$1endpoint**: un valore booleano. Il valore predefinito è `true`. Quando utilizzi il OpenSearch servizio Amazon e imposti questo parametro su true, il connettore può scoprire automaticamente i tuoi domini ed endpoint chiamando le operazioni API appropriate per descrivere o elencare sul Servizio. OpenSearch Per qualsiasi altro tipo di OpenSearch istanza (ad esempio, self-hosted), devi specificare gli endpoint di dominio associati nella variabile. `domain_mapping` Se`auto_discover_endpoint=true`, il connettore utilizza AWS le credenziali per l'autenticazione al Servizio. OpenSearch In caso contrario, il connettore recupera le credenziali del nome utente e della password tramite la variabile. Gestione dei segreti AWS `domain_mapping`
+ **domain\$1mapping**: viene utilizzato solo quando `auto_discover_endpoint` è impostato su false e definisce la mappatura tra i nomi di dominio e gli endpoint associati. La `domain_mapping` variabile può contenere più OpenSearch endpoint nel seguente formato:
```
domain1=endpoint1,domain2=endpoint2,domain3=endpoint3,...
```
Ai fini dell'autenticazione su un OpenSearch endpoint, il connettore supporta stringhe sostitutive inserite utilizzando il formato `${SecretName}` con nome utente e password recuperati da. Gestione dei segreti AWS Il segreto deve essere archiviato nel seguente formato JSON:
```
{ "username": "your_username", "password": "your_password" }
```
Il connettore analizzerà automaticamente questa struttura JSON per recuperare le credenziali.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) nella Guida per l'utente. Gestione dei segreti AWSGestione dei segreti AWS *
Nell'esempio seguente viene utilizzato il segreto `opensearch-creds`.
```
movies=https://${opensearch-creds}:search-movies-ne...qu---us-east-1---es.amazonaws.com
```
In fase di runtime, `${opensearch-creds}` viene visualizzato come nome utente e password, come nell'esempio seguente.
```
movies=https://myusername@mypassword:search-movies-ne...qu---us-east-1---es.amazonaws.com
```
Nel parametro `domain_mapping`, ogni coppia dominio-endpoint può utilizzare un segreto diverso. Il segreto stesso deve essere specificato nel formato @. *user\$1name* *password* Sebbene la password possa contenere `@` segni incorporati, la prima `@` funge da separatore da*user\$1name*.
È anche importante tenere a mente che questo connettore utilizza la virgola (,) e il segno uguale (=) come separatori per le coppie dominio-endpoint. Per questo motivo, non è consigliabile utilizzarli da nessuna parte all'interno del secreto archiviato.
## Configurazione di database e tabelle in AWS Glue
Il connettore ottiene le informazioni sui metadati utilizzando AWS Glue o. OpenSearch È possibile impostare una AWS Glue tabella come fonte di definizione dei metadati supplementare. Per abilitare questa funzionalità, definisci un AWS Glue database e una tabella che corrispondano al dominio e all'indice della fonte che stai integrando. Il connettore può inoltre sfruttare le definizioni dei metadati memorizzate nell' OpenSearch istanza recuperando la mappatura per l'indice specificato.
### Definizione dei metadati per gli array in OpenSearch
OpenSearch non dispone di un tipo di dati di array dedicato. Qualsiasi campo può contenere zero o più valori purché siano dello stesso tipo di dati. Se si desidera utilizzare OpenSearch come fonte di definizione dei metadati, è necessario definire una `_meta` proprietà per tutti gli indici utilizzati con Athena per i campi che devono essere considerati un elenco o un array. Se non completi questo passaggio, le query restituiscono solo il primo elemento nel campo elenco. Quando specifichi la proprietà `_meta`, i nomi dei campi devono essere completamente qualificati per le strutture JSON nidificate (ad esempio, `address.street`, dove `street` è un campo nidificato all'interno di una struttura `address`).
L'esempio seguente definisce gli elenchi `actor` e `genre` nella tabella `movies`.
```
PUT movies/_mapping
{
"_meta": {
"actor": "list",
"genre": "list"
}
}
```
### Tipi di dati
Il OpenSearch connettore può estrarre le definizioni dei metadati da entrambe le istanze o dall'istanza AWS Glue . OpenSearch Il connettore utilizza la mappatura illustrata nella seguente tabella per convertire le definizioni in tipi di dati Apache Arrow, inclusi i punti indicati nella sezione seguente.
****
| OpenSearch | Apache Arrow | AWS Glue |
| --- | --- | --- |
| text, keyword, binary | VARCHAR | stringa |
| Long | BIGINT | bigint |
| scaled\$1float | BIGINT | SCALED\$1FLOAT(...) |
| intero | INT | int |
| short | SMALLINT | smallint |
| byte | TINYINT | tinyint |
| virgola mobile a doppia precisione | FLOAT8 | virgola mobile a doppia precisione |
| float, half\$1float | FLOAT4 | virgola mobile |
| booleano | BIT | booleano |
| date, date\$1nanos | DATEMILLI | timestamp |
| Struttura JSON | STRUCT | STRUCT |
| \$1meta (per informazioni, consulta la sezione [Definizione dei metadati per gli array in OpenSearch](#connectors-opensearch-defining-metadata-for-arrays-in-opensearch).) | LIST | ARRAY |
#### Note sui tipi di dati
+ Attualmente, il connettore supporta solo OpenSearch i AWS Glue tipi di dati elencati nella tabella precedente.
+ Un `scaled_float` è un numero a virgola mobile scalato in base a un fattore di scala fisso doppio e rappresentato come `BIGINT` in Apache Arrow. Ad esempio, 0,756 con un fattore di scala pari a 100 viene arrotondato a 76.
+ Per definire un `scaled_float` in AWS Glue, è necessario selezionare il tipo di `array` colonna e dichiarare il campo utilizzando il formato SCALED\$1FLOAT (). *scaling\$1factor*
Gli esempi seguenti sono validi:
```
SCALED_FLOAT(10.51)
SCALED_FLOAT(100)
SCALED_FLOAT(100.0)
```
Gli esempi seguenti non sono validi:
```
SCALED_FLOAT(10.)
SCALED_FLOAT(.5)
```
+ Durante la conversione da `date_nanos` a `DATEMILLI`, i nanosecondi vengono arrotondati al millisecondo più vicino. I valori validi per `date` e `date_nanos` includono, senza limitazione, i seguenti formati:
```
"2020-05-18T10:15:30.123456789"
"2020-05-15T06:50:01.123Z"
"2020-05-15T06:49:30.123-05:00"
1589525370001 (epoch milliseconds)
```
+ An OpenSearch `binary` è una rappresentazione in formato stringa di un valore binario codificato utilizzando `Base64` e convertito in a. `VARCHAR`
## Esecuzione di query SQL
Di seguito sono riportati alcuni esempi di query DDL che puoi utilizzare con questo connettore. Negli esempi, *function\$1name* corrisponde al nome della funzione Lambda, *domain* è il nome del dominio su cui si desidera eseguire la query ed *index* è il nome dell'indice.
```
SHOW DATABASES in `lambda:function_name`
```
```
SHOW TABLES in `lambda:function_name`.domain
```
```
DESCRIBE `lambda:function_name`.domain.index
```
## Performance
Il OpenSearch connettore Athena supporta scansioni parallele basate su shard. Il connettore utilizza le informazioni sullo stato del cluster recuperate dall' OpenSearch istanza per generare più richieste per una query di ricerca di documenti. Le richieste vengono suddivise per ogni partizione ed eseguite in simultanea.
Il connettore inoltre esegue il pushdown dei predicati come parte delle sue query di ricerca di documenti. I seguenti query e predicato di esempio mostrano come il connettore utilizza il pushdown del predicato.
**Query**
```
SELECT * FROM "lambda:elasticsearch".movies.movies
WHERE year >= 1955 AND year <= 1962 OR year = 1996
```
**Predicate**
```
(_exists_:year) AND year:([1955 TO 1962] OR 1996)
```
## Query passthrough
Il OpenSearch connettore supporta [le query passthrough e utilizza il linguaggio Query](federated-query-passthrough.md) DSL. [Per ulteriori informazioni sull'esecuzione di query con Query DSL, consulta Query DSL nella documentazione di Elasticsearch o [Query DSL](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html) nella documentazione.](https://opensearch.org/docs/latest/query-dsl/) OpenSearch
Per utilizzare le query passthrough con il connettore, utilizzate la seguente sintassi: OpenSearch
```
SELECT * FROM TABLE(
system.query(
schema => 'schema_name',
index => 'index_name',
query => "{query_string}"
))
```
Il seguente OpenSearch esempio di filtri di interrogazione passthrough per i dipendenti con status occupazionale attivo nell'`employee`indice dello schema. `default`
```
SELECT * FROM TABLE(
system.query(
schema => 'default',
index => 'employee',
query => "{ ''bool'':{''filter'':{''term'':{''status'': ''active''}}}}"
))
```
## Risorse aggiuntive
+ *Per un articolo sull'utilizzo del OpenSearch connettore Amazon Athena per interrogare i dati in Amazon OpenSearch Service e Amazon S3 in un'unica query, [consulta Interrogare i dati in Amazon Service usando SQL di OpenSearch Amazon Athena](https://aws.amazon.com/blogs/big-data/query-data-in-amazon-opensearch-service-using-sql-from-amazon-athena/) nel Big Data Blog.AWS *
+ Per ulteriori informazioni su questo connettore, visita [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-elasticsearch) su .com. GitHub
# Connettore Amazon Athena per Oracle
Il connettore Amazon Athena per Oracle consente ad Amazon Athena di eseguire query SQL sui dati archiviati in Oracle in esecuzione on-premise oppure su Amazon EC2 o Amazon RDS. Puoi anche utilizzare il connettore per eseguire query sui dati [Oracle Exadata](https://www.oracle.com/engineered-systems/exadata/).
Questo connettore può essere registrato con Catalogo Glue Data come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Solo i Database Oracle della versione 12.1.0.2 sono supportati.
+ Se il connettore Oracle non utilizza una connessione Glue, i nomi di database, tabelle e colonne verranno convertiti in lettere maiuscole dal connettore.
Se il connettore Oracle utilizza una connessione Glue, i nomi di database, tabelle e colonne non verranno impostati in maiuscolo dal connettore. Per modificare questo comportamento di classificazione delle maiuscole, modificare la variabile `casing_mode` di ambiente Lambda in `upper` o `lower` in base alle esigenze.
Un connettore Oracle che utilizza la connessione Glue non supporta l’uso di un gestore multiplexing.
+ Quando si utilizza Oracle `NUMBER` senza definire Precision e Scale, Athena lo considera come `BIGINT`. Per ottenere le cifre decimali richieste in Athena, specificare `default_scale=` nelle variabili di ambiente Lambda.
## Termini
I seguenti termini si riferiscono al connettore Oracle.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizzare i parametri mostrati in questa sezione per configurare il connettore Oracle.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Oracle utilizzando un oggetto di connessioni Glue. Per fare ciò, impostare la variabile di ambiente `glue_connection` del connettore Oracle Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type ORACLE
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **is\$1fips\$1enabled**: (facoltativo) imposta su true quando la modalità FIPS è abilitata. Il valore predefinito è false.
+ **casing\$1mode**: (facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **lower**: tutti i nomi di schemi e tabelle specificati verranno impostati in minuscolo. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati verranno impostati in maiuscolo. Questa è l’impostazione predefinita per i connettori a cui non è associata una connessione glue.
+ **case\$1insensitive\$1search**: esegue ricerche senza distinzione tra maiuscole e minuscole nei nomi di schemi e tabelle in Oracle. Utilizza questo valore se la query contiene nomi di schemi o tabelle che non corrispondono al casing predefinito del connettore.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Oracle creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore Oracle creato utilizzando connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
**Proprietà dell’ambiente**
+ **default**: la stringa di connessione JDBC da utilizzare per connettersi all’istanza del database Oracle. Ad esempio, `oracle://${jdbc_connection_string}`
+ **catalog\$1connection\$1string**: utilizzata dal gestore multiplexing (non supportata quando si utilizza una connessione Glue). Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato con Athena è myoraclecatalog, il nome della variabile di ambiente è myoraclecatalog\$1connection\$1string.
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **is\$1fips\$1enabled**: (facoltativo) imposta su true quando la modalità FIPS è abilitata. Il valore predefinito è false.
+ **casing\$1mode**: (facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **lower**: tutti i nomi di schemi e tabelle specificati verranno impostati in minuscolo. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati verranno impostati in maiuscolo. Questa è l’impostazione predefinita per i connettori a cui non è associata una connessione glue.
+ **case\$1insensitive\$1search**: esegue ricerche senza distinzione tra maiuscole e minuscole nei nomi di schemi e tabelle in Oracle. Utilizza questo valore se la query contiene nomi di schemi o tabelle che non corrispondono al casing predefinito del connettore.
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
oracle://${jdbc_connection_string}
```
**Nota**
Se la password contiene caratteri speciali (ad esempio `some.password`), racchiudi la password tra virgolette doppie quando la passi alla stringa di connessione (ad esempio `"some.password"`). In caso contrario, è possibile che venga generato come errore URL Oracle specificato non valido.
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Oracle.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | OracleCompositeHandler |
| Gestore dei metadati | OracleMetadataHandler |
| Gestore dei record | OracleRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
| IsFIPSEnabled | Opzionale. Imposta su true quando è abilitata la modalità FIPS. Il valore predefinito è false. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
Il connettore supporta connessioni basate su SSL alle istanze Amazon RDS. Il supporto è limitato al protocollo Transport Layer Security (TLS) e all'autenticazione del server da parte del client. L'autenticazione reciproca non è supportata in Amazon RDS. La seconda riga della tabella seguente mostra la sintassi per l'utilizzo di SSL.
La seguente proprietà di esempio si riferisce a una singola istanza Oracle supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle\$1@//hostname:port/servicename |
| | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle\$1@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS) (HOST=)(PORT=))(CONNECT\$1DATA=(SID=))(SECURITY=(SSL\$1SERVER\$1CERT\$1DN=))) |
#### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati nella Guida per l' Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Nota**
Se la password contiene caratteri speciali (ad esempio `some.password`), racchiudi la password tra virgolette doppie quando la memorizzi in Secrets Manager (ad esempio `"some.password"`). In caso contrario, è possibile che venga generato come errore URL Oracle specificato non valido.
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/RDS/Oracle}`.
```
oracle://jdbc:oracle:thin:${Test/RDS/Oracle}@//hostname:port/servicename
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
oracle://jdbc:oracle:thin:username/password@//hostname:port/servicename
```
Attualmente, il connettore Oracle riconosce le proprietà JDBC `UID` e `PWD`.
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | OracleMuxCompositeHandler |
| Gestore dei metadati | OracleMuxMetadataHandler |
| Gestore dei record | OracleMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è myoraclecatalog, il nome della variabile di ambiente è myoraclecatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è. lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME \$1 |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Oracle MUX che supporta due istanze del database: `oracle1` (il valore predefinito) e `oracle2`.
****
| Proprietà | Valore |
| --- | --- |
| default | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle1\$1@//oracle1.hostname:port/servicename |
| oracle\$1catalog1\$1connection\$1string | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle1\$1@//oracle1.hostname:port/servicename |
| oracle\$1catalog2\$1connection\$1string | oracle://jdbc:oracle:thin:\$1\$1Test/RDS/Oracle2\$1@//oracle2.hostname:port/servicename |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC, Oracle e Arrow.
****
| JDBC | Oracle | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Numero intero | N/D | Tiny |
| Breve | smallint | Smallint |
| Numero intero | intero | Int |
| Long | bigint | Bigint |
| virgola mobile | float4 | Float4 |
| Double | float8 | Float8 |
| Data | date | DateDay |
| Time stamp | timestamp | DateMilli |
| Stringa | text | Varchar |
| Byte | bytes | Varbinary |
| BigDecimal | numeric(p,s) | Decimale |
| ARRAY | N/D (vedi nota) | List |
## Partizioni e suddivisioni
Le partizioni vengono utilizzate per determinare come generare suddivisioni per il connettore. Athena costruisce una colonna sintetica di tipo `varchar` che rappresenta lo schema di partizionamento della tabella per aiutare il connettore a generare suddivisioni. Il connettore non modifica la definizione effettiva della tabella.
## Performance
Oracle supporta le partizioni native. Il connettore Oracle di Athena può recuperare dati da queste partizioni in parallelo. Se desideri interrogare set di dati molto grandi con una distribuzione uniforme delle partizioni, ti consigliamo vivamente il partizionamento nativo. La selezione di un sottoinsieme di colonne velocizza notevolmente il runtime delle query e riduce i dati scansionati. Il connettore Oracle è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità. Tuttavia, i tempi di esecuzione delle query tendono a essere lunghi.
Il connettore Athena Oracle esegue il pushdown del predicato per ridurre la quantità di dati scansionati dalla query. I predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati scansionati e ridurre il tempo di esecuzione delle query.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Oracle di Athena può combinare queste espressioni e inviarle direttamente a Oracle per funzionalità avanzate e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Oracle di Athena supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Query passthrough
Il connettore Oracle supporta [query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare la query completa all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Oracle, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in Oracle. La query seleziona tutte le colonne della tabella `customer`.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-oracle/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-oracle/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-oracle/pom.xml) per il connettore Oracle su .com. GitHub
Per ulteriori informazioni su questo connettore, visita [il sito corrispondente su GitHub .com](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-oracle).
# Connettore PostgreSQL di Amazon Athena
Il connettore PostgreSQL per Amazon Athena consente ad Amazon Athena di accedere ai database PostgreSQL.
Questo connettore può essere registrato con Catalogo dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Come PostgreSQL, Athena considera gli spazi finali nei tipi `CHAR` di PostgreSQL come semanticamente insignificanti ai fini della lunghezza e del confronto. Nota che ciò si applica solo ai tipi `CHAR` ma non ai tipi `VARCHAR`. Athena ignora gli spazi finali per il tipo `CHAR`, ma li considera significativi per il tipo `VARCHAR`.
+ Quando si utilizza il tipo di dati stringa di caratteri [citext](https://www.postgresql.org/docs/current/citext.html) senza distinzione tra maiuscole e minuscole, PostgreSQL utilizza un confronto di dati senza distinzione tra maiuscole e minuscole diverso da Athena. Questa differenza crea una discrepanza tra i dati durante le operazioni `JOIN` di SQL. Per risolvere questo problema, utilizzare la funzionalità query passthrough del connettore PostgreSQL. Per ulteriori informazioni, consultare la sezione relativa alle [query passthrough](#connectors-postgres-passthrough-queries) più avanti in questo documento.
## Termini
I seguenti termini si riferiscono al connettore PostgreSQL.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore PostgreSQL.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore PostgreSQL utilizzando un oggetto di connessioni Glue.
Per fare ciò, impostare la variabile di ambiente `glue_connection` del connettore PostgreSQL Lambda sul nome della connessione Glue da utilizzare.
Utilizzare il seguente comando per ottenere lo schema dell’oggetto di una connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type POSTGRESQL
```
**Proprietà dell’ambiente Lambda**
**glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore PostgreSQL creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore PostgreSQL creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
postgres://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | PostGreSqlMuxCompositeHandler |
| Gestore dei metadati | PostGreSqlMuxMetadataHandler |
| Gestore dei record | PostGreSqlMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mypostgrescatalog, il nome della variabile di ambiente è mypostgrescatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio riguardano una funzione Lambda PostGreSql MUX che supporta due istanze di database`postgres1`: (impostazione predefinita) e. `postgres2`
****
| Proprietà | Valore |
| --- | --- |
| default | postgres://jdbc:postgresql://postgres1.host:5432/default?\$1\$1Test/RDS/PostGres1\$1 |
| postgres\$1catalog1\$1connection\$1string | postgres://jdbc:postgresql://postgres1.host:5432/default?\$1\$1Test/RDS/PostGres1\$1 |
| postgres\$1catalog2\$1connection\$1string | postgres://jdbc:postgresql://postgres2.host:5432/default?user=sample&password=sample |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti hardcoded in Gestione dei segreti AWS, consultate [Move hardcoded](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) secret in nella Guida per l'utente. Gestione dei segreti AWSGestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/RDS/PostGres1}`.
```
postgres://jdbc:postgresql://postgres1.host:5432/default?...&${Test/RDS/PostGres1}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
postgres://jdbc:postgresql://postgres1.host:5432/default?...&user=sample2&password=sample2&...
```
Attualmente, il connettore PostgreSQL riconosce le proprietà JDBC `user` e `password`.
##### Abilitazione SSL
Per supportare SSL nella tua connessione PostgreSQL, aggiungi alla stringa di connessione quanto segue:
```
&sslmode=verify-ca&sslfactory=org.postgresql.ssl.DefaultJavaSSLFactory
```
**Esempio**
La stringa di connessione dell'esempio seguente non utilizza SSL.
```
postgres://jdbc:postgresql://example-asdf-aurora-postgres-endpoint:5432/asdf?user=someuser&password=somepassword
```
Per abilitare SSL, modifica la stringa come segue.
```
postgres://jdbc:postgresql://example-asdf-aurora-postgres-endpoint:5432/asdf?user=someuser&password=somepassword&sslmode=verify-ca&sslfactory=org.postgresql.ssl.DefaultJavaSSLFactory
```
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza PostgreSQL.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | PostGreSqlCompositeHandler |
| Gestore dei metadati | PostGreSqlMetadataHandler |
| Gestore dei record | PostGreSqlRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza PostgreSQL supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | postgres://jdbc:postgresql://postgres1.host:5432/default?secret=\$1\$1Test/RDS/PostgreSQL1\$1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
La tabella seguente mostra i tipi di dati corrispondenti per JDBC, PostGre SQL e Arrow.
****
| JDBC | PostGreSQL | Arrow |
| --- | --- | --- |
| Booleano | Booleano | Bit |
| Numero intero | N/D | Tiny |
| Breve | smallint | Smallint |
| Numero intero | intero | Int |
| Long | bigint | Bigint |
| virgola mobile | float4 | Float4 |
| Double | float8 | Float8 |
| Data | date | DateDay |
| Time stamp | timestamp | DateMilli |
| Stringa | text | Varchar |
| Byte | bytes | Varbinary |
| BigDecimal | numeric(p,s) | Decimale |
| ARRAY | N/D (vedi nota) | List |
**Nota**
Il tipo `ARRAY` è supportato per il connettore PostgreSQL con i seguenti vincoli: le matrici multidimensionali (`[][]` o matrici nidificate) non sono supportate. Le colonne con tipi di dati `ARRAY` non supportati vengono convertite in una matrice di elementi di stringa (`array`).
## Partizioni e suddivisioni
Le partizioni vengono utilizzate per determinare come generare suddivisioni per il connettore. Athena costruisce una colonna sintetica di tipo `varchar` che rappresenta lo schema di partizionamento della tabella per aiutare il connettore a generare suddivisioni. Il connettore non modifica la definizione effettiva della tabella.
## Performance
PostgreSQL supporta le partizioni native. Il connettore PostgreSQL di Athena può recuperare dati da queste partizioni in parallelo. Se desideri interrogare set di dati molto grandi con una distribuzione uniforme delle partizioni, ti consigliamo vivamente il partizionamento nativo.
Il connettore Athena PostgreSQL esegue il pushdown dei predicati per ridurre i dati scansionati dalla query. Le clausole `LIMIT`, i predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati scansionati e per ridurre il tempo di esecuzione delle query. Tuttavia, la selezione di un sottoinsieme di colonne comporta un runtime di esecuzione delle query più lungo.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore PostgreSQL di Athena può combinare queste espressioni e inviarle direttamente a PostgreSQL per funzionalità avanzate e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore PostgreSQL di Athena supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Query passthrough
Il connettore PostgreSQL supporta le [query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con PostgreSQL, è possibile usare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in PostgreSQL. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-postgresql/pom.xml) per il connettore PostgreSQL su .com. GitHub
[Per ulteriori informazioni su questo connettore, visita il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-postgresql) GitHub
# Connettore Amazon Athena Redis OSS
Il connettore Amazon Athena Redis OSS consente ad Amazon Athena di comunicare con le istanze Redis OSS in modo da poter eseguire query sui dati Redis OSS con SQL. È possibile utilizzare AWS Glue Data Catalog per mappare le coppie chiave-valore Redis OSS in tabelle virtuali.
A differenza dei tradizionali archivi di dati relazionali, Redis OSS non ha il concetto di tabella o colonna. Al contrario, Redis OSS offre modelli di accesso chiave-valore in cui la chiave è essenzialmente una `string` e il valore è una `string`, un `z-set` oppure una `hmap`.
È possibile utilizzare il AWS Glue Data Catalog per creare schemi e configurare tabelle virtuali. Le proprietà speciali della tabella indicano al connettore Redis OSS per Athena come mappare le chiavi e i valori di Redis OSS in una tabella. Per ulteriori informazioni, consultare [Configurazione di database e tabelle in AWS Glue](#connectors-redis-setting-up-databases-and-tables-in-glue) riportata di seguito in questo documento.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
Se hai abilitato Lake Formation nel tuo account, il ruolo IAM per il tuo connettore Lambda federato Athena che hai distribuito nell'accesso in lettura deve avere accesso in lettura in AWS Serverless Application Repository Lake Formation a. AWS Glue Data Catalog
Il connettore Amazon Athena Redis OSS supporta Amazon MemoryDB e ElastiCache Amazon (Redis OSS).
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
+ Prima di utilizzare questo connettore, configura un VPC e un gruppo di sicurezza. Per ulteriori informazioni, consulta [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore Redis.
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **glue\$1catalog**: (facoltativo) utilizza questa opzione per specificare un [catalogo AWS Glue multi-account](data-sources-glue-cross-account.md). Per impostazione predefinita, il connettore tenta di ottenere metadati dal proprio account. AWS Glue
## Configurazione di database e tabelle in AWS Glue
Per abilitare una AWS Glue tabella da utilizzare con Redis OSS, è possibile impostare le seguenti proprietà della tabella: `redis-endpoint``redis-value-type`, e `redis-keys-zset` o`redis-key-prefix`.
Inoltre, qualsiasi AWS Glue database che contiene tabelle Redis OSS deve avere una `redis-db-flag` proprietà URI del database. Per impostare la proprietà `redis-db-flag` URI, usa la AWS Glue console per modificare il database.
L'elenco seguente descrive le proprietà delle tabelle.
+ **redis-endpoint** — (Obbligatorio) Il *hostname* `:` *port* `:` *password* server Redis OSS che contiene i dati per questa tabella (ad esempio,`athena-federation-demo.cache.amazonaws.com:6379`) In alternativa, puoi memorizzare l'endpoint, o parte dell'endpoint, Gestione dei segreti AWS utilizzando \$1 \$1\$1 *Secret\$1Name* come valore della proprietà della tabella.
**Nota**
[Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
+ **redis-keys-zset**[— (Obbligatorio se non `redis-key-prefix` viene utilizzato) Un elenco di chiavi separate da virgole il cui valore è un set (ad esempio,).](https://redis.com/ebook/part-2-core-concepts/chapter-3-commands-in-redis/3-5-sorted-sets/) `active-orders,pending-orders` Ciascuno dei valori del set viene considerato come una chiave facente parte della tabella. È necessario impostare la proprietà `redis-keys-zset` o la proprietà `redis-key-prefix`.
+ **redis-key-prefix**— (Obbligatorio se non `redis-keys-zset` viene utilizzato) Un elenco separato da virgole di prefissi chiave per la scansione dei valori nella tabella (ad esempio,). `accounts-*,acct-` È necessario impostare la proprietà `redis-key-prefix` o la proprietà `redis-keys-zset`.
+ **redis-value-type**— (Obbligatorio) Definisce in che modo i valori delle chiavi definite da uno `redis-key-prefix` o dall'altro `redis-keys-zset` vengono mappati sulla tabella. Un valore letterale è associato a una singola colonna. Anche un zset è associato a una singola colonna, ma ogni chiave può archiviare più righe. Un hash consente a ciascuna chiave di costituire una riga con più colonne (ad esempio, hash, letterale o zset).
+ **redis-ssl-flag**— (Facoltativo) Quando`True`, crea una connessione Redis che utilizza SSL/TLS. Il valore predefinito è `False`.
+ **redis-cluster-flag**— (Facoltativo) Quando`True`, abilita il supporto per le istanze Redis in cluster. Il valore predefinito è `False`.
+ **redis-db-number**— (Facoltativo) Si applica solo alle istanze autonome e non raggruppate.) Imposta questo numero (ad esempio 1, 2 o 3) per leggere da un database Redis non predefinito. L'impostazione predefinita è il database logico Redis 0. Questo numero non si riferisce a un database in Athena o AWS Glue, ma a un database logico Redis. Per ulteriori informazioni, consulta la sezione [SELECT index](https://redis.io/commands/select) (Indice SELECT) nella documentazione di Redis.
## Tipi di dati
Il connettore Redis OSS supporta i seguenti tipi di dati. I flussi Redis OSS non sono supportati.
+ [Stringa](https://redis.com/ebook/part-1-getting-started/chapter-1-getting-to-know-redis/1-2-what-redis-data-structures-look-like/1-2-1-strings-in-redis/)
+ [Hash](https://redis.com/ebook/part-1-getting-started/chapter-1-getting-to-know-redis/1-2-what-redis-data-structures-look-like/1-2-4-hashes-in-redis/)
+ Set ordinato () [ZSet](https://redis.com/ebook/part-2-core-concepts/chapter-3-commands-in-redis/3-5-sorted-sets/)
Tutti i valori di Redis OSS vengono recuperati come tipo di dati `string`. Quindi vengono convertiti in uno dei seguenti tipi di dati Apache Arrow in base a come sono state definite le tabelle nel AWS Glue Data Catalog.
****
| AWS Glue tipo di dati | Tipo di dati Apache Arrow |
| --- | --- |
| int | INT |
| stringa | VARCHAR |
| bigint | BIGINT |
| virgola mobile a doppia precisione | FLOAT8 |
| virgola mobile | FLOAT4 |
| smallint | SMALLINT |
| tinyint | TINYINT |
| booleano | BIT |
| binary | VARBINARY |
## Autorizzazioni richieste
Consulta la sezione `Policies` del file [athena-redis.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-redis/athena-redis.yaml) per i dettagli completi delle policy IAM richieste da questo connettore. L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **AWS Glue Data Catalog**— Il connettore Redis richiede l'accesso in sola lettura a per ottenere informazioni sullo schema. AWS Glue Data Catalog
+ **CloudWatch Registri**: il connettore richiede l'accesso ai CloudWatch registri per l'archiviazione dei registri.
+ **Gestione dei segreti AWS accesso in lettura**: se scegli di archiviare i dettagli degli endpoint Redis in Secrets Manager, devi concedere al connettore l'accesso a tali segreti.
+ **Accesso VPC**: il connettore richiede la capacità di collegare e scollegare le interfacce al VPC in modo che possa connettersi ad esso e comunicare con le istanze Redis.
## Performance
Il connettore Redis OSS per Athena tenta di eseguire in parallelo le query sull’istanza Redis OSS in base al tipo di tabella che hai definito (ad esempio, chiavi zset chiavi di prefisso).
Il connettore Athena Redis esegue il pushdown del predicato per ridurre la quantità di dati scansionati dalla query. Tuttavia, le query contenenti un predicato sulla chiave primaria comportano un errore di timeout. Le clausole `LIMIT` riducono la quantità di dati scansionati, ma se non viene fornito un predicato, le query `SELECT` con una clausola `LIMIT` eseguiranno la scansione di almeno 16 MB di dati. Il connettore Redis è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
## Query passthrough
Il connettore Redis supporta le [query passthrough](federated-query-passthrough.md). È possibile utilizzare questa funzionalità per eseguire query che utilizzano lo script Lua sui database Redis.
Per creare query passthrough con Redis, utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.script(
script => 'return redis.[call|pcall](query_script)',
keys => '[key_pattern]',
argv => '[script_arguments]'
))
```
L’esempio seguente esegue uno script Lua per ottenere il valore in chiave `l:a`.
```
SELECT * FROM TABLE(
system.script(
script => 'return redis.call("GET", KEYS[1])',
keys => '[l:a]',
argv => '[]'
))
```
## Informazioni sulla licenza
Il progetto del connettore Redis per Amazon Athena è concesso in licenza ai sensi della [Licenza Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Risorse aggiuntive
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente su GitHub .com](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-redis).
# Connettore Redshift di Amazon Athena
Il connettore Redshift di Amazon Athena consente ad Amazon Athena di accedere ai propri database Amazon Redshift e Amazon Redshift Serverless, incluse le visualizzazioni Redshift Serverless. È possibile connettersi a entrambi i servizi usando le impostazioni di configurazione della stringa di connessione JDBC descritte in questa pagina.
Questo connettore può essere registrato con il Catalogo dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Poiché Redshift non supporta le partizioni esterne, tutti i dati specificati da una query vengono recuperati ogni volta.
+ Come Redshift, Athena considera gli spazi finali nei tipi `CHAR` di Redshift come semanticamente insignificanti ai fini della lunghezza e del confronto. Notare che ciò si applica solo ai tipi `CHAR` ma non ai tipi `VARCHAR`. Athena ignora gli spazi finali per il tipo `CHAR`, ma li considera significativi per il tipo `VARCHAR`.
## Termini
I seguenti termini sono correlati al connettore Redshift.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore Redshift.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Redshift utilizzando un oggetto di connessioni Glue. Per farlo, impostare la variabile di ambiente `glue_connection` del connettore Amazon Redshift Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type REDSHIFT
```
**Proprietà dell’ambiente Lambda**
**glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Redshift creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore Redshift creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
**Proprietà dell’ambiente**
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **disable\$1glue** — (Facoltativo) Se presente e impostato su true, il connettore non tenta di recuperare metadati supplementari da. AWS Glue
+ **glue\$1catalog**: (facoltativo) utilizza questa opzione per specificare un [catalogo AWS Glue multi-account](data-sources-glue-cross-account.md). Per impostazione predefinita, il connettore tenta di ottenere metadati dal proprio account. AWS Glue
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
redshift://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | RedshiftMuxCompositeHandler |
| Gestore dei metadati | RedshiftMuxMetadataHandler |
| Gestore dei record | RedshiftMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è myredshiftcatalog, il nome della variabile di ambiente è myredshiftcatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Redshift MUX che supporta due istanze del database: `redshift1` (il valore predefinito) e `redshift2`.
****
| Proprietà | Valore |
| --- | --- |
| default | redshift://jdbc:redshift://redshift1.host:5439/dev?user=sample2&password=sample2 |
| redshift\$1catalog1\$1connection\$1string | redshift://jdbc:redshift://redshift1.host:3306/default?\$1\$1Test/RDS/Redshift1\$1 |
| redshift\$1catalog2\$1connection\$1string | redshift://jdbc:redshift://redshift2.host:3333/default?user=sample2&password=sample2 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto \$1\$1Test/RDS/ `Redshift1`\$1.
```
redshift://jdbc:redshift://redshift1.host:3306/default?...&${Test/RDS/Redshift1}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
redshift://jdbc:redshift://redshift1.host:3306/default?...&user=sample2&password=sample2&...
```
Attualmente, il connettore Redshift riconosce le proprietà JDBC `user` e `password`.
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC e Apache Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Numero intero | Tiny |
| Breve | Smallint |
| Numero intero | Int |
| Long | Bigint |
| virgola mobile | Float4 |
| Double | Float8 |
| Data | DateDay |
| Time stamp | DateMilli |
| Stringa | Varchar |
| Byte | Varbinary |
| BigDecimal | Decimale |
| ARRAY | List |
## Partizioni e suddivisioni
Redshift non supporta le partizioni esterne. Per ulteriori informazioni sui problemi relativi alle prestazioni, consulta la sezione [Performance](#connectors-redshift-performance).
## Performance
Il connettore Athena Redshift esegue il pushdown dei predicati per ridurre i dati scansionati dalla query. `LIMIT`clausole, `ORDER BY` clausole, predicati semplici ed espressioni complesse vengono inserite nel connettore per ridurre la quantità di dati scansionati e ridurre il tempo di esecuzione delle query. Tuttavia, la selezione di un sottoinsieme di colonne comporta un runtime di esecuzione delle query più lungo. Amazon Redshift è particolarmente soggetto a rallentamenti nell'esecuzione delle query quando più query vengono eseguite simultaneamente.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Query top N
Una query top `N` principale specifica un ordinamento dei set di risultati e un limite al numero di righe restituite. Puoi utilizzare questo tipo di query per determinare i valori massimi top `N` o i valori minimi top `N` per i set di dati. Con il pushdown top `N`, il connettore restituisce solo le righe ordinate `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Redshift di Athena può combinare queste espressioni e inviarle direttamente a Redshift per migliorare le funzionalità e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Redshift di Athena supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
ORDER BY col_a DESC
LIMIT 10;
```
Per un articolo sull'utilizzo del pushdown del predicato per migliorare le prestazioni nelle query federate, incluso Amazon Redshift, consulta [Come migliorare le query federate con il pushdown del predicato in Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-federated-queries-with-predicate-pushdown-in-amazon-athena/) nel *Blog sui Big Data di AWS *.
## Query passthrough
Il connettore Redshift supporta le [query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Redshift, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in Redshift. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-redshift/pom.xml) per il connettore Redshift su .com. GitHub
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-redshift) su .com. GitHub
# Connettore Amazon Athena per SAP HANA
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ In SAP HANA, i nomi degli oggetti vengono convertiti in lettere maiuscole quando vengono archiviati nel database SAP HANA. Tuttavia, poiché i nomi tra virgolette fanno distinzione tra maiuscole e minuscole, è possibile che due tabelle abbiano lo stesso nome in lettere minuscole e maiuscole (ad esempio, `EMPLOYEE` e `employee`).
In Athena Federated Query, i nomi delle tabelle dello schema vengono forniti alla funzione Lambda in lettere minuscole. Per risolvere il problema, puoi fornire suggerimenti sulle query `@schemaCase` per recuperare i dati dalle tabelle i cui nomi che fanno distinzione tra maiuscole e minuscole. Di seguito sono riportate due query di esempio con suggerimenti per le query.
```
SELECT *
FROM "lambda:saphanaconnector".SYSTEM."MY_TABLE@schemaCase=upper&tableCase=upper"
```
```
SELECT *
FROM "lambda:saphanaconnector".SYSTEM."MY_TABLE@schemaCase=upper&tableCase=lower"
```
## Termini
I seguenti termini si riferiscono al connettore SAP HANA.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizza i parametri di questa sezione per configurare il connettore SAP HANA.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore SAP HANA utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore SAP HANA Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type SAPHANA
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore SAP HANA creato utilizzando le connessioni Glue non supporta l’uso di un gestore di multiplexing.
Il connettore SAP HANA creato utilizzando le connessioni Glue supporta `ConnectionSchemaVersion` solo 2.
### Connessioni legacy
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
saphana://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | SaphanaMuxCompositeHandler |
| Gestore dei metadati | SaphanaMuxMetadataHandler |
| Gestore dei record | SaphanaMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mysaphanacatalog, il nome della variabile di ambiente è mysaphanacatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è. lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME \$1 |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Saphana MUX che supporta due istanze del database: `saphana1` (il valore predefinito) e `saphana2`.
****
| Proprietà | Valore |
| --- | --- |
| default | saphana://jdbc:sap://saphana1.host:port/?\$1\$1Test/RDS/ Saphana1\$1 |
| saphana\$1catalog1\$1connection\$1string | saphana://jdbc:sap://saphana1.host:port/?\$1\$1Test/RDS/ Saphana1\$1 |
| saphana\$1catalog2\$1connection\$1string | saphana://jdbc:sap://saphana2.host:port/?user=sample2&password=sample2 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/RDS/Saphana1}`.
```
saphana://jdbc:sap://saphana1.host:port/?${Test/RDS/Saphana1}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
saphana://jdbc:sap://saphana1.host:port/?user=sample2&password=sample2&...
```
Attualmente, il connettore SAP HANA riconosce le proprietà JDBC `user` e `password`.
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza SAP HANA.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | SaphanaCompositeHandler |
| Gestore dei metadati | SaphanaMetadataHandler |
| Gestore dei record | SaphanaRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza SAP HANA supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | saphana://jdbc:sap://saphana1.host:port/?secret=Test/RDS/Saphana1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC e Apache Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Numero intero | Tiny |
| Breve | Smallint |
| Numero intero | Int |
| Long | Bigint |
| virgola mobile | Float4 |
| Double | Float8 |
| Data | DateDay |
| Time stamp | DateMilli |
| Stringa | Varchar |
| Byte | Varbinary |
| BigDecimal | Decimale |
| ARRAY | List |
## Conversioni dei tipi di dati
Oltre alle conversioni da JDBC a Arrow, il connettore esegue alcune altre conversioni per rendere compatibili l'origine SAP HANA e i tipi di dati Athena. Queste conversioni contribuiscono a garantire che le query vengano eseguite in modo corretto. Nella tabella seguente vengono illustrate queste conversioni.
****
| Tipo di dati di origine (SAP HANA) | Tipo di dati convertito (Athena) |
| --- | --- |
| DECIMAL | BIGINT |
| INTEGER | INT |
| DATE | DATEDAY |
| TIMESTAMP | DATEMILLI |
Tutti gli altri tipi di dati non supportati vengono convertiti in `VARCHAR`.
## Partizioni e suddivisioni
Una partizione è rappresentata da una singola colonna di partizione di tipo `Integer`. La colonna contiene i nomi delle partizioni definite in una tabella SAP HANA. Se una tabella non ha nomi di partizione, viene restituito \$1, che equivale a una singola partizione. Una partizione equivale a una suddivisione.
****
| Name | Tipo | Description |
| --- | --- | --- |
| PART\$1ID | Numero intero | Partizione denominata in SAP HANA. |
## Performance
SAP HANA supporta le partizioni native. Il connettore SAP HANA di Athena può recuperare dati da queste partizioni in parallelo. Se desideri interrogare set di dati molto grandi con una distribuzione uniforme delle partizioni, ti consigliamo vivamente il partizionamento nativo. La selezione di un sottoinsieme di colonne velocizza notevolmente il runtime delle query e riduce i dati scansionati. Il connettore presenta una significativa limitazione della larghezza di banda della rete e talvolta errori di query dovuti alla simultaneità.
Il connettore Athena SAP HANA esegue il pushdown dei predicati per ridurre i dati scansionati dalla query. Le clausole `LIMIT`, i predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati analizzati e per ridurre il tempo di esecuzione delle query.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Athena SAP HANA può combinare queste espressioni e inviarle direttamente a SAP HANA per migliorare le funzionalità e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena SAP HANA supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
## Query passthrough
[Il connettore SAP HANA supporta le query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con SAP HANA, puoi utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in SAP HANA. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-saphana/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-saphana/LICENSE.txt) su .com. GitHub
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-saphana/pom.xml) per il connettore SAP HANA su .com. GitHub
Per ulteriori informazioni su questo connettore, visita [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-saphana) su .com. GitHub
# Connettore Amazon Athena per Snowflake
Il connettore Amazon Athena per [Snowflake](https://www.snowflake.com/) consente ad Amazon Athena di eseguire query SQL sui dati archiviati nei database SQL Snowflake o sulle istanze RDS utilizzando JDBC.
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
Implementa il connettore sul tuo Account AWS utilizzando la console Athena o `CreateDataCatalog` l'operazione API. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Solo le connessioni legacy supportano la configurazione del multiplexer.
+ Al momento, le viste di Snowflake non sono supportate.
+ In Snowflake, i nomi degli oggetti fanno distinzione tra maiuscole e minuscole. Athena accetta una combinazione di maiuscole e [minuscole](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html#table-names-and-table-column-names-in-ate-must-be-lowercase) nelle query DDL e DML, ma per impostazione predefinita i nomi degli oggetti quando esegue la query. Il connettore Snowflake supporta solo lettere minuscole quando si utilizza Glue Catalog/Lake Formation. Quando viene utilizzato il catalogo Athena, i clienti possono controllare il comportamento del case utilizzando la variabile di ambiente `casing_mode` Lambda i cui valori possibili sono elencati nella [Parameters](#connectors-snowflake-parameters) sezione (ad esempio,). `key=casing_mode, value = CASE_INSENSITIVE_SEARCH`
## Termini
I seguenti termini si riferiscono al connettore Snowflake.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizzate i parametri di questa sezione per configurare il connettore Snowflake.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Snowflake utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore Snowflake Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type SNOWFLAKE
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **NESSUNA** — Non modificate le maiuscole e minuscole dello schema e dei nomi delle tabelle specificati (eseguite la query su Snowflake così com'è). Questo è il valore predefinito quando **casing\$1mode** non è specificato.
+ **UPPER** — Tutti i nomi di schemi e tabelle indicati nella query prima di eseguirla su Snowflake.
+ **MINUSCOLO**: tutti i nomi di schemi e tabelle indicati nella query prima di eseguirla su Snowflake.
+ **CASE\$1INSENSITIVE\$1SEARCH — Esegue ricerche** senza distinzione tra maiuscole e minuscole nei nomi di schemi e tabelle in Snowflake. Ad esempio, puoi utilizzare questa modalità quando hai una query del tipo e Snowflake contiene una tabella chiamata. `SELECT * FROM EMPLOYEE` `Employee` Tuttavia, in presenza di conflitti tra nomi, ad esempio se viene chiamata una tabella `EMPLOYEE` e un'altra tabella `Employee` in Snowflake, la query avrà esito negativo.
**Nota**
Il connettore Snowflake creato utilizzando le connessioni Glue non supporta l’uso di un gestore di multiplazione.
Il connettore Snowflake creato utilizzando le connessioni Glue supporta `ConnectionSchemaVersion` solo 2.
**Memorizzazione delle credenziali**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali. Per ulteriori informazioni, consulta [Autenticare con Snowflake](connectors-snowflake-authentication.md).
### Connessioni legacy
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
**Proprietà dell’ambiente**
+ **default**: la stringa di connessione JDBC da utilizzare per connettersi all’istanza del database Snowflake. Ad esempio, `snowflake://${jdbc_connection_string}`
+ **catalog\$1connection\$1string**: utilizzata dal gestore multiplexing (non supportata quando si utilizza una connessione Glue). Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato con Athena è mysnowflakecatalog, il nome della variabile di ambiente è mysnowflakecatalog\$1connection\$1string.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **NESSUNO** — Non modifica le maiuscole e minuscole dello schema e dei nomi delle tabelle specificati (esegui la query così com'è su Snowflake). Questo è il valore predefinito quando **casing\$1mode** non è specificato.
+ **UPPER** — Tutti i nomi di schemi e tabelle indicati nella query prima di eseguirla su Snowflake.
+ **MINUSCOLO**: tutti i nomi di schemi e tabelle indicati nella query prima di eseguirla su Snowflake.
+ **CASE\$1INSENSITIVE\$1SEARCH — Esegue ricerche** senza distinzione tra maiuscole e minuscole nei nomi di schemi e tabelle in Snowflake. Ad esempio, puoi utilizzare questa modalità quando hai una query del tipo e Snowflake contiene una tabella chiamata. `SELECT * FROM EMPLOYEE` `Employee` Tuttavia, in presenza di conflitti tra nomi, ad esempio se viene chiamata una tabella `EMPLOYEE` e un'altra tabella `Employee` in Snowflake, la query avrà esito negativo.
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
snowflake://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | SnowflakeMuxCompositeHandler |
| Gestore dei metadati | SnowflakeMuxMetadataHandler |
| Gestore dei record | SnowflakeMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mysnowflakecatalog, il nome della variabile di ambiente è mysnowflakecatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Snowflake MUX che supporta due istanze del database: `snowflake1` (il valore predefinito) e `snowflake2`.
****
| Proprietà | Valore |
| --- | --- |
| default | snowflake://jdbc:snowflake://snowflake1.host:port/?warehouse=warehousename&db=db1&schema=schema1&\$1\$1Test/RDS/Snowflake1\$1 |
| snowflake\$1catalog1\$1connection\$1string | snowflake://jdbc:snowflake://snowflake1.host:port/?warehouse=warehousename&db=db1&schema=schema1\$1\$1Test/RDS/Snowflake1\$1 |
| snowflake\$1catalog2\$1connection\$1string | snowflake://jdbc:snowflake://snowflake2.host:port/?warehouse=warehousename&db=db1&schema=schema1&user=sample2&password=sample2 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/RDS/Snowflake1}`.
```
snowflake://jdbc:snowflake://snowflake1.host:port/?warehouse=warehousename&db=db1&schema=schema1${Test/RDS/Snowflake1}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
snowflake://jdbc:snowflake://snowflake1.host:port/warehouse=warehousename&db=db1&schema=schema1&user=sample2&password=sample2&...
```
Attualmente, Snowflake riconosce le proprietà JDBC `user` e `password`. Accetta anche il nome utente e la password nel formato *username* `/` *password* senza le chiavi `user` o. `password`
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Snowflake.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | SnowflakeCompositeHandler |
| Gestore dei metadati | SnowflakeMetadataHandler |
| Gestore dei record | SnowflakeRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Snowflake supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | snowflake://jdbc:snowflake://snowflake1.host:port/?secret=Test/RDS/Snowflake1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC e Apache Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Numero intero | Tiny |
| Breve | Smallint |
| Numero intero | Int |
| Long | Bigint |
| virgola mobile | Float4 |
| Double | Float8 |
| Data | DateDay |
| Time stamp | DateMilli |
| Stringa | Varchar |
| Byte | Varbinary |
| BigDecimal | Decimale |
| ARRAY | List |
## Conversioni dei tipi di dati
Oltre alle conversioni da JDBC ad Arrow, il connettore esegue alcune altre conversioni per rendere compatibili l'origine Snowflake e i tipi di dati Athena. Queste conversioni contribuiscono a garantire che le query vengano eseguite in modo corretto. Nella tabella seguente vengono illustrate queste conversioni.
****
| Tipo di dati di origine (Snowflake) | Tipo di dati convertito (Athena) |
| --- | --- |
| TIMESTAMP | TIMESTAMPMILLI |
| DATE | TIMESTAMPMILLI |
| INTEGER | INT |
| DECIMAL | BIGINT |
| TIMESTAMP\$1NTZ | TIMESTAMPMILLI |
Tutti gli altri tipi di dati non supportati vengono convertiti in `VARCHAR`.
## Partizioni e suddivisioni
Le partizioni vengono utilizzate per determinare come generare suddivisioni per il connettore. Athena costruisce una colonna sintetica di tipo `varchar` che rappresenta lo schema di partizionamento della tabella per aiutare il connettore a generare suddivisioni. Il connettore non modifica la definizione effettiva della tabella.
Per creare questa colonna sintetica e le partizioni, Athena richiede la definizione di una chiave primaria. Tuttavia, poiché Snowflake non impone vincoli relativi alla chiave primaria, è necessario imporre l’unicità autonomamente. In caso contrario, Athena passerà automaticamente a una singola divisione.
## Performance
Per assicurare prestazioni ottimali, utilizza i filtri nelle query ogniqualvolta possibile. Inoltre, consigliamo vivamente di utilizzare il partizionamento nativo per recuperare set di dati di grandissime dimensioni con una distribuzione uniforme delle partizioni. La selezione di un sottoinsieme di colonne velocizza notevolmente il runtime delle query e riduce i dati scansionati. Il connettore Snowflake è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
Il connettore Athena Snowflake esegue il pushdown dei predicati per ridurre i dati scansionati dalla query. Le clausole `LIMIT`, i predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati scansionati e per ridurre il tempo di esecuzione delle query.
### Clausole LIMIT
Una dichiarazione `LIMIT N` riduce la quantità di dati analizzati dalla query. Con il pushdown `LIMIT N`, il connettore restituisce solo le righe `N` ad Athena.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Snowflake di Athena può combinare queste espressioni e inviarle direttamente a Snowflake per migliorare le funzionalità e ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena Snowflake supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%')
LIMIT 10;
```
# Autenticare con Snowflake
Puoi configurare il connettore Amazon Athena Snowflake per utilizzare l'autenticazione a coppia di chiavi o il metodo di autenticazione per connetterti al tuo data OAuth warehouse Snowflake. Entrambi i metodi forniscono un accesso sicuro a Snowflake ed eliminano la necessità di memorizzare le password nelle stringhe di connessione.
+ **Autenticazione con coppia di chiavi**: questo metodo utilizza coppie di chiavi pubbliche o private RSA per l’autenticazione con Snowflake. La chiave privata firma digitalmente le richieste di autenticazione mentre la chiave pubblica corrispondente viene registrata in Snowflake per la verifica. Questo metodo elimina la necessità di memorizzare le password.
+ **OAuth autenticazione**: questo metodo utilizza il token di autorizzazione e il token di aggiornamento per l'autenticazione con Snowflake. Supporta l’aggiornamento automatico dei token, rendendolo adatto per applicazioni a lunga durata.
Per ulteriori informazioni, consulta l'autenticazione e l'[autenticazione a coppie di chiavi](https://docs.snowflake.com/en/user-guide/key-pair-auth) nella guida per l'utente di [OAuth Snowflake](https://docs.snowflake.com/en/user-guide/oauth-custom).
## Prerequisiti
Prima di iniziare, completa i seguenti prerequisiti:
+ Accesso all’account Snowflake con privilegi amministrativi.
+ Account utente Snowflake dedicato al connettore Athena.
+ OpenSSL o strumenti equivalenti per la generazione di chiavi per l’autenticazione a coppie di chiavi.
+ Gestione dei segreti AWS accesso per creare e gestire segreti.
+ Browser Web per completare il OAuth flusso di OAuth autenticazione.
## Configurare l’autenticazione tramite coppia di chiavi
Questo processo prevede la generazione di una coppia di chiavi RSA, la configurazione dell’account Snowflake con la chiave pubblica e l’archiviazione sicura della chiave privata in Gestione dei segreti AWS. I seguenti passaggi ti guideranno nella creazione delle chiavi crittografiche, nell'impostazione delle autorizzazioni Snowflake necessarie e nella configurazione AWS delle credenziali per un'autenticazione senza interruzioni.
1. **Generare una coppia di chiavi RSA**
Generare una coppia di chiavi privata e pubblica usando OpenSSL.
+ Per generare una versione non crittografata, usare il seguente comando nell’applicazione a riga di comando locale.
```
openssl genrsa 2048 | openssl pkcs8 -topk8 -inform PEM -out rsa_key.p8 -nocrypt
```
+ Per generare una versione crittografata, utilizzare il seguente comando, che omette `-nocrypt`.
```
openssl genrsa 2048 | openssl pkcs8 -topk8 -v2 des3 -inform PEM -out rsa_key.p8
```
+ Per generare una chiave pubblica da una chiave privata.
```
openssl rsa -in rsa_key.p8 -pubout -out rsa_key.pub
# Set appropriate permissions (Unix/Linux)
chmod 600 rsa_key.p8
chmod 644 rsa_key.pub
```
**Nota**
Si raccomanda di non condividere la propria chiave privata. La chiave privata deve essere accessibile solo all’applicazione che deve autenticarsi con Snowflake.
1. **Estrarre il contenuto della chiave pubblica senza delimitatori per Snowflake**
```
# Extract public key content (remove BEGIN/END lines and newlines)
cat rsa_key.pub | grep -v "BEGIN\|END" | tr -d '\n'
```
Salvare l’output poiché sarà necessario nella fase successiva.
1. **Configurare l’utente Snowflake**
Per configurare un account utente Snowflake, seguire la procedura illustrata qui.
1. Creare un utente dedicato per il connettore Athena se non esiste già.
```
-- Create user for Athena connector
CREATE USER athena_connector_user;
-- Grant necessary privileges
GRANT USAGE ON WAREHOUSE your_warehouse TO ROLE athena_connector_role;
GRANT USAGE ON DATABASE your_database TO ROLE athena_connector_role;
GRANT SELECT ON ALL TABLES IN DATABASE your_database TO ROLE athena_connector_role;
```
1. Concedere i privilegi di autenticazione. Per assegnare una chiave pubblica a un utente, è necessario disporre di uno dei seguenti ruoli o privilegi.
+ Il privilegio `MODIFY PROGRAMMATIC AUTHENTICATION METHODS` o `OWNERSHIP` sull’utente.
+ Il ruolo `SECURITYADMIN` o il livello superiore.
Concedere i privilegi necessari per l’assegnazione delle chiavi pubbliche tramite il seguente comando.
```
GRANT MODIFY PROGRAMMATIC AUTHENTICATION METHODS ON USER athena_connector_user TO ROLE your_admin_role;
```
1. Assegnare la chiave pubblica all’account utente Snowflake con il seguente comando.
```
ALTER USER athena_connector_user SET RSA_PUBLIC_KEY='RSAkey';
```
Verificare che la chiave pubblica sia stata assegnata correttamente all’utente con il seguente comando.
```
DESC USER athena_connector_user;
```
1. **Memorizza la chiave privata in Gestione dei segreti AWS**
1. Convertire la chiave privata nel formato richiesto dal connettore.
```
# Read private key content
cat rsa_key.p8
```
1. Crea un account segreto Gestione dei segreti AWS con la seguente struttura.
```
{
"sfUser": "your_snowflake_user",
"pem_private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----",
"pem_private_key_passphrase": "passphrase_in_case_of_encrypted_private_key(optional)"
}
```
**Nota**
L’intestazione e il piè di pagina sono opzionali.
La chiave privata deve essere separata da `\n`.
## Configura OAuth l'autenticazione
Questo metodo di autenticazione consente un accesso a Snowflake sicuro e basato su token, con funzionalità di aggiornamento automatico delle credenziali. Il processo di configurazione prevede la creazione di un'integrazione di sicurezza in Snowflake, il recupero delle credenziali OAuth del client, il completamento del flusso di autorizzazione per ottenere un codice di accesso e l'archiviazione delle OAuth credenziali da utilizzare nel Gestione dei segreti AWS connettore.
1. **Creare un'integrazione di sicurezza in Snowflake**
Esegui il seguente comando SQL in Snowflake per creare un'integrazione di sicurezza Snowflake. OAuth
```
CREATE SECURITY INTEGRATION my_snowflake_oauth_integration_a
TYPE = OAUTH
ENABLED = TRUE
OAUTH_CLIENT = CUSTOM
OAUTH_CLIENT_TYPE = 'CONFIDENTIAL'
OAUTH_REDIRECT_URI = 'https://localhost:8080/oauth/callback'
OAUTH_ISSUE_REFRESH_TOKENS = TRUE
OAUTH_REFRESH_TOKEN_VALIDITY = 7776000;
```
**Parametri di configurazione**
+ `TYPE = OAUTH`— specifica il tipo di OAuth autenticazione.
+ `ENABLED = TRUE`: abilita l’integrazione della sicurezza.
+ `OAUTH_CLIENT = CUSTOM`— Utilizza una configurazione OAuth client personalizzata.
+ `OAUTH_CLIENT_TYPE = 'CONFIDENTIAL'`: impostare il tipo di client per applicazioni sicure.
+ `OAUTH_REDIRECT_URI`— L'URL di callback per OAuth flow. Può essere localhost per i test.
+ `OAUTH_ISSUE_REFRESH_TOKENS = TRUE`: abilita la generazione di token di aggiornamento.
+ `OAUTH_REFRESH_TOKEN_VALIDITY = 7776000`: imposta la validità del token di aggiornamento (90 giorni in secondi).
1. **Recupera i segreti OAuth del cliente**
1. Eseguire il seguente comando, per ottenere queste credenziali.
```
DESC SECURITY INTEGRATION 'MY_SNOWFLAKE_OAUTH_INTEGRATION_A';
```
1. Recupera i segreti del OAuth cliente.
```
SELECT SYSTEM$SHOW_OAUTH_CLIENT_SECRETS('MY_SNOWFLAKE_OAUTH_INTEGRATION_A');
```
**Esempio di risposta**
```
{
"OAUTH_CLIENT_SECRET_2": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"OAUTH_CLIENT_SECRET": "je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY,
"OAUTH_CLIENT_ID": "AIDACKCEVSQ6C2EXAMPLE"
}
```
**Nota**
Mantenere queste credenziali al sicuro e non condividerle. Questi verranno utilizzati per configurare il OAuth client.
1. **Autorizzare l’utente e recuperare il codice di autorizzazione**
1. Aprire il seguente URL in un browser.
```
https://.snowflakecomputing.com/oauth/authorize?client_id=&response_type=code&redirect_uri=https://localhost:8080/oauth/callback
```
1. Completare il flusso di autorizzazione.
1. Accedere usando le credenziali Snowflake.
1. Concedere le autorizzazioni richieste. Si verrà reindirizzati all’URI di callback con un codice di autorizzazione.
1. Estrarre il codice di autorizzazione copiando il parametro code dall’URL di reindirizzamento.
```
https://localhost:8080/oauth/callback?code=
```
**Nota**
Il codice di autorizzazione è valido per un periodo di tempo limitato e può essere utilizzato una sola volta.
1. **Memorizza OAuth le credenziali in Gestione dei segreti AWS**
Crea un account segreto Gestione dei segreti AWS con la seguente struttura.
```
{
"redirect_uri": "https://localhost:8080/oauth/callback",
"client_secret": "je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY",
"token_url": "https://.snowflakecomputing.com/oauth/token-request",
"client_id": "AIDACKCEVSQ6C2EXAMPLE,
"username": "your_snowflake_username",
"auth_code": "authorizationcode"
}
```
**Campi obbligatori**
+ `redirect_uri`— URI di OAuth reindirizzamento ottenuto dal passaggio 1.
+ `client_secret`— segreto OAuth del cliente ottenuto dalla Fase 2.
+ `token_url`— Snowflake L'endpoint del OAuth token.
+ `client_id`— L'ID OAuth client del passaggio 2.
+ `username`: il nome utente Snowflake per il connettore.
+ `auth_code`: il codice di autorizzazione che ottenuto al passaggio 3.
Dopo aver creato un segreto, si ottiene un ARN segreto che è possibile usare nella propria connessione Glue quando si [crea una connessione a un’origine dati](connect-to-a-data-source.md).
## Query passthrough
[Il connettore Snowflake supporta le query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Snowflake, puoi utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in Snowflake. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-snowflake/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-snowflake/LICENSE.txt) su .com. GitHub
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consulta il file [pom.xml per il connettore](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-snowflake/pom.xml) Snowflake su .com. GitHub
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-snowflake) su .com. GitHub
# Connettore Amazon Athena per Microsoft SQL Server
Il connettore Amazon Athena per [Microsoft SQL Server](https://docs.microsoft.com/en-us/sql/?view=sql-server-ver15) consente ad Amazon Athena di eseguire query SQL sui dati archiviati in Microsoft SQL Server utilizzando JDBC.
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Nelle condizioni di filtro, è necessario impostare i tipi di dati `Date` e `Timestamp` sul tipo di dati appropriato.
+ Per cercare valori negativi del tipo `Real` e `Float`, utilizza l'operatore `<=` o `>=`.
+ I tipi di dati `binary`, `varbinary`, `image` e `rowversion` non sono supportati.
## Termini
I seguenti termini si riferiscono al connettore SQL Server.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizza i parametri in questa sezione per configurare il connettore SQL Server.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore SQL Server utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore SQL Server Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type SQLSERVER
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore SQL Server creato utilizzando le connessioni Glue non supporta l’uso di un gestore di multiplexing.
Il connettore SQL Server creato utilizzando le connessioni Glue supporta solo `ConnectionSchemaVersion` 2.
### Connessioni legacy
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
sqlserver://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | SqlServerMuxCompositeHandler |
| Gestore dei metadati | SqlServerMuxMetadataHandler |
| Gestore dei record | SqlServerMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è mysqlservercatalog, il nome della variabile di ambiente è mysqlservercatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME\$1. |
Le seguenti proprietà di esempio riguardano una funzione Lambda SqlServer MUX che supporta due istanze di database`sqlserver1`: (impostazione predefinita) e. `sqlserver2`
****
| Proprietà | Valore |
| --- | --- |
| default | sqlserver://jdbc:sqlserver://sqlserver1.hostname:port;databaseName=;\$1\$1secret1\$1name\$1 |
| sqlserver\$1catalog1\$1connection\$1string | sqlserver://jdbc:sqlserver://sqlserver1.hostname:port;databaseName=;\$1\$1secret1\$1name\$1 |
| sqlserver\$1catalog2\$1connection\$1string | sqlserver://jdbc:sqlserver://sqlserver2.hostname:port;databaseName=;\$1\$1secret2\$1name\$1 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti hardcoded in Gestione dei segreti AWS, consultate [Move hardcoded](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) secret in nella Guida per l'utente. Gestione dei segreti AWSGestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${secret_name}`.
```
sqlserver://jdbc:sqlserver://hostname:port;databaseName=;${secret_name}
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
sqlserver://jdbc:sqlserver://hostname:port;databaseName=;user=;password=
```
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza SQL Server.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | SqlServerCompositeHandler |
| Gestore dei metadati | SqlServerMetadataHandler |
| Gestore dei record | SqlServerRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza SQL Server supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | sqlserver://jdbc:sqlserver://hostname:port;databaseName=;\$1\$1secret\$1name\$1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per SQL Server e Apache Arrow.
****
| SQL Server | Arrow |
| --- | --- |
| bit | TINYINT |
| tinyint | SMALLINT |
| smallint | SMALLINT |
| int | INT |
| bigint | BIGINT |
| decimal | DECIMAL |
| numeric | FLOAT8 |
| smallmoney | FLOAT8 |
| money | DECIMAL |
| float[24] | FLOAT4 |
| float[53] | FLOAT8 |
| real | FLOAT4 |
| datetime | Date(MILLISECOND) |
| datetime2 | Date(MILLISECOND) |
| smalldatetime | Date(MILLISECOND) |
| data | Date(DAY) |
| time | VARCHAR |
| datetimeoffset | Date(MILLISECOND) |
| char[n] | VARCHAR |
| varchar[n/max] | VARCHAR |
| nchar[n] | VARCHAR |
| nvarchar[n/max] | VARCHAR |
| testo | VARCHAR |
| ntext | VARCHAR |
## Partizioni e suddivisioni
Una partizione è rappresentata da una singola colonna di partizione di tipo `varchar`. Nel caso del connettore SQL Server, una funzione di partizione determina il modo in cui le partizioni vengono applicate alla tabella. Le informazioni sulla funzione e sul nome della colonna di partizione vengono recuperate dalla tabella dei metadati di SQL Server. La partizione viene quindi recuperata con una query personalizzata. Le suddivisioni vengono create in base al numero di partizioni distinte ricevute.
## Performance
La selezione di un sottoinsieme di colonne velocizza notevolmente il runtime delle query e riduce i dati scansionati. Il connettore SQL Server è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
Il connettore Athena SQL Server esegue il pushdown del predicato per ridurre la quantità di dati scansionati dalla query. I predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati scansionati e ridurre il tempo di esecuzione delle query.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Athena SQL Server può combinare queste espressioni e inviarle direttamente a SQL Server per migliorare le funzionalità e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore SQL Server di Athena supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, IS\$1DISTINCT\$1FROM, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Query passthrough
Il connettore SQL Server supporta [le query passthrough](federated-query-passthrough.md). Le query passthrough utilizzano una funzione di tabella per inviare la query completa all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con SQL Server, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in SQL Server. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-sqlserver/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-sqlserver/LICENSE.txt) su GitHub .com.
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, vedere il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-sqlserver/pom.xml) per il connettore SQL Server all'indirizzo .com. GitHub
Per ulteriori informazioni su questo connettore, visita [il sito corrispondente su GitHub .com](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-sqlserver).
# Connettore Amazon Athena per Teradata
Il connettore Amazon Athena per Teradata consente ad Amazon Athena di eseguire query SQL sui dati archiviati nei database Teradata.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Limitazioni
+ Le operazioni di scrittura DDL non sono supportate.
+ In una configurazione multiplex, il bucket di spill e il prefisso sono condivisi tra tutte le istanze del database.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
## Termini
I seguenti termini si riferiscono al connettore Teradata.
+ **Istanza del database**: qualsiasi istanza del database distribuita on-premise, su Amazon EC2 o su Amazon RDS.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
+ **Gestore multiplex**: un gestore Lambda in grado di accettare e utilizzare più connessioni al database.
## Parameters
Utilizzate i parametri di questa sezione per configurare il connettore Teradata.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Teradata utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore Teradata Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type TERADATA
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Teradata creato utilizzando le connessioni Glue non supporta l’uso di un gestore di multiplazione.
Il connettore Teradata creato utilizzando le connessioni Glue supporta `ConnectionSchemaVersion` solo 2.
### Connessioni legacy
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
teradata://${jdbc_connection_string}
```
#### Utilizzo di un gestore multiplex
Puoi utilizzare un gestore multiplex per connetterti a più istanze del database con una singola funzione Lambda. Le richieste vengono indirizzate in base al nome del catalogo. Utilizza le seguenti classi in Lambda.
****
| Gestore | Classe |
| --- | --- |
| Gestore composito | TeradataMuxCompositeHandler |
| Gestore dei metadati | TeradataMuxMetadataHandler |
| Gestore dei record | TeradataMuxRecordHandler |
##### Parametri del gestore multiplex
****
| Parametro | Description |
| --- | --- |
| \$1catalog\$1connection\$1string | Obbligatorio. Una stringa di connessione di un'istanza del database. Appone alla variabile di ambiente un prefisso con il nome del catalogo utilizzato in Athena. Ad esempio, se il catalogo registrato presso Athena è myteradatacatalog, il nome della variabile di ambiente è myteradatacatalog\$1connection\$1string. |
| default | Obbligatorio. La stringa di connessione predefinita. Questa stringa viene utilizzata quando il catalogo è. lambda:\$1\$1 AWS\$1LAMBDA\$1FUNCTION\$1NAME \$1 |
Le seguenti proprietà di esempio si riferiscono a una funzione Lambda Teradata MUX che supporta due istanze del database: `teradata1` (il valore predefinito) e `teradata2`.
****
| Proprietà | Valore |
| --- | --- |
| default | teradata://jdbc:teradata://teradata2.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,user=sample2&password=sample2 |
| teradata\$1catalog1\$1connection\$1string | teradata://jdbc:teradata://teradata1.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,\$1\$1Test/RDS/Teradata1\$1 |
| teradata\$1catalog2\$1connection\$1string | teradata://jdbc:teradata://teradata2.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,user=sample2&password=sample2 |
##### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati Gestione dei segreti AWS nella Guida per l'](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html)utente.Gestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nome del segreto**
La stringa seguente ha il nome del segreto `${Test/RDS/Teradata1}`.
```
teradata://jdbc:teradata1.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,${Test/RDS/Teradata1}&...
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
teradata://jdbc:teradata://teradata1.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,...&user=sample2&password=sample2&...
```
Attualmente, Teradata riconosce le proprietà JDBC `user` e `password`. Accetta anche il nome utente e la password nel formato *username* `/` *password* senza le chiavi `user` o. `password`
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Teradata.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | TeradataCompositeHandler |
| Gestore dei metadati | TeradataMetadataHandler |
| Gestore dei record | TeradataRecordHandler |
##### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
La seguente proprietà di esempio si riferisce a una singola istanza Teradata supportata da una funzione Lambda.
****
| Proprietà | Valore |
| --- | --- |
| default | teradata://jdbc:teradata://teradata1.host/TMODE=ANSI,CHARSET=UTF8,DATABASE=TEST,secret=Test/RDS/Teradata1 |
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati corrispondenti per JDBC e Apache Arrow.
****
| JDBC | Arrow |
| --- | --- |
| Booleano | Bit |
| Numero intero | Tiny |
| Breve | Smallint |
| Numero intero | Int |
| Long | Bigint |
| virgola mobile | Float4 |
| Double | Float8 |
| Data | DateDay |
| Time stamp | DateMilli |
| Stringa | Varchar |
| Byte | Varbinary |
| BigDecimal | Decimale |
| ARRAY | List |
## Partizioni e suddivisioni
Una partizione è rappresentata da una singola colonna di partizione di tipo `Integer`. La colonna contiene i nomi delle partizioni definite in una tabella Teradata. Se una tabella non ha nomi di partizione, viene restituito \$1, che equivale a una singola partizione. Una partizione equivale a una suddivisione.
****
| Name | Tipo | Description |
| --- | --- | --- |
| partition | Numero intero | Partizione denominata in Teradata. |
## Performance
Teradata supporta le partizioni native. Il connettore Teradata di Athena può recuperare dati da queste partizioni in parallelo. Se desideri interrogare set di dati molto grandi con una distribuzione uniforme delle partizioni, ti consigliamo vivamente il partizionamento nativo. La selezione di un sottoinsieme di colonne rallenta notevolmente l'esecuzione delle query. Il connettore mostra alcune limitazioni della larghezza di banda della rete dovute alla simultaneità.
Il connettore Athena Teradata esegue il pushdown del predicato per ridurre la quantità di dati scansionati dalla query. I predicati semplici e le espressioni complesse vengono inviati al connettore per ridurre la quantità di dati scansionati e ridurre il tempo di esecuzione delle query.
### Predicati
Un predicato è un'espressione nella clausola `WHERE` di una query SQL che valuta a un valore booleano e filtra le righe in base a più condizioni. Il connettore Teradata di Athena può combinare queste espressioni e inviarle direttamente a Teradata per funzionalità avanzate e per ridurre la quantità di dati scansionati.
I seguenti operatori del connettore Athena Teradata supportano il pushdown dei predicati:
+ **Booleano: **AND, OR, NOT
+ **Uguaglianza: **EQUAL, NOT\$1EQUAL, LESS\$1THAN, LESS\$1THAN\$1OR\$1EQUAL, GREATER\$1THAN, GREATER\$1THAN\$1OR\$1EQUAL, NULL\$1IF, IS\$1NULL
+ **Aritmetica: **ADD, SUBTRACT, MULTIPLY, DIVIDE, MODULUS, NEGATE
+ **Altro: **LIKE\$1PATTERN, IN
### Esempio di pushdown combinato
Per le funzionalità di esecuzione di query avanzate, combina i tipi di pushdown, come nell'esempio seguente:
```
SELECT *
FROM my_table
WHERE col_a > 10
AND ((col_a + col_b) > (col_c % col_d))
AND (col_e IN ('val1', 'val2', 'val3') OR col_f LIKE '%pattern%');
```
## Query passthrough
[Il connettore Teradata supporta le query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Teradata, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un’origine dati in Teradata. La query seleziona tutte le colonne della tabella `customer`.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer'
))
```
## Informazioni sulla licenza
[Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-teradata/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file LICENSE.txt su .com.](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-teradata/LICENSE.txt) GitHub
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consultate il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-teradata/pom.xml) per il connettore Teradata su .com. GitHub
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-teradata) su .com. GitHub
# Connettore Amazon Athena Timestream
Il connettore Amazon Athena per Timestream consente ad Amazon Athena di comunicare con [Amazon Timestream](https://aws.amazon.com/timestream/), rendendo i dati di serie temporali accessibili mediante Amazon Athena. Facoltativamente, puoi utilizzarlo AWS Glue Data Catalog come fonte di metadati supplementari.
Amazon Timestream è un database di serie temporali veloce, scalabile, completamente gestito e appositamente costruito che semplifica l'archiviazione e l'analisi giornaliera di trilioni di punti dati delle serie temporali. Timestream consente di risparmiare tempo e denaro nella gestione del ciclo di vita dei dati di serie temporali mantenendo i dati recenti in memoria e spostando i dati cronologici su un livello di archiviazione ottimizzato in base a policy definite dall'utente.
Questo connettore può essere registrato con Catalogo Dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
Se hai abilitato Lake Formation nel tuo account, il ruolo IAM per il tuo connettore Lambda federato Athena che hai distribuito nell'accesso in lettura deve avere accesso in lettura in AWS Serverless Application Repository Lake Formation a. AWS Glue Data Catalog
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Parameters
Usa i parametri in questa sezione per configurare il connettore Timestream.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Timestream utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore Timestream Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type TIMESTREAM
```
**Proprietà dell’ambiente Lambda**
**glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Timestream creato utilizzando le connessioni Glue non supporta l’uso di un gestore di multiplazione.
Il connettore Timestream creato utilizzando le connessioni Glue supporta `ConnectionSchemaVersion` solo 2.
### Connessioni legacy
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati senza una connessione Glue associata. Utilizza i seguenti parametri solo quando [implementi manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena o quando la proprietà dell’ambiente `glue_connection` non è specificata.
**Proprietà dell’ambiente**
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
+ **glue\$1catalog**: (facoltativo) utilizza questa opzione per specificare un [catalogo AWS Glue multi-account](data-sources-glue-cross-account.md). Per impostazione predefinita, il connettore tenta di ottenere metadati dal proprio account. AWS Glue
## Configurazione di database e tabelle in AWS Glue
Facoltativamente, puoi utilizzarli AWS Glue Data Catalog come fonte di metadati supplementari. Per abilitare una AWS Glue tabella da utilizzare con Timestream, è necessario disporre di un database e di una tabella con nomi che corrispondano al AWS Glue database e alla tabella Timestream per i quali si desidera fornire metadati supplementari.
**Nota**
Per prestazioni ottimali, utilizza solo lettere minuscole per i nomi dei database e delle tabelle. L'utilizzo di caratteri misti tra maiuscole e minuscole fa sì che il connettore esegua una ricerca senza distinzione tra maiuscole e minuscole, più impegnativa dal punto di vista computazionale.
Per configurare la AWS Glue tabella da utilizzare con Timestream, è necessario impostarne le proprietà in. AWS Glue
**Per utilizzare una AWS Glue tabella per metadati supplementari**
1. Modifica la tabella nella AWS Glue console per aggiungere le seguenti proprietà della tabella:
+ **timestream-metadata-flag**— Questa proprietà indica al connettore Timestream che il connettore può utilizzare la tabella per metadati supplementari. Puoi fornire qualsiasi valore per `timestream-metadata-flag`, purché la proprietà `timestream-metadata-flag` sia presente nell'elenco delle proprietà della tabella.
+ **\$1view\$1template**: quando utilizzi AWS Glue per i metadati supplementari, puoi utilizzare questa proprietà della tabella e specificare qualsiasi SQL Timestream come visualizzazione. Il connettore Timestream per Athena utilizza il codice SQL della visualizzazione insieme al codice SQL di Athena per eseguire la query. È utile se desideri utilizzare una funzionalità di Timestream SQL altrimenti non disponibile in Athena.
1. Assicurati di utilizzare i tipi di dati appropriati elencati in questo AWS Glue documento.
### Tipi di dati
Attualmente, il connettore Timestream supporta solo un sottoinsieme dei tipi di dati disponibili in Timestream, in particolare i valori scalari `varchar`, `double` e `timestamp`.
Per interrogare il tipo di dati `timeseries`, devi configurare una visualizzazione nelle proprietà delle tabelle AWS Glue che utilizza la funzione di Timestream `CREATE_TIME_SERIES`. Inoltre, per la visualizzazione devi fornire uno schema che utilizzi la sintassi `ARRAY>` come tipo per qualsiasi colonna delle tue serie temporali. Assicurati di sostituire `double` con il tipo scalare appropriato per la tabella.
L'immagine seguente mostra un esempio di proprietà della AWS Glue tabella configurate per impostare una visualizzazione su una serie temporale.
![\[Configurazione delle proprietà della tabella in AWS Glue per impostare una visualizzazione su una serie temporale.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-timestream-1.png)
## Autorizzazioni richieste
Consulta la sezione `Policies` del file [athena-timestream.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-timestream/athena-timestream.yaml) per i dettagli completi delle policy IAM richieste da questo connettore. L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
+ **AWS Glue Data Catalog**— Il connettore Timestream richiede l'accesso in sola lettura a per ottenere informazioni sullo schema. AWS Glue Data Catalog
+ **CloudWatch Registri**: il connettore richiede l'accesso ai CloudWatch registri per l'archiviazione dei registri.
+ **Accesso a Timestream**: per eseguire query su Timestream.
## Performance
Ti consigliamo di utilizzare la clausola `LIMIT` per limitare i dati restituiti (non i dati scansionati) a meno di 256 MB per garantire l'efficienza delle query interattive.
Il connettore Athena Timestream esegue il pushdown dei predicati per ridurre i dati analizzati dalla query. `LIMIT`le clausole riducono la quantità di dati scansionati, ma se non fornisci un predicato, dovresti aspettarti che le `SELECT` query con una clausola scansionino almeno 16 MB di dati. `LIMIT` La selezione di un sottoinsieme di colonne velocizza notevolmente il runtime delle query e riduce i dati scansionati. Il connettore Timestream è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
## Query passthrough
[Il connettore Timestream supporta le query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Timestream, puoi utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in Timestream. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Il progetto del connettore Timestream per Amazon Athena è concesso in licenza ai sensi della [Licenza Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Risorse aggiuntive
Per ulteriori informazioni su questo connettore, visitate [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-timestream) su .com. GitHub
# Connettore Amazon Athena TPC Benchmark DS (TPC-DS)
Il connettore TPC-DS per Amazon Athena consente ad Amazon Athena di comunicare con un'origine di dati TPC Benchmark DS generati casualmente per l'utilizzo nel benchmarking e nei test funzionali di Athena Federation. Il connettore TPC-DS Athena genera un database compatibile con TPC-DS in corrispondenza di uno dei quattro fattori di scala. Non consigliamo di utilizzare questo connettore in alternativa ai test sulle prestazioni dei data lake basati su Amazon S3.
Questo connettore può essere registrato nel Catalogo dati Glue come catalogo federato. Supporta i controlli di accesso ai dati definiti in Lake Formation a livello di catalogo, database, tabella, colonna, riga e tag. Questo connettore utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
## Parameters
Utilizzare i parametri illustrati in questa sezione per configurare il connettore TPC-DS.
**Nota**
I connettori di origine dati Athena creati il 3 dicembre 2024 e versioni successive utilizzano connessioni. AWS Glue
I nomi e le definizioni dei parametri elencati di seguito si riferiscono ai connettori di origine dati Athena creati prima del 3 dicembre 2024. Questi possono differire dalle [proprietà diconnessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) corrispondenti. Dal 3 dicembre 2024, utilizzare i parametri seguenti solo quando si [implementa manualmente](connect-data-source-serverless-app-repo.md) una versione precedente di un connettore di origine dati Athena.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore TPC-DS utilizzando un oggetto di connessioni Glue. Per fare ciò, impostare la variabile di ambiente `glue_connection` del connettore TPC-DS Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type TPCDS
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore TPC-DS creato utilizzando le connessioni Glue non supporta l’uso di un gestore multiplexing.
Il connettore TPC-DS creato utilizzando le connessioni Glue supporta solo 2 `ConnectionSchemaVersion`.
### Connessioni legacy
+ **spill\$1bucket**: specifica il bucket Amazon S3 per i dati che superano i limiti della funzione Lambda.
+ **spill\$1prefix**: (facoltativo) per impostazione predefinita, viene utilizzata una sottocartella nello `spill_bucket` specificato chiamata `athena-federation-spill`. Ti consigliamo di configurare un [ciclo di vita dell'archiviazione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) di Amazon S3 in questa posizione per eliminare gli spill più vecchi di un numero predeterminato di giorni o ore.
+ **spill\$1put\$1request\$1headers**: (facoltativo) una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta `putObject` di Amazon S3 utilizzata per lo spill (ad esempio, `{"x-amz-server-side-encryption" : "AES256"}`). Per altre possibili intestazioni, consulta il *riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service*.
+ **kms\$1key\$1id**: (facoltativo) per impostazione predefinita, tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente. Per fare in modo che la tua funzione Lambda utilizzi chiavi di crittografia più potenti generate da KMS come `a7e63k4b-8loc-40db-a2a1-4d0en2cd8331`, puoi specificare l'ID della chiave KMS.
+ **disable\$1spill\$1encryption**: (facoltativo) se impostato su `True`, disabilita la crittografia dello spill. L'impostazione predefinita è `False`: in questo modo, i dati riversati su S3 vengono crittografati utilizzando AES-GCM tramite una chiave generata casualmente o una chiave generata mediante KMS. La disabilitazione della crittografia dello spill può migliorare le prestazioni, soprattutto se la posizione dello spill utilizza la [crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
## Esecuzione di test su database e tabelle
Il connettore TPC-DS per Athena genera un database compatibile con TPC-DS in uno dei quattro fattori di scala `tpcds1`, `tpcds10`, `tpcds100`, `tpcds250` o `tpcds1000`.
### Riepilogo delle tabelle
Per un elenco completo delle tabelle e delle colonne dei dati del test, esegui le query `SHOW TABLES` o `DESCRIBE TABLE`. Per comodità, viene fornito il seguente riepilogo delle tabelle.
1. call\$1center
1. catalog\$1page
1. catalog\$1returns
1. catalog\$1sales
1. customer
1. customer\$1address
1. customer\$1demographics
1. date\$1dim
1. dbgen\$1version
1. household\$1demographics
1. income\$1band
1. Inventory
1. elemento
1. promotion
1. motivo
1. ship\$1mode
1. memorizzazione
1. store\$1returns
1. store\$1sales
1. time\$1dim
1. warehouse
1. web\$1page
1. web\$1returns
1. web\$1sales
1. web\$1site
Per le query TPC-DS compatibili con lo schema e i dati generati, consulta la directory [athena](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-tpcds/src/main/resources/queries) -/su. tpcds/src/main/resources/queries GitHub
### Query di esempio
La query `SELECT` di esempio seguente interroga il catalogo `tpcds` in merito ai dati demografici dei clienti in contee specifiche.
```
SELECT
cd_gender,
cd_marital_status,
cd_education_status,
count(*) cnt1,
cd_purchase_estimate,
count(*) cnt2,
cd_credit_rating,
count(*) cnt3,
cd_dep_count,
count(*) cnt4,
cd_dep_employed_count,
count(*) cnt5,
cd_dep_college_count,
count(*) cnt6
FROM
"lambda:tpcds".tpcds1.customer c, "lambda:tpcds".tpcds1.customer_address ca, "lambda:tpcds".tpcds1.customer_demographics
WHERE
c.c_current_addr_sk = ca.ca_address_sk AND
ca_county IN ('Rush County', 'Toole County', 'Jefferson County',
'Dona Ana County', 'La Porte County') AND
cd_demo_sk = c.c_current_cdemo_sk AND
exists(SELECT *
FROM "lambda:tpcds".tpcds1.store_sales, "lambda:tpcds".tpcds1.date_dim
WHERE c.c_customer_sk = ss_customer_sk AND
ss_sold_date_sk = d_date_sk AND
d_year = 2002 AND
d_moy BETWEEN 1 AND 1 + 3) AND
(exists(SELECT *
FROM "lambda:tpcds".tpcds1.web_sales, "lambda:tpcds".tpcds1.date_dim
WHERE c.c_customer_sk = ws_bill_customer_sk AND
ws_sold_date_sk = d_date_sk AND
d_year = 2002 AND
d_moy BETWEEN 1 AND 1 + 3) OR
exists(SELECT *
FROM "lambda:tpcds".tpcds1.catalog_sales, "lambda:tpcds".tpcds1.date_dim
WHERE c.c_customer_sk = cs_ship_customer_sk AND
cs_sold_date_sk = d_date_sk AND
d_year = 2002 AND
d_moy BETWEEN 1 AND 1 + 3))
GROUP BY cd_gender,
cd_marital_status,
cd_education_status,
cd_purchase_estimate,
cd_credit_rating,
cd_dep_count,
cd_dep_employed_count,
cd_dep_college_count
ORDER BY cd_gender,
cd_marital_status,
cd_education_status,
cd_purchase_estimate,
cd_credit_rating,
cd_dep_count,
cd_dep_employed_count,
cd_dep_college_count
LIMIT 100
```
## Autorizzazioni richieste
Consulta la sezione `Policies` del file [athena-tpcds.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-tpcds/athena-tpcds.yaml) per i dettagli completi delle policy IAM richieste da questo connettore. L'elenco che segue riporta un riepilogo delle autorizzazioni richieste.
+ **Accesso in scrittura ad Amazon S3**: per trasferire i risultati di query di grandi dimensioni, il connettore richiede l'accesso in scrittura a una posizione in Amazon S3.
+ **Athena GetQueryExecution**: il connettore utilizza questa autorizzazione per fallire rapidamente quando la query Athena upstream è terminata.
## Performance
Il connettore TPC-DS per Athena tenta di condurre le query in parallelo in base al fattore di scala scelto. Il pushdown dei predicati viene eseguito all'interno della funzione Lambda.
## Informazioni sulla licenza
Il progetto del connettore TPC-DS per Amazon Athena è concesso in licenza ai sensi della [Licenza Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
## Risorse aggiuntive
[Per ulteriori informazioni su questo connettore, visitate il sito corrispondente su .com.](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-tpcds) GitHub
# Connettore Amazon Athena Vertica
Vertica è una piattaforma di database colonnare che può essere implementata nel cloud o on-premise che supporta data warehouse con scalabilità exabyte. Puoi utilizzare il connettore Amazon Athena Vertica nelle query federate per interrogare le origini dati Vertica da Athena. Ad esempio, è possibile eseguire query analitiche su un data warehouse in Vertica e su un data lake in Amazon S3.
Questo connettore non utilizza connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
## Prerequisiti
+ Implementa il connettore sul tuo Account AWS utilizzando la console Athena o AWS Serverless Application Repository. Per ulteriori informazioni, consulta [Crea una connessione di un'origine dati](connect-to-a-data-source.md) o [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md).
+ Prima di utilizzare questo connettore, configura un VPC e un gruppo di sicurezza. Per ulteriori informazioni, consulta [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
## Limitazioni
+ Poiché il connettore Athena Vertica legge i file Parquet esportati da Amazon S3, le prestazioni del connettore possono essere lente. Per eseguire una query su tabelle di grandi dimensioni, ti suggeriamo di utilizzare una query [CREATE TABLE AS (SELECT ...)](ctas.md) (Crea tabella come [seleziona...]) e predicati SQL.
+ Attualmente, a causa di un problema noto in Athena Federated Query, il connettore fa sì che Vertica esporti tutte le colonne della tabella interrogata in Amazon S3, ma nei risultati sulla console di Athena risultano visibili solo le colonne interrogate.
+ Le operazioni di scrittura DDL non sono supportate.
+ Eventuali limiti Lambda pertinenti. Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
## Flusso di lavoro
Il diagramma seguente mostra il flusso di lavoro di una query che utilizza il connettore Vertica.
![\[Flusso di lavoro di una query Vertica da Amazon Athena\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-vertica-1.png)
1. Viene eseguita una query SQL su una o più tabelle in Vertica.
1. Il connettore analizza la query SQL per inviare la porzione pertinente a Vertica tramite la connessione JDBC.
1. Le stringhe di connessione utilizzano il nome utente e la password memorizzati per accedere a Gestione dei segreti AWS Vertica.
1. Il connettore esegue il wrapping della query SQL con un comando `EXPORT` di Vertica, come nell'esempio seguente.
```
EXPORT TO PARQUET (directory = 's3://amzn-s3-demo-bucket/folder_name,
Compression='Snappy', fileSizeMB=64) OVER() as
SELECT
PATH_ID,
...
SOURCE_ITEMIZED,
SOURCE_OVERRIDE
FROM DELETED_OBJECT_SCHEMA.FORM_USAGE_DATA
WHERE PATH_ID <= 5;
```
1. Vertica elabora la query SQL e invia il set di risultati a un bucket Amazon S3. Per una migliore velocità di trasmissione effettiva, Vertica utilizza l'opzione `EXPORT` per eseguire in parallelo l'operazione di scrittura di più file Parquet.
1. Athena effettua la scansione del bucket Amazon S3 per determinare il numero di file da leggere per il set di risultati.
1. Athena effettua più chiamate alla funzione Lambda e utilizza Apache `ArrowReader` per leggere i file Parquet dal data set di risultati. Le chiamate multiple consentono ad Athena di parallelizzare la lettura dei file Amazon S3 e di raggiungere un throughput fino a 100 GB al secondo.
1. Athena elabora i dati restituiti da Vertica con i dati scansionati dal data lake e restituisce il risultato.
## Termini
I seguenti termini si riferiscono al connettore Vertica.
+ **Istanza del database**: qualsiasi istanza del database Vertica distribuita su Amazon EC2.
+ **Gestore**: un gestore Lambda che accede all'istanza del database. Un gestore può gestire i metadati o i record di dati.
+ **Gestore dei metadati**: un gestore Lambda che recupera i metadati dall'istanza del database.
+ **Gestore dei record**: un gestore Lambda che recupera i record di dati dall'istanza del database.
+ **Gestore composito**: un gestore Lambda che recupera sia i metadati sia i record di dati dall'istanza del database.
+ **Proprietà o parametro**: una proprietà del database utilizzata dai gestori per estrarre le informazioni del database. Queste proprietà vengono configurate come variabili di ambiente Lambda.
+ **Stringa di connessione**: una stringa di testo utilizzata per stabilire una connessione a un'istanza del database.
+ **Catalogo**: un AWS Glue catalogo non registrato con Athena che è un prefisso obbligatorio per la proprietà. `connection_string`
## Parameters
Utilizzate i parametri di questa sezione per configurare il connettore Vertica.
### Connessioni Glue (consigliate)
Si consiglia di configurare un connettore Vertica utilizzando un oggetto Glue connections. Per fare ciò, imposta la variabile di `glue_connection` ambiente del connettore Vertica Lambda sul nome della connessione Glue da utilizzare.
**Proprietà delle connessioni Glue**
Utilizzare il seguente comando per ottenere lo schema di un oggetto di connessione Glue. Questo schema contiene tutti i parametri che è possibile usare per controllare la connessione.
```
aws glue describe-connection-type --connection-type VERTICA
```
**Proprietà dell’ambiente Lambda**
+ **glue\$1connection**: specifica il nome della connessione Glue associata al connettore federato.
+ **casing\$1mode**: (Facoltativo) specifica come gestire il casing per i nomi di schemi e tabelle. Il parametro `casing_mode` utilizza i seguenti valori per specificare il comportamento di casing:
+ **none**: Non modifica il casing dello schema e dei nomi delle tabelle specificati. Questa è l’impostazione predefinita per i connettori a cui è associata una connessione glue.
+ **upper**: tutti i nomi di schemi e tabelle specificati in maiuscolo.
+ **lower**: tutti i nomi di schemi e tabelle specificati in minuscolo.
**Nota**
Tutti i connettori che utilizzano le connessioni Glue devono essere utilizzati Gestione dei segreti AWS per memorizzare le credenziali.
Il connettore Vertica creato utilizzando le connessioni Glue non supporta l’uso di un gestore di multiplazione.
Il connettore Vertica creato utilizzando le connessioni Glue supporta solo `ConnectionSchemaVersion` 2.
### Connessioni legacy
Il connettore Vertica per Amazon Athena presenta diverse opzioni di configurazione attraverso le variabili di ambiente Lambda. Puoi utilizzare le seguenti variabili di ambiente Lambda per configurare il connettore.
+ **AthenaCatalogName**— Nome della funzione Lambda
+ **ExportBucket**— Il bucket Amazon S3 in cui vengono esportati i risultati delle query Vertica.
+ **SpillBucket**— Il nome del bucket Amazon S3 in cui questa funzione può trasferire dati.
+ **SpillPrefix**— Il prefisso della `SpillBucket` posizione in cui questa funzione può trasferire dati.
+ **SecurityGroupIds**— Uno o più IDs che corrispondono al gruppo di sicurezza da applicare alla funzione Lambda (ad esempio, `sg1``sg2`, o`sg3`).
+ **SubnetIds**— Una o più sottoreti IDs che corrispondono alla sottorete che la funzione Lambda può utilizzare per accedere all'origine dati (ad esempio, `subnet1` o). `subnet2`
+ **SecretNameOrPrefix**— Il nome o il prefisso di un set di nomi in Secrets Manager a cui questa funzione ha accesso (ad esempio,`vertica-*`)
+ **VerticaConnectionString**— I dettagli della connessione Vertica da utilizzare di default se non è definita alcuna connessione specifica al catalogo. La stringa può utilizzare facoltativamente la Gestione dei segreti AWS sintassi (ad esempio,). `${secret_name}`
+ **ID VPC**: l'ID del VPC da collegare alla funzione Lambda.
#### Stringa di connessione
Utilizza una stringa di connessione JDBC nel formato seguente per connetterti a un'istanza del database.
```
vertica://jdbc:vertica://host_name:
port/database?user=vertica-username&password=
vertica-password
```
#### Utilizzo di un gestore a singola connessione
Puoi utilizzare i seguenti gestori di metadati e record a singola connessione per connetterti a una singola istanza Vertica.
****
| Tipo di gestore | Classe |
| --- | --- |
| Gestore composito | VerticaCompositeHandler |
| Gestore dei metadati | VerticaMetadataHandler |
| Gestore dei record | VerticaRecordHandler |
#### Parametri del gestore a singola connessione
****
| Parametro | Description |
| --- | --- |
| default | Obbligatorio. La stringa di connessione predefinita. |
I gestori a singola connessione supportano una sola istanza del database e devono fornire un parametro di stringa di connessione del tipo `default`. Tutte le altre stringhe di connessione vengono ignorate.
#### Specifica delle credenziali
Per fornire un nome utente e una password per il database nella stringa di connessione JDBC, puoi utilizzare le proprietà della stringa di connessione o Gestione dei segreti AWS.
+ **Stringa di connessione**: puoi specificare un nome utente e una password come proprietà nella stringa di connessione JDBC.
**Importante**
Come best practice di sicurezza, non utilizzare credenziali codificate nelle variabili di ambiente o nelle stringhe di connessione. *Per informazioni su come trasferire i segreti codificati in Gestione dei segreti AWS, consulta [Move i segreti codificati](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) nella Guida per l'utente. Gestione dei segreti AWSGestione dei segreti AWS *
+ **Gestione dei segreti AWS**[— Per utilizzare la funzionalità Athena Federated Query con, Gestione dei segreti AWS il VPC collegato alla funzione Lambda deve avere [accesso a Internet o](https://aws.amazon.com/premiumsupport/knowledge-center/internet-access-lambda-function/) un endpoint VPC per connettersi a Secrets Manager.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html)
È possibile inserire il nome di un segreto nella Gestione dei segreti AWS stringa di connessione JDBC. Il connettore sostituisce il nome del segreto con i valori `username` e `password` di Secrets Manager.
Per le istanze del database Amazon RDS, questo supporto è strettamente integrato. Se usi Amazon RDS, ti consigliamo vivamente di utilizzare Gestione dei segreti AWS la rotazione delle credenziali. Se il tuo database non utilizza Amazon RDS, archivia le credenziali come JSON nel seguente formato:
```
{"username": "${username}", "password": "${password}"}
```
**Esempio di stringa di connessione con nomi dei segreti**
La stringa seguente ha i nomi del segreto \$1\$1`vertica-username`\$1 e `${vertica-password}`.
```
vertica://jdbc:vertica://
host_name:port/database?user=${vertica-username}&password=${vertica-password}
```
Il connettore utilizza il nome del segreto per recuperare i segreti e fornire il nome utente e la password, come nell'esempio seguente.
```
vertica://jdbc:vertica://
host_name:port/database?user=sample-user&password=sample-password
```
Attualmente, il connettore Vertica riconosce le proprietà JDBC `vertica-username` e `vertica-password`.
#### Parametri di spill
L'SDK Lambda può riversare i dati su Amazon S3. Tutte le istanze del database a cui accede la stessa funzione Lambda riversano i dati nella stessa posizione.
****
| Parametro | Description |
| --- | --- |
| spill\$1bucket | Obbligatorio. Nome del bucket di spill. |
| spill\$1prefix | Obbligatorio. Prefisso della chiave del bucket di spill. |
| spill\$1put\$1request\$1headers | (Facoltativo) Una mappa codificata in JSON delle intestazioni e dei valori della richiesta per la richiesta putObject di Amazon S3 utilizzata per lo spill (ad esempio, \$1"x-amz-server-side-encryption" : "AES256"\$1). Per altre possibili intestazioni, consulta il riferimento [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)all'API di Amazon Simple Storage Service. |
## Supporto dei tipi di dati
Nella tabella seguente vengono illustrati i tipi di dati supportati per il connettore Vertica.
****
| Booleano |
| --- |
| BigInt |
| Breve |
| Numero intero |
| Long |
| Float |
| Double |
| Data |
| Varchar |
| Byte |
| BigDecimal |
| TimeStamp come Varchar |
## Performance
La funzione Lambda esegue il pushdown di proiezione per ridurre i dati scansionati dalla query. `LIMIT`le clausole riducono la quantità di dati scansionati, ma se non fornisci un predicato, dovresti aspettarti che le `SELECT` query con una `LIMIT` clausola scansionino almeno 16 MB di dati. Il connettore Vertica è resiliente alla limitazione della larghezza di banda della rete dovuta alla simultaneità.
## Query passthrough
[Il connettore Vertica supporta le query passthrough.](federated-query-passthrough.md) Le query passthrough utilizzano una funzione di tabella per inviare l’intera query all’origine dati per l’esecuzione.
Per utilizzare le query passthrough con Vertica, è possibile utilizzare la seguente sintassi:
```
SELECT * FROM TABLE(
system.query(
query => 'query string'
))
```
La seguente query di esempio invia una query a un'origine dati in Vertica. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
system.query(
query => 'SELECT * FROM customer LIMIT 10'
))
```
## Informazioni sulla licenza
Utilizzando questo connettore, l'utente riconosce l'inclusione di componenti di terze parti, un elenco dei quali è disponibile nel file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-vertica/pom.xml) relativo a questo connettore, e accetta i termini delle rispettive licenze di terze parti fornite nel file [LICENSE.txt](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-vertica/LICENSE.txt) su .com. GitHub
## Risorse aggiuntive
Per le informazioni sulla versione più recente del driver JDBC, consultate il file [pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-vertica/pom.xml) per il connettore Vertica su .com. GitHub
*Per ulteriori informazioni su questo connettore, consulta [il sito corrispondente](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-vertica) su GitHub .com e [Interrogazione di un'origine dati Vertica in Amazon Athena utilizzando l'Athena Federated Query](https://aws.amazon.com/blogs/big-data/querying-a-vertica-data-source-in-amazon-athena-using-the-athena-federated-query-sdk/) SDK nel Big Data Blog.AWS *
# Crea una connessione di un'origine dati
Per utilizzare un connettore di origine dati Athena, è necessario creare la AWS Glue connessione che memorizza le informazioni di connessione relative al connettore e all'origine dati. Quando si crea la connessione, si assegna all’origine dati un nome da utilizzare per fare riferimento all’origine dati nelle query SQL.
Puoi creare e configurare una connessione a un'origine dati in Athena utilizzando la [console](connect-to-a-data-source-console-steps.md) o le operazioni [CreateDataCatalogAPI](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateDataCatalog.html).
**Topics**
+ [Autorizzazioni per creare e utilizzare un'origine dati in Athena](connect-to-a-data-source-permissions.md)
+ [Usa la console Athena per connettere a un'origine dati](connect-to-a-data-source-console-steps.md)
+ [Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati](connect-data-source-serverless-app-repo.md)
+ [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md)
+ [Carica le immagini ECR sul tuo account AWS](pull-ecr-customer-account.md)
+ [Registra la tua connessione come Catalogo Dati Glue](register-connection-as-gdc.md)
+ [Abilitare le query federate tra account](xacct-fed-query-enable.md)
+ [Aggiornare un connettore di origine dati](connectors-updating.md)
# Autorizzazioni per creare e utilizzare un'origine dati in Athena
Per creare e utilizzare un'origine dati, sono necessari i seguenti set di autorizzazioni.
+ AmazonAthenaFullAccess che fornisce accesso completo ad Amazon Athena e accesso mirato alle dipendenze necessarie per consentire l'interrogazione, la scrittura dei risultati e la gestione dei dati. Per ulteriori informazioni, consulta la AWS Managed Policy [AmazonAthenaFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html)Reference Guide.
+ Autorizzazioni per chiamare l' CreateDataCatalog API. Queste autorizzazioni sono necessarie solo quando crei un'origine dati che si integra con connessioni Glue. Per ulteriori informazioni sulla policy di esempio, consultare [Autorizzazioni necessarie per creare il connettore e il catalogo Athena](athena-catalog-access.md).
+ Se si desidera utilizzare il controllo degli accessi fine-grain di Lake Formation, oltre alle autorizzazioni sopra elencate, si ha anche bisogno delle seguenti autorizzazioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:RegisterResource",
"iam:ListRoles",
"glue:CreateCatalog",
"glue:GetCatalogs",
"glue:GetCatalog"
],
"Resource": "*"
}
]
}
```
------
# Usa la console Athena per connettere a un'origine dati
È possibile utilizzare la console Athena per creare e configurare una connessione a un’origine dati.
**Per creare una connessione a un'origine dati**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Nel pannello di navigazione scegliere **Origini dati e cataloghi**.
1. Nella pagina **Origini dati e cataloghi**, scegli **Crea origine dati**.
1. In **Choose a data source** (Scegli un'origine dati), scegli l'origine dati su cui eseguire una query con Athena, tenendo conto delle seguenti linee guida:
+ Scegli un’opzione di connessione che corrisponde all’origine dati. Athena dispone di connettori di origine dati predefiniti che è possibile configurare per origini, tra cui MySQL, Amazon DocumentDB e PostgreSQL.
+ Scegli ** AWS Glue Data Catalog- S3** se desideri interrogare i dati in Amazon S3 senza utilizzare un metastore Apache Hive o una delle altre opzioni di origine dati di query federate in questa pagina. Athena utilizza AWS Glue Data Catalog per archiviare i metadati e le informazioni sullo schema per le origini dati in Amazon S3. Si tratta dell'opzione di default (non federata). Per ulteriori informazioni, consulta [AWS Glue Data Catalog Utilizzalo per connetterti ai tuoi dati](data-sources-glue.md). Per i passaggi relativi all’utilizzo di questo flusso di lavoro, consultare [Registrare e utilizzare cataloghi dati in Athena](gdc-register.md).
+ Scegli **S3 - Apache Hive metastore** (Metastore Apache Hive - S3) per interrogare set di dati in Amazon S3 che utilizzano un metastore Apache Hive. Per ulteriori informazioni su questa opzione, consulta [Connect Athena a un metastore Apache Hive](connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore.md).
+ Scegli **Custom or shared connector** (Connettore personalizzato o condiviso) se desideri creare un connettore origine dati personalizzato da utilizzare con Athena. Per informazioni sulla scrittura di un connettore origine dati, consulta [Sviluppare un connettore di origine dati utilizzando l’SDK di Athena Query Federation](connect-data-source-federation-sdk.md).
1. Scegli **Next (Successivo)**.
1. Nella pagina **Inserisci i dettagli dell’origine dati**, per **Nome origine dati**, inserisci il nome che desideri utilizzare nelle istruzioni SQL quando esegui una query sull’origine dati da Athena. Il nome può contenere fino a 127 caratteri e deve essere univoco all'interno dell'account. Non può essere modificato dopo la creazione. I caratteri validi sono a-z, A-z, 0-9, \$1 (trattino basso), @ (chiocciola) e - (trattino). I nomi `awsdatacatalog`, `hive`, `jmx` e `system` sono riservati ad Athena e non possono essere utilizzati per i nomi delle origini dati.
1. Se l'origine dati scelta si integra con AWS Glue le connessioni.
1. Peri **dettagli della connessione AWS Glue **, inserire le informazioni richieste. Una connessione contiene le proprietà necessarie per connettersi a una particolare origine dati. Le proprietà richieste cambiano a seconda del tipo di connessione. Per ulteriori informazioni sulle proprietà relative al connettore, consultare [Connettori di origine dati disponibili](connectors-available.md). Per informazioni sulle proprietà di connessione aggiuntive, vedere le [proprietà di connessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) nella *Guida per l’utente AWS Glue *.
**Nota**
Quando si aggiornano le proprietà della connessione Glue, è necessario riavviare il connettore Lambda per ottenere le proprietà aggiornate. Per fare ciò, modificare le proprietà dell’ambiente e salvarlo senza modificare nulla.
Quando si aggiorna una connessione Glue, le seguenti proprietà non verranno aggiornate automaticamente nella funzione Lambda corrispondente. È necessario aggiornare manualmente la funzione Lambda per queste proprietà.
Configurazione VPC Lambda: `security_group_ids`, `subnet_ids`
Ruolo di esecuzione Lambda: `spill_bucket`, `secret_name`, `spill_kms_key_id`
1. In **Ruolo IAM esecuzione Lambda**, scegliere una delle seguenti opzioni:
+ **Crea e usa un nuovo ruolo di esecuzione**: (impostazione predefinita) Athena crea un ruolo di esecuzione che utilizzerà quindi per accedere alle risorse per tuo AWS Lambda conto. Athena richiede questo ruolo per creare un’origine dati federata.
+ **Utilizza un ruolo di esecuzione esistente**: usare questa opzione per scegliere un ruolo di esecuzione esistente. Per questa opzione, scegliere il ruolo di esecuzione che desideri utilizzare dal menu a discesa **Ruolo di esecuzione**.
1. Se l’origine dati scelta non si integra con le connessioni AWS Glue .
1. Per **Lambda function** (Funzione Lambda), scegli **Create Lambda function** (Crea funzione Lambda). La pagina delle funzioni per il connettore che hai scelto si apre nella AWS Lambda console. La pagina include informazioni dettagliate sul connettore.
1. Sotto **Impostazioni applicazione**, leggere la descrizione per ogni impostazione dell'applicazione e quindi inserire i valori corrispondenti alle proprie esigenze.
Le impostazioni dell'applicazione visualizzate variano a seconda del connettore di origini dati. Le impostazioni minime richieste includono:
+ **AthenaCatalogName**— Un nome, in minuscolo, per la funzione Lambda che indica l'origine dati a cui è destinata, ad esempio. `cloudwatchlogs`
+ **SpillBucket**— Un bucket Amazon S3 nel tuo account per archiviare i dati che superano i limiti di dimensione della risposta della funzione Lambda.
**Nota**
I dati fuoriusciti non vengono riutilizzati nelle esecuzioni successive e possono essere eliminati in modo sicuro. Athena non elimina questi dati al posto tuo. Per gestire questi oggetti, prendi in considerazione l'aggiunta di una policy del ciclo di vita degli oggetti che elimina i dati precedenti dal bucket spill di Amazon S3. Per ulteriori informazioni, consultare [Gestione del ciclo di vita dello storage](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) nella Guida per l’utente di Amazon S.
1. Seleziona **I acknowledge that this app creates custom IAM roles and resource policies** (Sono consapevole che questa app crea ruoli IAM personalizzati e policy della risorsa). Per ulteriori informazioni, scegliere il link **Info (Informazioni)** .
1. Seleziona **Implementa**. Al termine dell'implementazione, la funzione Lambda viene visualizzata nella sezione **Resources** (Risorse) nella console Lambda.
Dopo aver implementato il connettore origine dati nell'account, puoi connetterlo ad Athena.
1. Torna alla pagina **Enter data source details** (Inserisci i dettagli dell'origine dati) nella console Athena.
1. Nella sezione **Connection details** (Dettagli di connessione), scegli l'icona di aggiornamento accanto alla casella di ricerca **Select or enter a Lambda function** (Seleziona o inserisci una funzione Lambda).
1. Scegli il nome della funzione appena creata nella console Lambda. Viene visualizzato l'ARN della funzione Lambda.
1. (Facoltativo) Per **Tags** (Tag), aggiungi coppie chiave-valore da associare a questa origine dati. Per ulteriori informazioni sui tag, consulta [Assegnare tag alle risorse di Athena](tags.md).
1. Scegli **Next (Successivo)**.
1. Nella pagina **Verifica e crea**, esamina i dettagli dell’origine dati. Per apportare modifiche, scegliere **Modifica**
1. Leggere le informazioni in **Athena creerà risorse nel tuo account**. Se si è d'accordo, selezionare **Dichiaro di essere consapevole del fatto che Athena creerà risorse per mio conto**.
1. Seleziona **Create data source (Crea origine dati)**. **Athena ** creerà per te le seguenti risorse.
+ Ruolo IAM di esecuzione Lambda
+ AWS Glue connessione (solo se l'origine dati è compatibile con Connections) AWS Glue
+ funzione Lambda
La sezione **Data source details** (Dettagli sull'origine dati) della pagina dell'origine dati mostra le informazioni relative al nuovo connettore. È ora possibile utilizzare il connettore nelle query Athena.
Per informazioni sull'utilizzo di connettori dati nelle query, consulta [Eseguire query federate](running-federated-queries.md).
# Utilizzare il AWS Serverless Application Repository per distribuire un connettore di origine dati
Per implementare un connettore origine dati è possibile utilizzare [AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/) invece di utilizzare una connessione AWS Glue .
**Nota**
Si consiglia di utilizzare il SAR solo se si dispone di un connettore personalizzato o se si richiede l’uso di un connettore precedente. In caso contrario, si consiglia l’utilizzo della console Athena.
Puoi utilizzare il AWS Serverless Application Repository per trovare il connettore che desideri utilizzare, fornire i parametri richiesti dal connettore e quindi distribuire il connettore al tuo account. Quindi, dopo aver distribuito il connettore, utilizza la console Athena per rendere disponibile l'origine dati ad Athena.
## Implementazione del connettore sull'account
**Da utilizzare AWS Serverless Application Repository per distribuire un connettore di origine dati nel tuo account**
1. Accedi Console di gestione AWS e apri il **Serverless App** Repository.
1. Nel pannello di navigazione, scegli **Available applications (Applicazioni disponibili)**.
1. Seleziona l'opzione **Visualizzare le app che creano ruoli IAM personalizzati o policy delle risorse**.
1. Nella casella di ricerca digita il nome del connettore. Per un elenco dei connettori dati Athena predefiniti, consulta [Connettori di origine dati disponibili](connectors-available.md).
1. Scegliere il nome del connettore. In seguito a questa operazione, si apre la pagina della funzione Lambda **Dettagli dell'applicazione** nella console AWS Lambda .
1. Sul lato destro della pagina dei dettagli, inserisci le informazioni richieste in **Application settings** (Impostazioni dell'applicazione). Le impostazioni minime richieste includono quanto segue. Per informazioni sulle opzioni configurabili rimanenti per i connettori dati creati da Athena, consultate il [corrispondente argomento Connettori disponibili su](https://github.com/awslabs/aws-athena-query-federation/wiki/Available-Connectors). GitHub
+ **AthenaCatalogName**— Un nome per la funzione Lambda in minuscolo che indica l'origine dati a cui è destinata, ad esempio. `cloudwatchlogs`
+ **SpillBucket**— Specificate un bucket Amazon S3 nel vostro account per ricevere dati da payload di risposta di grandi dimensioni che superano i limiti di dimensione della risposta della funzione Lambda.
1. Seleziona **I acknowledge that this app creates custom IAM roles and resource policies** (Sono consapevole che questa app crea ruoli IAM personalizzati e policy della risorsa). Per ulteriori informazioni, scegliere il link **Info (Informazioni)** .
1. Nella parte inferiore destra della pagina **Application settings** (Impostazioni dell'applicazione), scegli **Deploy** (Implementa). Al termine dell'implementazione, la funzione Lambda viene visualizzata nella sezione **Resources** (Risorse) nella console Lambda.
## Rendere disponibile il connettore in Athena
A questo punto, puoi usare la console Athena per rendere disponibile il connettore origine dati per Athena.
**Per rendere disponibile il connettore origine dati per Athena**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Nel pannello di navigazione scegliere **Origini dati e cataloghi**.
1. Nella pagina **Origini dati e cataloghi**, scegliere **Crea origine dati**.
1. In **Choose a data source** (Scegli un'origine dati), scegli l'origine dati per la quale è stato creato un connettore in AWS Serverless Application Repository. Questo tutorial utilizza **Amazon CloudWatch Logs** come fonte di dati federata.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Enter data source details** (Inserisci i dettagli dell'origine dati), per **Data source name** (Nome origine dati), inserisci il nome che desideri utilizzare nelle istruzioni SQL quando esegui una query sull'origine dati da Athena (ad esempio, `CloudWatchLogs`). Il nome può contenere fino a 127 caratteri e deve essere univoco all'interno dell'account. Non può essere modificato dopo la creazione. I caratteri validi sono a-z, A-z, 0-9, \$1 (trattino basso), @ (chiocciola) e - (trattino). I nomi `awsdatacatalog`, `hive`, `jmx` e `system` sono riservati ad Athena e non possono essere utilizzati per i nomi delle origini dati.
1. Nella sezione **Connection details** (Dettagli di connessione), usa la casella **Select or enter a Lambda function** (Seleziona o inserisci una funzione Lambda) per scegliere il nome della funzione appena creata. Viene visualizzato l'ARN della funzione Lambda.
1. (Facoltativo) Per **Tags** (Tag), aggiungi coppie chiave-valore da associare a questa origine dati. Per ulteriori informazioni sui tag, consulta [Assegnare tag alle risorse di Athena](tags.md).
1. Scegli **Next (Successivo)**.
1. Nella pagina **Review and create** (Rivedi e crea), esamina i dettagli dell'origine dati, quindi scegli **Create data source** (Crea origine dati).
1. La sezione **Data source details** (Dettagli sull'origine dati) della pagina dell'origine dati mostra le informazioni relative al nuovo connettore. È ora possibile utilizzare il connettore nelle query Athena.
Per informazioni sull'utilizzo di connettori dati nelle query, consulta [Eseguire query federate](running-federated-queries.md).
# Crea un VPC per un connettore o una connessione di origine dati AWS Glue
Alcuni connettori e AWS Glue connessioni di origine dati Athena richiedono un VPC e un gruppo di sicurezza. In questo argomento viene illustrato come creare un VPC con una sottorete e un gruppo di sicurezza per il VPC. Come parte di questo processo, recuperi il file IDs per il VPC, la sottorete e il gruppo di sicurezza che create. Questi IDs sono necessari quando si configura la AWS Glue connessione o il connettore di origine dati per l'uso con Athena.
**Creazione di un VPC da utilizzare con un connettore origine dati Athena.**
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. Seleziona **Crea VPC**.
1. Nella pagina **Crea VPC**, alla voce **Impostazioni VPC**, per **Risorse da creare**, selezionare **VPC e altro**.
1. Alla voce **Generazione automatica tag nome**, per **Genera automaticamente** inserisci un valore che verrà utilizzato per generare i tag dei nomi per tutte le risorse del VPC.
1. Seleziona **Crea VPC**.
1. Al termine del processo, scegliere **Visualizza VPC.**
1. Nella sezione **Details** (Dettagli), alla voce **VPC ID** (ID VPC), copia l'ID VPC per riferimento futuro.
Ora è tutto pronto per recuperare l'ID della sottorete per il VPC appena creato.
**Recupero dell'ID della sottorete VPC**
1. Nel pannello di navigazione della console del VPC, seleziona **Subnets (Sottoreti)**.
1. Selezionare il nome di una sottorete la cui colonna **VPC** ha l’ID VPC annotato.
1. Nella sezione **Dettagli**, alla voce **ID sottorete**, copia il tuo ID sottorete per un riferimento successivo.
Successivamente, crea un gruppo di sicurezza per la VPC.
**Creazione di un gruppo di sicurezza per il proprio VPC**
1. Nel pannello di navigazione della console del VPC; seleziona **Sicurezza**, **Gruppi di sicurezza**.
1. Scegliere **Create Security Group** (Crea gruppo di sicurezza).
1. Nella pagina **Create Security Group (Crea gruppo di sicurezza)** immettere le seguenti informazioni:
+ In **Security group name** (Nome gruppo di sicurezza), inserisci un nome per il tuo gruppo di sicurezza.
+ In **Description** (Descrizione), inserisci una breve descrizione per il tuo gruppo di sicurezza. È richiesta una descrizione.
+ In **VPC**, selezionare l’ID VPC del VPC creato per il connettore origine dati.
+ In **Inbound rules** (Regole in entrata) e **Outbound rules** (Regole in uscita), aggiungi tutte le regole in entrata e in uscita necessarie.
1. Scegliere **Create Security Group** (Crea gruppo di sicurezza).
1. Nella pagina **Details** (Dettagli) per il gruppo di sicurezza, copia la voce nel campo **Security group ID** (ID gruppo di sicurezza) per riferimento successivo.
## Considerazioni importanti sull’utilizzo di VPC con connettori Athena
Le seguenti istruzioni si applicano a tutti i connettori Athena, poiché tutti i connettori possono utilizzare VPC.
**Nota**
Quando si utilizza un VPC con connessioni AWS Glue, è necessario configurare i seguenti PrivateLink endpoint:
Simple Storage Service (Amazon S3)
AWS Glue
AWS Secrets Manager
In alternativa, è possibile utilizzare l’accesso pubblico a Internet, sebbene ciò non sia consigliato per motivi di sicurezza.
**avvertimento**
L’utilizzo dell’accesso a un internet pubblico può esporre le risorse a ulteriori rischi per la sicurezza. Si consiglia vivamente di utilizzare gli PrivateLink endpoint per una maggiore sicurezza nella configurazione VPC.
# Carica le immagini ECR sul tuo account AWS
Le funzioni Lambda del connettore di federazione Athena utilizzano immagini di container archiviate in repository Amazon ECR gestiti da Athena. Per eseguire scansioni di sicurezza su queste immagini di container, bisogna prima copiarle in un repository Amazon ECR nel proprio account. Questa sezione fornisce step-by-step istruzioni su come copiare un'immagine nel repository e configurare la funzione Lambda per l'utilizzo dell'immagine.
## Prerequisiti
+ Un connettore di federazione Athena: il connettore può essere creato tramite qualsiasi fonte, a condizione che utilizzi un'immagine del container.
**Nota**
Per verificare l’implementazione delle immagini, controllare la scheda Immagine nel proprio Connettore Lambda di federazione Athena
+ Docker installato e funzionante
+ AWS CLI installato
+ Credenziali dell’account con autorizzazioni di estrazione appropriate
## Come trasferire un'immagine
1. Individuare l’URI dell’immagine dal connettore Lambda di federazione Athena
**Example**
```
account_id_1.dkr.ecr.us-east-1.amazonaws.com/athena-federation-repository:2025.15.1
```
1. Generare un token di autenticazione Docker per l’account gestito da Athena:
```
aws ecr get-login-password --region regionID | docker login --username AWS --password-stdin athena-managed-registry
```
Dove:
+ *regionID*è la tua regione di distribuzione (ad es. us-east-1)
+ *athena-managed-registry*è la parte del registro dell'URI dell'immagine (ad esempio, account\$1id\$11.dkr. ecr.us-east-1.amazonaws.com)
1. Estrarre l’immagine dall’account gestito da Athena:
```
docker pull athenaImageURI
```
1. Autenticare Docker nel registro:
```
aws ecr get-login-password --region regionID | docker login --username AWS --password-stdin customer-registry
```
*customer-registry*Dov'è il registro ECR (ad esempio, account\$1id\$12.dkr. ecr.us-east-1.amazonaws.com)
1. Aggiungere un tag all’immagine estratta per il tuo repository.
```
docker tag athenaImageURI yourImageURI
```
1. Invia l’immagine al tuo repository:
```
docker push yourImageURI
```
1. Aggiorna il tuo Connettore di federazione:
1. Vai alla tua funzione Lambda
1. Seleziona **Implementa nuovaimmagine**
1. Inserire l’URI della nuova immagine
L’immagine del connettore federato Athena si trova ora nel proprio account, il che consente di eseguire scansioni CVE sull’immagine.
# Registra la tua connessione come Catalogo Dati Glue
Dopo aver creato l’origine dati, è possibile utilizzare la console Athena per registrare la tua connessione come Catalogo Dati Glue. Una volta registrato, è possibile gestire il catalogo di dati federato e abilitare il controllo granulare degli accessi utilizzando Lake Formation. Per ulteriori informazioni, consultare [Creazione di un catalogo federato](https://docs.aws.amazon.com/lake-formation/latest/dg/create-fed-catalog-data-source.html).
È possibile registrare i seguenti connettori con cui integrarli per un controllo granulare degli accessi. AWS Glue
+ Redshift
+ BigQuery
+ DynamoDB (anteprima)
+ Snowflake (anteprima)
+ MySQL
+ PostgreSQL
+ AWS CMDB
+ Timestream
+ Archiviazione Azure Data Lake
+ Azure Synapse
+ IBM Db2
+ IBM Db2 AS/400 (Db2 iSeries)
+ DocumentDB
+ Google Cloud Storage
+ HBase
+ OpenSearch
+ Oracle
+ SAP HANA
+ SQL Server
+ TPC-DS
+ Cloudera Hive
+ Cloudwatch
+ Parametri Cloudwatch
+ Teradata
+ Vertica
## Prerequisiti
Prima di iniziare, è necessario completare i seguenti prerequisiti.
+ Assicurati di disporre dei ruoli e delle autorizzazioni richieste per registrare le sedi. Per ulteriori informazioni, consulta i [Requisiti per i ruoli](https://docs.aws.amazon.com/lake-formation/latest/dg/registration-role.html) nella Guida per gli AWS Lake Formation sviluppatori.
+ Assicurarsi di disporre dei ruoli richiesti in Lake Formation. Per ulteriori informazioni, consulta [Prerequisiti per la connessione del Data Catalog a fonti di dati esterne](https://docs.aws.amazon.com/lake-formation/latest/dg/federated-catalog-data-connection.html) nella Guida per gli AWS Lake Formation sviluppatori.
+ Il ruolo registrato in Glue deve disporre delle autorizzazioni elencate nell’esempio seguente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/spill-prefix/*",
"arn:aws:s3:::amzn-s3-demo-bucket/spill-prefix"
]
},
{
"Sid": "lambdainvoke",
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:lambda_function_name"
},
{
"Sid": "gluepolicy",
"Effect": "Allow",
"Action": "glue:*",
"Resource": [
"arn:aws:glue:us-east-1:111122223333:connection/",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
}
]
}
```
------
+ L’utente è responsabile di determinare e gestire un accesso appropriato ai dati. Con controlli di accesso dettagliati sulle query federate, si consiglia di utilizzare la policy gestita. [AmazonAthenaFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html) Se si desidera utilizzare una policy personalizzata, assicurarsi che gli utenti che eseguono le query federate non abbiano accesso alle seguenti risorse.
+ `lambda:InvokeFunction` sul connettore Lambda specificato nella connessione Glue
+ Accesso alla posizione del bucket spill in IAM
+ Accesso alla connessione Glue associata al proprio catalogo federato
+ Il ruolo di Lake Formation in IAM
## Registrare la propria connessione utilizzando la console
**Per registrare la propria connessione come Catalogo Dati Glue**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Nel pannello di navigazione scegliere **Origini dati e cataloghi**.
1. Dall’elenco **Origini dati**, scegliere l’origine dati creata per aprire la pagina **Dettagli dell’origine dati**.
1. **Scegli Inizia con. AWS Lake Formation**
**Nota**
Dopo aver scelto questa opzione, bisogna gestire la funzione Lambda in proprio. Athena non eliminerà la funzione Lambda.
1. Per **Nome catalogo dati**, fornire un nome univoco per il proprio catalogo.
1. Scegliere il **ruolo IAM di Lake Formation** che concede il permesso a Lake Formation di invocare la funzione Lambda. Assicurarsi che il ruolo disponga delle autorizzazioni mostrate nell’[esempio.](#register-connection-as-gdc-pre)
1. Nella casella di testo, digitare **conferma** per eliminare l’origine dati Athena, sostituirla con una registrazione del catalogo dati Glue.
**Nota**
Questa azione eliminerà l’origine dati Athena e creerà un nuovo catalogo dati Glue al suo posto. Una volta completata questa procedura, potrebbe essere necessario aggiornare le query che accedono all’origine dati per fare invece riferimento al catalogo dati Glue appena creato.
1. Scegliere **Crea catalogo e vai a Lake Formation**. Si apre la console Lake Formation in cui è possibile gestire il catalogo e concedere le autorizzazioni agli utenti su cataloghi, database e tabelle.
# Abilitare le query federate tra account
La query federata consente di eseguire query su origini dati diverse da Amazon S3 utilizzando connettori di origine dati implementati su AWS Lambda. La funzione di query federata tra account consente alla funzione Lambda e alle origini dati che devono essere sottoposte a query di trovarsi in account diversi.
**Nota**
Utilizzare questo metodo solo se non è stata registrata l’origine dati federata con AWS Glue Data Catalog. Se hai registrato la tua fonte di dati con AWS Glue Data Catalog, utilizza il modello di funzionalità e autorizzazioni AWS Glue Data Catalog cross-account. Per ulteriori informazioni, consultare [Concedere accesso multi-account](https://docs.aws.amazon.com/glue/latest/dg/cross-account-access.html) nella *Guida per l’utente AWS Glue *.
In qualità di amministratore dei dati, puoi abilitare query federate tra più account condividendo il connettore dati con l'account di un analista di dati o, in qualità di analista di dati, utilizzando un ARN Lambda condiviso da un amministratore di dati da aggiungere al tuo account. Quando vengono apportate modifiche di configurazione a un connettore nell'account di origine, la configurazione aggiornata viene automaticamente applicata alle istanze condivise del connettore negli account di altri utenti.
## Considerazioni e limitazioni
+ La funzione di query federata tra account è disponibile per i connettori dati di metastore non Hive che utilizzano un'origine dati basata su Lambda.
+ La funzionalità non è disponibile per il tipo di origine AWS Glue Data Catalog dati. Per informazioni sull'accesso a AWS Glue Data Catalog s da più account, vedere[Configurare l'accesso tra account ai cataloghi di AWS Glue dati](security-iam-cross-account-glue-catalog-access.md).
+ Se la risposta della funzione Lambda del connettore supera il limite di dimensione della risposta Lambda di 6 MB, Athena crittografa, raggruppa e trasferisce automaticamente la risposta a un bucket Amazon S3 da te configurato. L'entità che esegue la query Athena deve avere accesso al luogo dello sversamento affinché Athena possa leggere i dati fuoriusciti. Ti consigliamo di impostare una policy del ciclo di vita di Amazon S3 per eliminare gli oggetti dal luogo di fuoriuscita, poiché i dati non sono necessari dopo il completamento della query.
+ L'utilizzo di query federate su più server Regioni AWS non è supportato.
## Autorizzazioni richieste
Per configurare le autorizzazioni richieste, è necessario eseguire azioni sia nell'Account A () che nell'Account B (*444455556666*). *111122223333*
### Azioni per l’account A
Affinché l'account A dell'amministratore dei dati condivida una funzione Lambda con l'account B dell'analista dati, l'account B richiede la funzione di richiamo Lambda e l'accesso al bucket spill. Di conseguenza, l'account A dovrebbe aggiungere una [policy basata sulle risorse](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) alla funzione Lambda e un [accesso principale](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-policy-language-overview.html) al relativo bucket spill in Amazon S3.
1. La seguente policy concede a Lambda le autorizzazioni di richiamo funzione all'account B su una funzione Lambda nell'account A.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CrossAccountInvocationStatement",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:user/username"
]
},
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-1:444455556666:function:lambda-function-name"
}
]
}
```
------
1. La seguente policy consente l'accesso del bucket spill al principale nell'account B.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": ["arn:aws:iam::111122223333:user/username"]
},
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::spill-bucket",
"arn:aws:s3:::spill-bucket/*"
]
}
]
}
```
------
1. Se la funzione Lambda crittografa lo spill bucket con una AWS KMS chiave anziché la crittografia predefinita offerta dall'SDK di federazione, la politica AWS KMS chiave nell'Account A deve concedere l'accesso all'utente nell'Account B, come nell'esempio seguente.
```
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal":
{
"AWS": ["arn:aws:iam::account-B-id:user/username"]
},
"Action": [ "kms:Decrypt" ],
"Resource": "*" // Resource policy that gets placed on the KMS key.
}
```
### Azioni per l’account B
Affinché l'Account A condivida il connettore con l'Account B, l'Account B deve creare un ruolo chiamato `AthenaCrossAccountCreate-account-A-id` che l'Account A assume chiamando l' AWS azione API Security Token Service. [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)
1. Utilizza la console IAM o AWS CLI per creare il `AthenaCrossAccountCreate-account-A-id` ruolo come ruolo personalizzato in termini di policy di fiducia. Una policy di fiducia personalizzata delega l'accesso e consente ad altri di eseguire azioni sul tuo AWS account. Per i passaggi, consultare [Creare un ruolo utilizzando criteri di attendibilità personalizzati](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) nella *Guida per l’utente IAM*.
La relazione di attendibilità dovrebbe avere un oggetto principale in cui la chiave è `AWS` e il valore è l’ARN dell’account A, come nell’esempio seguente.
```
...
"Principal":
{
"AWS": ["arn:aws:iam::account-A-id:user/username"]
},
...
```
1. Inoltre, nell’account B, creare un criterio come il seguente che consenta l’azione `CreateDataCatalog`.
```
{
"Effect": "Allow",
"Action": "athena:CreateDataCatalog",
"Resource": "arn:aws:athena:*:account-B-id:datacatalog/*"
}
```
1. Aggiungere il criterio che consente l’azione `CreateDataCatalog` al ruolo `AthenaCrossAccountCreate-account-A-id` creato utilizzando l’account B.
## Condivisione di un'origine dati nell'account A con l'account B
Dopo che le autorizzazioni sono state impostate, è possibile utilizzare la pagina **Origini dati e cataloghi** nella console Athena per condividere un connettore dati nel proprio account (account A) con un altro account (account B). L'account A mantiene il pieno controllo e la proprietà del connettore. Quando l'account A apporta modifiche di configurazione al connettore, la configurazione aggiornata si applica al connettore condiviso nell'account B.
**Nota**
È possibile condividere solo un'origine dati di tipo Lambda e non è possibile condividere origini dati che utilizzano connessioni AWS Glue . Per ulteriori informazioni, consulta [Connettori di origine dati disponibili](connectors-available.md).
**Per condividere un'origine dati Lambda nell'account A con l'account B**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Scegliere **Origini dati e cataloghi**.
1. Sulla pagina **Origini dati e cataloghi**, scegliere il collegamento del connettore da condividere.
1. Nella pagina dei dettagli relativa a un’origine dati Lambda, dal menu **Azioni** nell’angolo in alto a destra, selezionare **Condividi**.
1. Nella sezione **Condividi *Lambda-name* con un altro account**? finestra di dialogo, inserisci le informazioni richieste.
+ Per **Data source name** (Nome origine dati), inserisci il nome dell'origine dati copiata come desideri che appaia nell'altro account.
+ Per **Account ID** (ID account), inserisci l'ID dell'account con cui desideri condividere l'origine dati (in questo caso, l'account B).
1. Scegli **Condividi**. Il connettore dati condiviso specificato viene creato nell'account B. Le modifiche di configurazione apportate al connettore nell'account A si applicano al connettore nell'account B.
## Aggiunta di un'origine dati condivisa dall'account A all'account B
In qualità di analista di dati, potresti ricevere l'ARN di un connettore da aggiungere al tuo account da un amministratore dei dati. È possibile utilizzare la pagina **Origini dati e cataloghi** della console Athena per aggiungere l’ARN Lambda fornito dall’amministratore al proprio account.
**Per aggiungere l'ARN Lambda di un connettore dati condiviso al tuo account**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione non è visibile, scegliere il menu di espansione a sinistra.
1. Scegliere **Origini dati e cataloghi**.
1. Nella pagina **Origini dati e cataloghi** scegliere **Crea origine dati**.
1. Nella pagina **Scegli un'origine dati**, selezionare **Connettore personalizzato o condiviso**.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Inserisci i dettagli dell’origine dati**, nella sezione **Dettagli della connessione**, per **Seleziona o inserisci una funzione Lambda**, inserire l’ARN Lambda dell’account A.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Rivedi e crea** scegliere **Crea origine dati**.
## Risoluzione dei problemi
Se viene visualizzato un messaggio di errore che indica che l'account A non dispone delle autorizzazioni per assumere un ruolo nell'account B, assicurarsi che il nome del ruolo creato nell'account B sia scritto correttamente e che la policy appropriata sia collegata.
# Aggiornare un connettore di origine dati
Athena consiglia di aggiornare regolarmente i connettori di origine dati utilizzati alla versione più recente per sfruttare le nuove funzionalità e miglioramenti. L’aggiornamento di un connettore di origine dati include i seguenti passaggi:
# Connessioni Glue (consigliate)
## Trovare la versione più recente di Athena Query Federation
Il numero di versione più recente dei connettori di origine dati di Athena Data corrisponde all'ultima versione di Athena Query Federation. In alcuni casi, le GitHub versioni possono essere leggermente più recenti di quelle disponibili su AWS Serverless Application Repository (SAR).
**Come trovare il numero di versione più recente di Athena Query Federation**
1. Visita l' GitHub URL [https://github.com/awslabs/aws-athena-query-federation/releases/latest](https://github.com/awslabs/aws-athena-query-federation/releases/latest).
1. Prendi nota del numero della versione nell'intestazione della pagina principale nel seguente formato:
***year*Rilascio v.** *week\$1of\$1year*. *iteration\$1of\$1week***di Athena Query Federation**
Ad esempio, il numero di rilascio per la versione di **rilascio v2023.8.3 di Athena Query Federation** è 2023.8.3.
## Trovare la versione del proprio connettore
Seguire questi passaggi per determinare la versione del connettore in uso.
**Per trovare la versione del connettore**
1. Nella pagina della console Lambda dell’applicazione Lambda, selezionare la scheda **Immagine**.
1. Nella scheda Immagine, individuare l’URI dell’immagine. L’URI segue questo formato:
```
Image_location_account.dkr.ecr.us-west-2.amazonaws.com/athena-federation-repository:Version
```
1. Il numero di versione nell’URI dell’immagine segue il formato `year.week_of_year.iteration_of_week` (ad esempio, `2021.42.1`). Questo numero rappresenta la versione del connettore in uso.
## Implementazione di una nuova versione del connettore
Segui questi passaggi per implementare una nuova versione del connettore.
**Per implementare una nuova versione del connettore**
1. Trovare la versione desiderata seguendo la procedura per trovare la versione più recente di Athena Query Federation.
1. Nella funzione Lambda del connettore federato, individuare l’URI dell’immagine e aggiornare il tag alla versione desiderata. Esempio:
Da:
```
509399631660.dkr.ecr.us-east-1.amazonaws.com/athena-federation-repository:2025.15.1
```
A:
```
509399631660.dkr.ecr.us-east-1.amazonaws.com/athena-federation-repository:2025.26.1
```
**Nota**
Se la versione attualmente in uso è precedente alla 2025.15.1, bisogna tenere in considerazione queste importanti modifiche:
Il nome del repository è stato aggiornato a `athena-federation-repository`
Per le versioni precedenti a questo aggiornamento, il comando override potrebbe non essere impostato. È necessario impostarlo sul gestore composito.
# Connessioni legacy
## Trovare la versione più recente di Athena Query Federation
Il numero di versione più recente dei connettori di origine dati di Athena Data corrisponde all'ultima versione di Athena Query Federation. In alcuni casi, le GitHub versioni possono essere leggermente più recenti di quelle disponibili su AWS Serverless Application Repository (SAR).
**Come trovare il numero di versione più recente di Athena Query Federation**
1. Visita l' GitHub URL [https://github.com/awslabs/aws-athena-query-federation/releases/latest](https://github.com/awslabs/aws-athena-query-federation/releases/latest).
1. Prendi nota del numero della versione nell'intestazione della pagina principale nel seguente formato:
***year*Rilascio v.** *week\$1of\$1year*. *iteration\$1of\$1week***di Athena Query Federation**
Ad esempio, il numero di rilascio per la versione di **rilascio v2023.8.3 di Athena Query Federation** è 2023.8.3.
## Trovare e annotare i nomi delle risorse
Per prepararti all'aggiornamento, individua e prendi nota delle seguenti informazioni:
1. Il nome della funzione Lambda del connettore.
1. Variabili di ambiente della funzione Lambda.
1. Il nome dell'applicazione Lambda, che gestisce la funzione Lambda del connettore.
**Come trovare i nomi delle risorse dalla console Athena**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Nel pannello di navigazione scegliere **Origini dati e cataloghi**.
1. Nella colonna **Nome origine dati**, seleziona il link dell'origine dati del tuo connettore.
1. Nella sezione **Dettagli origine dati**, in **Funzione Lambda**, seleziona il link alla tua funzione Lambda.
![\[Seleziona il link della funzione Lambda.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-updating-1.png)
1. Nella pagina **Funzioni**, nella colonna **Nome funzione**, annota il nome della funzione per il connettore.
![\[Prendi nota del nome della funzione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-updating-2.png)
1. Scegli il link del nome della funzione.
1. Nella sezione **Panoramica funzioni**, seleziona la scheda **Configurazione**.
1. Nel riquadro a sinistra, seleziona **Variabili di ambiente**.
1. Nella sezione **Variabili ambiente**, prendi nota delle chiavi e dei valori corrispondenti.
1. Scorri fino alla parte superiore della pagina.
1. Nel messaggio **Questa funzione appartiene a un'applicazione. Fai clic qui per gestirlo**, seleziona il link **Fai clic qui**.
1. **Nella *your\$1application\$1name* pagina **serverlessrepo-**, prendi nota del nome della tua applicazione senza serverlessrepo.** Ad esempio, se il nome dell'applicazione è **serverlessrepo** -, il nome dell'applicazione è. DynamoDbTestApp **DynamoDbTestApp**
1. Resta sulla pagina della console Lambda dell'applicazione, quindi continua con i passaggi descritti in **Individuazione della versione del connettore in uso**.
## Trovare la versione del connettore in uso
Segui questi passaggi per trovare la versione del connettore in uso.
**Come trovare la versione del connettore in uso**
1. Nella pagina della console Lambda dell'applicazione Lambda, seleziona la scheda **Implementazioni**.
1. Nella scheda **Distribuzioni** espandi il **modello SAM**.
1. Cercare **CodeUri**.
1. Nel campo **Chiave** sotto **CodeUri**, trova la seguente stringa:
```
applications-connector_name-versions-year.week_of_year.iteration_of_week/hash_number
```
L'esempio seguente mostra una stringa per il CloudWatch connettore:
```
applications-AthenaCloudwatchConnector-versions-2021.42.1/15151159...
```
1. Registra il valore per*year*. *week\$1of\$1year*. *iteration\$1of\$1week*(ad esempio, **2021.42.1**). Questa è la versione del tuo connettore.
## Implementare una nuova versione del connettore
Segui questi passaggi per implementare una nuova versione del connettore.
**Come implementare una nuova versione del connettore**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Nel pannello di navigazione scegliere **Origini dati e cataloghi**.
1. Nella pagina **Origini dati e cataloghi**, scegliere **Crea origine dati**.
1. Seleziona l'origine dati che intendi aggiornare, quindi seleziona **Avanti**.
1. Nella sezione **Dettagli connessione**, seleziona **Crea funzione Lambda**. Si apre la console Lambda dove potrai implementare l'applicazione aggiornata.
![\[Pagina del connettore nella console. AWS Lambda\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-updating-3.png)
1. Poiché di fatto non stai creando una nuova origine dati, puoi chiudere la scheda della console Athena.
1. Nella pagina della console Lambda del connettore, esegui le seguenti operazioni:
1. Assicurati di aver rimosso il prefisso **serverlessrepo-** dal nome dell'applicazione, quindi copia il nome dell'applicazione nel campo **Nome applicazione**.
1. Copia il nome della funzione Lambda nel **AthenaCatalogName**campo. Alcuni connettori chiamano questo campo **LambdaFunctionName**.
1. Copia le variabili di ambiente registrate nei campi corrispondenti.
1. Seleziona l'opzione **Sono consapevole che questa app crea ruoli IAM personalizzati e policy delle risorse**, quindi scegli **Implementa**.
1. Per verificare che l'applicazione sia stata aggiornata, seleziona la scheda **Implementazioni**.
La sezione **Cronologia delle implementazioni** mostra che l'aggiornamento è completo.
![\[Aggiornamento del connettore completato.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connectors-updating-4.png)
1. Per confermare il nuovo numero di versione, puoi espandere il **modello SAM** come prima **CodeUri**, trovare e controllare il numero di versione del connettore nel campo **Chiave**.
Ora puoi usare il connettore aggiornato per creare query federate Athena.
# Modifica o elimina la connessione di un'origine dati
È possibile utilizzare la console Athena per aggiornare la descrizione, l’host, la porta, il database e altre proprietà di una connessione esistente. È anche possibile eliminare le origini dati dalla console Athena.
## Modifica la connessione di un'origine dati
**Per modificare la connessione di un'origine dati**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Nel pannello di navigazione scegliere **Data sources and catalogs** (Origini dati e cataloghi).
1. Nella pagina **Data sources and catalogs** (Origini dati e cataloghi), scegliere la connessione all’origine dati che si desidera modificare.
1. Per **AWS Glue i dettagli della connessione**, scegliere **Modifica**.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Edit ** (Modifica ), aggiornare le informazioni come richiesto. Le proprietà disponibili dipendono dal tipo di connessione.
**Nota**
Quando si aggiornano le proprietà di connessione per i segreti, la posizione dello spill o l’ID della chiave AWS KMS , assicurarsi che il ruolo di esecuzione Lambda abbia ancora accesso alle risorse aggiornate. Per ulteriori informazioni, consultare [Visualizzazione e aggiornamento delle autorizzazioni nel ruolo di esecuzione](https://docs.aws.amazon.com/lambda/latest/dg/permissions-executionrole-update.html) nella Guida per gli sviluppatori AWS Lambda .
+ **Descrizione**: modifica la descrizione della connessione.
+ **Host**: modifica il nome host del database.
+ **Porta**: modifica il numero di porta per il database.
+ **Database**: modifica il nome del database.
+ **Parametri JDBC**: modifica eventuali parametri JDBC aggiuntivi richiesti per la connessione.
+ **Segreto**: scegli o crea un segreto da Gestione dei segreti AWS. Usa AWS i segreti per evitare di codificare informazioni sensibili nella stringa di connessione JDBC. [Per ulteriori informazioni, consulta Cos'è? Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) Per ulteriori informazioni sulla creazione dei segreti in Secrets Manager, consultare [Creazione di un segreto Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) nella *Guida per l’utente Gestione dei segreti AWS *.
Per utilizzarle Gestione dei segreti AWS con le query federate Athena, devi configurare un endpoint privato Amazon VPC per Secrets Manager. Per ulteriori informazioni, consulta [Creare un endpoint privato Secrets Manager VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/vpc-endpoint-overview.html#vpc-endpoint-create) nella *Guida dell’utente di Gestione dei segreti AWS *.
+ **Spill location in Amazon S3**: seleziona o crea una posizione bucket Amazon S3 nel tuo account per archiviare i dati che superano i limiti delle dimensioni della risposta della funzione Lambda.
**Nota**
I dati fuoriusciti non vengono riutilizzati nelle esecuzioni successive e possono essere eliminati in modo sicuro dopo 12 ore. Athena non elimina questi dati al posto tuo. Per gestire questi oggetti, prendi in considerazione l'aggiunta di una policy del ciclo di vita degli oggetti che elimina i dati precedenti dal bucket spill di Amazon S3. Per ulteriori informazioni, consulta [Gestione del ciclo di vita dello storage](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) nella *Guida per l'utente di Amazon S3*.
+ **Crittografia per i risultati delle query in S3**: scegliere una delle seguenti opzioni:
+ (Predefinita) **Usa una chiave generata causalmente**: tutti i dati riversati in Amazon S3 vengono crittografati utilizzando la modalità di crittografia autenticata AES-GCM e una chiave generata casualmente.
+ **Usa una AWS KMS chiave**: scegli o crea una chiave di crittografia generata più potente. AWS KMS Per ulteriori informazioni, consultare [Creazione di chiavi](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) nella *Guida per gli sviluppatori AWS Key Management Service *.
+ **Disattiva**: non crittografare i dati di spill.
+ **Impostazioni di rete**: alcune connessioni richiedono un cloud privato virtuale (VPC). Scegliere o creare un VPC con l’archivio dati a cui si desidera accedere, una sottorete e uno o più gruppi di sicurezza. Per ulteriori informazioni, consulta [Crea un VPC per un connettore o una connessione di origine dati AWS Glue](athena-connectors-vpc-creation.md).
**Nota**
Dopo aver aggiornato le proprietà di connessione per risorse come secret, spill location o AWS KMS key ID, assicurati che il ruolo di esecuzione Lambda continui ad avere accesso alle risorse aggiornate.
Dopo aver aggiornato le impostazioni di rete per la connessione, assicurarsi di aggiornare la funzione Lambda con le stesse impostazioni per rendere la connessione compatibile con l’origine dati.
Per informazioni sulle proprietà di connessione aggiuntive, consultare le [proprietà di connessione AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/connection-properties.html) nella *Guida per l’utente AWS Glue * oppure [Connettori di origine dati disponibili](connectors-available.md) nella *Guida per l’utente Amazon Athena*.
1. Scegli **Save** (Salva).
La sezione**AWS Glue connection details** (Dettagli connessione) della pagina dell’origine dati mostra le informazioni aggiornate relative al connettore.
## Eliminazione di un’origine dati
Quando si elimina un’origine dati, viene eliminata solo l’origine dati Athena e non vengono eliminate risorse come le connessioni Glue, il ruolo di esecuzione IAM e la funzione Lambda.
**Per eliminare un’origine dati**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Nel pannello di navigazione scegli **Data sources amd catalogs** (Origini dati e cataloghi).
1. Nella pagina **Data sources and catalogs** (Origini dati e cataloghi) selezionare l’origine dati da eliminare.
1. Scegliere **Elimina**.
1. Nella pagina **Delete data source** (Elimina origine dati), digitare *confirm* (conferma) per confermare l’eliminazione e quindi scegliere **Delete**(Elimina). Potrebbe essere necessario aspettare prima che l’eliminazione dell’origine dati venga completata. Una volta eliminata l’origine dati, viene visualizzato un avviso a conferma dell’avvenuta eliminazione.
# Eseguire query federate
Dopo aver configurato uno o più connettori dati e averli distribuiti nell'account, puoi utilizzarli nelle query Athena.
## Eseguire query su una singola origine dati
Negli esempi di questa sezione si presuppone che [Connettore Amazon Athena CloudWatch](connectors-cloudwatch.md) sia stato configurato e distribuito nel tuo account. Utilizza lo stesso approccio per eseguire query quando utilizzi altri connettori.
**Per creare una query Athena che utilizza il connettore CloudWatch**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Nell'editor di query Athena, creare una query SQL che utilizza la sintassi seguente nella clausola `FROM`.
```
MyCloudwatchCatalog.database_name.table_name
```
### Esempi
[L'esempio seguente utilizza il CloudWatch connettore Athena per connettersi alla `all_log_streams` vista nel gruppo `/var/ecommerce-engine/order-processor` CloudWatch Logs Log.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) La visualizzazione `all_log_streams` è una visualizzazione di tutti i flussi di log nel gruppo di log. La query di esempio limita il numero di righe restituite a 100.
```
SELECT *
FROM "MyCloudwatchCatalog"."/var/ecommerce-engine/order-processor".all_log_streams
LIMIT 100;
```
Nell'esempio seguente vengono analizzate le informazioni della stessa visualizzazione dell'esempio precedente. Nell'esempio vengono estratti l'ID ordine e il livello di log e filtrati tutti i messaggi che dispongono del livello `INFO`.
```
SELECT
log_stream as ec2_instance,
Regexp_extract(message '.*orderId=(\d+) .*', 1) AS orderId,
message AS order_processor_log,
Regexp_extract(message, '(.*):.*', 1) AS log_level
FROM MyCloudwatchCatalog."/var/ecommerce-engine/order-processor".all_log_streams
WHERE Regexp_extract(message, '(.*):.*', 1) != 'INFO'
```
## Eseguire query su più origini dati
Come esempio più complesso, immagina un'azienda di e-commerce che utilizza le seguenti fonti di dati per archiviare i dati relativi agli acquisti dei clienti:
+ [Amazon RDS per MySQL](https://aws.amazon.com/rds/mysql/) per archiviare i dati del catalogo dei prodotti
+ [Amazon DocumentDB](https://aws.amazon.com/documentdb/) per archiviare dati dell'account del cliente come e-mail e indirizzi di spedizione
+ [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) per archiviare i dati di spedizione e tracciamento degli ordini
Immagina che un analista di dati per questa applicazione di e-commerce scopra che i tempi di spedizione in alcune regioni sono stati influenzati dalle condizioni meteorologiche locali. L'analista desidera sapere quanti ordini subiscono ritardi, dove si trovano i clienti interessati e quali prodotti sono maggiormente interessati. Invece di esaminare separatamente le fonti di informazioni, l'analista utilizza Athena per unire i dati in un'unica query federata.
**Example**
```
SELECT
t2.product_name AS product,
t2.product_category AS category,
t3.customer_region AS region,
count(t1.order_id) AS impacted_orders
FROM my_dynamodb.default.orders t1
JOIN my_mysql.products.catalog t2 ON t1.product_id = t2.product_id
JOIN my_documentdb.default.customers t3 ON t1.customer_id = t3.customer_id
WHERE
t1.order_status = 'PENDING'
AND t1.order_date between '2022-01-01' AND '2022-01-05'
GROUP BY 1, 2, 3
ORDER BY 4 DESC
```
## Eseguire query su visualizzazioni federate
Quando si interrogano fonti federate, è possibile utilizzare le viste per offuscare le fonti di dati sottostanti o nascondere join complessi ad altri analisti che eseguono query sui dati.
### Considerazioni e limitazioni
+ Le viste federate richiedono la versione 3 del motore Athena.
+ Le viste federate vengono archiviate nell'origine dati sottostante AWS Glue, non con essa.
+ Le visualizzazioni federate non sono supportate nelle origini dati [registrate come Catalogo dati Glue](register-connection-as-gdc.md).
+ Le viste create con cataloghi federati devono utilizzare una sintassi dei nomi completa, come nell'esempio seguente:
```
"ddbcatalog"."default"."customers"
```
+ Gli utenti che eseguono query su fonti federate devono disporre dell'autorizzazione per poterle eseguire.
+ L'autorizzazione `athena:GetDataCatalog` è richiesta per le visualizzazioni federate. Per ulteriori informazioni, consulta [Consenti l’accesso alla query federata Athena](federated-query-iam-access.md).
### Esempi
L'esempio seguente crea una visualizzazione chiamata `customers` sui dati archiviati in un'origine dati federata.
**Example**
```
CREATE VIEW customers AS
SELECT *
FROM my_federated_source.default.table
```
La seguente query di esempio mostra una query che fa riferimento alla visualizzazione `customers` anziché all'origine dati federata sottostante.
**Example**
```
SELECT id, SUM(order_amount)
FROM customers
GROUP by 1
ORDER by 2 DESC
LIMIT 50
```
L'esempio seguente crea una visualizzazione chiamata `order_summary` che combina i dati provenienti da un'origine dati federata e da un'origine dati Amazon S3. Dall'origine federata, che è già stata creata in Athena, la visualizzazione utilizza `person` e le tabelle `profile`. Da Amazon S3, la visualizzazione utilizza le tabelle `purchase` e `payment`. Per fare riferimento ad Amazon S3, l'istruzione utilizza la parola chiave `awsdatacatalog`. Tieni presente che l'origine dati federata utilizza la sintassi dei nomi completa. *federated\$1source\$1name* *federated\$1source\$1database*. *federated\$1source\$1table*.
**Example**
```
CREATE VIEW default.order_summary AS
SELECT *
FROM federated_source_name.federated_source_database."person" p
JOIN federated_source_name.federated_source_database."profile" pr ON pr.id = p.id
JOIN awsdatacatalog.default.purchase i ON p.id = i.id
JOIN awsdatacatalog.default.payment pay ON pay.id = p.id
```
### Risorse aggiuntive
+ Per un esempio di vista federata disaccoppiata dalla fonte di origine e disponibile per l'analisi su richiesta in un modello multi-utente, consulta [Enstensione di data mesh con Amazon Athena e visualizzazioni federate](https://aws.amazon.com/blogs/big-data/extend-your-data-mesh-with-amazon-athena-and-federated-views/) nel *Blog sui Big Data di AWS *.
+ Per ulteriori informazioni sull’utilizzo delle visualizzazioni in Athena, consulta [Utilizzo delle viste](views.md).
# Utilizzare query passthrough federate
In Athena, è possibile eseguire query su origini dati federate utilizzando il linguaggio di query dell’origine dati stessa e inviare l’intera query all’origine dati per l’esecuzione. Queste query sono chiamate query passthrough. Per eseguire query passthrough, si utilizza una funzione di tabella nella query Athena. Includere la query passthrough da eseguire sull’origine dati in uno degli argomenti della funzione di tabella. Le query pass through restituiscono una tabella che è possibile analizzare utilizzando Athena SQL.
## Connettori supportati
I seguenti connettori di origine dati Athena supportano le query passthrough.
+ [Archiviazione Azure Data Lake](connectors-adls-gen2.md)
+ [Azure Synapse](connectors-azure-synapse.md)
+ [Cloudera Hive](connectors-cloudera-hive.md)
+ [Cloudera Impala](connectors-cloudera-impala.md)
+ [CloudWatch](connectors-cloudwatch.md)
+ [Db2](connectors-ibm-db2.md)
+ [Db2 iSeries](connectors-ibm-db2-as400.md)
+ [DocumentDB](connectors-docdb.md)
+ [DynamoDB](connectors-dynamodb.md)
+ [HBase](connectors-hbase.md)
+ [Google BigQuery](connectors-bigquery.md)
+ [Hortonworks](connectors-hortonworks.md)
+ [MySQL](connectors-mysql.md)
+ [Neptune](connectors-neptune.md)
+ [OpenSearch](connectors-opensearch.md)
+ [Oracle](connectors-oracle.md)
+ [PostgreSQL](connectors-postgresql.md)
+ [Redshift](connectors-redshift.md)
+ [SAP HANA](connectors-sap-hana.md)
+ [Snowflake](connectors-snowflake.md)
+ [SQL Server](connectors-microsoft-sql-server.md)
+ [Teradata](connectors-teradata.md)
+ [Timestream](connectors-timestream.md)
+ [Vertica](connectors-vertica.md)
## Considerazioni e limitazioni
Durante l’utilizzo di query passthrough in Athena, è necessario considerare i seguenti punti:
+ Le query passthrough sono supportate solo per le istruzioni `SELECT` Athena o le operazioni di lettura.
+ Le prestazioni delle query possono variare a seconda della configurazione dell’origine dati.
+ La query passthrough non supporta il controllo granulare degli accessi di Lake Formation.
+ Le query passthrough non sono supportate su origini dati [registrate come Catalogo Dati Glue](register-connection-as-gdc.md).
## Sintassi
La sintassi passthrough generale delle query Athena è la seguente.
```
SELECT * FROM TABLE(catalog.system.function_name(arg1 => 'arg1Value'[, arg2 => 'arg2Value', ...]))
```
Tenere presente quanto segue:
+ **catalog**: il nome del connettore federato Athena di destinazione o il nome del catalogo dati.
+ **system**: il namespace che contiene la funzione. Tutte le implementazioni del connettore Athena utilizzano questo namespace.
+ **function\$1name**: il nome della funzione che invia la query passthrough all’origine dati. Spesso viene chiamata `query`. La combinazione `catalog.system.function_name` è il percorso a piena risoluzione per la funzione.
+ **arg1, arg2 e così via**: argomenti della funzione. L’utente deve passarli alla funzione. Nella maggior parte dei casi, questa è la stringa di query che viene trasmessa all’origine dati.
Per la maggior parte delle origini dati, il primo e unico argomento è `query` seguito dall’operatore freccia `=>` e dalla stringa della query.
```
SELECT * FROM TABLE(catalog.system.query(query => 'query string'))
```
Per semplicità, è possibile omettere l’argomento denominato opzionale `query` e l’operatore freccia `=>`.
```
SELECT * FROM TABLE(catalog.system.query('query string'))
```
È possibile semplificare ulteriormente l’esecuzione della query rimuovendo il nome `catalog` se la query viene eseguita nel contesto del catalogo di destinazione.
```
SELECT * FROM TABLE(system.query('query string'))
```
Se l’origine dati richiede più della stringa della query, utilizzare argomenti denominati nell’ordine previsto dall’origine dati. Ad esempio, l’espressione `arg1 => 'arg1Value'` contiene il primo argomento e il relativo valore. Il nome *arg1* è specifico dell'origine dati e può differire da connettore a connettore.
```
SELECT * FROM TABLE(
system.query(
arg1 => 'arg1Value',
arg2 => 'arg2Value',
arg3 => 'arg3Value'
));
```
Quanto sopra può essere semplificato anche omettendo i nomi degli argomenti. Tuttavia, è necessario seguire l’ordine della firma del metodo. Consultare la documentazione di ciascun connettore per ulteriori informazioni sulla firma della funzione.
```
SELECT * FROM TABLE(catalog.system.query('arg1Value', 'arg2Value', 'arg3Value'))
```
È possibile eseguire più query passthrough su diversi connettori Athena utilizzando il percorso completo di risoluzione delle funzioni, come nell’esempio seguente.
```
SELECT c_customer_sk
FROM TABLE (postgresql.system.query('select * from customer limit 10'))
UNION
SELECT c_customer_sk
FROM TABLE(dynamodb.system.query('select * from customer')) LIMIT 10
```
È possibile utilizzare le query passthrough come parte di una visualizzazione federata. Si applicano le stesse limitazioni. Per ulteriori informazioni, consultare [Esecuzione di query su visualizzazioni federate](https://docs.aws.amazon.com/athena/latest/ug/running-federated-queries.html#running-federated-queries-federated-views).
```
CREATE VIEW catalog.database.ViewName AS
SELECT * FROM TABLE (
catalog.system.query('query')
)
```
Per informazioni sulla sintassi esatta da utilizzare con un particolare connettore, consultate la documentazione relativa ai singoli connettori.
### Utilizzo delle virgolette
I valori degli argomenti, inclusa la stringa di query passata, devono essere racchiusi tra virgolette singole, come nell’esempio seguente.
```
SELECT * FROM TABLE(system.query(query => 'SELECT * FROM testdb.persons LIMIT 10'))
```
Quando la stringa di query è racchiusa tra virgolette doppie, la query ha esito negativo. La seguente query ha esito negativo e restituisce il messaggio di errore COLUMN\$1NOT\$1FOUND: line 1:43: Column 'select \$1 from testdb.persons limit 10' cannot be resolved.
```
SELECT * FROM TABLE(system.query(query => "SELECT * FROM testdb.persons LIMIT 10"))
```
Per evitare una singola virgoletta, aggiungere una singola virgoletta all’originale (ad esempio, `terry's_group` a `terry''s_group`).
## Esempi
La seguente query di esempio invia una query a un origine dati. La query seleziona tutte le colonne della tabella `customer`, limitando i risultati a 10.
```
SELECT * FROM TABLE(
catalog.system.query(
query => 'SELECT * FROM customer LIMIT 10;'
))
```
L’istruzione seguente esegue la stessa query, ma elimina l’argomento denominato opzionale `query` e l’operatore freccia `=>`.
```
SELECT * FROM TABLE(
catalog.system.query(
'SELECT * FROM customer LIMIT 10;'
))
```
Questo può anche essere incapsulato in una visualizzazione federata per facilitarne il riutilizzo. Quando viene utilizzata con una visualizzazione, è necessario utilizzare il percorso di risoluzione completo della funzione.
```
CREATE VIEW AwsDataCatalog.default.example_view AS
SELECT * FROM TABLE (
catalog.system.query('SELECT * FROM customer LIMIT 10;')
)
```
## Disabilitare il passthrough delle query
Per disabilitare le query passthrough, aggiungere una variabile di ambiente Lambda denominata `enable_query_passthrough` e impostarla su `false`.
# Comprendere i qualificatori di nomi di tabella federati
Athena utilizza i seguenti termini per fare riferimento alle gerarchie di oggetti dati:
+ **Origine dati**: un gruppo di database
+ **Database**: un gruppo di tabelle
+ **Tabella**: dati organizzati come gruppo di righe o colonne
A volte si fa riferimento a questi oggetti anche con nomi alternativi ma equivalenti, come i seguenti:
+ Un'origine dati talvolta viene definita catalogo.
+ Talvolta un database viene definito schema.
## Termini nelle fonti di dati federate
Quando esegui una query su origini dati federate, tieni presente che l'origine dati sottostante potrebbe non utilizzare la stessa terminologia di Athena. Tieni presente questa distinzione quando scrivi le tue query federate. Le sezioni seguenti descrivono in che modo i termini relativi agli oggetti dati in Athena corrispondono a quelli delle origini dati federate.
### Amazon Redshift
Un *database* Amazon Redshift è un gruppo di *schemi* Redshift che contiene un gruppo di *tabelle* Redshift.
****
| Athena | Redshift |
| --- | --- |
| Origine dati Redshift | Una funzione Lambda del connettore Redshift configurata per puntare a un database Redshift. |
| data\$1source.database.table | database.schema.table |
Query di esempio
```
SELECT * FROM
Athena_Redshift_connector_data_source.Redshift_schema_name.Redshift_table_name
```
Per ulteriori informazioni su questo connettore, consulta [Connettore Redshift di Amazon Athena](connectors-redshift.md).
### Cloudera Hive
Un *server* o *cluster* Cloudera Hive è un gruppo di *database* Cloudera Hive che contiene un gruppo di *tabelle* Cloudera Hive.
****
| Athena | Hive |
| --- | --- |
| Origine dati Cloudera Hive | Funzione Lambda del connettore Cloudera Hive configurata per puntare a un server Cloudera Hive. |
| data\$1source.database.table | server.database.table |
Query di esempio
```
SELECT * FROM
Athena_Cloudera_Hive_connector_data_source.Cloudera_Hive_database_name.Cloudera_Hive_table_name
```
Per ulteriori informazioni su questo connettore, consulta [Connettore Amazon Athena per Cloudera Hive](connectors-cloudera-hive.md).
### Cloudera Impala
Un *server* o *cluster* Impala è un gruppo di *database* Impala che contiene un gruppo di *tabelle* Impala.
****
| Athena | Impala |
| --- | --- |
| Origine dati Impala | Funzione Lambda del connettore Impala configurata per puntare a un server Impala. |
| data\$1source.database.table | server.database.table |
Query di esempio
```
SELECT * FROM
Athena_Impala_connector_data_source.Impala_database_name.Impala_table_name
```
Per ulteriori informazioni su questo connettore, consulta [Connettore Amazon Athena per Cloudera Impala](connectors-cloudera-impala.md).
### MySQL
Un server *MySQL* è un gruppo di *database* MySQL che contiene un gruppo di *tabelle* MySQL.
****
| Athena | MySQL |
| --- | --- |
| Origine dati MySQL | Funzione Lambda del connettore MySQL configurata per puntare a un server MySQL. |
| data\$1source.database.table | server.database.table |
Query di esempio
```
SELECT * FROM
Athena_MySQL_connector_data source.MySQL_database_name.MySQL_table_name
```
Per ulteriori informazioni su questo connettore, consulta [Connettore MySQL di Amazon Athena](connectors-mysql.md).
### Oracle
Un *server* (o *database*) Oracle è un gruppo di *schemi* Oracle che contiene un gruppo di *tabelle* Oracle.
****
| Athena | Oracle |
| --- | --- |
| Origine dati Oracle | Funzione Lambda del connettore Oracle configurata per puntare a un server Oracle. |
| data\$1source.database.table | server.schema.table |
Query di esempio
```
SELECT * FROM
Athena_Oracle_connector_data_source.Oracle_schema_name.Oracle_table_name
```
Per ulteriori informazioni su questo connettore, consulta [Connettore Amazon Athena per Oracle](connectors-oracle.md).
### Postgres
Un *server* (o *cluster*) Postgres è un gruppo di *database* Postgres. Un *database* Postgres è un gruppo di *schemi* Postgres che contiene un gruppo di *tabelle* Postgres.
****
| Athena | Postgres |
| --- | --- |
| Origine dati Postgres | Funzione Lambda del connettore Postgres configurata per puntare a un server e un database Postgres. |
| data\$1source.database.table | server.database.schema.table |
Query di esempio
```
SELECT * FROM
Athena_Postgres_connector_data_source.Postgres_schema_name.Postgres_table_name
```
Per ulteriori informazioni su questo connettore, consulta [Connettore PostgreSQL di Amazon Athena](connectors-postgresql.md).
# Sviluppare un connettore di origine dati utilizzando l’SDK di Athena Query Federation
Per scrivere i propri connettori origine dati, puoi utilizzare l’SDK di [Athena Query Federation](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk). L’SDK Athena Query Federation definisce un insieme di interfacce e protocolli di collegamento che è possibile utilizzare per consentire ad Athena di delegare parti del suo piano di esecuzione della query al codice scritto e distribuito. L’SDK include una suite di connettori e un connettore di esempio.
I connettori personalizzati non utilizzano connessioni Glue per centralizzare le proprietà di configurazione in Glue. La configurazione della connessione viene effettuata tramite Lambda.
È inoltre possibile personalizzare i [connettori preconfigurati](https://github.com/awslabs/aws-athena-query-federation/wiki/Available-Connectors) di Amazon Athena per il proprio uso personale. Puoi modificare una copia del codice sorgente da GitHub e quindi utilizzare [lo strumento di pubblicazione Connector](https://github.com/awslabs/aws-athena-query-federation/wiki/Connector_Publish_Tool) per creare il tuo pacchetto. AWS Serverless Application Repository Dopo aver distribuito il connettore in questo modo, è possibile utilizzarlo nelle query Athena.
Per informazioni su come scaricare l'SDK e istruzioni dettagliate per scrivere un connettore personalizzato, consulta [Example Athena](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-example) connector on. GitHub
# Lavorare con connettori origine dati per Apache Spark
Alcuni connettori di origine dati Athena sono disponibili come connettori DSV2 Spark. I nomi dei DSV2 connettori Spark hanno un `-dsv2` suffisso (ad esempio,). `athena-dynamodb-dsv2`
Di seguito sono riportati i DSV2 connettori attualmente disponibili, il nome `.format()` della classe Spark e i collegamenti alla documentazione corrispondente di Amazon Athena Federated Query:
| DSV2 connettore | Spark .format() nome classe | Documentazione |
| --- | --- | --- |
| athena-cloudwatch-dsv2 | com.amazonaws.athena.connectors.dsv2.cloudwatch.CloudwatchTableProvider | [CloudWatch](connectors-cloudwatch.md) |
| athena-cloudwatch-metrics-dsv2 | com.amazonaws.athena.connectors.dsv2.cloudwatch.metrics.CloudwatchMetricsTableProvider | [CloudWatch metriche](connectors-cwmetrics.md) |
| athena-aws-cmdb-dsv2 | com.amazonaws.athena.connectors.dsv2.aws.cmdb.AwsCmdbTableProvider | [CMDB](connectors-cmdb.md) |
| athena-dynamodb-dsv2 | com.amazonaws.athena.connectors.dsv2.dynamodb.DDBTableProvider | [DynamoDB](connectors-dynamodb.md) |
Per scaricare `.jar` i file per i DSV2 connettori, visita la DSV2 GitHub pagina [Amazon Athena Query Federation](https://github.com/awslabs/aws-athena-query-federation-dsv2) e consulta la sezione **Releases, **Release ******, **Assets**.
## Specificare il jar a Spark
Per utilizzare i DSV2 connettori Athena con Spark, devi inviare il `.jar` file relativo al connettore all'ambiente Spark che stai utilizzando. Le sezioni seguenti descrivono casi specifici.
### Athena per Spark
Per informazioni sull'aggiunta di file `.jar` personalizzati e configurazioni personalizzate ad Amazon Athena per Apache Spark, consulta [Utilizzare le proprietà Spark per specificare una configurazione personalizzata](notebooks-spark-custom-jar-cfg.md).
### General Spark
Per passare il file `.jar` del connettore a Spark, usa il comando `spark-submit` e specifica il file `.jar` nell'opzione `--jars`, come nell'esempio seguente:
```
spark-submit \
--deploy-mode cluster \
--jars https://github.com/awslabs/aws-athena-query-federation-dsv2/releases/download/some_version/athena-dynamodb-dsv2-some_version.jar
```
### Spark di Amazon EMR
Per eseguire un comando `spark-submit` con il parametro `--jars` su Amazon EMR, devi aggiungere un passaggio al cluster Spark di Amazon EMR. Per informazioni dettagliate su come utilizzare `spark-submit` su Amazon EMR, consulta la [Aggiungi fase Spark](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-submit-step.html) nella *Guida di rilascio di Amazon EMR*.
### AWS Glue ETL Spark
Per AWS Glue ETL, puoi passare l'URL GitHub .com del `.jar` file all'`--extra-jars`argomento del comando. `aws glue start-job-run` La AWS Glue documentazione descrive il `--extra-jars` parametro come se accettasse un percorso Amazon S3, ma il parametro può anche accettare un URL HTTPS. Per ulteriori informazioni, consulta la [Documentazione di riferimento dei parametri dei processi](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html#w5aac32c13c11) nella *Guida per gli sviluppatori di AWS Glue *.
## Eseguire query del connettore su Spark
Per inviare l'equivalente della tua query esistente federata di Athena su Apache Spark, utilizza la funzione `spark.sql()`. Ad esempio, supponi che intendi utilizzare la seguente query Athena su Apache Spark.
```
SELECT somecola, somecolb, somecolc
FROM ddb_datasource.some_schema_or_glue_database.some_ddb_or_glue_table
WHERE somecola > 1
```
Per eseguire la stessa query su Spark utilizzando il connettore Amazon Athena DSV2 DynamoDB, usa il codice seguente:
```
dynamoDf = (spark.read
.option("athena.connectors.schema", "some_schema_or_glue_database")
.option("athena.connectors.table", "some_ddb_or_glue_table")
.format("com.amazonaws.athena.connectors.dsv2.dynamodb.DDBTableProvider")
.load())
dynamoDf.createOrReplaceTempView("ddb_spark_table")
spark.sql('''
SELECT somecola, somecolb, somecolc
FROM ddb_spark_table
WHERE somecola > 1
''')
```
## Specificare i parametri
Le DSV2 versioni dei connettori delle sorgenti dati Athena utilizzano gli stessi parametri dei connettori delle sorgenti dati Athena corrispondenti. Per informazioni sui parametri, consulta la documentazione del connettore corrispondente di origine dati Athena.
Nel PySpark codice, utilizzate la seguente sintassi per configurare i parametri.
```
spark.read.option("athena.connectors.conf.parameter", "value")
```
Ad esempio, il codice seguente imposta il parametro `disable_projection_and_casing` del connettore DynamoDB di Amazon Athena su `always`.
```
dynamoDf = (spark.read
.option("athena.connectors.schema", "some_schema_or_glue_database")
.option("athena.connectors.table", "some_ddb_or_glue_table")
.option("athena.connectors.conf.disable_projection_and_casing", "always")
.format("com.amazonaws.athena.connectors.dsv2.dynamodb.DDBTableProvider")
.load())
```