Tutorial: Implementación de una aplicación sin servidor - Amazon CodeCatalyst
Requisitos previosPaso 1: Crear un repositorio de origenPaso 2: Crear AWS rolesPaso 3: Añadir AWS roles a CodeCatalystPaso 4: Crear un bucket de Amazon S3Paso 5: Añadir los archivos fuentePaso 6: Crear y ejecutar un flujo de trabajoPaso 7: Realizar un cambioLimpieza

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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

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

La aplicación de este tutorial es una aplicación web sencilla que genera un mensaje de «Hola mundo». Consta de una AWS Lambda función y un Amazon API Gateway, y se crea con AWS Serverless Application Model (AWS SAM), que es una extensión de AWS CloudFormation.

Requisitos previos

Antes de empezar

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

  • En tu espacio, necesitas un proyecto vacío llamado:

    codecatalyst-cfn-project

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

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

  • En su proyecto, necesita un CodeCatalyst entorno llamado:

    codecatalyst-cfn-environment

    Configure este entorno de la siguiente manera:

    • Elija cualquier tipo, como el de no producción.

    • Conecta tu AWS cuenta a ella.

    • Para el IAMrol predeterminado, elige cualquier rol. Especificará un rol diferente más adelante.

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

Paso 1: Crear un repositorio de origen

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

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

Para crear un repositorio de origen

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

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

  3. En Nombre del repositorio, introduzca:

    codecatalyst-cfn-source-repository

  4. Seleccione Crear.

Ahora ha creado un repositorio llamadocodecatalyst-cfn-source-repository.

Paso 2: Crear AWS roles

En este paso, se crean los siguientes AWS IAM roles:

  • Función de implementación: otorga a la acción CodeCatalyst Deploy AWS CloudFormation stack el permiso para acceder a la AWS cuenta y CloudFormation al servicio en los que se implementará la aplicación sin servidor. La acción Implementar AWS CloudFormation pila forma parte de tu flujo de trabajo.

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

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

Para obtener más información sobre IAM las funciones, consulte IAMlas funciones en la Guía del AWS Identity and Access Management usuario.

nota

Para ahorrar tiempo, puede crear un único rol, denominado CodeCatalystWorkflowDevelopmentRole-spaceName rol, en lugar de los tres roles enumerados anteriormente. Para obtener más información, consulte Crear el CodeCatalystWorkflowDevelopmentRole-spaceNamerol para su cuenta y su espacio. Tenga en cuenta que el CodeCatalystWorkflowDevelopmentRole-spaceName rol tiene permisos muy amplios que pueden suponer un riesgo para la seguridad. Le recomendamos que utilice esta función únicamente en los tutoriales y situaciones en las que la seguridad sea un problema menor. En este tutorial se da por sentado que está creando los tres roles enumerados anteriormente.

nota

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

Para crear un rol de despliegue

  1. Cree una política para el rol, de la siguiente manera:

    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 Crear política.

    5. Elija la pestaña JSON.

    6. Elimina 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 se utilice el rol para ejecutar acciones de flujo de trabajo, utilice el comodín en la declaración de política de recursos y, a continuación, defina la política con el nombre del recurso cuando esté disponible.

      "Resource": "*"

    8. Elija Siguiente: Etiquetas.

    9. Elija Siguiente: Revisar.

    10. En Nombre, introduzca:

      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 la descripción del rol, introduzca:

      CodeCatalyst deploy role

    10. Elija Crear rol.

    Ahora ha creado un rol de despliegue con una política de confianza y una política de permisos.

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

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

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

    3. Elija el rol de la lista.

      Aparece la página de resumen del rol.

    4. En la parte superior, copia el ARNvalor.

    Ahora ha creado el rol de despliegue con los permisos adecuados y ha obtenido el suyoARN.

Para crear un rol de compilación

  1. Cree una política para el rol, de la siguiente manera:

    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 Crear política.

    5. Elija la pestaña JSON.

    6. Elimina 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 se utilice el rol para ejecutar acciones de flujo de trabajo, utilice el comodín en la declaración de política de recursos y, a continuación, defina la política con el nombre del recurso cuando esté disponible.

      "Resource": "*"

    8. Elija Siguiente: Etiquetas.

    9. Elija Siguiente: Revisar.

    10. En Nombre, introduzca:

      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 la descripción del rol, introduzca:

      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 rol de creación ARN de la siguiente manera:

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

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

    3. Elija el rol de la lista.

      Aparece la página de resumen del rol.

    4. En la parte superior, copia el ARNvalor.

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

Para crear un rol de pila

  1. Inicia sesión AWS con la cuenta en la que quieres implementar tu stack.

  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 una opción CloudFormationde la lista desplegable.

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

    6. En la parte inferior, selecciona Siguiente.

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

      nota

      Si buscas una política y no aparece, asegúrate de seleccionar Borrar filtros e inténtalo de nuevo.

      • CloudWatchFullAccess

      • AWS CloudFormationFullAccess

      • IAMFullAccess

      • AWS Lambda_ FullAccess

      • Un administrador mazonAPIGateway

      • Amazon S3 FullAccess

      • Amazon EC2ContainerRegistryFullAccess

      La primera política permite el acceso para CloudWatch permitir la reversión de las pilas cuando se produce una alarma.

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

    8. Elija Siguiente.

    9. En el nombre del rol, escriba:

      codecatalyst-stack-role

    10. Elija Crear rol.

  4. Obtenga los roles de la pila ARN de la siguiente manera:

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

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

    3. Elija el rol de la lista.

    4. En la sección Resumen, copia el ARNvalor. Lo necesitará más adelante.

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

Paso 3: Añadir AWS roles a CodeCatalyst

En este paso, agrega el rol de creación (codecatalyst-build-role) y el rol de implementación (codecatalyst-deploy-role) a la conexión de CodeCatalyst cuentas de su espacio.

nota

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

Para añadir funciones de creación e implementación a la conexión de tu cuenta

  1. En CodeCatalyst, navega hasta tu espacio.

  2. Elige AWS cuentas. Aparece una lista de conexiones de cuentas.

  3. Elija la conexión de cuenta que represente la AWS cuenta en la que creó las funciones de creación e implementación.

  4. Seleccione Administrar roles en la consola de AWS administración.

    Aparece la página Añadir IAM rol al CodeCatalyst espacio de Amazon. Puede que tengas que iniciar sesión para acceder a la página.

  5. Selecciona Añadir un rol existente en el que hayas creado IAM.

    Aparece una lista desplegable. La lista muestra todos los IAM roles con una política de confianza que incluye a los directores de codecatalyst.amazonaws.com servicio codecatalyst-runner.amazonaws.com y a los directores de servicio.

  6. En la lista desplegablecodecatalyst-build-role, elija y elija Agregar función.

  7. Seleccione Añadir IAM función, seleccione Añadir una función existente en la que haya creado yIAM, en la lista desplegable, elijacodecatalyst-deploy-role. Seleccione Add role (Añadir rol).

    Ahora ha agregado los roles de creación e implementación a su espacio.

  8. Copia el valor del nombre CodeCatalyst mostrado de Amazon. Necesitarás este valor más adelante, al crear tu flujo de trabajo.

Paso 4: Crear un bucket de Amazon S3

En este paso, debe crear un depósito de Amazon S3 en el que almacenar el archivo.zip del paquete de despliegue de la aplicación sin servidor.

Creación de un bucket de Amazon S3

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

  2. En el panel principal, elija Crear depósito.

  3. En el nombre del bucket, introduce:

    codecatalyst-cfn-s3-bucket

  4. En AWS Región, seleccione una región. En este tutorial se asume que ha elegido US West (Oregon) us-west-2. Para obtener información sobre las regiones compatibles con Amazon S3, consulte los puntos de enlace y las cuotas de Amazon Simple Storage Service en. Referencia general de AWS

  5. En la parte inferior de la página, selecciona Crear depósito.

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

Paso 5: Añadir los archivos fuente

En este paso, añadirá varios archivos fuente de la aplicación a su repositorio CodeCatalyst de código fuente. La hello-world carpeta contiene los archivos de la aplicación que va a implementar. La tests carpeta 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 tests carpeta porque no forma parte de la aplicación.

Para agregar el archivo.npmignore

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

  2. Elige tu proyecto, codecatalyst-cfn-project

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

  4. De la lista de repositorios de origen, elige tu repositorio,codecatalyst-cfn-source-repository.

  5. En Archivos, selecciona Crear archivo.

  6. En Nombre de archivo, introduzca:

    .npmignore

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

    tests/*

  8. Selecciona Confirmar y, a continuación, selecciona Confirmar de nuevo.

    Ahora has creado un archivo llamado .npmignore en la raíz de tu repositorio.

archivo package.json

El package.json archivo contiene metadatos importantes sobre tu 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.

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

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

  • En Estambul (Nueva York), el script de prueba genera un informe de cobertura de código (clover.xml) utilizando el Clover Reporter. Para obtener más información, consulte Uso de reporteros alternativos en la documentación de Estambul.

Para añadir el archivo package.json

  1. En tu repositorio, en Archivos, selecciona Crear archivo.

  2. En Nombre de archivo, introduce:

    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. Selecciona Confirmar y, a continuación, selecciona Confirmar de nuevo.

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

archivo sam-template.yml

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

En este tutorial, utilizarás una AWS SAM plantilla en lugar de una AWS CloudFormation plantilla normal porque AWS SAM ofrece un útil tipo de recurso AWS: :Serverless: :Function. Este tipo realiza una gran parte behind-the-scenes de la configuración que normalmente hay que escribir para usar la sintaxis básica. CloudFormation Por ejemplo, AWS::Serverless::Function crea una función Lambda, una función de ejecución de Lambda y asignaciones de fuentes de eventos que inician la función. Tienes que codificar todo esto si quieres escribirlo usando Basic. CloudFormation

Aunque en este tutorial se utiliza una plantilla preescrita, puedes generar una como parte de tu flujo de trabajo mediante una acción de creación. Para obtener más información, consulte Implementación de una AWS CloudFormation pila.

Para añadir el archivo sam-template.yml

  1. En tu repositorio, en Archivos, selecciona Crear archivo.

  2. En Nombre de archivo, introduce:

    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. Selecciona Confirmar y, a continuación, selecciona Confirmar de nuevo.

    Ahora has añadido un archivo llamado sam-template.yml en la carpeta raíz de tu repositorio.

archivo setup-sam.sh

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

Para agregar el archivo setup-sam.sh

  1. En tu repositorio, en Archivos, selecciona Crear archivo.

  2. En Nombre de archivo, introduce:

    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 con tu AWS región.

  4. Selecciona Confirmar y, a continuación, selecciona Confirmar de nuevo.

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

archivo app.js

app.jsContiene el código de la función Lambda. En este tutorial, el código devuelve el textohello world.

Para añadir el archivo app.js

  1. En tu repositorio, en Archivos, selecciona Crear archivo.

  2. En Nombre de archivo, introduce:

    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. Selecciona Confirmar y, a continuación, selecciona Confirmar de nuevo.

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

archivo test-handler.js

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

Para añadir el archivo test-handler.js

  1. En tu repositorio, en Archivos, selecciona Crear archivo.

  2. En Nombre de archivo, introduce:

    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. Selecciona Confirmar y, a continuación, selecciona Confirmar de nuevo.

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

Ahora ha agregado todos sus archivos fuente.

Tómate un momento para comprobar tu trabajo y asegurarte de que has 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, se crea un flujo de trabajo que empaqueta el código fuente de Lambda y lo despliega. El flujo de trabajo consta de los siguientes componentes básicos que se ejecutan de forma secuencial:

  • Un disparador: este activador inicia la ejecución automática del flujo de trabajo al introducir un cambio en el repositorio de origen. Para obtener más información acerca de los disparadores, consulte Iniciar un flujo de trabajo, ejecutarlo automáticamente mediante activadores.

  • Una acción de prueba (Test): al activarse, esta acción instala el administrador de paquetes Node (npm) y, a continuación, ejecuta el npm run test comando. Este comando le indica a npm que ejecute el test script definido en el archivo. package.json El test script, 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 transforma los XML informes en CodeCatalyst informes y los muestra en la CodeCatalyst consola, en la pestaña Informes de la acción de prueba.

    Para obtener más información sobre la acción de prueba, consultePruebas 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 AWS SAM CLI, empaqueta el hello-world código fuente y copia el paquete en su bucket de Amazon S3, donde el servicio Lambda espera que esté. La acción también genera un nuevo archivo de AWS SAM plantilla 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 creación, consulteConstruir con flujos de trabajo.

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

Para crear 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 origen, elijacodecatalyst-cfn-source-repository.

  4. Para Branch, elijamain.

  5. Seleccione Crear.

  6. Elimine el código de YAML muestra.

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

    nota

    En el YAML código siguiente, puede omitir las Connections: secciones si lo desea. Si omite estas secciones, debe asegurarse de que la función especificada en el campo IAMFunción predeterminada de su entorno incluya los permisos y las políticas de confianza de ambas funciones descritas en. Paso 2: Crear AWS roles Para obtener más información sobre la configuración de un entorno con un IAM rol predeterminado, consulteCreació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 con el nombre de su entorno.

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

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

    • codecatalyst-cfn-s3-bucket con el nombre del bucket de Amazon S3 en el que lo creastePaso 4: Crear un bucket de Amazon S3.

    • Ambas instancias de us-west-2 con 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 configuradas enus-west-2. Para obtener más información sobre las regiones compatibles con Amazon S3 AWS CloudFormation, consulte los puntos de enlace y las cuotas del Referencia general de AWSservicio en.

    • codecatalyst-deploy-role con el nombre de la función de implementación en Paso 2: Crear AWS roles la que creó.

    • codecatalyst-cfn-environment con el nombre del entorno en el que ha creadoRequisitos previos.

    • arn:aws:iam::111122223333:role/StackRole con el nombre de recurso de Amazon (ARN) del rol de pila en el que creastePaso 2: Crear AWS roles.

      nota

      Si ha decidido no crear funciones de creación, implementación y apilado, sustitúyalas codecatalyst-build-role, codecatalyst-deploy-role, y arn:aws:iam::111122223333:role/StackRole por el nombre o ARN el CodeCatalystWorkflowDevelopmentRole-spaceName rol. Para obtener más información acerca de este rol, consulte Paso 2: Crear AWS roles.

    Para obtener información sobre las propiedades del código mostrado anteriormente, consulte laAcción «Desplegar AWS CloudFormation pila» YAML.

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

  9. Elija Commit (Confirmar).

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

    1. Para el nombre del archivo de flujo de trabajo, mantenga el valor predeterminado,codecatalyst-cfn-workflow.

    2. Para el mensaje de confirmación, introduzca:

      add initial workflow file

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

    4. Para el nombre de la sucursal, elija principal.

    5. Elija Commit (Confirmar).

    Ahora ha creado un flujo de trabajo. La ejecución de un flujo de trabajo se inicia automáticamente debido al activador definido en la parte superior del flujo de trabajo. En concreto, cuando depositaste (e insertaste) el codecatalyst-cfn-workflow.yaml archivo en tu repositorio de origen, el desencadenador inició la ejecución del flujo de trabajo.

Para ver 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. Selecciona Probar para ver el progreso de las pruebas.

  6. Elige BuildBackendver el progreso de la compilación.

  7. Elija DeployCloudFormationStackver el progreso de la implementación.

    Para obtener más información sobre la visualización de los detalles de la ejecución, consulteVer el estado y los detalles de la ejecución del flujo de trabajo.

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

    • Si el flujo de trabajo se ejecutó correctamente, continúe con el siguiente procedimiento.

    • Si la ejecución del flujo de trabajo falló en la prueba o la BuildBackendacción, seleccione Registros para solucionar el problema.

    • Si la ejecución del flujo de trabajo falló en la DeployCloudFormationStackacción, elija la acción de despliegue y, a continuación, elija la pestaña Resumen. Desplázate hasta la sección de CloudFormation eventos para ver el mensaje de error detallado. Si se ha producido una reversión, elimina la codecatalyst-cfn-stack pila a través de la AWS CloudFormation consola AWS antes de volver a ejecutar el flujo de trabajo.

Para verificar la implementación

  1. Tras una implementación correcta, elija 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, péguela https:// URL en un navegador.

    Aparece un JSONmensaje de saludo de la función Lambda, que indica que el flujo de trabajo implementó y configuró la función Lambda y Gateway correctamente. API

    sugerencia

    Puede hacer que CodeCatalyst muestre esto URL en el diagrama de flujo de trabajo con algunas configuraciones pequeñas. Para obtener más información, consulte Mostrar la aplicación URL en el diagrama de flujo de trabajo.

Para verificar 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 TestReportver los resultados de las pruebas unitarias o los detalles de la cobertura del código de los archivos que se están probando, en este caso, app.js ytest-handler.js. CoverageReport

Para verificar los recursos desplegados

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

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

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

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

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

  6. Puede ver cómo la API puerta de enlace activa la función. Esta integración se configuró automáticamente según el tipo de AWS SAM AWS::Serverless::Function recurso.

Paso 7: Realizar un cambio

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

Para realizar un cambio en la fuente Lambda

  1. En CodeCatalyst, navegue hasta su proyecto.

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

  3. Elige tu repositorio de origencodecatalyst-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 aTutorial complete!.

    5. Elija Confirmar y, a continuación, vuelva a elegir Confirmar.

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

  5. Actualiza las pruebas unitarias:

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

    2. Elija Editar.

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

    4. Elija Confirmar y, a continuación, vuelva a elegir 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 ycodecatalyst-cfn-workflow, a continuación, elija Ejecuciones.

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

  9. Seleccione Probar y verá el progreso DeployCloudFormationStackde la ejecución del flujo de trabajo. BuildBackend

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

  11. Junto a HelloWorldApi, péguela https:// URL en un navegador.

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

Limpieza

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

Para limpiar en la CodeCatalyst consola

  1. Abre la CodeCatalyst consola en https://codecatalyst.aws/.

  2. Eliminarcodecatalyst-cfn-workflow.

  3. Eliminarcodecatalyst-cfn-environment.

  4. Eliminarcodecatalyst-cfn-source-repository.

  5. Eliminarcodecatalyst-cfn-project.

Para limpiar en el AWS Management Console

  1. Limpie en CloudFormation, de la siguiente manera:

    1. Abre la AWS CloudFormation consola 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 API servicios Gateway y Lambda.

  2. Limpie en Amazon S3 de la siguiente manera:

    1. Abra la consola 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 el interior 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, aprendió a implementar una aplicación sin servidor como una CloudFormation pila mediante un CodeCatalyst flujo de trabajo y una acción de implementación de una AWS CloudFormation pila.