# Tipos e opções de conexão para ETL no AWS Glue para Spark
No AWS Glue Glue, vários métodos e transformações do PySpark e do Scala especificam o tipo de conexão usando um parâmetro `connectionType`. Eles especificam opções de conexão usando um parâmetro `connectionOptions` ou `options`.
O parâmetro `connectionType` pode usar os valores mostrados na tabela a seguir. Os valores do parâmetro `connectionOptions` (ou `options`) associados para cada tipo estão documentados nas seções a seguir. Salvo indicação em contrário, os parâmetros se aplicam quando a conexão é usada como fonte ou coletor.
Para obter um código de exemplo que demonstra a configuração e o uso de opções de conexão, consulte a página inicial de cada tipo de conexão.
| `connectionType` | Conecta-se a |
| --- | --- |
| [dynamodb](aws-glue-programming-etl-connect-dynamodb-home.md) | Banco de dados do [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) |
| [kinesis](aws-glue-programming-etl-connect-kinesis-home.md) | [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) |
| [S3 da3](aws-glue-programming-etl-connect-s3-home.md) | [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/) |
| [documentdb](aws-glue-programming-etl-connect-documentdb-home.md#aws-glue-programming-etl-connect-documentdb) | banco de dados do [Amazon DocumentDB (compatível com MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/) |
| [opensearch](aws-glue-programming-etl-connect-opensearch-home.md) | [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). |
| [redshift](aws-glue-programming-etl-connect-redshift-home.md) | Banco de dados do [Amazon Redshift](https://aws.amazon.com/redshift/) |
| [kafka](aws-glue-programming-etl-connect-kafka-home.md) | [Kafka](https://kafka.apache.org/) ou [Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) |
| [azurecosmos](aws-glue-programming-etl-connect-azurecosmos-home.md) | Azure Cosmos para NoSQL. |
| [azuresql](aws-glue-programming-etl-connect-azuresql-home.md) | Azure SQL. |
| [bigquery](aws-glue-programming-etl-connect-bigquery-home.md) | Google BigQuery. |
| [mongodb](aws-glue-programming-etl-connect-mongodb-home.md) | Banco de dados [MongoDB](https://www.mongodb.com/what-is-mongodb), incluindo MongoDB Atlas. |
| [sqlserver](aws-glue-programming-etl-connect-jdbc-home.md) | Banco de dados do Microsoft SQL Server (consulte [Conexões JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [mysql](aws-glue-programming-etl-connect-jdbc-home.md) | Banco de dados [MySQL](https://www.mysql.com/) (consulte [Conexões JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [oracle](aws-glue-programming-etl-connect-jdbc-home.md) | Banco de dados [Oracle](https://www.oracle.com/database/) (consulte [Conexões JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [postgresql](aws-glue-programming-etl-connect-jdbc-home.md) | Banco de dados [PostgreSQL](https://www.postgresql.org/) (consulte [Conexões JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [saphana](aws-glue-programming-etl-connect-saphana-home.md) | SAP HANA. |
| [snowflake](aws-glue-programming-etl-connect-snowflake-home.md) | Data lake do [Snowflake](https://www.snowflake.com/) |
| [teradata](aws-glue-programming-etl-connect-teradata-home.md) | Teradata Vantage. |
| [vertica](aws-glue-programming-etl-connect-vertica-home.md) | Vertica. |
| [custom.\$1](#aws-glue-programming-etl-connect-market) | Armazenamentos de dados do Spark, Athena ou JDBC (consulte [Valores de connectionType personalizados e AWS Marketplace](#aws-glue-programming-etl-connect-market) |
| [marketplace.\$1](#aws-glue-programming-etl-connect-market) | Armazenamentos de dados do Spark, Athena ou JDBC (consulte [Valores de connectionType personalizados e AWS Marketplace](#aws-glue-programming-etl-connect-market)) |
# Conexões do DynamoDB
É possível usar o AWS Glue para Spark para ler e gravar em tabelas no DynamoDB no AWS Glue. Conecte-se ao DynamoDB usando as permissões do IAM anexadas ao seu trabalho do AWS Glue. O AWS Glueoferece suporte à gravação de dados em uma tabela do DynamoDB em uma conta da AWS diferente. Para obter mais informações, consulte [Acesso a tabelas do DynamoDB entre contas e entre regiões](aws-glue-programming-etl-dynamo-db-cross-account.md).
O conector original do DynamoDB usa objetos Glue DynamicFrame para trabalhar com os dados extraídos do DynamoDB. AWS O Glue 5.0\$1 apresenta um [Conector do DynamoDB com suporte para Spark DataFrame](aws-glue-programming-etl-connect-dynamodb-dataframe-support.md) novo que fornece suporte nativo ao Spark DataFrame.
Além do conector de ETL para AWS Glue DynamoDB, é possível ler do DynamoDB usando o conector de exportação para DynamoDB. Esse conector invoca uma solicitação `ExportTableToPointInTime` do DynamoDB e a armazena no formato [DynamoDB JSON](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html) em um local do Amazon S3 fornecido por você. Em seguida, o AWS Glue cria um objeto DynamicFrame ao ler os dados do local de exportação do Amazon S3.
O gravador do DynamoDB é compatível com o AWS Glue versão 1.0 ou posterior. O conector de exportação do AWS Glue DynamoDB é compatível com o AWS Glue versão 2.0 ou posterior. O novo conector do DynamoDB baseado em DataFrame está disponível no AWS Glue versão 5.0 ou versões posteriores.
Para obter mais informações sobre o DynamoDB, consulte a documentação do [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/).
**nota**
O leitor de ETL do DynamoDB não é compatível com filtros ou predicados de aplicação.
## Configurar conexões do DynamoDB
Para se conectar ao DynamoDB via AWS Glue, conceda ao perfil do IAM associado ao seu trabalho do AWS Glue permissão para interagir com o DynamoDB. Para obter mais informações sobre as permissões necessárias para ler ou gravar no DynamoDB, consulte [Ações, recursos e chaves de condição para DynamoDB](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html) na documentação do IAM.
Nas seguintes situações, configurações adicionais podem ser necessárias:
+ Ao usar o conector de exportação do DynamoDB, você precisará configurar o IAM para que seu trabalho possa solicitar exportações de tabelas do DynamoDB. Além disso, você precisará identificar um bucket do Amazon S3 para a exportação e fornecer as permissões apropriadas no IAM para que o DynamoDB grave nele e para que seu trabalho do AWS Glue possa ler dele. Para obter mais informações, consulte [Solicitar uma exportação de tabela no DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/S3DataExport_Requesting.html).
+ Se sua tarefa do AWS Glue tiver requisitos específicos de conectividade da Amazon VPC, use o tipo de conexão `NETWORK` do AWS Glue para fornecer opções de rede. Como o acesso ao DynamoDB é autorizado pelo IAM, não há necessidade de um tipo de conexão AWS Glue DynamoDB.
## Ler e gravar no DynamoDB
Os exemplos de código a seguir mostram como fazer a leitura (via conector ETL) e gravação de tabelas do DynamoDB. Eles demonstram a leitura de uma tabela e a gravação em uma outra tabela.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame.from_options(
connection_type="dynamodb",
connection_options={"dynamodb.input.tableName": test_source,
"dynamodb.throughput.read.percent": "1.0",
"dynamodb.splits": "100"
}
)
print(dyf.getNumPartitions())
glue_context.write_dynamic_frame_from_options(
frame=dyf,
connection_type="dynamodb",
connection_options={"dynamodb.output.tableName": test_sink,
"dynamodb.throughput.write.percent": "1.0"
}
)
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.input.tableName" -> test_source,
"dynamodb.throughput.read.percent" -> "1.0",
"dynamodb.splits" -> "100"
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
val dynamoDbSink: DynamoDbDataSink = glueContext.getSinkWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.output.tableName" -> test_sink,
"dynamodb.throughput.write.percent" -> "1.0"
))
).asInstanceOf[DynamoDbDataSink]
dynamoDbSink.writeDynamicFrame(dynamicFrame)
Job.commit()
}
}
```
------
## Usar o conector de exportação do DynamoDB
O conector de exportação apresenta um melhor desempenho do que o conector de ETL quando o tamanho da tabela do DynamoDB é superior a 80 GB. Além disso, como a solicitação de exportação é conduzida fora dos processos do Spark em um trabalho do AWS Glue, você pode habilitar a [autoescalabilidade de trabalhos do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/auto-scaling.html) para poupar o uso de DPU durante a solicitação de exportação. Com o conector de exportação, você também não precisa configurar o número de divisões para o paralelismo do executor do Spark ou o percentual de leitura de throughput do DynamoDB.
**nota**
O DynamoDB tem requisitos específicos para invocar as solicitações `ExportTableToPointInTime`. Para mais informações, consulte [Solicitação de uma exportação de tabela no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Requesting.html). Por exemplo, para usar esse conector, é necessário que a Point-in-Time-Recovery (PITR – Recuperação em um ponto anterior no tempo) esteja habilitada na tabela. O conector do DynamoDB também é compatível com criptografia do AWS KMS para exportações do DynamoDB para o Amazon S3. O fornecimento de sua configuração de segurança na configuração do trabalho do AWS Glue habilita a criptografia do AWS KMS para uma exportação do DynamoDB. A chave do KMS precisa estar na mesma região do bucket do Amazon S3.
Observe que há cobranças adicionais para exportação do DynamoDB e custos de armazenamento do Amazon S3. Os dados exportados no Amazon S3 persistem após a conclusão de uma execução de trabalho, de modo que você possa reutilizá-los sem exportações adicionais do DynamoDB. Um requisito para o uso desse conector é que a recuperação a um ponto anterior no tempo (PITR) esteja habilitada para a tabela.
O conector de ETL e o conector de exportação do DynamoDB não são compatíveis com a aplicação de filtros ou predicados de aplicação na fonte do DynamoDB.
Os exemplos de código a seguir mostram como fazer a leitura (usando o conector de exportação) e imprimir o número de partições.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame.from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.export": "ddb",
"dynamodb.tableArn": test_source,
"dynamodb.s3.bucket": bucket_name,
"dynamodb.s3.prefix": bucket_prefix,
"dynamodb.s3.bucketOwner": account_id_of_bucket,
}
)
print(dyf.getNumPartitions())
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> test_source,
"dynamodb.s3.bucket" -> bucket_name,
"dynamodb.s3.prefix" -> bucket_prefix,
"dynamodb.s3.bucketOwner" -> account_id_of_bucket,
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
Job.commit()
}
}
```
------
Estes exemplos mostram como fazer a leitura (usando o conector de exportação) e imprimir o número de partições de uma tabela do AWS Glue Data Catalog que tenha uma classificação `dynamodb`:
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dynamicFrame = glue_context.create_dynamic_frame.from_catalog(
database=catalog_database,
table_name=catalog_table_name,
additional_options={
"dynamodb.export": "ddb",
"dynamodb.s3.bucket": s3_bucket,
"dynamodb.s3.prefix": s3_bucket_prefix
}
)
print(dynamicFrame.getNumPartitions())
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getCatalogSource(
database = catalog_database,
tableName = catalog_table_name,
additionalOptions = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.s3.bucket" -> s3_bucket,
"dynamodb.s3.prefix" -> s3_bucket_prefix
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
)
```
------
## Simplificar o uso do JSON de exportação do DynamoDB
As exportações do DynamoDB feitas com o conector de exportação para DynamoDB do AWS Glue resultam em arquivos JSON de estruturas aninhadas específicas. Para mais informações, consulte [Objetos de dados](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). O AWS Glue fornece uma transformação DynamicFrame, que pode desaninhar essas estruturas em uma forma mais fácil de usar para aplicações downstream.
A transformação pode ser invocada de duas formas. É possível definir a opção de conexão `"dynamodb.simplifyDDBJson"` com o valor `"true"` ao chamar um método para ler do DynamoDB. Você também pode chamar a transformação como um método disponível de forma independente na biblioteca do AWS Glue.
Considere o seguinte esquema gerado por uma exportação do DynamoDB:
```
root
|-- Item: struct
| |-- parentMap: struct
| | |-- M: struct
| | | |-- childMap: struct
| | | | |-- M: struct
| | | | | |-- appName: struct
| | | | | | |-- S: string
| | | | | |-- packageName: struct
| | | | | | |-- S: string
| | | | | |-- updatedAt: struct
| | | | | | |-- N: string
| |-- strings: struct
| | |-- SS: array
| | | |-- element: string
| |-- numbers: struct
| | |-- NS: array
| | | |-- element: string
| |-- binaries: struct
| | |-- BS: array
| | | |-- element: string
| |-- isDDBJson: struct
| | |-- BOOL: boolean
| |-- nullValue: struct
| | |-- NULL: boolean
```
A transformação `simplifyDDBJson` simplificará isso para:
```
root
|-- parentMap: struct
| |-- childMap: struct
| | |-- appName: string
| | |-- packageName: string
| | |-- updatedAt: string
|-- strings: array
| |-- element: string
|-- numbers: array
| |-- element: string
|-- binaries: array
| |-- element: string
|-- isDDBJson: boolean
|-- nullValue: null
```
**nota**
`simplifyDDBJson` só está disponível no AWS Glue 3.0 e versões posteriores. A transformação `unnestDDBJson` também está disponível para simplificar o JSON de exportação do DynamoDB. Incentivamos os usuários a fazer a transição de `unnestDDBJson` para `simplifyDDBJson`.
## Configurar o paralelismo nas operações do DynamoDB
Para aumentar a performance, é possível ajustar alguns parâmetros disponíveis para o conector do DynamoDB. Seu objetivo ao ajustar os parâmetros de paralelismo é maximizar o uso dos operadores do AWS Glue provisionados. Assim, se você precisar de mais performance, recomendamos aumentar a escala do seu trabalho horizontalmente aumentando o número de DPUs.
Você pode alterar o paralelismo em uma operação de leitura do DynamoDB usando o parâmetro `dynamodb.splits` ao utilizar o conector ETL. Ao ler com o conector de exportação, não é necessário configurar o número de divisões para o paralelismo do executor do Spark. Você pode alterar o paralelismo em uma operação de gravação do DynamoDB com `dynamodb.output.numParallelTasks`.
**Ler com o conector ETL do DynamoDB**
Recomendamos calcular `dynamodb.splits` com base no número máximo de trabalhadores definido em sua configuração de trabalho e no cálculo `numSlots` a seguir. Em caso de escalonamento automático, o número real de operadores disponíveis pode cair abaixo desse limite. Para obter mais informações sobre como definir o número máximo de trabalhadores, consulte **Número de trabalhadores** (`NumberOfWorkers`) em [Configurar propriedades de trabalho para trabalhos do Spark no AWS Glue](add-job.md).
+ `numExecutors = NumberOfWorkers - 1`
Para contextualizar, um executor é reservado para o driver do Spark, outros executores são usados para processar dados.
+ `numSlotsPerExecutor =`
------
#### [ AWS Glue 3.0 and later versions ]
+ `4` se `WorkerType` for `G.1X`
+ `8` se `WorkerType` for `G.2X`
+ `16` se `WorkerType` for `G.4X`
+ `32` se `WorkerType` for `G.8X`
------
#### [ AWS Glue 2.0 and legacy versions ]
+ `8` se `WorkerType` for `G.1X`
+ `16` se `WorkerType` for `G.2X`
------
+ `numSlots = numSlotsPerExecutor * numExecutors`
Recomendamos definir `dynamodb.splits` como o número de slots disponíveis, `numSlots`.
**Gravar no DynamoDB**
O parâmetro `dynamodb.output.numParallelTasks` é usado para determinar a WCU por tarefa do Spark, usando o seguinte cálculo:
`permittedWcuPerTask = ( TableWCU * dynamodb.throughput.write.percent ) / dynamodb.output.numParallelTasks`
O gravador do DynamoDB funcionará melhor se a configuração representar com precisão o número de tarefas do Spark gravadas no DynamoDB. Em alguns casos, talvez seja necessário substituir o cálculo padrão para aumentar o desempenho de gravação. Se você não especificar esse parâmetro, as WCU permitidas por tarefa do Spark serão calculadas automaticamente pela seguinte fórmula:
+
+ `numPartitions = dynamicframe.getNumPartitions()`
+ `numSlots` (conforme definido anteriormente nesta seção)
+ `numParallelTasks = min(numPartitions, numSlots)`
+ Exemplo 1. DPU=10, WorkerType=Standard. DynamicFrame de entrada tem 100 partições RDD.
+ `numPartitions = 100`
+ `numExecutors = (10 - 1) * 2 - 1 = 17`
+ `numSlots = 4 * 17 = 68`
+ `numParallelTasks = min(100, 68) = 68`
+ Exemplo 2. DPU=10, WorkerType=Standard. DynamicFrame de entrada tem 20 partições RDD.
+ `numPartitions = 20`
+ `numExecutors = (10 - 1) * 2 - 1 = 17`
+ `numSlots = 4 * 17 = 68`
+ `numParallelTasks = min(20, 68) = 20`
**nota**
Trabalhos em versões antigas do AWS Glue e aqueles que usam operadores Standard exigem métodos diferentes para calcular o número de slots. Se você precisar ajustar a performance desses trabalhos, recomendamos fazer a transição para as versões compatíveis do AWS Glue.
## Referência de opções de conexão do DynamoDB
Designa uma conexão com o Amazon DynamoDB.
As opções de conexão diferem para uma conexão da fonte e uma conexão do coletor.
### “connectionType”: “dynamodb” com o conector de ETL como fonte
Ao usar o conector de ETL para DynamoDB do AWS Glue, use as seguintes opções de conexão com `"connectionType": "dynamodb"` como fonte:
+ `"dynamodb.input.tableName"`: (obrigatório) a tabela do DynamoDB da qual fazer a leitura.
+ `"dynamodb.throughput.read.percent"`: (opcional) a porcentagem de unidades de capacidade de leitura (RCU) para usar. O padrão é definido como "0,5". Os valores aceitáveis são de "0,1" a "1,5", inclusive.
+ `0.5` representa a taxa de leitura padrão, o que significa que o AWS Glue tentará consumir metade da capacidade de leitura da tabela. Se você aumentar o valor acima de `0.5`, o AWS Glue aumentará a taxa de solicitação. Diminuir o valor abaixo de `0.5` reduz a taxa de solicitação de leitura. (A taxa de leitura real poderá variar, dependendo de fatores como se há uma distribuição de chaves uniformes na tabela do DynamoDB.)
+ Quando a tabela do DynamoDB está no modo sob demanda, o AWS Glue lida com a capacidade de leitura da tabela como 40.000. Para exportar uma tabela grande, recomendamos alternar sua tabela do DynamoDB para o modo sob demanda.
+ `"dynamodb.splits"`: (opcional) define em quantas divisões essa tabela do DynamoDB deve ser particionada ao fazer a leitura. O padrão é definido como "1". Os valores aceitáveis são de "1" a "1,000,000", inclusive.
`1` indica que não há paralelismo. É altamente recomendável que você especifique um valor maior para uma performance melhor usando a fórmula abaixo. Para obter mais informações sobre como definir adequadamente um valor, consulte [Configurar o paralelismo nas operações do DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.sts.roleArn"`: (opcional) o ARN da função do IAM a ser assumida para acesso entre contas. Esse parâmetro está disponível no AWS Glue 1.0 ou posterior.
+ `"dynamodb.sts.roleSessionName"`: (opcional) nome da sessão STS. O padrão é definido como “glue-dynamodb-read-sts-session”. Esse parâmetro está disponível no AWS Glue 1.0 ou posterior.
### “connectionType”: “dynamodb” com o conector de exportação para DynamoDB do AWS Glue como fonte
Use as seguintes opções de conexão com "connectionType": "dynamodb" como fonte ao usar o conector de exportação para DynamoDB do AWS Glue, que está disponível apenas para o AWS Glue versão 2.0 em diante:
+ `"dynamodb.export"`: (obrigatório) um valor de string:
+ Se definido como `ddb`, habilita o conector de exportação para DynamoDB do AWS Glue. Um novo `ExportTableToPointInTimeRequest` será invocado durante o trabalho do AWS Glue. Uma nova exportação será gerada com o local repassado de `dynamodb.s3.bucket` e `dynamodb.s3.prefix`.
+ Se definido como `s3`, habilita o conector de exportação para DynamoDB do AWS Glue, mas ignora a criação de uma nova exportação do DynamoDB. Em vez disso, usa o `dynamodb.s3.bucket` e `dynamodb.s3.prefix` como o local do Amazon S3 de uma exportação anterior dessa tabela.
+ `"dynamodb.tableArn"`: (obrigatório) a tabela do DynamoDB da qual fazer a leitura.
+ `"dynamodb.unnestDDBJson"`: (Opcional) Padrão: false. Valores válidos: booleano. Se definido como “true” (verdadeiro), executa uma transformação de desaninhamento da estrutura JSON do DynamoDB que está presente nas exportações. É um erro definir `"dynamodb.unnestDDBJson"` e `"dynamodb.simplifyDDBJson"` como verdadeiro ao mesmo tempo. No AWS Glue 3.0 e versões posteriores, recomendamos usar `"dynamodb.simplifyDDBJson"` para melhorar o comportamento ao simplificar os tipos de mapas do DynamoDB. Para obter mais informações, consulte [Simplificar o uso do JSON de exportação do DynamoDB](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.simplifyDDBJson"`: (Opcional) Padrão: false. Valores válidos: booleano. Se definido como “true” (verdadeiro), executa uma transformação para simplificar o esquema da estrutura JSON do DynamoDB que está presente nas exportações. Isso tem a mesma finalidade que a opção `"dynamodb.unnestDDBJson"`, mas fornece melhor suporte a tipos de mapas do DynamoDB ou até mesmo tipos de mapas aninhados em sua tabela do DynamoDB. Esse atributo só está disponível no AWS Glue 3.0 e versões posteriores. É um erro definir `"dynamodb.unnestDDBJson"` e `"dynamodb.simplifyDDBJson"` como verdadeiro ao mesmo tempo. Para obter mais informações, consulte [Simplificar o uso do JSON de exportação do DynamoDB](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.s3.bucket"`: (opcional) indica o local do bucket do Amazon S3 no qual o processo `ExportTableToPointInTime` do DynamoDB deve ser executado. O formato de arquivo para a exportação é DynamoDB JSON.
+ `"dynamodb.s3.prefix"`: (Opcional) indica o local do prefixo do Amazon S3 dentro do bucket do Amazon S3 no qual as cargas `ExportTableToPointInTime` do DynamoDB devem ser armazenadas. Se não houver a especificação de `dynamodb.s3.prefix` e `dynamodb.s3.bucket`, esses valores serão definidos por padrão para o local do diretório temporário especificado na configuração de trabalho do AWS Glue. Para mais informações, consulte [Parâmetros especiais usados pelo AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html).
+ `"dynamodb.s3.bucketOwner"`: indica o proprietário do bucket necessário para acesso entre contas do Amazon S3.
+ `"dynamodb.sts.roleArn"`: (opcional) o ARN do perfil do IAM a ser assumido para acesso entre contas e/ou acesso entre regiões para a tabela do DynamoDB. Observação: o mesmo ARN de função do IAM será usado para acessar o local do Amazon S3 especificado para a solicitação `ExportTableToPointInTime`.
+ `"dynamodb.sts.roleSessionName"`: (opcional) nome da sessão STS. O padrão é definido como “glue-dynamodb-read-sts-session”.
+ `"dynamodb.exportTime"` (Opcional) Valores válidos: strings representando instantes ISO-8601. Um momento no qual a exportação deve ser feita.
+ `"dynamodb.sts.region"`: (obrigatório se estiver fazendo uma chamada entre regiões usando um endpoint regional) a região que hospeda a tabela do DynamoDB que você deseja ler.
### “connectionType”: “dynamodb” com o conector de ETL como coletor
Use as seguintes opções de conexão com `"connectionType": "dynamodb"` como coletor:
+ `"dynamodb.output.tableName"`: (obrigatório) a tabela do DynamoDB na qual fazer a gravação.
+ `"dynamodb.throughput.write.percent"`: (opcional) a porcentagem de unidades de capacidade de gravação (WCU) para usar. O padrão é definido como "0,5". Os valores aceitáveis são de "0,1" a "1,5", inclusive.
+ `0.5` representa a taxa de gravação padrão, o que significa que o AWS Glue tentará consumir metade da capacidade de gravação da tabela. Se você aumentar o valor acima de 0,5, o AWS Glue aumentará a taxa de solicitação. Diminuir o valor abaixo de 0,5 reduz a taxa de solicitação de gravação. (A taxa de gravação real pode variar, dependendo de fatores como a existência de uma distribuição de chaves uniforme na tabela do DynamoDB.)
+ Quando a tabela do DynamoDB está no modo sob demanda, o AWS Glue lida com a capacidade de gravação da tabela como `40000`. Para importar uma tabela grande, recomendamos mudar sua tabela do DynamoDB para o modo sob demanda.
+ `"dynamodb.output.numParallelTasks"`: (opcional) define quantas tarefas simultâneas gravam no DynamoDB ao mesmo tempo. Usado para calcular as WCU permissivas por tarefa do Spark. Na maioria dos casos, o AWS Glue calculará um valor padrão razoável para esse valor. Para obter mais informações, consulte [Configurar o paralelismo nas operações do DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.output.retry"`: (opcional) define quantas novas tentativas realizamos quando há uma `ProvisionedThroughputExceededException` do DynamoDB. O padrão é definido como “10”.
+ `"dynamodb.sts.roleArn"`: (opcional) o ARN da função do IAM a ser assumida para acesso entre contas.
+ `"dynamodb.sts.roleSessionName"`: (opcional) nome da sessão STS. O padrão é definido como “glue-dynamodb-write-sts-session”.
# Acesso a tabelas do DynamoDB entre contas e entre regiões
AWS Glue Os trabalhos de ETL do oferecem suporte a acesso a tabelas do DynamoDB tanto entre regiões quanto entre contas. Os trabalhos de ETL do. AWS Glue suportam tanto a leitura de dados de uma tabela do DynamoDB de outra conta da AWS quanto a gravação de dados em uma tabela do DynamoDB de outra conta da AWS. O AWS Glue também suporta leitura de uma tabela do DynamoDB em outra região e gravação em uma tabela do DynamoDB em outra região. Esta seção fornece instruções sobre como configurar o acesso e fornece um script de exemplo.
Os procedimentos nesta seção fazem referência a um tutorial do IAM para criar uma função do IAM e conceder acesso à função. O tutorial também discute sobre como assumir uma função, mas aqui, em vez disso, você usará um script de trabalho para assumir a função no AWS Glue. Este tutorial também contém informações sobre práticas gerais entre contas. Para ver um exemplo, consulte o [Tutorial: Delegar acesso entre contas da AWS usando funções do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) no *Manual do usuário do IAM*.
## Criar um perfil
Siga o [passo 1 no tutorial](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-1) para criar uma função do IAM na conta A. Ao definir as permissões da função, você pode optar por anexar políticas existentes, como `AmazonDynamoDBReadOnlyAccess` ou `AmazonDynamoDBFullAccess`, para permitir que a função leia/grave do DynamoDB. O exemplo a seguir mostra a criação de uma função chamada `DynamoDBCrossAccessRole` com a política de permissão `AmazonDynamoDBFullAccess`.
## Conceder acesso ao perfil
Siga o [passo 2 no tutorial](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-2) no *Guia do usuário do IAM* para permitir que a conta B alterne para a função recém-criada. O exemplo a seguir cria uma nova política com a seguinte instrução:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/DynamoDBCrossAccessRole"
}
}
```
------
Em seguida, você pode anexar essa política ao grupo/função/usuário que deseja usar para acessar o DynamoDB.
## Assumir o perfil no script de trabalho do AWS Glue
Agora, você pode fazer login na conta B e criar um trabalho do AWS Glue. Para criar um trabalho, consulte as instruções em [Configurar propriedades de trabalho para trabalhos do Spark no AWS Glue](add-job.md).
No script de trabalho, você precisa usar o parâmetro `dynamodb.sts.roleArn` para assumir a função `DynamoDBCrossAccessRole`. Assumir essa função permite que você obtenha as credenciais temporárias, que precisam ser usadas para acessar o DynamoDB na conta B. Revise estes scripts de exemplo.
Para uma leitura entre contas entre regiões (conector ETL):
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-east-1",
"dynamodb.input.tableName": "test_source",
"dynamodb.sts.roleArn": ""
}
)
dyf.show()
job.commit()
```
Para uma leitura entre contas entre regiões (conector ELT):
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.export": "ddb",
"dynamodb.tableArn": "",
"dynamodb.sts.roleArn": ""
}
)
dyf.show()
job.commit()
```
Para uma leitura e gravação entre contas entre regiões:
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-east-1",
"dynamodb.input.tableName": "test_source"
}
)
dyf.show()
glue_context.write_dynamic_frame_from_options(
frame=dyf,
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-west-2",
"dynamodb.output.tableName": "test_sink",
"dynamodb.sts.roleArn": ""
}
)
job.commit()
```
# Conector do DynamoDB com suporte para Spark DataFrame
O conector do DynamoDB com suporte para Spark DataFrame permite ler e gravar em tabelas no DynamoDB usando as APIs do Spark DataFrame. As etapas de configuração do conector são as mesmas do conector baseado em DynamicFrame e podem ser encontradas [aqui.](aws-glue-programming-etl-connect-dynamodb-home.md#aws-glue-programming-etl-connect-dynamodb-configure)
Para carregar na biblioteca de conectores baseada em DataFrame, certifique-se de conectar uma conexão do DynamoDB ao trabalho do Glue.
**nota**
Atualmente, a interface de usuário do console do Glue não oferece suporte à criação de uma conexão do DynamoDB. Você pode usar a CLI do Glue ([CreateConnection](https://docs.aws.amazon.com/cli/latest/reference/glue/create-connection.html)) para criar uma conexão do DynamoDB:
```
aws glue create-connection \
--connection-input '{ \
"Name": "my-dynamodb-connection", \
"ConnectionType": "DYNAMODB", \
"ConnectionProperties": {}, \
"ValidateCredentials": false, \
"ValidateForComputeEnvironments": ["SPARK"] \
}'
```
Ao criar a conexão do DynamoDB, você pode anexá-la ao seu trabalho do Glue via CLI ([CreateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/create-job.html), [UpdateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/update-job.html)) ou diretamente na página “Detalhes do trabalho”:
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/dynamodb-dataframe-connector.png)
Ao garantir que uma conexão com o DYNAMODB Type esteja conectada ao seu trabalho do Glue, é possível usar as seguintes operações de leitura, gravação e exportação do conector baseado em DataFrame.
## Ler e gravar no DynamoDB com o conector baseado em DataFrame
Os exemplos de código a seguir mostram como ler e gravar em tabelas do DynamoDB por meio do conector baseado em DataFrame. Eles demonstram a leitura de uma tabela e a gravação em uma outra tabela.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
spark = glueContext.spark_session
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
# Read from DynamoDB
df = spark.read.format("dynamodb") \
.option("dynamodb.input.tableName", "test-source") \
.option("dynamodb.throughput.read.ratio", "0.5") \
.option("dynamodb.consistentRead", "false") \
.load()
print(df.rdd.getNumPartitions())
# Write to DynamoDB
df.write \
.format("dynamodb") \
.option("dynamodb.output.tableName", "test-sink") \
.option("dynamodb.throughput.write.ratio", "0.5") \
.option("dynamodb.item.size.check.enabled", "true") \
.save()
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val spark = glueContext.getSparkSession
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val df = spark.read
.format("dynamodb")
.option("dynamodb.input.tableName", "test-source")
.option("dynamodb.throughput.read.ratio", "0.5")
.option("dynamodb.consistentRead", "false")
.load()
print(df.rdd.getNumPartitions)
df.write
.format("dynamodb")
.option("dynamodb.output.tableName", "test-sink")
.option("dynamodb.throughput.write.ratio", "0.5")
.option("dynamodb.item.size.check.enabled", "true")
.save()
job.commit()
}
}
```
------
## Usar a exportação do DynamoDB por meio do conector baseado em DataFrame
A operação de exportação é preferida à operação de leitura para tamanhos de tabela do DynamoDB maiores que 80 GB. Os exemplos de código a seguir mostram como ler de uma tabela, exportar para o S3 e imprimir o número de partições por meio do conector baseado em DataFrame.
**nota**
A funcionalidade de exportação do DynamoDB está disponível por meio do objeto `DynamoDBExport` do Scala. Os usuários do Python podem acessá-la por meio da interoperabilidade JVM do Spark ou usar o AWS SDK para Python (Boto3) com a API `ExportTableToPointInTime` do DynamoDB.
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.{GlueArgParser, Job}
import org.apache.spark.SparkContext
import glue.spark.dynamodb.DynamoDBExport
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val spark = glueContext.getSparkSession
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val options = Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> "arn:aws:dynamodb:us-east-1:123456789012:table/my-table",
"dynamodb.s3.bucket" -> "my-s3-bucket",
"dynamodb.s3.prefix" -> "my-s3-prefix",
"dynamodb.simplifyDDBJson" -> "true"
)
val df = DynamoDBExport.fullExport(spark, options)
print(df.rdd.getNumPartitions)
df.count()
Job.commit()
}
}
```
------
## Opções de configuração
### Opções de leitura
| Opção | Descrição | Padrão |
| --- | --- | --- |
| dynamodb.input.tableName | Nome da tabela do DynamoDB (obrigatório) | - |
| dynamodb.throughput.read | As unidades de capacidade de leitura (RCU) a serem usadas. Se não for especificada, dynamodb.throughput.read.ratio é usado para cálculo. | - |
| dynamodb.throughput.read.ratio | A proporção de unidades de capacidade de leitura (RCU) para uso | 0,5 |
| dynamodb.table.read.capacity | A capacidade de leitura da tabela sob demanda usada para calcular o throughput. Esse parâmetro é efetivo somente em tabelas de capacidade sob demanda. O padrão é aquecer as unidades de leitura de throughput. | - |
| dynamodb.splits | Define quantos segmentos são usados em operações de verificação paralela. Se não for fornecido, o conector calculará um valor padrão razoável. | - |
| dynamodb.consistentRead | Se deve usar leituras altamente consistentes | FALSE |
| dynamodb.input.retry | Define quantas tentativas fazemos quando há uma exceção que pode ser repetida. | 10 |
### Opções de gravação
| Opção | Descrição | Padrão |
| --- | --- | --- |
| dynamodb.output.tableName | Nome da tabela do DynamoDB (obrigatório) | - |
| dynamodb.throughput.write | Unidades de capacidade de gravação (WCU) a serem usadas. Se não for especificada, dynamodb.throughput.write.ratio é usado para cálculo. | - |
| dynamodb.throughput.write.ratio | A proporção de unidades de capacidade de gravação (WCU) a serem usadas | 0,5 |
| dynamodb.table.write.capacity | A capacidade de gravação da tabela sob demanda usada para calcular o throughput. Esse parâmetro é efetivo somente em tabelas de capacidade sob demanda. O padrão é aquecer as unidades de gravação de throughput. | - |
| dynamodb.item.size.check.enabled | Se verdadeiro, o conector calcula o tamanho do item e aborta se o tamanho exceder o tamanho máximo, antes de gravar na tabela do DynamoDB. | TRUE |
| dynamodb.output.retry | Define quantas tentativas fazemos quando há uma exceção que pode ser repetida. | 10 |
### Opções de exportação
| Opção | Descrição | Padrão |
| --- | --- | --- |
| dynamodb.export | Se definido como ddb, habilita o conector de exportação para DynamoDB do AWS Glue, onde um novo ExportTableToPointInTimeRequet será invocado durante o trabalho do AWS Glue. Uma nova exportação será gerada com o local repassado de dynamodb.s3.bucket e dynamodb.s3.prefix. Se definido como s3, habilita o conector de exportação do AWS Glue DynamoDB, mas ignora a criação de uma nova exportação do DynamoDB. Em vez disso, usa o dynamodb.s3.bucket e dynamodb.s3.prefix como o local do Amazon S3 de uma exportação anterior dessa tabela. | ddb |
| dynamodb.tableArn | A tabela do DynamoDB da qual se deseja ler os dados. Necessário se dynamodb.export estiver definido como ddb. | |
| dynamodb.simplifyDDBJson | Se definido como true, executa uma transformação para simplificar o esquema da estrutura JSON do DynamoDB que está presente nas exportações. | FALSE |
| dynamodb.s3.bucket | O bucket do S3 para armazenar dados temporários durante a exportação do DynamoDB (obrigatório) | |
| dynamodb.s3.prefix | O prefixo do S3 para armazenar dados temporários durante a exportação do DynamoDB | |
| dynamodb.s3.bucketOwner | Indica o proprietário do bucket necessário para acesso entre contas do Amazon S3 | |
| dynamodb.s3.sse.algorithm | Tipo de criptografia usada no bucket em que os dados temporários serão armazenados. Os valores válidos são AES256 e KMS. | |
| dynamodb.s3.sse.kmsKeyId | O ID da chave gerenciada do AWS KMS usada para criptografar o bucket do S3 onde os dados temporários serão armazenados (se aplicável). | |
| dynamodb.exportTime | Um momento no qual a exportação deve ser feita. Valores válidos: strings representando instantes ISO-8601. | |
### Opções gerais
| Opção | Descrição | Padrão |
| --- | --- | --- |
| dynamodb.sts.roleArn | O ARN do perfil do IAM a ser assumido para acesso entre contas. | - |
| dynamodb.sts.roleSessionName | Nome da sessão do STS | glue-dynamodb-sts-session |
| dynamodb.sts.region | Região do cliente STS (para suposição de perfil entre regiões) | Igual à opção region |
# Conexões do Kinesis
É possível usar uma conexão do Kinesis para ler e gravar o Amazon Kinesis Data Streams usando informações armazenadas em uma tabela do Data Catalog ou fornecendo informações para acessar diretamente o fluxo de dados. Você pode ler informações do Kinesis em um Spark DataFrame e depois convertê-las em um Glue DynamicFrame AWS. Você pode gravar DynamicFrames no Kinesis em um formato JSON. Se você acessar diretamente o fluxo de dados, use essas opções para fornecer as informações sobre como acessar o fluxo de dados.
Se você usar `getCatalogSource` ou `create_data_frame_from_catalog` para consumir registros de uma fonte de transmissão do Kinesis, o trabalho tem o banco de dados do catálogo de dados e as informações de nome da tabela, e pode usá-los para obter alguns parâmetros básicos para leitura da fonte de transmissão do Kinesis. Se você usar `getSource`, `getSourceWithFormat`, `createDataFrameFromOptions` ou `create_data_frame_from_options`, será necessário especificar esses parâmetros básicos usando as opções de conexão descritas aqui.
Você pode especificar as opções de conexão para o Kinesis usando os seguintes argumentos para os métodos especificados na classe `GlueContext`.
+ Scala
+ `connectionOptions`: usar com `getSource`, `createDataFrameFromOptions`, `getSink`
+ `additionalOptions`: usar com `getCatalogSource`, `getCatalogSink`
+ `options`: usar com `getSourceWithFormat`, `getSinkWithFormat`
+ Python
+ `connection_options`: usar com `create_data_frame_from_options`, `write_dynamic_frame_from_options`
+ `additional_options`: usar com `create_data_frame_from_catalog`, `write_dynamic_frame_from_catalog`
+ `options`: usar com `getSource`, `getSink`
Para notas e restrições sobre trabalhos de ETL de streaming, consulte [Notas e restrições sobre ETL de transmissão](add-job-streaming.md#create-job-streaming-restrictions).
## Configurar o Kinesis
Para ler um fluxo de dados do Kinesis em uma trabalho do AWS Glue Spark, você precisará de alguns pré-requisitos:
+ Se for leitura, o trabalho do AWS Glue deve ter permissões IAM do nível de acesso de leitura ao fluxo de dados do Kinesis.
+ Se for gravação, o trabalho do AWS Glue deve ter permissões IAM do nível de acesso de gravação ao fluxo de dados do Kinesis.
Em certos casos, você precisará configurar pré-requisitos adicionais:
+ Se o trabalho do AWS Glue estiver configurado com **conexões de rede adicionais** (normalmente para se conectar a outros conjuntos de dados) e uma dessas conexões fornecer **opções de rede** da Amazon VPC, isso direcionará o trabalho para se comunicar pela Amazon VPC. Nesse caso, você também precisará configurar o fluxo de dados do Kinesis para se comunicar pela Amazon VPC. É possível fazer isso criando um endpoint da VPC de interface entre a Amazon VPC e o fluxo de dados do Kinesis. Para obter mais informações, consulte [Using Kinesis Data Streams with Interface VPC Endpoints](https://docs.aws.amazon.com//streams/latest/dev/vpc.html).
+ Ao especificar Amazon Kinesis Data Streams em outra conta, você deve configurar os perfis e políticas para permitir o acesso entre contas. Para obter mais informações, consulte [Exemplo: Ler de uma transmissão do Kinesis em outra conta](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html).
Para obter mais informações sobre pré-requisitos de trabalho de ETL de streaming, consulte [Trabalhos de transmissão de ETL no AWS Glue](add-job-streaming.md).
## Exemplo: ler de fluxos do Kinesis
### Exemplo: ler de fluxos do Kinesis
Usado em conjunto com [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Exemplo para fonte de transmissão do Amazon Kinesis:
```
kinesis_options =
{ "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream",
"startingPosition": "TRIM_HORIZON",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options)
```
## Exemplo: gravação em streams do Kinesis
### Exemplo: ler de fluxos do Kinesis
Usado em conjunto com [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Exemplo para fonte de transmissão do Amazon Kinesis:
```
kinesis_options =
{ "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream",
"startingPosition": "TRIM_HORIZON",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options)
```
## Referência de opções de conexão do Kinesis
Designa opções de conexão para o Amazon Kinesis Data Streams.
Use as seguintes opções de conexão para fontes de dados de transmissão do Kinesis:
+ `"streamARN"` (obrigatório) usado para leitura/gravação. O ARN do fluxo de dados do Kinesis.
+ `"classification"` (Obrigatório para leitura) Usado para leitura. O formato de arquivo usado pelos dados no registro. Obrigatório, a menos que fornecido por meio do catálogo de dados.
+ `"streamName"` (opcional) usado para leitura. O nome de um fluxo de dados do Kinesis de onde ler. Usado com `endpointUrl`.
+ `"endpointUrl"` (opcional) usado para leitura. Padrão: “https://kinesis.us-east-1.amazonaws.com” O endpoint AWS do stream do Kinesis. Você não precisa alterar isso, a menos que esteja se conectando a uma região especial.
+ `"partitionKey"` (opcional) usado para gravação. A chave de partição do Kinesis usada na produção de registros.
+ `"delimiter"` (opcional) usado para leitura. O separador de valores usado quando a `classification` é CSV. O padrão é "`,`".
+ `"startingPosition"`: (opcional) usado para leitura. A posição inicial no fluxo de dados do Kinesis de onde ler os dados. Os valores possíveis são `"latest"`, `"trim_horizon"`, `"earliest"` ou uma string de timestamp no formato UTC no padrão `yyyy-mm-ddTHH:MM:SSZ` (onde `Z` representa um desvio do fuso horário UTC com \$1/-). Por exemplo: "2023-04-04T08:00:00-04:00"). O valor padrão é `"latest"`. Observação: a string de timestamp no formato UTC para `"startingPosition"` é compatível somente com a versão 4.0 ou posterior do AWS Glue.
+ `"failOnDataLoss"`: (Opcional) Falha na tarefa se algum fragmento ativo estiver ausente ou expirado. O valor padrão é `"false"`.
+ `"awsSTSRoleARN"`: (opcional) usado para leitura/gravação. O nome de recurso da Amazon (ARN) da função a ser assumida com o uso do AWS Security Token Service (AWS STS). Essa função deve ter permissões para descrever ou ler operações de registro para o fluxo de dados do Kinesis. Você deve usar esse parâmetro ao acessar um fluxo de dados em uma conta diferente. Usado em conjunto com `"awsSTSSessionName"`.
+ `"awsSTSSessionName"`: (opcional) usado para leitura/gravação. Um identificador para a sessão que assume a função usando o AWS STS. Você deve usar esse parâmetro ao acessar um fluxo de dados em uma conta diferente. Usado em conjunto com `"awsSTSRoleARN"`.
+ `"awsSTSEndpoint"`: (Opcional) O AWS STS endpoint a ser usado ao se conectar ao Kinesis com uma função assumida. Isso permite usar o AWS STS endpoint regional em uma VPC, o que não é possível com o endpoint global padrão.
+ `"maxFetchTimeInMs"`: (opcional) usado para leitura. O tempo máximo para o executor do trabalho ler registros referentes ao lote atual do fluxo de dados do Kinesis especificado em milissegundos (ms). Várias chamadas de API `GetRecords` podem ser feitas nesse período. O valor padrão é `1000`.
+ `"maxFetchRecordsPerShard"`: (opcional) usado para leitura. O número máximo de registros a serem obtidos por fragmento no fluxo de dados do Kinesis por microlote. Observação: o cliente poderá exceder esse limite se o trabalho de streaming já tiver lido registros extras do Kinesis (na mesma chamada get-records). Se `maxFetchRecordsPerShard` precisa ser rigoroso, então precisa ser um múltiplo de `maxRecordPerRead`. O valor padrão é `100000`.
+ `"maxRecordPerRead"`: (opcional) usado para leitura. O número máximo de registros a serem obtidos por fragmento no fluxo de dados do Kinesis em cada operação `getRecords`. O valor padrão é `10000`.
+ `"addIdleTimeBetweenReads"`: (opcional) usado para leitura. Adiciona um atraso de tempo entre duas operações `getRecords`. O valor padrão é `"False"`. Essa opção só pode ser configurada para o Glue versão 2.0 e posterior.
+ `"idleTimeBetweenReadsInMs"`: (opcional) usado para leitura. O atraso mínimo entre duas operações , especificado em ms. O valor padrão é `1000`. Essa opção só pode ser configurada para o Glue versão 2.0 e posterior.
+ `"describeShardInterval"`: (opcional) usado para leitura. O intervalo de tempo mínimo entre duas chamadas de API `ListShards` para que seu script considere a refragmentação. Para obter mais informações, consulte [Estratégias para refragmentação](https://docs.aws.amazon.com//streams/latest/dev/kinesis-using-sdk-java-resharding-strategies.html) no *Guia do desenvolvedor do Amazon Kinesis Data Streams*. O valor padrão é `1s`.
+ `"numRetries"`: (opcional) usado para leitura. O número máximo de novas tentativas para solicitações de API do Kinesis Data Streams. O valor padrão é `3`.
+ `"retryIntervalMs"`: (opcional) usado para leitura. O período de espera (especificado em ms) antes de repetir a chamada da API Kinesis Data Streams. O valor padrão é `1000`.
+ `"maxRetryIntervalMs"`: (opcional) usado para leitura. O período de espera máximo (especificado em ms) entre duas tentativas de uma chamada de API Kinesis Data Streams. O valor padrão é `10000`.
+ `"avoidEmptyBatches"`: (opcional) usado para leitura. Evita a criação de um trabalho de micro lote vazio verificando se há dados não lidos no fluxo de dados do Kinesis antes de o lote ser iniciado. O valor padrão é `"False"`.
+ `"schema"`: (Obrigatório quando inferSchema é definido como false): usado para leitura. O esquema a ser usado para processar a carga. Se a classificação for `avro`, o esquema fornecido deverá estar no formato de esquema Avro. Se a classificação não for `avro`, o esquema fornecido deverá estar no formato de esquema DDL.
Veja a seguir alguns exemplos de esquema.
------
#### [ Example in DDL schema format ]
```
`column1` INT, `column2` STRING , `column3` FLOAT
```
------
#### [ Example in Avro schema format ]
```
{
"type":"array",
"items":
{
"type":"record",
"name":"test",
"fields":
[
{
"name":"_id",
"type":"string"
},
{
"name":"index",
"type":
[
"int",
"string",
"float"
]
}
]
}
}
```
------
+ `"inferSchema"`: (opcional) usado para leitura. O valor padrão é "false". Se definido como “true”, o esquema será detectado em runtime com base na carga útil em `foreachbatch`.
+ `"avroSchema"`: (Obsoleto) Usado para leitura. Parâmetro usado para especificar um esquema de dados Avro quando o formato Avro é usado. Esse parâmetro foi descontinuado. Use o parâmetro `schema`.
+ `"addRecordTimestamp"`: (opcional) usado para leitura. Quando essa opção for definida como "true", a saída de dados conterá uma coluna adicional denominada "\$1\$1src\$1timestamp" que indica a hora que o registro correspondente é recebido pelo fluxo. O valor padrão é "false". Essa opção é compatível com o AWS Glue versão 4.0 ou posterior.
+ `"emitConsumerLagMetrics"`: (opcional) usado para leitura. Quando a opção for definida como "true" (verdadeira), para cada lote, serão emitidas métricas durante o período entre a hora que o registro mais antigo é recebido pelo tópico e a hora que ele chega ao AWS Glue para o CloudWatch. O nome da métrica é "glue.driver.streaming.maxConsumerLagInMs". O valor padrão é "false". Essa opção é compatível com o AWS Glue versão 4.0 ou posterior.
+ `"fanoutConsumerARN"`: (opcional) usado para leitura. O ARN de um consumidor de fluxo do Kinesis para o fluxo especificado em `streamARN`. Usado para habilitar o modo de distribuição avançada para a conexão do Kinesis. Para obter mais informações sobre como consumir um fluxo do Kinesis com distribuição avançada, consulte [Usar distribuição avançada nas tarefas de streaming do Kinesis](aws-glue-programming-etl-connect-kinesis-efo.md).
+ `"recordMaxBufferedTime"` (opcional) usado para gravação. Padrão: 1000 (ms). Tempo máximo em que um registro é armazenado em buffer enquanto espera para ser gravado.
+ `"aggregationEnabled"` (opcional) usado para gravação. Padrão: true. Especifica se os registros devem ser agregados antes de serem enviados para o Kinesis.
+ `"aggregationMaxSize"` (opcional) usado para gravação. Padrão: 51200 (bytes) Se um registro for maior que esse limite, ele ignorará o agregador. Nota: O Kinesis impõe um limite de 50 KB no tamanho do registro. Se você definir isso além de 50 KB, registros grandes serão rejeitados pelo Kinesis.
+ `"aggregationMaxCount"` (opcional) usado para gravação. Padrão: 4294967295. O número máximo de itens a serem retornados em um registro agregado.
+ `"producerRateLimit"` (opcional) usado para gravação. Padrão: 150 (%). Limita o throughput por fragmento enviado por um único produtor (como seu trabalho), como uma porcentagem do limite de back-end.
+ `"collectionMaxCount"` (opcional) usado para gravação. Padrão: 500. Número máximo de itens a serem compactados em uma solicitação PutRecords.
+ `"collectionMaxSize"` (opcional) usado para gravação. Padrão: 5242880 (bytes) Quantidade máxima de dados a serem enviados com uma solicitação PutRecords.
# Usar distribuição avançada nas tarefas de streaming do Kinesis
Um consumidor de distribuição avançada pode receber registros de um fluxo do Kinesis com um throughput dedicado que pode ser maior que o dos consumidores comuns. Isso é feito otimizando o protocolo de transferência usado para fornecer dados a um consumidor do Kinesis, como o seu trabalho. [Para obter mais informações sobre distribuição avançada do Kinesis, consulte a documentação do Kinesis](https://docs.aws.amazon.com//streams/latest/dev/enhanced-consumers.html).
No modo de distribuição avançada, as opções de conexão `maxRecordPerRead` e `idleTimeBetweenReadsInMs` não se aplicam mais, pois esses parâmetros não são configuráveis quando se usa o fan-out aprimorado. As opções de configuração para novas tentativas funcionam conforme descrito.
Use os procedimentos a seguir para habilitar e desabilitar a distribuição avançada para seu trabalho de streaming. Você deve registrar um consumidor de fluxo para cada trabalho que consuma dados do fluxo.
**Para permitir um maior consumo de distribuição avançada no trabalho:**
1. Registre um consumidor de fluxo para o trabalho usando a API do Kinesis. Siga as instruções para *register a consumer with enhanced fan-out using the Kinesis Data Streams API* na [documentação do Kinesis](https://docs.aws.amazon.com//streams/latest/dev/building-enhanced-consumers-api). Você só precisará seguir a primeira etapa: chamar [RegisterStreamConsumer](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RegisterStreamConsumer.html). Sua solicitação deve retornar um ARN, *consumerARN*.
1. Defina a opção de conexão `fanoutConsumerARN` como *consumerARN* nos argumentos do método de conexão.
1. Reinicie seu trabalho.
**Para desabilitar o consumo de distribuição avançada no trabalho:**
1. Remova a opção de conexão `fanoutConsumerARN` da sua chamada de método.
1. Reinicie seu trabalho.
1. Siga as instruções para *deregister a consumer* na [documentação do Kinesis](https://docs.aws.amazon.com/streams/latest/dev/building-enhanced-consumers-console.html). Essas instruções se aplicam ao console, mas também podem ser obtidas por meio da API Kinesis. Para obter mais informações sobre o cancelamento do registro de consumidores de fluxo por meio da API do Kinesis, consulte [DeregisterStreamConsumer](https://docs.aws.amazon.com//kinesis/latest/APIReference/API_DeregisterStreamConsumer.html) na documentação do Kinesis.
# Conexões do Amazon S3
Você pode usar o AWS Glue para Spark para ler e gravar arquivos no Amazon S3. O AWS Glue para Spark é compatível com muitos formatos de dados comuns armazenados no Amazon S3 prontos para uso, incluindo CSV, Avro, JSON, Orc e Parquet. Para obter mais informações sobre os formatos de dados compatíveis, consulte [Opções de formato de dados para entradas e saídas no AWS Glue para Spark](aws-glue-programming-etl-format.md). Cada formato de dados pode ser compatível um conjunto diferente de atributos do AWS Glue. Consulte a página do seu formato de dados para obter os detalhes específicos da compatibilidade com atributos. Além disso, você pode ler e gravar arquivos versionados armazenados nas estruturas de data lake do Hudi, Iceberg e do Delta Lake. Para obter mais informações sobre estruturas de data lake, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Com o AWS Glue, você pode particionar os objetos do Amazon S3 em uma estrutura de pastas durante a gravação e depois recuperá-los por partição para melhorar a performance usando uma configuração simples. Você também pode definir a configuração para agrupar arquivos pequenos ao transformar seus dados, para melhorar a performance. Você pode ler e gravar arquivos `bzip2` e `gzip` no Amazon S3.
**Topics**
+ [Configurar conexões do S3](#aws-glue-programming-etl-connect-s3-configure)
+ [Referência de opções de conexão do Amazon S3](#aws-glue-programming-etl-connect-s3)
+ [Sintaxes de conexão obsoletas para formatos de dados](#aws-glue-programming-etl-connect-legacy-format)
+ [Excluir classes de armazenamento do Amazon S3](aws-glue-programming-etl-storage-classes.md)
+ [Gerenciar partições para saída de ETL no AWS Glue](aws-glue-programming-etl-partitions.md)
+ [Ler arquivos de entrada em grupos maiores](grouping-input-files.md)
+ [Endpoints da Amazon VPC para o Amazon S3](vpc-endpoints-s3.md)
## Configurar conexões do S3
Para se conectar ao Amazon S3 em um trabalho do AWS Glue com Spark, você precisará de alguns pré-requisitos:
+ O trabalho do AWS Glue deve ter permissões do IAM para buckets relevantes do Amazon S3.
Em certos casos, você precisará configurar pré-requisitos adicionais:
+ Ao configurar o acesso entre contas, os controles de acesso apropriados no bucket do Amazon S3.
+ Por motivos de segurança, você pode optar por rotear suas solicitações do Amazon S3 por meio de uma Amazon VPC. Essa abordagem pode introduzir desafios de largura de banda e disponibilidade. Para obter mais informações, consulte [Endpoints da Amazon VPC para o Amazon S3](vpc-endpoints-s3.md).
## Referência de opções de conexão do Amazon S3
Designa uma conexão com o Amazon S3.
Como o Amazon S3 gerencia arquivos em vez de tabelas, além de especificar as propriedades de conexão fornecidas neste documento, você precisará especificar configurações adicionais sobre seu tipo de arquivo. Você especifica essas informações por meio de opções de formato de dados. Para obter mais informações sobre essas opções de formato, consulte [Opções de formato de dados para entradas e saídas no AWS Glue para Spark](aws-glue-programming-etl-format.md). Você também pode especificar essas informações fazendo a integração com o catálogo de dados do AWS Glue.
Para obter um exemplo da distinção entre opções de conexão e opções de formato, considere como o método [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) usa `connection_type`, `connection_options`, `format` e `format_options`. Esta seção discute especificamente os parâmetros fornecidos às `connection_options`.
Use as seguintes opções de conexão com `"connectionType": "s3"`:
+ `"paths"`: (obrigatório) uma lista de caminhos do Amazon S3 dos quais fazer a leitura.
+ `"exclusions"`: (Opcional) Uma string contendo uma lista JSON de padrões glob de estilo Unix padrões para excluir. Por exemplo, `"[\"**.pdf\"]"` exclui todos os arquivos PDF. Para obter mais informações sobre a sintaxe glob compatível com o AWS Glue, consulte [Incluir e excluir padrões](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude).
+ `"compressionType"`: ou "`compression`": (opcional) especifica como os dados são compactados. Use `"compressionType"` para fontes do Amazon S3 e `"compression"` para destinos do Amazon S3. Isso geralmente não é necessário se os dados tem uma extensão de arquivo padrão. Os possíveis valores são `"gzip"` e `"bzip2"`). Formatos de compactação adicionais podem ser compatíveis com formatos específicos. Para obter os detalhes específicos da compatibilidade com atributos, consulte a página do seu formato de dados.
+ `"groupFiles"`: (opcional) o agrupamento de arquivos é ativado por padrão quando a entrada contiver mais de 50.000 arquivos. Para habilitar o agrupamento com menos de 50.000 arquivos, defina esse parâmetro como `"inPartition"`. Para desabilitar o agrupamento quando houver mais de 50.000 arquivos, defina esse parâmetro como `"none"`.
+ `"groupSize"`: (Opcional) O tamanho do grupo de destino em bytes. O padrão é calculado com base no tamanho de dados de entrada e o tamanho de seu cluster. Quando há menos de 50.000 arquivos de entrada, `"groupFiles"` deve ser definido como `"inPartition"` para poder entrar em vigor.
+ `"recurse"`: (Opcional) Se definido como verdadeiro, recursivamente lê arquivos em todos os subdiretórios de acordo com os caminhos especificados.
+ `"maxBand"`: (opcional, avançado) essa opção controla a duração, em milissegundos, após a qual a listagem `s3` provavelmente será consistente. Os arquivos com carimbos de data e hora de modificação que estão dentro dos últimos `maxBand` milissegundos são rastreados principalmente ao usar `JobBookmarks` para considerar a consistência final do Amazon S3. A maioria dos usuários não precisa definir essa opção. O valor padrão é 900.000 milissegundos, ou 15 minutos.
+ `"maxFilesInBand"`: (opcional, avançado) essa opção especifica o número máximo de arquivos que devem ser salvos dos últimos `maxBand` segundos. Se esse número for excedido, os arquivos extras são ignorados e apenas processados na próxima execução do trabalho. A maioria dos usuários não precisa definir essa opção.
+ `"isFailFast"`: (opcional) essa opção determina se um trabalho de ETL do AWS Glue lança exceções de análise do leitor. Se definido como `true`, os trabalhos falham rapidamente se quatro tentativas da tarefa do Spark falharem em analisar os dados corretamente.
+ `"catalogPartitionPredicate"`: (opcional) usado para leitura. O conteúdo de uma cláusula SQL `WHERE`. Usado ao ler tabelas do catálogo de dados com uma quantidade muito grande de partições. Recupera partições correspondentes dos índices do catálogo de dados. Usado com `push_down_predicate`, uma opção do método [create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog) (e outros métodos similares). Para obter mais informações, consulte [Filtragem do lado do servidor usando predicados de partição de catálogo](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
+ `"partitionKeys"`: (opcional) usado para gravação. Uma matriz de strings de rótulo da coluna. O AWS Glue particionará os dados conforme especificado por essa configuração. Para obter mais informações, consulte [Gravar partições](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-writing).
+ `"excludeStorageClasses"`: (opcional) usado para leitura. Uma matriz de strings especificando as classes de armazenamento do Amazon S3. O AWS Glue excluirá objetos do Amazon S3 com base nessa configuração. Para obter mais informações, consulte [Excluir classes de armazenamento do Amazon S3](aws-glue-programming-etl-storage-classes.md).
## Sintaxes de conexão obsoletas para formatos de dados
Certos formatos de dados podem ser acessados usando a sintaxe de um tipo de conexão específico. Essa sintaxe está obsoleta. Em seu lugar, recomendamos que você especifique os formatos usando o tipo de conexão `s3` e as opções de formato fornecidas em [Opções de formato de dados para entradas e saídas no AWS Glue para Spark](aws-glue-programming-etl-format.md).
### “connectionType”: “orc”
Designa uma conexão para arquivos armazenados no Amazon S3 no formato de arquivo [Apache Hive Optimized Row Columnar (ORC)](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC).
Use as seguintes opções de conexão com `"connectionType": "orc"`:
+ `paths`: (obrigatório) uma lista de caminhos do Amazon S3 dos quais fazer a leitura.
+ *(Outras opções de pares de nome/valor)*: qualquer opção adicional, incluindo opções de formatação, são transmitidas diretamente à `DataSource` do SparkSQL.
### "connectionType": "parquet"
Designa uma conexão com arquivos armazenados no Amazon S3 no formato de arquivo [Apache Parquet](https://parquet.apache.org/docs/).
Use as seguintes opções de conexão com `"connectionType": "parquet"`:
+ `paths`: (obrigatório) uma lista de caminhos do Amazon S3 dos quais fazer a leitura.
+ *(Outras opções de pares de nome/valor)*: qualquer opção adicional, incluindo opções de formatação, são transmitidas diretamente à `DataSource` do SparkSQL.
# Excluir classes de armazenamento do Amazon S3
Se você estiver executando trabalhos de ETL do AWS Glue que leiam arquivos ou partições do Amazon Simple Storage Service (Amazon S3), poderá excluir alguns tipos de classe de armazenamento do Amazon S3.
As seguintes classes de armazenamento estão disponíveis no Amazon S3:
+ `STANDARD`: para armazenamento de uso geral de dados acessados com frequência.
+ `INTELLIGENT_TIERING`: para dados com padrões de acesso desconhecidos ou inconstantes.
+ `STANDARD_IA` e `ONEZONE_IA`: para dados de longa duração, mas acessados com menos frequência.
+ `GLACIER`, `DEEP_ARCHIVE` e `REDUCED_REDUNDANCY`: para arquivamento de longo prazo e preservação digital.
Para obter mais informações, consulte [Classes de armazenamento do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) no *Guia do desenvolvedor do Amazon S3*.
Os exemplos nesta seção mostram como excluir as classes de armazenamento `GLACIER` e `DEEP_ARCHIVE`. Essas classes permitem que você liste arquivos, mas elas não permitem que você leia os arquivos, a menos que sejam restaurados. (Para obter mais informações, consulte [Restaurar objetos arquivados](https://docs.aws.amazon.com/AmazonS3/latest/dev/restoring-objects.html) no *Guia do desenvolvedor do Amazon S3*).
Ao usar exclusões de classe de armazenamento, você pode garantir que seus trabalhos do AWS Glue funcionarão em tabelas com partições entre esses níveis de classe de armazenamento. Sem exclusões, os trabalhos que leem dados desses níveis falham com o seguinte erro: AmazonS3Exception: The operation is not valid for the object's storage class (AmazonS3Exception: a operação não é válida para a classe de armazenamento do objeto).
Há diferentes maneiras de filtrar classes de armazenamento do Amazon S3 no AWS Glue.
**Topics**
+ [Excluir classes de armazenamento do Amazon S3 ao criar um quadro dinâmico](#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [Excluir classes de armazenamento do Amazon S3 em uma tabela do Data Catalog](#aws-glue-programming-etl-storage-classes-table)
## Excluir classes de armazenamento do Amazon S3 ao criar um quadro dinâmico
Para excluir classes de armazenamento do Amazon S3 ao criar um quadro dinâmico, use `excludeStorageClasses` em `additionalOptions`. O AWS Glue usa automaticamente sua própria implementação do `Lister` do Amazon S3 para listar e excluir arquivos correspondentes às classes de armazenamento especificadas.
Os exemplos de Python e Scala a seguir mostram como excluir as classes de armazenamento `GLACIER` e `DEEP_ARCHIVE` ao criar um quadro dinâmico.
Exemplo de Python do:
```
glueContext.create_dynamic_frame.from_catalog(
database = "my_database",
tableName = "my_table_name",
redshift_tmp_dir = "",
transformation_ctx = "my_transformation_context",
additional_options = {
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
```
Exemplo do Scala:
```
val* *df = glueContext.getCatalogSource(
nameSpace, tableName, "", "my_transformation_context",
additionalOptions = JsonOptions(
Map("excludeStorageClasses" -> List("GLACIER", "DEEP_ARCHIVE"))
)
).getDynamicFrame()
```
## Excluir classes de armazenamento do Amazon S3 em uma tabela do Data Catalog
É possível especificar exclusões de classe de armazenamento a serem usadas por um trabalho de ETL do AWS Glue como um parâmetro de tabela no catálogo de dados do Glue da AWS. Você pode incluir esse parâmetro na operação `CreateTable` usando a AWS Command Line Interface (AWS CLI) ou de forma programática com a API. Para obter mais informações, consulte [Estrutura de tabelas](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-Table) e [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html).
Você também pode especificar classes de armazenamento excluídas no console do AWS Glue.
**Como excluir classes de armazenamento do Amazon S3 (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação à esquerda, escolha **Tables (Tabelas)**.
1. Escolha o nome da tabela na lista e, depois, escolha **Edit table (Editar tabela)**.
1. Em **Table properties (Propriedades da tabela)**, adicione **excludeStorageClasses** como uma chave e **[\$1"GLACIER\$1",\$1"DEEP\$1ARCHIVE\$1"]** como um valor.
1. Escolha **Aplicar**.
# Gerenciar partições para saída de ETL no AWS Glue
O particionamento é uma técnica importante para organizar os conjuntos de dados para que possam ser consultados com eficiência. Ele organiza dados em uma estrutura hierárquica de diretórios com base nos valores distintos de uma ou mais colunas.
Por exemplo, você pode decidir particionar os logs da sua aplicação no Amazon Simple Storage Service (Amazon S3) por data, divididos em ano, mês e dia. Os arquivos que correspondem a um único dia de dados são colocados com um prefixo, como `s3://my_bucket/logs/year=2018/month=01/day=23/`. Sistemas como o Amazon Athena, o Amazon Redshift Spectrum e agora o AWS Glue podem usar essas partições para filtrar dados por valor de partição sem precisar ler todos os dados subjacentes do Amazon S3.
Os crawlers não apenas inferem tipos de arquivo e esquemas, como também identificam automaticamente a estrutura da partição do seu conjunto de dados quando eles preenchem o AWS Glue Data Catalog. As colunas resultantes da partição ficam disponíveis para consulta em trabalhos de ETL do AWS Glue ou em mecanismos de consulta, como o Amazon Athena.
Após rastrear uma tabela, você pode visualizar as partições que o crawler criou. No console do AWS Glue, escolha **Tables** (Tabelas) no painel de navegação esquerdo. Escolha a tabela criada pelo crawler e, em seguida, selecione **View Partitions** (Exibir partições).
Para os caminhos particionados do Apache Hive no estilo `key=val`, os crawlers preenchem automaticamente o nome da coluna usando o nome da chave padrão. Caso contrário, ele usa nomes padrão, como `partition_0`, `partition_1` e assim por diante. Você pode alterar os nomes padrão no console. Para fazer isso, navegue até a tabela. Verifique se os índices existem na guia **Índices**. Se for esse o caso, você precisa excluí-las para continuar (você poderá recriá-las posteriormente usando os novos nomes das colunas). Em seguida, escolha **Editar esquema** e modifique os nomes das colunas de partição.
Nos scripts de ETL, você pode filtrar as colunas da partição. Uma vez que as informações de partição são armazenadas no Data Catalog, utilize as chamadas de API `from_catalog` para incluir as colunas de partição no `DynamicFrame`. Por exemplo, use `create_dynamic_frame.from_catalog` em vez de `create_dynamic_frame.from_options`.
Particionamento é uma técnica de otimização que reduz as varreduras de dados. Para obter mais informações sobre o processo para identificar quando essa técnica é adequada, consulte [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/reduce-data-scan.html) no guia *Best practices for performance tuning AWS Glue for Apache Spark jobs* em AWS Prescriptive Guidance.
## Pré-filtragem usando a aplicação de predicados
Em muitos casos, você pode usar uma aplicação de predicado para filtrar partições sem precisar listar e ler todos os arquivos do seu conjunto de dados. Em vez de ler todo o conjunto de dados e, em seguida, filtrá-lo em um DynamicFrame, você pode aplicar o filtro diretamente nos metadados da partição no Data Catalog. Em seguida, você lista e lê somente o que você realmente precisa em um DynamicFrame.
Por exemplo, em Python, você pode gravar o seguinte.
```
glue_context.create_dynamic_frame.from_catalog(
database = "my_S3_data_set",
table_name = "catalog_data_table",
push_down_predicate = my_partition_predicate)
```
Isso cria um DynamicFrame que carrega somente as partições do Data Catalog que satisfazem a expressão do predicado. Dependendo do tamanho do subconjunto dos dados que você está carregando, isso pode economizar muito tempo de processamento.
A expressão do predicado pode ser qualquer expressão booleana compatível com Spark SQL. Tudo que você pode colocar em uma cláusula `WHERE` de uma consulta do SQL Spark funcionará. Por exemplo, a expressão de predicado `pushDownPredicate = "(year=='2017' and month=='04')"` carrega apenas as partições no Data Catalog que tiverem tanto `year` igual a 2017 quanto `month` igual a 04. Para obter mais informações, consulte a [Documentação do Apache Spark SQL](https://spark.apache.org/docs/2.1.1/sql-programming-guide.html) e, em especial, a [Referência das funções SQL em Scala](https://spark.apache.org/docs/2.1.1/api/scala/index.html#org.apache.spark.sql.functions$).
## Filtragem do lado do servidor usando predicados de partição de catálogo
A opção `push_down_predicate` é aplicada depois de listar todas as partições do catálogo e antes de listar arquivos do Amazon S3 para essas partições. Se você tiver muitas partições para uma tabela, a listagem de partições de catálogo ainda poderá incorrer em sobrecarga de tempo adicional. Para resolver essa sobrecarga, você pode usar a remoção de partição do lado do servidor com a opção `catalogPartitionPredicate`, que usa[índices de partição](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) no AWS Glue Data Catalog. Isso torna a filtragem de partição muito mais rápida quando você tem milhões de partições em uma tabela. Você pode usar `push_down_predicate` e `catalogPartitionPredicate` em `additional_options` juntos, se seu `catalogPartitionPredicate` exigir sintaxe de predicado que ainda não é suportada com os índices de partição de catálogo.
Python:
```
dynamic_frame = glueContext.create_dynamic_frame.from_catalog(
database=dbname,
table_name=tablename,
transformation_ctx="datasource0",
push_down_predicate="day>=10 and customer_id like '10%'",
additional_options={"catalogPartitionPredicate":"year='2021' and month='06'"}
)
```
Scala:
```
val dynamicFrame = glueContext.getCatalogSource(
database = dbname,
tableName = tablename,
transformationContext = "datasource0",
pushDownPredicate="day>=10 and customer_id like '10%'",
additionalOptions = JsonOptions("""{
"catalogPartitionPredicate": "year='2021' and month='06'"}""")
).getDynamicFrame()
```
**nota**
`push_down_predicate` e `catalogPartitionPredicate` usam sintaxes diferentes. O primeiro usa a sintaxe padrão do Spark SQL e o outro usa o analisador JSQL.
## Gravar partições
Por padrão, um DynamicFrame não é particionado quando é gravado. Todos os arquivos de saída são gravados no nível superior do caminho de saída especificado. Até recentemente, a única maneira de gravar um DynamicFrame em partições era convertê-lo em um DataFrame Spark SQL antes da gravação.
No entanto, DynamicFrames agora oferecem suporte ao particionamento nativo usando uma sequência de chaves, usando a opção `partitionKeys` ao criar um depósito. Por exemplo, o seguinte código Python grava um conjunto de dados no Amazon S3 no formato Parquet em diretórios particionados, de acordo com o tipo de campo. A partir daí, você pode processar essas partições usando outros sistemas, como o Amazon Athena.
```
glue_context.write_dynamic_frame.from_options(
frame = projectedEvents,
connection_type = "s3",
connection_options = {"path": "$outpath", "partitionKeys": ["type"]},
format = "parquet")
```
# Ler arquivos de entrada em grupos maiores
Você pode definir as propriedades das tabelas para habilitar um trabalho de ETL do AWS Glue a fim de agrupar arquivos quando eles são lidos em um armazenamento de dados do Amazon S3. Essas propriedades permitem que cada tarefa de ETL leia um grupo de arquivos de entrada em uma única partição na memória. Isso é especialmente útil quando há um grande número de arquivos pequenos no armazenamento de dados do Amazon S3. Ao definir determinadas propriedades, você instrui o AWS Glue a agrupar arquivos em uma partição de dados do Amazon S3 e a definir o tamanho dos grupos a serem lidos. Você também pode definir essas opções durante a leitura em um armazenamento de dados do Amazon S3 com o método `create_dynamic_frame.from_options`.
Para habilitar o agrupamento de arquivos para uma tabela, defina pares de chave/valor no campo de parâmetros da estrutura da tabela. Use a notação JSON para definir um valor para o campo de parâmetro da tabela. Para obter mais informações sobre como editar as propriedades de uma tabela, consulte [Exibir e gerenciar detalhes da tabela](tables-described.md#console-tables-details).
Você pode usar esse método para habilitar o agrupamento de tabelas no Data Catalog com armazenamentos de dados do Amazon S3.
**groupFiles**
Defina **groupFiles** (agrupar arquivos) como `inPartition` para habilitar o agrupamento de arquivos em uma partição de dados do Amazon S3. O AWS Glue habilitará automaticamente o agrupamento se houver mais de 50.000 arquivos de entrada, como no exemplo a seguir.
```
'groupFiles': 'inPartition'
```
**groupSize**
Defina **groupSize** como o tamanho de destino de grupos em bytes. A propriedade **groupSize** é opcional. Se não for fornecida, o AWS Glue calculará um tamanho para usar todos os núcleos de CPU no cluster e, ao mesmo tempo, ainda reduzindo o número total de tarefas de ETL e partições na memória.
Por exemplo, o seguinte define o tamanho do grupo como 1 MB.
```
'groupSize': '1048576'
```
Observe que o `groupsize` deve ser definido com o resultado de um cálculo. Por exemplo 1024 \$1 1024 = 1048576.
**recurse**
Defina **recursivo** para `True` recursivamente ler arquivos em todos os subdiretórios ao especificar `paths` uma matriz de caminhos. Você não precisará definir **recurse** (recursivo) se `paths` for uma matriz de chaves de objeto no Amazon S3 ou se o formato de entrada for parquet/orc, como no exemplo a seguir.
```
'recurse':True
```
Se você estiver lendo no Amazon S3 diretamente usando o método `create_dynamic_frame.from_options`, adicione estas opções de conexão. Por exemplo, as seguintes tentativas de agrupar arquivos em grupos de 1 MB.
```
df = glueContext.create_dynamic_frame.from_options("s3", {'paths': ["s3://s3path/"], 'recurse':True, 'groupFiles': 'inPartition', 'groupSize': '1048576'}, format="json")
```
**nota**
Há suporte para `groupFiles` para DynamicFrames criados a partir dos seguintes formatos de dados: csv, ion, grokLog, json e xml. Não há suporte dessa opção para avro, parquet e orc.
# Endpoints da Amazon VPC para o Amazon S3
Por motivos de segurança, muitos clientes da AWS executam suas aplicações em um ambiente da Amazon Virtual Private Cloud (Amazon VPC). Com a Amazon VPC, você pode executar instâncias do Amazon EC2 em uma nuvem privada virtual, a qual é isolada logicamente de outras redes, incluindo a Internet pública. Com uma Amazon VPC, você tem controle sobre o intervalo de endereços IP, sub-redes, tabelas de roteamento, gateways de rede e configurações de segurança.
**nota**
Caso tenha criado sua conta da AWS após 4/12/2013, você já tem uma VPC padrão em cada região da AWS. Você pode começar a usar sua VPC padrão imediatamente sem qualquer configuração adicional.
Para obter mais informações, consulte [Suas sub-redes e VPC padrão](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) no Manual do usuário da Amazon VPC.
Muitos clientes têm preocupações legítimas com a segurança e a privacidade sobre o envio e o recebimento de dados pela Internet pública. Os clientes podem resolver essas preocupações usando uma rede privada virtual (VPN) para rotear todo o tráfego de rede do Amazon S3 por meio da infraestrutura de rede corporativa deles. No entanto, essa abordagem pode introduzir desafios de largura de banda e disponibilidade.
Os endpoints da VPC para o Amazon S3 podem reduzir esses desafios. Um endpoint da VPC para o Amazon S3 permite ao AWS Glue usar endereços IP privados para acessar o Amazon S3 sem exposição à Internet pública. O AWS Glue não precisa de endereços IP públicos e você não precisa de um gateway da Internet, de um dispositivo NAT ou de um gateway privado virtual na sua VPC. Use as políticas de endpoint para controlar o acesso ao Amazon S3. O tráfego entre sua VPC e o produto da AWS não sai da rede da Amazon.
Ao criar um endpoint da VPC para o Amazon S3, quaisquer solicitações para um endpoint do Amazon S3 dentro da região (por exemplo: *s3.us-west-2.amazonaws.com*) são encaminhadas para um endpoint privado do Amazon S3 dentro da rede da Amazon. Você não precisa modificar suas aplicações em execução em instâncias do Amazon EC2 na VPC. O nome do endpoint permanece o mesmo, mas a rota para o Amazon S3 permanece inteiramente dentro da rede da Amazon e não acessa a Internet pública.
Para obter mais informações sobre o endpoints da VPC, consulte [Endpoints da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) no Manual do usuário da Amazon VPC.
O diagrama a seguir mostra como o AWS Glue pode usar um endpoint da VPC para acessar o Amazon S3.
![\[Fluxo de tráfego de rede que mostra a conexão da VPC com o Amazon S3.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/PopulateCatalog-vpc-endpoint.png)
**Para configurar o acesso ao Amazon S3**
1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. No painel de navegação à esquerda, escolha **Endpoints**.
1. Escolha **Create Endpoint** (Criar endpoint) e siga as etapas para criar um endpoint da VPC do Amazon S3 do tipo Gateway.
# Conexões do Amazon DocumentDB
É possível usar o AWS Glue para Spark para ler e gravar em tabelas no Amazon DocumentDB. Você pode se conectar ao Amazon DocumentDB usando credenciais armazenadas no AWS Secrets Manager por meio de uma conexão do AWS Glue.
Para obter mais informações sobre o Amazon DocumentDB, consulte a [Documentação do Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/what-is.html).
**nota**
No momento, os clusters elásticos do Amazon DocumentDB não são compatíveis com o uso do conector do AWS Glue. Para obter mais informações sobre clusters elásticos, consulte [Using Amazon DocumentDB elastic clusters](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html).
## Ler e gravar em coleções do Amazon DocumentDB
**nota**
Ao criar um trabalho de ETL que se conecta ao Amazon DocumentDB, para a propriedade de trabalho `Connections`, é necessário designar um objeto de conexão que especifica a nuvem privada virtual (VPC) em que o Amazon DocumentDB é executado. Para o objeto de conexão, o tipo de conexão deve ser `JDBC`, e o `JDBC URL` deve ser `mongo://:27017`.
**nota**
Estes exemplos de código foram desenvolvidos para o AWS Glue 3.0. Para migrar para o AWS Glue 4.0, consulte [MongoDB](migrating-version-40.md#migrating-version-40-connector-driver-migration-mongodb). O parâmetro `uri` foi alterado.
**nota**
Ao usar o Amazon DocumentDB, `retryWrites` deve ser definido como falso em determinadas situações, como quando o documento escrito especifica `_id`. Para obter mais informações, consulte [Diferenças funcionais com o MongoDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/functional-differences.html#functional-differences.retryable-writes) na documentação do Amazon DocumentDB.
O script Python a seguir demonstra como usar tipos e opções de conexão para ler e gravar no Amazon DocumentDB.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
documentdb_uri = "mongodb://:27017"
documentdb_write_uri = "mongodb://:27017"
read_docdb_options = {
"uri": documentdb_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "1234567890",
"ssl": "true",
"ssl.domain_match": "false",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"
}
write_documentdb_options = {
"retryWrites": "false",
"uri": documentdb_write_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "pwd"
}
# Get DynamicFrame from DocumentDB
dynamic_frame2 = glueContext.create_dynamic_frame.from_options(connection_type="documentdb",
connection_options=read_docdb_options)
# Write DynamicFrame to MongoDB and DocumentDB
glueContext.write_dynamic_frame.from_options(dynamic_frame2, connection_type="documentdb",
connection_options=write_documentdb_options)
job.commit()
```
O script Scala a seguir demonstra como usar tipos e opções de conexão para ler e gravar no Amazon DocumentDB.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DOC_URI: String = "mongodb://:27017"
val DOC_WRITE_URI: String = "mongodb://:27017"
lazy val documentDBJsonOption = jsonOptions(DOC_URI)
lazy val writeDocumentDBJsonOption = jsonOptions(DOC_WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from DocumentDB
val resultFrame2: DynamicFrame = glueContext.getSource("documentdb", documentDBJsonOption).getDynamicFrame()
// Write DynamicFrame to DocumentDB
glueContext.getSink("documentdb", writeJsonOption).writeDynamicFrame(resultFrame2)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"test",
|"collection":"coll",
|"username": "username",
|"password": "pwd",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
## Referência de opções de conexão do Amazon DocumentDB
Designa uma conexão com o Amazon DocumentDB (compatível com MongoDB).
As opções de conexão diferem para uma conexão da fonte e uma conexão do coletor.
### “connectionType”: “documentdb” como fonte
Use as seguintes opções de conexão com `"connectionType": "documentdb"` como fonte:
+ `"uri"`: (obrigatório) o host do Amazon DocumentDB do qual fazer a leitura, formatado como `mongodb://:`.
+ `"database"`: (obrigatório) o banco de dados do Amazon DocumentDB do qual fazer a leitura.
+ `"collection"`: (obrigatório) a coleção do Amazon DocumentDB da qual fazer a leitura.
+ `"username"`: (obrigatório) o nome de usuário do Amazon DocumentDB.
+ `"password"`: (obrigatório) a senha do Amazon DocumentDB.
+ `"ssl"`: (obrigatório se estiver usando SSL) se sua conexão usar SSL, você deve incluir essa opção com o valor `"true"`.
+ `"ssl.domain_match"`: (obrigatório se estiver usando SSL) se sua conexão usar SSL, você deve incluir essa opção com o valor `"false"`.
+ `"batchSize"`: (opcional) o número de documentos que devem ser retornados por lote, usado no cursor de lotes internos.
+ `"partitioner"`: (opcional) o nome da classe do particionador do qual deve ser feita a leitura dos dados de entrada do Amazon DocumentDB. O conector fornece os seguintes particionadores:
+ `MongoDefaultPartitioner` (padrão) (sem suporte no AWS Glue 4.0)
+ `MongoSamplePartitioner` (sem suporte no AWS Glue 4.0)
+ `MongoShardedPartitioner`
+ `MongoSplitVectorPartitioner`
+ `MongoPaginateByCountPartitioner`
+ `MongoPaginateBySizePartitioner` (sem suporte no AWS Glue 4.0)
+ `"partitionerOptions"`: (opcional) opções para o particionador designado. As seguintes opções são compatíveis com cada particionador:
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner`: `partitionKey`, partitionSizeMB
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner`: `partitionKey`, partitionSizeMB
Para obter mais informações sobre essas opções, consulte [Partitioner Configuration](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) na documentação do MongoDB.
### “connectionType”: “documentdb” como coletor
Use as seguintes opções de conexão com `"connectionType": "documentdb"` como coletor:
+ `"uri"`: (obrigatório) o host do Amazon DocumentDB no qual fazer a gravação, formatado como `mongodb://:`.
+ `"database"`: (obrigatório) o banco de dados do Amazon DocumentDB no qual fazer a gravação.
+ `"collection"`: (obrigatório) a coleção do Amazon DocumentDB na qual fazer a gravação.
+ `"username"`: (obrigatório) o nome de usuário do Amazon DocumentDB.
+ `"password"`: (obrigatório) a senha do Amazon DocumentDB.
+ `"extendedBsonTypes"`: (opcional) se `true`, permite tipos BSON estendidos ao gravar dados no Amazon DocumentDB. O padrão é `true`.
+ `"replaceDocument"`: (opcional) se for `true`, substituirá todo o documento ao salvar conjuntos de dados que contêm um campo `_id`. Se for `false`, serão atualizados somente os campos do documento que correspondam aos campos do conjunto de dados. O padrão é `true`.
+ `"maxBatchSize"`: (opcional) o tamanho máximo do lote para operações em massa ao salvar dados. O padrão é 512.
+ `"retryWrites"`: (Opcional): repita automaticamente determinadas operações de escrita uma única vez se o AWS Glue encontrar um erro de rede.
# Conexões do OpenSearch Service
O AWS Glue para Spark pode ser usado para ler e escrever em tabelas no OpenSearch Service no AWS Glue 4.0 e versões posteriores. Você pode definir o que deseja ler do OpenSearch Service com uma consulta do OpenSearch. Conecte-se ao OpenSearch Service usando credenciais de autenticação básica HTTP armazenadas no AWS Secrets Manager via conexão do AWS Glue. Esse recurso não é compatível com o OpenSearch Service com tecnologia sem servidor.
Para obter mais informações sobre o serviço Amazon OpenSearch Service, consulte a [Documentação do Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/).
## Configurar conexões do OpenSearch Service
Para se conectar ao OpenSearch Service via AWS Glue, você precisará criar e armazenar suas credenciais do OpenSearch Service em um segredo do AWS Secrets Manager e, em seguida, associar esse segredo a uma conexão AWS Glue OpenSearch Service.
**Pré-requisitos:**
+ Identifique o endpoint do domínio, *aosEndpoint* e porta, *aosPort* do qual gostaria de ler, ou crie o recurso seguindo as instruções na documentação do Amazon OpenSearch Service. Para obter mais informações sobre a criação de domínios, consulte [Criar e gerenciar domínios do Amazon OpenSearch Service](https://docs.aws.amazon.com//opensearch-service/latest/developerguide/createupdatedomains.html) na documentação do Amazon OpenSearch Service.
Um endpoint de domínio do Amazon OpenSearch Service terá o seguinte formato padrão, https://search-*domainName*-*unstructuredIdContent*.*region*.es.amazonaws.com. Para obter mais informações sobre a identificação do endpoint do domínio, consulte [Criar e gerenciar domínios do Amazon OpenSearch Service](https://docs.aws.amazon.com//opensearch-service/latest/developerguide/createupdatedomains.html) na documentação do Amazon OpenSearch Service.
Identifique ou gere credenciais de autenticação básica HTTP, *aosUser* e *aosPassword* para seu domínio.
**Para configurar uma conexão com o OpenSearch Service:**
1. No AWS Secrets Manager, crie um segredo usando suas credenciais do OpenSearch Service. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criar uma AWS Secrets Manager segredo ](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `USERNAME` com o valor *aosUser*.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `PASSWORD` com o valor *aosPassword*.
1. No console do AWS Glue, crie uma conexão seguindo as etapas em [Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para uso futuro no AWS Glue.
+ Ao selecionar um **Tipo de conexão**, escolha OpenSearch Service.
+ Ao selecionar um endpoint de domínio, forneça *aosEndpoint*.
+ Ao selecionar uma porta, forneça *aosPort*.
+ Ao selecionar um **Segredo da AWS**, forneça o *secretName*.
Depois de criar uma conexão AWS Glue OpenSearch Service, siga estas etapas antes de executar seu trabalho do AWS Glue:
+ Conceda ao perfil do IAM associada ao seu trabalho do AWS Glue permissão para ler *secretName*.
+ Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
## Ler dos índices do OpenSearch Service
**Pré-requisitos:**
+ Um índice do OpenSearch Service do qual você gostaria de ler, *aosIndex*.
+ Uma conexão do AWS Glue OpenSearch Service configurada para fornecer informações de autenticação e localização da rede. Para fazer isso, conclua as etapas do procedimento anterior, *Para configurar uma conexão com o OpenSearch Service*. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Este exemplo lê um índice do Amazon OpenSearch Service. Será necessário fornecer o parâmetro `pushdown`.
Por exemplo:
```
opensearch_read = glueContext.create_dynamic_frame.from_options(
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
"pushdown": "true",
}
)
```
Você também pode fornecer uma srting de consulta para filtrar os resultados retornados em seu DynamicFrame. Você precisará configurar `opensearch.query`.
O `opensearch.query` pode usar uma string de parâmetros de consulta de URL *queryString* ou um objeto *queryObject* de consulta JSON DSL. Para obter mais informações sobre a consulta DSL, consulte [Consulta DSL](https://opensearch.org/docs/latest/query-dsl/index/) na documentação do OpenSearch. Para fornecer uma string de parâmetros de consulta de URL, adicione o prefixo `?q=` à sua consulta, como você faria em um URL totalmente qualificado. Para fornecer um objeto DSL de consulta, faça o escape de string do objeto JSON antes de fornecê-lo.
Por exemplo:
```
queryObject = "{ "query": { "multi_match": { "query": "Sample", "fields": [ "sample" ] } } }"
queryString = "?q=queryString"
opensearch_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
"opensearch.query": queryString,
"pushdown": "true",
}
)
```
Para obter mais informações sobre como criar uma consulta fora de sua sintaxe específica, consulte [Sintaxe da string de consulta](https://opensearch.org/docs/latest/query-dsl/full-text/query-string/#query-string-syntax) na documentação do OpenSearch.
Ao ler as coleções do OpenSearch que contêm dados do tipo de matriz, você deve especificar quais campos são do tipo de matriz em sua chamada de método usando o parâmetro `opensearch.read.field.as.array.include`.
Por exemplo, ao ler o documento abaixo, você encontrará os campos `genre` e `actor` de matriz:
```
{
"_index": "movies",
"_id": "2",
"_version": 1,
"_seq_no": 0,
"_primary_term": 1,
"found": true,
"_source": {
"director": "Frankenheimer, John",
"genre": [
"Drama",
"Mystery",
"Thriller",
"Crime"
],
"year": 1962,
"actor": [
"Lansbury, Angela",
"Sinatra, Frank",
"Leigh, Janet",
"Harvey, Laurence",
"Silva, Henry",
"Frees, Paul",
"Gregory, James",
"Bissell, Whit",
"McGiver, John",
"Parrish, Leslie",
"Edwards, James",
"Flowers, Bess",
"Dhiegh, Khigh",
"Payne, Julie",
"Kleeb, Helen",
"Gray, Joe",
"Nalder, Reggie",
"Stevens, Bert",
"Masters, Michael",
"Lowell, Tom"
],
"title": "The Manchurian Candidate"
}
}
```
Nesse caso, você incluiria esses nomes de campo na chamada do método. Por exemplo:
```
"opensearch.read.field.as.array.include": "genre,actor"
```
Se o campo de matriz estiver aninhado dentro da estrutura do documento, consulte-o usando a notação de pontos: `"genre,actor,foo.bar.baz"`. Isso especificaria uma matriz `baz` incluída em seu documento de origem por meio do documento incorporado `foo` que contém o documento incorporado `bar`.
## Escrever em tabelas do OpenSearch Service
Este exemplo escreve informações de um DynamicFrame existente, *dynamicFrame*, no OpenSearch Service. Se o índice já tiver informações, o AWS Glue anexará dados do seu DynamicFrame. Será necessário fornecer o parâmetro `pushdown`.
**Pré-requisitos:**
+ Uma tabela do OpenSearch Service na qual você gostaria de escrever. Você precisará de informações de identificação para a tabela. Vamos chamar isso de *tableName*.
+ Uma conexão do AWS Glue OpenSearch Service configurada para fornecer informações de autenticação e localização da rede. Para fazer isso, conclua as etapas do procedimento anterior, *Para configurar uma conexão com o OpenSearch Service*. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
},
)
```
## Referência de opções de conexão do OpenSearch Service
+ `connectionName` — Obrigatório. Usado para leitura/gravação. O nome de uma conexão do AWS Glue OpenSearch Service configurada para fornecer informações de autenticação e localização da rede ao seu método de conexão.
+ `opensearch.resource` — Obrigatório. Usado para leitura/gravação. Valores válidos: nomes de índice do OpenSearch. O nome do índice com o qual seu método de conexão interagirá.
+ `opensearch.query` - Usado para leitura. Valores válidos: JSON com escape de string ou, quando essa string começa com `?`, a parte de pesquisa de um URL. Uma consulta do OpenSearch que filtra o que deve ser recuperado durante a leitura. Para obter mais informações sobre como usar esse parâmetro, consulte a seção [Ler dos índices do OpenSearch Service](#aws-glue-programming-etl-connect-opensearch-read) anterior.
+ `pushdown`: exigido se. Usado para leitura. Valores válidos: booleano. Instrui o Spark a passar consultas de leitura para o OpenSearch para que o banco de dados retorne apenas documentos relevantes.
+ `opensearch.read.field.as.array.include`: obrigatório ao ler dados do tipo matriz. Usado para leitura. Valores válidos: listas separadas por vírgulas de nomes de campo. Especifica os campos a serem lidos como matrizes de documentos do OpenSearch. Para obter mais informações sobre como usar esse parâmetro, consulte a seção anterior [Ler dos índices do OpenSearch Service](#aws-glue-programming-etl-connect-opensearch-read).
# Conexões do Redshift
Você pode usar o AWS Glue para Spark para ler e gravar tabelas nos bancos de dados do Amazon Redshift. Ao se conectar aos bancos de dados do Amazon Redshift, o AWS Glue move dados pelo Amazon S3 para obter o throughput máximo usando os comandos `COPY` e `UNLOAD` do Amazon Redshift SQL. No AWS Glue 4.0 e posteriores, você pode usar a [integração do Amazon Redshift para Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) para ler e gravar com otimizações e atributos específicos do Amazon Redshift além dos disponíveis ao fazer a conexão por meio das versões anteriores.
Saiba como o AWS Glue está tornando mais fácil do que nunca para os usuários do Amazon Redshift migrar para o AWS Glue para integração de dados e ETL com tecnologia sem servidor.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/ZapycBq8TKU)
## Configurar conexões do Redshift
Para usar clusters do Amazon Redshift no AWS Glue, você precisará de alguns pré-requisitos:
+ Um diretório do Amazon S3 a ser usado para armazenamento temporário ao ler e gravar no banco de dados.
+ Uma Amazon VPC que permita a comunicação entre o cluster do Amazon Redshift, o trabalho do AWS Glue e o diretório do Amazon S3.
+ Permissões apropriadas do IAM no trabalho do AWS Glue e no cluster do Amazon Redshift.
### Configurar perfis do IAM
**Configurar o perfil para o cluster do Amazon Redshift**
O cluster do Amazon Redshift precisa poder ler e gravar no Amazon S3 para se integrar com os trabalhos do AWS Glue. Para permitir isso, você pode associar perfis do IAM ao cluster do Amazon Redshift ao qual você deseja se conectar. Seu perfil deve ter uma política que permita ler e gravar no diretório temporário do Amazon S3. Seu perfil deve ter uma relação de confiança que permita ao serviço `redshift.amazonaws.com` `AssumeRole`.
**Para associar um perfil do IAM ao Amazon Redshift**
1. **Pré-requisitos:** um bucket ou diretório do Amazon S3 usado para o armazenamento temporário de arquivos.
1. Identifique quais permissões do Amazon S3 o cluster do Amazon Redshift precisará ter. Ao mover dados entre um cluster do Amazon Redshift, os trabalhos do AWS Glue emitem instruções COPY e UNLOAD no Amazon Redshift. Se o trabalho modificar uma tabela no Amazon Redshift, o AWS Glue também emitirá instruções CREATE LIBRARY. Para obter informações sobre as permissões específicas do Amazon S3 necessárias para o Amazon Redshift executar essas instruções, consulte a documentação do Amazon Redshift: [Amazon Redshift: Permissões para acessar outros recursos da AWS](https://docs.aws.amazon.com/redshift/latest/dg/copy-usage_notes-access-permissions.html).
1. No console do IAM, crie uma política do IAM com as permissões necessárias. Para obter informações sobre a criação de uma política, consulte [Criação de políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
1. No console do IAM, crie um perfil e uma relação de confiança que permita ao Amazon Redshift assumir o perfil. Siga as instruções na documentação do IAM [Para criar um perfil para um serviço da AWS (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console)
+ Quando solicitado a escolher um caso de uso de um serviço da AWS, escolha "Redshift: personalizável".
+ Quando solicitado a anexar uma política, escolha a política que você definiu anteriormente.
**nota**
Para obter mais informações sobre a configuração de perfis para o Amazon Redshift, consulte [Autorizar o Amazon Redshift a acessar outros serviços da AWS em seu nome](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) na documentação do Amazon Redshift.
1. No console do Amazon Redshift, associe o perfil ao seu cluster do Amazon Redshift. Siga as instruções na [documentação do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html).
Selecione a opção realçada no console do Amazon Redshift para definir esta configuração:
![\[Um exemplo de onde gerenciar as permissões do IAM no console do Amazon Redshift.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/RS-role-config.png)
**nota**
Por padrão, o AWS Glue transmite credenciais temporárias do Amazon Redshift que são criadas usando o perfil que você especificou para executar o trabalho. Não recomendamos usar esses parâmetros para especificar credenciais. Por motivos de segurança, essas credenciais expiram após 1 hora.
**Configurar o perfil para o trabalho do AWS Glue**
O trabalho do AWS Glue precisa de um perfil para acessar o bucket do Amazon S3. Você não precisa de permissões do IAM para o cluster do Amazon Redshift, seu acesso é controlado pela conectividade no Amazon VPC e por suas credenciais do banco de dados.
### Configurar a Amazon VCP
**Para configurar o acesso aos armazenamentos de dados do Amazon Redshift**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Redshift em [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/).
1. No painel de navegação à esquerda, escolha **Clusters**.
1. Escolha o nome de cluster que você deseja acessar no AWS Glue.
1. Na seção **Cluster Properties (Propriedades do cluster)**, escolha um grupo de segurança em **VPC security groups (Grupos de segurança da VPC)** para permitir que o AWS Glue o utilize. Anote o nome do grupo de segurança que você escolheu para referência futura. Escolher o grupo de segurança abre a lista **Security Groups** (Grupos de segurança) do console do Amazon EC2.
1. Escolha o grupo de segurança a ser modificado e navegue até a guia **Inbound**.
1. Adicione uma regra de autorreferência para permitir que os componentes do AWS Glue se comuniquem. Especificamente, adicione ou confirme que existe uma regra de **Type** `All TCP`, que **Protocol** é `TCP`, **Port Range** inclui todas as portas e **Source** e **Group ID** apresentam o mesmo nome de grupo de segurança.
O regra de entrada tem aparência semelhante a esta:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Por exemplo:
![\[Um exemplo de uma regra de entrada de autorreferência.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/SetupSecurityGroup-Start.png)
1. Adicione também uma regra para o tráfego de saída. Abra o tráfego de saída a todas as portas, por exemplo:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Ou crie uma regra de autorreferência em que **Type (Tipo)** é `All TCP`, **Protocol (Protocolo)** é `TCP`, **Port Range (Intervalo de portas)** inclui todas as portas e cujo **Destination (Destino)** é o mesmo nome de grupo de segurança de **Group ID (ID de grupo)**. Se você estiver usando um endpoint da VPC do Amazon S3, adicione também uma regra HTTPS para acesso ao Amazon S3. O *s3-prefix-list-id* é necessário na regra do grupo de segurança para permitir o tráfego da VPC para o endpoint da VPC do Amazon S3.
Por exemplo:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
### Configurar o AWS Glue
Você precisará criar uma conexão do catálogo de dados do AWS Glue que forneça informações de conexão com a Amazon VPC.
**Para configurar a conectividade da Amazon VPC do Amazon Redshift com o AWS Glue no console**
1. Crie uma conexão do catálogo de dados seguindo as etapas em:[Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para a próxima etapa.
+ Ao selecionar um **tipo de conexão**, selecione **Amazon Redshift**.
+ Ao selecionar um **cluster do Redshift**, selecione seu cluster pelo nome.
+ Forneça informações de conexão padrão para um usuário do Amazon Redshift em seu cluster.
+ As configurações do Amazon VPC serão definidas automaticamente.
**nota**
Você precisará fornecer `PhysicalConnectionRequirements` manualmente para a Amazon VPC ao criar uma conexão do **Amazon Redshift** por meio do SDK da AWS.
1. Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
## Exemplo: leitura de tabelas do Amazon Redshift
Você pode ler nos clusters do Amazon Redshift e ambientes do Amazon Redshift sem servidor.
**Pré-requisitos:** uma tabela do Amazon Redshift que você deseja ler. *Siga as etapas da seção anterior [Configurar conexões do Redshift](#aws-glue-programming-etl-connect-redshift-configure) e, depois disso, você deverá ter o URI do Amazon S3 para um diretório temporário, *temp-s3-dir*, e um perfil do IAM, *rs-role-name*, (na conta role-account-id*).
------
#### [ Using the Data Catalog ]
**Pré-requisitos adicionais:** um banco de dados e uma tabela do catálogo de dados para a tabela do Amazon Redshift que você deseja ler. Para obter mais informações sobre o catálogo de dados, consulte [Descoberta e catalogação de dados no AWS Glue](catalog-and-crawler.md). *Depois de criar uma entrada para a tabela do Amazon Redshift, você identificará sua conexão com um *redshift-dc-database-name* e redshift-table-name.*
**Configuração:** nas opções de função, você identificará a tabela do catálogo de dados com os parâmetros `database` e `table_name`. Você identificará seu diretório temporário do Amazon S3 com `redshift_tmp_dir`. Você também fornecerá *rs-role-name* usando a chave `aws_iam_role` no parâmetro `additional_options`.
```
glueContext.create_dynamic_frame.from_catalog(
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"})
```
------
#### [ Connecting directly ]
**Pré-requisitos adicionais:** *você precisará do nome da sua tabela do Amazon Redshift (redshift-table-name*). Você precisará das informações da conexão JDBC para o cluster do Amazon Redshift que armazena essa tabela. Você fornecerá suas informações de conexão com *host*, *porta*, *redshift-database-name*, *nome de usuário* e *senha*.
Você pode recuperar suas informações de conexão no console do Amazon Redshift ao trabalhar com clusters do Amazon Redshift. Ao usar o Amazon Redshift sem servidor, consulte [Conectar-se ao Amazon Redshift Serverless](https://docs.aws.amazon.com//redshift/latest/mgmt/serverless-connecting.html) na documentação do Amazon Redshift.
**Configuração:** nas opções de função, você identificará os parâmetros `url`, `dbtable`, `user` e `password`. Você identificará seu diretório temporário do Amazon S3 com `redshift_tmp_dir`. Você pode especificar seu perfil do IAM usando `aws_iam_role` quando você usa `from_options`. A sintaxe é semelhante à conexão por meio do catálogo de dados, mas você coloca os parâmetros no mapa de `connection_options`.
Não é um prática recomendável codificar senhas em scripts do AWS Glue. Considere armazenar suas senhas do AWS Secrets Manager e recuperá-las no seu script com o SDK for Python (Boto3).
```
my_conn_options = {
"url": "jdbc:redshift://host:port/redshift-database-name",
"dbtable": "redshift-table-name",
"user": "username",
"password": "password",
"redshiftTmpDir": args["temp-s3-dir"],
"aws_iam_role": "arn:aws:iam::account id:role/rs-role-name"
}
df = glueContext.create_dynamic_frame.from_options("redshift", my_conn_options)
```
------
## Exemplo: gravaçr em tabelas do Amazon Redshift
Você pode ler dos clusters do Amazon Redshift e em ambientes do Amazon Redshift sem servidor.
**Pré-requisitos:** um cluster do Amazon Redshift e siga as etapas da seção anterior. [Configurar conexões do Redshift](#aws-glue-programming-etl-connect-redshift-configure). Depois disso, você deverá ter o URI do Amazon S3 para um diretório temporário, *temp-s3-dir* e um perfil do IAM, *rs-role-name*, (na conta *role-account-id*). Você também precisará de um `DynamicFrame` cujo conteúdo você deseja gravar no banco de dados.
------
#### [ Using the Data Catalog ]
**Pré-requisitos adicionais:** um banco de dados do catálogo de dados para o cluster do Amazon Redshift no qual que você deseja gravar. Para obter mais informações sobre o catálogo de dados, consulte [Descoberta e catalogação de dados no AWS Glue](catalog-and-crawler.md). *Você identificará sua conexão com *redshift-dc-database-name* e a tabela de destino com redshift-table-name*.
**Configuração:** nas opções de função, você identificará o banco de dados do catálogo de dados com o parâmetros `database` e depois fornecerá a tabela com `table_name`. Você identificará seu diretório temporário do Amazon S3 com `redshift_tmp_dir`. Você também fornecerá *rs-role-name* usando a chave `aws_iam_role` no parâmetro `additional_options`.
```
glueContext.write_dynamic_frame.from_catalog(
frame = input dynamic frame,
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::account-id:role/rs-role-name"})
```
------
#### [ Connecting through a AWS Glue connection ]
Você pode se conectar ao Amazon Redshift diretamente usando o método `write_dynamic_frame.from_options`. Porém, em vez de inserir os detalhes da conexão diretamente no script, você pode referenciar os detalhes da conexão armazenados em uma conexão do catálogo de dados com o método `from_jdbc_conf`. Você pode fazer isso sem fazer crawling ou criar tabelas do catálogo de dados para o banco de dados. Para obter mais informações sobre as conexões do catálogo de dados, consulte [Conectar a dados](glue-connections.md).
**Pré-requisitos adicionais:** uma conexão do catálogo de dados para seu banco de dados, uma tabela do Amazon Redshift que você deseja ler
**Configuração:** você identificará sua conexão do catálogo de dados com *dc-connection-name*. *Você identificará seu banco de dados e tabela do Amazon Redshift com *redshift-table-name* e redshift-database-name*. Você fornecerá as informações de conexão do catálogo de dados com `catalog_connection` e as informações do Amazon Redshift com `dbtable` e `database`. A sintaxe é semelhante à conexão por meio do catálogo de dados, mas você coloca os parâmetros no mapa de `connection_options`.
```
my_conn_options = {
"dbtable": "redshift-table-name",
"database": "redshift-database-name",
"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"
}
glueContext.write_dynamic_frame.from_jdbc_conf(
frame = input dynamic frame,
catalog_connection = "dc-connection-name",
connection_options = my_conn_options,
redshift_tmp_dir = args["temp-s3-dir"])
```
------
## Referência da opções de conexão do Amazon Redshift
As opções básicas de conexão usadas em todas as conexões JDBC do AWS Glue para configurar informações como `url`, `user` e `password` são consistentes em todos os tipos de JDBC. Para obter mais informações sobre os parâmetros padrão de JDBC consulte [Referência de opções de conexão JDBC](aws-glue-programming-etl-connect-jdbc-home.md#aws-glue-programming-etl-connect-jdbc).
O tipo de conexão do Amazon Redshift tem algumas opções adicionais de conexão:
+ `"redshiftTmpDir"`: (obrigatório) o caminho do Amazon S3 onde dados temporários podem ser preparados ao serem copiados para fora do banco de dados.
+ `"aws_iam_role"`: (opcional) o ARN de um perfil do IAM. O trabalho AWS Glue passará esse perfil para o cluster do Amazon Redshift para conceder ao cluster as permissões necessárias para concluir as instruções do trabalho.
### Opções adicionais de conexão disponíveis no AWS Glue 4.0\$1
Você também pode transmitir opções para o novo conector do Amazon Redshift por meio das opções de conexão do AWS Glue. Para obter uma lista completa das opções de conectores compatíveis, consulte a seção de *Parâmetros do Spark SQL* em [Amazon Redshift integration for Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) (Integração do Amazon Redshift for Apache Spark).
Para sua conveniência, reiteramos algumas novas opções aqui:
| Nome | Obrigatório | Padrão | Descrição |
| --- | --- | --- | --- |
| autopushdown | Não | TRUE | Aplica pushdown de predicados e consultas capturando e analisando os planos lógicos do Spark para operações SQL. As operações são traduzidas em uma consulta SQL e executadas no Amazon Redshift para melhorar a performance. |
| autopushdown.s3\$1result\$1cache | Não | FALSE | Armazena a consulta SQL para descarregar dados do mapeamento de caminhos do Amazon S3 na memória para que a mesma consulta não precise ser executada novamente na mesma sessão do Spark. Só é possível quando o `autopushdown` está habilitado. |
| unload\$1s3\$1format | Não | PARQUET | PARQUET - descarrega os resultados da consulta no formato Parquet. TEXT - descarrega os resultados da consulta em formato de texto delimitado por barras. |
| sse\$1kms\$1key | Não | N/D | A chave do AWS SSE-KMS a ser usada para criptografia durante as operações, de `UNLOAD` em vez da criptografia padrão para AWS. |
| extracopyoptions | Não | N/D | Uma lista de opções extras para anexar ao comando `COPY` do Amazon Redshift ao carregar dados, como `TRUNCATECOLUMNS` ou `MAXERROR n` (para outras opções, consulte [COPY: parâmetros opcionais](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax-overview-optional-parameters)). Observe que, como essas opções são anexadas ao fim do comando `COPY`, apenas opções que façam sentido no final do comando podem ser usadas. Isso deve abranger a maioria dos casos de uso possíveis. |
| csvnullstring (experimental) | Não | NULL | O valor da string a ser gravado para nulos ao usar o `tempformat` CSV. Esse deve ser um valor que não apareça nos dados reais. |
Esses novos parâmetros podem ser usados como se segue.
**Novas opções para melhoria de performance**
O novo conector introduz algumas novas opções de melhoria de performance:
+ `autopushdown`: habilitado por padrão.
+ `autopushdown.s3_result_cache`: desabilitado por padrão.
+ `unload_s3_format`: `PARQUET` por padrão.
Para obter informações sobre como usar essas opções, consulte [Amazon Redshift integration for Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) (Integração do Amazon Redshift for Apache Spark). Recomendamos que você não ative o ` autopushdown.s3_result_cache` quando tiver operações mistas de leitura e gravação, pois os resultados em cache podem conter informações obsoletas. A opção `unload_s3_format` é definida como `PARQUET` por padrão para o comando `UNLOAD`, para melhorar a performance e reduzir o custo de armazenamento. Para usar o comportamento padrão do comando `UNLOAD`, redefina a opção como `TEXT`.
**Nova opção de criptografia para leitura**
Por padrão, os dados na pasta temporária usada pelo AWS Glue ao ler dados da tabela do Amazon Redshift são criptografados usando a criptografia `SSE-S3`. Para usar as chaves gerenciadas pelo cliente do AWS Key Management Service (AWS KMS) para criptografar dados, você pode configurar `("sse_kms_key" → kmsKey)` em que ksmKey é a [ID da chave do AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/find-cmk-id-arn.html), em vez da opção de configuração antiga `("extraunloadoptions" → s"ENCRYPTED KMS_KEY_ID '$kmsKey'")` no AWS Glue versão 3.0.
```
datasource0 = glueContext.create_dynamic_frame.from_catalog(
database = "database-name",
table_name = "table-name",
redshift_tmp_dir = args["TempDir"],
additional_options = {"sse_kms_key":""},
transformation_ctx = "datasource0"
)
```
**Compatibilidade com a URL JDBC baseada no IAM**
O novo conector é compatível com uma URL JDBC baseada no IAM para que você não precise passar um usuário/senha ou um segredo. Com uma URL JDBC baseada no IAM, o conector usa o perfil de runtime de trabalho para acessar a fonte de dados do Amazon Redshift.
Etapa 1: anexar a seguinte política mínima exigida ao perfil de runtime AWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "redshift:GetClusterCredentials",
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:dbgroup:/*",
"arn:aws:redshift:*:111122223333:dbuser:*/*",
"arn:aws:redshift:us-east-1:111122223333:dbname:/"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "redshift:DescribeClusters",
"Resource": "*"
}
]
}
```
------
Etapa 2: usar a URL do JDBC baseado em IAM como se segue. Especifique uma nova opção `DbUser` com o nome de usuário do Amazon Redshift com o qual você está se conectando.
```
conn_options = {
// IAM-based JDBC URL
"url": "jdbc:redshift:iam://:/",
"dbtable": dbtable,
"redshiftTmpDir": redshiftTmpDir,
"aws_iam_role": aws_iam_role,
"DbUser": "" // required for IAM-based JDBC URL
}
redshift_write = glueContext.write_dynamic_frame.from_options(
frame=dyf,
connection_type="redshift",
connection_options=conn_options
)
redshift_read = glueContext.create_dynamic_frame.from_options(
connection_type="redshift",
connection_options=conn_options
)
```
**nota**
Atualmente, um `DynamicFrame` é compatível apenas com uma URL JDBC baseada no IAM com um ` DbUser` no fluxo de trabalho `GlueContext.create_dynamic_frame.from_options`.
## Migrar do AWS Glue versão 3.0 para a versão 4.0
No AWS Glue 4.0, trabalhos de ETL têm acesso a um novo conector do Amazon Redshift Spark e um novo driver JDBC com opções e configurações diferentes. O novo conector e o novo driver do Amazon Redshift foram criados pensando em performance e mantêm a consistência transacional dos dados. Esses produtos estão documentados na documentação do Amazon Redshift. Para obter mais informações, consulte:
+ [Integração do Amazon Redshift for Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html)
+ [Driver JDBC do Amazon Redshift, versão 2.1](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-download-driver.html)
**Restrição de nomes e identificadores de tabelas/colunas**
O novo conector e driver do Amazon Redshift Spark têm um requisito mais restrito para o nome da tabela do Redshift. Para obter mais informações, consulte [Nomes e identificadores](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) para definir o nome da tabela do Amazon Redshift. O fluxo de trabalho de marcadores de trabalho pode não funcionar com um nome de tabela que não corresponda às regras e com determinados caracteres, como espaço.
Se você tiver tabelas antigas com nomes que não estão em conformidade com as regras de [nomes e identificadores](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) e tiver problemas com marcadores (trabalhos que reprocessam dados de tabelas antigas do Amazon Redshift), recomendamos que você renomeie as tabelas. Para obter mais informações, consulte [Exemplos de ALTER TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_TABLE_examples_basic.html).
**Alteração de tempformat padrão no Dataframe**
O conector Spark versão 3.0 da AWS Glue usa como padrão o `tempformat` para CSV ao gravar no Amazon Redshift. Para ser consistente, no AWS Glue versão 3.0, o ` DynamicFrame` ainda tem como padrão que o `tempformat` use `CSV`. Se você já usou APIs de Dataframe do Spark diretamente com o conector do Amazon Redshift Spark, você pode definir explicitamente o `tempformat` como CSV nas opções `DataframeReader`/`Writer`. Caso contrário, o padrão para `tempformat` é `AVRO` no novo conector Spark.
**Alteração de comportamento: mapeie o tipo de dados REAL do Amazon Redshift para o tipo de dados do FLOAT do Spark, em vez de DOUBLE**
No AWS Glue versão 3.0, o Amazon Redshift `REAL` é convertido em um tipo ` DOUBLE` do Spark. O novo conector do Amazon Redshift Spark atualizou o comportamento para que o tipo ` REAL` do Amazon Redshift seja convertido para o tipo `FLOAT` do Spark e vice-versa. Se você tiver um caso de uso antigo em que ainda desejar que o tipo `REAL` do Amazon Redshift seja mapeado para um tipo `DOUBLE` do Spark, poderá usar a seguinte solução alternativa:
+ Para um `DynamicFrame`, mapeie o tipo `Float` para um tipo `Double` com `DynamicFrame.ApplyMapping`. Para um `Dataframe`, você precisa usar `cast`.
Exemplo de código:
```
dyf_cast = dyf.apply_mapping([('a', 'long', 'a', 'long'), ('b', 'float', 'b', 'double')])
```
**Manipular o tipo de dados VARBYTE**
Ao trabalhar com tipos de dados do AWS Glue 3.0 e do Amazon Redshift, o AWS Glue 3.0 converte o `VARBYTE` Redshift para o tipo Spark `STRING`. No entanto, o conector Spark mais recente do Amazon Redshift não é compatível com o tipo de dados `VARBYTE`. Para contornar essa limitação, você pode [criar uma visualização do Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW.html) que transforma colunas `VARBYTE` em um tipo de dados compatível. Em seguida, use o novo conector para carregar dados dessa visualização em vez da tabela original, o que garante a compatibilidade e mantém o acesso aos seus dados `VARBYTE`.
Exemplo de consulta do Redshift:
```
CREATE VIEW view_name AS SELECT FROM_VARBYTE(varbyte_column, 'hex') FROM table_name
```
# Conexões do Kafka
É possível usar uma conexão do Kafka para ler e gravar fluxos de dados do Kafka usando informações armazenadas em uma tabela do Catálogo de Dados ou fornecendo informações para acessar diretamente o fluxo de dados. A conexão é compatível com um cluster do Kafka ou um cluster do Amazon Managed Streaming for Apache Kafka. Você pode ler informações do Kafka em um Spark DataFrame e depois convertê-las em um AWS Glue DynamicFrame. É possível gravar DynamicFrames no Kafka em um formato JSON. Se você acessar diretamente o fluxo de dados, use essas opções para fornecer as informações sobre como acessar o fluxo de dados.
Se você usar `getCatalogSource` ou `create_data_frame_from_catalog` para consumir registros de uma fonte de streaming do Kafka, ou `getCatalogSink` ou `write_dynamic_frame_from_catalog` para gravar registros no Kafka, e o trabalho tiver o banco de dados do catálogo de dados e as informações de nome da tabela, e poderá usá-los para obter alguns parâmetros básicos para leitura da fonte de streaming do Kafka. Se você usar `getSource`, `getCatalogSink`, `getSourceWithFormat`, `getSinkWithFormat`, `createDataFrameFromOptions`, `create_data_frame_from_options` ou `write_dynamic_frame_from_catalog`, será necessário especificar esses parâmetros básicos usando as opções de conexão descritas aqui.
Você pode especificar as opções de conexão para o Kafka usando os seguintes argumentos para os métodos especificados na classe `GlueContext`.
+ Scala
+ `connectionOptions`: usar com `getSource`, `createDataFrameFromOptions`, `getSink`
+ `additionalOptions`: usar com `getCatalogSource`, `getCatalogSink`
+ `options`: usar com `getSourceWithFormat`, `getSinkWithFormat`
+ Python
+ `connection_options`: usar com `create_data_frame_from_options`, `write_dynamic_frame_from_options`
+ `additional_options`: usar com `create_data_frame_from_catalog`, `write_dynamic_frame_from_catalog`
+ `options`: usar com `getSource`, `getSink`
Para notas e restrições sobre trabalhos de ETL de streaming, consulte [Notas e restrições sobre ETL de transmissão](add-job-streaming.md#create-job-streaming-restrictions).
**Topics**
+ [Configurar o Kafka](#aws-glue-programming-etl-connect-kafka-configure)
+ [Exemplo: leitura de fluxos do Kafka](#aws-glue-programming-etl-connect-kafka-read)
+ [Exemplo: gravação em fluxos do Kafka](#aws-glue-programming-etl-connect-kafka-write)
+ [Referência de opções de conexão do Kafka](#aws-glue-programming-etl-connect-kafka)
## Configurar o Kafka
Não há pré-requisitos da AWS para se conectar aos fluxos do Kafka disponíveis pela Internet.
Você pode criar uma conexão do AWS Glue Kafka para gerenciar suas credenciais de conexão. Para obter mais informações, consulte [Criar uma conexão do AWS Glue para um fluxo de dados do Apache Kafka](add-job-streaming.md#create-conn-streaming). Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional** e depois na chamada do método, forneça *connectionName* para o parâmetro `connectionName`.
Em certos casos, você precisará configurar pré-requisitos adicionais:
+ Se estiver usando o Amazon Managed Streaming for Apache Kafka com autenticação do IAM, você precisará da configuração apropriada do IAM.
+ Se estiver usando o Amazon Managed Streaming for Apache Kafka com uma Amazon VPC, você precisará da configuração apropriada do Amazon VPC. Você precisará criar uma conexão do AWS Glue que forneça informações de conexão com o Amazon VPC. Você precisará que a configuração do trabalho inclua a conexão do AWS Glue como uma **conexão de rede adicional**.
Para obter mais informações sobre pré-requisitos de trabalho de ETL de streaming, consulte [Trabalhos de transmissão de ETL no AWS Glue](add-job-streaming.md).
## Exemplo: leitura de fluxos do Kafka
Usado em conjunto com [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Exemplo para fonte de transmissão do Kafka:
```
kafka_options =
{ "connectionName": "ConfluentKafka",
"topicName": "kafka-auth-topic",
"startingOffsets": "earliest",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kafka", connection_options=kafka_options)
```
## Exemplo: gravação em fluxos do Kafka
Exemplos de gravação no Kafka:
Exemplo com o método `getSink`:
```
data_frame_datasource0 =
glueContext.getSink(
connectionType="kafka",
connectionOptions={
JsonOptions("""{
"connectionName": "ConfluentKafka",
"classification": "json",
"topic": "kafka-auth-topic",
"typeOfData": "kafka"}
""")},
transformationContext="dataframe_ApacheKafka_node1711729173428")
.getDataFrame()
```
Exemplo com o método `write_dynamic_frame.from_options`:
```
kafka_options =
{ "connectionName": "ConfluentKafka",
"topicName": "kafka-auth-topic",
"classification": "json"
}
data_frame_datasource0 = glueContext.write_dynamic_frame.from_options(connection_type="kafka", connection_options=kafka_options)
```
## Referência de opções de conexão do Kafka
Ao ler, use as seguintes opções de conexão com `"connectionType": "kafka"`:
+ `"bootstrap.servers"` (obrigatório) uma lista de URLs do servidor de bootstrap, por exemplo, como `b-1.vpc-test-2.o4q88o.c6.kafka.us-east-1.amazonaws.com:9094`. Essa opção deve ser especificada na chamada de API ou definida nos metadados da tabela no Data Catalog.
+ `"security.protocol"` (obrigatório) O protocolo usado para se comunicar com os agentes. Os valores possíveis são `"SSL"` ou `"PLAINTEXT"`.
+ `"topicName"` (Obrigatório): uma lista separada por vírgulas de tópicos para assinar. É necessário especificar um e apenas um de `"topicName"`, `"assign"` ou `"subscribePattern"`.
+ `"assign"` (Obrigatório): uma string JSON para especificar o `TopicPartitions` a ser consumido. É necessário especificar um e apenas um de `"topicName"`, `"assign"` ou `"subscribePattern"`.
Exemplo: '\$1"topicA":[0,1],"topicB":[2,4]\$1'
+ `"subscribePattern"`: (obrigatório) uma string regex Java que identifica a lista de tópicos para assinar. É necessário especificar um e apenas um de `"topicName"`, `"assign"` ou `"subscribePattern"`.
Exemplo: 'topic.\$1'
+ `"classification"` (Obrigatório) O formato de arquivo usado pelos dados no registro. Obrigatório, a menos que fornecido por meio do catálogo de dados.
+ `"delimiter"` (Opcional) O separador de valores usado quando a `classification` é CSV. O padrão é "`,`".
+ `"startingOffsets"`: (opcional) a posição inicial no tópico do Kafka de onde ler os dados. Os valores possíveis são `"earliest"` ou `"latest"`. O valor padrão é `"latest"`.
+ `"startingTimestamp"`: (opcional, compatível somente com o AWS Glue versão 4.0 ou posterior) O timestamp do registro no tópico do Kafka do qual ler os dados. O valor possível é uma string de timestamp no formato UTC no padrão `yyyy-mm-ddTHH:MM:SSZ` (onde `Z` representa um desvio do fuso horário UTC com \$1/-). Por exemplo: "2023-04-04T08:00:00-04:00").
Observação: somente um dos 'startingOffsets' ou 'startingTimestamp' pode estar presente na lista de opções de conexão do script de streaming do AWS Glue. A inclusão de ambas as propriedades resultará em falha no trabalho.
+ `"endingOffsets"`: (opcional) o ponto final quando uma consulta em lote é encerrada. Os valores possíveis são `"latest"` ou uma string JSON que especifica um deslocamento final para cada `TopicPartition`.
Para a string JSON, o formato é `{"topicA":{"0":23,"1":-1},"topicB":{"0":-1}}`. O valor `-1` como um deslocamento representa `"latest"`.
+ `"pollTimeoutMs"`: (opcional) o tempo limite em milissegundos para sondar dados do Kafka em executores de trabalho do Spark. O valor padrão é `600000`.
+ `"numRetries"`: (opcional) o número de novas tentativas antes de falhar em obter os deslocamentos do Kafka. O valor padrão é `3`.
+ `"retryIntervalMs"`: (opcional) o tempo em milissegundos a se esperar antes de tentar novamente buscar os deslocamentos do Kafka. O valor padrão é `10`.
+ `"maxOffsetsPerTrigger"`: (opcional) o limite de taxa no número máximo de deslocamentos que são processados por intervalo do acionador. O número total especificado de deslocamentos é dividido proporcionalmente entre `topicPartitions` de diferentes volumes. O valor padrão é nulo, o que significa que o consumidor lê todos os deslocamentos até o deslocamento mais recente conhecido.
+ `"minPartitions"`: (opcional) o número mínimo desejado de partições a serem lidas do Kafka. O valor padrão é nulo, o que significa que o número de partições do Spark é igual ao número de partições do Kafka.
+ `"includeHeaders"`: (opcional) informa se deve incluir os cabeçalhos do Kafka. Quando a opção estiver definida como "true", a saída de dados conterá uma coluna adicional chamada "glue\$1streaming\$1kafka\$1headers" com o tipo `Array[Struct(key: String, value: String)]`. O valor padrão é “false”. Essa opção está disponível no AWS Glue versão 3.0 ou posterior.
+ `"schema"` (Obrigatório quando inferSchema é definido como false): o esquema a ser usado para processar a carga útil. Se a classificação for `avro`, o esquema fornecido deverá estar no formato de esquema Avro. Se a classificação não for `avro`, o esquema fornecido deverá estar no formato de esquema DDL.
Veja a seguir alguns exemplos de esquema.
------
#### [ Example in DDL schema format ]
```
'column1' INT, 'column2' STRING , 'column3' FLOAT
```
------
#### [ Example in Avro schema format ]
```
{
"type":"array",
"items":
{
"type":"record",
"name":"test",
"fields":
[
{
"name":"_id",
"type":"string"
},
{
"name":"index",
"type":
[
"int",
"string",
"float"
]
}
]
}
}
```
------
+ `"inferSchema"` (Opcional): o valor padrão é "false". Se definido como “true”, o esquema será detectado em runtime com base na carga útil em `foreachbatch`.
+ `"avroSchema"` (Descontinuado): parâmetro usado para especificar um esquema de dados Avro quando o formato Avro é usado. Esse parâmetro foi descontinuado. Use o parâmetro `schema`.
+ `"addRecordTimestamp"`: (opcional) quando essa opção for definida como “true“, a saída de dados conterá uma coluna adicional denominada “\$1\$1src\$1timestamp” que indica a hora em que o registro correspondente foi recebido pelo tópico. O valor padrão é "false". Essa opção é compatível com o AWS Glue versão 4.0 ou posterior.
+ `"emitConsumerLagMetrics"`: (opcional) quando a opção for definida como "true", para cada lote, serão emitidas métricas durante o período entre a hora que o registro mais antigo é recebido pelo tópico e a hora que ele chega ao AWS Glue para o CloudWatch. O nome da métrica é "glue.driver.streaming.maxConsumerLagInMs". O valor padrão é "false". Essa opção é compatível com o AWS Glue versão 4.0 ou posterior.
Ao gravar, use as seguintes opções de conexão com o `"connectionType": "kafka"`:
+ `"connectionName"` (Obrigatório) Nome da conexão do AWS Glue usada para se conectar ao cluster do Kafka (semelhante à origem do Kafka).
+ `"topic"` (Obrigatório) Se uma coluna de tópico existir, seu valor será usado como tópico ao gravar a linha especificada no Kafka, a menos que a opção de configuração do tópico esteja definida. Ou seja, a opção de configuração `topic` substitui a coluna do tópico.
+ `"partition"` (Opcional) Se um número de partição válido for especificado, essa `partition` será usada no envio do registro.
Se nenhuma partição for especificada, mas uma `key` estiver presente, uma partição será escolhida usando um hash da chave.
Se nem `key` nem `partition` estiverem presentes, uma partição será escolhida com base no particionamento fixo dessas alterações quando pelo menos bytes batch.size forem produzidos na partição.
+ `"key"` (Opcional) Usado para particionar se `partition` for nulo.
+ `"classification"` (Opcional) O formato de arquivo usado pelos dados no registro. Só oferecemos suporte a JSON, CSV e Avro.
Com o formato Avro, podemos fornecer um avroSchema personalizado para serializar, mas observe que isso também precisa ser fornecido na fonte para desserialização. Caso contrário, por padrão, ele usa o Apache AvroSchema para serializar.
Além disso, você pode ajustar o coletor Kafka conforme necessário atualizando os [parâmetros de configuração do produtor Kafka](https://kafka.apache.org/documentation/#producerconfigs). Observe que não há nenhuma lista de permissões nas opções de conexão. Todos os pares de chave-valor são mantidos no coletor como estão.
No entanto, há uma pequena lista de opções negadas que não entrarão em vigor. Para obter mais informações, consulte [Configurações específicas do Kafka](https://spark.apache.org/docs/latest/structured-streaming-kafka-integration.html).
# Conexões do Azure Cosmos DB
O AWS Glue para Spark pode ser usado para ler e escrever em contêineres existentes no Azure Cosmos DB usando a API NoSQL no AWS Glue 4.0 e versões posteriores. Você pode definir o que ler no Azure Cosmos DB com uma consulta SQL. Conecte-se ao Azure Cosmos DB usando uma chave do Azure Cosmos DB armazenada no AWS Secrets Manager via conexão do AWS Glue.
Para obter mais informações sobre o Azure Cosmos DB para NoSQL, consulte a [Documentação do Azure](https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/).
## Configurar conexões do Azure Cosmos DB
Para se conectar ao Azure Cosmos DB via AWS Glue, será necessário criar e armazenar sua chave do Azure Cosmos DB em um segredo do AWS Secrets Manager e, em seguida, associar esse segredo a uma conexão do Azure Cosmos DB AWS Glue.
**Pré-requisitos:**
+ No Azure, será necessário identificar ou gerar uma chave do Azure Cosmos DB para uso pelo AWS Glue, `cosmosKey`. Para obter mais informações, consulte [Acesso seguro a dados no Azure Cosmos DB](https://learn.microsoft.com/en-us/azure/cosmos-db/secure-access-to-data?tabs=using-primary-key) na documentação do Azure.
**Para configurar uma conexão com o Azure Cosmos DB:**
1. No AWS Secrets Manager, crie um segredo usando sua chave do Azure Cosmos DB. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criar uma AWS Secrets Manager segredo ](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `spark.cosmos.accountKey` com o valor *cosmosKey*.
1. No console do AWS Glue, crie uma conexão seguindo as etapas em [Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para uso futuro no AWS Glue.
+ Ao selecionar um **Tipo de conexão**, selecione Azure Cosmos DB.
+ Ao selecionar um **Segredo da AWS**, forneça o *secretName*.
Depois de criar uma conexão AWS Glue Azure Cosmos DB, siga estas etapas antes de executar seu trabalho do AWS Glue:
+ Conceda ao perfil do IAM associada ao seu trabalho do AWS Glue permissão para ler *secretName*.
+ Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
## Ler de contêineres do Azure Cosmos DB para NoSQL
**Pré-requisitos:**
+ Um contêiner do Azure Cosmos DB para NoSQL do qual você gostaria de ler. Você precisará de informações de identificação para o contêiner.
Um contêiner do Azure Cosmos para NoSQL é identificado por seu banco de dados e contêiner. É necessário fornecer os nomes do banco de dados, *cosmosDBName* e do contêiner, *cosmosContainerName*, ao se conectar à API do Azure Cosmos para NoSQL.
+ Uma conexão do AWS Glue Azure Cosmos DB configurada para fornecer informações de autenticação e localização da rede. Para fazer isso, conclua as etapas do procedimento anterior, *Para configurar uma conexão com o Azure Cosmos DB*. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
azurecosmos_read = glueContext.create_dynamic_frame.from_options(
connection_type="azurecosmos",
connection_options={
"connectionName": connectionName,
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName,
}
)
```
Você também pode fornecer uma consulta SQL SELECT para filtrar os resultados retornados ao seu DynamicFrame. Você precisará configurar `query`.
Por exemplo:
```
azurecosmos_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="azurecosmos",
connection_options={
"connectionName": "connectionName",
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName,
"spark.cosmos.read.customQuery": "query"
}
)
```
## Escrever em contêineres do Azure Cosmos DB para NoSQL
Este exemplo escreve informações de um DynamicFrame existente, *dynamicFrame*, no Azure Cosmos DB. Se o contêiner já contiver informações, o AWS Glue anexará dados do seu DynamicFrame. Se as informações no contêiner tiverem um esquema diferente das informações que você escrever, haverá erros.
**Pré-requisitos:**
+ Uma tabela do Azure Cosmos DB em que você deseja escrever. Você precisará de informações de identificação para o contêiner. **É necessário criar o contêiner antes de chamar o método de conexão.**
Um contêiner do Azure Cosmos para NoSQL é identificado por seu banco de dados e contêiner. É necessário fornecer os nomes do banco de dados, *cosmosDBName* e do contêiner, *cosmosContainerName*, ao se conectar à API do Azure Cosmos para NoSQL.
+ Uma conexão do AWS Glue Azure Cosmos DB configurada para fornecer informações de autenticação e localização da rede. Para fazer isso, conclua as etapas do procedimento anterior, *Para configurar uma conexão com o Azure Cosmos DB*. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
azurecosmos_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="azurecosmos",
connection_options={
"connectionName": connectionName,
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName
)
```
## Referência de opções de conexão do Azure Cosmos DB
+ `connectionName` — Obrigatório. Usado para leitura/gravação. O nome de uma conexão AWS Glue Azure Cosmos DB configurada para fornecer informações de autenticação e localização da rede ao seu método de conexão.
+ `spark.cosmos.database` — Obrigatório. Usado para leitura/gravação. Valores válidos: nomes de bancos de dados. Nome do banco de dados do Azure Cosmos DB para NoSQL.
+ `spark.cosmos.container` — Obrigatório. Usado para leitura/gravação. Valores válidos: nomes de contêineres. Nome do contêiner do Azure Cosmos DB para NoSQL.
+ `spark.cosmos.read.customQuery` - Usado para leitura. Valores válidos: consultas SQL SELECT. Consulta personalizada para selecionar documentos a serem lidos.
# Conexões do Azure SQL
O AWS Glue para Spark pode ser usado para ler e gravar em tabelas em instâncias gerenciadas do Azure SQL no AWS Glue 4.0 e versões posteriores. Você pode definir o que ler no Azure SQL com uma consulta SQL. Conecte-se ao Azure SQL usando credenciais de usuário e senha armazenadas no AWS Secrets Manager via conexão do AWS Glue.
Para obter mais informações sobre o Azure SQL, consulte a [Documentação do Azure SQL](https://azure.microsoft.com/en-us/products/azure-sql).
## Configurar conexões do Azure SQL
Para se conectar ao Azure SQL via AWS Glue, será necessário criar e armazenar sua credenciais do Azure SQL em um segredo do AWS Secrets Manager e, em seguida, associar esse segredo a uma conexão do Azure SQL AWS Glue.
**Para configurar uma conexão com o Azure SQL:**
1. No AWS Secrets Manager, crie um segredo usando suas credenciais do Azure SQL. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criar uma AWS Secrets Manager segredo ](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `user` com o valor *azuresqlUsername*.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `password` com o valor *azuresqlPassword*.
1. No console do AWS Glue, crie uma conexão seguindo as etapas em [Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para uso futuro no AWS Glue.
+ Ao selecionar um **Tipo de conexão**, selecione Azure SQL.
+ Ao fornecer o **URL do Azure SQL**, forneça um URL de endpoint do JDBC.
Essa lista deve estar no seguinte formato: `jdbc:sqlserver://databaseServerName:databasePort;databaseName=azuresqlDBname;`.
O AWS Glue requer as seguintes propriedades de URL:
+ `databaseName`: um banco de dados padrão no Azure SQL ao qual se conectar.
Para obter mais informações sobre URLs de JDBC para instâncias gerenciadas Azure SQL, consulte a [Documentação da Microsoft](https://learn.microsoft.com/en-us/sql/connect/jdbc/building-the-connection-url?view=azuresqldb-mi-current).
+ Ao selecionar um **Segredo da AWS**, forneça o *secretName*.
Depois de criar uma conexão AWS Glue Azure SQL, siga estas etapas antes de executar seu trabalho do AWS Glue:
+ Conceda ao perfil do IAM associada ao seu trabalho do AWS Glue permissão para ler *secretName*.
+ Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
## Ler de tabelas SQL do Azure
**Pré-requisitos:**
+ Uma tabela do Azure SQL da qual você deseja ler. Você precisará de informações de identificação para a tabela, *databaseName* e *tableIdentifier*.
Uma tabela do Azure SQL é identificada por seu banco de dados, esquema e nome da tabela. É necessário fornecer o nome do banco de dados e o nome da tabela ao se conectar ao Azure SQL. Você também deverá fornecer o esquema se ele não for o padrão, "public". O banco de dados é fornecido por meio de uma propriedade de URL em *connectionName*, esquema e nome da tabela via `dbtable`.
+ Uma conexão AWS Glue Azure SQL configurada para fornecer informações de autenticação. Conclua as etapas do procedimento anterior, *Para configurar uma conexão com o Azure SQL* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
azuresql_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier"
}
)
```
Você também pode fornecer uma consulta SQL SELECT para filtrar os resultados retornados ao seu DynamicFrame. Você precisará configurar `query`.
Por exemplo:
```
azuresql_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Escrevendo em tabelas do Azure SQL
Este exemplo escreve informações de um DynamicFrame existente, *dynamicFrame*, no Azure SQL. Se a tabela já contiver informações, o AWS Glue anexará dados do seu DynamicFrame.
**Pré-requisitos:**
+ Uma tabela do Azure SQL em que você deseja escrever. Você precisará de informações de identificação para a tabela, *databaseName* e *tableIdentifier*.
Uma tabela do Azure SQL é identificada por seu banco de dados, esquema e nome da tabela. É necessário fornecer o nome do banco de dados e o nome da tabela ao se conectar ao Azure SQL. Você também deverá fornecer o esquema se ele não for o padrão, "public". O banco de dados é fornecido por meio de uma propriedade de URL em *connectionName*, esquema e nome da tabela via `dbtable`.
+ Informações de autenticação do Azure SQL. Conclua as etapas do procedimento anterior, *Para configurar uma conexão com o Azure SQL* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
azuresql_write = glueContext.write_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier"
}
)
```
## Referência de opções de conexão do Azure SQL
+ `connectionName` — Obrigatório. Usado para leitura/gravação. O nome de uma conexão AWS Glue Azure SQL configurada para fornecer informações de autenticação e localização da rede ao seu método de conexão.
+ `databaseName`: usado para leitura/gravação. Valores válidos: nomes de bancos de dados do Azure SQL. O nome do banco de dados do Azure SQL ao qual conectar.
+ `dbtable`: necessário para escrever, obrigatório para leitura, a menos que `query` seja fornecido. Usado para leitura/gravação. Valores válidos: nomes de tabelas do Azure SQL ou combinações de nomes de esquema/tabela separados por pontos. Usado para especificar a tabela e o esquema que identificam a tabela à qual conectar. O esquema padrão é "public". Se sua tabela estiver em um esquema não padrão, forneça essas informações no formulário `schemaName.tableName`.
+ `query` - Usado para leitura. Uma consulta SQL SELECT que define o que deve ser recuperado na leitura do Azure SQL. Para obter mais informações, consulte a [Documentação da Microsoft](https://learn.microsoft.com/en-us/sql/t-sql/queries/select-transact-sql?view=azuresqldb-mi-current).
# Conexões BigQuery
Você pode usar o AWS Glue for Spark para ler e gravar tabelas no Google BigQuery no AWS Glue 4.0 e versões posteriores. Você pode ler no BigQuery com uma consulta do Google SQL. Você se conecta ao BigQuery usando credenciais armazenadas AWS Secrets Manager por meio de uma conexão AWS Glue.
Para obter mais informações sobre o Google BigQuery, consulte o [site do Google Cloud BigQuery](https://cloud.google.com/bigquery).
## Configurar conexões BigQuery
Para se conectar ao Google BigQuery a partir do AWS Glue, você precisará criar e armazenar suas credenciais do Google Cloud Platform em um segredo e, em seguida, associar esse AWS Secrets Manager segredo a uma conexão do Google BigQuery AWS Glue.
**Para configurar uma conexão com o BigQuery:**
1. No Google Cloud Platform, crie e identifique recursos relevantes:
+ Crie ou identifique um projeto do GCP contendo tabelas do BigQuery às quais você gostaria de se conectar.
+ Ative a API BigQuery. Para obter mais informações, consulte [Use the BigQuery Storage Read API to read na tabela](https://cloud.google.com/bigquery/docs/reference/storage/#enabling_the_api).
1. No Google Cloud Platform, crie e exporte as credenciais da conta de serviço:
[Você pode usar o assistente de credenciais do BigQuery para acelerar essa etapa: criar credenciais.](https://console.cloud.google.com/apis/credentials/wizard?api=bigquery.googleapis.com)
Para criar uma conta de serviço no GCP, siga o tutorial disponível em [Criar contas de serviço](https://cloud.google.com/iam/docs/service-accounts-create).
+ Ao selecionar o **projeto**, selecione o projeto que contém sua tabela do BigQuery.
+ Ao selecionar perfis do IAM do GCP para sua conta de serviço, adicione ou crie um papel que conceda permissões apropriadas para executar jobs do BigQuery para ler, gravar ou criar tabelas do BigQuery.
Para criar credenciais para a sua conta de serviço, siga o tutorial disponível em [Criar uma chave da conta de serviço](https://cloud.google.com/iam/docs/keys-create-delete#creating).
+ Ao selecionar o tipo de chave, selecione **JSON**.
Agora você deve ter baixado um arquivo JSON com credenciais para sua conta de serviço. A aparência deve ser semelhante à seguinte:
```
{
"type": "service_account",
"project_id": "*****",
"private_key_id": "*****",
"private_key": "*****",
"client_email": "*****",
"client_id": "*****",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "*****",
"universe_domain": "googleapis.com"
}
```
1. Carregue seu arquivo JSON de credenciais em um local do Amazon S3 adequadamente seguro. Guarde o caminho para o arquivo, *s3secretpath, para futuras etapas*.
1. Nos AWS Secrets Manager, crie um segredo usando suas credenciais do Google Cloud Platform. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criar uma AWS Secrets Manager segredo ](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
Ao criar pares de chave/valor, especifique chaves e valores da seguinte forma:
+ Para chaves `token_uri`, `client_x509_cert_url`, `private_key_id`, `project_id`, `universe_domain`, `auth_provider_x509_cert_url`, `auth_uri`, `client_email`, `private_key`, `type` e `client_id`, especifique os valores correspondentes no arquivo JSON baixado.
+ Para a chave `spark.hadoop.google.cloud.auth.service.account.json.keyfile`, especifique o *s3secretpath*.
1. No catálogo de dados do AWS Glue, crie uma conexão seguindo as etapas em [Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para a próxima etapa.
+ Ao selecionar um **tipo de conexão**, selecione Google BigQuery.
+ Ao selecionar um **Segredo da AWS**, forneça o *secretName*.
1. Conceda ao perfil do IAM associada ao seu trabalho do AWS Glue permissão para ler *secretName*.
1. Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
## Ler das tabelas do BigQuery
**Pré-requisitos:**
+ Uma tabela do BigQuery que você deseja ler. Você precisará dos nomes da tabela e do conjunto de dados do BigQuery no formulário `[dataset].[table]`. Vamos chamar isso de *tableName*.
+ O projeto de faturamento da tabela do BigQuery. Você precisará do nome do projeto, *ParentProject*. Se não houver um projeto principal de cobrança, use o projeto que contém a tabela.
+ Informações de autenticação do BigQuery. Conclua as etapas *para gerenciar suas credenciais de conexão com o AWS Glue* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
bigquery_read = glueContext.create_dynamic_frame.from_options(
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"sourceType": "table",
"table": "tableName",
}
```
Você também pode fornecer uma consulta para filtrar os resultados retornados ao seu DynamicFrame. Você precisará configurar `query`, `sourceType`, `viewsEnabled` e `materializationDataset`.
Por exemplo:
**Pré-requisitos adicionais:**
Você precisará criar ou identificar um conjunto de dados do BigQuery, *MaterializationDataset, em que o BigQuery possa escrever visualizações materializadas* para suas consultas.
Você precisará conceder as permissões apropriadas do GCP IAM à sua conta de serviço para criar tabelas no *MaterializationDataset*.
```
glueContext.create_dynamic_frame.from_options(
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"materializationDataset": materializationDataset,
"parentProject": "parentProject",
"viewsEnabled": "true",
"sourceType": "query",
"query": "select * from bqtest.test"
}
)
```
## Gravar em tabelas do BigQuery
Este exemplo grava diretamente no serviço BigQuery. O BigQuery também é compatível com o método de escrita “indireto”. Para obter mais informações sobre como configurar gravações indiretas, consulte [Usar gravação indireta com o Google BigQuery](#aws-glue-programming-etl-connect-bigquery-indirect-write).
**Pré-requisitos:**
+ Uma tabela do BigQuery na qual você gravar. Você precisará dos nomes da tabela e do conjunto de dados do BigQuery no formulário `[dataset].[table]`. Você também pode fornecer um novo nome de tabela que será criado automaticamente. Vamos chamar isso de *tableName*.
+ O projeto de faturamento da tabela do BigQuery. Você precisará do nome do projeto, *ParentProject*. Se não houver um projeto principal de cobrança, use o projeto que contém a tabela.
+ Informações de autenticação do BigQuery. Conclua as etapas *para gerenciar suas credenciais de conexão com o AWS Glue* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
bigquery_write = glueContext.write_dynamic_frame.from_options(
frame=frameToWrite,
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"writeMethod": "direct",
"table": "tableName",
}
)
```
## Referência de opções de conexão BigQuery
+ `project` — Padrão: conta de serviço padrão do Google Cloud. Usado para leitura/gravação. O nome de um projeto do Google Cloud associado à sua tabela.
+ `table`: (obrigatório) usado para leitura/gravação. O nome da sua tabela do BigQuery no formato `[[project:]dataset.]`.
+ `dataset` — Obrigatório quando não definido por meio da `table` opção. Usado para leitura/gravação. O nome do conjunto de dados que contém sua tabela do BigQuery.
+ `parentProject` — Padrão: conta de serviço padrão do Google Cloud. Usado para leitura/gravação. O nome de um projeto do Google Cloud associado ao `project` usado para faturamento.
+ `sourceType` - Usado para leitura. Obrigatório ao ler. Valores válidos: `table`, `query` informa ao AWS Glue se você lerá por tabela ou por consulta.
+ `materializationDataset` - Usado para leitura. Valores válidos: strings. O nome de um conjunto de dados do BigQuery usado para armazenar materializações para visualizações.
+ `viewsEnabled` - Usado para leitura. Padrão: falso. Valores válidos: true, false Configura se o BigQuery usará visualizações.
+ `query` - Usado para leitura. Usado quando `viewsEnabled` for verdadeiro. Uma consulta DQL do GoogleSQL.
+ `temporaryGcsBucket` — Usado para escrever. Obrigatório quando `writeMethod` estiver definido como padrão (`indirect`). Nome de um bucket do Google Cloud Storage usado para armazenar uma forma intermediária dos seus dados ao gravar no BigQuery.
+ `writeMethod` — padrão: `indirect`. Valores válidos: `direct`, `indirect`. Usado para gravação. Especifica o método usado para gravar seus dados.
+ Se definido como `direct`, seu conector gravará usando a API BigQuery Storage Write.
+ Se definido como `indirect`, seu conector gravará no Google Cloud Storage e o transferirá para o BigQuery usando uma operação de carregamento. Sua conta de serviço do Google Cloud precisará das permissões apropriadas do GCS.
## Usar gravação indireta com o Google BigQuery
Este exemplo usa gravação indireta, que grava dados no Google Cloud Storage e os copia para o Google BigQuery.
**Pré-requisitos:**
Você precisará de um bucket temporário do Google Cloud Storage, *TemporaryBucket*.
*O papel do GCP IAM para a conta de serviço do GCP do AWS Glue precisará das permissões apropriadas do GCS para acessar o TemporaryBucket.*
**Configuração adicional:**
**Para configurar a gravação indireta com o BigQuery:**
1. Avalie [Configurar conexões BigQuery](#aws-glue-programming-etl-connect-bigquery-configure) e localize ou baixe novamente seu arquivo JSON de credenciais do GCP. Identifique *secretName*, o AWS Secrets Manager segredo da conexão do Google BigQuery AWS Glue usada em seu trabalho.
1. Carregue seu arquivo JSON de credenciais em um local do Amazon S3 adequadamente seguro. Guarde o caminho para o arquivo, *s3secretpath, para futuras etapas*.
1. Edite *SecretName*, adicionando a `spark.hadoop.google.cloud.auth.service.account.json.keyfile` chave. Defina o valor como *s3secretpath*.
1. *Conceda ao seu trabalho do AWS Glue permissões do Amazon S3 IAM para acessar s3secretpath.*
Agora você pode fornecer a localização temporária do bucket do GCS ao seu método de gravação. Você não precisa fornecer `writeMethod`, pois historicamente `indirect` é o padrão.
```
bigquery_write = glueContext.write_dynamic_frame.from_options(
frame=frameToWrite,
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"temporaryGcsBucket": "temporaryBucket",
"table": "tableName",
}
)
```
# Conexões JDBC
Certos tipos de banco de dados, geralmente relacionais, são compatíveis com conexão por meio do padrão JDBC. Para obter mais informações sobre o JDBC, consulte a documentação da [Java JDBC API](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/). O AWS Glue oferece suporte nativo à conexão a determinados bancos de dados por meio de conectores JDBC; as bibliotecas JDBC são fornecidas nos trabalhos do AWS Glue Spark. Ao se conectar a esses tipos de banco de dados usando as bibliotecas do AWS Glue, você tem acesso a um conjunto padrão de opções.
Os valores JDBCConnectionType incluem o seguinte:
+ `"connectionType": "sqlserver"`: Designa uma conexão a um banco de dados do Microsoft SQL Server.
+ `"connectionType": "mysql"`: designa uma conexão com um banco de dados MySQL.
+ `"connectionType": "oracle"`: designa uma conexão com um banco de dados Oracle.
+ `"connectionType": "postgresql"`: designa uma conexão com um banco de dados PostgreSQL.
+ `"connectionType": "redshift"`: designa uma conexão com um banco de dados do Amazon Redshift. Para obter mais informações, consulte [Conexões do Redshift](aws-glue-programming-etl-connect-redshift-home.md).
A tabela a seguir lista as versões de driver do JDBC compatíveis com o AWS Glue.
| Produto | Versões do driver JDBC para o Glue 5.1 | Versões do driver JDBC para o Glue 5.0 | Versões do driver JDBC para o Glue 4.0 | Versões do driver JDBC para o Glue 3.0 | Versões do driver JDBC para o Glue 0.9, 1.0, 2.0 |
| --- | --- | --- | --- | --- | --- |
| Microsoft SQL Server | 10.2.0 | 10.2.0 | 9.4.0 | 7.x | 6.x |
| MySQL | 8.0.33 | 8.0.33 | 8.0.23 | 8.0.23 | 5.1 |
| Oracle Database | 23.3.0.23.09 | 23.3.0.23.09 | 21.7 | 21.1 | 11.2 |
| PostgreSQL | 42.7.3 | 42.7.3 | 42.3.6 | 42.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 Para o tipo de conexão do Amazon Redshift, todas as outras opções de pares nome/valor que estão incluídas nas opções de conexão para uma conexão JDBC, incluindo opções de formatação, são passadas diretamente para a fonte de dados SparkSQL subjacente. Nos trabalhos do AWS Glue com Spark no AWS Glue 4.0 e versões posteriores, o conector nativo do AWS Glue para o Amazon Redshift usa a integração do Amazon Redshift para o Apache Spark. Para obter informações sobre como usar essas opções, consulte [Integração do Amazon Redshift para o Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Nas versões anteriores, consulte a [fonte de dados do Amazon Redshift para Spark](https://github.com/databricks/spark-redshift).
Para configurar a Amazon VPC para se conectar aos armazenamentos de dados do Amazon RDS usando JDBC, consulte [Configurar um Amazon VPC para conexões JDBC aos armazenamentos de dados do Amazon RDS desde o AWS Glue](setup-vpc-for-glue-access.md).
**nota**
Os trabalhos do AWS são associados apenas a uma sub-rede durante uma execução. Isso pode afetar sua capacidade de se conectar a várias fontes de dados por meio do mesmo trabalho. Esse comportamento não se limita às fontes JDBC.
**Topics**
+ [Referência de opções de conexão JDBC](#aws-glue-programming-etl-connect-jdbc)
+ [Usar sampleQuery](#aws-glue-programming-etl-jdbc-samplequery)
+ [Usar o driver JDBC personalizado](#aws-glue-programming-etl-jdbc-custom-driver)
+ [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md)
+ [Configurar um Amazon VPC para conexões JDBC aos armazenamentos de dados do Amazon RDS desde o AWS Glue](setup-vpc-for-glue-access.md)
## Referência de opções de conexão JDBC
Se você já tiver uma conexão JDBC do AWS Glue definida, poderá reutilizar as propriedades de configuração nela definidas, como: url, usuário e senha, para não precisar especificá-las no código como opções de conexão. Esse atributo só está disponível no AWS Glue 3.0 e versões posteriores. Para fazer isso, use as seguintes propriedades de conexão:
+ `"useConnectionProperties"`: defina como "true" para indicar que você deseja usar a configuração de uma conexão.
+ `"connectionName"`: insira o nome da conexão da qual recuperar a configuração; a conexão deve ser definida na mesma região da tarefa.
Use estas opções de conexão com conexões JDBC:
+ `"url"`: (Obrigatório) O URL do JDBC para o banco de dados.
+ `"dbtable"`: (obrigatório) o banco de dados a ser lido. Para armazenamentos de dados JDBC que oferecem suporte a esquemas dentro de um banco de dados, especifique `schema.table-name`. Se um esquema não for fornecido, o esquema "público" padrão será usado.
+ `"user"`: (obrigatório) o nome de usuário a ser usado ao se conectar.
+ `"password"`: (Obrigatório) A senha a ser usada ao se conectar.
+ (Opcional) As opções a seguir permitem que você forneça um driver do JDBC personalizado. Use estas opções se for necessário usar um driver que não seja compatível nativamente com o AWS Glue.
Os trabalhos de ETL podem usar diferentes versões de driver JDBC para o destino e a fonte de dados, mesmo que o destino e a origem sejam o mesmo produto de banco de dados. Isso permite migrar dados entre bancos de dados de fonte e de destino com versões diferentes. Para usar estas opções, é necessário primeiro fazer upload do arquivo JAR do driver do JDBC para o Amazon S3.
+ `"customJdbcDriverS3Path"`: o caminho no Amazon S3 do driver JDBC personalizado.
+ `"customJdbcDriverClassName"`: o nome da classe do driver JDBC.
+ `"bulkSize"`: (opcional) usado para configurar inserções paralelas para acelerar cargas em massa em destinos de JDBC. Especifique um valor inteiro para o grau de paralelismo a ser usado ao gravar ou inserir dados. Essa opção é útil para melhorar a performance de gravações em bancos de dados, como o Arch User Repository (AUR).
+ `"hashfield"` (Opcional) Uma string, usada para especificar o nome de uma coluna na tabela JDBC a ser usada para dividir os dados em partições ao ler tabelas JDBC em paralelo. Forneça "hashfield" OU "hashexpression". Para obter mais informações, consulte [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md).
+ `"hashexpression"` (Opcional) Uma cláusula de seleção SQL retornando um número inteiro. Usada para dividir os dados em uma tabela JDBC em partições ao ler tabelas JDBC em paralelo. Forneça "hashfield" OU "hashexpression". Para obter mais informações, consulte [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md).
+ `"hashpartitions"` (Opcional) Um número inteiro positivo. Usado para especificar o número de leituras paralelas da tabela JDBC ao ler tabelas JDBC em paralelo. Padrão: 7. Para obter mais informações, consulte [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md).
+ `"sampleQuery"`: (opcional) uma instrução de consulta SQL personalizada. Usada para especificar um subconjunto de informações em uma tabela para recuperar uma amostra do conteúdo da tabela. **Quando configurada sem considerar os dados, pode ser menos eficiente do que os métodos DynamicFrame, causando timeouts ou erros de falta de memória.** Para obter mais informações, consulte [Usar sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
+ `"enablePartitioningForSampleQuery"`: (opcional) um booleano. Padrão: falso. Usado para permitir a leitura de tabelas JDBC em paralelo ao especificar `sampleQuery`. **Se definido como verdadeiro, `sampleQuery` deve terminar com "where" ou "and" para o AWS Glue para anexar condições de particionamento.** Para obter mais informações, consulte [Usar sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
+ `"sampleSize"`: (opcional) um número inteiro positivo. Limita o número de linhas retornado pela consulta de amostra. Funciona somente quando `enablePartitioningForSampleQuery` é verdadeiro. Se o particionamento não estiver habilitado, você deverá adicionar diretamente `"limit x"` à `sampleQuery` para limitar o tamanho. Para obter mais informações, consulte [Usar sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
## Usar sampleQuery
Esta seção explica como usar `sampleQuery`, `sampleSize` e `enablePartitioningForSampleQuery`.
`sampleQuery` pode ser uma forma eficiente de amostrar algumas linhas do conjunto de dados. Por padrão, a consulta é executada por um único executor. Quando configurada sem considerar os dados, pode ser menos eficiente do que os métodos DynamicFrame, causando timeouts ou erros de falta de memória. A execução de SQL no banco de dados subjacente como parte do pipeline de ETL geralmente só é necessária para fins de performance. Se você estiver tentando visualizar algumas linhas do conjunto de dados, considere usar [show](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show). Se você estiver tentando transformar o conjunto de dados usando SQL, considere usar [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) para definir uma transformação de SparkSQL para os dados no formato DataFrame.
Embora sua consulta possa manipular uma variedade de tabelas, a `dbtable` continua sendo obrigatória.
**Usar sampleQuery para recuperar uma amostra da tabela**
Ao usar o comportamento padrão de sampleQuery para recuperar uma amostra dos dados, o AWS Glue não espera um throughput substancial, assim ele executa a consulta em um único executor. Para limitar os dados que você fornece e não causar problemas de performance, sugerimos que você inclua uma cláusula `LIMIT` no SQL.
**Example Usar SampleQuery sem particionamento**
O exemplo de código a seguir mostra como usar `sampleQuery` sem particionamento.
```
//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()
```
**Usar sampleQuery em conjuntos de dados maiores**
Se você estiver lendo um conjunto de dados grande, talvez seja necessário ativar o particionamento JDBC para consultar uma tabela em paralelo. Para obter mais informações, consulte [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md). Para usar `sampleQuery` com particionamento JDBC, defina `enablePartitioningForSampleQuery` como verdadeiro. A ativação desse atributo exige que você faça algumas alterações na `sampleQuery`.
Ao usar particionamento JDBC com `sampleQuery`, a consulta deve terminar com "where" ou "and" para o AWS Glue para anexar condições de particionamento.
Se você quiser limitar os resultados da sampleQuery ao ler tabelas JDBC em paralelo, defina o parâmetro `"sampleSize"` em vez de especificar uma cláusula `LIMIT`.
**Example Usar SampleQuery com particionamento JDBC**
O exemplo de código a seguir mostra como usar `sampleQuery` com particionamento 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()
```
**Regras e restrições:**
Consultas de amostra não podem ser usadas junto com marcadores de trabalho. O estado do marcador será ignorado quando a configuração de ambos for fornecida.
## Usar o driver JDBC personalizado
Os exemplos de código a seguir mostram como fazer a leitura e gravação de bancos de dados JDBC com drivers JDBC personalizados. Eles demonstram a leitura de uma versão de um produto de banco de dados e a gravação em uma versão posterior do mesmo produto.
------
#### [ 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)
}
}
```
------
# Leitura de tabelas JDBC em paralelo
Você pode definir propriedades da sua tabela JDBC para permitir que o AWS Glue leia dados em paralelo. Ao definir determinadas propriedades, você instrui o AWS Glue a executar consultas SQL paralelas em partições lógicas dos seus dados. Você pode controlar o particionamento definindo um campo de hash ou uma expressão de hash. Você também pode controlar o número de leituras paralelas que são usadas para acessar seus dados.
Ler as tabelas JDBC em paralelo é uma técnica de otimização que pode melhorar a performance. Para obter mais informações sobre o processo para identificar quando essa técnica é adequada, consulte [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/parallelize-tasks.html) no guia *Best practices for performance tuning AWS Glue for Apache Spark jobs* em AWS Prescriptive Guidance.
Para habilitar leituras paralelas, você pode definir pares de chave e valor no campo de parâmetros da estrutura da tabela. Use a notação JSON para definir um valor para o campo de parâmetro da tabela. Para obter mais informações sobre como editar as propriedades de uma tabela, consulte [Exibir e gerenciar detalhes da tabela](tables-described.md#console-tables-details). Você também pode habilitar leituras paralelas ao chamar os métodos de ETL (extração, transformação e carregamento) `create_dynamic_frame_from_options` e `create_dynamic_frame_from_catalog`. Para obter mais informações sobre como especificar opções nesses métodos, consulte [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).
Você pode usar esse método para tabelas JDBC, ou seja, a maioria das tabelas cujos dados de base são um armazenamento de dados JDBC. Essas propriedades são ignoradas durante a leitura de tabelas do Amazon RedShift e Amazon S3.
**hashfield**
Defina `hashfield` como o nome de uma coluna na tabela JDBC a ser usada para dividir os dados em partições. Para obter os melhores resultados, essa coluna deve ter uma distribuição uniforme de valores para distribuir os dados entre partições. Essa coluna pode ser de qualquer tipo de dados. O AWS Glue gera consultas não sobrepostas que são executadas em paralelo para ler os dados particionados por essa coluna. Por exemplo, se os dados estiverem distribuídos uniformemente por mês, você poderá usar a coluna `month` para ler cada mês de dados em paralelo.
```
'hashfield': 'month'
```
O AWS Glue cria uma consulta para definir o hash do valor do campo como um número de partição e executa essa consulta para todas as partições em paralelo. Para usar sua própria consulta para particionar uma leitura de tabela, forneça uma tabela `hashexpression` em vez de um `hashfield`.
**hashexpression**
Defina `hashexpression` como uma expressão SQL (de acordo com a gramática do mecanismo de banco de dados JDBC) que retorne um número inteiro. Uma expressão simples é o nome de qualquer coluna numérica na tabela. O AWS Glue gera consultas SQL para ler os dados JDBC em paralelo usando o `hashexpression` na cláusula `WHERE` para particionar os dados.
Por exemplo, use a coluna numérica `customerID` para ler dados particionados por um número de cliente.
```
'hashexpression': 'customerID'
```
Para que o AWS Glue controle o particionamento, forneça um `hashfield` em vez de um `hashexpression`.
**hashpartitions**
Defina `hashpartitions` como o número de leituras paralelas da tabela JDBC. Se essa propriedade não for definida, o valor padrão será 7.
Por exemplo, defina o número de leituras em paralelo como `5` para que o AWS Glue lê os dados com cinco consultas (ou menos).
```
'hashpartitions': '5'
```
# Configurar um Amazon VPC para conexões JDBC aos armazenamentos de dados do Amazon RDS desde o AWS Glue
Ao usar o JDBC para conectar a bancos de dados no Amazon RDS, você precisará realizar configurações adicionais. Para permitir que os componentes do AWS Glue se comuniquem com o Amazon RDS, é necessário configurar o acesso aos seus armazenamentos de dados do Amazon RDS no Amazon VPC. Para permitir que o AWS Glue se comunique entre seus componentes, especifique um grupo de segurança com uma regra de entrada de autorreferência para todas as portas TCP. Ao criar uma regra de autorreferência, você pode restringir a origem ao mesmo security group na VPC. Uma regra de autorreferência não abrirá a VPC para todas as redes. O security group padrão para sua VPC pode já conter uma regra de entrada de autorreferenciada para ALL Traffic.
**Para configurar o acesso entre o AWS Glue e os armazenamentos de dados do Amazon RDS**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No console do Amazon RDS, identifique os grupos de segurança usados para controlar o acesso ao banco de dados do Amazon RDS.
No painel de navegação esquerdo, escolha **Bancos de dados** e, em seguida, selecione a instância à qual você gostaria de se conectar na lista no painel principal.
Na página de detalhes do banco de dados, encontre **Grupos de segurança da VPC** na guia **Conectividade e segurança**.
1. Com base na sua arquitetura de rede, identifique qual grupo de segurança associado é melhor modificar para permitir o acesso ao serviço AWS Glue. Salve seu nome, *database-security-group*, para referência futura. Se não houver um grupo de segurança apropriado, siga as instruções para [Fornecer acesso à instância de banco de dados na VPC criando um grupo de segurança](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) na documentação do Amazon RDS.
1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. No console do Amazon VPC, identifique como atualizar *database-security-group*.
No painel de navegação esquerdo, escolha **Grupos de segurança** e, em seguida, selecione *database-security-group* na lista no painel principal.
1. Identifique o ID do grupo de segurança para *database-security-group*, *database-sg-id*. Guarde-o para uso posterior.
Na página de detalhes do grupo de segurança, encontre **ID do grupo de segurança**.
1. Altere as regras de entrada para *database-security-group* e adicione uma regra de autorreferência para permitir que os componentes do AWS Glue se comuniquem. Especificamente, adicione ou confirme que existe uma regra em que **Tipo** é `All TCP`, **Protocolo** é `TCP`, **Intervalo de portas** inclui todas as portas e **Origem** é *database-sg-id*. Verifique se o grupo de segurança que você inseriu para **Origem** é o mesmo que o grupo de segurança que você está editando.
Na página de detalhes do grupo de segurança, selecione **Editar regras de entrada**.
A regra de entrada é semelhante a esta:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/setup-vpc-for-glue-access.html)
1. Adicione regras para o tráfego de saída.
Na página de detalhes do grupo de segurança, selecione **Editar regras de saída**.
Se o grupo de segurança permitir todo o tráfego de saída, você não precisará de regras separadas. Por exemplo:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/setup-vpc-for-glue-access.html)
Se sua arquitetura de rede foi desenvolvida para que você restrinja o tráfego de saída, crie as seguintes regras de saída:
Crie uma regra de autorreferência em que **Tipo** é `All TCP`, **Protocolo** é `TCP`, **Intervalo de portas** inclui todas as portas e **Destino** é *database-sg-id*. Verifique se o grupo de segurança que você inseriu para **Destino** é o mesmo que o grupo de segurança que você está editando.
Se você estiver usando um endpoint da VPC do Amazon S3, adicione uma regra de HTTPS para permitir o tráfego da VPC para o Amazon S3. Crie uma regra em que **Tipo** é `HTTPS`, **Protocolo** é `TCP`, **Intervalo de portas** é `443` e **Destino** é o ID da lista de prefixos gerenciados para o endpoint do gateway Amazon S3, *s3-prefix-list-id*. Para obter mais informações sobre listas de prefixos e endpoints de gateway do Amazon S3, consulte [Endpoints de gateway para Amazon S3](https://docs.aws.amazon.com//vpc/latest/privatelink/vpc-endpoints-s3.html) na documentação do Amazon VPC.
Por exemplo:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/setup-vpc-for-glue-access.html)
# Conexões do MongoDB
O AWS Glue para Spark pode ser usado para ler e gravar em tabelas no MongoDB e MongoDB Atlas no AWS Glue 4.0 e versões posteriores. Conecte-se ao MongoDB usando credenciais de nome de usuário e senha armazenadas no AWS Secrets Manager via conexão do AWS Glue.
Para obter mais informações sobre o MongoDB, consulte a [Documentação do MongoDB](https://www.mongodb.com/docs/).
## Configurar conexões do MongoDB
Para se conectar ao MongoDB via AWS Glue, você precisará de suas credenciais do MongoDB, *mongodbUser* e *mongodbPass*.
Para se conectar ao MongoDB via AWS Glue, talvez seja necessário atender a alguns pré-requisitos:
+ Se a sua instância do MongoDB estiver em uma Amazon VPC, configure a Amazon VPC para permitir que seu trabalho do AWS Glue se comunique com a instância do MongoDB sem que o tráfego passe pela Internet pública.
Na Amazon VPC, identifique ou crie uma **VPC**, uma **Sub-rede** e um **Grupo de segurança** que o AWS Glue usará durante a execução do trabalho. Além disso, você precisa garantir que a Amazon VPC esteja configurada para permitir o tráfego de rede entre sua instância do MongoDB e esse local. Com base no layout da rede, isso pode exigir alterações em regras do grupo de segurança, ACLs de rede, gateways de NAT e conexões de emparelhamento.
Em seguida, você pode continuar com a configuração do AWS Glue para usá-lo com o MongoDB.
**Para configurar uma conexão com o MongoDB:**
1. Opcionalmente, no AWS Secrets Manager, crie um segredo usando suas credenciais do MongoDB. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criar uma AWS Secrets Manager segredo ](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `username` com o valor *mongodbUser*.
Ao selecionar **Pares chave/valor**, crie um par para a chave `password` com o valor *mongodbPass*.
1. No console do AWS Glue, crie uma conexão seguindo as etapas em [Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para uso futuro no AWS Glue.
+ Ao selecionar um **Tipo de conexão**, selecione **MongoDB** ou **MongoDB Atlas**.
+ Ao selecionar o **URL do MongoDB** ou o **URL do MongoDB Atlas**, forneça o nome de host da sua instância do MongoDB.
Um URL do MongoDB é fornecido no formato `mongodb://mongoHost:mongoPort/mongoDBname`.
Um URL do MongoDB Atlas é fornecido no formato `mongodb+srv://mongoHost/mongoDBname`.
+ Se você optar por criar um segredo do Secrets Manager, escolha o **Tipo de credencial** do AWS Secrets Manager.
Em seguida, em **Segredo do AWS**, forneça o *secretName*.
+ *Se você optar por fornecer **Nome de usuário e senha**, forneça também o *mongodbUser* e o mongodbPass*.
1. Nas seguintes situações, configurações adicionais podem ser necessárias:
+
Para instâncias do MongoDB hospedadas na AWS em uma Amazon VPC
+ Será necessário fornecer informações de conexão da Amazon VPC à conexão do AWS Glue que define suas credenciais de segurança do MongoDB. Ao criar ou atualizar sua conexão, defina **VPC**, **Sub-rede** e **Grupos de segurança** em **Opções de rede**.
Depois de criar uma conexão AWS Glue MongoDB, siga estas etapas a seguir antes de chamar seu método de conexão.
+ Se você optar por criar um segredo do Secrets Manager, conceda ao perfil do IAM associado ao seu trabalho do AWS Glue permissão para ler *secretName*.
+ Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
Para usar sua conexão AWS Glue MongoDB no AWS Glue para Spark, forneça a opção `connectionName` na chamada ao método de conexão. Como alternativa, você pode seguir as etapas [Trabalhar com conexões MongoDB em trabalhos de ETL](integrate-with-mongo-db.md) para usar a conexão em conjunto com o AWS Glue Data Catalog.
## Ler do MongoDB usando uma conexão do AWS Glue
**Pré-requisitos:**
+ Uma coleção do MongoDB da qual você gostaria de ler. Você precisará de informações de identificação para a coleção.
Uma coleção do MongoDB é identificada por um nome de banco de dados e um nome de coleção, *mongodbName* e *mongodbCollection*.
+ Uma conexão AWS Glue MongoDB configurada para fornecer informações de autenticação. Conclua as etapas do procedimento anterior, *Para configurar uma conexão com o MongoDB* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
mongodb_read = glueContext.create_dynamic_frame.from_options(
connection_type="mongodb",
connection_options={
"connectionName": "connectionName",
"database": "mongodbName",
"collection": "mongodbCollection",
"partitioner": "com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id",
"disableUpdateUri": "false",
}
)
```
## Escrever em tabelas do MongoDB
Este exemplo escreve informações de um DynamicFrame existente, *dynamicFrame*, no MongoDB.
**Pré-requisitos:**
+ Uma coleção do MongoDB na qual você gostaria de escrever. Você precisará de informações de identificação para a coleção.
Uma coleção do MongoDB é identificada por um nome de banco de dados e um nome de coleção, *mongodbName* e *mongodbCollection*.
+ Uma conexão AWS Glue MongoDB configurada para fornecer informações de autenticação. Conclua as etapas do procedimento anterior, *Para configurar uma conexão com o MongoDB* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="mongodb",
connection_options={
"connectionName": "connectionName",
"database": "mongodbName",
"collection": "mongodbCollection",
"disableUpdateUri": "false",
"retryWrites": "false",
},
)
```
## Leitura e escrita em tabelas no MongoDB
Este exemplo escreve informações de um DynamicFrame existente, *dynamicFrame*, no MongoDB.
**Pré-requisitos:**
+ Uma coleção do MongoDB da qual você gostaria de ler. Você precisará de informações de identificação para a coleção.
Uma coleção do MongoDB na qual você gostaria de escrever. Você precisará de informações de identificação para a coleção.
Uma coleção do MongoDB é identificada por um nome de banco de dados e um nome de coleção, *mongodbName* e *mongodbCollection*.
+ Informações de autenticação do MongoDB, *mongodbUser* e *mongodbPassword*.
Por exemplo:
------
#### [ Python ]
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
mongo_uri = "mongodb://:27017"
mongo_ssl_uri = "mongodb://:27017"
write_uri = "mongodb://:27017"
read_mongo_options = {
"uri": mongo_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"username": "mongodbUsername",
"password": "mongodbPassword",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"}
ssl_mongo_options = {
"uri": mongo_ssl_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"ssl": "true",
"ssl.domain_match": "false"
}
write_mongo_options = {
"uri": write_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"username": "mongodbUsername",
"password": "mongodbPassword",
}
# Get DynamicFrame from MongoDB
dynamic_frame = glueContext.create_dynamic_frame.from_options(connection_type="mongodb",
connection_options=read_mongo_options)
# Write DynamicFrame to MongoDB
glueContext.write_dynamic_frame.from_options(dynamicFrame, connection_type="mongodb", connection_options=write_mongo_options)
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DEFAULT_URI: String = "mongodb://:27017"
val WRITE_URI: String = "mongodb://:27017"
lazy val defaultJsonOption = jsonOptions(DEFAULT_URI)
lazy val writeJsonOption = jsonOptions(WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from MongoDB
val dynamicFrame: DynamicFrame = glueContext.getSource("mongodb", defaultJsonOption).getDynamicFrame()
// Write DynamicFrame to MongoDB
glueContext.getSink("mongodb", writeJsonOption).writeDynamicFrame(dynamicFrame)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"mongodbName",
|"collection":"mongodbCollection",
|"username": "mongodbUsername",
|"password": "mongodbPassword",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
------
## Referência de opções de conexão do MongoDB
Designa uma conexão com o MongoDB. As opções de conexão diferem para uma conexão da fonte e uma conexão do coletor.
Essas propriedades de conexão são compartilhadas entre as conexões de origem e coletor:
+ `connectionName`: usado para leitura/gravação. O nome de uma conexão do AWS Glue MongoDB configurada para fornecer informações de autenticação e rede ao seu método de conexão. Quando uma conexão do AWS Glue é configurada conforme descrito na seção [Configurar conexões do MongoDB](#aws-glue-programming-etl-connect-mongodb-configure) anterior, fornecer `connectionName` substituirá a necessidade de fornecer as opções de conexão `"uri"`, `"username"` e `"password"`.
+ `"uri"`: (obrigatório) o host do MongoDB do qual fazer a leitura, formatado como `mongodb://:`. Usado nas versões do AWS Glue anteriores ao AWS Glue 4.0.
+ `"connection.uri"`: (obrigatório) o host do MongoDB do qual fazer a leitura, formatado como `mongodb://:`. Usado no AWS Glue 4.0 e versões posteriores.
+ `"username"`: (obrigatório) o nome de usuário do MongoDB.
+ `"password"`: (obrigatório) a senha do MongoDB.
+ `"database"`: (obrigatório) o banco de dados MongoDB do qual fazer a leitura. Essa opção também pode ser passada em `additional_options` ao chamar `glue_context.create_dynamic_frame_from_catalog` em seu script de trabalho.
+ `"collection"`: (obrigatório) a coleção do MongoDB da qual fazer a leitura. Essa opção também pode ser passada em `additional_options` ao chamar `glue_context.create_dynamic_frame_from_catalog` em seu script de trabalho.
### “connectionType”: “mongodb” como fonte
Use as seguintes opções de conexão com `"connectionType": "mongodb"` como fonte:
+ `"ssl"`: (opcional) se for `true`, iniciará uma conexão SSL. O padrão é `false`.
+ `"ssl.domain_match"`: (opcional) se for `true` e se `ssl` for `true`, será realizada a verificação de correspondência do domínio. O padrão é `true`.
+ `"batchSize"`: (opcional) o número de documentos que devem ser retornados por lote, usado no cursor de lotes internos.
+ `"partitioner"`: (opcional) o nome da classe do particionador do qual fazer a leitura de dados de entrada do MongoDB. O conector fornece os seguintes particionadores:
+ `MongoDefaultPartitioner` (padrão) (sem suporte no AWS Glue 4.0)
+ `MongoSamplePartitioner` (requer o MongoDB 3.2 ou posterior) (Sem suporte no AWS Glue 4.0)
+ `MongoShardedPartitioner` (sem suporte no AWS Glue 4.0)
+ `MongoSplitVectorPartitioner` (sem suporte no AWS Glue 4.0)
+ `MongoPaginateByCountPartitioner` (sem suporte no AWS Glue 4.0)
+ `MongoPaginateBySizePartitioner` (sem suporte no AWS Glue 4.0)
+ `com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner`
+ `com.mongodb.spark.sql.connector.read.partitioner.ShardedPartitioner`
+ `com.mongodb.spark.sql.connector.read.partitioner.PaginateIntoPartitionsPartitioner`
+ `"partitionerOptions"`: (opcional) opções para o particionador designado. As seguintes opções são compatíveis com cada particionador:
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner`: `partitionKey`, `partitionSizeMB`
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner`: `partitionKey`, `partitionSizeMB`
Para obter mais informações sobre essas opções, consulte [Partitioner Configuration](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) na documentação do MongoDB.
### “connectionType”: “mongodb” como coletor
Use as seguintes opções de conexão com `"connectionType": "mongodb"` como coletor:
+ `"ssl"`: (opcional) se for `true`, iniciará uma conexão SSL. O padrão é `false`.
+ `"ssl.domain_match"`: (opcional) se for `true` e se `ssl` for `true`, será realizada a verificação de correspondência do domínio. O padrão é `true`.
+ `"extendedBsonTypes"`: (opcional) se for `true`, permite tipos de BSON estendidos ao gravar dados no MongoDB. O padrão é `true`.
+ `"replaceDocument"`: (opcional) se for `true`, substituirá todo o documento ao salvar conjuntos de dados que contêm um campo `_id`. Se for `false`, serão atualizados somente os campos do documento que correspondam aos campos do conjunto de dados. O padrão é `true`.
+ `"maxBatchSize"`: (opcional) o tamanho máximo do lote para operações em massa ao salvar dados. O padrão é 512.
+ `"retryWrites"`: (Opcional): repita automaticamente determinadas operações de escrita uma única vez se o AWS Glue encontrar um erro de rede.
# Conexões do SAP HANA
O AWS Glue para Spark pode ser usado para ler e escrever em tabelas no SAP HANA no AWS Glue 4.0 e versões posteriores. Você pode definir o que ler no SAP HANA com uma consulta SQL. Conecte-se ao SAP HANA usando credenciais JDBC armazenadas no AWS Secrets Manager via conexão AWS Glue SAP HANA.
Para obter mais informações sobre o JDBC do SAP HANA, consulte a [Documentação do SAP HANA](https://help.sap.com/docs/SAP_HANA_PLATFORM/0eec0d68141541d1b07893a39944924e/ff15928cf5594d78b841fbbe649f04b4.html).
## Configurar conexões do SAP HANA
Para se conectar ao SAP HANA via AWS Glue, será necessário criar e armazenar suas credenciais do SAP HANA em um segredo do AWS Secrets Manager e, em seguida, associar esse segredo a uma conexão ao AWS Glue do SAP HANA. Você precisará configurar a conectividade de rede entre seu serviço SAP HANA e o AWS Glue.
Para se conectar ao SAP HANA, talvez seja necessário atender a alguns pré-requisitos:
+ Se o seu serviço SAP HANA estiver em uma Amazon VPC, configure a Amazon VPC para permitir que seu trabalho do AWS Glue se comunique com o serviço SAP HANA sem que o tráfego passe pela Internet pública.
Na Amazon VPC, identifique ou crie uma **VPC**, uma **Sub-rede** e um **Grupo de segurança** que o AWS Glue usará durante a execução do trabalho. Além disso, você precisa garantir que a Amazon VPC esteja configurada para permitir o tráfego de rede entre seu endpoint SAP HANA e esse local. Seu trabalho precisará estabelecer uma conexão TCP com a porta JDBC do SAP HANA. Para obter mais informações sobre as portas do SAP HANA, consulte a [Documentação do SAP HANA](https://help.sap.com/docs/HANA_SMART_DATA_INTEGRATION/7952ef28a6914997abc01745fef1b607/88e2e8bded9e4041ad3ad87dc46c7b55.html?locale=en-US). Com base no layout da rede, isso pode exigir alterações em regras do grupo de segurança, ACLs de rede, gateways de NAT e conexões de emparelhamento.
+ Não há pré-requisitos adicionais quando seu endpoint do SAP HANA está acessível pela Internet.
**Para configurar uma conexão com o SAP HANA:**
1. No AWS Secrets Manager, crie um segredo usando suas credenciais do SAP HANA. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criar uma AWS Secrets Manager segredo ](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `username/USERNAME` com o valor *saphanaUsername*.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `password/PASSWORD` com o valor *saphanaPassword*.
1. No console do AWS Glue, crie uma conexão seguindo as etapas em [Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para uso futuro no AWS Glue.
+ Ao selecionar um **Tipo de conexão**, selecione SAP HANA.
+ Ao fornecer o **URL do SAP HANA**, forneça o URL da sua instância.
Os URLs JDBC do SAP HANA estão no formato `jdbc:sap://saphanaHostname:saphanaPort/?databaseName=saphanaDBname,ParameterName=ParameterValue`
O AWS Glue requer os seguintes parâmetros de URL do JDBC:
+ `databaseName`: um banco de dados padrão no SAP HANA ao qual se conectar.
+ Ao selecionar um **Segredo da AWS**, forneça o *secretName*.
Depois de criar uma conexão AWS Glue SAP HANA, siga estas etapas antes de executar seu trabalho do AWS Glue:
+ Conceda ao perfil do IAM associada ao seu trabalho do AWS Glue permissão para ler *secretName*.
+ Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
## Ler de tabelas do SAP HANA
**Pré-requisitos:**
+ Uma tabela do SAP HANA da qual você deseja ler. Você precisará de informações de identificação para a tabela.
Uma tabela pode ser especificada com um nome de tabela e um nome de esquema do SAP HANA, no formulário `schemaName.tableName`. O nome do esquema e o separador "." não serão necessários se a tabela estiver no esquema padrão, "público". Chame isso de *tableIdentifier*. Observe que o banco de dados é fornecido como um parâmetro de URL do JDBC em `connectionName`.
+ Uma conexão AWS Glue SAP HANA configurada para fornecer informações de autenticação. Conclua as etapas do procedimento anterior, *Para configurar uma conexão com o SAP HANA* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
saphana_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="saphana",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier",
}
)
```
Você também pode fornecer uma consulta SQL SELECT para filtrar os resultados retornados ao seu DynamicFrame. Você precisará configurar `query`.
Por exemplo:
```
saphana_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="saphana",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Escrever em tabelas do SAP HANA
Este exemplo escreve informações de um DynamicFrame existente, *dynamicFrame*, no SAP HANA. Se a tabela já contiver informações, o AWS Glue irá gerar um erro.
**Pré-requisitos:**
+ Uma tabela do SAP HANA na qual você gostaria de escrever.
Uma tabela pode ser especificada com um nome de tabela e um nome de esquema do SAP HANA, no formulário `schemaName.tableName`. O nome do esquema e o separador "." não serão necessários se a tabela estiver no esquema padrão, "público". Chame isso de *tableIdentifier*. Observe que o banco de dados é fornecido como um parâmetro de URL do JDBC em `connectionName`.
+ Informações de autenticação do SAP HANA. Conclua as etapas do procedimento anterior, *Para configurar uma conexão com o SAP HANA* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
options = {
"connectionName": "connectionName",
"dbtable": 'tableIdentifier'
}
saphana_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="saphana",
connection_options=options
)
```
## Referência de opções de conexão do SAP HANA
+ `connectionName` — Obrigatório. Usado para leitura/gravação. O nome de uma conexão do AWS Glue SAP HANA configurada para fornecer informações de autenticação e rede ao seu método de conexão.
+ `databaseName`: usado para leitura/gravação. Valores válidos: nomes de bancos de dados no SAP HANA. O nome do banco de dados ao qual se conectar.
+ `dbtable`: necessário para escrever, obrigatório para leitura, a menos que `query` seja fornecido. Usado para leitura/gravação. Valores válidos: conteúdo de uma cláusula SQL FROM do SAP HANA. Identifica uma tabela no SAP HANA à qual se conectar. Você também pode fornecer outro SQL além do nome de uma tabela, como uma subconsulta. Para obter mais informações, consulte a [cláusula From](https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/20fcf24075191014a89e9dc7b8408b26.html#loio20fcf24075191014a89e9dc7b8408b26__from_clause) na documentação do SAP HANA.
+ `query` - Usado para leitura. Uma consulta SQL SELECT do SAP HANA que define o que deve ser recuperado na leitura do SAP HANA.
# Conexões do Snowflake
Você pode usar o AWS Glue para Spark para ler e gravar em tabelas no Snowflake no AWS Glue 4.0 e versões posteriores. Você pode ler no Snowflake com uma consulta SQL. Você pode se conectar ao Snowflake usando um usuário e uma senha. Você pode consultar as credenciais do Snowflake armazenadas no AWS Secrets Manager por meio do catálogo de dados do AWS Glue . As credenciais do Snowflake do catálogo de dados do AWS Glue para Spark são armazenadas separadamente das credenciais do Snowflake do catálogo de dados para crawlers. Você deve escolher um tipo de conexão do `SNOWFLAKE` e não um tipo de conexão `JDBC` configurada para se conectar ao Snowflake.
Para obter mais informações sobre o Snowflake, consulte o [site do Snowflake](https://www.snowflake.com/). Para obter mais informações sobre o Snowflake na AWS, consulte [Snowflake Data Warehouse na Amazon Web Services](https://aws.amazon.com/financial-services/partner-solutions/snowflake/).
## Configurar conexões do Snowflake
Não há pré-requisitos da AWS para se conectar aos fluxos do Snowflake disponíveis pela Internet.
Opcionalmente, você pode realizar a seguinte configuração para gerenciar suas credenciais de conexão com o AWS Glue.
**Para gerenciar suas credenciais de conexão com AWS o Glue**
1. No Snowflake, gere um usuário, *SnowflakeUser* e senha, *snowflakePassword*.
1. Nos AWS Secrets Manager, crie um segredo usando suas credenciais do Snowflake. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criação de um segredo do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html#create_secret_cli) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar **pares de chave/valor**, crie um par para *snowflakeUser* com a chave `USERNAME`.
+ Ao selecionar **pares de chave/valor**, crie um par para *snowflakePassword* com a chave `PASSWORD`.
+ Ao selecionar **pares de chave/valor**, você pode fornecer a chave ao seu armazém do Snowflake `sfWarehouse`.
+ Ao selecionar **pares de chave/valor**, você pode fornecer propriedades adicionais de conexão do Snowflake usando os nomes de propriedades correspondentes do Spark como chaves. As propriedades compatíveis incluem:
+ `sfDatabase`: nome do banco de dados do Snowflake
+ `sfSchema`: nome do esquema do Snowflake
+ `sfRole`: nome da tabela do Snowflake
+ `pem_private_key`: chave privada para autenticação de pares de chaves
1. No AWS Glue Data Catalog, crie uma conexão escolhendo **Conexões** e depois selecionando **Criar conexão**. Acompanhe as etapas do assistente de conexão para concluir o processo:
+ Ao selecionar uma **Fonte de dados**, escolha Snowflake e depois **Avançar**.
+ Insira os detalhes da conexão, como o host e a porta. Ao inserir o **URL do Snowflake** do host, forneça o URL da sua instância do Snowflake. Em geral, o URL usará um nome de host no formato `account_identifier.snowflakecomputing.com`. Porém, o formato do URL pode variar dependendo do tipo de conta do Snowflake (como AWS, Azure ou hospedada no Snowflake).
+ Ao selecionar o perfil de serviço do IAM, escolha no menu suspenso. Esse é o perfil do IAM da sua conta que será usado para acessar o AWS Secrets Manager e atribuir o IP se a VPC for especificada.
+ Ao selecionar um **Segredo da AWS**, forneça o *secretName*.
1. Na etapa seguinte do assistente, defina as propriedades da conexão do Snowflake.
1. Na etapa final do assistente, reveja as configurações e conclua o processo para criar a conexão.
Nas seguintes situações, você pode precisar do seguinte:
+
Para Snowflake hospedado na AWS em uma Amazon VPC
+ Você precisará da configuração apropriada da Amazon VPC para o Snowflake. Para obter mais informações sobre como configurar a Amazon VPC, consulte [AWS PrivateLink & Snowflake](https://docs.snowflake.com/en/user-guide/admin-security-privatelink) na documentação do Snowflake.
+ Você precisará da configuração apropriada da Amazon VPC para o AWS Glue. [Configurar VPC endpoints de interface (AWS PrivateLink) para AWS Glue (AWS PrivateLink)](vpc-interface-endpoints.md).
+ Você precisará criar uma conexão do catálogo de dados do AWS Glue que forneça informações de conexão do Amazon VPC (além da identificação de um AWS Secrets Manager segredo que define suas credenciais de segurança do Snowflake). A URL mudará quando o AWS PrivateLink estiver sendo usado, conforme descrito na documentação do Snowflake associada a um item anterior.
+ Você precisará que a configuração do trabalho inclua a conexão do catálogo de dados como uma **Conexão de rede adicional**.
## Ler das tabelas do Snowflake
**Pré-requisitos:** uma tabela do Snowflake que você gostaria de ler. *Você precisará do nome da tabela Snowflake, tableName*. Você precisará da URL do Snowflake, *snowflakeUrl*, do nome de usuário *snowflakeUser* e da senha *snowflakePassword*. *Se o usuário do Snowflake não tiver um namespace padrão definido, você precisará do nome do banco de dados do Snowflake *databaseName* e do nome do esquema schemaName*. *Além disso, se o usuário do Snowflake não tiver um armazém padrão definido, você precisará de um nome de armazém warehouseName*.
Por exemplo:
**Pré-requisitos adicionais:** conclua as etapas de *Para gerenciar suas credenciais de conexão com o AWS Glue* para configurar *snowflakeURL*, *snowflakeUsername* e *snowflakePassword*. Para revisar essas etapas, consulte [Configurar conexões do Snowflake](#aws-glue-programming-etl-connect-snowflake-configure) na seção anterior. Para selecionar com qual **conexão de rede adicional** se conectar, usaremos o parâmetro `connectionName`.
```
snowflake_read = glueContext.create_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
}
)
```
Além disso, você pode usar os parâmetros `autopushdown` e `query` para ler uma parte de uma tabela do Snowflake. Isso pode ser substancialmente mais eficiente do que filtrar os resultados depois de serem carregados no Spark. Considere um exemplo em que todas as vendas são armazenadas na mesma tabela, mas você só precisa analisar as vendas de uma determinada loja nos feriados. Se essas informações estiverem armazenadas na tabela, você poderá usar pushdown de predicado para recuperar os resultados da seguinte forma:
```
snowflake_node = glueContext.create_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"autopushdown": "on",
"query": "select * from sales where store='1' and IsHoliday='TRUE'",
"connectionName": "snowflake-glue-conn",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
}
)
```
## Gravar em tabelas do Snowflake
**Pré-requisitos:** um banco de dados do Snowflake no qual você deseja gravar. Você precisará de um nome de tabela atual ou desejado, *tableName*. Você precisará da URL do Snowflake, *snowflakeUrl*, do nome de usuário *snowflakeUser* e da senha *snowflakePassword*. *Se o usuário do Snowflake não tiver um namespace padrão definido, você precisará do nome do banco de dados do Snowflake *databaseName* e do nome do esquema schemaName*. *Além disso, se o usuário do Snowflake não tiver um armazém padrão definido, você precisará de um nome de armazém warehouseName*.
Por exemplo:
**Pré-requisitos adicionais:** conclua as etapas de *Para gerenciar suas credenciais de conexão com o AWS Glue* para configurar *snowflakeURL*, *snowflakeUsername* e *snowflakePassword*. Para revisar essas etapas, consulte [Configurar conexões do Snowflake](#aws-glue-programming-etl-connect-snowflake-configure) na seção anterior. Para selecionar com qual **conexão de rede adicional** se conectar, usaremos o parâmetro `connectionName`.
```
glueContext.write_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
},
)
```
## Referência de opções de conexão do Snowflake
O tipo de conexão do Snowflake usa as seguintes opções de conexão:
Você pode recuperar alguns dos parâmetros desta seção de uma conexão do catálogo de dados (`sfUrl`, `sfUser`, `sfPassword`) e, nesse caso, não será necessário fornecê-los. É possível fazer isso fornecendo o parâmetro `connectionName`.
É possível recuperar parâmetros de conexão dos segredos do AWS Secrets Manager usando o parâmetro `secretId`. Ao usar o Secrets Manager, as seguintes propriedades do Spark poderão ser recuperadas automaticamente se estiverem presentes no segredo:
+ `sfUser` (usando a chave `USERNAME` ou `sfUser`)
+ `sfPassword` (usando a chave `PASSWORD` ou `sfPassword`)
+ `sfWarehouse` (usando a chave `sfWarehouse`)
+ `sfDatabase` (usando a chave `sfDatabase`)
+ `sfSchema` (usando a chave `sfSchema`)
+ `sfRole` (usando a chave `sfRole`)
+ `pem_private_key` (usando a chave `pem_private_key`)
**Ordem de precedência da propriedade:** quando a mesma propriedade é especificada em vários locais, o AWS Glue usa a seguinte ordem de precedência (da maior para a menor):
1. Opções de conexão fornecidas explicitamente em seu código de trabalho
1. Propriedades da conexão do Catálogo de Dados
1. Valores de segredos do AWS Secrets Manager (quando `secretId` é especificado)
1. Padrões de usuário do Snowflake
Os parâmetros a seguir geralmente são usados ao se conectar com o Snowflake.
+ `sfDatabase`: obrigatório se o padrão do usuário não estiver definido no Snowflake. Usado para leitura/gravação. O banco de dados a ser usado na sessão após a conexão.
+ `sfSchema`: obrigatório se o padrão do usuário não estiver definido no Snowflake. Usado para leitura/gravação. O esquema a ser usado na sessão após a conexão.
+ `sfWarehouse`: obrigatório se o padrão do usuário não estiver definido no Snowflake. Usado para leitura/gravação. O armazém virtual padrão a ser usado na sessão após a conexão.
+ `sfRole`: obrigatório se o padrão do usuário não estiver definido no Snowflake. Usado para leitura/gravação. O perfil de segurança padrão a ser usado na sessão após a conexão.
+ `sfUrl`: (obrigatório) usado para leitura/gravação. Especifica o nome do host da sua conta no seguinte formato: `account_identifier.snowflakecomputing.com`. Para obter mais informações sobre identificadores de conta, consulte [Account Identifiers](https://docs.snowflake.com/en/user-guide/admin-account-identifier) na documentação do Snowflake.
+ `sfUser`: (obrigatório) usado para leitura/gravação. Nome de login do usuário do Snowflake.
+ `sfPassword`: (obrigatório, exceto se `pem_private_key` for fornecido) usado para leitura/gravação. Senha do usuário do Snowflake.
+ `dbtable`: obrigatório ao trabalhar com tabelas completas. Usado para leitura/gravação. O nome da tabela a ser lida ou da tabela na qual os dados serão gravados. Durante a leitura, todas as colunas e registros são recuperados.
+ `pem_private_key`: usado para leitura/gravação. Uma string de chave privada codificada em b64 não criptografada. A chave privada do usuário do Snowflake. É comum copiá-la de um arquivo PEM. Para obter mais informações, consulte [Autenticação e rotação de pares de chaves](https://docs.snowflake.com/en/user-guide/key-pair-auth) na documentação do Snowflake.
+ `query`: obrigatório ao ler com uma consulta. Usado para leitura. A consulta exata (instrução `SELECT`) a ser executada
As opções a seguir são usadas para configurar comportamentos específicos durante o processo de conexão com o Snowflake.
+ `preactions`: usado para leitura/gravação. Valores válidos: lista separada por ponto e vírgula de instruções SQL como string. As instruções SQL são executadas antes que os dados sejam transferidos entre o AWS Glue e o Snowflake. Se uma instrução contiver `%s`, `%s` será substituído pelo nome da tabela referenciada para a operação.
+ `postactions`: usado para leitura/gravação. As instruções SQL são executadas após os dados serem transferidos entre o AWS Glue e o Snowflake. Se uma instrução contiver `%s`, `%s` será substituído pelo nome da tabela referenciada para a operação.
+ `autopushdown`: padrão: `"on"`. Valores válidos: `"on"`, `"off"`. Esse parâmetro controla se o pushdown automática de consultas está habilitado. Se o pushdown estiver habilitado, quando uma consulta for executada no Spark, se for possível fazer pushdown de parte da consulta para o servidor do Snowflake, isso ocorrerá. Isso melhora a performance de algumas consultas. Para obter informações sobre se é possível fazer pushdown da consulta, consulte [Pushdown](https://docs.snowflake.com/en/user-guide/spark-connector-use#pushdown) na documentação do Snowflake.
Além disso, algumas das opções disponíveis no conector do Snowflake Spark podem ser compatíveis com o AWS Glue. Para obter mais informações sobre as opções disponíveis no conector do Snowflake Spark, consulte [Setting Configuration Options for the Connector](https://docs.snowflake.com/en/user-guide/spark-connector-use#setting-configuration-options-for-the-connector) no Snowflake.
## Métodos de autenticação do Snowflake
O AWS Glue é compatível com os seguintes métodos de autenticação para conexão ao Snowflake:
+ **Autenticação de nome de usuário e senha:** forneça os parâmetros `sfUser` e `sfPassword`.
+ **Autenticação por par de chaves:** forneça os parâmetros `sfUser` e `pem_private_key`. Quando a autenticação por par de chaves é usada, o parâmetro `sfPassword` não é necessário.
Ambos os métodos de autenticação são totalmente aceitos e podem ser configurados por meio de qualquer combinação de opções de conexão, conexões do Catálogo de Dados ou segredos do AWS Secrets Manager.
## Limitações do conector do Snowflake
A conexão com o Snowflake com o AWS Glue para Spark está sujeita às limitações a seguir.
+ Esse conector não é compatível com marcadores de trabalho. Para obter mais informações sobre marcadores de trabalho, consulte [Rastrear dados processados usando marcadores de trabalho](monitor-continuations.md).
+ Esse conector não é compatível com leituras e gravações do Snowflake por meio de tabelas no catálogo de dados do AWS Glue usando os métodos `create_dynamic_frame.from_catalog` e `write_dynamic_frame.from_catalog`.
+ Esse conector oferece suporte à autenticação por nome de usuário/senha e à autenticação por par de chaves. Não há suporte a outros métodos de autenticação (como OAuth ou SAML) no momento.
+ Esse conector não é compatível com trabalhos de streaming.
+ Esse conector é compatível com consultas baseadas em instrução `SELECT` ao recuperar informações (como com o parâmetro `query`). Outros tipos de consultas (como `SHOW`, `DESC` ou instruções DML) não são compatíveis.
+ O Snowflake limita o tamanho do texto da consulta (ou seja, instruções SQL) enviado pelos clientes do Snowflake a 1 MB por instrução. Para obter mais detalhes, consulte [Limits on Query Text Size](https://docs.snowflake.com/en/user-guide/query-size-limits).
# Conexões do Teradata Vantage
O AWS Glue para Spark pode ser usado para ler e escrever em tabelas no Teradata Vantage no AWS Glue 4.0 e versões posteriores. Você pode definir o que ler no Teradata com uma consulta SQL. Conecte-se ao Teradata usando credenciais de nome de usuário e senha armazenadas no AWS Secrets Manager via conexão do AWS Glue.
Para obter mais informações sobre o Teradata, consulte a [Documentação do Teradata](https://docs.teradata.com/).
## Configurar conexões do Teradata
Para se conectar ao Teradata via AWS, será necessário criar e armazenar suas credenciais do Teradata em um segredo do AWS Secrets Manager e, em seguida, associar esse segredo a uma conexão ao AWS Glue do Teradata. Se sua instância do Teradata estiver em uma Amazon VPC, você também precisará fornecer opções de rede para sua conexão AWS Glue Teradata.
Para se conectar ao Teradata via AWS Glue, talvez seja necessário atender a alguns pré-requisitos:
+ Se você estiver acessando seu ambiente Teradata via Amazon VPC, configure a Amazon VPC para permitir que seu trabalho do AWS Glue se comunique com o ambiente Teradata. Recomendamos não acessar o ambiente Teradata via Internet pública.
Na Amazon VPC, identifique ou crie uma **VPC**, uma **Sub-rede** e um **Grupo de segurança** que o AWS Glue usará durante a execução do trabalho. Além disso, você precisa garantir que a Amazon VPC esteja configurada para permitir o tráfego de rede entre sua instância do Teradata e esse local. Seu trabalho precisará estabelecer uma conexão TCP com a porta cliente do Teradata. Para obter mais informações sobre portas do Teradata, consulte a [Documentação do Teradata](https://docs.teradata.com/r/Teradata-VantageTM-on-AWS-DIY-Installation-and-Administration-Guide/April-2020/Before-Deploying-Vantage-on-AWS-DIY/Security-Groups-and-Ports).
Com base no layout da sua rede, a conectividade segura da VPC pode exigir alterações na Amazon VPC e em outros serviços de rede. Para obter mais informações sobre conectividade com a AWS, consulte [Opções de conectividade da AWS](https://docs.teradata.com/r/Teradata-VantageCloud-Enterprise/Get-Started/Connecting-Your-Environment/AWS-Connectivity-Options) na documentação da Teradata.
**Para configurar uma conexão AWS Teradata:**
1. Em sua configuração do Teradata, identifique ou crie um usuário e a senha com os quais o AWS Glue se conectará, *teradataUser* e *teradataPassword*. Para obter mais informações, consulte [Visão geral da segurança do Vantage](https://docs.teradata.com/r/Configuring-Teradata-VantageTM-After-Installation/January-2021/Security-Overview/Vantage-Security-Overview) na documentação do Teradata.
1. No AWS Secrets Manager, crie um segredo usando suas credenciais do Teradata. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criar uma AWS Secrets Manager segredo ](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `user` com o valor *teradataUsername*.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `password` com o valor *teradataPassword*.
1. No console do AWS Glue, crie uma conexão seguindo as etapas em [Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para a próxima etapa.
+ Ao selecionar um **Tipo de conexão**, selecione Teradata.
+ Ao fornecer o **URL do JDBC**, forneça o URL da sua instância. Você também pode codificar certos parâmetros de conexão separados por vírgula no URL do JDBC. O URL deve estar de acordo com o seguinte formato: `jdbc:teradata://teradataHostname/ParameterName=ParameterValue,ParameterName=ParameterValue`
Os parâmetros de URL compatíveis incluem:
+ `DATABASE`: o nome do banco de dados no host a ser acessado por padrão.
+ `DBS_PORT`: a porta do banco de dados usada para execução em uma porta não padrão.
+ Ao selecionar um **Tipo de credencial**, selecione **AWS Secrets Manager** e defina **Segredo da AWS** como *secretName*.
1. Nas seguintes situações, configurações adicionais podem ser necessárias:
+
Para instâncias do Teradata hospedadas na AWS em uma Amazon VPC
+ Será necessário fornecer informações de conexão da Amazon VPC à conexão do AWS Glue que define suas credenciais de segurança do Teradata. Ao criar ou atualizar sua conexão, defina **VPC**, **Sub-rede** e **Grupos de segurança** em **Opções de rede**.
Depois de criar uma conexão AWS Glue Teradata, será necessário executar as etapas a seguir antes de chamar seu método de conexão.
+ Conceda ao perfil do IAM associada ao seu trabalho do AWS Glue permissão para ler *secretName*.
+ Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
## Ler do Teradata
**Pré-requisitos:**
+ Uma tabela do Teradata da qual você deseja ler. Você precisará do nome da tabela, *tableName*.
+ Uma conexão AWS Glue Teradata configurada para fornecer informações de autenticação. Conclua as etapas *Para configurar uma conexão com o Teradata* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
Por exemplo:
```
teradata_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName"
}
)
```
Você também pode fornecer uma consulta SQL SELECT para filtrar os resultados retornados ao seu DynamicFrame. Você precisará configurar `query`.
Por exemplo:
```
teradata_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Escrever em tabelas do Teradata
**Pré-requisitos**: uma tabela do Teradata na qual você gostaria de escrever, *tableName*. **É necessário criar a tabela antes de chamar o método de conexão.**
Por exemplo:
```
teradata_write = glueContext.write_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName"
}
)
```
## Referência de opções de conexão do Teradata
+ `connectionName` — Obrigatório. Usado para leitura/gravação. O nome de uma conexão do AWS Glue Teradata configurada para fornecer informações de autenticação e rede ao seu método de conexão.
+ `dbtable`: necessário para escrever, obrigatório para leitura, a menos que `query` seja fornecido. Usado para leitura/gravação. O nome de uma tabela com a qual seu método de conexão interagirá.
+ `query` - Usado para leitura. Uma consulta SQL SELECT que define o que deve ser recuperado na leitura do Teradata.
# Conexões do Teradata Vantage NOS
A conexão do Teradata NOS (Native Object Store) é uma nova conexão para o Teradata Vantage que utiliza a consulta Teradata WRITE\$1NOS para ler tabelas existentes e a consulta READ\$1NOS para gravar em tabelas. Essas consultas usam o Amazon S3 como um diretório de preparação e, portanto, o conector Teradata NOS é mais rápido do que o conector Teradata existente (baseado em JDBC), especialmente ao lidar com grandes quantidades de dados.
É possível usar a conexão do Teradata NOS no AWS Glue para ler e escrever em tabelas no Teradata Vantage no AWS Glue Glue 5.0 e versões posteriores. Você pode definir o que ler no Teradata com uma consulta SQL. É possível se conectar ao Teradata usando credenciais de nome de usuário e senha armazenadas no AWS Secrets Manager via conexão do AWS Glue.
Para obter mais informações sobre o Teradata, consulte a [Documentação do Teradata](https://docs.teradata.com/).
**Topics**
+ [Criar uma conexão do Teradata NOS](#creating-teradata-nos-connection)
+ [Ler de tabelas do Teradata](#reading-from-teradata-nos-tables)
+ [Escrever em tabelas do Teradata](#writing-to-teradata-nos-tables)
+ [Referência de opções de conexão do Teradata](#teradata-nos-connection-option-reference)
+ [Fornecer opções na interface de usuário de ETL visual do AWS Glue](#teradata-nos-connection-option-visual-etl-ui)
## Criar uma conexão do Teradata NOS
Para se conectar ao Teradata NOS via AWS Glue, será necessário criar e armazenar suas credenciais do Teradata em um segredo do AWS Secrets Manager e, em seguida, associar esse segredo a uma conexão ao AWS Glue do Teradata NOS. Se sua instância do Teradata estiver em uma Amazon VPC, você também precisará fornecer opções de rede para sua conexão do AWS Glue Teradata NOS.
**Pré-requisitos**:
+ Se você estiver acessando seu ambiente Teradata via Amazon VPC, configure a Amazon VPC para permitir que seu trabalho do AWS Glue se comunique com o ambiente Teradata. Recomendamos não acessar o ambiente Teradata via Internet pública.
+ Na Amazon VPC, identifique ou crie uma VPC, uma sub-rede e um grupo de segurança para o AWS Glue usar durante a execução do trabalho. Além disso, você precisa garantir que a Amazon VPC esteja configurada para permitir o tráfego de rede entre sua instância do Teradata e esse local. Seu trabalho precisará estabelecer uma conexão TCP com a porta cliente do Teradata. Para obter mais informações sobre portas do Teradata, consulte [Grupos de Segurança do Teradata Vantage](https://docs.teradata.com/r/Teradata-VantageTM-on-AWS-DIY-Installation-and-Administration-Guide/April-2020/Before-Deploying-Vantage-on-AWS-DIY/Security-Groups-and-Ports).
+ Com base no layout da sua rede, a conectividade segura da VPC pode exigir alterações na Amazon VPC e em outros serviços de rede. Para obter mais informações sobre conectividade com a AWS, consulte [Opções de conectividade da AWS](https://docs.teradata.com/r/Teradata-VantageCloud-Enterprise/Get-Started/Connecting-Your-Environment/AWS-Connectivity-Options) na documentação do Teradata.
### Para configurar uma conexão do AWS Glue Teradata NOS:
1. Em sua configuração do Teradata, identifique ou crie um usuário *teradataUsername* e uma senha *teradataPassword* que serão usados pelo AWS Glue para conectar. Para obter mais informações, consulte [Visão geral da segurança do Vantage](https://docs.teradata.com/r/Configuring-Teradata-VantageTM-After-Installation/January-2021/Security-Overview/Vantage-Security-Overview) na documentação do Teradata.
1. No AWS Secrets Manager, crie um segredo usando suas credenciais do Teradata. Para criar um segredo no AWS Secrets Manager, siga o tutorial disponível em [Criar um segredo do AWS Secrets Manager na documentação do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html). Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar pares de chave/valor, crie um par para a chave USERNAME com o valor *teradataUsername*.
+ Ao selecionar pares de chave/valor, crie um par para a chave PASSWORD com o valor *teradataPassword*.
1. No console do AWS Glue, crie uma conexão de acordo com as etapas em [Adicionar uma conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para a próxima etapa.
+ Ao selecionar um **Tipo de conexão**, selecione Teradata Vantage NOS.
+ Ao fornecer o URL do JDBC, forneça o URL da sua instância. Você também pode codificar certos parâmetros de conexão separados por vírgula no URL do JDBC. O URL deve estar de acordo com o seguinte formato: ` jdbc:teradata://teradataHostname/ParameterName=ParameterValue,ParameterName=ParameterValue `.
+ Os parâmetros de URL compatíveis incluem:
+ `DATABASE`: o nome do banco de dados no host a ser acessado por padrão.
+ `DBS_PORT`: a porta do banco de dados usada para execução em uma porta não padrão.
+ Ao selecionar um **Tipo de credencial**, selecione AWS Secrets Manager e defina **Segredo da AWS** como *secretName*.
1. Nas seguintes situações, configurações adicionais podem ser necessárias:
+ Para instâncias do Teradata hospedas na AWS em uma Amazon VPC, será necessário fornecer informações de conexão da Amazon VPC à conexão do AWS Glue que define suas credenciais de segurança do Teradata. Ao criar ou atualizar sua conexão, defina **VPC**, **Sub-rede** e **Grupos de segurança** em **Opções de rede**.
Depois de criar uma conexão do AWS Glue Teradata Vantage NOS, será necessário executar as etapas a seguir antes de chamar seu método de conexão.
1. Conceda ao perfil do IAM associada ao seu trabalho do AWS Glue permissão para ler *secretName*.
1. Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional** em **Conexões**.
## Ler de tabelas do Teradata
### Pré-requisitos:
+ Uma tabela do Teradata da qual você deseja ler. Você precisará do nome da tabela, *tableName*.
+ O ambiente Teradata tem acesso de gravação ao caminho do Amazon S3 especificado pela opção `staging_fs_url`, *stagingFsUrl*.
+ O perfil do IAM associado ao trabalho do AWS Glue tem acesso de gravação ao local do Amazon S3 especificado pela opção `staging_fs_url`.
+ Uma conexão do AWS Glue Teradata NOS configurada para fornecer informações de autenticação. Conclua as etapas [Para configurar uma conexão do AWS Glue Teradata NOS:](#creating-teradata-nos-connection-procedure) para configurar suas informações de autenticação. Você precisará do nome da conexão do AWS Glue, *connectionName*.
Exemplo:
```
teradata_read_table = glueContext.create_dynamic_frame.from_options(
connection_type= "teradatanos",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"staging_fs_url": "stagingFsUrl"
}
)
```
Você também pode fornecer uma consulta SQL SELECT para filtrar os resultados retornados ao seu DynamicFrame. É necessário configurar a consulta. Se você configurar tanto dbTable quanto a consulta, o conector não conseguirá ler os dados. Por exemplo:
```
teradata_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="teradatanos",
connection_options={
"connectionName": "connectionName",
"query": "query",
"staging_fs_url": "stagingFsUrl"
}
)
```
Além disso, é possível usar a API Spark DataFrame para ler tabelas do Teradata. Por exemplo:
```
options = {
"url": "JDBC_URL",
"dbtable": "tableName",
"user": "teradataUsername", # or use "username" as key here
"password": "teradataPassword",
"staging_fs_url": "stagingFsUrl"
}
teradata_read_table = spark.read.format("teradatanos").option(**options).load()
```
## Escrever em tabelas do Teradata
### Pré-requisitos
+ Uma tabela do Teradata na qual você gostaria de escrever: *tableName*.
+ O ambiente Teradata tem acesso de leitura à localização do Amazon S3 especificada pela opção `staging_fs_url`, *stagingFsUrl*.
+ O perfil do IAM associado ao trabalho do AWS Glue tem acesso de gravação ao local do Amazon S3 especificado pela opção `staging_fs_url`.
+ Uma conexão do AWS Glue Teradata configurada para fornecer informações de autenticação. Conclua as etapas em [Para configurar uma conexão do AWS Glue Teradata NOS:](#creating-teradata-nos-connection-procedure) para configurar suas informações de autenticação. Você precisará do nome da conexão do AWS Glue, *connectionName*.
Por exemplo:
```
teradata_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type= "teradatanos",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"staging_fs_url": "stagingFsUrl"
}
)
```
## Referência de opções de conexão do Teradata
**Opções de conexão e operação:**
+ `connectionName` — Obrigatório. Usado para leitura/gravação. O nome de uma conexão do AWS Glue Teradata configurada para fornecer informações de autenticação e rede ao seu método de conexão.
+ `staging_fs_url` — Obrigatório. Usado para leitura/gravação. Um local gravável no Amazon S3, para ser usado para os dados descarregados ao ler do Teradata e para dados Parquet a serem carregados no Redshift ao gravar no Teradata. O bucket do S3 deve estar na mesma região que os seus trabalhos do AWS Glue.
+ `dbtable`: necessário para escrever, obrigatório para leitura, a menos que `query` seja fornecido. Usado para leitura/gravação. O nome de uma tabela com a qual seu método de conexão interagirá.
+ `query` - Usado para leitura. Uma consulta SQL SELECT que define o que deve ser recuperado na leitura do Teradata. Não será possível passar se a opção `dbtable` for fornecida.
+ `clean_staging_s3_dir`: opcional. Usado para leitura/gravação. Se verdadeiro, limpa os objetos de staging do Amazon S3 após uma leitura ou gravação. O valor padrão é true.
+ `pre_actions`: opcional. Usado para gravação. Lista separada por ponto e vírgula de comandos SQL que são executados antes da transferência de dados entre o Spark e o Teradata Vantage.
+ `post_actions`: opcional. Usado para gravação. Lista separada por ponto e vírgula de comandos SQL que são executados após a transferência de dados entre o Spark e o Teradata Vantage.
+ `truncate`: opcional. Usado para gravação. Se verdadeiro, o conector trunca a tabela ao gravar no modo de sobrescrita. Se falso, o conector descarta a tabela ao gravar no modo de sobrescrita. O valor padrão é falso.
+ `create_table_script`: opcional. Usado para gravação. Uma instrução SQL para criar tabela ao gravar no Teradata Vantage. Útil quando você deseja criar uma tabela com metadados personalizados (por exemplo, CREATE MULTISET ou SET table ou alterar o índice primário). Observe que o nome da tabela usado no script de criação de tabela deve corresponder ao nome da tabela especificado na opção `dbtable`.
+ `partition_size_in_mb`: opcional. Usado para leitura. Tamanho máximo de uma partição do Spark em megabytes durante a leitura de objetos de preparação do Amazon S3. O valor padrão é 128.
É possível fornecer opções avançadas ao criar um nó do Teradata. Essas opções são as mesmas disponíveis ao programar AWS Glue para scripts do Spark.
Consulte [Conexões do Teradata Vantage](aws-glue-programming-etl-connect-teradata-home.md).
**Opções de autorização:**
Abaixo encontram-se as opções usadas para fornecer as credenciais da conta da AWS que o conector usa para acessar o bucket de preparação do Amazon S3. Você pode optar por (1) não fornecer nenhuma opção de autorização e usar as credenciais temporárias geradas pelo perfil de execução AWS Glue; ou (2) fornecer um objeto de autorização `auth_object` que você criou; ou (3) fornecer `aws_access_key_id and aws_secret_access_key` se estiver usando credenciais de longo prazo, ou fornecer `aws_access_key`, `aws_secret_access_key` e `aws_session_token` se estiver usando credenciais temporárias.
+ `auth_object`: opcional. Usado para acessar o bucket de preparação do Amazon S3. Uma string de objeto de autorização criada na instância do Teradata. Se fornecido, o conector usará esse objeto de autorização para acessar o bucket de preparação do Amazon S3. Se não for fornecido, e `aws_access_key_id` e `aws_secret_access_key` também não forem fornecidos, uma credencial temporária será recuperada do perfil de execução AWS Glue e usada pelo conector. A conta da AWS associada a esse objeto de autorização deve estar na mesma região que os trabalhos do AWS Glue e o bucket de preparação do Amazon S3 ou estar configurada com confiança entre contas.
+ `aws_access_key_id`: opcional. Usada para acessar o bucket de preparação do Amazon S3. Parte de uma credencial de segurança da conta da AWS. Se o `auth_object` não for fornecido e o `aws_access_key_id` for fornecido com a `aws_secret_access_key`, o conector os usará para acessar o bucket de preparação do Amazon S3. A conta da AWS associada a essa chave de acesso deve estar na mesma região que os trabalhos do AWS Glue e o bucket de preparação do Amazon S3 ou estar configurada com confiança entre contas.
+ `aws_secret_access_key`: opcional. Usada para acessar o bucket de preparação do Amazon S3. Parte de uma credencial de segurança da conta da AWS. Se o `auth_object` não for fornecido e o `aws_secret_access_key` for fornecido com o `aws_access_key_id`, o conector os usará para acessar o bucket de preparação do Amazon S3. A conta da AWS associada a esse segredo deve estar na mesma região que os trabalhos do AWS Glue e o bucket de preparação do Amazon S3 ou estar configurada com confiança entre contas.
+ `aws_session_token`: opcional. Usado para acessar o bucket de preparação do Amazon S3. Parte de uma credencial de segurança temporária da conta da AWS. Deve ser fornecido com o `aws_access_key_id` e a `aws_secret_access_key`.
## Fornecer opções na interface de usuário de ETL visual do AWS Glue
Você pode fornecer todas as opções acima em sua interface de usuário de trabalho de ETL visual. Para a opção ConnectionName, você deve escolhê-la na lista suspensa de conexão do NOS Vantage do Teradata. Para todas as outras opções, você deve fornecê-las por meio das propriedades personalizadas do NOS Vantage do Teradata como pares de chave-valor.
![\[O painel mostra que a conexão do NOS Vantage do Teradata está selecionada.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/teradata-nos-vantage-connection-options.png)
# Conexões do Vertica
O AWS Glue para Spark pode ser usado para ler e escrever em tabelas no Vertica no AWS Glue 4.0 e versões posteriores. Você pode definir o que ler no Vertica com uma consulta SQL. Conecte-se ao Vertica usando credenciais de nome de usuário e senha armazenadas no AWS Secrets Manager via conexão do AWS Glue.
Para obter mais informações sobre o Vertica, consulte a [Documentação do Vertica](https://www.vertica.com/docs/9.3.x/HTML/Content/Authoring/UsingVerticaOnAWS/UsingVerticaOnAWS.htm).
## Configurar conexões do Vertica
Para se conectar ao Vertica via AWS Glue, será necessário criar e armazenar suas credenciais do Vertica em um segredo do AWS Secrets Manager e, em seguida, associar esse segredo a uma conexão ao AWS Glue do Vertica. Se sua instância do Vertica estiver em uma Amazon VPC, você também precisará fornecer opções de rede para sua conexão AWS Glue Vertica. É necessário um bucket ou uma pasta do Amazon S3 para usar como armazenamento temporário ao ler e gravar no banco de dados.
Para se conectar ao Vertica via AWS Glue, talvez seja necessário atender a alguns pré-requisitos:
+ Um bucket ou uma pasta do Amazon S3 para usar como armazenamento temporário ao ler e escrever no banco de dados, referido por *tempS3Path*.
**nota**
Quando o Vertica é usado em pré-visualizações de dados de trabalhos do AWS Glue, os arquivos temporários podem não ser removidos automaticamente de *tempS3Path*. Para garantir a remoção de arquivos temporários, encerre diretamente a sessão de visualização de dados escolhendo **Encerrar sessão** no painel **Visualização de dados**.
Se não for possível garantir que a sessão de visualização de dados seja encerrada diretamente, considere definir a configuração do ciclo de vida do Amazon S3 para remover dados antigos. Recomendamos remover dados com mais de 49 horas com base no runtime máximo do trabalho somado a uma margem. Para obter mais informações sobre a configuração do Amazon S3, consulte [Gerenciar o ciclo de vida do armazenamento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) na documentação do Amazon S3.
+ Uma política do IAM com permissões apropriadas para seu caminho do Amazon S3 que você pode associar ao seu perfil de trabalho do AWS Glue.
+ Se a sua instância do Vertica estiver em uma Amazon VPC, configure a Amazon VPC para permitir que seu trabalho do AWS Glue se comunique com a instância do Vertica sem que o tráfego passe pela Internet pública.
Na Amazon VPC, identifique ou crie uma **VPC**, uma **Sub-rede** e um **Grupo de segurança** que o AWS Glue usará durante a execução do trabalho. Além disso, você precisa garantir que a Amazon VPC esteja configurada para permitir o tráfego de rede entre sua instância do Vertica e esse local. Seu trabalho precisará estabelecer uma conexão TCP com a porta cliente do Vertica (por padrão, 5433). Com base no layout da rede, isso pode exigir alterações em regras do grupo de segurança, ACLs de rede, gateways de NAT e conexões de emparelhamento.
Em seguida, você pode continuar com a configuração do AWS Glue para usá-lo com o Vertica.
**Para configurar uma conexão com o Vertica:**
1. No AWS Secrets Manager, crie um segredo usando suas credenciais do Vertica, *verticaUsername* e *verticaPassword*. Para criar um segredo no Secrets Manager, siga o tutorial disponível em [Criar uma AWS Secrets Manager segredo ](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, *SecretName*, para a próxima etapa.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `user` com o valor *verticaUsername*.
+ Ao selecionar **Pares chave/valor**, crie um par para a chave `password` com o valor *verticaPassword*.
1. No console do AWS Glue, crie uma conexão seguindo as etapas em [Adicionar uma conexão do AWS Glue](console-connections.md). Depois de criar a conexão, guarde o nome da conexão, *connectionName*, para a próxima etapa.
+ Ao selecionar um **Tipo de conexão**, selecione Vertica.
+ Ao selecionar **Host do Vertica**, forneça o URL da sua instalação do Vertica.
+ Ao selecionar **Porta do Vertica**, a porta pela qual sua instalação do Vertica está disponível.
+ Ao selecionar um **Segredo da AWS**, forneça o *secretName*.
1. Nas seguintes situações, configurações adicionais podem ser necessárias:
+
Para instâncias do Teradata hospedadas na AWS em uma Amazon VPC
+ Forneça informações de conexão da Amazon VPC à conexão do AWS Glue que define suas credenciais de segurança do Vertica. Ao criar ou atualizar sua conexão, defina **VPC**, **Sub-rede** e **Grupos de segurança** em **Opções de rede**.
Depois de criar uma conexão AWS Glue Vertica, será necessário executar as etapas a seguir antes de chamar seu método de conexão.
+ Conceda ao perfil do IAM associado ao seu trabalho do AWS Glue permissão para *tempS3Path*.
+ Conceda ao perfil do IAM associada ao seu trabalho do AWS Glue permissão para ler *secretName*.
+ Na configuração do trabalho do AWS Glue, forneça *connectionName* como uma **conexão de rede adicional**.
## Ler no Vertica
**Pré-requisitos:**
+ Uma tabela do Vertica que você deseja ler. Você precisará do nome do banco de dados do Vertica, *dbName* e do nome da tabela, *tableName*.
+ Uma conexão AWS Glue Vertica configurada para fornecer informações de autenticação. Conclua as etapas do procedimento anterior, *Para configurar uma conexão com o Vertica* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
+ Um bucket ou pasta do Amazon S3 para usar para armazenamento temporário, mencionado anteriormente. Você precisará do nome *tempS3Path*. Você deverá se conectar a esse local usando o protocolo `s3a`.
Por exemplo:
```
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"table": "tableName",
}
)
```
Você também pode fornecer uma consulta SQL SELECT para filtrar os resultados retornados ao seu DynamicFrame ou para acessar um conjunto de dados de várias tabelas.
Por exemplo:
```
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"query": "select * FROM tableName",
},
)
```
## Escrever em tabelas do Vertica
Este exemplo escreve informações de um DynamicFrame existente, *dynamicFrame*, no Vertica. Se a tabela já contiver informações, o AWS Glue anexará dados do seu DynamicFrame.
**Pré-requisitos:**
+ O nome de uma tabela atual ou desejada, *tableName*, na qual você deseja escrever. Você também precisará do nome do banco de dados Vertica correspondente, *dbName*.
+ Uma conexão AWS Glue Vertica configurada para fornecer informações de autenticação. Conclua as etapas do procedimento anterior, *Para configurar uma conexão com o Vertica* para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, *ConnectionName*.
+ Um bucket ou pasta do Amazon S3 para usar para armazenamento temporário, mencionado anteriormente. Você precisará do nome *tempS3Path*. Você deverá se conectar a esse local usando o protocolo `s3a`.
Por exemplo:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"table": "tableName",
}
)
```
## Referência de opções de conexão do Vertica
+ `connectionName` — Obrigatório. Usado para leitura/gravação. O nome de uma conexão do AWS Glue Vertica configurada para fornecer informações de autenticação e rede ao seu método de conexão.
+ `db` — Obrigatório. Usado para leitura/gravação. O nome de um banco de dados no Vertica com o qual seu método de conexão interagirá.
+ `dbSchema`: exigido se necessário para identificar sua tabela. Usado para leitura/gravação. Padrão: `public`. O nome de um esquema com o qual seu método de conexão interagirá.
+ `table`: necessário para escrever, obrigatório para leitura, a menos que `query` seja fornecido. Usado para leitura/gravação. O nome de uma tabela com a qual seu método de conexão interagirá.
+ `query` - Usado para leitura. Uma consulta SQL SELECT que define o que deve ser recuperado na leitura do Teradata.
+ `staging_fs_url` — Obrigatório. Usado para leitura/gravação. Valores válidos: URLs do `s3a`. O URL de um bucket ou pasta do Amazon S3 a ser usado para armazenamento temporário.
## Opções de DataFrame para ETL no AWS Glue 5.0 para Spark
Um DataFrame é um conjunto de dados organizados em colunas nomeadas semelhante a uma tabela e é compatível com operações de estilo funcional (mapear/reduzir/filtrar etc.) e operações SQL (select, project, aggregate).
Para criar um DataFrame para uma fonte de dados compatível com o Glue os seguintes requisitos devem ser atendidos:
+ conector da fonte de dados `ClassName`
+ conexão da fonte de dados `Options`
Da mesma forma, para gravar um DataFrame em um coletor de dados suportado pelo Glue, o mesmo é necessário:
+ conector do coletor de dados `ClassName`
+ conexão do coletor de dados `Options`
Observe que recursos do AWS Glue, como marcadores de tarefas, e opções de DynamicFrame, como `connectionName`, não são compatíveis com o DataFrame. Para obter mais detalhes sobre o DataFrame e as operações válidas, consulte a documentação do Spark para o [DataFrame](https://spark.apache.org/docs/3.5.2/api/python/reference/pyspark.sql/dataframe.html).
### Especificar o ClassName do conector
Para especificar o `ClassName` de um coletor/fonte de dados, use a opção `.format` para fornecer o conector `ClassName` correspondente que define o coletor/fonte de dados.
**Conectores JDBC**
Para conectores JDBC, especifique `jdbc` como o valor da opção `.format` e forneça o driver JDBC `ClassName` na opção `driver`.
```
df = spark.read.format("jdbc").option("driver", "")...
df.write.format("jdbc").option("driver", "")...
```
A tabela a seguir lista o driver JDBC `ClassName` da fonte de dados compatível no AWS Glue para DataFrames.
| Fonte de dados | Driver ClassName |
| --- |--- |
| PostgreSQL | org.postgresql.Driver |
| Oracle | oracle.jdbc.driver.OracleDriver |
| SQLServer | com.microsoft.sqlserver.jdbc.SQLServerDriver |
| MySQL | com.mysql.jdbc.Driver |
| SAPHana | com.sap.db.jdbc.Driver |
| Teradata | com.teradata.jdbc.TeraDriver |
**Conectores do Spark**
Para conectores do Spark, especifique o `ClassName` do conector como o valor da opção `.format`.
```
df = spark.read.format("")...
df.write.format("")...
```
A tabela a seguir lista o conector Spark `ClassName` da fonte de dados compatível no AWS Glue para DataFrames.
| Fonte de dados | ClassName |
| --- |--- |
| MongoDB/DocumentDB | glue.spark.mongodb |
| Redshift | io.github.spark\$1redshift\$1community.spark.redshift |
| AzureCosmos | cosmos.oltp |
| AzureSQL | com.microsoft.sqlserver.jdbc.spark |
| BigQuery | com.google.cloud.spark.bigquery |
| OpenSearch | org.opensearch.spark.sql |
| Snowflake | net.snowflake.spark.snowflake |
| Vertica | com.vertica.spark.datasource.VerticaSource |
### Especificar as opções de conexão
Para especificar as `Options` da conexão com um coletor/fonte de dados, use o `.option(, )` para fornecer opções individuais ou `.options(