As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Implantar uma aplicação rails no Elastic Beanstalk
Rails é uma estrutura de código aberto model-view-controller (MVC) para Ruby. Este tutorial mostra o processo de geração de um aplicativo Rails e sua implantação em um AWS Elastic Beanstalk ambiente.
**Topics**
+ [Pré-requisitos](#ruby-rails-tutorial-prereqs)
+ [Conhecimento básico do Elastic Beanstalk](#ruby-rails-tutorial-prereqs-basic)
+ [Iniciar um ambiente do Elastic Beanstalk](#ruby-rails-tutorial-launch)
+ [Instalar o rails e gerar um site](#ruby-rails-tutorial-generate)
+ [Definir as configurações do rails](#ruby-rails-tutorial-configure)
+ [Implantar o aplicativo](#ruby-rails-tutorial-deploy)
+ [Limpeza](#ruby-rails-tutorial-cleanup)
+ [Próximas etapas](#ruby-rails-tutorial-nextsteps)
## Pré-requisitos
## Conhecimento básico do Elastic Beanstalk
Este tutorial pressupõe que você tenha conhecimento das operações básicas e do console do Elastic Beanstalk. Caso ainda não tenha, siga as instruções em [Saiba como começar a usar o Elastic Beanstalk](GettingStarted.md) para iniciar seu primeiro ambiente do Elastic Beanstalk.
### Linha de comando
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.
### Dependências do rails
O framework Rails 6.1.4.1 tem as dependências a seguir. Certifique-se de que você tem todas elas instaladas.
+ **Ruby 2.5.0 ou mais recente**: para obter instruções de instalação, consulte [Configurar seu ambiente de desenvolvimento Ruby para o Elastic Beanstalk](ruby-development-environment.md).
Neste tutorial, usamos Ruby 3.0.2 e a versão correspondente da plataforma do Elastic Beanstalk.
+ **Node.js**: para obter instruções de instalação, consulte [Instalar o Node.js como o gerenciador de pacotes](https://nodejs.org/en/download/package-manager/).
+ **Yarn**: para obter instruções de instalação, consulte [Installation](https://yarnpkg.com/lang/en/docs/install/) no site do *Yarn*.
## Iniciar um ambiente do Elastic Beanstalk
Use o console do Elastic Beanstalk para criar um ambiente do Elastic Beanstalk. Escolha a configuração da Plataforma **Ruby** e aceite as configurações padrão e o código de exemplo.
**Para iniciar um ambiente (console)**
1. [Abra o console do Elastic Beanstalk usando este link pré-configurado: console.aws.amazon. com/elasticbeanstalk/home\$1/newApplication? Nome do aplicativo = Tutoriais](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced) e tipo de ambiente = LoadBalanced
1. Em **Platform (Plataforma)**, selecione a plataforma e a ramificação da plataforma que correspondem à linguagem usada pelo seu aplicativo.
1. Para **Application code**, escolha **Sample application**.
1. Selecione **Review and launch**.
1. Examine as opções disponíveis. Escolha a opção disponível que deseja usar e, quando estiver pronto, escolha **Create app (Criar aplicativo)**.
A criação de ambiente leva cerca de 5 minutos e cria 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.
Todos esses recursos são gerenciados pelo Elastic Beanstalk. Quando você encerra o ambiente, o Elastic Beanstalk encerra todos os recursos dele.
**nota**
O bucket do Amazon S3 que o Elastic Beanstalk cria é compartilhado entre ambientes e não é excluído durante o encerramento do ambiente. Para obter mais informações, consulte [Usar o Elastic Beanstalk com o Amazon S3](AWSHowTo.S3.md).
## Instalar o rails e gerar um site
Instale o Rails e suas dependências com o comando `gem`.
```
~$ gem install rails
Fetching: concurrent-ruby-1.1.9.gem
Successfully installed concurrent-ruby-1.1.9
Fetching: rack-2.2.3.gem
Successfully installed rack-2.2.3
...
```
Teste a instalação do Rails.
```
~$ rails --version
Rails 6.1.4.1
```
Use `rails new` com o nome do aplicativo para criar um novo projeto Rails.
```
~$ rails new ~/eb-rails
```
O Rails cria um diretório com o nome especificado, gera todos os arquivos necessários para executar um projeto de exemplo localmente e, em seguida, executa o bundler para instalar todas as dependências (Gems) definidas no Gemfile do projeto.
**nota**
Este processo instala a versão mais recente do Puma para o projeto. Talvez essa versão seja diferente da versão que o Elastic Beanstalk fornece na versão da plataforma Ruby do seu ambiente. Para ver as versões do Puma fornecidas pelo Elastic Beanstalk, consulte [Histórico de plataforma Ruby](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platform-history-ruby.html) no *Guia de plataformas do AWS Elastic Beanstalk *. Para mais informações sobre a versão mais recente do Puma, consulte o site [Puma.io](http://puma.io). Se houver uma incompatibilidade entre as duas versões do Puma, adote uma das seguintes opções:
Use a versão do Puma instalada pelo comando `rails new` anterior. Nesse caso, é necessário adicionar um `Procfile` para que a plataforma use a versão do servidor Puma que você fornece. Para obter mais informações, consulte [Configurar o processo da aplicação com um Procfile no Elastic Beanstalk.](ruby-platform-procfile.md).
Atualize a versão do Puma para ser consistente com a versão pré-instalada na versão da plataforma Ruby do seu ambiente. Para fazer isso, modifique a versão do Puma no [Gemfile](ruby-platform-gemfile.md#ruby-platform-gemfile.title) localizado na raiz do diretório de origem do projeto. Em seguida, execute `bundle update`. Para mais informações, consulte a página [bundle update](https://bundler.io/man/bundle-update.1.html) (atualização do pacote) no site Bundler.io.
Teste a instalação do Rails executando o projeto padrão localmente.
```
~$ cd eb-rails
~/eb-rails$ rails server
=> Booting Puma
=> Rails 6.1.4.1 application starting in development
=> Run `bin/rails server --help` for more startup options
Puma starting in single mode...
* Puma version: 5.5.2 (ruby 3.0.2-p107) ("Zawgyi")
* Min threads: 5
* Max threads: 5
* Environment: development
* PID: 77857
* Listening on http://127.0.0.1:3000
* Listening on http://[::1]:3000
Use Ctrl-C to stop
...
```
Abra `http://localhost:3000` em um navegador da web para ver o projeto padrão em ação.
![\[A página de desenvolvimento padrão do site do rails.\]](http://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/images/ruby-rails-default.png)
Essa página só está visível em modo de desenvolvimento. Adicione algum conteúdo à página inicial da aplicação para oferecer suporte à implantação de produção no Elastic Beanstalk. Use `rails generate` para criar um controlador, uma rota e uma visualização de sua página de boas-vindas.
```
~/eb-rails$ rails generate controller WelcomePage welcome
create app/controllers/welcome_page_controller.rb
route get 'welcome_page/welcome'
invoke erb
create app/views/welcome_page
create app/views/welcome_page/welcome.html.erb
invoke test_unit
create test/controllers/welcome_page_controller_test.rb
invoke helper
create app/helpers/welcome_page_helper.rb
invoke test_unit
invoke assets
invoke coffee
create app/assets/javascripts/welcome_page.coffee
invoke scss
create app/assets/stylesheets/welcome_page.scss.
```
Isso fornece tudo o que você precisa para acessar a página na `/welcome_page/welcome`. No entanto, antes de publicar as alterações, altere o conteúdo na visualização e adicione uma rota para que essa página apareça no nível superior do site.
Use um editor de texto para editar o conteúdo em `app/views/welcome_page/welcome.html.erb`. Para este exemplo, você usará `cat` para simplesmente substituir o conteúdo do arquivo existente.
**Example app/views/welcome\$1page/welcome.html.erb**
```
Welcome!
This is the front page of my first Rails application on Elastic Beanstalk.
```
Por fim, adicione a seguinte rota a `config/routes.rb`:
**Example config/routes.rb**
```
Rails.application.routes.draw do
get 'welcome_page/welcome'
root 'welcome_page#welcome'
```
Isso instrui o Rails a rotear as solicitações à raiz do site para o método de boas-vindas do controlador da página de boas-vindas, que renderiza o conteúdo na visualização de boas-vindas (`welcome.html.erb`).
Para que o Elastic Beanstalk implante com sucesso a aplicação na plataforma Ruby, precisamos atualizar o `Gemfile.lock`. Algumas dependências do `Gemfile.lock ` talvez sejam específicas da plataforma. Portanto, precisamos adicionar **platform ruby** a `Gemfile.lock` para que todas as dependências necessárias sejam instaladas com a implantação.
**Example**
```
~/eb-rails$ bundle lock --add-platform ruby
Fetching gem metadata from https://rubygems.org/............
Resolving dependencies...
Writing lockfile to /Users/janedoe/EBDPT/RubyApps/eb-rails-doc-app/Gemfile.lock
```
## Definir as configurações do rails
Use o console do Elastic Beanstalk para configurar o Rails com propriedades do ambiente. Defina a propriedade do ambiente `SECRET_KEY_BASE` para uma string de até 256 caracteres alfanuméricos.
O Rails usa essa propriedade para criar chaves. Portanto, você deve mantê-la em segredo e não armazená-la no controle de origem em texto sem formatação. Em vez disso, você a fornece ao código do Rails no ambiente por meio de uma propriedade de ambiente.
**Para configurar variáveis de 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. 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)**.
1. Role para baixo até **Variáveis de ambiente de runtime**.
1. Selecione **Adicionar variável de ambiente**.
1. Em **Origem**, selecione **Texto sem formatação**.
**nota**
Os valores do **Secrets Manager** e do **SSM Parameter Store** no menu suspenso servem para configurar variáveis de ambiente como segredos para armazenar dados sensíveis, como credenciais e chaves de API. Para obter mais informações, consulte [Usando o Elastic AWS Secrets Manager AWS Systems Manager Beanstalk com um Parameter Store](AWSHowTo.secrets.md).
1. Insira os pares de **Nome da variável de ambiente** e **Valores da variável de ambiente**.
1. Se for necessário adicionar mais variáveis, repita a **Etapa 6** até a **Etapa 8**.
1. Para salvar as alterações, escolha **Apply (Aplicar)** na parte inferior da página.
Agora você está pronto para implantar o site no ambiente.
## Implantar o aplicativo
Crie um [pacote de origem](applications-sourcebundle.md) com os arquivos criados pelo Rails. O comando a seguir cria um pacote de origem chamado `rails-default.zip`.
```
~/eb-rails$ zip ../rails-default.zip -r * .[^.]*
```
Faça upload do pacote de origem no Elastic Beanstalk para implantar o Rails no ambiente.
**Para implantar um pacote de origem**
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, escolha **Upload and deploy (Fazer upload e implantar)**.
1. Use a caixa de diálogo na tela para carregar o pacote de origem.
1. Escolha **Deploy (Implantar)**.
1. Quando a implantação for concluída, é possível escolher o URL do site para abri-lo em uma nova guia.
## Limpeza
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.
## Próximas etapas
Para obter mais informações sobre o Rails, visite [rubyonrails.org](https://rubyonrails.org/).
À medida que você desenvolva a aplicação, provavelmente vai precisar de uma maneira de gerenciar ambientes e implantá-la sem criar manualmente um arquivo .zip e carregá-la no console do Elastic Beanstalk. A interface de [linha de comando do Elastic Beanstalk](eb-cli3.md) (EB CLI easy-to-use) fornece comandos para criar, configurar e implantar aplicativos nos ambientes do Elastic Beanstalk a partir da linha de comando.
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 HTTPS](configuring-https.md) para conexões seguras.