Como configurar a autenticação do usuário com Devise em uma aplicação Rails 7

O autor selecionou Girls Who Code para receber uma doação como parte do programa Write for DOnations.

Introdução

O gem Devise é uma solução de autenticação para aplicações Ruby on Rails; ele ajuda a configurar autenticação de usuário pronta para produção em seus projetos sem a necessidade de fazer tudo sozinho. O Devise fornece muitos recursos úteis, como lidar com sessões de usuário e adicionar suporte para login de terceiros com OAuth usando o gem OmniAuth. O Devise também vem com módulos integrados para funcionalidades como redefinir senhas esquecidas, rastrear contagem e carimbos de login, definir timeouts, bloquear contas, e muito mais.

O Devise simplifica a autenticação do usuário, bastando inicializar o gem e criar um modelo User com os recursos necessários. Se você fosse construir a autenticação do usuário do zero, teria que escrever código e testes para todos os recursos desejados e lidar com todos os casos especiais no manuseio de sessões, armazenamento de cookies e manutenção da segurança dos dados. Ao usar o gem Devise, você evita fazer tudo isso sozinho e pode se concentrar na construção de seu aplicativo.

Neste tutorial, você criará uma aplicação web mínima com Rails e instalará o Devise, que permitirá aos usuários criar contas, fazer login e sair de suas contas.

Pré-requisitos

Para completar este tutorial, você precisará:

• A local development environment for Ruby on Rails. For Linux, you can follow our tutorial How To Install Ruby on Rails with rvm on Ubuntu 20.04 or use the rvm product docs for installing on Mac or Windows. You can also refer to the Ruby project docs to install Ruby directly in your system. To install the Rails gem, you can use the official Rails documentation. The Devise gem requires Ruby version 2.1.0 or greater; this tutorial was tested using Ruby version 3.0.2 and Rails version 7.0.3.
• O Node.js instalado em sua máquina. Alguns recursos do Rails, como o Asset Pipeline, dependem de um Tempo de Execução JavaScript. O Node.js fornece essa funcionalidade. Para Ubuntu, instale o Node.js usando o PPA oficial, conforme explicado na opção 2 de Como Instalar o Node.js no Ubuntu 20.04. Para Mac OS, siga nosso guia Como Instalar o Node.js e Criar um Ambiente de Desenvolvimento Local no MacOS.
• Familiaridade com Ruby e o framework Ruby on Rails. Você pode conferir os primeiros tutoriais de nossa série Rails em Contêineres, ou você pode usar os Guias Oficiais do Rails.

Passo 1 — Criando um Novo Aplicativo Rails

Neste passo, você irá criar um novo aplicativo Rails e executá-lo localmente em sua máquina. Você usará a utilidade de linha de comando rails para inicializar o projeto.

Execute o seguinte comando a partir de um terminal:

rails new blog

O comando rails new irá criar um novo projeto Rails no diretório blog, que inclui vários arquivos e pastas gerados. Um deles é o Gemfile, que contém as dependências do projeto. Você configurará o Gemfile para usar o Devise no Passo 3 — Instalando e Configurando o Devise.

Você pode abrir este diretório em seu editor de texto favorito ou navegá-lo usando o terminal:

cd blog

Para iniciar o aplicativo Rails, inicie o servidor de desenvolvimento com o comando rails server a partir do diretório do projeto:

bundle exec rails server

Este comando iniciará o servidor de desenvolvimento do Rails. Abra http://localhost:3000 em seu navegador para acessar a página de boas-vindas do Rails. O Rails utiliza a porta 3000 para executar a aplicação se você não forneceu um número de porta alternativo.

Agora você inicializou uma nova aplicação Rails, à qual adicionará autenticação de usuário em uma etapa posterior. Na próxima etapa, você substituirá a página inicial padrão que o Rails fornece por uma página de destino personalizada, o que facilitará a navegação na aplicação de exemplo depois de adicionar o Devise. Depois de criar uma nova página de destino, você adicionará links para que o usuário possa se cadastrar e fazer login na aplicação.

Passo 2 — Criando uma Página de Destino

Agora que você tem uma aplicação Rails básica, substituirá a página padrão fornecida pelo Rails por sua própria página de destino. Uma página de destino personalizada facilitará mostrar ao usuário links para se cadastrar e fazer login na URL raiz da aplicação. Você adicionará links para entrar e registrar em etapas posteriores.

Para criar sua página de destino, você precisará fazer o seguinte:

• Adicione a rota no arquivo config/routes.rb.
• Crie um HomeController que lidará com as solicitações para esta rota.
• Crie um arquivo de visualização para ser renderizado quando você acessar a rota.

Você começará adicionando o caminho raiz ao arquivo routes.rb que foi gerado quando você criou o projeto.

Usando o nano ou seu editor de texto favorito, abra o arquivo config/routes.rb que foi gerado anteriormente:

nano config/routes.rb

Adicione a linha destacada:

Rails.application.routes.draw do
  root to: "home#index" 
end

root to: define qual ação do controlador lidará com solicitações ao caminho raiz — neste caso, a rota será http://localhost:3000, que é a porta padrão para aplicativos Rails. As solicitações a esta rota serão tratadas pela ação index no controlador home. Este arquivo ainda não existe, então você criará o arquivo app/controllers/home_controller.rb em seguida.

Salve e feche o config/routes.rb. Usando o nano, pressione CTRL+X para sair, Y para salvar e ENTER para confirmar o nome do arquivo e fechar o arquivo.

Em seguida, crie o arquivo app/controllers/home_controller.rb e adicione as seguintes linhas:

class HomeController < ApplicationController
  def index
    render
  end
end

Este é um HomeController básico com um método index que faz uma coisa: renderiza o arquivo de visualização associado à ação do controlador.

Neste caso, o arquivo de visualização será o arquivo app/views/home/index.html.erb. Você precisará criar este arquivo, assim como o diretório home dentro do diretório app/views.

Salve e feche o arquivo do controlador home.

Em seguida, crie o diretório home no diretório app/views:

mkdir app/views/home/

O diretório home conterá todas as visualizações para um controlador Rails específico.

Depois, crie o arquivo app/views/home/index.html.erb e adicione as seguintes linhas:

<h1>Hello DigitalOcean!</h1>

app/views/home/index.html.erb é o arquivo de visualização que a ação index do controlador Home vai renderizar. Este é um arquivo HTML onde você pode incorporar código Ruby. Quando a rota definida para a ação específica do controlador é acionada, este arquivo de visualização é renderizado no navegador do usuário.

Salve e feche seu arquivo.

Para ver as alterações na URL raiz, abra http://localhost:3000 no seu navegador (ou atualize a página se ela já estiver aberta). A página de destino atualizada será semelhante a esta:

Você pode personalizar ainda mais esta página, se necessário, mas isso é tudo o que é necessário para este tutorial.

Agora que você tem uma aplicação Rails simples com sua própria página de destino, você adicionará autenticação de usuário com a gem Devise.

Etapa 3 — Instalação e Configuração do Devise

Nesta etapa, você irá instalar e configurar o Devise em sua aplicação Rails para que você possa utilizar os métodos e auxiliares fornecidos pela gema. Você utilizará o método user_signed_in? para verificar as informações de sessão de qualquer usuário autenticado armazenadas nos cookies do navegador. Você também utilizará o auxiliar current_user para obter os detalhes da conta que está atualmente autenticada. Ambos os métodos são integrados ao Devise e podem ser utilizados diretamente em sua aplicação sem a necessidade de escrever código adicional. Você pode aprender mais sobre esses métodos auxiliares na página do GitHub do projeto Devise.

O primeiro passo para instalar o Devise é adicionar a gema ao seu Gemfile, que contém informações sobre todas as dependências necessárias para executar seu projeto Ruby. Neste caso, ao inicializar a aplicação Rails, o Gemfile gerado já possui todas as gemas básicas necessárias para o Rails funcionar.

Mas antes de fazer alterações no seu Gemfile, pare o servidor de desenvolvimento que você iniciou na última etapa pressionando CTRL+C no terminal onde ele está sendo executado.

Em seguida, abra seu Gemfile para edição. Para adicionar a gema Devise, insira a linha destacada no final do arquivo, mas fora dos grupos development e test:

# ...

# Reduz os tempos de inicialização através de cache; necessário em config/boot.rb
gem "bootsnap", require: false

# Usa variantes do Active Storage [https://guides.rubyonrails.org/active_storage_overview.html#transforming-images]
# gem "image_processing", "~> 1.2"

gem "devise" 

group :development, :test do
  # Veja https://guides.rubyonrails.org/debugging_rails_applications.html#debugging-with-the-debug-gem
  gem "debug", platforms: %i[ mri mingw x64_mingw ]
end

# ...

Salve e feche seu arquivo.

Em seguida, você instalará a nova gem adicionada executando o comando bundle install no terminal. Do diretório do seu projeto (blog), execute o seguinte comando:

bundle install

Este comando instalará a gem Devise em seu projeto, o que permitirá que você use o comando devise com a utilidade de linha de comando rails e configure a autenticação.

Para configurar o Devise em seu projeto, execute o comando do gerador:

bundle exec rails g devise:install

A bandeira g no comando acima representa generate e é usada para invocar os geradores do Rails. Os geradores criarão arquivos que podem servir como ponto de partida. Você pode ler os guias do Rails para obter mais informações sobre os geradores do Rails.

O comando anterior irá gerar vários arquivos, incluindo o arquivo inicializador e o arquivo de localização i18n para o Devise. O arquivo inicializador, explicado detalhadamente abaixo, é usado para configurar o Devise quando você inicia o aplicativo. i18n representa internacionalização, que é um padrão para ajudá-lo a executar seu aplicativo em diferentes idiomas.

Neste ponto, algumas instruções também serão impressas no terminal, assim:

Output
===============================================================================

Depending on your application's configuration some manual setup may be required:

  1. Ensure you have defined default url options in your environments files. Here
     is an example of default_url_options appropriate for a development environment
     in config/environments/development.rb:

       config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }

     In production, :host should be set to the actual host of your application.

     * Required for all applications. *

  2. Ensure you have defined root_url to *something* in your config/routes.rb.
     For example:

       root to: "home#index"

     * Not required for API-only Applications *

  3. Ensure you have flash messages in app/views/layouts/application.html.erb.
     For example:

       <p class="notice"><%= notice %></p>
       <p class="alert"><%= alert %></p>

     * Not required for API-only Applications *

  4. You can copy Devise views (for customization) to your app by running:

       rails g devise:views

     * Not required *

===============================================================================

Embora esta configuração manual não seja necessária para este tutorial, você adicionará mensagens de aviso e alerta mais tarde nesta etapa.

Você terminou de instalar o Devise. Em seguida, você precisará configurar algumas coisas no arquivo inicializador do Devise que acabou de ser gerado.

Quando você executou o comando devise:install, você gerou config/initializers/devise.rb, que é o arquivo inicializador para o Devise. Sempre que você inicia sua aplicação Rails, o Rails carrega todos os gems e plugins, e então carrega todos os arquivos inicializadores. Você pode configurar configurações específicas para diferentes partes de sua aplicação a partir desses arquivos inicializadores. Todos esses inicializadores residem no diretório config/initializers/, e é onde o gem Devise cria seu inicializador também.

Abra config/initializers/devise.rb para edição. No arquivo, localize o bloco Devise.setup e adicione a seguinte linha destacada (pode haver outros blocos de código dentro do bloco Devise.setup, mas você pode ignorá-los):

Devise.setup do |config|
  # ...

  config.navigational_formats = ['*/*', :html, :turbo_stream]

  # ...
end

Esta linha adiciona turbo_stream como um formato de navegação. Os Turbo Streams são uma parte do Turbo, que permite enviar HTML renderizado pelo servidor e renderizar páginas sem usar muito JavaScript. Você precisa adicionar isso para que o Devise 4.8.1 funcione com o Rails 7; caso contrário, você receberá um erro undefined method user_url.

Salve e feche o arquivo.

Em seguida, você também adicionará as mensagens de alerta e aviso que foram destacadas nas instruções impressas anteriormente. As tags alert e notice são onde as mensagens como “Senha incorreta” e similares apareceriam na interface do usuário. Você sempre pode implementar mensagens de alerta personalizadas em sua aplicação (por exemplo, se estiver usando interceptadores Axios com React como frontend), mas, para este tutorial, você concluirá a configuração mínima do Devise.

Abra app/views/layouts/application.html.erb para edição. Adicione as tags para as mensagens "notice" e "alerta" dentro da tag body, logo acima de <%= yield %>:

...
<body>
  <p class="notice"><%= notice %></p> 
  <p class="alert"><%= alert %></p> 
  <%= yield %>
</body>

Quando a visualização é renderizada no navegador, o bloco <%= yield %> será substituído pelo conteúdo de seus arquivos de visualização. Em seu arquivo de visualização, você tinha apenas a tag p. Essa tag de yield será substituída por esse conteúdo.

Salve e feche seu arquivo.

Neste passo, você instalou e configurou o Devise no seu projeto. No próximo passo, você criará o modelo de usuário para sua aplicação com o Devise e configurará a autenticação do usuário.

Passo 4 — Criando o Modelo de Usuário com Devise

Agora você está pronto para gerar o modelo de usuário com o Devise, que criará o arquivo de modelo necessário e gerará uma migração que você pode executar para criar uma tabela users em sua aplicação. Sempre que alguém se inscrever, você precisará criar um novo registro na tabela users no banco de dados. Com o modelo de usuário, você pode manipular esses registros do banco de dados a partir da sua visualização frontal.

Neste passo, você gerará um modelo de usuário, inspecionará a configuração padrão e, em seguida, executará a migração para atualizar seu banco de dados.

Como o Rails é um framework modelo-visão-controlador (MVC), cada tabela de banco de dados tem uma classe associada a ela, que pode ser usada para trabalhar com os dados na tabela. Neste caso, se você criar uma tabela users, poderá usar o modelo User para fazer operações como User.first ou User.find_by_email("[email protected]"). Você pode criar este modelo fazendo uma classe normal herdada de ApplicationRecord no Rails, mas gerar um modelo de usuário com o Devise oferece muitos métodos que você pode usar para autenticação.

Para criar seu usuário do Devise, execute o seguinte comando gerador:

bundle exec rails g devise user

A saída seguinte será exibida na tela:

Output
invoke  active_record
create    db/migrate/20220908152949_devise_create_users.rb
create    app/models/user.rb
invoke    test_unit
create      test/models/user_test.rb
create      test/fixtures/users.yml
insert    app/models/user.rb
route  devise_for :users

A saída mostra que o Devise gerou vários arquivos, criou testes e adicionou rotas. O primeiro arquivo, db/migrate/20220908152949_devise_create_users.rb, é um arquivo de migração para criar a tabela users no seu banco de dados. Um arquivo de migração Rails descreve as alterações que precisam ser feitas no banco de dados. O nome de cada migração conterá um carimbo de data e hora para que o Rails saiba em que ordem fazer essas alterações.

O Devise também criou o arquivo do modelo de usuário (app/models/user.rb), juntamente com testes para o mesmo. A última linha da saída indica que uma rota foi adicionada ao arquivo config/routes.rb existente. O Devise adiciona automaticamente todas as rotas como /users/sign_up e /users/sign_out usando o auxiliar devise_for :users.

Antes de executar o arquivo de migração e criar a tabela users no banco de dados, vamos revisar esses arquivos gerados. Isso ajudará você a entender a configuração que o Devise gerou para que você saiba o que está acontecendo quando executar a migração.

Comece abrindo o arquivo de migração (db/migrate/20220908152949_devise_create_users.rb) para revisar o código padrão:

# frozen_string_literal: true

class DeviseCreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users do |t|
      ## Autenticável no Banco de Dados
      t.string :email,              null: false, default: ""
      t.string :encrypted_password, null: false, default: ""

      ## Recuperável
      t.string   :reset_password_token
      t.datetime :reset_password_sent_at

      ## Memorizável
      t.datetime :remember_created_at

      ## Rastreável
      # t.integer  :sign_in_count, default: 0, null: false
      # t.datetime :current_sign_in_at
      # t.datetime :last_sign_in_at
      # t.string   :current_sign_in_ip
      # t.string   :last_sign_in_ip

      ## Confirmável
      # t.string   :confirmation_token
      # t.datetime :confirmed_at
      # t.datetime :confirmation_sent_at
      # t.string   :unconfirmed_email # Apenas se estiver usando reconfirmável

O Devise inclui muitas opções úteis, como campos para o token de redefinição de senha e o horário do envio do último token, e assim por diante. Existem também linhas para recursos como confirmação de e-mail, bloqueio do usuário após tentativas de login malsucedidas e até mesmo rastreamento dos detalhes do login.

Dado que você não precisa fazer alterações, feche o arquivo de migração.

O Devise também gerou o arquivo de modelo User. Este estará disponível no diretório app/models/.

Abra o arquivo de modelo app/models/user.rb para revisar o código padrão:

class User < ApplicationRecord
# Inclua os módulos padrão do Devise. Outros disponíveis são:
# :confirmable, :lockable, :timeoutable, :trackable e :omniauthable
devise :database_authenticatable, :registerable,
       :recoverable, :rememberable, :validatable
end

A few options are added by Devise to configure how the user model works. The basic modules (database_authenticatable, registerable, recoverable, rememberable, and validatable) are already included. There are some additional options commented out, corresponding to the extra features you saw in the migration file. You can add these modules to the model file and configure the migration, depending on how much functionality you need in your application.

Isso é o que os módulos básicos fazem:

• database_authenticatable: Os usuários podem se autenticar com um campo de login e senha. Sua senha criptografada será armazenada no banco de dados.
• registerable: Os usuários podem se registrar e editar ou excluir suas contas.
• recoverable: Os usuários podem redefinir sua senha e recuperar suas contas se esquecerem suas credenciais.
• rememberable: Este módulo lembra as sessões do usuário salvando as informações em um cookie do navegador.
• validatable: Este módulo fornece validações para os campos de email e senha do usuário. (Por exemplo, sua aplicação solicita que a senha tenha pelo menos seis caracteres, mesmo que você não tenha definido validações personalizadas em seu modelo.)

Esses módulos básicos estão incluídos no modelo de usuário que você acabou de gerar. Você pode encontrar uma lista completa de módulos que vem com o Devise no repositório do Devise no GitHub.

Você não precisa fazer nenhuma alteração, então feche o arquivo de modelo User.

Outra atualização é que o arquivo config/routes.rb foi modificado para adicionar uma linha devise_for para users:

Rails.application.routes.draw do
  devise_for :users

  root "home#index"
end

Este é um método útil que define todas as rotas necessárias relacionadas à autenticação do usuário, como /users/sign_in, /users/sign_out e /users/password/new. O Devise cuida de tudo isso para você e até mantém o arquivo de rotas limpo. Se você quiser entender como adicionar devise_for :users automaticamente traduz para todas essas rotas, você pode verificar o código-fonte do método no repositório do GitHub do Devise.

Você não precisa fazer nenhuma alteração aqui, então feche o arquivo config/routes.rb.

Para aprender quais rotas são definidas em sua aplicação, você pode listá-las executando o seguinte comando:

bundle exec rails routes

Este comando imprime todas as rotas da aplicação e os controladores com os quais essas rotas estão sendo processadas. No caso da autenticação, todas essas rotas foram criadas pelo Devise e você não precisou adicioná-las manualmente.

A saída será longa, mas aqui está um trecho mostrando algumas das rotas:

As rotas listadas na saída são as rotas que foram adicionadas pelo Devise quando você incluiu a linha devise_for :users em seu arquivo de rotas. Estas são as rotas para ações como sign in, sign up, reset password e assim por diante.

Agora que você revisou os arquivos e configurações gerados pelo Devise, você pode executar a migração que você gerou no início deste passo com o seguinte comando:

bundle exec rails db:migrate

O comando acima fará todas as alterações em cada um dos arquivos de migração no seu banco de dados. As alterações precisam ser feitas uma após a outra, assim como estão definidas nos arquivos. O Rails precisa saber a sequência na qual as migrações devem ser executadas, por isso os arquivos são criados com timestamps em seus nomes.

A saída como a seguinte será impressa na tela:

Output
== 20220908152949 DeviseCreateUsers: migrating ================================
-- create_table(:users)
 -> 0.0040s
-- add_index(:users, :email, {:unique=>true})
 -> 0.0012s
-- add_index(:users, :reset_password_token, {:unique=>true})
 -> 0.0011s
== 20220908152949 DeviseCreateUsers: migrated (0.0074s) =======================

Uma vez que a migração foi executada, seu banco de dados está configurado. Você fez tudo o que precisa para configurar a autenticação de usuário em seu projeto.

Neste ponto, reinicie seu servidor Rails:

bundle exec rails server

O arquivo de inicialização mencionado anteriormente é carregado apenas quando o Rails está inicializando. Você precisa reiniciar o servidor para que o Rails possa carregar o novo arquivo de inicialização do Devise e configurar tudo para que a autenticação de usuário funcione.

Vá para http://localhost:3000/users/sign_up no seu navegador, onde você encontrará um formulário de inscrição para criar uma conta inserindo um email e senha. (No próximo passo, você irá adicionar botões para se inscrever e entrar na página inicial para que seja mais fácil para o leitor navegar para esta URL.)

Para testar a autenticação, insira um email de teste como [email protected] e uma senha.

Assim que você se inscrever, será redirecionado para a página raiz, que exibe Olá DigitalOcean! bem como uma mensagem dizendo que você se inscreveu com sucesso, assim:

Este aviso de sucesso de inscrição é renderizado na tag <p class="notice"><%= notice %></p> que você adicionou no arquivo application.html.erb.

Neste ponto, você configurou a autenticação do usuário com o Devise em seu projeto e se inscreveu usando uma conta de exemplo. Você configurou o Devise para atender às necessidades de sua aplicação, enquanto o Devise gerou as rotas, visualizações e controladores que facilitam essa experiência de inscrição de usuário.

Agora que você confirmou que o processo de inscrição funciona conforme o esperado, seu próximo passo é adicionar essa autenticação à página de destino que você criou no Passo 2. No próximo passo, você irá vincular a página de inscrição à página de destino para que os usuários não precisem navegar para uma URL específica para se inscrever, como você teve que fazer aqui.

Passo 5 — Vinculando a Autenticação à Página de Destino

Você tem todas as funcionalidades configuradas no seu projeto, mas ainda precisa conectar as páginas criadas pelo Devise com a sua página inicial. No passo anterior, você visitou manualmente a página /users/sign_up para fazer login. Neste passo, você irá vincular todas as páginas adicionando os links necessários à sua página inicial. Você também mostrará condicionalmente aos usuários os links para entrar ou sair da aplicação com base no status deles.

Você conseguirá isso com alguns métodos auxiliares do Devise. O gem Devise vem com muitos métodos auxiliares que você pode usar sem precisar implementar tudo sozinho. Isso torna o código mais fácil de ler e manter.

Você começará adicionando código para verificar se o usuário está logado. Se estiver, a página inicial exibirá o email deles e um link para sair da aplicação. Se o usuário não estiver logado, a página inicial exibirá um link para ir para a página de login.

Abra o arquivo app/views/home/index.html.erb para edição e adicione as linhas destacadas:

<% if user_signed_in? %> 
 <div> Welcome <%= current_user.email %> </div> 
  <%= button_to "Sign out", destroy_user_session_path, method: :delete %> 
<% else %>
  <%= button_to "Sign in", new_user_session_path %> 
<% end %>
<h1>Hello DigitalOcean!</h1>

user_signed_in? vem dos métodos auxiliares associados aos controladores do Devise. Ele verifica se o usuário está logado ou não e retorna um valor booleano true ou false. Você pode usar esse resultado para programar outras funcionalidades em seu aplicativo, como mostrar as informações da conta do usuário se estiverem logados. Para mais detalhes sobre este método auxiliar, você pode verificar o código-fonte no Repositório do GitHub do Devise.

current_user é um auxiliar do Devise que acessa os detalhes do usuário que está atualmente conectado à aplicação. Por exemplo, se você entrar com [email protected], o auxiliar current_user retornaria o modelo de usuário para [email protected]. Portanto, ao usar current_user.email, você obteria [email protected] como resultado. Ao usar o Devise, você evita ter que implementar essa lógica do zero, economizando tempo e esforço.

Por fim, com este código, você adicionou os botões Entrar e Sair à página inicial. Dependendo do resultado do método auxiliar user_signed_in?, você mostrará a opção de entrar ou sair usando os botões recém-adicionados Entrar e Sair.

Você está usando o método button_to para definir um botão que leva o usuário a uma rota específica. Você também está usando métodos auxiliares para obter essas rotas: destroy_user_session_path resolve para /users/sign_out e new_user_session_path resolve para /users/sign_in. (Você pode revisar a lista completa de ajudantes de URL de rota executando bundle exec rails routes, como mencionado em uma etapa anterior.)

Salve e feche o arquivo.

Atualize sua página no navegador para revisar as mudanças.

Se você ainda não experimentou se inscrever para o seu aplicativo, você pode visitar a rota /users/sign_in clicando no botão Entrar na sua página. A partir daqui, você pode prosseguir para criar uma nova conta clicando no link Inscrever-se na parte inferior. Insira um email de teste como [email protected] e uma senha. Depois de se inscrever, você será levado novamente para a página inicial. Agora a página inicial mostra o endereço de email do usuário atualmente logado, juntamente com um botão Sair, como mostrado aqui:

Você também receberá uma mensagem dizendo, Você se inscreveu com sucesso.

E com isso, você integrou com sucesso o gem Devise e configurou a autenticação do usuário em seu aplicativo.

Conclusão

Neste tutorial, você usou o Devise para adicionar autenticação de usuário a um aplicativo Rails. Usando os métodos auxiliares do Devise, você criou um aplicativo onde os usuários podem criar contas, se inscrever e sair.

Para entender melhor o Devise e os métodos e auxiliares adicionais, confira o arquivo README no repositório do GitHub do Devise. Como próximo passo deste tutorial, você pode tentar renderizar condicionalmente a saudação “Olá Mundo!” na página com algo como Olá nome de usuário dependendo se o usuário está logado ou não.

Você pode encontrar o código para este projeto no repositório do GitHub da Comunidade DigitalOcean.