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