Clonar um grupo de espaços de trabalho em um novo grupo de contas

Esta página fornece diretrizes para administradores de workspace que desejam conceder aos usuários Acesso ao Consumidor dentro de um workspace do Azure Databricks. Ele inclui um script Python para ajudar a gerenciar grupos usando o SDK do Databricks para Python.

Contexto

Os workspaces são normalmente configurados de modo que todos os usuários em um workspace recebam automaticamente o acesso ao Workspace e os direitos de Databricks SQL quando são provisionados. Como os direitos são aditivos, os usuários só veem o ambiente de trabalho simplificado quando o acesso ao consumidor é seu único direito. Se um grupo receber qualquer direito com privilégios maiores do que o acesso do consumidor, nenhum dos usuários desse grupo receberá apenas a experiência do consumidor.

Esta página fornece um fluxo de trabalho para clonar o grupo de sistema existente users em um novo grupo que retém o acesso ao Workspace e os direitos de acesso ao SQL do Databricks . Em seguida, ele explica como reconfigurar o users grupo para que os usuários recém-provisionados sejam atribuídos apenas ao direito de acesso do consumidor por padrão. Com essa configuração, os usuários que exigem um acesso de nível mais alto devem ser adicionados ao novo grupo quando são adicionados ao workspace.

Conceder acesso ao consumidor

Se você tiver usado o grupo users para conceder privilégios de criação a todos os usuários do espaço de trabalho, use as etapas a seguir para permitir que alguns usuários tenham direito de acesso exclusivo ao consumidor.

1. Duplique o grupo de sistemas do espaço de trabalho users:

   • Crie um novo grupo de contas contendo todos os membros atuais do grupo do users workspace.
   • Atribua direitos de privilégios mais altos, como acesso ao workspace ou acesso sql do Databricks a esse novo grupo em vez do grupo padrão users .

2. Remova permissões ou privilégios de nível elevado do grupo users: assim, você pode adicionar novos usuários como consumidores sem que eles sejam atualizados automaticamente por direitos de grupo.

3. Adicionar novos usuários como consumidores: adicione usuários que devem ter apenas a experiência de acesso do consumidor ao espaço de trabalho.

Usar o SDK do Databricks para Python para automatizar o gerenciamento de direitos

O script Python a seguir automatiza o processo de duplicação do users grupo e atribuição de direitos apropriados. Ele usa o SDK do Databricks para Python e requer uma entidade de serviço com privilégios de administrador para a conta e o espaço de trabalho, autenticada por meio do OAuth. Consulte Autorizar acesso interativo aos recursos do Azure Databricks com uma conta de usuário usando o OAuth.

Pré-requisitos:

• Principal de serviço com direitos de administrador
• Conjunto de variáveis de ambiente:
  • DATABRICKS_ACCOUNT_ID (UUID do URL do console de conta)
  • DATABRICKS_WORKSPACE_ID (ID numérico do URL do espaço de trabalho)
  • DATABRICKS_CLIENT_ID (ID do cliente da entidade de serviço)
  • DATABRICKS_CLIENT_SECRET (segredo do cliente da entidade de serviço)

Script de exemplo

import os
import databricks.sdk as dbx
from databricks.sdk.service import iam

# Set the Databricks account host URL for your account's cloud
DATABRICKS_HOST = "https://accounts.azuredatabricks.net
"

Fetch credentials from environment variables
DATABRICKS_ACCOUNT_ID = os.getenv("DATABRICKS_ACCOUNT_ID")
DATABRICKS_WORKSPACE_ID = os.getenv("DATABRICKS_WORKSPACE_ID")
DATABRICKS_CLIENT_ID = os.getenv("DATABRICKS_CLIENT_ID")
DATABRICKS_CLIENT_SECRET = os.getenv("DATABRICKS_CLIENT_SECRET")

# Initialize Databricks account client
account_client = dbx.AccountClient(
host=DATABRICKS_HOST,
account_id=DATABRICKS_ACCOUNT_ID,
client_id=DATABRICKS_CLIENT_ID,
client_secret=DATABRICKS_CLIENT_SECRET,
)

print(f"Authenticated to Databricks account {DATABRICKS_ACCOUNT_ID}")

# Get workspace and initialize workspace client
workspace = account_client.workspaces.get(workspace_id=DATABRICKS_WORKSPACE_ID)
workspace_name = workspace.workspace_name
workspace_client = account_client.get_workspace_client(workspace)

print(f"Authenticated to Databricks workspace {DATABRICKS_WORKSPACE_ID}, '{workspace_name}'")

def get_workspace_group(group_name):
group = list(workspace_client.groups.list(filter=f"displayName eq '{group_name}'"))
print(f"Found workspace group: {group.display_name}")
print(f"Workspace {group.display_name} has {len(group.members)} members")
return group

def clone_workspace_group_to_account(workspace_group_name, new_account_group_name):
workspace_group = get_workspace_group(workspace_group_name)
group = account_client.groups.create(
display_name=new_account_group_name, members=workspace_group.members
)
print(f"Created account group: {new_account_group_name}")
print(f"Cloned workspace group {workspace_group.display_name} to account group {group.display_name}")
print(f"Account {group.display_name} has {len(group.members)} members")
return group

def add_account_group_to_workspace(account_group, workspace):
permissions = account_client.workspace_assignment.update(
workspace_id=workspace.workspace_id,
principal_id=account_group.id,
permissions=[iam.WorkspacePermission.USER],
)
print(f"Added account group {account_group.display_name} to workspace {workspace.workspace_id}, {workspace.workspace_name}")
return permissions

# Clone workspace 'users' group to new account group '{workspace_name}-contributors'
account_group = clone_workspace_group_to_account(
"users", f"{workspace_name}-contributors"
)

# Add account group '{workspace_name}-contributors' to the workspace
permissions = add_account_group_to_workspace(account_group, workspace)

Depois de duplicar os grupos existentes e reatribuir permissões, você poderá conceder Acesso ao consumidor ao grupo users, ou a qualquer outro, para que novos usuários sejam automaticamente autorizados a ter esse acesso quando forem adicionados ao espaço de trabalho.

Observação

Ajuste os nomes dos grupos e as permissões de acordo com as políticas e convenções de nomenclatura da sua organização. Sempre teste as alterações em um ambiente de não produção antes de aplicá-las amplamente.