Distribuzione di un'applicazione Node.js Express con clustering su Elastic Beanstalk

Per configurare un CLI repository EB per l'applicazione e creare un ambiente Elastic Beanstalk che esegue la piattaforma Node.js

1. Creazione di un repository con il comando eb init.

   ~/nodejs-example-express-elasticache$ eb init --platform node.js --region <region>

   Questo comando crea un file di configurazione in una cartella denominata .elasticbeanstalk, che specifica le impostazioni per la creazione di ambienti per l'applicazione e crea un'applicazione Elastic Beanstalk che prende nome dalla cartella corrente.

2. Crea un ambiente che esegue un'applicazione di esempio con il comando eb create.

   ~/nodejs-example-express-elasticache$ eb create --sample nodejs-example-express-elasticache

   Questo comando crea un ambiente con bilanciamento del carico con le impostazioni predefinite per la piattaforma Node.js e le risorse seguenti:

   • EC2istanza: una macchina virtuale Amazon Elastic Compute Cloud (AmazonEC2) configurata per eseguire app Web sulla piattaforma scelta.

     Ogni piattaforma esegue un insieme specifico di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di essi. La maggior parte delle piattaforme utilizza Apache o NGINX come proxy inverso che si trova davanti all'app Web, inoltra le richieste, fornisce risorse statiche e genera log di accesso e di errore.

   • Gruppo di sicurezza dell'istanza: un gruppo EC2 di sicurezza Amazon configurato per consentire il traffico in entrata sulla porta 80. Questa risorsa consente al HTTP traffico proveniente dal sistema di bilanciamento del carico di raggiungere l'EC2istanza su cui è in esecuzione la tua app web. Per impostazione predefinita, il traffico non è consentito su altre porte.

   • Sistema di bilanciamento del carico: un sistema di bilanciamento del carico Elastic Load Balancing configurato per distribuire richieste alle istanze in esecuzione sull'applicazione. Un sistema di bilanciamento del carico inoltre elimina la necessità di esporre le proprie istanze direttamente in Internet.

   • Gruppo di sicurezza Load Balancer: un gruppo EC2 di sicurezza Amazon configurato per consentire il traffico in entrata sulla porta 80. Questa risorsa consente al HTTP traffico proveniente da Internet di raggiungere il sistema di bilanciamento del carico. Per impostazione predefinita, il traffico non è consentito su altre porte.

   • Gruppo Auto Scaling: un gruppo Auto Scaling configurato per sostituire un'istanza se viene terminata o diventa non disponibile.

   • Bucket Amazon S3: posizione di storage per il codice sorgente, i log e altri artefatti creati quando si utilizza Elastic Beanstalk.

   • CloudWatch Allarmi Amazon: due CloudWatch allarmi che monitorano il carico sulle istanze nel tuo ambiente e che vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza.

   • AWS CloudFormation stack: Elastic AWS CloudFormation Beanstalk utilizza per avviare le risorse nell'ambiente e propagare le modifiche alla configurazione. Le risorse sono definite in un modello, visualizzabile nella console AWS CloudFormation.

   • Nome di dominio: un nome di dominio che indirizza alla tua app Web nel modulo subdomain.region.elasticbeanstalk.com.

     Sicurezza del dominio

     Per aumentare la sicurezza delle tue applicazioni Elastic Beanstalk, il dominio elasticbeanstalk.com è registrato nella Public Suffix List (). PSL

     Se hai bisogno di impostare cookie sensibili nel nome di dominio predefinito per le tue applicazioni Elastic Beanstalk, ti consigliamo di utilizzare i cookie __Host- con un prefisso per una maggiore sicurezza. Questa pratica difende il tuo dominio dai tentativi di falsificazione delle richieste tra siti (). CSRF Per ulteriori informazioni, consulta la pagina Impostazione cookie nella pagina Mozilla Developer Network.

3. Al termine della creazione dell'ambiente, utilizzate il eb opencomando per aprire l'ambiente URL nel browser predefinito.

   ~/nodejs-example-express-elasticache$ eb open

Per aggiornare l'applicazione per usare Express

Una volta creato un ambiente con un'applicazione di esempio, potrai aggiornarlo con la tua applicazione. In questa procedura, eseguiamo innanzitutto i comandi express e npm install per configurare il framework Express nella directory dell'applicazione.

1. Esegui il comando express. Questo genera package.json, app.js e poche altre directory.

   ~/nodejs-example-express-elasticache$ express

   Quando ti viene chiesto se desideri proseguire, digita y.

   Nota

   Se il comando express non funziona, è possibile che non sia stato installato il generatore di riga di comando Express come descritto nella precedente sezione Prerequisiti. Oppure potrebbe essere necessario configurare l'impostazione del percorso della directory per il computer locale in modo da eseguire il comando express. Consulta la sezione Prerequisiti per i passaggi dettagliati sulla configurazione dell'ambiente di sviluppo, in modo da poter procedere con questo tutorial.

2. Configura le dipendenze locali.

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

3. (Facoltativo) Verifica dell'avvio del server dell'applicazione Web.

   ~/nodejs-example-express-elasticache$ npm start

   Verrà visualizzato un output simile al seguente:

   > nodejs@0.0.0 start /home/local/user/node-express
   > node ./bin/www

   Il server viene eseguito sulla porta 3000 per impostazione predefinita. Per testarlo, eseguilo curl http://localhost:3000 su un altro terminale o apri un browser sul computer locale e inserisci l'URLindirizzohttp://localhost:3000.

   Premi Ctrl+C per arrestare il server.

4. Rinomina nodejs-example-express-elasticache/app.js come nodejs-example-express-elasticache/express-app.js.

   ~/nodejs-example-express-elasticache$ mv app.js express-app.js

5. Aggiornare la riga var app = express(); in nodejs-example-express-elasticache/express-app.js sui seguenti elementi.

   var app = module.exports = express();

6. Sul computer locale, creare un file denominato nodejs-example-express-elasticache/app.js con il seguente codice.

   /**
    * 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;

7. Sostituisci il contenuto del file nodejs-example-express-elasticache/bin/www con quanto riportato di seguito:

   #!/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;
   }

8. Implementa le modifiche apportate all'ambiente Elastic Beanstalk con il comando eb deploy.

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

9. Il tuo ambiente sarà aggiornato dopo qualche minuto. Una volta che l'ambiente è verde e pronto, aggiornalo URL per verificare che funzioni. Visualizzerai una pagina Web con la dicitura Welcome to Express (Benvenuto in Express).

Per aggiornare la tua applicazione Express per utilizzare Amazon ElastiCache

1. Sul computer locale, creare una directory .ebextensions nella directory di primo livello del bundle di origine. In questo esempio viene utilizzato nodejs-example-express-elasticache/.ebextensions.

2. Creare un file di configurazione nodejs-example-express-elasticache/.ebextensions/elasticache-iam-with-script.config con il seguente snippet. Per ulteriori informazioni sul file di configurazione, consulta Node.js spazio dei nomi di configurazione. Questo crea un IAM utente con le autorizzazioni necessarie per scoprire i nodi elasticache e scrive su un file ogni volta che la cache cambia. Puoi anche copiare il file da.zip. nodejs-example-express-elasticache Per ulteriori informazioni sulle ElastiCache proprietà, vedereEsempio: ElastiCache.

   Nota

   YAMLsi basa su un'indentazione coerente. Utilizza lo stesso livello di rientro quando sostituisci del contenuto in un file di configurazione di esempio e assicurati che il tuo editor di testo utilizzi gli spazi e non le tabulazioni per il rientro.

   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

3. Sul tuo computer locale, crea un file di configurazione nodejs-example-express-elasticache/.ebextensions/elasticache_settings.config con il seguente frammento da configurare. ElastiCache

   option_settings:
     "aws:elasticbeanstalk:customoption":
        CacheNodeType: cache.t2.micro
        NumCacheNodes: 1
        Engine: memcached
        NodeListPath: /var/nodelist

4. Sul computer locale, sostituire nodejs-example-express-elasticache/express-app.js con lo snippet seguente. Questo file legge l'elenco dei nodi dal disco (/var/nodelist) e configura express per utilizzare memcached come uno store di sessione se sono presenti nodi. Il file avrà un aspetto simile al seguente.

   /**
    * 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);
   });

5. Sul computer locale, aggiorna package.json con i seguenti contenuti:

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

6. Esegui npm install.

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

7. Distribuisci l'applicazione aggiornata.

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

8. Il tuo ambiente sarà aggiornato dopo qualche minuto. Quando l'ambiente è verde e pronto, verificare che il codice abbia funzionato.

   1. Controlla la CloudWatch console Amazon per visualizzare le tue ElastiCache metriche. Per visualizzare le tue ElastiCache metriche, seleziona Metriche nel riquadro a sinistra, quindi cerca. CurrItems Seleziona ElastiCache > Metriche del nodo di cache, quindi seleziona il nodo di cache per visualizzare il numero di elementi nella cache.

      

      Nota

      Verifica di fare riferimento alla stessa regione in cui hai distribuito la tua applicazione.

      Se copi e incolli l'applicazione URL in un altro browser Web e aggiorni la pagina, dovresti vedere il CurrItem conteggio aumentare dopo 5 minuti.

   2. Acquisire uno snapshot dei log. Per ulteriori informazioni sul recupero di oggetti, consulta Visualizzazione dei log delle EC2 istanze Amazon nel tuo ambiente Elastic Beanstalk.

   3. Selezionare il file /var/log/nodejs/nodejs.log nel bundle dei log. Dovrebbe essere visualizzato un output simile al seguente:

      Using memcached store nodes:
      [ 'aws-my-1oys9co8zt1uo.1iwtrn.0001.use1.cache.amazonaws.com:11211' ]