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.
# Tutorial: Bereitstellung WordPress auf einer Amazon EC2 EC2-Instance (Amazon Linux oder Red Hat Enterprise Linux und Linux, macOS oder Unix)
In diesem Tutorial stellen WordPress Sie ein Open-Source-Blogging-Tool und ein Content-Management-System auf der Basis von PHP und MySQL auf einer einzelnen Amazon EC2 EC2-Instance bereit, auf der Amazon Linux oder Red Hat Enterprise Linux (RHEL) ausgeführt wird.
Nicht das, wonach Sie gesucht haben?
+ Informationen zum Bereitstellen auf einer Amazon EC2 EC2-Instance, auf der stattdessen Windows Server ausgeführt wird, finden Sie unter[Tutorial: Bereite ein „Hallo, Welt\$1“ vor Anwendung mit CodeDeploy (Windows Server)](tutorials-windows.md).
+ Informationen zur Bereitstellung auf einer lokalen Instance statt auf einer Amazon EC2 EC2-Instance finden Sie unter. [Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md)
Die Schritte dieses Tutorials werden aus der Perspektive einer lokalen Entwicklungsmaschine vorgestellt, auf der Linux, macOS oder Unix ausgeführt wird. Sie können die meisten der Schritte auch auf einem lokalen Computer mit Windows durchführen, müssen dann jedoch alle Schritte anpassen, die Befehle wie **chmod** und **wget**, Anwendungen wie sed und Verzeichnispfade wie `/tmp` verwenden.
Bevor Sie mit diesem Tutorial beginnen, müssen Sie sicherstellen, dass die unter [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) beschriebenen Voraussetzungen erfüllt sind. Dazu gehören die Konfiguration eines Benutzers, die Installation oder Aktualisierung von und die AWS CLI Erstellung eines IAM-Instanzprofils und einer Servicerolle.
**Topics**
+ [Schritt 1: Starten und konfigurieren Sie eine Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance](tutorials-wordpress-launch-instance.md)
+ [Schritt 2: Konfigurieren Sie Ihren Quellinhalt für die Bereitstellung auf der Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance](tutorials-wordpress-configure-content.md)
+ [Schritt 3: Laden Sie Ihre WordPress Bewerbung auf Amazon S3 hoch](tutorials-wordpress-upload-application.md)
+ [Schritt 4: Stellen Sie Ihre WordPress Anwendung bereit](tutorials-wordpress-deploy-application.md)
+ [Schritt 5: Aktualisieren Sie Ihre WordPress Anwendung und stellen Sie sie erneut bereit](tutorials-wordpress-update-and-redeploy-application.md)
+ [Schritt 6: Bereinigen Sie Ihre WordPress Anwendung und die zugehörigen Ressourcen](tutorials-wordpress-clean-up.md)
# Schritt 1: Starten und konfigurieren Sie eine Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance
Um die WordPress Anwendung bereitzustellen CodeDeploy, benötigen Sie eine Amazon EC2 EC2-Instance, auf der Amazon Linux oder Red Hat Enterprise Linux (RHEL) ausgeführt wird. Die Amazon EC2 EC2-Instance erfordert eine neue Sicherheitsregel für eingehenden Datenverkehr, die HTTP-Verbindungen zulässt. Diese Regel ist erforderlich, um die WordPress Seite nach erfolgreicher Bereitstellung in einem Browser anzuzeigen.
Folgen Sie den Anweisungen in [Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy](instances-ec2-create.md). Wenn Sie zu dem Teil in diesen Anweisungen gelangen, in dem es darum geht, der Instance ein Amazon EC2 EC2-Instance-Tag zuzuweisen, geben Sie unbedingt den Tag-Schlüssel von **Name** und den Tag-Wert von an. **CodeDeployDemo** (Wenn Sie einen anderen Tag-Schlüssel oder Tag-Wert angeben, dann können die Anweisungen in [Schritt 4: Stellen Sie Ihre WordPress Anwendung bereit](tutorials-wordpress-deploy-application.md) zu unerwarteten Ergebnissen führen.)
Nachdem Sie die Anweisungen zum Starten der Amazon EC2 EC2-Instance befolgt haben, kehren Sie zu dieser Seite zurück und fahren Sie mit dem nächsten Abschnitt fort. Fahren Sie nicht mit [Erstellen Sie eine Anwendung mit CodeDeploy](applications-create.md) dem nächsten Schritt fort.
## Connect zu Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance her
Nachdem Ihre neue Amazon EC2 EC2-Instance gestartet wurde, folgen Sie diesen Anweisungen, um zu üben, wie Sie sich mit ihr verbinden.
1. Verwenden Sie den **ssh** Befehl (oder einen SSH-fähigen Terminalemulator wie [PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html)), um eine Verbindung zu Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance herzustellen. Sie benötigen die öffentliche DNS-Adresse der Instance und den privaten Schlüssel für das key pair, das Sie beim Starten der Amazon EC2 EC2-Instance verwendet haben. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html) (Verbindung mit der Instance herstellen).
Wenn die öffentliche DNS-Adresse beispielsweise lautet **ec2-01-234-567-890.compute-1.amazonaws.com** und Ihr Amazon EC2 EC2-Instance-Schlüsselpaar für den SSH-Zugriff benannt ist**codedeploydemo.pem**, würden Sie Folgendes eingeben:
```
ssh -i /path/to/codedeploydemo.pem ec2-user@ec2-01-234-567-890.compute-1.amazonaws.com
```
`/path/to/codedeploydemo.pem`Ersetzen Sie durch den Pfad zu Ihrer `.pem` Datei und die Beispiel-DNS-Adresse durch die Adresse Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance.
**Anmerkung**
Wenn ein Fehler angezeigt wird, der besagt, dass die Berechtigungen der Schlüsseldatei nicht restriktiv genug sind, müssen Sie diese Berechtigungen einschränken, sodass nur der aktuelle Benutzer (Sie) Zugriff hat. Geben Sie beispielsweise mit dem **chmod** Befehl unter Linux, macOS oder Unix Folgendes ein:
```
chmod 400 /path/to/codedeploydemo.pem
```
1. Nachdem Sie sich angemeldet haben, sehen Sie das AMI-Banner für die Amazon EC2 EC2-Instance. Für Amazon Linux sollte es so aussehen:
```
__| __|_ )
_| ( / Amazon Linux AMI
___|\___|___|
```
1. Sie können sich jetzt von der laufenden Amazon EC2 EC2-Instance abmelden.
**Warnung**
Beenden oder beenden Sie die Amazon EC2 EC2-Instance nicht. Andernfalls kann sie CodeDeploy nicht bereitgestellt werden.
## Fügen Sie eine Regel für eingehenden Datenverkehr hinzu, die HTTP-Verkehr zu Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance zulässt
Im nächsten Schritt wird bestätigt, dass Ihre Amazon EC2 EC2-Instance über einen offenen HTTP-Port verfügt, sodass Sie die Startseite der bereitgestellten WordPress Anwendung in einem Browser sehen können.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie **Instances** und dann Ihre Instance aus.
1. Wählen Sie auf der Registerkarte **Beschreibung** unter **Sicherheitsgruppen** die Option **Regeln für eingehenden Datenverkehr anzeigen** aus.
In Ihrer Sicherheitsgruppe sollte eine Liste mit Regeln wie die folgende angezeigt werden:
```
Security Groups associated with i-1234567890abcdef0
Ports Protocol Source launch-wizard-N
22 tcp 0.0.0.0/0 ✔
```
1. Wählen Sie unter **Sicherheitsgruppen** die Sicherheitsgruppe für Ihre Amazon EC2 EC2-Instance aus. Ein möglicher Name ist **launch-wizard-*N***. Beim ***N*** im Namen handelt es sich um eine Nummer, die Ihrer Sicherheitsgruppe beim Erstellen Ihrer Instance zugewiesen wurde.
Wählen Sie die Registerkarte **Inbound (Eingehend)**. Wenn die Sicherheitsgruppe für Ihre Instance korrekt konfiguriert ist, sollte Ihnen eine Regel mit den folgenden Werten angezeigt werden:
+ **Typ**: HTTP
+ **Protocol (Protokoll)**: TCP
+ **Portbereich**: 80
+ **Quelle**: 0.0.0.0/0
1. Wenn Sie keine Regel mit diesen Werten sehen, gehen Sie wie unter [Regeln zu einer Sicherheitsgruppe hinzufügen beschrieben vor, um sie einer neuen Sicherheitsregel](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) hinzuzufügen.
# Schritt 2: Konfigurieren Sie Ihren Quellinhalt für die Bereitstellung auf der Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance
Jetzt ist es an der Zeit, die Quellinhalte Ihrer Anwendung zu konfigurieren, damit Sie Inhalte haben, die Sie auf der Instance bereitstellen können.
**Topics**
+ [Holen Sie sich den Quellcode](#tutorials-wordpress-configure-content-download-code)
+ [Erstellen Sie Skripts, um Ihre Anwendung auszuführen](#tutorials-wordpress-configure-content-create-scripts)
+ [Fügen Sie eine Anwendungsspezifikationsdatei hinzu](#tutorials-wordpress-configure-content-add-appspec-file)
## Holen Sie sich den Quellcode
In diesem Tutorial stellen Sie die Plattform zur Veröffentlichung von WordPress Inhalten von Ihrem Entwicklungscomputer auf der Amazon EC2 EC2-Zielinstanz bereit. Um den WordPress Quellcode abzurufen, können Sie integrierte Befehlszeilenaufrufe verwenden. Wenn Sie auf Ihrem Entwicklungscomputer Git installiert haben, können Sie stattdessen auch Git verwenden.
Für diese Schritte gehen wir davon aus, dass Sie eine Kopie des WordPress Quellcodes in das `/tmp` Verzeichnis auf Ihrem Entwicklungscomputer heruntergeladen haben. (Sie können jedes beliebige Verzeichnis wählen. Denken Sie aber daran, den Speicherort für `/tmp` zu ersetzen, wenn dies in den folgenden Schritten angegeben ist.)
Wählen Sie eine der folgenden beiden Optionen, um die WordPress Quelldateien auf Ihren Entwicklungscomputer zu kopieren. Bei der ersten Option werden integrierte Befehlszeilenaufrufe genutzt. Bei der zweiten Option wird Git verwendet.
**Topics**
+ [Um eine Kopie des WordPress Quellcodes zu erhalten (integrierte Befehlszeilenaufrufe)](#tutorials-wordpress-configure-content-download-code-command-line)
+ [Um eine Kopie des WordPress Quellcodes zu erhalten (Git)](#tutorials-wordpress-configure-content-download-code-git)
### Um eine Kopie des WordPress Quellcodes zu erhalten (integrierte Befehlszeilenaufrufe)
1. Rufen Sie den **wget** Befehl auf, um eine Kopie des WordPress Quellcodes als ZIP-Datei in das aktuelle Verzeichnis herunterzuladen:
```
wget https://github.com/WordPress/WordPress/archive/master.zip
```
1. Rufen Sie die Befehle **unzip**, **mkdir**, **cp** und **rm** auf, um:
+ die `master` .zip-Datei im `/tmp/WordPress_Temp`-Verzeichnis (Ordner) zu entpacken.
+ den entpackten Inhalt in den `/tmp/WordPress`-Zielordner zu kopieren.
+ den temporären `/tmp/WordPress_Temp`-Ordner und die `master`-Datei zu löschen.
Führen Sie die Befehle einzeln aus:
```
unzip master -d /tmp/WordPress_Temp
```
```
mkdir -p /tmp/WordPress
```
```
cp -paf /tmp/WordPress_Temp/WordPress-master/* /tmp/WordPress
```
```
rm -rf /tmp/WordPress_Temp
```
```
rm -f master
```
Dadurch erhalten Sie einen sauberen Satz von WordPress Quellcodedateien im `/tmp/WordPress` Ordner.
### Um eine Kopie des WordPress Quellcodes zu erhalten (Git)
1. Laden Sie [Git](http://git-scm.com) auf Ihren Entwicklungscomputer herunter und installieren Sie das Programm.
1. Rufen Sie im Ordner `/tmp/WordPress` den Befehl **git init** auf.
1. Rufen Sie den **git clone** Befehl zum Klonen des öffentlichen WordPress Repositorys auf und erstellen Sie Ihre eigene Kopie davon im `/tmp/WordPress` Zielordner:
```
git clone https://github.com/WordPress/WordPress.git /tmp/WordPress
```
Dadurch erhalten Sie einen sauberen Satz von WordPress Quellcodedateien im `/tmp/WordPress` Ordner.
## Erstellen Sie Skripts, um Ihre Anwendung auszuführen
Erstellen Sie als Nächstes einen Ordner und Skripts im Verzeichnis. CodeDeploy verwendet diese Skripts, um Ihre Anwendungsrevision auf der Amazon EC2 EC2-Zielinstanz einzurichten und bereitzustellen. Sie können zum Erstellen der Skripts jeden beliebigen Texteditor verwenden.
1. Erstellen Sie ein Skriptverzeichnis in Ihrer Kopie des WordPress Quellcodes:
```
mkdir -p /tmp/WordPress/scripts
```
1. Erstellen Sie eine `install_dependencies.sh`-Datei in `/tmp/WordPress/scripts`. Fügen Sie der Datei die folgenden Zeilen hinzu. Dieses `install_dependencies.sh`-Skript installiert Apache, MySQL und PHP. Außerdem wird MySQL-Support für PHP hinzugefügt.
```
#!/bin/bash
sudo amazon-linux-extras install php7.4
sudo yum install -y httpd mariadb-server php
```
1. Erstellen Sie eine `start_server.sh`-Datei in `/tmp/WordPress/scripts`. Fügen Sie der Datei die folgenden Zeilen hinzu. Dieses `start_server.sh`-Skript startet Apache und MySQL.
```
#!/bin/bash
systemctl start mariadb.service
systemctl start httpd.service
systemctl start php-fpm.service
```
1. Erstellen Sie eine `stop_server.sh`-Datei in `/tmp/WordPress/scripts`. Fügen Sie der Datei die folgenden Zeilen hinzu. Dieses `stop_server.sh`-Skript stoppt Apache und MySQL.
```
#!/bin/bash
isExistApp="pgrep httpd"
if [[ -n $isExistApp ]]; then
systemctl stop httpd.service
fi
isExistApp=pgrep mysqld
if [[ -n $isExistApp ]]; then
systemctl stop mariadb.service
fi
isExistApp=pgrep php-fpm
if [[ -n $isExistApp ]]; then
systemctl stop php-fpm.service
fi
```
1. Erstellen Sie eine `create_test_db.sh`-Datei in `/tmp/WordPress/scripts`. Fügen Sie der Datei die folgenden Zeilen hinzu. Dieses `create_test_db.sh` Skript verwendet MySQL, um eine **test** Datenbank zur Verwendung WordPress zu erstellen.
```
#!/bin/bash
mysql -uroot <
Fügen Sie als Nächstes eine Anwendungsspezifikationsdatei (Datei) hinzu, eine AppSpec Datei im [YAML-Format](http://www.yaml.org), die von verwendet wird, um: CodeDeploy
+ Ordnen Sie die Quelldateien in Ihrer Anwendungsrevision ihren Zielen auf der Amazon EC2 EC2-Zielinstanz zu.
+ Geben Sie benutzerdefinierte Berechtigungen für bereitgestellte Dateien an.
+ Geben Sie die Skripts an, die während der Bereitstellung auf der Amazon EC2 EC2-Zielinstanz ausgeführt werden sollen.
Die AppSpec Datei muss benannt `appspec.yml` werden. Sie muss sich im Stammverzeichnis des Anwendungsquellcodes befinden. Das Stammverzeichnis dieses Tutorials ist `/tmp/WordPress`.
Erstellen Sie mit Ihrem Texteditor eine Datei mit dem Namen `appspec.yml`. Fügen Sie der Datei die folgenden Zeilen hinzu:
```
version: 0.0
os: linux
files:
- source: /
destination: /var/www/html/WordPress
hooks:
BeforeInstall:
- location: scripts/install_dependencies.sh
timeout: 300
runas: root
AfterInstall:
- location: scripts/change_permissions.sh
timeout: 300
runas: root
ApplicationStart:
- location: scripts/start_server.sh
- location: scripts/create_test_db.sh
timeout: 300
runas: root
ApplicationStop:
- location: scripts/stop_server.sh
timeout: 300
runas: root
```
CodeDeploy verwendet diese AppSpec Datei, um alle Dateien im Ordner auf dem Entwicklungscomputer in den `/tmp/WordPress` Ordner auf der `/var/www/html/WordPress` Amazon EC2 EC2-Zielinstanz zu kopieren. CodeDeploy Führt während der Bereitstellung die angegebenen Skripts wie `root` im `/var/www/html/WordPress/scripts` Ordner auf der Amazon EC2 EC2-Zielinstanz zu bestimmten Ereignissen während des Bereitstellungszyklus aus, z. B. **BeforeInstall** und**AfterInstall**. Wenn die Ausführung eines dieser Skripts länger als 300 Sekunden (5 Minuten) dauert, wird die Bereitstellung CodeDeploy gestoppt und die Bereitstellung als fehlgeschlagen markiert.
Weitere Informationen zu diesen Einstellungen finden Sie in der [CodeDeploy AppSpec Dateiverweis](reference-appspec-file.md).
**Wichtig**
Die Platzierung und Anzahl von Leerzeichen zwischen den einzelnen Elementen in dieser Datei ist wichtig. Wenn der Abstand falsch ist, wird CodeDeploy ein Fehler ausgelöst, der möglicherweise schwer zu debuggen ist. Weitere Informationen finden Sie unter [AppSpec Abstand zwischen den Dateien](reference-appspec-file.md#reference-appspec-file-spacing).
# Schritt 3: Laden Sie Ihre WordPress Bewerbung auf Amazon S3 hoch
Jetzt bereiten Sie Ihre Quellinhalte vor und laden sie an einen Ort hoch, von dem aus Sie sie bereitstellen CodeDeploy können. Die folgenden Anweisungen zeigen Ihnen, wie Sie einen Amazon S3 S3-Bucket bereitstellen, die Dateien der Anwendungsrevision für den Bucket vorbereiten, die Dateien der Revision bündeln und dann die Revision in den Bucket übertragen.
**Anmerkung**
Obwohl dies in diesem Tutorial nicht behandelt wird, können Sie es verwenden, CodeDeploy um Anwendungen von GitHub Repositorys auf Instances bereitzustellen. Weitere Informationen finden Sie unter [Integrieren CodeDeploy mit GitHub](integrations-partners-github.md).
**Topics**
+ [Bereitstellen eines Amazon S3 S3-Buckets](#tutorials-wordpress-upload-application-create-s3-bucket)
+ [Bereiten Sie die Dateien der Anwendung für den Bucket vor](#tutorials-wordpress-upload-application-prepare-application-files)
+ [Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push](#tutorials-wordpress-upload-application-bundle-and-push-archive)
## Bereitstellen eines Amazon S3 S3-Buckets
Erstellen Sie einen Speichercontainer oder *Bucket* in Amazon S3 — oder verwenden Sie einen vorhandenen Bucket. Stellen Sie sicher, dass Sie die Revision in den Bucket hochladen können und dass Amazon EC2 EC2-Instances, die in Bereitstellungen verwendet werden, die Revision aus dem Bucket herunterladen können.
Sie können die AWS CLI, die Amazon S3-Konsole oder Amazon S3 verwenden, APIs um einen Amazon S3 S3-Bucket zu erstellen. Nachdem Sie den Bucket erstellt haben, stellen Sie sicher, dass Sie Zugriffsberechtigungen für den Bucket und Ihr AWS Konto erteilen.
**Anmerkung**
Bucket-Namen müssen in Amazon S3 für alle AWS Konten eindeutig sein. Falls Sie **amzn-s3-demo-bucket** nicht verwenden können: Versuchen Sie es mit einem anderen Bucket-Namen wie **amzn-s3-demo-bucket**, gefolgt von einem Bindestrich und Ihren Initialen oder einem anderen eindeutigen Bezeichner. Anschließend müssen Sie überall im Tutorial **amzn-s3-demo-bucket** durch Ihren Bucket-Namen ersetzen.
Der Amazon S3 S3-Bucket muss in derselben AWS Region erstellt werden, in der Ihre Amazon EC2 EC2-Ziel-Instances gestartet werden. Wenn Sie den Bucket beispielsweise in der Region USA Ost (Nord-Virginia) erstellen, müssen Ihre Amazon EC2 EC2-Ziel-Instances in der Region USA Ost (Nord-Virginia) gestartet werden.
**Topics**
+ [So erstellen Sie einen Amazon S3 S3-Bucket (CLI)](#tutorials-wordpress-upload-application-create-s3-bucket-cli)
+ [So erstellen Sie einen Amazon S3 S3-Bucket (Konsole)](#tutorials-wordpress-upload-application-create-s3-bucket-console)
+ [Erteilen Sie Berechtigungen für den Amazon S3 S3-Bucket und das Amazon AWS S3-Konto](#tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions)
### So erstellen Sie einen Amazon S3 S3-Bucket (CLI)
Rufen Sie den **mb** Befehl auf, um einen Amazon S3 S3-Bucket mit dem Namen zu erstellen**amzn-s3-demo-bucket**:
```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```
### So erstellen Sie einen Amazon S3 S3-Bucket (Konsole)
1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Wählen Sie in der Amazon S3 S3-Konsole **Create Bucket** aus.
1. Geben Sie im Feld **Bucket name (Bucket-Name)** einen Namen für den Bucket ein.
1. Wählen Sie aus der Liste **Region** die Zielregion aus, und klicken Sie auf **Create (Erstellen)**.
### Erteilen Sie Berechtigungen für den Amazon S3 S3-Bucket und das Amazon AWS S3-Konto
Sie müssen über Berechtigungen zum Hochladen in den Amazon S3 S3-Bucket verfügen. Sie können diese Berechtigungen über eine Amazon S3 S3-Bucket-Richtlinie angeben. In der folgenden Amazon S3 S3-Bucket-Richtlinie ermöglicht die Verwendung des Platzhalterzeichens (\$1) dem AWS Konto `111122223333` beispielsweise das Hochladen von Dateien in ein beliebiges Verzeichnis im Amazon S3 S3-Bucket mit dem Namen`amzn-s3-demo-bucket`:
```
{
"Statement": [
{
"Action": [
"s3:PutObject"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"111122223333"
]
}
}
]
}
```
Informationen zur Anzeige Ihrer AWS Konto-ID [finden Sie unter Ihre AWS Konto-ID finden](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId).
Jetzt ist ein guter Zeitpunkt, um zu überprüfen, ob der Amazon S3 S3-Bucket Download-Anfragen von jeder teilnehmenden Amazon EC2 EC2-Instance zulässt. Sie können dies über eine Amazon S3 S3-Bucket-Richtlinie angeben. In der folgenden Amazon S3 S3-Bucket-Richtlinie ermöglicht die Verwendung des Platzhalterzeichens (\$1) beispielsweise jeder Amazon EC2 EC2-Instance mit einem angehängten IAM-Instance-Profil, das den ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` enthält, Dateien aus einem beliebigen Verzeichnis im Amazon S3 S3-Bucket mit dem Namen herunterzuladen: `amzn-s3-demo-bucket`
```
{
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"arn:aws:iam::444455556666:role/CodeDeployDemo"
]
}
}
]
}
```
Informationen zum Generieren und Anhängen einer Amazon S3 S3-Bucket-Richtlinie finden Sie unter [Beispiele für Bucket-Richtlinien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).
Informationen zum Erstellen und Anhängen einer IAM-Richtlinie finden Sie unter [Arbeiten mit Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console).
## Bereiten Sie die Dateien der Anwendung für den Bucket vor
Stellen Sie sicher, dass die WordPress Anwendungsdateien, die AppSpec Datei und die Skripts auf Ihrem Entwicklungscomputer ähnlich wie folgt organisiert sind:
```
/tmp/
|--WordPress/
|-- appspec.yml
|-- scripts/
| |-- change_permissions.sh
| |-- create_test_db.sh
| |-- install_dependencies.sh
| |-- start_server.sh
| |-- stop_server.sh
|-- wp-admin/
| |-- (various files...)
|-- wp-content/
| |-- (various files...)
|-- wp-includes/
| |-- (various files...)
|-- index.php
|-- license.txt
|-- readme.html
|-- (various files ending with .php...)
```
## Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push
Bündeln Sie die WordPress Anwendungsdateien und die AppSpec Datei in einer Archivdatei (bekannt als *Anwendungsrevision*).
**Anmerkung**
Möglicherweise werden Ihnen für die Speicherung von Objekten in einem Bucket und die Übertragung von Anwendungsrevisionen in einen oder aus einem Bucket Gebühren berechnet. Weitere Informationen finden Sie unter [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
1. Wechseln Sie auf dem Entwicklungscomputer in den Ordner, in dem die Dateien abgelegt sind:
```
cd /tmp/WordPress
```
**Anmerkung**
Wenn Sie nicht in diesen Ordner wechseln, startet die Dateibündelung im jeweils aktuellen Ordner. Beispiel: Wenn der aktuelle Ordner `/tmp` statt `/tmp/WordPress` ist, beginnt der Bündelvorgang mit den Dateien und Unterordnern im Ordner `tmp`, in dem u. U. mehr enthalten ist als bloß die `WordPress`-Unterordner.
1. Rufen Sie den Befehl **create-application** auf, um eine neue Anwendung namens **WordPress\$1App** zu registrieren:
```
aws deploy create-application --application-name WordPress_App
```
1. Rufen Sie den CodeDeploy [Push-Befehl](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) auf, um die Dateien zu bündeln, die Revisionen auf Amazon S3 hochzuladen und Informationen CodeDeploy über die hochgeladene Version zu registrieren — alles in einer Aktion.
```
aws deploy push \
--application-name WordPress_App \
--s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
--ignore-hidden-files
```
Dieser Befehl bündelt die Dateien aus dem aktuellen Verzeichnis (mit Ausnahme aller versteckten Dateien) in einer einzigen Archivdatei mit dem Namen**WordPressApp.zip**, lädt die Revision in den **amzn-s3-demo-bucket** Bucket hoch und registriert Informationen CodeDeploy über die hochgeladene Revision.
# Schritt 4: Stellen Sie Ihre WordPress Anwendung bereit
Jetzt stellen Sie die Version der WordPress Beispielanwendung bereit, die Sie auf Amazon S3 hochgeladen haben. Sie können die AWS CLI oder die CodeDeploy Konsole verwenden, um die Version bereitzustellen und den Fortschritt der Bereitstellung zu überwachen. Im Anschluss an die Bereitstellung der Anwendungsrevision überprüfen Sie die Ergebnisse.
**Topics**
+ [Stellen Sie die Revision Ihrer Anwendung bereit mit CodeDeploy](#tutorials-wordpress-deploy-application-create-deployment)
+ [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](#tutorials-wordpress-deploy-application-monitor)
+ [Überprüfen Sie Ihre Bereitstellung](#tutorials-wordpress-deploy-application-verify-deployment)
## Stellen Sie die Revision Ihrer Anwendung bereit mit CodeDeploy
Verwenden Sie die Konsole AWS CLI oder die Konsole, um Ihre Anwendungsrevision bereitzustellen.
**Topics**
+ [Mit der CLI stellen Sie die Anwendungsrevision wie folgt bereit:](#tutorials-wordpress-deploy-application-create-deployment-cli)
+ [Mit der Konsole stellen Sie die Anwendungsrevision wie folgt bereit:](#tutorials-wordpress-deploy-application-create-deployment-console)
### Mit der CLI stellen Sie die Anwendungsrevision wie folgt bereit:
1. Für die Bereitstellung ist eine Bereitstellungsgruppe erforderlich. Bevor Sie die Bereitstellungsgruppe erstellen können, benötigen Sie allerdings den ARN einer Service-Rolle. Eine Servicerolle ist eine IAM-Rolle, die einem Dienst die Erlaubnis erteilt, in Ihrem Namen zu handeln. In diesem Fall erteilt die Service-Rolle die CodeDeploy Erlaubnis, auf Ihre Amazon EC2 EC2-Instances zuzugreifen, um deren Amazon EC2 EC2-Instance-Tags zu erweitern (zu lesen).
Sie sollten bereits anhand der Anweisungen unter [Erstellen Sie eine Servicerolle (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli) eine Service-Rolle erstellt haben. Wie Sie den ARN der Service-Rolle abrufen können, erfahren Sie unter [Rufen Sie die Servicerolle ARN (CLI) ab](getting-started-create-service-role.md#getting-started-get-service-role-cli).
1. Nachdem Sie die Dienstrolle ARN haben, rufen Sie den **create-deployment-group** Befehl auf, um eine Bereitstellungsgruppe mit dem Namen zu erstellen**WordPress\$1DepGroup**, die der genannten Anwendung zugeordnet ist. Verwenden Sie dazu das Amazon EC2-Tag mit dem Namen **CodeDeployDemo** und die Bereitstellungskonfiguration mit dem Namen**CodeDeployDefault.OneAtATime**: **WordPress\$1App**
```
aws deploy create-deployment-group \
--application-name WordPress_App \
--deployment-group-name WordPress_DepGroup \
--deployment-config-name CodeDeployDefault.OneAtATime \
--ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE \
--service-role-arn serviceRoleARN
```
**Anmerkung**
Der [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)Befehl bietet Unterstützung für die Erstellung von Triggern, die zum Senden von Amazon SNS SNS-Benachrichtigungen an Themenabonnenten über bestimmte Ereignisse in Bereitstellungen und Instances führen. Der Befehl unterstützt auch Optionen für das automatische Rollback von Bereitstellungen und die Einrichtung von Alarmen, um Bereitstellungen zu beenden, wenn die Überwachungsschwellenwerte in CloudWatch Amazon-Alarmen erreicht werden. Befehle für diese Aktionen sind in diesem Tutorial nicht enthalten.
1. Bevor Sie eine Bereitstellung erstellen, muss der CodeDeploy Agent auf den Instances in Ihrer Bereitstellungsgruppe installiert sein. Sie können den Agenten über die Befehlszeile mit folgendem Befehl mit AWS Systems Manager installieren:
```
aws ssm create-association \
--name AWS-ConfigureAWSPackage \
--targets Key=tag:Name,Values=CodeDeployDemo \
--parameters action=Install,name=AWSCodeDeployAgent \
--schedule-expression "cron(0 2 ? * SUN *)"
```
Dieser Befehl erstellt eine Verknüpfung in Systems Manager State Manager, die den CodeDeploy Agenten installiert und dann versucht, ihn jeden Sonntagmorgen um 2:00 Uhr zu aktualisieren. Weitere Informationen zum CodeDeploy Agenten finden Sie unter [Mit dem CodeDeploy Agenten arbeiten](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Weitere Informationen zu Systems Manager finden Sie unter [Was ist AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).
1. Rufen Sie nun den Befehl **create-deployment** zum Erstellen einer Bereitstellung auf, die der Anwendung **WordPress\$1App**, der Bereitstellungskonfiguration **CodeDeployDefault.OneAtATime** und der Bereitstellungsgruppe **WordPress\$1DepGroup** zugeordnet ist, unter Verwendung der Anwendungrevision **WordPressApp.zip** im Bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
### Mit der Konsole stellen Sie die Anwendungsrevision wie folgt bereit:
1. Bevor Sie die CodeDeploy Konsole zum Bereitstellen Ihrer Anwendungsrevision verwenden, benötigen Sie einen ARN für die Servicerolle. Eine Servicerolle ist eine IAM-Rolle, die einem Dienst die Erlaubnis erteilt, in Ihrem Namen zu handeln. In diesem Fall erteilt die Service-Rolle die CodeDeploy Erlaubnis, auf Ihre Amazon EC2 EC2-Instances zuzugreifen, um deren Amazon EC2 EC2-Instance-Tags zu erweitern (zu lesen).
Sie sollten bereits anhand der Anweisungen unter [Erstellen Sie eine Servicerolle (Konsole)](getting-started-create-service-role.md#getting-started-create-service-role-console) eine Service-Rolle erstellt haben. Wie Sie den ARN der Service-Rolle abrufen können, erfahren Sie unter [Rufen Sie die Servicerolle ARN ab (Konsole)](getting-started-create-service-role.md#getting-started-get-service-role-console).
1. Nachdem Sie den ARN haben, verwenden Sie die CodeDeploy Konsole, um die Revision Ihrer Anwendung bereitzustellen:
Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)
1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.
1. Wählen Sie in der Liste der Anwendungen die Option **WordPress\$1App** aus.
1. Wählen Sie auf der Registerkarte **Deployment groups (Bereitstellungsgruppen)**, die Option **Create deployment group (Bereitstellungsgruppe erstellen)** aus.
1. Geben Sie unter **Deployment group name (Name der Bereitstellungsgruppe)** **WordPress\$1DepGroup** ein.
1. Wählen Sie unter **Deployment type** die Option **In-place deployment**.
1. Wählen Sie unter **Umgebungskonfiguration** **Amazon EC2 EC2-Instances** aus.
1. Behalten Sie **unter Agentenkonfiguration mit AWS Systems Manager** die Standardeinstellungen bei.
1. Geben Sie für **Key (Schlüssel)** **Name** ein.
1. Geben Sie unter **Value (Wert)** **CodeDeployDemo** ein.
**Anmerkung**
Nach der Eingabe sollte unter **Passende Instances** eine **1** erscheinen**CodeDeployDemo**, um zu bestätigen, dass eine passende Amazon EC2 EC2-Instance CodeDeploy gefunden wurde.
1. **Wählen Sie in der **Bereitstellungskonfiguration** die OptionCodeDeployDefault. OneAtATime**.
1. Wählen Sie in der Dropdownliste **Service role ARN (Servicerolle-ARN)** den ARN der Servicerolle aus und klicken Sie dann auf **Create deployment group (Bereitstellungsgruppe erstellen)**.
1. Wählen Sie **Create deployment**.
1. Wählen Sie unter **Deployment group (Bereitstellungsgruppe)** die Option **WordPress\$1DepGroup** aus.
1. Wählen Sie neben **Repository-Typ** die Option **Meine Anwendung ist in Amazon S3 gespeichert** aus. Geben Sie **unter Revisionsort** den Speicherort der Version der WordPress Beispielanwendung ein, die Sie zuvor auf Amazon S3 hochgeladen haben. Ermitteln Sie den Speicherort wie folgt:
1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Wählen Sie in der Liste der Buckets **amzn-s3-demo-bucket** aus (oder den Namen des Buckets, in den Sie Ihre Anwendungsrevision hochgeladen haben).
1. **Wählen Sie in der Liste der Objekte die Datei .zip aus. WordPressApp**
1. Kopieren Sie auf der Registerkarte **Overview** (Übersicht) den Wert des Feldes **Link** (Link) in die Zwischenablage.
Er kann wie folgt aussehen:
**https://s3.amazonaws.com/amzn-s3-demo-bucket/WordPressApp.zip**
1. Kehren Sie zur CodeDeploy Konsole zurück, und fügen Sie in **Revisionsort** den Feldwert **Link** ein.
1. Falls in der Liste **File type** (Dateityp) die Meldung angezeigt wird, dass der Dateityp nicht erkannt wurde, wählen Sie **.zip** aus der Liste der Dateitypen aus.
1. (Optional) Geben Sie einen Kommentar in dem Feld **Deployment description** ein.
1. **Erweitern Sie **Deployment Group Overrides** und wählen Sie CodeDeployDefault unter **Deployment-Konfiguration** die Option aus. OneAtATime**.
1. Klicken Sie auf **Start deployment (Bereitstellung starten)**. Auf der Seite **Deployments** werden nun Informationen zu der neu erstellten Bereitstellung angezeigt.
## Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler
Verwenden Sie die Konsole AWS CLI oder die Konsole, um Ihre Bereitstellung zu überwachen und Fehler zu beheben.
**Topics**
+ [Über die CLI können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:](#tutorials-wordpress-deploy-application-monitor-cli)
+ [Über die Konsole können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:](#tutorials-wordpress-deploy-application-monitor-console)
### Über die CLI können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:
1. Fordern Sie die ID der Bereitstellung an, indem Sie den Befehl **list-deployments** für die Anwendung **WordPress\$1App** und die Bereitstellungsgruppe **WordPress\$1DepGroup** aufrufen:
```
aws deploy list-deployments --application-name WordPress_App --deployment-group-name WordPress_DepGroup --query 'deployments' --output text
```
1. Rufen Sie den Befehl **get-deployment** mit der Bereitstellungs-ID auf:
```
aws deploy get-deployment --deployment-id deploymentID --query 'deploymentInfo.status' --output text
```
1. Der Befehl gibt den allgemeinen Status der Bereitstellung zurück. Wurde die Bereitstellung erfolgreich abgeschlossen, lautet der Wert `Succeeded`.
Wird als allgemeiner Status `Failed` zurückgegeben, können Sie zur Problembehebung Befehle wie [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) und [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) aufrufen. Weitere Optionen für die Problembehebung finden Sie unter [Analysieren von Protokolldateien zur Untersuchung von Bereitstellungsfehlern auf Instances](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
### Über die Konsole können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:
Auf der Seite **Bereitstellungen** in der CodeDeploy Konsole können Sie den Status Ihrer Bereitstellung in der Spalte **Status** überwachen.
Weitere Informationen zu Ihrer Bereitstellung können Sie wie nachfolgend beschrieben abrufen. Dies ist insbesondere nützlich, falls in der Spalte **Status** ein anderer Wert als **Succeeded** steht:
1. Wählen Sie in der Tabelle **Deployments (Bereitstellungen)** den Namen der Bereitstellung aus. Falls eine Bereitstellung fehlschlägt, wird eine Meldung mit dem Grund des Fehlschlagens angezeigt.
1. Unter **Instance activity (Instance-Aktivität)** werden weitere Informationen zur Bereitstellung angezeigt. Wenn eine Bereitstellung fehlschlägt, können Sie möglicherweise feststellen, auf welchen Amazon EC2 EC2-Instances und in welchem Schritt die Bereitstellung fehlgeschlagen ist.
1. Für eine weitergehende Problembehebung können Sie wie unter [Instanzdetails anzeigen mit CodeDeploy](instances-view-details.md) beschrieben vorgehen. Sie können auch die Bereitstellungsprotokolldateien auf einer Amazon EC2 EC2-Instance analysieren. Weitere Informationen finden Sie unter [Analysieren von Protokolldateien zur Untersuchung von Bereitstellungsfehlern auf Instances](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
## Überprüfen Sie Ihre Bereitstellung
Stellen Sie nach erfolgreicher Bereitstellung sicher, dass Ihre WordPress Installation funktioniert. Verwenden Sie die öffentliche DNS-Adresse der Amazon EC2 EC2-Instance, gefolgt von`/WordPress`, um Ihre Site in einem Webbrowser anzuzeigen. (Um den öffentlichen DNS-Wert abzurufen, wählen Sie in der Amazon EC2 EC2-Konsole die Amazon EC2 EC2-Instance aus und suchen Sie auf der Registerkarte **Beschreibung** nach dem Wert von **Public DNS**.)
Wenn die öffentliche DNS-Adresse Ihrer Amazon EC2 EC2-Instance beispielsweise lautet**ec2-01-234-567-890.compute-1.amazonaws.com**, würden Sie die folgende URL verwenden:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress
```
Wenn Sie die Website in Ihrem Browser aufrufen, sollten Sie eine WordPress Willkommensseite sehen, die der folgenden ähnelt:
![\[WordPress Willkommensseite\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/WordPress-Welcome-Page-013118.png)
Wenn Ihrer Amazon EC2 EC2-Instance keine Regel für eingehenden HTTP-Datenverkehr zur Sicherheitsgruppe hinzugefügt wurde, wird die WordPress Willkommensseite nicht angezeigt. Wenn Sie eine Meldung sehen, die besagt, dass der Remote-Server nicht reagiert, stellen Sie sicher, dass die Sicherheitsgruppe für Ihre Amazon EC2 EC2-Instance die eingehende Regel hat. Weitere Informationen finden Sie unter [Fügen Sie eine Regel für eingehenden Datenverkehr hinzu, die HTTP-Verkehr zu Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance zulässtFügen Sie eine Regel für eingehenden Datenverkehr hinzu, die HTTP-Verkehr zu Ihrer Windows Server Amazon EC2 EC2-Instance zulässt](tutorials-wordpress-launch-instance.md#tutorials-wordpress-launch-instance-add-inbound-rule).
# Schritt 5: Aktualisieren Sie Ihre WordPress Anwendung und stellen Sie sie erneut bereit
Nachdem Sie Ihre Anwendungsversion erfolgreich bereitgestellt haben, aktualisieren Sie den WordPress Code auf dem Entwicklungscomputer und verwenden Sie ihn dann, CodeDeploy um die Site erneut bereitzustellen. Danach sollten Sie die Codeänderungen auf der Amazon EC2 EC2-Instance sehen.
**Topics**
+ [Richten Sie die Site ein WordPress](#tutorials-wordpress-update-and-redeploy-application-configure-and-install)
+ [Ändern Sie die Site](#tutorials-wordpress-update-and-redeploy-application-modify-code)
+ [Stellen Sie die Site erneut bereit](#tutorials-wordpress-update-and-redeploy-application-deploy-updates)
## Richten Sie die Site ein WordPress
Um die Auswirkungen der Codeänderung zu sehen, beenden Sie die Einrichtung der WordPress Site, sodass Sie über eine voll funktionsfähige Installation verfügen.
1. Geben Sie die URL Ihrer Site in Ihren Webbrowser ein. Die URL ist die öffentliche DNS-Adresse der Amazon EC2 EC2-Instance plus eine `/WordPress` Erweiterung. Für diese WordPress Beispiel-Site (und die öffentliche DNS-Adresse der Amazon EC2 EC2-Instance) lautet die URL. **http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress**
1. Wenn Sie die Site noch nicht eingerichtet haben, wird die WordPress Standard-Willkommensseite angezeigt. Wählen Sie **Let's go\$1** (Los geht's\$1).
1. Geben Sie auf der Seite Datenbankkonfiguration die folgenden Werte ein, um die Standard-MySQL-Datenbank zu nutzen:
+ **Datenbankname**: **test**
+ **Benutzername**: **root**
+ **Passwort**: Lassen Sie das Feld leer.
+ **Datenbank-Host**: **localhost**
+ **Tabellenpräfix**: **wp\$1**
Wählen Sie **Submit**, um die Datenbank einzurichten.
1. Fahren Sie mit der Einrichtung der Website fort. Geben Sie auf der **Willkommensseite** alle gewünschten Werte ein und wählen Sie **Installieren WordPress**. Wenn die Installation abgeschlossen ist, können Sie sich bei Ihrem Dashboard anmelden.
**Wichtig**
Während der Bereitstellung der WordPress Anwendung hat das **change\$1permissions.sh** Skript die Berechtigungen für den `/tmp/WordPress` Ordner aktualisiert, sodass jeder in den Ordner schreiben kann. Nun ist eine gute Gelegenheit, den folgenden Befehl auszuführen, um die Berechtigungen so einzuschränken, dass nur Sie als Eigentümer darin schreiben können:
```
chmod -R 755 /var/www/html/WordPress
```
## Ändern Sie die Site
Um die WordPress Site zu ändern, wechseln Sie in den Ordner der Anwendung auf Ihrem Entwicklungscomputer:
```
cd /tmp/WordPress
```
Verwenden Sie zur Modifizierung einiger der Farben der Website in der Datei `wp-content/themes/twentyfifteen/style.css` einen Texteditor oder **sed**, um `#fff` in `#768331` zu ändern.
Bei Linux oder anderen Systemen mit GNU **sed** verwenden Sie:
```
sed -i 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
Bei macOS, Unix oder anderen Systemen mit BSD **sed** verwenden Sie:
```
sed -i '' 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
## Stellen Sie die Site erneut bereit
Nachdem Sie den Code der Site geändert haben, verwenden Sie Amazon S3 und CodeDeploy stellen Sie die Site erneut bereit.
Bündeln Sie die Änderungen und laden Sie sie auf Amazon S3 hoch, wie unter beschrieben[Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push](tutorials-wordpress-upload-application.md#tutorials-wordpress-upload-application-bundle-and-push-archive). (Wenn Sie diese Anweisungen befolgen, müssen Sie keine Anwendung erstellen.) Geben Sie der neuen Revision denselben Schlüssel wie zuvor (**WordPressApp.zip**). Laden Sie es in denselben Amazon S3 S3-Bucket hoch, den Sie zuvor erstellt haben (z. B.**amzn-s3-demo-bucket**).
Verwenden Sie die AWS CLI, die CodeDeploy Konsole oder die, CodeDeploy APIs um die Site erneut bereitzustellen.
**Topics**
+ [Erneutes Bereitstellen der Website (CLI)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli)
+ [Erneutes Bereitstellen der Website (Konsole)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-console)
### Erneutes Bereitstellen der Website (CLI)
Rufen Sie den Befehl **create-deployment** auf, um eine auf der neu hochgeladenen Revision basierende Bereitstellung zu erstellen. Verwenden Sie die Anwendung mit dem Namen **WordPress\$1App**, die Bereitstellungskonfiguration mit dem Namen **CodeDeployDefault.OneAtATime**, die Bereitstellungsgruppe mit dem Namen **WordPress\$1DepGroup** und die Revision mit dem Namen **WordPressApp.zip** im Bucket mit dem Namen **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
Sie können den Status der Bereitstellung wie in [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor) beschrieben überprüfen.
Nachdem CodeDeploy Sie die Site erneut bereitgestellt haben, rufen Sie die Site erneut in Ihrem Webbrowser auf, um zu überprüfen, ob die Farben geändert wurden. (Sie müssen möglicherweise Ihren Browser aktualisieren.) Wenn die Farben geändert wurden, herzlichen Glückwunsch\$1 Sie haben Ihre Website erfolgreich geändert und erneut bereitgestellt\$1
### Erneutes Bereitstellen der Website (Konsole)
1. [Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter https://console.aws.amazon.com /codedeploy.](https://console.aws.amazon.com/codedeploy)
**Anmerkung**
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)
1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.
1. Wählen Sie in der Liste der Anwendungen die Option **WordPress\$1App** aus.
1. Wählen Sie auf der Registerkarte **Deployment groups (Bereitstellungsgruppen)** die Option **WordPress\$1DepGroup**.
1. Wählen Sie **Create deployment**.
1. Auf der Seite **Create deployment**:
1. Wählen Sie unter **Deployment group (Bereitstellungsgruppe)** die Option **WordPress\$1DepGroup** aus.
1. Wählen Sie im Bereich **Repository-Typ** die Option **Meine Anwendung ist in Amazon S3 gespeichert** aus und kopieren Sie dann den Amazon S3 S3-Link Ihrer Revision in das Feld **Speicherort der Revision**. Ermitteln des Link-Wertes:
1. In einer separaten Browser-Registerkarte:
Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
Navigieren Sie zu **amzn-s3-demo-bucket**, öffnen Sie es und wählen Sie dann Ihre Revision aus. **WordPressApp.zip**
1. Wenn der **Eigenschaftenbereich** in der Amazon S3 S3-Konsole nicht sichtbar ist, wählen Sie die Schaltfläche **Eigenschaften**.
1. Kopieren Sie im **Eigenschaftenbereich** den Wert des **Link-Felds** in das Feld **Revisionsort** in der CodeDeploy Konsole.
1. Wenn eine Meldung angezeigt wird, die besagt, dass der Dateityp nicht erkannt werden konnte, wählen Sie **.zip**.
1. Lassen Sie das Feld **Deployment description** leer.
1. **Erweitern Sie **Deployment Group Overrides** und wählen Sie CodeDeployDefault unter **Deployment-Konfiguration** die Option aus. OneAtATime**.
1. Klicken Sie auf **Start deployment (Bereitstellung starten)**. Auf der Seite **Deployments** werden nun Informationen zu der neu erstellten Bereitstellung angezeigt.
1. Sie können den Status der Bereitstellung wie in [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor) beschrieben überprüfen.
Nachdem CodeDeploy Sie die Site erneut bereitgestellt haben, rufen Sie die Site erneut in Ihrem Webbrowser auf, um zu überprüfen, ob die Farben geändert wurden. (Sie müssen möglicherweise Ihren Browser aktualisieren.) Wenn die Farben geändert wurden, herzlichen Glückwunsch\$1 Sie haben Ihre Website erfolgreich geändert und erneut bereitgestellt\$1
# Schritt 6: Bereinigen Sie Ihre WordPress Anwendung und die zugehörigen Ressourcen
Sie haben den WordPress Code jetzt erfolgreich aktualisiert und die Site erneut bereitgestellt. Um laufende Gebühren für die Ressourcen, die Sie für dieses Tutorial erstellt haben, zu vermeiden, sollten Sie Folgendes löschen:
+ Alle CloudFormation Stacks (oder beenden Sie alle Amazon EC2 EC2-Instances, falls Sie sie außerhalb von CloudFormation erstellt haben).
+ Alle Amazon S3 S3-Buckets.
+ Die Anwendung `WordPress_App` in CodeDeploy.
+ Die AWS Systems Manager State Manager-Zuordnung für den CodeDeploy Agenten.
Sie können Amazon S3 AWS CLI CloudFormation, Amazon EC2 und die CodeDeploy Konsolen oder die verwenden, AWS APIs um die Bereinigung durchzuführen.
**Topics**
+ [So bereinigen Sie die Ressourcen (CLI):](#tutorials-wordpress-clean-up-cli)
+ [So bereinigen Sie Ressourcen (Konsole):](#tutorials-wordpress-clean-up-console)
+ [Als nächstes](#tutorials-wordpress-clean-up-whats-next)
## So bereinigen Sie die Ressourcen (CLI):
1. Wenn Sie unsere CloudFormation Vorlage für dieses Tutorial verwendet haben, rufen Sie den **delete-stack** Befehl für den genannten Stack auf. **CodeDeployDemoStack** Dadurch werden alle zugehörigen Amazon EC2 EC2-Instances beendet und alle zugehörigen IAM-Rollen gelöscht, die der Stack erstellt hat:
```
aws cloudformation delete-stack --stack-name CodeDeployDemoStack
```
1. Um den Amazon S3 S3-Bucket zu löschen, rufen Sie den **rm** Befehl mit dem **--recursive** Schalter für den genannten Bucket auf**amzn-s3-demo-bucket**. So löschen Sie den Bucket und alle Objekte im Bucket:
```
aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
```
1. Um die Anwendung `WordPress_App` zu löschen, rufen Sie den Befehl **delete-application** auf. Damit werden auch alle zugehörigen Bereitstellungsgruppen-Datensätze und die Bereitstellungsdatensätze für die Anwendung gelöscht:
```
aws deploy delete-application --application-name WordPress_App
```
1. Rufen Sie den **delete-association** Befehl auf, um die Systems Manager State Manager-Zuordnung zu löschen.
```
aws ssm delete-association --assocation-id association-id
```
Sie können den abrufen, *association-id* indem Sie den **describe-association** Befehl aufrufen.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
Wenn Sie den CloudFormation Stack für dieses Tutorial nicht verwendet haben, rufen Sie den **terminate-instances** Befehl auf, um alle Amazon EC2 EC2-Instances zu beenden, die Sie manuell erstellt haben. Geben Sie die ID der Amazon EC2 EC2-Instance an, die beendet werden soll:
```
aws ec2 terminate-instances --instance-ids instanceId
```
## So bereinigen Sie Ressourcen (Konsole):
Wenn Sie unsere CloudFormation Vorlage für dieses Tutorial verwendet haben, löschen Sie den zugehörigen CloudFormation Stack.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Geben Sie im Feld **Filter** den CloudFormation Stacknamen ein, den Sie zuvor erstellt haben (z. B.**CodeDeployDemoStack**).
1. Aktivieren Sie das Kontrollkästchen neben dem Stack-Namen. Wählen Sie im Menü **Actions** die Option **Delete Stack**.
CloudFormation löscht den Stack, beendet alle zugehörigen Amazon EC2 EC2-Instances und löscht alle zugehörigen IAM-Rollen.
So beenden Sie Amazon EC2 EC2-Instances, die Sie außerhalb eines CloudFormation Stacks erstellt haben:
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie in der Liste **INSTANCES** die Option **Instances**.
1. Geben Sie in das Suchfeld den Namen der Amazon EC2 EC2-Instance ein, die Sie beenden möchten (z. B.**CodeDeployDemo**), und drücken Sie dann die Eingabetaste.
1. Wählen Sie den Namen der Amazon EC2 EC2-Instanz.
1. Zeigen Sie im Menü **Actions** auf **Instance State**, und wählen Sie dann **Terminate**. Wählen Sie bei Aufforderung **Yes, Terminate**.
Wiederholen Sie diese Schritte für jede Instance.
Um den Amazon S3 S3-Bucket zu löschen:
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Suchen Sie in der Liste der Buckets nach dem Namen des Amazon S3 S3-Buckets, den Sie zuvor erstellt haben, und wählen Sie ihn aus (z. B.**amzn-s3-demo-bucket**).
1. Bevor Sie einen Bucket löschen können, müssen Sie zunächst seinen Inhalt löschen. Wählen Sie alle Dateien im Bucket aus, z. B. **WordPressApp.zip**. Wählen Sie im Menü **Actions** die Option **Delete**. Wenn Sie zum Bestätigen des Löschvorgangs aufgefordert werden, wählen Sie **OK**.
1. Nachdem der Bucket leer ist, kann er gelöscht werden. Wählen Sie in der Bucket-Liste die Zeile mit dem Bucket aus (aber nicht den Namen des Buckets). Wählen Sie **Delete bucket** und bei der Aufforderung zum Bestätigen **OK**.
Um die `WordPress_App` Anwendung zu löschen von CodeDeploy:
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)
1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.
1. Wählen Sie in der Liste der Anwendungen **WordPress\$1App** aus.
1. Wählen Sie auf der Seite **Application details** die Option **Delete application**.
1. Geben Sie bei Aufforderung den Namen der Anwendung ein, um das Löschen zu bestätigen, und klicken Sie auf **Delete (Löschen)**.
So löschen Sie die Systems Manager State Manager-Zuordnung:
1. Öffnen Sie die AWS Systems Manager Konsole unter https://console.aws.amazon.com /systems-manager.
1. Wählen Sie im Navigationsbereich **Statusmanager** aus.
1. Wählen Sie die Verknüpfung aus, die Sie erstellt haben, und wählen Sie **Delete (Löschen)** aus.
## Als nächstes
Glückwunsch, dass Sie hier angekommen sind\$1 Sie haben erfolgreich eine CodeDeploy-Bereitstellung abgeschlossen, dann den Code Ihrer Site aktualisiert und ihn erneut bereitgestellt.