Entonces, configurémoslos y veamos cómo funcionaría.

Cree el archivo main.tf usando las siguientes configuraciones:

Estas configuraciones son para crear

1. Función lambda
2. Política de ejecución y rol
3. También comprime la carpeta de código (“terraform_test” donde está nuestro código de ejecución)

terraform {
  required_version = ">= 0.12"
  required_providers {
    aws = ">= 4.10"
    archive = {
      source  = "hashicorp/archive"
      version = "~> 2.2.0"
    }
  }

}
provider "aws" {
  region  = "us-east-1"
  # if you run terraform locally then you will need to replace this with your credentials/aws-profile
  # and if you want to run through Github actions then you need to configure Secrets into Github
  # profile = "aws-profile" 
}

data "archive_file" "lambda_terraform_test" {
  type = "zip"

  source_dir  = "${path.module}/terraform_test"
  output_path = "${path.module}/terraform_test.zip"
}

# to Create function
resource "aws_lambda_function" "terraform_test" {
  function_name = "terraform_test"
  filename      = "terraform_test.zip"
  runtime = "nodejs14.x"
  handler = "index.handler"
  source_code_hash = data.archive_file.lambda_terraform_test.output_base64sha256
  role             = aws_iam_role.lambda_exec.arn
}

resource "aws_cloudwatch_log_group" "terraform_test" {
  name = "/aws/lambda/terraform_test"
  retention_in_days = 30
}

resource "aws_iam_role" "lambda_exec" {
  name = "serverless_test_lambda"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Sid    = ""
      Principal = {
        Service = "lambda.amazonaws.com"
      }
      }
    ]
  })
}

resource "aws_iam_role_policy_attachment" "lambda_policy" {
  role       = aws_iam_role.lambda_exec.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
}

Ahora vamos a crear la carpeta y agregar 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, configuremos las acciones de Github para la implementación automática de AWS lambda.

1. Configure las credenciales de AWS en el repositorio de Github.

Ahora, creemos una carpeta en la raíz del proyecto y agreguemos el archivo main.yaml como se muestra a continuación. Este archivo se ejecutará cuando 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-1
      - name: npm install
        working-directory: ./terraform_test
        env:
          CI: true
        run: |
          pwd
          npm ci --only=prod
      - uses: hashicorp/setup-terraform@v2
      - name: Terraform init
        id: init
        run: terraform init
      - name: Terraform plan
        id: plan
        run: terraform plan
      - name: Terraform apply
        id: apply
        run: terraform apply -auto-approve -input=false

Este archivo:

1. Configurar la versión del nodo para instalar las dependencias
2. Recopile las credenciales que ha configurado en las acciones de Github
3. Instalar dependencias
4. Inicialización de Terraform
5. Despliegue de Terraform

He marcado “-aprobación automática” aquí solo por conveniencia.

Eso es todo. Con suerte, podrá configurar el flujo completo. Dado que ahora que AWS lambda proporciona una “URL de función” directa, puede probarla fácilmente.

Siéntase libre de comentar con cualquier sugerencia o si algo no está claro. Todavía no he descubierto cómo podemos integrar las pruebas en este CICD. Así que cualquier comentario es bienvenido.

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