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à. # Connessioni JDBC Alcuni tipi di database, tipicamente relazionali, supportano la connessione tramite lo standard JDBC. Per ulteriori informazioni su JDBC, consulta la documentazione dell'API [Java JDBC](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/). AWS Glue supporta nativamente la connessione a determinati database tramite i relativi connettori JDBC: le librerie JDBC sono fornite nei job Glue Spark. AWS Quando ci si connette a questi tipi di database utilizzando le librerie do AWS Glue, si ha accesso a un set standard di opzioni. I valori JDBC connectionType includono quanto segue: + `"connectionType": "sqlserver"`: designa una connessione a un database Microsoft SQL Server. + `"connectionType": "mysql"`: designa una connessione al database MySQL. + `"connectionType": "oracle"`: designa una connessione a un database Oracle. + `"connectionType": "postgresql"`: designa una connessione al database PostgreSQL. + `"connectionType": "redshift"`: designa una connessione a un database Amazon Redshift. Per ulteriori informazioni, consulta [Connessioni Redshift](aws-glue-programming-etl-connect-redshift-home.md). La tabella seguente elenca le versioni dei driver JDBC supportate da AWS Glue. | Prodotto | Versioni dei driver JDBC per Glue 5.1 | Versioni dei driver JDBC per Glue 5.0 | Versioni del driver JDBC per Glue 4.0 | Versioni del driver JDBC per Glue 3.0 | Versioni del driver JDBC per Glue 0.9, 1.0, 2.0 | | --- | --- | --- | --- | --- | --- | | Microsoft SQL Server | 10.2.0 | 10.2,0 | 9,40 | 7.x | 6.x | | MySQL | 8,0,33 | 8,0,33 | 8.0.23 | 8.0.23 | 5.1 | | Banca dati Oracle | 23.3.0.23.09 | 23,3,023,09 | 21,7 | 21,1 | 11.2 | | PostgreSQL | 42,7,3 | 42,7,3 | 42,36 | 4,2,18 | 42.1.x | | Amazon Redshift\$1 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 | \$1 Per il tipo di connessione Amazon Redshift, tutte le altre name/value coppie di opzioni incluse nelle opzioni di connessione per una connessione JDBC, incluse le opzioni di formattazione, vengono passate direttamente allo SparkSQL sottostante. DataSource Nei lavori AWS Glue with Spark in AWS Glue 4.0 e versioni successive, il connettore nativo AWS Glue per Amazon Redshift utilizza l'integrazione Amazon Redshift per Apache Spark. Per ulteriori informazioni, consulta la pagina [Integrazione di Amazon Redshift per Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Nelle versioni precedenti, consulta la sezione [Amazon Redshift data source for Spark](https://github.com/databricks/spark-redshift). Per configurare Amazon VPC per la connessione ai datastore Amazon RDS tramite JDBC, consulta la pagina [Impostazione di Amazon VPC per le connessioni JDBC ai data store Amazon RDS su JDBC da AWS Glue](setup-vpc-for-glue-access.md). **Nota** AWS I Glue job vengono associati solo a una sottorete durante un'esecuzione. Ciò potrebbe influire sulla capacità di connettersi a più origini dati tramite lo stesso processo. Questo comportamento non è limitato alle origini JDBC. **Topics** + [Indicazioni di riferimento alle opzioni di connessione a JDBC](#aws-glue-programming-etl-connect-jdbc) + [Utilizzo di sampleQuery](#aws-glue-programming-etl-jdbc-samplequery) + [Utilizzo di un driver JDBC personalizzato](#aws-glue-programming-etl-jdbc-custom-driver) + [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md) + [Impostazione di Amazon VPC per le connessioni JDBC ai data store Amazon RDS su JDBC da AWS Glue](setup-vpc-for-glue-access.md) ## Indicazioni di riferimento alle opzioni di connessione a JDBC Se hai già definito una connessione AWS JDBC Glue, puoi riutilizzare le proprietà di configurazione in essa definite, come: url, user e password; quindi non devi specificarle nel codice come opzioni di connessione. Questa funzionalità è disponibile in AWS Glue 3.0 e versioni successive. A tale scopo, utilizza le seguenti proprietà di connessione: + `"useConnectionProperties"`: impostare su “true” per indicare che si desidera utilizzare la configurazione da una connessione. + `"connectionName"`: inserire il nome della connessione da cui recuperare la configurazione; la connessione deve essere definita nella stessa regione del processo. Utilizzare queste opzioni di connessione con connessioni JDBC: + `"url"`: (obbligatorio) l'URL JDBC per il database. + `"dbtable"`: (obbligatorio) la tabella database da cui leggere. Per gli archivi dati JDBC che supportano schemi all'interno di un database, specificare `schema.table-name`. Se non viene fornito alcuno schema, viene usato lo schema “pubblico” predefinito. + `"user"`: (obbligatorio) il nome utente da usare per la connessione. + `"password"`: (obbligatorio) la password da usare per la connessione. + (Opzionale) Le seguenti opzioni consentono di fornire un driver JDBC personalizzato. Usa queste opzioni se devi usare un driver che AWS Glue non supporta nativamente. I processi ETL possono utilizzare versioni di driver JDBC diverse per l'origine dati e la destinazione, anche se l'origine e la destinazione sono lo stesso prodotto di database. In questo modo è possibile eseguire la migrazione dei dati tra database di origine e di destinazione con versioni diverse. Per utilizzare queste opzioni, è necessario innanzitutto caricare il file JAR del driver JDBC su Amazon S3. + `"customJdbcDriverS3Path"`: il percorso Amazon S3 del driver JDBC personalizzato. + `"customJdbcDriverClassName"`: il nome della classe del driver JDBC. + `"bulkSize"`: (opzionale) utilizzato per configurare inserti paralleli per accelerare i carichi di massa nelle destinazioni JDBC. Specifica un valore intero per il grado di parallelismo da utilizzare durante la scrittura o l'inserimento di dati. Questa opzione è utile per migliorare le prestazioni delle scritture in database come Arch User Repository (AUR). + `"hashfield"`: (opzionale) una stringa utilizzata per specificare il nome di una colonna nella tabella JDBC da utilizzare per dividere i dati in partizioni durante la lettura da tabelle JDBC in parallelo. Fornire “hashfield” O “hashexpression”. Per ulteriori informazioni, consultare [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md). + `"hashexpression"`: (opzionale) una clausola SQL select che restituisce un numero intero. Utilizzata per suddividere i dati presenti in una tabella JDBC in partizioni durante la lettura da tabelle JDBC in parallelo. Fornire “hashfield” O “hashexpression”. Per ulteriori informazioni, consultare [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md). + `"hashpartitions"`: (opzionale) un numero intero positivo. Utilizzato per specificare il numero di letture parallele della tabella JDBC durante la lettura da tabelle JDBC in parallelo. Impostazione predefinita: 7. Per ulteriori informazioni, consultare [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md). + `"sampleQuery"`: (opzionale) un'istruzione di query SQL personalizzata. Utilizzata per specificare un sottoinsieme di informazioni in una tabella per recuperare un campione del contenuto della tabella. **Se configurato indipendentemente dai dati, può essere meno efficiente dei DynamicFrame metodi e causare timeout o errori di esaurimento della memoria.** Per ulteriori informazioni, consulta [Utilizzo di sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). + `"enablePartitioningForSampleQuery"`: (opzionale) un valore booleano. Valore predefinito: false. Utilizzato per abilitare la lettura da tabelle JDBC in parallelo durante la specificazione della `sampleQuery`. **Se impostato su true, `sampleQuery` deve terminare con «where» o «and» affinché AWS Glue aggiunga le condizioni di partizionamento.** Per ulteriori informazioni, consulta [Utilizzo di sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). + `"sampleSize"`: (opzionale) un numero intero positivo. Limita il numero di righe restituite dalla query di esempio. Funziona solo quando `enablePartitioningForSampleQuery` è true. Se il partizionamento non è abilitato, è invece necessario aggiungere direttamente `"limit x"` nella `sampleQuery` per limitare le dimensioni. Per ulteriori informazioni, consultare [Utilizzo di sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). ## Utilizzo di sampleQuery Questa sezione illustra come utilizzare `sampleQuery`, `sampleSize` e `enablePartitioningForSampleQuery`. `sampleQuery` può essere un modo efficace per campionare alcune righe del set di dati. Per impostazione predefinita, la query viene eseguita da un singolo esecutore. Se configurato indipendentemente dai dati, può essere meno efficiente dei DynamicFrame metodi e causare timeout o errori di esaurimento della memoria. Nelle pipeline ETL, l'esecuzione diretta di query SQL sul database sottostante è in genere necessaria solo per ottimizzare le prestazioni. Se si sta cercando di visualizzare in anteprima alcune righe del tuo set di dati, prendere in considerazione l'utilizzo di [show](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show). Se stai cercando di trasformare il tuo set di dati utilizzando SQL, prendi in considerazione l'utilizzo [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) per definire una trasformazione SparkSQL rispetto ai tuoi dati in DataFrame un modulo. Anche se la query può manipolare diverse tabelle, `dbtable` resta obbligatoria. **Utilizzo di SampleQuery per recuperare un campione della tabella** Quando si utilizza il comportamento SampleQuery predefinito per recuperare un campione dei dati, AWS Glue non prevede un throughput sostanziale, quindi esegue la query su un singolo esecutore. Per limitare i dati forniti e non causare problemi di prestazioni, consigliamo di fornire a SQL una clausola `LIMIT`. **Example Usare SampleQuery senza partizionamento** Il codice di esempio seguente mostra come utilizzare `sampleQuery` senza partizionamento. ``` //A full sql query statement. val query = "select name from $tableName where age > 0 limit 1" val connectionOptions = JsonOptions(Map( "url" -> url, "dbtable" -> tableName, "user" -> user, "password" -> password, "sampleQuery" -> query )) val dyf = glueContext.getSource("mysql", connectionOptions) .getDynamicFrame() ``` **Utilizzo di SampleQuery con set di dati più grandi** Se si sta leggendo un set di dati di grandi dimensioni, potrebbe essere necessario abilitare il partizionamento JDBC per interrogare una tabella in parallelo. Per ulteriori informazioni, consultare [Lettura in parallelo dalle tabelle JDBC](run-jdbc-parallel-read-job.md). Per utilizzare `sampleQuery` con partizionamento JDBC, impostare `enablePartitioningForSampleQuery` su true. L'attivazione di questa funzionalità richiede di apportare alcune modifiche alla `sampleQuery`. Quando si utilizza il partizionamento JDBC con`sampleQuery`, la query deve terminare con «where» o «and» affinché AWS Glue possa aggiungere le condizioni di partizionamento. Se si desidera limitare i risultati di SampleQuery durante la lettura da tabelle JDBC in parallelo, impostare il parametro `"sampleSize"` anziché specificare una clausola `LIMIT`. **Example Usare SampleQuery con partizionamento JDBC** Il codice di esempio seguente mostra come utilizzare `sampleQuery` con partizionamento JDBC. ``` //note that the query should end with "where" or "and" if use with JDBC partitioning. val query = "select name from $tableName where age > 0 and" //Enable JDBC partitioning by setting hashfield. //to use sampleQuery with partitioning, set enablePartitioningForSampleQuery. //use sampleSize to limit the size of returned data. val connectionOptions = JsonOptions(Map( "url" -> url, "dbtable" -> tableName, "user" -> user, "password" -> password, "hashfield" -> primaryKey, "sampleQuery" -> query, "enablePartitioningForSampleQuery" -> true, "sampleSize" -> "1" )) val dyf = glueContext.getSource("mysql", connectionOptions) .getDynamicFrame() ``` **Note e restrizioni:** Le query di esempio non possono essere utilizzate insieme ai segnalibri del processo. Lo stato del segnalibro verrà ignorato quando viene fornita la configurazione per entrambi. ## Utilizzo di un driver JDBC personalizzato Negli esempi di codice riportati di seguito viene illustrato come leggere e scrivere nei database JDBC con driver JDBC personalizzati. Essi dimostrano la lettura da una versione di un prodotto di database e la scrittura a una versione successiva dello stesso prodotto. ------ #### [ Python ] ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext, SparkConf from awsglue.context import GlueContext from awsglue.job import Job import time from pyspark.sql.types import StructType, StructField, IntegerType, StringType sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Construct JDBC connection options connection_mysql5_options = { "url": "jdbc:mysql://:3306/db", "dbtable": "test", "user": "admin", "password": "pwd"} connection_mysql8_options = { "url": "jdbc:mysql://:3306/db", "dbtable": "test", "user": "admin", "password": "pwd", "customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar", "customJdbcDriverClassName": "com.mysql.cj.jdbc.Driver"} connection_oracle11_options = { "url": "jdbc:oracle:thin:@//:1521/ORCL", "dbtable": "test", "user": "admin", "password": "pwd"} connection_oracle18_options = { "url": "jdbc:oracle:thin:@//:1521/ORCL", "dbtable": "test", "user": "admin", "password": "pwd", "customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/ojdbc10.jar", "customJdbcDriverClassName": "oracle.jdbc.OracleDriver"} # Read from JDBC databases with custom driver df_mysql8 = glueContext.create_dynamic_frame.from_options(connection_type="mysql", connection_options=connection_mysql8_options) # Read DynamicFrame from MySQL 5 and write to MySQL 8 df_mysql5 = glueContext.create_dynamic_frame.from_options(connection_type="mysql", connection_options=connection_mysql5_options) glueContext.write_from_options(frame_or_dfc=df_mysql5, connection_type="mysql", connection_options=connection_mysql8_options) # Read DynamicFrame from Oracle 11 and write to Oracle 18 df_oracle11 = glueContext.create_dynamic_frame.from_options(connection_type="oracle", connection_options=connection_oracle11_options) glueContext.write_from_options(frame_or_dfc=df_oracle11, connection_type="oracle", connection_options=connection_oracle18_options) ``` ------ #### [ Scala ] ``` import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.MappingSpec import com.amazonaws.services.glue.errors.CallSite import com.amazonaws.services.glue.util.GlueArgParser import com.amazonaws.services.glue.util.Job import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.DynamicFrame import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { val MYSQL_5_URI: String = "jdbc:mysql://:3306/db" val MYSQL_8_URI: String = "jdbc:mysql://:3306/db" val ORACLE_11_URI: String = "jdbc:oracle:thin:@//:1521/ORCL" val ORACLE_18_URI: String = "jdbc:oracle:thin:@//:1521/ORCL" // Construct JDBC connection options lazy val mysql5JsonOption = jsonOptions(MYSQL_5_URI) lazy val mysql8JsonOption = customJDBCDriverJsonOptions(MYSQL_8_URI, "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar", "com.mysql.cj.jdbc.Driver") lazy val oracle11JsonOption = jsonOptions(ORACLE_11_URI) lazy val oracle18JsonOption = customJDBCDriverJsonOptions(ORACLE_18_URI, "s3://amzn-s3-demo-bucket/ojdbc10.jar", "oracle.jdbc.OracleDriver") def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) // Read from JDBC database with custom driver val df_mysql8: DynamicFrame = glueContext.getSource("mysql", mysql8JsonOption).getDynamicFrame() // Read DynamicFrame from MySQL 5 and write to MySQL 8 val df_mysql5: DynamicFrame = glueContext.getSource("mysql", mysql5JsonOption).getDynamicFrame() glueContext.getSink("mysql", mysql8JsonOption).writeDynamicFrame(df_mysql5) // Read DynamicFrame from Oracle 11 and write to Oracle 18 val df_oracle11: DynamicFrame = glueContext.getSource("oracle", oracle11JsonOption).getDynamicFrame() glueContext.getSink("oracle", oracle18JsonOption).writeDynamicFrame(df_oracle11) Job.commit() } private def jsonOptions(url: String): JsonOptions = { new JsonOptions( s"""{"url": "${url}", |"dbtable":"test", |"user": "admin", |"password": "pwd"}""".stripMargin) } private def customJDBCDriverJsonOptions(url: String, customJdbcDriverS3Path: String, customJdbcDriverClassName: String): JsonOptions = { new JsonOptions( s"""{"url": "${url}", |"dbtable":"test", |"user": "admin", |"password": "pwd", |"customJdbcDriverS3Path": "${customJdbcDriverS3Path}", |"customJdbcDriverClassName" : "${customJdbcDriverClassName}"}""".stripMargin) } } ``` ------ # Lettura in parallelo dalle tabelle JDBC Puoi impostare le proprietà della tabella JDBC per permettere a AWS Glue di leggere i dati in parallelo. Quando imposti determinate proprietà, indichi a AWS Glue di eseguire query SQL parallele su partizioni logiche dei dati. Puoi controllare il partizionamento impostando un campo hash o un'espressione hash. Puoi anche controllare il numero di operazioni di lettura parallele usate per accedere ai dati. La lettura delle tabelle JDBC in parallelo è una tecnica di ottimizzazione che può migliorare le prestazioni. Per ulteriori informazioni sul processo di identificazione di quando questa tecnica è appropriata, consulta [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/parallelize-tasks.html) nella guida *sulle migliori pratiche per l'ottimizzazione delle prestazioni per i lavori di Apache Spark su AWS Glue AWS Prescriptive* Guidance. Per abilitare le letture parallele, puoi impostare coppie chiave/valore nel campo dei parametri della struttura della tabella. Utilizza la notazione JSON per impostare un valore per il campo parametri della tabella. Per ulteriori informazioni sulle modifiche delle proprietà di una tabella, consulta [Visualizzazione e gestione dei dettagli della tabella](tables-described.md#console-tables-details). Puoi anche abilitare le letture parallele chiamando i metodi ETL (Extract, Transform and Load, estrazione, trasformazione e caricamento) `create_dynamic_frame_from_options` e `create_dynamic_frame_from_catalog`. Per ulteriori informazioni sulla definizione delle opzioni in questi metodi, consulta [from\$1options](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_options) e [from\$1catalog](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog). Puoi usare questo metodo per le tabelle JDBC, ovvero la maggior parte delle tabelle i cui dati dai base costituiscono un datastore JDBC. Queste proprietà vengono ignorate quando viene eseguita la lettura delle tabelle Amazon Redshift e Amazon S3. **hashfield** Imposta `hashfield` sul nome di una colonna nella tabella JDBC da usare per dividere i dati in partizioni. Per ottenere risultati ottimali, questa colonna deve avere una distribuzione uniforme dei valori per distribuire i dati tra le partizioni. Questa colonna può contenere qualsiasi tipo di dati. AWS Glue genera query non sovrapposte eseguite in parallelo per leggere i dati partizionati in base a questa colonna. Ad esempio, se i dati sono distribuiti in modo uniforme in base al mese, è possibile usare la colonna `month` per leggere ogni mese di dati in parallelo. ``` 'hashfield': 'month' ``` AWS Glue crea una query per l'hashing del valore di campo a un numero di partizione ed esegue la query per tutte le partizioni in parallelo. Per usare la query personalizzata per partizionare la lettura di una tabella, fornisci un oggetto `hashexpression` al posto di un oggetto `hashfield`. **hashexpression** Imposta `hashexpression` su un'espressione SQL (conforme alla grammatica del motore di database JDBC) che restituisce un numero intero. Un'espressione semplice è il nome di qualsiasi colonna numerica nella tabella. AWS Glue genera query SQL per leggere i dati JDBC in parallelo usando `hashexpression` nella clausola `WHERE` per partizionare i dati. Ad esempio, è possibile usare la colonna numerica `customerID` per leggere i dati partizionati in base a un numero cliente. ``` 'hashexpression': 'customerID' ``` Per fare in modo che AWS Glue controlli il partizionamento, fornisci un oggetto `hashfield` al posto di un oggetto `hashexpression`. **hashpartitions** Imposta `hashpartitions` sul numero di letture parallele della tabella JDBC. Se questa proprietà non viene impostata, il valore predefinito è 7. Imposta, ad esempio, il numero di letture parallele su `5`, in modo che AWS Glue legga i dati con cinque query (o meno). ``` 'hashpartitions': '5' ``` # Impostazione di Amazon VPC per le connessioni JDBC ai data store Amazon RDS su JDBC da AWS Glue Quando si utilizza JDBC per connettersi ai database in Amazon RDS, è necessario eseguire una configurazione aggiuntiva. Per permettere la comunicazione tra i componenti AWS Glue e Amazon RDS, è necessario configurare l'accesso ai datastore Amazon RDS in Amazon VPC. Per permettere la comunicazione dei componenti di AWS Glue, specifica un gruppo di sicurezza con una regola per il traffico in entrata autoreferenziale per tutte le porte TCP. Creando una regola autoreferenziale, si può limitare l'origine allo stesso gruppo di sicurezza nel VPC. Una regola autoreferenziale non aprirà il VPC a tutte le reti. Il gruppo di sicurezza predefinito per il tuo VPC potrebbe già avere una regola autoreferenziata in entrata per ALL Traffic. **Per configurare l'accesso tra AWS Glue e gli archivi dati Amazon RDS** 1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. Nella console Amazon RDS, identificare i gruppi di sicurezza utilizzati per controllare l'accesso al database Amazon RDS. Nel riquadro di navigazione a sinistra, scegliere **Database**, poi selezionare l'istanza a cui ci si desidera connettersi dall'elenco nel riquadro principale. Nella pagina dei dettagli del database, individuare i **gruppi di sicurezza di VPC** nella scheda **Connettività e sicurezza**. 1. In base all'architettura di rete, identificate quale gruppo di sicurezza associato è meglio modificare per consentire l'accesso al servizio AWS Glue. Salva il suo nome, *database-security-group* per riferimenti futuri. Se non esiste un gruppo di sicurezza appropriato, seguire le istruzioni per [Fornire l'accesso all'istanza DB nel VPC creando un gruppo di sicurezza](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) nella documentazione relativa ad Amazon RDS. 1. Accedi a Console di gestione AWS e apri la console Amazon VPC all'indirizzo. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. Nella console Amazon VPC, identifica come eseguire l'aggiornamento. *database-security-group* Nel riquadro di navigazione a sinistra, scegli **Gruppi di sicurezza**, quindi seleziona *database-security-group* dall'elenco nel riquadro principale. 1. Identifica l'ID del gruppo di sicurezza per*database-security-group*,*database-sg-id*. Salvarlo per utilizzarlo in futuro. Nella pagina dei dettagli del gruppo di sicurezza, individuare l'**ID del gruppo di sicurezza**. 1. Modifica le regole in entrata per*database-security-group*, aggiungi una regola di autoreferenziazione per consentire ai AWS Glue componenti di comunicare. **In particolare, aggiungi o conferma l'esistenza di una regola in cui **Type** è`All TCP`, **Protocol** è`TCP`, **Port Range** include tutte le porte e Source è.** *database-sg-id* Verificare che il gruppo di sicurezza inserito per **Origine** sia lo stesso del gruppo di sicurezza in fase di modifica. Nella pagina dei dettagli del gruppo di sicurezza, selezionare **Modifica regole in entrata**. La regola in entrata è simile alla seguente: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/setup-vpc-for-glue-access.html) 1. Aggiungere le regole per il traffico in uscita. Nella pagina dei dettagli del gruppo di sicurezza, selezionare **Modifica regole in uscita**. Se il gruppo di sicurezza abilita tutto il traffico in uscita, non sono necessarie regole separate. Esempio: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/setup-vpc-for-glue-access.html) Se l'architettura di rete è progettata per limitare il traffico in uscita, creare le seguenti regole in uscita: Crea una regola autoreferenziale in cui **Type** è`All TCP`, **Protocol** è`TCP`, **Port Range** include tutte le porte e **Destination** è. *database-sg-id* Verificare che il gruppo di sicurezza inserito per **Destinazione** sia lo stesso del gruppo di sicurezza in fase di modifica. Se si utilizza un endpoint VPC Amazon S3, aggiungere una regola HTTPS per permettere il traffico dal VPC verso Amazon S3. Crea una regola in cui **Type** è`HTTPS`, **Protocol** is`TCP`, **Port Range** è `443` e **Destination** è l'ID dell'elenco di prefissi gestiti per l'endpoint gateway Amazon S3,. *s3-prefix-list-id* Per ulteriori informazioni sugli elenchi di prefissi e sugli endpoint gateway Amazon S3, consultare [Endpoint gateway per Amazon S3](https://docs.aws.amazon.com//vpc/latest/privatelink/vpc-endpoints-s3.html) nella documentazione di Amazon VPC. Ad esempio: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/setup-vpc-for-glue-access.html)