Connessioni JDBC - AWS Glue
Parametri di connessione JDBCUtilizzo di sampleQueryUtilizzo di un driver JDBC personalizzato

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 JDBC. AWS Glue supporta nativamente la connessione a determinati database tramite i relativi connettori JDBC; le librerie JDBC sono fornite nei processi AWS Glue Spark. 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.

Nella tabella seguente sono elencate le versioni dei driver JDBC supportate da AWS Glue.

Prodotto 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 9,40 7.x 6.x
MySQL 8.0.23 8.0.23 5.1
Oracle Database 21,7 21,1 11.2
PostgreSQL 42,36 4,2,18 42.1.x
MongoDB 4.7.2 4.0.0 2.0.0
Amazon Redshift* redshift-jdbc42-2.1.0.16 redshift-jdbc41-1.2.12.1017 redshift-jdbc41-1.2.12.1017

* Per il tipo di connessione Amazon Redshift, tutte le altre coppie nome/valore incluse nelle opzioni di connessione per una connessione JDBC, incluse le opzioni di formattazione, vengono trasmesse direttamente all'origine dati SparkSQL sottostante. Nei processi AWS Glue con Spark in AWS Glue 4.0 e versioni successive, il connettore nativo di 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. Nelle versioni precedenti, consulta la sezione Amazon Redshift data source for Spark.

Per configurare Amazon VPC per la connessione ai datastore Amazon RDS tramite JDBC, consulta la pagina Configurazione di Amazon VPC per connessioni JDBC agli archivi dati Amazon RDS da AWS Glue.

Nota

I processi AWS Glue sono 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.

Argomenti

Indicazioni di riferimento alle opzioni di connessione a JDBC

Se hai già definito una connessione JDBC AWS Glue, puoi riutilizzare le proprietà di configurazione in essa definite, come url, utente e password; pertanto, non è necessario specificarle nel codice come opzioni di connessione. Questa funzionalità è disponibile solo in AWS Glue 3.0 e versioni successive. A tale scopo, utilizza le seguenti proprietà di connessione:

  • "useConnectionProperties": impostalo su "true" per indicare che desideri utilizzare la configurazione da una connessione.

  • "connectionName": inserisci 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 i archivi dati JDBC che supportano schemi all'interno di un database, specifica 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.

  • (Facoltativo) Le seguenti opzioni consentono di fornire un driver JDBC personalizzato. Utilizzare queste opzioni se è necessario utilizzare un driver che AWS Glue non supporta in modo nativo.

    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": (Facoltativo) 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": (facoltativo) 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. Fornisci "hashfield" O "hashexpression". Per ulteriori informazioni, consulta Lettura in parallelo dalle tabelle JDBC.

  • "hashexpression": (facoltativo) 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. Fornisci "hashfield" O "hashexpression". Per ulteriori informazioni, consulta Lettura in parallelo dalle tabelle JDBC.

  • "hashpartitions": (facoltativo) 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, consulta Lettura in parallelo dalle tabelle JDBC.

  • "sampleQuery": (facoltativo) 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 metodi DynamicFrame, causando timeout o errori di esaurimento della memoria. Per ulteriori informazioni, consulta Utilizzo di sampleQuery.

  • "enablePartitioningForSampleQuery": (facoltativo) 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.

  • "sampleSize": (facoltativo) 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, consulta Utilizzo di 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 configurata indipendentemente dai dati, può essere meno efficiente dei metodi DynamicFrame, causando 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 stai cercando di visualizzare in anteprima alcune righe del tuo set di dati, prendi in considerazione l'utilizzo di show. Se stai cercando di trasformare il tuo set di dati utilizzando SQL, prendi in considerazione l'utilizzo di toDF per definire una trasformazione SparkSQL relativamente ai tuoi dati in un modulo DataFrame.

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 una velocità di trasmissione effettiva 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.

Esempio 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 stai leggendo un set di dati di grandi dimensioni, potrebbe essere necessario abilitare il partizionamento JDBC per interrogare una tabella in parallelo. Per ulteriori informazioni, consulta Lettura in parallelo dalle tabelle JDBC. Per utilizzare sampleQuery con partizionamento JDBC, imposta 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 aggiunga le condizioni di partizionamento.

Se desideri limitare i risultati di SampleQuery durante la lettura da tabelle JDBC in parallelo, imposta il parametro "sampleSize" anziché specificare una clausola LIMIT.

Esempio 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://<jdbc-host-name>:3306/db",
    "dbtable": "test",
    "user": "admin",
    "password": "pwd"}

connection_mysql8_options = {
    "url": "jdbc:mysql://<jdbc-host-name>:3306/db",
    "dbtable": "test",
    "user": "admin",
    "password": "pwd",
    "customJdbcDriverS3Path": "s3://DOC-EXAMPLE-BUCKET/mysql-connector-java-8.0.17.jar",
    "customJdbcDriverClassName": "com.mysql.cj.jdbc.Driver"}

connection_oracle11_options = {
    "url": "jdbc:oracle:thin:@//<jdbc-host-name>:1521/ORCL",
    "dbtable": "test",
    "user": "admin",
    "password": "pwd"}

connection_oracle18_options = {
    "url": "jdbc:oracle:thin:@//<jdbc-host-name>:1521/ORCL",
    "dbtable": "test",
    "user": "admin",
    "password": "pwd",
    "customJdbcDriverS3Path": "s3://DOC-EXAMPLE-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://<jdbc-host-name>:3306/db"
  val MYSQL_8_URI: String = "jdbc:mysql://<jdbc-host-name>:3306/db"
  val ORACLE_11_URI: String = "jdbc:oracle:thin:@//<jdbc-host-name>:1521/ORCL"
  val ORACLE_18_URI: String = "jdbc:oracle:thin:@//<jdbc-host-name>:1521/ORCL"

  // Construct JDBC connection options
  lazy val mysql5JsonOption = jsonOptions(MYSQL_5_URI)
  lazy val mysql8JsonOption = customJDBCDriverJsonOptions(MYSQL_8_URI, "s3://DOC-EXAMPLE-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://DOC-EXAMPLE-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)
  }
}