Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Configuración de una URL amigable para las aplicaciones de OpenSearch interfaz de usuario (autoservicio)
<a name="application-custom-domain"></a>

OpenSearch Las aplicaciones de interfaz de usuario tienen URL generadas automáticamente, como. `https://application-{{name}}-{{id}}.{{Region}}.opensearch.amazonaws.com` Estas URL son largas y difíciles de recordar. Puedes configurar una URL amigable (por ejemplo`https://prod.example.com`). Esta URL redirige a su aplicación, por lo que puede acceder a los paneles directamente sin tener que navegar por la AWS consola de administración.

## Funcionamiento
<a name="application-custom-domain-overview"></a>

Esta solución se utiliza CloudFront para redirigir las solicitudes desde tu URL amigable al punto final de tu aplicación de OpenSearch interfaz de usuario. La arquitectura consta de los siguientes componentes:
+ **Certificado ACM**: proporciona cifrado HTTPS para su URL amigable.
+ **CloudFront KeyValueStore**— Almacena el mapeo entre los nombres de los subdominios y las URL de las aplicaciones.
+ **CloudFront función ** — Lee KeyValueStore y devuelve una redirección 302 a la URL de la aplicación correcta.
+ **CloudFront distribución**: muestra su URL amigable con TLS y dirige las solicitudes a través de la función.
+ **Registro DNS de Route 53**: apunta tu URL amigable a la CloudFront distribución.

Cuando visitas tu URL amigable (por ejemplo,`https://prod.example.com`), la CloudFront función busca la URL de la aplicación correspondiente y redirige el navegador a ella. La aplicación gestiona la autenticación directamente.

## Requisitos previos
<a name="application-custom-domain-prerequisites"></a>
+ Una o más aplicaciones de OpenSearch interfaz de usuario con sus URL de punto final.
+ Un nombre de dominio de tu propiedad (por ejemplo,`example.com`).
+ Una zona alojada pública en Route 53 para tu dominio. Si no tiene una, para obtener más información, consulte[Configuración sin Route 53 (configuración manual)](#application-custom-domain-without-route53).
+ Un bucket de Amazon S3 para almacenar el archivo de mapeo de URL de la aplicación.

## Implemente usando AWS CloudFormation
<a name="application-custom-domain-deploy-cfn"></a>

Utilice el siguiente procedimiento para implementar la infraestructura de redireccionamiento de URL amigable con una CloudFormation plantilla.

**Para configurar una URL amigable para sus aplicaciones de OpenSearch interfaz de usuario**

1. Crea un archivo JSON que asigne tus nombres descriptivos a las URL de las aplicaciones. Cada clave se convierte en un subdominio (por ejemplo, la clave `prod` se convierte en`https://prod.example.com`).

   ```
   {
     "data": [
       {"key": "prod", "value": "https://application-prod-abc123.us-west-2.opensearch.amazonaws.com"},
       {"key": "staging", "value": "https://application-staging-def456.us-east-1.opensearch.amazonaws.com"},
       {"key": "analytics", "value": "https://application-analytics-ghi789.eu-west-1.opensearch.amazonaws.com"}
     ]
   }
   ```

   Guarde este archivo como `opensearch-ui-friendly-url-app-mappings-v1.json`. El `v1` sufijo lo identifica como la primera versión de sus mapeos. Esta versión se incrementa cuando se actualizan las asignaciones.

1. Suba el archivo de mapeos a un bucket de Amazon S3 de su cuenta:

   ```
   aws s3 cp opensearch-ui-friendly-url-app-mappings-v1.json \
     s3://{{your-bucket-name}}/opensearch-ui-friendly-url-app-mappings-v1.json
   ```

1. Conceda CloudFront permiso para leer el archivo de mapeos añadiendo una política de bucket. Sustituya {{your-bucket-name}} y por {{your-account-id}} sus valores:

   ```
   aws s3api put-bucket-policy \
     --bucket {{your-bucket-name}} \
     --policy '{
       "Version": "2012-10-17",
       "Statement": [{
         "Sid": "AllowCloudFrontKVSImport",
         "Effect": "Allow",
         "Principal": {"Service": "cloudfront.amazonaws.com"},
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::{{your-bucket-name}}/*",
         "Condition": {"StringEquals": {"aws:SourceAccount": "{{your-account-id}}"}}
       }]
     }'
   ```
**nota**  
Esta política de bucket permite CloudFront leer el archivo de mapeos durante KeyValueStore la creación. Sin él, la implementación de la pila falla y aparece el error «SourceARN es inaccesible».

1. Implemente la CloudFormation pila mediante una de las siguientes opciones:

   **Opción 1: Launch Stack (recomendado) **

   Copia la siguiente URL y pégala en tu navegador para abrir la página de AWS CloudFormation creación rápida con la plantilla precargada. Rellene los parámetros y seleccione ** Crear pila. **

   ```
   https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/quickcreate?templateURL=https://opensearch-ui-quickstart-sample-cfn-templates.s3.us-west-2.amazonaws.com/opensearch-ui-friendly-url/main.yaml&stackName=opensearch-ui-friendly-url&param_MappingsVersion=v1
   ```

   **Opción 2: AWS CLI **

   Sustituya los valores del marcador de posición por los suyos propios:

   ```
   aws cloudformation create-stack \
     --stack-name opensearch-ui-friendly-url \
     --template-url https://opensearch-ui-quickstart-sample-cfn-templates.s3.us-west-2.amazonaws.com/opensearch-ui-friendly-url/main.yaml \
     --parameters \
       ParameterKey=DomainName,ParameterValue={{your-domain.com}} \
       ParameterKey=HostedZoneId,ParameterValue={{Z0123456789ABCDEFG}} \
       ParameterKey=MappingsBucket,ParameterValue={{your-bucket-name}} \
       ParameterKey=MappingsKey,ParameterValue=opensearch-ui-friendly-url-app-mappings-v1.json \
       ParameterKey=MappingsVersion,ParameterValue=v1 \
     --region us-east-1
   ```

1. Si usó la AWS CLI (opción 2), implemente la pila en la `us-east-1` región. CloudFront requiere que estén incluidos los certificados de ACM. `us-east-1` Sus aplicaciones de OpenSearch interfaz de usuario pueden estar en cualquier región [ admitida y con cuotas de OpenSearch interfaz de usuario](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/opensearch-ui-endpoints-quotas.html).

1. Espera a que se complete la pila (aproximadamente 15 minutos). Puedes supervisar el progreso:

   ```
   aws cloudformation wait stack-create-complete \
     --stack-name opensearch-ui-friendly-url \
     --region us-east-1
   ```

1. Prueba la redirección. Abre tu navegador y navega hasta`https://{{prod}}.{{your-domain.com}}`. Debería ser redirigido a su aplicación de OpenSearch interfaz de usuario.

   También puedes verificarlo con`curl`:

   ```
   curl -I https://{{prod}}.{{your-domain.com}}
   # Expected: HTTP/2 302
   # location: https://application-prod-abc123.us-west-2.opensearch.amazonaws.com
   ```

### CloudFormation fuente de la plantilla
<a name="application-custom-domain-template-source"></a>

La siguiente es la CloudFormation plantilla completa utilizada por el comando CLI y enlace Launch Stack anterior. También puede descargarla directamente desde`https://opensearch-ui-quickstart-sample-cfn-templates.s3.us-west-2.amazonaws.com/opensearch-ui-friendly-url/main.yaml`.

```
AWSTemplateFormatVersion: '2010-09-09'
Metadata:
  TemplateVersion: '1.0.0'
  LastUpdated: '2026-08-05'
  Author: 'OpenSearch UI Team'
Description: >
  OpenSearch UI Friendly URL - Creates a CloudFront distribution with a CloudFront Function
  that redirects friendly subdomain URLs to OpenSearch Application endpoints.
  Deploy this template in us-east-1 (required for ACM certificates used with CloudFront).

Parameters:
  DomainName:
    Type: String
    Description: "Your domain name (e.g., example.com or subdomain.example.com)"
    AllowedPattern: "^[a-zA-Z0-9][a-zA-Z0-9-]*(\\.[a-zA-Z0-9][a-zA-Z0-9-]*)+$"
  HostedZoneId:
    Type: AWS::Route53::HostedZone::Id
    Description: "Route 53 Hosted Zone ID for your domain"
  MappingsBucket:
    Type: String
    Description: "S3 bucket name containing your app mappings JSON file"
  MappingsKey:
    Type: String
    Description: "S3 key (path) to your app mappings JSON file"
    Default: "opensearch-ui-friendly-url-app-mappings.json"
  MappingsVersion:
    Type: String
    Description: "Version identifier for your mappings (change this when updating mappings, e.g., v1, v2, v3)"
    Default: "v1"
    AllowedPattern: "^[a-zA-Z0-9-]+$"

Resources:
  # 1. Wildcard TLS Certificate (DNS validated via Route 53)
  Certificate:
    Type: AWS::CertificateManager::Certificate
    Properties:
      DomainName: !Sub "*.${DomainName}"
      ValidationMethod: DNS
      DomainValidationOptions:
        - DomainName: !Sub "*.${DomainName}"
          HostedZoneId: !Ref HostedZoneId

  # 2. CloudFront KeyValueStore with S3 import for app mappings
  AppMappingStore:
    Type: AWS::CloudFront::KeyValueStore
    Properties:
      Name: !Sub "${AWS::StackName}-kvs-${MappingsVersion}"
      Comment: !Sub "OpenSearch UI app mappings ${MappingsVersion} for ${DomainName}"
      ImportSource:
        SourceType: S3
        SourceArn: !Sub "arn:aws:s3:::${MappingsBucket}/${MappingsKey}"

  # 3. CloudFront Function (reads KVS, returns 302 redirect)
  RedirectFunction:
    Type: AWS::CloudFront::Function
    Properties:
      Name: !Sub "${AWS::StackName}-fn"
      AutoPublish: true
      FunctionConfig:
        Comment: !Sub "Redirects friendly URLs to OpenSearch Application endpoints (${MappingsVersion})"
        Runtime: cloudfront-js-2.0
        KeyValueStoreAssociations:
          - KeyValueStoreARN: !GetAtt AppMappingStore.Arn
      FunctionCode: !Sub |
        import cf from 'cloudfront';

        const kvsHandle = cf.kvs("${AppMappingStore.Id}");

        async function handler(event) {
          var request = event.request;
          var host = request.headers.host.value;
          
          // Extract subdomain prefix (e.g., "app1" from "app1.example.com")
          var subdomain = host.split('.')[0];
          
          try {
            var targetUrl = await kvsHandle.get(subdomain);
            return {
              statusCode: 302,
              statusDescription: 'Found',
              headers: {
                'location': { value: targetUrl },
                'cache-control': { value: 'no-cache, no-store, must-revalidate' }
              }
            };
          } catch (e) {
            // Key not found - return 404
            return {
              statusCode: 404,
              statusDescription: 'Not Found',
              headers: {
                'content-type': { value: 'text/html' }
              },
              body: {
                encoding: 'text',
                data: '<html><body><h1>Application Not Found</h1><p>No OpenSearch application is mapped to the requested subdomain.</p></body></html>'
              }
            };
          }
        }

  # 4. CloudFront Distribution
  Distribution:
    Type: AWS::CloudFront::Distribution
    DependsOn: Certificate
    Properties:
      DistributionConfig:
        Enabled: true
        Comment: !Sub "OpenSearch UI Friendly URL for ${DomainName}"
        Aliases:
          - !Sub "*.${DomainName}"
        ViewerCertificate:
          AcmCertificateArn: !Ref Certificate
          SslSupportMethod: sni-only
          MinimumProtocolVersion: TLSv1.2_2021
        DefaultCacheBehavior:
          ViewerProtocolPolicy: redirect-to-https
          AllowedMethods:
            - GET
            - HEAD
          CachedMethods:
            - GET
            - HEAD
          CachePolicyId: "4135ea2d-6df8-44a3-9df3-4b5a84be39ad"  # AWS managed CachingDisabled policy
          TargetOriginId: dummy-origin
          FunctionAssociations:
            - EventType: viewer-request
              FunctionARN: !GetAtt RedirectFunction.FunctionMetadata.FunctionARN
        Origins:
          - Id: dummy-origin
            DomainName: "example.com"
            CustomOriginConfig:
              OriginProtocolPolicy: https-only
        HttpVersion: http2and3
        IPV6Enabled: true
        PriceClass: PriceClass_All

  # 5. Wildcard DNS record pointing to CloudFront
  WildcardDnsRecord:
    Type: AWS::Route53::RecordSet
    Properties:
      HostedZoneId: !Ref HostedZoneId
      Name: !Sub "*.${DomainName}"
      Type: A
      AliasTarget:
        HostedZoneId: Z2FDTNDATAQYW2  # CloudFront's fixed hosted zone ID (constant for all distributions)
        DNSName: !GetAtt Distribution.DomainName
        EvaluateTargetHealth: false

Outputs:
  CloudFrontDomain:
    Description: "CloudFront distribution domain name"
    Value: !GetAtt Distribution.DomainName
  CertificateArn:
    Description: "ACM Certificate ARN"
    Value: !Ref Certificate
  KeyValueStoreArn:
    Description: "CloudFront KeyValueStore ARN"
    Value: !GetAtt AppMappingStore.Arn
  ExampleUrl:
    Description: "Example friendly URL"
    Value: !Sub "https://prod.${DomainName}"
  MappingsFileLocation:
    Description: "S3 location of your app mappings file"
    Value: !Sub "s3://${MappingsBucket}/${MappingsKey}"
  CurrentMappingsVersion:
    Description: "Current mappings version deployed"
    Value: !Ref MappingsVersion
  TemplateVersion:
    Description: "Template version and last updated date"
    Value: "1.0.0 (2026-08-05)"
```

### Agregar o eliminar aplicaciones
<a name="application-custom-domain-add-apps"></a>

Para añadir, actualizar o eliminar las asignaciones de aplicaciones, cree una nueva versión del archivo de asignaciones de S3 y actualice la pila con la nueva versión. El enfoque versionado mantiene el archivo S3 como la fuente de información fiable y permite actualizar a nuevas configuraciones o volver a versiones anteriores en cualquier momento.

1. Edite el archivo de mapeos para agregar o eliminar entradas. Guárdelo con un sufijo de versión incrementada (por ejemplo,). `opensearch-ui-friendly-url-app-mappings-v2.json`

1. Suba la nueva versión a S3:

   ```
   aws s3 cp opensearch-ui-friendly-url-app-mappings-v2.json \
     s3://{{your-bucket-name}}/opensearch-ui-friendly-url-app-mappings-v2.json
   ```

1. Actualice la pila con la nueva `MappingsKey` y`MappingsVersion`:

   **Uso de la consola: ** abre la [CloudFormation consola](https://console.aws.amazon.com/cloudformation/), selecciona tu pila, elige ** Actualizar**, selecciona ** Usar la plantilla actual y**, a continuación, actualiza los `MappingsVersion` parámetros `MappingsKey` y con los nuevos valores.

   **Uso de la AWS CLI: **

   ```
   aws cloudformation update-stack \
     --stack-name opensearch-ui-friendly-url \
     --use-previous-template \
     --parameters \
       ParameterKey=DomainName,UsePreviousValue=true \
       ParameterKey=HostedZoneId,UsePreviousValue=true \
       ParameterKey=MappingsBucket,UsePreviousValue=true \
       ParameterKey=MappingsKey,ParameterValue=opensearch-ui-friendly-url-app-mappings-v2.json \
       ParameterKey=MappingsVersion,ParameterValue=v2 \
     --region us-east-1
   ```

**importante**  
Debe cambiar el `MappingsVersion` parámetro cada vez que actualice las asignaciones. La versión controla el KeyValueStore nombre, lo que hace CloudFormation que se sustituya el por KeyValueStore los datos actualizados. Mantenga el nombre del `MappingsKey` archivo y `MappingsVersion` manténgalo sincronizado (por ejemplo, `...-v2.json` con`MappingsVersion=v2`) para mayor claridad.

Para volver a una versión anterior, actualiza la pila que apunta al archivo y la versión anteriores.

**Uso de la consola: ** abre la [CloudFormation consola](https://console.aws.amazon.com/cloudformation/), selecciona tu pila, elige ** Actualizar**, selecciona ** Usar la plantilla actual y**, a continuación, establece `MappingsKey` y `MappingsVersion` vuelve a los valores anteriores (por ejemplo,`v1`).

**Uso de la AWS CLI: **

```
aws cloudformation update-stack \
  --stack-name opensearch-ui-friendly-url \
  --use-previous-template \
  --parameters \
    ParameterKey=DomainName,UsePreviousValue=true \
    ParameterKey=HostedZoneId,UsePreviousValue=true \
    ParameterKey=MappingsBucket,UsePreviousValue=true \
    ParameterKey=MappingsKey,ParameterValue=opensearch-ui-friendly-url-app-mappings-v1.json \
    ParameterKey=MappingsVersion,ParameterValue=v1 \
  --region us-east-1
```

Este enfoque versionado le brinda el control total para avanzar o deshacer las asignaciones de las aplicaciones según sea necesario, al tiempo que mantiene los archivos de S3 como el registro definitivo de cada versión de configuración.

## Configuración sin Route 53 (configuración manual)
<a name="application-custom-domain-without-route53"></a>

Si su dominio lo administra un proveedor de DNS que no sea Route 53, puede configurar manualmente redireccionamientos de URL amigables en la consola AWS de administración. Este enfoque no utiliza Amazon S3 para las asignaciones; los pares clave-valor se administran directamente en la consola. CloudFront 

**Para configurar un redireccionamiento de URL amigable sin Route 53**

1. 

**Solicite un certificado en ACM**

   1. Abra la consola de ACM [ https://console.aws.amazon.com/acm/ ](https://console.aws.amazon.com/acm/) en la `us-east-1` región.

   1. Elija ** Solicitar certificado. **

   1. En Nombre de ** dominio**, introduzca `*.{{your-domain.com}}` (certificado comodín).

   1. En Método de ** validación**, elija la validación ** de ** DNS.

   1. Seleccione **Solicitar**.

   1. En la página de detalles del certificado, anote el nombre y el valor del registro CNAME en Validación ** del ** dominio. Crea este registro CNAME en tu proveedor de DNS para validar la propiedad del dominio.

   1. Espera a que el estado del certificado cambie a ** Emitido ** (normalmente entre 5 y 30 minutos después de la creación del registro DNS).

1. 

**Crea un CloudFront KeyValueStore**

   1. Abra la CloudFront consola en [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

   1. Seleccione **Funciones** en el panel de navegación. Luego elige la ** KeyValueStores ** pestaña.

   1. Seleccione **Crear KeyValueStore**.

   1. Introduzca un nombre (por ejemplo,`opensearch-ui-friendly-url-app-mappings-store`).

   1. Seleccione **Crear**.

   1. Tras la creación, elija ** Editar ** para añadir pares clave-valor. Para cada aplicación, añada una clave (el nombre del subdominio, por ejemplo`prod`) y un valor (la URL completa de la aplicación de OpenSearch interfaz de usuario).

1. 

**Crea una función CloudFront**

   1. Abra la CloudFront consola en [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

   1. Seleccione **Funciones** en el panel de navegación.

   1. En la ** pestaña ** Funciones, seleccione ** Crear función**.

   1. Introduzca un nombre para la función (por ejemplo,`opensearch-ui-friendly-url-redirect-function`).

   1. Para ** Runtime**, elija ** ** cloudfront-js-2.0.

   1. Sustituya el código de función por el siguiente:

      ```
      import cf from 'cloudfront';
      
      const kvsHandle = cf.kvs("{{YOUR_KVS_ID}}");
      
      async function handler(event) {
        var request = event.request;
        var host = request.headers.host.value;
        var subdomain = host.split('.')[0];
      
        try {
          var targetUrl = await kvsHandle.get(subdomain);
          return {
            statusCode: 302,
            statusDescription: 'Found',
            headers: {
              'location': { value: targetUrl },
              'cache-control': { value: 'no-cache, no-store, must-revalidate' }
            }
          };
        } catch (e) {
          return {
            statusCode: 404,
            statusDescription: 'Not Found',
            headers: { 'content-type': { value: 'text/html' } },
            body: {
              encoding: 'text',
              data: '<html><body><h1>Application Not Found</h1><p>No OpenSearch application is mapped to the requested subdomain.</p></body></html>'
            }
          };
        }
      }
      ```

      {{YOUR\_KVS\_ID}}Sustitúyalo por el ID del KeyValueStore que creó (visible en la página de KeyValueStore detalles).

   1. En ** KeyValueStore las asociaciones**, asocia las KeyValueStore que creaste.

   1. Seleccione ** Guardar cambios ** y, a continuación, la función ** Publicar**.

1. 

**Crea una CloudFront distribución**

   1. En la CloudFront consola, elija ** Crear distribución**.

   1. Para el dominio ** Origin**, introduce cualquier dominio válido (por ejemplo,`example.com`). Nunca se contacta con el origen porque la función devuelve una respuesta antes de llegar a él.

   1. En Comportamiento ** predeterminado de la caché**, para la política de protocolo de ** Viewer**, elija ** Redirigir HTTP a HTTPS**.

   1. Para la política de ** caché**, elija ** CachingDisabled**.

   1. En Asociaciones de ** funciones**, para la solicitud del ** visor**, seleccione su CloudFront función.

   1. En ** Configuración**, para Nombres de dominio ** alternativos (CNAME)**, introduzca`*.{{your-domain.com}}`.

   1. Para el certificado SSL ** personalizado**, selecciona el certificado que creaste en ACM.

   1. Elija **Crear distribución**.

   1. Anote el nombre del dominio de distribución (por ejemplo,`d1234abcdef8.cloudfront.net`).

1. 

**Configure el DNS en su proveedor**

   En tu proveedor de DNS, crea un registro CNAME que apunte `*.{{your-domain.com}}` a tu nombre de dominio de CloudFront distribución (por ejemplo,`d1234abcdef8.cloudfront.net`).
**nota**  
Algunos proveedores de DNS no admiten registros CNAME con caracteres comodín. En ese caso, crea registros CNAME individuales para cada subdominio que quieras usar (por ejemplo,). `prod.your-domain.com` `staging.your-domain.com`

### Agregar mapeos de aplicaciones manualmente
<a name="application-custom-domain-manual-add-apps"></a>

Para agregar nuevas asignaciones de aplicaciones después de la configuración manual inicial:

1. Abra la CloudFront consola en. [ https://console.aws.amazon.com/cloudfront/ ](https://console.aws.amazon.com/cloudfront/)

1. Seleccione **Funciones** en el panel de navegación. Luego elige la ** KeyValueStores ** pestaña.

1. Elige tu KeyValueStore nombre (por ejemplo,`opensearch-ui-friendly-url-app-mappings-store`).

1. Elija **Edit (Edición de)**.

1. Selecciona ** Añadir par**. Introduzca el nombre del subdominio como clave y la URL completa de la aplicación de OpenSearch interfaz de usuario como valor.

1. Seleccione **Save changes (Guardar cambios)**.

La nueva URL amigable estará disponible inmediatamente después de guardarla.

## Limpieza
<a name="application-custom-domain-cleanup"></a>

Para eliminar la infraestructura de redireccionamiento de URL amigables, ejecuta el siguiente comando:

```
aws cloudformation delete-stack \
  --stack-name opensearch-ui-friendly-url \
  --region us-east-1
```

Este comando elimina la CloudFront distribución, la función KeyValueStore, el certificado ACM y el registro DNS. No afecta a las aplicaciones de OpenSearch interfaz de usuario.

## Resolución de problemas
<a name="application-custom-domain-troubleshooting"></a>

El certificado ACM permanece en vigor `Pending validation`  
Asegúrese de que el DNS de su dominio esté debidamente delegado a Route 53 (o de que haya creado el CNAME de validación en su proveedor de DNS). `dig {{your-domain}} NS`Utilízalo para verificar los servidores de nombres.

El navegador muestra un error de certificado  
Verifique que el certificado ACM incluya su dominio como comodín ()`*.your-domain.com`. El certificado debe estar en la `us-east-1` región.

404 No se encontró la aplicación  
El subdominio al que intentas acceder no tiene ningún mapa en. KeyValueStore Comprueba que la clave existe en tu archivo de mapeos y confirma que has actualizado la pila (o que has añadido el par manualmente) después del último cambio.

CloudFront la distribución muestra `Deploying` el estado durante más de 15 minutos  
CloudFront las distribuciones pueden tardar hasta 15 minutos en implementarse en todo el mundo. Si la implementación lleva más tiempo, consulte la CloudFront consola para ver los detalles del error.

Error de inaccesibilidad al SourceARN durante la creación de la pila  
Asegúrese de que la política de cubos de S3 conceda `cloudfront.amazonaws.com` permiso para leer el archivo de mapeos. Compruebe también el rol de IAM que implementa la pila y `s3:GetBucketLocation` los permisos en el bucket. `s3:GetObject` `s3:HeadObject`