Crear un entorno de desarrollo usando Vagrant.

Hoy quiero ponerme la meta de comenzar aprender algo nuevo. Quizás swarm, kubernetes ….

¡Pero, 🙁 no tengo recursos! Solo una laptop común con un poco de RAM.

¡Le ha sucedido! Si es así Ud. no es el único. No se desanime. Pues llega a su rescate Vagrant.

¿Qué es Vagrant?

Vagrant es un software de código abierto para crear y mantener entornos de desarrollo. Intenta simplificar la gestión de la configuración de software de la virtualización para aumentar la productividad del desarrollo o aprendizaje.

La configuración de la máquina virtual es un simple fichero de texto plano, podemos incluir este fichero en nuestro repositorio en el control de versiones, junto con el resto del código del proyecto. De esta manera, un nuevo desarrollador o un amigo que se incorpore simplemente tendrá que clonar el repositorio del proyecto y ejecutar Vagrant para tener el entorno de desarrollo montado y funcionando en cuestión de minutos.

Crearemos un entorno de desarrollo reproducible. Tendrá todo lo necesario para aprender, probar. Mostraremos lo fácil que es levantar un clúster docker swarm. Aplicando este mismo conocimiento podrías reproducir el entorno que desees incluso un clúster de kubernetes para probar cosas. Si usas tus habilidades de ingenio podrás sacar el máximo de provecho con lo que dispones.

Requerimientos:

• Disponer de conexión a internet.
• Una computadora.

Para no hacer tan largo el tutorial usaremos el proveedor por defecto que es Virtualbox*. Pero puedes usar otros tal como VMware,  Hyper-V, KVM, AWS y si tienes pocos recursos libvirt.

Nota: Estaré usando en esta guía el box de Bento/Ubuntu 20.04 tamaño 512.9 MB. Puede visitar el sitio para escoger la instalación acorde a tu Sistema operativo.

¿Quieres hacer y usar tu propio box?  Al final de este post te doy un resumen de los pasos a seguir.

Instalación:

En Ubuntu/Debian lo instalaremos así:

•  Desde el repo oficial de hashicorp

curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install vagrant

• Instalando desde el repo de UCLV desde la red de cuba

sudo apt install vagrant

Verifiquemos la versión:

vagrant version

Nota: El proveedor que usaremos será Virtualbox. Si no lo tienes instalado debería hacerlo ahora. No es nuestro objetivo enseñar a instalarlo. En internet encontraras las guías para eso. Pero normalmente es solo ejecutar:

sudo apt install virtualbox

Box

• La lista de box las podrás encontrar aquí.

Si deseas descargar el box manualmente use este link.

Para cargarlo ejecutamos el siguiente comando.

vagrant box add bento/ubuntu-20.04 virtualbox.vbox

Si lo vas a bajar directo de internet

vagrant box add bento/ubuntu-20.04

Llegado a este punto vamos a crear nuestro entorno de desarrollo.

Nota: Si prefieres saltarte el paso y descargar todo puedes hacerlo clonando el recurso.

Entorno de desarrollo

• Creamos la carpeta de trabajo

mkdir vagrant_swarm_desde_base
cd vagrant_swarm_desde_base

Estructura del proyecto de como debe quedar.

• Creamos el archivo Vagrantfile

nano Vagrantfile

Pegue dentro estas líneas:

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

## vagrant parameters
# Use this BOX bento/ubuntu-20.04

BOX = "bento/ubuntu-20.04"

##     Proxy and port
##     If you do not use proxy, leave empty what is in quotes if not use proxy
##   Examples
# PROXY_IP =  ""
# PROXY_PORT = ""
# 
## You use proxy
# PROXY_IP =  "192.0.0.1"
# PROXY_PORT = "8080"
#############################################

PROXY_IP =  "192.168.1.20"
PROXY_PORT = "3128"

# master node parameters set IP RAM and CPU
MANAGER_IP = "10.8.100.10"
MANAGER_CPU = "1"
MANAGER_RAM = "2048"
# node parameters set  RAM and CPU
WORKER_IP = "10.8.100."
WORKER_CPU = "1"
WORKER_RAM = "1024"
# Number node create
WORKER_COUNT = 2

## general vagrant configurations
Vagrant.configure("2") do |config|
  config.vm.box = BOX
  config.vm.box_check_update = false
  config.vm.provision "shell", :path => "provision/provision_base.sh",
    env: {
        "PROXY_IP" => PROXY_IP,
        "PROXY_PORT" => PROXY_PORT
      }

  # master node configuration
  config.vm.define "manager" do |manager|
    manager.vm.hostname = "manager"
    manager.vm.network "private_network", ip: MANAGER_IP
    manager.vm.network "public_network", bridge: "wlan0"
   # en esta session es donde especificamos nuestro proveedor
    manager.vm.provider :virtualbox do |vb|
      vb.customize ["modifyvm", :id, "--cpus", MANAGER_CPU]
      vb.customize ["modifyvm", :id, "--memory", MANAGER_RAM]
    end
    manager.vm.provision :shell, :path => "provision/manager.sh",
      env: {
        "MANAGER_IP" => MANAGER_IP
      }
  end

  # node configuration
  (1..WORKER_COUNT).each do |i|
    config.vm.define "worker#{i}" do |worker|
      worker.vm.hostname = "worker#{i}"
      worker.vm.network "private_network", ip: WORKER_IP + "#{i + 10}"
      worker.vm.provider :virtualbox do |vb|
        vb.customize ["modifyvm", :id, "--cpus", WORKER_CPU]
        vb.customize ["modifyvm", :id, "--memory", WORKER_RAM]
      end
      worker.vm.provision :shell, :path => "provision/worker.sh",
      env: {
        "MANAGER_IP" => MANAGER_IP
      }
    end
  end
end

• Creamos el archivo provision_base

mkdir provision
cd provision

nano provision_base.sh

Pegue dentro estas líneas:


#!/usr/bin/env bash

sudo sed -i 's/archive.ubuntu.com/repos.uclv.edu.cu/' /etc/apt/sources.list
sudo sed -i 's/security.ubuntu.com/repos.uclv.edu.cu/' /etc/apt/sources.list

# Add authorized_keys uncomment below 
# echo "ssh-rsa " >> /home/vagrant/.ssh/authorized_keys
# echo "ssh-rsa ">> /home/vagrant/.ssh/authorized_keys

### Check if PROXY_Ip is NULL

if [ ! -n "${PROXY_IP}" ]
then
echo "Not use proxy"
else
sudo cat <<EOF > /etc/apt/apt.conf.d/proxy.conf
Acquire {
HTTP::proxy "http://${PROXY_IP}:${PROXY_PORT}";
HTTPS::proxy "http://${PROXY_IP}:${PROXY_PORT}";
}
EOF
fi


# change config sshd
sudo sed -i 's/PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
sudo sed -i 's/PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config
sudo service sshd restart

# actualizando

sudo apt update && sudo apt upgrade -y

# Instalando docker docker-compose

sudo apt install docker.io docker-compose -y

# creando daemon.json

sudo bash -c 'cat << EOF > /etc/docker/daemon.json
{
"registry-mirrors": [
"https://docker.uclv.cu"
]
}
EOF'

sleep 5

# Reiniciando docker
echo "Reiniciando servicio docker"
sudo service docker reload

sleep 5

# add vagrant into docker group
usermod -aG docker vagrant

• Creamos el archivo manager

nano manager.sh

Pegue dentro estas líneas:

#!/usr/bin/env bash

docker swarm init --advertise-addr ${MANAGER_IP}
docker swarm join-token -q worker > /vagrant/token

• Creamos el archivo worker

nano worker.sh

Pegue dentro estas líneas:

#!/usr/bin/env bash
sleep 10
docker swarm join --token `cat /vagrant/token` ${MANAGER_IP}:2377

Explicación de algunos ajustes que quedan a su valoración:

1. En el archivo Vagranfile usted puede ajustar estos valores que los declare como variables:

 Si usa proxy escriba la ip del mismo y el puerto. Sino deje solamente las comillas

PROXY_IP = ""
PROXY_PORT = ""

Puedes ajustar los recursos que serán asignados al manager y a los nodos

MANAGER_CPU = "1"
MANAGER_RAM = "2048"
WORKER_CPU = "1"
WORKER_RAM = "1024"

Puedes ajustar la cantidad de worker que deseas que se creen y unan al clúster swarm

WORKER_COUNT = 2

Puedes ajustar la tarjeta que usaras como bridge. Si no tienes dhcp en tu red puedes asignar la ip directamente de esta forma:

vm.network :public_network , ip: "10.0.0.1" , bridge: "wlan0"
manager.vm.network "public_network", bridge: "wlan0"

2. En el archivo provision_base.sh usted puede ajustar estos valores 

Si deseas usar el repo oficial de Ubuntu elimine la línea 3 y 4

sudo sed -i 's/archive.ubuntu.com/repos.uclv.edu.cu/' /etc/apt/sources.list
sudo sed -i 's/security.ubuntu.com/repos.uclv.edu.cu/' /etc/apt/sources.list

Si no desea usar un registry mirror o cambiar el que tenemos declarado ajuste las líneas 41 al 47

sudo bash -c 'cat << EOF > /etc/docker/daemon.json

{
   "registry-mirrors": [
   "https://docker.uclv.cu"]
}
EOF'

Levantamos nuestro entorno de desarrollo.

vagrant up

El resultado sería algo así.

Tardará unos minutos en dependencia de la velocidad del internet y de la cantidad de nodos worker que le hayamos configurado.

Validemos que tengamos corriendo 1 manager y los nodos que le pusimos en el archivo Vagranfile en  WORKER_COUNT =  (número de línea 32).

vagrant status

Conectarnos al manager

vagrant ssh manager

Swarm

En un clúster de Swarm existen dos tipos de nodo, los Manager y los Worker.

Manager: Es el responsable de gestionar los nodos del cluster, distribuir las tareas y encargarse de mantener el estado del clúster. Si hay mas de un Manager entre todos se elige automáticamente un líder. Por defecto también actúan como nodos Worker aunque se puede cambiar su configuración para que sólo asuman tareas de Manager.

Worker: Estos son los responsables de ejecutar las tareas que el manager le indica, creando y ejecutando los contenedores.

Comprobemos que el clúster está activo usando el comando

docker node ls

• Despleguemos 2 servicios sencillos con 4 replicas

Usando docker cli

docker service create --name web --replicas 4 --publish published=80,target=80 docker.uclv.cu/nginx:stable-alpine

Accedemos a él abriendo nuestro navegador http://ipdelbridge

docker service create --name whoami --replicas 4 --publish published=8080,target=80 docker.uclv.cu/whoami

Si ejecutamos el comando curl al servicio del whoami veremos cómo nos responde los diferentes replicas

curl -H HOST:ipdelbridge http://ipdelbridge:8080/

Llegaste hasta acá cierto? Pero quizás escuchas el siguiente pretexto.

Pero necesitas internet para descargar un dichoso box y que pesa unos 512 MB. Eso no es muy factible. etc. etc etc.

Y te hago la pregunta. ¿Por qué descargar un box? ¿Por qué no lo haces tú mismo? 🙂

Eres de la vieja escuela que tienes que instalar el sistema tú mismo. Pues acá tienes los pasos.

• Crear la máquina virtual en Virtualbox, con estas características:

Disco duro expandible de entre 40 a 100 GB

RAM comprendida entre 360 a 512 MB

Deshabilitar todos los recursos que no se vayan a utilizar.

La primera interfaz de red debe ser NAT

•  Configurar el Sistema Operativo, con estas características:

Crear el usuario vagrant, debe ser administrador con el comando sudoer.

echo 'vagrant ALL=(ALL) NOPASSWD:ALL' >/etc/sudoers.d/vagrant;
chmod 440 /etc/sudoers.d/vagrant;

• Instalar un servidor SSH 
• Instalar las Virtualbox additions, para optimizar la vm
• Instalar nfs o smb, si queremos utilizar directorios compartidos o sincronizados
• Optimizar hdd de la box final, para lo que podemos:

Eliminar paquetes innecesarios:

dpkg --list \
	| awk '{ print $2 }' \
	| grep 'linux-headers' \
	| xargs apt-get -y purge;

	dpkg --list \
	| awk '{ print $2 }' \
	| grep 'linux-image-.*-generic' \
	| grep -v `uname -r` \
	| xargs apt-get -y purge;

	dpkg --list \
	| awk '{ print $2 }' \
	| grep 'linux-modules-.*-generic' \
	| grep -v `uname -r` \
	| xargs apt-get -y purge;

	dpkg --list \
	| awk '{ print $2 }' \
	| grep linux-source \
	| xargs apt-get -y purge;

	dpkg --list \
	| awk '{ print $2 }' \
	| grep -- '-dev\(:[a-z0-9]\+\)\?$' \
	| xargs apt-get -y purge;


	dpkg --list \
	| awk '{ print $2 }' \
	| grep -- '-doc$' \
	| xargs apt-get -y purge;


	apt-get -y purge libx11-data xauth libxmuu1 libxcb1 libx11-6 libxext6;
	apt-get -y purge ppp pppconfig pppoeconf;
	apt-get -y purge popularity-contest command-not-found friendly-recovery bash-completion fonts-ubuntu-font-family-console laptop-detect motd-news-config usbutils grub-legacy-ec2
	apt-get -y purge fonts-ubuntu-console || true;
	apt-get -y autoremove;
	apt-get -y clean;

	rm -rf /usr/share/doc/*
	find /var/cache -type f -exec rm -rf {} \;
	find /var/log -type f -exec truncate --size=0 {} \;

	truncate -s 0 /etc/machine-id

	rm -rf /tmp/* /var/tmp/*
	rm -f /var/lib/systemd/random-seed
	rm -f /root/.wget-hsts

	export HISTSIZE=0

Llenar con ceros el disco virtual y eliminar espacio sobrante:

sudo dd if=/dev/zero of=/espaciovacio bs=4096k
sudo rm -rf /espaciovacio

Apagamos la VM. Y ejecutamos el comando:

vboxmanage modifyhd /ruta_del_disco/disco.vdi --compact

Ya tenemos el disco reducido y optimizado.

• Empaquetar la box

vagrant package --base el_nombre_de_la_VM

Listar las box:

vagrant box list

Agregar un box local:

vagrant box add new-box-name name-of-your-box.box

LISTOOOOOOOOO

Ya tienes tu box. Hecho por ti mismo.

¿Pero? Que Ubuntu consume mucho. Tengo poca RAM.

Bájate el box de alpine. O créate tú mismo como hice yo mi box de alpine. Los pasos son los mismo solo que cambiando el uso de apt por apk. (Bueno y más que otros ajustillos)

No más escusa amigo.  ¡Bien! 🙂

Estas son las nociones básicas. Si deseas puedes leer más en la web oficial de vagrant. Este tutorial es un aporte de Argenis Ochoa González(AKA @linux8a) que continuará regalándonos más sobre Docker.