Processando Dados na Nuvem Com DuckDB e AWS S3

Tutoriais

AWS

DuckDb é um poderoso banco de dados em memória que possui um recurso de processamento paralelo, o que o torna uma boa escolha para ler/transformar dados armazenados na nuvem, neste caso, AWS S3. Eu tive muito sucesso usando-o e vou guiá-lo pelos passos para implementá-lo.

Também incluirei alguns aprendizados e melhores práticas para você. Usando a extensão DuckDb, httpfs e pyarrow, podemos processar arquivos Parquet armazenados em buckets S3 de forma eficiente. Vamos mergulhar:

Antes de começar a instalação do DuckDb, certifique-se de ter os seguintes pré-requisitos:

Python 3.9 ou superior instalado
Conhecimento prévio sobre configuração de projetos em Python e ambientes virtuais ou ambientes conda

Instalando Dependências

Primeiro, vamos estabelecer o ambiente necessário:

Shell

# Install required packages for cloud integration

pip install "duckdb>=0.8.0" pyarrow pandas boto3 requests

As dependências explicadas:

duckdb>=0.8.0: O motor de banco de dados principal que fornece funcionalidade SQL e processamento em memória
pyarrow: Manipula operações em arquivos Parquet de forma eficiente com suporte a armazenamento em colunas
pandas: Habilita poderosas capacidades de manipulação e análise de dados
boto3: SDK da AWS para Python, fornecendo interfaces para os serviços da AWS
requests: Gerencia comunicações HTTP para interações na nuvem

Configurando Acesso Seguro à Nuvem

Python

import duckdb

import os

​

# Initialize DuckDB with cloud support

conn = duckdb.connect(':memory:')

conn.execute("INSTALL httpfs;")

conn.execute("LOAD httpfs;")

​

# Secure AWS configuration

conn.execute("""

    SET s3_region='your-region';

    SET s3_access_key_id='your-access-key';

    SET s3_secret_access_key='your-secret-key';

""")

Esse código de inicialização faz várias coisas importantes:

Criamos uma nova conexão DuckDB na memória usando :memory:
Instala e carrega a extensão de sistema de arquivos HTTP (httpfs), que permite o acesso ao armazenamento em nuvem
Configura as credenciais da AWS com sua região específica e chaves de acesso
Estabelece uma conexão segura com os serviços da AWS

Processando Arquivos Parquet S3 da AWS

Vamos examinar um exemplo abrangente de processamento de arquivos Parquet com mascaramento de dados sensíveis:

Python

import duckdb

import pandas as pd

​

# Create sample data to demonstrate parquet processing

sample_data = pd.DataFrame({

    'name': ['John Smith', 'Jane Doe', 'Bob Wilson', 'Alice Brown'],

    'email': ['[email protected]', '[email protected]', '[email protected]', '[email protected]'],

    'phone': ['123-456-7890', '234-567-8901', '345-678-9012', '456-789-0123'],

    'ssn': ['123-45-6789', '234-56-7890', '345-67-8901', '456-78-9012'],

    'address': ['123 Main St', '456 Oak Ave', '789 Pine Rd', '321 Elm Dr'],

    'salary': [75000, 85000, 65000, 95000]  # Non-sensitive data

})

Essa criação de dados de exemplo nos ajuda a demonstrar técnicas de mascaramento de dados. Incluímos vários tipos de informações sensíveis comumente encontradas em conjuntos de dados do mundo real:

Identificadores pessoais (nome, CPF)
Informações de contato (e-mail, telefone, endereço)
Dados financeiros (salário)

Agora, vamos olhar a função de processamento:

Python

def demonstrate_parquet_processing():

    # Create a DuckDB connection

    conn = duckdb.connect(':memory:')

    # Save sample data as parquet

    sample_data.to_parquet('sample_data.parquet')

    # Define sensitive columns to mask

    sensitive_cols = ['email', 'phone', 'ssn']

    # Process the parquet file with masking

    query = f"""

    CREATE TABLE masked_data AS

    SELECT 

        -- Mask name: keep first letter of first and last name

        regexp_replace(name, '([A-Z])[a-z]+ ([A-Z])[a-z]+', '\1*** \2***') as name,

        -- Mask email: hide everything before @

        regexp_replace(email, '([a-zA-Z0-9._%+-]+)(@.*)', '****\2') as email,

        -- Mask phone: show only last 4 digits

        regexp_replace(phone, '[0-9]{3}-[0-9]{3}-', '***-***-') as phone,

        -- Mask SSN: show only last 4 digits

        regexp_replace(ssn, '[0-9]{3}-[0-9]{2}-', '***-**-') as ssn,

        -- Mask address: show only street type

        regexp_replace(address, '[0-9]+ [A-Za-z]+ ', '*** ') as address,

        -- Keep non-sensitive data as is

        salary

    FROM read_parquet('sample_data.parquet');

    """

Vamos detalhar essa função de processamento:

Criamos uma nova conexão DuckDB
Convertendo nosso DataFrame de exemplo em um arquivo Parquet
Definimos quais colunas contêm informações sensíveis
Crie uma consulta SQL que aplique diferentes padrões de mascaramento:
- Nomes: Preserva iniciais (ex.: “John Smith” → “J*** S***”)
- Emails: Oculta a parte local enquanto mantém o domínio (ex.: “” → “****@email.com”)
- Números de telefone: Mostra apenas os últimos quatro dígitos
- SSNs: Exibe apenas os últimos quatro dígitos
- Endereços: Mantém apenas o tipo de rua
- Salário: Permanece sem mascaramento como dado não sensível

A saída deve ser parecida com:

Plain Text

Original Data:

=============

         name                   email           phone          ssn        address  salary

0  John Smith    [email protected]   123-456-7890  123-45-6789   123 Main St   75000

1   Jane Doe    [email protected]   234-567-8901  234-56-7890   456 Oak Ave   85000

2  Bob Wilson         [email protected]     345-678-9012  345-67-8901   789 Pine Rd   65000

3 Alice Brown      [email protected]     456-789-0123  456-78-9012   321 Elm Dr    95000

Masked Data:

===========

      name                email           phone          ssn     address  salary

0  J*** S***    ****@email.com     ***-***-7890  ***-**-6789   *** St   75000

1  J*** D***  ****@company.com     ***-***-8901  ***-**-7890   *** Ave   85000

2  B*** W***      ****@email.net   ***-***-9012  ***-**-8901   *** Rd   65000

3  A*** B***      ****@org.com     ***-***-0123  ***-**-9012   *** Dr    95000

Agora, vamos explorar diferentes padrões de mascaramento com explicações nos comentários dos trechos de código Python:

Variações de Mascaramento de Email

Python

# Show first letter only

"[email protected]" → "j***@email.com"

​

# Show domain only

"[email protected]" → "****@email.com"

​

# Show first and last letter

"[email protected]" → "j*********[email protected]"

Mascaramento de Números de Telefone

Python

# Last 4 digits only

"123-456-7890" → "***-***-7890"

​

# First 3 digits only

"123-456-7890" → "123-***-****"

​

# Middle digits only

"123-456-7890" → "***-456-****"

Mascaramento de Nomes

Python

# Initials only

"John Smith" → "J.S."

​

# First letter of each word

"John Smith" → "J*** S***"

​

# Fixed length masking

"John Smith" → "XXXX XXXXX"

Processamento Eficiente de Dados Particionados

Ao lidar com grandes conjuntos de dados, a partição se torna crucial. Aqui está como lidar com dados particionados de forma eficiente:

Python

def process_partitioned_data(base_path, partition_column, sensitive_columns):

    """

    Process partitioned data efficiently

    Parameters:

    - base_path: Base path to partitioned data

    - partition_column: Column used for partitioning (e.g., 'date')

    - sensitive_columns: List of columns to mask

    """

    conn = duckdb.connect(':memory:')

    try:

        # 1. List all partitions

        query = f"""

        WITH partitions AS (

            SELECT DISTINCT {partition_column}

            FROM read_parquet('{base_path}/*/*.parquet')

        )

        SELECT * FROM partitions;

        """

Esta função demonstra vários conceitos importantes:

Descoberta dinâmica de partições
Processamento eficiente em termos de memória
Tratamento de erros com limpeza adequada
Geração de saída de dados mascarados

A estrutura de partição geralmente se parece com:

Estrutura de Partição

Plain Text

sample_data/

├── date=2024-01-01/

│   └── data.parquet

├── date=2024-01-02/

│   └── data.parquet

└── date=2024-01-03/

    └── data.parquet

Dados de Amostra

Plain Text

Original Data:

date        customer_id  email              phone           amount

2024-01-01  1           [email protected]    123-456-0001    500.00

2024-01-01  2           [email protected]    123-456-0002    750.25

...

Masked Data:

date        customer_id  email     phone        amount

2024-01-01  1           ****      ****         500.00

2024-01-01  2           ****      ****         750.25

Abaixo estão alguns benefícios do processamento particionado:

Redução do uso de memória
Capacidade de processamento paralelo
Desempenho aprimorado
Manipulação de dados escalável

Técnicas de Otimização de Desempenho

1. Configurando Processamento Paralelo

Python

# Optimize for performance

conn.execute("""

    SET partial_streaming=true;

    SET threads=4;

    SET memory_limit='4GB';

""")

Essas configurações:

Habilitar streaming parcial para melhor gerenciamento de memória
Definir threads de processamento paralelo
Definir limites de memória para evitar estouro

2. Tratamento de Erros Robusto

Python

def robust_s3_read(s3_path, max_retries=3):

    """

    Implement reliable S3 data reading with retries.

    Parameters:

    - s3_path: Path to S3 data

    - max_retries: Maximum retry attempts

    """

    for attempt in range(max_retries):

        try:

            return conn.execute(f"SELECT * FROM read_parquet('{s3_path}')")

        except Exception as e:

            if attempt == max_retries - 1:

                raise

            time.sleep(2 ** attempt)  # Exponential backoff

Esse bloco de código demonstra como implementar tentativas e também lançar exceções quando necessário para tomar medidas proativas.

3. Otimização de Armazenamento

Python

# Efficient data storage with compression

conn.execute("""

    COPY (SELECT * FROM masked_data)

    TO 's3://output-bucket/masked_data.parquet'

    (FORMAT 'parquet', COMPRESSION 'ZSTD');

""")

Esse bloco de código demonstra a aplicação de tipo de compressão de armazenamento para otimizar o armazenamento.

Melhores Práticas e Recomendações

Melhores Práticas de Segurança

A segurança é crucial ao lidar com dados, especialmente em ambientes de nuvem. Seguir essas práticas ajuda a proteger informações sensíveis e manter a conformidade:

Funções IAM. Use funções do AWS Identity and Access Management em vez de chaves de acesso diretas sempre que possível.
Rotação de chaves. Implemente a rotação regular de chaves de acesso
Menor privilégio. Conceda as permissões mínimas necessárias
Monitoramento de acesso. Revise e audite regularmente os padrões de acesso

Por que é importante: Violações de segurança podem levar a vazamentos de dados, violações de conformidade e perdas financeiras. Medidas de segurança adequadas protegem tanto a sua organização quanto os dados dos seus usuários.

Otimização de Desempenho

A otimização de desempenho garante a utilização eficiente de recursos e um processamento de dados mais rápido:

Tamanho de partição. Escolha tamanhos de partição apropriados com base no volume de dados e nos padrões de processamento
Processamento paralelo. Utilize múltiplas threads para um processamento mais rápido
Gerenciamento de memória. Monitore e otimize o uso de memória
Otimização de consultas. Estruture consultas para máxima eficiência

Por que é importante: Um desempenho eficiente reduz o tempo de processamento, economiza recursos computacionais e melhora a confiabilidade geral do sistema.

Tratamento de Erros

Um tratamento de erros robusto garante um processamento de dados confiável:

Mecanismos de nova tentativa. Implemente um backoff exponencial para operações falhadas
Registro abrangente. Mantenha registros detalhados para depuração
Monitoramento de status. Acompanhe o progresso do processamento
Casos extremos. Lide com cenários de dados inesperados

Por que é importante: O tratamento adequado de erros evita a perda de dados, garante a completude do processamento e facilita a solução de problemas.

Conclusão

O processamento de dados na nuvem com DuckDB e AWS S3 oferece uma poderosa combinação de desempenho e segurança. Me avise como está sendo a implementação do DuckDB!tratamento de erros

Source:
https://dzone.com/articles/processing-cloud-data-duckdb-aws