# Opções de formato de dados para entradas e saídas no AWS Glue para Spark
Essas páginas oferecem informações sobre suporte a atributos e parâmetros de configuração para formatos de dados compatíveis com o AWS Glue para Spark. Consulte a seguir uma descrição do uso e da aplicabilidade destas informações.
## Suporte de recursos em todos os formatos de dados no AWS Glue
Cada formato de dados pode ser compatível com diferentes recursos do AWS Glue. Os recursos comuns a seguir podem ou não ser compatíveis, de acordo com o tipo de formato. Consulte a documentação do formato de dados para entender como utilizar nossos recursos para atender a suas necessidades.
| | |
| --- |--- |
| Ler | O AWS Glue pode reconhecer e interpretar esse formato de dados sem recursos adicionais, como conectores. |
| Gravar | O AWS Glue pode gravar dados nesse formato sem recursos adicionais. É possível incluir bibliotecas de terceiros em seu trabalho e usar as funções padrão do Apache Spark para gravar dados, como faria em outros ambientes Spark. Para mais informações sobre como incluir bibliotecas, consulte [Usar bibliotecas Python com o AWS Glue](aws-glue-programming-python-libraries.md). |
| Leitura de transmissão | O AWS Glue pode reconhecer e interpretar esse formato de dados a partir de um fluxo de mensagens do Apache Kafka, do Amazon Managed Streaming para Apache Kafka ou do Amazon Kinesis. Esperamos que os fluxos apresentem os dados em um formato consistente, para que sejam lidos como DataFrames. |
| Agrupar arquivos pequenos | O AWS Glue pode agrupar arquivos para trabalhos em lote enviados para cada nó durante a execução de transformações do AWS Glue. Isso pode melhorar consideravelmente a performance de workloads que envolvam grandes quantidades de arquivos pequenos. Para obter mais informações, consulte [Ler arquivos de entrada em grupos maiores](grouping-input-files.md). |
| Marcadores de trabalho | O AWS Glue pode acompanhar o progresso das transformações que realizam o mesmo trabalho no mesmo conjunto de dados em todas as execuções de tarefas com indicadores de tarefas. Isso pode melhorar a performance de workloads que envolvem conjuntos de dados em que o trabalho só precisa ser feito com novos dados desde a última execução do trabalho. Para obter mais informações, consulte [Rastrear dados processados usando marcadores de trabalho](monitor-continuations.md). |
## Parâmetros usados para interagir com formatos de dados no AWSGlue
Certos tipos de conexão do AWS Glue são compatíveis com vários tipos de `format`, fazendo com que seja necessário especificar informações sobre o formato de dados com um objeto `format_options` ao usar métodos como `GlueContext.write_dynamic_frame.from_options`.
+ `s3`: para obter mais informações, consulte Tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Também é possível visualizar a documentação para os métodos que facilitam esse tipo de conexão: [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) e [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options) em Python e os métodos Scala correspondentes [def getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat) e [def getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
+ `kinesis`: para obter mais informações, consulte Tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do Kinesis](aws-glue-programming-etl-connect-kinesis-home.md#aws-glue-programming-etl-connect-kinesis). Também é possível visualizar a documentação para o método que facilita esse tipo de conexão: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) em Python e o método Scala correspondente [def createDataFrameFromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions).
+ `kafka`: para obter mais informações, consulte Tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do Kafka](aws-glue-programming-etl-connect-kafka-home.md#aws-glue-programming-etl-connect-kafka). Também é possível visualizar a documentação para o método que facilita esse tipo de conexão: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) em Python e o método Scala correspondente [def createDataFrameFromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions).
Alguns tipos de conexão não exigem `format_options`. Por exemplo, em uso normal, uma conexão JDBC com um banco de dados relacional recupera dados em formato de dados tabular consistente. Portanto, a leitura de uma conexão JDBC não exigiria `format_options`.
Alguns métodos para ler e gravar dados no Glue não exigem `format_options`. Por exemplo, usar `GlueContext.create_dynamic_frame.from_catalog` com crawlers do AWS Glue. Os crawlers determinam a forma dos dados. Ao usar crawlers, um classificador do AWS Glue examinará seus dados para tomar decisões inteligentes sobre como representar o formato de dados. Em seguida, armazenará uma representação de seus dados no Catálogo de Dados do AWS Glue, que pode ser usado em um script ETL do AWS Glue para recuperar dados com o método `GlueContext.create_dynamic_frame.from_catalog`. Os crawlers eliminam a necessidade de especificar manualmente as informações sobre o formato dos dados.
Para trabalhos que acessam tabelas governadas pelo AWS Lake Formation, o AWS Glue oferece suporte para a leitura e a escrita de todos os formatos com suporte pelas tabelas governadas pelo Lake Formation. Para obter a lista atual de formatos com suporte para tabelas governadas pelo AWS Lake Formation, consulte [Notas e restrições para tabelas controladas](https://docs.aws.amazon.com/lake-formation/latest/dg/governed-table-restrictions.html) no *Guia do desenvolvedor do AWS Lake Formation*.
**nota**
Para gravar Apache Parquet, o ETL do AWS Glue só oferece suporte para gravação em uma tabela controlada especificando uma opção para um tipo de gravador Parquet personalizado otimizado para quadros dinâmicos. Ao gravar em uma tabela governada com o formato `parquet`, você deve adicionar a chave `useGlueParquetWriter` com um valor de `true` nos parâmetros da tabela.
**Topics**
+ [Suporte de recursos em todos os formatos de dados no AWS Glue](#aws-glue-programming-etl-format-features)
+ [Parâmetros usados para interagir com formatos de dados no AWSGlue](#aws-glue-programming-etl-format-parameters)
+ [Uso do formato CSV no AWS Glue](aws-glue-programming-etl-format-csv-home.md)
+ [Uso do formato Parquet no AWS Glue](aws-glue-programming-etl-format-parquet-home.md)
+ [Uso do formato XML no AWS Glue](aws-glue-programming-etl-format-xml-home.md)
+ [Uso do formato Avro no AWS Glue](aws-glue-programming-etl-format-avro-home.md)
+ [Uso do formato grokLog no AWS Glue](aws-glue-programming-etl-format-grokLog-home.md)
+ [Uso do formato Ion no AWS Glue](aws-glue-programming-etl-format-ion-home.md)
+ [Uso do formato JSON no AWS Glue](aws-glue-programming-etl-format-json-home.md)
+ [Usar o formato ORC no AWS Glue](aws-glue-programming-etl-format-orc-home.md)
+ [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md)
+ [Referência de configuração compartilhada](#aws-glue-programming-etl-format-shared-reference)
# Uso do formato CSV no AWS Glue
O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se seus dados forem armazenados ou transportados no formato de dados CSV, este documento apresenta os recursos disponíveis para usar seus dados no AWS Glue.
O AWS Glue é compatível com o uso do formato de arquivo de valores separados por vírgulas (CSV). Esse formato é um formato de dados baseado em linha. Em geral, os CSVs não estão em conformidade estrita com um padrão, mas você pode consultar [RFC 4180](https://tools.ietf.org/html/rfc4180) e [RFC 7111](https://tools.ietf.org/html/rfc7111) para obter mais informações.
Você pode usar o AWS Glue para ler CSVs do Amazon S3 e de fontes de transmissão, bem como para gravar CSVs no Amazon S3. Você pode ler e gravar arquivos `bzip` e `gzip` do S3 que contenham arquivos CSV. Você configura o comportamento de compactação no [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) e não na configuração apresentada nesta página.
A tabela a seguir mostra quais são os recursos comuns do AWS Glue compatíveis com a opção de formato CSV.
| Ler | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Compatível | Compatível | Compatível | Compatível |
## Exemplo: ler arquivos ou pastas CSV do S3
**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas CSV que deseja ler.
**Configuração:** nas opções da sua função, especifique `format="csv"`. Em seu `connection_options`, use a chave `paths` para especificar `s3path`. Você pode configurar como o leitor interage com o S3 no `connection_options`. Para mais detalhes, consulte os tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Você pode configurar como o leitor interpreta os arquivos CSV em seu `format_options`. Para obter mais detalhes, consulte [CSV Configuration Reference](#aws-glue-programming-etl-format-csv-reference) (Referência de configuração de CSV).
O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas CSV provenientes do S3.
Fornecemos um leitor personalizado de CSV com otimizações de desempenho para fluxos de trabalho comuns por meio da chave de configuração `optimizePerformance`. Para determinar se esse leitor é adequado para sua workload, consulte [Otimizar o desempenho de leitura com o leitor de SIMD vetorizado para CSV](#aws-glue-programming-etl-format-simd-csv-reader).
------
#### [ Python ]
Neste exemplo, use o método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read CSV from S3
# For show, we handle a CSV with a header row. Set the withHeader option.
# Consider whether optimizePerformance is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="csv",
format_options={
"withHeader": True,
# "optimizePerformance": True,
},
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.format("csv")\
.option("header", "true")\
.load("s3://s3path")
```
------
#### [ Scala ]
Neste exemplo, use a operação [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read CSV from S3
// For show, we handle a CSV with a header row. Set the withHeader option.
// Consider whether optimizePerformance is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"withHeader": true}"""),
connectionType="s3",
format="csv",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
Você também pode usar DataFrames em um script (`org.apache.spark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("header","true")
.format("csv")
.load("s3://s3path“)
```
------
## Exemplo: gravar arquivos e pastas CSV no S3
**Pré-requisitos:** você precisará de um DataFrame (`dataFrame`) ou de um DynamicFrame (`dynamicFrame`) inicializado. Você também precisará do caminho de saída esperado do S3, `s3path`.
**Configuração:** nas opções da sua função, especifique `format="csv"`. Em seu `connection_options`, use a chave `paths` para especificar `s3path`. Você pode configurar como o gravador interage com o S3 no `connection_options`. Para mais detalhes, consulte os tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Você pode configurar como sua operação grava o conteúdo de seus arquivos no `format_options`. Para obter mais detalhes, consulte [CSV Configuration Reference](#aws-glue-programming-etl-format-csv-reference) (Referência de configuração de CSV). O seguinte script de ETL do AWS Glue mostra o processo de gravação de arquivos e pastas CSV no S3.
------
#### [ Python ]
Neste exemplo, use o método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write CSV to S3
# For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
connection_options={"path": "s3://s3path"},
format="csv",
format_options={
"quoteChar": -1,
},
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
dataFrame.write\
.format("csv")\
.option("quote", None)\
.mode("append")\
.save("s3://s3path")
```
------
#### [ Scala ]
Neste exemplo, use o método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write CSV to S3
// For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="csv"
).writeDynamicFrame(dynamicFrame)
}
}
```
Você também pode usar DataFrames em um script (`org.apache.spark.sql.DataFrame`).
```
dataFrame.write
.format("csv")
.option("quote", null)
.mode("Append")
.save("s3://s3path")
```
------
## Referência de configuração de CSV
Você pode usar o seguinte `format_options` sempre que as bibliotecas do AWS Glue especificarem `format="csv"`:
+ `separator`: especifica o caractere delimitador. O padrão é uma vírgula, mas é possível especificar qualquer outro caractere.
+ **Tipo:** texto, **padrão:** `","`
+ `escaper`: especifica um caractere a ser usado para escape. Essa opção é usada somente ao ler arquivos CSV, não para gravar. Se ativado, o caractere imediatamente seguinte será usado no estado em que se encontrar, exceto para um pequeno conjunto de escapes conhecidos (`\n`, `\r`, `\t` e `\0`).
+ **Tipo:** texto, **padrão:** nenhum
+ `quoteChar`: especifica o caractere a ser usado para aspas. O padrão é aspas duplas. Defina como `-1` para desativar as aspas por completo.
+ **Tipo:** texto, **padrão:** `'"'`
+ `multiLine`: especifica se um único registro pode abranger várias linhas. Isso pode ocorrer quando um campo contém um caractere de nova linha entre aspas. Você deve definir essa opção como `True` se algum registro ocupar várias linhas. Habilitar `multiLine` pode diminuir o desempenho, pois isso requer uma divisão de arquivos mais cautelosa durante a análise.
+ **Tipo:** booliano, **padrão:** `false`
+ `withHeader`: especifica se a primeira linha deve ser tratada como um cabeçalho. Esta opção pode ser usada na classe `DynamicFrameReader`.
+ **Tipo:** booliano, **padrão:** `false`
+ `writeHeader`: especifica se deve gravar o cabeçalho na saída. Esta opção pode ser usada na classe `DynamicFrameWriter`.
+ **Tipo:** booliano, **padrão:** `true`
+ `skipFirst`: especifica se é necessário ignorar a primeira linha de dados.
+ **Tipo:** booliano, **padrão:** `false`
+ `optimizePerformance`: especifica se deve usar o leitor de SIMD avançado para CSV junto com formatos de memória colunar baseados em Apache Arrow. Disponível apenas no AWS Glue 3.0\$1.
+ **Tipo:** booliano, **padrão:** `false`
+ `strictCheckForQuoting`: ao escrever CSVs, o Glue pode adicionar aspas aos valores que interpreta como strings. Isso é feito para evitar ambiguidade no que é gravado. Para economizar tempo ao decidir o que gravar, o Glue pode incluir aspas em determinadas situações em que as aspas não são necessárias. Habilitar uma verificação rigorosa executará um cálculo mais intensivo e só incluirá aspas quando estritamente necessário. Disponível apenas no AWS Glue 3.0\$1.
+ **Tipo:** booliano, **padrão:** `false`
## Otimizar o desempenho de leitura com o leitor de SIMD vetorizado para CSV
O AWS Glue versão 3.0 adiciona um leitor de CSV otimizado que pode acelerar significativamente o desempenho geral do trabalho em comparação com os leitores de CSV baseados em linhas.
O leitor otimizado:
+ Usa instruções SIMD da CPU para fazer leituras do disco.
+ Grava imediatamente registros na memória em um formato colunar (Apache Arrow).
+ Divide os registros em lotes.
Isso economiza tempo de processamento quando os registros são colocados em lote ou convertidos em um formato colunar posteriormente. Por exemplo, ao alterar esquemas ou recuperar dados por coluna.
Para usar o leitor otimizado, defina `"optimizePerformance"` como `true` na propriedade `format_options` ou da tabela.
```
glueContext.create_dynamic_frame.from_options(
frame = datasource1,
connection_type = "s3",
connection_options = {"paths": ["s3://s3path"]},
format = "csv",
format_options={
"optimizePerformance": True,
"separator": ","
},
transformation_ctx = "datasink2")
```
**Limitações para o leitor vetorizado de CSV**
Observe as seguintes limitações do leitor vetorizado de CSV:
+ Ele não oferece suporte às opções de formato `multiLine` e `escaper`. Ele usa o padrão `escaper` de caractere de aspas duplas `'"'`. Quando essas opções são definidas, o AWS Glue automaticamente volta ao uso do leitor de CSV baseado em linha.
+ Ele não oferece suporte à criação de um DynamicFrame com [ChoiceType](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-extensions-types.html#aws-glue-api-crawler-pyspark-extensions-types-awsglue-choicetype).
+ Ele não oferece suporte à criação de um DynamicFrame com [registros de erro](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame).
+ Ele não oferece suporte à leitura de arquivos CSV com caracteres multibyte, como caracteres japoneses ou chineses.
# Uso do formato Parquet no AWS Glue
O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se seus dados forem armazenados ou transportados no formato de dados Parquet, este documento apresenta os recursos disponíveis para usar seus dados no AWS Glue.
O AWS Glue é compatível com o uso do formato Parquet. Esse formato é um formato de dados orientado a desempenho e baseado em colunas. Para uma apresentação do formato feita pela autoridade padrão, consulte [Apache Parquet Documentation Overview](https://parquet.apache.org/docs/overview/) (Visão geral da documentação do Apache Parquet).
Você pode usar o AWS Glue para ler arquivos Parquet do Amazon S3 e de fontes de transmissão, bem como para gravar arquivos Parquet no Amazon S3. Você pode ler e gravar arquivos `bzip` e `gzip` do S3 que contenham arquivos Parquet. Você configura o comportamento de compactação no [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) e não na configuração apresentada nesta página.
A tabela a seguir mostra quais são os recursos comuns do AWS Glue compatíveis com a opção de formato Parquet.
| Ler | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Compatível | Compatível | Sem suporte | Compatível\$1 |
\$1Compatível com o AWS Glue versão 1.0\$1
## Exemplo: ler arquivos ou pastas Parquet do S3
**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas Parquet que deseja ler.
**Configuração:** nas opções da sua função, especifique `format="parquet"`. Em seu `connection_options`, use a chave `paths` para especificar seu `s3path`.
Você pode configurar como o leitor interage com o S3 no `connection_options`. Para mais detalhes, consulte os tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
Você pode configurar como o leitor interpreta os arquivos Parquet em seu `format_options`. Para obter mais detalhes, consulte [Parquet Configuration Reference](#aws-glue-programming-etl-format-parquet-reference) (Referência de configuração de Parquet).
O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas Parquet provenientes do S3:
------
#### [ Python ]
Neste exemplo, use o método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read Parquet from S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type = "s3",
connection_options = {"paths": ["s3://s3path/"]},
format = "parquet"
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read.parquet("s3://s3path/")
```
------
#### [ Scala ]
Neste exemplo, use o método [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read Parquet from S3
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="parquet",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
}
```
Você também pode usar DataFrames em um script (`org.apache.spark.sql.DataFrame`).
```
spark.read.parquet("s3://s3path/")
```
------
## Exemplo: gravar arquivos e pastas Parquet no S3
**Pré-requisitos:** você precisará de um DataFrame (`dataFrame`) ou de um DynamicFrame (`dynamicFrame`) inicializado. Você também precisará do caminho de saída esperado do S3, `s3path`.
**Configuração:** nas opções da sua função, especifique `format="parquet"`. Em seu `connection_options`, use a chave `paths` para especificar `s3path`.
Em `connection_options`, você pode alterar ainda mais a forma como o gravador interage com o S3. Para mais detalhes, consulte os tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Você pode configurar como sua operação grava o conteúdo de seus arquivos no `format_options`. Para obter mais detalhes, consulte [Parquet Configuration Reference](#aws-glue-programming-etl-format-parquet-reference) (Referência de configuração de Parquet).
O seguinte script de ETL do AWS Glue mostra o processo de gravação de arquivos e pastas Parquet no S3.
Fornecemos um gravador personalizado de Parquet com otimizações de desempenho para DynamicFrames, por meio da chave de configuração `useGlueParquetWriter`. Para determinar se esse gravador é adequado para sua workload, consulte [Glue Parquet Writer](#aws-glue-programming-etl-format-glue-parquet-writer) (Gravador Parquet do Glue).
------
#### [ Python ]
Neste exemplo, use o método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write Parquet to S3
# Consider whether useGlueParquetWriter is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="parquet",
connection_options={
"path": "s3://s3path",
},
format_options={
# "useGlueParquetWriter": True,
},
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
df.write.parquet("s3://s3path/")
```
------
#### [ Scala ]
Neste exemplo, use o método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write Parquet to S3
// Consider whether useGlueParquetWriter is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="parquet"
).writeDynamicFrame(dynamicFrame)
}
}
```
Você também pode usar DataFrames em um script (`org.apache.spark.sql.DataFrame`).
```
df.write.parquet("s3://s3path/")
```
------
## Referência de configuração do Parquet
Você pode usar o seguinte `format_options` sempre que as bibliotecas do AWS Glue especificarem `format="parquet"`:
+ `useGlueParquetWriter`: especifica o uso de um gravador de Parquet personalizado com otimizações de desempenho para fluxos de trabalho DynamicFrame. Para obter mais detalhes sobre o uso, consulte [Glue Parquet Writer](#aws-glue-programming-etl-format-glue-parquet-writer) (Gravador Parquet do Glue).
+ **Tipo:** booliano, **padrão:**`false`
+ `compression`: especifica o codec de compactação usado. Os valores são totalmente compatíveis com `org.apache.parquet.hadoop.metadata.CompressionCodecName`.
+ **Tipo:** texto enumerado, **padrão:** `"snappy"`
+ Valores: `"uncompressed"`, `"snappy"`, `"gzip"` e `"lzo"`
+ `blockSize`: especifica em bytes o tamanho de um grupo de linhas que está sendo armazenado em memória. Você usa isso para ajustar o desempenho. O tamanho deve ser dividido exatamente em um número de megabytes.
+ **Digite:** numérico, **padrão:**`134217728`
+ O valor padrão é igual a 128 MB.
+ `pageSize`: especifica o tamanho de uma página em bytes. Você usa isso para ajustar o desempenho. Uma página é a menor unidade que deve ser totalmente lida para acessar um único registro.
+ **Digite:** numérico, **padrão:**`1048576`
+ O valor padrão é igual a 1 MB.
**nota**
E ainda, quaisquer opções aceitas pelo código SparkSQL subjacente podem ser transmitidas para ele por meio do parâmetro de mapa `connection_options`. Por exemplo, é possível definir uma configuração do Spark, como [mergeSchema](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#schema-merging), para o leitor de Spark do AWS Glue mesclar o esquema para todos os arquivos.
## Otimizar o desempenho de gravação com o gravador de Parquet do AWS Glue
**nota**
Historicamente, o gravador de Parquet do AWS Glue tem sido acessado por meio do tipo de formato `glueparquet`. Esse padrão de acesso não é mais promovido. Em vez disso, use o tipo `parquet` com `useGlueParquetWriter` habilitado.
O gravador de Parquet do AWS Glue tem aprimoramentos de desempenho que permitem gravações mais rápidas de arquivos Parquet. O gravador tradicional calcula um esquema antes da gravação. O formato Parquet não armazena o esquema de uma maneira rapidamente recuperável, então isso pode levar algum tempo. Com o gravador de Parquet do AWS Glue, não é necessário usar um esquema pré-calculado. O gravador calcula e modifica o esquema dinamicamente conforme recebe os dados.
Ao especificar `useGlueParquetWriter`, observe as seguintes limitações:
+ O gravador oferece só é compatível com evolução do esquema (p. ex., adicionar ou remover colunas), mas não com a alteração de tipos de coluna, como com `ResolveChoice`.
+ O gravador não oferece suporte à gravação de DataFrames vazios; por exemplo, para gravar um arquivo somente de esquema. Ao realizar a integração com o Catálogo de Dados da AWS ao configurar `enableUpdateCatalog=True`, a tentativa de gravar um DataFrame vazio não atualizará o Catálogo de Dados. Isso resultará na criação de uma tabela no Catálogo de Dados sem esquema.
Se sua transformação não exigir essas limitações, a ativação do gravador Parquet do AWS Glue deverá aumentar o desempenho.
# Uso do formato XML no AWS Glue
O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se seus dados forem armazenados ou transportados no formato de dados XML, este documento apresenta os recursos disponíveis para usar seus dados no AWS Glue.
O AWS Glue é compatível com o uso do formato XML. Esse formato representa estruturas de dados altamente configuráveis e rigidamente definidas que não são baseadas em linhas ou colunas. O XML é altamente padronizado. Para uma introdução ao formato pela autoridade padrão, consulte [XML Essentials](https://www.w3.org/standards/xml/core) (Conceitos básicos de XML).
Você pode usar o AWS Glue para ler arquivos XML do Amazon S3, bem como arquivos `bzip` e `gzip` contendo arquivos XML. Você configura o comportamento de compactação no [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) e não na configuração apresentada nesta página.
A tabela a seguir mostra quais são os recursos comuns do AWS Glue compatíveis com a opção de formato XML.
| Leitura | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Sem compatibilidade | Sem compatibilidade | Compatível | Compatível |
## Exemplo: ler XML do S3
O leitor de XML usa um nome de tag XML. Ele examina elementos com essa tag em sua entrada para inferir um esquema e preenche um DynamicFrame com valores correspondentes. A funcionalidade de XML do AWS Glue se comporta de modo semelhante a [XML Data Source for Apache Spark](https://github.com/databricks/spark-xml) (Fonte de dados XML para Apache Spark). Talvez você consiga obter informações sobre o comportamento básico comparando esse leitor com a documentação do projeto.
**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas XML que deseja ler, além de algumas informações sobre seu arquivo XML. Você também precisará da tag para o elemento XML que deseja ler, `xmlTag`.
**Configuração:** nas opções da sua função, especifique `format="xml"`. Em seu `connection_options`, use a chave `paths` para especificar `s3path`. Você pode configurar adicionalmente como o leitor interage com o S3 no `connection_options`. Para mais detalhes, consulte os tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Em seu `format_options`, use a chave `rowTag` para especificar `xmlTag`. Você pode configurar adicionalmente como o leitor interpreta os arquivos XML em seu `format_options`. Para obter mais detalhes, consulte [XML Configuration Reference](#aws-glue-programming-etl-format-xml-reference) (Referência de configuração de XML).
O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas XML provenientes do S3.
------
#### [ Python ]
Neste exemplo, use o método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read XML from S3
# Set the rowTag option to configure the reader.
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="xml",
format_options={"rowTag": "xmlTag"},
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.format("xml")\
.option("rowTag", "xmlTag")\
.load("s3://s3path")
```
------
#### [ Scala ]
Neste exemplo, use a operação [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read XML from S3
// Set the rowTag option to configure the reader.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkSession
val glueContext = new GlueContext(SparkContext.getOrCreate())
val sparkSession: SparkSession = glueContext.getSparkSession
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"rowTag": "xmlTag"}"""),
connectionType="s3",
format="xml",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
```
Você também pode usar DataFrames em um script (`org.apache.spark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("rowTag", "xmlTag")
.format("xml")
.load("s3://s3path“)
```
------
## Referência de configuração de XML
Você pode usar o seguinte `format_options` sempre que as bibliotecas do AWS Glue especificarem `format="xml"`:
+ `rowTag`: especifica a tag XML no arquivo a ser tratada como uma linha. Tags de linha não podem ser de fechamento automático.
+ **Tipo:** texto, **obrigatório**
+ `encoding`: especifica a codificação de caracteres. Pode ser o nome ou alias de um [Charset](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html) compatível com nosso ambiente de runtime. Não oferecemos garantias específicas em relação ao suporte à codificação, mas as codificações principais devem funcionar.
+ **Tipo:** texto, **padrão:** `"UTF-8"`
+ `excludeAttribute`: especifica se você deseja excluir atributos em elementos ou não.
+ **Tipo:** booliano, **padrão:** `false`
+ `treatEmptyValuesAsNulls`: especifica se o espaço em branco deve ser tratado como um valor nulo.
+ **Tipo:** booliano, **padrão:** `false`
+ `attributePrefix`: um prefixo para atributos a fim de diferenciá-los de elementos de texto secundários. Esse prefixo é usado para nomes de campo.
+ **Tipo:** texto, **padrão:** `"_"`
+ `valueTag`: a tag usada para um valor quando há atributos no elemento que não têm secundários.
+ **Tipo:** texto, **padrão:** `"_VALUE"`
+ `ignoreSurroundingSpaces`: especifica se o espaço em branco que envolve valores deve ser ignorado.
+ **Tipo:** booliano, **padrão:** `false`
+ `withSchema`: contém o esquema esperado, em situações nas quais você deseja substituir o esquema inferido. Se você não usar essa opção, o AWS Glue inferirá o esquema com base nos dados XML.
+ **Tipo:** texto, **padrão:** não aplicável
+ O valor deve ser um objeto JSON que represente um `StructType`.
## Especificar manualmente o esquema XML
**Exemplo de esquema XML manual**
Este é um exemplo de uso da opção de formato `withSchema` para especificar o esquema para dados XML.
```
from awsglue.gluetypes import *
schema = StructType([
Field("id", IntegerType()),
Field("name", StringType()),
Field("nested", StructType([
Field("x", IntegerType()),
Field("y", StringType()),
Field("z", ChoiceType([IntegerType(), StringType()]))
]))
])
datasource0 = create_dynamic_frame_from_options(
connection_type,
connection_options={"paths": ["s3://xml_bucket/someprefix"]},
format="xml",
format_options={"withSchema": json.dumps(schema.jsonValue())},
transformation_ctx = ""
)
```
# Uso do formato Avro no AWS Glue
O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se seus dados forem armazenados ou transportados no formato de dados Avro, o documento apresenta os recursos disponíveis para usar seus dados no AWS Glue.
O AWS Glue é compatível com o uso do formato Avro. Esse é um formato de dados orientado a performance e baseado em linhas. Para uma apresentação do formato feita pela autoridade padrão, consulte [a documentação do Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/).
Você pode usar o AWS Glue para ler arquivos Avro do Amazon S3 e de fontes de transmissão, bem como para gravar arquivos Avro no Amazon S3. Você pode ler e gravar arquivos `bzip2` e `gzip` do S3 que contenham arquivos Avro. Além disso, você pode gravar arquivamentos `deflate`, `snappy` e `xz` contendo arquivos Avro. Você configura o comportamento de compactação no [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) e não na configuração apresentada nesta página.
A tabela a seguir mostra quais são as operações comuns do AWS Glue compatíveis com a opção de formato Avro.
| Leitura | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Compatível | Compatível\$1 | Sem compatibilidade | Compatível |
\$1Compatível, com restrições. Para obter mais informações, consulte [Notas e restrições para fontes de transmissão Avro](add-job-streaming.md#streaming-avro-notes).
## Exemplo: ler arquivos ou pastas Avro do S3
**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas Avro que deseja ler.
**Configuração:** nas opções da sua função, especifique `format="avro"`. Em seu `connection_options`, use a chave `paths` para especificar `s3path`. Você pode configurar como o leitor interage com o S3 no `connection_options`. Para obter detalhes, consulte Opções de formato de dados para entradas e saídas de ETL no AWSGlue: [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Você pode configurar como o leitor interpreta os arquivos Avro em seu `format_options`. Para obter mais detalhes, consulte [Avro Configuration Reference](#aws-glue-programming-etl-format-avro-reference) (Referência de configuração de Avro).
O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas Avro provenientes do S3:
------
#### [ Python ]
Neste exemplo, use o método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="avro"
)
```
------
#### [ Scala ]
Neste exemplo, use a operação [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="avro",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
```
------
## Exemplo: gravar arquivos e pastas Avro no S3
**Pré-requisitos:** você precisará de um DataFrame (`dataFrame`) ou de um DynamicFrame (`dynamicFrame`) inicializado. Você também precisará do caminho de saída esperado do S3, `s3path`.
**Configuração:** nas opções da sua função, especifique `format="avro"`. Em seu `connection_options`, use a chave `paths` para especificar seu `s3path`. Em `connection_options`, você pode alterar ainda mais a forma como o gravador interage com o S3. Para obter detalhes, consulte Opções de formato de dados para entradas e saídas de ETL no AWSGlue: [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Você pode alterar a forma como o gravador interpreta os arquivos Avro em `format_options`. Para obter mais detalhes, consulte [Avro Configuration Reference](#aws-glue-programming-etl-format-avro-reference) (Referência de configuração de Avro).
O seguinte script de ETL do AWS Glue mostra o processo de gravação de arquivos ou pastas Avro no S3.
------
#### [ Python ]
Neste exemplo, use o método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="avro",
connection_options={
"path": "s3://s3path"
}
)
```
------
#### [ Scala ]
Neste exemplo, use o método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="avro"
).writeDynamicFrame(dynamicFrame)
}
}
```
------
## Referência de configuração de Avro
Você pode usar os seguinte valores de `format_options` sempre que as bibliotecas do AWS Glue especificarem `format="avro"`:
+ `version`: especifica a versão do formato de leitor/gravador Apache Avro a ser suportada. O padrão é “1.7”. É possível especificar `format_options={"version": “1.8”}` para habilitar a leitura e gravação do tipo lógico Avro. Para obter mais informações, consulte a [Especificação do Apache Avro 1.7.7](https://avro.apache.org/docs/1.7.7/spec.html) e a [Especificação do Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/spec.html).
O conector do Apache Avro 1.8 oferece suporte para os seguintes tipos de conversão:
Para o leitor: esta tabela mostra a conversão entre o tipo de dados Avro (tipo lógico e o tipo primitivo Avro) e o tipo de dados `DynamicFrame` do AWS Glue para o leitor Avro 1.7 e 1.8.
| Tipo de dados Avro: Tipo lógico | Tipo de dados Avro: Tipo primitivo Avro | Tipo de dados GlueDynamicFrame:Leitor Avro 1.7 | Tipo de dados GlueDynamicFrame: Leitor Avro 1.8 |
| --- | --- | --- | --- |
| Decimal | bytes | BINARY | Decimal |
| Decimal | fixo | BINARY | Decimal |
| Data | int | INT | Data |
| Tempo (milissegundo) | int | INT | INT |
| Tempo (microssegundo) | longo | LONG | LONG |
| Time stamp (milissegundo) | longo | LONG | Timestamp |
| Time stamp (microssegundo) | longo | LONG | LONG |
| Duração (não é um tipo lógico) | fixo de 12 | BINARY | BINARY |
Para o gravador: esta tabela mostra a conversão entre o tipo de dados `DynamicFrame` do AWS Glue e o tipo de dados Avro para o gravador Avro 1.7 e 1.8.
| Tipo de dados do `DynamicFrame` do AWS Glue | Tipo de dados Avro:Gravador Avro 1.7 | Tipo de dados Avro:Gravador Avro 1.8 |
| --- | --- | --- |
| Decimal | String | decimal |
| Data | String | date |
| Marca de data e hora | String | timestamp-micros |
## Suporte para Avro Spark DataFrame
Para usar o Avro da API Spark DataFrame, é necessário instalar o plugin Spark Avro para a versão correspondente do Spark. A versão do Spark disponível em seu trabalho é determinada pela versão do AWS Glue. Para obter mais informações sobre as versões do Spark, consulte [AWS GlueVersões do](release-notes.md). O plugin é mantido pelo Apache. Não oferecemos garantias específicas de suporte.
No AWS Glue 2.0: use a versão 2.4.3 do plugin do Spark Avro. Você encontra esse JAR no Maven Central. Consulte [org.apache.spark:spark-avro\$12.12:2.4.3](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar).
No AWS Glue 3.0: use a versão 3.1.1 do plugin do Spark Avro. Você encontra esse JAR no Maven Central. Consulte [org.apache.spark:spark-avro\$12.12:3.1.1](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar).
Para incluir JARs adicionais em um trabalho de ETL do AWS Glue, use o parâmetro de trabalho `--extra-jars`. Para obter mais informações sobre parâmetros de trabalho, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md). Também é possível configurar esse parâmetro no Console de gerenciamento da AWS.
# Uso do formato grokLog no AWS Glue
O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se seus dados forem armazenados ou transportados em um formato de texto não criptografado fracamente estruturado, o documento apresenta os recursos disponíveis para usar seus dados no AWS Glue por meio de padrões Grok.
O AWS Glue é compatível com o uso de padrões Grok. Os padrões Grok são semelhantes aos grupos de captura de expressões regulares. Eles reconhecem padrões de sequências de caracteres em um arquivo de texto simples e fornecem um tipo e propósito. No AWS Glue, seu objetivo principal é ler logs. Para ver uma apresentação do Grok feita pelos autores, consulte [Logstash Reference: Grok filter plugin](https://www.elastic.co/guide/en/logstash/current/plugins-filters-grok.html) (Referência do Logstash: plugin de filtro Grok).
| Leitura | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Não aplicável | Compatível | Compatível | Sem compatibilidade |
## Referência da configuração grokLog
Você pode usar os seguintes valores de `format_options` com `format="grokLog"`:
+ `logFormat`: especifica o padrão Grok que corresponde ao formato de log.
+ `customPatterns`: especifica outros padrões Grok usados aqui.
+ `MISSING`: especifica o sinal a ser usado na identificação de valores ausentes. O padrão é `'-'`.
+ `LineCount`: especifica o número de linhas em cada registro de log. O padrão é `'1'`, e atualmente somente os registros de linha única são compatíveis.
+ `StrictMode`: um valor booliano que especifica se o modo estrito está habilitado. No modo estrito, o leitor não faz conversão ou recuperação de tipo automática. O valor padrão é `"false"`.
# Uso do formato Ion no AWS Glue
O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se seus dados forem armazenados ou transportados no formato de dados Ion, este documento apresenta os recursos disponíveis para usar seus dados no AWS Glue.
O AWS Glue é compatível com o uso do formato Ion. Esse formato representa estruturas de dados (que não são baseadas em linhas ou colunas) em representações intercambiáveis em binários e em texto não criptografado. Para ver uma apresentação do formato feita pelos autores, consulte [Amazon Ion](https://amzn.github.io/ion-docs/). (Para obter mais informações, consulte a [Especificação do Amazon Ion](https://amzn.github.io/ion-docs/spec.html).)
Você pode usar o AWS Glue para ler arquivos Ion do Amazon S3. Você pode ler arquivos `bzip` e `gzip` do S3 que contenham arquivos Ion. Você configura o comportamento de compactação no [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) e não na configuração apresentada nesta página.
A tabela a seguir mostra quais são as operações comuns do AWS Glue compatíveis com a opção de formato Ion.
| Leitura | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Sem compatibilidade | Sem compatibilidade | Compatível | Sem compatibilidade |
## Exemplo: ler arquivos e pastas Ion do S3
**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas Ion que você deseja ler.
**Configuração:** nas opções da sua função, especifique `format="json"`. Em seu `connection_options`, use a chave `paths` para especificar seu `s3path`. Você pode configurar como o leitor interage com o S3 no `connection_options`. Para mais detalhes, consulte os tipos de conexão e opções para ETL no AWS Glue: [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas Ion provenientes do S3:
------
#### [ Python ]
Neste exemplo, use o método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read ION from S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="ion"
)
```
------
#### [ Scala ]
Neste exemplo, use a operação [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read ION from S3
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="ion",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
------
## Referência de configuração de Ion
Não há valores de `format_options` para `format="ion"`.
# Uso do formato JSON no AWS Glue
O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se os dados forem armazenados ou transportados no formato de dados JSON, este documento apresenta os recursos disponíveis para usar os dados no AWS Glue.
O AWS Glue é compatível com o uso do formato JSON. Esse formato representa estruturas de dados com forma consistente, mas com conteúdo flexível, que não são baseadas em linhas ou colunas. O JSON é definido por padrões paralelos emitidos por várias autoridades, e uma dela é a ECMA-404. Para ver uma apresentação do formato por uma fonte bastante referenciada, consulte [Introducing JSON](https://www.json.org/) (Introdução ao JSON).
Você pode usar o AWS Glue para ler arquivos JSON do Amazon S3, bem como arquivos JSON `bzip` e `gzip` compactados. Você configura o comportamento de compactação no [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) e não na configuração apresentada nesta página.
| Leitura | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Compatível | Compatível | Compatível | Compatível |
## Exemplo: ler arquivos ou pastas JSON do S3
**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas JSON que gostaria de ler.
**Configuração:** nas opções da sua função, especifique `format="json"`. Em seu `connection_options`, use a chave `paths` para especificar seu `s3path`. Você pode alterar ainda mais a forma como sua operação de leitura atravessará o S3 nas opções de conexão. Consulte [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) para obter mais detalhes. Você pode configurar como o leitor interpreta os arquivos JSON em seu `format_options`. Para obter mais detalhes, consulte [JSON Configuration Reference](#aws-glue-programming-etl-format-json-reference) (Referência de configuração de JSON).
O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas JSON provenientes do S3:
------
#### [ Python ]
Neste exemplo, use o método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read JSON from S3
# For show, we handle a nested JSON file that we can limit with the JsonPath parameter
# For show, we also handle a JSON where a single entry spans multiple lines
# Consider whether optimizePerformance is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="json",
format_options={
"jsonPath": "$.id",
"multiline": True,
# "optimizePerformance": True, -> not compatible with jsonPath, multiline
}
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.option("multiline", "true")\
.json("s3://s3path")
```
------
#### [ Scala ]
Neste exemplo, use a operação [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read JSON from S3
// For show, we handle a nested JSON file that we can limit with the JsonPath parameter
// For show, we also handle a JSON where a single entry spans multiple lines
// Consider whether optimizePerformance is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"jsonPath": "$.id", "multiline": true, "optimizePerformance":false}"""),
connectionType="s3",
format="json",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("multiline", "true")
.json("s3://s3path")
```
------
## Exemplo: gravar arquivos e pastas JSON no S3
**Pré-requisitos:**você precisará de um DataFrame (`dataFrame`) ou de um DynamicFrame (`dynamicFrame`) inicializado. Você também precisará do caminho de saída esperado do S3, `s3path`.
**Configuração:** nas opções da sua função, especifique `format="json"`. Em seu `connection_options`, use a chave `paths` para especificar `s3path`. Em `connection_options`, você pode alterar ainda mais a forma como o gravador interage com o S3. Para obter detalhes, consulte Opções de formato de dados para entradas e saídas de ETL no AWSGlue: [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Você pode configurar como o gravador interpreta os arquivos JSON em seu `format_options`. Para obter mais detalhes, consulte [JSON Configuration Reference](#aws-glue-programming-etl-format-json-reference) (Referência de configuração de JSON).
O seguinte script de ETL do AWS Glue mostra o processo de gravação de arquivos ou pastas JSON provenientes do S3:
------
#### [ Python ]
Neste exemplo, use o método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write JSON to S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
connection_options={"path": "s3://s3path"},
format="json"
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
df.write.json("s3://s3path/")
```
------
#### [ Scala ]
Neste exemplo, use o método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write JSON to S3
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="json"
).writeDynamicFrame(dynamicFrame)
}
}
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
df.write.json("s3://s3path")
```
------
## Referência de configuração de JSON
Você pode usar os seguintes valores de `format_options` com `format="json"`:
+ `jsonPath`: uma expressão [JsonPath](https://github.com/json-path/JsonPath) que identifica um objeto a ser ler lido em registros. Isso é especialmente útil quando um arquivo contém registros aninhados dentro de uma matriz externa. Por exemplo, a expressão JsonPath a seguir visa o campo `id` de um objeto JSON.
```
format="json", format_options={"jsonPath": "$.id"}
```
+ `multiline`: um valor booliano que especifica se um único registro pode gerar várias linhas. Isso pode ocorrer quando um campo contém um caractere de nova linha entre aspas. Você deve definir essa opção como `"true"` se algum registro ocupar várias linhas. O valor padrão é `"false"`, que permite uma divisão de arquivos mais radical durante a análise.
+ `optimizePerformance`: um valor booleano que especifica se deve usar o leitor SIMD para JSON avançado junto com formatos de memória colunar baseados em Apache Arrow. Disponível apenas no AWS Glue 3.0. Não compatível com `multiline` ou `jsonPath`. Fornecer qualquer uma dessas opções instruirá o AWS Glue a voltar ao leitor padrão.
+ `withSchema`: um valor de String que especifica um esquema de tabela no formato descrito em [Especificar manualmente o esquema XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema). Usado apenas com o `optimizePerformance` ao ler de conexões que não são do catálogo.
## Usar o leitor vetorizado SIMD para JSON com formato colunar Apache Arrow
O AWS Glue versão 3.0 adiciona um leitor vetorizado para dados JSON. Ele executa duas vezes mais rápido sob certas condições, em comparação com o leitor padrão. Esse leitor vem com certas limitações que os usuários devem conhecer antes de usar, documentadas nesta seção.
Para usar o leitor otimizado, defina `"optimizePerformance"` como Verdadeiro no `format_options` ou propriedade de tabela. Você também precisará fornecer `withSchema` a menos que esteja lendo do catálogo. O `withSchema` espera uma entrada conforme descrito em [Especificar manualmente o esquema XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema)
```
// Read from S3 data source
glueContext.create_dynamic_frame.from_options(
connection_type = "s3",
connection_options = {"paths": ["s3://s3path"]},
format = "json",
format_options={
"optimizePerformance": True,
"withSchema": SchemaString
})
// Read from catalog table
glueContext.create_dynamic_frame.from_catalog(
database = database,
table_name = table,
additional_options = {
// The vectorized reader for JSON can read your schema from a catalog table property.
"optimizePerformance": True,
})
```
Para obter mais informações sobre a criação de um *SchemaString* na biblioteca do AWS Glue, consulte [Tipos de extensão do PySpark](aws-glue-api-crawler-pyspark-extensions-types.md).
**Limitações para o leitor vetorizado de CSV**
Observe as seguintes limitações:
+ Elementos JSON com objetos aninhados ou valores de matriz não são compatíveis. Se fornecido, o AWS Glue voltará para o leitor padrão.
+ Um esquema deve ser fornecido do Catálogo ou com `withSchema`.
+ Não compatível com `multiline` ou `jsonPath`. Fornecer qualquer uma dessas opções instruirá o AWS Glue a voltar ao leitor padrão.
+ Fornecer registros de entrada que não correspondam ao esquema de entrada resultará em falha do leitor.
+ [Registros de erro](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame) não serão criados.
+ Arquivos JSON com caracteres multiByte, como caracteres japoneses ou chineses, não são aceitos.
# Usar o formato ORC no AWS Glue
O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se seus dados forem armazenados ou transportados no formato de dados ORC, este documento apresenta os recursos disponíveis para usar seus dados no AWS Glue.
O AWS Glue é compatível com o uso do formato ORC. Esse formato é um formato de dados orientado a desempenho e baseado em colunas. Para ver uma introdução ao formato pela autoridade padrão, consulte [Apache Orc](https://orc.apache.org/docs/).
Você pode usar o AWS Glue para ler arquivos ORC do Amazon S3 e de fontes de transmissão, bem como para gravar arquivos ORC no Amazon S3. Você pode ler e gravar arquivos `bzip` e `gzip` do S3 que contenham arquivos ORC. Você configura o comportamento de compactação no [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) e não na configuração apresentada nesta página.
A tabela a seguir mostra quais são as operações comuns do AWS Glue compatíveis com a opção de formato ORC.
| Leitura | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Compatível | Compatível | Sem compatibilidade | Compatível\$1 |
\$1Compatível com o AWS Glue versão 1.0\$1
## Exemplo: ler arquivos ou pastas ORC do S3
**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas ORC que deseja ler.
**Configuração:** nas opções da sua função, especifique `format="orc"`. Em seu `connection_options`, use a chave `paths` para especificar seu `s3path`. Você pode configurar como o leitor interage com o S3 no `connection_options`. Para mais detalhes, consulte os tipos de conexão e opções para ETL no AWS Glue: [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas ORC provenientes do S3:
------
#### [ Python ]
Neste exemplo, use o método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="orc"
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.orc("s3://s3path")
```
------
#### [ Scala ]
Neste exemplo, use a operação [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="orc",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
}
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
val dataFrame = spark.read
.orc("s3://s3path")
```
------
## Exemplo: gravar arquivos e pastas ORC no S3
**Pré-requisitos:** você precisará de um DataFrame (`dataFrame`) ou de um DynamicFrame (`dynamicFrame`) inicializado. Você também precisará do caminho de saída esperado do S3, `s3path`.
**Configuração:** nas opções da sua função, especifique `format="orc"`. Em suas opções de conexão, use a chave `paths` para especificar `s3path`. Em `connection_options`, você pode alterar ainda mais a forma como o gravador interage com o S3. Para obter detalhes, consulte Opções de formato de dados para entradas e saídas de ETL no AWSGlue: [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). O código de exemplo a seguir mostra o processo:
------
#### [ Python ]
Neste exemplo, use o método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="orc",
connection_options={
"path": "s3://s3path"
}
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
df.write.orc("s3://s3path/")
```
------
#### [ Scala ]
Neste exemplo, use o método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="orc"
).writeDynamicFrame(dynamicFrame)
}
}
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
df.write.orc("s3://s3path/")
```
------
## Referência de configuração de ORC
Não há valores de `format_options` para `format="orc"`. No entanto, quaisquer opções aceitas pelo código SparkSQL subjacente podem ser transmitidas para ele por meio do parâmetro de mapa `connection_options`.
# Usar estruturas de data lake com trabalhos do AWS Glue ETL
As estruturas de data lake de código aberto simplificam o processamento incremental de dados para os arquivos que você armazena em data lakes criados no Amazon S3. O AWS Glue 3.0 e posteriores são compatíveis com as seguintes estruturas de data lake de código aberto:
+ Apache Hudi
+ Linux Foundation Delta Lake
+ Apache Iceberg
Fornecemos suporte nativo para essas estruturas para que você possa ler e gravar os dados que armazenar no Amazon S3 de maneira transacionalmente consistente. Não é necessário instalar um conector separado nem realizar etapas adicionais de configuração para usar essas estruturas em trabalhos do AWS Glue ETL.
Ao gerenciar conjuntos de dados por meio do AWS Glue Data Catalog, você pode usar os métodos do AWS Glue para ler e gravar tabelas de data lake com o Spark DataFrames. Você também pode ler e gravar dados do Amazon S3 usando a API DataFrame do Spark.
Neste vídeo, você pode aprender sobre os conceitos básicos de como o Apache Hudi, o Apache Iceberg e o Delta Lake funcionam. Você verá como inserir, atualizar e excluir dados no data lake e como cada uma dessas estruturas funciona.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/fryfx0Zg7KA)
**Topics**
+ [Limitações](aws-glue-programming-etl-datalake-native-frameworks-limitations.md)
+ [Usar a estrutura Hudi no AWS Glue](aws-glue-programming-etl-format-hudi.md)
+ [Usar a estrutura Delta Lake no AWS Glue](aws-glue-programming-etl-format-delta-lake.md)
+ [Usar a estrutura Iceberg no AWS Glue](aws-glue-programming-etl-format-iceberg.md)
# Limitações
Considere as seguintes limitações antes de usar estruturas de data lake com o AWS Glue.
+ Os métodos do `GlueContext` do AWS Glue a seguir não são compatíveis com leitura e escrita em tabelas de estrutura de data lake. Em vez disso, use os métodos `GlueContext` da API do DataFrame ou Spark DataFrame.
+ `create_dynamic_frame.from_catalog`
+ `write_dynamic_frame.from_catalog`
+ `getDynamicFrame`
+ `writeDynamicFrame`
+ Os métodos `GlueContext` a seguir para DataFrame são compatíveis com o controle de permissão do Lake Formation:
+ `create_data_frame.from_catalog`
+ `write_data_frame.from_catalog`
+ `getDataFrame`
+ `writeDataFrame`
+ [Agrupamento de arquivos pequenos](grouping-input-files.md) não é compatível.
+ [Marcadores de trabalho](monitor-continuations.md) não são compatíveis.
+ O Apache Hudi 0.10.1 para AWS Glue 3.0 não é compatível com tabelas Merge on Read (MoR) do Hudi.
+ `ALTER TABLE … RENAME TO` não está disponível para o Apache Iceberg 0.13.1 para o AWS Glue 3.0.
## Limitações para tabelas em formato de data lake gerenciadas pelas permissões do Lake Formation
Os formatos de data lake são integrados ao AWS Glue ETL por meio das permissões do Lake Formation. Não há suporte à criação de um DynamicFrame usando `create_dynamic_frame`. Para obter mais informações, veja os exemplos a seguir:
+ [Exemplo: ler e escrever na tabela do Iceberg com o controle de permissão do Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-iceberg.html#aws-glue-programming-etl-format-iceberg-read-write-lake-formation-tables)
+ [Exemplo: ler e escrever na tabela do Hudi com o controle de permissão do Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-hudi.html#aws-glue-programming-etl-format-hudi-read-write-lake-formation-tables)
+ [Exemplo: ler e escrever na tabela do Delta Lake com o controle de permissão do Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-delta-lake.html#aws-glue-programming-etl-format-delta-lake-read-write-lake-formation-tables)
**nota**
A integração com o AWS Glue ETL por meio das permissões do Lake Formation para o Apache Hudi, o Apache Iceberg e o Delta Lake só é possível no AWS Glue versão 4.0.
O Apache Iceberg tem a melhor integração com o AWS Glue ETL por meio das permissões do Lake Formation. Ele é compatível com quase todas as operações e inclui suporte a SQL.
O Hudi é compatível com a maioria das operações básicas, com exceção de operações administrativas. Isso ocorre porque essas opções geralmente são feitas por meio da gravação de dataframes e especificadas via `additional_options`. Você precisa usar APIs do AWS Glue para criar DataFrames para suas operações, pois não há suporte ao SparkSQL.
O Delta Lake é compatível somente com leitura, anexação e substituição de dados da tabela. O Delta Lake exige o uso de suas próprias bibliotecas para poder realizar várias tarefas, como atualizações.
Os recursos a seguir não estão disponíveis para tabelas do Iceberg gerenciadas por permissões do Lake Formation.
+ Compactação usando o AWS Glue ETL
+ Suporte ao Spark SQL via AWS Glue ETL
A seguir estão as limitações das tabelas do Hudi gerenciadas por permissões do Lake Formation:
+ Remoção de arquivos órfãos
A seguir estão as limitações das tabelas do Data Lake gerenciadas por permissões do Lake Formation:
+ Todos os recursos, exceto inserir e ler das tabelas do Delta Lake.
# Usar a estrutura Hudi no AWS Glue
O AWS Glue 3.0 e versões posteriores são compatíveis com a estrutura Apache Hudi para data lakes. Hudi é uma estrutura de armazenamento de data lake de código aberto que simplifica o processamento incremental de dados e o desenvolvimento de pipelines de dados. Este tópico aborda os recursos disponíveis para usar dados no AWS Glue ao transportar ou armazenar dados em uma tabela do Hudi. Para saber mais sobre o Hudi, consulte a [documentação do Apache Hudi](https://hudi.apache.org/docs/overview/).
Você pode usar o AWS Glue para realizar operações de leitura e gravação em tabelas do Hudi no Amazon S3 ou trabalhar com tabelas do Hudi usando o AWS Glue Data Catalog. Operações adicionais, incluindo inserção, atualização e todas as [operações do Apache Spark](https://hudi.apache.org/docs/quick-start-guide/) também são compatíveis.
**nota**
A implementação do Apache Hudi 0.15.0 no AWS Glue 5.0 reverte internamente o [HUDI-7001](https://github.com/apache/hudi/pull/9936). Ele não exibe a regressão relacionada à geração de chaves complexas quando a chave de registro consiste em um único campo. No entanto, esse comportamento difere do OSS Apache Hudi 0.15.0.
O Apache Hudi 0.10.1 para AWS Glue 3.0 não é compatível com tabelas Merge on Read (MoR) do Hudi.
A tabela a seguir lista a versão do Hudi incluída em cada versão do AWS Glue.
****
| Versão do AWS Glue | Versões compatíveis do Hudi |
| --- | --- |
| 5.1 | 1.0.2 |
| 5,0 | 0.15.0 |
| 4,0 | 0.12.1 |
| 3.0 | 0.10.1 |
Para saber mais sobre as estruturas de data lake compatíveis com o AWS Glue, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Habilitar o Hudi
Para habilitar o Hudi para AWS Glue, faça as seguintes tarefas:
+ Especifique `hudi` como um valor para o parâmetro de trabalho `--datalake-formats`. Para obter mais informações, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Crie uma chave denominada `--conf` para o trabalho do AWS Glue e defina-a com o seguinte valor. Ou então, você pode definir a configuração a seguir usando `SparkConf` no script. Essas configurações ajudam o Apache Spark a lidar corretamente com as tabelas do Hudi.
```
spark.serializer=org.apache.spark.serializer.KryoSerializer
```
+ O suporte à permissão do Lake Formation para tabelas do Hudi está habilitado por padrão para o AWS Glue 4.0. Nenhuma configuração adicional é necessária para leitura/escrita em tabelas do Hudi registradas no Lake Formation. Para ler uma tabela do Hudi registrada, o perfil do IAM do trabalho do AWS Glue deve ter a permissão SELECT. Para escrever em uma tabela do Hudi registrada, o perfil do IAM do trabalho do AWS Glue deve ter a permissão SUPER. Para saber mais sobre como gerenciar as permissões do Lake Formation, consulte [Conceder e revogar permissões nos recursos do Catálogo de Dados](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
**Usar uma versão diferente do Hudi**
Para usar uma versão do Hudi que não é compatível com o AWS Glue, especifique seus próprios arquivos JAR do Hudi usando o parâmetro de trabalho `--extra-jars`. Não inclua `hudi` como um valor para o parâmetro de trabalho `--datalake-formats`. Se você usa o AWS Glue 5.0 ou versões superiores, é necessário definir o parâmetro `--user-jars-first true` do trabalho.
## Exemplo: escrever uma tabela Hudi no Amazon S3 e registrá-la no AWS Glue Data Catalog
O exemplo a seguir demonstra como gravar uma tabela do Hudi no Amazon S3 e registrá-la no AWS Glue Data Catalog. O exemplo usa a [ferramenta Hive Sync](https://hudi.apache.org/docs/syncing_metastore/) do Hudi para registrar a tabela.
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
```
# Example: Create a Hudi table from a DataFrame
# and register the table to Glue Data Catalog
additional_options={
"hoodie.table.name": "",
"hoodie.database.name": "",
"hoodie.datasource.write.storage.type": "COPY_ON_WRITE",
"hoodie.datasource.write.operation": "upsert",
"hoodie.datasource.write.recordkey.field": "",
"hoodie.datasource.write.precombine.field": "",
"hoodie.datasource.write.partitionpath.field": "",
"hoodie.datasource.write.hive_style_partitioning": "true",
"hoodie.datasource.hive_sync.enable": "true",
"hoodie.datasource.hive_sync.database": "",
"hoodie.datasource.hive_sync.table": "",
"hoodie.datasource.hive_sync.partition_fields": "",
"hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc": "false",
"hoodie.datasource.hive_sync.mode": "hms",
"path": "s3://"
}
dataFrame.write.format("hudi") \
.options(**additional_options) \
.mode("overwrite") \
.save()
```
------
#### [ Scala ]
```
// Example: Example: Create a Hudi table from a DataFrame
// and register the table to Glue Data Catalog
val additionalOptions = Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "upsert",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms",
"path" -> "s3://")
dataFrame.write.format("hudi")
.options(additionalOptions)
.mode("append")
.save()
```
------
## Exemplo: ler uma tabela do Hudi do Amazon S3 usando o AWS Glue Data Catalog
Este exemplo lê a tabela Hudi que você criou no [Exemplo: escrever uma tabela Hudi no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-hudi-write) do Amazon S3.
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este exemplo, use o método `GlueContext.create\$1data\$1frame.from\$1catalog()`.
```
# Example: Read a Hudi table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
dataFrame = glueContext.create_data_frame.from_catalog(
database = "",
table_name = ""
)
```
------
#### [ Scala ]
Neste exemplo, use o método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource).
```
// Example: Read a Hudi table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
}
}
```
------
## Exemplo: atualizar e inserir um `DataFrame` a em uma tabela do Hudi no Amazon S3
Este exemplo usa o AWS Glue Data Catalog para inserir um DataFrame na tabela do Hudi que você criou em [Exemplo: escrever uma tabela Hudi no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-hudi-write).
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este exemplo, use o método `GlueContext.write\$1data\$1frame.from\$1catalog()`.
```
# Example: Upsert a Hudi table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame = dataFrame,
database = "",
table_name = "",
additional_options={
"hoodie.table.name": "",
"hoodie.database.name": "",
"hoodie.datasource.write.storage.type": "COPY_ON_WRITE",
"hoodie.datasource.write.operation": "upsert",
"hoodie.datasource.write.recordkey.field": "",
"hoodie.datasource.write.precombine.field": "",
"hoodie.datasource.write.partitionpath.field": "",
"hoodie.datasource.write.hive_style_partitioning": "true",
"hoodie.datasource.hive_sync.enable": "true",
"hoodie.datasource.hive_sync.database": "",
"hoodie.datasource.hive_sync.table": "",
"hoodie.datasource.hive_sync.partition_fields": "",
"hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc": "false",
"hoodie.datasource.hive_sync.mode": "hms"
}
)
```
------
#### [ Scala ]
Neste exemplo, use o método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink).
```
// Example: Upsert a Hudi table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.JsonOptions
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = JsonOptions(Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "upsert",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms"
)))
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Exemplo: ler uma tabela do Hudi do Amazon S3 usando o Spark
Este exemplo lê uma tabela do Hudi do Amazon S3 usando a API do Spark.
------
#### [ Python ]
```
# Example: Read a Hudi table from S3 using a Spark DataFrame
dataFrame = spark.read.format("hudi").load("s3://")
```
------
#### [ Scala ]
```
// Example: Read a Hudi table from S3 using a Spark DataFrame
val dataFrame = spark.read.format("hudi").load("s3://")
```
------
## Exemplo: gravar uma tabela no Amazon S3 usando o Spark
Este exemplo grava uma tabela no Amazon S3 usando o Spark.
------
#### [ Python ]
```
# Example: Write a Hudi table to S3 using a Spark DataFrame
dataFrame.write.format("hudi") \
.options(**additional_options) \
.mode("overwrite") \
.save("s3://)
```
------
#### [ Scala ]
```
// Example: Write a Hudi table to S3 using a Spark DataFrame
dataFrame.write.format("hudi")
.options(additionalOptions)
.mode("overwrite")
.save("s3://")
```
------
## Exemplo: ler e escrever na tabela do Hudi com o controle de permissão do Lake Formation
Este exemplo lê e escreve uma tabela do Hudi com o controle de permissão do Lake Formation
1. Criar uma tabela do Hudi e registrá-la no Lake Formation
1. Para habilitar o controle de permissão do Lake Formation, primeiro será necessário registrar o caminho da tabela do Amazon S3 no Lake Formation. Para obter mais informações, consulte [Registering an Amazon S3 location](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html) (Registrar um local do Amazon S3). É possível registrá-lo no console do Lake Formation ou usando a AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Depois de registrar uma localização no Amazon S3, qualquer tabela do AWS Glue apontando para a localização (ou qualquer uma de suas localizações secundárias) retornará o valor do parâmetro `IsRegisteredWithLakeFormation` como verdadeiro na chamada `GetTable`.
1. Crie uma tabela do Hudi que aponte para o caminho registrado do Amazon S3 por meio da API de dataframe do Spark:
```
hudi_options = {
'hoodie.table.name': table_name,
'hoodie.database.name': database_name,
'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE',
'hoodie.datasource.write.recordkey.field': 'product_id',
'hoodie.datasource.write.table.name': table_name,
'hoodie.datasource.write.operation': 'upsert',
'hoodie.datasource.write.precombine.field': 'updated_at',
'hoodie.datasource.write.hive_style_partitioning': 'true',
'hoodie.upsert.shuffle.parallelism': 2,
'hoodie.insert.shuffle.parallelism': 2,
'path': ,
'hoodie.datasource.hive_sync.enable': 'true',
'hoodie.datasource.hive_sync.database': database_name,
'hoodie.datasource.hive_sync.table': table_name,
'hoodie.datasource.hive_sync.use_jdbc': 'false',
'hoodie.datasource.hive_sync.mode': 'hms'
}
df_products.write.format("hudi") \
.options(**hudi_options) \
.mode("overwrite") \
.save()
```
1. Conceda permissão do Lake Formation para o perfil do IAM do trabalho do AWS Glue. Você pode conceder permissões no console do Lake Formation ou usando a AWS CLI. Para obter mais informações, consulte [Conceder permissões de banco de dados usando o console do Lake Formation e o método de recurso nomeado](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Leia a tabela do Hudi registrada no Lake Formation. O código é o mesmo que o da leitura de uma tabela do Hudi não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SELECT para que a leitura seja bem-sucedida.
```
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
```
1. Escreva em uma tabela do Hudi registrada no Lake Formation. O código é o mesmo que o da escrita em uma tabela do Hudi não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SUPER para que a escrita seja bem-sucedida.
```
glueContext.getCatalogSink("", "",
additionalOptions = JsonOptions(Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms"
)))
.writeDataFrame(dataFrame, glueContext)
```
# Usar a estrutura Delta Lake no AWS Glue
O AWS Glue 3.0 e versões posteriores são compatíveis com a estrutura Linux Foundation Delta Lake. Delta Lake é uma estrutura de armazenamento de data lake de código aberto que ajuda você a realizar transações ACID, escalar o tratamento de metadados e unificar o streaming e o processamento de dados em lote. Este tópico aborda os recursos disponíveis para usar dados no AWS Glue ao transportar ou armazenar dados em uma tabela do Delta Lake. Para saber mais sobre o Delta Lake, consulte a [documentação oficial do Delta Lake](https://docs.delta.io/latest/delta-intro.html).
Você pode usar o AWS Glue para realizar operações de leitura e gravação em tabelas do Delta Lake no Amazon S3 ou trabalhar com tabelas do Delta Lake usando o AWS Glue Data Catalog. Operações adicionais, como inserção, atualização e [leitura e gravação em lote de tabelas](https://docs.delta.io/0.7.0/api/python/index.html), também são compatíveis. Quando você usa tabelas do Delta Lake, também tem a opção de usar métodos da biblioteca do Delta Lake Python, como `DeltaTable.forPath`. Para obter mais informações sobre a biblioteca de Python do Delta Lake, consulte a documentação de Python do Delta Lake.
A tabela a seguir lista a versão do Delta Lake incluída em cada versão do AWS Glue.
****
| Versão do AWS Glue | Versão Delta Lake compatível |
| --- | --- |
| 5.1 | 3.3.2 |
| 5,0 | 3.3.0 |
| 4,0 | 2.1.0 |
| 3.0 | 1.0.0 |
Para saber mais sobre as estruturas de data lake compatíveis com o AWS Glue, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Habilitar o Delta Lake para AWS Glue
Para habilitar o Delta Lake para AWS Glue, faça as seguintes tarefas:
+ Especifique `delta` como um valor para o parâmetro de trabalho `--datalake-formats`. Para obter mais informações, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Crie uma chave denominada `--conf` para o trabalho do AWS Glue e defina-a com o seguinte valor. Ou então, é possível definir a configuração a seguir usando `SparkConf` no script. Essas configurações ajudam o Apache Spark a lidar corretamente com tabelas do Delta Lake.
```
spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog --conf spark.delta.logStore.class=org.apache.spark.sql.delta.storage.S3SingleDriverLogStore
```
+ O suporte à permissão do Lake Formation para tabelas do Delta está habilitado por padrão para o AWS Glue 4.0. Nenhuma configuração adicional é necessária para leitura/escrita em tabelas do Delta registradas no Lake Formation. Para ler uma tabela do Delta registrada, o perfil do IAM do trabalho do AWS Glue deve ter a permissão SELECT. Para escrever em uma tabela do Delta registrada, o perfil do IAM do trabalho do AWS Glue deve ter a permissão SUPER. Para saber mais sobre como gerenciar as permissões do Lake Formation, consulte [Conceder e revogar permissões nos recursos do Catálogo de Dados](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
**Usar uma versão diferente do Delta Lake**
Para usar uma versão do Delta Lake que não seja compatível com o AWS Glue, especifique seus próprios arquivos JAR do Delta Lake usando o parâmetro de trabalho `--extra-jars`. Não inclua `delta` como um valor para o parâmetro de trabalho `--datalake-formats`. Se você usa o AWS Glue 5.0 ou versões superiores, é necessário definir o parâmetro `--user-jars-first true` do trabalho. Para usar a biblioteca do Delta Lake Python nesse caso, você deve especificar os arquivos JAR da biblioteca usando o parâmetro de trabalho `--extra-py-files`. A biblioteca do Python vem empacotada nos arquivos JAR do Delta Lake.
## Exemplo: escrever uma tabela Delta Lake no Amazon S3 e registrá-la no AWS Glue Data Catalog
O script do AWS Glue ETL a seguir demonstra como gravar uma tabela do Delta Lake no Amazon S3 e registrá-la no AWS Glue Data Catalog.
------
#### [ Python ]
```
# Example: Create a Delta Lake table from a DataFrame
# and register the table to Glue Data Catalog
additional_options = {
"path": "s3://"
}
dataFrame.write \
.format("delta") \
.options(**additional_options) \
.mode("append") \
.partitionBy("") \
.saveAsTable(".")
```
------
#### [ Scala ]
```
// Example: Example: Create a Delta Lake table from a DataFrame
// and register the table to Glue Data Catalog
val additional_options = Map(
"path" -> "s3://"
)
dataFrame.write.format("delta")
.options(additional_options)
.mode("append")
.partitionBy("")
.saveAsTable(".")
```
------
## Exemplo: ler uma tabela do Delta Lake do Amazon S3 usando o AWS Glue Data Catalog
O script do AWS Glue ETL a seguir lê a tabela do Delta Lake que você criou em [Exemplo: escrever uma tabela Delta Lake no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-delta-lake-write).
------
#### [ Python ]
Neste exemplo, use o método [create\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog).
```
# Example: Read a Delta Lake table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Neste exemplo, use o método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource).
```
// Example: Read a Delta Lake table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val df = glueContext.getCatalogSource("", "",
additionalOptions = additionalOptions)
.getDataFrame()
}
}
```
------
## Exemplo: inserir um `DataFrame` em uma tabela do Delta Lake no Amazon S3 usando o AWS Glue Data Catalog
Este exemplo insere dados na tabela do Delta Lake que você criou em [Exemplo: escrever uma tabela Delta Lake no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-delta-lake-write).
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Neste exemplo, use o método [write\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog).
```
# Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Neste exemplo, use o método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink).
```
// Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = additionalOptions)
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Exemplo: ler uma tabela do Delta Lake do Amazon S3 usando a API do Spark
Este exemplo lê uma tabela do Delta Lake do Amazon S3 usando a API do Spark.
------
#### [ Python ]
```
# Example: Read a Delta Lake table from S3 using a Spark DataFrame
dataFrame = spark.read.format("delta").load("s3://")
```
------
#### [ Scala ]
```
// Example: Read a Delta Lake table from S3 using a Spark DataFrame
val dataFrame = spark.read.format("delta").load("s3://")
```
------
## Exemplo: gravar uma tabela do Delta Lake no Amazon S3 usando o Spark
Exemplo: grava uma tabela do Delta Lake no Amazon S3 usando o Spark.
------
#### [ Python ]
```
# Example: Write a Delta Lake table to S3 using a Spark DataFrame
dataFrame.write.format("delta") \
.options(**additional_options) \
.mode("overwrite") \
.partitionBy("")
.save("s3://")
```
------
#### [ Scala ]
```
// Example: Write a Delta Lake table to S3 using a Spark DataFrame
dataFrame.write.format("delta")
.options(additionalOptions)
.mode("overwrite")
.partitionBy("")
.save("s3://")
```
------
## Exemplo: ler e escrever na tabela do Delta Lake com o controle de permissão do Lake Formation
Este exemplo lê e escreve uma tabela do Delta Lake com o controle de permissão do Lake Formation.
1. Criar uma tabela do Delta e registrá-la no Lake Formation
1. Para habilitar o controle de permissão do Lake Formation, primeiro será necessário registrar o caminho da tabela do Amazon S3 no Lake Formation. Para obter mais informações, consulte [Registering an Amazon S3 location](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html) (Registrar um local do Amazon S3). É possível registrá-lo no console do Lake Formation ou usando a AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Depois de registrar uma localização no Amazon S3, qualquer tabela do AWS Glue apontando para a localização (ou qualquer uma de suas localizações secundárias) retornará o valor do parâmetro `IsRegisteredWithLakeFormation` como verdadeiro na chamada `GetTable`.
1. Crie uma tabela do Delta que aponte para o caminho registrado do Amazon S3 por meio do Spark:
**nota**
Os exemplos a seguir foram criados em Python.
```
dataFrame.write \
.format("delta") \
.mode("overwrite") \
.partitionBy("") \
.save("s3://")
```
Depois que os dados forem gravados no Amazon S3, use o crawler do AWS Glue para criar uma nova tabela de catálogo do Delta. Para obter mais informações, consulte [Introdução ao suporte a tabelas nativas do Delta Lake com crawlers do AWS Glue](https://aws.amazon.com/blogs/big-data/introducing-native-delta-lake-table-support-with-aws-glue-crawlers/).
Você também pode criar a tabela manualmente por meio da API `CreateTable` do AWS Glue.
1. Conceda permissão do Lake Formation para o perfil do IAM do trabalho do AWS Glue. Você pode conceder permissões no console do Lake Formation ou usando a AWS CLI. Para obter mais informações, consulte [Conceder permissões de banco de dados usando o console do Lake Formation e o método de recurso nomeado](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Leia a tabela do Delta registrada no Lake Formation. O código é o mesmo que o da leitura de uma tabela do Delta não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SELECT para que a leitura seja bem-sucedida.
```
# Example: Read a Delta Lake table from Glue Data Catalog
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
1. Escreva em uma tabela do Delta registrada no Lake Formation. O código é o mesmo que o da escrita em uma tabela do Delta não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SUPER para que a escrita seja bem-sucedida.
Por padrão, o AWS Glue usa `Append` como saveMode. Você pode alterá-lo configurando a opção saveMode em `additional_options`. Para obter informações sobre o suporte ao saveMode em tabelas do Delta, consulte [Escrever em uma tabela](https://docs.delta.io/latest/delta-batch.html#write-to-a-table).
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
# Usar a estrutura Iceberg no AWS Glue
O AWS Glue 3.0 e versões posteriores são compatíveis com a estrutura Apache Iceberg para data lakes. O Iceberg fornece um formato de tabela de alta performance que funciona exatamente como uma tabela SQL. Este tópico aborda os recursos disponíveis para usar dados no AWS Glue ao transportar ou armazenar dados em uma tabela do Iceberg. Para saber mais sobre o Iceberg, consulte a [documentação do Apache Iceberg](https://iceberg.apache.org/docs/latest/).
É possível usar o AWS Glue para realizar operações de leitura e gravação em tabelas do Iceberg no Amazon S3 ou trabalhar com tabelas do Iceberg usando o AWS Glue Data Catalog. Operações adicionais, incluindo inserção e todas as [consultas do Spark](https://iceberg.apache.org/docs/latest/spark-queries/) e [gravações do Spark](https://iceberg.apache.org/docs/latest/spark-writes/) também são compatíveis. Não há suporte à atualização de tabelas do Iceberg.
**nota**
`ALTER TABLE … RENAME TO` não está disponível para o Apache Iceberg 0.13.1 para AWS Glue 3.0.
A tabela a seguir lista a versão do Iceberg incluída em cada versão do AWS Glue.
****
| Versão do AWS Glue | Versão compatível do Iceberg |
| --- | --- |
| 5.1 | 1.10.0 |
| 5,0 | 1.7.1 |
| 4,0 | 1.0.0 |
| 3.0 | 0.13.1 |
Para saber mais sobre as estruturas de data lake compatíveis com o AWS Glue, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Habilitar a estrutura Iceberg
Para habilitar o Iceberg para AWS Glue, faça as seguintes tarefas:
+ Especifique `iceberg` como um valor para o parâmetro de trabalho `--datalake-formats`. Para obter mais informações, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Crie uma chave denominada `--conf` para o trabalho do AWS Glue e defina-a com o seguinte valor. Ou então, é possível definir a configuração a seguir usando `SparkConf` no script. Essas configurações ajudam o Apache Spark a lidar corretamente com as tabelas do Iceberg.
```
spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog
--conf spark.sql.catalog.glue_catalog.warehouse=s3:///
--conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog
--conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO
```
Se você estiver lendo ou gravando em tabelas do Iceberg registradas no Lake Formation, siga as orientações em [Usar o AWS Glue com AWS Lake Formation para controle de acesso refinado](security-lf-enable.md) no AWS Glue 5.0 e versões posteriores. No AWS Glue 4.0, adicione a configuração a seguir para habilitar o suporte ao Lake Formation.
```
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true
--conf spark.sql.catalog.glue_catalog.glue.id=
```
Se você usar o AWS Glue 3.0 com o Iceberg 0.13.1, deverá definir as seguintes configurações adicionais para usar o gerenciador de bloqueios do Amazon DynamoDB para garantir a transação atômica. AWS O Glue 4.0 usa o bloqueio positivo por padrão. Para obter mais informações, consulte [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/#dynamodb-lock-manager) na documentação oficial do Apache Iceberg.
```
--conf spark.sql.catalog.glue_catalog.lock-impl=org.apache.iceberg.aws.glue.DynamoLockManager
--conf spark.sql.catalog.glue_catalog.lock.table=
```
**Usar uma versão diferente do Iceberg**
Para usar uma versão do Iceberg que não é compatível com o AWS Glue, especifique seus próprios arquivos JAR do Iceberg usando o parâmetro de trabalho `--extra-jars`. Não inclua `iceberg` como um valor para o parâmetro `--datalake-formats`. Se você usa o AWS Glue 5.0 ou versões superiores, é necessário definir o parâmetro `--user-jars-first true` do trabalho.
**Habilitar criptografia para tabelas do Iceberg**
**nota**
As tabelas do Iceberg têm seus próprios mecanismos para habilitar a criptografia no lado do servidor. Você deve habilitar essa configuração além da configuração de segurança do AWS Glue.
Para habilitar a criptografia do lado do servidor nas tabelas do Iceberg, consulte as orientações na [documentação do Iceberg.](https://iceberg.apache.org/docs/latest/aws/#s3-server-side-encryption)
**Adicionar configuração do Spark para acesso entre regiões do Iceberg**
Para adicionar uma configuração adicional do Spark para acesso à tabela entre regiões do Iceberg com o Catálogo de Dados do AWS Glue e o AWS Lake Formation, siga as etapas abaixo:
1. Crie um [ponto de acesso multirregional](https://docs.aws.amazon.com/AmazonS3/latest/userguide/multi-region-access-point-create-examples.html).
1. Defina as seguintes propriedades do Spark:
```
-----
--conf spark.sql.catalog.my_catalog.s3.use-arn-region-enabled=true \
--conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket1", "arn:aws:s3:::accesspoint/.mrap \
--conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket2", "arn:aws:s3:::accesspoint/.mrap
-----
```
## Exemplo: escrever uma tabela do Iceberg no Amazon S3 e registrá-la no AWS Glue Data Catalog
Esse exemplo de script demonstra como escrever uma tabela Iceberg no Amazon S3. O exemplo usa aso [integrações da AWS no Iceberg](https://iceberg.apache.org/docs/latest/aws/) para registrar a tabela no AWS Glue Data Catalog.
------
#### [ Python ]
```
# Example: Create an Iceberg table from a DataFrame
# and register the table to Glue Data Catalog
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
TBLPROPERTIES ("format-version"="2")
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
------
#### [ Scala ]
```
// Example: Example: Create an Iceberg table from a DataFrame
// and register the table to Glue Data Catalog
dataFrame.createOrReplaceTempView("tmp_")
val query = """CREATE TABLE glue_catalog..
USING iceberg
TBLPROPERTIES ("format-version"="2")
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
------
Como alternativa, é possível escrever uma tabela do Iceberg no Amazon S3 e no catálogo de dados usando os métodos do Spark.
Pré-requisitos: você precisará provisionar um catálogo para uso da biblioteca do Iceberg. Ao usar o catálogo de dados do AWS Glue, o AWS Glue simplifica essa operação. O catálogo de dados do AWS Glue é pré-configurado para ser usado pelas bibliotecas do Spark como `glue_catalog`. As tabelas do catálogo de dados são identificadas por um*databaseName* e um *tableName*. Para obter mais informações sobre o catálogo de dados do AWS Glue, consulte [Descoberta e catalogação de dados no AWS Glue](catalog-and-crawler.md).
Se você não estiver usando o catálogo de dados do AWS Glue, precisará provisionar um catálogo por meio das APIs do Spark. Para obter mais informações, consulte [Configuração do Spark](https://iceberg.apache.org/docs/latest/spark-configuration/) na documentação do Iceberg.
Este exemplo grava uma tabela Iceberg no Amazon S3 e no Data Catalog usando Spark.
------
#### [ Python ]
```
# Example: Write an Iceberg table to S3 on the Glue Data Catalog
# Create (equivalent to CREATE TABLE AS SELECT)
dataFrame.writeTo("glue_catalog.databaseName.tableName") \
.tableProperty("format-version", "2") \
.create()
# Append (equivalent to INSERT INTO)
dataFrame.writeTo("glue_catalog.databaseName.tableName") \
.tableProperty("format-version", "2") \
.append()
```
------
#### [ Scala ]
```
// Example: Write an Iceberg table to S3 on the Glue Data Catalog
// Create (equivalent to CREATE TABLE AS SELECT)
dataFrame.writeTo("glue_catalog.databaseName.tableName")
.tableProperty("format-version", "2")
.create()
// Append (equivalent to INSERT INTO)
dataFrame.writeTo("glue_catalog.databaseName.tableName")
.tableProperty("format-version", "2")
.append()
```
------
## Exemplo: ler uma tabela do Iceberg do Amazon S3 usando o AWS Glue Data Catalog
Este exemplo lê a tabela do Iceberg que você criou em [Exemplo: escrever uma tabela do Iceberg no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-iceberg-write).
------
#### [ Python ]
Para este exemplo, use o método `GlueContext.create\$1data\$1frame.from\$1catalog()`.
```
# Example: Read an Iceberg table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Neste exemplo, use o método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource).
```
// Example: Read an Iceberg table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val df = glueContext.getCatalogSource("", "",
additionalOptions = additionalOptions)
.getDataFrame()
}
}
```
------
## Exemplo: inserir um `DataFrame` em um tabela do Iceberg no Amazon S3 usando o AWS Glue Data Catalog
Este exemplo insere dados na tabela do Iceberg que você criou em [Exemplo: escrever uma tabela do Iceberg no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-iceberg-write).
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este exemplo, use o método `GlueContext.write\$1data\$1frame.from\$1catalog()`.
```
# Example: Insert into an Iceberg table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Neste exemplo, use o método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink).
```
// Example: Insert into an Iceberg table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = additionalOptions)
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Exemplo: ler uma tabela do Iceberg do Amazon S3 usando o Spark
Pré-requisitos: você precisará provisionar um catálogo para uso da biblioteca do Iceberg. Ao usar o catálogo de dados do AWS Glue, o AWS Glue simplifica essa operação. O catálogo de dados do AWS Glue é pré-configurado para ser usado pelas bibliotecas do Spark como `glue_catalog`. As tabelas do catálogo de dados são identificadas por um*databaseName* e um *tableName*. Para obter mais informações sobre o catálogo de dados do AWS Glue, consulte [Descoberta e catalogação de dados no AWS Glue](catalog-and-crawler.md).
Se você não estiver usando o catálogo de dados do AWS Glue, precisará provisionar um catálogo por meio das APIs do Spark. Para obter mais informações, consulte [Configuração do Spark](https://iceberg.apache.org/docs/latest/spark-configuration/) na documentação do Iceberg.
Este exemplo lê uma tabela do Iceberg no Amazon S3 do catálogo de dados usando o Spark.
------
#### [ Python ]
```
# Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog
dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName")
```
------
#### [ Scala ]
```
// Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog
val dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName")
```
------
## Exemplo: ler e escrever na tabela do Iceberg com o controle de permissão do Lake Formation
Este exemplo lê e escreve uma tabela do Iceberg com o controle de permissão do Lake Formation.
**nota**
Este exemplo funciona apenas no AWS Glue 4.0. No AWS Glue 5.0 e versões posteriores, siga as orientações em [Usar o AWS Glue com AWS Lake Formation para controle de acesso refinado](security-lf-enable.md).
1. Crie uma tabela do Iceberg e registrá-la no Lake Formation:
1. Para habilitar o controle de permissão do Lake Formation, primeiro será necessário registrar o caminho da tabela do Amazon S3 no Lake Formation. Para obter mais informações, consulte [Registering an Amazon S3 location](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html) (Registrar um local do Amazon S3). É possível registrá-lo no console do Lake Formation ou usando a AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Depois de registrar uma localização no Amazon S3, qualquer tabela do AWS Glue apontando para a localização (ou qualquer uma de suas localizações secundárias) retornará o valor do parâmetro `IsRegisteredWithLakeFormation` como verdadeiro na chamada `GetTable`.
1. Crie uma tabela do Iceberg que aponte para o caminho registrado por meio do Spark:
**nota**
Os exemplos a seguir foram criados em Python.
```
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
Você também pode criar a tabela manualmente por meio da API `CreateTable` do AWS Glue. Para obter mais informações, consulte [Criar tabelas do Apache Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-iceberg-tables.html).
**nota**
No momento, a API `UpdateTable` não oferece suporte ao formato de tabela do Iceberg como entrada para a operação.
1. Conceda permissão do Lake Formation para o perfil do IAM do trabalho. É possível conceder permissões no console do Lake Formation ou usando a AWS CLI. Para obter mais informações, consulte: https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html
1. Leia uma tabela do Iceberg registrada no Lake Formation. O código é o mesmo que o da leitura de uma tabela do Iceberg não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SELECT para que a leitura seja bem-sucedida.
```
# Example: Read an Iceberg table from the AWS Glue Data Catalog
from awsglue.context import GlueContextfrom pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
1. Escreva em uma tabela do Iceberg registrada no Lake Formation. O código é o mesmo que o da escrita em uma tabela do Iceberg não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SUPER para que a escrita seja bem-sucedida.
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
## Referência de configuração compartilhada
Você pode usar os valores de `format_options` a seguir com qualquer tipo de formato.
+ `attachFilename`: uma string no formato apropriado para ser usada como nome de coluna. Se você fornecer essa opção, o nome do arquivo de origem do registro será anexado ao registro. O valor do parâmetro será usado como nome da coluna.
+ `attachTimestamp`: uma string no formato apropriado para ser usada como nome de coluna. Se você fornecer essa opção, a hora da modificação do arquivo de origem do registro será anexado ao registro. O valor do parâmetro será usado como nome da coluna.