Definování oprávnění k datům

Fabric Apps k připojení autorizačních pravidel přímo k datovým modelům používá dekorátor @role. Oprávnění jsou typově bezpečná, refaktorovatelově přívětivá a automaticky se kompilují do základní konfigurace přístupu k datům.

Než začnete

Předdefinované role

Fabric Apps rozpozná integrovanou roli authenticated. V případě potřeby můžete také definovat vlastní role v zásadách.

Úloha Description Případ použití
authenticated Vyžaduje platnou uživatelskou relaci s ověřením Fabric. Data specifická pro uživatele, chráněné prostředky

Dekorátor @role

Použijte @role na úrovni třídy, abyste mohli určit, které role můžou provádět akce u entity:

@role(roleName, actions, options?)

Parameters

Parameter Typ Description
roleName string Název role, například 'authenticated' nebo vlastní role aplikace
actions string \| string[] Jedna akce nebo pole: 'create', 'read', 'update', 'delete' nebo '*' pro vše
options object Volitelný objekt s vlastnostmi check, include a exclude

Základní příklad

Omezit ověřené uživatele na vlastní data:

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

V tomto příkladu:

  • Ověření uživatelé mají přístup pouze k položkám Todo, kde userId odpovídá jejich claimu JWT sub.

Typově bezpečné výrazy zásad

Zpětné policy volání poskytuje typový přístup k deklaracím i polím entity. TypeScript odvodí typ entity z zdobené třídy a poskytuje automatické dokončování a bezpečnost refaktoringu:

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

Podporovaná tvrzení

Požadavek Description Ukázková hodnota
claims.sub Identifikátor subjektu (ID uživatele) 00000000-0000-0000-0000-000000000001
claims.email E-mailová adresa uživatele user@contoso.com
claims.role Role uživatele (pokud ji poskytuje zprostředkovatel identity) admin

Operátory výrazů

Operator Example Description
.eq() claims.sub.eq(item.userId) Kontrola rovnosti

Logické operátory

Kombinování výrazů s .and() a .or():

// 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))
})

Obě strany jsou automaticky uzavřeny do závorek pro správné seskupení.

Oprávnění na úrovni pole

Určete, ke kterým polím má role přístup, pomocí include nebo exclude v možnostech role.

Zahrnout konkrétní pole

Povolit title pole pouze během operací vytváření:

@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;
}

Vyloučit konkrétní pole

Skrytí citlivých polí v operacích čtení:

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

Poznámka:

Pole polí se zadají do skutečných názvů vlastností entity. Přejmenování pole způsobí chybu při kompilaci v každém seznamu include nebo exclude, který na toto pole odkazuje.

Oprávnění specifická pro akci

Použijte různá pravidla pro každou akci pomocí několika @role dekorátorů:

@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;
}

Tato konfigurace:

  • Vytvořit: Pouze tvůrce může vytvořit a jsou povolena pouze title pole a content pole.
  • Číst: Pouze tvůrce může číst vlastní dokumenty.
  • Aktualizace: Pouze tvůrce může aktualizovat, ale nemůže upravovat adminNotes.
  • Odstranit: Odstranit může pouze tvůrce.

Jak fungují oprávnění

  • Kolekce metadat: @role Dekorátor shromažďuje metadata oprávnění při definování třídy.
  • Generování schématu: Při spuštění db applyrozhraní příkazového řádku čte metadata a generuje konfiguraci oprávnění.
  • Kompilace zásad: Zpětná volání zásad TypeScriptu se kompilují do výrazů zásad přístupu k datům (například @claims.sub eq @item.userId).
  • Vynucení za běhu: Vrstva přístupu k datům vynucuje oprávnění pro každý požadavek rozhraní API.
  • Detekce konfliktů: Více @role dekorátorů ve stejné třídě se agreguje na roli s upozorněními pro konfliktní deklarace.

Obvyklé scénáře

Přístup jen pro vlastníka

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

Úplný přístup pro ověřené uživatele

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

Přepsání správcem

@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;
}

Správci můžou upravovat jakýkoli prostředek, ale odstranit můžou jenom správci.

Další kroky

  • Last updated on