Criar, desenvolver e manter notebooks Synapse no Azure Synapse Analytics

Um notebook Synapse é uma interface da web para você criar arquivos que contém códigos, visualizações e textos de narração em tempo real. Os notebooks são um bom lugar para validar ideias e fazer experimentos rápidos para obter insights de seus dados. Os notebooks também são amplamente usados na preparação e visualização de dados, no aprendizado de máquina e em outros cenários de Big Data.

Com um notebook Synapse, você pode:

• Começar a trabalhar com um mínimo de configuração.
• Manter os dados protegidos com recursos internos de segurança corporativa.
• Analisar dados em formatos brutos (CSV, txt, JSON, etc.), formatos de arquivo processados (Parquet, Delta Lake, ORC, etc.) e arquivos de dados tabulares do SQL em Spark e SQL.
• Seja produtivo com recursos de criação aprimorados e visualização de dados interna.

Este artigo descreve como usar notebooks no Synapse Studio.

Criar um notebook

Há dois modos de criar um notebook. Você pode criar um notebook ou importar um existente para um workspace do Synapse no Pesquisador de Objetos. Os notebooks Synapse podem reconhecer arquivos IPYNB padrão do Jupyter Notebook.

Desenvolver notebooks

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

Fornecemos operações avançadas para desenvolver notebooks:

• Adicionar uma célula
• Definir uma linguagem principal
• Usar vários idiomas
• Usar tabelas temporárias para fazer referência a dados entre linguagens
• IntelliSense de estilo IDE
• Snippets de código
• Formatar célula de texto com botões da barra de ferramentas
• Operação desfazer/refazer célula
• Comentário da célula de código
• Mover uma célula
• Excluir uma célula
• Recolher uma entrada de célula
• Recolher uma saída de célula
• Estrutura do notebook

Observação

Nos notebooks, há uma SparkSession criada automaticamente para você, armazenada em uma variável chamada spark. Além disso, há uma variável para SparkContext que é chamada de sc. Os usuários podem acessar essas variáveis diretamente e não devem alterar os valores dessas variáveis.

Adicionar uma célula

Há várias maneiras de adicionar uma nova célula ao notebook.

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

2. Use teclas de atalho aznb 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 uma linguagem principal

Os notebooks Synapse dão suporte a quatro linguagens do Apache Spark:

• PySpark (Python)
• Spark (Scala)
• Spark SQL
• .NET Spark (C#)
• SparkR (R)

Você pode definir a linguagem principal para novas células adicionadas na lista suspensa na barra de comandos superior.

Usar vários idiomas

Você pode usar várias linguagens em um notebook especificando o comando magic da linguagem correto no início de uma célula. A tabela a seguir lista os comandos magic para alternar entre linguagens de célula.

Comandos magic	Linguagem	Descrição
%%pyspark	Python	Execute uma consulta Python no contexto do Spark.
%%spark	Scala	Execute uma consulta Scala no contexto do Spark.
%%sql	SparkSQL	Execute uma consulta SparkSQL no contexto do Spark.
%%csharp	.NET para Spark C#	Execute uma consulta .NET para Spark C# no contexto do Spark.
%%sparkr	R	Execute uma consulta R no contexto do Spark.

A imagem a seguir é um exemplo de como você pode escrever uma consulta PySpark com o comando magic %%pyspark ou uma consulta SparkSQL com o comando magic %%sql em um notebook Spark (Scala) . Observe que a linguagem principal do notebook está definida como pySpark.

Usar tabelas temporárias para fazer referência a dados entre linguagens

Você não pode fazer referência a dados ou variáveis diretamente em linguagens diferentes em um notebook Synapse. No Spark, uma tabela temporária pode ser referenciada entre os idiomas. Aqui está um exemplo de como ler um dataframe Scala no PySpark e SparkSQL usando uma tabela temporária do Spark como solução alternativa.

1. Na célula 1, leia um dataframe do conector do pool de SQL usando o Scala e crie uma tabela temporária.

   %%spark
   val scalaDataFrame = spark.read.sqlanalytics("mySQLPoolDatabase.dbo.mySQLPoolTable")
   scalaDataFrame.createOrReplaceTempView( "mydataframetable" )
   

2. Na célula 2, consulte os dados com o Spark SQL.

   %%sql
   SELECT * FROM mydataframetable
   

3. Na célula 3, use os dados no PySpark.

   %%pyspark
   myNewPythonDataFrame = spark.sql("SELECT * FROM mydataframetable")
   

IntelliSense de estilo IDE

Os notebooks Synapse são integrados ao editor Monaco para colocar o IntelliSense de estilo IDE ao editor de célula. O realce de sintaxe, o marcador de erros e os preenchimentos de código automáticos ajudam você a codificar e identificar problemas mais rapidamente.

Os recursos do IntelliSense estão em níveis diferentes de maturidade para linguagens diferentes. Use a tabela a seguir para ver o que é suportado.

Languages	Realce da sintaxe	Marcador de erro de sintaxe	Conclusão de código de sintaxe	Conclusão de código de variável	Conclusão de código de função do sistema	Conclusão do código de função do usuário	Recuo Inteligente	Dobramento de código
PySpark (Python)	Sim	Yes	Yes	Yes	Yes	Yes	Yes	Sim
Spark (Scala)	Sim	Yes	Yes	Yes	Yes	Yes	-	Sim
SparkSQL	Sim	Yes	Yes	Yes	Sim	-	-	-
.NET para Spark (C#)	Sim	Yes	Yes	Yes	Yes	Yes	Yes	Yes

Observação

É necessário ter uma sessão ativa do Spark para beneficiar o Preenchimento do Código Variável, o Preenchimento do Código da Função do Sistema, o Preenchimento do Código da Função de Usuário para .NET para Spark (C#).

Snippets de código

Os notebooks Synapse fornecem trechos de código que facilitam a inserção de padrões de código usados comuns, como a configuração da sessão do Spark, a leitura de dados como um DataFrame do Spark ou desenhar gráficos com o matplotlib, etc.

Os trechos aparecem em Teclas de atalho do IntelliSense de estilo IDE misturados com outras sugestões. O conteúdo dos trechos de código é alinhado com a linguagem de célula de código. Você pode ver os trechos disponíveis digitando Trecho ou qualquer palavra-chave que aparece no título do trecho no editor de célula de códigos. Por exemplo, digitando read, você pode ver a lista de trechos para ler os dados de várias fontes de dados.

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

Você pode usar os botões de formatação da barra de ferramentas de células de texto para realizar ações de markdown comuns. Inclui texto em negrito, texto em itálico, parágrafos/cabeçalhos por meio de um menu suspenso, inserção de código, inserção de lista não ordenada, inserção de lista ordenada, inserção de hiperlink e inserção de imagem da URL.

---

Operação desfazer/refazer célula

Selecione o botão Desfazer / Refazer ou pressione Z / Shift+Z para revogar as operações de célula mais recentes. Agora você pode desfazer/refazer até as 10 últimas operações do histórico da célula.

Operações de desfazer célula com suporte:

• Célula Inserir/Excluir: você pode revogar as operações de exclusão selecionando Desfazer; o conteúdo do texto será mantido junto com a célula.
• Reordene a célula.
• Alternar parâmetro.
• Converter entre célula de Código e célula Markdown.

Observação

Operações de texto na célula e operações de comentário de célula de código não podem ser desfeitas. Agora você pode desfazer/refazer até as 10 últimas operações do histórico da célula.

---

Comentário da célula de código

1. Selecione o botão Comentários na barra de ferramentas do notebook para abrir o painel Comentários.

   

2. Selecione o código na célula de código, clique em Novo no painel Comentários, adicione comentários e clique no botão Postar comentário para salvar.

   

3. Você poderia executar Editar comando, Resolver thread ou Excluir thread ao clicar no botão Mais ao lado do seu comentário.

   

---

Mover uma célula

Clique no lado esquerdo de uma célula e arraste-a para a posição desejada.

---

Excluir uma célula

Para excluir uma célula, selecione o botão excluir à direita da célula.

Você também pode usar teclas de atalho no modo de comando. Pressione Shift + D para excluir a célula atual.

---

Recolher uma entrada de célula

Selecione as elipses Mais comandos (...) na barra de ferramentas da célula e Ocultar entrada para recolher a entrada da célula atual. Para expandi-la, selecione Mostrar entrada enquanto a célula estiver recolhida.

---

Recolher uma saída de célula

Selecione as elipses Mais comandos (...) na barra de ferramentas da célula e Ocultar entrada para recolher a saída da célula atual. Para expandi-la, selecione Mostrar saída enquanto a saída da célula estiver recolhida.

---

Estrutura do notebook

As Estruturas (Sumário) apresentam o primeiro cabeçalho de markdown de qualquer célula de markdown em uma janela da barra lateral para navegação rápida. A barra lateral de estruturas é redimensionável e recolhível para se ajustar à tela da melhor maneira possível. Você pode selecionar o botão Estrutura na barra de comandos do notebook para abrir ou ocultar a barra lateral

---

Executar notebooks

Você pode executar as células de código em seu notebook individualmente ou todas de uma vez. O status e o progresso de cada célula são representados no notebook.

Executar uma célula

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

1. Passe o mouse sobre a célula que você deseja executar e selecione o botão Executar Célula ou pressione Ctrl+Enter.

   

2. Use teclas de atalho no modo de comando. Pressione Shift+Enter para executar a célula atual e selecionar a célula abaixo. Pressione Alt+Enter para executar a célula atual e inserir uma célula abaixo.

---

Executar todas as células

Selecione o botão Executar Tudo para executar todas as células no notebook atual em sequência.

Executar todas as células acima ou abaixo

Expanda a lista suspensa do botão Executar tudo e selecione Executar células acima para executar todas as células acima da atual em sequência. Selecione Executar células abaixo para executar todas as células abaixo da atual em sequência.

---

Cancelar todas as células em execução

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

---

Referência de notebook

Você pode usar o comando mágico %run <notebook path> para fazer referência a outro notebook no contexto do notebook atual. Todas as variáveis definidas no bloco de anotações de referência estão disponíveis no notebook atual. O comando mágico %run dá suporte a chamadas aninhadas, mas não oferece suporte a chamadas recursivas. Você receberá uma exceção se a profundidade da declaração for maior que cinco.

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

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

Observação

• Atualmente, o comando %run só dá suporte para passar um caminho absoluto ou nome de notebook apenas como parâmetro, não há suporte para o caminho relativo.
• Atualmente, o comando %run só dá suporte a 4 tipos de valor de parâmetro: int, float, bool, string, não há suporte para a operação de substituição de variável.
• Os notebooks referenciados precisam ser publicados. É necessário publicar os notebooks para referenciá-los, a menos que o Referenciar notebook não publicado esteja habilitado. O Synapse Studio não reconhece os notebooks não publicados do repositório Git.
• Os notebooks referenciados não dão suporte à instrução que profundidade é maior que cinco.

---

Gerenciador de variáveis

O notebook Synapse fornece um gerenciador de variáveis incorporado para você ver a lista de nomes de variáveis, tipo, comprimento e valor na atual sessão Spark para células (Python) PySpark. Mais variáveis são mostradas 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.

Você pode selecionar o botão Variáveis na barra de comandos do notebook para abrir ou ocultar o explorador de variáveis.

Observação

O Explorador de Variáveis dá suporte apenas ao Python.

---

Indicador de status de célula

Um status de execução de célula passo a passo é exibido abaixo da célula para ajudá-lo a ver seu progresso atual. Depois que a execução da célula for concluída, um resumo de execução com a duração total e a hora de término serão mostrados e mantidos ali para referência futura.

Indicador de progresso do Spark

O notebook Synapse é baseado exclusivamente no Spark. As células de código são executadas remotamente no pool sem servidor do Apache Spark. Um indicador de progresso do trabalho do Spark é fornecido com uma barra de progresso em tempo real para ajudá-lo a entender o status de execução do trabalho. O número de tarefas de cada trabalho ou estágio ajuda a identificar o nível paralelo do seu trabalho do Spark. Você também pode analisar mais detalhadamente a interface do usuário do Spark de um trabalho (ou estágio) específico por meio da seleção do link no nome do trabalho (ou estágio).

Configuração de sessão do Spark

Você pode especificar a duração do tempo limite, o número e o tamanho dos executores para dar à sessão atual do Spark em Configurar sessão. Reinicie a sessão do Spark para que as alterações de configuração entrem em vigor. Todas as variáveis do notebook em cache serão limpas.

Também é possível criar uma configuração na configuração do Apache Spark ou selecionar uma configuração existente. Para saber detalhes, confira Gerenciamento de Configuração do Apache Spark.

Comando magic de configuração de sessão do Spark

Você também pode especificar as configurações de sessão do Spark por meio de um comando mágico %%configure. A sessão do Spark precisa ser reiniciada para que as configurações tenham efeito. Recomendamos que você execute o %%configure no início do notebook. Aqui está um exemplo, confira https://github.com/cloudera/livy#request-body para obter uma lista completa de parâmetros válidos.

%%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", "472g"]
    "driverCores":4, // Recommended values: [4, 8, 16, 32, 64, 80]
    "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 standard spark property, to find more available properties please visit:https://spark.apache.org/docs/latest/configuration.html#application-properties.
        "spark.driver.maxResultSize":"10g",
    //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" 
    }
}

Observação

• "DriverMemory" e "ExecutorMemory" são recomendados para definir como o mesmo valor em %%configure, portanto, faça "driverCores" e "executorCores".
• Você pode usar %%configure em pipelines do Azure Synapse, mas se ele não estiver definido na primeira célula de código, a execução de pipeline falhará porque não é possível reiniciar a sessão.
• O %%configure usado em mssparkutils.notebook.run será ignorado, mas se ele for usado em %run, o notebook continuará em execução.
• As propriedades de configuração padrão do Spark precisam ser usadas no corpo de "conf". Não damos suporte para a referência de primeiro nível nas propriedades de configuração do Spark.
• Algumas propriedades especiais do Spark, incluindo "spark.driver.cores", "spark.executor.cores", "spark.driver.memory", "spark.executor.memory" e "spark.executor.instances" não entrarão em vigor no corpo de "conf".

Configuração de sessão parametrizada do pipeline

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

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

%%configure  

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

O notebook usa o valor padrão se um notebook for executado no modo interativo diretamente ou se nenhum parâmetro que corresponder a "activityParameterName" for fornecido na atividade Notebook do Pipeline.

Durante o modo de execução de pipeline, você pode definir as configurações da atividade Notebook do pipeline conforme mostrado abaixo:

Caso deseje alterar a configuração da sessão, o nome dos parâmetros da atividade Notebook do pipeline deve ser o mesmo que activityParameterName no notebook. Ao executar esse pipeline for executado, neste exemplo, os driverCores de %%configure serão substituídos por 8 e livy.rsc.sql.num-rows será substituído por 4000.

Observação

Se o pipeline de execução falhar devido ao uso deste novo magic %%configure, verifique mais informações de erro executando a célula do magic %%configure no modo interativo do notebook.

Trazer dados para um notebook

Você pode carregar dados do Armazenamento de Blobs do Azure, do Azure Data Lake Store Gen 2 e de pool do SQL, como mostram os exemplos de código abaixo.

Ler um CSV do Azure Data Lake Store Gen2 como um dataframe do Spark

from pyspark.sql import SparkSession
from pyspark.sql.types import *
account_name = "Your account name"
container_name = "Your container name"
relative_path = "Your path"
adls_path = 'abfss://%s@%s.dfs.core.windows.net/%s' % (container_name, account_name, relative_path)

df1 = spark.read.option('header', 'true') \
                .option('delimiter', ',') \
                .csv(adls_path + '/Testfile.csv')

Ler um CSV do Armazenamento de Blobs do Azure como um dataframe do Spark

from pyspark.sql import SparkSession

# Azure storage access info
blob_account_name = 'Your account name' # replace with your blob name
blob_container_name = 'Your container name' # replace with your container name
blob_relative_path = 'Your path' # replace with your relative folder path
linked_service_name = 'Your linked service name' # replace with your linked service name

blob_sas_token = mssparkutils.credentials.getConnectionStringOrCreds(linked_service_name)

# Allow SPARK to access from Blob remotely

wasb_path = 'wasbs://%s@%s.blob.core.windows.net/%s' % (blob_container_name, blob_account_name, blob_relative_path)

spark.conf.set('fs.azure.sas.%s.%s.blob.core.windows.net' % (blob_container_name, blob_account_name), blob_sas_token)
print('Remote blob path: ' + wasb_path)

df = spark.read.option("header", "true") \
            .option("delimiter","|") \
            .schema(schema) \
            .csv(wasbs_path)

Ler dados da conta de armazenamento primária

Você pode acessar os dados na conta de armazenamento principal diretamente. Não é necessário fornecer as chaves secretas. No Data Explorer, clique com o botão direito do mouse em um arquivo e selecione Novo notebook para ver um novo notebook com o extrator de dados gerado automaticamente.

Widgets de IPython

Widgets são objetos Python com eventos que têm uma representação no navegador, geralmente como um controle, por exemplo, um controle deslizante, uma caixa de texto etc. Os Widgets de IPython só funcionam no ambiente Python. Ainda não há suporte para eles em outras linguagens (por exemplo, Scala, SQL, C#).

Para usar o Widget de IPython

1. Primeiro, você precisa importar o módulo ipywidgets para usar a estrutura do Widget do Jupyter.

   import ipywidgets as widgets
   

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

   slider = widgets.IntSlider()
   display(slider)
   

   slider = widgets.IntSlider()
   slider
   

3. Execute a célula e o widget será exibido na área de saída.

   

4. Você pode usar várias chamadas a display() para renderizar várias vezes a mesma instância de widget, mas elas permanecem em sincronia.

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

   

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

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

Widgets com suporte

Tipo de widgets	Widgets
Widgets numéricos	IntSlider, FloatSlider, FloatLogSlider, IntRangeSlider, FloatRangeSlider, IntProgress, FloatProgress, BoundedIntText, BoundedFloatText, IntText, FloatText
Widgets boolianas	ToggleButton, Checkbox, Valid
Widgets de seleção	Dropdown, RadioButtons, Select, SelectionSlider, SelectionRangeSlider, ToggleButtons, SelectMultiple
Widgets de cadeia de caracteres	Texto, Área de texto, Combobox, Senha, Rótulo, HTML, HTML Math, Imagem, Botão
Widgets de reprodução (animação)	Seletor de data, Seletor de cor, Controlador
Widgets de contêiner/layout	Box, HBox, VBox, GridBox, Accordion, Tabs, Stacked

Limitações conhecidas

1. Os widgets a seguir ainda não têm suporte. Siga a solução alternativa correspondente abaixo:

   Funcionalidade	Solução alternativa
   Widget Output	Em vez disso, use a função print() para escrever texto no StdOut.
   widgets.jslink()	Use a função widgets.link() para vincular dois objetos parecidos.
   Widget FileUpload	Ainda não há suporte.

2. A função global display fornecida pelo Synapse não oferece suporte à exibição de vários widgets em uma chamada (ou seja, display(a, b)), o que é diferente da função IPython display.

3. Se você fechar um notebook que contém o widget de IPython, não poderá vê-lo ou interagir com ele até executar a célula correspondente novamente.

---

Salvar notebooks

Você pode salvar um único notebook ou todos eles em seu espaço de trabalho.

1. Para salvar as alterações feitas em um único notebook, selecione o botão Publicar na barra de comandos do notebook.

   

2. Para salvar todos os notebooks em seu espaço de trabalho, selecione o botão Publicar tudo na barra de comandos do espaço de trabalho.

   

Nas propriedades do notebook, você pode configurar se deseja incluir a saída da célula ao salvar.

Comandos magic

Você pode usar seus comandos magic do Jupyter conhecidos nos notebooks Synapse. Examine a lista abaixo com os comandos magic disponíveis atualmente. Fale para nós dos seus casos de uso no GitHub para que possamos continuar a criar mais comandos mágicos e atender às suas necessidades.

Observação

Apenas os comandos mágicos a seguir têm suporte no pipeline do Synapse: %%pyspark, %%spark, %%csharp, %%sql.

Magics de linha disponíveis: %lsmagic, %time, % timeit, %history, %run, %load

Magics de célula disponíveis: %%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, %%spark, %%csharp, %%html, %%configure

---

Referenciar um notebook não publicado

A referência de um notebook não publicado é útil quando você deseja faz a depuração "localmente". Ao habilitar esse recurso, a execução de notebook busca o conteúdo atual no cache da Web. Se você executar uma célula incluindo uma instrução de notebooks de referência, referenciará os notebooks de apresentação no navegador de notebook atual em vez de em uma versão salva no cluster, o que significa que as alterações no editor de notebook podem ser referenciadas imediatamente por outros notebooks sem que precisem ser publicadas (modo dinâmico) ou nem confirmadas (modo Git). Aproveitando essa abordagem, você pode evitar com facilidade que bibliotecas comuns sejam poluídas durante o processo de desenvolvimento ou depuração.

É possível habilitar o notebook de referência não publicado no painel Propriedades:

Para ver uma comparação entre diferentes casos, verifique a tabela abaixo:

Observe que %run e mssparkutils.notebook.run tem o mesmo comportamento aqui. Usamos %run aqui como um exemplo.

Caixa	Desabilitar	Habilitar
Modo dinâmico
– Nb1 (publicado) %run Nb1	Executar a versão publicada do Nb1	Executar a versão publicada do Nb1
– Nb1 (novo) %run Nb1	Erro do	Executar um novo Nb1
– Nb1 (publicado anteriormente, editado) %run Nb1	Executar a versão publicada do Nb1	Executar a versão editada do Nb1
Modo Git
– Nb1 (publicado) %run Nb1	Executar a versão publicada do Nb1	Executar a versão publicada do Nb1
– Nb1 (novo) %run Nb1	Erro do	Executar um novo Nb1
– Nb1 (não publicado, confirmado) %run Nb1	Erro do	Executar um Nb1 confirmado
– Nb1 (publicado anteriormente, confirmado) %run Nb1	Executar a versão publicada do Nb1	Executar a versão confirmada do Nb1
– Nb1 (publicado anteriormente, novo no branch atual) %run Nb1	Executar a versão publicada do Nb1	Executar um novo Nb1
– Nb1 (não publicado, confirmado anteriormente, editado) %run Nb1	Erro do	Executar a versão editada do Nb1
– Nb1 (anteriormente publicado e confirmado, editado) %run Nb1	Executar a versão publicada do Nb1	Executar a versão editada do Nb1

Conclusão

• Se desabilitado, sempre execute a versão publicada.
• Se habilitado, a prioridade será: editado/novo > confirmado > publicado.

Gerenciamento de sessão ativa

É possível reutilizar suas sessões de notebook de forma conveniente agora sem precisar iniciar novas. O notebook Synapse agora dá suporte ao gerenciamento de sessões ativas na lista Gerenciar sessões, você pode ver todas as sessões no espaço de trabalho atual iniciadas por você no notebook.

Na lista Sessões ativas, você pode ver as informações da sessão e o notebook correspondente que está anexado à sessão no momento. É possível operar o Desanexar com o notebook, Parar a sessão e Exibir em monitoramento aqui. Além disso, você pode conectar facilmente o notebook selecionado a uma sessão ativa na lista iniciada a partir de outro notebook, a sessão é desanexada do notebook anterior (se não estiver ociosa) e, em seguida, anexada ao atual.

Registro em log do Python no Notebook

É possível encontrar logs do Python e definir diferentes níveis de log e formatar seguindo o código de exemplo abaixo:

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")

Integrar um notebook

Adicionar um notebook a um pipeline

Selecione o botão Adicionar ao pipeline no canto superior direito para adicionar um notebook a um pipeline existente ou criar um novo pipeline.

Designar uma célula de parâmetros

Para parametrizar o seu notebook, selecione as reticências (...) para acessar 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.

---

O Azure Data Factory procura a célula parâmetros e trata essa célula como 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 de parâmetros de um pipeline

Depois de criar um notebook com parâmetros, você pode executá-lo a partir de um pipeline com a atividade do notebook Synapse. Depois de adicionar a atividade à tela do pipeline, você poderá definir os valores dos parâmetros na seção Parâmetros de base na guia Configurações.

Ao atribuir valores de parâmetro, você pode usar a linguagem de expressão de pipeline ou variáveis do sistema.

Teclas de atalho

Semelhantemente aos Jupyter Notebooks, os notebooks Synapse têm uma interface de usuário modal. O teclado faz coisas diferentes, dependendo de em qual modo a célula do notebook está. Os notebooks Synapse dão suporte aos seguintes dois modos de uma célula de código: modo de comando e modo de edição.

1. Uma célula está no modo de comando quando não há um cursor de texto solicitando que você digite. Quando uma célula está no modo de comando, você pode editar o notebook como um todo, mas não pode 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.

   

2. O modo de edição é indicado por um cursor de texto solicitando que você digite na área do editor. Quando uma célula está no modo de edição, não é possível digitar nela. Entre no modo de edição pressionando Enter ou usando o mouse para selecionar na área do editor de uma célula.

   

Teclas de atalho no modo de comando

Ação	Atalhos do notebook Synapse
Executar a célula atual e selecionar abaixo	Shift+Enter
Executar a célula atual e inserir abaixo	Alt+Enter
Executar a célula atual	Ctrl+Enter
Selecionar célula acima	Para cima
Selecionar célula abaixo	Para baixo
Selecionar célula anterior	K
Selecionar próxima célula	J
Inserir célula acima	Um
Inserir célula abaixo	B
Excluir células selecionadas	Shift+D
Mudar para o modo de edição	Digite

---

Teclas de atalho no modo de edição

Usando os atalhos de tecla a seguir, você pode navegar e executar o código com mais facilidade nos notebooks Synapse quando no modo de edição.

Ação	Atalhos do notebook Synapse
Mover cursor para cima	Para cima
Mover cursor para baixo	Para baixo
Desfazer	CTRL+Z
Refaz	Ctrl+Y
Inserir/remover comentário	Ctrl+/
Excluir palavra anterior	Ctrl+Backspace
Excluir palavra seguinte	Ctrl+Delete
Ir para o início da célula	Ctrl+Home
Ir para o final da célula	Ctrl+End
Ir uma palavra para a esquerda	CTRL+Seta para a esquerda
Ir uma palavra para a direita	CTRL+Seta para a direita
Selecionar tudo	CTRL+A
Recuar	Ctrl +]
Desfazer recuo	Ctrl+[
Alternar para o modo de comando	Esc

---

Próximas etapas

• Confira os notebooks de exemplo do Azure Synapse
• Início Rápido: Criar um Pool do Apache Spark no Azure Synapse Analytics usando ferramentas da Web
• O que é Apache Spark no Azure Synapse Analytics
• Use .NET para Apache Spark com Azure Synapse Analytics
• Documentação do .NET para Apache Spark
• Azure Synapse Analytics