Usar a extensão do JupyterLab para desenvolver cargas de trabalho do Spark sem servidor

Neste documento, descrevemos como instalar e usar a extensão do JupyterLab em uma máquina ou VM autogerenciada que tenha acesso aos serviços do Google. Também descrevemos como desenvolver e implantar código de notebook do Spark sem servidor.

Instale a extensão em minutos para aproveitar os seguintes recursos:

  • Inicie notebooks sem servidor do Spark e do BigQuery para desenvolver código rapidamente
  • Procurar e visualizar conjuntos de dados do BigQuery no JupyterLab
  • Editar arquivos do Cloud Storage no JupyterLab
  • Programar um notebook no Composer

Antes de começar

  1. Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloud, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that you have the permissions required to complete this guide.

  4. Verify that billing is enabled for your Google Cloud project.

  5. Enable the Dataproc API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  6. Instale a CLI do Google Cloud.

  7. Ao usar um provedor de identidade (IdP) externo, primeiro faça login na CLI gcloud com sua identidade federada.

  8. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  10. Verify that you have the permissions required to complete this guide.

  11. Verify that billing is enabled for your Google Cloud project.

  12. Enable the Dataproc API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  13. Instale a CLI do Google Cloud.

  14. Ao usar um provedor de identidade (IdP) externo, primeiro faça login na CLI gcloud com sua identidade federada.

  15. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

Funções exigidas

Alguns papéis do IAM são necessários para executar os exemplos nesta página. Dependendo das políticas da organização, esses papéis podem já ter sido concedidos. Para verificar as concessões de papéis, consulte Você precisa conceder papéis?.

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Papéis do usuário

Para receber as permissões necessárias e criar uma sessão de notebook interativo, peça ao administrador para conceder a você os seguintes papéis do IAM:

Papel de conta de serviço

Para garantir que a conta de serviço padrão do Compute Engine tenha as permissões necessárias para criar uma sessão interativa, peça ao administrador para conceder o papel do IAM de worker do Dataproc (roles/dataproc.worker) à conta de serviço padrão do Compute Engine no projeto.

Instalar a extensão do JupyterLab

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

Para instalar a extensão, siga estas etapas:

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

    • Verifique a instalação do Python 3.11 ou mais recente. 
      python3 --version

  2. Virtualize o ambiente Python. 

    pip3 install pipenv

    • Crie uma pasta de instalação. 
      mkdir jupyter
    • Mude para a pasta de instalação. 
      cd jupyter
    • Crie um ambiente virtual. 
      pipenv shell

  3. Instale o JupyterLab no ambiente virtual. 

    pipenv install jupyterlab

  4. Instale a extensão do JupyterLab. 

    pipenv install bigquery-jupyter-plugin

  5. Inicie o JupyterLab. 

    jupyter lab

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

      Página do navegador do acesso rápido do JupyterLab

    2. Por padrão, sua sessão interativa é executada no projeto e na região que você definiu ao executar gcloud init em Antes de começar. É possível mudar as configurações de projeto e região das suas sessões em JupyterLab Configurações > Google Cloud Configurações > Google Cloud Configurações do projeto.

      É necessário reiniciar a extensão para que as mudanças entrem em vigor.

Criar um modelo de ambiente de execução do Serviço Gerenciado para Apache Spark

Os modelos de tempo de execução do Serviço Gerenciado para Apache Spark (também chamados de modelos de sessão) contêm configurações para executar código Spark em uma sessão. É possível criar e gerenciar modelos de tempo de execução usando o Jupyterlab ou a Google Cloud CLI.

JupyterLab

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

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

    • Informações do modelo:

      • Nome de exibição, ID do ambiente de execução e Descrição: aceite ou preencha um nome de exibição, um ID do ambiente de execução e uma descrição do modelo.

    • Configuração de execução: selecione Conta de usuário para executar notebooks com a identidade do usuário em vez da identidade da conta de serviço do Dataproc.

      • Conta de serviço: se você não especificar uma conta de serviço, a conta de serviço padrão do Compute Engine será usada.
      • Versão do ambiente de execução: confirme ou selecione a versão do ambiente de execução 2.3.
      • Imagem de contêiner personalizada: especifique opcionalmente o URI de uma imagem de contêiner personalizada.
      • Bucket de preparo: você pode especificar o nome de um bucket de preparo do Cloud Storage para uso pelo Serviço gerenciado para Apache Spark.
      • Repositório de pacotes Python: por padrão, os pacotes Python são baixados e instalados do cache de pull-through do PyPI quando os usuários executam comandos de instalação pip nos notebooks. É possível especificar o repositório de artefatos particulares da sua organização para pacotes Python como o repositório padrão de pacotes Python.

    • Criptografia: aceite o Google-owned and Google-managed encryption key padrão ou selecione Chave de criptografia gerenciada pelo cliente (CMEK). Se for CMEK, selecione ou forneça as informações da chave.

    • Configuração de rede: selecione uma sub-rede no projeto ou compartilhada de um projeto host. É possível mudar o projeto em Configurações do JupyterLab > Google Cloud Configurações > Google Cloud Configurações do projeto. É possível especificar tags de rede para aplicar à rede especificada. Observação: o Serviço gerenciado para Apache Spark ativa o Acesso privado do Google (PGA) na sub-rede especificada. Para requisitos de conectividade de rede, consulte Configuração de rede do Serviço Gerenciado para Apache Spark.

    • Configuração da sessão: você pode preencher esses campos para limitar a duração das sessões criadas com o modelo.

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

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

    • Servidor de histórico permanente: você pode selecionar um servidor de histórico permanente do Spark disponível para acessar os registros de sessão durante e depois das sessões.

    • Propriedades do Spark:é possível selecionar e adicionar propriedades de alocação de recursos, escalonamento automático ou GPU do Spark. Clique em Adicionar propriedade para incluir outras propriedades do Spark. Para mais informações, consulte Propriedades do Spark.

    • Rótulos:clique em Adicionar rótulo para cada rótulo que será definido nas sessões criadas com o modelo.

  3. Clique em Salvar para criar o modelo.

  4. Para ver ou excluir um modelo de ambiente de execução.

    1. Clique em Configurações > Google Cloud Configurações.

    2. A seção Configurações do Dataproc > Modelos de ambiente de execução sem servidor mostra a lista de modelos de ambiente de execução.

      Lista de modelos de ambiente de execução

      • Clique no nome de um modelo para conferir os detalhes dele.
      • É possível excluir um modelo no menu Ação dele.

  5. Abra e recarregue a página Acesso rápido do JupyterLab para ver o card do modelo de notebook salvo.

gcloud

  1. Crie um arquivo YAML com a configuração do modelo de ambiente 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

    description: Example session template
environmentConfig:
  executionConfig:
    serviceAccount: sa1
    # Choose either networkUri or subnetworkUri
    networkUri:
    subnetworkUri: default
    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: "2.3"
  containerImage: gcr.io/my-project-id/my-image:1.0.1
  properties:
    "p1": "v1"
description: Team A Development Environment

  2. Crie um modelo de sessão (tempo de execução) com base no arquivo YAML executando o seguinte comando gcloud beta dataproc session-templates import 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 a extensão do Serviço Gerenciado para Apache Spark JupyterLab, clique nos cards de modelo na página Launcher do JupyterLab para:

Iniciar um notebook do Jupyter

A seção Notebooks sem servidor do Dataproc na página do iniciador do JupyterLab mostra cards de modelo de notebook que correspondem aos modelos de ambiente de execução do Serviço Gerenciado para Apache Spark. Consulte Criar um modelo de ambiente de execução do Serviço Gerenciado para Apache Spark.

  1. Clique em um card para criar uma sessão do Serviço Gerenciado para Apache Spark 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 dele mudará de Starting para Idle (Ready).

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

    1. Copie e cole o seguinte código PySpark Pi estimation na célula do notebook 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 Desligar kernel na guia Kernel.

    • Para reutilizar a sessão, crie um notebook escolhendo Notebook no menu Arquivo>>Novo. Depois que o novo notebook for criado, escolha a sessão atual na caixa de diálogo de seleção do kernel. O novo notebook vai reutilizar a sessão e manter o contexto da sessão do notebook anterior.

  4. Se você não encerrar a sessão, o Serviço Gerenciado para Apache Spark a encerrará quando o temporizador de inatividade dela expirar. Você pode configurar o tempo de inatividade da sessão na configuração do modelo de ambiente de execução. O tempo de inatividade de sessão padrão é de uma hora.

Iniciar um notebook em um cluster

Se você criou um cluster Jupyter do Serviço Gerenciado para Apache Spark, a página Launcher do JupyterLab contém uma seção Notebook do cluster do Dataproc com cards de kernel pré-instalados.

Para iniciar um notebook Jupyter no cluster do Serviço Gerenciado para Apache Spark no Compute Engine:

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

  2. Quando o status do kernel mudar de Starting para Idle (Ready), você poderá 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 Desligar 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 Serviço Gerenciado para Apache Spark acessa esses arquivos no Cloud Storage.

  • Para acessar o navegador do Cloud Storage, clique no ícone dele 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 mudanças nos arquivos, elas são gravadas no Cloud Storage.

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

  • Para fazer upload de arquivos em um bucket do Cloud Storage ou pasta, clique no ícone de upload e selecione os arquivos que você quer enviar.

Desenvolver código de notebook do Spark

Depois de instalar a extensão do JupyterLab, é possível iniciar os notebooks do Jupyter na página Acesso rápido do JupyterLab para desenvolver código do aplicativo.

Desenvolvimento de código PySpark e Python

Os clusters do Serviço Gerenciado para Apache Spark são compatíveis com kernels do PySpark e do Python.

Desenvolvimento de código SQL

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

Magia do Spark SQL:como o kernel do PySpark que inicia os Notebooks sem servidor do Dataproc já vem com a magia do Spark SQL, em vez de usar spark.sql('SQL STATEMENT').show() para encapsular sua instrução SQL, digite %%sparksql magic na parte de cima de uma célula e digite sua instrução SQL nela.

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

Os ambientes de execução do Serviço Gerenciado para Apache Spark 2.2 e versões mais recentes incluem o conector do BigQuery para Spark. Se você usar um ambiente de execução anterior para iniciar notebooks do Serviço Gerenciado para Apache Spark, instale o conector do BigQuery para Spark adicionando a seguinte propriedade do Spark ao seu modelo de ambiente de execução do Serviço Gerenciado para Apache Spark:

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

Desenvolvimento de código Scala

Os clusters do Serviço Gerenciado para Apache Spark criados com versões de imagem 2.0 e mais recentes incluem 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 da página Acesso rápido do JupyterLab para abrir um notebook para desenvolvimento de código em Scala.

    Figura 1. Card do kernel do Apache Toree na página de acesso rápido do JupyterLab.

Desenvolver código com a extensão do Visual Studio Code

Com a extensão do Google Cloud Visual Studio Code (VS Code), é possível fazer o seguinte:

  • Desenvolver e executar código do Spark em notebooks do Serviço Gerenciado para Apache Spark.
  • Criar e gerenciar modelos de ambiente de execução (sessão) do Serviço Gerenciado para Apache Spark, sessões interativas e cargas de trabalho em lote.

A extensão do Visual Studio Code é sem custo financeiro, mas você recebe cobranças por todos os serviços doGoogle Cloud , incluindo o Serviço Gerenciado para Apache Spark e os recursos do Cloud Storage que você usa.

Usar o VS Code com o BigQuery: também é possível usar o VS Code com o BigQuery para fazer o seguinte:

  • Desenvolver e executar notebooks do BigQuery.
  • Navegue, inspecione e visualize conjuntos de dados do BigQuery.

Antes de começar

  1. Faça o download e instale o VS Code.
  2. Abra o VS Code e, na barra de atividades, clique em Extensões.

  3. Na barra de pesquisa, encontre a extensão Jupyter e clique em Instalar. A extensão do Jupyter da Microsoft é uma dependência obrigatória.

    Uma lista de extensões do Jupyter no console do VS Code.

Instalar a extensão Google Cloud

  1. Abra o VS Code e, na barra de atividades, clique em Extensões.

  2. Use a barra de pesquisa para encontrar a extensão Google Cloud Code e clique em Instalar.

    A extensão Google Cloud Code no console do VS Code.

  3. Se solicitado, reinicie o VS Code.

O ícone Google Cloud Code agora está visível na barra de atividades do VS Code.

Configurar a extensão

  1. Abra o VS Code e, na barra de atividades, clique em Google Cloud Code.
  2. Abra a seção Dataproc.
  3. Clique em Fazer login em Google Cloud. Você será redirecionado para fazer login com suas credenciais.
  4. Use a barra de tarefas superior do aplicativo para navegar até Código > Configurações > Configurações > Extensões.
  5. Encontre Google Cloud Código e clique no ícone Gerenciar para abrir o menu.
  6. Selecione Configurações.
  7. Nos campos Projeto e Região do Serviço Gerenciado para Apache Spark, insira o nome do projeto Google Cloud e a região a serem usados para desenvolver notebooks e gerenciar recursos do Serviço Gerenciado para Apache Spark.

Desenvolver notebooks

  1. Abra o VS Code e, na barra de atividades, clique em Google Cloud Code.
  2. Abra a seção Notebooks e clique em Novo notebook do Spark sem servidor.
  3. Selecione ou crie um modelo de ambiente de execução (sessão) para usar na sessão do notebook.

  4. Um novo arquivo .ipynb com um exemplo de código é criado e aberto no editor.

    Novo notebook do Spark sem servidor no console do VS Code.

    Agora é possível escrever e executar código no notebook do Serviço Gerenciado para Apache Spark.

Criar e gerenciar recursos

  1. Abra o VS Code e, na barra de atividades, clique em Google Cloud Code.

  2. Abra a seção Dataproc e clique nos seguintes nomes de recursos:

    • Clusters: crie e gerencie clusters e jobs.
    • Sem servidor: crie e gerencie cargas de trabalho em lote e sessões interativas.
    • Modelos de ambiente de execução do Spark: crie e gerencie modelos de sessão.

    Recursos do Dataproc listados no console do VS Code.

Explorador de conjunto de dados

Use o explorador de conjuntos de dados do JupyterLab para ver os conjuntos de dados do metastore do BigLake.

Para abrir o Explorador de conjunto de dados do JupyterLab, clique no ícone dele na barra lateral.

É possível pesquisar um banco de dados, uma tabela ou uma coluna no explorador de conjuntos de dados. Clique no nome de um banco de dados, tabela ou coluna para ver os metadados associados.

Implantar o código

Depois de instalar a extensão do JupyterLab, você pode usar o JupyterLab para:

  • Executar o código do notebook na infraestrutura do Serviço Gerenciado para Apache Spark

  • Programar a execução de notebooks no Serviço gerenciado para Apache Airflow

  • Envie jobs em lote para a infraestrutura do Serviço Gerenciado para Apache Spark ou para seu cluster do Serviço Gerenciado para Apache Spark.

Programar a execução de notebooks no Airflow gerenciado

Conclua as etapas a seguir para programar o código do notebook no Airflow gerenciado para ser executado como um job em lote no Serviço Gerenciado para Apache Spark ou em um cluster do Serviço Gerenciado para Apache Spark.

  1. Crie um ambiente do Airflow gerenciado.

  2. Clique no botão Job Scheduler no canto superior direito do notebook.

  3. Preencha o formulário Criar um job programado para fornecer as seguintes informações:

    • Um nome exclusivo para o job de execução do notebook
    • O ambiente do Airflow Gerenciado a ser usado para implantar o notebook
    • Parâmetros de entrada, se o notebook estiver parametrizado
    • O cluster do Serviço Gerenciado para Apache Spark ou o modelo de ambiente de execução sem servidor a ser usado para executar o notebook
      • Se um cluster for selecionado, pare o cluster depois que o notebook terminar de ser executado nele.
    • Contagem de tentativas e atraso na repetição em minutos se a execução do notebook falhar na primeira tentativa
    • Notificações de execução a serem enviadas e a lista de destinatários. As notificações são enviadas usando uma configuração SMTP do Airflow.
    • A programação de execução do notebook

  4. Clique em Criar.

  5. Depois que o notebook é programado, o nome do job aparece na lista de jobs programados no ambiente do Airflow Gerenciado.

Enviar um job em lote para o Serviço Gerenciado para Apache Spark

  • Clique no card Sem servidor na seção Jobs e sessões do Dataproc na página Acesso rápido do JupyterLab.

  • Clique na guia Lote e em Criar lote. Preencha os campos Informações do lote.

  • Clique em Enviar para enviar o job.

Enviar um job em lote para um cluster do Serviço Gerenciado para Apache Spark

  • Clique no card Clusters na seção Jobs e sessões do Dataproc na página Acesso rápido 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.

Ver e gerenciar recursos

Depois de instalar a extensão do JupyterLab, é possível conferir e gerenciar o Serviço Gerenciado para Apache Spark e o Serviço Gerenciado para Apache Spark 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 Sem servidor.

Para conferir e gerenciar sessões do Serviço Gerenciado para Apache Spark:

  1. Clique no card Sem servidor.
  2. Clique na guia Sessões e em um ID de sessão para abrir a página Detalhes da sessão. Nela, é possível conferir as propriedades da sessão, ver os registros Google Cloud na Análise de registros e encerrar uma sessão. Observação: uma sessão exclusiva do Serviço Gerenciado para Apache Spark é criada para iniciar cada notebook do Serviço Gerenciado para Apache Spark.

Para conferir e gerenciar lotes do Serviço Gerenciado para Apache Spark:

  1. Clique na guia Lotes para conferir a lista de lotes do Serviço Gerenciado para Apache Spark no projeto e na região atuais. Clique em um ID do lote para ver os detalhes dele.

Para conferir e gerenciar clusters do Serviço Gerenciado para Apache Spark:

  1. Clique no card Clusters. A guia Clusters é selecionada para listar os clusters ativos do Serviço Gerenciado para Apache Spark 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 ver os detalhes dele. Clique nos ícones na coluna Ações para clonar, interromper ou excluir um job.

Para conferir e gerenciar jobs do Serviço Gerenciado para Apache Spark:

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