So richten Sie die Autorisierung in einem Buchhandlungsverwaltungssystem mit Go, HTMX und Permit.io ein

Autorisierung ist beim Erstellen von Anwendungen wichtig, da sie bestimmt, auf welche Aktionen und Ressourcen ein Benutzer zugreifen darf, nachdem er sich authentifiziert hat.

In diesem Artikel werfen wir einen Blick darauf, wie Sie die Autorisierung mithilfe von Permit.io implementieren. Um es zu demonstrieren, erstellen wir eine einfache Buchladen-App mit Golang und HTMX (ich bin ein großer Fan).

Voraussetzungen

Um dieses Tutorial durcharbeiten zu können, sollten die folgenden Voraussetzungen erfüllt sein:

• Golang wurde zusammen mit einem grundlegenden Verständnis davon installiert.
• Ein Permit.io-Konto.
• Docker installiert.
• Grundlegendes Verständnis von HTML-, HTTP- und REST-APIs.
• PostgreSQL (Datenbank).
• Vertrautheit mit SQL.

Projektumfang

• Bei dieser Demonstration halten wir es einfach. Wir werden zwei Benutzertypen haben, einen Administrator und einen Standardbenutzer. Beide werden auf Permit.io registriert. Bei der Anmeldung konsultiert die Datenbank Permit.io, um die Rolle des Benutzers zu bestimmen und seine Aktionen zu autorisieren.

Alle Benutzer (einschließlich Administratoren) können Bücher lesen. Administratoren können außerdem Bücher hinzufügen, löschen und aktualisieren. Standardbenutzer können nur Bücher lesen.

Dieses Tutorial führt Sie durch die Einrichtung einer Buchladenanwendung mit Basisautorisierung. Wir werden Folgendes umsetzen:

• Autorisierungslogik: Definieren Sie Rollen (Administrator und Standardbenutzer) mithilfe von Permit.io, um den Zugriff auf verschiedene Ressourcen einzuschränken oder zu gewähren.

• Datenbank: Richten Sie eine PostgreSQL-Datenbank ein, um Buch- und Benutzerdaten zu speichern.

• Handler: Implementieren Sie Routen zum Anzeigen, Hinzufügen, Aktualisieren und Löschen von Büchern mit Zugriffskontrollprüfungen.

• Frontend: Verwenden Sie HTMX, um Buchdaten dynamisch zu laden.

Projekt-Setup

Beim Einrichten des Projekts beginnen wir mit der Einrichtung von erlauben.io. Navigieren Sie zu Ihrem Dashboard-Arbeitsbereich und erstellen Sie ein neues Projekt. Ich gebe meiner den Namen Buchhandlung.

Dadurch werden zwei Umgebungen erstellt: eine Entwicklungsumgebung und eine Produktionsumgebung.

Da wir lokal arbeiten, nutzen wir die Entwicklungsumgebung. Klicken Sie in der Entwicklungsumgebung auf Dashboard öffnen und dann auf Richtlinie erstellen. Sie werden zunächst aufgefordert, eine neue Ressource zu erstellen. Klicken Sie auf Ressource erstellen. Geben Sie ihm einen Namen und geben Sie die Aktionen an. Für dieses Projekt werde ich meine Bücher benennen und die Aktion wird Erstellen, Aktualisieren, Löschen und Anzeigen sein.

Navigieren Sie als Nächstes zum Abschnitt „Richtlinieneditor“. Standardmäßig sollte eine bereits erstellte Administratorrolle angezeigt werden. Sie müssen nur die von uns hinzugefügte Ansichtsaktion ankreuzen, da sie standardmäßig nicht erkannt wird. Du brauchst eine andere Rolle. Dies gilt nur für Benutzer mit Leseberechtigung.

Klicken Sie auf „Erstellen“ und dann auf „Rolle“ und geben Sie den Namen des Benutzers ein. Sobald Sie es erstellt haben, sollten Sie es im Richtlinieneditor und in der soeben erstellten Benutzerrolle wie folgt sehen:

Als nächstes müssen Sie die Benutzer registrieren, die von Permit.io autorisiert werden sollen. Navigieren Sie über das Seitenleistenmenü zurück zu Ihrem Home-Menü. Sie sollten immer noch Folgendes sehen:

Klicken Sie auf „Benutzer hinzufügen“ und dann auf „Hinzufügen“ und dann auf „Benutzer hinzufügen“. Geben Sie die Details ein, die Ihren Benutzern in der Datenbank entsprechen.

Sobald dies erledigt ist, navigieren Sie zurück zu Ihrem Projekt. Klicken Sie in der Entwicklungsumgebung für das Buchladenprojekt auf das Symbol mit den drei Punkten. Sie sehen eine Option zum Kopieren des API-Schlüssels. Kopieren Sie es und speichern Sie es irgendwo, da Sie es für das Projekt benötigen.

Richten Sie die Datenbank ein

Erstellen Sie eine PostgreSQL-Datenbank namens Bookstore. Sie müssen zwei Tabellen einrichten:

• Benutzertabelle: Speichert Benutzeranmeldeinformationen und -rollen:

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  username VARCHAR(255) NOT NULL,
  password_hash VARCHAR(255) NOT NULL,
  role VARCHAR(50) NOT NULL
);

Fahren Sie fort und füllen Sie dies aus, aber geben Sie jedem Benutzer die Rolle „Administrator“ bzw. „Benutzer“ und stellen Sie sicher, dass sie mit den auf Permit.io hinzugefügten Benutzern übereinstimmen.

• Büchertabelle: Speichert Buchdetails:

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()
);

Sie müssen dies nicht ausfüllen, wir machen das im Code.

Abhängigkeiten installieren

Sie müssen die folgenden Abhängigkeiten installieren:

• github.com/permitio/permit-golang: Bietet Tools für die Handhabung der rollenbasierten Zugriffskontrolle (RBAC) und Berechtigungsverwaltung mit Permit.io in Go-Anwendungen.

• github.com/google/uuid: Dies bietet Funktionen zum Generieren und Arbeiten mit Universally Unique Identifiers (UUIDs).

• github.com/gorilla/mux: Hilft bei der Implementierung eines HTTP-Anforderungsrouters und -Dispatchers für die Verarbeitung von Routen in einer Webanwendung.

• github.com/joho/godotenv: Dies lädt Umgebungsvariablen aus einer .env. Datei in die Anwendung, was die Verwaltung der Konfigurationseinstellungen erleichtert.

• github.com/lib/pq: Dies ist der Postgres-Treiber von Go für die Kommunikation mit PostgreSQL-Datenbanken.

• golang.org/x/crypto: Implementiert zusätzliche kryptografische Algorithmen und Bibliotheken, die nicht in der Standardbibliothek von Go enthalten sind.

Um diese Abhängigkeiten zu installieren, müssen Sie ein neues Go-Modul initialisieren. Dies ist der Ausgangspunkt für das Abhängigkeitsmanagement in Go.

Führen Sie diesen Befehl aus:

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  username VARCHAR(255) NOT NULL,
  password_hash VARCHAR(255) NOT NULL,
  role VARCHAR(50) NOT NULL
);

Führen Sie als Nächstes diesen Befehl aus:

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()
);

Dadurch werden alle oben aufgeführten Abhängigkeiten installiert.

Richten Sie Ihren PDP-Container (Policy Decision Point) ein

Um das PDP einzurichten, müssen Sie Docker starten. Öffnen Sie anschließend Ihr Terminal und führen Sie diesen Befehl aus:

go mod init bookstore

Danach müssen Sie den Container mit diesem Befehl ausführen:

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

Ersetzen Sie den Teil mit der Aufschrift mit Ihrem tatsächlichen API-Schlüssel. Jetzt fangen wir mit dem Bauen an.

Erstellen Sie die Anwendung

Um die Anwendung zu erstellen, sieht unsere Projektstruktur wie folgt aus:

docker pull permitio/pdp-v2:latest

Fügen wir zunächst unseren API-Schlüssel in eine .env-Datei ein. Erstellen Sie einen und dann Ihren Genehmigungs-API-Schlüssel wie folgt:

 docker run -it -p 7766:7000 --env PDP_DEBUG=True --env PDP_API_KEY=<YOUR_API_KEY> permitio/pdp-v2:latest

Datenbankverbindung konfigurieren

Erstellen Sie einen Ordner namens config. Erstellen Sie darin eine Datei mit dem Namen config.go. Fügen Sie den folgenden Code hinzu:

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

Hier richten wir lediglich eine Konfiguration ein, um eine Verbindung zu einer PostgreSQL-Datenbank herzustellen.

Erstellen Sie die Handler

Als nächstes erstellen Sie einen Ordner namens handlers und darin eine Datei namens handlers.go. Fügen Sie darin den folgenden Code hinzu:

export PERMIT_API_KEY=”your_api_key”

Abgesehen vom Importieren der Pakete versuchen wir hier, eine Struktur zu erstellen, die die Datenbankverbindung und „permit.io“ enthält. Wir stellen auch eine Initialisierungsfunktion bereit, die Permit.io mit lokalem PDP einrichtet.

Direkt nach den NewHandlers fügen Sie Folgendes hinzu:

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
}

Der LoginHandler führt Folgendes aus:

• Verarbeitet sowohl GET (Anmeldeformular anzeigen) als auch POST (Anmeldung verarbeiten).
• Authentifiziert Benutzer gegenüber der Datenbank.
• Setzt Sitzungscookies für authentifizierte Benutzer.
• Synchronisiert Benutzerdaten mit Permit.io zur Autorisierung.
• Rendert geeignete Vorlagen basierend auf dem Erfolg/Misserfolg der Anmeldung.

Der nächste Schritt besteht darin, einen Buchhandler hinzuzufügen, um auf die Bücher zuzugreifen. Außerdem wird „permit.io“ verwendet, um die Rolle des Benutzers zu überprüfen. Fügen Sie den folgenden Code direkt nach dem LoginHandler hinzu:

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,
  }
}

Der BookHandler führt Folgendes aus:

• Überprüft die Benutzerauthentifizierung über Cookies.
• Überprüft Benutzerrolle und Berechtigungen mithilfe von Permit.io.
• Ruft Bücher aus der Datenbank ab, sofern autorisiert.
• Rendert die Buchvorlage mit den abgerufenen Daten.
• Behandelt Autorisierungsfehler angemessen.

Als nächstes benötigen Sie einen Handler zum Hinzufügen von Büchern. Außerdem wird die Rolle des Benutzers über Permit.io überprüft, um sicherzustellen, dass nur autorisierte Benutzer Bücher hinzufügen können:

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  username VARCHAR(255) NOT NULL,
  password_hash VARCHAR(255) NOT NULL,
  role VARCHAR(50) NOT NULL
);

Der AddBookHandler führt Folgendes aus:

• Überprüft Benutzerberechtigungen für die Bucherstellung.
• Verarbeitet sowohl GET (Formular anzeigen) als auch POST (Buch hinzufügen).
• Validiert Eingabedaten.
• Generiert UUID für neue Bücher.
• Verwaltet die Datumsanalyse für Veröffentlichungsdaten.
• Weiterleitung zur Bücherliste nach erfolgreicher Hinzufügung.

Sie benötigen zwei weitere Handler, einen zum Löschen und einen zum Aktualisieren. Fügen Sie diesen Code direkt nach der AddBookHandler-Funktion hinzu:

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()
);

Der DeleteBookHandler führt Folgendes aus:

• Überprüft Benutzerberechtigungen zum Löschen.
• Überprüft die Buch-ID.
• Führt das Löschen der Datenbank durch.
• Behandelt Fehler und Weiterleitungen angemessen.

Fügen Sie direkt nach der Funktion „DeleteBookHandler“ Folgendes hinzu:

go mod init bookstore

Der UpdateHandler führt Folgendes aus:

• Überprüft Update-Berechtigungen.
• Verarbeitet sowohl GET (Bearbeitungsformular anzeigen) als auch POST (Buch aktualisieren).
• Ruft vorhandene Buchdaten zur Bearbeitung ab.
• Überprüft und verarbeitet Aktualisierungen.
• Verwaltet Datumsformatierung und Datenbankaktualisierungen.

Im gesamten Code werden Sie feststellen, dass das Autorisierungssystem auf dem rollenbasierten Zugriffskontroll-Framework von Permit.io basiert, das eine ausgefeilte Berechtigungsverwaltung bietet.

Dieses System ermöglicht außerdem eine differenzierte Kontrolle über Benutzeraktionen und ermöglicht verschiedene Zugriffsebenen zum Anzeigen, Erstellen, Aktualisieren und Löschen von Ressourcen. Jeder Vorgang in der Anwendung wird einer detaillierten Berechtigungsprüfung unterzogen und stellt sicher, dass Benutzer nur Aktionen ausführen können, für die sie autorisiert sind.

Erstellen Sie eine Autorisierungs-Middleware

Jetzt sind wir mit den Handlern fertig. Erstellen Sie einen Ordner mit dem Namen „middleware“ und darin eine Datei mit dem Namen „middleware.go“. Fügen Sie den folgenden Code hinzu:

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

Dieses Middleware-Paket hilft bei der Bereitstellung eines sicheren Passwort-Hashings und der Authentifizierung sowie bei CRUD-Vorgängen zum Verwalten von Büchern in einer Buchladenanwendung. Es verwendet bcrypt zum Hashen von Passwörtern zur sicheren Speicherung und überprüft Passwort-Hashes während der Anmeldung. Es verhindert auch die Offenlegung sensibler Daten.

Die LoginUser-Funktion authentifiziert Benutzer, indem sie ihre Eingaben mit gespeicherten Passwort-Hashes vergleicht und bei erfolgreicher Anmeldung das vollständige Benutzerprofil abruft, mit Ausnahme des Passwort-Hashs für zusätzliche Sicherheit.

Außerdem ermöglichen Ihnen CRUD-Vorgänge das Erstellen, Aktualisieren, Abrufen und Löschen von Buchdatensätzen in der Datenbank, mit Zugriffskontrolle, um sicherzustellen, dass nur autorisierte Benutzer von ihnen erstellte Einträge ändern oder löschen können. Das Paket enthält außerdem eine GetUserRole-Funktion zum Abrufen von Benutzerrollen und erleichtert so die rollenbasierte Zugriffskontrolle.

Erstellen Sie die Modelle

Erstellen Sie einen weiteren Ordner mit dem Namen „models“ und erstellen Sie darin eine Datei mit dem Namen „models.go“. Und fügen Sie Folgendes hinzu:

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  username VARCHAR(255) NOT NULL,
  password_hash VARCHAR(255) NOT NULL,
  role VARCHAR(50) NOT NULL
);

Dieses Paket definiert mehrere Datenmodelle für eine Buchladenanwendung, einschließlich User-, Book- und LoginRequest-Strukturen, zusammen mit einem benutzerdefinierten NullUUID-Typ für die Verarbeitung von nullbaren UUIDs in der Datenbank.

Fast fertig. Als nächstes müssen Sie die Vorlagen für Ihr Projekt erstellen. Sie müssen Vorlagen für die Anmeldung und den Index erstellen, um Bücher hinzuzufügen, Bücher anzuzeigen, Bücher zu löschen und Bücher zu aktualisieren.

Erstellen Sie die HTML-Vorlagen

Erstellen Sie einen Ordner mit dem Namen „Vorlagen“. Hier befinden sich Ihre HTML-Vorlagen.
Erstellen Sie für die Anmeldung eine Datei mit dem Namen login.html und fügen Sie darin Folgendes ein:

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()
);

Dieses Hauptpaket dient als Einstiegspunkt für eine Buchladenanwendung. Es richtet Datenbankkonnektivität, Umgebungskonfiguration und HTTP-Routen für die Benutzeranmeldung und Buchverwaltung ein.

In der Hauptfunktion werden Routen mithilfe des Gorilla Mux-Routers registriert. Die Funktion handlers.NewHandlers initialisiert Handler mit der Datenbank und dem Permit.io-API-Schlüssel. Es ermöglicht Funktionen wie Benutzerauthentifizierung (/login) und Buchverwaltung (/books, /add, /delete, /update). Jede Route ist bestimmten HTTP-Methoden zugeordnet und organisiert die Endpunkte für verschiedene Aktionen.

Schließlich startet der Server auf Port 8080, lauscht auf eingehende Anfragen und protokolliert auftretende Fehler. Dieses Setup gewährleistet eine strukturierte API-Endpunktkonfiguration und einen sicheren Umgang mit Umgebungsvariablen.

Testen Sie die Anwendung

Das ist nun alles! Starten wir unsere App, um es zu sehen. das Ergebnis. Um den Server zu starten, führen Sie diesen Befehl aus:

go mod init bookstore

Besuchen Sie http://localhost:8080/login in Ihrem Browser.

Beginnen wir damit, nur die Berechtigungen des Standardbenutzers zu testen:

Sie werden sehen, dass der Standardbenutzer nur Bücher anzeigen darf und kein Buch hinzufügen, löschen oder aktualisieren kann.

Lassen Sie uns jetzt mit dem Benutzer admin_user anmelden, um zu sehen, was passiert:

Sie werden sehen, dass der Administrator zu fast allem berechtigt ist! So solide und einfach zu bedienen ist Permit!

Sie können sich diese Ressourcen ansehen, um mehr über die Autorisierung von Permit zu erfahren:

• Authentifizierung und Autorisierung in Anwendungen.
• Best Practices für effektive Benutzerberechtigungen und Zugriffsdelegierung.
• Was ist eine feinkörnige Autorisierung?

Abschluss

In diesem Tutorial haben wir eine einfache App zur Buchhandlungsverwaltung erstellt, um eine rollenbasierte Zugriffskontrolle mit Go, HTMX und Permit.io zu implementieren. Die Autorisierung ist ein grundlegender Aspekt der Anwendungssicherheit, da sie sicherstellt, dass Benutzer nur auf das zugreifen können, was ihnen gestattet ist.

Die Implementierung eines effektiven Zugriffskontrollmodells wie RBAC oder ABAC in Ihre Anwendung würde nicht nur Ihre Anwendung sichern, sondern auch ihre Skalierbarkeit und Compliance verbessern.

Das obige ist der detaillierte Inhalt vonSo richten Sie die Autorisierung in einem Buchhandlungsverwaltungssystem mit Go, HTMX und Permit.io ein. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!