Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Étape 1 : configurer votre infrastructure Cette rubrique explique comment créer des fichiers AWS SAM pour votre AWS SAM modèle et vos fonctions Lambda. Ensuite, vous utilisez les `deploy` commandes AWS SAM `package` et pour générer les composants de votre infrastructure. Lorsque votre infrastructure est prête, vous disposez d'une CodeDeploy application et d'un groupe de déploiement, de la fonction Lambda à mettre à jour et à déployer, et de deux fonctions Lambda contenant des tests de validation exécutés lorsque vous déployez la fonction Lambda. Lorsque vous avez terminé, vous pouvez l'utiliser CloudFormation pour afficher vos composants dans la console Lambda ou AWS CLI pour tester votre fonction Lambda. **Topics** + [Créez vos fichiers](tutorial-lambda-create-files.md) + [Package de l'application AWS SAM](tutorial-lambda-sam-package.md) + [Déployer l'application AWS SAM](tutorial-lambda-sam-deploy.md) + [(Facultatif) inspectez et testez votre infrastructure](tutorial-lambda-sam-confirm-components.md) # Créez vos fichiers Pour créer votre infrastructure, vous devez créer les fichiers suivants : + `template.yml` + `myDateTimeFunction.js` + `beforeAllowTraffic.js` + `afterAllowTraffic.js` **Topics** + [Créez votre modèle AWS SAM](tutorial-lambda-sam-template.md) + [Créez un fichier pour votre fonction Lambda](tutorial-lambda-sam-create-lambda-function.md) + [Créez un fichier pour votre fonction BeforeAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-before-traffic.md) + [Créez un fichier pour votre fonction AfterAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-after-traffic.md) # Créez votre modèle AWS SAM Créez un fichier modèle AWS SAM qui spécifie les composants de votre infrastructure. **Pour créer votre modèle AWS SAM** 1. Créez un répertoire nommé `SAM-Tutorial`. 1. Dans votre répertoire `SAM-Tutorial`, créez un fichier nommé `template.yml`. 1. Copiez le code YAML suivant dans `template.yml`. Il s'agit de votre modèle AWS SAM . ``` AWSTemplateFormatVersion : '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: A sample SAM template for deploying Lambda functions. Resources: # Details about the myDateTimeFunction Lambda function myDateTimeFunction: Type: AWS::Serverless::Function Properties: Handler: myDateTimeFunction.handler Runtime: nodejs18.x # Instructs your myDateTimeFunction is published to an alias named "live". AutoPublishAlias: live # Grants this function permission to call lambda:InvokeFunction Policies: - Version: "2012-10-17" Statement: - Effect: "Allow" Action: - "lambda:InvokeFunction" Resource: '*' DeploymentPreference: # Specifies the deployment configuration Type: Linear10PercentEvery1Minute # Specifies Lambda functions for deployment lifecycle hooks Hooks: PreTraffic: !Ref beforeAllowTraffic PostTraffic: !Ref afterAllowTraffic # Specifies the BeforeAllowTraffic lifecycle hook Lambda function beforeAllowTraffic: Type: AWS::Serverless::Function Properties: Handler: beforeAllowTraffic.handler Policies: - Version: "2012-10-17" # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus Statement: - Effect: "Allow" Action: - "codedeploy:PutLifecycleEventHookExecutionStatus" Resource: !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*' - Version: "2012-10-17" # Grants this function permission to call lambda:InvokeFunction Statement: - Effect: "Allow" Action: - "lambda:InvokeFunction" Resource: !Ref myDateTimeFunction.Version Runtime: nodejs18.x # Specifies the name of the Lambda hook function FunctionName: 'CodeDeployHook_beforeAllowTraffic' DeploymentPreference: Enabled: false Timeout: 5 Environment: Variables: NewVersion: !Ref myDateTimeFunction.Version # Specifies the AfterAllowTraffic lifecycle hook Lambda function afterAllowTraffic: Type: AWS::Serverless::Function Properties: Handler: afterAllowTraffic.handler Policies: - Version: "2012-10-17" Statement: # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus - Effect: "Allow" Action: - "codedeploy:PutLifecycleEventHookExecutionStatus" Resource: !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*' - Version: "2012-10-17" Statement: # Grants this function permission to call lambda:InvokeFunction - Effect: "Allow" Action: - "lambda:InvokeFunction" Resource: !Ref myDateTimeFunction.Version Runtime: nodejs18.x # Specifies the name of the Lambda hook function FunctionName: 'CodeDeployHook_afterAllowTraffic' DeploymentPreference: Enabled: false Timeout: 5 Environment: Variables: NewVersion: !Ref myDateTimeFunction.Version ``` Ce modèle spécifie les éléments suivants. Pour plus d'informations, consultez la section [Concepts des AWS SAM modèles](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html). **Une fonction Lambda appelée `myDateTimeFunction`** Lorsque cette fonction Lambda est publiée, la `AutoPublishAlias` ligne du modèle la lie à un alias nommé. `live` Plus loin dans ce didacticiel, une mise à jour de cette fonction déclenche un déploiement AWS CodeDeploy qui déplace progressivement le trafic de production de la version d'origine vers la version mise à jour. **Deux fonctions de validation du déploiement Lambda** Les fonctions Lambda suivantes sont exécutées pendant les hooks CodeDeploy du cycle de vie. Ces fonctions contiennent du code qui valide le déploiement de la fonction `myDateTimeFunction` mise à jour. Le résultat des tests de validation est transmis à CodeDeploy à l'aide de sa méthode d'API `PutLifecycleEventHookExecutionStatus`. Si un test de validation échoue, le déploiement échoue et est annulé. + `CodeDeployHook_beforeAllowTraffic` s'exécute pendant le hook `BeforeAllowTraffic`. + `CodeDeployHook_afterAllowTraffic` s'exécute pendant le hook `AfterAllowTraffic`. Le nom des deux fonctions commence par `CodeDeployHook_`. Le `CodeDeployRoleForLambda` rôle autorise les appels à la `invoke` méthode Lambda uniquement dans les fonctions Lambda dont le nom commence par ce préfixe. Pour plus d'informations, veuillez consulter les sections [AppSpec section « hooks » pour un déploiement AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda) et [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html) (français non garanti) de la *Référence d'API CodeDeploy *. **Détection automatique d'une fonction Lambda mise à jour** Le terme `AutoPublishAlias` indique au cadre de détecter quand la fonction `myDateTimeFunction` change, puis de la déployer à l'aide de l'alias `live`. **Une configuration de déploiement** La configuration de déploiement détermine la vitesse à laquelle votre CodeDeploy application déplace le trafic de la version d'origine de la fonction Lambda vers la nouvelle version. Ce modèle spécifie la configuration de déploiement prédéfinie `Linear10PercentEvery1Minute`. Vous ne pouvez pas spécifier de configuration de déploiement personnalisée dans un modèle AWS SAM. Pour de plus amples informations, veuillez consulter [Créez une configuration de déploiement avec CodeDeploy](deployment-configurations-create.md). **Fonctions de hook de cycle de vie de déploiement** La section `Hooks` spécifie les fonctions à exécuter pendant les hooks d'événement de cycle de vie. `PreTraffic` spécifie la fonction qui s'exécute pendant le hook `BeforeAllowTraffic`. `PostTraffic` spécifie la fonction qui s'exécute pendant le hook `AfterAllowTraffic`. **Autorisations permettant à Lambda d'appeler une autre fonction Lambda** L'`lambda:InvokeFunction`autorisation spécifiée accorde au rôle utilisé par l'application AWS SAM l'autorisation d'appeler une fonction Lambda. Cela est nécessaire lorsque les `CodeDeployHook_afterAllowTraffic` fonctions `CodeDeployHook_beforeAllowTraffic` et invoquent la fonction Lambda déployée lors des tests de validation. # Créez un fichier pour votre fonction Lambda Créez le fichier pour la fonction que vous mettrez à jour et déploierez ultérieurement dans ce didacticiel. **Note** Une fonction Lambda peut utiliser n'importe quel environnement d'exécution pris en charge par. AWS Lambda Pour plus d'informations, consultez [Environnement d'exécution AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). **Pour créer votre fonction Lambda** 1. Créez un fichier texte et enregistrez-le sous le nom `myDateTimeFunction.js` dans le répertoire `SAM-Tutorial`. 1. Copiez le code Node.js suivant dans `myDateTimeFunction.js`. ``` 'use strict'; exports.handler = function(event, context, callback) { if (event.body) { event = JSON.parse(event.body); } var sc; // Status code var result = ""; // Response payload switch(event.option) { case "date": switch(event.period) { case "yesterday": result = setDateResult("yesterday"); sc = 200; break; case "today": result = setDateResult(); sc = 200; break; case "tomorrow": result = setDateResult("tomorrow"); sc = 200; break; default: result = { "error": "Must specify 'yesterday', 'today', or 'tomorrow'." }; sc = 400; break; } break; /* Later in this tutorial, you update this function by uncommenting this section. The framework created by AWS SAM detects the update and triggers a deployment by CodeDeploy. The deployment shifts production traffic to the updated version of this function. case "time": var d = new Date(); var h = d.getHours(); var mi = d.getMinutes(); var s = d.getSeconds(); result = { "hour": h, "minute": mi, "second": s }; sc = 200; break; */ default: result = { "error": "Must specify 'date' or 'time'." }; sc = 400; break; } const response = { statusCode: sc, headers: { "Content-type": "application/json" }, body: JSON.stringify( result ) }; callback(null, response); function setDateResult(option) { var d = new Date(); // Today var mo; // Month var da; // Day var y; // Year switch(option) { case "yesterday": d.setDate(d.getDate() - 1); break; case "tomorrow": d.setDate(d.getDate() + 1); default: break; } mo = d.getMonth() + 1; // Months are zero offset (0-11) da = d.getDate(); y = d.getFullYear(); result = { "month": mo, "day": da, "year": y }; return result; } }; ``` La fonction Lambda renvoie le jour, le mois et l'année pour hier, aujourd'hui ou demain. Plus loin dans ce didacticiel, vous annulerez la mise en commentaire du code qui met à jour la fonction pour renvoyer des informations sur le jour ou l'heure que vous spécifiez (par exemple, le jour, le mois et l'année, ou l'heure, la minute et la seconde actuelles). Le framework créé par AWS SAM détecte et déploie la version mise à jour de la fonction. **Note** Cette fonction Lambda est également utilisée dans un AWS Cloud9 didacticiel. AWS Cloud9 est un environnement de développement intégré basé sur le cloud. Pour plus d'informations sur la création, l'exécution, la mise à jour et le débogage de cette fonction dans AWS Cloud9, consultez le [AWS Lambda didacticiel pour AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial-lambda.html). # Créez un fichier pour votre fonction BeforeAllowTraffic Lambda Créez le fichier pour la fonction Lambda de votre `beforeAllowTraffic` hook. 1. Créez un fichier texte et enregistrez-le sous le nom `beforeAllowTraffic.js` dans le répertoire `SAM-Tutorial`. 1. Copiez le code Node.js suivant dans `beforeAllowTraffic.js`. Cette fonction s'exécute pendant le hook `BeforeAllowTraffic` de votre déploiement. ``` 'use strict'; const AWS = require('aws-sdk'); const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'}); var lambda = new AWS.Lambda(); exports.handler = (event, context, callback) => { console.log("Entering PreTraffic Hook!"); // Read the DeploymentId and LifecycleEventHookExecutionId from the event payload var deploymentId = event.DeploymentId; var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId; var functionToTest = process.env.NewVersion; console.log("BeforeAllowTraffic hook tests started"); console.log("Testing new function version: " + functionToTest); // Create parameters to pass to the updated Lambda function that // include the newly added "time" option. If the function did not // update, then the "time" option is invalid and function returns // a statusCode of 400 indicating it failed. var lambdaParams = { FunctionName: functionToTest, Payload: "{\"option\": \"time\"}", InvocationType: "RequestResponse" }; var lambdaResult = "Failed"; // Invoke the updated Lambda function. lambda.invoke(lambdaParams, function(err, data) { if (err){ // an error occurred console.log(err, err.stack); lambdaResult = "Failed"; } else{ // successful response var result = JSON.parse(data.Payload); console.log("Result: " + JSON.stringify(result)); console.log("statusCode: " + result.statusCode); // Check if the status code returned by the updated // function is 400. If it is, then it failed. If // is not, then it succeeded. if (result.statusCode != "400"){ console.log("Validation succeeded"); lambdaResult = "Succeeded"; } else { console.log("Validation failed"); } // Complete the PreTraffic Hook by sending CodeDeploy the validation status var params = { deploymentId: deploymentId, lifecycleEventHookExecutionId: lifecycleEventHookExecutionId, status: lambdaResult // status can be 'Succeeded' or 'Failed' }; // Pass CodeDeploy the prepared validation test results. codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) { if (err) { // Validation failed. console.log("CodeDeploy Status update failed"); console.log(err, err.stack); callback("CodeDeploy Status update failed"); } else { // Validation succeeded. console.log("CodeDeploy status updated successfully"); callback(null, "CodeDeploy status updated successfully"); } }); } }); } ``` # Créez un fichier pour votre fonction AfterAllowTraffic Lambda Créez le fichier pour la fonction Lambda de votre `afterAllowTraffic` hook. 1. Créez un fichier texte et enregistrez-le sous le nom `afterAllowTraffic.js` dans le répertoire `SAM-Tutorial`. 1. Copiez le code Node.js suivant dans `afterAllowTraffic.js`. Cette fonction s'exécute pendant le hook `AfterAllowTraffic` de votre déploiement. ``` 'use strict'; const AWS = require('aws-sdk'); const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'}); var lambda = new AWS.Lambda(); exports.handler = (event, context, callback) => { console.log("Entering PostTraffic Hook!"); // Read the DeploymentId and LifecycleEventHookExecutionId from the event payload var deploymentId = event.DeploymentId; var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId; var functionToTest = process.env.NewVersion; console.log("AfterAllowTraffic hook tests started"); console.log("Testing new function version: " + functionToTest); // Create parameters to pass to the updated Lambda function that // include the original "date" parameter. If the function did not // update as expected, then the "date" option might be invalid. If // the parameter is invalid, the function returns // a statusCode of 400 indicating it failed. var lambdaParams = { FunctionName: functionToTest, Payload: "{\"option\": \"date\", \"period\": \"today\"}", InvocationType: "RequestResponse" }; var lambdaResult = "Failed"; // Invoke the updated Lambda function. lambda.invoke(lambdaParams, function(err, data) { if (err){ // an error occurred console.log(err, err.stack); lambdaResult = "Failed"; } else{ // successful response var result = JSON.parse(data.Payload); console.log("Result: " + JSON.stringify(result)); console.log("statusCode: " + result.statusCode); // Check if the status code returned by the updated // function is 400. If it is, then it failed. If // is not, then it succeeded. if (result.statusCode != "400"){ console.log("Validation of time parameter succeeded"); lambdaResult = "Succeeded"; } else { console.log("Validation failed"); } // Complete the PostTraffic Hook by sending CodeDeploy the validation status var params = { deploymentId: deploymentId, lifecycleEventHookExecutionId: lifecycleEventHookExecutionId, status: lambdaResult // status can be 'Succeeded' or 'Failed' }; // Pass CodeDeploy the prepared validation test results. codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) { if (err) { // Validation failed. console.log("CodeDeploy Status update failed"); console.log(err, err.stack); callback("CodeDeploy Status update failed"); } else { // Validation succeeded. console.log("CodeDeploy status updated successfully"); callback(null, "CodeDeploy status updated successfully"); } }); } }); } ``` # Package de l'application AWS SAM Vous devez maintenant avoir quatre fichiers dans votre répertoire `SAM-Tutorial` : + `beforeAllowTraffic.js` + `afterAllowTraffic.js` + `myDateTimeFunction.js` + `template.yml` Vous êtes maintenant prêt à utiliser la **sam package** commande AWS SAM pour créer et empaqueter des artefacts pour vos fonctions et CodeDeploy applications Lambda. Les artefacts sont chargés dans un compartiment S3. La sortie de la commande est un nouveau fichier nommé `package.yml`. Ce fichier est utilisé par la **sam deploy** commande AWS SAM à l'étape suivante. **Note** Pour plus d'informations sur la **sam package** commande, consultez la [référence des commandes AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) dans le *manuel du AWS Serverless Application Model développeur*. Dans le répertoire `SAM-Tutorial`, exécutez la commande suivante. ``` sam package \ --template-file template.yml \ --output-template-file package.yml \ --s3-bucket amzn-s3-demo-bucket ``` Pour le `s3-bucket` paramètre, spécifiez le compartiment Amazon S3 que vous avez créé comme condition préalable à ce didacticiel. `output-template-file`Spécifie le nom du nouveau fichier utilisé par la **sam deploy** commande AWS SAM. # Déployer l'application AWS SAM Utilisez la **sam deploy** commande AWS SAM avec le `package.yml` fichier pour créer vos fonctions Lambda, votre CodeDeploy application et votre groupe de déploiement à l'aide de. CloudFormation **Note** Pour plus d'informations sur la **sam deploy** commande, consultez la [référence des commandes AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) dans le *manuel du AWS Serverless Application Model développeur*. Dans le répertoire `SAM-Tutorial`, exécutez la commande suivante. ``` sam deploy \ --template-file package.yml \ --stack-name my-date-time-app \ --capabilities CAPABILITY_IAM ``` Le `--capabilities CAPABILITY_IAM` paramètre est obligatoire pour autoriser la création CloudFormation de rôles IAM. # (Facultatif) inspectez et testez votre infrastructure Cette rubrique explique comment visualiser les composants de votre infrastructure et tester votre fonction Lambda. **Pour afficher le résultat de votre pile après avoir exécuté `sam deploy`** 1. Ouvrez la CloudFormation console à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/) 1. Dans le volet de navigation, choisissez **Stack (Piles)**. La pile `my-date-time-app` s'affiche en haut. 1. Choisissez l'onglet **Événements** pour voir quels événements sont terminés. Vous pouvez afficher les événements pendant que la création de la pile est en cours. Lorsque la création de la pile est terminée, vous pouvez voir tous les événements de création de la pile. 1. Une fois la pile sélectionnée, choisissez **Ressources**. Dans la colonne **Type**, vous pouvez voir vos fonctions Lambda, `myDateTimeFunction``CodeDeployHook_beforeAllowTraffic`, et. `CodeDeployHook_afterAllowTraffic` La colonne **Physical ID** de chacune de vos fonctions Lambda contient un lien permettant d'afficher les fonctions dans la console Lambda. **Note** Le nom de la fonction `myDateTimeFunction` Lambda est précédé du nom de la CloudFormation pile et un identifiant y est ajouté, ce qui donne l'apparence suivante : `my-date-time-app-myDateTimeFunction-123456ABCDEF` 1. Ouvrez la CodeDeploy console à l'adresse [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/). 1. Dans le volet de navigation, développez **Déployer**, puis choisissez **Applications**. 1. Vous devriez voir une nouvelle CodeDeploy application créée par CloudFormation et dont le nom commence par`my-date-time-app-ServerlessDeploymentApplication`. Choisissez cette application. 1. Vous devez voir un groupe de déploiement dont le nom commence par `my-date-time-app-myDateTimeFunctionDeploymentGroup`. Choisissez ce groupe de déploiement. Sous **Configuration du déploiement**, vous devriez voir **CodeDeployDefault. LambdaLinear10 PercentEvery 1 minute.** **(Facultatif) pour tester votre fonction (console)** 1. Ouvrez la AWS Lambda console à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Dans le volet de navigation, choisissez votre fonction `my-date-time-app-myDateTimeFunction`. Dans la console, son nom contient un identifiant. Il ressemble donc à `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 1. Sélectionnez **Tester)**. 1. Dans **Nom de l'événement**, entrez un nom pour votre événement de test. 1. Entrez les informations suivantes pour votre événement de test, puis choisissez **Créer**. ``` { "option": "date", "period": "today" } ``` 1. Sélectionnez **Tester)**. Vous devriez voir uniquement votre événement de test dans la liste des événements de test. Pour **Résultat de l'exécution**, vous devriez voir **réussite**. 1. Sous **Résultat de l'exécution**, développez **Détails** pour afficher les résultats. Vous devriez voir le mois, le jour et l'année en cours. **(Facultatif) pour tester votre fonction (AWS CLI)** 1. Localisez l'ARN de votre fonction Lambda. Il apparaît en haut de la console Lambda lorsque vous visualisez votre fonction. 1. Exécutez la commande suivante. Remplacez *your-function-arn* par la fonction ARN. ``` aws lambda invoke \ --function your-function-arn \ --cli-binary-format raw-in-base64-out \ --payload "{\"option\": \"date\", \"period\": \"today\"}" out.txt ``` 1. Ouvrez `out.txt` pour confirmer que le résultat contient le mois, le jour et l'année en cours.