En este artículo, exploraremos las mejores prácticas para implementar IaC con Pulumi, con ejemplos prácticos en GCP, AWS y DigitalOcean, estrategias avanzadas para Kubernetes y consideraciones clave en Disaster Recovery Planning (DRP).

1. ¿Por qué Pulumi para IaC?

Pulumi ofrece ventajas únicas frente a alternativas como Terraform o CloudFormation:

✅ Lenguajes familiares (Python, TypeScript, Go) en lugar de DSLs propietarios.
✅ Soporte multi-cloud (AWS, GCP, Azure, DigitalOcean, Kubernetes).
✅ Estado de infraestructura gestionado (Pulumi Service, S3, etc.).
✅ Integración con CI/CD nativa.
✅ Reutilización de código mediante componentes y librerías.

Ejemplo: Desplegando un cluster Kubernetes en DigitalOcean con Pulumi (Python)

import pulumi
import pulumi_digitalocean as do
# Crear un cluster Kubernetes en DigitalOcean
cluster = do.KubernetesCluster(
    "saas-cluster",
    region="nyc1",
    version="1.25.4-do.0",
    node_pool={
        "name": "default-pool",
        "size": "s-2vcpu-4gb",
        "node_count": 3,
    }
)
# Exportar el kubeconfig
pulumi.export("kubeconfig", cluster.kube_configs[0].raw_config)

Este código despliega un cluster gestionado en DigitalOcean con tres nodos, listo para integrarse en un pipeline de CI/CD.

2. Mejores Prácticas para IaC con Pulumi

🔹 Modularización y Reutilización

Evitar scripts monolíticos. En su lugar, estructurar el código en componentes reutilizables:

# Ejemplo: Módulo para un bucket S3 con políticas de acceso
class SecureBucket(pulumi.ComponentResource):
    def __init__(self, name, **kwargs):
        super().__init__("custom:SecureBucket", name, **kwargs)
        
        self.bucket = aws.s3.Bucket(name)
        aws.s3.BucketPolicy(
            f"{name}-policy",
            bucket=self.bucket.id,
            policy=json.dumps({
                "Version": "2012-10-17",
                "Statement": [{
                    "Effect": "Deny",
                    "Principal": "*",
                    "Action": "s3:*",
                    "Resource": [self.bucket.arn, f"{self.bucket.arn}/*"],
                    "Condition": {"Bool": {"aws:SecureTransport": False}}
                }]
            })
        )
# Uso del módulo
bucket = SecureBucket("prod-data-lake")

🔹 Gestión de Estado (State Management)

Pulumi guarda el estado de la infraestructura. Opciones recomendadas:

• Pulumi Service (gratis para proyectos pequeños).

• Amazon S3 / Google Cloud Storage (para mayor control).

# Inicializar un proyecto con backend en S3
pulumi login s3://my-pulumi-state-bucket

🔹 CI/CD Integrado

Ejemplo con GitHub Actions:

name: Deploy Infrastructure
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: pulumi/actions@v3
        with:
          command: up
          stack-name: prod
        env:
          PULUMI_ACCESS_TOKEN: ${{ secrets.PULUMI_ACCESS_TOKEN }}

3. Kubernetes con Pulumi: Gestión Eficiente

Pulumi permite gestionar Kubernetes de forma declarativa sin necesidad de kubectl manual.

Ejemplo: Despliegue de una App en Kubernetes

import pulumi_kubernetes as k8s
# Crear un Namespace
app_ns = k8s.core.v1.Namespace("app-ns")
# Desplegar una aplicación
app = k8s.apps.v1.Deployment(
    "app-deployment",
    metadata={"namespace": app_ns.metadata["name"]},
    spec={
        "replicas": 3,
        "selector": {"match_labels": {"app": "my-saas"}},
        "template": {
            "metadata": {"labels": {"app": "my-saas"}},
            "spec": {
                "containers": [{
                    "name": "app",
                    "image": "my-registry/my-saas-app:latest",
                    "ports": [{"container_port": 8080}]
                }]
            }
        }
    }
)
# Exponer el servicio
service = k8s.core.v1.Service(
    "app-service",
    metadata={"namespace": app_ns.metadata["name"]},
    spec={
        "selector": {"app": "my-saas"},
        "ports": [{"port": 80, "target_port": 8080}],
        "type": "LoadBalancer"
    }
)
pulumi.export("service_url", service.status["load_balancer"]["ingress"][0]["hostname"])

4. Disaster Recovery Planning (DRP) con Pulumi

Un buen DRP define RTO (Recovery Time Objective) y RPO (Recovery Point Objective).

Visualización de RTO/RPO

(Imagen conceptual: Tabla comparando estrategias de backup y replicación)

Ejemplo: Configuración de DRP en AWS

import pulumi_aws as aws
# Replicación de buckets S3 entre regiones
primary_bucket = aws.s3.Bucket("primary-bucket", acl="private")
replica_bucket = aws.s3.Bucket("replica-bucket", acl="private")
aws.s3.BucketReplication(
    "replication",
    bucket=primary_bucket.id,
    role=replication_role.arn,
    rules=[{
        "status": "Enabled",
        "destination": {
            "bucket": replica_bucket.arn,
            "storage_class": "STANDARD"
        }
    }]
)

5. Conclusión

Pulumi es una herramienta poderosa para automatizar infraestructura cloud con código real, mejorando la productividad de equipos DevOps y startups SaaS.

🔹 Mejores prácticas clave:

• Modularizar el código IaC.

• Gestionar el estado de forma segura.

• Integrar con CI/CD.

• Planificar Disaster Recovery (RTO/RPO).

¿Listo para probar Pulumi? Comienza con su documentación oficial.

📢 ¿Quieres más detalles sobre algún tema? ¡Contactame!

#DevOps #InfrastructureAsCode #Pulumi #Kubernetes #CloudComputing #SaaS #DisasterRecovery

Recientemente hemos estado haciendo PoC´s con Pulumi y Digital Ocean así que metimos a un tercero a la ecuación, ArgoCD, una herramienta de Delivery para Kubernetes.

A partir del PoC hecho con Pulumi y Digital Ocean instalamos ArgoCD en el cluster de Kubernetes creado y vinculamos un único repositorio con dos ramas, master y feature/python-simple-web para dos apps diferentes mypage y simple-web en ArgoCD, lo que hace difiere estas dos ramas son el namespace del proyecto, la imagen del contenedor y la url que nginx-ingress deberá administrar.

Esta nueva herramienta después de hacer todos los ajustes se vuelve divertida y amigable, como primer acercamiento puedo decir que tiene una agradable interface gráfica y que me hace pensar si dejaremos fuera a Pulumi para administrar el estatus deseado de los recursos creados previamente como deployments/services/ingress/configMaps etc, en el cluster.

A continuación les dejo unas capturas del PoC.

Branches Repositorio Git

ArgoCD Dashboard Applications

ArgoCD vista de red del app “mypage”

ArgoCD vista de arbol del app “mypage”

ArgoCD vista de red del app “simple-web”

ArgoCD vista de arbol del app “simple-web”

Vista en vivo de app “mypage”

Vista en vivo de app “simple’web” balance pod 2

Vista en vivo de app “simple’web” balance pod 1

Si requieres de mi ayuda para administrar tu infraestructura e implementar un sistema GitOps contáctame.

Usando código en Typescript trabaje en un PoC para vincular 3 Droplets y balancear sus cargas, para ello hice uso de Pulumi para generar la arquitectura en donde un balanceador de carga recibirá las peticiones y las dirigirá hacia los droplets, a su vez un firewall evitara accesos a puertos no solicitados.

En un post previo hable de Pulumi con Digital Ocean, con el que trabaje en un PoC y Kubernetes. Para este PoC me base en este código  al cual le hice algunas adecuaciones para instalar docker y ejecutar el contenedor de Simple Web y validar el balanceo a través de los 3 Droplets creados.

En la primer creación del Load Balancer, el verificador de salud lo habia definido para revisar el protocolo TCP en el puerto 80, esto genero un fallo general debido al uso del contenedor con python, por lo que procedí a ajustarlo para revisar el protocolo HTTP en el codigo de Typescript en lugar de hacerlo en el panel administrativo de Digital Ocean obteniendo así el estado de salud satisfactorio.

Cabe señalar que existen algunos glitches que Pulumi deberá resolver como en el caso de actualizar el Userdata de los Droplets se generan errores en el recurso del Firewall y Load Balancer.

Les dejo a continuación unas capturas del PoC.

Pulumi Stack

DO VPC creado

DO DROPLETS creados

DO LB creado

DO FW creado

Puedes usar una gran variedad de software para llevarlo a cabo, lo que implica en algunos casos aprender un nuevo lenguaje, algo que Pulumi ha tomado en cuenta para su rápida adopción, por lo que si sabes Typescript, Go, Python, Javascript o .Net reducirás enormemente la curvatura de aprendizaje.

Había escuchado de Pulumi hace un año, hace unas semanas tome dos webinars  y las dudas que tenia sobre su uso, escenarios me animo a probarlo con una promo que obtuve en Digital Ocean por lo que inicie con la creación de un cluster Kuberntes usando Typescript. Pulumi te ofrece una version gratuita si únicamente tú usas el entorno.

La ventaja de esto que puedes ir haciéndolo poco a poco y esta es la lista ordenada de lo que fui administrando con mi código.

1. Creación del Cluster Kubernetes.
2. Creación de algunos namespaces, ex: staging, website
3. Creación de un primer Deployment con nginx en el namespace de staging.
4. Creación de un ClusterIP Service para el Deployment creado en el punto 3.
5. Una gran pausa para instalar Istio (muy complicado y tomaría mas horas) o nginx como Ingress
6. Después de decidirme en el punto 5 por nginx, procedí a crear el código para instalarlo como Ingress, con su namespace usando el Helm v3 Chart; esto me genero un LoadBalancer en Digital Ocean a su vez asignándome la IP Publica.
7. Creación de un Service Ingress para dirigir el tráfico del ingress-nginx creado en el punto 6 hacia el ClusterIP creado en el punto 4, puedes verlo en do.webmago.dev (puede no estar disponible en el futuro).

Ejecucion Paso 1 Pulumi

Revision Dashboard Digital Ocean

Dashboard Pulumi paso 1

Cabe señalar que para mantener mi entorno aislado y no interferir con mis configuraciones de mi equipo trabaje desde un contenedor de docker.

Tengo que aclarar que tuve algunos glitches con Pulumi al aplicar/actualizar cambios y al parecer es un comportamiento algo raro que tiene Digital Ocean, por lo que recibía errores y tenia que volver a ejecutar la actualización de cambios.

En mi experiencia, puedo decir que Pulumi reduce considerablemente su curvatura de aprendizaje y adopción permitiéndote administrar tu Infraestructura como Código con los lenguajes antes mencionados.