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à.
# Utilizzo di connettori e connessioni personalizzati con AWS Glue Studio
AWS Glue fornisce supporto integrato per gli archivi dati più comuni (ad esempio Amazon Redshift, Amazon Aurora, Microsoft SQL Server, MySQL, MongoDB e PostgreSQL) utilizzando le connessioni JDBC. AWS Glue consente inoltre di usare driver JDBC personalizzati nei processi di estrazione, trasformazione e caricamento (ETL). Per gli archivi dati non supportati in modo nativo, ad esempio le applicazioni SaaS, è possibile utilizzare i connettori.
Un *connettore* è un pacchetto di codice opzionale che aiuta con l'accesso ai datastore in AWS Glue Studio. Puoi iscriverti a diversi connettori offerti in Marketplace AWS.
Quando si creano lavori ETL, è possibile utilizzare un archivio dati supportato in modo nativo, un connettore da Marketplace AWS o connettori personalizzati. Se utilizzi un connettore, è innanzitutto necessario creare una connessione. Una *connessione* contiene le proprietà necessarie per connettersi a un particolare datastore. È possibile utilizzare la connessione con le tue origini dati e destinazioni dati nel processo ETL. Connettori e connessioni funzionano insieme per facilitare l'accesso ai datastore.
Le seguenti connessioni sono disponibili durante la creazione di connessioni per connettori:
+ **Amazon Aurora**— un motore di database relazionale scalabile e ad alte prestazioni con sicurezza, backup e ripristino integrati e accelerazione in memoria.
+ **Amazon DocumentDB**: un servizio di database di documenti scalabile, altamente disponibile e completamente gestito che supporta MongoDB e SQL. APIs
+ **Amazon Redshift**— un servizio di database di documenti scalabile, altamente disponibile e completamente gestito che supporta MongoDB e SQL. APIs
+ **Azure SQL**: un servizio di database relazionale basato su cloud di Microsoft Azure che offre funzionalità di archiviazione e gestione dei dati scalabili, affidabili e sicure.
+ **Cosmos DB**: un servizio di database cloud distribuito a livello globale di Microsoft Azure che offre funzionalità di archiviazione e interrogazione di dati scalabili e ad alte prestazioni.
+ **Google BigQuery**: un data warehouse cloud senza server per l'esecuzione di query SQL veloci su set di dati di grandi dimensioni.
+ **JDBC**: un sistema di gestione di database relazionale (RDBMS) che utilizza un'API Java per connettersi e interagire con le connessioni dati.
+ **Kafka**: una piattaforma di elaborazione di flussi open-source, utilizzata per lo streaming e la messaggistica di dati in tempo reale.
+ **MariaDB**: un fork di MySQL sviluppato dalla comunità che offre prestazioni, scalabilità e funzionalità migliorate.
+ **MongoDB**: un database orientato ai documenti multipiattaforma che offre scalabilità, flessibilità e prestazioni elevate.
+ **MongoDB** Atlas: un'offerta di database as a service (DBaaS) basata su cloud di MongoDB che semplifica la gestione e la scalabilità delle implementazioni di MongoDB.
+ **Microsoft SQL Server**: un sistema di gestione di database relazionale (RDBMS) di Microsoft che offre solide funzionalità di archiviazione, analisi e reporting dei dati.
+ **Mixpanel**: una piattaforma di analisi che aiuta le aziende ad analizzare il modo in cui gli utenti interagiscono con i loro siti Web, con le loro applicazioni mobili e con altri prodotti digitali.
+ **MySQL**: un sistema di gestione di database relazionale (RDBMS) open-source ampiamente utilizzato nelle applicazioni Web e noto per la sua affidabilità e scalabilità.
+ **Rete**: un'origine dati di rete rappresenta una risorsa o un servizio accessibile in rete a cui è possibile accedere tramite una piattaforma di integrazione dei dati.
+ **OpenSearch**— una fonte di OpenSearch dati è un'applicazione in grado di connettersi e importare dati da. OpenSearch
+ **Oracle**: un sistema di gestione di database relazionale (RDBMS) di Oracle Corporation che offre solide funzionalità di archiviazione, analisi e reporting dei dati.
+ **PostgreSQL**: un sistema di gestione di database relazionale (RDBMS) open-source che offre solide funzionalità di archiviazione, analisi e reporting dei dati.
+ **Salesforce**: Salesforce fornisce software di gestione delle relazioni con i clienti (CRM) che aiutano nelle vendite, nell'assistenza clienti, nell'e-commerce e altro ancora. Se sei un utente Salesforce, puoi connetterti AWS Glue al tuo account Salesforce. Quindi, puoi usare Salesforce come origine o destinazione dei dati per i tuoi processi ETL. Esegui questi processi per trasferire dati tra Salesforce e AWS i servizi o altre applicazioni supportate.
+ **SAP HANA**: un database in memoria e una piattaforma di analisi che fornisce elaborazione rapida dei dati, analisi avanzate e integrazione dei dati in tempo reale.
+ **Snowflake**: un data warehouse basato su cloud che fornisce servizi di archiviazione e analisi dei dati scalabili e ad alte prestazioni.
+ **Teradata**: un sistema di gestione di database relazionale (RDBMS) che offre funzionalità di archiviazione, analisi e reporting dei dati ad alte prestazioni.
+ **Vertica**: un data warehouse analitico orientato alle colonne progettato per l'analisi di big data che offre prestazioni di query rapide, analisi avanzate e scalabilità.
# Creazione di connettori personalizzati
Puoi anche costruire un connettore personalizzato e caricare il codice del connettore su AWS Glue Studio.
I connettori personalizzati sono integrati in AWS Glue Studio attraverso l'API del runtime di Spark AWS Glue. l'API del runtime di Spark AWS Glue consente di collegare qualsiasi connettore compatibile con l'interfaccia Spark, Athena o JDBC. Consente di aggiungere qualsiasi opzione di connessione disponibile per il connettore personalizzato.
È possibile incapsulare tutte le proprietà di connessione con le [connessioni AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-connections.html) e fornire il nome della connessione al processo ETL. L'integrazione con le connessioni del catalogo dati consente di utilizzare le stesse proprietà di connessione per più chiamate in una singola applicazione Spark o in applicazioni diverse.
Puoi specificare ulteriori opzioni per la connessione. Lo script di processo che AWS Glue Studio genera contiene una voce `Datasource` che utilizza la connessione per collegare il connettore con le opzioni di connessione specificate. Ad esempio:
```
Datasource = glueContext.create_dynamic_frame.from_options(connection_type =
"custom.jdbc", connection_options = {"dbTable":"Account","connectionName":"my-custom-jdbc-
connection"}, transformation_ctx = "DataSource0")
```
**Per aggiungere un connettore ad AWS Glue Studio**
1. Crea il codice per il connettore personalizzato. Per ulteriori informazioni, consulta [Sviluppo di connettori personalizzati](developing-custom-connectors.md).
1. Aggiungi il supporto per le caratteristiche AWS Glue al connettore. Di seguito sono riportati alcuni esempi di queste funzionalità e di come vengono utilizzate all'interno dello script di processo generato da AWS Glue Studio:
+ **Mappatura dei dati**: il connettore può eseguire il typecast le colonne durante la lettura dal datastore sottostante. Ad esempio, una `dataTypeMapping` di `{"INTEGER":"STRING"}` converte tutte le colonne di tipo `Integer` in colonne di tipo `String` durante l'analisi dei record e la costruzione del `DynamicFrame`. In questo modo gli utenti possono eseguire il cast delle colonne nel tipo desiderato.
```
DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type
= "custom.jdbc", connection_options = {"dataTypeMapping":{"INTEGER":"STRING"}",
connectionName":"test-connection-jdbc"}, transformation_ctx = "DataSource0")
```
+ **Partizionamento per letture parallele**: AWS Glue consente la lettura dei dati paralleli dal datastore partizionando i dati su una colonna. È necessario specificare la colonna, il limite inferiore e il limite superiore della partizione e il numero di partizioni. Questa funzione consente di utilizzare il parallelismo dei dati e più executor Spark allocati per l'applicazione Spark.
```
DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type
= "custom.jdbc", connection_options = {"upperBound":"200","numPartitions":"4",
"partitionColumn":"id","lowerBound":"0","connectionName":"test-connection-jdbc"},
transformation_ctx = "DataSource0")
```
+ **Utilizzo Gestione dei segreti AWS per l'archiviazione delle credenziali**: la connessione Data Catalog può contenere anche un `secretId` file segreto memorizzato in. Gestione dei segreti AWS Il AWS segreto può archiviare in modo sicuro le informazioni di autenticazione e credenziali e fornirle in fase di esecuzione. AWS Glue In alternativa, è possibile specificare l'`secretId` dallo script Spark come segue:
```
DataSource = glueContext.create_dynamic_frame.from_options(connection_type
= "custom.jdbc", connection_options = {"connectionName":"test-connection-jdbc",
"secretId"-> "my-secret-id"}, transformation_ctx = "DataSource0")
```
+ **Filtraggio dei dati di origine con predicati di riga e proiezioni di colonna**: il runtime di Spark AWS Glue consente inoltre agli utenti di trasferire le query SQL per filtrare i dati all'origine con predicati di riga e proiezioni di colonna. Ciò permette al processo ETL di caricare i dati filtrati più velocemente dagli archivi dati che supportano push-down. Un esempio di query SQL trasferita in un'origine dati JDBC è: `SELECT id, name, department FROM department WHERE id < 200.`
```
DataSource = glueContext.create_dynamic_frame.from_options(connection_type =
"custom.jdbc", connection_options = {"query":"SELECT id, name, department FROM department
WHERE id < 200","connectionName":"test-connection-jdbc"}, transformation_ctx =
"DataSource0")
```
+ **Segnalibri di processo**: AWS Glue supporta il caricamento incrementale dei dati da origini JDBC. AWS Glue tiene traccia dell'ultimo record elaborato dal datastore ed elabora nuovi record di dati nelle successive esecuzioni del processo ETL. I segnalibri di processo utilizzano la chiave primaria come colonna predefinita per il tasto segnalibro, a condizione che questa colonna aumenti o diminuisca in sequenza. Per ulteriori informazioni sui segnalibri di processo, consulta [Segnalibri di processo](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) nella *Guida per sviluppatori di AWS Glue *.
```
DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type =
"custom.jdbc", connection_options = {"jobBookmarkKeys":["empno"], "jobBookmarkKeysSortOrder"
:"asc", "connectionName":"test-connection-jdbc"}, transformation_ctx = "DataSource0")
```
1. Impacchetta il connettore personalizzato come file JAR e carica il file su Amazon S3.
1. Testa il connettore personalizzato. Per ulteriori informazioni, consulta le istruzioni su [Glue Custom Connectors: GitHub Local Validation Tests Guide](https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/localValidation/README.md).
1. Nella console AWS Glue Studio, scegli **Connectors (Connettori)** nel pannello di navigazione della console.
1. Nella pagina **Connectors (Connettori)**, seleziona **Create custom connector (Crea connettore personalizzato)**.
1. Nella pagina **Create custom connecto** (Crea connettore personalizzato), immetti le seguenti informazioni:
+ Il percorso della posizione del file JAR di codice personalizzato in Amazon S3.
+ Un nome per il connettore che verrà utilizzato da AWS Glue Studio.
+ Il tipo di connettore, che può essere uno tra **JDBC**, **Spark** o **Athena**.
+ Il nome del punto di ingresso all'interno del codice personalizzato che AWS Glue Studio chiama per utilizzare il connettore.
+ Per i connettori JDBC, questo campo deve essere il nome della classe del driver JDBC.
+ Per i connettori Spark, questo campo deve essere il nome completo della classe dell'origine dati, o il relativo alias, che si utilizza quando si carica l'origine dati Spark con l'operatore `format`.
+ (Solo JDBC) L'URL di base utilizzato dalla connessione JDBC per l'archivio dati.
+ (Facoltativo) Una descrizione del connettore personalizzato.
1. Scegli **Create connector** (Crea connettore).
1. Dalla pagina **Connectors** (Connettori), crea una connessione che utilizza questo connettore, come descritto in [Creazione di connessioni per i connettori](creating-connections.md).
## Aggiunta di connettori a AWS Glue Studio
Un connettore è una parte di codice che facilita la comunicazione tra il datastore e AWS Glue. Puoi abbonarti a un connettore disponibile in Marketplace AWS oppure puoi creare il tuo connettore personalizzato.
### Iscrizione ai Marketplace AWS connettori
AWS Glue Studiosemplifica l'aggiunta di connettori da Marketplace AWS.
**Per aggiungere un connettore da Marketplace AWS a AWS Glue Studio**
1. Nella console AWS Glue Studio, scegli **Connectors (Connettori)** nel pannello di navigazione della console.
1. Nella pagina **Connectors** (Connectors), scegli **Go to Marketplace AWS** (Vai su Marketplace AWS).
1. In Marketplace AWS, in **Prodotti in evidenza**, scegli il connettore che desideri utilizzare. Puoi scegliere uno dei connettori in evidenza o utilizzare la ricerca. Puoi eseguire la ricerca in base al nome o al tipo di connettore e utilizzare le opzioni per perfezionare i risultati della ricerca.
Se desideri utilizzare uno dei connettori in evidenza, scegli **View product (Visualizza prodotto)**. Se hai usato la ricerca per trovare un connettore, scegli il nome del connettore.
1. Nella pagina prodotto del connettore, utilizza le schede per visualizzare le informazioni sul connettore. Se decidi di acquistare il connettore, scegli **Continue to Subscribe** (Continua con la sottoscrizione).
1. Inserisci le informazioni di pagamento, quindi scegli **Continue to Configure** (Continua con la configurazione).
1. Nella pagina **Configure this software** (Configurazione software), scegli il metodo di implementazione e la versione del connettore da utilizzare. Quindi, scegli **Continue to Launch** (Continua con l'avvio).
1. Nella pagina **Launch this software** (Avvia software), puoi rivedere le **istruzioni di utilizzo** fornite dal provider del connettore. Quando vuoi continuare, scegli **Attiva connessione in AWS Glue Studio**.
Dopo un breve periodo di tempo, la console mostra la pagina **Create marketplace connection** (Crea connessione al marketplace) in AWS Glue Studio.
1. Crea una connessione che utilizza questo connettore, come descritto in [Creazione di connessioni per i connettori](creating-connections.md).
In alternativa, ora puoi scegliere **Activate connector only** (Attiva solo connettore) per ignorare la creazione di una connessione. Devi creare una connessione in un secondo momento prima di poter utilizzare il connettore.
# Creazione di connessioni per i connettori
Una AWS Glue connessione è un oggetto del catalogo dati che memorizza le informazioni di connessione per un particolare data store. Le connessioni memorizzano le credenziali di accesso, le stringhe URI, le informazioni sul cloud privato virtuale (VPC) e altro ancora. La creazione di connessioni nel catalogo dati consente di evitare di dover specificare tutti i dettagli della connessione ogni volta che si crea un processo.
**Per creare una connessione per un connettore**
1. Nella AWS Glue Studio console, scegli **Connettori nel pannello** di navigazione della console. Nella sezione **Connessioni**, scegli **Crea connessione**.
1. Scegli l'origine dati per la quale desideri creare una connessione nel passaggio 1 della procedura guidata **Crea connessione dati**. Sono disponibili diversi modi per visualizzare le origini dati disponibili, inclusi i seguenti:
+ Filtra le origini dati disponibili scegliendo una scheda. Per impostazione predefinita, è selezionata l'opzione **Tutti i connettori**.
+ Attiva **Elenco** per visualizzare le origini dati sotto forma di elenco o torna a **Griglia** per visualizzare i connettori disponibili nel layout a griglia.
+ Utilizza la barra di ricerca per restringere l'elenco delle origini dati. Durante la digitazione, i risultati di ricerca vengono visualizzati e le fonti non corrispondenti vengono rimosse dalla visualizzazione.
Dopo aver scelto l'origine dati, scegli **Avanti**.
1. Configura la connessione nel passaggio 2 della procedura guidata.
Inserisci i dettagli della connessione. A seconda del tipo di connettore selezionato, viene richiesto di inserire ulteriori informazioni:
![\[La schermata mostra la pagina Connettori e la sezione Connessioni. Il pulsante Crea connessione è racchiuso in una casella rossa. Scegli Crea connessione per avviare la procedura guidata della Connessione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/connections-create-connection.png)
1. Scegli l'origine dati per la quale desideri creare una connessione nel passaggio 1 della procedura guidata **Crea connessione dati**. Sono disponibili diversi modi per visualizzare le origini dati disponibili. Per impostazione predefinita, tutte le origini dati disponibili vengono visualizzate in un layout a griglia. Puoi anche:
+ Attiva **Elenco** per visualizzare le origini dati sotto forma di elenco o torna a **Griglia** per visualizzare i connettori disponibili nel layout a griglia.
+ Utilizza la barra di ricerca per restringere l'elenco delle origini dati. Durante la digitazione, i risultati di ricerca vengono visualizzati e le fonti non corrispondenti vengono rimosse dalla visualizzazione.
![\[La schermata mostra la barra di ricerca e l'interruttore Griglia-Elenco.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/connections-create-step-1-view.png)
Dopo aver scelto l'origine dati, scegli **Avanti**.
1. Configura la connessione nel passaggio 2 della procedura guidata.
Inserisci i dettagli della connessione. A seconda del tipo di connettore selezionato, potrebbe essere richiesto di inserire ulteriori informazioni di connessione: Sono inclusi:
+ **Dettagli di connessione**: questi campi cambieranno a seconda dell'origine dati a cui ti stai connettendo. Ad esempio, se ti connetti a database Amazon DocumentDB, inserirai l'URL di Amazon DocumentDB. Se ti connetti a Amazon Aurora, sceglierai l'istanza del database e inserirai il nome del database. Di seguito sono riportati i dettagli di connessione necessari per Amazon Aurora:
![\[La schermata mostra i dettagli di connessione necessari per la configurazione Amazon Aurora come fonte di dati.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/connections-create-step-2-configure.png)
+ Tipo di credenziale: scegli tra **nome utente e password** o ** Gestione dei segreti AWS**. Inserisci le informazioni di autenticazione richieste.
+ Per i connettori che utilizzano JDBC, inserisci le informazioni necessarie per creare l'URL JDBC per il datastore.
+ Se usi un cloud privato virtuale (VPC), inserisci le relative informazioni di rete.
1. Impostare le proprietà di connessione nel passaggio 3 della procedura guidata. È possibile aggiungere descrizione e tag come parte opzionale di questo passaggio. Il nome è obbligatorio ed è precompilato con un valore predefinito. Scegli **Next (Successivo)**.
1. Controlla l'origine, i dettagli e le proprietà della connessione. Per apportare modifiche, scegli **Modifica** per il passaggio della procedura guidata. Quando è tutto pronto, scegli **Crea connessione**.
Scegli **Create connection (Crea connessione)**.
Vieni reindirizzato alla pagina **Connectors** (Connettori) e il banner informativo indica la connessione creata. Ora puoi utilizzare la connessione nei tuoi processi AWS Glue Studio .
# Creazione di una connessione Kafka
Quando crei una connessione Kafka, selezionando **Kafka** dal menu a discesa visualizzerai impostazioni aggiuntive da configurare:
+ Dettagli del cluster Kafka
+ Autenticazione
+ Encryption (Crittografia)
+ Opzioni di rete
**Configurazione dei dettagli del cluster Kafka**
1. Scegli la posizione del cluster. Puoi scegliere tra un cluster **Amazon Managed Streaming for Apache Kafka (MSK)** o un cluster **Apache Kafka gestito dal cliente**. Per ulteriori informazioni sullo streaming Amazon Managed for Apache Kafka, consulta [Amazon Managed Streaming for Apache Kafka (MSK)](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html).
**Nota**
Amazon Streaming gestito per Apache Kafka supporta solo i metodi di autenticazione TLS e SASL/SCRAM-SHA-512.
![\[La schermata mostra la sezione dei dettagli del cluster Kafka con le opzioni per selezionare una posizione del cluster e per accedere al server Kafka boostrap. URLs\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/kafka-cluster-details.png)
1. Inserisci il file per i tuoi server di bootstrap URLs Kafka. È possibile inserirne più di uno separando ciascun server con una virgola. Includi il numero della porta alla fine dell'URL aggiungendo `:`.
Ad esempio: `b-1.vpc-test-2.034a88o.kafka-us-east-1.amazonaws.com:9094`
**Selezionare i metodi di autenticazione**
![\[Lo screenshot mostra il menu a discesa per la selezione di un metodo di autenticazione Kafka.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/kafka-connection-authentication.png)
AWS Glue supporta il framework SASL (Simple Authentication and Security Layer) per l'autenticazione. Il framework SASL supporta vari meccanismi di autenticazione e AWS Glue offre i protocolli SCRAM (nome utente e password), GSSAPI (protocollo Kerberos) e PLAIN (nome utente e password).
Quando si sceglie un metodo di autenticazione dal menu a discesa, è possibile selezionare i seguenti metodi di autenticazione client:
+ Nessuno: nessuna autenticazione. Questo è utile se si crea una connessione a scopo di test.
+ SASL/SCRAM-SHA-512: scegli questo metodo di autenticazione per specificare le credenziali di autenticazione. Sono disponibili due opzioni:
+ Usa AWS Secrets Manager (consigliato): se selezioni questa opzione, puoi memorizzare le tue credenziali in AWS Secrets Manager e consentire AWS Glue l'accesso alle informazioni quando necessario. Specifica il segreto che memorizza le credenziali di autenticazione SSL o SASL.
![\[Lo screenshot mostra le opzioni per le credenziali di autenticazione se il metodo di autenticazione è SASL/SCRAM-SHA-512.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/kafka-connection-authentication-sha-512.png)
+ Fornisci direttamente nome utente e password.
+ SASL/GSSAPI (Kerberos): se si seleziona questa opzione, è possibile selezionare la posizione del file keytab, il file krb5.conf e immettere il nome principale Kerberos e il nome del servizio Kerberos. Le posizioni per il file keytab e il file krb5.conf devono trovarsi in una posizione Amazon S3. Poiché MSK non supporta ancora SASL/GSSAPI, questa opzione è disponibile solo per i cluster Apache Kafka gestiti dal cliente. Per ulteriori informazioni, consulta la [Documentazione di MIT Kerberos: keytab](https://web.mit.edu/kerberos/krb5-latest/doc/basic/keytab_def.html).
+ SASL/PLAIN - Scegliete questo metodo di autenticazione per specificare le credenziali di autenticazione. Sono disponibili due opzioni:
+ Usa AWS Secrets Manager (consigliato): se selezioni questa opzione, puoi memorizzare le tue credenziali in AWS Secrets Manager e consentire AWS Glue l'accesso alle informazioni quando necessario. Specifica il segreto che memorizza le credenziali di autenticazione SSL o SASL.
+ Fornisci direttamente nome utente e password.
+ Autenticazione client SSL: selezionando questa opzione, è possibile selezionare la posizione del keystore client Kafka navigando su Amazon S3. Facoltativamente, è possibile inserire la password del keystore del client Kafka e la password della chiave del client Kafka.
![\[Lo screenshot mostra l'opzione di crittografia se SSL è il metodo di autenticazione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/kafka-connection-authentication-ssl.png)
**Configurazione delle impostazioni di crittografia**
1. Se la connessione Kafka richiede una connessione SSL, seleziona la casella di controllo per **Require SSL connection (Connessione SSL necessaria)**. Tieni presente che la connessione non riesce se non può connettersi tramite SSL. SSL per la crittografia può essere utilizzato con qualsiasi metodo di autenticazione (SASL/SCRAM-SHA-512, SASL/GSSAPI, SASL/PLAINo SSL Client Authentication) ed è facoltativo.
Se il metodo di autenticazione è impostato su **Autenticazione client SSL**, questa opzione verrà selezionata automaticamente e verrà disattivata per evitare eventuali modifiche.
1. (Facoltativo). Scegli la posizione del certificato privato dell'autorità di certificazione (CA). Tieni presente che la posizione della certificazione deve trovarsi in una sede S3. Scegli **Browse (Sfoglia)** per scegliere il file da un bucket S3 collegato. Il percorso deve essere nel formato `s3://bucket/prefix/filename.pem`. Deve terminare con il nome del file e l'estensione .pem.
1. È possibile scegliere di saltare la convalida del certificato da un'autorità di certificazione (CA). Scegli la casella di controllo**Skip validation of certificate from certificate authority (CA)** (Salta la convalida del certificato da un'autorità di certificazione [CA]). Se questa casella non è selezionata, AWS Glue convalida i certificati per tre algoritmi:
+ SHA256withRSA
+ SHA384withRSA
+ SHA512withRSA
![\[Lo screenshot mostra le opzioni per la configurazione della crittografia, tra cui se richiedere o meno la connessione SSL, l'opzione per selezionare la posizione del certificato privato dall'autorità di certificazione (CA) e l'opzione per saltare la convalida del certificato dall'autorità di certificazione (CA).\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/kafka-connection-encryption.png)
**(Facoltativo) Opzioni di rete**
Di seguito sono riportate i passaggi opzionali per configurare VPC, sottorete e gruppi di sicurezza. Se il tuo AWS Glue processo deve essere eseguito su istanze Amazon EC2 in una sottorete di cloud privato virtuale (VPC), devi fornire ulteriori informazioni di configurazione specifiche per VPC.
1. Scegli il VPC (cloud privato virtuale) che contiene l'origine dati.
1. Scegli la sottorete nel VPC.
1. Scegli uno o più gruppi di sicurezza per consentire l'accesso all'archivio dati nella sottorete VPC. I gruppi di sicurezza sono associati all'ENI collegata alla sottorete. È necessario scegliere almeno un gruppo di sicurezza con una regola in entrata autoreferenziale per tutte le porte TCP.
![\[Lo screenshot mostra le opzioni di rete facoltative per VPC, sottorete e gruppi di sicurezza.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/kafka-connection-network-options.png)
# Creazione di processi con connettori personalizzati
Puoi utilizzare connettori e connessioni sia per i nodi di origine dati che per i nodi di destinazione dati in AWS Glue Studio.
**Topics**
+ [Creare processi che utilizzano un connettore per l'origine dati](#create-job-connectors)
+ [Configurare le proprietà di origine per i nodi che utilizzano connettori](#edit-connector-source)
+ [Configurare le proprietà di destinazione per i nodi che utilizzano connettori](#edit-connector-target)
## Creare processi che utilizzano un connettore per l'origine dati
Quando si crea un nuovo processo, puoi scegliere un connettore per l'origine dati e le destinazioni dati.
**Per creare un processo che utilizza connettori per l'origine dati o la destinazione dati**
1. Accedi a Console di gestione AWS e apri la AWS Glue Studio console all'indirizzo [https://console.aws.amazon.com/gluestudio/](https://console.aws.amazon.com/gluestudio/).
1. Nella pagina **Connectors ** (Connettori), nell'elenco di risorse **Your connections** (Le tue connessioni), scegli la connessione da utilizzare nel processo, quindi scegli **Create job** (crea processo).
In alternativa, nella pagina **Jobs (Processi) ** di AWS Glue Studio, sotto **Create job (Crea processo)**, scegli **Source and target added to the graph (Origine e destinazione aggiunti al grafico)**. Nell'elenco a discesa **Source** (Origine), scegli il connettore personalizzato che desideri utilizzare nel processo. Puoi anche scegliere un connettore per **Target** (Destinazione).
![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/create-job-data-sources-screenshot.png)
1. Scegli quindi **Create** (Crea) per aprire l'editor visivo dei processi.
1. Configura il nodo di origine dati, come descritto in [Configurare le proprietà di origine per i nodi che utilizzano connettori](#edit-connector-source).
1. Continua a creare il processo ETL aggiungendo trasformazioni, datastore aggiuntivi e destinazioni dati, come descritto in [Avvio di processi ETL visivi in AWS Glue Studio](edit-nodes-chapter.md).
1. Personalizza l'ambiente di esecuzione configurando le proprietà del processo, come descritto in [Modificare le proprietà del processo](managing-jobs-chapter.md#edit-jobs-properties).
1. Salva ed esegui il processo.
## Configurare le proprietà di origine per i nodi che utilizzano connettori
Dopo aver creato un processo che utilizza un connettore per l'origine dati, l'editor visivo dei processi mostra un grafico del processo con un nodo di origine dati configurato per il connettore. Devi configurare le proprietà dell'origine dati per tale nodo.
**Per configurare le proprietà di un nodo di origine dati che utilizza un connettore**
1. Scegli il nodo dell'origine dati del connettore nel grafico del processo oppure aggiungi un nuovo nodo e scegli il connettore per **Node type** (Tipo di nodo). Quindi, sulla destra, nel pannello dei dettagli dei nodi, scegli la scheda **Data source properties** (Proprietà dell'origine dati) se non è già selezionata.
![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-source-properties-connector-screenshot2.png)
1. Nella scheda **Data source properties** (Proprietà dell'origine dati), scegli la connessione da utilizzare per questo processo.
Inserisci le informazioni aggiuntive necessarie per ciascun tipo di connessione:
------
#### [ JDBC ]
+ **Data source input type** (Tipo di input dell'origine dati): scegli di specificare un nome di tabella o una query SQL come origine dati. A seconda del tipo, devi fornire le seguenti informazioni aggiuntive:
+ **Table name** (Nome tabella): il nome della tabella nell'origine dati. Se l'origine dati non utilizza la *tabella* dei termini, fornisci il nome di una struttura dati appropriata, come indicato dalle informazioni sull'utilizzo del connettore personalizzato (disponibili in Marketplace AWS).
+ **Filter predicate** (Predicato di filtro): una clausola di condizione da utilizzare durante la lettura dell'origine dati, simile a una clausola `WHERE`, che viene utilizzata per recuperare un sottoinsieme dei dati.
+ **Query code** (Codice query): inserisci una query SQL da utilizzare per recuperare un set di dati specifico dall'origine dati. Un esempio di query SQL di base è:
```
SELECT column_list FROM
table_name WHERE where_clause
```
+ **Schema**: poiché AWS Glue Studio utilizza le informazioni archiviate nella connessione per accedere all'origine dati anziché recuperare le informazioni sui metadati da una tabella del Data Catalog, devi fornire i metadati dello schema per l'origine dati. Scegli **Add schema (Aggiungi schema)** per aprire l'editor dello schema.
Per istruzioni su come utilizzare l'editor dello schema, consulta [Modifica dello schema in un nodo di trasformazione personalizzato](transforms-custom.md#transforms-custom-editschema).
+ **Partition column** (Colonna di partizione): (facoltativo) puoi scegliere di partizionare le letture dei dati fornendo valori per **Partition column** (Colonna di partizione), **Lower bound** (Limite inferiore), **Upper bound** (Limite superiore) e **Number of partitions** (Numero di partizioni).
I valori `lowerBound` e `upperBound` vengono utilizzati per decidere lo stride della partizione, non per filtrare le righe nella tabella. Tutte le righe della tabella vengono partizionate e restituite.
**Nota**
Il partizionamento delle colonne aggiunge una condizione di partizionamento aggiuntiva alla query utilizzata per leggere i dati. Quando si utilizza una query anziché un nome di tabella, è necessario verificare che la query funzioni con la condizione di partizionamento specificata. Ad esempio:
Se il formato della query è `"SELECT col1 FROM table1"`, testa la query aggiungendo una clausola `WHERE` alla fine della query che utilizza la colonna della partizione.
Se il formato della query è `"SELECT col1 FROM table1 WHERE col2=val"`, testa la query estendendo la clausola `WHERE` con `AND` e un'espressione che utilizza la colonna della partizione.
+ **Data type casting** (Casting del tipo di dati): se l'origine dati utilizza tipi di dati non disponibili in JDBC, utilizza questa sezione per specificare come convertire un tipo di dati dell'origine dati in tipi di dati JDBC. Puoi specificare fino a 50 conversioni di tipi di dati diverse. Tutte le colonne dell'origine dati che utilizzano lo stesso tipo di dati vengono convertite nello stesso modo.
Ad esempio, se nell'origine dati sono presenti tre colonne che utilizzano il tipo di dati `Float` e si indica che il tipo di dati `Float` deve essere convertito nel tipo di dati `String` JDBC, tutte e tre le colonne che utilizzano il tipo di dati `Float` vengono convertite in `String`.
+ **Job bookmark keys** (Chiavi di segnalibro di processo): i segnalibri del processo aiutano AWS Glue a mantenere le informazioni sullo stato e prevenire la rielaborazione dei dati precedenti. Specifica un'altra o più colonne come chiavi di segnalibro. AWS Glue Studio utilizza i tasti di segnalibro per tenere traccia dei dati già elaborati durante una precedente esecuzione del processo ETL. Tutte le colonne utilizzate per le chiavi di segnalibro personalizzati devono aumentare o diminuire in modo rigorosamente monotonico, ma sono ammessi spazi.
Se inserisci più chiavi di segnalibro, queste vengono combinate per formare una singola chiave composta. Una chiave di segnalibro di processo composta non deve contenere colonne duplicate. Se non si specificano le chiavi di segnalibro, AWS Glue Studio per impostazione predefinita utilizza la chiave primaria come chiave di segnalibro, a condizione che sia in ordine crescente o decrescente sequenzialmente (senza spazi vuoti). Se la tabella non dispone di una chiave primaria, ma la proprietà segnalibro di processo è abilitata, devi fornire chiavi personalizzate di segnalibro di processo. In caso contrario, la ricerca delle chiavi primarie da utilizzare come impostazione predefinita avrà esito negativo e l'esecuzione del processo avrà non riuscirà.
+ **Job bookmark keys sorting order** (Ordinamento delle chiavi di segnalibro di processo): scegli se i valori chiave vengono aumentati o diminuiti in sequenza.
------
#### [ Spark ]
+ **Schema**: poiché AWS Glue Studio utilizza le informazioni archiviate nella connessione per accedere all'origine dati anziché recuperare le informazioni sui metadati da una tabella del Data Catalog, devi fornire i metadati dello schema per l'origine dati. Scegli **Add schema (Aggiungi schema)** per aprire l'editor dello schema.
Per istruzioni su come utilizzare l'editor dello schema, consulta [Modifica dello schema in un nodo di trasformazione personalizzato](transforms-custom.md#transforms-custom-editschema).
+ **Connection options** (Opzioni di connessione): inserisci ulteriori coppie chiave-valore in base alle esigenze per fornire ulteriori informazioni o opzioni di connessione. Ad esempio, puoi inserire un nome di database, un nome di tabella, un nome utente e una password.
Ad esempio, per OpenSearch, si inseriscono le seguenti coppie chiave-valore, come descritto in: [Tutorial: utilizzo del AWS Glue connettore per Elasticsearch](tutorial-elastisearch-connector.md)
+ `es.net.http.auth.user` : `username`
+ `es.net.http.auth.pass` : `password`
+ `es.nodes` : `https://`
+ `es.port` : `443`
+ `path`: ``
+ `es.nodes.wan.only` : `true`
Per un esempio delle opzioni di connessione minime da usare, vedete lo script di test di esempio [MinimalSparkConnectorTest.scala](https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/development/Spark/MinimalSparkConnectorTest.scala) on GitHub, che mostra le opzioni di connessione che normalmente fornireste in una connessione.
------
#### [ Athena ]
+ **Table name** (Nome tabella): il nome della tabella nell'origine dati. Se utilizzi un connettore per leggere i log di CloudWatch Athena-log, devi inserire il nome della tabella. `all_log_streams`
+ **Athena schema name** (Nome schema Athena): scegli lo schema nell'origine dati Athena corrispondente al database che contiene la tabella. Se si utilizza un connettore per la lettura da CloudWatch Athena-logs, è necessario immettere un nome di schema simile a. `/aws/glue/name`
+ **Schema**: poiché AWS Glue Studio utilizza le informazioni archiviate nella connessione per accedere all'origine dati anziché recuperare le informazioni sui metadati da una tabella del Data Catalog, devi fornire i metadati dello schema per l'origine dati. Scegli **Add schema (Aggiungi schema)** per aprire l'editor dello schema.
Per istruzioni su come utilizzare l'editor dello schema, consulta [Modifica dello schema in un nodo di trasformazione personalizzato](transforms-custom.md#transforms-custom-editschema).
+ **Additional connection options** (Opzioni di connessione aggiuntive): inserisci ulteriori coppie chiave-valore in base alle esigenze per fornire ulteriori informazioni o opzioni di connessione.
[Per un esempio, vedi il `README.md` file in https://github.com/aws-samples/aws-glue-samples/. tree/master/GlueCustomConnectors/development/Athena](https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/development/Athena) Nei passaggi di questo documento, il codice di esempio mostra le opzioni di connessione minime richieste, che sono `tableName`, `schemaName` e `className`. L'esempio di codice specifica queste opzioni come parte della variabile `optionsMap`, ma puoi specificarle per la connessione e quindi utilizzarla.
------
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e dell'origine dati, puoi visualizzare lo schema dei dati risultante per l'origine dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. Lo schema visualizzato in questa scheda viene utilizzato da tutti i nodi figlio aggiunti al grafico del processo.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e dell'origine dati, puoi visualizzare il set di dati dall'origine dati scegliendo la scheda Data preview (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
## Configurare le proprietà di destinazione per i nodi che utilizzano connettori
Se usi un connettore per il tipo di destinazione dati, devi configurare le proprietà del nodo di destinazione dati.
**Per configurare le proprietà di un nodo di destinazione dati che utilizza un connettore**
1. Scegli il nodo di destinazione dati del connettore nel grafico del processo. Quindi, sulla destra, nel pannello dei dettagli dei nodi, scegli la scheda **Data target properties** (Proprietà della destinazione dati) se non è già selezionata.
1. Nella scheda **Data target properties** (Proprietà della destinazione dati), scegli la connessione da utilizzare per la scrittura nella destinazione.
Inserisci le informazioni aggiuntive necessarie per ciascun tipo di connessione:
------
#### [ JDBC ]
+ **Connection** (Connessione): scegli la connessione da utilizzare con il connettore. Per informazioni su come creare una connessione, vedi [Creazione di connessioni per i connettori](creating-connections.md).
+ **Table name** (Nome tabella): il nome della tabella nella destinazione dati. Se la destinazione dei dati non utilizza la *tabella* dei termini, fornite il nome di una struttura dati appropriata, come indicato dalle informazioni sull'utilizzo del connettore personalizzato (disponibili in Marketplace AWS).
+ **Batch size** (Dimensione batch): (facoltativo): immetti il numero di righe o record da inserire nella tabella di destinazione in un'unica operazione. Il valore predefinito è 1000 righe.
------
#### [ Spark ]
+ **Connection** (Connessione): scegli la connessione da utilizzare con il connettore. Se non hai creato una connessione in precedenza, scegli **Create connection** (Crea connessione) per crearne una. Per informazioni su come creare una connessione, vedi [Creazione di connessioni per i connettori](creating-connections.md).
+ **Connection options** (Opzioni di connessione): inserisci ulteriori coppie chiave-valore in base alle esigenze per fornire ulteriori informazioni o opzioni di connessione. Puoi inserire un nome di database, un nome di tabella, un nome utente e una password.
Ad esempio, per OpenSearch, si inseriscono le seguenti coppie chiave-valore, come descritto in: [Tutorial: utilizzo del AWS Glue connettore per Elasticsearch](tutorial-elastisearch-connector.md)
+ `es.net.http.auth.user` : `username`
+ `es.net.http.auth.pass` : `password`
+ `es.nodes` : `https://`
+ `es.port` : `443`
+ `path`: ``
+ `es.nodes.wan.only` : `true`
Per un esempio delle opzioni di connessione minime da usare, vedete lo script di test di esempio [MinimalSparkConnectorTest.scala](https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/development/Spark/MinimalSparkConnectorTest.scala) on GitHub, che mostra le opzioni di connessione che normalmente fornireste in una connessione.
------
1. Dopo aver configurato le proprietà del nodo e dell'origine dati, puoi visualizzare lo schema dei dati risultante per l'origine dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo.
# Gestione di connettori e connessioni
Per gestire i connettori e le connessioni, utilizza la pagina **Connessioni** di AWS Glue.
**Topics**
+ [Visualizzazione dei dettagli dei connettori e delle connessioni](#connector-details)
+ [Modifica di connettori e connessioni](#editing-connectors)
+ [Eliminazione di connettori e connessioni](#deleting-connectors)
+ [Annullare una sottoscrizione per un connettore](#cancel-subscription)
## Visualizzazione dei dettagli dei connettori e delle connessioni
Puoi visualizzare le informazioni di riepilogo sui connettori e sulle connessioni nelle tabelle delle risorse **Your connectors** (I tuoi connettori) e **Your connections** (Le tue connessioni) nella scheda **Connectors** (Connettori). Per visualizzare le informazioni dettagliate, procedi come segue.
**Per visualizzare i dettagli del connettore o della connessione**
1. Nella console AWS Glue Studio, scegli **Connectors (Connettori)** nel pannello di navigazione della console.
1. Scegli il connettore o la connessione di cui visualizzare le informazioni dettagliate.
1. Scegli **Actions** (Operazioni) e quindi **View details** (Visualizza i dettagli) per aprire la pagina relativa ai dettagli del connettore o della connessione.
1. Nella pagina prodotto, puoi scegliere di **modificare** o **eliminare** il connettore o la connessione.
+ Per i connettori, puoi scegliere **Create connection** (Crea connessione) per creare una nuova connessione che utilizza il connettore.
+ Per i connettori, puoi scegliere **Create job** (Crea processo) per creare un processo che utilizza il connettore.
## Modifica di connettori e connessioni
Per modificare le informazioni archiviate nei connettori e nelle connessioni, devi utilizzare la pagina **Connectors** (Connettori).
**Per modificare un connettore o una connessione**
1. Nella console AWS Glue Studio, scegli **Connectors (Connettori)** nel pannello di navigazione della console.
1. Scegli il connettore o la connessione da modificare.
1. Seleziona **Actions (Operazioni)**, quindi scegli **Edit (Modifica)**.
Puoi anche scegliere **View details** (Visualizza i dettagli) e nella pagina dei dettagli del connettore o della connessione scegliere **Edit** (Modifica).
1. Nella pagina **Edit connector** (Modifica connettore) o **Edit connection** (Modifica connessione), aggiorna le informazioni, quindi scegli **Save** (Salva).
## Eliminazione di connettori e connessioni
Per eliminare connettori e connessioni, devi utilizzare la pagina **Connectors** (Connettori). Eliminando un connettore, è necessario eliminare anche tutte le connessioni create per tale connettore.
**Come rimuovere i connettori da AWS Glue Studio**
1. Nella console AWS Glue Studio, scegli **Connectors (Connettori)** nel pannello di navigazione della console.
1. Scegli il connettore o la connessione da eliminare.
1. Scegli **Actions (Operazioni)**, quindi **Delete (Elimina)**.
Puoi anche scegliere **View details** (Visualizza i dettagli) e nella pagina dei dettagli del connettore o della connessione scegliere **Delete** (Elimina).
1. Conferma di voler rimuovere il connettore o la connessione inserendo **Delete** e quindi scegli **Delete** (Elimina).
Eliminando un connettore, è necessario eliminare anche tutte le connessioni create per tale connettore.
I processi che utilizzano una connessione eliminata non funzioneranno più. Puoi modificare i processi per utilizzare un datastore diverso oppure rimuoverli. Per informazioni su come eliminare un processo, consulta [Eliminazione dei processi](managing-jobs-chapter.md#delete-jobs).
Se elimini un connettore, la sottoscrizione per il connettore non viene annullata in Marketplace AWS. Per rimuovere una sottoscrizione per un connettore eliminato, segui le istruzioni riportate in [Annullare una sottoscrizione per un connettore](#cancel-subscription).
## Annullare una sottoscrizione per un connettore
Dopo aver eliminato le connessioni e il connettore daAWS Glue Studio, puoi annullare l'abbonamento Marketplace AWS se non ti serve più il connettore.
**Nota**
Se annulli la sottoscrizione a un connettore, il connettore o la connessione non vengono rimossi dall'account. Qualsiasi processo che utilizza il connettore e le connessioni correlate non sarà più in grado di utilizzare il connettore e avrà esito negativo.
Prima di annullare l'iscrizione o sottoscrivere nuovamente un connettore Marketplace AWS, è necessario eliminare le connessioni e i connettori esistenti associati a quel Marketplace AWS prodotto.
**Per annullare l'iscrizione a un connettore in Marketplace AWS**
1. Accedi alla Marketplace AWS console all'indirizzo [https://console.aws.amazon.com/marketplace.](https://console.aws.amazon.com/marketplace)
1. Scegli **Manage subscriptions** (Gestisci sottoscrizioni).
1. Nella pagina **Manage subscriptions** (Gestione degli abbonamenti), scegli **Manage** (Gestisci) accanto alla sottoscrizione del connettore che vuoi annullare.
1. Scegli **Actions** (Operazioni), quindi **Cancel Subscriptions** (Annulla sottoscrizione).
1. Seleziona la casella di controllo per acconsentire che le istanze in esecuzione siano addebitate all'account, quindi scegli **Yes, cancel subscription (Sì, annulla sottoscrizione)**.
# Sviluppo di connettori personalizzati
Puoi scrivere il codice che legge o scrive i dati nel datastore e formatta i dati per l'utilizzo con i processi AWS Glue Studio. Puoi creare connettori per datastore Spark, Athena e JDBC. Il codice di esempio pubblicato su GitHub fornisce una panoramica delle interfacce di base da implementare.
Per creare il codice del connettore è necessario un ambiente di sviluppo locale. Puoi usare qualsiasi IDE o anche solo un editor della riga di comando per scrivere il connettore. Esempi di ambienti di sviluppo includono:
+ Un ambiente Scala locale con una libreria Maven ETL AWS Glue locale, come descritto in [Sviluppo in locale con Scala](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-libraries.html#develop-local-scala) nella *Guida per gli sviluppatori di AWS Glue *.
+ IntelliJ IDE, scaricando l'IDE da. [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/)
**Topics**
+ [Sviluppo dei connettori Spark](#code-spark-connector)
+ [Sviluppo di connettori Athena](#code-athena-connector)
+ [Sviluppo di connettori JDBC](#code-jdbc-connector)
+ [Esempi di utilizzo di connettori personalizzati con AWS Glue Studio](#custom-connector-examples)
+ [AWS GlueSviluppo di connettori per Marketplace AWS](#code-marketplace-connector)
## Sviluppo dei connettori Spark
Puoi creare un connettore Spark con Spark DataSource API V2 (Spark 2.4) per leggere i dati.
**Per creare un connettore Spark personalizzato**
[Segui i passaggi nella libreria di AWS Glue GitHub esempio per lo sviluppo di connettori Spark, che si trova in/.md. https://github.com/aws-samples/ aws-glue-samples tree/master/GlueCustomConnectors/development/Spark/README](https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/development/Spark/README.md)
## Sviluppo di connettori Athena
Puoi creare un connettore Athena utilizzabile da AWS Glue e AWS Glue Studio per eseguire query su un'origine dati personalizzata.
**Per creare un connettore Athena personalizzato**
[Segui i passaggi nella libreria di AWS Glue GitHub esempio per lo sviluppo dei connettori Athena, che si trova in https://github.com/aws-samples/aws-glue-samples/. tree/master/GlueCustomConnectors/development/Athena](https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/development/Athena)
## Sviluppo di connettori JDBC
Puoi creare un connettore che utilizza JDBC per accedere ai datastore.
**Per creare un connettore JDBC personalizzato**
1. Installa le librerie runtime Spark AWS Glue nel tuo ambiente di sviluppo locale. Fate riferimento alle istruzioni nella libreria di AWS Glue GitHub esempio all'indirizzo [ https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/development/GlueSparkRuntime/README.md.](https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/development/GlueSparkRuntime/README.md)
1. Implementa il driver JDBC responsabile del recupero dei dati dall'origine dati. Fai riferimento alla [documentazione Java](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/) per Java SE 8.
Crea un punto di ingresso all'interno del tuo codice che AWS Glue Studio utilizza per individuare il connettore. Il campo **Class name** (Nome classe) dovrebbe essere il percorso completo del driver JDBC.
1. Usa l'API `GlueContext` per leggere i dati con il connettore. Se necessario, gli utenti possono aggiungere altre opzioni di input nella console AWS Glue Studio per configurare la connessione all'origine dati. Per un esempio di codice che mostra come leggere e scrivere su un database JDBC con un connettore JDBC personalizzato, vedete Valori Custom [e](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-market) ConnectionType. Marketplace AWS
## Esempi di utilizzo di connettori personalizzati con AWS Glue Studio
Fai riferimento ai seguenti blog per esempi di utilizzo di connettori personalizzati:
+ [Sviluppo, test e implementazione di connettori personalizzati per gli archivi dati con AWS Glue](https://aws.amazon.com/blogs/big-data/developing-testing-and-deploying-custom-connectors-for-your-data-stores-with-aws-glue/)
+ Apache Hudi: [Scrittura in tabelle Apache Hudi usando il connettore personalizzato AWS Glue](https://aws.amazon.com/blogs/big-data/writing-to-apache-hudi-tables-using-aws-glue-connector/)
+ Google BigQuery: [migrazione dei dati da Google BigQuery ad Amazon S3 AWS Glue](https://aws.amazon.com/blogs/big-data/migrating-data-from-google-bigquery-to-amazon-s3-using-aws-glue-custom-connectors/) tramite connettori personalizzati
+ Snowflake (JDBC): [Esecuzione di trasformazione dati con Snowflake e AWS Glue](https://aws.amazon.com/blogs/big-data/performing-data-transformations-using-snowflake-and-aws-glue/)
+ SingleStore: [Creazione di un sistema ETL rapido utilizzando e SingleStore AWS Glue](https://aws.amazon.com/blogs/big-data/building-fast-etl-using-singlestore-and-aws-glue/)
+ Salesforce: inserisci i dati [di Salesforce in Amazon S3 utilizzando il connettore personalizzato JDBC](https://aws.amazon.com/blogs/big-data/ingest-salesforce-data-into-amazon-s3-using-the-cdata-jdbc-custom-connector-with-aws-glue) con - CData AWS Glue
+ MongoDB: [Creazione di processi AWS Glue Spark ETL con Amazon DocumentDB (con compatibilità MongoDB) e MongoDB](https://aws.amazon.com/blogs/big-data/building-aws-glue-spark-etl-jobs-using-amazon-documentdb-with-mongodb-compatibility-and-mongodb/)
+ Amazon Relational Database Service (Amazon RDS): [crea offerte di lavoro AWS Glue Spark ETL introducendo i tuoi driver JDBC](https://aws.amazon.com/blogs/big-data/building-aws-glue-spark-etl-jobs-by-bringing-your-own-jdbc-drivers-for-amazon-rds/) per Amazon RDS
+ [MySQL (JDBC): /.scala https://github.com/aws-samples/ aws-glue-samples blob/master/GlueCustomConnectors/development/Spark/SparkConnectorMySQL](https://github.com/aws-samples/aws-glue-samples/blob/master/GlueCustomConnectors/development/Spark/SparkConnectorMySQL.scala)
## AWS GlueSviluppo di connettori per Marketplace AWS
In qualità di AWS partner, puoi creare connettori personalizzati e caricarli su Marketplace AWS per venderli ai AWS Glue clienti.
Il processo per lo sviluppo del codice del connettore è lo stesso dei connettori personalizzati, ma il processo di caricamento e verifica del codice del connettore è più dettagliato. Consulta le istruzioni contenute nella sezione [Creazione di connettori Marketplace AWS](https://github.com/aws-samples/aws-glue-samples/tree/master/GlueCustomConnectors/marketplace/publishGuide.pdf) disponibili sul GitHub sito Web.
# Restrizioni per l'utilizzo di connettori e connessioni in AWS Glue Studio
Quando utilizzi connettori personalizzati o connettori di Marketplace AWS, prendi nota delle seguenti restrizioni:
+ L'API TestConnection non è supportata con le connessioni create per i connettori personalizzati.
+ La crittografia delle password di connessione al catalogo dati non è supportata con connettori personalizzati.
+ Non è possibile utilizzare i segnalibri di processo se specifichi un predicato di filtro per un nodo di origine dati che utilizza un connettore JDBC.
+ La creazione di una connessione Marketplace non è supportata al di fuori AWS Glue Studio dell'interfaccia utente.