Pular para o conteúdo principal
Última atualização em

Limitações conhecidas do Databricks Notebook

Os notebooks do Databricks têm limitações conhecidas sobre tamanho, escala do workspace, saídas de célula, depurador, sessões de SQL warehouse e widgets. Os notebooks podem ter até 100 MB, a entrada de cada célula pode ter até 6 MB e os resultados de tabelas são limitados a 10.000 linhas ou 2 MB, o que for menor. Para limites de recursos adicionais, consulte Limites de recursos.

DimensionamentoNotebook​

  • O salvamento automático, o salvamento manual e a clonagem do Revision Snapshot são suportados em todos os Notebooks de até 100 MB.
  • Importação e exportação são suportadas para ipynb Notebook de até 100 MB.
  • A importação e exportação são suportadas para arquivo DBC, HTML, R Markdown e Notebook de origem de até 10 MB.
  • As células individuais do Notebook têm um limite de entrada de 6 MB.

Escala do workspace​

  • A Databricks recomenda um máximo de 1.000 usuários online concorrentes por workspace. Um usuário conta como online enquanto tiver um Notebooks aberto, e cada Notebooks aberto adicional aumenta a carga. Esse limite não é imposto, mas, acima dele, o carregamento de notebooks, salvá-los e executar comandos pode ficar mais lento para todos os usuários no workspace.
  • Se você espera mais de 1.000 usuários online concorrentes, divida-os em vários workspaces, por exemplo, por unidade de negócio ou equipe. Entre em contato com sua equipe de account do Databricks antes de integrar um grande grupo de usuários em um único workspace.

Notebook saídas de células​

  • Os resultados da tabela são limitados a 10.000 linhas ou 2 MB, o que for menor.

  • Job têm um tamanho máximo de saída do Notebook de 30 MB.

  • No Databricks Runtime 17.0 e versões superiores, e no ambiente serverless 3:

    • O tamanho máximo de saída da célula é de 10 MB por padrão.
    • Esse limite pode ser personalizado nas células Python para qualquer valor entre 1 MB e 20 MB (inclusive) usando a seguinte mágica de célula: %set_cell_max_output_size_in_mb <size_in_MB>. Esse limite será aplicado a todas as células do Notebook.
    • Quando a saída da célula excede o limite de tamanho configurado, a saída é truncada para caber dentro do limite. O truncamento é aplicado de forma a preservar o máximo possível de resultados úteis.

  • No Databricks Runtime 16.4 LTS e versões anteriores, e no ambiente serverless 2 e versões anteriores:

    • Os resultados de texto retornam no máximo 50.000 caracteres.
    • Em Databricks Runtime 12.2 e acima, o senhor pode aumentar esse limite para até 20 MB definindo a propriedade de configuração Spark, spark.databricks.driver.maxReplOutputLength.
    • Quando a saída da célula excede o limite de tamanho configurado, a saída é totalmente descartada .

Notebook depurador​

Limitações do depurador do Notebook:

  • O depurador funciona apenas com o Python. Ele não é compatível com Scala ou R.

  • Para acessar o depurador, o Notebook deve estar conectado a um dos seguintes recursos compute:

    • computação sem servidor
    • computar com o modo de acesso definido como Standard (anteriormente compartilhado) em Databricks Runtime 14.3 LTS e acima
    • computar com o modo de acesso definido como Dedicado (anteriormente, usuário único) em Databricks Runtime 13.3 LTS e acima
    • computar com o modo de acesso definido como No Isolation Shared em Databricks Runtime 13.3 LTS e acima

  • O depurador não suporta a entrada passo a passo na biblioteca Python .

  • O senhor não pode executar outro comando no Notebook quando uma sessão de depuração estiver ativa.

  • O depurador não oferece suporte à depuração em subprocessos quando conectado ao serverless compute e em cluster com o modo de acesso definido como Padrão .

SQL warehouse Caderno de anotações​

Limitações do SQL warehouse Notebook:

  • Quando anexado a um SQL warehouse, os contextos de execução têm um tempo limite ocioso de 8 horas.

widgets ipy​

Limitações dos ipywidgets:

  • Um Notebook que usa ipywidgets deve ser anexado a um cluster em execução.
  • Os estados do widget não são preservados entre as sessões do Notebook. O senhor deve reexecutar as células do widget para renderizá-las sempre que anexar o Notebook a um cluster.
  • Os widgets Password and Controller ipywidgets não são suportados.
  • Os widgets HTMLMath e rótulo com expressões LaTeX não são renderizados corretamente. (Por exemplo, widgets.Label(value=r'$$\frac{x+1}{x-1}$$') não é renderizado corretamente.)
  • Os widgets podem não ser renderizados corretamente se o Notebook estiver no modo escuro, especialmente os widgets coloridos.
  • As saídas do widget não podem ser usadas na visualização do painel do Notebook.
  • O tamanho máximo da carga útil da mensagem para um ipywidget é de 5 MB. Os widgets que usam imagens ou dados de texto grandes podem não ser renderizados adequadamente.

Widgets do Databricks​

Limitações dos widgets da Databricks:

  • Um máximo de 512 widgets pode ser criado em um Notebook.

  • O nome do widget é limitado a 1024 caracteres.

  • O rótulo de um widget é limitado a 2048 caracteres.

  • No máximo 2048 caracteres podem ser inseridos em um widget de texto.

  • Pode haver um máximo de 1024 opções para um widget de seleção múltipla, caixa de combinação ou dropdown.

  • Existe um problema conhecido em que o estado de um widget pode não ser limpo corretamente após pressionar "Executar tudo" , mesmo depois de limpar ou remover o widget no código. Caso isso aconteça, você verá uma discrepância entre o estado visual e o estado impresso do widget. Executar as células individualmente novamente pode contornar esse problema. Para evitar esse problema, a Databricks recomenda o uso de ipywidgets.

  • Não acesse o estado do widget diretamente em contextos assíncronos como threads, subprocessos ou transmissão estruturada (foreachBatch), pois o estado do widget pode mudar enquanto o código assíncrono está sendo executado. Se você precisar acessar o estado do widget em um contexto assíncrono, passe-o como argumento. Por exemplo, se você tiver o seguinte código que usa threads:

    Python
    import threading

    def thread_func():
      # Unsafe access in a thread
      value = dbutils.widgets.get('my_widget')
      print(value)

    thread = threading.Thread(target=thread_func)
    thread.start()
    thread.join()

    Em vez disso, a Databricks recomenda o uso de um argumento:

    Python
    # Access widget values outside the asynchronous context and pass them to the function
    value = dbutils.widgets.get('my_widget')

    def thread_func(val):
      # Use the passed value safely inside the thread
      print(val)

    thread = threading.Thread(target=thread_func, args=(value,))
    thread.start()
    thread.join()

  • Em geral, os widgets não podem passar argumentos entre idiomas diferentes em um Notebook. O senhor pode criar um widget arg1 em uma célula Python e usá-lo em uma célula SQL ou Scala se executar uma célula de cada vez. No entanto, isso não funciona se o senhor usar o recurso Executar tudo ou executar o Notebook como um trabalho. Algumas soluções alternativas são:

    • Para Notebooks que não misturam idiomas, o senhor pode criar um Notebook para cada idioma e passar os argumentos ao executar o Notebook.
    • Você pode acessar o widget usando uma spark.sql() chamada. Por exemplo, em Python: spark.sql("select getArgument('arg1')").take(1)[0][0].
Nesta página