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

# Implantação de aplicações Node.js com o Elastic Beanstalk
<a name="create_deploy_nodejs"></a>

Este capítulo fornece instruções para configurar e implantar seu aplicativo web Node.js no. AWS Elastic Beanstalk Ele também fornece orientações para tarefas comuns, como integração de banco de dados e trabalho com a framework Express. O Elastic Beanstalk facilita a implantação, o gerenciamento e o dimensionamento de suas aplicações da Web Node.js usando o Amazon Web Services.

Você pode implantar sua aplicação em apenas alguns minutos usando a Interface de Linha de Comando (EB CLI) do Elastic Beanstalk ou o console do Elastic Beanstalk. Depois de implantar seu aplicativo Elastic Beanstalk, você pode continuar usando o EB CLI para gerenciar seu aplicativo e ambiente, ou você pode usar o console do Elastic Beanstalk, ou o. AWS CLI APIs

Siga as step-by-step instruções [QuickStart para Node.js](nodejs-quickstart.md) para criar e implantar um aplicativo web *Hello World* Node.js com a CLI do EB.

**Topics**
+ [QuickStart: implante um aplicativo Node.js no Elastic Beanstalk](nodejs-quickstart.md)
+ [Configurar seu ambiente de desenvolvimento Node.js para o Elastic Beanstalk](nodejs-devenv.md)
+ [Usar a plataforma Node.js do Elastic Beanstalk](create_deploy_nodejs.container.md)
+ [Mais aplicações de exemplo e tutoriais do Elastic Beanstalk para Node.js](nodejs-getstarted.md)
+ [Implantar uma aplicação Node.js Express no Elastic Beanstalk](create_deploy_nodejs_express.md)
+ [Implantar uma aplicação Node.js Express com clustering no Elastic Beanstalk](nodejs-express-clustering.md)
+ [Implantar uma aplicação Node.js com o DynamoDB no Elastic Beanstalk](nodejs-dynamodb-tutorial.md)
+ [Adicionar uma instância de banco de dados do Amazon RDS ao seu ambiente do Node.js Elastic Beanstalk](create-deploy-nodejs.rds.md)
+ [Ferramentas e recursos Node.js](create_deploy_nodejs.resources.md)

# QuickStart: implante um aplicativo Node.js no Elastic Beanstalk
<a name="nodejs-quickstart"></a>

Este QuickStart tutorial mostra o processo de criação de um aplicativo Node.js e sua implantação em um AWS Elastic Beanstalk ambiente.

**Não é para uso em produção**  
Os exemplos são destinados apenas para demonstração. Não use aplicações de exemplo na produção.

**Topics**
+ [Sua AWS conta](#nodejs-quickstart-aws-account)
+ [Pré-requisitos](#nodejs-quickstart-prereq)
+ [Etapa 1: criar uma aplicação Node.js](#nodejs-quickstart-create-app)
+ [Etapa 2: executar a aplicação localmente](#nodejs-quickstart-run-local)
+ [Etapa 3: implantar a aplicação Node.js com a EB CLI](#nodejs-quickstart-deploy)
+ [Etapa 4: executar a aplicação no Elastic Beanstalk](#nodejs-quickstart-run-eb-ap)
+ [Etapa 5: limpar](#go-tutorial-cleanup)
+ [AWS recursos para seu aplicativo](#nodejs-quickstart-eb-resources)
+ [Próximas etapas](#nodejs-quickstart-next-steps)
+ [Implantar com o console do Elastic Beanstalk](#nodejs-quickstart-console)

## Sua AWS conta
<a name="nodejs-quickstart-aws-account"></a>

Se você ainda não é AWS cliente, precisa criar uma AWS conta. A inscrição permite que você acesse o Elastic Beanstalk AWS e outros serviços de que você precisa.

Se você já tem uma AWS conta, você pode passar para[Pré-requisitos](#nodejs-quickstart-prereq).

### Crie uma AWS conta
<a name="nodejs-quickstart-aws-account-procedure"></a>

#### Inscreva-se para um Conta da AWS
<a name="sign-up-for-aws"></a>

Se você não tiver um Conta da AWS, conclua as etapas a seguir para criar um.

**Para se inscrever em um Conta da AWS**

1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup)

1. Siga as instruções online.

   Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.

   Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS envia um e-mail de confirmação após a conclusão do processo de inscrição. A qualquer momento, você pode visualizar a atividade atual da sua conta e gerenciar sua conta acessando [https://aws.amazon.com/e](https://aws.amazon.com/) escolhendo **Minha conta**.

#### Criar um usuário com acesso administrativo
<a name="create-an-admin"></a>

Depois de se inscrever em um Conta da AWS, proteja seu Usuário raiz da conta da AWS Centro de Identidade do AWS IAM, habilite e crie um usuário administrativo para que você não use o usuário root nas tarefas diárias.

**Proteja seu Usuário raiz da conta da AWS**

1.  Faça login [Console de gerenciamento da AWS](https://console.aws.amazon.com/)como proprietário da conta escolhendo **Usuário raiz** e inserindo seu endereço de Conta da AWS e-mail. Na próxima página, insira a senha.

   Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS *.

1. Habilite a autenticação multifator (MFA) para o usuário-raiz.

   Para obter instruções, consulte [Habilitar um dispositivo de MFA virtual para seu usuário Conta da AWS raiz (console) no Guia](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) do *usuário do IAM*.

**Criar um usuário com acesso administrativo**

1. Habilita o Centro de Identidade do IAM.

   Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.

1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário.

   Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte [Configurar o acesso do usuário com o padrão Diretório do Centro de Identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia Centro de Identidade do AWS IAM do usuário*.

**Iniciar sessão como o usuário com acesso administrativo**
+ Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado.

  Para obter ajuda para fazer login usando um usuário do IAM Identity Center, consulte Como [fazer login no portal de AWS acesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) no *Guia Início de Sessão da AWS do usuário*.

**Atribuir acesso a usuários adicionais**

1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.

   Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.

1. Atribua usuários a um grupo e, em seguida, atribua o acesso de logon único ao grupo.

   Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.

## Pré-requisitos
<a name="nodejs-quickstart-prereq"></a>

Para seguir os procedimentos neste manual, você precisa de um terminal de linha de comando ou de um shell para executar os comandos. Nas listagens, os comandos são mostrados precedidos por um símbolo de prompt (\$1) e pelo nome do diretório atual, quando apropriado.

```
~/eb-project$ this is a command
this is output
```

No Linux e no macOS, você pode usar seu gerenciador de pacotes e de shell preferido. No Windows, você pode [instalar o subsistema Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obter uma versão do Ubuntu e Bash integrada ao Windows.

### EB CLI
<a name="nodejs-quickstart-prereq.ebcli"></a>

Este tutorial também usa a Interface de Linhas de Comando do Elastic Beanstalk (CLI do EB). Para obter detalhes sobre a instalação e configuração da CLI do EB, 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).

### Node.js
<a name="nodejs-quickstart-prereq.runtime"></a>

Instale o Node.js na máquina local seguindo [Como instalar o Node.js](https://nodejs.org/en/learn/getting-started/how-to-install-nodejs) no site do Node.js. 

Verifique sua instalação do Node.js executando o comando a seguir.

```
~$ node -v
```

## Etapa 1: criar uma aplicação Node.js
<a name="nodejs-quickstart-create-app"></a>

Crie um diretório do projeto.

```
~$ mkdir eb-nodejs
~$ cd eb-nodejs
```

Depois, crie uma aplicação a ser implantada usando o Elastic Beanstalk. Criaremos um serviço RESTful web “Hello World”.

**Example `~/eb-nodejs/server.js`**  

```
const http = require('node:http');

const hostname = '127.0.0.1';
const port = 8080;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello Elastic Beanstalk!\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});
```

Esta aplicação abre um receptor na porta 8080. O Elastic Beanstalk encaminha solicitações para sua aplicação na porta 8080 por padrão para Node.js.

## Etapa 2: executar a aplicação localmente
<a name="nodejs-quickstart-run-local"></a>

Execute o seguinte comando para executar sua aplicação localmente.

```
~/eb-nodejs$ node server.js
```

Você deverá ver o seguinte texto.

```
Server running at http://127.0.0.1:8080/
```

Insira o endereço URL `http://127.0.0.1:8080/` no navegador. O navegador deve exibir “Hello Elastic Beanstalk\$1”.

## Etapa 3: implantar a aplicação Node.js com a EB CLI
<a name="nodejs-quickstart-deploy"></a>

Execute os seguintes comandos para criar um ambiente Elastic Beanstalk para essa aplicação.

**Para criar um ambiente e implantar sua aplicação Node.js**

1. Inicialize o repositório da EB CLI com o comando **eb init**:

   ```
   ~/eb-nodejs$ eb init -p node.js nodejs-tutorial --region us-east-2
   ```

   Este comando cria uma aplicação `nodejs-tutorial` e configura seu repositório local para criar ambientes com a versão mais recente da plataforma Node.js.

1. (Opcional) Execute **eb init** novamente para configurar um par de chaves padrão para que você possa usar o SSH para se conectar à EC2 instância que executa seu aplicativo.

   ```
   ~/eb-nodejs$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   Selecione um par de chaves se você já tiver um, ou siga os as instruções na tela para criar um. Se nenhum prompt aparecer ou se for necessário alterar as configurações posteriormente, execute **eb init -i**.

1. Crie um ambiente e implante o aplicativo nele com **eb create**. O Elastic Beanstalk cria automaticamente um arquivo zip para seu aplicativo e o implanta em uma instância no ambiente. EC2 Após implantar sua aplicação, o Elastic Beanstalk o inicia na porta 8080.

   ```
   ~/eb-nodejs$ eb create nodejs-env
   ```

   O Elastic Beanstalk leva cerca de cinco minutos para criar seu ambiente.

## Etapa 4: executar a aplicação no Elastic Beanstalk
<a name="nodejs-quickstart-run-eb-ap"></a>

Quando o processo de criação de seu ambiente for concluído, abra seu site com **eb open**.

```
~/eb-nodejs$ eb open
```

Parabéns\$1 Você implantou uma aplicação Node.js com o Elastic Beanstalk\$1 Isso abre uma janela do navegador usando o nome de domínio criado para o seu aplicativo.

## Etapa 5: limpar
<a name="go-tutorial-cleanup"></a>

Você pode encerrar o ambiente quando terminar de trabalhar com a aplicação. O Elastic Beanstalk AWS encerra todos os recursos associados ao seu ambiente.

Para encerrar seu ambiente do Elastic Beanstalk com a CLI do EB, execute o seguinte comando.

```
~/eb-nodejs$ eb terminate
```

## AWS recursos para seu aplicativo
<a name="nodejs-quickstart-eb-resources"></a>

Você acabou de criar uma aplicação de instância única. Ele serve como um aplicativo de amostra simples com uma única EC2 instância, portanto, não requer balanceamento de carga ou escalonamento automático. Para aplicativos de instância única, o Elastic Beanstalk cria os seguintes recursos: AWS 
+ **EC2 instância** — Uma máquina EC2 virtual da Amazon configurada para executar aplicativos web na plataforma que você escolher.

  Cada plataforma executa um conjunto diferente 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 nginx como um proxy reverso que processa tráfego da web na frente do aplicativo web, encaminha solicitações para ele, 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.
+ **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 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*. 

O Elastic Beanstalk gerencia todos esses recursos. Quando você encerra o ambiente, o Elastic Beanstalk encerra todos os recursos dele.

## Próximas etapas
<a name="nodejs-quickstart-next-steps"></a>

Depois que um ambiente estiver executando um aplicativo, você poderá implantar uma nova versão do aplicativo ou um aplicativo diferente a qualquer momento. A implantação de uma nova versão do aplicativo é muito rápida porque não exige provisionamento ou reinicialização de instâncias. EC2 Também é possível explorar o novo ambiente usando o console do Elastic Beanstalk. Para conhecer as etapas detalhadas, consulte [Explore seu ambiente](GettingStarted.md#GettingStarted.Explore), no capítulo *Primeiros passos* deste guia.

**Explore mais tutoriais**  
Se quiser experimentar outros tutoriais com diferentes aplicações de exemplo, consulte [Mais aplicações de exemplo e tutoriais do Elastic Beanstalk para Node.js](nodejs-getstarted.md).

Depois de implantar uma ou duas aplicações de exemplo e quando estiver pronto para começar a desenvolver e executar aplicações Node.js localmente, consulte [Configurar seu ambiente de desenvolvimento Node.js para o Elastic Beanstalk](nodejs-devenv.md).

## Implantar com o console do Elastic Beanstalk
<a name="nodejs-quickstart-console"></a>

Você também pode usar o console do Elastic Beanstalk para iniciar a aplicação de exemplo. Para conhecer as etapas detalhadas, consulte [Criar uma aplicação de exemplo](GettingStarted.md#GettingStarted.CreateApp), no capítulo *Primeiros passos* deste guia.

# Configurar seu ambiente de desenvolvimento Node.js para o Elastic Beanstalk
<a name="nodejs-devenv"></a>

Este tópico fornece instruções para configurar um ambiente de desenvolvimento Node.js para testar sua aplicação localmente antes de implantá-la no AWS Elastic Beanstalk. Também faz referência a sites com instruções de instalação para ferramentas úteis.

**Topics**
+ [Instale o Node.js.](#nodejs-devenv-nodejs)
+ [Confirmar instalação do NPM](#nodejs-devenv-npm)
+ [Instale o AWS SDK para Node.js](#nodejs-devenv-awssdk)
+ [Instale o gerador Express](#nodejs-devenv-express)
+ [Configurar uma estrutura e um servidor Express](#nodejs-devenv-express-framework)

## Instale o Node.js.
<a name="nodejs-devenv-nodejs"></a>

Instale Node.js para executar aplicativos Node.js localmente. Se você não tiver uma preferência, obtenha a versão mais recente compatível com o Elastic Beanstalk. Consulte [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) no documento *Plataformas do AWS Elastic Beanstalk * para obter uma lista das versões suportadas.

Faça download do Node.js em [nodejs.org](https://nodejs.org/en/).

## Confirmar instalação do NPM
<a name="nodejs-devenv-npm"></a>

O Node.js usa um gerenciador de pacotes do NPM que ajuda a instalar ferramentas e frameworks de trabalho para uso em seu aplicativo. Como o NPM é distribuído com Node.js, você o instalará automaticamente quando baixar e instalar o Node.js. Para confirmar que você tem o NPM instalado, você pode executar o seguinte comando:

```
$ npm -v
```

Para obter mais informações sobre o NPM, visite o site [npmjs](https://www.npmjs.com/get-npm) .

## Instale o AWS SDK para Node.js
<a name="nodejs-devenv-awssdk"></a>

Se você precisar gerenciar AWS recursos de dentro do seu aplicativo, instale o AWS SDK para JavaScript no Node.js. Instale o SDK com o NPM:

```
$ npm install aws-sdk
```

Visite a página inicial do [AWS SDK for JavaScript in Node.js](https://aws.amazon.com/sdk-for-node-js/) para obter mais informações.

## Instale o gerador Express
<a name="nodejs-devenv-express"></a>

O Express é um framework de aplicativo web que é executado no Node.js. Para usá-lo, primeiro instale o aplicativo de linha de comando do gerador Express. Depois que o gerador Express estiver instalado, você poderá executar o comando **express** para gerar uma estrutura de projeto base para sua aplicação web. Depois que o projeto base, os arquivos e as dependências estiverem instalados, você poderá iniciar um servidor Express local em sua máquina de desenvolvimento.

 

**nota**  
Estas etapas orientam você na instalação do gerador Express em um sistema operacional Linux.
Para Linux, dependendo do seu nível de permissão para diretórios do sistema, pode ser necessário prefixar alguns desses comandos com `sudo`.

**Para instalar o gerador Express em seu ambiente de desenvolvimento**

1. Crie um diretório de trabalho para sua estrutura e servidor Express. 

   ```
   ~$ mkdir node-express
   ~$ cd node-express
   ```

1. Instale o Express globalmente para ter acesso ao comando `express`.

   ```
   ~/node-express$ npm install -g express-generator
   ```

1. Dependendo de seu sistema operacional, pode ser necessário configurar seu caminho para executar o comando `express`. A saída da etapa anterior fornece informações se você precisar definir sua variável de caminho. O seguinte é um exemplo para Linux.

   ```
   ~/node-express$ export PATH=$PATH:/usr/local/share/npm/bin/express
   ```

   Ao seguir os tutoriais deste capítulo, você precisará executar o comando **express** de diferentes diretórios. Cada tutorial configura uma estrutura básica do projeto Express em seu próprio diretório.

Agora você instalou o gerador de linha de comando Express. Você pode usá-lo para criar um diretório de estrutura para seu aplicativo da web, configurar dependências e iniciar o servidor de aplicativos da web. Em seguida, seguiremos as etapas para fazer isso no diretório `node-express` que criamos.

## Configurar uma estrutura e um servidor Express
<a name="nodejs-devenv-express-framework"></a>

Siga estas etapas para criar os diretórios e conteúdos básicos da estrutura do Express. Os tutoriais neste capítulo também incluem estas etapas para configurar a estrutura básica do Express em cada um dos diretórios de aplicativos do tutorial.

**Configurar uma estrutura e um servidor Express**

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

   ```
   ~/node-express$ express
   ```

   Quando solicitado, digite **y** se você deseja continuar.

1. Configure as dependências locais.

   ```
   ~/node-express$ npm install
   ```

1. Verifique se o servidor de aplicativos da web é inicializado.

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

# Usar a plataforma Node.js do Elastic Beanstalk
<a name="create_deploy_nodejs.container"></a>

Este tópico descreve como configurar, criar e executar suas aplicações Node.js no Elastic Beanstalk.

AWS Elastic Beanstalk suporta várias ramificações de plataforma para diferentes versões da linguagem de programação Node.js. Consulte [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) no documento *Plataformas do AWS Elastic Beanstalk * para uma lista completa.

O Elastic Beanstalk fornece [opções de configuração](command-options.md) que podem ser usadas para personalizar o software que é executado nas instâncias do EC2 no ambiente Elastic Beanstalk. É possível [configurar as variáveis de ambiente](environments-cfg-softwaresettings.md#environments-cfg-softwaresettings-console) necessárias à aplicação, habilitar a alternância de logs para o Amazon S3 e mapear pastas da origem da aplicação que contenham arquivos estáticos para caminhos atendidos pelo servidor de proxy.

As opções de configuração estão disponíveis no console do Elastic Beanstalk para [modificar a configuração de um ambiente em execução](environment-configuration-methods-after.md). Para evitar a perda da configuração do ambiente quando você terminá-la, você pode usar [configurações salvas](environment-configuration-savedconfig.md) para salvar as configurações e depois aplicá-las a outro ambiente.

Para salvar as configurações no código-fonte, você pode incluir [arquivos de configuração](ebextensions.md). As definições em arquivos de configuração são aplicadas sempre que você cria um ambiente ou implementa a aplicação. Você também pode usar arquivos de configuração para instalar pacotes, executar scripts e realizar outras operações de personalização da instância em implantações.

É possível [incluir um arquivo `Package.json`](nodejs-platform-dependencies.md#nodejs-platform-packagejson) no pacote de fontes para instalar pacotes durante a implantação, fornecer um comando iniciar e especificar a versão do Node.js que você deseja que a aplicação use. Você pode incluir um [arquivo `npm-shrinkwrap.json`](nodejs-platform-shrinkwrap.md) para bloquear versões de dependência.

A plataforma Node.js inclui um servidor proxy para servir ativos estáticos, encaminhar tráfego para a aplicação e compactar respostas. Você pode [estender ou substituir a configuração de proxy padrão](nodejs-platform-proxy.md) para cenários avançados.

Existem várias opções para iniciar seu aplicativo. Você pode adicionar um [Procfile](nodejs-configuration-procfile.md) ao pacote de fontes para especificar o comando que inicia a aplicação. Quando você não fornece um `Procfile`, mas fornece um arquivo `package.json`, o Elastic Beanstalk executa `npm start`. Se você não fornecer nenhum dos dois, o Elastic Beanstalk procurará o arquivo `app.js` ou `server.js`, nessa ordem, e o executará.

As configurações aplicadas no console do Elastic Beanstalk substituem as mesmas configurações em arquivos de configuração, caso elas existam. Isso permite que você tenha configurações padrão em arquivos de configuração e as substitua por configurações específicas de ambiente no console. Para obter mais informações sobre precedência e outros métodos de alteração das configurações, consulte [Opções de configuração](command-options.md).

Para obter detalhes sobre as várias maneiras de estender uma plataforma do Elastic Beanstalk baseada em Linux, consulte [Estender as plataformas Linux do Elastic Beanstalk](platforms-linux-extend.md).

## Configurar o ambiente Node.js
<a name="nodejs-platform-console"></a>

Você pode usar as configurações da plataforma Node.js para aprimorar ainda mais o comportamento das instâncias do Amazon EC2. É possível editar a configuração da instância do Amazon EC2 do ambiente do Elastic Beanstalk usando o console do Elastic Beanstalk.

Você pode usar o console do Elastic Beanstalk para habilitar a alternância de logs para o Amazon S3 e configurar variáveis que sua aplicação pode ler no ambiente.

**Para configurar o ambiente Node.js no console do Elastic Beanstalk**

1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS

1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.

1. No painel de navegação, escolha **Configuration (Configuração)**.

1. Na categoria de configuração **Updates, monitoring, and logging (Atualizações, monitoramento e logs)**, escolha **Edit (Editar)**.

### Opções de contêiner
<a name="nodejs-platform-console-settings"></a>

É possível definir estas opções específicas da plataforma:
+ **Proxy server (Servidor de proxy)**: o servidor de proxy a ser usado nas instâncias de ambiente. Por padrão, o NGINX é usado.

### Opções de log
<a name="nodejs-platform-console-logging"></a>

A seção **Log Options (Opções de log)** tem duas configurações:
+ **Instance profile (Perfil da instância)**: especifica o perfil da instância que tem permissão para acessar o bucket do Amazon S3 associado à sua aplicação.
+ **Enable log file rotation to Amazon S3** (Habilitar a rotação de arquivos de log para o Amazon S3): especifica se os arquivos de log das instâncias do Amazon EC2 da aplicação serão copiados para o bucket do Amazon S3 associado a ela.

### Arquivos estáticos
<a name="nodejs-platform-console-staticfiles"></a>

Para melhorar a performance, você pode usar a seção **Static files** (Arquivos estáticos) para configurar o servidor proxy para servir arquivos estáticos (por exemplo, HTML ou imagens) de um conjunto de diretórios dentro da aplicação Web. Defina, para cada diretório, o caminho virtual para mapeamento de diretórios. Quando o servidor de proxy recebe uma solicitação para um arquivo no caminho especificado, ele atende o arquivo diretamente em vez de rotear solicitação para seu aplicativo.

Para ver detalhes sobre como configurar arquivos estáticos usando arquivos de configuração ou o console do Elastic Beanstalk, consulte [Fornecer arquivos estáticos](environment-cfg-staticfiles.md).

### Propriedades de ambiente
<a name="nodejs-platform-console-envprops"></a>

Use a seção **Propriedades do Ambiente** para especificar definições de configuração de ambientes nas instâncias do Amazon EC2 que estão executando sua aplicação. Essas definições são passadas para o aplicativo como pares de chave-valor.

Dentro do Node.js ambiente em que é executado AWS Elastic Beanstalk, você pode acessar as variáveis de ambiente executando`process.env.ENV_VARIABLE`.

```
var endpoint = process.env.API_ENDPOINT
```

A plataforma Node.js define a variável de ambiente PORT como a porta para a qual o servidor proxy direciona o tráfego. Para obter mais informações, consulte [Configurar o servidor de proxy](nodejs-platform-proxy.md).

Consulte [Variáveis de ambiente e outras configurações de software](environments-cfg-softwaresettings.md) para obter mais informações.

### Configurar um ambiente Node.js do Amazon Linux AMI (anterior ao Amazon Linux 2)
<a name="nodejs-platform-console.alami"></a>

As categorias a seguir de configuração de software do console só são compatíveis com um ambiente Node.js do Elastic Beanstalk que use uma versão da plataforma Amazon Linux AMI (anterior ao Amazon Linux 2).

**Observações**  
As informações neste tópico se aplicam somente às ramificações da plataforma baseadas no Amazon Linux AMI (AL1). AL2023/as ramificações da AL2 plataforma são incompatíveis com as versões anteriores da plataforma Amazon Linux AMI (AL1) e *exigem configurações diferentes*.
 [Em 18 de julho de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **o Elastic Beanstalk definiu o status de todas as ramificações da plataforma baseadas no Amazon Linux AMI AL1 () como descontinuadas.** Para obter mais informações sobre como migrar para uma ramificação da plataforma Amazon Linux 2023 atual e totalmente compatível, consulte [Migrar a aplicação Linux do Elastic Beanstalk para o Amazon Linux 2023 ou Amazon Linux 2](using-features.migration-al.md).

#### Opções de contêiner — Amazon Linux AMI (AL1)
<a name="nodejs-platform-console-settings"></a>

Na página de configuração, especifique o seguinte:
+ **Proxy server** (Servidor proxy): especifica o servidor Web a ser usado para conexões do proxy com o Node.js. Por padrão, o NGINX é usado. Se você selecionar **none** (nenhum), os mapeamentos de arquivos não terão efeito e a compactação GZIP será desabilitada.
+ **Node.js version** (Versão do ): especifica a versão do Node.js. Para obter uma lista das versões compatíveis do Node.js, consulte [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs), no guia *Plataformas AWS Elastic Beanstalk *.
+ **GZIP compression** (Compactação ): especifica se a compactação GZIP está habilitada. Por padrão, a compactação GZIP está habilitada.
+ **Node command** (Comando de nó): permite inserir o comando usado para iniciar a aplicação Node.js. Uma string vazia (o padrão) significa que o Elastic Beanstalk usa `app.js`, em seguida `server.js` e depois `npm start`.

## Namespace de configuração do Node.js
<a name="nodejs-namespaces"></a>

Você pode usar um [arquivo de configuração](ebextensions.md) para definir opções de configuração e executar outras tarefas de configuração de instância durante implantações. Opções de configuração podem ser [específicas da plataforma](command-options-specific.md) ou aplicáveis a [todas as plataformas](command-options-general.md) no serviço Elastic Beanstalk como um todo. As opções de configuração são organizadas em *namespaces*.

É possível escolher o proxy a ser usado nas instâncias do seu ambiente usando o namespace `aws:elasticbeanstalk:environment:proxy`. O exemplo a seguir configura o ambiente para usar o servidor proxy Apache HTTPD.

**Example .ebextensions/nodejs-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
```

É possível configurar o proxy para servir arquivos estáticos usando o namespace `aws:elasticbeanstalk:environment:proxy:staticfiles`. Para obter mais informações e um exemplo, consulte [Fornecer arquivos estáticos](environment-cfg-staticfiles.md).

O Elastic Beanstalk oferece muitas opções de configuração para personalizar o ambiente. Além de arquivos de configuração, você também pode definir opções de configuração usando o console, configurações salvas, a EB CLI ou a AWS CLI. Consulte [Opções de configuração](command-options.md) para obter mais informações.

## A plataforma Node.js do Amazon Linux AMI (anterior ao Amazon Linux 2)
<a name="nodejs.alami"></a>

Se o ambiente Node.js do Elastic Beanstalk usar uma versão da plataforma Amazon Linux AMI (anterior ao Amazon Linux 2), considere as configurações e recomendações específicas nesta seção.

**Observações**  
As informações neste tópico se aplicam somente às ramificações da plataforma baseadas no Amazon Linux AMI (AL1). AL2023/as ramificações da AL2 plataforma são incompatíveis com as versões anteriores da plataforma Amazon Linux AMI (AL1) e *exigem configurações diferentes*.
 [Em 18 de julho de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **o Elastic Beanstalk definiu o status de todas as ramificações da plataforma baseadas no Amazon Linux AMI AL1 () como descontinuadas.** Para obter mais informações sobre como migrar para uma ramificação da plataforma Amazon Linux 2023 atual e totalmente compatível, consulte [Migrar a aplicação Linux do Elastic Beanstalk para o Amazon Linux 2023 ou Amazon Linux 2](using-features.migration-al.md).

### Node.jsopções de configuração específicas da plataforma — Amazon Linux AMI () AL1
<a name="nodejs.alami.options"></a>

O Elastic Beanstalk é compatível com algumas opções de configurações específicas da plataforma para versões da plataforma Node.js do Amazon Linux AMI. Você pode escolher o servidor proxy para ser executado na frente da aplicação, uma versão específica do Node.js para ser executada e o comando usado para executar a aplicação.

Como servidor proxy, você pode usar um servidor proxy NGINX ou Apache. Você pode definir o valor `none` para a opção `ProxyServer`. Nesse caso, o Elastic Beanstalk executa a aplicação como autônoma, não por atrás de algum servidor de proxy. Se o ambiente executar uma aplicação autônoma, atualize o código para escutar a porta para a qual o NGINX direciona o tráfego.

```
var port = process.env.PORT || 8080;

app.listen(port, function() {
  console.log('Server running at http://127.0.0.1:%s', port);
});
```

### Node.jsversões de idioma — Amazon Linux AMI (AL1)
<a name="nodejs.alami.versions"></a>

Em termos de versão de linguagem compatível, a plataforma Node.js do Amazon Linux AMI é diferente de outras plataformas gerenciadas pelo Elastic Beanstalk. Isso porque cada versão da plataforma Node.js só é compatível com algumas versões da linguagem Node.js. Para obter uma lista das versões compatíveis do Node.js, consulte [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs), no guia *Plataformas AWS Elastic Beanstalk *.

Você pode usar uma opção de configuração específica da plataforma para definir a versão da linguagem. Para instruções, consulte [Configurar o ambiente Node.js](#nodejs-platform-console). Ou então, use o console do Elastic Beanstalk para atualizar a versão do Node.js que o ambiente usa, como parte da atualização da versão da plataforma.

**nota**  
Quando o suporte oferecido para a versão do Node.js que você estiver usando for removido da plataforma, será necessário alterar ou remover a configuração da versão antes de fazer a [atualização da plataforma](using-features.platform.upgrade.md). Isso pode ocorrer quando uma vulnerabilidade de segurança é identificada para uma ou mais versões do Node.js.  
Quando isso acontece, a tentativa de atualizar para uma nova versão da plataforma que não suporta a configuração [NodeVersion](command-options-specific.md#command-options-nodejs)falha. Para evitar a necessidade de criar um novo ambiente, altere a opção de *NodeVersion*configuração para uma versão do Node.js compatível com a versão antiga e a nova da plataforma, ou [remova a configuração da opção](environment-configuration-methods-after.md) e execute a atualização da plataforma.

**Para configurar a versão do Node.js do ambiente no console do Elastic Beanstalk**

1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS

1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.

1. Na página de visão geral do ambiente, em **Platform (Plataforma)**, escolha **Change (Alterar)**.

1. Na caixa de diálogo **Update platform version** (Atualizar versão da plataforma), selecione uma versão do Node.js.  
![\[Confirmação da versão da plataforma de atualização do Elastic Beanstalk\]](http://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/images/platform-nodejs-update-node-version.png)

1. Escolha **Salvar**.

### Node.jsnamespaces de configuração — Amazon Linux AMI () AL1
<a name="nodejs.alami.namespaces"></a>

A plataforma Node.js do Amazon Linux AMI define opções adicionais nos namespaces `aws:elasticbeanstalk:container:nodejs:staticfiles` e `aws:elasticbeanstalk:container:nodejs`.

O arquivo de configuração a seguir diz ao Elastic Beanstalk para usar `npm start` para executar a aplicação. Ele também define o tipo de proxy como Apache e permite compactação. Por fim, ele configura o proxy para servir arquivos estáticos de dois diretórios de origem. Uma origem são os arquivos HTML  no caminho `html` na raiz do site a partir do diretório de origem `statichtml`. A outra fonte são arquivos de imagem no `images` caminho sob a raiz do site a partir do diretório de origem `staticimages`.

**Example .ebextensions/node-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:container:nodejs: 
    NodeCommand: "npm start"
    ProxyServer: apache
    GzipCompression: true
  aws:elasticbeanstalk:container:nodejs:staticfiles:
    /html: statichtml
    /images: staticimages
```

O Elastic Beanstalk oferece muitas opções de configuração para personalizar o ambiente. Além de arquivos de configuração, você também pode definir opções de configuração usando o console, configurações salvas, a EB CLI ou a AWS CLI. Consulte [Opções de configuração](command-options.md) para obter mais informações.

# Configurar comandos de inicialização personalizados com um Procfile no Elastic Beanstalk
<a name="nodejs-configuration-procfile"></a>

Você pode incluir um arquivo denominado `Procfile` na raiz do pacote de fontes para especificar o comando que inicia a aplicação.

**Example Procfile**  

```
web: node index.js
```

Para obter informações sobre o uso de `Procfile`, consulte[Buildfile e Procfile](platforms-linux-extend.build-proc.md).

**nota**  
Esse recurso substitui a opção `NodeCommand` herdada no namespace `aws:elasticbeanstalk:container:nodejs`.

# Configurar dependências da sua aplicação no Elastic Beanstalk
<a name="nodejs-platform-dependencies"></a>

A aplicação pode ter dependências em alguns módulos Node.js, como os que você especifica nas instruções `require()`. Esses módulos são armazenados em um diretório `node_modules`. Quando a aplicação é executada, o Node.js carrega os módulos desse diretório. Para obter mais informações, consulte [Loading from node\$1modules folders](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) (Carregar das pastas node\$1modules) na documentação do Node.js.

Você pode especificar essas dependências usando um arquivo `package.json`. Se o Elastic Beanstalk detectar esse arquivo e não houver um diretório `node_modules` presente, o Elastic Beanstalk executa `npm install` como usuário de *aplicativo da web*. O comando `npm install` instala as dependências no diretório `node_modules`, que o Elastic Beanstalk cria de antemão. O comando `npm install` acessa os pacotes listados no arquivo `package.json` do registro npm público ou outros locais. Para obter mais informações, consulte o site [npm Docs](https://docs.npmjs.com/about-the-public-npm-registry). 

Se o Elastic Beanstalk detectar o diretório `node_modules`, não executa o `npm install`, mesmo que exista um arquivo `package.json`. O Elastic Beanstalk pressupõe que os pacotes de dependências estejam disponíveis no diretório `node_modules` para o Node.js acessar e carregar.

As seções a seguir fornecem mais informações sobre como estabelecer as dependências do módulo Node.js para a aplicação.

**nota**  
Se você tiver algum problema de implantação quando o Elastic Beanstalk estiver executando o `npm install`, considere a adoção de uma abordagem alternativa. Inclua o diretório `node_modules` com os módulos de dependências no pacote de fontes da aplicação. Dessa forma você contorna os problemas de instalação das dependências do registro npm público enquanto você investiga o problema. Como a origem dos módulos de dependências é um diretório local, fazer isso também pode ajudar a reduzir o tempo de implantação. Para obter mais informações, consulte [Incluir dependências do Node.js em um diretório node\$1modules](#nodejs-platform-nodemodules).

## Especificar as dependências do Node.js com um arquivo package.json
<a name="nodejs-platform-packagejson"></a>

Use um arquivo `package.json` na raiz do código-fonte do projeto para especificar pacotes de dependência e para fornecer um comando para iniciar. Quando existe um arquivo `package.json` presente e não existe um diretório `node_modules` na raiz da origem do projeto, o Elastic Beanstalk executa `npm install` como usuário do *aplicativo da web* para instalar dependências do registro npm público. O Elastic Beanstalk também usa o comando `start` para iniciar a aplicação. Para obter mais informações sobre o arquivo `package.json`, consulte [Specifying dependencies in a `package.json` file](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file) (Especificar dependências em um arquivo ) no site *npm Docs*. 

Use a palavra-chave `scripts` para fornecer um comando para iniciar. Atualmente, a palavra-chave `scripts` é usada em vez da opção herdada `NodeCommand` no namespace `aws:elasticbeanstalk:container:nodejs`.

**Example package.json: Express**  

```
{
    "name": "my-app",
    "version": "0.0.1",
    "private": true,
    "dependencies": {
      "ejs": "latest",
      "aws-sdk": "latest",
      "express": "latest",
      "body-parser": "latest"
    },
    "scripts": {
      "start": "node app.js"
    }
  }
```

**Modo de produção e dependências de desenvolvimento**  
Para especificar suas dependências no arquivo `package.json`, use os atributos *dependências* e *devDependencies*. O atributo *dependências* designa os pacotes exigidos pelo seu aplicativo em produção. O atributo *devDependencies* designa pacotes que são necessários apenas para desenvolvimento e testes locais.

Se você precisar instalar os pacotes *devDependencies*, defina a propriedade de ambiente NPM\$1USE\$1PRODUCTION como`false`. Com esta configuração, não usaremos as opções acima ao executar o npm install. Isso resultará na instalação dos pacotes *devDependencies*.

## Incluir dependências do Node.js em um diretório node\$1modules
<a name="nodejs-platform-nodemodules"></a>

Para implantar pacotes de dependência em instâncias de ambiente juntamente com o código da aplicação, inclua-os em um diretório chamado `node_modules` na raiz da fonte de seu projeto. Para obter mais informações, consulte [Downloading and installing packages locally](https://docs.npmjs.com/downloading-and-installing-packages-locally) (Baixar e instalar pacotes localmente) no site *npm Docs*. 

[Quando você implanta um `node_modules` diretório em uma versão da AL2 Node.js plataforma AL2023/, o Elastic Beanstalk presume que você está fornecendo seus próprios pacotes de dependências e evita instalar dependências especificadas em um arquivo package.json.](#nodejs-platform-packagejson) Node.jsprocura dependências no `node_modules` diretório. Para obter mais informações, consulte [Loading from node\$1modules Folders](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) (Carregar das pastas node\$1modules) na documentação do Node.js.

**nota**  
Se você tiver algum problema de implantação enquanto o Elastic Beanstalk estiver executando `npm install`, considere a abordagem descrita neste tópico como uma solução alternativa enquanto investiga o problema.   
 

### Considerações sobre o Node.js no Amazon Linux 2
<a name="nodejs-al2-considerations"></a>

Leia esta seção se você estiver usando uma ramificação da plataforma *Node.js* em execução no *Amazon Linux 2*.

#### Considerações sobre o Node.js no Amazon Linux 2
<a name="nodejs-al2-considerations-detail"></a>

**nota**  
As informações neste tópico se aplicam às ramificações Node.js da plataforma executadas no Amazon Linux 2. O conteúdo aqui descreve características e comportamentos AL2 específicos que diferem de AL2023.

**Variações de comando**  
As opções de comando variam de acordo com a versão do npm incluída na ramificação da plataforma Amazon Linux 2 na qual seu aplicativo é executado.
+ npm v6 — O Elastic Beanstalk instala dependências no modo de produção por padrão. Ele usa o comando `npm install --production`. 
+ npm v7 ou superior — O Elastic Beanstalk omite as *devDependencies*. Ele usa o comando `npm install --omit=dev`.

Ambos os comandos listados acima não instalam os pacotes que são *devDependencies*. 

**Protocolos SSH e HTTPS para dependências do Git**  
A partir do lançamento da plataforma Amazon Linux 2 de 7 de março de 2023, você pode usar os protocolos SSH e HTTPS para recuperar pacotes de um repositório Git. A ramificação da plataforma Node.js 16 suporta os protocolos SSH e HTTPS. Node.js 14 suporta somente o protocolo HTTPS.

**Example package.json —Node.js 16 suporta HTTPS e SSH**  

```
    ...
    "dependencies": {
      "aws-sdk": "https://github.com/aws/aws-sdk-js.git",
      "aws-chime": "git+ssh://git@github.com:aws/amazon-chime-sdk-js.git"
    }
```

**Versões e intervalos de versões**  
Use a palavra-chave `engines` no arquivo `package.json` para especificar a versão do Node.js que você deseja que a aplicação use. Você também pode especificar um intervalo de versões usando a notação npm. Para obter mais informações sobre a sintaxe para intervalos de versões, consulte [Semantic Versioning using npm](https://nodejs.dev/learn/semantic-versioning-using-npm) (Versionamento semântico usando o npm) no site Node.js. A palavra-chave `engines` no arquivo `package.json` do Node.js substitui a opção herdada `NodeVersion` no namespace `aws:elasticbeanstalk:container:nodejs`.

**Importante**  
O recurso para especificar intervalos de versões não está disponível para ramificações da plataforma Node.js em execução AL2023. Só oferecemos suporte a uma versão do Node.js em uma ramificação específica do Node.js em AL2023. Se o arquivo `package.json` especificar um intervalo de versões, ele será ignorado e a versão da ramificação da plataforma do Node.js será usada por padrão.

**Example `package.json`: versão única do Node.js**  

```
{
    ...
    "engines": { "node" : "14.16.0" }
  }
```

**Example `package.json`: intervalo de versões do Node.js**  

```
{
    ...
    "engines": { "node" : ">=10 <11" }
  }
```

Quando um intervalo de versões é indicado, o Elastic Beanstalk instala a versão do Node.js mais recente que a plataforma tem disponível dentro do intervalo. Neste exemplo, o intervalo indica que a versão deve ser maior ou igual à versão 10, mas menor que a versão 11. Como resultado, o Elastic Beanstalk instala a versão mais recente do Node.js, a 10.x.y, disponível na [plataforma compatível](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs).

Lembre-se de que você só pode especificar uma versão do Node.js que corresponda à ramificação da plataforma. Por exemplo, se você estiver usando a ramificação da plataforma Node.js 16, só poderá especificar uma versão 16.x.y do Node.js. Você pode usar as opções de intervalo de versões suportadas pelo npm para permitir mais flexibilidade. Para saber quais são as versões válidas do Node.js para cada ramificação da plataforma, consulte [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) no guia *Plataformas do AWS Elastic Beanstalk *.

**nota**  
Quando o suporte oferecido para a versão do Node.js que você estiver usando for removido da plataforma, será necessário alterar ou remover a configuração da versão do Node.js antes de fazer a [atualização da plataforma](using-features.platform.upgrade.md). Isso pode ocorrer quando uma vulnerabilidade de segurança é identificada para uma ou mais versões do Node.js.  
Nesse caso, ocorre uma falha na tentativa de atualizar para uma nova versão da plataforma não compatível com a versão do Node.js configurada. Para evitar a necessidade de criar um novo ambiente, altere a configuração da versão Node.js`package.json` para uma versão Node.js suportada pela versão antiga da plataforma e a nova. Você tem a opção de especificar um intervalo de versão Node.js que inclua uma versão suportada, conforme descrito anteriormente neste tópico. Você também tem a opção de remover a configuração e, em seguida, implantar o novo pacote de fonte.

# Bloquear dependências com npm shrinkwrap no Elastic Beanstalk
<a name="nodejs-platform-shrinkwrap"></a>

A plataforma Node.js executa o `npm install` como usuário do *aplicativo da web* sempre que você faz uma implantação. Quando há novas versões das dependências disponíveis, elas são instaladas quando você implanta a aplicação, o que pode causar demora na implantação.

Você pode evitar a atualização de dependências criando um arquivo `npm-shrinkwrap.json` que bloqueia as dependências do aplicativo para a versão atual.

```
$ npm install
$ npm shrinkwrap
wrote npm-shrinkwrap.json
```

Inclua esse arquivo no seu pacote de origem para garantir que as dependências sejam instaladas somente uma vez.

# Configurar o servidor de proxy
<a name="nodejs-platform-proxy"></a>

O Elastic Beanstalk usa o NGINX ou o Apache HTTPD como proxy reverso para mapear a aplicação para o balanceador de carga do Elastic Load Balancing na porta 80. O padrão é NGINX. O Elastic Beanstalk oferece uma configuração de proxy padrão que pode ser estendida ou modificada completamente por sua própria configuração.

Por padrão, o Elastic Beanstalk configura o proxy para encaminhar solicitações à sua aplicação na porta 5000. É possível modificar a porta padrão definindo a `PORT` [propriedade de ambiente](create_deploy_nodejs.container.md#nodejs-platform-console) para a porta de escuta da sua aplicação principal.

**nota**  
A porta na qual a aplicação escuta não afeta a porta à qual o servidor NGINXescuta para receber solicitações do balanceador de carga.

**Configurar o servidor proxy na sua versão da plataforma**  
Todas as AL2 plataformas AL2023/suportam um recurso de configuração de proxy uniforme. Para obter mais informações sobre como configurar o servidor proxy nas versões da sua plataforma executando AL2023/AL2, consulte[Configuração de proxy reverso](platforms-linux-extend.proxy.md). 

## Configurar o proxy da AMI do Amazon Linux (anterior ao Amazon Linux 2)
<a name="nodejs-platform-proxy.alami"></a>

Se o ambiente Node.js do Elastic Beanstalk usar uma versão da plataforma Amazon Linux AMI (anterior ao Amazon Linux 2), leia as informações desta seção.

**Observações**  
As informações neste tópico se aplicam somente às ramificações da plataforma baseadas no Amazon Linux AMI (AL1). AL2023/as ramificações da AL2 plataforma são incompatíveis com as versões anteriores da plataforma Amazon Linux AMI (AL1) e *exigem configurações diferentes*.
 [Em 18 de julho de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **o Elastic Beanstalk definiu o status de todas as ramificações da plataforma baseadas no Amazon Linux AMI AL1 () como descontinuadas.** Para obter mais informações sobre como migrar para uma ramificação da plataforma Amazon Linux 2023 atual e totalmente compatível, consulte [Migrar a aplicação Linux do Elastic Beanstalk para o Amazon Linux 2023 ou Amazon Linux 2](using-features.migration-al.md).

### Estendendo e substituindo a configuração padrão do proxy — Amazon Linux AMI () AL1
<a name="nodejs-platform-proxy.alami.extending"></a>

A plataforma Node.js usa um proxy reverso para retransmitir solicitações da porta 80 na instância para a aplicação que está escutando na porta 8081. O Elastic Beanstalk oferece uma configuração de proxy padrão que pode ser estendida ou modificada completamente por sua própria configuração.

Para estender a configuração padrão, adicione arquivos `.conf` a `/etc/nginx/conf.d` com um arquivo de configuração. Para um exemplo específico, consulte [Encerrar o HTTPS em instâncias do EC2 que executam Node.js](https-singleinstance-nodejs.md).

A plataforma Node.js define a variável de ambiente PORT como a porta para a qual o servidor proxy direciona o tráfego. Leia essa variável no seu código para configurar a porta da sua aplicação.

```
    var port = process.env.PORT || 3000;

    var server = app.listen(port, function () {
        console.log('Server running at http://127.0.0.1:' + port + '/');
    });
```

A configuração padrão do NGINX encaminha o tráfego para um servidor upstream denominado `nodejs` em `127.0.0.1:8081`. É possível remover a configuração padrão e fornecer a sua própria em um [arquivo de configuração](ebextensions.md).

**Example .ebextensions/proxy.config**  
O exemplo a seguir remove a configuração padrão e adiciona uma configuração personalizada que encaminha o tráfego para a porta 5000, em vez de 8081.  

```
files:
  /etc/nginx/conf.d/proxy.conf:
    mode: "000644"
    owner: root
    group: root
    content: |
      upstream nodejs {
        server 127.0.0.1:5000;
        keepalive 256;
      }

      server {
        listen 8080;

        if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
            set $year $1;
            set $month $2;
            set $day $3;
            set $hour $4;
        }
        access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
        access_log  /var/log/nginx/access.log  main;

        location / {
            proxy_pass  http://nodejs;
            proxy_set_header   Connection "";
            proxy_http_version 1.1;
            proxy_set_header        Host            $host;
            proxy_set_header        X-Real-IP       $remote_addr;
            proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        gzip on;
        gzip_comp_level 4;
        gzip_types text/html text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

        location /static {
            alias /var/app/current/static;
        }

      }

  /opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh:
    mode: "000755"
    owner: root
    group: root
    content: |
      #!/bin/bash -xe
      rm -f /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf
      service nginx stop 
      service nginx start

container_commands:
  removeconfig:
    command: "rm -f /tmp/deployment/config/#etc#nginx#conf.d#00_elastic_beanstalk_proxy.conf /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf"
```
A configuração de exemplo (`/etc/nginx/conf.d/proxy.conf`), usa a configuração padrão em `/etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf` como base para incluir o bloco de servidor padrão com configurações de compactação e log, bem como um mapeamento de arquivo estático.  
O comando `removeconfig` remove a configuração padrão do contêiner para garantir que o servidor proxy use a configuração personalizada. O Elastic Beanstalk recria a configuração padrão quando cada configuração é implantada. Para explicar isso, no exemplo a seguir, um post-configuration-deployment hook (`/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh`) é adicionado. Isso remove a configuração padrão e reinicia o servidor de proxy.

**nota**  
A configuração padrão pode ser alterada em versões futuras da plataforma Node.js. Use a versão mais recente da configuração como base para suas personalizações para garantir a compatibilidade.

Se você substituir a configuração padrão, deverá definir os mapeamento de arquivos estáticos e a compactação GZIP. Isso ocorre porque a plataforma não pode aplicar as [ configurações padrão](create_deploy_nodejs.container.md#nodejs-namespaces).

# Mais aplicações de exemplo e tutoriais do Elastic Beanstalk para Node.js
<a name="nodejs-getstarted"></a>

Esta seção fornece aplicações e tutoriais adicionais. O tópico [QuickStart para Node.js](nodejs-quickstart.md), localizado anteriormente neste tópico, orienta pela inicialização da aplicação de exemplo Node.js com a EB CLI.

 Para começar a usar os aplicativos Node.js AWS Elastic Beanstalk, tudo o que você precisa é de um [pacote de origem](applications-sourcebundle.md) do aplicativo para carregar como sua primeira versão do aplicativo e implantá-lo em um ambiente. 

## Iniciar um ambiente com um aplicativo Node.js de exemplo
<a name="nodejs-getstarted-samples"></a>

O Elastic Beanstalk fornece exemplos de aplicativos de página única para cada plataforma, bem como exemplos mais complexos que mostram o uso de recursos AWS adicionais, como Amazon RDS e recursos específicos da linguagem ou da plataforma e. APIs

**nota**  
Siga as etapas no arquivo `README.md` do pacote de origem para implantá-lo. 


**Amostras**  

|  Tipo de ambiente  |  Pacote de origem  |  Description  | 
| --- | --- | --- | 
|  Servidor Web  |   [nodejs.zip](samples/nodejs.zip)   |  Aplicativo de página única. Para iniciar a aplicação de exemplo com a EB CLI, consulte [QuickStart para Node.js](nodejs-quickstart.md). Você também pode usar o console do Elastic Beanstalk para iniciar a aplicação de exemplo. Para conhecer as etapas detalhadas, consulte [Criar uma aplicação de exemplo](GettingStarted.md#GettingStarted.CreateApp), no capítulo *Primeiros passos* deste guia.  | 
|  Servidor Web com o Amazon RDS  |  [nodejs-example-express-rds.zip](samples/nodejs-example-express-rds.zip)  |  Aplicativo de log de caminhada que usa a framework Express e um Amazon Relational Database Service (RDS). [Tutorial](create_deploy_nodejs_express.md)  | 
|  Servidor Web com Amazon ElastiCache  |  [nodejs-example-express-elasticache.zip](samples/nodejs-example-express-elasticache.zip)  |  Aplicativo web expresso que usa a Amazon ElastiCache para agrupamento. O clustering aprimora a alta disponibilidade, a performance e a segurança do seu aplicativo web. [Tutorial](nodejs-express-clustering.md)  | 
|  Servidor Web com DynamoDB, Amazon SNS e Amazon SQS  |  [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip)  |  Site Express que coleta informações de contato dos usuários para uma nova campanha de marketing da empresa. Usa o AWS SDK do Node.js para gravar entradas JavaScript em uma tabela do DynamoDB e os arquivos de configuração do Elastic Beanstalk para criar recursos no DynamoDB, no Amazon SNS e no Amazon SQS. [Tutorial](nodejs-dynamodb-tutorial.md)  | 

## Próximas etapas
<a name="nodejs-getstarted-next"></a>

Depois que um ambiente estiver executando um aplicativo, você poderá implantar uma nova versão do aplicativo ou um aplicativo completamente diferente a qualquer momento. A implantação de uma nova versão do aplicativo é muito rápida, pois não é necessário provisionar ou reiniciar as instâncias do EC2. Para obter detalhes sobre a implantação de aplicativo, consulte [Implantar uma nova versão do seu aplicativo](GettingStarted.md#GettingStarted.DeployApp).

Depois de implantar um ou dois aplicativos de exemplo e quando estiver pronto para começar a desenvolver e executar aplicativos Node.js localmente, consulte [Configurar seu ambiente de desenvolvimento Node.js para o Elastic Beanstalk](nodejs-devenv.md) para configurar um ambiente de desenvolvimento Node.js com todas as ferramentas e bibliotecas necessárias.

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

# Implantar uma aplicação Node.js Express com clustering no Elastic Beanstalk
<a name="nodejs-express-clustering"></a>

[http://expressjs.com/](http://expressjs.com/) O clustering aprimora a alta disponibilidade, a performance e a segurança do seu aplicativo web. Para saber mais sobre a Amazon ElastiCache, acesse [O que é a Amazon ElastiCache (Memcached](https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/Introduction.html))? no Guia do *usuário da Amazon ElastiCache (Memcached)*.

**nota**  
Este exemplo cria AWS recursos, pelos quais você pode ser cobrado. Para obter mais informações sobre AWS preços, consulte[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/). Alguns serviços fazem parte do nível de uso AWS gratuito. Se for um cliente novo, você pode testar esses serviços gratuitamente. Consulte [https://aws.amazon.com/free/](https://aws.amazon.com/free/) para obter mais informações.

## Pré-requisitos
<a name="nodejs-express-clustering.prereq"></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="nodejs-express-clustering.create"></a>

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

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

**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-elasticache`.

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

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-elasticache$ 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-elasticache$ eb create --sample nodejs-example-express-elasticache
   ```

   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-elasticache$ 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="nodejs-express-clustering.update"></a>

Atualize a aplicação demonstrativa no ambiente do Elastic Beanstalk para usar a framework do Express.

Você pode baixar o código-fonte final em [nodejs-example-express-elasticache.zip.](samples/nodejs-example-express-elasticache.zip)

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

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.

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

   ```
   ~/nodejs-example-express-elasticache$ 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-elasticache$ npm install
   ```

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

   ```
   ~/nodejs-example-express-elasticache$ 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. Renomeie `nodejs-example-express-elasticache/app.js` para `nodejs-example-express-elasticache/express-app.js`.

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

1. Atualize a linha `var app = express();` no `nodejs-example-express-elasticache/express-app.js` da seguinte forma:

   ```
   var app = module.exports = express();
   ```

1. No seu computador local, crie um arquivo chamado `nodejs-example-express-elasticache/app.js` com o seguinte código.

   ```
   /**
    * 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. Substitua o conteúdo do arquivo `nodejs-example-express-elasticache/bin/www` com o seguinte:

   ```
   #!/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. Implante as alterações em seu ambiente Elastic Beanstalk com o comando [**eb deploy**](eb3-deploy.md).

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

1. O ambiente será atualizado após alguns minutos. Assim que o ambiente estiver verde e pronto, atualize o URL para verificar se funcionou. Você deverá ver uma página da web dizendo: "Welcome to Express".

Você pode acessar os registros das EC2 instâncias que executam seu aplicativo. Para obter instruções sobre como acessar os logs, consulte [Visualizar logs de instâncias do Amazon EC2 no ambiente do Elastic Beanstalk](using-features.logging.md).

Em seguida, vamos atualizar o aplicativo Express para usar a Amazon ElastiCache.

**Para atualizar seu aplicativo Express para usar a Amazon ElastiCache**

1. No computador local, crie um diretório `.ebextensions` no diretório de nível superior do seu pacote de origem. Neste exemplo, usamos `nodejs-example-express-elasticache/.ebextensions`.

1. Crie um arquivo de configuração `nodejs-example-express-elasticache/.ebextensions/elasticache-iam-with-script.config` com o seguinte snippet. Para obter mais informações sobre o arquivo de configuração, consulte [Namespace de configuração do Node.js](create_deploy_nodejs.container.md#nodejs-namespaces). Isso cria um usuário do IAM com as permissões necessárias para descobrir os nós do ElastiCache e grava em um arquivo sempre que o cache muda. Você também pode copiar o arquivo do [nodejs-example-express-elasticachearquivo.zip.](samples/nodejs-example-express-elasticache.zip) Para obter mais informações sobre as ElastiCache propriedades, consulte[Exemplo: ElastiCache.](customize-environment-resources-elasticache.md).
**nota**  
YAML depende de um recuo consistente. Compare o nível de recuo ao substituir o conteúdo em um arquivo de configuração de exemplo e se confira se o editor de texto usa espaços, e não caracteres de tabulação, como recuo.

   ```
   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. No seu computador local, crie um arquivo de configuração `nodejs-example-express-elasticache/.ebextensions/elasticache_settings.config` com o seguinte trecho para configurar. ElastiCache

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

1. No seu computador local, substitua `nodejs-example-express-elasticache/express-app.js` pelo seguinte snippet. Esse arquivo lê a lista de nós do disco (`/var/nodelist`) e configura o Express para usar `memcached` como armazenamento de sessão se os nós estiverem presentes. Seu arquivo deve ter uma aparência semelhante à seguinte:

   ```
   /**
    * 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. No computador local, atualize `package.json` com o seguinte conteúdo:

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

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

1. Implante o aplicativo atualizado.

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

1. O ambiente será atualizado após alguns minutos. Depois que seu ambiente estiver verde e pronto, verifique se o código funcionou.

   1. Verifique o [ CloudWatch console da Amazon](https://console.aws.amazon.com/cloudwatch/home) para ver suas ElastiCache métricas. Para visualizar suas ElastiCache métricas, selecione **Métricas** no painel esquerdo e, em seguida, pesquise por **CurrItems**. Selecione **ElastiCache > Métricas do nó de cache** e, em seguida, selecione seu nó de cache para visualizar o número de itens no cache.  
![\[CloudWatch dashboard showing CurrItems metric for an ElastiCache node over time.\]](http://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/images/elasticache-express.png)
**nota**  
Verifique se você está visualizando a mesma região na qual implantou seu aplicativo.

      Se você copiar e colar o URL do aplicativo em outro navegador da Web e atualizar a página, verá sua CurrItem contagem aumentar após 5 minutos.

   1. Faça um snapshot dos logs. Para obter mais informações sobre recuperação de logs, consulte [Visualizar logs de instâncias do Amazon EC2 no ambiente do Elastic Beanstalk](using-features.logging.md).

   1. Verifique o arquivo `/var/log/nodejs/nodejs.log` no pacote de logs. Você deverá ver algo semelhante a:

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

## Limpeza
<a name="nodejs-express-clustering.delete"></a>

Se não quiser mais executar seu aplicativo, você pode limpar encerrando seu ambiente e excluindo o aplicativo.

Use o comando `eb terminate` para encerrar o seu ambiente e o comando `eb delete` para excluir o seu aplicativo. 

**Para encerrar seu ambiente**

No diretório onde você criou o repositório local, execute `eb terminate`.

```
$ eb terminate
```

Esse processo pode levar alguns minutos. O Elastic Beanstalk exibirá uma mensagem quando o ambiente foi encerrado com êxito. 

# Implantar uma aplicação Node.js com o DynamoDB no Elastic Beanstalk
<a name="nodejs-dynamodb-tutorial"></a>

Este tutorial e seu aplicativo de exemplo [nodejs-example-dynamo.zip orientam](samples/nodejs-example-dynamo.zip) você pelo processo de implantação de um aplicativo Node.js que usa o AWS SDK JavaScript em Node.js para interagir com o serviço Amazon DynamoDB. Você criará uma tabela do DynamoDB em um banco de dados desacoplado ou externo do ambiente. AWS Elastic Beanstalk Você também configurará o aplicativo para usar um banco de dados desacoplado. Em um ambiente de produção, é uma prática recomendada usar um banco de dados desacoplado do ambiente Elastic Beanstalk para que seja independente do ciclo de vida do ambiente. Essa prática também permite que você execute [implantações azul/verde](using-features.CNAMESwap.md).

O aplicativo de exemplo ilustra o seguinte:
+ Uma tabela do DynamoDB que armazena dados de texto fornecidos pelo usuário.
+ Os [arquivos de configuração](ebextensions.md) para criar a tabela.
+ Um tópico do Amazon Simple Notification Service.
+  O uso de um [arquivo package.json](nodejs-platform-dependencies.md#nodejs-platform-packagejson) para instalar pacotes durante a implantação.

**Topics**
+ [Pré-requisitos](#nodejs-dynamodb-tutorial-prereqs)
+ [Criar um ambiente do Elastic Beanstalk](#nodejs-dynamodb-tutorial-launch)
+ [Adicionar permissões às instâncias do seu ambiente](#nodejs-dynamodb-tutorial-role)
+ [Implante o aplicativo de exemplo](#nodejs-dynamodb-tutorial-deploy)
+ [Criar uma tabela do DynamoDB](#nodejs-dynamodb-tutorial-database)
+ [Atualizar os arquivos de configuração do aplicativo](#nodejs-dynamodb-tutorial-update)
+ [Configurar seu ambiente para alta disponibilidade](#nodejs-dynamodb-tutorial-configure)
+ [Limpeza](#nodejs-dynamodb-tutorial-cleanup)
+ [Próximas etapas](#nodejs-dynamodb-tutorial-nextsteps)

## Pré-requisitos
<a name="nodejs-dynamodb-tutorial-prereqs"></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="nodejs-dynamodb-tutorial-launch"></a>

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

```
~$ mkdir nodejs-example-dynamo
```

**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-dynamo`.

```
~$ cd nodejs-example-dynamo
```

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-dynamo$ 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-dynamo$ eb create --sample nodejs-example-dynamo
   ```

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

## Adicionar permissões às instâncias do seu ambiente
<a name="nodejs-dynamodb-tutorial-role"></a>

Seu aplicativo é executado em uma ou mais EC2 instâncias por trás de um balanceador de carga, atendendo a solicitações HTTP da Internet. Quando recebe uma solicitação que exige o uso de AWS serviços, o aplicativo usa as permissões da instância em que é executado para acessar esses serviços.

O aplicativo de amostra usa permissões de instância para gravar dados em uma tabela do DynamoDB e enviar notificações para um tópico do Amazon SNS com o SDK em Node.js. JavaScript Adicione as seguintes políticas gerenciadas ao [perfil de instância](concepts-roles-instance.md) padrão para conceder às EC2 instâncias em seu ambiente permissão para acessar o DynamoDB e o Amazon SNS:
+ **AmazonDynamoDBFullAcesso**
+ **Amazon SNSFull Access**

**Para adicionar políticas ao perfil da instância padrão**

1. Abra a página [Roles (Funções)](https://console.aws.amazon.com/iam/home#roles) no console do IAM.

1. Escolha **aws-elasticbeanstalk-ec2 funções**.

1. Na guia **Permissions (Permissões)**, escolha **Attach policies (Anexar políticas)**.

1. Selecione a política gerenciada para os serviços adicionais que o seu aplicativo utiliza. Para este tutorial, selecione `AmazonSNSFullAccess` e `AmazonDynamoDBFullAccess`. 

1. Escolha **Anexar política**.

Consulte [Gerenciar perfis de instância do Elastic Beanstalk](iam-instanceprofile.md) para saber mais sobre o gerenciamento de perfis de instância.

## Implante o aplicativo de exemplo
<a name="nodejs-dynamodb-tutorial-deploy"></a>

Agora seu ambiente está pronto para você implantar e executar o aplicativo de exemplo deste tutorial: [nodejs-example-dynamo.zip.](samples/nodejs-example-dynamo.zip)

**Para implantar e executar o aplicativo de exemplo do tutorial**

1. Altere seu diretório de trabalho atual para o diretório do aplicativo `nodejs-example-dynamo`.

   ```
   ~$ cd nodejs-example-dynamo
   ```

1. Baixe e extraia o conteúdo do pacote de origem do aplicativo de exemplo [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) para o diretório do aplicativo. `nodejs-example-dynamo`

1. Implante o aplicativo de exemplo em seu ambiente Elastic Beanstalk com o comando [**eb deploy**](eb3-deploy.md).

   ```
   ~/nodejs-example-dynamo$ eb deploy
   ```
**nota**  
Por padrão, o comando `eb deploy` cria um arquivo ZIP da pasta do seu projeto. Você pode configurar a EB CLI para implantar um artefato do seu processo de compilação, em vez de criar um arquivo ZIP da pasta do projeto. Para obter mais informações, consulte [Implantar um artefato, em vez da pasta do projeto](eb-cli3-configuration.md#eb-cli3-artifact).

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-dynamo$ eb open
   ```

O site coleta informações de contato do usuário e usa uma tabela do DynamoDB para armazenar os dados. Para adicionar uma entrada, escolha **Sign up today**, insira um nome e um endereço de e-mail e, em seguida, selecione **Sign Up\$1**. A aplicação Web grava o conteúdo do formulário na tabela e aciona uma notificação por e-mail do Amazon SNS.

![\[Startup landing page with teaser message and sign-up button for upcoming product launch.\]](http://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/images/nodejs-dynamodb-tutorial-app.png)


No momento, o tópico do Amazon SNS está configurado com um espaço reservado para notificações de e-mail. Você atualizará a configuração em breve, mas enquanto isso, pode verificar a tabela do DynamoDB e o tópico do Amazon SNS no Console de Gerenciamento da Console de gerenciamento da AWS.

**Para visualizar a tabela**

1. Abra a [página Tables (Tabelas)](https://console.aws.amazon.com/dynamodb/home?#tables:) no console do DynamoDB.

1. Encontre a tabela que o aplicativo criou. O nome começa com **awseb e contém**. **StartupSignupsTable**

1. Selecione a tabela, escolha **Items** e **Start search** para visualizar todos os itens na tabela.

A tabela contém uma entrada para cada endereço de e-mail enviado no site de inscrição. Além de gravar na tabela, a aplicação envia uma mensagem para um tópico do Amazon SNS que tem duas assinaturas, uma para notificações por e-mail para você e outra para uma fila do Amazon Simple Queue Service que uma aplicação de operador pode ler para processar solicitações e enviar e-mails para os clientes interessados.

**Para visualizar o tópico**

1. Abra a [página Topics (Tópicos)](https://console.aws.amazon.com/sns/v2/home?#/topics) no console do Amazon SNS.

1. Encontre o tópico que o aplicativo criou. O nome começa com **awseb e contém**. **NewSignupTopic**

1. Escolha o tópico para visualizar as assinaturas.

O aplicativo (`[app.js](https://github.com/awslabs/eb-node-express-sample/blob/master/app.js)`) define duas rotas. O caminho raiz (`/`) retorna uma página da Web renderizada a partir de um modelo Embedded JavaScript (EJS) com um formulário que o usuário preenche para registrar seu nome e endereço de e-mail. A submissão do formulário envia uma solicitação POST com os dados do formulário para a rota `/signup`, que grava uma entrada na tabela do DynamoDB e publica uma mensagem para o tópico do Amazon SNS para notificar o proprietário da inscrição.

A aplicação demonstrativa inclui os [arquivos de configuração](ebextensions.md) que criam a tabela do DynamoDB, o tópico do Amazon SNS e a fila do Amazon SQS usados pela aplicação. Isso permite que você crie um novo ambiente e teste a funcionalidade imediatamente, mas tem a desvantagem de vincular a tabela do DynamoDB ao ambiente. Para um ambiente de produção, você deve criar a tabela do DynamoDB fora do seu ambiente para evitar perdê-lo quando encerrar o ambiente ou atualizar sua configuração.

## Criar uma tabela do DynamoDB
<a name="nodejs-dynamodb-tutorial-database"></a>

Para usar uma tabela do DynamoDB externa com uma aplicação em execução no Elastic Beanstalk primeiro crie uma tabela no DynamoDB. Quando uma instância é criada fora do Elastic Beanstalk, ela é completamente independente do Elastic Beanstalk e dos ambientes do Elastic Beanstalk e não será encerrada pelo Elastic Beanstalk.

Crie uma tabela com as seguintes configurações:
+ **Table name (Nome da tabela)**: **nodejs-tutorial**
+ **chave primária**: **email**
+ Tipo de chave primária: **string**

**Como criar uma tabela do DynamoDB**

1. Abra a [página Tables (Tabelas)](https://console.aws.amazon.com/dynamodb/home?#tables:) no console de gerenciamento do DynamoDB.

1. Escolha **Criar tabela**.

1. Digite um **nome de tabela** e **chave primária**.

1. Escolha o tipo de chave primária.

1. Escolha **Criar**.

## Atualizar os arquivos de configuração do aplicativo
<a name="nodejs-dynamodb-tutorial-update"></a>

Atualize os [arquivos de configuração](ebextensions.md) na origem do aplicativo para usar a tabela **nodejs-tutorial** em vez de criar uma nova.

**Para atualizar o aplicativo de exemplo para uso em produção**

1. Altere seu diretório de trabalho atual para o diretório do aplicativo `nodejs-example-dynamo`.

   ```
   ~$ cd nodejs-example-dynamo
   ```

1. Abra `.ebextensions/options.config` e altere os valores das configurações a seguir:
   + **NewSignupEmail**— Seu endereço de e-mail.
   + **STARTUP\$1SIGNUP\$1TABLE**: **nodejs-tutorial**

     
**Example .ebextensions/options.config**  

   ```
   option_settings:
     aws:elasticbeanstalk:customoption:
       NewSignupEmail: you@example.com
     aws:elasticbeanstalk:application:environment:
       THEME: "flatly"
       AWS_REGION: '`{"Ref" : "AWS::Region"}`'
       STARTUP_SIGNUP_TABLE: nodejs-tutorial
       NEW_SIGNUP_TOPIC: '`{"Ref" : "NewSignupTopic"}`'
     aws:elasticbeanstalk:container:nodejs:
       ProxyServer: nginx
     aws:elasticbeanstalk:container:nodejs:staticfiles:
       /static: /static
     aws:autoscaling:asg:
       Cooldown: "120"
     aws:autoscaling:trigger:
       Unit: "Percent"
       Period: "1"
       BreachDuration: "2"
       UpperThreshold: "75"
       LowerThreshold: "30"
       MeasureName: "CPUUtilization"
   ```

   Isso aplica as seguintes configurações para o aplicativo:
   + O endereço de e-mail que o tópico do Amazon SNS usa para notificações é definido como seu endereço ou aquele que você insere no arquivo `options.config`.
   + A tabela **nodejs-tutorial** será usada em vez da criada por `.ebextensions/create-dynamodb-table.config`.

1. Remova `.ebextensions/create-dynamodb-table.config`.

   ```
   ~/nodejs-tutorial$ rm .ebextensions/create-dynamodb-table.config
   ```

   Na próxima vez que você implantar o aplicativo, a tabela criada por esse arquivo de configuração será excluída.

1. Implante o aplicativo atualizado em seu ambiente Elastic Beanstalk com o comando [**eb deploy**](eb3-deploy.md).

   ```
   ~/nodejs-example-dynamo$ eb deploy
   ```

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-dynamo$ eb open
   ```

Quando você implanta, o Elastic Beanstalk atualiza a configuração do tópico do Amazon SNS e exclui a tabela do DynamoDB que ele criou quando a primeira versão da aplicação foi implantada.

Agora, quando você encerrar o ambiente, a tabela **nodejs-tutorial** não será excluída. Isso permite que você realize implantações azul/verde, modifique os arquivos de configuração ou desative seu site sem o risco de perda de dados.

Abra seu site em um navegador e verifique se o formulário funciona como esperado. Crie alguma entradas e, depois, verifique o console do DynamoDB para verificar a tabela.

**Para visualizar a tabela**

1. Abra a [página Tables (Tabelas)](https://console.aws.amazon.com/dynamodb/home?#tables:) no console do DynamoDB.

1. Encontre a tabela **nodejs-tutorial**.

1. Selecione a tabela, escolha **Items** e **Start search** para visualizar todos os itens na tabela.

Você também pode ver que o Elastic Beanstalk excluiu a tabela que foi criada anteriormente.

## Configurar seu ambiente para alta disponibilidade
<a name="nodejs-dynamodb-tutorial-configure"></a>

Por fim, configure o grupo de Auto Scaling do seu ambiente com uma contagem mínima de instâncias mais alta. Execute pelo menos duas instâncias o tempo todo para impedir que os servidores Web em seu ambiente sejam um ponto único de falha e para permitir que você implante alterações sem colocar seu site fora do serviço.

**Para configurar o grupo de Auto Scaling de seu ambiente para alta disponibilidade**

1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS

1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.

1. No painel de navegação, escolha **Configuration (Configuração)**.

1. Na categoria de configuração **Capacity (Capacidade)**, escolha **Edit (Editar)**.

1. Na seção **Auto Scaling group (Grupo de Auto Scaling)** defina **Min instances (Mínimo de instâncias)** como **2**.

1. Para salvar as alterações, escolha **Apply (Aplicar)** na parte inferior da página.

## Limpeza
<a name="nodejs-dynamodb-tutorial-cleanup"></a>

Depois de terminar de trabalhar com o código de demonstração, você pode encerrar seu ambiente. [O Elastic Beanstalk exclui todos os recursos AWS relacionados, [como instâncias da EC2 Amazon](using-features.managing.ec2.md), [instâncias de banco de dados, balanceadores de carga[,](using-features.managing.elb.md)](using-features.managing.db.md) grupos de segurança e alarmes.](using-features.alarms.md#using-features.alarms.title) 

Como a remoção de recursos não exclui a aplicação Elastic Beanstalk, é possível criar ambientes para a aplicação a qualquer momento.

**Para encerrar seu ambiente Elastic Beanstalk do console**

1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS

1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.

1. Escolha **Actions** (Ações) e depois **Terminate Environment** (Encerrar ambiente).

1. Use a caixa de diálogo na tela para confirmar o encerramento do ambiente.

Você também pode excluir as tabelas externas do DynamoDB que você criou.

**Como excluir uma tabela do DynamoDB**

1. Abra a [página Tables (Tabelas)](https://console.aws.amazon.com/dynamodb/home?#tables:) no console do DynamoDB.

1. Selecione uma tabela.

1. Escolha **Actions** e, em seguida, escolha **Delete table**.

1. Escolha **Excluir**.

## Próximas etapas
<a name="nodejs-dynamodb-tutorial-nextsteps"></a>

O aplicativo de exemplo usa arquivos de configuração para definir as configurações do software e criar AWS recursos como parte do seu ambiente. Consulte [Personalização avançada de ambiente com arquivos de configuração (`.ebextensions`)](ebextensions.md) para obter mais informações sobre os arquivos de configuração e seu uso.

O aplicativo de exemplo para este tutorial usa a framework da Web Express para Node.js. Para obter mais informações sobre o Express, consulte a documentação oficial em [expressjs.com](https://expressjs.com).

Por fim, se você planeja usar seu aplicativo em um ambiente de produção, [configure um nome de domínio personalizado](customdomains.md) para seu ambiente e [habilite o HTTPS](configuring-https.md) para conexões seguras.

# Adicionar uma instância de banco de dados do Amazon RDS ao seu ambiente do Node.js Elastic Beanstalk
<a name="create-deploy-nodejs.rds"></a>

Este tópico fornece instruções para criar o Amazon RDS usando o console do Elastic Beanstalk. É possível usar uma instância de banco de dados do Amazon Relational Database Service (Amazon RDS) para armazenar dados coletados e modificados pela aplicação. O banco de dados pode ser acoplado ao seu ambiente e gerenciado pelo Elastic Beanstalk ou pode ser criado como desacoplado e gerenciado externamente por outro serviço. Nestas instruções, o banco de dados é acoplado ao ambiente e gerenciado pelo Elastic Beanstalk. Para obter mais informações sobre como integrar um Amazon RDS com o Elastic Beanstalk, consulte [Adição de um banco de dados ao seu ambiente do Elastic Beanstalk](using-features.managing.db.md).

**Topics**
+ [Adicionar uma instância de banco de dados ao seu ambiente](#nodejs-rds-create)
+ [Download de um driver](#nodejs-rds-drivers)
+ [Conectar-se a um banco de dados](#nodejs-rds-connect)

## Adicionar uma instância de banco de dados ao seu ambiente
<a name="nodejs-rds-create"></a>

**Para adicionar uma instância de banco de dados ao ambiente**

1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS

1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.

1. No painel de navegação, escolha **Configuration (Configuração)**.

1. Na categoria de configuração **Database (Banco de dados)**, escolha **Edit (Editar)**.

1. Escolha um mecanismo de banco de dados e insira um nome de usuário e senha.

1. Para salvar as alterações, escolha **Apply (Aplicar)** na parte inferior da página.

A adição de uma instância de banco de dados leva cerca de 10 minutos. Quando a atualização do ambiente for concluída, o nome de host da instância de banco de dados e outras informações de conexão estarão disponíveis para o seu aplicativo por meio das seguintes propriedades de ambiente:


| Nome da propriedade | Descrição | Valor da propriedade | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  O nome do host da instância de banco de dados.  |  Na guia **Connectivity & security (Conectividade e segurança)** no console do Amazon RDS: **Endpoint**.  | 
|  `RDS_PORT`  |  A porta na qual a instância de banco de dados aceita conexões. O valor padrão varia entre os mecanismos de banco de dados.  |  Na guia **Connectivity & security (Conectividade e segurança)** do console do Amazon RDS: **Port (Porta)**.  | 
|  `RDS_DB_NAME`  |  O nome do banco de dado, **ebdb**.  |  Na guia **Configuration (Configuração)** no console do Amazon RDS: **DB Name (Nome do banco de dados)**.  | 
|  `RDS_USERNAME`  |  O nome de usuário que você configurou para seu banco de dados.  |  Na guia **Configuration (Configuração)** do console do Amazon RDS: **Nome de usuário primário**.  | 
|  `RDS_PASSWORD`  |  A senha que você configurou para seu banco de dados.  |  Não disponível para referência no console do Amazon RDS.  | 

Para obter mais informações sobre como configurar uma instância de banco de dados acoplada a um ambiente Elastic Beanstalk, consulte [Adição de um banco de dados ao seu ambiente do Elastic Beanstalk](using-features.managing.db.md).

## Download de um driver
<a name="nodejs-rds-drivers"></a>

Adicione o driver de banco de dados ao arquivo [`package.json` do projeto](nodejs-platform-dependencies.md#nodejs-platform-packagejson) em `dependencies`.

**Example `package.json`: Express com MySQL**  

```
{
  "name": "my-app",
  "version": "0.0.1",
  "private": true,
  "dependencies": {
    "ejs": "latest",
    "aws-sdk": "latest",
    "express": "latest",
    "body-parser": "latest",
    "mysql": "latest"
  },
  "scripts": {
    "start": "node app.js"
  }
}
```

**Pacotes de drivers comuns para Node.js**
+ **MySQL** – [mysql](https://www.npmjs.com/package/mysql)
+ **PostgreSQL** – [node-postgres](https://www.npmjs.com/package/pg)
+ **SQL Server** – [node-mssql](https://www.npmjs.com/package/mssql)
+ **Oracle** – [node-oracledb](https://www.npmjs.com/package/oracledb)

## Conectar-se a um banco de dados
<a name="nodejs-rds-connect"></a>

O Elastic Beanstalk fornece informações de conexão referentes às instâncias de banco de dados associadas nas propriedades de ambiente. Use `process.env.VARIABLE` para ler as propriedades e configurar uma conexão de banco de dados.

**Example app.js: conexão de banco de dados MySQL**  

```
var mysql = require('mysql');

var connection = mysql.createConnection({
  host     : process.env.RDS_HOSTNAME,
  user     : process.env.RDS_USERNAME,
  password : process.env.RDS_PASSWORD,
  port     : process.env.RDS_PORT
});

connection.connect(function(err) {
  if (err) {
    console.error('Database connection failed: ' + err.stack);
    return;
  }

  console.log('Connected to database.');
});

connection.end();
```
[Para obter mais informações sobre como construir uma string de conexão usando node-mysql, consulte npmjs. org/package/mysql](https://npmjs.org/package/mysql).

# Ferramentas e recursos Node.js
<a name="create_deploy_nodejs.resources"></a>

Há vários lugares que você pode acessar para obter ajuda adicional durante o desenvolvimento de seus aplicativos Node.js: 


****  

|  Recurso  |  Description  | 
| --- | --- | 
|  [GitHub](https://github.com/aws/aws-sdk-js)  | Instale o AWS SDK para Node.js usando o. GitHub  | 
|  [AWS SDK para Node.js (prévia para desenvolvedores)](https://aws.amazon.com/sdkfornodejs/)  | Um local central para acessar código de exemplo, documentação, ferramentas e outros recursos. |