# O que é Apache Iceberg? Guia prático para times pequenos

> Entenda o que é o Apache Iceberg, como ele transforma arquivos Parquet em tabelas, que manutenção exige e quando um time pequeno deve usar.

Source: https://www.erathos.com/blog/o-que-e-apache-iceberg
Published: 2026-11-13
Category: Engenharia de Dados

![O que é Apache Iceberg](https://cms-media.erathos.com/O que é Apache Iceberg.png)

Hoje, os times de dados costumam carregar dados no BigQuery ou gravar arquivos Parquet no S3, e isso funciona. Mas aí você começa a ouvir os termos "lakehouse" e "Iceberg" em toda palestra, página de fornecedor e vaga de emprego. E fica na dúvida se está ficando para trás.

O Apache Iceberg é um formato de tabela aberto. Ele consiste em pequenos arquivos de metadados que ficam ao lado dos seus arquivos Parquet e transformam uma pasta de arquivos em uma tabela. Spark, Trino, Snowflake, BigQuery, DuckDB e outros engines conseguem ler e gravar em tabelas Iceberg com segurança. Ele é gratuito, é um padrão e não é um banco de dados que você precisa instalar. Se o seu time é pequeno, precisar ou não do Iceberg depende de alguns fatores. Na maioria das vezes, a resposta é "ainda não".

## Por que uma pasta de arquivos Parquet não é uma tabela

É aqui que o Parquet se destaca. Ele armazena os dados por coluna, o que é ideal para queries analíticas que só precisam de algumas colunas. O [guia de OLAP vs OLTP](https://www.erathos.com/en/blog/olap-vs-oltp-analytics-vs-transaction-databases) explica muito bem por que o armazenamento colunar é mais rápido para queries analíticas. O Parquet também é barato de armazenar no S3. Mas cada arquivo Parquet continua sendo só um arquivo. Quando você joga vários deles em uma pasta e a chama de `orders`, essa "tabela" só existe na sua cabeça. Nada no seu bucket sabe disso.

Isso gera alguns problemas:

- **Leitores podem ler dados parciais**. Um engine de query lê os arquivos que encontrar ao listar o diretório. Se alguém ainda estiver gravando, ou se a gravação tiver falhado no meio, a query vai ler uma mistura de arquivos antigos e novos.
- **Escritores podem entrar em conflito**. Não há nenhum lock que impeça vários escritores de gravar no mesmo diretório ao mesmo tempo, ou de apagar arquivos que outro processo está lendo.
- **Mudanças de schema podem ser arriscadas**. Se você renomeia uma coluna, o nome não muda nos arquivos antigos. Cabe a cada engine de query decidir como mapear o nome antigo para o novo.
- **Deletes exigem reescrever arquivos**. Arquivos Parquet não podem ser atualizados no lugar. Se você precisa apagar os dados de um cliente, tem que encontrar todos os arquivos que contêm as linhas dele, reescrevê-los e depois substituir os antigos sem atrapalhar as queries em andamento.
- **As partições são fixas**. Se você tem uma estrutura de diretórios como `order_date=2026-10-01/`, [mudar para particionamento por hora exigiria criar uma nova tabela](https://iceberg.apache.org/docs/latest/evolution/) e regravar todos os dados. E, para aproveitar esse particionamento, as queries precisam filtrar explicitamente pela coluna de partição; caso contrário, vão ler todos os dados.

Sem uma camada de tabela, um bucket de arquivos é [só um bucket de arquivos](https://www.erathos.com/en/blog/data-lake-vs-data-warehouse). O Iceberg é essa camada.

## O que é o Apache Iceberg?

O Apache Iceberg é um formato de tabela aberto, ou seja, uma [especificação para gerenciar uma coleção grande e que muda devagar de arquivos como uma tabela](https://iceberg.apache.org/spec/). Seus arquivos de dados continuam sendo arquivos Parquet no seu próprio bucket, mas o Iceberg adiciona algumas camadas de arquivos de metadados por cima, que listam os arquivos de dados que pertencem à tabela naquele momento.

O Iceberg tem quatro camadas, lidas de cima para baixo:

1. Catálogo. Um pequeno serviço que guarda a localização do arquivo de metadados atual de cada tabela. Por exemplo, o AWS Glue, um catálogo REST do Iceberg ou o catálogo nativo do Snowflake ou do Databricks.
2. Arquivo de metadados. Um arquivo JSON com o schema da tabela, o esquema de particionamento, as configurações e uma lista de snapshots. Um snapshot é o estado da tabela em um determinado momento.
3. Manifest list e manifests. Cada snapshot aponta para uma manifest list. A manifest list aponta para manifests. Um manifest tem uma linha por arquivo de dados, com os valores de partição daquele arquivo e estatísticas sobre ele, como contagem de linhas e valores mínimo e máximo. Os engines usam essas estatísticas para pular arquivos que não importam para uma query.
4. Arquivos de dados. Arquivos [Parquet, Avro ou ORC](https://iceberg.apache.org/spec/) comuns, os mesmos que você já tem hoje.

O conceito principal é que o Iceberg [rastreia arquivos individuais em vez de pastas](https://iceberg.apache.org/spec/). Assim, um escritor pode adicionar novos arquivos Parquet ao bucket, mas eles ficam invisíveis até o escritor fazer o commit.

Este é o caminho que um engine percorre para ler uma tabela:

![How on Apache Iceberg table is organized](https://cms-media.erathos.com/How on Apache Iceberg table is organized)

Ao fazer um commit, o escritor cria novos arquivos de dados, manifests e arquivos de metadados. Depois, pede ao catálogo que troque, de forma atômica, o ponteiro "atual" do arquivo de metadados antigo para o novo. Isso pode falhar se outro escritor já tiver feito um commit; nesse caso, o escritor tenta de novo em cima da versão mais nova. Os leitores nunca usam lock. Eles acessam o arquivo de metadados que era o atual no momento da query, então sempre veem um snapshot completo dos dados. Este é o fluxo de um commit:

![How an Iceberg commit works](https://cms-media.erathos.com/How an Iceberg commit works)

Criamos uma pequena tabela `orders` com Spark e fizemos nove mudanças nela: criação, insert, duas mudanças de coluna, uma mudança de partição, outro insert, um update, um delete e um merge. Este é o conteúdo da pasta da tabela depois disso (resumido):

`data/order_ts_day=2026-10-01/00000-1-898fedd7-...-00001.parquet`
`data/order_ts_hour=2026-10-02-14/00000-7-881a285b-...-00001.parquet`
`...`
`metadata/9ddfbacd-26b4-4ed5-9091-8572bf1d7f8e-m0.avro`
`metadata/snap-3903044455079110341-1-9ddfbacd-....avro`
`...`
`metadata/v1.metadata.json`
`...`
`metadata/v9.metadata.json`
`metadata/version-hint.text`

Também vemos que a tabela tem cinco linhas. Por fim, a pasta tem 30 arquivos. 8 deles são arquivos Parquet. Há 9 arquivos de metadados (um para cada mudança), 5 manifest lists (os arquivos `snap-*.avro`, um para cada mudança nos dados) e 8 manifests.

O Iceberg nunca atualiza arquivos, só cria novos. Ele mantém as versões antigas dos arquivos para que possamos usá-las em time travel. Em algum momento, precisamos limpá-las. É por isso que existe a seção sobre manutenção mais abaixo.

No nosso teste local, usamos o catálogo mais simples, que atualiza o ponteiro por meio de um arquivo `version-hint.text`. Isso funciona bem em um laptop, mas, segundo a especificação, o esquema de commit baseado em arquivo [não é seguro em object stores](https://iceberg.apache.org/spec/). No S3, precisamos usar um catálogo de verdade, como o AWS Glue ou um catálogo REST.

## O que o Iceberg acrescenta, com um exemplo curto de cada recurso

Todos os exemplos abaixo foram executados no Spark com Iceberg, na mesma tabela `orders`. Qualquer engine com suporte de escrita no Iceberg poderia fazer o mesmo, com a sua própria sintaxe SQL.

**Particionamento oculto.** Você diz ao Iceberg como dividir os dados uma única vez, ao criar a tabela. Aqui, ele agrupa as linhas pelo dia de `order_ts`:

`CREATE TABLE demo.shop.orders (`
`    order_id bigint,`
`    customer string,`
`    amount decimal(10,2),`
`    order_ts timestamp`
`)`
`USING iceberg`
`PARTITIONED BY (days(order_ts));`

Depois, as queries filtram pela coluna real, e o Iceberg pula os dias que não batem. Ninguém precisa saber de uma coluna de partição `order_date` separada:

`SELECT * FROM demo.shop.orders`
`WHERE order_ts >= '2026-10-01' AND order_ts < '2026-10-02';`

**Evolução de schema.** Adicionar, remover, renomear, ampliar ou reordenar colunas são [mudanças de metadados, então nenhum arquivo de dados é reescrito](https://iceberg.apache.org/docs/latest/evolution/). O Iceberg dá um ID a cada coluna, então uma coluna renomeada continua correspondendo aos seus dados antigos:

`ALTER TABLE demo.shop.orders` `ADD COLUMN` country string;
`ALTER TABLE demo.shop.orders RENAME COLUMN customer TO customer_name;`

As linhas antigas mostram `NULL` na nova coluna `country`, e a coluna renomeada mantém os seus valores:

`+--------+-------------+------+-------------------+-------+`
`|order_id|customer_name|amount|order_ts           |country|`
`+--------+-------------+------+-------------------+-------+`
`|1       |Ada          |25.00 |2026-10-01 09:00:00|NULL   |`
`|2       |Ben          |40.00 |2026-10-01 10:00:00|NULL   |`
`+--------+-------------+------+-------------------+-------+`

**Evolução de partição.** Quando partições diárias ficam grandes demais, você as muda no lugar:

`ALTER TABLE demo.shop.orders`
`REPLACE PARTITION FIELD days(order_ts) WITH hours(order_ts);`

Os arquivos antigos mantêm o layout diário, e os novos usam o layout por hora. A tabela de metadados de arquivos mostra os dois layouts (spec 0 e spec 1) convivendo na mesma tabela depois de mais um insert:

`+-------+------------------+------------+`
`|spec_id|partition         |record_count|`
`+-------+------------------+------------+`
`|0      |{2026-10-01, NULL}|2           |`
`|0      |{2026-10-02, NULL}|2           |`
`|1      |{NULL, 497486}    |1           |`
`+-------+------------------+------------+`

**Updates, deletes e merges por linha.** O Iceberg suporta `UPDATE`, `DELETE` e `MERGE INTO`. Quando um delete atinge só algumas linhas, o Iceberg [reescreve apenas os arquivos de dados afetados](https://iceberg.apache.org/docs/latest/spark-writes/). A versão 2 do formato também adicionou delete files, que marcam linhas como deletadas sem reescrever o arquivo de dados. Um merge é a forma mais comum de aplicar um lote de mudanças:

`MERGE INTO demo.shop.orders AS orders`
`USING (`
`    SELECT * FROM VALUES`
`    (2, 'Ben', 45.00, TIMESTAMP '2026-10-01 10:00:00', 'US'),`
`    (6, 'Finn', 120.00, TIMESTAMP '2026-10-02 15:00:00', 'FR')`
`    AS source(order_id, customer_name, amount, order_ts, country)`
`) AS incoming`
`ON orders.order_id = incoming.order_id`
`WHEN MATCHED THEN UPDATE SET`
`    amount = incoming.amount, country = incoming.country`
`WHEN NOT MATCHED THEN INSERT *;`

**Transações ACID**: ACID significa atômico, consistente, isolado e durável. Em outras palavras, uma mudança acontece por inteiro ou não acontece, e os leitores nunca veem as coisas pela metade. No merge acima, a linha do Ben foi atualizada e a do Finn foi inserida, tudo em um único commit. Qualquer query que comece durante o merge vê a tabela como estava antes dele, e qualquer query que comece depois vê as duas mudanças. Se dois jobs fizerem commit ao mesmo tempo a partir da mesma versão, [só um commit dá certo](https://iceberg.apache.org/spec/), e o outro precisa tentar de novo.

**Time travel e rollback.** Cada mudança nos dados cria um snapshot, e você pode listá-los:

`SELECT snapshot_id, committed_at, operation`
`FROM demo.shop.orders.snapshots;`

`+-------------------+-----------------------+---------+`
`|snapshot_id        |committed_at           |operation|`
`+-------------------+-----------------------+---------+`
`|8712082876802806949|2026-10-23 01:48:50.471|append   |`
`|4468552588377488096|2026-10-23 01:48:52.206|append   |`
`|40938677677449855  |2026-10-23 01:48:53.061|overwrite|`
`|3903044455079110341|2026-10-23 01:48:53.712|overwrite|`
`|5403034263911535346|2026-10-23 01:48:54.631|overwrite|`
`+-------------------+-----------------------+---------+`

Você pode [consultar qualquer snapshot pelo ID ou pelo horário](https://iceberg.apache.org/docs/latest/spark-queries/) com `VERSION AS OF` ou `TIMESTAMP AS OF`:

`SELECT * FROM demo.shop.orders VERSION AS OF 8712082876802806949;`

Repare que a query retornou os quatro primeiros pedidos com os valores originais. Também aparece o nome antigo da coluna, `customer`, e não existe a coluna `country`. Isso acontece porque o time travel traz o schema como era no momento do snapshot. Isso pode causar problemas em queries de dashboard escritas para as colunas atuais da tabela, que podem falhar ao olhar um snapshot mais antigo.

Se um job ruim rodou, você pode voltar a tabela para um snapshot anterior. Esta chamada desfez o delete e o merge de uma vez:

`CALL demo.system.rollback_to_snapshot('shop.orders', 40938677677449855);`

## A manutenção que vem com o Iceberg

Claro que o time travel tem um custo. [Cada gravação, update, delete, merge e compactação cria um novo snapshot](https://iceberg.apache.org/docs/latest/spark-procedures/) e mantém os arquivos de dados e de metadados antigos. Além disso, muitas cargas pequenas podem gerar muitos arquivos pequenos. [Arquivos pequenos geram mais metadados e deixam as queries mais lentas](https://iceberg.apache.org/docs/latest/spark-procedures/), porque o engine precisa abrir cada um deles.

Por isso, uma tabela Iceberg precisa de três jobs de limpeza:

Job

O que faz

Padrão importante

Compactação (`rewrite_data_files`)

Junta arquivos de dados pequenos em arquivos maiores

Mira arquivos de 512 MB e só age em grupos de pelo menos 5 arquivos

Expiração de snapshots (`expire_snapshots`)

Apaga snapshots antigos e os arquivos usados só por eles

Expira snapshots com mais de 5 dias, mantém pelo menos 1

Limpeza de arquivos órfãos (`remove_orphan_files`)

Apaga arquivos para os quais nenhum metadado aponta, como sobras de jobs que falharam

Só mexe em arquivos com mais de 3 dias, tem modo dry run

Estas são as chamadas que rodamos na tabela de demonstração:

`CALL demo.system.rewrite_data_files(table => 'shop.orders');`

`CALL demo.system.expire_snapshots(`
`    table => 'shop.orders',`
`    older_than => TIMESTAMP '2026-10-23 01:48:55',`
`    retain_last => 1`
`);`

`CALL demo.system.remove_orphan_files(table => 'shop.orders', dry_run => true);`

A expiração dos snapshots apagou 4 arquivos de dados, 5 manifests e 4 manifest lists. A compactação não reescreveu nenhum arquivo, por causa do pequeno número de linhas (cinco). Depois da expiração, deixa de ser possível fazer time travel para esses snapshots.

Em um time pequeno, alguém precisa ser responsável por rodar esses jobs. Isso pode ser feito de duas formas.

- **Você mesmo roda os jobs.** Dá para agendar a execução dos procedures no Spark (ou em qualquer outro engine que tenha o mesmo recurso) de forma periódica. É pouquíssimo código a mais, mas é mais um job para monitorar.
- **Você usa um serviço gerenciado de tabelas.** O Amazon S3 Tables permite rodar a compactação como parte do serviço. Você paga [US$ 0,002 por 1.000 objetos e US$ 0,005 por GB de dados processados](https://aws.amazon.com/s3/pricing/). Então, para compactar 30.000 arquivos de 5 MB cada, você pagaria cerca de US$ 0,06 pelos objetos e US$ 0,73 pelos dados. As tabelas Iceberg gerenciadas do BigQuery também oferecem [dimensionamento automático de arquivos, clustering e garbage collection](https://docs.cloud.google.com/bigquery/docs/biglake-iceberg-tables-in-bigquery).

## Quais engines suportam o Apache Iceberg?

Spark, Trino, Flink, Snowflake, BigQuery, Databricks, Amazon Athena e DuckDB conseguem ler e gravar tabelas Iceberg. O ClickHouse consegue ler tabelas Iceberg, com gravação disponível em beta. A maioria dos engines só grava em um único catálogo e pode restringir recursos como a evolução de partição.

Isto é o que a documentação oficial de cada engine confirmava em outubro de 2026:

Engine

Leitura

Escrita

Condições importantes

[Apache Spark](https://iceberg.apache.org/multi-engine-support/)

Sim

Sim

Conector mantido pelo projeto Iceberg. É o engine de referência para os procedures de manutenção.

[Apache Flink](https://iceberg.apache.org/docs/latest/flink/)

Sim

Sim

Conector mantido pelo projeto Iceberg. Suporta gravações em streaming com `INSERT INTO`.

[Trino](https://trino.io/docs/current/connector/iceberg.html)

Sim

Sim

O conector Iceberg lê e grava dados e metadados.

[Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg.html)

Sim

Sim

As tabelas precisam estar no catálogo do AWS Glue. Cria e grava apenas tabelas Iceberg v2.

[Snowflake](https://docs.snowflake.com/en/user-guide/tables-iceberg)

Sim

Sim

Funciona com o Snowflake como catálogo ou com um catálogo externo. Gravações externas exigem Iceberg v2 ou v3.

[BigQuery](https://docs.cloud.google.com/bigquery/docs/biglake-iceberg-tables-in-bigquery)

Sim

Sim

As tabelas Iceberg gerenciadas mantêm os dados no seu bucket do Cloud Storage. Sem evolução de partição, um `UPDATE`, `DELETE` ou `MERGE` por vez por tabela, e outros engines leem por meio de metadados exportados.

[Databricks](https://docs.databricks.com/aws/en/iceberg/)

Sim

Sim

Grava tabelas Iceberg gerenciadas no Unity Catalog. Tabelas Iceberg de outros catálogos são somente leitura.

[DuckDB](https://duckdb.org/docs/current/core_extensions/iceberg/writing_to_iceberg)

Sim

Sim

Gravações exigem um catálogo REST conectado. Deletes usam apenas delete files (merge-on-read).

[ClickHouse](https://clickhouse.com/docs/reference/functions/table-functions/iceberg)

Sim

Beta

Lê pelo table engine ou pela table function do Iceberg. Inserts são um recurso beta que você ativa com uma configuração.

O BigQuery, por exemplo, avisa explicitamente que adicionar arquivos a uma tabela Iceberg gerenciada pelo BigQuery fora do BigQuery [pode causar perda de dados](https://docs.cloud.google.com/bigquery/docs/biglake-iceberg-tables-in-bigquery). Embora o Iceberg seja um "formato aberto", isso não significa que qualquer engine pode gravar em qualquer tabela. As tabelas Iceberg pertencem ao catálogo que guarda o ponteiro para elas; qualquer engine que consiga gravar por meio desse catálogo pode gravar na tabela.

Na documentação do BigQuery, há algumas restrições adicionais para as tabelas Iceberg do BigQuery, como não permitir renomear tabelas, clones nem materialized views:

![BigQuery Documentation](https://cms-media.erathos.com/BigQuery Documentation)

## Iceberg vs Delta Lake vs Apache Hudi

O Iceberg tem dois rivais entre os formatos de tabela abertos. Os três adicionam transações, mudanças de schema e time travel em cima de arquivos Parquet. Eles diferem na origem e no que fazem melhor:

Formato

Origem

Melhor em

Indicado para

Apache Iceberg

[Netflix, hoje um projeto Apache](https://www.databricks.com/blog/open-table-formats)

Ser lido e gravado por muitos engines

Times que querem escolher ou trocar de engine livremente

Delta Lake

[Databricks, lançado como open source](https://www.databricks.com/blog/open-table-formats)

Pipelines em Spark e Databricks

Times que rodam tudo no Databricks

Apache Hudi

[Uber](https://www.dremio.com/blog/comparison-of-data-lake-table-formats-apache-iceberg-apache-hudi-and-delta-lake/), hoje um projeto Apache

[Upserts e deletes rápidos e pipelines incrementais](https://hudi.apache.org/docs/overview)

Atualizações frequentes por registro, como replicação via CDC

Essas diferenças estão começando a diminuir. O recurso UniForm do Delta Lake permite que [uma tabela Delta seja lida como uma tabela Iceberg](https://www.databricks.com/blog/open-table-formats). Além disso, o Databricks grava as próprias tabelas Iceberg gerenciadas.

O Iceberg é a escolha mais fácil para times pequenos que não usam Databricks. Ele funciona com mais engines do que os outros formatos. O Delta Lake é a melhor escolha para empresas que usam só o Databricks e não pretendem usar mais nada. O Hudi é a melhor escolha para empresas que precisam fazer muitos upserts por registro.

## Iceberg vs um data warehouse em nuvem

Um data lake guarda arquivos brutos em um object storage barato e deixa você escolher o engine de query depois. Um data warehouse armazena tabelas estruturadas e junta armazenamento, compute e gerenciamento em um único produto. (O nosso [guia de data lake vs data warehouse](https://www.erathos.com/en/blog/data-lake-vs-data-warehouse) traz a comparação completa.) O Iceberg dá a um lake os recursos de tabela pelos quais as pessoas costumavam comprar um warehouse, então a escolha real é entre tabelas Iceberg no seu bucket e tabelas nativas no BigQuery ou no Snowflake:

Tabelas Iceberg no seu bucket

Data warehouse em nuvem

Custo de armazenamento

[US$ 0,0265 por GB por mês](https://aws.amazon.com/s3/pricing/) no S3 Tables para os primeiros 50 TB

[US$ 23,55 por TiB por mês](https://cloud.google.com/bigquery/pricing) no armazenamento ativo do BigQuery, [US$ 23 por TB por mês](https://www.snowflake.com/en/pricing-options/) no Snowflake on demand

Compute

Qualquer engine da tabela de suporte, e você pode usar mais de um

O engine do próprio warehouse, cobrado pelo warehouse

Dependência do fornecedor

Baixa. Os arquivos e metadados seguem uma especificação aberta, em um armazenamento seu

Maior. Sair significa exportar os seus dados

Esforço operacional

Você escolhe um catálogo, configura os acessos e roda ou paga pela compactação e limpeza

O fornecedor cuida dos arquivos, da compactação e dos acessos

O custo de armazenamento por gigabyte é parecido, então ele raramente é o fator decisivo. A maior diferença de custo está no compute. Com o Iceberg, você pode rodar um job batch grande no Spark e depois queries menores no DuckDB ou no Athena sobre as mesmas tabelas. Em um data warehouse, você sempre roda as queries no medidor do warehouse. Por exemplo, o preço on-demand do BigQuery é de [US$ 6,25 por TiB escaneado depois do primeiro TiB gratuito de cada mês](https://cloud.google.com/bigquery/pricing).

Hoje em dia, os dois mundos estão convergindo. O Snowflake, por exemplo, consegue ler e gravar tabelas Iceberg. Quando essas tabelas ficam no seu próprio volume externo, [o Snowflake só cobra pelo compute usado para consultá-las](https://www.erathos.com/en/blog/data-lake-vs-data-warehouse). Da mesma forma, as tabelas Iceberg gerenciadas do BigQuery não têm [custo de armazenamento do BigQuery](https://docs.cloud.google.com/bigquery/docs/biglake-iceberg-tables-in-bigquery), já que os arquivos ficam no seu bucket do Cloud Storage. Isso significa que você pode continuar usando um data warehouse como principal engine de compute e, ao mesmo tempo, armazenar os dados em Iceberg.

## Um time pequeno deve usar o Iceberg?

Então, quando um time pequeno deve usar o Iceberg? Se você precisa acessar os mesmos dados em vários engines, ou se já tem arquivos no S3 que precisa conseguir atualizar, apagar ou mudar o schema, o Iceberg se encaixa muito bem. Se um único warehouse atende todas as suas queries, fique com o warehouse; o Iceberg acrescenta o catálogo e os jobs de limpeza, que só fazem sentido se você precisa dos benefícios dele.

Aqui está a decisão em forma de fluxograma:

![Do you need Iceberg?](https://cms-media.erathos.com/Do you need Iceberg)

O Iceberg se encaixa bem quando você tem uma ou mais destas necessidades:

- **Dois ou mais engines usam as mesmas tabelas.** Você tem cientistas de dados treinando modelos em Spark ou Python e analistas consultando os mesmos dados no Athena, Trino ou Snowflake. Sem o Iceberg, você fica tentando manter duas cópias dos dados sincronizadas.
- **Os seus arquivos no S3 precisam se comportar como tabelas de verdade.** Você precisa apagar linhas de um cliente por um pedido de privacidade, corrigir uma carga ruim ou adicionar uma coluna a uma tabela sem quebrar os arquivos antigos.
- **Você quer ser dono do seu armazenamento.** Você prevê trocar de engine de query ou não quer o seu histórico preso a um único fornecedor.
- **Alguém pode cuidar da manutenção, ou você pode pagar por ela.** Isso significa ter alguém no time para operar o catálogo e os jobs de limpeza, ou usar um serviço gerenciado como o S3 Tables ou as tabelas Iceberg gerenciadas do BigQuery.

Um warehouse gerenciado como o BigQuery é mais atraente quando:

- **Um único engine faz todo o trabalho.** Todos os usuários olham dashboards de BI ou rodam modelos SQL. Os dados são tabelas estruturadas vindas dos seus apps e ferramentas SaaS.
- **Ninguém tem tempo para a infraestrutura.** Ninguém no time quer configurar um catálogo, permissões na nuvem e jobs de manutenção.
- **A conta está ok.** O custo de armazenamento é parecido nos dois cenários, então você não vai migrar para o Iceberg para economizar em armazenamento.

Ou você pode usar o BigQuery ou o Snowflake como principal engine de query, mas armazenar as tabelas como Iceberg no seu próprio bucket. Assim, você tem a experiência completa do warehouse e ganha a opção de adicionar outro engine depois. Essa opção tem as mesmas limitações mostradas na tabela de engines acima.

## Como os dados chegam às tabelas Iceberg

Uma tabela Iceberg só é útil quando tem dados. Há três formas comuns de colocar dados em uma tabela Iceberg:

1. **Cargas batch.** Um job que roda de forma agendada, lê dados de uma fonte e adiciona linhas novas ou faz merge das mudanças. Os exemplos de `INSERT` e `MERGE INTO` acima seriam uma carga batch. Esse tipo de job pode rodar no Spark, Trino, Athena, Snowflake e DuckDB.
2. **CDC (change data capture) a partir de bancos de dados.** Uma ferramenta que lê o log de mudanças de um banco como PostgreSQL ou MySQL e aplica cada insert, update e delete na tabela Iceberg, normalmente como um `MERGE`. As mudanças por linha do Iceberg tornam isso possível. Veja o nosso guia sobre [sync baseada em cursor vs CDC](https://www.erathos.com/en/blog/cursor-based-sync-vs-change-data-capture) para saber mais sobre as diferentes formas de ler dados de mudança.
3. **Streaming.** O Flink consegue [fazer streaming para uma tabela Iceberg](https://iceberg.apache.org/docs/latest/flink/) com `INSERT INTO`. O Flink faz commits pequenos e frequentes, o que gera muitos arquivos pequenos e snapshots. Por isso, tabelas em streaming são as que mais precisam de compactação e expiração de snapshots.

Para montar qualquer uma dessas opções por conta própria, você precisa escrever e rodar os jobs de carga e configurar o catálogo.

A Erathos agora suporta [S3 com Apache Iceberg como destino](https://www.erathos.com/en/blog/erathos-now-supports-s3-apache-iceberg-as-destination), então os pipelines da Erathos podem carregar dados em tabelas Iceberg no seu próprio bucket S3. Ela usa o catálogo do AWS Glue, então as tabelas podem ser consultadas com Athena, Trino, Spark e Databricks. Para usar, [vá em Settings -> Data Warehouse -> S3 Iceberg](https://docs.erathos.com/destinations/s3-iceberg) e adicione a sua access key da AWS, o nome do bucket, a região do bucket e o banco de dados do catálogo Glue. Esse conector está em beta.

## FAQ

**O Apache Iceberg é um banco de dados?**
Não. O Iceberg é uma [especificação de formato de tabela](https://iceberg.apache.org/spec/). Ela descreve os arquivos de metadados que, por sua vez, descrevem uma tabela formada por arquivos de dados. O Iceberg não tem servidor nem executa queries. Um engine como Spark, Athena, Snowflake ou DuckDB lê os metadados e executa a query.

**O Apache Iceberg é gratuito?**
Sim. O Iceberg é um projeto open source da Apache. Você paga pelo armazenamento dos arquivos, pelos engines que executam as queries e por qualquer serviço gerenciado que usar. Por exemplo, o S3 Tables custa [US$ 0,0265 por GB por mês](https://aws.amazon.com/s3/pricing/) para os primeiros 50 TB.

**Qual é a diferença entre Iceberg e Parquet?**
O Parquet é um formato de arquivo que armazena dados por coluna em um único arquivo. O Iceberg é um formato de tabela que rastreia quais arquivos Parquet pertencem a uma tabela, além do schema, das partições e do histórico dela. O Iceberg também pode rastrear arquivos Avro e ORC.

**Preciso do Spark para usar o Iceberg?**
Não. Athena, Trino, Snowflake, BigQuery e DuckDB conseguem ler e gravar tabelas Iceberg. Os procedures de limpeza mencionados na documentação do Iceberg podem ser executados no Spark, então vale tê-lo por perto, a menos que você use um serviço gerenciado que cuide da limpeza.

**O que é um catálogo Iceberg?**
Um catálogo guarda o ponteiro para o arquivo de metadados atual de cada tabela e o troca quando uma gravação é confirmada. AWS Glue, Snowflake, Databricks Unity Catalog e qualquer serviço que implemente a API de catálogo REST do Iceberg podem ser catálogos. Os engines que você usa podem limitar quais catálogos dá para usar. Por exemplo, o Athena precisa do Glue como catálogo. O DuckDB [precisa de um catálogo REST para gravar](https://duckdb.org/docs/current/core_extensions/iceberg/writing_to_iceberg).

**O que é o Amazon S3 Tables?**
O S3 Tables é um serviço de armazenamento da AWS feito para o Iceberg. Ele organiza as tabelas em table buckets e pode fazer a compactação. A compactação custa [US$ 0,002 por 1.000 objetos e US$ 0,005 por GB processado](https://aws.amazon.com/s3/pricing/).

**O Iceberg substitui um data warehouse?**
Ele substitui a parte de armazenamento, mas você ainda precisa de um engine para rodar as queries, que pode ser um data warehouse. O Snowflake e o BigQuery suportam consultar tabelas Iceberg, então dá para usar o Iceberg com um data warehouse sem problema.

Se você decidir que o Iceberg é a escolha certa, a Erathos pode carregar dados em tabelas Iceberg no S3. [Teste a Erathos grátis por 14 dias](https://app.erathos.com/signup).
