L'autorisation est importante lors de la création d'applications, car elle détermine les actions et les ressources auxquelles un utilisateur est autorisé à accéder après son authentification.
Dans cet article, nous verrons comment implémenter l'autorisation à l'aide de permit.io. Pour le démontrer, nous allons créer une application de librairie simple en utilisant Golang et HTMX (je suis un grand fan).
Pour suivre ce tutoriel, les prérequis suivants doivent être remplis :
Tous les utilisateurs (administrateurs inclus) peuvent lire des livres. Les administrateurs peuvent également ajouter, supprimer et mettre à jour des livres. Les utilisateurs standard sont limités à la lecture de livres.
Ce tutoriel vous guidera dans la mise en place d'une application de librairie avec une autorisation de base. Nous mettrons en œuvre :
Logique d'autorisation : Définissez les rôles (administrateur et utilisateur standard) à l'aide de Permit.io pour restreindre ou accorder l'accès à différentes ressources.
Base de données : Configurez une base de données PostgreSQL pour stocker les données des livres et des utilisateurs.
Gestionnaires : Implémentez des itinéraires pour afficher, ajouter, mettre à jour et supprimer des livres avec des contrôles de contrôle d'accès.
Frontend : Utilisez HTMX pour charger les données du livre de manière dynamique.
Dans la mise en place du projet, nous commencerons par configurer permit.io. Accédez à l'espace de travail de votre tableau de bord et créez un nouveau projet. Je donnerai au mien le nom de la librairie.
Cela créera deux environnements : un environnement de développement et un environnement de production.
Puisque nous travaillons localement, nous utiliserons l’environnement de développement. Cliquez sur Ouvrir le tableau de bord dans l'environnement de développement puis sur Créer une politique. Il vous sera d’abord demandé de créer une nouvelle ressource. Cliquez sur créer une ressource. Donnez-lui un nom et indiquez les actions. Pour ce projet, je nommerai mes livres, et l'action sera de créer, mettre à jour, supprimer et afficher.
Ensuite, accédez à la section de l'éditeur de stratégie. Par défaut, vous devriez voir un rôle d'administrateur déjà créé. Il vous suffit de cocher l'action d'affichage que nous avons ajoutée, car elle n'est pas reconnue par défaut. Vous avez besoin d'un autre rôle. Ce sera destiné aux utilisateurs ayant uniquement l'autorisation de lire.
Cliquez sur Créer puis sur Rôle et donnez-lui le nom d'utilisateur. Une fois créé, vous devriez le voir dans l'éditeur de stratégie et cocher la vue dans le rôle d'utilisateur que vous venez de créer comme ceci :
La prochaine étape est d'enregistrer les utilisateurs qui seraient autorisés par permit.io. Revenez à votre menu d'accueil via le menu de la barre latérale, vous devriez toujours avoir quelque chose comme ceci :
Cliquez sur Ajouter des utilisateurs puis ajoutez, puis ajoutez un utilisateur. Remplissez les détails qui correspondront à vos utilisateurs dans la base de données.
Une fois cela fait, revenez à votre projet. Dans le projet Développement Pour l'environnement de la librairie, cliquez sur l'icône à 3 points. Vous verrez une option pour copier la clé API. Copiez-le et enregistrez-le quelque part, car vous en aurez besoin pour le projet.
Créez une base de données PostgreSQL appelée librairie. Vous devrez dresser deux tables :
CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL );
Allez-y et remplissez-le, mais faites en sorte que chaque utilisateur ait respectivement un rôle d'administrateur et d'utilisateur, et assurez-vous qu'il correspond aux utilisateurs ajoutés sur Permit.io.
CREATE TABLE books ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title VARCHAR(255) NOT NULL, author VARCHAR(255) NOT NULL, published_at DATE, created_at TIMESTAMPTZ DEFAULT now() );
Vous n'avez pas besoin de renseigner ceci, nous le ferons dans le code.
Vous devrez installer les dépendances suivantes :
github.com/permitio/permit-golang : Fournit des outils pour gérer le contrôle d'accès basé sur les rôles (RBAC) et la gestion des autorisations avec Permit.io dans les applications Go.
github.com/google/uuid : Cela fournit des fonctions pour générer et utiliser des identifiants universellement uniques (UUID).
github.com/gorilla/mux : Aide à implémenter un routeur et un répartiteur de requêtes HTTP pour gérer les itinéraires dans une application Web.
github.com/joho/godotenv: Cela charge les variables d'environnement à partir d'un .env. fichier dans l'application, ce qui facilite la gestion des paramètres de configuration.
github.com/lib/pq : Il s'agit du pilote Postgres de Go pour communiquer avec les bases de données PostgreSQL.
golang.org/x/crypto : Implémente des algorithmes et des bibliothèques cryptographiques supplémentaires qui ne sont pas inclus dans la bibliothèque standard de Go.
Pour installer ces dépendances, vous devez initialiser un nouveau module Go. C'est le point de départ de la gestion des dépendances dans Go.
Exécutez cette commande :
CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL );
Ensuite, exécutez cette commande :
CREATE TABLE books ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title VARCHAR(255) NOT NULL, author VARCHAR(255) NOT NULL, published_at DATE, created_at TIMESTAMPTZ DEFAULT now() );
Cela installera toutes les dépendances répertoriées ci-dessus.
Pour configurer le PDP, vous devrez démarrer Docker. Une fois que vous l'avez fait, ouvrez votre terminal et exécutez cette commande :
go mod init bookstore
Après quoi vous devez exécuter le conteneur avec cette commande :
go get github.com/google/uuid \
github.com/gorilla/mux \
github.com/joho/godotenv \
github.com/lib/pq \
github.com/permitio/permit-golang \
golang.org/x/crypto
Remplacez la pièce qui dit
Pour construire l'application, voici comment sera la structure de notre projet :
docker pull permitio/pdp-v2:latest
Ajoutons d'abord notre clé API dans un fichier .env. Créez-en un, puis votre clé API d'autorisation comme ceci :
docker run -it -p 7766:7000 --env PDP_DEBUG=True --env PDP_API_KEY=<YOUR_API_KEY> permitio/pdp-v2:latest
Créez un dossier appelé config. À l’intérieur, créez un fichier appelé config.go. Ajoutez le code suivant :
Bookstore ├── config │ └── config.go │ ├── handlers │ └── handlers.go │ ├── middleware │ └── middleware.go │ ├── models │ └── models.go │ ├── templates │ ├── add.html │ ├── books.html │ ├── index.html │ ├── layout.html │ ├── login.html │ └── update.html │ ├── main.go └── .env
Il s'agit simplement de la configuration d'une configuration pour se connecter à une base de données PostgreSQL.
Ensuite, créez un dossier appelé handlers, et à l'intérieur, créez un fichier appelé handlers.go. À l'intérieur, ajoutez le code suivant :
export PERMIT_API_KEY=”your_api_key”
En plus d'importer les packages, ce que nous essayons de faire ici est de créer une structure qui contient la connexion à la base de données et permit.io. Nous fournissons également une fonction d'initialisation qui configure Permit.io avec un PDP local.
Juste après les NewHandlers, ajoutez ceci :
package config
import (
"database/sql"
"fmt"
_ "github.com/lib/pq"
)
type Config struct {
DB *sql.DB
Port string
DBConfig PostgresConfig
}
type PostgresConfig struct {
Host string
Port string
User string
Password string
DBName string
}
func NewConfig() *Config {
return &Config{
Port: "8080",
DBConfig: PostgresConfig{
Host: "localhost",
Port: "5432",
User: "bookstore_user",
Password: "your_password",
DBName: "bookstore_db",
},
}
}
func (c *Config) ConnectDB() error {
connStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
c.DBConfig.Host,
c.DBConfig.Port,
c.DBConfig.User,
c.DBConfig.Password,
c.DBConfig.DBName,
)
db, err := sql.Open("postgres", connStr)
if err != nil {
return fmt.Errorf("error opening database: %v", err)
}
if err := db.Ping(); err != nil {
return fmt.Errorf("error connecting to database: %v", err)
}
c.DB = db
return nil
}
Le LoginHandler effectue les opérations suivantes :
L'étape suivante consiste à ajouter un gestionnaire de livres pour accéder aux livres. Il utilisera également permit.io pour vérifier le rôle de l'utilisateur. Ajoutez le code suivant juste après le LoginHandler :
package handlers
import (
"bookstore/middleware"
"bookstore/models"
"context"
"database/sql"
"fmt"
"html/template"
"net/http"
"strings"
"time"
"github.com/google/uuid"
"github.com/permitio/permit-golang/pkg/config"
"github.com/permitio/permit-golang/pkg/enforcement"
permitModels "github.com/permitio/permit-golang/pkg/models"
"github.com/permitio/permit-golang/pkg/permit"
)
var tmpl = template.Must(template.ParseGlob("templates/*.html"))
func StringPtr(s string) *string {
return &s
}
type Handlers struct {
db *sql.DB
permitClient *permit.Client
}
func NewHandlers(db *sql.DB, apiKey string) *Handlers {
permitConfig := config.NewConfigBuilder(apiKey).
WithPdpUrl("http://localhost:7766").
Build()
permitClient := permit.NewPermit(permitConfig)
if permitClient == nil {
panic("Failed to initialize Permit.io client")
}
return &Handlers{
db: db,
permitClient: permitClient,
}
}
Le BookHandler effectue les opérations suivantes :
Ensuite, vous avez besoin d'un gestionnaire pour ajouter des livres. Il vérifiera également le rôle de l'utilisateur via Permit.io pour garantir que seuls les utilisateurs autorisés peuvent ajouter des livres :
CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL );
AddBookHandler effectue les opérations suivantes :
Vous avez besoin de deux gestionnaires supplémentaires, un pour la suppression et l'autre pour la mise à jour. Ajoutez ce code juste après la fonction AddBookHandler :
CREATE TABLE books ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title VARCHAR(255) NOT NULL, author VARCHAR(255) NOT NULL, published_at DATE, created_at TIMESTAMPTZ DEFAULT now() );
Le DeleteBookHandler effectue les opérations suivantes :
Juste après la fonction DeleteBookHandler, ajoutez ce qui suit :
go mod init bookstore
Le UpdateHandler effectue les opérations suivantes :
Tout au long du code, vous remarquerez que le système d'autorisation est construit autour du cadre de contrôle d'accès basé sur les rôles de Permit.io, qui fournit une gestion sophistiquée des autorisations.
Ce système permet également un contrôle précis sur les actions des utilisateurs et autorise différents niveaux d'accès pour afficher, créer, mettre à jour et supprimer des ressources. Chaque opération dans l'application est soumise à une vérification détaillée des autorisations et garantit que les utilisateurs ne peuvent effectuer que les actions pour lesquelles ils sont autorisés.
Maintenant, nous en avons fini avec les gestionnaires. Créez un dossier appelé middleware et, à l'intérieur, créez un fichier appelé middleware.go. Ajoutez le code suivant :
go get github.com/google/uuid \
github.com/gorilla/mux \
github.com/joho/godotenv \
github.com/lib/pq \
github.com/permitio/permit-golang \
golang.org/x/crypto
Ce package middleware permet de fournir un hachage et une authentification sécurisés des mots de passe, ainsi que des opérations CRUD pour la gestion des livres dans une application de librairie. Il utilise bcrypt pour hacher les mots de passe pour un stockage sécurisé et vérifie les hachages de mots de passe lors de la connexion. Cela empêche également l'exposition de données sensibles.
La fonction LoginUser authentifie les utilisateurs en comparant leur saisie avec les hachages de mot de passe stockés et récupère le profil utilisateur complet en cas de connexion réussie, à l'exclusion du hachage de mot de passe pour plus de sécurité.
De plus, les opérations CRUD vous permettent de créer, mettre à jour, récupérer et supprimer des enregistrements de livre dans la base de données, avec un contrôle d'accès pour garantir que seuls les utilisateurs autorisés peuvent modifier ou supprimer les entrées qu'ils ont créées. Le package comprend également une fonction GetUserRole pour récupérer les rôles des utilisateurs, facilitant ainsi le contrôle d'accès basé sur les rôles.
Créez un autre dossier appelé models, et à l'intérieur, créez un fichier appelé models.go. Et ajoutez ce qui suit :
CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL );
Ce package définit plusieurs modèles de données pour une application de librairie, notamment les structures User, Book et LoginRequest, ainsi qu'un type NullUUID personnalisé pour gérer les UUID nullables dans la base de données.
Presque terminé. La prochaine chose que vous devez faire est de créer les modèles pour votre projet. Vous devrez créer des modèles de connexion et d'indexation, pour ajouter des livres, afficher des livres, supprimer des livres et mettre à jour des livres.
Créez un dossier appelé modèles. C'est ici que seront vos modèles HTML.
Pour vous connecter, créez un fichier appelé login.html, et à l'intérieur, collez ceci :
CREATE TABLE books ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title VARCHAR(255) NOT NULL, author VARCHAR(255) NOT NULL, published_at DATE, created_at TIMESTAMPTZ DEFAULT now() );
Ce package principal sert de point d'entrée pour une application de librairie. Il configure la connectivité de la base de données, la configuration de l'environnement et les routes HTTP pour gérer la connexion des utilisateurs et la gestion des livres.
Dans la fonction principale, les itinéraires sont enregistrés à l'aide du routeur Gorilla Mux. La fonction handlers.NewHandlers initialise les gestionnaires avec la base de données et la clé API Permit.io. Il active des fonctionnalités telles que l'authentification des utilisateurs (/login) et la gestion des livres (/books, /add, /delete, /update). Chaque route est mappée à des méthodes HTTP spécifiques, organisant les points de terminaison pour différentes actions.
Enfin, le serveur démarre sur le port 8080, écoutant les requêtes entrantes et enregistrant toutes les erreurs qui se produisent. Cette configuration garantit une configuration structurée des points de terminaison de l'API et une gestion sécurisée des variables d'environnement.
Maintenant, c'est à peu près tout ! Démarrons notre application pour voir. le résultat. Pour démarrer le serveur, exécutez cette commande :
go mod init bookstore
Visitez http://localhost:8080/login dans votre navigateur.
Commençons par tester uniquement les autorisations de l'utilisateur_standard :
Vous verrez que l'utilisateur standard_user est limité à l'affichage des livres uniquement et ne peut pas ajouter, supprimer ou mettre à jour un livre.
Connectons-nous maintenant en utilisant l'utilisateur_admin pour voir ce qui se passe :
Vous verrez que l'administrateur a la permission de faire à peu près n'importe quoi ! Voilà à quel point Permit est solide et facile à utiliser !
Vous pouvez consulter ces ressources pour en savoir plus sur l’autorisation du permis :
Dans ce didacticiel, nous avons créé une application simple de gestion de librairie pour implémenter un contrôle d'accès basé sur les rôles à l'aide de Go, HTMX et Permit.io. L'autorisation est un aspect fondamental de la sécurité des applications, car elle garantit que les utilisateurs ne peuvent accéder qu'à ce à quoi ils sont autorisés.
La mise en œuvre d'un modèle de contrôle d'accès efficace tel que RBAC ou ABAC dans votre application sécuriserait non seulement votre application, mais améliorerait également son évolutivité et sa conformité.
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!
Quelles sont les plateformes de e-commerce ?
Qu'est-ce que le quota de disque
Les dix principaux échanges de devises numériques
Introduction à la monnaie numérique du concept Dex
Comment afficher les procédures stockées dans MySQL
Quels sont les logiciels de dessin ?
La différence entre les pages Web statiques et les pages Web dynamiques
Introduction aux composants Laravel
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
