Desenvolver, executar e gerir notebooks do Microsoft Fabric

Um notebook Microsoft Fabric é um item de código primário para o desenvolvimento de trabalhos do Apache Spark e experimentos de aprendizado de máquina. É uma superfície interativa baseada na Web usada por cientistas de dados e engenheiros de dados para escrever código, beneficiando-se de visualizações ricas e texto Markdown. Este artigo explica como desenvolver notebooks com operações em células de código e executá-las.

Desenvolver cadernos

Os blocos de notas consistem em células, que são blocos individuais de código ou texto que podem ser executados independentemente ou em grupo.

Fornecemos funcionalidades avançadas para criar notebooks.

• Adicionar uma célula
• Definir um idioma principal
• Usar vários idiomas
• IntelliSense no estilo IDE
• Fragmentos de código
• Arrastar e soltar para inserir trechos
• Arrastar e soltar para inserir imagens
• Formatar célula de texto com botões da barra de ferramentas
• Desfazer ou refazer operação na célula
• Mover uma célula
• Excluir uma célula
• Recolher uma entrada na célula
• Recolher o resultado de uma célula
• Segurança de saída de energia
• Bloquear ou congelar uma célula
• Conteúdo do caderno
• Recolhimento de Markdown
• Localizar e substituir

Adicionar uma célula

Existem várias formas de adicionar uma nova célula ao seu bloco de notas.

1. Passe o cursor sobre o espaço entre duas células e selecione Código ou Markdown.

2. Use teclas de atalho no modo de comando. Pressione A para inserir uma célula acima da célula atual. Pressione B para inserir uma célula abaixo da célula atual.

Definir um idioma principal

Atualmente, os notebooks do Fabric suportam quatro linguagens do Apache Spark.

• PySpark (Python)
• Faísca (Scala)
• Spark SQL
• SparkR

Você pode definir o idioma principal para células recém-adicionadas a partir da lista suspensa na barra de comandos superior.

Usar vários idiomas

Você pode usar vários idiomas em um bloco de anotações especificando o comando language magic no início de uma célula. Você também pode alternar o idioma da célula a partir do seletor de idiomas. A tabela a seguir lista os comandos mágicos para alternar idiomas de células.

IntelliSense ao estilo IDE

Os notebooks Fabric são integrados com o editor Monaco para trazer IntelliSense ao estilo do IDE para o editor de células. Realce de sintaxe, marcador de erro e conclusão automática de código ajudam você a escrever código rapidamente e identificar problemas.

Os recursos do IntelliSense estão em diferentes níveis de maturidade para diferentes idiomas. A tabela a seguir mostra o que o Fabric suporta:

Melhore o desenvolvimento Python com o Pylance

O Pylance, um servidor de idiomas poderoso e rico em recursos, agora está disponível no notebook Fabric. O Pylance facilita o desenvolvimento em Python com completações inteligentes, melhor deteção de erros e insights de código aprimorados. As principais melhorias incluem preenchimento automático mais inteligente, suporte aprimorado a lambda, sugestões de parâmetros, informações de foco aprimoradas, melhor renderização de docstring e realce de erros. Com o Pylance, escrever código Python e PySpark torna-se mais rápido, preciso e eficiente.

Fragmentos de código

Os blocos de anotações de malha fornecem trechos de código que ajudam você a escrever facilmente padrões de código comumente usados, como:

• Lendo dados como um Apache Spark DataFrame
• Desenhando gráficos com Matplotlib

Fragmentos de código aparecem em teclas de atalho do estilo IDE IntelliSense misturados com outras sugestões. O conteúdo do trecho de código é alinhado com a linguagem da célula de código. Você pode ver os trechos disponíveis digitando Snippet. Você também pode digitar qualquer palavra-chave para ver uma lista de trechos relevantes. Por exemplo, se você digitar ler, verá a lista de trechos para ler dados de várias fontes de dados.

Arrastar e soltar para inserir trechos

Utilize arrastar e largar para ler dados do Lakehouse explorer de forma conveniente. Vários tipos de arquivo são suportados aqui; Você pode operar em arquivos de texto, tabelas, imagens, etc. Você pode soltar para uma célula existente ou para uma nova célula. O notebook gera o trecho de código para pré-visualizar os dados.

Arrastar e soltar para inserir imagens

Use o recurso de arrastar e soltar para inserir facilmente imagens do seu navegador ou computador local em uma célula de marcação.

Formatar célula de texto com botões da barra de ferramentas

Para concluir ações comuns de marcação, use os botões de formatação na barra de ferramentas da célula de texto.

Desfazer ou refazer ações na célula

Selecione Undo ou Redo, ou pressione Z ou Shift+Z para anular as operações de células mais recentes. Você pode desfazer ou refazer até 10 das operações de células mais recentes.

Operações de desfazer célula suportadas:

• Inserir ou excluir célula. Você pode reverter as operações excluídas selecionando Desfazer (o conteúdo textual é mantido junto à célula).
• Reordenar célula.
• Alternar parâmetro.
• Converter entre célula de código e célula de Markdown.

Mover uma célula

Pode arrastar a partir da parte vazia de uma célula e soltá-la na posição desejada.

Pode também mover a célula selecionada usando Move up e Move down no friso.

Excluir uma célula

Para excluir uma célula, selecione o botão Excluir no lado direito da célula.

Você também pode usar teclas de atalho no modo de comando. Pressione D,D (D duas vezes) para eliminar a célula atual.

Recolher a entrada de uma célula

Selecione as reticências Mais comandos (...) na barra de ferramentas da célula e Ocultar entrada para ocultar a entrada da célula atual. Para expandi-la novamente, selecione Mostrar entrada quando a célula estiver colapsada.

Recolher o resultado de uma célula

Selecione as reticências Mais comandos (...) na barra de ferramentas da célula e Ocultar saída para ocultar a saída da célula atual. Para expandi-lo novamente, selecione Mostrar saída quando a saída da célula estiver recolhida.

Segurança da saída da célula

Você pode usar as funções de acesso a dados do OneLake (pré-visualização) para configurar o acesso a apenas pastas específicas em um lakehouse durante consultas de notebooks. Os usuários sem acesso a uma pasta ou tabela veem um erro não autorizado durante a execução da consulta.

Bloquear ou congelar uma célula

As operações de bloqueio e congelamento de células permitem que torne as células somente leitura ou impeça a execução das células de código individualmente.

Mesclar e dividir células

Você pode usar Mesclar com a célula anterior ou Mesclar com a próxima célula para mesclar células relacionadas convenientemente.

Selecionar Dividir célula ajuda a dividir instruções irrelevantes em várias células. A operação divide o código de acordo com a posição da linha do cursor.

Conteúdo do caderno

Selecionar Resumos ou Índice apresenta o primeiro cabeçalho markdown de qualquer célula markdown numa janela lateral para uma navegação rápida. A barra lateral Contornos é redimensionável e colapsável para se ajustar à tela da forma mais eficaz. Selecione o botão Conteúdo na barra de comandos do bloco de notas para abrir ou ocultar a barra lateral.

Recolhimento de Markdown

A opção de recolhimento do markdown permite-lhe ocultar células sob uma célula markdown que contém um cabeçalho. A célula Markdown e as suas células ocultas são tratadas da mesma forma que um conjunto de células multi-selecionadas contíguas ao realizar operações de células.

Localizar e substituir

A opção localizar e substituir pode ajudá-lo a encontrar e localizar as palavras-chave ou expressões no conteúdo do seu bloco de notas. Você também pode facilmente substituir a cadeia de caracteres de destino por uma nova cadeia de caracteres.

Copilot autocompletar código em linha (pré-visualização)

A função de preenchimento de código em linha do Copilot é um recurso impulsionado por IA que o ajuda a escrever código Python de forma mais rápida e eficiente nos Fabric Notebooks. Esse recurso fornece sugestões de código inteligentes e sensíveis ao contexto à medida que você digita código. Reduz tarefas repetitivas, minimiza erros de sintaxe e acelera o desenvolvimento, integrando-se perfeitamente no fluxo de trabalho do seu bloco de notas.

Principais benefícios

• Conclusão orientada por IA: Gera sugestões com base no contexto do seu bloco de anotações usando um modelo treinado em milhões de linhas de código.
• Aumenta a produtividade: Ajuda a escrever funções complexas, reduz a codificação repetitiva e acelera a exploração de bibliotecas desconhecidas.
• Reduz erros: Minimiza erros de digitação e sintaxe com conclusões inteligentes e sensíveis ao contexto.
• Configuração mínima: Integrado em notebooks Fabric e não requer nenhuma instalação. Você pode apenas ativá-lo e começar a codificar.

Como funciona

Habilite sugestões de código em linha usando o botão na parte inferior do seu caderno.

À medida que você digita, as sugestões aparecem em texto cinza claro, pressione Tab para aceitar ou modificar. As sugestões baseiam-se em células anteriores do bloco de notas.

Limitações atuais

• Copilot Inline Code Completion atualmente suporta a linguagem Python e usa contexto de células anteriores e esquemas Lakehouse.
• As sugestões consideram dados de esquemas Lakehouse.
• Somente um subconjunto de elementos de esquema é usado quando há muitas tabelas ou colunas.
• As tabelas criadas dinamicamente (via Spark) não são reconhecidas em tempo real.

Executar cadernos

Pode executar as células de código no seu bloco de notas individualmente ou todas de uma só vez. O estado e o progresso de cada célula são apresentados no bloco de notas.

Executar uma célula

Há várias maneiras de executar o código em uma célula.

• Passe o cursor sobre a célula que deseja executar e selecione o botão Executar célula ou pressione Ctrl+Enter.

• Use teclas de atalho no modo de comando. Pressione Shift+Enter para executar a célula atual e selecionar a próxima célula. Pressione Alt+Enter para executar a célula atual e inserir uma nova célula.

Executar todas as células

Selecione o botão Executar tudo para executar todas as células do bloco de anotações atual em sequência.

Executar todas as células acima ou abaixo

Expanda a lista suspensa de Executar tudo e selecione Executar células acima para executar em sequência todas as células acima da célula atual. Selecione Executar células abaixo para executar a célula atual e todas as células abaixo desta, em sequência.

Cancelar todas as células em execução

Selecione Cancelar tudo para cancelar as células em execução ou as células que aguardam na fila.

Parar sessão

Parar sessão cancela as células em execução e as que estão em espera e interrompe a sessão atual. Você pode reiniciar uma nova sessão selecionando a opção de execução novamente.

Teste de referência

Executar uma referência de notebook computacional

Além de usar a API de execução de referência do notebookutils, pode-se também utilizar o comando mágico para referir outro bloco de anotações dentro do contexto do bloco de anotações atual. Todas as variáveis definidas no bloco de notas de referência estão disponíveis no bloco de notas atual. O %run comando magic suporta chamadas aninhadas, mas não suporta chamadas recursivas. Você receberá uma exceção se a profundidade da instrução for maior que cinco.

Exemplo: %run Notebook1 { "parameterInt": 1, "parameterFloat": 2.5, "parameterBool": true, "parameterString": "abc" }.

A referência do notebook funciona no modo interativo e no modo pipeline.

Referência para executar um script

O %run comando também permite que você execute arquivos Python ou SQL que são armazenados nos recursos internos do notebook, para que você possa executar seus arquivos de código-fonte no notebook convenientemente.

%run [-b/--builtin -c/--current] [script_file.py/.sql] [variables ...]

Para opções:

• -b/--builtin: Esta opção indica que o comando localiza e executa o arquivo de script especificado a partir dos recursos nativos do caderno.
• -c/--current: Esta opção garante que o comando utiliza sempre os recursos incorporados do bloco de notas atual, mesmo que o bloco de notas atual seja referenciado por outros blocos de notas.

Exemplos:

• Para executar script_file.py a partir dos recursos internos: %run -b script_file.py

• Para executar script_file.sql a partir dos recursos internos: %run -b script_file.sql

• Para executar script_file.py a partir dos recursos internos com variáveis específicas: %run -b script_file.py { "parameterInt": 1, "parameterFloat": 2.5, "parameterBool": true, "parameterString": "abc" }

Exemplo de uso para caso de execução aninhado:

• Suponhamos que temos dois cadernos.
  • Notebook1: Contém script_file1.py em seus recursos internos
  • Notebook2: contém script_file2.py em seus recursos internos
• Vamos usar Notebook1 como um caderno raiz com o conteúdo: %run Notebook2.
• Em seguida, no Notebook2 a instrução de uso é:
  • Para executar script_file1.py noNotebook1 (o Notebook raiz), o código seria:
  • Para executar script_file2.py em Notebook2(o Notebook atual), o código seria: %run -b -c script_file2.py

Explorador de variáveis

Os notebooks Fabric fornecem um explorador de variáveis interno que exibe a lista de nomes, tipos, comprimentos e valores das variáveis na sessão atual do Spark para células PySpark. Mais variáveis aparecem automaticamente à medida que são definidas nas células de código. Clicar em cada cabeçalho de coluna classifica as variáveis na tabela.

Para abrir ou ocultar o explorador de variáveis, selecione Variáveis na faixa de opções Ver do bloco de notas.

Indicador de estado da célula

O estado de execução passo a passo de uma célula é exibido abaixo dela para ajudá-lo a acompanhar o seu progresso atual. Quando a execução da célula estiver concluída, um resumo de execução com a duração total e a hora de término aparecerá e será armazenado lá para referência futura.

Indicador de estado da sessão

Configuração de tempo limite da sessão

No canto inferior esquerdo, você pode selecionar o status da sessão para obter mais informações sobre a sessão atual:

No pop-up, há uma opção para redefinir o tempo limite para x minutos ou horas.

Escolha por quanto tempo deseja uma sessão ininterrupta e clique em aplicar. O tempo limite da sessão se redefine com o novo valor e você está pronto para ir!

Você também pode definir o tempo limite conforme descrito em:

• Configurações de administração do espaço de trabalho de Engenharia de Dados no Microsoft Fabric
• Comando mágico de configuração da sessão Spark

Permaneça conectado: Durante o início de sessão, se vir a caixa de diálogo Permanecer com sessão iniciada , selecione Sim para desativar o tempo limite da sessão inativa da sessão atual.

Solicite uma alteração de política: Se você precisar de uma duração de sessão mais longa, peça ao administrador do locatário para estender a política de duração do tempo limite da sessão ociosa. Eles podem fazer isso navegando até Configurações da > organização, Segurança e privacidade, > Tempo limite da sessão ociosa no Centro de Administração do Microsoft 365.

Como o ABT e o tempo limite de sessão inativa afetam as execuções prolongadas do Fabric Notebook?

Se o locatário usar o "tempo limite baseado em atividades (ABT)", os trabalhos interativos de longa duração em notebooks do Fabric poderão ser afetados pela política de tempo limite de sessão ociosa do Microsoft 365. Este recurso de segurança foi projetado para terminar a sessão dos utilizadores em dispositivos inativos e não geridos, mesmo que uma tarefa de notebook ainda esteja em execução. Enquanto a atividade em outros aplicativos do Microsoft 365 pode manter a sessão ativa, os dispositivos ociosos são desconectados por design.

Por que os utilizadores são desconectados enquanto uma tarefa de bloco de anotações ainda está em execução?

O tempo limite da sessão ociosa prioriza a segurança encerrando sessões em dispositivos inativos para impedir o acesso não autorizado. Mesmo quando uma execução de notebook está em andamento, a sessão termina se o dispositivo não mostrar nenhuma atividade. Manter as sessões abertas em dispositivos ociosos comprometeria a segurança, e é por isso que o comportamento atual é imposto.

Indicador de trabalho integrado do Apache Spark

Os notebooks Fabric são baseados no Apache Spark. As células de código são executadas no cluster Apache Spark remotamente. Um indicador de progresso de trabalho do Spark é fornecido com uma barra de progresso em tempo real que aparece para ajudá-lo a entender o status de execução do trabalho. O número de tarefas por cada trabalho ou estágio ajuda você a identificar o nível paralelo do seu trabalho do Spark. Pode também aprofundar-se na interface do utilizador do Spark de um trabalho (ou etapa) específico, selecionando o link no nome do trabalho (ou etapa).

Você também pode encontrar o log de nível de célula em tempo real ao lado do indicador de progresso, e Diagnósticos pode fornecer sugestões úteis para ajudar a refinar e depurar o código.

Em Mais ações, você pode navegar facilmente até a página de detalhes do aplicativo Spark e a página da interface do usuário da Web do Spark.

Redação secreta

Para evitar que as credenciais sejam vazadas acidentalmente ao executar blocos de anotações Fabric, os blocos de anotações suportam a redação de segredos para substituir os valores secretos exibidos na saída da célula por . A redação secreta é aplicável para Python, Scala e R.

Comandos mágicos num bloco de notas

Comandos mágicos integrados

Pode usar comandos mágicos familiares do IPython em cadernos Fabric. Analise a seguinte lista de comandos mágicos atualmente disponíveis.

Comandos mágicos de linha disponíveis: %lsmagic, %time, %timeit, %history, %run, %load, %alias, %alias_magic, %autoawait, %autocall, %automagic, %bookmark, %cd, %colors, %dhist, %dirs, %doctest_mode, %killbgscripts, %load_ext, %logoff, %logon, %logstart, %logstate, %logstop, %magic, %matplotlib, %page, %pastebin, %pdef, %pfile, %pinfo, %pinfo2, %popd, %pprint, %precision, %prun, %psearch, %psource, %pushd, %pwd, %pycat, %quickref, %rehashx, %reload_ext, %reset, %reset_selective, %sx, %system, %tb, %unalias, %unload_ext, %who, %who_ls, %whos, %xdel, %xmode.

O Fabric notebook também suporta os comandos aprimorados %pip de gerenciamento de biblioteca e %conda. Para obter mais informações sobre o uso, consulte Gerenciar bibliotecas do Apache Spark no Microsoft Fabric.

Comandos mágicos de célula disponíveis: %%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, %%spark, %%csharp, %%configure, %%html, %%bash, %%markdown, %%perl, %%script, %%sh.

Comandos mágicos personalizados

Você também pode criar mais comandos mágicos personalizados para atender às suas necessidades específicas. Eis um exemplo:

1. Crie um bloco de anotações com o nome "MyLakehouseModule".

   

2. Em outro notebook, faça referência ao "MyLakehouseModule" e seus comandos mágicos. Este processo é como você pode organizar convenientemente seu projeto com blocos de anotações que usam diferentes idiomas.

   

IPython Widgets

IPython Widgets são objetos Python interativos que têm uma representação no navegador. Você pode usar IPython Widgets como controles low-code (por exemplo, controle deslizante ou caixa de texto) em seu bloco de anotações, assim como o bloco de anotações Jupyter. Atualmente ele só funciona em um contexto Python.

Para usar IPython Widgets

1. Importe o módulo ipywidgets primeiro para usar a estrutura Jupyter Widget.

   import ipywidgets as widgets
   

2. Use a função display de nível superior para renderizar um widget ou deixe uma expressão do tipo widget na última linha da célula de código.

   slider = widgets.IntSlider()
   display(slider)
   

3. Executar a célula. O widget é exibido na área de saída.

   slider = widgets.IntSlider()
   display(slider)
   

   

4. Utilize várias chamadas de display() para renderizar a mesma instância de widget (componente) várias vezes. Eles permanecem em sincronia uns com os outros.

   slider = widgets.IntSlider()
   display(slider)
   display(slider)
   

   

5. Para renderizar dois widgets independentes um do outro, crie duas instâncias de widget:

   slider1 = widgets.IntSlider()
   slider2 = widgets.IntSlider()
   display(slider1)
   display(slider2)
   

   

Widgets suportados

Limitações conhecidas

• Os widgets a seguir ainda não são suportados. As seguintes soluções alternativas estão disponíveis:

  Funcionalidade	Solução
  Widget de saída	Você pode usar a função print() em vez disso para escrever texto no stdout.
  widgets.jslink()	Você pode usar a função widgets.link() para vincular dois widgets semelhantes.
  Widget FileUpload	Ainda não suportado.

• A função de exibição global do Fabric não suporta a exibição de vários widgets em uma chamada (por exemplo, display(a, b)). Esse comportamento é diferente da função de exibição IPython.

• Se você fechar um bloco de anotações que contém um widget IPython, não poderá ver ou interagir com ele até executar a célula correspondente novamente.

• A função interact (ipywidgets.interact) não é suportada.

Integrar um caderno

Designar uma célula de parâmetros

Para parametrizar o seu caderno, selecione as reticências (...) para aceder aos Mais comandos na barra de ferramentas da célula. Em seguida, selecione Alternar célula de parâmetro para designar a célula como a célula de parâmetros.

A célula de parâmetro é útil para integrar um notebook em um pipeline. A atividade do pipeline procura pela célula de parâmetros e trata essa célula como o padrão para os parâmetros passados no momento da execução. O mecanismo de execução adiciona uma nova célula abaixo da célula de parâmetros com parâmetros de entrada para substituir os valores padrão.

Atribuir valores aos parâmetros de um pipeline

Depois de criar um bloco de anotações com parâmetros, pode executá-lo a partir de um pipeline com a atividade do bloco de anotações Fabric. Depois de adicionar a atividade à tela do pipeline, pode definir os valores dos parâmetros na Base de parâmetros da guia Configurações.

Ao atribuir valores de parâmetro, pode-se usar a linguagem de expressão de pipeline ou funções e variáveis.

Os parâmetros do notebook suportam tipos simples, como int, float, boole string. Tipos complexos, como list e dict ainda não são suportados. Para passar um tipo complexo, considere serializá-lo para um formato de cadeia de caracteres (por exemplo, JSON) e, em seguida, desserializá-lo dentro do bloco de anotações. O exemplo a seguir mostra como passar uma cadeia de caracteres JSON do pipeline para o notebook e desserializá-la:

O código python a seguir demonstra como desserializar a cadeia de caracteres JSON em um dicionário Python:

import json

# Deserialize the JSON string into a Python dictionary
params = json.loads(json_string)

# Access the individual parameters
param1 = params.get("param1")
param2 = params.get("param2")

Verifique se o nome do parâmetro na célula de código do parâmetro corresponde ao nome do parâmetro no pipeline.

Comando mágico de configuração da sessão Spark

Pode personalizar a sua sessão do Spark com o comando magic %%configure. O notebook de Fabric suporta vCores personalizados, memória do driver e do executor, propriedades do Apache Spark, pontos de montagem, agrupamento e o lakehouse padrão da sessão do notebook. Podem ser utilizadas tanto em atividades de notebooks interativos quanto em atividades de notebooks de fluxo de trabalho. Recomendamos que execute o comando %%configure no início do seu bloco de notas ou tem de reiniciar a sessão do Spark para que as definições entrem em vigor.

%%configure
{
    // You can get a list of valid parameters to config the session from https://github.com/cloudera/livy#request-body.
    "driverMemory": "28g", // Recommended values: ["28g", "56g", "112g", "224g", "400g"]
    "driverCores": 4, // Recommended values: [4, 8, 16, 32, 64]
    "executorMemory": "28g",
    "executorCores": 4,
    "jars": ["abfs[s]: //<file_system>@<account_name>.dfs.core.windows.net/<path>/myjar.jar", "wasb[s]: //<containername>@<accountname>.blob.core.windows.net/<path>/myjar1.jar"],
    "conf":
    {
        // Example of customized property, you can specify count of lines that Spark SQL returns by configuring "livy.rsc.sql.num-rows".
        "livy.rsc.sql.num-rows": "3000",
        "spark.log.level": "ALL"
    },
    "defaultLakehouse": {  // This overwrites the default lakehouse for current session
        "name": "<lakehouse-name>",
        "id": "<(optional) lakehouse-id>",
        "workspaceId": "<(optional) workspace-id-that-contains-the-lakehouse>" // Add workspace ID if it's from another workspace
    },
    "mountPoints": [
        {
            "mountPoint": "/myMountPoint",
            "source": "abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>"
        },
        {
            "mountPoint": "/myMountPoint1",
            "source": "abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path1>"
        },
    ],
    "environment": {
        "id": "<environment-id>",
        "name": "<environment-name>"
    },
    "sessionTimeoutInSeconds": 1200,
    "useStarterPool": false,  // Set to true to force using starter pool
    "useWorkspacePool": "<workspace-pool-name>"
}

Você também pode usar o %%configure para injetar dinamicamente valores de configuração da Biblioteca de Variáveis no seu bloco de notas.

%%configure
{
  "defaultLakehouse": {
    "name": {
      "variableName": "$(/**/myVL/LHname)" 
    },
    "id": {
      "variableName": "$(/**/myVL/LHid)"
    },
    "workspaceId": {
      "variableName": "$(/**/myVL/WorkspaceId)"
    }
  }
}

Neste exemplo:

• myVL é o nome da sua Biblioteca de Variáveis.
• LHname, LHid, e WorkspaceId são chaves de variáveis definidas na biblioteca.
• Todas as variáveis devem ser definidas como tipo String na biblioteca de variáveis, mesmo para valores GUID.
• workspaceId é necessário quando o Lakehouse está num espaço de trabalho diferente do caderno atual.
• Esses valores são resolvidos em tempo de execução, dependendo do ambiente ativo (por exemplo, Dev, Test, Prod).

Isso permite que você alterne configurações como o lakehouse padrão sem modificar o código do seu notebook.

Configuração de sessão parametrizada a partir de um pipeline

A configuração de sessão parametrizada permite substituir o valor em %%configure magic pelos parâmetros da atividade do bloco de notas de execução do pipeline. Ao preparar %%configure célula de código, você pode substituir valores padrão (também configuráveis, 4 e "2000" no exemplo abaixo) por um objeto como este:

{
      "parameterName": "paramterNameInPipelineNotebookActivity",
      "defaultValue": "defaultValueIfNoParamterFromPipelineNotebookActivity"
} 

%%configure  

{ 
    "driverCores": 
    { 
        "parameterName": "driverCoresFromNotebookActivity", 
        "defaultValue": 4 
    }, 
    "conf": 
    { 
        "livy.rsc.sql.num-rows": 
        { 
            "parameterName": "rows", 
            "defaultValue": "2000" 
        } 
    } 
} 

Um notebook utiliza o valor padrão se for executado diretamente em modo interativo ou se a atividade do notebook no pipeline não fornecer nenhum parâmetro que corresponda a "activityParameterName."

Durante uma execução de pipeline, é possível configurar as definições de atividade do notebook de pipeline da seguinte forma:

Se desejar alterar a configuração da sessão, o nome dos parâmetros de atividade do notebook pipeline deve ser o mesmo que parameterName no notebook. Neste exemplo de execução de um pipeline, driverCores em %%configure são substituídos por 8 e livy.rsc.sql.num-rows são substituídos por 4000.

Registo de atividade em Python num caderno

Você pode encontrar logs Python e definir diferentes níveis de log e formato como o código de exemplo mostrado aqui:

import logging

# Customize the logging format for all loggers
FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
formatter = logging.Formatter(fmt=FORMAT)
for handler in logging.getLogger().handlers:
    handler.setFormatter(formatter)

# Customize log level for all loggers
logging.getLogger().setLevel(logging.INFO)

# Customize the log level for a specific logger
customizedLogger = logging.getLogger('customized')
customizedLogger.setLevel(logging.WARNING)

# logger that use the default global log level
defaultLogger = logging.getLogger('default')
defaultLogger.debug("default debug message")
defaultLogger.info("default info message")
defaultLogger.warning("default warning message")
defaultLogger.error("default error message")
defaultLogger.critical("default critical message")

# logger that use the customized log level
customizedLogger.debug("customized debug message")
customizedLogger.info("customized info message")
customizedLogger.warning("customized warning message")
customizedLogger.error("customized error message")
customizedLogger.critical("customized critical message")

Ver o histórico de comandos de entrada

O notebook Fabric suporta o comando mágico %history para imprimir o histórico dos comandos de entrada que foram executados na sessão atual, em comparação com o comando padrão do Jupyter IPython, que %history funciona em vários idiomas.

%history [-n] [range [range ...]]

Para opções:

• -n: Imprimir o número de execução.

Onde o intervalo pode ser:

• N: Código de impressão da célula N-ésima executada.
• M-N: Imprimir o código da Mth à Nth célula executada.

Exemplo:

• Imprimir o histórico de entrada desde a 1ª até à 2ª célula executada: %history -n 1-2

Teclas de atalho

Semelhante aos Jupyter Notebooks, os notebooks Fabric têm uma interface de usuário modal. O teclado faz coisas diferentes dependendo do modo em que a célula do notebook está. Os Fabric notebooks suportam os dois modos a seguir para uma determinada célula de código: Modo de Comando e Modo de Edição.

• Uma célula está no modo de comando quando não há nenhum cursor de texto solicitando que você digite. Quando uma célula está no modo de comando, você pode editar o bloco de anotações como um todo, mas não digitar em células individuais. Entre no modo de comando pressionando ESC ou usando o mouse para selecionar fora da área do editor de uma célula.

  

• O modo de edição pode ser indicado a partir de um cursor de texto que solicita que você digite na área do editor. Quando uma célula está no modo de edição, você pode digitar na célula. Entre no modo de edição pressionando Enter ou usando o mouse para selecionar a área do editor de uma célula.

  

Atalhos de teclas no modo de comando

Teclas de atalho no modo de edição

Usando os seguintes atalhos de teclado, pode-se navegar e executar código facilmente em notebooks Fabric quando em modo de edição.

Para localizar todas as teclas de atalho, selecione Ver no friso do bloco de notas e, em seguida, selecione Ligações de teclas.

Conteúdos relacionados

• Visualização do bloco de notas
• Introdução do Fabric NotebookUtils