00HORAS
00MIN
00SEG
Compre com desconto

Primeiras aulas do curso

Engenharia de Dados: pipelines confiáveis com testes automatizados

Preparando o ambiente e subindo a camada Bronze - Apresentação

Apresentando o curso

Olá! Bem-vindas e bem-vindos ao curso de engenharia de dados: construindo pipelines confiáveis com testes automatizados. Eu sou o Luiz Fernando e vou guiar vocês ao longo dessa jornada.

Audiodescrição: Luiz é um homem de pele clara, com cabelo de raiz escura e pontas claras, na altura entre as orelhas e os ombros. Ao fundo, luzes roxas e azuladas se refletem em um armário marrom. À esquerda, vê-se a ponta de uma mesa com uma pilha de livros sobre ela.

Eu trabalho com engenharia de dados há pouco mais de seis anos, quase sete, e já atuei em algumas startups de renome. Trago essa experiência para colaborar com a criação de uma infraestrutura de dados mais robusta, mostrando como adicionar testes e como aumentar a confiança nas pipelines. Essa é a proposta deste curso.

Detalhando o cronograma do curso

Ao longo do curso, vamos passar por algumas aulas.

Na Aula 1, teremos vídeos voltados ao ambiente de desenvolvimento e à camada de bronze. Vamos conhecer a API, realizar nossa primeira extração para verificar como os dados estão e executar nosso primeiro teste.

Na Aula 2, vamos aprofundar os testes, aplicar transformações e organizar suítes de testes.

Na Aula 3, nós criaremos uma camada de prata e avançaremos em direção ao final da nossa pipeline.

Na Aula 4, teremos a camada de ouro integrada ao Great Expectations, uma forma de validar os dados automaticamente.

Na Aula 5, vamos enviar tudo isso em um processo de CI/CD, integrar mecanismos de observabilidade e outros recursos relacionados. A proposta é percorrer, de ponta a ponta, da criação até a entrega de uma API com praticamente tudo: você terá um certo nível de deploy (implantação), um processo de CI/CD em execução, seus testes em execução e o código executando a pipeline (fluxo de processamento). Essa é a ideia central.

Alinhando pré-requisitos e abordagem didática

Partimos do pressuposto de que você dispõe de conhecimento de Python e SQL; qualquer outro conhecimento relacionado aos tópicos que tratarmos irá agregar bastante. No entanto, não se preocupe se você ainda não conhecer ou não tiver tanta familiaridade: nós vamos explicar ao longo das aulas, você compreenderá progressivamente e, provavelmente, conseguirá absorver todo o conteúdo apresentado. Sempre haverá material de referência para quem quiser dar um passo adicional e realizar um aprofundamento em algumas das ferramentas ou dos tópicos que formos tratando.

Também não vamos escrever tanto código. Vamos revisar grande parte do código que, em parte, foi escrito por nós e pela LLM (Modelo de Linguagem Grande). Estamos em um contexto no qual raramente se escreve código completamente de forma manual. Por isso, vamos explicar alguns dos prompts (instruções) que utilizamos para criar essas pipelines (fluxos de processamento), para que você possa realizar testes por conta própria e contar com uma referência caso ainda não tenha muita prática com a LLM. Talvez nossos prompts (instruções) ajudem.

Esperamos que você se divirta e aproveite bastante estas aulas. Vamos para a primeira aula?

Preparando o ambiente e subindo a camada Bronze - Preparando o ambiente Docker

Iniciando o projeto e preparando o ambiente

Olá, bem-vindas e bem-vindos de volta. No vídeo anterior, fizemos uma rápida apresentação; agora vamos pôr a mão na massa.

Vamos acessar o repositório disponibilizado, clonar e abrir a pasta com as informações. Observaremos que há diversos arquivos e passos. Não é necessário se preocupar com tudo neste momento; vamos explorar esses arquivos e passos ao longo do projeto, familiarizando-nos gradualmente e entendendo onde cada peça se encaixa nesse grande quebra-cabeça.

Estamos trabalhando em uma máquina Linux, e tudo bem se você estiver usando Windows, macOS ou Linux. Foi criado um ambiente em Docker para desenvolvermos da mesma forma, independentemente do sistema base. Por isso, há arquivos e configurações como Airflow Dockerfile, Docker Compose e Dockerfile, com o objetivo de abstrair a máquina base e partirmos do mesmo ponto. Haverá material de apoio com instruções para instalar, baixar e subir o Docker, para que possamos alcançar o mesmo estado inicial em todas as máquinas. A ideia é que, com o Docker, tudo rode de forma equivalente e reduzamos diversos problemas.

Há também um arquivo Troubleshooting.md com erros recorrentes. Se algum erro ocorrer, vale consultar esse arquivo. Caso o problema não esteja documentado, publique no fórum; vamos ajudar.

Subindo os serviços e validando o ambiente

Vamos abrir o terminal. Para Windows e macOS, haverá instruções de como abrir o terminal e navegar por ele. Em seguida, vamos até a pasta onde estão os dados deste projeto.

Primeiro, vamos verificar se o Docker está em execução. Às vezes, o Docker está instalado, mas desativado, o que gera erros pouco claros. Usamos comandos de verificação; se o version retornar as versões, significa que o Docker está ativo. O mesmo vale para o Docker Compose.

Agora, vamos subir os serviços no Docker. Utilizamos o subcomando up com a opção -d (de detached (desacoplado)), para que não fiquem acoplados ao terminal, e a opção build para construir as imagens. Dessa forma, o ambiente é construído e iniciado em segundo plano. No exemplo, tudo subiu rapidamente porque o comando havia sido executado recentemente nesta máquina. Se na sua demorar, é normal: aguarde alguns minutos e retome assim que finalizar.

Limpamos o terminal para acompanhar melhor o que está acontecendo. A proposta central do curso é testar continuamente. Portanto, após subir o Docker, vamos validar se ele está funcionando como esperamos.

Executando os testes iniciais do ambiente

Vamos executar nossa pipeline (fluxo de processamento) com docker compose exec e rodar os testes com pytest. Na pasta "testes", há um arquivo chamado teste_ambiente. É ele que vamos utilizar para verificar se o ambiente foi instalado corretamente e se tudo está executando como esperado.

Houve inicialmente um erro de caminho porque foi utilizada uma barra no lugar de um underline; após corrigirmos, os testes foram encontrados e executados. Foram rodados o teste_ambiente, a verificação de versão mínima do Python e a checagem de dependências disponíveis. Todos os testes passaram. Há também um relatório de cobertura.

Este conjunto está relacionado a todos os outros testes. Observamos que há muitos testes disponíveis, mas não precisamos nos preocupar com todos neste momento. Ele apenas informa sobre as variações possíveis de testes. Por enquanto, queremos analisar apenas o teste de ambiente.

Inspecionando o teste de ambiente

Vamos fechar o terminal e abrir o teste de ambiente no editor de texto. Vamos maximizar a janela e observar o código deste teste de ambiente.

Para contextualizar o que estamos vendo, segue o conteúdo do arquivo de testes de ambiente mencionado:

"""Environment tests test.


If this passes, the environment is ready to start tests :). If you don't have any data yet,
that's fine. The pipeline hasn't run yet.
Only that Python, the pipest package, and dependencies are in place.
"""




from pathlib import Path




import pytest
import sys




def test_python_version_should_be_greater_than_3_11():
"""Test python version."""
assert sys.version_info >= (3, 11)




def test_base_dependencies_are_installed():
"""Test basic dependencies are installed."""
import pytest as _pytest  # noqa: F401
import requests




def test_project_package_imports_are_working():
"""Test project package exports are working."""
import ptax_pipeline.pipeline as _pipeline # noqa: F401




def test_base_constants_are_in_place():
"""Test basic constants are in place."""
from ptax_pipeline.config import EXPECTED_YEARS
from ptax_pipeline.config import EXPECTED_MONTHS



assert EXPECTED_YEARS == ["2022", "2023", "2024"]
assert EXPECTED_MONTHS == ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"]




def test_base_folders_exist():
"""Test basic folders exist."""
from ptax_pipeline.config import BASE_FOLDER



assert Path(BASE_FOLDER).exists()


Ele valida a versão mínima do Python, que deve ser 3.11. Verifica se conseguimos importar algumas das dependências que vamos utilizar. Verifica se a nossa Ptax Pipeline pode ser importada a partir de outros pacotes. Verifica se as nossas constantes básicas estão funcionando: ele acessa duas constantes e checa se contêm as informações esperadas. Também verifica se existe determinada pasta dentro do nosso repositório e se ela é um diretório. Vamos minimizar aqui.

Vamos retornar à página anterior e confirmar que era isso que aqueles testes estavam verificando.

Acessando o contêiner e reconhecendo os serviços

Agora, vamos sair do editor de texto e abrir novamente o terminal. No terminal, voltamos para "Pipelines" com os testes automatizados. Em seguida, vamos mostrar como conectar todos os sistemas, isto é, todas as máquinas básicas, no mesmo ambiente Docker para executar tudo de forma idêntica. O comando é docker compose exec pipeline bash. O que acontece ao executarmos esse bash? Ele dá acesso a um shell bash, ou seja, a um terminal (no Windows seria o cmd), dentro do contêiner Docker que está em execução.

Todos os arquivos que clonamos para a máquina local (Linux, Windows ou macOS) também ficam acessíveis dentro desse bash do Docker. O comando ls lista todos os arquivos, e veremos que são os mesmos do projeto local. O que está dentro do contêiner funcionará da mesma forma em Linux, Windows ou macOS, porque o Docker está abstraindo a base do sistema operacional para o ambiente do contêiner. Assim, tudo roda de forma igual, independentemente da máquina local. Se executássemos tudo fora do Docker, o comportamento poderia variar de acordo com o sistema operacional.

Para concluir esta parte, vamos fechar este terminal e abrir um novo, ainda com docker compose, apenas para elencar o que temos. Vamos maximizar a janela. No docker compose, temos uma parte do Spark em execução e um serviço do Airflow, com um Dockerfile do Airflow que traz diversas configurações. Esses são alguns dos ambientes disponíveis.

Para visualizar concretamente essa configuração, o arquivo de orquestração está assim:

version: '3.8'


x-spark-common: &spark-common
image: bitnami/spark:3.5.0
volumes:
- ./data:/opt/bitnami/spark/data
- ./src:/opt/bitnami/spark/src
networks:
- data-network




services:
spark:
<<: *spark-common
command: bin/spark-class org.apache.spark.deploy.master.Master
ports:
- "8080:8080"
- "7077:7077"
environment:
- SPARK_MODE=master
- SPARK_RPC_AUTHENTICATION_ENABLED=no
- SPARK_RPC_ENCRYPTION_ENABLED=no
- SPARK_LOCAL_STORAGE_ENCRYPTION_ENABLED=no
- SPARK_SSL_ENABLED=no




spark-worker:
<<: *spark-common
command: bin/spark-class org.apache.spark.deploy.worker.Worker spark://spark:7077
depends_on:
- spark
environment:
- SPARK_MODE=worker
- SPARK_MASTER_URL=spark://spark:7077
- SPARK_WORKER_MEMORY=1G
- SPARK_WORKER_CORES=1
- SPARK_RPC_AUTHENTICATION_ENABLED=no
- SPARK_RPC_ENCRYPTION_ENABLED=no
- SPARK_LOCAL_STORAGE_ENCRYPTION_ENABLED=no
- SPARK_SSL_ENABLED=no




pipeline:
build:
context: .
dockerfile: airflow.Dockerfile
image: ptax-pipeline:latest
volumes:
- ./data:/app/data
- ./src:/app/src
- ./tests:/app/tests
ports:
- "8081:8080"
networks:
- data-network
depends_on:
- spark
environment:
- AIRFLOW__CORE__LOAD_EXAMPLES=False
- AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=sqlite:////app/airflow/airflow.db


networks: data-network: driver: bridge

O Spark está na porta 8080 e o Airflow na porta 8081.

Vamos alternar rapidamente para o navegador. Na porta 8080, temos o Spark em execução. Na porta 8081, temos o Airflow. Aqui já está logado porque testamos anteriormente, mas ao acessar pela primeira vez, você verá a tela de login; as credenciais são usuário admin e senha admin. A nossa pipeline já está disponível. Portanto, temos o Spark e o Airflow em execução.

Encerrando e anunciando próximos passos

Vamos voltar. É isso: o Docker está rodando com todas as ferramentas que vamos utilizar, com o código testado e o ambiente corretamente configurado. Podemos partir agora do mesmo ponto e desenvolver da mesma forma, facilitando o processo e reduzindo a quantidade de erros simples ao longo do curso.

Espero vocês na próxima aula, em que vamos começar a trabalhar com a ingestão, analisar a pipeline, a API que vamos consumir, ver os primeiros dados e construir o nosso primeiro teste. Vai ser bem divertido. Espero vocês lá.

Preparando o ambiente e subindo a camada Bronze - Construindo a camada Bronze

Iniciando a construção da camada bronze

Olá, pessoal.

Boas-vindas de volta.

Vamos para a próxima etapa da nossa pipeline. Agora, vamos finalmente construir a nossa camada bronze. Já apresentamos um panorama sobre o repositório e sobre a infraestrutura. Agora, vamos analisar o código para compreender o que vai acontecer nesta primeira etapa.

Explorando a documentação da api do banco central

Antes de vermos o código em si, vamos mostrar a documentação. Se procurarmos no site do Banco Central, veremos a API que vamos usar. Ela trata sobre o dólar comercial, com cotação de compra e de venda. Vamos usar um endpoint que retorna a relação da cotação do dólar em uma determinada data. Existem vários outros endpoints relacionados a essa API, mas este é o que vamos usar.

Na documentação, estão listados todos os parâmetros aceitos e os parâmetros retornados. São três principais (apenas esses três, de fato): cotação compra, cotação venda e data-hora cotação. Os tipos são decimal, decimal e, no caso da data-hora, texto. Há também uma descrição breve do que acontece. Esta consulta serve para termos uma ideia do que vamos consumir nessa API.

Revisando o arquivo de configuração

Vamos voltar ao nosso repositório. Agora, vamos para onde está o código de verdade. O código deste repositório está dentro da pasta "source", "syntax pipeline". Aqui está todo o código da pipeline, fim a fim. Há também esse “quad”, sobre o qual vamos falar depois. A primeira parte do bronze está no arquivo injection pipe. Porém, antes de olharmos esse arquivo, vamos passar pelo config.py, que é um arquivo que permeia todos os outros. Ele traz algumas variáveis e constantes, que vamos examinar brevemente.

É um arquivo simples, basicamente com a definição de algumas constantes. Ele importa annotations (vamos falar mais disso quando abrirmos o arquivo principal desta aula) e importa Path para resolver o caminho de algumas constantes. Agora, veja como isso aparece no código do config:

from __future__ import annotations

from pathlib import Path

Encontramos a URL da API que estamos usando, isto é, a URL onde estarão os dados, além dos campos esperados (os mesmos que vimos na documentação: cotação compra, cotação venda e data-hora cotação). Há também o tempo de espera da requisição (REQUEST_TIMEOUT), uma configuração que define por quanto tempo vamos aguardar a resposta da API; vamos usar essa constante ao fazer a requisição. No código:

BCB_PTAX_BASE_URL = "https://olinda.bcb.gov.br/olinda/servico/PTAX/versao/v1/odata"

EXPECTED_FIELDS: list[str] = [ "cotacaoCompra", "cotacaoVenda", "dataHoraCotacao", ]

E o tempo limite da requisição:

REQUEST_TIMEOUT = 30

O arquivo define onde está a raiz do projeto, informando que está dois níveis acima no diretório. Define também onde estarão os diretórios com os dados que vamos baixar: o diretório de dados "data" e, dentro dele, as camadas "bronze", "silver" e "gold". No código, isso fica:

PROJECT_ROOT = Path(__file__).resolve().parents[2]

DATA_DIR = PROJECT_ROOT / "data" BRONZE_DIR = DATA_DIR / "bronze" SILVER_DIR = DATA_DIR / "silver" GOLD_DIR = DATA_DIR / "gold"

Além disso, há configurações de atualidade dos dados (freshness) e de quantas linhas esperamos por cada resposta. Vamos usar essas configurações mais adiante, quando estivermos testando as saídas da nossa pipeline. Em resumo, é um arquivo simples, apenas com essas constantes:

FRESHNESS_SLA_DAYS = 7
MIN_EXPECTED_ROWS = 1

Implementando a ingestão na camada bronze

Agora, vamos ao conteúdo principal desta aula. Vamos passar pelo código da ingestão, que é a camada bronze. A ingestão é conhecida como camada bronze, isto é, a camada que contém os dados mais brutos. A ideia é armazenarmos os dados que vamos utilizar nas camadas seguintes da forma mais próxima possível da fonte. Caso seja necessário fazer um backfill ou um reprocessamento, não precisamos consumir a API repetidamente. Isso ajuda muito com o volume de dados e também com a estratégia de testes, permitindo chegarmos mais confiantes nas camadas acima. É isso que vamos ver aqui, e vamos percorrer o código.

Começamos com from __future__ import annotations. Isso é uma anotação para ajustar a resolução de tipagem no Python. Pode parecer complexo dependendo do quanto se utiliza tipagem em Python, mas serve para reduzir a quantidade de erros de tipagem durante a execução. Não altera a execução do código em si; trata muito mais da resolução de tipos. Esse import aparece em quase todos os arquivos, então não é motivo de preocupação: ele cuida apenas da resolução de tipagem para o Python, não é algo específico da pipeline ou do código de dados. No arquivo principal da ingestão, iniciamos assim:

from __future__ import annotations

Em seguida, entramos no que vamos de fato usar no arquivo. Vamos trabalhar com CSVs. Importamos de collections.abc alguns tipos mais complexos com os quais vamos trabalhar, como Iterable e Mapping, para explorarmos os dados que estamos recebendo. Vamos trabalhar com datetime, pois vimos que a API retorna a data. Usamos Path para trabalhar com arquivos, criação de arquivos e caminhos no repositório. Também importamos tipos como Protocol, TypedDict e cast para estruturar nossas definições de tipos, especialmente para a requisição HTTP e para compreendermos nossos dados. Esses imports ficam assim:

import csv
from collections.abc import Iterable, Mapping
from datetime import date, datetime
from pathlib import Path
from typing import Protocol, TypedDict, cast

Para consumo da API, importamos três itens relacionados à requisição HTTP: requests, HTTPAdapter e Retry, para possibilitar retentativas de requisição. Importamos também o arquivo config com algumas constantes: a BCB_PTAX_BASE_URL, o diretório de bronze, os campos esperados e o tempo de REQUEST_TIMEOUT. Essas são as constantes que vamos utilizar aqui:

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

E em seguida, as constantes do config:

from config import BCB_PTAX_BASE_URL, BRONZE_DIR, EXPECTED_FIELDS, REQUEST_TIMEOUT

Criamos a classe RawRecord, que representa o retorno da API: cotação compra, cotação venda e data-hora cotação. Seguimos a documentação, atribuindo float ao que a documentação define como decimal e str ao que a documentação define como texto (no caso da data-hora):

class RawRecord(TypedDict):
    cotacaoCompra: float
    cotacaoVenda: float
    dataHoraCotacao: str

Em seguida, criamos classes para a nossa requisição. Definimos a resposta como um Protocol que deve implementar um método json, que retorna um object, e um método raise_for_status, que não retorna nada. Essa tipagem é útil porque, ao olharmos para os tipos, conseguimos entender melhor o que acontece nos métodos e funções, sem precisar ir imediatamente à implementação. Assim, a classe de resposta deverá implementar esses dois métodos:

class Response(Protocol):
    def json(self) -> object: ...
    def raise_for_status(self) -> None: ...

Aqui, o HttpClient, de forma semelhante, precisará implementar o método get, que recebe uma string url, pode receber parâmetros, possui um timeout (tempo limite) que pode ser um número de ponto flutuante ou None, e retorna uma Response, que é a classe que acabamos de criar:

class HttpClient(Protocol):
    def get(self, url: str, *, timeout: float | None = None) -> Response: ...

Construindo url do período da api

Partindo para a implementação concreta, a primeira função é build_period_url. Ela recebe start e end, que são duas datas, e retorna uma string. Trata-se da URL (endereço) que estamos construindo: passamos as datas e obtemos uma string com essa URL incluindo as datas:

def build_period_url(start: date, end: date) -> str:

Como o foco do curso é teste, é importante conferirmos nosso código. Queremos garantir que, para as datas que estamos passando, a data final seja maior que a data de início. Caso contrário, estaríamos começando no futuro e parando no presente ou no passado, o que não faz sentido. Se isso ocorrer, devemos lançar um ValueError informando o erro:

    if end < start:
        raise ValueError("end date must be after start date")

Se estiver correto, convertemos start e end para strings no formato esperado, que é o formato americano. É diferente do formato brasileiro, portanto, precisamos ter atenção:

    start_str = start.strftime("%m-%d-%Y")
    end_str = end.strftime("%m-%d-%Y")

O recurso da API que vamos utilizar é a cotação do dólar por período. Nele, passamos a data inicial com @dataInicial e a data final com @dataFinalCotacao. Esse “cotacao” torna o nome dos campos um pouco assimétrico (poderia ser apenas dataInicial e dataFinal), então precisamos ter cuidado para não esquecer essa parte ao escrever o código:

    resource = f"CotacaoDolarPeriodo(dataInicial=@dataInicial,dataFinalCotacao=@dataFinalCotacao)"

Em seguida, passamos as datas que estamos usando, definimos a data inicial e a data final com as strings que acabamos de criar e solicitamos a resposta no formato JSON (formato de dados). Por fim, retornamos a URL base somada aos parâmetros que acabamos de construir:

    query = f"@dataInicial='{start_str}'&@dataFinalCotacao='{end_str}'&$format=json"

return f&#34;{BCB_PTAX_BASE_URL}/{resource}?{query}&#34;


Extraindo registros do payload

Na função seguinte, recebemos um objeto payload e retornamos uma lista da classe RawRecord, que criamos anteriormente. A lógica segue a mesma ideia explicada na função anterior. Primeiro, verificamos se payload é do tipo mapping (mapeamento). Se não for, lançamos um TypeError. Depois, checamos se existe o campo value em payload. Caso exista, extraímos value de payload, pois dentro dele virão diferentes campos (como o código), mas queremos apenas value, onde estarão os dados:

def extract_records(payload: object) -> list[RawRecord]:
    if not isinstance(payload, Mapping):
        raise TypeError("payload must be a mapping")

if &#34;value&#34; not in payload:
    raise ValueError(&#34;payload must contain a value key&#34;)


Após extrair value, verificamos se ele é uma lista, pois esperamos uma lista de dados. Se não for, sinalizamos que precisa ser uma lista e geramos a exceção correspondente. Se tudo estiver de acordo, tentamos converter esse value em uma lista de objetos:

    value = payload["value"]

if not isinstance(value, list):
    raise TypeError(&#34;value must be a list&#34;)

value &#61; cast(list[object], value)


Em seguida, começamos a iterar para extrair as informações do payload. Criamos records, que será uma lista de RawRecord. Iteramos sobre value com um laço for para extrair os campos:

    records: list[RawRecord] = []

for index, record in enumerate(value):
    if not isinstance(record, Mapping):
        raise TypeError(f&#34;record at index {index} must be a mapping&#34;)


Dentro de cada item que percorremos, verificamos se é do tipo mapping (mapeamento); caso contrário, indicamos que está incorreto. Também checamos se todas as colunas esperadas estão presentes. A variável missing verifica se todos os campos esperados estão presentes no registro que estamos analisando. Se estiver faltando algum, informamos a ausência; caso contrário, adicionamos (append) o novo registro à lista records que estamos montando a partir da resposta do payload da API. Ao final, depois de percorrer todos os itens dentro de value extraído de payload, retornamos records já com o cast para RawRecord, no formato da classe esperada:

        missing = [field for field in EXPECTED_FIELDS if field not in record]
        if missing:
            raise ValueError(f"record is missing fields: {missing}")

    records.append(cast(RawRecord, record))

return records


Temos também um método com um sublinhado no início do nome. Isso segue uma boa prática do Python: quando for um método interno ou privado, utilizamos o sublinhado inicial (underscore (sublinhado)) para indicar que a intenção é que ele seja utilizado apenas por esse arquivo. Não precisaríamos criar _build_default_session em outros arquivos; o sublinhado serve para reforçar essa indicação.

Essa função retorna uma sessão de requisições (request session (sessão de requisições)). Faz sentido: _build_default_session retorna uma sessão. Definimos valores padrão, criamos uma sessão a partir da biblioteca requests, configuramos um retry (nova tentativa) para essa sessão, que tentará três vezes, e definimos um backoff (retardo incremental) de 0.1, isto é, aumentamos gradualmente o tempo de espera entre falhas. Definimos a lista de códigos de resposta da API que aceitaremos e indicamos que o único método com o qual queremos trabalhar é o verbo GET (verbo HTTP). Em seguida, criamos a sessão, aplicamos um HTTP adapter (adaptador HTTP) para passar a configuração de retry que acabamos de definir e, com isso, temos a sessão pronta:

def _build_default_session() -> requests.Session:
    session = requests.Session()
    retry = Retry(
        total=3,
        backoff_factor=0.1,
        status_forcelist=[429, 500, 502, 503, 504],
        allowed_methods=["GET"],
    )
    session.mount("https://", HTTPAdapter(max_retries=retry))
    return session

Utilizando a sessão para buscar registros do período

Passamos então a utilizar essa sessão. A função fetch_period usa essa sessão. Ela recebe uma data de início, uma data final, pode receber outros parâmetros, recebe uma sessão e retorna a lista de RawRecord. Diversos elementos aqui já foram vistos anteriormente, pois estamos juntando as peças que criamos.

Primeiro, chamamos build_period_url, passando start e end. Em seguida, criamos um cliente que verifica se uma sessão existe; se não existir, chamamos _build_default_session que acabamos de ver. Esse cliente nos garante que temos uma sessão válida. Com a sessão disponível, fazemos uma requisição get à URL que criamos anteriormente, definindo o timeout (tempo limite), que é aquele definido como constante no arquivo config. Após obter a resposta, chamamos raise_for_status() para lançar uma exceção caso o código de status (código de resposta) indique erro.

Se tudo estiver correto, vamos retornar o response.json aplicado ao método que vimos anteriormente, o extract_records, que recebe o payload e realiza a extração para a lista de records existente na nossa classe RawRecord, que implementa essa mesma estrutura.

def fetch_period(start: date, end: date, *, session: HttpClient | None = None) -> list[RawRecord]:
    url = build_period_url(start, end)
    client: HttpClient = session if session is not None else _build_default_session()
    response = client.get(url, timeout=REQUEST_TIMEOUT)
    response.raise_for_status()

return extract_records(response.json())


Isso nos fornecerá a saída esperada.

Essa é a ideia do que devemos fazer na camada bronze: acessar a API (interface de programação de aplicações) e consumi-la.

Faltará apenas uma etapa adicional: salvar. Agora que estamos consumindo, precisamos fazer algo com essa informação, que é salvá-la.

Salvando dados em csv na camada bronze

Para isso, teremos o método save_bronze, que receberá os records extraídos e obterá um destination para realizarmos o salvamento.

Nesse ponto, o método verifica se esse destino existe. Se não existir, ele será criado.

Em seguida, o arquivo será aberto como CSV (valores separados por vírgula). O nome já indica que estamos utilizando o formato CSV.

Vamos criar o escritor, o objeto responsável pela escrita: DictWriter, utilizando o csvfile.

Definiremos os campos esperados conforme a documentação da API. Em seguida, escreveremos o cabeçalho e, para cada registro no nosso iterável (lista de registros), escreveremos a linha no arquivo.

Depois disso, retornaremos o destination, que é o caminho onde estamos salvando. Isso serve para retornar algo útil, pois, às vezes, executamos um código que tem apenas efeitos colaterais (efeitos paralelos) e nada aparece no terminal, o que pode gerar dúvida sobre o funcionamento. Nessas situações, retornar algo, como um print do path, pode ajudar a verificar que tudo está executando corretamente. Isso indica que o fluxo foi concluído e, ao final, o caminho foi impresso.

def save_bronze(records: Iterable[Mapping[str, object]], destination: Path) -> Path:
    destination.parent.mkdir(parents=True, exist_ok=True)

with open(destination, &#34;w&#34;, newline&#61;&#34;&#34;) as csv_file:
    writer &#61; csv.DictWriter(csv_file, fieldnames&#61;EXPECTED_FIELDS)
    writer.writeheader()
    for record in records:
        writer.writerow({field: record.get(field) for field in EXPECTED_FIELDS})

return destination


Orquestrando a ingestão por período

Por fim, temos o ingest_period, que simplesmente aglomera todos os métodos que acabamos de ver. Ele executará o fetch_period (já discutido acima), definirá um filename composto pela data de começo, a data de fim e a extensão .csv, construirá o destination com o caminho do diretório de saída e o filename, e chamará o save_bronze com os registros retornados por fetch_period e o destination recém-criado.

O ingest_period, portanto, apenas concatena os métodos que precisam ser executados.

def ingest_period(start: date, end: date, *, session: HttpClient | None = None) -> None:
    records = fetch_period(start, end, session=session)

destination &#61; BRONZE_DIR / f&#34;{start.isoformat()}_{end.isoformat()}.csv&#34;

save_bronze(records, destination)


Isso nos fornece a camada bronze: percorremos desde o consumo da API até o salvamento dos dados localmente (ou em um servidor). Dessa forma, temos os dados salvos em uma parte do nosso fluxo de dados (pipeline), compondo essa etapa da arquitetura.

Vamos encerrar este vídeo por aqui. No próximo, vamos abordar os testes desse fluxo de dados (pipeline), referentes à primeira etapa.

Sobre o curso Engenharia de Dados: pipelines confiáveis com testes automatizados

O curso Engenharia de Dados: pipelines confiáveis com testes automatizados possui 249 minutos de vídeos, em um total de 47 atividades. Gostou? Conheça nossos outros cursos de Engenharias e Arquiteturas de Dados em Dados, ou leia nossos artigos de Dados.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

  • Preparando o ambiente e subindo a camada Bronze
  • Testes unitários e integração
  • Verificações de fonte e a camada Prata
  • Qualidade com Great Expectations, Spark e a camada Ouro
  • Observabilidade, automação e código gerado com IA

Aprenda Engenharias e Arquiteturas de Dados acessando integralmente esse e outros cursos. Comece hoje!

Plus 24

Todos os cursos, trilhas e certificados para evoluir.

Carregando precos do plano

7 dias para cancelar com reembolso

Alura EmpregabilidadeNOVO
  • Acesso ao maior portal de vagas tech do BrasilExclusivo na Black
  • Modo entrevista técnica e comportamental
  • 2.337 Cursos e 37 Carreiras
  • Certificados reconhecidos pelo mercado
  • Luri: nossa IA exclusiva, que acelera e personaliza seu aprendizado

Pro 24

Aprenda mais rápido com IA, idiomas e imersões.

Carregando precos do plano

7 dias para cancelar com reembolso

TUDO DO PLUS, MAIS:

Alura EmpregabilidadeNOVO
  • Acesso ao maior portal de vagas tech do Brasil
  • Modo entrevista técnica e comportamental
  • Desafios de código
  • System design
  • Luri Vision: a versão mais completa da nossa IA, que permite envio de imagens
  • Livros da Casa do código: Acesso ao acervo de livros da maior editora tech do país
  • Alura Língua: cursos de inglês e espanhol com foco na área tech

Ultra Lab 24

Aceleração de carreira: mentoria, vagas e prática guiada.

Carregando precos do plano

7 dias para cancelar com reembolso

TUDO DO PRO, MAIS:

Alura EmpregabilidadeNOVO
  • Acesso ao maior portal de vagas tech do Brasil
  • Modo entrevista técnica e comportamental
  • Desafios de código
  • System design
  • 2 mentorias individuais com foco na sua carreira
  • Luri Vision Ilimitada: a versão mais completa da nossa IA
  • Lives CareerUp: eventos exclusivos com foco em empregabilidade e carreira
Melhor opção para a sua carreira
Conheça os Planos para Empresas