Inscrivez-vous pour obtenir un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre locataire.
;
};
export const sections = [{
id: "configure-auth0",
title: "Configurer Auth0"
}, {
id: "add-dependencies",
title: "Ajouter des dépendances"
}, {
id: "configure-the-sdk",
title: "Configurer le SDK"
}, {
id: "configure-the-omniauth-middleware",
title: "Configurer le middleware OmniAuth"
}, {
id: "add-an-auth0-controller",
title: "Ajouter un contrôleur Auth0"
}, {
id: "configure-routes",
title: "Configurer les routes"
}, {
id: "add-login-to-your-application",
title: "Ajouter la fonctionnalité de connexion à votre application"
}, {
id: "add-logout-to-your-application",
title: "Ajouter la fonctionnalité de déconnexion à votre application"
}, {
id: "show-user-profile-information",
title: "Afficher les informations du profil de l’utilisateur"
}];
Pour utiliser les services Auth0, vous devez d’abord configurer une application dans l’Auth0 Dashboard. L’application Auth0 est
l’endroit où vous définirez le mode de 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 correspondant
au projet que vous souhaitez intégrer. Chaque application dans Auth0 se voit attribuer un ID client alphanumérique unique
que le code de votre application utilisera pour appeler les API Auth0 au moyen du SDK.
Tous les paramètres que vous configurez à l’aide de ce guide de démarrage rapide seront automatiquement mis à jour pour votre application dans l’[Auth0 Dashboard](https://manage.auth0.com/#/), où vous
pourrez gérer vos applications par la suite.
Si vous préférez explorer une configuration complète, vous pouvez plutôt consulter un exemple d’application.
### Configurer les URL de rappel
Une URL de rappel est une URL de 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 leur connexion.
Si vous suivez notre projet d’exemple, définissez-la à
`http://localhost:3000/auth/auth0/callback`.
### Configurer les URL de déconnexion
Une URL de déconnexion est une URL de 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 une erreur.
Si vous suivez notre projet d’exemple, définissez-la à `http://localhost:3000`.
### Configurer les origines Web autorisées
Une origine Web autorisée est une URL à laquelle vous souhaitez autoriser l’accès à votre flux d’authentification. Elle doit
contenir l’URL de votre projet. Si elle n’est pas correctement définie, votre projet ne pourra pas actualiser silencieusement
les jetons d’authentification; vos utilisateurs seront donc déconnectés lors de leur prochaine visite dans votre application ou lorsqu’ils actualiseront une
page.
Si vous suivez notre projet d’exemple, définissez-la à `http://localhost:3000`.
Utilisez `omniauth-auth0`, une [stratégie OmniAuth personnalisée](https://github.com/intridea/omniauth#omniauth-standardized-multi-provider-authentication), pour gérer le processus d’authentification.
Ajoutez les dépendances suivantes à votre `Gemfile` :
```gem lines theme={null}
gem 'omniauth-auth0', '~> 3.0'
gem 'omniauth-rails_csrf_protection', '~> 1.0' # empêche les requêtes d'authentification falsifiées
```
Une fois les gems ajoutés, installez-les avec `bundle install`.
Créez un fichier de configuration `./config/auth0.yml` pour indiquer les valeurs de votre domaine Auth0, de votre ID client et du secret de l’application, qui se trouvent dans l’Auth0 Dashboard, sous **Settings** de l’application.
Créez le fichier d’initialisation suivant `./config/initializers/auth0.rb`, puis [configurez](https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#send-additional-authentication-parameters) le middleware **OmniAuth** à l’aide du fichier de configuration
créé à l’étape précédente.
Assurez-vous que `callback_path` correspond à la valeur indiquée dans le paramètre "Allowed Callback URLs" de votre
application Auth0.
Créez un contrôleur Auth0 pour gérer le rappel d’authentification, l’action `logout` et les méthodes permettant de
construire 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 callback, assignez le hachage des renseignements de l’utilisateur — renvoyé sous la forme de
`request.env['omniauth.auth']` — à la session en cours.
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`. Redirigez ensuite vers le point de terminaison de déconnexion d’Auth0. Pour en savoir plus sur
`reset_session`, consultez la [documentation d’ActionController pour Ruby on Rails](http://api.rubyonrails.org/classes/ActionController/Base.html#M000668).
Ajoutez ces routes à votre fichier `./config/routes.rb`.
Ces routes doivent être configurées pour que Rails sache comment acheminer les différentes URL de rappel d’Auth0 vers le contrôleur Auth0 que vous
avez créé à l’étape précédente.
##### Vérification
Exécutez votre application pour vérifier qu’elle fonctionne toujours comme prévu et que vous ne recevez aucune erreur
liée à Auth0.
Un utilisateur peut maintenant ouvrir une session dans votre application en accédant au point de terminaison `/auth/auth0`.
Pour [éviter les requêtes d’authentification falsifiées](https://github.com/cookpad/omniauth-rails_csrf_protection), utilisez les méthodes utilitaires `link_to` ou
`button_to` avec la méthode `:post`.
```ruby lines theme={null}
<%= button_to 'Login', '/auth/auth0', method: :post %>
```
##### Point de contrôle
Ajoutez à votre application un bouton qui redirige l’utilisateur vers le point de terminaison `/auth/auth0` lorsqu’il
est sélectionné. Notez que vous êtes redirigé vers Auth0 pour vous connecter, puis de nouveau vers votre application une fois
l’authentification réussie.
Maintenant que vous pouvez vous connecter à votre application Rails, il vous faut 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 devrez peut-être vider votre session, puis rediriger l’utilisateur
vers le point de terminaison de déconnexion d’Auth0.
```ruby lines theme={null}
<%= button_to 'Logout', 'auth/logout', method: :get %>
```
##### Point de contrôle
Ajoutez à votre application un bouton 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 rapidement vers votre application, et que vous n’êtes
plus connecté.
Pour afficher le profil de l’utilisateur, votre application doit définir une route protégée. Vous pouvez utiliser un [Concern](https://guides.rubyonrails.org/getting_started.html#using-concerns) pour contrôler l’accès aux routes pouvant être partagées entre plusieurs
contrôleurs. Le concern doit rediriger automatiquement vers Auth0 lorsque l’utilisateur n’est pas authentifié. Sinon, le
concern doit renvoyer le profil de l’utilisateur courant.
Une fois que vous avez un Concern, incluez-le dans tout contrôleur qui exige qu’un utilisateur soit connecté. Vous pourrez ensuite accéder à
l’utilisateur à partir de la session `session[:userinfo]`, comme dans l’exemple suivant :
```ruby lines theme={null}
class DashboardController < ApplicationController
include Secured
def show
@user = session[:userinfo]
end
end
```
Une fois l’utilisateur récupéré depuis la session, utilisez-le pour afficher des informations dans votre interface utilisateur :
```html lines 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 exige qu’un
utilisateur soit 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 s’authentifier.
## Prochaines étapes
Excellent travail ! Si vous êtes arrivé jusqu'ici, vous devriez maintenant avoir les fonctionnalités de connexion, de déconnexion et de profil utilisateur opérationnelles dans votre application.
Ce tutoriel de démarrage rapide est maintenant terminé, mais il reste encore beaucoup à explorer. Pour en savoir plus sur ce que vous pouvez faire avec Auth0, consultez :
* [Auth0 Dashboard](https://manage.auth0.com/dashboard/us/dev-gja8kxz4ndtex3rq) - Apprenez à configurer et à gérer votre locataire Auth0 et vos applications
* [SDK omniauth-auth0](https://github.com/auth0/omniauth-auth0) - Découvrez plus en détail le SDK utilisé dans ce tutoriel
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Découvrez les 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 stocke les informations retournées par
# Auth0 et l'IdP dans request.env['omniauth.auth'].
# Dans ce code, vous extrairez le raw_info fourni
# par le id_token et l'assignerez à la session.
# Consultez https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# pour obtenir des informations complètes sur le contenu de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirige vers l'URL souhaitée après une authentification réussie
redirect_to '/dashboard'
end
def failure
# Gère les échecs d'authentification
@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 stocke les informations retournées par
# Auth0 et l'IdP dans request.env['omniauth.auth'].
# Dans ce code, vous extrairez le raw_info fourni
# par le id_token et l'assignerez à la session.
# Consultez https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# pour obtenir des informations complètes sur le contenu de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirige vers l'URL souhaitée après une authentification réussie
redirect_to '/dashboard'
end
def failure
# Gère les échecs d'authentification
@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 stocke les informations retournées par
# Auth0 et l'IdP dans request.env['omniauth.auth'].
# Dans ce code, vous extrairez le raw_info fourni
# par le id_token et l'assignerez à la session.
# Consultez https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# pour obtenir des informations complètes sur le contenu de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirige vers l'URL souhaitée après une authentification réussie
redirect_to '/dashboard'
end
def failure
# Gère les échecs d'authentification
@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 stocke les informations retournées par
# Auth0 et l'IdP dans request.env['omniauth.auth'].
# Dans ce code, vous extrairez le raw_info fourni
# par le id_token et l'assignerez à la session.
# Consultez https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# pour obtenir des informations complètes sur le contenu de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirige vers l'URL souhaitée après une authentification réussie
redirect_to '/dashboard'
end
def failure
# Gère les échecs d'authentification
@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 stocke les informations retournées par
# Auth0 et l'IdP dans request.env['omniauth.auth'].
# Dans ce code, vous extrairez le raw_info fourni
# par le id_token et l'assignerez à la session.
# Consultez https://github.com/auth0/omniauth-auth0/blob/master/EXAMPLES.md#example-of-the-resulting-authentication-hash
# pour obtenir des informations complètes sur le contenu de 'omniauth.auth'.
auth_info = request.env['omniauth.auth']
session[:userinfo] = auth_info['extra']['raw_info']
# Redirige vers l'URL souhaitée après une authentification réussie
redirect_to '/dashboard'
end
def failure
# Gère les échecs d'authentification
@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
```
Inscrivez-vous pour obtenir un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre locataire.