Introduzindo o contexto do pipeline
Olá.
No último vídeo, analisamos o pipeline (fluxo de processamento) que já tínhamos construído e chegamos a uma conclusão importante: ele funciona.
Conseguimos receber os dados, processá-los nas diferentes camadas da nossa arquitetura Medalhão e obter um resultado na camada Gold. Portanto, tudo está funcional.
Também percebemos que o fato de o pipeline (fluxo de processamento) funcionar não significa, necessariamente, que ele esteja pronto para produção. Quando mudamos para um contexto de produção de uma empresa, surgem novas preocupações.
Separamos cinco delas, que vão nos acompanhar ao longo do curso:
- Automação
- Confiabilidade
- Observabilidade
- Governança
- Sustentabilidade
Esses são pontos fundamentais quando falamos de um ambiente produtivo em uma empresa.
Automatizando a execução do pipeline
Vamos começar pela automação.
Até agora, toda vez que quisermos executar nosso processo de ETL, precisamos entrar no Databricks, abrir o notebook (bloco de notas de código) e iniciar a execução manualmente. Durante o desenvolvimento do projeto, isso não é um problema; é natural enquanto desenvolvemos e testamos.
Em produção, imaginemos que esse pipeline (fluxo de processamento) precise processar novos dados todos os dias ou até a cada uma hora, a cada X minutos. Precisamos executá-lo diversas vezes.
Não é interessante dependermos de uma pessoa entrar no Databricks diariamente, abrir a conta e executar o notebook (bloco de notas de código) etapa por etapa.
Além disso, não basta executar; é necessário respeitar a ordem das camadas. Só podemos executar a camada Silver se já houver uma camada Bronze, porque ela lê a camada Bronze. Só podemos executar a camada Gold se já houver uma camada Silver. Há uma ordem correta a ser seguida. A camada Silver depende dos dados que passaram pela camada Bronze, e a Gold depende da Silver.
Quando pensamos em produção, precisamos representar essa ordem e garantir que essas etapas sejam executadas de forma automática. Esse é o nosso primeiro ponto de preocupação: automação.
Garantindo a confiabilidade do pipeline
Quanto à confiabilidade, nossa segunda preocupação, até agora consideramos apenas o caminho em que tudo funciona. Observamos o caminho feliz: a Bronze executa, a Silver executa, a Gold executa.
Em produção, precisamos pensar no caminho em que algo pode dar errado — e, às vezes, vai dar errado, o que faz parte do processo. Por exemplo, a Bronze pode ser executada corretamente, mas, durante o processamento da Silver, algo falha. Queremos continuar e executar a Gold? Provavelmente não.
Depois que corrigirmos o problema, precisamos decidir: executamos tudo novamente ou apenas a parte que falhou? Conseguimos executar somente a Silver? Se executarmos novamente, o que acontece com os dados já processados? Se processamos 50% do lote na Silver e os outros 50% falharam, processamos tudo de novo ou apenas o que não foi processado? Conseguimos identificar o que já havia sido processado para evitar reprocessamento?
Esses pontos compõem a confiabilidade: falhas, rejeições e a necessidade de prever e saber como se comportar caso ocorram.
Essa preocupação não é exatamente nova. No curso anterior, utilizamos o checkpointing (ponto de verificação) para realizar a ingestão incremental, permitindo que o Spark mantenha informações sobre o progresso da consulta. Já estávamos atentos a isso. Agora, ao olharmos para o nosso pipeline (fluxo de processamento) em produção, a preocupação com rejeições aparece não apenas na ingestão, mas ao longo de todo o fluxo — ali, a ingestão já era um início dessa preocupação.
Implementando observabilidade no pipeline
Em seguida, falamos de observabilidade, nossa terceira preocupação.
Quando executamos o notebook (bloco de notas de código) manualmente e ele apresenta erro, estamos olhando para a tela, percebemos o erro e lemos a mensagem. Entretanto, se o pipeline (fluxo de processamento) está sendo executado automaticamente, ninguém estará acompanhando isso a cada execução. Afinal, a ideia de automatizar é justamente o processo seguir sozinho.
Se ocorrer uma falha, precisamos conseguir voltar posteriormente e entender o que aconteceu: qual execução falhou, qual etapa apresentou o problema, quanto tempo a execução levou, qual mensagem de erro foi registrada, quais etapas conseguiram terminar antes da falha.
Automatizar por si só não é suficiente. Precisamos desses pontos de observabilidade, pois ninguém vai automatizar e colocar uma pessoa para acompanhar continuamente — se fosse para fazer isso, manteríamos a execução manual. A ideia é adicionar uma camada de observabilidade que nos permita entender o que aconteceu durante o processo que estava rodando de forma automática. Precisamos conseguir acompanhar e investigar as execuções.
Há outro detalhe: imagine que o pipeline (fluxo de processamento) executou corretamente e atualizou a nossa camada Gold. O funcionamento ocorreu como esperado. Hoje, uma nova execução começa, mas falha. A camada Gold produzida ontem pode continuar disponível. Ou seja, simplesmente encontrar dados naquela tabela não significa, necessariamente, que a execução de hoje ocorreu corretamente.
Em produção, precisamos distinguir essa situação e identificar que o dado não está atualizado — ele é de ontem. O que aconteceu? Não queremos apenas saber se existe resultado. Queremos entender qual execução produziu aquele dado e se a publicação esperada realmente aconteceu.
Percebemos, então, que essas preocupações são interconectadas: automatizamos, mas precisamos de confiabilidade. Está automático, e se ocorrer problema?
O que vai acontecer com essa automação?
Precisamos de confiabilidade e de um modo claro de executar o processo em caso de falhas.
Em seguida, avançamos para a observabilidade.
Se algo falhar, como saberemos o que deu errado? Como entenderemos onde ocorreu a falha?
Tudo isso se conecta para compor uma arquitetura completa. Precisamos de um processo em produção que, por exemplo, execute a cada hora, traga informações de erro, permita reexecuções e mantenha tudo integrado.
Estabelecendo governança de acesso
Nossa quarta preocupação é a governança. Enquanto desenvolvemos o projeto de forma individual, muitas vezes trabalhamos com acesso amplo e sem delimitações. No entanto, em um ambiente corporativo ou produtivo, aplicamos a regra do menor privilégio.
Imagine o pipeline (esteira de dados) sendo utilizado por diferentes pessoas e equipes. Surge a pergunta: todas as pessoas devem acessar a camada Bronze? E, se alguém precisa consultar uma informação na camada Gold, essa pessoa também deve ter permissão para alterar a tabela? Frequentemente, a resposta é não.
Se somos responsáveis por produzir os dados e concedemos acesso para consumo, não faz sentido permitir alteração. Portanto, partimos do princípio de que ninguém tem acesso por padrão e concedemos apenas as permissões estritamente necessárias. Caso contrário, corremos o risco de, por exemplo, alguém com permissão de edição alterar uma tabela por engano. Devemos controlar acessos e credenciais para garantir a confiabilidade dos dados e evitar exposição de informações sensíveis a quem não deveria visualizá-las.
Também podemos utilizar credenciais específicas do próprio pipeline (esteira de dados) para acessar recursos. Ao pensar em produção, precisamos definir quem pode acessar o quê e como proteger informações sensíveis, incluindo dados de clientes. É essencial desenhar o processo de governança.
Mais adiante, vamos trabalhar essas preocupações utilizando recursos como Unity Catalog e Secrets.
Garantindo sustentabilidade do pipeline
Nossa última preocupação é a sustentabilidade do pipeline (esteira de dados). Aqui não falamos de sustentabilidade ambiental, e sim da capacidade de manter o projeto funcionando e evoluindo ao longo do tempo.
Colocar o pipeline (esteira de dados) em produção não significa que ele nunca mais mudará. Novas regras de negócio podem surgir, novas pessoas podem ingressar no projeto, o volume de dados pode aumentar e o código também deve evoluir. É natural que ocorram mudanças, e precisamos saber exatamente qual código está sendo executado.
Por isso, devemos considerar versionamento, desenvolvimento de alterações sem comprometer imediatamente o que já está funcionando, e o acompanhamento de desempenho e custo. Um processamento que atende bem com poucos dados pode não se comportar da mesma forma quando o volume cresce, podendo degradar desempenho ou até falhar com muitos dados.
Nosso pipeline (esteira de dados) precisa ser funcional hoje e manutenível ao longo do tempo. Por isso, mais adiante, vamos trabalhar com Git, CLI e otimização de computação, desempenho e custos.
Tudo isso está interligado. Colocar um pipeline (esteira de dados) em produção não é apenas pegar um notebook (caderno de código) e executá-lo em outro ambiente. Existe uma mudança na forma de pensar o pipeline (esteira de dados) como um todo.
A automação garante que não dependamos de execução manual. A confiabilidade nos obriga a pensar em falhas e reexecuções. A observabilidade permite entender o que aconteceu em cada execução. A governança controla quem e quais sistemas acessam os recursos. A sustentabilidade assegura que o projeto continue sendo mantido e evoluindo ao longo do tempo.
Esses pontos se conectam para assegurar um produto completo em produção. Eles não aparecem de forma isolada; fazem parte da operação de um pipeline (esteira de dados) profissional e são de extrema importância.
Contextualizando o ambiente de laboratório
Há um ponto relevante sobre nosso laboratório. Durante este curso, estamos utilizando a Databricks Free Edition (Edição Gratuita). Isso significa que trabalhamos em um ambiente educacional com algumas limitações em relação a um ambiente corporativo completo.
No nosso caso, vamos trabalhar principalmente com o Serverless Compute (Computação sem servidor), um único Workspace (espaço de trabalho) e volumes pequenos de dados. Nosso objetivo não é reproduzir a arquitetura completa de uma empresa. Queremos praticar as decisões de engenharia envolvidas na operação de um pipeline (esteira de dados). Vamos treinar as decisões que seriam tomadas em um ambiente produtivo.
Sempre que uma funcionalidade tiver diferença ou limitação na Free Edition (Edição Gratuita), vamos sinalizar para que fique claro o que é limitação do ambiente e como seria em contexto corporativo. Vamos destacar esses pontos.
Estruturando o roteiro do curso
Esses cinco pilares também orientam o caminho que vamos percorrer a partir de agora. Primeiro, trabalharemos com automação, transformando as etapas em um fluxo de orquestração.
Depois, nós vamos trabalhar com confiabilidade e observabilidade, provocando uma falha e investigando o que aconteceu.
Em seguida, vamos abordar governança, controlando acessos e protegendo credenciais.
Por fim, trabalharemos a sustentabilidade do projeto, considerando organização, versionamento, performance (desempenho) e custos.
Ou seja, nós vamos evoluir progressivamente o mesmo pipeline que nós acabamos de analisar.
Automatizando a execução do pipeline
O primeiro problema que nós precisamos resolver é justamente o primeiro da nossa lista: a automação.
Atualmente, nós temos diferentes notebooks com etapas no Databricks que precisam ser executadas em uma ordem específica, mas ainda dependemos de alguém realizar a execução manual.
Precisamos de uma maneira de transformar essas etapas em tarefas e estabelecer dependências para conseguirmos acompanhar a execução; é justamente aqui que entra o LakeFlow Jobs.
No próximo vídeo, nós vamos conhecer esse recurso e entender como ele pode nos ajudar a começar a operacionalizar o nosso pipeline.
E eu te vejo lá!