Zum Hauptinhalt springen

Adapter

In Casbin wird die Speicherung der Richtlinien als Adapter implementiert (auch Middleware für Casbin). Ein Casbin-Benutzer kann einen Adapter verwenden, um Regeln von einem Speicher zu laden (aka LoadPolicy()), oder speichern Sie Richtlinien-Regeln (aka SavePolicy()). Um das Gewicht gering zu halten, legen wir den Adaptercode nicht in die Hauptbibliothek ein.

Unterstützte Adapter

Eine vollständige Liste der Casbin-Adapter finden Sie wie unten. Jeder Beitrag von Drittanbietern an einem neuen Adapter ist willkommen, bitte informieren Sie uns und wir werden ihn in diese Liste setzen:)

AdapterTypAutorAutoSaveBeschreibung
Datei-Adapter (eingebaut)DateiCasbinFür .CSV (Comma-Separated Values) Dateien
Gefilterter Datei-Adapter (eingebaut)Datei@gesichts-HeiligerFür .CSV (Comma-Separated Values) Dateien mit Richtlinien-Untermengenunterstützung
SQL-AdapterSQL@Blank-XuMySQL, PostgreSQL, SQL Server, SQLite3 werden in Master Branch unterstützt und Oracle wird in Orakel Branch von Datenbank/sql unterstützt
Xorm-AdapterRMCasbinMySQL, PostgreSQL, TiDB, SQLite, SQL Server, Oracle werden von Xorm unterstützt
Gorm-AdapterRMCasbinMySQL, PostgreSQL, Sqlite3, SQL Server werden von Gorm unterstützt
Ent-AdapterRMCasbinMySQL, MariaDB, PostgreSQL, SQLite, Gremlin-basierte Graphdatenbanken werden von ent ORM unterstützt
Beego ORM AdapterRMCasbinMySQL, PostgreSQL, Sqlite3 werden von Beego ORM unterstützt
SQLX-AdapterRM@memweyMySQL, PostgreSQL, SQLite, Oracle werden von SQLX unterstützt
Sqlx-AdapterSQL@Blank-XuMySQL, PostgreSQL, SQL Server, SQLite3 werden in Master Branch unterstützt und Oracle wird in Orakel Branch von sqlx unterstützt
GF ORM AdapterRM@vance-liuMySQL, SQLite, PostgreSQL, Oracle, SQL Server werden von GoFrame ORM unterstützt
GoFrame ORM AdapterRM@kotlin2018MySQL, SQLite, PostgreSQL, Oracle, SQL Server werden von GoFrame ORM unterstützt
Gefilterter PostgreSQL-AdapterSQLCasbinFür PostgreSQL
Gefilterter pgx-AdapterSQL@pckhoiPostgreSQL wird von pgx unterstützt
PostgreSQL-AdapterSQL@cychiuaeFür PostgreSQL
RQLite-AdapterSQLEDOMO-SystemeFür RQLite
MongoDB AdapterNoSQLCasbinFür MongoDB basierend auf MongoDB Go Treiber
RethinkDB AdapterNoSQL@adityapandey9Für RethinkDB
Kassandra-AdapterNoSQLCasbinFür Apache Cassandra DB
DynamoDB AdapterNoSQLHOOQFür Amazon DynamoDB
DynacasbinNoSQLNewbMiaoFür Amazon DynamoDB
ArangoDB AdapterNoSQL@adamwasilaFür ArangoDB
Amazon S3 AdapterWolkeLösungFür Minio und Amazon S3
Azure Kosmos DB AdapterWolke@SpacycodiererFür Microsoft Azure Cosmos DB
GCP Firestore AdapterWolke@reedomFür Google Cloud Plattform-Firestore
GCP Cloud-SpeicheradapterWolkequramiFür Google Cloud Platform Cloud Storage
GCP Cloud Spanner AdapterWolke@blumenightFür Google Cloud Plattform Cloud Spanner
KonsumadapterKV Shop@ankitm123Für HashiCorp Verbrauch
Redis-Adapter (Redigo)KV ShopCasbinFür Redis
Redis Adapter (go-redis)KV Shop@mlsenFür Redis
Etcd-AdapterKV Shop@sebastianliuFür etcd
BoltDB AdapterKV Shop@spezaFür Bolt
Bolt AdapterKV Shop@wirepairFür Bolt
BadgerDB AdapterKV Shop@initsFür BadgerDB
Protobuf AdapterStreamCasbinFür Google-Protokoll-Puffer
JSON-AdapterStringCasbinFür JSON
String-AdapterString@qiangmzsxFür Zeichenkette
HTTP-Datei-AdapterHTTP@h4ckednekoFür http.FileSystem
FileSystem AdapterDatei@nauconFür fs.FS und embed.FS
note
  1. Wenn casbin.NewEnforcer() mit einem expliziten oder impliziten Adapter aufgerufen wird, wird die Richtlinie automatisch geladen.
  2. Sie können e.LoadPolicy() aufrufen, um die Richtlinien-Regeln aus dem Speicher neu zu laden.
  3. Wenn der Adapter die Auto-Speichern Funktion nicht unterstützt, Die Richtlinien-Regeln können beim Hinzufügen oder Entfernen von Richtlinien nicht automatisch wieder in den Speicher gespeichert werden. Sie müssen SavePolicy() manuell aufrufen, um alle Regeln zu speichern.

Beispiele

Hier finden Sie einige Beispiele:

Datei-Adapter (eingebaut)

Unten wird gezeigt, wie man einen Erzwinger aus dem eingebauten Datei-Adapter initialisiert:

import "github.com/casbin/casbin"

e := casbin.NewEnforcer("examples/basic_model.conf", "examples/basic_policy.csv")

Dies ist das gleiche mit:

import (
"github.com/casbin/casbin"
"github.com/casbin/casbin/file-adapter"
)

a := fileadapter.NewAdapter("examples/basic_policy.csv")
e := casbin.NewEnforcer("examples/basic_model.conf", a)

MySQL adapter

Im Folgenden wird gezeigt, wie ein Durchsetzer aus der MySQL-Datenbank initialisiert wird. es verbindet sich mit einer MySQL DB auf 127.0.0.1:3306 mit einem root-und einem leeren Passwort.

import (
"github.com/casbin/casbin"
"github.com/casbin/mysql-adapter"
)

a := mysqladapter.NewAdapter("mysql", "root:@tcp(127.0.0.1:3306)/")
e := casbin.NewEnforcer("examples/basic_model.conf", a)

Verwende deinen eigenen Speicheradapter

Du kannst deinen eigenen Adapter verwenden wie unten:

import (
"github.com/casbin/casbin"
"github.com/your-username/your-repo"
)

a := yourpackage.NewAdapter(params)
e := casbin.NewEnforcer("examples/basic_model.conf", a)

Zwischen verschiedenen Adaptern migrieren/konvertieren

If you want to convert adapter from A to B, you can do like this:

  1. Richtlinien von A in den Speicher laden

    e, _ := NewEnforcer(m, A)

    oder

    e.SetAdapter(A)
    e.LoadPolicy()
  2. Ihren Adapter von A nach B konvertieren

    e.SetAdapter(B)
  3. Richtlinie vom Speicher auf B speichern

    e.LoadPolicy()

Laden/Speichern zur Laufzeit

Sie können auch das Modell neu laden, die Richtlinie neu laden oder die Richtlinie nach der Initialisierung speichern:

// Laden Sie das Modell aus der CONF-Datei neu.
e.LoadModel()

// Richtlinien aus der Datei/Datenbank neu laden.
e.LoadPolicy()

// Speichere die aktuelle Richtlinie (in der Regel nach der Änderung mit der Casbin API) zurück in die Datei/Datenbank.
e.SavePolicy()

AutoSave

Es gibt eine Funktion namens Auto-Speichern für Adapter. Wenn ein Adapter Auto-Speichern unterstützt, es bedeutet, dass es unterstützen kann, dem Speicher eine einzige Richtlinien-Regel hinzuzufügen oder eine einzige Richtlinien-Regel aus dem Speicher zu entfernen. Dies ist anders als SavePolicy(), da letztere alle Richtlinien-Regeln im Speicher löschen und alle Richtlinien-Regeln von Casbin erzwungen in die Speicherung speichern. Es könnte also zu Problemen bei der Leistung kommen, wenn die Anzahl der politischen Regeln groß ist.

Wenn der Adapter Auto-Speichernunterstützt, können Sie diese Option über Enforcer.EnableAutoSave() ändern. Die Option ist standardmäßig aktiviert (wenn der Adapter es unterstützt).

note
  1. Die Funktion Auto-Speichern ist optional. Ein Adapter kann wählen, ob er implementiert wird oder nicht.
  2. Auto-Speichern funktioniert nur für einen Casbin-Durchsetzer wenn der Adapter, den der Durchsetzer verwendet, dies unterstützt.
  3. Sehen Sie sich die Spalte AutoSave in der oben genannten Adapterliste an, um zu sehen, ob Auto-Speichern von einem Adapter unterstützt wird.

Hier ist ein Beispiel für die Verwendung von Auto-Speichern:

import (
"github.com/casbin/casbin"
"github.com/casbin/xorm-adapter"
_ "github.com/go-sql-driver/mysql"
)

// Standardmäßig ist die Option AutoSave für einen Enforcer aktiviert.
a := xormadapter.NewAdapter("mysql", "mysql_username:mysql_password@tcp(127.0.0.1:3306)/")
e := casbin.NewEnforcer("examples/basic_model.conf", a)

// AutoSave Option deaktivieren.
e.EnableAutoSave(false)

// Weil AutoSave deaktiviert ist, die Änderung der Richtlinien wirkt sich nur auf die Richtlinie in Casbin durchsetzer,
// sie wirkt sich nicht auf die Richtlinien im Speicher.
e.AddPolicy(...)
e.RemovePolicy(...)

// Automatische Speicherung aktivieren.
e.EnableAutoSave(true)

// Weil AutoSave aktiviert ist, die Änderung der Richtlinien betrifft nicht nur die Richtlinien in Casbin Durchsetzer,
// sondern auch die Richtlinien im Speicher.
e.AddPolicy(...)
e.RemovePolicy(...)

Weitere Beispiele finden Sie hier: https://github.com/casbin/xorm-adapter/blob/master/adapter_test.go

Wie man einen Adapter schreibt

Alle Adapter sollten die Adapter Schnittstelle implementieren, indem mindestens zwei obligatorische Methoden angegeben werden:LoadPolicy(Modellmodell). odel) Fehler und SavePolicy(model model.Model).

Die anderen drei Funktionen sind optional. Sie sollten implementiert werden, wenn der Adapter die Auto-Save Funktion unterstützt.

MethodeTypBeschreibung
LoadPolicy()mandatoryLade alle Regeln aus dem Speicher
SavePolicy()mandatoryAlle Richtlinien-Regeln im Speicher speichern
AddPolicy()optionalRichtlinien-Regel zum Speicher hinzufügen
RemovePolicy()optionalEine Richtlinien-Regel vom Speicher entfernen
FilteredPolicy() entfernenoptionalRegeln, die dem Filter entsprechen, vom Speicher entfernen
note

Wenn ein Adapter Auto-Speichernnicht unterstützt, sollte er eine leere Implementierung für die drei optionalen Funktionen bereitstellen. Hier ist ein Beispiel für Golang:

// AddPolicy fügt dem Speicher eine Richtlinien-Regel hinzu.
func (a *Adapter) AddPolicy(sec string, ptype string, rule []string) error {
return errors. ew("nicht implementiert")
}



// Entfernt eine Richtlinien-Regel vom Speicher.
func (a *Adapter) removePolicy(sec string, ptype string, rule []string) error {
return errors. ew("nicht implementiert")
}



// Entfernt Richtlinien-Regeln, die mit dem Filter übereinstimmen, vom Speicher entfernt.
func (a *Adapter) RemoveFilteredPolicy(sec string, ptype string, fieldIndex int, fieldValues ...string) error {
return errors.New("not implemented")
}

Beim Aufruf dieser drei optionalen Funktionen wird der nicht implementierte Fehler ignoriert.

Es gibt Details, wie man einen Adapter schreibt.

  • Datenstruktur. Adapter should support reading at least six columns.
  • Datenbank-Name. Der Standard-Datenbankname sollte casbin sein.
  • Tabellenname. Der Standard-Tabellenname sollte casbin_rule sein.
  • Ptype Spalte. Name dieser Spalte sollte ptype anstelle von p_type oder Ptype sein.
  • Tabellendefinition sollte (id int primary keyy, ptype varchar, v0 varchar, v1 varchar, v2 varchar, v3 varchar, v4 varchar, v5 varchar) sein.
  • Der eindeutige Schlüsselindex sollte auf Spalten ptype,v0,v1,v2,v3,v4,v5 gebaut werden.
  • LoadFilteredPolicy benötigt einen Filter als Parameter. Der Filter sollte so etwas sein.
    {
    "p":[ [ "alice" ], [ "bob" ] ],
    "g":[ [ "", "book_group" ], [ "", "pen_group" ] ],
    "g2":[ [ "alice" ] ]
    }

Wer ist für die Erstellung der Datenbank verantwortlich?

Als Konvent der Adapter sollte in der Lage sein, automatisch eine Datenbank mit dem Namen casbin zu erstellen, falls sie nicht vorhanden ist und sie für die Speicherung von Richtlinien verwenden. Bitte verwenden Sie den Xorm-Adapter als Referenzimplementierung: https://github.com/casbin/xorm-adapter