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

O

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

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

  • Iniciar notebooks do Spark e do BigQuery sem servidor para desenvolver códigos 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. 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. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

    gcloud init

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

    Go to project selector

  8. Enable the Dataproc API.

    Enable the API

  9. Install the Google Cloud CLI.

  10. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

    gcloud init

    12. 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 a 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 a versão 3.11 ou mais recente do Python 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 JupyterLab. 

      pipenv install bigquery-jupyter-plugin

    5. 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.

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

      2. Por padrão, a sessão do Dataproc sem servidor para Spark interativo é 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 do projeto e da região das suas sessões na página Configurações > Configurações do Google Dataproc do JupyterLab.

        Reinicie a extensão para que as mudanças entrem em vigor.

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

    Os modelos de ambiente de execução do Dataproc sem servidor (também chamados de modelos de sessão) 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 Acesso rápido do JupyterLab.

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

      • Informações do modelo:

        • Nome de exibição, ID de execução e Descrição: aceite ou preencha um nome de exibição, um ID 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.
        • Imagem de contêiner personalizada: especifique o URI de uma imagem de contêiner personalizada.
        • Repositório de pacotes do Python: por padrão, os pacotes Python são transferidos por download 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 particular da sua organização para que os pacotes Python o usem como o repositório de pacotes Python padrão.

      • Criptografia: aceite a configuração padrão Google-owned and Google-managed encryption key 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 no menu Configurações > Configurações do Google Dataproc do JupyterLab. É possível especificar tags de rede para aplicar à rede especificada. O Dataproc Serverless ativa o Acesso privado do Google (PGA, na sigla em inglês) na sub-rede especificada. Para requisitos de conectividade de rede, consulte Configuração de rede do Dataproc Serverless para Spark.

      • Configuração da sessão: preencha 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 de sessão:o tempo máximo de vida de uma sessão antes que ela seja 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: é possível selecionar um servidor de histórico permanente do Spark disponível para acessar os registros de sessão durante e após as sessões.

      • Propriedades do Spark:selecione e adicione as propriedades Resource Allocation, Autoscaling ou GPU do Spark. Clique em Adicionar propriedade para adicionar outras propriedades do Spark. Para mais informações, consulte Propriedades do Spark.

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

    3. Clique em Salvar para criar o modelo.

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

      1. Clique em Configurações > Configurações do Google Dataproc.
      2. A seção "Modelos de ambiente de execução sem servidor do Dataproc" mostra a 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.

    5. 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

      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 (runtime) 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 a extensão 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 de acesso rápido 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 do Dataproc Serverless 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. 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.

      • Para reutilizar a sessão, crie um novo notebook escolhendo Notebook no menu File>>New. 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 Dataproc 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 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 Starting para Idle (Ready), é 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 a extensão 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 e 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.

    BigQuery SQL: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 Dataproc Serverless 2.2 e os ambientes de execução mais recentes incluem o conector do BigQuery Spark. Se você usar 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 versões de imagem 2.0 e 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.

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

    Você pode usar a extensão Google Cloud Visual Studio Code (VS Code) para fazer o seguinte:

    • Desenvolva e execute o código do Spark em notebooks do Dataproc Serverless.
    • Crie e gerencie modelos de ambiente de execução (sessões) do Dataproc sem servidor, sessões interativas e cargas de trabalho em lote.

    A extensão do Visual Studio Code é gratuita, mas você vai receber cobranças por todos os serviçosGoogle Cloud , incluindo o Dataproc, o Dataproc sem servidor 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:

    • Desenvolva e execute notebooks do BigQuery.
    • Navegue, inspecione e visualize os 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 Extensions.

    3. Usando a barra de pesquisa, encontre a extensão Jupyter e clique em Install. A extensão Jupyter da Microsoft é uma dependência necessá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 Extensions.

    2. Usando a barra de pesquisa, encontre a extensão Google Cloud Code e clique em Install.

      A extensão de código Google Cloud 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 do aplicativo de nível superior para navegar até Código > Configurações > Configurações > Extensões.
    5. Encontre Google Cloud Code e clique no ícone Manage para abrir o menu.
    6. Selecione Configurações.
    7. Nos campos Project e Dataproc Region, digite o nome do Google Cloud projeto e a região a serem usados para desenvolver notebooks e gerenciar recursos do Dataproc sem servidor.

    Desenvolver notebooks do Dataproc sem servidor

    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 novo modelo de execução (sessão) para usar na sessão do notebook.

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

      Novo notebook do Serverless Spark no console do VS Code.

      Agora é possível escrever e executar códigos no seu notebook do Dataproc Serverless.

    Criar e gerenciar recursos do Dataproc sem servidor

    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 conjuntos de dados

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

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

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

    Implantar o código

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

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

    • Programar a execução de notebooks no Cloud Composer

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

    Programar a execução de notebooks no Cloud Composer

    Siga as etapas abaixo para programar o código do notebook no Cloud Composer para ser executado como um job em lote no Dataproc sem servidor ou em um cluster do Dataproc no Compute Engine.

    1. Crie um ambiente do Cloud Composer..

    2. Clique no botão Job Scheduler no canto superior direito do bloco de notas.

    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 Cloud Composer a ser usado para implantar o notebook
      • Parâmetros de entrada se o notebook estiver parametrizado
      • O cluster do Dataproc ou o modelo de ambiente de execução sem servidor para usar executar o notebook
        • Se um cluster for selecionado, pare-o 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
      • As 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.
      • 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 Cloud Composer.

    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 e em Create Batch. Em seguida, 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 a extensão do Dataproc JupyterLab, você pode conferir e gerenciar o Dataproc sem servidor e o Dataproc no Compute Engine na seção Jobs and Sessions 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 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 sem servidor 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.