🎮 Crea tu Laboratorio DevOps Local (¡Sin Gastar un Peso!)


🚨 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
Activá la virtualización en la BIOS.
Descargá Docker Desktop.
Durante la instalación, habilitá WSL2.
Reiniciá y abrí Docker Desktop. Esperá que la ballenita deje de moverse.
Para Mac
Descargá el
.dmg
desde el sitio de Docker.Instalalo en “Aplicaciones”.
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
Descargá el instalador desde Minikube Releases.
Ejecutalo.
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
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:
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!
(Opcional) Crear un Vagrant Boxes personalizada a partir de ISO
- Descargar ISO de Ubuntu :
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:
- Archivo
hosts
:
[local]
localhost ansible_connection=local
playbook.yml
:
---
- name: Prueba de Ansible
hosts: local
tasks:
- name: Mostrar mensaje
debug:
msg: "¡Ansible funciona!"
- 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
- Inicializar Terraform y generar los archivos
terraform init
terraform apply
- Levantar las VMs con Vagrant
vagrant up
- Aplicar la configuración con Ansible
ansible-playbook -i inventory playbook.yml
- Abrir la app web
Navegá a http://localhost:8080
y deberías ver la página por defecto de Nginx.
- Tambien podes probar las maquinas virtuales con vagrant
vagrant ssh web
vagrant ssh db
- 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
yservice.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
Subscribe to my newsletter
Read articles from Rossana Suarez directly inside your inbox. Subscribe to the newsletter, and don't miss out.
Written by

Rossana Suarez
Rossana Suarez
Soy Roxs 👩💻| Software Developer | DevOps | DevSecOps | en @295DevOps 🖼 Content Creator. No se puede crecer si no estas dispuesto a saltar a la zona de peligro 🔥