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.

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. 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 Installieren Sie die Elastic Beanstalk Beanstalk-Befehlszeilenschnittstelle und Konfigurieren 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 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.

   ~/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.

2. 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:

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

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

     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-Seite im Mozilla Developer Network.

3. Wenn die Umgebungserstellung abgeschlossen ist, verwenden Sie den Befehl eb open, 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.

2. Richten Sie lokale Abhängigkeiten ein.

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

3. (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+C, um den Server zu stoppen.

4. Stellen Sie die Änderungen in Ihrer Elastic-Beanstalk-Umgebung mit dem Befehl eb deploy bereit.

   ~/nodejs-example-express-rds$ eb deploy

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

2. (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.

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

4. 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);

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

6. Stellen Sie die Änderungen mit dem eb deploy-Befehl bereit.

   ~/nodejs-example-express-rds$ eb deploy

7. 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 weiter unten in diesem Kapitel. Das Hinzufügen einer Datenbank-Instance dauert ca. 10 Minuten.

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

3. Führen Sie npm install.

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

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

5. 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');
         }
      });
   };

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

   /*
    * GET home page.
    */
   
   exports.index = function(req, res){
     res.render('index', { title: 'Express' });
   };

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

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