Voraussetzungen Erstellen einer Elastic Beanstalk-Umgebung Aktualisieren der Anwendung zur Nutzung von Express Aktualisieren Sie die Anwendung, um Amazon zu verwenden RDS Bereinigen

Bereitstellen einer Express-Anwendung für Elastic Beanstalk

In diesem Abschnitt erfahren Sie, wie Sie mithilfe der Elastic Beanstalk-Befehlszeilenschnittstelle (EBCLI) eine Beispielanwendung in Elastic Beanstalk bereitstellen und anschließend die Anwendung für die Verwendung des Express-Frameworks aktualisieren.

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 Beanstalk-Befehlszeilenschnittstelle (EB) CLI

Weitere Informationen zur Installation dieser ersten drei Komponenten und zur Einrichtung Ihrer lokalen Entwicklungsumgebung finden Sie unter Einrichten Ihrer Node.js-Entwicklungsumgebung. Für dieses Tutorial müssen Sie die Datei AWS SDK for Node.js nicht installieren, die auch im referenzierten Thema erwähnt wird.

Einzelheiten zur Installation und Konfiguration des EB CLI finden Sie unter Installieren der EB CLI undKonfigurieren der EB CLI.

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 verwenden die Elastic Beanstalk Beanstalk-Befehlszeilenschnittstelle (EBCLI).

Um ein CLI EB-Repository für Ihre Anwendung zu konfigurieren und eine Elastic Beanstalk Beanstalk-Umgebung zu erstellen, auf der die Plattform Node.js ausgeführt wird

Erstellen Sie ein Repository mit dem Befehl eb init.
```
~/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.
Erstellen Sie mit dem Befehl eb create 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:
- EC2Instanz — Eine virtuelle Maschine von Amazon Elastic Compute Cloud (AmazonEC2), 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 Reverse-Proxy, der sich vor Ihrer Web-App befindet, Anfragen an diese weiterleitet, statische Ressourcen bereitstellt 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 Datenverkehr 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 es dem HTTP Datenverkehr aus dem Internet, den Load Balancer zu erreichen. 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.
- AWS CloudFormation stack — Elastic Beanstalk verwendet AWS 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 AWS CloudFormation -Konsole anzeigen können.
- Domainname — Ein Domainname, der in der folgenden Form an Ihre Web-App weitergeleitet wird subdomain.region.elasticbeanstalk.com.
  
  Anmerkung
  Um die Sicherheit Ihrer Elastic Beanstalk Beanstalk-Anwendungen zu erhöhen, ist die Domain elasticbeanstalk.com in der Public Suffix List () registriert. PSL Aus Sicherheitsgründen empfehlen wir Ihnen, Cookies mit einem __Host--Präfix zu verwenden, falls Sie jemals sensible Cookies im Standard-Domainnamen für Ihre Elastic-Beanstalk-Anwendungen einrichten müssen. Diese Vorgehensweise hilft Ihnen dabei, Ihre Domain vor Cross-Site-Request-Forgery-Versuchen zu schützen (). CSRF Weitere Informationen finden Sie auf der Set-Cookie-Seite im Mozilla Developer Network.
Wenn die Erstellung der Umgebung abgeschlossen ist, verwenden Sie den eb openBefehl, um die Umgebung URL 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. Anschließend verwenden wir die EBCLI, um Ihre Elastic Beanstalk Beanstalk-Umgebung mit der aktualisierten Anwendung zu aktualisieren.

So aktualisieren Sie die Anwendung zur Nutzung von Express

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.

Richten Sie lokale Abhängigkeiten ein.


~/nodejs-example-express-rds$ npm install

(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. Um es zu testen, führen Sie es curl http://localhost:3000 in einem anderen Terminal aus oder öffnen Sie einen Browser auf dem lokalen Computer und geben Sie URL die Adresse ein. http://localhost:3000

Drücken Sie Strg+C, um den Server zu stoppen.
Stellen Sie die Änderungen in Ihrer Elastic-Beanstalk-Umgebung mit dem Befehl eb deploy bereit.
```
~/nodejs-example-express-rds$ eb deploy
```
Sobald die Umgebung grün und bereit ist, aktualisieren Sie die, URL um zu überprüfen, ob sie funktioniert hat. 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

Fügen Sie eine zweite Konfigurationsdatei in den .ebextensions-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 weiter oben in diesem Kapitel.
(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.

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) {
};

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);
```
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
```
Stellen Sie die Änderungen mit dem eb deploy-Befehl bereit.
```
~/nodejs-example-express-rds$ eb deploy
```
Die Umgebung wird nach einigen Minuten aktualisiert. Wenn Ihre Umgebung grün und bereit ist, überprüfen Sie, ob sie funktioniert hat, indem Sie Ihren Browser aktualisieren und hikes am Ende den URL (z. B.http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes) anhängen.

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 Sie die Anwendung, um Amazon zu verwenden RDS

In diesem nächsten Schritt aktualisieren wir die Anwendung, um Amazon RDS for My zu verwendenSQL.

Um Ihre Anwendung zur Verwendung RDS für My zu aktualisieren SQL

Um eine mit Ihrer Elastic Beanstalk Beanstalk-Umgebung gekoppelte SQL Datenbank RDS für Meine Datenbank zu erstellen, folgen Sie den Anweisungen im Thema Datenbank hinzufügen weiter unten in diesem Kapitel. Das Hinzufügen einer Datenbank-Instance dauert ca. 10 Minuten.

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"
  }

Führen Sie npm install.


~/nodejs-example-express-rds$ npm install

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

Fügen Sie routes/hike.js den folgenden Inhalt hinzu. Dadurch können die Routen neue Wanderprotokolle in die HIKESDatenbank 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');
      }
   });
};

Ersetzen Sie den Inhalt von routes/index.js durch Folgendes:


/*
 * GET home page.
 */

exports.index = function(req, res){
  res.render('index', { title: 'Express' });
};

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}

Stellen Sie die Änderungen mit dem eb deploy-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.
...

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Beispielanwendungen und Tutorials

Tutorial – Express mit Clustering