Intégration d'Active Directory - AWS ParallelCluster

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Intégration d'Active Directory

Dans ce didacticiel, vous allez créer un environnement multi-utilisateurs. Cet environnement inclut un AWS ParallelCluster qui est intégré à un AWS Managed Microsoft AD (Active Directory) àcorp.example.com. Vous configurez un Admin utilisateur pour gérer le répertoire, un ReadOnly utilisateur pour lire le répertoire et un user000 utilisateur pour se connecter au cluster. Vous pouvez utiliser le chemin automatique ou le chemin manuel pour créer les ressources réseau, un Active Directory (AD) et l'instance EC2 que vous utilisez pour configurer l'AD. Quel que soit le chemin, l'infrastructure que vous créez est préconfigurée pour s'intégrer à AWS ParallelCluster l'aide de l'une des méthodes suivantes :

  • LDAPS avec vérification des certificats (recommandé comme option la plus sûre)

  • LDAPS sans vérification du certificat

  • LDAP

Le protocole LDAP en lui-même ne fournit pas de chiffrement. Pour garantir la transmission sécurisée d'informations potentiellement sensibles, nous vous recommandons vivement d'utiliser LDAPS (LDAP over TLS/SSL) pour les clusters intégrés à ADs. Pour plus d'informations, voir Activer le protocole LDAPS côté serveur à l'aide du AWS Directory Service guide d'AWS Managed Microsoft ADadministration.

Après avoir créé ces ressources, configurez et créez votre cluster intégré à votre Active Directory (AD). Une fois le cluster créé, connectez-vous en tant qu'utilisateur que vous avez créé. Pour plus d'informations sur la configuration que vous créez dans ce didacticiel, consultez Accès de plusieurs utilisateurs aux clusters la section relative à la DirectoryServiceconfiguration.

Ce didacticiel explique comment créer un environnement prenant en charge l'accès de plusieurs utilisateurs aux clusters. Ce didacticiel n'explique pas comment créer et utiliser un AWS Directory Service AD. Les étapes que vous suivez pour configurer un AWS Managed Microsoft AD dans ce didacticiel sont fournies à des fins de test uniquement. Ils ne sont pas fournis pour remplacer la documentation officielle et les meilleures pratiques que vous pouvez trouver sur AWS Managed Microsoft ADSimple AD dans le Guide d'AWS Directory Serviceadministration.

Note

Les mots de passe des utilisateurs de l'annuaire expirent conformément aux définitions des propriétés de la politique de mot de passe d'annuaire. Pour plus d'informations, consultez la section Paramètres de stratégie pris en charge. Pour réinitialiser les mots de passe des annuaires avecAWS ParallelCluster, voirComment réinitialiser le mot de passe d'un utilisateur et les mots de passe expirés.

Note

Les adresses IP du contrôleur de domaine de l'annuaire peuvent changer en raison des modifications du contrôleur de domaine et de la maintenance de l'annuaire. Si vous avez choisi la méthode de création rapide automatisée pour créer l'infrastructure d'annuaire, vous devez aligner manuellement l'équilibreur de charge devant les contrôleurs d'annuaire lorsque les adresses IP des répertoires changent. Si vous utilisez la méthode de création rapide, les adresses IP du répertoire ne sont pas automatiquement alignées avec les équilibreurs de charge.

Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour en savoir plus, consultez AWSservices utilisés par AWS ParallelCluster.

L'AWS ParallelClusterinterface utilisateur repose sur une architecture sans serveur et vous pouvez l'utiliser dans la catégorie AWS Free Tier dans la plupart des cas. Pour en savoir plus, consultez AWS ParallelClusterCoûts d'interface utilisateur.

Prérequis

Au cours du didacticiel, remplacezinputs highlighted in red, par exemple region-id etd-abcdef01234567890, par vos propres noms et identifiants. Remplacez 0123456789012 par votre Compte AWS numéro.

Choisissez l'onglet Automatisé pour créer l'infrastructure Active Directory (AD) à l'aide d'un modèle de création AWS CloudFormation rapide.

Choisissez l'onglet Manuel pour créer manuellement l'infrastructure AD.

  1. Connectez-vous à la AWS Management Console.

  2. Ouvrez CloudFormation Quick Create (region us-east-1) pour créer les ressources suivantes dans la console : CloudFormation

    • Un VPC avec deux sous-réseaux et un routage pour un accès public, si aucun VPC n'est spécifié.

    • Un AWS Managed Microsoft AD.

    • Une instance EC2 jointe à l'AD que vous pouvez utiliser pour gérer le répertoire.

  3. Dans la section Paramètres de la page de création rapide d'une pile, entrez des mots de passe pour les paramètres suivants :

    • AdminPassword

    • ReadOnlyPassword

    • UserPassword

    Prenez note des mots de passe. Vous les utiliserez ultérieurement dans ce didacticiel.

  4. Pour DomainName, entrez corp.example.com.

  5. Pour Keypair, entrez le nom d'une paire de clés EC2.

  6. Cochez les cases correspondant à chacune des fonctionnalités d'accès au bas de la page.

  7. Sélectionnez Créer la pile.

  8. Une fois que la CloudFormation pile a atteint son CREATE_COMPLETE état, choisissez l'onglet Sorties de la pile. Notez les noms et les identifiants des ressources de sortie, car vous devrez les utiliser ultérieurement. Les sorties fournissent les informations nécessaires à la création du cluster.

    Un diagramme qui montre les sorties de pile créées dans leAWS Management Console.

  9. Pour terminer les exercices(Facultatif) Étape 2 : Gérer les utilisateurs et les groupes AD, vous avez besoin de l'ID du répertoire. Choisissez Ressources et faites défiler l'écran vers le bas pour prendre note de l'ID du répertoire.

  10. Continuez sur (Facultatif) Étape 2 : Gérer les utilisateurs et les groupes AD ouÉtape 3 : Création du cluster.

Créez un VPC pour le service d'annuaire avec deux sous-réseaux dans différentes zones de disponibilité et un. AWS Managed Microsoft AD

Note

  • Le répertoire et le nom de domaine sontcorp.example.com. Le nom abrégé estCORP.

  • Modifiez le Admin mot de passe dans le script.

  • La création de l'Active Directory (AD) prend au moins 15 minutes.

Utilisez le script Python suivant pour créer le VPC, les sous-réseaux et les ressources AD dans votre environnement local. Région AWS Enregistrez ce fichier sous ad.py et exécutez-le.

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})

Voici un exemple de sortie du script 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"
}

Notez les noms et les identifiants des ressources de sortie. Vous les utiliserez ultérieurement.

Une fois le script terminé, passez à l'étape suivante.

New EC2 console

  1. Connectez-vous à la AWS Management Console.

  2. Si aucun rôle n'est associé aux politiques répertoriées à l'étape 4 ci-jointe, ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/. Sinon, passez à l'étape 5.

  3. Créez la ResetUserPassword politique en remplaçant le contenu surligné en rouge par votre Région AWS identifiant, votre identifiant de compte et l'identifiant du répertoire à partir de la sortie du script que vous avez exécuté pour créer l'AD.

    ResetUserPassword

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

  4. Créez un rôle IAM avec les politiques suivantes associées.

  5. Ouvrez la console Amazon EC2 à l'adresse https://console.aws.amazon.com/ec2/.

  6. Dans le tableau de bord EC2, choisissez Launch Instance.

  7. Dans Images d'applications et de systèmes d'exploitation, sélectionnez une AMI Amazon Linux 2 récente.

  8. Pour Type d'instance, choisissez t2.micro.

  9. Pour Key pair, choisissez une paire de clés.

  10. Sous Paramètres réseau, choisissez Modifier.

  11. Pour VPC, sélectionnez le répertoire VPC.

  12. Faites défiler l'écran vers le bas et sélectionnez Détails avancés.

  13. Dans Détails avancés, Répertoire des jointures de domaines, sélectionnezcorp.example.com.

  14. Pour le profil d'instance IAM, choisissez le rôle que vous avez créé à l'étape 1 ou un rôle dont les politiques sont répertoriées à l'étape 4 ci-jointes.

  15. Dans Résumé, choisissez Launch instance.

  16. Notez l'ID de l'instance (par exemple, i-1234567890abcdef0) et attendez que le lancement de l'instance soit terminé.

  17. Une fois l'instance lancée, passez à l'étape suivante.

Old EC2 console

  1. Connectez-vous à la AWS Management Console.

  2. Si aucun rôle n'est associé aux politiques répertoriées à l'étape 4 ci-jointe, ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/. Sinon, passez à l'étape 5.

  3. Créez la ResetUserPassword politique. Remplacez le contenu surligné en rouge par votre Région AWS Compte AWS identifiant, votre identifiant et l'identifiant du répertoire figurant dans le résultat du script que vous avez exécuté pour créer l'Active Directory (AD).

    ResetUserPassword

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

  4. Créez un rôle IAM avec les politiques suivantes associées.

  5. Ouvrez la console Amazon EC2 à l'adresse https://console.aws.amazon.com/ec2/.

  6. Dans le tableau de bord EC2, choisissez Launch Instance.

  7. Dans Images d'applications et de systèmes d'exploitation, sélectionnez une AMI Amazon Linux 2 récente.

  8. Concernant l'option Instance type (Type d'instance), choisissez t2.micro.

  9. Pour Key pair, choisissez une paire de clés.

  10. Dans Paramètres réseau, choisissez Modifier.

  11. Dans Paramètres réseau, VPC, sélectionnez le répertoire VPC.

  12. Faites défiler l'écran vers le bas et sélectionnez Détails avancés.

  13. Dans Détails avancés, Répertoire des jointures de domaines, sélectionnezcorp.example.com.

  14. Dans Détails avancés, Profil d'instance, choisissez le rôle que vous avez créé à l'étape 1 ou un rôle auquel sont jointes les politiques répertoriées à l'étape 4.

  15. Dans Résumé, choisissez Launch instance.

  16. Notez l'ID de l'instance (par exemple,i-1234567890abcdef0) et attendez que le lancement de l'instance soit terminé.

  17. Une fois l'instance lancée, passez à l'étape suivante.

  1. Connectez-vous à votre instance et rejoignez le domaine AD en tant queadmin.

    Exécutez les commandes suivantes pour vous connecter à l'instance.

    $ 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
  2. Installez le logiciel nécessaire et rejoignez le royaume.
    $ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
  3. Remplacez le mot de passe administrateur par votre admin mot de passe.
    $ ADMIN_PW="asdfASDF1234"
    $ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:

    Si la procédure précédente a réussi, vous êtes rattaché au royaume et pouvez passer à l'étape suivante.

  1. Créez le ReadOnlyUser et un utilisateur supplémentaire.

    Dans cette étape, vous utilisez les outils adcli et openldap-clients que vous avez installés lors d'une étape précédente.

    $ 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

  2. Vérifiez que les utilisateurs sont créés :

    Les adresses IP DNS du répertoire sont des sorties du 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"

    Par défaut, lorsque vous créez un utilisateur avec lead-cli, l'utilisateur est désactivé.

  3. Réinitialisez et activez les mots de passe utilisateur depuis votre ordinateur local :

    Déconnectez-vous de votre instance EC2.

    Note

    • ro-p@ssw0rdest le mot de passe deReadOnlyUser, extrait deAWS Secrets Manager.

    • user-p@ssw0rdest le mot de passe d'un utilisateur du cluster fourni lorsque vous vous connectez (ssh) au cluster.

    directory-idIl s'agit d'une sortie du 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"

  4. Ajoutez le mot de passe à un secret du Gestionnaire de Secrets.

    Maintenant que vous avez créé ReadOnlyUser et défini le mot de passe, stockez-le dans un secret qui AWS ParallelCluster servira à valider les connexions.

    Utilisez Secrets Manager pour créer un nouveau secret contenant le mot de passe correspondant ReadOnlyUser à la valeur. Le format de la valeur secrète doit être uniquement en texte brut (pas au format JSON). Prenez note de l'ARN secret pour les étapes futures.

    $ 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

Notez les identifiants des ressources. Vous les utiliserez par étapes ultérieures.

  1. Générez un certificat de domaine, localement.
    $ 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
  2. Stockez le certificat dans Secrets Manager pour qu'il puisse être récupéré ultérieurement dans le cluster.
    $ 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"
}

  3. Ajoutez la politique suivante au rôle IAM que vous avez créé pour joindre l'instance EC2 au domaine AD.

    PutDomainCertificateSecrets

    {
    "Statement": [
        {
            "Action": [
                "secretsmanager:PutSecretValue"
            ],
            "Resource": [
                "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
            ],
            "Effect": "Allow"
        }
    ]
}
  4. Importez le certificat dans 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"
}
  5. Créez et l'équilibreur de charge placé devant les points de terminaison 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"
    }   
  ]
}
  6. Créez le groupe cible qui cible les points de terminaison 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"
    }
  ]
}
  7. Enregistrez les points de terminaison Active Directory (AD) dans le groupe cible.
    $ 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
  8. Créez l'écouteur LB avec le certificat.
    $ 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"
              }
            ]
          }
        }
      ]
    }
  ]
}
  9. Créez la zone hébergée pour rendre le domaine détectable dans le VPC du 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"
  }
}
  10. Créez un fichier nommé recordset-change.json avec le contenu suivant. HostedZoneIdest l'ID de zone hébergée canonique de l'équilibreur de charge.
    {
  "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
        }
      }
    }
  ]
}
  11. Soumettez la modification du jeu d'enregistrements à la zone hébergée, cette fois en utilisant l'ID de zone hébergée.
    $ 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"
  }
}
  12. Créez un document de politique policy.json avec le contenu suivant.
    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "secretsmanager:GetSecretValue"
      ],
      "Resource": [
        "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-abc123"
      ],
      "Effect": "Allow"
    }
  ]
}
  13. Créez un document de politique nommé policy.json avec le contenu suivant.
    $ 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"
  }
}
  14. Continuez à suivre les étapes indiquées dans (Facultatif) Étape 2 : Gérer les utilisateurs et les groupes AD ouÉtape 3 : Création du cluster.

Au cours de cette étape, vous gérez les utilisateurs et les groupes à partir d'une instance Amazon Linux 2 EC2 jointe au domaine Active Delivery (AD).

Si vous avez suivi le chemin automatique, redémarrez et connectez-vous à l'instance jointe à AD créée dans le cadre de l'automatisation.

Si vous avez suivi le chemin manuel, redémarrez et connectez-vous à l'instance que vous avez créée et jointe à AD lors des étapes précédentes.

Au cours de ces étapes, vous utilisez les outils adcli et openldap-clients qui ont été installés dans l'instance lors d'une étape précédente.

Connectez-vous à une instance EC2 jointe au domaine AD

  1. Dans la console EC2, sélectionnez l'instance EC2 sans titre créée lors des étapes précédentes. L'état de l'instance est peut-être Arrêté.

  2. Si l'état de l'instance est Arrêté, choisissez État de l'instance, puis Démarrer l'instance.

  3. Une fois les vérifications d'état terminées, sélectionnez l'instance, puis choisissez Connect and SSH in to the instance.

Gérez les utilisateurs et les groupes lorsque vous êtes connecté à une instance Amazon Linux 2 EC2 qui a rejoint l'AD

Lorsque vous exécutez les adcli commandes avec l' -U "Admin"option, vous êtes invité à saisir le mot de Admin passe AD. Vous incluez le Admin mot de passe AD dans les ldapsearch commandes.

  1. Créez un utilisateur.
    $ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
  2. Définissez un mot de passe utilisateur.
    $ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
  3. Créez un groupe.
    $ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
  4. Ajoutez un utilisateur à un groupe.
    $ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
  5. Décrivez les utilisateurs et les groupes.

    Décrivez tous les utilisateurs.

    $ 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"

    Décrivez un utilisateur spécifique.

    $ 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"

    Décrivez tous les utilisateurs avec un modèle de nom.

    $ 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"

    Décrivez tous les utilisateurs qui font partie d'un groupe spécifique.

    $ 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"

    Décrire tous les groupes

    $ 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"

    Décrire un groupe spécifique

    $ 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"
  6. Supprimer un utilisateur d'un groupe.
    $ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
  7. Supprime un utilisateur.
    $ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
  8. Supprimez un groupe.
    $ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"

Si vous n'avez pas quitté l'instance EC2, faites-le maintenant.

L'environnement est configuré pour créer un cluster capable d'authentifier les utilisateurs auprès d'Active Directory (AD).

Créez une configuration de cluster simple et fournissez les paramètres nécessaires à la connexion à l'AD. Pour plus d’informations, consultez la section DirectoryService.

Choisissez l'une des configurations de cluster suivantes et copiez-la dans un fichier nommé ldaps_config.yamlldaps_nocert_config.yaml, ouldap_config.yaml.

Nous vous recommandons de choisir la configuration LDAPS avec vérification des certificats. Si vous choisissez cette configuration, vous devez également copier le script bootstrap dans un fichier nomméactive-directory.head.post.sh. Vous devez également le stocker dans un compartiment Amazon S3 comme indiqué dans le fichier de configuration.

Note
Les composants suivants doivent être modifiés.

  • KeyName: L'une de vos paires de clés EC2.

  • SubnetId / SubnetIds: l'un des identifiants de sous-réseau fournis dans la sortie de la pile de création CloudFormation rapide (didacticiel automatisé) ou du script python (didacticiel manuel).

  • Region: Région dans laquelle vous avez créé l'infrastructure AD.

  • DomainAddr: Cette adresse IP est l'une des adresses DNS de votre service AD.

  • PasswordSecretArn: le nom de ressource Amazon (ARN) du secret qui contient le mot de passe duDomainReadOnlyUser.

  • BucketName: nom du compartiment contenant le script bootstrap.

  • AdditionalPolicies/Policy: Le nom de ressource Amazon (ARN) de la politique de certification du domaine lu ReadCertExample.

  • CustomActions/OnNodeConfigured/Args: Nom de ressource Amazon (ARN) du secret contenant la politique de certification du domaine.

Pour une meilleure sécurité, nous vous suggérons d'utiliser la AllowedIps configuration HeadNodeSsh//pour limiter l'accès SSH au nœud 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 Bootstrap

Après avoir créé le fichier bootstrap et avant de le télécharger dans votre compartiment S3, exécutez-le chmod +x active-directory.head.post.sh pour donner l'autorisation d'AWS ParallelClusterexécution.

#!/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
Note
Les composants suivants doivent être modifiés.

  • KeyName: L'une de vos paires de clés EC2.

  • SubnetId / SubnetIds: l'un des identifiants de sous-réseau figurant dans la sortie de la pile de création CloudFormation rapide (didacticiel automatisé) ou du script python (didacticiel manuel).

  • Region: Région dans laquelle vous avez créé l'infrastructure AD.

  • DomainAddr: Cette adresse IP est l'une des adresses DNS de votre service AD.

  • PasswordSecretArn: le nom de ressource Amazon (ARN) du secret qui contient le mot de passe duDomainReadOnlyUser.

Pour une meilleure sécurité, nous vous suggérons d'utiliser la AllowedIps configuration HeadNode /Ssh/ pour limiter l'accès SSH au nœud 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
Note
Les composants suivants doivent être modifiés.

  • KeyName: L'une de vos paires de clés EC2.

  • SubnetId / SubnetIds: l'un des identifiants de sous-réseau fournis dans la sortie de la pile de création CloudFormation rapide (didacticiel automatisé) ou du script python (didacticiel manuel).

  • Region: Région dans laquelle vous avez créé l'infrastructure AD.

  • DomainAddr: Cette adresse IP est l'une des adresses DNS de votre service AD.

  • PasswordSecretArn: le nom de ressource Amazon (ARN) du secret qui contient le mot de passe duDomainReadOnlyUser.

Pour une meilleure sécurité, nous vous suggérons d'utiliser la AllowedIps configuration HeadNode /Ssh/ pour limiter l'accès SSH au nœud 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

Créez votre cluster à l'aide de la commande suivante.

$ 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"
  }
}

Vous pouvez déterminer l'état du cluster à l'aide des commandes suivantes.

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

La sortie est la suivante.

"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"

Lorsque le statut atteint"CREATE_COMPLETE", connectez-vous avec le nom d'utilisateur et le mot de passe créés.

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

Vous pouvez vous connecter sans mot de passe en fournissant la SSH clé créée pour le nouvel utilisateur sur/home/user000@HEAD_NODE_IP/.ssh/id_rsa.

Si la ssh commande a réussi, vous vous êtes connecté avec succès au cluster en tant qu'utilisateur authentifié pour utiliser Active Directory (AD).

  1. Depuis votre ordinateur local, supprimez le 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"
  }
}
  2. Vérifiez la progression du cluster en cours de suppression.
    $ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"

    Une fois le cluster supprimé avec succès, passez à l'étape suivante.

Supprimer les ressources Active Directory

  1. Depuis https://console.aws.amazon.com/cloudformation/.

  2. Dans le volet de navigation, choisissez Stack (Piles).

  3. Dans la liste des piles, choisissez la pile AD (par exemple,pcluster-ad).

  4. Sélectionnez Delete (Supprimer).

  1. Supprimez l'instance EC2.

    1. Sur https://console.aws.amazon.com/ec2/, sélectionnez Instances dans le volet de navigation.

    2. Dans la liste des instances, choisissez l'instance que vous avez créée pour ajouter des utilisateurs à l'annuaire.

    3. Choisissez État de l'instance, puis Terminate instance.

  2. Supprimez la zone hébergée.

    1. Créez un recordset-delete.json avec le contenu suivant. Dans cet exemple, HostedZoneId il s'agit de l'ID de zone hébergée canonique de l'équilibreur de charge.

      {
  "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
        }
      }
    }
  ]
}

    2. Soumettez la modification du jeu d'enregistrements à la zone hébergée à l'aide de l'ID de zone hébergée.

      $ 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"
 }
}

    3. Supprimez la zone hébergée.

      $ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
 "ChangeInfo": {
     "Id": "/change/C0468051QFABTVHMDEG9",
     "Status": "PENDING",
     "SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
 }
}
  3. Supprimez l'écouteur LB.
    $ aws elbv2 delete-listener \
  --listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
  4. Supprimez le groupe cible.
    $ aws elbv2 delete-target-group \
  --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
  5. Supprimez l'équilibreur de charge.
    $ aws elbv2 delete-load-balancer \
  --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
  6. Supprimez la politique utilisée par le cluster pour lire le certificat depuis Secrets Manager.
    $ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
  7. Supprimez le secret qui contient le certificat de domaine.
    $ 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"
}
  8. Supprimez le certificat d'ACM.
    $ aws acm delete-certificate \
  --certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
  9. Supprimez les ressources Active Directory (AD).

    1. Obtenez les identifiants de ressources suivants à partir de la sortie du script python ad.py :

      • IDENTIFIANT DE L'ANNONCE

      • ID de sous-réseau AD

      • AJOUTER UN IDENTIFIANT VPC

    2. Supprimez le répertoire en exécutant la commande suivante.

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

    3. Répertoriez les groupes de sécurité du VPC.

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

    4. Supprimez le groupe de sécurité personnalisé.

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

    5. Supprimer les sous-réseaux.

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

    6. Décrivez la passerelle 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": []
    }
  ]  
}

    7. Détachez la passerelle Internet.

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

    8. Supprimez la passerelle Internet.

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

    9. Supprimer le VPC.

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

    10. Supprimez le secret qui contient le ReadOnlyUser mot de passe.

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