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 o código do notebook do Spark sem servidor.

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

  • Iniciar notebooks sem servidor do Spark e do BigQuery 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

Use o Google Cloud Data Agent Kit: além do JupyterLab, também é possível desenvolver e gerenciar suas cargas de trabalho do serviço gerenciado para Apache Spark no VS Code usando o Data Agent Kit. Com o Data Agent Kit, você pode gerenciar todo o ciclo de vida da carga de trabalho de dados no seu IDE ou usando uma Agents CLI compatível, incluindo a criação de pipelines de dados.

Antes de começar

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

  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, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  6. Install the Google Cloud CLI.

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

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

    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, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  13. Install the Google Cloud CLI.

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

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

    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 para 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. Baixe e instale o Python versão 3.11 ou mais recente em python.org/downloads.

    • Verifique a instalação do Python 3.11+. 
      python3 --version

  2. Virtualize o ambiente do 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 Acesso rápido do JupyterLab é aberta no navegador. Ele contém uma seção Jobs e sessões do Dataproc. Ele também pode conter as seções Notebooks do Dataproc sem servidor e Notebooks de cluster do Dataproc se você tiver acesso aos notebooks ou clusters do Serviço Gerenciado para Apache Spark com o componente opcional do Jupyter em execução no seu projeto.

      Página do navegador do inicializador 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 sessões em Configurações > Google Cloud Configurações > Google Cloud Configurações do projeto do JupyterLab.

      É 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 ambiente de execução do Serviço Gerenciado para Apache Spark (chamados de perfis de ambiente de execução na página Perfis de ambiente de execução no console doGoogle Cloud e de modelos de sessão na Google Cloud CLI e na API Dataproc) contêm configurações para executar o código do Spark em uma sessão. É possível criar e gerenciar modelos de ambiente de execução usando o JupyterLab, o console doGoogle Cloud ou a Google Cloud CLI.

JupyterLab

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

  2. Preencha o formulário Modelo de ambiente 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 do 2.3.
      • Imagem de contêiner personalizada: se quiser, especifique o URI de uma imagem de contêiner personalizada.
      • Bucket de preparo: é possível especificar o nome de um bucket de preparo do Cloud Storage para uso pelo Serviço Gerenciado para Apache Spark.
      • Repositório de pacotes do Python: por padrão, os pacotes do 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 que os pacotes do Python sejam usados como o repositório padrão de pacotes do Python.

    • Criptografia: aceite 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 em Configurações > Google Cloud Configurações > Google Cloud Configurações do projeto do JupyterLab. É possível especificar tags de rede para aplicar à rede especificada. Observe que 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: é possível 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 que ela seja encerrada. Intervalo permitido: de 10 minutos a 336 horas (14 dias).

    • Metastore: para usar um serviço do Dataproc Metastore 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: é possível selecionar e adicionar propriedades de Alocação de recursos, Escalonamento automático 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 visualizar 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 atualize 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 (perfil de ambiente 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 JupyterLab do Serviço Gerenciado para Apache Spark, clique nos cards de modelo na página Iniciador do JupyterLab para:

Iniciar um notebook do Jupyter

A seção Notebooks sem servidor do Dataproc na página do inicializador do JupyterLab exibe cards de modelos de notebook que são mapeados para modelos de ambiente de execução do Managed Service para Apache Spark (consulte Criar um modelo de ambiente de execução do Managed Service 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 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 Desligar 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 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 do Jupyter do Serviço Gerenciado para Apache Spark, a página Iniciador do JupyterLab contém uma seção Notebook do cluster do Dataproc com cards de kernel pré-instalados.

Para iniciar um notebook do 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), será 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 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 do navegador do Cloud Storage na barra lateral da página Iniciador do JupyterLab e clique duas vezes em uma pasta para ver 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 para um bucket do Cloud Storage ou uma pasta, clique no ícone de upload e selecione os arquivos.

Desenvolver código de notebook do Spark

Depois de instalar a extensão do JupyterLab, é possível iniciar notebooks do Jupyter na página Acesso rápido do JupyterLab para desenvolver o 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 para escrever e executar código SQL, na página Iniciador do JupyterLab, na seção Notebooks do Dataproc sem servidor ou Notebook do cluster do Dataproc, clique no card do kernel do PySpark.

Spark SQL Magic: como o kernel do PySpark que inicia os notebooks do Dataproc sem servidor é pré-carregado com o Spark SQL Magic, em vez de usar spark.sql('SQL STATEMENT').show() para encapsular a instrução SQL, digite %%sparksql magic na parte de cima de uma célula e, em seguida, digite a instrução SQL na célula.

SQL do BigQuery: o conector do BigQuery para 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.

O Serviço Gerenciado para Apache Spark 2.2 e os ambientes de execução posteriores incluem o conector do BigQuery Spark. Se você usar um ambiente de execução anterior para iniciar notebooks do Serviço Gerenciado para Apache Spark, poderá instalar o conector do Spark para BigQuery adicionando a seguinte propriedade do Spark ao 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 as versões de imagem 2.0 e posteriores incluem o Apache Toree, um kernel do Scala para a plataforma Jupyter Notebook que fornece acesso interativo ao Spark.

  • Clique no card do Apache Toree na seção Notebook do cluster do Dataproc na página Acesso rápido do JupyterLab para abrir um notebook para desenvolvimento de código 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

Use a extensão do Google Cloud Visual Studio Code (VS Code) para fazer o seguinte:

  • Desenvolva e execute código do Spark em notebooks do Serviço Gerenciado para Apache Spark.

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

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

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.
  • Navegar, inspecionar e visualizar 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. Usando a 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 do Google Cloud

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

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

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

  3. Se solicitado, reinicie o VS Code.

O ícone do 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 no Google Cloud. Você será redirecionado para fazer login com suas credenciais.
  4. Use a barra de tarefas superior do aplicativo para acessar 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 do Google Cloud e a região que serão 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 novo perfil de ambiente de execução (modelo de 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 você pode 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 perfis de ambiente de execução (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 visualizar conjuntos de dados do metastore do BigLake.

Para abrir o Explorador de Conjuntos 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, é possível usá-lo 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 o cluster do Serviço Gerenciado para Apache Spark.

Programar a execução de notebooks no Airflow Gerenciado

Siga as etapas abaixo 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. Criar um ambiente do Airflow Gerenciado.

  2. Clique no botão Programador de jobs 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 modelo de ambiente de execução sem servidor ou cluster do Serviço Gerenciado para Apache Spark a ser usado para executar o notebook.
      • Se um cluster for selecionado, se ele será interrompido depois que o notebook terminar de ser executado no cluster
    • Contagem de novas tentativas e atraso 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 for programado, o nome do job vai aparecer 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, em Criar lote e 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 de 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 Iniciador do JupyterLab.

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

Para conferir e gerenciar as 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, onde é possível conferir as propriedades da sessão, os registros do 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 de 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 está 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 visualizar 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 da tarefa para ver os detalhes dele.