Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Configuration d'une URL conviviale pour les applications d' OpenSearch interface utilisateur (libre-service)
<a name="application-custom-domain"></a>

OpenSearch Les applications d'interface utilisateur ont des URL générées automatiquement, telles que`https://application-{{name}}-{{id}}.{{Region}}.opensearch.amazonaws.com`. Ces URL sont longues et difficiles à mémoriser. Vous pouvez configurer une URL conviviale (telle que`https://prod.example.com`). Cette URL redirige vers votre application afin que vous puissiez accéder directement aux tableaux de bord sans avoir à passer par la AWS console de gestion.

## Comment ça marche
<a name="application-custom-domain-overview"></a>

Cette solution permet CloudFront de rediriger les demandes de votre URL conviviale vers le point de terminaison de votre application d' OpenSearch interface utilisateur. L'architecture comprend les éléments suivants :
+ **Certificat ACM ** : fournit un cryptage HTTPS pour votre URL conviviale.
+ **CloudFront KeyValueStore**— Stocke le mappage entre les noms de sous-domaines et les URL des applications.
+ **CloudFront fonction ** — Lit KeyValueStore et renvoie une redirection 302 vers l'URL correcte de l'application.
+ **CloudFront distribution ** — Fournit à votre URL conviviale le protocole TLS et achemine les demandes via cette fonction.
+ **Enregistrement DNS Route 53 ** : pointe votre URL conviviale vers la CloudFront distribution.

Lorsque vous visitez votre URL conviviale (par exemple`https://prod.example.com`), la CloudFront fonction recherche l'URL de l'application correspondante et redirige votre navigateur vers celle-ci. L'application gère directement l'authentification.

## Conditions préalables
<a name="application-custom-domain-prerequisites"></a>
+ Une ou plusieurs applications d' OpenSearch interface utilisateur avec leurs URL de point de terminaison.
+ Un nom de domaine dont vous êtes propriétaire (par exemple,`example.com`).
+ Une zone hébergée publique dans Route 53 pour votre domaine. Si vous n'en avez pas, pour plus d'informations, consultez[Configuration sans Route 53 (configuration manuelle)](#application-custom-domain-without-route53).
+ Un compartiment Amazon S3 pour stocker le fichier de mappage d'URL de votre application.

## Déployez en utilisant AWS CloudFormation
<a name="application-custom-domain-deploy-cfn"></a>

Utilisez la procédure suivante pour déployer l'infrastructure conviviale de redirection d'URL à l'aide d'un CloudFormation modèle.

**Pour configurer une URL conviviale pour vos applications d' OpenSearch interface utilisateur**

1. Créez un fichier JSON qui associe vos noms conviviaux aux URL des applications. Chaque clé devient un sous-domaine (par exemple, la clé `prod` devient`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"}
     ]
   }
   ```

   Enregistrez ce fichier en tant que `opensearch-ui-friendly-url-app-mappings-v1.json`. Le `v1` suffixe indique qu'il s'agit de la première version de vos mappages. Vous incrémentez cette version lorsque vous mettez à jour vos mappages.

1. Téléchargez le fichier de mappages dans un compartiment Amazon S3 de votre compte :

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

1. Accordez CloudFront l'autorisation de lire le fichier de mappages en ajoutant une politique de compartiment. Remplacez {{your-bucket-name}} et {{your-account-id}} par vos valeurs :

   ```
   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}}"}}
       }]
     }'
   ```
**Note**  
Cette politique de compartiment permet CloudFront de lire le fichier de mappages lors de sa KeyValueStore création. Sans cela, le déploiement de la pile échoue et le message d'erreur « SourceARN est inaccessible » s'affiche.

1. Déployez la CloudFormation pile à l'aide de l'une des options suivantes :

   **Option 1 : Launch Stack (recommandé) **

   Copiez l'URL suivante et collez-la dans votre navigateur pour ouvrir la page de AWS CloudFormation création rapide avec le modèle préchargé. Renseignez les paramètres et choisissez ** Créer une pile**.

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

   **Option 2 : AWS CLI **

   Remplacez les valeurs des espaces réservés par les vôtres :

   ```
   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 vous avez utilisé l' AWS interface de ligne de commande (option 2), déployez la pile dans la `us-east-1` région. CloudFront nécessite la présence de certificats ACM. `us-east-1` Vos applications d' OpenSearch interface utilisateur peuvent se trouver dans n'importe quelle région [ prise en charge et avoir des quotas pour l' OpenSearch interface utilisateur](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/opensearch-ui-endpoints-quotas.html).

1. Attendez que la pile soit complète (environ 15 minutes). Vous pouvez suivre les progrès :

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

1. Testez la redirection. Ouvrez votre navigateur et accédez à`https://{{prod}}.{{your-domain.com}}`. Vous devriez être redirigé vers votre application d' OpenSearch interface utilisateur.

   Vous pouvez également vérifier auprès de `curl` :

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

### CloudFormation source du modèle
<a name="application-custom-domain-template-source"></a>

Voici le CloudFormation modèle complet utilisé par le lien Launch Stack et la commande CLI ci-dessus. Vous pouvez également le télécharger directement depuis`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)"
```

### Ajouter ou supprimer des applications
<a name="application-custom-domain-add-apps"></a>

Pour ajouter, mettre à jour ou supprimer des mappages d'applications, créez une nouvelle version de votre fichier de mappages S3 et mettez à jour la pile avec la nouvelle version. L'approche versionnée permet de conserver votre fichier S3 comme source de référence et vous permet de passer à de nouvelles configurations ou de revenir aux versions précédentes à tout moment.

1. Modifiez votre fichier de mappages pour ajouter ou supprimer des entrées. Enregistrez-le avec un suffixe de version incrémenté (par exemple,`opensearch-ui-friendly-url-app-mappings-v2.json`).

1. Téléchargez la nouvelle version sur 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. Mettez à jour la pile avec la nouvelle `MappingsKey` et `MappingsVersion` :

   **À l'aide de la console : ** ouvrez la [CloudFormation console](https://console.aws.amazon.com/cloudformation/), sélectionnez votre pile, choisissez ** Mettre à jour**, sélectionnez ** Utiliser le modèle actuel**, puis mettez à jour les `MappingsVersion` paramètres `MappingsKey` et avec les nouvelles valeurs.

   **À l'aide 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
   ```

**Important**  
Vous devez modifier le `MappingsVersion` paramètre chaque fois que vous mettez à jour des mappages. La version détermine le KeyValueStore nom, ce qui déclenche le remplacement CloudFormation de celui-ci par KeyValueStore les données mises à jour. Conservez le nom du `MappingsKey` fichier et `MappingsVersion` synchronisez-le (par exemple, `...-v2.json` avec`MappingsVersion=v2`) pour plus de clarté.

Pour revenir à une version précédente, mettez à jour la pile pointant vers le fichier et la version antérieurs.

[**À l'aide de la CloudFormation console : ** ouvrez la console](https://console.aws.amazon.com/cloudformation/), sélectionnez votre pile, choisissez ** Mettre à jour ****, sélectionnez ** Utiliser le modèle actuel, `MappingsKey` puis `MappingsVersion` revenez aux valeurs précédentes (par exemple,`v1`).

**À l'aide 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
```

Cette approche versionnée vous donne le contrôle total pour avancer ou annuler les mappages de vos applications selon vos besoins, tout en conservant vos fichiers S3 comme enregistrement définitif de chaque version de configuration.

## Configuration sans Route 53 (configuration manuelle)
<a name="application-custom-domain-without-route53"></a>

Si votre domaine est géré par un fournisseur DNS autre que Route 53, vous pouvez configurer manuellement des redirections d'URL conviviales dans la console AWS de gestion. Cette approche n'utilise pas Amazon S3 pour les mappages : vous gérez les paires clé-valeur directement dans la console. CloudFront 

**Pour configurer une redirection d'URL conviviale sans Route 53**

1. 

**Demandez un certificat dans ACM**

   1. Ouvrez la console ACM à l'adresse [ https://console.aws.amazon.com/acm/ ](https://console.aws.amazon.com/acm/) In the `us-east-1` Region.

   1. Choisissez ** Demander un certificat**.

   1. Dans le ** champ Nom de domaine**, saisissez `*.{{your-domain.com}}` (certificat générique).

   1. Pour Méthode ** de validation**, choisissez Validation ** DNS**.

   1. Cliquez sur **Demander**.

   1. Sur la page des détails du certificat, notez le nom et la valeur de l'enregistrement CNAME sous Validation ** ** du domaine. Créez cet enregistrement CNAME auprès de votre fournisseur DNS pour valider la propriété du domaine.

   1. Attendez que le statut du certificat passe à ** Émis ** (généralement 5 à 30 minutes après la création de l'enregistrement DNS).

1. 

**Créez un CloudFront KeyValueStore**

   1. Ouvrez la CloudFront console à l'adresse [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

   1. Dans le volet de navigation, choisissez **Fonctions**. Choisissez ensuite l'**KeyValueStores**onglet.

   1. Choisissez **Créer KeyValueStore**.

   1. Entrez un nom (par exemple,`opensearch-ui-friendly-url-app-mappings-store`).

   1. Choisissez **Créer**.

   1. Après la création, choisissez ** Modifier ** pour ajouter des paires clé-valeur. Pour chaque application, ajoutez une clé (le nom du sous-domaine, par exemple`prod`) et une valeur (l'URL complète de l'application d' OpenSearch interface utilisateur).

1. 

**Création d'une CloudFront fonction**

   1. Ouvrez la CloudFront console à l'adresse [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

   1. Dans le volet de navigation, choisissez **Fonctions**.

   1. Dans l'**onglet ** Fonctions, choisissez ** Créer une fonction**.

   1. Entrez un nom pour la fonction (par exemple,`opensearch-ui-friendly-url-redirect-function`).

   1. Pour ** Runtime**, choisissez ** ** cloudfront-js-2.0.

   1. Remplacez le code de fonction par le code suivant :

      ```
      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}}Remplacez-le par l'ID KeyValueStore que vous avez créé (visible sur la page de KeyValueStore détails).

   1. Dans ** KeyValueStore les associations**, associez celles que KeyValueStore vous avez créées.

   1. Choisissez ** Enregistrer les modifications, ** puis fonction de ** publication**.

1. 

**Création d'une CloudFront distribution**

   1. Dans la CloudFront console, choisissez ** Créer une distribution**.

   1. Pour Domaine ** d'origine**, entrez n'importe quel domaine valide (par exemple,`example.com`). L'origine n'est jamais contactée car la fonction renvoie une réponse avant de l'atteindre.

   1. Dans Comportement du cache ** par défaut**, pour Politique du protocole ** Viewer**, choisissez ** Rediriger HTTP vers HTTPS**.

   1. Pour Politique de ** cache**, choisissez ** CachingDisabled**.

   1. Dans Associations de ** fonctions**, pour la requête ** Viewer**, sélectionnez votre CloudFront fonction.

   1. Dans ** Paramètres**, dans la ** zone Noms de domaine alternatifs (CNAME)**, entrez`*.{{your-domain.com}}`.

   1. Pour le certificat SSL ** personnalisé**, sélectionnez le certificat que vous avez créé dans ACM.

   1. Choisissez **Créer une distribution**.

   1. Notez le nom du domaine de distribution (par exemple,`d1234abcdef8.cloudfront.net`).

1. 

**Configurez le DNS chez votre fournisseur**

   Chez votre fournisseur DNS, créez un enregistrement CNAME qui pointe `*.{{your-domain.com}}` vers votre nom de domaine de CloudFront distribution (par exemple,`d1234abcdef8.cloudfront.net`).
**Note**  
Certains fournisseurs DNS ne prennent pas en charge les enregistrements CNAME génériques. Dans ce cas, créez des enregistrements CNAME individuels pour chaque sous-domaine que vous souhaitez utiliser (par exemple`prod.your-domain.com`,`staging.your-domain.com`).

### Ajouter manuellement des mappages d'applications
<a name="application-custom-domain-manual-add-apps"></a>

Pour ajouter de nouveaux mappages d'applications après la configuration manuelle initiale :

1. Ouvrez la CloudFront console à l'adresse [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

1. Dans le volet de navigation, choisissez **Fonctions**. Choisissez ensuite l'**KeyValueStores**onglet.

1. Choisissez votre KeyValueStore nom (par exemple,`opensearch-ui-friendly-url-app-mappings-store`).

1. Choisissez **Modifier**.

1. Choisissez ** Ajouter une paire**. Entrez le nom du sous-domaine comme clé et l'URL complète de l'application d' OpenSearch interface utilisateur comme valeur.

1. Sélectionnez **Enregistrer les modifications**.

La nouvelle URL conviviale est disponible immédiatement après l'enregistrement.

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

Pour supprimer l'infrastructure conviviale de redirection d'URL, exécutez la commande suivante :

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

Cette commande supprime la CloudFront distribution, la fonction KeyValueStore, le certificat ACM et l'enregistrement DNS. Cela n'affecte pas vos applications d' OpenSearch interface utilisateur.

## Résolution des problèmes
<a name="application-custom-domain-troubleshooting"></a>

Le certificat ACM reste valide `Pending validation`  
Assurez-vous que le DNS de votre domaine est correctement délégué à Route 53 (ou que vous avez créé le CNAME de validation auprès de votre fournisseur DNS). Utilisez-le `dig {{your-domain}} NS` pour vérifier les serveurs de noms.

Le navigateur affiche une erreur de certificat  
Vérifiez que le certificat ACM couvre votre domaine en tant que caractère générique ()`*.your-domain.com`. Le certificat doit être délivré dans la `us-east-1` région.

404 Application introuvable  
Le sous-domaine auquel vous essayez d'accéder ne possède pas de mappage dans le KeyValueStore. Vérifiez que la clé existe dans votre fichier de mappages et confirmez que vous avez mis à jour la pile (ou que vous avez ajouté la paire manuellement) après votre dernière modification.

CloudFront la distribution affiche `Deploying` le statut pendant plus de 15 minutes  
CloudFront le déploiement des distributions dans le monde peut prendre jusqu'à 15 minutes. Si le déploiement prend plus de temps, consultez la CloudFront console pour obtenir des informations sur les erreurs.

Erreur SourceArn est inaccessible lors de la création de la pile  
Assurez-vous que la politique de compartiment S3 `cloudfront.amazonaws.com` autorise la lecture du fichier de mappages. Vérifiez également que le rôle IAM déployant la pile possède `s3:GetObject``s3:HeadObject`, et `s3:GetBucketLocation` les autorisations sur le bucket.