Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Crea l'infrastruttura AD
Scegli la scheda *Automatizzata* per creare l'infrastruttura Active Directory (AD) con un modello di creazione CloudFormation rapida.
Scegli la scheda *Manuale* per creare manualmente l'infrastruttura AD.
## Automatizzata
1. Accedi alla Console di gestione AWS.
1. Apri [CloudFormation Quick Create (region 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)) per creare le seguenti risorse nella console: CloudFormation
+ Un VPC con due sottoreti e routing per l'accesso pubblico, se non viene specificato alcun VPC.
+ Un AWS Managed Microsoft AD.
+ Un'istanza Amazon EC2 aggiunta all'AD che puoi utilizzare per gestire la directory.
1. Nella sezione **Parametri della pagina **Quick create stack**, inserisci le password per i seguenti parametri**:
+ **AdminPassword**
+ **ReadOnlyPassword**
+ **UserPassword**
Prendi nota delle password. Le userai più avanti in questo tutorial.
1. In **DomainName**, immetti **corp.example.com**.
1. Per **Keypair**, inserisci il nome di una coppia di chiavi Amazon EC2.
1. Seleziona le caselle per confermare ciascuna delle funzionalità di accesso nella parte inferiore della pagina.
1. Seleziona **Crea stack**.
1. Dopo che lo CloudFormation stack ha raggiunto lo `CREATE_COMPLETE` stato, scegli la scheda **Output** dello stack. Prendi nota dei nomi delle risorse di output e IDs perché devi usarli nei passaggi successivi. Gli output forniscono le informazioni necessarie per creare il cluster.
![\[Un diagramma che mostra gli output dello stack creati in. Console di gestione AWS\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/ad-cfn.png)
1. Per completare gli esercizi[(Facoltativo) Gestisci utenti e gruppi AD](tutorials_05_multi-user-ad-step2.md), è necessario l'ID della directory. Scegli **Risorse** e scorri verso il basso per prendere nota dell'ID della directory.
1. Continua su [(Facoltativo) Gestisci utenti e gruppi AD](tutorials_05_multi-user-ad-step2.md) o[Creazione del cluster](tutorials_05_multi-user-ad-step3.md).
## Manuale
Crea un VPC per il servizio di directory con due sottoreti in diverse zone di disponibilità e un. AWS Managed Microsoft AD
### Crea l'AD
**Nota**
La directory e il nome di dominio sono`corp.example.com`. Il nome breve è`CORP`.
Cambia la `Admin` password nello script.
La creazione di Active Directory (AD) richiede almeno 15 minuti.
Usa il seguente script Python per creare il VPC, le sottoreti e le risorse AD nel tuo locale. Regione AWS Salva questo file con nome ed eseguilo`ad.py`.
```
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})
```
Di seguito è riportato un esempio di output dallo 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"
}
```
Prendi nota dei nomi delle risorse di output e IDs. Li usi nei passaggi successivi.
Una volta completato lo script, vai al passaggio successivo.
### Creazione di un'istanza Amazon EC2
------
#### [ New Amazon EC2 console ]
1. Accedi alla Console di gestione AWS.
1. Se non hai un ruolo con le politiche elencate nel passaggio 4 allegato, apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Altrimenti, vai al passaggio 5.
1. Crea la `ResetUserPassword` policy, sostituendo il contenuto evidenziato in rosso con il tuo Regione AWS ID, ID account e ID di directory dall'output dello script che hai eseguito per creare l'AD.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Crea un ruolo IAM con le seguenti politiche allegate.
+ AWS politica gestita [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS politica gestita [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword politica
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nella **dashboard di Amazon EC2**, scegli **Launch** Instance.
1. In **Immagini dell'applicazione e del sistema operativo**, seleziona un'AMI Amazon Linux 2 recente.
1. Per **tipo di esempio**, scegli t2.micro.
1. Per **Coppia di chiavi**, scegli una coppia di chiavi.
1. Per **Impostazioni di rete**, scegli **Modifica**.
1. Per **VPC**, seleziona la directory VPC.
1. Scorri verso il basso e seleziona Dettagli **avanzati**.
1. In **Dettagli avanzati**, **Domain join directory**, scegli**corp.example.com**.
1. Per il **profilo IAM Instance**, scegli il ruolo che hai creato nella fase 1 o un ruolo con le policy elencate nel passaggio 4 allegate.
1. In **Riepilogo** scegli **Launch instance**.
1. Prendi nota dell'ID dell'istanza (ad esempio, i-1234567890abcdef0) e attendi che l'istanza finisca di essere avviata.
1. Dopo l'avvio dell'istanza, procedi con il passaggio successivo.
------
#### [ Old Amazon EC2 console ]
1. Accedi alla Console di gestione AWS.
1. Se non ricopri un ruolo con le politiche elencate nel passaggio 4 allegato, apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Altrimenti, vai al passaggio 5.
1. Crea la `ResetUserPassword` politica. Sostituisci il contenuto evidenziato in rosso con il tuo Regione AWS Account AWS ID, ID e l'ID di directory dall'output dello script che hai eseguito per creare Active Directory (AD).
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Crea un ruolo IAM con le seguenti politiche allegate.
+ AWS politica gestita [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS politica gestita [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ Policy ResetUserPassword
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nella **dashboard di Amazon EC2**, scegli **Launch** Instance.
1. In **Immagini dell'applicazione e del sistema operativo**, seleziona un'AMI Amazon Linux 2 recente.
1. In **Instance type (Tipo di istanza)** selezionare t2.micro.
1. Per **Coppia di chiavi**, scegli una coppia di chiavi.
1. In **Impostazioni di rete** scegli **Modifica**.
1. In **Impostazioni di rete**, **VPC**, seleziona la directory VPC.
1. Scorri verso il basso e seleziona Dettagli **avanzati**.
1. In **Dettagli avanzati**, **Domain join directory**, scegli**corp.example.com**.
1. In **Dettagli avanzati**, **Profilo dell'istanza**, scegli il ruolo creato nel passaggio 1 o un ruolo con le politiche elencate nel passaggio 4 allegate.
1. In **Riepilogo** scegli **Launch instance**.
1. Prendi nota dell'ID dell'istanza (ad esempioi-1234567890abcdef0) e attendi che l'istanza finisca di essere avviata.
1. Dopo l'avvio dell'istanza, vai al passaggio successivo.
------
### Unisci la tua istanza all'AD
1.
**Connettiti alla tua istanza e unisciti al regno AD come`admin`.**
Esegui i seguenti comandi per connetterti all'istanza.
```
$ 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.
**Installa il software necessario ed entra a far parte del regno.**
```
$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
```
1.
**Sostituisci la password dell'amministratore con la tua `admin` password.**
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
```
Se la procedura precedente ha avuto successo, sei entrato a far parte del regno e puoi procedere al passaggio successivo.
### Aggiungi utenti all'AD
1.
**Crea il ReadOnlyUser e un altro utente.**
In questo passaggio, si utilizzano gli strumenti [adcli](https://www.mankier.com/package/adcli) e [openldap-clients installati](https://www.mankier.com/package/openldap-clients) in un passaggio precedente.
```
$ 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. **Verifica che gli utenti siano stati creati:**
Gli indirizzi IP DNS della directory sono output dello 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"
```
Per impostazione predefinita, quando si crea un utente con`ad-cli`, l'utente è disabilitato.
1.
****Reimposta e attiva le password degli utenti dal computer locale:****
Esci dalla tua istanza Amazon EC2.
**Nota**
`ro-p@ssw0rd`è la password di`ReadOnlyUser`, recuperata da. Gestione dei segreti AWS
`user-p@ssw0rd`è la password di un utente del cluster fornita quando ci si connette (`ssh`) al cluster.
`directory-id`È un output dello 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. **Aggiungi la password a un segreto di Secrets Manager.**
Ora che hai creato `ReadOnlyUser` e impostato la password, memorizzala in un luogo segreto da AWS ParallelCluster utilizzare per la convalida degli accessi.
Usa Secrets Manager per creare un nuovo segreto che contenga la password `ReadOnlyUser` come valore. Il formato del valore segreto deve essere solo testo semplice (non in formato JSON). Prendi nota dell'ARN segreto per le fasi future.
```
$ 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
```
### Configurazione LDAPS con verifica del certificato (consigliata)
Prendi nota della risorsa IDs. Li usi nei passaggi successivi.
1.
**Genera un certificato di dominio, 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
```
1.
**Archivia il certificato in Secrets Manager per renderlo recuperabile dall'interno del cluster in un secondo momento.**
```
$ 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. Aggiungi la seguente policy al ruolo IAM che hai creato per aggiungere l'istanza Amazon EC2 al dominio AD.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**Importa il certificato in 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.
**Crea e posiziona il load balancer davanti agli endpoint di 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.
**Crea il gruppo target destinato agli endpoint di 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.
**Registra gli endpoint Active Directory (AD) nel gruppo target.**
```
$ 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.
**Crea il listener LB con il certificato.**
```
$ 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.
**Crea la zona ospitata per rendere il dominio individuabile all'interno del VPC del 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.
**Crea un file denominato `recordset-change.json` con il seguente contenuto. `HostedZoneId`è l'ID canonico della zona ospitata del sistema di bilanciamento del carico.**
```
{
"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.
**Inviate la modifica del recordset alla zona ospitata, questa volta utilizzando l'ID della zona ospitata.**
```
$ 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.
**Create un documento di policy `policy.json` con il seguente contenuto.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**Create un documento di policy denominato `policy.json` con il seguente contenuto.**
```
$ 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. Continua a seguire i passaggi indicati in [(Facoltativo) Gestisci utenti e gruppi AD](tutorials_05_multi-user-ad-step2.md) o[Creazione del cluster](tutorials_05_multi-user-ad-step3.md).