mdb openfga
1.0.0
Die MongoDB -Atlas -Vektor -Suche ermöglicht eine effiziente Ähnlichkeitssuche basierend auf Vektordarstellungen. Dies ist besonders vorteilhaft, wenn Sie mit unstrukturierten Daten wie Text, Bildern oder Audio arbeiten, bei denen herkömmliche Keyword-basierte Suchvorgänge möglicherweise zu kurz kommen.
Schlüsselvorteile:
Integration mit OpenFGA:
In Kombination mit OpenFGA bietet die MongoDB -Atlas -Vektor -Suche eine leistungsstarke Lösung für den sicheren Zugriff auf den sicheren Dokumenten. Sie können die Vektorsuche verwenden, um relevante Dokumente basierend auf ihren Inhalten abzurufen und dann die Zugriffsregelungsregeln von OpenFGA anzuwenden, um sicherzustellen, dass nur autorisierte Benutzer die Ergebnisse anzeigen können.
Beispiel:
Stellen Sie sich ein Dokumentverwaltungssystem vor, in dem Benutzer basierend auf ihren Inhalten nach Dokumenten suchen können. Durch die Verwendung von MongoDB -Atlas -Vektor -Suche können Sie Dokumente, die der Abfrage des Benutzers semantisch ähnlich sind, effizient abrufen. OpenFGA kann dann verwendet werden, um die Zugriffskontrolle durchzusetzen, um sicherzustellen, dass Benutzer nur Dokumente sehen, die sie anzeigen können.
OpenFGA ist eine Open-Source-Autorisierungsplattform, mit der eine feinkörnige Zugriffskontrolle für Cloud-native Anwendungen bereitgestellt werden soll. Es bietet eine flexible und skalierbare Lösung für die Verwaltung von Benutzerberechtigungen und zum Zugriff auf Ressourcen.
OpenFGA arbeitet mit dem Konzept der Tupel . Ein Tupel stellt eine Erlaubnis dar, die aus einem Benutzer, einer Beziehung (z. B. "gelesen", "Schreiben") und einem Objekt (z. B. einer Datei, einer Datenbank) besteht. Es werden Richtlinien definiert, um anzugeben, welche Tupel zulässig oder verweigert werden. Wenn ein Benutzer versucht, auf eine Ressource zuzugreifen, bewertet OpenFGA das entsprechende Tupel anhand der definierten Richtlinien, um festzustellen, ob der Zugriff gewährt oder abgelehnt wird.
Ziehen Sie das OpenFGA Docker -Bild:
docker pull openfga/openfgaFühren Sie den OpenFGA -Container mit exponierten Ports aus:
docker run -p 8080:8080 -p 3000:3000 openfga/openfga runZiehen Sie das lokale Docker -Bild von MongoDB Atlas:
docker pull mongodb/mongodb-atlas-localFühren Sie den lokalen Container des MongoDB Atlas aus:
docker run -p 27017:27017 mongodb/mongodb-atlas-localDieser Abschnitt leitet Sie durch das Erstellen eines Vektorsuchesindex für effiziente Ähnlichkeitssuche in OpenFGA -Daten.
Stellen Sie mit mongosh eine Verbindung zum lokalen Atlas -Cluster her:
mongosh " mongodb://localhost/demo?directConnection=true " Wechseln Sie zur demo -Datenbank (ersetzen Sie bei Bedarf durch Ihren tatsächlichen Datenbanknamen):
use demo
Erstellen Sie einen Vektor -Suchindex mit dem Namen "vector_index" im Feld "Einbettdings":
db . mdb_fga . createSearchIndex (
"vector_index" ,
"vectorSearch" , // index type
{
fields : [
{
"type" : "vector" ,
"numDimensions" : 1536 ,
"path" : "embeddings" ,
"similarity" : "cosine"
} ,
]
}
) ;Installation der erforderlichen Python -Bibliotheken
pip install asyncio requests pymongo unstructured openai Dieser Befehl installiert alle erforderlichen Bibliotheken ( asyncio , requests , pymongo , unstructured und openai ), um den Python -Code auszuführen.
Unstrukturiert: Bedeutung aus Dokumenten extrahieren
Unstrukturierte ermächtigen Sie, Textdokumente in kleinere, überschaubare Einheiten zu zerlegen. Stellen Sie sich ein Forschungspapier vor: Unstrukturiert kann sie in Abschnitte, Absätze oder sogar Sätze unterteilt, wodurch die Verarbeitung und Analyse erleichtert wird. Die Bibliothek hilft auch dabei, Entitäten wie Namen, Daten und Standorte zu extrahieren und beim Abrufen von Informationen zu helfen.
OpenFGA: Sicherung des Zugriffs auf extrahierte Daten sichern
Sie definieren Richtlinien, die die Benutzerberechtigungen auf der Grundlage bestimmter Bedingungen regeln. Wenn ein Benutzer versucht, auf ein Dokument oder seine extrahierten Daten zuzugreifen, bewertet OpenFGA den entsprechenden Benutzer und das Dokument gegen diese Richtlinien, die Zugriff gewährt oder verweigert.
MongoDB -Atlas -Vektor -Suche: ähnliche Dokumente effizient finden
Stellen Sie sich vor, Sie suchen nach einem bestimmten Konzept innerhalb einer Dokumentsammlung. Keyword-basierte Suchvorgänge verpassen möglicherweise relevante Dokumente, die nicht die genauen Schlüsselwörter enthalten. Die Vektorsuche analysiert jedoch die Vektordarstellungen von Dokumentinhalten und ermöglicht es Ihnen, semantisch ähnliche Dokumente zu finden, auch wenn sie unterschiedliche Formulierungen verwenden.
Die Kraft, diese Werkzeuge zu kombinieren
Durch die Integration dieser drei Tools erstellen Sie ein robustes und sicheres Dokumentverwaltungssystem. Hier ist der Workflow:
add_tuple in openFGA Die add_tuple -Funktion, die Sie im Code-Snippet gesehen haben, spielt eine entscheidende Rolle bei der Verwaltung der Zugriffskontrolle innerhalb der MDB-OpenFGA-Anwendung. Es interagiert mit OpenFGA, um eine Benutzererlaubnis zum Anzeigen einer bestimmten Ressource zu erteilen.
Hier ist eine Aufschlüsselung darüber, wie add_tuple funktioniert:
Argumente:
USER : Dies stellt den Benutzer dar, für den Sie die Erlaubnis erteilen. Das Code formatiert es als "user:"+USER für Konsistenz in OpenFGA.RESOURCE : Dies repräsentiert die Ressource, auf die dem Benutzer Zugriff erhalten. Im Beispiel ist es als "doc:"+RESOURCE (unter der Annahme von Dokumenten) formatiert.API -Anruf:
/stores/{store_id}/write ). Dieser Endpunkt wird zum Schreiben von Daten (Tupel) in den OpenFGA -Store verwendet.writes : Dieser Schlüssel enthält ein Objekt, das die zugegebenen Tupel angibt.tuple_keys : Dies ist ein Array, das die Tuple -Objekte enthält, die die Berechtigungen definieren. Jedes Tuple -Objekt hat drei Eigenschaften:user : Die Benutzer -ID wie früher formatiert.relation : Dies definiert die Art der Erlaubnis, die erteilt wird. In diesem Fall ist es auf "viewer" eingestellt, um den Lesezugriff anzuzeigen.object : Die Ressourcen -ID wie früher formatiert.authorization_model_id : Dies gibt die ID des in OpenFGA verwendeten Autorisierungsmodells an. Dieses Modell definiert die Zugriffskontrollregeln, die regeln, wie Tupel bewertet werden.Antwort:
Im Wesentlichen erstellt add_tuple in OpenFGA ein neues Tupel mit der Angabe, dass ein bestimmter Benutzer ( USER ) die Erlaubnis hat, eine bestimmte Ressource ( RESOURCE ) anzuzeigen. Dieses Tupel wird dann von den Zugriffskontrollmechanismen von OpenFGA verwendet, um festzustellen, ob der Benutzer in zukünftigen Anfragen auf die Ressource zugreifen kann.
check_authorization in mdb-openfga Die Funktion check_authorization spielt eine wichtige Rolle in der MDB-OpenFGA-Anwendung. Es ist verantwortlich dafür, zu bestimmen, ob ein bestimmter Benutzer die Erlaubnis hat, auf eine bestimmte Ressource auf der Grundlage der in OpenFGA definierten Zugriffskontrollrichtlinien zuzugreifen.
Wie es funktioniert:
Argumente:
tuple_key : Dies ist ein JSON -Objekt, das ein Tupel darstellt. Wie Sie wissen, definiert ein Tupel eine Erlaubnis. Es enthält typischerweise drei Eigenschaften:user : Die Benutzer -ID.relation : Die Art der Erlaubnis (z. B. "Betrachter", "Editor").object : Die Ressourcen -ID.API -Anruf:
/stores/{store_id}/check . Dieser Endpunkt wird verwendet, um ein Tupel gegen das definierte Autorisierungsmodell zu bewerten.authorization_model_id : Die ID des verwendeten Autorisierungsmodells.tuple_key : Das Tuple -Objekt, das Sie überprüfen möchten.Antwort:
bool -Wert:true : Der Benutzer hat die Berechtigung.false : Der Benutzer hat keine Erlaubnis. Im Wesentlichen nimmt check_authorization ein Tupel als Eingabe und Abfragen openFGA an, um festzustellen, ob der im Tupel angegebene Benutzer die Aktion (Beziehung) auf der angegebenen Ressource (Objekt) ausführen darf.
Die Demo laufen
python3 demo.py
Starting FGA setup...
FGA setup response: {'code': 'write_failed_due_to_invalid_input', 'message': "cannot write a tuple which already exists: user: 'user:demo_user', relation: 'viewer', object: 'doc:demo.pdf': invalid write input"}
Clearing the db first...
Database cleared.
Starting PDF document partitioning...
PDF partitioning and database insertion completed successfully.
Waiting for index to be updated. This may take a few seconds...
Starting search tool...
Access Granted: User 'demo_user' has permission to read document 'demo.pdf'.
Access Denied: User 'demo_user-denyme' does not have permission to read document 'demo.pdf'.
import asyncio
import requests
import json
import pymongo
from unstructured . partition . auto import partition
from openai import AzureOpenAI
class FGA_MDB_DEMO :
def __init__ ( self , azure_endpoint , api_version , api_key , mongo_uri , fga_api_url , fga_store_id , fga_api_token , authorization_model_id , db_name , collection_name ):
self . az_client = AzureOpenAI ( azure_endpoint = azure_endpoint , api_version = api_version , api_key = api_key )
self . mongo_client = pymongo . MongoClient ( mongo_uri )
self . fga_api_url = fga_api_url
self . fga_store_id = fga_store_id
self . fga_api_token = fga_api_token
self . authorization_model_id = authorization_model_id
self . db_name = db_name
self . collection_name = collection_name
def generate_embeddings ( self , text , model = "" ):
return self . az_client . embeddings . create ( input = [ text ], model = model ). data [ 0 ]. embedding
def check_authorization ( self , tuple_key ):
url = f" { self . fga_api_url } /stores/ { self . fga_store_id } /check"
headers = {
"Authorization" : f"Bearer { self . fga_api_token } " ,
"content-type" : "application/json" ,
}
data = {
"authorization_model_id" : self . authorization_model_id ,
"tuple_key" : tuple_key
}
response = requests . post ( url , headers = headers , data = json . dumps ( data ))
return response . json ()
def add_tuple ( self , USER , RESOURCE ):
url = f" { self . fga_api_url } /stores/ { self . fga_store_id } /write"
headers = {
"Authorization" : f"Bearer { self . fga_api_token } " ,
"content-type" : "application/json" ,
}
data = {
"writes" : {
"tuple_keys" : [
{
"user" : "user:" + USER ,
"relation" : "viewer" ,
"object" : "doc:" + RESOURCE
}
]
},
"authorization_model_id" : self . authorization_model_id
}
response = requests . post ( url , headers = headers , data = json . dumps ( data ))
return response . json ()
def search_tool ( self , text , USER_ID ):
response = self . mongo_client [ self . db_name ][ self . collection_name ]. aggregate ([
{
"$vectorSearch" : {
"index" : "vector_index" ,
"queryVector" : self . az_client . embeddings . create ( model = "text-embedding-ada-002" , input = text ). data [ 0 ]. embedding ,
"path" : "embeddings" ,
"limit" : 5 ,
"numCandidates" : 30
}
}, { "$project" :{ "_id" : 0 , "embeddings" : 0 , "metadata" : 0 }}
])
for doc in response :
tuple_key = { "user" : "user:" + USER_ID , "relation" : "viewer" , "object" : "doc:" + doc [ "source" ]}
response = self . check_authorization ( tuple_key )
if response [ 'allowed' ]:
print ( f"Access Granted: User ' { USER_ID } ' has permission to read document ' { doc [ 'source' ] } '." )
else :
print ( f"Access Denied: User ' { USER_ID } ' does not have permission to read document ' { doc [ 'source' ] } '." )
def partition_pdf ( self , resource ):
mdb_db = self . mongo_client [ self . db_name ]
mdb_collection = mdb_db [ self . collection_name ]
print ( "Clearing the db first..." )
mdb_collection . delete_many ({})
print ( "Database cleared." )
print ( "Starting PDF document partitioning..." )
elements = partition ( resource )
for element in elements :
mdb_collection . insert_one ({
"text" : str ( element . text ),
"embeddings" : self . generate_embeddings ( str ( element . text ), "text-embedding-ada-002" ),
"metadata" : {
"raw_element" : element . to_dict (),
},
"source" : resource
})
print ( "PDF partitioning and database insertion completed successfully." )
def fga_setup ( self , user , resource ):
response = self . add_tuple ( user , resource )
print ( f"FGA setup response: { response } " )
async def main ( self , user , resource ):
print ( "Starting FGA setup..." )
self . fga_setup ( user , resource )
self . partition_pdf ( resource )
print ( "Waiting for index to be updated. This may take a few seconds..." )
await asyncio . sleep ( 15 )
print ( "Starting search tool..." )
self . search_tool ( "test" , user )
self . search_tool ( "test" , user + "-denyme" )
print ( "Process completed successfully." )
if __name__ == "__main__" :
fga_mdb_demo = FGA_MDB_DEMO (
azure_endpoint = "" ,
api_version = "2024-04-01-preview" ,
api_key = "" ,
mongo_uri = "mongodb://localhost:27017/demo?directConnection=true" ,
fga_api_url = 'http://localhost:8080' ,
fga_store_id = '01J8VP1HYCHN459VT76DQG0W2R' ,
fga_api_token = '' ,
authorization_model_id = '01J8VP3BMPZNFJ480G5ZNF3H0C' ,
db_name = "demo" ,
collection_name = "mdb_fga"
)
asyncio . run ( fga_mdb_demo . main ( "demo_user" , "demo.pdf" ))
