AWS Cloud9 ist für Neukunden nicht mehr verfügbar. Bestehende Kunden von AWS Cloud9 können den Dienst weiterhin wie gewohnt nutzen. [Weitere Informationen](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
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.
# Tutorials für AWS Cloud9
Sind Sie neu bei AWS Cloud9? Unter [Erste Schritte: grundlegende Tutorials](tutorials-basic.md) erhalten Sie eine Einführung in die IDE.
Experimentieren Sie mit diesen Tutorials und dem Beispielcode, um Ihr Wissen und Ihr Selbstvertrauen im Umgang AWS Cloud9 mit verschiedenen Programmiersprachen und AWS Diensten zu erweitern.
**Topics**
+ [AWS CLI und Aws-Shell-Tutorial](sample-aws-cli.md)
+ [AWS CodeCommit Tutorial](sample-codecommit.md)
+ [Amazon DynamoDB DynamoDB-Anleitung](sample-dynamodb.md)
+ [AWS CDK Tutorial](sample-cdk.md)
+ [LAMP-Tutorial](sample-lamp.md)
+ [WordPress Tutorial](sample-wordpress.md)
+ [Java-Tutorial](sample-java.md)
+ [C\$1\$1-Tutorial](sample-cplusplus.md)
+ [Python-Tutorial](sample-python.md)
+ [.NET-Tutorial](sample-dotnetcore.md)
+ [Anleitung Node.js](sample-nodejs.md)
+ [PHP-Tutorial](sample-php.md)
+ [Ruby](tutorial-ruby.md)
+ [Gehe zum Tutorial](sample-go.md)
+ [TypeScript Tutorial](sample-typescript.md)
+ [Docker-Tutorial](sample-docker.md)
+ [Verwandte Tutorials](#samples-additonal)
# AWS CLI und AWS-Shell-Tutorial für AWS Cloud9
Das folgende Tutorial ermöglicht es Ihnen, die AWS Command Line Interface (AWS CLI), die AWS-Shell oder beide in einer AWS Cloud9 Entwicklungsumgebung einzurichten. Die AWS CLI und die AWS-Shell sind vereinheitlichte Tools, die eine konsistente Oberfläche für die Interaktion mit allen Teilen von bieten. AWS Sie können AWS CLI anstelle von die Befehle verwenden AWS-Managementkonsole , um schnell Befehle auszuführen AWS, mit denen Sie interagieren können, und einige dieser Befehle können mit AWS CLI oder alternativ mit dem ausgeführt werden. AWS CloudShell
Weitere Informationen zu AWS CLI finden Sie im [AWS Command Line Interface Benutzerhandbuch](https://docs.aws.amazon.com/cli/latest/userguide/). Informationen über aws-shell finden Sie in den folgenden Ressourcen:
+ [aws-shell](https://github.com/awslabs/aws-shell) auf der Website GitHub
+ [aws-shell](https://pypi.python.org/pypi/aws-shell) auf der pip-Website
Eine Liste der Befehle, mit denen Sie interagieren können AWS, finden AWS CLI Sie in der [AWS CLI Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/). Sie können dieselben Befehle mit verwenden AWS CloudShell, mit der Ausnahme, dass Sie Befehle ohne das `aws` Präfix starten.
Die Erstellung dieses Beispiels kann dazu führen, dass Ihr AWS Konto belastet wird. Dies umfasst mögliche Kosten für Services wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-aws-cli-prereqs)
+ [Schritt 1: Installieren Sie die AWS CLI AWS-Shell oder beides in Ihrer Umgebung](#sample-aws-cli-install)
+ [Schritt 2: Richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein](#sample-aws-cli-creds)
+ [Schritt 3: Führen Sie grundlegende Befehle mit der AWS CLI oder der AWS-Shell in Ihrer Umgebung aus](#sample-aws-cli-run)
+ [Schritt 4: Bereinigen](#sample-aws-cli-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren Sie die AWS CLI AWS-Shell oder beides in Ihrer Umgebung
In diesem Schritt verwenden Sie die AWS Cloud9 IDE, um die AWS-Shell oder beides in Ihrer Umgebung zu installieren, sodass Sie Befehle ausführen können, mit denen Sie interagieren können. AWS CLI AWS
Wenn Sie eine AWS Cloud9 EC2-Entwicklungsumgebung verwenden und nur die verwenden möchten AWS CLI, können Sie mit fortfahren. [Schritt 3: Führen Sie grundlegende Befehle mit der AWS CLI oder der AWS-Shell in Ihrer Umgebung aus](#sample-aws-cli-run) Das liegt daran, dass der AWS CLI bereits in einer EC2-Umgebung installiert ist und in der Umgebung bereits ein Satz von AWS Zugangsdaten eingerichtet ist. Weitere Informationen finden Sie unter [AWS verwaltete temporäre Anmeldeinformationen](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Wenn Sie keine EC2-Umgebung verwenden, führen Sie die folgenden Schritte aus, um die AWS CLI zu installieren:
1. Prüfen Sie bei geöffneter Umgebung in der IDE, ob der bereits installiert AWS CLI ist. Führen Sie im Terminal den ** `aws --version` **-Befehl aus. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus.) Wenn der installiert AWS CLI ist, wird die Versionsnummer mit Informationen wie den Versionsnummern von Python und der Betriebssystemversionsnummer Ihrer Amazon EC2 EC2-Instance oder Ihres eigenen Servers angezeigt. Wenn der installiert AWS CLI ist, fahren Sie mit fort[Schritt 2: Richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein](#sample-aws-cli-creds).
1. Informationen zur AWS CLI Installation [von finden Sie unter Installation von AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) im *AWS Command Line Interface Benutzerhandbuch*. Führen Sie beispielsweise in einer EC2-Umgebung unter Amazon Linux diese drei Befehle nacheinander im Terminal aus, um die AWS CLI zu installieren.
```
sudo yum -y update # Install the latest system updates.
sudo yum -y install aws-cli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
Führen Sie in einer EC2-Umgebung, die auf einem Ubuntu Server ausgeführt wird, stattdessen diese drei Befehle nacheinander im Terminal aus, um die AWS CLI zu installieren.
```
sudo apt update # Install the latest system updates.
sudo apt install -y awscli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
Führen Sie folgende Schritte aus, um die aws-shell zu installieren:
1. Überprüfen Sie in der IDE bei geöffneter Umgebung, ob aws-shell bereits installiert ist. Führen Sie im Terminal den ** `aws-shell` **-Befehl aus. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus.) Wenn aws-shell installiert ist, wird die `aws>`-Eingabeaufforderung angezeigt. Wenn die aws-shell installiert ist, können Sie mit [Schritt 2: Richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein](#sample-aws-cli-creds) fortfahren.
1. Zum Installieren von aws-shell verwenden Sie pip. Um pip verwenden zu können, muss Python installiert sein.
Um zu überprüfen, ob Python bereits installiert ist (und um es gegebenenfalls zu installieren), befolgen Sie die Anweisungen in [Schritt 1: Installieren von Python](sample-python.md#sample-python-install) im *Python-Beispiel* und kehren Sie dann zu diesem Thema zurück.
Um zu überprüfen, ob pip bereits installiert ist, führen Sie im Terminal den ** `pip --version` **-Befehl aus. Wenn pip installiert ist, wird die Versionsnummer angezeigt. Wenn pip nicht installiert ist, installieren Sie es, indem Sie diese drei Befehle nacheinander im Terminal ausführen.
```
wget https://bootstrap.pypa.io/get-pip.py # Get the pip install file.
sudo python get-pip.py # Install pip. (You might need to run 'sudo python2 get-pip.py' or 'sudo python3 get-pip.py' instead, depending on how Python is installed.)
rm get-pip.py # Delete the pip install file, as it is no longer needed.
```
1. Um aws-shell mithilfe von pip zu installieren, führen Sie den folgenden Befehl aus.
```
sudo pip install aws-shell
```
## Schritt 2: Richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein
Jedes Mal, wenn Sie die AWS CLI oder die AWS-Shell verwenden, um einen AWS Dienst aufzurufen, müssen Sie beim Aufruf eine Reihe von Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob die AWS CLI oder die AWS-Shell über die entsprechenden Berechtigungen für den Aufruf verfügt. Wenn die Anmeldeinformationen nicht die entsprechenden Berechtigungen haben, schlägt der Aufruf fehl.
Wenn Sie eine AWS Cloud9 EC2-Entwicklungsumgebung verwenden, können Sie mit fortfahren. [Schritt 3: Führen Sie grundlegende Befehle mit der AWS CLI oder der AWS-Shell in Ihrer Umgebung aus](#sample-aws-cli-run) Das liegt daran, dass die Anmeldeinformationen in einer EC2-Umgebung bereits eingerichtet sind. Weitere Informationen finden Sie unter [AWS verwaltete temporäre Anmeldeinformationen](security-iam.md#auth-and-access-control-temporary-managed-credentials).
Wenn Sie keine EC2-Umgebung verwenden, müssen Sie Ihre Anmeldeinformationen manuell in der Umgebung speichern. Befolgen Sie stattdessen die Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md) und kehren Sie dann zu diesem Thema zurück.
## Schritt 3: Führen Sie grundlegende Befehle mit der AWS CLI oder der AWS-Shell in Ihrer Umgebung aus
In diesem Schritt verwenden Sie die AWS CLI oder die aws-shell in Ihrer Umgebung, um einen Bucket in Amazon S3 zu erstellen, Ihre verfügbaren Buckets aufzulisten und dann den Bucket zu löschen.
1. Wenn Sie aws-shell verwenden möchten, aber noch nicht gestartet haben, starten Sie aws-shell, indem Sie den `aws-shell` Befehl ausführen. Es wird die `aws>`-Eingabeaufforderung angezeigt.
1. Erstellen Sie einen Bucket. Führen Sie den **`aws s3 mb`**Befehl mit dem **`s3 mb`**Befehl AWS CLI or mit der AWS-Shell aus und geben Sie den Namen des zu erstellenden Buckets an. In diesem Beispiel verwenden wir einen Bucket mit dem Namen`cloud9-123456789012-bucket`, wobei Ihre AWS Konto-ID `123456789012` ist. Wenn Sie einen anderen Namen verwenden, muss dieser während des gesamten Schritts verwendet werden.
```
aws s3 mb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 mb s3://cloud9-123456789012-bucket # For the aws-shell.
```
**Anmerkung**
Bucket-Namen müssen für alle, nicht nur für Ihr AWS Konto AWS, eindeutig sein. Der zuvor vorgeschlagene Bucket-Namen kann Ihnen dabei behilflich sein, sich einen eindeutigen Bucket-Namen zu überlegen. Wenn Sie die Fehlernachricht `BucketAlreadyExists` erhalten, müssen Sie den Befehl mit einem anderen Bucket-Namen erneut ausführen.
1. Listen Sie die verfügbaren Buckets auf. Führen Sie den **`aws s3 ls`**Befehl mit AWS CLI oder den **`s3 ls`**Befehl mit der AWS-Shell aus. Es wird eine Liste der verfügbaren Buckets angezeigt.
1. Löschen Sie den Bucket. Führen Sie den **`aws s3 rb`**Befehl mit AWS CLI oder den Befehl mit der AWS-Shell **`s3 rb`**aus und geben Sie den Namen des zu löschenden Buckets an.
```
aws s3 rb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 rb s3://cloud9-123456789012-bucket # For the aws-shell.
```
Um zu überprüfen, ob der Bucket gelöscht wurde, führen Sie den **`aws s3 ls`**Befehl erneut mit AWS CLI oder den Befehl erneut mit der **`s3 ls`**AWS-Shell aus. Der Name des gelöschten Buckets, sollte nicht länger in der Liste angezeigt werden.
**Anmerkung**
Sie müssen den Bucket nicht löschen, wenn Sie ihn weiter verwenden möchten. Anleitungen finden Sie unter [Hinzufügen eines Objekts zu einem Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) im *Benutzerhandbuch zu Amazon Simple Storage Service*. Weitere Informationen finden Sie auch unter[S3-Befehle](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html.html) im *AWS CLI -Befehlsreferenz*. (Denken Sie daran: Wenn Sie den Bucket nicht löschen, kann dies zu laufenden Belastungen Ihres AWS Kontos führen.)
Weitere Informationen zum Experimentieren finden Sie unter [Arbeiten mit Amazon Web Services](https://docs.aws.amazon.com/cli/latest/userguide/chap-working-with-services.html) im *AWS Command Line Interface Benutzerhandbuch* sowie in der [AWS CLI Befehlsreferenz. AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/) Weitere Experimente mit aws-shell finden Sie in der [AWS CLI -Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/). Beachten Sie hierbei, die Befehle ohne das `aws` Präfix zu verwenden.
## Schritt 4: Bereinigen
Wenn Sie aws-shell verwenden, können Sie anhand der Befehle ** `.exit` ** oder ** `.quit` ** dessen Verwendung einstellen.
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie die Umgebung löschen. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# AWS CodeCommit Tutorial für AWS Cloud9
Sie können das AWS CodeCommit Tutorial verwenden, um eine AWS Cloud9 Entwicklungsumgebung einzurichten, in CodeCommit der Sie mit einem Remote-Code-Repository interagieren können. CodeCommit ist ein Dienst zur Quellcodeverwaltung, mit dem Sie Git Repositorys privat speichern und verwalten können. AWS Cloud Weitere Informationen dazu CodeCommit finden Sie im [AWS CodeCommit Benutzerhandbuch](https://docs.aws.amazon.com/codecommit/latest/userguide/).
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, können Gebühren für Sie anfallen AWS-Konto. Dazu gehören mögliche Gebühren für Dienste wie Amazon EC2 und CodeCommit. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [AWS CodeCommit – Preise](https://aws.amazon.com/codecommit/pricing/).
+ [Voraussetzungen](#sample-codecommit-prereqs)
+ [Schritt 1: Einrichten Ihrer IAM-Gruppe mit den erforderlichen Zugriffsberechtigungen](#sample-codecommit-permissions)
+ [Schritt 2: Erstellen Sie ein Repository in AWS CodeCommit](#sample-codecommit-create-repo)
+ [Schritt 3: Verbinden Ihrer Umgebung mit dem Remote-Repository](#sample-codecommit-connect-repo)
+ [Schritt 4: Klonen des Remote-Repositorys in Ihre Umgebung](#sample-codecommit-clone-repo)
+ [Schritt 5: Hinzufügen von Dateien zum Repository](#sample-codecommit-add-files)
+ [Schritt 6: Bereinigen](#sample-codecommit-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Einrichten Ihrer IAM-Gruppe mit den erforderlichen Zugriffsberechtigungen
Angenommen, Ihre AWS Anmeldeinformationen sind mit einem Administratorbenutzer in Ihrem AWS-Konto verknüpft und Sie möchten diesen Benutzer verwenden, um mit diesem Benutzer zu arbeiten. Fahren Sie CodeCommit dann mit [Schritt 2: Repository erstellen in](#sample-codecommit-create-repo) fort AWS CodeCommit.
Sie können diesen Schritt mit der [AWS-Managementkonsole](#sample-codecommit-permissions-console) oder der [AWS Command-Line-Schnittstelle (AWS CLI)](#sample-codecommit-permissions-cli) abschließen.
### Einrichten Ihrer IAM-Gruppe mit erforderlichen Zugriffsberechtigungen mithilfe der Konsole
1. Melden Sie sich bei der an AWS-Managementkonsole, falls Sie noch nicht angemeldet sind.
Wir empfehlen Ihnen, sich für diesen Schritt mit Anmeldeinformationen eines Administratorbenutzers in Ihrem AWS-Konto anzumelden. Falls dies nicht möglich ist, wenden Sie sich an Ihren AWS-Konto -Administrator.
1. Öffnen Sie die IAM-Konsole. Wählen Sie dazu in der Navigationsleiste der Konsole die Option **Services** aus. Wählen Sie anschließend **IAM** aus.
1. Klicken Sie auf **Groups (Gruppen)**.
1. Wählen Sie den Namen der Gruppe.
1. Wählen Sie auf der Registerkarte **Permissions (Berechtigungen)** für **Managed Policies (Verwaltete Richtlinien)** die Option **Attach Policy (Richtlinie anfügen)** aus.
1. Wählen Sie in der Liste der Richtliniennamen eines der folgenden Felder aus:
+ Wählen Sie **AWSCodeCommitPowerUser**diese Option aus, um auf alle Funktionen von CodeCommit und Ressourcen im Zusammenhang mit dem Repository zuzugreifen. Dies ermöglicht es Ihnen jedoch nicht, Repositorys zu löschen oder CodeCommit repository-bezogene Ressourcen in anderen zu erstellen oder zu löschen AWS-Services, z. B. in Amazon Events. CloudWatch
+ Wählen Sie diese Option **AWSCodeCommitFullAccess**für die vollständige Kontrolle über CodeCommit Repositorys und zugehörige Ressourcen in der. AWS-Konto Dazu gehört auch die Möglichkeit, Repositorys zu löschen.
Wenn Sie keinen dieser Richtliniennamen in der Liste sehen, geben Sie die Richtliniennamen im Feld **Filter** ein, um sie anzuzeigen.
1. Wählen Sie **Richtlinie anfügen** aus.
Eine Liste der Zugriffsberechtigungen, die diese AWS verwalteten Richtlinien einer Gruppe gewähren, finden Sie AWS CodeCommit im *AWS CodeCommit Benutzerhandbuch* unter [AWS Verwaltete (vordefinierte) Richtlinien für](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies).
Fahren Sie mit [Schritt 2 fort: Erstellen Sie ein Repository in AWS CodeCommit](#sample-codecommit-create-repo).
### Richten Sie Ihre IAM-Gruppe mit den erforderlichen Zugriffsberechtigungen ein, indem Sie AWS CLI
Führen Sie den `attach-group-policy` IAM-Befehl aus und geben Sie den Gruppennamen und den Amazon-Ressourcennamen (ARN) der AWS verwalteten Richtlinie an, die die erforderlichen Zugriffsberechtigungen beschreibt. Die Syntax ist wie folgt.
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
Ersetzen Sie im vorherigen Befehl `MyGroup` durch den Namen der Gruppe. Durch `POLICY_ARN` den ARN der AWS verwalteten Richtlinie ersetzen:
+ `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser`für den Zugriff auf alle Funktionen von CodeCommit und Ressourcen, die sich auf das Repository beziehen. Es erlaubt Ihnen jedoch nicht, Repositorys zu löschen oder CodeCommit repository-bezogene Ressourcen in anderen zu erstellen oder zu löschen AWS-Services, z. B. in Amazon Events. CloudWatch
+ `arn:aws:iam::aws:policy/AWSCodeCommitFullAccess`für die volle Kontrolle über CodeCommit Repositorys und zugehörige Ressourcen in der. AWS-Konto Dazu gehört auch die Möglichkeit, Repositorys zu löschen.
Eine Liste der Zugriffsberechtigungen, die diese AWS verwalteten Richtlinien einer Gruppe gewähren, finden Sie AWS CodeCommit im *AWS CodeCommit Benutzerhandbuch* unter [AWS Verwaltete (vordefinierte) Richtlinien für](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies).
## Schritt 2: Erstellen Sie ein Repository in CodeCommit
In diesem Schritt erstellen Sie CodeCommit mithilfe der CodeCommit Konsole ein Remote-Code-Repository in.
Wenn Sie bereits über ein CodeCommit Repository verfügen, fahren Sie mit [Schritt 3: Connect Ihre Umgebung mit dem Remote-Repository](#sample-codecommit-connect-repo) fort.
Sie können diesen Schritt mit der [AWS-Managementkonsole](#sample-codecommit-create-repo-console) oder der [AWS Command-Line-Schnittstelle (AWS CLI)](#sample-codecommit-create-repo-cli) abschließen.
### Erstellen Sie CodeCommit mithilfe der Konsole ein Repository
1. Angenommen, Sie sind im vorherigen Schritt AWS-Managementkonsole als Administratorbenutzer angemeldet und möchten den Administratorbenutzer nicht zum Erstellen des Repositorys verwenden. Melden Sie sich dann von der ab AWS-Managementkonsole.
1. Öffnen Sie die CodeCommit Konsole unter [https://console.aws.amazon.com/codecommit.](https://console.aws.amazon.com/codecommit)
1. Verwenden Sie in der Navigationsleiste der Konsole die Regionenauswahl, um die AWS-Region auszuwählen, in der Sie das Repository erstellen möchten (z. B. **USA Ost (Ohio)**).
1. Wenn eine Willkommensseite angezeigt wird, wählen Sie die Option **Get Started** aus. Andernfalls, wählen Sie **Create repository (Repository erstellen)** aus.
1. Geben Sie auf der Seite **Create repository** (Repository erstellen) im Feld **Repository name** (Repository-Name) einen Namen für Ihr Repository ein (z. B. `MyDemoCloud9Repo`). Wenn Sie einen anderen Namen verwenden, muss dieser im gesamten Beispiel verwendet werden.
1. (Optional) Geben Sie im Feld **Description** (Beschreibung) Informationen über das Repository ein. Sie können beispielsweise Folgendes eingeben: `This is a demonstration repository for the AWS Cloud9 sample.`
1. Wählen Sie **Repository erstellen** aus. Ein Bereich **Connect to your repository (Herstellen einer Verbindung mit Ihrem Repository)** wird angezeigt. Klicken Sie auf **Close (Schließen)**, da Sie zu einem späteren Zeitpunkt in diesem Thema eine Verbindung mit Ihrem Repository auf eine andere Weise herstellen.
Fahren Sie mit [Schritt 3: Verbinden Ihrer Umgebung mit dem Remote-Repository](#sample-codecommit-connect-repo) fort.
### Erstellen Sie ein Repository mit dem CodeCommit AWS CLI
Führen Sie den Befehl AWS CodeCommit `create-repository` aus. Geben Sie den Namen des Repositorys, eine optionale Beschreibung und den Ort AWS-Region an, in dem das Repository erstellt werden soll.
```
aws codecommit create-repository --repository-name MyDemoCloud9Repo --repository-description "This is a demonstration repository for the AWS Cloud9 sample." --region us-east-2
```
Ersetzen Sie im vorherigen Befehl `us-east-2` durch die ID der AWS-Region , in der das Repository erstellt werden soll. Eine Liste der unterstützten Regionen finden Sie [AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region)in der *Allgemeine Amazon Web Services-Referenz*.
Wenn Sie einen anderen Repository-Namen verwenden möchten, muss dieser im gesamten Beispiel verwendet werden.
## Schritt 3: Verbinden Ihrer Umgebung mit dem Remote-Repository
In diesem Schritt verwenden Sie die AWS Cloud9 IDE, um eine Verbindung zu dem CodeCommit Repository herzustellen, das Sie im vorherigen Schritt erstellt oder identifiziert haben.
**Anmerkung**
Wenn Sie es vorziehen, mit Git über eine visuelle Schnittstelle zu arbeiten, können Sie das Remote-Repository klonen. Anschließend können Sie mithilfe der [Git-Panel](source-control-gitpanel.md)-Funktion, die in der IDE verfügbar ist, Dateien hinzufügen.
Befolgen Sie eines der folgenden Verfahren je nach Typ Ihrer AWS Cloud9 -Entwicklungsumgebung.
****
| **Umgebungstyp** | **Befolgen Sie diese Verfahren** |
| --- | --- |
| EC2-Umgebung | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/sample-codecommit.html) |
| SSH-Umgebung | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/sample-codecommit.html) |
## Schritt 4: Klonen des Remote-Repositorys in Ihre Umgebung
In diesem Schritt verwenden Sie die AWS Cloud9 IDE, um das Remote-Repository CodeCommit in Ihre Umgebung zu klonen.
Führen Sie zum Klonen des Repositorys den Befehl **`git clone`** aus. Ersetzen Sie `CLONE_URL` durch die Klon-URL des Repositorys.
```
git clone CLONE_URL
```
Bei einer EC2-Umgebung übergeben Sie eine HTTPS-Klon-URL, die mit `https://` beginnt. Bei einer SSH-Umgebung übergeben Sie eine SSH-Klon-URL, die mit `ssh://` beginnt.
Informationen zum Abrufen der vollständigen Clone-URL des Repositorys finden [Sie im *AWS CodeCommit Benutzerhandbuch* unter Repository-Details mithilfe der AWS CodeCommit Konsole anzeigen](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-view-repository-details.html#how-to-view-repository-details-console).
Wenn Ihr Repository keine Dateien enthält, wird eine Warnmeldung angezeigt, z. B. `You appear to have cloned an empty repository.`. Dies ist ein erwartetes Verhalten. Sie werden sich später damit befassen.
## Schritt 5: Hinzufügen von Dateien zum Repository
In diesem Schritt erstellen Sie drei einfache Dateien im geklonten Repository in Ihrer AWS Cloud9 -Umgebung. Als Nächstes fügen Sie die Dateien dem Git-Stagingbereich in Ihrem geklonten Repository hinzu. Zuletzt übergeben Sie die Dateien in der Staging-Umgebung und übertragen den Commit per Push in CodeCommit Ihr Remote-Repository.
Wenn das Repository bereits Dateien enthält, sind Sie fertig und können den Rest dieses Beispiels überspringen.
**So fügen Sie Dateien dem Repository hinzu**
1. Erstellen Sie eine neue Datei. Wählen Sie in der Menüleiste **File** (Datei) und dann **New File** (Neue Datei) aus.
1. Geben Sie den folgenden Inhalt in die Datei ein und wählen Sie dann „**Datei**“, „**Speichern**“, um die Datei `bird.txt` in dem `MyDemoCloud9Repo` Verzeichnis in Ihrer AWS Cloud9 Umgebung zu speichern.
```
bird.txt
--------
Birds are a group of endothermic vertebrates, characterized by feathers,
toothless beaked jaws, the laying of hard-shelled eggs, a high metabolic
rate, a four-chambered heart, and a lightweight but strong skeleton.
```
**Anmerkung**
Sie können bestätigen, dass Sie diese Datei im korrekten Verzeichnis speichern, indem Sie im Dialogfeld **Save As** (Speichern als) den Ordner `MyDemoCloud9Repo` auswählen. Stellen Sie dann sicher, dass für **Folder** (Ordner) `/MyDemoCloud9Repo` angezeigt wird.
1. Erstellen Sie zwei weitere Dateien mit dem Namen `insect.txt` und `reptile.txt` mit dem folgenden Inhalt. Speichern Sie die Dateien im Verzeichnis `MyDemoCloud9Repo`.
```
insect.txt
----------
Insects are a class of invertebrates within the arthropod phylum that
have a chitinous exoskeleton, a three-part body (head, thorax, and abdomen),
three pairs of jointed legs, compound eyes, and one pair of antennae.
```
```
reptile.txt
-----------
Reptiles are tetrapod (four-limbed vertebrate) animals in the class
Reptilia, comprising today's turtles, crocodilians, snakes,
amphisbaenians, lizards, tuatara, and their extinct relatives.
```
1. Führen Sie im Terminal den Befehl **`cd`** aus, um in das Verzeichnis `MyDemoCloud9Repo` zu wechseln.
```
cd MyDemoCloud9Repo
```
1. Bestätigen Sie, dass die Dateien erfolgreich im Verzeichnis `MyDemoCloud9Repo` gespeichert wurden, indem Sie den Befehl **`git status`** ausführen. Alle drei Dateien werden als nicht verfolgte Dateien angezeigt.
```
Untracked files:
(use "git add ..." to include in what will be committed)
bird.txt
insect.txt
reptile.txt
```
1. Fügen Sie die Dateien dem Git-Stagingbereich hinzu, indem Sie den Befehl **`git add`** ausführen.
```
git add --all
```
1. Bestätigen Sie, dass die Dateien dem Git-Stagingbereich erfolgreich hinzugefügt wurden, indem Sie den Befehl **`git status`** erneut ausführen. Alle drei Dateien werden jetzt als zu bestätigende Änderungen angezeigt.
```
Changes to be committed:
(use "git rm --cached ..." to unstage)
new file: bird.txt
new file: insect.txt
new file: reptile.txt
```
1. Führen Sie den Commit für die bereitgestellten Dateien durch, indem Sie den Befehl **`git commit`** ausführen.
```
git commit -m "Added information about birds, insects, and reptiles."
```
1. Übertrage den Commit in dein Remote-Repository, CodeCommit indem du den **`git push`**Befehl ausführst.
```
git push -u origin master
```
1. Bestätigen Sie, ob die Dateien erfolgreich übertragen wurden. Öffnen Sie die CodeCommit Konsole unter [https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit), falls sie nicht bereits geöffnet ist.
1. Wählen Sie in der oberen Navigationsleiste am rechten Rand den Ort aus, AWS-Region an dem Sie das Repository erstellt haben (z. B. **US East (Ohio))**.
1. Wählen Sie auf der **Dashboard-Seite MyDemoCloud** **9Repo** aus. Die drei Dateien werden angezeigt.
*Weitere Informationen zum Experimentieren mit Ihrem CodeCommit Repository finden Sie im Benutzerhandbuch unter [Den Inhalt Ihres Repositorys durchsuchen](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse).AWS CodeCommit *
[Wenn Sie mit Ihrem CodeCommit Repository noch nicht vertraut sind Git und es nicht durcheinander bringen möchten, experimentieren Sie mit einem Git Beispiel-Repository auf der Git Try-Website.](https://try.github.io/)
## Schritt 6: Bereinigen
Um zu verhindern, dass Ihnen AWS-Konto nach der Nutzung dieses Beispiels weitere Kosten entstehen, löschen Sie das CodeCommit Repository. Anweisungen finden Sie im *AWS CodeCommit Benutzerhandbuch* unter [Löschen eines AWS CodeCommit Repositorys](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html).
Löschen Sie auch die Umgebung. Weitere Informationen finden Sie unter [Löschen einer Umgebung](delete-environment.md).
# Amazon DynamoDB-Tutorial für AWS Cloud9
In diesem Tutorial können Sie eine AWS Cloud9 Entwicklungsumgebung für die Arbeit mit Amazon DynamoDB einrichten.
DynamoDB ist ein vollständig verwalteter NoSQL-Datenbankservice. Sie können mit DynamoDB eine Datenbanktabelle erstellen, mit der eine beliebige Datenmenge gespeichert und abgerufen werden kann und der Anforderungsdatenverkehr verarbeitet werden kann. DynamoDB verteilt die Daten und den Datenverkehr für die Tabelle automatisch auf eine ausreichende Anzahl von Servern, um die angegebene Anforderungskapazität und die Menge der gespeicherten Daten zu verarbeiten und dabei eine konsistente und schnelle Leistung beizubehalten. Weitere Informationen finden Sie auf der [Website unter Amazon DynamoDB](https://aws.amazon.com/dynamodb/). AWS
Die Erstellung dieses Beispiels kann dazu führen, dass Ihr AWS Konto belastet wird. Dies umfasst mögliche Kosten für Services wie Amazon EC2 und DynamoDB. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon DynamoDB – Preise](https://aws.amazon.com/dynamodb/pricing/).
Informationen zu zusätzlichen AWS Datenbankangeboten finden Sie auf der [Website unter Amazon Relational Database Service (RDS)](https://aws.amazon.com/rds/) ElastiCache, [Amazon](https://aws.amazon.com/elasticache/) [und Amazon Redshift](https://aws.amazon.com/redshift/). AWS Weitere Informationen finden Sie auch unter[AWS Database Migration Service](https://aws.amazon.com/dms/) auf der AWS -Website.
+ [Voraussetzungen](#sample-dynamodb-prereqs)
+ [Schritt 1: Installieren und Konfigurieren der AWS CLI, der AWS CloudShell oder beider in Ihrer Umgebung](#sample-dynamodb-cli-setup)
+ [Schritt 2: Erstellen einer Tabelle](#sample-dynamodb-create-table)
+ [Schritt 3: Hinzufügen eines Elements zur Tabelle](#sample-dynamodb-add-item)
+ [Schritt 4: Hinzufügen von mehreren Elementen zur Tabelle](#sample-dynamodb-add-items)
+ [Schritt 5: Erstellen eines globalen sekundären Indexes](#sample-dynamodb-create-index)
+ [Schritt 6: Abrufen von Elementen aus der Tabelle](#sample-dynamodb-get-items)
+ [Schritt 7: Bereinigen](#sample-dynamodb-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren und konfigurieren Sie die AWS CLI AWS CloudShell, die oder beide in Ihrer Umgebung
In diesem Schritt verwenden Sie die AWS Cloud9 IDE, um das AWS CLI, das oder beide in Ihrer Umgebung zu installieren und zu konfigurieren AWS CloudShell, sodass Sie Befehle für die Interaktion mit DynamoDB ausführen können. Anschließend verwenden Sie die AWS CLI , um einen grundlegenden DynamoDB-Befehl auszuführen, um Ihre Installation und Konfiguration zu testen.
1. Um die Verwaltung der Anmeldeinformationen für das AWS CLI oder das einzurichten AWS CloudShell und das AWS CLI AWS CloudShell, das oder beide in Ihrer Umgebung zu installieren, folgen Sie den Schritten 1 und 2 im [AWS CloudShell Beispiel AWS CLI und](sample-aws-cli.md) kehren Sie dann zu diesem Thema zurück. Wenn Sie das AWS CLI AWS CloudShell, das oder beide bereits in Ihrer Umgebung installiert und konfiguriert haben, müssen Sie dies nicht erneut tun.
1. Testen Sie die Installation und Konfiguration der AWS CLI AWS-Shell oder beider, indem Sie den **`list-tables`**DynamoDB-Befehl von einer Terminalsitzung in Ihrer Umgebung aus ausführen, um Ihre vorhandenen DynamoDB-Tabellen aufzulisten, falls vorhanden. Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window (Fenster)**, **New Terminal (Neues Terminal)** aus.
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**Anmerkung**
In diesem Beispiel, lassen Sie `aws` aus jedem Befehl aus, der mit `aws` beginnt, wenn Sie die aws-shell verwenden. Führen Sie den Befehl ** `aws-shell` ** aus, um die aws-shell zu starten. Führen Sie den Befehl ** `.exit` ** oder ** `.quit` ** aus, um die aws-shell nicht mehr zu verwenden.
Wenn dieser Befehl erfolgreich ist, gibt er ein `TableNames`-Array mit einer Liste vorhandener DynamoDB-Tabellen zurück, die Sie eventuell bereits haben. Wenn Sie noch über keine DynamoDB-Tabellen verfügen, ist das `TableNames`-Array leer.
```
{
"TableNames": []
}
```
Wenn Sie DynamoDB-Tabellen haben, enthält das `TableNames`-Array eine Liste der Tabellennamen.
## Schritt 2: Erstellen einer Tabelle
In diesem Schritt erstellen Sie eine Tabelle in DynamoDB und geben den Namen, das Layout, den einfachen Primärschlüssel und Datendurchsatz in den Einstellungen an.
Diese Beispieltabelle namens `Weather` enthält Informationen über Wettervorhersagen für einige Städte in den USA. Die Tabelle enthält die folgenden Arten von Informationen (in DynamoDB wird jede Information als ein *Attribut* bezeichnet):
+ Erforderliche eindeutige Stadt-ID (`CityID`)
+ Erforderliches Vorhersagedatum (`Date`)
+ Name der Stadt (`City`)
+ Name des Bundesstaats (`State`)
+ Vorhersage-Wetterbedingungen (`Conditions`)
+ Vorhersagetemperaturen (`Temperatures`)
+ Vorhersage hoch, in Fahrenheit (`HighF`)
+ Vorhersage niedrig, in Fahrenheit (`LowF`)
Um die Tabelle zu erstellen, führen Sie in einer Terminalsitzung in der AWS Cloud9 IDE den DynamoDB-Befehl **`create-table`**aus.
```
aws dynamodb create-table \
--table-name Weather \
--attribute-definitions \
AttributeName=CityID,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema \
AttributeName=CityID,KeyType=HASH AttributeName=Date,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
In diesem Befehl gilt Folgendes:
+ `--table-name` stellt den Tabellennamen (`Weather` in diesem Beispiel) dar. Tabellennamen müssen in jeder AWS Region Ihres AWS Kontos eindeutig sein.
+ `--attribute-definitions` stellt die Attribute dar, die zum eindeutigen Identifizieren der Tabellenelemente verwendet werden. Jedes dieser Tabellenelemente wird eindeutig durch eine Kombination aus einem numerischen `ID`-Attribut und einem `Date`-Attribut, das als formatierte ISO-8601-Zeichenfolge dargestellt wird, identifiziert.
+ `--key-schema` stellt das Schlüsselschema der Tabelle dar. Diese Tabelle verfügt über den zusammengesetzten Primärschlüssel aus `CityID` und `Date`. Das bedeutet, dass alle Elemente der Tabelle einen `CityID`-Attributwert und einen `Date`-Attributwert haben müssen, aber keine zwei Elemente in der Tabelle können den gleichen `CityID`-Attributwert und `Date`-Attributwert haben.
+ `--provisioned-throughput` stellt die Lese- und Schreib-Kapazität der Tabelle dar. DynamoDB erlaubt bis zu fünf „Strongly Consistent“-Lesevorgänge pro Sekunde für Elemente mit bis zu 4 KB oder bis zu fünf „Eventually Consistent“-Lesevorgänge pro Sekunde für Elemente mit bis zu 4 KB. DynamoDB erlaubt auch bis zu fünf Schreibvorgänge pro Sekunde für Elemente von bis zu 1 KB.
**Anmerkung**
Wenn Sie einen höheren bereitgestellten Durchsatz festlegen, kann dies zu zusätzlichen Gebühren für Ihr AWS Konto führen.
Weitere Informationen zu diesen und anderen DynamoDB-Befehlen finden Sie unter [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html) in der *AWS CLI Befehlsreferenz*.
Wenn dieser Befehl erfolgreich ist, werden zusammenfassende Informationen zur neuen Tabelle angezeigt, die erstellt wird. Um zu bestätigen, dass die Tabelle erfolgreich erstellt wurde, führen Sie den DynamoDB-Befehl ** `describe-table` ** aus, wobei Sie den Namen der Tabelle angeben (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Wenn die Tabelle erfolgreich erstellt ist, ändert sich der `TableStatus`-Wert von `CREATING` zu `ACTIVE`. Fahren Sie nicht mit weiteren Schritten fort, bis die Tabelle erfolgreich erstellt wurde.
## Schritt 3: Hinzufügen eines Elements zu einer Tabelle
In diesem Schritt fügen Sie der Tabelle, die Sie gerade erstellt haben, ein Element hinzu.
1. Erstellen Sie eine Datei mit dem Namen `weather-item.json` und dem folgenden Inhalt. (Um eine neue Datei zu erstellen, wählen Sie in der Menüleiste **File (Datei)**, **New File (Neue Datei)** aus. Um die Datei zu speichern, wählen Sie **File (Datei)**, **Save (Speichern)** aus.
```
{
"CityID": { "N": "1" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "46" }
}
}
}
```
In diesem Code stellt `N` einen Attributwert dar, der eine Zahl ist. `S` ist ein Zeichenkettenattributwert. `M` ist ein Map-Attribut, das eine Menge von Attribut-Wert-Paaren ist. Sie müssen den Datentyp eines Attribut immer angeben, wenn Sie mit Elementen arbeiten. Weitere verfügbare Attribut-Datentypen finden Sie unter [Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) im *Entwicklerhandbuch für Amazon DynamoDB*.
1. Führen Sie den DynamoDB-Befehl ** `put-item` ** aus, wobei Sie den Namen der Tabelle (`--table-name`) und den Pfad zum JSON-formatierten Element (`--item`) angeben.
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
Wenn der Befehl erfolgreich ist, wird er ohne Fehler ausgeführt, und keine Bestätigungsmeldung wird angezeigt.
1. Um den aktuellen Inhalt der Tabelle zu prüfen, führen Sie den DynamoDB-Befehl ** `scan` ** aus, wobei Sie den Namen der Tabelle angeben (`--table-name`).
```
aws dynamodb scan --table-name Weather
```
Wenn der Befehl erfolgreich ist, werden zusammenfassende Informationen zu der Tabelle und zum Element, das Sie gerade hinzugefügt haben, angezeigt.
## Schritt 4: Hinzufügen von mehreren Elementen zu einer Tabelle
In diesem Schritt fügen Sie einige weitere Elemente zur Tabelle `Weather` hinzu.
1. Erstellen Sie eine Datei mit dem Namen `more-weather-items.json` und dem folgenden Inhalt.
```
{
"Weather": [
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "52" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Thunderstorms" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "51" },
"LowF": { "N": "41" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain Showers" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "39" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "40" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Partly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "54" },
"LowF": { "N": "37" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Mostly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "53" },
"LowF": { "N": "37" }
}
}
}
}
}
]
}
```
In diesem Code definieren acht `Item`-Objekte die acht Elemente, die der Tabelle hinzugefügt werden sollen, ähnlich wie bei dem einzelnen Element, das im vorherigen Schritt definiert wurde. Wenn Sie allerdings den DynamoDB-Befehl ** `batch-write-item` ** im nächsten Schritt ausführen, müssen Sie ein JSON-formatiertes Objekt angeben, das alle `Item`-Objekte in einem enthaltenden `PutRequest`-Objekt umfasst. Anschließend müssen Sie die `PutRequest`-Objekte in einem übergeordneten Array mit demselben Namen wie die Tabelle aufnehmen.
1. Führen Sie den DynamoDB-Befehl ** `batch-write-item` ** aus, wobei Sie den Pfad zu den JSON-formatierten Elementen angeben, die hinzugefügt werden sollen (`--request-items`).
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
Wenn der Befehl erfolgreich ist, wird die folgende Nachricht angezeigt, in der bestätigt wird, dass die Elemente erfolgreich hinzugefügt wurden.
```
{
"UnprocessedItems": {}
}
```
1. Um den aktuellen Inhalt der Tabelle zu bestätigen, führen Sie den DynamoDB-Befehl ** `scan` ** erneut aus.
```
aws dynamodb scan --table-name Weather
```
Wenn der Befehl erfolgreich ist, werden nun neun Elemente angezeigt.
## Schritt 5: Erstellen eines globalen sekundären Indexes
Das Ausführen des DynamoDB-Befehls ** `scan` **, um Informationen über die Elemente zu erhalten, kann langsam sein, vor allem, wenn die Tabelle größer wird oder wenn die Informationen, die Sie abrufen möchten, komplex sind. Sie können einen oder mehrere sekundäre Indizes hinzufügen, um die Dinge zu beschleunigen und das Abrufen von Informationen zu erleichtern. In diesem Schritt erfahren Sie mehr über zwei Arten von sekundären Indizes, die DynamoDB genau zu diesem Zweck unterstützt. Diese werden als *lokaler sekundärer Index* und als *globaler sekundärer Index* bezeichnet. Dann erstellen Sie einen globalen sekundären Index.
Um diese sekundären Index-Typen nachzuvollziehen, müssen Sie Primärschlüssel kennen, die die Elemente einer Tabelle eindeutig identifizieren. DynamoDB unterstützt einen *einfachen Primärschlüssel* oder einem *zusammengesetzten Primärschlüssel*. Ein einfacher Primärschlüssel hat ein einzelnes Attribut und dieser Attributwert muss für jedes Element in der Tabelle eindeutig sein. Dieses Attribut wird auch als *Partitions-Schlüssel* (oder *Hash-Attribut*) bezeichnet, das DynamoDB für eine Partition von Elementen verwenden kann, damit der Zugriff schneller erfolgt. Eine Tabelle kann auch über einen zusammengesetzten Primärschlüssel verfügen, der zwei Attribute enthält. Das erste Attribut ist der Partitionsschlüssel und das zweite ist ein *Sortierschlüssel* (auch bekannt als *Bereichsattribut*). In einer Tabelle mit einem zusammengesetzten Primärschlüssel, können zwei Elemente denselben Partitions-Schlüsselwert haben, aber sie können auch den gleichen Sortierschlüssel-Wert haben. Die Tabelle `Weather` verfügt über einen zusammengesetzten Primärschlüssel.
Ein lokaler sekundärer Index hat denselben Partitionsschlüssel wie die Tabelle selbst, der Indextyp kann jedoch einen anderen Sortierschlüssel haben. Ein globaler sekundärer Index kann einen Partitionsschlüssel und einen Sortierschlüssel haben, die sich beide von der Tabelle selbst unterscheiden können.
Beispielsweise können Sie bereits den Primärschlüssel für den Zugriff auf `Weather`-Elemente über `CityID` verwenden. Für den Zugriff auf `Weather`-Elemente über `State` können Sie einen lokalen sekundären Index mit einem Partitionsschlüssel `CityID` (es muss der gleiche wie für die Tabelle selbst sein) und einen Sortierschlüssel `State` erstellen. Für den Zugriff auf `Weather`-Elemente über `City` können Sie einen globalen sekundären Index mit einem Partitionsschlüssel `City` und einem Sortierschlüssel `Date` erstellen.
Sie können lokale sekundäre Indizes nur beim Erstellen einer Tabelle erstellen. Da die `Weather`-Tabelle bereits vorhanden ist, können Sie keine lokalen sekundären Indizes zu ihr hinzufügen. Sie können jedoch globale sekundäre Indizes hinzufügen. Üben Sie nun das Hinzufügen.
**Anmerkung**
Das Erstellen sekundärer Indizes kann zu zusätzlichen Gebühren in Ihrem AWS -Konto führen.
1. Erstellen Sie eine Datei mit dem Namen `weather-global-index.json` und dem folgenden Inhalt.
```
[
{
"Create": {
"IndexName": "weather-global-index",
"KeySchema": [
{
"AttributeName": "City",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"State",
"Conditions",
"Temperatures"
]
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
}
}
}
]
```
Infos zu diesem Code:
+ Der Name des globalen sekundären Indexes lautet `weather-global-index`.
+ Das `City`-Attribut ist der Partitionsschlüssel (Hash-Attribut) und das `Date`-Attribut ist der Sortierschlüssel (Bereichsattribut).
+ `Projection` definiert die Attribute, die standardmäßig (zusätzlich zu dem Hash-Attribut und jedem Bereichsattribut) für jedes Element abgerufen werden, das mit einer Tabellensuchanfrage übereinstimmt, die diesen Index verwendet. In diesem Beispiel werden die Attribute `State`, `Conditions`, `HighF` (Teil von `Temperatures`) und `LowF` (auch ein Teil von `Temperatures`) (sowie die Attribute `City` und `Date`) für jedes übereinstimmende Element abgerufen.
+ Ähnlich wie bei Tabellen muss ein globaler sekundärer Index die Einstellungen für bereitgestellten Durchsatz definieren.
+ Die Einstellungen `IndexName`, `KeySchema`, `Projection` und `ProvisionedThroughput` müssen in einem `Create`-Objekt vorhanden sein, das den zu erstellenden globalen sekundären Index definiert, wenn Sie den DynamoDB-Befehl ** `update-table` ** im nächsten Schritt ausführen.
1. Ausführen von DynamoDB-Befehl ** `update-table` **.
```
aws dynamodb update-table \
--table-name Weather \
--attribute-definitions \
AttributeName=City,AttributeType=S AttributeName=Date,AttributeType=S \
--global-secondary-index-updates file://weather-global-index.json
```
In diesem Befehl gilt Folgendes:
+ `--table-name` ist der Name der zu aktualisierenden Tabelle.
+ `--attribute-definitions` sind die Attribute, die in den Index aufgenommen werden sollen. Der Partitionsschlüssel wird immer an erster Stelle aufgeführt und alle Sortierschlüssel kommen an zweiter Stelle.
+ `--global-secondary-index-updates` ist der Pfad zu der Datei, die den globalen sekundären Index definiert.
Wenn dieser Befehl erfolgreich ist, werden zusammenfassende Informationen zum neuen globalen sekundären Index angezeigt, der erstellt wird. Um zu bestätigen, dass der globale sekundäre Index erfolgreich erstellt wurde, führen Sie den DynamoDB-Befehl ** `describe-table` ** aus, wobei Sie den Namen der Tabelle angeben (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Wenn der globale sekundäre Index erfolgreich erstellt wurde, wird der `TableStatus`-Wert von `UPDATING` in `ACTIVE` geändert und der `IndexStatus`-Wert ändert sich von `CREATING` in `ACTIVE`. Fahren Sie nicht mit weiteren Schritten fort, bis der globale sekundäre Index erfolgreich erstellt wurde. Dies kann mehrere Minuten dauern.
## Schritt 6: Abrufen von Elementen aus der Tabelle
Es gibt zahlreiche Möglichkeiten, um Elemente aus Tabellen abzurufen. In diesem Schritt erhalten Sie Elemente mit dem Primärschlüssel der Tabelle, indem Sie die anderen Attribute der Tabelle verwenden und mit dem globalen sekundären Index.
### So rufen Sie ein einzelnes Element aus einer Tabelle basierend auf dem primären Schlüsselwert des Elements ab
Wenn Sie den Primärschlüssel-Wert eines Elements kennen, können Sie das entsprechende Element abrufen, indem Sie den DynamoDB-Befehl ** `get-item` **, ** `scan` **, oder ** `query` ** ausführen. Im Folgenden sind die wichtigsten Unterschiede in diesen Befehlen erläutert:
+ ** `get-item` ** gibt einen Satz an Attributen für das Element mit dem gegebenen Primärschlüssel zurück.
+ ** `scan` ** gibt eines oder mehrere Elemente und Elementattribute zurück, indem auf jedes Element in einer Tabelle oder einen sekundären Index zugegriffen wird.
+ ** `query` ** findet Elemente auf der Basis von Primärschlüsselwerten. Sie können jede Tabelle oder jeden sekundären Index, die bzw. der über einen zusammengesetzten Primärschlüssel verfügt, abfragen (einen Partitionsschlüssel und einen Sortierschlüssel).
In diesem Beispiel wird gezeigt, wie Sie die Befehle verwenden können, um das Element mit dem `CityID`-Attributwert `1` und dem `Date`-Attributwert `2017-04-12` abzurufen.
1. Zum Ausführen des DynamoDB-Befehls ** `get-item` ** geben Sie den Namen der Tabelle (`--table-name`), den primären Schlüsselwert (`--key`) und die Attributwerte für das anzuzeigende Element (`--projection-expression`) an. Da `Date` ein reserviertes Schlüsselwort in DynamoDB ist, müssen Sie auch einen Alias für den `Date`-Attributwert angeben (`--expression-attribute-names`). (`State` ist ebenfalls ein reserviertes Schlüsselwort, daher sehen Sie in späteren Schritten auch hier einen Alias dafür).
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }' \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
In diesem und anderen Befehlen fügen Sie zum Anzeigen aller Attribute des Elements `--projection-expression` nicht ein. Da Sie `--projection-expression` in diesem Beispiel nicht einschließen, müssen Sie auch `--expression-attribute-names` nicht einschließen.
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. Zum Ausführen des DynamoDB-Befehls ** `scan` ** geben Sie Folgendes an:
+ Der Name der Tabelle (`--table-name`).
+ Die auszuführende Suche (`--filter-expression`).
+ Die zu verwendenden Suchkriterien (`--expression-attribute-values`).
+ Die Arten von Attributen, die für das übereinstimmende Element angezeigt werden sollen (`--select`).
+ Die Attribute für das anzuzeigende Element (`--projection-expression`).
+ Wenn eines Ihrer Attribute reservierte Schlüsselwörter in DynamoDB verwendet, werden Aliase für diese Attribute angegeben (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
1. Zum Ausführen des DynamoDB-Befehls ** `query` ** geben Sie Folgendes an:
+ Der Name der Tabelle (`--table-name`).
+ Die auszuführende Suche (`--key-condition-expression`).
+ In der Suche zu verwendenden Attributwerte (`--expression-attribute-values`).
+ Die Arten von Attributen, die für das übereinstimmende Element angezeigt werden sollen (`--select`).
+ Die Attribute für das anzuzeigende Element (`--projection-expression`).
+ Wenn eines Ihrer Attribute reservierte Schlüsselwörter in DynamoDB verwendet, werden Aliase für diese Attribute angegeben (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--key-condition-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
Beachten Sie, dass der ** `scan` **-Befehl alle neun Elemente benötigt, um das Ergebnis abzurufen, während der ** `query` **-Befehl nur zum Scannen von einem Element benötigt wird.
### So rufen Sie mehrere Elemente aus einer Tabelle basierend auf den primären Schlüsselwerten des Elements ab
Wenn Sie die Primärschlüssel-Werte des Elements kennen, können Sie entsprechende Elemente abrufen, indem Sie den DynamoDB-Befehl ** `batch-get-item` ** ausführen. In diesem Beispiel wird gezeigt, wie Sie die Befehle abrufen können, die den `CityID`-Attributwert `3` und `Date`-Attributwert `2017-04-13` oder `2017-04-14` enthalten können.
Führen Sie den DynamoDB-Befehl ** `batch-get-item` ** aus, indem Sie den Pfad zu einer Datei mit der Beschreibung des abzurufenden Elements (`--request-items`) angeben.
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
Für dieses Beispiel gibt der Code in der `batch-get-item.json`-Datei an, in der `Weather`-Tabelle nach Elemente mit einer `CityID` von `3` und einem `Date` von `2017-04-13` oder `2017-04-14` zu suchen. Für jedes gefundene Element werden die Attributwerte für `City`, `State`, `Date` und `HighF` (Teil von `Temperatures`) angezeigt, wenn sie vorhanden sind.
```
{
"Weather" : {
"Keys": [
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" }
},
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" }
}
],
"ProjectionExpression": "City, #S, #D, Temperatures.HighF",
"ExpressionAttributeNames": { "#S": "State", "#D": "Date" }
}
}
```
### So rufen Sie alle übereinstimmenden Elemente aus einer Tabelle ab
Wenn Sie etwas über die Werte der Elemente in der Tabelle wissen, können Sie entsprechende Elemente abrufen, indem Sie den DynamoDB-Befehl ** `scan` ** ausführen. In diesem Beispiel wird gezeigt, wie Sie die Daten abrufen können, wenn der `Conditions`-Attributwert `Sunny` enthält und der `HighF`-Attributwert (Teil von `Temperatures`) größer als `53` ist.
Führen Sie den DynamoDB-Befehl** `scan` ** aus und geben Sie Folgendes an:
+ Der Name der Tabelle (`--table-name`).
+ Die auszuführende Suche (`--filter-expression`).
+ Die zu verwendenden Suchkriterien (`--expression-attribute-values`).
+ Die Arten von Attributen, die für das übereinstimmende Element angezeigt werden sollen (`--select`).
+ Die Attribute für das anzuzeigende Element (`--projection-expression`).
+ Wenn eines Ihrer Attribute reservierte Schlüsselwörter in DynamoDB verwendet, werden Aliase für diese Attribute angegeben (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression \
"(contains (Conditions, :sun)) and (Temperatures.HighF > :h)" \
--expression-attribute-values \
'{ ":sun": { "S" : "Sunny" }, ":h": { "N" : "53" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
### So rufen Sie alle übereinstimmenden Elemente aus einem globalen sekundären Index ab
Um mit einem globalen sekundären Index zu suchen, verwenden Sie die DynamoDB-Befehl ** `query` **. In diesem Beispiel wird gezeigt, wie Sie den sekundären Index `weather-global-index` verwenden, um die Vorhersagebedingungen für Städte mit dem Namen `Portland` für die Daten `2017-04-13` und `2017-04-14` zu erhalten.
Führen Sie den DynamoDB-Befehl** `query` ** aus und geben Sie Folgendes an:
+ Der Name der Tabelle (`--table-name`).
+ Den Namen des globalen sekundären Indexes (`--index-name`).
+ Die auszuführende Suche (`--key-condition-expression`).
+ In der Suche zu verwendenden Attributwerte (`--expression-attribute-values`).
+ Die Arten von Attributen, die für das übereinstimmende Element angezeigt werden sollen (`--select`).
+ Wenn eines Ihrer Attribute reservierte Schlüsselwörter in DynamoDB verwendet, werden Aliase für diese Attribute angegeben (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--index-name weather-global-index \
--key-condition-expression "(City = :city) and (#D between :date1 and :date2)" \
--expression-attribute-values \
'{ ":city": { "S" : "Portland" }, ":date1": { "S": "2017-04-13" }, ":date2": { "S": "2017-04-14" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
## Schritt 7: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie die Tabelle löschen. Durch das Löschen der Tabelle wird auch der globale sekundäre Index gelöscht. Sie sollten Ihre Umgebung ebenfalls löschen.
Um die Tabelle zu löschen, führen Sie den DynamoDB-Befehl ** `delete-table` ** aus, wobei Sie den Namen der Tabelle angeben (`--table-name`).
```
aws dynamodb delete-table --table-name Weather
```
Wenn der Befehl erfolgreich ist, werden Informationen über die Tabelle angezeigt, einschließlich des `TableStatus`-Werts von `DELETING`.
Um zu bestätigen, dass die Tabelle erfolgreich gelöscht wurde, führen Sie den DynamoDB-Befehl ** `describe-table` ** aus, wobei Sie den Namen der Tabelle angeben (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Wenn die Tabelle erfolgreich gelöscht wurde, wird eine Meldung mit dem Satz `Requested resource not found` angezeigt.
Weitere Informationen zum Löschen Ihrer Umgebung finden Sie unter [Löschen einer Umgebung](delete-environment.md).
# AWS CDK Tutorial für AWS Cloud9
Dieses Tutorial zeigt Ihnen, wie Sie mit dem AWS Cloud Development Kit (AWS CDK) in einer AWS Cloud9 Entwicklungsumgebung arbeiten. Dabei AWS CDK handelt es sich um eine Reihe von Softwaretools und Bibliotheken, mit denen Entwickler AWS Infrastrukturkomponenten als Code modellieren können.
AWS CDK Dazu gehört die AWS Construct-Bibliothek, mit der Sie viele Aufgaben schnell lösen können AWS. Sie können beispielsweise das Konstrukt `Fleet` verwenden, um Code vollständig und sicher auf einer Flotte von Hosts bereitzustellen. Sie können Ihre eigenen Konstrukte erstellen, um verschiedene Elemente Ihrer Architekturen zu modellieren, sie mit anderen zu teilen oder sie in der Community zu veröffentlichen. Weitere Informationen finden Sie im [AWS Cloud Development Kit Entwicklerhandbuch](https://docs.aws.amazon.com/cdk/v2/guide/home.html).
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies zu Gebühren für Ihr AWS Konto führen. Dies umfasst mögliche Kosten für Services wie Amazon EC2, Amazon SNS und Amazon SQS. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/), [Amazon SNS – Preise](https://aws.amazon.com/sns/pricing/) und [Amazon SQS – Preise](https://aws.amazon.com/sqs/pricing/).
**Topics**
+ [Voraussetzungen](#sample-cdk-prereqs)
+ [Schritt 1: Installieren der erforderlichen Tools](#sample-cdk-install)
+ [Schritt 2: Code hinzufügen](#sample-cdk-code)
+ [Schritt 3: Führen Sie den Code aus](#sample-cdk-run)
+ [Schritt 4: Bereinigen](#sample-cdk-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren der erforderlichen Tools
In diesem Schritt installieren Sie alle Tools in Ihrer Umgebung, die für die Ausführung eines in der TypeScript Programmiersprache geschriebenen Beispiels AWS CDK erforderlich sind.
1. [Node Version Manager](#sample-cdk-install-nvm) oder ** `nvm` **, mit dem Sie Node.js später installieren können.
1. [Node.js](#sample-cdk-install-nodejs), das für das Beispiel erforderlich ist und Node Package Manager enthält, oder **`npm`**, das Sie für die Installation TypeScript und AWS CDK später verwenden.
1. [TypeScript](#sample-cdk-install-typescript), das für dieses Beispiel erforderlich ist. (Das bietet AWS CDK auch Unterstützung für mehrere andere Programmiersprachen.)
1. Die[AWS CDK](#sample-cdk-install-cdk)aus.
### Schritt 1.1: Node Version Manager installieren (nvm)
1. Stellen Sie in einer Terminalsitzung in der AWS Cloud9 IDE sicher, dass die neuesten Sicherheitsupdates und Bugfixes installiert sind. Um dies zu tun, führen Sie den Befehl ** `yum update` ** (für Amazon Linux) oder ** `apt update` ** (für Ubuntu Server) aus. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus.
Für Amazon Linux:
```
sudo yum -y update
```
Für Ubuntu Server:
```
sudo apt update
```
1. Prüfen Sie, ob ** `nvm` ** bereits installiert ist. Führen Sie zu diesem Zweck den Befehl ** `nvm` ** mit der Option ** `--version` ** aus.
```
nvm --version
```
Ist der Befehl erfolgreich, enthält die Ausgabe die ** `nvm` **-Versionsnummer, und Sie können zur [Schritt 1.2: Installieren von Node.js](#sample-cdk-install-nodejs) springen.
1. Laden Sie ** `nvm` ** herunter und installieren Sie es. Führen Sie dazu das Installationsskript aus. In diesem Beispiel ist v0.33.0 installiert, Sie können jedoch nach der neuesten Version von** `nvm` ** [Hier gilt:](https://github.com/nvm-sh/nvm#installing-and-updating)aus.
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Beginnen Sie mit der Nutzung von ** `nvm` **. Sie können die Terminalsitzung entweder schließen und dann neu starten oder die Datei `~/.bashrc` auslesen, die die Befehle zum Laden von ** `nvm` ** enthält.
```
. ~/.bashrc
```
### Schritt 1.2: Installieren von Node.js
1. Überprüfen Sie, ob Sie Node.js bereits installiert haben, und wenn ja, ob die installierte Version 16.17.0 oder höher ist. **Dieses Beispiel wurde mit Node.js 16.17.0 getestet.** Um zu überprüfen, ob die Terminalsitzung in der IDE noch geöffnet ist, führen Sie den Befehl ** `node` ** mit der Option ** `--version` ** aus.
```
node --version
```
Wenn Sie Node.js installiert haben, enthält die Ausgabe die Versionsnummer. Wenn die Versionsnummer v16.17.0 ist, fahren Sie mit [Schritt 1.3: Installieren TypeScript](#sample-cdk-install-typescript) fort.
1. Installieren Sie Node.js 16, indem Sie den **`nvm`**Befehl mit der **`install`**Aktion ausführen.
**Anmerkung**
Sie können auch die LTS-Version (Long-Term Support) von Node.js ausführen, **`nvm install node`**um sie zu installieren. AWS Cloud9 Support verfolgt die LTS-Version von Node.js.
```
nvm install v16
```
1. Fangen Sie an, Node.js 16 zu verwenden. Führen Sie dazu den Befehl ** `nvm` ** mit der Aktion ** `alias` **, der Versionsnummer des Alias und der Version, die für diesen Alias verwendet werden soll, wie folgt aus.
```
nvm alias default 16
```
**Anmerkung**
Mit dem vorherigen Befehl wird Node.js 16 als Standardversion von Node.js festgelegt. Alternativ können Sie den Befehl **`nvm`** zusammen mit der Aktion **`use`** anstelle der Aktion **`alias`** ausführen (z.°B. **`nvm use 16.17.0`**). Die Aktion ** `use` ** bewirkt jedoch, dass diese Version von Node.js nur ausgeführt wird, während die aktuelle Terminalsitzung läuft.
1. Um zu bestätigen, dass Sie Node.js 16 verwenden, führen Sie den **`node --version`**Befehl erneut aus. Wenn die richtige Version installiert ist, enthält die Ausgabe Version v16.
### Schritt 1.3: Installieren TypeScript
1. Bestätigen Sie, ob Sie es bereits TypeScript installiert haben. Führen Sie dazu den TypeScript Befehlszeilen-Compiler mit der **`--version`**Option aus, während die Terminalsitzung noch in der IDE geöffnet ist.
```
tsc --version
```
Wenn Sie es TypeScript installiert haben, enthält die Ausgabe die TypeScript Versionsnummer. Falls installiert TypeScript ist, fahren Sie mit fort[Schritt 1.4: Installieren Sie das AWS CDK](#sample-cdk-install-cdk).
1. Installieren TypeScript. Führen Sie dazu den **`npm`**Befehl mit der **`install`**Aktion, der **`-g`**Option und dem Namen des TypeScript Pakets aus. Dies wird TypeScript als globales Paket in der Umgebung installiert.
```
npm install -g typescript
```
1. Vergewissern Sie sich, dass TypeScript es installiert ist. Führen Sie dazu den TypeScript Befehlszeilen-Compiler mit der **`--version`**Option aus.
```
tsc --version
```
Wenn installiert TypeScript ist, enthält die Ausgabe die TypeScript Versionsnummer.
### Schritt 1.4: Installieren Sie das AWS CDK
1. Bestätigen Sie, ob Sie das bereits AWS CDK installiert haben. Führen Sie dazu, wenn die Terminalsession in der IDE noch geöffnet ist, den Befehl ** `cdk` ** mit der Option** `--version` ** aus.
```
cdk --version
```
Wenn das installiert AWS CDK ist, enthält die Ausgabe die AWS CDK Versions- und Buildnummern. Fahren Sie mit [Schritt 2: Code hinzufügen](#sample-cdk-code) fort.
1. Installieren Sie das, AWS CDK indem Sie den **`npm`**Befehl zusammen mit der `install` Aktion, dem Namen des zu installierenden AWS CDK Pakets und der `-g` Option zur globalen Installation des Pakets in der Umgebung ausführen.
```
npm install -g aws-cdk
```
1. Vergewissern Sie sich, dass das installiert AWS CDK ist und korrekt referenziert wurde. Führen Sie zu diesem Zweck den Befehl ** `cdk` ** mit der Option ** `--version` ** aus.
```
cdk --version
```
Bei Erfolg werden die AWS CDK Versions- und Buildnummern angezeigt.
## Schritt 2: Code hinzufügen
In diesem Schritt erstellen Sie ein TypeScript Beispielprojekt, das den gesamten Quellcode enthält, den Sie für die AWS CDK programmgesteuerte Bereitstellung eines AWS CloudFormation Stacks benötigen. Dieser Stapel erstellt ein Amazon SNS SNS-Thema und eine Amazon SQS SQS-Warteschlange in Ihrem AWS Konto und abonniert dann die Warteschlange für das Thema.
1. Erstellen Sie mit geöffneter Terminalsitzung in der IDE ein Verzeichnis, in dem der Quellcode des Projekts gespeichert wird, z. B. ein Verzeichnis `~/environment/hello-cdk` in Ihrer Umgebung. Wechseln Sie dann in dieses Verzeichnis.
```
rm -rf ~/environment/hello-cdk # Remove this directory if it already exists.
mkdir ~/environment/hello-cdk # Create the directory.
cd ~/environment/hello-cdk # Switch to the directory.
```
1. Richten Sie das Verzeichnis als TypeScript Sprachprojekt für das ein. AWS CDK Führen Sie dazu den Befehl ** `cdk` ** mit der Aktion ** `init` **, der Vorlage ** `sample-app` ** und der Option ** `--language` ** zusammen mit dem Namen der Programmiersprache aus.
```
cdk init sample-app --language typescript
```
Dadurch werden die folgenden Dateien und Unterverzeichnisse im Verzeichnis erstellt.
+ Ein verborgenes Unterverzeichnis `.git` und eine verborgene Datei `.gitignore`, die das Projekt kompatibel mit Quellcode-Tools wie Git machen.
+ Ein Unterverzeichnis `lib`, das eine Datei `hello-cdk-stack.ts` enthält. Diese Datei enthält den Code für Ihren AWS CDK Stack. Dieser Code wird im nächsten Schritt beschrieben.
+ Ein Unterverzeichnis `bin`, das eine Datei `hello-cdk.ts` enthält. Diese Datei enthält den Einstiegspunkt für Ihre AWS CDK App.
+ Ein Unterverzeichnis `node_modules`, das unterstützende Codepakete enthält, die die App und der Stack bei Bedarf verwenden können.
+ Eine versteckte Datei `.npmignore`, die die Arten von Unterverzeichnissen und Dateien auflistet, die ** `npm` ** nicht benötigt, wenn es den Code erstellt.
+ Eine Datei `cdk.json`, die Informationen enthält, um die Ausführung des Befehls ** `cdk` ** zu erleichtern.
+ Eine Datei `package-lock.json`, die Informationen enthält, die ** `npm` ** verwenden kann, um mögliche Build und Run Error zu reduzieren.
+ Eine Datei `package.json`, die Informationen enthält, um die Ausführung des ** `npm` **-Befehls zu vereinfachen und mit möglicherweise weniger Build und Run Errors.
+ Eine `README.md` Datei, die nützliche Befehle auflistet, mit denen Sie sie ausführen können, **`npm`**und die AWS CDK.
+ Eine Datei `tsconfig.json`, die Informationen enthält, um die Ausführung des ** `tsc` **-Befehls zu vereinfachen und mit möglicherweise weniger Build und Run Errors.
1. Öffnen Sie im Fenster **Environment (Umgebung)** die Datei `lib/hello-cdk-stack.ts` und durchsuchen Sie den folgenden Code in dieser Datei.
```
import sns = require('@aws-cdk/aws-sns');
import sqs = require('@aws-cdk/aws-sqs');
import cdk = require('@aws-cdk/cdk');
export class HelloCdkStack extends cdk.Stack {
constructor(parent: cdk.App, name: string, props?: cdk.StackProps) {
super(parent, name, props);
const queue = new sqs.Queue(this, 'HelloCdkQueue', {
visibilityTimeoutSec: 300
});
const topic = new sns.Topic(this, 'HelloCdkTopic');
topic.subscribeQueue(queue);
}
}
```
+ Die `Topic` Klassen`Stack`, `App` `StackProps``Queue`, und stehen jeweils für einen CloudFormation Stack und seine Eigenschaften, ein ausführbares Programm, eine Amazon SQS SQS-Warteschlange und ein Amazon SNS SNS-Thema.
+ Die `HelloCdkStack` Klasse stellt den CloudFormation Stack für diese Anwendung dar. Dieser Stack enthält die neue Amazon-SQS-Warteschlange und das Amazon-SNS-Thema für diese Anwendung.
1. Öffnen Sie im Fenster **Environment (Umgebung)** die Datei `bin/hello-cdk.ts` und durchsuchen Sie den folgenden Code in dieser Datei.
```
#!/usr/bin/env node
import cdk = require('@aws-cdk/cdk');
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack');
app.run();
```
Dieser Code lädt die Klasse `HelloCdkStack` aus der Datei `lib/hello-cdk-stack.ts`, instanziiert sie und führt sie aus.
1. Wird verwendet **`npm`**, um den TypeScript Compiler auszuführen, um nach Codierungsfehlern zu suchen, und um dann den AWS CDK zu aktivieren, um die `bin/hello-cdk.js` Projektdatei auszuführen. Führen Sie dazu aus dem Stammverzeichnis des Projekts den Befehl ** `npm` ** mit der Aktion ** `run` ** aus, indem Sie den Wert des Befehls ** `build` ** in der Datei `package.json` wie folgt angeben.
```
npm run build
```
Mit dem vorherigen Befehl wird der TypeScript Compiler ausgeführt, der unterstützende Dateien `bin/hello-cdk.d.ts` und `lib/hello-cdk-stack.d.ts` Dateien hinzufügt. Die Compiler transpiliert außerdem die Dateien `hello-cdk.ts` und `hello-cdk-stack.ts` in die Dateien `hello-cdk.js` und `hello-cdk-stack.js`.
## Schritt 3: Führen Sie den Code aus
In diesem Schritt weisen Sie die an, eine CloudFormation Stack-Vorlage auf der Grundlage des Codes in der `bin/hello-cdk.js` Datei AWS CDK zu erstellen. Anschließend weisen Sie die AWS CDK an, den Stack bereitzustellen, der das Amazon SNS SNS-Thema und die Amazon SQS SQS-Warteschlange erstellt und dann die Warteschlange für das Thema abonniert. Sie bestätigen dann, dass das Thema und die Warteschlange erfolgreich bereitgestellt wurden, indem Sie eine Nachricht vom Thema an die Warteschlange senden.
1. Lassen Sie sie die Stack-Vorlage AWS CDK erstellen. CloudFormation Wenn die Terminalsitzung noch in der IDE geöffnet ist, führen Sie aus dem Stammverzeichnis des Projekts den Befehl ** `cdk` ** mit der Aktion ** `synth` ** und dem Namen des Stacks aus.
```
cdk synth HelloCdkStack
```
Bei Erfolg wird in der Ausgabe der `Resources` Abschnitt der CloudFormation Stack-Vorlage angezeigt.
1. Wenn Sie eine AWS CDK App zum ersten Mal in einer Umgebung für eine bestimmte Kombination aus AWS Konto und AWS Region bereitstellen, müssen Sie einen *Bootstrap-Stack* installieren. Dieser Stack enthält verschiedene Ressourcen, die er AWS CDK benötigt, um die verschiedenen Operationen abzuschließen. Dieser Stack umfasst beispielsweise einen Amazon S3 S3-Bucket, in AWS CDK dem Vorlagen und Ressourcen während der Bereitstellungsprozesse gespeichert werden. Um den Bootstrap-Stack zu installieren, führen Sie den Befehl ** `cdk` ** mit der Aktion ** `bootstrap` ** aus.
```
cdk bootstrap
```
**Anmerkung**
Wenn Sie `cdk bootstrap` ohne Angabe von Optionen ausführen, werden das AWS Standardkonto und die AWS Region verwendet. Sie können auch ein Bootstrapping für eine bestimmte Umgebung durchführen, indem Sie ein Profil und eine account/Region Kombination angeben. Beispiel:
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. Lassen Sie sie die CloudFormation Stack-Vorlage AWS CDK ausführen, um den Stack bereitzustellen. Führen Sie dazu aus dem Stammverzeichnis des Projekts den Befehl ** `cdk` ** mit der Aktion ** `deploy` ** und dem Namen des Stacks aus.
```
cdk deploy HelloCdkStack
```
Bei Erfolg zeigt die Ausgabe an, dass der `HelloCdkStack`-Stack fehlerfrei bereitgestellt wurde.
**Anmerkung**
Wenn in der Ausgabe eine Meldung angezeigt wird, dass der Stack keine Umgebung definiert und dass AWS Anmeldeinformationen nicht von Standardspeicherorten abgerufen werden konnten oder keine Region konfiguriert wurde, stellen Sie sicher, dass Ihre AWS Anmeldeinformationen in der IDE korrekt festgelegt sind, und führen Sie den **`cdk deploy`**Befehl dann erneut aus. Weitere Informationen finden Sie unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md).
1. Um zu bestätigen, dass das Amazon-SNS-Thema und die Amazon-SQS-Warteschlange erfolgreich bereitgestellt wurden, senden Sie eine Nachricht an das Thema und überprüfen Sie dann die Warteschlange auf die empfangene Nachricht. Dazu können Sie ein Tool wie das AWS Command Line Interface (AWS CLI) oder das verwenden AWS CloudShell. Weitere Informationen zu diesen Tools finden Sie unter [AWS CLI und AWS-Shell-Tutorial für AWS Cloud9](sample-aws-cli.md).
Um beispielsweise eine Nachricht an das Thema zu senden, während die Terminalsitzung noch in der IDE geöffnet ist, verwenden Sie den, AWS CLI um den Amazon SNS **`publish`**SNS-Befehl auszuführen und dabei den Betreff und den Hauptteil der Nachricht, die AWS Region für das Thema und den Amazon-Ressourcennamen (ARN) des Themas anzugeben.
```
aws sns publish --subject "Hello from the AWS CDK" --message "This is a message from the AWS CDK." --topic-arn arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K
```
Ersetzen Sie im vorherigen Befehl durch den `arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K` ARN, der dem Thema CloudFormation zugewiesen ist. Um die ID zu erhalten, können Sie den Befehl Amazon SNS ** `list-topics` ** ausführen.
```
aws sns list-topics --output table --query 'Topics[*].TopicArn'
```
Wenn erfolgreich, zeigt die Ausgabe des Befehls ** `publish` ** den Wert `MessageId` für die veröffentlichte Nachricht an.
Um die Warteschlange für die empfangene Nachricht zu überprüfen, führen Sie den Befehl Amazon SQS** `receive-message` ** aus und geben Sie die URL der Warteschlange an.
```
aws sqs receive-message --queue-url https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K
```
Ersetzen Sie im vorherigen Befehl durch den `https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K` ARN, der der Warteschlange CloudFormation zugewiesen ist. Um die URL zu erhalten, können Sie den Befehl Amazon SQS** `list-queues` ** ausführen.
```
aws sqs list-queues --output table --query 'QueueUrls[*]'
```
Wenn erfolgreich, zeigt die Ausgabe des Befehls ** `receive-message` ** Informationen über die empfangene Nachricht an.
## Schritt 4: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie den CloudFormation Stapel löschen. Dadurch werden das Amazon-SNS-Thema und die Amazon SQS Warteschlange gelöscht. Sie sollten die Umgebung ebenfalls löschen.
### Schritt 4.1: Löschen des Stacks
Wenn die Terminalsitzung noch in der IDE geöffnet ist, führen Sie aus dem Stammverzeichnis des Projekts den Befehl ** `cdk` ** mit der Aktion ** `destroy` ** und dem Namen des Stacks aus.
```
cdk destroy HelloCdkStack
```
Wenn Sie aufgefordert werden, den Stapel zu löschen, geben Sie `y` ein, und drücken Sie dann die Eingabetaste `Enter`.
Bei Erfolg zeigt die Ausgabe an, dass der `HelloCdkStack`-Stack fehlerfrei gelöscht wurde.
### Schritt 4.2: Löschen der Umgebung
Informationen zum Löschen der Umgebung finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# LAMP-Tutorial für AWS Cloud9
Dieses Tutorial ermöglicht Ihnen die Einrichtung und Ausführung LAMP (Linux, Apache HTTP-Server, MySQL, und PHP) innerhalb einer AWS Cloud9 Entwicklungsumgebung.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, können Gebühren für Sie anfallen AWS-Konto. Dazu gehören mögliche Gebühren für AWS-Services beispielsweise Amazon Elastic Compute Cloud (Amazon EC2). Weitere Informationen finden Sie unter [ EC2 Amazon-Preise](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Voraussetzungen](#sample-lamp-prereqs)
+ [Schritt 1: Installieren der Tools](#sample-lamp-install-tools)
+ [Schritt 2: Einrichten MySQL](#sample-lamp-setup-mysql)
+ [Schritt 3: Einrichten einer Website](#sample-lamp-apache)
+ [Schritt 4: Bereinigen](#sample-lamp-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2 Entwicklungsumgebung verfügen.** In diesem Beispiel wird davon ausgegangen, dass Sie bereits über eine EC2 Umgebung verfügen, die mit einer EC2 Amazon-Instance verbunden ist, auf der Amazon Linux ausgeführt wird, oder Ubuntu Server. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren der Tools
In diesem Schritt installieren Sie folgende Tools:
+ Apache HTTP-Server, ein Webserver-Host.
+ PHP, eine Skriptsprache, die speziell für die Web-Entwicklung geeignet ist und in HTML eingebettet werden kann.
+ MySQL, ein Datenbankmanagementsystem.
Anschließend beenden Sie diesen Schritt, indem Sie beginnen Apache HTTP-Server und dann MySQL.
1. Stellen Sie sicher, dass die Sicherheitsupdates und Fehlerbehebungen in der Instance auf dem aktuellen Stand sind. Führen Sie dazu in einer Terminalsitzung in der AWS Cloud9 IDE den Befehl **`yum update`**for (Amazon Linux) oder **`apt update`**for (Ubuntu Befehl (Server). (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus.
Für Amazon Linux:
```
sudo yum -y update
```
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server:
```
sudo apt -y update
```
1. Prüfen Sie, ob Apache Der HTTP-Server ist bereits installiert. Führen Sie dazu den Befehl **`httpd -v`**(für Amazon Linux) oder **`apache2 -v`**(für Ubuntu Befehl (Server).
Bei Erfolg enthält die Ausgabe den Apache Versionsnummer des HTTP-Servers.
Wenn Sie einen Fehler sehen, installieren Sie Apache HTTP-Server, indem **`install`**Sie den Befehl ausführen.
Für Amazon Linux:
```
sudo yum install -y httpd24
```
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server:
```
sudo apt install -y apache2
```
1. Bestätigen Sie, ob PHP ist bereits installiert, indem Sie den **`php -v`**Befehl ausführen.
Bei Erfolg enthält die Ausgabe die PHP-Versionsnummer.
Wenn Sie einen Fehler sehen, installieren Sie PHP, indem Sie den Befehl **`install`** ausführen.
Für Amazon Linux:
```
sudo yum install -y php56
```
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server:
```
sudo apt install -y php libapache2-mod-php php-xml
```
1. Bestätigen Sie, ob MySQL ist bereits installiert, indem Sie den **`mysql --version`**Befehl ausführen.
Bei Erfolg enthält die Ausgabe den MySQL Versionsnummer.
Wenn Sie einen Fehler sehen, installieren Sie MySQL indem Sie den **`install`**Befehl ausführen.
Für Amazon Linux:
```
sudo yum install -y mysql-server
```
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server:
```
sudo apt install -y mysql-server
```
1. Nach der Installation Apache HTTP-Server, PHP, und MySQL, starten Apache HTTP-Server, und bestätigen Sie dann, dass er gestartet wurde, indem Sie den folgenden Befehl ausführen.
Für Amazon Linux (diesen Befehl müssen Sie möglicherweise zweimal ausführen):
```
sudo service httpd start && sudo service httpd status
```
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server (um zur Eingabeaufforderung zurückzukehren, drücken Sie`q`):
```
sudo service apache2 start && sudo service apache2 status
```
1. Starten MySQL, und bestätigen Sie dann, dass es gestartet wurde, indem Sie den folgenden Befehl ausführen.
Für Amazon Linux:
```
sudo service mysqld start && sudo service mysqld status
```
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server (um zur Befehlszeile zurückzukehren, drücken Sie`q`):
```
sudo service mysql start && sudo service mysql status
```
## Schritt 2: Einrichten MySQL
In diesem Schritt richten Sie ein MySQL zu folgen MySQL Bewährte Methoden im Bereich Sicherheit. Zu diesen bewährten Sicherheitsmethoden gehören das Festlegen eines Passworts für Root-Konten und das Entfernen von Root-Konten, auf die von außerhalb des lokalen Hosts zugegriffen werden kann. Weitere bewährte Methoden, die Sie beachten sollten, sind das Entfernen anonymer Benutzer, das Entfernen der Testdatenbank und das Entfernen von Rechten, die es jedem ermöglichen, auf Datenbanken zuzugreifen, deren Namen mit `test_` beginnen.
Anschließend beenden Sie diesen Schritt, indem Sie das Starten und Beenden von üben MySQL Befehlszeilen-Client.
1. Implementieren MySQL Bewährte Sicherheitsmethoden für MySQL Installation durch Ausführen des folgenden Befehls in einer Terminalsitzung in der AWS Cloud9 IDE.
```
sudo mysql_secure_installation
```
1. Beantworten Sie die folgenden Fragen wie angegeben, wenn Sie dazu aufgefordert werden.
Für Amazon Linux:
1. **Enter current password for root (enter for none) (Geben Sie das aktuelle Stamm-Passwort ein (Eingabetaste, wenn keines vorhanden))** – Geben Sie `Enter` ein (wenn kein Passwort vorhanden).
1. **Set root password (Passwort für Stamm festlegen)** – Geben Sie `Y` ein und drücken Sie dann `Enter`.
1. **New password (Neues Passwort)** – Geben Sie ein Passwort ein und drücken Sie dann `Enter`.
1. **Re-enter new password (Passwort nochmals eingeben)** – Geben Sie das Passwort erneut ein und drücken Sie dann `Enter`. (Vergewissern Sie sich, das Passwort für die spätere Nutzung an einem sicheren Ort zu speichern.)
1. **Remove anonymous user (Anonyme Benutzer entfernen)** – Geben Sie `Y` ein und drücken Sie anschließend `Enter`.
1. **Disallow root login remotely (Fernzugriff auf Stamm verweigern)** – Geben Sie `Y` ein und drücken Sie dann `Enter`.
1. **Remove test database and access to it (Testdatenbank und Zugriff darauf entfernen)** – Geben Sie `Y` ein und drücken Sie dann `Enter`.
1. **Reload privilege tables now (Berechtigungstabelle jetzt neu laden)** – Geben Sie `Y` ein und drücken Sie dann `Enter`.
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server:
1. **Would you like to setup VALIDATE PASSWORD plugin** (Möchten Sie das Plug-in VALIDATE PASSWORD einrichten) – Geben Sie `y` ein und drücken Sie dann `Enter`.
1. **There are three levels of password validation policy** (Die Richtlinie für die Passwortvalidierung umfasst drei Stufen) – Geben Sie `0`, `1` oder `2` ein und drücken Sie dann `Enter`.
1. **New password** (Neues Passwort) – Geben Sie ein Passwort ein und drücken Sie dann `Enter`.
1. **Re-enter new password** (Passwort nochmals eingeben) – Geben Sie das Passwort erneut ein und drücken Sie dann `Enter`. Speichern Sie das Passwort für die spätere Nutzung unbedingt an einem sicheren Ort.
1. **Do you wish to continue with the password provided** (Möchten Sie mit dem bereitgestellten Passwort fortfahren) – Geben Sie `y` ein und drücken Sie dann `Enter`.
1. **Remove anonymous user** (Anonyme Benutzer entfernen) – Geben Sie `y` ein und drücken Sie anschließend `Enter`.
1. **Disallow root login remotely** (Fernzugriff auf Stamm verweigern) – Geben Sie `y` ein und drücken Sie dann `Enter`.
1. **Remove test database and access to it** (Testdatenbank und Zugriff darauf entfernen) – Geben Sie `y` ein und drücken Sie dann `Enter`.
1. **Reload privilege tables now** (Berechtigungstabelle jetzt neu laden) – Geben Sie `y` ein und drücken Sie dann `Enter`.
1. Um direkt zu interagieren mit MySQL, starte den MySQL Befehlszeilenclient als Root-Benutzer, indem Sie den folgenden Befehl ausführen. Geben Sie auf Aufforderung das Stammbenutzerpasswort ein, das Sie zuvor festgelegt haben und drücken Sie dann `Enter`. Die Eingabeaufforderung ändert sich zu, `mysql>` während Sie sich im MySQL Befehlszeilen-Client.
```
sudo mysql -uroot -p
```
1. Um das zu beenden MySQL Führen Sie den folgenden Befehl vom Befehlszeilen-Client aus. Die Eingabeaufforderung ändert sich wieder in `$`.
```
exit;
```
## Schritt 3: Einrichten einer Website
In diesem Schritt richten Sie das Standard-Stammverzeichnis der Website ein Apache HTTP-Server mit empfohlenen Besitzern und Zugriffsberechtigungen. Anschließend erstellen Sie eine PHPbasierte Webseite innerhalb dieses Standard-Stammverzeichnisses der Website.
Anschließend ermöglichen Sie eingehenden Web-Traffic, um diese Webseite anzusehen, indem Sie die Sicherheitsgruppe in Amazon EC2 und die Network Access Control List (Network ACL) in Amazon Virtual Private Cloud (Amazon VPC) einrichten, die mit dieser EC2 Umgebung verknüpft sind. Jede EC2 Umgebung muss sowohl einer Sicherheitsgruppe in Amazon EC2 als auch einer Netzwerk-ACL in Amazon VPC zugeordnet sein. Während die Standard-Netzwerk-ACL in einem AWS-Konto jedoch den gesamten eingehenden und ausgehenden Datenverkehr für die Umgebung zulässt, erlaubt die Standard-Sicherheitsgruppe nur eingehenden Datenverkehr unter Verwendung von SSH über Port 22. Weitere Informationen finden Sie unter [VPC-Einstellungen für AWS Cloud9 Entwicklungsumgebungen](vpc-settings.md).
Anschließend schließen Sie diesen Schritt ab, indem Sie die Webseite erfolgreich außerhalb der AWS Cloud9 IDE anzeigen lassen.
1. Richten Sie das Standard-Website-Stammverzeichnis für die ein Apache HTTP-Server (`/var/www/html`) mit empfohlenen Besitzern und Zugriffsberechtigungen. Führen Sie dazu die folgenden sechs Befehle nacheinander in der folgenden Reihenfolge in einer Terminalsitzung in der AWS Cloud9 IDE aus. Informationen dazu, was die einzelnen Befehle auslösen, finden Sie in der Erklärung hinter dem `#`-Zeichen hinter jedem Befehl.
Für Amazon Linux:
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ec2-user # Add the user ec2-user (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a apache # Add the user apache (Apache HTTP Server) to the group web-content.
sudo chown -R ec2-user:web-content /var/www/html # Change the owner of /var/www/html and its files to user ec2-user and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server:
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ubuntu # Add the user ubuntu (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a www-data # Add the user www-data (Apache HTTP Server) to the group web-content.
sudo chown -R ubuntu:web-content /var/www/html # Change the owner of /var/www/html and its files to user ubuntu and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
1. Erstellen Sie ein PHPbasierte Webseite, benannt `index.php` im Standard-Stammordner der Website für Apache HTTP-Server (das ist`/var/www/html`), indem Sie den folgenden Befehl ausführen.
Für Amazon Linux:
```
sudo touch /var/www/html/index.php && sudo chown -R ec2-user:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
Der obige Befehl für Amazon Linux ändert auch den Eigentümer der Datei in`ec2-user`, ändert die Gruppe der Datei in und ändert die Dateiberechtigungen read/write for the user, and read/execute für die Gruppe und andere. `web-content`
Wählen Sie in der &Snowconsole; Ihren Auftrag aus der Tabelle. Ubuntu Server:
```
sudo touch /var/www/html/index.php && sudo chown -R ubuntu:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
Der vorhergehende Befehl für Ubuntu Der Server ändert außerdem den Besitzer der Datei in`ubuntu`, ändert die Gruppe der Datei in und ändert die Dateiberechtigungen read/write for the user, and read/execute für die Gruppe und andere. `web-content`
Ist der Vorgang erfolgreich, wird durch den oben genannten Befehl die Datei `index.php` mit den folgenden Inhalten erstellt:
```
```
1. Aktivieren Sie eingehenden Webverkehr über Port 80, um die neue Webseite anzuzeigen, indem Sie die Netzwerk-ACL in Amazon VPC und der Sicherheitsgruppe Amazon einrichten EC2 , die dieser EC2 Umgebung zugeordnet ist. Führen Sie dazu die folgenden acht Befehle nacheinander in der angegebenen Reihenfolge aus: Informationen dazu, was die einzelnen Befehle auslösen, finden Sie in der Erklärung hinter dem `#`-Zeichen für jeden Befehl.
**Wichtig**
Durch Ausführen der folgenden Befehle wird eingehender Webdatenverkehr über Port 80 für **alle** EC2 Umgebungen und EC2 Amazon-Instances aktiviert, die der Sicherheitsgruppe und der Netzwerk-ACL für diese Umgebung zugeordnet sind. Dies kann dazu führen, dass unerwartet eingehender Webdatenverkehr über Port 80 für andere EC2 Umgebungen und EC2 Amazon-Instances als diese aktiviert wird.
**Anmerkung**
Mit den Befehlen zwei bis vier wird die Sicherheitsgruppe aktiviert, um eingehenden Web-Datenverkehr über Port 80 zu aktivieren. Wenn Sie über eine Standard-Sicherheitsgruppe verfügen, die ausschließlich eingehenden SSH-Datenverkehr über Port 22 zulässt, müssen Sie den ersten Befehl ausführen und anschließend die Befehle zwei bis vier. Wenn Sie jedoch über eine benutzerdefinierte Sicherheitsgruppe verfügen, die bereits eingehenden Web-Datenverkehr über Port 80 zulässt, können Sie diese Befehle überspringen.
Mit den Befehlen fünf bis acht wird die Netzwerk-ACL aktiviert, um eingehenden Web-Datenverkehr über Port 80 zu erlauben. Wenn Sie über eine Standard-Netzwerk-ACL verfügen, die bereits eingehenden Datenverkehr über alle Ports erlaubt, können Sie diese Befehle überspringen. Nehmen wir jedoch an, Sie haben eine benutzerdefinierte Netzwerk-ACL, die keinen eingehenden Web-Datenverkehr über Port 80 zulässt. Führen Sie dann den ersten Befehl aus, gefolgt von den Befehlen 5 bis 8.
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Add an inbound rule to the security group to allow all incoming IPv4-based traffic over port 80.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Add an inbound rule to the security group to allow all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10000 --cidr-block 0.0.0.0/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv4-based traffic over port 80. Advanced users: change this suggested rule number as desired.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10100 --ipv6-cidr-block ::/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv6-based traffic over port 80. Advanced users: change this suggested rule number as desired.
```
1. Rufen Sie die URL für die `index.php` Datei innerhalb des Web-Server-Stamms ab. Führen Sie dazu den folgenden Befehl aus und verwenden Sie einen neuen Webbrowser-Tab oder einen anderen Webbrowser als die AWS Cloud9 IDE, um zu der angezeigten URL zu gelangen. Wenn der Vorgang erfolgreich ist, werden auf der Webseite Informationen zu folgenden Themen angezeigt Apache HTTP-Server, MySQL, PHPund andere verwandte Einstellungen.
```
MY_PUBLIC_IP=$(curl http://169.254.169.254/latest/meta-data/public-ipv4) && echo http://$MY_PUBLIC_IP/index.php # Get the URL to the index.php file within the web server root.
```
## Schritt 4: Bereinigen
Angenommen, Sie möchten diese Umgebung weiterhin verwenden, aber den eingehenden Web-Datenverkehr über Port 80 deaktivieren. Führen Sie in diesem Fall die folgenden acht Befehle nacheinander in der angegebenen Reihenfolge aus. Damit löschen Sie die entsprechenden eingehenden Web-Datenverkehrregeln, die Sie zuvor in der mit der Umgebung verbundenen Sicherheitsgruppe und Netzwerk-ACL festgelegt haben. Informationen dazu, was die einzelnen Befehle auslösen, finden Sie in der Erklärung hinter dem `#`-Zeichen für jeden Befehl.
**Wichtig**
Wenn Sie die folgenden Befehle ausführen, wird eingehender Webdatenverkehr über Port 80 für **alle** EC2 Umgebungen und EC2 Amazon-Instances deaktiviert, die der Sicherheitsgruppe und der Netzwerk-ACL für diese Umgebung zugeordnet sind. Dies kann dazu führen, dass eingehender Webverkehr über Port 80 für andere EC2 Umgebungen und EC2 Amazon-Instances als diese unerwartet deaktiviert wird.
**Anmerkung**
Mit den Befehlen 5 bis 8 werden vorhandene Regeln entfernt, um zu verhindern, dass die Netzwerk-ACL eingehenden Web-Datenverkehr über Port 80 erlaubt. Wenn Sie über eine Standard-Netzwerk-ACL verfügen, die bereits eingehenden Datenverkehr über alle Ports erlaubt, können Sie diese Befehle überspringen. Angenommen, Sie verfügen jedoch über eine benutzerdefinierte Netzwerk-ACL mit vorhandenen Regeln, die eingehenden Web-Datenverkehr über Port 80 erlauben, und möchten diese Regeln löschen. In diesem Fall müssen Sie den ersten Befehl ausführen, gefolgt von den Befehlen 5 bis 8.
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Delete the existing inbound rule from the security group to block all incoming IPv4-based traffic over port 80.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Delete the existing inbound rule from the security group to block all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10000 # Delete the existing inbound rule from the network ACL to block all IPv4-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10100 # Delete the existing inbound rule from the network ACL to block all IPv6-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
```
Wenn Sie die Umgebung nicht mehr benötigen, löschen Sie sie, um zu verhindern, dass weiterhin Gebühren für Ihr AWS-Konto anfallen. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# WordPress Tutorial für AWS Cloud9
Dieses Tutorial ermöglicht Ihnen die Installation und Ausführung WordPress in einer AWS Cloud9 Entwicklungsumgebung. WordPress ist ein Open-Source-Content-Management-System (CMS), das häufig für die Bereitstellung von Webinhalten verwendet wird.
**Anmerkung**
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann es sein, dass Ihr AWS Konto belastet wird. Dies umfasst mögliche Kosten für Services wie Amazon Elastic Compute Cloud (Amazon EC2). Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/).
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
+ **Sie haben eine up-to-date EC2-Instance mit den neuesten Softwarepaketen**. Im AWS Cloud9 IDE-Terminalfenster können Sie die Ausführung `yum update` mit der `-y` Option ausführen, Updates zu installieren, ohne nach einer Bestätigung zu fragen. Wenn Sie die Aktualisierungen vor der Installation überprüfen möchten, können Sie diese Option auslassen.
```
sudo yum update -y
```
## Übersicht über den Installationsprozess
Die Installation WordPress auf der EC2-Instanz Ihrer Umgebung umfasst die folgenden Schritte:
1. Installation und Konfiguration von MariaDB Server, einer relationalen Open-Source-Datenbank, die Informationen für Installationen speichert WordPress
1. Installation und Konfiguration WordPress, einschließlich der Bearbeitung der Konfigurationsdatei `wordpress.conf`
1. Konfiguration des Apache-Servers, der die WordPress Site hostet
1. Vorschau der WordPress Webinhalte anzeigen, die vom Apache-Server gehostet werden
## Schritt 1: Installieren und Konfigurieren von MariaDB Server
1. Wählen Sie in der AWS Cloud9 IDE **Window**, **New Terminal** und geben Sie die folgenden Befehle ein, um eine MariaDB Server-Installation zu installieren und zu starten:
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. Als nächstes führen Sie das Skript `mysql_secure_installation` aus, um die Sicherheit Ihrer MariaDB Server-Installation zu verbessern.
Wenn Sie Antworten in das Skript eingeben, drücken Sie bei der ersten Frage **Enter (Eingabe)**, um das Root-Passwort leer zu lassen. Drücken Sie **n** für `Set root password?` und dann **y** für jede der restlichen Sicherheitsoptionen.
```
mysql_secure_installation
```
1. Erstellen Sie nun eine Datenbanktabelle zum Speichern von WordPress Informationen mit dem MariaDB-Client.
(Drücken Sie **Enter (Eingabe)**, wenn Sie nach Ihrem Passwort gefragt werden.)
```
sudo mysql -u root -p
MariaDB [(none)]> create database wp_test;
MariaDB [(none)]> grant all privileges on wp_test.* to root@localhost identified by ';'
```
1. Führen Sie den Befehl `exit` aus, um sich vom MariaDB-Client abzumelden.
## Schritt 2: Installation und Konfiguration WordPress
1. Navigieren Sie im IDE-Terminalfenster zu dem Verzeichnis `environment` und erstellen Sie die Verzeichnisse `config` und `wordpress`. Führen Sie dann den Befehl `touch` aus, um eine Datei namens `wordpress.conf` im Verzeichnis `config` zu erstellen:
```
cd /home/ec2-user/environment
mkdir config wordpress
touch config/wordpress.conf
```
1. Verwenden Sie den IDE-Editor oder vim, um die Host-Konfigurationsinformationen zu `wordpress.conf` aktualisieren, die es dem Apache-Server ermöglichen, WordPress Inhalte bereitzustellen:
```
# Ensure that Apache listens on port 80
Listen 8080
DocumentRoot "/var/www/wordpress"
ServerName www.example.org
# Other directives here
```
1. Führen Sie nun die folgenden Befehle aus, um die erforderliche Archivdatei abzurufen und zu installieren WordPress:
```
cd /home/ec2-user/environment
wget https://wordpress.org/latest.tar.gz
tar xvf latest.tar.gz
```
1. Führen Sie den Befehl `touch` aus, um eine Datei namens `wp-config.php` im Verzeichnis `environment/wordpress` zu erstellen:
```
touch wordpress/wp-config.php
```
1. Verwenden Sie den IDE-Editor oder vim, um die Beispieldaten zu aktualisieren `wp-config.php` und durch Ihr Setup zu ersetzen:
```
// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define( 'DB_NAME', 'wp_test' );
/** MySQL database username */
define( 'DB_USER', 'wp_user' );
/** MySQL database password */
define( 'DB_PASSWORD', 'YourSecurePassword' );
/** MySQL hostname */
define( 'DB_HOST', 'localhost' );
/** Database Charset to use in creating database tables. */
define( 'DB_CHARSET', 'utf8' );
/** The Database Collate type. Don't change this if in doubt. */
define( 'DB_COLLATE', '' );
define('FORCE_SSL', true);
if ($_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https') $_SERVER['HTTPS'] = 'on';
```
## Schritt 3: Konfigurieren Ihres Apache HTTP-Servers
1. Stellen Sie im AWS Cloud9 IDE-Terminalfenster sicher, dass Apache installiert ist:
```
httpd -v
```
Wenn der Apache-Server nicht installiert ist, führen Sie den folgenden Befehl aus:
```
sudo yum install -y httpd
```
1. Navigieren Sie zum Verzeichnis `/etc/httpd/conf.d`, in dem sich die Konfigurationsdateien des virtuellen Apache-Hosts befinden. Verwenden Sie dann den Befehl `ln`, um das zuvor erstellte `wordpress.conf` mit dem aktuellen Arbeitsverzeichnis (`/etc/httpd/conf.d`) zu verknüpfen:
```
cd /etc/httpd/conf.d
sudo ln -s /home/ec2-user/environment/config/wordpress.conf
```
1. Wechseln Sie nun zum Verzeichnis `/var/www`, dem Standard-Stammverzeichnis für Apache-Server. Verwenden Sie dann den Befehl `ln`, um das zuvor erstellte Verzeichnis `wordpress` mit dem aktuellen Arbeitsverzeichnis (`/var/www`) zu verknüpfen:
```
cd /var/www
sudo ln -s /home/ec2-user/environment/wordpress
```
1. Führen Sie den Befehl `chmod` aus, damit der Apache-Server den Inhalt des Unterverzeichnisses `wordpress` ausführen kann:
```
sudo chmod +x /home/ec2-user/
```
1. Starten Sie nun den Apache-Server neu, damit er die neuen Konfigurationen erkennen kann:
```
sudo service httpd restart
```
## Schritt 4: Vorschau von WordPress Webinhalten
1. Erstellen Sie mit der AWS Cloud9 IDE eine neue Datei mit dem Namen `index.html` im folgenden Verzeichnis:`environment/wordpress`.
1. Fügen Sie HTML-formatierten Text zu `index.html` hinzu. Beispiel:
```
Hello World!
```
1. Wählen Sie im **Umgebungsfenster** die `index.html` Datei aus und klicken Sie dann auf **Vorschau**, **Vorschau der laufenden Anwendung**.
Die Webseite mit der Nachricht *Hello World\$1* wird auf der Registerkarte für die Anwendungsvorschau angezeigt. Um den Webinhalt in Ihrem bevorzugten Browser anzuzeigen, wählen Sie **Pop Out Into a New Window (In einem neuen Fenster öffnen)**.
Wenn Sie die `index.html` Datei löschen und die Registerkarte „Anwendungsvorschau“ aktualisieren, wird die WordPress Konfigurationsseite angezeigt.
## Vorgehensweise bei „Mixed Content“-Fehlern
Webbrowser zeigen Fehler mit gemischten Inhalten für eine WordPress Website an, wenn sie HTTPS- und HTTP-Skripts oder Inhalte gleichzeitig lädt. Der Wortlaut der Fehlermeldungen hängt von dem von Ihnen verwendeten Webbrowser ab. In jedem Fall werden Sie darüber informiert, dass Ihre Verbindung zu einer Website unsicher oder nicht vollständig sicher ist. Und Ihr Webbrowser blockiert den Zugriff auf den gemischten Inhalt.
**Wichtig**
Standardmäßig verwenden alle Webseiten, auf die Sie auf der Registerkarte Anwendungsvorschau der AWS Cloud9 IDE zugreifen, automatisch das HTTPS-Protokoll. Wenn der URI einer Seite das unsichere `http`-Protokoll enthält, wird er automatisch durch `https` ersetzt. Sie können auch nicht auf den unsicheren Inhalt zugreifen, wenn Sie `https` manuell auf `http` zurücksetzen.
Anleitungen zur Implementierung von HTTPS für Ihre Website finden Sie in der [WordPressDokumentation](https://wordpress.org/support/article/https-for-wordpress/).
# Java-Tutorial für AWS Cloud9
**Wichtig**
Wenn Sie eine AWS Cloud9 Entwicklungsumgebung verwenden, die von einer EC2-Instance mit 2 GiB oder mehr Arbeitsspeicher unterstützt wird, empfehlen wir Ihnen, die erweiterte Java-Unterstützung zu aktivieren. Dies ermöglicht den Zugriff auf Produktivitätsfunktionen wie Code-Vervollständigung, Untersuchung auf Fehler, kontextspezifische Aktionen und Debugging-Optionen wie Haltepunkte und Stepping.
Weitere Informationen finden Sie unter [Erweiterter Support für Java-Entwicklung](enhanced-java.md).
In diesem Tutorial können Sie Java-Code in einer AWS Cloud9 Entwicklungsumgebung ausführen.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies zu Gebühren für Ihr AWS Konto führen. Dies umfasst mögliche Kosten für Services wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-java-prerequisites)
+ [Schritt 1: Installieren der erforderlichen Tools](#sample-java-install)
+ [Schritt 2: Code hinzufügen](#sample-java-code)
+ [Schritt 3: Erstellen und Ausführen des Codes](#sample-java-run)
+ [Schritt 4: Richten Sie die Verwendung von ein AWS SDK für Java](#sample-java-sdk)
+ [Schritt 5: Richten Sie die Verwaltung von AWS Anmeldeinformationen in Ihrer Umgebung ein](#sample-java-sdk-creds)
+ [Schritt 6: AWS SDK-Code hinzufügen](#sample-java-sdk-code)
+ [Schritt 7: Erstellen Sie den AWS SDK-Code und führen Sie ihn aus](#sample-java-sdk-run)
+ [Schritt 8: Bereinigen](#sample-java-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren der erforderlichen Tools
In diesem Schritt installieren Sie eine Reihe von Java-Entwicklungstools in Ihrer AWS Cloud9 Entwicklungsumgebung. Wenn Sie bereits einen Satz von Java-Entwicklungstools wie Oracle JDK oder OpenJDK in der Umgebung installiert haben, können Sie zu [Schritt 2: Code hinzufügen](#sample-java-code) springen. Dieses Beispiel wurde mit OpenJDK 8 entwickelt. Sie können es mit folgendem Verfahren in der Umgebung installieren.
1. Prüfen Sie, ob OpenJDK 8 bereits installiert ist. Führen Sie dazu in einer Terminalsitzung in der AWS Cloud9 IDE die Befehlszeilenversion des Java-Runners mit der **`-version`**Option aus. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus.
```
java -version
```
Führen Sie basierend auf der Ausgabe des vorhergehenden Befehls einen der folgenden Schritte aus:
+ Wenn die Ausgabe besagt, dass der Befehl `java` nicht gefunden wurde, fahren Sie zum Installieren von OpenJDK 8 mit Schritt 2 in diesem Verfahren fort.
+ Wenn die Ausgabe Werte enthält, die mit `Java(TM)`, `Java Runtime Environment`, `Java SE`, `J2SE` oder `Java2` beginnen, ist OpenJDK nicht installiert oder nicht als Standard-Toolset für die Java-Entwicklung festgelegt. Fahren Sie mit Schritt 2 in diesem Verfahren fort, um OpenJDK 8 zu installieren. Wechseln Sie dann zur Verwendung von OpenJDK 8.
+ Wenn die Ausgabe Werte enthält, die mit `java version 1.8` und `OpenJDK` beginnen, fahren Sie mit [Schritt 2: Code hinzufügen](#sample-java-code) fort. OpenJDK 8 ist für dieses Beispiel richtig installiert.
+ Wenn die Ausgabe eine `java version` vor `1.8` und Werte enthält, die mit `OpenJDK` beginnen, fahren Sie mit Schritt 2 in diesem Verfahren fort, um die installierte Version von OpenJDK auf OpenJDK 8 upzugraden.
1. Stellen Sie sicher, dass die neuesten Sicherheitsupdates und Fehlerbehebungen installiert wurden. Führen Sie dazu das yum-Tool (für Amazon Linux) oder das apt-Tool (für Ubuntu Server) mit dem Befehl ** `update` ** aus.
Für Amazon Linux:
```
sudo yum -y update
```
Für Ubuntu Server:
```
sudo apt update
```
1. Installieren Sie OpenJDK 8. Führen Sie dazu das yum-Tool (für Amazon Linux) oder das apt-Tool (für Ubuntu Server) mit dem Befehl ** `install` ** unter Angabe des OpenJDK 8-Pakets aus.
Für Amazon Linux:
```
sudo yum -y install java-1.8.0-openjdk-devel
```
Für Ubuntu Server:
```
sudo apt install -y openjdk-8-jdk
```
Weitere Informationen finden Sie unter [How to download and install prebuilt OpenJDK packages](https://openjdk.org/install/) auf der OpenJDK-Website.
1. Wechseln Sie zum Standard-Toolset OpenJDK 8 für die Java-Entwicklung oder nehmen Sie ein entsprechendes Upgrade vor. Führen Sie zu diesem Zweck den Befehl ** `update-alternatives` ** mit der Option ** `--config` ** aus. Führen Sie diesen Befehl zweimal aus, um zu den Befehlszeilenversionen des Java-Runners und -Compilers zu wechseln oder ein entsprechendes Upgrade vorzunehmen.
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
Geben Sie an jeder Eingabeaufforderung die Auswahlziffer für OpenJDK 8 an (das Paket mit `java-1.8`).
1. Vergewissern Sie sich, dass die Befehlszeilenversionen von Java-Runner und -Compiler OpenJDK 8 verwenden. Führen Sie zu diesem Zweck die Befehlszeilenversionen von Java-Runner und -Compiler mit der Option `-version` aus.
```
java -version
javac -version
```
Wenn OpenJDK 8 installiert und richtig eingerichtet ist, enthält die Java-Runner-Versionsausgabe einen mit `openjdk version 1.8` beginnenden Wert, während die Java-Compiler-Versionsausgabe mit dem Wert `javac 1.8` beginnt.
## Schritt 2: Code hinzufügen
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit dem folgenden Code und speichern Sie die Datei unter dem Namen`hello.java`. (Um eine Datei zu erstellen, wählen Sie in der Menüleiste **File (Datei)**, **New File (Neue Datei)** aus. Um die Datei zu speichern, wählen Sie **Datei**, **Save (Speichern)**.)
```
public class hello {
public static void main(String []args) {
System.out.println("Hello, World!");
System.out.println("The sum of 2 and 3 is 5.");
int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);
System.out.format("The sum of %s and %s is %s.\n",
args[0], args[1], Integer.toString(sum));
}
}
```
## Schritt 3: Erstellen und Ausführen des Codes
1. Verwenden Sie die Befehlszeilenversion des Java-Compilers, um die Datei `hello.java` in eine `hello.class`-Datei zu kompilieren. Führen Sie dazu mithilfe des Terminals in der AWS Cloud9 IDE aus demselben Verzeichnis wie die `hello.java` Datei den Java-Compiler aus und geben Sie die `hello.java` Datei an.
```
javac hello.java
```
1. Verwenden Sie die Befehlszeilenversion des Java-Runners, um die Datei `hello.class` auszuführen. Führen Sie zu diesem Zweck im Verzeichnis mit der Datei `hello.class` den Java-Runner aus. Geben Sie dabei den Namen der Klasse `hello`, die in der Datei `hello.java` deklariert wurde, mit zwei ergänzenden Ganzzahlen (z. B. `5` und `9`) an.
```
java hello 5 9
```
1. Vergleichen Sie die Ausgabe.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Schritt 4: Richten Sie die Verwendung von ein AWS SDK für Java
Sie können dieses Beispiel erweitern, um mit dem einen Amazon S3 S3-Bucket AWS SDK für Java zu erstellen, Ihre verfügbaren Buckets aufzulisten und dann den gerade erstellten Bucket zu löschen.
In diesem Schritt installieren Sie [Apache Maven](https://maven.apache.org/) oder [Gradle](https://gradle.org/) in der Umgebung. Maven und Gradle sind gebräuchliche Systeme zur Build-Automatisierung, die für Java-Projekte verwendet werden können. Nachdem Sie Maven oder Gradle installiert haben, können Sie die Software verwenden, um ein neues Java-Projekt zu generieren. In diesem neuen Projekt fügen Sie einen Verweis auf das AWS SDK für Java hinzu. Dies AWS SDK für Java bietet eine bequeme Möglichkeit, über Ihren Java-Code mit AWS Diensten wie Amazon S3 zu interagieren.
**Topics**
+ [Einrichten mit Maven](#sample-java-sdk-maven)
+ [Einrichten mit Gradle](#sample-java-sdk-gradle)
### Einrichten mit Maven
1. Installieren Sie Maven in Ihrer Umgebung. Um zu sehen, ob Maven bereits installiert ist, verwenden Sie das Terminal in der AWS Cloud9 IDE, indem Sie Maven mit der **`-version`**Option ausführen.
```
mvn -version
```
Bei erfolgreicher Ausführung enthält die Ausgabe die Maven-Versionsnummer. Wenn Maven bereits installiert ist, fahren Sie mit Schritt 4 in diesem Verfahren fort, um mit Maven ein neues Java-Projekt in der Umgebung zu generieren.
1. Installieren Sie Maven, indem Sie mit dem Terminal die folgenden Befehle ausführen.
Für Amazon Linux rufen die folgenden Befehle Informationen über das Paket-Repository ab, in dem Maven gespeichert ist. Diese Informationen werden dann zum Installieren von Maven verwendet.
```
sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo
sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
sudo yum install -y apache-maven
```
Weitere Informationen zu den vorstehenden Befehlen finden Sie unter [Extra Packages for Enterprise Linux (EPEL)](https://docs.fedoraproject.org/en-US/epel/) im Wiki des Fedora-Projekts.
Führen Sie stattdessen für Ubuntu Server den folgenden Befehl aus:
```
sudo apt install -y maven
```
1. Prüfen Sie die Installation, indem Sie Maven mit der Option ** `-version` ** ausführen.
```
mvn -version
```
1. Verwenden Sie Maven, um ein neues Java-Projekt zu generieren. Führen Sie zu diesem Zweck mit dem Terminal den folgenden Befehl in dem Verzeichnis aus, in dem Maven das Projekt generieren soll (z. B. im Stammverzeichnis Ihrer Umgebung).
```
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
Der vorstehende Befehl erstellt die folgende Verzeichnisstruktur für das Projekt in der Umgebung.
```
my-app
|- src
| `- main
| `- java
| `- com
| `- mycompany
| `- app
| `-App.java
|- test
| `- java
| `- com
| `- mycompany
| `- app
| `- AppTest.java
`- pom.xml
```
Weitere Informationen zur vorstehenden Verzeichnisstruktur finden Sie unter [Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) und [Introduction to the Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) auf der Apache Maven Project-Website.
1. Ändern Sie die Project Object Model (POM)-Datei für das Projekt. (Eine POM-Datei definiert die Einstellungen eines Maven-Projekts.) Öffnen Sie zu diesem Zweck im Fenster **Environment (Umgebung)** die Datei `my-app/pom.xml`. Ersetzen Sie im Editor den aktuellen Inhalt der Datei durch den folgenden Code und speichern Sie dann die Datei `pom.xml`.
```
4.0.0
com.mycompany.app
my-app
jar
1.0-SNAPSHOT
org.apache.maven.plugins
maven-assembly-plugin
3.6.0
jar-with-dependencies
com.mycompany.app.App
package
single
junit
junit
3.8.1
test
com.amazonaws
aws-java-sdk
1.11.330
```
Die vorstehende POM-Datei enthält Projekteinstellungen mit Deklarationen wie den folgenden:
+ Die Einstellung `artifactid` von `my-app` legt den Namen des Projekt-Stammverzeichnisses und die Einstellung `group-id` in `com.mycompany.app` die `com/mycompany/app`-Unterverzeichnisstruktur sowie die `package`-Deklaration in den Dateien `App.Java` und `AppTest.java` fest.
+ Die `artifactId`-Einstellung von `my-app` legt mit der `packaging`-Einstellung von `jar`, der `version`-Einstellung von `1.0-SNAPSHOT` und der `descriptorRef`-Einstellung von `jar-with-dependencies` den Namen `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar` für die JAR-Ausgabedatei fest.
+ Der Abschnitt `plugin` deklariert das Erstellen eines JAR mit allen Abhängigkeiten.
+ Der `dependency` Abschnitt mit der `groupId` Einstellung von `com.amazon.aws` und der `artifactId` Einstellung von `aws-java-sdk` enthält die AWS SDK für Java Bibliotheksdateien. Die zu verwendende AWS SDK für Java -Version wird mit der Einstellung `version` deklariert. Wenn Sie eine andere Version verwenden, ersetzen Sie diese Versionsnummer.
Fahren Sie mit [Schritt 5: Richten Sie die Verwaltung von AWS Anmeldeinformationen in Ihrer Umgebung ein](#sample-java-sdk-creds) fort.
### Einrichten mit Gradle
1. Installieren Sie Gradle in Ihrer Umgebung. Um zu sehen, ob Gradle bereits installiert ist, verwenden Sie das Terminal in der AWS Cloud9 IDE, indem Sie Gradle mit der **`-version`**Option ausführen.
```
gradle -version
```
Bei erfolgreicher Ausführung enthält die Ausgabe die Gradle-Versionsnummer. Wenn Gradle bereits installiert ist, fahren Sie mit Schritt 4 in diesem Verfahren fort, um mit Gradle ein neues Java-Projekt in der Umgebung zu generieren.
1. Installieren Sie Gradle, indem Sie mit dem Terminal die folgenden Befehle ausführen. Diese Befehle installieren und führen das SDKMAN\$1 Tool aus. Dann verwenden Sie SDKMAN\$1, um die neueste Version von Gradle zu installieren.
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
Weitere Informationen zu den obigen Befehlen finden Sie unter [Installation](https://sdkman.io/install) auf der SDKMAN\$1-Website, und unter [Install with a package manager](https://gradle.org/install/#with-a-package-manager) auf der Gradle-Website.
1. Prüfen Sie die Installation, indem Sie Gradle mit der Option ** `-version` ** ausführen.
```
gradle -version
```
1. Verwenden Sie Gradle, um ein neues Java-Projekt in der Umgebung zu generieren. Führen Sie zu diesem Zweck mit dem Terminal die folgenden Befehle aus, um ein Verzeichnis für das Projekt zu erstellen. Wechseln Sie dann in dieses Verzeichnis.
```
mkdir my-app
cd my-app
```
1. Führen Sie den folgenden Befehl aus, um Gradle ein neues Java-Anwendungsprojekt im Verzeichnis `my-app` der Umgebung generieren zu lassen.
```
gradle init --type java-application
```
Der vorstehende Befehl erstellt die folgende Verzeichnisstruktur für das Projekt in der Umgebung.
```
my-app
|- .gradle
| `- (various supporting project folders and files)
|- gradle
| `- (various supporting project folders and files)
|- src
| |- main
| | `- java
| | `- App.java
| `- test
| `- java
| `- AppTest.java
|- build.gradle
|- gradlew
|- gradlew.bat
`- settings.gradle
```
1. Ändern Sie die Datei `AppTest.java` für das Projekt. (Wenn Sie dies nicht tun, wird das Projekt möglicherweise nicht wie erwartet erstellt oder ausgeführt). Öffnen Sie zu diesem Zweck im Fenster **Environment (Umgebung)** die Datei `my-app/src/test/java/AppTest.java`. Ersetzen Sie im Editor den aktuellen Inhalt der Datei durch den folgenden Code und speichern Sie dann die Datei `AppTest.java`.
```
import org.junit.Test;
import static org.junit.Assert.*;
public class AppTest {
@Test public void testAppExists () {
try {
Class.forName("com.mycompany.app.App");
} catch (ClassNotFoundException e) {
fail("Should have a class named App.");
}
}
}
```
1. Ändern Sie die Datei `build.gradle` für das Projekt. (Eine `build.gradle`-Datei definiert die Einstellungen eines Gradle-Projekts.) Öffnen Sie zu diesem Zweck im Fenster **Environment (Umgebung)** die Datei `my-app/build.gradle`. Ersetzen Sie im Editor den aktuellen Inhalt der Datei durch den folgenden Code und speichern Sie dann die Datei `build.gradle`.
```
apply plugin: 'java'
apply plugin: 'application'
repositories {
jcenter()
mavenCentral()
}
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
}
}
apply plugin: "io.spring.dependency-management"
dependencyManagement {
imports {
mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330'
}
}
dependencies {
compile 'com.amazonaws:aws-java-sdk-s3'
testCompile group: 'junit', name: 'junit', version: '4.12'
}
run {
if (project.hasProperty("appArgs")) {
args Eval.me(appArgs)
}
}
mainClassName = 'App'
```
Die vorstehende `build.gradle`-Datei enthält Projekteinstellungen mit Deklarationen wie den folgenden:
+ Das `io.spring.dependency-management` Plugin wird verwendet, um die AWS SDK für Java Maven Bill of Materials (BOM) zu importieren, um AWS SDK für Java Abhängigkeiten für das Projekt zu verwalten. `classpath`deklariert die zu verwendende Version. Wenn Sie eine andere Version verwenden, ersetzen Sie diese Versionsnummer.
+ `com.amazonaws:aws-java-sdk-s3` enthält den Amazon S3-Teil der AWS SDK für Java -Bibliotheksdateien. `mavenBom` deklariert die Version, die verwendet werden soll. Wenn Sie eine andere Version verwenden möchten, ersetzen Sie diese Versionsnummer.
## Schritt 5: Richten Sie die Verwaltung von AWS Anmeldeinformationen in Ihrer Umgebung ein
Jedes Mal, wenn Sie den verwenden, AWS SDK für Java um einen AWS Dienst aufzurufen, müssen Sie beim Anruf eine Reihe von AWS Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob der AWS SDK für Java über die entsprechenden Berechtigungen für den Anruf verfügt. Wenn die Anmeldeinformationen nicht die entsprechenden Berechtigungen haben, schlägt der Aufruf fehl.
In diesem Schritt speichern Sie Ihre Anmeldeinformationen innerhalb der Umgebung. Befolgen Sie stattdessen die Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md) und kehren Sie dann zu diesem Thema zurück.
Weitere Informationen finden Sie unter [Einrichten der AWS -Anmeldeinformationen und ‑Region für die Entwicklung](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) im *AWS SDK für Java -Entwicklerhandbuch*.
## Schritt 6: AWS SDK-Code hinzufügen
In diesem Schritt fügen Sie Code für die Interaktion mit Amazon S3 hinzu, um einen Bucket zu erstellen, die verfügbaren Buckets aufzulisten und dann den soeben erstellten Bucket zu löschen.
Öffnen Sie im Fenster **Environment (Umgebung)** die Datei `my-app/src/main/java/com/mycompany/app/App.java` für Maven oder die Datei `my-app/src/main/java/App.java` für Gradle. Ersetzen Sie im Editor den aktuellen Inhalt der Datei durch den folgenden Code und speichern Sie dann die Datei `App.java`.
```
package com.mycompany.app;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import java.util.List;
public class App {
private static AmazonS3 s3;
public static void main(String[] args) {
if (args.length < 2) {
System.out.format("Usage: \n" +
"Example: my-test-bucket us-east-2\n");
return;
}
String bucket_name = args[0];
String region = args[1];
s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(region)
.build();
// List current buckets.
ListMyBuckets();
// Create the bucket.
if (s3.doesBucketExistV2(bucket_name)) {
System.out.format("\nCannot create the bucket. \n" +
"A bucket named '%s' already exists.", bucket_name);
return;
} else {
try {
System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name);
s3.createBucket(new CreateBucketRequest(bucket_name, region));
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
}
// Confirm that the bucket was created.
ListMyBuckets();
// Delete the bucket.
try {
System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name);
s3.deleteBucket(bucket_name);
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
// Confirm that the bucket was deleted.
ListMyBuckets();
}
private static void ListMyBuckets() {
List buckets = s3.listBuckets();
System.out.println("My buckets now are:");
for (Bucket b : buckets) {
System.out.println(b.getName());
}
}
}
```
## Schritt 7: Erstellen Sie den AWS SDK-Code und führen Sie ihn aus
Führen Sie zum Ausführen des Codes aus dem vorherigen Schritt die folgenden Befehle mit dem Terminal aus. Diese Befehle verwenden Maven oder Gradle zum Erstellen einer ausführbaren JAR-Datei für das Projekt und den Java-Runner zum Ausführen der JAR-Datei. Das JAR wird mit dem Namen des Buckets ausgeführt, der in Amazon S3 erstellt werden soll (z. B.`my-test-bucket`) und der ID der AWS Region, in der der Bucket erstellt werden soll, als Eingabe (z. B.`us-east-2`).
Führen Sie für Maven die folgenden Befehle aus.
```
cd my-app
mvn package
java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2
```
Führen Sie für Gradle die folgenden Befehle aus.
```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```
Vergleichen Sie die Ergebnisse mit der folgenden Ausgabe.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Schritt 8: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie die Umgebung löschen. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# C\$1\$1-Tutorial für AWS Cloud9
In diesem Tutorial können Sie C\$1\$1-Code in einer AWS Cloud9 Entwicklungsumgebung ausführen. Der Code verwendet auch Ressourcen, die von [AWS SDK für C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/welcome.html) bereitgestellt werden, einer modularisierten, plattformübergreifenden Open-Source-Bibliothek, die Sie für die Verbindung mit Amazon Web Services verwenden können.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies zu Gebühren für Ihr AWS Konto führen. Dies umfasst mögliche Kosten für Services wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-cplusplus-prereqs)
+ [Schritt 1: Installieren von g\$1\$1 und der erforderlichen Entwicklungspakete](#sample-cplusplus-install)
+ [Schritt 2: Installieren CMake](#install-cmake)
+ [Schritt 3: Abrufen und Erstellen des SDK für C\$1\$1](#install-cmake)
+ [Schritt 4: C\$1\$1- und CMake Lists-Dateien erstellen](#sample-cplusplus-sdk-code)
+ [Schritt 5: Erstellen und Ausführen des C\$1\$1-Codes](#build-and-run-cpp)
+ [Schritt 6: Bereinigen](#sample-cplusplus-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren von g\$1\$1 und der erforderlichen Entwicklungspakete
Zum Erstellen und Ausführen einer C\$1\$1-Anwendung benötigen Sie ein Dienstprogramm wie `g++`, das ein C\$1\$1-Compiler ist, der von der [GNU Complier Collection (GCC)](https://gcc.gnu.org/) bereitgestellt wird.
Sie müssen außerdem Header-Dateien (`-dev`-Pakete) für`libcurl`, `libopenssl`, `libuuid`, `zlib` und, optional `libpulse`, für Amazon Polly-Support hinzufügen.
Der Prozess der Installation von Entwicklungstools variiert geringfügig, je nachdem, ob Sie eine Amazon Linux/Amazon Linux 2-Instance oder eine Ubuntu-Instance verwenden.
------
#### [ Amazon Linux-based systems ]
Sie können überprüfen, ob Sie es bereits `gcc` installiert haben, indem Sie den folgenden Befehl im AWS Cloud9 Terminal ausführen:
```
g++ --version
```
Wenn `g++` nicht installiert ist, können Sie es einfach als Teil der Paketgruppe „Development Tools“ installieren. Diese Tools werden einer Instance mit dem Befehl `yum groupinstall` hinzugefügt:
```
sudo yum groupinstall "Development Tools"
```
Führen Sie `g++ --version` erneut aus, um zu überprüfen, ob der Compiler installiert wurde.
Installieren Sie nun die Pakete für die benötigten Bibliotheken mit dem Paketmanager Ihres Systems:
```
sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
```
------
#### [ Ubuntu-based systems ]
Sie können überprüfen, ob Sie bereits `gcc` installiert haben, indem Sie den folgenden Befehl im AWS Cloud9 Terminal ausführen:
```
g++ --version
```
Wenn gcc nicht installiert ist, können Sie ihn auf einem Ubuntu-basierten System installieren, indem Sie die folgenden Befehle ausführen:
```
sudo apt update
sudo apt install build-essential
sudo apt-get install manpages-dev
```
Führen Sie `g++ --version` erneut aus, um zu überprüfen, ob der Compiler installiert wurde.
Installieren Sie nun die Pakete für die benötigten Bibliotheken mit dem Paketmanager Ihres Systems:
```
sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
```
------
## Schritt 2: Installieren CMake
Sie müssen das Tool `cmake` installieren, das den Prozess der Erstellung ausführbarer Dateien aus dem Quellcode automatisiert.
1. Führen Sie im IDE-Terminalfenster den folgenden Befehl aus, um das erforderliche Archiv abzurufen:
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
1. Extrahieren Sie die Dateien aus dem Archiv und navigieren Sie zu dem Verzeichnis mit den entpackten Dateien:
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
1. Führen Sie als Nächstes ein Bootstrap-Skript aus und installieren Sie `cmake`, indem Sie die folgenden Befehle ausführen:
```
./bootstrap
make
sudo make install
```
1. Überprüfen Sie, ob Sie das Tool installiert haben, indem Sie den folgenden Befehl ausführen:
```
cmake --version
```
## Schritt 3: Abrufen und Erstellen des SDK für C\$1\$1
Um das AWS SDK for C\$1\$1 einzurichten, können Sie das SDK entweder selbst direkt aus der Quelle erstellen oder die Bibliotheken mit einem Paketmanager herunterladen. Einzelheiten zu den verfügbaren Optionen finden Sie [unter Erste Schritte mit dem AWS SDK for C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html) im *AWS SDK für C\$1\$1 Entwicklerhandbuch*.
In diesem Beispiel wird die Verwendung von `git` zum Klonen des SDK-Quellcodes und von `cmake` zum Erstellen des SDK für C\$1\$1 demonstriert.
1. Klonen Sie das entfernte Repository und rufen Sie alle Git-Submodule rekursiv für Ihre AWS Cloud9 -Umgebung ab, indem Sie den folgenden Befehl im Terminal ausführen:
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. Navigieren Sie zu dem neuen `aws-sdk-cpp` Verzeichnis, erstellen Sie ein Unterverzeichnis, in das das AWS SDK for C\$1\$1 eingebaut werden soll, und navigieren Sie dann zu diesem:
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**Anmerkung**
Aus Zeitgründen wird in diesem Schritt nur der Amazon S3-Teil von AWS SDK für C\$1\$1 erstellt. Wenn Sie das komplette SDK erstellen möchten, lassen Sie das `-DBUILD_ONLY=s3` im Befehl `cmake` weg.
Je nach den verfügbaren Rechenressourcen Ihrer Amazon-EC2-Instance oder Ihres eigenen Servers kann die Erstellung des kompletten SDK für C\$1\$1 mehr als eine Stunde in Anspruch nehmen.
Verwenden Sie `cmake`, um den Amazon S3-Teil des SDK für C\$1\$1 im `sdk_build`-Verzeichnis zu erstellen, indem Sie den folgenden Befehl ausführen:
```
cmake .. -DBUILD_ONLY=s3
```
1. Führen Sie nun den Befehl `make install` aus, damit auf das erstellte SDK zugegriffen werden kann:
```
sudo make install
cd ..
```
## Schritt 4: C\$1\$1- und CMake Lists-Dateien erstellen
In diesem Schritt erstellen Sie eine `C++`-Datei, mit der die Benutzer des Projekts mit Amazon S3-Buckets interagieren können.
Sie erstellen auch eine `CMakeLists.txt`-Datei, die Anweisungen enthält, die von `cmake` zur Erstellung Ihrer C\$1\$1-Bibliothek verwendet werden.
1. Erstellen Sie in der AWS Cloud9 IDE eine Datei mit diesem Inhalt und speichern Sie die Datei mit dem Namen `s3-demo.cpp` im Stammverzeichnis (`/`) Ihrer Umgebung.
```
#include
#include
#include
#include
#include
#include
#include
// Look for a bucket among all currently available Amazon S3 buckets.
bool FindTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
Aws::S3::Model::ListBucketsOutcome outcome = s3Client.ListBuckets();
if (outcome.IsSuccess()) {
std::cout << "Looking for a bucket named '" << bucketName << "'..."
<< std::endl << std::endl;
Aws::Vector bucket_list =
outcome.GetResult().GetBuckets();
for (Aws::S3::Model::Bucket const &bucket: bucket_list) {
if (bucket.GetName() == bucketName) {
std::cout << "Found the bucket." << std::endl << std::endl;
return true;
}
}
std::cout << "Could not find the bucket." << std::endl << std::endl;
} else {
std::cerr << "listBuckets error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Create an Amazon S3 bucket.
bool CreateTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName,
const Aws::String ®ion) {
std::cout << "Creating a bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::CreateBucketRequest request;
request.SetBucket(bucketName);
if (region != "us-east-1") {
Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
createBucketConfig.SetLocationConstraint(
Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
region));
request.SetCreateBucketConfiguration(createBucketConfig);
}
Aws::S3::Model::CreateBucketOutcome outcome =
s3Client.CreateBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket created." << std::endl << std::endl;
} else {
std::cerr << "createBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Delete an existing Amazon S3 bucket.
bool DeleteTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
std::cout << "Deleting the bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::DeleteBucketRequest request;
request.SetBucket(bucketName);
Aws::S3::Model::DeleteBucketOutcome outcome =
s3Client.DeleteBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket deleted." << std::endl << std::endl;
} else {
std::cerr << "deleteBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
#ifndef EXCLUDE_MAIN_FUNCTION
// Create an S3 bucket and then delete it.
// Before and after creating the bucket, and again after deleting the bucket,
// try to determine whether that bucket still exists.
int main(int argc, char *argv[]) {
if (argc < 3) {
std::cout << "Usage: s3-demo " << std::endl
<< "Example: s3-demo my-bucket us-east-1" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
Aws::String bucketName = argv[1];
Aws::String region = argv[2];
Aws::Client::ClientConfiguration config;
config.region = region;
Aws::S3::S3Client s3Client(config);
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!CreateTheBucket(s3Client, bucketName, region)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!DeleteTheBucket(s3Client, bucketName)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
}
Aws::ShutdownAPI(options);
return 0;
}
#endif // EXCLUDE_MAIN_FUNCTION
```
1. Erstellen Sie eine zweite Datei mit diesem Inhalt, und speichern Sie die Datei unter dem Namen `CMakeLists.txt` im Stammverzeichnis (`/`) Ihrer Umgebung. Diese Datei ermöglicht es Ihnen, aus Ihrem Code eine ausführbare Datei zu erstellen.
```
# A minimal CMakeLists.txt file for the AWS SDK for C++.
# The minimum version of CMake that will work.
cmake_minimum_required(VERSION 2.8)
# The project name.
project(s3-demo)
# Locate the AWS SDK for C++ package.
set(AWSSDK_ROOT_DIR, "/usr/local/")
set(BUILD_SHARED_LIBS ON)
find_package(AWSSDK REQUIRED COMPONENTS s3)
# The executable name and its source files.
add_executable(s3-demo s3-demo.cpp)
# The libraries used by your executable.
target_link_libraries(s3-demo ${AWSSDK_LINK_LIBRARIES})
```
## Schritt 5: Erstellen und Ausführen des C\$1\$1-Codes
1. Führen Sie im Stammverzeichnis Ihrer Umgebung, in dem Sie die Dateien `s3-demo.cpp` und `CMakeLists.txt` gespeichert haben, `cmake` aus, um Ihr Projekt zu erstellen:
```
cmake .
make
```
1. Sie können jetzt Ihr Programm über die Befehlszeile ausführen. Ersetzen Sie im folgenden Befehl `my-unique-bucket-name` durch einen eindeutigen Namen für den Amazon S3-Bucket und ersetzen Sie `us-east-1` gegebenenfalls durch den Bezeichner einer anderen AWS Region, in der Sie einen Bucket erstellen möchten.
```
./s3-demo my-unique-bucket-name us-east-1
```
Wird das Programm erfolgreich ausgeführt, wird eine Ausgabe ähnlich der folgenden zurückgegeben:
```
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
Creating a bucket named 'my-unique-bucket-name'...
Bucket created.
Looking for a bucket named 'my-unique-bucket-name'...
Found the bucket.
Deleting the bucket named 'my-unique-bucket-name'...
Bucket deleted.
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
```
## Schritt 6: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie mit diesem Beispiel fertig sind, löschen Sie die Umgebung. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# Python-Tutorial für AWS Cloud9
Dieses Tutorial zeigt Ihnen, wie Sie Python-Code in einer AWS Cloud9 Entwicklungsumgebung ausführen.
Wenn Sie diesem Tutorial folgen, kann dies zu Gebühren für Ihr AWS Konto führen. Dazu gehören mögliche Gebühren für Services wie Amazon Elastic Compute Cloud (Amazon EC2) und Amazon Simple Storage Service (Amazon S3). Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-python-prereqs)
+ [Schritt 1: Installieren von Python](#sample-python-install)
+ [Schritt 2: Code hinzufügen](#sample-python-code)
+ [Schritt 3: Ausführen des Codes](#sample-python-run)
+ [Schritt 4: Installieren und konfigurieren Sie AWS SDK für Python (Boto3)](#sample-python-sdk)
+ [Schritt 5: AWS SDK-Code hinzufügen](#sample-python-sdk-code)
+ [Schritt 6: Führen Sie den AWS SDK-Code aus](#sample-python-sdk-run)
+ [Schritt 7: Bereinigen](#sample-python-clean-up)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, stellen Sie sicher, dass die folgenden Anforderungen erfüllt sind.
+ **Sie haben eine AWS Cloud9 EC2-Entwicklungsumgebung**
In diesem Tutorial wird davon ausgegangen, dass Sie eine EC2-Umgebung besitzen und dass die Umgebung mit einer Amazon EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Details dazu finden Sie unter [Eine EC2 Umgebung erstellen](create-environment-main.md).
Wenn Sie mit einer anderen Umgebung oder einem anderen Betriebssystem arbeiten, müssen Sie die Anweisungen in diesem Tutorial möglicherweise anpassen.
+ **Sie haben die AWS Cloud9 IDE für diese Umgebung geöffnet**
Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Details dazu finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren von Python
1. Bestätigen Sie in einer Terminalsitzung in der AWS Cloud9 IDE, ob Python bereits installiert ist, indem Sie den **`python --version`**Befehl ausführen. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window (Fenster)**, **New Terminal (Neues Terminal)** aus.) Wenn Python installiert ist, fahren Sie mit [Schritt 2: Code hinzufügen](#sample-python-code) fort.
1. Führen Sie den Befehl ** `yum update`** für (Amazon Linux) oder **`apt update`** für (Ubuntu Server) aus, um sicherzustellen, dass die Sicherheitsupdates und Fehlerbehebungen auf dem aktuellen Stand sind.
Für Amazon Linux:
```
sudo yum -y update
```
Für Ubuntu Server:
```
sudo apt update
```
1. Installieren Sie Python, indem Sie den **`install`**-Befehl ausführen.
Für Amazon Linux:
```
sudo yum -y install python3
```
Für Ubuntu Server:
```
sudo apt-get install python3
```
## Schritt 2: Code hinzufügen
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit dem folgenden Inhalt und speichern Sie die Datei unter dem Namen`hello.py`. (Um eine Datei zu erstellen, wählen Sie in der Menüleiste **File (Datei)**, **New File (Neue Datei)** aus. Um die Datei zu speichern, wählen Sie **Datei**, **Save (Speichern)**.)
```
import sys
print('Hello, World!')
print('The sum of 2 and 3 is 5.')
sum = int(sys.argv[1]) + int(sys.argv[2])
print('The sum of {0} and {1} is {2}.'.format(sys.argv[1], sys.argv[2], sum))
```
## Schritt 3: Ausführen des Codes
1. Wählen Sie in der AWS Cloud9 IDE in der Menüleiste „**Ausführen**“, „**Konfigurationen ausführen**“, „**Neue Ausführungskonfiguration**“.
1. Auf der Registerkarte **[New] - Stopped (Angehalten)** Geben Sie `hello.py 5 9` für **Befehl** ein. Im Code repräsentiert `5` `sys.argv[1]` und `9` repräsentiert `sys.argv[2]`.
1. Wählen Sie **Run (Ausführen)** und vergleichen Sie die Ausgabe.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
1. Wählt standardmäßig AWS Cloud9 automatisch einen Runner für Ihren Code aus. Um den Runner zu ändern, wählen Sie **Runner** und dann **Python 2** oder **Python 3**.
**Anmerkung**
Sie können benutzerdefinierte Runner für bestimmte Python-Versionen erstellen. Details hierzu finden Sie unter [Einen Builder oder Runner erstellen](build-run-debug.md#build-run-debug-create-builder-runner).
## Schritt 4: Installieren und konfigurieren Sie AWS SDK für Python (Boto3)
Das AWS SDK für Python (Boto3) ermöglicht es Ihnen, Python-Code zu verwenden, um mit AWS Diensten wie Amazon S3 zu interagieren. Sie können dieses Beispiel so erweitern, dass Sie das SDK für das Erstellen eines Amazon S3-Buckets, das Auflisten der verfügbaren Buckets und das anschließende Löschen des Buckets zu nutzen, den Sie gerade erstellt haben.
### Installieren von pip
Bestätigen Sie in der AWS Cloud9 IDE, ob die aktive Version von Python bereits installiert `pip` ist, indem **`python -m pip --version`**Sie den Befehl ausführen. Wenn `pip` installiert ist, fahren Sie mit dem nächsten Abschnitt fort.
Führen Sie die folgenden Befehle aus, um `pip` zu installieren. Da sich sudo in einer anderen Umgebung als Ihr Benutzer befindet, müssen Sie die zu verwendende Version von Python angeben, wenn sie sich von der aktuellen Aliasversion unterscheidet.
```
curl -O https://bootstrap.pypa.io/get-pip.py # Get the install script.
sudo python3 get-pip.py # Install pip for Python 3.
python -m pip --version # Verify pip is installed.
rm get-pip.py # Delete the install script.
```
Weitere Informationen finden Sie unter [Installation](https://pip.pypa.io/en/stable/installing/) auf der `pip`-Website.
### Installieren Sie den AWS SDK für Python (Boto3)
Installieren Sie nach der Installation den`pip`, AWS SDK für Python (Boto3) indem Sie den **`pip install`**Befehl ausführen.
```
sudo python3 -m pip install boto3 # Install boto3 for Python 3.
python -m pip show boto3 # Verify boto3 is installed for the current version of Python.
```
Weitere Informationen finden Sie im Abschnitt „Installation“ von [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) im AWS SDK für Python (Boto3).
### Richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein
Jedes Mal, wenn Sie den verwenden, AWS SDK für Python (Boto3) um einen AWS Dienst aufzurufen, müssen Sie beim Anruf eine Reihe von Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob das SDK über die erforderlichen Berechtigungen verfügt, um den Anruf durchzuführen. Wenn die Anmeldeinformationen nicht die erforderlichen Berechtigungen abdecken, schlägt der Aufruf fehl.
Um Ihre Anmeldeinformationen in der Umgebung zu speichern, folgen Sie den Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md), und kehren Sie dann zu diesem Thema zurück.
Weitere Informationen finden Sie unter [Anmeldeinformationen](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html) im AWS SDK für Python (Boto3).
## Schritt 5: AWS SDK-Code hinzufügen
Fügen Sie Code hinzu, der Amazon S3 zum Erstellen eines Buckets, zum Auflisten der verfügbaren Buckets und zum optionalen Löschen des soeben erstellten Buckets verwendet.
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit dem folgenden Inhalt und speichern Sie die Datei unter dem Namen`s3.py`.
```
import sys
import boto3
from botocore.exceptions import ClientError
def list_my_buckets(s3_resource):
print("Buckets:\n\t", *[b.name for b in s3_resource.buckets.all()], sep="\n\t")
def create_and_delete_my_bucket(s3_resource, bucket_name, keep_bucket):
list_my_buckets(s3_resource)
try:
print("\nCreating new bucket:", bucket_name)
bucket = s3_resource.create_bucket(
Bucket=bucket_name,
CreateBucketConfiguration={
"LocationConstraint": s3_resource.meta.client.meta.region_name
},
)
except ClientError as e:
print(
f"Couldn't create a bucket for the demo. Here's why: "
f"{e.response['Error']['Message']}"
)
raise
bucket.wait_until_exists()
list_my_buckets(s3_resource)
if not keep_bucket:
print("\nDeleting bucket:", bucket.name)
bucket.delete()
bucket.wait_until_not_exists()
list_my_buckets(s3_resource)
else:
print("\nKeeping bucket:", bucket.name)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("bucket_name", help="The name of the bucket to create.")
parser.add_argument("region", help="The region in which to create your bucket.")
parser.add_argument(
"--keep_bucket",
help="Keeps the created bucket. When not "
"specified, the bucket is deleted "
"at the end of the demo.",
action="store_true",
)
args = parser.parse_args()
s3_resource = (
boto3.resource("s3", region_name=args.region)
if args.region
else boto3.resource("s3")
)
try:
create_and_delete_my_bucket(s3_resource, args.bucket_name, args.keep_bucket)
except ClientError:
print("Exiting the demo.")
if __name__ == "__main__":
main()
```
## Schritt 6: Führen Sie den AWS SDK-Code aus
1. Wählen Sie auf der Menüleiste **Run** (Ausführen), **Run Configurations** (Run-Konfigurationen), **New Run Configuration** (Neue Run-Konfiguration) aus.
1. Geben Sie **unter Command** den Namen des Buckets ein`s3.py my-test-bucket us-west-2`, der erstellt werden soll, und `us-west-2` geben Sie die ID der AWS Region ein, in der Ihr Bucket erstellt wurde. `my-test-bucket` Standardmäßig wird Ihr Bucket vor dem Beenden des Skripts gelöscht. Um Ihren Bucket zu behalten, fügen Sie Ihrem Befehl `--keep_bucket` hinzu. Eine Liste der AWS Regionen IDs finden Sie unter [Amazon Simple Storage Service Endpoints and Quotas](https://docs.aws.amazon.com/general/latest/gr/s3.html) in der *Allgemeine AWS-Referenz*.
**Anmerkung**
Amazon S3 S3-Bucket-Namen müssen überall eindeutig sein AWS— nicht nur in Ihrem AWS Konto.
1. Wählen Sie **Run (Ausführen)** und vergleichen Sie die Ausgabe.
```
Buckets:
a-pre-existing-bucket
Creating new bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
my-test-bucket
Deleting bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
```
## Schritt 7: Bereinigen
Um zu verhindern, dass Ihr AWS Konto nach Abschluss dieses Tutorials ständig belastet wird, löschen Sie die AWS Cloud9 Umgebung. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# .NET-Tutorial für AWS Cloud9
In diesem Tutorial können Sie einem.NET-Code in einer AWS Cloud9 Entwicklungsumgebung ausführen.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies zu Gebühren für Ihr AWS Konto führen. Dies umfasst mögliche Kosten für Services wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-dotnetcore-prereqs)
+ [Schritt 1: Installieren der erforderlichen Tools](#sample-dotnetcore-setup)
+ [Schritt 2 (Optional): Installieren der Erweiterung.NET CLI für Lambda Funktionen](#sample-dotnetcore-lambda)
+ [Schritt 3: Erstellen Sie ein Projekt für eine .NET-Konsolenanwendung](#sample-dotnetcore-app)
+ [Schritt 4: Hinzufügen von Code](#sample-dotnetcore-code)
+ [Schritt 5: Erstellen und Ausführen des Codes](#sample-dotnetcore-run)
+ [Schritt 6: Erstellen und richten Sie ein .NET-Konsolenanwendungsprojekt ein, das AWS SDK für .NET](#sample-dotnetcore-sdk)
+ [Schritt 7: AWS SDK-Code hinzufügen](#sample-dotnetcore-sdk-code)
+ [Schritt 8: Erstellen Sie den AWS SDK-Code und führen Sie ihn aus](#sample-dotnetcore-sdk-run)
+ [Schritt 9: Bereinigen](#sample-dotnetcore-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren der erforderlichen Tools
In diesem Schritt installieren Sie das.NET-SDK in Ihrer Umgebung, das für die Ausführung dieses Beispiels erforderlich ist.
1. Vergewissern Sie sich, ob die neueste Version des.NET-SDK bereits in Ihrer Umgebung installiert ist. Führen Sie dazu in einer Terminalsitzung in der AWS Cloud9 IDE das.NET Core-Befehlszeileninterface (CLI) mit der **`--version`**Option aus.
```
dotnet --version
```
Wenn die Version der .NET-Befehlszeilen-Tools angezeigt wird und die Version 2.0 oder höher ist, gehen Sie weiter zu [Schritt 3: Erstellen Sie ein Projekt für eine .NET-Konsolenanwendung](#sample-dotnetcore-app). Wenn die Version niedriger als 2.0 ist oder wenn ein Fehler wie z. B. angezeigt `bash: dotnet: command not found` wird, fahren Sie mit der Installation des.NET-SDK fort.
1. Führen Sie für Amazon Linux in einer Terminalsitzung in der AWS Cloud9 IDE die folgenden Befehle aus, um sicherzustellen, dass die neuesten Sicherheitsupdates und Bugfixes installiert sind, und um ein `libunwind` Paket zu installieren, das das.NET-SDK benötigt. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window (Fenster), New Terminal (Neues Terminal)** aus.)
```
sudo yum -y update
sudo yum -y install libunwind
```
Führen Sie für Ubuntu Server in einer Terminalsitzung in der AWS Cloud9 IDE den folgenden Befehl aus, um sicherzustellen, dass die neuesten Sicherheitsupdates und Bugfixes installiert sind. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window (Fenster), New Terminal (Neues Terminal)** aus.)
```
sudo apt -y update
```
1. Laden Sie das .NET SDK-Installationsskript in Ihre Umgebung herunter, indem Sie den folgenden Befehl ausführen.
```
wget https://dot.net/v1/dotnet-install.sh
```
1. Machen Sie das Installationsskript für den aktuellen Benutzer ausführbar, indem Sie den folgenden Befehl ausführen.
```
sudo chmod u=rx dotnet-install.sh
```
1. Führen Sie das Installationsskript aus, das das.NET-SDK herunterlädt und installiert, indem Sie den folgenden Befehl ausführen.
```
./dotnet-install.sh -c Current
```
1. Fügen Sie das.NET-SDK zu Ihrem hinzu`PATH`. Fügen Sie dazu im Shell-Profil für die Umgebung (z.B. die Datei `.bashrc`) das Unterverzeichnis `$HOME/.dotnet` wie folgt der Variablen `PATH` für die Umgebung hinzu.
1. Öffnen Sie die `.bashrc`-Datei mit dem Befehl ** `vi` ** zum Bearbeiten.
```
vi ~/.bashrc
```
1. Navigieren Sie für Amazon Linux mit dem Abwärtspfeil oder der Taste `j` zu der Zeile, die mit `export PATH` beginnt.
Gehen Sie für Ubuntu Server in die letzte Zeile der Datei, indem Sie `G` eingeben.
1. Navigieren Sie mit dem Rechtspfeil oder der Taste `$` zum Ende dieser Zeile.
1. Wechseln Sie in den Einfügemodus, indem Sie die `i`-Taste drücken. (`-- INSERT ---` erscheint am Ende der Anzeige).
1. Fügen Sie für Amazon Linux das Unterverzeichnis `$HOME/.dotnet` zur Variablen ** `PATH` ** hinzu, indem Sie `:$HOME/.dotnet` eingeben. Vergessen Sie nicht, den Doppelpunkt (`:`) anzugeben. Die Zeile sollte nun etwa folgendermaßen aussehen.
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
Für Ubuntu Server drücken Sie die Pfeiltaste nach rechts und dann zweimal `Enter`, gefolgt von der Eingabe der folgenden Zeile am Ende der Datei.
```
export PATH=$HOME/.dotnet:$PATH
```
1. Speichern Sie die Datei. Drücken Sie zu diesem Zweck die Taste `Esc` (`-- INSERT ---` am Ende der Anzeige wird ausgeblendet), geben Sie `:wq` ein (damit in die Datei geschrieben und diese dann geschlossen wird) und drücken Sie dann `Enter`.
1. Laden Sie das.NET-SDK, indem Sie die `.bashrc` Datei beschaffen.
```
. ~/.bashrc
```
1. Vergewissern Sie sich, dass das.NET-SDK geladen ist, indem Sie.NET CLI mit der **`--help`**Option ausführen.
```
dotnet --help
```
Bei Erfolg wird die Versionsnummer des .NET SDK mit zusätzlichen Nutzungsinformationen angezeigt.
1. Wenn Sie das .NET SDK-Installationsskript nicht mehr in Ihrer Umgebung behalten möchten, können Sie es wie folgt löschen.
```
rm dotnet-install.sh
```
## Schritt 2 (Optional): Installieren der Erweiterung.NET CLI für Lambda Funktionen
Obwohl für dieses Tutorial nicht erforderlich, können Sie AWS Lambda Funktionen und AWS Serverless Application Model Anwendungen mithilfe der.NET-CLI bereitstellen, wenn Sie das `Amazon.Lambda.Tools` Paket auch installieren.
1. Zur Installation dieses Pakets führen Sie den folgenden Befehl aus:
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Legen Sie nun die Umgebungsvariablen `PATH` und `DOTNET_ROOT` so fest, dass sie auf das installierte Lambda-Tool verweisen. Suchen Sie in der Datei `.bashrc` den Abschnitt `export PATH` und bearbeiten Sie ihn so, dass er etwa wie folgt aussieht (Einzelheiten zur Bearbeitung dieser Datei finden Sie in Schritt 1):
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```
## Schritt 3: Erstellen Sie ein Projekt für eine .NET-Konsolenanwendung
In diesem Schritt verwenden Sie.NET, um ein Projekt mit dem Namen zu erstellen`hello`. Dieses Projekt enthält alle Dateien, die .NET benötigt, um eine einfache Anwendung vom Terminal in der IDE aus auszuführen. Der Code der Anwendung ist in C\$1 geschrieben.
Erstellen Sie ein .NET-Konsolenanwendungsprojekt. Führen Sie dazu die .NET-CLI mit dem **`new`**Befehl aus und geben Sie den Projektvorlagentyp der Konsolenanwendung und die zu verwendende Programmiersprache (in diesem Beispiel C\$1) an.
Die Option `-n` gibt an, dass das Projekt in ein neues Verzeichnis, `hello`, ausgegeben wird: Navigieren Sie anschließend zu diesem Verzeichnis.
```
dotnet new console -lang C# -n hello
cd hello
```
Der vorherige Befehl fügt ein Unterverzeichnis namens `obj` mit mehreren Dateien sowie einige eigenständige Dateien im Verzeichnis `hello` hinzu. Beachten Sie diese beiden wichtigen Dateien:
+ Die Datei `hello/hello.csproj` enthält Informationen zum Konsolenanwendungsprojekt.
+ Die Datei `hello/Program.cs` enthält den auszuführenden Code der Anwendung.
## Schritt 4: Hinzufügen von Code
In diesem Schritt fügen Sie der Anwendung einige Codezeilen hinzu.
Öffnen Sie die `hello/Program.cs` Datei im Fenster **Umgebung** in der AWS Cloud9 IDE.
Ersetzen Sie im Editor den aktuellen Inhalt der Datei durch den folgenden Code und speichern Sie dann die Datei `Program.cs`.
```
using System;
namespace hello
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Please provide 2 numbers");
return;
}
Console.WriteLine("Hello, World!");
Console.WriteLine("The sum of 2 and 3 is 5.");
int sum = Int32.Parse(args[0]) + Int32.Parse(args[1]);
Console.WriteLine("The sum of {0} and {1} is {2}.",
args[0], args[1], sum);
}
}
}
```
## Schritt 5: Erstellen und Ausführen des Codes
In diesem Schritt erstellen Sie das Projekt und seine Abhängigkeiten. Dabei entstehen eine Reihe von Binärdateien sowie eine ausführbare Anwendungsdatei. Anschließend führen Sie die Anwendung aus.
1. Erstellen Sie in der IDE wie folgt einen Builder für.NET.
1. Wählen Sie in der Menüleiste **Run (Ausführen), Build System (Build-System), New Build System (Neues Build-System)**.
1. Ersetzen Sie den Inhalt der Registerkarte **My Builder.build (Mein Builder.build)** durch den folgenden Code.
```
{
"cmd" : ["dotnet", "build"],
"info" : "Building..."
}
```
1. Wählen Sie **File (Datei), Save As (Speichern unter)** aus.
1. Geben Sie für **Filename (Dateiname)** den Wert `.NET.build` ein.
1. Geben Sie für **Folder (Ordner)** den Wert `/.c9/builders` ein.
1. Wählen Sie **Speichern**.
1. Wenn der Inhalt der `Program.cs` Datei im Editor angezeigt wird, wählen Sie **Run, Build System, .NET**. Wählen Sie dann **Run (Ausführen), Build (Erstellen)**.
Dieser Builder fügt ein Unterverzeichnis namens `bin` und fügt ein Unterverzeichnis namens `Debug` in das Unterverzeichnis `hello/obj` ein. Beachten Sie die folgenden drei wichtigen Dateien.
+ Die Datei `hello/bin/Debug/netcoreapp3.1/hello.dll` ist die ausführbare Anwendungsdatei.
+ Die Datei `hello/bin/Debug/netcoreapp3.1/hello.deps.json` listet die Abhängigkeiten der Anwendung auf.
+ Die Datei `hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json` gibt die gemeinsame Laufzeitumgebung und deren Version für die Anwendung an.
**Anmerkung**
Der Ordnername,`netcoreapp3.1`, spiegelt die Version des.NET-SDK wider, die in diesem Beispiel verwendet wurde. Je nach installierter Version wird im Ordnernamen möglicherweise eine andere Nummer angezeigt.
1. Erstellen Sie wie folgt einen Runner für.NET.
1. Wählen Sie in der Menüleiste **Run (Ausführen), Run With (Ausführen mit), New Runner (Neuer Runner)**.
1. Ersetzen Sie den Inhalt der Registerkarte **My Runner.run (Mein Runner.run)** durch den folgenden Code.
```
{
"cmd" : ["dotnet", "run", "$args"],
"working_dir": "$file_path",
"info" : "Running..."
}
```
1. Wählen Sie **File (Datei), Save As (Speichern unter)** aus.
1. Geben Sie für **Filename (Dateiname)** den Wert `.NET.run` ein.
1. Geben Sie für **Folder (Ordner)** den Wert `/.c9/runners` ein.
1. Wählen Sie **Speichern**.
1. Führen Sie die Anwendung folgendermaßen mit zwei übergebenen Ganzzahlen aus (z. B. `5` und `9`).
1. Wählen Sie `Program.cs`Run (Ausführen), Run Configurations (Ausführungskonfigurationen), New Run Configuration (Neue Ausführungskonfiguration)**, während der Inhalt der Datei ** im Editor angezeigt wird.
1. Wählen Sie auf der Registerkarte **[Neu] — Leerlauf** die Option **Runner: Auto** und dann **.NET**.
1. Geben Sie in das Feld **Command (Befehl)** den Wert `hello 5 9` ein.
1. Klicken Sie auf **Ausführen**.
Standardmäßig weist dieser Runner .NET an, die `hello.dll` Datei im `hello/bin/Debug/netcoreapp3.1` Verzeichnis auszuführen.
Vergleichen Sie die Ausgabe mit Folgendem.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Schritt 6: Erstellen und richten Sie ein .NET-Konsolenanwendungsprojekt ein, das AWS SDK für .NET
Sie können dieses Beispiel erweitern, um mit dem einen Amazon S3 S3-Bucket AWS SDK für .NET zu erstellen, Ihre verfügbaren Buckets aufzulisten und dann den gerade erstellten Bucket zu löschen.
In diesem neuen Projekt fügen Sie einen Verweis auf das AWS SDK für .NET hinzu. Das AWS SDK für .NET bietet eine bequeme Möglichkeit, über Ihren .NET-Code mit AWS Diensten wie Amazon S3 zu interagieren. Anschließend richten Sie die Verwaltung von AWS Anmeldeinformationen in Ihrer Umgebung ein. The AWS SDK für .NET benötigt diese Anmeldeinformationen, um mit AWS Diensten zu interagieren.
### So erstellen Sie das --Projekt
1. Erstellen Sie ein .NET-Konsolenanwendungsprojekt. Führen Sie dazu die .NET-CLI mit dem **`new`**Befehl aus und geben Sie dabei den Projektvorlagentyp der Konsolenanwendung und die zu verwendende Programmiersprache an.
Die Option `-n` gibt an, dass das Projekt in ein neues Verzeichnis, `s3`, ausgegeben wird: Navigieren Sie anschließend zu diesem Verzeichnis.
```
dotnet new console -lang C# -n s3
cd s3
```
1. Fügen Sie einen Projektverweis auf das Amazon S3-Paket in der Datei AWS SDK für .NET ein. Führen Sie dazu die .NET-CLI mit dem **`add package`**Befehl aus und geben Sie den Namen des Amazon S3 S3-Pakets in an NuGet. (NuGetdefiniert, wie Pakete für .NET erstellt, gehostet und genutzt werden, und stellt die Tools für jede dieser Rollen bereit.)
```
dotnet add package AWSSDK.S3
```
Wenn Sie dem Amazon S3 S3-Paket eine Projektreferenz hinzufügen, wird NuGet auch eine Projektreferenz zum Rest von hinzugefügt AWS SDK für .NET.
**Anmerkung**
Die Namen und Versionen anderer AWS verwandter Pakete finden Sie auf der NuGet Website unter [NuGetPakete, die NuGet mit aws-sdk gekennzeichnet](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22) sind.
### So richten Sie die Verwaltung von Anmeldedaten ein AWS
Jedes Mal, wenn Sie den verwenden, AWS SDK für .NET um einen AWS Dienst aufzurufen, müssen Sie beim Anruf eine Reihe von AWS Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob der AWS SDK für .NET über die entsprechenden Berechtigungen verfügt, um diesen Anruf zu tätigen. Wenn die Anmeldeinformationen nicht die entsprechenden Berechtigungen haben, schlägt der Aufruf fehl.
Um Ihre Anmeldeinformationen in der Umgebung zu speichern, folgen Sie den Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md), und kehren Sie dann zu diesem Thema zurück.
Weitere Informationen finden Sie im *AWS SDK für .NET Developer Guide* unter [Configuring AWS Credentials](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html).
## Schritt 7: AWS SDK-Code hinzufügen
In diesem Schritt fügen Sie Code für die Interaktion mit Amazon S3 hinzu, um einen Bucket zu erstellen, den soeben erstellten Bucket hinzuzufügen und dann die verfügbaren Buckets aufzulisten.
Öffnen Sie die `s3/Program.cs` Datei im **Umgebungsfenster** der AWS Cloud9 IDE. Ersetzen Sie im Editor den aktuellen Inhalt der Datei durch den folgenden Code und speichern Sie dann die Datei `Program.cs`.
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;
using System;
using System.Threading.Tasks;
namespace s3
{
class Program
{
async static Task Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Usage: ");
Console.WriteLine("Example: my-test-bucket us-east-2");
return;
}
if (args[1] != "us-east-2") {
Console.WriteLine("Cannot continue. The only supported AWS Region ID is " +
"'us-east-2'.");
return;
}
var bucketRegion = RegionEndpoint.USEast2;
// Note: You could add more valid AWS Regions above as needed.
using (var s3Client = new AmazonS3Client(bucketRegion)) {
var bucketName = args[0];
// Create the bucket.
try
{
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Cannot continue. Cannot create bucket. \n" +
"A bucket named '{0}' already exists.", bucketName);
return;
} else {
Console.WriteLine("\nCreating the bucket named '{0}'...", bucketName);
await s3Client.PutBucketAsync(bucketName);
}
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
// Confirm that the bucket was created.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Created the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Did not create the bucket named '{0}'.", bucketName);
}
// Delete the bucket.
Console.WriteLine("\nDeleting the bucket named '{0}'...", bucketName);
await s3Client.DeleteBucketAsync(bucketName);
// Confirm that the bucket was deleted.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Did not delete the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Deleted the bucket named '{0}'.", bucketName);
};
// List current buckets.
Console.WriteLine("\nMy buckets now are:");
var response = await s3Client.ListBucketsAsync();
foreach (var bucket in response.Buckets)
{
Console.WriteLine(bucket.BucketName);
}
}
}
}
}
```
## Schritt 8: Erstellen Sie den AWS SDK-Code und führen Sie ihn aus
In diesem Schritt erstellen Sie das Projekt und seine Abhängigkeiten. Dabei entstehen eine Reihe von Binärdateien sowie eine ausführbare Anwendungsdatei. Anschließend führen Sie die Anwendung aus.
1. Erstellen Sie das Projekt. Wählen Sie zu diesem Zweck in der Menüleiste `s3/Program.cs`Run (Ausführen), Build (Erstellen)**, während der Inhalt der Datei ** im Editor angezeigt wird.
1. Führen Sie folgendermaßen die Anwendung mit dem Namen des Amazon S3-Buckets und der ID der AWS -Region aus, in der der Bucket erstellt werden soll (z. B. `my-test-bucket` und `us-east-2`).
1. Wählen Sie `s3/Program.cs`Run (Ausführen), Run Configurations (Ausführungskonfigurationen), New Run Configuration (Neue Ausführungskonfiguration)**, während der Inhalt der Datei ** noch im Editor angezeigt wird.
1. Wählen Sie auf der Registerkarte **[Neu] — Leerlauf** die Option **Runner: Auto** und dann **.NET**.
1. Geben Sie im Feld **Befehl** den Namen der Anwendung, den Namen des zu erstellenden Amazon S3 S3-Buckets und die ID der AWS Region ein, in der der Bucket erstellt werden soll (z. B.`s3 my-test-bucket us-east-2`).
1. Klicken Sie auf **Ausführen**.
Standardmäßig weist dieser Runner .NET an, die `s3.dll` Datei im `s3/bin/Debug/netcoreapp3.1` Verzeichnis auszuführen.
Vergleichen Sie die Ergebnisse mit der folgenden Ausgabe.
```
Creating a new bucket named 'my-test-bucket'...
Created the bucket named 'my-test-bucket'.
Deleting the bucket named 'my-test-bucket'...
Deleted the bucket named 'my-test-bucket'.
My buckets now are:
```
## Schritt 9: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie die Umgebung löschen. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# Node.js Tutorial für AWS Cloud9
Dieses Tutorial ermöglicht es Ihnen, einige Node.js -Skripte in einer AWS Cloud9 Entwicklungsumgebung auszuführen.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies dazu führen, dass Ihr AWS Konto belastet wird. Dazu gehören mögliche Gebühren für Dienste wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [ EC2 Amazon-Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3-Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-nodejs-prereqs)
+ [Schritt 1: Installieren der erforderlichen Tools](#sample-nodejs-install)
+ [Schritt 2: Code hinzufügen](#sample-nodejs-code)
+ [Schritt 3: Ausführen des Codes](#sample-nodejs-run)
+ [Schritt 4: Installieren und konfigurieren Sie das AWS SDK für JavaScript in Node.js](#sample-nodejs-sdk)
+ [Schritt 5: AWS SDK-Code hinzufügen](#sample-nodejs-sdk-code)
+ [Schritt 6: Führen Sie den AWS SDK-Code aus](#sample-nodejs-sdk-run)
+ [Schritt 7: Bereinigen](#sample-nodejs-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2 Entwicklungsumgebung verfügen.** In diesem Beispiel wird davon ausgegangen, dass Sie bereits über eine EC2 Umgebung verfügen, die mit einer EC2 Amazon-Instance verbunden ist, auf der Amazon Linux ausgeführt wird, oder Ubuntu Server. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren der erforderlichen Tools
In diesem Schritt installieren Sie Node.js, das erforderlich ist, um dieses Beispiel auszuführen.
1. Vergewissern Sie sich in einer Terminalsitzung in der AWS Cloud9 IDE, ob Node.js bereits installiert ist, indem Sie den **`node --version`**Befehl ausführen. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus. Bei Erfolg enthält die Ausgabe die Node.js-Versionsnummer. Wenn Node.js installiert ist, fahren Sie mit [Schritt 2: Code hinzufügen](#sample-nodejs-code) fort.
1. Führen Sie den Befehl ** `yum update` ** für (Amazon Linux) oder ** `apt update` ** für (Ubuntu Server) aus, um sicherzustellen, dass die Sicherheitsupdates und Fehlerbehebungen auf dem aktuellen Stand sind.
Für Amazon Linux:
```
sudo yum -y update
```
Für Ubuntu Server:
```
sudo apt update
```
1. Um Node.js zu installieren, führen Sie zunächst diesen Befehl aus, um Node Version Manager (nvm) herunterzuladen. (nvm ist ein einfaches Bash-Shell-Skript, das für die Installation und Verwaltung von Versionen von Node.js nützlich ist. Weitere Informationen finden Sie unter [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md) auf der GitHub Website.)
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
```
1. Um mit nvm zu beginnen, schließen Sie entweder die Terminalsitzung und starten Sie sie erneut oder verwenden Sie die Datei `~/.bashrc`, die die Befehle zum Laden von nvm enthält.
```
. ~/.bashrc
```
1. Führen Sie diesen Befehl aus, um Node.js 16 auf Amazon Linux 2, Amazon Linux 1 und Ubuntu 18.04 zu installieren. Amazon Linux 1- und Ubuntu 18.04-Instances unterstützen nur Node.js bis v16.
```
nvm install 16
```
Führen Sie diesen Befehl aus, um die neueste Version von Node.js auf Amazon Linux 2023 und Ubuntu 22.04 zu installieren:
```
nvm install --lts && nvm alias default lts/*
```
**Anmerkung**
Auf dem neuesten AL2 AWS Cloud9 023-Image ist Node.js 20 installiert, und auf dem neuesten Amazon Linux AWS Cloud9 2-Image ist Node.js 18 installiert. Wenn Sie Node.js 18 AWS Cloud9 manuell auf Amazon Linux 2 installieren möchten, führen Sie den folgenden Befehl im AWS Cloud9 IDE-Terminal aus:
```
C9_NODE_INSTALL_DIR=~/.nvm/versions/node/v18.17.1
C9_NODE_URL=https://d3kgj69l4ph6w4.cloudfront.net/static/node-amazon/node-v18.17.1-linux-x64.tar.gz
mkdir -p $C9_NODE_INSTALL_DIR
curl -fSsl $C9_NODE_URL | tar xz --strip-components=1 -C "$C9_NODE_INSTALL_DIR"
nvm alias default v18.17.1
nvm use default
echo -e 'nvm use default' >> ~/.bash_profile
```
## Schritt 2: Code hinzufügen
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit diesem Inhalt und speichern Sie die Datei unter dem Namen`hello.js`. (Um eine Datei zu erstellen, wählen Sie in der Menüleiste **File (Datei)**, **New File (Neue Datei)** aus. Um die Datei zu speichern, wählen Sie **Datei**, **Save (Speichern)**.)
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
var sum = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## Schritt 3: Ausführen des Codes
1. Wählen Sie in der AWS Cloud9 IDE in der Menüleiste „**Ausführen**“, „**Konfigurationen ausführen**“, „**Neue Ausführungskonfiguration**“.
1. Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] - Leerlauf)** die Option **Runner: Auto** und dann **Node.js** aus.
1. Geben Sie für **Command (Befehl)** `hello.js 5 9` ein. Im Code stellen `5` `process.argv[2]` und `9` `process.argv[3]` dar. (`process.argv[0]` steht für den Namen der Laufzeit (`node`), und `process.argv[1]` für den Namen der Datei (`hello.js`).)
1. Klicken Sie auf **Run (Ausführen)** und vergleichen Sie die Ausgabe.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Ausgabe von Node.js nach dem Ausführen des Codes in der AWS Cloud9 IDE\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## Schritt 4: Installieren und konfigurieren Sie das AWS SDK für JavaScript in Node.js
Wenn Sie Node.js -Skripts in ausführen AWS Cloud9, können Sie zwischen dem AWS SDK für JavaScript Version 3 (V3) und dem älteren AWS SDK für JavaScript Version 2 (V2) wählen. Wie bei Version 2 ermöglicht Ihnen V3 die einfache Arbeit mit Amazon Web Services, wurde jedoch bereits integriert TypeScript und bietet mehrere häufig nachgefragte Funktionen, wie z. B. modularisierte Pakete.
------
#### [ AWS SDK for JavaScript (V3) ]
Sie können dieses Beispiel erweitern, um das AWS SDK für JavaScript in Node.js zu verwenden, um einen Amazon S3 S3-Bucket zu erstellen, Ihre verfügbaren Buckets aufzulisten und dann den gerade erstellten Bucket zu löschen.
In diesem Schritt installieren und konfigurieren Sie das Amazon S3 S3-Serviceclient-Modul des AWS SDK für JavaScript in Node.js, das eine bequeme Möglichkeit bietet, über Ihren JavaScript Code mit dem Amazon S3 AWS S3-Service zu interagieren.
Wenn Sie andere AWS Dienste verwenden möchten, müssen Sie sie separat installieren. Weitere Informationen zur Installation von AWS Modulen finden Sie [im *AWS Developer Guide (V3)*.](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/working-with-services) Informationen zu den ersten Schritten mit Node.js und AWS SDK für JavaScript (V3) finden [Sie unter Erste Schritte mit Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure) im *AWS SDK for JavaScript Developers Guide (V3)*.
Nachdem Sie das AWS SDK für JavaScript in Node.js installiert haben, müssen Sie die Verwaltung der Anmeldeinformationen in Ihrer Umgebung einrichten. Das AWS SDK für JavaScript in Node.js benötigt diese Anmeldeinformationen, um mit AWS Diensten zu interagieren.
**Um das AWS SDK für JavaScript in Node.js zu installieren**
Verwenden Sie npm, um den Befehl ** `install` ** auszuführen.
```
npm install @aws-sdk/client-s3
```
Weitere Informationen finden Sie unter [Installieren des SDK für JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html#installing-jssdk) im *AWS SDK für JavaScript Entwicklerhandbuch*.
**So richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein**
Jedes Mal, wenn Sie das AWS SDK für JavaScript in Node.js verwenden, um einen AWS Dienst aufzurufen, müssen Sie beim Aufruf eine Reihe von Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob das AWS SDK für JavaScript in Node.js über die entsprechenden Berechtigungen verfügt, um diesen Aufruf durchzuführen. Wenn die Anmeldeinformationen nicht die entsprechenden Berechtigungen haben, schlägt der Aufruf fehl.
In diesem Schritt speichern Sie Ihre Anmeldeinformationen innerhalb der Umgebung. Folgen Sie dazu den Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md) und kehren Sie dann zu diesem Thema zurück.
Weitere Informationen finden Sie unter [Festlegen von Anmeldeinformationen in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) im*AWS SDK für JavaScript Entwicklerhandbuch*.
------
#### [ AWS SDK for JavaScript (V2) ]
Sie können dieses Beispiel erweitern, um das AWS SDK für JavaScript in Node.js zu verwenden, um einen Amazon S3 S3-Bucket zu erstellen, Ihre verfügbaren Buckets aufzulisten und dann den gerade erstellten Bucket zu löschen.
In diesem Schritt installieren und konfigurieren Sie das AWS SDK für JavaScript in Node.js, das eine bequeme Möglichkeit bietet, über Ihren JavaScript Code mit AWS Diensten wie Amazon S3 zu interagieren. Nachdem Sie das AWS SDK für JavaScript in Node.js installiert haben, müssen Sie die Verwaltung der Anmeldeinformationen in Ihrer Umgebung einrichten. Das AWS SDK für JavaScript in Node.js benötigt diese Anmeldeinformationen, um mit AWS Diensten zu interagieren.
**Um das AWS SDK für JavaScript in Node.js zu installieren**
Verwenden Sie npm, um den Befehl ** `install` ** auszuführen.
```
npm install aws-sdk
```
Weitere Informationen finden Sie unter [Installieren des SDK für JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) im *AWS SDK für JavaScript Entwicklerhandbuch*.
**So richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein**
Jedes Mal, wenn Sie das AWS SDK für JavaScript in Node.js verwenden, um einen AWS Dienst aufzurufen, müssen Sie beim Aufruf eine Reihe von Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob das AWS SDK für JavaScript in Node.js über die entsprechenden Berechtigungen verfügt, um diesen Aufruf durchzuführen. Wenn die Anmeldeinformationen nicht die entsprechenden Berechtigungen haben, schlägt der Aufruf fehl.
In diesem Schritt speichern Sie Ihre Anmeldeinformationen innerhalb der Umgebung. Folgen Sie dazu den Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md) und kehren Sie dann zu diesem Thema zurück.
Weitere Informationen finden Sie unter [Festlegen von Anmeldeinformationen in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html) im*AWS SDK für JavaScript Entwicklerhandbuch*.
------
## Schritt 5: AWS SDK-Code hinzufügen
------
#### [ AWS SDK for JavaScript (V3) ]
In diesem Schritt fügen Sie weiteren Code hinzu. Dieses Mal für die Interaktion mit Amazon S3, um einen Bucket zu erstellen, Ihre verfügbaren Buckets aufzulisten und anschließend den Bucket zu löschen, den Sie zuvor erstellt haben. Sie führen diesen Code später aus.
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit diesem Inhalt und speichern Sie die Datei unter dem Namen`s3.js`.
```
import {
CreateBucketCommand,
DeleteBucketCommand,
ListBucketsCommand,
S3Client,
} from "@aws-sdk/client-s3";
const wait = async (milliseconds) => {
return new Promise((resolve) => setTimeout(resolve, milliseconds));
};
export const main = async () => {
const client = new S3Client({});
const now = Date.now();
const BUCKET_NAME = `easy-bucket-${now.toString()}`;
const createBucketCommand = new CreateBucketCommand({ Bucket: BUCKET_NAME });
const listBucketsCommand = new ListBucketsCommand({});
const deleteBucketCommand = new DeleteBucketCommand({ Bucket: BUCKET_NAME });
try {
console.log(`Creating bucket ${BUCKET_NAME}.`);
await client.send(createBucketCommand);
console.log(`${BUCKET_NAME} created`);
await wait(2000);
console.log(`Here are your buckets:`);
const { Buckets } = await client.send(listBucketsCommand);
Buckets.forEach((bucket) => {
console.log(` • ${bucket.Name}`);
});
await wait(2000);
console.log(`Deleting bucket ${BUCKET_NAME}.`);
await client.send(deleteBucketCommand);
console.log(`${BUCKET_NAME} deleted`);
} catch (err) {
console.error(err);
}
};
main();
```
------
#### [ AWS SDK for JavaScript (V2) ]
In diesem Schritt fügen Sie weiteren Code hinzu. Dieses Mal für die Interaktion mit Amazon S3, um einen Bucket zu erstellen, Ihre verfügbaren Buckets aufzulisten und anschließend den Bucket zu löschen, den Sie zuvor erstellt haben. Sie führen diesen Code später aus.
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit diesem Inhalt und speichern Sie die Datei unter dem Namen`s3.js`.
```
if (process.argv.length < 4) {
console.log(
"Usage: node s3.js \n" +
"Example: node s3.js my-test-bucket us-east-2"
);
process.exit(1);
}
var AWS = require("aws-sdk"); // To set the AWS credentials and region.
var async = require("async"); // To call AWS operations asynchronously.
AWS.config.update({
region: region,
});
var s3 = new AWS.S3({ apiVersion: "2006-03-01" });
var bucket_name = process.argv[2];
var region = process.argv[3];
var create_bucket_params = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region,
},
};
var delete_bucket_params = { Bucket: bucket_name };
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback) {
s3.listBuckets(function (err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (var i = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback) {
console.log("\nCreating a bucket named " + bucket_name + "...\n");
s3.createBucket(create_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback) {
console.log("\nDeleting the bucket named " + bucket_name + "...\n");
s3.deleteBucket(delete_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets,
]);
```
------
## Schritt 6: Führen Sie den AWS SDK-Code aus
1. Ermöglichen Sie dem Code das Aufrufen von Amazon S3-Operationen, indem Sie npm verwenden, um den Befehl ** `install` ** auszuführen.
```
npm install async
```
1. Wählen Sie in der Menüleiste der AWS Cloud9 IDE die Optionen **Ausführen**, **Konfigurationen ausführen**, **Neue Ausführungskonfiguration aus**.
1. Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] - Leerlauf)** die Option **Runner: Auto** und dann **Node.js** aus.
1. Wenn Sie AWS SDK für JavaScript (V3) verwenden, geben Sie den **Befehlstyp ein**`s3.js`. Wenn Sie AWS SDK für Javascript (v2) verwenden`s3.js my-test-bucket us-east-2`, geben Sie als **Befehl** den Namen des Buckets ein, den Sie erstellen und dann löschen möchten, sowie `us-east-2` die ID der AWS Region, in der Sie den Bucket erstellen möchten. `my-test-bucket` Weitere Informationen IDs finden Sie unter [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) in der *Allgemeine Amazon Web Services-Referenz*.
**Anmerkung**
Amazon S3 S3-Bucket-Namen müssen überall eindeutig sein AWS— nicht nur in Ihrem AWS Konto.
1. Klicken Sie auf **Run (Ausführen)** und vergleichen Sie die Ausgabe.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Schritt 7: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie die Umgebung löschen. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# PHP-Tutorial für AWS Cloud9
In diesem Tutorial können Sie einige PHP-Skripte in einer AWS Cloud9 Entwicklungsumgebung ausführen.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies zu Gebühren für Ihr AWS Konto führen. Dies umfasst mögliche Kosten für Services wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-php-prereqs)
+ [Schritt 1: Installieren der erforderlichen Tools](#sample-php-install)
+ [Schritt 2: Code hinzufügen](#sample-php-code)
+ [Schritt 3: Ausführen des Codes](#sample-php-run)
+ [Schritt 4: Installieren und konfigurieren Sie den AWS SDK für PHP](#sample-php-sdk)
+ [Schritt 5: AWS SDK-Code hinzufügen](#sample-php-sdk-code)
+ [Schritt 6: Führen Sie den AWS SDK-Code aus](#sample-php-sdk-run)
+ [Schritt 7: Bereinigen](#sample-php-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren der erforderlichen Tools
In diesem Schritt installieren Sie PHP, das erforderlich ist, um dieses Beispiel auszuführen.
**Anmerkung**
Im folgenden Verfahren wird nur PHP installiert. Informationen zur Installation verwandter Tools wie eines Apache-Webservers und einer MySQL-Datenbank finden Sie unter [Tutorial: Installation eines LAMP-Webservers auf Amazon Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-LAMP.html) im *Amazon EC2-Benutzerhandbuch*.
1. Vergewissern Sie sich in einer Terminalsitzung in der AWS Cloud9 IDE, ob PHP bereits installiert ist, indem Sie den **`php --version`**Befehl ausführen. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus. Bei Erfolg enthält die Ausgabe die PHP-Versionsnummer. Wenn PHP installiert ist, fahren Sie mit [Schritt 2: Code hinzufügen](#sample-php-code) fort.
1. Führen Sie den Befehl ** `yum update` ** für (Amazon Linux) oder ** `apt update` ** für (Ubuntu Server) aus, um sicherzustellen, dass die Sicherheitsupdates und Fehlerbehebungen auf dem aktuellen Stand sind.
Für Amazon Linux 2 und Amazon Linux
```
sudo yum -y update
```
Für Ubuntu Server:
```
sudo apt update
```
1. Installieren Sie PHP, indem Sie den Befehl ** `install` ** ausführen.
Für Amazon Linux 2:
```
sudo amazon-linux-extras install -y php7.2
```
Für Amazon Linux:
```
sudo yum -y install php72
```
**Anmerkung**
Sie können Ihre Version von Amazon Linux mit dem folgenden Befehl anzeigen.
```
cat /etc/system-release
```
Für Ubuntu Server:
```
sudo apt install -y php php-xml
```
Weitere Informationen finden Sie unter [Installation and Configuration](http://php.net/manual/en/install.php) auf der PHP-Website.
## Schritt 2: Code hinzufügen
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit diesem Inhalt und speichern Sie die Datei unter dem Namen`hello.php`. (Um eine Datei zu erstellen, wählen Sie in der Menüleiste** File (Datei)**, **New File (Neue Datei)**aus. Um die Datei zu speichern, wählen Sie **File**, **Save (Speichern)**, geben Sie `hello.php` für **File name (Dateiname)** ein und wählen Sie anschließend **Save**.)
```
```
**Anmerkung**
Der zuvor genannten Code greift nicht auf externe Dateien zu. Wenn Sie jedoch jemals andere PHP-Dateien in Ihre Datei aufnehmen oder benötigen und diese Dateien für die Codevervollständigung während der Eingabe verwenden AWS Cloud9 möchten, aktivieren Sie die Einstellung **Projekt, PHP-Unterstützung, PHP-Codevervollständigung aktivieren** in den **Einstellungen** und fügen Sie dann die Pfade zu diesen Dateien zur Einstellung **Projekt, PHP-Unterstützung, PHP-Vervollständigung einschließen Pfade** hinzu. (Um Ihre Einstellungen anzuzeigen und zu ändern **AWS Cloud9, wählen Sie in der Menüleiste „Einstellungen**“.)
## Schritt 3: Ausführen des Codes
1. Wählen Sie in der Menüleiste der AWS Cloud9 IDE die Optionen **Ausführen**, **Konfigurationen ausführen**, **Neue Ausführungskonfiguration aus**.
1. Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] – Leerlauf)** die Option **Runner: Auto** und dann **PHP (cli)** aus.
1. Geben Sie für **Command (Befehl)** `hello.php 5 9` ein. Im Code stehen `5` für `$argv[1]` und `9` für `$argv[2]`. (`$argv[0]` steht für den Namen der Datei (`hello.php`).)
1. Klicken Sie auf **Run (Ausführen)** und vergleichen Sie die Ausgabe.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Ausgabe der Ausführung des PHP-Codes in der AWS Cloud9 IDE\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/images/ide-php-simple.png)
## Schritt 4: Installieren und konfigurieren Sie den AWS SDK für PHP
Sie können dieses Beispiel erweitern, um mit dem einen Amazon S3 S3-Bucket AWS SDK für PHP zu erstellen, Ihre verfügbaren Buckets aufzulisten und dann den gerade erstellten Bucket zu löschen.
In diesem Schritt installieren und konfigurieren Sie den AWS SDK für PHP, der eine bequeme Möglichkeit bietet, mit AWS Diensten wie Amazon S3 von Ihrem PHP-Code aus zu interagieren. Bevor Sie das installieren können AWS SDK für PHP, sollten Sie [Composer](https://getcomposer.org/) installieren. Nach der AWS SDK für PHP Installation von müssen Sie die Verwaltung der Anmeldeinformationen in Ihrer Umgebung einrichten. The AWS SDK für PHP benötigt diese Anmeldeinformationen, um mit AWS Diensten zu interagieren.
### So installieren Sie Composer
Führen Sie den ** `curl` ** -Befehl mit den Optionen „silent“ (`-s`) und „show error“ (`-S`) aus, indem Sie das Composer-Installationsprogramm in eine PHP-Archivdatei überleiten, die gemeinhin `composer.phar` genannt wird.
```
curl -sS https://getcomposer.org/installer | php
```
### Um das zu installieren AWS SDK für PHP
Installieren Sie für Ubuntu Server zusätzliche Pakete, die Composer zur Installation der AWS SDK für PHP benötigt.
```
sudo apt install -y php-xml php-curl
```
Verwenden Sie für Amazon Linux oder Ubuntu Server den Befehl **php**, um das Composer-Installationsprogramm auszuführen und die AWS SDK für PHP zu installieren.
```
php composer.phar require aws/aws-sdk-php
```
Mit diesem Befehl werden mehrere Ordner und Dateien in Ihrer Umgebung; erstellt. Die primäre Datei, die Sie verwenden, ist `autoload.php`. Sie befindet sich im `vendor`-Ordner in Ihrer Umgebung.
**Anmerkung**
Nach der Installation kann der Composer vorschlagen, dass Sie zusätzliche Abhängigkeiten installieren. Sie können dies mit einem Befehl wie dem folgenden tun, der die Liste der zu installierenden Abhängigkeiten angibt. Der folgende Befehl weist den Composer beispielsweise an, die aufgeführten Abhängigkeiten zu installieren.
```
php composer.phar require psr/log ext-curl doctrine/cache aws/aws-php-sns-message-validator
```
Weitere Informationen finden Sie unter [Installation](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/installation.html) im *AWS SDK für PHP Entwicklerhandbuch*.
### So richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein
Jedes Mal, wenn Sie den verwenden, AWS SDK für PHP um einen AWS Dienst aufzurufen, müssen Sie beim Anruf eine Reihe von Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob der AWS SDK für PHP über die entsprechenden Berechtigungen verfügt, um diesen Anruf zu tätigen. Wenn die Anmeldeinformationen nicht die entsprechenden Berechtigungen haben, schlägt der Aufruf fehl.
In diesem Schritt speichern Sie Ihre Anmeldeinformationen innerhalb der Umgebung. Folgen Sie dazu den Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md) und kehren Sie dann zu diesem Thema zurück.
Weitere Informationen finden Sie im Bereich „Creating a client“unter [Grundlegende Nutzung](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/basic-usage.html) im *AWS SDK für PHP -Entwicklerhandbuch*.
## Schritt 5: AWS SDK-Code hinzufügen
In diesem Schritt fügen Sie weiteren Code hinzu. Dieses Mal für die Interaktion mit Amazon S3, um einen Bucket zu erstellen, Ihre verfügbaren Buckets aufzulisten und anschließend den Bucket zu löschen, den Sie zuvor erstellt haben. Sie führen diesen Code später aus.
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit diesem Inhalt und speichern Sie die Datei unter dem Namen`s3.php`.
```
\n" .
"Example: php s3.php America/Los_Angeles my-test-bucket us-east-2");
}
$timeZone = $argv[1];
$bucketName = $argv[2];
$region = $argv[3];
date_default_timezone_set($timeZone);
$s3 = new Aws\S3\S3Client([
'region' => $region,
'version' => '2006-03-01'
]);
# Lists all of your available buckets in this AWS Region.
function listMyBuckets($s3)
{
print("\nMy buckets now are:\n");
$promise = $s3->listBucketsAsync();
$result = $promise->wait();
foreach ($result['Buckets'] as $bucket) {
print("\n");
print($bucket['Name']);
}
}
listMyBuckets($s3);
# Create a new bucket.
print("\n\nCreating a new bucket named '$bucketName'...\n");
try {
$promise = $s3->createBucketAsync([
'Bucket' => $bucketName,
'CreateBucketConfiguration' => [
'LocationConstraint' => $region
]
]);
$promise->wait();
} catch (Exception $e) {
if ($e->getCode() == 'BucketAlreadyExists') {
exit("\nCannot create the bucket. " .
"A bucket with the name '$bucketName' already exists. Exiting.");
}
}
listMyBuckets($s3);
# Delete the bucket you just created.
print("\n\nDeleting the bucket named '$bucketName'...\n");
$promise = $s3->deleteBucketAsync([
'Bucket' => $bucketName
]);
$promise->wait();
listMyBuckets($s3);
?>
```
## Schritt 6: Führen Sie den AWS SDK-Code aus
1. Wählen Sie in der Menüleiste der AWS Cloud9 IDE die Optionen **Ausführen**, **Konfigurationen ausführen**, **Neue Ausführungskonfiguration aus**.
1. Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] – Leerlauf)** die Option **Runner: Auto** und dann **PHP (cli)** aus.
1. Geben Sie für **Command (Befehl)** `s3.php America/Los_Angeles my-test-bucket us-east-2` ein, wobei:
+ `America/Los_Angeles` Ihre Standardzeitzonen-ID ist. Weitere Informationen IDs finden Sie auf [der PHP-Website unter Liste der unterstützten Zeitzonen](http://php.net/manual/en/timezones.php).
+ `my-test-bucket` der Name des Buckets ist, den Sie erstellen und anschließend löschen möchten.
**Anmerkung**
Amazon S3 S3-Bucket-Namen müssen überall eindeutig sein AWS— nicht nur in Ihrem AWS Konto.
+ `us-east-2`ist die ID der AWS Region, in der Sie den Bucket erstellen möchten. Weitere Informationen IDs finden Sie unter [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) in der *Allgemeine Amazon Web Services-Referenz*.
1. Klicken Sie auf **Run (Ausführen)** und vergleichen Sie die Ausgabe.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Schritt 7: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie die Umgebung löschen. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
### Behebung von Problemen mit PHP Runner für AWS Cloud9
Falls Sie Probleme mit dem PHP-CLI-Runner haben, müssen Sie sicherstellen, dass der Runner auf PHP eingestellt und der Debugger-Modus aktiviert ist.
# AWS SDK for Ruby in AWS Cloud9
Informationen zur Verwendung AWS Cloud9 mit dem AWS SDK for Ruby finden Sie unter [Using AWS Cloud9 with the AWS SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html) im *AWS SDK for Ruby Developer Guide*.
**Anmerkung**
Wenn Sie diesem Tutorial folgen, kann dies zu Belastungen Ihres AWS Kontos führen. Dazu gehören mögliche Gebühren für Dienste wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [ EC2 Amazon-Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3-Preise](https://aws.amazon.com/s3/pricing/).
# Gehe zum Tutorial für AWS Cloud9
In diesem Tutorial können Sie Go-Code in einer AWS Cloud9 Entwicklungsumgebung ausführen.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies zu Gebühren für Ihr AWS Konto führen. Dies umfasst mögliche Kosten für Services wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-go-prereqs)
+ [Schritt 1: Installieren der erforderlichen Tools](#sample-go-install)
+ [Schritt 2: Code hinzufügen](#sample-go-code)
+ [Schritt 3: Ausführen des Codes](#sample-go-run)
+ [Schritt 4: Installieren und konfigurieren Sie den AWS SDK für Go](#sample-go-sdk)
+ [Schritt 5: AWS SDK-Code hinzufügen](#sample-go-sdk-code)
+ [Schritt 6: Führen Sie den AWS SDK-Code aus](#sample-go-sdk-run)
+ [Schritt 7: Bereinigen](#sample-go-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren der erforderlichen Tools
In diesem Schritt installieren und konfigurieren Sie Go, das erforderlich ist, um dieses Beispiel auszuführen.
1. Vergewissern Sie sich in einer Terminalsitzung in der AWS Cloud9 IDE, ob Go bereits installiert ist, indem Sie den **`go version`**Befehl ausführen. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus. Bei Erfolg enthält die Ausgabe die Go-Versionsnummer. Andernfalls wird eine Fehlermeldung ausgegeben. Wenn Go installiert ist, gehen Sie weiter zu [Schritt 2: Code hinzufügen](#sample-go-code).
1. Führen Sie den Befehl ** `yum update` ** für (Amazon Linux) oder ** `apt update` ** für (Ubuntu Server) aus, um sicherzustellen, dass die Sicherheitsupdates und Bugfixes auf dem aktuellen Stand sind.
Für Amazon Linux:
```
sudo yum -y update
```
Für Ubuntu Server:
```
sudo apt update
```
1. Führen Sie zum Installieren von Go nacheinander die folgenden Befehle aus.
```
wget https://storage.googleapis.com/golang/go1.9.3.linux-amd64.tar.gz # Download the Go installer.
sudo tar -C /usr/local -xzf ./go1.9.3.linux-amd64.tar.gz # Install Go.
rm ./go1.9.3.linux-amd64.tar.gz # Delete the installer.
```
Bei den vorangegangenen Befehlen wird die letzte stabile Version von Go zum Erstellungszeitpunkt dieses Themas angenommen. Weitere Informationen finden Sie unter [Downloads](https://golang.org/dl/) auf der Website der Go-Programmiersprache.
1. Fügen Sie den Pfad zur Go-Binärdatei wie folgt zu Ihrer Umgebungsvariablen `PATH` hinzu.
1. Öffnen Sie Ihre Shell-Profildatei (z. B. `~/.bashrc`) zur Bearbeitung.
1. Geben Sie am Ende dieser Codezeile Folgendes ein. Der Code sollte nun so aussehen.
```
PATH=$PATH:/usr/local/go/bin
```
1. Speichern Sie die Datei.
1. Führen sie die Datei `~/.bashrc` aus, damit die Go-Binärdatei, auf die Sie gerade verwiesen haben, im Terminal gefunden werden kann.
```
. ~/.bashrc
```
1. Überprüfen Sie mit dem Befehl ** `go version` **, dass Go erfolgreich installiert und konfiguriert wurde. Bei Erfolg enthält die Ausgabe die Go-Versionsnummer.
## Schritt 2: Code hinzufügen
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit diesem Inhalt und speichern Sie die Datei unter dem Namen`hello.go`. (Um eine Datei zu erstellen, wählen Sie in der Menüleiste **File (Datei)**, **New File (Neue Datei)** aus. Um die Datei zu speichern, wählen Sie **Datei**, **Save (Speichern)**.)
```
package main
import (
"fmt"
"os"
"strconv"
)
func main() {
fmt.Printf("Hello, World!\n")
fmt.Printf("The sum of 2 and 3 is 5.\n")
first, _ := strconv.Atoi(os.Args[1])
second, _ := strconv.Atoi(os.Args[2])
sum := first + second
fmt.Printf("The sum of %s and %s is %s.",
os.Args[1], os.Args[2], strconv.Itoa(sum))
}
```
## Schritt 3: Ausführen des Codes
1. Wählen Sie in der Menüleiste der AWS Cloud9 IDE die Optionen **Ausführen**, **Konfigurationen ausführen**, **Neue Ausführungskonfiguration aus**.
1. Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] – Leerlauf)** die Option **Runner: Auto** und dann **Go** aus.
**Anmerkung**
Wenn **Go** nicht verfügbar ist, können Sie einen benutzerdefinierten Runner für Go erstellen.
Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] - Leerlauf)** die Option **Runner: Auto** und dann **New Runner (Neuer Runner)** aus.
Ersetzen Sie auf der Registerkarte **My Runner.run (Mein Runner.run)** den Inhalt der Registerkarte durch diesen Code.
```
{
"cmd" : ["go", "run", "$file", "$args"],
"info" : "Running $project_path$file_name...",
"selector" : "source.go"
}
```
Klicken Sie in der Menüleiste auf **File (Datei)**, **Save As (Speichern unter)** und speichern Sie die Datei unter dem Namen `Go.run` im Verzeichnis `/.c9/runners`.
Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] – Leerlauf)** die Option **Runner: Auto** und dann **Go** aus.
Klicken Sie auf die Registerkarte **hello.go**, um sie zu aktivieren.
1. Geben Sie für **Command (Befehl)** `hello.go 5 9` ein. Im Code repräsentiert `5` `os.Args[1]` und `9` repräsentiert `os.Args[2]`.
![\[Ausgabe der Ausführung des Go-Codes in der AWS Cloud9 IDE\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/images/ide-go-simple.png)
1. Klicken Sie auf **Run (Ausführen)** und vergleichen Sie die Ausgabe.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Schritt 4: Installieren und konfigurieren Sie den AWS SDK für Go
Sie können dieses Beispiel erweitern, um mit dem einen Amazon S3 S3-Bucket AWS SDK für Go zu erstellen, Ihre verfügbaren Buckets aufzulisten und dann den gerade erstellten Bucket zu löschen.
In diesem Schritt installieren und konfigurieren Sie den AWS SDK für Go, der eine bequeme Möglichkeit bietet, mit AWS Diensten wie Amazon S3 über Ihren Go-Code zu interagieren. Bevor Sie das AWS SDK für Go installieren, müssen Sie Ihre Umgebungsvariable `GOPATH` konfigurieren. Nach der Installation des AWS SDK für Go und der Konfiguration der `GOPATH`-Umgebungsvariablen müssen Sie die Verwaltung von Anmeldeinformationen in Ihrer Umgebung einrichten. The AWS SDK für Go benötigt diese Anmeldeinformationen, um mit AWS Diensten zu interagieren.
### So konfigurieren Sie Ihre GOPATH-Umgebungsvariable
1. Öffnen Sie Ihre `~/.bashrc`-Datei zur Bearbeitung.
1. Geben Sie hinter der letzten Zeile in der Datei den folgenden Code ein.
```
GOPATH=~/environment/go
export GOPATH
```
1. Speichern Sie die Datei.
1. Führen sie die Datei `~/.bashrc` aus, damit die `GOPATH`-Umgebungsvariable, auf die Sie gerade verwiesen haben, im Terminal gefunden werden kann.
```
. ~/.bashrc
```
1. Führen Sie den Befehl `GOPATH` ** `echo $GOPATH` aus, um sicherzustellen, dass die **-Umgebungsvariable erfolgreich konfiguriert wurde. Bei Erfolg wird `/home/ec2-user/environment/go` oder `/home/ubuntu/environment/go` ausgegeben.
### Um das zu installieren AWS SDK für Go
Führen Sie den **`go get`**Befehl aus und geben Sie den Speicherort der AWS SDK für Go Quelle an.
```
go get -u github.com/aws/aws-sdk-go/...
```
Go installiert die AWS SDK für Go Quelle an dem in Ihrer `GOPATH` Umgebungsvariablen angegebenen Speicherort, dem `go` Ordner in Ihrer Umgebung.
### So richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein
Jedes Mal, wenn Sie den verwenden, AWS SDK für Go um einen AWS Dienst aufzurufen, müssen Sie bei dem Anruf eine Reihe von Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob der AWS SDK für Go über die entsprechenden Berechtigungen verfügt, um diesen Anruf zu tätigen. Wenn die Anmeldeinformationen nicht die entsprechenden Berechtigungen haben, schlägt der Aufruf fehl.
In diesem Schritt speichern Sie Ihre Anmeldeinformationen innerhalb der Umgebung. Befolgen Sie stattdessen die Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md) und kehren Sie dann zu diesem Thema zurück.
Weitere Informationen finden Sie unter [Festlegen von Anmeldeinformationen](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials) im*AWS SDK für Go Entwicklerhandbuch*.
## Schritt 5: AWS SDK-Code hinzufügen
In diesem Schritt fügen Sie weiteren Code hinzu. Dieses Mal für die Interaktion mit Amazon S3, um einen Bucket zu erstellen, Ihre verfügbaren Buckets aufzulisten und anschließend den Bucket zu löschen, den Sie zuvor erstellt haben. Sie führen diesen Code später aus.
Erstellen Sie in der AWS Cloud9 IDE eine Datei mit diesem Inhalt und speichern Sie die Datei unter dem Namen`s3.go`.
```
package main
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
)
func main() {
if len(os.Args) < 3 {
fmt.Printf("Usage: go run s3.go \n" +
"Example: go run s3.go my-test-bucket us-east-2\n")
os.Exit(1)
}
sess := session.Must(session.NewSessionWithOptions(session.Options{
SharedConfigState: session.SharedConfigEnable,
}))
svc := s3.New(sess, &aws.Config{
Region: aws.String(os.Args[2]),
})
listMyBuckets(svc)
createMyBucket(svc, os.Args[1], os.Args[2])
listMyBuckets(svc)
deleteMyBucket(svc, os.Args[1])
listMyBuckets(svc)
}
// List all of your available buckets in this AWS Region.
func listMyBuckets(svc *s3.S3) {
result, err := svc.ListBuckets(nil)
if err != nil {
exitErrorf("Unable to list buckets, %v", err)
}
fmt.Println("My buckets now are:\n")
for _, b := range result.Buckets {
fmt.Printf(aws.StringValue(b.Name) + "\n")
}
fmt.Printf("\n")
}
// Create a bucket in this AWS Region.
func createMyBucket(svc *s3.S3, bucketName string, region string) {
fmt.Printf("\nCreating a new bucket named '" + bucketName + "'...\n\n")
_, err := svc.CreateBucket(&s3.CreateBucketInput{
Bucket: aws.String(bucketName),
CreateBucketConfiguration: &s3.CreateBucketConfiguration{
LocationConstraint: aws.String(region),
},
})
if err != nil {
exitErrorf("Unable to create bucket, %v", err)
}
// Wait until bucket is created before finishing
fmt.Printf("Waiting for bucket %q to be created...\n", bucketName)
err = svc.WaitUntilBucketExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// Delete the bucket you just created.
func deleteMyBucket(svc *s3.S3, bucketName string) {
fmt.Printf("\nDeleting the bucket named '" + bucketName + "'...\n\n")
_, err := svc.DeleteBucket(&s3.DeleteBucketInput{
Bucket: aws.String(bucketName),
})
if err != nil {
exitErrorf("Unable to delete bucket, %v", err)
}
// Wait until bucket is deleted before finishing
fmt.Printf("Waiting for bucket %q to be deleted...\n", bucketName)
err = svc.WaitUntilBucketNotExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// If there's an error, display it.
func exitErrorf(msg string, args ...interface{}) {
fmt.Fprintf(os.Stderr, msg+"\n", args...)
os.Exit(1)
}
```
## Schritt 6: Führen Sie den AWS SDK-Code aus
1. Wählen Sie in der Menüleiste der AWS Cloud9 IDE die Optionen **Ausführen**, **Konfigurationen ausführen**, **Neue Ausführungskonfiguration aus**.
1. Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] – Leerlauf)** die Option **Runner: Auto** und dann **Go** aus.
1. Geben Sie unter **Command** den Namen des Buckets ` YOUR_BUCKET_NAME ` ein`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `, den Sie erstellen und dann löschen möchten, und ` THE_AWS_REGION ` geben Sie die ID der AWS Region ein, in der Sie den Bucket erstellen möchten. Verwenden Sie zum Beispiel für die Region "USA Ost (Ohio)" `us-east-2`. Weitere Informationen IDs finden Sie unter [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) in der *Allgemeine Amazon Web Services-Referenz*.
**Anmerkung**
Amazon S3 S3-Bucket-Namen müssen überall eindeutig sein AWS— nicht nur in Ihrem AWS Konto.
1. Klicken Sie auf **Run (Ausführen)** und vergleichen Sie die Ausgabe.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Schritt 7: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie die Umgebung löschen. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# TypeScript Tutorial für AWS Cloud9
Dieses Tutorial zeigt Ihnen, wie Sie TypeScript in einer AWS Cloud9 Entwicklungsumgebung damit arbeiten.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies zu Belastungen Ihres AWS Kontos führen. Dies umfasst mögliche Kosten für Services wie Amazon EC2 und Amazon S3. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) und [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Voraussetzungen](#sample-typescript-prereqs)
+ [Schritt 1: Installieren der erforderlichen Tools](#sample-typescript-install)
+ [Schritt 2: Code hinzufügen](#sample-typescript-code)
+ [Schritt 3: Ausführen des Codes](#sample-typescript-run)
+ [Schritt 4: Installieren und konfigurieren Sie das AWS SDK für JavaScript in Node.js](#sample-typescript-sdk)
+ [Schritt 5: AWS SDK-Code hinzufügen](#sample-typescript-sdk-code)
+ [Schritt 6: Führen Sie den AWS SDK-Code aus](#sample-typescript-sdk-run)
+ [Schritt 7: Bereinigen](#sample-typescript-clean-up)
## Voraussetzungen
Bevor Sie dieses Beispiel verwenden, stellen Sie sicher, dass Ihre Einrichtung die folgenden Anforderungen erfüllt:
+ **Sie müssen über eine bestehende AWS Cloud9 EC2-Entwicklungsumgebung verfügen.** Bei diesem Beispiel wird davon ausgegangen, dass Sie bereits eine EC2-Umgebung eingerichtet haben, die mit einer Amazon-EC2-Instance verbunden ist, die Amazon Linux oder Ubuntu Server ausführt. Wenn Sie ein andere Art von Umgebung oder ein anderes Betriebssystem verwenden, müssen Sie die Anweisungen dieses Beispiels zum Einrichten zugehöriger Tools möglicherweise anpassen. Weitere Informationen finden Sie unter [Schaffung einer Umgebung in AWS Cloud9](create-environment.md).
+ **Sie haben die AWS Cloud9 IDE für die bestehende Umgebung bereits geöffnet.** Wenn Sie eine Umgebung AWS Cloud9 öffnen, wird die IDE für diese Umgebung in Ihrem Webbrowser geöffnet. Weitere Informationen finden Sie unter [Öffnen einer Umgebung in AWS Cloud9](open-environment.md).
## Schritt 1: Installieren der erforderlichen Tools
In diesem Schritt installieren TypeScript Sie mit Node Package Manager (**`npm`**). Verwenden Sie zum Installieren von ** `npm` ** Node Version Manager (** `nvm` **). Wenn Sie ** `nvm` ** nicht haben, installieren Sie die Software im ersten Schritt.
1. Überprüfen Sie in einer Terminalsitzung in der AWS Cloud9 IDE, ob das Programm bereits installiert TypeScript ist, indem Sie den TypeScript Befehlszeilen-Compiler mit der **`--version`**Option ausführen. (Um eine neue Terminalsitzung zu starten, wählen Sie in der Menüleiste **Window** (Fenster), **New Terminal** (Neues Terminal) aus. Bei Erfolg enthält die Ausgabe die TypeScript Versionsnummer. Wenn installiert TypeScript ist, fahren Sie mit fort[Schritt 2: Code hinzufügen](#sample-typescript-code).
```
tsc --version
```
1. Bestätigen Sie, ob ** `npm` ** bereits installiert ist, indem Sie ** `npm` ** mit der Option ** `--version` ** ausführen. Bei Erfolg enthält die Ausgabe die ** `npm` **-Versionsnummer. Falls installiert **`npm`**ist, fahren Sie mit Schritt 10 dieses **`npm`**zur Installation verwendeten Verfahrens fort TypeScript.
```
npm --version
```
1. Führen Sie den Befehl ** `yum update` ** für (Amazon Linux) oder ** `apt update` ** für (Ubuntu Server) aus, um sicherzustellen, dass die Sicherheitsupdates und Fehlerbehebungen auf dem aktuellen Stand sind.
Für Amazon Linux:
```
sudo yum -y update
```
Für Ubuntu Server:
```
sudo apt update
```
1. Führen Sie zur Installation **`npm`**zunächst den folgenden Befehl aus, um Node Version Manager (**`nvm`**) herunterzuladen. (**`nvm`**ist ein einfaches Bash-Shell-Skript, das für die Installation und Verwaltung von Node.js nützlich ist. Weitere Informationen finden Sie unter [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md) auf der GitHub Website.)
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. Um ** `nvm` ** zu nutzen, schließen Sie entweder die Terminalsitzung und starten sie dann neu oder lesen die Datei `~/.bashrc` mit den Befehlen zum Laden von ** `nvm` **.
```
. ~/.bashrc
```
1. Bestätigen Sie, dass ** `nvm` ** installiert ist, indem Sie ** `nvm` ** mit der Option ** `--version` ** ausführen.
```
nvm --version
```
1. Installieren Sie die neueste Version 16 von Node.js, indem Sie den Befehl ausführen **`nvm`**. (**`npm`**ist in Node.js enthalten.)
```
nvm install v16
```
1. Prüfen Sie, ob Node.js installiert wurde, indem Sie die Befehlszeilenversion von Node.js mit der Option ** `--version` ** ausführen.
```
node --version
```
1. Bestätigen Sie, dass ** `npm` ** installiert ist, indem Sie ** `npm` ** mit der Option ** `--version` ** ausführen.
```
npm --version
```
1. Installieren Sie TypeScript , indem Sie es **`npm`**mit der **`-g`**Option ausführen. Dies wird TypeScript als globales Paket in der Umgebung installiert.
```
npm install -g typescript
```
1. Bestätigen Sie, dass TypeScript es installiert ist, indem Sie den TypeScript Befehlszeilen-Compiler mit der **`--version`**Option ausführen.
```
tsc --version
```
## Schritt 2: Code hinzufügen
1. Erstellen Sie in der AWS Cloud9 IDE eine Datei mit dem Namen`hello.ts`. (Um eine Datei zu erstellen, wählen Sie in der Menüleiste **File (Datei)**, **New File (Neue Datei)** aus. Um die Datei zu speichern, wählen Sie **Datei**, **Save (Speichern)**.)
1. Führen Sie in einem Terminal in der IDE; in dem Verzeichnis, in dem sich die Datei `hello.ts` befindet, **`npm`** aus, um die Bibliothek `@types/node` zu installieren.
```
npm install @types/node
```
Dadurch wird ein `node_modules/@types/node`-Ordner in dem Verzeichnis hinzugefügt, in dem sich die Datei `hello.ts` befindet. Dieser neue Ordner enthält die Typdefinitionen von Node.js, die Sie später in diesem Verfahren für die `process.argv` Eigenschaften `console.log` und TypeScript benötigen, die Sie der `hello.ts` Datei hinzufügen werden.
1. Fügen Sie den folgenden Code zur Datei `hello.ts` hinzu:
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
const sum: number = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## Schritt 3: Ausführen des Codes
1. Führen Sie im Terminal aus demselben Verzeichnis wie die `hello.ts` Datei den TypeScript Compiler aus. Geben Sie die Datei `hello.ts` und die weiteren einzuschließenden Bibliotheken an.
```
tsc hello.ts --lib es6
```
TypeScript verwendet die `hello.ts` Datei und einen Satz von ECMAScript 6 (ES6) Bibliotheksdateien, um den Code in der Datei in äquivalenten TypeScript JavaScript Code in einer `hello.ts` Datei mit dem Namen zu transpilieren. `hello.js`
1. Öffnen Sie im Fenster **Environment (Umgebung)** die Datei `hello.js`.
1. Wählen Sie auf der Menüleiste **Run** (Ausführen), **Run Configurations** (Run-Konfigurationen), **New Run Configuration** (Neue Run-Konfiguration) aus.
1. Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] - Leerlauf)** die Option **Runner: Auto** und dann **Node.js** aus.
1. Geben Sie für **Command (Befehl)** `hello.js 5 9` ein. Im Code stellen `5` `process.argv[2]` und `9` `process.argv[3]` dar. (`process.argv[0]` steht für den Namen der Laufzeit (`node`), und `process.argv[1]` für den Namen der Datei (`hello.js`).)
1. Wählen Sie **Run (Ausführen)** und vergleichen Sie die Ausgabe. Klicken Sie anschließend auf **Stop (Stopp)**.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[Ausgabe von Node.js nach dem Ausführen des Codes in der IDE AWS Cloud9\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**Anmerkung**
Statt eine neue Konfiguration in der IDE; zu erstellen, können Sie diesen Code auch ausführen, indem Sie den Befehl **`node hello.js 5 9`** im Terminal ausführen.
## Schritt 4: Installieren und konfigurieren Sie das AWS SDK für JavaScript in Node.js
Sie können dieses Beispiel erweitern, um das AWS SDK für JavaScript in Node.js zu verwenden, um einen Amazon S3 S3-Bucket zu erstellen, Ihre verfügbaren Buckets aufzulisten und dann den gerade erstellten Bucket zu löschen.
In diesem Schritt installieren und konfigurieren Sie das AWS SDK für JavaScript in Node.js. Das SDK bietet eine bequeme Möglichkeit, über Ihren JavaScript Code mit AWS Diensten wie Amazon S3 zu interagieren. Nachdem Sie das AWS SDK für JavaScript in Node.js installiert haben, müssen Sie die Verwaltung der Anmeldeinformationen in Ihrer Umgebung einrichten. Das SDK benötigt diese Anmeldeinformationen, um mit AWS Diensten zu interagieren.
### Um das AWS SDK für JavaScript in Node.js zu installieren
Führen Sie in einer Terminalsitzung in der AWS Cloud9 IDE aus demselben Verzeichnis, aus dem die `hello.js` Datei stammt[Schritt 3: Ausführen des Codes](#sample-typescript-run), den Befehl aus, **`npm`**um das AWS SDK für JavaScript in Node.js zu installieren.
```
npm install aws-sdk
```
Dieser Befehl fügt verschiedene Ordner in den Ordner `node_modules` aus [Schritt 3: Ausführen des Codes](#sample-typescript-run) ein. Diese Ordner enthalten Quellcode und Abhängigkeiten für das AWS SDK JavaScript in Node.js. Weitere Informationen finden Sie unter [Installieren des SDK für JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html) im *AWS SDK für JavaScript Entwicklerhandbuch*.
### So richten Sie die Anmeldeinformationsverwaltung in Ihrer Umgebung ein
Jedes Mal, wenn Sie das AWS SDK für JavaScript in Node.js verwenden, um einen AWS Dienst aufzurufen, müssen Sie beim Aufruf eine Reihe von Anmeldeinformationen angeben. Diese Anmeldeinformationen bestimmen, ob das AWS SDK für JavaScript in Node.js über die entsprechenden Berechtigungen für diesen Aufruf verfügt. Wenn die Anmeldeinformationen nicht die entsprechenden Berechtigungen haben, schlägt der Aufruf fehl.
In diesem Schritt speichern Sie Ihre Anmeldeinformationen innerhalb der Umgebung. Folgen Sie dazu den Anweisungen unter [AWS-Services Aus einer Umgebung anrufen in AWS Cloud9](credentials.md) und kehren Sie dann zu diesem Thema zurück.
Weitere Informationen finden Sie unter [Festlegen von Anmeldeinformationen in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html) im*AWS SDK für JavaScript Entwicklerhandbuch*.
## Schritt 5: AWS SDK-Code hinzufügen
In diesem Schritt fügen Sie weiteren Code hinzu. Dieses Mal für die Interaktion mit Amazon S3, um einen Bucket zu erstellen, Ihre verfügbaren Buckets aufzulisten und anschließend den Bucket zu löschen, den Sie zuvor erstellt haben. Sie werden diesen Code später ausführen.
1. Erstellen Sie in der AWS Cloud9 IDE im selben Verzeichnis wie die `hello.js` Datei in den vorherigen Schritten eine Datei mit dem Namen`s3.ts`.
1. Aktivieren Sie von einem Terminal in der AWS Cloud9 IDE aus, das sich im selben Verzeichnis wie die `s3.ts` Datei befindet, den Code, um Amazon S3 S3-Operationen asynchron aufzurufen, indem Sie **`npm`**zweimal ausführen, um die asynchrone Bibliothek für TypeScript und erneut für zu installieren. JavaScript
```
npm install @types/async # For TypeScript.
npm install async # For JavaScript.
```
1. Fügen Sie den folgenden Code zur Datei `s3.ts` hinzu:
```
import * as async from 'async';
import * as AWS from 'aws-sdk';
if (process.argv.length < 4) {
console.log('Usage: node s3.js \n' +
'Example: node s3.js my-test-bucket us-east-2');
process.exit(1);
}
const AWS = require('aws-sdk'); // To set the AWS credentials and AWS Region.
const async = require('async'); // To call AWS operations asynchronously.
const s3: AWS.S3 = new AWS.S3({apiVersion: '2006-03-01'});
const bucket_name: string = process.argv[2];
const region: string = process.argv[3];
AWS.config.update({
region: region
});
const create_bucket_params: any = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region
}
};
const delete_bucket_params: any = {
Bucket: bucket_name
};
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback): void {
s3.listBuckets(function(err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (let i: number = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback): void {
console.log("\nCreating a bucket named '" + bucket_name + "'...\n");
s3.createBucket(create_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback): void {
console.log("\nDeleting the bucket named '" + bucket_name + "'...\n");
s3.deleteBucket(delete_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets
]);
```
## Schritt 6: Führen Sie den AWS SDK-Code aus
1. Führen Sie im Terminal aus demselben Verzeichnis wie die `s3.ts` Datei den TypeScript Compiler aus. Geben Sie die Datei `s3.ts` und die weiteren einzuschließenden Bibliotheken an.
```
tsc s3.ts --lib es6
```
TypeScript verwendet die `s3.ts` Datei, das AWS SDK für JavaScript in Node.js, die asynchrone Bibliothek und einen Satz von ECMAScript 6 (ES6) Bibliotheksdateien, um den Code in der Datei in äquivalenten TypeScript JavaScript Code in einer `s3.ts` Datei mit dem Namen zu transpilieren. `s3.js`
1. Öffnen Sie im Fenster **Environment (Umgebung)** die Datei `s3.js`.
1. Wählen Sie auf der Menüleiste **Run** (Ausführen), **Run Configurations** (Run-Konfigurationen), **New Run Configuration** (Neue Run-Konfiguration) aus.
1. Wählen Sie auf der Registerkarte **[New] - Idle ([Neu] - Leerlauf)** die Option **Runner: Auto** und dann **Node.js** aus.
1. Geben Sie **unter Command** den Namen des Buckets ` YOUR_BUCKET_NAME ` ein`s3.js YOUR_BUCKET_NAME THE_AWS_REGION `, den Sie erstellen und dann löschen möchten, und geben Sie die ID der AWS Region ` THE_AWS_REGION ` ein, in der der Bucket erstellt werden soll. Verwenden Sie zum Beispiel für die Region "USA Ost (Ohio)" `us-east-2`. Weitere Informationen IDs finden Sie unter [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) in der *Allgemeine Amazon Web Services-Referenz*.
**Anmerkung**
Amazon S3 S3-Bucket-Namen müssen überall eindeutig sein AWS— nicht nur in Ihrem AWS Konto.
1. Wählen Sie **Run (Ausführen)** und vergleichen Sie die Ausgabe. Klicken Sie anschließend auf **Stop (Stopp)**.
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## Schritt 7: Bereinigen
Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie die Umgebung löschen. Detaillierte Anweisungen finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
# Docker-Tutorial für AWS Cloud9
Dieses Tutorial zeigt Ihnen, wie Sie eine AWS Cloud9 SSH-Entwicklungsumgebung mit einem laufenden Docker-Container innerhalb einer Amazon Linux-Instance in Amazon EC2 verbinden. Auf diese Weise können Sie die AWS Cloud9 IDE verwenden, um mit Code und Dateien in einem Docker-Container zu arbeiten und Befehle in diesem Container auszuführen. Weitere Informationen zu Docker finden Sie unter [Was ist Docker](https://www.docker.com/what-docker) auf der Docker-Website.
Wenn Sie diesem Tutorial folgen und dieses Beispiel erstellen, kann dies dazu führen, dass Ihr AWS Konto belastet wird. Dies umfasst mögliche Kosten für Services wie .Amazon EC2. Weitere Informationen finden Sie unter [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/).
**Topics**
+ [Voraussetzungen](#sample-docker-prereqs)
+ [Schritt 1: Installieren und Ausführen von Docker](#sample-docker-install)
+ [Schritt 2: Erstellen des Image](#sample-docker-build)
+ [Schritt 3: Ausführen des Containers](#sample-docker-run)
+ [Schritt 4: Erstellen der Umgebung](#sample-docker-env)
+ [Schritt 5: Ausführen des Codes](#sample-docker-code)
+ [Schritt 6: Bereinigen](#sample-docker-clean-up)
## Voraussetzungen
+ **Sie sollten eine Amazon-EC2-Instance besitzen, auf der Amazon Linux oder Ubuntu Server ausgeführt wird.** In diesem Beispiel wird davon ausgegangen, dass Sie in Ihrem AWS Konto bereits eine Amazon EC2 EC2-Instance haben, auf der Amazon Linux oder Ubuntu Server ausgeführt wird. Weitere Informationen zum Starten einer Amazon-EC2-Instance finden Sie unter [Starten einer virtuellen Linux-Maschine](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/). Wählen Sie auf der Seite **Choose an Amazon Machine Image (AMI) (Ein Amazon Machine Image (AMI) auswählen)** des Assistenten ein AMI aus, dessen Anzeigename mit **Amazon Linux AMI** oder **Ubuntu Server** beginnt.
+ **Wenn die Amazon EC2-Instance innerhalb einer Amazon VPC ausgeführt wird, gibt es zusätzliche Anforderungen.** Siehe [VPC-Einstellungen für AWS Cloud9 Entwicklungsumgebungen](vpc-settings.md).
+ **Die Amazon EC2-Instance sollte über mindestens 8 bis 16 GB freien Speicherplatz verfügen.** Dieses Beispiel verwendet Docker-Images, die größer als 3 GB sind, und kann zusätzliche Inkrements von 3 GB oder mehr Speicherplatz zum Erstellen von Images nutzen. Beim Versuch, dieses Beispiel auf einem Datenträger mit 8 GB freiem Speicherplatz oder weniger auszuführen, haben wir festgestellt, dass das Docker-Image möglicherweise nicht erstellt oder der Docker-Container nicht ausgeführt wird. Um den freien Speicher der Instance zu überprüfen, können Sie einen Befehl wie z. B. ** `df -h` ** (für „Dateisysteminformationen in vom Menschen lesbaren Format“) auf der Instance ausführen. Informationen zum Erhöhen der Festplattengröße einer vorhandenen Instance finden Sie unter [Modifying a Volume](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
## Schritt 1: Installieren und Ausführen von Docker
In diesem Schritt prüfen Sie, ob Docker auf der Amazon-EC2-Instance installiert ist, und installieren Docker, falls es noch nicht installiert ist. Nachdem Sie Docker installiert haben, führen Sie es auf der Instance aus.
1. Stellen Sie eine Verbindung mit der laufenden Amazon-EC2-Instance unter Verwendung eines SSH-Clients her, wie z. B. über das Dienstprogramms ** `ssh` ** oder PuTTY. Wie das funktioniert, ist unter „Schritt 3: Herstellen einer Verbindung mit Ihrer Instance“ in [Starten einer virtuellen Linux-Maschine](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/) beschrieben.
1. Überprüfen Sie, ob Docker auf der Instance installiert ist. Führen Sie zu diesem Zweck den Befehl ** `docker` ** auf der Instance mit der Option ** `--version` ** aus.
```
docker --version
```
Wenn Docker installiert ist, werden die Docker-Version und die Build-Nummer angezeigt. In diesem Fall fahren Sie mit Schritt 5 dieses Verfahrens fort.
1. Docker-Installation. Dazu führen Sie den Befehl ** `yum` ** oder ** `apt` ** mit der Aktion ** `install` ** aus und geben das zu installierende Paket ** `docker` ** oder ** `docker.io` ** an.
Für Amazon Linux:
```
sudo yum install -y docker
```
Für Ubuntu Server:
```
sudo apt install -y docker.io
```
1. Vergewissern Sie sich, dass Docker installiert ist. Führen Sie dazu den Befehl ** `docker --version` ** erneut aus. Die Docker-Version und die Build-Nummer werden angezeigt.
1. Führen Sie Docker aus. Dazu führen Sie den Befehl ** `service` ** mit dem Service ** `docker` ** und der Aktion ** `start` ** aus.
```
sudo service docker start
```
1. Überprüfen Sie, ob Docker ausgeführt wird. Führen Sie zu diesem Zweck den Befehl ** `docker` ** mit der Aktion ** `info` ** aus.
```
sudo docker info
```
Wenn Docker ausgeführt wird, werden Informationen über Docker angezeigt.
## Schritt 2: Erstellen des Image
In diesem Schritt verwenden Sie eine Dockerdatei, um ein Docker-Image auf der Instance zu erstellen. Dieses Beispiel verwendet ein Image mit Node.js und ein Beispiel für eine Chat-Server-Anwendung.
1. Klicken Sie das Dockerfile auf der Instance. Dazu erstellen Sie, während der SSH-Client noch mit der Instance verbunden ist, im Verzeichnis `/tmp` auf der Instance die Datei namens `Dockerfile`. Führen Sie beispielsweise den Befehl ** `touch` ** wie folgt aus.
```
sudo touch /tmp/Dockerfile
```
1. Fügen Sie der Datei `Dockerfile` die folgenden Inhalte hinzu.
```
# Build a Docker image based on the Amazon Linux 2 Docker image.
FROM amazonlinux:2
# install common tools
RUN yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
RUN yum update -y
RUN yum install -y sudo bash curl wget git man-db nano vim bash-completion tmux gcc gcc-c++ make tar
# Enable the Docker container to communicate with AWS Cloud9 by
# installing SSH.
RUN yum install -y openssh-server
# Ensure that Node.js is installed.
RUN yum install -y nodejs
# Create user and enable root access
RUN useradd --uid 1000 --shell /bin/bash -m --home-dir /home/ubuntu ubuntu && \
sed -i 's/%wheel\s.*/%wheel ALL=NOPASSWD:ALL/' /etc/sudoers && \
usermod -a -G wheel ubuntu
# Add the AWS Cloud9 SSH public key to the Docker container.
# This assumes a file named authorized_keys containing the
# AWS Cloud9 SSH public key already exists in the same
# directory as the Dockerfile.
RUN mkdir -p /home/ubuntu/.ssh
ADD ./authorized_keys /home/ubuntu/.ssh/authorized_keys
RUN chown -R ubuntu /home/ubuntu/.ssh /home/ubuntu/.ssh/authorized_keys && \
chmod 700 /home/ubuntu/.ssh && \
chmod 600 /home/ubuntu/.ssh/authorized_keys
# Update the password to a random one for the user ubuntu.
RUN echo "ubuntu:$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)" | chpasswd
# pre-install Cloud9 dependencies
USER ubuntu
RUN curl https://d2j6vhu5uywtq3.cloudfront.net/static/c9-install.sh | bash
USER root
# Start SSH in the Docker container.
CMD ssh-keygen -A && /usr/sbin/sshd -D
```
Um den vorherigen Inhalt der Datei `Dockerfile` hinzuzufügen, könnten Sie das Dienstprogramm ** `vi` ** auf der Instance wie folgt verwenden.
1. Verwenden Sie den AWS Cloud9 , um die `/tmp/Dockerfile` Datei zu öffnen und zu bearbeiten.
```
sudo vi /tmp/Dockerfile
```
1. Fügen Sie den vorherigen Inhalt in die `Dockerfile`-Datei ein. Falls Sie nicht sicher sind, wie das geht, lesen Sie in der Dokumentation Ihres SSH-Clients nach.
1. Wechseln Sie in den Befehlsmodus. Um dies zu tun, drücken Sie die `Esc`-Taste. (`-- INSERT --` verschwindet unten im Fenster).
1. Geben Sie `:wq` ein (um in die `/tmp/Dockerfile`-Datei zu schreiben, die Datei zu speichern und ** `vi` ** zu verlassen), und drücken Sie dann `Enter`.
**Anmerkung**
Sie können auf eine häufig aktualisierte Liste von Docker-Images unter zugreifen. AWS CodeBuild Weitere Informationen finden Sie CodeBuild im *AWS CodeBuild Benutzerhandbuch* unter [Docker-Images bereitgestellt von](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html).
1. Erstellen Sie auf der Instanz eine Datei, die den öffentlichen AWS Cloud9 SSH-Schlüssel für den zu verwendenden Docker-Container enthält. Erstellen Sie dazu im selben Verzeichnis, in dem sich die `Dockerfile`-Datei befindet, eine Datei beispielsweise namens `authorized_keys`, indem Sie den Befehl ** `touch` ** ausführen.
```
sudo touch /tmp/authorized_keys
```
1. Fügen Sie der AWS Cloud9 Datei den öffentlichen SSH-Schlüssel hinzu. `authorized_keys` Gehen Sie wie folgt vor, um den öffentlichen AWS Cloud9 SSH-Schlüssel zu erhalten:
1. Öffnen Sie die AWS Cloud9 Konsole unter. [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/)
1. Wählen Sie in der AWS Navigationsleiste in der AWS Regionsauswahl die AWS Region aus, in der Sie später in diesem Thema die AWS Cloud9 Entwicklungsumgebung erstellen möchten.
1. Wenn eine Willkommensseite angezeigt wird, wählen Sie für **Neue AWS Cloud9 Umgebung** die Option **Umgebung erstellen** aus. Andernfalls wählen Sie **Create environment (Umgebung erstellen)** aus.
1. Geben Sie auf der Seite **Name environment (Umgebung benennen)** für **Name** einen Namen für die Umgebung ein. (Der Name spielt hier keine Rolle. Sie werden später einen anderen Namen wählen.)
1. Klicken Sie auf **Nächster Schritt**.
1. Wählen Sie für **Environment type (Umgebungstyp)** die Option **Connect and run in remote server (SSH) (Verbindung zu Remote-Server herstellen (SSH) und dort ausführen)**.
1. Erweitern Sie **View public SSH key (Öffentlichen SSH-Schlüssel anzeigen)**.
1. Wählen Sie **Copy key to clipboard (Schlüssel in Zwischenablage kopieren)**. (Diese Option befindet sich zwischen **View public SSH key (Öffentlichen SSH-Schlüssel anzeigen)** und **Advanced settings (Erweiterte Einstellungen)**.)
1. Klicken Sie auf **Abbrechen**.
1. Kopieren Sie den Inhalt der Zwischenablage in die `authorized_keys`-Datei und speichern Sie die Datei. Beispielsweise können Sie das Dienstprogramm ** `vi` ** verwenden, wie weiter oben in diesem Schritt beschrieben.
1. Erstellen Sie das Image, indem Sie den Befehl ** `docker` ** mit der Aktion ** `build` ** ausführen, dem Image das Tag `cloud9-image:latest` hinzufügen und den Pfad zu der zu verwendenden `Dockerfile`-Datei angeben.
```
sudo docker build -t cloud9-image:latest /tmp
```
Ist der Befehl erfolgreich, enthalten die letzten beiden Zeilen der Build-Ausgabe `Successfully built` und `Successfully tagged`.
Um zu bestätigen, dass Docker das Image erfolgreich erstellt hat, führen Sie den Befehl ** `docker` ** mit der Aktion `image ls` aus.
```
sudo docker image ls
```
Ist dieser erfolgreich, zeigt die Ausgabe einen Eintrag an, in dem das Feld `REPOSITORY` auf `cloud9-image` und das Feld `TAG` auf `latest` gesetzt sind.
1. Notieren Sie die öffentliche IP-Adresse der Amazon EC2-Instance. Sie benötigen sie für [Schritt 4: Erstellen der Umgebung](#sample-docker-env). Wenn Sie sich nicht sicher sind, was die öffentliche IP-Adresse der Instance ist, können Sie den folgenden Befehl auf der Instance ausführen, um sie abzurufen.
```
curl http://169.254.169.254/latest/meta-data/public-ipv4
```
## Schritt 3: Ausführen des Containers
In diesem Schritt führen Sie einen Docker-Container auf der Instance aus. Dieser Container basiert auf dem Image, das Sie im vorherigen Schritt erstellt haben.
1. Um den Docker-Container auszuführen, führen Sie den Befehl ** `docker` ** auf der Instance mit der Aktion ** `run` ** und den folgenden Optionen aus.
```
sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
```
+ `-d` führt den Container in getrennten Modus aus und beendet der Befehl, wenn der Root-Prozess, der für die Ausführung des Containers verwendet wird (in diesem Beispiel der SSH-Client) beendet wird.
+ `-it` führt den Container mit einem zugewiesenen Pseudo-TTY aus und hält STDIN offen, auch wenn der Container nicht zugeordnet ist.
+ `--expose` stellt den angegebenen Port (in diesem Beispiel Port `9090`) vom Container aus zur Verfügung.
+ `-p` stellt den angegebenen Port für die Amazon EC2-Instance über die angegebene IP-Adresse und den Port zur Verfügung. In diesem Beispiel ist der Zugriff auf Port `9090` im Container intern über Port `22` auf der Amazon EC2-Instance möglich.
+ `--name` ist ein vom Menschen lesbarer Name für den Container (in diesem Beispiel `cloud9`).
+ `cloud9-image:latest` ist der vom Menschen lesbare Name des erstellten Image, das für die Ausführung des Containers verwendet wird.
Um zu bestätigen, dass Docker den Container erfolgreich ausführt, führen Sie den Befehl ** `docker` ** mit der Aktion `container ls` aus.
```
sudo docker container ls
```
Ist dieser erfolgreich, zeigt die Ausgabe einen Eintrag an, in dem das Feld `IMAGE` auf `cloud9-image:latest` und das Feld `NAMES` auf `cloud9` gesetzt sind.
1. Melden Sie sich bei dem ausgeführten Container an. Führen Sie dazu den Befehl ** `docker` ** mit der Aktion ** `exec` ** und den folgenden Optionen aus.
```
sudo docker exec -it cloud9 bash
```
+ `-it` führt den Container mit einem zugewiesenen Pseudo-TTY aus und hält STDIN offen, auch wenn der Container nicht zugeordnet ist.
+ `cloud9` ist der vom Menschen lesbare Name des ausgeführten Containers.
+ `bash` startet die Standard-Shell im ausgeführten Container.
Ist der Befehl erfolgreich ändert sich die Terminal-Eingabeaufforderung und zeigt den Namen des angemeldeten Benutzers für den Container und die ID des Containers an.
**Anmerkung**
Wenn Sie sich von dem ausgeführten Container abmelden möchten, führen Sie den Befehl ** `exit` ** aus. Die Terminal-Eingabeaufforderung zeigt wieder den Namen des angemeldeten Benutzers für die Instance und den privaten DNS der Instance an. Der Container muss noch ausgeführt werden.
1. Legen Sie für das Verzeichnis auf dem laufenden Container, von dem aus Sie nach der Anmeldung beginnen möchten AWS Cloud9 , die Zugriffsberechtigungen auf fest **`rwxr-xr-x`**. Das bedeutet read-write-execute Berechtigungen für den Besitzer, Lese- und Ausführungsberechtigungen für die Gruppe und Lese- und Ausführungsberechtigungen für andere. Beispiel: Wenn der Pfad des Verzeichnisses `~` ist, können Sie diese Berechtigungen für das Verzeichnis festlegen, indem Sie folgendermaßen den Befehl ** `chmod` ** in dem ausgeführten Container ausführen.
```
sudo chmod u=rwx,g=rx,o=rx ~
```
1. Notieren Sie den Pfad zu dem Verzeichnis auf dem laufenden Container, der die Binärdatei Node.js enthält, weil Sie ihn für [Schritt 4: Erstellen der Umgebung](#sample-docker-env) benötigen. Wenn Sie sich nicht sicher sind, was dieser Pfad ist, führen Sie den folgenden Befehl auf dem ausgeführten Container aus, um ihn abzurufen.
```
which node
```
## Schritt 4: Erstellen der Umgebung
In diesem Schritt erstellen Sie AWS Cloud9 eine AWS Cloud9 SSH-Entwicklungsumgebung und verbinden sie mit dem laufenden Docker-Container. Nachdem die Umgebung AWS Cloud9 erstellt wurde, wird die AWS Cloud9 IDE angezeigt, sodass Sie mit der Arbeit mit den Dateien und dem Code im Container beginnen können.
Sie erstellen mit der AWS Cloud9 Konsole eine AWS Cloud9 SSH-Entwicklungsumgebung. Sie können keine SSH-Umgebung mit der CLI erstellen.
### Voraussetzungen
+ Stellen Sie sicher, dass Sie die in [Einrichten AWS Cloud9](setting-up.md) beschriebenen Schritte zuerst ausführen. Sie können sich so bei der AWS Cloud9 -Konsole anmelden und Umgebungen erstellen.
+ Identifizieren Sie eine vorhandene Cloud-Recheninstanz (z. B. eine Amazon EC2 EC2-Instance in Ihrer AWS-Konto) oder Ihren eigenen Server, den Sie mit der Umgebung verbinden AWS Cloud9 möchten.
+ Stellen Sie sicher, dass die vorhandene Instance oder Ihr eigener Server alle [SSH-Host-Anforderungen](ssh-settings.md#ssh-settings-requirements) erfüllt. Dazu gehören, dass bestimmte Versionen von Python, Node.js und anderen Komponenten installiert sein müssen; das Festlegen spezifischer Berechtigungen für das Verzeichnis, in dem Sie AWS Cloud9 nach der Anmeldung starten möchten; und das Einrichten zugehöriger Amazon Virtual Private Clouds.
### Erstellen Sie die SSH-Umgebung
1. Achten Sie darauf, dass die folgenden Voraussetzungen erfüllt sind.
1. Sofern noch keine Verbindung besteht, stellen Sie über einen SSH-Client eine Verbindung mit Ihrer vorhandenen Instance oder Ihrem eigenen Server her. Dadurch wird sichergestellt, dass Sie der Instance oder dem Server den erforderlichen öffentlichen SSH-Schlüsselwert hinzufügen können. Dies wird später in dieser Anleitung beschrieben.
**Anmerkung**
Um eine Verbindung zu einer vorhandenen AWS Cloud Compute-Instance herzustellen, sehen Sie sich eine oder mehrere der folgenden Ressourcen an:
Informationen zu Amazon EC2 finden Sie unter [Connect to Your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
Informationen zu Amazon Lightsail finden Sie unter [Herstellen einer Verbindung mit Ihrer Linux-/Unix-basierten Lightsail-Instance](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server) in der *Amazon Lightsail-Dokumentation*.
Weitere Informationen finden Sie unter [Auflisten von Server-Instances und Herstellen einer Verbindung zu Server-Instances](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.ec2connect.html) im *AWS Elastic Beanstalk Entwicklerhandbuch*. AWS Elastic Beanstalk
Weitere Informationen finden Sie [unter SSH zur Anmeldung bei einer Linux-Instance](https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-ssh.html) verwenden im *AWS OpsWorks Benutzerhandbuch*. AWS OpsWorks
Weitere AWS-Services Informationen finden Sie in der Dokumentation für den jeweiligen Dienst.
Verwenden Sie SSH, um eine Verbindung mit Ihrem eigenen Server herzustellen. SSH ist bereits auf den Betriebssystemen macOS und Linux installiert. Wenn Sie über SSH unter Windows eine Verbindung mit Ihrem Server herstellen möchten, müssen Sie [PuTTY](https://www.putty.org/) installieren.
1. Melden Sie sich bei der AWS Cloud9 Konsole an, unter [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/).
1. Nachdem Sie sich bei der AWS Cloud9 Konsole angemeldet haben, wählen Sie in der oberen Navigationsleiste eine aus AWS-Region , in der die Umgebung erstellt werden soll. Eine Liste der verfügbaren AWS-Regionen finden Sie [AWS Cloud9](https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region)in der *Allgemeine AWS-Referenz*.
![\[Regionsauswahl in der Konsole AWS Cloud9\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/images/consolas_region_new_UX.png)
1. Wenn Sie zum ersten Mal eine Entwicklungsumgebung erstellen, wird eine Willkommensseite angezeigt. Wählen Sie im Bereich **Neue AWS Cloud9 Umgebung** die Option **Umgebung erstellen** aus.
Wenn Sie zuvor bereits Entwicklungsumgebungen erstellt haben, können Sie auch den Bereich auf der linken Seite des Bildschirms erweitern. Wählen Sie **Your environments** (Ihre Umebungen) und dann **Create environment (Umgebung erstellen)** aus.
In der**Willkommen**-Seite:
![\[Auswählen der Schaltfläche „Create environment“ (Umgebung erstellen), wenn die Willkommensseite angezeigt wird\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)
Oder in der**Ihre Umgebungen**-Seite:
![\[Auswählen der Schaltfläche „Create environment“ (Umgebung erstellen), wenn die Willkommensseite nicht angezeigt wird\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/images/console_create_env_new_UX.png)
1. Geben Sie auf der Seite **Create environment** (Umgebung erstellen) einen Namen für Ihre Umgebung ein.
1. Geben Sie unter **Description (Beschreibung)** eine Beschreibung für Ihre Umgebung ein. Verwenden Sie für dieses Tutorial `This environment is for the AWS Cloud9 tutorial.`
1. Wählen Sie als **Environment type** (Umgebungstyp) **Existing Compute** (Bestehendes Computing) aus den folgenden Optionen aus:
+ **Neue EC2-Instance** — Startet eine Amazon EC2 EC2-Instance, mit der eine direkte Verbindung über SSH hergestellt werden AWS Cloud9 kann.
+ **Bestehende Rechenleistung** — Startet eine Amazon EC2 EC2-Instance, für die keine offenen eingehenden Ports erforderlich sind. AWS Cloud9 stellt eine Verbindung zur Instance her über. [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html)
+ Wenn Sie die Option **Existing compute** (Bestehendes Computing) auswählen, werden eine Servicerolle und ein IAM-Instance-Profil erstellt, damit Systems Manager in Ihrem Namen mit der EC2-Instance interagieren kann. Sie können die Namen der beiden im Abschnitt **Service role and instance profile for Systems Manager access (Dienstrolle und Instance-Profil für den Zugriff auf den Systemmanager)** weiter unten auf der Oberfläche einsehen. Weitere Informationen finden Sie unter [Zugreifen auf EC2-Instances ohne Zutritt mit AWS Systems Manager](ec2-ssm.md).
**Warnung**
Wenn Sie eine EC2-Instance für Ihre Umgebung erstellen, können Ihnen möglicherweise Gebühren AWS-Konto für Amazon EC2 entstehen. Für die Nutzung von Systems Manager zur Verwaltung von Verbindungen mit Ihrer EC2-Instance fallen keine zusätzlichen Kosten an.
**Warnung**
AWS Cloud9 verwendet den öffentlichen SSH-Schlüssel, um eine sichere Verbindung zu Ihrem Server herzustellen. Um die sichere Verbindung herzustellen, fügen Sie Ihrer `~/.ssh/authorized_keys`-Datei unseren öffentlichen Schlüssel hinzu und geben Sie Ihre Anmeldeinformationen in den folgenden Schritten an. Wählen Sie **Copy key to clipboard** (Schlüssel in die Zwischenablage kopieren) aus, um den SSH-Schlüssel zu kopieren, oder **View public SSH key** (Öffentlichen SSH-Schlüssel anzeigen), um ihn anzuzeigen.
1. Geben Sie im Bereich **Existing Compute** (Bestehendes Computing) für **User** (Benutzer) den Anmeldenamen ein, den Sie zuvor in diesem Verfahren für die Verbindung mit der Instance oder dem Server verwendet haben. Für eine AWS Cloud -Computing-Instance könnte dies z. B. `ec2-user`, `ubuntu` oder `root` sein.
**Anmerkung**
Es wird empfohlen, dass der Anmeldename Administratorberechtigungen erhält oder einem Administratorbenutzer der Instance oder des Servers zugeordnet ist. Insbesondere wird empfohlen, dass dieser Anmeldename Besitzer der Node.js-Installation auf der Instance oder dem Server ist. Dies können Sie prüfen, indem Sie auf dem Terminal Ihrer Instance oder Ihres Servers den Befehl **`ls -l $(which node)`** (oder **`ls -l $(nvm which node)`**, falls Sie `nvm` verwenden) ausführen. Dieser Befehl zeigt den Namen des Besitzers der Node.js-Installation an. Außerdem zeigt er die Berechtigungen, dem Gruppennamen und den Speicherort der Installation an.
1. Geben Sie in das Feld **Host** die öffentliche IP-Adresse (bevorzugt) oder den Hostnamen der Instance oder des Servers ein.
1. Geben Sie **unter Port** den Port ein, über den Sie AWS Cloud9 versuchen möchten, eine Verbindung mit der Instanz oder dem Server herzustellen. Sie können auch den Standardport beibehalten.
1. Wählen Sie **Additional details - optional** (Zusätzliche Details – optional) aus, um den Umgebungspfad, den Pfad zur Binärdatei node.js und die SSH-Sprunghost-Informationen anzuzeigen.
1. Geben Sie unter **Umgebungspfad** den Pfad zu dem Verzeichnis auf der Instanz oder dem Server ein, von dem aus Sie beginnen AWS Cloud9 möchten. Sie haben dies bereits in den Voraussetzungen für dieses Verfahren identifiziert. Wenn Sie dieses Feld leer lassen, verwendet AWS Cloud9 das Verzeichnis, mit dem die Instance oder der Server normalerweise nach der Anmeldung startet. Dies ist normalerweise ein Stamm- oder Standardverzeichnis.
1. Geben Sie unter **Path to Node.js binary path** (Pfad zur Binäredatei Node.js) die Pfadinformationen ein, um den Pfad zur Binärdatei node.js auf der Instance oder dem Server anzugeben. Um den Pfad abzurufen, können Sie den Befehl **`which node`** (oder ** `nvm which node` **, wenn Sie `nvm` verwenden) auf der Instance oder dem Server ausführen. Der Pfad kann beispielsweise `/usr/bin/node` sein. Wenn Sie dieses Feld leer lassen, versucht AWS Cloud9 zu erraten, wo sich die Node.js-Binärdatei befindet, wenn sie versucht, eine Verbindung herzustellen.
1. Geben Sie für **SSH jump host** (SSH-Sprunghost) Informationen über den Sprunghost ein, den die Instance oder der Server verwendet. Verwenden Sie das Format `USER_NAME@HOSTNAME:PORT_NUMBER` (z. B. `ec2-user@:ip-192-0-2-0:22`).
Der Sprunghost muss die folgenden Anforderungen erfüllen:
+ Er muss über das öffentliche Internet mit SSH erreichbar sein.
+ Es muss eingehenden Zugriff von beliebigen IP-Adressen über den angegebenen Port zulassen.
+ Die öffentlichen SSH-Schlüsselwert, der in die Datei `~/.ssh/authorized_keys` auf der vorhandenen Instance oder dem Server kopiert wurde, muss auch in die Datei `~/.ssh/authorized_keys` auf dem Jump-Host kopiert werden.
+ Netcat muss installiert sein.
1. Fügen Sie bis zu 50 Tags hinzu, indem Sie für jeden Tag einen **Key (Schlüssel)** und einen **Value (Wert)** angeben. Wählen Sie dazu **Add new tag** (Neues Tag hinzufügen) aus. Die Tags werden als Ressourcen-Tags an die AWS Cloud9 Umgebung angehängt und an die folgenden zugrunde liegenden Ressourcen weitergegeben: den CloudFormation Stack, die Amazon EC2-Instance und Amazon EC2-Sicherheitsgruppen. Weitere Informationen zu Tags finden Sie unter [Zugriffskontrolle mithilfe von AWS Ressourcen-Tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) im *[IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/)* und in den [erweiterten Informationen](tags.md) zu Tags in diesem Handbuch.
**Warnung**
Wenn Sie diese Tags nach ihrer Erstellung aktualisieren, werden die Änderungen nicht automatisch an die zugrunde liegenden Ressourcen weitergegeben. Näheres finden Sie [Weitergeben von Tag-Aktualisierungen an zugrunde liegende Ressourcen](tags.md#tags-propagate) in den ausführlicheren Informationen über [Tags](tags.md).
1. Wählen Sie **Create** (Erstellen) aus, um Ihre Umgebung zu erstellen. Sie werden dann zur Startseite weitergeleitet. Wenn das Konto erfolgreich erstellt wurde, erscheint oben in der AWS Cloud9 Konsole eine grüne Flash-Leiste. Sie können die neue Umgebung und **Open in Cloud9** (In Cloud9 öffnen) auswählen, um die IDE zu starten.
![\[AWS Cloud9 IDE-Selektor in der Konsole AWS Cloud9\]](http://docs.aws.amazon.com/de_de/cloud9/latest/user-guide/images/cloud9-ide-open.png)
Wenn das Konto nicht erstellt werden konnte, erscheint oben in der AWS Cloud9 -Konsole eine rote Flashleiste. Ihr Konto kann möglicherweise aufgrund eines Problems mit Ihrem Webbrowser, Ihren AWS Zugriffsberechtigungen, der Instanz oder dem zugehörigen Netzwerk nicht erstellt werden. Informationen zu möglichen Lösungen für Probleme, die die Erstellung des Kontos verhindern könnten, finden Sie im Abschnitt [AWS Cloud9 -Fehlerbehebung](troubleshooting.md#troubleshooting-env-loading).
**Anmerkung**
Wenn Ihre Umgebung einen Proxy für den Zugriff auf das Internet verwendet, müssen Sie Proxydetails angeben, AWS Cloud9 damit Abhängigkeiten installiert werden können. Weitere Informationen finden Sie unter [Abhängigkeiten konnten nicht installiert werden](troubleshooting.md#proxy-failed-dependencies).
## Schritt 5: Ausführen des Codes
In diesem Schritt verwenden Sie die AWS Cloud9 IDE, um eine Beispielanwendung im laufenden Docker-Container auszuführen.
1. Starten Sie den Beispiel-Chat-Server, während die AWS Cloud9 IDE für den laufenden Container angezeigt wird. Dazu klicken Sie im Fenster **Environment (Umgebung)** mit der rechten Maustaste auf die Beispieldatei `workspace/server.js` und wählen dann **Run (Ausführen)**.
1. Zeigen Sie die Vorschau für die Beispielanwendung an. Dazu öffnen Sie im Fenster **Environment (Umgebung)** die Datei `workspace/client/index.html`. Wählen Sie dann auf der Menüleiste **Tools, Preview, Preview Running Application (Extras, Vorschau, Vorschau auf die ausgeführte Anwendung)**.
1. Geben Sie auf der Registerkarte für die Anwendungsvorschau für **Your Name (Ihr Name)** Ihren Namen ein. Geben Sie die Nachricht unter **Message (Meldung)** ein. Wählen Sie **Send (Senden)**. Der Chat-Server fügt Ihren Namen und Ihre Nachricht der Liste hinzu.
## Schritt 6: Bereinigen
In diesem Schritt löschen Sie die Umgebung AWS Cloud9 und entfernen die Docker-Supportdateien aus der Amazon EC2 EC2-Instance. Um zu verhindern, dass Ihr AWS Konto weiterhin belastet wird, nachdem Sie dieses Beispiel nicht mehr verwendet haben, sollten Sie außerdem die Amazon EC2 EC2-Instance beenden, auf der Docker ausgeführt wird.
### Schritt 6.1: Löschen der Umgebung
Informationen zum Löschen der Umgebung finden Sie unter [Löschen einer Umgebung in AWS Cloud9](delete-environment.md).
### Schritt 6.2: Entfernen Sie die AWS Cloud9 Supportdateien aus dem Container
Nachdem Sie die Umgebung gelöscht haben, verbleiben einige AWS Cloud9 Unterstützungsdateien immer noch im Container. Wenn Sie den Container weiterhin verwenden möchten, diese Unterstützungsdateien aber nicht mehr benötigen, löschen Sie den `.c9` Ordner aus dem Verzeichnis auf dem Container, von dem Sie angegeben haben, dass er nach der Anmeldung beginnen AWS Cloud9 soll. Ist das Verzeichnis beispielsweise `~`, führen Sie den Befehl ** `rm` ** mit der Option ** `-r` ** wie folgt aus.
```
sudo rm -r ~/.c9
```
### Schritt 6.3: Entfernen der Docker-Supportdateien aus der Instance
Wenn Sie den Docker-Container, das Docker-Image und Docker auf der Amazon EC2-Instance nicht behalten wollen, sehr wohl aber die Instance, können Sie diese Docker-Supportdateien wie folgt entfernen.
1. Entfernen des Docker-Containers von der Instance. Dazu führen Sie den Befehl ** `docker` ** auf der Instance mit den Stopp-Aktionen ** `stop` ** und ** `rm` ** und dem vom Menschen lesbaren Namen des Containers aus.
```
sudo docker stop cloud9
sudo docker rm cloud9
```
1. Entfernen Sie das Docker-Image von der Instance. Dazu führen Sie den Befehl ** `docker` ** auf der Instance mit der Aktion ** `image rm` ** und dem Tag des Image aus.
```
sudo docker image rm cloud9-image:latest
```
1. Entfernen Sie alle weiteren Docker-Supportdateien, die möglicherweise noch vorhanden sind. Dazu führen Sie den Befehl ** `docker` ** auf der Instance mit der Aktion ** `system prune` ** aus.
```
sudo docker system prune -a
```
1. Deinstallieren Sie Docker. Dazu führen Sie den Befehl ** `yum` ** auf der Instance mit der Aktion ** `remove` ** aus und geben das zu deinstallierende Paket ** `docker` ** an.
Für Amazon Linux:
```
sudo yum -y remove docker
```
Für Ubuntu Server:
```
sudo apt -y remove docker
```
Sie können auch die zuvor erstellten `Dockerfile`- und `authorized_keys`-Dateien entfernen. Führen Sie zum Beispiel den Befehl ** `rm` ** auf der Instance aus.
```
sudo rm /tmp/Dockerfile
sudo rm /tmp/authorized_keys
```
### Schritt 6.4: Beenden der Instance
Informationen zum Beenden der Amazon EC2 EC2-Instance finden Sie unter [Terminate Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
## Verwandte Tutorials
+ [Erste Schritte mit](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html) finden Sie AWS RoboMaker im *AWS RoboMaker Entwicklerhandbuch*. In diesem Tutorial wird AWS Cloud9 eine Roboter-Beispielanwendung geändert, erstellt und gebündelt.