Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
;
};
export const sections = [{
id: "configuration-d-auth0",
title: "Configuration d’Auth0"
}, {
id: "ajouter-des-dépendances",
title: "Ajouter des dépendances"
}, {
id: "configuration-de-la-trousse-sdk",
title: "Configuration de la trousse SDK"
}, {
id: "configurer-l-intergiciel-omniauth",
title: "Configurer l’intergiciel OmniAuth"
}, {
id: "ajouter-un-contrôleur-auth0",
title: "Ajouter un contrôleur Auth0"
}, {
id: "configurer-les-routes",
title: "Configurer les routes"
}, {
id: "ajouter-une-fonctionnalité-de-connexion-à-votre-application",
title: "Ajouter une fonctionnalité de connexion à votre application"
}, {
id: "ajoutez-une-fonctionnalité-de-déconnexion-à-votre-application",
title: "Ajoutez une fonctionnalité de déconnexion à votre application"
}, {
id: "afficher-les-informations-du-profil-utilisateur",
title: "Afficher les informations du profil utilisateur"
}];
Pour utiliser les services Auth0, vous devez avoir une application installée dans Auth0 Dashboard. L’application Auth0 est l’endroit où vous allez configurer le fonctionnement de l’authentification pour le projet que vous développez.
### Configurer une application
Utilisez le sélecteur interactif pour créer une nouvelle application Auth0 ou sélectionner une application existante qui représente le projet avec lequel vous souhaitez effectuer l’intégration. Dans Auth0, il est attribué à chaque application un identifiant client unique alphanumérique que votre code d’application utilisera pour appeler les API Auth0 via la trousse SDK.
Tous les paramètres que vous configurez à l’aide de ce guide rapide seront automatiquement mis à jour pour votre application dans le [Dashboard](https://manage.auth0.com/#/), qui est l’endroit où vous pourrez gérer vos applications à l’avenir.
Si vous préférez explorer une configuration complète, consultez plutôt un exemple d’application.
### Configurer les URL de rappel
Une URL de rappel est une URL intégrée dans votre application vers laquelle vous souhaitez qu’Auth0 redirige les utilisateurs après leur authentification. Si elle n’est pas définie, les utilisateurs ne seront pas redirigés vers votre application après s’être connectés.
Si vous suivez notre exemple de projet, définissez cette URL comme suit : `http://localhost:3000/auth/auth0/callback`.
### Configuration des URL de déconnexion
Une URL de déconnexion est une URL intégrée dans votre application vers laquelle vous souhaitez qu’Auth0 redirige les utilisateurs après leur déconnexion. Si elle n’est pas définie, les utilisateurs ne pourront pas se déconnecter de votre application et recevront un message d’erreur.
Si vous suivez notre exemple de projet, définissez cette URL comme suit : `http://localhost:3000`.
### Configurer les origines Web autorisées
Une origine Web autorisée est une URL que vous souhaitez autoriser à accéder à votre flux d’authentification. Elle doit contenir l’URL de votre projet. Si elle n’est pas configurée adéquatement, votre projet ne pourra pas actualiser silencieusement les jetons d’authentification, ce qui entraînera la déconnexion de vos utilisateurs lorsque prochainement ils visiteront votre application ou lors de l’actualisation d’une page.
Si vous suivez notre exemple de projet, définissez cette URL comme suit : `http://localhost:3000`.
Utilisez `omniauth-auth0`, une [stratégie OmniAuth](https://github.com/intridea/omniauth#omniauth-standardized-multi-provider-authentication) personnalisée, pour gérer le flux d’authentification.
Ajoutez les dépendances suivantes à votre `Gemfile` :
```
gem 'omniauth-auth0', '~> 3.0'
gem 'omniauth-rails_csrf_protection', '~> 1.0' # prevents forged authentication requests
```
Une fois vos gems ajoutés, installez-les avec la commande `bundle install`.
Créez un fichier de configuration `./config/auth0.yml` pour préciser votre domaine Auth0, votre identifiant client et vos valeurs de secret client situées dans votre Auth0 Dashboard sous les **paramètres** de l’application.
Créez le fichier d’initialisation suivant `./config/initializers/auth0.rb` et [configurez](https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#send-additional-authentication-parameters) l’intergiciel **OmniAuth** avec le fichier de configuration que vous avez créé à l’étape précédente.
Assurez-vous que `callback_path` correspond à la valeur donnée dans le paramètre des URL de rappel autorisées de votre application Auth0.
Créez un contrôleur Auth0 pour gérer le rappel d’authentification, l’action `logout` et les méthodes pour créer l’URL de déconnexion.
Exécutez la commande `rails generate controller auth0 callback failure logout --skip-assets --skip-helper --skip-routes --skip-template-engine`.
Dans la méthode de rappel, assignez le hachage des informations utilisateur, renvoyé en tant que `request.env[’omniauth.auth’]` à la session active.
Pour configurer la déconnexion, effacez tous les objets stockés dans la session en appelant la méthode `reset_session` dans l’action `logout`. Ensuite, redirigez vers le point de terminaison de déconnexion Auth0. Pour en savoir plus sur `reset_session`, consultez [Documentation relative au ActionController Ruby on Rails](http://api.rubyonrails.org/classes/ActionController/Base.html#M000668).
Ajoutez ces routes à votre fichier `./config/routes.rb`.
Les routes doivent être en place afin que Rails sache comment diriger les différentes URL de rappel Auth0 vers le contrôleur Auth0 que vous avez créé à l’étape précédente.
##### Point de contrôle
Exécutez votre application pour vérifier qu’elle fonctionne toujours comme prévu et que vous ne recevez aucun message d’erreur lié à Auth0.
Un utilisateur peut maintenant se connecter à votre application en visitant le point de terminaison `/auth/auth0`.
Pour [prévenir les requêtes d’authentification falsifiées](https://github.com/cookpad/omniauth-rails_csrf_protection), utilisez les méthodes d’assistance `link\_to` ou `button\_to` avec la méthode `:post`.
```html theme={null}
<%= button_to 'Login', '/auth/auth0', method: :post %>
```
##### Point de contrôle
Ajoutez un bouton à votre application qui redirige l’utilisateur vers le point de terminaison `/auth/auth0` lorsqu’il est sélectionné. Observez si vous êtes redirigé vers Auth0 pour vous connecter, puis renvoyé vers votre application après une authentification réussie.
Maintenant que vous pouvez vous connecter à votre application Rails, vous avez besoin d’un moyen de vous déconnecter. Déconnectez un utilisateur en le redirigeant vers l’action `auth/logout` qui le redirige vers le point de terminaison de déconnexion d’Auth0.
Pour tester cela après l’étape précédente, vous devez peut-être effacer votre session, puis rediriger l’utilisateur vers le point de terminaison de déconnexion d’Auth0.
```html theme={null}
<%= button_to 'Logout', 'auth/logout', method: :get %>
```
##### Point de contrôle
Ajoutez un bouton à votre application qui redirige l’utilisateur vers le point de terminaison `/auth/logout` lorsqu’il est sélectionné. Vérifiez que vous êtes redirigé vers Auth0, puis renvoyé rapidement vers votre application, et que vous n’êtes plus connecté.
Pour afficher le profil utilisateur, votre application doit fournir une route protégée. Vous pouvez utiliser une [préoccupation](https://guides.rubyonrails.org/getting_started.html#using-concerns) pour contrôler l’accès aux routes qui peuvent être partagées entre plusieurs contrôleurs. La préoccupation devrait rediriger automatiquement vers Auth0 lorsque l’utilisateur n’est pas authentifié. Au cas contraire, la préoccupation devrait renvoyer le profil utilisateur actuel.
Une fois que vous avez une préoccupation, incluez-la dans tout contrôleur qui nécessite un utilisateur connecté. Vous pouvez ensuite accéder à l’utilisateur à partir de la session `session[:userinfo]` comme dans l’exemple suivant :
```
class DashboardController < ApplicationController
include Secured
def show
@user = session[:userinfo]
end
end
```
Une fois que l’utilisateur a chargé la session, utilisez-la pour afficher des informations dans votre système frontal :
```html theme={null}
Normalized User Profile:<%= JSON.pretty_generate(@user[:info])%>
Full User Profile:<%= JSON.pretty_generate(@user[:extra][:raw_info])%>
```
##### Point de contrôle
Ajoutez le concern `Secured` à votre application, puis incluez-le dans le contrôleur qui nécessite un utilisateur authentifié pour y accéder. Vérifiez qu’un utilisateur authentifié a accès aux actions de ce contrôleur et que les utilisateurs non authentifiés sont redirigés vers Auth0 pour l’authentification.
## Étapes suivantes
Beau travail! Si vous en êtes arrivé là, vous devriez avoir la connexion, la déconnexion et les informations de profil utilisateur actives dans votre application.
Cela conclut notre tutoriel de démarrage rapide, mais il y a tellement plus à explorer. Pour en savoir plus sur ce que vous pouvez faire avec Auth0, consultez :
* [Auth0 Dashboard](https://manage.auth0.com/#) : apprenez à configurer et gérer votre locataire et vos applications Auth0
* [Trousse SDK omniauth-auth0](https://github.com/auth0/omniauth-auth0) : explorez en détail la trousse SDK utilisée dans ce tutoriel
* [Auth0 Marketplace](https://marketplace.auth0.com/) : découvrez des intégrations que vous pouvez activer pour étendre les fonctionnalités d’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 stores the informatin returned from
# Auth0 and the IdP in request.env['omniauth.auth'].
# In this code, you will pull the raw_info supplied
# from the id_token and assign it to the session.
# Refer to https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# for complete information on 'omniauth.auth' contents.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirect to the URL you want after successful auth
redirect_to '/dashboard'
end
def failure
# Handles failed authentication
@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 stores the informatin returned from
# Auth0 and the IdP in request.env['omniauth.auth'].
# In this code, you will pull the raw_info supplied
# from the id_token and assign it to the session.
# Refer to https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# for complete information on 'omniauth.auth' contents.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirect to the URL you want after successful auth
redirect_to '/dashboard'
end
def failure
# Handles failed authentication
@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 stores the informatin returned from
# Auth0 and the IdP in request.env['omniauth.auth'].
# In this code, you will pull the raw_info supplied
# from the id_token and assign it to the session.
# Refer to https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# for complete information on 'omniauth.auth' contents.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirect to the URL you want after successful auth
redirect_to '/dashboard'
end
def failure
# Handles failed authentication
@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 stores the informatin returned from
# Auth0 and the IdP in request.env['omniauth.auth'].
# In this code, you will pull the raw_info supplied
# from the id_token and assign it to the session.
# Refer to https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# for complete information on 'omniauth.auth' contents.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirect to the URL you want after successful auth
redirect_to '/dashboard'
end
def failure
# Handles failed authentication
@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 stores the informatin returned from
# Auth0 and the IdP in request.env['omniauth.auth'].
# In this code, you will pull the raw_info supplied
# from the id_token and assign it to the session.
# Refer to https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# for complete information on 'omniauth.auth' contents.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirect to the URL you want after successful auth
redirect_to '/dashboard'
end
def failure
# Handles failed authentication
@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
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.