Ver el código de «Escenario Vagrant 1D: FW-Server»


= Introdución =

Nesta ocasión imos ver como Vagrant pode levantar rápidamente infraestruturas máis complexas con varias máquinas conectadas a redes diferentes. Crearemos unha infraestrutura con dúas máquinas virtuais, unha que actuará como router-firewall e outra coma un servidor web interno cumprindo os seguintes requerimentos:

* O router-firewall FW sae a Internet a través dun router 192.168.1.1. NOTA: para o exercicio non é preciso a existencia do router 192.168.1.1, é un exemplo dunha posible infraestrutura. Podería indicarse a IP do router da casa/clase.
* O servidor interno queremos que saia a Internet a través do router-firewall FW.
* Os servizos correndo no servidor interno serán accesibles dende o exterior a través do router-firewall FW.

[[File:Escenario 1D fw lan virtualbox.png]]

Haberá que solucionar os seguintes problemas:

* En base ós requerimentos, o router-firewall FW ten que saír a Internet a través dun router 192.168.1.1 usando unha interfaz en modo ponte, pero Vagrant sempre crea unha interfaz NAT que permite ó guest saír ó exterior a través do host e que non pode eliminarse xa que é necesaria para o funcionamento de Vagrant (p.e. para facer vagrant ssh).
* O servidor interno ten que saír a Internet a través do router-firewall FW e non a través do equipo anfitrión. Igual que antes, temos o problema da interfaz NAT.
* Para facer accesibles os servizos correndo no servidor interno dende o exterior a través do router-firewall FW haberá que configurar unhas regras iptables de tipo DNAT que fagan que as peticións http/https destinadas á interfaz externa do router-firewall FW vaian hacia o servidor interno (sobre netfilter/iptables falarase en temas posteriores). Unha vez máis, non nos interesa a interfaz NAT creada por defecto nin para que FW teña acceso a Internet (usará o seu propio router 192.168.1.1) nin para abrir portos (farase directamente en FW con regras netfilter/iptables e non no anfitrión con config.vm.network "forwarded_port").

= Vagrantfile =

Creamos un cartafol para o novo proxecto e editamos o Vagrantfile:
 ~/Vagrant$ mkdir fw-server
 ~/Vagrant$ cd fw-server/
 ~/Vagrant/fw-server$ vagrant init --minimal
 ~/Vagrant/fw-server$ nano Vagrantfile

<pre>
Vagrant.configure("2") do |config|
# Definición de FW
  config.vm.define "fw" do |fw|
    fw.vm.box = "bento/ubuntu-22.04"
    fw.vm.hostname = "FW"
    fw.vm.network "public_network", bridge: "enp6s0", ip: "192.168.1.254", netmask: "255.255.255.0"
    fw.vm.network "private_network", ip: "192.168.56.254", netmask: "255.255.255.0"
    # eliminar default gw en eth0 – red NAT creada por defecto
    fw.vm.provision "shell",
        run: "always",
        inline:  "ip route del default"    
    # default router
    fw.vm.provision "shell",
        run: "always",
        inline: "ip route add default via 192.168.1.1"
    fw.vm.provider "virtualbox" do |vb|
        vb.name = "FW"
        # vb.gui = true
        vb.memory = "1024"
        vb.cpus = 1
        vb.linked_clone = true
        vb.customize ["modifyvm", :id, "--groups", "/FW-Server"]
    end
  end

# Definición servidor interno
  config.vm.define "server" do |server|
    server.vm.box = "bento/ubuntu-22.04"
    server.vm.hostname = "server"
    server.vm.network "private_network", ip: "192.168.56.253", netmask: "255.255.255.0"
    server.vm.synced_folder "./www", "/var/www/html", owner: "root", group: "root", mount_options: ["dmode=755,fmode=644"]
    server.vm.provision "shell", path: "server.sh"
    # eliminar default gw en eth0 – red NAT creada por defecto
    server.vm.provision "shell",
        run: "always",
        inline:  "ip route del default"   
    # default router
    server.vm.provision "shell",
        run: "always",
        inline: "ip route add default via 192.168.56.254"
    server.vm.provider "virtualbox" do |vb|
        vb.name = "server"
        # vb.gui = true
        vb.memory = "1024"
        vb.cpus = 2
        vb.linked_clone = true
        vb.customize ["modifyvm", :id, "--groups", "/FW-Server"]
    end
  end
end
</pre>

Analizando o Vagrantfile veremos o seguinte.

Hai dúas seccións onde están definidas as características particulares das máquinas do proxecto:
; config.vm.define "fw" do |fw|
: usada para definir o router-firewall FW.
; config.vm.define "server" do |server|
: usada para definir o servidor interno.

No router-firewall imos ter 3 interfaces de rede:
* Unha de tipo NAT creada automáticamente por Vagrant e que polo box usado chamarase eth0.
* Unha de tipo ponte (bridge) con IP 192.168.1.254/24 que chamarase eth1 e estará asociada á interfaz enp6s0 do equipo anfitrión: fw.vm.network "public_network", bridge: "enp6s0", ip: "192.168.1.254", netmask: "255.255.255.0". enp6s0 é o nome asignado á interfaz real do host anfitrión no meu caso. No caso de non saber o nome da interfaz, o comando VBoxManage list bridgedifs lista o nome das interfaces do anfitrión para configurar adaptadores en modo ponte.
* Unha de tipo só-anfitrión con IP 192.168.56.254/24 que chamarase eth2: fw.vm.network "private_network", ip: "192.168.56.254", netmask: "255.255.255.0"

No router-firewall para configurar a pasarela predeterminada correcta executaranse en cada inicio (run: "always") dous comandos shell (server.vm.provision "shell"):
* Un que borra a pasarela predeterminada creada por defecto por Vagrant e asociada á rede NAT: inline: "ip route del default"
* Un que engade a pasarela predeterminada correcta: inline: "ip route add default via 192.168.1.1"

Fixádevos que simplemente é executar dous comandos de configuración de rede: ip route del e ip route add.

= Solución alternativa da documentación oficial =

Na documentación oficial de Vagrant propoñen a seguinte solución, máis complexa e dependente do nome asignado á interfaz polo sistema operativo guest:

<pre>
# default router
fw.vm.provision "shell",
  run: "always",
  inline: "route add default gw 192.168.1.1"
# eliminar default gw en eth0 da red NAT creada por defecto
fw.vm.provision "shell",
  run: "always",
  inline:  "eval `route -n | awk '{ if ($8 == \"eth0\" && $2 != \"0.0.0.0\") print \"route del default gw \" $2; }'`"  
</pre>

O primeiro comando engade a pasarela predeterminada correcta: 
* inline: "route add default gw 192.168.1.1"
O segundo comando borra a pasarela predeterminada creda por defecto por Vagrant e asociada á rede NAT:
* inline:  "eval `route -n | awk '{ if ($8 == \"eth0\" && $2 != \"0.0.0.0\") print \"route del default gw \" $2; }'`"

No servidor interno teremos 2 interfaces de rede:
* Unha de tipo NAT creada automáticamente por Vagrant e que polo box usado chamarase eth0.
* Unha de tipo só-anfitrión con IP 192.168.56.253/24 que chamarase eth1: fw.vm.network "private_network", ip: "192.168.56.253", netmask: "255.255.255.0"

No servidor interno repítese o explicado anteriormente para configurar a IP interna do router-firewall 192.168.56.254 como pasarela predeterminada.
; vb.customize ["modifyvm", :id, "--groups", "/FW-Server"]
: permite agrupar as máquinas virtuais desta contorna nun grupo chamado FW-Server, visible na interfaz de Virtualbox.

A modo de exemplo, na máquina FW non se fai ningún aprovisionamento (salvo o necesario para configurar a pasarela predeterminada) e no servidor interno o script de aprovisionamento server.sh instala apache con soporte para php e MySQL e tamén crea un arquivo de exemplo index.php no DocumentRoot. Fixarse na ubicación de server.vm.provision "shell", path: "server.sh" dentro do Vagrantfile para que se execute antes de cambiar o default gw (así terá acceso ós repositorios aínda que a máquina router-firewall non estea configurada grazas á rede NAT).

= vagrant up =

Se iniciamos a contorna veremos como se crean as dúas máquinas coa configuración indicada e agrupadas na interfaz de Virtualbox dentro do grupo FW-server:
 ~/Vagrant/fw-server$ mkdir www
 ~/Vagrant/fw-server$ vagrant up
 ~/Vagrant/fw-server$ vagrant status
 Current machine states:
 fw running (virtualbox)
 server running (virtualbox)
 This environment represents multiple VMs. The VMs are all listed above with their current state. For more information about a specific VM, run `vagrant status NAME`.
 ~/Vagrant/fw-server$

[[File: A.png| Fig. Máquinas do grupo FW-Server]]

Para acceder ás máquinas podemos especificar en vagrant ssh aa que nos interesa. No fw:

 ~/Vagrant/fw-server$ vagrant ssh fw
 vagrant@FW:~$ ip route

<pre>
default via 192.168.1.1 dev eth1 
10.0.2.0/24 dev eth0 proto kernel scope link src 10.0.2.15 metric 100 
10.0.2.2 dev eth0 proto dhcp scope link src 10.0.2.15 metric 100 
10.0.2.3 dev eth0 proto dhcp scope link src 10.0.2.15 metric 100 
192.168.1.0/24 dev eth1 proto kernel scope link src 192.168.1.254 
192.168.56.0/24 dev eth2 proto kernel scope link src 192.168.56.254 
</pre>

Para server sería:
 ~/Vagrant/fw-server$ vagrant ssh server
 vagrant@server:~$ ip route

<pre>
default via 192.168.56.254 dev eth1 
10.0.2.0/24 dev eth0 proto kernel scope link src 10.0.2.15 metric 100 
10.0.2.2 dev eth0 proto dhcp scope link src 10.0.2.15 metric 100 
10.0.2.3 dev eth0 proto dhcp scope link src 10.0.2.15 metric 100 
192.168.56.0/24 dev eth1 proto kernel scope link src 192.168.56.253 
</pre>

Do mesma xeito poderíanse enviar ordes a unha máquina concreta da contorna: 
 vagrant {up|halt|reload|ssh} [name]