Como Configurar a Autenticação de Usuário com o 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 ter que fazer tudo sozinho. O Devise oferece muitos recursos úteis, como o manuseio de sessões de usuário e o suporte à autenticação de terceiros com OAuth usando o gem OmniAuth. O Devise também vem com módulos integrados para funcionalidades como redefinição de senhas esquecidas, rastreamento de contagem e timestamps de login, definição de tempos limite, bloqueio de contas, etc.

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 do 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 concluir 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. Algumas funcionalidades do Rails, como o Pipeline de Ativos, dependem de um Tempo de Execução JavaScript. O Node.js fornece essa funcionalidade. Para o 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 o 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 on Containers, ou você pode usar os Guias Oficiais do Rails.

Passo 1 — Criando uma Nova Aplicação Rails

Neste passo, você irá criar uma nova aplicação Rails e executá-la localmente em sua máquina. Utilize 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 diversos arquivos e pastas gerados. Um deles é o Gemfile, que contém as dependências do projeto. Você irá configurar o Gemfile para usar o Devise no Passo 3 — Instalando e Configurando o Devise.

Você pode abrir este diretório no seu editor de texto favorito ou navegar até ele usando o terminal:

cd blog

Para iniciar a aplicação 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 caso você não tenha fornecido um número de porta alternativo.

Agora você inicializou uma nova aplicação Rails, à qual adicionará autenticação de usuário em um próximo passo. No próximo passo, 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 pela aplicação de exemplo assim que você adicionar o Devise. Após criar uma nova página de destino, você adicionará links para o usuário se inscrever e entrar 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 que o Rails fornece por sua própria página de destino. Uma página de destino personalizada facilitará a exibição de links para o usuário se inscrever e entrar na URL raiz da aplicação. Você adicionará links para entrar e inscrever-se em passos 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 irá lidar com as solicitações para o caminho raiz — neste caso, a rota será http://localhost:3000, que é a porta padrão para aplicativos Rails. As solicitações para 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 específico do Rails.

Então, 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 mudanças na URL raiz, abra http://localhost:3000 em seu navegador (ou atualize a página se ela já estiver aberta). A página inicial 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 inicial, você adicionará autenticação de usuário com a gema Devise.

Passo 3 — Instalando e Configurando o Devise

Neste passo, você irá instalar e configurar o Devise em sua aplicação Rails para que você possa utilizar os métodos e ajudantes que vêm com a gema. Você utilizará o método user_signed_in? para verificar as informações da sessão de qualquer usuário logado armazenadas nos cookies do navegador. Você também usará o ajudante current_user para obter os detalhes da conta que está atualmente logada. Ambos os métodos estão integrados ao Devise e você pode utilizá-los diretamente em sua aplicação sem precisar escrever código extra. Você pode saber mais sobre esses ajudantes 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á contém 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 no último passo pressionando CTRL+C no terminal onde ele está sendo executado.

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

# ...

# Reduz os tempos de inicialização por meio de caching; 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
  # Consulte 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ê irá instalar a nova gem adicionada executando o comando bundle install no terminal. A partir do diretório do seu projeto (blog), execute o seguinte comando:

bundle install

Este comando irá instalar a gem Devise no seu projeto, 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 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 localidades i18n para o Devise. O arquivo inicializador, explicado detalhadamente abaixo, é usado para configurar o Devise quando você inicia o aplicativo. i18n significa 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, como este:

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 flash para notice e alert mais tarde neste passo.

Você terminou de instalar o Devise. Em seguida, será necessário 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ê iniciar sua aplicação Rails, o Rails carregará todas as gems e plugins e, em seguida, carregará 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 a 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 de undefined method user_url.

Salve e feche o arquivo.

Em seguida, você também vai adicionar as mensagens flash de aviso e alerta que foram destacadas nas instruções impressas anteriormente. As tags alert e notice são onde as mensagens como “Senha incorreta” e outras 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 seu frontend), mas para este tutorial, você completará a configuração mínima do Devise.

Abra o arquivo app/views/layouts/application.html.erb para edição. Adicione as tags para as mensagens "notice" e "alert" 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 <%= yield %> bloco será substituído pelo conteúdo de seus arquivos de visualização. Em seu arquivo de visualização, você tinha apenas a tag p. Esta tag de yield será substituída por esse conteúdo.

Salve e feche seu arquivo.

Nesta etapa, você instalou e configurou o Devise em seu projeto. Na próxima etapa, 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 o 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 cadastrar, você precisará criar um novo registro na tabela users no banco de dados. Com o modelo de usuário, você pode manipular esses registros de banco de dados a partir de sua visualização frontend.

Nesta etapa, você irá 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 de 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 realizar 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 lhe dá 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 a seguir será impressa 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 por 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

      ## Memorável
      t.datetime :remember_created_at

      ## Rastreável
      # t.integer  :contagem_de_login, default: 0, null: false
      # t.datetime :ultima_autenticacao_em, default: -> { 'CURRENT_TIMESTAMP' }
      # t.datetime :ultima_autenticacao_anterior_em
      # t.string   :ip_atual_autenticacao
      # t.string   :ip_ultima_autenticacao

      ## Confirmável
      # t.string   :token_confirmacao
      # t.datetime :confirmado_em
      # t.datetime :enviado_confirmacao_em
      # t.string   :email_nao_confirmado # Somente se estiver usando reconfirmável

O Devise inclui muitas opções úteis, como campos para o token de redefinição de senha e o momento do envio do último token, e assim por diante. Há 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.

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

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

class User < ApplicationRecord
# Inclua 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: Usuários podem autenticar-se com um campo de login e senha. A senha criptografada será armazenada no seu banco de dados.
• registerable: Usuários podem se registrar e editar ou excluir suas contas.
• recoverable: Usuários podem redefinir sua senha e recuperar suas contas se esquecerem suas credenciais.
• rememberable: Este módulo lembra as sessões de um usuário salvando as informações em um cookie do navegador.
• validatable: Este módulo fornece validações para os campos de e-mail e senha do usuário. (Por exemplo, sua aplicação pede que a senha tenha pelo menos seis caracteres, mesmo que você não tenha definido nenhuma validação personalizada no 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 fornecidos pelo Devise no repositório do Devise no GitHub.

Você não precisa fazer nenhuma alteração, então feche o arquivo do 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 estã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 no seu arquivo de rotas. Estas são as rotas para ações como login, cadastro, redefinir senha, 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 irá fazer 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 carimbos de data/hora em seus nomes.

A saída, como a seguinte, será exibida 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) =======================

Depois que a migração for executada, seu banco de dados estará 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 do usuário funcione.

Vá para http://localhost:3000/users/sign_up no seu navegador, onde você encontrará um formulário de registro para criar uma conta inserindo um email e senha. (No próximo passo, você adicionará botões para se registrar e fazer login 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.

Uma vez que você se cadastra, você será redirecionado para a página raiz, que exibe Olá DigitalOcean! bem como uma mensagem dizendo que você se cadastrou com sucesso, assim:

Esta notificação de sucesso no cadastro é renderizada na tag <p class="notice"><%= notice %></p> que você adicionou no arquivo application.html.erb.

Neste ponto, você configurou a autenticação de usuário com o Devise em seu projeto e se cadastrou 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 esta experiência de cadastro de usuário.

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

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

Você tem todas as funcionalidades configuradas em seu projeto, mas ainda precisa conectar as páginas criadas pelo Devise com sua página inicial. Na etapa anterior, você visitou manualmente a página /users/sign_up para fazer login. Nesta etapa, 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 fazer login ou sair da aplicação com base em seu status.

Isso será feito com a ajuda de alguns métodos auxiliares do Devise. O Devise gem vem com muitos métodos auxiliares que você pode usar sem precisar implementar tudo por conta própria. 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á seu e-mail 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 eles estiverem logados. Para mais detalhes sobre este método auxiliar, você pode conferir 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 autenticado na aplicação. Por exemplo, se você fizer login 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 auxiliares de URL de rota executando bundle exec rails routes, como mencionado em um passo anterior.)

Salve e feche o arquivo.

Atualize sua página no navegador para revisar as alterações.

Se você ainda não tentou se inscrever para o seu aplicativo, você pode visitar a rota /users/sign_in clicando no botão Entrar em sua página. A partir daqui, você pode prosseguir para criar uma nova conta clicando no link Registrar-se na parte inferior. Insira um e-mail 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 e-mail do usuário atualmente conectado, 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 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á conectado ou não.

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