# Particionar workloads com execução limitada
<a name="bounded-execution"></a>

Erros em aplicações do Spark geralmente surgem de scripts ineficientes do Spark, execução distribuída na memória de transformações em grande escala e anormalidades do conjunto de dados. Há muitas razões que podem causar problemas de memória de driver ou executor, por exemplo, uma distorção de dados, listar muitos objetos ou colocar em ordem aleatória dados grandes. Esses problemas geralmente aparecem quando você está processando grandes quantidades de dados de backlog com o Spark.

O AWS Glue permite que você resolva problemas de OOM e torne seu processamento ETL mais fácil com o particionamento de workload. Com o particionamento de workload habiltado, cada execução de trabalho de ETL seleciona somente dados não processados, com um limite superior no tamanho do conjunto de dados ou o número de arquivos a serem processados com essa execução de trabalho. Futuras execuções de trabalho processarão os dados restantes. Por exemplo, se houver 1.000 arquivos que precisem ser processados, você pode definir o número de arquivos para 500 e separá-los em duas execuções de trabalho.

O particionamento de workload é suportado apenas para fontes de dados do Amazon S3.

## Habilitar o particionamento de workloads
<a name="bounded-execution-enable"></a>

Você pode habilitar a execução limitada definindo manualmente as opções no seu script ou adicionando propriedades da tabela de catálogo.

**Para habilitar o particionamento de workload com execução limitada no seu script:**

1. Para evitar o reprocessamento de dados, habilite os marcadores de trabalho no novo trabalho ou no já existente. Para obter mais informações, consulte [Rastreamento de dados processados usando marcadores de trabalho](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html).

1. Modifique seu script e defina o limite nas opções adicionais na API `getSource` do AWS Glue. Você também deve definir o contexto de transformação para que o marcador de trabalho armazene o elemento `state`. Por exemplo:

   Python

   ```
   glueContext.create_dynamic_frame.from_catalog(
       database = "database",
       table_name = "table_name",
       redshift_tmp_dir = "",
       transformation_ctx = "datasource0",
       additional_options = {
           "boundedFiles" : "500", # need to be string
         # "boundedSize" : "1000000000" unit is byte
       }
   )
   ```

   Scala

   ```
   val datasource0 = glueContext.getCatalogSource(
       database = "database", tableName = "table_name", redshiftTmpDir = "", 
       transformationContext = "datasource0",
       additionalOptions = JsonOptions(
           Map("boundedFiles" -> "500") // need to be string
         //"boundedSize" -> "1000000000" unit is byte
       ) 
   ).getDynamicFrame()
   ```

   ```
   val connectionOptions = JsonOptions(
       Map("paths" -> List(baseLocation), "boundedFiles" -> "30")
   )
   val source = glueContext.getSource("s3", connectionOptions, "datasource0", "")
   ```

**Para habilitar o particionamento de workload com execução limitada na tabela do Data Catalog:**

1. Defina os pares de chave-valor no campo `parameters` de sua estrutura de tabela no Data Catalog. Para obter mais informações, consulte [Visualização e edição dos detalhes da tabela](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details).

1. Defina o limite superior para o tamanho do conjunto de dados ou o número de arquivos processados:
   + Defina `boundedSize` para o tamanho de destino do conjunto de dados em bytes. A execução do trabalho será interrompida depois de atingir o tamanho desejado da tabela.
   + Defina `boundedFiles` para o número de destino de arquivos. A execução do trabalho será interrompida após o processamento do número de arquivos desejado.
**nota**  
Você deve definir apenas um entre `boundedSize` ou `boundedFiles`, pois somente um limite é suportado.

## Configurar um acionador do AWS Glue para executar o trabalho automaticamente
<a name="bounded-execution-trigger"></a>

Depois de habilitar a execução limitada, é possível configurar um acionador do AWS Glue para executar automaticamente o trabalho e carregar os dados incrementalmente em execuções sequenciais. Vá para console do AWS Glue e crie um acionador, configure o horário de programação e anexe-o ao seu trabalho. Em seguida, ele acionará automaticamente a próxima execução do trabalho e processará o novo lote de dados. 

Você também pode usar fluxos de trabalho do AWS Glue para orquestrar vários trabalhos a fim de processar dados de diferentes partições simultaneamente. Para obter mais informações, consulte [Acionadores do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/about-triggers.html) e [Fluxos de trabalho do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/workflows_overview.html).

Para obter mais informações sobre casos de uso e opções, consulte o blog [Optimizing Spark applications with workload partitioning in AWS Glue](https://aws.amazon.com/blogs/big-data/optimizing-spark-applications-with-workload-partitioning-in-aws-glue/).