As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Otimizando o desempenho de gravação
<a name="best-practices-write"></a>

Esta seção discute as propriedades da tabela que você pode ajustar para otimizar o desempenho de gravação nas tabelas do Iceberg, independentemente do mecanismo.

## Definir o modo de distribuição da tabela
<a name="write-distribution-mode"></a>

O Iceberg oferece vários modos de distribuição de gravação que definem como os dados de gravação são distribuídos nas tarefas do Spark. Para uma visão geral dos modos disponíveis, consulte [Escrevendo modos de distribuição](https://iceberg.apache.org/docs/latest/spark-writes/#writing-distribution-modes) na documentação do Iceberg.

Para casos de uso que priorizam a velocidade de gravação, especialmente em cargas de trabalho de streaming, defina como. `write.distribution-mode` `none` Isso garante que o Iceberg não solicite embaralhamento adicional do Spark e que os dados sejam gravados assim que forem disponibilizados nas tarefas do Spark. Esse modo é particularmente adequado para aplicativos Spark Structured Streaming.

**nota**  
Definir o modo de distribuição de gravação como `none` tende a produzir vários arquivos pequenos, o que degrada o desempenho de leitura. Recomendamos a compactação regular para consolidar esses arquivos pequenos em arquivos de tamanho adequado para o desempenho da consulta.

## Escolha a estratégia de atualização correta
<a name="write-update-strategy"></a>

Use uma merge-on-read**** estratégia para otimizar o desempenho de gravação, quando operações de leitura mais lentas nos dados mais recentes forem aceitáveis para seu caso de uso.

Quando você usa merge-on-read, o Iceberg grava atualizações e exclui no armazenamento como pequenos arquivos separados. Quando a tabela é lida, o leitor precisa mesclar essas alterações com os arquivos base para retornar a visão mais recente dos dados. Isso resulta em uma penalidade de desempenho nas operações de leitura, mas acelera a gravação de atualizações e exclusões. Normalmente, merge-on-read é ideal para streaming de cargas de trabalho com atualizações ou trabalhos com poucas atualizações espalhadas por várias partições de tabela.

Você pode definir merge-on-read as configurações (`write.update.mode``write.delete.mode`, e`write.merge.mode`) no nível da tabela ou de forma independente no lado do aplicativo.

O uso merge-on-read requer a execução de compactação regular para evitar que o desempenho de leitura se degrade com o tempo. A compactação reconcilia atualizações e exclusões com arquivos de dados existentes para criar um novo conjunto de arquivos de dados, eliminando assim a penalidade de desempenho incorrida no lado da leitura. Por padrão, a compactação do Iceberg não mescla arquivos excluídos, a menos que você altere o padrão da `delete-file-threshold` propriedade para um valor menor (consulte a documentação do [Iceberg](https://iceberg.apache.org/docs/latest/spark-procedures/#rewrite_data_files)). Para saber mais sobre compactação, consulte a seção Compactação do [Iceberg](best-practices-compaction.md) mais adiante neste guia.

## Escolha o formato de arquivo correto
<a name="write-file-format"></a>

O Iceberg suporta a gravação de dados nos formatos Parquet, ORC e Avro. O parquet é o formato padrão. Parquet e ORC são formatos colunares que oferecem desempenho de leitura superior, mas geralmente são mais lentos para gravar. Isso representa a compensação típica entre desempenho de leitura e gravação.

Se a velocidade de gravação for importante para seu caso de uso, como em cargas de trabalho de streaming, considere escrever no formato Avro `write-format` configurando como `Avro` nas opções do gravador. Como o Avro é um formato baseado em linhas, ele fornece tempos de gravação mais rápidos ao custo de um desempenho de leitura mais lento.

Para melhorar o desempenho de leitura, execute a compactação regular para mesclar e transformar pequenos arquivos Avro em arquivos Parquet maiores. O resultado do processo de compactação é determinado pela configuração da `write.format.default` tabela. O formato padrão do Iceberg é o Parquet, então se você escrever em Avro e depois executar a compactação, o Iceberg transformará os arquivos Avro em arquivos Parquet. Veja um exemplo abaixo:

```
spark.sql(f"""
    CREATE TABLE IF NOT EXISTS glue_catalog.{DB_NAME}.{TABLE_NAME} (
        Col_1 float, 
        <<<…other columns…>>
        ts timestamp)
    USING iceberg
    PARTITIONED BY (days(ts))
    OPTIONS (
      'format-version'='2',
      write.format.default'=parquet)
""")

query = df \
    .writeStream \
    .format("iceberg") \
    .option("write-format", "avro") \
    .outputMode("append") \
    .trigger(processingTime='60 seconds') \
    .option("path", f"glue_catalog.{DB_NAME}.{TABLE_NAME}") \
    .option("checkpointLocation", f"s3://{BUCKET_NAME}/checkpoints/iceberg/")

    .start()
```