Primero configuremos todo en la máquina local y luego veremos la configuración de GitHub.

Instale AWS CDK globalmente (alternativamente, puede usar npx) para ejecutar CDK localmente.

npm i -g aws-cdk

Inicializar CDK:

mkdir backend
cd backend
cdk init app --language=typescript

Ahora escribamos el código para el backend:

Ahora creemos la carpeta en la raíz y agreguemos el código de ejecución para lambda. Aquí estoy usando el código API REST de Fastify. Entonces, esto tendrá un archivo para el controlador lambda y un archivo para Fastify y, por supuesto, package.json para las dependencias.

app.js

const fastify = require("fastify");

function init() {
  const app = fastify();
  app.get("/", (request, reply) => reply.send({ hello: "world" }));
  return app;
}

if (require.main === module) {
  // called directly i.e. "node app"
  init().listen(3005, (err) => {
    if (err) console.error(err);
    console.log("server listening on 3005");
  });
} else {
  // required as a module => executed on aws lambda
  module.exports = init;
}

index.js

const awsLambdaFastify = require("aws-lambda-fastify");
const init = require("./app");

const proxy = awsLambdaFastify(init());
exports.handler = proxy;

Ahora escribamos el código CDK:

1. Cree una construcción de función Lambda con activos que hagan referencia a la carpeta “código de función”. Esto adjuntará nuestro código de back-end al controlador lambda en AWS.

2. Cree una construcción API Gateway con un controlador que haga referencia a la construcción lambda creada en el paso 1.

import { Stack, StackProps, CfnOutput } from "aws-cdk-lib";
import { Construct } from "constructs";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as apigateway from "aws-cdk-lib/aws-apigateway";
import * as path from "path";
export class BackendInfraStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    const handler = new lambda.Function(this, "FastifyHandle", {
      runtime: lambda.Runtime.NODEJS_14_X,
      code: lambda.Code.fromAsset(path.resolve(__dirname, "../function-code")), // reference to backend function code
      handler: "index.handler",
    });
    const api = new apigateway.LambdaRestApi(this, "testapi", {
      handler: handler,
      defaultCorsPreflightOptions: {
        allowOrigins: apigateway.Cors.ALL_ORIGINS,
        allowMethods: apigateway.Cors.ALL_METHODS,
        allowHeaders: ["*"],
      },
      // REMOVE Auth for options manually
      defaultMethodOptions: {
        authorizationType: apigateway.AuthorizationType.NONE,
      },
      deployOptions: {
        stageName: "dev",
      },
    });
    new CfnOutput(this, "TheUrl", {
      value: api.url,
    });
  }
}

Local

Si tiene las credenciales de AWS configuradas localmente, puede intentar impulsar la configuración de CDK usando el comando “CDK deployment”:

Aquí está el enlace sobre cómo configurar las credenciales de AWS

Aquí, el comando ‘cdk synth’ es solo para saber si el archivo de configuración funcionará o no y, de lo contrario, obtendremos errores y la oportunidad de corregirlos antes de la implementación.

cdk synth
cdk deploy --profile your-local-aws-profile

Continuando con las acciones de Github.

Ahora, configuremos las acciones de Github para la implementación automática de AWS lambda.

Configure las credenciales de AWS en el repositorio de Github.

Ahora, creemos una carpeta ‘.github/workflows’ en la raíz del proyecto y agreguemos el archivo main.yaml como se muestra a continuación. Este archivo se ejecutará cada vez que insertemos el código en nuestra rama principal y luego después de cada inserción posterior.

.github/workflows/main.yaml

name: Deploy

on:
  push:
    branches:
      - main

jobs:
  deploy_lambda:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v2
        with:
          node-version: "14"
      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-east-2
      - name: npm install
        working-directory: ./function-code
        env:
          CI: true
        run: |
          pwd
          npm ci --only=prod
      - name: npm install cdk modules
        env:
          CI: true
        run: |
          pwd
          npm ci
      - name: cdk synth
        id: synth
        run: npx cdk synth
      - name: cdk deploy
        id: cdk
        run: npx cdk deploy --require-approval never

Este archivo:

1. Configura la versión del nodo para instalar las dependencias
2. Recopila las credenciales que ha configurado en las acciones de Github
3. Instala dependencias para el código de back-end, así como para CDK
4. Implementa CDK: esto configurará la infraestructura y el código lambda en AWS

Eso es todo. Con suerte, podrá configurar el flujo completo.

Siéntase libre de comentar con cualquier sugerencia o si algo no está claro.

He adjuntado un enlace de Github aquí para su referencia:

https://github.com/ashansurkar/backend_lambda_cdk

Y si te ha gustado este post no dudes en aplaudir. ¡Feliz aprendizaje y feliz codificación!