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.
# Bereitstellung von Node.js Anwendungen mit Elastic Beanstalk
Dieses Kapitel enthält Anweisungen zur Konfiguration und Bereitstellung Ihrer Node.js -Webanwendung für AWS Elastic Beanstalk. Es enthält auch exemplarische Vorgehensweisen für allgemeine Aufgaben wie Datenbankintegration und Arbeit mit dem Express-Framework. Elastic Beanstalk macht es einfach, Ihre Node.js Webanwendungen mithilfe von Amazon Web Services bereitzustellen, zu verwalten und zu skalieren.
Sie können Ihre Anwendung in nur wenigen Minuten mithilfe der Elastic Beanstalk Command Line Interface (EB CLI) oder der Elastic Beanstalk Beanstalk-Konsole bereitstellen. Nachdem Sie Ihre Elastic Beanstalk Beanstalk-Anwendung bereitgestellt haben, können Sie weiterhin die EB-CLI verwenden, um Ihre Anwendung und Umgebung zu verwalten, oder Sie können die Elastic Beanstalk Beanstalk-Konsole verwenden, AWS CLI oder die. APIs
Folgen Sie den step-by-step Anweisungen [QuickStart für Node.js](nodejs-quickstart.md) zum Erstellen und Bereitstellen einer *Hello World* Node.js Webanwendung mit der EB CLI.
**Topics**
+ [QuickStart: Stellen Sie eine Node.js -Anwendung auf Elastic Beanstalk bereit](nodejs-quickstart.md)
+ [Einrichtung Ihrer Node.js Entwicklungsumgebung für Elastic Beanstalk](nodejs-devenv.md)
+ [Verwenden der Elastic Beanstalk Node.js-Plattform](create_deploy_nodejs.container.md)
+ [Weitere Elastic Beanstalk Beanstalk-Beispielanwendungen und Tutorials für Node.js](nodejs-getstarted.md)
+ [Eine Node.js Express-Anwendung auf Elastic Beanstalk bereitstellen](create_deploy_nodejs_express.md)
+ [Bereitstellung einer Node.js Express-Anwendung mit Clustering auf Elastic Beanstalk](nodejs-express-clustering.md)
+ [Bereitstellen einer Node.js-Anwendung mit DynamoDB in Elastic Beanstalk](nodejs-dynamodb-tutorial.md)
+ [Hinzufügen einer Amazon RDS-DB-Instance zu Ihrer Node.js Elastic Beanstalk Beanstalk-Umgebung](create-deploy-nodejs.rds.md)
+ [Tools und Ressourcen für Node.js](create_deploy_nodejs.resources.md)
# QuickStart: Stellen Sie eine Node.js -Anwendung auf Elastic Beanstalk bereit
Dieses QuickStart Tutorial führt Sie durch den Prozess der Erstellung einer Node.js -Anwendung und deren Bereitstellung in einer AWS Elastic Beanstalk Umgebung.
**Nicht für Produktionszwecke**
Beispiele dienen nur zur Veranschaulichung. Verwenden Sie keine Beispielanwendungen in der Produktion.
**Topics**
+ [Ihr AWS Konto](#nodejs-quickstart-aws-account)
+ [Voraussetzungen](#nodejs-quickstart-prereq)
+ [Schritt 1: Erstellen Sie eine Node.js -Anwendung](#nodejs-quickstart-create-app)
+ [Schritt 2: Führen Sie Ihre Anwendung lokal aus](#nodejs-quickstart-run-local)
+ [Schritt 3: Stellen Sie Ihre Anwendung Node.js mit der EB CLI bereit](#nodejs-quickstart-deploy)
+ [Schritt 4: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus](#nodejs-quickstart-run-eb-ap)
+ [Schritt 5: Bereinigen](#go-tutorial-cleanup)
+ [AWS Ressourcen für Ihre Anwendung](#nodejs-quickstart-eb-resources)
+ [Nächste Schritte](#nodejs-quickstart-next-steps)
+ [Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole](#nodejs-quickstart-console)
## Ihr AWS Konto
Wenn Sie noch kein AWS Kunde sind, müssen Sie ein AWS Konto erstellen. Wenn Sie sich registrieren, können Sie auf Elastic Beanstalk und andere AWS Dienste zugreifen, die Sie benötigen.
Wenn Sie bereits ein AWS Konto haben, können Sie weitermachen zu. [Voraussetzungen](#nodejs-quickstart-prereq)
### Erstellen Sie ein AWS Konto
#### Melde dich an für ein AWS-Konto
Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.
**Um sich für eine anzumelden AWS-Konto**
1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)
1. Folgen Sie den Online-Anweisungen.
Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.
#### Erstellen eines Benutzers mit Administratorzugriff
Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.
**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**
1. Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.
Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.
1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.
Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.
**Erstellen eines Benutzers mit Administratorzugriff**
1. Aktivieren Sie das IAM Identity Center.
Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.
*Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *
**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.
Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).
**Weiteren Benutzern Zugriff zuweisen**
1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.
Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.
Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
## Voraussetzungen
Um die Verfahren in diesem Leitfaden zu befolgen, benötigen Sie ein Befehlszeilen-Terminal oder eine Shell für die Ausführung der Befehle. Befehle werden ggf. in Auflistungen mit einem vorangestellten Eingabeaufforderungssymbol (\$1) und dem Namen des aktuellen Verzeichnisses angezeigt.
```
~/eb-project$ this is a command
this is output
```
In Linux und macOS können Sie Ihren bevorzugten Shell- und Paket-Manager verwenden. Unter Windows können Sie [das Windows-Subsystem für Linux installieren](https://docs.microsoft.com/en-us/windows/wsl/install-win10), um eine Windows-integrierte Version von Ubuntu und Bash zu erhalten.
### EB-CLI
Dieses Tutorial verwendet die Befehlszeilenschnittstelle Elastic Beanstalk Command Line Interface (EB CLI). Detaillierte Anweisungen zum Installieren und Konfigurieren der EB CLI finden Sie unter [EB CLI mit Setup-Skript installieren (empfohlen)](eb-cli3.md#eb-cli3-install) und [Konfigurieren der EB CLI](eb-cli3-configuration.md).
### Node.js
Installieren Sie Node.js auf Ihrem lokalen Computer, indem Sie den [Anweisungen zur Installation von Node.js](https://nodejs.org/en/learn/getting-started/how-to-install-nodejs) auf der Website Node.js folgen.
Überprüfen Sie Ihre Node.js -Installation, indem Sie den folgenden Befehl ausführen.
```
~$ node -v
```
## Schritt 1: Erstellen Sie eine Node.js -Anwendung
Erstellen Sie ein Projektverzeichnis.
```
~$ mkdir eb-nodejs
~$ cd eb-nodejs
```
Erstellen Sie anschließend eine Anwendung, die Sie mit Elastic Beanstalk bereitstellen. Wir werden einen „Hello World“ RESTful -Webservice erstellen.
**Example `~/eb-nodejs/server.js`**
```
const http = require('node:http');
const hostname = '127.0.0.1';
const port = 8080;
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello Elastic Beanstalk!\n');
});
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});
```
Diese Anwendung öffnet einen Listener auf Port 8080. Elastic Beanstalk leitet Anfragen für Node.js standardmäßig an Port 8080 an Ihre Anwendung weiter.
## Schritt 2: Führen Sie Ihre Anwendung lokal aus
Führen Sie den folgenden Befehl aus, um Ihre Anwendung lokal auszuführen.
```
~/eb-nodejs$ node server.js
```
Sie sollten den folgenden Text sehen.
```
Server running at http://127.0.0.1:8080/
```
Geben Sie die URL-Adresse `http://127.0.0.1:8080/` in Ihren Webbrowser ein. Der Browser sollte „Hello Elastic Beanstalk\$1“ anzeigen.
## Schritt 3: Stellen Sie Ihre Anwendung Node.js mit der EB CLI bereit
Führen Sie die folgenden Befehle aus, um eine Elastic Beanstalk Beanstalk-Umgebung für diese Anwendung zu erstellen.
**Um eine Umgebung zu erstellen und Ihre Anwendung Node.js bereitzustellen**
1. Initialisieren Sie mit dem Befehl **eb init** das EB CLI-Repository.
```
~/eb-nodejs$ eb init -p node.js nodejs-tutorial --region us-east-2
```
Dieser Befehl erstellt eine Anwendung mit dem Namen `nodejs-tutorial` und konfiguriert Ihr lokales Repository so, dass Umgebungen mit der neuesten Plattformversion von Node.js erstellt werden.
1. (Optional) Führen Sie den Vorgang **eb init** erneut aus, um ein Standardschlüsselpaar zu konfigurieren, sodass Sie SSH verwenden können, um eine Verbindung zu der EC2 Instance herzustellen, auf der Ihre Anwendung ausgeführt wird.
```
~/eb-nodejs$ eb init
Do you want to set up SSH for your instances?
(y/n): y
Select a keypair.
1) my-keypair
2) [ Create new KeyPair ]
```
Wählen Sie ein Schlüsselpaar aus (sofern vorhanden) oder befolgen Sie die Anweisungen, um ein Schlüsselpaar zu erstellen. Falls keine Anweisungen angezeigt werden oder Sie die Einstellungen später ändern möchten, führen Sie **eb init -i** aus.
1. Verwenden Sie **eb create**, um eine Umgebung zu erstellen und die Anwendung darin bereitzustellen. Elastic Beanstalk erstellt automatisch eine Zip-Datei für Ihre Anwendung und stellt sie auf einer EC2 Instanz in der Umgebung bereit. Nach der Bereitstellung Ihrer Anwendung startet Elastic Beanstalk sie auf Port 8080.
```
~/eb-nodejs$ eb create nodejs-env
```
Es dauert etwa fünf Minuten, bis Elastic Beanstalk Ihre Umgebung erstellt hat.
## Schritt 4: Führen Sie Ihre Anwendung auf Elastic Beanstalk aus
Wenn der Prozess zur Erstellung Ihrer Umgebung abgeschlossen ist, öffnen Sie Ihre Website mit. **eb open**
```
~/eb-nodejs$ eb open
```
Herzlichen Glückwunsch\$1 Sie haben eine Node.js Anwendung mit Elastic Beanstalk bereitgestellt\$1 Es wird ein Browserfenster mit dem für die Anwendung erstellten Domainnamen geöffnet.
## Schritt 5: Bereinigen
Sie können Ihre Umgebung beenden, wenn Sie mit der Arbeit an Ihrer Anwendung fertig sind. Elastic Beanstalk beendet alle AWS Ressourcen, die mit Ihrer Umgebung verknüpft sind.
Führen Sie den folgenden Befehl aus, um Ihre Elastic Beanstalk Beanstalk-Umgebung mit der EB-CLI zu beenden.
```
~/eb-nodejs$ eb terminate
```
## AWS Ressourcen für Ihre Anwendung
Sie haben gerade eine Einzelinstanzanwendung erstellt. Es dient als einfache Beispielanwendung mit einer einzigen EC2 Instanz, sodass kein Lastenausgleich oder auto Skalierung erforderlich sind. Für Einzelinstanzanwendungen erstellt Elastic Beanstalk die folgenden Ressourcen: AWS
+ **EC2 Instanz** — Eine EC2 virtuelle Maschine von Amazon, die so konfiguriert ist, dass sie Web-Apps auf der von Ihnen ausgewählten Plattform ausführt.
Jede Plattform führt eine andere Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Framework, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder nginx als Reverse-Proxy, der Web-Datenverkehr vor Ihrer Web-App verarbeitet, Anforderungen an sie weiterleitet, statische Komponenten verarbeitet und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Datenverkehr auf Port 80 zulässt. Diese Ressource ermöglicht es dem HTTP-Verkehr vom Load Balancer, die EC2 Instance zu erreichen, auf der Ihre Web-App ausgeführt wird. Standardmäßig ist Datenverkehr ist auf anderen Ports nicht zulässig.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch Amazon-Alarme** — Zwei CloudWatch Alarme, die die Auslastung der Instances in Ihrer Umgebung überwachen und ausgelöst werden, wenn die Last zu hoch oder zu niedrig ist. Wenn ein Alarm ausgelöst wird, wird Ihre Auto Scaling-Gruppe nach oben oder nach unten skaliert.
+ **CloudFormation stack** — Elastic Beanstalk verwendet CloudFormation , um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu propagieren. Die Ressourcen werden in einer Vorlage definiert, die Sie in der [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation) anzeigen können.
+ **Domainname** *— Ein Domainname, der in der Form an Ihre Web-App weitergeleitet wird. *subdomain* *region*.elasticbeanstalk.com*.
Elastic Beanstalk verwaltet all diese Ressourcen. Wenn Sie die Umgebung beenden, werden alle darin enthaltenen Ressourcen von Elastic Beanstalk beendet.
## Nächste Schritte
Nachdem Sie eine Umgebung erstellt haben, in der eine Anwendung ausgeführt wird, können Sie jederzeit eine neue Version der Anwendung oder eine andere Anwendung bereitstellen. Die Bereitstellung einer neuen Anwendungsversion ist sehr schnell, da dafür keine Bereitstellung oder Neustarts von Instances erforderlich sind. EC2 Sie können Ihre neue Umgebung auch mit der Elastic Beanstalk Beanstalk-Konsole erkunden. Ausführliche Schritte finden [Sie unter Erkunden Sie Ihre Umgebung](GettingStarted.md#GettingStarted.Explore) im Kapitel *Erste Schritte* dieses Handbuchs.
**Probieren Sie weitere Tutorials aus**
Wenn Sie andere Tutorials mit anderen Beispielanwendungen ausprobieren möchten, finden Sie weitere Informationen unter[Weitere Elastic Beanstalk Beanstalk-Beispielanwendungen und Tutorials für Node.js](nodejs-getstarted.md).
Wenn Sie eine oder zwei Beispielanwendungen bereitgestellt haben und bereit sind, Node.js -Anwendungen lokal zu entwickeln und auszuführen, finden Sie weitere Informationen unter[Einrichtung Ihrer Node.js Entwicklungsumgebung für Elastic Beanstalk](nodejs-devenv.md).
## Bereitstellung mit der Elastic Beanstalk Beanstalk-Konsole
Sie können die Beispielanwendung auch mit der Elastic Beanstalk Beanstalk-Konsole starten. Ausführliche Schritte finden Sie unter [Erstellen einer Beispielanwendung](GettingStarted.md#GettingStarted.CreateApp) im Kapitel *Erste Schritte* dieses Handbuchs.
# Einrichtung Ihrer Node.js Entwicklungsumgebung für Elastic Beanstalk
Dieses Thema enthält Anweisungen zum Einrichten einer Entwicklungsumgebung vom Typ Node.js, in der Sie Ihre Anwendung lokal testen können, bevor Sie sie bereitstellen. AWS Elastic Beanstalk Außerdem wird auf Websites verwiesen, die Installationsanweisungen für nützliche Tools bereitstellen.
**Topics**
+ [Installieren von Node.js](#nodejs-devenv-nodejs)
+ [Bestätigen der npm-Installation](#nodejs-devenv-npm)
+ [Installieren Sie das AWS SDK für Node.js](#nodejs-devenv-awssdk)
+ [Installieren des Express-Generators](#nodejs-devenv-express)
+ [Einrichten eines Express-Frameworks und eines Servers](#nodejs-devenv-express-framework)
## Installieren von Node.js
Installieren Sie Node.js, um Node.js-Anwendungen lokal auszuführen. Falls Sie keine Version bevorzugen, wählen Sie die neueste, von Elastic Beanstalk unterstützte Version aus. Eine Liste der unterstützten Versionen finden Sie unter [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) im Dokument *AWS Elastic Beanstalk -Plattformen*.
Laden Sie Node.js unter [nodejs.org](https://nodejs.org/en/) herunter.
## Bestätigen der npm-Installation
Node.js verwendet einen npm-Paketmanager, mit dem Sie Tools und Frameworks für die Verwendung in Ihrer Anwendung installieren können. npm wird mit Node.js bereitgestellt und automatisch installiert, sobald Sie Node.js herunterladen und installieren. Sie können zur Bestätigung, dass npm installiert ist, folgenden Befehl ausführen:
```
$ npm -v
```
Weitere Informationen zu npm finden Sie auf der [npmjs](https://www.npmjs.com/get-npm)-Website.
## Installieren Sie das AWS SDK für Node.js
Wenn Sie AWS Ressourcen von Ihrer Anwendung aus verwalten müssen, installieren Sie das AWS SDK für JavaScript in Node.js. So installieren Sie das SDK mit npm:
```
$ npm install aws-sdk
```
Weitere Informationen finden Sie [auf der Startseite des AWS SDK JavaScript in Node.js](https://aws.amazon.com/sdk-for-node-js/).
## Installieren des Express-Generators
Express ist ein Framework für Webanwendungen, das in Node.js ausgeführt wird. Um es zu verwenden, installieren Sie zuerst die Express-Generator-Befehlszeilenanwendung. Sobald der Express-Generator installiert ist, können Sie den **express**-Befehl ausführen, um eine Basisprojektstruktur für Ihre Webanwendung zu generieren. Sobald das Basisprojekt, die Dateien und Abhängigkeiten installiert sind, können Sie einen lokalen Express-Server auf Ihrem Entwicklungscomputer starten.
**Anmerkung**
Diese Schritte führen Sie durch die Installation des Express-Generators auf einem Linux-Betriebssystem.
Unter Linux müssen Sie, je nach Berechtigungsstufe für die Systemverzeichnisse, möglicherweise einige dieser Befehle mit dem Präfix `sudo` versehen.
**So installieren Sie den Express-Generator in Ihrer Entwicklungsumgebung**
1. Erstellen Sie ein Arbeitsverzeichnis für Ihr Express-Framework und Ihren Server.
```
~$ mkdir node-express
~$ cd node-express
```
1. Installieren Sie Express global, sodass Sie Zugriff auf den `express`-Befehl haben.
```
~/node-express$ npm install -g express-generator
```
1. Je nach Betriebssystem müssen Sie möglicherweise einen Pfad zur Ausführung des `express`-Befehls festlegen. Die Ausgabe des vorherigen Schritts gibt Auskunft darüber, ob Sie Ihre Pfadvariable setzen müssen. Im Folgenden finden Sie ein Beispiel für Linux.
```
~/node-express$ export PATH=$PATH:/usr/local/share/npm/bin/express
```
Wenn Sie den Anleitungen in diesem Kapitel folgen, müssen Sie den **express**-Befehl von verschiedenen Verzeichnissen ausführen. Jedes Tutorial richtet eine Express-Basisprojektstruktur in einem eigenen Verzeichnis ein.
Sie haben jetzt den Express-Befehlszeilengenerator installiert. Sie können damit ein Framework-Verzeichnis für Ihre Webanwendung erstellen, Abhängigkeiten einrichten und den Web-App-Server starten. Als Nächstes führen wir die Schritte durch, um dies in dem von uns erstellten `node-express`-Verzeichnis zu erreichen.
## Einrichten eines Express-Frameworks und eines Servers
Gehen Sie wie folgt vor, um die Basisverzeichnisse und -inhalte des Express-Frameworks zu erstellen. Die Tutorials in diesem Kapitel enthalten auch diese Schritte zum Einrichten des Express-Basis-Frameworks in den einzelnen Anwendungsverzeichnissen des Tutorials.
**So richten Sie ein Express-Framework und einen Server ein**
1. Führen Sie den Befehl `express` aus. Dadurch werden `package.json`, `app.js` und weitere Verzeichnisse generiert.
```
~/node-express$ express
```
Wenn Sie gefragt werden, ob Sie fortfahren möchten, geben Sie **y** ein.
1. Richten Sie lokale Abhängigkeiten ein.
```
~/node-express$ npm install
```
1. Stellen Sie sicher, dass der Web-App-Server gestartet wird.
```
~/node-express$ npm start
```
Die Ausgabe sollte folgendermaßen oder ähnlich aussehen:
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
Der Server läuft standardmäßig über Port 3000. Führen Sie als Test `curl http://localhost:3000` in einem anderen Terminal aus oder öffnen Sie einen Browser auf dem lokalen Computer und geben Sie die URL `http://localhost:3000` ein.
Drücken Sie **Strg\$1C**, um den Server zu stoppen.
# Verwenden der Elastic Beanstalk Node.js-Plattform
In diesem Thema wird beschrieben, wie Sie Ihre Node.js -Anwendungen auf Elastic Beanstalk konfigurieren, erstellen und ausführen.
AWS Elastic Beanstalk unterstützt eine Reihe von Plattformzweigen für verschiedene Versionen der Programmiersprache Node.js. Eine vollständige Liste finden Sie unter [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) im Dokument *AWS Elastic Beanstalk Platforms*.
Elastic Beanstalk bietet [Konfigurationsoptionen](command-options.md), mit denen sich die auf den EC2-Instances in der Elastic-Beanstalk-Umgebung ausgeführte Software anpassen lässt. Sie können die von Ihrer Anwendung benötigten [Umgebungsvariablen konfigurieren](environments-cfg-softwaresettings.md#environments-cfg-softwaresettings-console), die Protokollrotation an Amazon S3 aktivieren und die Ordner in der Anwendungsquelle, die statische Dateien enthalten, den vom Proxy-Server verwendeten Pfaden zuordnen.
In der Elastic Beanstalk-Konsole sind Konfigurationsoptionen für das [Ändern der Konfiguration einer ausgeführten Umgebung](environment-configuration-methods-after.md) verfügbar. Um zu verhindern, dass die Umgebungskonfiguration beim Beenden verloren geht, können Sie [gespeicherte Konfigurationen](environment-configuration-savedconfig.md) verwenden, um Ihre Einstellungen zu speichern und sie später für eine andere Umgebung zu übernehmen.
Zum Speichern der Einstellungen im Quellcode können Sie [Konfigurationsdateien](ebextensions.md) einschließen. Die Einstellungen in Konfigurationsdateien werden jedes Mal verwendet, wenn Sie eine Umgebung erstellen oder Ihre Anwendung bereitstellen. Mit Konfigurationsdateien können Sie auch Pakete installieren, Skripts ausführen und andere Instance-Anpassungen bei Bereitstellungen vornehmen.
Sie [können eine `Package.json`-Datei in Ihr Quell-Bundle aufnehmen](nodejs-platform-dependencies.md#nodejs-platform-packagejson), um Pakete während der Bereitstellung zu installieren, einen Startbefehl bereitzustellen und die Node.js-Version anzugeben, die Ihre Anwendung verwenden soll. Sie können eine [-Datei `npm-shrinkwrap.json`](nodejs-platform-shrinkwrap.md) aufnehmen, um Abhängigkeitsversionen zu sperren.
Die Node.js-Plattform umfasst einen Proxy-Server, um statische Komponenten zu verarbeiten, Datenverkehr an Ihre Anwendung weiterzuleiten und Antworten zu komprimieren. Sie können die für erweiterte Szenarien [Proxy-Standardkonfiguration erweitern oder überschreiben](nodejs-platform-proxy.md).
Es gibt verschiedene Möglichkeiten, um Ihre Anwendung zu starten. Sie können [Procfile](nodejs-configuration-procfile.md) zu Ihrem Quell-Bundle hinzufügen, um den Befehl anzugeben, mit dem Ihre Anwendung gestartet wird. Wenn Sie kein `Procfile` bereitstellen, aber stattdessen eine `package.json`-Datei verfügbar machen führt Elastic Beanstalk `npm start` aus. Wenn Sie auch dies nicht angeben, sucht Elastic Beanstalk die Datei von `app.js` oder `server.js` (in dieser Reihenfolge) und führt das Script aus.
Die in der Elastic Beanstalk-Konsole angewendeten Einstellungen überschreiben die entsprechenden Einstellungen in Konfigurationsdateien, falls vorhanden. So sind Standardeinstellungen in Konfigurationsdateien möglich, die Sie mit umgebungsspezifischen Einstellungen in der Konsole überschreiben können. Für weitere Informationen zur Rangfolge und zu anderen Methoden zum Ändern der Einstellungen siehe [Konfigurationsoptionen](command-options.md).
Details zu den verschiedenen Möglichkeiten für das Erweitern einer Linux-basierten Elastic Beanstalk-Plattform finden Sie unter [Erweitern von Elastic Beanstalk-Linux-Plattformen](platforms-linux-extend.md).
## Konfiguration der Node.js-Umgebung
Mit den Einstellungen der Node.js-Plattform können Sie das Verhalten Ihrer Amazon-EC2-Instances optimieren. Sie können die Amazon-EC2-Instance-Konfiguration der Elastic-Beanstalk-Umgebung mit der Elastic-Beanstalk-Konsole bearbeiten.
Mithilfe der Elastic Beanstalk-Konsole aktivieren Sie die Protokollrotation an Amazon S3 und konfigurieren Variablen, die die Anwendung aus der Umgebung auslesen kann.
**So konfigurieren Sie Ihre Node.js-Umgebung in der Elastic-Beanstalk-Konsole**
1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region
1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.
1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.
1. Wählen Sie in der Konfigurationskategorie **Updates, monitoring and logging ** (Updates, Überwachung und Protokolle) die Option **Edit** (Bearbeiten) aus.
### Container-Optionen
Sie können die folgenden plattformspezifischen Optionen angeben:
+ **Proxy server (Proxy-Server)** – Der Proxy-Server, der in Ihren Umgebungs-Instances verwendet werden soll. Standardmäßig wird NGINX verwendet.
### Protokolloptionen
Im Abschnitt mit den **Protokolloptionen** sind zwei Einstellungen vorhanden:
+ **Instance profile (Instance-Profil)** – Gibt das Instance-Profil an, das zum Zugriff auf den mit der Anwendung verknüpften Amazon S3-Bucket berechtigt ist.
+ **Enable log file rotation to Amazon S3** (Protokolldateirotation für Amazon S3 aktivieren) – Gibt an, ob die Protokolldateien für die Amazon-EC2-Instances der Anwendung in den der Anwendung zugeordneten Amazon-S3-Bucket kopiert werden.
### Statische Dateien
Um die Leistung zu verbessern, können Sie den Abschnitt **Static files** (Statische Dateien) benutzen, um den Proxy-Server so zu konfigurieren, dass er statische Dateien (z. B. HTML oder Bilder) aus Verzeichnissen innerhalb Ihrer Webanwendung bereitstellt. Legen Sie für jedes Verzeichnis den virtuellen Pfad zum Verzeichnis-Mapping fest. Wenn der Proxy-Server eine Anfrage nach einer Datei unter dem angegebenen Pfad erhält, stellt er die Datei direkt bereit, anstatt die Anfrage an Ihre Anwendung weiterzuleiten.
Weitere Informationen zum Konfigurieren statischer Dateien mit der Elastic Beanstalk-Konsole finden Sie unter [Bereitstellen von statischen Dateien](environment-cfg-staticfiles.md).
### Umgebungseigenschaften
Im Bereich **Environment Properties (Umgebungseigenschaften)** können Sie die Einstellungen für die Umgebungskonfiguration der Amazon-EC2-Instances angeben, auf denen die Anwendung ausgeführt wird. Diese Einstellungen werden als Schlüsselwert-Paare an die Anwendung weitergeleitet.
In der Node.js Umgebung, in der ausgeführt wird AWS Elastic Beanstalk, können Sie auf die Umgebungsvariablen zugreifen, indem Sie den Befehl ausführen`process.env.ENV_VARIABLE`.
```
var endpoint = process.env.API_ENDPOINT
```
Die Node.js-Plattform legt die PORT-Umgebungsvariable auf den Port fest, an den der Proxy-Server den Datenverkehr weiterleitet. Weitere Informationen finden Sie unter [Konfigurieren des Proxy-Server](nodejs-platform-proxy.md).
Weitere Informationen finden Sie unter [Umgebungsvariablen und andere Softwareeinstellungen](environments-cfg-softwaresettings.md).
### Konfigurieren einer Amazon Linux AMI (Vorgängerversion von Amazon Linux 2) Node.js-Umgebung
Die folgenden Konfigurationskategorien für Konsolensoftware werden nur in einer Elastic-Beanstalk-Node.js-Umgebung unterstützt, die eine Amazon-Linux-AMI-Plattformversion (vor Amazon Linux 2) verwendet.
**Hinweise**
Die Informationen in diesem Thema gelten nur für Plattformbranches, die auf Amazon Linux AMI (AL1) basieren. AL2023/AL2 Plattformbranches sind nicht mit früheren Amazon Linux AMI (AL1) -Plattformversionen kompatibel und *erfordern andere Konfigurationseinstellungen*.
[Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).
#### Container-Optionen — Amazon Linux AMI (AL1)
Geben Sie auf der Konfigurationsseite Folgendes ein:
+ **Proxy Server** (Proxy-Server) – Gibt den Webserver an, der für Proxy-Verbindungen zu Node.js verwendet werden soll. Standardmäßig wird NGINX verwendet. Wenn Sie **none** (keine) auswählen, sind statische Dateizuordnungen nicht wirksam und die GZIP-Komprimierung ist deaktiviert.
+ **Node.js-Version** – Gibt die Version von Node.js an. Die Liste der unterstützten Node.js-Versionen finden Sie unter [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) im Handbuch für *AWS Elastic Beanstalk -Plattformen*.
+ **GZIP-Komprimierung** – Gibt an, ob die GZIP-Komprimierung aktiviert ist. Die GZIP-Komprimierung ist standardmäßig aktiviert.
+ **Node Command** (Knotenbefehl) – Hier können Sie den Befehl eingeben, der zum Starten der Node.js-Anwendung verwendet wird. Eine leere Zeichenfolge (Standard) bedeutet, dass Elastic Beanstalk erst `app.js`, dann `server.js` und dann `npm start` verwendet.
## Node.js-Konfigurations-Namespace
Mithilfe einer [Konfigurationsdatei](ebextensions.md) können Sie im Rahmen der Bereitstellung Konfigurationsoptionen festlegen und andere Instance-Konfigurationsaufgaben durchführen. Die Konfigurationsoptionen können [plattformspezifisch](command-options-specific.md) sein oder für [alle Plattformen](command-options-general.md) im Elastic Beanstalk-Service als Ganzes gelten. *Die Konfigurationsoptionen sind in Namespaces organisiert.*
Sie können mittels des Namespace `aws:elasticbeanstalk:environment:proxy` den Proxy auswählen, der für die Instances Ihrer Umgebung verwendet werden soll. Im folgenden Beispiel wird Ihre Umgebung für die Verwendung des Apache HTTPD-Proxy-Server konfiguriert.
**Example .ebextensions/nodejs-settings.config**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:
ProxyServer: apache
```
Sie können den Proxy so konfigurieren, dass statische Dateien mittels des Namespace `aws:elasticbeanstalk:environment:proxy:staticfiles` bereitgestellt werden. Weitere Informationen sowie ein Beispiel finden Sie unter [Bereitstellen von statischen Dateien](environment-cfg-staticfiles.md).
Elastic Beanstalk bietet zahlreiche Konfigurationsoptionen für die Anpassung Ihrer Umgebung. Neben den Konfigurationsdateien können Sie die Konfigurationsoptionen auch unter Verwendung der Konsole, gespeicherter Konfigurationen, der EB CLI oder der AWS CLI einrichten. Weitere Informationen finden Sie unter [Konfigurationsoptionen](command-options.md).
## Die Amazon Linux AMI (Vorgängerversion von Amazon Linux 2) Node.js-Plattform
Wenn die Elastic-Beanstalk-Node.js-Umgebung eine Amazon-Linux-AMI-Plattformversion verwendet (vor Amazon Linux 2), beachten Sie die speziellen Konfigurationen und Empfehlungen in diesem Abschnitt.
**Hinweise**
Die Informationen in diesem Thema gelten nur für Plattformbranches, die auf Amazon Linux AMI (AL1) basieren. AL2023/AL2 Plattformbranches sind nicht mit früheren Amazon Linux AMI (AL1) -Plattformversionen kompatibel und *erfordern andere Konfigurationseinstellungen*.
[Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).
### Node.jsplattformspezifische Konfigurationsoptionen — Amazon Linux AMI () AL1
Elastic Beanstalk unterstützt einige plattformspezifische Konfigurationsoptionen für Amazon Linux AMI Node.js-Plattformversionen. Sie können auswählen, welchen Proxy-Server Sie vor Ihrer Anwendung ausführen möchten, eine bestimmte Version von Node.js für die Ausführung verwenden und den Befehl wählen, um Ihre Anwendung auszuführen.
Für Proxyserver können Sie einen NGINX- oder Apache-Proxy-Server verwenden. Sie können den Wert `none` auf die Option `ProxyServer` festlegen. Mit dieser Einstellung führt Elastic Beanstalk Ihre Anwendung als eigenständige Anwendung aus und nicht hinter einem Proxy-Server. Wenn in Ihrer Umgebung eine eigenständige Anwendung ausgeführt wird, aktualisieren Sie den Code so, dass dem Port zugehört wird, an den NGINX den Datenverkehr weiterleitet.
```
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log('Server running at http://127.0.0.1:%s', port);
});
```
### Node.jsSprachversionen — Amazon Linux AMI (AL1)
In Bezug auf die unterstützte Sprachversion unterscheidet sich die Amazon-Linux-AMI-Node.js-Plattform von anderen von Elastic Beanstalk verwalteten Plattformen. Das liegt daran, dass jede Node.js-Plattformversion nur wenige Node.js-Sprachversionen unterstützt. Die Liste der unterstützten Node.js-Versionen finden Sie unter [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) im Handbuch für *AWS Elastic Beanstalk -Plattformen*.
Sie können eine plattformspezifische Konfigurationsoption verwenden, um die Sprachversion festzulegen. Detaillierte Anweisungen finden Sie unter [Konfiguration der Node.js-Umgebung](#nodejs-platform-console). Alternativ können Sie die Elastic-Beanstalk-Konsole verwenden, um die Node.js-Version zu aktualisieren, die Ihre Umgebung als Teil der Aktualisierung Ihrer Plattformversion verwendet.
**Anmerkung**
Wenn die von Ihnen verwendete Version von Node.js von der Plattform nicht mehr unterstützt wird, müssen Sie die Versionseinstellung vor der Ausführung einer [Plattformaktualisierung](using-features.platform.upgrade.md) ändern oder löschen. Dieser Fall kann eintreten, wenn eine Schwachstelle für eine oder mehrere Versionen von Node.js identifiziert wird.
In diesem Fall schlägt der Versuch [NodeVersion](command-options-specific.md#command-options-nodejs)fehl, auf eine neue Version der Plattform zu aktualisieren, die die konfigurierte Version nicht unterstützt. Um zu vermeiden, dass eine neue Umgebung erstellt werden muss, ändern Sie die *NodeVersion*Konfigurationsoption in eine Version von Node.js, die sowohl von der alten als auch von der neuen Plattformversion unterstützt wird, oder [entfernen Sie die Optionseinstellung](environment-configuration-methods-after.md) und führen Sie dann das Plattformupdate durch.
**So konfigurieren Sie die Node.js-Version Ihrer Umgebung in der Elastic-Beanstalk-Konsole**
1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region
1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.
1. Wählen Sie auf der Umgebungsübersichtsseite unter **Platform (Plattform)** die Option **Change (Ändern)** aus.
1. Wählen Sie im Dialogfeld **Plattformversion aktualisieren** eine Node.js-Plattformversion aus.
![\[Bestätigen der Aktualisierung der Elastic-Beanstalk-Plattformversion\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/platform-nodejs-update-node-version.png)
1. Wählen Sie **Save** aus.
### Node.jsKonfigurations-Namespaces — Amazon Linux AMI () AL1
Die Plattform von Node.js Amazon Linux AMI definiert zusätzliche Optionen in den `aws:elasticbeanstalk:container:nodejs:staticfiles`- und `aws:elasticbeanstalk:container:nodejs`-Namespaces.
Die folgende Konfigurationsdatei weist Elastic Beanstalk an, `npm start` zum Ausführen der Anwendung zu verwenden. Sie legt auch den Proxytyp auf Apache fest und aktiviert die Komprimierung. Zuletzt konfiguriert sie den Proxy, um statische Dateien aus zwei Quellverzeichnissen bereitzustellen. Eine Quelle besteht aus HTML -Dateien unter dem Pfad `html` im Stammverzeichnis der Website aus dem Quellverzeichnis von `statichtml`. Die andere Quelle besteht aus Image-Dateien unter dem Pfad `images` im Stammverzeichnis der Website aus dem Quellverzeichnis von `staticimages`.
**Example .ebextensions/node-settings.config**
```
option_settings:
aws:elasticbeanstalk:container:nodejs:
NodeCommand: "npm start"
ProxyServer: apache
GzipCompression: true
aws:elasticbeanstalk:container:nodejs:staticfiles:
/html: statichtml
/images: staticimages
```
Elastic Beanstalk bietet zahlreiche Konfigurationsoptionen für die Anpassung Ihrer Umgebung. Neben den Konfigurationsdateien können Sie die Konfigurationsoptionen auch unter Verwendung der Konsole, gespeicherter Konfigurationen, der EB CLI oder der AWS CLI einrichten. Weitere Informationen finden Sie unter [Konfigurationsoptionen](command-options.md).
# Konfiguration benutzerdefinierter Startbefehle mit einem Procfile auf Elastic Beanstalk
Sie können eine Datei namens `Procfile` in das Stammverzeichnis des Quell-Bundles einfügen, um den Befehl anzugeben, mit dem Ihre Anwendung gestartet wird.
**Example Procfile**
```
web: node index.js
```
Informationen zur `Procfile` Verwendung finden Sie unter. [Buildfile und Procfile](platforms-linux-extend.build-proc.md)
**Anmerkung**
Dieses Feature ersetzt die ältere Option `NodeCommand` im Namespace `aws:elasticbeanstalk:container:nodejs`.
# Konfiguration der Abhängigkeiten Ihrer Anwendung von Elastic Beanstalk
Ihre Anwendung verfügt möglicherweise über Abhängigkeiten von einigen Node.js-Modulen, wie z. B. Modulen, die Sie in `require()`-Anweisungen angeben. Diese Module werden in einem `node_modules`-Verzeichnis gespeichert. Wenn Ihre Anwendung ausgeführt wird, lädt Node.js die Module aus diesem Verzeichnis. Weitere Informationen finden Sie in der Node.js-Dokumentation unter [Laden aus den Ordnern „node\$1modules“](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders).
Sie können diese Modul-Abhängigkeiten mithilfe einer `package.json`-Datei angeben. Wenn Elastic Beanstalk diese Datei erkennt und kein `node_modules`-Verzeichnis vorhanden ist, führt Elastic Beanstalk `npm install` als der *webapp*-Benutzer aus. Der `npm install`-Befehl installiert die Abhängigkeiten in dem `node_modules`-Verzeichnis, das Elastic Beanstalk zuvor erstellt hat. Der `npm install`-Befehl greift auf die in der `package.json`-Datei aufgeführten Pakete aus der öffentlichen npm-Registrierung oder von anderen Orten zu. Weitere Informationen finden Sie auf der Website [npm-Dokumente](https://docs.npmjs.com/about-the-public-npm-registry).
Wenn Elastic Beanstalk das `node_modules`-Verzeichnis erkennt, führt Elastic Beanstalk `npm install` nicht aus, auch wenn eine `package.json`-Datei existiert. Elastic Beanstalk geht davon aus, dass die Abhängigkeitspakete im `node_modules`-Verzeichnis verfügbar sind, sodass sie von Node.js abgerufen und geladen werden können.
In den folgenden Abschnitten erhalten Sie weitere Informationen zu den Node.js-Modulabhängigkeiten für Ihre Anwendung.
**Anmerkung**
Wenn bei der Ausführung von `npm install` durch Elastic Beanstalk Probleme bei der Bereitstellung auftreten, sollten Sie einen alternativen Ansatz in Betracht ziehen. Fügen Sie das `node_modules`-Verzeichnis mit den Abhängigkeiten zu Ihrem Anwendungs-Quell-Bundle hinzu. Dadurch können Sie Probleme bei der Installation von Abhängigkeiten aus der öffentlichen npm-Registry umgehen, während Sie das Problem untersuchen. Da die Abhängigkeitsmodule aus einem lokalen Verzeichnis stammen, kann dies auch dabei helfen, die Bereitstellungszeit zu verkürzen. Weitere Informationen finden Sie unter [Einschließen von Node.js-Abhängigkeiten in ein node\$1modules-Verzeichnis](#nodejs-platform-nodemodules).
## Angeben von Node.js-Abhängigkeiten mit einer package.json-Datei
Sie können mithilfe einer `package.json`-Datei im Stammverzeichnis Ihrer Projektquelle Abhängigkeitspakete angeben und einen Startbefehl bereitstellen. Wenn eine `package.json`-Datei vorhanden ist und kein `node_modules`-Verzeichnis im Stammverzeichnis Ihrer Projektquelle vorhanden ist, wird Elastic Beanstalk `npm install` als *webapp*-Benutzer ausführen, um Abhängigkeiten aus der öffentlichen npm-Registry zu installieren. Außerdem wird Elastic Beanstalk die Anwendung mit dem Befehl `start` starten. Weitere Informationen zur `package.json`-Datei finden Sie unter [Angeben von Abhängigkeiten in einer `package.json`-Datei](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file) auf der *npm-Docs-Website*.
Geben Sie mit dem Schlüsselwort `scripts` einen Startbefehl an. Derzeit wird das Schlüsselwort `scripts` anstelle der Legacy-Option `NodeCommand` im Namespace `aws:elasticbeanstalk:container:nodejs` verwendet.
**Example package.json – Express**
```
{
"name": "my-app",
"version": "0.0.1",
"private": true,
"dependencies": {
"ejs": "latest",
"aws-sdk": "latest",
"express": "latest",
"body-parser": "latest"
},
"scripts": {
"start": "node app.js"
}
}
```
**Produktionsmodus und Entwicklungsabhängigkeiten**
Verwenden Sie die Attribute *dependencies* und *devDependencies*, um Ihre Abhängigkeiten in der `package.json`-Datei anzugeben. Das Attribut *dependencies* bezeichnet Pakete, die Ihre Anwendung in der Produktion benötigt. Das Attribut *devDependencies* bezeichnet Pakete, die nur für die lokale Entwicklung und das Testen benötigt werden.
Wenn Sie die *devDependencies*-Pakete installieren müssen, setzen Sie die Umgebungseigenschaft NPM\$1USE\$1PRODUCTION auf `false`. Mit dieser Einstellung werden wir die obigen Optionen nicht verwenden, wenn wir npm install ausführen. Dies führt dazu, dass die *devDependencies*-Pakete installiert werden.
## Einschließen von Node.js-Abhängigkeiten in ein node\$1modules-Verzeichnis
Wenn Sie Abhängigkeitspakete zusammen mit Ihrem Anwendungscode in Umgebungsinstances bereitstellen möchten, fügen Sie sie in das Verzeichnis `node_modules` im Stammverzeichnis der Projektquelle ein. Weitere Informationen finden Sie unter [Pakete lokal herunterladen und installieren](https://docs.npmjs.com/downloading-and-installing-packages-locally) auf der *npm-Docs-Website*.
Wenn Sie ein `node_modules` Verzeichnis für eine AL2 Node.js Plattformversion von AL2023/bereitstellen, geht Elastic Beanstalk davon aus, dass Sie Ihre eigenen Abhängigkeitspakete bereitstellen, und vermeidet die Installation von Abhängigkeiten, die in einer [package.json-Datei](#nodejs-platform-packagejson) angegeben sind. Node.jssucht im Verzeichnis nach Abhängigkeiten. `node_modules` Weitere Informationen finden Sie unter [Laden aus node\$1modules-Ordnern](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) in der Node.js-Dokumentation.
**Anmerkung**
Wenn bei der Ausführung von `npm install` durch Elastic Beanstalk Probleme bei der Bereitstellung auftreten, sollten Sie bei der Untersuchung des Problems den in diesem Thema beschriebenen Ansatz als Workaround verwenden.
### Überlegungen zu Node.js auf Amazon Linux 2
Lesen Sie diesen Abschnitt, wenn Sie einen Plattformzweig von *Node.js* verwenden, der auf *Amazon Linux 2* ausgeführt wird.
#### Überlegungen zu Node.js auf Amazon Linux 2
**Anmerkung**
Die Informationen in diesem Thema beziehen sich auf Node.js Plattformbranches, die auf Amazon Linux 2 ausgeführt werden. In diesem Artikel werden AL2 spezifische Funktionen und Verhaltensweisen beschrieben, die sich von AL2023 unterscheiden.
**Varianten von Befehlen**
Die Befehlsoptionen variieren je nach der npm-Version, die im Amazon Linux 2-Plattformzweig enthalten ist, auf dem Ihre Anwendung ausgeführt wird.
+ npm v6 – Elastic Beanstalk installiert die Abhängigkeiten standardmäßig im Produktionsmodus. Es verwendet den Befehl `npm install --production`.
+ npm v7 oder höher – Elastic Beanstalk lässt die *devDependencies* weg. Es verwendet den Befehl `npm install --omit=dev`.
Beide oben aufgeführten Befehle installieren keine Pakete, bei denen es sich um *devDependencies* handelt.
**SSH- und HTTPS-Protokolle für Git-Abhängigkeiten**
Ab der Amazon Linux 2-Plattformversion vom 7. März 2023 können Sie die Protokolle SSH und HTTPS verwenden, um Pakete aus einem Git-Repository abzurufen. Plattformzweig Node.js 16 unterstützt sowohl das SSH- als auch das HTTPS-Protokoll. Node.js 14 unterstützt nur das HTTPS-Protokoll.
**Example package.json – Node.js 16 unterstützt sowohl HTTPS als auch SSH**
```
...
"dependencies": {
"aws-sdk": "https://github.com/aws/aws-sdk-js.git",
"aws-chime": "git+ssh://git@github.com:aws/amazon-chime-sdk-js.git"
}
```
**Versionen und Versionsbereiche**
Verwenden Sie das Schlüsselwort `engines` in der Datei `package.json`, um die Node.js-Version anzugeben, die Ihre Anwendung verwenden soll. Mit der npm-Notation können Sie auch einen Versionsbereich angeben. Weitere Informationen zur Syntax für Versionsbereiche finden Sie unter [Semantische Versionsverwaltung mit npm](https://nodejs.dev/learn/semantic-versioning-using-npm) auf der Website Node.js. Das Schlüsselwort `engines` in der Node.js `package.json`-Datei ersetzt die ältere Option `NodeVersion` im `aws:elasticbeanstalk:container:nodejs`-Namespace.
**Wichtig**
Die Funktion zur Angabe von Versionsbereichen ist für Plattformzweige von Node.js, auf AL2023 denen sie ausgeführt werden, nicht verfügbar. Wir unterstützen nur eine Version von Node.js innerhalb einer bestimmten Node.js -Verzweigung auf AL2023. Wenn Ihre `package.json`-Datei einen Versionsbereich angibt, ignorieren wir diesen und verwenden standardmäßig die Version des Plattformzweigs von Node.js.
**Example `package.json` – Einzelne Node.js-Version**
```
{
...
"engines": { "node" : "14.16.0" }
}
```
**Example `package.json` – Node.js Versionsbereich**
```
{
...
"engines": { "node" : ">=10 <11" }
}
```
Wenn ein Versionsbereich angegeben wird, installiert Elastic Beanstalk die neueste Node.js-Version, die der Plattform innerhalb des Bereichs zur Verfügung steht. In diesem Beispiel gibt der Bereich an, dass die Version größer oder gleich als Version 10 sein muss, aber kleiner als Version 11. Infolgedessen installiert Elastic Beanstalk die neueste Version von Node.js 10.x.y, die auf der [unterstützten Plattform](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) verfügbar ist.
Beachten Sie, dass Sie jeweils nur eine Node.js-Version angeben können, die Ihrem Plattformzweig entspricht. Wenn Sie beispielsweise den Plattformzweig Node.js 16 verwenden, können Sie nur eine 16.x.y-Version Node.js angeben. Sie können die von npm unterstützten Versionsbereichsoptionen verwenden, um eine größere Flexibilität zu ermöglichen. Gültige Versionen von Node.js für jeden Plattformzweig finden Sie unter [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) im Handbuch *AWS Elastic Beanstalk -Plattformen*.
**Anmerkung**
Wenn die von Ihnen verwendete Version von Node.js von der Plattform nicht mehr unterstützt wird, müssen Sie die Einstellung der Node.js-Version vor der Ausführung einer [Plattform-Aktualisierung](using-features.platform.upgrade.md) ändern oder löschen. Dieser Fall kann eintreten, wenn eine Schwachstelle bei einer oder mehreren Versionen von Node.js identifiziert wird.
In diesem Fall schlägt die Aktualisierung auf eine neue Plattformversion, die die konfigurierte Node.js-Version nicht unterstützt, fehl. Um zu vermeiden, dass eine neue Umgebung erstellt werden muss, ändern Sie die Einstellung der Node.js-Version in `package.json` in eine Node.js-Version, die sowohl von der alten als auch von der neuen Version unterstützt wird. Sie können einen Node.js-Versionsbereich angeben, der eine unterstützte Version enthält, wie oben in diesem Thema beschrieben. Außerdem können Sie die Einstellung entfernen und dann das neue Quellpaket bereitstellen.
# Sperren von Abhängigkeiten mit npm shrinkwrap auf Elastic Beanstalk
Die Node.js-Plattform führt `npm install` als *webapp*-Benutzer bei jeder Bereitstellung aus. Wenn neue Versionen Ihrer Abhängigkeiten verfügbar sind, werden diese installiert, wenn Sie Ihre Anwendung bereitstellen. Dadurch kann die Bereitstellung möglicherweise sehr lange dauern.
Sie können eine Aktualisierung Ihrer Abhängigkeiten vermeiden, indem Sie eine `npm-shrinkwrap.json`-Datei erstellen, die die Abhängigkeiten Ihrer Anwendung von der aktuellen Version sperrt.
```
$ npm install
$ npm shrinkwrap
wrote npm-shrinkwrap.json
```
Fügen Sie diese Datei in Ihr Quell-Bundle sein, um sicherzustellen, dass Abhängigkeiten nur einmal installiert werden.
# Konfigurieren des Proxy-Server
Elastic Beanstalk kann NGINX oder Apache-HTTPD als Reverse-Proxy verwenden, um die Anwendung dem Load Balancer von Elastic Load Balancing auf Port 80 zuzuweisen. Der Standardwert ist NGINX. Elastic Beanstalk bietet eine Proxy-Standard-Proxykonfiguration, die Sie entweder erweitern oder gänzlich mit einer eigenen Konfiguration überschreiben können.
Standardmäßig wird der Proxy von Elastic Beanstalk für die Weiterleitung von Anforderungen an die Anwendung auf Port 5000 konfiguriert. Sie können den Standardport überschreiben, indem Sie für die `PORT`-[Umgebungseigenschaft](create_deploy_nodejs.container.md#nodejs-platform-console) den Überwachungsport Ihrer Hauptanwendung festlegen.
**Anmerkung**
Der Port, den Ihre Anwendung überwacht, hat keinen Einfluss auf den Port, den der NGINX-Server überwacht, um Anfragen vom Load Balancer zu empfangen.
**Konfigurieren des Proxy-Servers auf Ihrer Plattformversion**
Alle AL2023 AL2 /-Plattformen unterstützen eine einheitliche Proxy-Konfigurationsfunktion. Weitere Informationen zur Konfiguration des Proxyservers auf Ihren Plattformversionen, auf denen AL2023/ausgeführt wirdAL2, finden Sie unter[Reverse-Proxy-Konfiguration](platforms-linux-extend.proxy.md).
## Konfigurieren des Proxys in Amazon Linux AMI (Vorgängerversion von Amazon Linux 2)
Wenn Ihre Elastic Beanstalk Node.js-Umgebung eine Amazon-Linux-AMI-Plattformversion verwendet (Vorgängerversion von Amazon Linux 2), lesen Sie die Informationen in diesem Abschnitt.
**Hinweise**
Die Informationen in diesem Thema gelten nur für Plattformbranches, die auf Amazon Linux AMI (AL1) basieren. AL2023/AL2 Plattformbranches sind nicht mit früheren Amazon Linux AMI (AL1) -Plattformversionen kompatibel und *erfordern andere Konfigurationseinstellungen*.
[Am 18. Juli 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **hat Elastic Beanstalk den Status aller Plattformbranches, die auf Amazon Linux AMI (AL1) basieren, auf eingestellt gesetzt.** Weitere Informationen zur Migration zu einem aktuellen und vollständig unterstützten Plattformzweig für Amazon Linux 2023 finden Sie unter [Migrieren der Elastic-Beanstalk-Linux-Anwendung zu Amazon Linux 2023 oder Amazon Linux 2](using-features.migration-al.md).
### Erweiterung und Außerkraftsetzung der Standard-Proxykonfiguration — Amazon Linux AMI () AL1
Die Node.js-Plattform verwendet einen Reverse-Proxy-Server, um Anforderungen von Port 80 auf der Instance an die Anwendung weiterzuleiten, welche Port 8081 überwacht. Elastic Beanstalk bietet eine Proxy-Standard-Proxykonfiguration, die Sie entweder erweitern oder gänzlich mit einer eigenen Konfiguration überschreiben können.
Um die Standardkonfiguration zu erweitern, fügen Sie `.conf`-Dateien zu `/etc/nginx/conf.d` mit einer Konfigurationsdatei hinzu. Ein spezifisches Beispiel finden Sie unter [Beenden von HTTPS auf EC2-Instances, auf denen Node.js ausgeführt wird](https-singleinstance-nodejs.md).
Die Node.js-Plattform legt die PORT-Umgebungsvariable auf den Port fest, an den der Proxy-Server den Datenverkehr weiterleitet. Lesen Sie diese Variable in Ihrem Code, um den Port Ihrer Anwendung zu konfigurieren.
```
var port = process.env.PORT || 3000;
var server = app.listen(port, function () {
console.log('Server running at http://127.0.0.1:' + port + '/');
});
```
Die standardmäßige NGINX-Konfiguration leitet Datenverkehr an einen Upstream-Server mit dem Namen `nodejs` auf `127.0.0.1:8081` weiter. Sie können die Standardkonfiguration entfernen und Ihre eigene in einer [Konfigurationsdatei](ebextensions.md) bereitstellen.
**Example .ebextensions/proxy.config**
Im folgenden Beispiel wird die Standard-Konfiguration entfernt und eine benutzerdefinierte Konfiguration hinzugefügt, die Datenverkehr an Port 5000 anstatt an 8081 weiterleitet.
```
files:
/etc/nginx/conf.d/proxy.conf:
mode: "000644"
owner: root
group: root
content: |
upstream nodejs {
server 127.0.0.1:5000;
keepalive 256;
}
server {
listen 8080;
if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
set $year $1;
set $month $2;
set $day $3;
set $hour $4;
}
access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
access_log /var/log/nginx/access.log main;
location / {
proxy_pass http://nodejs;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
gzip on;
gzip_comp_level 4;
gzip_types text/html text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
location /static {
alias /var/app/current/static;
}
}
/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh:
mode: "000755"
owner: root
group: root
content: |
#!/bin/bash -xe
rm -f /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf
service nginx stop
service nginx start
container_commands:
removeconfig:
command: "rm -f /tmp/deployment/config/#etc#nginx#conf.d#00_elastic_beanstalk_proxy.conf /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf"
```
Die Beispielkonfiguration (`/etc/nginx/conf.d/proxy.conf`) verwendet die Standardkonfiguration unter `/etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf` als Basis, um den Standard-Serverblock mit Komprimierungs- und Protokolleinstellungen und eine statische Dateizuordnung einzuschließen.
Der `removeconfig`-Befehl entfernt die Standardkonfiguration für den Container, um sicherzustellen, dass der Proxy-Server die benutzerdefinierte Konfiguration verwendet. Elastic Beanstalk erstellt die Standardkonfiguration während jeder Konfigurationsbereitstellung neu. Um dies zu berücksichtigen, wird im folgenden Beispiel ein post-configuration-deployment Hook (`/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh`) hinzugefügt. Dadurch wird die Standardkonfiguration entfernt und der Proxy-Server neu gestartet.
**Anmerkung**
Die Standardkonfiguration kann sich in späteren Versionen der Node.js-Plattform ändern. Verwenden Sie die neueste Version der Konfiguration als Grundlage für Ihre Anpassungen, um Kompatibilität sicherzustellen.
Wenn Sie die Standardkonfiguration überschreiben, müssen Sie alle statischen Dateizuordnungen und die GZIP-Komprimierung definieren. Das liegt daran, dass die Plattform die [Standardeinstellungen](create_deploy_nodejs.container.md#nodejs-namespaces) nicht anwenden kann.
# Weitere Elastic Beanstalk Beanstalk-Beispielanwendungen und Tutorials für Node.js
Dieser Abschnitt enthält zusätzliche Anwendungen und Tutorials. Das zuvor in diesem [QuickStart für Node.js](nodejs-quickstart.md) Thema befindliche Thema führt Sie durch den Start der Beispielanwendung Node.js mit der EB CLI.
Um mit den Anwendungen Node.js loszulegen AWS Elastic Beanstalk, benötigen Sie lediglich ein [Anwendungsquellpaket](applications-sourcebundle.md), das Sie als erste Anwendungsversion hochladen und in einer Umgebung bereitstellen können.
## Starten einer Umgebung mit einer Beispielanwendung von Node.js
Elastic Beanstalk bietet einseitige Beispielanwendungen für jede Plattform sowie komplexere Beispiele, die die Verwendung zusätzlicher AWS Ressourcen wie Amazon RDS und sprach- oder plattformspezifische Funktionen und zeigen. APIs
**Anmerkung**
Folgen Sie den Schritten in der `README.md`-Quellpaketdatei, um sie bereitzustellen.
**Beispiele**
| Umgebungstyp | Quell-Bundle | Description |
| --- | --- | --- |
| Webserver | [nodejs.zip](samples/nodejs.zip) | Anwendung mit einer Seite. Informationen zum Starten der Beispielanwendung mit der EB-CLI finden Sie unter[QuickStart für Node.js](nodejs-quickstart.md). Sie können die Beispielanwendung auch mit der Elastic Beanstalk Beanstalk-Konsole starten. Ausführliche Schritte finden Sie unter [Erstellen einer Beispielanwendung](GettingStarted.md#GettingStarted.CreateApp) im Kapitel *Erste Schritte* dieses Handbuchs. |
| Webserver mit Amazon RDS | [nodejs-example-express-rds.zip](samples/nodejs-example-express-rds.zip) | Hiking-Protokollanwendung, die das Express-Framework und eine Amazon Relational Database Service (RDS)-Datenbank verwendet. [Praktische Anleitung](create_deploy_nodejs_express.md) |
| Webserver mit Amazon ElastiCache | [nodejs-example-express-elasticache.zip](samples/nodejs-example-express-elasticache.zip) | Express-Webanwendung, die Amazon ElastiCache für Clustering verwendet. Mit Clustering lassen sich hohe Verfügbarkeit, Leistung und Sicherheit Ihrer Webanwendung verbessern. [Praktische Anleitung](nodejs-express-clustering.md) |
| Webserver mit DynamoDB, Amazon SNS und Amazon SQS | [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) | Express-Website, die Kontaktinformationen der Benutzer für eine neue Marketingkampagne des Unternehmens sammelt. Verwendet das AWS SDK für JavaScript in Node.js, um Einträge in eine DynamoDB-Tabelle zu schreiben, und Elastic Beanstalk Beanstalk-Konfigurationsdateien, um Ressourcen in DynamoDB, Amazon SNS und Amazon SQS zu erstellen. [Praktische Anleitung](nodejs-dynamodb-tutorial.md) |
## Nächste Schritte
Nachdem Sie eine Umgebung erstellt haben, in der eine Anwendung ausgeführt wird, können Sie jederzeit eine neue Version der Anwendung oder eine gänzlich andere Anwendung bereitstellen. Das Bereitstellen einer neuen Anwendungsversion geht sehr schnell, da keine EC2-Instances bereitgestellt oder neu gestartet werden müssen. Weitere Informationen zur Anwendungsbereitstellung finden Sie unter [Bereitstellen einer neuen Version Ihrer Anwendung](GettingStarted.md#GettingStarted.DeployApp).
Nachdem Sie ein oder zwei Beispielanwendungen bereitgestellt haben und bereit sind, Node.js -Anwendungen lokal zu entwickeln und auszuführen, lesen Sie, wie Sie [Einrichtung Ihrer Node.js Entwicklungsumgebung für Elastic Beanstalk](nodejs-devenv.md) eine Node.js -Entwicklungsumgebung mit allen Tools einrichten, die Sie benötigen.
# Eine Node.js Express-Anwendung auf Elastic Beanstalk bereitstellen
[In diesem Abschnitt erfahren Sie, wie Sie mithilfe der Elastic Beanstalk Command Line Interface (EB CLI) eine Beispielanwendung auf Elastic Beanstalk bereitstellen und anschließend die Anwendung für die Verwendung des Express-Frameworks aktualisieren.](http://expressjs.com/)
## Voraussetzungen
Für dieses Tutorial sind die folgenden Voraussetzungen erforderlich:
+ Die Node.js-Laufzeiten
+ Die Standard-Paketmanager-Software von Node.js, npm
+ Der Express-Befehlszeilengenerator
+ Die Elastic Beanstalk Command Line Interface (EB CLI)
Weitere Informationen zur Installation dieser ersten drei Komponenten und zur Einrichtung Ihrer lokalen Entwicklungsumgebung finden Sie unter [Einrichtung Ihrer Node.js Entwicklungsumgebung für Elastic Beanstalk](nodejs-devenv.md). Für dieses Tutorial müssen Sie das AWS SDK für Node.js nicht installieren, das auch im referenzierten Thema erwähnt wird.
Detaillierte Anweisungen zum Installieren und Konfigurieren der EB-CLI finden Sie unter [EB CLI mit Setup-Skript installieren (empfohlen)](eb-cli3.md#eb-cli3-install) und [Konfigurieren der EB CLI](eb-cli3-configuration.md).
## Erstellen einer Elastic Beanstalk-Umgebung
**Ihr Anwendungsverzeichnis**
In diesem Tutorial wird ein Verzeichnis verwendet, das als `nodejs-example-express-rds` für das Anwendungsquellpaket bezeichnet wird. Erstellen Sie das `nodejs-example-express-rds`-Verzeichnis für dieses Tutorial.
```
~$ mkdir nodejs-example-express-rds
```
**Anmerkung**
Jedes Tutorial in diesem Kapitel verwendet ein eigenes Verzeichnis für das Anwendungsquellpaket. Der Verzeichnisname entspricht dem Namen der Beispielanwendung, die im Tutorial verwendet wird.
Ändern Sie Ihr aktuelles Arbeitsverzeichnis zu `nodejs-example-express-rds`.
```
~$ cd nodejs-example-express-rds
```
Jetzt können wir eine Elastic-Beanstalk-Umgebung mit der Node.js und der Beispielanwendung einrichten. Wir werden die Elastic-Beanstalk-Befehlszeilenschnittstelle (EB-CLI) verwenden.
**So konfigurieren Sie ein EB-CLI-Repository für Ihre Anwendung und erstellen eine Elastic-Beanstalk-Umgebung mit der Node.js-Plattform**
1. Erstellen Sie ein Repository mit dem Befehl **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-express-rds$ eb init --platform node.js --region
```
Mit diesem Befehl wird eine Konfigurationsdatei in einem Ordner mit dem Namen `.elasticbeanstalk` generiert. Sie gibt die Einstellungen für die Erstellung von Umgebungen für Ihre Anwendung an und erstellt eine Elastic Beanstalk-Anwendung mit dem Namen des aktuellen Ordners.
1. Erstellen Sie mit dem Befehl **[**eb create**](eb3-create.md)** eine Umgebung mit einer laufenden Beispielanwendung.
```
~/nodejs-example-express-rds$ eb create --sample nodejs-example-express-rds
```
Mit diesem Befehl wird eine Umgebung mit Lastausgleich, den Standardeinstellungen für die Node.js-Plattform und den folgenden Ressourcen erstellt:
+ **EC2 Instanz** — Eine virtuelle Maschine von Amazon Elastic Compute Cloud (Amazon EC2), die für die Ausführung von Web-Apps auf der von Ihnen ausgewählten Plattform konfiguriert ist.
Jede Plattform führt eine spezifische Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Frameworks, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder NGINX als Reverseproxy, der vor der Web-App platziert ist, Anforderungen weiterleitet, statische Komponenten bedient und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Datenverkehr auf Port 80 zulässt. Diese Ressource ermöglicht es dem HTTP-Verkehr vom Load Balancer, die EC2 Instance zu erreichen, auf der Ihre Web-App ausgeführt wird. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.
+ **Load balancer (Load Balancer)**– Ein Elastic Load Balancing Load Balancer ist für die Verteilung von Anforderungen an die Instances, auf denen Ihre Anwendung ausgeführt wird, konfiguriert. Mit einem Load Balancer müssen Ihre Instances nicht mehr direkt für das Internet zugänglich gemacht werden.
+ **Load Balancer-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Verkehr auf Port 80 zulässt. Diese Ressource ermöglicht, dass HTTP-Datenverkehr aus dem Internet den Load Balancer erreicht. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.
+ **Auto Scaling group (Auto Scaling-Gruppe)** – Eine Auto Scaling-Gruppe, die so konfiguriert ist, dass sie eine Instance ersetzt, wenn diese beendet wird oder nicht verfügbar ist.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch CloudWatch Amazon-Alarme** — Zwei Alarme, die die Auslastung der Instances in Ihrer Umgebung überwachen und ausgelöst werden, wenn die Last zu hoch oder zu niedrig ist. Wenn ein Alarm ausgelöst wird, wird Ihre Auto Scaling-Gruppe nach oben oder nach unten skaliert.
+ **CloudFormation Stack** — Elastic Beanstalk verwendet CloudFormation , um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu propagieren. Die Ressourcen werden in einer Vorlage definiert, die Sie in der [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation) anzeigen können.
+ **Domainname** *— Ein Domainname, der in der Form an Ihre Web-App weitergeleitet wird. *subdomain* *region*.elasticbeanstalk.com*.
**Domain-Sicherheit**
[Um die Sicherheit Ihrer Elastic-Beanstalk-Anwendungen zu erhöhen, ist die Domain *elasticbeanstalk.com* in der Public Suffix List (PSL) registriert.](https://publicsuffix.org/)
Wenn Sie jemals sensible Cookies im Standard-Domainnamen für Ihre Elastic Beanstalk Beanstalk-Anwendungen einrichten müssen, empfehlen wir Ihnen, Cookies mit einem `__Host-` Präfix zu verwenden, um die Sicherheit zu erhöhen. Diese Vorgehensweise schützt Ihre Domain vor Cross-Site-Request-Forgery-Versuchen (CSRF). Weitere Informationen finden Sie auf der [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes)-Seite im Mozilla Developer Network.
1. Wenn die Umgebungserstellung abgeschlossen ist, verwenden Sie den Befehl [**eb open**](eb3-open.md), um die URL der Umgebung im Standardbrowser zu öffnen.
```
~/nodejs-example-express-rds$ eb open
```
Sie haben jetzt eine Node.js Elastic-Beanstalk-Umgebung mit einer Beispielanwendung erstellt. Sie können sie mit Ihrer eigenen Anwendung aktualisieren. Als nächstes aktualisieren wir die Beispielanwendung, um das Express-Framework zu verwenden.
## Aktualisieren der Anwendung zur Nutzung von Express
Nachdem Sie eine Umgebung mit einer Beispielanwendung erstellt haben, können Sie diese mit Ihrer eigenen Anwendung aktualisieren. In diesem Verfahren führen wir zunächst die **express**- und **npm install**-Befehle aus, um das Express-Framework in Ihrem Anwendungsverzeichnis einzurichten. Dann verwenden wir die EB CLI, um Ihre Elastic-Beanstalk-Umgebung mit der aktualisierten Anwendung zu aktualisieren.
**So aktualisieren Sie die Anwendung zur Nutzung von Express**
1. Führen Sie den Befehl `express` aus. Dadurch werden `package.json`, `app.js` und weitere Verzeichnisse generiert.
```
~/nodejs-example-express-rds$ express
```
Wenn Sie gefragt werden, ob Sie fortfahren möchten, geben Sie **y** ein.
**Anmerkung**
Wenn der **express**-Befehl nicht funktioniert, haben Sie den Express-Befehlszeilengenerator möglicherweise nicht installiert, wie im vorherigen Abschnitt mit den *Voraussetzungen* beschrieben. Oder die Verzeichnispfadeinstellung für Ihren lokalen Computer muss möglicherweise eingerichtet werden, um den **express**-Befehl auszuführen. Im Abschnitt *Voraussetzungen* finden Sie detaillierte Schritte zum Einrichten Ihrer Entwicklungsumgebung, sodass Sie mit diesem Tutorial fortfahren können.
1. Richten Sie lokale Abhängigkeiten ein.
```
~/nodejs-example-express-rds$ npm install
```
1. (Optional) Stellen Sie sicher, dass der Web-Anwendungs-Server startet.
```
~/nodejs-example-express-rds$ npm start
```
Die Ausgabe sollte folgendermaßen oder ähnlich aussehen:
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
Der Server läuft standardmäßig über Port 3000. Führen Sie als Test `curl http://localhost:3000` in einem anderen Terminal aus oder öffnen Sie einen Browser auf dem lokalen Computer und geben Sie die URL `http://localhost:3000` ein.
Drücken Sie **Strg\$1C**, um den Server zu stoppen.
1. Stellen Sie die Änderungen in Ihrer Elastic-Beanstalk-Umgebung mit dem Befehl [**eb deploy**](eb3-deploy.md) bereit.
```
~/nodejs-example-express-rds$ eb deploy
```
1. Sobald die Umgebung grün und einsatzbereit ist, aktualisieren Sie die URL, um die ordnungsgemäße Funktionsweise zu prüfen. Sie sollten eine Webseite mit dem Text **Welcome to Express** sehen.
Aktualisieren wir jetzt die Express-Anwendung für die Bereitstellung statischer Dateien und das Hinzufügen einer neuen Seite.
**So konfigurieren Sie statische Dateien und fügen eine neue Seite zu Ihrer Express-Anwendung hinzu**
1. Fügen Sie eine zweite Konfigurationsdatei in den [`.ebextensions`](ebextensions.md)-Ordner mit dem folgenden Inhalt hinzu:
**`nodejs-example-express-rds/.ebextensions/staticfiles.config`**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:staticfiles:
/stylesheets: public/stylesheets
```
Mit dieser Einstellung wird konfiguriert, dass der Proxy-Server Dateien im `public`-Ordner im Pfad `/public` der Anwendung bereitstellt. Das statische Bereitstellen von Dateien vom Proxy-Server reduziert die Last Ihrer Anwendung. Weitere Informationen finden Sie unter [Statische Dateien](create_deploy_nodejs.container.md#nodejs-platform-console-staticfiles) weiter oben in diesem Kapitel.
1. (Optional) Um zu überprüfen, ob statische Mappings korrekt konfiguriert sind, kommentieren Sie die statische Mapping-Konfiguration unter `nodejs-example-express-rds/app.js` aus. Dadurch wird das Mapping aus der Knotenanwendung entfernt.
```
// app.use(express.static(path.join(__dirname, 'public')));
```
Die statischen Dateizuordnungen in der `staticfiles.config`-Datei aus dem vorherigen Schritt sollten das Stylesheet immer noch erfolgreich laden, auch wenn Sie diese Zeile auskommentiert haben. Um zu überprüfen, ob die statischen Dateizuordnungen über die statische Proxydateikonfiguration und nicht über die Express-Anwendung geladen werden, entfernen Sie die auf `option_settings:` folgenden Werte. Nachdem es sowohl aus der statischen Dateikonfiguration als auch aus der Knotenanwendung entfernt wurde, kann das Stylesheet nicht geladen werden.
Denken Sie daran, den Inhalt `nodejs-example-express-rds/app.js` und `staticfiles.config` nach dem Testen zurückzusetzen.
1. Fügen Sie `nodejs-example-express-rds/routes/hike.js` hinzu. Geben Sie Folgendes ein:
```
exports.index = function(req, res) {
res.render('hike', {title: 'My Hiking Log'});
};
exports.add_hike = function(req, res) {
};
```
1. Aktualisieren Sie `nodejs-example-express-rds/app.js`, um drei neue Zeilen hinzuzufügen.
Fügen Sie zuerst die folgende Zeile hinzu, um einen `require` für diese Route hinzuzufügen:
```
var hike = require('./routes/hike');
```
Die Datei sollte wie im folgenden Ausschnitt aussehen:
```
var express = require('express');
var path = require('path');
var hike = require('./routes/hike');
```
Fügen Sie anschließend die folgenden beiden Zeilen zu `nodejs-example-express-rds/app.js` nach `var app = express();` hinzu.
```
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
```
Die Datei sollte wie im folgenden Ausschnitt aussehen:
```
var app = express();
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
```
1. Kopieren Sie `nodejs-example-express-rds/views/index.jade` in `nodejs-example-express-rds/views/hike.jade`.
```
~/nodejs-example-express-rds$ cp views/index.jade views/hike.jade
```
1. Stellen Sie die Änderungen mit dem [**eb deploy**](eb3-deploy.md)-Befehl bereit.
```
~/nodejs-example-express-rds$ eb deploy
```
1. Die Umgebung wird nach einigen Minuten aktualisiert. Nachdem Ihre Umgebung grün und bereit ist, überprüfen Sie das Funktionieren durch Aktualisieren Ihres Browsers und Anfügen von **hikes** am Ende der URL (z. B. `http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes`).
Sie sollten eine Webseite mit dem Titel **My Hiking Log (Mein Hiking-Protokoll)** sehen.
Sie haben jetzt eine Webanwendung erstellt, die das Express-Framework nutzt. Im nächsten Abschnitt ändern wir die Anwendung so, dass sie einen Amazon Relational Database Service (RDS) zum Speichern eines Wanderprotokolls verwendet.
## Aktualisieren der Anwendung, um Amazon RDS zu nutzen
In diesem nächsten Schritt aktualisieren wir die Anwendung, um Amazon RDS für MySQL zu verwenden.
**So aktualisieren Sie die Anwendung zur Nutzung von RDS für MySQL**
1. Um eine RDS-für-MySQL-Datenbank zu erstellen, die an Ihre Elastic-Beanstalk-Umgebung gekoppelt ist, folgen Sie den Anweisungen im Thema [Hinzufügen einer Datenbank](create-deploy-nodejs.rds.md) weiter unten in diesem Kapitel. Das Hinzufügen einer Datenbank-Instance dauert ca. 10 Minuten.
1. Aktualisieren Sie den Abschnitt Abhängigkeiten in der `package.json` mit dem folgenden Inhalt:
```
"dependencies": {
"async": "^3.2.4",
"express": "4.18.2",
"jade": "1.11.0",
"mysql": "2.18.1",
"node-uuid": "^1.4.8",
"body-parser": "^1.20.1",
"method-override": "^3.0.0",
"morgan": "^1.10.0",
"errorhandler": "^1.5.1"
}
```
1. Führen Sie **npm install**.
```
~/nodejs-example-express-rds$ npm install
```
1. Aktualisieren Sie `app.js`, um eine Verbindung zur Datenbank herzustellen, eine Tabelle zu erstellen und ein einzelnes Standard-Wanderprotokoll einzufügen. Jedes Mal, wenn diese Anwendung bereitgestellt wird, wird die Tabelle der vorherigen Wanderungen gelöscht und neu erstellt.
```
/**
* Module dependencies.
*/
const express = require('express')
, routes = require('./routes')
, hike = require('./routes/hike')
, http = require('http')
, path = require('path')
, mysql = require('mysql')
, async = require('async')
, bodyParser = require('body-parser')
, methodOverride = require('method-override')
, morgan = require('morgan')
, errorhandler = require('errorhandler');
const { connect } = require('http2');
const app = express()
app.set('views', __dirname + '/views')
app.set('view engine', 'jade')
app.use(methodOverride())
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(express.static(path.join(__dirname, 'public')))
app.set('connection', mysql.createConnection({
host: process.env.RDS_HOSTNAME,
user: process.env.RDS_USERNAME,
password: process.env.RDS_PASSWORD,
port: process.env.RDS_PORT}));
function init() {
app.get('/', routes.index);
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
}
const client = app.get('connection');
async.series([
function connect(callback) {
client.connect(callback);
console.log('Connected!');
},
function clear(callback) {
client.query('DROP DATABASE IF EXISTS mynode_db', callback);
},
function create_db(callback) {
client.query('CREATE DATABASE mynode_db', callback);
},
function use_db(callback) {
client.query('USE mynode_db', callback);
},
function create_table(callback) {
client.query('CREATE TABLE HIKES (' +
'ID VARCHAR(40), ' +
'HIKE_DATE DATE, ' +
'NAME VARCHAR(40), ' +
'DISTANCE VARCHAR(40), ' +
'LOCATION VARCHAR(40), ' +
'WEATHER VARCHAR(40), ' +
'PRIMARY KEY(ID))', callback);
},
function insert_default(callback) {
const hike = {HIKE_DATE: new Date(), NAME: 'Hazard Stevens',
LOCATION: 'Mt Rainier', DISTANCE: '4,027m vertical', WEATHER:'Bad', ID: '12345'};
client.query('INSERT INTO HIKES set ?', hike, callback);
}
], function (err, results) {
if (err) {
console.log('Exception initializing database.');
throw err;
} else {
console.log('Database initialization complete.');
init();
}
});
module.exports = app
```
1. Fügen Sie `routes/hike.js` den folgenden Inhalt hinzu. Dadurch können die Routen neue Wanderprotokolle in die *HIKES*-Datenbank einfügen.
```
const uuid = require('node-uuid');
exports.index = function(req, res) {
res.app.get('connection').query( 'SELECT * FROM HIKES', function(err,
rows) {
if (err) {
res.send(err);
} else {
console.log(JSON.stringify(rows));
res.render('hike', {title: 'My Hiking Log', hikes: rows});
}});
};
exports.add_hike = function(req, res){
const input = req.body.hike;
const hike = { HIKE_DATE: new Date(), ID: uuid.v4(), NAME: input.NAME,
LOCATION: input.LOCATION, DISTANCE: input.DISTANCE, WEATHER: input.WEATHER};
console.log('Request to log hike:' + JSON.stringify(hike));
req.app.get('connection').query('INSERT INTO HIKES set ?', hike, function(err) {
if (err) {
res.send(err);
} else {
res.redirect('/hikes');
}
});
};
```
1. Ersetzen Sie den Inhalt von `routes/index.js` durch Folgendes:
```
/*
* GET home page.
*/
exports.index = function(req, res){
res.render('index', { title: 'Express' });
};
```
1. Fügen Sie die folgende Jade-Vorlage zu `views/hike.jade` hinzu, um die Benutzeroberfläche für das Hinzufügen von Wanderprotokollen bereitzustellen.
```
extends layout
block content
h1= title
p Welcome to #{title}
form(action="/add_hike", method="post")
table(border="1")
tr
td Your Name
td
input(name="hike[NAME]", type="textbox")
tr
td Location
td
input(name="hike[LOCATION]", type="textbox")
tr
td Distance
td
input(name="hike[DISTANCE]", type="textbox")
tr
td Weather
td
input(name="hike[WEATHER]", type="radio", value="Good")
| Good
input(name="hike[WEATHER]", type="radio", value="Bad")
| Bad
input(name="hike[WEATHER]", type="radio", value="Seattle", checked)
| Seattle
tr
td(colspan="2")
input(type="submit", value="Record Hike")
div
h3 Hikes
table(border="1")
tr
td Date
td Name
td Location
td Distance
td Weather
each hike in hikes
tr
td #{hike.HIKE_DATE.toDateString()}
td #{hike.NAME}
td #{hike.LOCATION}
td #{hike.DISTANCE}
td #{hike.WEATHER}
```
1. Stellen Sie die Änderungen mit dem [**eb deploy**](eb3-deploy.md)-Befehl bereit.
```
~/nodejs-example-express-rds$ eb deploy
```
## Bereinigen
Falls Sie nicht länger mit Elastic Beanstalk arbeiten möchten, können Sie Ihre Umgebung beenden.
Mit dem **eb terminate**-Befehl können Sie Umgebung und alle darin enthaltenen Ressourcen beenden.
```
~/nodejs-example-express-rds$ eb terminate
The environment "nodejs-example-express-rds-env" and all associated instances will be terminated.
To confirm, type the environment name: nodejs-example-express-rds-env
INFO: terminateEnvironment is starting.
...
```
# Bereitstellung einer Node.js Express-Anwendung mit Clustering auf Elastic Beanstalk
Dieses Tutorial führt Sie durch die Bereitstellung einer Beispielanwendung in Elastic Beanstalk mithilfe der Elastic Beanstalk Command Line Interface (EB CLI) und die anschließende Aktualisierung der Anwendung für die Verwendung des [Express-Frameworks](http://expressjs.com/), [Amazon ElastiCache](https://aws.amazon.com/elasticache/) und Clustering. Mit Clustering lassen sich hohe Verfügbarkeit, Leistung und Sicherheit Ihrer Webanwendung verbessern. Weitere Informationen zu Amazon ElastiCache finden Sie unter [Was ist Amazon ElastiCache (Memcached](https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/Introduction.html))? im *Amazon ElastiCache (Memcached) -Benutzerhandbuch*.
**Anmerkung**
In diesem Beispiel werden AWS Ressourcen erstellt, für die Ihnen möglicherweise Gebühren berechnet werden. Weitere Informationen zur AWS Preisgestaltung finden Sie unter[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/). Einige Dienste sind Teil des AWS kostenlosen Nutzungskontingents. Als Neukunde können Sie diese Services kostenlos testen. Weitere Informationen finden Sie unter [https://aws.amazon.com/free/](https://aws.amazon.com/free/).
## Voraussetzungen
Für dieses Tutorial sind die folgenden Voraussetzungen erforderlich:
+ Die Node.js-Laufzeiten
+ Die Standard-Paketmanager-Software von Node.js, npm
+ Der Express-Befehlszeilengenerator
+ Die Elastic Beanstalk Command Line Interface (EB CLI)
Weitere Informationen zur Installation dieser ersten drei Komponenten und zur Einrichtung Ihrer lokalen Entwicklungsumgebung finden Sie unter [Einrichtung Ihrer Node.js Entwicklungsumgebung für Elastic Beanstalk](nodejs-devenv.md). Für dieses Tutorial müssen Sie das AWS SDK für Node.js nicht installieren, das auch im referenzierten Thema erwähnt wird.
Detaillierte Anweisungen zum Installieren und Konfigurieren der EB-CLI finden Sie unter [EB CLI mit Setup-Skript installieren (empfohlen)](eb-cli3.md#eb-cli3-install) und [Konfigurieren der EB CLI](eb-cli3-configuration.md).
## Erstellen einer Elastic Beanstalk-Umgebung
**Ihr Anwendungsverzeichnis**
In diesem Tutorial wird ein Verzeichnis verwendet, das als `nodejs-example-express-elasticache` für das Anwendungsquellpaket bezeichnet wird. Erstellen Sie das `nodejs-example-express-elasticache`-Verzeichnis für dieses Tutorial.
```
~$ mkdir nodejs-example-express-elasticache
```
**Anmerkung**
Jedes Tutorial in diesem Kapitel verwendet ein eigenes Verzeichnis für das Anwendungsquellpaket. Der Verzeichnisname entspricht dem Namen der Beispielanwendung, die im Tutorial verwendet wird.
Ändern Sie Ihr aktuelles Arbeitsverzeichnis zu `nodejs-example-express-elasticache`.
```
~$ cd nodejs-example-express-elasticache
```
Jetzt können wir eine Elastic-Beanstalk-Umgebung mit der Node.js und der Beispielanwendung einrichten. Wir werden die Elastic-Beanstalk-Befehlszeilenschnittstelle (EB-CLI) verwenden.
**So konfigurieren Sie ein EB-CLI-Repository für Ihre Anwendung und erstellen eine Elastic-Beanstalk-Umgebung mit der Node.js-Plattform**
1. Erstellen Sie ein Repository mit dem Befehl **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-express-elasticache$ eb init --platform node.js --region
```
Mit diesem Befehl wird eine Konfigurationsdatei in einem Ordner mit dem Namen `.elasticbeanstalk` generiert. Sie gibt die Einstellungen für die Erstellung von Umgebungen für Ihre Anwendung an und erstellt eine Elastic Beanstalk-Anwendung mit dem Namen des aktuellen Ordners.
1. Erstellen Sie mit dem Befehl **[**eb create**](eb3-create.md)** eine Umgebung mit einer laufenden Beispielanwendung.
```
~/nodejs-example-express-elasticache$ eb create --sample nodejs-example-express-elasticache
```
Mit diesem Befehl wird eine Umgebung mit Lastausgleich, den Standardeinstellungen für die Node.js-Plattform und den folgenden Ressourcen erstellt:
+ **EC2 Instanz** — Eine virtuelle Maschine von Amazon Elastic Compute Cloud (Amazon EC2), die für die Ausführung von Web-Apps auf der von Ihnen ausgewählten Plattform konfiguriert ist.
Jede Plattform führt eine spezifische Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Frameworks, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder NGINX als Reverseproxy, der vor der Web-App platziert ist, Anforderungen weiterleitet, statische Komponenten bedient und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Datenverkehr auf Port 80 zulässt. Diese Ressource ermöglicht es dem HTTP-Verkehr vom Load Balancer, die EC2 Instance zu erreichen, auf der Ihre Web-App ausgeführt wird. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.
+ **Load balancer (Load Balancer)**– Ein Elastic Load Balancing Load Balancer ist für die Verteilung von Anforderungen an die Instances, auf denen Ihre Anwendung ausgeführt wird, konfiguriert. Mit einem Load Balancer müssen Ihre Instances nicht mehr direkt für das Internet zugänglich gemacht werden.
+ **Load Balancer-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Verkehr auf Port 80 zulässt. Diese Ressource ermöglicht, dass HTTP-Datenverkehr aus dem Internet den Load Balancer erreicht. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.
+ **Auto Scaling group (Auto Scaling-Gruppe)** – Eine Auto Scaling-Gruppe, die so konfiguriert ist, dass sie eine Instance ersetzt, wenn diese beendet wird oder nicht verfügbar ist.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch CloudWatch Amazon-Alarme** — Zwei Alarme, die die Auslastung der Instances in Ihrer Umgebung überwachen und ausgelöst werden, wenn die Last zu hoch oder zu niedrig ist. Wenn ein Alarm ausgelöst wird, wird Ihre Auto Scaling-Gruppe nach oben oder nach unten skaliert.
+ **CloudFormation stack** — Elastic Beanstalk verwendet CloudFormation , um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu propagieren. Die Ressourcen werden in einer Vorlage definiert, die Sie in der [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation) anzeigen können.
+ **Domainname** *— Ein Domainname, der in der Form an Ihre Web-App weitergeleitet wird. *subdomain* *region*.elasticbeanstalk.com*.
**Domain-Sicherheit**
[Um die Sicherheit Ihrer Elastic-Beanstalk-Anwendungen zu erhöhen, ist die Domain *elasticbeanstalk.com* in der Public Suffix List (PSL) registriert.](https://publicsuffix.org/)
Wenn Sie jemals sensible Cookies im Standard-Domainnamen für Ihre Elastic Beanstalk Beanstalk-Anwendungen einrichten müssen, empfehlen wir Ihnen, Cookies mit einem `__Host-` Präfix zu verwenden, um die Sicherheit zu erhöhen. Diese Vorgehensweise schützt Ihre Domain vor Cross-Site-Request-Forgery-Versuchen (CSRF). Weitere Informationen finden Sie auf der [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes)-Seite im Mozilla Developer Network.
1. Wenn die Umgebungserstellung abgeschlossen ist, verwenden Sie den Befehl [**eb open**](eb3-open.md), um die URL der Umgebung im Standardbrowser zu öffnen.
```
~/nodejs-example-express-elasticache$ eb open
```
Sie haben jetzt eine Node.js Elastic-Beanstalk-Umgebung mit einer Beispielanwendung erstellt. Sie können sie mit Ihrer eigenen Anwendung aktualisieren. Als nächstes aktualisieren wir die Beispielanwendung, um das Express-Framework zu verwenden.
## Aktualisieren der Anwendung zur Nutzung von Express
Aktualisieren Sie die Beispielanwendung in der Elastic Beanstalk-Umgebung zur Verwendung des Express-Frameworks.
[Sie können den endgültigen Quellcode von .zip herunterladen. nodejs-example-express-elasticache](samples/nodejs-example-express-elasticache.zip)
**So aktualisieren Sie die Anwendung zur Nutzung von Express**
Nachdem Sie eine Umgebung mit einer Beispielanwendung erstellt haben, können Sie diese mit Ihrer eigenen Anwendung aktualisieren. In diesem Verfahren führen wir zunächst die **express**- und **npm install**-Befehle aus, um das Express-Framework in Ihrem Anwendungsverzeichnis einzurichten.
1. Führen Sie den Befehl `express` aus. Dadurch werden `package.json`, `app.js` und weitere Verzeichnisse generiert.
```
~/nodejs-example-express-elasticache$ express
```
Wenn Sie gefragt werden, ob Sie fortfahren möchten, geben Sie **y** ein.
**Anmerkung**
Wenn der **express**-Befehl nicht funktioniert, haben Sie den Express-Befehlszeilengenerator möglicherweise nicht installiert, wie im vorherigen Abschnitt mit den *Voraussetzungen* beschrieben. Oder die Verzeichnispfadeinstellung für Ihren lokalen Computer muss möglicherweise eingerichtet werden, um den **express**-Befehl auszuführen. Im Abschnitt *Voraussetzungen* finden Sie detaillierte Schritte zum Einrichten Ihrer Entwicklungsumgebung, sodass Sie mit diesem Tutorial fortfahren können.
1. Richten Sie lokale Abhängigkeiten ein.
```
~/nodejs-example-express-elasticache$ npm install
```
1. (Optional) Stellen Sie sicher, dass der Web-Anwendungs-Server startet.
```
~/nodejs-example-express-elasticache$ npm start
```
Die Ausgabe sollte folgendermaßen oder ähnlich aussehen:
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
Der Server läuft standardmäßig über Port 3000. Führen Sie als Test `curl http://localhost:3000` in einem anderen Terminal aus oder öffnen Sie einen Browser auf dem lokalen Computer und geben Sie die URL `http://localhost:3000` ein.
Drücken Sie **Strg\$1C**, um den Server zu stoppen.
1. Benennen Sie `nodejs-example-express-elasticache/app.js` um in `nodejs-example-express-elasticache/express-app.js`.
```
~/nodejs-example-express-elasticache$ mv app.js express-app.js
```
1. Aktualisieren Sie die Zeile `var app = express();` in `nodejs-example-express-elasticache/express-app.js` folgendermaßen:
```
var app = module.exports = express();
```
1. Erstellen Sie auf dem lokalen Computer eine Datei namens `nodejs-example-express-elasticache/app.js` mit dem folgenden Code.
```
/**
* Module dependencies.
*/
const express = require('express'),
session = require('express-session'),
bodyParser = require('body-parser'),
methodOverride = require('method-override'),
cookieParser = require('cookie-parser'),
fs = require('fs'),
filename = '/var/nodelist',
app = express();
let MemcachedStore = require('connect-memcached')(session);
function setup(cacheNodes) {
app.use(bodyParser.raw());
app.use(methodOverride());
if (cacheNodes.length > 0) {
app.use(cookieParser());
console.log('Using memcached store nodes:');
console.log(cacheNodes);
app.use(session({
secret: 'your secret here',
resave: false,
saveUninitialized: false,
store: new MemcachedStore({ 'hosts': cacheNodes })
}));
} else {
console.log('Not using memcached store.');
app.use(session({
resave: false,
saveUninitialized: false, secret: 'your secret here'
}));
}
app.get('/', function (req, resp) {
if (req.session.views) {
req.session.views++
resp.setHeader('Content-Type', 'text/html')
resp.send(`You are session: ${req.session.id}. Views: ${req.session.views}`)
} else {
req.session.views = 1
resp.send(`You are session: ${req.session.id}. No views yet, refresh the page!`)
}
});
if (!module.parent) {
console.log('Running express without cluster. Listening on port %d', process.env.PORT || 5000)
app.listen(process.env.PORT || 5000)
}
}
console.log("Reading elastic cache configuration")
// Load elasticache configuration.
fs.readFile(filename, 'UTF8', function (err, data) {
if (err) throw err;
let cacheNodes = []
if (data) {
let lines = data.split('\n');
for (let i = 0; i < lines.length; i++) {
if (lines[i].length > 0) {
cacheNodes.push(lines[i])
}
}
}
setup(cacheNodes)
});
module.exports = app;
```
1. Ersetzen Sie den Inhalt der Datei `nodejs-example-express-elasticache/bin/www` durch Folgendes:
```
#!/usr/bin/env node
/**
* Module dependencies.
*/
const app = require('../app');
const cluster = require('cluster');
const debug = require('debug')('nodejs-example-express-elasticache:server');
const http = require('http');
const workers = {},
count = require('os').cpus().length;
function spawn() {
const worker = cluster.fork();
workers[worker.pid] = worker;
return worker;
}
/**
* Get port from environment and store in Express.
*/
const port = normalizePort(process.env.PORT || '3000');
app.set('port', port);
if (cluster.isMaster) {
for (let i = 0; i < count; i++) {
spawn();
}
// If a worker dies, log it to the console and start another worker.
cluster.on('exit', function (worker, code, signal) {
console.log('Worker ' + worker.process.pid + ' died.');
cluster.fork();
});
// Log when a worker starts listening
cluster.on('listening', function (worker, address) {
console.log('Worker started with PID ' + worker.process.pid + '.');
});
} else {
/**
* Create HTTP server.
*/
let server = http.createServer(app);
/**
* Event listener for HTTP server "error" event.
*/
function onError(error) {
if (error.syscall !== 'listen') {
throw error;
}
const bind = typeof port === 'string'
? 'Pipe ' + port
: 'Port ' + port;
// handle specific listen errors with friendly messages
switch (error.code) {
case 'EACCES':
console.error(bind + ' requires elevated privileges');
process.exit(1);
break;
case 'EADDRINUSE':
console.error(bind + ' is already in use');
process.exit(1);
break;
default:
throw error;
}
}
/**
* Event listener for HTTP server "listening" event.
*/
function onListening() {
const addr = server.address();
const bind = typeof addr === 'string'
? 'pipe ' + addr
: 'port ' + addr.port;
debug('Listening on ' + bind);
}
/**
* Listen on provided port, on all network interfaces.
*/
server.listen(port);
server.on('error', onError);
server.on('listening', onListening);
}
/**
* Normalize a port into a number, string, or false.
*/
function normalizePort(val) {
const port = parseInt(val, 10);
if (isNaN(port)) {
// named pipe
return val;
}
if (port >= 0) {
// port number
return port;
}
return false;
}
```
1. Stellen Sie die Änderungen in Ihrer Elastic-Beanstalk-Umgebung mit dem Befehl [**eb deploy**](eb3-deploy.md) bereit.
```
~/nodejs-example-express-elasticache$ eb deploy
```
1. Die Umgebung wird nach einigen Minuten aktualisiert. Sobald die Umgebung grün und einsatzbereit ist, aktualisieren Sie die URL, um die ordnungsgemäße Funktionsweise zu prüfen. Sie sollten eine Webseite mit dem Text „Welcome to Express“ (Willkommen bei Express) sehen.
Sie können auf die Protokolle Ihrer EC2 Instances zugreifen, auf denen Ihre Anwendung ausgeführt wird. Anleitung zum Zugreifen auf Ihre Protokolle finden Sie unter [Protokolle von Amazon EC2-Instances in Ihrer Elastic Beanstalk Umgebung anzeigen](using-features.logging.md).
Als Nächstes aktualisieren wir die Express-Anwendung für die Verwendung von Amazon ElastiCache.
**Um Ihre Express-Anwendung für die Nutzung von Amazon zu aktualisieren ElastiCache**
1. Erstellen Sie auf dem lokalen Computer ein `.ebextensions`-Verzeichnis im Verzeichnis der obersten Ebene Ihres Quell-Bundles. In diesem Beispiel verwenden wir `nodejs-example-express-elasticache/.ebextensions`.
1. Erstellen Sie eine Konfigurationsdatei `nodejs-example-express-elasticache/.ebextensions/elasticache-iam-with-script.config` mit dem folgenden Snippet. Weitere Informationen zur Konfigurationsdatei finden Sie unter [Node.js-Konfigurations-Namespace](create_deploy_nodejs.container.md#nodejs-namespaces). Damit wird ein IAM-Benutzer mit den benötigten Berechtigungen zum Erkennen der Elasticache-Knoten erstellt. Zudem wird jede Veränderung im Cache in einer Datei erfasst. Sie können die Datei auch aus einer [nodejs-example-express-elasticacheZIP-Datei](samples/nodejs-example-express-elasticache.zip) kopieren. Weitere Informationen zu den ElastiCache Eigenschaften finden Sie unter[Beispiel: ElastiCache](customize-environment-resources-elasticache.md).
**Anmerkung**
Für YAML sind konsistente Einrückungen erforderlich. Wählen Sie die entsprechende Einrückungsebene aus, wenn Sie Inhalte in einer Beispielkonfigurationsdatei ersetzen, und stellen Sie sicher, dass Ihr Texteditor Leerzeichen statt Tabulatorzeichen zum Einrücken verwendet.
```
Resources:
MyCacheSecurityGroup:
Type: 'AWS::EC2::SecurityGroup'
Properties:
GroupDescription: "Lock cache down to webserver access only"
SecurityGroupIngress:
- IpProtocol: tcp
FromPort:
Fn::GetOptionSetting:
OptionName: CachePort
DefaultValue: 11211
ToPort:
Fn::GetOptionSetting:
OptionName: CachePort
DefaultValue: 11211
SourceSecurityGroupName:
Ref: AWSEBSecurityGroup
MyElastiCache:
Type: 'AWS::ElastiCache::CacheCluster'
Properties:
CacheNodeType:
Fn::GetOptionSetting:
OptionName: CacheNodeType
DefaultValue: cache.t2.micro
NumCacheNodes:
Fn::GetOptionSetting:
OptionName: NumCacheNodes
DefaultValue: 1
Engine:
Fn::GetOptionSetting:
OptionName: Engine
DefaultValue: redis
VpcSecurityGroupIds:
-
Fn::GetAtt:
- MyCacheSecurityGroup
- GroupId
AWSEBAutoScalingGroup :
Metadata :
ElastiCacheConfig :
CacheName :
Ref : MyElastiCache
CacheSize :
Fn::GetOptionSetting:
OptionName : NumCacheNodes
DefaultValue: 1
WebServerUser :
Type : AWS::IAM::User
Properties :
Path : "/"
Policies:
-
PolicyName: root
PolicyDocument :
Statement :
-
Effect : Allow
Action :
- cloudformation:DescribeStackResource
- cloudformation:ListStackResources
- elasticache:DescribeCacheClusters
Resource : "*"
WebServerKeys :
Type : AWS::IAM::AccessKey
Properties :
UserName :
Ref: WebServerUser
Outputs:
WebsiteURL:
Description: sample output only here to show inline string function parsing
Value: |
http://`{ "Fn::GetAtt" : [ "AWSEBLoadBalancer", "DNSName" ] }`
MyElastiCacheName:
Description: Name of the elasticache
Value:
Ref : MyElastiCache
NumCacheNodes:
Description: Number of cache nodes in MyElastiCache
Value:
Fn::GetOptionSetting:
OptionName : NumCacheNodes
DefaultValue: 1
files:
"/etc/cfn/cfn-credentials" :
content : |
AWSAccessKeyId=`{ "Ref" : "WebServerKeys" }`
AWSSecretKey=`{ "Fn::GetAtt" : ["WebServerKeys", "SecretAccessKey"] }`
mode : "000400"
owner : root
group : root
"/etc/cfn/get-cache-nodes" :
content : |
# Define environment variables for command line tools
export AWS_ELASTICACHE_HOME="/home/ec2-user/elasticache/$(ls /home/ec2-user/elasticache/)"
export AWS_CLOUDFORMATION_HOME=/opt/aws/apitools/cfn
export PATH=$AWS_CLOUDFORMATION_HOME/bin:$AWS_ELASTICACHE_HOME/bin:$PATH
export AWS_CREDENTIAL_FILE=/etc/cfn/cfn-credentials
export JAVA_HOME=/usr/lib/jvm/jre
# Grab the Cache node names and configure the PHP page
aws cloudformation list-stack-resources --stack `{ "Ref" : "AWS::StackName" }` --region `{ "Ref" : "AWS::Region" }` --output text | grep MyElastiCache | awk '{print $4}' | xargs -I {} aws elasticache describe-cache-clusters --cache-cluster-id {} --region `{ "Ref" : "AWS::Region" }` --show-cache-node-info --output text | grep '^ENDPOINT' | awk '{print $2 ":" $3}' > `{ "Fn::GetOptionSetting" : { "OptionName" : "NodeListPath", "DefaultValue" : "/var/www/html/nodelist" } }`
mode : "000500"
owner : root
group : root
"/etc/cfn/hooks.d/cfn-cache-change.conf" :
"content": |
[cfn-cache-size-change]
triggers=post.update
path=Resources.AWSEBAutoScalingGroup.Metadata.ElastiCacheConfig
action=/etc/cfn/get-cache-nodes
runas=root
sources :
"/home/ec2-user/elasticache" : "https://elasticache-downloads.s3.amazonaws.com/AmazonElastiCacheCli-latest.zip"
commands:
make-elasticache-executable:
command: chmod -R ugo+x /home/ec2-user/elasticache/*/bin/*
packages :
"yum" :
"aws-apitools-cfn" : []
container_commands:
initial_cache_nodes:
command: /etc/cfn/get-cache-nodes
```
1. Erstellen Sie auf Ihrem lokalen Computer eine Konfigurationsdatei `nodejs-example-express-elasticache/.ebextensions/elasticache_settings.config` mit dem folgenden Codeausschnitt zur Konfiguration. ElastiCache
```
option_settings:
"aws:elasticbeanstalk:customoption":
CacheNodeType: cache.t2.micro
NumCacheNodes: 1
Engine: memcached
NodeListPath: /var/nodelist
```
1. Ersetzen Sie auf Ihrem lokalen Computer `nodejs-example-express-elasticache/express-app.js` durch den folgenden Snippet. Diese Datei liest die Knoten-Liste vom Datenträger (`/var/nodelist`) und konfiguriert Express so, dass `memcached` als Sitzungsspeicher verwendet wird, wenn Knoten vorhanden sind. Ihre Datei sollte wie folgt aussehen.
```
/**
* Module dependencies.
*/
var express = require('express'),
session = require('express-session'),
bodyParser = require('body-parser'),
methodOverride = require('method-override'),
cookieParser = require('cookie-parser'),
fs = require('fs'),
filename = '/var/nodelist',
app = module.exports = express();
var MemcachedStore = require('connect-memcached')(session);
function setup(cacheNodes) {
app.use(bodyParser.raw());
app.use(methodOverride());
if (cacheNodes) {
app.use(cookieParser());
console.log('Using memcached store nodes:');
console.log(cacheNodes);
app.use(session({
secret: 'your secret here',
resave: false,
saveUninitialized: false,
store: new MemcachedStore({'hosts': cacheNodes})
}));
} else {
console.log('Not using memcached store.');
app.use(cookieParser('your secret here'));
app.use(session());
}
app.get('/', function(req, resp){
if (req.session.views) {
req.session.views++
resp.setHeader('Content-Type', 'text/html')
resp.write('Views: ' + req.session.views)
resp.end()
} else {
req.session.views = 1
resp.end('Refresh the page!')
}
});
if (!module.parent) {
console.log('Running express without cluster.');
app.listen(process.env.PORT || 5000);
}
}
// Load elasticache configuration.
fs.readFile(filename, 'UTF8', function(err, data) {
if (err) throw err;
var cacheNodes = [];
if (data) {
var lines = data.split('\n');
for (var i = 0 ; i < lines.length ; i++) {
if (lines[i].length > 0) {
cacheNodes.push(lines[i]);
}
}
}
setup(cacheNodes);
});
```
1. Aktualisieren Sie `package.json` auf dem lokalen Computer mit den folgenden Inhalten:
```
"dependencies": {
"cookie-parser": "~1.4.4",
"debug": "~2.6.9",
"express": "~4.16.1",
"http-errors": "~1.6.3",
"jade": "~1.11.0",
"morgan": "~1.9.1",
"connect-memcached": "*",
"express-session": "*",
"body-parser": "*",
"method-override": "*"
}
```
1. Führen Sie **npm install**.
```
~/nodejs-example-express-elasticache$ npm install
```
1. Stellen Sie die aktualisierte Anwendung bereit.
```
~/nodejs-example-express-elasticache$ eb deploy
```
1. Die Umgebung wird nach einigen Minuten aktualisiert. Wenn die Umgebung grün und einsatzbereit ist, überprüfen Sie, ob der Code funktioniert hat.
1. Sehen Sie in der [ CloudWatch Amazon-Konsole](https://console.aws.amazon.com/cloudwatch/home) nach, um Ihre ElastiCache Messwerte einzusehen. Um Ihre ElastiCache Metriken anzuzeigen, wählen Sie im linken Bereich **Metriken** aus und suchen Sie dann nach **CurrItems**. Wählen Sie **ElastiCache > Cache-Knoten-Metriken** und wählen Sie dann Ihren Cache-Knoten aus, um die Anzahl der Elemente im Cache anzuzeigen.
![\[CloudWatch dashboard showing CurrItems metric for an ElastiCache node over time.\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/elasticache-express.png)
**Anmerkung**
Achten Sie darauf, dass Sie in der Region suchen, in der Sie die Anwendung bereitgestellt haben.
Wenn Sie Ihre Anwendungs-URL kopieren und in einen anderen Webbrowser einfügen und die Seite aktualisieren, sollte Ihre CurrItem Anzahl nach 5 Minuten steigen.
1. Erstellen Sie einen Snapshot Ihrer Protokolle. Weitere Informationen über das Abrufen von Protokollen finden Sie unter [Protokolle von Amazon EC2-Instances in Ihrer Elastic Beanstalk Umgebung anzeigen](using-features.logging.md).
1. Überprüfen Sie die Datei `/var/log/nodejs/nodejs.log` im Protokoll-Bundle. Die Ausgabe sollte wie folgt aussehen:
```
Using memcached store nodes:
[ 'aws-my-1oys9co8zt1uo.1iwtrn.0001.use1.cache.amazonaws.com:11211' ]
```
## Bereinigen
Wenn Sie Ihre Anwendung nicht mehr ausführen möchten, können Sie Ihr System durch Beenden Ihrer Umgebung und Löschen Ihrer Anwendung bereinigen.
Beenden Sie die Umgebung mit dem Befehl `eb terminate`, und löschen Sie die Anwendung mit dem Befehl `eb delete`.
**So beenden Sie Ihre Umgebung**
Führen Sie in dem Verzeichnis, in dem Sie Ihr lokales Repository erstellt haben, `eb terminate` aus.
```
$ eb terminate
```
Dieser Vorgang kann einige Minuten dauern. Elastic Beanstalk zeigt eine Meldung an, sobald die Umgebung erfolgreich beendet wurde.
# Bereitstellen einer Node.js-Anwendung mit DynamoDB in Elastic Beanstalk
Dieses Tutorial und die dazugehörige Beispielanwendung ([nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip)) führen Sie durch den Prozess der Bereitstellung einer Node.js -Anwendung, die das AWS SDK für JavaScript in Node.js verwendet, um mit dem Amazon DynamoDB-Service zu interagieren. Sie erstellen eine DynamoDB-Tabelle, die sich in einer Datenbank befindet, die von der Umgebung entkoppelt oder extern ist. AWS Elastic Beanstalk Sie werden die Anwendung auch so konfigurieren, dass sie eine entkoppelte Datenbank verwendet. In einer Produktionsumgebung empfiehlt es sich, eine Datenbank zu verwenden, die von der Elastic-Beanstalk-Umgebung entkoppelt ist, sodass sie unabhängig vom Lebenszyklus der Umgebung ist. Diese Vorgehensweise ermöglicht es Ihnen auch, [Blau/Grün-Bereitstellungen](using-features.CNAMESwap.md) durchzuführen.
Die Beispielanwendung veranschaulicht das Folgende:
+ Eine DynamoDB-Tabelle zum Speichern der vom Benutzer bereitgestellten Textdaten.
+ Die [Konfigurationsdateien](ebextensions.md) zum Erstellen der Tabelle.
+ Ein Amazon-Simple-Notification-Service-Thema.
+ Während der Bereitstellung Pakete mit der [package.json-Datei](nodejs-platform-dependencies.md#nodejs-platform-packagejson) installieren.
**Topics**
+ [Voraussetzungen](#nodejs-dynamodb-tutorial-prereqs)
+ [Erstellen einer Elastic Beanstalk-Umgebung](#nodejs-dynamodb-tutorial-launch)
+ [Hinzufügen von Berechtigungen zu den Instances Ihrer Umgebung](#nodejs-dynamodb-tutorial-role)
+ [Bereitstellen der Beispielanwendung](#nodejs-dynamodb-tutorial-deploy)
+ [Erstellen einer DynamoDB-Tabelle](#nodejs-dynamodb-tutorial-database)
+ [Aktualisieren der Konfigurationsdateien der Anwendung](#nodejs-dynamodb-tutorial-update)
+ [Konfigurieren der Umgebung für hohe Verfügbarkeit](#nodejs-dynamodb-tutorial-configure)
+ [Bereinigen](#nodejs-dynamodb-tutorial-cleanup)
+ [Nächste Schritte](#nodejs-dynamodb-tutorial-nextsteps)
## Voraussetzungen
Für dieses Tutorial sind die folgenden Voraussetzungen erforderlich:
+ Die Node.js-Laufzeiten
+ Die Standard-Paketmanager-Software von Node.js, npm
+ Der Express-Befehlszeilengenerator
+ Die Elastic Beanstalk Command Line Interface (EB CLI)
Weitere Informationen zur Installation dieser ersten drei Komponenten und zur Einrichtung Ihrer lokalen Entwicklungsumgebung finden Sie unter [Einrichtung Ihrer Node.js Entwicklungsumgebung für Elastic Beanstalk](nodejs-devenv.md). Für dieses Tutorial müssen Sie das AWS SDK für Node.js nicht installieren, das auch im referenzierten Thema erwähnt wird.
Detaillierte Anweisungen zum Installieren und Konfigurieren der EB-CLI finden Sie unter [EB CLI mit Setup-Skript installieren (empfohlen)](eb-cli3.md#eb-cli3-install) und [Konfigurieren der EB CLI](eb-cli3-configuration.md).
## Erstellen einer Elastic Beanstalk-Umgebung
**Ihr Anwendungsverzeichnis**
In diesem Tutorial wird ein Verzeichnis verwendet, das als `nodejs-example-dynamo` für das Anwendungsquellpaket bezeichnet wird. Erstellen Sie das `nodejs-example-dynamo`-Verzeichnis für dieses Tutorial.
```
~$ mkdir nodejs-example-dynamo
```
**Anmerkung**
Jedes Tutorial in diesem Kapitel verwendet ein eigenes Verzeichnis für das Anwendungsquellpaket. Der Verzeichnisname entspricht dem Namen der Beispielanwendung, die im Tutorial verwendet wird.
Ändern Sie Ihr aktuelles Arbeitsverzeichnis zu `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
Jetzt können wir eine Elastic-Beanstalk-Umgebung mit der Node.js und der Beispielanwendung einrichten. Wir werden die Elastic-Beanstalk-Befehlszeilenschnittstelle (EB-CLI) verwenden.
**So konfigurieren Sie ein EB-CLI-Repository für Ihre Anwendung und erstellen eine Elastic-Beanstalk-Umgebung mit der Node.js-Plattform**
1. Erstellen Sie ein Repository mit dem Befehl **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-dynamo$ eb init --platform node.js --region
```
Mit diesem Befehl wird eine Konfigurationsdatei in einem Ordner mit dem Namen `.elasticbeanstalk` generiert. Sie gibt die Einstellungen für die Erstellung von Umgebungen für Ihre Anwendung an und erstellt eine Elastic Beanstalk-Anwendung mit dem Namen des aktuellen Ordners.
1. Erstellen Sie mit dem Befehl **[**eb create**](eb3-create.md)** eine Umgebung mit einer laufenden Beispielanwendung.
```
~/nodejs-example-dynamo$ eb create --sample nodejs-example-dynamo
```
Mit diesem Befehl wird eine Umgebung mit Lastausgleich, den Standardeinstellungen für die Node.js-Plattform und den folgenden Ressourcen erstellt:
+ **EC2 Instanz** — Eine virtuelle Maschine von Amazon Elastic Compute Cloud (Amazon EC2), die für die Ausführung von Web-Apps auf der von Ihnen ausgewählten Plattform konfiguriert ist.
Jede Plattform führt eine spezifische Gruppe von Software, Konfigurationsdateien und Skripts zur Unterstützung einer bestimmten Sprachversion, eines Frameworks, Webcontainers oder einer Kombination daraus aus. Die meisten Plattformen verwenden entweder Apache oder NGINX als Reverseproxy, der vor der Web-App platziert ist, Anforderungen weiterleitet, statische Komponenten bedient und Zugriffs- und Fehlerprotokolle generiert.
+ **Instance-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Datenverkehr auf Port 80 zulässt. Diese Ressource ermöglicht es dem HTTP-Verkehr vom Load Balancer, die EC2 Instance zu erreichen, auf der Ihre Web-App ausgeführt wird. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.
+ **Load balancer (Load Balancer)**– Ein Elastic Load Balancing Load Balancer ist für die Verteilung von Anforderungen an die Instances, auf denen Ihre Anwendung ausgeführt wird, konfiguriert. Mit einem Load Balancer müssen Ihre Instances nicht mehr direkt für das Internet zugänglich gemacht werden.
+ **Load Balancer-Sicherheitsgruppe** — Eine EC2 Amazon-Sicherheitsgruppe, die so konfiguriert ist, dass sie eingehenden Verkehr auf Port 80 zulässt. Diese Ressource ermöglicht, dass HTTP-Datenverkehr aus dem Internet den Load Balancer erreicht. Standardmäßig ist Datenverkehr auf anderen Ports nicht zulässig.
+ **Auto Scaling group (Auto Scaling-Gruppe)** – Eine Auto Scaling-Gruppe, die so konfiguriert ist, dass sie eine Instance ersetzt, wenn diese beendet wird oder nicht verfügbar ist.
+ **Amazon S3-Bucket** – Ein Speicherort für Ihren Quellcode, Protokolle und andere Artefakte, die bei der Verwendung von Elastic Beanstalk erstellt werden.
+ ** CloudWatch CloudWatch Amazon-Alarme** — Zwei Alarme, die die Auslastung der Instances in Ihrer Umgebung überwachen und ausgelöst werden, wenn die Last zu hoch oder zu niedrig ist. Wenn ein Alarm ausgelöst wird, wird Ihre Auto Scaling-Gruppe nach oben oder nach unten skaliert.
+ **CloudFormation stack** — Elastic Beanstalk verwendet CloudFormation , um die Ressourcen in Ihrer Umgebung zu starten und Konfigurationsänderungen zu propagieren. Die Ressourcen werden in einer Vorlage definiert, die Sie in der [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation) anzeigen können.
+ **Domainname** *— Ein Domainname, der in der Form an Ihre Web-App weitergeleitet wird. *subdomain* *region*.elasticbeanstalk.com*.
**Domain-Sicherheit**
[Um die Sicherheit Ihrer Elastic-Beanstalk-Anwendungen zu erhöhen, ist die Domain *elasticbeanstalk.com* in der Public Suffix List (PSL) registriert.](https://publicsuffix.org/)
Wenn Sie jemals sensible Cookies im Standard-Domainnamen für Ihre Elastic Beanstalk Beanstalk-Anwendungen einrichten müssen, empfehlen wir Ihnen, Cookies mit einem `__Host-` Präfix zu verwenden, um die Sicherheit zu erhöhen. Diese Vorgehensweise schützt Ihre Domain vor Cross-Site-Request-Forgery-Versuchen (CSRF). Weitere Informationen finden Sie auf der [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes)-Seite im Mozilla Developer Network.
1. Wenn die Umgebungserstellung abgeschlossen ist, verwenden Sie den Befehl [**eb open**](eb3-open.md), um die URL der Umgebung im Standardbrowser zu öffnen.
```
~/nodejs-example-dynamo$ eb open
```
Sie haben jetzt eine Node.js Elastic-Beanstalk-Umgebung mit einer Beispielanwendung erstellt. Sie können sie mit Ihrer eigenen Anwendung aktualisieren. Als nächstes aktualisieren wir die Beispielanwendung, um das Express-Framework zu verwenden.
## Hinzufügen von Berechtigungen zu den Instances Ihrer Umgebung
Ihre Anwendung läuft auf einer oder mehreren EC2 Instances hinter einem Load Balancer und bedient HTTP-Anfragen aus dem Internet. Wenn sie eine Anfrage erhält, die die Nutzung von AWS Diensten erfordert, verwendet die Anwendung die Berechtigungen der Instance, auf der sie ausgeführt wird, um auf diese Dienste zuzugreifen.
Die Beispielanwendung verwendet Instanzberechtigungen, um Daten in eine DynamoDB-Tabelle zu schreiben und Benachrichtigungen an ein Amazon SNS SNS-Thema mit dem SDK für JavaScript in Node.js zu senden. Fügen Sie dem [Standard-Instance-Profil](concepts-roles-instance.md) die folgenden verwalteten Richtlinien hinzu, um den EC2 Instances in Ihrer Umgebung Zugriff auf DynamoDB und Amazon SNS zu gewähren:
+ **AmazonDynamoDBFullAccess**
+ **SNSFullZugriff auf Amazon**
**So fügen Sie Richtlinien zum Instance-Standardprofil hinzu**
1. Öffnen Sie die Seite [Roles (Rollen)](https://console.aws.amazon.com/iam/home#roles) in der IAM-Konsole.
1. Wählen Sie **aws-elasticbeanstalk-ec2 Rollen**.
1. Wählen Sie auf der Registerkarte **Permissions (Berechtigungen)** die Option **Attach policies (Richtlinien anfügen)** aus.
1. Wählen Sie die verwaltete Richtlinie für die zusätzlichen Services aus, die von der Anwendung verwendet werden. Wählen Sie in diesem Tutorial `AmazonSNSFullAccess` und `AmazonDynamoDBFullAccess`.
1. Wählen Sie **Richtlinie anfügen** aus.
Weitere Informationen zum Verwalten von Instance-Profilen finden Sie unter [Elastic Beanstalk Instance-Profile verwalten](iam-instanceprofile.md).
## Bereitstellen der Beispielanwendung
Jetzt ist Ihre Umgebung bereit, damit Sie die Beispielanwendung für dieses Tutorial bereitstellen und ausführen können: [nodejs-example-dynamo.zip.](samples/nodejs-example-dynamo.zip)
**So stellen Sie die Tutorial-Beispielanwendung bereit und führen sie aus**
1. Wechseln Sie von Ihrem aktuellen Arbeitsverzeichnis in das Installationsverzeichnis `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
1. Laden Sie den Inhalt des Quellpakets für die Beispielanwendung ([nodejs-example-dynamo.zip) herunter und extrahieren Sie ihn](samples/nodejs-example-dynamo.zip) in das Anwendungsverzeichnis. `nodejs-example-dynamo`
1. Stellen Sie die Anwendung in Ihrer Elastic-Beanstalk-Umgebung mit dem Befehl [**eb deploy**](eb3-deploy.md) bereit.
```
~/nodejs-example-dynamo$ eb deploy
```
**Anmerkung**
Standardmäßig erstellt der `eb deploy` Befehl eine ZIP-Datei Ihres Projektordners. Sie können die EB-CLI so konfigurieren, dass sie ein Artefakt aus Ihrem Erstellungsprozess bereitstellt, anstatt eine ZIP-Datei Ihres Projektordners zu erstellen. Weitere Informationen finden Sie unter [Bereitstellen eines Artefakts anstelle des Projektordners](eb-cli3-configuration.md#eb-cli3-artifact).
1. Wenn die Umgebungserstellung abgeschlossen ist, verwenden Sie den Befehl [**eb open**](eb3-open.md), um die URL der Umgebung im Standardbrowser zu öffnen.
```
~/nodejs-example-dynamo$ eb open
```
Die Website sammelt Benutzerkontaktinformationen und speichert die Daten in einer DynamoDB-Tabelle. Zum Hinzufügen eines Eintrags wählen Sie **Sign up today (Jetzt registrieren)**, geben Sie einen Namen und eine E-Mail-Adresse ein, und wählen Sie dann **Sign Up\$1 (Registrieren)** aus. Die Web-App schreibt die Formularinhalte in die Tabelle und löst eine E-Mail-Benachrichtigung von Amazon SNS aus.
![\[Startup landing page with teaser message and sign-up button for upcoming product launch.\]](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/images/nodejs-dynamodb-tutorial-app.png)
Aktuell ist das Amazon SNS-Thema mit einer Platzhalter-E-Mail für Benachrichtigungen konfiguriert. Sie werden die Konfiguration in Kürze aktualisieren, aber in der Zwischenzeit können Sie die DynamoDB-Tabelle und das Amazon SNS-Thema in der AWS-Managementkonsoleüberprüfen.
**So zeigen Sie die Tabelle an**
1. Öffnen Sie die Seite [Tables (Tabellen)](https://console.aws.amazon.com/dynamodb/home?#tables:) in der DynamoDB-Konsole.
1. Suchen Sie die Tabelle, die die Anwendung erstellt hat. Der Name beginnt mit **awseb und enthält**. **StartupSignupsTable**
1. Wählen Sie die Tabelle aus, klicken Sie auf **Items (Elemente)** und anschließend auf **Start search (Suche starten)**, um alle Elemente in der Tabelle anzuzeigen.
Die Tabelle enthält einen Eintrag für jede E-Mail-Adresse, die auf der Anmeldungs-Website übermittelt wurde. Zusätzlich zum Schreiben in die Tabelle sendet die Anwendung eine Nachricht an ein Amazon SNS-Thema, das zwei Abonnements hat: eines für E-Mail-Benachrichtigungen an Sie und ein anderes für eine Amazon Simple Queue Service-Warteschlange, aus der eine Worker-Anwendung lesen kann, um Anfragen zu verarbeiten und E-Mails an interessierte Kunden zu senden.
**So zeigen Sie das Thema an**
1. Öffnen Sie die Seite [Topics (Themen)](https://console.aws.amazon.com/sns/v2/home?#/topics) in der Amazon SNS-Konsole.
1. Suchen Sie das Thema, das die Anwendung erstellt hat. Der Name beginnt mit **awseb** und enthält. **NewSignupTopic**
1. Wählen Sie das Thema, um seine Abonnements anzuzeigen.
Die Anwendung (`[app.js](https://github.com/awslabs/eb-node-express-sample/blob/master/app.js)`) definiert zwei Routen. Der Root-Pfad (`/`) gibt eine Webseite zurück, die anhand einer Embedded-Vorlage JavaScript (EJS) mit einem Formular gerendert wurde, das der Benutzer ausfüllt, um seinen Namen und seine E-Mail-Adresse zu registrieren. Durch das Übermitteln des Formulars wird eine POST-Anforderung mit den Formulardaten an das `/signup`-Routing gesendet. Es schreibt einen Eintrag in die DynamoDB-Tabelle und veröffentlicht eine Nachricht im Amazon SNS-Thema, um den Eigentümer des Themas zu benachrichtigen.
Die Beispielanwendung enthält [Konfigurationsdateien](ebextensions.md), mit der die DynamoDB-Tabelle, das Amazon SNS-Thema und die Amazon SQS-Warteschlange der Anwendung erstellt werden. Dadurch können Sie eine neue Umgebung erstellen und die Funktionalität sofort testen. Der Nachteil ist, dass die DynamoDB-Tabelle an die Umgebung gebunden ist. Bei einer Produktionsumgebung sollten Sie die DynamoDB-Tabelle außerhalb Ihrer Umgebung erstellen. Auf diese Weise vermeiden Sie, dass Sie sie verlieren, wenn Sie die Umgebung beenden oder ihre Konfiguration aktualisieren.
## Erstellen einer DynamoDB-Tabelle
Um eine externe DynamoDB-Tabelle mit einer Anwendung zu verwenden, die in Elastic Beanstalk ausgeführt wird, erstellen Sie zuerst eine Tabelle in DynamoDB. Wenn Sie eine Tabelle außerhalb von Elastic Beanstalk erstellen, ist sie völlig unabhängig von Elastic Beanstalk und Ihren Elastic Beanstalk-Umgebungen und wird von Elastic Beanstalk nicht beendet.
Erstellen Sie die Tabelle mit folgenden Einstellungen:
+ **Table name (Name der Tabelle)** – **nodejs-tutorial**
+ **Primary key (Primärschlüssel)** – **email**
+ Primary key type (Primärschlüsseltyp) – **Zeichenfolge**
**So erstellen Sie eine DynamoDB-Tabelle**
1. Öffnen Sie die Seite [Tables (Tabellen)](https://console.aws.amazon.com/dynamodb/home?#tables:)in der DynamoDB Management-Konsole.
1. Wählen Sie **Create table (Tabelle erstellen)** aus.
1. Geben Sie einen **Table name (Name der Tabelle)** und einen **Primary key (Primärschlüssel)** ein.
1. Wählen Sie den Typ des Primärschlüssels aus.
1. Wählen Sie **Erstellen** aus.
## Aktualisieren der Konfigurationsdateien der Anwendung
Aktualisieren Sie die [Konfigurationsdateien](ebextensions.md) in der Anwendungsquelle zur Verwendung der **nodejs-tutorial**-Tabelle, anstatt eine neue Tabelle zu erstellen.
**So aktualisieren Sie die Beispielanwendung für die Verwendung in der Produktion**
1. Wechseln Sie von Ihrem aktuellen Arbeitsverzeichnis in das Installationsverzeichnis `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
1. Öffnen Sie `.ebextensions/options.config` und ändern Sie die Werte der folgenden Einstellungen:
+ **NewSignupEmail**— Ihre E-Mail-Adresse.
+ **STARTUP\$1SIGNUP\$1TABLE** – **nodejs-tutorial**
**Example .ebextensions/options.config**
```
option_settings:
aws:elasticbeanstalk:customoption:
NewSignupEmail: you@example.com
aws:elasticbeanstalk:application:environment:
THEME: "flatly"
AWS_REGION: '`{"Ref" : "AWS::Region"}`'
STARTUP_SIGNUP_TABLE: nodejs-tutorial
NEW_SIGNUP_TOPIC: '`{"Ref" : "NewSignupTopic"}`'
aws:elasticbeanstalk:container:nodejs:
ProxyServer: nginx
aws:elasticbeanstalk:container:nodejs:staticfiles:
/static: /static
aws:autoscaling:asg:
Cooldown: "120"
aws:autoscaling:trigger:
Unit: "Percent"
Period: "1"
BreachDuration: "2"
UpperThreshold: "75"
LowerThreshold: "30"
MeasureName: "CPUUtilization"
```
Dies gilt für die folgenden Konfigurationen für die Anwendung:
+ Die E-Mail-Adresse, die das Amazon-SNS-Thema für Benachrichtigungen verwendet, ist auf Ihre Adresse gesetzt oder auf die, die Sie in die `options.config`-Datei eingegeben.
+ Die Tabelle **nodejs-tutorial** wird anstelle der Tabelle verwendet, die von `.ebextensions/create-dynamodb-table.config` erstellt wurde.
1. Entfernen Sie `.ebextensions/create-dynamodb-table.config`.
```
~/nodejs-tutorial$ rm .ebextensions/create-dynamodb-table.config
```
Wenn Sie die Anwendung das nächste Mal bereitstellen, wird die Tabelle, die von dieser Konfigurationsdatei erstellt wurde, gelöscht.
1. Stellen Sie die aktualisierte Anwendung in Ihrer Elastic-Beanstalk-Umgebung mit dem Befehl [**eb deploy**](eb3-deploy.md) bereit.
```
~/nodejs-example-dynamo$ eb deploy
```
1. Wenn die Umgebungserstellung abgeschlossen ist, verwenden Sie den Befehl [**eb open**](eb3-open.md), um die URL der Umgebung im Standardbrowser zu öffnen.
```
~/nodejs-example-dynamo$ eb open
```
Bei der Bereitstellung aktualisiert Elastic Beanstalk die Konfiguration des Amazon SNS-Themas und löscht die DynamoDB-Tabelle, die erstellt wurde, als Sie die erste Version der Anwendung bereitgestellt haben.
Wenn Sie die Umgebung jetzt beenden, wird die **nodejs-tutorial**-Tabelle nicht gelöscht. Dadurch können Sie blaue/grüne Bereitstellungen durchführen, Konfigurationsdateien ändern oder Ihre Website offline nehmen, ohne Datenverlust zu riskieren.
Öffnen Sie Ihre Webseite in einem Browser und überprüfen Sie, ob das Formular wie erwartet funktioniert. Erstellen Sie einige Einträge und überprüfen Sie die Tabelle in der DynamoDB-Konsole.
**So zeigen Sie die Tabelle an**
1. Öffnen Sie die Seite [Tables (Tabellen)](https://console.aws.amazon.com/dynamodb/home?#tables:) in der DynamoDB-Konsole.
1. Suchen Sie die **nodejs-tutorial**-Tabelle.
1. Wählen Sie die Tabelle aus, klicken Sie auf **Items (Elemente)** und anschließend auf **Start search (Suche starten)**, um alle Elemente in der Tabelle anzuzeigen.
Sie können auch sehen, dass Elastic Beanstalk die zuvor erstellte Tabelle gelöscht hat.
## Konfigurieren der Umgebung für hohe Verfügbarkeit
Konfigurieren Sie abschließend für die Auto-Scaling-Gruppe der Umgebung für höhere Instance-Mindestanzahl. Führen Sie immer mindestens zwei Instances aus, damit einzelne Webserver in der Umgebung keine Fehlerquelle darstellen und damit Sie Änderungen ohne Ausfallzeit der Website bereitstellen können.
**So konfigurieren Sie die Auto-Scaling-Gruppe in der Umgebung für hohe Verfügbarkeit**
1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region
1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.
1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.
1. Wählen Sie in der Konfigurationskategorie **Capacity (Kapazität)** die Option **Edit (Bearbeiten)**.
1. Legen Sie im Abschnitt **Auto Scaling Group (Gruppe der automatischen Skalierung)** für die Option **Min instances (Min. Instances)** **2** fest.
1. Wählen Sie unten auf der Seite die Option **Apply** (Anwenden) aus, um die Änderungen zu speichern.
## Bereinigen
Nachdem Sie die Arbeit mit dem Demo-Code abgeschlossen haben, können Sie Ihre Umgebung beenden. [Elastic Beanstalk löscht alle zugehörigen AWS Ressourcen wie [ EC2 Amazon-Instances, [Datenbank-Instances](using-features.managing.db.md)](using-features.managing.ec2.md), [Load Balancer](using-features.managing.elb.md), Sicherheitsgruppen und Alarme.](using-features.alarms.md#using-features.alarms.title)
Durch das Entfernen von Ressourcen wird die Elastic Beanstalk Beanstalk-Anwendung nicht gelöscht, sodass Sie jederzeit neue Umgebungen für Ihre Anwendung erstellen können.
**So beenden Sie Ihre Elastic Beanstalk Beanstalk-Umgebung über die Konsole**
1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region
1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.
1. Klicken Sie auf **Actions** (Aktionen) und dann auf **Terminate Environment** (Umgebung beenden).
1. Verwenden Sie das Dialogfeld auf dem Bildschirm, um die Beendigung der Umgebung zu bestätigen.
Sie können auch die durch Sie erstellten, externen DynamoDB-Tabellen löschen.
**So löschen Sie eine DynamoDB-Tabelle**
1. Öffnen Sie die Seite [Tables (Tabellen)](https://console.aws.amazon.com/dynamodb/home?#tables:) in der DynamoDB-Konsole.
1. Wählen Sie eine Tabelle aus.
1. Wählen Sie die Option **Actions (Aktionen)** und anschließend **Delete table (Tabelle löschen)** aus.
1. Wählen Sie **Delete (Löschen)** aus.
## Nächste Schritte
Die Beispielanwendung verwendet Konfigurationsdateien, um Softwareeinstellungen zu konfigurieren und AWS Ressourcen als Teil Ihrer Umgebung zu erstellen. Weitere Informationen über Konfigurationsdateien und Ihre Verwendung finden Sie unter [Erweiterte Umgebungsanpassung mit Konfigurationsdateien (`.ebextensions`)](ebextensions.md).
Die Beispielanwendung dieses Tutorials verwendet das Express-Web-Framework für Node.js. Weitere Informationen zu Express finden Sie in der offiziellen Dokumentation unter [expressjs.com](https://expressjs.com).
Sofern Sie planen, die Anwendung in einer Produktionsumgebung einzusetzen, [konfigurieren Sie einen benutzerdefinierten Domainnamen](customdomains.md) für die Umgebung und [aktivieren Sie HTTPS](configuring-https.md) für sichere Verbindungen.
# Hinzufügen einer Amazon RDS-DB-Instance zu Ihrer Node.js Elastic Beanstalk Beanstalk-Umgebung
Dieses Thema enthält Anweisungen zum Erstellen eines Amazon RDS mit der Elastic-Beanstalk-Konsole. Sie können eine DB-Instance von Amazon Relational Database Service (Amazon RDS) verwenden, um Daten zu speichern, die von Ihrer Anwendung gesammelt und geändert wurden. Die Datenbank kann an Ihre Umgebung gekoppelt sein und von Elastic Beanstalk verwaltet werden oder sie kann als entkoppelte Datenbank erstellt und extern von einem anderen Service verwaltet werden. In dieser Anleitung wird die Datenbank an Ihre Umgebung gekoppelt und von Elastic Beanstalk verwaltet. Weitere Informationen zur Integration eines Amazon RDS mit Elastic Beanstalk finden Sie unter [Hinzufügen einer Datenbank zu Ihrer Elastic Beanstalk-Umgebung](using-features.managing.db.md).
**Topics**
+ [Hinzufügen einer DB-Instance zu Ihrer Umgebung](#nodejs-rds-create)
+ [Herunterladen eines Treibers](#nodejs-rds-drivers)
+ [Herstellen einer Verbindung zu einer Datenbank](#nodejs-rds-connect)
## Hinzufügen einer DB-Instance zu Ihrer Umgebung
**So fügen Sie eine DB-Instance zu Ihrer Umgebung hinzu**
1. Öffnen Sie die [Elastic Beanstalk Beanstalk-Konsole](https://console.aws.amazon.com/elasticbeanstalk) und wählen Sie in der Liste **Regionen** Ihre aus. AWS-Region
1. Wählen Sie im Navigationsbereich **Environments (Umgebungen)** aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.
1. Wählen Sie im Navigationsbereich **Configuration (Konfiguration)** aus.
1. Wählen Sie in der Konfigurationskategorie **Database (Datenbank)** die Option **Edit (Bearbeiten)**.
1. Wählen Sie eine DB-Engine aus und geben Sie Benutzernamen und Passwort ein.
1. Wählen Sie unten auf der Seite die Option **Apply** (Anwenden) aus, um die Änderungen zu speichern.
Das Hinzufügen einer DB-Instance dauert ca. 10 Minuten. Sobald die Umgebungsaktualisierung abgeschlossen ist, stehen der Hostname der DB-Instance und andere Verbindungsinformationen über die folgenden Umgebungseigenschaften zur Verfügung:
| Eigenschaftenname | Beschreibung | Eigenschaftenwert |
| --- | --- | --- |
| `RDS_HOSTNAME` | Der Hostname der DB-Instance. | Auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** in der Amazon RDS-Konsole: **Endpoint (Endpunkt)**. |
| `RDS_PORT` | Der Port, über den die DB-Instance Verbindungen annimmt. Die DB-Engines haben unterschiedliche Standardwerte. | Auf der Registerkarte **Connectivity & security (Konnektivität und Sicherheit)** auf der Amazon RDS-Konsole: **Port**. |
| `RDS_DB_NAME` | Der Datenbanknam, **ebdb**. | Auf der Registerkarte **Configuration (Konfiguration)** der Amazon RDS-Konsole: **DB-Name**. |
| `RDS_USERNAME` | Der Benutzername, der für die Datenbank konfiguriert wurde. | Auf der Registerkarte **Configuration (Konfiguration)** in der Amazon RDS-Konsole: **Master username (Master-Benutzername)**. |
| `RDS_PASSWORD` | Das Passwort, das für die Datenbank konfiguriert wurde. | Es ist in der Amazon RDS-Konsole nicht als Referenz angegeben. |
Weitere Informationen zur Konfiguration einer Datenbank-Instance in Verbindung mit einer Elastic-Beanstalk-Umgebung finden Sie unter [Hinzufügen einer Datenbank zu Ihrer Elastic Beanstalk-Umgebung](using-features.managing.db.md).
## Herunterladen eines Treibers
Fügen Sie den Datenbanktreiber zur [`package.json`-Datei](nodejs-platform-dependencies.md#nodejs-platform-packagejson) unter `dependencies` hinzu.
**Example `package.json` – Express mit MySQL**
```
{
"name": "my-app",
"version": "0.0.1",
"private": true,
"dependencies": {
"ejs": "latest",
"aws-sdk": "latest",
"express": "latest",
"body-parser": "latest",
"mysql": "latest"
},
"scripts": {
"start": "node app.js"
}
}
```
**Gängige Treiberpakete für Node.js**
+ **MySQL** – [mysql](https://www.npmjs.com/package/mysql)
+ **PostgreSQL** – [node-postgress](https://www.npmjs.com/package/pg)
+ **SQL Server** – [node-mssql](https://www.npmjs.com/package/mssql)
+ **Oracle** – [node-oracledb](https://www.npmjs.com/package/oracledb)
## Herstellen einer Verbindung zu einer Datenbank
Elastic Beanstalk stellt Verbindungsinformationen für zugehörige DB-Instances in Umgebungseigenschaften bereit. Mit `process.env.VARIABLE` können Sie die Eigenschaften lesen und eine Datenbankverbindung konfigurieren.
**Example app.js – MySQL-Datenbankverbindung**
```
var mysql = require('mysql');
var connection = mysql.createConnection({
host : process.env.RDS_HOSTNAME,
user : process.env.RDS_USERNAME,
password : process.env.RDS_PASSWORD,
port : process.env.RDS_PORT
});
connection.connect(function(err) {
if (err) {
console.error('Database connection failed: ' + err.stack);
return;
}
console.log('Connected to database.');
});
connection.end();
```
[Weitere Informationen zum Konstruieren einer Verbindungszeichenfolge mithilfe von node-mysql finden Sie unter npmjs. org/package/mysql](https://npmjs.org/package/mysql).
# Tools und Ressourcen für Node.js
Es gibt zahlreiche Möglichkeiten, um zusätzliche Unterstützung bei der Entwicklung von Node.js-Anwendungen zu erhalten:
****
| Ressource | Description |
| --- | --- |
| [GitHub](https://github.com/aws/aws-sdk-js) | Installieren Sie das AWS SDK für Node.js mit GitHub. |
| [AWS SDK für Node.js (Entwicklervorschau)](https://aws.amazon.com/sdkfornodejs/) | Umfangreiches Kit mit Beispiel-Code, Dokumentation, Tools und zusätzlichen Ressourcen. |