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

## 🚨 El Problema: Practicar DevOps sin miedo a la factura

**<mark>A Sofía</mark>**<mark>, 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.</mark>

“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.

![Using AWS : r/ProgrammerHumor](https://i.redd.it/lmyrdzu7twc91.jpg align="center")

**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](https://www.docker.com/products/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](https://docs.docker.com/engine/install/)

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1748016916055/06bf0a87-ab92-4ad5-b4be-f14dc5fa1c86.png align="center")

```bash
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:

```bash
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](https://github.com/kubernetes/minikube/releases).
    
2. Ejecutalo.
    
3. Abrí CMD como administrador y corré:
    

```bash
minikube start --driver=docker
```

#### En macOS (con Homebrew)

```bash
brew install minikube
minikube start --driver=docker
```

#### En Linux:

```bash
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:

```bash
minikube status
minikube dashboard
```

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

[Sobre Kind](https://kind.sigs.k8s.io/docs/user/quick-start/#installing-with-a-package-manager)

#### Instalación universal:

```bash
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:

```bash
kind create cluster --name devops-lab
```

---

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

### [Instalación](https://kubernetes.io/docs/tasks/tools/):

* **Windows**: `choco install kubernetes-cli`
    
* **macOS**: `brew install kubectl`
    
* **Linux**:
    

```bash
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:

```bash
kubectl get pods --all-namespaces
```

---

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

### Requisitos:

* **VirtualBox**
    
* **Vagrant**
    

#### Instalación en cualquier sistema:

1. [Descargá VirtualBox](https://www.virtualbox.org/wiki/Downloads)
    
2. [Descargá Vagrant](https://developer.hashicorp.com/vagrant/downloads)
    
3. Verificá:
    

```bash
vboxmanage --version
vagrant --version
```

---

### Crear tu primera VM:

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

Listo, ¡tenés Ubuntu corriendo!

[Listado de Boxes](https://portal.cloud.hashicorp.com/vagrant/discover)

<div data-node-type="callout">
<div data-node-type="callout-emoji">💡</div>
<div data-node-type="callout-text">Si usas arquitectura MAC m1,m2,etc que trabaja con arm64, ya virtualbox lo soporta y además en los boxes revisa que tenga este soporte sino te dará error.</div>
</div>

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

1. **Descargar ISO de Ubuntu** :
    

* Vaya a [https://ubuntu.com/download/desktop (o servidor)](https://ubuntu.com/download/desktop)
    
* 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** :

```bash

 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:

```bash
brew install ansible
```

### Linux (Ubuntu):

```bash
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`:
    

```ini
[local]
localhost ansible_connection=local
```

2. `playbook.yml`:
    

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

3. Ejecutá:
    

```bash
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**:
    

```bash
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`:

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

```bash
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:

```bash
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`](http://main.tf):

```bash
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**
    

```bash
terraform init
terraform apply
```

2. **Levantar las VMs con Vagrant**
    

```bash
vagrant up
```

3. **Aplicar la configuración con Ansible**
    

```bash
ansible-playbook -i inventory playbook.yml
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1748022420890/555e5946-d394-4f48-bc40-b3506ccefdd2.png align="center")

4. **Abrir la app web**
    

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

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1748022178198/020b910e-6c4f-4a26-aade-8e2dff868822.png align="center")

5. Tambien podes probar las maquinas virtuales con vagrant
    

```bash
vagrant ssh web
vagrant ssh db
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1748022843730/34cf70e5-2553-4a7b-be8f-b9e9f667ba15.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1748022873833/22c8db87-0034-411d-b0c1-bef559668f60.png align="center")

5. **Destruir cuando termines**
    

```bash
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](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](https://github.com/spurin/diveintoansible-lab)

```bash
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.
    

<div data-node-type="callout">
<div data-node-type="callout-emoji">💡</div>
<div data-node-type="callout-text">…. se viene un post extra sobre esto.</div>
</div>

---

## 🧭 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
    

<div data-node-type="callout">
<div data-node-type="callout-emoji">💡</div>
<div data-node-type="callout-text">Ahora te toca a vos: <strong>rompé cosas, arreglalas, y volvé a intentar.</strong> Esa es la magia del aprendizaje DevOps.</div>
</div>