Tutorial: implementación de una aplicación sin servidor - Amazon CodeCatalyst
Requisitos previosPaso 1: crear un repositorio de código fuentePaso 2: crear roles de AWSPaso 3: añadir roles de AWS a CodeCatalystPaso 4: crear un bucket de Amazon S3Paso 5: añadir archivos de código fuentePaso 6: crear y ejecutar un flujo de trabajoPaso 7: realizar un cambioLimpieza

Tutorial: implementación de una aplicación sin servidor

En este tutorial, aprenderá a compilar, probar e implementar una aplicación sin servidor como una pila de CloudFormation mediante un flujo de trabajo.

La aplicación de este tutorial es una aplicación web sencilla que genera un mensaje “Hello World”. Se compone de una función de AWS Lambda y una instancia de Amazon API Gateway, y se crea mediante el AWS Serverless Application Model(AWS SAM), que es una extensión de AWS CloudFormation.

Requisitos previos

Antes de empezar

  • Necesita un espacio de CodeCatalyst con una cuenta de AWS conectada. Para obtener más información, consulte Creación de un espacio.

  • En su espacio, necesita un proyecto vacío llamado:

    codecatalyst-cfn-project

    Use la opción Empezar desde cero para crear este proyecto.

    Para obtener más información, consulte Creación de un proyecto vacío en Amazon CodeCatalyst.

  • En su proyecto, necesita un entorno de CodeCatalyst llamado:

    codecatalyst-cfn-environment

    Configure este entorno de la siguiente manera:

    • Elija cualquier tipo, como Sin producción.

    • Conecte su cuenta de AWS al entorno.

    • En Rol de IAM predeterminado, elija cualquier rol. Especificará un rol diferente más adelante.

    Para obtener más información, consulte Implementación en Cuentas de AWS y VPC.

Paso 1: crear un repositorio de código fuente

En este paso, creará un repositorio de código fuente en CodeCatalyst. Este repositorio se utiliza para almacenar los archivos de código fuente del tutorial, como el archivo de funciones de Lambda.

Para obtener más información sobre los repositorios de código fuente, consulte Creación de un repositorio de código fuente.

Creación de un repositorio de código fuente

  1. En CodeCatalyst, elija Código y, a continuación, elija Repositorios de código fuente.

  2. Elija Agregar repositorio y, a continuación, elija Crear repositorio.

  3. En Nombre del repositorio, escriba:

    codecatalyst-cfn-source-repository

  4. Seleccione Crear.

Ahora ha creado un repositorio llamado codecatalyst-cfn-source-repository.

Paso 2: crear roles de AWS

En este paso, creará los siguientes roles de AWS IAM:

  • Rol de implementación: concede a la acción Deploy AWS CloudFormation stack de CodeCatalyst permiso para acceder a su cuenta de AWS y al servicio CloudFormation, donde implementará la aplicación sin servidor. La acción Deploy AWS CloudFormation stack forma parte de su flujo de trabajo.

  • Rol de compilación: concede a la acción de compilación de CodeCatalyst permiso para acceder a su cuenta de AWS y escribir en Amazon S3, donde se almacenará la aplicación sin servidor. La acción de compilación forma parte de su flujo de trabajo.

  • Rol de pila: concede a CloudFormation permiso para leer y modificar los recursos especificados en la plantilla de AWS SAM que proporcionará más adelante. También concede permiso a CloudWatch.

Para obtener más información sobre los roles de IAM, consulte Roles de IAM en la Guía del usuario de AWS Identity and Access Management.

nota

Para ahorrar tiempo, puede crear un único rol, denominado rol CodeCatalystWorkflowDevelopmentRole-spaceName, en lugar de los tres roles indicados anteriormente. Para obtener más información, consulte Creación del rol CodeCatalystWorkflowDevelopmentRole-spaceName para su cuenta y su espacio. Tenga en cuenta que el rol CodeCatalystWorkflowDevelopmentRole-spaceName tiene permisos muy amplios, lo que puede suponer un riesgo para la seguridad. Le recomendamos que utilice este rol solo en tutoriales y situaciones en las que la seguridad no sea un problema. En este tutorial se presupone que va a crear los tres roles indicados anteriormente.

nota

También se requiere un rol de ejecución de Lambda, pero no es necesario que lo cree ahora porque el archivo sam-template.yml lo crea automáticamente cuando ejecuta el flujo de trabajo en el paso 5.

Creación de un rol de implementación

  1. Cree una política para el rol del modo siguiente:

    1. Inicie sesión en AWS.

    2. Abra la consola de IAM en https://console.aws.amazon.com/iam/.

    3. En el panel de navegación, seleccione Políticas.

    4. Elija Create Policy (Crear política).

    5. Seleccione la pestaña JSON.

    6. Elimine el código existente.

    7. Pegue el siguiente código:

      {
    "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 primera vez que utilice el rol para ejecutar acciones de flujo de trabajo, use el comodín en la instrucción de política de recursos y, a continuación, precise el ámbito de la política con el nombre del recurso cuando esté disponible.

      "Resource": "*"

    8. Elija Siguiente: Etiquetas.

    9. Elija Siguiente: Revisar.

    10. En Nombre, escriba:

      codecatalyst-deploy-policy

    11. Elija Crear política.

      Ahora ha creado una política de permisos.

  2. Cree el rol de implementación de la siguiente manera:

    1. En el panel de navegación, seleccione Roles y luego seleccione Crear rol.

    2. Elija Política de confianza personalizada.

    3. Elimine la política de confianza personalizada existente.

    4. Añada la siguiente política de confianza personalizada:

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

    5. Elija Siguiente.

    6. En Políticas de permisos, busque codecatalyst-deploy-policy y active su casilla de verificación.

    7. Elija Siguiente.

    8. En Nombre del rol, escriba:

      codecatalyst-deploy-role

    9. En Descripción del rol, escriba:

      CodeCatalyst deploy role

    10. Elija Crear rol.

    Ahora ha creado un rol de implementación con una política de confianza y una política de permisos.

  3. Obtenga el ARN del rol de implementación de la siguiente manera:

    1. Seleccione Roles en el panel de navegación.

    2. En el cuadro de búsqueda, introduzca el nombre del rol que acaba de crear (codecatalyst-deploy-role).

    3. Elija el rol de la lista.

      Aparece la página Resumen del rol.

    4. En la parte superior, copie el valor de ARN.

    Ahora ha creado el rol de implementación con los permisos adecuados y ha obtenido su ARN.

Creación de un rol de compilación

  1. Cree una política para el rol del modo siguiente:

    1. Inicie sesión en AWS.

    2. Abra la consola de IAM en https://console.aws.amazon.com/iam/.

    3. En el panel de navegación, seleccione Políticas.

    4. Elija Create Policy (Crear política).

    5. Seleccione la pestaña JSON.

    6. Elimine el código existente.

    7. Pegue el siguiente código:

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

      La primera vez que utilice el rol para ejecutar acciones de flujo de trabajo, use el comodín en la instrucción de política de recursos y, a continuación, precise el ámbito de la política con el nombre del recurso cuando esté disponible.

      "Resource": "*"

    8. Elija Siguiente: Etiquetas.

    9. Elija Siguiente: Revisar.

    10. En Nombre, escriba:

      codecatalyst-build-policy

    11. Elija Crear política.

      Ahora ha creado una política de permisos.

  2. Cree el rol de compilación de la siguiente manera:

    1. En el panel de navegación, seleccione Roles y luego seleccione Crear rol.

    2. Elija Política de confianza personalizada.

    3. Elimine la política de confianza personalizada existente.

    4. Añada la siguiente política de confianza personalizada:

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

    5. Elija Siguiente.

    6. En Políticas de permisos, busque codecatalyst-build-policy y active su casilla de verificación.

    7. Elija Siguiente.

    8. En Nombre del rol, escriba:

      codecatalyst-build-role

    9. En Descripción del rol, escriba:

      CodeCatalyst build role

    10. Elija Crear rol.

    Ahora ha creado un rol de compilación con una política de confianza y una política de permisos.

  3. Obtenga el ARN del rol de compilación de la siguiente manera:

    1. Seleccione Roles en el panel de navegación.

    2. En el cuadro de búsqueda, introduzca el nombre del rol que acaba de crear (codecatalyst-build-role).

    3. Elija el rol de la lista.

      Aparece la página Resumen del rol.

    4. En la parte superior, copie el valor de ARN.

    Ahora ha creado el rol de compilación con los permisos adecuados y ha obtenido su ARN.

Creación de un rol de pila

  1. Inicie sesión en AWS con la cuenta en la que desea implementar la pila.

  2. Abra la consola de IAM en https://console.aws.amazon.com/iam/.

  3. Cree el rol de pila de la siguiente manera:

    1. Seleccione Roles en el panel de navegación.

    2. Elija Crear rol.

    3. Elija Servicio de AWS.

    4. En la sección Caso de uso, elija CloudFormation en la lista desplegable.

    5. Seleccione el botón de opción CloudFormation.

    6. En la parte inferior, elija Siguiente.

    7. En el cuadro de búsqueda, busque las siguientes políticas de permisos y, a continuación, active las casillas de verificación correspondientes.

      nota

      Si busca una política y no aparece, asegúrese de seleccionar Borrar filtros e inténtelo de nuevo.

      • CloudWatchFullAccess

      • AWSCloudFormationFullAccess

      • IAMFullAccess

      • AWSLambda_FullAccess

      • AmazonAPIGatewayAdministrator

      • AmazonS3FullAccess

      • AmazonEC2ContainerRegistryFullAccess

      La primera política permite el acceso a CloudWatch para que pueda revertir la pila cuando se produzca una alarma.

      Las políticas restantes permiten a AWS SAM acceder a los servicios y recursos de la pila que se implementarán en este tutorial. Para obtener más información, consulte Permisos en la Guía para desarrolladores de AWS Serverless Application Model.

    8. Elija Siguiente.

    9. En Nombre del rol, escriba:

      codecatalyst-stack-role

    10. Elija Crear rol.

  4. Obtenga el ARN del rol de pila de la siguiente manera:

    1. Seleccione Roles en el panel de navegación.

    2. En el cuadro de búsqueda, introduzca el nombre del rol que acaba de crear (codecatalyst-stack-role).

    3. Elija el rol de la lista.

    4. En la sección Resumen, copie el valor de ARN. Lo necesitará más adelante.

    Ahora ha creado el rol de pila con los permisos adecuados y ha obtenido su ARN.

Paso 3: añadir roles de AWS a CodeCatalyst

En este paso, añadirá el rol de compilación (codecatalyst-build-role) y el rol de implementación (codecatalyst-deploy-role) a la conexión de cuenta de CodeCatalyst en su espacio.

nota

No es necesario añadir el rol de pila (codecatalyst-stack-role) a la conexión. Esto se debe a que CloudFormation (no CodeCatalyst) utiliza el rol de pila después de que ya se haya establecido una conexión entre CodeCatalyst y AWS mediante el rol de implementación. Como CodeCatalyst no utiliza el rol de pila para acceder a AWS, no es necesario que esté asociado a una conexión de cuenta.

Incorporación de roles de compilación e implementación a la conexión de cuenta

  1. En CodeCatalyst, vaya a su espacio.

  2. Elija Cuentas de AWS. Aparecerá una lista de conexiones de cuenta.

  3. Elija la conexión de cuenta que represente la cuenta de AWS en la que creó los roles de compilación e implementación.

  4. Elija Administrar roles desde la Consola de administración de AWS.

    Aparece la página Agregar el rol de IAM al espacio de Amazon CodeCatalyst. Es posible que tenga que iniciar sesión para acceder a la página.

  5. Seleccione Agregar un rol existente que haya creado en IAM.

    Se muestra una lista desplegable. La lista muestra todos los roles de IAM con una política de confianza que incluye las entidades principales de los servicios codecatalyst-runner.amazonaws.com y codecatalyst.amazonaws.com.

  6. En la lista desplegable, elija codecatalyst-build-role y, a continuación, elija Agregar rol.

  7. Seleccione Agregar rol de IAM, seleccione Agregar un rol existente que haya creado en IAM y, en la lista desplegable, elija codecatalyst-deploy-role. Seleccione Add role (Añadir rol).

    Ahora ha añadido los roles de compilación e implementación a su espacio.

  8. Copie el valor del nombre de visualización de Amazon CodeCatalyst. Necesitará este valor más adelante, cuando cree el flujo de trabajo.

Paso 4: crear un bucket de Amazon S3

En este paso, creará un bucket de Amazon S3 en el que se almacenará el archivo .zip del paquete de implementación de la aplicación sin servidor.

Creación de un bucket de Amazon S3

  1. Abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

  2. En el panel principal, elija Crear bucket.

  3. En Nombre del bucket, escriba:

    codecatalyst-cfn-s3-bucket

  4. En AWS Región, seleccione una región. En este tutorial, se asume que ha elegido Oeste de EE. UU. (Oregón) us-west-2. Para obtener más información sobre las regiones admitidas en Amazon S3, consulte Puntos de conexión y cuotas de Amazon Simple Storage Service en la Referencia general de AWS.

  5. En la parte inferior de la página, elija Crear bucket.

Ahora ha creado un bucket llamado codecatalyst-cfn-s3-bucket en la región Oeste de EE. UU. (Oregón) us-west-2.

Paso 5: añadir archivos de código fuente

En esta sección, añadirá varios archivos de código fuente de la aplicación al repositorio de código fuente de CodeCatalyst. La carpeta hello-world contiene los archivos de la aplicación que va a implementar. La carpeta tests contiene las pruebas unitarias. La estructura de carpetas es la siguiente:

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

Archivo .npmignore

El .npmignore archivo indica qué archivos y carpetas debe excluir npm del paquete de la aplicación. En este tutorial, npm excluye la carpeta tests porque no forma parte de la aplicación.

Adición del .npmignore

  1. Abra la consola de CodeCatalyst en https://codecatalyst.aws/.

  2. Elija el proyecto, codecatalyst-cfn-project.

  3. En el panel de navegación, elija Código y, a continuación, elija Repositorios de origen.

  4. En la lista de repositorios de código fuente, elija su repositorio, codecatalyst-cfn-source-repository.

  5. En Archivos, elija Crear archivo.

  6. En Nombre del archivo, escriba:

    .npmignore

  7. En el cuadro de texto, introduzca el siguiente código:

    tests/*

  8. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    Ahora ha creado un archivo llamado .npmignore en la raíz del repositorio.

Archivo package.json

El archivo package.json contiene metadatos importantes sobre su proyecto de Node, como el nombre del proyecto, el número de versión, la descripción, las dependencias y otros detalles que describen cómo interactuar con la aplicación y cómo ejecutarla.

El archivo package.json de este tutorial incluye una lista de dependencias y un script test. El script de prueba hace lo siguiente:

  • Mediante mocha, el script de prueba ejecuta las pruebas unitarias especificadas en hello-world/tests/unit/ y escribe los resultados en un archivo junit.xml mediante el generador de informes xunit.

  • Usando Istanbul (nyc), el script de prueba genera un informe de cobertura de código (clover.xml) utilizando el generador de informes clover. Para obtener más información, consulte Using alternative reporters en la documentación de Istanbul.

Adición del archivo package.json

  1. En el repositorio, en Archivos, seleccione Crear archivo.

  2. En Nombre del archivo, escriba:

    package.json

  3. En el cuadro de texto, introduzca el siguiente código:

    {
  "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. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    Ahora ha añadido un archivo llamado package.json en la raíz del repositorio.

Archivo sam-template.yml

El archivo sam-template.yml contiene las instrucciones para implementar la función de Lambda y la instancia de API Gateway y configurarlas juntas. Sigue la especificación de la plantilla de AWS Serverless Application Model, que amplía la especificación de la plantilla de AWS CloudFormation.

En este tutorial, utilizará una plantilla de AWS SAM en lugar de una plantilla de AWS CloudFormation normal, porque AWS SAM ofrece un tipo de recurso AWS::Serverless::Function que es muy útil. Este tipo realiza una gran parte de la configuración entre bastidores que normalmente hay que escribir para utilizar la sintaxis básica de CloudFormation. Por ejemplo, el recurso AWS::Serverless::Function crea una función de Lambda, un rol de ejecución de Lambda y asignaciones de orígenes de eventos que inician la función. Tiene que codificar todo esto si quiere escribirlo usando CloudFormation básico.

Aunque en este tutorial se utiliza una plantilla prediseñada, puede generar una como parte de su flujo de trabajo mediante una acción de compilación. Para obtener más información, consulte Implementación de una pila de AWS CloudFormation.

Adición del archivo sam-template.yml

  1. En el repositorio, en Archivos, seleccione Crear archivo.

  2. En Nombre del archivo, escriba:

    sam-template.yml

  3. En el cuadro de texto, introduzca el siguiente código:

    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. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    Ahora ha añadido un archivo llamado sam-template.yml en la carpeta raíz del repositorio.

Archivo setup-sam.sh

El archivo setup-sam.sh contiene las instrucciones para descargar e instalar la utilidad de la CLI de AWS SAM. El flujo de trabajo usa esta utilidad para empaquetar el código fuente de hello-world.

Adición del archivo setup-sam.sh

  1. En el repositorio, en Archivos, seleccione Crear archivo.

  2. En Nombre del archivo, escriba:

    setup-sam.sh

  3. En el cuadro de texto, introduzca el siguiente código:

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

    En el código anterior, sustituya us-west-2 por su región de AWS.

  4. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    Ahora ha añadido un archivo llamado setup-sam.sh en la raíz del repositorio.

Archivo app.js

El archivo app.js contiene el código de la función de Lambda. En este tutorial, el código devuelve el texto hello world.

Adición del archivo app.js

  1. En el repositorio, en Archivos, seleccione Crear archivo.

  2. En Nombre del archivo, escriba:

    hello-world/app.js

  3. En el cuadro de texto, introduzca el siguiente código:

    // 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. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    Ahora ha creado una carpeta llamada hello-world y un archivo llamado app.js.

Archivo test-handler.js

El archivo test-handler.js contiene pruebas unitarias para la función de Lambda.

Adición del archivo test-handler.js

  1. En el repositorio, en Archivos, seleccione Crear archivo.

  2. En Nombre del archivo, escriba:

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

  3. En el cuadro de texto, introduzca el siguiente código:

    '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. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

    Ahora ha añadido un archivo llamado test-handler.js en la carpeta hello-world/tests/unit.

Ahora ha añadido todos los archivos de código fuente.

Dedique unos minutos a comprobar su trabajo y a asegurarse de que ha colocado todos los archivos en las carpetas correctas. La estructura de carpetas es la siguiente:

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

Paso 6: crear y ejecutar un flujo de trabajo

En este paso, creará un flujo de trabajo que empaquetará el código fuente de Lambda y lo implementará. El flujo de trabajo consta de los siguientes componentes que se ejecutarán en orden:

  • Un desencadenador: este desencadenador inicia la ejecución automática del flujo de trabajo cuando se introduce un cambio en el repositorio de código fuente. Para obtener más información acerca de los disparadores, consulte Inicio de un flujo de trabajo y ejecución automática mediante desencadenadores.

  • Una acción de prueba (Test): al activarse, esta acción instala el administrador de paquetes de Node (npm) y, a continuación, ejecuta el comando npm run test. Este comando indica a npm que ejecute el script test definido en el archivo package.json. El script test, a su vez, ejecuta las pruebas unitarias y genera dos informes: un informe de prueba (junit.xml) y un informe de cobertura de código (clover.xml). Para obtener más información, consulte Archivo package.json.

    A continuación, la acción de prueba convierte los informes XML en informes de CodeCatalyst y los muestra en la consola de CodeCatalyst, en la pestaña Informes de la acción de prueba.

    Para obtener más información sobre la acción de prueba, consulte Pruebas con flujos de trabajo.

  • Una acción de compilación (BuildBackend): al finalizar la acción de prueba, la acción de compilación descarga e instala la CLI de AWS SAM, empaqueta el código fuente de hello-world y copia el paquete en su bucket de Amazon S3, donde el servicio de Lambda espera que esté. La acción también genera un nuevo archivo de plantilla de AWS SAM llamado sam-template-packaged.yml y lo coloca en un artefacto de salida llamado buildArtifact.

    Para obtener más información sobre la acción de compilación, consulte Compilación con flujos de trabajo.

  • Una acción de implementación (DeployCloudFormationStack): al completarse la acción de compilación, la acción de implementación busca el artefacto de salida generado por la acción de compilación (buildArtifact), encuentra la plantilla de AWS SAM que contiene y la ejecuta. La plantilla de AWS SAM crea una pila que implementa la aplicación sin servidor.

Creación de un flujo de trabajo

  1. En el panel de navegación, elija CI/CD y, a continuación, elija Flujos de trabajo.

  2. Seleccione Crear flujo de trabajo.

  3. En Repositorio de código fuente, elija codecatalyst-cfn-source-repository.

  4. En Ramificación, elija main.

  5. Seleccione Crear.

  6. Elimine el código de ejemplo de YAML.

  7. Añada el código de YAML siguiente:

    nota

    En el código de YAML que se muestra a continuación, puede omitir las secciones Connections: si lo desea. Si omite estas secciones, debe asegurarse de que el rol especificado en el campo Rol de IAM predeterminado del entorno incluya los permisos y las políticas de confianza de ambos roles que se describen en Paso 2: crear roles de AWS. Para obtener más información sobre cómo configurar un entorno con un rol de IAM predeterminado, consulte Creación de un entorno.

    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

    En el código anterior, sustituya:

    • Ambas instancias de codecatalyst-cfn-environment por el nombre de su entorno.

    • Ambas instancias de codecatalyst-account-connection por el nombre de visualización de su conexión de cuenta. El nombre de visualización puede ser un número. Para obtener más información, consulte Paso 3: añadir roles de AWS a CodeCatalyst.

    • codecatalyst-build-role por el nombre del rol de compilación que creó en Paso 2: crear roles de AWS.

    • codecatalyst-cfn-s3-bucket por el nombre del bucket de Amazon S3 que creó en Paso 4: crear un bucket de Amazon S3.

    • Ambas instancias de us-west-2 por la región en la que reside su bucket de Amazon S3 (primera instancia) y en la que se implementará su pila (segunda instancia). Estas regiones pueden ser diferentes. En este tutorial se asume que ambas regiones están establecidas en us-west-2. Para obtener más información sobre las regiones compatibles con Amazon S3 y AWS CloudFormation, consulte Puntos de conexión y cuotas del servicio en la Referencia general de AWS.

    • codecatalyst-deploy-role por el nombre del rol de implementación que creó en Paso 2: crear roles de AWS.

    • codecatalyst-cfn-environment por el nombre del entorno que ha creado en Requisitos previos.

    • arn:aws:iam::111122223333:role/StackRole por el Nombre de recurso de Amazon (ARN) del rol de pila que creó en Paso 2: crear roles de AWS.

      nota

      Si decidió no crear roles de compilación, implementación y pila, sustituya codecatalyst-build-role, codecatalyst-deploy-role y arn:aws:iam::111122223333:role/StackRole por el nombre o el ARN del rol de CodeCatalystWorkflowDevelopmentRole-spaceName. Para obtener más información acerca de este rol, consulte Paso 2: crear roles de AWS.

    Para obtener información sobre las propiedades del código mostrado anteriormente, consulte el Acción 'Deploy AWS CloudFormation stack' de YAML.

  8. (Opcional) Seleccione Validar para asegurarse de que el código de YAML del flujo de trabajo es válido antes de confirmarlo.

  9. Elija Commit (Confirmar).

  10. En el cuadro de diálogo Confirmar flujo de trabajo, escriba lo siguiente:

    1. En Nombre del archivo de flujo de trabajo, deje el valor predeterminado, codecatalyst-cfn-workflow.

    2. En Mensaje de confirmación, escriba:

      add initial workflow file

    3. En Repositorio, elija codecatalyst-cfn-source-repository.

    4. En Nombre de la ramificación, elija principal.

    5. Elija Commit (Confirmar).

    Ahora ha creado un flujo de trabajo. La ejecución del flujo de trabajo se inicia automáticamente debido al desencadenador definido en la parte superior del flujo de trabajo. En concreto, cuando confirmó (e incorporó) el archivo codecatalyst-cfn-workflow.yaml en su repositorio de código fuente, el desencadenador inició la ejecución del flujo de trabajo.

Consulta de la ejecución del flujo de trabajo en curso

  1. En el panel de navegación, elija CI/CD y, a continuación, elija Flujos de trabajo.

  2. Elija el flujo de trabajo que acaba de crear: codecatalyst-cfn-workflow.

  3. Elija la pestaña Ejecuciones.

  4. En la columna ID de ejecución, elija el ID de ejecución.

  5. Elija Prueba para ver el progreso de las pruebas.

  6. Elija BuildBackend para ver el progreso de la compilación.

  7. Elija DeployCloudFormationStack para ver el progreso de la implementación.

    Para obtener más información sobre cómo ver los detalles de ejecución, consulte Visualización del estado y los detalles de la ejecución de un flujo de trabajo.

  8. Cuando finalice la acción DeployCloudFormationStack, haga lo siguiente:

    • Si la ejecución del flujo de trabajo se realizó correctamente, vaya al siguiente procedimiento.

    • Si se produjo un error en la acción Test o BuildBackend, seleccione Registros para solucionar el problema.

    • Si la ejecución del flujo de trabajo falló en la acción DeployCloudFormationStack, elija la acción de implementación y, a continuación, elija la pestaña Resumen. Vaya a la sección Eventos de CloudFormation para ver el mensaje de error detallado. Si se ha producido una reversión, elimine la pila de codecatalyst-cfn-stack mediante la consola de AWS CloudFormation en AWS antes de volver a ejecutar de nuevo el flujo de trabajo.

Verificación de la implementación

  1. Tras una implementación correcta, seleccione Variables (7) en la barra de menú horizontal situada cerca de la parte superior. (No elija Variables en el panel de la derecha).

  2. Junto a HelloWorldApi, pegue la URL https:// en un navegador.

    Aparece un mensaje JSON hello world de la función de Lambda, que indica que el flujo de trabajo implementó y configuró correctamente la función de Lambda y la instancia de API Gateway.

    sugerencia

    Puede hacer que CodeCatalyst muestre esta URL en el diagrama de flujo de trabajo con algunas pequeños ajustes. Para obtener más información, consulte Visualización de la URL de la aplicación en el diagrama de flujo de trabajo.

Verificación de los resultados de las pruebas unitarias y la cobertura del código

  1. En el diagrama de flujo de trabajo, elija Probar y, a continuación, elija Informes.

  2. Elija TestReport para ver los resultados de las pruebas unitarias o elija CoverageReport para ver los detalles de la cobertura del código de los archivos que se están probando, en este caso, app.js y test-handler.js.

Verificación de los recursos implementados

  1. Inicie sesión en la AWS Management Console y abra la consola de API Gateway en https://console.aws.amazon.com/apigateway/.

  2. Observe la API codecatalyst-cfn-stack que creó la plantilla de AWS SAM. El nombre de la API proviene del valor Configuration/name del archivo de definición del flujo de trabajo (codecatalyst-cfn-workflow.yaml).

  3. Abra la consola de AWS Lambda en https://console.aws.amazon.com/lambda/.

  4. Seleccione Funciones en el panel de navegación.

  5. Elija su función de Lambda, codecatalyst-cfn-stack-HelloWorldFunction-string.

  6. Puede ver cómo la instancia de API Gateway es un desencadenador de la función. Esta integración se configuró automáticamente a través del tipo de recurso AWS::Serverless::Function de AWS SAM.

Paso 7: realizar un cambio

En este paso, realizará un cambio en el código fuente de Lambda y lo confirmará. Esta confirmación inicia una nueva ejecución del flujo de trabajo. Esta ejecución implementa la nueva función de Lambda en un esquema azul-verde que usa la configuración de cambio de tráfico predeterminada especificada en la consola de Lambda.

Realización de un cambio en el código fuente de Lambda

  1. En CodeCatalyst, vaya a su proyecto.

  2. En el panel de navegación, elija Código y, a continuación, elija Repositorios de origen.

  3. Elija su repositorio de código fuente codecatalyst-cfn-source-repository.

  4. Cambie el archivo de la aplicación:

    1. Elija la carpeta hello-world.

    2. Seleccione el archivo app.js.

    3. Elija Editar.

    4. En la línea 23, cambie hello world por Tutorial complete!

    5. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

      La confirmación hace que se inicie una nueva ejecución del flujo de trabajo. Esta ejecución fallará porque no ha actualizado las pruebas unitarias para que reflejen el cambio de nombre.

  5. Actualice las pruebas unitarias:

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

    2. Elija Editar.

    3. En la línea 19, cambie hello world por Tutorial complete!

    4. Seleccione Confirmar y, a continuación, vuelva a seleccionar Confirmar.

      La confirmación hace que se inicie otra ejecución del flujo de trabajo. Esta ejecución se realizará correctamente.

  6. En el panel de navegación, elija CI/CD y, a continuación, elija Flujos de trabajo.

  7. Elija codecatalyst-cfn-workflow y, a continuación, Ejecuciones.

  8. Elija el ID de ejecución de la última ejecución. Debería estar todavía en curso.

  9. Seleccione Test, BuildBackend y DeployCloudFormationStack para ver el progreso de la ejecución del flujo de trabajo.

  10. Cuando finalice el flujo de trabajo, elija Variables (7) cerca de la parte superior.

  11. Junto a HelloWorldApi, pegue la URL https:// en un navegador.

    Aparece un mensaje Tutorial complete! en el navegador, lo que indica que la aplicación se ha implementado correctamente.

Limpieza

Limpie los archivos y servicios utilizados en este tutorial para evitar que le cobren por ellos.

Limpieza en la consola de CodeCatalyst

  1. Abra la consola de CodeCatalyst en https://codecatalyst.aws/.

  2. Elimine codecatalyst-cfn-workflow.

  3. Elimine codecatalyst-cfn-environment.

  4. Elimine codecatalyst-cfn-source-repository.

  5. Elimine codecatalyst-cfn-project.

Limpieza en la AWS Management Console

  1. Limpie CloudFormation de la siguiente manera:

    1. Abra la consola de AWS CloudFormation en https://console.aws.amazon.com/cloudformation.

    2. Elimine la codecatalyst-cfn-stack.

      Al eliminar la pila, se eliminan todos los recursos del tutorial de los servicios de API Gateway y Lambda.

  2. Limpie Amazon S3 de la siguiente manera:

    1. Abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.

    2. Elija el icono codecatalyst-cfn-s3-bucket.

    3. Elimine el contenido del bucket.

    4. Elimine el bucket.

  3. Limpie IAM de la siguiente manera:

    1. Abra la consola de IAM en https://console.aws.amazon.com/iam/.

    2. Elimine la codecatalyst-deploy-policy.

    3. Elimine la codecatalyst-build-policy.

    4. Elimine la codecatalyst-stack-policy.

    5. Elimine la codecatalyst-deploy-role.

    6. Elimine la codecatalyst-build-role.

    7. Elimine la codecatalyst-stack-role.

En este tutorial, ha aprendido a implementar una aplicación sin servidor como una pila de CloudFormation mediante un flujo de trabajo y una acción Deploy AWS CloudFormation stack de CodeCatalyst.