User's blog

Como automatizar permissões personalizadas por usuário no Amazon QuickSight

Written by

Make.com Service User

in

O problema de escalar controle de acesso no QuickSight

Conforme os ambientes do Amazon QuickSight crescem — especialmente com a expansão das funcionalidades de IA — gerenciar permissões personalizadas de forma manual se torna inviável. O princípio do menor privilégio exige que cada usuário tenha acesso apenas ao que precisa, e fazer isso na mão para centenas ou milhares de usuários é receita para erro.

O QuickSight trabalha com uma hierarquia de três camadas para aplicar permissões: conta, função (role) e usuário. As configurações de usuário sobrepõem as de função, que por sua vez sobrepõem as de conta. Isso permite políticas de segurança em camadas bastante flexíveis. A AWS documentou quatro cenários práticos para automatizar essa atribuição nos momentos críticos do ciclo de vida do usuário.

Cenário 1: Aplicar permissões no momento do cadastro via API

Para quem controla o processo de criação de usuários de ponta a ponta — como plataformas SaaS que incorporam o QuickSight para seus clientes — a abordagem mais simples é incluir o parâmetro --custom-permissions-name diretamente na chamada da API RegisterUser. O perfil de permissão é aplicado no ato da criação, sem necessidade de infraestrutura adicional.

aws quicksight register-user \
  --aws-account-id 123456789012 \
  --namespace default \
  --identity-type QUICKSIGHT \
  --user-role AUTHOR \
  --email user@example.com \
  --user-name user_name \
  --custom-permissions-name "Restricted-Author-Profile"

Um exemplo prático: restringir automaticamente funcionalidades premium — como relatórios paginados e GenBI — com base no plano contratado pelo cliente, no momento em que o usuário é provisionado.

Cenário 2: Definir padrões no nível de conta ou função

Antes de construir automações mais elaboradas, a AWS recomenda configurar padrões que se aplicam automaticamente a todos os usuários, atuais e futuros, com esforço operacional mínimo. Há duas APIs nativas para isso, e a escolha depende do nível de granularidade desejado.

Padrão no nível de conta

A API UpdateAccountCustomPermission define um perfil de fallback aplicado a qualquer usuário sem perfil explícito atribuído — incluindo novos usuários criados via provisionamento Just-In-Time.

aws quicksight update-account-custom-permission \
  --aws-account-id 123456789012 \
  --custom-permissions-name "Restricted-User-Profile"

Padrão no nível de função

Já a API UpdateRoleCustomPermission permite definir um perfil padrão por função do QuickSight (READER, AUTHOR, ADMIN e funções PRO).

aws quicksight update-role-custom-permission \
  --aws-account-id 123456789012 \
  --role AUTHOR \
  --namespace default \
  --custom-permissions-name "Restricted-Author-Profile"

Um cenário real: uma empresa com 50.000 usuários que precisa bloquear todas as novas funcionalidades de GenBI enquanto a equipe de segurança faz uma revisão de 60 a 90 dias. O padrão no nível de conta aplica essa restrição instantaneamente, sem automação por usuário e sem janela de exposição.

Cenário 3: Automação orientada a eventos com EventBridge e Lambda

Quando a organização precisa de perfis de permissão diferentes por grupo, é necessária uma arquitetura mais sofisticada. O QuickSight não oferece uma API nativa para atribuir permissões diretamente a grupos, então a solução detecta quando um usuário é adicionado ou removido de um grupo e aplica o perfil correspondente automaticamente.

A AWS recomenda combinar este cenário com o Cenário 2. Quando um usuário é provisionado via federação Just-In-Time, existe uma janela entre a criação da conta e a adição ao grupo correto. O Cenário 2 fecha essa janela com um padrão restritivo; o Cenário 3 refina as permissões assim que o usuário é atribuído ao grupo. A configuração no nível de usuário do Cenário 3 tem precedência sobre o padrão do Cenário 2 — sem conflito, apenas camadas complementares.

Como a arquitetura funciona

O QuickSight e o IAM Identity Center (IDC) emitem eventos distintos no AWS CloudTrail para mudanças de membros em grupos. O QuickSight emite CreateGroupMembership ao adicionar e DeleteGroupMembership ao remover. O IDC emite AddMemberToGroup ao adicionar e RemoveMemberFromGroup ao remover. O Amazon EventBridge detecta esses eventos e aciona o AWS Lambda, que aplica o perfil correto via API UpdateUserCustomPermission.

Pré-requisitos

  • Uma conta AWS com acesso administrativo
  • Permissões do AWS IAM para criar e gerenciar recursos via AWS CloudFormation
  • AWS CloudTrail habilitado na região de destino
  • AWS IAM Identity Center: necessário apenas se usar gatilhos baseados em grupos do IDC
  • Python 3.9+ e AWS CLI v2 (para o script de atualização em lote do Cenário 4)

Implantação com CloudFormation

É possível implantar o pipeline completo — função IAM, função Lambda e regra do EventBridge — usando o template CloudFormation fornecido pela AWS. O stack deve ser implantado na mesma região da assinatura do QuickSight, pois as regras do EventBridge capturam eventos apenas dentro da própria região. Os parâmetros do template incluem: UseIdentityCenter, TargetGroupName, PermissionProfileName, QuickSightNamespace e LambdaFunctionPrefixName.

Implantação manual: passo a passo

Passo 1: Criar a função IAM para o Lambda. No Console do IAM, crie uma política chamada QuickSight-Lambda-Policy com as permissões necessárias para logs, QuickSight e Identity Store (se usar IDC). Em seguida, crie a função QuickSight-Auto-Permissions-Role vinculada a essa política.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents"
      ],
      "Resource": "arn:aws:logs:*:YOUR_ACCOUNT_ID:log-group:/aws/lambda/Auto-Assign-QS-Permissions:*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "quicksight:UpdateUserCustomPermission",
        "quicksight:DeleteUserCustomPermission",
        "quicksight:UpdateUser",
        "quicksight:DescribeUser"
      ],
      "Resource": "arn:aws:quicksight:*:*:user/*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "identitystore:DescribeUser",
        "identitystore:DescribeGroup"
      ],
      "Resource": "*"
    }
  ]
}

Passo 2: Implantar a função Lambda. Crie a função Auto-Assign-QS-Permissions com runtime Python 3.14 (ou a versão mais recente disponível), usando a role criada no passo anterior. Aumente o timeout para 30 segundos e configure as variáveis de ambiente: PERMISSION_PROFILE, TARGET_GROUP_NAME e NAMESPACE. Cole o código abaixo no editor:

import logging
import os
import time
import boto3

logger = logging.getLogger()
logger.setLevel(logging.INFO)

quicksight = boto3.client("quicksight")
identity_store = boto3.client("identitystore")

def lambda_handler(event, context):
    detail = event.get("detail", {})
    event_source = detail.get("eventSource", "")
    event_name = detail.get("eventName", "")
    permission_profile = os.environ["PERMISSION_PROFILE"]
    target_group = os.environ["TARGET_GROUP_NAME"]
    namespace = os.environ["NAMESPACE"]
    account_id = (
        detail.get("userIdentity", {}).get("accountId")
        or detail.get("recipientAccountId")
    )
    logger.info(
        "Event received: source=%s, name=%s", event_source, event_name
    )
    try:
        if event_source == "sso-directory.amazonaws.com":
            return handle_idc_event(detail, account_id, namespace, permission_profile, target_group)
        elif event_source == "quicksight.amazonaws.com":
            return handle_quicksight_event(detail, account_id, namespace, permission_profile, target_group)
        else:
            logger.warning("Unknown event source: %s", event_source)
            return {"statusCode": 200, "body": "Unknown event source"}
    except Exception as e:
        logger.error("Error processing event: %s", str(e))
        return {"statusCode": 500, "body": str(e)}

def handle_idc_event(detail, account_id, namespace, permission_profile, target_group):
    """Handle AddMemberToGroup or RemoveMemberFromGroup from sso-directory.amazonaws.com."""
    request_params = detail.get("requestParameters") or {}
    identity_store_id = request_params.get("identityStoreId")
    group_id = request_params.get("groupId")
    member_id = (request_params.get("memberId") or (request_params.get("member") or {}).get("memberId"))
    if not identity_store_id or not group_id or not member_id:
        logger.warning("Missing identityStoreId, groupId, or memberId.")
        return {"statusCode": 200, "body": "Missing IDC event info"}
    group_resp = identity_store.describe_group(
        IdentityStoreId=identity_store_id,
        GroupId=group_id,
    )
    group_name = group_resp.get("DisplayName", "")
    logger.info("IDC group resolved: '%s' (ID: %s)", group_name, group_id)
    if group_name != target_group:
        logger.info(
            "Group '%s' does not match target '%s'. Skipping.",
            group_name, target_group,
        )
        return {"statusCode": 200, "body": f"Group {group_name} not targeted"}
    idc_user = identity_store.describe_user(
        IdentityStoreId=identity_store_id,
        UserId=member_id,
    )
    user_name = idc_user.get("UserName")
    if not user_name:
        logger.warning("No UserName found for IDC user %s", member_id)
        return {"statusCode": 200, "body": "No UserName in IDC"}
    logger.info("IDC user resolved: %s (ID: %s)", user_name, member_id)
    qs_user = None
    for attempt in range(5):
        try:
            qs_user = quicksight.describe_user(
                AwsAccountId=account_id,
                Namespace=namespace,
                UserName=user_name,
            )
            break
        except quicksight.exceptions.ResourceNotFoundException:
            logger.info(
                "User '%s' not yet in QuickSight (attempt %d/5). Waiting...",
                user_name, attempt + 1,
            )
            time.sleep(3)
    if qs_user is None:
        logger.warning(
            "User '%s' not found in QuickSight after retries.", user_name,
        )
        return {"statusCode": 200, "body": f"User {user_name} not in QuickSight"}
    event_name = detail.get("eventName", "")
    if event_name == "RemoveMemberFromGroup":
        return remove_permissions(account_id, namespace, user_name)
    else:
        return apply_permissions(account_id, namespace, user_name, permission_profile)

def handle_quicksight_event(detail, account_id, namespace, permission_profile, target_group):
    """Handle CreateGroupMembership or DeleteGroupMembership from quicksight.amazonaws.com."""
    request_params = detail.get("requestParameters") or {}
    group_name = request_params.get("groupName", "")
    member_name = request_params.get("memberName", "")
    if not group_name or not member_name:
        logger.warning("Missing groupName or memberName in event.")
        return {"statusCode": 200, "body": "Missing event info"}
    event_name = detail.get("eventName", "")
    action = "removed from" if event_name == "DeleteGroupMembership" else "added to"
    logger.info(
        "QuickSight group membership: user '%s' %s '%s'",
        member_name, action, group_name,
    )
    if group_name != target_group:
        logger.info(
            "Group '%s' does not match target '%s'. Skipping.",
            group_name, target_group,
        )
        return {"statusCode": 200, "body": f"Group {group_name} not targeted"}
    if event_name == "DeleteGroupMembership":
        return remove_permissions(account_id, namespace, member_name)
    else:
        return apply_permissions(account_id, namespace, member_name, permission_profile)

def apply_permissions(account_id, namespace, user_name, permission_profile):
    """Apply the custom permission profile to a QuickSight user."""
    quicksight.update_user_custom_permission(
        AwsAccountId=account_id,
        Namespace=namespace,
        UserName=user_name,
        CustomPermissionsName=permission_profile,
    )
    logger.info(
        "Permission profile '%s' applied to user '%s'.",
        permission_profile, user_name,
    )
    return {
        "statusCode": 200,
        "body": f"Permission applied for user: {user_name}",
    }

def remove_permissions(account_id, namespace, user_name):
    """Remove custom permissions, reverting user to account/role-level default."""
    try:
        quicksight.delete_user_custom_permission(
            AwsAccountId=account_id,
            Namespace=namespace,
            UserName=user_name,
        )
        logger.info("Permission removed for user '%s'.", user_name)
        return {
            "statusCode": 200,
            "body": f"Permission removed for user: {user_name}",
        }
    except quicksight.exceptions.ResourceNotFoundException:
        logger.info("User '%s' had no custom permission to remove.", user_name)
        return {"statusCode": 200, "body": f"No permission to remove for: {user_name}"}

Passo 3: Criar a regra no Amazon EventBridge. No console do EventBridge, crie uma regra chamada QuickSight-Group-Membership-Creation-Rule. O padrão de evento varia conforme o tipo de autenticação da conta:

Opção A — IAM Identity Center:

{
  "source": ["aws.sso-directory"],
  "detail-type": ["AWS API Call via CloudTrail"],
  "detail": {
    "eventSource": ["sso-directory.amazonaws.com"],
    "eventName": ["AddMemberToGroup", "RemoveMemberFromGroup"],
    "errorCode": [{ "exists": false }]
  }
}

Opção B — Outros métodos de autenticação (grupos nativos do QuickSight):

{
  "source": ["aws.quicksight"],
  "detail-type": ["AWS API Call via CloudTrail"],
  "detail": {
    "eventSource": ["quicksight.amazonaws.com"],
    "eventName": ["CreateGroupMembership", "DeleteGroupMembership"],
    "errorCode": [{ "exists": false }]
  }
}

Passo 4: Adicionar o gatilho do EventBridge à função Lambda. Na função Lambda, acesse Configuração → Gatilhos → Adicionar gatilho, selecione Amazon EventBridge e escolha a regra criada no passo anterior.

Passo 5: Verificar a configuração. Adicione manualmente um usuário ao grupo alvo e monitore os logs do CloudWatch da função Lambda. A confirmação de sucesso aparece como: Permission profile '123' applied to user 'XYZ'.

Pontos de atenção no design

Quando um usuário é removido do grupo alvo, a função Lambda chama DeleteUserCustomPermission, revertendo o usuário ao padrão de conta ou função definido no Cenário 2. Se um usuário pertencer a múltiplos grupos com perfis diferentes, o QuickSight suporta apenas um perfil por usuário por vez — a lógica de resolução de conflito entre grupos deve ser definida pela equipe com base nas regras de prioridade da organização.

Cenário 4: Atualização em lote para usuários já existentes

A automação orientada a eventos do Cenário 3 só captura eventos futuros — ela não resolve o caso de grupos que já existem com usuários que precisam de restrições aplicadas retroativamente. Para isso, a solução é um script Python que itera por todos os membros de um grupo do QuickSight e aplica o perfil de permissão a cada um. O script lida com paginação via NextToken, já que a API ListGroupMemberships retorna no máximo 100 membros por chamada.

import boto3
import sys
import time
import csv
from botocore.exceptions import ClientError

# =========================================================
# CONFIGURATION - Edit these values before running
# =========================================================
# 1. Your AWS Account ID
AWS_ACCOUNT_ID = '279938032093'

# 2. The QuickSight Group whose members you want to target
TARGET_GROUP_NAME = 'BlogTestGroup'

# 3. The name of the Custom Permission Profile you want to apply
PERMISSION_PROFILE_NAME = 'TestBlog'

# 4. Namespace (almost always 'default')
NAMESPACE = 'default'
# =========================================================

qs = boto3.client('quicksight')

def get_all_group_members(group_name):
    print(f"Fetching members from group: '{group_name}'...")
    next_token = None
    while True:
        try:
            api_args = {
                'AwsAccountId': AWS_ACCOUNT_ID,
                'Namespace': NAMESPACE,
                'GroupName': group_name,
                'MaxResults': 100
            }
            if next_token:
                api_args['NextToken'] = next_token
            response = qs.list_group_memberships(**api_args)
            for member in response.get('GroupMemberList', []):
                yield member.get('MemberName')
            next_token = response.get('NextToken')
            if not next_token:
                break
        except qs.exceptions.ResourceNotFoundException:
            print(f"ERROR: The group '{group_name}' does not exist.")
            sys.exit(1)
        except ClientError as e:
            print(f"CRITICAL API ERROR: {e}")
            sys.exit(1)

def apply_permission(user_name):
    try:
        qs.update_user_custom_permission(
            AwsAccountId=AWS_ACCOUNT_ID,
            UserName=user_name,
            Namespace=NAMESPACE,
            CustomPermissionsName=PERMISSION_PROFILE_NAME
        )
        return True, "Success"
    except qs.exceptions.ResourceNotFoundException as e:
        error_msg = str(e)
        if 'User' in error_msg or 'user' in error_msg:
            return False, "User not found (might have been deleted)"
        else:
            return False, f"Profile '{PERMISSION_PROFILE_NAME}' not found"
    except ClientError as e:
        return False, str(e)

def main():
    print("--------------------------------------------")
    print(f"STARTING BATCH UPDATE")
    print(f"Target Group: {TARGET_GROUP_NAME}")
    print(f"Applying Profile: {PERMISSION_PROFILE_NAME}")
    print("--------------------------------------------\n")
    success_count = 0
    fail_count = 0
    failed_users = []
    for user_name in get_all_group_members(TARGET_GROUP_NAME):
        print(f"Processing: {user_name}...", end=" ")
        status, message = apply_permission(user_name)
        if status:
            print("OK")
            success_count += 1
        else:
            print(f"FAILED ({message})")
            fail_count += 1
            failed_users.append({'UserName': user_name, 'Error': message})
        time.sleep(0.1)
    print("\n--------------------------------------------")
    print("JOB COMPLETED")
    print(f"Total Success: {success_count}")
    print(f"Total Failed: {fail_count}")
    print("--------------------------------------------")
    if failed_users:
        csv_filename = f"failed_users_{TARGET_GROUP_NAME}.csv"
        with open(csv_filename, 'w', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=['UserName', 'Error'])
            writer.writeheader()
            writer.writerows(failed_users)
        print(f"\nFailed users written to: {csv_filename}")

if __name__ == "__main__":
    main()

O script pode ser executado localmente ou diretamente no AWS CloudShell, que já vem pré-autenticado e com o Boto3 instalado. O intervalo padrão de 0,1 segundo entre chamadas (~10 requisições/segundo) é adequado para a maioria dos ambientes. Para grupos com mais de 10.000 membros, recomenda-se aumentar esse valor para evitar throttling.

Limpeza dos recursos

Se a implantação foi feita via CloudFormation, basta excluir o stack para remover todos os recursos criados. Na implantação manual, exclua: a regra do EventBridge (QuickSight-Group-Membership-Creation-Rule), a função Lambda (Auto-Assign-QS-Permissions), a função IAM (QuickSight-Auto-Permissions-Role) e a política IAM (QuickSight-Lambda-Policy). O script do Cenário 4 não implanta infraestrutura e não requer limpeza.

Qual cenário usar em cada situação

Os quatro cenários cobrem contextos distintos e, em alguns casos, se complementam:

  • Cenário 1 — Cadastro via API: ideal para portais de onboarding personalizados que controlam a criação de usuários de ponta a ponta
  • Cenário 2 — Padrões de conta ou função: restrições consistentes para todos os usuários ou por função, sem automação adicional — ponto de partida recomendado
  • Cenário 3 — Eventos com EventBridge e Lambda: perfis distintos por grupo, com suporte a grupos nativos do QuickSight e grupos do IDC
  • Cenário 4 — Atualização em lote: para usuários já existentes provisionados antes da automação entrar em vigor

Vale reforçar: os Cenários 2 e 3 são complementares, não alternativos. O Cenário 2 estabelece a linha de base restritiva e o Cenário 3 refina as permissões conforme os usuários são atribuídos a grupos. Para quem está começando, a recomendação é partir pelo Cenário 2. Para mais detalhes, consulte a documentação de permissões personalizadas do Amazon QuickSight.

Fonte

Automate user-level custom permissions for Amazon Quick (https://aws.amazon.com/blogs/machine-learning/automate-user-level-custom-permissions-for-amazon-quick/)

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

More posts