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.
# Arbeiten mit Instanzen für CodeDeploy
CodeDeploy unterstützt Bereitstellungen auf Instances, auf denen Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) und Windows Server ausgeführt werden.
Sie können CodeDeploy die Bereitstellung sowohl für Amazon EC2 EC2-Instances als auch für lokale Instances verwenden. Eine lokale Instance ist jedes physische Gerät, bei dem es sich nicht um eine Amazon EC2 EC2-Instance handelt, auf dem der CodeDeploy Agent ausgeführt und eine Verbindung zu öffentlichen AWS Service-Endpunkten hergestellt werden kann. Sie können damit eine Anwendung gleichzeitig CodeDeploy auf Amazon EC2 EC2-Instances in der Cloud und auf dem Desktop PCs in Ihrem Büro oder auf Servern in Ihrem eigenen Rechenzentrum bereitstellen.
## Vergleich von Amazon EC2 EC2-Instances mit lokalen Instances
In der folgenden Tabelle werden Amazon EC2 EC2-Instances und lokale Instances verglichen:
| **Betreff** | **Amazon EC2-Instances** | **Lokale Instances** |
| --- | --- | --- |
| Erfordert, dass Sie eine Version des CodeDeploy Agenten installieren und ausführen, die mit dem Betriebssystem kompatibel ist, das auf der Instanz ausgeführt wird. | Ja | Ja |
| Erfordern, dass die jeweilige Instance eine Verbindung zum CodeDeploy-Service herstellen kann. | Ja | Ja |
| Erfordert, dass ein IAM-Instanzprofil an die Instanz angehängt wird. Das IAM-Instanzprofil muss über Berechtigungen verfügen, um an Bereitstellungen teilnehmen CodeDeploy zu können. Weitere Informationen finden Sie unter [Schritt 4: Erstellen Sie ein IAM-Instance-Profil für Ihre Amazon EC2 EC2-Instances](getting-started-create-iam-instance-profile.md). | Ja | Nein |
| Erfordern einen der folgenden Schritte zur Authentifizierung und Registrierung von Instances: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/instances.html) | Nein | Ja |
| Erfordert, dass Sie jede Instanz bei registrieren, CodeDeploy bevor Sie sie bereitstellen können. | Nein | Ja |
| Erfordert, dass Sie jede Instanz taggen, bevor Sie sie bereitstellen CodeDeploy können. | Ja | Ja |
| Kann im Rahmen von CodeDeploy Bereitstellungen an Amazon EC2 Auto Scaling- und Elastic Load Balancing Balancing-Szenarien teilnehmen. | Ja | Nein |
| Kann aus Amazon S3 S3-Buckets und GitHub Repositorys bereitgestellt werden. | Ja | Ja |
| Unterstützen Auslöser für das Senden von SMS oder E-Mail-Benachrichtigungen bei Eintreten bestimmter Ereignisse in Bereitstellungen oder Instances. | Ja | Ja |
| Werden für zugeordnete Bereitstellungen mit Kosten belastet. | Nein | Ja |
## Instanzaufgaben für CodeDeploy
Befolgen Sie die unten angegebenen Anweisungen, um Instances für Bereitstellungen zu starten oder zu konfigurieren:
| | |
| --- |--- |
| Ich möchte eine neue Amazon Linux- oder Windows Server Amazon EC2 EC2-Instance starten. | Informationen zum Starten der Amazon EC2 EC2-Instance mit dem geringsten Aufwand finden Sie unter[Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy (CloudFormation Vorlage)](instances-ec2-create-cloudformation-template.md). Informationen darüber, wie Sie die Amazon EC2 EC2-Instance größtenteils selbst starten, finden Sie unter[Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy (AWS CLI oder Amazon EC2 EC2-Konsole)](instances-ec2-create.md). |
| Ich möchte eine neue Ubuntu Server- oder RHEL Amazon EC2 EC2-Instance starten. | Siehe [Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy (AWS CLI oder Amazon EC2 EC2-Konsole)](instances-ec2-create.md). |
| Ich möchte eine Amazon Linux-, Windows Server-, Ubuntu Server- oder RHEL Amazon EC2 EC2-Instance konfigurieren. | Siehe [Konfigurieren Sie eine Amazon EC2 EC2-Instance, mit der Sie arbeiten können CodeDeploy](instances-ec2-configure.md). |
| Ich möchte eine lokale Windows Server-, Ubuntu Server- oder RHEL-Instance konfigurieren (physische Geräte, die keine Amazon EC2 EC2-Instances sind). | Siehe [Arbeiten mit lokalen Instanzen für CodeDeploy](instances-on-premises.md). |
| Ich CodeDeploy möchte während einer Bereitstellung eine Ersatzflotte von Instances bereitstellen. blue/green | Siehe [Arbeiten mit Bereitstellungen in CodeDeploy](deployments.md). |
Um Amazon EC2-Instances in Amazon EC2 Auto Scaling-Gruppen vorzubereiten, müssen Sie einige zusätzliche Schritte ausführen. Weitere Informationen finden Sie unter [Integration CodeDeploy mit Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
**Topics**
+ [Tagging Instances for Deployments](instances-tagging.md)
+ [Working with Amazon EC2 Instances](instances-ec2.md)
+ [Working with On-Premises Instances](instances-on-premises.md)
+ [View Instance Details](instances-view-details.md)
+ [Instance Health](instances-health.md)
# Tagging von Instanzen für Bereitstellungsgruppen in CodeDeploy
Um Ihre Amazon EC2 EC2-Instances und lokalen Instances zu verwalten, können Sie Tags verwenden, um jeder Ressource Ihre eigenen Metadaten zuzuweisen. Tags ermöglichen Ihnen, Ihre Instances auf unterschiedliche Weise zu kategorisieren (z. B. nach Zweck, Eigentümer oder Umgebung). Dies ist nützlich, wenn Sie viele Instances haben. Sie können eine Instance oder eine Gruppe von Instances schnell auf der Grundlage der Tags identifizieren, die Sie ihnen zugewiesen haben. Jeder Tag (Markierung) besteht aus einem Schlüssel und einem optionalen Wert, beides können Sie bestimmen. Weitere Informationen finden Sie unter [Taggen Ihrer Amazon EC2 EC2-Ressourcen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html).
Um anzugeben, welche Instances in einer CodeDeploy Bereitstellungsgruppe enthalten sind, geben Sie Tags in einer oder mehreren *Tag-Gruppen* an. Instances, die Ihren Tag-Kriterien entsprechen, sind diejenigen, auf denen die letzte Anwendungsversion installiert wird, wenn eine Bereitstellung zu dieser Bereitstellungsgruppe erstellt wird.
**Anmerkung**
Sie können Amazon EC2 Auto Scaling Scaling-Gruppen auch in Bereitstellungsgruppen aufnehmen, sie werden jedoch anhand ihrer Namen und nicht anhand von Tags identifiziert, die auf Instances angewendet werden. Weitere Informationen finden Sie unter [Integration CodeDeploy mit Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
Die Kriterien für die Instances in einer Bereitstellungsgruppe können so einfach wie ein einzelnes Tag in einer einzigen Tag-Gruppe sein. Sie können auch so komplex wie jeweils 10 Tags in maximal drei Tag-Gruppen sein.
Wenn Sie eine einzelne Tag-Gruppe verwenden, ist jede von mindestens einem Tag in der Gruppe identifizierte Instance in der Bereitstellungsgruppe enthalten. Wenn Sie mehrere Tag-Gruppen verwenden, sind nur die Instances, die durch mindestens einen Tag in *jeder* Tag-Gruppe identifiziert werden, enthalten.
Die folgenden Beispiele veranschaulichen, wie Tags und Tag-Gruppen verwendet werden können, um die Instances für eine Bereitstellungsgruppe auszuwählen.
**Topics**
+ [Beispiel 1: Einzelne Tag-Gruppe, einzelnes Tag](#instances-tagging-example-1)
+ [Beispiel 2: Einzelne Tag-Gruppe, mehrere Tags](#instances-tagging-example-2)
+ [Beispiel 3: Mehrere Tag-Gruppen, einzelne Tags](#instances-tagging-example-3)
+ [Beispiel 4: Mehrere Tag-Gruppen, mehrere Tags](#instances-tagging-example-4)
## Beispiel 1: Einzelne Tag-Gruppe, einzelnes Tag
Sie können einen einzelnen tag in einer einzelnen Tag-Gruppe angeben:
**Tag-Gruppe 1**
| Key (Schlüssel) | Value (Wert) |
| --- | --- |
| Name | AppVersion-ABC |
Jede Instance, die mit `Name=AppVersion-ABC` markiert ist, ist Teil der Bereitstellungsgruppe, selbst wenn sie noch weitere Tags hat.
CodeDeploy Ansicht des Konsolen-Setups:
![\[Die CodeDeploy Konsole zeigt eine Tag-Gruppe mit einem Tag.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/TaggingExample1-polaris.png)
JSON-Struktur:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
]
]
},
```
## Beispiel 2: Einzelne Tag-Gruppe, mehrere Tags
Sie können auch mehrere Tags in einer einzigen Tag-Gruppe angeben:
**Tag-Gruppe 1**
| Key (Schlüssel) | Value (Wert) |
| --- | --- |
| Region | Nord |
| Region | Süd |
| Region | Ost |
Eine Instance, die mit einem dieser drei Tags markiert ist, ist Teil der Bereitstellungsgruppe, selbst wenn sie noch weitere Tags hat. Wenn Sie beispielsweise weitere mit `Region=West` markierte Instances haben, sind diese nicht Teil der Bereitstellungsgruppe.
CodeDeploy Ansicht des Konsolen-Setups:
![\[Die CodeDeploy Konsole zeigt eine Tag-Gruppe mit drei Tags.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/TaggingExample2-polaris.png)
JSON-Struktur:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
]
]
},
```
## Beispiel 3: Mehrere Tag-Gruppen, einzelne Tags
Sie können auch mehrere Sätze von Tag-Gruppen mit jeweils einem einzelnen Schlüssel-Wert-Paar verwenden, um die Kriterien für Instances in der Bereitstellungsgruppe anzugeben. Wenn Sie mehrere Tag-Gruppen in einer Bereitstellungsgruppe verwenden, gehören nur Instances, die von allen tag-Gruppen identifiziert werden, zu der Bereitstellungsgruppe.
**Tag-Gruppe 1**
| Key (Schlüssel) | Value (Wert) |
| --- | --- |
| Name | AppVersion-ABC |
**Tag-Gruppe 2**
| Key (Schlüssel) | Value (Wert) |
| --- | --- |
| Region | Nord |
**Gruppe 3 taggen**
| Key (Schlüssel) | Value (Wert) |
| --- | --- |
| Typ | t2.medium |
Sie können Instances in vielen Regionen und von verschiedenen Instance-Typen haben, die mit `Name=AppVersion-ABC` markiert sind. In diesem Beispiel sind nur die Instances, die auch mit `Region=North` und `Type=t2.medium` markiert sind, Teil der Bereitstellungsgruppe.
CodeDeploy Ansicht des Konsolen-Setups:
![\[Die CodeDeploy Konsole zeigt drei Tag-Gruppen mit jeweils einem Tag.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/TaggingExample3-polaris.png)
JSON-Struktur:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
}
],
]
},
```
## Beispiel 4: Mehrere Tag-Gruppen, mehrere Tags
Wenn Sie mehrere Tag-Gruppen mit mehreren Tags in mindestens einer Gruppe verwenden, muss eine Instance mindestens mit einem der Tags in jeder der Gruppen übereinstimmen.
**Tag-Gruppe 1**
| Key (Schlüssel) | Value (Wert) |
| --- | --- |
| Umgebung | Beta |
| Umgebung | Staging |
**Gruppe 2 taggen**
| Key (Schlüssel) | Value (Wert) |
| --- | --- |
| Region | Nord |
| Region | Süd |
| Region | Ost |
**Gruppe 3 taggen**
| Key (Schlüssel) | Value (Wert) |
| --- | --- |
| Typ | t2.medium |
| Typ | t2.large |
In diesem Beispiel muss eine Instance, um Mitglied der Bereitstellungsgruppe zu sein, mit `Environment=Beta` oder `Environment=Staging`, mit (2) `Region=North`, `Region=South`oder `Region=East`, und mit (3) `Type=t2.medium` oder `Type=t2.large` markiert sein.
Beispielsweise *sind* Instances mit den folgenden Tag-Gruppen Teil der Bereitstellungsgruppe:
+ `Environment=Beta`, `Region=North`,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,`Type=t2.large`
+ `Environment=Staging`,`Region=South`,`Type=t2.large`
Instances mit den folgenden Tag-Gruppen sind *nicht* Teil der Bereitstellungsgruppe. Die **hervorgehobenen** Schlüsselwerte führen dazu, dass die Instances ausgeschlossen werden:
+ `Environment=Beta`, Region=**West**,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,Typ=**t2.micro**
+ Umgebung=**Produktion**,`Region=South`,`Type=t2.large`
CodeDeploy Ansicht des Konsolen-Setups:
![\[Die CodeDeploy Konsole zeigt drei Tag-Gruppen mit jeweils mehreren Tags.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/TaggingExample4-polaris.png)
JSON-Struktur:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Beta"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Staging"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.large"
}
],
]
},
```
# Arbeiten mit Amazon EC2 EC2-Instances für CodeDeploy
Eine Amazon EC2 EC2-Instance ist eine virtuelle Computerumgebung, die Sie mit Amazon Elastic Compute Cloud erstellen und konfigurieren. Amazon EC2 bietet skalierbare Rechenkapazität in der AWS Cloud. Sie können Amazon EC2 verwenden, um so viele oder so wenige virtuelle Server zu starten, wie Sie für Ihre CodeDeploy Bereitstellungen benötigen.
Weitere Informationen zu Amazon EC2 finden Sie im [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Die Anweisungen in diesem Abschnitt zeigen Ihnen, wie Sie Amazon EC2 EC2-Instances für die Verwendung in Ihren CodeDeploy Bereitstellungen erstellen und konfigurieren.
**Topics**
+ [Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy](instances-ec2-create.md)
+ [Eine Amazon EC2 EC2-Instance erstellen (CloudFormation Vorlage)](instances-ec2-create-cloudformation-template.md)
+ [Eine Amazon EC2 EC2-Instance konfigurieren](instances-ec2-configure.md)
# Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy (AWS CLI oder Amazon EC2 EC2-Konsole)
Diese Anweisungen zeigen Ihnen, wie Sie eine neue Amazon EC2 EC2-Instance starten, die für die Verwendung in CodeDeploy Bereitstellungen konfiguriert ist.
Sie können unsere CloudFormation Vorlage verwenden, um eine Amazon EC2 EC2-Instance zu starten, auf der Amazon Linux oder Windows Server ausgeführt wird und die bereits für die Verwendung in CodeDeploy Bereitstellungen konfiguriert ist. Wir stellen keine CloudFormation Vorlage für Amazon EC2 EC2-Instances bereit, auf denen Ubuntu Server oder Red Hat Enterprise Linux (RHEL) ausgeführt werden. Alternativen zur Nutzung der Vorlage finden Sie unter [Arbeiten mit Instanzen für CodeDeploy](instances.md).
Sie können die Amazon EC2 EC2-Konsole oder Amazon EC2 EC2-APIs verwenden AWS CLI, um eine Amazon EC2 EC2-Instance zu starten.
## Starten Sie eine Amazon EC2 EC2-Instance (Konsole)
### Voraussetzungen
Falls Sie dies noch nicht getan haben, folgen Sie den Anweisungen unter, [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) um das AWS CLI einzurichten und zu konfigurieren und ein IAM-Instance-Profil zu erstellen.
### Starten Sie eine Amazon-EC2-Instance
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 im Navigationsbereich **Instances** und **Launch Instance (Instance starten)** aus.
1. Suchen Sie auf der Seite **Step 1: Choose an Amazon Machine Image (AMI) (Schritt 1: Auswählen eines Amazon Machine Images (AMI))** auf der Registerkarte **Quick Start (Schnellstart)** das Betriebssystem und die Version, die Sie verwenden möchten, und wählen Sie dann **Select (Auswählen)** aus. Sie müssen ein Amazon EC2 AMI-Betriebssystem wählen, das von CodeDeploy unterstützt wird. Weitere Informationen finden Sie unter [Betriebssysteme, die vom Agenten unterstützt werden CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
1. Wählen Sie auf der Seite **Schritt 2: Instance-Typ auswählen einen** beliebigen verfügbaren Amazon EC2 EC2-Instance-Typ aus und klicken Sie dann auf **Weiter: Instance-Details konfigurieren**.
1. Wählen Sie auf der Seite **Schritt 3: Instance-Details konfigurieren** in der **IAM-Rollenliste die IAM-Instance-Rolle** aus, in der Sie sie erstellt haben. [Schritt 4: Erstellen Sie ein IAM-Instance-Profil für Ihre Amazon EC2 EC2-Instances](getting-started-create-iam-instance-profile.md) Wenn Sie den empfohlenen Rollennamen verwenden, wählen Sie **CodeDeployDemo-EC2-Instance-Profile** aus. Wenn Sie einen eigenen Rollenname erstellt haben, wählen Sie diesen aus.
**Anmerkung**
Wenn eine standardmäßige Virtual Private Cloud (VPC) nicht in der **Netzwerkliste** angezeigt wird, müssen Sie eine Amazon-VPC und ein Amazon-Subnetz auswählen oder erstellen. Wählen Sie **Create new VPC (Neue VPC erstellen)** oder **Create new subnet (Neues Subnetz erstellen)** oder beides aus. Weitere Informationen finden Sie unter [Ihre VPC und Subnetze](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html).
1. Wählen Sie **Next: Add Storage** aus.
1. Lassen Sie die Seite **Step 4: Add Storage (Schritt 4: Speicher hinzufügen)** unverändert, und wählen Sie **Next: Add Tags (Weiter: Tags hinzufügen)** aus.
1. Wählen Sie auf der Seite **Step 5: Add Tags (Schritt 5: Tags hinzufügen)** die Option **Add Tag (Tag hinzufügen)** aus.
1. Geben Sie im Feld **Schlüssel** **Name** ein. Geben Sie im Feld **Value (Wert)** den Wert **CodeDeployDemo** ein.
**Wichtig**
Bei den Inhalten der Felder **Key (Schlüssel)** und **Value (Wert)** ist die Groß- und Kleinschreibung zu beachten.
1. Wählen Sie **Weiter: Sicherheitsgruppe konfigurieren** aus.
1. Lassen Sie auf der Seite **Step 6: Configure Security Group (Schritt 6: Konfigurieren einer Sicherheitsgruppe)** die Option **Create a new security group (Neue Sicherheitsgruppe erstellen)** ausgewählt.
Eine Standard-SSH-Rolle ist für Amazon EC2 EC2-Instances konfiguriert, auf denen Amazon Linux, Ubuntu Server oder RHEL ausgeführt wird. Eine standardmäßige RDP-Rolle ist für Amazon EC2 EC2-Instances konfiguriert, auf denen Windows Server ausgeführt wird.
1. Wenn Sie den HTTP-Port öffnen möchten, klicken Sie auf die Schaltfläche **Add Rule (Regel hinzufügen)**. Wählen Sie in der Dropdown-Liste **Type (Typ)** die Option **HTTP** aus. **Akzeptieren Sie den **Standardquellwert** **Custom 0.0.0.0/0** und wählen Sie dann Review and Launch.**
**Anmerkung**
**In einer Produktionsumgebung empfehlen wir, den Zugriff auf die SSH-, RDP- und HTTP-Ports einzuschränken, anstatt Anywhere 0.0.0.0/0 anzugeben.** CodeDeploy erfordert keinen uneingeschränkten Portzugriff und erfordert keinen HTTP-Zugriff. Weitere Informationen finden Sie unter [Tipps zur Sicherung Ihrer Amazon EC2 EC2-Instance](https://aws.amazon.com/articles/1233).
Wenn das Dialogfeld **Boot from General Purpose (SSD) (Neustart von Allzweck-(SSD)-Volume)** angezeigt wird, befolgen Sie die Anweisungen, und wählen Sie dann **Next (Weiter)** aus.
1. Lassen Sie die Seite **Step 7: Review Instance Launch (Schritt 7: Prüfen eines Starts einer Instance)** unverändert und wählen Sie **Launch (Starten)** aus.
1. Wählen Sie im Dialogfeld **Select an existing key pair or create a new key pair (Ein bestehendes Schlüsselpaar wählen oder ein neues Schlüsselpaar erstellen)** entweder **Choose an existing key pair (Ein vorhandenes Schlüsselpaars auswählen)** oder **Create a new key pair (Ein neues Schlüsselpaar erstellen)**. Wenn Sie ein Amazon EC2-Instance-Schlüsselpaar bereits konfiguriert haben, können Sie das Schlüsselpaar hier auswählen.
Wenn Sie noch kein Amazon EC2-Instance-Schlüsselpaar haben, klicken Sie auf **Create a new key pair (Ein neues Schlüsselpaar erstellen)** und geben Sie einen wiedererkennbaren Namen ein. Wählen Sie **key pair herunterladen**, um das Amazon EC2 EC2-Instance-Schlüsselpaar auf Ihren Computer herunterzuladen.
**Wichtig**
Sie benötigen ein key pair, wenn Sie mit SSH oder RDP auf Ihre Amazon EC2 EC2-Instance zugreifen möchten.
1. Wählen Sie **Instances starten** aus.
1. Wählen Sie die ID für Ihre Amazon EC2 EC2-Instance. Fahren Sie nicht fort, bis die Instance gestartet wurde und alle Prüfungen bestanden hat.
### Installieren Sie den Agenten CodeDeploy
Der CodeDeploy Agent muss auf Ihrer Amazon EC2 EC2-Instance installiert sein, bevor Sie ihn in CodeDeploy Bereitstellungen verwenden können. Weitere Informationen finden Sie unter [Installieren Sie den CodeDeploy Agenten](codedeploy-agent-operations-install.md).
**Anmerkung**
Sie können die automatische Installation und Updates des CodeDeploy Agenten konfigurieren, wenn Sie Ihre Bereitstellungsgruppe in der Konsole erstellen.
## Starten Sie eine Amazon EC2 EC2-Instance (CLI)
### Voraussetzungen
Falls Sie dies noch nicht getan haben, folgen Sie den Anweisungen unter, [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) um das AWS CLI einzurichten und zu konfigurieren und ein IAM-Instance-Profil zu erstellen.
### Starten Sie eine Amazon-EC2-Instance
1. **Nur für Windows Server** Wenn Sie eine Amazon EC2 EC2-Instance erstellen, auf der Windows Server ausgeführt wird, rufen Sie die **authorize-security-group-ingress** Befehle **create-security-group** und auf, um eine Sicherheitsgruppe zu erstellen, die RDP-Zugriff (der standardmäßig nicht zulässig ist) und alternativ HTTP-Zugriff ermöglicht. Um beispielsweise eine Sicherheitsgruppe mit dem Namen *CodeDeployDemo-Windows-Security-Group* zu erstellen, führen Sie nacheinander die folgenden Befehle aus:
```
aws ec2 create-security-group --group-name CodeDeployDemo-Windows-Security-Group --description "For launching Windows Server images for use with CodeDeploy"
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 3389 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 3389
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 80 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 80
```
**Anmerkung**
Mit diesen Befehlen kann eine Sicherheitsgruppe zu Demonstrationszwecken erstellt werden, die uneingeschränkten RDP-Zugriff über Port 3389 und alternativ HTTP-Zugriff über Port 80 ermöglicht. Als bewährte Methode empfehlen wir, den Zugriff auf RDP- und HTTP-Ports einzuschränken. CodeDeploy benötigt keinen uneingeschränkten Port-Zugriff und erfordert keinen HTTP-Zugriff. Weitere Informationen finden Sie unter [Tipps zur Sicherung Ihrer Amazon EC2 EC2-Instance](https://aws.amazon.com/articles/1233).
1. Rufen Sie den **run-instances** Befehl auf, um die Amazon EC2 EC2-Instance zu erstellen und zu starten.
Bevor Sie diesen Befehl aufrufen, müssen Sie Folgendes erfassen:
+ Die ID eines Amazon Machine Image (AMI) (*ami-id*), das Sie für die Instance verwenden. Informationen zum Abrufen der ID [finden Sie unter Ein geeignetes AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html) finden.
+ Der Name des Typs der Amazon EC2 EC2-Instance (*instance-type*), die Sie erstellen, z. B. `t1.micro` Eine Liste finden Sie unter [Amazon EC2 EC2-Instance-Typen](https://aws.amazon.com/ec2/instance-types/).
+ Der Name eines IAM-Instance-Profils mit der Berechtigung für den Zugriff auf den Amazon S3 S3-Bucket, in dem die CodeDeploy Agenteninstallationsdateien für Ihre Region gespeichert sind.
Informationen zum Erstellen eines IAM-Instance-Profils finden Sie unter. [Schritt 4: Erstellen Sie ein IAM-Instance-Profil für Ihre Amazon EC2 EC2-Instances](getting-started-create-iam-instance-profile.md)
+ Der Name eines Amazon EC2 EC2-Instance-Schlüsselpaars (*key-name*), um den SSH-Zugriff auf eine Amazon EC2 EC2-Instance zu ermöglichen, auf der Amazon Linux, Ubuntu Server oder RHEL- oder RDP-Zugriff auf eine Amazon EC2 EC2-Instance ausgeführt wird, auf der Windows Server ausgeführt wird.
**Wichtig**
Geben Sie nur den Namen des Schlüsselpaars ein, nicht die Dateierweiterung des Schlüsselpaars. Zum Beispiel *my-keypair*, nicht *my-keypair.pem*.
Um einen Schlüsselpaarnamen zu finden, öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2](https://console.aws.amazon.com/ec2). Wählen Sie im Navigationsbereich unter **Network & Security (Netzwerk und Sicherheit)** **Key Pairs (Schlüsselpaare)** aus und notieren Sie den Schlüsselpaarnamen in der Liste.
Informationen zum Generieren eines key pair finden Sie unter [Erstellen Ihres key pair mit Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Stellen Sie sicher, dass Sie das key pair in einer der Regionen erstellen, die unter [Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Allgemeine AWS-Referenz*aufgeführt sind. Andernfalls können Sie das Amazon EC2 EC2-Instance-Schlüsselpaar nicht mit CodeDeploy verwenden.
**Für Amazon Linux, RHEL und Ubuntu Server**
Um den **run-instances** Befehl aufzurufen, um eine Amazon EC2 EC2-Instance zu starten, auf der Amazon Linux, Ubuntu Server oder RHEL ausgeführt wird, und das IAM-Instance-Profil anzuhängen, das Sie in erstellt haben. [Schritt 4: Erstellen Sie ein IAM-Instance-Profil für Ihre Amazon EC2 EC2-Instances](getting-started-create-iam-instance-profile.md) Beispiel:
```
aws ec2 run-instances \
--image-id ami-id \
--key-name key-name \
--count 1 \
--instance-type instance-type \
--iam-instance-profile Name=iam-instance-profile
```
**Anmerkung**
Dieser Befehl erstellt eine Standardsicherheitsgruppe für die Amazon EC2 EC2-Instance, die den Zugriff auf mehrere Ports ermöglicht, einschließlich des uneingeschränkten Zugriffs für SSH über Port 22 und alternativ HTTP über Port 80. Als bewährte Methode empfehlen wir, den Zugriff nur auf die SSH- und HTTP-Ports zu beschränken. CodeDeploy erfordert keinen uneingeschränkten Portzugriff und erfordert keinen HTTP-Portzugriff. Weitere Informationen finden Sie unter [Tipps zur Sicherung Ihrer Amazon EC2 EC2-Instance](https://aws.amazon.com/articles/1233).
**Für Windows Server**
Um den **run-instances** Befehl aufzurufen, um eine Amazon EC2 EC2-Instance zu starten, auf der Windows Server ausgeführt wird, und das IAM-Instance-Profil anzuhängen[Schritt 4: Erstellen Sie ein IAM-Instance-Profil für Ihre Amazon EC2 EC2-Instances](getting-started-create-iam-instance-profile.md), in dem Sie erstellt haben, und den Namen der Sicherheitsgruppe anzugeben, die Sie in Schritt 1 erstellt haben. Beispiel:
```
aws ec2 run-instances --image-id ami-id --key-name key-name --count 1 --instance-type instance-type --iam-instance-profile Name=iam-instance-profile --security-groups CodeDeploy-Windows-Security-Group
```
Diese Befehle starten eine einzelne Amazon EC2 EC2-Instance mit dem angegebenen AMI, dem angegebenen key pair und dem angegebenen Instance-Typ mit dem angegebenen IAM-Instance-Profil und führen das angegebene Skript beim Start aus.
1. Beachten Sie den Wert von `InstanceID` in der Ausgabe. Wenn Sie diesen Wert vergessen, können Sie ihn später abrufen, indem Sie den **describe-instances** Befehl für das Amazon EC2 EC2-Instance-Schlüsselpaar aufrufen.
```
aws ec2 describe-instances --filters "Name=key-name,Values=keyName" --query "Reservations[*].Instances[*].[InstanceId]" --output text
```
Verwenden Sie die Instance-ID, um den **create-tags** Befehl aufzurufen, der die Amazon EC2 EC2-Instance kennzeichnet, sodass sie später während einer Bereitstellung gefunden werden CodeDeploy kann. Im folgenden Beispiel ist das Tag benannt**CodeDeployDemo**, aber Sie können jedes beliebige Amazon EC2 EC2-Instance-Tag angeben.
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=CodeDeployDemo
```
Sie können einer Instance gleichzeitig mehrere Tags zuordnen. Beispiel:
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=testInstance Key=Region,Value=West Key=Environment,Value=Beta
```
Um zu überprüfen, ob die Amazon EC2 EC2-Instance gestartet wurde und alle Prüfungen bestanden hat, verwenden Sie die Instance-ID, um den **describe-instance-status** Befehl aufzurufen.
```
aws ec2 describe-instance-status --instance-ids instance-id --query "InstanceStatuses[*].InstanceStatus.[Status]" --output text
```
Wenn die Instance gestartet wurde und alle Prüfungen bestanden wurden, wird `ok` in der Ausgabe angezeigt.
### Installieren Sie den Agenten CodeDeploy
Der CodeDeploy Agent muss auf Ihrer Amazon EC2 EC2-Instance installiert sein, bevor Sie ihn in CodeDeploy Bereitstellungen verwenden können. Weitere Informationen finden Sie unter [Installieren Sie den CodeDeploy Agenten](codedeploy-agent-operations-install.md).
**Anmerkung**
Sie können die automatische Installation und Updates des CodeDeploy Agenten konfigurieren, wenn Sie Ihre Bereitstellungsgruppe in der Konsole erstellen.
# Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy (CloudFormation Vorlage)
Sie können unsere CloudFormation Vorlage verwenden, um schnell eine Amazon EC2 EC2-Instance zu starten, auf der Amazon Linux oder Windows Server ausgeführt wird. Sie können die AWS CLI, die CodeDeploy Konsole oder die verwenden, AWS APIs um die Instance mit der Vorlage zu starten. Zusätzlich zum Starten der Instance übernimmt die Vorlage folgende Aufgaben:
+ Weist an CloudFormation , der Instance die Erlaubnis zu erteilen, an CodeDeploy Bereitstellungen teilzunehmen.
+ Markiert die Instanz, sodass sie während einer Bereitstellung gefunden werden CodeDeploy kann.
+ Installiert den CodeDeploy Agenten und führt ihn auf der Instanz aus.
Sie müssen unsere CloudFormation nicht verwenden, um eine Amazon EC2 EC2-Instance einzurichten. Alternativen finden Sie unter [Arbeiten mit Instanzen für CodeDeploy](instances.md).
Wir bieten keine CloudFormation Vorlage für Amazon EC2 EC2-Instances, auf denen Ubuntu Server oder Red Hat Enterprise Linux (RHEL) ausgeführt werden.
**Topics**
+ [Bevor Sie beginnen](#instances-ec2-create-cloudformation-template-before)
+ [Starten Sie eine Amazon EC2 EC2-Instance mit der CloudFormation Vorlage (Konsole)](#instances-ec2-create-cloudformation-template-console)
+ [Starten Sie eine Amazon EC2 EC2-Instance mit der CloudFormation Vorlage ()AWS CLI](#instances-ec2-create-cloudformation-template-cli)
## Bevor Sie beginnen
Bevor Sie die CloudFormation Vorlage zum Starten von Amazon EC2 EC2-Instances verwenden können, stellen Sie sicher, dass Sie die folgenden Schritte ausführen.
1. Stellen Sie sicher, dass Sie einen Administratorbenutzer erstellt haben, wie unter beschrieben[Schritt 1: Einrichtung](getting-started-setting-up.md). Vergewissern Sie sich, dass der Benutzer über die folgenden Mindestberechtigungen verfügt, und fügen Sie alle Rechte hinzu, die nicht vorhanden sind:
+ Wolkenbildung: \$1
+ codedeploy:\$1
+ ec2:\$1
+ ich bin: AddRoleToInstanceProfile
+ ich bin: CreateInstanceProfile
+ ich bin: CreateRole
+ ich bin: DeleteInstanceProfile
+ ich bin: DeleteRole
+ ich bin: DeleteRolePolicy
+ ich bin: GetRole
+ ich bin: DeleteRolePolicy
+ ich bin: PutRolePolicy
+ ich bin: RemoveRoleFromInstanceProfile
1. Stellen Sie sicher, dass Sie über ein Instance-Schlüsselpaar verfügen, um den SSH-Zugriff auf die Amazon EC2-Instance, auf der Amazon Linux ausgeführt wird, oder den RDP-Zugriff auf die Instance, auf der Windows Server ausgeführt wird, zu ermöglichen.
Um einen Schlüsselpaarnamen zu finden, öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2](https://console.aws.amazon.com/ec2). Wählen Sie im Navigationsbereich unter **Network & Security (Netzwerk und Sicherheit)** **Key Pairs (Schlüsselpaare)** aus und notieren Sie den Schlüsselpaarnamen in der Liste.
Informationen zum Generieren eines neuen key pair finden Sie unter [Erstellen Ihres key pair mit Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Stellen Sie sicher, dass das key pair in einer der unter [Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Allgemeine AWS-Referenz*aufgeführten Regionen erstellt wurde. Ansonsten können Sie das Instance-Schlüsselpaar nicht mit CodeDeploy verwenden.
## Starten Sie eine Amazon EC2 EC2-Instance mit der CloudFormation Vorlage (Konsole)
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/).
**Wichtig**
Melden Sie sich AWS-Managementkonsole mit demselben Konto an, das Sie verwendet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) Wählen Sie in der Navigationsleiste in der Regionsauswahl eine der Regionen aus, die unter [Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in aufgeführt sind. *Allgemeine AWS-Referenz* CodeDeploy unterstützt nur diese Regionen.
1. Wählen Sie **Stack erstellen** aus.
1. Wählen Sie unter **Vorlage auswählen** die Option **Geben Sie eine Amazon S3 S3-Vorlagen-URL** an. Geben Sie in das Feld den Speicherort der CloudFormation Vorlage für Ihre Region ein und wählen Sie dann **Weiter** aus.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
1. Geben Sie in das Feld **Stack name (Stack-Name)** einen Namen ein (z. B. **CodeDeployDemoStack**).
1. Geben Sie im Feld **Parameters (Parameter)** Folgendes ein und wählen Sie dann **Next (Weiter)** aus.
+ Geben Sie für **InstanceCount**die Anzahl der Instances ein, die Sie starten möchten. (Wir empfehlen, den Standardwert **1** beizubehalten.)
+ Geben Sie für den Instance-Typ ein **InstanceType**, den Sie starten möchten (oder behalten Sie den Standardwert **t1.micro** bei).
+ Geben Sie für **KeyPairName**den Namen des Instanzschlüsselpaars key pair. Geben Sie nur den Namen des Schlüsselpaars ein, nicht die Dateierweiterung des Schlüsselpaars.
+ Geben Sie im **OperatingSystem**Feld ein, **Windows** um Instanzen zu starten, auf denen Windows Server ausgeführt wird (oder behalten Sie die Standardeinstellung **Linux** bei).
+ Geben Sie für den IP-Adressbereich ein **SSHLocation**, der für die Verbindung mit der Instanz über SSH oder RDP verwendet werden soll (oder behalten Sie den Standardwert **0.0.0.0/0** bei).
**Wichtig**
Die Standardeinstellung von wird nur zu **0.0.0.0/0** Demonstrationszwecken bereitgestellt. CodeDeploy erfordert nicht, dass Amazon EC2 EC2-Instances uneingeschränkten Zugriff auf Ports haben. Als bewährte Methode empfehlen wir, Zugriff auf SSH- (und HTTP)-Ports einzuschränken. Weitere Informationen finden Sie unter [Tipps zur Sicherung Ihrer Amazon EC2 EC2-Instance](https://aws.amazon.com/articles/1233).
+ Geben Sie den Instance-Tag-Schlüssel ein **TagKey**, mit dem die Instances während der Bereitstellung identifiziert CodeDeploy werden sollen (oder behalten Sie die Standardeinstellung **Name** bei).
+ Geben Sie für den Instanz-Tag-Wert ein **TagValue**, mit dem die Instances während der Bereitstellung identifiziert CodeDeploy werden sollen (oder behalten Sie den Standardwert von bei **CodeDeployDemo**).
1. Lassen Sie auf der Seite **Options (Optionen)** die Optionsfelder leer, und wählen Sie **Next (Weiter)**.
**Wichtig**
CloudFormation Tags unterscheiden sich von CodeDeploy Tags. CloudFormation verwendet Tags, um die Verwaltung Ihrer Infrastruktur zu vereinfachen. CodeDeploy verwendet Tags, um Amazon EC2 EC2-Instances zu identifizieren. Sie haben CodeDeploy-Tags auf der Seite **Specify Parameters (Parameter angeben)** angegeben.
1. **Wählen Sie auf der Seite „**Überprüfen**“ unter **Funktionen** das Feld **Ich bestätige, dass CloudFormation möglicherweise IAM-Ressourcen erstellt werden, und wählen Sie dann Erstellen** aus.**
**Nachdem CloudFormation der Stack erstellt und die Amazon EC2 EC2-Instances gestartet wurden, wird **CREATE\$1COMPLETE** in der Spalte Status in der CloudFormation Konsole angezeigt.** Dieser Vorgang kann einige Minuten dauern.
Informationen zur Überprüfung, ob der CodeDeploy Agent auf den Amazon EC2 EC2-Instances ausgeführt wird, finden Sie unter[Verwaltung des CodeDeploy Agentenbetriebs](codedeploy-agent-operations.md), und fahren Sie dann fort mit. [Erstellen Sie eine Anwendung mit CodeDeploy](applications-create.md)
## Starten Sie eine Amazon EC2 EC2-Instance mit der CloudFormation Vorlage ()AWS CLI
1. Verwenden Sie unsere CloudFormation Vorlage in einem Aufruf des **create-stack** Befehls. Dieser Stack startet eine neue Amazon EC2 EC2-Instance mit dem installierten CodeDeploy Agenten.
So starten Sie eine Amazon EC2 EC2-Instance, auf der Amazon Linux ausgeführt wird:
```
aws cloudformation create-stack \
--stack-name CodeDeployDemoStack \
--template-url templateURL \
--parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro \
ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Linux \
ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name \
ParameterKey=TagValue,ParameterValue=CodeDeployDemo \
--capabilities CAPABILITY_IAM
```
So starten Sie eine Amazon EC2 EC2-Instance, auf der Windows Server ausgeführt wird:
```
aws cloudformation create-stack --stack-name CodeDeployDemoStack --template-url template-url --parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Windows ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name ParameterKey=TagValue,ParameterValue=CodeDeployDemo --capabilities CAPABILITY_IAM
```
*keyName*ist der Name des Instanzschlüsselpaars. Geben Sie nur den Namen des Schlüsselpaars ein, nicht die Dateierweiterung des Schlüsselpaars.
*template-url*ist der Speicherort der CloudFormation Vorlage für Ihre Region:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
Dieser Befehl erstellt einen CloudFormation Stack mit dem Namen**CodeDeployDemoStack**, der die CloudFormation Vorlage im angegebenen Amazon S3 S3-Bucket verwendet. Die Amazon EC2 EC2-Instance basiert auf dem Instance-Typ t1.micro, Sie können jedoch jeden beliebigen Typ verwenden. Sie ist mit dem Wert **CodeDeployDemo** getaggt, aber Sie können sie mit jedem beliebigen Wert taggen. Das angegebene Instance-Schlüsselpaar wurde darauf angewendet.
1. Rufen Sie den **describe-stacks** Befehl auf, um zu überprüfen, ob der angegebene CloudFormation Stack erfolgreich erstellt **CodeDeployDemoStack** wurde:
```
aws cloudformation describe-stacks --stack-name CodeDeployDemoStack --query "Stacks[0].StackStatus" --output text
```
Fahren Sie erst fort, wenn der Wert `CREATE_COMPLETE` zurückgegeben wurde.
Informationen zur Überprüfung, ob der CodeDeploy Agent auf der Amazon EC2 EC2-Instance ausgeführt wird, finden Sie unter[Verwaltung des CodeDeploy Agentenbetriebs](codedeploy-agent-operations.md), und fahren Sie dann fort mit. [Erstellen Sie eine Anwendung mit CodeDeploy](applications-create.md)
# Konfigurieren Sie eine Amazon EC2 EC2-Instance, mit der Sie arbeiten können CodeDeploy
Diese Anweisungen zeigen Ihnen, wie Sie eine Amazon EC2 EC2-Instance, auf der Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) oder Windows Server ausgeführt wird, für die Verwendung in CodeDeploy Bereitstellungen konfigurieren.
**Anmerkung**
Wenn Sie keine Amazon EC2 EC2-Instance haben, können Sie die CloudFormation Vorlage verwenden, um eine Instance zu starten, auf der Amazon Linux oder Windows Server ausgeführt wird. Wir bieten keine Vorlage für Ubuntu Server oder RHEL an.
## Schritt 1: Stellen Sie sicher, dass ein IAM-Instance-Profil an Ihre Amazon EC2 EC2-Instance angehängt ist
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 im Navigationsbereich unter **Instances** die Option **Instances**.
1. Navigieren Sie zu Ihrer Amazon EC2 EC2-Instance und wählen Sie sie in der Liste aus.
1. Notieren Sie sich im Detailbereich auf der Registerkarte **Beschreibung** den Wert im Feld **IAM-Rolle** und fahren Sie dann mit dem nächsten Abschnitt fort.
Wenn das Feld leer ist, können Sie der Instance ein IAM-Instanzprofil anhängen. Weitere Informationen finden Sie unter [Eine IAM-Rolle an eine Instance anhängen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
## Schritt 2: Stellen Sie sicher, dass das angehängte IAM-Instanzprofil über die richtigen Zugriffsberechtigungen verfügt
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie im Navigationsbereich **Rollen**.
1. Navigieren Sie zu dem IAM-Rollennamen, den Sie sich in Schritt 4 des vorherigen Abschnitts notiert haben, und wählen Sie ihn aus.
**Anmerkung**
Wenn Sie die durch die CloudFormation Vorlage generierte Servicerolle anstelle einer Servicerolle verwenden möchten, die Sie anhand der Anweisungen unter erstellt haben[Schritt 2: Erstellen Sie eine Servicerolle für CodeDeploy](getting-started-create-service-role.md), beachten Sie Folgendes:
In einigen Versionen unserer CloudFormation Vorlage entspricht der Anzeigename des generierten und an die Amazon EC2 EC2-Instances angehängten IAM-Instance-Profils nicht dem Anzeigenamen in der IAM-Konsole. Beispielsweise könnte das IAM-Instance-Profil den Anzeigenamen haben`CodeDeploySampleStack-expnyi6-InstanceRoleInstanceProfile-IK8J8A9123EX`, während das IAM-Instance-Profil in der IAM-Konsole den Anzeigenamen haben könnte. `CodeDeploySampleStack-expnyi6-InstanceRole-C5P33V1L64EX`
Um Ihnen bei der Identifizierung des Instanzprofils in der IAM-Konsole zu helfen, sehen Sie, dass das Präfix von für beide `CodeDeploySampleStack-expnyi6-InstanceRole` identisch ist. Informationen darüber, warum diese Anzeigenamen unterschiedlich sein können, finden Sie unter [Instanzprofile](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html).
1. Wählen Sie die Registerkarte **Trust Relationships.** Wenn es in **Trusted Entities** keinen Eintrag mit der Aufschrift **The identity provider (s) ec2.amazonaws.com gibt, können Sie diese Amazon EC2 EC2-Instance** nicht verwenden. Stoppen und erstellen Sie eine Amazon EC2 EC2-Instance mithilfe der Informationen in[Arbeiten mit Instanzen für CodeDeploy](instances.md).
Wenn es einen Eintrag mit der Aufschrift **The identity provider (s) ec2.amazonaws.com** gibt und Sie Ihre Anwendungen nur in GitHub Repositorys speichern, fahren Sie mit fort. [Schritt 3: Markieren Sie die Amazon EC2 EC2-Instance](#instances-ec2-configure-3-tag-instance)
**Wenn es einen Eintrag mit der Aufschrift **The identity provider (s) ec2.amazonaws.com** gibt und Sie Ihre Anwendungen in Amazon S3 S3-Buckets speichern, wählen Sie den Tab Berechtigungen.**
1. Wenn es eine Richtlinie im Bereich **Permissions policies (Berechtigungsrichtlinien)** gibt, erweitern Sie die Richtlinie und wählen dann **Edit policy (Richtlinie bearbeiten)**.
1. Wählen Sie den Tab **JSON**. Wenn Sie Ihre Anwendungen in Amazon S3 S3-Buckets speichern, stellen Sie sicher`"s3:Get*"`, dass sie in der Liste der angegebenen Aktionen aufgeführt `"s3:List*"` sind.
Dies kann etwa wie folgt aussehen:
```
{"Statement":[{"Resource":"*","Action":[
... Some actions may already be listed here ...
"s3:Get*","s3:List*"
... Some more actions may already be listed here ...
],"Effect":"Allow"}]}
```
Oder es kann wie folgt aussehen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": "*"
}
]
}
```
------
Wenn `"s3:Get*"` und `"s3:List*"` nicht in der Liste der angegebenen Aktionen stehen, verwenden Sie **Edit (Bearbeiten)**, um sie hinzuzufügen, und wählen Sie dann **Save (Speichern)**. (Wenn weder `"s3:Get*"` noch `"s3:List*"` die letzte Aktion in der Liste ist, fügen Sie ein Komma direkt nach der Aktion ein, sodass das Richtliniendokument validiert wird.)
**Anmerkung**
Wir empfehlen, diese Richtlinie nur auf die Amazon S3 S3-Buckets zu beschränken, auf die Ihre Amazon EC2 EC2-Instances zugreifen müssen. Stellen Sie sicher, dass Sie Zugriff auf die Amazon S3 S3-Buckets gewähren, die den CodeDeploy Agenten enthalten. Andernfalls kann ein Fehler auftreten, wenn der CodeDeploy Agent auf den Instances installiert oder aktualisiert wird. Um dem IAM-Instance-Profil nur Zugriff auf einige CodeDeploy Resource Kit-Buckets in Amazon S3 zu gewähren, verwenden Sie die folgende Richtlinie, entfernen Sie jedoch die Zeilen für Buckets, auf die Sie den Zugriff verhindern möchten:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
## Schritt 3: Markieren Sie die Amazon EC2 EC2-Instance
Anweisungen dazu, wie Sie die Amazon EC2 EC2-Instance taggen, sodass sie während einer Bereitstellung gefunden werden CodeDeploy kann, finden Sie unter [Arbeiten mit Tags in der Konsole](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_Console). Kehren Sie dann zu dieser Seite zurück.
**Anmerkung**
Sie können die Amazon EC2 EC2-Instance mit einem beliebigen Schlüssel und Wert kennzeichnen. Denken Sie daran, diesen Schlüssel und den Wert bei der Bereitstellung anzugeben.
## Schritt 4: Installieren Sie den AWS CodeDeploy Agenten auf der Amazon EC2 EC2-Instance
Anweisungen zur Installation des CodeDeploy Agenten auf der Amazon EC2 EC2-Instance und zur Überprüfung, ob er ausgeführt wird[Verwaltung des CodeDeploy Agentenbetriebs](codedeploy-agent-operations.md), finden Sie unter und fahren Sie dann mit fort[Erstellen Sie eine Anwendung mit CodeDeploy](applications-create.md).
# Arbeiten mit lokalen Instanzen für CodeDeploy
Eine lokale Instance ist jedes physische Gerät, bei dem es sich nicht um eine Amazon EC2 EC2-Instance handelt, auf dem der CodeDeploy Agent ausgeführt und eine Verbindung zu öffentlichen AWS Service-Endpunkten hergestellt werden kann.
Die Bereitstellung einer CodeDeploy Anwendungsversion für eine lokale Instance umfasst zwei wichtige Schritte:
+ **Schritt 1** — Konfigurieren Sie jede lokale Instanz, registrieren Sie sie bei und CodeDeploy taggen Sie sie anschließend.
+ **Schritt 2** — Stellen Sie Anwendungsrevisionen auf der lokalen Instanz bereit.
**Anmerkung**
Informationen dazu, wie Sie mit dem Erstellen und Bereitstellen einer Beispielanwendungsrevision auf einer korrekt konfigurierten und registrierten lokalen Instance experimentieren, 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). Informationen zu lokalen Instanzen und deren Verwendung finden Sie unter CodeDeploy. [Arbeiten mit lokalen Instanzen für CodeDeploy](#instances-on-premises)
Wenn Sie nicht mehr möchten, dass eine lokale Instanz in Bereitstellungen verwendet wird, können Sie die lokalen Instanz-Tags aus den Bereitstellungsgruppen entfernen. Sie können die Tags der lokalen Instance auch von der Instance entfernen. Sie können auch explizit die Registrierung einer lokalen Instance aufheben, sodass sie in Bereitstellungen nicht mehr verwendet werden kann. Weitere Informationen finden Sie unter [Verwaltung von Vorgängen für lokale Instanzen in CodeDeploy](on-premises-instances-operations.md).
Die Anweisungen in diesem Abschnitt zeigen Ihnen, wie Sie eine lokale Instanz konfigurieren und sie anschließend registrieren und taggen, CodeDeploy damit sie in Bereitstellungen verwendet werden kann. In diesem Abschnitt wird auch beschrieben, wie Sie CodeDeploy Informationen über lokale Instances abrufen und die Registrierung einer lokalen Instance aufheben können, wenn Sie nicht mehr planen, auf ihr zu implementieren.
**Topics**
+ [Voraussetzungen für die Konfiguration einer lokalen Instanz](instances-on-premises-prerequisites.md)
+ [Registrieren einer lokalen Instance](on-premises-instances-register.md)
+ [Verwaltung des Betriebs von lokalen Instanzen](on-premises-instances-operations.md)
# Voraussetzungen für die Konfiguration einer lokalen Instanz
Die folgenden Voraussetzungen müssen erfüllt sein, bevor Sie eine lokale Instanz registrieren können.
**Wichtig**
Wenn Sie den [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)Befehl verwenden und die mit AWS -Security-Token-Service (AWS STS) generierten temporären Anmeldeinformationen regelmäßig aktualisieren, gelten weitere Voraussetzungen. Weitere Informationen finden Sie unter [ARN-Registrierungsvoraussetzungen für die IAM-Sitzung](register-on-premises-instance-iam-session-arn.md#register-on-premises-instance-iam-session-arn-prerequisites).
**Anforderungen an Speichergeräte**
Auf dem Gerät, das Sie vorbereiten, registrieren und als lokale Instanz kennzeichnen möchten, CodeDeploy muss ein unterstütztes Betriebssystem ausgeführt werden. Eine Liste finden Sie hier: [Betriebssysteme, die vom Agenten unterstützt werden CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
Wenn Ihr Betriebssystem nicht unterstützt wird, steht Ihnen der CodeDeploy Agent als Open-Source-Lösung zur Verfügung, sodass Sie ihn an Ihre Bedürfnisse anpassen können. Weitere Informationen finden Sie im [CodeDeploy Agenten-Repository](https://github.com/aws/aws-codedeploy-agent) unter GitHub.
**Ausgehende Kommunikation**
Die lokale Instanz muss in der Lage sein, eine Verbindung zu Endpunkten des öffentlichen AWS Dienstes herzustellen, mit denen sie kommunizieren kann. CodeDeploy
Der CodeDeploy Agent kommuniziert ausgehend über HTTPS über Port 443.
**Administrative Kontrolle**
Das lokale Konto oder das Netzwerkkonto, das auf der lokalen Instanz zur Konfiguration der lokalen Instanz verwendet wird, muss entweder als `sudo` oder `root` (für Ubuntu Server) oder als Administrator (für Windows Server) ausgeführt werden können.
**IAM-Berechtigungen**
Der IAM-Identität, die Sie für die Registrierung der lokalen Instanz verwenden, müssen Berechtigungen zum Abschließen der Registrierung (und zum Abmelden der lokalen Instanz, falls erforderlich) erteilt werden.
Stellen Sie zusätzlich zu der unter beschriebenen Richtlinie sicher[Schritt 3: Beschränken Sie die CodeDeploy Benutzerberechtigungen](getting-started-policy.md), dass der aufrufenden IAM-Identität die folgende zusätzliche Richtlinie beigefügt ist.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser"
],
"Resource": "*"
}
]
}
```
------
Informationen zum Zuweisen von IAM-Richtlinien finden Sie unter [Verwalten von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html).
# Registrieren Sie eine lokale Instanz mit CodeDeploy
Um eine lokale Instance zu registrieren, müssen Sie eine IAM-Identität zur Authentifizierung Ihrer Anforderungen verwenden. Sie können zwischen den folgenden IAM-Identitäts- und Registrierungsmethoden auswählen:
+ Verwenden Sie einen IAM-Rollen-ARN zum Authentifizieren von Anforderungen.
+ Verwenden Sie den [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)Befehl und die regelmäßig aktualisierten temporären Anmeldeinformationen, die mit AWS -Security-Token-Service (AWS STS) generiert wurden, um die meisten Registrierungsoptionen manuell zu konfigurieren. Diese Option bietet die höchste Sicherheitsstufe, da die Authentifizierung mithilfe eines temporären Tokens erfolgt, bei dem das Timeout überschritten wird und das regelmäßig aktualisiert werden muss. Diese Option wird für Produktionsbereitstellungen jeder Größe empfohlen. Weitere Informationen finden Sie unter [Verwenden Sie den register-on-premises-instance Befehl (IAM Session ARN), um eine lokale Instanz zu registrieren](register-on-premises-instance-iam-session-arn.md).
+ (Nicht empfohlen) Verwenden Sie einen IAM-Benutzer-ARN, um Anfragen zu authentifizieren.
+ Verwenden Sie den Befehl [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html) für den automatisiertesten Registrierungsprozess. Diese Option sollte nur für Bereitstellungen außerhalb der Produktion verwendet werden, bei denen die Sicherheit weniger wichtig ist. Diese Option ist weniger sicher, da sie statische (permanente) Anmeldeinformationen für die Authentifizierung verwendet. Diese Option eignet sich gut für die Registrierung einer einzelnen lokalen Instanz. Weitere Informationen finden Sie unter [Verwenden Sie den Befehl register (IAM-Benutzer-ARN), um eine lokale Instanz zu registrieren](instances-on-premises-register-instance.md).
+ Verwenden Sie den [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)-Befehl, um die meisten Registrierungsoptionen manuell zu konfigurieren. Für die Registrierung einer kleinen Anzahl lokaler Instances geeignet. Weitere Informationen finden Sie unter [Verwenden Sie den register-on-premises-instance Befehl (IAM-Benutzer-ARN), um eine lokale Instanz zu registrieren](register-on-premises-instance-iam-user-arn.md).
**Topics**
+ [Verwenden Sie den register-on-premises-instance Befehl (IAM Session ARN), um eine lokale Instanz zu registrieren](register-on-premises-instance-iam-session-arn.md)
+ [Verwenden Sie den Befehl register (IAM-Benutzer-ARN), um eine lokale Instanz zu registrieren](instances-on-premises-register-instance.md)
+ [Verwenden Sie den register-on-premises-instance Befehl (IAM-Benutzer-ARN), um eine lokale Instanz zu registrieren](register-on-premises-instance-iam-user-arn.md)
# Verwenden Sie den register-on-premises-instance Befehl (IAM Session ARN), um eine lokale Instanz zu registrieren
Um maximale Kontrolle über die Authentifizierung und Registrierung Ihrer lokalen Instances zu erhalten, können Sie den [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)Befehl und regelmäßig aktualisierte temporäre Anmeldeinformationen verwenden, die mit dem () generiert werden. AWS -Security-Token-Service AWS STS Eine statische IAM-Rolle für die Instance übernimmt die Rolle dieser aktualisierten AWS STS Anmeldeinformationen für die Durchführung von Bereitstellungsvorgängen. CodeDeploy
Diese Methode ist besonders nützlich, wenn Sie eine große Anzahl von Instances registrieren müssen. Sie ermöglicht es Ihnen, den Registrierungsprozess mit zu automatisieren. CodeDeploy Sie können Ihr eigenes Identitäts- und Authentifizierungssystem verwenden, um lokale Instanzen zu authentifizieren und die Anmeldeinformationen für IAM-Sitzungen vom Dienst an die Instanzen zu verteilen, mit denen sie verwendet werden können. CodeDeploy
**Anmerkung**
Alternativ können Sie einen gemeinsam genutzten IAM-Benutzer verwenden, der auf alle lokalen Instanzen verteilt ist, um die AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API aufzurufen, um Sitzungsanmeldeinformationen für lokale Instanzen abzurufen. Diese Methode ist weniger sicher und wird nicht für Produktions- oder geschäftskritische Umgebungen empfohlen.
Verwenden Sie die Informationen in den folgenden Themen, um eine lokale Instanz mithilfe temporärer Sicherheitsanmeldeinformationen zu konfigurieren, die mit generiert wurden. AWS STS
**Topics**
+ [ARN-Registrierungsvoraussetzungen für die IAM-Sitzung](#register-on-premises-instance-iam-session-arn-prerequisites)
+ [Schritt 1: Erstellen Sie die IAM-Rolle, die lokale Instanzen übernehmen sollen](#register-on-premises-instance-iam-session-arn-1)
+ [Schritt 2: Generieren Sie temporäre Anmeldeinformationen für eine einzelne Instanz mit AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ [Schritt 3: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-session-arn-3)
+ [Schritt 4: Bereiten Sie eine lokale Instanz für Bereitstellungen vor CodeDeploy](#register-on-premises-instance-iam-session-arn-4)
+ [Schritt 5: Registrieren Sie die lokale Instanz bei CodeDeploy](#register-on-premises-instance-iam-session-arn-5)
+ [Schritt 6: Kennzeichnen Sie die lokale Instanz](#register-on-premises-instance-iam-session-arn-6)
+ [Schritt 7: Stellen Sie Anwendungsrevisionen auf der lokalen Instanz bereit](#register-on-premises-instance-iam-session-arn-7)
+ [Schritt 8: Verfolgen Sie Bereitstellungen auf der lokalen Instanz](#register-on-premises-instance-iam-session-arn-8)
## ARN-Registrierungsvoraussetzungen für die IAM-Sitzung
Zusätzlich zu den unter [Voraussetzungen für die Konfiguration einer lokalen Instanz](instances-on-premises-prerequisites.md) aufgeführten Voraussetzungen müssen die folgenden zusätzlichen Anforderungen erfüllt sein:
**IAM-Berechtigungen**
Der IAM-Identität, die Sie zur Registrierung einer lokalen Instanz verwenden, müssen Berechtigungen zur Ausführung von Vorgängen erteilt werden. CodeDeploy Stellen Sie sicher, dass die verwaltete **AWSCodeDeployFullAccess**-Richtlinie der IAM-Identität zugeordnet ist. Weitere Informationen finden Sie im *IAM-Benutzerhandbuch* unter [AWS Verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies).
**System zum Aktualisieren temporärer Anmeldeinformationen**
Wenn Sie einen IAM-Sitzungs-ARN zum Registrieren lokaler Instances verwenden, müssen Sie über ein System zum regelmäßigen Aktualisieren der temporären Anmeldeinformationen verfügen. Temporäre Anmeldeinformationen laufen nach einer Stunde ab, oder früher, wenn bei der Generierung der Anmeldeinformationen ein kürzerer Zeitraum angegeben wird. Es gibt zwei Methoden zum Aktualisieren der Anmeldeinformationen:
+ **Methode 1**: Verwenden Sie das Identitäts- und Authentifizierungssystem in Ihrem Unternehmensnetzwerk mit einem CRON-Skript, das regelmäßig das Identitäts- und Authentifizierungssystem abfragt und die neuesten Sitzungsanmeldeinformationen auf die Instance kopiert. Auf diese Weise können Sie Ihre Authentifizierungs- und Identitätsstruktur integrieren, AWS ohne Änderungen am CodeDeploy Agenten oder Dienst vornehmen zu müssen, um die in Ihrer Organisation verwendeten Authentifizierungstypen zu unterstützen.
+ **Methode 2**: Führen Sie regelmäßig einen CRON-Job auf der Instanz aus, um die AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)Aktion aufzurufen und die Sitzungsanmeldedaten in eine Datei zu schreiben, auf die der CodeDeploy Agent zugreifen kann. Bei dieser Methode müssen Sie weiterhin einen IAM-Benutzer verwenden und Anmeldeinformationen auf die lokale Instance kopieren, jedoch können Sie dieselben IAM-Benutzer- und -Anmeldeinformationen in der gesamten Flotte lokaler Instances wiederverwenden.
**Anmerkung**
Unabhängig davon, ob Sie Methode 1 oder 2 verwenden, müssen Sie einen Prozess einrichten, um den CodeDeploy Agenten neu zu starten, nachdem die temporären Anmeldeinformationen aktualisiert wurden, damit die neuen Anmeldeinformationen wirksam werden.
Informationen zum Erstellen und Arbeiten mit AWS STS Anmeldeinformationen finden Sie unter [AWS -Security-Token-Service API-Referenz](https://docs.aws.amazon.com/STS/latest/APIReference/) und [Verwenden temporärer Sicherheitsanmeldedaten, um Zugriff auf AWS Ressourcen anzufordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
## Schritt 1: Erstellen Sie die IAM-Rolle, die lokale Instanzen übernehmen sollen
Sie können die AWS CLI oder die IAM-Konsole verwenden, um eine IAM-Rolle zu erstellen, die von Ihren lokalen Instances zur Authentifizierung und Interaktion verwendet wird. CodeDeploy
Sie müssen nur eine IAM-Rolle erstellen. Jede Ihrer lokalen Instances kann diese Rolle übernehmen, um die temporären Sicherheitsanmeldeinformationen abzurufen, die die dieser Rolle erteilten Berechtigungen gewähren.
Für die Rolle, die Sie erstellen, sind die folgenden Berechtigungen erforderlich, um auf die Dateien zuzugreifen, die für die Installation des Agenten erforderlich sind: CodeDeploy
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Wir empfehlen, diese Richtlinie nur auf die Amazon S3 S3-Buckets zu beschränken, auf die Ihre lokale Instance zugreifen muss. Wenn Sie diese Richtlinie einschränken, stellen Sie sicher, dass Sie Zugriff auf die Amazon S3 S3-Buckets gewähren, die den CodeDeploy Agenten enthalten. Andernfalls kann ein Fehler auftreten, wenn der CodeDeploy Agent auf der lokalen Instance installiert oder aktualisiert wird. Informationen zur Steuerung des Zugriffs auf Amazon S3 S3-Buckets finden Sie unter [Zugriffsberechtigungen für Ihre Amazon S3 S3-Ressourcen verwalten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html).
**So erstellen Sie die IAM-Rolle**
1. Rufen Sie den Befehl [create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html) mit der Option `--role-name` auf, um einen Namen für die IAM-Rolle anzugeben (z. B. `CodeDeployInstanceRole`), und mit der Option `--assume-role-policy-document`, um die Berechtigungen zu erteilen.
Wenn Sie die IAM-Rolle für diese Instance erstellen, können Sie ihr den Namen `CodeDeployInstanceRole` geben und die erforderlichen Berechtigungen in eine Datei mit dem Namen `CodeDeployRolePolicy.json` einschließen:
```
aws iam create-role --role-name CodeDeployInstanceRole --assume-role-policy-document file://CodeDeployRolePolicy.json
```
1. Notieren Sie den Wert des ARN-Felds aus der Ausgabe des Aufrufs für den Befehl **create-role**. Beispiel:
```
arn:aws:iam::123456789012:role/CodeDeployInstanceRole
```
Sie benötigen den Rollen-ARN, wenn Sie die AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API verwenden, um kurzfristige Anmeldeinformationen für jede Instanz zu generieren.
Weitere Informationen zum Erstellen von IAM-Rollen finden Sie unter [Creating a role to delegate permissions to an AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) im *IAM-Benutzerhandbuch*.
[Informationen zum Zuweisen von Berechtigungen zu einer vorhandenen Rolle finden Sie unter [put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)Befehlsreferenz.AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
## Schritt 2: Generieren Sie temporäre Anmeldeinformationen für eine einzelne Instanz mit AWS STS
Bevor Sie die temporären Anmeldeinformationen generieren, die für die Registrierung einer lokalen Instance verwendet werden, müssen Sie die IAM-Identität (Benutzer oder Rolle) erstellen oder auswählen, für die Sie die temporären Anmeldeinformationen generieren. Die Berechtigung `sts:AssumeRole` muss für diese IAM-Identität in die Richtlinieneinstellungen eingeschlossen werden.
Informationen zum Erteilen von `sts:AssumeRole` Berechtigungen für eine IAM-Identität finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen AWS Dienst](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) und. [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)
Es gibt zwei Möglichkeiten zum Generieren der temporären Anmeldeinformationen:
+ Verwenden Sie den Befehl [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) mit dem. AWS CLI Beispiel:
```
aws sts assume-role --role-arn arn:aws:iam::12345ACCOUNT:role/role-arn --role-session-name session-name
```
Wobei Folgendes gilt:
+ *12345ACCOUNT*ist die 12-stellige Kontonummer für Ihre Organisation.
+ *role-arn*ist der ARN der zu übernehmenden Rolle, den Sie generiert haben[Schritt 1: Erstellen Sie die IAM-Rolle, die lokale Instanzen übernehmen sollen](#register-on-premises-instance-iam-session-arn-1).
+ *session-name*ist der Name, den Sie der Rollensitzung geben möchten, die Sie gerade erstellen.
**Anmerkung**
Wenn Sie ein CRON-Skript verwenden, das das Identitäts- und Authentifizierungssystem regelmäßig abfragt und die neuesten Sitzungsanmeldedaten in die Instanz kopiert (Methode 1 zum Aktualisieren temporärer Anmeldeinformationen, beschrieben unter[ARN-Registrierungsvoraussetzungen für die IAM-Sitzung](#register-on-premises-instance-iam-session-arn-prerequisites)), können Sie stattdessen jedes unterstützte AWS SDK zum Aufrufen verwenden. [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)
+ Verwenden Sie ein von bereitgestelltes Tool. AWS
Das aws-codedeploy-session-helper Tool generiert AWS STS Anmeldeinformationen und schreibt sie in eine Datei, die Sie auf der Instanz platzieren. Dieses Tool eignet sich am besten für Methode 2 zum Aktualisieren von temporären Anmeldeinformationen, die unter [ARN-Registrierungsvoraussetzungen für die IAM-Sitzung](#register-on-premises-instance-iam-session-arn-prerequisites) beschrieben wird. Bei dieser Methode wird das aws-codedeploy-session-helper Tool auf jeder Instanz platziert und führt den Befehl mit den Berechtigungen eines IAM-Benutzers aus. Jede Instance verwendet dieselben IAM-Benutzer-Anmeldeinformationen in Verbindung mit diesem Tool.
Weitere Informationen finden Sie im [aws-codedeploy-session-helper](https://github.com/awslabs/aws-codedeploy-samples/tree/master/utilities/aws-codedeploy-session-helper) GitHub Repository.
**Anmerkung**
Nach dem Erstellen der Anmeldeinformationen für die IAM-Sitzung platzieren Sie sie irgendwo auf der lokalen Instance. Im nächsten Schritt konfigurieren Sie den CodeDeploy Agenten so, dass er auf die Anmeldeinformationen an diesem Speicherort zugreift.
Bevor Sie fortfahren, stellen Sie sicher, dass das System, das Sie zur regelmäßigen Aktualisierung der temporären Anmeldeinformationen verwenden, vorhanden ist. Wenn die temporären Anmeldeinformationen nicht aktualisiert werden, schlagen Bereitstellungen auf der lokalen Instance fehl. Weitere Informationen finden Sie im Abschnitt „System to refresh temporary credentials“ unter [ARN-Registrierungsvoraussetzungen für die IAM-Sitzung](#register-on-premises-instance-iam-session-arn-prerequisites).
## Schritt 3: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu
Fügen Sie einer lokalen Instance eine Konfigurationsdatei mithilfe von Root- oder Administratorberechtigungen. Diese Konfigurationsdatei wird verwendet, um die IAM-Anmeldeinformationen und die AWS Zielregion zu deklarieren, für die verwendet werden soll. CodeDeploy Die Datei muss an einem bestimmten Speicherort in der lokalen Instance abgelegt werden. Die Datei muss den ARN der temporären IAM-Sitzung, die zugehörige geheime Schlüssel-ID und den geheimen Zugriffsschlüssel sowie die AWS Zielregion enthalten.
**Hinzufügen eine Konfigurationsdatei**
1. Erstellen Sie eine Datei mit dem Namen `codedeploy.onpremises.yml` (für eine lokale Ubuntu Server- oder RHEL-Instanz) oder `conf.onpremises.yml` (für eine lokale Windows Server-Instanz) am folgenden Speicherort auf der lokalen Instanz:
+ Für Ubuntu Server: `/etc/codedeploy-agent/conf`
+ Für Windows Server: `C:\ProgramData\Amazon\CodeDeploy`
1. Verwenden Sie einen Texteditor, um der neu erstellten `codedeploy.onpremises.yml` Datei (Linux) oder `conf.onpremises.yml` Datei (Windows) die folgenden Informationen hinzuzufügen:
```
---
iam_session_arn: iam-session-arn
aws_credentials_file: credentials-file
region: supported-region
```
Wobei Folgendes gilt:
+ *iam-session-arn*ist der ARN der IAM-Sitzung, den Sie notiert haben. [Schritt 2: Generieren Sie temporäre Anmeldeinformationen für eine einzelne Instanz mit AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ *credentials-file*ist der Speicherort der Anmeldeinformationsdatei für den temporären Sitzungs-ARN, wie unter angegeben[Schritt 2: Generieren Sie temporäre Anmeldeinformationen für eine einzelne Instanz mit AWS STS](#register-on-premises-instance-iam-session-arn-2).
+ *supported-region*ist eine der Regionen, die CodeDeploy unterstützt werden, wie unter [Region und Endgeräte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Allgemeine AWS-Referenz*aufgeführt.
## Schritt 4: Bereiten Sie eine lokale Instanz für Bereitstellungen vor CodeDeploy
**Installieren und konfigurieren Sie das AWS CLI **
Installieren und konfigurieren Sie AWS CLI die lokale Instanz. (Der AWS CLI wird verwendet, um den CodeDeploy Agenten herunterzuladen und auf der lokalen Instanz zu installieren.)
1. Um den AWS CLI auf der lokalen Instanz zu installieren, folgen Sie den Anweisungen unter [Getting Setup with the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) im *AWS Command Line Interface Benutzerhandbuch*.
**Anmerkung**
CodeDeploy Befehle für die Arbeit mit lokalen Instanzen wurden in Version 1.7.19 von verfügbar. AWS CLI Wenn Sie AWS CLI bereits eine Version von installiert haben, können Sie deren Version überprüfen, indem Sie anrufen. **aws --version**
1. Um die AWS CLI On-Premises-Instanz zu konfigurieren, folgen Sie den Anweisungen [unter Konfiguration der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) im *AWS Command Line Interface Benutzerhandbuch*.
**Wichtig**
Achten Sie bei der Konfiguration der AWS CLI (z. B. durch Aufrufen des **aws configure** Befehls) darauf, die geheime Schlüssel-ID und den geheimen Zugriffsschlüssel eines IAM-Benutzers anzugeben, der mindestens über die unter beschriebenen Berechtigungen verfügt. [ARN-Registrierungsvoraussetzungen für die IAM-Sitzung](#register-on-premises-instance-iam-session-arn-prerequisites)
**Legen Sie die AWS\$1REGION Umgebungsvariable fest (nur Ubuntu Server und RHEL)**
Wenn Sie Ubuntu Server oder RHEL nicht auf Ihrer lokalen Instanz ausführen, überspringen Sie diesen Schritt und fahren Sie direkt mit „Agent installieren“ fort. CodeDeploy
Installieren Sie den CodeDeploy Agenten auf einer lokalen Ubuntu-Server- oder RHEL-Instanz und ermöglichen Sie der Instanz, den CodeDeploy Agenten zu aktualisieren, sobald eine neue Version verfügbar ist. Dazu legen Sie die Umgebungsvariable `AWS_REGION` auf der Instance auf die ID einer der von CodeDeploy unterstützten Regionen fest. Wir empfehlen, dass Sie den Wert auf die Region festlegen, in der sich Ihre CodeDeploy Anwendungen, Bereitstellungsgruppen und Anwendungsversionen befinden (z. B.). `us-west-2` Eine Liste der Regionen finden Sie unter [Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in der. *Allgemeine AWS-Referenz*
Rufen Sie zum Festlegen der Umgebungsvariable Folgendes vom Terminal ab:
```
export AWS_REGION=supported-region
```
Wo *supported-region* ist die Regionskennung (zum Beispiel`us-west-2`).
**Installieren Sie den CodeDeploy Agenten**
+ Folgen Sie für eine lokale Ubuntu-Server-Instanz den Anweisungen unter [Installieren Sie den CodeDeploy Agenten für Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md) und kehren Sie dann zu dieser Seite zurück.
+ Folgen Sie für eine lokale RHEL-Instanz den Anweisungen unter und kehren Sie dann zu dieser Seite zurück. [Installieren Sie den CodeDeploy Agenten für Amazon Linux oder RHEL](codedeploy-agent-operations-install-linux.md)
+ Folgen Sie für eine lokale Windows Server-Instanz den Anweisungen unter und kehren Sie dann zu dieser Seite zurück. [Installieren Sie den CodeDeploy Agenten für Windows Server](codedeploy-agent-operations-install-windows.md)
## Schritt 5: Registrieren Sie die lokale Instanz bei CodeDeploy
Bei diesen Anweisungen gehen wir davon aus, dass Sie die Registrierung des lokalen Instance von der lokalen Instance aus durchführen. Sie können eine lokale Instanz von einem separaten Gerät oder einer Instanz aus registrieren, auf der die Instanz AWS CLI installiert und konfiguriert ist.
Verwenden Sie den AWS CLI , um die lokale Instanz zu registrieren, CodeDeploy damit sie in Bereitstellungen verwendet werden kann.
Bevor Sie den verwenden können AWS CLI, benötigen Sie den ARN der temporären Sitzungsanmeldedaten, die Sie in erstellt haben[Schritt 3: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-session-arn-3). Zum Beispiel für eine als `AssetTag12010298EX` identifizierte Instance:
```
arn:sts:iam::123456789012:assumed-role/CodeDeployInstanceRole/AssetTag12010298EX
```
Rufen Sie den Befehl [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html) mit folgenden Angaben auf:
+ Ein eindeutiger Bezeichner für die lokale Instance (mit der Option `--instance-name`).
**Wichtig**
Um die lokale Instance identifizieren zu können, insbesondere für Debugging-Zwecke, empfehlen wir dringend, dass Sie einen Namen verwenden, der einige eindeutige Merkmale der lokalen Instance enthält (z. B. der session-name der STS-Anmeldeinformationen und die Seriennummer oder eine eindeutige interne Asset-ID, falls zutreffend). Wenn Sie eine MAC-Adresse als Namen angeben, beachten Sie, dass MAC-Adressen unzulässige Zeichen enthalten, z. B. Doppelpunkt (:). CodeDeploy Eine Liste der zulässigen Zeichen finden Sie unter [CodeDeploy Kontingente](limits.md).
+ Den ARN der IAM-Sitzung, den Sie zur Authentifizierung mehrerer lokaler Instances in [Schritt 1: Erstellen Sie die IAM-Rolle, die lokale Instanzen übernehmen sollen](#register-on-premises-instance-iam-session-arn-1) eingerichtet haben.
Beispiel:
```
aws deploy register-on-premises-instance --instance-name name-of-instance --iam-session-arn arn:aws:sts::account-id:assumed-role/role-to-assume/session-name
```
Wobei Folgendes gilt:
+ *name-of-instance*ist der Name, den Sie zur Identifizierung der lokalen Instanz verwenden, z. B. `AssetTag12010298EX`
+ *account-id*ist die 12-stellige Konto-ID für Ihre Organisation, z. B. `111222333444`
+ *role-to-assume*ist der Name der IAM-Rolle, die Sie für die Instance erstellt haben, z. B. `CodeDeployInstanceRole`
+ *session-name*ist der Name der Sitzungsrolle, in [Schritt 2: Generieren Sie temporäre Anmeldeinformationen für eine einzelne Instanz mit AWS STS](#register-on-premises-instance-iam-session-arn-2) der Sie angegeben haben.
## Schritt 6: Kennzeichnen Sie die lokale Instanz
Sie können entweder die Konsole AWS CLI oder die CodeDeploy Konsole verwenden, um die lokale Instanz zu taggen. (CodeDeployverwendet lokale Instanz-Tags, um die Bereitstellungsziele während einer Bereitstellung zu identifizieren.)
**So markieren Sie eine lokale Instance (CLI):**
+ Rufen Sie den Befehl [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html) auf und geben Sie Folgendes an:
+ Der eindeutige Bezeichner für die lokale Instance (mit der Option `--instance-names`).
+ Der Name des Tag-Schlüssels und des Tag-Werts der lokalen Instance, die Sie verwenden möchten (mit der Option `--tags`). Sie müssen sowohl einen Namen als auch einen Wert angeben. CodeDeploy erlaubt keine lokalen Instanz-Tags, die nur Werte enthalten.
Beispiel:
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**So markieren Sie eine lokale Instance (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 **Lokale Instanzen** aus.
1. Klicken Sie in der Liste der lokalen Instances auf den Namen der lokalen Instance, die Sie markieren möchten.
1. Wählen Sie in der Liste der Tags den gewünschten Tag-Schlüssel und -Wert aus oder geben Sie ihn ein. Nachdem Sie den Tag-Schlüssel und den Tag-Wert eingegeben haben, wird eine weitere Zeile angezeigt. Sie können das für bis zu 10 Tags wiederholen. Klicken Sie zum Entfernen eines Tags auf **Remove (Entfernen)**.
1. Wählen Sie nach dem Hinzufügen der Tags die Option **Update Tags**.
## Schritt 7: Stellen Sie Anwendungsrevisionen auf der lokalen Instanz bereit
Sie können nun auf den registrierten und mit einem Tag markierten lokalen Instances Anwendungsrevisionen bereitstellen.
Sie stellen Anwendungsrevisionen auf lokale Instances auf ähnliche Weise bereit, wie Sie Anwendungsrevisionen für Amazon EC2 EC2-Instances bereitstellen. Detaillierte Anweisungen finden Sie unter [Erstellen Sie eine Bereitstellung mit CodeDeploy](deployments-create.md). Diese Anweisungen enthalten einen Link zu den Voraussetzungen, wie dem Erstellen einer Anwendung, Erstellen einer Bereitstellungsgruppe und Vorbereiten einer Anwendungsrevision. Wenn Sie eine einfache Beispielanwendungsrevision bereitstellen möchten, können Sie die unter [Schritt 2: Erstellen Sie eine Version der Beispielanwendung](tutorials-on-premises-instance-2-create-sample-revision.md) im [Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md) beschriebene Revision verwenden.
**Wichtig**
Wenn Sie eine CodeDeploy Servicerolle im Rahmen der Erstellung einer Bereitstellungsgruppe für lokale Instances wiederverwenden, müssen Sie die Richtlinienerklärung der Servicerolle in diesen `Action` Teil aufnehmen`Tag:get*`. Weitere Informationen finden Sie unter [Schritt 2: Erstellen Sie eine Servicerolle für CodeDeploy](getting-started-create-service-role.md).
## Schritt 8: Verfolgen Sie Bereitstellungen auf der lokalen Instanz
Nachdem Sie eine Anwendungsrevision auf einer registrierten und markierten lokalen Instance bereitgestellt haben, können Sie den Fortschritt der Bereitstellung nachverfolgen.
Sie verfolgen Bereitstellungen für lokale Instances auf ähnliche Weise wie die Nachverfolgung von Bereitstellungen auf Amazon EC2 EC2-Instances. Detaillierte Anweisungen finden Sie unter [CodeDeploy Bereitstellungsdetails anzeigen](deployments-view-details.md).
# Verwenden Sie den Befehl register (IAM-Benutzer-ARN), um eine lokale Instanz zu registrieren
**Wichtig**
Die Registrierung einer Instanz mithilfe eines IAM-Benutzers wird nicht empfohlen, da statische (permanente) Anmeldeinformationen für die Authentifizierung verwendet werden. Aus Sicherheitsgründen empfehlen wir, eine Instance mit temporären Anmeldeinformationen für die Authentifizierung zu registrieren. Weitere Informationen finden Sie unter [Verwenden Sie den register-on-premises-instance Befehl (IAM Session ARN), um eine lokale Instanz zu registrieren](register-on-premises-instance-iam-session-arn.md).
**Wichtig**
Stellen Sie sicher, dass Sie über einen Plan zur Rotation der Zugriffsschlüssel (permanente Anmeldeinformationen) des IAM-Benutzers verfügen. Weitere Informationen finden Sie unter [Rotieren von Zugriffsschlüsseln](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
In diesem Abschnitt wird beschrieben, wie Sie eine lokale Instance konfigurieren und registrieren und sie mit CodeDeploy mit dem geringsten Aufwand mit Tags versehen. Der Befehl **register** ist besonders nützlich, wenn Sie mit einer einzigen oder einer kleinen Anzahl von lokalen Instances arbeiten. Sie können den **register** Befehl nur verwenden, wenn Sie einen IAM-Benutzer-ARN zur Authentifizierung einer Instance verwenden. Sie können den **register** Befehl nicht mit einem IAM-Sitzungs-ARN zur Authentifizierung verwenden.
Wenn Sie den **register** Befehl verwenden, können Sie Folgendes CodeDeploy tun lassen:
+ Erstellen Sie einen IAM-Benutzer AWS Identity and Access Management für die lokale Instanz, falls Sie keinen mit dem Befehl angeben.
+ Speichern Sie die Anmeldeinformationen des IAM-Benutzers in einer lokalen Instanzkonfigurationsdatei.
+ Registrieren Sie die lokale Instanz bei. CodeDeploy
+ Fügen Sie Tags zur lokalen Instance hinzu, indem Sie diese als Teil des Befehls angeben.
**Anmerkung**
Der [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)Befehl ist eine Alternative zum Befehl [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html). Sie verwenden den Befehl **register-on-premises-instance**, wenn Sie eine Instance vor Ort konfigurieren möchten und sie bei CodeDeploy eigenständig registrieren und mit Tags versehen möchten. Der **register-on-premises-instance** Befehl bietet Ihnen auch die Möglichkeit, anstelle eines IAM-Benutzer-ARN einen IAM-Sitzungs-ARN zur Registrierung von Instances zu verwenden. Dieser Ansatz bietet einen großen Vorteil, wenn Sie große Serverfarmen für lokale Instances haben. Insbesondere können Sie einen einzelnen IAM-Sitzungs-ARN verwenden, um mehrere Instanzen zu authentifizieren, anstatt nacheinander einen IAM-Benutzer für jede lokale Instanz erstellen zu müssen. Weitere Informationen erhalten Sie unter [Verwenden Sie den register-on-premises-instance Befehl (IAM-Benutzer-ARN), um eine lokale Instanz zu registrieren](register-on-premises-instance-iam-user-arn.md) und [Verwenden Sie den register-on-premises-instance Befehl (IAM Session ARN), um eine lokale Instanz zu registrieren](register-on-premises-instance-iam-session-arn.md).
**Topics**
+ [Schritt 1: Installieren und konfigurieren Sie die lokale Instanz AWS CLI](#instances-on-premises-register-instance-1-install-cli)
+ [Schritt 2: Rufen Sie den Befehl register auf](#instances-on-premises-register-instance-2-register-command)
+ [Schritt 3: Rufen Sie den Befehl install auf](#instances-on-premises-register-instance-3-install-command)
+ [Schritt 4: Stellen Sie Anwendungsrevisionen auf der lokalen Instanz bereit](#instances-on-premises-register-instance-4-deploy-revision)
+ [Schritt 5: Verfolgen Sie die Bereitstellungen auf der lokalen Instanz](#instances-on-premises-register-instance-5-track-deployment)
## Schritt 1: Installieren und konfigurieren Sie die lokale Instanz AWS CLI
1. Installieren Sie die AWS CLI auf der lokalen Instanz. Folgen Sie den Anweisungen [unter Getting Setup with the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) im *AWS Command Line Interface Benutzerhandbuch*.
**Anmerkung**
CodeDeploy Befehle für die Arbeit mit lokalen Instanzen sind in AWS CLI Version 1.7.19 und höher verfügbar. Wenn Sie das AWS CLI bereits installiert haben, rufen Sie an, **aws --version** um die Version zu überprüfen.
1. Konfigurieren Sie AWS CLI die lokale Instanz. Folgen Sie den Anweisungen [unter Konfiguration AWS CLI der AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *Bedienungsanleitung*.
**Wichtig**
Achten Sie bei der Konfiguration AWS CLI (z. B. durch Aufrufen des **aws configure** Befehls) darauf, die geheime Schlüssel-ID und den geheimen Zugriffsschlüssel eines IAM-Benutzers anzugeben, der zusätzlich zu den unter angegebenen Berechtigungen mindestens über die folgenden AWS Zugriffsberechtigungen verfügt. [Voraussetzungen für die Konfiguration einer lokalen Instanz](instances-on-premises-prerequisites.md) Dadurch ist es möglich, den CodeDeploy Agenten auf die lokale Instanz herunterzuladen und zu installieren. Die Zugriffsberechtigungen können etwa wie folgt aussehen:
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:getTagKeys",
"tag:getTagValues",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
Wenn Sie beim Versuch, auf einen der oben aufgeführten Amazon S3 S3-Buckets zuzugreifen, die Fehler „Zugriff verweigert“ sehen, versuchen Sie, den `/*` Teil des Ressourcen-ARN des Buckets wegzulassen, zum Beispiel. `arn:aws:s3:::aws-codedeploy-sa-east-1`
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket2/*"
]
}
]
}
```
## Schritt 2: Rufen Sie den Befehl register auf
Bei diesem Schritt gehen wir davon aus, dass Sie die Registrierung des lokalen Instance von der lokalen Instance aus durchführen. Sie können eine lokale Instanz auch von einem separaten Gerät oder einer Instanz aus registrieren, auf der sie wie im vorherigen Schritt beschrieben AWS CLI installiert und konfiguriert ist.
Rufen Sie AWS CLI mit dem den Befehl [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html) auf und geben Sie Folgendes an:
+ Ein Name, der die lokale Instanz eindeutig identifiziert CodeDeploy (mit der `--instance-name` Option).
**Wichtig**
Um die lokale Instance später identifizieren zu können, insbesondere für Debugging-Zwecke, empfehlen wir dringend, dass Sie einen Namen verwenden, die einige eindeutige Merkmale der lokalen Instance enthält (z. B. die Seriennummer oder eine eindeutige interne Asset-ID, falls zutreffend). Wenn Sie eine MAC-Adresse für einen Namen angeben, beachten Sie, dass MAC-Adressen unzulässige Zeichen enthalten, z. B. einen Doppelpunkt (`:`). CodeDeploy Eine Liste der zulässigen Zeichen finden Sie unter [CodeDeploy Kontingente](limits.md).
+ Optional der ARN eines vorhandenen IAM-Benutzers, den Sie dieser lokalen Instanz zuordnen möchten (mit der `--iam-user-arn` Option). **Um den ARN eines IAM-Benutzers abzurufen, rufen Sie den Befehl [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html) auf, oder wählen Sie den IAM-Benutzernamen im Abschnitt **Benutzer** der IAM-Konsole aus und suchen Sie dann im Abschnitt Zusammenfassung nach dem Wert **Benutzer-ARN**.** Wenn diese Option nicht angegeben ist, CodeDeploy wird in Ihrem Namen ein IAM-Benutzer in Ihrem AWS Konto erstellt und dieser der lokalen Instanz zugeordnet.
**Wichtig**
Wenn Sie die Option `--iam-user-arn` festlegen, müssen Sie die lokale Instance-Konfigurationsdatei manuell erstellen, wie in [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](register-on-premises-instance-iam-user-arn.md#register-on-premises-instance-iam-user-arn-4) beschrieben.
Sie können nur einen IAM-Benutzer nur einer lokalen Instanz zuordnen. Der Versuch, einen einzelnen IAM-Benutzer mehreren lokalen Instanzen zuzuordnen, kann zu Fehlern, fehlgeschlagenen Bereitstellungen für diese lokalen Instanzen oder Bereitstellungen für diese lokalen Instanzen führen, die in einem dauerhaften Status „Ausstehend“ hängen bleiben.
+ Optional ein Satz von lokalen Instance-Tags (mit der `--tags` Option), anhand derer der Satz von Amazon EC2 EC2-Instances identifiziert CodeDeploy wird, auf denen die Bereitstellung erfolgen soll. Geben Sie jeden Tag mit `Key=tag-key,Value=tag-value` an (z. B. `Key=Name,Value=Beta Key=Name,Value=WestRegion`). Wenn diese Option nicht angegeben ist, werden keine Tags registriert. Um Tags später zu registrieren, rufen Sie den Befehl [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html) auf.
+ Optional die AWS Region, in der die lokale Instanz registriert werden soll CodeDeploy (mit der Option). `--region` Dabei muss es sich um eine der unterstützten Regionen handeln, die unter [Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in aufgeführt sind *Allgemeine AWS-Referenz*(z. B.`us-west-2`). Wenn diese Option nicht angegeben ist, wird die AWS Standardregion verwendet, die dem aufrufenden IAM-Benutzer zugeordnet ist.
Beispiel:
```
aws deploy register --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem --tags Key=Name,Value=CodeDeployDemo-OnPrem --region us-west-2
```
Der Befehl **register** hat folgende Auswirkungen:
1. Wenn kein vorhandener IAM-Benutzer angegeben ist, wird ein IAM-Benutzer erstellt, diesem die erforderlichen Berechtigungen zugewiesen und ein entsprechender geheimer Schlüssel und ein geheimer Zugriffsschlüssel generiert. Die lokale Instanz verwendet diesen IAM-Benutzer und seine Berechtigungen und Anmeldeinformationen, um sich zu authentifizieren und mit ihm zu interagieren. CodeDeploy
1. Registriert die lokale Instanz bei. CodeDeploy
1. Falls angegeben, ordnet es CodeDeploy den Tags, die mit der `--tags` Option angegeben sind, dem Namen der registrierten lokalen Instanz zu.
1. Wenn ein IAM-Benutzer erstellt wurde, wird auch die erforderliche Konfigurationsdatei in demselben Verzeichnis erstellt, aus dem der **register** Befehl aufgerufen wurde.
Wenn dieser Befehl Fehler erkennt, wird eine Fehlermeldung angezeigt, in der beschrieben wird, wie Sie die verbleibenden Schritte manuell durchführen können. Andernfalls wird eine Erfolgsmeldung angezeigt, die beschreibt, wie Sie den Befehl **install** aufrufen, wie im nächsten Schritt beschrieben.
## Schritt 3: Rufen Sie den Befehl install auf
Rufen Sie in der lokalen Instanz den Befehl [install AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/deploy/install.html) mit auf und geben Sie Folgendes an:
+ Der Pfad zur Konfigurationsdatei (mit der Option `--config-file`).
+ Optional, ob die Konfigurationsdatei ersetzt werden soll, die bereits auf der lokalen Instance vorhanden ist (mit der `--override-config` Option). Wenn nicht angegeben, wird die vorhandene Konfigurationsdatei nicht ersetzt.
+ Optional die AWS Region, in der die lokale Instanz registriert werden soll CodeDeploy (mit der `--region` Option). Dabei muss es sich um eine der unterstützten Regionen handeln, die unter [Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in aufgeführt sind *Allgemeine AWS-Referenz*(z. B.`us-west-2`). Wenn diese Option nicht angegeben ist, wird die AWS Standardregion verwendet, die dem aufrufenden IAM-Benutzer zugeordnet ist.
+ Optional ein benutzerdefinierter Speicherort, von dem aus der CodeDeploy Agent installiert werden soll (mit der `--agent-installer` Option). Diese Option ist nützlich, um eine benutzerdefinierte Version des CodeDeploy Agenten zu installieren, die CodeDeploy nicht offiziell unterstützt wird (z. B. eine benutzerdefinierte Version, die auf dem [CodeDeployAgenten-Repository](https://github.com/aws/aws-codedeploy-agent) in basiert GitHub). Der Wert muss der Pfad zu einem Amazon S3 S3-Bucket sein, der entweder Folgendes enthält:
+ Ein CodeDeploy Agenten-Installationsskript (für Linux- oder UNIX-basierte Betriebssysteme, ähnlich der Installationsdatei im [CodeDeployAgenten-Repository](https://github.com/aws/aws-codedeploy-agent/blob/master/bin/install) unter). GitHub
+ Eine CodeDeploy Agenteninstallationspaketdatei (.msi) (für Windows-basierte Betriebssysteme).
Wenn diese Option nicht angegeben ist, versucht CodeDeploy es nach besten Kräften, von seinem eigenen Standort aus eine offiziell unterstützte Version des CodeDeploy Agenten zu installieren, die mit dem Betriebssystem auf der lokalen Instanz kompatibel ist.
Beispiel:
```
aws deploy install --override-config --config-file /tmp/codedeploy.onpremises.yml --region us-west-2 --agent-installer s3://aws-codedeploy-us-west-2/latest/codedeploy-agent.msi
```
Der Befehl **install** hat folgende Auswirkungen:
1. Prüft, ob es sich bei der lokalen Instance um eine Amazon EC2 EC2-Instance handelt. Wenn dies der Fall ist, wird eine Fehlermeldung angezeigt.
1. Kopiert die Konfigurationsdatei für lokale Instances vom angegebenen Speicherort auf der Instance an den Speicherort, an dem der CodeDeploy Agent sie voraussichtlich finden wird, sofern sich die Datei nicht bereits an diesem Speicherort befindet.
Für Ubuntu Server und Red Hat Enterprise Linux (RHEL) ist `/etc/codedeploy-agent/conf` dies/. `codedeploy.onpremises.yml`
Für Windows Server ist dies`C:\ProgramData\Amazon\CodeDeploy`\$1`conf.onpremises.yml`.
Wenn die Option `--override-config` angegeben wurde, wird die Datei erstellt oder überschrieben.
1. Installiert den CodeDeploy Agenten auf der lokalen Instanz und startet ihn dann.
## Schritt 4: Stellen Sie Anwendungsrevisionen auf der lokalen Instanz bereit
Sie können nun auf den registrierten und mit einem Tag markierten lokalen Instances Anwendungsrevisionen bereitstellen.
Sie stellen Anwendungsrevisionen auf lokale Instances auf ähnliche Weise bereit, wie Sie Anwendungsrevisionen für Amazon EC2 EC2-Instances bereitstellen. Detaillierte Anweisungen finden Sie unter [Erstellen Sie eine Bereitstellung mit CodeDeploy](deployments-create.md). Diese Anweisungen bieten einen Link zu den Voraussetzungen, wie dem Erstellen einer Anwendung, Erstellen einer Bereitstellungsgruppe und Vorbereiten einer Anwendungsrevision. Wenn Sie eine einfache Beispielanwendungsrevision bereitstellen möchten, können Sie die unter [Schritt 2: Erstellen Sie eine Version der Beispielanwendung](tutorials-on-premises-instance-2-create-sample-revision.md) im [Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md) beschriebene Revision verwenden.
**Wichtig**
Wenn Sie eine bestehende CodeDeploy Servicerolle im Rahmen der Erstellung einer Bereitstellungsgruppe für lokale Instances wiederverwenden, müssen Sie die Richtlinienerklärung der Servicerolle in diesen `Action` Teil aufnehmen`Tag:get*`. Weitere Informationen finden Sie unter [Schritt 2: Erstellen Sie eine Servicerolle für CodeDeploy](getting-started-create-service-role.md).
## Schritt 5: Verfolgen Sie die Bereitstellungen auf der lokalen Instanz
Nachdem Sie eine Anwendungsrevision auf einer registrierten und markierten lokalen Instance bereitgestellt haben, können Sie den Fortschritt der Bereitstellung nachverfolgen.
Sie verfolgen Bereitstellungen für lokale Instances auf ähnliche Weise wie die Nachverfolgung von Bereitstellungen auf Amazon EC2 EC2-Instances. Detaillierte Anweisungen finden Sie unter [CodeDeploy Bereitstellungsdetails anzeigen](deployments-view-details.md).
Weitere Optionen finden Sie unter [Verwaltung von Vorgängen für lokale Instanzen in CodeDeploy](on-premises-instances-operations.md).
# Verwenden Sie den register-on-premises-instance Befehl (IAM-Benutzer-ARN), um eine lokale Instanz zu registrieren
**Wichtig**
Die Registrierung einer Instanz mithilfe eines IAM-Benutzers wird nicht empfohlen, da statische (permanente) Anmeldeinformationen für die Authentifizierung verwendet werden. Aus Sicherheitsgründen empfehlen wir, eine Instance mit temporären Anmeldeinformationen für die Authentifizierung zu registrieren. Weitere Informationen finden Sie unter [Verwenden Sie den register-on-premises-instance Befehl (IAM Session ARN), um eine lokale Instanz zu registrieren](register-on-premises-instance-iam-session-arn.md).
**Wichtig**
Stellen Sie sicher, dass Sie über einen Plan zur Rotation der Zugriffsschlüssel (permanente Anmeldeinformationen) des IAM-Benutzers verfügen. Weitere Informationen finden Sie unter [Rotieren von Zugriffsschlüsseln](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
Befolgen Sie diese Anweisungen zum Konfigurieren einer lokalen Instance. Registrieren Sie sie und markieren Sie sie weitestgehend selbst mit CodeDeploy , wobei Sie die statischen IAM-Benutzeranmeldeinformationen für die Authentifizierung verwenden.
**Topics**
+ [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1)
+ [Schritt 2: Weisen Sie dem IAM-Benutzer Berechtigungen zu](#register-on-premises-instance-iam-user-arn-2)
+ [Schritt 3: Holen Sie sich die IAM-Benutzeranmeldedaten](#register-on-premises-instance-iam-user-arn-3)
+ [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4)
+ [Schritt 5: Installieren und konfigurieren Sie AWS CLI](#register-on-premises-instance-iam-user-arn-5)
+ [Schritt 6: Legen Sie die AWS\$1REGION Umgebungsvariable fest (nur Ubuntu Server und RHEL)](#register-on-premises-instance-iam-user-arn-6)
+ [Schritt 7: Installieren Sie den CodeDeploy Agenten](#register-on-premises-instance-iam-user-arn-7)
+ [Schritt 8: Registrieren Sie die lokale Instanz bei CodeDeploy](#register-on-premises-instance-iam-user-arn-8)
+ [Schritt 9: Kennzeichnen Sie die lokale Instanz](#register-on-premises-instance-iam-user-arn-9)
+ [Schritt 10: Stellen Sie Anwendungsrevisionen auf der lokalen Instanz bereit](#register-on-premises-instance-iam-user-arn-10)
+ [Schritt 11: Verfolgen Sie Bereitstellungen auf der lokalen Instanz](#register-on-premises-instance-iam-user-arn-11)
## Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz
Erstellen Sie einen IAM-Benutzer, den die lokale Instanz zur Authentifizierung und Interaktion verwendet. CodeDeploy
**Wichtig**
Sie müssen für jede teilnehmende lokale Instanz einen eigenen IAM-Benutzer erstellen. Wenn Sie versuchen, einen einzelnen IAM-Benutzer für mehrere lokale Instanzen wiederzuverwenden, können Sie diese lokalen Instanzen möglicherweise nicht erfolgreich registrieren oder mit Tags versehen. CodeDeploy Bereitstellungen auf solchen lokalen Instances können in einem dauerhaften schwebenden Zustand hängenbleiben oder ganz fehlschlagen.
Wir empfehlen, dem IAM-Benutzer einen Namen zuzuweisen, der seinen Zweck identifiziert, z. B. -. CodeDeployUser OnPrem
Sie können die AWS CLI oder die IAM-Konsole verwenden, um einen IAM-Benutzer zu erstellen. Weitere Informationen finden Sie unter [Einen IAM-Benutzer in](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) Ihrem Konto erstellen. AWS
**Wichtig**
Unabhängig davon, ob Sie die AWS CLI oder die IAM-Konsole verwenden, um einen neuen IAM-Benutzer zu erstellen, notieren Sie sich den Benutzer-ARN, der für den Benutzer bereitgestellt wurde. Diese Informationen sind später in [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4) und [Schritt 8: Registrieren Sie die lokale Instanz bei CodeDeploy](#register-on-premises-instance-iam-user-arn-8) erforderlich.
## Schritt 2: Weisen Sie dem IAM-Benutzer Berechtigungen zu
Wenn Ihre lokale Instance Anwendungsrevisionen aus Amazon S3 S3-Buckets bereitstellt, müssen Sie dem IAM-Benutzer die Berechtigungen für die Interaktion mit diesen Buckets zuweisen. Sie können die AWS CLI oder die IAM-Konsole verwenden, um Berechtigungen zuzuweisen.
**Anmerkung**
Wenn Sie Anwendungsrevisionen nur aus GitHub Repositorys bereitstellen möchten, überspringen Sie diesen Schritt und wechseln Sie direkt zu. [Schritt 3: Holen Sie sich die IAM-Benutzeranmeldedaten](#register-on-premises-instance-iam-user-arn-3) (Sie benötigen weiterhin Informationen über den IAM-Benutzer, in dem Sie ihn erstellt haben. [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1) Er wird in späteren Schritten verwendet.)
**So weisen Sie Berechtigungen (CLI) zu:**
1. Erstellen Sie eine Datei mit den folgenden Richtlinieninhalten auf der Amazon EC2 EC2-Instance oder dem Gerät, das Sie zum Aufrufen von verwenden. AWS CLI Verwenden Sie einen Dateinamen wie etwa **CodeDeploy-OnPrem-Permissions.json** und speichern Sie die Datei.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
**Anmerkung**
Wir empfehlen, dass Sie diese Richtlinie nur auf die Amazon S3 S3-Buckets beschränken, auf die Ihre lokale Instance zugreifen muss. Wenn Sie diese Richtlinie einschränken, stellen Sie sicher, dass Sie auch Zugriff auf die Amazon S3 S3-Buckets gewähren, die den AWS CodeDeploy Agenten enthalten. Andernfalls kann ein Fehler auftreten, wenn der CodeDeploy Agent auf der zugehörigen lokalen Instance installiert oder aktualisiert wird.
Beispiel:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
1. Rufen Sie den [put-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-user-policy.html)Befehl auf und geben Sie den Namen des IAM-Benutzers (mit der `--user-name` Option), einen Namen für die Richtlinie (mit der `--policy-name` Option) und den Pfad zum neu erstellten Richtliniendokument (mit der `--policy-document` Option) an. Wenn sich z. B. die Datei **CodeDeploy-OnPrem-Permissions.json** im selben Verzeichnis (Ordner) befindet, aus dem Sie diesen Befehl aufrufen:
**Wichtig**
Achten Sie darauf, dass `file://` vor dem Dateinamen steht. Dies ist bei diesem Befehl erforderlich.
```
aws iam put-user-policy --user-name CodeDeployUser-OnPrem --policy-name CodeDeploy-OnPrem-Permissions --policy-document file://CodeDeploy-OnPrem-Permissions.json
```
**So weisen Sie Berechtigungen (Konsole) zu:**
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie im Navigationsbereich **Richtlinien** und dann **Richtlinie erstellen**. (Wenn die Schaltfläche **Get Started (Erste Schritte)** angezeigt wird, klicken Sie darauf und wählen Sie anschließend **Create Policy (Richtlinie erstellen)** aus.)
1. Klicken Sie neben **Create Your Own Policy** auf **Select**.
1. Geben Sie in das Feld **Policy Name** einen Namen für diese Richtlinie ein (z. B. **CodeDeploy-OnPrem-Permissions**).
1. Geben oder fügen Sie in das Feld **Policy Document** den folgenden Berechtigungsausdruck ein, der es AWS CodeDeploy ermöglicht, Anwendungsrevisionen von jedem in der Richtlinie angegebenen Amazon S3 S3-Bucket für die lokale Instance im Namen des IAM-Benutzers bereitzustellen:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
1. Wählen Sie **Richtlinie erstellen** aus.
1. Klicken Sie im Navigationsbereich auf **Users (Benutzer)**.
1. Suchen Sie in der Benutzerliste nach dem Namen des IAM-Benutzers, in dem Sie ihn erstellt haben, und wählen Sie ihn aus. [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1)
1. Wählen Sie auf der Registerkarte **Permissions** unter **Managed Policies** die Option **Attach Policy**.
1. Wählen Sie die Richtlinie mit dem Namen **CodeDeploy-OnPrem-Permissions** aus, und klicken Sie dann auf **Attach Policy (Richtlinie anfügen)**.
## Schritt 3: Holen Sie sich die IAM-Benutzeranmeldedaten
Rufen Sie die geheime Schlüssel-ID und den geheimen Zugriffsschlüssel für den IAM-Benutzer ab. Sie benötigen diese für [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4). Sie können die AWS CLI oder die IAM-Konsole verwenden, um die geheime Schlüssel-ID und den geheimen Zugriffsschlüssel abzurufen.
**Anmerkung**
Wenn Sie die geheime Schlüssel-ID und den geheimen Zugriffsschlüssel bereits haben, überspringen Sie diesen Schritt und gehen Sie direkt zu [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4) über.
Benutzer benötigen programmgesteuerten Zugriff, wenn sie mit AWS außerhalb des interagieren möchten. AWS-Managementkonsole Die Art und Weise, wie programmatischer Zugriff gewährt wird, hängt von der Art des Benutzers ab, der zugreift. AWS
Um Benutzern programmgesteuerten Zugriff zu gewähren, wählen Sie eine der folgenden Optionen.
****
| Welcher Benutzer benötigt programmgesteuerten Zugriff? | Bis | Von |
| --- | --- | --- |
| IAM | (Empfohlen) Verwenden Sie Konsolenanmeldeinformationen als temporäre Anmeldeinformationen, um programmatische Anfragen an AWS CLI AWS SDKs, oder zu signieren. AWS APIs | Befolgen Sie die Anweisungen für die Schnittstelle, die Sie verwenden möchten. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| Mitarbeiteridentität (Benutzer, die in IAM Identity Center verwaltet werden) | Verwenden Sie temporäre Anmeldeinformationen, um programmatische Anfragen an das AWS CLI AWS SDKs, oder AWS APIs zu signieren. | Befolgen Sie die Anweisungen für die Schnittstelle, die Sie verwenden möchten. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| IAM | Verwenden Sie temporäre Anmeldeinformationen, um programmatische Anfragen an das AWS CLI AWS SDKs, oder zu signieren. AWS APIs | Folgen Sie den Anweisungen unter [Verwenden temporärer Anmeldeinformationen mit AWS Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) im IAM-Benutzerhandbuch. |
| IAM | (Nicht empfohlen)Verwenden Sie langfristige Anmeldeinformationen, um programmatische Anfragen an das AWS CLI AWS SDKs, oder zu signieren. AWS APIs | Befolgen Sie die Anweisungen für die Schnittstelle, die Sie verwenden möchten. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
**So rufen Sie Anmeldeinformationen (CLI) ab:**
1. Rufen Sie den [list-access-keys](https://docs.aws.amazon.com/cli/latest/reference/iam/list-access-keys.html)Befehl auf, geben Sie den Namen des IAM-Benutzers an (mit der `--user-name` Option) und fragen Sie nur den Zugriffsschlüssel ab IDs (mit den Optionen `--query` und`--output`). Beispiel:
```
aws iam list-access-keys --user-name CodeDeployUser-OnPrem --query "AccessKeyMetadata[*].AccessKeyId" --output text
```
1. Wenn in der Ausgabe keine Schlüssel oder nur Informationen zu einem Schlüssel in der Ausgabe erscheinen, rufen Sie den [create-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html)Befehl auf und geben Sie den Namen des IAM-Benutzers an (mit der `--user-name` Option):
```
aws iam create-access-key --user-name CodeDeployUser-OnPrem
```
Notieren Sie den Wert der Felder `AccessKeyId` und `SecretAccessKey` aus der Ausgabe des Aufrufs des Befehls **create-access-key**. Sie benötigen diese Informationen in [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4).
**Wichtig**
Das ist das einzige Mal, dass Sie Zugriff auf den geheimen Zugriffsschlüssel erhalten. Wenn Sie diesen geheimen Zugriffsschlüssel vergessen oder verlieren, müssen Sie einen neuen Zugriffsschlüssel erstellen, indem Sie die Schritte in [Schritt 3: Holen Sie sich die IAM-Benutzeranmeldedaten](#register-on-premises-instance-iam-user-arn-3) befolgen.
1. Wenn bereits zwei Zugriffsschlüssel aufgeführt sind, müssen Sie einen davon löschen, indem Sie den [delete-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html)Befehl aufrufen und dabei den Namen des IAM-Benutzers (mit der `--user-name` Option) und die ID des zu löschenden Zugriffsschlüssels (mit der `--access-key-id` Option) angeben. Rufen Sie dann den Befehl **create-access-key** auf, wie weiter oben in diesem Schritt beschrieben. Es folgt ein Beispiel für einen Aufruf des Befehls **delete-access-key**:
```
aws iam delete-access-key --user-name CodeDeployUser-OnPrem --access-key-id access-key-ID
```
**Wichtig**
Wenn Sie den **delete-access-key** Befehl zum Löschen eines dieser Zugriffsschlüssel aufrufen und eine lokale Instanz diesen Zugriffsschlüssel bereits wie unter beschrieben verwendet[Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4), müssen Sie die Anweisungen unter [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4) erneut befolgen, um eine andere Zugriffsschlüssel-ID und einen anderen geheimen Zugriffsschlüssel für diesen IAM-Benutzer anzugeben. Andernfalls bleiben Bereitstellungen auf dieser lokalen Instance in einem dauerhaften schwebenden Zustand hängen oder schlagen ganz fehl.
**So rufen Sie Anmeldeinformationen (Konsole) ab:**
1.
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wenn die Benutzerliste nicht angezeigt wird, klicken Sie im Navigationsbereich auf **Users**.
1. Suchen Sie in der Benutzerliste nach dem Namen des IAM-Benutzers, in dem Sie ihn erstellt haben, und wählen Sie ihn aus. [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1)
1. Wählen Sie auf der Registerkarte **Security credentials**, wenn kein oder nur ein Schlüssel aufgelistet ist, die Option **Create access key**.
Wenn zwei Zugriffsschlüssel aufgelistet sind, müssen Sie einen davon löschen. Wählen Sie **Delete** neben einem der Zugriffsschlüssel, und wählen Sie dann **Create access key**.
**Wichtig**
Wenn Sie neben einem dieser Zugriffsschlüssel die Option **Löschen** auswählen und eine lokale Instanz diesen Zugriffsschlüssel bereits wie unter beschrieben verwendet[Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4), müssen Sie [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4) erneut den Anweisungen unter folgen, um eine andere Zugriffsschlüssel-ID und einen anderen geheimen Zugriffsschlüssel für diesen IAM-Benutzer anzugeben. Andernfalls bleiben Bereitstellungen auf dieser lokalen Instance in einem dauerhaften schwebenden Zustand hängen oder schlagen ganz fehl.
1. Wählen Sie **Show**, und notieren Sie sich die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel. Diese Informationen sind für den nächsten Schritt erforderlich. Alternativ können Sie **Download .csv file** wählen, um eine Kopie der Zugriffsschlüssel-ID und des geheimen Zugriffsschlüssels zu speichern.
**Wichtig**
Wenn Sie sich die Anmeldeinformationen nicht notieren oder herunterladen, ist es das einzige Mal, dass Sie Zugriff auf diesen geheimen Zugriffsschlüssel haben. Wenn Sie diesen geheimen Zugriffsschlüssel vergessen oder verlieren, müssen Sie einen neuen Zugriffsschlüssel erstellen, indem Sie die Schritte in [Schritt 3: Holen Sie sich die IAM-Benutzeranmeldedaten](#register-on-premises-instance-iam-user-arn-3) befolgen.
1. Wählen Sie „**Schließen**“, um zur Seite „**Benutzer“ > *IAM User Name*** zurückzukehren.
## Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu
Fügen Sie einer lokalen Instance eine Konfigurationsdatei mithilfe von Root- oder Administratorberechtigungen. Diese Konfigurationsdatei wird verwendet, um die IAM-Benutzeranmeldedaten und die AWS Zielregion zu deklarieren, für die verwendet werden soll. CodeDeploy Die Datei muss an einem bestimmten Speicherort in der lokalen Instance abgelegt werden. Die Datei muss den ARN, die geheime Schlüssel-ID, den geheimen Zugriffsschlüssel und die AWS Zielregion des IAM-Benutzers enthalten. Die Datei muss in einem bestimmten Format vorliegen.
1. Erstellen Sie eine Datei mit dem Namen `codedeploy.onpremises.yml` (für eine lokale Ubuntu Server- oder RHEL-Instanz) oder `conf.onpremises.yml` (für eine lokale Windows Server-Instanz) am folgenden Speicherort auf der lokalen Instanz:
+ Für Ubuntu Server: `/etc/codedeploy-agent/conf`
+ Für Windows Server: `C:\ProgramData\Amazon\CodeDeploy`
1. Verwenden Sie einen Texteditor, um die folgenden Informationen der neu erstellten `codedeploy.onpremises.yml`- oder `conf.onpremises.yml`-Datei hinzuzufügen:
```
---
aws_access_key_id: secret-key-id
aws_secret_access_key: secret-access-key
iam_user_arn: iam-user-arn
region: supported-region
```
Wobei Folgendes gilt:
+ *secret-key-id*ist die geheime Schlüssel-ID des entsprechenden IAM-Benutzers, die Sie in [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1) oder [Schritt 3: Holen Sie sich die IAM-Benutzeranmeldedaten](#register-on-premises-instance-iam-user-arn-3) notiert haben.
+ *secret-access-key*ist der geheime Zugriffsschlüssel des entsprechenden IAM-Benutzers, den Sie in [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1) oder notiert haben. [Schritt 3: Holen Sie sich die IAM-Benutzeranmeldedaten](#register-on-premises-instance-iam-user-arn-3)
+ *iam-user-arn*ist der ARN des IAM-Benutzers, den Sie weiter oben notiert [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1) haben.
+ *supported-region*ist die Kennung einer Region, die von der Region unterstützt wird, CodeDeploy in der sich Ihre CodeDeploy Anwendungen, Bereitstellungsgruppen und Anwendungsversionen befinden (z. B.`us-west-2`). Eine Liste der Regionen finden Sie unter [Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in der. *Allgemeine AWS-Referenz*
**Wichtig**
Wenn Sie neben einem der Zugriffsschlüssel unter **Löschen** ausgewählt haben und Ihre lokale Instanz bereits die zugehörige Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel verwendet, müssen Sie den Anweisungen unter folgen, um eine andere Zugriffsschlüssel-ID und einen anderen geheimen Zugriffsschlüssel für diesen IAM-Benutzer anzugeben. [Schritt 3: Holen Sie sich die IAM-Benutzeranmeldedaten](#register-on-premises-instance-iam-user-arn-3) [Schritt 4: Fügen Sie der lokalen Instanz eine Konfigurationsdatei hinzu](#register-on-premises-instance-iam-user-arn-4) Andernfalls bleiben Bereitstellungen auf dieser lokalen Instance in einem dauerhaften schwebenden Zustand hängen oder schlagen ganz fehl.
## Schritt 5: Installieren und konfigurieren Sie AWS CLI
Installieren und konfigurieren Sie die AWS CLI auf der lokalen Instanz. ( AWS CLI Wird verwendet, [Schritt 7: Installieren Sie den CodeDeploy Agenten](#register-on-premises-instance-iam-user-arn-7) um den CodeDeploy Agenten herunterzuladen und auf der lokalen Instanz zu installieren.)
1. Folgen Sie den Anweisungen AWS CLI unter [Getting Setup with the im *AWS Command Line Interface Benutzerhandbuch*, um den auf der](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) lokalen Instanz AWS CLI zu installieren.
**Anmerkung**
CodeDeploy Befehle für die Arbeit mit lokalen Instanzen wurden in Version 1.7.19 von verfügbar. AWS CLI Wenn Sie AWS CLI bereits eine Version von installiert haben, können Sie deren Version überprüfen, indem Sie anrufen. **aws --version**
1. Um die AWS CLI On-Premises-Instanz zu konfigurieren, folgen Sie den Anweisungen [unter Konfiguration der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) im *AWS Command Line Interface Benutzerhandbuch*.
**Wichtig**
Achten Sie bei der Konfiguration der AWS CLI (z. B. durch Aufrufen des **aws configure** Befehls) darauf, die geheime Schlüssel-ID und den geheimen Zugriffsschlüssel eines IAM-Benutzers anzugeben, der zusätzlich zu den in der angegebenen AWS Zugriffsberechtigungen mindestens über die folgenden Zugriffsberechtigungen verfügt. [Voraussetzungen für die Konfiguration einer lokalen Instanz](instances-on-premises-prerequisites.md) Auf diese Weise können Sie den CodeDeploy Agenten herunterladen und auf der lokalen Instanz installieren:
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"*"
]
}
]
}
```
Diese Zugriffsberechtigungen können entweder dem IAM-Benutzer zugewiesen werden, in dem Sie ihn erstellt haben, [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1) oder einem anderen IAM-Benutzer. Um diese Berechtigungen einem IAM-Benutzer zuzuweisen, folgen Sie den Anweisungen unter und verwenden Sie diese Zugriffsberechtigungen anstelle der in diesem Schritt angegebenen. [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1)
## Schritt 6: Legen Sie die AWS\$1REGION Umgebungsvariable fest (nur Ubuntu Server und RHEL)
Wenn Sie Ubuntu Server oder RHEL nicht auf Ihrer lokalen Instanz ausführen, überspringen Sie diesen Schritt und gehen Sie direkt zu. [Schritt 7: Installieren Sie den CodeDeploy Agenten](#register-on-premises-instance-iam-user-arn-7)
Installieren Sie den CodeDeploy Agenten auf einer lokalen Ubuntu-Server- oder RHEL-Instanz und aktivieren Sie die Instanz, um den CodeDeploy Agenten zu aktualisieren, sobald eine neue Version verfügbar ist. Dazu legen Sie die Umgebungsvariable `AWS_REGION` auf der Instance auf die ID einer der von CodeDeploy unterstützten Regionen fest. Wir empfehlen, dass Sie den Wert auf die Region festlegen, in der sich Ihre CodeDeploy Anwendungen, Bereitstellungsgruppen und Anwendungsversionen befinden (z. B.). `us-west-2` Eine Liste der Regionen finden Sie unter [Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in der. *Allgemeine AWS-Referenz*
Rufen Sie zum Festlegen der Umgebungsvariable Folgendes vom Terminal ab:
```
export AWS_REGION=supported-region
```
Wo *supported-region* befindet sich die Regionskennung (z. B.`us-west-2`).
## Schritt 7: Installieren Sie den CodeDeploy Agenten
Installieren Sie den CodeDeploy Agenten auf der lokalen Instanz:
+ Folgen Sie für eine lokale Ubuntu-Server-Instanz den Anweisungen unter und kehren Sie dann zu dieser Seite zurück. [Installieren Sie den CodeDeploy Agenten für Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md)
+ Folgen Sie für eine lokale RHEL-Instanz den Anweisungen unter und kehren Sie dann zu dieser Seite zurück. [Installieren Sie den CodeDeploy Agenten für Amazon Linux oder RHEL](codedeploy-agent-operations-install-linux.md)
+ Folgen Sie für eine lokale Windows Server-Instanz den Anweisungen unter und kehren Sie dann zu dieser Seite zurück. [Installieren Sie den CodeDeploy Agenten für Windows Server](codedeploy-agent-operations-install-windows.md)
## Schritt 8: Registrieren Sie die lokale Instanz bei CodeDeploy
Bei diesen Anweisungen gehen wir davon aus, dass Sie die Registrierung des lokalen Instance von der lokalen Instance aus durchführen. Sie können eine lokale Instanz von einem separaten Gerät oder einer Instanz aus registrieren, auf der die Instanz AWS CLI installiert und konfiguriert ist, wie unter beschrieben. [Schritt 5: Installieren und konfigurieren Sie AWS CLI](#register-on-premises-instance-iam-user-arn-5)
Verwenden Sie den AWS CLI , um die lokale Instanz zu registrieren, CodeDeploy damit sie in Bereitstellungen verwendet werden kann.
1. Bevor Sie den verwenden können AWS CLI, benötigen Sie den Benutzer-ARN des IAM-Benutzers, in [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1) dem Sie ihn erstellt haben. Wenn Sie den Benutzer-ARN noch nicht haben, rufen Sie den Befehl [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html) auf, geben Sie den Namen des IAM-Benutzers an (mit der `--user-name` Option) und fragen Sie nur nach dem Benutzer-ARN (mit den Optionen `--query` und`--output`) ab:
```
aws iam get-user --user-name CodeDeployUser-OnPrem --query "User.Arn" --output text
```
1. Rufen Sie den Befehl [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html) mit folgenden Angaben auf:
+ Ein eindeutiger Bezeichner für die lokale Instance (mit der Option `--instance-name`).
**Wichtig**
Um die lokale Instance identifizieren zu können, insbesondere für Debugging-Zwecke, empfehlen wir dringend, dass Sie einen Namen angeben, die einige eindeutige Merkmale der lokalen Instance enthält (z. B. die Seriennummer oder eine eindeutige interne Asset-ID, falls zutreffend). Wenn Sie eine MAC-Adresse als Namen angeben, beachten Sie, dass MAC-Adressen unzulässige Zeichen enthalten, z. B. einen Doppelpunkt (). CodeDeploy `:` Eine Liste der zulässigen Zeichen finden Sie unter [CodeDeploy Kontingente](limits.md).
+ Der Benutzer-ARN des IAM-Benutzers, in dem Sie ihn erstellt haben [Schritt 1: Erstellen Sie einen IAM-Benutzer für die lokale Instanz](#register-on-premises-instance-iam-user-arn-1) (mit der `--iam-user-arn` Option).
Beispiel:
```
aws deploy register-on-premises-instance --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem
```
## Schritt 9: Kennzeichnen Sie die lokale Instanz
Sie können entweder die Konsole AWS CLI oder die CodeDeploy Konsole verwenden, um die lokale Instanz zu taggen. (CodeDeployverwendet lokale Instanz-Tags, um die Bereitstellungsziele während einer Bereitstellung zu identifizieren.)
**So markieren Sie eine lokale Instance (CLI):**
+ Rufen Sie den Befehl [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html) auf und geben Sie Folgendes an:
+ Der eindeutige Bezeichner für die lokale Instance (mit der Option `--instance-names`).
+ Der Name des Tag-Schlüssels und des Tag-Werts der lokalen Instance, die Sie verwenden möchten (mit der Option `--tags`). Sie müssen sowohl einen Namen als auch einen Wert angeben. CodeDeploy erlaubt keine lokalen Instanz-Tags, die nur Werte enthalten.
Beispiel:
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**So markieren Sie eine lokale Instance (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. Wählen Sie im CodeDeploy Menü die Option **On-Premises-Instanzen** aus.
1. Klicken Sie in der Liste der lokalen Instances auf den Pfeil neben der lokalen Instance, die Sie markieren möchten.
1. Wählen Sie in der Liste der Tags den gewünschten Tag-Schlüssel und -Wert aus oder geben Sie ihn ein. Nachdem Sie den Tag-Schlüssel und den Tag-Wert eingegeben haben, wird eine weitere Zeile angezeigt. Sie können das für bis zu 10 Tags wiederholen. Zum Entfernen eines Tags wählen Sie das Symbol "Löschen" aus (![\[The delete icon.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/delete-triggers-x.png)).
1. Wählen Sie nach dem Hinzufügen der Tags die Option **Update Tags**.
## Schritt 10: Stellen Sie Anwendungsrevisionen auf der lokalen Instanz bereit
Sie können nun auf den registrierten und mit einem Tag markierten lokalen Instances Anwendungsrevisionen bereitstellen.
Sie stellen Anwendungsrevisionen auf lokale Instances auf ähnliche Weise bereit, wie Sie Anwendungsrevisionen für Amazon EC2 EC2-Instances bereitstellen. Detaillierte Anweisungen finden Sie unter [Erstellen Sie eine Bereitstellung mit CodeDeploy](deployments-create.md). Diese Anweisungen enthalten einen Link zu den Voraussetzungen, wie dem Erstellen einer Anwendung, Erstellen einer Bereitstellungsgruppe und Vorbereiten einer Anwendungsrevision. Wenn Sie eine einfache Beispielanwendungsrevision bereitstellen möchten, können Sie die unter [Schritt 2: Erstellen Sie eine Version der Beispielanwendung](tutorials-on-premises-instance-2-create-sample-revision.md) im [Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md) beschriebene Revision verwenden.
**Wichtig**
Wenn Sie eine CodeDeploy Servicerolle im Rahmen der Erstellung einer Bereitstellungsgruppe für lokale Instances wiederverwenden, müssen Sie die Richtlinienerklärung der Servicerolle in diesen `Action` Teil aufnehmen`Tag:get*`. Weitere Informationen finden Sie unter [Schritt 2: Erstellen Sie eine Servicerolle für CodeDeploy](getting-started-create-service-role.md).
## Schritt 11: Verfolgen Sie Bereitstellungen auf der lokalen Instanz
Nachdem Sie eine Anwendungsrevision auf einer registrierten und markierten lokalen Instance bereitgestellt haben, können Sie den Fortschritt der Bereitstellung nachverfolgen.
Sie verfolgen Bereitstellungen für lokale Instances auf ähnliche Weise wie die Nachverfolgung von Bereitstellungen auf Amazon EC2 EC2-Instances. Detaillierte Anweisungen finden Sie unter [CodeDeploy Bereitstellungsdetails anzeigen](deployments-view-details.md).
# Verwaltung von Vorgängen für lokale Instanzen in CodeDeploy
Folgen Sie den Anweisungen in diesem Abschnitt, um Vorgänge auf Ihren lokalen Instances zu verwalten, nachdem Sie sie registriert haben CodeDeploy, z. B. um weitere Informationen zu lokalen Instances zu erhalten, Tags zu entfernen und sie zu deinstallieren und deren Registrierung aufzuheben.
**Topics**
+ [Informieren Sie sich über eine einzelne lokale Instanz](on-premises-instances-operations-view-details-single.md)
+ [Rufen Sie Informationen zu mehreren lokalen Instanzen ab](on-premises-instances-operations-view-details-multiple.md)
+ [Entfernen Sie manuell lokale Instanz-Tags aus einer lokalen Instanz](on-premises-instances-operations-remove-tags.md)
+ [Deinstallieren Sie den CodeDeploy Agenten automatisch und entfernen Sie die Konfigurationsdatei aus einer lokalen Instanz](on-premises-instances-operations-uninstall-agent.md)
+ [Automatische Deregistrierung einer lokalen Instanz](on-premises-instances-operations-deregister-automatically.md)
+ [Manuelles Aufheben der Registrierung einer lokalen Instanz](on-premises-instances-operations-deregister-manually.md)
# Informieren Sie sich über eine einzelne lokale Instanz
Sie können Informationen zu einer einzelnen lokalen Instance erhalten, indem Sie die Anweisungen unter [CodeDeploy Bereitstellungsdetails anzeigen](deployments-view-details.md) befolgen. Sie können die Konsole AWS CLI oder die CodeDeploy Konsole verwenden, um weitere Informationen zu einer einzelnen lokalen Instanz zu erhalten.
**Abrufen von Informationen über eine einzelne lokale Instance (CLI)**
+ Rufen Sie den Befehl [get-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-on-premises-instance.html) unter Angabe des eindeutigen Namens der lokalen Instance auf (mit der Option `--instance-name`):
```
aws deploy get-on-premises-instance --instance-name AssetTag12010298EX
```
**Abrufen von Informationen über eine einzelne lokale Instance (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 **Lokale Instanzen** aus.
1. Wählen Sie in der Liste der lokalen Instances den Namen einer lokalen Instance aus, um ihre Details anzuzeigen.
# Rufen Sie Informationen zu mehreren lokalen Instanzen ab
Sie können Informationen zu lokalen Instances erhalten, indem Sie die Anweisungen unter [CodeDeploy Bereitstellungsdetails anzeigen](deployments-view-details.md) befolgen. Sie können die Konsole AWS CLI oder die CodeDeploy Konsole verwenden, um weitere Informationen zu lokalen Instanzen zu erhalten.
**Abrufen von Informationen über mehrere lokale Instances (CLI)**
1. Eine Liste der Namen der lokalen Instances erhalten Sie durch Aufrufen des Befehls [list-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-on-premises-instances.html), indem Sie Folgendes angeben:
+ Ob Informationen zu allen registrierten lokalen Instances oder allen lokalen Instances, deren Registrierung aufgehoben wurde, abgerufen werden sollen (mit der Option `--registration-status` und `Registered` bzw. `Deregistered`). Wenn Sie diese Angabe auslassen, werden Namen der registrierten lokalen Instances und der lokalen Instances, deren Registrierung aufgehoben wurde, zurückgegeben.
+ Ob nur Informationen zu lokalen Instances mit spezifischen Tags für lokale Instances abgerufen werden sollen (mit der Option `--tag-filters`). Geben Sie für jedes Tag für lokale Instances `Key`, `Value` und `Type` an (immer `KEY_AND_VALUE`). Trennen Sie mehrere Tags für lokale Instances durch Leerzeichen zwischen jeder Dreiergruppe aus `Key`, `Value` und `Type`.
Beispiel:
```
aws deploy list-on-premises-instances --registration-status Registered --tag-filters Key=Name,Value=CodeDeployDemo-OnPrem,Type=KEY_AND_VALUE Key=Name,Value=CodeDeployDemo-OnPrem-Beta,Type=KEY_AND_VALUE
```
1. Für detailliertere Informationen rufen Sie den Befehl [batch-get-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/batch-get-on-premises-instances.html) mit den Namen der lokalen Instanzen (mit der `--instance-names` Option) auf:
```
aws deploy batch-get-on-premises-instances --instance-names AssetTag12010298EX AssetTag09920444EX
```
**Abrufen von Informationen über mehrere lokale Instances (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 **Lokale Instanzen** aus.
Informationen zu den lokalen Instances werden angezeigt.
# Entfernen Sie manuell lokale Instanz-Tags aus einer lokalen Instanz
In der Regel entfernen Sie ein Tag für lokale Instances von einer lokalen Instance, wenn dieses nicht mehr genutzt wird oder wenn Sie die lokale Instance aus Bereitstellungsgruppen entfernen möchten, die dieses Tag benötigen. Sie können die AWS CLI oder die AWS CodeDeploy Konsole verwenden, um lokale Instanz-Tags aus lokalen Instanzen zu entfernen.
Sie müssen Tags für lokale Instances nicht von einer lokalen Instance entfernen, bevor Sie deren Registrierung aufheben.
Durch manuelles Entfernen von Tags für lokale Instances von einer lokalen Instance wird die Registrierung der Instance nicht aufgehoben. Der CodeDeploy Agent wird dadurch nicht von der Instanz deinstalliert. Die Konfigurationsdatei wird nicht von der Instance entfernt. Der mit der Instanz verknüpfte IAM-Benutzer wird nicht gelöscht.
Informationen zum automatischen Aufheben der Registrierung der lokalen Instance finden Sie unter [Automatische Deregistrierung einer lokalen Instanz](on-premises-instances-operations-deregister-automatically.md).
Informationen zum manuellen Aufheben der Registrierung der lokalen Instance finden Sie unter [Manuelles Aufheben der Registrierung einer lokalen Instanz](on-premises-instances-operations-deregister-manually.md).
Informationen zur automatischen Deinstallation des CodeDeploy Agenten und zum Entfernen der Konfigurationsdatei aus der lokalen Instanz finden Sie unter. [Deinstallieren Sie den CodeDeploy Agenten automatisch und entfernen Sie die Konfigurationsdatei aus einer lokalen Instanz](on-premises-instances-operations-uninstall-agent.md)
Informationen zur manuellen Deinstallation nur des CodeDeploy Agenten von der lokalen Instanz finden Sie unter. [Verwaltung des CodeDeploy Agentenbetriebs](codedeploy-agent-operations.md)
Informationen zum manuellen Löschen des zugehörigen IAM-Benutzers finden Sie unter [Löschen eines IAM-Benutzers aus](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html) Ihrem Konto. AWS
**Entfernen von Tags für lokale Instances von einer lokalen Instance (CLI)**
+ Rufen Sie die [remove-tags-from-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/remove-tags-from-on-premises-instances.html) auf und geben Sie Folgendes an:
+ Die eindeutigen Namen der lokalen Instance (mit der Option `--instance-names`).
+ Die Namen und Werte der Tags, die Sie entfernen möchten (mit der Option `--tags`).
Beispiel:
```
aws deploy remove-tags-from-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Entfernen von Tags für lokale Instances von einer lokalen Instance (Konsole)**
1. [Melden Sie sich bei /codedeploy an AWS-Managementkonsole und öffnen Sie die Konsole CodeDeploy . https://console.aws.amazon.com](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 **Lokale Instanzen** aus.
1. Klicken Sie in der Liste der lokalen Instances auf den Namen der lokalen Instance, aus der Sie Tags entfernen möchten.
1. Wählen Sie im Bereich **Tags** neben jedem Tag, das Sie entfernen möchten, **Remove (Entfernen)** aus.
1. Wählen Sie nach dem Löschen der Tags die Option **Update tags**.
# Deinstallieren Sie den CodeDeploy Agenten automatisch und entfernen Sie die Konfigurationsdatei aus einer lokalen Instanz
In der Regel deinstallieren Sie den CodeDeploy Agenten und entfernen die Konfigurationsdatei aus einer lokalen Instanz, nachdem Sie die Bereitstellung auf dieser Instanz nicht mehr planen.
**Anmerkung**
Durch die automatische Deinstallation des CodeDeploy Agenten und das Entfernen der Konfigurationsdatei aus einer lokalen Instanz wird die Registrierung einer lokalen Instanz nicht aufgehoben. Die Zugehörigkeit von Tags für lokale Instances, die mit der lokalen Instance verbunden sind, wird nicht aufgehoben. Der mit der lokalen Instanz verknüpfte IAM-Benutzer wird dadurch nicht gelöscht.
Informationen zum automatischen Aufheben der Registrierung der lokalen Instance finden Sie unter [Automatische Deregistrierung einer lokalen Instanz](on-premises-instances-operations-deregister-automatically.md).
Informationen zum manuellen Aufheben der Registrierung der lokalen Instance finden Sie unter [Manuelles Aufheben der Registrierung einer lokalen Instanz](on-premises-instances-operations-deregister-manually.md).
Informationen zum manuellen Aufheben der Zugehörigkeit zugehöriger Tags für lokale Instances finden Sie unter [Entfernen Sie manuell lokale Instanz-Tags aus einer lokalen Instanz](on-premises-instances-operations-remove-tags.md).
Informationen zur manuellen Deinstallation des CodeDeploy Agenten von der lokalen Instanz finden Sie unter. [Verwaltung des CodeDeploy Agentenbetriebs](codedeploy-agent-operations.md)
Informationen zum manuellen Löschen des zugehörigen IAM-Benutzers finden Sie unter [Löschen eines IAM-Benutzers aus](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html) Ihrem Konto. AWS
[Rufen Sie in der lokalen Instanz den Befehl AWS CLI uninstall auf.](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html)
Beispiel:
```
aws deploy uninstall
```
Der Befehl **uninstall** hat folgende Auswirkungen:
1. Stoppt den laufenden CodeDeploy Agenten auf der lokalen Instanz.
1. Deinstalliert den CodeDeploy Agenten von der lokalen Instanz aus.
1. Entfernt die Konfigurationsdatei von der lokalen Instance. (Für Ubuntu Server und RHEL ist dies/. `/etc/codedeploy-agent/conf` `codedeploy.onpremises.yml` Für Windows Server ist dies`C:\ProgramData\Amazon\CodeDeploy`\$1`conf.onpremises.yml`.)
# Automatische Deregistrierung einer lokalen Instanz
In der Regel heben Sie die Registrierung einer lokalen Instance auf, wenn Sie sie voraussichtlich nicht mehr bereitstellen werden. Wenn Sie die Registrierung einer lokalen Instance aufheben, wird diese, auch wenn sie Teil der Tags für lokale Instances einer Bereitstellungsgruppe ist, nicht mehr in Bereitstellungen eingeschlossen. Sie können das verwenden, AWS CLI um lokale Instanzen abzumelden.
**Anmerkung**
Sie können die CodeDeploy Konsole nicht verwenden, um die Registrierung einer lokalen Instanz aufzuheben. Zudem werden durch die Aufhebung der Registrierung einer lokalen Instance alle lokalen Instance-Tags, die mit der lokalen Instance verbunden sind, entfernt. Der CodeDeploy Agent wird nicht von der lokalen Instanz deinstalliert. Die Konfigurationsdatei der lokalen Instance wird nicht von der lokalen Instance entfernt.
Informationen dazu, wie Sie mit der CodeDeploy Konsole einige (aber nicht alle) der Aktivitäten in diesem Abschnitt ausführen können, finden Sie im CodeDeploy Konsolenabschnitt von[Manuelles Aufheben der Registrierung einer lokalen Instanz](on-premises-instances-operations-deregister-manually.md).
Informationen zum manuellen Aufheben der Zugehörigkeit zugehöriger Tags für lokale Instances finden Sie unter [Entfernen Sie manuell lokale Instanz-Tags aus einer lokalen Instanz](on-premises-instances-operations-remove-tags.md).
Informationen zur automatischen Deinstallation des CodeDeploy Agenten und zum Entfernen der Konfigurationsdatei aus der lokalen Instanz finden Sie unter[Deinstallieren Sie den CodeDeploy Agenten automatisch und entfernen Sie die Konfigurationsdatei aus einer lokalen Instanz](on-premises-instances-operations-uninstall-agent.md).
Informationen zur manuellen Deinstallation nur des CodeDeploy Agenten von der lokalen Instanz finden Sie unter. [Verwaltung des CodeDeploy Agentenbetriebs](codedeploy-agent-operations.md)
Rufen Sie AWS CLI mit dem den Befehl [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html) auf und geben Sie Folgendes an:
+ Der Name, der die lokale Instanz eindeutig identifiziert CodeDeploy (mit der `--instance-name` Option).
+ Optional, ob der IAM-Benutzer gelöscht werden soll, der der lokalen Instanz zugeordnet ist. Das Standardverhalten besteht darin, den IAM-Benutzer zu löschen. Wenn Sie den mit der lokalen Instance verbundenen IAM-Benutzer nicht löschen möchten, geben Sie im Befehl die Option `--no-delete-iam-user` an.
+ Optional die AWS Region, in der die lokale Instanz registriert wurde CodeDeploy (mit der `--region` Option). Dies muss eine der unterstützten Regionen sein, die unter [Region aufgeführt sind, und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Allgemeine AWS-Referenz*(z. B.`us-west-2`). Wenn diese Option nicht angegeben ist, wird die AWS Standardregion verwendet, die dem aufrufenden IAM-Benutzer zugeordnet ist.
Ein Beispiel, das die Registrierung einer Instance aufhebt und den Benutzer löscht:
```
aws deploy deregister --instance-name AssetTag12010298EX --region us-west-2
```
Ein Beispiel, das die Registrierung einer Instance aufhebt und den Benutzer nicht löscht:
```
aws deploy deregister --instance-name AssetTag12010298EX --no-delete-iam-user --region us-west-2
```
Der Befehl **deregister** hat folgende Auswirkungen:
1. Deregistriert die lokale Instanz bei. CodeDeploy
1. Falls angegeben, wird der IAM-Benutzer gelöscht, der der lokalen Instanz zugeordnet ist.
Nach dem Aufheben der Registrierung einer lokalen Instance:
+ Sie wird sofort nicht mehr auf der Konsole angezeigt.
+ Sie können umgehend eine andere Instance mit demselben Namen erstellen.
Wenn dieser Befehl Fehler erkennt, wird eine Fehlermeldung angezeigt, in der beschrieben wird, wie Sie die verbleibenden Schritte manuell durchführen können. Andernfalls wird eine Meldung über den erfolgreichen Abschluss angezeigt, in der beschrieben wird, wie Sie den Befehl **uninstall** aufrufen.
# Manuelles Aufheben der Registrierung einer lokalen Instanz
In der Regel heben Sie die Registrierung einer lokalen Instance auf, wenn Sie sie voraussichtlich nicht mehr bereitstellen werden. Sie verwenden die, AWS CLI um lokale Instanzen manuell abzumelden.
Durch die manuelle Deregistrierung einer lokalen Instanz wird der Agent nicht deinstalliert. CodeDeploy Die Konfigurationsdatei wird nicht von der Instance entfernt. Der mit der Instanz verknüpfte IAM-Benutzer wird dadurch nicht gelöscht. Mit der Instance verbundene Tags werden nicht entfernt.
Informationen zur automatischen Deinstallation des CodeDeploy Agenten und zum Entfernen der Konfigurationsdatei aus der lokalen Instanz finden Sie unter. [Deinstallieren Sie den CodeDeploy Agenten automatisch und entfernen Sie die Konfigurationsdatei aus einer lokalen Instanz](on-premises-instances-operations-uninstall-agent.md)
Informationen zur manuellen Deinstallation nur des CodeDeploy Agenten finden Sie unter[Verwaltung des CodeDeploy Agentenbetriebs](codedeploy-agent-operations.md).
Informationen zum manuellen Löschen des zugehörigen IAM-Benutzers finden Sie unter [Löschen eines IAM-Benutzers aus Ihrem AWS Konto](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
Informationen zum manuellen Entfernen nur der zugehörigen Tags für lokale Instances finden Sie unter [Entfernen Sie manuell lokale Instanz-Tags aus einer lokalen Instanz](on-premises-instances-operations-remove-tags.md).
+ Rufen Sie den Befehl [deregister-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister-on-premises-instance.html) unter Angabe des eindeutigen Namens der lokalen Instance auf (mit der Option `--instance-name`):
```
aws deploy deregister-on-premises-instance --instance-name AssetTag12010298EX
```
Nach dem Aufheben der Registrierung einer lokalen Instance:
+ Sie wird sofort nicht mehr auf der Konsole angezeigt.
+ Sie können umgehend eine andere Instance mit demselben Namen erstellen.
# Instanzdetails anzeigen mit CodeDeploy
Sie können die CodeDeploy Konsole, die oder die verwenden AWS CLI, um Details CodeDeploy APIs zu den in einer Bereitstellung verwendeten Instances anzuzeigen.
Informationen zur Verwendung von CodeDeploy API-Aktionen zum Anzeigen von Instanzen finden Sie unter [GetDeploymentInstance[ListDeploymentInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListDeploymentInstances.html)](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_GetDeploymentInstance.html), und [ListOnPremisesInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListOnPremisesInstances.html).
**Topics**
+ [Instanzdetails anzeigen (Konsole)](#instances-view-details-console)
+ [Instanzdetails anzeigen (CLI)](#instances-view-details-cli)
## Instanzdetails anzeigen (Konsole)
So zeigen Sie Instance-Details an:
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 **Bereitstellungen** aus.
**Anmerkung**
Wenn keine Einträge angezeigt werden, stellen Sie sicher, dass die richtige Region ausgewählt ist. Wählen Sie in der Navigationsleiste in der Regionsauswahl eine der Regionen aus, die unter [Region und Endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in der aufgeführt sind. *Allgemeine AWS-Referenz* CodeDeploy wird nur in diesen Regionen unterstützt.
1. Um Bereitstellungsdetails anzuzeigen, wählen Sie die Bereitstellungs-ID für die Instance aus.
1. Auf der Seite der Bereitstellung können Sie alle Instances im Bereich **Instance activity (Instance-Aktivität)** anzeigen.
1. Um auf der Seite zu den Details der Bereitstellung Informationen zu einzelnen Bereitstellungslebenszyklusereignissen anzuzeigen, wählen Sie in der Spalte **Events** die Option **View events** aus.
**Anmerkung**
Wenn für eines der Lebenszyklusereignisse die Option **Fehlgeschlagen** angezeigt wird, wählen Sie auf der Seite mit den Instanzdetails die Option **Protokolle anzeigen EC2****, Anzeigen in** oder beides aus. Tipps zur Fehlerbehebung finden Sie unter [Beheben von Instance-Problemen](troubleshooting-ec2-instances.md).
1. Wenn Sie weitere Informationen zu einer EC2 Amazon-Instance sehen möchten, wählen Sie die ID der Instance in der Spalte **Instance-ID** aus.
## Instanzdetails anzeigen (CLI)
Rufen Sie entweder AWS CLI den `get-deployment-instance` Befehl oder den Befehl auf, um Instanzdetails anzuzeigen. `list-deployment-instances`
Um Details zu einer einzelnen Instance anzuzeigen, rufen Sie den [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html)-Befehl auf und geben Sie dabei Folgendes an:
+ Die eindeutige Bereitstellungs-ID. Rufen Sie den Befehl [list-deployments auf, um die Deployment-ID](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html) abzurufen.
+ Die eindeutige Instance-ID. Um die Instance-ID zu erhalten, rufen Sie den [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html)-Befehl auf.
Um eine Liste der IDs in einer Bereitstellung verwendeten Instanzen anzuzeigen, rufen Sie den [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html)Befehl auf und geben Sie Folgendes an:
+ Die eindeutige Bereitstellungs-ID. Rufen Sie den Befehl [list-deployments auf, um die Bereitstellungs-ID](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html) abzurufen.
+ Optional, ob nur bestimmte Instanzen anhand ihres Bereitstellungsstatus eingeschlossen IDs werden sollen. (Wenn nicht angegeben, IDs werden alle passenden Instances unabhängig von ihrem Bereitstellungsstatus aufgelistet.)
# CodeDeploy Zustand der Instanz
CodeDeploy überwacht den Integritätsstatus der Instances in einer Bereitstellungsgruppe. Bereitstellungen schlagen fehl, wenn die Anzahl fehlerfreier Instances unter die Mindestanzahl fehlerfreier Instances fällt, die für die Bereitstellungsgruppe während einer Bereitstellung angegeben wurden. Wenn beispielsweise 85 % der Instances während einer Bereitstellung fehlerfrei bleiben müssen und die Bereitstellungsgruppe 10 Instances enthält, schlägt die gesamte Bereitstellung fehl, wenn die Bereitstellung auf einer einzigen Instance fehlschlägt. Das liegt daran, dass wenn eine Instance offline geschaltet wird, sodass die neuste Anwendungsrevision installiert werden kann, die Anzahl verfügbarer fehlerfreier Instances bereits auf 90 % fällt. Eine fehlerhafte Instance plus eine weitere offline geschaltete Instance bedeuten, dass nur 80 % der Instances fehlerfrei und verfügbar sind. CodeDeploy lässt die gesamte Bereitstellung fehlschlagen.
Denken Sie unbedingt daran, dass für den Erfolg einer allgemeinen Bereitstellung Folgendes gelten muss:
+ CodeDeploy kann für jede Instanz in der Bereitstellung bereitgestellt werden.
+ Es muss die Bereitstellung auf mindestens einer Instance erfolgreich sein. Das bedeutet, dass selbst wenn der minimale Wert für fehlerfreie Hosts 0 ist, die Bereitstellung auf mindestens einer Instanz erfolgreich sein muss (d. h. mindestens eine Instanz muss fehlerfrei sein), damit die gesamte Bereitstellung erfolgreich ist.
**Topics**
+ [Gesundheitsstatus](#instances-health-status)
+ [Ungefähr die Mindestanzahl fehlerfreier Instanzen](#minimum-healthy-hosts)
+ [Ungefähr die Mindestanzahl fehlerfreier Instanzen pro Availability Zone](#minimum-healthy-hosts-az)
## Gesundheitsstatus
CodeDeploy weist jeder Instanz zwei Integritätsstatuswerte zu: *Versionsstatus* und *Instanzstatus*.
Revisionszustand
Der Revisionszustand basiert auf der Anwendungsrevision, die derzeit auf der Instance installiert ist. Sie hat die folgenden Statuswerte:
+ Aktuell: Die auf der Instance installierte Revision stimmt mit der Revision für die letzte erfolgreiche Bereitstellung der Bereitstellungsgruppe überein.
+ Alt: Die auf der Instance installierte Revision stimmt mit einer älteren Version der Anwendung überein.
+ Unbekannt: Die Anwendungsrevision wurde nicht erfolgreich auf der Instance installiert.
Zustand der Instanz
Der Instance-Zustand basiert darauf, ob Bereitstellungen auf einer Instance erfolgreich waren. Er hat die folgenden Werte:
+ Fehlerfrei: Die letzte Bereitstellung auf der Instance war erfolgreich.
+ Fehlerhaft: Der Versuch, eine Revision auf der Instance bereitzustellen, ist fehlgeschlagen, oder eine Revision wurde noch nicht auf der Instance bereitgestellt.
CodeDeploy verwendet Revisionsstatus und Instanzintegrität, um die Bereitstellung für die Instanzen der Bereitstellungsgruppe in der folgenden Reihenfolge zu planen:
1. Fehlerhafter Instance-Zustand.
1. Unbekannter Revisionszustand.
1. Alter Revisionszustand.
1. Aktueller Revisionszustand.
Wenn die gesamte Bereitstellung erfolgreich ist, wird die Revision aktualisiert und die Werte für den Zustand der Bereitstellungsgruppe werden entsprechend der neusten Bereitstellung aktualisiert.
+ Alle aktuellen Instances mit erfolgreicher Bereitstellung behalten den Status „Aktuell“. Andernfalls wechselt ihr Status zu „Unbekannt“.
+ Alle alten oder unbekannten Instances mit erfolgreicher Bereitstellung erhalten den Status „Aktuell“. Andernfalls behalten Sie den Status „Alt“ bzw. „Unbekannt“.
+ Alle fehlerfreien Instances mit erfolgreicher Bereitstellung behalten den Status „Fehlerfrei“. Andernfalls wechselt ihr Status zu „Fehlerhaft“.
+ Alle fehlerhaften Instances mit erfolgreicher Bereitstellung erhalten den Status „Fehlerfrei“. Andernfalls behalten Sie den Status „Fehlerhaft“.
Wenn die gesamte Bereitstellung fehlschlägt oder angehalten wird:
+ Für jede Instanz, für die CodeDeploy versucht wurde, die Anwendungsrevision bereitzustellen, ist der Instanzstatus auf fehlerfrei oder fehlerhaft gesetzt, je nachdem, ob der Bereitstellungsversuch für diese Instanz erfolgreich war oder fehlgeschlagen ist.
+ Für jede Instanz, für die CodeDeploy nicht versucht wurde, die Anwendungsrevision bereitzustellen, wird der aktuelle Instanzintegritätswert beibehalten.
+ Die Revision der Bereitstellungsgruppe bleibt gleich.
## Ungefähr die Mindestanzahl fehlerfreier Instanzen
Die erforderliche Mindestanzahl fehlerfreier Instances wird im Rahmen der Bereitstellungskonfiguration definiert.
**Wichtig**
Während einer blue/green Bereitstellung gelten die Bereitstellungskonfiguration und der Mindestwert für fehlerfreie Hosts für Instanzen in der Ersatzumgebung, nicht für Instanzen in der ursprünglichen Umgebung. Wenn jedoch die Registrierung von Instances in der Originalumgebung beim Load Balancer aufgehoben wird, wird die gesamte Bereitstellung als fehlgeschlagen gekennzeichnet, wenn die Registrierung nur einer einzigen Original-Instance nicht erfolgreich aufgehoben werden kann.
CodeDeploy bietet drei standardmäßige Bereitstellungskonfigurationen, für die üblicherweise die Mindestwerte für fehlerfreie Hosts verwendet wurden:
| Name der Standardbereitstellungskonfiguration | Vordefinierter Mindestwert für fehlerfreie Hosts |
| --- | --- |
| CodeDeployDefault.OneAtATime | 1 |
| CodeDeployDefault.HalfAtATime | 50 % |
| CodeDeployDefault.AllAtOnce | 0 |
Weitere Informationen zu Standardbereitstellungskonfigurationen finden Sie unter [Arbeiten mit Bereitstellungskonfigurationen in CodeDeploy](deployment-configurations.md).
Sie können benutzerdefinierte Bereitstellungskonfigurationen erstellen CodeDeploy , um Ihre eigenen Mindestwerte für einen fehlerfreien Host zu definieren. Sie können diese Werte als Ganzzahlen oder Prozentwerte definieren, wenn Sie die folgenden Operationen verwenden:
+ Wie `minimum-healthy-hosts` wenn Sie den [create-deployment-config](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-config.html)Befehl in der verwenden AWS CLI.
+ Wie `Value` beim [MinimumHealthyHosts](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_MinimumHealthyHosts.html)Datentyp in der CodeDeploy API.
+ Wie `MinimumHealthyHosts` bei der Verwendung [AWS::CodeDeploy::DeploymentConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-deploymentconfig.html)in einer CloudFormation Vorlage.
CodeDeploy ermöglicht es Ihnen, eine Mindestanzahl fehlerfreier Instanzen für die Bereitstellung für zwei Hauptzwecke anzugeben:
+ Um bestimmen zu können, ob die gesamte Bereitstellung erfolgreich ist oder fehlschlägt. Die Bereitstellung ist erfolgreich, wenn die Anwendungsrevision erfolgreich auf mindestens der Mindestanzahl fehlerfreier Instances bereitgestellt wurde.
+ Um die Anzahl an Instances bestimmen zu können, die während einer Bereitstellung fehlerfrei sein müssen, damit die Bereitstellung fortgesetzt wird.
Sie können die Mindestanzahl fehlerfreier Instances für Ihre Bereitstellungsgruppe als eine Anzahl von Instances oder als einen Prozentsatz der Gesamtzahl von Instances angeben. Wenn Sie einen Prozentsatz angeben, CodeDeploy rechnet der Prozentsatz zu Beginn der Bereitstellung in die entsprechende Anzahl von Instanzen um und rundet alle Bruchteile der Instanzen auf.
CodeDeploy verfolgt den Integritätsstatus der Instanzen der Bereitstellungsgruppe während des Bereitstellungsprozesses und bestimmt anhand der für die Bereitstellung angegebenen Mindestanzahl fehlerfreier Instanzen, ob die Bereitstellung fortgesetzt werden soll. Das Grundprinzip besagt, dass eine Bereitstellung nicht dazu führen darf, dass die Anzahl fehlerfreier Instances unter die angegebene Mindestanzahl fällt. Die einzige Ausnahme zu dieser Regel gilt, wenn eine Bereitstellungsgruppe zu Anfang weniger als die angegebene Mindestanzahl fehlerfreier Instances aufweist. In diesem Fall wird die Anzahl fehlerfreier Instances durch den Bereitstellungsvorgang nicht weiter reduziert.
**Anmerkung**
CodeDeploy versucht, die Bereitstellung für alle Instances in einer Bereitstellungsgruppe durchzuführen, auch für diejenigen, die sich derzeit im Status Gestoppt befinden. Bei der Berechnung der Mindestanzahl fehlerfreier Hosts hat eine angehaltene Instance dieselbe Wirkung wie eine fehlerhafte Instance. Um Bereitstellungsfehler aufgrund von zu vielen angehaltenen Instances zu beheben, starten Sie entweder Instances neu oder ändern Sie ihre Tags, um sie aus der Bereitstellungsgruppe auszuschließen.
CodeDeploy startet den Bereitstellungsprozess, indem versucht wird, die Anwendungsrevision für die fehlerhaften Instanzen der Bereitstellungsgruppe bereitzustellen. CodeDeploy Ändert bei jeder erfolgreichen Bereitstellung den Integritätsstatus der Instanz auf Fehlerfrei und fügt sie den fehlerfreien Instanzen der Bereitstellungsgruppe hinzu. CodeDeploy vergleicht dann die aktuelle Anzahl fehlerfreier Instances mit der angegebenen Mindestanzahl fehlerfreier Instances.
+ Wenn die Anzahl der fehlerfreien Instanzen kleiner oder gleich der angegebenen Mindestanzahl fehlerfreier Instanzen ist, wird die Bereitstellung CodeDeploy abgebrochen, um sicherzustellen, dass die Anzahl der fehlerfreien Instanzen nicht mit mehr Bereitstellungen abnimmt.
+ Wenn die Anzahl der fehlerfreien Instanzen die angegebene Mindestanzahl fehlerfreier Instanzen um mindestens eins übersteigt, wird die CodeDeploy Anwendungsrevision für die ursprüngliche Gruppe fehlerfreier Instanzen bereitgestellt.
Wenn eine Bereitstellung auf einer fehlerfreien Instance fehlschlägt, wird der Integritätsstatus dieser Instance in „Fehlerhaft“ CodeDeploy geändert. Im Verlauf der Bereitstellung wird die aktuelle Anzahl fehlerfreier Instanzen CodeDeploy aktualisiert und mit der angegebenen Mindestanzahl fehlerfreier Instanzen verglichen. Wenn die Anzahl der fehlerfreien Instanzen zu einem beliebigen Zeitpunkt des Bereitstellungsprozesses auf die angegebene Mindestanzahl fällt, wird die Bereitstellung CodeDeploy beendet. Dadurch wird verhindert, dass die nächste Bereitstellung fehlschlägt, weil die Anzahl fehlerfreier Instances unter die angegebene Mindestanzahl fällt.
**Anmerkung**
Achten Sie darauf, dass die angegebene Mindestanzahl fehlerfreier Instances kleiner ist als die Gesamtzahl der Instances in der Bereitstellungsgruppe. Wenn Sie einen Prozentsatz angeben, bedenken Sie, dass dieser aufgerundet wird. Andernfalls ist die Anzahl fehlerfreier Instances zu Beginn der Bereitstellung bereits kleiner oder gleich der angegebenen Mindestanzahl fehlerfreier Instances und CodeDeploy lässt die gesamte Bereitstellung umgehend fehlschlagen.
CodeDeploy verwendet außerdem die angegebene Mindestanzahl fehlerfreier Instanzen und die tatsächliche Anzahl fehlerfreier Instanzen, um zu bestimmen, ob und wie die Anwendungsversion für mehrere Instanzen bereitgestellt werden soll. Standardmäßig wird die Anwendungsrevision auf so vielen Instanzen wie möglich CodeDeploy bereitgestellt, ohne dass das Risiko besteht, dass die Anzahl der fehlerfreien Instanzen unter die angegebene Mindestanzahl fehlerfreier Instanzen fällt.
Um die Anzahl der Instanzen zu ermitteln, auf denen gleichzeitig bereitgestellt werden soll, CodeDeploy wird die folgende Berechnung verwendet:
```
[total-hosts] - [minimum-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
Beispiel:
+ Wenn Ihre Bereitstellungsgruppe aus 10 Instances besteht und Sie die Mindestanzahl fehlerfreier Instanzen auf 9 festlegen CodeDeploy , wird jeweils nur eine Instanz bereitgestellt.
+ Wenn Ihre Bereitstellungsgruppe aus 10 Instances besteht und Sie die Mindestanzahl fehlerfreier Instances auf 3 festlegen, erfolgt die CodeDeploy Bereitstellung im ersten Batch auf 7 Instances gleichzeitig und im zweiten Batch auf die restlichen 3 Instances.
+ Wenn Ihre Bereitstellungsgruppe aus 10 Instances besteht und Sie die Mindestanzahl fehlerfreier Instanzen auf 0 setzen, CodeDeploy erfolgt die Bereitstellung auf 10 Instances gleichzeitig.
**Beispiele**
In den folgenden Beispielen wird von einer Bereitstellungsgruppe mit 10 Instances ausgegangen.
Mindestanzahl fehlerfreier Instances: 95 %
CodeDeploy rundet die Mindestanzahl fehlerfreier Instanzen auf 10 Instanzen auf, was der Anzahl fehlerfreier Instanzen entspricht. Die gesamte Bereitstellung schlägt umgehend fehl, ohne dass die Revision auf einer einzigen Instance bereitgestellt wurde.
Mindestanzahl fehlerfreier Instances: 9
CodeDeploy stellt die Revision jeweils für eine Instanz bereit. Wenn die Bereitstellung auf einer der Instanzen fehlschlägt, schlägt die gesamte Bereitstellung CodeDeploy sofort fehl, da die Anzahl der fehlerfreien Instanzen der Mindestanzahl fehlerfreier Instanzen entspricht. Die Ausnahme zu dieser Regel besagt, dass wenn die letzte Instance fehlschlägt, die Bereitstellung trotzdem erfolgreich ist.
CodeDeploy setzt die Bereitstellung fort, eine Instanz nach der anderen, bis eine Bereitstellung fehlschlägt oder die gesamte Bereitstellung abgeschlossen ist. Wenn alle 10 Bereitstellungen erfolgreich sind, hat die Bereitstellungsgruppe jetzt 10 fehlerfreie Instances.
Mindestanzahl fehlerfreier Instances: 8
CodeDeploy stellt die Revision auf zwei Instanzen gleichzeitig bereit. Wenn zwei dieser Bereitstellungen fehlschlagen, schlägt die gesamte Bereitstellung CodeDeploy sofort fehl. Die Ausnahme zu dieser Regel besagt, dass wenn die letzte Instance die zweite ist, die fehlschlägt, die Bereitstellung trotzdem erfolgreich ist.
Mindestanzahl fehlerfreier Instances: 0
CodeDeploy stellt die Revision gleichzeitig für die gesamte Bereitstellungsgruppe bereit. Mindestens eine Bereitstellung einer Instance muss erfolgreich sein, damit die allgemeine Bereitstellung erfolgreich ist. Wenn 0 Instances fehlerfrei sind, schlägt die Bereitstellung fehl. Dies liegt an der Anforderung, dass mindestens eine Instanz nach Abschluss der gesamten Bereitstellung fehlerfrei sein muss, um eine Gesamtbereitstellung als erfolgreich zu kennzeichnen, auch wenn der Mindestwert für fehlerfreie Instanzen 0 ist.
## Ungefähr die Mindestanzahl fehlerfreier Instanzen pro Availability Zone
**Anmerkung**
In diesem Abschnitt werden die Begriffe *Instance* und *Host* synonym verwendet, um sich auf Amazon EC2 EC2-Instances zu beziehen.
Wenn Sie für Instances in mehreren [Availability Zones](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones) bereitstellen, können Sie optional die [zonal configuration](deployment-configurations-create.md#zonal-config) Funktion aktivieren, mit der Sie die Bereitstellung jeweils in einer Availability Zone durchführen können CodeDeploy .
Wenn diese Funktion aktiviert ist, CodeDeploy wird sichergestellt, dass die Anzahl der fehlerfreien Hosts über den Werten „Mindestanzahl fehlerfreier Hosts pro Zone“ *und* „Mindestanzahl fehlerfreier Hosts“ liegt. Wenn die Anzahl der fehlerfreien Hosts unter einen der Werte fällt, schlägt die Bereitstellung in allen Availability CodeDeploy Zones fehl.
Um die Anzahl der Hosts zu berechnen, auf denen die Bereitstellung gleichzeitig erfolgen soll, werden sowohl die Werte „Mindestanzahl fehlerfreier Hosts pro Zone“ als auch die Werte für „mindestens fehlerfreie Hosts“ CodeDeploy verwendet. CodeDeploy verwendet die *geringere* Anzahl von Berechnungen `[A]` und, wo und `[B]` sind: `[A]` `[B]`
```
[A] = [total-hosts] - [min-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
```
[B] = [total-hosts-per-AZ] - [min-healthy-hosts-per-AZ] =
[number-of-hosts-to-deploy-to-at-once-per-AZ]
```
Nachdem die Anzahl der Hosts bestimmt wurde, auf denen die Bereitstellung gleichzeitig erfolgen soll CodeDeploy , erfolgt die Bereitstellung auf Hosts in Batches dieser Anzahl, jeweils eine Availability Zone, mit einer optionalen Pause (oder „Bake-Time“) zwischen den Zonen.
**Beispiel**
Wenn Ihre Bereitstellung wie folgt konfiguriert ist:
+ `[total-hosts]` ist `200`
+ `[minimum-healthy-hosts]` ist `160`
+ `[total-hosts-per-AZ]` ist `100`
+ `[minimum-healthy-hosts-per-AZ]` ist `50`
Dann …
+ `[A]` = `200 - 160 = 40`
+ `[B]` = `100 - 50 = 50`
+ `40`ist weniger als `50`
CodeDeploy Wird daher sofort auf `40` Hosts bereitgestellt.
In diesem Szenario verläuft die Bereitstellung wie folgt:
1. CodeDeploy wird in der ersten Availability Zone bereitgestellt:
1. CodeDeploy wird auf den ersten `40` Hosts bereitgestellt.
1. CodeDeploy wird auf den nächsten `40` Hosts bereitgestellt.
1. CodeDeploy wird auf den verbleibenden `20` Hosts bereitgestellt.
Die Bereitstellung in der ersten Availability Zone ist jetzt abgeschlossen.
1. (Optional) CodeDeploy wartet, bis die Bereitstellung in der ersten Zone wie in der Einstellung **Überwachungsdauer oder Monitordauer** **hinzufügen für die erste Zone** festgelegt ist, „läuft“. Wenn es keine Probleme gibt, CodeDeploy fährt fort.
1. CodeDeploy wird in der zweiten Availability Zone bereitgestellt:
1. CodeDeploy wird auf den ersten `40` Hosts bereitgestellt.
1. CodeDeploy wird auf den nächsten `40` Hosts bereitgestellt.
1. CodeDeploy wird auf den verbleibenden `20` Hosts bereitgestellt.
Die Bereitstellung in der zweiten und letzten Availability Zone ist jetzt abgeschlossen.
Weitere Informationen zur Funktion für die zonale Konfiguration und zur Angabe der Mindestanzahl fehlerfreier Instances pro Availability Zone finden Sie unter[zonal configuration](deployment-configurations-create.md#zonal-config).