Crie a infraestrutura do AD

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

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

Faça login no Console de gerenciamento da AWS.
Abra a CloudFormation Criação Rápida (região us-east-1) para criar os seguintes recursos no console: CloudFormation
- Uma VPC com duas sub-redes e roteamento para acesso público, se nenhuma VPC for especificada.
- Um AWS Managed Microsoft AD.
- Uma EC2 instância da Amazon 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 de um par de EC2 chaves da Amazon.
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 dos recursos de saída e IDs 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) 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) Gerenciar usuários e grupos do AD ou 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 local. Região da AWS 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 dos recursos de saída IDs e. Você vai usá-los em etapas subsequentes.

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

New Amazon EC2 console

Faça login no Console de gerenciamento da AWS.
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 5.

Crie a ResetUserPassword política, substituindo o conteúdo destacado em vermelho por seu Região da AWS ID, 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.
- AWS política gerenciada Amazon SSMManaged InstanceCore
- AWS política gerenciada Amazon SSMDirectory ServiceAccess
- ResetUserPassword política
Abra o EC2 console da Amazon em https://console.aws.amazon.com/ec2/.
No EC2 painel da Amazon, escolha Launch Instance.
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 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.

Old Amazon EC2 console

Faça login no Console de gerenciamento da AWS.
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 5.

Crie a política ResetUserPassword. Substitua o conteúdo destacado em vermelho por sua Região da AWS Conta da AWS ID, ID e 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.
- AWS política gerenciada Amazon SSMManaged InstanceCore
- AWS política gerenciada Amazon SSMDirectory ServiceAccess
- Política ResetUserPassword
Abra o EC2 console da Amazon em https://console.aws.amazon.com/ec2/.
No EC2 painel da Amazon, escolha Launch Instance.
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 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 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:

Saia da sua EC2 instância da Amazon.

nota

ro-p@ssw0rdé a senha deReadOnlyUser, 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 AWS ParallelCluster usado 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 o recurso IDs. 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 política a seguir à função do IAM que você criou para unir a EC2 instância da Amazon 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.

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) Gerenciar usuários e grupos do AD ou Criar um cluster.

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

Integração do Active Directory

(Opcional) Gerenciar usuários e grupos do AD

Crie a infraestrutura do AD

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.

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.