Contrôle d'accès à l'évaluation côté client Mise en route avec Lambda

Utilisation de l'évaluation côté client – optimisée par AWS AppConfig

Important

Avis de fin de support : le 16 octobre 2025, le support d' CloudWatch Evidently AWS sera interrompu. Après le 16 octobre 2025, vous ne pourrez plus accéder à la console Evidently ni aux ressources d'Evidently.

Vous pouvez utiliser l'évaluation côté client, alimentée par AWS AppConfig (évaluation côté client) dans un projet, qui permet à votre application d'attribuer des variations aux sessions utilisateur localement au lieu d'attribuer des variations en appelant l'opération. EvaluateFeature Cela permet d'atténuer les risques de latence et de disponibilité associés à un API appel.

Pour utiliser l'évaluation côté client, associez l'extension AWS AppConfig Lambda en tant que couche à vos fonctions Lambda et configurez les variables d'environnement. L'évaluation côté client s'exécute comme un processus secondaire sur l'hôte local. Ensuite, vous pouvez appeler les PutProjectEventopérations EvaluationFeatureet contrelocalhost. Le processus d'évaluation côté client gère l'affectation des variations, la mise en cache et la synchronisation des données. Pour plus d'informations AWS AppConfig, consultez la section AWS AppConfig Fonctionnement.

Lors de l'intégration à AWS AppConfig, vous spécifiez un ID d' AWS AppConfig application et un ID d' AWS AppConfig environnement à Evidently. Vous pouvez utiliser les mêmes ID d'application et d'environnement pour tous les projets Evidently.

Lorsque vous créez un projet avec l'évaluation côté client activée, Evidently crée un profil de AWS AppConfig configuration pour ce projet. Le profil de configuration de chaque projet sera différent.

Contrôle d'accès à l'évaluation côté client

L'évaluation côté client d'Evidently utilise un mécanisme de contrôle d'accès différent de celui du reste d'Evidently. Nous vous recommandons fortement de comprendre cela afin de pouvoir implémenter les mesures de sécurité appropriées.

Avec Evidently, vous pouvez créer des IAM politiques qui limitent les actions qu'un utilisateur peut effectuer sur des ressources individuelles. Par exemple, vous pouvez créer un rôle d'utilisateur qui interdit à un utilisateur d'effectuer cette EvaluateFeatureaction. Pour plus d'informations sur les actions Evidently qui peuvent être contrôlées par des IAM politiques, consultez Actions définies par Amazon CloudWatch Evidently.

Le modèle d'évaluation côté client permet des évaluations locales des fonctions Evidently qui utilisent des métadonnées du projet. Un utilisateur d'un projet dont l'évaluation côté client est activée peut appeler le EvaluateFeatureAPIpoint de terminaison d'un hôte local, mais cet API appel n'atteint pas Eviently et n'est pas authentifié par les politiques du service Eviently. IAM Cet appel est réussi même si l'utilisateur n'est pas IAM autorisé à utiliser l'EvaluateFeatureaction. Cependant, un utilisateur doit toujours être autorisé à PutProjectEventsautoriser l'agent à mettre en mémoire tampon les événements d'évaluation ou les événements personnalisés et à transférer les données vers Evidently de manière asynchrone.

En outre, un utilisateur doit disposer de l'autorisation evidently:ExportProjectAsConfiguration pour pouvoir créer un projet qui utilise l'évaluation côté client. Cela vous permet de contrôler l'accès aux EvaluateFeatureactions appelées lors de l'évaluation côté client.

Si vous ne faites pas attention, le modèle de sécurité de l'évaluation côté client peut contrecarrer les politiques que vous avez définies sur le reste d'Evidently. Un utilisateur evidently:ExportProjectAsConfiguration autorisé peut créer un projet avec l'évaluation côté client activée, puis utiliser l'EvaluateFeatureaction pour l'évaluation côté client avec ce projet, même si l'EvaluateFeatureaction lui est expressément refusée dans une politique. IAM

Mise en route avec Lambda

Evidently prend actuellement en charge l'évaluation côté client grâce à un environnement AWS Lambda . Pour commencer, déterminez d'abord l' AWS AppConfig application et l'environnement à utiliser. Choisissez une application et un environnement existants, ou créez-en de nouveaux.

Les exemples de AWS AppConfig AWS CLI commandes suivants permettent de créer une application et un environnement.


aws appconfig create-application --name YOUR_APP_NAME


aws appconfig create-environment --application-id YOUR_APP_ID --name YOUR_ENVIRONMENT_NAME

Ensuite, créez un projet Evidently en utilisant ces AWS AppConfig ressources. Pour de plus amples informations, veuillez consulter Création d'un nouveau projet..

L'évaluation côté client est prise en charge dans Lambda grâce à une couche Lambda. Il s'agit d'une couche publique qui fait partie AWS-AppConfig-Extension d'une AWS AppConfig extension publique créée par le AWS AppConfig service. Pour plus d'informations sur les couches Lambda, consultez Couche.

Pour utiliser l'évaluation côté client, vous devez ajouter cette couche à votre fonction Lambda et configurer les autorisations et les variables d'environnement.

Pour ajouter la couche Lambda d'évaluation côté client Evidently à votre fonction Lambda et la configurer

Créez une fonction Lambda si ce n'est pas déjà fait.
Ajoutez la couche d'évaluation côté client à votre fonction. Vous pouvez le spécifier ARN ou le sélectionner dans la liste des AWS couches si ce n'est pas déjà fait. Pour plus d'informations, consultez Configuration des fonctions pour utiliser des couches et Versions disponibles de l'extension AWS AppConfig Lambda.

Créez une IAM politique nommée EvidentlyAppConfigCachingAgentPolicyavec le contenu suivant et associez-la au rôle d'exécution de la fonction. Pour plus d'informations, consultez Rôle d'exécution Lambda.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": [
                "appconfig:GetLatestConfiguration",
                "appconfig:StartConfigurationSession",
                "evidently:PutProjectEvents"
            ],
            "Resource": "*"
        }
    ]
}

Ajoutez la variable d'environnement requise AWS_APPCONFIG_EXTENSION_EVIDENTLY_CONFIGURATIONS à votre fonction Lambda. Cette variable d'environnement spécifie le mappage entre le projet Evidently et les AWS AppConfig ressources.

Si vous utilisez cette fonction pour un seul projet Evidently, définissez la valeur de la variable d'environnement sur : applications/APP_ID/environments/ENVIRONMENT_ID/configurations/PROJECT_NAME

Si vous utilisez cette fonction pour plusieurs projets Evidently, utilisez une virgule pour séparer les valeurs, comme dans l'exemple suivant : applications/APP_ID_1/environments/ENVIRONMENT_ID_1/configurations/PROJECT_NAME_1, applications/APP_ID_2/environments/ENVIRONMENT_ID_2/configurations/PROJECT_NAME_2
(Facultatif) Définissez d'autres variables d'environnement. Pour plus d'informations, consultez Configuration de l'extension AWS AppConfig Lambda.

Dans votre application, obtenez localement les évaluations d'Evidently en envoyant EvaluateFeature à localhost.

Exemple Python :


import boto3
from botocore.config import Config
        
def lambda_handler(event, context):
    local_client = boto3.client(
        'evidently',
        endpoint_url="http://localhost:2772",
        config=Config(inject_host_prefix=False)
    )
    response = local_client.evaluate_feature(
        project=event['project'],
        feature=event['feature'],
        entityId=event['entityId']
    )
    print(response)

Exemple de module Node.js :


const AWS = require('aws-sdk');
const evidently = new AWS.Evidently({
    region: "us-west-2",
    endpoint: "http://localhost:2772",
    hostPrefixEnabled: false
});

exports.handler = async (event) => {
    
    const evaluation = await evidently.evaluateFeature({
        project: 'John_ETCProject_Aug2022',
        feature: 'Feature_IceCreamFlavors',
        entityId: 'John'
    }).promise()
    
    console.log(evaluation)
    const response = {
        statusCode: 200,
        body: evaluation,
    };
    return response;
};

Exemple en Kotlin :


String localhostEndpoint = "http://localhost:2772/"
public AmazonCloudWatchEvidentlyClient getEvidentlyLocalClient() {
    return AmazonCloudWatchEvidentlyClientBuilder.standard()
        .withEndpointConfiguration(AwsClientBuilder.EndpointConfiguration(localhostEndpoint, region))
        .withClientConfiguration(ClientConfiguration().withDisableHostPrefixInjection(true))
        .withCredentials(credentialsProvider)
        .build();
}

AmazonCloudWatchEvidentlyClient evidently = getEvidentlyLocalClient();

// EvaluateFeature via local client.
EvaluateFeatureRequest evaluateFeatureRequest = new EvaluateFeatureRequest().builder()
   .withProject(${YOUR_PROJECT}) //Required.
   .withFeature(${YOUR_FEATURE}) //Required.
   .withEntityId(${YOUR_ENTITY_ID}) //Required.
   .withEvaluationContext(${YOUR_EVAL_CONTEXT}) //Optional: a JSON object of attributes that you can optionally pass in as part of the evaluation event sent to Evidently.
   .build();
   
EvaluateFeatureResponse evaluateFeatureResponse = evidently.evaluateFeature(evaluateFeatureRequest);

// PutProjectEvents via local client. 
PutProjectEventsRequest putProjectEventsRequest = new PutProjectEventsRequest().builder()
    .withData(${YOUR_DATA})
    .withTimeStamp(${YOUR_TIMESTAMP})
    .withType(${YOUR_TYPE})
    .build();
    
PutProjectEvents putProjectEventsResponse = evidently.putProjectEvents(putProjectEventsRequest);

Configuration de la fréquence à laquelle le client envoie des données à Evidently

Pour spécifier la fréquence à laquelle l'évaluation côté client envoie des données à Evidently, vous pouvez configurer deux variables d'environnement.

AWS_APPCONFIG_EXTENSION_EVIDENTLY_EVENT_BATCH_SIZE spécifie le nombre d'événements par projet à regrouper avant de les envoyer à Evidently. Les valeurs valides sont des nombres entiers compris entre 1 et 50, la valeur par défaut étant 40.
AWS_APPCONFIG_EXTENSION_EVIDENTLY_BATCH_COLLECTION_DURATION spécifie la durée en secondes pour attendre les événements avant de les envoyer à Evidently. La valeur par défaut est 30.

Résolution des problèmes

Utilisez les informations suivantes pour résoudre les problèmes liés à l'utilisation d' CloudWatchEvidently avec une évaluation côté client - optimisée par. AWS AppConfig

Une erreur s'est produite (BadRequestException) lors de l'appel de l' EvaluateFeature opération : HTTP méthode non prise en charge pour le chemin fourni

Vos variables d'environnement sont peut-être mal configurées. Par exemple, vous avez peut-être utilisé EVIDENTLY_CONFIGURATIONS comme nom de variable d'environnement au lieu de AWS_APPCONFIG_EXTENSION_EVIDENTLY_CONFIGURATIONS.

ResourceNotFoundException: Déploiement introuvable

Votre mise à jour des métadonnées du projet n'a pas été déployée sur AWS AppConfig. Vérifiez s'il s'agit d'un déploiement actif dans l' AWS AppConfig environnement que vous avez utilisé pour l'évaluation côté client.

ValidationException: Aucune configuration évidente pour le projet

Votre variable d'environnement AWS_APPCONFIG_EXTENSION_EVIDENTLY_CONFIGURATIONS est peut-être configurée avec un nom de projet incorrect.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Création d'un nouveau projet.

Ajouter une fonction à un projet