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.
# Beispiele für geführte Befehle für die AWS CLI
Die AWS Command Line Interface (AWS CLI) ist ein Open-Source-Tool, mit dem Sie über Befehle in Ihrer Befehlszeilen-Shell mit einer Vielzahl von AWS-Services-Services interagieren können. Dieser Abschnitt enthält angeleitete Beispiele, die zeigen, wie Sie mithilfe der AWS CLI auf einige der AWS-Services zugreifen können. Dazu gehören einige der benutzerdefinierten AWS CLI-Befehle, z. B. die High-Level-Befehle von `aws s3`. Diese Befehlsbeispiele veranschaulichen allgemeine Aktionen, die für einige AWS-Services verwendet werden, und bieten zusätzliche Ressourcen für weitere Informationen.
Unabhängig davon, ob Sie ein erfahrener AWS-Benutzer oder noch nicht mit der AWS CLI vertraut sind, dienen diese geführten Beispiele als Ressource zur Optimierung Ihrer AWS-Operationen.
Eine vollständige Referenz aller verfügbaren Befehle für jeden einzelnen AWS-Service finden Sie im [Referenzhandbuch zu AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/reference/index.html). Darüber hinaus können Sie die [integrierte Befehlszeilenhilfe](cli-usage-help.md) verwenden, um sich mit den verschiedenen Befehlen, Optionen und Funktionen der AWS CLI vertraut zu machen.
Weitere Befehlsbeispiele, die in diesem Abschnitt nicht verfügbar sind, finden Sie im Abschnitt [AWS CLI Befehlsbeispiele](cli_code_examples.md). Dabei handelt es sich um Open-Source-Befehlsbeispiele, die auch im [Referenzhandbuch zu AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/reference/index.html) verfügbar sind. Befehlsbeispiele werden im [AWS CLI](https://github.com/aws/aws-cli/tree/develop/awscli/examples)-Repository auf *GitHub* gehostet.
Beispiele für das Bash-Scripting mit Open-Source-Optionen finden Sie unter [AWS CLI mit Bash-Skriptcodebeispielen](bash_code_examples.md). Bash-Scripting-Beispiele werden im [AWS-Code Examples Repository auf *GitHub*](https://github.com/awsdocs/aws-doc-sdk-examples) gehostet.
**Topics**
+ [DynamoDB](cli-services-dynamodb.md)
+ [Amazon EC2](cli-services-ec2.md)
+ [Amazon Glacier](cli-services-glacier.md)
+ [IAM](cli-services-iam.md)
+ [Amazon S3](cli-services-s3.md)
+ [Amazon SNS](cli-services-sns.md)
# Verwenden von Amazon DynamoDB in der AWS CLI
Die AWS Command Line Interface (AWS CLI) unterstützt alle AWS-Datenbank-Services, einschließlich Amazon DynamoDB. Sie können die AWS CLI für improvisierte Vorgänge wie das Erstellen einer Tabelle verwenden. Sie können damit auch DynamoDB-Vorgänge in Hilfsprogrammskripts einbetten.
Weitere Informationen zur Verwendung der AWS CLI mit DynamoDB finden Sie unter ```[dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)` in der *AWS CLI-Befehlsreferenz*.
Verwenden Sie den folgenden Befehl, um die AWS CLI-Befehle für DynamoDB aufzulisten.
```
$ aws dynamodb help
```
**Topics**
+ [Voraussetzungen](#cli-services-dynamodb-prereqs)
+ [Erstellen und Verwenden von DynamoDB-Tabellen](#cli-services-dynamodb-using)
+ [Verwenden von DynamoDB Local](#cli-services-dynamodb-local)
+ [Ressourcen](#cli-services-dynamodb-resources)
## Voraussetzungen
Zur Ausführung von `dynamodb`-Befehlen ist Folgendes erforderlich:
+ Installieren und Konfigurieren der AWS CLI. Weitere Informationen finden 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).
## Erstellen und Verwenden von DynamoDB-Tabellen
Das Befehlszeilenformat besteht aus einem DynamoDB-Befehlsnamen, gefolgt von den Parametern für diesen Befehl. Die AWS CLI unterstützt die CLI-[Syntax-Kurznotation](cli-usage-shorthand.md) für die Parameterwerte und JSON (vollständig).
Im folgenden Beispiel wird eine Tabelle mit dem Namen `MusicCollection` erstellt.
```
$ aws dynamodb create-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=1,WriteCapacityUnits=1
```
Sie können neue Zeilen zur Tabelle hinzufügen mithilfe von Befehlen, die denen im folgenden Beispiel ähneln. Diese Beispiele verwenden eine Kombination von Syntax-Kurznotation und JSON.
```
$ aws dynamodb put-item \
--table-name MusicCollection \
--item '{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"} ,
"AlbumTitle": {"S": "Somewhat Famous"}
}' \
--return-consumed-capacity TOTAL
{
"ConsumedCapacity": {
"CapacityUnits": 1.0,
"TableName": "MusicCollection"
}
}
```
```
$ aws dynamodb put-item \
--table-name MusicCollection \
--item '{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"} ,
"AlbumTitle": {"S": "Songs About Life"}
}' \
--return-consumed-capacity TOTAL
{
"ConsumedCapacity": {
"CapacityUnits": 1.0,
"TableName": "MusicCollection"
}
}
```
Es ist nicht einfach, einen gültigen JSON-Code in einem einzeiligen Befehl unterzubringen. Um dies zu vereinfachen, kann die AWS CLI JSON-Dateien lesen. Betrachten Sie dazu das folgende Beispiel für einen JSON-Codeausschnitt. Er wird in einer Datei mit dem Namen `expression-attributes.json` gespeichert.
```
{
":v1": {"S": "No One You Know"},
":v2": {"S": "Call Me Today"}
}
```
Sie können diese Datei verwenden, um eine `query`-Anfrage mithilfe der AWS CLI auszugeben. Im folgenden Beispiel wird der Inhalt der Datei `expression-attributes.json` für den Wert des Parameters `--expression-attribute-values` verwendet.
```
$ aws dynamodb query --table-name MusicCollection \
--key-condition-expression "Artist = :v1 AND SongTitle = :v2" \
--expression-attribute-values file://expression-attributes.json
{
"Count": 1,
"Items": [
{
"AlbumTitle": {
"S": "Somewhat Famous"
},
"SongTitle": {
"S": "Call Me Today"
},
"Artist": {
"S": "No One You Know"
}
}
],
"ScannedCount": 1,
"ConsumedCapacity": null
}
```
## Verwenden von DynamoDB Local
Außer mit DynamoDB können Sie die AWS CLI auch mit DynamoDB Local verwenden. DynamoDB Local ist eine kleine clientseitige Datenbank, die nach dem Vorbild des DynamoDB-Service funktioniert. Mit DynamoDB Local können Sie Anwendungen schreiben, die die DynamoDB-API verwenden, ohne Tabellen oder Daten im DynamoDB-Webservice zu ändern. Stattdessen werden alle API-Aktionen an eine lokale Datenbank umgeleitet. Dies ermöglicht Ihnen Einsparungen, die den bereitgestellten Durchsatz, die Datenspeicherung und Datenübertragungsgebühren betreffen.
Weitere Informationen zu DynamoDB Local und der Verwendung mit AWS CLI finden Sie in den folgenden Abschnitten im [Amazon-DynamoDB-Entwicklerhandbuch](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/):
+ [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html)
+ [Verwendung der AWS CLI mit DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.CLI.html#UsingWithDDBLocal)
## Ressourcen
**AWS CLI-Referenz:**
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/query.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/query.html)
**Service-Referenz:**
+ [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html) im Entwicklerhandbuch zu Amazon DynamoDB
+ [Verwendung mit AWS CLI DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.CLI.html#UsingWithDDBLocal) im Entwicklerhandbuch zu Amazon DynamoDB
# Verwenden von Amazon EC2 in der AWS CLI
| Eine Einführung in Amazon Elastic Compute Cloud |
| --- |
| [](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
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
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
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
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
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
**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
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
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
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
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
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
**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
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
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
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
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
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
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
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
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
**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
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
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
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
**-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
**`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
**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*.
# Verwendung von Amazon Glacier in AWS CLI
| Eine Einführung in Amazon Glacier |
| --- |
| |
Dieses Thema zeigt Beispiele für AWS CLI Befehle, die allgemeine Aufgaben für Amazon Glacier ausführen. Die Beispiele zeigen, wie Sie mithilfe von eine große Datei AWS CLI auf Amazon Glacier hochladen können, indem Sie sie in kleinere Teile aufteilen und diese über die Befehlszeile hochladen.
Sie können mit dem AWS Command Line Interface (AWS CLI) auf Amazon Glacier-Funktionen zugreifen. Verwenden Sie den folgenden Befehl, um die AWS CLI Befehle für Amazon Glacier aufzulisten.
```
aws glacier help
```
**Anmerkung**
Weitere Befehlsreferenzen und -beispiele finden Sie unter `[aws glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html)` in der *AWS CLI -Befehlsreferenz*..
**Topics**
+ [Voraussetzungen](#cli-services-glacier-prereqs)
+ [Einen Amazon Glacier-Tresor erstellen](#cli-services-glacier-vault)
+ [Vorbereiten einer Datei zum Hochladen](#cli-services-glacier-prep)
+ [Starten eines mehrteiligen Uploads und Hochladen der Dateien](#cli-services-glacier-initiate)
+ [Abschließen des Uploads](#cli-services-glacier-complete)
+ [Ressourcen](#cli-services-glacier-resources)
## Voraussetzungen
Zur Ausführung von `glacier`-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).
+ Dieses Tutorial verwendet mehrere Befehlszeilentools, die normalerweise auf Unix-ähnlichen Betriebssystemen vorinstalliert sind, einschließlich Linux und macOS. Windows-Benutzer können die gleichen Tools verwenden, indem Sie [Cygwin](https://www.cygwin.com/) installieren und die Befehle vom Cygwin-Terminal ausführen. Wir geben systemeigene Windows-Befehle und -Hilfsprogramme an, die die gleichen Funktionen ausführen, sofern verfügbar.
## Einen Amazon Glacier-Tresor erstellen
Erstellen Sie einen Tresor mit dem Befehl `[create-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/create-vault.html)`.
```
$ aws glacier create-vault --account-id - --vault-name myvault
{
"location": "/123456789012/vaults/myvault"
}
```
**Anmerkung**
Alle Amazon Glacier-Befehle erfordern einen Konto-ID-Parameter. Verwenden Sie den Bindestrich (`--account-id -`), um das aktuelle Konto zu verwenden.
## Vorbereiten einer Datei zum Hochladen
Erstellen Sie eine Datei für einen Probe-Upload. Mit den folgenden Befehlen wird eine Datei mit dem Namen erstellt*largefile*, die genau 3 MiB an zufälligen Daten enthält.
**Linux oder macOS**
```
$ dd if=/dev/urandom of=largefile bs=3145728 count=1
1+0 records in
1+0 records out
3145728 bytes (3.1 MB) copied, 0.205813 s, 15.3 MB/s
```
`dd` ist ein Hilfsprogramm, das eine Anzahl von Bytes aus einer Eingabedatei in eine Ausgabedatei kopiert. Im vorigen Beispiel wird die Systemgerätedatei `/dev/urandom` als Quelle für Zufallsdaten verwendet. `fsutil` führt eine ähnliche Funktion in Windows aus.
**Windows**
```
C:\> fsutil file createnew largefile 3145728
File C:\temp\largefile is created
```
Teilen Sie als Nächstes die Datei mithilfe eines Programms zur Dateiaufteilung in 1-MiB-Blöcke (1 048 576 Byte) auf.
```
$ split -b 1048576 --verbose largefile chunk
creating file `chunkaa'
creating file `chunkab'
creating file `chunkac'
```
## Starten eines mehrteiligen Uploads und Hochladen der Dateien
Erstellen Sie mithilfe des `[initiate-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html)` Befehls einen mehrteiligen Upload in Amazon Glacier.
```
$ aws glacier initiate-multipart-upload --account-id - --archive-description "multipart upload test" --part-size 1048576 --vault-name myvault
{
"uploadId": "19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ",
"location": "/123456789012/vaults/myvault/multipart-uploads/19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
}
```
Amazon Glacier benötigt die Größe jedes Teils in Byte (1 MiB in diesem Beispiel), Ihren Tresornamen und eine Konto-ID, um den mehrteiligen Upload zu konfigurieren. Der AWS CLI gibt eine Upload-ID aus, wenn der Vorgang abgeschlossen ist. Speichern Sie diesen Upload-ID zur späteren Verwendung in einer Shell-Variablen.
**Linux oder macOS**
```
$ UPLOADID="19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
```
**Windows**
```
C:\> set UPLOADID="19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
```
Verwenden Sie als Nächstes den Befehl `[upload-multipart-part](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-multipart-part.html)`, um die drei Teile hochzuladen.
```
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkaa --range 'bytes 0-1048575/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkab --range 'bytes 1048576-2097151/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkac --range 'bytes 2097152-3145727/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
```
**Anmerkung**
Im vorigen Beispiel wird das Dollarzeichen (`$`) verwendet, um die Inhalte der `UPLOADID` Shell-Variablen unter Linux zu referenzieren. Verwenden Sie in der Windows-Befehlszeile ein Prozentzeichen (%) auf beiden Seiten des Variablennamens (z. B, `%UPLOADID%`).
Sie müssen den Bytebereich jedes Teils angeben, wenn Sie es hochladen, damit Amazon Glacier es in der richtigen Reihenfolge wieder zusammensetzen kann. Jeder Teil hat 1 048 576 Bytes. Der erste Teil belegt somit Byte 0-1048575, der zweite 1048576-2097151 und der dritte 2097152-3145727.
## Abschließen des Uploads
Amazon Glacier benötigt einen Tree-Hash der Originaldatei, um zu bestätigen, dass alle hochgeladenen Teile AWS unversehrt erreicht wurden.
Berechnen Sie den Struktur-Hash, indem Sie die Datei in 1-MiB-Blöcke aufteilen und einen binären SHA-256-Hash für jeden einzelnen Teil berechnen. Dann teilen Sie die Liste der Hashes in Paare auf. Sie kombinieren die beiden binären Hashes in jedem Paar und ermitteln die Hashes der Ergebnisse. Wiederholen Sie diesen Prozess, bis nur ein Hash übrig ist. Wenn es auf einer beliebigen Ebene eine ungerade Anzahl von Hashes gibt, verschieben Sie diese auf die nächste Ebene, ohne sie zu bearbeiten.
Das Wichtigste bei der korrekten Berechnung von einem Struktur-Hash unter Verwendung von Befehlszeilen-Hilfsprogrammen ist, den jeweiligen Hash im Binärformat zu speichern und erst im letzten Schritt in einen Hexadezimalwert zu konvertieren. Wenn Sie eine Hexadezimalversion von einem beliebigen Hash in der Struktur kombinieren oder hashen, erhalten Sie ein falsches Ergebnis.
**Anmerkung**
Windows-Benutzer können den Befehl `type` anstelle von `cat` verwenden. OpenSSL für Windows steht unter [OpenSSL.org](https://www.openssl.org/source/) zur Verfügung.
**So berechnen Sie einen Struktur-Hash:**
1. Falls noch nicht geschehen, teilen Sie die Originaldatei in 1-MiB-Teile auf.
```
$ split --bytes=1048576 --verbose largefile chunk
creating file `chunkaa'
creating file `chunkab'
creating file `chunkac'
```
1. Berechnen und speichern Sie den binären SHA-256-Hash von jedem Block.
```
$ openssl dgst -sha256 -binary chunkaa > hash1
$ openssl dgst -sha256 -binary chunkab > hash2
$ openssl dgst -sha256 -binary chunkac > hash3
```
1. Kombinieren Sie die ersten beiden Hashes und ermitteln Sie den binären Hash des Ergebnisses.
```
$ cat hash1 hash2 > hash12
$ openssl dgst -sha256 -binary hash12 > hash12hash
```
1. Kombinieren Sie den übergeordnete Hash der Blöcke `aa` und `ab` mit dem Hash `ac` und hashen Sie das Ergebnis, dieses Mal mit einer hexadezimalen Ausgabe. Speichern Sie das Ergebnis in einer Shell-Variablen.
```
$ cat hash12hash hash3 > hash123
$ openssl dgst -sha256 hash123
SHA256(hash123)= 9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67
$ TREEHASH=9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67
```
Schließen Sie den Upload mit dem Befehl `[complete-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html)` ab. Dieser Befehl akzeptiert die Größe der ursprünglichen Datei in Bytes, den endgültigen Hash-Wert in Hexadezimalformat und Ihre Konto-ID sowie den Tresornamen.
```
$ aws glacier complete-multipart-upload --checksum $TREEHASH --archive-size 3145728 --upload-id $UPLOADID --account-id - --vault-name myvault
{
"archiveId": "d3AbWhE0YE1m6f_fI1jPG82F8xzbMEEZmrAlLGAAONJAzo5QdP-N83MKqd96Unspoa5H5lItWX-sK8-QS0ZhwsyGiu9-R-kwWUyS1dSBlmgPPWkEbeFfqDSav053rU7FvVLHfRc6hg",
"checksum": "9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67",
"location": "/123456789012/vaults/myvault/archives/d3AbWhE0YE1m6f_fI1jPG82F8xzbMEEZmrAlLGAAONJAzo5QdP-N83MKqd96Unspoa5H5lItWX-sK8-QS0ZhwsyGiu9-R-kwWUyS1dSBlmgPPWkEbeFfqDSav053rU7FvVLHfRc6hg"
}
```
Sie können auch den Status des Tresors mithilfe des Befehls `[describe-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-vault.html)` überprüfen.
```
$ aws glacier describe-vault --account-id - --vault-name myvault
{
"SizeInBytes": 3178496,
"VaultARN": "arn:aws:glacier:us-west-2:123456789012:vaults/myvault",
"LastInventoryDate": "2018-12-07T00:26:19.028Z",
"NumberOfArchives": 1,
"CreationDate": "2018-12-06T21:23:45.708Z",
"VaultName": "myvault"
}
```
**Anmerkung**
Der Tresor-Status wird etwa einmal pro Tag aktualisiert. Weitere Informationen finden Sie unter [Arbeiten mit Tresoren](https://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-vaults.html).
Sie können jetzt die von Ihnen erstellten Chunk- und Hash-Dateien entfernen.
```
$ rm chunk* hash*
```
Weitere Informationen zu mehrteiligen Uploads finden Sie unter [Hochladen großer Archive in Parts and [Computing Checksums](https://docs.aws.amazon.com/amazonglacier/latest/dev/checksum-calculations.html) im](https://docs.aws.amazon.com/amazonglacier/latest/dev/uploading-archive-mpu.html) *Amazon* Glacier Developer Guide.
## Ressourcen
**AWS CLI Referenz:**
+ `[aws glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html)`
+ `[aws glacier complete-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html)`
+ `[aws glacier create-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/create-vault.html)`
+ `[aws glacier describe-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-vault.html)`
+ `[aws glacier initiate-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html)`
**Service-Referenz:**
+ [Amazon Glacier-Entwicklerhandbuch](https://docs.aws.amazon.com/amazonglacier/latest/dev/)
+ [Teilweises Hochladen großer Archive im](https://docs.aws.amazon.com/amazonglacier/latest/dev/uploading-archive-mpu.html) *Amazon Glacier Developer Guide*
+ [Berechnung von Prüfsummen](https://docs.aws.amazon.com/amazonglacier/latest/dev/checksum-calculations.html) im *Amazon Glacier Developer Guide*
+ [Arbeiten mit Tresoren](https://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-vaults.html) im *Amazon Glacier Developer Guide*
# Verwenden von IAM in der AWS CLI
| Eine Einführung in AWS Identity and Access Management |
| --- |
| |
Sie können mit dem AWS Identity and Access Management (IAM) auf die Funktionen von AWS Command Line Interface (AWS CLI) zugreifen. Verwenden Sie den folgenden Befehl, um die AWS CLI-Befehle für IAM aufzulisten.
```
aws iam help
```
Dieses Thema enthält Beispiele für AWS CLI-Befehle, über die allgemeine Aufgaben für IAM ausgeführt werden.
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).
Weitere Informationen zum IAM-Service finden Sie im [AWS Identity and Access Management-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html).
**Topics**
+ [Erstellen von neuen IAM-Benutzern und -Gruppen](#cli-services-iam-new-user-group)
+ [Anfügen einer IAM-verwalteten Richtlinie an einen Benutzer](#cli-services-iam-policy)
+ [Festlegen eines Anfangspassworts für einen IAM-Benutzer](#cli-services-iam-set-pw)
+ [Erstellen eines Zugriffsschlüssels für einen IAM-Benutzer](#cli-services-iam-create-creds)
## Erstellen von neuen IAM-Benutzern und -Gruppen
**So erstellen Sie eine Gruppe und fügen dieser einen neuen Benutzer hinzu**
1. Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/iam/create-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-group.html), um die Gruppe zu erstellen.
```
$ aws iam create-group --group-name MyIamGroup
{
"Group": {
"GroupName": "MyIamGroup",
"CreateDate": "2018-12-14T03:03:52.834Z",
"GroupId": "AGPAJNUJ2W4IJVEXAMPLE",
"Arn": "arn:aws:iam::123456789012:group/MyIamGroup",
"Path": "/"
}
}
```
1. Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html), um den Benutzer zu erstellen.
```
$ aws iam create-user --user-name MyUser
{
"User": {
"UserName": "MyUser",
"Path": "/",
"CreateDate": "2018-12-14T03:13:02.581Z",
"UserId": "AIDAJY2PE5XUZ4EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/MyUser"
}
}
```
1. Fügen Sie mit dem Befehl [https://docs.aws.amazon.com/cli/latest/reference/iam/add-user-to-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/add-user-to-group.html) den Benutzer zur Gruppe hinzu.
```
$ aws iam add-user-to-group --user-name MyUser --group-name MyIamGroup
```
1. Vergewissern Sie sich, dass die `MyIamGroup`-Gruppe `MyUser` enthält. Nutzen Sie dazu den Befehl [https://docs.aws.amazon.com/cli/latest/reference/iam/get-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/get-group.html).
```
$ aws iam get-group --group-name MyIamGroup
{
"Group": {
"GroupName": "MyIamGroup",
"CreateDate": "2018-12-14T03:03:52Z",
"GroupId": "AGPAJNUJ2W4IJVEXAMPLE",
"Arn": "arn:aws:iam::123456789012:group/MyIamGroup",
"Path": "/"
},
"Users": [
{
"UserName": "MyUser",
"Path": "/",
"CreateDate": "2018-12-14T03:13:02Z",
"UserId": "AIDAJY2PE5XUZ4EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/MyUser"
}
],
"IsTruncated": "false"
}
```
## Anfügen einer IAM-verwalteten Richtlinie an einen Benutzer
Die Richtlinie dieses Beispiels stattet den Benutzer mit "Hauptbenutzerberechtigungen" aus.
**Anfügen einer IAM-verwalteten Richtlinie an einen Benutzer**
1. Bestimmen Sie den Amazon-Ressourcennamen (ARN) der Richtlinie, die angehängt werden soll. Der folgende Befehl verwendet `list-policies`, um den ARN der Richtlinie mit dem Namen `PowerUserAccess` zu finden. Er speichert dann diesen ARN als Umgebungsvariable.
```
$ export POLICYARN=$(aws iam list-policies --query 'Policies[?PolicyName==`PowerUserAccess`].{ARN:Arn}' --output text) ~
$ echo $POLICYARN
arn:aws:iam::aws:policy/PowerUserAccess
```
1. Zum Anfügen einer Richtlinie nutzen Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html) und geben die Umgebungsvariable an, die den Richtlinien-ARN enthält.
```
$ aws iam attach-user-policy --user-name MyUser --policy-arn $POLICYARN
```
1. Überprüfen Sie, ob die Richtlinie dem Benutzer zugewiesen ist, indem Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-user-policies.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-user-policies.html) ausführen.
```
$ aws iam list-attached-user-policies --user-name MyUser
{
"AttachedPolicies": [
{
"PolicyName": "PowerUserAccess",
"PolicyArn": "arn:aws:iam::aws:policy/PowerUserAccess"
}
]
}
```
Weitere Informationen finden Sie unter [Zugriffsmanagementressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-additional-resources.html). Dieses Thema bietet Links zu einer Übersicht über die Berechtigungen und Richtlinien sowie Links zu Beispielen von Richtlinien für den Zugriff auf Amazon S3, Amazon EC2 und weitere Services.
## Festlegen eines Anfangspassworts für einen IAM-Benutzer
Im folgenden Befehl wird `[create-login-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/create-login-profile.html)` verwendet, um ein Anfangspasswort für den angegebenen Benutzer festzulegen. Wenn sich der Benutzer zum ersten Mal anmeldet, wird er aufgefordert, das Passwort zu einem Passwort zu ändern, dass nur er kennt.
```
$ aws iam create-login-profile --user-name MyUser --password My!User1Login8P@ssword --password-reset-required
{
"LoginProfile": {
"UserName": "MyUser",
"CreateDate": "2018-12-14T17:27:18Z",
"PasswordResetRequired": true
}
}
```
Verwenden Sie den Befehl `update-login-profile` zum *Ändern* des Passworts für einen Benutzer.
```
$ aws iam update-login-profile --user-name MyUser --password My!User1ADifferentP@ssword
```
## Erstellen eines Zugriffsschlüssels für einen IAM-Benutzer
Sie können den Befehl [https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html) verwenden, um einen Zugriffsschlüssel für einen Benutzer zu erstellen. Ein Zugriffsschlüssel ist ein Satz von Sicherheits-Anmeldeinformationen bestehend aus einer Zugriffsschlüssel-ID und einem geheimen Schlüssel.
Ein Benutzer kann gleichzeitig maximal zwei Zugriffsschlüssel erstellen. Wenn Sie versuchen, einen dritten Satz zu erstellen, gibt der Befehl einen `LimitExceeded`-Fehler aus.
```
$ aws iam create-access-key --user-name MyUser
{
"AccessKey": {
"UserName": "MyUser",
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"Status": "Active",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"CreateDate": "2018-12-14T17:34:16Z"
}
}
```
Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html), um einen Zugriffsschlüssel für einen Benutzer zu löschen. Geben Sie mit der Zugriffsschlüssel-ID an, welcher Zugriffsschlüssel gelöscht werden soll.
```
$ aws iam delete-access-key --user-name MyUser --access-key-id AKIAIOSFODNN7EXAMPLE
```
# Verwenden von Amazon S3 in der AWS CLI
| Eine Einführung in Amazon Simple Storage Service (Amazon S3) |
| --- |
| |
Greifen Sie mit der AWS Command Line Interface (AWS CLI) auf die Funktionen von Amazon Simple Storage Service (Amazon S3) zu. Amazon S3 ist ein hochgradig skalierbarer und dauerhafter Objektspeicherservice. Amazon S3 ist auf eine praktisch unbegrenzte Speicherkapazität ausgelegt und damit die ideale Lösung für eine Vielzahl von Datenspeicher- und -verwaltungsanforderungen.
Amazon S3 ermöglicht es Ihnen, beliebige Datenmengen von kleinen Dateien bis hin großen Datensätzen in Form von Objekten zu speichern und abzurufen. Jedes Objekt wird in einem Container gespeichert, der als Bucket bezeichnet wird. Der Zugriff auf und die Verwaltung dieser Buckets können über die AWS-Managementkonsole oder programmatisch über die AWS SDKs, Tools und AWS CLI erfolgen.
Amazon S3 bietet neben Basisspeicher auch eine Reihe von Funktionen wie Lebenszyklusmanagement, Versionsverwaltung, Skalierbarkeit und Sicherheit. Diese lassen sich in andere AWS-Services integrieren, sodass Sie cloudbasierte Lösungen entwickeln können, die sich gemäß Ihren Anforderungen skalieren lassen.
Die AWS CLI bietet zwei Befehlsebenen für den Zugriff auf Amazon S3:
+ **s3** – Benutzerdefinierte High-Level-Befehle, die speziell für die AWS CLI entwickelt wurden, vereinfachen das Ausführen häufiger Vorgänge wie das Erstellen, Bearbeiten, Löschen und Synchronisieren von Objekten und Buckets.
+ **s3api** – Bietet einen direkten Zugriff auf alle Amazon-S3-API-Operationen, mit denen Sie erweiterte Operationen ausführen können.
**Topics**
+ [Verwenden von High-Level-Befehlen (s3) in AWS CLI](cli-services-s3-commands.md)
+ [Verwenden von Befehlen auf API-Ebene (s3api) in AWS CLI](cli-services-s3-apicommands.md)
+ [Skriptbeispiel für den Amazon S3 S3-Bucket-Lebenszyklus in der AWS CLI](cli-services-s3-lifecycle-example.md)
# Verwenden von High-Level-Befehlen (s3) in AWS CLI
In diesem Thema wird beschrieben, wie Sie Amazon-S3-Buckets und -Objekte mit den [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html)-Befehlen in der AWS CLI verwalten. Befehle, die in diesem Thema nicht behandelt werden, und weitere Befehlsbeispiele finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html)-Befehle in der *AWS CLI -Referenz*.
Die `aws s3`-High-Level-Befehle vereinfachen die Verwaltung von Amazon-S3-Objekten. Mit diesen Befehlen können Sie den Inhalt von Amazon S3 intern und mit lokalen Verzeichnissen verwalten.
**Topics**
+ [Voraussetzungen](#using-s3-commands-prereqs)
+ [Bevor Sie beginnen](#using-s3-commands-before)
+ [Erstellen eines Buckets](#using-s3-commands-managing-buckets-creating)
+ [Auflisten von Buckets und Objekten](#using-s3-commands-listing-buckets)
+ [Buckets löschen](#using-s3-commands-delete-buckets)
+ [Objekte löschen](#using-s3-commands-delete-objects)
+ [Verschieben von Objekten](#using-s3-commands-managing-objects-move)
+ [Kopieren von Objekten](#using-s3-commands-managing-objects-copy)
+ [Synchronisieren von Objekten](#using-s3-commands-managing-objects-sync)
+ [Häufig verwendete Optionen für s3-Befehle](#using-s3-commands-managing-objects-param)
+ [Ressourcen](#using-s3-commands-managing-buckets-references)
## Voraussetzungen
Zur Ausführung von `s3`-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).
+ Das Profil, das Sie verwenden, muss über Berechtigungen verfügen, die die in den Beispielen ausgeführten AWS Operationen zulassen.
+ Sie müssen diese Amazon-S3-Begriffe verstehen:
+ **Bucket** – Ein Amazon-S3-Ordner der obersten Ebene.
+ **Präfix** – Ein Amazon-S3-Ordner in einem Bucket.
+ **Objekt** – Jedes Element, das in einem Amazon-S3-Bucket gehostet wird.
## Bevor Sie beginnen
In diesem Abschnitt finden Sie einige Hinweise zur Verwendung von `aws s3`-Befehlen.
### Uploads großer Objekte
Wenn Sie `aws s3`-Befehle zum Hochladen großer Objekte in einen Amazon-S3-Bucket verwenden, führt die AWS CLI automatisch einen mehrteiligen Upload durch. Sie können einen fehlgeschlagenen Upload nicht fortsetzen, wenn Sie diese `aws s3`-Befehle verwenden.
Wenn der mehrteilige Upload aufgrund eines Timeouts fehlschlägt oder wenn Sie den Vorgang manuell abgebrochen haben AWS CLI, AWS CLI stoppt der Upload und bereinigt alle erstellten Dateien. Dieser Vorgang kann einige Minuten dauern.
Wenn der mehrteilige Upload oder Bereinigungsprozess durch einen Kill-Befehl oder einen Systemfehler abgebrochen wird, verbleiben die erstellten Dateien im Amazon-S3-Bucket.
### Dateieigenschaften und Tags in mehrteiligen Kopien
Wenn Sie die AWS CLI Version 1 der Befehle im `aws s3` Namespace verwenden, um eine Datei von einem Amazon S3 S3-Bucket-Speicherort an einen anderen Amazon S3 S3-Bucket-Speicherort zu kopieren, und dieser Vorgang [mehrteiliges Kopieren](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CopyingObjctsMPUapi.html) verwendet, werden keine Dateieigenschaften vom Quellobjekt in das Zielobjekt kopiert.
Standardmäßig übertragen die Befehle der AWS CLI Version 2 im `s3` Namespace, mit denen mehrteilige Kopien ausgeführt werden, alle Tags und die folgenden Eigenschaften von der Quell- zur Zielkopie:`content-type`,,,, `content-language` `content-encoding``content-disposition`, `cache-control` und. `expires` `metadata`
Dies kann zu zusätzlichen AWS API-Aufrufen an den Amazon S3 S3-Endpunkt führen, die nicht getätigt worden wären, wenn Sie AWS CLI Version 1 verwendet hätten. Dies sind beispielsweise: `HeadObject`, `GetObjectTagging` und `PutObjectTagging`.
Wenn Sie dieses Standardverhalten in Befehlen der AWS CLI Version 2 ändern müssen, verwenden Sie den `--copy-props` Parameter, um eine der folgenden Optionen anzugeben:
+ **default** – Der Standardwert. Gibt an, dass die Kopie alle an das Quellobjekt angehängten Tags und die Eigenschaften enthält, die durch den `--metadata-directive`-Parameter für nicht mehrteilige Kopien verwendet werden: `content-type`, `content-language`, `content-encoding`, `content-disposition`, `cache-control`, `expires` und `metadata`.
+ **metadata-directive** – Gibt an, dass die Kopie nur die Eigenschaften enthält, die von dem Parameter `--metadata-directive` für nicht mehrteilige Kopien verwendet werden. Es werden keine Tags kopiert.
+ **none** – Gibt an, dass die Kopie keine der Eigenschaften des Quellobjekts enthält.
## Erstellen eines Buckets
Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html), um einen Bucket zu erstellen. Bucket-Namen müssen ***global*** eindeutig (eindeutig in ganz Amazon S3) und DNS-kompatibel sein.
Bucket-Namen können Kleinbuchstaben, Zahlen, Bindestriche und Punkte enthalten. Bucket-Namen können nur mit einem Buchstaben oder einer Zahl beginnen und enden. Ein Punkt neben einem Bindestrich oder einem weiteren Punkt ist unzulässig.
**Syntax**
```
$ aws s3 mb [--options]
```
### s3-mb-Beispiele
Im folgenden Beispiel wird der Bucket `s3://amzn-s3-demo-bucket` erstellt.
```
$ aws s3 mb s3://amzn-s3-demo-bucket
```
## Auflisten von Buckets und Objekten
Um Ihre Buckets, Ordner oder Objekte aufzulisten, verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html). Wenn Sie den Befehl ohne Ziel oder Optionen verwenden, werden alle Buckets aufgelistet.
**Syntax**
```
$ aws s3 ls [--options]
```
Ein paar gängige Optionen für diesen Befehl und Beispiele finden Sie unter [Häufig verwendete Optionen für s3-Befehle](#using-s3-commands-managing-objects-param). Eine vollständige Liste der verfügbaren Optionen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html) in der *AWS CLI -Befehlsreferenz*.
### s3-ls-Beispiele
Das folgende Beispiel listet alle Amazon-S3-Buckets auf.
```
$ aws s3 ls
2018-12-11 17:08:50 amzn-s3-demo-bucket1
2018-12-14 14:55:44 amzn-s3-demo-bucket2
```
Mit dem Befehl unten werden alle Objekte und Präfixe in einem Bucket aufgeführt. In dieser Beispielausgabe enthält das Präfix `example/` eine Datei mit dem Namen `MyFile1.txt`.
```
$ aws s3 ls s3://amzn-s3-demo-bucket
PRE example/
2018-12-04 19:05:48 3 MyFile1.txt
```
Sie können die Ausgabe nach einem bestimmten Präfix filtern, indem Sie das Präfix in den Befehl einschließen. Der folgende Befehl listet die Objekte in auf *bucket-name/example/* (d. h. Objekte, die nach dem Präfix *bucket-name* gefiltert sind*example/*).
```
$ aws s3 ls s3://amzn-s3-demo-bucket/example/
2018-12-06 18:59:32 3 MyFile1.txt
```
Um nur die Buckets und Objekte in einer bestimmten Region anzuzeigen, verwenden Sie die `--region`-Optionen.
```
$ aws s3 ls --region us-east-2
2018-12-06 18:59:32 3 MyFile1.txt
```
Wenn Sie über eine umfangreiche Liste mit Buckets und Objekten verfügen, können Sie die Ergebnisse mithilfe der Option `--max-items` oder `--page-size` paginieren. Die Option `--max-items` begrenzt, wie viele Buckets und Objekte insgesamt in einem Aufruf zurückgegeben werden, während die Option `--page-size` begrenzt, wie viele davon auf einer Seite aufgeführt werden.
```
$ aws s3 ls --max-items 100 --page-size 10
```
Weitere Informationen zur Paginierung finden Sie unter [So verwenden Sie den –page-size-Parameter](cli-usage-pagination.md#cli-usage-pagination-pagesize) und [So verwenden Sie den –max-items-Parameter](cli-usage-pagination.md#cli-usage-pagination-maxitems).
## Buckets löschen
Verwenden Sie zum Löschen eines Buckets den Befehl [https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html).
**Syntax**
```
$ aws s3 rb [--options]
```
### s3-rb-Beispiele
Im folgenden Beispiel wird der Bucket `s3://amzn-s3-demo-bucket` entfernt.
```
$ aws s3 rb s3://amzn-s3-demo-bucket
```
Standardmäßig muss der Bucket leer sein, damit der Vorgang erfolgreich ist. Zum Entfernen eines Buckets, der nicht leer ist, müssen Sie die Option `--force` hinzufügen. Wenn Sie einen versionsgesteuerten Bucket verwenden, der bereits gelöschte–aber aufbewahrte–Objekte enthält, lässt dieser Befehl *nicht* zu, dass Sie den Bucket entfernen. Sie müssen zunächst alle Inhalte entfernen.
Im folgenden Beispiel werden alle Objekte und Präfixe im Bucket gelöscht und anschließend der Bucket gelöscht.
```
$ aws s3 rb s3://amzn-s3-demo-bucket --force
```
## Objekte löschen
Um Objekte in einem Bucket oder in Ihrem lokalen Verzeichnis zu löschen, verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html).
**Syntax**
```
$ aws s3 rm [--options]
```
Ein paar gängige Optionen für diesen Befehl und Beispiele finden Sie unter [Häufig verwendete Optionen für s3-Befehle](#using-s3-commands-managing-objects-param). Eine vollständige Liste der Optionen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) in der *AWS CLI -Befehlsreferenz*.
### s3-rm-Beispiele
Im folgenden Beispiel wird `filename.txt` aus `s3://amzn-s3-demo-bucket/example` gelöscht.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/example/filename.txt
```
Im folgenden Beispiel werden alle Objekte aus `s3://amzn-s3-demo-bucket/example` mit der Option `--recursive` gelöscht.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/example --recursive
```
## Verschieben von Objekten
Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html), um Objekte aus einem Bucket oder einem lokalen Verzeichnis zu verschieben. Mit dem Befehl `s3 mv` wird das Quellobjekt oder die Quelldatei an den angegebenen Speicherort kopiert. Anschließend wird das Quellobjekt oder die Quelldatei gelöscht.
**Syntax**
```
$ aws s3 mv [--options]
```
Ein paar gängige Optionen für diesen Befehl und Beispiele finden Sie unter [Häufig verwendete Optionen für s3-Befehle](#using-s3-commands-managing-objects-param). Eine vollständige Liste der verfügbaren Optionen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html) in der *AWS CLI -Befehlsreferenz*.
**Warnung**
Wenn Sie in Ihrer Amazon S3-Quelle ARNs oder Ihrem Amazon S3-Ziel irgendeine Art von Access Point- oder Access Point-Aliasnamen verwenden, müssen Sie besonders darauf achten URIs, dass Ihr Amazon S3 S3-Quell- und Ziel-Alias in verschiedene zugrunde liegende Buckets URIs aufgelöst werden. Wenn die Quell- und Ziel-Buckets identisch sind, kann die Quelldatei oder das Quellobjekt auf sich selbst verschoben werden, was zu einem versehentlichen Löschen Ihrer Quelldatei oder Ihres Quellobjekts führen kann. Um zu überprüfen, dass Quell- und Ziel-Buckets nicht identisch sind, verwenden Sie den Parameter `--validate-same-s3-paths` oder setzen Sie die Umgebungsvariable ``AWS_CLI_S3_MV_VALIDATE_SAME_S3_PATHS`` auf `true`.
### s3-mv-Beispiele
Im folgenden Beispiel werden alle Objekte von `s3://amzn-s3-demo-bucket/example` nach `s3://amzn-s3-demo-bucket/` verschoben.
```
$ aws s3 mv s3://amzn-s3-demo-bucket/example s3://amzn-s3-demo-bucket/
```
Im folgenden Beispiel wird eine lokale Datei mit dem `s3 mv`-Befehl aus Ihrem aktuellen Arbeitsverzeichnis in den Amazon-S3-Bucket verschoben.
```
$ aws s3 mv filename.txt s3://amzn-s3-demo-bucket
```
Im folgenden Beispiel wird eine Datei aus Ihrem Amazon-S3-Bucket in Ihr aktuelles Arbeitsverzeichnis verschoben, wobei `./` Ihr aktuelles Arbeitsverzeichnis angibt.
```
$ aws s3 mv s3://amzn-s3-demo-bucket/filename.txt ./
```
## Kopieren von Objekten
Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html), um Objekte aus einem Bucket oder einem lokalen Verzeichnis zu verschieben.
**Syntax**
```
$ aws s3 cp [--options]
```
Sie können den Bindestrich-Parameter für das Dateistreaming an die Standardeingabe (`stdin`) oder die Standardausgabe (`stdout`) verwenden.
**Warnung**
Wenn Sie verwenden PowerShell, ändert die Shell möglicherweise die Kodierung einer CRLF oder fügt eine CRLF zur Eingabe oder Ausgabe über die Pipeline oder zur umgeleiteten Ausgabe hinzu.
Der Befehl `s3 cp` verwendet die folgende Syntax, um einen Dateistream von `stdin` in einen angegebenen Bucket hochzuladen.
**Syntax**
```
$ aws s3 cp - [--options]
```
Der `s3 cp`-Befehl verwendet die folgende Syntax, um einen Amazon-S3-Dateistream für `stdout` herunterzuladen.
**Syntax**
```
$ aws s3 cp [--options] -
```
Ein paar gängige Optionen für diesen Befehl und Beispiele finden Sie unter [Häufig verwendete Optionen für s3-Befehle](#using-s3-commands-managing-objects-param). Eine vollständige Liste der Optionen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) in der *AWS CLI -Befehlsreferenz*.
### Beispiele für `s3 cp`
Im folgenden Beispiel werden alle Objekte von `s3://amzn-s3-demo-bucket/example` nach `s3://amzn-s3-demo-bucket/` kopiert.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/example s3://amzn-s3-demo-bucket/
```
Im folgenden Beispiel wird eine lokale Datei mit dem `s3 cp`-Befehl aus Ihrem aktuellen Arbeitsverzeichnis in den Amazon-S3-Bucket kopiert.
```
$ aws s3 cp filename.txt s3://amzn-s3-demo-bucket
```
Im folgenden Beispiel wird eine Datei aus Ihrem Amazon-S3-Bucket in Ihr aktuelles Arbeitsverzeichnis kopiert, wobei `./` Ihr aktuelles Arbeitsverzeichnis angibt.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/filename.txt ./
```
Im folgenden Beispiel wird echo verwendet, um den Text „hello world“ in die Datei `s3://bucket-name/filename.txt` zu streamen.
```
$ echo "hello world" | aws s3 cp - s3://amzn-s3-demo-bucket/filename.txt
```
Im folgenden Beispiel wird die `s3://amzn-s3-demo-bucket/filename.txt`-Datei nach `stdout` gestreamt und der Inhalt an die Konsole ausgegeben.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/filename.txt -
hello world
```
Das folgende Beispiel streamt den Inhalt von `s3://bucket-name/pre` nach `stdout`, verwendet den Befehl `bzip2` zum Komprimieren der Dateien und lädt die neue komprimierte Datei namens `key.bz2` nach `s3://bucket-name` hoch.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/pre - | bzip2 --best | aws s3 cp - s3://amzn-s3-demo-bucket/key.bz2
```
## Synchronisieren von Objekten
Der Befehl [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) synchronisiert die Inhalte von einem Bucket und einem Verzeichnis oder die Inhalte von zwei Buckets. Normalerweise werden mit `s3 sync` fehlende oder veraltete Dateien bzw. Objekte zwischen Quelle und Ziel kopiert. Sie können aber auch die Option `--delete` hinzufügen, um Dateien oder Objekte, die nicht in der Quelldatei vorhanden sind, aus dem Ziel zu entfernen.
**Syntax**
```
$ aws s3 sync [--options]
```
Ein paar gängige Optionen für diesen Befehl und Beispiele finden Sie unter [Häufig verwendete Optionen für s3-Befehle](#using-s3-commands-managing-objects-param). Eine vollständige Liste der Optionen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) in der *AWS CLI -Befehlsreferenz*.
### Beispiele für die s3-Synchronisierung
Im folgenden Beispiel wird der Inhalt eines Amazon-S3-Präfixes namens *path* im Bucket mit dem Namen *amzn-s3-demo-bucket* mit dem aktuellen Arbeitsverzeichnis synchronisiert.
`s3 sync` aktualisiert alle Dateien mit einer anderen Größe oder geänderten Zeit als Dateien mit demselben Namen am Ziel. Die Ausgabe enthält bestimmte Vorgänge, die während der Synchronisierung ausgeführt wurden. Beachten Sie, dass die Operation rekursiv das Unterverzeichnis `MySubdirectory` und seinen Inhalt mit `s3://amzn-s3-demo-bucket/path/MySubdirectory` synchronisiert.
```
$ aws s3 sync . s3://amzn-s3-demo-bucket/path
upload: MySubdirectory\MyFile3.txt to s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
upload: MyFile2.txt to s3://amzn-s3-demo-bucket/path/MyFile2.txt
upload: MyFile1.txt to s3://amzn-s3-demo-bucket/path/MyFile1.txt
```
Das folgende Beispiel, das das vorherige erweitert, zeigt die Verwendung der Option `--delete`.
```
// Delete local file
$ rm ./MyFile1.txt
// Attempt sync without --delete option - nothing happens
$ aws s3 sync . s3://amzn-s3-demo-bucket/path
// Sync with deletion - object is deleted from bucket
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --delete
delete: s3://amzn-s3-demo-bucket/path/MyFile1.txt
// Delete object from bucket
$ aws s3 rm s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
delete: s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
// Sync with deletion - local file is deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete
delete: MySubdirectory\MyFile3.txt
// Sync with Infrequent Access storage class
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --storage-class STANDARD_IA
```
Bei Verwendung der Option `--delete` können mit den Optionen `--exclude` und `--include` die Dateien oder Objekte gefiltert werden, die während einer `s3 sync`-Operation gelöscht werden sollen. In diesem Fall muss die Parameterzeichenfolge Dateien angeben, die für das Zielverzeichnis oder den Bucket vom Löschen ausgenommen oder zum Löschen hinzugefügt werden. Es folgt ein Beispiel.
```
Assume local directory and s3://amzn-s3-demo-bucket/path currently in sync and each contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
'''
// Sync with delete, excluding files that match a pattern. MyFile88.txt is deleted, while remote MyFile1.txt is not.
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --delete --exclude "path/MyFile?.txt"
delete: s3://amzn-s3-demo-bucket/path/MyFile88.txt
'''
// Sync with delete, excluding MyFile2.rtf - local file is NOT deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete --exclude "./MyFile2.rtf"
download: s3://amzn-s3-demo-bucket/path/MyFile1.txt to MyFile1.txt
'''
// Sync with delete, local copy of MyFile2.rtf is deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete
delete: MyFile2.rtf
```
## Häufig verwendete Optionen für s3-Befehle
Die folgenden Optionen werden häufig für die in diesem Thema beschriebenen Befehle verwendet. Eine vollständige Liste der Optionen, die Sie für einen Befehl verwenden können, finden Sie im Referenzhandbuch, [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/reference/index.html), im den jeweiligen Befehl.
**acl**
`s3 sync` und `s3 cp` können die Option `--acl` verwenden. Auf diese Weise können Sie die Zugriffsberechtigungen für Dateien festlegen, die nach Amazon S3 kopiert werden. Die Option `--acl` akzeptiert die Werte `private`, `public-read` und `public-read-write`. Weitere Informationen finden Sie unter [Vordefinierte ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) im *Amazon-S3-Benutzerhandbuch*.
```
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --acl public-read
```
**exclude**
Wenn Sie die Befehle `s3 cp`, `s3 mv`, `s3 sync` oder `s3 rm` verwenden, können Sie die Ergebnisse mit der Option `--exclude` oder `--include` filtern. Die Option `--exclude` legt Regeln fest, um nur Objekte vom Befehl auszuschließen, und die Optionen gelten in der angegebenen Reihenfolge. Dies wird im folgenden Beispiel veranschaulicht.
```
Local directory contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
// Exclude all .txt files, resulting in only MyFile2.rtf being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt"
// Exclude all .txt files but include all files with the "MyFile*.txt" format, resulting in, MyFile1.txt, MyFile2.rtf, MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt" --include "MyFile*.txt"
// Exclude all .txt files, but include all files with the "MyFile*.txt" format, but exclude all files with the "MyFile?.txt" format resulting in, MyFile2.rtf and MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt" --include "MyFile*.txt" --exclude "MyFile?.txt"
```
**include**
Wenn Sie die Befehle `s3 cp`, `s3 mv`, `s3 sync` oder `s3 rm` verwenden, können Sie die Ergebnisse mit der Option `--exclude` oder `--include` filtern. Die Option `--include` legt Regeln fest, um nur die für den Befehl angegebenen Objekte einzuschließen, und die Optionen gelten in der angegebenen Reihenfolge. Dies wird im folgenden Beispiel veranschaulicht.
```
Local directory contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
// Include all .txt files, resulting in MyFile1.txt and MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt"
// Include all .txt files but exclude all files with the "MyFile*.txt" format, resulting in no files being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt" --exclude "MyFile*.txt"
// Include all .txt files, but exclude all files with the "MyFile*.txt" format, but include all files with the "MyFile?.txt" format resulting in MyFile1.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt" --exclude "MyFile*.txt" --include "MyFile?.txt"
```
**grant**
Die Befehle `s3 cp`, `s3 mv` und `s3 sync` enthalten die Option `--grants`. Diese kann genutzt werden, um Berechtigungen für das Objekt an bestimmte Benutzer oder Gruppen zu erteilen. Mithilfe der folgenden Syntax legen Sie für die Option `--grants` eine Liste mit Berechtigungen fest. Ersetzen Sie `Permission`, `Grantee_Type` und `Grantee_ID` durch Ihre eigenen Werte.
**Syntax**
```
--grants Permission=Grantee_Type=Grantee_ID
[Permission=Grantee_Type=Grantee_ID ...]
```
Jeder Wert enthält die folgenden Elemente:
+ *Permission*— Gibt die erteilten Berechtigungen an. Mögliche Einstellungen sind `read`, `readacl`, `writeacl` oder `full`.
+ *Grantee\$1Type*— Gibt an, wie der Empfänger identifiziert werden kann. Mögliche Einstellungen sind `uri`, `emailaddress` oder `id`.
+ *Grantee\$1ID*— Gibt den Empfänger anhand von an. *Grantee\$1Type*
+ `uri` – Der URI der Gruppe. Weitere Informationen finden Sie unter [Wer ist ein Berechtigungsempfänger?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ACLOverview.html#SpecifyingGrantee)
+ `emailaddress` – Die E-Mail-Adresse des Kontos.
+ `id` – Die kanonische ID des Kontos.
Weitere Informationen zur Amazon-S3-Zugriffssteuerung finden Sie unter [Zugriffssteuerung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingAuthAccess.html).
Im folgenden Beispiel wird ein Objekt in einen Bucket kopiert. Es werden `read`-Berechtigungen für das Objekt für alle erteilt. Das Konto, das zu `full` gehört, erhält `read`-Berechtigungen (`readacl`, `writeacl` und `user@example.com`).
```
$ aws s3 cp file.txt s3://amzn-s3-demo-bucket/ --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers full=emailaddress=user@example.com
```
Sie können auch eine nicht standardmäßige Speicherklasse (`REDUCED_REDUNDANCY` oder `STANDARD_IA`) für Objekte angeben, die Sie in Amazon S3 hochladen. Verwenden Sie dazu die Option `--storage-class`.
```
$ aws s3 cp file.txt s3://amzn-s3-demo-bucket/ --storage-class REDUCED_REDUNDANCY
```
**kein Überschreiben**
Die `s3 sync` Befehle `s3 cp``s3 mv`, und enthalten eine `--no-overwrite` Option, mit der Sie verhindern können, dass Objekte überschrieben werden, die am Ziel bereits vorhanden sind.
Im folgenden Beispiel wird ein Objekt nur dann aus einem Bucket in das lokale Verzeichnis kopiert, wenn es nicht bereits im lokalen Verzeichnis vorhanden ist.
```
$ aws s3 cp --no-overwrite s3://amzn-s3-demo-bucket/file.txt file.txt
```
Im folgenden Beispiel werden Dateien rekursiv aus einem lokalen Verzeichnis in einen Bucket kopiert. Es werden nur Dateien kopiert, die noch nicht im Bucket vorhanden sind.
```
$ aws s3 cp --recursive --no-overwrite /path/to/demo-files/ s3://amzn-s3-demo-bucket/demo-files/
```
Im folgenden Beispiel wird ein Objekt nur dann aus einem lokalen Verzeichnis in einen Bucket verschoben, wenn es nicht bereits am Zielort des Buckets vorhanden ist.
```
$ aws s3 mv --no-overwrite file.txt s3://amzn-s3-demo-bucket/file.txt
```
Im folgenden Beispiel werden Dateien aus einem lokalen Verzeichnis mit einem Bucket synchronisiert. Es werden nur Dateien synchronisiert, die noch nicht im Ziel-Bucket vorhanden sind.
```
$ aws s3 sync --no-overwrite /path/to/demo-files/ s3://amzn-s3-demo-bucket/demo-files/
```
**recursive**
Wenn Sie diese Option verwenden, wird der Befehl für alle Dateien oder Objekte unter dem angegebenen Verzeichnis oder Präfix ausgeführt. Das folgende Beispiel löscht `s3://amzn-s3-demo-bucket/path` und seinen gesamten Inhalt.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/path --recursive
```
## Ressourcen
**AWS CLI Referenz:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html)
**Service-Referenz:**
+ [Arbeiten mit Amazon-S3-Buckets](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) im *Amazon-S3-Benutzerhandbuch*
+ [Arbeiten mit Amazon-S3-Objekten](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) im *Amazon-S3-Benutzerhandbuch*
+ [Hierarchisches Auflisten von Schlüsseln mithilfe von Präfix und Trennzeichen](https://docs.aws.amazon.com//AmazonS3/latest/userguide/ListingKeysHierarchy.html) im *Amazon-S3-Benutzerhandbuch*
+ [Brechen Sie mehrteilige Uploads in einen S3-Bucket mithilfe der AWS SDK für .NET (Low-Level) im Amazon S3 S3-Benutzerhandbuch](https://docs.aws.amazon.com//AmazonS3/latest/userguide/LLAbortMPUnet.html) *ab*
# Verwenden von Befehlen auf API-Ebene (s3api) in AWS CLI
Die Befehle auf API-Ebene (im `s3api` Befehlssatz enthalten) bieten direkten Zugriff auf den Amazon Simple Storage Service (Amazon S3) und ermöglichen einige Operationen APIs, die in den allgemeinen `s3` Befehlen nicht offengelegt werden. Diese Befehle entsprechen anderen AWS -Services, die einen Zugriff auf API-Ebene auf Servicefunktionen bereitstellen. Weitere Informationen zu den Befehlen `s3` finden Sie unter [Verwenden von High-Level-Befehlen (s3) in AWS CLI](cli-services-s3-commands.md).
Dieses Thema enthält Beispiele, die zeigen, wie die Befehle auf niedrigerer Ebene verwendet werden, die Amazon S3 zugeordnet sind. APIs Darüber hinaus finden Sie Beispiele für jeden S3-API-Befehl im `s3api` Abschnitt des [Version 2.](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html)
**Topics**
+ [Voraussetzungen](#cli-services-s3-apicommands-prereqs)
+ [Anwenden einer benutzerdefinierten ACL](#cli-services-s3-apicommands-acls)
+ [Konfigurieren einer Protokollierungsrichtlinie](#cli-services-s3-apicommands-logpol)
+ [Ressourcen](#cli-services-s3-apicommands-resources)
## Voraussetzungen
Zur Ausführung von `s3api`-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).
+ Das von Ihnen verwendete Profil muss über Berechtigungen verfügen, die die anhand der Beispiele ausgeführten AWS Operationen zulassen.
+ Sie müssen diese Amazon-S3-Begriffe verstehen:
+ **Bucket** – Ein Amazon-S3-Ordner der obersten Ebene.
+ **Präfix** – Ein Amazon-S3-Ordner in einem Bucket.
+ **Objekt** – Jedes Element, das in einem Amazon-S3-Bucket gehostet wird.
## Anwenden einer benutzerdefinierten ACL
Mit Befehlen auf hoher Ebene können Sie die `--acl` Option verwenden, um vordefinierte Zugriffskontrolllisten (ACLs) auf Amazon S3 S3-Objekte anzuwenden. Sie können diesen Befehl jedoch nicht verwenden, um Einstellungen für den gesamten Bucket festzulegen. ACLs Hierfür können Sie aber den Befehl ```[put-bucket-acl](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html)` auf API-Ebene nutzen.
Das folgende Beispiel zeigt, wie zwei AWS Benutzern (*user1@example.com* und *user2@example.com*) Vollzugriff und allen Benutzern Leseberechtigungen gewährt werden. Die Kennung für "alle" stammt von einer speziellen URI, die Sie als Parameter übergeben.
```
$ aws s3api put-bucket-acl --bucket amzn-s3-demo-bucket --grant-full-control 'emailaddress="user1@example.com",emailaddress="user2@example.com"' --grant-read 'uri="http://acs.amazonaws.com/groups/global/AllUsers"'
```
Einzelheiten zur Erstellung von finden Sie unter [PUT Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) in der *Amazon Simple Storage Service API-Referenz*. ACLs Die `s3api`-ACL-Befehle in der CLI, beispielsweise `put-bucket-acl`, verwenden dieselbe [Argument-Kurznotation](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-shorthand.html).
## Konfigurieren einer Protokollierungsrichtlinie
Der API-Befehl `put-bucket-logging` konfiguriert die Bucket-Protokollierungsrichtlinie.
Im folgenden Beispiel wird dem AWS Benutzer *user@example.com* die volle Kontrolle über die Protokolldateien gewährt, und alle Benutzer haben Lesezugriff darauf. Beachten Sie, dass der Befehl `put-bucket-acl` auch erforderlich ist, um dem System zur Bereitstellung von Protokollen von Amazon S3 (angegeben durch einen URI) die erforderlichen Berechtigungen zum Lesen und Schreiben der Protokolle im Bucket zu gewähren.
```
$ aws s3api put-bucket-acl --bucket amzn-s3-demo-bucket --grant-read-acp 'URI="http://acs.amazonaws.com/groups/s3/LogDelivery"' --grant-write 'URI="http://acs.amazonaws.com/groups/s3/LogDelivery"'
$ aws s3api put-bucket-logging --bucket amzn-s3-demo-bucket --bucket-logging-status file://logging.json
```
Die Datei `logging.json` aus dem vorherigen Befehl hat folgenden Inhalt.
```
{
"LoggingEnabled": {
"TargetBucket": "amzn-s3-demo-bucket",
"TargetPrefix": "amzn-s3-demo-bucketLogs/",
"TargetGrants": [
{
"Grantee": {
"Type": "AmazonCustomerByEmail",
"EmailAddress": "user@example.com"
},
"Permission": "FULL_CONTROL"
},
{
"Grantee": {
"Type": "Group",
"URI": "http://acs.amazonaws.com/groups/global/AllUsers"
},
"Permission": "READ"
}
]
}
}
```
## Ressourcen
**AWS CLI Referenz:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-logging.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-logging.html)
**Service-Referenz:**
+ [Arbeiten mit Amazon-S3-Buckets](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) im *Amazon-S3-Benutzerhandbuch*
+ [Arbeiten mit Amazon-S3-Objekten](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) im *Amazon-S3-Benutzerhandbuch*
+ [Hierarchisches Auflisten von Schlüsseln mithilfe von Präfix und Trennzeichen](https://docs.aws.amazon.com//AmazonS3/latest/userguide/ListingKeysHierarchy.html) im *Amazon-S3-Benutzerhandbuch*
+ [Brechen Sie mehrteilige Uploads in einen S3-Bucket mithilfe der AWS SDK für .NET (Low-Level) im Amazon S3 S3-Benutzerhandbuch](https://docs.aws.amazon.com//AmazonS3/latest/userguide/LLAbortMPUnet.html) *ab*
# Skriptbeispiel für den Amazon S3 S3-Bucket-Lebenszyklus in der AWS CLI
In diesem Thema wird ein Beispiel der Bash-Skriptsprache für Amazon-S3-Bucket-Lebenszyklusoperationen mithilfe der AWS Command Line Interface (AWS CLI) verwendet. Dieses Skriptsprachebeispiel verwendet den Befehlssatz [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html). Shell-Skripte sind Programme, die in einer Befehlszeilenschnittstelle ausgeführt werden sollen.
**Topics**
+ [Bevor Sie beginnen](#cli-services-s3-lifecycle-example-before)
+ [Über das Beispiel](#cli-services-s3-lifecycle-example-about)
+ [Dateien](#cli-services-s3-lifecycle-example-files)
+ [Referenzen](#cli-services-s3-lifecycle-example-references)
## Bevor Sie beginnen
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 Profil, das Sie verwenden, muss über Berechtigungen verfügen, die die in den Beispielen ausgeführten AWS Operationen zulassen.
+ Es hat sich AWS bewährt, diesem Code die geringsten Rechte oder nur die für die Ausführung einer Aufgabe erforderlichen Berechtigungen zu gewähren. Weitere Informationen finden Sie unter [Gewähren von geringsten Rechten](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) im *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.
Der Amazon-S3-Service verwendet die folgenden Begriffe:
+ Bucket – Ein Amazon-S3-Ordner der obersten Ebene.
+ Präfix – Ein Amazon-S3-Ordner in einem Bucket.
+ Objekt – Jedes Element, das in einem Amazon-S3-Bucket gehostet wird.
## Über das Beispiel
Dieses Beispiel zeigt, wie Sie mit einigen grundlegenden Amazon-S3-Operationen interagieren, indem Sie eine Reihe von Funktionen in Shell-Skriptdateien verwenden. Die Funktionen befinden sich in der Shell-Skriptdatei namens `bucket-operations.sh`. Sie können diese Funktionen in einer anderen Datei aufrufen. Jede Skriptdatei enthält Kommentare, die jede der Funktionen beschreiben.
Um die Zwischenergebnisse jedes Schritts anzuzeigen, führen Sie das Skript mit einem `-i`-Parameter aus. Sie können den aktuellen Status des Buckets oder seinen Inhalt mithilfe der Amazon-S3-Konsole anzeigen. Das Skript fährt nur dann mit dem nächsten Schritt fort, wenn Sie an der Eingabeaufforderung die **Eingabetaste** drücken.
Das vollständige Beispiel und die herunterladbaren Skriptdateien finden Sie unter [Amazon S3 Bucket Lifecycle Operations](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations) im *AWS Code Examples Repository* unter *GitHub*.
## Dateien
Das Beispiel enthält die folgenden Dateien:
**bucket-operations.sh**
Diese Hauptskriptdatei kann aus einer anderen Datei bezogen werden. Sie umfasst Funktionen, die die folgenden Aufgaben ausführen:
+ Erstellen eines Buckets und Überprüfen, ob er vorhanden ist
+ Kopieren einer Datei vom lokalen Computer in einen Bucket
+ Kopieren einer Datei von einem Bucket-Speicherort an einen anderen Bucket-Speicherort
+ Auflisten der Inhalte eines Buckets
+ Löschen einer Datei aus einem Bucket
+ Löschen eines Buckets
Sehen Sie sich den Code für `[bucket-operations.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/bucket_operations.sh)` on an *GitHub*.
**test-bucket-operations.sh**
Die Shell-Skriptdatei `test-bucket-operations.sh` zeigt, wie die Funktionen aufgerufen werden, indem die Datei `bucket-operations.sh` bezogen und jede der Funktionen aufgerufen wird. Nach dem Aufrufen von Funktionen entfernt das Testskript alle Ressourcen, die es erstellt hat.
Sehen Sie sich den Code für `[test-bucket-operations.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/test_bucket_operations.sh)` on an *GitHub*.
**awsdocs-general.sh**
Die Skriptdatei `awsdocs-general.sh` enthält allgemeine Funktionen, die in erweiterten Codebeispielen für die AWS CLI verwendet werden.
Sehen Sie sich den Code für `[awsdocs-general.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/awsdocs_general.sh)` on an *GitHub*.
## Referenzen
**AWS CLI Referenz:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/copy-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/copy-object.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-object.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/head-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/head-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html)
**Andere Referenz:**
+ [Arbeiten mit Amazon-S3-Buckets](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) im *Amazon-S3-Benutzerhandbuch*
+ [Arbeiten mit Amazon-S3-Objekten](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) im *Amazon-S3-Benutzerhandbuch*
+ 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*.
# Zugreifen auf Amazon SNS in der AWS CLI
Sie können auf die Funktionen von Amazon Simple Notification Service (Amazon SNS) zugreifen, indem Sie die AWS Command Line Interface (AWS CLI) verwenden. Verwenden Sie den folgenden Befehl, um die AWS CLI-Befehle für Amazon SNS aufzulisten.
```
aws sns 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 enthält Beispiele für AWS CLI-Befehle, über die allgemeine Aufgaben für Amazon SNS ausgeführt werden.
**Topics**
+ [Erstellen eines Themas](#cli-create-sns-topic)
+ [Abonnieren eines Themas](#cli-subscribe-sns-topic)
+ [Veröffentlichung für ein Thema](#cli-publish-sns-topic)
+ [Abbestellen eines Themas](#cli-unsubscribe-sns-topic)
+ [Löschen eines Themas](#cli-delete-sns-topic)
## Erstellen eines Themas
Zum Erstellen eines Themas verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sns/create-topic.html](https://docs.aws.amazon.com/cli/latest/reference/sns/create-topic.html) und geben den Namen an, den Sie dem Thema zuweisen möchten.
```
$ aws sns create-topic --name my-topic
{
"TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
```
Notieren Sie sich den `TopicArn` der Antwort, den Sie später zum Veröffentlichen einer Nachricht benötigen.
## Abonnieren eines Themas
Verwenden Sie zum Abonnieren eines Themas den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html](https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html).
Das folgende Beispiel gibt das `email`-Protokoll und eine E-Mail-Adresse für den `notification-endpoint` an.
```
$ aws sns subscribe --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic --protocol email --notification-endpoint saanvi@example.com
{
"SubscriptionArn": "pending confirmation"
}
```
AWS sendet sofort eine Bestätigungsnachricht per E-Mail an die Adresse, die Sie im Befehl `subscribe` angegeben haben. Die E-Mail-Nachricht enthält den folgenden Text.
```
You have chosen to subscribe to the topic:
arn:aws:sns:us-west-2:123456789012:my-topic
To confirm this subscription, click or visit the following link (If this was in error no action is necessary):
Confirm subscription
```
Nachdem der Empfänger auf den Link für **Confirm subscription (Abonnement bestätigen)** geklickt hat, zeigt der Browser des Empfängers eine Benachrichtigung mit Informationen ähnlich der folgenden an.
```
Subscription confirmed!
You have subscribed saanvi@example.com to the topic:my-topic.
Your subscription's id is:
arn:aws:sns:us-west-2:123456789012:my-topic:1328f057-de93-4c15-512e-8bb22EXAMPLE
If it was not your intention to subscribe, click here to unsubscribe.
```
## Veröffentlichung für ein Thema
Zum Senden einer Nachricht an alle Abonnenten eines Themas verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html](https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html).
Das folgende Beispiel sendet die Meldung „Hallo Welt\$1“ an alle Abonnenten des angegebenen Themas.
```
$ aws sns publish --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic --message "Hello World!"
{
"MessageId": "4e41661d-5eec-5ddf-8dab-2c867EXAMPLE"
}
```
In diesem Beispiel sendet AWS eine E-Mail-Nachricht mit dem Text „Hallo Welt\$1“ an `saanvi@example.com`.
## Abbestellen eines Themas
Zum Abmelden von einem Thema und zum Beenden des Empfangs von Nachrichten zu diesem Thema verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sns/unsubscribe.html](https://docs.aws.amazon.com/cli/latest/reference/sns/unsubscribe.html) und geben den ARN des Themas an, das Sie nicht mehr abonnieren möchten.
```
$ aws sns unsubscribe --subscription-arn arn:aws:sns:us-west-2:123456789012:my-topic:1328f057-de93-4c15-512e-8bb22EXAMPLE
```
Wenn Sie prüfen möchten, ob das Abonnement erfolgreich beendet wurde, verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sns/list-subscriptions.html](https://docs.aws.amazon.com/cli/latest/reference/sns/list-subscriptions.html), um zu bestätigen, dass der ARN nicht mehr in der Liste erscheint.
```
$ aws sns list-subscriptions
```
## Löschen eines Themas
Mit dem Befehl [https://docs.aws.amazon.com/cli/latest/reference/sns/delete-topic.html](https://docs.aws.amazon.com/cli/latest/reference/sns/delete-topic.html) können Sie ein Thema löschen.
```
$ aws sns delete-topic --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic
```
Wenn Sie prüfen möchten, ob AWS das Thema erfolgreich gelöscht hat, verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sns/list-topics.html](https://docs.aws.amazon.com/cli/latest/reference/sns/list-topics.html), um zu bestätigen, dass das Thema nicht mehr in der Liste erscheint.
```
$ aws sns list-topics
```