;
};
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 le login à votre application"
}, {
id: "add-logout-to-your-application",
title: "Ajouter le logout à votre application"
}, {
id: "show-user-profile-information",
title: "Afficher les renseignements du profil utilisateur"
}];
Pour utiliser les services Auth0, vous devez d’abord avoir une application configurée dans l’Auth0 Dashboard. L’application Auth0 est
l’endroit où vous configurerez 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 que vous souhaitez intégrer. Chaque application dans Auth0 reçoit un ID client alphanumérique unique
que le code de votre application utilisera pour effectuer des requêtes vers les API Auth0 au moyen du SDK.
Tous les paramètres que vous configurez à l’aide de ce Quickstart seront automatiquement mis à jour pour votre Application dans le [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 aussi 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 s’être connectés.
Si vous suivez notre projet d’exemple, définissez-la sur
`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 sur `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
inclure 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 la prochaine fois qu’ils visiteront votre application ou actualiseront une
page.
Si vous suivez notre projet d’exemple, définissez-la sur `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 vos gems ajoutées, installez-les avec `bundle install`.
Créez un fichier de configuration `./config/auth0.yml` pour indiquer les valeurs de votre domaine Auth0, de votre client ID et du secret de votre client, que vous trouverez dans votre Auth0 Dashboard, sous **Settings** 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) 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 callback d’authentification, l’action `logout` et les méthodes permettant de
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 callback, attribuez à la session active le hachage des informations de l’utilisateur — renvoyé sous la
forme de `request.env['omniauth.auth']`.
Pour configurer la déconnexion, supprimez tous les objets stockés dans la session en appelant la méthode `reset_session`
dans l’action `logout`. Redirigez ensuite vers l’endpoint de déconnexion d’Auth0. Pour en savoir plus sur
`reset_session`, consultez la [documentation Ruby on Rails ActionController](http://api.rubyonrails.org/classes/ActionController/Base.html#M000668).
Ajoutez ces routes à votre fichier `./config/routes.rb`.
Ces routes doivent être définies pour que Rails sache comment diriger 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 se connecter à votre application en accédant au point de terminaison `/auth/auth0`.
Pour [empêcher 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’on clique dessus. Notez que l’utilisateur est redirigé vers Auth0 pour se connecter, puis retourné à 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 endpoint de logout d’Auth0.
Pour tester cela après l’étape précédente, vous devrez peut-être effacer votre session, puis rediriger l’utilisateur
vers le endpoint de logout d’Auth0.
```ruby lines theme={null}
<%= button_to 'Logout', 'auth/logout', method: :get %>
```
##### Vérification
Ajoutez à votre application un bouton qui redirige l’utilisateur vers le point de terminaison `/auth/logout` lorsqu’on clique dessus. Vérifiez que vous êtes redirigé vers Auth0, puis presque immédiatement de retour dans 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 à des 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 actuel de l’utilisateur.
Une fois que vous avez un Concern, incluez-le dans tout contrôleur qui nécessite qu’un utilisateur soit connecté. Vous pouvez ensuite accéder à l’utilisateur depuis 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 renseignements 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 le login, le logout et les renseignements du profil utilisateur fonctionnels dans votre application.
Ceci conclut notre tutoriel de démarrage rapide, 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) - Découvrez comment configurer et gérer votre tenant Auth0 ainsi que vos applications
* [omniauth-auth0 SDK](https://github.com/auth0/omniauth-auth0) - Explorez 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 le 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 le 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 le 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 le 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 le 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
```
Créez un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre tenant.