Tutoriel : Déployer une application sans serveur - Amazon CodeCatalyst
PrérequisÉtape 1 : Création d'un référentiel sourceÉtape 2 : créer des AWS rôlesÉtape 3 : ajouter AWS des rôles à CodeCatalystÉtape 4 : Création d'un compartiment Amazon S3Étape 5 : Ajouter des fichiers sourceÉtape 6 : créer et exécuter un flux de travailÉtape 7 : Apporter une modificationNettoyage

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.

Tutoriel : Déployer une application sans serveur

Dans ce didacticiel, vous apprendrez à créer, tester et déployer une application sans serveur sous forme de CloudFormation pile à l'aide d'un flux de travail.

L'application présentée dans ce didacticiel est une simple application Web qui produit un message « Hello World ». Il se compose d'une AWS Lambda fonction et d'un Amazon API Gateway, et vous le créez à l'aide du AWS Serverless Application Model (AWS SAM), qui est une extension de AWS CloudFormation.

Prérequis

Avant de commencer :

  • Vous avez besoin d'un CodeCatalyst espace avec un AWS compte connecté. Pour plus d’informations, consultez Création d'un espace.

  • Dans votre espace, vous avez besoin d'un projet vide appelé :

    codecatalyst-cfn-project

    Utilisez l'option Partir de zéro pour créer ce projet.

    Pour plus d’informations, consultez Création d'un projet vide dans Amazon CodeCatalyst.

  • Dans votre projet, vous avez besoin d'un CodeCatalyst environnement appelé :

    codecatalyst-cfn-environment

    Configurez cet environnement comme suit :

    • Choisissez n'importe quel type, tel que Non-production.

    • AWS Connectez-y votre compte.

    • Pour le IAMrôle par défaut, choisissez n'importe quel rôle. Vous spécifierez un autre rôle ultérieurement.

    Pour plus d’informations, consultez Déploiement dans Comptes AWS et VPCs.

Étape 1 : Création d'un référentiel source

Au cours de cette étape, vous créez un référentiel source dans CodeCatalyst. Ce référentiel est utilisé pour stocker les fichiers sources du didacticiel, tels que le fichier de fonction Lambda.

Pour plus d'informations sur les référentiels sources, consultezCréation d'un référentiel source.

Pour créer un référentiel de sources

  1. Dans CodeCatalyst le volet de navigation, sélectionnez Code, puis sélectionnez Référentiels sources.

  2. Choisissez Ajouter un référentiel, puis sélectionnez Créer un référentiel.

  3. Dans Nom du référentiel, entrez :

    codecatalyst-cfn-source-repository

  4. Choisissez Créer.

Vous venez de créer un dépôt appelécodecatalyst-cfn-source-repository.

Étape 2 : créer des AWS rôles

Au cours de cette étape, vous allez créer les AWS IAM rôles suivants :

  • Rôle de déploiement : accorde à l'action CodeCatalyst Deploy AWS CloudFormation Stack l'autorisation d'accéder à votre AWS compte et au CloudFormation service sur lesquels vous déploierez votre application sans serveur. L'action Deploy AWS CloudFormation stack fait partie de votre flux de travail.

  • Rôle de création : accorde à l'action de CodeCatalyst création l'autorisation d'accéder à votre AWS compte et d'écrire sur Amazon S3 où votre package d'application sans serveur sera stocké. L'action de création fait partie de votre flux de travail.

  • Rôle Stack : CloudFormation autorise la lecture et la modification des ressources spécifiées dans le AWS SAM modèle que vous fournirez ultérieurement. Accorde également l'autorisation de CloudWatch.

Pour plus d'informations sur IAM les rôles, voir IAMles rôles dans le Guide de AWS Identity and Access Management l'utilisateur.

Note

Pour gagner du temps, vous pouvez créer un seul rôle, appelé CodeCatalystWorkflowDevelopmentRole-spaceName rôle, au lieu des trois rôles répertoriés précédemment. Pour plus d’informations, consultez Création du CodeCatalystWorkflowDevelopmentRole-spaceNamerôle pour votre compte et votre espace. Sachez que le CodeCatalystWorkflowDevelopmentRole-spaceName rôle dispose d'autorisations très étendues qui peuvent présenter un risque de sécurité. Nous vous recommandons de n'utiliser ce rôle que dans les didacticiels et les scénarios où la sécurité est moins préoccupante. Ce didacticiel part du principe que vous créez les trois rôles répertoriés précédemment.

Note

Un rôle d'exécution Lambda est également requis, mais vous n'avez pas besoin de le créer maintenant car le sam-template.yml fichier le crée pour vous lorsque vous exécutez le flux de travail à l'étape 5.

Pour créer un rôle de déploiement

  1. Créez une politique pour le rôle, comme suit :

    1. Connectez-vous à AWS.

    2. Ouvrez la console IAM à l’adresse https://console.aws.amazon.com/iam/.

    3. Dans le panneau de navigation, choisissez Politiques.

    4. Sélectionnez Create policy (Créer une politique).

    5. Cliquez sur l'onglet JSON.

    6. Supprimez le code existant.

    7. Collez le code suivant :

      {
    "Version": "2012-10-17",
    "Statement": [{
    "Action": [
        "cloudformation:CreateStack",
        "cloudformation:DeleteStack",
        "cloudformation:Describe*",
        "cloudformation:UpdateStack",
        "cloudformation:CreateChangeSet",
        "cloudformation:DeleteChangeSet",
        "cloudformation:ExecuteChangeSet",
        "cloudformation:SetStackPolicy",
        "cloudformation:ValidateTemplate",
        "cloudformation:List*",
        "iam:PassRole"
    ],
    "Resource": "*",
    "Effect": "Allow"
}]
}
      Note

      La première fois que le rôle est utilisé pour exécuter des actions de flux de travail, utilisez le caractère générique dans la déclaration de politique de ressources, puis définissez la stratégie avec le nom de la ressource une fois celle-ci disponible.

      "Resource": "*"

    8. Choisissez Suivant : Balises.

    9. Choisissez Suivant : Vérification.

    10. Dans Nom, entrez :

      codecatalyst-deploy-policy

    11. Choisissez Créer une politique.

      Vous venez de créer une politique d'autorisation.

  2. Créez le rôle de déploiement comme suit :

    1. Dans le volet de navigation, sélectionnez Rôles, puis Créer un rôle.

    2. Choisissez une politique de confiance personnalisée.

    3. Supprimez la politique de confiance personnalisée existante.

    4. Ajoutez la politique de confiance personnalisée suivante :

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

    5. Choisissez Suivant.

    6. Dans Politiques d'autorisations, recherchez codecatalyst-deploy-policy et cochez la case correspondante.

    7. Choisissez Suivant.

    8. Dans Nom du rôle, entrez :

      codecatalyst-deploy-role

    9. Dans le champ Description du rôle, entrez :

      CodeCatalyst deploy role

    10. Sélectionnez Créer un rôle.

    Vous venez de créer un rôle de déploiement avec une politique de confiance et une politique d'autorisations.

  3. Obtenez le rôle de déploiementARN, comme suit :

    1. Dans le panneau de navigation, choisissez Roles (Rôles).

    2. Dans le champ de recherche, entrez le nom du rôle que vous venez de créer (codecatalyst-deploy-role).

    3. Choisissez le rôle dans la liste.

      La page Résumé du rôle apparaît.

    4. En haut, copiez la ARNvaleur.

    Vous avez maintenant créé le rôle de déploiement avec les autorisations appropriées, et vous l'avez obtenuARN.

Pour créer un rôle de build

  1. Créez une politique pour le rôle, comme suit :

    1. Connectez-vous à AWS.

    2. Ouvrez la console IAM à l’adresse https://console.aws.amazon.com/iam/.

    3. Dans le panneau de navigation, choisissez Politiques.

    4. Sélectionnez Create policy (Créer une politique).

    5. Cliquez sur l'onglet JSON.

    6. Supprimez le code existant.

    7. Collez le code suivant :

      {
    "Version": "2012-10-17",
    "Statement": [{
    "Action": [
        "s3:PutObject",
        "iam:PassRole"
    ],
    "Resource": "*",
    "Effect": "Allow"
}]
}
      Note

      La première fois que le rôle est utilisé pour exécuter des actions de flux de travail, utilisez le caractère générique dans la déclaration de politique de ressources, puis définissez la stratégie avec le nom de la ressource une fois celle-ci disponible.

      "Resource": "*"

    8. Choisissez Suivant : Balises.

    9. Choisissez Suivant : Vérification.

    10. Dans Nom, entrez :

      codecatalyst-build-policy

    11. Choisissez Créer une politique.

      Vous venez de créer une politique d'autorisation.

  2. Créez le rôle de build, comme suit :

    1. Dans le volet de navigation, sélectionnez Rôles, puis Créer un rôle.

    2. Choisissez une politique de confiance personnalisée.

    3. Supprimez la politique de confiance personnalisée existante.

    4. Ajoutez la politique de confiance personnalisée suivante :

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

    5. Choisissez Suivant.

    6. Dans Politiques d'autorisations, recherchez codecatalyst-build-policy et cochez la case correspondante.

    7. Choisissez Suivant.

    8. Dans Nom du rôle, entrez :

      codecatalyst-build-role

    9. Dans le champ Description du rôle, entrez :

      CodeCatalyst build role

    10. Sélectionnez Créer un rôle.

    Vous avez maintenant créé un rôle de build avec une politique de confiance et une politique d'autorisations.

  3. Obtenez le rôle de buildARN, comme suit :

    1. Dans le panneau de navigation, choisissez Roles (Rôles).

    2. Dans le champ de recherche, entrez le nom du rôle que vous venez de créer (codecatalyst-build-role).

    3. Choisissez le rôle dans la liste.

      La page Résumé du rôle apparaît.

    4. En haut, copiez la ARNvaleur.

    Vous avez maintenant créé le rôle de build avec les autorisations appropriées, et vous l'avez obtenuARN.

Pour créer un rôle de pile

  1. Connectez-vous à AWS l'aide du compte sur lequel vous souhaitez déployer votre stack.

  2. Ouvrez la console IAM à l’adresse https://console.aws.amazon.com/iam/.

  3. Créez le rôle de pile comme suit :

    1. Dans le panneau de navigation, choisissez Roles (Rôles).

    2. Sélectionnez Create role (Créer un rôle).

    3. Choisissez Service AWS .

    4. Dans la section Cas d'utilisation, choisissez CloudFormationdans la liste déroulante.

    5. Sélectionnez le bouton CloudFormationradio.

    6. En bas de la page, choisissez Next.

    7. À l'aide de la zone de recherche, recherchez les politiques d'autorisation suivantes, puis cochez leurs cases respectives.

      Note

      Si vous recherchez une politique et qu'elle n'apparaît pas, assurez-vous de choisir Effacer les filtres et réessayez.

      • CloudWatchFullAccess

      • AWS CloudFormationFullAccess

      • IAMFullAccess

      • AWS Lambda_ FullAccess

      • Un mazonAPIGateway administrateur

      • Amazon S3 FullAccess

      • Amazon EC2ContainerRegistryFullAccess

      La première politique autorise l'accès CloudWatch pour activer les rollbacks de pile lorsqu'une alarme se produit.

      Les politiques restantes permettent AWS SAM d'accéder aux services et aux ressources de la pile qui seront déployés dans ce didacticiel. Pour plus d'informations, consultez la section Permissions dans le guide du AWS Serverless Application Model développeur.

    8. Choisissez Suivant.

    9. Dans Nom du rôle, entrez :

      codecatalyst-stack-role

    10. Sélectionnez Créer un rôle.

  4. Obtenez les rôles de pileARN, comme suit :

    1. Dans le panneau de navigation, choisissez Roles (Rôles).

    2. Dans le champ de recherche, entrez le nom du rôle que vous venez de créer (codecatalyst-stack-role).

    3. Choisissez le rôle dans la liste.

    4. Dans la section Résumé, copiez la ARNvaleur. Vous en aurez besoin ultérieurement.

    Vous avez maintenant créé le rôle stack avec les autorisations appropriées, et vous l'avez obtenuARN.

Étape 3 : ajouter AWS des rôles à CodeCatalyst

Au cours de cette étape, vous ajoutez le rôle de création (codecatalyst-build-role) et le rôle de déploiement (codecatalyst-deploy-role) à la connexion au CodeCatalyst compte dans votre espace.

Note

Il n'est pas nécessaire d'ajouter le rôle stack (codecatalyst-stack-role) à la connexion. Cela est dû au fait que le rôle de pile est utilisé CloudFormation(et non CodeCatalyst), une fois qu'une connexion est déjà établie entre CodeCatalyst et AWS en utilisant le rôle de déploiement. Comme le rôle stack n'est pas utilisé CodeCatalyst pour accéder à AWS, il n'est pas nécessaire de l'associer à une connexion à un compte.

Pour ajouter des rôles de création et de déploiement à votre compte, connectez-vous

  1. Dans CodeCatalyst, naviguez jusqu'à votre espace.

  2. Choisissez AWS des comptes. La liste des connexions au compte s'affiche.

  3. Choisissez la connexion au compte qui représente le AWS compte sur lequel vous avez créé vos rôles de création et de déploiement.

  4. Choisissez Gérer les rôles depuis AWS la console de gestion.

    La page Ajouter IAM un rôle à CodeCatalyst l'espace Amazon apparaît. Il se peut que vous deviez vous connecter pour accéder à la page.

  5. Sélectionnez Ajouter un rôle existant que vous avez créé dans IAM.

    Une liste déroulante apparaît. La liste affiche tous les IAM rôles dotés d'une politique de confiance qui inclut les directeurs codecatalyst.amazonaws.com de service codecatalyst-runner.amazonaws.com et.

  6. Dans la liste déroulante, sélectionnezcodecatalyst-build-role, puis choisissez Ajouter un rôle.

  7. Choisissez Ajouter un IAM rôle, choisissez Ajouter un rôle existant dans lequel vous avez créé IAM, puis dans la liste déroulante, choisissezcodecatalyst-deploy-role. Choisissez Ajouter un rôle.

    Vous avez maintenant ajouté les rôles de création et de déploiement à votre espace.

  8. Copiez la valeur du nom CodeCatalyst d'affichage Amazon. Vous aurez besoin de cette valeur ultérieurement, lors de la création de votre flux de travail.

Étape 4 : Création d'un compartiment Amazon S3

Au cours de cette étape, vous créez un compartiment Amazon S3 dans lequel vous stockez le fichier .zip du package de déploiement de votre application sans serveur.

Pour créer un compartiment Amazon S3

  1. Ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le volet principal, choisissez Create bucket.

  3. Dans le champ Nom du compartiment, entrez :

    codecatalyst-cfn-s3-bucket

  4. Choisissez une région dans Région AWS . Ce didacticiel part du principe que vous avez choisi US West (Oregon) us-west-2. Pour plus d'informations sur les régions prises en charge par Amazon S3, consultez la section Points de terminaison et quotas Amazon Simple Storage Service dans le Références générales AWS.

  5. Au bas de la page, choisissez Create bucket.

Vous venez de créer un bucket appelé codecatalyst-cfn-s3-bucket dans la région us-west-2 de l'ouest des États-Unis (Oregon).

Étape 5 : Ajouter des fichiers source

Au cours de cette étape, vous allez ajouter plusieurs fichiers source de l'application à votre référentiel CodeCatalyst source. Le hello-world dossier contient les fichiers d'application que vous allez déployer. Le tests dossier contient les tests unitaires. La structure des dossiers est la suivante :

.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh

fichier .npmignore

Le .npmignore fichier indique les fichiers et dossiers que npm doit exclure du package de l'application. Dans ce didacticiel, npm exclut le tests dossier car il ne fait pas partie de l'application.

Pour ajouter le fichier .npmignore

  1. Ouvrez la CodeCatalyst console à l'adresse https://codecatalyst.aws/.

  2. Choisissez votre projet, codecatalyst-cfn-project

  3. Dans le volet de navigation, choisissez Code, puis sélectionnez Référentiels sources.

  4. Dans la liste des référentiels sources, choisissez votre référentiel,codecatalyst-cfn-source-repository.

  5. Dans Fichiers, choisissez Créer un fichier.

  6. Dans le champ Nom du fichier, entrez :

    .npmignore

  7. Dans la zone de texte, entrez le code suivant :

    tests/*

  8. Choisissez Commit, puis sélectionnez Commit à nouveau.

    Vous venez de créer un fichier appelé .npmignore à la racine de votre dépôt.

fichier package.json

Le package.json fichier contient des métadonnées importantes concernant votre projet Node, telles que le nom du projet, le numéro de version, la description, les dépendances et d'autres détails qui décrivent comment interagir avec votre application et l'exécuter.

package.jsonDans ce didacticiel, vous trouverez une liste de dépendances et un test script. Le script de test effectue les opérations suivantes :

  • À l'aide de mocha, le script de test exécute les tests unitaires spécifiés dans hello-world/tests/unit/ et écrit les résultats dans un junit.xml fichier à l'aide du rapporteur xunit.

  • À l'aide d'Istanbul (NYC), le script de test génère un rapport de couverture de code (clover.xml) à l'aide du Clover Reporter. Pour plus d'informations, consultez la section Utilisation de reporters alternatifs dans la documentation d'Istanbul.

Pour ajouter le fichier package.json

  1. Dans votre référentiel, dans Fichiers, choisissez Créer un fichier.

  2. Dans le champ Nom du fichier, entrez :

    package.json

  3. Dans la zone de texte, entrez le code suivant :

    {
  "name": "hello_world",
  "version": "1.0.0",
  "description": "hello world sample for NodeJS",
  "main": "app.js",
  "repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
  "author": "SAM CLI",
  "license": "MIT",
  "dependencies": {
    "axios": "^0.21.1",
    "nyc": "^15.1.0"
  },
  "scripts": {
    "test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
  },
  "devDependencies": {
    "aws-sdk": "^2.815.0",
    "chai": "^4.2.0",
    "mocha": "^8.2.1"
  }
}

  4. Choisissez Commit, puis sélectionnez Commit à nouveau.

    Vous venez d'ajouter un fichier appelé package.json à la racine du dépôt.

fichier sam-template.yml

Le sam-template.yml fichier contient les instructions pour déployer la fonction Lambda et API Gateway et pour les configurer ensemble. Il suit la spécification du AWS Serverless Application Model modèle, qui étend la spécification du AWS CloudFormation modèle.

Dans ce didacticiel, vous utilisez un AWS SAM modèle au lieu d'un AWS CloudFormation modèle normal car il AWS SAM propose un type de ressource utile AWS: :Serverless : :Function. Ce type effectue une grande partie de la behind-the-scenes configuration que vous devez normalement écrire pour utiliser la CloudFormation syntaxe de base. Par exemple, AWS::Serverless::Function crée une fonction Lambda, un rôle d'exécution Lambda et des mappages de sources d'événements qui démarrent la fonction. Vous devez coder tout cela si vous voulez l'écrire en utilisant basic CloudFormation.

Bien que ce didacticiel utilise un modèle pré-écrit, vous pouvez en générer un dans le cadre de votre flux de travail à l'aide d'une action de génération. Pour plus d’informations, consultez Déploiement d'une AWS CloudFormation pile.

Pour ajouter le fichier sam-template.yml

  1. Dans votre référentiel, dans Fichiers, choisissez Créer un fichier.

  2. Dans le champ Nom du fichier, entrez :

    sam-template.yml

  3. Dans la zone de texte, entrez le code suivant :

    AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >
  serverless-api

  Sample SAM Template for serverless-api
  
# More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
Globals:
  Function:
    Timeout: 3

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
    Properties:
      CodeUri: hello-world/
      Handler: app.lambdaHandler
      Runtime: nodejs12.x
      Events:
        HelloWorld:
          Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
          Properties:
            Path: /hello
            Method: get

Outputs:
  # ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
  # Find out about other implicit resources you can reference within AWS SAM at
  # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
  HelloWorldApi:
    Description: "API Gateway endpoint URL for the Hello World function"
    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
  HelloWorldFunction:
    Description: "Hello World Lambda function ARN"
    Value: !GetAtt HelloWorldFunction.Arn
  HelloWorldFunctionIamRole:
    Description: "Implicit Lambda execution role created for the Hello World function"
    Value: !GetAtt HelloWorldFunctionRole.Arn

  4. Choisissez Commit, puis sélectionnez Commit à nouveau.

    Vous venez d'ajouter un fichier appelé sam-template.yml sous le dossier racine de votre dépôt.

fichier setup-sam.sh

Le setup-sam.sh fichier contient les instructions de téléchargement et d'installation de l' AWS SAM CLIutilitaire. Le flux de travail utilise cet utilitaire pour empaqueter la hello-world source.

Pour ajouter le fichier setup-sam.sh

  1. Dans votre référentiel, dans Fichiers, choisissez Créer un fichier.

  2. Dans le champ Nom du fichier, entrez :

    setup-sam.sh

  3. Dans la zone de texte, entrez le code suivant :

    #!/usr/bin/env bash
echo "Setting up sam"

yum install unzip -y

curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory

./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2

    Dans le code précédent, remplacez us-west-2 avec votre AWS région.

  4. Choisissez Commit, puis sélectionnez Commit à nouveau.

    Vous venez d'ajouter un fichier appelé setup-sam.sh à la racine du dépôt.

fichier app.js

app.jsContient le code de la fonction Lambda. Dans ce didacticiel, le code renvoie le textehello world.

Pour ajouter le fichier app.js

  1. Dans votre référentiel, dans Fichiers, choisissez Créer un fichier.

  2. Dans le champ Nom du fichier, entrez :

    hello-world/app.js

  3. Dans la zone de texte, entrez le code suivant :

    // const axios = require('axios')
// const url = 'http://checkip.amazonaws.com/';
let response;

/**
 *
 * Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
 * @param {Object} event - API Gateway Lambda Proxy Input Format
 *
 * Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html 
 * @param {Object} context
 *
 * Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
 * @returns {Object} object - API Gateway Lambda Proxy Output Format
 * 
 */
exports.lambdaHandler = async (event, context) => {
    try {
        // const ret = await axios(url);
        response = {
            'statusCode': 200,
            'body': JSON.stringify({
                message: 'hello world',
                // location: ret.data.trim()
            })
        }
    } catch (err) {
        console.log(err);
        return err;
    }

    return response
};

  4. Choisissez Commit, puis sélectionnez Commit à nouveau.

    Vous avez maintenant créé un dossier appelé hello-world et un fichier appeléapp.js.

fichier test-handler.js

Le test-handler.js fichier contient des tests unitaires pour la fonction Lambda.

Pour ajouter le fichier test-handler.js

  1. Dans votre référentiel, dans Fichiers, choisissez Créer un fichier.

  2. Dans le champ Nom du fichier, entrez :

    hello-world/tests/unit/test-handler.js

  3. Dans la zone de texte, entrez le code suivant :

    'use strict';

const app = require('../../app.js');
const chai = require('chai');
const expect = chai.expect;
var event, context;

describe('Tests index', function () {
    it('verifies successful response', async () => {
        const result = await app.lambdaHandler(event, context)

        expect(result).to.be.an('object');
        expect(result.statusCode).to.equal(200);
        expect(result.body).to.be.an('string');

        let response = JSON.parse(result.body);

        expect(response).to.be.an('object');
        expect(response.message).to.be.equal("hello world");
        // expect(response.location).to.be.an("string");
    });
});

  4. Choisissez Commit, puis sélectionnez Commit à nouveau.

    Vous venez d'ajouter un fichier appelé test-handler.js sous le hello-world/tests/unit dossier.

Vous avez maintenant ajouté tous vos fichiers sources.

Prenez le temps de vérifier votre travail et de vous assurer que vous avez placé tous les fichiers dans les bons dossiers. La structure des dossiers est la suivante :

.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh

Étape 6 : créer et exécuter un flux de travail

Au cours de cette étape, vous créez un flux de travail qui empaquette votre code source Lambda et le déploie. Le flux de travail comprend les éléments de base suivants qui s'exécutent de manière séquentielle :

  • Un déclencheur : ce déclencheur lance automatiquement l'exécution du flux de travail lorsque vous apportez une modification à votre référentiel source. Pour plus d'informations sur les déclencheurs, consultez Démarrage d'un flux de travail exécuté automatiquement à l'aide de déclencheurs.

  • Une action de test (Test) — Au déclenchement, cette action installe le gestionnaire de packages Node (npm), puis exécute la npm run test commande. Cette commande indique à npm d'exécuter le test script défini dans le package.json fichier. Le test script exécute à son tour les tests unitaires et génère deux rapports : un rapport de test (junit.xml) et un rapport de couverture de code (clover.xml). Pour plus d’informations, consultez fichier package.json.

    Ensuite, l'action de test transforme les XML rapports en CodeCatalyst rapports et les affiche dans la CodeCatalyst console, sous l'onglet Rapports de l'action de test.

    Pour plus d'informations sur l'action de test, consultezTests avec des flux de travail.

  • Une action de génération (BuildBackend) : à la fin de l'action de test, l'action de génération télécharge et installe le package AWS SAM CLI, empaquète la hello-world source et copie le package dans votre compartiment Amazon S3, là où le service Lambda s'attend à ce qu'il se trouve. L'action génère également un nouveau fichier AWS SAM modèle appelé sam-template-packaged.yml et le place dans un artefact de sortie appelébuildArtifact.

    Pour plus d'informations sur l'action de génération, consultezConstruire avec des flux de travail.

  • Une action de déploiement (DeployCloudFormationStack) : à la fin de l'action de génération, l'action de déploiement recherche l'artefact de sortie généré par l'action de génération (buildArtifact), trouve le AWS SAM modèle à l'intérieur de celui-ci, puis exécute le modèle. Le AWS SAM modèle crée une pile qui déploie l'application sans serveur.

Pour créer un flux de travail

  1. Dans le volet de navigation, choisissez CI/CD, puis Workflows.

  2. Choisissez Créer un flux de travail.

  3. Pour Référentiel source, choisissezcodecatalyst-cfn-source-repository.

  4. Pour Branch, choisissezmain.

  5. Choisissez Créer.

  6. Supprimez l'YAMLexemple de code.

  7. Ajoutez le YAML code suivant :

    Note

    Dans le YAML code qui suit, vous pouvez omettre les Connections: sections si vous le souhaitez. Si vous omettez ces sections, vous devez vous assurer que le rôle spécifié dans le champ IAMRôle par défaut de votre environnement inclut les autorisations et les politiques de confiance des deux rôles décrits dansÉtape 2 : créer des AWS rôles. Pour plus d'informations sur la configuration d'un environnement doté d'un IAM rôle par défaut, consultezCréation d'un environnement.

    Name: codecatalyst-cfn-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main   
Actions:
  Test:
    Identifier: aws/managed-test@v1
    Inputs:
      Sources:
        - WorkflowSource
    Outputs:
      Reports:
        CoverageReport:
          Format: CLOVERXML
          IncludePaths:
            - "coverage/*"
        TestReport:
          Format: JUNITXML
          IncludePaths:
            - junit.xml
    Configuration:
      Steps:
        - Run: npm install
        - Run: npm run test  
  BuildBackend:
    Identifier: aws/build@v1
    DependsOn:
      - Test
    Environment:
      Name: codecatalyst-cfn-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-build-role
    Inputs:
      Sources:
        - WorkflowSource
    Configuration: 
      Steps:
        - Run: . ./setup-sam.sh
        - Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
    Outputs:
      Artifacts:
        - Name: buildArtifact
          Files:
            - "**/*"
  DeployCloudFormationStack:
    Identifier: aws/cfn-deploy@v1
    DependsOn: 
      - BuildBackend
    Environment:
      Name: codecatalyst-cfn-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-deploy-role
    Inputs:
      Artifacts:
        - buildArtifact
      Sources: []
    Configuration:
      name: codecatalyst-cfn-stack
      region: us-west-2
      role-arn: arn:aws:iam::111122223333:role/StackRole
      template: ./sam-template-packaged.yml
      capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND

    Dans le code précédent, remplacez :

    • Les deux cas de codecatalyst-cfn-environment avec le nom de votre environnement.

    • Les deux cas de codecatalyst-account-connection avec le nom d'affichage de la connexion à votre compte. Le nom d'affichage peut être un chiffre. Pour plus d’informations, consultez Étape 3 : ajouter AWS des rôles à CodeCatalyst.

    • codecatalyst-build-role avec le nom du rôle de build que vous avez créé dansÉtape 2 : créer des AWS rôles.

    • codecatalyst-cfn-s3-bucket avec le nom du compartiment Amazon S3 dans lequel vous l'avez crééÉtape 4 : Création d'un compartiment Amazon S3.

    • Les deux cas de us-west-2 avec la région dans laquelle se trouve votre compartiment Amazon S3 (première instance) et où votre stack sera déployé (deuxième instance). Ces régions peuvent être différentes. Ce didacticiel part du principe que les deux régions sont définies surus-west-2. Pour en savoir plus sur les régions prises en charge par Amazon S3 AWS CloudFormation, consultez la section Points de terminaison et quotas du service dans le Références générales AWS.

    • codecatalyst-deploy-role avec le nom du rôle de déploiement que vous avez créé dansÉtape 2 : créer des AWS rôles.

    • codecatalyst-cfn-environment avec le nom de l'environnement dans lequel vous l'avez crééPrérequis.

    • arn:aws:iam::111122223333:role/StackRole avec le nom de ressource Amazon (ARN) du rôle de pile que vous avez créé dansÉtape 2 : créer des AWS rôles.

      Note

      Si vous avez décidé de ne pas créer de rôles de génération, de déploiement et d'empilement, remplacez codecatalyst-build-role, codecatalyst-deploy-role, et arn:aws:iam::111122223333:role/StackRole avec le nom ou ARN le CodeCatalystWorkflowDevelopmentRole-spaceName rôle. Pour plus d’informations sur ce rôle, consultez Étape 2 : créer des AWS rôles.

    Pour plus d'informations sur les propriétés du code présenté précédemment, consultez leAction « Déployer une AWS CloudFormation pile » YAML.

  8. (Facultatif) Choisissez Valider pour vous assurer que le YAML code est valide avant de le valider.

  9. Choisissez Commit (Valider).

  10. Dans la boîte de dialogue du flux de travail de validation, entrez ce qui suit :

    1. Pour le nom du fichier de flux de travail, conservez la valeur par défaut,codecatalyst-cfn-workflow.

    2. Pour le message de validation, entrez :

      add initial workflow file

    3. Pour Repository, choisissez codecatalyst-cfn-source-repository.

    4. Pour Nom de la branche, choisissez main.

    5. Choisissez Commit (Valider).

    Vous venez de créer un flux de travail. L'exécution d'un flux de travail démarre automatiquement en raison du déclencheur défini en haut du flux de travail. Plus précisément, lorsque vous avez validé (et transféré) le codecatalyst-cfn-workflow.yaml fichier dans votre référentiel source, le déclencheur a lancé l'exécution du flux de travail.

Pour consulter le flux de travail en cours d'exécution

  1. Dans le volet de navigation, choisissez CI/CD, puis Workflows.

  2. Choisissez le flux de travail que vous venez de créer :codecatalyst-cfn-workflow.

  3. Choisissez l'onglet Runs.

  4. Dans la colonne Run ID, choisissez l'Run ID.

  5. Choisissez Test pour voir la progression des tests.

  6. Choisissez BuildBackendde voir la progression de la construction.

  7. Choisissez DeployCloudFormationStackde voir la progression du déploiement.

    Pour plus d'informations sur l'affichage des détails des courses, consultezAfficher le statut et les détails de l'exécution du flux de travail.

  8. Lorsque l'DeployCloudFormationStackaction est terminée, procédez comme suit :

    • Si l'exécution du flux de travail a réussi, passez à la procédure suivante.

    • Si l'exécution du flux de travail a échoué lors du test ou de BuildBackendl'action, choisissez Logs pour résoudre le problème.

    • Si l'exécution du flux de travail a échoué lors de l'DeployCloudFormationStackaction, choisissez l'action de déploiement, puis cliquez sur l'onglet Résumé. Accédez à la section CloudFormation des événements pour afficher le message d'erreur détaillé. En cas de restauration, supprimez la codecatalyst-cfn-stack pile via la AWS CloudFormation console AWS avant de réexécuter le flux de travail.

Pour vérifier le déploiement

  1. Une fois le déploiement réussi, choisissez Variables (7) dans la barre de menu horizontale située en haut. (Ne choisissez pas Variables dans le volet de droite.)

  2. Ensuite HelloWorldApi, collez-le https:// URL dans un navigateur.

    Un JSON message Hello World provenant de la fonction Lambda s'affiche, indiquant que le flux de travail a déployé et configuré correctement la fonction Lambda et Gateway. API

    Astuce

    Vous pouvez CodeCatalyst l'afficher URL dans le diagramme du flux de travail avec quelques petites configurations. Pour plus d’informations, consultez Afficher l'application URL dans le diagramme du flux de travail.

Pour vérifier les résultats des tests unitaires et la couverture du code

  1. Dans le diagramme du flux de travail, choisissez Test, puis Reports.

  2. Choisissez TestReportd'afficher les résultats des tests unitaires ou CoverageReportd'afficher les détails de couverture du code des fichiers testés, dans ce cas, app.js ettest-handler.js.

Pour vérifier les ressources déployées

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

  2. Observez codecatalyst-cfn-stackAPIce que le AWS SAM modèle a créé. Le API nom provient de la Configuration/name valeur du fichier de définition du flux de travail (codecatalyst-cfn-workflow.yaml).

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

  4. Dans le volet de navigation, choisissez Fonctions.

  5. Choisissez votre fonction Lambda,. codecatalyst-cfn-stack-HelloWorldFunction-string

  6. Vous pouvez voir comment la API passerelle est un déclencheur de cette fonction. Cette intégration a été automatiquement configurée en fonction du type de AWS SAM AWS::Serverless::Function ressource.

Étape 7 : Apporter une modification

Au cours de cette étape, vous apportez une modification à votre code source Lambda et vous le validez. Ce commit lance une nouvelle exécution du flux de travail. Cette exécution déploie la nouvelle fonction Lambda dans un schéma bleu-vert qui utilise la configuration de transfert de trafic par défaut spécifiée dans la console Lambda.

Pour apporter une modification à votre source Lambda

  1. Dans CodeCatalyst, accédez à votre projet.

  2. Dans le volet de navigation, choisissez Code, puis sélectionnez Référentiels sources.

  3. Choisissez votre référentiel sourcecodecatalyst-cfn-source-repository.

  4. Modifiez le dossier de candidature :

    1. Choisissez le dossier hello-world.

    2. Choisissez le app.js fichier.

    3. Choisissez Modifier.

    4. À la ligne 23, changez hello world enTutorial complete!.

    5. Choisissez Commit, puis sélectionnez Commit à nouveau.

      La validation entraîne le démarrage d'un flux de travail. Cette exécution échouera car vous n'avez pas mis à jour les tests unitaires pour refléter le changement de nom.

  5. Mettez à jour les tests unitaires :

    1. Sélectionnez hello-world\tests\unit\test-handler.js.

    2. Choisissez Modifier.

    3. À la ligne 19, changez hello world enTutorial complete!.

    4. Choisissez Commit, puis sélectionnez Commit à nouveau.

      La validation entraîne le démarrage d'un autre flux de travail. Cette course sera couronnée de succès.

  6. Dans le volet de navigation, choisissez CI/CD, puis Workflows.

  7. Choisissezcodecatalyst-cfn-workflow, puis choisissez Runs.

  8. Choisissez l'ID d'exécution de la dernière exécution. Il devrait toujours être en cours de réalisation.

  9. Choisissez Test BuildBackend, et DeployCloudFormationStackpour voir la progression de l'exécution du flux de travail.

  10. Lorsque le flux de travail est terminé, choisissez Variables (7) en haut.

  11. Ensuite HelloWorldApi, collez-le https:// URL dans un navigateur.

    Un Tutorial complete! message s'affiche dans le navigateur, indiquant que votre nouvelle application a été déployée avec succès.

Nettoyage

Nettoyez les fichiers et les services utilisés dans ce didacticiel pour éviter de vous les faire facturer.

Pour nettoyer dans la CodeCatalyst console

  1. Ouvrez la CodeCatalyst console à l'adresse https://codecatalyst.aws/.

  2. Supprimercodecatalyst-cfn-workflow.

  3. Supprimercodecatalyst-cfn-environment.

  4. Supprimercodecatalyst-cfn-source-repository.

  5. Supprimercodecatalyst-cfn-project.

Pour nettoyer dans AWS Management Console

  1. Nettoyez en CloudFormation procédant comme suit :

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

    2. Supprimez la codecatalyst-cfn-stack.

      La suppression de la pile supprime toutes les ressources du didacticiel des API services Gateway et Lambda.

  2. Nettoyez dans Amazon S3, comme suit :

    1. Ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.

    2. Cliquez sur le bouton codecatalyst-cfn-s3-bucket.

    3. Supprimez le contenu du compartiment.

    4. Supprimez le compartiment.

  3. Nettoyez en IAM procédant comme suit :

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

    2. Supprimez la codecatalyst-deploy-policy.

    3. Supprimez la codecatalyst-build-policy.

    4. Supprimez la codecatalyst-stack-policy.

    5. Supprimez la codecatalyst-deploy-role.

    6. Supprimez la codecatalyst-build-role.

    7. Supprimez la codecatalyst-stack-role.

Dans ce didacticiel, vous avez appris à déployer une application sans serveur sous forme de CloudFormation pile à l'aide d'un CodeCatalyst flux de travail et d'une action de déploiement de AWS CloudFormation pile.