Otimizar tabelas Lakehouse com base em verificações de saúde

Aplica-se a: ✅ endpoint de análise SQL em Microsoft Fabric

Neste tutorial, aprende a construir um Microsoft Fabric Pipeline para realizar manutenção inteligente de tabelas.

Esta solução chama o procedimento armazenado T-SQL sys.sp_get_table_health_metrics no endpoint de análise SQL do Lakehouse, avalia o resultado e executa OPTIMIZE apenas quando a tabela realmente precisa de manutenção. Este padrão de "verificar e depois agir" evita gastos computacionais desnecessários em tabelas saudáveis, garantindo ao mesmo tempo que as tabelas degradadas são mantidas automaticamente.

Por que a manutenção é necessária

As tabelas Lakehouse podem acumular demasiados ficheiros pequenos de Parquet ao longo do tempo, o que prejudica o desempenho das consultas no endpoint de análise SQL.

Em vez de correr OPTIMIZE num calendário fixo independentemente do estado da tabela, este pipeline toma uma decisão informada: verifica primeiro a saúde da tabela e só ativa a otimização quando é detetada uma anomalia.

Pré-requisitos

Antes de começar, certifique-se de que tem:

• Um espaço de trabalho Microsoft Fabric com permissões de contribuidor ou superiores.
• Um Lakehouse nesse espaço de trabalho que contenha pelo menos uma tabela Delta que pretende monitorizar. Este tutorial utiliza um Lakehouse denominado SalesDataLakehouse.
• Familiaridade com pipelines de dados Fabric.
• Familiaridade com os notebooks do Fabric.

Estrutura da solução

O oleoduto concluído tem esta estrutura:

1. Atividade de script: Executa sp_get_table_health_metrics contra a tabela alvo e devolve métricas de saúde da tabela como saída estruturada.
2. Se for atividade de condição: Lê PotentialAnomalyType diretamente da saída do Script e verifica se é maior que zero. Para mais informações sobre o PotentialAnomalyType, veja Códigos de tipo de anomalia potencial.
3. Atividade do bloco de notas (dentro da ramificação True): Executa OPTIMIZE na tabela a partir de um bloco de notas do Spark.

No final deste tutorial, terás um caderno que recolhe parâmetros do pipeline e otimiza uma tabela quando é ativado.

Passo 1: Criar o caderno de otimização

O caderno recebe o Lakehouse de destino, o esquema e o nome da tabela como parâmetros a partir do pipeline e, em seguida, executa OPTIMIZE com o Spark SQL.

1. No seu espaço de trabalho Fabric, selecione + Novo item>Caderno.
2. Dê o nome de Optimize-Table ao caderno.
3. Em Localização, selecione o Lakehouse onde estão armazenadas as tabelas que selecionar. Este exercício utiliza um Lakehouse com o nome SalesDataLakehouse.
4. Selecione Criar.

Adicionar a célula de parâmetros

A primeira célula define as variáveis que o pipeline substitui em tempo de execução.

1. Na primeira célula, introduza os seguintes parâmetros. Os valores não são importantes e o processo substitui-os em tempo de execução.

   # Parameters 
   lakehouse_name = "<LakehouseName>"
   schema_name    = "<SchemaName>"
   table_name     = "<TableName>"
   

   Importante

   Como funciona a parametrização nos notebooks Fabric: Em tempo de execução, o Fabric injeta uma nova célula imediatamente após a célula de parâmetros que reatribui estas variáveis com os valores passados pelo pipeline. Os valores que definiste aqui apenas inicializam as variáveis e melhoram a legibilidade.

2. Selecione o menu de células (...) >Alterne a célula de parâmetros para marcar esta célula como uma célula de parâmetro.

Adicionar a célula OPTIMIZE

O OPTIMIZE comando é um comando SQL da Spark, não um comando T-SQL. Deve executá-lo em ambientes Spark como cadernos, definições de funções Spark ou a interface de Manutenção Lakehouse. O endpoint de análise SQL e o editor de consultas SQL do Warehouse não suportam este comando diretamente.

1. Na segunda célula, introduza:

   full_name = f"{lakehouse_name}.{schema_name}.{table_name}"
   print(f"Optimizing {full_name} ...")
   
   result = spark.sql(f"OPTIMIZE {full_name}")
   result.show(truncate=False)
   

2. Adicione células Markdown conforme necessário para documentar corretamente o caderno para outros utilizadores. O seu caderno finalizado deverá ser algo assim:

   

Passo 2: Criar a canalização

1. No seu espaço de trabalho do Fabric, selecione + Novo item>Pipeline.

2. Nomeie o pipeline como Tabela de Verificação e Otimização.

3. Seleciona o fundo do pipeline canvas e depois abre o separador Parâmetros . Adicione três parâmetros:

   Nome	Tipo	Valor predefinido
   lakehouse_name	String	SalesDataLakehouse
   schema_name	String	dbo
   table_name	String	FactSales

Passo 3: Adicionar a atividade de Script

A atividade Script executa sys.sp_get_table_health_metrics no endpoint de análise SQL e captura o resultado.

1. No separador Activities, selecione Script para adicioná-lo à área de trabalho.
2. Dá-lhe o nome Verificar o Estado da Tabela.
3. No separador Definições :

   • Ligação: Selecione o endpoint de análise SQL para o seu Lakehouse. Se não estiver listado, selecione Explorar tudo na parte inferior da lista pendente e, em seguida, localize o endpoint de análise SQL do seu Lakehouse.

   • Tipo de script: Selecionar Consulta.

   • Script: Selecione Adicionar conteúdo dinâmico e introduza a seguinte expressão:

     @concat('EXEC sys.sp_get_table_health_metrics ''',
             pipeline().parameters.schema_name, '.',
             pipeline().parameters.table_name, '''')
     

Esta expressão produz o comando SQL que executa o procedimento armazenado contra a sua tabela alvo, por exemplo: EXEC sys.sp_get_table_health_metrics 'dbo.FactSales'.

Verificar a saída do script

Execute o pipeline uma vez e inspecione o resultado da atividade Script. Vê um objeto JSON semelhante a:

{
  "resultSetCount": 1,
  "resultSets": [
    {
      "rowCount": 1,
      "rows": [
        {
          "PotentialAnomalyType": 3,
          "PotentialAnomalyDescription": "Too many small files...",
          "FileCount": 2688,
          "...": "..."
        }
      ]
    }
  ]
}

Passo 4: Adicionar a atividade Condição Se

A atividade Condição If lê PotentialAnomalyType diretamente da saída da atividade Script e toma uma decisão com base no respetivo resultado. Utilize os passos seguintes:

1. No separador Atividades, selecione If Condition para adicionar uma atividade na área de desenho.

2. Dá-lhe o nome de Check Anomaly.

3. Desenhe uma seta de êxito (verde) de Verificar o estado da tabela para Verificar anomalias.

4. No separador Atividades da atividade Condição Se, defina a Expressão como:

   @greater(int(activity('Check Table Health').output.resultSets[0].rows[0]['PotentialAnomalyType']), 0)
   

Esta expressão lê a primeira linha devolvida por sys.sp_get_table_health_metrics, converte PotentialAnomalyType num inteiro e avalia para true quando o valor é superior a zero, o que indica uma anomalia detetada na tabela de destino.

Passo 5: Adicionar a atividade Bloco de notas (ramo Verdadeiro)

Com a atividade Condição Se selecionada, selecione Editar (ícone de lápis) ao lado de Verdadeiro. A área de desenho muda para uma subárea de desenho limitada ao ramo True.

1. Arrasta uma atividade Notebook para o subcanvas True.

2. Chama-lhe Run OPTIMIZE.

3. Na guia Configurações:

   • Caderno: Selecione o caderno Optimize-Table que criou no Passo 1.

   • Expanda os parâmetros base, depois adicione três linhas:

     Nome	Tipo	Valor
     lakehouse_name	String	@pipeline().parameters.lakehouse_name
     schema_name	String	@pipeline().parameters.schema_name
     table_name	String	@pipeline().parameters.table_name

Os três valores das colunas de nome devem corresponder exatamente aos nomes das variáveis na célula de parâmetros do caderno.

O seu pipeline concluído deve ter o seguinte aspeto:

Passo 6: Validar e executar

1. Selecione Validar na barra de ferramentas do pipeline para verificar erros de configuração.

2. Selecione Executar para executar manualmente o pipeline.

3. Monitorize a execução e confirme:

   1. Verifique o estado da tabela: inspecione a saída desta atividade quando esta atividade é executada. Deverias ver a saída do sys.sp_get_table_health_metrics procedimento armazenado em formato JSON.
   2. Check Anomaly: avalia corretamente lendo PotentialAnomalyType diretamente da saída do Script.
   3. Run OPTIMIZE (apenas se PotentialAnomalyType > 0): se a atividade Check Anomaly avaliar True, verifique a entrada da atividade Run OPTIMIZE para confirmar que utiliza os parâmetros corretos (nome do Lakehouse, esquema e nome da tabela) e verifique a saída para analisar as mensagens da operação OPTIMIZE.

Limpeza de recursos

Se criou recursos apenas para este tutorial e já não precisa deles, elimine os seguintes itens do seu espaço de trabalho:

• O pipeline de Tabela de Verificação e Otimização .
• O bloco de notas Optimize-Table.

Conteúdo relacionado

• sp_get_table_health_metrics (Transact-SQL)
• Diretrizes de desempenho no Fabric Data Warehouse