Megosztás a következőn keresztül:

Útmutató: Tárolót létrehozó felhasználó ellenőrzése

  • Cikk

Amikor létrehoz egy tárolót az Azure Fluid Relayben, az ITokenProvider által a létrehozási kérelemhez biztosított JWT csak egyszer használható. Tároló létrehozása után az ügyfélnek létre kell hoznia egy új JWT-t, amely tartalmazza a szolgáltatás által a létrehozáskor megadott dokumentumazonosítót (amely valójában a tárolóazonosító). Ha egy alkalmazás rendelkezik olyan engedélyezési szolgáltatással, amely a tároló hozzáférés-vezérlését kezeli, tudnia kell, hogy ki hozott létre egy adott azonosítóval rendelkező tárolót, hogy engedélyezze egy új JWT létrehozását a tárolóhoz való hozzáféréshez.

Az engedélyezési szolgáltatás értesítése tároló létrehozásakor

Az alkalmazások egy nyilvános documentPostCreateCallback() metódus implementálásával csatlakozhatnak a tárolólétrehozási életciklushoz TokenProvider. (A függvény neve zavaró lehet. Ez valójában egy visszahívás a tároló létrehozása után.) Ez a visszahívás közvetlenül a tároló létrehozása után aktiválódik, mielőtt az ügyfél az új JWT-t kéri, hogy olvasási/írási engedélyeket szerezzen a létrehozott tárolóhoz.

A documentPostCreateCallback() rendszer két paramétert kap: 1) a létrehozott tároló azonosítóját (más néven a "dokumentumazonosítót"), és 2) a szolgáltatás által aláírt JWT-t engedélyhatókör nélkül. Az engedélyezési szolgáltatás ellenőrizheti a megadott JWT-t, és a JWT-ben található információk segítségével megfelelő felhasználói engedélyeket adhat az újonnan létrehozott tárolóhoz.

Végpont létrehozása a tárolólétrehozás visszahívásához

Az alábbi példa egy Azure-függvény, amely a How to: Write a TokenProvider with a Azure Function (TokenProvider és egy Azure-függvény) című példán alapul.

import { AzureFunction, Context, HttpRequest } from "@azure/functions";
import { ITokenClaims, IUser } from "@fluidframework/protocol-definitions";
import * as jwt from "jsonwebtoken";

// NOTE: retrieve the key from a secure location.
const key = "myTenantKey";

const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
    const token = (req.query.token || (req.body && req.body.token)) as string;
    const documentId = (req.query.documentId || (req.body && req.body.documentId)) as string;

    if (!token) {
        context.res = {
            status: 400,
            body: "No token provided in request",
        };
        return;
    }
    if (!documentId) {
        context.res = {
            status: 400,
            body: "No documentId provided in request",
        };
        return;
    }
    
    const claims = jwt.decode(token) as ITokenClaims;
    if (!claims) {
        context.res = {
            status: 403,
            body: "Missing token claims",
        };
        return;
    }

    const tenantId = claims.tenantId;
    if (!claims) {
        context.res = {
            status: 400,
            body: "No tenantId provided in token claims",
        };
        return;
    }
    if (!key) {
        context.res = {
            status: 404,
            body: `No key found for the provided tenantId: ${tenantId}`,
        };
        return;
    }
    try {
        jwt.verify(token, key);
    } catch (e) {
        if (e instanceof jwt.TokenExpiredError) {
            context.res = {
                status: 401,
                body: `Token is expired`,
            };
            return
        }
        context.res = {
            status: 403,
            body: `Token signed with invalid key`,
        }
        return;
    }

    const user: IUser = claims.user;
    // Pseudo-function: implement according to your needs
    giveUserPermissionsForContainer(documentId, user);

    context.res = {
        status: 200,
        body: "OK",
    };
};

export default httpTrigger;

A documentPostCreateCallback

Az alábbi példa implementáció kiterjeszti az AzureFunctionTokenProvidert, és az axios-kódtár használatával HTTP-kérést küld a jogkivonatok létrehozásához használt Azure-függvényhez.

import { AzureFunctionTokenProvider, AzureMember } from "@fluidframework/azure-client";
import axios from "axios";

/**
 * Token Provider implementation for connecting to an Azure Function endpoint for
 * Azure Fluid Relay token resolution.
 */
export class AzureFunctionTokenProviderWithContainerCreateCallback extends AzureFunctionTokenProvider {
    /**
     * Creates a new instance using configuration parameters.
     * @param azFunctionUrl - URL to Azure Function endpoint
     * @param user - User object
     */
    constructor(
        private readonly authAzFunctionUrl: string,
        azFunctionUrl: string,
        user?: Pick<AzureMember, "userId" | "userName" | "additionalDetails">,
    ) {
        super(azFunctionUrl, user);
    }

    // In this context, a document is another name for container, so you can think of this function
    // as if it were named containerPostCreateCallback.
    public async documentPostCreateCallback?(documentId: string, creationToken: string): Promise<void> {
        await axios.post(this.authAzFunctionUrl, {
            params: {
                documentId,
                token: creationToken,
            },
        });
    }
}

Kapcsolódó információk