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.
# Création de l'infrastructure AD
Choisissez l'onglet *Automatisé* pour créer l'infrastructure Active Directory (AD) à l'aide d'un modèle de création CloudFormation rapide.
Choisissez l'onglet *Manuel* pour créer manuellement l'infrastructure AD.
## Automatisé
1. Connectez-vous au AWS Management Console.
1. Ouvrez [CloudFormation Quick Create (région us-east-1](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-ad&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/ad-integration.yaml)) 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 Amazon EC2 jointe à l'AD que vous pouvez utiliser pour gérer l'annuaire.
1. 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 plus tard dans ce didacticiel.
1. Pour **DomainName**, entrez **corp.example.com**.
1. Pour **Keypair**, entrez le nom d'une paire de clés Amazon EC2.
1. Cochez les cases correspondant à chacune des fonctionnalités d'accès au bas de la page.
1. Sélectionnez **Créer la pile**.
1. Une fois que la CloudFormation pile a atteint son `CREATE_COMPLETE` état, choisissez l'onglet **Sorties** de la pile. Notez les noms des ressources de sortie et les IDs raisons pour lesquelles 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 le AWS Management Console.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/ad-cfn.png)
1. Pour terminer les exercices[(Facultatif) Gérer les utilisateurs et les groupes AD](tutorials_05_multi-user-ad-step2.md), 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.
1. Continuez sur [(Facultatif) Gérer les utilisateurs et les groupes AD](tutorials_05_multi-user-ad-step2.md) ou[Créer le cluster](tutorials_05_multi-user-ad-step3.md).
## Manuelle
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
### Créez l'AD
**Note**
Le répertoire et le nom de domaine sont`corp.example.com`. Le nom abrégé est`CORP`.
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 des ressources de sortie et IDs. Vous les utiliserez ultérieurement.
Une fois le script terminé, passez à l'étape suivante.
### Création d'une instance Amazon EC2
------
#### [ New Amazon EC2 console ]
1. Connectez-vous au AWS Management Console.
1. Si aucun rôle n'est associé aux politiques répertoriées à l'étape 4 ci-jointe, ouvrez la console IAM à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse. Sinon, passez à l'étape 5.
1. 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"
}
]
}
```
1. Créez un rôle IAM avec les politiques suivantes associées.
+ AWS politique gérée [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS politique gérée [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword politique
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le tableau de **bord Amazon EC2**, choisissez **Launch** Instance.
1. Dans **Images d'applications et de systèmes d'exploitation**, sélectionnez une AMI Amazon Linux 2 récente.
1. Pour **Type d'instance**, choisissez t2.micro.
1. Pour **Key pair**, choisissez une paire de clés.
1. Sous **Paramètres réseau**, choisissez **Modifier**.
1. Pour **VPC**, sélectionnez le répertoire VPC.
1. Faites défiler l'écran vers le bas et sélectionnez **Détails avancés**.
1. Dans **Détails avancés**, **Répertoire des jointures de domaines**, sélectionnez**corp.example.com**.
1. 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.
1. Dans **Résumé**, choisissez **Launch instance**.
1. Notez l'ID de l'instance (par exemple, i-1234567890abcdef0) et attendez que le lancement de l'instance soit terminé.
1. Une fois l'instance lancée, passez à l'étape suivante.
------
#### [ Old Amazon EC2 console ]
1. Connectez-vous au AWS Management Console.
1. Si aucun rôle n'est associé aux politiques répertoriées à l'étape 4 ci-jointe, ouvrez la console IAM à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse. Sinon, passez à l'étape 5.
1. 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"
}
]
}
```
1. Créez un rôle IAM avec les politiques suivantes associées.
+ AWS politique gérée [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS politique gérée [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ Stratégie ResetUserPassword
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le tableau de **bord Amazon EC2**, choisissez **Launch** Instance.
1. Dans **Images d'applications et de systèmes d'exploitation**, sélectionnez une AMI Amazon Linux 2 récente.
1. Concernant l'option **Instance type (Type d'instance)**, choisissez t2.micro.
1. Pour **Key pair**, choisissez une paire de clés.
1. Dans **Paramètres réseau**, choisissez **Modifier**.
1. Dans **Paramètres réseau**, **VPC**, sélectionnez le répertoire VPC.
1. Faites défiler l'écran vers le bas et sélectionnez **Détails avancés**.
1. Dans **Détails avancés**, **Répertoire des jointures de domaines**, sélectionnez**corp.example.com**.
1. 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.
1. Dans **Résumé**, choisissez **Launch instance**.
1. Notez l'ID de l'instance (par exemple,i-1234567890abcdef0) et attendez que le lancement de l'instance soit terminé.
1. Une fois l'instance lancée, passez à l'étape suivante.
------
### Joignez votre instance à l'AD
1.
**Connectez-vous à votre instance et rejoignez le domaine AD en tant que`admin`.**
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
```
1.
**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
```
1.
**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.
### Ajouter des utilisateurs à l'AD
1.
**Créez le ReadOnlyUser et un utilisateur supplémentaire.**
Dans cette étape, vous utiliserez les outils [adcli](https://www.mankier.com/package/adcli) et [openldap-clients](https://www.mankier.com/package/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
```
1. **Vérifiez que les utilisateurs ont été 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 le`ad-cli`, l'utilisateur est désactivé.
1.
****Réinitialisez et activez les mots de passe utilisateur depuis votre ordinateur local :****
Déconnectez-vous de votre instance Amazon EC2.
**Note**
`ro-p@ssw0rd`est le mot de passe de`ReadOnlyUser`, extrait de AWS Secrets Manager.
`user-p@ssw0rd`est le mot de passe d'un utilisateur du cluster fourni lorsque vous vous connectez (`ssh`) au cluster.
`directory-id`Il 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"
```
1. **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
```
### Configuration de LDAPS avec vérification des certificats (recommandée)
Prenez note de la ressource IDs. 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
```
1.
**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"
}
```
1. Ajoutez la politique suivante au rôle IAM que vous avez créé pour joindre l'instance Amazon EC2 au domaine AD.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**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"
}
```
1.
**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"
}
]
}
```
1.
**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"
}
]
}
```
1.
**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
```
1.
**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"
}
]
}
}
]
}
]
}
```
1.
**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"
}
}
```
1.
**Créez un fichier nommé `recordset-change.json` avec le contenu suivant. `HostedZoneId`est 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
}
}
}
]
}
```
1.
**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"
}
}
```
1.
**Créez un document de politique `policy.json` avec le contenu suivant.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**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"
}
}
```
1. Continuez à suivre les étapes indiquées dans [(Facultatif) Gérer les utilisateurs et les groupes AD](tutorials_05_multi-user-ad-step2.md) ou[Créer le cluster](tutorials_05_multi-user-ad-step3.md).