Rendimiento en el nodo MSAL

Prerequisites

  • Consulte Rendimiento en MSAL Browser , que describe las técnicas que puede usar la aplicación para mejorar el rendimiento de la adquisición de tokens mediante MSAL.
  • Node.js

Medición del rendimiento

Las aplicaciones que quieran medir el rendimiento de los flujos de autenticación en el nodo MSAL pueden hacerlo manualmente, mediante las API de medición de rendimiento de Node o similares. A continuación se muestra una lista de algunos puntos de datos importantes que puede recopilar:

Data Meaning Sugerencias
authType acquireToken* API usada para la solicitud de token Se usa para identificar el uso.
correlationId Id. de correlación usado para la solicitud de token. Puede obtenerlo a través de la correlationId propiedad en AuthenticationResult. Se usa para identificar el uso.
durationTotalInMs Tiempo total invertido en MSAL, incluidas las llamadas de red y el acceso a caché Alarma en la latencia general alta (> 1 segundo). El valor depende del origen del token. Desde la memoria caché: un acceso a la memoria caché. Desde la red: dos accesos a caché más dos llamadas HTTP.
durationInCacheInMs Tiempo empleado en cargar o guardar la persistencia de la caché de tokens (p. ej., Redis). Alarma sobre aumentos.
durationInHttpInMs Tiempo dedicado a realizar llamadas HTTP a IdP (por ejemplo, Microsoft Entra ID). Puede usar un cliente de red personalizado para una supervisión más específica. Consulte Ejemplo de configuración y red personalizada para obtener más información. Alarma sobre aumentos.
tokenSource Origen del token (es decir, caché frente a red). Puede obtenerlo a través de la fromCache propiedad en AuthenticationResult. Los tokens se recuperan de la memoria caché mucho más rápido (por ejemplo, ~100 ms frente a ~700 ms). Se puede usar para supervisar y generar alertas sobre la tasa de aciertos de caché. Use junto con durationTotalInMs.

Por ejemplo:

    const { PerformanceObserver, performance } = require('node:perf_hooks');

    const perfObserver = new PerformanceObserver((items) => {
        items.getEntries().forEach((entry) => {
            console.log(entry);
        })
    });

    perfObserver.observe({ entryTypes: ["measure"], buffered: true });

    // ...

    performance.mark("acquireTokenByClientCredential-start");

    const tokenResponse = await msalInstance.acquireTokenByClientCredential({
        scopes: ["User.Read.All"],
    });

    performance.mark("acquireTokenByClientCredential-end");

    performance.measure("acquireTokenByClientCredential", {
        start: "acquireTokenByClientCredential-start"
        end: "acquireTokenByClientCredential-end"
        detail: {
            tokenSource: tokenResponse.fromCache
            correlationId: tokenResponse.correlationId
        }
    });

Consideraciones de rendimiento para aplicaciones cliente confidenciales

Dado que las aplicaciones cliente confidenciales se usan principalmente con escenarios del lado servidor que implican el procesamiento simultáneo de solicitudes, se recomienda definir el ámbito de las instancias de MSAL ConfidenticalClientApplication (CCA) a cada usuario, solicitud o sesión.

Una nueva instancia de CCA para cada solicitud significa que su caché en memoria predeterminada inicialmente no contendrá ningún token o metadatos sobre cómo adquirir tokens. Por lo tanto, la instancia de CCA que cree debe estar preparada antes de la solicitud de token para evitar un rendimiento deficiente.

import {
    ConfidentialClientApplication,
    AuthenticationResult,
    CryptoProvider,
    OnBehalfOfRequest
} from "@azure/msal-node";

function getMsalInstance(partitionKey: string): ConfidentialClientApplication {
    return new ConfidentialClientApplication({
        auth: {
            clientId: "ENTER_CLIENT_ID",
            authority: "http://login.microsoftonline.com/ENTER_TENANT_ID"
            cloudDiscoveryMetadata: "PROVIDE_STRINGIFIED_DISCOVERY_METADATA"
            authorityMetadata: "PROVIDE_STRINGIFIED_AUTHORITY_METADATA"
        },
        cache: {
            cachePlugin: new CustomCachePlugin(
                this.cacheClientWrapper,
                partitionKey
            )
        }
    });
};

async function getToken(tokenRequest: OnBehalfOfRequest): Promise<AuthenticationResult | null> {
    const partitionKey = await this.cryptoProvider.hashString(tokenRequest.oboAssertion);

    const cca = getMsalInstance(partitionKey);

    let tokenResponse = null;

    try {
        await cca.getTokenCache().getAllAccounts(); // required for cache read
        tokenResponse = await cca.acquireTokenOnBehalfOf(tokenRequest);
    } catch (error) {
        throw error;
    }

    return tokenResponse;
};

Consulte la API web (CCA) que usa un complemento personalizado de caché distribuida para más información.

Consulte también

  • Last updated on