Integración de Active Directory

En este tutorial, se crea un entorno de varios usuarios. Este entorno incluye un AWS ParallelCluster que está integrado con un AWS Managed Microsoft AD (Active Directory) encorp.example.com. Se configura un Admin usuario para que administre el directorio, un ReadOnly usuario para que lea el directorio y un user000 usuario para que inicie sesión en el clúster. Puede usar la ruta automática o la ruta manual para crear los recursos de red, un Active Directory (AD) y la instancia EC2 que utiliza para configurar el AD. Independientemente de la ruta, la infraestructura que cree está preconfigurada para integrarse AWS ParallelCluster mediante uno de los siguientes métodos:

LDAPS con verificación de certificados (se recomienda como la opción más segura)
sobre LDAPS sin verificación de certificados
LDAP

El LDAP por sí solo no proporciona cifrado. Para garantizar la transmisión segura de información potencialmente confidencial, le recomendamos encarecidamente que utilice LDAPS (LDAP sobre TLS/SSL) para los clústeres integrados con los AD. Para obtener más información, consulte Habilitar el uso de LDAPS del lado del servidor en la Guía de administración. AWS Managed Microsoft AD AWS Directory Service

Tras crear estos recursos, proceda a configurar y crear el clúster integrado con su Active Directory (AD). Una vez que se cree el clúster, inicie sesión como el usuario que creó. Para obtener más información sobre la configuración que se crea en este tutorial, consulte Acceso de varios usuarios a los clústeres la sección DirectoryServicede configuración.

En este tutorial se explica cómo crear un entorno que admita el acceso de varios usuarios a los clústeres. En este tutorial no se explica cómo crear y utilizar un AWS Directory Service AD. Los pasos que debe seguir para configurar un AWS Managed Microsoft AD en este tutorial se proporcionan únicamente con fines de prueba. No se proporcionan para reemplazar la documentación oficial y las mejores prácticas que puede encontrar en AWS Managed Microsoft AD Simple AD en la Guía de AWS Directory Service administración.

nota

Las contraseñas de los usuarios de directorios caducan según las definiciones de propiedades de la política de contraseñas de los directorios. Para obtener más información, consulte Supported policy permissions (Permisos de políticas compatibles). Para restablecer las contraseñas de los directorios conAWS ParallelCluster, consulteCómo restablecer una contraseña de usuario y contraseñas caducadas.

nota

Las direcciones IP del controlador de dominio del directorio pueden cambiar debido a los cambios en el controlador de dominio y al mantenimiento del directorio. Si ha elegido el método de creación rápida automática para crear la infraestructura de directorios, debe alinear manualmente el balanceador de cargas frente a los controladores de directorios cuando cambien las direcciones IP del directorio. Si utilizas el método de creación rápida, las direcciones IP del directorio no se alinean automáticamente con los balanceadores de carga.

Al utilizar la interfaz de línea de comandos (CLI) o API de AWS ParallelCluster, solo paga por los recursos de AWS que se crean al crear o actualizar imágenes y clústeres de AWS ParallelCluster. Para más información, consulte Servicios de AWS utilizados por AWS ParallelCluster.

La interfaz de usuario de AWS ParallelCluster se basa en una arquitectura sin servidor y, en la mayoría de los casos, se puede utilizar en la categoría de nivel AWS gratuito. Para más información, consulte Costes de la interfaz de usuario de AWS ParallelCluster.

Requisitos previos

AWS ParallelCluster está instalado.
AWS CLI está instalado y configurado.
Tiene un EC2 key pair.
Tiene un rol de IAM con los permisos necesarios para ejecutar el CLI pcluster.

A medida que avance en el tutorialinputs highlighted in red, sustituya (region-idyd-abcdef01234567890) por sus propios nombres e identificadores. Reemplace 0123456789012 por el ID de su Cuenta de AWS.

Elija la pestaña Automatizado para crear la infraestructura de Active Directory (AD) con una plantilla de creación AWS CloudFormation rápida.

Seleccione la pestaña Manual para crear manualmente la infraestructura de AD.

Inicie sesión en la AWS Management Console.
Abre CloudFormation Quick Create (region us-east-1) para crear los siguientes recursos en la CloudFormation consola:
- Una VPC con dos subredes y enrutamiento para acceso público, si no se especifica ninguna VPC.
- Una AWS Managed Microsoft AD.
- Una instancia de EC2 unida al AD que puede usar para administrar el directorio.
En la sección Parámetros Creación rápida de pila, proporcione valores para los parámetros siguientes:
- AdminPassword
- ReadOnlyPassword
- UserPassword
Anote la contraseña. Los necesitará más adelante en este tutorial.
En DomainName, introduzca corp.example.com
En KeyName, escriba el nombre del par de claves EC2.
Elija las casillas de verificación para confirmar las capacidades de acceso en la parte inferior de la página.
Seleccione Crear pila.
Una vez que la CloudFormation pila haya alcanzado el CREATE_COMPLETE estado, seleccione la pestaña Salidas de la pila. Anote los nombres e ID de los recursos de salida porque necesitará usarlos en pasos posteriores. Los resultados proporcionan la información necesaria para crear el clúster.
Para completar los ejercicios(Opcional) Paso 2: Administrar los usuarios y grupos de AD, necesitará el ID del directorio. Elija Recursos y desplácese hacia abajo para anotar el ID del directorio.
Continúe en (Opcional) Paso 2: Administrar los usuarios y grupos de AD oPaso 1: Crear el clúster.

Los servidores de directorio se crean en dos subredes en dos zonas de disponibilidad diferentes dentro de una VPC.

nota

El directorio y el nombre de dominio soncorp.example.com. El formato del nombre es CORP.
Cambie la Admin contraseña en el script.
La creación de Active Directory (AD) tarda al menos 15 minutos.

Utilice la siguiente secuencia de comandos de Python para crear los recursos de VPC, subredes y AD en su entorno local. Región de AWS Guarda este archivo como ad.py y ejecútalo.


import boto3
import time
from pprint import pprint

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

ec2 = boto3.client("ec2")
ds = boto3.client("ds")
region = boto3.Session().region_name

# Create the VPC, Subnets, IGW, Routes
vpc = ec2.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
vpc_id = vpc["VpcId"]
time.sleep(30)
ec2.create_tags(Resources=[vpc_id], Tags=[{"Key": "Name", "Value": vpc_name}])
subnet1 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.0.0/17", AvailabilityZone=f"{region}a")["Subnet"]
subnet1_id = subnet1["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet1_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet1"}])
ec2.modify_subnet_attribute(SubnetId=subnet1_id, MapPublicIpOnLaunch={"Value": True})
subnet2 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.128.0/17", AvailabilityZone=f"{region}b")["Subnet"]
subnet2_id = subnet2["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet2_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet2"}])
ec2.modify_subnet_attribute(SubnetId=subnet2_id, MapPublicIpOnLaunch={"Value": True})
igw = ec2.create_internet_gateway()["InternetGateway"]
ec2.attach_internet_gateway(InternetGatewayId=igw["InternetGatewayId"], VpcId=vpc_id)
route_table = ec2.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])["RouteTables"][0]
ec2.create_route(RouteTableId=route_table["RouteTableId"], DestinationCidrBlock="0.0.0.0/0", GatewayId=igw["InternetGatewayId"])
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsSupport={"Value": True})
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsHostnames={"Value": True})

# Create the Active Directory
ad = ds.create_microsoft_ad(
    Name=ad_domain,
    Password=admin_password,
    Description="ParallelCluster AD",
    VpcSettings={"VpcId": vpc_id, "SubnetIds": [subnet1_id, subnet2_id]},
    Edition="Standard",
)
directory_id = ad["DirectoryId"]

# Wait for completion
print("Waiting for the directory to be created...")
directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
directory = directories[0]
while directory["Stage"] in {"Requested", "Creating"}:
    time.sleep(3)
    directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
    directory = directories[0]
    
dns_ip_addrs = directory["DnsIpAddrs"]

pprint({"directory_id": directory_id,
        "vpc_id": vpc_id,
        "subnet1_id": subnet1_id,
        "subnet2_id": subnet2_id,
        "dns_ip_addrs": dns_ip_addrs})

A continuación se muestra un ejemplo de salida del comando.


{
  "directory_id": "d-abcdef01234567890",
  "dns_ip_addrs": ["192.0.2.254", "203.0.113.237"],
  "subnet1_id": "subnet-021345abcdef6789",
  "subnet2_id": "subnet-1234567890abcdef0",
  "vpc_id": "vpc-021345abcdef6789"
}

Anote los nombres e ID de los recursos de salida. Los usará en pasos posteriores.

Una vez finalizada la secuencia de comandos, continúe con el siguiente paso.

New EC2 console

Inicie sesión en la AWS Management Console.
Si no tienes un rol con las políticas enumeradas en el paso 4, abre la consola de IAM en https://console.aws.amazon.com/iam/. De lo contrario, vaya al paso 8.

Cree la ResetUserPassword política y sustituya el contenido resaltado en rojo por su Región de AWS ID, ID de cuenta y ID de directorio del resultado del script que ejecutó para crear el AD.

ResetUserPassword


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

Cree un usuario de IAM con la siguiente política asociada:
- AWSpolítica gestionada: AmazonSSM. ManagedInstanceCore
- AWSpolítica gestionada: AmazonSSM DirectoryServiceAccess
- ResetUserPassword política
Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.
En el panel de Amazon EC2, elija Lanzar instancia.
En Imágenes de aplicaciones y sistemas operativos, seleccione una AMI reciente de Amazon Linux 2.
Para EC2 Instance type (Tipo de instancia EC2), seleccione t2.micro.
En Key pair (login) (Par de claves [inicio de sesión]), elija un par de claves.
En Configuración de red, elija Editar.
Seleccione la VPC del directorio.
Desplácese hacia abajo y seleccione Detalles avanzados.
En Detalles avanzados, seleccione el directorio de unión a dominioscorp.example.com.
Para el perfil de instancia de IAM, elija el rol que creó en el paso 1 o un rol al que se adjunten las políticas enumeradas en el paso 4.
En Resumen, seleccione Lanzar instancia.
Anote el ID de la instancia (por ejemplo, i-1234567890abcdef0) y espere a que la instancia termine de lanzarse.
Una vez que el estado de la instancia cambie a , proceda con el siguiente paso.

Old EC2 console

Inicie sesión en la AWS Management Console.
Si no tienes un rol con las políticas enumeradas en el paso 4, abre la consola de IAM en https://console.aws.amazon.com/iam/. De lo contrario, vaya al paso 8.

Cree la política de ResetUserPassword. Sustituya el contenido resaltado en rojo por su Región de AWS Cuenta de AWS ID, ID y ID de directorio del resultado del script que ejecutó para crear Active Directory (AD).

ResetUserPassword


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

Cree un usuario de IAM con la siguiente política asociada:
- AWSpolítica gestionada: AmazonSSM ManagedInstanceCore
- AWSpolítica gestionada: AmazonSSM DirectoryServiceAccess
- Política de ResetUserPassword
Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.
En el panel de Amazon EC2, elija Lanzar instancia.
En Imágenes de aplicaciones y sistemas operativos, seleccione una AMI reciente de Amazon Linux 2.
En Instance type (Tipo de instancia), elija t2.micro.
En Key pair (login) (Par de claves [inicio de sesión]), elija un par de claves.
En Configuración de red, elija Editar.
En Configuración de red, VPC, seleccione el directorio VPC.
Desplázate hacia abajo y selecciona Detalles avanzados.
En Detalles avanzados, seleccione el directorio de unión a dominioscorp.example.com.
En Detalles avanzados, perfil de instancia, elija el rol que creó en el paso 1 o un rol al que se adjunten las políticas que se enumeran en el paso 4.
En Resumen, elija Lanzar instancia.
Anote el ID de la instancia (por ejemploi-1234567890abcdef0) y espere a que la instancia termine de lanzarse.
Una vez que el estado de la instancia cambie a , proceda con el siguiente paso.

Conéctese a su instancia y únase al dominio AD como`admin`.

Conéctese a la instancia y ejecute el siguiente comando.


$ 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

Instala el software necesario y únete al reino.


$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python

Sustituya la contraseña por la nueva contraseña.
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
       
```
Si lo anterior se ha realizado correctamente, se unirá al reino y continúe con el siguiente paso.

Cree el ReadOnlyUser y un usuario adicional.

En este paso, utilizará las herramientas adcli y openldap-clients que instaló en el paso anterior.


$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=ReadOnlyUser ReadOnlyUser


$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=user000 user000

Compruebe que se hayan creado los usuarios:

Las direcciones IP DNS del directorio son salidas del script de 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"

De forma predeterminada, cuando se crea un usuario conad-cli, el usuario está deshabilitado.

Restablezca y active las contraseñas de los usuarios desde su máquina local:

No cierre todavía la sesión de su instancia &EC2;.
nota
- ro-p@ssw0rdes la contraseña deReadOnlyUser, recuperada deAWS Secrets Manager.
- user-p@ssw0rdes la contraseña de un usuario del clúster que se proporciona cuando te conectas (ssh) al clúster.
directory-idEs una salida del script de 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"
```
Añade la contraseña a un secreto de Secrets Manager.

Ahora que ha creado una contraseña ReadOnlyUser y la ha establecido, guárdela en un secreto que se AWS ParallelCluster utilice para validar los inicios de sesión.

Usa Secrets Manager para crear un nuevo secreto que contenga la contraseña ReadOnlyUser como valor. El formato del valor secreto debe ser solo texto plano (no formato JSON). Toma nota del ARN secreto para futuros pasos.
```
$ aws secretsmanager create-secret --name "ADSecretPassword" \
--region region_id \
--secret-string "ro-p@ssw0rd" \
--query ARN \
--output text
arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
```

Anote los ID de recursos. Los usará en pasos posteriores.

Genere el certificado de dominio de forma local.


$ 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

Guarde el certificado en Secrets Manager para poder recuperarlo del clúster más adelante.


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

Agregue la siguiente política al rol de IAM que creó para unir la instancia de EC2 con el dominio de AD.

PutDomainCertificateSecrets


{
    "Statement": [
        {
            "Action": [
                "secretsmanager:PutSecretValue"
            ],
            "Resource": [
                "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
            ],
            "Effect": "Allow"
        }
    ]
}

Importe el certificado a 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"
}

Cree el balanceador de carga que se coloca delante de los puntos finales de 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"
    }   
  ]
}

Cree el grupo objetivo que se dirige a los puntos finales de Active Directory.


$ aws elbv2 create-target-group --name CorpExampleCom-Targets --protocol TCP \
  --port 389 \
  --target-type ip \
  --vpc-id vpc-021345abcdef6789 \
  --region region-id
{
  "TargetGroups": [
    {
      "TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
      "TargetGroupName": "CorpExampleCom-Targets",
      "Protocol": "TCP",
      "Port": 389,
      "VpcId": "vpc-021345abcdef6789",
      "HealthCheckProtocol": "TCP",
      "HealthCheckPort": "traffic-port",
      "HealthCheckEnabled": true,
      "HealthCheckIntervalSeconds": 30,
      "HealthCheckTimeoutSeconds": 10,
      "HealthyThresholdCount": 3,
      "UnhealthyThresholdCount": 3,
      "TargetType": "ip",
      "IpAddressType": "ipv4"
    }
  ]
}

Registre los puntos finales de Active Directory (AD) en el grupo de destino.


$ aws elbv2 register-targets --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
  --targets Id=192.0.2.254,Port=389 Id=203.0.113.237,Port=389 \
  --region region-id

Cree el listener LB con el certificado.


$ aws elbv2 create-listener --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 \
  --protocol TLS \
  --port 636 \
  --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
  --ssl-policy ELBSecurityPolicy-TLS-1-2-2017-01 \
  --certificates CertificateArn=arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 \
  --region region-id
  "Listeners": [
  {
    "ListenerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b",
    "LoadBalancerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4",
    "Port": 636,
    "Protocol": "TLS",
    "Certificates": [
      {
        "CertificateArn": "arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72"
       }
     ],
     "SslPolicy": "ELBSecurityPolicy-TLS-1-2-2017-01",
     "DefaultActions": [
       {
         "Type": "forward",
         "TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
         "ForwardConfig": {
           "TargetGroups": [
             {
                "TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81"
              }
            ]
          }
        }
      ]
    }
  ]
}

Cree la zona alojada para que el dominio se pueda detectar en la VPC del clúster.


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

Cree un archivo denominado `recordset-change.json` con el contenido siguiente. `HostedZoneId`es el ID de zona alojada canónico del balanceador de carga.


{
  "Changes": [
    {
      "Action": "CREATE",
      "ResourceRecordSet": {
        "Name": "corp.example.com",
        "Type": "A",
        "Region": "region-id",
        "SetIdentifier": "example-active-directory",
        "AliasTarget": {
          "HostedZoneId": "Z2IFOLAFXWLO4F",
          "DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
          "EvaluateTargetHealth": true
        }
      }
    }
  ]
}

Envía el cambio del conjunto de registros a la zona alojada, esta vez con el ID de la zona alojada.


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

Cree un Dockerfile con el siguiente contenido.


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "secretsmanager:GetSecretValue"
      ],
      "Resource": [
        "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-abc123"
      ],
      "Effect": "Allow"
    }
  ]
}

Cree un archivo Dockerfile denominado `policy.json` con el siguiente contenido.


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

Siga los pasos indicados en (Opcional) Paso 2: Administrar los usuarios y grupos de AD oPaso 1: Crear el clúster.

En este paso, administra los usuarios y los grupos desde una instancia EC2 de Amazon Linux 2 que está unida al dominio Active Delivery (AD).

Si ha seguido la ruta automática, reinicie e inicie sesión en la instancia unida a AD que se creó como parte de la automatización.

Si has seguido la ruta manual, reinicia e inicia sesión en la instancia que creaste y uniste al AD en los pasos anteriores.

En estos pasos, se utilizan las herramientas adcli y openldap-clients que se instalaron en la instancia como parte del paso anterior.

Inicie sesión en una instancia EC2 que esté unida al dominio AD

En la consola EC2, seleccione la instancia EC2 sin título que se creó en los pasos anteriores. La instancia debe tener el estado Stopped.
Si el estado de la instancia es Detenido, elija Estado de instancia y, a continuación, Iniciar instancia.
Una vez superadas las comprobaciones de estado, selecciona la instancia y elige Conectar y entrar SSH en la instancia.

Administre los usuarios y grupos al iniciar sesión en una instancia EC2 de Amazon Linux 2 que se haya unido al AD

Cuando ejecute los adcli comandos con la -U "Admin" opción, se le solicitará que introduzca la Admin contraseña de AD. Incluyes la Admin contraseña de AD como parte de los ldapsearch comandos.

Crear un usuario.


$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"

Para restablecer una contraseña de usuario


$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"

Crear un grupo


$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"

Adición de un usuario a un grupo


$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"

Describa los usuarios y los grupos.

Describa a todos los usuarios.


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

Describa a un usuario específico.


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

Describa a todos los usuarios con un patrón de nombres.


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

Describa a todos los usuarios que forman parte de un grupo específico.


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

Descripción de grupos de registros


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

Describir un grupo específico


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

Eliminación de un usuario de un grupo


$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"

Elimina un usuario.


$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"

Eliminación de un grupo


$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"

Si no ha salido de la instancia EC2, hágalo ahora.

El entorno está configurado para crear un clúster que pueda autenticar a los usuarios en Active Directory (AD).

Cree una configuración de clúster sencilla y proporcione los ajustes pertinentes para conectarse al AD. Para obtener más información, consulte la sección DirectoryService.

Elija una de las siguientes configuraciones de clúster y cópiela en un archivo con el nombre ldaps_config.yamlldaps_nocert_config.yaml, oldap_config.yaml.

Se recomienda elegir la configuración de LDAPS con verificación de certificado. Si elige esta configuración, también debe copiar el script de arranque en un archivo que lleve el nombre. active-directory.head.post.sh Además, debe almacenarlo en un bucket de Amazon S3, tal y como se indica en el archivo de configuración.

nota

Se deben cambiar los siguientes componentes.

KeyName: Uno de sus pares de claves EC2.
SubnetId / SubnetIds: Uno de los identificadores de subred proporcionados en el resultado de la pila de creación CloudFormation rápida (tutorial automatizado) o en el script de Python (tutorial manual).
Region: La región en la que creó la infraestructura de AD.
DomainAddr: Esta dirección IP es una de las direcciones DNS de su servicio de AD.
PasswordSecretArn: el nombre de recurso de Amazon (ARN) del secreto que contiene la contraseña del usuario efadmin
BucketName: El nombre del depósito que contiene el script de arranque.
AdditionalPolicies/Policy: El nombre de recurso de Amazon (ARN) de la política de certificación de dominio de lectura. ReadCertExample
CustomActions/OnNodeConfigured/Args: El nombre de recurso de Amazon (ARN) secreto que contiene la política de certificación de dominios.

Para mejorar la seguridad, sugerimos utilizar la AllowedIps configuraciónHeadNode/Ssh/para limitar el acceso SSH al nodo 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

Secuencia de comandos de arranque

Tras crear el archivo de arranque y antes de subirlo a su bucket de S3, ejecute chmod +x active-directory.head.post.sh para conceder el permiso de AWS ParallelCluster ejecución.


#!/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

Se deben cambiar los siguientes componentes.

KeyName: Uno de sus pares de claves EC2.
SubnetId / SubnetIds: Uno de los identificadores de subred que aparecen en el resultado de la pila de creación CloudFormation rápida (tutorial automático) o del script de Python (tutorial manual).
Region: La región en la que creó la infraestructura de AD.
DomainAddr: Esta dirección IP es una de las direcciones DNS de su servicio de AD.
PasswordSecretArn: el nombre de recurso de Amazon (ARN) del secreto que contiene la contraseña del usuario efadmin

Para mejorar la seguridad, sugerimos usar la AllowedIps configuración HeadNode /Ssh/ para limitar el acceso SSH al nodo 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

nota

Se deben cambiar los siguientes componentes.

KeyName: Uno de sus pares de claves EC2.
SubnetId / SubnetIds: Uno de los identificadores de subred proporcionados en el resultado de la pila de creación CloudFormation rápida (tutorial automatizado) o en el script de Python (tutorial manual).
Region: La región en la que creó la infraestructura de AD.
DomainAddr: Esta dirección IP es una de las direcciones DNS de su servicio de AD.
PasswordSecretArn: el nombre de recurso de Amazon (ARN) del secreto que contiene la contraseña del usuario efadmin

Para mejorar la seguridad, sugerimos usar la AllowedIps configuración HeadNode /Ssh/ para limitar el acceso SSH al nodo 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

Cree el clúster con el comando siguiente.


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

Puede consultar el estado del clúster con el comando siguiente.


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

El resultado es el siguiente.


"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"

Cuando llegue el estado"CREATE_COMPLETE", inicie sesión con el nombre de usuario y la contraseña creados.


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


$ ssh user000@$HEAD_NODE_IP

Puede iniciar sesión sin la contraseña proporcionando la SSH clave que se creó para el nuevo usuario en/home/user000@HEAD_NODE_IP/.ssh/id_rsa.

Si el ssh comando se ejecutó correctamente, se conectó correctamente al clúster como usuario autenticado para usar Active Directory (AD).

Desde su máquina local, elimine el clúster.


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

Compruebe el progreso de la eliminación del clúster.
```
$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"
```
Una vez que el clúster se haya eliminado correctamente, continúe con el siguiente paso.

Elimine los recursos de Active Directory

Navegue hasta https://console.aws.amazon.com/cloudwatch/.
En el panel de navegación, seleccione Stacks (Pilas).
De la lista de pilas, elige la pila AD (por ejemplo,pcluster-ad).
Elija Eliminar.

Elimine la instancia de EC2.
1. En https://console.aws.amazon.com/ec2/, elija Instances en el panel de navegación.
2. De la lista de instancias, elija la que creó para añadir usuarios al directorio.
3. Elija Instance state (Estado de instancia) y luego Terminate instance (Terminar instancia).

Eliminación de la zona alojada en

Cree un archivo recordset-delete.json, con el siguiente contenido: En este ejemplo, HostedZoneId es el ID canónico de la zona hospedada del balanceador de cargas.


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

Envía el cambio del conjunto de registros a la zona alojada mediante el ID de la zona alojada.


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

Eliminación de la zona alojada en


$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
 "ChangeInfo": {
     "Id": "/change/C0468051QFABTVHMDEG9",
     "Status": "PENDING",
     "SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
 }
}

Eliminar el agente de escucha.


$ aws elbv2 delete-listener \
  --listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id

Eliminar un grupo de destino


$ aws elbv2 delete-target-group \
  --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id

Eliminar el equilibrador de carga.


$ aws elbv2 delete-load-balancer \
  --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id

Elimine la política que usa el clúster para leer el certificado de Secrets Manager.


$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample

Elimine el secreto que contiene el certificado de 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"
}

Elimine el certificado de ACM.


$ aws acm delete-certificate \
  --certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id

Elimine los recursos de Active Directory (AD).

Obtenga los siguientes identificadores de recursos de la salida del script de Pythonad.py:
- ID DE ANUNCIO
- ID de subred de AD
- ID DE LA VPC

Elimine los puentes ejecutando el siguiente comando.


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

Enumere los grupos de seguridad de la VPC.


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

Elimine el grupo de seguridad personalizado.


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

Eliminar las subredes.


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


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

describe-internet-puerta de enlaces ()


$ 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": []
    }
  ]  
}

detach-internet-puerta de enlace ()


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

- Elimina la puerta de enlace de Internet.


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

Eliminación de la VPC


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

Elimine el secreto que contiene la ReadOnlyUser contraseña.


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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Creación de una AMI de AWS ParallelCluster personalizada

Configuración del cifrado de almacenamiento compartido con una clave AWS KMS

Integración de Active Directory

nota

nota

Requisitos previos

nota

Conéctese a su instancia y únase al dominio AD comoadmin.

Instala el software necesario y únete al reino.

Sustituya la contraseña por la nueva contraseña.

Cree el ReadOnlyUser y un usuario adicional.

Restablezca y active las contraseñas de los usuarios desde su máquina local:

nota

Genere el certificado de dominio de forma local.

Guarde el certificado en Secrets Manager para poder recuperarlo del clúster más adelante.

Importe el certificado a AWS Certificate Manager (ACM).

Cree el balanceador de carga que se coloca delante de los puntos finales de Active Directory.

Cree el grupo objetivo que se dirige a los puntos finales de Active Directory.

Registre los puntos finales de Active Directory (AD) en el grupo de destino.

Cree el listener LB con el certificado.

Cree la zona alojada para que el dominio se pueda detectar en la VPC del clúster.

Cree un archivo denominado recordset-change.json con el contenido siguiente. HostedZoneIdes el ID de zona alojada canónico del balanceador de carga.

Envía el cambio del conjunto de registros a la zona alojada, esta vez con el ID de la zona alojada.

Cree un Dockerfile con el siguiente contenido.

Cree un archivo Dockerfile denominado policy.json con el siguiente contenido.

Siga los pasos indicados en (Opcional) Paso 2: Administrar los usuarios y grupos de AD oPaso 1: Crear el clúster.

Inicie sesión en una instancia EC2 que esté unida al dominio AD

Administre los usuarios y grupos al iniciar sesión en una instancia EC2 de Amazon Linux 2 que se haya unido al AD

Crear un usuario.

Para restablecer una contraseña de usuario

Crear un grupo

Adición de un usuario a un grupo

Describa los usuarios y los grupos.

Eliminación de un usuario de un grupo

Elimina un usuario.

Eliminación de un grupo

nota

Se deben cambiar los siguientes componentes.

nota

Se deben cambiar los siguientes componentes.

nota

Se deben cambiar los siguientes componentes.

Desde su máquina local, elimine el clúster.

Compruebe el progreso de la eliminación del clúster.

Elimine los recursos de Active Directory

Elimine la instancia de EC2.

Eliminación de la zona alojada en

Eliminar el agente de escucha.

Eliminar un grupo de destino

Eliminar el equilibrador de carga.

Elimine la política que usa el clúster para leer el certificado de Secrets Manager.

Elimine el secreto que contiene el certificado de dominio.

Elimine el certificado de ACM.

Elimine los recursos de Active Directory (AD).

Conéctese a su instancia y únase al dominio AD como`admin`.

Cree un archivo denominado `recordset-change.json` con el contenido siguiente. `HostedZoneId`es el ID de zona alojada canónico del balanceador de carga.

Cree un archivo Dockerfile denominado `policy.json` con el siguiente contenido.