Eso se llama contexto switching. Y mata la productividad más silenciosamente que un merge conflict un viernes a las 6pm.

Hoy arrancamos una serie para erradicarlo. Y el primer episodio tiene protagonista: el Terraform MCP Server.

¿Qué es MCP y por qué te debería importar?

MCP son las siglas de Model Context Protocol un estándar abierto que le permite a los modelos de AI conectarse de forma segura con herramientas externas, aplicaciones y fuentes de datos. La idea es simple y poderosa: en vez de que la IA trabaje solo con lo que aprendió hasta su fecha de corte, puede consultar información actualizada en tiempo real.

HashiCorp lanzó su propio MCP Server para Terraform y es exactamente lo que el nombre promete: un servidor que le da a tu IA acceso directo al Terraform Registry. Providers, módulos, políticas Sentinel, workspaces de HCP Terraform todo disponible en el momento en que lo necesitás, desde tu IDE, sin cambiar de pantalla.

"En vez de que la IA adivine cómo se configura un aws_s3_bucket con la versión actual del provider, le pregunta al Registry directamente."

Está en beta (v0.5.x), pero ya funciona muy bien para el día a día.

Pensalo como el "USB-C" de los agentes de AI: un protocolo universal para enchufar contexto.

Acá el diagrama de arquitectura completo:

Cómo funciona por dentro

El flujo es así:

Vos escribís un prompt en tu IDE
         ↓
    IA Agent (Copilot / Cursor / Claude)
         ↓
    Terraform MCP Server
         ↓
    Terraform Registry (docs actualizadas, en vivo)
         ↓
    HCL correcto en tu editor

Los componentes clave que necesitás entender:

• MCP Host: tu IDE (VS Code, Cursor) o app como Claude Desktop

• MCP Client: el agente de AI que interpreta tus prompts

• MCP Server: el servidor de Terraform que expone las herramientas

• Transport: cómo se comunican — por defecto usa stdio (stdin/stdout), también soporta HTTP streamable para deployments remotos

El MCP Server tiene tres toolsets principales:

Y dentro de registry, los tools que vas a usar más seguido son:

• search_providers — busca documentación por servicio

• get_provider_details — documentación completa de un recurso

• search_modules — encuentra módulos por nombre o funcionalidad

• get_module_details — inputs, outputs, ejemplos, submódulos

Lo mejor: no los invocás manualmente. El agente los usa automáticamente cuando le hacés una pregunta relevante.

Sin MCP → la AI es como un empleado muy listo que estudió todo de memoria antes de entrar, pero que lleva 6 meses sin actualizar su conocimiento. Si le preguntás por un provider de Terraform que cambió el mes pasado, te va a dar la versión vieja... o directamente inventar algo que suena bien pero no existe.

Con MCP → ese mismo empleado ahora tiene una computadora conectada a internet, a tu GitLab, a AWS, al Terraform Registry. Antes de responderte, va y busca la información real. No adivina, no recuerda mal: consulta la fuente directamente.

Setup en 5 minutos (en serio, 5 minutos)

Tenés tres opciones de instalación:

Vamos con Docker que es la más portable.

Prerequisitos

• Docker corriendo

• VS Code con la extensión GitHub Copilot en modo Agent, o Cursor con MCP habilitado

• Ganas de dejar de abrir tabs

Paso 1: Pull de la imagen

docker pull hashicorp/terraform-mcp-server:latest

Paso 2: Configuración en VS Code

Creá la carpeta .vscode en tu proyecto y adentro el archivo mcp.json:

{
  "servers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "hashicorp/terraform-mcp-server"
      ]
    }
  }
}

Guardás el archivo. VS Code te va a mostrar un link start debajo de "servers". Lo clickeás. El container arranca.

⚠️ Tip de campo: No uses el botón "Add Server..." de la UI de VS Code. La experiencia guiada es confusa y no siempre funciona bien. Pegá el JSON directamente.

Paso 3: Verificar que el agente lo ve

Abrís GitHub Copilot Chat, te asegurás de estar en modo Agent, y clickeás el ícono de herramientas. Debería aparecerte terraform-mcp-server con todos sus tools habilitados.

Configuración para Cursor

En Cursor, editás tu settings.json de usuario:

{
  "mcp": {
    "servers": {
      "terraform": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "hashicorp/terraform-mcp-server"
        ]
      }
    }
  }
}

Después: Settings → MCP → verificar que Terraform MCP Server aparezca con tools activos.

¿Usás HCP Terraform o Terraform Enterprise?

Agregás las variables de entorno en el config:

{
  "servers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "TFE_TOKEN=tu-token-aqui",
        "-e", "TFE_ADDRESS=https://app.terraform.io",
        "hashicorp/terraform-mcp-server"
      ]
    }
  }
}

Con esto el MCP Server también puede listar tus workspaces, runs y módulos privados.

Laboratorio: hacelo vos ahora mismo

Ya tenés el MCP corriendo. Hora de probarlo con algo concreto y sin dependencias de nube sin AWS, sin credenciales, sin nada. Solo Terraform y tu filesystem local.

Copiá este prompt exacto en tu agente:

Usa Terraform MCP para revisar el provider hashicorp/local 
y luego genera un ejemplo mínimo funcional en Terraform.

El agente va a llamar a search_providers con hashicorp/local, después a get_provider_details para ver los recursos disponibles, y te va a devolver algo así:

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.5"
    }
  }
}
 
# Crea un archivo de texto en tu sistema local
resource "local_file" "ejemplo" {
  content  = "Hola desde Terraform MCP 🔥"
  filename = "${path.module}/output.txt"
}
 
# Lee un archivo existente (data source)
data "local_file" "leeme" {
  filename = "${path.module}/output.txt"
}
 
output "contenido" {
  value = local_file.ejemplo.content
}

Guardás eso en un main.tf, y ejecutás:

terraform init
terraform apply -auto-approve
cat output.txt

¿Qué acaba de pasar?

El agente no usó su memoria de entrenamiento para saber qué atributos acepta local_file. Consultó el Registry en tiempo real vía MCP, obtuvo la documentación actualizada del provider hashicorp/local v2.5, y generó HCL válido contra esa versión específica.

Resultado: un archivo output.txt en tu directorio con el contenido que le pediste. Sin abrir el Registry. Sin chequear si content o file_content era el atributo correcto en esta versión.

💡 Por qué este ejemplo importa: hashicorp/local es el provider más sencillo que existe en Terraform — no necesita credenciales de nube ni configuración extra. Si el MCP funciona acá, funciona en cualquier otro provider. Es el hello world perfecto para validar que el setup está bien antes de meterle AWS, GCP o Azure.

Demo: S3 con versioning y lifecycle policy, sin abrir el Registry

Este es el momento que justifica todo el setup.

Antes del MCP Server, el workflow era así:

1. Abrir el Terraform Registry

2. Buscar aws_s3_bucket

3. Buscar aws_s3_bucket_versioning (porque ya no va en el mismo recurso, cambió en el provider v4)

4. Buscar aws_s3_bucket_lifecycle_configuration

5. Copiar snippets

6. Pegar en el editor

7. Descubrir que estás usando atributos deprecados

8. Volver al Registry

9. Rezar

Con el MCP Server, le escribís esto a tu agente:

How do I configure an AWS S3 bucket with versioning enabled and a 
lifecycle policy that moves objects to Glacier after 90 days?
Use the latest version of the AWS provider.

El agente llama a search_providers para encontrar el provider de AWS, después a get_provider_details para cada recurso relevante, y te devuelve esto:

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

resource "aws_s3_bucket" "example" {
  bucket = "mi-bucket-con-versioning"
}

resource "aws_s3_bucket_versioning" "example" {
  bucket = aws_s3_bucket.example.id

  versioning_configuration {
    status = "Enabled"
  }
}

resource "aws_s3_bucket_lifecycle_configuration" "example" {
  bucket = aws_s3_bucket.example.id

  rule {
    id     = "mover-a-glacier"
    status = "Enabled"

    transition {
      days          = 90
      storage_class = "GLACIER"
    }
  }
}

HCL correcto. Recursos separados según la estructura actual del provider v5. Sin atributos deprecados. Sin tabs extras abiertas.

¿La diferencia que más importa? Como el MCP consulta el Registry en tiempo real, no te va a devolver el esquema de la versión 3 del provider AWS que aprendió hace meses. Te da lo que está vigente hoy.

Una nota sobre seguridad (no la saltees)

El MCP Server es una herramienta poderosa. Algunas consideraciones antes de usarlo en un entorno de equipo:

Corrélo local. La recomendación oficial es correrlo en 127.0.0.1 vía STDIO o HTTP Streamable. No expongas el servidor directamente a internet.

Permisos mínimos para el TFE_TOKEN. Si lo configurás con HCP Terraform, dale al token solo los permisos que necesita. Nada más.

ENABLE_TF_OPERATIONS está OFF por defecto, y con razón. Esta variable habilita operaciones destructivas como auto_approve y is_destroy. No la toques hasta entender bien qué hace. Lo cubrimos en detalle en el Episodio 6.

Rate limiting. Si lo usás en equipo o de forma intensiva, configurá los límites de requests para no saturar el Registry:

MCP_RATE_LIMIT_GLOBAL=10:20   # 10 req/seg, burst de 20
MCP_RATE_LIMIT_SESSION=5:10   # por sesión

Lo que acabás de conectar

Con este setup tenés un agente que:

✅ Sabe qué resources existen en cualquier provider de Terraform, en la versión actual
✅ Puede buscar y recomendar módulos del Registry según lo que necesitás
✅ Genera HCL válido sin depender de datos de entrenamiento desactualizados
✅ Puede hablar con tus workspaces de HCP Terraform si lo configurás

Y todo desde tu IDE. Sin cambiar de pantalla. Sin abrir el Registry manualmente.

https://youtu.be/UKrf6qyfyoo

Próximo episodio

Episodio 2 → Escribí módulos de Terraform sin acordarte de la sintaxis

Workflow completo con MCP + Cursor en modo Agent para crear módulos reutilizables desde cero. Inputs, outputs, variables — todo generado y validado contra el Registry en tiempo real. Y lo más importante: qué pasa cuando el agente se equivoca y cómo corregirlo sin perder el hilo.

¿Te resultó útil? Compartilo con ese colega que todavía tiene 20 tabs del Registry abiertas.

Seguime en blog.295devops.com para el resto de la serie.

Recursos

• Terraform MCP Server — Documentación oficial

• Repositorio en GitHub

• Referencia de tools y variables de entorno

En esta entrada vamos a cubrir todo lo que necesitas saber para darle vida a tus scripts con color: desde los fundamentos de los códigos ANSI hasta patrones avanzados que puedes reutilizar en tus proyectos.

¿Por qué colorear la salida de tus scripts?

Antes de entrar en el código, vale la pena reflexionar sobre por qué esto importa. Cuando ejecutas un script que despliega infraestructura, corre pruebas o gestiona contenedores, la cantidad de output puede ser abrumadora. Los colores te permiten:

• Identificar errores al instante: rojo para fallos, verde para éxito.

• Separar secciones lógicas: cada fase de tu pipeline puede tener su propio color.

• Mejorar la experiencia del usuario: si otros desarrolladores usan tus scripts, agradecerán la claridad visual.

• Reducir el tiempo de depuración: encontrar el problema en un log colorizado es exponencialmente más rápido.

En el contexto de DevOps, donde la automatización es el pan de cada día, esto no es un lujo — es productividad real.

Los códigos de escape ANSI: la base de todo

La magia detrás de los colores en la terminal son los códigos de escape ANSI. El estándar ANSI (American National Standards Institute) define una serie de secuencias de caracteres que las terminales interpretan como instrucciones de formato en lugar de texto visible.

La estructura básica de una secuencia de escape es:

\e[CODIGOm

Donde:

• \e (o \033 en octal, o \x1b en hexadecimal) inicia la secuencia de escape.

• [ abre la secuencia CSI (Control Sequence Introducer).

• CODIGO es el número que define el color o estilo.

• m cierra la secuencia.

Tabla de colores de primer plano (texto)

Códigos de estilo (no relacionados con color)

Tu primer texto en color

El comando echo imprime texto en la terminal. Para que interprete las secuencias de escape ANSI, necesitamos la opción -e:

echo -e "\e[31mTexto en rojo\e[0m"

Desglosemos esto:

• \e[31m → Activa el color rojo (código 31 de primer plano).

• Texto en rojo → El contenido que se mostrará en rojo.

• \e[0m → Restablece el formato a la normalidad (código 0).

⚠️ Importante: El \e[0m al final es crucial. Sin él, todo el texto que imprimas después en esa sesión de terminal aparecerá en rojo. Siempre cierra tus secuencias de color.

Usando variables para mayor legibilidad

Escribir \e[31m cada vez que quieres rojo no es práctico ni legible. La solución es almacenar los códigos en variables:

RED="\e[31m"
GREEN="\e[32m"
YELLOW="\e[33m"
BLUE="\e[34m"
MAGENTA="\e[35m"
CYAN="\e[36m"
ENDCOLOR="\e[0m"

echo -e "\({RED}Error: algo salió mal\){ENDCOLOR}"
echo -e "\({GREEN}Éxito: despliegue completado\){ENDCOLOR}"
echo -e "\({YELLOW}Advertencia: revisa la configuración\){ENDCOLOR}"

Ahora el código es mucho más expresivo. Cualquiera que lo lea entiende inmediatamente la intención.

Script básico completo

#! /usr/bin/env bash

RED="\e[31m"
GREEN="\e[32m"
ENDCOLOR="\e[0m"

echo -e "\({RED}This is some red text, \){ENDCOLOR}"
echo -e "\({GREEN}And this is some green text\){ENDCOLOR}"

Combinando estilos y colores

Aquí es donde la cosa se pone interesante. Puedes combinar múltiples códigos separándolos con punto y coma (;) dentro de una sola secuencia de escape:

\e[ESTILO;COLORm

Por ejemplo:

#! /usr/bin/env bash

RED="31"
GREEN="32"
BOLDGREEN="\e[1;${GREEN}m"
ITALICRED="\e[3;${RED}m"
ENDCOLOR="\e[0m"

echo -e "\({BOLDGREEN}Behold! Bold, green text.\){ENDCOLOR}"
echo -e "\({ITALICRED}Italian italics\){ENDCOLOR}"

Observa cómo separamos el código de estilo del código de color: 1;32 significa "negrita + verde". Puedes incluso combinar tres o más códigos: \e[1;4;31m te daría texto rojo, negrita y subrayado.

Más combinaciones útiles

BOLD="\e[1m"
DIM="\e[2m"
UNDERLINE="\e[4m"
BLINK="\e[5m"
REVERSE="\e[7m"
STRIKETHROUGH="\e[9m"

BOLD_RED="\e[1;31m"
UNDERLINE_BLUE="\e[4;34m"
BOLD_YELLOW_ON_RED="\e[1;33;41m"  # Texto amarillo negrita sobre fondo rojo

Color de fondo

Los códigos de fondo (40-47 y 100-107) se usan de la misma forma. Puedes combinarlos con colores de texto:

# Texto blanco sobre fondo rojo (ideal para errores críticos)
echo -e "\e[97;41m CRITICAL ERROR \e[0m Something broke badly"

# Texto negro sobre fondo amarillo (ideal para advertencias)
echo -e "\e[30;43m WARNING \e[0m Check your configuration"

# Texto negro sobre fondo verde (ideal para éxito)
echo -e "\e[30;42m SUCCESS \e[0m Deployment completed"

Este patrón de "badges" o etiquetas de color es muy común en herramientas CLI profesionales.

Colores de 256 colores y RGB (True Color)

Las terminales modernas soportan más que los 16 colores básicos ANSI.

256 colores

Puedes acceder a una paleta de 256 colores usando:

# Primer plano: \e[38;5;COLORm
# Fondo:        \e[48;5;COLORm

echo -e "\e[38;5;208mTexto naranja (color 208)\e[0m"
echo -e "\e[48;5;27mFondo azul intenso\e[0m"

Los valores van de 0 a 255, donde 0-7 son los colores estándar, 8-15 son los colores brillantes, 16-231 es un cubo de color 6×6×6, y 232-255 son tonos de gris.

True Color (24-bit RGB)

Si tu terminal lo soporta (la mayoría de las modernas lo hacen), puedes usar colores RGB exactos:

# Primer plano: \e[38;2;R;G;Bm
# Fondo:        \e[48;2;R;G;Bm

echo -e "\e[38;2;255;100;0mNaranja personalizado\e[0m"
echo -e "\e[38;2;0;200;255mAzul cielo\e[0m"

Esto te da acceso a más de 16 millones de colores.

Alternativas a \e: compatibilidad entre terminales

Aunque \e funciona en la mayoría de las terminales modernas, existen alternativas más portables:

Si necesitas máxima compatibilidad, usa \033:

RED="\033[31m"
ENDCOLOR="\033[0m"
echo -e "\({RED}Compatible con más terminales\){ENDCOLOR}"

O usa el comando tput, que consulta la base de datos terminfo de tu sistema:

RED=$(tput setaf 1)
GREEN=$(tput setaf 2)
BOLD=$(tput bold)
RESET=$(tput sgr0)

echo "\({RED}Rojo con tput\){RESET}"
echo "\({BOLD}\){GREEN}Verde negrita${RESET}"

La ventaja de tput es que genera la secuencia correcta para cada terminal automáticamente.

Patrón práctico: funciones de logging con color

En lugar de usar variables sueltas, un patrón más profesional es crear funciones de logging reutilizables:

#! /usr/bin/env bash

# --- Colores ---
RED="\e[31m"
GREEN="\e[32m"
YELLOW="\e[33m"
BLUE="\e[34m"
BOLD="\e[1m"
DIM="\e[2m"
ENDCOLOR="\e[0m"

# --- Funciones de logging ---
log_info() {
    echo -e "\({BLUE}[INFO]\){ENDCOLOR} $1"
}

log_success() {
    echo -e "\({GREEN}[OK]\){ENDCOLOR} $1"
}

log_warning() {
    echo -e "\({YELLOW}[WARN]\){ENDCOLOR} $1"
}

log_error() {
    echo -e "\({RED}[ERROR]\){ENDCOLOR} $1"
}

log_step() {
    echo -e "\({BOLD}\){BLUE}==>\({ENDCOLOR}\){BOLD} \(1\){ENDCOLOR}"
}

# --- Uso ---
log_step "Iniciando despliegue..."
log_info "Conectando al cluster de Kubernetes..."
log_success "Conexión establecida"
log_warning "La imagen no tiene tag específico, usando :latest"
log_error "Fallo al aplicar el manifiesto: timeout después de 30s"

Este patrón es extremadamente útil para scripts de CI/CD, hooks de Git y herramientas de automatización.

Detectando soporte de color

No todas las terminales soportan colores (piensa en logs redirigidos a archivos o terminales mínimas). Es buena práctica verificar:

#! /usr/bin/env bash

# Desactivar colores si no estamos en una terminal interactiva
if [[ -t 1 ]]; then
    RED="\e[31m"
    GREEN="\e[32m"
    YELLOW="\e[33m"
    ENDCOLOR="\e[0m"
else
    RED=""
    GREEN=""
    YELLOW=""
    ENDCOLOR=""
fi

echo -e "\({GREEN}Esto se ve verde en terminal, y normal en un archivo\){ENDCOLOR}"

El test -t 1 verifica si el file descriptor 1 (stdout) está conectado a una terminal. Si el output se redirige a un archivo (script.sh > log.txt), los códigos de color se omiten, evitando ensuciar los logs con caracteres de escape ilegibles.

También puedes respetar la variable de entorno NO_COLOR (estándar de la comunidad: no-color.org):

if [[ -n "${NO_COLOR:-}" ]]; then
    RED=""
    GREEN=""
    ENDCOLOR=""
fi

Ejemplo completo: script de despliegue con salida colorizada

Para cerrar, aquí tienes un ejemplo más realista que podrías adaptar para tus propios scripts de despliegue o hooks de Git:

#! /usr/bin/env bash
set -euo pipefail

# ============================================================
# Colores y estilos
# ============================================================
if [[ -t 1 ]]; then
    RED="\e[31m"
    GREEN="\e[32m"
    YELLOW="\e[33m"
    BLUE="\e[34m"
    CYAN="\e[36m"
    BOLD="\e[1m"
    DIM="\e[2m"
    NC="\e[0m"  # No Color
else
    RED="" GREEN="" YELLOW="" BLUE="" CYAN="" BOLD="" DIM="" NC=""
fi

# ============================================================
# Funciones de utilidad
# ============================================================
header() {
    echo ""
    echo -e "\({BOLD}\){CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "\({BOLD}\){CYAN}  \(1\){NC}"
    echo -e "\({BOLD}\){CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
}

info()    { echo -e "  \({BLUE}ℹ\){NC}  $1"; }
success() { echo -e "  \({GREEN}✔\){NC}  $1"; }
warn()    { echo -e "  \({YELLOW}⚠\){NC}  $1"; }
error()   { echo -e "  \({RED}✘\){NC}  $1"; }
step()    { echo -e "  \({DIM}→\){NC}  $1"; }

# ============================================================
# Script principal
# ============================================================
header "DEPLOY v2.4.1 → production"

info "Verificando pre-requisitos..."
step "kubectl configurado: $(kubectl config current-context 2>/dev/null || echo 'N/A')"
step "Docker version: $(docker --version 2>/dev/null | cut -d' ' -f3 || echo 'N/A')"
success "Pre-requisitos verificados"

info "Construyendo imagen Docker..."
if docker build -t myapp:v2.4.1 . > /dev/null 2>&1; then
    success "Imagen construida exitosamente"
else
    error "Fallo al construir la imagen"
    exit 1
fi

info "Aplicando manifiestos de Kubernetes..."
warn "Usando namespace: production (¡cuidado!)"
success "Despliegue completado"

header "RESUMEN"
echo -e "  Estado:  \({GREEN}\){BOLD}EXITOSO${NC}"
echo -e "  Versión: \({CYAN}v2.4.1\){NC}"
echo -e "  Tiempo:  \({DIM}12.4s\){NC}"
echo ""

Consejos finales

1. Siempre resetea con \e[0m al final de cada línea coloreada. No hacerlo es la fuente número uno de bugs visuales.

2. Usa funciones, no variables sueltas en scripts de producción. Son más mantenibles y puedes agregar timestamps, redirección a archivo, y otras mejoras en un solo lugar.

3. Respeta NO_COLOR y -t 1. Tus scripts serán ciudadanos de primera clase en pipelines automatizados.

4. No abuses del color. Si todo es colorido, nada destaca. Usa rojo solo para errores reales, amarillo para advertencias, y verde para confirmaciones de éxito.

5. printf vs echo -e: Si buscas portabilidad máxima, printf maneja secuencias de escape sin necesidad de flags adicionales:

   printf "\({RED}Error: %s\){ENDCOLOR}\n" "algo falló"
   

6. Prueba en múltiples terminales. Lo que se ve perfecto en tu iTerm2 o Alacritty puede verse diferente en una terminal más básica.

Las combinaciones son infinitas y son tuyas. Ahora que tienes las herramientas, dale personalidad a tus scripts y haz que la terminal sea un lugar más amigable para trabajar.

La meta es la excusa

Escribir un libro, empezar un proyecto o mudarte a otro país…
Sí, son metas enormes, pero lo más valioso no está en la meta, sino en la historia que inspira a otros a soñar y a moverse.

Cuando compartís tu proceso con errores, dudas y victorias mostrás que no hay que ser extraordinario para hacer algo extraordinario.

¿Tienes superpoderes?

No vienen de ser un héroe de película ni de haber nacido con un don especial.
💪 Tus superpoderes vienen de lo que elegís hacer… y más aún, de lo que elegís dar a los demás.

Ser optimista, feliz y agradecido está bien, pero ayudar a que otras personas también lo sean… eso es un nivel más alto.

Personas comunes, logros increíbles

No suelo ver a gente “perfecta” haciendo lo imposible.
Lo que veo cada día son personas normales que:

• Dan un paso cuando nadie se atreve.

• Vuelven a intentar después de fallar.

• Inspiran con pequeños gestos que cambian mucho.

No es magia. Es voluntad.
No es suerte. Es decisión.

La chispa que enciende todo

Tu historia, por simple que te parezca, puede ser la señal que alguien estaba esperando.
Un post, una charla, una conversación… y de pronto, esa persona se anima.

🌍 Si cada uno de nosotros comparte, inspira y ayuda, el mundo no va a necesitar superhéroes:
Va a estar lleno de personas con superpoderes reales.

💬 Reflexión final:

No importa si tu meta es correr, emprender, aprender o cambiar de rumbo.
Lo importante es a quién ayudas a creer que también puede hacerlo.

Ese sí es un verdadero superpoder. 🔥

Al final, no se trata solo de lo que logras, sino de lo que despiertas en los demás.
Tus metas y retos son importantes, pero tu verdadero legado es la huella que dejas en las personas que, gracias a tu ejemplo, deciden avanzar.
Cada palabra, cada gesto y cada historia que compartes puede ser el impulso que alguien necesitaba para creer que también es posible.
Ese es el superpoder que todos podemos elegir: inspirar y encender caminos. 🔥

Y aunque suene gracioso eso de “Dra Roxs”, descubrí que muchas personas no necesitan una receta técnica, sino un espacio humano para poder decir:

"Estoy perdida, ¿cómo encuentro mi camino en este mundo tech?"

Y ahí entendí algo importante que quiero compartirte hoy

🌸 Cada persona florece distinto

Durante la charla, me preguntaron:

"Roxs, ¿cuál es tu especialidad para poder guiar a otros?"

Y mi respuesta fue simple, pero honesta: No tengo una única especialidad, porque cada persona es distinta.

Lo que a mí me funciona puede no encenderte a vos. A mí me enciende la rosa 🌹 porque la siento potente, vibrante, intensa. Pero quizás a vos te conmueve la margarita 🌼: más simple, más serena, igual de hermosa. Ambas son flores. Ambas son caminos válidos.

Y ahí está la clave: no se trata de imitar a otros, sino de descubrir tu propia flor, tu propio fuego, tu propio crecimiento.

🔥 Crecer cada día: 6 estrategias que me sostienen

En este mundo que corre a mil por hora, donde la presión por “estar al día” nos puede abrumar, necesito anclas. Pequeñas acciones que me conecten con mi propósito y que me permitan evolucionar sin perderme en el caos. Estas son mis 6 estrategias personales para aprender y crecer todos los días, incluso en los días nublados:

1️⃣ Planificá lo que querés aprender

No dejo mi aprendizaje al azar. Antes de arrancar una semana, me pregunto:

• ¿Qué habilidad quiero mejorar?

• ¿Qué concepto quiero explorar más allá de lo básico?

No todo lo que aprendo tiene que estar ligado al trabajo. A veces es sobre comunicación, empatía, o incluso cómo descansar mejor.

2️⃣ Practicá con intención, no en automático

Hacer las cosas por rutina no siempre significa que estás creciendo. La práctica deliberada significa poner foco, evaluar, ajustar.

Por ejemplo, si estoy mejorando una charla o una aplicación que estoy automatizando, me grabo, me escucho, pido feedback. No para criticarme, sino para evolucionar.

3️⃣ Procesar Ideas (reflexionar en movimiento)

Hay días donde necesito salir a caminar, auriculares puestos, hablando sola. Sí, suena raro. Pero funciona.

Esa conversación conmigo misma me ayuda a acomodar ideas, a detectar lo que me vibra o lo que ya no me representa. Reflexionar también es crecer.

4️⃣ Creá espacios para aprender

No siempre tengo una hora libre para sentarme a leer, pero me creo mini espacios:

• 10 minutos para escuchar un podcast mientras desayuno

• 15 minutos de newsletter técnica antes de dormir

• O una charla con alguien que admiro

El aprendizaje también se nutre de lo cotidiano.

5️⃣ Resolvé los problemas en el momento, no después

Muchas veces escondemos los errores bajo la alfombra. Pero lo pequeño que se ignora hoy, explota mañana.

Tener espacios en blanco en el día (sin reuniones, sin distracciones) me permite detectar fricciones, ruidos, incomodidades. Y resolver antes de que se vuelva un incendio.

6️⃣ Experimentá, incluso si falla

Hago mini-experimentos todo el tiempo. En mi comunidad, en mi lab de CI/CD, en cómo enseño, en cómo vivo.

Algunos salen increíbles. Otros me enseñan lo que no quiero hacer.

Pero todos me dan algo: perspectiva, valentía y evolución.

💬 La lección más linda de ser Dra “Fuego” Roxs

Ese día no resolví todos los dilemas de la persona que me escribió. No le di un "camino seguro" ni una receta mágica. Le mostré cómo buscar su propio camino.

Le dije:

"Si te gusta la margarita, no te esfuerces en parecerte a la rosa. Tu luz está en florecer a tu manera."

Y ese fue el momento superpower. Que crecer es más lindo cuando se hace desde lo auténtico, no desde lo impuesto.

🚀 Y recuerda…

Crecer no siempre es cómodo. A veces duele, a veces confunde, a veces cansa. Pero también libera, transforma y enciende.

Y en ese camino, no estás sola. Estamos floreciendo juntas, con espinas, colores, tierra y sol.

Gracias por leer. Gracias por crecer.

Con fuego, Roxs 🔥

Sí, leíste bien: AWS te paga el examen.
En este blog te cuento paso a paso cómo acceder a esta oportunidad, sumar puntos, y canjear tu voucher antes que se agoten.

🔥 Spoiler: si seguís bien los pasos, ¡vas a poder rendir tu certificación sin pagar ni un dólar!

🧾 ¿Qué vouchers están disponibles?

🔹 Foundational Level – 4,500 puntos

• AWS Certified Cloud Practitioner (CLF-C01)

• AWS Certified AI Practitioner
  📅 Válido hasta: 31 de Agosto de 2025

🔹 Associate Level – 5,200 puntos

• Solutions Architect

• Developer Associate

• SysOps Administrator

• Data Engineer

• Machine Learning Engineer
  📅 Válido hasta: 31 de Agosto de 2025

🌟 ¿Cómo obtengo mi voucher 100% GRATIS?

1️⃣ Crea tu cuenta en AWS Educate

Es la plataforma para estudiantes y profesionales que quieren formarse con contenido oficial de AWS.

2️⃣ Regístrate también en AWS Skill Builder

Usá el mismo email que en AWS Educate.

3️⃣ Completá un badge (por ejemplo, “Introduction to Cloud 101”)

Esto te habilita a entrar al Emerging Talent Community (ETC), la comunidad donde se acumulan puntos para canjear recompensas.

4️⃣ Sumá puntos completando contenido (videos, quizzes, artículos) en ETC

💎 Cada actividad suma puntos que se muestran con un ícono de gema.

5️⃣ Prepará tu examen con Skill Builder

Debés:

• Completar un curso de preparación (score mínimo: 70%)

• Rendir el badge assessment con un score de al menos 80%

6️⃣ ¡Canjeá tu voucher desde la sección “Rewards” en el ETC!

La revisión de la solicitud tarda hasta 3 días hábiles.

🧠 Tips clave para no perderte:

✅ Debés tener +18 años para acceder al ETC
✅ Usá el mismo email en todas las plataformas
✅ Repetí quizzes para subir tu puntaje
✅ Revisa el catálogo en Skill Builder buscando tu certificación
✅ ¡Visitá el ETC seguido! Hay contenido nuevo 6 veces por semana 😮

🔥 ¿Por qué deberías aprovechar esto?

• No todos los días podés certificarte en AWS sin pagar ni un centavo.

• Aumenta tu empleabilidad y salario potencial.

• Es una manera increíble de comenzar tu carrera en la nube.

📌 Enlaces útiles

➡️ AWS Educate
➡️ AWS Skill Builder
➡️ Emerging Talent Community FAQs

Resumen Final: ¿Qué necesito para reclamar mi voucher gratuito?

Para obtener tu voucher 100% free y certificarte en AWS, asegurate de cumplir con estos requisitos:

1. Completá un curso de preparación en AWS Skill Builder para la certificación que elegiste.

2. Aprobá un examen práctico (practice test o question set oficial) con al menos 70% de puntaje.

3. Usá el mismo correo electrónico en AWS Educate y AWS Skill Builder para evitar errores.

4. Reclamá tu voucher antes del 31 de agosto de 2025 — tu examen debe rendirse antes de esa fecha.

5. El equipo de AWS ETC validará que hayas cumplido los pasos, así que revisá bien tu progreso antes de solicitarlo.

6. Tené acceso al correo que usaste en AWS Educate — el voucher no se reenvía ni se reemplaza si se pierde.

🎯 ¡Y listo! Seguí estos pasos, reclamá tu voucher y presentá tu examen de certificación AWS…
¡totalmente GRATIS! 🚀

🚨 ¡Corre, que se agotan!

Esta es una oportunidad de oro para certificarte con uno de los líderes globales en la nube.
Aunque esta edición ya cerró, el programa ETC sigue activo y es una fuente constante de recompensas, vouchers y formación de primer nivel.

🗓️ Estate atento a futuras ediciones y preparate desde ya.

¿Querés más tips sobre certificaciones, DevOps, cloud y recursos gratuitos?
🔥 Seguime en LinkedIn: Roxs | 295DevOps

En este post, te mostraré cómo desplegar tu portafolio web localmente, sin complicaciones y en solo unos minutos, utilizando Vagrant, Nginx y sslip.io. Olvídate de las configuraciones interminables y empieza a trabajar de forma rápida y eficiente.

Arquitectura Local para Portafolio Web con Vagrant + Nginx

Descripción del flujo:

1. Vagrant gestionará la creación de la máquina virtual, con un entorno basado en Ubuntu.

2. Nginx servirá el portafolio web estático. Este se colocará en el directorio /var/www/portfolio y será accesible mediante el subdominio proporcionado por sslip.io (ej. 192.168.56.10.sslip.io).

3. El proceso de aprovisionamiento automatizado mediante Vagrant garantizará que el entorno de desarrollo se configure rápidamente.

El Portafolio web

Este portafolio DevOps está construido utilizando HTML5, CSS3 y JavaScript (vanilla), y está diseñado para mostrar tus habilidades en la implementación de un entorno de desarrollo local. Usando Vagrant, puedes levantar una máquina virtual que ejecuta Nginx para servir tu portafolio web estático de manera eficiente. Con sslip.io, asignas un dominio dinámico a tu entorno local. Este enfoque simplifica la configuración y te permite enfocarte en lo que realmente importa: ¡tu portafolio!

¿Qué es Nginx y cómo funciona?

Nginx es un servidor web de alto rendimiento que también puede funcionar como proxy inverso, balanceador de carga, servidor de correo y caché HTTP. Su arquitectura basada en eventos lo hace especialmente eficiente en el manejo de múltiples conexiones simultáneas, lo que lo convierte en una opción popular para servir aplicaciones web modernas.

Una de sus principales ventajas es su eficiencia al manejar tráfico concurrente. A diferencia de servidores tradicionales como Apache, Nginx usa un enfoque asincrónico para manejar las conexiones. Esto significa que, en lugar de abrir un nuevo hilo para cada solicitud, Nginx usa un solo hilo para manejar miles de conexiones, lo que mejora el rendimiento y la escalabilidad.

¿Qué es sslip.io?

sslip.io es un servicio gratuito que permite asignar un dominio dinámico a una dirección IP local. Esto es útil para desarrolladores que quieren exponer su entorno local a Internet sin tener que configurar un servidor DNS completo. Con sslip.io, simplemente añades una cadena de texto en tu dirección IP local (como .sslip.io) y el dominio se resuelve automáticamente a la dirección IP que especificas.

Además, sslip.io incluye certificados SSL válidos para cada subdominio generado, lo que te permite probar aplicaciones locales de forma segura sin tener que lidiar con certificados autofirmados. En resumen, sslip.io resuelve las direcciones locales de manera eficiente y segura, haciendo que el desarrollo sea mucho más rápido.

Estos servicios geniales resuelven automáticamente cualquier subdominio a la IP que especifiques:

# Ejemplos de resolución automática
192.168.1.100.sslip.io → 192.168.1.100
localhost.sslip.io → 127.0.0.1
10.0.0.5.nip.io → 10.0.0.5

Lo mejor: incluyen certificados SSL válidos sin configuración adicional.

Configurando el entorno con Vagrant

1. Instalar Vagrant y VirtualBox

• Vagrant:
  Vagrant es una herramienta para crear y gestionar máquinas virtuales. Para instalarla en este enlace

• VirtualBox:
  VirtualBox es un proveedor de máquinas virtuales compatible con Vagrant. Puedes instalarlo en este enlace

2. Verificar la instalación

Una vez instalados Vagrant y VirtualBox, puedes verificar que todo esté funcionando correctamente ejecutando:

vagrant --version

Deberías ver la versión instalada de Vagrant en la salida. Si también tienes VirtualBox instalado, puedes verificarlo ejecutando:

vboxmanage --version

3. Crear y configurar la máquina virtual

Ahora que tienes Vagrant y VirtualBox instalados, puedes crear y configurar tu máquina virtual para el portafolio web.

Configuración del Vagrantfile

Primero, creamos nuestro Vagrantfile:

# -*- mode: ruby -*-
# vi: set ft=ruby :

# 🚀 HTTP Local con sslip.io + Nginx + Vagrant
# 📝 Blog: Desarrollo local
# 🎯 Objetivo: Demostrar cómo usar sslip.io para HTTP local sin complicaciones
# 🔗 Acceso: http://192.168.56.10.sslip.io

Vagrant.configure("2") do |config|
  # 📦 Box base: Ubuntu 24.04 LTS compatible con mac soporta amd64/arm64
  config.vm.box = "bento/ubuntu-24.04"
  config.vm.box_check_update = true
  config.vm.hostname = "portafolio-ssl-local"

  # 🌐 Configuración de red
  # IP privada para acceso directo desde el host
  config.vm.network "private_network", ip: "192.168.56.10"
  config.vm.network "forwarded_port", guest: 80, host: 8080, 
    auto_correct: true, id: "http"

  # 💻 Configuración del proveedor VirtualBox
  config.vm.provider "virtualbox" do |vb|
    vb.name = "devops-local"
    vb.memory = "1024"  
    vb.cpus = 2
  end

  # 🚀 Aprovisionamiento principal
  config.vm.provision "shell", path: "provision.sh", privileged: true

  # 📋 Mensaje de bienvenida post-instalación
  config.vm.provision "shell", inline: <<-SHELL
    echo ""
    echo "🎉 ¡Configuración completada exitosamente!"
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo "💼 Portafolio Web disponible en:"
    echo "   🔗 http://192.168.56.10.sslip.io"
    echo ""
    echo ""
    echo "📝 HTTP Local con sslip.io"
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo ""
  SHELL
end

Script de aprovisionamiento

Creamos provision.sh para automatizar toda la configuración:

#!/bin/bash

# Simple Local Development with sslip.io + Nginx + Vagrant
# HTTP-only setup for fast and simple local development
# Objective: Deploy web portfolio with sslip.io domain (HTTP only)

set -euo pipefail  # Exit on any error

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Function to show progress
show_progress() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

# Function to show success
show_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

# Function to show warnings
show_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

# Function to show errors
show_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Welcome banner
echo -e "${GREEN}"
echo "=================================================================="
echo "                                                                  "
echo "          Simple Local Development with sslip.io                 "
echo "                                                                  "
echo "    HTTP + Nginx + Vagrant = Quick Development Setup             "
echo "                                                                  "
echo "=================================================================="
echo -e "${NC}"

# Verify if it's Ubuntu
if ! grep -q "Ubuntu" /etc/os-release; then
    show_error "This script is designed for Ubuntu. Exiting..."
    exit 1
fi

show_progress "Updating Ubuntu system"
export DEBIAN_FRONTEND=noninteractive
apt-get update -qq
show_success "System updated successfully"

show_progress "Installing essential dependencies"
apt-get install -y -qq \
    nginx \
    curl \
    wget \
    git \
    unzip \
    htop \
    tree \
    net-tools
show_success "Dependencies installed"

show_progress "Setting up web directory"
WEB_ROOT="/var/www/portfolio"
mkdir -p "$WEB_ROOT"
chown -R www-data:www-data "$WEB_ROOT"
chmod -R 755 "$WEB_ROOT"


# Descarga y descomprime el portafolio web desde GitHub
download_and_extract_portfolio() {
    local ZIP_URL="https://github.com/roxsross/devops-static-web/raw/portafolio-web/portafolio-web.zip"
    local TMP_ZIP="/tmp/portfolio.zip"

    show_progress "Descargando portafolio web desde GitHub..."
    if curl -L --fail -o "$TMP_ZIP" "$ZIP_URL"; then
        show_success "ZIP descargado correctamente."
        show_progress "Descomprimiendo portafolio en $WEB_ROOT..."
        if unzip -o "$TMP_ZIP" -d "$WEB_ROOT"; then
            show_success "Portafolio descomprimido en $WEB_ROOT."
            local SUBDIR=$(find "$WEB_ROOT" -mindepth 1 -maxdepth 1 -type d | head -n1)
            if [ -d "$SUBDIR" ] && [ "$SUBDIR" != "$WEB_ROOT" ]; then
                mv "$SUBDIR"/* "$WEB_ROOT"/
                rmdir "$SUBDIR"
            fi
        else
            show_error "Error al descomprimir el portafolio. Se dejará el directorio vacío."
            rm -rf "$WEB_ROOT"/*
        fi
        rm -f "$TMP_ZIP"
    else
        show_error "No se pudo descargar el portafolio. Se creará un index.html de emergencia."
        echo "<html><body><h1>Error: No se pudo descargar el portafolio web.</h1></body></html>" > "$WEB_ROOT/index.html"
    fi
}

download_and_extract_portfolio

chown -R www-data:www-data "$WEB_ROOT"
find "$WEB_ROOT" -type f -exec chmod 644 {} \;
find "$WEB_ROOT" -type d -exec chmod 755 {} \;

show_progress "Configuring Nginx"

cat > /etc/nginx/sites-available/portfolio << 'EOF'
server {
    listen 80;
    server_name *.sslip.io sslip.io *.192.168.56.10.sslip.io 192.168.56.10.sslip.io;

    root /var/www/portfolio;
    index index.html index.htm;

    # Basic security headers
    add_header X-Frame-Options DENY always;
    add_header X-Content-Type-Options nosniff always;
    add_header X-XSS-Protection "1; mode=block" always;

    # Gzip compression
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/javascript
        application/xml+rss
        application/json;

    location / {
        try_files $uri $uri/ =404;
    }

    # Static files caching
    location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff|woff2|ttf|svg)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    # Security
    location ~ /\. {
        deny all;
    }
}
EOF


ln -sf /etc/nginx/sites-available/portfolio /etc/nginx/sites-enabled/
rm -f /etc/nginx/sites-enabled/default


if nginx -t; then
    show_success "Nginx configuration is valid"
else
    show_error "Nginx configuration has errors"
    exit 1
fi


systemctl restart nginx
systemctl enable nginx

show_progress "Setting up firewall rules"
ufw allow 22/tcp
ufw allow 80/tcp
ufw --force enable

VM_IP="192.168.56.10"
SSLIP_DOMAIN="${VM_IP}.sslip.io"

show_progress "Verifying installation"

sleep 3

# Test HTTP
if curl -s -o /dev/null -w "%{http_code}" "http://${SSLIP_DOMAIN}" | grep -q "200"; then
    show_success "HTTP site is responding correctly"
else
    show_warning "HTTP site might not be responding correctly"
fi

echo ""
echo -e "${GREEN}"
echo "=================================================================="
echo "                                                                  "
echo "             🚀 DEPLOY LISTO! 🚀                                  "
echo "                                                                  "
echo "  🌐 Sitio de desarrollo simple listo                             "
echo "  🔗 HTTP + dominio sslip.io configurado                          "
echo "                                                                  "
echo "=================================================================="
echo -e "${NC}"

echo -e "${BLUE}"
echo "📋 Access Guide:"
echo ""
echo "🌐 Site URL: http://${SSLIP_DOMAIN}"
echo "📝 VM IP: $VM_IP"
echo "🔗 sslip.io domain: $SSLIP_DOMAIN"
echo ""
echo "💡 Features:"
echo "• Simple HTTP setup"
echo "• No SSL complexity"
echo "• sslip.io automatic domain mapping"
echo "• Ready for immediate development"
echo -e "${NC}"

show_success "Simple development environment ready!"

Ejemplo práctico: Desplegando el Portafolio

Para hacer esto más divertido, vamos a desplegar el portafolio devops

Desplegando el entorno

# Clonar o crear los archivos
mkdir vagrant-https-demo
cd vagrant-https-demo

# Crear archivos Vagrantfile y provision.sh
# (copiar contenido de arriba)

# Levantar la VM
vagrant up

# Verificar estado
vagrant status

Verificación y pruebas

Una vez desplegado, puedes probar:

# Desde tu máquina host - Acceder al juego
open http://192.168.56.10.sslip.io

Ventajas de este enfoque

Para DevOps:

• Infraestructura como código con Vagrant

• Aprovisionamiento automático repetible

• Entorno aislado que no afecta tu máquina

• Fácil destrucción y recreación (vagrant destroy && vagrant up)

Limpieza y comandos útiles

bash# Ver logs de Nginx
vagrant ssh -c "sudo tail -f /var/log/nginx/error.log"

# Reiniciar servicios
vagrant ssh -c "sudo systemctl restart nginx"

# Destruir entorno
vagrant destroy -f

Conclusión

Configurar un entorno de desarrollo local para tu portafolio web no tiene por qué ser complicado. Con Vagrant, Nginx y sslip.io, puedes levantar un servidor local funcional en cuestión de minutos, sin preocuparte por configuraciones complejas. Este flujo te permite concentrarte en lo que realmente importa: ¡tu proyecto!

Recuerda que la automatización y la reutilización de entornos es clave para mantener tu desarrollo ágil y eficiente. Con herramientas como Vagrant y Nginx, puedes replicar fácilmente tu configuración en cualquier máquina y compartir tu trabajo con otros sin problemas.

Si quieres seguir aprendiendo y profundizando en DevOps, te invito a unirte a mi Reto 90 Días de DevOps con Roxs, donde exploraremos aún más herramientas y prácticas que te ayudarán a llevar tus habilidades al siguiente nivel. ¡Nos vemos en el camino hacia un futuro DevOps más eficiente!

🤘 ¡Nos vemos en el próximo experimento DevOps!

Y esto no solo aplica en DevOps, sino en todos los desafíos que enfrentamos en la vida.

Hoy quiero contarte las lecciones más valiosas que aprendí durante este proceso, para que tu camino sea más claro, enfocado y, sobre todo, más eficaz. Aquí no te hablaré de atajos o fórmulas mágicas. Mi historia es sobre aprender de forma constante, con la mente abierta, y adaptarme en cada etapa del camino.

De Isla de Margarita a DevOps: Mi Camino Personal

Antes de ser “Roxs”, mi historia comenzó de una manera bastante diferente. Estudiaba Licenciatura en Informática en Isla de Margarita, Venezuela. Al principio, todo me parecía tan complejo que llegué a pensar que no era buena en eso, y me cuestioné muchas veces. La carrera me resultaba extremadamente difícil: la teoría, los profesores y los compañeros con sus grupitos, que nunca me integraban. Además, mi familia no tenía muchos recursos. Recuerdo que mi papá tuvo que vender algunas cosas para poder inscribirme en la universidad, lo que me hacía sentir aún más presionada. Mi situación económica era nada fácil y, sumado sentir que no pertenecía al mundo universitario, me sentía completamente perdida. A mitad de carrera, abandoné. Pensaba que era imposible para mí seguir en ese camino.

Pero la vida, como siempre, me dio una segunda oportunidad. En lugar de rendirme, comencé a trabajar en marketing digital y redes sociales, apoyando a periodistas cubriendo noticias en toda la Isla de Margarita, y fue ahí donde, casi sin darme cuenta, me acerqué a la automatización otra vez “Estaba buscando como mejorar y agilizar publicar fotos y noticias en las redes sociales.

Después de ese desvío, decidí volver a estudiar y seguir en este caso con Ingeniería en Sistemas, en universidad privada para poder estudiar a la noche, pero esta vez con una nueva visión, comencé hacer aplicaciones en el mismo trabajo en el que estaba y cada vez me sentía motivada, un paso a la vez.

Terminé mis estudios con un enfoque renovado, Roxs es Ingeniera en Sistemas

El gran giro en mi historia llegó cuando tomé la decisión de mudarme a Argentina. Un nuevo país, un nuevo comienzo, y otra vez, comenzar desde cero. Aunque esta parte de la historia tiene más detalles que compartir, te contaré más adelante.

En este nuevo capítulo, descubrí una aceleración tecnológica que no conocía. Había roles en tecnología que ni siquiera sabía que existían, y el único que conocía era el de desarrolladora... programar. Fue como si de repente, un iceberg de oportunidades se levantara ante mí, y decidí sumergirme de lleno en ese mar de nuevas posibilidades.

Mi primer trabajo en Argentina fue en una joyería, lo que me permitió ahorrar lo suficiente para comprar mi primera notebook. Recuerdo claramente la computadora usada que compré, y cómo, cada noche, surfeaba en aprender algo nuevo, sin roadmap, sin una guía clara. Solo me aferraba a la curiosidad y a la necesidad de darle una oportunidad a la tecnología.

Y, poco a poco, mi CV fue subiendo en los portales de empleo, hasta que me ofrecieron mi primera oportunidad como analista DevOps. ¡Ni siquiera sabía qué era exactamente ese rol! Pero dije que sí, me mudé a otra provincia a 1000 km, y aunque esa historia podría dar lugar a otro blog, lo más importante es que tomé la oportunidad. Fue un nuevo día cero, y a partir de allí mi vida en la tecnología despegó por completo.

Lecciones Aprendidas

Ahora, quiero compartirte las lecciones que me han permitido avanzar y que pueden ayudarte a recorrer un camino más sólido y efectivo en DevOps.

1. Comienza con lo Básico y Construye una Base Sólida

Uno de los mayores errores que cometí fue intentar abarcarlo todo desde el principio sin tener una base sólida. Aprender sobre herramientas como Docker o Kubernetes sin conocer los fundamentos de DevOps fue como intentar construir una casa sin cimientos. Durante mi pausa, me centré en los conceptos fundamentales de DevOps: control de versiones, integración continua, infraestructura como código. Comprender estos principios no solo me ayudó a entender las herramientas, sino que les dio un propósito real en mi camino.

Lección aprendida: Domina lo básico antes de sumergirte en las herramientas. Entender el “por qué” detrás de cada herramienta te proporciona una base sólida y hace que todo lo demás sea mucho más claro.

2. Las Certificaciones Son Buenas, Pero Solo Son El Comienzo

Creí que las certificaciones serían la clave para dominar DevOps, pero pronto descubrí que son solo una introducción. Son útiles para construir la confianza, pero no te enseñan a resolver problemas reales. Después entendí que el aprendizaje real viene con la práctica, trabajando en proyectos que te desafíen a aplicar lo que has aprendido en entornos reales.

Lección aprendida: Las certificaciones son valiosas, pero no te quedes ahí. El verdadero aprendizaje llega con la práctica. Los proyectos reales te enseñan a solucionar problemas y a mejorar tus habilidades.

3. El Síndrome del Impostor Es Normal y Se Puede Gestionar

Uno de los mayores obstáculos que enfrenté fue el síndrome del impostor. Pensaba que no era lo suficientemente buena, y ver a otros avanzar más rápido solo me hacía sentir que no tenía lo que se necesitaba. Aprendí que este síndrome es común en casi todos los que empiezan en un campo nuevo. Me di cuenta de que debía celebrar cada pequeño logro, y establecí metas pequeñas y alcanzables para mantenerme enfocada en el progreso.

Lección aprendida: El síndrome del impostor es normal, y todos lo enfrentamos en algún momento. Enfócate en pequeñas metas, celebra cada paso y sigue adelante. Cada paso cuenta.

4. La Práctica Real Es Clave para Consolidar Tus Habilidades

Una vez que entendí lo básico, me concentré en practicar. No solo quería saber cómo funcionaban las herramientas, sino verlas en acción. Trabajar en proyectos reales me dio la oportunidad de poner a prueba todo lo aprendido y, sobre todo, me permitió ganar confianza. Empecé con entornos de prueba y luego me lancé a proyectos más complejos. Ver los resultados tangibles de mis esfuerzos fue lo que realmente consolidó mis habilidades.

Lección aprendida: Practica desde el primer momento. La experiencia real es la que te dará la confianza necesaria para enfrentar desafíos más grandes.

5. Está Bien Pausar, Reiniciar y Priorizar

Tomarme un descanso a veces es necesario. Me permitió revaluar mi enfoque, bajar el ritmo y establecer prioridades claras. Si te sientes abrumado, no temas hacer una pausa. Usa ese tiempo para reorientarte, reflexionar y crear un plan que sea manejable. DevOps es un viaje largo, y es mejor avanzar a un ritmo que te mantenga motivado y comprometido.

Lección final: Pausar no significa rendirse. Es un paso para prepararte para el éxito. Aprovecha el tiempo para reflexionar, reorganizar y continuar con un enfoque renovado.

Si estás empezando en DevOps, mi consejo es este: empieza poco a poco, domina lo básico y no te agobies por saberlo todo al principio. La práctica real y un ritmo más lento te permitirán asimilar más de lo que imaginas. Cuando te sientas abrumado, tómate un paso atrás. ¡Recuerda que cada paso cuenta en este camino hacia el éxito!

Si pude hacerlo, ¡tú también puedes! Recuerda siempre que el día cero es solo el comienzo, pero si persistes, cada paso te llevará más cerca de tus metas. 💪🚀

90 Días de DevOps con Roxs: ¡Únete al Desafío!

Si te apasiona DevOps y quieres dar ese primer paso con una guía clara, te invito a unirte a mi programa 90 Días de DevOps con Roxs. ¡Es completamente gratis! En este desafío, recorreremos juntos el camino de aprender, practicar y crecer en DevOps. Te acompañaré en cada etapa para que logres los conocimientos y habilidades necesarias para ser un profesional competente en el campo.

Si quieres seguir aprendiendo y apoyarme en la creación de más contenido gratuito, puedes hacerlo en mi perfil de Ko-fi. Tu apoyo me permitirá seguir ofreciendo material valioso para la comunidad.

Visita roxs.295devops.com para más información sobre el desafío y mis redes sociales.

¡Nos vemos en el desafío! 💥🔥

Desde el primer día que decidí sumergirme en el mundo de la tecnología, nunca imaginé lo que significaría para mí. Con cada desafío superado, descubrí que el fuego dentro de mí nunca se apagaba. Y ahora, quiero que ese mismo fuego arda en ti. Porque si algo tengo claro, es que cuando decides dar el primer paso, el camino se abre ante ti

1. Dar el Primer Paso No Es Fácil, Pero Ese Paso Te Define

El mundo de DevOps y Cloud puede parecer un gigante abrumador al principio. La sensación de no saber por dónde empezar es real. Pero quiero que sepas algo: el primer paso es lo más difícil, pero también es el que más te impulsa. Cuando lo des, cuando empieces a aprender, a probar herramientas, a experimentar con contenedores, ahí es cuando el fuego comienza a encenderse.

Sé que no es fácil, pero el primer paso te cambia. A partir de ese momento, ya no hay vuelta atrás. Cada pequeña victoria, cada línea de código que aprendas, cada vez que consigas algo que no sabías que podías hacer, será un paso más en tu viaje.

2. Fracasos, ¿Una Trampa o Una Oportunidad?

¡Déjame decirte algo! Los fracasos no son el fin del mundo, son el combustible que enciende tu motor. Si caíste, si algo no funcionó, si el contenedor no se levantó como esperabas… ¡no te preocupes! Es solo una oportunidad de aprender, de mejorar.

En DevOps y Cloud, el error es una herramienta poderosa. Cada error significa que estás un paso más cerca de dominarlo. Fallar rápido, aprender rápido. Y lo más importante, no te rindas. Cada paso hacia adelante es un triunfo, y aunque no lo creas, cuando te levantes de nuevo, tu fuego será aún más fuerte.

3. Sigue Aprendiendo, Porque El Fuego Nunca Se Apaga

En DevOps, la curva de aprendizaje es infinita, pero eso es lo que la hace tan excitante. ¡Hay tanto por aprender! Desde Kubernetes, hasta Docker, AWS, y mucho más. La clave está en seguir avanzando. Si hoy no entiendes algo, ¡mañana lo harás! La tecnología avanza, y tú con ella.

No importa lo que te enfrentes, el fuego de aprender es lo que te hará imparable. Cada nuevo conocimiento es una chispa que avivará tu pasión, y esa pasión te llevará a hacer cosas increíbles. Nunca dejes de aprender, nunca dejes de arder.

4. Nunca Estás Solo: La Comunidad es Tu Mayor Fuerza

Una de las cosas más increíbles de este mundo es la comunidad. Aquí, nadie se queda atrás. No tengas miedo de pedir ayuda, de conectarte con otros, de compartir tus dudas. La comunidad tecnológica está llena de personas dispuestas a levantarte cuando lo necesites.

Cuando estés en esos momentos difíciles, donde parece que todo está en contra, recuerda que puedes contar con los demás. ¡Aquí estamos para apoyarnos y crecer juntos! Si algo he aprendido en mi camino es que las conexiones y los lazos que creas son lo que realmente marca la diferencia.

5. Construye Tu Red, Porque Juntos Somos Más Fuertes

Tu red de contactos es oro puro. No se trata solo de LinkedIn, se trata de las conexiones reales, de esas personas que te inspiran, te motivan y te ayudan a ser mejor cada día. Asiste a eventos, participa en meetups, únete a grupos online. Cada persona que cruza tu camino puede ser un mentor, una fuente de motivación, o incluso un aliado para el futuro.

El poder de tu red está en la colaboración. Así que, nunca subestimes el impacto de las personas que conoces en tu camino. Juntos, ¡podemos conquistar todo lo que se nos ponga enfrente!

6. Descanso, Recarga, ¡Y Vuelve Con Más Fuerza!

No olvides algo fundamental: también está bien descansar. A veces, lo mejor que puedes hacer por tu aprendizaje es alejarte un poco. Sal a caminar, haz ejercicio, desconéctate de la pantalla, ¡y cuando regreses, vuelve con el doble de energía! 🚀

Los descansos no son una debilidad, son una estrategia para regresar más fuerte y más enfocado. Así que, recarga tu fuego, y sigue con más ganas que nunca.

7. Celebra Cada Logro, ¡Porque Tienes Fuego! 🔥

Recuerda siempre celebrar tus logros, por pequeños que sean. Cada paso que des es una victoria. Hoy aprendiste a configurar un contenedor, mañana has desplegado tu primera aplicación en la nube, y pasado mañana automatizas tu primer pipeline CI/CD. Cada logro suma, y es parte de tu historia de fuego.

Como dice Roxs, cada victoria te acerca más a ser imparable. ¡Celebra con fuerza, celebra con pasión, porque el fuego está en vos!

Y Por Eso Nació "90 Días de DevOps con Roxs" 🔥

Este camino puede ser solitario a veces, pero no tiene que serlo. Por eso nació "90 Días de DevOps con Roxs", un desafío práctico en DevOps, donde todos vamos codo a codo, aprendiendo y creciendo juntos. Este reto es una oportunidad única para dar ese primer paso, enfrentar los desafíos y avanzar en la práctica. Aquí, te voy a acompañar en cada etapa para que ese fuego nunca se apague.

Si aún no te has unido, aún estás a tiempo, siempre que tengas la fuerza y la determinación. 💪 Juntos vamos a acelerar ese aprendizaje, a convertir cada dificultad en un impulso, y a asegurarnos de que, cuando llegues a la meta, no solo hayas aprendido, sino que hayas transformado todo tu ser en un devops on fire. 🔥🔥🔥

Revisa mi página con todos los enlaces https://roxs.295devops.com/ y no te pierdas ninguna de las oportunidades que tengo para ti. Además, te invito a que te suscribas a mi canal de YouTube aquí donde subo contenido exclusivo para que sigas aprendiendo con nosotros.

Antes de mis Reflexiones Finales: Mi Historia

Quiero compartir una imagen de quién era yo antes de entrar 100% en la tecnología. Esa era yo antes de tener rumbo, sin fuego ni objetivos claros, viviendo entre un sueldo y sin sueños, sin saber qué hacer con mi vida. No sabía qué era el fuego, pero con esfuerzo y determinación, me levanté.

Hoy, estoy aquí para demostrar que todos podemos empezar de cero. Mi historia la contaré en otro post, pero lo que quiero que te lleves hoy es que el fuego se enciende cuando decides dar ese primer paso. Si yo pude, ¡tú también puedes!

Reflexiones Finales

Roxs te dice: El primer paso es solo el principio. ¡Este viaje va a ser increíble, y el fuego que llevas dentro es todo lo que necesitas! Así que no te detengas, no te rindas, y sigue aprendiendo, creciendo, y sobre todo, mantén ese fuego ardiendo.

Hoy comenzaste este viaje, y mañana serás el que inspire a otros a dar su primer paso. Porque cuando tienes el fuego de Roxs en ti, no hay límites.

¡Vamos con todo! ¡El futuro es tuyo, y el fuego nunca se apaga! 🔥🔥🔥

Pero, en medio de todo eso, hay algo que no puede quitártelo nadie: tu decisión.

✨ ¿Qué es el éxito? ¿Y quién lo define?

La sociedad nos vende que ser exitoso es tener plata, fama o un puesto con título rimbombante. Pero vos y yo sabemos que eso no es todo. Para mí, y para muchas personas que conozco en comunidad, el éxito puede ser cosas como:

• Terminar el deploy que te venía fallando hace días.

• Animarte a levantar la mano en una daily.

• Compartir tu primer blog o crear tu primer repo público.

• O simplemente seguir adelante, aún cuando sentís que el mundo se te viene encima.

Cada quien tiene su propia definición de éxito, y está bien. Lo importante es que la definas vos.

💪 La receta secreta no es tan secreta: espíritu indomable

Sí, hay factores que ayudan: tener tiempo, apoyo, acceso a tecnología, buenos mentores. Pero lo que realmente te hace seguir cuando todo tiembla es ese fuego interno, ese “no me rindo”, ese mindset de superación constante que decidís renovar todos los días.

Lo llamo espíritu indomable.

Ese fuego que te hace:

🔥 Volver a intentar después de un error.

🔥 Estudiar de madrugada aunque estés cansado.

🔥 Creer en vos cuando nadie más lo hace.

Y no es magia. Es una elección diaria. Elegís seguir. Elegís crecer. Elegís mejorar. Elegís ser tu propia versión del éxito.

🧠 Grit, foco y vulnerabilidad

El éxito real no es lineal ni glamoroso. Es ensayo y error. Es llorar frente a la compu y volver al rato con más fuerza. Es aprender a decir “no sé”, buscar ayuda, compartir lo que sabés y apoyar a otros en su camino.

No se trata solo de talento o inteligencia. Se trata de grit: esa mezcla de pasión + perseverancia + resistencia que te mantiene en el camino, incluso cuando se vuelve cuesta arriba.

🌎 Vos podés redefinir el sistema (aunque el sistema no sea justo)

¿La igualdad de oportunidades es real? No del todo. Pero eso no significa que nos tengamos que resignar.

Desde nuestros espacios ya sea una comunidad tech, un bootcamp, una empresa o un canal de YouTube podemos construir un entorno más justo, más inclusivo y con menos barreras. Donde no importe de dónde venís, sino las ganas que tenés de llegar.

Yo lo vivo todos los días en la comunidad de 90 Días de DevOps con Roxs: hay gente que viene de diseño, de marketing, de cocina, de mil lados. Y todos crecen. Porque el primer paso fue elegir intentar.

💥 Conclusión: El éxito no es destino, es camino

Elegí tu definición. Caminá tu trayecto. Rodeate de gente que encienda tu fuego.

Y nunca olvides esto:

“Éxito no es tener más que otros, es tener más de vos mismo que ayer.”

🌟 El éxito no te llega por suerte. El éxito se construye. El éxito, como el crecimiento, es una elección diaria.

¿Y vos? ¿Hoy qué elegís?

🔗 Seguime y sumate al fuego

📚 Todo mi contenido, comunidad y redes:
👉 https://roxs.295devops.com

🎥 Canal de YouTube con clases, desafíos y comunidad ON FIRE:
👉 https://www.youtube.com/@295devops

👾 ¿Querés aprender DevOps desde cero? Unite al reto 90 Días de DevOps con Roxs

🔥 ¡Te espero con fuego y superpower para que despleguemos juntxs!

📦 Pre-requisitos técnicos

Para correr este laboratorio necesitás:

🔹 Docker Desktop instalado y corriendo
🔹 Docker Compose v2.34 o superior * ya viene incluido en el docker desktop
🔹 Make (opcional, pero súper útil)
🔹 Sistema operativo: Linux, macOS o Windows con WSL2
🔹 Al menos 4 GB de RAM (recomendado 8 GB)
🔹 Mínimo 5 GB libres en disco
🔹 Conexión a internet para descargar imágenes la primera vez

Verificá si ya tenés todo listo:

docker version
Client:
 Version:           28.0.4
 API version:       1.48
 Go version:        go1.23.7
 Git commit:        b8034c0
 Built:             Tue Mar 25 15:06:09 2025
 OS/Arch:           darwin/arm64
 Context:           desktop-linux

docker compose version

Docker Compose version v2.34.0-desktop.1

make --version # (opcional)

💡 Si estás en Windows, asegurate de tener WSL2 activado y Docker corriendo correctamente.

Podes completar el setup con mi blog anterior https://blog.295devops.com/crea-tu-laboratorio-devops-local-sin-gastar-un-peso

🎯 ¿Qué vas a encontrar en este proyecto?

La idea es que puedas aprender y practicar DevOps sin vueltas. El stack incluye:

• Frontend con Nginx y HTML/CSS/JS vanilla

• Backend con FastAPI y PostgreSQL

• Docker y Docker Compose para orquestar todo

• Prometheus + Grafana para monitoreo real

• Node Exporter para métricas de sistema

• Un Makefile lleno de comandos útiles

• Dashboards visuales listos para usar

💡 Ideal para quienes quieren aprender DevOps desde cero o armar su propio laboratorio para practicar CI/CD, monitoreo, troubleshooting y más.

🧱 Arquitectura simple pero poderosa

Todo esto conectado por redes Docker personalizadas (roxs-devops-network y roxs-monitoring-network), con métricas expuestas en /metrics y monitoreo en tiempo real de toda la aplicación. ¡Literalmente podés ver cuántas requests hacés y cómo responde tu app! 🔍📈

🧪 ¿Cómo lo usás?

1. Clonás el repo:

git clone https://github.com/roxsross/roxs-devops-stack
cd roxs-devops-stack
make install
make all

2. Accedé a los servicios:

🎮 ¿Qué podés hacer?

• Crear, listar, editar y borrar ítems desde el frontend

• Ver métricas como requests, latencia, uptime

• Ver dashboards en Grafana con performance y estado de todos los servicios

• Inspeccionar logs del backend

• Ver el estado de salud de cada contenedor

• Probar los endpoints con curl o Swagger UI

📊 El toque DevOps: métrica, logging y dashboards

Este no es solo un “todo corre en Docker”, sino que incluye un sistema de monitoreo funcional, con:

• Dashboards listos en Grafana

• Métricas de performance de la API

• Estado de la base de datos

• Logs estructurados del backend

• Health checks, latencia y uptimes

🎯 ¡Ideal para aprender Prometheus y Grafana sin pelearte con configuraciones!

🛠️ ¿Qué aprendés armándolo?

• Cómo dockerizar backend y frontend

• Cómo conectar servicios con redes personalizadas

• Cómo exponer y recolectar métricas con Prometheus

• Cómo visualizar todo con Grafana

• Cómo automatizar con Makefile

• Troubleshooting real con logs y health checks

📸 Screenshots by ROXS

Revisa en: https://github.com/roxsross/roxs-devops-stack

🧪 Casos de uso recomendados

• 🔍 Simular caídas y ver alertas en Prometheus/Grafana

• 🧩 Practicar debugging usando métricas y logs

• 📈 Agregar nuevas métricas personalizadas a FastAPI

• 🔐 Experimentar con escaneos de seguridad (Próximo paso del roadmap)

• 📦 Crear tu pipeline CI/CD con GitHub Actions usando este stack como base

📊 Detrás del monitoreo

La app expone métricas en /metrics usando Prometheus client for Python. Entre las métricas disponibles:

Todo esto es recolectado por Prometheus, y luego Grafana lo grafica automáticamente. Ya incluye dashboards preconfigurados.

🧰 Makefile: tu asistente DevOps

El Makefile te ahorra escribir comandos largos. Algunos highlights:

make up                # Levanta la app
make down              # La detiene
make monitoring        # Solo Prometheus + Grafana
make logs              # Ver logs en tiempo real
make health            # Chequeo de salud de servicios
make urls              # Muestra todas las URLs

⚙️ ¿Y si no quiero usar make?

Sin drama. Todos los comandos del Makefile también se pueden ejecutar manualmente con Docker Compose. Acá te dejo los pasos:

🔧 Levantar la aplicación sin make

# 1. Cloná el repo
git clone https://github.com/roxsross/roxs-devops-stack
cd roxs-devops-stack

# 2. Levantar la aplicación principal
docker compose -f docker-compose.yml up -d

# 3. Levantar el stack de monitoreo
docker compose -f docker-compose.monitoring.yml up -d

📊 Acceder a los servicios

🔍 Ver logs

docker compose logs -f
docker compose -f docker-compose.monitoring.yml logs -f

💡 Consejo: si no usás make, podés revisar el archivo Makefile para ver todos los comandos disponibles y adaptarlos a tu estilo.

💡 ¿Cómo personalizar este stack?

Algunas ideas para que lo hagas tuyo:

• Cambiá la base de datos a MySQL o MongoDB

• Usá React o Vue como frontend (sirve igual con Nginx)

• Agregá tu propio microservicio

• Sumá alertas reales con Alertmanager

• Añadí un Dockerfile para testing o CI

🧠 ¿Querés probarlo?

👉 https://github.com/roxsross/roxs-devops-stack

Dale una estrella ⭐ si te gusta, y escribime si querés sumarte a contribuir o tenés ideas.

🔮 ¿Qué sigue?

Este es solo el comienzo. En el roadmap tengo pensado:

• CI/CD completo con GitHub Actions

• Deploy en Kubernetes con Helm y ArgoCD

• Configuración de Terraform para IaC

• Integración con herramientas de seguridad

• Test de performance y Chaos Engineering

¡Y todo lo vas a poder practicar con este stack base! 💥

🎓 Bonus: se viene "90 Días de DevOps by Roxs" 🚀

¿Querés aprender DevOps en serio, acompañado/a, y con práctica real?

🧑‍💻 Estoy lanzando una experiencia gratuita llamada 90 Días de DevOps by Roxs, con:

• 🔁 Encuentros semanales ó quincenales (según cómo avancemos)

• 📦 Proyectos reales como el roxs-devops-stack

• 💬 Comunidad privada para dudas, feedback y networking

• 📈 Desafíos técnicos, guías y tips de carrera

• 🤝 Totalmente GRATIS (solo cupo limitado)

🎯 Solo para las primeras 200 personas

👉 ¿Querés participar?

📩 Completá este formulario de interés o escribime por redes y te mando el acceso cuando abramos inscripciones.

¡Va a ser una aventura intensa, práctica y transformadora!

✉️ Contacto

• 🐦 Twitter: @roxsross

• 🔗 LinkedIn: roxsross

• ▶️ Youtube: 295devops

• 💌 Email: roxs@295devops.com

🤘 ¡Nos vemos en el próximo experimento DevOps!

A Sofía, como a muchos que están aprendiendo DevOps, le pasaba lo siguiente: leía sobre CI/CD, containers, automatización… pero al momento de practicar, todo requería usar AWS, Azure o GCP.

“Registrate en el nivel gratuito,” decían todos los tutoriales. Pero ella sabía que esos "free tiers" tienen límites, y había leído historias de terror donde el descuido de dejar un recurso encendido se traducía en una factura de cientos de dólares.

Sofía pensó: “¿Y si armo todo local, sin depender del cloud?” Y así fue como descubrió el poder de un laboratorio DevOps en su laptop/notebook/pc.

🛠️ DevOps explicado sencillo

DevOps es colaboración. Imaginá que estás construyendo una casa: los desarrolladores serían los arquitectos, y el equipo de operaciones, los albañiles. En modelos tradicionales, estos equipos apenas se hablan. DevOps propone que trabajen codo a codo desde el día uno. Así se entregan soluciones más rápidas, estables y de mejor calidad.

Herramientas claves que vas a usar:

• Docker: Contenedores que empacan tu app con todo lo necesario para correr.

• Kubernetes: Orquestador que gestiona múltiples contenedores.

• Vagrant: Te permite levantar máquinas virtuales de forma fácil.

• Ansible: Automatiza tareas repetitivas como configurar servidores.

• Terraform: Infraestructura como código: define entornos con archivos .tf.

🚀 Ventajas de montar tu laboratorio local

• 💸 Costo cero: sin facturas sorpresa.

• ✈️ Offline-friendly: perfecto para aprender incluso sin conexión.

• 🔒 Seguro: todo queda en tu máquina.

• 🧠 Aprendizaje profundo: rompes, arreglas, entendés.

• ⚡ Velocidad: sin esperar a que cargue nada en la nube.

• 🧪 Control total: podés experimentar sin miedo.

🧰 Requisitos para armar tu laboratorio

• 💻 Laptop con mínimo 8 GB de RAM (16 GB recomendado).

• 📂 Al menos 20 GB de espacio libre.

• 🖥️ Windows, macOS o Linux.

• 👑 Acceso administrador.

• 🧬 Virtualización activada en BIOS.

• 🕒 Unas horas de tu tiempo.

🧱 Paso 1: Instalar Docker, tu parque de contenedores

Para Windows

1. Activá la virtualización en la BIOS.

2. Descargá Docker Desktop.

3. Durante la instalación, habilitá WSL2.

4. Reiniciá y abrí Docker Desktop. Esperá que la ballenita deje de moverse.

Para Mac

1. Descargá el .dmg desde el sitio de Docker.

2. Instalalo en “Aplicaciones”.

3. Abrilo y esperá que el ícono de la barra esté listo.

Para Linux (Ubuntu):

Como podemos instalarlo en Linux

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install docker-ce
sudo usermod -aG docker $USER

Salí y volvé a iniciar sesión para que los permisos se apliquen.

Verificá que Docker funciona:

docker run hello-world

Deberías ver un mensaje de “Hello from Docker!”

🎻 Paso 2: Kubernetes – Tu orquesta de contenedores

Opción A: Minikube – Ideal para principiantes

Minikube levanta un cluster Kubernetes de un solo nodo en tu compu.

Instalación en Windows

1. Descargá el instalador desde Minikube Releases.

2. Ejecutalo.

3. Abrí CMD como administrador y corré:

minikube start --driver=docker

En macOS (con Homebrew)

brew install minikube
minikube start --driver=docker

En Linux:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube-linux-amd64
sudo mv minikube-linux-amd64 /usr/local/bin/minikube
minikube start --driver=docker

Probalo:

minikube status
minikube dashboard

Opción B: Kind – Kubernetes más liviano, corre dentro de Docker

Sobre Kind

Instalación universal:

curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-$(uname)-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

Crear un cluster:

kind create cluster --name devops-lab

🕹️ Paso 3: kubectl – Tu control remoto de Kubernetes

Instalación:

• Windows: choco install kubernetes-cli

• macOS: brew install kubectl

• Linux:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/kubectl

Verificá que funcione:

kubectl get pods --all-namespaces

🧳 Paso 4: Vagrant – Gestioná tus máquinas virtuales

Requisitos:

• VirtualBox

• Vagrant

Instalación en cualquier sistema:

1. Descargá VirtualBox

2. Descargá Vagrant

3. Verificá:

vboxmanage --version
vagrant --version

Crear tu primera VM:

mkdir mi_lab && cd mi_lab
vagrant init ubuntu/focal64
vagrant up
vagrant ssh

Listo, ¡tenés Ubuntu corriendo!

Listado de Boxes

(Opcional) Crear un Vagrant Boxes personalizada a partir de ISO

1. Descargar ISO de Ubuntu :

• Vaya a https://ubuntu.com/download/desktop (o servidor)

• Elija Ubuntu 24.04.2 LTS y guarde el archivo .iso localmente

2. Instalar Ubuntu en VirtualBox :

• Abrir VirtualBox → Nuevo → Nombre: ubuntu-devops → Tipo: Linux → Versión: Ubuntu (64 bits)

• Asignar 2048 MB de RAM, 20 GB de disco duro (VDI)

• En Almacenamiento, adjunte el .iso descargado en Unidad óptica

• Inicie la máquina virtual y complete la instalación de Ubuntu (cree usuario, establezca contraseña)

3. Empaquetar la máquina virtual como Vagrant Boxes :

 VBoxManage list vms   
# Paquete
 vagrant package -- base  "ubuntu-devops" --output ubuntu2404.box   
# Agregar a Vagrant  
 vagrant box add ubuntu2404 ubuntu2404.box

Ahora tienes Ubuntu 2404 como equipo local, sin necesidad de Internet

🤖 Paso 5: Ansible – Automatización sin drama

macOS:

brew install ansible

Linux (Ubuntu):

sudo apt update
sudo apt install software-properties-common
sudo apt-add-repository --yes --update ppa:ansible/ansible
sudo apt install ansible

Windows:

Usá Ubuntu vía WSL. Luego instalás Ansible como en Linux.

Probar Ansible:

1. Archivo hosts:

[local]
localhost ansible_connection=local

2. playbook.yml:

---
- name: Prueba de Ansible
  hosts: local
  tasks:
    - name: Mostrar mensaje
      debug:
        msg: "¡Ansible funciona!"

3. Ejecutá:

ansible-playbook -i hosts playbook.yml

✨ Paso 6: Terraform – Tu varita mágica de Infraestructura

Instalación:

• Windows: choco install terraform

• macOS: brew install terraform

• Linux:

wget https://releases.hashicorp.com/terraform/1.6.0/terraform_1.6.0_linux_amd64.zip
unzip terraform_1.6.0_linux_amd64.zip
sudo mv terraform /usr/local/bin/

Probar Terraform:

Archivo main.tf:

resource "local_file" "demo" {
  content  = "¡Hola desde Terraform!"
  filename = "${path.module}/saludo.txt"
}

terraform init
terraform apply

Chequeá que exista el archivo saludo.txt.

🧩 Tu Primer Proyecto DevOps Local Integrado

Ya tenés Docker, Kubernetes, Vagrant, Ansible y Terraform instalados. Ahora, vamos a combinar todo en un proyecto real que simula una infraestructura DevOps básica. Esto te va a servir para aprender CI/CD, gestión de infraestructura y automatización de una manera 100% práctica.

🎯 Objetivo del Proyecto

Crear una arquitectura de dos niveles (web + base de datos), usando:

• Terraform para generar archivos de configuración.

• Vagrant para levantar las máquinas virtuales.

• Ansible para configurar los servidores.

• Docker para desplegar la app.

• Kubernetes (opcional para más adelante).

🗂️ Estructura de Archivos

Crea una carpeta llamada devops-lab-proyecto con estos archivos:

devops-lab-proyecto/
├── Vagrantfile (generado por Terraform)
├── inventory (Ansible hosts)
├── playbook.yml (Ansible playbook)
└── main.tf (Terraform config)

🧙‍♂️ Terraform – Generación de configuración

Archivo main.tf:

resource "local_file" "vagrant_file" {
  content = <<-EOT
    Vagrant.configure("2") do |config|
      config.vm.box = "bento/ubuntu-22.04"

      config.vm.define "web" do |web|
        web.vm.network "private_network", ip: "192.168.33.10"
        web.vm.network "forwarded_port", guest: 80, host: 8080
      end

      config.vm.define "db" do |db|
        db.vm.network "private_network", ip: "192.168.33.11"
      end
    end
  EOT
  filename = "${path.module}/Vagrantfile"
}

resource "local_file" "inventory_file" {
  content = <<-EOT
    [webservers]
    192.168.33.10 ansible_user=vagrant ansible_ssh_private_key_file=.vagrant/machines/web/virtualbox/private_key

    [dbservers]
    192.168.33.11 ansible_user=vagrant ansible_ssh_private_key_file=.vagrant/machines/db/virtualbox/private_key
  EOT
  filename = "${path.module}/inventory"
}

resource "local_file" "playbook_file" {
  content = <<-EOT
    ---
    - name: Configurar servidor web
      hosts: webservers
      become: yes
      tasks:
        - name: Instalar Docker
          apt:
            name: docker.io
            state: present
            update_cache: yes

        - name: Agregar usuario al grupo docker
          user:
            name: "{{ ansible_user }}"
            groups: docker
            append: yes

        - name: Iniciar y habilitar servicio Docker
          systemd:
            name: docker
            state: started
            enabled: yes
            daemon_reload: yes

        - name: Desplegar contenedor Nginx
          docker_container:
            name: webapp
            image: nginx
            ports:
              - "80:80"
            restart_policy: always

    - name: Configurar base de datos
      hosts: dbservers
      become: yes
      tasks:
        - name: Instalar MariaDB
          apt:
            name: mariadb-server
            state: present
            update_cache: yes

        - name: Iniciar servicio MariaDB
          service:
            name: mariadb
            state: started
            enabled: yes
  EOT
  filename = "${path.module}/playbook.yml"
}

⚙️ Ejecutá los pasos

1. Inicializar Terraform y generar los archivos

terraform init
terraform apply

2. Levantar las VMs con Vagrant

vagrant up

3. Aplicar la configuración con Ansible

ansible-playbook -i inventory playbook.yml

4. Abrir la app web

Navegá a http://localhost:8080 y deberías ver la página por defecto de Nginx.

5. Tambien podes probar las maquinas virtuales con vagrant

vagrant ssh web
vagrant ssh db

5. Destruir cuando termines

vagrant destroy -f
terraform destroy

🧪 Bonus: No quiero usar Vagrant, alguna opción? pues si.

El crack de James Spurin tiene un repo re-copado https://github.com/spurin/diveintoansible-lab

con docker-compose podes levantar algunas maquinas

Si te gusta lo que viste de Ansible te recomiendo este repo https://github.com/spurin/diveintoansible-lab

services:
  ubuntu-c:
    hostname: ubuntu-c
    container_name: ubuntu-c
    image: spurin/diveintoansible:ansible
    ports: 
     - ${UBUNTUC_PORT_SSHD}:22
     - ${UBUNTUC_PORT_TTYD}:7681
    privileged: true
    volumes:
     - ${CONFIG}:/config
     - ${ANSIBLE_HOME}/shared:/shared
     - ${ANSIBLE_HOME}/ubuntu-c/ansible:/home/ansible
     - ${ANSIBLE_HOME}/ubuntu-c/root:/root
    networks:
     - diveinto.io

  ubuntu1:
    hostname: ubuntu1
    container_name: ubuntu1
    image: spurin/diveintoansible:ubuntu
    ports: 
     - ${UBUNTU1_PORT_SSHD}:22
     - ${UBUNTU1_PORT_TTYD}:7681
    privileged: true
    volumes:
     - ${CONFIG}:/config
     - ${ANSIBLE_HOME}/shared:/shared
     - ${ANSIBLE_HOME}/ubuntu1/ansible:/home/ansible
     - ${ANSIBLE_HOME}/ubuntu1/root:/root
    networks:
     - diveinto.io

  ....

🧪 Bonus: ¿Y si lo paso a Kubernetes?

En una siguiente etapa podés:

• Empaquetar tu app como una imagen personalizada de Docker.

• Crear archivos deployment.yaml y service.yaml.

• Usar kubectl apply -f para desplegar en Minikube o Kind.

🧭 Conclusión: ¡Tu laboratorio DevOps está ON FIRE!

Lograste lo que muchos solo sueñan: un entorno completo para aprender DevOps desde tu compu, sin gastar ni un peso y entendiendo cada capa del proceso.

🌟 Ya tenés:

• Infraestructura local

• Automatización

• Contenedores

• Entendimiento real del stack

¿Quién no ha caído en la trampa? Es tan seductora como un amigo que te dice: "¡No te preocupes! Yo te apoyo en todo", solo para luego dejarte en la estacada cuando más lo necesitas.

Aunque la etiqueta :latest puede parecer inofensiva y útil, en realidad es un desastre esperando a suceder. En este artículo, te contaré por qué deberías dejar de usarla y cómo evitar que se convierta en tu peor pesadilla.

¿Qué es la etiqueta :latest y por qué es peligrosa?

Primero, aclaramos el concepto. La etiqueta :latest no significa "última versión". ¡Sorpresa! En realidad, significa "la imagen que se etiquetó como latest más recientemente". Esto no es lo mismo que tener siempre el código más actualizado, y es aquí donde comienza el lío.

La etiqueta :latest puede ser etiquetada sobre una imagen con código de hace seis meses, o incluso un código con errores. ¿La peor parte? Docker no tiene forma de saber si realmente es la versión más reciente de tu código. Solo se basa en la última imagen que recibió la etiqueta. Así que, si alguien se equivocó y subió una versión errónea, esa será la que se ejecute en producción.

Historias de no son on-fire, pero con mucho thriller a lo Michael Jackson con la etiqueta :latest

Para que entiendas mejor el peligro de usar :latest, déjame contarte unas historias de terror sobre cómo esta etiqueta ha arruinado despliegues, ha hecho desaparecer aplicaciones y ha dejado a equipos de desarrollo luchando por encontrar el problema.

1. Kubernetes se vuelve loco

Tu equipo de desarrollo despliega un Helm chart con la imagen roxsross:latest. Todo va bien en staging, pero cuando se lleva a producción, todo explota. Los pods se caen, y tu aplicación no funciona. ¿Por qué?

Porque alguien más subió una versión diferente de roxsross:latest desde su notebook/laptop. Aunque la etiqueta es la misma, el código es diferente. Kubernetes descarga la imagen incorrecta, y el despliegue se arruina. El resultado: la versión que funcionaba en staging ahora no sirve en producción.

2. CI/CD se convierte en un juego de azar

Imagina que tienes una pipeline de GitHub Actions que construye app-roxsops:latest. Las pruebas pasan, todo parece perfecto. Pero horas después, otro pipeline se ejecuta, esperando que :latest sea lo mismo, pero un nuevo commit ha sobrescrito la imagen. Las pruebas fallan y el equipo comienza a buscar errores en el código, pero el problema es mucho más simple: la imagen :latest estaba equivocada.

3. Terraform te apuñala por la espalda

Tienes un entorno de producción en AWS ECS que utiliza la imagen webroxsapp:latest. Todo parece funcionar bien, hasta que un redeploy se ejecuta y ECS toma una nueva versión de :latest. Pero no hay cambios en el código ni en la infraestructura; simplemente es una versión equivocada de la imagen.

Terraform dice que todo está bien, pero la aplicación responde con un error 404. Nadie sabe por qué. La etiqueta :latest ha causado el caos.

4. Rollbacks imposibles

El despliegue con :latest falla. Intentas hacer rollback, pero ahora :latest está apuntando a la versión rota. La versión anterior ya no está disponible. El proceso de rollback se convierte en un juego de adivinanza, buscando imágenes antiguas en los registros. El tiempo de inactividad se extiende y nadie sabe qué hacer.

¿Cómo funciona realmente la etiqueta :latest en Docker?

Es crucial entender cómo funciona Docker para ver por qué :latest es tan peligrosa. Aquí te muestro cómo Docker maneja las etiquetas:

Construcción y Etiquetado

Cuando ejecutas un docker build, si no especificas una etiqueta, Docker por defecto le asignará la etiqueta :latest a la imagen.

# Construcción con versión explícita
docker build -t devopsconrox:0.1 .

# Construcción sin etiqueta
docker build -t devopsconrox .

¿Qué sucede? La segunda construcción recibe la etiqueta devopsconrox:latest. Si luego construyes una nueva versión:

docker build -t devopsconrox:0.2 .

¿Crees que :latest se actualizó? ¡No! Sigue apuntando a la construcción anterior. Docker no sabe cuál es la imagen más reciente si no le especificas una etiqueta clara. Es un caos total.

¿Cómo evitar los problemas con :latest?

Ahora que sabes lo peligrosa que puede ser la etiqueta :latest, te voy a contar cómo puedes evitar que esta trampa te cause problemas en tu equipo.

1. Usa versiones semánticas o SHAs de commits

La clave es etiquetar las imágenes de manera precisa. Usa versiones semánticas o el SHA de los commits. De esta manera, siempre sabrás qué versión estás utilizando, y no tendrás que depender de la ambigua etiqueta :latest.

docker build -t devopsconrox:1.3.7 -t devopsconrox:commit-b6fa2e1 .
docker push devopsconrox:1.3.7
docker push devopsconrox:commit-b6fa2e1

2. Usa Digests para un control aún más preciso

Los digests son inmutables, lo que significa que la imagen no podrá ser sobrescrita accidentalmente. Usar digests es una forma de asegurarte de que el despliegue sea siempre el correcto.

# Despliegue en Kubernetes con Digest
spec:
  containers:
    - name: devopsconroxapp
      image: devopsconroxapp@sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890

3. Automatiza el etiquetado con tu pipeline CI/CD

Para evitar errores manuales, automatiza el etiquetado dentro de tu pipeline de CI/CD. De esta forma, nunca tendrás que preocuparte de que alguien etiquete mal la imagen.

name: Build and Deploy
on:
  push:
    branches: [ main ]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Build and tag
        run: |
          docker build -t devopsconrox:${{ github.sha }} -t devopsconrox:prod .
          docker push devopsconrox:${{ github.sha }}
          docker push devopsconrox:prod

4. Prohíbe :latest en tu pipeline y en tus registros

Usa herramientas como conftest o kube-linter para detectar el uso de :latest. Además, puedes configurar reglas en tu registro (por ejemplo, AWS ECR) para evitar que se suban imágenes con esta etiqueta.

1. Escanea tu código con conftest o kube-linter

Puedes usar herramientas como conftest o kube-linter para escanear tu código y detectar el uso de :latest. Estas herramientas te permiten asegurarte de que los manifiestos y las configuraciones de Kubernetes no incluyan esta etiqueta problemática.

Aquí tienes un ejemplo de cómo configurar una regla de Open Policy Agent (OPA) para bloquear :latest en los despliegues de Kubernetes:

package kubernetes
deny[msg] {
  input.kind == "Deployment"
  container := input.spec.template.spec.containers[_]
  contains(container.image, ":latest")
  msg := "No :latest allowed!"
}

Con esta regla, cualquier intento de despliegue con una imagen que contenga :latest será rechazado, garantizando que tus aplicaciones solo se desplieguen con versiones explícitas y controladas.

2. Agrega un paso en tu pipeline para rechazar :latest

Una de las formas más efectivas de evitar que :latest se cuele es agregar una verificación en tu pipeline de CI/CD. Con un simple script, puedes detectar la presencia de la etiqueta y fallar el pipeline si aparece.

Este es un ejemplo de un paso en tu pipeline que detecta y rechaza :latest en tus manifiestos y Dockerfiles:

if grep -r ":latest" manifests/ Dockerfile; then
  echo "Error: :latest detected!"
  exit 1
fi

Este comando busca la etiqueta :latest en todos los archivos relevantes de tu proyecto. Si la encuentra, el pipeline se detendrá inmediatamente, evitando que un despliegue potencialmente problemático llegue a producción.

Aquí tienes un ejemplo de cómo configurar una regla en ECR para rechazar la etiqueta :latest:

{
  "rules": [
    {
      "rulePriority": 1,
      "description": "No :latest allowed",
      "selection": {
        "tagStatus": "tagged",
        "tagPrefixList": ["latest"],
        "countType": "imageCountMoreThan",
        "countNumber": 0
      },
      "action": {
        "type": "expire"
      }
    }
  ]
}

Buenas prácticas en Docker: Despliegues eficientes y sin sorpresas

Además de evitar el uso de la peligrosa etiqueta :latest, es esencial seguir buenas prácticas en Docker para asegurarte de que tus contenedores sean eficientes, seguros y fáciles de mantener. Docker es una herramienta poderosa, pero su verdadero potencial se alcanza cuando aplicas las mejores prácticas. Aquí te comparto algunas de las principales recomendaciones para construir y gestionar tus imágenes de manera efectiva:

• Usa imágenes base pequeñas y optimizadas: Como las imágenes alpine para reducir el tamaño de las imágenes.

• Minimiza el número de capas en tu Dockerfile combinando las instrucciones en bloques.

• Ordena bien las instrucciones para aprovechar el cache de Docker.

• Usa multi-stage builds para optimizar el tamaño de la imagen.

• Elimina archivos innecesarios en cada etapa de construcción.

• Usa .dockerignore para excluir archivos que no necesitas en el contenedor final.

Para más detalles, puedes revisar la documentación oficial de buenas prácticas de Docker.

Conclusión: ¡Evita el thriller de :latest y asegura tus despliegues!

La etiqueta :latest en Docker es como un thriller lleno de suspenso, pero sin la emoción que deseas. Puede parecer una solución rápida y fácil, pero lo único que trae son problemas inesperados, caos en producción y confusión en tu pipeline. Como en cualquier buen thriller, todo parece ir bien hasta que, de repente, todo se viene abajo.

Para evitar que tu historia de despliegue se convierta en una pesadilla, es hora de decirle adiós a :latest. Usa versiones semánticas, digests y automatiza el etiquetado para tener un control total sobre lo que está ocurriendo en tus entornos de desarrollo y producción. Así, en lugar de enfrentarte a un thriller lleno de sorpresas, podrás disfrutar de un despliegue confiable y predecible, donde todo sigue el guion.

Recuerda, no pongas en riesgo tus despliegues por una etiqueta que suena fácil, pero esconde un montón de problemas. La etiqueta :latest es la verdadera estrella del drama, ¡y es hora de que dejes que el thriller termine y comiences una nueva era de despliegues seguros y controlados!

Bonus: ¡Y esto no es todo!

Si pensabas que ya habíamos cubierto todo lo importante, te tengo una sorpresa. Este artículo solo ha sido el principio de una serie de posts sobre Docker, DevOps y buenas prácticas que te ayudarán a sobrevivir al fuego.

En la próxima entrada, nos vamos a sumergir en un tema aún más ON FIRE: las historias de terror en contenedores multiarquitectura. ¡Prepárate! Este tema es más intenso que un buen thriller de suspenso. Si pensabas que el uso de :latest era un riesgo, espera a ver lo que puede pasar cuando ejecutas contenedores en diferentes arquitecturas. Vamos a hablar de las sorpresas, los problemas y las soluciones que te ayudarán a navegar sin miedo por el mundo de las multiarquitecturas.

Así que quédate atento, porque ¡esto se pone aún más emocionante! 🔥🔥

¡No dejes que el miedo a lo desconocido te detenga!

En DevOps y el desarrollo, la innovación y la mejora continua son el camino hacia el éxito. No temas dar el siguiente paso hacia un futuro más seguro y confiable en tus despliegues. ¡Lo único constante es el cambio y las mejoras, y con el conocimiento adecuado, puedes transformar cualquier desafío en una oportunidad!

¡Vamos por más! 💪 Nunca dejes de aprender y compartir, porque en la comunidad, todos crecemos juntos. 🚀

Sígueme en mis redes para más consejos, trucos y contenido exclusivo sobre DevOps, Docker y mucho más:

• Twitter: @roxsross

• LinkedIn: Rossana Suarez

• Instagram: @roxsdevops

A continuación, te traigo 20 ideas DevOps para principiantes que te ayudarán a construir una base sólida y a familiarizarte con las herramientas y conceptos fundamentales. ¡Vamos al challenge!

1. Automatización de Tareas Básicas con Scripts Bash

Aprende a usar Bash para automatizar tareas repetitivas de administración del sistema, como eliminar archivos antiguos o crear copias de seguridad. Este es un primer paso para familiarizarte con la automatización de procesos que se repiten en el entorno de desarrollo y administración de sistemas.

Enfoque:

• Crea un script .sh que elimine logs antiguos de una carpeta específica.

• Usa comandos como ls, rm, cp y tar para manejar archivos y directorios.

• Añade condicionales (if/else) y bucles (for) para darle flexibilidad al script, de manera que puedas personalizar el comportamiento según las necesidades.

• Practica con Killercoda: En Killercoda puedes realizar una gran variedad de prácticas que te permitirán afianzar lo aprendido con Bash, como la creación de scripts más complejos y la ejecución en entornos controlados.

Objetivo:

Familiarizarte con Bash, aprender a automatizar tareas comunes y comprender la lógica básica de programación en un entorno Unix/Linux.

2. Pipeline de CI/CD Básico con GitHub Actions

Configura un pipeline sencillo que ejecute pruebas automáticas cada vez que empujas código al repositorio. Ideal para entender cómo funciona la integración continua y cómo automatizar los procesos de construcción y prueba en tus proyectos.

Enfoque:

• Crea un repositorio en GitHub y sube un pequeño proyecto (por ejemplo, una app en Node.js o Python).

• Configura un archivo de flujo de trabajo en .github/workflows/main.yml para que se ejecute cada vez que se haga un push al branch principal.

• Agrega pasos para hacer el checkout del código, instalar dependencias y correr pruebas automáticas.

• Entrenamiento en CI/CD en GitHub: Si quieres comenzar a entrenarte con CI/CD en GitHub, cuentas con los pasos disponibles directamente en la documentación oficial de GitHub Actions. Aquí podrás entender cómo configurar y personalizar tus pipelines, lo que te permitirá automatizar tareas de forma eficiente y segura.

Objetivo:

Familiarizarte con GitHub Actions y aprender los fundamentos de la integración continua mediante la automatización de pruebas en un flujo de trabajo de CI/CD.s automáticas.

3. Despliegue de un Sitio Estático con Docker

Aprende los principios de contenerización utilizando Docker para ejecutar un sitio web estático dentro de un contenedor. Este proyecto te permitirá familiarizarte con la creación de contenedores Docker para aplicaciones web simples.

Enfoque:

• Crea una página web básica con HTML y CSS.

• Escribe un Dockerfile usando una imagen base como nginx:alpine para servir tu sitio web.

• Construye la imagen con docker build y corre el contenedor con docker run para poner en marcha tu sitio estático.

• Refuerza tus conocimientos de Docker: Puedes usar esta web, que ofrece varios temas sobre sitios estáticos, y si deseas profundizar más en Docker, este tutorial sobre Docker es increíble para aprender más sobre la contenerización y cómo utilizar Docker en diferentes escenarios.

Objetivo:

Familiarizarte con la creación y ejecución de contenedores Docker para sitios estáticos, lo que te permitirá aplicar principios de contenerización en proyectos reales.

4. Monitoreo Básico del Sistema en Linux

Familiarízate con los comandos básicos de Linux para monitorear el rendimiento de tu sistema, como CPU, memoria y espacio en disco.

Enfoque:

• Utiliza comandos como top, htop, df -h y free -h para monitorear los recursos del sistema.

• Puedes escribir un script que verifique la carga del sistema y avise si hay problemas de rendimiento.

• Practica con Killercoda

5. Automatización de Instalación de Paquetes en Linux

Crea un script para automatizar la instalación de software en un servidor Linux. Esto te ayudará a entender cómo mantener tus servidores consistentes.

Enfoque:

• Escribe un script en Bash que instale herramientas esenciales como git, docker, nodejs.

• Usa apt o yum según el sistema operativo que estés utilizando.

• Practica con Killercoda

6. Control de Versiones con Git

Aprende los conceptos básicos de Git, la herramienta más usada para el control de versiones en proyectos de software.

Enfoque:

• Inicializa un repositorio con git init.

• Realiza un commit, crea ramas y haz merges de manera sencilla.

• Aprende a resolver conflictos de fusión.

• Practica con Killercoda

7. Provisionamiento de Servidores con Ansible

Ansible es una herramienta de automatización que te permite configurar servidores y aplicaciones de manera eficiente. Ideal para principiantes en IaC (Infraestructura como Código).

Enfoque:

• Instala Ansible en tu máquina y escribe un playbook básico para instalar un servidor web (como nginx).

• Ejecuta el playbook con ansible-playbook y configura tu servidor automáticamente.

• Practica con Killercoda

8. Rotación Automática de Logs

Aprende a gestionar archivos de logs para evitar que llenen el disco con información innecesaria.

Enfoque:

• Usa logrotate para gestionar logs y asegurarte de que los archivos no crezcan demasiado.

• Configura el archivo de configuración de logrotate para realizar la rotación y compresión de logs automáticamente.

• Practica con Killercoda

9. Introducción a Terraform para IaC

Terraform es una herramienta de IaC que te permite gestionar infraestructuras en la nube. Comienza con algo simple como crear una máquina virtual en AWS.

Enfoque:

• Instala Terraform y configura tu proveedor (por ejemplo, AWS).

• Crea un archivo main.tf que defina una instancia de EC2 en AWS.

• Usa terraform init, terraform plan, y terraform apply para provisionar la infraestructura.

10. Monitoreo de Uptime de un Sitio Web con Cron Jobs

Configura un cron job para verificar la disponibilidad de un sitio web y enviarte un aviso si está caído.

Enfoque:

• Escribe un script que use curl para verificar el código de estado HTTP de un sitio.

• Si el sitio está caído, el script enviará un correo electrónico o una alerta por Slack.

• Programa el script para que se ejecute cada 5 minutos usando cron.

11. Pipeline de CI/CD con Jenkins y Docker

Configura un pipeline básico de CI/CD en Jenkins y usa Docker para crear un entorno de construcción consistente.

Enfoque:

• Instala Jenkins y configúralo para usar Docker.

• Crea un Jenkinsfile para definir las etapas del pipeline: checkout del código, construcción de la imagen Docker, pruebas y despliegue.

12. Despliegue de una Aplicación Web en AWS usando Terraform

Lleva el concepto de IaC un paso más allá creando una infraestructura en AWS para alojar una aplicación web.

Enfoque:

• Usa Terraform para crear recursos en AWS, como una instancia EC2 y un grupo de seguridad.

• Implementa una aplicación simple en la instancia y hazla accesible a través de un balanceador de carga.

13. Respaldo Automático de Bases de Datos con Shell Scripts

Aprende a crear copias de seguridad automatizadas de una base de datos y a almacenarlas en la nube.

Enfoque:

• Escribe un script que use mysqldump o pg_dump para crear una copia de seguridad de la base de datos.

• Comprime la copia de seguridad y súbela a un servicio de almacenamiento en la nube como AWS S3.

14. Configuración Básica de Kubernetes con Minikube

Configura un clúster Kubernetes localmente con Minikube y aprende los conceptos básicos como Pods y Servicios.

Enfoque:

• Instala Minikube y kubectl en tu máquina.

• Inicia un clúster local con minikube start y despliega una aplicación simple en Kubernetes.

15. Gestión Centralizada de Logs con ELK Stack

Aprende a recolectar y visualizar logs usando Elasticsearch, Logstash y Kibana (ELK).

Enfoque:

• Despliega Elasticsearch y Kibana utilizando Docker.

• Usa Logstash para procesar logs de un servidor o aplicación y visualízalos en Kibana.

16. CI/CD para Microservicios con Docker y Kubernetes

Aprende cómo gestionar una arquitectura de microservicios usando Docker y Kubernetes.

Enfoque:

• Configura un repositorio para múltiples microservicios.

• Crea un pipeline de CI/CD que construya imágenes Docker, ejecute pruebas y las despliegue en Kubernetes.

17. Gestión de Configuración de Servidores con Puppet

Puppet es una herramienta poderosa para gestionar la configuración de servidores. Ideal para principiantes que quieren aprender IaC.

Enfoque:

• Instala Puppet y configura un servidor web con nginx usando un manifiesto de Puppet.

18. Revisiones Automáticas de Calidad de Código con SonarQube

Integra SonarQube en tu pipeline para realizar análisis estáticos de código y asegurar que se cumplan los estándares de calidad.

Enfoque:

• Configura un servidor de SonarQube y conéctalo a tu pipeline de CI/CD.

• Ejecuta análisis de calidad de código cada vez que se haga un commit en el repositorio.

19. Implementación de un Servidor de Nginx con Docker y Ansible

Aprende a automatizar la implementación de un servidor Nginx usando Docker y Ansible para la configuración de servidores de forma eficiente.

Enfoque:

• Crea un archivo Dockerfile para desplegar Nginx en un contenedor Docker.

• Utiliza Ansible para automatizar la instalación de Docker y la configuración del contenedor Nginx en un servidor remoto.

• Configura un playbook de Ansible para asegurarte de que el servidor tenga el contenedor Docker con Nginx funcionando automáticamente.

Objetivo:

Familiarizarte con la integración de Docker y Ansible para la gestión y configuración de servidores.

20. Automatización del Proceso de Certificados con Let's Encrypt

Automatiza la obtención y renovación de certificados SSL/TLS usando Let's Encrypt.

Enfoque:

• Usa certbot para obtener y renovar certificados SSL de manera automática.

• Configura un cron job para renovar los certificados periódicamente.

Estos fundamentos de DevOps son esenciales para cualquiera que quiera adentrarse en el mundo de la automatización, integración continua y gestión de infraestructuras. A medida que avanzas en estos proyectos, estarás construyendo no solo una base técnica sólida, sino también una mentalidad ágil y eficiente que te permitirá enfrentar desafíos reales en el desarrollo y despliegue de aplicaciones. Además, aprender y practicar con herramientas como Docker, GitHub Actions, Ansible y Terraform te abrirá puertas a muchas oportunidades en el mundo de la tecnología.

Recuerda que el camino en DevOps es un proceso continuo de aprendizaje y mejora. No tengas miedo de experimentar, probar nuevas herramientas y enfrentarte a desafíos. Cada pequeño paso te acerca más a ser un profesional completo en este campo.

¡Estamos todos juntos en esta ola!

Si tienes alguna duda o quieres seguir aprendiendo más sobre DevOps, puedes encontrarme en mis redes sociales. ¡Conéctate conmigo y sigamos compartiendo conocimiento y creciendo juntos!

• Twitter: @roxsross

• LinkedIn: Rossana Suarez

• GitHub: roxsross

• YouTube: 295devops

A continuación, exploramos algunos de los mayores desafíos que enfrentan los DevOps durante las entrevistas y cómo puedes prepararte para superarlos de manera efectiva.

La brecha entre teoría y práctica: el mayor desafío

Es común que las entrevistas se centren en conocimientos teóricos y certificaciones, pero esto no siempre refleja las habilidades prácticas necesarias para el trabajo. A menudo, los candidatos que se presentan con un currículum cargado de certificaciones como AWS o Kubernetes se ven sorprendidos al enfrentarse a preguntas básicas sobre conceptos fundamentales, como balanceo de carga o la terminación de SSL.

La lección aquí es clara: tener certificaciones no garantiza que poseas las habilidades necesarias para resolver problemas reales. Es fácil memorizar respuestas para aprobar un examen, pero la experiencia práctica es lo que realmente cuenta cuando se trata de DevOps. Las empresas buscan a alguien que sepa cómo aplicar sus conocimientos en entornos de producción, no solo que pueda repetir teoría.

¿Memorizar o resolver?

• La tecnología cambia todos los días.

• Los comandos de hoy, mañana quedan obsoletos.

• La verdadera habilidad no está en recordar cada línea.

• Está en pensar, adaptarse y encontrar soluciones cuando el desafío aparece.

¿Qué buscan realmente las empresas?

Las certificaciones pueden abrirte puertas, pero no son suficientes para asegurar el puesto. Los gerentes de contratación buscan habilidades concretas y experiencia práctica. Algunos aspectos esenciales que destacan en las entrevistas incluyen:

• Conocimiento sólido de los principios fundamentales: Las empresas valoran una comprensión robusta de conceptos clave como por ejemplo: administración de sistemas Linux, automatización, contenedores, redes, proveedores de nube, seguridad y cicd, antes de abordar herramientas avanzadas como Kubernetes o Terraform.

Ejemplo:
Una empresa puede valorar más a un candidato que entiende a fondo cómo funciona un sistema operativo (como Linux) y cómo interactúa con redes, en lugar de uno que solo sabe cómo usar herramientas como Kubernetes sin saber cómo optimizar las configuraciones a nivel de sistema.

• Capacidad para resolver problemas reales: Ser capaz de identificar y resolver problemas de forma rápida es crucial. Las empresas valoran enormemente la habilidad de gestionar errores y fallos sin entrar en pánico.

Ejemplo:
En un escenario real, si un equipo de DevOps enfrenta un fallo en una pipeline CI/CD debido a un cambio de configuración en un repositorio, el candidato ideal no solo debe identificar el problema rápidamente sino también proponer y aplicar una solución eficiente sin causar interrupciones significativas en la entrega continua. Este tipo de resolución de problemas en tiempo real es lo que más valoran las empresas.

• Capacidad para trabajar bajo presión: En DevOps, la gestión de incidentes y la resolución de crisis son habilidades fundamentales. Un buen ingeniero de DevOps debe poder mantener la calma bajo presión y aplicar soluciones rápidas y eficaces.

Ejemplo:
Imagina que una empresa está experimentando una interrupción crítica en su base de datos debido a un aumento inesperado de tráfico. Un buen DevOps no solo identificaría el problema rápidamente, sino que también implementaría una estrategia de escalado automático en el clúster de bases de datos, lo que permite manejar el tráfico sin afectar la experiencia del usuario, todo mientras mantiene la comunicación clara y efectiva con los equipos involucrados.

Ejemplo práctico:

Imagina que una empresa está buscando un DevOps para integrar su nueva aplicación en la nube. El candidato ideal no solo tendría que tener conocimientos sobre la infraestructura en la nube y cómo configurar Kubernetes, sino también ser capaz de identificar rápidamente un problema en el flujo de trabajo de despliegue. Supongamos que al realizar el despliegue se presenta un error de acceso a la base de datos debido a una mala configuración de los secretos de la nube.

El DevOps debería ser capaz de:

1. Diagnosticar el problema rápidamente al revisar los registros y los secretos de la nube.

2. Aplicar una solución rápida configurando correctamente los permisos y accesos.

3. Optimizar el proceso de despliegue para evitar que el problema ocurra en el futuro.

4. Mantener la comunicación constante con los equipos de desarrollo y seguridad para asegurar que no se repita el incidente.

Este tipo de experiencia práctica y habilidad para manejar situaciones en tiempo real es exactamente lo que buscan las empresas en un profesional DevOps.

Preparación práctica: lo que realmente importa

Para prepararte adecuadamente para una entrevista en DevOps, es importante enfocarte en las siguientes áreas:

• Domina lo básico antes de las herramientas complejas.
  Antes de lanzarte a aprender herramientas como Terraform o Kubernetes, asegúrate de tener una comprensión sólida [Fundamentos] de sistemas operativos, scripting, redes, seguridad … [Roadmap]. Estas áreas constituyen la base de la mayoría de las tareas en DevOps.

Consejo práctico:
Haz un "sandbox" en tu propio entorno (puedes usar VMs o contenedores locales). Este será tu laboratorio personal donde podrás experimentar con configuraciones de red, sistemas de monitoreo y pequeños scripts de automatización antes de meterte en tecnologías más complejas.

• Desarrolla experiencia resolviendo problemas reales.
  La teoría está bien, pero la práctica es lo que realmente cuenta. Si puedes, crea un entorno de laboratorio en tu casa, contribuye a proyectos de código abierto o trabaja en proyectos prácticos para aprender a resolver problemas reales. Aquí te dejo una solución práctica para avanzar en 60 días

Ejemplo práctico:
Simula un fallo en el balanceo de carga en un entorno de producción. Intenta identificar la raíz del problema usando logs, trazabilidad y monitoreo de métricas. La habilidad para reconstruir el incidente y tomar acciones correctivas rápidamente te prepara para los verdaderos desafíos de producción.

• Aprende a leer logs y mensajes de error.
  La lectura de registros es crucial en DevOps. Muchas veces, la solución a un problema está en los logs, y saber interpretarlos es esencial para diagnosticar y solucionar problemas rápidamente.

Consejo práctico:
Haz ejercicios regulares de debugging. Revisa los logs de un contenedor o una aplicación en ejecución y busca errores comunes. Desafíate a encontrar la causa raíz de un problema solo mirando los logs. Cuanto más lo practiques, mejor serás en resolver problemas rápidamente.

• Sé honesto sobre lo que no sabes.
  En lugar de intentar impresionar a los entrevistadores con conocimientos falsos, admite lo que no sabes y muestra tu disposición a aprender. La actitud proactiva hacia el aprendizaje es altamente valorada en DevOps.

Ejemplo práctico:
Si en una entrevista no sabes cómo manejar un escenario específico, en lugar de intentar adivinar la respuesta, puedes responder algo como:
"No tengo experiencia directa con esa herramienta, pero me siento cómodo aprendiendo nuevas tecnologías rápidamente. Te puedo dar ejemplos de cómo he aprendido otras herramientas, como [menciona alguna]. Estoy seguro de que podré adaptarme a este desafío también."
Esto demuestra confianza y disposición para aprender.

• Construye un portafolio de soluciones reales.
  Presentar ejemplos tangibles de tu trabajo y las soluciones que has implementado en proyectos anteriores demuestra tu experiencia y capacidad real.

Consejo práctico:
Documenta tu experiencia utilizando markdown o en una plataforma como GitHub o GitLab. Comparte las soluciones que implementaste y describe las lecciones aprendidas. Incluye enlaces a repositorios de código, configuraciones de infraestructura o diagramas que muestren tu proceso.

La realidad de los roles en DevOps: un equilibrio complicado

Uno de los mayores desafíos en los roles de DevOps es la necesidad de tener un conocimiento equilibrado tanto de desarrollo como de operaciones. A diferencia de otros campos, DevOps requiere que seas capaz de navegar entre estas dos áreas, algo que tradicionalmente ha sido manejado por diferentes especialidades. Esta dualidad hace que el rol sea complicado, ya que no solo debes ser un experto en herramientas y procesos, sino también en la colaboración entre equipos de desarrollo y operaciones.

Este equilibrio también implica que, como ingeniero DevOps, es probable que tengas que cambiar de contexto constantemente, lo que significa que es más importante ser adaptable y tener una base sólida en lugar de memorizar detalles específicos de cada herramienta o servicio.

Shades of DevOps Roles: Un concepto para entender las múltiples facetas de DevOps

El gráfico de Patrick Debois, que muestra los "Shades of DevOps Roles", ilustra cómo DevOps significa cosas diferentes para diferentes personas. En el diagrama, se puede ver cómo diferentes roles se encuentran en el espectro entre desarrollo y operaciones, cada uno con su propio conjunto de habilidades y responsabilidades.

Este gráfico revela cómo el rol de DevOps es dinámico y diverso, y cómo ha evolucionado más allá de su origen como un conjunto de prácticas relacionadas con la automatización y la entrega continua. Ahora incluye roles emergentes como DataOps, AIOps, MLops, hasta llegar a aquellos que están más centrados en la producción, como Cloud Ops y SysAdmin. La "Buzzword Hipness" muestra cómo algunas tendencias son más populares que otras en el momento, pero todas las prácticas son igualmente importantes en su contexto.

Hoy, hay más…

Y como muestra el gráfico de Patrick Debois, hoy hay más roles en DevOps que nunca, cada uno con un enfoque especializado para necesidades específicas dentro del ciclo de vida del software. Pero, claro, no olvidemos que RoxsOps (¡sí, lo dije!, soy yo 🔥) , con toda la fuerza de la IA y el poder de la automatización, llevando a DevOps a un nivel superpower. 😎

¡Así que, si tienes dudas, no te preocupes! Solo recuerda "surfea el fuego" y mantén el ritmo con RoxsOps. ¡La IA está aquí, y RoxsOps no te dejará atrás! 💪🔥

Enfoque para avanzar en DevOps

Si estás buscando ingresar a DevOps o mejorar tu rendimiento en las entrevistas, lo más importante es construir una base sólida de habilidades prácticas en lugar de enfocarte solo en obtener certificaciones. Recuerda que DevOps no se trata solo de conocer herramientas o plataformas específicas, sino de conectar diferentes áreas y resolver problemas de manera eficiente.

Si eres parte del proceso de contratación, considera que podrías estar filtrando a candidatos valiosos con habilidades reales. Revisa tus procesos de entrevistas y asegúrate de que estés buscando las habilidades que realmente importan.

Al final, DevOps no es solo sobre tener un conjunto de habilidades técnicas; se trata de tener la capacidad de adaptarse, aprender y colaborar de manera efectiva. Enfócate en la práctica, mantén una mentalidad de aprendizaje constante, y te convertirás en un candidato invaluable para cualquier equipo de DevOps.

Bonus Track: La IA en DevOps: Una tendencia clave en la aceleración

La inteligencia artificial (IA) está jugando un papel crucial en DevOps, acelerando procesos y transformando la forma en que gestionamos el ciclo de vida del software. La automatización impulsada por IA permite que los equipos de DevOps realicen tareas con mayor rapidez y precisión, desde la optimización de pipelines hasta la predicción de fallos en los sistemas.

Aceleración y optimización con IA:

• Monitoreo inteligente: Las herramientas de IA pueden analizar grandes cantidades de datos y detectar patrones que podrían pasarse por alto en un entorno tradicional. Esto acelera la identificación de problemas y permite una respuesta proactiva antes de que el impacto sea significativo.

• Automatización predictiva: Con el uso de IA, es posible predecir fallos en la infraestructura antes de que ocurran, lo que permite a los equipos DevOps tomar medidas preventivas y mejorar la fiabilidad del sistema.

• Optimización de pipelines: Herramientas como Jenkins y GitLab están incorporando IA para mejorar la ejecución de pipelines, ayudando a identificar y solucionar cuellos de botella de manera automática.

¿Cómo prepararte para aprovechar la IA en DevOps?

Familiarízate con herramientas basadas en IA que se integran en el flujo de trabajo DevOps, como GitLab CI/CD, Github Actions con capacidades de aprendizaje automático y Terraform para automatización predictiva. Entender cómo aplicar IA para mejorar la eficiencia de tu pipeline y la estabilidad de tus sistemas será un diferenciador clave en las entrevistas.

20 Trucos de IA para Dominar tu Flujo de Trabajo DevOps y Acelerar Resultados

En este mundo en constante cambio, DevOps es un campo donde el aprendizaje continuo es la clave. No te limites a memorizar teorías: practica, resuelve problemas reales y mantén una mentalidad de crecimiento. DevOps es para quienes buscan adaptarse, aprender y colaborar, no solo para quienes conocen herramientas. Con estas estrategias, estarás en el camino correcto para destacarte y tener éxito en tus entrevistas.

¡Sigue surfeando el fuego del cambio, cada desafío es una oportunidad para crecer!

Conéctate conmigo y vamos a surfear juntos:

Si quieres seguir aprendiendo, compartir ideas, o simplemente unirte a la comunidad, conéctate conmigo en mis redes sociales.

• Twitter: @roxsross

• LinkedIn: Rossana Suarez

• YouTube (295devops): 295DevOps en YouTube

• Instagram: @roxsross

• GitHub: Roxs GitHub

¡Juntos seguimos creciendo!

Ser DevOps es, por lo general, sinónimo de lidiar con conceptos tan técnicos que, cuando intentas explicarlos a alguien que no tiene idea, la conversación termina en *“*Ah, entonces trabajas con computadoras, ¿no?”

Pero no te preocupes, aquí te traemos algunas formas divertidas, y a veces absurdas, de explicar tu trabajo sin perder la paciencia. 😎

1. La Fábrica de Tacos: La Explicación que Todos Entienden 🌮

"Los desarrolladores hacen tacos. Yo construyo la taquería donde se preparan esos tacos". 🏭

¿Quién no entiende esa metáfora? Un ingeniero me dijo: “Usé esta explicación en la fiesta de mi prima y todos lo entendieron al instante”. Y claro, hay más versiones, porque en el mundo DevOps todo se puede comparar con comida:

• "Yo hago las tortillas y las salsas que hacen que los tacos salgan perfectos".

• "Me aseguro de que podamos hacer tacos en masa sin que exploten las parrillas".

• "¡Yo soy el que prueba los tacos y a veces los tiro al suelo solo para ver si hay salsa derramada!"

Así que ya sabes, tu trabajo en DevOps también es como construir una taquería de tacos... ¡todo el mundo lo entiende!

2. ¿Trabajo con Computadoras? ¡Ya está! 🙄

La respuesta más rápida de muchos es simplemente "Trabajo con computadoras" y hacen un movimiento como si estuvieran escribiendo un código secreto. Y luego… ¡plop! La gente ya no pregunta más.

Ingeniero 1: "Digo 'Trabajo con computadoras' y automáticamente la gente se va."
Ingeniero 2: "Lo mejor es decir 'Trabajo con computadoras', luego decir que si te hace falta la impresora, no es mi problema" 😆

3. Respuestas Absurdas para Crear Confusión Total 🤯

¿Alguna vez has querido salirte por la tangente completamente? Aquí tienes un par de respuestas para dejar a todos boquiabiertos:

• "Digo que soy influencer en OnlyFotos. Nadie hace más preguntas."

• “Soy un RoxsStar de Eurovision”

• “Chef de una cadena de comida coreana”

A veces, cuanto más extraño suene, más divertido es el desconcierto de la gente.

4. La Caja de Pandora Digital: ¡Nunca Sabes lo que Va a Salir! 🎁

¿Dices "trabajo con la nube"? Y ahí empieza la confusión…

Yo: "Trabajo con la nube."
Ellos: "Ah, ¿como el Wi-Fi?"
Yo: "Sí, pero imagina que el Wi-Fi está tomando café y no lo puedes ver." ☕

Es como tener una caja de Pandora digital: nadie sabe qué hay adentro, pero cuando la abres, todo está funcionando… ¡hasta que de repente no lo está! 😜

5. La Clásica Pregunta: "¿Arreglas mi computadora?" 💻

No importa cuán técnico sea tu trabajo, siempre habrá alguien que pregunte:
“Entonces, ¿eres un experto en computadoras? ¿Puedes arreglar mi computadora?”

La respuesta clásica: "Solo porque trabajo con computadoras no significa que pueda arreglar tu impresora, pero sí, la puedo arreglar... aunque no sea mi trabajo". 🙃

6. El Superhéroe Digital 🦸‍♂️

"Soy como un superhéroe digital. ¡Pero sin capa! Mi trabajo es asegurarme de que el código fluya sin problemas, que los sistemas estén listos para escalar y que todo el equipo de desarrollo y operaciones pueda colaborar eficientemente. Mientras todos están distraídos con memes, yo me aseguro de que la magia ocurra sin que se note." 😎💻

En DevOps, nadie ve todo el trabajo detrás del telón. Pero sin ese esfuerzo continuo de automatización, integración continua y entrega continua, ¡la web sería un caos! 🚀

7. La Comparación con la Cocina 🍳

"Soy como un chef de software. Los desarrolladores son los que preparan los ingredientes, pero yo soy el que se encarga de la receta para que todo salga a tiempo, bien cocido y sin que se queme". 🍴

Si no fuera por ti, el “plato” (es decir, el sistema) podría no salir como se espera. ¡Alguien tiene que estar al mando de la cocina para que todo quede delicioso y funcione perfectamente!

Reflexión Final: Lo Importante No Es lo que Haces, Sino Cómo Lo Explicas.

Al final del día, lo que más importa es tu capacidad de comunicar lo que haces y ayudar a otros a entender la importancia de tu trabajo, incluso si tu explicación es algo tan simple como “Soy el arquitecto de la nube” o “Arreglo la autopista digital por donde corren los datos”. Lo que haces puede ser complejo, pero si lo explicas con humor y claridad, ¡todo se hace más fácil de entender!

Recuerda, como en DevOps, la clave es la colaboración. La comunidad tech está aquí para apoyarnos y aprender juntos, así que no te frustres si no te entienden. Al final, todos estamos en el mismo equipo. 🔥

Sígueme en mis redes sociales para más contenido onfire:

• LinkedIn: @roxsross

• Twitter: @roxsross

• Instagram: @roxsross

• YouTube: 295devops

¡Y no olvides que lo importante no es la respuesta, sino surfear las olas! 💪

Si alguna vez has tenido que lidiar con estos problemas, no te preocupes, no estás solo. La buena noticia es que ¡puedes resolverlo de manera rápida y eficiente! Hoy comenzamos con "CI/CD The Series", y en esta primera entrega vamos a hablar de Jenkins, la herramienta de automatización de tareas en procesos de integración continua (CI) más extendida. Vamos a entender qué es Jenkins, cómo funciona, para qué sirve y, por qué es una de las mejores opciones si queremos aplicar CI en nuestros proyectos de software. Además, explicaremos de forma sencilla en qué consiste la práctica de la integración continua y por qué es tan crucial en el mundo del desarrollo ágil y la entrega de software.

¿Qué es CI (Integración Continua)?

La integración continua (CI) es una práctica fundamental en el desarrollo de software moderno. En términos simples, se refiere a la acción de integrar cambios de código frecuentemente en un repositorio compartido. Los desarrolladores no esperan semanas para realizar cambios masivos, sino que lo hacen de manera continua, integrando los cambios a medida que avanzan. Esto permite a los equipos detectar errores rápidamente y mantener la calidad del código constantemente.

Beneficios de la CI:

1. Desarrollo más rápido: Al integrar cambios pequeños y frecuentes, los desarrolladores pueden detectar errores más rápidamente.

2. Menos conflictos de código: La integración continua ayuda a reducir los conflictos de código que suelen ocurrir cuando varias personas trabajan en una misma base de código durante largo tiempo sin integración.

3. Mejora de la calidad: Las pruebas automáticas frecuentes permiten encontrar errores más pronto, lo que significa que los desarrolladores pueden corregir los fallos antes de que se conviertan en problemas críticos.

4. Entrega continua: Al facilitar la integración de todos los cambios, se hace más fácil implementar la práctica de entrega continua (CD), donde cada cambio pasa por un proceso automático de pruebas y despliegue.

Integración continua by AWS

Con la entrega continua, se crean, prueban y preparan automáticamente los cambios en el código y se entregan para la fase de producción. La entrega continua amplía la integración continua al implementar todos los cambios en el código en un entorno de pruebas y/o de producción después de la fase de creación.

Siempre fue un gran desafío para las empresas establecer, configurar y administrar un flujo de trabajo constante. Debido a los rápidos cambios de los últimos años, el desarrollo de software ha dado un gran paso adelante desde la introducción de la integración continua y la entrega continua (CI/CD). Ahora que comprende el papel que desempeña la CI en el desarrollo de software, podemos pasar al objetivo central de este tutorial de pipeline de Jenkins. by Roxs

¿Por qué Jenkins es una de las mejores opciones para CI/CD?

Jenkins es el servidor de CI más popular y utilizado, diseñado para facilitar la integración continua y la entrega continua. Con más de 23.9k estrellas en GitHub y 9.1k forks, Jenkins es conocido por su flexibilidad y la capacidad de automatizar casi todos los aspectos del ciclo de vida del software.

Ventajas de Jenkins:

• Automatización total: Jenkins permite automatizar completamente los procesos de construcción, pruebas y despliegue, eliminando tareas manuales tediosas y propensas a errores.

• Extensibilidad mediante plugins: Jenkins cuenta con una enorme cantidad de plugins que lo hacen muy versátil. Puedes integrar Jenkins con herramientas de testing, bases de datos, servicios en la nube como AWS, y mucho más.

• Escalabilidad: Desde proyectos pequeños hasta sistemas a gran escala, Jenkins se adapta fácilmente a proyectos de cualquier tamaño y complejidad.

• Código abierto: Al ser open-source, Jenkins permite modificaciones y personalización para adaptarse a las necesidades específicas de tu equipo y flujo de trabajo.

• Interfaz web intuitiva: Jenkins es fácil de manejar gracias a su interfaz web que te permite configurar tus pipelines de manera visual, aunque también puedes hacerlo directamente con código.

¿Cómo funciona Jenkins en un flujo de trabajo CI/CD?

Jenkins actúa como el corazón del flujo de trabajo CI/CD. Usando Jenkinsfiles (archivos de configuración en Groovy), puedes definir qué pasos se deben ejecutar automáticamente cuando se realiza un commit o pull request en tu repositorio de código.

Un flujo de trabajo típico de Jenkins implica varios pasos automatizados:

1. Checkout del código: Jenkins descarga el código desde un repositorio de control de versiones como Git.

2. Compilación: Se compila el código (si aplica), asegurando que no haya errores de sintaxis.

3. Pruebas: Ejecuta pruebas automatizadas para validar la integridad del código.

4. Despliegue: Si las pruebas pasan con éxito, el código se despliega en un entorno de staging o producción.

Con Jenkins, este proceso se convierte en algo automático, eliminando los errores humanos y acelerando el tiempo de entrega.

Tipos de Pipelines en Jenkins

Jenkins ofrece dos tipos de pipelines:

1. Scripted Pipeline:

Este es el modelo tradicional y más flexible, pero también es más complejo. Se utiliza Groovy para escribir un pipeline que te permite un control total sobre el proceso.

2. Declarative Pipeline:

Este tipo de pipeline es más simple y accesible, especialmente para quienes se inician en Jenkins. Usando una sintaxis más amigable y estructurada, los pipelines declarativos permiten escribir las etapas de CI/CD de forma más clara y fácil de entender.

Sintaxis de un Pipeline Declarativo:

Un ejemplo simple de un pipeline declarativo en Jenkins:

pipeline {
    agent any
    stages {
        stage('Stage: Hola Mundo') {
            steps {
                echo 'Paso 1: Hola Mundo'
            }
        }
        stage('Stage: Segundo Stage') {
            steps {
                echo 'Paso 2: Hola Dos Veces'
                echo 'Paso 3: Hola Tres Veces'
            }
        }
    }
}

Este código define un pipeline con dos etapas (stages): una que imprime "Hola Mundo" y otra que imprime "Hola Dos Veces" y "Hola Tres Veces". ¡Imagina lo que podrías hacer con un pipeline real de construcción y despliegue!

¿Cómo instalar Jenkins?

Jenkins se puede instalar de varias maneras, pero la forma más rápida y sencilla es usando Docker. Esto te permite tener Jenkins corriendo en minutos sin preocuparte por la configuración del sistema.

Instalación con Docker:

docker run -p 8080:8080 -p 50000:50000 -d --name jenkins --restart=always jenkins/jenkins:alpine

Una vez que Jenkins esté en funcionamiento, puedes acceder a él a través de tu navegador en http://localhost:8080. ¡Y listo! Ahora puedes comenzar a configurar tu primer pipeline.

Desbloquear Jenkins: Abre tu navegador en http://localhost:8080 y usa la contraseña que se encuentra en:

docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

Instalación en Ubuntu:

Si prefieres instalar Jenkins directamente en un sistema Ubuntu, sigue estos pasos:

1. Instalar Java: Jenkins requiere Java, así que asegúrate de tenerlo instalado. Puedes instalar OpenJDK con el siguiente comando:

    sudo apt install -y openjdk-21-jre
   

2. Agregar el repositorio de Jenkins:

    sudo wget -O /etc/apt/keyrings/jenkins-keyring.asc https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key
    echo "deb [signed-by=/etc/apt/keyrings/jenkins-keyring.asc] https://pkg.jenkins.io/debian-stable binary/" | sudo tee /etc/apt/sources.list.d/jenkins.list > /dev/null
    sudo apt-get update
    sudo apt install -y jenkins
   

3. Iniciar Jenkins:

    sudo systemctl start jenkins
    sudo systemctl status jenkins
   

4. Desbloquear Jenkins: Abre tu navegador en http://localhost:8080 y usa la contraseña que se encuentra en:

    sudo cat /var/lib/jenkins/secrets/initialAdminPassword
   

Espera hasta que se instalen todos los complementos. Cuando finalice la instalación, haga clic en continúar.

Iniciando Jenkins

Cree un perfil de administrador para Jenkins. Ingrese los detalles requeridos y haga clic en Guardar y continuar.

Sabemos que siempre cuando es la primera vez, usamos user y pass admin:admin xD bueno tratemos que si es un ambiente productivo colocar pass con mas seguridad

Finalmente, el proceso de configuración está hecho, y el anterior es el predeterminado,

¡Bienvenido a Jenkins! .

10 Plugins Esenciales para Jenkins

Jenkins es increíblemente flexible y potente, y gran parte de esa flexibilidad se debe a su sistema de plugins. Con los siguientes 10 plugins podrás integrar Jenkins con diversas herramientas y servicios, facilitando aún más tu flujo de trabajo CI/CD.

1. AWS Credentials Plugin

Este plugin permite que Jenkins gestione y utilice las credenciales de AWS para integrarse con servicios de Amazon Web Services, como S3, EC2, Lambda, etc. Es fundamental para la integración de Jenkins con la nube.

2. Docker Pipeline Plugin

Este plugin permite que Jenkins interactúe con Docker para crear contenedores, ejecutar pruebas dentro de contenedores y más. Es esencial si usas Docker en tu flujo de trabajo.

3. Blue Ocean Plugin

Blue Ocean redefine la experiencia de usuario en Jenkins. Este plugin te proporciona una interfaz más moderna y visual para configurar, ejecutar y monitorear tus pipelines.

4. GitHub Plugin

Este plugin conecta Jenkins con GitHub, permitiendo disparar pipelines automáticamente cuando se realizan cambios en repositorios de GitHub.

5. SonarQube Scanner Plugin

El plugin SonarQube Scanner para Jenkins facilita la integración de Jenkins con SonarQube, permitiendo realizar análisis de calidad de código automáticamente.

6. Slack Notification Plugin

Este plugin envía notificaciones a canales de Slack cada vez que un job o un pipeline cambia de estado. Ideal para mantener al equipo informado sobre el estado de las tareas.

7. GitLab Plugin

El plugin de GitLab integra Jenkins con los repositorios GitLab, permitiendo que las tareas de Jenkins se ejecuten cada vez que se haga un commit o un pull request en un repositorio GitLab.

8. Pipeline Utility Steps Plugin

Este plugin proporciona pasos adicionales para manipular archivos y ejecutar comandos útiles dentro de los pipelines, como la creación de archivos, lectura y escritura de variables, etc.

9. Email Extension Plugin

El plugin de Email Extension permite enviar correos electrónicos en función de los resultados de las compilaciones. Es útil para alertar a los miembros del equipo si algo sale mal durante el proceso de integración.

10. Jira Plugin

Si utilizas Jira para gestionar los tickets de tu proyecto, este plugin te permite conectar Jenkins con Jira y asociar automáticamente los builds con tickets específicos.

¡Vamos a Crear Nuestro Primer Pipeline!

Ejemplo Simple de Pipeline en Jenkins:

A continuación, te mostramos un Jenkinsfile básico que realiza las siguientes acciones:

1. Compila el código.

2. Ejecuta pruebas.

1. Crea un Nuevo Proyecto en Jenkins

• Inicia sesión en Jenkins y haz clic en Nuevo Elemento.

• Selecciona la opción Pipeline como tipo de proyecto. Este tipo de proyecto te permitirá definir tu pipeline mediante un Jenkinsfile.

• Dale un nombre descriptivo a tu proyecto, como "MiPrimerPipeline" o algo relacionado con tu aplicación.

2. Define tu Jenkinsfile

• En la configuración de tu nuevo proyecto, busca la sección Pipeline.

• En el campo Pipeline Script, define tu Jenkinsfile, que es el archivo donde escribirás las etapas (stages) de tu pipeline.

pipeline {
    agent any

    stages {
        // Etapa de compilación
        stage('Build') {
            steps {
                echo 'Compilando el código...'
                // Aquí puedes agregar tu comando de compilación, por ejemplo:
                sh 'echo "Compilación exitosa!"'
            }
        }

        // Etapa de pruebas
        stage('Test') {
            steps {
                echo 'Ejecutando las pruebas...'
                // Aquí puedes agregar el comando para ejecutar pruebas, por ejemplo:
                sh 'echo "Pruebas exitosas!"'
            }
        }
    }
}

3. Guarda y Ejecuta tu Pipeline

• Una vez que hayas definido tu Jenkinsfile, haz clic en Guardar para guardar la configuración del proyecto.

• Para ejecutar el pipeline, haz clic en Construir ahora. Jenkins comenzará a ejecutar cada etapa que hayas definido en el Jenkinsfile.

• Puedes ver el progreso en la consola de Jenkins mientras se ejecutan las etapas, y si alguna falla, podrás revisar los logs para identificar el problema.

4. Observa el Progreso y Resultados

• Una vez que el pipeline se haya ejecutado, podrás ver el estado de cada etapa (Build, Test). Si todo sale bien, tu pipeline se completará exitosamente.

• Si alguna de las etapas falla (por ejemplo, en las pruebas), Jenkins te mostrará los logs detallados para que puedas identificar y corregir el error.

¿Qué hace este pipeline?

• Este pipeline no está haciendo realmente una compilación o ejecutando pruebas reales, pero es un buen punto de partida. Lo importante aquí es que ya estás viendo cómo se estructura un pipeline en Jenkins.

Tip Importante para Docker:

Recuerden usar el parámetro restart: always cuando configuren Jenkins en Docker. Esto es crucial, ya que si instalas plugins o realizas cambios en la configuración, Jenkins necesitará reiniciarse. Si no tienes este parámetro configurado, tu contenedor no se reiniciará automáticamente y tendrás que hacerlo manualmente cada vez que actualices Jenkins o añadas nuevos plugins.

Por ejemplo, al ejecutar Jenkins en Docker, usa el siguiente comando para asegurarte de que el contenedor se reinicie automáticamente:

docker run -p 8080:8080 -p 50000:50000 -d --name jenkins --restart=always jenkins/jenkins:alpine

Este pequeño ajuste te ahorrará mucho tiempo y asegurará que Jenkins se reinicie correctamente tras cualquier cambio importante, como la instalación de plugins o actualizaciones.

Resumen de la instalación con Ubuntu

Bonus Track: Curso Gratuito de Jenkins - ¡Aprende desde Cero! 🚀

Si estás listo para dar el siguiente paso y profundizar aún más en Jenkins, te recomiendo este curso gratuito ofrecido por la Linux Foundation. Se llama Introduction to Jenkins (LFS167) y está diseñado para enseñarte todo lo que necesitas saber para implementar flujos de trabajo de Integración Continua (CI) y Entrega Continua (CD) utilizando Jenkins. 💻🔧

¿Quién debería tomar este curso?
Este curso es ideal para equipos que estén considerando usar Jenkins como herramienta CI/CD y busquen automatizar su proceso de entrega de software. También es perfecto para quienes necesiten pautas sobre cómo configurar un flujo de trabajo de CI/CD usando el servidor de automatización Jenkins.

Lo que aprenderás:

• El rol de Jenkins en el ciclo de vida del desarrollo de software.

• Cómo configurar y acceder al servidor de automatización Jenkins.

• Cómo construir tu software configurando y ejecutando varios tipos de proyectos Jenkins.

• Instalación y gestión de plugins.

• Cómo escalar y asegurar Jenkins.

¿Qué te preparará para hacer?
Al completar este curso, tendrás una comprensión sólida de:

• El papel de Jenkins en CI/CD.

• Cómo instalar Jenkins y gestionar proyectos.

• Integración con terceros mediante plugins.

• Cómo asegurar y escalar Jenkins para grandes proyectos.

Este curso te proporcionará todas las herramientas necesarias para convertirte en un experto en Jenkins y llevar tus pipelines al siguiente nivel. Además, es completamente gratuito. 🎓

Puedes comenzar el curso aquí:
Introducción a Jenkins (LFS167)

¡No pierdas la oportunidad de mejorar tus habilidades en CI/CD con Jenkins! 🌟

Conclusión:

Aunque todo esto pueda parecer complejo al principio, la magia de Jenkins está en la automatización. ¡No más scripts manuales, no más errores humanos! Jenkins facilita todo el proceso de desarrollo y despliegue, y lo mejor es que puedes empezar a trabajar con él en minutos.

La CI/CD no es solo para grandes empresas, es para cualquier desarrollador que quiera llevar su proceso de entrega de software al siguiente nivel. ¡Anímate a probar Jenkins y a ver cómo mejora tu flujo de trabajo!

¡Mantente Onfire! 🔥

Si te ha gustado este tutorial, ¡espera la parte II de "CI/CD The Series" sobre Jenkins! Mientras tanto, puedes seguirme en mis redes sociales para mantenerte al día con todo lo relacionado a DevOps, RoxsOps y CI/CD.

Sígueme en:

• GitHub: https://github.com/roxsross

• LinkedIn: https://www.linkedin.com/in/roxsross/

• Linktree: https://roxs.295devops.com

¡Hasta la próxima! 💪🚀

Requisitos previos

Para seguir este tutorial, asegúrate de tener lo siguiente instalado:

1. Terraform: Si aún no lo tienes instalado, puedes seguir las instrucciones de instalación aquí.

2. Docker: Para crear y gestionar contenedores, instala Docker desde aquí.

3. Conexión a Docker: Asegúrate de tener Docker en funcionamiento en tu máquina local para poder usarlo con Terraform.

4. Provider Docker: El proveedor Docker se utiliza para interactuar con contenedores e imágenes Docker. Aquí

Si ya tienes estos programas instalados, ¡estás listo para comenzar!

Paso 1: Preparación del entorno de Terraform

Lo primero es crear un archivo de configuración en Terraform. En este archivo, definiremos dos recursos principales:

• El provider Docker para conectarnos a tu instalación local de Docker.

• El provider local para gestionar archivos locales, como el archivo index.html que se usará en el contenedor.

• El recurso data "local_file" para referirnos al archivo index.html ya existente en el directorio.

Archivo index.html

Archivo main.tf

terraform {
  required_providers {
    docker = {
      source = "kreuzwerker/docker"
      version = "3.4.0"
    }
  }
}

provider "docker" {
}

provider "local" {}

data "local_file" "index_html" {
  filename = "${path.module}/index.html"
}

resource "docker_container" "web" {
  name  = "nginx-terraform"
  image = "nginx:latest"

  ports {
    internal = 80
    external = 8080
  }

  upload {
    file    = "/usr/share/nginx/html/index.html"
    content = data.local_file.index_html.content
  }
}

output "container_name" {
  value = docker_container.web.name
}
output "container_id" {
  value = docker_container.web.id
  description = "ID del contenedor Nginx"
}
output "container_image" {
  value = docker_container.web.image
  description = "Imagen del contenedor Nginx"
}


output "nginx_access_url" {
  value = "http://localhost:8080"
  description = "URL para acceder al servidor Nginx"
}

Explicación del código:

1. provider "docker": Configura la conexión con tu máquina local de Docker.

2. provider "local": Configura el uso de archivos locales. Aquí, lo utilizamos para referirnos al archivo index.html que ya existe en tu sistema.

3. data "local_file" "index_html": Este recurso se utiliza para referirse a un archivo local existente. El archivo index.html contendrá el mensaje que se mostrará cuando accedas a tu contenedor.

4. docker_container "web": Crea el contenedor usando la imagen nginx:alpine y sube el archivo index.html al contenedor en la ruta /usr/share/nginx/html/.

Paso 2: Inicialización y Validación de Terraform

Una vez que tengas el archivo main.tf listo, puedes proceder con los siguientes pasos:

1. Inicializar el entorno de Terraform: Este comando descarga los proveedores necesarios y prepara el entorno de trabajo.

    terraform init
   

2. Validar la configuración de Terraform: Este paso verifica que la configuración de Terraform sea correcta y no haya errores en el archivo de configuración.

    terraform validate
   

3. Formatear el código de Terraform: Antes de aplicar la configuración, puedes formatear tu archivo main.tf para que siga las mejores prácticas de estilo de código.

    terraform fmt
   

4. Generar un plan de ejecución: Este comando te muestra el plan de lo que Terraform va a hacer. Verás los recursos que se van a crear, modificar o eliminar.

    terraform plan
   

   Esto es útil para confirmar que todo está bien antes de aplicar los cambios.

5. Aplicar la configuración: Si todo está correcto, ejecuta el siguiente comando para crear los recursos y desplegar el contenedor Docker.

    terraform apply
   

   Terraform te pedirá que confirmes antes de proceder. Si todo está bien, escribe yes para confirmar.

Paso 3: Ver el contenedor en ejecución

Una vez que Terraform haya terminado de crear el contenedor, podrás acceder a él desde tu navegador. Abre un navegador y navega a:

http://localhost:8080

Verás la página:

Comprobación del contenedor Docker:

Si quieres asegurarte de que el contenedor está funcionando correctamente, puedes ejecutar el siguiente comando para ver los contenedores activos:

docker ps

Esto mostrará el contenedor terraform-web en ejecución en el puerto 8080.

Paso 4: Limpiar los recursos

Si ya no necesitas el contenedor y deseas liberar los recursos, puedes destruir todo lo creado con Terraform ejecutando:

terraform destroy

Esto eliminará tanto el contenedor como el archivo index.html y cualquier otro recurso que Terraform haya creado.

Paso a paso

Próximos Pasos: Mejorando la Estructura de tu Proyecto de Terraform

Una vez que hayas trabajado con este ejemplo básico, puedes mejorar la estructura de tu proyecto de Terraform para hacerlo más modular, eficiente y fácil de mantener. Aquí te doy algunas recomendaciones para organizar y escalar tu infraestructura con Terraform:

1. Uso de archivos de configuración separados

Para mantener tu proyecto organizado, puedes separar diferentes aspectos de tu infraestructura en varios archivos de configuración. Por ejemplo, puedes tener:

• variables.tf: Para definir variables que se utilizarán en tu configuración.

• outputs.tf: Para definir los outputs que necesitas mostrar después de aplicar la configuración.

• main.tf: Donde se define la mayoría de los recursos de infraestructura.

Esto ayuda a mantener tu proyecto limpio y más fácil de modificar, especialmente cuando trabajas en proyectos más grandes.

2. Gestionar valores con variables

Es recomendable utilizar variables en lugar de codificar valores directamente en tu archivo main.tf. De esta forma, puedes reutilizar los mismos valores en diferentes partes de tu configuración y cambiar los valores sin modificar directamente el código.

Ejemplo de un archivo variables.tf:

variable "container_name" {
  type    = string
  default = "terraform-web"
}

variable "nginx_image" {
  type    = string
  default = "nginx:alpine"
}

Y luego referenciar estas variables en tu main.tf:

resource "docker_container" "web" {
  image = var.nginx_image
  name  = var.container_name
}

3. Uso de backends remotos para gestionar el estado

Si trabajas en equipo o tienes múltiples entornos, es importante usar un backend remoto para gestionar el estado de Terraform. Usar backends como S3 o Terraform Cloud te permite almacenar el estado de manera centralizada, evitando problemas de inconsistencia cuando varias personas o sistemas interactúan con la infraestructura.

4. Planificación y validación constante

Recuerda siempre ejecutar el comando terraform plan antes de aplicar cambios en producción. Esto te permite visualizar los cambios que Terraform va a hacer y evita sorpresas.

Genera tu propio proyecto con IA

Si quieres crear tu propio entorno de Terraform y Docker, puedes usar este prompt para generar el código:

Prompt:

"Crear un contenedor Docker utilizando Terraform con la imagen nginx:alpine, donde se suba un archivo index.html con un mensaje personalizado. Utilizar los proveedores docker version 3.4.0 y local de Terraform para gestionar el contenedor y el archivo local. Asegúrate de que el contenedor exponga el puerto 8080 y muestre el contenido del archivo index.html cuando se acceda desde un navegador. Además, configura outputs para mostrar el nombre, y los puertos del contenedor después de aplicarlo."

Conclusión

En este tutorial, aprendiste a desplegar un contenedor Docker utilizando Terraform con la imagen nginx:alpine y a montar un archivo index.html con un mensaje personalizado. Esta es una excelente forma de comenzar a trabajar con Terraform y Docker, dos herramientas poderosas que te permiten automatizar la infraestructura y mejorar tu flujo de trabajo en DevOps.

Recursos adicionales

Si deseas profundizar más en Terraform y Docker, te dejo algunos recursos útiles:

• Documentación de Terraform

• Docker Provider de Terraform

• Documentación oficial de Docker

Recuerda, cada paso que des te acerca más a dominar la infraestructura como código. No importa si estás comenzando o si ya tienes experiencia, lo importante es seguir aprendiendo y explorando nuevas herramientas. ¡Lo mejor de todo es que nunca es tarde para empezar a transformar tu forma de trabajar con la tecnología! 🌟

Sígueme en Redes Sociales

Si te ha gustado este tutorial y quieres seguir aprendiendo sobre DevOps, Terraform, Docker y más, no dudes en seguirme en mis redes sociales:

• Twitter: @roxsross

• LinkedIn: Rossana Suarez

• YouTube: 295devops

• Instagram: @roxsross

¡No olvides compartir este post con tu comunidad! 💬 Si tienes dudas o sugerencias, ¡déjalas en los comentarios! Juntos seguimos aprendiendo y creciendo. 🚀

Herramientas como Amazon Q CLI, ChatGPT, Claude, DeepSeek y GitHub Copilot están aquí para transformar la forma en que trabajas. Al aprender a utilizar los prompts adecuados, los DevOps pueden automatizar tareas, diagnosticar problemas y optimizar la eficiencia en sus flujos de trabajo.

En este artículo, te comparto 20 prompts de IA altamente efectivos que pueden transformar la forma en que enfrentas los desafíos comunes de DevOps. Estas fórmulas prácticas, probadas en el campo, han ahorrado incontables horas, simplificado la depuración y ayudado a los equipos a cumplir sus plazos de manera más eficiente. ¡Vamos a ver cómo la IA puede potenciar tu flujo de trabajo!

1. Soluciona Errores en el Pipeline CI/CD Rápidamente

El Prompt:

"Analiza este error de pipeline CI/CD y sugiere soluciones:
[Pega los logs de error]
Contexto:

• Sistema CI/CD: GitLab

• Aplicación: Node.js

• Las pruebas pasan localmente pero fallan en el pipeline después de una actualización de dependencias."

2. Genera Documentación Clara de Infraestructura

El Prompt:

"Genera documentación para esta infraestructura:

• Componentes: [Lista de servicios, dependencias]

• Incluir: Visión general arquitectónica, componentes clave, flujo de datos, consideraciones de seguridad, puntos de fallo comunes."

3. Escribe Scripts para Tareas Repetitivas

El Prompt:

"Escribe un script bash que:

• Respaldos de bases de datos MySQL

• Comprime los respaldos

• Los sube a S3

• Elimina respaldos mayores de 5 días

• Envia un correo de estado con los logs de éxito/error."

4. Optimiza las Reglas de Monitoreo y Alertas

El Prompt:

"Optimiza las reglas de alertas de Prometheus:

• Problemas actuales: falsos positivos para picos de CPU, alertas faltantes para problemas de conexión a bases de datos.

• Entorno: Kubernetes, microservicios en Go/Java, PostgreSQL/Redis."

5. Genera Código Terraform para Infraestructura

El Prompt:

"Genera la configuración de Terraform para infraestructura AWS:

• S3 + CloudFront para recursos estáticos”

Opción compleja:

El Prompt:

"Genera la configuración de Terraform para infraestructura AWS:

• Tier web balanceado en dos zonas de disponibilidad

• Tier de aplicación con autoescalado y réplicas de lectura de RDS

• S3 + CloudFront para recursos estáticos

• Grupos de seguridad e IAM adecuados."

6. Diagnostica Problemas de Kubernetes al Instante

El Prompt:

"Diagnostica el siguiente problema de Kubernetes:

• Síntomas: Los Pods se caen continuamente y se reinician

• Logs de error: [pegar logs relevantes]

• Entorno: AWS EKS Kubernetes 1.30

• Qué he probado: Reiniciar despliegues, revisar presión de CPU/memoria."

7. Crea Runbooks para Respuestas a Incidentes

El Prompt:

"Crea un runbook de respuesta a incidentes para fallos de base de datos Postgres:

• Incluir: Pasos de evaluación, causas comunes, procedimientos de recuperación, escalación, análisis post-incidente."

8. Analiza Vulnerabilidades de Seguridad Rápidamente

El Prompt:

"Analiza la vulnerabilidad CVE-2023-XXXXX para nuestro entorno:

• Entorno: 2 microservicios (Node.js 20), Kubernetes, APIs expuestas detrás de Cloudflare.

• Proveer: Evaluación de exposición, servicios afectados, pasos inmediatos de mitigación, plan de remediación a largo plazo."

9. Optimiza los Costos en la Nube con IA

El Prompt:

"Analiza la asignación de costos en AWS y sugiere optimizaciones:

• Uso: Entornos de desarrollo 24/7, procesamiento nocturno, picos de tráfico, instancias EC2 infrautilizadas."

10. Escribe Postmortems sin Culpas

El Prompt:

"Ayúdame a escribir un postmortem sin culpas para este incidente:

• Detalles: Disrupción de servicio de 4 horas en sistema de procesamiento de pagos

• Causa raíz: Agotamiento del pool de conexiones a base de datos

• Factores contribuyentes: Picos de tráfico, monitoreo insuficiente

• Resolución: Aumento del tamaño del pool, se agregaron cortafuegos."

11. Automatiza la Creación de Tickets de Incidente

El Prompt:

"Crea un ticket de incidente para el equipo de soporte:

• Incidente: Fallo en la base de datos

• Impacto: 4 horas de inactividad en producción

• Causa raíz: Conexión al servicio de la base de datos no disponible

• Resolución: Reinicio del servicio y ajuste de la configuración."

12. Genera Un Plan de Continuidad del Negocio

El Prompt:

"Genera un plan de continuidad del negocio para nuestros servicios en la nube:

• Entorno: AWS, microservicios en Kubernetes

• Incluir: Estrategias de recuperación ante desastres, planes de redundancia y backups."

13. Revisa y Mejora la Configuración de Seguridad en AWS

El Prompt:

"Revisa la configuración de seguridad de nuestra infraestructura AWS:

• Entorno: EKS, RDS, S3, IAM

• Sugerir mejoras en las políticas de IAM, encriptación de datos y controles de acceso."

14. Automatiza la Gestión de Configuraciones con Ansible

El Prompt:

"Escribe un playbook de Ansible para configurar:

• Servidor web Nginx en Ubuntu 22.04

• Instalar y configurar Git, Docker, Node.js y PostgreSQL."

15. Mejora la Gestión de Logs en el Sistema

El Prompt:

"Mejora la configuración de gestión de logs en Kubernetes:

• Entorno: EKS, Fluentd, Elasticsearch y Kibana

• Sugerir mejoras en la retención de logs, agregación y visualización."

16. Configura Alertas Personalizadas en Slack

El Prompt:

"Crea una alerta personalizada para los errores de la base de datos:

• Enviar una notificación a Slack con el mensaje de error y el nombre de la base de datos afectada cuando un servicio esté caído más de 5 minutos."

17. Automatiza el Despliegue de Aplicaciones con Helm

El Prompt:

"Genera un archivo Helm para desplegar una aplicación web Node.js en Kubernetes:

• Incluir configuración para autoescalado, servicio de base de datos y despliegue de contenedores."

18. Optimiza la Configuración de GitLab CI/CD

El Prompt:

"Optimiza mi configuración de GitLab CI/CD:

• Incluir pipelines paralelos, caching adecuado y estrategias de despliegue para mejorar la velocidad y reducir el tiempo de ejecución."

19. Automatiza la Revisión de Código con Herramientas de IA

El Prompt:

"Automatiza la revisión de código con herramientas como SonarQube:

• Incluir reglas personalizadas para detectar vulnerabilidades y malas prácticas en el código."

20. Gestiona el Versionado de API de Forma Automática

El Prompt:

"Genera una estrategia de versionado de API utilizando OpenAPI y Swagger:

• Incluir control de versiones, cambios de endpoint y estrategia de migración."

Probemos los prompt:

Soluciona Errores en el Pipeline CI/CD Rápidamente:

Asistente de IA: Claude

"Analiza el siguiente error de pipeline CI/CD y sugiere soluciones:

Contexto:

• Sistema CI/CD: GitLab

• Aplicación: SonarQube

• Comando ejecutado:

$ sonar-scanner \
-Dsonar.projectKey=my-project \
-Dsonar.sources=. \
-Dsonar.host.url=https://sonarqube.295devops.com/ \
-Dsonar.login=xxxxxxxxxxx

• Error:

ERROR: Unrecognized option:  -Dsonar.sources=.
INFO: 
INFO: usage: sonar-scanner [options]
INFO: Options:
-D,--define <arg>     Define property
-h,--help             Display help information
-v,--version          Display version information
-X,--debug            Produce execution debug output

Respuesta de Claude:

Analizaré este error de pipeline CI/CD en GitLab con SonarQube y sugeriré soluciones adecuadas.

Análisis del error

El problema principal es que el comando de SonarQube está fallando con el error: ERROR: Unrecognized option: -Dsonar.sources=.

Este error indica que la opción -Dsonar.sources=. no es reconocida por el ejecutable SonarQube que se está utilizando en el pipeline, a pesar de que funciona correctamente en el entorno local.

Causas probables

1. Versión incompatible: Después de la actualización de dependencias, la versión de SonarQube Scanner en el pipeline podría ser diferente a la local.

2. Sintaxis incorrecta: La forma de pasar parámetros puede haber cambiado en la nueva versión.

3. Configuración de entorno: Posible conflicto entre variables de entorno o configuraciones predeterminadas.

4. Permisos insuficientes: El usuario de CI podría no tener permisos adecuados para acceder a las fuentes.

Genera Código Terraform para Infraestructura

Asistente Amazon q cli

Información sobre el asistente amazonq

El Prompt:

"Genera la configuración de Terraform para infraestructura AWS:

• S3 + CloudFront para recursos estáticos”

Respuesta de Amazon Q CLI

Te genera una salida en la terminal con el resultado

… y ademas si te parece bien, apruebas y te genera el archivo main.tf

Optimiza los Costos en la Nube con IA

Asistente ChatGPT

"Analiza la asignación de costos en AWS y sugiere optimizaciones:

• Uso: Entornos de desarrollo 24/7, procesamiento nocturno, picos de tráfico, instancias EC2 infrautilizadas."

Respuesta de ChatGPT:

Para analizar la asignación de costos en AWS y sugerir optimizaciones en el contexto de entornos de desarrollo 24/7, procesamiento nocturno, picos de tráfico y EC2 infrautilizadas, se deben considerar varias estrategias de optimización. Aquí te dejo un análisis y algunas recomendaciones:

Análisis de la situación:

1. Entornos de desarrollo 24/7:

   • Los entornos de desarrollo en AWS que están activos constantemente pueden resultar costosos debido al uso continuo de instancias EC2, almacenamiento y otros recursos.

   • Las instancias EC2 en ejecución sin necesidad de estar siempre activas generan costos innecesarios.

¡Recuerda siempre validar las respuestas generadas por la IA! Aunque estas herramientas son poderosas, la supervisión sigue siendo esencial para garantizar que las soluciones sean apropiadas para tu entorno específico. Asegúrate de revisar los resultados, aplicar tu criterio y realizar ajustes cuando sea necesario.

Cómo Usar la IA de Forma Responsable en DevOps

Si bien estos prompts de IA pueden aumentar tu productividad, es importante considerar la privacidad y la seguridad de los datos. Siempre sanitiza los logs antes de compartirlos con herramientas de IA para proteger la información sensible, como claves de API o datos personales.

Al integrar estos prompts de IA en tu flujo de trabajo DevOps, podrás resolver problemas complejos más rápido, automatizar tareas repetitivas y mejorar la eficiencia de tus procesos. La IA no reemplaza tu experiencia, pero ciertamente la amplifica, permitiéndote enfocarte en tareas de mayor nivel mientras ella se encarga del trabajo rutinario.

Si te ha parecido útil este contenido, no dudes en compartirlo con tu comunidad.

¡Sigue mis redes sociales para más consejos y recursos de DevOps!

• Twitter

• LinkedIn

• Instagram

• YouTube

No necesitás una cuenta de AWS ni pagar por infraestructura. En este post te muestro cómo levantar una aplicación de votación con Flask usando Docker y DynamoDB Local, simulando un entorno cloud en tu propia máquina.

¿Qué vamos a construir?

Una pequeña app REST que te permite enviar votos, consultarlos, eliminarlos y almacenarlos usando una base de datos NoSQL como DynamoDB. Y todo esto lo vamos a ejecutar de forma local.

Requisitos previos

Antes de comenzar, asegurate de tener instalado:

• Docker y Docker Compose que viene incluidas en Docker Desktop

• Python 3.x

• (Opcional) AWS CLI

• Revisar la documentación sobre DynamoDB

• Sobre DynamoDB Local

• Toda la Fuerza de la IA: Amazon Q, ChatGPT, deepseek, RoxsGPT 🤭

🐍 Configurar un entorno virtual en Python (opcional pero recomendado)

Para mantener tu entorno limpio y evitar conflictos de dependencias entre proyectos, podés crear un entorno virtual usando venv. Es una buena práctica, sobre todo cuando trabajás con Flask u otras librerías.

1. Crear el entorno virtual

Desde la raíz del proyecto, ejecutá:

python3 -m venv venv

Esto creará una carpeta llamada venv con un entorno aislado de Python.

2. Activar el entorno virtual

• En Linux/macOS:

source venv/bin/activate

• En Windows (CMD):

venv\Scripts\activate

• En PowerShell:

venv\Scripts\Activate.ps1

Una vez activado, verás el prefijo (venv) en tu consola.

3. Instalar dependencias

Con el entorno activo, podés instalar las librerías del proyecto (por ejemplo, Flask y Boto3):

pip install -r requirements.txt

⚠️ Si no tenés un archivo requirements.txt, podés instalar manualmente con pip install flask boto3 y luego generar el archivo con pip freeze > requirements.txt.

🗃️ ¿Qué es DynamoDB (y por qué lo usamos en este proyecto)?

Amazon DynamoDB es un servicio de base de datos NoSQL de alto rendimiento ofrecido por AWS. A diferencia de una base relacional (como MySQL o PostgreSQL), DynamoDB almacena los datos en forma de tablas con claves primarias, pero sin esquemas rígidos, lo que lo hace ideal para aplicaciones modernas y escalables.

🚀 Características clave:

• Es serverless: no necesitás preocuparte por servidores ni escalabilidad.

• Permite consultas ultra rápidas a gran escala.

• Se usa mucho en arquitecturas modernas, como microservicios y apps serverless.

🤓 ¿Y qué es DynamoDB Local?

Para no depender de internet ni gastar créditos de AWS mientras aprendés, podés correr DynamoDB Local en tu máquina, que emula el comportamiento real del servicio. ¡Perfecto para desarrollos y pruebas locales!

🧱 Arquitectura de la aplicación

Tu stack ahora se compone de tres componentes principales:

1. Frontend (HTML + JS)

   • Vive dentro del servicio Flask (vote) en la carpeta templates/.

   • Permite a los usuarios votar y ver resultados desde el navegador.

2. Backend (Flask + Python)

   • Expone una API REST (/api/votes, /api/stats, etc.).

   • Sirve el HTML y recibe interacciones del usuario.

   • Se comunica con DynamoDB Local a través de Boto3.

3. DynamoDB Local (Base de datos NoSQL)

   • Ejecutada en un contenedor independiente ó puedes correrlo local.

   • Guarda votos persistidos.

   • Inicializada al inicio con init_db.py.

🔁 Flujo de interacción

1. El usuario entra a http://localhost:8080 y ve la interfaz de votación.

2. Al hacer clic en “Votar por Gatos”, el navegador llama al endpoint /api/cats.

3. Flask procesa la petición y actualiza DynamoDB Local.

4. La interfaz recupera los votos actualizados con /api/getvotes y muestra los resultados.

5. Todo esto corre localmente con Docker, sin conexión a AWS real.

💻 Repositorio del Código

Cloná este repositorio desde GitHub:

https://github.com/roxsross/workshop-ecs

Y accedé a la carpeta del proyecto:

git clone https://github.com/roxsross/workshop-ecs
cd workshop-ecs

⚙️ Entendiendo los servicios

Esta aplicación se compone de dos contenedores definidos en docker-compose.yml:

• vote: aplicación en Flask que maneja los votos.

• vote-db: contenedor que ejecuta DynamoDB Local.

La app se compone de dos servicios definidos en compose.yml:

• vote: Servicio en Flask que recibe y gestiona los votos.

• vote-db: Contenedor que ejecuta DynamoDB Local.

services:
  vote:
    build:
      context: .
    ports:
      - "8080:8080"
    environment:
      - DDB_AWS_REGION=us-east-1
      - DDB_TABLE_NAME=votes
      - ENV=local
    depends_on:
      - vote-db

  vote-db:
    image: amazon/dynamodb-local
    ports:
      - "8000:8000"
    environment:
      - AWS_ACCESS_KEY_ID=FAKE
      - AWS_SECRET_ACCESS_KEY=FAKE

El contenedor de Flask se comunica con DynamoDB Local utilizando credenciales falsas, ya que este modo de ejecución no necesita autenticación real.

Para manejos de variables de entorno te recomiendo lo siguiente: https://docs.docker.com/compose/how-tos/environment-variables/set-environment-variables/

🧱 Construir los Contenedores

Usá el siguiente comando para construir los servicios con Docker Compose:

docker compose build

🔌 Inicializar DynamoDB Local

Primero levantá el servicio de base de datos:

docker compose up vote-db -d

Luego, ejecutá el script init_db.py para crear la tabla y pre-cargar datos:

python init_db.py

📋 Ejemplo de salida esperada:

INFO - Creando tabla votes...
INFO - Tabla creada correctamente.
INFO - Inicializando contador para 'cats'
INFO - Inicializando contador para 'dogs'

Este paso es clave para que la app funcione correctamente.

🚀 Levantar la Aplicación

Ahora sí, levantá todo el stack local:

docker compose up -d

La aplicación Flask estará disponible en:
👉 http://localhost:8080

🔗 Endpoints Disponibles

Podés interactuar con la app vía API REST:

1. GET /api/votes

Obtiene todos los votos almacenados.

curl http://localhost:8080/api/getvotes

2. GET /api/cats

Gestionar un voto a la opción gatos

curl -X GET http://localhost:8080/api/cats

3. GET /api/dogs

Elimina un voto por ID.

curl -X GET http://localhost:8080/api/dogs

4. GET /api/reset

Reinicia los votos de "cats" y "dogs" a 0.

curl -X POST http://localhost:8080/api/reset

5. GET /api/history

Obtiene el historial de votos para una entidad específica (por ejemplo, "cats" o "dogs"). Puedes limitar el número de registros con el parámetro limit

curl -X GET "http://localhost:8080/api/history/cats?limit=5"

6. GET /api/stats

Devuelve estadísticas como el total de votos, la distribución de votos y el líder actual.

curl -X GET http://localhost:8080/api/stats

🧪 Probar la Conexión con AWS CLI (opcional)

Si querés ver las tablas directamente desde AWS CLI:

export AWS_ACCESS_KEY_ID=FAKE
export AWS_SECRET_ACCESS_KEY=FAKE
aws dynamodb list-tables --endpoint-url http://localhost:8000

🧹 Apagar y Limpiar los Contenedores

Cuando termines, podés apagar todo con:

docker compose down

Y si querés eliminar volúmenes:

docker compose down --volumes

🐳 ¿Docker te parece complejo?

No te preocupes, al principio a todos nos pasó. Pero te prometo que con práctica se vuelve una de tus herramientas favoritas.

Si querés dar tus primeros pasos y entender bien cómo funciona, te dejo este workshop oficial para empezar:

👉 Iniciá con Docker – Workshop oficial de Docker

Animate a practicar, romper cosas, reconstruir y aprender. ¡Así se crece! 💪🚀

🎥 Mirá el video corriendo el ejercicio

🌱 Reflexión Final

Empezar en local no significa quedarse atrás.
💻 Aprender a levantar tu propia app, gestionar una base de datos y simular un entorno cloud es una habilidad clave.

Lo que construís en tu máquina hoy... 🔥 mañana puede escalar a producción en AWS, ECS o donde vos decidas.

📁 Recursos

• Código fuente: https://github.com/roxsross/workshop-ecs

• Documentación oficial de DynamoDB Local

Conclusión

Empezar a desarrollar en local es uno de los mejores caminos para aprender cómo funcionan los servicios reales. Esta guía te permite practicar la interacción entre una aplicación en Flask y una base de datos NoSQL como DynamoDB, sin necesidad de subir nada a la nube.

Lo que hoy ejecutás en tu laptop/Notebook, mañana puede escalar a servicios como AWS ECS o Fargate. Pero antes de despegar, es importante entender cómo funciona todo desde el piso.

📲 Seguime y sumate a la comunidad

Si te gustó esta guía, compartila con tu comunidad. Y si querés más contenido como este, podés seguirme en mi canal de Youtube 295DEVOPS, donde subo tutoriales y workshops enfocados en DevOps, cloud y desarrollo práctico.

• 💜 YouTube (tutoriales y charlas): 295DEVOPS

• 🐦 Twitter/X: @roxsross

• 📸 Instagram: @roxsross

• 📝 Blog: blog.295devops.com

• 🐙 GitHub: github.com/roxsross

¡Gracias por llegar hasta acá! Y recordá: lo que hoy probás en local, mañana lo podés escalar a lo grande

Nos vemos!

El dilema del profesional tech

Soy Roxs, DevOps desde hace años, y he pasado por muchas etapas en mi carrera: desde mis inicios como desarrolladora hasta convertirme en una especialista en DevOps. He invertido innumerables horas en aprender herramientas a fondo y perfeccionar mi conocimiento. Pero, de repente, algo cambia en la industria: surgen nuevas tecnologías, y ese conocimiento que tanto esfuerzo costó obtener comienza a sentirse insuficiente.

Hace poco tuve una charla sincera con otros profesionales del sector, y surgió algo que muchos pensamos pero pocos decimos en voz alta: la presión constante por absorber nuevos conocimientos técnicos, mientras que las habilidades humanas como la comunicación efectiva, la resolución de problemas o el trabajo en equipo suelen quedar relegadas.

La montaña infinita de conocimientos

Pensá por un segundo en todo lo que una persona dedicada al DevOps tiene que saber hoy:

• Detalles específicos de proveedores en la nube (AWS, Azure, GCP).

• Kubernetes y orquestación de contenedores.

• Infraestructura como código (Terraform, CloudFormation).

• Pipelines de integración y despliegue continuo (CI/CD).

• Lenguajes de programación y scripting.

• Sistemas operativos.

• Redes y seguridad informática.

• Herramientas de monitoreo y observabilidad.

• Control de versiones.

• Inteligencia Artificial aplicada al desarrollo (IA Developer Experience)

La IA está revolucionando la manera en que trabajamos y aprendemos, potenciando nuestras habilidades y cambiando las expectativas del mercado. Cada vez más, herramientas impulsadas por IA como GitHub Copilot, Amazon Q y diversas soluciones de inteligencia artificial están redefiniendo la experiencia del desarrollador y automatizando tareas repetitivas, permitiéndonos enfocarnos en lo verdaderamente importante: resolver problemas de manera creativa y efectiva.

¡Y la lista sigue creciendo! Como decía alguien hace poco: "Cada vez que parpadeo aparece un nuevo framework, servicio en la nube o mejor práctica que supuestamente debo dominar. ¡Es una locura!"

Cambiando el enfoque: Aprender es nuestro trabajo

En medio de tanta frustración, surgió una idea poderosa que cambió mi manera de ver las cosas: "Nos pagan por aprender".

Este enfoque transforma el aprendizaje continuo en algo esencial y emocionante. Como dijo una colega con 30 años de experiencia: "Mi habilidad más valiosa es la capacidad de aprender sobre la marcha".

Otra compañera DevOps coincidió: "Nunca vamos a dejar de aprender herramientas nuevas… nuestro trabajo es básicamente ‘descubrir cómo hacerlo’. Y justamente eso me encanta, porque siempre me empuja a crecer".

El arte de olvidar

Algo curioso que surgió de estas conversaciones es que olvidar no solo es inevitable, sino beneficioso.

Una ingeniera de fiabilidad (SRE) comentó algo que resonó conmigo profundamente: "No intento retener todo en la cabeza, es inútil. Prefiero fortalecer mi habilidad para resolver problemas por mí misma. De hecho, olvidar cosas es la mejor manera de perfeccionarme en esto".

Esto puede sonar contradictorio, pero tiene mucho sentido. La industria tecnológica no premia a quienes memorizan comandos o configuraciones, sino a quienes saben resolver problemas con rapidez y eficacia.

Mis herramientas para gestionar el exceso de información

En mi experiencia, hay ciertas técnicas que me ayudan mucho a no ahogarme en información:

• Notas detalladas y buscables: Tomo notas constantemente, sabiendo que probablemente olvidaré ciertos detalles en días o semanas.

• Enfocarme en los fundamentos: Las bases como Linux, redes, virtualización, contenedores, kuberntenes, roxsops, permanecen constantes y siempre útiles.

• Documentación organizada: Utilizo notion y guardo documentación detallada para futuras referencias rápidas.

• Repositorios personales: Mantengo ejemplos básicos y plantillas de infraestructura y desarrollo en repos personales, como GitHub o GitLab.

Lo humano también cuenta (¡y mucho!)

A pesar de que las demandas técnicas son intensas, nunca subestimes la importancia de las habilidades interpersonales. Una buena compañera, una comunicación clara y una actitud proactiva en los momentos difíciles son cosas que realmente se valoran en equipos saludables.

Como dijo una colega líder de plataforma con décadas de experiencia: "Una buena empresa valora que seas una persona solidaria, que puedas comunicarte con claridad, y que estés dispuesta a ayudar cuando las cosas se ponen difíciles".

Buscando equilibrio

Entonces, ¿cómo evitar quemarse frente a tantos cambios tecnológicos?

• Aceptar lo imposible: No podemos saber todo, y eso está bien. No ejerzas una presión irreal sobre vos.

• Aprender a aprender: Desarrollá métodos eficientes para aprender nuevas tecnologías rápidamente, empezando simple y avanzando en pequeños pasos.

• Establecer límites: No dediques todo tu tiempo libre exclusivamente al aprendizaje técnico; el equilibrio es clave para mantener el bienestar.

• Elegir bien dónde trabajar: Elegí empresas que valoren tu capacidad para aprender y resolver problemas por sobre la cantidad absoluta de conocimiento acumulado.

Abrazando el cambio continuo

Quizás lo más lindo de trabajar en tecnología es justamente eso: que nunca deja de cambiar. Lo que para algunas personas es estrés, para otras es justamente lo que hace apasionante esta carrera.

Como escuché hace poco: "Esta es una de las pocas profesiones que constantemente cambia. Para mí, eso significa aprender algo nuevo cada día. Por eso nunca me aburro".

Mirando hacia adelante

El panorama tecnológico seguirá cambiando, surgirán nuevas herramientas, otras quedarán atrás. Pero en medio de estos cambios constantes, hay habilidades que nunca pierden valor: la curiosidad, la adaptabilidad y la capacidad para aprender.

La próxima vez que te sientas desbordada o desbordado por otra tecnología que "deberías" dominar, recordá: la verdadera habilidad no es saberlo todo, sino saber cómo resolver cualquier cosa que se presente.

¡Sigamos disfrutando de este camino lleno de aprendizajes y aventuras tecnológicas!