Comment effectuer l'authentification des utilisateurs avec Flask-Login

Dans cet article, nous examinerons les différentes fonctionnalités offertes par Flask-Login et comment les utiliser pour créer une fonctionnalité de connexion utilisateur sécurisée pour votre application Web. À la fin de cet article, vous comprenez bien comment utiliser Flask-Login pour implémenter une authentification utilisateur sécurisée dans vos applications Flask.

L'authentification est une partie importante de toute application Web qui permet aux utilisateurs d'accéder aux données ou aux ressources car elle garantit que seules les bonnes personnes ont accès à des informations sensibles. Cela peut également être réalisé dans Flask à l'aide de la logine de la flacon.

FLASK-LOGIN est une extension dans Flask avec des fonctions qui gèrent la connexion et la connexion des utilisateurs et gardent une trace des utilisateurs actuels dans toute l'application. Cela facilite la mise en œuvre de l'authentification et de l'autorisation dans vos applications de fiole.

Les plats clés

• Facilité d'authentification avec la logine à troupeaux: Flask-Login simplifie la mise en œuvre de l'authentification des utilisateurs dans les applications Flask. Il fournit des fonctionnalités essentielles telles que la gestion de session utilisateur, une fonctionnalité de connexion / déconnexion facile et un rappel de chargeur d'utilisateurs pour une intégration transparente avec une base de données. Cela aide à gérer efficacement les séances des utilisateurs et à gérer les processus d'authentification.
• Gestion des mots de passe sécurisée et gestion des sessions utilisateur: nous détaillerons l'importance de la sécurité des mots de passe à l'aide de Flask-Bcrypt pour le hachage des mots de passe, et comment Flask-Login gère les séances utilisateur avec des cookies de session. Cela garantit que les informations d'identification de l'utilisateur sont stockées en toute sécurité et que les séances utilisateur sont suivies avec précision, améliorant la sécurité globale de l'application.
• Guide de mise en œuvre pratique: nous fournissons un guide complet sur la configuration et l'utilisation de Flask-Login, y compris la création de modèles d'utilisateurs, la configuration d'une base de données (SQLite), la création de vues pour l'enregistrement et la connexion des utilisateurs, et l'implémentation de la logique de déconnexion avec des routes protégées. Il fournit une approche pratique pour construire un système d'authentification utilisateur sécurisé dans une application Flask, ce qui le rend accessible même pour les nouveaux dans le développement du ballon ou des applications Web.

Pourquoi utiliser le login de flacon?

Flask-Login possède un certain nombre de fonctionnalités et de fonctions qui facilitent l'authentification de manière transparente dans les applications Flask. Voici quelques-uns des avantages de l'utilisation de la login de flacon:

• Gestion de session utilisateur. Flask-Login gère la création et la destruction des séances utilisateur. Il peut également stocker l'ID de l'utilisateur actuel dans la session afin que vous puissiez facilement vérifier si un utilisateur est connecté.
• Fonctionnalité de connexion et de déconnexion. Flask-Login offre des fonctions de connexion et de déconnexion intégrées. Ces fonctions s'occupent de tous les processus importants, tels que la création et la destruction de sessions et rediriger l'utilisateur vers la page appropriée.
• Rappel de chargeur d'utilisateurs. Flask-Login vous permet de définir un rappel de chargeur d'utilisateurs. Ce rappel est utilisé pour charger l'objet utilisateur pour la session en cours. Ceci est utile si vous utilisez une base de données pour stocker les informations utilisateur.
• Authentification et autorisation. Flask-Login facilite la mise en œuvre d'authentification et d'autorisation dans vos applications. Vous pouvez utiliser Flask-Login pour protéger des pages ou des itinéraires spécifiques et pour accorder aux utilisateurs différents niveaux d'accès à votre application.

Prérequis

Pour suivre longtemps avec cet article, vous avez besoin de ce qui suit:

• Une connaissance de la syntaxe Python et Flask
• Une connaissance de base de HTML et CSS
• Python version 3 et Flask installé

De toute évidence, vous avez également besoin d'accéder à un navigateur Web.

Pour commencer

Pour utiliser pleinement le module de connexion FLASK, nous devons faire installer des dépendances à flacon et d'autres dépendances nécessaires. Ces bibliothèques fournissent les fonctions et outils nécessaires nécessaires pour améliorer les fonctionnalités de votre application. Pour les installer, ouvrez votre invite de commande ou votre terminal et exécutez la commande PIP suivante:

pip <span>install flask-login flask_sqlalchemy flask_bcrypt</span>

Voici une ventilation de ce que chacune de ces bibliothèques est utilisée:

• FLASK-SQLALCHEMY: intègre Sqlalchemy avec Flask pour les opérations de base de données
• FLASK-BCRYPT: Ajoute du hachage bcrypt pour la sécurité des mots de passe dans Flask

Une fois l'installation terminée, il sera automatiquement téléchargé la connexion du flacon dans le répertoire que vous avez utilisé.

Remarque: Au moment de la rédaction du moment de la rédaction, il y a un léger problème à résoudre les dépendances dans la dernière version de Flask et Werkzug. Pour résoudre ce problème, vous devez forcer l'installation de la version 2.3.0 de Werkzug, car c'est la seule version connue en ce moment.

Une fois vos dépendances installées, vous devrez les initialiser avec votre application Flask:

<span>from flask_sqlalchemy import SQLAlchemy
</span>
<span>from flask_login import UserMixin, LoginManager, login_user, logout_user, login_required
</span>
<span>from flask_bcrypt import Bcrypt
</span>
<span>from flask_login import LoginManager
</span> app <span>= Flask(__name__)
</span>
login_manager <span>= LoginManager()
</span>
login_manager<span>.init_app(app)  </span>

Dans l'extrait de code ci-dessus, nous avons également initialisé l'objet LoginManager dans notre application. LoginManager est une extension de Flask-Login qui est utilisée pour configurer les configurations nécessaires pour gérer les sessions utilisateur.

Création d'un modèle utilisateur

Un modèle est une représentation de la structure de données que vous souhaitez utiliser dans votre application. Il définit comment les données sont organisées, stockées et manipulées dans le système. Les modèles sont généralement utilisés avec une base de données qui suit la structure définie au préalable. Pour notre application, nous avons les données suivantes:

• un ID unique
• un nom d'utilisateur
• un mot de passe (haché)

pip <span>install flask-login flask_sqlalchemy flask_bcrypt</span>

Vous pouvez également ajouter des propriétés supplémentaires à votre modèle d'utilisateur, comme une adresse e-mail ou une photo de profil, selon la portée de votre projet.

Création d'une base de données

Une fois que vous avez défini votre modèle d'utilisateur, vous devez créer une base de données qui stockera la structure de données que nous avons créée dans le modèle précédent.

Pour cet article, nous utiliserons une base de données SQLite. En effet, SQLite est un moteur de base de données léger et sans serveur. Cela facilite la configuration et l'utilisation, car il ne nécessite pas d'installation distincte. C'est aussi un bon choix pour les applications de petite à moyenne taille.

Voici une ventilation des étapes d'utilisation d'une base de données SQLite dans notre application:

1. Pour utiliser la base de données SQLite, vous devez définir un URI dans votre configuration d'application FLASK. Cela se fait généralement en haut, aux côtés d'autres configurations. Voici un extrait que vous pouvez utiliser:

   <span>from flask_sqlalchemy import SQLAlchemy
   </span>
   <span>from flask_login import UserMixin, LoginManager, login_user, logout_user, login_required
   </span>
   <span>from flask_bcrypt import Bcrypt
   </span>
   <span>from flask_login import LoginManager
   </span> app <span>= Flask(__name__)
   </span>
   login_manager <span>= LoginManager()
   </span>
   login_manager<span>.init_app(app)  </span>

   Dans cet extrait, le /// ... indique le chemin relatif de votre fichier - Site.db - qui est le nom que nous avons utilisé pour notre fichier de base de données SQLite. Ce nom peut être changé pour tout ce que vous préférez.

2. Ensuite, vous devez initialiser le Flask-Sqlalchemy Orm à l'aide de cet extrait:

   <span>class User(UserMixin):
   </span>
   <span>id = db.Column(db.Integer, primary_key=True)
   </span>username <span>= db.Column(db.String(64), unique=True)
   </span>password_hash <span>= db.Column(db.String(128))
   </span>
   <span>def __repr__(self):
   </span>  <span>return <span>f'<User <span>{self.username}</span>>'</span></span>

   SQLALCHEMY est un mappeur relationnel d'objet qui fournit un ensemble d'outils pour travailler avec des bases de données à l'aide de Python. La ligne DB = SQLALCHEMY (APP) crée une instance de la classe SQLALCHEMY et la lie à votre application Flask (app).

3. Pour créer cette base de données, nous devons initialiser la base de données, en utilisant la méthode create_all:

   app<span>.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db' # Using SQLite as the database</span>

   Ce code est généralement placé à la fin de votre script Python ou dans un script séparé dédié à l'initialisation de la base de données. Une fois que vous exécutez votre script, le fichier de base de données sera créé avec des tables correspondantes en fonction des modèles que nous avons définis précédemment.

   Dans ce cas, le code créera un fichier Site.db avec une table utilisateur s'il n'existe pas déjà. Le fichier Site.db est généralement disponible dans un dossier appelé / instance /.

   

Ensuite, nous devons créer un user_loader qui prend un ID utilisateur et renvoie l'objet utilisateur correspondant. Voici un exemple:

db <span>= SQLAlchemy(app)</span>

hachage de mot de passe

Le hachage du mot de passe est une mesure de sécurité qui stocke la représentation cryptographique du mot de passe de l'utilisateur avant d'être stocké dans une base de données. De cette façon, il devient plus difficile d'obtenir le mot de passe réel même lorsque la sécurité de l'application a été compromise.

Habituellement, le mot de passe est d'abord haché dans le processus d'enregistrement et stocké dans une base de données. Ensuite, chaque fois qu'un utilisateur se connecte, son mot de passe est à nouveau haché et comparé au mot de passe haché stocké dans la base de données. Si les deux mots de passe correspondent, l'utilisateur est authentifié et a accès à l'application.

comment hacher et vérifier les mots de passe à l'aide de flask-bcrypt

FLASK a une extension appelée Flask-Bcrypt qui aide à atteindre cette fonctionnalité. Il a deux fonctions principales: generate_password_hash () et check_password_hash ().

thegenerate_password_hash () La fonction prend le mot de passe de l'utilisateur comme un argument et renvoie un mot de passe haché. Ceci est généralement utilisé dans la logique d'enregistrement.

La fonction Check_password_hash () prend un mot de passe et un mot de passe hachée comme arguments et renvoie true si les deux mots de passe correspondent, ou faux s'ils ne correspondent pas. Ceci est appelé avant d'accorder l'accès à la vue de connexion

Création d'une vue de registre

Les vues font partie du framework Flask utilisé pour générer des données HTML, JSON ou d'autres données envoyées au navigateur de l'utilisateur. Dans cet extrait de code, nous allons créer une vue qui accepte l'entrée de l'utilisateur et ajoute les détails à la base de données:

pip <span>install flask-login flask_sqlalchemy flask_bcrypt</span>

Voici une ventilation du code:

• Dans la première ligne, nous définissons un itinéraire pour le chemin / la connexion de l'URL. Cet itinéraire accepte à la fois les demandes Get et Post. La fonction Login (), qui est associée à l'itinéraire, sera exécutée lorsqu'une demande sera faite.
• Ensuite, nous confirmons si la méthode de demande est une méthode post:

  <span>from flask_sqlalchemy import SQLAlchemy
  </span>
  <span>from flask_login import UserMixin, LoginManager, login_user, logout_user, login_required
  </span>
  <span>from flask_bcrypt import Bcrypt
  </span>
  <span>from flask_login import LoginManager
  </span> app <span>= Flask(__name__)
  </span>
  login_manager <span>= LoginManager()
  </span>
  login_manager<span>.init_app(app)  </span>

  Une fois confirmé, la fonction récupère les valeurs saisies par l'utilisateur dans le formulaire de connexion:

  <span>class User(UserMixin):
  </span>
  <span>id = db.Column(db.Integer, primary_key=True)
  </span>username <span>= db.Column(db.String(64), unique=True)
  </span>password_hash <span>= db.Column(db.String(128))
  </span>
  <span>def __repr__(self):
  </span>  <span>return <span>f'<User <span>{self.username}</span>>'</span></span>

• Il interroge ensuite la base de données pour un utilisateur avec le nom d'utilisateur fourni. Si un utilisateur avec le nom d'utilisateur fourni est trouvé et que le mot de passe correspond, le code à l'intérieur de ce bloc sera exécuté.

Création d'une vue de connexion

Dans la vue de connexion, nous créons une logique qui accepte les entrées à partir d'une page, puis vérifie si l'entrée correspond à une ligne dans la base de données:

app<span>.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db' # Using SQLite as the database</span>

Voici une ventilation du fonctionnement du code:

• dans la première ligne - @ app.Route ('/ Login', méthodes = ['Get', 'Post']): - Nous utilisons un décorateur qui définit un itinéraire pour le chemin / la connexion de l'URL . L'itinéraire accepte à la fois les demandes Get et Post. La fonction associée, Login (), sera exécutée lorsqu'une demande sera effectuée sur cette voie.
• La fonction Login () commence par vérifier si la méthode de demande est publiée:

  db <span>= SQLAlchemy(app)</span>

  Une fois, il est confirmé qu'il s'agit d'une demande de poste, il récupère les valeurs saisies par l'utilisateur dans le formulaire de connexion:

  pip <span>install flask-login flask_sqlalchemy flask_bcrypt</span>

• Il interroge ensuite la base de données pour un utilisateur avec le nom d'utilisateur fourni:

  <span>from flask_sqlalchemy import SQLAlchemy
  </span>
  <span>from flask_login import UserMixin, LoginManager, login_user, logout_user, login_required
  </span>
  <span>from flask_bcrypt import Bcrypt
  </span>
  <span>from flask_login import LoginManager
  </span> app <span>= Flask(__name__)
  </span>
  login_manager <span>= LoginManager()
  </span>
  login_manager<span>.init_app(app)  </span>

• Si le nom d'utilisateur et le mot de passe sont validés, l'utilisateur a accès à l'accès à l'aide de fonctions Login_user et rediriger de Flask-Login:

  <span>class User(UserMixin):
  </span>
  <span>id = db.Column(db.Integer, primary_key=True)
  </span>username <span>= db.Column(db.String(64), unique=True)
  </span>password_hash <span>= db.Column(db.String(128))
  </span>
  <span>def __repr__(self):
  </span>  <span>return <span>f'<User <span>{self.username}</span>>'</span></span>

• Cependant, si la méthode de demande n'est pas publiée ou si les détails sont incorrects, il rend le modèle Login.html:

  app<span>.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db' # Using SQLite as the database</span>

  Essentiellement, il vérifie si les informations d'identification entrées sont valides, enregistrent l'utilisateur et les redirige vers la page de bienvenue en cas de succès. Si la connexion est infructueuse ou si c'est une demande de GET, elle rend le modèle de connexion pour que l'utilisateur entre ses informations d'identification.

Création de la logique de déconnexion à l'aide d'une vue protégé

Dans la plupart des applications, certaines pages sont inaccessibles si l'utilisateur n'est pas connecté. Cela inclut des pages comme l'historique des transactions, les brouillons et les pages de déconnexion. Flask-Login fournit un moyen pratique de protéger ces pages / routes et de restreindre l'accès aux utilisateurs authentifiés à l'aide du décorateur Login_Required. Voici une ventilation de son fonctionnement.

Pour utiliser cette fonctionnalité, vous devez importer le décorateur Login_Required de Flask-Login:

db <span>= SQLAlchemy(app)</span>

Ensuite, vous devez ajouter le décorateur Login_Required à toute voie que vous souhaitez protéger. Par exemple, créons une page de déconnexion qui ne peut être accessible que lorsque l'utilisateur est connecté:

<span>if __name__ == '__main__':
</span>
db<span>.create_all()
</span>
app<span>.run(debug=True)</span>

Voici une ventilation de son fonctionnement:

• Tout comme dans la vue de connexion, @ app.Route ('/ Logout') définit une route pour le chemin d'accès / déconnexion d'URL.
• Ensuite, nous ajoutons un décorateur Login_Required qui garantit que l'utilisateur doit être connecté pour accéder à l'itinéraire de déconnexion. Si un utilisateur n'est pas connecté et essaie d'accéder à cette voie, il sera redirigé vers la page de connexion.
• À l'intérieur de la fonction de déconnexion, Logout_User () est appelé. Cette fonction est fournie par Flask-Login et est utilisée pour enregistrer l'utilisateur actuel.
• Après avoir enregistré l'utilisateur, la fonction les redirige vers la route de connexion en utilisant Redirect (url_for ('connexion')). ​​

Ainsi, lorsqu'un utilisateur accède à l'itinéraire / déconnexion, Flask-Login garantit qu'il est connecté (@login_required), les enregistre et les redirige vers la page de connexion. Cela permet de gérer en toute sécurité la déconnexion des utilisateurs dans votre application Flask. Le décorateur Login_Required est appliqué à l'itinéraire / protégé, indiquant que seuls les utilisateurs authentifiés peuvent y accéder. Et si un utilisateur essaie d'accéder à une page protégée sans être connectée, Flask-Login les redirigera vers la page de connexion.

Ajout de modèles

Les modèles

dans le ballon vous permettent d'utiliser des pages HTML pour définir à quoi ressemblera votre site. Pour implémenter pleinement la logique dans notre fichier app.py, nous allons créer les pages HTML illustrées ci-dessous.

L'animation ci-dessous montre comment les modèles rendent les différentes pages de notre site.

Vous pouvez voir le code complet de ce tutoriel et en savoir plus sur son implémentation dans le référentiel GitHub de cet article.

comment Flask-Login gère les sessions utilisateur avec les cookies de session utilisateur

Une session utilisateur est un système utilisé pour suivre et mettre à jour les informations de l'utilisateur pendant que l'utilisateur est connecté. Flask-Login gère ces sessions en stockant un cookie de session sur le navigateur de l'utilisateur. Le cookie de session est un petit morceau de données qui contient un identifiant unique pour la session de l'utilisateur.

Lorsqu'un utilisateur se connecte à un site Web à l'aide de Flask-Login, le serveur génère un cookie de session et l'envoie au navigateur de l'utilisateur. Le navigateur stocke le cookie de session et l'inclut dans toutes les demandes du serveur. Le serveur utilise le cookie de session pour identifier l'utilisateur et son état de session.

Par exemple, si l'utilisateur est connecté et visite une page protégée par Flask-Login, Flask-Login vérifiera le cookie de session pour voir si l'utilisateur est authentifié. Si l'utilisateur est authentifié, Flask-Login chargera les informations de profil de l'utilisateur à partir de la base de données et la mettra à la disposition de la vue. Si l'utilisateur n'est pas authentifié, Flask-Login redirigera l'utilisateur vers la page de connexion.

Lorsque l'utilisateur se déconnecte du site Web, le serveur supprime le cookie de session du navigateur de l'utilisateur, qui termine la session utilisateur.

Conclusion

FLASK propose une variété de fonctions qui abordent différents aspects de l'authentification, allant de la gestion des sessions utilisateur à l'autorisation. En utilisant ces fonctions, vous pouvez implémenter un système d'authentification robuste et sécurisé adapté aux besoins spécifiques de votre application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!