Migrar dados de captura de dados alterados (CDC) do Delta Lake para um Lakehouse sem fronteiras usando o Dataflow

Manter as tabelas de destino do Lakehouse Apache Iceberg sincronizadas com as tabelas de origem do Delta Lake atualizadas com frequência pode ser difícil. A realização de recargas completas da tabela para capturar mudanças no conjunto de dados aumenta os custos de computação e a latência de processamento, e a criação de pipelines personalizados para processar registros de transações introduz uma sobrecarga operacional complexa.

Ao usar pipelines de captura de dados alterados (CDC) em lote programados do Dataflow, é possível sincronizar continuamente as tabelas de origem do Delta Lake com as tabelas do Lakehouse Apache Iceberg. Em vez de recarregar tabelas completas, os jobs em lote programados extraem atualizações incrementais diretamente dos registros de transações do Delta Lake e as aplicam às tabelas de destino em uma programação configurável.

O pipeline de CDC em lote programado oferece os seguintes recursos:

  • Sincronização incremental econômica: processa periodicamente apenas os dados alterados (operações INSERT, UPDATE e DELETE), reduzindo a sobrecarga de computação e a latência de dados.
  • Mapeamento automático de mudanças: analisa os registros do feed de dados de mudanças do Delta Lake e mapeia as operações de mudança para a tabela de destino do Lakehouse Iceberg
  • Programação flexível de jobs: executa jobs do Dataflow no modo em lote em uma programação (por exemplo, intervalos de 15 minutos) que atenda às suas necessidades de negócios.

Fluxo de trabalho de migração contínua

Para configurar a migração contínua de ponta a ponta do Delta Lake para o Lakehouse, conclua a seguinte sequência de operações:

  1. Ative a propriedade delta.enableChangeDataFeed (true) na tabela de entrada do Delta Lake.
  2. Realize uma migração inicial da tabela para um ID de confirmação ou carimbo de data/hora depois de ativar a propriedade delta.enableChangeDataFeed. Para instruções, consulte Importar tabelas do Delta Lake para o Lakehouse usando o Dataflow.
  3. Execute jobs de CDC em lote programados para atualizações de dados subsequentes com uma frequência (ID de confirmação ou intervalo de carimbo de data/hora) escolhida para os requisitos da carga de trabalho.

Antes de começar

Para configurar a migração de CDC em lote programada, verifique se você tem o seguinte:

  1. Ative as APIs Dataflow, BigQuery e Lakehouse, se alguma delas ainda não estiver ativada.

    Funções necessárias para ativar APIs

    Para ativar as APIs, é necessário ter a permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pela função Proprietário (roles/owner). Caso contrário, você pode receber essa permissão pela função Administrador de uso do serviço (roles/serviceusage.serviceUsageAdmin). Saiba como conceder funções.

    Ativar as APIs

  2. Para receber as permissões necessárias para criar os recursos, peça ao administrador para conceder a você as funções necessárias do Identity and Access Management (IAM) no seu projeto.

  3. Uma tabela válida do Delta Lake armazenada em um bucket do Cloud Storage. O diretório da tabela precisa conter seus arquivos de dados e o diretório de registro de transações _delta_log/. Além disso, a tabela precisa atender aos seguintes requisitos:

    • A propriedade delta.enableChangeDataFeed precisa estar ativada (true) na tabela do Delta Lake.
    • O ID de confirmação ou carimbo de data/hora de início configurado para o pipeline de CDC precisa ser posterior à ativação da propriedade delta.enableChangeDataFeed.
  4. Um catálogo do Lakehouse Iceberg para receber os dados sincronizados. Se o namespace de destino não existir, o pipeline de CDC o criará automaticamente. Se a tabela de destino do Lakehouse não existir, o pipeline de CDC a criará automaticamente se você fornecer uma lista válida de colunas de igualdade.

Suporte e limitações

A migração de CDC em lote programada do Delta Lake para o Lakehouse tem as seguintes considerações:

  • Requisito do SDK:requer o SDK do Apache Beam versão 2.77.0 ou mais recente.
  • Criação da tabela de destino:a criação da tabela de destino do Lakehouse tem suporte. Se a tabela de destino não existir, o pipeline de CDC a criará automaticamente se você fornecer uma lista válida de colunas de igualdade (equality_columns). Somente um catálogo do Lakehouse é necessário. O pipeline de CDC cria automaticamente o namespace se ele não existir.
  • Evolução do esquema:as mudanças automáticas de esquema não têm suporte. Se o esquema da tabela de origem do Delta Lake mudar, atualize manualmente o esquema da tabela de destino do Lakehouse para que ele corresponda antes de executar o job de sincronização de CDC.
  • Modo de execução em lote:o CDC do Delta Lake opera no modo em lote. O pipeline extrai registros de transações uma vez por execução de job entre os limites de confirmação de início e fim especificados (ID de confirmação ou carimbo de data/hora). Se um limite de confirmação final (end_version ou end_timestamp) não for especificado, o pipeline vai ler até a versão de confirmação mais recente.
  • Armazenamento de origem com suporte:os dados de origem precisam ser uma tabela válida do Delta Lake armazenada no Cloud Storage (gs://). O Amazon S3 não tem suporte para fontes de tabela do Delta Lake.
  • Tabelas baseadas em catálogo:as tabelas do Delta Lake baseadas em catálogo (por exemplo, o Unity Catalog) não têm suporte.
  • Versões do Delta Lake sem suporte:a versão 1.2.1 ou anterior do Delta Lake não tem suporte porque o feed de dados de mudanças (CDF) não é compatível com essas versões.
  • Feed de dados de mudanças automático:o feed de dados de mudanças automático não tem suporte porque não grava arquivos de registro de alterações do CDF.

Criar um pipeline de CDC de maneira programática

Para criar e executar um pipeline de migração em lote de CDC do Delta Lake de maneira programática, use a transformação Managed.read no pipeline do Apache Beam.

Java

Adicione as seguintes dependências ao arquivo pom.xml:

<dependency>
  <groupId>org.apache.beam</groupId>
  <artifactId>beam-sdks-java-managed</artifactId>
  <version>${beam.version}</version>
</dependency>
<dependency>
  <groupId>org.apache.beam</groupId>
  <artifactId>beam-sdks-java-io-iceberg</artifactId>
  <version>${beam.version}</version>
</dependency>

<dependency>
  <groupId>org.apache.beam</groupId>
  <artifactId>beam-sdks-java-io-delta</artifactId>
  <version>${beam.version}</version>
</dependency>

O snippet de Java a seguir demonstra como configurar e executar um pipeline de CDC em lote do Delta Lake para o Lakehouse. Para um exemplo completo do Beam, consulte DeltaLakeCdcToLakehouse.java.

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.apache.beam.sdk.Pipeline;
import org.apache.beam.sdk.managed.Managed;
import org.apache.beam.sdk.options.PipelineOptionsFactory;
import org.apache.beam.sdk.values.PCollection;
import org.apache.beam.sdk.values.Row;

public class DeltaLakeCdcToLakehouse {
  public static void main(String[] args) {
    Pipeline pipeline = Pipeline.create(PipelineOptionsFactory.fromArgs(args).create());

    // 1. Configure Delta Lake CDC reader
    Map<String, Object> readConfig = new HashMap<>();
    readConfig.put("table", "gs://BUCKET_NAME/TABLE_NAME");
    // Starting commit bound (either start_version or start_timestamp must be provided):
    readConfig.put("start_version", START_COMMIT_ID);
    // Optional ending commit bound (end_version or end_timestamp, matching the start bound type):
    // readConfig.put("end_version", END_COMMIT_ID);
    readConfig.put("include_metadata_columns", Arrays.asList("_commit_version", "_change_type"));

    // Read CDC events from Delta Lake
    PCollection<Row> cdcRows =
        pipeline.apply(
            "ReadFromDeltaCDC",
            Managed.read(Managed.DELTA_LAKE_CDC).withConfig(readConfig)).getSinglePCollection();

    // 2. Configure BigLake REST Catalog properties for Lakehouse Iceberg
    Map<String, String> catalogProps = new HashMap<>();
    catalogProps.put("type", "rest");
    catalogProps.put("uri", "https://biglake.googleapis.com/iceberg/v1/restcatalog");
    catalogProps.put("warehouse", "gs://WAREHOUSE_BUCKET");
    catalogProps.put("header.x-goog-user-project", "PROJECT_ID");
    catalogProps.put("io-impl", "org.apache.iceberg.gcp.gcs.GCSFileIO");
    catalogProps.put("rest.auth.type", "org.apache.iceberg.gcp.auth.GoogleAuthManager");

    // 3. Map Delta Lake change types to Iceberg CDC change types
    Map<String, String> changeTypeMap = new HashMap<>();
    changeTypeMap.put("insert", "INSERT");
    changeTypeMap.put("delete", "DELETE");
    changeTypeMap.put("update_preimage", "UPDATE_BEFORE");
    changeTypeMap.put("update_postimage", "UPDATE_AFTER");

    // 4. Configure Lakehouse Iceberg CDC writer
    Map<String, Object> writeConfig = new HashMap<>();
    writeConfig.put("table", "TARGET_NAMESPACE.TARGET_TABLE");
    writeConfig.put("catalog_name", "lakehouse");
    writeConfig.put("catalog_properties", catalogProps);
    writeConfig.put("mode", "merge-on-read");
    writeConfig.put("sequence_number_column", "_commit_version");
    writeConfig.put("equality_columns", Arrays.asList("PRIMARY_KEY_COLUMN"));
    // change_type_column and change_type_map are only required for Portable Runner
    writeConfig.put("change_type_column", "_change_type");
    writeConfig.put("change_type_map", changeTypeMap);

    // Write CDC rows to target Lakehouse Iceberg table
    cdcRows.apply(
        "WriteToLakehouse",
        Managed.write(Managed.ICEBERG).withConfig(writeConfig));

    pipeline.run();
  }
}

Substitua:

  • BUCKET_NAME: o nome do bucket do Cloud Storage que contém a tabela do Delta Lake.
  • TABLE_NAME: o nome do diretório da tabela de origem do Delta Lake.
  • START_COMMIT_ID: número da versão de confirmação inicial para leitura de eventos de CDC do Delta Lake. É necessário fornecer start_version ou start_timestamp. O ID de confirmação ou carimbo de data/hora de início precisa ser posterior à ativação da propriedade delta.enableChangeDataFeed na tabela de origem.
  • END_COMMIT_ID: número da versão de confirmação final para leitura de eventos de CDC do Delta Lake. Como prática recomendada, especifique um limite final (end_version ou end_timestamp) que corresponda ao tipo de limite usado para o início (start_version ou start_timestamp). Se um limite final for omitido, o pipeline vai ler até a versão de confirmação mais recente.
  • WAREHOUSE_BUCKET: o nome do bucket do Cloud Storage usado como o data warehouse do catálogo do Lakehouse.
  • PROJECT_ID: o ID do Google Cloud projeto.
  • TARGET_NAMESPACE: o namespace da tabela de destino do Lakehouse.
  • TARGET_TABLE: o nome da tabela de destino do Lakehouse.
  • PRIMARY_KEY_COLUMN: o nome da coluna de chave primária usada para identificar linhas para atualizações e exclusões de CDC.
  • Adicione outras dependências necessárias para o Delta Lake e o Iceberg com base no exemplo do Beam.

Examinar a saída do job

Verifique se os dados de CDC foram mesclados com sucesso na tabela do Lakehouse:

  1. No Google Cloud console do, acesse a página Studio do BigQuery.

    Acessar o BigQuery

  2. No editor de consultas, execute uma consulta SQL para verificar os dados sincronizados:

    SELECT * FROM `PROJECT_ID`.`CATALOG`.`NAMESPACE`.`TABLE_NAME` LIMIT 10;
    

    Substitua:

    • PROJECT_ID: o ID do Google Cloud projeto.
    • CATALOG: o nome do catálogo do Lakehouse.
    • NAMESPACE: o namespace da tabela do Lakehouse.
    • TABLE_NAME: o nome da tabela de destino do Lakehouse.
  3. Clique em Executar e verifique os resultados.

A seguir