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

# Impostazione di un URL intuitivo per le applicazioni OpenSearch dell'interfaccia utente (self-service)
<a name="application-custom-domain"></a>

OpenSearch Le applicazioni dell'interfaccia utente hanno URL generati automaticamente come. `https://application-{{name}}-{{id}}.{{Region}}.opensearch.amazonaws.com` Questi URL sono lunghi e difficili da ricordare. Puoi impostare un URL descrittivo (ad esempio`https://prod.example.com`). Questo URL reindirizza alla tua applicazione, quindi puoi accedere direttamente alle dashboard senza navigare nella console di gestione. AWS 

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

Questa soluzione viene utilizzata CloudFront per reindirizzare le richieste dall'URL descrittivo all'endpoint dell'applicazione UI. OpenSearch L'architettura è composta dai seguenti componenti:
+ **Certificato ACM**: fornisce la crittografia HTTPS per il tuo URL intuitivo.
+ **CloudFront KeyValueStore**— Memorizza la mappatura tra i nomi dei sottodomini e gli URL delle applicazioni.
+ **CloudFront funzione**: legge KeyValueStore e restituisce un reindirizzamento 302 all'URL dell'applicazione corretto.
+ **CloudFront distribuzione**: fornisce l'URL descrittivo con TLS e indirizza le richieste tramite la funzione.
+ **Record DNS Route 53**: indirizza l'URL descrittivo alla CloudFront distribuzione.

Quando visiti il tuo URL amichevole (ad esempio`https://prod.example.com`), la CloudFront funzione cerca l'URL dell'applicazione corrispondente e reindirizza il browser ad esso. L'applicazione gestisce direttamente l'autenticazione.

## Prerequisiti
<a name="application-custom-domain-prerequisites"></a>
+ Una o più applicazioni OpenSearch dell'interfaccia utente con i relativi URL degli endpoint.
+ Un nome di dominio di tua proprietà (ad esempio,`example.com`).
+ Una zona pubblica ospitata in Route 53 per il tuo dominio. Se non ne hai una, per ulteriori informazioni, consulta[Configurazione senza Route 53 (configurazione manuale)](#application-custom-domain-without-route53).
+ Un bucket Amazon S3 per archiviare il file di mappatura degli URL dell'applicazione.

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

Utilizza la seguente procedura per implementare l'infrastruttura di reindirizzamento URL intuitiva con un modello. CloudFormation 

**Per impostare un URL descrittivo per le tue applicazioni UI OpenSearch**

1. Crea un file JSON che associa i tuoi nomi descrittivi agli URL delle applicazioni. Ogni chiave diventa un sottodominio (ad esempio, la chiave `prod` diventa). `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"}
     ]
   }
   ```

   Salva questo file come `opensearch-ui-friendly-url-app-mappings-v1.json`. Il `v1` suffisso la identifica come la prima versione delle tue mappature. Questa versione viene incrementata quando si aggiornano le mappature.

1. Carica il file di mappatura in un bucket Amazon S3 nel tuo account:

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

1. Concedi CloudFront il permesso di leggere il file di mappatura aggiungendo una bucket policy. Sostituisci {{your-bucket-name}} e {{your-account-id}} con i tuoi valori:

   ```
   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**  
Questa policy del bucket consente di CloudFront leggere il file di mappatura durante la creazione. KeyValueStore Senza di essa, la distribuzione dello stack fallisce con un errore «SourceARN is inaccessible».

1. Distribuisci lo CloudFormation stack utilizzando una delle seguenti opzioni:

   **Opzione 1: Avvia Stack (consigliata) **

   Copia il seguente URL e incollalo nel browser per aprire la pagina di AWS CloudFormation creazione rapida con il modello precaricato. Inserisci i parametri e scegli ** Crea stack. **

   ```
   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
   ```

   **Opzione 2: AWS CLI **

   Sostituisci i valori segnaposto con i tuoi:

   ```
   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. Se hai utilizzato la AWS CLI (opzione 2), distribuisci lo stack nella regione. `us-east-1` CloudFront richiede l'installazione dei certificati ACM. `us-east-1` Le applicazioni OpenSearch dell'interfaccia utente possono trovarsi in qualsiasi regione [ supportata e con qualsiasi quota per OpenSearch l'interfaccia utente. ](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/opensearch-ui-endpoints-quotas.html)

1. Attendi il completamento dello stack (circa 15 minuti). Puoi monitorare i progressi:

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

1. Prova il reindirizzamento. Apri il browser e vai a. `https://{{prod}}.{{your-domain.com}}` Dovresti essere reindirizzato alla tua applicazione OpenSearch UI.

   Puoi anche verificare 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 fonte del modello
<a name="application-custom-domain-template-source"></a>

Quello che segue è il CloudFormation modello completo utilizzato dal collegamento Launch Stack e dal comando CLI sopra riportato. Puoi anche scaricarlo direttamente da`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)"
```

### Aggiungere o rimuovere applicazioni
<a name="application-custom-domain-add-apps"></a>

Per aggiungere, aggiornare o rimuovere le mappature delle applicazioni, create una nuova versione del file di mappatura S3 e aggiornate lo stack con la nuova versione. L'approccio basato sulle versioni mantiene il file S3 come fonte di verità e consente di passare a nuove configurazioni o ripristinare le versioni precedenti in qualsiasi momento.

1. Modifica il file di mappatura per aggiungere o rimuovere voci. Salvalo con un suffisso di versione incrementato (ad esempio,). `opensearch-ui-friendly-url-app-mappings-v2.json`

1. Carica la nuova versione su 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. Aggiorna lo stack con il nuovo `MappingsKey` e`MappingsVersion`:

   **Uso della console: ** apri la [CloudFormation console](https://console.aws.amazon.com/cloudformation/), seleziona lo stack, scegli ** Aggiorna**, seleziona ** Usa modello corrente**, quindi aggiorna i `MappingsVersion` parametri `MappingsKey` e con i nuovi valori.

   **Utilizzando 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**  
È necessario modificare il `MappingsVersion` parametro ogni volta che si aggiornano le mappature. La versione determina il KeyValueStore nome, che attiva CloudFormation la sostituzione KeyValueStore con i dati aggiornati. Mantieni il nome del `MappingsKey` file e `MappingsVersion` sincronizzati (ad esempio, `...-v2.json` con`MappingsVersion=v2`) per maggiore chiarezza.

Per tornare a una versione precedente, aggiorna lo stack che punta al file e alla versione precedenti.

**Uso della console: ** apri la [CloudFormation console](https://console.aws.amazon.com/cloudformation/), seleziona lo stack, scegli ** Aggiorna**, seleziona ** Usa modello corrente**, quindi imposta `MappingsKey` e `MappingsVersion` torna ai valori precedenti (ad esempio,`v1`).

**Utilizzando 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
```

Questo approccio basato sulle versioni offre il pieno controllo per avanzare o ripristinare le mappature delle applicazioni in base alle esigenze, mantenendo i file S3 come record definitivo di ogni versione di configurazione.

## Configurazione senza Route 53 (configurazione manuale)
<a name="application-custom-domain-without-route53"></a>

Se il tuo dominio è gestito da un provider DNS diverso da Route 53, puoi impostare reindirizzamenti URL amichevoli manualmente nella AWS Console di gestione. Questo approccio non utilizza Amazon S3 per le mappature: puoi gestire le coppie chiave-valore direttamente nella console. CloudFront 

**Per impostare un reindirizzamento URL intuitivo senza Route 53**

1. 

**Richiedi un certificato in ACM**

   1. Apri la console ACM all'indirizzo [ https://console.aws.amazon.com/acm/ ](https://console.aws.amazon.com/acm/) in the `us-east-1` Region.

   1. Scegli ** Richiedi certificato**.

   1. Per Nome di ** dominio**, inserisci `*.{{your-domain.com}}` (certificato wildcard).

   1. Per il metodo di ** convalida**, scegli la convalida ** DNS. **

   1. Scegli **Richiedi**.

   1. Nella pagina dei dettagli del certificato, annota il nome e il valore del record CNAME in Convalida del dominio. ** ** Crea questo record CNAME presso il tuo provider DNS per convalidare la proprietà del dominio.

   1. Attendi che lo stato del certificato passi a ** Emesso ** (in genere da 5 a 30 minuti dopo la creazione del record DNS).

1. 

**Crea un CloudFront KeyValueStore**

   1. Apri la CloudFront console all'indirizzo [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

   1. Nel riquadro di navigazione, seleziona **Funzioni**. Quindi scegli la ** KeyValueStores ** scheda.

   1. Scegli **Create KeyValueStore** (Crea).

   1. Inserisci un nome (ad esempio,`opensearch-ui-friendly-url-app-mappings-store`).

   1. Scegli **Create** (Crea).

   1. Dopo la creazione, scegli ** Modifica ** per aggiungere coppie chiave-valore. Per ogni applicazione, aggiungi una chiave (il nome del sottodominio, ad esempio`prod`) e un valore (l'URL completo dell'applicazione OpenSearch UI).

1. 

**Crea una funzione CloudFront**

   1. Apri la CloudFront console all'indirizzo [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

   1. Nel riquadro di navigazione, seleziona **Funzioni**.

   1. **Nella scheda ** Funzioni, scegli ** Crea funzione**.

   1. Inserisci un nome per la funzione (ad esempio,`opensearch-ui-friendly-url-redirect-function`).

   1. Per ** Runtime**, scegli ** ** cloudfront-js-2.0.

   1. Sostituisci il codice della funzione con quanto segue:

      ```
      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>'
            }
          };
        }
      }
      ```

      Sostituisci {{YOUR\_KVS\_ID}} con l'ID KeyValueStore che hai creato (visibile nella pagina dei KeyValueStore dettagli).

   1. Nelle ** KeyValueStore associazioni**, associa quelle KeyValueStore che hai creato.

   1. Scegli ** Salva modifiche ** e poi la funzione ** Pubblica**.

1. 

**Crea una CloudFront distribuzione**

   1. Nella CloudFront console, scegli ** Crea distribuzione**.

   1. Per il dominio ** Origin**, inserisci un dominio valido (ad esempio,`example.com`). L'origine non viene mai contattata perché la funzione restituisce una risposta prima di raggiungerla.

   1. In Comportamento ** predefinito della cache**, per i criteri del protocollo ** Viewer**, scegli ** Reindirizza HTTP a HTTPS. **

   1. Per ** la politica della cache**, scegli ** CachingDisabled**.

   1. In Associazioni di ** funzioni**, per la richiesta di ** Viewer**, seleziona la tua CloudFront funzione.

   1. In ** Impostazioni**, per Nomi di dominio ** alternativi (CNAME)**, inserisci. `*.{{your-domain.com}}`

   1. Per il certificato SSL ** personalizzato**, seleziona il certificato che hai creato in ACM.

   1. Scegli **Create Distribution** (Crea distribuzione).

   1. Annota il nome del dominio di distribuzione (ad esempio,`d1234abcdef8.cloudfront.net`).

1. 

**Configura il DNS presso il tuo provider**

   Nel tuo provider DNS, crea un record CNAME che punti `*.{{your-domain.com}}` al tuo nome di dominio di CloudFront distribuzione (ad esempio,). `d1234abcdef8.cloudfront.net`
**Nota**  
Alcuni provider DNS non supportano i record CNAME wildcard. In tal caso, crea singoli record CNAME per ogni sottodominio che desideri utilizzare (ad esempio,,). `prod.your-domain.com` `staging.your-domain.com`

### Aggiungere manualmente le mappature delle applicazioni
<a name="application-custom-domain-manual-add-apps"></a>

Per aggiungere nuove mappature delle applicazioni dopo la configurazione manuale iniziale:

1. Apri la CloudFront console all'indirizzo. [ https://console.aws.amazon.com/cloudfront/ ](https://console.aws.amazon.com/cloudfront/)

1. Nel riquadro di navigazione, seleziona **Funzioni**. Quindi scegli la ** KeyValueStores ** scheda.

1. Scegli il tuo KeyValueStore nome (ad esempio,`opensearch-ui-friendly-url-app-mappings-store`).

1. Scegli **Modifica**.

1. Scegli ** Aggiungi coppia**. Inserisci il nome del sottodominio come chiave e l'URL completo dell'applicazione OpenSearch UI come valore.

1. Scegli **Save changes** (Salva modifiche).

Il nuovo URL descrittivo è disponibile subito dopo il salvataggio.

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

Per rimuovere l'infrastruttura di reindirizzamento URL amichevole, esegui il seguente comando:

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

Questo comando rimuove la CloudFront distribuzione, la funzione KeyValueStore, il certificato ACM e il record DNS. Non influisce sulle applicazioni OpenSearch dell'interfaccia utente.

## Risoluzione dei problemi
<a name="application-custom-domain-troubleshooting"></a>

Il certificato ACM rimane valido `Pending validation`  
Assicurati che il DNS del tuo dominio sia correttamente delegato a Route 53 (o che tu abbia creato il CNAME di convalida presso il tuo provider DNS). `dig {{your-domain}} NS`Usalo per verificare i nameserver.

Il browser mostra un errore nel certificato  
Verifica che il certificato ACM copra il tuo dominio come wildcard ()`*.your-domain.com`. Il certificato deve essere nella Regione. `us-east-1`

404 Domanda non trovata  
Il sottodominio a cui stai tentando di accedere non ha una mappatura in. KeyValueStore Verifica che la chiave esista nel tuo file di mappatura e conferma di aver aggiornato lo stack (o aggiunto la coppia manualmente) dopo l'ultima modifica.

CloudFront la distribuzione mostra `Deploying` lo stato per più di 15 minuti  
CloudFront le distribuzioni possono richiedere fino a 15 minuti per essere distribuite a livello globale. Se la distribuzione richiede più tempo, controlla la CloudFront console per i dettagli dell'errore.

SourceARN è un errore inaccessibile durante la creazione dello stack  
Assicurati che la policy del bucket S3 conceda l'autorizzazione a leggere il file di mappatura. `cloudfront.amazonaws.com` Verifica inoltre il ruolo IAM di distribuzione dello stack e le autorizzazioni sul `s3:GetObject` `s3:HeadObject` bucket. `s3:GetBucketLocation`