Usar o plug-in Dataproc JupyterLab para sessões de notebook interativas e em lote sem servidor

Este documento descreve como instalar e usar o plug-in Dataproc JupyterLab em uma máquina ou VM que tenha acesso aos serviços do Google, como a máquina local ou uma instância de VM do Compute Engine. Também descreve como desenvolver e deploy o código do notebook do Spark.

Depois de instalar o plug-in do JupyterLab do Dataproc, você pode usá-lo para fazer as seguintes tarefas:

  • Iniciar sessões de notebook interativas do Dataproc Serverless para Spark
  • Enviar jobs em lote sem servidor do Dataproc

Limitações e considerações do Dataproc sem servidor

  • Os jobs do Spark são executados com a identidade da conta de serviço, não com a identidade do usuário que fez o envio.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Enable the Dataproc API.

    Enable the API

  4. Install the Google Cloud CLI.

  5. To initialize the gcloud CLI, run the following command: 

    gcloud init

  6. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  7. Enable the Dataproc API.

    Enable the API

  8. Install the Google Cloud CLI.

  9. To initialize the gcloud CLI, run the following command: 

    gcloud init
  10. Verifique se a sub-rede VPC regional em que você vai executar a sessão interativa do Dataproc Serverless tem o Acesso particular do Google ativado. Para mais informações, consulte Criar um modelo de ambiente de execução sem servidor do Dataproc.

Instalar o plug-in JupyterLab do Dataproc

É possível instalar e usar o plug-in Dataproc JupyterLab em uma máquina ou VM que tenha acesso aos serviços do Google, como a máquina local ou uma instância de VM do Compute Engine.

Para instalar o plug-in, siga estas etapas:

  1. Faça o download e instale a versão 3.8 ou mais recente do Python em python.org/downloads.

    • Verifique a instalação do Python 3.8 ou mais recente.

      python3 --version

  2. Instale o JupyterLab 3.6.3+ na sua máquina.

    pip3 install --upgrade jupyterlab

    • Verifique a instalação do JupyterLab 3.6.3 ou mais recente.

       pip3 show jupyterlab
 ```

  3. Instale o plug-in do JupyterLab do Dataproc.

    pip3 install dataproc-jupyter-plugin

    • Se a versão do JupyterLab for anterior a 4.0.0, ative a extensão do plug-in.

       jupyter server extension enable dataproc_jupyter_plugin
 ```

  4. Inicie o JupyterLab.

    jupyter lab

    1. A página Acesso rápido do JupyterLab é aberta no navegador. Ela contém uma seção Jobs e sessões do Dataproc. Ela também pode conter seções de Notebooks sem servidor do Dataproc e Notebooks do cluster do Dataproc se você tiver acesso a notebooks sem servidor do Dataproc ou clusters do Dataproc com o componente opcional do Jupyter em execução no projeto.

    2. Por padrão, a sessão do Dataproc Serverless para Spark Interactive é executada no projeto e na região que você definiu quando executou gcloud init em Antes de começar. É possível mudar as configurações de projeto e região das suas sessões na página Settings > Dataproc Settings do JupyterLab.

Criar um modelo de ambiente de execução sem servidor do Dataproc

Os modelos de ambiente de execução do Dataproc Serverless (também chamados de modelos session) contêm configurações para executar o código do Spark em uma sessão. É possível criar e gerenciar modelos de execução usando o Jupyterlab ou a CLI gcloud.

JupyterLab

  1. Clique no card New runtime template na seção Notebooks sem servidor do Dataproc na página Launcher do JupyterLab.

  2. Preencha o formulário Modelo de execução.

  3. Especifique um nome de exibição e uma descrição e insira ou confirme as outras configurações.

    Observações:

    • Configuração de rede: a sub-rede precisa ter o Acesso privado do Google ativado e permitir a comunicação da sub-rede em todas as portas. Consulte Configuração de rede do Dataproc Serverless para Spark.

      Se a sub-rede da rede default para a região que você configurou ao executar gcloud init em Antes de começar não estiver ativada para o Acesso privado do Google:

      • Ative o Acesso privado do Google ou
      • Selecione outra rede com uma sub-rede regional que tenha o Acesso privado do Google ativado. É possível mudar a região que o Dataproc Serverless usa na página Configurações > Configurações do Dataproc do JupyterLab.

    • Metastore: para usar um serviço do Metastore do Dataproc nas suas sessões, selecione o ID do projeto, a região e o serviço do metastore.

    • Tempo máximo de inatividade:o tempo máximo de inatividade do notebook antes que a sessão seja encerrada. Intervalo permitido: de 10 minutos a 336 horas (14 dias).

    • Tempo máximo da sessão:o tempo de vida máximo de uma sessão antes que ela seja encerrada. Intervalo permitido: de 10 minutos a 336 horas (14 dias).

    • PHS: é possível selecionar um servidor de histórico persistente do Spark disponível para acessar os registros de sessão durante e depois das sessões.

    • Propriedades do Spark:clique em Adicionar propriedade para definir cada propriedade nas suas sessões do Spark sem servidor. Consulte Propriedades do Spark para conferir uma lista de propriedades do Spark com e sem suporte, incluindo propriedades de execução, recursos e escalonamento automático do Spark.

    • Rótulos:clique em Adicionar rótulo para definir cada rótulo nas suas sessões Spark serverless.

  4. Acesse os modelos de execução na página Configurações > Configurações do Dataproc.

    • É possível excluir um modelo no menu Ação.

  5. Clique em Salvar.

  6. Abra e recarregue a página Acesso rápido do JupyterLab para conferir o cartão de modelo de notebook salvo na página Acesso rápido do JupyterLab.

gcloud

  1. Crie um arquivo YAML com a configuração do modelo de execução.

    YAML simples

    environmentConfig:
  executionConfig:
    networkUri: default
jupyterSession:
  kernel: PYTHON
  displayName: Team A
labels:
  purpose: testing
description: Team A Development Environment

    YAML complexo

    environmentConfig:
  executionConfig:
    serviceAccount: sa1
    # Choose either networkUri or subnetworkUri
    networkUri: default
    subnetworkUri: subnet
    networkTags:
     - tag1
    kmsKey: key1
    idleTtl: 3600s
    ttl: 14400s
    stagingBucket: staging-bucket
  peripheralsConfig:
    metastoreService: projects/my-project-id/locations/us-central1/services/my-metastore-id
    sparkHistoryServerConfig:
      dataprocCluster: projects/my-project-id/regions/us-central1/clusters/my-cluster-id
jupyterSession:
  kernel: PYTHON
  displayName: Team A
labels:
  purpose: testing
runtimeConfig:
  version: "1.1"
  containerImage: gcr.io/my-project-id/my-image:1.0.1
  properties:
    "p1": "v1"
description: Team A Development Environment

    Se a sub-rede da rede default para a região que você configurou ao executar gcloud init em Antes de começar não estiver ativada para o Acesso privado do Google:

    • Ative o Acesso privado do Google ou
    • Selecione outra rede com uma sub-rede regional que tenha o Acesso privado do Google ativado. É possível mudar a região que o Dataproc Serverless usa na página Configurações > Configurações do Dataproc do JupyterLab.

  2. Crie um modelo de sessão (ambiente de execução) a partir do arquivo YAML executando o comando gcloud beta dataproc session-templates import a seguir localmente ou no Cloud Shell: 

    gcloud beta dataproc session-templates import TEMPLATE_ID \
    --source=YAML_FILE \
    --project=PROJECT_ID \
    --location=REGION

Iniciar e gerenciar notebooks

Depois de instalar o plug-in do JupyterLab do Dataproc, clique nos cards de modelo na página Acesso rápido do JupyterLab para:

Iniciar um notebook do Jupyter no Dataproc Serverless

A seção Dataproc Serverless Notebooks na página do iniciador do JupyterLab mostra cards de modelos de notebook que são mapeados para modelos de ambiente de execução do Dataproc Serverless. Consulte Criar um modelo de ambiente de execução do Dataproc Serverless.

  1. Clique em um card para criar uma sessão sem servidor do Dataproc e iniciar um notebook. Quando a criação da sessão for concluída e o kernel do notebook estiver pronto para uso, o status do kernel mudará de Unknown para Idle.

  2. Programar e testar o código do notebook.

    1. Copie e cole o código Pi estimation do PySpark abaixo na célula do notebook do PySpark e pressione Shift + Return para executar o código. 

      import random
    
def inside(p):
    x, y = random.random(), random.random()
    return x*x + y*y < 1
    
count = sc.parallelize(range(0, 10000)) .filter(inside).count()
print("Pi is roughly %f" % (4.0 * count / 10000))

      Resultado do notebook:

  3. Depois de criar e usar um notebook, você pode encerrar a sessão dele clicando em Shut Down Kernel na guia Kernel.

    • Se você não encerrar a sessão, o Dataproc vai encerrar a sessão quando o timer de inatividade da sessão expirar. É possível configurar o tempo de inatividade da sessão na configuração do modelo de execução. O tempo de inatividade padrão da sessão é de uma hora.

Iniciar um notebook em um cluster do Dataproc no Compute Engine

Se você criou um Dataproc no cluster Jupyter do Compute Engine, a página Launcher do JupyterLab contém uma seção Dataproc Cluster Notebook com cards de kernel pré-instalados.

Para iniciar um notebook do Jupyter no cluster do Dataproc no Compute Engine:

  1. Clique em um card na seção Notebook do cluster do Dataproc.

  2. Quando o status do kernel muda de Unknown para Idle, é possível começar a escrever e executar o código do notebook.

  3. Depois de criar e usar um notebook, você pode encerrar a sessão dele clicando em Shut Down Kernel na guia Kernel.

Gerenciar arquivos de entrada e saída no Cloud Storage

A análise de dados exploratórios e a criação de modelos de ML geralmente envolvem entradas e saídas baseadas em arquivos. O Dataproc Serverless acessa esses arquivos no Cloud Storage.

  • Para acessar o navegador do Cloud Storage, clique no ícone do navegador do Cloud Storage na barra lateral da página Launcher do JupyterLab e clique duas vezes em uma pasta para conferir o conteúdo dela.

  • Clique nos tipos de arquivo compatíveis com o Jupyter para abrir e editar. Quando você salva as alterações nos arquivos, elas são gravadas no Cloud Storage.

  • Para criar uma nova pasta do Cloud Storage, clique no ícone de nova pasta e insira o nome dela.

  • Para fazer upload de arquivos em um bucket ou uma pasta do Cloud Storage, clique no ícone de upload e selecione os arquivos.

Desenvolver código de notebook do Spark

Depois de instalar o plug-in do JupyterLab do Dataproc, é possível iniciar notebooks do Jupyter na página Launcher do JupyterLab para desenvolver o código do aplicativo.

Desenvolvimento de código PySpark e Python

O Dataproc sem servidor e o Dataproc em clusters do Compute Engine oferecem suporte a kernels do PySpark. O Dataproc no Compute Engine também oferece suporte a kernels do Python.

Desenvolvimento de código SQL

Para abrir um notebook do PySpark para escrever e executar código SQL, na página Launcher do JupyterLab, na seção Dataproc Serverless Notebooks ou Dataproc Cluster Notebook, clique no card do kernel do PySpark.

Magia do Spark SQL:como o kernel do PySpark que inicia os notebooks sem servidor do Dataproc (link em inglês) é pré-carregado com a magia do Spark SQL, em vez de usar spark.sql('SQL STATEMENT').show() para agrupar a instrução SQL, você pode digitar %%sparksql magic na parte superior de uma célula e, em seguida, digitar a instrução SQL na célula.

SQL do BigQuery:o conector do BigQuery Spark permite que o código do seu notebook carregue dados das tabelas do BigQuery, realize análises no Spark e grave os resultados em uma tabela do BigQuery.

O ambiente de execução do Dataproc sem servidor 2.1 inclui o conector do BigQuery Spark. Se você usar o Dataproc sem servidor 2.0 ou um ambiente de execução anterior para iniciar notebooks do Dataproc sem servidor, é possível instalar o conector Spark BigQuery adicionando a seguinte propriedade do Spark ao seu modelo de ambiente de execução sem servidor do Dataproc:

spark.jars: gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.25.2.jar

Desenvolvimento de código Scala

O Dataproc em clusters do Compute Engine criados com a versão de imagem 2.0 ou mais recente, 2.1 ou mais recente e versões mais recentes, inclui o Apache Toree, um kernel Scala para a plataforma Jupyter Notebook que oferece acesso interativo ao Spark.

  • Clique no card do Apache Toree na seção Notebook do cluster do Dataproc na página Launcher do JupyterLab para abrir um notebook para desenvolvimento de código Scala.

    Figura 1. Card do kernel do Apache Toree na página do JupyterLab Launcher.

Explorador de metadados

Se uma instância do metastore do Dataproc (DPMS, na sigla em inglês) for anexada a um modelo de execução sem servidor do Dataproc ou a um cluster do Dataproc no Compute Engine, o esquema da instância do DPMS será exibido no JupyterLab Metadata Explorer quando um notebook for aberto. O DPMS é um serviço de metastore Hive (HMS) totalmente gerenciado e escalonável horizontalmente no Google Cloud.

Para conferir os metadados do HMS no Metadata Explorer:

Para abrir o explorador de metadados do JupyterLab, clique no ícone dele na barra lateral.

Você pode pesquisar um banco de dados, uma tabela ou uma coluna no Metadata Explorer. Clique no nome de um banco de dados, tabela ou coluna para conferir os metadados associados.

Implantar o código

Depois de instalar o plug-in JupyterLab do Dataproc, é possível usar o JupyterLab para:

  • Executar o código do notebook na infraestrutura sem servidor do Dataproc

  • Envie jobs em lote para a infraestrutura do Dataproc Serverless ou para o cluster do Dataproc no Compute Engine.

Executar o código do notebook no Dataproc Serverless

  • Para executar o código em uma célula do notebook, clique em Run ou pressione as teclas Shift-Return.

  • Para executar o código em uma ou mais células do notebook, use o menu Run.

Enviar um job em lote para o Dataproc sem servidor

  • Clique no card Serverless na seção Jobs and Sessions do Dataproc na página Launcher do JupyterLab.

  • Clique na guia Batch, em Create Batch e preencha os campos Batch Info.

  • Clique em Enviar para enviar o job.

Enviar um job em lote para um cluster do Dataproc no Compute Engine

  • Clique no card Clusters na seção Jobs and Sessions do Dataproc na página Launcher do JupyterLab.

  • Clique na guia Jobs e em Enviar job.

  • Selecione um Cluster e preencha os campos Job.

  • Clique em Enviar para enviar o job.

Conferir e gerenciar recursos

Depois de instalar o plug-in Dataproc JupyterLab, é possível conferir e gerenciar o Dataproc sem servidor e o Dataproc no Compute Engine na seção Jobs e sessões do Dataproc na página Launcher do JupyterLab.

Clique na seção Jobs e sessões do Dataproc para mostrar os cards Clusters e Serverless.

Para conferir e gerenciar sessões sem servidor do Dataproc:

  1. Clique no card Serverless.
  2. Clique na guia Sessões e em um ID de sessão para abrir a página Detalhes da sessão e conferir as propriedades da sessão, os registros do Google Cloud no Explorador de registros e encerrar uma sessão. Observação: uma sessão exclusiva do Dataproc Serverless é criada para iniciar cada notebook do Dataproc Serverless.

Para conferir e gerenciar lotes do Dataproc sem servidor:

  1. Clique na guia Batches para conferir a lista de lotes do Dataproc Serverless no projeto e na região atuais. Clique em um ID do lote para conferir os detalhes.

Para conferir e gerenciar o Dataproc em clusters do Compute Engine:

  1. Clique no card Clusters. A guia Clusters é selecionada para listar o Dataproc ativo em clusters do Compute Engine no projeto e na região atuais. Clique nos ícones na coluna Ações para iniciar, interromper ou reiniciar um cluster. Clique no nome de um cluster para conferir os detalhes dele. Clique nos ícones na coluna Ações para clonar, interromper ou excluir um job.

Para conferir e gerenciar jobs do Dataproc no Compute Engine:

  1. Clique no card Jobs para conferir a lista de jobs no projeto atual. Clique em um ID de job para conferir os detalhes.