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. # Konfiguration der HTTPS-Terminierung auf der Instanz Sie können [Konfigurationsdateien](ebextensions.md) zum Konfigurieren des Proxy-Servers verwenden, der Datenverkehr an Ihre Anwendung weiterleitet, um HTTPS-Verbindungen zu beenden. Dies ist nützlich, wenn Sie HTTPS mit einer Umgebung mit einer einzelnen Instance verwenden möchten, oder wenn Sie den Load Balancer so konfigurieren möchten, dass Datenverkehr durchgeht, ohne entschlüsselt werden. Um HTTPS zu aktivieren, müssen Sie eingehenden Traffic auf Port 443 zu der EC2 Instance zulassen, auf der Ihre Elastic Beanstalk Beanstalk-Anwendung läuft. Verwenden Sie dazu den `Resources` Schlüssel in der Konfigurationsdatei, um den Eingangsregeln für die AWSEBSecurity Gruppensicherheitsgruppe eine Regel für Port 443 hinzuzufügen. Der folgende Codeausschnitt fügt eine entsprechende Ingress-Regel zur `AWSEBSecurityGroup`-Sicherheitsgruppe hinzu, die Port 443 für allen Datenverkehr für eine Umgebung mit einer einzelnen Instance öffnet: **`.ebextensions/https-instance-securitygroup.config`** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` In einer Umgebung mit Load-Balancing in einer [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/)-Standardumgebung (Amazon VPC) können Sie diese Richtlinie so ändern, dass nur Datenverkehr vom Load Balancer akzeptiert wird. Ein Beispiel finden Sie unter [Konfiguration der end-to-end Verschlüsselung in einer Elastic Beanstalk Beanstalk-Umgebung mit Lastenausgleich](configuring-https-endtoend.md). **Topics** + [Beenden von HTTPS auf EC2-Instances, auf denen Docker ausgeführt wird](https-singleinstance-docker.md) + [Beenden von HTTPS auf EC2 Instances, auf denen Go ausgeführt wird](https-singleinstance-go.md) + [Beenden von HTTPS auf EC2-Instances, auf denen Java SE ausgeführt wird](https-singleinstance-java.md) + [Beenden von HTTPS auf EC2-Instances, auf denen Node.js ausgeführt wird](https-singleinstance-nodejs.md) + [Beenden von HTTPS auf EC2 Instanzen, auf denen PHP ausgeführt wird](https-singleinstance-php.md) + [Beenden von HTTPS auf EC2-Instances, auf denen Python ausgeführt wird](https-singleinstance-python.md) + [Beenden von HTTPS auf EC2-Instances, auf denen Ruby ausgeführt wird](https-singleinstance-ruby.md) + [Beenden von HTTPS auf EC2-Instances, auf denen Tomcat ausgeführt wird](https-singleinstance-tomcat.md) + [HTTPS auf Amazon EC2-Instances mit .NET Core unter Linux terminieren](https-singleinstance-dotnet-linux.md) + [Beenden von HTTPS auf EC2 Amazon-Instances, auf denen .NET ausgeführt wird](SSLNET.SingleInstance.md) # Beenden von HTTPS auf EC2-Instances, auf denen Docker ausgeführt wird Verwenden Sie bei Docker-Containern eine [Konfigurationsdatei](ebextensions.md) für die HTTPS-Aktivierung. Fügen Sie der Konfigurationsdatei das folgende Snippet hinzu, folgen Sie den Anweisungen, um die Daten für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im Quell-Bundle im Verzeichnis `.ebextensions`. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/nginx/conf.d/https.conf` Konfiguriert den nginx-Server. Diese Datei wird mit dem Start des nginx-Service geladen. `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. *certificate file contents*Ersetzen Sie es durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. **Example .ebextensions/https-instance.config** ``` files: /etc/nginx/conf.d/https.conf: mode: "000644" owner: root group: root content: | # HTTPS Server server { listen 443; server_name localhost; ssl on; ssl_certificate /etc/pki/tls/certs/server.crt; ssl_certificate_key /etc/pki/tls/certs/server.key; ssl_session_timeout 5m; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; location / { proxy_pass http://docker; proxy_http_version 1.1; proxy_set_header Connection ""; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto https; } } /etc/pki/tls/certs/server.crt: mode: "000400" owner: root group: root content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: mode: "000400" owner: root group: root content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # Beenden von HTTPS auf EC2 Instances, auf denen Go ausgeführt wird Verwenden Sie bei Go-Containertypen eine [Konfigurationsdatei](ebextensions.md) für die HTTPS-Aktivierung sowie eine nginx-Konfigurationsdatei, um den nginx-Server für die Verwendung von HTTPS zu konfigurieren. Fügen Sie der Konfigurationsdatei das folgende Snippet hinzu, folgen Sie den Anweisungen, um die Platzhalter für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im Quell-Bundle im Verzeichnis `.ebextensions`. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `Resources` aktiviert Port 443 auf der Sicherheitsgruppe, die von der Umgebungs-Instance verwendet wird. + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. *certificate file contents*Ersetzen Sie es durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. **Example .ebextensions/https-instance.config** ``` files: /etc/pki/tls/certs/server.crt: content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). Binden Sie folgendes Snippet in eine `.conf`-Datei ein und platzieren Sie diese im Verzeichnis `.ebextensions/nginx/conf.d/` des Quell-Bundles (z. B. `.ebextensions/nginx/conf.d/https.conf`). *app\$1port*Ersetzen Sie es durch die Portnummer, auf der Ihre Anwendung lauscht. In diesem Beispiel wird der nginx-Server zur Überwachung von Port 443 mit SSL konfiguriert. Weitere Informationen zu diesen Konfigurationsdateien für die Go-Plattform finden Sie unter [Konfigurieren des Proxy-Server](go-nginx.md). **Example . ebextensions/nginx/conf.d/https.conf** ``` # HTTPS server server { listen 443; server_name localhost; ssl on; ssl_certificate /etc/pki/tls/certs/server.crt; ssl_certificate_key /etc/pki/tls/certs/server.key; ssl_session_timeout 5m; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; location / { proxy_pass http://localhost:app_port; proxy_set_header Connection ""; proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto https; } } ``` In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # Beenden von HTTPS auf EC2-Instances, auf denen Java SE ausgeführt wird Verwenden Sie bei Java SE-Containertypen eine .ebextensions-[Konfigurationsdatei](ebextensions.md) für die HTTPS-Aktivierung sowie eine nginx-Konfigurationsdatei, um den nginx-Server für die Verwendung von HTTPS zu konfigurieren. Alle AL2023 AL2 /-Plattformen unterstützen eine einheitliche Proxykonfigurationsfunktion. Weitere Informationen zur Konfiguration des Proxyservers auf Ihren Plattformversionen, auf denen AL2023/ausgeführt wirdAL2, finden Sie unter[Reverse-Proxy-Konfiguration](platforms-linux-extend.proxy.md). Fügen Sie der Konfigurationsdatei das folgende Snippet hinzu, folgen Sie den Anweisungen, um die Platzhalter für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im Verzeichnis `.ebextensions`. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. *certificate file contents*Ersetzen Sie es durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. **Example .ebextensions/https-instance.config** ``` files: /etc/pki/tls/certs/server.crt: content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). Binden Sie folgendes Snippet in eine `.conf`-Datei ein und platzieren Sie diese im Verzeichnis `.ebextensions/nginx/conf.d/` des Quell-Bundles (z. B. `.ebextensions/nginx/conf.d/https.conf`). *app\$1port*Ersetzen Sie es durch die Portnummer, auf der Ihre Anwendung lauscht. In diesem Beispiel wird der nginx-Server zur Überwachung von Port 443 mit SSL konfiguriert. Weitere Informationen zu diesen Konfigurationsdateien für die Java SE-Plattform finden Sie unter [Konfigurieren des Proxy-Server](java-se-nginx.md). **Example . ebextensions/nginx/conf.d/https.conf** ``` # HTTPS server server { listen 443; server_name localhost; ssl on; ssl_certificate /etc/pki/tls/certs/server.crt; ssl_certificate_key /etc/pki/tls/certs/server.key; ssl_session_timeout 5m; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; location / { proxy_pass http://localhost:app_port; proxy_set_header Connection ""; proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto https; } } ``` In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # Beenden von HTTPS auf EC2-Instances, auf denen Node.js ausgeführt wird Die folgende Beispielkonfigurationsdatei [erweitert die Standard-Nginx-Konfiguration](nodejs-platform-proxy.md) so, dass sie Port 443 abhört und SSL/TLS Verbindungen mit einem öffentlichen Zertifikat und einem privaten Schlüssel beendet. Wenn Sie Ihre Umgebung für [erweiterte Zustandsberichte](health-enhanced.md) konfiguriert haben, müssen Sie nginx für die Generierung von Zugriffsprotokollen konfigurieren. Hierzu muss die Auskommentierung des Zeilenblocks unter dem Kommentar mit dem Text `# For enhanced health...` durch Entfernen der führenden `#`-Zeichen erfolgen. **Example .ebextensions/https-instance.config** ``` files: /etc/nginx/conf.d/https.conf: mode: "000644" owner: root group: root content: | # HTTPS server server { listen 443; server_name localhost; ssl on; ssl_certificate /etc/pki/tls/certs/server.crt; ssl_certificate_key /etc/pki/tls/certs/server.key; ssl_session_timeout 5m; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; # For enhanced health reporting support, uncomment this block: #if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") { # set $year $1; # set $month $2; # set $day $3; # set $hour $4; #} #access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd; #access_log /var/log/nginx/access.log main; location / { proxy_pass http://nodejs; proxy_set_header Connection ""; proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto https; } } /etc/pki/tls/certs/server.crt: mode: "000400" owner: root group: root content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: mode: "000400" owner: root group: root content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- ``` Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/nginx/conf.d/https.conf` Konfiguriert den nginx-Server. Diese Datei wird mit dem Start des nginx-Service geladen. `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. Ersetzen Sie es *certificate file contents* durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # Beenden von HTTPS auf EC2 Instanzen, auf denen PHP ausgeführt wird Verwenden Sie bei PHP-Containertypen eine [Konfigurationsdatei](ebextensions.md), um den Apache HTTP-Server für die Verwendung von HTTPS zu aktivieren. Fügen Sie der Konfigurationsdatei das folgende Snippet hinzu, folgen Sie den Anweisungen, um die Daten für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im Quell-Bundle im Verzeichnis `.ebextensions`. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `packages` nutzt "yum" für die Installation von `mod24_ssl`. + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/httpd/conf.d/ssl.conf` Konfiguriert den Apache-Server. Diese Datei wird mit dem Start des Apache-Service geladen. `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. *certificate file contents*Ersetzen Sie es durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. **Example .ebextensions/https-instance.config** ``` packages: yum: mod24_ssl : [] files: /etc/httpd/conf.d/ssl.conf: mode: "000644" owner: root group: root content: | LoadModule ssl_module modules/mod_ssl.so Listen 443 Order deny,allow Allow from all SSLEngine on SSLCertificateFile "/etc/pki/tls/certs/server.crt" SSLCertificateKeyFile "/etc/pki/tls/certs/server.key" SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH SSLProtocol All -SSLv2 -SSLv3 SSLHonorCipherOrder On SSLSessionTickets Off Header always set Strict-Transport-Security "max-age=63072000; includeSubdomains; preload" Header always set X-Frame-Options DENY Header always set X-Content-Type-Options nosniff ProxyPass / http://localhost:80/ retry=0 ProxyPassReverse / http://localhost:80/ ProxyPreserveHost on RequestHeader set X-Forwarded-Proto "https" early /etc/pki/tls/certs/server.crt: mode: "000400" owner: root group: root content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: mode: "000400" owner: root group: root content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # Beenden von HTTPS auf EC2-Instances, auf denen Python ausgeführt wird Für Python-Containertypen mit Apache HTTP-Server mit dem Web Server Gateway Interface (WSGI) verwenden Sie eine [Konfigurationsdatei](ebextensions.md), um den Apache HTTP-Server für die Verwendung von HTTPS zu aktivieren. Fügen Sie der [Konfigurationsdatei](ebextensions.md) das folgende Snippet hinzu. Folgen Sie den Anweisungen, um die Daten für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im `.ebextensions`-Verzeichnis des Quell-Bundles. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `packages` nutzt "yum" für die Installation von `mod_ssl`. + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/httpd/conf.d/ssl.conf` Konfiguriert den Apache-Server. Wenn Ihre Anwendung nicht den Namen `application.py` hat, ersetzen Sie den markierten Text im Wert für `WSGIScriptAlias` durch den lokalen Pfad zu Ihrer Anwendung. Beispiel: Eine Django-Anwendung kann sich zum Beispiel unter `django/wsgi.py` befinden. Der Speicherort sollte mit dem Wert der `WSGIPath`-Option, die Sie für Ihre Umgebung festlegen, übereinstimmen. Abhängig von den Anforderungen Ihrer Anwendung müssen Sie auch andere Verzeichnisse zum **python-path**-Parameter hinzufügen. `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. *certificate file contents*Ersetzen Sie es durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. + Mit dem Schlüssel `container_commands` wird der httpd-Service nach der abgeschlossenen Konfiguration beendet, sodass der Service die neue `https.conf`-Datei und das entsprechende Zertifikat verwendet. **Anmerkung** Das Beispiel funktioniert nur in Umgebungen, die die [Python](create-deploy-python-container.md)-Plattform verwenden. **Example .ebextensions/https-instance.config** ``` packages: yum: mod_ssl: [] files: /etc/httpd/conf.d/ssl.conf: mode: "000644" owner: root group: root content: | LoadModule wsgi_module modules/mod_wsgi.so WSGIPythonHome /var/app/venv/staging-LQM1lest WSGISocketPrefix run/wsgi WSGIRestrictEmbedded On Listen 443 SSLEngine on SSLCertificateFile "/etc/pki/tls/certs/server.crt" SSLCertificateKeyFile "/etc/pki/tls/certs/server.key" Alias /static/ /var/app/current/static/ Order allow,deny Allow from all WSGIScriptAlias / /var/app/current/application.py Require all granted WSGIDaemonProcess wsgi-ssl processes=1 threads=15 display-name=%{GROUP} \ python-path=/var/app/current \ python-home=/var/app/venv/staging-LQM1lest \ home=/var/app/current \ user=webapp \ group=webapp WSGIProcessGroup wsgi-ssl /etc/pki/tls/certs/server.crt: mode: "000400" owner: root group: root content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: mode: "000400" owner: root group: root content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- container_commands: 01killhttpd: command: "killall httpd" 02waitforhttpddeath: command: "sleep 3" ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). **Hinweis für Amazon Linux 2023-Umgebungen** Auf Amazon Linux 2023 `mod_wsgi` muss es separat installiert werden, da es nicht in den Paket-Repositorys verfügbar ist. Installationsanweisungen finden Sie unter [mod\$1wsgi](https://pypi.org/project/mod-wsgi/) auf PyPI. In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # Beenden von HTTPS auf EC2-Instances, auf denen Ruby ausgeführt wird Bei Ruby-Containertypen hängt die Art und Weise der HTTPS-Aktivierung vom eingesetzten Anwendungsserver ab. **Topics** + [Konfigurieren von HTTPS für Ruby mit Puma](#Puma) + [Konfigurieren von HTTPS für Ruby mit Passenger](#Passenger) ## Konfigurieren von HTTPS für Ruby mit Puma Verwenden Sie bei Ruby-Containertypen, die einen Puma-Anwendungsserver nutzen, eine [Konfigurationsdatei](ebextensions.md) für die HTTPS-Aktivierung. Fügen Sie der Konfigurationsdatei das folgende Snippet hinzu, folgen Sie den Anweisungen, um die Daten für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im Quell-Bundle im Verzeichnis `.ebextensions`. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/nginx/conf.d/https.conf` Konfiguriert den nginx-Server. Diese Datei wird mit dem Start des nginx-Service geladen. `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. *certificate file contents*Ersetzen Sie es durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. **Example .ebextensions/https-instance.config** ``` files: /etc/nginx/conf.d/https.conf: content: | # HTTPS server server { listen 443; server_name localhost; ssl on; ssl_certificate /etc/pki/tls/certs/server.crt; ssl_certificate_key /etc/pki/tls/certs/server.key; ssl_session_timeout 5m; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; location / { proxy_pass http://my_app; proxy_set_header Host $host; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto https; } location /assets { alias /var/app/current/public/assets; gzip_static on; gzip on; expires max; add_header Cache-Control public; } location /public { alias /var/app/current/public; gzip_static on; gzip on; expires max; add_header Cache-Control public; } } /etc/pki/tls/certs/server.crt: content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end ## Konfigurieren von HTTPS für Ruby mit Passenger Verwenden Sie bei Ruby-Containertypen, die einen Passenger-Anwendungsserver nutzen, sowohl eine Konfigurationsdatei als auch eine JSON-Datei für die HTTPS-Aktivierung. **So konfigurieren Sie HTTPS für Ruby mit Passenger** 1. Fügen Sie der Konfigurationsdatei das folgende Snippet hinzu, folgen Sie den Anweisungen, um die Daten für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im Quell-Bundle im Verzeichnis `.ebextensions`. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. Ersetzen Sie es durch den Inhalt Ihres *certificate file contents* Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. **Example .Ebextensions-Snippet zum Konfigurieren von HTTPS für Ruby mit Passenger** ``` files: /etc/pki/tls/certs/server.crt: content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). 1. Erstellen Sie eine Textdatei und fügen Sie die folgenden JSON-Daten ein. Speichern Sie die Datei im Stammverzeichnis des Quell-Bundles mit dem Namen `passenger-standalone.json`. Mit dieser JSON-Datei wird Passenger für die Verwendung von HTTPS konfiguriert. **Wichtig** Die JSON-Datei darf keine Markierung der Bytereihenfolge enthalten. Sollte das der Fall sein, kann die Passenger-JSON-Bibliothek die Datei nicht korrekt lesen und der Passenger-Service wird nicht gestartet. **Example passenger-standalone.json** ``` { "ssl" : true, "ssl_port" : 443, "ssl_certificate" : "/etc/pki/tls/certs/server.crt", "ssl_certificate_key" : "/etc/pki/tls/certs/server.key" } ``` In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # Beenden von HTTPS auf EC2-Instances, auf denen Tomcat ausgeführt wird Verwenden Sie bei Tomcat-Containertypen eine [Konfigurationsdatei](ebextensions.md), um den Apache HTTP-Server für die Verwendung von HTTPS zu aktivieren, wenn dieser als Reverse-Proxy-Server für Tomcat eingesetzt wird. Fügen Sie der Konfigurationsdatei das folgende Snippet hinzu, folgen Sie den Anweisungen, um die Daten für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im Quell-Bundle im Verzeichnis `.ebextensions`. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. *certificate file contents*Ersetzen Sie es durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. `/opt/elasticbeanstalk/hooks/appdeploy/post/99_start_httpd.sh` Erstellt nach der Bereitstellung ein Hook-Skript für den Neustart des httpd-Service. **Example .ebextensions/https-instance.config** ``` files: /etc/pki/tls/certs/server.crt: mode: "000400" owner: root group: root content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: mode: "000400" owner: root group: root content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- /opt/elasticbeanstalk/hooks/appdeploy/post/99_start_httpd.sh: mode: "000755" owner: root group: root content: | #!/usr/bin/env bash sudo service httpd restart ``` Sie müssen auch den Proxy-Server Ihrer Umgebung für die Überwachung von Port 443 konfigurieren. Mit der folgenden Apache 2.4-Konfiguration wird ein Listener auf Port 443 hinzugefügt: Weitere Informationen hierzu finden Sie unter [Konfigurieren des Proxy-Server](java-tomcat-proxy.md). **Example . ebextensions/httpd/conf.d/ssl.conf** ``` Listen 443 ServerName server-name SSLEngine on SSLCertificateFile "/etc/pki/tls/certs/server.crt" SSLCertificateKeyFile "/etc/pki/tls/certs/server.key" Require all granted ProxyPass / http://localhost:8080/ retry=0 ProxyPassReverse / http://localhost:8080/ ProxyPreserveHost on ErrorLog /var/log/httpd/elasticbeanstalk-ssl-error_log ``` Möglicherweise erhalten Sie von Ihrem Zertifikatanbieter auch Zwischenzertifikate, die Sie für eine bessere Kompatibilität mit mobilen Clients installieren können. Konfigurieren Sie Apache mit einem Zwischenzertifizierungsstellen-Bundle, indem Sie Folgendes zur SSL-Konfigurationsdatei hinzufügen (siehe [Erweiterung und Außerkraftsetzung der Apache-Standardkonfiguration — Amazon Linux AMI () AL1](java-tomcat-proxy.md#java-tomcat-proxy-apache) für die Platzierung): + Geben Sie in den `ssl.conf`-Dateiinhalten die Chain-Datei an: ``` SSLCertificateKeyFile "/etc/pki/tls/certs/server.key" SSLCertificateChainFile "/etc/pki/tls/certs/gd_bundle.crt" SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH ``` + Fügen Sie dem Schlüssel `files` einen neuen Eintrag mit den Inhalten der Zwischenzertifikate hinzu: ``` files: /etc/pki/tls/certs/gd_bundle.crt: mode: "000400" owner: root group: root content: | -----BEGIN CERTIFICATE----- First intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- Second intermediate certificate -----END CERTIFICATE----- ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # HTTPS auf Amazon EC2-Instances mit .NET Core unter Linux terminieren Sie verwenden für .NT Core on Linux-Containertypen eine `.ebextensions`-[Konfigurationsdatei](ebextensions.md), um HTTPS zu aktivieren, und eine nginx-Konfigurationsdatei, um den nginx-Server für die Verwendung von HTTPS zu konfigurieren. Fügen Sie der Konfigurationsdatei das folgende Snippet hinzu, folgen Sie den Anweisungen, um die Platzhalter für Zertifikat und privaten Schlüssel zu ersetzen, und speichern Sie dies im Verzeichnis `.ebextensions`. Von der Konfigurationsdatei werden folgende Schritte ausgeführt: + Der Schlüssel `files` generiert folgende Dateien auf der Instance: `/etc/pki/tls/certs/server.crt` Damit wird die Zertifikatdatei auf der Instance erstellt. *certificate file contents*Ersetzen Sie es durch den Inhalt Ihres Zertifikats. Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet. Wenn Zwischenzertifikate vorhanden sind, nehmen Sie sie nach Ihrem Site-Zertifikat in `server.crt` auf. ``` -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- first intermediate certificate -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- second intermediate certificate -----END CERTIFICATE----- ``` `/etc/pki/tls/certs/server.key` Damit wird die private Schlüsseldatei auf der Instance erstellt. *private key contents*Ersetzen Sie es durch den Inhalt des privaten Schlüssels, der zur Erstellung der Zertifikatsanforderung oder des selbstsignierten Zertifikats verwendet wurde. **Example .ebextensions/https-instance.config** ``` files: /etc/pki/tls/certs/server.crt: content: | -----BEGIN CERTIFICATE----- certificate file contents -----END CERTIFICATE----- /etc/pki/tls/certs/server.key: content: | -----BEGIN RSA PRIVATE KEY----- private key contents # See note below. -----END RSA PRIVATE KEY----- ``` **Anmerkung** Führen Sie möglichst keinen Commit für eine Konfigurationsdatei, die Ihren privaten Schlüssel enthält, an die Quellüberwachung durch. Nachdem Sie die Konfiguration getestet haben, speichern Sie Ihren privaten Schlüssel in Amazon S3 und ändern Sie die Konfiguration, um sie während der Bereitstellung herunterzuladen. Detaillierte Anweisungen finden Sie unter [Sicheres Speichern von privaten Schlüsseln in Amazon S3](https-storingprivatekeys.md). Fügen Sie Folgendes in eine Datei mit der Erweiterung `.conf` im Verzeichnis `.platform/nginx/conf.d/` Ihres Quellpakets ein (z. B. `.platform/nginx/conf.d/https.conf`). *app\$1port*Ersetzen Sie es durch die Portnummer, auf der Ihre Anwendung lauscht. In diesem Beispiel wird der nginx-Server zur Überwachung von Port 443 mit SSL konfiguriert. Weitere Informationen zu diesen Konfigurationsdateien auf der .NET Core on Linux-Plattform finden Sie unter [Konfigurieren des Proxy-Server](dotnet-linux-platform-nginx.md). **Example . platform/nginx/conf.d/https.conf** ``` # HTTPS server server { listen 443 ssl; server_name localhost; ssl_certificate /etc/pki/tls/certs/server.crt; ssl_certificate_key /etc/pki/tls/certs/server.key; ssl_session_timeout 5m; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; location / { proxy_pass http://localhost:app_port; proxy_set_header Connection ""; proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto https; } } ``` In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end # Beenden von HTTPS auf EC2 Amazon-Instances, auf denen .NET ausgeführt wird Die folgende [Konfigurationsdatei](ebextensions.md) erstellt und führt ein PowerShell Windows-Skript aus, das die folgenden Aufgaben ausführt: + Überprüft, ob ein vorhandenes HTTPS-Zertifikat an Port 443 gebunden ist. + Ruft das [PFX-Zertifikat](configuring-https-ssl.md) aus einem Amazon S3 S3-Bucket ab. **Anmerkung** Fügen Sie eine `AmazonS3ReadOnlyAccess` Richtlinie für den `aws-elasticbeanstalk-ec2-role` Zugriff auf das SSL-Zertifikat im Amazon S3 S3-Bucket hinzu. + Ruft das Passwort von ab AWS Secrets Manager. **Anmerkung** Fügen Sie eine Anweisung hinzu`aws-elasticbeanstalk-ec2-role`, die die `secretsmanager:GetSecretValue` Aktion für das Geheimnis ermöglicht, das das Zertifikatspasswort enthält + Installiert das Zertifikat. + Bindet das Zertifikat an Port 443. **Anmerkung** Um den HTTP-Endpunkt (Port 80) zu entfernen, fügen Sie den `Remove-WebBinding`-Befehl unter dem Abschnitt **Remove the HTTP binding** des Beispiels hinzu. **Example .ebeextensions/ .config https-instance-dotnet** ``` files: "C:\\certs\\install-cert.ps1": content: | import-module webadministration ## Settings - replace the following values with your own $bucket = "amzn-s3-demo-bucket" ## S3 bucket name $certkey = "example.com.pfx" ## S3 object key for your PFX certificate $secretname = "example_secret" ## AWS Secrets Manager name for a secret that contains the certificate's password ## # Set variables $certfile = "C:\cert.pfx" $pwd = Get-SECSecretValue -SecretId $secretname | select -expand SecretString # Clean up existing binding if ( Get-WebBinding "Default Web Site" -Port 443 ) { Echo "Removing WebBinding" Remove-WebBinding -Name "Default Web Site" -BindingInformation *:443: } if ( Get-Item -path IIS:\SslBindings\0.0.0.0!443 ) { Echo "Deregistering WebBinding from IIS" Remove-Item -path IIS:\SslBindings\0.0.0.0!443 } # Download certificate from S3 Read-S3Object -BucketName $bucket -Key $certkey -File $certfile # Install certificate Echo "Installing cert..." $securepwd = ConvertTo-SecureString -String $pwd -Force -AsPlainText $cert = Import-PfxCertificate -FilePath $certfile cert:\localMachine\my -Password $securepwd # Create site binding Echo "Creating and registering WebBinding" New-WebBinding -Name "Default Web Site" -IP "*" -Port 443 -Protocol https New-Item -path IIS:\SslBindings\0.0.0.0!443 -value $cert -Force ## Remove the HTTP binding ## (optional) Uncomment the following line to unbind port 80 # Remove-WebBinding -Name "Default Web Site" -BindingInformation *:80: ## # Update firewall netsh advfirewall firewall add rule name="Open port 443" protocol=TCP localport=443 action=allow dir=OUT commands: 00_install_ssl: command: powershell -NoProfile -ExecutionPolicy Bypass -file C:\\certs\\install-cert.ps1 ``` In einer einzelnen Instance-Umgebung müssen Sie außerdem die Sicherheitsgruppe der Instance ändern, damit Datenverkehr über Port 443 zugelassen wird. Die folgende Konfigurationsdatei ruft mithilfe einer CloudFormation [Funktion](ebextensions-functions.md) die ID der Sicherheitsgruppe ab und fügt ihr eine Regel hinzu. **Example .ebeextensions/ .config https-instance-single** ``` Resources: sslSecurityGroupIngress: Type: AWS::EC2::SecurityGroupIngress Properties: GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]} IpProtocol: tcp ToPort: 443 FromPort: 443 CidrIp: 0.0.0.0/0 ``` [In einer Umgebung mit Lastenausgleich konfigurieren Sie den Load Balancer so, dass er entweder [sicheren Datenverkehr unangetastet weiterleitet oder zur Verschlüsselung entschlüsselt und erneut](https-tcp-passthrough.md) verschlüsselt.](configuring-https-endtoend.md) end-to-end