Adatengedélyek definiálása

Fabric Alkalmazások a @role dekoratőr használatával csatolják az engedélyezési szabályokat közvetlenül az adatmodellekhez. Az engedélyek típusbiztosak, újrabontásbarátak, és automatikusan lefordíthatók az alapul szolgáló adathozzáférési konfigurációba.

Mielőtt hozzákezdene

Beépített szerepkörök

A Fabric Apps felismeri a beépített authenticated funkciókat és anonymous a szerepeket. Szükség esetén egyéni szerepköröket is definiálhat a szabályzatokban.

Role Leírás Felhasználási eset
authenticated Érvényes felhasználói munkamenetet igényel Fabric hitelesítéssel Felhasználóspecifikus adatok, védett erőforrások
anonymous Lehetővé teszi a hozzáférést érvényes felhasználói ülés nélkül. További információért lásd: Anonim adathozzáférés a Fabric alkalmazásokban. Nyilvános adatok és hitelesítetlen élmények

A @role dekoratőr

Az osztály szintjén alkalmazva @role szabályozhatja, hogy mely szerepkörök hajthatják végre az entitásokon végrehajtott műveleteket:

@role(roleName, actions, options?)

Parameters

Paraméter Típus Leírás
roleName string A szerepkör neve, például 'authenticated' vagy egy egyéni alkalmazásszerepkör
actions string \| string[] Egyetlen művelet vagy tömb: 'create', 'read', 'update', 'delete'vagy '*' az összes
options object Választható objektum check, és includeexclude tulajdonságokkal

Alapvető példa

A hitelesített felhasználók korlátozása a saját adataikra:

import { entity, role, uuid, text } from '@microsoft/rayfin-core';

@entity()
@role('authenticated', ['create', 'read', 'update', 'delete'], {
  policy: (claims, item) => claims.sub.eq(item.userId),
})
export class Todo {
  @uuid() id!: string;
  @text() title!: string;
  @text({ optional: true }) description?: string;
  @text() userId!: string;
}

Ebben a példában:

  • A hitelesített felhasználók csak olyan Todo-elemeket érhetnek el, amelyek userId megegyeznek a JWT-jogcímükkel sub .

Típusbiztos szabályzatkifejezések

A policy visszahívás gépelt hozzáférést biztosít a jogcímekhez és az entitásmezőkhöz is. A TypeScript a dekorált osztály alapján kikövetkezteti az entitás típusát, így automatikus kódkiegészítést és biztonságos refaktorálást tesz lehetővé:

policy: (claims, item) => claims.sub.eq(item.userId)

Támogatott állítások

Igény Leírás Példaérték
claims.sub Tárgyazonosító (felhasználói azonosító) 00000000-0000-0000-0000-000000000001
claims.email Felhasználói e-mail-cím user@contoso.com
claims.role Felhasználói szerepkör (ha az identitásszolgáltató biztosítja) admin

Kifejezés operátorai

Operator Example Leírás
.eq() claims.sub.eq(item.userId) Egyenlőség ellenőrzése

Logikai operátorok

Kifejezések kombinálása a .and() és .or() elemekkel:

// User must own the item AND item must be active
@role('authenticated', 'read', {
  policy: (claims, item) =>
    claims.sub.eq(item.userId).and(item.isActive.eq(true))
})

// User is admin OR user owns the item
@role('authenticated', ['update', 'delete'], {
  policy: (claims, item) =>
    claims.role.eq('admin').or(claims.sub.eq(item.ownerId))
})

A megfelelő csoportosítás érdekében mindkét oldal zárójelben van.

Mezőszintű engedélyek

Adja meg, hogy egy szerepkör mely mezőkhöz férhet hozzá a szerepkör beállításainál a(z) include vagy exclude használatával.

Adott mezők belefoglalása

Csak létrehozási műveletek során engedélyezze a(z) title mezőt:

@entity()
@role('authenticated', 'create', {
  policy: (claims, item) => claims.sub.eq(item.createdBy),
  include: ['title'],
})
export class Document {
  @uuid() id!: string;
  @text() title!: string;
  @text({ optional: true }) content?: string;
  @text() createdBy!: string;
}

Adott mezők kizárása

Bizalmas mezők elrejtése olvasási műveletek elől:

@entity()
@role('authenticated', 'read', {
  exclude: ['lastLogin', 'passwordHash'],
})
export class User {
  @uuid() id!: string;
  @text() email!: string;
  @date({ optional: true }) lastLogin?: Date;
  @text() passwordHash!: string;
}

Megjegyzés:

A mezőtömbök az entitás tényleges tulajdonságneveibe vannak begépelve. Egy mező átnevezése fordítási idejű hibát eredményez minden olyan include vagy exclude listában, amely hivatkozik rá.

Műveletspecifikus engedélyek

Műveletenként különböző szabályokat alkalmazhat több @role dekorátor használatával:

@entity()
@role('authenticated', 'create', {
  policy: (claims, item) => claims.sub.eq(item.createdBy),
  include: ['title', 'content'],
})
@role('authenticated', 'read', {
  policy: (claims, item) => claims.sub.eq(item.createdBy),
})
@role('authenticated', 'update', {
  policy: (claims, item) => claims.sub.eq(item.createdBy),
  exclude: ['adminNotes'],
})
@role('authenticated', 'delete', {
  policy: (claims, item) => claims.sub.eq(item.createdBy),
})
export class SecureDocument {
  @uuid() id!: string;
  @text() title!: string;
  @text({ optional: true }) content?: string;
  @text({ optional: true }) adminNotes?: string;
  @text() createdBy!: string;
}

Ez a konfiguráció:

  • Létrehozás: Csak a létrehozó hozhat létre, és csak title és content mezők engedélyezettek.
  • Olvasás: Csak a létrehozó tudja elolvasni a saját dokumentumait.
  • Frissítés: Csak a létrehozó frissíthet, de nem módosíthatja adminNotes.
  • Törlés: Csak a létrehozó törölhet.

Az engedélyek működése

  • Metaadatok gyűjtése: A @role dekorátor az osztály definiálásakor gyűjti az engedély metaadatait.
  • Séma létrehozása: Futtatáskor db applya parancssori felület felolvassa a metaadatokat, és létrehozza az engedélykonfigurációt.
  • Szabályzat összeállítása: A TypeScript-szabályzatvisszahívások adathozzáférési szabályzatkifejezésekké vannak lefordítva (például @claims.sub eq @item.userId).
  • Futtatókörnyezet kényszerítése: Az adatelérési réteg minden API-kéréshez kikényszeríti az engedélyeket.
  • Ütközések észlelése: Az ugyanazon az osztályon szereplő több @role dekorátort a rendszer szerepkörönként összesíti, és figyelmeztetést ad az ütköző deklarációk esetén.

Gyakori minták

Csak tulajdonosi hozzáférés

@entity()
@role('authenticated', '*', {
  policy: (claims, item) => claims.sub.eq(item.ownerId)
})
export class PrivateNote {
  @uuid() id!: string;
  @text() ownerId!: string;
  @text() content!: string;
}

Teljes hozzáférés hitelesített felhasználók számára

@entity()
@role('authenticated', '*')
export class BlogPost {
  @uuid() id!: string;
  @text() title!: string;
  @text() content!: string;
}

Rendszergazdai felülbírálat

@entity()
@role('authenticated', ['create', 'read', 'update'], {
  policy: (claims, item) =>
    claims.role.eq('admin').or(claims.sub.eq(item.ownerId))
})
@role('authenticated', 'delete', {
  policy: (claims, _item) => claims.role.eq('admin')
})
export class ManagedResource {
  @uuid() id!: string;
  @text() ownerId!: string;
  @text() name!: string;
}

A rendszergazdák bármilyen erőforrást módosíthatnak, de csak a rendszergazdák törölhetik őket.

Következő lépések

  • Last updated on