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.
# HTTPS-Listener für Ihren Classic Load Balancer
Sie können einen Load Balancer erstellen, der das SSL/TLS Protokoll für verschlüsselte Verbindungen verwendet (auch bekannt als *SSL-Offload*). Diese Funktion ermöglicht die Verschlüsselung des Datenverkehrs zwischen Ihrem Load Balancer und den Clients, welche die HTTPS-Sitzungen starten, sowie für Verbindungen zwischen Ihrem Load Balancer und Ihren EC2-Instances.
Elastic Load Balancing verwendet Secure Sockets Layer (SSL)-Aushandlungskonfigurationen, auch bekannt als *Sicherheitsrichtlinien*, um Verbindungen zwischen Clients und dem Load Balancer zu verhandeln. Wenn Sie es HTTPS/SSL für Ihre Front-End-Verbindungen verwenden, können Sie entweder eine vordefinierte Sicherheitsrichtlinie oder eine benutzerdefinierte Sicherheitsrichtlinie verwenden. Sie müssen ein SSL-Zertifikat auf dem Load Balancer bereitstellen. Der Load Balancer verwendet dieses Zertifikat, um die Verbindung zu beenden und dann Anfragen von Clients zu entschlüsseln, bevor er sie an die Instances sendet. Der Load Balancer verwendet eine statische Verschlüsselungssammlung für Backend-Verbindungen. Sie können optional festlegen, dass Authentifizierung auf Ihren Instances aktiviert wird.
Classic Load Balancers unterstützt keine Servernamensanzeige (Server Name Indication, SNI) auf Ihrem Load Balancer. Sie können stattdessen eine der folgenden Alternativen verwenden:
+ Stellen Sie ein Zertifikat auf dem Load Balancer bereit und fügen Sie für jede weitere Website einen Subject Alternative Name (SAN) hinzu. SANs ermöglicht es Ihnen, mehrere Hostnamen mit einem einzigen Zertifikat zu schützen. Erkundigen Sie sich bei Ihrem Zertifikatsanbieter nach weiteren Informationen darüber, wie viele Zertifikate pro Zertifikat unterstützt werden und wie Sie SANs diese hinzufügen und entfernen können SANs.
+ Verwenden Sie TCP-Listener an Port 443 für die Frontend- und Backend-Verbindungen. Der Load Balancer leitet die Anforderung im aktuellen Zustand weiter, sodass Sie die HTTPS-Beendigung auf der EC2-Instance verarbeiten können.
Classic Load Balancer unterstützen keine gegenseitige TLS-Authentifizierung (mTLS). Für mTLS-Unterstützung erstellen Sie einen TCP-Listener. Der Load Balancer leitet die Anforderung unverändert weiter, sodass Sie mTLS auf der EC2-Instance implementieren können.
**Topics**
+ [SSL-/TLS-Zertifikate](ssl-server-cert.md)
+ [SSL-Aushandlungskonfigurationen](elb-ssl-security-policy.md)
+ [Vordefinierte SSL-Sicherheitsrichtlinien](elb-security-policy-table.md)
+ [Erstellen eines HTTPS-Load-Balancers](elb-create-https-ssl-load-balancer.md)
+ [Konfigurieren eines HTTPS-Listeners](elb-add-or-delete-listeners.md)
+ [Ersetzen des SSL-Zertifikats](elb-update-ssl-cert.md)
+ [Aktualisieren der SSL-Aushandlungskonfiguration](ssl-config-update.md)
# SSL/TLS-Zertifikate für Classic Load Balancer
Wenn Sie HTTPS (SSL oder TLS) für Ihre Frontend-Listener verwenden, müssen Sie ein SSL/TLS-Zertifikat auf dem Load Balancer bereitstellen. Der Load Balancer verwendet das Zertifikat, um die Verbindung zu beenden und dann Anfragen von Clients zu entschlüsseln, bevor er sie an die Instances sendet.
Die SSL- und TLS-Protokolle verwenden ein X.509-Zertifikat (SSL/TLS-Serverzertifikat) zum Authentifizieren von Client und Backend-Anwendung. Ein X.509-Zertifikat ist eine digitale Form der Identifikation, die von einer Zertifizierungsstelle (CA) ausgestellt wurde und Informationen zur Identifizierung, einer Gültigkeitsdauer, einen öffentlichen Schlüssel, einer Seriennummer und die digitale Signatur des Ausstellers enthält.
Sie können ein Zertifikat mit AWS Certificate Manager oder einem Tool erstellen, das die SSL- und TLS-Protokolle unterstützt, z. B. OpenSSL. Sie legen dieses Zertifikat beim Erstellen oder Aktualisieren eines HTTPS-Listeners für Ihren Load Balancer fest. Wenn Sie ein Zertifikat zur Verwendung mit Ihrem Load Balancer erstellen, müssen Sie einen Domainnamen angeben.
Wenn Sie ein Zertifikat zur Verwendung mit Ihrem Load Balancer erstellen, müssen Sie einen Domainnamen angeben. Der Domainname auf dem Zertifikat muss mit dem Datensatz für den benutzerdefinierten Domainnamen übereinstimmen. Wenn sie nicht übereinstimmen, wird der Datenverkehr nicht verschlüsselt, da die TLS-Verbindung nicht verifiziert werden kann.
Sie müssen einen vollqualifizierten Domainnamen (Fully Qualified Domain Name, FQDN) für Ihr Zertifikat wie `www.example.com` oder einen Apex-Domainnamen wie `example.com` angeben. Sie können auch ein Sternchen (\$1) als Platzhalter verwenden, um mehrere Websitenamen in derselben Domain zu schützen. Wenn Sie ein Platzhalter-Zertifikat anfordern, muss sich das Sternchen (\$1) ganz links im Domainnamen befinden und es kann nur eine Subdomain-Ebene geschützt werden. `*.example.com` schützt beispielsweise `corp.example.com` und `images.example.com`, aber es kann `test.login.example.com` nicht schützen. Beachten Sie außerdem, dass `*.example.com` nur die Subdomains von `example.com` schützt, jedoch nicht die „Bare“- oder „Apex“-Domain (`example.com`). Der Platzhaltername wird im Feld **Subject** (Betreff) und in der Erweiterung **Subject Alternative Name** (Alternativer Name des Betreffs) des Zertifikats angezeigt. Weitere Informationen zum Anfordern öffentlicher Zertifikate finden Sie unter [Anfordern eines öffentlichen Zertifikats](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html#request-public-console) im *AWS Certificate Manager -Benutzerhandbuch*.
## Erstellen oder importieren Sie ein SSL/TLS Zertifikat mit AWS Certificate Manager
Wir empfehlen, dass Sie AWS Certificate Manager (ACM) verwenden, um Zertifikate für Ihren Load Balancer zu erstellen oder zu importieren. ACM lässt sich in Elastic Load Balancing integrieren, sodass Sie das Zertifikat in Ihrem Load Balancer bereitstellen können. Um ein Zertifikat auf dem Load Balancer bereitzustellen, muss sich das Zertifikat in derselben Region wie der Load Balancer befinden. Weitere Informationen finden Sie unter [Anfordern eines öffentlichen Zertifikats](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html) oder [Importieren von Zertifikaten](https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html) im *AWS Certificate Manager -Benutzerhandbuch*.
Um einem Benutzer die Bereitstellung des Zertifikats auf Ihrem Load Balancer mithilfe der AWS-Managementkonsole zu ermöglichen, müssen Sie den Zugriff auf die ACM `ListCertificates`-API-Aktion erlauben. Weitere Informationen finden Sie unter [Auflisten von Zertifikaten](https://docs.aws.amazon.com/acm/latest/userguide/security_iam_id-based-policy-examples.html#policy-list-certificates) im *AWS Certificate Manager -Benutzerhandbuch*.
**Wichtig**
Sie können Zertifikate mit 4096-Bit-RSA-Schlüsseln oder EC-Schlüsseln nicht durch Integration in ACM auf Ihrem Load Balancer installieren. Sie müssen Zertifikate mit 4096-Bit-RSA-Schlüsseln oder EC-Schlüsseln zu IAM hochladen, um sie mit Ihrem Load Balancer verwenden zu können.
## Importieren Sie ein SSL/TLS Zertifikat mit IAM
Wenn Sie ACM nicht verwenden, können Sie SSL/TLS Tools wie OpenSSL verwenden, um eine Certificate Signing Request (CSR) zu erstellen, die CSR von einer CA signieren zu lassen, um ein Zertifikat zu erstellen, und das Zertifikat in IAM hochzuladen. Weitere Informationen finden Sie unter [Arbeiten mit Serverzertifikaten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html) im *IAM-Benutzerhandbuch*.
# SSL-Aushandlungskonfigurationen für Classic Load Balancer
Elastic Load Balancing verwendet eine Secure Socket Layer (SSL)-Aushandlungskonfiguration, die als *Sicherheitsrichtlinie* bezeichnet wird, um SSL-Verbindungen zwischen einem Client und dem Load Balancer auszuhandeln. Eine Sicherheitsrichtlinie ist eine Kombination von SSL-Protokollen, SSL-Verschlüsselung und der Präferenz für die Serverreihenfolge. Weitere Informationen über die Konfiguration einer SSL-Verbindung für Ihren Load Balancer finden Sie unter [Listener für Ihren Classic Load Balancer](elb-listener-config.md).
**Topics**
+ [Sicherheitsrichtlinien](#security-policy-types)
+ [SSL-Protokolle](#ssl-protocols)
+ [Präferenz für die Serverreihenfolge](#server-order-preference)
+ [SSL-Verschlüsselungsverfahren](#ssl-ciphers)
+ [Cipher Suite für Back-End-Verbindungen](#elb-backend-cipher-suite)
## Sicherheitsrichtlinien
Eine Sicherheitsrichtlinie bestimmt, welche Verschlüsselungen und Protokolle während der SSL-Aushandlungen zwischen einem Client und einem Load Balancer unterstützt werden. Sie können Ihre Classic Load Balancer so konfigurieren, dass sie entweder vordefinierte oder benutzerdefinierte Sicherheitsrichtlinien verwenden.
Beachten Sie, dass ein von AWS Certificate Manager (ACM) bereitgestelltes Zertifikat einen öffentlichen RSA-Schlüssel enthält. Daher müssen Sie eine Cipher Suite (Verschlüsselungssammlung) zu Ihrer Sicherheitsrichtlinie hinzufügen, die RSA verwendet, wenn Sie ein Zertifikat von ACM verwenden, da andernfalls die TLS-Verbindung fehlschlägt.
**Vordefinierte Sicherheitsrichtlinien**
Die Namen der neuesten vordefinierten Sicherheitsrichtlinien enthalten Informationen basierend auf dem Jahr und Monat, in dem sie veröffentlicht wurden. Die vordefinierte Standardsicherheitsrichtlinie ist beispielsweise `ELBSecurityPolicy-2016-08`. Jedes Mal, wenn eine neue vordefinierte Sicherheitsrichtlinie veröffentlicht wird, können Sie Ihre Konfiguration aktualisieren, um diese zu verwenden.
Weitere Informationen über die Protokolle und Verschlüsselungen für die vordefinierten Sicherheitsrichtlinien finden Sie unter [Vordefinierte SSL-Sicherheitsrichtlinien für Classic Load Balancer](elb-security-policy-table.md).
**Benutzerdefinierte Sicherheitsrichtlinien**
Sie können eine benutzerdefinierte Aushandlungskonfiguration mit den benötigten Verschlüsselungen und Protokollen erstellen. Beispielsweise erfordern einige Sicherheits-Compliance-Standards (z. B. PCI, SOC usw.) bestimmte Protokolle und Verschlüsselungen von Clients, um sicherzustellen, dass die Sicherheitsstandards erfüllt werden. In solchen Fällen können Sie eine benutzerdefinierte Sicherheitsrichtlinie erstellen, um diese Standards zu erfüllen.
Weitere Informationen zum Erstellen einer benutzerdefinierten Sicherheitsrichtlinie finden Sie unter [Aktualisieren der SSL-Aushandlungskonfiguration Ihres Classic Load Balancers](ssl-config-update.md).
## SSL-Protokolle
Das *SSL-Protokoll* stellt eine sichere Verbindung zwischen einem Client und einem Server her und stellt sicher, dass alle Daten, die zwischen dem Client und Ihrem Load Balancer übertragen werden, privat sind.
Secure Sockets Layer (SSL) und Transport Layer Security (TLS) sind kryptografische Protokolle, die für die Verschlüsselung vertraulicher Daten über unsichere Netzwerke wie das Internet verwendet werden. Das TLS-Protokoll ist eine neuere Version des SSL-Protokolls. In der Dokumentation zu Elastic Load Balancing bezeichnen wir sowohl SSL- als auch TLS-Protokolle als SSL-Protokoll.
**Empfohlenes Protokoll**
Wir empfehlen TLS 1.2, das in der vordefinierten Sicherheitsrichtlinie ELBSecurity Policy-TLS-1-2-2017-01 verwendet wird. Sie können TLS 1.2 auch in Ihren benutzerdefinierten Sicherheitsrichtlinien verwenden. Die Standard-Sicherheitsrichtlinie unterstützt sowohl TLS 1.2 als auch frühere Versionen von TLS und ist daher weniger sicher als Policy-TLS-1-2-2017-01. ELBSecurity
**Veraltete Protokolle**
Wenn Sie das SSL-2.0-Protokoll in einer benutzerdefinierten Richtlinie aktiviert haben, empfehlen wir, dass Sie Ihre Sicherheitsrichtlinie auf eine der vordefinierten Sicherheitsrichtlinien aktualisieren.
## Präferenz für die Serverreihenfolge
Elastic Load Balancing unterstützt die Option *Präferenz für die Serverreihenfolge* für das Aushandeln von Verbindungen zwischen einem Client und einem Load Balancer. Während der SSL-Verbindungsaushandlung präsentieren der Client und der Load Balancer eine Liste von Verschlüsselungsverfahren und Protokollen, die sie jeweils unterstützen, nach Priorität sortiert. Standardmäßig wird für die SSL-Verbindung die erste Verschlüsselung auf der Liste des Clients ausgewählt, die mit einem der Verschlüsselungsverfahren des Load Balancers übereinstimmt. Wenn der Load Balancer zur Unterstützung der Präferenz für die Serverreihenfolge konfiguriert ist, wählt der Load Balancer die erste Verschlüsselung in der Liste aus, die auch in der Client-Verschlüsselungsliste enthalten ist. Auf diese Weise wird sichergestellt, dass der Load Balancer bestimmt, welche Verschlüsselung für die SSL-Verbindung verwendet wird. Wenn Sie die Präferenz für die Serverreihenfolge nicht aktivieren, wird die vom Client angebotene Reihenfolge der Verschlüsselung zum Aushandeln der Verbindungen zwischen dem Client und dem Load Balancer verwendet.
## SSL-Verschlüsselungsverfahren
Ein *SSL-Verschlüsselungsverfahren* ist ein Algorithmus, der eine kodierte Nachricht mithilfe von Verschlüsselungsschlüsseln erstellt. SSL-Protokolle verwenden mehrere SSL-Verschlüsselungsverfahren zum Verschlüsseln von Daten über das Internet.
Beachten Sie, dass ein von AWS Certificate Manager (ACM) bereitgestelltes Zertifikat einen öffentlichen RSA-Schlüssel enthält. Daher müssen Sie eine Cipher Suite (Verschlüsselungssammlung) zu Ihrer Sicherheitsrichtlinie hinzufügen, die RSA verwendet, wenn Sie ein Zertifikat von ACM verwenden, da andernfalls die TLS-Verbindung fehlschlägt.
Elastic Load Balancing unterstützt die folgenden Verschlüsselungen für die Verwendung mit Classic Load Balancern. Ein Teil dieser Verschlüsselungen wird von den vordefinierten SSL-Richtlinien verwendet. Alle diese Verschlüsselungen sind für die Verwendung in einer benutzerdefinierten Richtlinie verfügbar. Wir empfehlen, dass Sie nur die Verschlüsselungen in der Standardsicherheitsrichtlinie (mit einem Sternchen gekennzeichnet) verwenden. Viele der anderen Verschlüsselungen sind nicht sicher und erfolgen auf eigenes Risiko.
**Verschlüsselungen**
+ ECDHE-ECDSA- -GCM- \$1 AES128 SHA256
+ ECDHE-RSA- AES128 -GCM- \$1 SHA256
+ ECDHE-ECDSA- AES128 - \$1 SHA256
+ ECDHE-RSA- AES128 - \$1 SHA256
+ AES128ECDHE-ECDSA-SHA \$1
+ AES128ECDHE-RSA-SHA \$1
+ AES128DHE-RSA-SHA
+ ECDHE-ECDSA- -GCM- \$1 AES256 SHA384
+ ECDHE-RSA- AES256 -GCM- \$1 SHA384
+ ECDHE-ECDSA- AES256 - \$1 SHA384
+ ECDHE-RSA- AES256 - \$1 SHA384
+ ECDHE-RSA- AES256 -SHA \$1
+ AES256ECDHE-ECDSA-SHA \$1
+ AES128-GCM- \$1 SHA256
+ AES128-SHA256 \$1
+ AES128-SCHA \$1
+ AES256-GCM- \$1 SHA384
+ AES256-SHA256 \$1
+ AES256-SCHA \$1
+ DHE-DSS-SHA AES128
+ CAMELLIA128-SCHA
+ EDH-RSA-DES-SHA CBC3
+ DES- CBC3 -SHA
+ ECDHE-RSA-SHA RC4
+ RC4-SCHA
+ ECDHE-ECDSA- -SHA RC4
+ DHE-DSS-GCM- AES256 SHA384
+ DHE-RSA- AES256 -GCM- SHA384
+ DHE-RSA- AES256 - SHA256
+ DHE-DSS- AES256 - SHA256
+ AES256DHE-RSA-SHA
+ AES256DHE-DSS-SHA
+ CAMELLIA256DHE-RSA-SHA
+ CAMELLIA256DHE-DSS-SHA
+ CAMELLIA256-SCHA
+ EDH-DSS-DES-SHA CBC3
+ AES128DHE-DSS-GCM- SHA256
+ DHE-RSA- AES128 -GCM- SHA256
+ DHE-RSA- AES128 - SHA256
+ DHE-DSS- AES128 - SHA256
+ CAMELLIA128DHE-RSA-SHA
+ CAMELLIA128DHE-DSS-SHA
+ ADH- AES128 -GCM- SHA256
+ ADH- -SHA AES128
+ ADH- - AES128 SHA256
+ ADH- AES256 -GCM- SHA384
+ ADH- -SHA AES256
+ ADH- - AES256 SHA256
+ ADH- CAMELLIA128 -SHA
+ ADH- -SHA CAMELLIA256
+ ADH-DES-SHA CBC3
+ ADH-DES-CBC-SHA
+ ADH- - RC4 MD5
+ ADH-SEED-SHA
+ DES-CBC-SHA
+ DHE-DSS-SEED-SHA
+ DHE-RSA-SEED-SHA
+ EDH-DSS-DES-CBC-SHA
+ EDH-RSA-DES-CBC-SHA
+ IDEA-CBC-SHA
+ RC4-MD5
+ SEED-SHA
+ DES- CBC3 - MD5
+ DES-CBC- MD5
+ RC2-CBC- MD5
+ PSK- -CBC-SHA AES256
+ PSK-3DES-EDE-CBC-SHA
+ KRB5-DES- CBC3 -SHA
+ KRB5-DES- - CBC3 MD5
+ PSK- -CBC-SHA AES128
+ PSK- RC4 -SHA
+ KRB5- -SCHA RC4
+ KRB5-RC4-MD5
+ KRB5-DES-CBC-SHA
+ KRB5-DES-CBC- MD5
+ EXP-EDH-RSA-DES-CBC-SHA
+ EXP-EDH-DSS-DES-CBC-SHA
+ EXP-ADH-DES-CBC-SHA
+ EXP-DES-CBC-SHA
+ EXP- -CBC- RC2 MD5
+ EXP- - -CBC-SHA KRB5 RC2
+ EXP- KRB5 -DES-CBC-SHA
+ EXP- - -CBC- KRB5 RC2 MD5
+ EXP- -DES-CBC- KRB5 MD5
+ RC4EXP-ADH- - MD5
+ EXP- - RC4 MD5
+ EXP- - -SHA KRB5 RC4
+ EXP- - - KRB5 RC4 MD5
\$1 Dies sind die Chiffren, die in der Standardsicherheitsrichtlinie Policy-2016-08 enthalten sind. ELBSecurity
## Cipher Suite für Back-End-Verbindungen
Classic Load Balancers verwendet eine statische Verschlüsselungssuite für Back-End-Verbindungen. Wenn Ihr Classic Load Balancer und registrierte Instances keine Verbindung aushandeln können, fügen Sie eine der folgenden Chiffren hinzu.
+ AES256-GCM- SHA384
+ AES256-SHA256
+ AES256-SCHA
+ CAMELLIA256-SCHA
+ AES128-GCM- SHA256
+ AES128-SHA256
+ AES128-SCHA
+ CAMELLIA128-SCHA
+ RC4-SCHA
+ DES-SHA CBC3
+ DES-CBC-SHA
+ DHE-DSS-GCM- AES256 SHA384
+ DHE-RSA- AES256 -GCM- SHA384
+ DHE-RSA- AES256 - SHA256
+ DHE-DSS- AES256 - SHA256
+ AES256DHE-RSA-SHA
+ AES256DHE-DSS-SHA
+ CAMELLIA256DHE-RSA-SHA
+ CAMELLIA256DHE-DSS-SHA
+ AES128DHE-DSS-GCM- SHA256
+ DHE-RSA- AES128 -GCM- SHA256
+ DHE-RSA- AES128 - SHA256
+ DHE-DSS- AES128 - SHA256
+ AES128DHE-RSA-SHA
+ AES128DHE-DSS-SHA
+ CAMELLIA128DHE-RSA-SHA
+ CAMELLIA128DHE-DSS-SHA
+ CBC3EDH-RSA-DES-SHA
+ CBC3EDH-DSS-DE-SHA
+ EDH-RSA-DES-CBC-SHA
+ EDH-DSS-DES-CBC-SHA
# Vordefinierte SSL-Sicherheitsrichtlinien für Classic Load Balancer
Sie können eine der vordefinierten Sicherheitsrichtlinien für Ihre HTTPS/SSL-Listener auswählen. Sie können eine der `ELBSecurityPolicy-TLS`-Richtlinien zur Erfüllung von Compliance- und Sicherheitsstandards verwenden, welche die Deaktivierung bestimmter TLS-Protokollversionen erfordern. Alternativ können Sie eine benutzerdefinierte Sicherheitsrichtlinie erstellen. Weitere Informationen finden Sie unter [Aktualisieren der SSL-Aushandlungskonfiguration](ssl-config-update.md).
Die RSA- und DSA-basierten Verschlüsselungen gelten speziell für den Signaturalgorithmus zum Erstellen von SSL-Zertifikaten. Stellen Sie sicher, dass Sie ein SSL-Zertifikat mit dem Signaturalgorithmus erstellen, der auf Verschlüsselungen basiert, die für Ihre Sicherheitsrichtlinie aktiviert sind.
Wenn Sie eine Richtlinie auswählen, für die Präferenz für die Serverreihenfolge aktiviert ist, verwendet der Load Balancer die Verschlüsselungen in der Reihenfolge, in der sie hier angegeben sind, um die Verbindungen zwischen dem Client und dem Load Balancer auszuhandeln. Andernfalls verwendet der Load Balancer die Verschlüsselungen in der Reihenfolge, in der sie vom Client angeboten werden.
In den folgenden Abschnitten werden die neuesten vordefinierten Sicherheitsrichtlinien für Classic Load Balancer beschrieben, einschließlich der aktivierten SSL-Protokolle und SSL-Verschlüsselungen. Sie können die vordefinierten Richtlinien auch mit dem Befehl beschreiben. [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)
**Tipp**
Diese Informationen gelten nur für Classic Load Balancers. Informationen, die für andere Load Balancer gelten, finden Sie unter [Sicherheitsrichtlinien für Ihren Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/describe-ssl-policies.html) und [Sicherheitsrichtlinien für Ihren Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/describe-ssl-policies.html).
**Topics**
+ [Protokolle nach Richtlinien](#tls-protocols)
+ [Chiffren nach Richtlinien](#tls-policy-ciphers)
+ [Richtlinien nach Chiffre](#tls-cipher-policies)
## Protokolle nach Richtlinien
In der folgenden Tabelle werden die TLS-Protokolle beschrieben, die von den einzelnen Sicherheitsrichtlinien unterstützt werden.
| Sicherheitsrichtlinien | TLS 1.2 | TLS 1.1 | TLS 1.0 |
| --- | --- | --- | --- |
| ELBSecurityPolicy-TLS-1-2-2017-01 | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/negative_icon.svg) Nein | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/negative_icon.svg) Nein |
| ELBSecurityRichtlinie-TLS-1-1-2017-01 | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/negative_icon.svg) Nein |
| ELBSecurityPolitik-2016-08 | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja |
| ELBSecurityPolitik-2015-05 | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja |
| ELBSecurityPolitik-2015-03 | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja |
| ELBSecurityPolitik-2015-02 | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/images/success_icon.svg) Ja |
## Chiffren nach Richtlinien
In der folgenden Tabelle werden die Verschlüsselungen beschrieben, die von den einzelnen Sicherheitsrichtlinien unterstützt werden.
| Sicherheitsrichtlinie | Verschlüsselungen |
| --- | --- |
| ELBSecurityPolicy-TLS-1-2-2017-01 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) |
| ELBSecurityRichtlinie-TLS-1-1-2017-01 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) |
| ELBSecurityPolitik - 2016-08 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) |
| ELBSecurityPolitik 2015-05 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) |
| ELBSecurityRichtlinie 2015-03 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) |
| ELBSecurityRichtlinien-2015-02 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) |
## Richtlinien nach Chiffre
In der folgenden Tabelle werden die Sicherheitsrichtlinien beschrieben, die die einzelnen Verschlüsselungen unterstützen.
| Name der Chiffre | Sicherheitsrichtlinien | Verschlüsselungssuite |
| --- | --- | --- |
| **OpenSSL** — ECDHE-ECDSA-AES 128-GCM- SHA256 **IANA — TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1128\$1GCM\$1** SHA256 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c02b |
| **OpenSSL** — ECDHE-RSA-AES 128-GCM- SHA256 **IANA — TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1** SHA256 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c02f |
| **OpenSSL** — ECDHE-ECDSA-AES 128- SHA256 **IANA** — TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c023 |
| **OpenSSL** — ECDHE-RSA-AES 128- SHA256 **IANA** — TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c027 |
| **OpenSSL — 128-SHA** ECDHE-ECDSA-AES **IANA** — TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c009 |
| **OpenSSL — 128-SHA** ECDHE-RSA-AES **IANA** — TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c013 |
| **OpenSSL** — ECDHE-ECDSA-AES 256-GCM- SHA384 **IANA — TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1** SHA384 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c02c |
| **OpenSSL** — ECDHE-RSA-AES 256-GCM- SHA384 **IANA — TLS\$1ECCHE\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1** SHA384 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c030 |
| **OpenSSL** — ECDHE-ECDSA-AES 256- SHA384 **IANA** — TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c024 |
| **OpenSSL** — ECDHE-RSA-AES 256- SHA384 **IANA** — TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA384 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c028 |
| **OpenSSL — 256-SHA** ECDHE-ECDSA-AES **IANA — TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA** | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c014 |
| **OpenSSL — 256-SHA** ECDHE-RSA-AES **IANA — TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1SHA** | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | c00a |
| **OpenSSL** — AES128 -GCM- SHA256 **IANA — TLS\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1** SHA256 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 9c |
| **OpenSSL** — - AES128 SHA256 **IANA** — TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 3c |
| **OpenSSL — -SHA** AES128 **IANA** — TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 2f |
| **OpenSSL** — AES256 -GCM- SHA384 **IANA — TLS\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1** SHA384 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 9d |
| **OpenSSL** — - AES256 SHA256 **IANA** — TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1 SHA256 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 3d |
| **OpenSSL — -SHA** AES256 **IANA** — TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 35 |
| **OpenSSL — 128-SHA** DHE-RSA-AES **IANA** — TLS\$1DHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 33 |
| **OpenSSL — 128-SHA** DHE-DSS-AES **IANA** — TLS\$1DHE\$1DSS\$1WITH\$1AES\$1128\$1CBC\$1SHA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 32 |
| **OpenSSL** — DES-SHA CBC3 **IANA** — TLS\$1RSA\$1WITH\$13DES\$1EDE\$1CBC\$1SHA | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/elasticloadbalancing/latest/classic/elb-security-policy-table.html) | 0a |
# Erstellen eines Classic Load Balancers mit einem HTTPS-Listener
Ein Load Balancer nimmt Anforderungen von Clients entgegen und verteilt sie über die EC2-Instances, die im Load Balancer registriert sind.
Sie können einen Load Balancer erstellen, der die Ports HTTP (80) und HTTPS (443) überwacht. Wenn Sie angeben, dass der HTTPS-Listener Anforderungen an die Instances auf Port 80 sendet, beendet der Load Balancer die Anforderungen und die Kommunikation über den Load Balancer an die Instances ist nicht verschlüsselt. Wenn der HTTPS-Listener Anforderungen an die Instances auf Port 443 sendet, ist die Kommunikation über den Load Balancer an die Instances verschlüsselt.
Wenn Ihr Load Balancer eine verschlüsselte Verbindung verwendet, um mit den Instances zu kommunizieren, können Sie optional die Authentifizierung der Instances aktivieren. Auf diese Weise wird sichergestellt, dass der Load Balancer mit einer Instance nur dann kommuniziert, wenn der öffentliche Schlüssel mit dem angegebenen Schlüssel, den Sie zu diesem Zweck auf dem Load Balancer angegeben haben, übereinstimmt.
Weitere Informationen über das Hinzufügen von HTTPS-Listenern zu einem vorhandenen Load Balancer finden Sie unter [Konfigurieren eines HTTPS-Listeners für Ihren Classic Load Balancer](elb-add-or-delete-listeners.md).
**Topics**
+ [Voraussetzungen](#elb-https-ssl-prerequisites)
+ [Erstellen Sie mithilfe der Konsole einen HTTPS-Load Balancer](#create-https-lb-console)
+ [Erstellen Sie einen HTTPS-Load Balancer mit dem AWS CLI](#create-https-lb-clt)
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:
+ Führen Sie die Schritte unter [Empfehlungen für Ihre VPC](elb-backend-instances.md#set-up-ec2) aus.
+ Starten Sie die EC2-Instances, die Sie bei Ihrem Load Balancer registrieren möchten. Die Sicherheitsgruppen für diese Instances müssen den Datenverkehr aus dem Load Balancer zulassen.
+ Die EC2-Instances müssen an das Ziel der Zustandsprüfung einen HTTP-Statuscode 200 als Antwort senden. Weitere Informationen finden Sie unter [Zustandsprüfungen für die Instances für Ihren Classic Load Balancer](elb-healthchecks.md).
+ Wenn Sie planen, die Keepalive-Option für Ihre EC2-Instances zu aktivieren, empfehlen wir, dass Sie die Keepalive-Einstellungen mindestens auf die Leerlaufzeitlimit-Einstellung Ihres Load Balancers setzen. Wenn Sie sicherstellen möchten, dass der Load Balancer für das Schließen von Verbindungen mit Ihrer Instance zuständig ist, stellen Sie die Keepalive-Zeit auf der Instance höher als das Load Balancer-Leerlaufzeitlimit ein. Weitere Informationen finden Sie unter [Konfigurieren des Leerlaufverbindungszeitlimits für Ihren Classic Load Balancer](config-idle-timeout.md).
+ Wenn Sie einen sicheren Listener erstellen, müssen Sie ein SSL-Zertifikat auf dem Load Balancer Server bereitstellen. Der Load Balancer verwendet das Zertifikat zum Beenden und entschlüsselt dann Anforderungen vor der Übermittlung an die Instances. Wenn Sie nicht über ein SSL-Zertifikat verfügen, können Sie eins erstellen. Weitere Informationen finden Sie unter [SSL/TLS-Zertifikate für Classic Load Balancer](ssl-server-cert.md).
## Erstellen Sie mithilfe der Konsole einen HTTPS-Load Balancer
In diesem Beispiel konfigurieren Sie zwei Listener für Ihren Load Balancer. Der erste Listener akzeptiert HTTP-Anforderungen auf Port 80 und sendet diese über HTTP auf Port 80 an die Instances. Der zweite Listener akzeptiert HTTPS-Anforderungen auf Port 443 und sendet diese mittels HTTP auf Port 80 (oder unter Verwendung von HTTPS auf Port 443, wenn Sie Backend-Instance-Authentifizierung konfigurieren möchten) an die Instances.
Ein *Listener* ist ein Prozess, der Verbindungsanfragen überprüft. Er wird mit einem Protokoll und einem Port für Frontend-Verbindungen (Client zu Load Balancer) sowie einem Protokoll und einem Port für Backend-Verbindungen (Load Balancer zu Instance) konfiguriert. Weitere Informationen zu den von Elastic Load Balancing unterstützten Ports, Protokollen und Listener-Konfigurationen finden Sie unter [Listener für Ihren Classic Load Balancer](elb-listener-config.md).
**So erstellen Sie Ihren sicheren Classic Load Balancer mithilfe der Konsole**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie in der Navigationsleiste eine Region für Ihren Load Balancer aus. Stellen Sie sicher, dass Sie die gleiche Region auswählen, die Sie für Ihre EC2-Instances ausgewählt haben.
1. Wählen Sie im Navigationsbereich unter **LOAD BALANCING** die Option **Load Balancers** aus.
1. Wählen Sie **Load Balancer erstellen** aus.
1. Erweitern Sie den Abschnitt **Classic Load Balancer** und wählen Sie dann **Create** (Erstellen) aus.
1. **Basiskonfiguration**
1. Geben Sie im Feld **Load balancer name** (Name des Load Balancers) einen Namen für Ihren Load Balancer ein.
Der Name des Classic Load Balancers muss innerhalb Ihrer Gruppe mit Classic Load Balancern für die Region eindeutig sein, darf maximal 32 Zeichen lang sein, darf nur alphanumerische Zeichen sowie Bindestriche enthalten und darf nicht mit einem Bindestrich beginnen oder enden.
1. Wählen Sie für **Scheme** (Schema) die Option **Internet-facing** (Internet verbunden) aus.
1. **Netzwerkzuordnung**
1. Wählen Sie im Feld **VPC** die VPC aus, die Sie für Ihre Instances verwendet haben.
1. Wählen Sie für **Mappings** (Zuordnungen) zunächst eine Availability Zone und dann ein öffentliches Subnetz aus den verfügbaren Subnetzen aus. Sie können nur ein Subnetz pro Availability Zone auswählen. Zur Verbesserung der Verfügbarkeit Ihrer Load Balancer wählen Sie mehr als eine Availability Zone und ein Subnetz aus.
1. **Sicherheitsgruppen**
1. Wählen Sie für **Security groups** (Sicherheitsgruppen) eine vorhandene Sicherheitsgruppe aus, die so konfiguriert ist, dass sie den erforderlichen HTTP-Verkehr auf Port 80 und HTTPS-Verkehr auf Port 443 zulässt.
Wenn keine vorhanden ist, können Sie eine neue Sicherheitsgruppe mit den erforderlichen Regeln erstellen.
1. **Listener und Routing**
1. Behalten Sie die Standardeinstellungen für den Standard-Listener bei und wählen Sie **Add listener** (Listener hinzufügen) aus.
1. Wählen Sie für **Listener** auf dem neuen Listener `HTTPS` als Protokoll aus, und der Port wird auf `443` aktualisiert. Standardmäßig verwendet **Instance** das `HTTP`-Protokoll auf dem Port `80`.
1. Wenn eine Backend-Authentifizierung erforderlich ist, ändern Sie das **Instance**-Protokoll auf `HTTPS`. Auf diese Weise wird auch der **Instance**-Port auf `443` aktualisiert
1. **Secure listener settings** (Sichere Listener-Einstellungen)
Wenn Sie HTTPS oder SSL für Ihre Frontend-Listener verwenden, müssen Sie ein SSL-Zertifikat auf dem Load Balancer bereitstellen. Der Load Balancer verwendet das Zertifikat, um die Verbindung zu beenden und dann Anfragen von Clients zu entschlüsseln, bevor er sie an die Instances sendet. Sie müssen auch eine Sicherheitsrichtlinie angeben. Elastic Load Balancing bietet Sicherheitsrichtlinien mit vordefinierten SSL-Aushandlungskonfigurationen, oder Sie können Ihre eigenen benutzerdefinierten Sicherheitsrichtlinien erstellen. Wenn Sie HTTPS/SSL auf der Back-End-Verbindung konfiguriert haben, können Sie die Authentifizierung Ihrer Instances aktivieren.
1. Für **Sicherheitsrichtlinien** empfehlen wir, immer die neueste vordefinierte Sicherheitsrichtlinie zu verwenden oder eine benutzerdefinierte Richtlinie zu erstellen. Siehe [Aktualisieren der SSL-Aushandlungskonfiguration](ssl-config-update.md#ssl-config-update-console).
1. Für das ** SSL/TLS Standardzertifikat** sind die folgenden Optionen verfügbar:
+ Wenn Sie ein Zertifikat mit erstellt oder importiert haben AWS Certificate Manager, wählen Sie **Aus ACM** und dann das Zertifikat unter **Zertifikat auswählen** aus.
+ Wenn Sie ein Zertifikat mit IAM importiert haben, wählen Sie **Von ACM** aus und wählen Sie dann das Zertifikat unter **Zertifikat auswählen** aus.
+ Wenn Sie ein Zertifikat importieren, aber ACM in Ihrer Region nicht verfügbar ist, wählen Sie **Importieren** und dann **An IAM** aus. Geben Sie im Feld **Zertifikatname** den Namen des Zertifikats ein. Kopieren Sie den Inhalt der privaten Schlüsseldatei (PEM-kodiert) und fügen Sie ihn in das Feld **Privater Zertifikatsschlüssel** ein. Kopieren Sie den Inhalt der öffentlichen Schlüsselzertifikatdatei (PEM-kodiert) und fügen Sie ihn in das Feld **Zertifikatstext** ein. Kopieren Sie den Inhalt der Zertifikatskettendatei (PEM-kodiert) und fügen Sie ihn in das Feld **Certificate Chain** (Zertifikats-Kette) ein, es sei denn, Sie verwenden ein selbst signiertes Zertifikat und es ist nicht wichtig, dass Browser das Zertifikat implizit akzeptieren.
1. (Optional) Wenn Sie den HTTPS-Listener für die Kommunikation mit den Instances über eine verschlüsselte Verbindung eingerichtet haben, können Sie optional die Authentifizierung der Instances unter **Backend authentication certificate** (Backend-Authentifizierungszertifikat) einrichten.
**Anmerkung**
Wenn Sie den Abschnitt **Backend authentication certificate** (Backend-Authentifizierungszertifikat) nicht sehen, kehren Sie zu **Listeners and routing** (Listeners und Routing) zurück und wählen Sie `HTTPS` als Protokoll für **Instance** aus.
1. Geben Sie für **Certificate name** den Namen des öffentlichen Schlüsselzertifikats ein.
1. Kopieren Sie für **Certificate Body (PEM encoded)** (Zertifizierungsstelle (PEM-codiert)) den Inhalt des Zertifikats und fügen Sie ihn ein. Der Load Balancer kommuniziert mit einer Instanz nur dann, wenn der öffentliche Schlüssel diesem Schlüssel entspricht.
1. Um ein weiteres Zertifikat hinzuzufügen, wählen Sie **Add new backend certificate** (Neues Backend-Zertifikat hinzufügen). Das Limit liegt bei fünf.
1. **Health checks** (Zustandsprüfungen)
1. Wählen Sie im Abschnitt **Ping target** (Ping-Ziel) ein **Ping Protocol** (Ping-Protokoll) und einen **Ping Port** (Ping-Port) aus. Ihre EC2-Instances müssen den Datenverkehr auf dem angegebenen Ping-Port akzeptieren.
1. Stellen Sie für **Ping Port** sicher, dass der Port `80` ist.
1. Ersetzen Sie den Standardwert für **Ping Path** (Ping-Pfad) durch einen Schrägstrich (`/`). Dadurch wird Elastic Load Balancing angewiesen, Zustandsprüfungsanfragen an die Standardstartseite Ihres Webservers, z. B. `index.html`, zu senden.
1. Verwenden Sie für die **Advanced health check settings** (Einstellungen für erweiterte Zustandsprüfungen) die Standardwerte.
1. **Instances**
1. Wählen Sie **Add instances** (Instances hinzufügen) aus, um den Bildschirm zur Instance-Auswahl aufzurufen.
1. Unter **Available instances** (Verfügbare Instances) können Sie basierend auf den zuvor gewählten Netzwerkeinstellungen aus den aktuellen Instances auswählen, die für den Load Balancer verfügbar sind.
1. Wenn Sie mit Ihrer Auswahl zufrieden sind, wählen Sie **Confirm** (Bestätigen) aus, um die zu registrierenden Instances zum Load Balancer hinzuzufügen.
1. **Attribute**
1. Behalten Sie für **Enable cross-zone load balancing** (Zonenübergreifendes Load Balancing aktivieren), **Enable connection draining** (Connection Draining aktivieren) und **Timeout (draining interval)** (Timeout (Draining-Intervall)) die Standardwerte bei.
1. **Load balancer tags (optional)** (Load-Balancer-Tags (optional))
1. Das Feld **Key** (Schlüssel) ist ein Pflichtfeld.
1. Das Feld **Value** (Wert) ist optional.
1. Um ein weiteres Tag hinzuzufügen, wählen Sie **Add new tag** (Neues Tag hinzufügen) aus und geben Sie dann Ihre Werte in das Feld **Key** (Schlüssel) und optional in das Feld **Value** (Wert) ein.
1. Um ein vorhandenes Tag zu entfernen, wählen Sie neben dem zu entfernenden Tag die Option **Remove** (Entfernen).
1. **Summary and creation** (Zusammenfassung und Erstellung)
1. Wenn Sie Einstellungen ändern müssen, wählen Sie neben der Einstellung, die geändert werden muss, **Edit** (Bearbeiten) aus.
1. Wenn Sie mit allen in der Zusammenfassung angezeigten Einstellungen zufrieden sind, wählen Sie **Create load balancer** (Load Balancer erstellen) aus, um mit der Erstellung Ihres Load Balancers zu beginnen.
1. Wählen Sie auf der letzten Erstellungsseite die Option **View load balancer** (Load Balancer anzeigen) aus, um Ihren Load Balancer in der Amazon-EC2-Konsole anzuzeigen.
1. **Verify**
1. Wählen Sie den neuen Load Balancer aus.
1. Überprüfen Sie auf der Registerkarte **Target instances** (Ziel-Instances) die Spalte **Health status** (Zustandsstatus). Wenn mindestens eine Ihrer EC2-Instances **In-service** (betriebsbereit) ist, können Sie Ihren Load Balancer testen.
1. Kopieren Sie im Abschnitt **Details** den **DNS name** (DNS-Namen) des Load Balancers, der etwa wie `my-load-balancer-1234567890.us-east-1.elb.amazonaws.com` aussehen würde.
1. Fügen Sie den **DNS name** (DNS-Namen) Ihres Load Balancers in das Adressfeld eines öffentlichen Webbrowsers mit Internetanschluss ein. Wenn Ihr Load Balancer korrekt funktioniert, sehen Sie die Standardseite Ihres Servers.
1. **Delete (optional)** (Löschen (optional))
1. Wenn Sie einen CNAME-Eintrag für Ihre Domain haben, der auf Ihren Load Balancer verweist, verweisen Sie ihn an den neuen Standort und warten Sie, bis die DNS-Änderungen wirksam werden, bevor Sie den Load Balancer löschen.
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie den Load Balancer aus.
1. Wählen Sie den Load Balancer aus und klicken Sie auf **Actions** (Aktionen) und dann auf **Delete load balancer** (Load Balancer löschen).
1. Wenn Sie zur Bestätigung aufgefordert werden, geben Sie `confirm` ein und wählen Sie dann **Delete** (Löschen) aus.
1. Nachdem Sie einen Load Balancer gelöscht haben, werden die EC2-Instances, die beim Load Balancer registriert wurden, weiter ausgeführt. Ihnen wird jede teilweise oder ganze Stunde in Rechnung gestellt, in der sie weiterlaufen. Wenn Sie eine EC2-Instance nicht mehr benötigen, können Sie sie anhalten oder beenden, um zu verhindern, dass es zu zusätzlichen Kosten kommt.
## Erstellen Sie einen HTTPS-Load Balancer mit dem AWS CLI
Verwenden Sie die folgenden Anweisungen, um einen HTTPS/SSL Load Balancer mit dem zu erstellen. AWS CLI
**Topics**
+ [Schritt 1: Konfigurieren von Listenern](#configuring_listener_clt)
+ [Schritt 2: Konfigurieren der SSL-Sicherheitsrichtlinie](#configure_ciphers_clt)
+ [Schritt 3: Konfigurieren der Backend-Instance-Authentifizierung (optional)](#configure_backendauth_clt)
+ [Schritt 4: Konfigurieren von Zustandsprüfungen (optional)](#configure_healthcheck_clt)
+ [Schritt 5: Registrieren von EC2-Instances](#add_ec2instances_clt)
+ [Schritt 6: Überprüfen der Instances](#verify-ec2instances-clt)
+ [Schritt 7: Löschen des Load Balancers (optional)](#us-tearing-lb-cli)
### Schritt 1: Konfigurieren von Listenern
Ein *Listener* ist ein Prozess, der Verbindungsanfragen überprüft. Er wird mit einem Protokoll und einem Port für Frontend-Verbindungen (Client zu Load Balancer) sowie einem Protokoll und einem Port für Backend-Verbindungen (Load Balancer zu Instance) konfiguriert. Weitere Informationen zu den von Elastic Load Balancing unterstützten Ports, Protokollen und Listener-Konfigurationen finden Sie unter [Listener für Ihren Classic Load Balancer](elb-listener-config.md).
In diesem Beispiel konfigurieren Sie zwei Listener für Ihren Load Balancer, indem Sie die Ports und Protokolle für die Frontend- und Backend-Verbindungen angeben. Der erste Listener akzeptiert HTTP-Anforderungen auf Port 80 und sendet die Anforderungen über HTTP auf Port 80 an die Instances. Der zweite Listener akzeptiert HTTPS-Anforderungen auf Port 443 und sendet Anforderungen über HTTP auf Port 80 an Instances.
Da der zweite Listener HTTPS für die Frontend-Verbindung verwendet, müssen ein SSL-Serverzertifikat auf dem Load Balancer bereitstellen. Der Load Balancer verwendet das Zertifikat zum Beenden und entschlüsselt dann Anforderungen vor der Übermittlung an die Instances.
**So konfigurieren Sie Listener für Ihren Load Balancer**
1. Rufen Sie den Amazon-Ressourcennamen (ARN) des SSL-Zertifikats ab. Beispiel:
**ACM**
```
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012
```
**IAM**
```
arn:aws:iam::123456789012:server-certificate/my-server-certificate
```
1. Verwenden Sie den folgenden [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer.html)Befehl, um den Load Balancer mit den beiden Listenern zu konfigurieren:
```
aws elb create-load-balancer --load-balancer-name my-load-balancer --listeners "Protocol=http,LoadBalancerPort=80,InstanceProtocol=http,InstancePort=80" "Protocol=https,LoadBalancerPort=443,InstanceProtocol=http,InstancePort=80,SSLCertificateId="ARN" --availability-zones us-west-2a
```
Nachfolgend finden Sie eine Beispielantwort:
```
{
"DNSName": "my-loadbalancer-012345678.us-west-2.elb.amazonaws.com"
}
```
1. (Optional) Verwenden Sie den folgenden [describe-load-balancers](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancers.html)Befehl, um die Details Ihres Load Balancers anzuzeigen:
```
aws elb describe-load-balancers --load-balancer-name my-load-balancer
```
### Schritt 2: Konfigurieren der SSL-Sicherheitsrichtlinie
Sie können eine der vordefinierten Sicherheitsrichtlinien auswählen oder Ihre eigene benutzerdefinierte Sicherheitsrichtlinie erstellen. Andernfalls konfiguriert Elastic Load Balancing Ihren Load Balancer mit der standardmäßigen vordefinierten Sicherheitsrichtlinie `ELBSecurityPolicy-2016-08`. Weitere Informationen finden Sie unter [SSL-Aushandlungskonfigurationen für Classic Load Balancer](elb-ssl-security-policy.md).
**So stellen Sie sicher, dass der Load Balancer der Standardsicherheitsrichtlinie zugeordnet ist**
Verwenden Sie den folgenden [describe-load-balancers](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancers.html)-Befehl:
```
aws elb describe-load-balancers --load-balancer-name my-loadbalancer
```
Nachfolgend finden Sie eine Beispielantwort. Beachten Sie, dass `ELBSecurityPolicy-2016-08` dem Load Balancer auf Port 443 zugeordnet ist.
```
{
"LoadBalancerDescriptions": [
{
...
"ListenerDescriptions": [
{
"Listener": {
"InstancePort": 80,
"SSLCertificateId": "ARN",
"LoadBalancerPort": 443,
"Protocol": "HTTPS",
"InstanceProtocol": "HTTP"
},
"PolicyNames": [
"ELBSecurityPolicy-2016-08"
]
},
{
"Listener": {
"InstancePort": 80,
"LoadBalancerPort": 80,
"Protocol": "HTTP",
"InstanceProtocol": "HTTP"
},
"PolicyNames": []
}
],
...
}
]
}
```
Wenn Sie möchten, können Sie die SSL-Sicherheitsrichtlinie für Ihren Load Balancer anstelle der Standardsicherheitsrichtlinie verwenden.
**(Optional) Verwendung einer vordefinierten SSL-Sicherheitsrichtlinie**
1. Verwenden Sie den folgenden [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)Befehl, um die Namen der vordefinierten Sicherheitsrichtlinien aufzulisten:
```
aws elb describe-load-balancer-policies
```
Informationen über die Konfiguration mit vordefinierten Sicherheitsrichtlinien finden Sie unter [Vordefinierte SSL-Sicherheitsrichtlinien für Classic Load Balancer](elb-security-policy-table.md).
1. Verwenden Sie den folgenden [create-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-policy.html)Befehl, um eine SSL-Verhandlungsrichtlinie mithilfe einer der vordefinierten Sicherheitsrichtlinien zu erstellen, die Sie im vorherigen Schritt beschrieben haben:
```
aws elb create-load-balancer-policy --load-balancer-name my-loadbalancer
--policy-name my-SSLNegotiation-policy --policy-type-name SSLNegotiationPolicyType
--policy-attributes AttributeName=Reference-Security-Policy,AttributeValue=predefined-policy
```
1. (Optional) Verwenden Sie den folgenden [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)Befehl, um zu überprüfen, ob die Richtlinie erstellt wurde:
```
aws elb describe-load-balancer-policies --load-balancer-name my-loadbalancer --policy-name my-SSLNegotiation-policy
```
Die Antwort enthält die Beschreibung der Richtlinie.
1. Verwenden Sie den folgenden Befehl [set-load-balancer-policies-of-listener](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-policies-of-listener.html), um die Richtlinie auf dem Load Balancer-Port 443 zu aktivieren:
```
aws elb set-load-balancer-policies-of-listener --load-balancer-name my-loadbalancer --load-balancer-port 443 --policy-names my-SSLNegotiation-policy
```
**Anmerkung**
Der Befehl `set-load-balancer-policies-of-listener` ersetzt die aktuellen Richtlinien für den angegebenen Load Balancer-Port durch die angegebenen Richtlinien. Die Liste `--policy-names` muss alle zu aktivierenden Richtlinien enthalten. Wenn Sie eine Richtlinie auslassen, die derzeit aktiviert ist, wird sie deaktiviert.
1. (Optional) Verwenden Sie den folgenden [describe-load-balancers](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancers.html)Befehl, um zu überprüfen, ob die Richtlinie aktiviert ist:
```
aws elb describe-load-balancers --load-balancer-name my-loadbalancer
```
Es folgt ein Beispiel für eine Antwort, die zeigt, dass die Richtlinie auf Port 443 aktiviert ist.
```
{
"LoadBalancerDescriptions": [
{
....
"ListenerDescriptions": [
{
"Listener": {
"InstancePort": 80,
"SSLCertificateId": "ARN",
"LoadBalancerPort": 443,
"Protocol": "HTTPS",
"InstanceProtocol": "HTTP"
},
"PolicyNames": [
"my-SSLNegotiation-policy"
]
},
{
"Listener": {
"InstancePort": 80,
"LoadBalancerPort": 80,
"Protocol": "HTTP",
"InstanceProtocol": "HTTP"
},
"PolicyNames": []
}
],
...
}
]
}
```
Wenn Sie eine benutzerdefinierte Sicherheitsrichtlinie erstellen, müssen Sie mindestens ein Protokoll und eine Verschlüsselung aktivieren. Die DSA- und RSA-Verschlüsselungen gelten speziell für den Signaturalgorithmus zum Erstellen von SSL-Zertifikaten. Wenn Sie bereits über ein SSL-Zertifikat verfügen, müssen Sie die Verschlüsselung aktivieren, mit der das Zertifikat erstellt wurde. Der Name der benutzerdefinierten Richtlinie darf nicht mit `ELBSecurityPolicy-` oder `ELBSample-` beginnen, da diese Präfixe für die Namen der vordefinierten Sicherheitsrichtlinien definiert sind.
**(Optional) Verwendung einer benutzerdefinierten SSL-Sicherheitsrichtlinie**
1. Verwenden Sie den [create-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-policy.html)Befehl, um eine SSL-Verhandlungsrichtlinie mithilfe einer benutzerdefinierten Sicherheitsrichtlinie zu erstellen. Beispiel:
```
aws elb create-load-balancer-policy --load-balancer-name my-loadbalancer
--policy-name my-SSLNegotiation-policy --policy-type-name SSLNegotiationPolicyType
--policy-attributes AttributeName=Protocol-TLSv1.2,AttributeValue=true
AttributeName=Protocol-TLSv1.1,AttributeValue=true
AttributeName=DHE-RSA-AES256-SHA256,AttributeValue=true
AttributeName=Server-Defined-Cipher-Order,AttributeValue=true
```
1. (Optional) Verwenden Sie den folgenden [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)Befehl, um zu überprüfen, ob die Richtlinie erstellt wurde:
```
aws elb describe-load-balancer-policies --load-balancer-name my-loadbalancer --policy-name my-SSLNegotiation-policy
```
Die Antwort enthält die Beschreibung der Richtlinie.
1. Verwenden Sie den folgenden Befehl [set-load-balancer-policies-of-listener](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-policies-of-listener.html), um die Richtlinie auf dem Load Balancer-Port 443 zu aktivieren:
```
aws elb set-load-balancer-policies-of-listener --load-balancer-name my-loadbalancer --load-balancer-port 443 --policy-names my-SSLNegotiation-policy
```
**Anmerkung**
Der Befehl `set-load-balancer-policies-of-listener` ersetzt die aktuellen Richtlinien für den angegebenen Load Balancer-Port durch die angegebenen Richtlinien. Die Liste `--policy-names` muss alle zu aktivierenden Richtlinien enthalten. Wenn Sie eine Richtlinie auslassen, die derzeit aktiviert ist, wird sie deaktiviert.
1. (Optional) Verwenden Sie den folgenden [describe-load-balancers](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancers.html)Befehl, um zu überprüfen, ob die Richtlinie aktiviert ist:
```
aws elb describe-load-balancers --load-balancer-name my-loadbalancer
```
Es folgt ein Beispiel für eine Antwort, die zeigt, dass die Richtlinie auf Port 443 aktiviert ist.
```
{
"LoadBalancerDescriptions": [
{
....
"ListenerDescriptions": [
{
"Listener": {
"InstancePort": 80,
"SSLCertificateId": "ARN",
"LoadBalancerPort": 443,
"Protocol": "HTTPS",
"InstanceProtocol": "HTTP"
},
"PolicyNames": [
"my-SSLNegotiation-policy"
]
},
{
"Listener": {
"InstancePort": 80,
"LoadBalancerPort": 80,
"Protocol": "HTTP",
"InstanceProtocol": "HTTP"
},
"PolicyNames": []
}
],
...
}
]
}
```
### Schritt 3: Konfigurieren der Backend-Instance-Authentifizierung (optional)
Wenn Sie die Back-End-Verbindung einrichten HTTPS/SSL , können Sie optional die Authentifizierung Ihrer Instances einrichten.
Wenn Sie Backend-Instance-Authentifizierung eingerichtet haben, erstellen Sie eine Richtlinie mit öffentlichem Schlüssel. Anschließend verwenden Sie diese Richtlinie mit öffentlichem Schlüssel zum Erstellen einer Backend-Instance-Authentifizierungsrichtlinie. Abschließend legen Sie den Instance-Port für das HTTPS-Protokoll der Backend-Instance-Authentifizierungsrichtlinie fest.
Der Load Balancer kommuniziert mit einer Instance nur dann, wenn der öffentliche Schlüssel, den die Instance dem Load Balancer bietet, einem öffentlichen Schlüssel in der Authentifizierungsrichtlinie für Ihren Load Balancer entspricht.
**So konfigurieren Sie Backend-Instance-Authentifizierung**
1. Verwenden Sie den folgenden Befehl, um den öffentlichen Schlüssel abzurufen:
```
openssl x509 -in your X509 certificate PublicKey -pubkey -noout
```
1. Verwenden Sie den folgenden [create-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-policy.html)Befehl, um eine Richtlinie für öffentliche Schlüssel zu erstellen:
```
aws elb create-load-balancer-policy --load-balancer-name my-loadbalancer --policy-name my-PublicKey-policy \
--policy-type-name PublicKeyPolicyType --policy-attributes AttributeName=PublicKey,AttributeValue=MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
```
**Anmerkung**
Wenn Sie einen öffentlichen Schlüssel für `--policy-attributes` angeben, entfernen Sie die ersten und letzten Zeilen des öffentlichen Schlüssels (die Zeilen mit "`-----BEGIN PUBLIC KEY-----`" und "`-----END PUBLIC KEY-----`"). Der AWS CLI akzeptiert keine Leerzeichen in`--policy-attributes`.
1. Verwenden Sie den folgenden [create-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-policy.html)Befehl, um eine Authentifizierungsrichtlinie für Back-End-Instanzen mithilfe von `my-PublicKey-policy` zu erstellen.
```
aws elb create-load-balancer-policy --load-balancer-name my-loadbalancer --policy-name my-authentication-policy --policy-type-name BackendServerAuthenticationPolicyType --policy-attributes AttributeName=PublicKeyPolicyName,AttributeValue=my-PublicKey-policy
```
Sie haben auch die Möglichkeit, verschiedene Richtlinien mit öffentlichem Schlüssel zu verwenden. Der Load Balancer versucht nacheinander alle Schlüssel. Wenn der von einer Instance angebotene öffentliche Schlüssel mit einem dieser öffentlichen Schlüssel übereinstimmt, ist die Instance authentifiziert.
1. Verwenden Sie den folgenden for-backend-server Befehl [set-load-balancer-policies-](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-policies-for-backend-server.html), `my-authentication-policy` um den Instanzport für HTTPS festzulegen. In diesem Beispiel ist der Instance-Port 443.
```
aws elb set-load-balancer-policies-for-backend-server --load-balancer-name my-loadbalancer --instance-port 443 --policy-names my-authentication-policy
```
1. (Optional) Verwenden Sie den folgenden [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)Befehl, um alle Richtlinien für Ihren Load Balancer aufzulisten:
```
aws elb describe-load-balancer-policies --load-balancer-name my-loadbalancer
```
1. (Optional) Verwenden Sie den folgenden [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)Befehl, um Details der Richtlinie anzuzeigen:
```
aws elb describe-load-balancer-policies --load-balancer-name my-loadbalancer --policy-names my-authentication-policy
```
### Schritt 4: Konfigurieren von Zustandsprüfungen (optional)
Elastic Load Balancing überprüft regelmäßig den Zustand der einzelnen registrierten EC2-Instances basierend auf den Zustandsprüfungen, die Sie konfiguriert haben. Wenn Elastic Load Balancing eine fehlerhafte Instance erkennt, wird der Datenverkehr nicht mehr an diese Instance gesendet und stattdessen an die fehlerfreien Instances geleitet. Weitere Informationen finden Sie unter [Zustandsprüfungen für die Instances für Ihren Classic Load Balancer](elb-healthchecks.md).
Wenn Sie Ihren Load Balancer erstellen, verwendet Elastic Load Balancing die Standardeinstellungen für die Zustandsprüfungen. Wenn Sie möchten, können Sie die Zustandsprüfungskonfiguration für Ihren Load Balancer ändern, anstatt die Standardeinstellungen zu verwenden.
**So konfigurieren Sie die Zustandsprüfungen für Ihre Instances**
Verwenden Sie den folgenden [configure-health-check](https://docs.aws.amazon.com/cli/latest/reference/elb/configure-health-check.html)-Befehl:
```
aws elb configure-health-check --load-balancer-name my-loadbalancer --health-check Target=HTTP:80/ping,Interval=30,UnhealthyThreshold=2,HealthyThreshold=2,Timeout=3
```
Nachfolgend finden Sie eine Beispielantwort:
```
{
"HealthCheck": {
"HealthyThreshold": 2,
"Interval": 30,
"Target": "HTTP:80/ping",
"Timeout": 3,
"UnhealthyThreshold": 2
}
}
```
### Schritt 5: Registrieren von EC2-Instances
Nachdem Sie Ihren Load Balancer erstellt haben, müssen Sie Ihre EC2-Instances beim Load Balancer registrieren. Sie können EC2-Instances aus einer einzigen Availability Zone oder aus mehreren Availability Zones in derselben Region wie der Load Balancer auswählen. Weitere Informationen finden Sie unter [Registrierte Instances pro Classic Load Balancer](elb-backend-instances.md).
Verwenden Sie den Befehl [register-instances-with-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elb/register-instances-with-load-balancer.html) wie folgt:
```
aws elb register-instances-with-load-balancer --load-balancer-name my-loadbalancer --instances i-4f8cf126 i-0bb7ca62
```
Nachfolgend finden Sie eine Beispielantwort:
```
{
"Instances": [
{
"InstanceId": "i-4f8cf126"
},
{
"InstanceId": "i-0bb7ca62"
}
]
}
```
### Schritt 6: Überprüfen der Instances
Ihr Load Balancer kann verwendet werden, sobald sich eine der registrierten Instances im Status `InService` befindet.
Verwenden Sie den folgenden Befehl, um den Status Ihrer neu registrierten EC2-Instances zu überprüfen: [describe-instance-health](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-instance-health.html)
```
aws elb describe-instance-health --load-balancer-name my-loadbalancer --instances i-4f8cf126 i-0bb7ca62
```
Nachfolgend finden Sie eine Beispielantwort:
```
{
"InstanceStates": [
{
"InstanceId": "i-4f8cf126",
"ReasonCode": "N/A",
"State": "InService",
"Description": "N/A"
},
{
"InstanceId": "i-0bb7ca62",
"ReasonCode": "Instance",
"State": "OutOfService",
"Description": "Instance registration is still in progress"
}
]
}
```
Wenn das Feld `State` für eine Instanz `OutOfService` ist, werden Ihre Instances immer noch registriert. Weitere Informationen finden Sie unter [Fehlerbehebung beim Classic Load Balancer: Instance-Registrierung](ts-elb-register-instance.md).
Nachdem der Status von mindestens einer Ihrer Instances `InService` ist, können Sie Ihren Load Balancer testen. Zum Testen des Load Balancers kopieren Sie den DNS-Namen des Load Balancers und fügen ihn in das Adressfeld eines mit dem Internet verbundenen Webbrowsers ein. Wenn Ihr Load Balancer verfügbar ist, sehen Sie die Standardseite Ihres HTTP-Servers.
### Schritt 7: Löschen des Load Balancers (optional)
Das Löschen eines Load Balancers hebt automatisch die Registrierung der zugehörigen EC2-Instances auf. Sobald der Load Balancer gelöscht ist, fallen keine weiteren Kosten für diesen Load Balancer mehr an. Doch die EC2-Instances werden weiter ausgeführt und verursachen weiterhin Kosten.
Verwenden Sie den folgenden [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elb/delete-load-balancer.html)Befehl, um Ihren Load Balancer zu löschen:
```
aws elb delete-load-balancer --load-balancer-name my-loadbalancer
```
Um Ihre EC2-Instances zu stoppen, verwenden Sie den Befehl [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html). Um Ihre EC2-Instances zu beenden, verwenden Sie den Befehl [terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html).
# Konfigurieren eines HTTPS-Listeners für Ihren Classic Load Balancer
Ein *Listener* ist ein Prozess, der Verbindungsanfragen überprüft. Er wird mit einem Protokoll und einem Port für Frontend-Verbindungen (Client zu Load Balancer) sowie einem Protokoll und einem Port für Backend-Verbindungen (Load Balancer zu Instance) konfiguriert. Weitere Informationen zu den von Elastic Load Balancing unterstützten Ports, Protokollen und Listener-Konfigurationen finden Sie unter [Listener für Ihren Classic Load Balancer](elb-listener-config.md).
Wenn Sie einen Load Balancer mit einem Listener haben, der HTTP-Anforderungen auf Port 80 akzeptiert, können Sie einen Listener hinzufügen, der HTTPS-Anforderungen auf Port 443 akzeptiert. Wenn Sie angeben, dass der HTTPS-Listener Anforderungen an die Instances auf Port 80 sendet, beendet der Load Balancer die SSL-Anforderungen und die Kommunikation über den Load Balancer an die Instances ist nicht verschlüsselt. Wenn der HTTPS-Listener Anforderungen an die Instances auf Port 443 sendet, ist die Kommunikation über den Load Balancer an die Instances verschlüsselt.
Wenn Ihr Load Balancer eine verschlüsselte Verbindung verwendet, um mit Instances zu kommunizieren, können Sie optional die Authentifizierung der Instances aktivieren. Auf diese Weise wird sichergestellt, dass der Load Balancer mit einer Instance nur dann kommuniziert, wenn der öffentliche Schlüssel mit dem angegebenen Schlüssel, den Sie zu diesem Zweck auf dem Load Balancer angegeben haben, übereinstimmt.
Weitere Informationen zum Erstellen eines neuen HTTPS-Listeners finden Sie unter [Erstellen eines Classic Load Balancers mit einem HTTPS-Listener](elb-create-https-ssl-load-balancer.md).
**Topics**
+ [Voraussetzungen](#add-listener-prerequisites)
+ [Hinzufügen eines HTTPS-Listeners mithilfe der Konsole](#add-listener-console)
+ [Fügen Sie einen HTTPS-Listener hinzu, indem Sie AWS CLI](#add-listener-cli)
## Voraussetzungen
Um die HTTPS-Unterstützung für einen HTTPS-Listener zu aktivieren, müssen Sie ein SSL-Zertifikat auf dem Load Balancer-Server bereitstellen. Der Load Balancer verwendet das Zertifikat zum Beenden und entschlüsselt dann Anforderungen vor der Übermittlung an die Instances. Wenn Sie nicht über ein SSL-Zertifikat verfügen, können Sie eins erstellen. Weitere Informationen finden Sie unter [SSL/TLS-Zertifikate für Classic Load Balancer](ssl-server-cert.md).
## Hinzufügen eines HTTPS-Listeners mithilfe der Konsole
Sie können einen HTTPS-Listener zu einem vorhandenen Load Balancer hinzufügen.
**Um Ihrem Load Balancer mithilfe der Konsole einen HTTPS-Listener hinzuzufügen**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich unter **LOAD BALANCING** die Option **Load Balancers** aus.
1. Wählen Sie den Namen des Load Balancers aus, um die Detailseite zu öffnen.
1. Wählen Sie auf der Registerkarte **Listeners** (Listener) die Option **Manage listeners** (Listener verwalten) aus.
1. Wählen Sie auf der Seite **Manage listeners** (Listener verwalten) im Abschnitt **Listeners** (Listener) die Option **Add listener** (Listener hinzufügen) aus.
1. Wählen Sie für **Listener protocol** (Listener-Protokoll) die Option **HTTPS** aus.
**Wichtig**
Das standardmäßige **Instance protocol** (Instance-Protokoll) ist HTTP. Wenn Sie Backend-Instance-Authentifizierung einrichten möchten, ändern Sie das **Instance protocol** (Instance-Protokoll) in HTTPS.
1. Für **Sicherheitsrichtlinien** empfehlen wir, die neueste vordefinierte Sicherheitsrichtlinie zu verwenden. Wenn Sie eine andere vordefinierte Sicherheitsrichtlinie verwenden möchten oder eine benutzerdefinierte Richtlinie erstellen müssen, finden Sie weitere Informationen unter [Aktualisieren der SSL-Aushandlungskonfiguration](ssl-config-update.md#ssl-config-update-console).
1. Wählen Sie für **Default SSL cert** (Standard-SSL-Zertifikat) die Option **Edit** (Bearbeiten) und gehen Sie dann wie folgt vor:
+ Wenn Sie ein Zertifikat mit erstellt oder importiert haben AWS Certificate Manager, wählen Sie **Aus ACM**, wählen Sie das Zertifikat aus der Liste aus und klicken Sie dann auf **Änderungen speichern**.
**Anmerkung**
Diese Option ist nur in den Regionen verfügbar, die AWS Certificate Manager unterstützen.
+ Wenn Sie ein Zertifikat mit IAM importiert haben, wählen Sie **From IAM** (Aus IAM), wählen Sie das Zertifikat aus der Liste und wählen Sie dann **Save changes** (Änderungen speichern).
+ Wenn Sie über ein SSL-Zertifikat verfügen, das in ACM importiert werden soll, wählen Sie **Import** und **To ACM** (In ACM) aus. Kopieren Sie den Inhalt der PEM-kodierten privaten Schlüsseldatei und fügen Sie ihn in das Feld **Certificate private key** (Privater Zertifikatsschlüssel) ein. Kopieren Sie den Inhalt der PEM-kodierten öffentlichen Schlüsselzertifikatdatei und fügen Sie ihn in das Feld **Certificate body** (Zertifikatstext) ein. Kopieren Sie den Inhalt der PEM-kodierten Zertifikatskettendatei und fügen Sie ihn in das Feld **Certificate chain - optional** (Zertifikats-Kette – optional) ein, es sei denn, Sie verwenden ein selbst signiertes Zertifikat und es ist nicht wichtig, dass Browser das Zertifikat implizit akzeptieren.
+ Wenn Sie ein SSL-Zertifikat zum Importieren haben, aber ACM in dieser Region nicht unterstützt wird, wählen Sie **Import** und **To IAM** (In ACM) aus. Geben Sie unter **Certificate name** (Zertifikatsname) den Namen des Zertifikats ein. Kopieren Sie den Inhalt der PEM-kodierten privaten Schlüsseldatei und fügen Sie ihn in das Feld **Certificate private key** (Privater Zertifikatsschlüssel) ein. Kopieren Sie den Inhalt der PEM-kodierten öffentlichen Schlüsselzertifikatdatei und fügen Sie ihn in das Feld **Certificate body** (Zertifikatstext) ein. Kopieren Sie den Inhalt der PEM-kodierten Zertifikatskettendatei und fügen Sie ihn in das Feld **Certificate chain - optional** (Zertifikats-Kette – optional) ein, es sei denn, Sie verwenden ein selbst signiertes Zertifikat und es ist nicht wichtig, dass Browser das Zertifikat implizit akzeptieren.
+ Wählen Sie **Änderungen speichern ** aus.
1. Für **Cookie stickiness** (Cookie-Stickiness) ist die Standardeinstellung **Disabled** (Deaktiviert). Um dies zu ändern, wählen Sie **Edit** (Bearbeiten). Wenn Sie **Generated by load balancer** (Generiert vom Load Balancer) wählen, muss ein **Expiration period** (Ablaufzeitraum) angegeben werden. Wenn Sie **Generated by application** (Generiert von der Anwendung) wählen, muss ein **Cookie name** (Cookie-Name) angegeben werden. Nachdem Sie Ihre Auswahl getroffen haben, wählen Sie **Save changes** (Änderungen speichern).
1. (Optional) Wählen Sie **Add listener** (Listener hinzufügen) zum Hinzufügen zusätzlicher Listener.
1. Wählen Sie **Save changes** (Änderungen speichern) zum Hinzufügen der Listener, die Sie gerade konfiguriert haben.
1. (Optional) Um die Back-End-Instance-Authentifizierung für einen vorhandenen Load Balancer einzurichten, müssen Sie die AWS CLI oder eine API verwenden, da diese Aufgabe über die Konsole nicht unterstützt wird. Weitere Informationen finden Sie unter [Konfigurieren der Backend-Instance-Authentifizierung](elb-create-https-ssl-load-balancer.md#configure_backendauth_clt).
## Fügen Sie einen HTTPS-Listener hinzu, indem Sie AWS CLI
Sie können einen HTTPS-Listener zu einem vorhandenen Load Balancer hinzufügen.
**Um Ihrem Load Balancer einen HTTPS-Listener hinzuzufügen, verwenden Sie AWS CLI**
1. Rufen Sie den Amazon-Ressourcennamen (ARN) des SSL-Zertifikats ab. Beispiel:
**ACM**
```
arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012
```
**IAM**
```
arn:aws:iam::123456789012:server-certificate/my-server-certificate
```
1. Verwenden Sie den folgenden [create-load-balancer-listeners](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-listeners.html)Befehl, um Ihrem Load Balancer einen Listener hinzuzufügen, der HTTPS-Anfragen an Port 443 akzeptiert und die Anfragen über HTTP an die Instances auf Port 80 sendet:
```
aws elb create-load-balancer-listeners --load-balancer-name my-load-balancer --listeners Protocol=HTTPS,LoadBalancerPort=443,InstanceProtocol=HTTP,InstancePort=80,SSLCertificateId=ARN
```
Wenn Sie die Backend-Instance-Authentifizierung einrichten möchten, verwenden Sie den folgenden Befehl, um einen Listener hinzuzufügen, der HTTPS-Anforderungen auf Port 443 akzeptiert und die Anforderungen an die Instances auf Port 443 mit HTTPS sendet:
```
aws elb create-load-balancer-listeners --load-balancer-name my-load-balancer --listeners Protocol=HTTPS,LoadBalancerPort=443,InstanceProtocol=HTTPS,InstancePort=443,SSLCertificateId=ARN
```
1. (Optional) Sie können den folgenden [describe-load-balancers](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancers.html)Befehl verwenden, um die aktualisierten Details Ihres Load Balancers anzuzeigen:
```
aws elb describe-load-balancers --load-balancer-name my-load-balancer
```
Nachfolgend finden Sie eine Beispielantwort:
```
{
"LoadBalancerDescriptions": [
{
...
"ListenerDescriptions": [
{
"Listener": {
"InstancePort": 80,
"SSLCertificateId": "ARN",
"LoadBalancerPort": 443,
"Protocol": "HTTPS",
"InstanceProtocol": "HTTP"
},
"PolicyNames": [
"ELBSecurityPolicy-2016-08"
]
},
{
"Listener": {
"InstancePort": 80,
"LoadBalancerPort": 80,
"Protocol": "HTTP",
"InstanceProtocol": "HTTP"
},
"PolicyNames": []
}
],
...
}
]
}
```
1. (Optional) Ihr HTTPS-Listener wurde mithilfe der Standardsicherheitsrichtlinie erstellt. Wenn Sie eine andere vordefinierte Sicherheitsrichtlinie oder eine benutzerdefinierte Sicherheitsrichtlinie angeben möchten, verwenden Sie die Befehle [create-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-policy.html)und [set-load-balancer-policies-of-listener](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-policies-of-listener.html). Weitere Informationen finden Sie unter [Aktualisieren Sie die SSL-Aushandlungskonfiguration mit dem AWS CLI](ssl-config-update.md#ssl-config-update-cli).
1. [(Optional) Verwenden Sie den Befehl -, um die Back-End-Instanzauthentifizierung einzurichten. set-load-balancer-policies for-backend-server](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-policies-for-backend-server.html) Weitere Informationen finden Sie unter [Konfigurieren der Backend-Instance-Authentifizierung](elb-create-https-ssl-load-balancer.md#configure_backendauth_clt).
# Ersetzen des SSL-Zertifikats für Ihren Classic Load Balancer
Wenn Sie über einen HTTPS-Listener verfügen, haben Sie beim Erstellen des Listeners ein SSL-Serverzertifikat auf dem Load Balancer bereitgestellt. Jedes Zertifikat verfügt über einen Gültigkeitszeitraum. Sie müssen sicherstellen, dass Sie das Zertifikat erneuern oder ersetzen, bevor die Gültigkeitsdauer endet.
Zertifikate, die von Ihrem Load Balancer bereitgestellt AWS Certificate Manager und dort bereitgestellt werden, können automatisch erneuert werden. ACM versucht, die Zertifikate zu verlängern, bevor sie ablaufen. Weitere Informationen finden Sie unter [Verwaltete Erneuerung](https://docs.aws.amazon.com/acm/latest/userguide/managed-renewal.html) im *AWS Certificate Manager -Benutzerhandbuch*. Wenn Sie ein Zertifikat in ACM importiert haben, müssen Sie das Ablaufdatum des Zertifikats überwachen und es vor dem Ablauf verlängern. Weitere Informationen finden Sie unter [Importieren von Zertifikaten](https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html) im *AWS Certificate Manager -Benutzerhandbuch*. Nachdem ein Zertifikat, das auf einem Load Balancer bereitgestellt ist, erneuert wurde, verwenden neue Anforderungen das erneuerte Zertifikat.
Um ein Zertifikat zu ersetzen, müssen Sie zunächst ein neues Zertifikat erstellen, indem Sie die gleichen Schritte ausführen, die Sie verwendet haben, als Sie das aktuelle Zertifikat erstellt haben. Dann können Sie das Zertifikat ersetzen. Nachdem ein Zertifikat, das auf einem Load Balancer bereitgestellt ist, ersetzt wurde, verwenden neue Anforderungen das neue Zertifikat.
Beachten Sie, dass sich das Erneuern oder Ersetzen eines Zertifikats nicht auf Anforderungen auswirkt, die bereits von einem Load Balancer-Knoten empfangen wurden und für die das Routing an ein funktionierendes Ziel aussteht.
**Topics**
+ [Ersetzen des SSL-Zertifikats mithilfe der Konsole](#us-update-lb-SSLcert-console)
+ [Ersetzen Sie das SSL-Zertifikat mit AWS CLI](#us-update-lb-SSLcert-cli)
## Ersetzen des SSL-Zertifikats mithilfe der Konsole
Sie können das auf Ihrem Load Balancer bereitgestellte Zertifikat durch ein Zertifikat von ACM oder ein in IAM hochgeladenes Zertifikat ersetzen.
**Um das SSL-Zertifikat für einen HTTPS-Load Balancer mithilfe der Konsole zu ersetzen**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich unter **LOAD BALANCING** die Option **Load Balancers** aus.
1. Wählen Sie den Namen des Load Balancers aus, um die Detailseite zu öffnen.
1. Wählen Sie auf der Registerkarte **Listeners** (Listener) die Option **Manage listeners** (Listener verwalten) aus.
1. Suchen Sie auf der Seite **Manage listeners** (Listener verwalten) den Listener, der aktualisiert werden soll, wählen Sie unter **Default SSL cert** (Standard-SSL-Zertifikat) die Option **Edit** (Bearbeiten) aus und führen Sie einen der folgenden Schritte aus:
+ Wenn Sie ein Zertifikat mit erstellt oder importiert haben AWS Certificate Manager, wählen Sie **Aus ACM**, wählen Sie das Zertifikat aus der Liste aus und klicken Sie dann auf Änderungen **speichern**.
**Anmerkung**
Diese Option ist nur in den Regionen verfügbar, die AWS Certificate Manager unterstützen.
+ Wenn Sie ein Zertifikat mit IAM importiert haben, wählen Sie **From IAM** (Aus IAM), wählen Sie das Zertifikat aus der Liste und wählen Sie dann **Save changes** (Änderungen speichern).
+ Wenn Sie über ein SSL-Zertifikat verfügen, das in ACM importiert werden soll, wählen Sie **Import** und **To ACM** (In ACM) aus. Kopieren Sie den Inhalt der PEM-kodierten privaten Schlüsseldatei und fügen Sie ihn in das Feld **Certificate private key** (Privater Zertifikatsschlüssel) ein. Kopieren Sie den Inhalt der PEM-kodierten öffentlichen Schlüsselzertifikatdatei und fügen Sie ihn in das Feld **Certificate body** (Zertifikatstext) ein. Kopieren Sie den Inhalt der PEM-kodierten Zertifikatskettendatei und fügen Sie ihn in das Feld **Certificate chain - optional** (Zertifikats-Kette – optional) ein, es sei denn, Sie verwenden ein selbst signiertes Zertifikat und es ist nicht wichtig, dass Browser das Zertifikat implizit akzeptieren.
+ Wenn Sie ein SSL-Zertifikat zum Importieren haben, aber ACM in dieser Region nicht unterstützt wird, wählen Sie **Import** und **To IAM** (In ACM) aus. Geben Sie unter **Certificate name** (Zertifikatsname) den Namen des Zertifikats ein. Kopieren Sie den Inhalt der PEM-kodierten privaten Schlüsseldatei und fügen Sie ihn in das Feld **Certificate private key** (Privater Zertifikatsschlüssel) ein. Kopieren Sie den Inhalt der PEM-kodierten öffentlichen Schlüsselzertifikatdatei und fügen Sie ihn in das Feld **Certificate body** (Zertifikatstext) ein. Kopieren Sie den Inhalt der PEM-kodierten Zertifikatskettendatei und fügen Sie ihn in das Feld **Certificate chain - optional** (Zertifikats-Kette – optional) ein, es sei denn, Sie verwenden ein selbst signiertes Zertifikat und es ist nicht wichtig, dass Browser das Zertifikat implizit akzeptieren.
+ Wählen Sie **Änderungen speichern ** aus.
## Ersetzen Sie das SSL-Zertifikat mit AWS CLI
Sie können das auf Ihrem Load Balancer bereitgestellte Zertifikat durch ein Zertifikat von ACM oder ein in IAM hochgeladenes Zertifikat ersetzen.
**So ersetzen Sie ein SSL-Zertifikat mit einem Zertifikat von ACM**
1. Verwenden Sie den folgenden Befehl [request-certificate](https://docs.aws.amazon.com/cli/latest/reference/acm/request-certificate.html), um ein neues Zertifikat anzufordern:
```
aws acm request-certificate --domain-name www.example.com
```
1. Verwenden Sie den folgenden Befehl [set-load-balancer-listener-ssl-certificate](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-listener-ssl-certificate.html), um das Zertifikat festzulegen:
```
aws elb set-load-balancer-listener-ssl-certificate --load-balancer-name my-load-balancer --load-balancer-port 443 --ssl-certificate-id arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012
```
**So ersetzen Sie ein SSL-Zertifikat mit einem von IAM hochgeladenen Zertifikat**
1. Wenn Sie über ein SSL-Zertifikat verfügen, aber es nicht hochgeladen haben, finden Sie weitere Informationen unter [Hochladen von Serverzertifikaten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html#upload-server-certificate) im *IAM-Benutzerhandbuch*.
1. Verwenden Sie den folgenden [get-server-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/get-server-certificate.html)Befehl, um den ARN des Zertifikats abzurufen:
```
aws iam get-server-certificate --server-certificate-name my-new-certificate
```
1. Verwenden Sie den folgenden Befehl [set-load-balancer-listener-ssl-certificate](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-listener-ssl-certificate.html), um das Zertifikat festzulegen:
```
aws elb set-load-balancer-listener-ssl-certificate --load-balancer-name my-load-balancer --load-balancer-port 443 --ssl-certificate-id arn:aws:iam::123456789012:server-certificate/my-new-certificate
```
# Aktualisieren der SSL-Aushandlungskonfiguration Ihres Classic Load Balancers
Elastic Load Balancing bietet Sicherheitsrichtlinien mit vordefinierten SSL-Aushandlungskonfigurationen zum Aushandeln von SSL-Verbindungen zwischen Clients und Ihrem Load Balancer. Wenn Sie das HTTPS/SSL Protokoll für Ihren Listener verwenden, können Sie eine der vordefinierten Sicherheitsrichtlinien oder Ihre eigene benutzerdefinierte Sicherheitsrichtlinie verwenden.
Weitere Informationen zu den Sicherheitsrichtlinien finden Sie unter [SSL-Aushandlungskonfigurationen für Classic Load Balancer](elb-ssl-security-policy.md). Weitere Informationen über die Konfigurationen der Sicherheitsrichtlinien von Elastic Load Balancing finden Sie unter [Vordefinierte SSL-Sicherheitsrichtlinien für Classic Load Balancer](elb-security-policy-table.md).
Wenn Sie einen HTTPS/SSL Listener erstellen, ohne eine Sicherheitsrichtlinie zuzuweisen, ordnet Elastic Load Balancing Ihrem Load Balancer die vordefinierte Standardsicherheitsrichtlinie zu. `ELBSecurityPolicy-2016-08`
Wenn Sie möchten, können Sie eine benutzerdefinierte Konfiguration erstellen. Wir empfehlen Ihnen dringend, Ihre Sicherheitsrichtlinie zu testen, bevor Sie Ihre Load Balancer-Konfiguration aktualisieren.
Die folgenden Beispiele zeigen Ihnen, wie Sie die SSL-Verhandlungskonfiguration für einen HTTPS/SSL Listener aktualisieren. Beachten Sie, dass die Änderung sich nicht auf Anforderungen auswirkt, die von einem Load Balancer-Knoten empfangen wurden und auf das Routing zu einer funktionierenden Instance warten, sondern die aktualisierte Konfiguration wird für neu empfangene Anforderungen verwendet.
**Topics**
+ [Aktualisieren der SSL-Aushandlungskonfiguration mit der Konsole](#ssl-config-update-console)
+ [Aktualisieren Sie die SSL-Aushandlungskonfiguration mit dem AWS CLI](#ssl-config-update-cli)
## Aktualisieren der SSL-Aushandlungskonfiguration mit der Konsole
Elastic Load Balancing ordnet Ihrem Load Balancer standardmäßig die neueste vordefinierte Richtlinie zu. Wenn eine neue vordefinierte Richtlinie hinzugefügt wird, sollten Sie Ihren Load Balancer mit der neuen vordefinierten Richtlinie aktualisieren. Alternativ können Sie eine andere vordefinierte Sicherheitsrichtlinie auswählen oder eine benutzerdefinierte Richtlinie erstellen.
**So aktualisieren Sie die SSL-Verhandlungskonfiguration für einen HTTPS/SSL Load Balancer mithilfe der Konsole**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich unter **LOAD BALANCING** die Option **Load Balancers** aus.
1. Wählen Sie den Namen des Load Balancers aus, um die Detailseite zu öffnen.
1. Wählen Sie auf der Registerkarte **Listeners** (Listener) die Option **Manage listeners** (Listener verwalten) aus.
1. Suchen Sie auf der Seite **Manage listeners** (Listener verwalten) den Listener, der aktualisiert werden soll, und wählen Sie unter **Security policy** (Sicherheitsrichtlinie) die Option **Edit** (Bearbeiten) aus. Wählen Sie mithilfe einer der folgenden Optionen eine Sicherheitsrichtlinie aus:
+ **Behalten Sie die Standardrichtlinie **ELBSecurityPolicy-2016-08** bei und wählen Sie dann Änderungen speichern aus.**
+ Wählen Sie eine andere vordefinierte Richtlinie als die Standardrichtlinie und wählen Sie dann **Save changes** (Änderungen speichern).
+ Wählen Sie **Custom** (Benutzerdefiniert) aus und aktivieren Sie mindestens ein Protokoll und eine Verschlüsselung wie folgt:
1. Wählen Sie für **SSL Protocols** ein oder mehrere Protokolle zur Aktivierung aus.
1. Wählen Sie für **SSL Options** die Option **Server Order Preference**, um den in der [Vordefinierte SSL-Sicherheitsrichtlinien für Classic Load Balancer](elb-security-policy-table.md) aufgelisteten Auftrag für die SSL-Aushandlung zu verwenden.
1. Wählen Sie für **SSL Ciphers** eine oder mehrere Verschlüsselungen zur Aktivierung aus. Wenn Sie bereits ein SSL-Zertifikat haben, müssen Sie die Verschlüsselung aktivieren, mit der das Zertifikat erstellt wurde, da DSA- und RSA-Verschlüsselung spezifisch für den Signaturalgorithmus sind.
1. Wählen Sie **Änderungen speichern ** aus.
## Aktualisieren Sie die SSL-Aushandlungskonfiguration mit dem AWS CLI
Sie können die vordefinierte Standardsicherheitsrichtlinie `ELBSecurityPolicy-2016-08` verwenden, eine andere vordefinierte Sicherheitsrichtlinie oder eine benutzerdefinierte Sicherheitsrichtlinie.
**Verwendung einer vordefinierten SSL-Sicherheitsrichtlinie**
1. Verwenden Sie den folgenden [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)Befehl, um die vordefinierten Sicherheitsrichtlinien aufzulisten, die von Elastic Load Balancing bereitgestellt werden. Die Syntax, die Sie verwenden, ist vom verwendeten Betriebssystem und der Shell abhängig.
**Linux**
```
aws elb describe-load-balancer-policies --query 'PolicyDescriptions[?PolicyTypeName==`SSLNegotiationPolicyType`].{PolicyName:PolicyName}' --output table
```
**Windows**
```
aws elb describe-load-balancer-policies --query "PolicyDescriptions[?PolicyTypeName==`SSLNegotiationPolicyType`].{PolicyName:PolicyName}" --output table
```
Das Folgende ist eine Beispielausgabe:
```
------------------------------------------
| DescribeLoadBalancerPolicies |
+----------------------------------------+
| PolicyName |
+----------------------------------------+
| ELBSecurityPolicy-2016-08 |
| ELBSecurityPolicy-TLS-1-2-2017-01 |
| ELBSecurityPolicy-TLS-1-1-2017-01 |
| ELBSecurityPolicy-2015-05 |
| ELBSecurityPolicy-2015-03 |
| ELBSecurityPolicy-2015-02 |
| ELBSecurityPolicy-2014-10 |
| ELBSecurityPolicy-2014-01 |
| ELBSecurityPolicy-2011-08 |
| ELBSample-ELBDefaultCipherPolicy |
| ELBSample-OpenSSLDefaultCipherPolicy |
+----------------------------------------+
```
Um zu bestimmen, welche Verschlüsselungsverfahren für eine Richtlinie aktiviert sind, verwenden Sie den folgenden Befehl:
```
aws elb describe-load-balancer-policies --policy-names ELBSecurityPolicy-2016-08 --output table
```
Informationen über die Konfiguration mit vordefinierten Sicherheitsrichtlinien finden Sie unter [Vordefinierte SSL-Sicherheitsrichtlinien für Classic Load Balancer](elb-security-policy-table.md).
1. Verwenden Sie den [create-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-policy.html)Befehl, um eine SSL-Verhandlungsrichtlinie mit einer der vordefinierten Sicherheitsrichtlinien zu erstellen, die Sie im vorherigen Schritt beschrieben haben. Der folgende Befehl verwendet beispielsweise die vordefinierte Standardsicherheitsrichtlinie:
```
aws elb create-load-balancer-policy --load-balancer-name my-loadbalancer
--policy-name my-SSLNegotiation-policy --policy-type-name SSLNegotiationPolicyType
--policy-attributes AttributeName=Reference-Security-Policy,AttributeValue=ELBSecurityPolicy-2016-08
```
Wenn Sie das Limit für die Anzahl der Richtlinien für den Load Balancer überschreiten, verwenden Sie den [delete-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/delete-load-balancer-policy.html)Befehl, um alle nicht verwendeten Richtlinien zu löschen.
1. (Optional) Verwenden Sie den folgenden [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)Befehl, um zu überprüfen, ob die Richtlinie erstellt wurde:
```
aws elb describe-load-balancer-policies --load-balancer-name my-loadbalancer --policy-name my-SSLNegotiation-policy
```
Die Antwort enthält die Beschreibung der Richtlinie.
1. Verwenden Sie den folgenden Befehl [set-load-balancer-policies-of-listener](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-policies-of-listener.html), um die Richtlinie auf dem Load Balancer-Port 443 zu aktivieren:
```
aws elb set-load-balancer-policies-of-listener --load-balancer-name my-loadbalancer --load-balancer-port 443 --policy-names my-SSLNegotiation-policy
```
**Anmerkung**
Der Befehl `set-load-balancer-policies-of-listener` ersetzt die aktuellen Richtlinien für den angegebenen Load Balancer-Port durch die angegebenen Richtlinien. Die Liste `--policy-names` muss alle zu aktivierenden Richtlinien enthalten. Wenn Sie eine Richtlinie auslassen, die derzeit aktiviert ist, wird sie deaktiviert.
1. (Optional) Verwenden Sie den folgenden [describe-load-balancers](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancers.html)Befehl, um zu überprüfen, ob die neue Richtlinie für den Load Balancer-Port aktiviert ist:
```
aws elb describe-load-balancers --load-balancer-name my-loadbalancer
```
Die Antwort zeigt, dass die Richtlinie auf Port 443 aktiviert ist.
```
...
{
"Listener": {
"InstancePort": 443,
"SSLCertificateId": "ARN",
"LoadBalancerPort": 443,
"Protocol": "HTTPS",
"InstanceProtocol": "HTTPS"
},
"PolicyNames": [
"my-SSLNegotiation-policy"
]
}
...
```
Wenn Sie eine benutzerdefinierte Sicherheitsrichtlinie erstellen, müssen Sie mindestens ein Protokoll und eine Verschlüsselung aktivieren. Die DSA- und RSA-Verschlüsselungen gelten speziell für den Signaturalgorithmus zum Erstellen von SSL-Zertifikaten. Wenn Sie bereits über ein SSL-Zertifikat verfügen, müssen Sie die Verschlüsselung aktivieren, mit der das Zertifikat erstellt wurde. Der Name der benutzerdefinierten Richtlinie darf nicht mit `ELBSecurityPolicy-` oder `ELBSample-` beginnen, da diese Präfixe für die Namen der vordefinierten Sicherheitsrichtlinien definiert sind.
**Verwendung einer benutzerdefinierten SSL-Sicherheitsrichtlinie**
1. Verwenden Sie den [create-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/create-load-balancer-policy.html)Befehl, um eine SSL-Verhandlungsrichtlinie mithilfe einer benutzerdefinierten Sicherheitsrichtlinie zu erstellen. Beispiel:
```
aws elb create-load-balancer-policy --load-balancer-name my-loadbalancer
--policy-name my-SSLNegotiation-policy --policy-type-name SSLNegotiationPolicyType
--policy-attributes AttributeName=Protocol-TLSv1.2,AttributeValue=true
AttributeName=Protocol-TLSv1.1,AttributeValue=true
AttributeName=DHE-RSA-AES256-SHA256,AttributeValue=true
AttributeName=Server-Defined-Cipher-Order,AttributeValue=true
```
Wenn Sie das Limit für die Anzahl der Richtlinien für den Load Balancer überschreiten, verwenden Sie den [delete-load-balancer-policy](https://docs.aws.amazon.com/cli/latest/reference/elb/delete-load-balancer-policy.html)Befehl, um alle nicht verwendeten Richtlinien zu löschen.
1. (Optional) Verwenden Sie den folgenden [describe-load-balancer-policies](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancer-policies.html)Befehl, um zu überprüfen, ob die Richtlinie erstellt wurde:
```
aws elb describe-load-balancer-policies --load-balancer-name my-loadbalancer --policy-name my-SSLNegotiation-policy
```
Die Antwort enthält die Beschreibung der Richtlinie.
1. Verwenden Sie den folgenden Befehl [set-load-balancer-policies-of-listener](https://docs.aws.amazon.com/cli/latest/reference/elb/set-load-balancer-policies-of-listener.html), um die Richtlinie auf dem Load Balancer-Port 443 zu aktivieren:
```
aws elb set-load-balancer-policies-of-listener --load-balancer-name my-loadbalancer --load-balancer-port 443 --policy-names my-SSLNegotiation-policy
```
**Anmerkung**
Der Befehl `set-load-balancer-policies-of-listener` ersetzt die aktuellen Richtlinien für den angegebenen Load Balancer-Port durch die angegebenen Richtlinien. Die Liste `--policy-names` muss alle zu aktivierenden Richtlinien enthalten. Wenn Sie eine Richtlinie auslassen, die derzeit aktiviert ist, wird sie deaktiviert.
1. (Optional) Verwenden Sie den folgenden [describe-load-balancers](https://docs.aws.amazon.com/cli/latest/reference/elb/describe-load-balancers.html)Befehl, um zu überprüfen, ob die neue Richtlinie für den Load Balancer-Port aktiviert ist:
```
aws elb describe-load-balancers --load-balancer-name my-loadbalancer
```
Die Antwort zeigt, dass die Richtlinie auf Port 443 aktiviert ist.
```
...
{
"Listener": {
"InstancePort": 443,
"SSLCertificateId": "ARN",
"LoadBalancerPort": 443,
"Protocol": "HTTPS",
"InstanceProtocol": "HTTPS"
},
"PolicyNames": [
"my-SSLNegotiation-policy"
]
}
...
```