mdb openfga
1.0.0
Pencarian vektor MongoDB Atlas memungkinkan pencarian kesamaan yang efisien berdasarkan representasi vektor. Ini sangat bermanfaat ketika bekerja dengan data yang tidak terstruktur seperti teks, gambar, atau audio, di mana pencarian berbasis kata kunci tradisional mungkin gagal.
Keuntungan utama:
Integrasi dengan OpenFGA:
Ketika dikombinasikan dengan OpenFGA, pencarian vektor MongoDB Atlas memberikan solusi yang kuat untuk akses dokumen yang aman. Anda dapat menggunakan pencarian vektor untuk mengambil dokumen yang relevan berdasarkan kontennya, dan kemudian menerapkan aturan kontrol akses OpenFGA untuk memastikan bahwa hanya pengguna yang berwenang yang dapat melihat hasilnya.
Contoh:
Bayangkan sistem manajemen dokumen di mana pengguna dapat mencari dokumen berdasarkan konten mereka. Dengan menggunakan pencarian vektor MongoDB Atlas, Anda dapat secara efisien mengambil dokumen yang secara semantik mirip dengan kueri pengguna. OpenFGA kemudian dapat digunakan untuk menegakkan kontrol akses, memastikan bahwa pengguna hanya melihat dokumen yang diizinkan untuk dilihat.
OpenFGA adalah platform otorisasi open-source yang dirancang untuk menyediakan kontrol akses berbutir halus untuk aplikasi cloud-asli. Ini menawarkan solusi yang fleksibel dan dapat diskalakan untuk mengelola izin pengguna dan akses ke sumber daya.
OpenFGA beroperasi pada konsep tupel . Tuple mewakili izin, yang terdiri dari pengguna, relasi (misalnya, "baca", "tulis"), dan objek (misalnya, file, database). Kebijakan didefinisikan untuk menentukan tupel mana yang diizinkan atau ditolak. Ketika pengguna mencoba mengakses sumber daya, OpenFGA mengevaluasi tuple yang sesuai terhadap kebijakan yang ditentukan untuk menentukan apakah akses diberikan atau ditolak.
Tarik gambar OpenFGA Docker:
docker pull openfga/openfgaJalankan wadah OpenFGA dengan port yang terbuka:
docker run -p 8080:8080 -p 3000:3000 openfga/openfga runTarik gambar Docker lokal Mongodb Atlas:
docker pull mongodb/mongodb-atlas-localJalankan wadah lokal Mongodb Atlas:
docker run -p 27017:27017 mongodb/mongodb-atlas-localBagian ini memandu Anda dengan membuat indeks pencarian vektor untuk pencarian kesamaan yang efisien dalam data OpenFGA.
Terhubung ke cluster atlas lokal menggunakan mongosh :
mongosh " mongodb://localhost/demo?directConnection=true " Beralih ke database demo (ganti dengan nama database Anda yang sebenarnya jika diperlukan):
use demo
Buat indeks pencarian vektor bernama "vector_index" di bidang "embeddings":
db . mdb_fga . createSearchIndex (
"vector_index" ,
"vectorSearch" , // index type
{
fields : [
{
"type" : "vector" ,
"numDimensions" : 1536 ,
"path" : "embeddings" ,
"similarity" : "cosine"
} ,
]
}
) ;Menginstal Perpustakaan Python yang Diperlukan
pip install asyncio requests pymongo unstructured openai Perintah ini menginstal semua perpustakaan yang diperlukan ( asyncio , requests , pymongo , unstructured , dan openai ) untuk menjalankan kode Python.
Tidak terstruktur: mengekstraksi makna dari dokumen
Tidak terstruktur memberdayakan Anda untuk memecah dokumen teks menjadi unit yang lebih kecil dan lebih mudah dikelola. Bayangkan sebuah makalah penelitian: tidak terstruktur dapat membaginya menjadi beberapa bagian, paragraf, atau bahkan kalimat, membuatnya lebih mudah untuk diproses dan dianalisis. Perpustakaan juga membantu mengekstrak entitas seperti nama, tanggal, dan lokasi, membantu pengambilan informasi.
OpenFGA: Mengamankan akses ke data yang diekstraksi
Anda mendefinisikan kebijakan yang mengatur izin pengguna berdasarkan kondisi tertentu. Ketika pengguna mencoba mengakses dokumen atau data yang diekstraksi, OpenFGA mengevaluasi pengguna dan dokumen yang sesuai terhadap kebijakan ini, memberikan atau menolak akses.
MongoDB Atlas Vector Search: Menemukan dokumen serupa secara efisien
Bayangkan Anda mencari konsep tertentu dalam koleksi dokumen. Pencarian berbasis kata kunci mungkin kehilangan dokumen yang relevan yang tidak berisi kata kunci yang tepat. Pencarian vektor, bagaimanapun, menganalisis representasi vektor konten dokumen, memungkinkan Anda untuk menemukan dokumen yang sama secara semantik, bahkan jika mereka menggunakan kata -kata yang berbeda.
Kekuatan menggabungkan alat -alat ini
Dengan mengintegrasikan ketiga alat ini, Anda membuat sistem manajemen dokumen yang kuat dan aman. Inilah alur kerja:
add_tuple di openfga Fungsi add_tuple yang Anda lihat di cuplikan kode memainkan peran penting dalam mengelola kontrol akses dalam aplikasi MDB-OpenFGA. Ini berinteraksi dengan OpenFGA untuk memberikan izin pengguna untuk melihat sumber daya tertentu.
Berikut adalah rincian cara kerja add_tuple :
Argumen:
USER : Ini mewakili pengguna yang Anda berikan izin. Kode memformatnya sebagai "user:"+USER untuk konsistensi dalam OpenFGA.RESOURCE : Ini mewakili sumber daya yang diberikan pengguna. Dalam contoh, diformat sebagai "doc:"+RESOURCE (asumsi dokumen).Panggilan API:
/stores/{store_id}/write ). Titik akhir ini digunakan untuk menulis data (Tuples) ke toko OpenFGA.writes : Kunci ini memegang objek yang menentukan tupel yang akan ditambahkan.tuple_keys : Ini adalah array yang berisi objek tuple yang mendefinisikan izin. Setiap objek tuple memiliki tiga properti:user : ID Pengguna yang diformat sebelumnya.relation : Ini mendefinisikan jenis izin yang diberikan. Dalam hal ini, diatur ke "viewer" untuk menunjukkan akses baca.object : ID sumber daya yang diformat sebelumnya.authorization_model_id : Ini menentukan ID model otorisasi yang digunakan di OpenFGA. Model ini mendefinisikan aturan kontrol akses yang mengatur bagaimana tupel dievaluasi.Tanggapan:
Intinya, add_tuple membuat tuple baru di OpenFGA, menyatakan bahwa pengguna tertentu ( USER ) memiliki izin untuk melihat sumber daya ( RESOURCE ) tertentu. Tuple ini kemudian akan digunakan oleh mekanisme kontrol akses OpenFGA untuk menentukan apakah pengguna berwenang untuk mengakses sumber daya selama permintaan di masa depan.
check_authorization di MDB-OpenFGA Fungsi check_authorization memainkan peran penting dalam aplikasi MDB-OpenFGA. Ini bertanggung jawab untuk menentukan apakah pengguna yang diberikan memiliki izin untuk mengakses sumber daya tertentu berdasarkan kebijakan kontrol akses yang ditentukan dalam OpenFGA.
Cara kerjanya:
Argumen:
tuple_key : Ini adalah objek JSON yang mewakili tuple. Tuple, seperti yang Anda tahu, mendefinisikan izin. Biasanya berisi tiga properti:user : ID Pengguna.relation : Jenis izin (misalnya, "penampil", "editor").object : ID Sumber Daya.Panggilan API:
/stores/{store_id}/check . Titik akhir ini digunakan untuk mengevaluasi tuple terhadap model otorisasi yang ditentukan.authorization_model_id : ID model otorisasi yang digunakan.tuple_key : Objek tuple yang ingin Anda periksa.Tanggapan:
bool :true : Pengguna memiliki izin.false : Pengguna tidak memiliki izin. Pada dasarnya, check_authorization mengambil tuple sebagai input dan kueri OpenFGA untuk menentukan apakah pengguna yang ditentukan dalam tuple diizinkan untuk melakukan tindakan (relasi) pada sumber daya yang ditentukan (objek).
Menjalankan demo
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" ))
