Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Einrichtung einer benutzerfreundlichen URL für OpenSearch UI-Anwendungen (Self-Service)
<a name="application-custom-domain"></a>

OpenSearch UI-Anwendungen haben automatisch generierte URLs wie. `https://application-{{name}}-{{id}}.{{Region}}.opensearch.amazonaws.com` Diese URLs sind lang und schwer zu merken. Sie können eine benutzerfreundliche URL einrichten (z. B.`https://prod.example.com`). Diese URL leitet zu Ihrer Anwendung weiter, sodass Sie direkt auf Dashboards zugreifen können, ohne die AWS Management Console aufrufen zu müssen.

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

Diese Lösung wird verwendet CloudFront , um Anfragen von Ihrer benutzerfreundlichen URL an den Endpunkt Ihrer OpenSearch UI-Anwendung umzuleiten. Die Architektur besteht aus den folgenden Komponenten:
+ **ACM-Zertifikat ** — Bietet HTTPS-Verschlüsselung für Ihre benutzerfreundliche URL.
+ **CloudFront KeyValueStore**— Speichert die Zuordnung zwischen Subdomainnamen und Anwendungs-URLs.
+ **CloudFront Funktion ** — Liest die KeyValueStore und gibt eine 302-Weiterleitung an die richtige Anwendungs-URL zurück.
+ **CloudFront Verteilung ** — Stellt Ihre benutzerfreundliche URL mit TLS bereit und leitet Anfragen über die Funktion weiter.
+ **Route 53-DNS-Eintrag ** — Leitet deine freundliche URL an die CloudFront Distribution weiter.

Wenn Sie Ihre benutzerfreundliche URL aufrufen (z. B.`https://prod.example.com`), sucht die CloudFront Funktion nach der entsprechenden Anwendungs-URL und leitet Ihren Browser dorthin weiter. Die Anwendung wickelt die Authentifizierung direkt ab.

## Voraussetzungen
<a name="application-custom-domain-prerequisites"></a>
+ Eine oder mehrere OpenSearch UI-Anwendungen mit ihren Endpunkt-URLs.
+ Ein Domainname, den Sie besitzen (z. B.`example.com`).
+ Eine öffentlich gehostete Zone in Route 53 für Ihre Domain. Falls Sie noch keine haben, finden Sie weitere Informationen unter[Einrichtung ohne Route 53 (manuelle Konfiguration)](#application-custom-domain-without-route53).
+ Ein Amazon S3-Bucket zum Speichern der URL-Zuordnungsdatei Ihrer Anwendung.

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

Gehen Sie wie folgt vor, um die benutzerfreundliche URL-Weiterleitungsinfrastruktur mit einer CloudFormation Vorlage bereitzustellen.

**So richten Sie eine benutzerfreundliche URL für Ihre OpenSearch UI-Anwendungen ein**

1. Erstellen Sie eine JSON-Datei, die Ihre benutzerfreundlichen Namen den Anwendungs-URLs zuordnet. Jeder Schlüssel wird zu einer Subdomain (Schlüssel `prod` wird beispielsweise`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"}
     ]
   }
   ```

   Speichern Sie diese Datei als `opensearch-ui-friendly-url-app-mappings-v1.json`. Das `v1` Suffix identifiziert dies als die erste Version Ihrer Mappings. Sie erhöhen diese Version, wenn Sie Ihre Mappings aktualisieren.

1. Laden Sie die Zuordnungsdatei in einen Amazon S3-Bucket in Ihrem Konto hoch:

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

1. Erteilen Sie die CloudFront Erlaubnis, die Zuordnungsdatei zu lesen, indem Sie eine Bucket-Richtlinie hinzufügen. Ersetze {{your-bucket-name}} und {{your-account-id}} durch deine Werte:

   ```
   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}}"}}
       }]
     }'
   ```
**Anmerkung**  
Diese Bucket-Richtlinie ermöglicht CloudFront das Lesen der Zuordnungsdatei während der KeyValueStore Erstellung. Ohne sie schlägt die Stack-Bereitstellung mit der Fehlermeldung „SourceARN ist nicht zugänglich“ fehl.

1. Stellen Sie den CloudFormation Stack mithilfe einer der folgenden Optionen bereit:

   **Option 1: Stack starten (empfohlen) **

   Kopieren Sie die folgende URL und fügen Sie sie in Ihren Browser ein, um die AWS CloudFormation Schnellerstellungsseite mit der vorinstallierten Vorlage zu öffnen. Füllen Sie die Parameter aus und wählen Sie ** Stapel erstellen. **

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

   Ersetzen Sie die Platzhalterwerte durch Ihre eigenen:

   ```
   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. Wenn Sie die AWS CLI verwendet haben (Option 2), stellen Sie den Stack in der `us-east-1` Region bereit. CloudFront erfordert, dass ACM-Zertifikate vorhanden sind. `us-east-1` Ihre OpenSearch UI-Anwendungen können sich in allen [ unterstützten Regionen und Kontingenten für OpenSearch Benutzeroberflächen ](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/opensearch-ui-endpoints-quotas.html) befinden.

1. Warten Sie, bis der Stapel vollständig ist (ungefähr 15 Minuten). Sie können den Fortschritt überwachen:

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

1. Testen Sie die Weiterleitung. Öffnen Sie Ihren Browser und navigieren Sie zu`https://{{prod}}.{{your-domain.com}}`. Sie sollten zu Ihrer OpenSearch UI-Anwendung weitergeleitet werden.

   Sie können dies auch überprüfen mit`curl`:

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

### CloudFormation Quelle der Vorlage
<a name="application-custom-domain-template-source"></a>

Im Folgenden finden Sie die vollständige CloudFormation Vorlage, die vom Launch Stack-Link und dem CLI-Befehl oben verwendet wird. Sie können sie auch direkt von herunterladen`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)"
```

### Hinzufügen oder Entfernen von Anwendungen
<a name="application-custom-domain-add-apps"></a>

Um Anwendungszuordnungen hinzuzufügen, zu aktualisieren oder zu entfernen, erstellen Sie eine neue Version Ihrer S3-Zuordnungsdatei und aktualisieren Sie den Stack mit der neuen Version. Durch den versionierten Ansatz bleibt Ihre S3-Datei die Informationsquelle und Sie können jederzeit zu neuen Konfigurationen wechseln oder zu früheren Versionen zurückkehren.

1. Bearbeiten Sie Ihre Zuordnungsdatei, um Einträge hinzuzufügen oder zu entfernen. Speichern Sie sie mit einem inkrementierten Versionssuffix (z. B.). `opensearch-ui-friendly-url-app-mappings-v2.json`

1. Laden Sie die neue Version auf S3 hoch:

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

1. Aktualisiere den Stack mit der neuen `MappingsKey` und`MappingsVersion`:

   **Mithilfe der Konsole: ** Öffnen Sie die [CloudFormation Konsole](https://console.aws.amazon.com/cloudformation/), wählen Sie Ihren Stack aus, wählen Sie ** Aktualisieren ** und dann Aktuelle Vorlage ** ** verwenden aus und aktualisieren Sie dann die `MappingsVersion` Parameter `MappingsKey` und mit den neuen Werten.

   **Verwenden der 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
   ```

**Wichtig**  
Sie müssen den `MappingsVersion` Parameter jedes Mal ändern, wenn Sie Zuordnungen aktualisieren. Die Version bestimmt den KeyValueStore Namen, was CloudFormation dazu führt, dass der durch die aktualisierten KeyValueStore Daten ersetzt wird. Halten Sie aus Gründen der Übersichtlichkeit den `MappingsKey` Dateinamen synchron (z. B. `...-v2.json` mit`MappingsVersion=v2`). `MappingsVersion`

Um zu einer früheren Version zurückzukehren, aktualisieren Sie den Stapel, der auf die frühere Datei und Version verweist.

**Mithilfe der Konsole: ** Öffnen Sie die [CloudFormation Konsole](https://console.aws.amazon.com/cloudformation/), wählen Sie Ihren Stack aus, wählen Sie „**Aktualisieren**“ und dann „Aktuelle Vorlage ** ** verwenden“ aus. Stellen Sie dann die Werte ein `MappingsKey` und `MappingsVersion` kehren Sie zu den vorherigen Werten zurück (z. B.`v1`).

**Verwenden der 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
```

Dieser versionierte Ansatz gibt Ihnen die volle Kontrolle darüber, ob Sie Ihre Anwendungszuordnungen nach Bedarf weiterleiten oder rückgängig machen können, während Ihre S3-Dateien als definitiver Datensatz für jede Konfigurationsversion beibehalten werden.

## Einrichtung ohne Route 53 (manuelle Konfiguration)
<a name="application-custom-domain-without-route53"></a>

Wenn Ihre Domain von einem anderen DNS-Anbieter als Route 53 verwaltet wird, können Sie benutzerfreundliche URL-Weiterleitungen manuell in der AWS Management Console einrichten. Bei diesem Ansatz wird Amazon S3 nicht für Zuordnungen verwendet — Sie verwalten Schlüssel-Wert-Paare direkt in der Konsole. CloudFront 

**Um eine benutzerfreundliche URL-Weiterleitung ohne Route 53 einzurichten**

1. 

**Fordern Sie ein Zertifikat in ACM an**

   1. Öffnen Sie die ACM-Konsole [ https://console.aws.amazon.com/acm/ ](https://console.aws.amazon.com/acm/) in der `us-east-1` Region.

   1. Wählen Sie Zertifikat ** ** anfordern.

   1. Geben Sie als ** Domainname ** `*.{{your-domain.com}}` (Wildcard-Zertifikat) ein.

   1. Wählen Sie als ** Validierungsmethode ** die Option ** DNS-Validierung ** aus.

   1. Wählen Sie **Anfrage** aus.

   1. Notieren Sie sich auf der Seite mit den Zertifikatsdetails den Namen und den Wert des CNAME-Eintrags unter ** Domainvalidierung**. Erstellen Sie diesen CNAME-Eintrag bei Ihrem DNS-Anbieter, um den Domainbesitz zu überprüfen.

   1. Warten Sie, bis der Zertifikatsstatus auf ** Ausgestellt geändert wird ** (in der Regel 5 bis 30 Minuten nach der Erstellung des DNS-Eintrags).

1. 

**Erstellen Sie eine CloudFront KeyValueStore**

   1. Öffnen Sie die CloudFront Konsole unter [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

   1. Wählen Sie im Navigationsbereich **Funktionen** aus. Wählen Sie dann den ** KeyValueStores ** Tab.

   1. Wählen Sie **Erstellen KeyValueStore** aus.

   1. Geben Sie einen Namen ein (z. B.`opensearch-ui-friendly-url-app-mappings-store`).

   1. Wählen Sie **Erstellen** aus.

   1. Wählen Sie nach der Erstellung ** Bearbeiten, ** um Schlüssel-Wert-Paare hinzuzufügen. Fügen Sie für jede Anwendung einen Schlüssel (den Subdomainnamen, z. B.`prod`) und einen Wert (die vollständige URL der OpenSearch UI-Anwendung) hinzu.

1. 

**Erstellen Sie eine Funktion CloudFront**

   1. Öffnen Sie die CloudFront Konsole unter [ https://console.aws.amazon.com/cloudfront/](https://console.aws.amazon.com/cloudfront/).

   1. Wählen Sie im Navigationsbereich **Funktionen** aus.

   1. Wählen Sie auf der ** Registerkarte ** Funktionen die Option Funktion ** erstellen aus**.

   1. Geben Sie einen Namen für die Funktion ein (z. B.`opensearch-ui-friendly-url-redirect-function`).

   1. Wählen Sie für ** Runtime ** ** ** cloudfront-js-2.0.

   1. Ersetzen Sie den Funktionscode durch Folgendes:

      ```
      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}}Ersetzen Sie ihn durch die ID des von KeyValueStore Ihnen erstellten (sichtbar auf der KeyValueStore Detailseite).

   1. Ordnen KeyValueStore Sie die von Ihnen erstellten ** KeyValueStore Verknüpfungen in Verknüpfungen ** zu.

   1. Wählen Sie Änderungen ** speichern ** und dann die Funktion ** Veröffentlichen**.

1. 

**Erstellen Sie eine CloudFront Distribution**

   1. Wählen Sie in der CloudFront Konsole ** Create distribution aus**.

   1. Geben Sie für die ** Ursprungsdomäne ** eine beliebige gültige Domäne ein (z. B.`example.com`). Der Ursprung wird nie kontaktiert, da die Funktion eine Antwort zurückgibt, bevor sie ihn erreicht hat.

   1. Wählen Sie unter ** ** Standard-Cacheverhalten für ** Viewer-Protokollrichtlinie die ** Option HTTP zu HTTPS ** umleiten aus**.

   1. Wählen Sie für ** Cache-Richtlinie ** ** CachingDisabled**.

   1. Wählen Sie unter ** Funktionszuordnungen ** für ** Viewer-Anfrage ** Ihre CloudFront Funktion aus.

   1. Geben ** `*.{{your-domain.com}}` Sie unter Einstellungen ** für ** Alternative Domainnamen (CNAMES) ** den Wert ein.

   1. Wählen Sie für ** Benutzerdefiniertes SSL-Zertifikat das Zertifikat aus**, das Sie in ACM erstellt haben.

   1. Wählen Sie **Create distribution** (Distribution erstellen) aus.

   1. Notieren Sie sich den Namen der Vertriebsdomäne (z. B.`d1234abcdef8.cloudfront.net`).

1. 

**Konfigurieren Sie DNS bei Ihrem Anbieter**

   Erstellen Sie bei Ihrem DNS-Anbieter einen CNAME-Eintrag, der `*.{{your-domain.com}}` auf Ihren CloudFront Vertriebsdomänennamen verweist (z. B.`d1234abcdef8.cloudfront.net`).
**Anmerkung**  
Einige DNS-Anbieter unterstützen keine CNAME-Einträge mit Platzhaltern. Erstellen Sie in diesem Fall individuelle CNAME-Einträge für jede Subdomain, die Sie verwenden möchten (z. B.,). `prod.your-domain.com` `staging.your-domain.com`

### Manuelles Hinzufügen von Anwendungszuordnungen
<a name="application-custom-domain-manual-add-apps"></a>

So fügen Sie nach der manuellen Erstkonfiguration neue Anwendungszuordnungen hinzu:

1. Öffnen Sie die CloudFront Konsole unter. [ https://console.aws.amazon.com/cloudfront/ ](https://console.aws.amazon.com/cloudfront/)

1. Wählen Sie im Navigationsbereich **Funktionen** aus. Wählen Sie dann den ** KeyValueStores ** Tab.

1. Wählen Sie Ihren KeyValueStore Namen (zum Beispiel`opensearch-ui-friendly-url-app-mappings-store`).

1. Wählen Sie **Bearbeiten** aus.

1. Wählen ** Sie Paar hinzufügen**. Geben Sie den Subdomainnamen als Schlüssel und die vollständige URL der OpenSearch UI-Anwendung als Wert ein.

1. Wählen Sie **Änderungen speichern ** aus.

Die neue benutzerfreundliche URL ist sofort nach dem Speichern verfügbar.

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

Führen Sie den folgenden Befehl aus, um die Infrastruktur für benutzerfreundliche URL-Weiterleitungen zu entfernen:

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

Mit diesem Befehl werden die CloudFront Verteilung, die Funktion KeyValueStore, das ACM-Zertifikat und der DNS-Eintrag entfernt. Es hat keine Auswirkungen auf Ihre OpenSearch UI-Anwendungen.

## Fehlerbehebung
<a name="application-custom-domain-troubleshooting"></a>

Das ACM-Zertifikat verbleibt in `Pending validation`  
Stellen Sie sicher, dass das DNS Ihrer Domain ordnungsgemäß an Route 53 delegiert wurde (oder dass Sie den Validierungs-CNAME bei Ihrem DNS-Anbieter erstellt haben). Wird verwendet`dig {{your-domain}} NS`, um die Nameserver zu verifizieren.

Der Browser zeigt einen Zertifikatsfehler an  
Stellen Sie sicher, dass das ACM-Zertifikat Ihre Domain als Platzhalter () `*.your-domain.com` abdeckt. Das Zertifikat muss sich in der `us-east-1` Region befinden.

404-Anwendung wurde nicht gefunden  
Die Subdomain, auf die Sie zugreifen möchten, hat keine Zuordnung in der KeyValueStore. Vergewissern Sie sich, dass der Schlüssel in Ihrer Zuordnungsdatei vorhanden ist, und bestätigen Sie, dass Sie den Stack nach Ihrer letzten Änderung aktualisiert (oder das Paar manuell hinzugefügt) haben.

CloudFront Die Verteilung zeigt `Deploying` den Status länger als 15 Minuten an  
CloudFront Die globale Bereitstellung von Distributionen kann bis zu 15 Minuten dauern. Wenn die Bereitstellung länger dauert, überprüfen Sie die CloudFront Konsole auf Fehlerdetails.

Fehler bei der Stack-Erstellung: SourceARN ist nicht zugänglich  
Stellen Sie sicher, dass die S3-Bucket-Richtlinie die `cloudfront.amazonaws.com` Berechtigung zum Lesen der Zuordnungsdatei gewährt. Stellen Sie außerdem sicher, dass die IAM-Rolle, die den Stack bereitstellt `s3:GetObject``s3:HeadObject`, über `s3:GetBucketLocation` Berechtigungen für den Bucket verfügt.