Como criar um Notebook Spark Job em Microsoft Fabric: passo a passo

João Barros 13 de August de 2026 5 min de leitura

Este tutorial mostra como criar um Notebook e publicar‑o como Spark Job em Microsoft Fabric para agendar execução recorrente de PySpark. É útil para automatizar ETL/ELT, transformações e pipelines sem intervenção manual — por exemplo, processar 1–10 GB de ficheiros diários ou agregar milhões de linhas para relatórios. Vou explicar o porquê das escolhas e dar exemplos concretos para testes e produção.

Pré‑requisitos

Conta com acesso a um workspace no Microsoft Fabric com permissões de autor (ou superiores).
Um Lakehouse ou OneLake para ler/escrever ficheiros (ex.: CSV/Parquet). Idealmente tens uma pasta para raw e outra para processed.
Conhecimentos básicos de Python/PySpark e do ambiente de Notebooks do Fabric. Saber interpretar logs e métricas de execução é uma mais‑valia.

Passo 1: Criar um novo Notebook no workspace

Abre o teu workspace no Microsoft Fabric e cria um novo Notebook. Escolhe o kernel PySpark adequado: Serverless Spark para cargas pequenas/ocasional ou um Spark Pool associado ao Warehouse/Lakehouse para cargas maiores. Dá um nome identificável, por exemplo: process_sales_notebook, junto com uma descrição breve: "Agrega vendas diárias". Mantém um standard de nomes (prefixo, propósito, ambiente) para gerir múltiplos jobs facilmente.

Passo 2: Escrever código PySpark mínimo e pronto para produção

Escreve código que leia dados do Lakehouse, faça uma transformação simples e grave o resultado. Mantém o código modular e com caminhos relativos a OneLake/Lakehouse para portabilidade entre dev e prod. Exemplos de boas práticas: validação de esquema, partição por data e uso de coalesce ao gravar para controlar número de ficheiros.

from pyspark.sql import functions as F

# Caminhos no OneLake/Lakehouse
input_path = 'one:///lakehouse/sales/raw/sales.csv'
output_path = 'one:///lakehouse/sales/processed/sales_agg.parquet'

# Ler CSV (ajusta opções conforme necessário)
df = spark.read.option('header', 'true').option('inferSchema', 'true').csv(input_path)

# Exemplo de transformação: agregação por dia
df2 = (df
  .withColumn('date', F.to_date('order_date'))
  .groupBy('date')
  .agg(F.sum(F.col('amount')).alias('total_amount'), F.count('*').alias('orders'))
)

# Gravar em Parquet (substituir)
df2.write.mode('overwrite').parquet(output_path)

Para datasets maiores, considera particionar por date e usar repartition(10) ou um número de partições equivalente ao número de cores disponíveis (ex.: 8–32). Se processares 5 GB diariamente, 8–16 cores são frequentemente suficientes para manter tempos de execução abaixo de 10–20 minutos, dependendo das transformações.

Passo 3: Testar o Notebook manualmente

Executa as células no Notebook para validar que o código corre sem erros e que os ficheiros são lidos/escritos no OneLake/Lakehouse. Testa com um subconjunto de 1–10% dos dados para reduzir tempo e custo. Corrige problemas comuns: credenciais, caminhos, opções de leitura (delimiter/header), permissões e incompatibilidades de tipo (string vs numeric).

Passo 4: Ajustar configurações para execução como Spark Job

Antes de publicar, certifica‑te que o Notebook não depende de variáveis interativas. Substitui valores hardcoded por parâmetros quando necessário. No topo do Notebook, adiciona um bloco para ler parâmetros quando executado como job. Isto permite reutilizar o mesmo Notebook entre ambientes (dev/prod) e datasets diários.

import os
# Parâmetros com valores por defeito
input_path = os.environ.get('INPUT_PATH', input_path)
output_path = os.environ.get('OUTPUT_PATH', output_path)

Verifica também o kernel e a versão de Spark pretendida. Confirma dependências (bibliotecas externas) e adiciona instruções para instalá‑las no ambiente do job se necessário.

Passo 5: Publicar o Notebook como Spark Job

No menu do Notebook, escolhe "Publish as Spark Job" (Publicar como Spark Job). Define um nome de Job, a descrição e escolhe o bundle do Notebook. Configura o tipo de cluster (Serverless Spark ou um Spark Pool/ Warehouse) e a dimensão (CPU/memória). Exemplo: para 5 GB diários, escolhe 8 cores e 32 GB RAM; para cargas pequenas usa 2 cores e 8 GB. Estas escolhas impactam diretamente o custo e tempo de execução.

Passo 6: Definir parâmetros e variáveis do Job

Na configuração do Spark Job, adiciona parâmetros de ambiente ou argumentos que o Notebook espera (por exemplo INPUT_PATH, OUTPUT_PATH). Isto torna o job reutilizável para diferentes ambientes (dev/prod) e datas. Usa convenções de nomes e inclui valores por defeito para testes rápidos.

{
  "INPUT_PATH": "one:///lakehouse/sales/raw/sales_2026-08-01.csv",
  "OUTPUT_PATH": "one:///lakehouse/sales/processed/sales_2026-08-01.parquet"
}

Passo 7: Agendar e configurar retries/alertas

Na secção de scheduling do Spark Job, cria uma recurrence (diária, horária ou CRON). Por exemplo, usa daily at 02:00 UTC para cargas noturnas. Define políticas de retry (ex.: 3 tentativas com backoff exponencial) e notificações (e‑mail ou integração com ferramentas de monitorização). Confirma o timezone e janela de execução para evitar sobreposição com outras janelas de manutenção.

Verificar o resultado

Depois da execução do Spark Job, verifica: 1) o estado do Job no painel de Jobs (Succeeded/Failed), 2) logs do run para mensagens, número de tasks e tempo de execução (por exemplo: 12 min, 8 executors), 3) presença e integridade do ficheiro de saída em OneLake/Lakehouse. Abre o Parquet com um Notebook ou usa a vista do Lakehouse para confirmar schema e contagens (count() / sample()).

Conclusão

Agora tens um Notebook transformado em Spark Job no Microsoft Fabric, pronto a correr de forma automática com parâmetros e agendamento. Próximos passos recomendados: adicionar testes unitários de dados, usar secrets para credenciais, versionar Notebooks e integrar com um Pipeline para orquestração. Dica prática: começa por agendar runs reduzidos (amostra de 1%) para validar custos e performance antes de passares para produção completa.