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.

# Eine Node.js Express-Anwendung auf Elastic Beanstalk bereitstellen
<a name="create_deploy_nodejs_express"></a>

[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
<a name="create_deploy_nodejs_express.prerequisites"></a>

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
<a name="create_deploy_nodejs_express.eb_init-rds"></a>

**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 <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
<a name="create_deploy_nodejs_express.update"></a>

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
<a name="create_deploy_nodejs_express.add_rds"></a>

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
<a name="create_deploy_nodejs_express.delete"></a>

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.
...
```