

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.

# Verwenden von Amazon EC2 in der AWS CLI
<a name="cli-services-ec2"></a>


| Eine Einführung in Amazon Elastic Compute Cloud | 
| --- | 
|  [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/TsRBftzZsQo/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/TsRBftzZsQo)  | 

Amazon Elastic Compute Cloud (Amazon EC2) bietet hochgradig skalierbare und flexible virtuelle Computing-Umgebungen. Mit Amazon EC2 können Sie virtuelle Server, sogenannte Amazon-EC2-Instances, bereitstellen und verwalten, um eine Vielzahl von Computing-Anforderungen zu erfüllen.

Amazon-EC2-Instances sind virtuelle Maschinen, die mit verschiedenen CPU-, Arbeitsspeicher-, Speicher- und Netzwerkkonfigurationen angepasst werden können. Sie können aus einer Vielzahl von Instance-Typen wählen, die je nach Ihren Anwendungsanforderungen von leichten, kostengünstigen Optionen bis hin zu leistungsstarken Instances mit hoher Performance reichen. Diese Flexibilität ermöglicht es Ihnen, Ihren Computing-Anforderungen gerecht zu werden und so die Leistung und Kosteneffizienz zu optimieren. 

Darüber hinaus bietet Amazon EC2 eine Reihe von Funktionen, mit denen Sie Ihre Rechenressourcen effektiv verwalten können. Dazu gehören die Möglichkeit, schnell neue Instances zu starten, benutzerdefinierte Machine Images (AMIs) für eine schnelle Bereitstellung zu erstellen und die Rechenkapazität nach Bedarf zu erhöhen oder zu reduzieren. 

Sie können über die AWS Command Line Interface (AWS CLI) auf die Funktionen von Amazon EC2 zugreifen. Verwenden Sie den folgenden Befehl, um die AWS CLI-Befehle für Amazon EC2 aufzulisten.

```
aws ec2 help
```

Bevor Sie Befehle ausführen, richten Sie die Standardanmeldeinformationen ein. Weitere Informationen finden Sie unter [Konfigurieren der Einstellungen für die AWS CLI](cli-chap-configure.md).

Dieses Thema zeigt Kurzbeispiele von AWS CLI-Befehlen, die allgemeine Aufgaben für Amazon EC2 ausführen.

Langformbeispiele für AWS CLI-Befehle finden Sie im [AWS CLI-Codebeispiel-Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli) auf *GitHub*.

**Topics**
+ [Amazon EC2 EC2-Schlüsselpaare erstellen, anzeigen und löschen in der AWS CLI](cli-services-ec2-keypairs.md)
+ [Erstellen, Konfigurieren und Löschen von Amazon EC2-Sicherheitsgruppen in AWS CLI](cli-services-ec2-sg.md)
+ [Starten, Auflisten und Löschen von Amazon EC2 EC2-Instances in AWS CLI](cli-services-ec2-instances.md)
+ [Ändern Sie einen Amazon EC2 EC2-Instance-Typ mit einem Bash-Skript in AWS CLI](cli-services-ec2-instance-type-script.md)

# Amazon EC2 EC2-Schlüsselpaare erstellen, anzeigen und löschen in der AWS CLI
<a name="cli-services-ec2-keypairs"></a>

Sie können die AWS Command Line Interface (AWS CLI) verwenden, um Ihre Schlüsselpaare für Amazon Elastic Compute Cloud (Amazon EC2) zu erstellen, anzuzeigen und zu löschen. Sie verwenden Schlüsselpaare, um eine Verbindung zu einer Amazon-EC2-Instance herzustellen. Sie können das Schlüsselpaar für Amazon EC2 bereitstellen, wenn Sie die Instance erstellen. Anschließend verwenden Sie das Schlüsselpaar zur Authentifizierung, wenn Sie sich mit der Instance verbinden.

**Anmerkung**  
Weitere Befehlsbeispiele finden Sie im [.](https://docs.aws.amazon.com/cli/latest/reference/index.html)

**Topics**
+ [Voraussetzungen](#cli-services-ec2-keypairs-prereqs)
+ [Erstellen eines Schlüsselpaares](#creating-a-key-pair)
+ [Anzeigen Ihres Schlüsselpaars](#displaying-a-key-pair)
+ [Löschen Ihres Schlüsselpaars](#deleting-a-key-pair)
+ [Referenzen](#cli-services-ec2-keypairs-references)

## Voraussetzungen
<a name="cli-services-ec2-keypairs-prereqs"></a>

Zur Ausführung von `ec2`-Befehlen ist Folgendes erforderlich:
+ Installieren und Konfigurieren der AWS CLI. Weitere Informationen erhalten Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md) und [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
+ Legen Sie Ihre IAM-Berechtigungen fest, um Zugriff auf Amazon EC2 zu ermöglichen. Weitere Informationen zu IAM-Berechtigungen für Amazon EC2 finden Sie unter [IAM-Richtlinien für Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) im *Benutzerhandbuch zu Amazon EC2*.

## Erstellen eines Schlüsselpaares
<a name="creating-a-key-pair"></a>

Zum Erstellen eines Schlüsselpaars verwenden Sie den Befehl `[aws ec2 create-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-key-pair.html)` mit den Optionen `--query` und `--output text`, um den privaten Schlüssel direkt in eine Datei weiterzureichen.

```
$ aws ec2 create-key-pair --key-name MyKeyPair --query 'KeyMaterial' --output text > MyKeyPair.pem
```

Denn PowerShell die `> file` Umleitung verwendet standardmäßig die UTF-8-Kodierung, die bei einigen SSH-Clients nicht verwendet werden kann. Sie müssen die Ausgabe konvertieren, indem Sie sie an den Befehl `out-file` weiterreichen und die Kodierung explizit auf `ascii` festlegen.

```
PS C:\>aws ec2 create-key-pair --key-name MyKeyPair --query 'KeyMaterial' --output text | out-file -encoding ascii -filepath MyKeyPair.pem
```

Die resultierende Datei `MyKeyPair.pem` sollte wie folgt aussehen.

```
-----BEGIN RSA PRIVATE KEY-----
EXAMPLEKEYKCAQEAy7WZhaDsrA1W3mRlQtvhwyORRX8gnxgDAfRt/gx42kWXsT4rXE/b5CpSgie/
vBoU7jLxx92pNHoFnByP+Dc21eyyz6CvjTmWA0JwfWiW5/akH7iO5dSrvC7dQkW2duV5QuUdE0QW
Z/aNxMniGQE6XAgfwlnXVBwrerrQo+ZWQeqiUwwMkuEbLeJFLhMCvYURpUMSC1oehm449ilx9X1F
G50TCFeOzfl8dqqCP6GzbPaIjiU19xX/azOR9V+tpUOzEL+wmXnZt3/nHPQ5xvD2OJH67km6SuPW
oPzev/D8V+x4+bHthfSjR9Y7DvQFjfBVwHXigBdtZcU2/wei8D/HYwIDAQABAoIBAGZ1kaEvnrqu
/uler7vgIn5m7lN5LKw4hJLAIW6tUT/fzvtcHK0SkbQCQXuriHmQ2MQyJX/0kn2NfjLV/ufGxbL1
mb5qwMGUnEpJaZD6QSSs3kICLwWUYUiGfc0uiSbmJoap/GTLU0W5Mfcv36PaBUNy5p53V6G7hXb2
bahyWyJNfjLe4M86yd2YK3V2CmK+X/BOsShnJ36+hjrXPPWmV3N9zEmCdJjA+K15DYmhm/tJWSD9
81oGk9TopEp7CkIfatEATyyZiVqoRq6k64iuM9JkA3OzdXzMQexXVJ1TLZVEH0E7bhlY9d8O1ozR
oQs/FiZNAx2iijCWyv0lpjE73+kCgYEA9mZtyhkHkFDpwrSM1APaL8oNAbbjwEy7Z5Mqfql+lIp1
YkriL0DbLXlvRAH+yHPRit2hHOjtUNZh4Axv+cpg09qbUI3+43eEy24B7G/Uh+GTfbjsXsOxQx/x
p9otyVwc7hsQ5TA5PZb+mvkJ5OBEKzet9XcKwONBYELGhnEPe7cCgYEA06Vgov6YHleHui9kHuws
ayav0elc5zkxjF9nfHFJRry21R1trw2Vdpn+9g481URrpzWVOEihvm+xTtmaZlSp//lkq75XDwnU
WA8gkn6O3QE3fq2yN98BURsAKdJfJ5RL1HvGQvTe10HLYYXpJnEkHv+Unl2ajLivWUt5pbBrKbUC
gYBjbO+OZk0sCcpZ29sbzjYjpIddErySIyRX5gV2uNQwAjLdp9PfN295yQ+BxMBXiIycWVQiw0bH
oMo7yykABY7Ozd5wQewBQ4AdSlWSX4nGDtsiFxWiI5sKuAAeOCbTosy1s8w8fxoJ5Tz1sdoxNeGs
Arq6Wv/G16zQuAE9zK9vvwKBgF+09VI/1wJBirsDGz9whVWfFPrTkJNvJZzYt69qezxlsjgFKshy
WBhd4xHZtmCqpBPlAymEjr/TOlbxyARmXMnIOWIAnNXMGB4KGSyl1mzSVAoQ+fqR+cJ3d0dyPl1j
jjb0Ed/NY8frlNDxAVHE8BSkdsx2f6ELEyBKJSRr9snRAoGAMrTwYneXzvTskF/S5Fyu0iOegLDa
NWUH38v/nDCgEpIXD5Hn3qAEcju1IjmbwlvtW+nY2jVhv7UGd8MjwUTNGItdb6nsYqM2asrnF3qS
VRkAKKKYeGjkpUfVTrW0YFjXkfcrR/V+QFL5OndHAKJXjW7a4ejJLncTzmZSpYzwApc=
-----END RSA PRIVATE KEY-----
```

Ihr privater Schlüssel wird nicht gespeichert AWS und kann ***erst*** abgerufen werden, wenn er erstellt wurde. Später kann er nicht mehr wiederhergestellt werden. Wenn Sie den privaten Schlüssel verlieren, müssen Sie ein neues Schlüsselpaar erstellen.

Wenn Sie über einen Linux-Computer eine Verbindung zu Ihrer Instance herstellen, sollten Sie den folgenden Befehl verwenden, um die Berechtigungen für Ihre private Schlüsseldatei festzulegen, sodass nur Sie diese lesen können.

```
$ chmod 400 MyKeyPair.pem
```

## Anzeigen Ihres Schlüsselpaars
<a name="displaying-a-key-pair"></a>

Aus dem Schlüsselpaar wird ein „Fingerabdruck“ generiert, mit dem Sie überprüfen können, ob der private Schlüssel auf Ihrem lokalen Computer dem öffentlichen Schlüssel entspricht, der in AWS gespeichert ist. 

Der Fingerabdruck ist ein SHA1 Hash, der aus einer DER-codierten Kopie des privaten Schlüssels stammt. Dieser Wert wird bei der Erstellung des key pair erfasst und AWS zusammen mit dem öffentlichen Schlüssel gespeichert. Sie können den Fingerabdruck in der Amazon EC2 EC2-Konsole oder durch Ausführen des AWS CLI Befehls `[aws ec2 describe-key-pairs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-key-pairs.html)` anzeigen. 

Das folgende Beispiel zeigt den Fingerabdruck für `MyKeyPair`.

```
$ aws ec2 describe-key-pairs --key-name MyKeyPair
{
    "KeyPairs": [
        {
            "KeyName": "MyKeyPair",
            "KeyFingerprint": "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f"
        }
    ]
}
```

Weitere Informationen über Schlüssel und Fingerabdrücke finden Sie unter [Amazon-EC2-Schlüsselpaare](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) im *Amazon-EC2-Benutzerhandbuch*.

## Löschen Ihres Schlüsselpaars
<a name="deleting-a-key-pair"></a>

Um ein Schlüsselpaar zu löschen, führen Sie den `[aws ec2 delete-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-key-pair.html)`-Befehl aus und ersetzen dabei *`MyKeyPair`* durch den Namen des zu löschenden Paares.

```
$ aws ec2 delete-key-pair --key-name MyKeyPair
```

## Referenzen
<a name="cli-services-ec2-keypairs-references"></a>

**AWS CLI Referenz:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 create-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-key-pair.html)`
+ `[aws ec2 delete-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-key-pair.html)`
+ `[aws ec2 describe-key-pairs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-key-pairs.html)`

**Andere Referenz:**
+ [Amazon Elastic Compute Cloud-Dokumentation](https://docs.aws.amazon.com/ec2/)
+  AWS SDKs und AWS CLI Codebeispiele finden Sie im [AWS Codebeispiel-Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) unter *GitHub*.

# Erstellen, Konfigurieren und Löschen von Amazon EC2-Sicherheitsgruppen in AWS CLI
<a name="cli-services-ec2-sg"></a>

Sie können eine Sicherheitsgruppe, die im Wesentlichen als Firewall fungiert, für Ihre Amazon-Elastic-Compute-Cloud (Amazon EC2)-Instances mit Regeln erstellen, die den ein- und ausgehenden Netzwerkverkehr bestimmen. 

Verwenden Sie AWS Command Line Interface (AWS CLI), um eine Sicherheitsgruppe zu erstellen, Regeln zu vorhandenen Sicherheitsgruppen hinzuzufügen und Sicherheitsgruppen zu löschen. 

**Anmerkung**  
Weitere Befehlsbeispiele finden Sie im .

**Topics**
+ [Voraussetzungen](#cli-services-ec2-sg-prereqs)
+ [Eine Sicherheitsgruppe erstellen](#creating-a-security-group)
+ [Hinzufügen von Regeln zu Ihrer Sicherheitsgruppe](#configuring-a-security-group)
+ [Löschen Ihrer Sicherheitsgruppe](#deleting-a-security-group)
+ [Referenzen](#cli-services-ec2-sg-references)

## Voraussetzungen
<a name="cli-services-ec2-sg-prereqs"></a>

Zur Ausführung von `ec2`-Befehlen ist Folgendes erforderlich:
+ Installieren und Konfigurieren der AWS CLI. Weitere Informationen erhalten Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md) und [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
+ Legen Sie Ihre IAM-Berechtigungen fest, um Zugriff auf Amazon EC2 zu ermöglichen. Weitere Informationen zu IAM-Berechtigungen für Amazon EC2 finden Sie unter [IAM-Richtlinien für Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) im *Benutzerhandbuch zu Amazon EC2*.

## Eine Sicherheitsgruppe erstellen
<a name="creating-a-security-group"></a>

Sie können Sicherheitsgruppen erstellen, die virtuellen privaten Clouds zugeordnet sind (VPCs).

Im folgenden `[aws ec2 create-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-security-group.html)`-Beispiel wird gezeigt, wie Sie eine Sicherheitsgruppe für eine bestimmte VPC erstellen.

```
$ aws ec2 create-security-group --group-name my-sg --description "My security group" --vpc-id vpc-1a2b3c4d
{
    "GroupId": "sg-903004f8"
}
```

Zum Anzeigen der Anfangsinformationen für eine Sicherheitsgruppe führen Sie den Befehl `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)` aus. Sie können auf eine EC2-VPC-Sicherheitsgruppe nur mit der `vpc-id` und nicht mit ihrem Namen verweisen.

```
$ aws ec2 describe-security-groups --group-ids sg-903004f8
{
    "SecurityGroups": [
        {
            "IpPermissionsEgress": [
                {
                    "IpProtocol": "-1",
                    "IpRanges": [
                        {
                            "CidrIp": "0.0.0.0/0"
                        }
                    ],
                    "UserIdGroupPairs": []
                }
            ],
            "Description": "My security group"
            "IpPermissions": [],
            "GroupName": "my-sg",
            "VpcId": "vpc-1a2b3c4d",
            "OwnerId": "123456789012",
            "GroupId": "sg-903004f8"
        }
    ]
}
```

## Hinzufügen von Regeln zu Ihrer Sicherheitsgruppe
<a name="configuring-a-security-group"></a>

Wenn Sie eine Amazon-EC2-Instance ausführen, müssen Sie Regeln in der Sicherheitsgruppe aktivieren, um eingehenden Netzwerkverkehr für Ihre Art der Verbindung zum Image zu aktivieren. 

Wenn Sie beispielsweise eine Windows-Instance starten, fügen Sie im Allgemeinen eine Regel hinzu, um eingehenden Datenverkehr über TCP-Port 3389 zu erlauben, um das Remote Desktop Protocol (RDP) zu unterstützen. Beim Starten einer Linux-Instance fügen Sie im Allgemeinen eine Regel hinzu, um eingehenden Datenverkehr über TCP-Port 22 zu erlauben, um SSH-Verbindungen zu unterstützen. 

Fügen Sie mit dem Befehl `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)` eine Regel zu Ihrer Sicherheitsgruppe hinzu. Ein erforderlicher Parameter dieses Befehls ist die öffentliche IP-Adresse Ihres Computers oder das Netzwerk (in Form eines Adressbereichs), das mit Ihrem Computer verbunden ist. Dabei wird die [CIDR](https://wikipedia.org/wiki/Classless_Inter-Domain_Routing)-Notation verwendet.

**Anmerkung**  
Wir bieten den folgenden Dienst, [https://checkip.global.api.aws/](https://checkip.global.api.aws/), an, damit Sie Ihre öffentliche IP-Adresse ermitteln können. Zum Finden weiterer Services zur Identifizierung Ihrer IP-Adresse geben Sie in Ihren Browser "*wie lautet meine IP-Adresse*" ein. Wenn Sie eine Verbindung über einen ISP oder von hinter einer Firewall mit einer dynamischen IP-Adresse herstellen (über ein NAT-Gateway von einem privaten Netzwerk), können Sie diese regelmäßig ändern. In diesem Fall müssen Sie den IP-Adressbereich herausfinden, der von Client-Computern verwendet wird.

Im folgenden Beispiel wird gezeigt, wie Sie eine Regel für das RDP (TCP-Port 3389) zu einer EC2-VPC-Sicherheitsgruppe mit der ID `sg-903004f8` mithilfe Ihrer IP-Adresse hinzufügen.

Suchen Sie zunächst Ihre IP-Adresse.

```
$ curl https://checkip.amazonaws.com
x.x.x.x
```

Sie können die IP-Adresse dann zur Sicherheitsgruppe hinzufügen, indem Sie den `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)`-Befehl ausführen.

```
$ aws ec2 authorize-security-group-ingress --group-id sg-903004f8 --protocol tcp --port 3389 --cidr x.x.x.x/x
```

Der folgende Befehl fügt eine weitere Regel hinzu, um SSH-Instances in derselben Sicherheitsgruppe zu aktivieren.

```
$ aws ec2 authorize-security-group-ingress --group-id sg-903004f8 --protocol tcp --port 22 --cidr x.x.x.x/x
```

Zum Anzeigen der Änderungen der Sicherheitsgruppe führen Sie den Befehl `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)` aus.

```
$ aws ec2 describe-security-groups --group-ids sg-903004f8
{
    "SecurityGroups": [
        {
            "IpPermissionsEgress": [
                {
                    "IpProtocol": "-1",
                    "IpRanges": [
                        {
                            "CidrIp": "0.0.0.0/0"
                        }
                    ],
                    "UserIdGroupPairs": []
                }
            ],
            "Description": "My security group"
            "IpPermissions": [
                {
                    "ToPort": 22,
                    "IpProtocol": "tcp",
                    "IpRanges": [
                        {
                            "CidrIp": "x.x.x.x/x"
                        }
                    ]
                    "UserIdGroupPairs": [],
                    "FromPort": 22
                }
            ],
            "GroupName": "my-sg",
            "OwnerId": "123456789012",
            "GroupId": "sg-903004f8"
        }
    ]
}
```

## Löschen Ihrer Sicherheitsgruppe
<a name="deleting-a-security-group"></a>

Um eine Sicherheitsgruppe zu löschen, führen Sie den Befehl `[aws ec2 delete-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-security-group.html)` aus. 

**Anmerkung**  
Sie können eine Sicherheitsgruppe nicht löschen, wenn sie aktuell an eine Umgebung angefügt ist.

Das folgende Befehlsbeispiel löscht die EC2-VPC-Sicherheitsgruppe.

```
$ aws ec2 delete-security-group --group-id sg-903004f8
```

## Referenzen
<a name="cli-services-ec2-sg-references"></a>

**AWS CLI Referenz:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)`
+ `[aws ec2 create-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-security-group.html)`
+ `[aws ec2 delete-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-security-group.html)`
+ `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)`

**Andere Referenz:**
+ [Amazon Elastic Compute Cloud-Dokumentation](https://docs.aws.amazon.com/ec2/)
+  AWS SDKs und AWS CLI Codebeispiele und Beiträge dazu finden Sie im [AWS Codebeispiel-Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) unter *GitHub*.

# Starten, Auflisten und Löschen von Amazon EC2 EC2-Instances in AWS CLI
<a name="cli-services-ec2-instances"></a>

Sie können die AWS Command Line Interface (AWS CLI) verwenden, um Amazon Elastic Compute Cloud (Amazon EC2) -Instances zu starten, aufzulisten und zu löschen. Wenn Sie eine Instance starten, die nicht zum AWS kostenlosen Kontingent gehört, wird Ihnen nach dem Start der Instance eine Rechnung gestellt und die Zeit berechnet, während die Instance läuft, auch wenn sie inaktiv bleibt.

**Anmerkung**  
Weitere Befehlsbeispiele finden Sie im [.](https://docs.aws.amazon.com/cli/latest/reference/index.html)

**Topics**
+ [Voraussetzungen](#cli-services-ec2-instances-prereqs)
+ [Starten Ihrer Instance](#launching-instances)
+ [Hinzufügen eines Blockgeräts zu Ihrer Instance](#block-device-mapping)
+ [Hinzufügen eines Tags zu Ihrer Instance](#tagging-instances)
+ [Herstellen einer Verbindung zu Ihrer Instance](#connecting-to-instances)
+ [Auflisten Ihrer Instances](#listing-instances)
+ [Löschen Ihrer Instance](#terminating-instances)
+ [Referenzen](#cli-services-ec2-instances-references)

## Voraussetzungen
<a name="cli-services-ec2-instances-prereqs"></a>

Um die `ec2`-Befehle in diesem Thema auszuführen, sind folgende Schritte erforderlich:
+ Installieren und Konfigurieren der AWS CLI. Weitere Informationen erhalten Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md) und [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
+ Legen Sie Ihre IAM-Berechtigungen fest, um Zugriff auf Amazon EC2 zu ermöglichen. Weitere Informationen zu IAM-Berechtigungen für Amazon EC2 finden Sie unter [IAM-Richtlinien für Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) im *Benutzerhandbuch zu Amazon EC2*.
+ Erstellen Sie ein [Schlüsselpaar](cli-services-ec2-keypairs.md) und eine [Sicherheitsgruppe](cli-services-ec2-sg.md).
+ Wählen Sie ein Amazon Machine Image (AMI) aus und notieren Sie sich die AMI-ID. Weitere Informationen finden Sie im Thema [Suchen eines geeigneten AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html) im *Benutzerhandbuch zu Amazon EC2*.

## Starten Ihrer Instance
<a name="launching-instances"></a>

Zum Starten einer Amazon-EC2-Instance mithilfe des AMI, das Sie ausgewählt haben, verwenden Sie den Befehl `[aws ec2 run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html)`. Sie können die Instance in einer Virtual Private Cloud (VPC) starten.

Die Instance weist zu Beginn den Status `pending` auf. Sie wechselt aber nach wenigen Minuten in den Status `running`.

Im folgenden Beispiel wird gezeigt, wie eine `t2.micro`-Instance im angegebenen Subnetz einer VPC gestartet wird. Ersetzen Sie die *italicized* Parameterwerte durch eigene.

```
$ aws ec2 run-instances --image-id ami-xxxxxxxx --count 1 --instance-type t2.micro --key-name MyKeyPair --security-group-ids sg-903004f8 --subnet-id subnet-6e7f829e
{
    "OwnerId": "123456789012",
    "ReservationId": "r-5875ca20",
    "Groups": [
        {
            "GroupName": "my-sg",
            "GroupId": "sg-903004f8"
        }
    ],
    "Instances": [
        {
            "Monitoring": {
                "State": "disabled"
            },
            "PublicDnsName": null,
            "Platform": "windows",
            "State": {
                "Code": 0,
                "Name": "pending"
            },
            "EbsOptimized": false,
            "LaunchTime": "2013-07-19T02:42:39.000Z",
            "PrivateIpAddress": "10.0.1.114",
            "ProductCodes": [],
            "VpcId": "vpc-1a2b3c4d",
            "InstanceId": "i-5203422c",
            "ImageId": "ami-173d747e",
            "PrivateDnsName": "ip-10-0-1-114.ec2.internal",
            "KeyName": "MyKeyPair",
            "SecurityGroups": [
                {
                    "GroupName": "my-sg",
                    "GroupId": "sg-903004f8"
                }
            ],
            "ClientToken": null,
            "SubnetId": "subnet-6e7f829e",
            "InstanceType": "t2.micro",
            "NetworkInterfaces": [
                {
                    "Status": "in-use",
                    "SourceDestCheck": true,
                    "VpcId": "vpc-1a2b3c4d",
                    "Description": "Primary network interface",
                    "NetworkInterfaceId": "eni-a7edb1c9",
                    "PrivateIpAddresses": [
                        {
                            "PrivateDnsName": "ip-10-0-1-114.ec2.internal",
                            "Primary": true,
                            "PrivateIpAddress": "10.0.1.114"
                        }
                    ],
                    "PrivateDnsName": "ip-10-0-1-114.ec2.internal",
                    "Attachment": {
                        "Status": "attached",
                        "DeviceIndex": 0,
                        "DeleteOnTermination": true,
                        "AttachmentId": "eni-attach-52193138",
                        "AttachTime": "2013-07-19T02:42:39.000Z"
                    },
                    "Groups": [
                        {
                            "GroupName": "my-sg",
                            "GroupId": "sg-903004f8"
                        }
                    ],
                    "SubnetId": "subnet-6e7f829e",
                    "OwnerId": "123456789012",
                    "PrivateIpAddress": "10.0.1.114"
                }              
            ],
            "SourceDestCheck": true,
            "Placement": {
                "Tenancy": "default",
                "GroupName": null,
                "AvailabilityZone": "us-west-2b"
            },
            "Hypervisor": "xen",
            "BlockDeviceMappings": [
                {
                    "DeviceName": "/dev/sda1",
                    "Ebs": {
                        "Status": "attached",
                        "DeleteOnTermination": true,
                        "VolumeId": "vol-877166c8",
                        "AttachTime": "2013-07-19T02:42:39.000Z"
                    }
                }              
            ],
            "Architecture": "x86_64",
            "StateReason": {
                "Message": "pending",
                "Code": "pending"
            },
            "RootDeviceName": "/dev/sda1",
            "VirtualizationType": "hvm",
            "RootDeviceType": "ebs",
            "Tags": [
                {
                    "Value": "MyInstance",
                    "Key": "Name"
                }
            ],
            "AmiLaunchIndex": 0
        }
    ]
}
```

## Hinzufügen eines Blockgeräts zu Ihrer Instance
<a name="block-device-mapping"></a>

Jede gestartete Instance hat ein zugehöriges Root-Gerät-Volume. Sie können das Blockgerät-Mapping verwenden, um zusätzliche Amazon-Elastic-Block-Store (Amazon EBS)-Volumes oder Instance-Speicher-Volumes anzugeben, die an eine Instance angehängt werden, wenn diese gestartet wird.

Zum Hinzufügen eines Blockgeräts zu Ihrer Instance geben Sie die Option `--block-device-mappings` an, wenn Sie `run-instances` verwenden.

Der folgende Beispielparameter stellt ein Standard-Amazon-EBS-Volume von 20 GB bereit und ordnet dieses mit der ID `/dev/sdf` Ihrer Instance zu.

```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false}}]"
```

Im folgenden Beispiel wird ein Amazon-EBS-Volume hinzugefügt, das `/dev/sdf` zugeordnet ist, basierend auf einem vorhandenen Snapshot. Ein Snapshot stellt ein Image dar, das für Sie in das Volume geladen wurde. Wenn Sie einen Snapshot angeben, müssen Sie keine Volume-Größe angeben; es wird groß genug für Ihr Image sein. Wenn Sie aber einen Größenwert angeben, muss dieser größer oder gleich der Snapshot-Größe sein.

```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"Ebs\":{\"SnapshotId\":\"snap-a1b2c3d4\"}}]"
```

Im folgenden Beispiel werden zwei Volumes zu Ihrer Instance hinzugefügt. Die Anzahl der Volumes, die für Ihre Instance verfügbar sind, hängt vom Instance-Typ ab.

```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"VirtualName\":\"ephemeral0\"},{\"DeviceName\":\"/dev/sdg\",\"VirtualName\":\"ephemeral1\"}]"
```

Das folgende Beispiel erstellt das Mapping (`/dev/sdj`), stellt aber kein Volume für die Instance bereit.

```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdj\",\"NoDevice\":\"\"}]"
```

Weitere Informationen finden Sie im Abschnitt [Blockgerät-Zuweisung](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html) im *Benutzerhandbuch zu Amazon EC2*.

## Hinzufügen eines Tags zu Ihrer Instance
<a name="tagging-instances"></a>

Ein Tag ist eine Bezeichnung, die Sie einer AWS Ressource zuweisen. Damit können Sie Metadaten zu Ressourcen hinzufügen, die Sie für eine Vielzahl von Zwecken einsetzen können. Weitere Informationen finden Sie unter [Tagging Ihrer Ressourcen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) im *Benutzerhandbuch zu Amazon EC2*.

Das folgende Beispiel zeigt, wie Sie ein Tag mit dem Schlüsselnamen „`Name`“ und den Wert „`MyInstance`“ zur angegebenen Instance hinzufügen, in dem Sie den Befehl `[aws ec2 create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html)` verwenden.

```
$ aws ec2 create-tags --resources i-5203422c --tags Key=Name,Value=MyInstance
```

## Herstellen einer Verbindung zu Ihrer Instance
<a name="connecting-to-instances"></a>

Wenn die Instance ausgeführt wird, können Sie eine Verbindung mit ihr herstellen und sie genau so verwenden wie einen Computer, der sich direkt vor Ihnen befindet. Weitere Informationen finden Sie unter [Verbinden mit Ihrer Amazon-EC2-Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) im *Benutzerhandbuch zu Amazon EC2*.

## Auflisten Ihrer Instances
<a name="listing-instances"></a>

Sie können das verwenden AWS CLI , um Ihre Instanzen aufzulisten und Informationen über sie einzusehen. Sie können alle Ihre Instances auflisten oder die Ergebnisse auf der Grundlage der Instances, die für Sie von Interesse sind, filtern.

Die folgenden Beispiele demonstrieren die Verwendung des `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html)`-Befehls.

Mit dem folgenden Befehl werden alle Ihre Instances aufgelistet.

```
$ aws ec2 describe-instances
```

Der folgende Befehl filtert die Liste nur nach Ihren `t2.micro`-Instances und gibt nur die `InstanceId`-Werte für die einzelnen Übereinstimmungen aus.

```
$ aws ec2 describe-instances --filters "Name=instance-type,Values=t2.micro" --query "Reservations[].Instances[].InstanceId"
[
    "i-05e998023d9c69f9a"
]
```

Der folgende Befehl listet alle Ihre Instances mit dem Tag `Name=MyInstance` auf.

```
$ aws ec2 describe-instances --filters "Name=tag:Name,Values=MyInstance"
```

Der folgende Befehl listet Ihre Instances auf, die mit einer der folgenden Methoden gestartet wurden AMIs: `ami-x0123456``ami-y0123456`, und`ami-z0123456`.

```
$ aws ec2 describe-instances --filters "Name=image-id,Values=ami-x0123456,ami-y0123456,ami-z0123456"
```

## Löschen Ihrer Instance
<a name="terminating-instances"></a>

Sie können die verwenden AWS CLI , um eine Amazon EC2 EC2-Instance zu beenden (zu löschen), wenn Sie sie nicht mehr benötigen.

**Wichtig**  
**Das Beenden einer Instance ist dauerhaft und irreversibel.**  
Nachdem Sie eine Instance beendet haben, können Sie keine Verbindung mehr zu ihr herstellen und sie kann nicht wiederhergestellt werden. Alle angehängten Amazon-EBS-Volumes, die so konfiguriert sind, dass sie beim Beenden gelöscht werden, werden ebenfalls dauerhaft gelöscht und können nicht wiederhergestellt werden. Alle auf den Instance-Speicher-Volumes gespeicherten Daten gehen dauerhaft verloren. Weitere Informationen finden Sie unter [So funktioniert die Instance-Kündigung](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-ec2-instance-termination-works.html).  
Bevor Sie eine Instance beenden, stellen Sie sicher, dass Sie alle Daten, die Sie nach der Beendigung behalten müssen, im persistenten Speicher gesichert haben.

Sobald der Status der Instance zu `shutting-down` oder `terminated` wechselt, fallen für diese Instance keine Gebühren mehr an. Wenn Sie später eine erneute Verbindung zu einer Instance herstellen möchten, verwenden Sie [stop-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/stop-instances.html) statt `terminate-instances`. Weitere Informationen finden Sie unter [Beenden Ihrer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) im *Amazon-EC2-Benutzerhandbuch*.

Das folgende Beispiel zeigt, wie eine Instanz mithilfe des `[aws ec2 terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html)` Befehls gelöscht wird.

```
$ aws ec2 terminate-instances --instance-ids i-5203422c
{
    "TerminatingInstances": [
        {
            "InstanceId": "i-5203422c",
            "CurrentState": {
                "Code": 32,
                "Name": "shutting-down"
            },
            "PreviousState": {
                "Code": 16,
                "Name": "running"
            }
        }
    ]
}
```

## Referenzen
<a name="cli-services-ec2-instances-references"></a>

**AWS CLI Referenz:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html)`
+ `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html)`
+ `[aws ec2 run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html)`
+ `[aws ec2 terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html)`

**Andere Referenz:**
+ [Amazon Elastic Compute Cloud-Dokumentation](https://docs.aws.amazon.com/ec2/)
+  AWS SDKs und AWS CLI Codebeispiele und Beiträge dazu finden Sie im [AWS Codebeispiel-Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) unter *GitHub*.

# Ändern Sie einen Amazon EC2 EC2-Instance-Typ mit einem Bash-Skript in AWS CLI
<a name="cli-services-ec2-instance-type-script"></a>

Dieses Bash-Skripting-Beispiel für Amazon EC2 ändert den Instance-Typ für eine Amazon EC2 EC2-Instance mithilfe von (). AWS Command Line Interface AWS CLI Dabei wird die Instance gestoppt, wenn sie ausgeführt wird, der Instance-Typ wird geändert und dann wird die Instance, falls angefordert, neu gestartet. Shell-Skripte sind Programme, die in einer Befehlszeilenschnittstelle ausgeführt werden sollen.

**Anmerkung**  
[Weitere Befehlsbeispiele finden Sie im .AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html)

**Topics**
+ [Bevor Sie beginnen](#cli-services-ec2-instance-type-script-prereqs)
+ [Über das Beispiel](#cli-services-ec2-instance-type-script-about)
+ [Parameters](#cli-services-ec2-instance-type-script-params)
+ [Dateien](#cli-services-ec2-instance-type-script-files.title)
+ [Referenzen](#cli-services-ec2-instance-type-script-references)

## Bevor Sie beginnen
<a name="cli-services-ec2-instance-type-script-prereqs"></a>

Bevor Sie eines der folgenden Beispiele ausführen können, müssen die folgenden Schritte abgeschlossen werden.
+ Installieren und Konfigurieren der AWS CLI. Weitere Informationen erhalten Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md) und [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
+ Das von Ihnen verwendete Profil muss über Berechtigungen verfügen, die die in den Beispielen ausgeführten AWS Operationen zulassen.
+ Eine laufende Amazon-EC2-Instance in dem Konto, für das Sie die Berechtigung zum Beenden und Ändern haben. Wenn Sie das Testskript ausführen, startet es eine Instance, testet die Änderung des Typs und beendet dann die Instance.
+ Es hat sich AWS bewährt, diesem Code die geringsten Rechte oder nur die zum Ausführen einer Aufgabe erforderlichen Berechtigungen zu gewähren. Weitere Informationen finden Sie unter [Gewähren der geringsten Berechtigung](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) im *AWS -Identity-and-Access-Management-(IAM)-Benutzerhandbuch*.
+ Dieser Code wurde nicht in allen AWS Regionen getestet. Einige AWS Dienste sind nur in bestimmten Regionen verfügbar. Weitere Informationen finden Sie unter [Service-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) im *allgemeinen AWS -Referenzhandbuch*. 
+ Wenn Sie diesen Code ausführen, kann dies zu Gebühren für Ihr AWS Konto führen. Es liegt in Ihrer Verantwortung sicherzustellen, dass alle durch dieses Skript erstellten Ressourcen entfernt werden, wenn Sie mit ihnen fertig sind. 

## Über das Beispiel
<a name="cli-services-ec2-instance-type-script-about"></a>

Dieses Beispiel ist als Funktion in der Shell-Skriptdatei `change_ec2_instance_type.sh` geschrieben, die Sie von einem anderen Skript oder von der Befehlszeile aus `source` können. Jede Skriptdatei enthält Kommentare, die jede der Funktionen beschreiben. Sobald sich die Funktion im Speicher befindet, können Sie sie über die Befehlszeile aufrufen. Mit den folgenden Befehlen wird beispielsweise der Typ der angegebenen Instance in `t2.nano` geändert:

```
$ source ./change_ec2_instance_type.sh
$ ./change_ec2_instance_type -i *instance-id* -t new-type
```

Das vollständige Beispiel und die herunterladbaren Skriptdateien finden Sie unter [Ändern des Amazon EC2 EC2-Instance-Typs](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/ec2/change-ec2-instance-type) im *AWS Codebeispiel-Repository* unter *GitHub*.

## Parameters
<a name="cli-services-ec2-instance-type-script-params"></a>

**-i** – *(String)* Gibt die zu ändernde Instance-ID an.

**-t** – *(String)* Gibt den Instance-Typ von Amazon-EC2 an, zu dem gewechselt werden soll.

**-r** – *(Switch)* Ist standardmäßig nicht festgelegt. Wenn `-r` festgelegt ist, startet die Instance nach dem Typwechsel neu.

**-f** – *(Switch)* Standardmäßig fordert das Skript den Benutzer auf, das Herunterfahren der Instance zu bestätigen, bevor der Wechsel vorgenommen wird. Wenn `-f` festgelegt ist, wird der Benutzer nicht aufgefordert, das Herunterfahren der Instance zu bestätigen, bevor der Typwechsel vorgenommen wird.

**-V** – *(Switch)* Standardmäßig arbeitet das Skript im Hintergrund und zeigt die Ausgabe nur im Fehlerfall an. Wenn `-v` festgelegt ist, zeigt die Funktion während der gesamten Ausführungszeit den Status an.

## Dateien
<a name="cli-services-ec2-instance-type-script-files.title"></a>

**`change_ec2_instance_type.sh`**  
Die Hauptskriptdatei enthält die `change_ec2_instance_type()`-Funktion, die die folgenden Aufgaben ausführt:  
+ Prüft, ob die angegebene Amazon-EC2-Instance vorhanden ist.
+ Warnt den Benutzer, bevor die Instance gestoppt wird, sofern `-f` nicht ausgewählt ist.
+ Ändert den Instance-Typ
+ Wenn Sie `-r` festlegen, wird die Instance neu gestartet und bestätigt, dass die Instance ausgeführt wird
Sehen Sie sich den Code für `[change\$1ec2\$1instance\$1type.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/change_ec2_instance_type.sh)` on an. *GitHub*

**`test_change_ec2_instance_type.sh`**  
Das `test_change_ec2_instance_type.sh`-Dateiskript testet die verschiedenen Codepfade für die `change_ec2_instance_type`-Funktion. Wenn alle Schritte im Testskript ordnungsgemäß funktionieren, entfernt das Testskript alle von ihm erstellten Ressourcen.  
Sie können das Testskript mit den folgenden Parametern ausführen:  
+ **-v** — *(Schalter)* Jeder Test zeigt während der Ausführung einen pass/failure Status an. Standardmäßig werden die Tests im Hintergrund ausgeführt und die Ausgabe enthält nur den endgültigen pass/failure Gesamtstatus.
+ **-i** – *(Schalter)* Das Skript wird nach jedem Test angehalten, damit Sie die Zwischenergebnisse jedes Schritts durchsuchen können. Mit dieser Option können Sie den aktuellen Status der Instance mit der Amazon-EC2-Konsole überprüfen. Das Skript fährt mit dem nächsten Schritt fort, nachdem Sie an der Eingabeaufforderung die *EINGABETASTE* gedrückt haben.
Zeigen Sie den Code für `[test\$1change\$1ec2\$1instance\$1type.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/test_change_ec2_instance_type.sh)` on an. *GitHub*

**`awsdocs_general.sh`**  
Die Skriptdatei `awsdocs_general.sh` enthält allgemeine Funktionen, die in erweiterten Beispielen für die AWS CLI verwendet werden.  
Sehen Sie sich den Code für `[awsdocs\$1general.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/awsdocs_general.sh)` on an *GitHub*.

## Referenzen
<a name="cli-services-ec2-instance-type-script-references"></a>

**AWS CLI Referenz:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/v1/reference/ec2/index.html)`
+ `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/describe-instances.html)`
+ `[aws ec2 modify-instance-attribute](https://docs.aws.amazon.com/cli/v1/reference/ec2/modify-instance-attribute.html)`
+ `[aws ec2 start-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/start-instances.html)`
+ `[aws ec2 stop-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/stop-instances.html)`
+ `[aws ec2 wait instance-running](https://docs.aws.amazon.com/cli/v1/reference/ec2/wait/instance-running.html)`
+ `[aws ec2 wait instance-stopped](https://docs.aws.amazon.com/cli/v1/reference/ec2/wait/instance-stopped.html)`

**Andere Referenz:**
+ [Amazon Elastic Compute Cloud-Dokumentation](https://docs.aws.amazon.com/ec2/)
+  AWS SDKs und AWS CLI Codebeispiele und Beiträge dazu finden Sie im [AWS Codebeispiel-Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) unter *GitHub*.