# 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\_dynamic\_frame.from\_options](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\_dynamic\_frame.from\_options](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\+. + **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\+. + **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.