Modernizar a autenticação do Amazon Redshift ao migrar o gerenciamento de usuários para o AWS IAM Id Heart

Amazon Redshift é um poderoso information warehouse baseado em nuvem que as organizações podem usar para analisar dados estruturados e semi-estruturados por meio de consultas SQL avançadas. Como um serviço totalmente gerenciado, fornece alto desempenho e escalabilidade, permitindo acesso seguro aos dados armazenados no information warehouse. As organizações em todo o mundo dependem do Amazon Redshift para lidar com conjuntos de dados enormes, atualizar seus recursos de análise e fornecer inteligência de negócios valiosa para seus stakeholders.

AWS IAM Heart Id serve como a plataforma preferida para controlar o acesso da força de trabalho às ferramentas da AWS, incluindo Desenvolvedor da Amazon Q.. Ele permite uma única conexão com o seu provedor de identidade existente (IDP), criando uma visão unificada dos usuários nos aplicativos da AWS e aplicando Propagação de identidade confiável Para uma experiência suave e consistente.

Você pode acessar dados no Amazon Redshift usando usuários locais ou usuários externos. Um usuário native no Amazon Redshift é uma conta de usuário do banco de dados criada e gerenciada diretamente no próprio cluster do Redshift. Amazon Redshift também integra -se ao IAM Id Hearte suportes Propagação de identidade confiávelentão você pode usar IDPs de terceiros como Microsoft ENTRA ID (Azure AD), Okta, Ping, OneLogin ou Use IAM Id Heart como fonte de identidade. A integração do IAM Id Heart com o Amazon Redshift suporta recursos centralizados de autenticação e SSO, simplificando o gerenciamento de acesso em ambientes de várias contas. À medida que as organizações crescem em escala, é recomendável usar usuários externos para integração entre serviços e gerenciamento de acesso centralizado.

Nesta postagem, orientamos você pelo processo de migrar suavemente o seu gerenciamento native de usuários de usuários de usuários para IAM para usuários e grupos do centro de identidade usando o RedshiftIdcMigration utilidade.

Visão geral da solução

O diagrama a seguir ilustra a arquitetura da solução.

O RedshiftIdcMigration A utilidade acelera a migração de seus usuários, grupos e funções locais de desvio para o vermelho para a instância do IAM Id Heart, realizando as seguintes atividades:

• Crie usuários no IAM Heart Id para todos os usuários locais em uma determinada instância do desvio para o vermelho.
• Crie grupos no Centro de Identidade do IAM para todos os grupos ou função em uma determinada instância do desvio para o vermelho.
• Atribua usuários a grupos no IAM Id Heart de acordo com as tarefas existentes na instância do desvio para o vermelho.
• Crie as funções do IAM Id Heart na instância do Redshift que correspondem aos grupos criados no IAM Id Heart.
• As permissões de concessão para as funções do IAM Id Heart na instância do Redshift com base nas permissões atuais dadas aos grupos e funções locais.

Pré -requisitos

Antes de executar o utilitário, full os seguintes pré -requisitos:

1. Ativar IAM Heart Id em sua conta.
2. Siga as etapas do submit Integrar o provedor de identidade (IDP) com o Amazon Redshift Question Editor V2 e o cliente SQL usando o AWS IAM Id Heart for Seamless Single Signal-On (Especificamente, siga as etapas 1–8, pulando as etapas 4 e 6).
3. Configure as atribuições de aplicativos do IAM Id Heart:
   1. No console do IAM Id Heart, escolha Atribuições de aplicativos e Aplicações.
   2. Selecione seu aplicativo e no Ações Menu suspenso, escolha Editar detalhes.
   3. Para Atribuições de usuário e grupoescolher Não requer tarefas. Essa configuração permite testar a conectividade do Amazon Redshift sem configurar permissões específicas de acesso a dados.
4. Configurar a autenticação do IAM Id Heart com acesso administrativo de qualquer Nuvem de computação elástica da Amazon (Amazon EC2) ou AWS CloudShell.

O utilitário será executado a partir de uma instância do EC2 ou CloudShell. Se você estiver usando uma instância do EC2, uma função de IAM será anexada à instância. Certifique -se de que o papel do IAM usado durante a execução tenha as seguintes permissões (se não, crie uma nova política com essas permissões e anexe -a à função do IAM):

• Amazon Redshift Permissões (para servidor sem servidor):

{
    "Model": "2012-10-17",
    "Assertion": (
        {
            "Sid": "VisualEditor0",
            "Impact": "Enable",
            "Motion": (
                "redshift-serverless:GetCredentials",
                "redshift-serverless:GetNamespace",
                "redshift-serverless:GetWorkgroup"
            ),
            "Useful resource": (
                "arn:aws:redshift-serverless:${area}:${account-id}:namespace/${namespace-id}",
                "arn:aws:redshift-serverless:${area}:${account-id}:workgroup/${workgroup-id}"
            )
        },
        {
            "Sid": "VisualEditor1",
            "Impact": "Enable",
            "Motion": (
                "redshift-serverless:ListNamespaces",
                "redshift-serverless:ListWorkgroups"
            ),
            "Useful resource": "*"
        },
        {
            "Sid": "VisualEditor2",
            "Impact": "Enable",
            "Motion": (
                "redshift:CreateClusterUser",
                "redshift:JoinGroup",
                "redshift:GetClusterCredentials",
                "redshift:ExecuteQuery",
                "redshift:FetchResults",
                "redshift:DescribeClusters",
                "redshift:DescribeTable"
            ),
            "Useful resource": (
                "arn:aws:redshift:${area}:${account-id}:cluster:redshift-serverless-${workgroup-name}",
                "arn:aws:redshift:${area}:${account-id}:dbgroup:redshift-serverless-${workgroup-name}/${dbgroup}",
                "arn:aws:redshift:${area}:${account-id}:dbname:redshift-serverless-${workgroup-name}/${dbname}",
                "arn:aws:redshift:${area}:${account-id}:dbuser:redshift-serverless-${workgroup-name}/${dbuser}"
            )
        }
    )
}

• Amazon Redshift Permissões (para provisionadas):

{
    "Model": "2012-10-17",
    "Assertion": (
        {
            "Sid": "VisualEditor0",
            "Impact": "Enable",
            "Motion": "redshift:GetClusterCredentials",
            "Useful resource": (
                "arn:aws:redshift: ${area}:${account-id}:dbname:${cluster_name}/${dbname}",
                "arn:aws:redshift: ${area}: ${account-id}:dbuser:${cluster-name}/${dbuser}"
            )
        },
        {
            "Sid": "VisualEditor1",
            "Impact": "Enable",
            "Motion": (
                "redshift:DescribeClusters",
                "redshift:ExecuteQuery",
                "redshift:FetchResults",
                "redshift:DescribeTable"
            ),
            "Useful resource": "*"
        }
    )
}

{
    "Model": "2012-10-17",
    "Assertion": (
        {
            "Sid": "VisualEditor0",
            "Impact": "Enable",
            "Motion": (
                "s3:PutObject",
                "s3:GetObject",
                "s3:GetEncryptionConfiguration",
                "s3:ListBucket",
                "s3:DeleteObject"
            ),
            "Useful resource": (
                "arn:aws:s3:::${s3_bucket_name}/*",
                "arn:aws:s3:::${s3_bucket_name}"
            )
        }
    )
}

• Permissões de armazenamento de identidade:

{
    "Model": "2012-10-17",
    "Assertion": (
        {
            "Sid": "VisualEditor0",
            "Impact": "Enable",
            "Motion": "identitystore:*",
            "Useful resource": (
                "arn:aws:identitystore:::group/*",
                "arn:aws:identitystore:::person/*",
                "arn:aws:identitystore::${account_id}:identitystore/${identity_store_id}",
                "arn:aws:identitystore:::membership/*"
            )
        },
        {
            "Sid": "VisualEditor1",
            "Impact": "Enable",
            "Motion": "identitystore:*",
            "Useful resource": (
                "arn:aws:identitystore:::membership/*",
                "arn:aws:identitystore:::person/*",
                "arn:aws:identitystore:::group/*"
            )
        }
    )
}

Artefatos

Baixar os seguintes artefatos de utilidade do Repo Github:

• idc_redshift_unload_indatabase_groups_roles_users.py – Um script python para descarregar usuários, grupos, funções e suas associações.
• redshift_unload.ini – O arquivo de configuração usado no script anterior para ler os detalhes do Redshift Information Warehouse e os locais da Amazon S3 para descarregar os arquivos.
• idc_add_users_groups_roles_sets.py – Um script Python para criar usuários e grupos no IAM Id Heart e depois associar os usuários a grupos no IAM Id Heart.
• idc_config.ini – O arquivo de configuração usado no script anterior para ler os detalhes do IAM Id Heart.
• VW_LOCAL_UGR_TO_IDC_URGR_PRIV.SQL – Um script que gera instruções SQL que executam duas tarefas no Amazon Redshift:
  • Crie funções que correspondam exatamente aos nomes dos grupos do IAM Id Heart, adicionando um prefixo especificado.
  • Conceda permissões apropriadas a essas funções de desvio para o vermelho recém -criadas.

Cenário de teste

Este caso de teste foi projetado para oferecer experiência prática e familiarizá -lo com a funcionalidade da concessionária. O cenário é estruturado em torno de um sistema hierárquico de papéis aninhados, começando com permissões no nível de objeto atribuídas a funções técnicas. Essas funções técnicas são alocadas para funções de negócios. Finalmente, as funções de negócios são concedidas a usuários individuais. Para aprimorar o ambiente de teste, o cenário também incorpora um grupo de usuários. O diagrama a seguir ilustra essa hierarquia.

Crie conjuntos de dados

Configure dois esquemas separados (tickit e tpcds) em um banco de dados de desvio para o vermelho usando o Crie esquema comando. Em seguida, crie e preencha algumas mesas em cada esquema usando o tickit e TPCDS amostras de conjuntos de dados.

Especifique o Nome do Recurso Amazon (ARN) apropriado do IAM (ARN) nos comandos de cópia, se necessário.

Criar usuários

Crie usuários com o seguinte código:

-- ETL customers
create person etl_user_1 password 'EtlUser1!';
create person etl_user_2 password 'EtlUser2!';
create person etl_user_3 password 'EtlUser3!';

-- Reporting customers
create person reporting_user_1 password 'ReportingUser1!';
create person reporting_user_2 password 'ReportingUser2!';
create person reporting_user_3 password 'ReportingUser3!';

-- Adhoc customers
create person adhoc_user_1 password 'AdhocUser1!';
create person adhoc_user_2 password 'AdhocUser2!';

-- Analyst customers
create person analyst_user_1 password 'AnalystUser1!';

Crie funções de negócios

Crie usuários de negócios com o seguinte código:

-- ETL enterprise roles
create function role_bn_etl_tickit;
create function role_bn_etl_tpcds;

-- Reporting enterprise roles
create function role_bn_reporting_tickit;
create function role_bn_reporting_tpcds;

-- Analyst enterprise roles
create function role_bn_analyst_tickit;

Crie papéis técnicos

Crie funções técnicas com o seguinte código:

-- Technical roles for tickit schema
create function role_tn_sel_tickit;
create function role_tn_dml_tickit;
create function role_tn_cte_tickit;

-- Technical roles for tpcds schema
create function role_tn_sel_tpcds;
create function role_tn_dml_tpcds;
create function role_tn_cte_tpcds;

Criar grupos

Crie grupos com o seguinte código:

-- Adhoc customers group
create group group_adhoc;

Conceder direitos às funções técnicas

Para conceder direitos aos papéis técnicos, use o seguinte código:

-- role_tn_sel_tickit
grant utilization on schema tickit to function role_tn_sel_tickit;
grant choose on all tables in schema tickit to function role_tn_sel_tickit;

-- role_tn_dml_tickit
grant utilization on schema tickit to function role_tn_dml_tickit;
grant insert, replace, delete on all tables in schema tickit to function role_tn_dml_tickit;

-- role_tn_cte_tickit
grant utilization, create on schema tickit to function role_tn_cte_tickit;
grant drop on all tables in schema tickit to function role_tn_cte_tickit;

-- role_tn_sel_tpcds
grant utilization on schema tpcds to function role_tn_sel_tpcds;
grant choose on all tables in schema tpcds to function role_tn_sel_tpcds;

-- role_tn_dml_tpcds
grant utilization on schema tpcds to function role_tn_dml_tpcds;
grant insert, replace, delete on all tables in schema tpcds to function role_tn_dml_tpcds;

-- role_tn_cte_tpcds
grant utilization, create on schema tpcds to function role_tn_cte_tpcds;
grant drop on all tables in schema tpcds to function role_tn_cte_tpcds;

Conceder funções técnicas a funções de negócios

Para conceder as funções técnicas às funções comerciais, use o seguinte código:

-- Enterprise function role_bn_etl_tickit
grant function role_tn_sel_tickit to function role_bn_etl_tickit;
grant function role_tn_dml_tickit to function role_bn_etl_tickit;
grant function role_tn_cte_tickit to function role_bn_etl_tickit;

-- Enterprise function role_bn_etl_tpcds
grant function role_tn_sel_tpcds to function role_bn_etl_tpcds;
grant function role_tn_dml_tpcds to function role_bn_etl_tpcds;
grant function role_tn_cte_tpcds to function role_bn_etl_tpcds;

-- Enterprise function role_bn_reporting_tickit
grant function role_tn_sel_tickit to function role_bn_reporting_tickit;

-- Enterprise function role_bn_reporting_tpcds
grant function role_tn_sel_tpcds to function role_bn_reporting_tpcds;

-- Enterprise function role_bn_analyst_tickit
grant function role_tn_sel_tickit to function role_bn_analyst_tickit;

Conceder funções comerciais aos usuários

Para conceder as funções comerciais aos usuários, use o seguinte código:

-- etl_user_1
grant function role_bn_etl_tickit to etl_user_1;

-- etl_user_2
grant function role_bn_etl_tpcds to etl_user_2;

-- etl_user_3
grant function role_bn_etl_tickit to etl_user_3;
grant function role_bn_etl_tpcds to etl_user_3;

-- reporting_user_1
grant function role_bn_reporting_tickit to reporting_user_1;

-- reporting_user_2
grant function role_bn_reporting_tpcds to reporting_user_2;

-- reporting_user_3
grant function role_bn_reporting_tickit to reporting_user_3;
grant function role_bn_reporting_tpcds to reporting_user_3;

-- analyst_user_1
grant function role_bn_analyst_tickit to analyst_user_1;

Conceder direitos aos grupos

Para conceder direitos aos grupos, use o seguinte código:

-- Group group_adhoc
grant utilization on schema tickit to group group_adhoc;
grant choose on all tables in schema tickit to group group_adhoc;

grant utilization on schema tpcds to group group_adhoc;
grant choose on all tables in schema tpcds to group group_adhoc;

Adicione usuários a grupos

Para adicionar usuários aos grupos, use o seguinte código:

alter group group_adhoc add person adhoc_user_1;
alter group group_adhoc add person adhoc_user_2;

Implantar a solução

Conclua as seguintes etapas para implantar a solução:

1. Atualize o Cluster Redshift ou os detalhes sem servidor e a localização da Amazon S3 em redshift_unload.ini:
   • cluster_type = provisioned ou serverless
   • cluster_id = ${cluster_identifier} (exigido se cluster_type é provisioned)
   • db_user = ${database_user}
   • db_name = ${database_name}
   • hospedar = ${host_url} (exigido se cluster_type é provisioned)
   • porta = ${port_number}
   • WorkGroup_Name = ${workgroup_name} (exigido se cluster_type é serverless)
   • região = ${area}
   • s3_bucket = ${S3_bucket_name}
   • papéis = roles.csv
   • Usuários = customers.csv
   • Role_memberships = role_memberships.csv
2. Atualizar detalhes do IAM Id Heart em idc_config.ini:
   • região = ${area}
   • conta_id = ${account_id}
   • identity_store_id = ${identity_store_id} (Disponível no console do IAM Id Heart Configurações página)
   • instância_arn = ${iam_identity_center_instance_arn} (Disponível no console do IAM Id Heart Configurações página)
   • permissão_set_arn = ${permission_set_arn}
   • atribui_permission_set = True ou False (True se permission_set_arn é definido)
   • s3_bucket = ${S3_bucket_name}
   • usuários_file = customers.csv
   • RONS_FILE = roles.csv
   • Role_memberships_file = role_memberships.csv
3. Crie um diretório no CloudShell ou em sua própria instância EC2 com conectividade com o Amazon Redshift.
4. Copie os dois arquivos .ini e faça o obtain dos scripts Python para esse diretório.
5. Correr idc_redshift_unload_indatabase_groups_roles_users.py de CloudShell ou sua instância EC2:python idc_redshift_unload_indatabase_groups_roles_users.py
6. Correr idc_add_users_groups_roles_psets.py de CloudShell ou sua instância EC2:python idc_add_users_groups_roles_psets.py
7. Conecte seu cluster Redshift usando o Amazon Redshift Question Editor V2 ou o cliente SQL preferido, usando credenciais de superusuário.
8. Copie o SQL no vw_local_ugr_to_idc_urgr_priv.sql Arquive e execute -o no editor de consulta para criar o vw_local_ugr_to_idc_urgr_priv visualizar.
9. Execute o comando SQL para gerar as instruções SQL para criar funções e permissões:

   choose existing_grants,idc_based_grants from vw_local_ugr_to_idc_urgr_priv;

   Por exemplo, considere os seguintes subsídios existentes:

   CREATE GROUP "group_adhoc";
   CREATE ROLE "role_bn_etl_tickit";
   GRANT USAGE ON SCHEMA tpcds TO function "role_tn_sel_tpcds" ;

   Essas doações são convertidas para o seguinte código:

   CREATE function "AWSIDC:group_adhoc";
   CREATE function "AWSIDC:role_bn_etl_tickit";
   GRANT USAGE ON SCHEMA tpcds TO function "AWSIDC:role_tn_sel_tpcds";

10. Revise as declarações no idc_based_grants coluna.
    Isso pode não ser uma lista abrangente de permissões; portanto, revise -as com cuidado.
11. Se tudo estiver correto, execute as instruções do cliente SQL.

Quando você concluir o processo, você deve ter a seguinte configuração:

• O IAM Id Heart agora contém usuários recém -criados da Amazon Redshift
• Os grupos e funções locais do desvio para o vermelho são criados como grupos no IAM Id Heart
• Novos papéis são estabelecidos no Amazon Redshift, correspondendo aos grupos criados no IAM Id Heart
• As funções de desvio para o vermelho recém -criadas recebem permissões apropriadas

Se você encontrar um problema enquanto se conecta ao Amazon Redshift com o editor de consulta usando o IAM Id Heart, consulte Solução de problemas de conexões do Amazon Redshift Consulta Editor V2.

Considerações

Considere o seguinte ao usar esta solução:

• No momento da redação, criando permissões em Formação do lago AWS não está no escopo.
• O IAM Id Heart e o IDP Integration Setup estão fora de escopo para este utilitário. No entanto, você pode usar a visualização vw_local_ugr_to_idc_urgr_priv.sqlPara criar funções e conceder permissões aos usuários e grupos do IDP, passaram pelo IAM Id Heart.
• Se você tiver permissões fornecidas diretamente aos IDs de usuários locais (não usando grupos ou funções), deve alterar isso para uma abordagem de permissão baseada em função para a integração do IAM Id Heart. Crie funções e forneça permissões usando funções em vez de fornecer permissões diretamente aos usuários.

Limpar

Se você concluiu o cenário de teste, limpe seu ambiente:

1. Remova as novas funções de desvio para o vermelho criadas pela concessionária, correspondendo aos grupos estabelecidos no IAM Id Heart.
2. Exclua os usuários e grupos criados pelo utilitário no IAM Id Heart.
3. Exclua os usuários, grupos e funções especificadas no cenário de teste.
4. Solte o tickit e tpcds Esquemas.

Você pode usar o VIGOR Parâmetro ao soltar as funções para remover atribuições associadas.

Conclusão

Nesta postagem, mostramos como migrar seu gerenciamento native de usuários do Redshift para o IAM Id Heart. Essa transição oferece várias vantagens importantes para sua organização, como gerenciamento de acesso simplificado por meio de administração centralizada de usuários e grupos, uma experiência de usuário simplificada nos serviços da AWS e uma sobrecarga administrativa reduzida. Você pode implementar esse processo de migração passo a passo, para que você possa testar e validar cada etapa antes de fazer a transição totalmente do seu ambiente de produção.

À medida que as organizações continuam a escalar sua infraestrutura da AWS, o uso do IAM Id Heart se torna cada vez mais valioso para manter o gerenciamento de acesso seguro e eficiente, incluindo Amazon Sagemaker Unified Studio Para uma experiência integrada para todos os seus dados e IA.

Sobre os autores