====== Open Nebula Environment - ONE ======

Open Nebula Environment és un gestor de infraestructura de virtualització. És 


===== Instal·lació de proves amb Vagrant =====

Tenim aquí els arxius per a una instal·lació típica de 1 frontend + 2 workers KVM (que es poden augmentar fàcilment).

Tindrem 5 arxius:
  - Vagranfile : arxiu principal de la infraestructura
  - network.sh : ajustos de la xarxa
  - common.sh : configuració bàsica de paquets comuns de Open Nebula
  - frontend.sh : configuració del node frontend
  - worker.sh : configuració del node worker KVM

Crearà 3 nodes, cadascun amb 3 interfícies de xarxa:
  - frontend amb IPs 192.168.100.10 i 192.168.101.10 . Té el GUI web al port 2621
  - worker1 amb IPs  192.168.100.11 i 192.168.101.11
  - worker2 amb IPs  192.168.100.12 i 192.168.101.12

Les interfícies son:
  - eth0 : reservada per Vagrant
  - eth1 : 192.168.100. reservada per admin i heartbeat de ONE
  - eth2 : 192.168.101. pensada per fer-hi bridges accessibles des de les pròpies VMs


==== Arxius ====

<file ruby Vagrantfile>
# -*- mode: ruby -*-
# vi: set ft=ruby :
 
# Vagrantfile per a ONE - Open Nebula Environment
# frontend node a 192.168.100.10
# nodes (2) a 192.168.100.11 , .12 , etc.
# xarxa bridge br0 per a VMs

#box = "bento/debian-12" # per a macos (aarch64)
box = "debian/bookworm64" # per a linux/windows (amd64)
#provider = "virtualbox"
provider = "libvirt" # tb utilitza virtiofs


Vagrant.configure("2") do |config|

  config.vm.define "frontend" do |frontend|
    frontend.vm.box = box
    frontend.vm.hostname = "frontend"
    frontend.vm.network "private_network", ip: "192.168.100.10" # main
    frontend.vm.network "private_network", ip: "192.168.101.10", auto_config: false # bridge per vms
    frontend.vm.provision "shell", path: "network.sh"
    frontend.vm.provision "shell", path: "common.sh"
    frontend.vm.provision "shell", path: "frontend.sh"
  end

  # Configuració de les màquines nodes
  (1..2).each do |i|
    config.vm.define "node#{i}" do |node|
      node.vm.box = box
      node.vm.hostname = "node#{i}"
      node.vm.network "private_network", ip: "192.168.100.1#{i}" # main
      node.vm.network "private_network", ip: "192.168.101.1#{i}", auto_config: false # bridge per vms
      node.vm.provision "shell", path: "network.sh"
      node.vm.provision "shell", path: "common.sh"
      node.vm.provision "shell", path: "worker.sh"
    end
  end
 
  # Configuració comuna per totes les màquines
  config.vm.provider provider do |virt|
    virt.memory = "4096"
    virt.cpus = 2
    # ajustos virtiofs (nomes en libvirt)
    if provider == "libvirt" then
      virt.memorybacking :access, :mode => 'shared'
    end
  end

  # carpeta compartida per virtiofs enlloc de NFS per libvirt
  if provider == "libvirt" then
    config.vm.synced_folder ".", "/vagrant", type: "virtiofs"
  end

end
</file>

<file bash network.sh>
#!/bin/bash

# configuració /etc/network/interfaces

IPBASE="192.168.101."
IFACE="eth2"

# paquets
apt-get update
apt-get install -y bridge-utils

# trobem numero de node
numero=$(echo "$(hostname)" | grep -oE '[0-9]+$')

# si no té número, és que és el frontend (.10)
if [ -z "$numero" ]; then
    numero=0
fi

lastipnum=$((10+$numero))
IP="$IPBASE$lastipnum"
echo "Configurant xarxa br0 a "$(hostname)" : $IP"

echo "
# interficie física per al pont
#auto $IFACE
iface $IFACE inet manual

# Bridge principal
auto br0

# Bridge amb IP estàtica
iface br0 inet static
    bridge_ports $IFACE
    bridge_stp off
    bridge_fd 0
    bridge_maxwait 0
    address $IP
    netmask 255.255.255.0
    # gateway "$IPBASE"1    # gateway: Descomentar si cal
" >> /etc/network/interfaces

# reiniciem xarxa
systemctl restart networking.service
</file>


<file bash common.sh>
#!/bin/bash

# actualització apt
apt-get update

# Eines bàsiques (per versió curl+gpg)
apt-get install -y wget curl net-tools vim nfs-common gnupg2

# repos Open Nebula
wget -q -O- https://downloads.opennebula.io/repo/repo2.key | apt-key add -
#curl -fsSL https://downloads.opennebula.io/repo/repo2.key | gpg --dearmor -o /etc/apt/keyrings/opennebula.gpg
echo "deb https://downloads.opennebula.io/repo/7.0/Debian/12 stable opennebula" > /etc/apt/sources.list.d/opennebula.list

# actualitzem
apt-get update
</file>

<file bash frontend.sh>
#!/bin/bash

# resetejem la clau pública del oneadmin per fer SSH
rm -f /vagrant/id_rsa.pub.frontend

# a la conf comuna ja s'ha fet update i afegir els repos de Open Nebula
#apt-get update

# Instal·lació packages Open Nebula
apt-get install -y opennebula opennebula-fireedge opennebula-gate opennebula-flow

# ajust password de oneadmin
echo 'oneadmin:vagrant' > /var/lib/one/.one/one_auth

# TODO: instal·lar i configurar mariadb-server i /etc/one/oned.conf

# arrenquem i configurem a l'inici els serveis
systemctl start opennebula opennebula-fireedge opennebula-gate opennebula-flow
systemctl enable opennebula opennebula-fireedge opennebula-gate opennebula-flow

# publiquem clau publica del oneadmin
cp /var/lib/one/.ssh/id_rsa.pub /vagrant/id_rsa.pub.frontend
</file>

<file bash worker.sh>
#!/bin/bash

# a la conf comuna ja s'ha fet update i afegir els repos de Open Nebula
#apt-get update

# instal·lem node worker KVM
apt-get install -y opennebula-node-kvm

while [ ! -f /vagrant/id_rsa.pub.frontend ]
do
	echo "Esperem que es publiqui la clau publica de oneadmin"
	sleep 5
done

# importem la clau pública de oneadmin
cat /vagrant/id_rsa.pub.frontend >> /var/lib/one/.ssh/authorized_keys
</file>

\\

==== Posada en marxa ====

Has de tenir instal·lat [[Vagrant]].

  $ time vagrant up

Hauria de crear 3 nodes amb noms "frontend", "node1" i "node2".