🚨 El Problema: Practicar DevOps sin miedo a la factura

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