Como: Validar um usuário que criou um contêiner
Quando você cria um contêiner no Azure Fluid Relay, o JWT fornecido pelo ITokenProvider para a solicitação de criação só pode ser usado uma vez. Depois de criar um contêiner, o cliente deve gerar um novo JWT que contém a ID do documento (que é realmente a ID do contêiner) fornecida pelo serviço no momento da criação. Se um aplicativo tiver um serviço de autorização que gerencia o controle de acesso ao contêiner, ele precisará saber quem criou um contêiner com uma determinada ID para autorizar a geração de um novo JWT para acesso a esse contêiner.
Informar um serviço de autorização quando um contêiner é criado
Um aplicativo pode se vincular ao ciclo de vida de criação do contêiner implementando um método publicPostCreateCallback() em seu TokenProvider
. (O nome desta função pode ser confuso. É realmente um retorno de chamada para a criação de contêiner de postagem.) Esse retorno de chamada será acionado diretamente após a criação do contêiner, antes que um cliente solicite o novo JWT que ele precisa para obter permissões de leitura/gravação para o contêiner que foi criado.
O documentPostCreateCallback()
recebe dois parâmetros: 1) o ID do contêiner que foi criado (também chamado de "ID do documento") e 2) um JWT assinado pelo serviço sem escopos de permissão. O serviço de autorização pode verificar o JWT fornecido e usar as informações no JWT para conceder as permissões de usuário corretas para o contêiner recém-criado.
Criar um ponto de extremidade para o retorno de chamada de criação do contêiner
O exemplo abaixo é uma Função do Azure baseada no exemplo em Como gravar um TokenProvider com uma Função do Azure.
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;
Implementar o documentPostCreateCallback
Esta implementação de exemplo abaixo estende o AzureFunctionTokenProvider e usa a biblioteca axios para fazer uma solicitação HTTP para a Função do Azure usada para gerar tokens.
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,
},
});
}
}