Integrazione di Active Directory - AWS ParallelCluster

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à.

Integrazione di Active Directory

In questo tutorial, crei un ambiente multiutente. Questo ambiente include un AWS ParallelCluster file integrato con un AWS Managed Microsoft AD (Active Directory) incorp.example.com. Si configura un Admin utente per gestire la directory, un ReadOnly utente per leggere la directory e un user000 utente per accedere al cluster. Puoi utilizzare il percorso automatico o il percorso manuale per creare le risorse di rete, un'Active Directory (AD) e l'istanza Amazon EC2 che usi per configurare l'AD. Indipendentemente dal percorso, l'infrastruttura creata è preconfigurata per AWS ParallelCluster l'integrazione utilizzando uno dei seguenti metodi:

  • LDAPS con verifica del certificato (consigliato come opzione più sicura)

  • LDAPS senza verifica del certificato

  • LDAP

LDAP di per sé non fornisce la crittografia. Per garantire la trasmissione sicura di informazioni potenzialmente sensibili, consigliamo vivamente di utilizzare LDAPS (LDAP su TLS/SSL) per i cluster integrati con gli annunci pubblicitari. Per ulteriori informazioni, consulta Abilitare l'utilizzo di LDAPS lato server nella Guida all'amministrazione. AWS Managed Microsoft AD AWS Directory Service

Dopo aver creato queste risorse, procedi con la configurazione e la creazione del cluster integrato con Active Directory (AD). Dopo aver creato il cluster, accedi come utente che hai creato. Per ulteriori informazioni sulla configurazione creata in questo tutorial, consulta Accesso di più utenti ai cluster la sezione relativa alla DirectoryServiceconfigurazione.

Questo tutorial spiega come creare un ambiente che supporti l'accesso di più utenti ai cluster. Questo tutorial non spiega come creare e utilizzare un AWS Directory Service AD. I passaggi da seguire per configurarne uno AWS Managed Microsoft AD in questo tutorial sono forniti solo a scopo di test. Non vengono forniti per sostituire la documentazione ufficiale e le best practice disponibili in Simple AD nella AWS Directory Service Administration Guide. AWS Managed Microsoft AD

Nota

Le password degli utenti delle directory scadono in base alle definizioni delle proprietà delle policy relative alle password delle directory. Per ulteriori informazioni, consulta Impostazioni dei criteri supportate. Per reimpostare le password delle directory con AWS ParallelCluster, vedereCome reimpostare la password di un utente e le password scadute.

Nota

Gli indirizzi IP dei controller di dominio delle directory possono cambiare a causa delle modifiche dei controller di dominio e della manutenzione delle directory. Se si è scelto il metodo di creazione rapida automatizzata per creare l'infrastruttura di directory, è necessario allineare manualmente il sistema di bilanciamento del carico davanti ai controller delle directory quando gli indirizzi IP delle directory cambiano. Se si utilizza il metodo di creazione rapida, gli indirizzi IP delle directory non vengono allineati automaticamente ai sistemi di bilanciamento del carico.

Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta AWS servizi usati da AWS ParallelCluster.

L' AWS ParallelCluster interfaccia utente è basata su un'architettura serverless ed è possibile utilizzarla nella categoria AWS Free Tier nella maggior parte dei casi. Per ulteriori informazioni, consulta AWS ParallelClusterCosti dell'interfaccia utente.

Prerequisiti

Durante il tutorial, sostituisciloinputs highlighted in red, ad esempio region-id ed-abcdef01234567890, con i tuoi nomi e ID. 0123456789012Sostituiscilo con il tuo Account AWS numero.

Scegli la scheda Automatizzata per creare l'infrastruttura Active Directory (AD) con un modello di creazione AWS CloudFormation rapida.

Scegli la scheda Manuale per creare manualmente l'infrastruttura AD.

  1. Accedi alla AWS Management Console.

  2. Apri CloudFormation Quick Create (region us-east-1) 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.

  3. 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.

  4. In DomainName, immetti corp.example.com.

  5. Per Keypair, inserisci il nome di una coppia di chiavi Amazon EC2.

  6. Seleziona le caselle per confermare ciascuna delle funzionalità di accesso nella parte inferiore della pagina.

  7. Seleziona Crea stack.

  8. Dopo che lo CloudFormation stack ha raggiunto lo CREATE_COMPLETE stato, scegli la scheda Output dello stack. Prendi nota dei nomi e degli ID delle risorse di output 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. AWS Management Console

  9. Per completare gli esercizi(Facoltativo) Passaggio 2: Gestione degli utenti e dei gruppi AD, è necessario l'ID della directory. Scegli Risorse e scorri verso il basso per prendere nota dell'ID della directory.

  10. Continua su (Facoltativo) Passaggio 2: Gestione degli utenti e dei gruppi AD oFase 3: Creare il cluster.

Crea un VPC per il servizio di directory con due sottoreti in diverse zone di disponibilità e un. AWS Managed Microsoft AD

Nota

  • La directory e il nome di dominio sonocorp.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 eseguiload.py.

import boto3
import time
from pprint import pprint

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

Amazon 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 e degli ID delle risorse di output. Li utilizzerai nei passaggi successivi.

Una volta completato lo script, vai al passaggio successivo.

New Amazon EC2 console

  1. Accedi alla AWS Management Console.

  2. 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/. Altrimenti, vai al passaggio 5.

  3. 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"
        }
    ]
}

  4. Crea un ruolo IAM con le seguenti politiche allegate.

  5. Apri la console Amazon EC2 all'indirizzo https://console.aws.amazon.com/ec2/.

  6. Nella dashboard di Amazon EC2, scegli Launch Instance.

  7. In Immagini dell'applicazione e del sistema operativo, seleziona un'AMI Amazon Linux 2 recente.

  8. Per tipo di esempio, scegli t2.micro.

  9. Per Coppia di chiavi, scegli una coppia di chiavi.

  10. Per Impostazioni di rete, scegli Modifica.

  11. Per VPC, seleziona la directory VPC.

  12. Scorri verso il basso e seleziona Dettagli avanzati.

  13. In Dettagli avanzati, Domain join directory, sceglicorp.example.com.

  14. 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.

  15. In Riepilogo scegli Launch instance.

  16. Prendi nota dell'ID dell'istanza (ad esempio, i-1234567890abcdef0) e attendi che l'istanza finisca di essere avviata.

  17. Dopo l'avvio dell'istanza, procedi con il passaggio successivo.

Old Amazon EC2 console

  1. Accedi alla AWS Management Console.

  2. Se non hai un ruolo nelle policy elencate nel passaggio 4 allegato, apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/. Altrimenti, vai al passaggio 5.

  3. 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"
            }
        ]
     }

  4. Crea un ruolo IAM con le seguenti politiche allegate.

  5. Apri la console Amazon EC2 all'indirizzo https://console.aws.amazon.com/ec2/.

  6. Nella dashboard di Amazon EC2, scegli Launch Instance.

  7. In Immagini dell'applicazione e del sistema operativo, seleziona un'AMI Amazon Linux 2 recente.

  8. In Instance type (Tipo di istanza) selezionare t2.micro.

  9. Per Coppia di chiavi, scegli una coppia di chiavi.

  10. In Impostazioni di rete scegli Modifica.

  11. In Impostazioni di rete, VPC, seleziona la directory VPC.

  12. Scorri verso il basso e seleziona Dettagli avanzati.

  13. In Dettagli avanzati, Domain join directory, sceglicorp.example.com.

  14. In Dettagli avanzati, Profilo dell'istanza, scegli il ruolo creato nel passaggio 1 o un ruolo con le politiche elencate nel passaggio 4 allegate.

  15. In Riepilogo scegli Launch instance.

  16. Prendi nota dell'ID dell'istanza (ad esempioi-1234567890abcdef0) e attendi che l'istanza finisca di essere avviata.

  17. Dopo l'avvio dell'istanza, vai al passaggio successivo.

  1. Connettiti alla tua istanza e unisciti al regno AD comeadmin.

    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
  2. 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
  3. 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.

  1. Crea il ReadOnlyUser e un altro utente.

    In questo passaggio, si utilizzano gli strumenti adcli e openldap-clients installati 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

  2. 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 conad-cli, l'utente è disabilitato.

  3. Reimposta e attiva le password degli utenti dal computer locale:

    Esci dalla tua istanza Amazon EC2.

    Nota

    • ro-p@ssw0rdè la password diReadOnlyUser, recuperata da. AWS Secrets Manager

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

  4. 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 convalidare gli 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

Prendi nota degli ID delle risorse. Li utilizzerai 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
  2. 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"
}

  3. 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"
        }
    ]
}
  4. 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"
}
  5. 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"
    }   
  ]
}
  6. 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"
    }
  ]
}
  7. 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
  8. 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"
              }
            ]
          }
        }
      ]
    }
  ]
}
  9. 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"
  }
}
  10. Crea un file denominato recordset-change.json con il seguente contenuto. HostedZoneIdè l'ID canonico della zona ospitata del load balancer.
    {
  "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. 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"
  }
}
  12. Create un documento di policy policy.json con il seguente contenuto.
    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "secretsmanager:GetSecretValue"
      ],
      "Resource": [
        "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-abc123"
      ],
      "Effect": "Allow"
    }
  ]
}
  13. 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"
  }
}
  14. Continua a seguire i passaggi indicati in (Facoltativo) Passaggio 2: Gestione degli utenti e dei gruppi AD oFase 3: Creare il cluster.

In questa fase, gestisci utenti e gruppi da un'istanza Amazon EC2 Amazon Linux 2 aggiunta al dominio Active Delivery (AD).

Se hai seguito il percorso automatizzato, riavvia e accedi all'istanza unita AD creata come parte dell'automazione.

Se hai seguito il percorso manuale, riavvia e accedi all'istanza che hai creato e che hai aggiunto all'AD nei passaggi precedenti.

In questi passaggi, si utilizzano gli strumenti adcli e openldap-clients installati nell'istanza come parte del passaggio precedente.

Accedi a un'istanza Amazon EC2 che fa parte del dominio AD

  1. Dalla console Amazon EC2, seleziona l'istanza Amazon EC2 senza titolo creata nei passaggi precedenti. Lo stato dell'istanza potrebbe essere Interrotto.

  2. Se lo stato dell'istanza è Interrotto, scegli Stato dell'istanza e quindi Avvia istanza.

  3. Una volta superati i controlli di stato, seleziona l'istanza e scegli Connect e accedi SSH all'istanza.

Gestisci utenti e gruppi quando accedi a un'istanza Amazon EC2 Amazon Linux 2 che fa parte di AD

Quando adcli esegui i comandi con l' -U "Admin"opzione, ti viene richiesto di inserire la password AD. Admin Includi la Admin password AD come parte dei ldapsearch comandi.

  1. Creare un utente.
    $ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
  2. Imposta una password utente.
    $ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
  3. Crea un gruppo.
    $ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
  4. Aggiungi un utente a un gruppo.
    $ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
  5. Descrivi utenti e gruppi.

    Descrivi tutti gli utenti.

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

    Descrivi un utente specifico.

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

    Descrivi tutti gli utenti con uno schema di nomi.

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

    Descrivi tutti gli utenti che fanno parte di un gruppo specifico.

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

    Descrivi tutti i gruppi

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

    Descrivi un gruppo specifico

    $ 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. Rimuovi un utente da un gruppo.
    $ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
  7. Elimina un utente.
    $ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
  8. Eliminare un gruppo.
    $ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"

Se non sei ancora uscito dall'istanza Amazon EC2, fallo ora.

L'ambiente è configurato per creare un cluster in grado di autenticare gli utenti tramite Active Directory (AD).

Crea una semplice configurazione del cluster e fornisci le impostazioni relative alla connessione ad AD. Per ulteriori informazioni, consulta la sezione DirectoryService.

Scegli una delle seguenti configurazioni del cluster e copiala in un file denominato ldaps_config.yamlldaps_nocert_config.yaml, oldap_config.yaml.

Ti consigliamo di scegliere la configurazione LDAPS con verifica del certificato. Se scegli questa configurazione, devi anche copiare lo script di bootstrap in un file denominato. active-directory.head.post.sh Inoltre, è necessario archiviarlo in un bucket Amazon S3 come indicato nel file di configurazione.

Nota
I seguenti componenti devono essere modificati.

  • KeyName: Una delle tue coppie di chiavi Amazon EC2.

  • SubnetId / SubnetIds: Uno degli ID di sottorete forniti nell'output dello stack di creazione CloudFormation rapida (tutorial automatico) o dello script python (tutorial manuale).

  • Region: La regione in cui hai creato l'infrastruttura AD.

  • DomainAddr: Questo indirizzo IP è uno degli indirizzi DNS del servizio AD.

  • PasswordSecretArn: L'Amazon Resource Name (ARN) del segreto che contiene la password per. DomainReadOnlyUser

  • BucketName: il nome del bucket che contiene lo script di bootstrap.

  • AdditionalPolicies/Policy: L'Amazon Resource Name (ARN) della politica di certificazione del dominio di lettura. ReadCertExample

  • CustomActions/OnNodeConfigured/Args: L'Amazon Resource Name (ARN) segreto che contiene la politica di certificazione del dominio.

Per una migliore sicurezza, suggeriamo di utilizzare la AllowedIps configurazioneHeadNode/Ssh/per limitare l'accesso SSH al nodo principale.

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

Dopo aver creato il file bootstrap e prima di caricarlo nel bucket S3, eseguilo per concedere l'autorizzazione chmod +x active-directory.head.post.sh all'esecuzione. AWS ParallelCluster 

#!/bin/bash
set -e

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

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

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

mkdir -p $(dirname $CERTIFICATE_PATH)
aws secretsmanager get-secret-value --region $REGION --secret-id $CERTIFICATE_SECRET_ARN --query SecretString --output text > $CERTIFICATE_PATH
Nota
I seguenti componenti devono essere modificati.

  • KeyName: Una delle tue coppie di chiavi Amazon EC2.

  • SubnetId / SubnetIds: Uno degli ID di sottorete presenti nell'output dello stack di creazione CloudFormation rapida (tutorial automatizzato) o dello script python (tutorial manuale).

  • Region: La regione in cui hai creato l'infrastruttura AD.

  • DomainAddr: Questo indirizzo IP è uno degli indirizzi DNS del servizio AD.

  • PasswordSecretArn: L'Amazon Resource Name (ARN) del segreto che contiene la password per. DomainReadOnlyUser

Per una migliore sicurezza, suggeriamo di utilizzare la AllowedIps configurazione HeadNode /Ssh/ per limitare l'accesso SSH al nodo principale.

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

  • KeyName: Una delle tue coppie di chiavi Amazon EC2.

  • SubnetId / SubnetIds: Uno degli ID di sottorete forniti nell'output dello stack di creazione CloudFormation rapida (tutorial automatico) o dello script python (tutorial manuale).

  • Region: La regione in cui hai creato l'infrastruttura AD.

  • DomainAddr: Questo indirizzo IP è uno degli indirizzi DNS del servizio AD.

  • PasswordSecretArn: L'Amazon Resource Name (ARN) del segreto che contiene la password per. DomainReadOnlyUser

Per una migliore sicurezza, suggeriamo di utilizzare la AllowedIps configurazione HeadNode /Ssh/ per limitare l'accesso SSH al nodo principale.

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

Crea un cluster con il seguente comando.

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

È possibile determinare lo stato del cluster con i seguenti comandi.

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

L'output è il seguente.

"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"

Quando lo stato viene raggiunto"CREATE_COMPLETE", accedi con il nome utente e la password creati.

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

È possibile accedere senza la password fornendo la SSH chiave creata per il nuovo utente all'indirizzo/home/user000@HEAD_NODE_IP/.ssh/id_rsa.

Se il ssh comando ha avuto esito positivo, la connessione al cluster è avvenuta correttamente come utente autenticato per l'utilizzo di Active Directory (AD).

  1. Dal computer locale, elimina il 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. Controlla lo stato di avanzamento del cluster da eliminare.
    $ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"

    Dopo che il cluster è stato eliminato con successo, procedi al passaggio successivo.

Eliminare le risorse di Active Directory

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

  2. Nel riquadro di navigazione selezionare Stacks (Stack).

  3. Dall'elenco degli stack, scegli lo stack AD (ad esempio,pcluster-ad).

  4. Scegli Elimina.

  1. Elimina l'istanza Amazon EC2.

    1. Da https://console.aws.amazon.com/ec2/, scegli Istanze nel riquadro di navigazione.

    2. Dall'elenco delle istanze, scegli l'istanza che hai creato per aggiungere utenti alla directory.

    3. Scegli Stato dell'istanza, quindi Termina istanza.

  2. Elimina la zona ospitata.

    1. Crea un recordset-delete.json file con il seguente contenuto. In questo esempio, HostedZoneId è l'ID canonico della zona ospitata del load balancer.

      {
  "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. Inviate la modifica del recordset alla zona ospitata utilizzando l'ID della zona ospitata.

      $ 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. Eliminare la zona ospitata.

      $ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
 "ChangeInfo": {
     "Id": "/change/C0468051QFABTVHMDEG9",
     "Status": "PENDING",
     "SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
 }
}
  3. Eliminare il listener LB.
    $ aws elbv2 delete-listener \
  --listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
  4. Eliminare il gruppo target.
    $ aws elbv2 delete-target-group \
  --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
  5. Eliminare il sistema di bilanciamento del carico.
    $ aws elbv2 delete-load-balancer \
  --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
  6. Eliminare la politica utilizzata dal cluster per leggere il certificato da Secrets Manager.
    $ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
  7. Elimina il segreto che contiene il certificato di dominio.
    $ 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. Eliminare il certificato da ACM.
    $ aws acm delete-certificate \
  --certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
  9. Eliminare le risorse di Active Directory (AD).

    1. Ottieni i seguenti ID di risorse dall'output dello script ad.py python:

      • E ID

      • ID di sottorete AD

      • E ID VPC

    2. Eliminare la directory eseguendo il comando seguente.

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

    3. Elenca i gruppi di sicurezza nel VPC.

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

    4. Elimina il gruppo di sicurezza personalizzato.

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

    5. Elimina le sottoreti.

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

    6. Descrivi Internet Gateway.

      $ 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. Scollegare il gateway Internet.

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

    8. Eliminare il gateway Internet.

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

    9. Elimina il VPC.

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

    10. Eliminare il segreto che contiene la ReadOnlyUser password.

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