Search for a command to run...
¿Alguna vez soñaste con tener un laboratorio DevOps totalmente tuyo, sin depender de la nube y sin gastar ni un centavo? Este es tu momento.
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 🔥
No comments yet. Be the first to comment.
Cada minuto que un dev espera un pipeline es un minuto de foco perdido. Multiplicalo por cada commit, cada MR, cada persona del equipo... y de repente ese pipeline de 25 minutos es el impuesto más car
Si venís siguiendo mi contenido hace rato, sabés que hay una frase que repito hasta el cansancio: la mejor forma de aprender cloud es rompiendo cosas en la cloud. El problema siempre fue el mismo: par
Si me seguís hace un tiempo ya sabés que estoy metida hasta con todo el power con Kiro IDE: demos, integraciones con GitLab CI, bootcamp y todo lo que se te ocurra. Así que cuando me crucé con este po
Build with fire, deploy with power 🔥
Por @roxsross · roxs.dev Introducción ¿Cuántas veces mergeaste un cambio de infraestructura y te enteraste del problema en producción? ¿Cuántos security groups abiertos al mundo, cuántos IAM con * en
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 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.
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.
💸 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.
💻 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.
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.
Descargá el .dmg desde el sitio de Docker.
Instalalo en “Aplicaciones”.
Abrilo y esperá que el ícono de la barra esté listo.
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.
docker run hello-world
Deberías ver un mensaje de “Hello from Docker!”
Minikube levanta un cluster Kubernetes de un solo nodo en tu compu.
Descargá el instalador desde Minikube Releases.
Ejecutalo.
Abrí CMD como administrador y corré:
minikube start --driver=docker
brew install minikube
minikube start --driver=docker
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
minikube status
minikube dashboard
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
kind create cluster --name devops-lab
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
kubectl get pods --all-namespaces
VirtualBox
Vagrant
Verificá:
vboxmanage --version
vagrant --version
mkdir mi_lab && cd mi_lab
vagrant init ubuntu/focal64
vagrant up
vagrant ssh
Listo, ¡tenés Ubuntu corriendo!
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
brew install ansible
sudo apt update
sudo apt install software-properties-common
sudo apt-add-repository --yes --update ppa:ansible/ansible
sudo apt install ansible
Usá Ubuntu vía WSL. Luego instalás Ansible como en Linux.
hosts:[local]
localhost ansible_connection=local
playbook.yml:---
- name: Prueba de Ansible
hosts: local
tasks:
- name: Mostrar mensaje
debug:
msg: "¡Ansible funciona!"
ansible-playbook -i hosts playbook.yml
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/
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.
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.
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).
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)
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"
}
terraform init
terraform apply
vagrant up
ansible-playbook -i inventory playbook.yml
Navegá a http://localhost:8080 y deberías ver la página por defecto de Nginx.
vagrant ssh web
vagrant ssh db
vagrant destroy -f
terraform destroy
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
....
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.
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