00HORAS
00MIN
00SEG
Compre com desconto

Primeiras aulas do curso

Databricks: automatizar e operar pipelines em produção

Preparando um pipeline para produção - Apresentação

Apresentando o curso

Olá! Seja muito bem-vinde! Eu sou Agnes Ruescos e vou te acompanhar ao longo de todo este curso, no qual veremos pipelines (fluxos de dados) em produção e governança. Partiremos de um projeto de pipeline (fluxo de dados) já pronto, que percorre as camadas bronze, silver (prata) e gold (ouro). Vamos adicionar um novo desafio: preparar esse pipeline (fluxo de dados) para operação em ambiente produtivo.

Antes de mais nada, eu quero me autodescrever.

Audiodescrição: Sou uma mulher branca, de cabelo castanho, longo e liso. Estou usando óculos e uma blusa azul esverdeada. Ao fundo, está o estúdio da Alura. À esquerda, há uma prateleira com algumas decorações. Estou olhando diretamente para a câmera.

Como comentei, eu sou a Agnes Ruescos, instrutora da Alura e engenheira de dados. Ao longo da minha carreira, já atuei como engenheira de software (programas de computador) e engenheira de DevOps (operações de desenvolvimento). Atualmente, trabalho especificamente construindo pipelines (fluxos de dados), definindo qualidade e governança, e projetando infraestrutura e processamento em cloud (nuvem). São justamente várias dessas preocupações que nós vamos trazer para o projeto ao longo deste curso.

Relembrando o projeto base e objetivos

Se você já acompanhou nosso curso de Databricks, Delta Lake e arquitetura medalhão, provavelmente reconhecerá o projeto que utilizaremos aqui. Naquele curso, nós construímos um pipeline (fluxo de dados) utilizando a arquitetura medalhão, passando pelas camadas bronze, silver (prata) e gold (ouro). É justamente a partir desse projeto que vamos avançar agora.

Nós não vamos reconstruir essa arquitetura do zero; ela já funciona. O desafio, agora, é entender o que precisamos adicionar e considerar ao levar esse pipeline (fluxo de dados) para um ambiente produtivo. É aí que começa a jornada deste curso. Quando pensamos em produção, não basta o código funcionar. Precisamos planejar como esse pipeline (fluxo de dados) será executado de forma automatizada, o que acontece quando uma etapa falha, como acompanhamos as execuções, quem pode acessar nossos recursos e como organizá-los em diferentes ambientes.

Ao longo das próximas aulas, vamos evoluir o projeto olhando para essas preocupações. Vamos colocar o pipeline (fluxo de dados) em operação com workflows (fluxos de trabalho) do Databricks, organizar tarefas das camadas bronze, silver (prata) e gold (ouro), além das verificações, e definir as dependências entre elas. Também vamos trabalhar com agendamentos e acompanhar o histórico de execuções.

Evoluindo a operação e a governança

Depois, vamos explorar situações em que ocorrem falhas em produção. Vamos provocar problemas no próprio pipeline (fluxo de dados) para nós aprendermos a investigar o que aconteceu. Vamos analisar logs (registros), trabalhar com retries (tentativas de nova execução) e adicionar informações que nos ajudem a acompanhar e entender o processo de falha.

Logo após isso, nós vamos avançar com preocupações de governança e segurança. Vamos utilizar o Unity Catalog para organizar acessos. Vamos trabalhar com secrets (segredos) para não expor credenciais e informações sensíveis no código. Também vamos separar nossos ambientes em três: dev (desenvolvimento), staging (homologação) e produção.

Na sequência, nós vamos analisar o fluxo de desenvolvimento e organizar melhor a estrutura do projeto, utilizando Git para versionar as alterações e conhecendo o Databricks CLI para utilizar o Databricks fora da interface. Com ele, nós vamos conseguir interagir com a plataforma e até criar recursos por linha de comando.

Avaliando desempenho e consumo

Para fechar essa jornada, nós vamos olhar para performance (desempenho), compute (recursos de computação) e consumo, o que é fundamental. Nós vamos analisar o comportamento do nosso próprio pipeline (fluxo de processamento de dados) e entender como decisões, como a frequência de execução ou a configuração de retries (novas tentativas), podem influenciar a qualidade do nosso trabalho. Também vamos discutir possíveis evoluções para a nossa arquitetura, pensando em um cenário de produção.

Teremos muitos tópicos para construir em conjunto. Vamos partir de um pipeline que já funciona e evoluir o projeto, passando por automação, agendamento, investigação de falhas, logs (registros), monitoramento, governança, segurança, separação de ambientes, versionamento e análise de desempenho e consumo.

A ideia é que, ao final do curso, você consiga enxergar o pipeline não apenas como um código que transforma dados, mas como uma solução que precisa ser automatizada, monitorada, governada e operada no dia a dia.

Indicando pré-requisitos e suporte

Como este curso é mais avançado, nós vamos assumir alguns conhecimentos prévios. É importante que você já tenha familiaridade com Delta Lake, arquitetura medalhão, construção de pipelines e também noção básica de Git. Se você ainda não fez o curso de Databricks, Delta Lake e arquitetura medalhão, recomendamos começar por ele, principalmente porque já construímos o projeto lá e, aqui, nós apenas o evoluiremos. Caso você já conheça esses conceitos, também pode seguir conosco utilizando o material que nós disponibilizamos aqui.

Durante todo esse processo, você terá apoio: nosso canal no Discord, o fórum da Alura e a Luri, nossa assistente virtual de IA, que pode auxiliar com exemplos e explicações de conceitos. Você pode utilizar todas essas ferramentas para ampliar o aprendizado ao longo do curso.

Temos bastante conteúdo para construir em conjunto nas próximas aulas e esperamos que você aproveite. Principalmente, pratique conosco durante toda a evolução do projeto. Preparade para começar? Vamos lá!

Preparando um pipeline para produção - Nosso pipeline está pronto?

Iniciando o curso e retomando o projeto base

Olá. Agora que você já sabe o que nós vamos desenvolver neste curso, vamos iniciá-lo efetivamente. Antes de começar, queremos trazer um ponto importante: partiremos de um projeto desenvolvido no nosso curso de Databricks, Data Lake (lago de dados) e arquitetura medalhão. Caso esse curso anterior não tenha sido realizado, recomendamos fazê-lo agora, pois ele demonstra como criamos todo o nosso pipeline (fluxo de processamento) básico, a partir do qual vamos evoluir para alcançar a produção neste curso.

No curso anterior, construímos um Lakehouse (arquitetura unificada de dados) com Delta Lake e organizamos os processamentos seguindo a arquitetura medalhão. Recebemos dados de pedidos, passamos pela camada de bronze (bronze), aplicamos os tratamentos necessários para a camada silver (prata) e disponibilizamos as informações mais refinadas do ponto de vista de negócio na camada gold (ouro). Também evoluímos a ingestão para utilizar o Auto Loader (carregador automático), que permite trabalhar com a chegada incremental de arquivos. Assim, já partimos de um pipeline (fluxo de processamento) funcional.

Agora, queremos fazer uma pergunta para começarmos: nosso pipeline (fluxo de processamento) está pronto? O simples fato de ele funcionar significa que está pronto para ir para produção? É isso que vamos compreender nesta primeira aula.

Revisando a arquitetura medalhão no databricks

Antes de responder, vamos retomar rapidamente, no Databricks, o que já construímos. Vamos abrir a seção de workspace (espaço de trabalho) e observar alguns notebooks. No notebook 4, estruturamos a arquitetura medalhão. Logo no início, realizamos os imports e, em seguida, trabalhamos a camada bronze (bronze), na qual mantivemos o dado o mais próximo possível da forma como foi recebido.

Abaixo, visualizamos a camada silver (prata), onde começamos a aplicar tratamentos e regras, como validação, tipos e normalização. É nessa camada que realmente tratamos o dado e o tornamos confiável, garantindo dados válidos.

Mais adiante, chegamos à camada gold (ouro), na qual disponibilizamos as informações mais preparadas para consumo por um time de negócio. Do ponto de vista de transformação de dados, há um fluxo claro: bronze (bronze), silver (prata) e gold (ouro). Os dados entram, passam pelas camadas e chegam a um resultado que pode ser utilizado pelo negócio. Até aqui, tudo parece correto.

Evoluindo a ingestão com auto loader e streaming

No final do curso anterior, utilizamos também o notebook 5 para introduzir o Auto Loader (carregador automático) e passamos a trabalhar com outro aspecto importante: os dados não chegam apenas uma vez. Novos pedidos e atualizações continuarão chegando continuamente. Por isso, evoluímos a ingestão utilizando leitura incremental com Spark Structured Streaming (processamento de fluxo estruturado do Spark) e Auto Loader (carregador automático). Essa abordagem permite que novos arquivos sejam identificados e processados conforme chegam na fonte.

Configuramos um ponto essencial: o checkpointing (registro de ponto de verificação). O checkpointing (registro de ponto de verificação) permite que o Spark mantenha informações sobre o progresso da consulta. Se o processamento for iniciado novamente utilizando o mesmo checkpoint (ponto de verificação), ele consegue continuar considerando o que já havia sido processado. Em outras palavras, fornecemos uma “memória” de execução por meio do checkpoint (ponto de verificação).

Esses elementos já ajudam em uma preocupação típica de produção: nosso pipeline (fluxo de processamento) será executado repetidamente — hoje, amanhã e assim por diante. Precisamos pensar em reexecução. Entretanto, há uma diferença importante: o checkpoint (ponto de verificação) nos ajuda a controlar o progresso da ingestão, mas isso não significa que todos os problemas de reexecução do pipeline (fluxo de processamento) estejam automaticamente resolvidos. Por exemplo, se uma nova versão de um pedido chegar em outro arquivo, esse arquivo é tratado como uma nova entrada. Ainda precisamos planejar como as camadas seguintes lidarão com atualizações, correções e possíveis reprocessamentos.

Mudando a perspectiva para operação em produção

Agora, vamos mudar um pouco a perspectiva. Até aqui, olhamos para o projeto como pessoas desenvolvedoras: construímos bronze (bronze), silver (prata) e gold (ouro), testamos e tudo funcionou. Porém, imagine que, a partir de amanhã, esse pipeline (fluxo de processamento) será responsável por disponibilizar informações utilizadas diariamente em uma empresa. Quem vai executar esses notebooks?

Da forma como trabalhamos até agora, uma possibilidade seria alguém do time entrar todos os dias no Databricks e iniciar o processamento manualmente: executar uma etapa, aguardar, executar a próxima e assim sucessivamente, até chegar ao resultado final. Para desenvolvimento, isso pode ser suficiente. Porém, depender diariamente de uma pessoa para executar o processo é inviável no dia a dia de empresas.

Assim, encontramos a primeira lacuna: a execução automática. Há ainda outro ponto: as etapas possuem uma ordem — bronze (bronze), silver (prata) e gold (ouro). Precisamos garantir orquestração, reexecução confiável e prontidão para produção. É isso que vamos endereçar a partir de agora.

Controlando dependências, ordem e falhas de execução

Há uma ordem específica de execução: não podemos executar a camada gold (ouro) sem ter executado a silver (prata), e não podemos executar a silver (prata) sem ter uma bronze (bronze). Existe, portanto, uma sequência exata a ser seguida. Não basta simplesmente executarmos três notebooks (cadernos de códigos). Há dependência entre as tarefas.

Agora, imagine que a bronze (bronze) falhou. Faz sentido continuarmos executando a silver (prata)? E, se a silver (prata) falhar, faz sentido executarmos a gold (ouro) mesmo assim? Devemos publicar uma gold (ouro) sabendo que a silver (prata) falhou? Provavelmente não. Identificamos, então, outra necessidade: precisamos controlar a ordem e a dependência das tarefas.

Até aqui, consideramos que tudo funcionaria, mas, em produção, nem sempre tudo funciona o tempo todo. Em algum momento, uma execução pode falhar, o que pode causar desespero. Podem ocorrer problemas durante a transformação; pode haver indisponibilidade das plataformas; podem surgir erros na nossa lógica, em geral, em algo que desenvolvemos. Quando isso acontece, precisamos responder a algumas perguntas:

  • Qual etapa falhou?
  • Quando falhou?
  • Qual foi o tipo de erro?
  • Precisamos executar todo o pipeline (fluxo de processamento) novamente ou podemos executar apenas a etapa específica?
  • Como sabemos se a gold (ouro) disponível foi gerada hoje ou se pertence à última execução bem-sucedida?

São pontos importantes para compreendermos. Saímos da pergunta básica “o pipeline (fluxo de processamento) está pronto e funcionando?” e passamos a questões mais aprofundadas, entendendo melhor o contexto. Essas questões não se relacionam apenas a transformar dados; começamos, de fato, a falar sobre um pipeline (fluxo de processamento).

Há ainda um detalhe importante. Imagine que ontem o nosso pipeline (fluxo de processamento) executou corretamente e produziu a camada gold (ouro). Hoje, ele executa novamente, mas a silver (prata) falha. O que acontece com a gold (ouro) que já existia? Ela não desaparece simplesmente porque a execução de hoje falhou. Alguém pode consultar aquela tabela e encontrar dados, mas esses dados podem corresponder à última publicação bem-sucedida e não necessariamente ao processamento que deveria ter acontecido hoje. Por isso, em produção, não queremos apenas saber se existe um resultado. Queremos ter evidência de que a publicação esperada realmente aconteceu.

Diagnosticando o fluxo

Vamos fazer um diagnóstico, observando o nosso fluxo.

O que nós já temos:

  • Um pipeline (fluxo de processamento) organizado seguindo a nossa arquitetura medalhão.
  • Tabelas Delta.
  • Ingestão incremental, utilizando o Auto Loader (carregador automático).
  • Checkpointing (ponto de verificação) que mantém o progresso da ingestão.

Nosso ponto de partida está muito bom; é um ponto de partida interessante.

O que ainda não temos:

  • Automação: o pipeline (fluxo de processamento) ainda depende de execução manual.
  • Dependências formalizadas: a sequência entre as tarefas ainda é gerenciada pelo processo manual; não formalizamos que só podemos executar a silver (prata) se existir a bronze (bronze), e que só podemos executar a gold (ouro) se a silver (prata) tiver sido concluída.
  • Agendamento: não definimos quando o pipeline (fluxo de processamento) deve ser executado automaticamente.
  • Monitoramento: não temos acompanhamento estruturado do histórico de execuções; executamos o notebook (caderno de códigos), vemos o resultado e paramos por aí.
  • Recuperação de falhas: precisamos definir como vamos atuar se uma das etapas falhar.
  • Evidência de publicação: precisamos verificar, de forma confiável, se o resultado esperado foi realmente atualizado.

Vimos o que já temos — um ótimo ponto de partida e um projeto funcional —, porém ainda há muito a evoluir para falar de um ambiente de produção utilizado em empresas. Podemos dizer que o nosso pipeline (fluxo de processamento) funciona? Sim. Ele é funcional: recebemos os dados, transformamos e produzimos um resultado. Mas ele está pronto para produção? Ainda não. Essa diferença é o ponto de partida do nosso curso.

Evoluindo para produção

Ao longo deste curso, continuaremos trabalhando com o pipeline (fluxo de processamento) que já construímos, mas algumas partes vão evoluir. Vamos reorganizar etapas e adaptar processamentos para permitir uma operação mais segura. Vamos adicionar componentes que não eram necessários quando o foco era apenas a construção de Lakehouse (arquitetura de dados unificada), mas que agora se tornam necessários. Não estamos começando um novo projeto; estamos partindo do que já tínhamos e elevando o nível de maturidade desse projeto. Essa é a mudança de perspectiva que queremos que você leve deste vídeo.

Quando desenvolvemos pipelines (fluxos de processamento), normalmente a primeira preocupação é “o código funciona”. Ao falar de produção, essa deixa de ser a única preocupação e passa a ser insuficiente. Também precisamos perguntar como esse pipeline (fluxo de processamento) será executado, como vamos acompanhar as execuções, o que acontece quando ele falha e como garantimos que continue sustentável conforme o fluxo de dados evolui.

Nos próximos vídeos, vamos transformar essas perguntas em decisões de engenharia. Mas, antes de automatizar o pipeline (fluxo de processamento), precisamos entender melhor por que essas preocupações aparecem, ou seja, o que realmente muda quando o pipeline (fluxo de processamento) sai do ambiente de desenvolvimento e passa a operar em produção. É isso que vamos discutir no próximo vídeo.

Eu te vejo lá! [♪]

Preparando um pipeline para produção - O que muda quando um pipeline vai para produção

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á!

Sobre o curso Databricks: automatizar e operar pipelines em produção

O curso Databricks: automatizar e operar pipelines em produção possui 292 minutos de vídeos, em um total de 60 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 um pipeline para produção
  • Automatizando o pipeline
  • Monitorando e resolvendo problemas
  • Segurança e governança
  • Tornando o pipeline sustentável

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