Integração do Active Directory

Neste tutorial, você criará um ambiente de vários usuários. Esse ambiente inclui um AWS ParallelCluster que está integrado a um AWS Managed Microsoft AD (Active Directory) em corp.example.com. Você configura um usuário Admin para gerenciar o diretório, um usuário ReadOnly para ler o diretório e um usuário user000 para fazer login no cluster. Você pode usar o caminho automatizado ou o caminho manual para criar os recursos de rede, um Active Directory (AD) e a instância do EC2 que você usa para configurar o AD. Independentemente do caminho, a infraestrutura que você cria é pré-configurada para integrar AWS ParallelCluster usando um dos seguintes métodos:

LDAPS com verificação de certificado (recomendado como a opção mais segura)
LDAPS sem verificação de certificado
LDAP

O LDAP por si só não fornece criptografia. Para garantir a transmissão segura de informações potencialmente confidenciais, é altamente recomendável que você use LDAPS (LDAP sobre TLS/SSL) para clusters integrados com ADs. Para obter mais informações, consulte Habilitar o LDAPS do lado do servidor usando AWS Managed Microsoft AD no Guia de Administração AWS Directory Service.

Depois de criar esses recursos, continue configurando e criando seu cluster integrado ao Active Directory (AD). Após criar o cluster, faça login como o usuário que você criou. Para obter mais informações sobre a configuração que você cria neste tutorial, consulte Acesso de vários usuários aos clusters e a seção de configuração DirectoryService.

Este tutorial aborda como criar um ambiente que ofereça suporte ao acesso de vários usuários aos clusters. Este tutorial não aborda como você cria e usa um AD AWS Directory Service. As etapas que você segue para configurar um AWS Managed Microsoft AD neste tutorial são fornecidas somente para fins de teste. Eles não são fornecidos para substituir a documentação oficial e as melhores práticas que você pode encontrar no AWS Managed Microsoft AD e Simple AD no Guia de Administração AWS Directory Service.

nota

As senhas de usuário do diretório expiram de acordo com as definições da propriedade da política de senha do diretório. Para obter mais informações, consulte Configurações de políticas compatíveis. Para redefinir as senhas do diretório com AWS ParallelCluster, consulte Como redefinir uma senha de usuário e senhas expiradas.

nota

Os endereços IP do controlador de domínio do diretório podem mudar devido às alterações do controlador de domínio e à manutenção do diretório. Se você escolheu o método automatizado de criação rápida para criar a infraestrutura de diretórios, deverá alinhar manualmente o balanceador de carga na frente dos controladores de diretório quando os endereços IP do diretório mudarem. Se você usar o método de criação rápida, os endereços IP do diretório não serão alinhados automaticamente com os balanceadores de carga.

Ao usar a interface de linha de comando (CLI) AWS ParallelCluster ou a API, você paga apenas pelos recursos AWS criados ao criar ou atualizar imagens e clusters AWS ParallelCluster. Para obter mais informações, consulte Serviços AWS usados por AWS ParallelCluster.

A interface do usuário AWS ParallelCluster é construída em uma arquitetura sem servidor e você pode usá-la na categoria AWS Free Tier na maioria dos casos. Para obter mais informações, consulte Custos de interface de usuário do AWS ParallelCluster.

Pré-requisitos

AWS ParallelClusterestá instalado.
O AWS CLI está instalado e configurado.
Você tem um par de chaves EC2.
Você tem um perfil do IAM com as permissões necessárias para executar a pcluster CLI.

Ao longo do tutorial, substitua inputs highlighted in red, como region-id e d-abcdef01234567890, por seus próprios nomes e IDs. Substituir 0123456789012 por seu número Conta da AWS.

Escolha a guia Automatizado para criar a infraestrutura do Active Directory (AD) com um modelo de criação AWS CloudFormation rápida.

Escolha a guia Manual para criar manualmente a infraestrutura do AD.

Faça login no AWS Management Console.
Abra a CloudFormation Criação Rápida (região us-east-1) para criar os seguintes recursos no CloudFormation console:
- Uma VPC com duas sub-redes e roteamento para acesso público, se nenhuma VPC for especificada.
- Uma AWS Managed Microsoft AD.
- Uma instância do EC2 associada ao AD que você pode usar para gerenciar o diretório.
Na seção Parâmetros da página de pilha de criação rápida, insira valores para os seguintes parâmetros:
- AdminPassword
- ReadOnlyPassword
- UserPassword
Anote a senha. Você precisará dela posteriormente neste tutorial.
Em DomainName, insira corp.example.com
Em Keypair, insira o nome do par de chaves do EC2.
Na parte inferior da página, marque as caixas de seleção que reconhecem cada um dos recursos de acesso.
Selecione Criar pilha.
Depois que a CloudFormation pilha atingir o CREATE_COMPLETE estado, escolha a guia Saídas da pilha. Anote os nomes e IDs dos recursos de saída porque você precisa usá-los em etapas posteriores. As saídas fornecem as informações necessárias para criar o cluster.
Para concluir os exercícios (Opcional) Etapa 2: gerenciar usuários e grupos do AD, você precisa do ID do diretório. Escolha Recursos e role para baixo para anotar o ID do diretório.
Continue em (Opcional) Etapa 2: gerenciar usuários e grupos do AD ou Etapa 1: criar um cluster.

Crie uma VPC no serviço de diretório com as duas sub-redes em diferentes zonas de disponibilidade e um AWS Managed Microsoft AD.

nota

O diretório e o nome do domínio são corp.example.com. O nome curto é CORP.
Altere a senha Admin no script.
O Active Directory (AD) leva pelo menos 15 minutos para ser criado.

Use o script Python a seguir para criar a VPC, as sub-redes e os recursos do AD em seu Região da AWS local. Salve esse arquivo como ad.py e execute-o.


import boto3
import time
from pprint import pprint

vpc_name = "PclusterVPC"
ad_domain = "corp.example.com"
admin_password = "asdfASDF1234"

ec2 = boto3.client("ec2")
ds = boto3.client("ds")
region = boto3.Session().region_name

# Create the VPC, Subnets, IGW, Routes
vpc = ec2.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
vpc_id = vpc["VpcId"]
time.sleep(30)
ec2.create_tags(Resources=[vpc_id], Tags=[{"Key": "Name", "Value": vpc_name}])
subnet1 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.0.0/17", AvailabilityZone=f"{region}a")["Subnet"]
subnet1_id = subnet1["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet1_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet1"}])
ec2.modify_subnet_attribute(SubnetId=subnet1_id, MapPublicIpOnLaunch={"Value": True})
subnet2 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.128.0/17", AvailabilityZone=f"{region}b")["Subnet"]
subnet2_id = subnet2["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet2_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet2"}])
ec2.modify_subnet_attribute(SubnetId=subnet2_id, MapPublicIpOnLaunch={"Value": True})
igw = ec2.create_internet_gateway()["InternetGateway"]
ec2.attach_internet_gateway(InternetGatewayId=igw["InternetGatewayId"], VpcId=vpc_id)
route_table = ec2.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])["RouteTables"][0]
ec2.create_route(RouteTableId=route_table["RouteTableId"], DestinationCidrBlock="0.0.0.0/0", GatewayId=igw["InternetGatewayId"])
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsSupport={"Value": True})
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsHostnames={"Value": True})

# Create the Active Directory
ad = ds.create_microsoft_ad(
    Name=ad_domain,
    Password=admin_password,
    Description="ParallelCluster AD",
    VpcSettings={"VpcId": vpc_id, "SubnetIds": [subnet1_id, subnet2_id]},
    Edition="Standard",
)
directory_id = ad["DirectoryId"]

# Wait for completion
print("Waiting for the directory to be created...")
directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
directory = directories[0]
while directory["Stage"] in {"Requested", "Creating"}:
    time.sleep(3)
    directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
    directory = directories[0]
    
dns_ip_addrs = directory["DnsIpAddrs"]

pprint({"directory_id": directory_id,
        "vpc_id": vpc_id,
        "subnet1_id": subnet1_id,
        "subnet2_id": subnet2_id,
        "dns_ip_addrs": dns_ip_addrs})

A seguir está um exemplo de saída do script do Python.


{
  "directory_id": "d-abcdef01234567890",
  "dns_ip_addrs": ["192.0.2.254", "203.0.113.237"],
  "subnet1_id": "subnet-021345abcdef6789",
  "subnet2_id": "subnet-1234567890abcdef0",
  "vpc_id": "vpc-021345abcdef6789"
}

Anote os nomes e IDs dos recursos de saída. Você vai usá-los em etapas subsequentes.

Após concluir o script, avance para a próxima etapa.

New EC2 console

Faça login no AWS Management Console.
Se você não tiver uma função com as políticas listadas na etapa 4 em anexo, abra o console do IAM em https://console.aws.amazon.com/iam/. Caso contrário, vá para a etapa 8.

Crie a política ResetUserPassword, substituindo o conteúdo destacado em vermelho por seu ID Região da AWS, ID da conta e ID do diretório da saída do script que você executou para criar o AD.

ResetUserPassword


{
       "Statement": [
        {
            "Action": [
                "ds:ResetUserPassword"
            ],
            "Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
            "Effect": "Allow"
        }
    ]
}

Crie um perfil do IAM com as políticas a seguir anexada.
- AWSpolítica gerenciada AmazonSSM ManagedInstanceCore
- AWSpolítica gerenciada AmazonSSM DirectoryServiceAccess
- ResetUserPassword política
Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.
No painel do EC2, escolha Launch Instance (Executar instância).
Em Imagens de aplicações e sistemas operacionais, selecione uma AMI recente do Amazon Linux 2.
Em tipo de instância, escolha t2.micro.
Em par de chaves, escolha um par de chaves.
Em Configurações de rede, escolha Editar.
Em VPC, selecione a VPC do diretório.
Role para baixo e selecione Detalhes avançados.
Em Detalhes avançados, Diretório de ingresso em domínio, escolhacorp.example.com.
Para o perfil de instância do IAM, escolha a função que você criou na etapa 1 ou uma função com as políticas listadas na etapa 4 em anexo.
Em Resumo, escolha Launch instance (Executar instância).
Anote o ID da instância (por exemplo, i-1234567890abcdef0) e aguarde a conclusão da execução da instância.
Após a instância ser executada, vá para a próxima etapa.

Old EC2 console

Faça login no AWS Management Console.
Se você não tiver uma função com as políticas listadas na etapa 4 em anexo, abra o console do IAM em https://console.aws.amazon.com/iam/. Caso contrário, vá para a etapa 8.

Crie a política do ResetUserPassword Substitua o conteúdo destacado em vermelho por seu IDRegião da AWS, ID Conta da AWS, ID do diretório da saída do script que você executou para criar o Active Directory (AD).

ResetUserPassword


{
        "Statement": [
            {
                "Action": [
                    "ds:ResetUserPassword"
                ],
                "Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
                "Effect": "Allow"
            }
        ]
     }

Crie um perfil do IAM com as políticas a seguir anexada.
- AWSpolítica gerenciada AmazonSSM ManagedInstanceCore
- AWSpolítica gerenciada AmazonSSM DirectoryServiceAccess
- Política do ResetUserPassword
Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.
No painel do EC2, escolha Launch Instance (Executar instância).
Em Imagens de aplicações e sistemas operacionais, selecione uma AMI recente do Amazon Linux 2.
Em Instance type (Tipo de instância), escolha t2.micro.
Em par de chaves, escolha um par de chaves.
Em Configurações de rede, escolha Editar.
Em Network settings (Configurações de rede), VPC, selecione o diretório VPC.
Role para baixo e selecione Detalhes avançados.
Em Detalhes avançados, Diretório de ingresso em domínio, escolhacorp.example.com.
Em Detalhes avançados, Perfil da instância, escolha a função que você criou na etapa 1 ou uma função com as políticas listadas na etapa 4 em anexo.
Em Resumo, escolha Launch instance (Executar instância).
Anote o ID da instância (por exemplo, i-1234567890abcdef0) e espere que a instância termine de ser executada.
Após a instância ser executada, vá para a próxima etapa.

Conecte-se à sua instância e entre no realm do AD como `admin`.

Execute os comandos a seguir para se conectar à instância.


$ INSTANCE_ID="i-1234567890abcdef0"


$ PUBLIC_IP=$(aws ec2 describe-instances \
--instance-ids $INSTANCE_ID \
--query "Reservations[0].Instances[0].PublicIpAddress" \
--output text)


$ ssh -i ~/.ssh/keys/keypair.pem ec2-user@$PUBLIC_IP

Instale o software necessário e entre no realm.


$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python

Substitua a senha do administrador pela sua senha admin.
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
       
```
Se o procedimento anterior tiver sido bem-sucedido, você se juntará ao realm e poderá avançar para a etapa seguinte.

Crie o ReadOnlyUser e um usuário adicional.

Nesta etapa, você usa as ferramentas adcli e openldap-clients que você instalou na etapa anterior.


$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=ReadOnlyUser ReadOnlyUser


$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=user000 user000

Verifique se os usuários foram criados:

Os endereços IP DNS do diretório são saídas do script Python.


$ DIRECTORY_IP="192.0.2.254"


$ ldapsearch -x -h $DIRECTORY_IP -D Admin -w $ADMIN_PW -b "cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com"


$ ldapsearch -x -h $DIRECTORY_IP -D Admin -w $ADMIN_PW -b "cn=user000,ou=Users,ou=CORP,dc=corp,dc=example,dc=com"

Por padrão, quando você cria um usuário com o ad-cli, o usuário é desabilitado.

Redefina e ative as senhas de usuário da sua máquina local:

Faça logout da instância do EC2.

nota

ro-p@ssw0rd é a senha de ReadOnlyUser, recuperada de AWS Secrets Manager.
user-p@ssw0rd é a senha de um usuário do cluster fornecida quando você se conecta (ssh) ao cluster.

directory-id é uma saída do script Python.


$ DIRECTORY_ID="d-abcdef01234567890"


$ aws ds reset-user-password \
--directory-id $DIRECTORY_ID \
--user-name "ReadOnlyUser" \
--new-password "ro-p@ssw0rd" \
--region "region-id"


$ aws ds reset-user-password \
--directory-id $DIRECTORY_ID \
--user-name "user000" \
--new-password "user-p@ssw0rd" \
--region "region-id"

Adicione a senha a um segredo do Secrets Manager.

Agora que você criou ReadOnlyUser e definiu a senha, armazene-a em um segredo usado pelo AWS ParallelCluster para validar logins.

Use o Secrets Manager para criar um novo segredo para manter a senha do ReadOnlyUser como valor. O formato do valor secreto deve ser somente texto sem formatação (não no formato JSON). Anote o ARN secreto para futuras etapas.
```
$ aws secretsmanager create-secret --name "ADSecretPassword" \
--region region_id \
--secret-string "ro-p@ssw0rd" \
--query ARN \
--output text
arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
```

Anote os IDs de recursos. Você vai usá-los em etapas subsequentes.

Gere certificado de domínio localmente.


$ PRIVATE_KEY="corp-example-com.key"
CERTIFICATE="corp-example-com.crt"
printf ".\n.\n.\n.\n.\ncorp.example.com\n.\n" | openssl req -x509 -sha256 -nodes -newkey rsa:2048 -keyout $PRIVATE_KEY -days 365 -out $CERTIFICATE

Armazene o certificado no Secrets Manager para torná-lo recuperável de dentro do cluster posteriormente.


$ aws secretsmanager create-secret --name example-cert \
  --secret-string file://$CERTIFICATE \
  --region region-id
{
  "ARN": "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
  "Name": "example-cert",
  "VersionId": "14866070-092a-4d5a-bcdd-9219d0566b9c"
}

Adicione a seguinte política ao perfil do IAM que você criou para unir a instância do EC2 ao domínio AD.

PutDomainCertificateSecrets


{
    "Statement": [
        {
            "Action": [
                "secretsmanager:PutSecretValue"
            ],
            "Resource": [
                "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
            ],
            "Effect": "Allow"
        }
    ]
}

Importe o certificado para AWS Certificate Manager (ACM).


$ aws acm import-certificate --certificate fileb://$CERTIFICATE \
  --private-key fileb://$PRIVATE_KEY \
  --region region-id
{
  "CertificateArn": "arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72"
}

Crie um balanceador de carga que é colocado na frente dos endpoints do Active Directory.


$ aws elbv2 create-load-balancer --name CorpExampleCom-NLB \
  --type network \
  --scheme internal \
  --subnets subnet-1234567890abcdef0 subnet-021345abcdef6789 \
  --region region-id
{
  "LoadBalancers": [
    {
      "LoadBalancerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4",
      "DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
      "CanonicalHostedZoneId": "Z2IFOLAFXWLO4F",
      "CreatedTime": "2022-05-05T12:56:55.988000+00:00",
      "LoadBalancerName": "CorpExampleCom-NLB",
      "Scheme": "internal",
      "VpcId": "vpc-021345abcdef6789",
      "State": {
        "Code": "provisioning"
       },
       "Type": "network",
       "AvailabilityZones": [
         {
           "ZoneName": "region-idb",
           "SubnetId": "subnet-021345abcdef6789",
           "LoadBalancerAddresses": []
         },
         {
           "ZoneName": "region-ida",
           "SubnetId": "subnet-1234567890abcdef0",
           "LoadBalancerAddresses": []
         }
       ],
       "IpAddressType": "ipv4"
    }   
  ]
}

Crie o grupo-alvo que tem como alvo os endpoints do Active Directory.


$ aws elbv2 create-target-group --name CorpExampleCom-Targets --protocol TCP \
  --port 389 \
  --target-type ip \
  --vpc-id vpc-021345abcdef6789 \
  --region region-id
{
  "TargetGroups": [
    {
      "TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
      "TargetGroupName": "CorpExampleCom-Targets",
      "Protocol": "TCP",
      "Port": 389,
      "VpcId": "vpc-021345abcdef6789",
      "HealthCheckProtocol": "TCP",
      "HealthCheckPort": "traffic-port",
      "HealthCheckEnabled": true,
      "HealthCheckIntervalSeconds": 30,
      "HealthCheckTimeoutSeconds": 10,
      "HealthyThresholdCount": 3,
      "UnhealthyThresholdCount": 3,
      "TargetType": "ip",
      "IpAddressType": "ipv4"
    }
  ]
}

Registre os endpoints do Active Directory (AD) no grupo de destino.


$ aws elbv2 register-targets --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
  --targets Id=192.0.2.254,Port=389 Id=203.0.113.237,Port=389 \
  --region region-id

Crie o receptor LB com o certificado.


$ aws elbv2 create-listener --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 \
  --protocol TLS \
  --port 636 \
  --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
  --ssl-policy ELBSecurityPolicy-TLS-1-2-2017-01 \
  --certificates CertificateArn=arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 \
  --region region-id
  "Listeners": [
  {
    "ListenerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b",
    "LoadBalancerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4",
    "Port": 636,
    "Protocol": "TLS",
    "Certificates": [
      {
        "CertificateArn": "arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72"
       }
     ],
     "SslPolicy": "ELBSecurityPolicy-TLS-1-2-2017-01",
     "DefaultActions": [
       {
         "Type": "forward",
         "TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
         "ForwardConfig": {
           "TargetGroups": [
             {
                "TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81"
              }
            ]
          }
        }
      ]
    }
  ]
}

Crie a zona hospedada para tornar o domínio detectável dentro da VPC do cluster.


$ aws route53 create-hosted-zone --name corp.example.com \
  --vpc VPCRegion=region-id,VPCId=vpc-021345abcdef6789 \
  --caller-reference "ParallelCluster AD Tutorial"
{
  "Location": "https://route53.amazonaws.com/2013-04-01/hostedzone/Z09020002B5MZQNXMSJUB",
  "HostedZone": {
    "Id": "/hostedzone/Z09020002B5MZQNXMSJUB",
    "Name": "corp.example.com.",
    "CallerReference": "ParallelCluster AD Tutorial",
    "Config": {
         "PrivateZone": true
    },
    "ResourceRecordSetCount": 2
  },
  "ChangeInfo": {
    "Id": "/change/C05533343BF3IKSORW1TQ",
    "Status": "PENDING",
    "SubmittedAt": "2022-05-05T13:21:53.863000+00:00"
  },
  "VPC": {
    "VPCRegion": "region-id",
    "VPCId": "vpc-021345abcdef6789"
  }
}

Crie um arquivo chamado `recordset-change.json` com o conteúdo a seguir. O `HostedZoneId` é o ID de zona hospedada canônica do balanceador de carga.


{
  "Changes": [
    {
      "Action": "CREATE",
      "ResourceRecordSet": {
        "Name": "corp.example.com",
        "Type": "A",
        "Region": "region-id",
        "SetIdentifier": "example-active-directory",
        "AliasTarget": {
          "HostedZoneId": "Z2IFOLAFXWLO4F",
          "DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
          "EvaluateTargetHealth": true
        }
      }
    }
  ]
}

Envie a alteração do conjunto de registros para a zona hospedada, desta vez usando o ID da zona hospedada.


$ aws route53 change-resource-record-sets --hosted-zone-id Z09020002B5MZQNXMSJUB \
  --change-batch file://recordset-change.json
{
  "ChangeInfo": {
    "Id": "/change/C0137926I56R3GC7XW2Y",
    "Status": "PENDING",
    "SubmittedAt": "2022-05-05T13:40:36.553000+00:00"
  }
}

Crie um documento de política `policy.json` com o conteúdo a seguir.


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "secretsmanager:GetSecretValue"
      ],
      "Resource": [
        "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-abc123"
      ],
      "Effect": "Allow"
    }
  ]
}

Crie um documento de política chamado `policy.json` com o conteúdo a seguir.


$ aws iam create-policy --policy-name ReadCertExample \
  --policy-document file://policy.json
{
  "Policy": {
    "PolicyName": "ReadCertExample",
    "PolicyId": "ANPAUUXUVBC42VZSI4LDY",
    "Arn": "arn:aws:iam::123456789012:policy/ReadCertExample-efg456",
    "Path": "/",
    "DefaultVersionId": "v1",
    "AttachmentCount": 0,
    "PermissionsBoundaryUsageCount": 0,
    "IsAttachable": true,
    "CreateDate": "2022-05-05T13:42:18+00:00",
    "UpdateDate": "2022-05-05T13:42:18+00:00"
  }
}

Continue seguindo as etapas em (Opcional) Etapa 2: gerenciar usuários e grupos do AD ou Etapa 1: criar um cluster.

Nesta etapa, você gerencia usuários e grupos de uma instância EC2 Amazon Linux 2 que está associada ao domínio Active Delivery (AD).

Se você seguiu o caminho automatizado, reinicie e faça login na instância associada ao AD que foi criada como parte da automação.

Se você seguiu o caminho manual, reinicie e faça login na instância que você criou e ingressou no AD nas etapas anteriores.

Nessas etapas, você usa as ferramentas adcli e openldap-clients que foram instaladas na instância como parte da etapa anterior.

Faça login em uma instância do EC2 que está associada ao domínio AD

No console do EC2, selecione a instância do EC2 sem título que foi criada nas etapas anteriores. A instância deve se encontrar no estado Interrompido.
Se o estado da instância for Interrompido, escolha Estado da instância e, em seguida, Iniciar instância.
Depois que as verificações de status forem aprovadas, selecione a instância e escolha Conectar e SSH na instância.

Gerencie usuários e grupos quando conectados a uma instância EC2 Amazon Linux 2 que se juntou ao AD

Ao executar os comandos adcli com a opção -U "Admin", você será solicitado a inserir a senha Admin do AD. Você inclui a senha Admin do AD como parte dos comandos ldapsearch.

Criar um usuário.


$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"

Definir uma senha de usuário


$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"

Criar um grupo


$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"

Adicionar um usuário a um grupo


$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"

Descrever usuários e grupos.

Descrever todos os usuários.


$ ldapsearch "(&(objectClass=user))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"

Descrever um usuário específico.


$ ldapsearch "(&(objectClass=user)(cn=clusteruser))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"

Descrever todos os usuários com um padrão de nome.


$ ldapsearch "(&(objectClass=user)(cn=user*))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"

Descrever todos os usuários que fazem parte de um grupo específico.


$ ldapsearch "(&(objectClass=user)(memberOf=CN=clusterteam,OU=Users,OU=CORP,DC=corp,DC=example,DC=com))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"

Descrever todos os grupos


$ ldapsearch "objectClass=group" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"

Descrever um grupo específico


$ ldapsearch "(&(objectClass=group)(cn=clusterteam))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"

Remover um usuário de um grupo.


$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"

Excluem um usuário.


$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"

Excluir um grupo


$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"

Se você ainda não saiu da instância do EC2, faça isso agora.

O ambiente está configurado para criar um cluster que possa autenticar usuários no Active Directory (AD).

Crie uma configuração de cluster simples e forneça as configurações relevantes para se conectar ao AD. Para obter mais informações, consulte a seção DirectoryService.

Escolha uma das seguintes configurações de cluster e copie-a em um arquivo chamado ldaps_config.yaml, ldaps_nocert_config.yaml, ou ldap_config.yaml.

Recomendamos que você escolha a configuração LDAPS com verificação de certificado. Se você escolher essa configuração, também deverá copiar o script de bootstrap em um arquivo chamado active-directory.head.post.sh. E você deve armazená-lo em um bucket do Amazon S3, conforme indicado no arquivo de configuração.

nota

Os componentes a seguir devem ser alterados.

KeyName: Um dos seus pares de chaves do EC2.
SubnetId / SubnetIds: um dos IDs de sub-rede fornecidos na saída da pilha de criação CloudFormation rápida (tutorial automatizado) ou do script python (tutorial manual).
Region: A região em que você criou a infraestrutura do AD.
DomainAddr: Esse endereço IP é um dos endereços DNS do seu serviço AD.
PasswordSecretArn: O nome de recurso da Amazon (ARN) do segredo que contém a senha para o DomainReadOnlyUser.
BucketName: o nome do bucket que contém o script de bootstrap.
AdditionalPolicies/Policy: O Amazon Resource Name (ARN) da política de certificação de domínio lido. ReadCertExample
CustomActions / OnNodeConfigured / Args: O nome de recurso da Amazon (ARN) do segredo que contém a política de certificação de domínio.

Para uma melhor postura de segurança, sugerimos usar a AllowedIps configuraçãoHeadNode/Ssh/para limitar o acesso SSH ao nó principal.


Region: region-id
Image:
  Os: alinux2
HeadNode: 
  InstanceType: t2.micro
  Networking:
    SubnetId: subnet-abcdef01234567890
  Ssh:
    KeyName: keypair
  Iam:
    AdditionalIamPolicies:
      - Policy: arn:aws:iam::123456789012:policy/ReadCertExample
    S3Access:
      - BucketName: my-bucket
        EnableWriteAccess: false
        KeyName: bootstrap/active-directory/active-directory.head.post.sh
  CustomActions:
    OnNodeConfigured:
      Script: s3://my-bucket/bootstrap/active-directory/active-directory.head.post.sh
      Args:
        - arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc
        - /opt/parallelcluster/shared/directory_service/domain-certificate.crt
Scheduling:
  Scheduler: slurm
  SlurmQueues:
    - Name: queue0
      ComputeResources:
        - Name: queue0-t2-micro
          InstanceType: t2.micro
          MinCount: 1
          MaxCount: 10         
      Networking:
        SubnetIds:
          - subnet-abcdef01234567890
DirectoryService:
  DomainName: corp.example.com
  DomainAddr: ldaps://corp.example.com
  PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
  DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
  LdapTlsCaCert: /opt/parallelcluster/shared/directory_service/domain-certificate.crt
  LdapTlsReqCert: hard

Script de bootstrap

Depois de criar o arquivo bootstrap e antes de carregá-lo no bucket do S3, execute chmod +x active-directory.head.post.sh para dar ao AWS ParallelCluster permissão de execução.


#!/bin/bash
set -e

CERTIFICATE_SECRET_ARN="$1"
CERTIFICATE_PATH="$2"

[[ -z $CERTIFICATE_SECRET_ARN ]] && echo "[ERROR] Missing CERTIFICATE_SECRET_ARN" && exit 1
[[ -z $CERTIFICATE_PATH ]] && echo "[ERROR] Missing CERTIFICATE_PATH" && exit 1

source /etc/parallelcluster/cfnconfig
REGION="${cfn_region:?}"

mkdir -p $(dirname $CERTIFICATE_PATH)
aws secretsmanager get-secret-value --region $REGION --secret-id $CERTIFICATE_SECRET_ARN --query SecretString --output text > $CERTIFICATE_PATH

nota

Os componentes a seguir devem ser alterados.

KeyName: Um dos seus pares de chaves do EC2.
SubnetId / SubnetIds: um dos IDs de sub-rede que está na saída da pilha de criação CloudFormation rápida (tutorial automatizado) ou do script python (tutorial manual).
Region: A região em que você criou a infraestrutura do AD.
DomainAddr: Esse endereço IP é um dos endereços DNS do seu serviço AD.
PasswordSecretArn: O nome de recurso da Amazon (ARN) do segredo que contém a senha para o DomainReadOnlyUser.

Para uma melhor postura de segurança, sugerimos usar a AllowedIps configuração HeadNode /Ssh/ para limitar o acesso SSH ao nó principal.


Region: region-id
Image:
  Os: alinux2
HeadNode: 
  InstanceType: t2.micro
  Networking:
    SubnetId: subnet-abcdef01234567890
  Ssh:
    KeyName: keypair
Scheduling:
  Scheduler: slurm
  SlurmQueues:
    - Name: queue0
      ComputeResources:
        - Name: queue0-t2-micro
          InstanceType: t2.micro
          MinCount: 1
          MaxCount: 10         
      Networking:
        SubnetIds:
          - subnet-abcdef01234567890
DirectoryService:
  DomainName: corp.example.com
  DomainAddr: ldaps://corp.example.com
  PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
  DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
  LdapTlsReqCert: never

nota

Os componentes a seguir devem ser alterados.

KeyName: Um dos seus pares de chaves do EC2.
SubnetId / SubnetIds: um dos IDs de sub-rede fornecidos na saída da pilha de criação CloudFormation rápida (tutorial automatizado) ou do script python (tutorial manual).
Region: A região em que você criou a infraestrutura do AD.
DomainAddr: Esse endereço IP é um dos endereços DNS do seu serviço AD.
PasswordSecretArn: O nome de recurso da Amazon (ARN) do segredo que contém a senha para o DomainReadOnlyUser.

Para uma melhor postura de segurança, sugerimos usar a AllowedIps configuração HeadNode /Ssh/ para limitar o acesso SSH ao nó principal.


Region: region-id
Image:
  Os: alinux2
HeadNode: 
  InstanceType: t2.micro
  Networking:
    SubnetId: subnet-abcdef01234567890
  Ssh:
    KeyName: keypair
Scheduling:
  Scheduler: slurm
  SlurmQueues:
    - Name: queue0
      ComputeResources:
        - Name: queue0-t2-micro
          InstanceType: t2.micro
          MinCount: 1
          MaxCount: 10         
      Networking:
        SubnetIds:
          - subnet-abcdef01234567890
DirectoryService:
  DomainName: dc=corp,dc=example,dc=com
  DomainAddr: ldap://192.0.2.254,ldap://203.0.113.237
  PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
  DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
  AdditionalSssdConfigs:
    ldap_auth_disable_tls_never_use_in_production: True

Crie o cluster usando o comando a seguir.


$ pcluster create-cluster --cluster-name "ad-cluster" --cluster-configuration "./ldaps_config.yaml"
{
  "cluster": {
    "clusterName": "pcluster",
    "cloudformationStackStatus": "CREATE_IN_PROGRESS",
    "cloudformationStackArn": "arn:aws:cloudformation:region-id:123456789012:stack/ad-cluster/1234567-abcd-0123-def0-abcdef0123456",
    "region": "region-id",
    "version": 3.7.0,
    "clusterStatus": "CREATE_IN_PROGRESS"
  }
}

Você pode determinar o status do cluster com os comandos a seguir.


$ pcluster describe-cluster -n ad-cluster --region "region-id" --query "clusterStatus"

A saída é a seguinte:


"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"

Quando o status chegar a "CREATE_COMPLETE", faça login com o nome de usuário e a senha criados.


$ HEAD_NODE_IP=$(pcluster describe-cluster -n "ad-cluster" --region "region-id" --query headNode.publicIpAddress | xargs echo)


$ ssh user000@$HEAD_NODE_IP

Você pode fazer login sem a senha fornecendo a chave SSH que foi criada para o novo usuário em /home/user000@HEAD_NODE_IP/.ssh/id_rsa.

Se o comando ssh for bem-sucedido, você se conectou com êxito ao cluster como um usuário autenticado para usar o Active Directory (AD).

Na sua máquina local, exclua o cluster.


$ pcluster delete-cluster --cluster-name "ad-cluster" --region "region-id"
{
  "cluster": {
    "clusterName": "ad-cluster",
    "cloudformationStackStatus": "DELETE_IN_PROGRESS",
    "cloudformationStackArn": "arn:aws:cloudformation:region-id:123456789012:stack/ad-cluster/1234567-abcd-0123-def0-abcdef0123456",
    "region": "region-id",
    "version": "3.7.0",
    "clusterStatus": "DELETE_IN_PROGRESS"
  }
}

Verifique o progresso do cluster que está sendo excluído.


$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"

Após excluir o cluster com sucesso, avance para a próxima etapa.

Excluir os recursos do Active Directory

Em https://console.aws.amazon.com/cloudformation/.
No painel de navegação, escolha Pilhas.
Na lista de pilhas, escolha a pilha AD (por exemplo, pcluster-ad).
Escolha Excluir.

Excluir a instância do EC2.
1. Em https://console.aws.amazon.com/ec2/, escolha Instâncias no painel de navegação.
2. Na lista de instâncias, selecione a instância que você criou para adicionar usuários ao diretório.
3. Escolha Instance state (Estado da instância) e Terminate instance (Terminar instância).

Excluir a zona hospedada.

Crie um recordset-delete.json, com o seguinte conteúdo. Neste exemplo, HostedZoneId é o ID canônico da zona hospedada do balanceador de carga.


{
  "Changes": [
    {
      "Action": "DELETE",
      "ResourceRecordSet": {
        "Name": "corp.example.com",
        "Type": "A",
        "Region": "region-id",
        "SetIdentifier": "pcluster-active-directory",
        "AliasTarget": {
          "HostedZoneId": "Z2IFOLAFXWLO4F",
          "DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
          "EvaluateTargetHealth": true
        }
      }
    }
  ]
}

Envie a alteração do conjunto de registros para a zona hospedada usando o ID da zona hospedada.


$ aws route53 change-resource-record-sets --hosted-zone-id Z09020002B5MZQNXMSJUB \
  --change-batch file://recordset-delete.json
{
 "ChangeInfo": {
     "Id": "/change/C04853642A0TH2TJ5NLNI",
     "Status": "PENDING",
     "SubmittedAt": "2022-05-05T14:25:51.046000+00:00"
 }
}

Excluir a zona hospedada.


$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
 "ChangeInfo": {
     "Id": "/change/C0468051QFABTVHMDEG9",
     "Status": "PENDING",
     "SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
 }
}

Exclui o receptor do LB.


$ aws elbv2 delete-listener \
  --listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id

Excluir um grupo de destino.


$ aws elbv2 delete-target-group \
  --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id

Excluir o balanceador de carga.


$ aws elbv2 delete-load-balancer \
  --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id

Excluir a política que o cluster usa para ler o certificado do Secrets Manager.


$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample

Excluir o segredo que contém o certificado de domínio.


$ aws secretsmanager delete-secret \
  --secret-id arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc \
  --region region-id
{
 "ARN": "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
 "Name": "example-cert",
 "DeletionDate": "2022-06-04T16:27:36.183000+02:00"
}

Excluir o certificado do ACM.


$ aws acm delete-certificate \
  --certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id

Excluir os recursos do Active Directory (AD).

Obtenha os seguintes IDs de recursos da saída do script python:ad.py:
- ID AD
- IDs de sub-rede do AD
- ID VPC AD

Exclua o diretório executando o comando a seguir.


$ aws ds delete-directory --directory-id d-abcdef0123456789 --region region-id
{
   "DirectoryId": "d-abcdef0123456789"
}

Liste os grupos de segurança na VPC.


$ aws ec2 describe-security-groups --filters '[{"Name":"vpc-id","Values":["vpc-07614ade95ebad1bc"]}]' --region region-id

Exclua o grupo de segurança personalizado.


$ aws ec2 delete-security-group --group-id sg-021345abcdef6789 --region region-id

Exclua as sub-redes.


$ aws ec2 delete-subnet --subnet-id subnet-1234567890abcdef --region region-id


$ aws ec2 delete-subnet --subnet-id subnet-021345abcdef6789 --region region-id

Descreva o gateway da Internet.


$ aws ec2 describe-internet-gateways \
  --filters Name=attachment.vpc-id,Values=vpc-021345abcdef6789 \
  --region region-id
{
  "InternetGateways": [
    {
      "Attachments": [
        {
          "State": "available",
          "VpcId": "vpc-021345abcdef6789"
        }
      ],
      "InternetGatewayId": "igw-1234567890abcdef",
      "OwnerId": "123456789012",
      "Tags": []
    }
  ]  
}

Separe o gateway da Internet.


$ aws ec2 detach-internet-gateway \
  --internet-gateway-id igw-1234567890abcdef \
  --vpc-id vpc-021345abcdef6789 \
  --region region-id

Exclua o gateway da internet.


$ aws ec2 delete-internet-gateway \
  --internet-gateway-id igw-1234567890abcdef \
  --region region-id

Exclua a VPC.


$ aws ec2 delete-vpc \
  --vpc-id vpc-021345abcdef6789 \
  --region region-id

Exclua o segredo que contém a senha ReadOnlyUser.


$ aws secretsmanager delete-secret \
  --secret-id arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234" \
  --region region-id

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Criação de uma AWS ParallelCluster AMI personalizada

Configurando a criptografia de armazenamento compartilhado com uma chave AWS KMS

Integração do Active Directory

nota

nota

Pré-requisitos

nota

Conecte-se à sua instância e entre no realm do AD como admin.

Instale o software necessário e entre no realm.

Substitua a senha do administrador pela sua senha admin.

Crie o ReadOnlyUser e um usuário adicional.

Redefina e ative as senhas de usuário da sua máquina local:

nota

Gere certificado de domínio localmente.

Armazene o certificado no Secrets Manager para torná-lo recuperável de dentro do cluster posteriormente.

Importe o certificado para AWS Certificate Manager (ACM).

Crie um balanceador de carga que é colocado na frente dos endpoints do Active Directory.

Crie o grupo-alvo que tem como alvo os endpoints do Active Directory.

Registre os endpoints do Active Directory (AD) no grupo de destino.

Crie o receptor LB com o certificado.

Crie a zona hospedada para tornar o domínio detectável dentro da VPC do cluster.

Crie um arquivo chamado recordset-change.json com o conteúdo a seguir. O HostedZoneId é o ID de zona hospedada canônica do balanceador de carga.

Envie a alteração do conjunto de registros para a zona hospedada, desta vez usando o ID da zona hospedada.

Crie um documento de política policy.json com o conteúdo a seguir.

Crie um documento de política chamado policy.json com o conteúdo a seguir.

Continue seguindo as etapas em (Opcional) Etapa 2: gerenciar usuários e grupos do AD ou Etapa 1: criar um cluster.

Faça login em uma instância do EC2 que está associada ao domínio AD

Gerencie usuários e grupos quando conectados a uma instância EC2 Amazon Linux 2 que se juntou ao AD

Criar um usuário.

Definir uma senha de usuário

Criar um grupo

Adicionar um usuário a um grupo

Descrever usuários e grupos.

Remover um usuário de um grupo.

Excluem um usuário.

Excluir um grupo

nota

Os componentes a seguir devem ser alterados.

nota

Os componentes a seguir devem ser alterados.

nota

Os componentes a seguir devem ser alterados.

Na sua máquina local, exclua o cluster.

Verifique o progresso do cluster que está sendo excluído.

Excluir os recursos do Active Directory

Excluir a instância do EC2.

Excluir a zona hospedada.

Exclui o receptor do LB.

Excluir um grupo de destino.

Excluir o balanceador de carga.

Excluir a política que o cluster usa para ler o certificado do Secrets Manager.

Excluir o segredo que contém o certificado de domínio.

Excluir o certificado do ACM.

Excluir os recursos do Active Directory (AD).

Conecte-se à sua instância e entre no realm do AD como `admin`.

Substitua a senha do administrador pela sua senha `admin`.

Crie um arquivo chamado `recordset-change.json` com o conteúdo a seguir. O `HostedZoneId` é o ID de zona hospedada canônica do balanceador de carga.

Crie um documento de política `policy.json` com o conteúdo a seguir.

Crie um documento de política chamado `policy.json` com o conteúdo a seguir.