Tutoriel : Création d'RESTAPIune intégration Lambda sans proxy

Dans cette présentation, nous utilisons la console API Gateway pour créer un système API qui permet à un client d'appeler des fonctions Lambda via l'intégration Lambda sans proxy (également connue sous le nom d'intégration personnalisée). Pour en savoir plus sur AWS Lambda et les fonctions Lambda, veuillez consulter le Guide du développeur AWS Lambda.

Pour faciliter l'apprentissage, nous avons choisi une fonction Lambda simple avec une API configuration minimale pour vous guider à travers les étapes de création d'une API passerelle API avec l'intégration personnalisée Lambda. Lorsque nécessaire, nous décrivons un aspect de la logique. Pour un exemple plus détaillé de l'intégration personnalisée Lambda, veuillez consulter Tutoriel : Création d'une calculatrice REST API avec deux intégrations AWS de services et une intégration Lambda sans proxy.

Avant de créer leAPI, configurez le backend Lambda en créant une fonction Lambda dans, comme décrit ci-dessous. AWS Lambda

Création d'une fonction Lambda pour l'intégration non proxy Lambda

Note

La création de fonctions Lambda peut entraîner des frais sur votre AWS compte.

Au cours de cette étape, vous allez créer une fonction Lambda de type « Hello, World ! » pour l'intégration Lambda personnalisée. Tout au long de cette procédure, la fonction est appelée GetStartedLambdaIntegration.

La mise en œuvre de cette fonction Lambda GetStartedLambdaIntegration est la suivante :

Node.js

'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];            
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];

console.log('Loading function');

export const handler = function(event, context, callback) {
  // Parse the input for the name, city, time and day property values
  let name = event.name === undefined ? 'you' : event.name;
  let city = event.city === undefined ? 'World' : event.city;
  let time = times.indexOf(event.time)<0 ? 'day' : event.time;
  let day = days.indexOf(event.day)<0 ? null : event.day;

  // Generate a greeting
  let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
  if (day) greeting += 'Happy ' + day + '!';
  
  // Log the greeting to CloudWatch
  console.log('Hello: ', greeting);
  
  // Return a greeting to the caller
  callback(null, {
      "greeting": greeting
  }); 
};

Python

import json

days = {
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}


def lambda_handler(event, context):
    print(event)
    # parse the input for the name, city, time, and day property values
    try:
        if event['name']:
            name = event['name']
    except KeyError:
        name = 'you'
    try:
        if event['city']:
            city = event['city']
    except KeyError:
        city = 'World'
    try:
        if event['time'] in times:
            time = event['time']
        else:
            time = 'day'
    except KeyError:
        time = 'day'
    try:
        if event['day'] in days:
            day = event['day']
        else:
            day = ''
    except KeyError:
        day = ''
    # Generate a greeting
    greeting = 'Good ' + time + ', ' + name + ' of ' + \
        city + '.' + ['', ' Happy ' + day + '!'][day != '']
    # Log the greeting to CloudWatch
    print(greeting)

    # Return a greeting to the caller
    return {"greeting": greeting}

Pour l'intégration personnalisée Lambda, API Gateway transmet l'entrée du client à la fonction Lambda en tant que corps de la demande d'intégration. L'objet event du gestionnaire de la fonction Lambda correspond à l'entrée.

Notre fonction Lambda est simple. Elle analyse l'objet event en entrée par rapport aux propriétés name, city, time et day. Il renvoie ensuite un message d'accueil, sous forme d'JSONobjet de{"message":greeting}, à l'appelant. Le message suit le modèle "Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!". On suppose que l'entrée de la fonction Lambda correspond à l'objet suivant : JSON

{
  "city": "...",
  "time": "...",
  "day": "...",
  "name" : "..."
}

Pour plus d’informations, consultez le Guide du développeur AWS Lambda.

En outre, la fonction enregistre son exécution sur Amazon CloudWatch en appelantconsole.log(...). Cet aspect est précieux pour suivre les appels lors du débogage de la fonction. Pour permettre à la GetStartedLambdaIntegration fonction d'enregistrer l'appel, définissez un IAM rôle avec des politiques appropriées pour que la fonction Lambda crée les CloudWatch flux et ajoute des entrées de journal aux flux. La console Lambda vous guide tout au long de la création des IAM rôles et politiques requis.

Si vous configurez le API sans utiliser la console API Gateway, par exemple lors de l'importation API d'un API fichier ouvert, vous devez explicitement créer, si nécessaire, et configurer un rôle et une politique d'appel permettant à API Gateway d'invoquer les fonctions Lambda. Pour plus d'informations sur la façon de configurer les rôles d'invocation et d'exécution Lambda pour une API passerelleAPI, consultez. Contrôler l'accès à un REST API avec des IAM autorisations

Par rapport à GetStartedLambdaProxyIntegration la fonction Lambda pour l'intégration du proxy Lambda, la fonction Lambda pour l'intégration personnalisée GetStartedLambdaIntegration Lambda ne prend en compte que les entrées du corps de la demande d'intégration de Gateway. API API La fonction peut renvoyer la sortie de n'importe quel JSON objet, d'une chaîne, d'un nombre, d'un booléen ou même d'un blob binaire. La fonction Lambda pour l'intégration du proxy Lambda, en revanche, peut prendre l'entrée de n'importe quelle donnée de demande, mais doit renvoyer une sortie d'un objet particulier. JSON La GetStartedLambdaIntegration fonction d'intégration personnalisée Lambda peut avoir les paramètres de API demande en entrée, à condition que API Gateway mappe les paramètres de API demande requis au corps de la demande d'intégration avant de transmettre la demande du client au backend. Pour ce faire, le API développeur doit créer un modèle de mappage et le configurer selon la API méthode lors de la création duAPI.

Maintenant, créez la fonction Lambda GetStartedLambdaIntegration.

Pour créer la fonction Lambda GetStartedLambdaIntegration pour l'intégration personnalisée Lambda

1. Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.

2. Effectuez l’une des actions suivantes :

   • Si la page de bienvenue s'affiche, choisissez Get Started Now (Commencer maintenant) puis Create function (Créer une fonction).

   • Si la liste Lambda > Functions (Fonctions) apparaît, choisissez Create function (Créer une fonction).

3. Choisissez Créer à partir de zéro.

4. Dans le volet Author from scratch (Créer à partir de zéro), procédez comme suit :

   1. Dans Name (Nom), entrez GetStartedLambdaIntegration comme nom de la fonction Lambda.

   2. Pour Exécution, choisissez le dernier environnement d’exécution Node.js ou Python compatible.

   3. Pour Architecture, conservez le paramètre par défaut.

   4. Sous Permissions (Autorisations), développez Change default execution role (Modifier le rôle d'exécution par défaut). Dans la liste déroulante Rôle d’exécution, choisissez Créer un nouveau rôle à partir de modèles de stratégie AWS .

   5. Pour Role name (Nom du rôle), indiquez le nom de votre rôle, par exemple GetStartedLambdaIntegrationRole.

   6. Pour Policy templates (Modèles de stratégie), choisissez Simple microservice permissions (Autorisations Microservice simples).

   7. Sélectionnez Create function (Créer une fonction).

5. Dans le volet Configure function (Configurer la fonction), sous Function code (Code de la fonction), suivez les étapes suivantes :

   1. Copiez le code de la fonction Lambda affiché au début de cette section et collez-le dans l'éditeur de code en ligne.

   2. Acceptez les choix par défaut pour tous les autres champs de cette section.

   3. Choisissez Deploy (Déployer).

6. Pour tester la fonction nouvellement créée, cliquez sur l’onglet Test.

   1. Dans Event name (Nom de l’événement), saisissez HelloWorldTest.

   2. Pour Event JSON, remplacez le code par défaut par le code suivant.

      {
        "name": "Jonny",
        "city": "Seattle",
        "time": "morning",
        "day": "Wednesday"
      }

   3. Sélectionnez Test pour appeler la fonction. La section Execution result: succeeded s'affiche. Développez Détails pour voir la sortie suivante.

      {
          "greeting": "Good morning, Jonny of Seattle. Happy Wednesday!"
      }

      La sortie est également écrite dans CloudWatch Logs.

En guise d'exercice parallèle, vous pouvez utiliser la IAM console pour afficher le IAM rôle (GetStartedLambdaIntegrationRole) créé dans le cadre de la création de la fonction Lambda. Deux politiques intégrées sont associées à ce IAM rôle. L'une stipule les autorisations les plus élémentaires pour l'exécution Lambda. Cela permet d'appeler toutes CloudWatch CreateLogGroup les CloudWatch ressources de votre compte dans la région où la fonction Lambda est créée. Cette politique permet également de créer les CloudWatch flux et de consigner les événements pour la fonction GetStartedLambdaIntegration Lambda.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:region:account-id:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:region:account-id:log-group:/aws/lambda/GetStartedLambdaIntegration:*"
            ]
        }
    ]
}

L'autre document de politique s'applique à l'appel d'un autre AWS service qui n'est pas utilisé dans cet exemple. Vous pouvez l'ignorer pour l'instant.

Une entité de confiance est associée au IAM rôle, c'est-à-direlambda.amazonaws.com. Voici la relation d'approbation :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

La combinaison de cette relation de confiance et de la politique intégrée permet à la fonction Lambda d'appeler console.log() une fonction pour consigner les événements CloudWatch dans Logs.

Création d'une intégration API sans proxy avec Lambda

Une fois la fonction Lambda (GetStartedLambdaIntegration) créée et testée, vous êtes prêt à exposer la fonction via une API passerelle. API À des fins d'illustration, nous exposons la fonction Lambda avec une méthode génériqueHTTP. Nous utilisons le corps de la requête, une variable de URL chemin, une chaîne de requête et un en-tête pour recevoir les données d'entrée requises du client. Nous activons le validateur de demandes API Gateway pour nous assurer que toutes les données requises sont correctement définies et spécifiées. API Nous configurons un modèle de mappage pour API Gateway afin de transformer les données de demande fournies par le client dans le format valide requis par la fonction Lambda du backend.

Pour créer un API avec une intégration Lambda sans proxy

1. Connectez-vous à la console API Gateway à l'adresse https://console.aws.amazon.com/apigateway.

2. Si c'est la première fois que vous utilisez API Gateway, une page vous présentant les fonctionnalités du service s'affiche. Sous RESTAPI, choisissez Build. Lorsque la API fenêtre contextuelle Create Example apparaît, cliquez sur OK.

   Si ce n'est pas la première fois que vous utilisez API Gateway, choisissez Create API. Sous RESTAPI, choisissez Build.

3. Pour APIle nom, entrezLambdaNonProxyAPI.

4. (Facultatif) Sous Description, entrez une description.

5. Conservez le type de API point de terminaison défini sur Régional.

6. Choisissez Create API.

Après avoir créé votreAPI, vous créez une ressource/{city}. Ceci est un exemple de ressource avec une variable de chemin qui accepte une entrée du client. Par la suite, vous mapperez cette variable de chemin avec l’entrée de la fonction Lambda à l’aide d’un modèle de mappage.

Pour créer une ressource

1. Choisissez Créer une ressource.

2. Maintenez Ressource proxy désactivée.

3. Conservez Chemin de la ressource sous la forme /.

4. Sous Resource Name (Nom de la ressource), entrez {city}.

5. Maintenez CORS(Cross Origin Resource Sharing) désactivé.

6. Choisissez Créer une ressource.

Après avoir créé votre ressource /{city}, vous créez une méthode ANY. Le ANY HTTP verbe est un espace réservé pour une HTTP méthode valide soumise par un client au moment de l'exécution. Cet exemple montre que la méthode ANY peut être utilisée pour l'intégration personnalisée Lambda aussi bien que pour l'intégration de proxy Lambda.

Pour créer une méthode ANY

1. Sélectionnez la ressource /{city}, puis choisissez Créer une méthode.

2. Pour Type de méthode, sélectionnez ANY.

3. Pour Type d'intégration, sélectionnez Fonction Lambda.

4. Maintenez Intégration proxy Lambda désactivée.

5. Pour la fonction Lambda, sélectionnez l' Région AWS endroit où vous avez créé votre fonction Lambda, puis entrez le nom de la fonction.

6. Choisissez les paramètres de demande de méthode.

   À présent, vous activez un validateur de demande pour une variable de URL chemin, un paramètre de chaîne de requête et un en-tête afin de vous assurer que toutes les données requises sont définies. Dans cet exemple, vous créez un paramètre de chaîne de requête time et un en-tête day.

7. Pour Validateur de requête, sélectionnez Valider les paramètres de chaîne de requête et les en-têtes.

8. Choisissez les paramètres de la chaîne de URL requête et procédez comme suit :

   1. Sélectionnez Add query string (Ajouter une chaîne de requêtes).

   2. Pour Name (Nom), saisissez time.

   3. Activez Obligatoire.

   4. Maintenez Mise en cache désactivée.

9. Choisissez les en-têtes de HTTP demande et procédez comme suit :

   1. Sélectionnez Add header.

   2. Pour Name (Nom), saisissez day.

   3. Activez Obligatoire.

   4. Maintenez Mise en cache désactivée.

10. Choisissez Créer une méthode.

Après avoir activé un validateur de demande, vous configurez la demande d'intégration pour la ANY méthode en ajoutant un modèle de mappage corporel pour transformer la demande entrante en JSON charge utile, comme l'exige la fonction Lambda du backend.

Pour configurer la requête d’intégration

1. Dans l'onglet Demande d'intégration, sous les paramètres de la demande d'intégration, choisissez Modifier.

2. Pour Transmission du corps de requête, sélectionnez Lorsqu’aucun modèle n’est défini (recommandé).

3. Choisissez Modèles de mappage.

4. Sélectionnez Add mapping template.

5. Pour Type de contenu, entrez application/json.

6. Pour Corps du modèle, entrez le code suivant :

   #set($inputRoot = $input.path('$'))
   {
     "city": "$input.params('city')",
     "time": "$input.params('time')",
     "day":  "$input.params('day')",
     "name": "$inputRoot.callerName"
   }

7. Choisissez Save (Enregistrer).

Test en invoquant la méthode API

La console API Gateway fournit une fonctionnalité de test vous permettant de tester l'invocation du API avant son déploiement. Vous utilisez la fonctionnalité Test de la console pour tester le API en soumettant la demande suivante :

POST /Seattle?time=morning
day:Wednesday

{
    "callerName": "John"
}

Dans cette demande de test, vous allez définir ANY sur POST et {city} sur Seattle, attribuer Wednesday comme valeur de l'en-tête day et attribuer "John" comme valeur de callerName.

Pour tester la méthode ANY

1. Choisissez l’onglet Test. Vous devrez peut-être choisir la flèche droite pour afficher l'onglet.

2. Pour Type de méthode, sélectionnez POST.

3. Pour Chemin, sous city, entrez Seattle.

4. Pour Chaînes de requête, saisissez time=morning.

5. Pour En-têtes, saisissez day:Wednesday.

6. Pour Corps de la requête, saisissez { "callerName": "John" }.

7. Sélectionnez Test.

Vérifiez que la charge utile de la réponse retournée se présente comme suit :

{
  "greeting": "Good morning, John of Seattle. Happy Wednesday!"
}

Vous pouvez également consulter les journaux pour examiner la manière dont API Gateway traite la demande et la réponse.

Execution log for request test-request
Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations: { "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-tag=test-request, Authorization=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid, X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs++ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
  "city": "Seattle",
  "time": "morning",
  "day": "Wednesday",
  "name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200

Les journaux présentent la demande entrante avant le mappage et la demande d'intégration après le mappage. Lorsqu'un test échoue, les journaux sont utiles pour évaluer si l'entrée d'origine est correcte ou si le modèle de mappage fonctionne correctement.

Déployez le API

L'appel du test est une simulation et possède ses limites. Par exemple, il contourne tout mécanisme d'autorisation mis en œuvre sur leAPI. Pour tester l'APIexécution en temps réel, vous devez déployer le API premier. Pour déployer unAPI, vous créez une étape pour créer un instantané du API à ce moment-là. Le nom de la scène définit également le chemin de base après le nom API d'hôte par défaut du. La ressource racine API est ajoutée après le nom de l'étape. Lorsque vous modifiez leAPI, vous devez le redéployer vers un stage nouveau ou existant avant que les modifications ne prennent effet.

Pour déployer le API sur une scène

1. Choisissez DeployAPI (Déployer).

2. Pour Étape, sélectionnez Nouvelle étape.

3. Sous Stage name (Nom de l'étape), entrez test.

   Note

   L'entrée doit être du texte codé en UTF -8 (c'est-à-dire non localisé).

4. (Facultatif) Sous Description, entrez une description.

5. Choisissez Deploy (Déployer).

Sous Détails de l'étape, cliquez sur l'icône de copie pour copier votre API appelURL. Le schéma général de API la base URL esthttps://api-id.region.amazonaws.com/stageName. Par exemple, la base URL du API (beags1mnid) créé dans la us-west-2 région et déployé sur la test scène esthttps://beags1mnid.execute-api.us-west-2.amazonaws.com/test.

Testez le API lors d'une phase de déploiement

Vous pouvez tester un déploiement de plusieurs manièresAPI. Pour les GET demandes utilisant uniquement des variables de URL chemin ou des paramètres de chaîne de requête, vous pouvez saisir la API ressource URL dans un navigateur. Pour les autres méthodes, vous devez utiliser des utilitaires de REST API test plus avancés, tels que POSTMANou URLc.

Pour tester l'APIutilisation de c URL

1. Ouvrez une fenêtre de terminal sur votre ordinateur local connecté à Internet.

2. Pour tester POST /Seattle?time=evening:

   Copiez la URL commande c suivante et collez-la dans la fenêtre du terminal.

   curl -v -X POST \
     'https://beags1mnid.execute-api.us-west-2.amazonaws.com/test/Seattle?time=evening' \
     -H 'content-type: application/json' \
     -H 'day: Thursday' \
     -H 'x-amz-docs-region: us-west-2' \
     -d '{
   	"callerName": "John"
   }'

   Vous devriez obtenir une réponse positive avec la charge utile suivante :

   {"greeting":"Good evening, John of Seattle. Happy Thursday!"}

   Si vous modifiez POST en PUT dans la demande de cette méthode, vous obtenez la même réponse.

Nettoyage

Si vous n'avez plus besoin des fonctions Lambda que vous avez créées pour cette procédure, vous pouvez maintenant les supprimer. Vous pouvez également supprimer les IAM ressources associées.

Avertissement

Si vous avez l'intention d'effectuer les autres procédures de cette série, ne supprimez pas le rôle d'exécution Lambda, ni le rôle d'appel Lambda. Si vous supprimez une fonction Lambda sur laquelle vous APIs comptez, elle ne APIs fonctionnera plus. La suppression d'une fonction Lambda ne peut pas être annulée. Si vous souhaitez utiliser à nouveau cette fonction Lambda, vous devez la recréer.

Si vous supprimez une IAM ressource sur laquelle repose une fonction Lambda, cette fonction Lambda ne fonctionnera plus, et toutes celles APIs qui s'appuient sur cette fonction ne fonctionneront plus. La suppression d'une IAM ressource ne peut pas être annulée. Si vous souhaitez réutiliser la IAM ressource, vous devez la recréer.

Pour supprimer la fonction Lambda

1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/lambda/.

2. Dans la liste des fonctions GetStartedLambdaIntegration, choisissez Actions, puis sélectionnez Supprimer la fonction. A l'invite, sélectionnez à nouveau Delete.

Pour supprimer les ressources IAM associées

1. Ouvrez la IAM console à l'adresse https://console.aws.amazon.com/iam/.

2. Dans le volet Details, sélectionnez Roles.

3. Dans la liste des rôles GetStartedLambdaIntegrationRole, choisissez Actions de rôle, puis choisissez Supprimer le rôle. Suivez les étapes indiquées dans la console pour supprimer le rôle.