Regístrate para obtener una{" "}
cuenta de Auth0
{" "}
o{" "}
console.log("log in")}>
inicia sesión
{" "}
en tu cuenta existente para integrarte directamente con tu propio tenant.
;
};
export const sections = [{
id: "configure-auth0",
title: "Configurar Auth0"
}, {
id: "add-dependencies",
title: "Agregar dependencias"
}, {
id: "configure-the-sdk",
title: "Configurar el SDK"
}, {
id: "configure-the-omniauth-middleware",
title: "Configurar el middleware de OmniAuth"
}, {
id: "add-an-auth0-controller",
title: "Agregar un controlador de Auth0"
}, {
id: "configure-routes",
title: "Configurar las rutas"
}, {
id: "add-login-to-your-application",
title: "Agregar el inicio de sesión a tu aplicación"
}, {
id: "add-logout-to-your-application",
title: "Agregar el cierre de sesión a tu aplicación"
}, {
id: "show-user-profile-information",
title: "Mostrar la información del perfil del usuario"
}];
Para usar los servicios de Auth0, necesitas tener una aplicación configurada en el Auth0 Dashboard. La aplicación de Auth0 es
donde configurarás cómo quieres que funcione la autenticación para el proyecto que estás desarrollando.
### Configurar una aplicación
Usa el selector interactivo para crear una nueva aplicación de Auth0 o seleccionar una aplicación existente que represente
el proyecto que quieres integrar. A cada aplicación de Auth0 se le asigna un ID de cliente alfanumérico único
que el código de tu aplicación usará para llamar a las API de Auth0 a través del SDK.
Cualquier configuración que realices con esta guía de inicio rápido se actualizará automáticamente en tu aplicación en el [Dashboard](https://manage.auth0.com/#/), que es donde
podrás administrar tus aplicaciones más adelante.
Si prefieres ver una configuración completa, puedes consultar una aplicación de ejemplo.
### Configurar URL de callback
Una URL de callback es una URL de tu aplicación a la que quieres que Auth0 redirija a los usuarios después de que se hayan
autenticado. Si no se configura, los usuarios no volverán a tu aplicación después de iniciar sesión.
Si estás siguiendo nuestro proyecto de ejemplo, establece esto en
`http://localhost:3000/auth/auth0/callback`.
### Configurar URL de cierre de sesión
Una URL de cierre de sesión es una URL de tu aplicación a la que quieres que Auth0 redirija a los usuarios después de que hayan cerrado
sesión. Si no se configura, los usuarios no podrán cerrar sesión en tu aplicación y recibirán un error.
Si estás siguiendo nuestro proyecto de ejemplo, establece esto en `http://localhost:3000`.
### Configurar orígenes web permitidos
Un origen web permitido es una URL desde la que quieres permitir el acceso a tu flujo de autenticación. Debe
contener la URL de tu proyecto. Si no se configura correctamente, tu proyecto no podrá renovar silenciosamente
los tokens de autenticación, por lo que tus usuarios cerrarán sesión la próxima vez que visiten tu aplicación o actualicen la
página.
Si estás siguiendo nuestro proyecto de ejemplo, establece esto en `http://localhost:3000`.
Usa `omniauth-auth0`, una [estrategia personalizada de OmniAuth](https://github.com/intridea/omniauth#omniauth-standardized-multi-provider-authentication), para gestionar el flujo de autenticación.
Agrega las siguientes dependencias a tu `Gemfile`:
```gem lines theme={null}
gem 'omniauth-auth0', '~> 3.0'
gem 'omniauth-rails_csrf_protection', '~> 1.0' # evita solicitudes de autenticación falsificadas
```
Una vez que hayas agregado las gemas, instálalas con `bundle install`.
Cree un archivo de configuración `./config/auth0.yml` para especificar los valores del dominio de Auth0, el ID de cliente y el secreto del cliente, que se encuentran en la **Configuración** de la aplicación en Auth0 Dashboard.
Cree el siguiente archivo de inicialización `./config/initializers/auth0.rb` y [configure](https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#send-additional-authentication-parameters) el middleware de **OmniAuth** con el archivo de configuración
que creó en el paso anterior.
Asegúrese de que `callback_path` coincida con el valor especificado en la configuración "Allowed Callback URLs" de su
aplicación de Auth0.
Cree un controlador de Auth0 para gestionar el callback de autenticación, la acción `logout` y los métodos para
construir la URL de cierre de sesión.
Ejecute el comando:
`rails generate controller auth0 callback failure logout --skip-assets --skip-helper --skip-routes --skip-template-engine`.
Dentro del método callback, asigne el hash con la información del usuario, que se devuelve como
`request.env['omniauth.auth']`, a la sesión activa.
Para configurar el cierre de sesión, elimine todos los objetos almacenados en la sesión llamando al método `reset_session`
dentro de la acción `logout`. Luego, redirija al endpoint de cierre de sesión de Auth0. Para obtener más información sobre
`reset_session`, consulte la [documentación de ActionController de Ruby on Rails](http://api.rubyonrails.org/classes/ActionController/Base.html#M000668).
Añade estas rutas al archivo `./config/routes.rb`.
Las rutas deben estar definidas para que Rails sepa cómo dirigir las distintas URL de devolución de llamada de Auth0 al controlador de Auth0 que
creaste en el paso anterior.
##### Punto de control
Ejecuta la aplicación para verificar que sigue funcionando según lo previsto y que no recibes ningún error
relacionado con Auth0.
Ahora, un usuario puede iniciar sesión en su aplicación visitando el endpoint `/auth/auth0`.
Para [evitar solicitudes de autenticación fraudulentas](https://github.com/cookpad/omniauth-rails_csrf_protection), use los métodos auxiliares `link_to` o
`button_to` con el método `:post`.
```ruby lines theme={null}
<%= button_to 'Login', '/auth/auth0', method: :post %>
```
##### Punto de control
Agregue un botón a su aplicación que redirija al usuario al endpoint `/auth/auth0` cuando
se seleccione. Observe que se le redirige a Auth0 para iniciar sesión y luego de vuelta a su aplicación
después de autenticarse correctamente.
Ahora que ya puede iniciar sesión en su aplicación Rails, necesita una
forma de cerrar sesión. Para cerrar la sesión de un usuario, rediríjalo a la acción `auth/logout`, que lo redirige
al endpoint de cierre de sesión de Auth0.
Para probar esto después del paso anterior, es posible que deba borrar la sesión y luego redirigir al usuario
al endpoint de cierre de sesión de Auth0.
```ruby lines theme={null}
<%= button_to 'Logout', 'auth/logout', method: :get %>
```
##### Punto de control
Agrega un botón a tu aplicación que redirija al usuario al endpoint `/auth/logout` cuando lo
seleccione. Verifica que se te redirige a Auth0 y luego rápidamente de vuelta a tu aplicación, y que ya no has
iniciado sesión.
Para mostrar el perfil del usuario, la aplicación debe proporcionar una ruta protegida. Puede usar un [Concern](https://guides.rubyonrails.org/getting_started.html#using-concerns) para controlar el acceso a rutas que pueden compartirse entre varios
controladores. El concern debe redirigir automáticamente a Auth0 cuando el usuario no esté autenticado. De lo contrario, el
concern debe devolver el perfil del usuario actual.
Una vez que tenga un Concern, inclúyalo en cualquier controlador que requiera que el usuario haya iniciado sesión. Luego podrá acceder al
usuario desde la sesión `session[:userinfo]`, como en el siguiente ejemplo:
```ruby lines theme={null}
class DashboardController < ApplicationController
include Secured
def show
@user = session[:userinfo]
end
end
```
Una vez que el usuario se haya cargado desde la sesión, úsalo para mostrar información en tu frontend:
```html lines theme={null}
Normalized User Profile:<%= JSON.pretty_generate(@user[:info])%>
Full User Profile:<%= JSON.pretty_generate(@user[:extra][:raw_info])%>
```
##### Punto de control
Agrega el concern `Secured` a tu aplicación y luego inclúyelo en el controlador que requiera un
usuario autenticado para acceder. Verifica que un usuario autenticado tenga acceso a las acciones dentro de ese
controlador y que los usuarios no autenticados sean redirigidos a Auth0 para autenticarse.
## Próximos pasos
¡Excelente trabajo! Si llegaste hasta aquí, ya deberías tener el inicio de sesión, el cierre de sesión y la información del perfil de usuario funcionando en tu aplicación.
Con esto concluye nuestro tutorial de inicio rápido, pero hay mucho más por explorar. Para saber más sobre lo que puedes hacer con Auth0, consulta:
* [Auth0 Dashboard](https://manage.auth0.com/dashboard/us/dev-gja8kxz4ndtex3rq) - Aprenda a configurar y administrar su inquilino de Auth0 y sus aplicaciones
* [omniauth-auth0 SDK](https://github.com/auth0/omniauth-auth0) - Explora en mayor profundidad el SDK utilizado en este tutorial
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Descubre las integraciones que puedes habilitar para ampliar la funcionalidad de Auth0
```yml config/auth0.yml lines theme={null}
development:
auth0_domain: {yourDomain}
auth0_client_id: {yourClientId}
auth0_client_secret: {yourClientSecret}
```
```ruby auth0.rb lines theme={null}
AUTH0_CONFIG = Rails.application.config_for(:auth0)
Rails.application.config.middleware.use OmniAuth::Builder do
provider(
:auth0,
AUTH0_CONFIG['auth0_client_id'],
AUTH0_CONFIG['auth0_client_secret'],
AUTH0_CONFIG['auth0_domain'],
callback_path: '/auth/auth0/callback',
authorize_params: {
scope: 'openid profile'
}
)
end
```
```ruby auth0_controller.rb lines theme={null}
class Auth0Controller < ApplicationController
def callback
# OmniAuth almacena la información devuelta por
# Auth0 y el IdP en request.env['omniauth.auth'].
# En este código, se extrae el raw_info proporcionado
# por el id_token y se asigna a la sesión.
# Consulte https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# para obtener información completa sobre el contenido de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirigir a la URL deseada tras una autenticación exitosa
redirect_to '/dashboard'
end
def failure
# Gestiona los errores de autenticación
@error_msg = request.params['message']
end
def logout
reset_session
redirect_to logout_url
end
private
AUTH0_CONFIG = Rails.application.config_for(:auth0)
def logout_url
request_params = {
returnTo: root_url,
client_id: AUTH0_CONFIG['auth0_client_id']
}
URI::HTTPS.build(host: AUTH0_CONFIG['auth0_domain'], path: '/v2/logout', query: to_query(request_params)).to_s
end
def to_query(hash)
hash.map { |k, v| "#{k}=#{CGI.escape(v)}" unless v.nil? }.reject(&:nil?).join('&')
end
end
```
```ruby routes.rb lines theme={null}
Rails.application.routes.draw do
# . .
get '/auth/auth0/callback' => 'auth0#callback'
get '/auth/failure' => 'auth0#failure'
get '/auth/logout' => 'auth0#logout'
end
```
```ruby secured.rb lines theme={null}
module Secured
extend ActiveSupport::Concern
included do
before_action :logged_in_using_omniauth?
end
def logged_in_using_omniauth?
redirect_to '/' unless session[:userinfo].present?
end
end
```
```ruby auth0.rb lines theme={null}
AUTH0_CONFIG = Rails.application.config_for(:auth0)
Rails.application.config.middleware.use OmniAuth::Builder do
provider(
:auth0,
AUTH0_CONFIG['auth0_client_id'],
AUTH0_CONFIG['auth0_client_secret'],
AUTH0_CONFIG['auth0_domain'],
callback_path: '/auth/auth0/callback',
authorize_params: {
scope: 'openid profile'
}
)
end
```
```yml config/auth0.yml lines theme={null}
development:
auth0_domain: {yourDomain}
auth0_client_id: {yourClientId}
auth0_client_secret: {yourClientSecret}
```
```ruby auth0_controller.rb lines theme={null}
class Auth0Controller < ApplicationController
def callback
# OmniAuth almacena la información devuelta por
# Auth0 y el IdP en request.env['omniauth.auth'].
# En este código, se extrae el raw_info proporcionado
# por el id_token y se asigna a la sesión.
# Consulte https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# para obtener información completa sobre el contenido de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirigir a la URL deseada tras una autenticación exitosa
redirect_to '/dashboard'
end
def failure
# Gestiona los errores de autenticación
@error_msg = request.params['message']
end
def logout
reset_session
redirect_to logout_url
end
private
AUTH0_CONFIG = Rails.application.config_for(:auth0)
def logout_url
request_params = {
returnTo: root_url,
client_id: AUTH0_CONFIG['auth0_client_id']
}
URI::HTTPS.build(host: AUTH0_CONFIG['auth0_domain'], path: '/v2/logout', query: to_query(request_params)).to_s
end
def to_query(hash)
hash.map { |k, v| "#{k}=#{CGI.escape(v)}" unless v.nil? }.reject(&:nil?).join('&')
end
end
```
```ruby routes.rb lines theme={null}
Rails.application.routes.draw do
# . .
get '/auth/auth0/callback' => 'auth0#callback'
get '/auth/failure' => 'auth0#failure'
get '/auth/logout' => 'auth0#logout'
end
```
```ruby secured.rb lines theme={null}
module Secured
extend ActiveSupport::Concern
included do
before_action :logged_in_using_omniauth?
end
def logged_in_using_omniauth?
redirect_to '/' unless session[:userinfo].present?
end
end
```
```ruby auth0_controller.rb lines theme={null}
class Auth0Controller < ApplicationController
def callback
# OmniAuth almacena la información devuelta por
# Auth0 y el IdP en request.env['omniauth.auth'].
# En este código, se extrae el raw_info proporcionado
# por el id_token y se asigna a la sesión.
# Consulte https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# para obtener información completa sobre el contenido de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirigir a la URL deseada tras una autenticación exitosa
redirect_to '/dashboard'
end
def failure
# Gestiona los errores de autenticación
@error_msg = request.params['message']
end
def logout
reset_session
redirect_to logout_url
end
private
AUTH0_CONFIG = Rails.application.config_for(:auth0)
def logout_url
request_params = {
returnTo: root_url,
client_id: AUTH0_CONFIG['auth0_client_id']
}
URI::HTTPS.build(host: AUTH0_CONFIG['auth0_domain'], path: '/v2/logout', query: to_query(request_params)).to_s
end
def to_query(hash)
hash.map { |k, v| "#{k}=#{CGI.escape(v)}" unless v.nil? }.reject(&:nil?).join('&')
end
end
```
```yml config/auth0.yml lines theme={null}
development:
auth0_domain: {yourDomain}
auth0_client_id: {yourClientId}
auth0_client_secret: {yourClientSecret}
```
```ruby auth0.rb lines theme={null}
AUTH0_CONFIG = Rails.application.config_for(:auth0)
Rails.application.config.middleware.use OmniAuth::Builder do
provider(
:auth0,
AUTH0_CONFIG['auth0_client_id'],
AUTH0_CONFIG['auth0_client_secret'],
AUTH0_CONFIG['auth0_domain'],
callback_path: '/auth/auth0/callback',
authorize_params: {
scope: 'openid profile'
}
)
end
```
```ruby routes.rb lines theme={null}
Rails.application.routes.draw do
# . .
get '/auth/auth0/callback' => 'auth0#callback'
get '/auth/failure' => 'auth0#failure'
get '/auth/logout' => 'auth0#logout'
end
```
```ruby secured.rb lines theme={null}
module Secured
extend ActiveSupport::Concern
included do
before_action :logged_in_using_omniauth?
end
def logged_in_using_omniauth?
redirect_to '/' unless session[:userinfo].present?
end
end
```
```ruby routes.rb lines theme={null}
Rails.application.routes.draw do
# . .
get '/auth/auth0/callback' => 'auth0#callback'
get '/auth/failure' => 'auth0#failure'
get '/auth/logout' => 'auth0#logout'
end
```
```yml config/auth0.yml lines theme={null}
development:
auth0_domain: {yourDomain}
auth0_client_id: {yourClientId}
auth0_client_secret: {yourClientSecret}
```
```ruby auth0.rb lines theme={null}
AUTH0_CONFIG = Rails.application.config_for(:auth0)
Rails.application.config.middleware.use OmniAuth::Builder do
provider(
:auth0,
AUTH0_CONFIG['auth0_client_id'],
AUTH0_CONFIG['auth0_client_secret'],
AUTH0_CONFIG['auth0_domain'],
callback_path: '/auth/auth0/callback',
authorize_params: {
scope: 'openid profile'
}
)
end
```
```ruby auth0_controller.rb lines theme={null}
class Auth0Controller < ApplicationController
def callback
# OmniAuth almacena la información devuelta por
# Auth0 y el IdP en request.env['omniauth.auth'].
# En este código, se extrae el raw_info proporcionado
# por el id_token y se asigna a la sesión.
# Consulte https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# para obtener información completa sobre el contenido de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirigir a la URL deseada tras una autenticación exitosa
redirect_to '/dashboard'
end
def failure
# Gestiona los errores de autenticación
@error_msg = request.params['message']
end
def logout
reset_session
redirect_to logout_url
end
private
AUTH0_CONFIG = Rails.application.config_for(:auth0)
def logout_url
request_params = {
returnTo: root_url,
client_id: AUTH0_CONFIG['auth0_client_id']
}
URI::HTTPS.build(host: AUTH0_CONFIG['auth0_domain'], path: '/v2/logout', query: to_query(request_params)).to_s
end
def to_query(hash)
hash.map { |k, v| "#{k}=#{CGI.escape(v)}" unless v.nil? }.reject(&:nil?).join('&')
end
end
```
```ruby secured.rb lines theme={null}
module Secured
extend ActiveSupport::Concern
included do
before_action :logged_in_using_omniauth?
end
def logged_in_using_omniauth?
redirect_to '/' unless session[:userinfo].present?
end
end
```
```ruby secured.rb lines theme={null}
module Secured
extend ActiveSupport::Concern
included do
before_action :logged_in_using_omniauth?
end
def logged_in_using_omniauth?
redirect_to '/' unless session[:userinfo].present?
end
end
```
```yml config/auth0.yml lines theme={null}
development:
auth0_domain: {yourDomain}
auth0_client_id: {yourClientId}
auth0_client_secret: {yourClientSecret}
```
```ruby auth0.rb lines theme={null}
AUTH0_CONFIG = Rails.application.config_for(:auth0)
Rails.application.config.middleware.use OmniAuth::Builder do
provider(
:auth0,
AUTH0_CONFIG['auth0_client_id'],
AUTH0_CONFIG['auth0_client_secret'],
AUTH0_CONFIG['auth0_domain'],
callback_path: '/auth/auth0/callback',
authorize_params: {
scope: 'openid profile'
}
)
end
```
```ruby auth0_controller.rb lines theme={null}
class Auth0Controller < ApplicationController
def callback
# OmniAuth almacena la información devuelta por
# Auth0 y el IdP en request.env['omniauth.auth'].
# En este código, se extrae el raw_info proporcionado
# por el id_token y se asigna a la sesión.
# Consulte https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# para obtener información completa sobre el contenido de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirigir a la URL deseada tras una autenticación exitosa
redirect_to '/dashboard'
end
def failure
# Gestiona los errores de autenticación
@error_msg = request.params['message']
end
def logout
reset_session
redirect_to logout_url
end
private
AUTH0_CONFIG = Rails.application.config_for(:auth0)
def logout_url
request_params = {
returnTo: root_url,
client_id: AUTH0_CONFIG['auth0_client_id']
}
URI::HTTPS.build(host: AUTH0_CONFIG['auth0_domain'], path: '/v2/logout', query: to_query(request_params)).to_s
end
def to_query(hash)
hash.map { |k, v| "#{k}=#{CGI.escape(v)}" unless v.nil? }.reject(&:nil?).join('&')
end
end
```
```ruby routes.rb lines theme={null}
Rails.application.routes.draw do
# . .
get '/auth/auth0/callback' => 'auth0#callback'
get '/auth/failure' => 'auth0#failure'
get '/auth/logout' => 'auth0#logout'
end
```
Regístrate para obtener una{" "}
cuenta de Auth0
{" "}
o{" "}
console.log("log in")}>
inicia sesión
{" "}
en tu cuenta existente para integrarte directamente con tu propio tenant.