Tutorial: Implementazione di un'applicazione serverless - Amazon CodeCatalyst
PrerequisitiFase 1: Creare un archivio di sorgentiFase 2: Creare ruoli AWSFase 3: Aggiungere AWS ruoli a CodeCatalystFase 4: creare un bucket Amazon S3Passaggio 5: Aggiungere i file sorgentePassaggio 6: creare ed eseguire un flusso di lavoroFase 7: Apportare una modificaEliminazione

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Tutorial: Implementazione di un'applicazione serverless

In questo tutorial, imparerai come creare, testare e distribuire un'applicazione serverless come stack utilizzando un flusso di lavoro. CloudFormation

L'applicazione in questo tutorial è una semplice applicazione web che emette un messaggio «Hello World». Consiste in una AWS Lambda funzione e un Amazon API Gateway e lo si crea utilizzando AWS Serverless Application Model (AWS SAM), che è un'estensione di AWS CloudFormation.

Prerequisiti

Prima di iniziare:

  • È necessario uno CodeCatalyst spazio con un AWS account connesso. Per ulteriori informazioni, consulta Creare uno spazio.

  • Nel tuo spazio, hai bisogno di un progetto vuoto chiamato:

    codecatalyst-cfn-project

    Usa l'opzione Inizia da zero per creare questo progetto.

    Per ulteriori informazioni, consulta Creare un progetto vuoto in Amazon CodeCatalyst.

  • Nel tuo progetto, hai bisogno di un CodeCatalyst ambiente chiamato:

    codecatalyst-cfn-environment

    Configura questo ambiente come segue:

    • Scegli qualsiasi tipo, ad esempio Non di produzione.

    • Connect il tuo AWS account.

    • Per il IAMruolo predefinito, scegli un ruolo qualsiasi. Specificherai un ruolo diverso in seguito.

    Per ulteriori informazioni, consulta Implementazione in e Account AWS VPCs.

Fase 1: Creare un archivio di sorgenti

In questo passaggio, creerai un repository di sorgenti in. CodeCatalyst Questo repository viene utilizzato per archiviare i file sorgente del tutorial, come il file della funzione Lambda.

Per ulteriori informazioni sui repository dei sorgenti, consulta. Creazione di un repository di sorgenti

Per creare un archivio di sorgenti

  1. Nel CodeCatalyst riquadro di navigazione, scegli Codice, quindi scegli Archivi di origine.

  2. Scegli Aggiungi repository, quindi scegli Crea repository.

  3. Nel nome del repository, inserisci:

    codecatalyst-cfn-source-repository

  4. Scegli Crea.

Ora hai creato un repository chiamato. codecatalyst-cfn-source-repository

Fase 2: Creare ruoli AWS

In questo passaggio, crei i seguenti AWS IAM ruoli:

  • Ruolo Deploy: concede all'azione CodeCatalyst Deploy AWS CloudFormation stack l'autorizzazione ad accedere al tuo AWS account e al CloudFormation servizio su cui distribuirai la tua applicazione serverless. L'azione Deploy AWS CloudFormation stack fa parte del tuo flusso di lavoro.

  • Ruolo di compilazione: concede all'azione di CodeCatalyst compilazione l'autorizzazione ad accedere al tuo AWS account e scrivere su Amazon S3 dove verrà archiviato il pacchetto di applicazioni serverless. L'azione di compilazione fa parte del tuo flusso di lavoro.

  • Ruolo Stack: concede CloudFormation l'autorizzazione a leggere e modificare le risorse specificate nel AWS SAM modello che fornirai in seguito. Concede inoltre l'autorizzazione a. CloudWatch

Per ulteriori informazioni sui IAM ruoli, consulta IAMi ruoli nella Guida per l'AWS Identity and Access Management utente.

Nota

Per risparmiare tempo, puoi creare un solo ruolo, chiamato CodeCatalystWorkflowDevelopmentRole-spaceName ruolo, anziché i tre ruoli elencati in precedenza. Per ulteriori informazioni, consulta Creazione del CodeCatalystWorkflowDevelopmentRole-spaceNameruolo per il tuo account e il tuo spazio. Tieni presente che il CodeCatalystWorkflowDevelopmentRole-spaceName ruolo ha autorizzazioni molto ampie che possono rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante. Questo tutorial presuppone che stiate creando i tre ruoli elencati in precedenza.

Nota

È richiesto anche un ruolo di esecuzione Lambda, ma non è necessario crearlo ora perché il sam-template.yml file lo crea automaticamente quando si esegue il flusso di lavoro nel passaggio 5.

Per creare un ruolo di distribuzione

  1. Crea una politica per il ruolo, come segue:

    1. Accedi a AWS.

    2. Apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

    3. Nel pannello di navigazione, selezionare Policies (Policy).

    4. Scegli Create Policy (Crea policy).

    5. Scegliere la scheda JSON.

    6. Eliminare il codice esistente.

    7. Incolla il codice seguente:

      {
    "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"
}]
}
      Nota

      La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizza il carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.

      "Resource": "*"

    8. Scegliere Next: Tags (Successivo: Tag).

    9. Scegliere Next:Review (Successivo: Rivedi).

    10. In Nome, inserisci:

      codecatalyst-deploy-policy

    11. Scegli Crea policy.

      Ora hai creato una politica di autorizzazioni.

  2. Crea il ruolo di distribuzione, come segue:

    1. Nel riquadro di navigazione, scegli Ruoli e quindi Crea ruolo.

    2. Scegli una politica di fiducia personalizzata.

    3. Elimina la politica di fiducia personalizzata esistente.

    4. Aggiungi la seguente politica di fiducia personalizzata:

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

    5. Seleziona Successivo.

    6. Nelle politiche di autorizzazione, cerca codecatalyst-deploy-policy e seleziona la relativa casella di controllo.

    7. Seleziona Successivo.

    8. Per il nome del ruolo, inserisci:

      codecatalyst-deploy-role

    9. Per la descrizione del ruolo, inserisci:

      CodeCatalyst deploy role

    10. Scegli Crea ruolo.

    Ora hai creato un ruolo di distribuzione con una politica di fiducia e una politica di autorizzazioni.

  3. Ottieni il ruolo di distribuzioneARN, come segue:

    1. Nel riquadro di navigazione, seleziona Ruoli.

    2. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato (codecatalyst-deploy-role).

    3. Scegli il ruolo dall'elenco.

      Viene visualizzata la pagina di riepilogo del ruolo.

    4. In alto, copia il ARNvalore.

    Ora hai creato il ruolo di distribuzione con le autorizzazioni appropriate e lo hai ottenuto. ARN

Per creare un ruolo di costruzione

  1. Crea una politica per il ruolo, come segue:

    1. Accedi a AWS.

    2. Apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

    3. Nel pannello di navigazione, selezionare Policies (Policy).

    4. Scegli Create Policy (Crea policy).

    5. Scegliere la scheda JSON.

    6. Eliminare il codice esistente.

    7. Incolla il codice seguente:

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

      La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizza il carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.

      "Resource": "*"

    8. Scegliere Next: Tags (Successivo: Tag).

    9. Scegliere Next:Review (Successivo: Rivedi).

    10. In Nome, inserisci:

      codecatalyst-build-policy

    11. Scegli Crea policy.

      Ora hai creato una politica di autorizzazioni.

  2. Crea il ruolo di costruzione, come segue:

    1. Nel riquadro di navigazione, scegli Ruoli e quindi Crea ruolo.

    2. Scegli una politica di fiducia personalizzata.

    3. Elimina la politica di fiducia personalizzata esistente.

    4. Aggiungi la seguente politica di fiducia personalizzata:

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

    5. Seleziona Successivo.

    6. Nelle politiche di autorizzazione, cerca codecatalyst-build-policy e seleziona la relativa casella di controllo.

    7. Seleziona Successivo.

    8. Per il nome del ruolo, inserisci:

      codecatalyst-build-role

    9. Per la descrizione del ruolo, inserisci:

      CodeCatalyst build role

    10. Scegli Crea ruolo.

    Ora hai creato un ruolo di sviluppo con una politica di fiducia e una politica di autorizzazioni.

  3. Ottieni il ruolo di costruzioneARN, come segue:

    1. Nel riquadro di navigazione, seleziona Ruoli.

    2. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato (codecatalyst-build-role).

    3. Scegli il ruolo dall'elenco.

      Viene visualizzata la pagina di riepilogo del ruolo.

    4. In alto, copia il ARNvalore.

    Ora hai creato il ruolo di costruzione con le autorizzazioni appropriate e lo hai ottenuto. ARN

Per creare un ruolo stack

  1. Accedi AWS utilizzando l'account in cui desideri distribuire il tuo stack.

  2. Apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  3. Crea il ruolo dello stack come segue:

    1. Nel pannello di navigazione, seleziona Roles (Ruoli).

    2. Selezionare Create role (Crea ruolo).

    3. Scegli un servizio in Servizio AWS .

    4. Nella sezione Caso d'uso, scegli CloudFormationdall'elenco a discesa.

    5. Seleziona il pulsante CloudFormationradio.

    6. In basso, scegli Avanti.

    7. Utilizzando la casella di ricerca, trova le seguenti politiche di autorizzazione, quindi seleziona le rispettive caselle di controllo.

      Nota

      Se cerchi una politica e questa non viene visualizzata, assicurati di scegliere Cancella filtri e riprova.

      • CloudWatchFullAccess

      • AWS CloudFormationFullAccess

      • IAMFullAccess

      • AWS Lambda_ FullAccess

      • Un amministratore mazonAPIGateway

      • Amazon S3 FullAccess

      • Amazon EC2ContainerRegistryFullAccess

      La prima policy consente l'accesso per CloudWatch abilitare i rollback dello stack quando si verifica un allarme.

      Le politiche rimanenti consentono di accedere AWS SAM ai servizi e alle risorse dello stack che verrà distribuito in questo tutorial. Per ulteriori informazioni, consulta Autorizzazioni nella Guida per gli AWS Serverless Application Model sviluppatori.

    8. Seleziona Successivo.

    9. Per il nome del ruolo, inserisci:

      codecatalyst-stack-role

    10. Scegli Crea ruolo.

  4. Ottieni i ruoli dello stackARN, come segue:

    1. Nel riquadro di navigazione, seleziona Ruoli.

    2. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato (codecatalyst-stack-role).

    3. Scegli il ruolo dall'elenco.

    4. Nella sezione Riepilogo, copia il ARNvalore. perché sarà necessaria in seguito.

    Ora hai creato il ruolo stack con le autorizzazioni appropriate e lo hai ottenuto. ARN

Fase 3: Aggiungere AWS ruoli a CodeCatalyst

In questo passaggio, aggiungi build role (codecatalyst-build-role) e deploy role (codecatalyst-deploy-role) alla connessione dell' CodeCatalyst account nel tuo spazio.

Nota

Non è necessario aggiungere lo stack role (codecatalyst-stack-role) alla connessione. Questo perché il ruolo stack viene utilizzato da CloudFormation(non CodeCatalyst), dopo che è già stata stabilita una connessione tra CodeCatalyst e AWS utilizzando il ruolo deploy. Poiché il ruolo stack non viene utilizzato per accedere CodeCatalyst a AWS, non è necessario che sia associato a una connessione all'account.

Per aggiungere ruoli, build e deploy alla connessione del tuo account

  1. Nel CodeCatalyst, accedi al tuo spazio.

  2. Seleziona AWS accounts (Account). Viene visualizzato un elenco di connessioni all'account.

  3. Scegli la connessione all'account che rappresenta l' AWS account in cui hai creato i ruoli di compilazione e distribuzione.

  4. Scegli Gestisci ruoli dalla console AWS di gestione.

    Viene visualizzata la pagina Aggiungi IAM ruolo CodeCatalyst allo spazio Amazon. Potrebbe essere necessario effettuare il login per accedere alla pagina.

  5. Seleziona Aggiungi un ruolo esistente in cui hai creato IAM.

    Viene visualizzato un elenco a discesa. L'elenco mostra tutti i IAM ruoli con una politica di fiducia che include i principali del codecatalyst-runner.amazonaws.com codecatalyst.amazonaws.com servizio.

  6. Nell'elenco a discesacodecatalyst-build-role, scegli e scegli Aggiungi ruolo.

  7. Scegli Aggiungi IAM ruolo, scegli Aggiungi un ruolo esistente in cui hai creato eIAM, nell'elenco a discesa, scegli. codecatalyst-deploy-role Scegliere Add role (Aggiungi ruolo).

    Ora hai aggiunto i ruoli di creazione e distribuzione al tuo spazio.

  8. Copia il valore del nome CodeCatalyst visualizzato di Amazon. Questo valore ti servirà in seguito, durante la creazione del tuo flusso di lavoro.

Fase 4: creare un bucket Amazon S3

In questa fase, crei un bucket Amazon S3 in cui archiviare il file.zip del pacchetto di distribuzione dell'applicazione serverless.

Come creare un bucket Amazon S3.

  1. Apri la console Amazon S3 all'indirizzo. https://console.aws.amazon.com/s3/

  2. Nel riquadro principale, scegli Crea bucket.

  3. Per il nome del bucket, inserisci:

    codecatalyst-cfn-s3-bucket

  4. In AWS Region (Regione), scegliere una Regione. Questo tutorial presuppone che tu abbia scelto US West (Oregon) us-west-2. Per informazioni sulle regioni supportate da Amazon S3, consulta gli endpoint e le quote di Amazon Simple Storage Service nel. Riferimenti generali di AWS

  5. Nella parte inferiore della pagina, scegli Crea bucket.

Ora hai creato un bucket chiamato codecatalyst-cfn-s3-bucket nella regione us-west-2 degli Stati Uniti occidentali (Oregon).

Passaggio 5: Aggiungere i file sorgente

In questo passaggio, aggiungi diversi file sorgente dell'applicazione al tuo repository CodeCatalyst di origine. La hello-world cartella contiene i file dell'applicazione che distribuirete. La tests cartella contiene i test unitari. La struttura delle cartelle è la seguente:

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

file.npmignore

Il .npmignore file indica quali file e cartelle npm deve escludere dal pacchetto dell'applicazione. In questo tutorial, npm esclude la tests cartella perché non fa parte dell'applicazione.

Per aggiungere il file.npmignore

  1. Apri la console all'indirizzo https://codecatalyst.aws/ CodeCatalyst .

  2. Scegli il tuo progetto, codecatalyst-cfn-project

  3. Nel riquadro di navigazione, scegli Codice, quindi scegli Archivi di origine.

  4. Dall'elenco dei repository di origine, scegli il tuo repository,. codecatalyst-cfn-source-repository

  5. In File, scegli Crea file.

  6. Per Nome file, inserisci:

    .npmignore

  7. Nella casella di testo, inserisci il seguente codice:

    tests/*

  8. Scegliete Commit, quindi scegliete nuovamente Commit.

    Ora hai creato un file chiamato .npmignore nella radice del tuo repository.

file package.json

Il package.json file contiene importanti metadati sul progetto Node, come il nome del progetto, il numero di versione, la descrizione, le dipendenze e altri dettagli che descrivono come interagire ed eseguire l'applicazione.

package.jsonIn questo tutorial sono inclusi un elenco di dipendenze e uno script. test Lo script di test esegue le seguenti operazioni:

  • Utilizzando mocha, lo script di test esegue i test unitari specificati in hello-world/tests/unit/ e scrive i risultati in un junit.xml file utilizzando il reporter xunit.

  • Utilizzando Istanbul (nyc), lo script di test genera un rapporto sulla copertura del codice (clover.xml) utilizzando il clover reporter. Per ulteriori informazioni, consulta Usare reporter alternativi nella documentazione di Istanbul.

Per aggiungere il file package.json

  1. Nel tuo repository, in File, scegli Crea file.

  2. Per Nome file, inserisci:

    package.json

  3. Nella casella di testo, inserisci il seguente codice:

    {
  "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. Scegliete Commit, quindi scegliete nuovamente Commit.

    Ora hai aggiunto un file chiamato package.json alla radice del repository.

file sam-template.yml

Il sam-template.yml file contiene le istruzioni per implementare la funzione Lambda API e Gateway e configurarli insieme. Segue la specifica del AWS Serverless Application Model modello, che estende la specifica del AWS CloudFormation modello.

In questo tutorial utilizzi un AWS SAM modello invece di un AWS CloudFormation modello normale perché AWS SAM offre un utile tipo di risorsa AWS: :Serverless: :Function. Questo tipo esegue molte behind-the-scenes configurazioni che normalmente è necessario scrivere per utilizzare la sintassi di base. CloudFormation Ad esempio, AWS::Serverless::Function crea una funzione Lambda, un ruolo di esecuzione Lambda e mappature delle sorgenti degli eventi che avviano la funzione. Devi codificare tutto questo se vuoi scriverlo usando basic. CloudFormation

Sebbene questo tutorial utilizzi un modello già scritto, puoi generarne uno come parte del tuo flusso di lavoro utilizzando un'azione di compilazione. Per ulteriori informazioni, consulta Implementazione di uno stack AWS CloudFormation.

Per aggiungere il file sam-template.yml

  1. Nel tuo repository, in File, scegli Crea file.

  2. Per Nome file, inserisci:

    sam-template.yml

  3. Nella casella di testo, inserisci il seguente codice:

    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. Scegliete Commit, quindi scegliete nuovamente Commit.

    Ora hai aggiunto un file chiamato sam-template.yml nella cartella principale del tuo repository.

file setup-sam.sh

Il setup-sam.sh file contiene le istruzioni per scaricare e installare l' AWS SAM CLIutilità. Il flusso di lavoro utilizza questa utilità per impacchettare il hello-world codice sorgente.

Per aggiungere il file setup-sam.sh

  1. Nel tuo repository, in File, scegli Crea file.

  2. Per Nome file, inserisci:

    setup-sam.sh

  3. Nella casella di testo, inserisci il seguente codice:

    #!/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

    Nel codice precedente, sostituisci us-west-2 con la tua AWS regione.

  4. Scegli Commetti, quindi scegli di nuovo Commetti.

    Ora hai aggiunto un file chiamato setup-sam.sh alla radice del repository.

file app.js

app.jsContiene il codice della funzione Lambda. In questo tutorial, il codice restituisce il testohello world.

Per aggiungere il file app.js

  1. Nel tuo repository, in File, scegli Crea file.

  2. Per Nome file, inserisci:

    hello-world/app.js

  3. Nella casella di testo, inserisci il seguente codice:

    // 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. Scegliete Commit, quindi scegliete nuovamente Commit.

    Ora hai creato una cartella chiamata hello-world e un file chiamatoapp.js.

file test-handler.js

Il test-handler.js file contiene test unitari per la funzione Lambda.

Per aggiungere il file test-handler.js

  1. Nel tuo repository, in File, scegli Crea file.

  2. Per Nome file, inserisci:

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

  3. Nella casella di testo, inserisci il seguente codice:

    '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. Scegliete Commit, quindi scegliete nuovamente Commit.

    Ora hai aggiunto un file chiamato test-handler.js sotto la hello-world/tests/unit cartella.

Ora hai aggiunto tutti i tuoi file sorgente.

Prenditi un momento per ricontrollare il tuo lavoro e assicurati di aver inserito tutti i file nelle cartelle corrette. La struttura delle cartelle è la seguente:

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

Passaggio 6: creare ed eseguire un flusso di lavoro

In questo passaggio, crei un flusso di lavoro che impacchetta il codice sorgente Lambda e lo distribuisce. Il flusso di lavoro è costituito dai seguenti elementi costitutivi eseguiti in sequenza:

  • Un trigger: questo trigger avvia l'esecuzione automatica del flusso di lavoro quando invii una modifica al tuo repository di origine. Per ulteriori informazioni sui trigger, consulta L'avvio di un flusso di lavoro viene eseguito automaticamente utilizzando i trigger.

  • Un'azione di test (Test): al momento del trigger, questa azione installa il gestore di pacchetti Node (npm), quindi esegue il comando. npm run test Questo comando dice a npm di eseguire lo test script definito nel file. package.json Lo test script, a sua volta, esegue gli unit test e genera due report: un test report (junit.xml) e un rapporto sulla copertura del codice (clover.xml). Per ulteriori informazioni, consulta file package.json.

    Successivamente, l'azione di test trasforma i XML report in CodeCatalyst report e li visualizza nella CodeCatalyst console, nella scheda Report dell'azione di test.

    Per ulteriori informazioni sull'azione di test, vedereTest con flussi di lavoro.

  • Un'azione di compilazione (BuildBackend): al termine dell'azione di test, l'azione di compilazione scarica e installa AWS SAM CLI, impacchetta il hello-world codice sorgente e lo copia nel bucket Amazon S3, dove il servizio Lambda prevede che si trovi. L'azione genera anche un nuovo file AWS SAM modello chiamato sam-template-packaged.yml e lo inserisce in un elemento di output chiamato. buildArtifact

    Per ulteriori informazioni sull'azione di compilazione, consulta. Creazione con flussi di lavoro

  • A deploy action (DeployCloudFormationStack): al termine dell'azione di compilazione, l'azione deploy cerca l'artefatto di output generato dall'azione di compilazione (buildArtifact), trova il AWS SAM modello al suo interno e quindi esegue il modello. Il AWS SAM modello crea uno stack che distribuisce l'applicazione serverless.

Creazione di un flusso di lavoro

  1. Nel riquadro di navigazione, scegli CI/CD, quindi scegli Flussi di lavoro.

  2. Scegli Crea flusso di lavoro.

  3. Per Source repository, sceglicodecatalyst-cfn-source-repository.

  4. Per Branch, sceglimain.

  5. Scegli Crea.

  6. Elimina il codice YAML di esempio.

  7. Aggiungi il YAML codice seguente:

    Nota

    Nel YAML codice che segue, puoi omettere le Connections: sezioni se lo desideri. Se si omettono queste sezioni, è necessario assicurarsi che il ruolo specificato nel campo Ruolo predefinito IAM nel proprio ambiente includa le autorizzazioni e le politiche di fiducia di entrambi i ruoli descritte in. Fase 2: Creare ruoli AWS Per ulteriori informazioni sulla configurazione di un ambiente con un IAM ruolo predefinito, vedere. Creazione di un ambiente

    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

    Nel codice precedente, sostituisci:

    • Entrambe le istanze di codecatalyst-cfn-environment con il nome del tuo ambiente.

    • Entrambe le istanze di codecatalyst-account-connection con il nome visualizzato della connessione all'account. Il nome visualizzato potrebbe essere un numero. Per ulteriori informazioni, consulta Fase 3: Aggiungere AWS ruoli a CodeCatalyst.

    • codecatalyst-build-role con il nome del ruolo di build in cui hai creatoFase 2: Creare ruoli AWS.

    • codecatalyst-cfn-s3-bucket con il nome del bucket Amazon S3 in cui hai creato. Fase 4: creare un bucket Amazon S3

    • Entrambe le istanze di us-west-2 con la regione in cui risiede il bucket Amazon S3 (prima istanza) e dove verrà distribuito lo stack (seconda istanza). Queste regioni possono essere diverse. Questo tutorial presuppone che entrambe le regioni siano impostate su. us-west-2 Per informazioni dettagliate sulle regioni supportate da Amazon S3 e AWS CloudFormation, consulta Endpoint e quote del servizio nel. Riferimenti generali di AWS

    • codecatalyst-deploy-role con il nome del ruolo di distribuzione in cui hai creato. Fase 2: Creare ruoli AWS

    • codecatalyst-cfn-environment con il nome dell'ambiente in Prerequisiti cui hai creato.

    • arn:aws:iam::111122223333:role/StackRole con l'Amazon Resource Name (ARN) dello stack role in Fase 2: Creare ruoli AWS cui hai creato.

      Nota

      Se hai deciso di non creare ruoli, build, deploy e stack, sostituiscili codecatalyst-build-role, codecatalyst-deploy-rolee arn:aws:iam::111122223333:role/StackRole con il nome o ARN del CodeCatalystWorkflowDevelopmentRole-spaceName ruolo. Per ulteriori informazioni su questo ruolo, consulta Fase 2: Creare ruoli AWS.

    Per informazioni sulle proprietà del codice mostrato in precedenza, vedereAzione 'Implementa AWS CloudFormation stack' YAML.

  8. (Facoltativo) Scegliete Convalida per assicurarvi che il YAML codice sia valido prima di eseguire il commit.

  9. Scegli Applica.

  10. Nella finestra di dialogo Conferma flusso di lavoro, inserisci quanto segue:

    1. Per il nome del file Workflow, mantenete il valore predefinito,codecatalyst-cfn-workflow.

    2. Per il messaggio di conferma, inserisci:

      add initial workflow file

    3. Per Repository, scegli codecatalyst-cfn-source-repository.

    4. Per il nome del ramo, scegli principale.

    5. Scegli Applica.

    Ora hai creato un flusso di lavoro. L'esecuzione di un flusso di lavoro viene avviata automaticamente a causa del trigger definito nella parte superiore del flusso di lavoro. In particolare, quando hai eseguito il commit (e inviato) del codecatalyst-cfn-workflow.yaml file nell'archivio di origine, il trigger ha avviato l'esecuzione del flusso di lavoro.

Per visualizzare il flusso di lavoro in corso

  1. Nel riquadro di navigazione, scegli CI/CD, quindi scegli Flussi di lavoro.

  2. Scegli il flusso di lavoro che hai appena creato:. codecatalyst-cfn-workflow

  3. Scegli la scheda Esecuzioni.

  4. Nella colonna Run ID, scegli l'ID di esecuzione.

  5. Scegli Test per vedere lo stato di avanzamento dei test.

  6. Scegli BuildBackenddi vedere lo stato di avanzamento della costruzione.

  7. Scegli DeployCloudFormationStackdi vedere lo stato di avanzamento della distribuzione.

    Per ulteriori informazioni sulla visualizzazione dei dettagli dell'esecuzione, consultaVisualizzazione dello stato e dei dettagli dell'esecuzione del flusso di lavoro.

  8. Al termine dell'DeployCloudFormationStackazione, procedi come segue:

    • Se l'esecuzione del flusso di lavoro è riuscita, passate alla procedura successiva.

    • Se l'esecuzione del flusso di lavoro non è riuscita durante il test o BuildBackendl'azione, scegli Registri per risolvere il problema.

    • Se l'esecuzione del flusso di lavoro non è riuscita nell'DeployCloudFormationStackazione, scegli l'azione di distribuzione, quindi scegli la scheda Riepilogo. Scorri fino alla sezione CloudFormation degli eventi per visualizzare il messaggio di errore dettagliato. Se si è verificato un rollback, elimina lo codecatalyst-cfn-stack stack tramite la AWS CloudFormation console AWS prima di eseguire nuovamente il flusso di lavoro.

Per verificare la distribuzione

  1. Dopo una distribuzione riuscita, scegli Variabili (7) dalla barra dei menu orizzontale in alto. (Non scegliete Variabili nel riquadro a destra).

  2. Successivamente HelloWorldApi, incollali https:// URL in un browser.

    Viene visualizzato un JSONmessaggio di benvenuto dalla funzione Lambda, che indica che il flusso di lavoro ha distribuito e configurato correttamente la funzione Lambda e il Gateway. API

    Suggerimento

    È possibile CodeCatalyst visualizzarlo URL nel diagramma del flusso di lavoro con alcune piccole configurazioni. Per ulteriori informazioni, consulta Visualizzazione dell'app URL nel diagramma del flusso di lavoro.

Per verificare i risultati dei test unitari e la copertura del codice

  1. Nel diagramma del flusso di lavoro, scegli Test, quindi scegli Report.

  2. Scegliete di TestReportvisualizzare i risultati del test unitario o scegliete di CoverageReportvisualizzare i dettagli della copertura del codice dei file da testare, in questo caso, app.js etest-handler.js.

Per verificare le risorse distribuite

  1. Accedi a AWS Management Console e apri la console API Gateway all'indirizzo https://console.aws.amazon.com/apigateway/.

  2. Osserva codecatalyst-cfn-stackAPIil AWS SAM modello creato. Il API nome deriva dal Configuration/name valore nel file di definizione del flusso di lavoro (codecatalyst-cfn-workflow.yaml).

  3. Apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

  4. Nel riquadro di navigazione, seleziona Funzioni.

  5. Scegli la tua funzione Lambda,. codecatalyst-cfn-stack-HelloWorldFunction-string

  6. Puoi vedere come il API Gateway funge da trigger per la funzione. Questa integrazione è stata configurata automaticamente in base al tipo di AWS SAM AWS::Serverless::Function risorsa.

Fase 7: Apportare una modifica

In questo passaggio, apporti una modifica al codice sorgente Lambda e la esegui il commit. Questo commit avvia l'esecuzione di un nuovo flusso di lavoro. Questa esecuzione implementa la nuova funzione Lambda in uno schema blu-verde che utilizza la configurazione di spostamento del traffico predefinita specificata nella console Lambda.

Per apportare una modifica alla sorgente Lambda

  1. In CodeCatalyst, accedi al tuo progetto.

  2. Nel riquadro di navigazione, scegli Codice, quindi scegli Archivi di origine.

  3. Scegli il tuo repository codecatalyst-cfn-source-repository di origine.

  4. Cambia il file dell'applicazione:

    1. Scegliere la cartella hello-world.

    2. Scegli il app.js file.

    3. Scegli Modifica.

    4. Sulla riga 23, cambia hello world inTutorial complete!.

    5. Scegli Commetti, quindi scegli di nuovo Commetti.

      Il commit avvia l'esecuzione di un flusso di lavoro. Questa esecuzione avrà esito negativo perché non hai aggiornato gli unit test in modo che riflettano la modifica del nome.

  5. Aggiorna i test unitari:

    1. Scegli hello-world\tests\unit\test-handler.js.

    2. Scegli Modifica.

    3. Sulla riga 19, passare hello world aTutorial complete!.

    4. Scegli Commetti, quindi scegli di nuovo Commetti.

      Il commit provoca l'avvio di un altro flusso di lavoro. L'esecuzione avrà esito positivo.

  6. Nel riquadro di navigazione, scegli CI/CD, quindi scegli Flussi di lavoro.

  7. Sceglicodecatalyst-cfn-workflow, quindi scegli Esecuzioni.

  8. Scegli l'ID di esecuzione dell'ultima esecuzione. Dovrebbe essere ancora in corso.

  9. Scegliete Test BuildBackend, e DeployCloudFormationStackper vedere l'avanzamento del flusso di lavoro viene eseguito.

  10. Al termine del flusso di lavoro, scegli Variabili (7) nella parte superiore.

  11. Successivamente HelloWorldApi, incollali https:// URL in un browser.

    Nel browser viene visualizzato un Tutorial complete! messaggio che indica che la nuova applicazione è stata distribuita correttamente.

Eliminazione

Pulisci i file e i servizi utilizzati in questo tutorial per evitare che ti vengano addebitati dei costi.

Per pulire la CodeCatalyst console

  1. Apri la CodeCatalyst console all'indirizzo https://codecatalyst.aws/.

  2. Eliminacodecatalyst-cfn-workflow.

  3. Eliminarecodecatalyst-cfn-environment.

  4. Eliminarecodecatalyst-cfn-source-repository.

  5. Eliminarecodecatalyst-cfn-project.

Per pulire in AWS Management Console

  1. Effettuare CloudFormation la pulizia nel modo seguente:

    1. Apri la AWS CloudFormation console all'indirizzo https://console.aws.amazon.com/cloudformation.

    2. Eliminare il codecatalyst-cfn-stack.

      L'eliminazione dello stack rimuove tutte le risorse del tutorial dai servizi API Gateway e Lambda.

  2. Esegui la pulizia in Amazon S3, come segue:

    1. Apri la console Amazon S3 all'indirizzo. https://console.aws.amazon.com/s3/

    2. Seleziona codecatalyst-cfn-s3-bucket.

    3. Elimina il contenuto del bucket.

    4. Elimina il bucket.

  3. Effettua la pulizia nel IAM modo seguente:

    1. Apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

    2. Eliminare il codecatalyst-deploy-policy.

    3. Eliminare il codecatalyst-build-policy.

    4. Eliminare il codecatalyst-stack-policy.

    5. Eliminare il codecatalyst-deploy-role.

    6. Eliminare il codecatalyst-build-role.

    7. Eliminare il codecatalyst-stack-role.

In questo tutorial, hai imparato a distribuire un'applicazione serverless come CloudFormation stack utilizzando un CodeCatalyst flusso di lavoro e un'azione AWS CloudFormation Deploy stack.