Personas e papéis do IAM sem servidor

Este guia mostra aos desenvolvedores, administradores e leitores do Spark como conseguir as permissões necessárias para começar a usar as cargas de trabalho em lote e as sessões interativas sem servidor do Serviço Gerenciado para Apache Spark.

Persona Quem são eles na organização O que eles precisam do IAM
Desenvolvedor do Spark O criador e o consumidor da plataforma. Grava e executa jobs do PySpark e do Spark, desenvolve em notebooks e sessões, lê e grava conjuntos de dados e monitora e soluciona problemas de cargas de trabalho. Inclui engenheiros de dados, cientistas de dados e desenvolvedores. Permissões para enviar, executar, monitorar e solucionar problemas de cargas de trabalho, além de ler e gravar os dados que os jobs acessam.
Administrador do Spark O proprietário e o administrador da plataforma. Configura o projeto, decide como as cargas de trabalho são autenticadas, integra desenvolvedores do Spark, gerencia contas de serviço compartilhadas e aplica proteções da organização e privilégio mínimo. Também chamado de administrador da plataforma. Permissões para conceder acesso a outras pessoas, configurar a identidade de execução (credenciais do usuário final ou uma conta de serviço compartilhada) e gerenciar recursos sem servidor em todo o projeto.
Leitor do Spark O observador e auditor da plataforma. Rastreia a conclusão de jobs, o histórico de execução, as métricas e os painéis sem enviar ou modificar cargas de trabalho. Inclui analistas, gerentes de projetos, FinOps e auditores de compliance. Permissões somente leitura para visualizar lotes, sessões, operações e painéis de status.

Escolha uma versão do ambiente de execução

A versão recomendada do ambiente de execução depende da versão do Apache Spark em que as cargas de trabalho são executadas.

  • Ambiente de execução 3.x (recomendado): usa o Spark 4 e tem integração e uso mais simples. Por padrão, as cargas de trabalho são executadas como o usuário que as enviou com as credenciais de usuário final (EUC, na sigla em inglês), o que exige a concessão de um único papel do IAM ao usuário. Os administradores podem configurar contas de serviço personalizadas de carga de trabalho para uso mais avançado.

  • Ambiente de execução 2.x: usa o Spark 3.5 e contas separadas de remetente e carga de trabalho. Por padrão, o remetente é a identidade do usuário, e a conta de serviço padrão do Compute Engine é a identidade da carga de trabalho. Os administradores podem configurar contas de serviço de carga de trabalho personalizadas para um controle de acesso mais refinado.

Para mais informações, consulte Versões do ambiente de execução do Serviço Gerenciado para Apache Spark.

Comparação dos recursos

O ambiente de execução 3.x faz upgrade dos componentes e recursos do 2.x e oferece uma configuração simplificada:

Capacidade e fluxo de trabalho Ambiente de execução 3.x (recomendado) Ambiente de execução 2.x
Versão do Apache Spark Spark 4 Spark 3.5 (e versões anteriores do 3.x)
Desenvolvimento interativo Sessões do Spark Connect (cliente interativo do Spark padrão do setor) Sessões do Jupyter
Cargas de trabalho em lote do R sparklyr Lotes do SparkR
Identidade de execução Credenciais do usuário final (EUC)1 Conta de serviço 1
Armazenamento para preparo de jobs Não é necessário (gerenciado internamente) Buckets de preparo do Cloud Storage
Formato de saída do registro Formato JSON estruturado (jsonPayload) Formato de texto simples (textPayload)

1 O ambiente de execução 3.x usa como padrão as credenciais de usuário final (EUC, na sigla em inglês) do remetente, a menos que uma conta de serviço personalizada seja especificada para a carga de trabalho ou sessão. O ambiente de execução 2.x usa como padrão a conta de serviço padrão do Compute Engine, a menos que uma conta de serviço personalizada seja especificada para a carga de trabalho ou sessão.

Papéis comuns de dados e serviços

Serviço Gerenciado para Apache Spark, normalmente para ler e gravar em outros serviços doGoogle Cloud . Nesta seção, listamos os papéis associados a serviços acessados com frequência.

  • Ambiente de execução 3.x (identidade EUC padrão): conceda papéis ao desenvolvedor do Spark (usuário ou grupo).
  • Ambiente de execução 2.x: conceda papéis à conta de serviço da carga de trabalho (a conta de serviço padrão do Compute Engine ou uma conta de serviço personalizada da carga de trabalho).
Serviço ou API Papel Finalidade
Cloud Storage roles/storage.objectViewer
roles/storage.objectAdmin
Ler dados de entrada e scripts em etapas.
Gravar dados de saída.
Catálogo do ambiente de execução do BigLake e do Lakehouse roles/biglake.viewer
roles/biglake.editor
roles/biglake.admin
Consulte e gerencie formatos de tabela abertos, como Apache Iceberg e Delta Lake, usando o catálogo REST do BigLake (Catálogo REST do Lakehouse (LRC)).
Bigtable roles/bigtable.reader
roles/bigtable.user
Ler tabelas do Bigtable.
Ler e gravar dados do Bigtable.
Dataproc Metastore (DPMS) roles/metastore.metadataViewer
roles/metastore.editor
Ler metadados do Hive.
Gerenciar esquemas e tabelas de metadados.

O DPMS é um metastore legado. Recomendamos que os clientes usem o catálogo REST do Lakehouse (LRC) do BigLake.

O BigQuery oferece muitos papéis do IAM refinados e ACLs no nível do recurso. Para mais informações, consulte Papéis e permissões do IAM do BigQuery.

Conceder papéis

A seção a seguir contém instruções sobre como conceder papéis para cada uma das personas associadas à configuração, ao envio e ao monitoramento de cargas de trabalho em lote e sessões interativas sem servidor do Serviço Gerenciado para Apache Spark 3.x e 2.x.

Ambiente de execução 3.x

Por padrão, as cargas de trabalho do 3.x são executadas com as credenciais de usuário final (EUC, na sigla em inglês) do usuário que as enviou. Os administradores concedem um único papel ao usuário, e não são necessárias contas de serviço compartilhadas ou buckets de preparo. Os administradores podem configurar contas de serviço personalizadas quando identidades de serviço dedicadas são necessárias.

Desenvolvedor

Desenvolvedor do Spark (ambiente de execução 3.x)

Como desenvolvedor do Spark, é possível usar o ambiente de execução 3.x com suas credenciais de usuário para desenvolver, enviar, monitorar e resolver problemas de cargas de trabalho do Spark, além de acessar dados diretamente.

  1. Solicite o papel de editor sem servidor. Peça ao administrador para conceder a você roles/dataproc.serverlessEditor no projeto.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/dataproc.serverlessEditor"
    

    Esse papel permite enviar, monitorar, solucionar problemas e cancelar cargas de trabalho em lote do Spark e sessões interativas do Spark Connect.

  2. Acessar dados e serviços. Como a carga de trabalho é executada como você, sua identidade precisa de acesso aos serviços e conjuntos de dados que o aplicativo Spark toca (consulte Papéis comuns de dados e serviços).

    Por exemplo, conceda a si mesmo acesso de leitura a um bucket de entrada do Cloud Storage:

    gcloud storage buckets add-iam-policy-binding gs://INPUT_BUCKET \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/storage.objectViewer"
    
  3. Envie uma carga de trabalho de teste. Envie uma carga de trabalho em lote de teste para confirmar a configuração.

    gcloud dataproc batches submit spark \
      --region=REGION \
      --version=3.0 \
      --class=org.apache.spark.examples.SparkPi \
      --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
      -- 1000
    

    Observações:

Contas de serviço de carga de trabalho personalizadas (ambiente de execução 3.x)

Use uma conta de serviço personalizada com o ambiente de execução 3.x quando sua organização exigir que as cargas de trabalho sejam executadas em uma identidade dedicada e auditável, em vez de credenciais de usuário final (consulte Práticas recomendadas para contas de serviço do IAM).

  1. Receba permissão para executar cargas de trabalho como a conta de serviço personalizada. Peça ao administrador para conceder a você roles/iam.serviceAccountUser na conta de serviço personalizada.

    gcloud iam service-accounts add-iam-policy-binding \
      WORKLOAD_SA_EMAIL \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/iam.serviceAccountUser"
    
  2. Especifique o serviço personalizado.

    gcloud dataproc batches submit spark \
      --region=REGION \
      --service-account=WORKLOAD_SA_EMAIL \
      --version=3.0 \
      --class=org.apache.spark.examples.SparkPi \
      --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
      -- 1000
    
  3. Conceder acesso ao conjunto de dados. Ao usar uma conta de serviço personalizada, conceda papéis no nível de dados diretamente a WORKLOAD_SA_EMAIL (consulte Papéis comuns de dados e de serviço).

Administrador

Administrador do Spark (ambiente de execução 3.x)

Como administrador do Spark, você configura o projeto, decide como as cargas de trabalho são autenticadas e concede acesso aos desenvolvedores do Spark.

As cargas de trabalho usam a sub-rede VPC default nomeada automaticamente. Se o projeto não tiver uma rede default ou usar VPCs personalizadas, consulte Configuração de rede sem servidor do Serviço Gerenciado para Apache Spark para configurar e especificar uma sub-rede para cargas de trabalho e sessões.

Ativar o ambiente de execução 3.x com credenciais de usuário final (recomendado)

Essa é a configuração de privilégio mínimo e manutenção mais baixa. Cada desenvolvedor do Spark executa cargas de trabalho como a identidade do usuário. Os administradores não precisam configurar e gerenciar contas de serviço de carga de trabalho.

  1. Conceda roles/dataproc.serverlessEditor aos desenvolvedores do Spark.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/dataproc.serverlessEditor"
    
  2. Conceda roles/dataproc.serverlessViewer aos leitores.

    Conceda esse papel a auditores, consumidores de painéis e membros da equipe que precisam monitorar o status e os registros de jobs sem enviar ou modificar cargas de trabalho.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:VIEWER_EMAIL" \
      --role="roles/dataproc.serverlessViewer"
    
  3. Garantir o acesso do desenvolvedor aos dados.

    Por padrão, as cargas de trabalho do ambiente de execução 3.x são executadas como o usuário que as enviou. Conceda papéis de acesso a dados, como roles/storage.objectViewer ou roles/storage.objectAdmin, ao desenvolvedor do Spark ou ao Grupo do Google que inclui desenvolvedores do Spark (consulte Papéis comuns de dados e serviços).

Ativar contas de serviço personalizadas de carga de trabalho (ambiente de execução 3.x)

Use uma conta de serviço personalizada com o ambiente de execução 3.x quando precisar que as cargas de trabalho sejam executadas em uma identidade dedicada e auditável em vez de credenciais de usuário final (consulte Práticas recomendadas para contas de serviço do IAM).

  1. Conceda roles/iam.serviceAccountUser na conta de serviço personalizada da carga de trabalho.

    gcloud iam service-accounts add-iam-policy-binding \
      WORKLOAD_SA_EMAIL \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/iam.serviceAccountUser"
    
  2. Conceda roles/dataproc.serverlessNode à conta de serviço personalizada da carga de trabalho.

    Esse papel permite que a conta de serviço gerencie pools de nós de computação e se comunique com aplicativos do Spark durante a execução da carga de trabalho:

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="serviceAccount:WORKLOAD_SA_EMAIL" \
      --role="roles/dataproc.serverlessNode"
    
  3. Conceder acesso aos dados do aplicativo.

    Conceda papéis no nível de dados diretamente à conta de serviço da carga de trabalho para que ela possa ler e gravar conjuntos de dados de aplicativos (consulte Papéis comuns de dados e serviços). Se as cargas de trabalho usarem scripts em etapas ou JARs personalizados, conceda também acesso de leitura aos buckets correspondentes do Cloud Storage.

Ativar contas de serviço personalizadas do remetente (ambiente de execução 3.x)

Use uma conta de serviço personalizada de remetente quando sistemas automatizados (como o Serviço Gerenciado para Apache Airflow, o Cloud Scheduler ou pipelines de CI ou CD) enviarem cargas de trabalho sem um usuário humano interativo.

  • Nesse cenário, a conta de serviço do remetente executa o comando gcloud que inicia o job. Veja um exemplo com gcloud:

    gcloud dataproc batches submit spark \
      --service-account=WORKLOAD_SA_EMAIL \
      ...
    
  • A conta de serviço da carga de trabalho executa o código do Spark nos nós de computação e acessa os conjuntos de dados do aplicativo.

    1. Conceda roles/dataproc.serverlessEditor à conta de serviço personalizada do remetente.
    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="serviceAccount:SUBMITTER_SA_EMAIL" \
      --role="roles/dataproc.serverlessEditor"
    

    Ao usar o ambiente de execução 3.x com uma conta de serviço personalizada do remetente, é necessária uma conta de serviço de carga de trabalho personalizada para executar a carga de trabalho. O ambiente de execução não pode usar as credenciais de usuário final (EUC, na sigla em inglês), porque não há um usuário final interativo. O job precisa ser executado como uma conta de serviço de carga de trabalho especificada (--service-account).

  1. Conceda roles/iam.serviceAccountUser na conta de serviço personalizada da carga de trabalho.

    gcloud iam service-accounts add-iam-policy-binding \
      WORKLOAD_SA_EMAIL \
      --member="serviceAccount:SUBMITTER_SA_EMAIL" \
      --role="roles/iam.serviceAccountUser"
    
  2. Configure a conta de serviço personalizada da carga de trabalho. Conceda os papéis de dados de aplicativo e roles/dataproc.serverlessNode a WORKLOAD_SA_EMAIL.

Referência de papéis de administrador do Spark (ambiente de execução 3.x)

A tabela a seguir resume os papéis que podem ser concedidos com o ambiente de execução 3.x.

Remetente Identidade da carga de trabalho Conceder ao remetente Conceder à conta de serviço da carga de trabalho
Usuário final (padrão) Usuário final (EUC) roles/dataproc.serverlessEditor (+ funções de dados no usuário) (nenhum: nenhuma SA usada)
Usuário final SA personalizada roles/dataproc.serverlessEditor + roles/iam.serviceAccountUser na SA personalizada roles/dataproc.serverlessNode + funções de dados
SA personalizada (automação) SA personalizada roles/dataproc.serverlessEditor + roles/iam.serviceAccountUser na SA personalizada roles/dataproc.serverlessNode + funções de dados

Leitor

Leitor do Spark (ambiente de execução 3.x)

Como leitor do Spark, você visualiza cargas de trabalho em lote, sessões interativas, métricas de execução, registros e painéis de status sem enviar ou modificar cargas de trabalho.

Peça ao administrador para conceder a você roles/dataproc.serverlessViewer.

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:VIEWER_EMAIL" \
  --role="roles/dataproc.serverlessViewer"

Esse papel concede acesso somente leitura para visualizar cargas de trabalho em lote sem servidor, sessões interativas e status de funcionamento.

Permissões detalhadas

Permissões detalhadas (ambiente de execução 3.x)

Nesta seção, listamos as permissões do IAM incluídas nos papéis do IAM associados ao ambiente de execução 3.x.

Papel de editor sem servidor (roles/dataproc.serverlessEditor)

Esse papel com as permissões dele fornece acesso de leitura e gravação às cargas de trabalho em lote sem servidor do ambiente de execução 3.x e às sessões interativas.

Permissão Descrição
dataproc.batches.create Criar e enviar novas cargas de trabalho em lote.
dataproc.batches.get Receber o status e os detalhes da carga de trabalho em lote.
dataproc.batches.list Listar todas as cargas de trabalho em lote em um projeto ou região.
dataproc.batches.delete Exclua lotes concluídos ou encerrados.
dataproc.batches.cancel Cancelar uma carga de trabalho em lote em execução.
dataproc.sessions.create Criar sessões interativas do Spark Connect.
dataproc.sessions.get Receber o status e os detalhes da sessão.
dataproc.sessions.list Listar todas as sessões em um projeto ou região.
dataproc.sessions.delete Excluir sessões encerradas.
dataproc.sessions.terminate Encerre uma sessão interativa em execução.
dataproc.sessionTemplates.create Criar perfis de ambiente de execução (modelos de sessão).
dataproc.sessionTemplates.get Receber detalhes do perfil de ambiente de execução.
dataproc.sessionTemplates.list Listar perfis de ambiente de execução em um projeto ou região.
dataproc.sessionTemplates.update Atualizar perfis de ambiente de execução.
dataproc.sessionTemplates.delete Excluir perfis de ambiente de execução.
dataproc.operations.get Verificar o status da operação assíncrona (exigido pela CLI gcloud).

Papel de nó sem servidor (roles/dataproc.serverlessNode)

Fornece gerenciamento de pool de nós e permissões de comunicação interna do Spark para contas de serviço de carga de trabalho personalizadas do ambiente de execução 3.x.

Esses papéis com as permissões são necessários ao usar uma conta de serviço de carga de trabalho personalizada com o ambiente de execução 3.x. As cargas de trabalho em execução com as credenciais de usuário final (EUC, na sigla em inglês) padrão do 3.x não usam uma conta de serviço de carga de trabalho.

Permissão Descrição
dataproc.batches.sparkApplicationWrite Comunicação do aplicativo Spark para cargas de trabalho em lote.
dataproc.sessions.sparkApplicationWrite Comunicação do aplicativo Spark para sessões interativas.
dataprocrm.nodePools.create Criar pools de nós de computação.
dataprocrm.nodePools.delete Excluir pools de nós de computação.
dataprocrm.nodePools.resize Escalonar pools de nós de forma dinâmica.
dataprocrm.nodePools.get Ler o status do pool de nós.
dataprocrm.nodePools.list Listar pools de nós.
dataprocrm.nodePools.update Atualizar a configuração do pool de nós.
dataprocrm.nodePools.deleteNodes Remover nós específicos de um pool.
dataprocrm.nodes.list Listar nós em um pool.
dataprocrm.nodes.delete Excluir nós após a conclusão da tarefa.
dataprocrm.nodes.get Ler o status do nó.
dataprocrm.nodes.heartbeat Relatar a integridade e as pulsações do nó.
dataprocrm.nodes.mintOAuthToken Crie tokens OAuth para operações de nó.
dataprocrm.operations.get Verificar o status de funcionamento da infraestrutura.

Papel de Leitor sem servidor (roles/dataproc.serverlessViewer)

Esse papel com as permissões dele é necessário ao usar o ambiente de execução 3.x com uma conta de serviço personalizada do remetente. Eles dão acesso somente leitura às cargas de trabalho em lote sem servidor do ambiente de execução 3.x, às sessões interativas e ao status da operação.

Permissão Descrição
dataproc.batches.get Ler o status e os detalhes da carga de trabalho em lote.
dataproc.batches.list Listar cargas de trabalho em lote.
dataproc.sessions.get Ler o status e os detalhes da sessão.
dataproc.sessions.list Lista sessões.
dataproc.operations.get Ler o status de funcionamento.
dataproc.operations.list Listar operações.

Papel de delegação da conta de serviço (roles/iam.serviceAccountUser)

Permite que um usuário ou sistema automatizado anexe e execute cargas de trabalho como uma conta de serviço personalizada. A carga de trabalho é executada com as permissões e o acesso aos recursos concedidos a essa conta de serviço, em vez das credenciais de usuário final (EUC, na sigla em inglês) do usuário que fez o envio.

Permissão Descrição
iam.serviceAccounts.actAs Permite que o remetente execute cargas de trabalho como a conta de serviço especificada.

Ambiente de execução 2.x

Por padrão, as cargas de trabalho do ambiente de execução 2.x são executadas como a conta de serviço padrão do Compute Engine. O remetente (o usuário ou sistema automatizado) age como essa conta ao executar cargas de trabalho ou sessões.

Desenvolvedor

Desenvolvedor do Spark (ambiente de execução 2.x)

Como desenvolvedor do Spark que usa o ambiente de execução 2.x, você desenvolve, envia, monitora e soluciona problemas de cargas de trabalho do Spark e acessa dados. Como a carga de trabalho é executada como uma conta de serviço, e não como sua identidade de usuário, um administrador concede a você o papel de Editor do IAM e o papel de Usuário da Conta de Serviço para executar cargas de trabalho como a conta de serviço da carga de trabalho.

  1. Solicite o papel de editor. Peça ao administrador para conceder a você roles/dataproc.editor no projeto:

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/dataproc.editor"
    
  2. Solicitar permissão de delegação. Peça ao administrador para conceder a você roles/iam.serviceAccountUser na conta de serviço da carga de trabalho.

    A conta de serviço de carga de trabalho padrão é a conta de serviço padrão do Compute Engine, PROJECT_NUMBER-compute@developer.gserviceaccount.com:

    gcloud iam service-accounts add-iam-policy-binding \
      PROJECT_NUMBER-compute@developer.gserviceaccount.com \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/iam.serviceAccountUser"
    
  3. Acessar o bucket de preparo. O remetente do ambiente de execução 2.x precisa de permissão para fazer upload de scripts e JARs, e a conta de serviço da carga de trabalho precisa de permissão para gerenciar arquivos e registros temporários. Essas permissões estão contidas no papel roles/storage.objectAdmin.

    # Grant submitter access to upload staged files
    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/storage.objectAdmin"
    
    # Grant workload service account access for staging, temporary files, and logs
    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
      --role="roles/storage.objectAdmin"
    
  4. Envie uma carga de trabalho de teste do Batch. Envie uma carga de trabalho em lote de teste para confirmar a configuração.

    gcloud dataproc batches submit spark \
      --region=REGION \
      --version=2.2 \
      --class=org.apache.spark.examples.SparkPi \
      --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
      -- 1000
    

    Observações:

Contas de serviço personalizadas de carga de trabalho personalizada (ambiente de execução 2.x)

Use uma conta de serviço personalizada quando sua organização exigir que as cargas de trabalho sejam executadas em uma identidade dedicada e auditável, em vez da conta de serviço padrão compartilhada do Compute Engine (consulte Práticas recomendadas para contas de serviço do IAM).

  1. Receba permissão para executar cargas de trabalho como a conta de serviço personalizada. Peça ao administrador para conceder a você roles/iam.serviceAccountUser na conta de serviço personalizada:

    gcloud iam service-accounts add-iam-policy-binding \
      WORKLOAD_SA_EMAIL \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/iam.serviceAccountUser"
    
  2. Especifique a conta de serviço personalizada com a flag --service-account ao enviar cargas de trabalho.

    gcloud dataproc batches submit spark \
      --region=REGION \
      --service-account=WORKLOAD_SA_EMAIL \
      --version=2.2 \
      --class=org.apache.spark.examples.SparkPi \
      --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
      -- 1000
    
  3. Acesso ao conjunto de dados: se a carga de trabalho não puder acessar conjuntos de dados, conceda à conta de serviço personalizada da carga de trabalho (não à sua conta de usuário) os papéis de acesso a dados necessários (consulte Papéis comuns de dados e serviços).

Administrador

Administrador do Spark (ambiente de execução 2.x)

Como administrador do Spark, você configura o projeto, as contas de serviço e concede acesso aos desenvolvedores do Spark.

As cargas de trabalho usam a sub-rede VPC default nomeada automaticamente. Se o projeto não tiver uma rede default ou usar VPCs personalizadas, consulte Configuração de rede sem servidor do Serviço Gerenciado para Apache Spark para configurar e especificar uma sub-rede para cargas de trabalho e sessões.

Ativar o ambiente de execução padrão 2.x

Com o ambiente de execução padrão 2.x, as cargas de trabalho são executadas como a conta de serviço padrão do Compute Engine.

  1. Conceda roles/dataproc.editor ao desenvolvedor.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/dataproc.editor"
    
  2. Conceda roles/iam.serviceAccountUser na conta de serviço padrão.

    gcloud iam service-accounts add-iam-policy-binding \
      PROJECT_NUMBER-compute@developer.gserviceaccount.com \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/iam.serviceAccountUser"
    
  3. Conceda roles/dataproc.worker à conta de serviço da carga de trabalho.

    Esse papel permite que a conta de serviço registre o agente de VM, faça o leasing e execute tarefas de computação e emita registros e métricas para o Cloud Logging e o Cloud Monitoring:

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
      --role="roles/dataproc.worker"
    
  4. Conceda roles/storage.objectAdmin para o armazenamento do bucket de preparo.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
      --role="roles/storage.objectAdmin"
    
  5. Conceda acesso ao conjunto de dados à conta de serviço da carga de trabalho.

    Conceda papéis no nível de dados à conta de serviço da carga de trabalho para permitir que ela acesse conjuntos de dados de aplicativos do Spark (consulte Papéis comuns de dados e serviços).

Ativar contas de serviço personalizadas de carga de trabalho (ambiente de execução 2.x)

Use uma conta de serviço personalizada de carga de trabalho com o ambiente de execução 2.x para isolar cargas de trabalho, em vez de usar a conta de serviço padrão compartilhada do Compute Engine.

  1. Conceda roles/iam.serviceAccountUser na conta de serviço personalizada ao desenvolvedor.

    gcloud iam service-accounts add-iam-policy-binding \
      WORKLOAD_SA_EMAIL \
      --member="user:DEVELOPER_EMAIL" \
      --role="roles/iam.serviceAccountUser"
    
  2. Conceda roles/dataproc.worker à conta de serviço personalizada.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="serviceAccount:WORKLOAD_SA_EMAIL" \
      --role="roles/dataproc.worker"
    
  3. Conceder acesso aos dados do aplicativo e ao ambiente de preparo.

    Conceda papéis no nível de dados diretamente à conta de serviço personalizada da carga de trabalho (consulte Papéis comuns de dados e serviços) e conceda roles/storage.objectAdmin em buckets temporários e de preparo.

Ativar contas de serviço personalizadas do remetente (ambiente de execução 2.x)

Use uma conta de serviço personalizada de remetente quando sistemas automatizados (como o Serviço Gerenciado para Apache Airflow, o Cloud Scheduler ou pipelines de CI/CD) enviarem cargas de trabalho sem um usuário humano interativo.

  1. Conceda roles/dataproc.editor à conta de serviço do remetente.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="serviceAccount:SUBMITTER_SA_EMAIL" \
      --role="roles/dataproc.editor"
    
  2. Conceda roles/iam.serviceAccountUser na conta de serviço da carga de trabalho.

    gcloud iam service-accounts add-iam-policy-binding \
      WORKLOAD_SA_EMAIL \
      --member="serviceAccount:SUBMITTER_SA_EMAIL" \
      --role="roles/iam.serviceAccountUser"
    
  3. Configure a conta de serviço da carga de trabalho. Conceda acesso de roles/dataproc.worker e ao conjunto de dados para WORKLOAD_SA_EMAIL.

Referência de papéis de administrador do Spark (ambiente de execução 2.x)

A tabela a seguir resume os papéis do IAM a serem concedidos com o ambiente de execução 2.x.

Remetente Identidade da carga de trabalho Conceder ao remetente Conceder à conta de serviço da carga de trabalho
Usuário final (padrão) Conta de serviço padrão do Compute Engine roles/dataproc.editor + roles/iam.serviceAccountUser na conta de serviço padrão roles/dataproc.worker + roles/storage.objectAdmin + funções de dados
Usuário final SA personalizada roles/dataproc.editor + roles/iam.serviceAccountUser na SA personalizada roles/dataproc.worker + roles/storage.objectAdmin + funções de dados
SA personalizada (automação) SA personalizada roles/dataproc.editor + roles/iam.serviceAccountUser na SA personalizada roles/dataproc.worker + roles/storage.objectAdmin + funções de dados

Leitor

Leitor do Spark (ambiente de execução 2.x)

Como leitor do Spark, você visualiza cargas de trabalho em lote, sessões interativas, métricas de execução, registros e painéis de status sem enviar ou modificar cargas de trabalho.

Peça ao administrador para conceder a você roles/dataproc.viewer:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:VIEWER_EMAIL" \
  --role="roles/dataproc.viewer"

Esse papel concede acesso somente leitura aos recursos do Serviço Gerenciado para Apache Spark, como clusters, jobs, lotes, sessões e operações.

Permissões detalhadas

Permissões detalhadas (ambiente de execução 2.x)

Nesta seção, listamos as permissões do IAM incluídas nos papéis do IAM associados ao ambiente de execução 2.x.

Papel de editor (roles/dataproc.editor)

Esse papel fornece controle sobre cargas de trabalho e sessões sem servidor do ambiente de execução 2.x, além de clusters e jobs do Serviço Gerenciado para Apache Spark no Compute Engine.

Permissão Obrigatório para sem servidor Descrição
dataproc.batches.create Sim Criar e enviar novas cargas de trabalho em lote.
dataproc.batches.get Sim Receber o status e os detalhes da carga de trabalho em lote.
dataproc.batches.list Sim Listar todas as cargas de trabalho em lote em um projeto ou região.
dataproc.batches.delete Sim Exclua lotes concluídos ou encerrados.
dataproc.batches.cancel Sim Cancelar uma carga de trabalho em lote em execução.
dataproc.sessions.create Sim Criar sessões interativas.
dataproc.sessions.get Sim Receber o status e os detalhes da sessão.
dataproc.sessions.list Sim Listar todas as sessões em um projeto ou região.
dataproc.sessions.delete Sim Excluir sessões encerradas.
dataproc.sessions.terminate Sim Encerre uma sessão interativa em execução.
dataproc.operations.get Sim Verificar o status da operação assíncrona (exigido pela CLI gcloud).
compute.networks.get Sim Visualizar a configuração da rede VPC.
compute.networks.list Sim Listar redes VPC no projeto. Não lista sub-redes. Para listar sub-redes no console do Google Cloud ou em ambientes de desenvolvimento integrado, é necessário ter compute.subnetworks.list (consulte Permissões adicionais para o console do Google Cloud e ambientes de desenvolvimento integrado).
dataproc.clusters.* Não (somente clusters) Criar, gerenciar e usar clusters do Serviço Gerenciado para Apache Spark baseados no Compute Engine.
dataproc.jobs.* Não (somente clusters) Envie e gerencie jobs em clusters do Serviço Gerenciado para Apache Spark baseados no Compute Engine.
dataproc.autoscalingPolicies.* Não (somente clusters) Políticas de escalonamento automático para clusters baseados no Compute Engine.
dataproc.nodeGroups.* Não (somente clusters) Grupos de nós personalizados em clusters baseados no Compute Engine.
dataproc.workflowTemplates.* Não (somente clusters) Fluxos de trabalho de modelo para clusters baseados no Compute Engine.
compute.machineTypes.* Não (somente clusters) Metadados de tipo de máquina para clusters baseados no Compute Engine.

Papel de worker (roles/dataproc.worker)

Esse papel fornece permissões de execução de carga de trabalho para o ambiente de execução 2.x.

Permissão Descrição
dataproc.agents.create Registre o agente de VM na VM.
dataproc.agents.get Ler o estado do agente.
dataproc.agents.update Atualizar o estado do agente.
dataproc.agents.delete Cancelar o registro do agente após a conclusão.
dataproc.tasks.lease Colocar tarefas de computação em lease para execução.
dataproc.tasks.reportStatus Informar o status de execução da tarefa.
storage.objects.create Gravar dados de preparo, arquivos temporários e registros.
storage.objects.delete Limpe os arquivos temporários.
storage.objects.get Ler scripts de inicialização e arquivos de preparo.
storage.objects.list Liste o conteúdo do bucket temporário e de preparo.

Papel de leitor (roles/dataproc.viewer)

Esse papel fornece acesso somente leitura a todos os recursos do Serviço Gerenciado para Apache Spark.

Permissão Obrigatório para sem servidor Descrição
dataproc.batches.get Sim Ler o status e os detalhes da carga de trabalho em lote.
dataproc.batches.list Sim Listar todas as cargas de trabalho em lote em um projeto ou região.
dataproc.sessions.get Sim Ler o status e os detalhes da sessão.
dataproc.sessions.list Sim Listar todas as sessões em um projeto ou região.
dataproc.operations.get Sim Ler o status da operação assíncrona.
dataproc.operations.list Sim Liste as operações em um projeto ou região.
dataproc.clusters.get Não (somente clusters) Ver a configuração e o status do cluster.
dataproc.clusters.list Não (somente clusters) Listar clusters em um projeto ou região.
dataproc.jobs.get Não (somente clusters) Ver detalhes e status de jobs em clusters.
dataproc.jobs.list Não (somente clusters) Listar jobs em clusters.
dataproc.autoscalingPolicies.get Não (somente clusters) Ver detalhes da política de escalonamento automático.
dataproc.autoscalingPolicies.list Não (somente clusters) Listar políticas de escalonamento automático.
dataproc.workflowTemplates.get Não (somente clusters) Ver detalhes do modelo de fluxo de trabalho.
dataproc.workflowTemplates.list Não (somente clusters) Listar modelos de fluxo de trabalho.

Papel de delegação da conta de serviço (roles/iam.serviceAccountUser)

Permite que um usuário ou sistema automatizado anexe e execute cargas de trabalho como a conta de serviço padrão do Compute Engine ou uma conta de serviço personalizada. A carga de trabalho é executada com as permissões e o acesso a recursos concedidos a essa conta de serviço.

Permissão Descrição
iam.serviceAccounts.actAs Permite que o remetente execute cargas de trabalho como a conta de serviço especificada.

Outras permissões para o console do Google Cloud e os ambientes de desenvolvimento integrado

Quando você envia cargas de trabalho com a Google Cloud CLI ou a API Dataproc, o plano de controle do Serviço Gerenciado para Apache Spark resolve a rede VPC e a sub-rede default do projeto automaticamente, sem verificar as permissões de sub-rede do Compute Engine ou do Service Usage no nível do autor da chamada.

No entanto, quando você cria ou edita perfis de ambiente de execução, sessões interativas ou cargas de trabalho em lote no console do Google Cloud ou quando usa o Google Cloud Data Agent Kit em um ambiente de desenvolvimento integrado, como o VS Code, o cliente realiza verificações de leitura adicionais com suas credenciais de usuário:

Permissão Fluxo de trabalho do cliente Finalidade
compute.subnetworks.list Console doGoogle Cloud e Data Agent Kit Liste as sub-redes VPC regionais para validar se a rede default tem uma sub-rede com o Acesso privado do Google ativado e para preencher os menus de rede e sub-rede.
compute.subnetworks.get Console doGoogle Cloud e Data Agent Kit Inspecione os metadados da sub-rede ao visualizar, clonar ou editar um perfil de ambiente de execução, uma sessão ou uma carga de trabalho em lote.
compute.networks.list Console doGoogle Cloud e Data Agent Kit Listar redes VPC no projeto (incluído em roles/dataproc.editor e roles/dataproc.admin, mas não em roles/dataproc.serverlessEditor).
compute.networks.get Console doGoogle Cloud e Data Agent Kit Ver detalhes da rede VPC (incluídos em roles/dataproc.editor e roles/dataproc.admin, mas não em roles/dataproc.serverlessEditor).
serviceusage.services.get Data Agent Kit e IDEs Verifique se a API Dataproc (dataproc.googleapis.com) está ativada no projeto selecionado antes de carregar a árvore de recursos do Spark.
serviceusage.services.list Console doGoogle Cloud e ambientes de desenvolvimento integrado Liste as APIs ativadas no projeto.

Conceder uma função personalizada mínima (recomendado)

Para seguir o princípio de menor privilégio, crie um papel personalizado do IAM que conceda apenas as permissões necessárias para os fluxos de trabalho do console e do ambiente de desenvolvimento integrado do Google Cloud e vincule-o aos desenvolvedores do Spark, além de roles/dataproc.serverlessEditor ou roles/dataproc.editor:

  1. Crie a função personalizada no projeto:

    gcloud iam roles create sparkConsoleAndIdeUser \
      --project=PROJECT_ID \
      --title="Managed Spark Console and IDE User" \
      --description="Read-only network and Service Usage permissions for Managed Spark console and IDE workflows" \
      --permissions=compute.networks.get,compute.networks.list,compute.subnetworks.get,compute.subnetworks.list,serviceusage.services.get,serviceusage.services.list \
      --stage=GA
    
  2. Conceda a função personalizada ao desenvolvedor do Spark:

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="user:DEVELOPER_EMAIL" \
      --role="projects/PROJECT_ID/roles/sparkConsoleAndIdeUser"
    

Como alternativa à manutenção de uma função personalizada, é possível conceder as funções predefinidas de Leitor de rede do Compute (roles/compute.networkViewer) e Leitor do Service Usage (roles/serviceusage.serviceUsageViewer). O uso de papéis predefinidos evita a manutenção de funções personalizadas, porque o Google Cloud gerencia as permissões automaticamente. No entanto, os papéis de Leitor predefinidos concedem acesso de leitura mais amplo do que o exigido pelo Serviço Gerenciado para Apache Spark: roles/compute.networkViewer permite que os usuários visualizem todos os recursos de rede do Compute Engine no projeto (incluindo regras de firewall, rotas, Cloud Routers, túneis de VPN, regras de encaminhamento e grupos de endpoints de rede), e roles/serviceusage.serviceUsageViewer permite que os usuários visualizem cotas e políticas de consumidor em todos os serviços do projeto. Não conceda roles/compute.networkUser ou roles/serviceusage.serviceUsageConsumer aos usuários finais apenas para acesso ao console do Google Cloud ou ao ambiente de desenvolvimento integrado, porque esses papéis também concedem permissões de anexo de recursos e de cota (compute.subnetworks.use e serviceusage.services.use) que os usuários finais não precisam.

A seguir