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.
# AL2 Anleitungen
Die folgenden Tutorials zeigen Ihnen, wie Sie allgemeine Aufgaben mit laufenden Amazon EC2 EC2-Instances ausführen AL2. Video-Tutorials finden Sie unter [AWS Lehrvideos und](https://www.aws.training/) Übungen.
AL2023 Anweisungen finden Sie unter [Tutorials](https://docs.aws.amazon.com/linux/al2023/ug/tutorials-al2023.html) im *Amazon Linux 2023 User Guide*.
**Topics**
+ [Tutorial: Installieren Sie einen LAMP-Server auf AL2](ec2-lamp-amazon-linux-2.md)
+ [Tutorial: Konfiguration SSL/TLS am AL2](SSL-on-amazon-linux-2.md)
+ [Tutorial: Hosten Sie einen WordPress Blog auf AL2](hosting-wordpress.md)
# Tutorial: Installieren Sie einen LAMP-Server auf AL2
Die folgenden Verfahren helfen Ihnen bei der Installation eines Apache-Webservers mit PHP- und [MariaDB-Unterstützung](https://mariadb.org/about/) (ein von der Community entwickelter Fork von MySQL) auf Ihrer AL2 Instance (manchmal auch LAMP-Webserver oder LAMP-Stack genannt). Sie können diesen Server dazu verwenden, eine statische Website zu hosten oder eine dynamische PHP-Anwendung bereitzustellen, die Informationen aus einer Datenbank liest und in diese schreibt.
**Wichtig**
Dieses Tutorial funktioniert nicht, wenn Sie versuchen, einen LAMP-Webserver auf einer anderen Verteilung, wie z. B. Ubuntu oder Red Hat Enterprise Linux, einzurichten. Weitere Informationen finden Sie AL2023 unter [Installieren eines](https://docs.aws.amazon.com//linux/al2023/ug/ec2-lamp-amazon-linux-2023.html) LAMP-Servers auf. AL2023 Informationen zu Ubuntu finden Sie in der folgenden Dokumentation der Ubuntu-Community: [ApacheMySQLPHP](https://help.ubuntu.com/community/ApacheMySQLPHP). Andere Verteilungen finden Sie in der jeweiligen Dokumentation.
**Option: Abschließen dieses Tutorials mit Automation**
Um dieses Tutorial mit AWS Systems Manager Automatisierung anstelle der folgenden Aufgaben abzuschließen, führen Sie das [AWS Dokument Docs-Install ALAMPServer — AL2](https://console.aws.amazon.com/systems-manager/automation/execute/AWSDocs-InstallALAMPServer-AL2) Automation aus.
**Topics**
+ [Schritt 1: Vorbereiten des LAMP-Servers](#prepare-lamp-server)
+ [Schritt 2: Testen Ihres Lamp-Servers](#test-lamp-server)
+ [Schritt 3: Sichern des Datenbankservers](#secure-mariadb-lamp-server)
+ [Schritt 4: (Optional) Installieren phpMyAdmin](#install-phpmyadmin-lamp-server)
+ [Fehlerbehebung](#lamp-troubleshooting)
+ [Verwandte Themen](#lamp-more-info)
## Schritt 1: Vorbereiten des LAMP-Servers
**Voraussetzungen**
+ In dieser Anleitung wird davon ausgegangen, dass Sie bereits eine neue Instanz mit einem öffentlichen DNS-Namen gestartet haben AL2, der über das Internet erreichbar ist. Weitere Informationen finden Sie unter [Launch an Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html) im *Amazon EC2 EC2-Benutzerhandbuch*. Außerdem müssen Sie Ihre Sicherheitsgruppe so konfiguriert haben, dass Verbindungen über SSH (Port 22), HTTP (Port 80) und HTTPS (Port 443) erlaubt sind. Weitere Informationen zu diesen Voraussetzungen finden Sie unter [Sicherheitsgruppenregeln](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
+ Mit dem folgenden Verfahren wird die neueste PHP-Version installiert AL2, die derzeit `php8.2` verfügbar ist. Falls Sie andere PHP-Anwendungen als die in diesem Tutorial beschriebenen verwenden möchten, prüfen Sie ihre Kompatibilität mit `php8.2`.
**Vorbereiten des LAMP-Servers**
1. [Verbinden Sie sich mit der Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html).
1. Um sicherzustellen, dass alle Ihre Softwarepakete aktuell sind, führen Sie ein schnelles Softwareupdate auf Ihrer Instance aus. Dieser Vorgang kann einige Minuten dauern. Es ist jedoch wichtig, sicherzustellen, dass Sie über die aktuellen Sicherheitsaktualisierungen und Fehlerbehebungen verfügen.
Mit der Option `-y` werden die Updates installiert, ohne um Bestätigung zu bitten. Wenn Sie die Aktualisierungen vor der Installation überprüfen möchten, können Sie diese Option auslassen.
```
[ec2-user ~]$ sudo yum update -y
```
1. Installieren Sie die Amazon-Linux-Extras-Repositorys vom Typ `mariadb10.5`, um die aktuelle Version des MariaDB-Pakets zu erhalten.
```
[ec2-user ~]$ sudo amazon-linux-extras install mariadb10.5
```
Wenn die Fehlermeldung `sudo: amazon-linux-extras: command not found` angezeigt wird, wurde Ihre Instance nicht mit einem Amazon Linux 2-AMI; gestartet (möglicherweise verwenden Sie stattdessen das Amazon Linux AMI). Sie können Ihre Version von Amazon Linux mit dem folgenden Befehl anzeigen.
```
cat /etc/system-release
```
1. Installieren Sie die `php8.2` Amazon Linux Extras-Repositorys, um die neueste Version des PHP Pakets für AL2 zu erhalten.
```
[ec2-user ~]$ sudo amazon-linux-extras install php8.2
```
1. Nachdem Ihre Instance nur auf dem neuesten Stand ist, können Sie die Softwarepakete für Apache-Webserver, MariaDB und PHP installieren. Verwenden Sie den Befehl „yum install“, um mehrere Softwarepakete und alle zugehörigen Abhängigkeiten gleichzeitig zu installieren.
```
[ec2-user ~]$ sudo yum install -y httpd
```
Sie können die aktuellen Versionen dieser Pakete mit dem folgenden Befehl anzeigen:
```
yum info package_name
```
1. Starten Sie den Apache-Webserver.
```
[ec2-user ~]$ sudo systemctl start httpd
```
1. Konfigurieren Sie den Apache-Webserver mit dem Befehl **systemctl** so, dass er bei jedem Systemstart startet.
```
[ec2-user ~]$ sudo systemctl enable httpd
```
Mit folgendem Befehl können Sie prüfen, ob der Befehl **httpd** ausgeführt wird:
```
[ec2-user ~]$ sudo systemctl is-enabled httpd
```
1. Fügen Sie eine Sicherheitsregel hinzu, um eingehende HTTP-Verbindungen (Port 80) auf Ihre Instance zuzulassen, wenn Sie dies nicht bereits getan haben. Standardmäßig wurde während der **Initialisierung eine *N* Launch-Wizard-Sicherheitsgruppe** für Ihre Instance eingerichtet. Diese Gruppe enthält eine einzige Regel, um SSH-Verbindungen zuzulassen.
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie **Instances** und wählen Sie Ihre Instance aus.
1. Zeigen Sie auf der Registerkarte **Sicherheit** die Regeln für eingehenden Datenverkehr an. Sie sollten die folgende Regel sehen:
```
Port range Protocol Source
22 tcp 0.0.0.0/0
```
**Warnung**
Durch die Verwendung `0.0.0.0/0` können alle IPv4 Adressen über SSH auf Ihre Instance zugreifen. Dies ist zwar für kurze Zeit in einer Testumgebung akzeptabel, aber für Produktionsumgebungen sehr unsicher. Für die Produktion wird nur eine bestimmte IP-Adresse bzw. ein bestimmter Adressbereich für den Zugriff auf Ihre Instance autorisiert.
1. Wählen Sie den Link für die Sicherheitsgruppe aus. [Fügen Sie mithilfe der Verfahren unter Regeln zu einer Sicherheitsgruppe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule) hinzufügen eine neue Sicherheitsregel für eingehenden Datenverkehr mit den folgenden Werten hinzu:
+ **Typ**: HTTP
+ **Protocol (Protokoll)**: TCP
+ **Portbereich**: 80
+ **Quelle**: Benutzerdefiniert
1. Testen Sie Ihren Webserver. Geben Sie in einen Web-Browser die öffentliche DNS-Adresse (oder die öffentliche IP-Adresse) Ihrer Instance ein. Wenn keine Inhalte in `/var/www/html` vorhanden sind, sollte die Testseite von Apache angezeigt werden. Sie können das öffentliche DNS für Ihre Instance mithilfe der Amazon EC2-Konsole abrufen (in der Spalte **Public DNS**; sollte diese Spalte verborgen sein, klicken Sie auf das Symbol **Show/Hide Columns (Spalten ein-/ausblenden)** (das getriebeförmige Symbol) und wählen Sie **Public DNS (Öffentliches DNS)** aus).
Stellen Sie sicher, dass die Sicherheitsgruppe für die Instance eine Regel enthält, die HTTP-Datenverkehr auf Port 80 zulässt. Weitere Informationen finden [Sie unter Regeln zu einer Sicherheitsgruppe hinzufügen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule).
**Wichtig**
Wenn Sie nicht Amazon Linux verwenden, müssen Sie möglicherweise auch die Firewall auf Ihrer Instance konfigurieren, um diese Verbindungen zu erlauben. Weitere Informationen zum Konfigurieren der Firewall finden Sie in der Dokumentation für Ihre spezifische Verteilung.
![\[Der Test des Servers zeigt die Apache-Testseite.\]](http://docs.aws.amazon.com/de_de/linux/al2/ug/images/apache_test_page_al2_2.4.png)
Der Apache-Befehl **httpd** gilt für Dateien, die in einem Verzeichnis gespeichert sind, das als Apache-Dokumenten-Stammverzeichnis bezeichnet wird. Das Amazon Linux-Apache-Dokumenten-Stammverzeichnis ist `/var/www/html`, das standardmäßig Eigentum des Stammverzeichnisses ist.
Damit das `ec2-user`-Konto Dateien in diesem Verzeichnis bearbeiten kann, müssen Sie die Eigentümerschaft und die Berechtigungen des Verzeichnisses ändern. Es gibt viele Möglichkeiten, um diese Aufgabe zu erfüllen. In diesem Tutorial fügen Sie `ec2-user` zur `apache`-Gruppe hinzu, geben der `apache`-Gruppe Eigentümerschaft über das Verzeichnis `/var/www` und weisen der Gruppe Schreibberechtigungen zu.
**So richten Sie Dateiberechtigungen ein**
1. Fügen Sie Ihren Benutzer (in diesem Fall `ec2-user`) zu der `apache`-Gruppe hinzu.
```
[ec2-user ~]$ sudo usermod -a -G apache ec2-user
```
1. Melden Sie sich ab und anschließend wieder an, um die neue Gruppe auszuwählen, und verifizieren Sie dann Ihre Mitgliedschaft.
1. Melden Sie sich ab (Sie können den Befehl **exit** verwenden oder das Terminal-Fenster schließen):
```
[ec2-user ~]$ exit
```
1. Ihre Mitgliedschaft in der `apache`-Gruppe zu verifizieren, stellen Sie erneut die Verbindung zu Ihrer Instance her und führen Sie anschließend den folgenden Befehl aus:
```
[ec2-user ~]$ groups
ec2-user adm wheel apache systemd-journal
```
1. Übertragen Sie die Eigentümerschaft der Datei `/var/www` und ihrer Inhalte auf die `apache`-Gruppe.
```
[ec2-user ~]$ sudo chown -R ec2-user:apache /var/www
```
1. Um Schreibberechtigungen für die Gruppe hinzuzufügen und die Gruppen-ID für zukünftige Unterverzeichnisse einzurichten, ändern Sie die Verzeichnisberechtigungen von `/var/www` und deren Unterverzeichnisse.
```
[ec2-user ~]$ sudo chmod 2775 /var/www && find /var/www -type d -exec sudo chmod 2775 {} \;
```
1. Um Schreibberechtigungen für die Gruppe hinzuzufügen, ändern Sie die Dateiberechtigungen von `/var/www` und deren Unterverzeichnisse rekursiv.
```
[ec2-user ~]$ find /var/www -type f -exec sudo chmod 0664 {} \;
```
Jetzt kann `ec2-user` (und jedes zukünftige Mitglied der `apache`-Gruppe) im Dokumenten-Stammverzeichnis von Apache Dateien hinzufügen, löschen und bearbeiten. Auf diese Weise können Sie Inhalte hinzufügen, beispielsweise eine statische Website oder eine PHP-Anwendung.
**So sichern Sie Ihren Webserver (optional)**
Ein Webserver, auf dem HTTP ausgeführt wird, bietet keine Transportsicherheit für die gesendeten oder empfangenen Daten. Wenn Sie über einen Webbrowser eine Verbindung zu einem HTTP-Server herstellen, sind URLs die von Ihnen besuchten Daten, der Inhalt der Webseiten, die Sie erhalten, und die Inhalte (einschließlich Kennwörter) aller HTML-Formulare, die Sie einreichen, für Lauscher überall im Netzwerkpfad sichtbar. Die beste Methode, Ihren Webserver abzusichern, besteht darin, Unterstützung für HTTPS (HTTP Secure) zu installieren, wodurch Ihre Daten mit der SSL/TLS-Verschlüsselung geschützt werden.
Informationen zur Aktivierung von HTTPS auf Ihrem Server finden Sie unter [Tutorial: Konfiguration SSL/TLS am AL2](SSL-on-amazon-linux-2.md).
## Schritt 2: Testen Ihres Lamp-Servers
Wenn Ihr Server installiert ist und läuft und Ihre Dateiberechtigungen korrekt eingestellt sind, müsste für Ihr `ec2-user`-Konto die Erstellung einer PHP-Datei im Verzeichnis `/var/www/html` möglich sein, auf die über das Internet zugegriffen werden kann.
**So testen Sie Ihren LAMP-Server**
1. Erstellen Sie eine PHP-Datei im Dokumenten-Stammverzeichnis von Apache.
```
[ec2-user ~]$ echo "" > /var/www/html/phpinfo.php
```
Wenn beim Ausführen dieses Befehls der Fehler „Permission denied“ angezeigt wird, melden Sie sich ab und anschließend wieder an, damit die richtigen Gruppenberechtigungen übernommen werden, die Sie in konfiguriert habe [So richten Sie Dateiberechtigungen ein](#setting-file-permissions-2).
1. Geben Sie in einem Webbrowser die URL der Datei ein, die Sie gerade erstellt haben. Diese URL ist die öffentliche DNS-Adresse Ihrer Instance, gefolgt von einem Schrägstrich und dem Dateinamen. Beispiel:
```
http://my.public.dns.amazonaws.com/phpinfo.php
```
Die PHP-Informationsseite wird angezeigt:
![\[Beim Test des LAMP-Servers wird die PHP-Informationsseite angezeigt.\]](http://docs.aws.amazon.com/de_de/linux/al2/ug/images/phpinfo7.2.10.png)
Wenn diese Seite nicht angezeigt wird, überprüfen Sie, ob die Datei `/var/www/html/phpinfo.php` im vorherigen Schritt ordnungsgemäß angelegt wurde. Mit dem folgenden Befehl können Sie auch überprüfen, ob alle erforderlichen Pakete installiert wurden.
```
[ec2-user ~]$ sudo yum list installed httpd mariadb-server php-mysqlnd
```
Wenn eines der erforderlichen Pakete in Ihrem Ergebnis nicht aufgelistet ist, installieren Sie es mit dem Befehl **sudo yum install *package***. Überprüfen Sie außerdem in der Ausgabe des Befehls **amazon-linux-extras**, ob die `php7.2`- und `lamp-mariadb10.2-php7.2`-Extras aktiviert sind.
1. Löschen Sie die Datei `phpinfo.php`. Obwohl sie nützliche Informationen enthalten könnte, sollte sie aus Sicherheitsgründen nicht über das Internet übertragen werden.
```
[ec2-user ~]$ rm /var/www/html/phpinfo.php
```
Sie sollten nun über einen voll funktionsfähigen LAMP-Webserver verfügen. Wenn Sie zum Dokumenten-Stammverzeichnis von Apache unter `/var/www/html` Inhalte hinzufügen, können Sie diese unter der öffentlichen DNS-Adresse für Ihre Instance anzeigen.
## Schritt 3: Sichern des Datenbankservers
Die Standardinstallation des MariaDB-Servers verfügt über mehrere Funktionen, die hervorragend zum Testen und für die Entwicklung geeignet sind, aber bei Produktionsservern sollten Sie deaktiviert oder entfernt werden. Mit dem Befehl **mysql\$1secure\$1installation** rufen Sie eine Anleitung dazu auf, wie Sie ein Stammpasswort einrichten und die unsicheren Funktionen aus Ihrer Installation entfernen. Auch wenn Sie nicht vorhaben, den MariaDB-Server zu verwenden, empfehlen wir Ihnen die Durchführung dieses Verfahrens.
**Sichern des MariaDB-Servers**
1. Starten Sie den MariaDB-Server.
```
[ec2-user ~]$ sudo systemctl start mariadb
```
1. Führen Sie **mysql\$1secure\$1installation**.
```
[ec2-user ~]$ sudo mysql_secure_installation
```
1. Geben Sie das Passwort für das Stammkonto ein, wenn Sie dazu aufgefordert werden.
1. Geben Sie das aktuelle Stammpasswort ein. Standardmäßig ist für das Stammkonto kein Passwort eingerichtet. Drücken Sie die Eingabetaste.
1. Drücken Sie **Y**, um ein Passwort einzurichten, und geben Sie ein sicheres Passwort zweimal ein. Weitere Hinweise zur Erstellung eines sicheren Passworts finden Sie unter [https://identitysafe.norton.com/password-generator/](https://identitysafe.norton.com/password-generator/). Bewahren Sie dieses Passwort an einem sicheren Ort auf.
Die Einrichtung eines Stammpassworts für MariaDB ist nur die grundlegendste Maßnahme, um Ihre Datenbank abzusichern. Wenn Sie eine datenbankgestützte Anwendung aufbauen oder installieren, legen Sie für diese Anwendung normalerweise einen Datenbank-Servicebenutzer an und nutzen das Stammkonto ausschließlich zur Datenbankverwaltung.
1. Geben Sie **Y** ein, um die anonymen Benutzerkonten zu entfernen.
1. Geben Sie **Y** ein, um die Root-Anmeldung per Remote-Zugriff zu deaktivieren.
1. Geben Sie **Y** ein, um die Testdatenbank zu entfernen.
1. Geben Sie **Y** ein, um die Tabellen mit den Berechtigungen neu zu laden. Speichern Sie anschließend Ihre Änderungen.
1. (Optional) Wenn Sie nicht vorhaben, den MariaDB-Server weiter zu verwenden, stoppen Sie ihn. Sie können ihn erneut starten, wenn Sie ihn wieder brauchen.
```
[ec2-user ~]$ sudo systemctl stop mariadb
```
1. (Optional) Wenn Sie wollen, dass der MariaDB-Server bei jedem Systemstart gestartet wird, geben Sie den folgenden Befehl ein.
```
[ec2-user ~]$ sudo systemctl enable mariadb
```
## Schritt 4: (Optional) Installieren phpMyAdmin
[phpMyAdmin](https://www.phpmyadmin.net/)ist ein webbasiertes Datenbankverwaltungstool, mit dem Sie die MySQL-Datenbanken auf Ihrer EC2-Instance anzeigen und bearbeiten können. Führen Sie die unten genannten Schritte durch, um `phpMyAdmin` auf Ihrer Amazon Linux-Instance zu installieren und zu konfigurieren.
**Wichtig**
Wir empfehlen nicht, es für `phpMyAdmin` den Zugriff auf einen LAMP-Server zu verwenden, es sei denn, Sie haben es SSL/TLS in Apache aktiviert. Andernfalls werden Ihr Datenbankadministratorkennwort und andere Daten unsicher über das Internet übertragen. Sicherheitsempfehlungen der Entwickler finden Sie unter [Sichern Ihrer phpMyAdmin Installation](https://docs.phpmyadmin.net/en/latest/setup.html#securing-your-phpmyadmin-installation). Allgemeine Informationen zur Sicherung eines Webservers auf einer EC2-Instance finden Sie unter [Tutorial: Konfiguration SSL/TLS am AL2](SSL-on-amazon-linux-2.md).
**Um zu installieren phpMyAdmin**
1. Installieren Sie die erforderlichen Abhängigkeiten.
```
[ec2-user ~]$ sudo yum install php-mbstring php-xml -y
```
1. Starten Sie Apache erneut.
```
[ec2-user ~]$ sudo systemctl restart httpd
```
1. Starten Sie `php-fpm` neu.
```
[ec2-user ~]$ sudo systemctl restart php-fpm
```
1. Navigieren Sie zum Stammverzeichnis von Apache unter `/var/www/html`.
```
[ec2-user ~]$ cd /var/www/html
```
1. Wählen Sie unter [https://www.phpmyadmin.net/downloads](https://www.phpmyadmin.net/downloads) ein Quellpaket für die neueste phpMyAdmin Version aus. Um die Datei direkt in Ihre Instance herunterzuladen, kopieren Sie den Link in einen **wget**-Befehl wie im folgenden Beispiel:
```
[ec2-user html]$ wget https://www.phpmyadmin.net/downloads/phpMyAdmin-latest-all-languages.tar.gz
```
1. Erstellen Sie mit dem folgenden Befehl einen `phpMyAdmin`-Ordner und extrahieren Sie das Paket in diesen.
```
[ec2-user html]$ mkdir phpMyAdmin && tar -xvzf phpMyAdmin-latest-all-languages.tar.gz -C phpMyAdmin --strip-components 1
```
1. Löschen Sie den *phpMyAdmin-latest-all-languages.tar.gz* Tarball.
```
[ec2-user html]$ rm phpMyAdmin-latest-all-languages.tar.gz
```
1. (Optional) Wenn der MySQL-Server nicht ausgeführt wird, starten Sie ihn jetzt.
```
[ec2-user ~]$ sudo systemctl start mariadb
```
1. Geben Sie in einem Webbrowser die URL Ihrer phpMyAdmin Installation ein. Diese URL ist die öffentliche DNS-Adresse (oder die öffentliche IP-Adresse) Ihrer Instance gefolgt von einem Schrägstrich und dem Namen wie im folgenden Beispiel: Beispiel:
```
http://my.public.dns.amazonaws.com/phpMyAdmin
```
Sie sollten die phpMyAdmin Anmeldeseite sehen:
![\[Das Ergebnis der Eingabe der URL Ihrer phpMyAdmin Installation ist der phpMyAdmin Anmeldebildschirm.\]](http://docs.aws.amazon.com/de_de/linux/al2/ug/images/phpmyadmin_login.png)
1. Melden Sie sich mit dem `root` Benutzernamen und dem MySQL-Root-Passwort, das Sie zuvor erstellt haben, bei Ihrer phpMyAdmin Installation an.
Ihre Installation muss vor der Inbetriebnahme noch konfiguriert werden. Wir schlagen vor, dass Sie zunächst die Konfigurationsdatei wie folgt manuell erstellen:
1. Um mit einer minimalen Konfigurationsdatei zu beginnen, erstellen Sie mit Ihrem bevorzugten Texteditor eine neue Datei und kopieren Sie dann den Inhalt von `config.sample.inc.php` hinein.
1. Speichern Sie die Datei `config.inc.php` in dem phpMyAdmin Verzeichnis, das enthält`index.php`.
1. Weitere Einstellungen finden Sie in den Anweisungen nach der Dateierstellung [im Abschnitt Verwenden des Setup-Skripts](https://docs.phpmyadmin.net/en/latest/setup.html#using-the-setup-script) der phpMyAdmin Installationsanweisungen.
Informationen zur Verwendung phpMyAdmin finden Sie im [phpMyAdmin Benutzerhandbuch](http://docs.phpmyadmin.net/en/latest/user.html).
## Fehlerbehebung
Dieser Abschnitt enthält Vorschläge zum Lösen häufiger Probleme, die bei der Einrichtung eines neuen LAMP-Servers auftreten können.
### Ich kann zu meinem Server keine Verbindung über einen Webbrowser herstellen
Führen Sie die folgende Prüfungen durch, um zu sehen, ob Ihr Apache-Webserver ausgeführt wird und auf ihn zugegriffen werden kann.
+ **Wird der Webserver ausgeführt?**
Mit folgendem Befehl können Sie prüfen, ob der Befehl **httpd** ausgeführt wird:
```
[ec2-user ~]$ sudo systemctl is-enabled httpd
```
Wenn der **httpd**-Prozess nicht ausgeführt wird, wiederholen Sie die unter [Vorbereiten des LAMP-Servers](#install_apache-2) beschriebenen Schritte.
+ **Ist die Firewall richtig konfiguriert?**
Stellen Sie sicher, dass die Sicherheitsgruppe für die Instance eine Regel enthält, die HTTP-Datenverkehr auf Port 80 zulässt. Weitere Informationen finden [Sie unter Regeln zur Sicherheitsgruppe hinzufügen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule).
### Ich kann über HTTPS keine Verbindung zu meinem Server herstellen
Führen Sie die folgende Prüfungen durch, um zu sehen, ob Ihr Apache-Webserver konfiguriert ist, HTTPS zu unterstützen.
+ **Ist der Webserver richtig konfiguriert? **
Nach der Installation von Apache ist der Server für HTTP-Verkehr konfiguriert. Um HTTPS zu unterstützen, aktivieren Sie TLS auf dem Server und installieren Sie ein SSL-Zertifikat. Weitere Informationen finden Sie unter [Tutorial: Konfiguration SSL/TLS am AL2](SSL-on-amazon-linux-2.md).
+ **Ist die Firewall richtig konfiguriert?**
Stellen Sie sicher, dass die Sicherheitsgruppe für die Instance eine Regel enthält, die HTTPS-Datenverkehr auf Port 443 zulässt. Weitere Informationen finden [Sie unter Regeln zu einer Sicherheitsgruppe hinzufügen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule).
## Verwandte Themen
Weitere Informationen zum Übertragen von Dateien auf Ihre Instance oder zum Installieren eines WordPress Blogs auf Ihrem Webserver finden Sie in der folgenden Dokumentation:
+ [Übertragen Sie Dateien auf Ihre Linux-Instance mit WinSCP](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html#Transfer_WinSCP).
+ [Übertragen Sie Dateien mithilfe eines SCP Clients auf Linux-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-linux-inst-ssh.html#linux-file-transfer-scp).
+ [Tutorial: Hosten Sie einen WordPress Blog auf AL2](hosting-wordpress.md)
Weitere Informationen über die in diesem Tutorial verwendete(n) Befehle und Software finden Sie auf den folgenden Webseiten:
+ Apache-Webserver: [http://httpd.apache.org/](http://httpd.apache.org/)
+ MariaDB-Datenbankserver: [https://mariadb.org/](https://mariadb.org/)
+ PHP-Programmiersprache: [http://php.net/](http://php.net/)
+ Der `chmod` Befehl: [https://en.wikipedia. org/wiki/Chmod](https://en.wikipedia.org/wiki/Chmod)
+ Der `chown` Befehl: [https://en.wikipedia. org/wiki/Chown](https://en.wikipedia.org/wiki/Chown)
Weitere Informationen zum Registrieren eines Domain-Namens für Ihren Webserver oder zum Übertragen eines bestehenden Domain-Namens auf diesen Host finden Sie unter [Erstellen und Migrieren von Domains und Sub-Domains zu Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/creating-migrating.html) im *Entwicklerhandbuch für Amazon Route 53*.
# Tutorial: Konfiguration SSL/TLS am AL2
Secure Sockets Layer/Transport Layer Security (SSL/TLS) creates an encrypted channel between a web server and web client that protects data in transit from being eavesdropped on. This tutorial explains how to add support manually for SSL/TLSauf einer EC2-Instance mit AL2 einem Apache-Webserver). In diesem Tutorial wird davon ausgegangen, dass Sie keinen Load Balancer verwenden. Wenn Sie Elastic Load Balancing verwenden, können Sie im Load Balancer SSL-Offload konfigurieren und stattdessen ein Zertifikat aus [AWS Certificate Manager](https://aws.amazon.com/certificate-manager/) verwenden.
Aus historischen Gründen wird die Webverschlüsselung häufig einfach als SSL bezeichnet. Auch wenn Webbrowser SSL weiterhin unterstützen, ist das Nachfolgeprotokoll TLS weniger anfällig für Angriffe. AL2 deaktiviert standardmäßig die serverseitige Unterstützung für alle Versionen von SSL. [Gremien für Sicherheitsstandards](https://www.ssl.com/article/deprecating-early-tls/) erachten TLS 1.0 als unsicher. TLS 1.0 und TLS 1.1 wurden im März 2021 formell [veraltet](https://datatracker.ietf.org/doc/rfc8996/). Dieses Tutorial enthält Empfehlungen, die ausschließlich auf der Aktivierung von TLS 1.2 basieren. TLS 1.3 wurde 2018 fertiggestellt und ist verfügbar, AL2 solange die zugrunde liegende TLS-Bibliothek (OpenSSL in diesem Tutorial) unterstützt und aktiviert ist. [Kunden müssen spätestens zum 28. Juni 2023 TLS 1.2 oder höher unterstützen](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/). Weitere Informationen zum aktualisierten Verschlüsselungsstandard finden Sie unter [RFC 7568](https://tools.ietf.org/html/rfc7568) und [RFC 8446](https://tools.ietf.org/html/rfc8446).
Dieses Tutorial bezieht sich auf TLS als moderne Web-Verschlüsselung.
**Wichtig**
Diese Verfahren sind für die Verwendung mit AL2 vorgesehen. Es wird auch angenommen, dass Sie mit einer neuen Amazon EC2-Instance beginnen. Wenn Sie versuchen, eine EC2-Instance einzurichten, auf der eine andere Distribution ausgeführt wird, oder eine Instance, auf der eine alte Version von ausgeführt wird AL2, funktionieren einige Verfahren in diesem Tutorial möglicherweise nicht. Für Ubuntu lesen Sie bitte die folgende Community-Dokumentation: [Open SSL auf Ubuntu](https://help.ubuntu.com/community/OpenSSL). Informationen zu Red Hat Enterprise Linux finden Sie im Thema [Apache-HTTP-Webserver einrichten](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/deploying_different_types_of_servers/setting-apache-http-server_deploying-different-types-of-servers). Andere Verteilungen finden Sie in der jeweiligen Dokumentation.
**Anmerkung**
Alternativ können Sie AWS Certificate Manager (ACM) für AWS Nitro-Enklaven verwenden. Dabei handelt es sich um eine Enklave-Anwendung, mit der Sie öffentliche und private SSL/TLS Zertifikate für Ihre Webanwendungen und Server verwenden können, die auf Amazon EC2 EC2-Instances mit Nitro Enclaves ausgeführt werden. AWS Nitro Enclaves ist eine Amazon EC2 EC2-Funktion, die die Schaffung isolierter Computerumgebungen ermöglicht, um hochsensible Daten wie SSL/TLS Zertifikate und private Schlüssel zu schützen und sicher zu verarbeiten.
ACM for Nitro Enclaves arbeitet mit **nginx** zusammen, das auf Ihrer Amazon-EC2-Linux-Instance ausgeführt wird, um private Schlüssel zu erstellen, Zertifikate und private Schlüssel zu verteilen und Zertifikatverlängerungen zu verwalten.
Um ACM for Nitro Enclaves verwenden zu können, müssen Sie eine Enclave-fähige Linux-Instance nutzen.
Weitere Informationen finden Sie unter [Was](https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave.html) ist Nitro Enclaves? AWS *und [AWS Certificate Manager für Nitro Enclaves im Nitro Enclaves-Benutzerhandbuch](https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html).AWS *
**Topics**
+ [Voraussetzungen](#ssl_prereq)
+ [Schritt 1: Aktivieren von TLS auf dem Server](#ssl_enable)
+ [Schritt 2: Abrufen eines CA-signierten Zertifikats](#ssl_certificate)
+ [Schritt 3: Testen und Verstärken der Sicherheitskonfiguration](#ssl_test)
+ [Fehlerbehebung](#troubleshooting)
## Voraussetzungen
Bevor Sie mit diesem Tutorial beginnen, führen Sie die folgenden Schritte aus:
+ Starten Sie eine Amazon EBS-gestützte AL2 Instance. Weitere Informationen finden Sie unter [Launch an Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
+ Konfigurieren Sie Ihre Sicherheitsgruppen so, dass Ihre Instance Verbindungen auf den folgenden TCP-Ports akzeptieren kann:
+ SSH (Port 22)
+ HTTP (Port 80)
+ HTTPS (Port 443)
Weitere Informationen finden Sie unter [Sicherheitsgruppenregeln](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules.html) im *Benutzerhandbuch für Amazon EC2*.
+ Installieren Sie den Apache-Webserver. step-by-stepAnweisungen finden Sie unter [Tutorial: Installieren Sie einen LAMP-Webserver auf AL2](ec2-lamp-amazon-linux-2.md). Es werden nur das httpd-Paket und die zugehörigen Abhängigkeiten benötigt, sodass die Anleitungen mit PHP und MariaDB ignoriert werden können.
+ Zum Identifizieren und Authentifizieren von Websites verwendet die Public Key-Infrastruktur (PKI) TLS das Domain Name System (DNS). Wenn Sie Ihre EC2-Instance zum Hosten einer öffentlichen Website verwenden möchten, müssen Sie einen Domain-Namen für Ihren Webserver registrieren oder einen vorhandenen Domain-Namen an Ihren Amazon-EC2-Host übertragen. Dafür sind zahlreiche Drittanbieterservices für die Domain-Registrierung und das DNS-Hosting verfügbar. Oder Sie verwenden [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html).
## Schritt 1: Aktivieren von TLS auf dem Server
**Option: Abschließen dieses Tutorials mit Automation**
Um dieses Tutorial mit AWS Systems Manager Automatisierung anstelle der folgenden Aufgaben abzuschließen, führen Sie das [Automatisierungsdokument](https://console.aws.amazon.com/systems-manager/documents/AWSDocs-Configure-SSL-TLS-AL2/) aus.
Dieses Verfahren führt Sie durch den Prozess der Einrichtung von TLS AL2 mit einem selbstsignierten digitalen Zertifikat.
**Anmerkung**
Ein selbstsigniertes Zertifikat kann zu Testzwecken, jedoch nicht für die Produktion verwendet werden. Wenn Sie Ihr selbstsigniertes Zertifikat im Internet bereitstellen, werden den Besuchern Ihrer Website Sicherheitswarnungen angezeigt.
**So aktivieren Sie TLS auf einem Server**
1. [Verbinden Sie sich mit der Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) und stellen Sie sicher, dass Apache ausgeführt wird.
```
[ec2-user ~]$ sudo systemctl is-enabled httpd
```
Wenn der zurückgegebene Wert nicht „enabled“ (aktiviert) ist, starten Sie Apache und richten es so ein, dass es bei jedem Neustart des Systems gestartet wird.
```
[ec2-user ~]$ sudo systemctl start httpd && sudo systemctl enable httpd
```
1. Um sicherzustellen, dass alle Ihre Softwarepakete aktuell sind, führen Sie ein schnelles Softwareupdate auf Ihrer Instance aus. Dieser Vorgang kann einige Minuten dauern. Es ist jedoch wichtig, sicherzustellen, dass Sie über die aktuellen Sicherheitsaktualisierungen und Fehlerbehebungen verfügen.
**Anmerkung**
Mit der Option `-y` werden die Updates installiert, ohne um Bestätigung zu bitten. Wenn Sie die Aktualisierungen vor der Installation überprüfen möchten, können Sie diese Option auslassen.
```
[ec2-user ~]$ sudo yum update -y
```
1. Wenn Ihre Instance jetzt aktuell ist, fügen Sie TLS-Unterstützung hinzu, indem Sie das Apache-Modul installiere `mod_ssl`.
```
[ec2-user ~]$ sudo yum install -y mod_ssl
```
Ihre Instance verfügt nun über die folgenden Dateien, mit denen Sie Ihren sicheren Server konfigurieren und ein Zertifikat zum Testen erstellen:
+ `/etc/httpd/conf.d/ssl.conf`
Die Konfigurationsdatei für mod\$1ssl. Diese enthält *Richtlinien*, die Apache mitteilen, wo Verschlüsselungsschlüssel und Zertifikate, die zu genehmigenden TLS-Protokollversionen und die zu akzeptierenden Verschlüsselungschiffren gefunden werden können.
+ `/etc/pki/tls/certs/make-dummy-cert`
Ein Skript zum Generieren eines selbstsignierten X.509-Zertifikats und privaten Schlüssels für Ihren Server-Host. Dieses Zertifikat ist nützlich zum Testen, ob Apache ordnungsgemäß für die Verwendung von TLS eingerichtet ist. Da es keinen Identitätsnachweis liefert, sollte es in der Produktion nicht verwendet werden. Wenn es in der Produktion eingesetzt wird, löst es Warnungen in Web-Browsern aus.
1. Führen Sie das Skript aus, um ein selbstsigniertes Dummy-Zertifikat und einen Schlüssel für die Überprüfung zu generieren.
```
[ec2-user ~]$ cd /etc/pki/tls/certs
sudo ./make-dummy-cert localhost.crt
```
Dadurch wird eine neue Datei `localhost.crt` im Verzeichnis `/etc/pki/tls/certs/` erstellt. Der angegebene Dateiname entspricht dem Standard, der in der **SSLCertificateFile**-Direktive in `/etc/httpd/conf.d/ssl.conf` zugewiesen ist.
Die Datei enthält sowohl ein selbstsigniertes Zertifikat als auch den privaten Schlüssel des Zertifikats. Für Apache müssen das Zertifikat und der Schlüssel im PEM-Format sein. Diese bestehen aus Base64-kodierten ASCII-Zeichen, die durch „BEGIN” und „END”-Zeilen eingerahmt werden, wie im folgendem, verkürzten Beispiel dargestellt.
```
-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQD2KKx/8Zk94m1q
3gQMZF9ZN66Ls19+3tHAgQ5Fpo9KJDhzLjOOCI8u1PTcGmAah5kEitCEc0wzmNeo
BCl0wYR6G0rGaKtK9Dn7CuIjvubtUysVyQoMVPQ97ldeakHWeRMiEJFXg6kZZ0vr
GvwnKoMh3DlK44D9dX7IDua2PlYx5+eroA+1Lqf32ZSaAO0bBIMIYTHigwbHMZoT
...
56tE7THvH7vOEf4/iUOsIrEzaMaJ0mqkmY1A70qQGQKBgBF3H1qNRNHuyMcPODFs
27hDzPDinrquSEvoZIggkDMlh2irTiipJ/GhkvTpoQlv0fK/VXw8vSgeaBuhwJvS
LXU9HvYq0U6O4FgD3nAyB9hI0BE13r1HjUvbjT7moH+RhnNz6eqqdscCS09VtRAo
4QQvAqOa8UheYeoXLdWcHaLP
-----END PRIVATE KEY-----
-----BEGIN CERTIFICATE-----
MIIEazCCA1OgAwIBAgICWxQwDQYJKoZIhvcNAQELBQAwgbExCzAJBgNVBAYTAi0t
MRIwEAYDVQQIDAlTb21lU3RhdGUxETAPBgNVBAcMCFNvbWVDaXR5MRkwFwYDVQQK
DBBTb21lT3JnYW5pemF0aW9uMR8wHQYDVQQLDBZTb21lT3JnYW5pemF0aW9uYWxV
bml0MRkwFwYDVQQDDBBpcC0xNzItMzEtMjAtMjM2MSQwIgYJKoZIhvcNAQkBFhVy
...
z5rRUE/XzxRLBZOoWZpNWTXJkQ3uFYH6s/sBwtHpKKZMzOvDedREjNKAvk4ws6F0
CuIjvubtUysVyQoMVPQ97ldeakHWeRMiEJFXg6kZZ0vrGvwnKoMh3DlK44D9dlU3
WanXWehT6FiSZvB4sTEXXJN2jdw8g+sHGnZ8zCOsclknYhHrCVD2vnBlZJKSZvak
3ZazhBxtQSukFMOnWPP2a0DMMFGYUHOd0BQE8sBJxg==
-----END CERTIFICATE-----
```
Die Dateinamen und Erweiterungen dienen der Einfachheit und haben keinerlei Auswirkungen auf die Funktion. Sie können beispielsweise ein Zertifikat mit `cert.crt`, `cert.pem` oder einem beliebigen anderen Dateinamen benennen, solange die zugehörige Richtlinie in der Datei `ssl.conf` denselben Namen verwendet.
**Anmerkung**
Wenn Sie die TLS-Standarddateien mit Ihren eigenen benutzerdefinierten Dateien ersetzen, müssen diese das PEM-Format aufweisen.
1. Öffnen Sie die `/etc/httpd/conf.d/ssl.conf`-Datei mit ihrem bevorzugten Texteditor (z. B. **vim** oder **nano**) als Root-Benutzer und kommentieren Sie die folgende Zeile aus, da das selbstsignierte Dummy-Zertifikat auch den Schlüssel enthält. Wenn Sie diese Zeile nicht auskommentieren, bevor Sie den nächsten Schritt abschließen, kann der Apache-Service nicht gestartet werden.
```
SSLCertificateKeyFile /etc/pki/tls/private/localhost.key
```
1. Starten Sie Apache erneut.
```
[ec2-user ~]$ sudo systemctl restart httpd
```
**Anmerkung**
Stellen Sie wie zuvor beschrieben sicher, dass auf den TCP-Port 443 über Ihre EC2-Instance zugegriffen werden kann.
1. Ihr Apache-Webserver sollte jetzt HTTPS (sicheres HTTP) über Port 443 unterstützen. Dies können Sie testen, indem Sie die IP-Adresse oder den vollständig qualifizierten Domain-Namen Ihrer EC2-Instance mit dem Präfix **https://** in einer Browser-URL-Leiste eingeben.
Da Sie eine Verbindung mit einer Website mit einem selbstsignierten, nicht vertrauenswürdigen Host-Zertifikat herstellen, zeigt Ihr Browser möglicherweise eine Reihe von Sicherheitswarnungen an. Setzen Sie die Warnmeldungen außer Kraft und fahren Sie mit der Website fort.
Wenn die Apache-Standardtestseite geöffnet wird, bedeutet dies, dass Sie TLS erfolgreich auf Ihrem Server konfiguriert haben. Alle Daten, die zwischen dem Browser und dem Server übertragen werden, sind nun verschlüsselt.
**Anmerkung**
Damit den Besuchern keine Warnbildschirme angezeigt werden, müssen Sie ein vertrauenswürdiges, CA-signiertes Zertifikat abrufen, das nicht nur verschlüsselt, sondern Sie auch öffentlich als den Besitzer der Website authentifiziert.
## Schritt 2: Abrufen eines CA-signierten Zertifikats
Sie können das folgende Verfahren verwenden, um ein CA-signiertes Zertifikat zu erhalten:
+ Erzeugen Sie aus dem privaten Schlüssel eine Zertifikatssignierungsanforderung (Certificate Signing Request, CSR)
+ Senden Sie die CSR an eine Zertifizierungsstelle (CA)
+ Sie erhalten ein signiertes Host-Zertifikat
+ Konfigurieren Sie Apache, um das Zertifikat zu verwenden
Ein selbstsigniertes TLS-X.509-Host-Zertifikat ist kryptologisch mit einem CA-signierten Zertifikat identisch. Der Unterschied liegt im sozialen, nicht im mathematischen Bereich. Eine CA validiert zumindest den Besitzer einer Domain, bevor ein Zertifikat für einen Antragsteller ausgegeben wird. Jeder Webbrowser enthält eine Liste der vom Browserhersteller zu diesem Zweck CAs vertrauenswürdigen Websites. Ein X.509-Zertifikat besteht hauptsächlich aus einem öffentlichen Schlüssel, der Ihrem privaten Serverschlüssel entspricht, sowie einer Signatur durch die CA, die kryptografisch an den öffentlichen Schlüssel gebunden ist. Wenn ein Browser über HTTPS eine Verbindung zu einem Webserver herstellt, präsentiert der Server dem Browser ein Zertifikat, das er anhand seiner Liste vertrauenswürdiger Server überprüfen kann CAs. Wenn sich der Aussteller auf der Liste befindet oder über eine *Vertrauenskette* aus anderen vertrauenswürdigen Ausstellern zugänglich ist, handelt der Browser einen schnellen verschlüsselten Datenkanal mit dem Server aus und lädt die Seite.
Im Allgemeinen sind Zertifikate aufgrund der Arbeit im Zusammenhang mit der Validierung der Anforderungen kostenpflichtig, deshalb lohnt es sich, die Angebote zu vergleichen. Einige CAs bieten kostenlose Basiszertifikate an. Das bemerkenswerteste davon CAs ist das [Let's Encrypt-Projekt](https://letsencrypt.org/), das auch die Automatisierung des Prozesses zur Erstellung und Verlängerung von Zertifikaten unterstützt. Weitere Informationen zur Verwendung eines Let's Encrypt-Zertifikats finden Sie unter [Get Certbot](https://eff-certbot.readthedocs.io/en/stable/install.html).
Wenn Sie beabsichtigen, kommerzielle Dienstleistungen anzubieten, ist [AWS Certificate Manager](https://docs.aws.amazon.com/acm/latest/userguide/acm-overview.html) eine gute Option.
Dem Host-Zertifikat liegt der Schlüssel zugrunde. Seit 2019 empfehlen [Regierungs-](http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-57pt1r4.pdf) und [Branchengruppen](https://cabforum.org/wp-content/uploads/CA-Browser-Forum-BR-1.6.5.pdf) eine Schlüssel(-Modul)-Mindestgröße von 2048 Bits für RSA-Schlüssel, die Dokumente bis 2030 schützen sollen. Die von OpenSSL generierte Standardmodulgröße AL2 beträgt 2048 Bit, was für die Verwendung in einem CA-signierten Zertifikat geeignet ist. Im folgenden Verfahren ist ein optionaler Schritt für diejenigen vorgesehen, die einen benutzerdefinierten Schlüssel verwenden möchten, z.B. einen mit einem größeren Modul oder mit einem anderen Verschlüsselungsalgorithmus.
**Wichtig**
Diese Anweisungen zum Erwerb eines CA-signierten Host-Zertifikats funktioniert nur, wenn Sie eine registrierte und gehostete DNS-Domain besitzen.
**So rufen Sie ein CA-signierten Zertifikat ab**
1. [Connect](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) zu Ihrer Instance her und navigieren Sie zu/etc/pki/tls/private/. Dies ist das Verzeichnis, in dem Sie den privaten Schlüssel des Servers für TLS speichern. Wenn Sie lieber Ihren vorhandenen Host-Schlüssel zum Generieren der CSR verwenden möchten, fahren Sie mit Schritt 3 fort.
1. (Optional) Generieren Sie einen neuen privaten Schlüssel. Hier sind einige Beispiele für Schlüsselkonfigurationen. Jeder der resultierenden Schlüssel funktioniert mit Ihrem Webserver, aber sie unterscheiden sich durch den Grad und die Art der Sicherheit, die sie implementieren.
+ **Beispiel 1:** Erstellen Sie einen Standard-RSA-Hostschlüssel. Bei der erstellten Datei, **custom.key**, handelt es sich um einen privaten 2048-Bit-RSA-Schlüssel.
```
[ec2-user ~]$ sudo openssl genrsa -out custom.key
```
+ **Beispiel 2:** Erstellen Sie einen stärkeren RSA-Schlüssel mit einem größeren Modul. Bei der erstellten Datei, **custom.key**, handelt es sich um einen privaten 4096-Bit-RSA-Schlüssel.
```
[ec2-user ~]$ sudo openssl genrsa -out custom.key 4096
```
+ **Beispiel 3:** Erstellen Sie einen 4096-Bit-verschlüsselten RSA-Schlüssel mit Passwortschutz. Die resultierende Datei, **custom.key**, ist ein privater 4096-Bit-RSA-Schlüssel, der mit der AES-128-Verschlüsselung verschlüsselt ist.
**Wichtig**
Die Verschlüsselung des Schlüssels bietet höhere Sicherheit. Da für einen verschlüsselten Schlüssel ein Passwort erforderlich ist, können von diesem abhängige Services jedoch nicht automatisch gestartet werden. Jedes Mal, wenn Sie diesen Schlüssel verwenden, müssen Sie das Passwort (im vorhergehenden Beispiel „abcde12345“) über eine SSH-Verbindung bereitstellen.
```
[ec2-user ~]$ sudo openssl genrsa -aes128 -passout pass:abcde12345 -out custom.key 4096
```
+ **Beispiel 4:** Erstellen Sie einen Schlüssel mit einer Nicht-RSA-Verschlüsselung. Die RSA-Kryptografie kann aufgrund der Größe ihrer öffentlichen Schlüssel, die auf dem Produkt aus zwei großen Primzahlen basieren, relativ langsam sein. Es ist jedoch möglich, Schlüssel für TLS zu erstellen, die andere Verschlüsselungschiffren als RSA verwenden. Schlüssel, die auf der Mathematik von Ellipsenkurven basieren, sind kleiner und bieten eine schnellere Rechenleistung bei der Bereitstellung einer gleichwertigen Sicherheitsebene.
```
[ec2-user ~]$ sudo openssl ecparam -name prime256v1 -out custom.key -genkey
```
Das Ergebnis ist ein privater Ellipsenkurvenschlüssel mit 256-Bit, der prime256v1 verwendet, einer „benannten Kurve“, die OpenSSL unterstützt. Die kryptografische Stärke ist hierbei [laut NIST](http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-57pt1r4.pdf) etwas höher als bei einem 2048-Bit-RSA-Schlüssel.
**Anmerkung**
Nicht alle CAs bieten dieselbe Unterstützung für elliptic-curve-based Schlüssel wie für RSA-Schlüssel.
Stellen Sie sicher, dass der neue private Schlüssel sehr restriktive Besitzrechte und Berechtigungen hat (owner = root, group=root, read/write nur für Besitzer). Führen Sie die Befehle wie im folgenden Beispiel veranschaulicht aus.
```
[ec2-user ~]$ sudo chown root:root custom.key
[ec2-user ~]$ sudo chmod 600 custom.key
[ec2-user ~]$ ls -al custom.key
```
Die vorhergehenden Befehle erzeugen das folgende Ergebnis.
```
-rw------- root root custom.key
```
Wenn Sie einen zufriedenstellenden Schlüssel erstellt und konfiguriert haben, können Sie eine CSR erstellen.
1. Erstellen Sie eine CSR mit Ihrem bevorzugten Schlüssel. Im folgenden Beispiel wird verwende **custom.key**.
```
[ec2-user ~]$ sudo openssl req -new -key custom.key -out csr.pem
```
OpenSSL öffnet einen Dialog und fordert Sie auf, die in der folgenden Tabelle aufgeführten Informationen einzugeben. Alle Felder außer **Common Name** (Allgemeiner Name) sind bei einem grundlegenden, Domain-validierten Host-Zertifikat optional.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/linux/al2/ug/SSL-on-amazon-linux-2.html)
Zuletzt fordert OpenSSL Sie zur Eingabe eines optionalen Challenge-Passworts auf. Dieses Passwort gilt nur für die CSR und für Transaktionen zwischen Ihnen und Ihrer CA. Befolgen Sie daher die Empfehlungen Ihrer CA diesbezüglich und in Bezug auf das andere optionale Feld, den optionalen Unternehmensnamen. Das CSR-Challenge-Passwort wirkt sich nicht auf den Serverbetrieb aus.
Die erstellte Datei **csr.pem** enthält Ihren öffentlichen Schlüssel, die digitale Signatur Ihres öffentlichen Schlüssels und die von Ihnen eingegebenen Metadaten.
1. Übermitteln Sie die CSR an eine CA. Dies besteht in der Regel daraus, Ihre CSR-Datei in einem Texteditor zu öffnen und den Inhalt in ein Webformular zu kopieren. Zu diesem Zeitpunkt werden Sie möglicherweise aufgefordert, einen oder mehrere alternative Namen (SANs) für das Zertifikat anzugeben. Wenn **www.example.com** der allgemeine Name ist, wäre **example.com** ein guter SAN und umgekehrt. Ein Besucher Ihrer Website, der einen dieser Namen eingibt, wird eine fehlerfreie Verbindung sehen. Wenn Ihr CA-Webformular dies zulässt, nehmen Sie den allgemeinen Namen in die Liste der auf SANs. Manche CAs schließen ihn automatisch ein.
Nachdem Ihre Anfrage genehmigt wurde, erhalten Sie ein neues, von der CA unterzeichnetes Host-Zertifikat. Möglicherweise werden Sie auch dazu aufgefordert, eine *Zwischenzertifikatsdatei* herunterzuladen, die zusätzliche Zertifikate enthält, welche zum Fertigstellen der Vertrauenskette der CA benötigt werden.
**Anmerkung**
Ihre CA kann Ihnen Dateien in verschiedenen Formaten für verschiedene Zwecke zusenden. Für dieses Tutorial sollten Sie nur eine Zertifikatsdatei im PEM-Format verwenden, die in der Regel (aber nicht immer) mit der Dateierweiterung `.pem` oder `.crt` gekennzeichnet ist. Wenn Sie sich nicht sicher sind, welche Datei Sie verwenden sollen, öffnen Sie die Dateien mit einem Texteditor und suchen Sie die Datei, die einen oder mehrere Blöcke enthält, die mit der folgenden Zeile beginnen.
```
- - - - -BEGIN CERTIFICATE - - - - -
```
Die Datei sollte darüber hinaus mit der folgenden Zeile enden.
```
- - - -END CERTIFICATE - - - - -
```
Sie können die Datei auch in der Befehlszeile testen, wie im Folgenden gezeigt.
```
[ec2-user certs]$ openssl x509 -in certificate.crt -text
```
Vergewissern Sie sich, dass diese Zeilen in der Datei erscheinen. Verwenden Sie keine Dateien, die mit `.p7b`, `.p7c` oder ähnlichen Dateiendungen enden.
1. Platzieren Sie ein neues CA-signiertes Zertifikat und alle Zwischenzertifikate im `/etc/pki/tls/certs`-Verzeichnis.
**Anmerkung**
Es gibt mehrere Möglichkeiten, für den Upload Ihres neuen Zertifikat in Ihre EC2-Instance. Der einfachste und informativste Weg ist jedoch, einen Texteditor (vi, nano oder notepad usw.) sowohl auf Ihrem lokalen Computer als auch auf Ihrer Instance zu öffnen, und dann den Dateiinhalt zwischen ihnen zu kopieren und einzufügen. Sie benötigen Root [sudo]-Berechtigungen, wenn Sie diese Operationen auf der EC2-Instance ausführen. Auf diese Weise können Sie sofort erkennen, ob es Probleme mit Berechtigungen oder mit dem Pfad gibt. Achten Sie jedoch darauf, beim Kopieren der Inhalte keine zusätzlichen Zeilen einzufügen und die Inhalte nicht zu ändern.
Überprüfen Sie innerhalb des `/etc/pki/tls/certs` Verzeichnisses, ob die Einstellungen für Dateibesitz, Gruppe und Berechtigungen den stark restriktiven AL2 Standardeinstellungen entsprechen (owner=root, group=root, read/write nur für Besitzer). Das folgende Beispiel zeigt die zu verwendenden Befehle.
```
[ec2-user certs]$ sudo chown root:root custom.crt
[ec2-user certs]$ sudo chmod 600 custom.crt
[ec2-user certs]$ ls -al custom.crt
```
Diese Befehle sollten das folgende Ergebnis hervorrufen.
```
-rw------- root root custom.crt
```
Die Berechtigungen für die Zwischenzertifikatsdatei sind weniger strikt (Eigentümer=root, Gruppe=root, Eigentümer kann schreiben, Gruppe kann lesen, die restliche Welt kann lesen). Das folgende Beispiel zeigt die zu verwendenden Befehle.
```
[ec2-user certs]$ sudo chown root:root intermediate.crt
[ec2-user certs]$ sudo chmod 644 intermediate.crt
[ec2-user certs]$ ls -al intermediate.crt
```
Diese Befehle sollten das folgende Ergebnis hervorrufen.
```
-rw-r--r-- root root intermediate.crt
```
1. Legen Sie den privaten Schlüssel, den Sie zum Erstellen der CSR verwendet haben, in das Verzeichnis `/etc/pki/tls/private/`.
**Anmerkung**
Es gibt mehrere Möglichkeiten für den Upload Ihrer benutzerdefinierten Schlüssel in Ihre EC2-Instance. Der einfachste und informativste Weg ist jedoch, einen Texteditor (vi, nano oder notepad usw.) sowohl auf Ihrem lokalen Computer als auch auf Ihrer Instance zu öffnen, und dann den Dateiinhalt zwischen ihnen zu kopieren und einzufügen. Sie benötigen Root [sudo]-Berechtigungen, wenn Sie diese Operationen auf der EC2-Instance ausführen. Auf diese Weise können Sie sofort erkennen, ob es Probleme mit Berechtigungen oder mit dem Pfad gibt. Achten Sie jedoch darauf, beim Kopieren der Inhalte keine zusätzlichen Zeilen einzufügen und die Inhalte nicht zu ändern.
Verwenden Sie innerhalb des `/etc/pki/tls/private` Verzeichnisses die folgenden Befehle, um zu überprüfen, ob die Einstellungen für Dateibesitz, Gruppen und Berechtigungen den stark restriktiven AL2 Standardeinstellungen entsprechen (owner=root, group=root, nur für Eigentümer). read/write
```
[ec2-user private]$ sudo chown root:root custom.key
[ec2-user private]$ sudo chmod 600 custom.key
[ec2-user private]$ ls -al custom.key
```
Diese Befehle sollten das folgende Ergebnis hervorrufen.
```
-rw------- root root custom.key
```
1. Bearbeiten Sie die Datei `/etc/httpd/conf.d/ssl.conf` so, dass sie Ihr neues Zertifikat und Ihre Schlüsseldateien widerspiegelt.
1. Geben Sie den Pfad und Dateinamen des CA-signierten Host-Zertifikats im `SSLCertificateFile`-Verzeichnis von Apache an.
```
SSLCertificateFile /etc/pki/tls/certs/custom.crt
```
1. Wenn Sie eine Zwischenzertifikatsdatei erhalten haben (`intermediate.crt` in diesem Beispiel), stellen Sie den entsprechenden Pfad und Dateinamen über das `SSLCACertificateFile`-Verzeichnis in Apache bereit:
```
SSLCACertificateFile /etc/pki/tls/certs/intermediate.crt
```
**Anmerkung**
Manche CAs kombinieren das Host-Zertifikat und die Zwischenzertifikate in einer einzigen Datei, sodass die Direktive überflüssig wird. `SSLCACertificateFile` Informieren Sie sich in den von Ihrer CA bereitgestellten Anweisungen.
1. Geben Sie den Pfad und Dateinamen des privaten Schlüssels (in diesem Beispiel `custom.key`) in der `SSLCertificateKeyFile`-Direktive von Apache an:
```
SSLCertificateKeyFile /etc/pki/tls/private/custom.key
```
1. Speichern Sie `/etc/httpd/conf.d/ssl.conf` und starten Sie Apache erneut.
```
[ec2-user ~]$ sudo systemctl restart httpd
```
1. Testen Sie Ihren Server, indem Sie Ihren Domain-Namen in eine Browser-URL-Leiste mit dem Präfix `https://` eingeben. Ihr Browser sollte die Testseite über HTTPS laden, ohne Fehler zu erzeugen.
## Schritt 3: Testen und Verstärken der Sicherheitskonfiguration
Wenn Ihre TLS betriebsbereit und öffentlich zugänglich ist, sollten Sie testen, wie sicher sie wirklich ist. Dies ist ganz einfach möglich mithilfe von Online-Services wie beispielsweise [Qualys SSL Labs](https://www.ssllabs.com/ssltest/analyze.html), der eine kostenlose und gründliche Analyse Ihrer Sicherheitseinrichtung durchführt. Basierend auf den Ergebnissen entscheiden Sie sich möglicherweise dafür, die Standard-Sicherheitskonfiguration zu verstärken, indem Sie kontrollieren, welche Protokolle akzeptiert werden sollen, welche Chiffren Sie bevorzugen und welche ausgeschlossen werden soll. Um weitere Informationen zu erhalten, sehen Sie sich an, [wie Qualys seine Skalen gestaltet](https://github.com/ssllabs/research/wiki/SSL-Server-Rating-Guide).
**Wichtig**
Reale Tests sind außerordentlich wichtig für die Sicherheit Ihres Servers. Kleine Konfigurationsfehler führen möglicherweise zu ernsten Sicherheitsverstößen und Datenverlusten. Da sich die empfohlenen Sicherheitsmaßnahmen aufgrund von Forschungen und neuartigen Bedrohungen ständig ändern, sind regelmäßige Sicherheitsprüfungen wichtig für eine gute Serveradministration.
Geben Sie auf der Website von [Qualys SSL Labs](https://www.ssllabs.com/ssltest/analyze.html) den vollständigen Domain-Namen Ihres Servers ein, in der Form **www.example.com**. Nach ungefähr zwei Minuten erhalten Sie eine Note (von A bis F) für Ihre Website sowie eine detaillierte Auflistung der Ergebnisse. In der folgenden Tabelle wird der Bericht für eine Domain zusammengefasst, deren Einstellungen mit der Standard-Apache-Konfiguration identisch sind AL2, und für die ein Certbot-Standardzertifikat vorhanden ist.
| | |
| --- |--- |
| Gesamtbewertung | B |
| Zertifikat | 100 % |
| Protokollunterstützung | 95 % |
| Schlüsselaustausch | 70 % |
| Chiffrestärke | 90 % |
Obwohl die Übersicht zeigt, dass die Konfiguration größtenteils intakt ist, zeigt der detaillierte Bericht einige potenzielle Probleme, die hier nach Schweregrad geordnet aufgelistet werden:
✗ **Die RC4 Chiffre wird für die Verwendung durch bestimmte ältere Browser unterstützt**. Eine Chiffre ist der mathematische Kern eines Verschlüsselungsalgorithmus. RC4[, eine schnelle Chiffre, die zur Verschlüsselung von TLS-Datenströmen verwendet wird, weist bekanntermaßen mehrere schwerwiegende Schwächen auf.](http://www.imperva.com/docs/hii_attacking_ssl_when_using_rc4.pdf) Wenn Sie nicht sehr gute Gründe haben, veraltete Browser zu unterstützen, sollten Sie dies deaktivieren.
✗ **Alte TLS-Versionen werden unterstützt.** Die Konfiguration unterstützt TLS 1.0 (bereits veraltet) und TLS 1.1 (demnächst veraltet). Seit 2018 wurde nur TLS 1.2 empfohlen.
✗ **Forward Secrecy wird nicht vollständig unterstützt.** [Forward Secrecy](https://en.wikipedia.org/wiki/Forward_secrecy) ist ein Feature von Algorithmen zur Verschlüsselung mit temporären (flüchtigen) Sitzungsschlüsseln, die von dem privaten Schlüssel abgeleitet werden. In der Praxis bedeutet dies, dass Angreifen HTTPS-Daten nicht entschlüsseln können, selbst wenn sie den langfristigen privaten Schlüssel eines Webservers besitzen.
**So korrigieren Sie die TLS-Konfiguration und machen Sie zukunftssicher**
1. Öffnen Sie die Konfigurationsdatei `/etc/httpd/conf.d/ssl.conf` in einem Texteditor und kommentieren Sie die folgende Zeile aus, indem Sie „\$1“ am Anfang der Zeile eingeben.
```
#SSLProtocol all -SSLv3
```
1. Fügen Sie die folgende Richtlinie hinzu:
```
#SSLProtocol all -SSLv3
SSLProtocol -SSLv2 -SSLv3 -TLSv1 -TLSv1.1 +TLSv1.2
```
Diese Richtlinie deaktiviert die SSL-Versionen 2 und 3 explizit sowie auch die TLS-Versionen 1.0 und 1.1. Der Server akzeptiert jetzt keine verschlüsselten Verbindungen mit Clients, die eine andere Version als TLS 1.2 verwenden. Der Verbose-Wortlaut in der Richtlinie teilt einem menschlichen Leser genauer mit, wofür der Server konfiguriert ist.
**Anmerkung**
Durch eine solche Deaktivierung der TLS-Versionen 1.0 und 1.1 wird ein kleiner Prozentsatz von veralteten Webbrowsern daran gehindert, auf Ihre Website zuzugreifen.
**So ändern Sie die Liste der zulässigen Chiffren**
1. Suchen Sie in der Konfigurationsdatei `/etc/httpd/conf.d/ssl.conf` den Abschnitt mit der **SSLCipherSuite**-Richtlinie und kommentieren Sie die bestehende Zeile aus, indem Sie „\$1“ am Anfang der Zeile eingeben.
```
#SSLCipherSuite HIGH:MEDIUM:!aNULL:!MD5
```
1. Geben Sie explizite Verschlüsselungssammlungen und eine Verschlüsselungsreihenfolge an, die Forward Secrecy unterstützt und unsichere Verschlüsselungen vermeidet. Die hier verwendete Richtlinie `SSLCipherSuite` basiert auf der Ausgabe aus dem [Mozilla SSL-Konfigurationsgenerator](https://mozilla.github.io/server-side-tls/ssl-config-generator/), der eine TLS-Konfiguration an die spezifische Software, die auf Ihrem Server ausgeführt wird, angepasst wird. Bestimmen Sie zunächst Ihre Apache- und OpenSSL-Versionen, indem Sie die Ausgabe der folgenden Befehle verwenden.
```
[ec2-user ~]$ yum list installed | grep httpd
[ec2-user ~]$ yum list installed | grep openssl
```
Wenn die zurückgegebenen Informationen beispielsweise Apache 2.4.34 und OpenSSL 1.0.2 sind, geben wir diese in den Generator ein. Wenn Sie das „moderne“ Kompatibilitätsmodell auswählen, wird dadurch eine `SSLCipherSuite`-Richtlinie erstellt, die die Sicherheit aggressiv durchsetzt, aber dennoch für die meisten Browser funktioniert. Wenn die Modemkonfiguration von der Software nicht unterstützt wird, können Sie Ihre Software aktualisieren oder stattdessen die „fortgeschrittene“ Konfiguration wählen.
```
SSLCipherSuite ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:
ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:
ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256
```
Die ausgewählten Chiffren weisen *ECDHE* im Namen auf, eine Abkürzung für *Elliptic Curve Diffie-Hellman Ephemeral*. Der Begriff *Ephemeralität* (Flüchtigkeit) gibt die "Forward Secrecy (Folgenlosigkeit)" an. Als Nebenprodukt werden diese Chiffren nicht unterstützt. RC4
Wir empfehlen, eine explizite Liste von Chiffren zu verwenden, anstatt sich auf Standardeinstellungen oder knappe Richtlinien zu verlassen, deren Inhalt nicht sichtbar ist.
Kopieren Sie die erzeugte Richtlinie in `/etc/httpd/conf.d/ssl.conf`.
**Anmerkung**
Obwohl dies hier zur besseren Lesbarkeit auf mehrere Zeilen verteilt ist, muss die Richtlinie in einer einzelnen Zeile mit nur einem Doppelpunkt (ohne Leerstellen) aufgeführt werden, wenn sie nach `/etc/httpd/conf.d/ssl.conf` kopiert wird.
1. Entfernen Sie schließlich die Kommentarzeichen in der folgende Zeile, indem Sie das „\$1“ am Anfang der Zeile löschen.
```
#SSLHonorCipherOrder on
```
Diese Richtlinie zwingt den Server, hochrangige Chiffren zu bevorzugen, einschließlich derjenigen (in diesem Fall), die Forward Secrecy unterstützen. Wenn diese Richtlinie aktiviert ist, versucht der Server, eine hochgradig sichere Verbindung herzustellen, bevor er auf Chiffren mit geringerer Sicherheit zurückgreift.
Nach Abschluss dieser beiden Verfahren speichern Sie die Änderungen in `/etc/httpd/conf.d/ssl.conf` und starten Sie Apache neu.
Wenn Sie die Domain erneut auf [Qualys SSL Labs](https://www.ssllabs.com/ssltest/analyze.html) testen, sollten Sie feststellen, dass die RC4 Sicherheitslücke und andere Warnungen behoben sind und die Zusammenfassung etwa wie folgt aussieht.
| | |
| --- |--- |
| Gesamtbewertung | A |
| Zertifikat | 100 % |
| Protokollunterstützung | 100 % |
| Schlüsselaustausch | 90 % |
| Chiffrestärke | 90 % |
Mit jeder Aktualisierung von OpenSSL werden neue Chiffren eingeführt und die Unterstützung für ältere entfernt. Behalten Sie Ihre AL2 EC2-Instance up-to-date, achten Sie auf Sicherheitsankündigungen von [OpenSSL](https://www.openssl.org/) und achten Sie auf Berichte über neue Sicherheitslücken in der Fachpresse.
## Fehlerbehebung
+ **Mein Apache-Webserver startet erst, wenn ich ein Passwort eingebe**
Dieses Verhalten wird erwartet, wenn Sie einen verschlüsselten, passwortgeschützten privaten Serverschlüssel installiert haben.
Sie können die Verschlüsselungs- und Passwortanforderung vom Schlüssel entfernen. Angenommen, Sie haben einen privaten verschlüsselten RSA-Schlüssel namens `custom.key` im Standardverzeichnis und das Passwort darauf ist **abcde12345**, dann führen Sie die folgenden Befehle auf Ihrer EC2-Instance aus, um eine unverschlüsselte Version des Schlüssels zu erzeugen.
```
[ec2-user ~]$ cd /etc/pki/tls/private/
[ec2-user private]$ sudo cp custom.key custom.key.bak
[ec2-user private]$ sudo openssl rsa -in custom.key -passin pass:abcde12345 -out custom.key.nocrypt
[ec2-user private]$ sudo mv custom.key.nocrypt custom.key
[ec2-user private]$ sudo chown root:root custom.key
[ec2-user private]$ sudo chmod 600 custom.key
[ec2-user private]$ sudo systemctl restart httpd
```
Apache sollte jetzt starten, ohne Sie zur Eingabe eines Passworts aufzufordern.
+ **Ich erhalten Fehlermeldungen, wenn ich sudo yum install -y mod\$1ssl ausführe.**
Wenn Sie die für SSL erforderlichen Pakete installieren, treten möglicherweise Fehler wie die folgenden auf.
```
Error: httpd24-tools conflicts with httpd-tools-2.2.34-1.16.amzn1.x86_64
Error: httpd24 conflicts with httpd-2.2.34-1.16.amzn1.x86_64
```
Dies bedeutet in der Regel, dass Ihre EC2-Instance nicht läuft. AL2 Dieses Tutorial unterstützt nur von einer offiziellen AL2-AMI neu erstellte Instances.
# Tutorial: Hosten Sie einen WordPress Blog auf AL2
Die folgenden Verfahren helfen Ihnen bei der Installation, Konfiguration und Sicherung eines WordPress Blogs auf Ihrer AL2-Instance. Dieses Tutorial ist eine gute Einführung in die Verwendung von Amazon EC2, da Sie die volle Kontrolle über einen Webserver haben, auf dem Ihr WordPress Blog gehostet wird, was bei einem herkömmlichen Hosting-Service nicht typisch ist.
Sie sind für das Aktualisieren der Softwarepakete und das Warten der Sicherheitspatches für Ihren Server verantwortlich. Für eine stärker automatisierte WordPress Installation, die keine direkte Interaktion mit der Webserver-Konfiguration erfordert, bietet der CloudFormation Service eine WordPress Vorlage, mit der Sie auch schnell loslegen können. Weitere Informationen finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/GettingStarted.Walkthrough.html) im *AWS CloudFormation -Benutzerhandbuch*. *Wenn Sie eine Hochverfügbarkeitslösung mit einer entkoppelten Datenbank benötigen, finden Sie weitere Informationen unter [Deployment a High Availability WordPress Website](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/php-hawordpress-tutorial.html) im Developer Guide.AWS Elastic Beanstalk *
**Wichtig**
Diese Verfahren sind für die Verwendung mit vorgesehen. AL2 Weitere Informationen zu anderen Verteilungen finden Sie in der jeweiligen Dokumentation. Zahlreiche Schritte in diesem Tutorial funktionieren auf Ubuntu-Instances nicht. Hilfe zur Installation WordPress auf einer Ubuntu-Instanz finden Sie [WordPress](https://help.ubuntu.com/community/WordPress)in der Ubuntu-Dokumentation. Sie können diese Aufgabe auch auf Amazon Linux-, macOS- oder Unix-Systemen ausführen. [CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-launch-instance.html)
**Topics**
+ [Voraussetzungen](#hosting-wordpress-prereqs)
+ [Installieren WordPress](#install-wordpress)
+ [Nächste Schritte](#wordpress-next-steps)
+ [Hilfe\$1 Mein öffentlicher DNS-Name hat sich geändert und jetzt funktioniert mein Blog nicht mehr.](#wordpress-troubleshooting)
## Voraussetzungen
In diesem Tutorial wird davon ausgegangen, dass Sie eine AL2 Instanz mit einem funktionierenden Webserver mit PHP- und Datenbankunterstützung (entweder MySQL oder MariaDB) gestartet haben, indem Sie alle Schritte unter ausgeführt haben. [Tutorial: Installieren Sie einen LAMP-Server auf AL2](ec2-lamp-amazon-linux-2.md) Dieses Tutorial enthält auch Schritte zum Konfigurieren einer Sicherheitsgruppe, um `HTTP`- und `HTTPS`-Datenverkehr zuzulassen, sowie mehrere Schritte zum Sicherstellen, dass die Dateiberechtigungen für Ihren Webserver richtig festgelegt sind. Informationen zum Hinzufügen von Regeln zu Ihrer Sicherheitsgruppe finden [Sie unter Regeln zu einer Sicherheitsgruppe hinzufügen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule).
Wir empfehlen dringend, dass Sie der Instance, die Sie zum Hosten eines WordPress Blogs verwenden, eine Elastic IP-Adresse (EIP) zuordnen. Dies verhindert, dass die öffentliche DNS-Adresse für Ihre Instance geändert und Ihre Installation beschädigt wird. Wenn Sie einen Domain-Namen besitzen und für Ihren Blog verwenden möchten, können Sie den DNS-Eintrag für den Domain-Namen so aktualisieren, dass er auf Ihre EIP-Adresse verweist (wenden Sie sich an Ihre Domain-Namen-Registrierungsstelle, wenn Sie dabei Hilfe benötigen). Sie können eine EIP-Adresse kostenlos mit einer aktiven Instance verknüpfen. Weitere Informationen finden Sie unter [Elastische IP-Adressen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) im *Benutzerhandbuch für Amazon EC2*.
Wenn Sie noch keinen Domain-Namen für Ihren Blog haben, können Sie einen Domain-Namen bei Route 53 registrieren und die EIP-Adresse Ihrer Instance mit Ihrem Domain-Namen verknüpfen. Weitere Informationen finden Sie unter [Registrieren von Domain-Namen mithilfe von Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar.html) im *Entwicklerhandbuch für Amazon Route 53*.
## Installieren WordPress
**Option: Abschließen dieses Tutorials mit Automation**
Um dieses Tutorial mit AWS Systems Manager Automatisierung anstelle der folgenden Aufgaben abzuschließen, führen Sie das [Automatisierungsdokument](https://console.aws.amazon.com/systems-manager/documents/AWSDocs-HostingAWordPressBlog/) aus.
Connect zu Ihrer Instance her und laden Sie das WordPress Installationspaket herunter.
**Um das WordPress Installationspaket herunterzuladen und zu entpacken**
1. Laden Sie das neueste WordPress Installationspaket mit dem **wget** Befehl herunter. Mit dem folgenden Befehl sollte immer die aktuelle Version heruntergeladen werden.
```
[ec2-user ~]$ wget https://wordpress.org/latest.tar.gz
```
1. Extrahieren Sie das Installationspaket. Der Installationsordner wird in einem Ordner namens extrahier `wordpress`.
```
[ec2-user ~]$ tar -xzf latest.tar.gz
```
**Um einen Datenbankbenutzer und eine Datenbank für Ihre WordPress Installation zu erstellen**
Ihre WordPress Installation muss Informationen wie Blogbeiträge und Benutzerkommentare in einer Datenbank speichern. Mit diesem Verfahren können Sie eine Datenbank für Ihren Blog und einen Benutzer mit der Berechtigung zum Lesen und Speichern von Informationen in dieser Datenbank erstellen.
1. Starten des Datenbankservers.
+
```
[ec2-user ~]$ sudo systemctl start mariadb
```
1. Melden Sie sich auf dem Datenbankserver als `root`-Benutzer an. Geben Sie Ihr Datenbank-`root`-Passwort ein, wenn Sie dazu aufgefordert werden; dieses kann sich von Ihrem `root`-Systempasswort unterscheiden oder sogar leer bleiben, wenn Sie Ihren Datenbankserver nicht gesichert haben.
Wenn Sie Ihren Datenbankserver noch nicht gesichert haben, ist es wichtig, dass Sie diesen Schritt durchführen. Weitere Informationen finden Sie unter [Sichern des MariaDB-Servers](ec2-lamp-amazon-linux-2.md#securing-maria-db) (AL2).
```
[ec2-user ~]$ mysql -u root -p
```
1. Erstellen Sie einen Benutzer und ein Passwort für Ihre MySQL-Datenbank. Ihre WordPress Installation verwendet diese Werte, um mit Ihrer MySQL-Datenbank zu kommunizieren.
Achten Sie darauf, ein sicheres Passwort für Ihren Benutzer zu erstellen. Verwenden Sie keine einfachen Anführungszeichen ( ' ) in Ihrem Passwort, da diese den vorhergehenden Befehl beschädigen. Verwenden Sie kein bereits vorhandenes Passwort und speichern Sie das Passwort an einem sicheren Ort.
Geben Sie den folgenden Befehl ein, wobei Sie einen eindeutigen Benutzernamen und ein eindeutiges Passwort einsetzen.
```
CREATE USER 'wordpress-user'@'localhost' IDENTIFIED BY 'your_strong_password';
```
1. Erstellen Sie Ihre Datenbank. Geben Sie Ihrer Datenbank einen aussagekräftigen Namen wie `wordpress-db`.
**Anmerkung**
Die Satzzeichen um den Datenbanknamen im folgenden Befehl heißen „einfache umgekehrte Anführungszeichen“. Die Taste für das einfache umgekehrte Anführungszeichen (```) befindet sich auf einer Standardtastatur in der Regel oberhalb der `Tab`-Taste. Einfache umgekehrte Anführungszeichen sind nicht immer erforderlich, sie ermöglichen Ihnen jedoch die Verwendung von Zeichen in Datenbanknamen, die andernfalls nicht zulässig wären, z. B. Bindestriche.
```
CREATE DATABASE `wordpress-db`;
```
1. Gewähren Sie dem WordPress Benutzer, den Sie zuvor erstellt haben, die vollen Rechte für Ihre Datenbank.
```
GRANT ALL PRIVILEGES ON `wordpress-db`.* TO "wordpress-user"@"localhost";
```
1. Löschen Sie die Datenbankrechte, damit alle Ihre Änderungen übernommen werden.
```
FLUSH PRIVILEGES;
```
1. Beenden Sie den `mysql`-Client.
```
exit
```
**So erstellen und bearbeiten Sie die Datei „wp-config.php“**
Der WordPress Installationsordner enthält eine Beispielkonfigurationsdatei mit dem Namen`wp-config-sample.php`. In diesem Verfahren kopieren und bearbeiten Sie diese Datei, um sie an Ihre individuelle Konfiguration anzupassen.
1. Kopieren Sie die Datei `wp-config-sample.php` in eine Datei namens `wp-config.php`. Dadurch wird eine neue Konfigurationsdatei erstellt und die Originalversion der Beispieldatei als Sicherung aufbewahrt.
```
[ec2-user ~]$ cp wordpress/wp-config-sample.php wordpress/wp-config.php
```
1. Bearbeiten Sie die Datei `wp-config.php` mit Ihrem bevorzugten Texteditor (z. B. **nano**oder **vim**) und geben Sie Werte für Ihre Installation ein. Falls Sie keinen bevorzugten Texteditor haben, ist `nano` für den Einstieg geeignet.
```
[ec2-user ~]$ nano wordpress/wp-config.php
```
1. Suchen Sie die Zeile, die `DB_NAME` definiert und ändern Sie `database_name_here` in den Namen der Datenbank, die Sie in [Step 4](#create_database) von [Um einen Datenbankbenutzer und eine Datenbank für Ihre WordPress Installation zu erstellen](#create_user_and_database) erstellt haben.
```
define('DB_NAME', 'wordpress-db');
```
1. Suchen Sie die Zeile, die `DB_USER` definiert und ändern Sie `username_here` in den Namen des Datenbankbenutzers, den Sie in [Step 3](#create_database_user) von [Um einen Datenbankbenutzer und eine Datenbank für Ihre WordPress Installation zu erstellen](#create_user_and_database) erstellt haben.
```
define('DB_USER', 'wordpress-user');
```
1. Suchen Sie die Zeile, die `DB_PASSWORD` definiert und ändern Sie `password_here` in das sichere Passwort, das Sie in [Step 3](#create_database_user) von [Um einen Datenbankbenutzer und eine Datenbank für Ihre WordPress Installation zu erstellen](#create_user_and_database) erstellt haben.
```
define('DB_PASSWORD', 'your_strong_password');
```
1. Suchen Sie den Abschnitt `Authentication Unique Keys and Salts`. Diese `KEY` und `SALT` Werte bieten eine Verschlüsselungsebene für die Browser-Cookies, die WordPress Benutzer auf ihren lokalen Computern speichern. Grundsätzlich wird Ihre Website durch das Hinzufügen langer, zufälliger Werte sicherer. Besuchen Sie [https://api.wordpress. org/secret-key/1.1/salt](https://api.wordpress.org/secret-key/1.1/salt/)/, um nach dem Zufallsprinzip eine Reihe von Schlüsselwerten zu generieren, die Sie kopieren und in Ihre `wp-config.php` Datei einfügen können. Zum Einfügen von Text in ein PuTTY-Terminal platzieren Sie den Mauszeiger dort, wo der Text eingefügt werden soll, und klicken mit der rechten Maustaste innerhalb des PuTTY-Terminals.
Weitere Informationen zu Sicherheitsschlüsseln finden Sie [unter https://wordpress. org/support/article/editing-wp-config-php/\$1security -keys](https://wordpress.org/support/article/editing-wp-config-php/#security-keys).
**Anmerkung**
Die folgenden Werte dienen nur als Beispiel; verwenden Sie diese Werte nicht für Ihre Installation.
```
define('AUTH_KEY', ' #U$$+[RXN8:b^-L 0(WU_+ c+WFkI~c]o]-bHw+)/Aj[wTwSiZ)Y |;(^[Iw]Pi+LG#A4R?7N`YB3');
define('NONCE_KEY', 'P(g62HeZxEes|LnI^i=H,[XwK9I&[2s|:?0N}VJM%?;v2v]v+;+^9eXUahg@::Cj');
define('AUTH_SALT', 'C$DpB4Hj[JK:?{ql`sRVa:{:7yShy(9A@5wg+`JJVb1fk%_-Bx*M4(qc[Qg%JT!h');
define('SECURE_AUTH_SALT', 'd!uRu#}+q#{f$Z?Z9uFPG.${+S{n~1M&%@~gL>U>NV.|Y%Ug4#I^*LVd9QeZ^&XmK|e(76miC+&W&+^0P/');
define('NONCE_SALT', '-97r*V/cgxLmp?Zy4zUU4r99QQ_rGs2LTd%P;|_e1tS)8_B/,.6[=UK`.
```
#
# Possible values for the Options directive are "None", "All",
# or any combination of:
# Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
#
# Note that "MultiViews" must be named *explicitly* --- "Options All"
# doesn't give it to you.
#
# The Options directive is both complicated and important. Please see
# http://httpd.apache.org/docs/2.4/mod/core.html#options
# for more information.
#
Options Indexes FollowSymLinks
#
# AllowOverride controls what directives may be placed in .htaccess files.
# It can be "All", "None", or any combination of the keywords:
# Options FileInfo AuthConfig Limit
#
AllowOverride None
#
# Controls who can get stuff from this server.
#
Require all granted
```
1. Ändern Sie die Zeile `AllowOverride None` im Abschnitt oben in `AllowOverride All`.
**Anmerkung**
Diese Datei enthält mehrere `AllowOverride`-Zeilen; achten Sie unbedingt darauf, die Zeile im Abschnitt `` zu ändern.
```
AllowOverride All
```
1. Speichern Sie die Datei und beenden Sie den Text-Editor.
**Um die PHP-Grafikbibliothek zu installieren auf AL2**
Mit der GD-Bibliothek für PHP können Sie Bilder bearbeiten. Installieren Sie diese Bibliothek wie folgt, wenn Sie das Header-Image für Ihren Blog zuschneiden müssen. Für die Version phpMyAdmin , die Sie installieren, ist möglicherweise eine bestimmte Mindestversion dieser Bibliothek erforderlich (z. B. Version 7.2).
Verwenden Sie den folgenden Befehl, um die PHP-Grafikzeichnungsbibliothek auf zu installieren AL2. Wenn Sie beispielsweise php7.2 im amazon-linux-extras Rahmen der Installation des LAMP-Stacks installiert haben, installiert dieser Befehl Version 7.2 der PHP-Grafikzeichnungsbibliothek.
```
[ec2-user ~]$ sudo yum install php-gd
```
Verwenden Sie den folgenden Befehl, um die installierte Version zu überprüfen:
```
[ec2-user ~]$ sudo yum list installed php-gd
```
Das Folgende ist eine Beispielausgabe:
```
php-gd.x86_64 7.2.30-1.amzn2 @amzn2extra-php7.2
```
**So beheben Sie Probleme mit den Dateizugriffsberechtigungen für den Apache-Webserver**
Für einige der verfügbaren Funktionen ist Schreibzugriff auf das Apache Document Root WordPress erforderlich (z. B. das Hochladen von Medien über die Administrationsbildschirme). Falls Sie dies noch nicht getan haben, wenden Sie die folgenden Gruppenmitgliedschaften und -berechtigungen an (wie in der [Tutorial: Installieren Sie einen LAMP-Server auf AL2](ec2-lamp-amazon-linux-2.md) ausführlicher beschrieben).
1. Machen Sie den `/var/www`-Benutzer zum Eigentümer der Datei `apache` und ihrer Inhalte.
```
[ec2-user ~]$ sudo chown -R apache /var/www
```
1. Machen Sie die `/var/www`-Gruppe zum Eigentümer der Datei `apache` und ihrer Inhalte.
```
[ec2-user ~]$ sudo chgrp -R apache /var/www
```
1. Ändern Sie die Verzeichnisberechtigungen von `/var/www` und deren Unterverzeichnissen, indem Sie Schreibberechtigungen für die Gruppe hinzufügen und die Gruppen-ID für zukünftige Unterverzeichnisse einrichten.
```
[ec2-user ~]$ sudo chmod 2775 /var/www
[ec2-user ~]$ find /var/www -type d -exec sudo chmod 2775 {} \;
```
1. Ändern Sie die Dateiberechtigungen von `/var/www` und deren Unterverzeichnissen rekursiv.
```
[ec2-user ~]$ find /var/www -type f -exec sudo chmod 0644 {} \;
```
**Anmerkung**
Wenn Sie beabsichtigen, ihn auch WordPress als FTP-Server zu verwenden, benötigen Sie hier großzügigere Gruppeneinstellungen. Bitte lesen Sie die empfohlenen [Schritte und Sicherheitseinstellungen unter](https://wordpress.org/support/article/changing-file-permissions/), WordPress um dies zu erreichen.
1. Starten Sie den Apache-Webserver neu, damit die neue Gruppe und die neuen Berechtigungen übernommen werden.
+
```
[ec2-user ~]$ sudo systemctl restart httpd
```
**Führen Sie das WordPress Installationsskript mit aus AL2**
Sie sind bereit zur Installation WordPress. Welche Befehle zu verwenden sind, ist vom Betriebssystem abhängig. Die Befehle in diesem Verfahren sind für die Verwendung mit bestimmt AL2.
1. Stellen Sie mit dem Befehl **systemctl** sicher, dass die `httpd`- und Datenbankdienste bei jedem Systemstart gestartet werden.
```
[ec2-user ~]$ sudo systemctl enable httpd && sudo systemctl enable mariadb
```
1. Überprüfen Sie, ob der Datenbankserver ausgeführt wird.
```
[ec2-user ~]$ sudo systemctl status mariadb
```
Wenn der Datenbankdienst nicht ausgeführt wird, starten Sie ihn.
```
[ec2-user ~]$ sudo systemctl start mariadb
```
1. Überprüfen Sie, ob Ihr Apache-Webserver (`httpd`) ausgeführt wird.
```
[ec2-user ~]$ sudo systemctl status httpd
```
Wenn der `httpd`-Dienst nicht ausgeführt wird, starten Sie ihn.
```
[ec2-user ~]$ sudo systemctl start httpd
```
1. Geben Sie in einem Webbrowser die URL Ihres WordPress Blogs ein (entweder die öffentliche DNS-Adresse für Ihre Instanz oder die Adresse, gefolgt vom `blog` Ordner). Sie sollten das WordPress Installationsskript sehen. Geben Sie die für die WordPress Installation erforderlichen Informationen ein. Klicken Sie auf **Installieren WordPress**, um die Installation abzuschließen. Weitere Informationen finden Sie unter [Schritt 5: Ausführen des Installationsskripts](https://wordpress.org/support/article/how-to-install-wordpress/#step-5-run-the-install-script) auf der WordPress Website.
## Nächste Schritte
Nachdem Sie Ihren WordPress Blog getestet haben, sollten Sie erwägen, seine Konfiguration zu aktualisieren.
**Verwenden eines benutzerdefinierten Domain-Namens**
Wenn ein Domain-Name mit der EIP-Adresse Ihrer EC2 Instance verknüpft ist, können Sie Ihren Blog für die Verwendung dieses Namens anstatt der öffentlichen DNS-Adresse von EC2 konfigurieren. Weitere Informationen finden Sie unter [Ändern der Site-URL](https://wordpress.org/support/article/changing-the-site-url/) auf der WordPress Website.
**Konfigurieren Ihres Blogs**
Sie können Ihren Blog für die Verwendung verschiedener [Designs](https://wordpress.org/themes/) und [Plugins](https://wordpress.org/plugins/) konfigurieren, um Ihren Lesern eine persönlich angepasste Umgebung zu bieten. Bisweilen kann der Installationsprozess jedoch fehlschlagen und zum Verlust des gesamten Blogs führen. Wir empfehlen dringend, eine Amazon Machine Image (AMI)-Sicherung Ihrer Instance zu erstellen, bevor Sie versuchen, Designs oder Plug-Ins zu installieren, damit Sie Ihren Blog wiederherstellen können, falls bei der Installation ein Fehler auftritt. Weitere Informationen finden Sie unter [Erstellen Sie Ihr eigenes AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami).
**Erhöhen der Kapazität**
Wenn Ihr WordPress Blog immer beliebter wird und Sie mehr Rechenleistung oder Speicherplatz benötigen, sollten Sie die folgenden Schritte in Betracht ziehen:
+ Erweitern Sie den Speicherplatz auf Ihrer Instance. Weitere Informationen finden Sie unter [Amazon EBS Elastic Volumes](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html) im *Amazon-EBS-Benutzerhandbuch*.
+ Verschieben Sie Ihre MySQL-Datenbank zu [Amazon RDS](https://aws.amazon.com/rds), um die Möglichkeit zur einfachen Skalierung dieses Services zu nutzen.
**Verbesserung der Netzwerkleistung Ihres Internetverkehrs**
Wenn Sie erwarten, dass Ihr Blog den Traffic von Nutzern auf der ganzen Welt steigern wird, sollten Sie [AWS Global Accelerator](https://aws.amazon.com/global-accelerator) in Betracht ziehen. Global Accelerator hilft Ihnen dabei, die Latenz zu senken, indem es die Leistung des Internetverkehrs zwischen den Client-Geräten Ihrer Benutzer und Ihrer WordPress Anwendung, auf der ausgeführt wird, verbessert AWS. Global Accelerator nutzt das [AWS globale Netzwerk](https://aws.amazon.com/about-aws/global-infrastructure/global_network/), um den Datenverkehr an einen funktionierenden Anwendungsendpunkt in der AWS Region weiterzuleiten, die dem Client am nächsten ist.
**Erfahren Sie mehr über WordPress**
Informationen dazu WordPress finden Sie in der WordPress Codex-Hilfedokumentation unter [http://codex.wordpress.org/](http://codex.wordpress.org/).
Weitere Informationen zur Problembehandlung bei Ihrer Installation finden Sie unter [Häufige Installationsprobleme](https://wordpress.org/support/article/how-to-install-wordpress/#common-installation-problems).
Informationen dazu, wie Sie Ihr WordPress Blog sicherer machen können, finden Sie unter [Hardening WordPress](https://wordpress.org/support/article/hardening-wordpress/).
Informationen dazu, wie Sie Ihr WordPress Blog behalten up-to-date, finden Sie unter [Aktualisieren WordPress](https://wordpress.org/support/article/updating-wordpress/).
## Hilfe\$1 Mein öffentlicher DNS-Name hat sich geändert und jetzt funktioniert mein Blog nicht mehr.
Ihre WordPress Installation wird automatisch mit der öffentlichen DNS-Adresse für Ihre EC2-Instance konfiguriert. Wenn Sie die Instance anhalten und neu starten ändert sich die öffentliche DNS-Adresse (es sei denn, sie ist mit einer Elastic IP-Adresse) und Ihr Blog funktioniert nicht mehr, da er auf Ressourcen an einer Adresse verweist, die nicht mehr vorhanden (oder einer anderen EC2 Instance zugewiesen) ist. Eine detailliertere Beschreibung des Problems und mehrere mögliche Lösungen finden Sie unter [Ändern der Site-URL.](https://wordpress.org/support/article/changing-the-site-url/)
Wenn dies bei Ihrer WordPress Installation passiert ist, können Sie Ihr Blog möglicherweise mit dem folgenden Verfahren wiederherstellen, bei dem die **wp-cli** Befehlszeilenschnittstelle für verwendet wird WordPress.
**Um die URL Ihrer WordPress Website mit dem zu ändern **wp-cli****
1. Stellen Sie eine Verbindung mit Ihrer EC2 Instance über SSH her.
1. Notieren Sie die alte und die neue Website-URL für Ihre Instance. Die alte Site-URL ist wahrscheinlich der öffentliche DNS-Name für Ihre EC2-Instance bei der Installation WordPress. Die neue Website-URL ist der aktuelle öffentliche DNS-Name für Ihre EC2 Instance. Wenn Sie nicht sicher sind, was Ihre alte Website-URL ist, können Sie sie mit dem folgenden Befehl mithilfe von **curl** ermitteln.
```
[ec2-user ~]$ curl localhost | grep wp-content
```
In der Ausgabe, die folgendermaßen aussieht (alte Website-URL in rot) sollten Referenzen auf Ihren alten öffentlichen DNS-Namen enthalten sein:
```
```
1. Laden Sie das **wp-cli** mit dem folgenden Befehl herunter.
```
[ec2-user ~]$ curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar
```
1. Suchen und ersetzen Sie die alte Site-URL in Ihrer WordPress Installation durch den folgenden Befehl. Ersetzen Sie die alten und neuen Site-URLs für Ihre EC2-Instance und den Pfad zu Ihrer WordPress Installation (normalerweise `/var/www/html` oder`/var/www/html/blog`).
```
[ec2-user ~]$ php wp-cli.phar search-replace 'old_site_url' 'new_site_url' --path=/path/to/wordpress/installation --skip-columns=guid
```
1. Geben Sie in einem Webbrowser die neue Site-URL Ihres WordPress Blogs ein, um zu überprüfen, ob die Website wieder ordnungsgemäß funktioniert. Ist dies nicht der Fall, finden Sie weitere Informationen unter [Ändern der Site-URL](https://wordpress.org/support/article/changing-the-site-url/) und [Häufige Installationsprobleme](https://wordpress.org/support/article/how-to-install-wordpress/#common-installation-problems).