Pruebas Unitarias de Infraestructura en Terraform con TFLint y Checkov

Introducción a las Pruebas de Infraestructura como Código 🚀

La Infraestructura como Código (IaC) ha revolucionado la forma en que las organizaciones gestionan sus recursos tecnológicos. Sin embargo, al igual que el código de aplicaciones tradicional, el código de Terraform es propenso a errores humanos, malas configuraciones de seguridad y desviaciones de estilo. Aquí es donde entran en juego las pruebas de infraestructura.

Implementar un ciclo de vida de desarrollo seguro implica no solo escribir archivos .tf, sino validarlos antes de que lleguen a producción. En este tutorial, exploraremos cómo utilizar dos de las herramientas más potentes del ecosistema de DevOps actual: TFLint para análisis estático y reglas específicas de proveedores, y Checkov para escaneo de seguridad y cumplimiento normativo.

¿Qué son TFLint y Checkov y por qué usarlos juntos? 🛠️

Para construir un pipeline de validación robusto, es fundamental entender el propósito de cada herramienta:

La combinación de ambas herramientas cubre tanto la corrección sintáctica y lógica como la postura de seguridad de la infraestructura.

Requisitos Previos y Entorno de Trabajo 📋

Antes de comenzar, asegúrate de tener instaladas las siguientes herramientas en tu máquina de desarrollo o entorno de integración continua:

• Terraform (versión 1.3 o superior)
• TFLint
• Checkov
• Un editor de código como VS Code.

Puedes verificar las instalaciones ejecutando los siguientes comandos en tu terminal:

terraform --version
tflint --version
checkov --version

Estructura del Proyecto de Prueba 📁

Crearemos un directorio de trabajo básico que despliegue un recurso de infraestructura común: un bucket de Amazon S3 con configuraciones intencionalmente mejorables para que TFLint y Checkov detecten las fallas.

Crea una carpeta llamada terraform-testing-demo y dentro de ella un archivo llamado main.tf:

terraform {
  required_version = ">= 1.3.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_s3_bucket" "insecure_bucket" {
  bucket = "mi-bucket-de-prueba-inseguro-123456"
}

resource "aws_s3_bucket_acl" "example" {
  bucket = aws_s3_bucket.insecure_bucket.id
  acl    = "public-read"
}

Configuración y Ejecución de TFLint 🔍

1. Inicializar y Configurar TFLint

TFLint requiere un archivo de configuración para entender qué reglas aplicar, especialmente las específicas del proveedor de nube (en este caso, AWS).

Crea un archivo llamado .tflint.hcl en la raíz de tu proyecto:

config {
  plugin_dir = "~/.tflint/plugins"
}

plugin "aws" {
  enabled = true
  version = "0.25.0"
  source  = "github.com/terraform-linters/tflint-ruleset-aws"
}

rule "terraform_unused_declarations" {enabled = true}
rule "terraform_comment_syntax" {enabled = true}

2. Inicializar los Plugins de TFLint

Ejecuta el siguiente comando para descargar los plugins necesarios definidos en la configuración:

tflint --init

3. Ejecutar el Análisis Estático

Ahora ejecuta TFLint para verificar el código:

tflint

Verás salidas indicando si existen atributos obsoletos, declaraciones no utilizadas o advertencias específicas del proveedor AWS.

Configuración y Ejecución de Checkov para Seguridad 🛡️

A diferencia de TFLint, Checkov no requiere archivos de configuración complejos para comenzar a escanear. Utiliza un motor basado en políticas para analizar el código HCL directamente.

1. Ejecutar el Escaneo Básico

Ejecuta el siguiente comando en la raíz del proyecto:

checkov -d .

2. Analizar los Resultados

Checkov generará un reporte detallado en la consola mostrando:

• Controles superados (Passed checks).
• Controles fallidos (Failed checks).
• El ID de la política de seguridad (por ejemplo, CKV_AWS_20 para políticas de S3).

El bucket que configuramos con acceso público provocará que Checkov devuelva un fallo, indicando que los buckets S3 no deben permitir acceso público global.

Corrigiendo el Código Basado en los Resultados ✏️

Una vez identificados los errores por TFLint y Checkov, procedemos a corregir el archivo main.tf para cumplir con los estándares de seguridad y buenas prácticas.

Modifica tu archivo main.tf con la versión segura:

terraform {
  required_version = ">= 1.3.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_s3_bucket" "secure_bucket" {
  bucket = "mi-bucket-de-prueba-seguro-123456"
}

resource "aws_s3_bucket_server_side_encryption_configuration" "secure_encryption" {
  bucket = aws_s3_bucket.secure_bucket.id

  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "AES256"
    }
  }
}

resource "aws_s3_bucket_public_access_block" "public_block" {
  bucket                  = aws_s3_bucket.secure_bucket.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

Vuelve a ejecutar TFLint y Checkov. Verás que todos los errores y advertencias han desaparecido.

Automatización en CI/CD con GitHub Actions 🤖

Para asegurar que ningún código defectuoso llegue a la rama principal, automatizamos las pruebas mediante un pipeline de CI.

Crea el archivo .github/workflows/terraform-test.yml en tu repositorio:

name: Terraform Validation and Security

on:
  pull_request:
    branches: [ "main" ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v2

      - name: Setup TFLint
        uses: tflint-actions/setup-tflint@v3
        with:
          tflint_version: v0.48.0

      - name: Init TFLint
        run: tflint --init

      - name: Run TFLint
        run: tflint

      - name: Run Checkov
        uses: bridgecrewio/checkov-action@master
        with:
          framework: terraform

Preguntas Frecuentes (FAQ) ❓

Conclusión 🎉

Implementar pruebas unitarias y análisis estático con TFLint y Checkov transforma la gestión de infraestructura en un proceso mucho más predecible, seguro y profesional. Al shift-left (mover la seguridad y validación a las etapas tempranas del desarrollo), garantizas que tu equipo trabaje con estándares altos desde la primera línea de código.