As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Implantar uma aplicação Node.js Express no Elastic Beanstalk
<a name="create_deploy_nodejs_express"></a>

Esta seção na implantação de uma aplicação de amostra no Elastic Beanstalk usando a Interface de Linha de Comando do Elastic Beanstalk (EB CLI) e, em seguida, atualizando a aplicação para usar a framework [Express](http://expressjs.com/). 

## Pré-requisitos
<a name="create_deploy_nodejs_express.prerequisites"></a>

Este tutorial requer os seguintes pré-requisitos:
+ Os tempos de execução do Node.js
+ O software gerenciador de pacotes Node.js padrão, npm
+ O gerador de linha de comando Express
+ A Elastic Beanstalk Command Line Interface (EB CLI)

Para obter detalhes sobre como instalar os três primeiros componentes listados e configurar seu ambiente de desenvolvimento local, consulte [Configurar seu ambiente de desenvolvimento Node.js para o Elastic Beanstalk](nodejs-devenv.md). Para este tutorial, você não precisa instalar o AWS SDK para Node.js, que também é mencionado no tópico referenciado.

Para obter detalhes sobre como instalar e configurar a EB CLI, consulte [Instalar a EB CLI com script de configuração (recomendado)](eb-cli3.md#eb-cli3-install) e [Configurar a EB CLI](eb-cli3-configuration.md).

## Criar um ambiente do Elastic Beanstalk
<a name="create_deploy_nodejs_express.eb_init-rds"></a>

**Seu diretório de aplicativos**  
Este tutorial usa um diretório chamado `nodejs-example-express-rds` para o pacote de origem do aplicativo. Crie o diretório `nodejs-example-express-rds` para este tutorial.

```
~$ mkdir nodejs-example-express-rds
```

**nota**  
Cada tutorial neste capítulo usa seu próprio diretório para o pacote de origem do aplicativo. O nome do diretório corresponde ao nome do aplicativo de amostra usado pelo tutorial.

Altere seu diretório de trabalho atual para `nodejs-example-express-rds`.

```
~$ cd nodejs-example-express-rds
```

Agora, vamos configurar um ambiente do Elastic Beanstalk executando a plataforma Node.js e o aplicativo de amostra. Usaremos a interface de linha de comando do Elastic Beanstalk (EB CLI).

**Para configurar um repositório EB CLI para seu aplicativo e criar um ambiente Elastic Beanstalk executando a plataforma Node.js**

1. Crie um repositório com o comando **[**eb init**](eb3-init.md)**.

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

   Esse comando cria um arquivo de configuração em uma pasta chamada `.elasticbeanstalk` que especifica as configurações para a criação de ambientes para a aplicação e cria uma aplicação do Elastic Beanstalk com nome baseado na pasta atual.

1. Crie um ambiente executando um aplicativo de exemplo com o comando **[**eb create**](eb3-create.md)**.

   ```
   ~/nodejs-example-express-rds$ eb create --sample nodejs-example-express-rds
   ```

   Esse comando cria um ambiente com balanceamento de carga com as configurações padrão da plataforma do Node.js e os seguintes recursos:
   + **EC2 instância** — Uma máquina virtual Amazon Elastic Compute Cloud (Amazon EC2) configurada para executar aplicativos web na plataforma que você escolher.

     Cada plataforma executa um conjunto específico de software, arquivos de configuração e scripts para oferecer suporte a uma versão de linguagem, framework, contêiner da web específicos ou a uma combinação deles. A maioria das plataformas usa o Apache ou o NGINX como um proxy reverso que fica na frente da aplicação Web, encaminha solicitações para ela, atende ativos estáticos e gera logs de acesso e de erro.
   + **Grupo de segurança da instância** — Um grupo EC2 de segurança da Amazon configurado para permitir tráfego de entrada na porta 80. Esse recurso permite que o tráfego HTTP do balanceador de carga chegue à EC2 instância que executa seu aplicativo web. Por padrão, o tráfego não é permitido em outras portas.
   + **Balanceador de carga**: um balanceador de carga do Elastic Load Balancing configurado para distribuir solicitações para as instâncias que executam a aplicação. Um load balancer também elimina a necessidade de expor suas instâncias diretamente à Internet.
   + **Grupo de segurança do balanceador de carga** — Um grupo EC2 de segurança da Amazon configurado para permitir tráfego de entrada na porta 80. Esse recurso permite que o tráfego HTTP da Internet acesse o load balancer. Por padrão, o tráfego não é permitido em outras portas.
   + **Grupo de Auto Scaling**: grupo de Auto Scaling configurado para substituir uma instância se ela for encerrada ou ficar indisponível.
   + **Bucket do Amazon S3**: um local de armazenamento do seu código-fonte, logs e outros artefatos criados quando o Elastic Beanstalk é utilizado.
   + ** CloudWatch Alarmes da Amazon** — Dois CloudWatch alarmes que monitoram a carga nas instâncias em seu ambiente e que são acionados se a carga for muito alta ou muito baixa. Quando um alarme é acionado, o seu grupo de Auto Scaling pode aumentar ou diminuir.
   + **CloudFormation stack** — O Elastic CloudFormation Beanstalk usa para lançar os recursos em seu ambiente e propagar as alterações de configuração. Os recursos são definidos em um modelo que você pode visualizar no [console do CloudFormation](https://console.aws.amazon.com/cloudformation).
   + **Nome de domínio** — Um nome de domínio que é direcionado para seu aplicativo da web no formulário **subdomain*. *region*.elasticbeanstalk.com*.
**Segurança de domínios**  
Para aumentar a segurança de suas aplicações do Elastic Beanstalk, o domínio *elasticbeanstalk.com* é registrado na [Lista Pública de Sufixos (PSL)](https://publicsuffix.org/).  
Se precisar definir cookies confidenciais no nome de domínio padrão para suas aplicações Elastic Beanstalk, recomendamos usar cookies com um prefixo `__Host-` para maior segurança. Essa prática defende seu domínio contra tentativas de falsificação de solicitação entre sites (CSRF). Para obter mais informações, consulte a página [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) na Mozilla Developer Network.

1. Quando a criação do ambiente for concluída, use o comando [**eb open**](eb3-open.md) para abrir o URL do ambiente no navegador padrão.

   ```
   ~/nodejs-example-express-rds$ eb open
   ```

Agora você criou um ambiente Node.js Elastic Beanstalk com um aplicativo de amostra. Você pode atualizá-lo com seu próprio aplicativo. Em seguida, atualizamos o aplicativo de exemplo para usar a framework do Express.

## Atualize o aplicativo para usar o Express
<a name="create_deploy_nodejs_express.update"></a>

Depois de criar um ambiente com um aplicativo de amostra, você pode atualizá-lo com seu próprio aplicativo. Neste procedimento, primeiro executamos os comandos **npm install** e **express** para configurar a estrutura Express no diretório do seu aplicativo. Em seguida, usamos a EB CLI para atualizar seu ambiente Elastic Beanstalk com o aplicativo atualizado.

**Para atualizar seu aplicativo para usar o Express**

1. Execute o comando `express`. Isso gera `package.json`, `app.js` e alguns diretórios.

   ```
   ~/nodejs-example-express-rds$ express
   ```

   Quando solicitado, digite **y** se você deseja continuar.
**nota**  
Se o comando **express** não funcionar, talvez você não tenha instalado o gerador de linha de comando Express conforme descrito na seção *Pré-requisitos* anterior. Ou talvez seja necessário configurar a configuração do caminho do diretório para sua máquina local para executar o comando **express**. Consulte a seção *Pré-requisitos* para obter etapas detalhadas sobre como configurar seu ambiente de desenvolvimento, para que você possa continuar com este tutorial. 

1. Configure as dependências locais.

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

1. (Opcional) Verifique a inicialização do servidor do aplicativo da web.

   ```
   ~/nodejs-example-express-rds$ npm start
   ```

   Você deve ver uma saída semelhante a:

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

   Por padrão, o servidor é executado na porta 3000. Para testá-lo, execute `curl http://localhost:3000` em outro terminal ou abra um navegador no computador local e insira o endereço URL `http://localhost:3000`.

   Pressione **Ctrl\$1C** para interromper o servidor.

1. Implante as alterações em seu ambiente Elastic Beanstalk com o comando [**eb deploy**](eb3-deploy.md).

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

1. Assim que o ambiente estiver verde e pronto, atualize o URL para verificar se funcionou. Você deve ver uma página da web que diz **Welcome to Express**.

Em seguida, vamos atualizar o aplicativo Express para servir arquivos estáticos e adicionar uma nova página.

**Para configurar arquivos estáticos e adicionar uma nova página ao seu aplicativo Express**

1. Adicione um segundo arquivo de configuração na pasta [`.ebextensions`](ebextensions.md) com o seguinte conteúdo:

   **`nodejs-example-express-rds/.ebextensions/staticfiles.config`**

   ```
   option_settings:
       aws:elasticbeanstalk:environment:proxy:staticfiles:
           /stylesheets: public/stylesheets
   ```

   Isso configura o servidor de proxy para servir arquivos na pasta `public` no caminho `/public` do aplicativo. Servir arquivos estaticamente do servidor proxy reduz a carga em seu aplicativo. Para obter mais informações, consulte [Arquivos estáticos](create_deploy_nodejs.container.md#nodejs-platform-console-staticfiles) anterior deste capítulo.

1. (Opcional) Para confirmar se os mapeamentos estáticos estão configurados corretamente, comente a configuração do mapeamento estático em `nodejs-example-express-rds/app.js`. Isso remove o mapeamento do aplicativo de nó.

   ```
   //  app.use(express.static(path.join(__dirname, 'public'))); 
   ```

   Os mapeamentos de arquivo estático no arquivo `staticfiles.config` da etapa anterior ainda devem carregar a folha de estilo com êxito, mesmo depois de comentar essa linha. Para verificar se os mapeamentos de arquivo estático são carregados por meio da configuração de arquivo estático do proxy, em vez do aplicativo expresso, remova os valores a seguir `option_settings:`. Depois de ter sido removido da configuração do arquivo estático e do aplicativo de nó, a folha de estilo falhará ao carregar.

   Lembre-se de redefinir o conteúdo do `nodejs-example-express-rds/app.js` e `staticfiles.config` quando terminar o teste.

1. Adicionar `nodejs-example-express-rds/routes/hike.js`. Digite o seguinte:

   ```
   exports.index = function(req, res) {
    res.render('hike', {title: 'My Hiking Log'});
   };
   
   exports.add_hike = function(req, res) {
   };
   ```

1. Atualize `nodejs-example-express-rds/app.js` para incluir três novas linhas.

   Primeiro, adicione a seguinte linha para adicionar um `require` a essa rota:

   ```
   var hike = require('./routes/hike');
   ```

   O seu arquivo deve ser semelhante ao seguinte snippet:

   ```
   var express = require('express');
   var path = require('path');
   var hike = require('./routes/hike');
   ```

   Em seguida, adicione as seguintes duas linhas ao `nodejs-example-express-rds/app.js` depois de `var app = express();`

   ```
   app.get('/hikes', hike.index);
   app.post('/add_hike', hike.add_hike);
   ```

   O seu arquivo deve ser semelhante ao seguinte snippet:

   ```
   var app = express();
   app.get('/hikes', hike.index);
   app.post('/add_hike', hike.add_hike);
   ```

1. Copie `nodejs-example-express-rds/views/index.jade` para `nodejs-example-express-rds/views/hike.jade`. 

   ```
   ~/nodejs-example-express-rds$ cp views/index.jade views/hike.jade
   ```

1. Implante as alterações com o comando [**eb deploy**](eb3-deploy.md).

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

1. O ambiente será atualizado após alguns minutos. Depois que seu ambiente estiver verde e pronto, verifique se funcionou atualizando seu navegador e anexando **hikes** no final do URL (por exemplo, `http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes`).

   Você deve ver uma página da web intitulada **My Hiking Log**.

Agora, você criou um aplicativo da Web que usa a estrutura Express. Na próxima seção, modificaremos o aplicativo para usar um Amazon Relational Database Service (RDS) para armazenar um log de caminhada.

## Atualize o aplicativo para usar o Amazon RDS
<a name="create_deploy_nodejs_express.add_rds"></a>

Na próxima etapa, atualizaremos o aplicativo para usar o Amazon RDS para MySQL.

**Para atualizar seu aplicativo para usar o RDS for MySQL**

1. Para criar um banco de dados RDS para MySQL acoplado ao seu ambiente Elastic Beanstalk, siga as instruções no tópico [Adicionar um banco de dados](create-deploy-nodejs.rds.md) incluído posteriormente neste capítulo. Adicionar uma instância de banco de dados leva cerca de 10 minutos.

1.  Atualize a seção de dependências no `package.json` com o seguinte conteúdo: 

   ```
   "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. Executar **npm install**.

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

1. Atualize `app.js` para se conectar ao banco de dados, criar uma tabela e inserir um único log de caminhada padrão. Sempre que este aplicativo for implantado, ele descartará a tabela de caminhadas anterior e a recriará.

   ```
   /**
    * 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. Adicione o seguinte conteúdo ao arquivo `routes/hike.js`. Isso permitirá que as rotas insiram novos logs de caminhada no banco de dados *HIKES*.

   ```
   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. Substitua o conteúdo de `routes/index.js` pelo seguinte:

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

1. Adicione o seguinte modelo de jade ao `views/hike.jade` para fornecer a interface do usuário para adicionar logs de caminhada.

   ```
   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. Implante as alterações com o comando [**eb deploy**](eb3-deploy.md).

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

## Limpeza
<a name="create_deploy_nodejs_express.delete"></a>

Se você terminar de trabalhar com o Elastic Beanstalk, poderá encerrar seu ambiente.

Use o comando **eb terminate** para encerrar seu ambiente e todos os recursos que ele contém.

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