Escenario Vagrant 1B: Servidor Web

Introdución

Neste escenario montaremos con Vagrant unha infraestrutura LAMP (Linux Apache Mariadb/MySQL PHP) compartindo un cartafol do host co DocumentRoot do servidor web Apache. Non só crearase a máquina virtual, senon que se automatizará a instalación e configuración da contorna (instalar as últimas versións de Apache, PHP e Mariadb/MySQL presentes nos repositorios oficiais de Ubuntu e habilitar o acceso por http/https).

Vagrantfile

Comezamos creando un novo cartafol para o proxecto e facemos un vagrant init --minimal ou vagrant init para comenzar a traballar sobre o Vagrantfile:

~/Vagrant$ mkdir WEB
~/Vagrant$ cd WEB
~/Vagrant/WEB$ vagrant init --minimal   
~/Vagrant/WEB$ nano Vagrantfile

Vagrant.configure("2") do |config|
  config.vm.box = "bento/ubuntu-22.04"
  config.vm.hostname = "web"
  config.vm.network "private_network", ip: "192.168.56.11"
  config.vm.network "forwarded_port", guest: 80, host: 8080
  config.vm.network "forwarded_port", guest: 443, host: 4430
  config.vm.provider "virtualbox" do |vb|
     vb.name = "web"
     vb.gui = true
     vb.memory = "1024"
     vb.cpus = 2
     vb.linked_clone = true
  end
  config.vm.post_up_message = "Para acceder ejecuta vagrant ssh"
end

Engadimos novas directivas:

config.vm.hostname = “web”

configura o nome da máquina virtual a web.

config.vm.network "private_network", ip: "192.168.56.11"

engade unha nova interfaz de rede á máquina virtual coa IP 192.168.56.11/24. Esta nova interfaz de rede está asociada a unha rede só-anfitrión (host-only) de Virtualbox, polo que o equipo guest terá conexión directa tanto co host como con calquera máquina virtual conectada a esta rede só-anfitrión.

É importante darse conta que a máquina virtual terá dúas interfaces de rede:

• A primeira en modo NAT que permitiralle acceder a Internet e ser administrable mediante vagrant ssh.
• A segunda en modo rede só-anfitrión.

Resto de directivas:

config.vm.network "forwarded_port", guest: 80, host: 8080

mapea o porto 8080 do host co 80 da máquina virtual, permitindo acceder dende calquera equipo ó servidor web da máquina virtual por http a través da IP do host porto 8080.

config.vm.network "forwarded_port", guest: 443, host: 4430

mapea o porto 4430 do host co 443 da máquina virtual, permitindo acceder dende calquera equipo ó servidor web da máquina virtual por https a través da IP do host porto 4430.

config.vm.provider "virtualbox" do |vb|

abre unha subsección de configuración que permite definir características extras da máquina ó usar Virtualbox como provider; é dicir, son características particulares do provider usado:

vb.name = "web"

configura o nome da máquina virtual na interfaz de Virtualbox.

vb.gui = true

permite iniciar a máquina en modo normal (non headless) de xeito que ó arrincar a máquina farase visible a súa xanela en Virtualbox. Con false a máquina iníciase en modo headless.

vb.memory = "1024"

permite indicar a memoria RAM asignada á máquina virtual.

vb.cpus = 2

permite indicar o número de CPUs asignadas á máquina virtual.

vb.linked_clone = true

permite usar a clonación enlazada para acelerar o proceso de creación da máquina virtual. Por defecto ó crearse unha máquina faise unha clonación completa a partir da imaxe (box) do sistema operativo descargado, que no caso de boxes grandes ralentiza todo o proceso.

config.vm.post_up_message = "Para acceder executa vagrant ssh"

permite amosar unha mensaxe ó terminar o vagrant up.

Agora poderíamos facer un vagrant up e crearíamos a máquina virtual coas configuracións anteriores pero sen ter o sistema LAMP operativo

provisioner

Para automatizar a instalación do sistema LAMP e permitir a compartición do DocumentRoot de Apache entre o host e o guest faremos uso dun provisioner e das synced folders polo que modificamos o Vagrantfile: ~/Vagrant/WEB$ nano Vagrantfile

Vagrant.configure("2") do |config|
  config.vm.box = "bento/ubuntu-22.04"
  config.vm.hostname = "web"
  config.vm.network "private_network", ip: "192.168.56.11"
  config.vm.network "forwarded_port", guest: 80, host: 8080
  config.vm.network "forwarded_port", guest: 443, host: 4430
  config.vm.provider "virtualbox" do |vb|
     vb.name = "web"
     vb.gui = true
     vb.memory = "1024"
     vb.cpus = 2
     vb.linked_clone = true
  end
  config.vm.synced_folder "./www", "/var/www/html"
  config.vm.provision "shell", path: "lamp.sh"
  config.vm.post_up_message = "Para acceder executa vagrant ssh"
end

As novas opcións de configuración:

config.vm.synced_folder "./www", "/var/www/html"

comparte o cartafol ./www do host co guest (onde aparecerá montado en /var/www/html )

config.vm.provision "shell", path: "lamp.sh"

indica que no primeiro inicio da máquina executarase o script lamp.sh. Como xa foi dito antes, existen diferentes provisioners ademais dos shell scripts (Ansible, Puppet, …).

Ás veces poden aparecer problemas de permisos nos cartafoles compartidos; xa que por defecto, Vagrant asígnalle como propietario/grupo a combinación vagrant/vagrant. Engadindo owner e group na definición do cartafol compartido poderemos asignar o propietario/grupo axeitado. Por exemplo:

• config.vm.synced_folder "./www", "/var/www/html", owner: "root", group: "root", mount_options: ["dmode=755,fmode=644"]

Un dos pasos previos a lanzar o vagrant up será crear o cartafol local ./www dentro do cartafol do proxecto. No caso de non existir o cartafol no equipo anfitrión, no momento de facer vagrant up aparece un error indicándoo.

~/Vagrant/WEB$ mkdir www

O outro paso previo é preparar o script lamp.sh no mesma cartafol do Vagrantfile e que automatizará todo o proceso. O script de exemplo fai as seguintes tarefas:

• As primeiras liñas comentadas correspóndense á configuración do equipo guest para que use unha caché de paquetes (no exemplo sería un apt-cacher-ng correndo no equipo 192.168.1.254 porto tcp/3142) para acelerar os procesos de instalación/actualización. Falaremos e instalaremos apt-cacher-ng en módulos posteriores do curso e quedan no script como exemplo.
• Actualiza a listaxe de paquetes e fai unha actualización do equipo. No script de exemplo aparece comentada a liña de actualización do equipo para facer máis rápido o proceso.
• Instala Apache, PHP e MySQL.
• Configura MySQL:

• usuario root con contrasinal Abc123..
• crea unha base de datos chamada wordpress e un usuario wordpress con permisos de acceso a ela dende o localhost.

• Crea unhas páxinas index.php, info.php e descarga adminer.php para poder administrar a base de datos vía web.
• Habilita os sitios por defecto HTTP e HTTPS en Apache.

~/Vagrant/WEB$ nano lamp.sh

#!/usr/bin/env bash
echo "-----------------"

## Configurar caché de paquetes para acelerar instalación
#echo "-----------------"
#echo "Añadiendo apt-cacher"
#echo "Acquire::http { Proxy \"http://192.168.1.254:3142\";};" > /etc/apt/apt.conf.d/01apt-cacher-ng
#echo "-----------------"

echo "Actualizando repositorios y equipo"
apt-get update
apt-get full-upgrade -y

echo "-----------------"
echo "Instalando apache-php-mysql"

echo "mysql-server mysql-server/root_password password Abc123.." | debconf-set-selections
echo "mysql-server mysql-server/root_password_again password Abc123.." | debconf-set-selections

apt-get install net-tools apache2 php libapache2-mod-php php-common php-mbstring php-xmlrpc php-soap php-gd php-xml php-intl php-mysql php-cli php-zip php-curl mysql-client mysql-server -y


#echo "[mysqld]" >> /etc/mysql/my.cnf
#echo "bind-address = 0.0.0.0" >> /etc/mysql/my.cnf
#systemctl restart mysql.service

echo "------------------"
echo "Creando base datos"
mysql -uroot -pAbc123.. -h localhost -e "CREATE DATABASE wordpress;"
mysql -uroot -pAbc123.. -h localhost -e "CREATE USER 'wordpress'@'localhost' IDENTIFIED BY 'Abc123..'";
mysql -uroot -pAbc123.. -h localhost -e "GRANT ALL ON wordpress.* TO 'wordpress'@'localhost'";

echo "-----------------"
echo "Habilitando SSL"
a2enmod ssl
a2ensite default-ssl.conf

echo "-----------------"
echo "Creando index.php"
cat > /var/www/html/index.php << 'EOF'
<?php
echo "
<html>
<head>
    <title>Sitio web en ${_SERVER["SERVER_ADDR"]}</title>
</head>
<body>
<h1>Mi Sitio Web</h1>
Estás en ${_SERVER["SERVER_ADDR"]}
</body>
</html>";
?>
EOF

echo "-----------------"
echo "Creando info.php"
cat > /var/www/html/info.php << 'EOF'
<?php
phpinfo();
?>
EOF

echo "-----------------"
echo "Borrando index.html"
rm /var/www/html/index.html

echo "-----------------"
echo "Preparando adminer.php"
wget -O /var/www/html/adminer.php https://www.adminer.org/latest.php

echo "-----------------"
echo "Reiniciando apache"
systemctl restart apache2.service

echo "------ FIN ------"

Trátase dun script de exemplo onde as saídas dos comandos non foron silenciadas para amosar o que está a ocorrer.

Pódense empregar opcións -qq nalgúns comandos e > /dev/null 2>&1  para acortar as mensaxes que saen ó facer vagrant up. Por suposto é máis que recomendable probar os scripts vendo as saídas dos comandos e únicamente silencialas cando todo estea correcto.

Agora falta lanzar vagrant up, ver como se crea o escenario e comprobar que todo foi ben.

vagrant up

Lanzamos o comando vagrant up:

~/Vagrant/WEB$ vagrant init --minimal   

Como novidade na saída a aparecerá a chamada ó provisioner shell e a execución do script.

Tras uns minutos teremos un entorno LAMP igual, sinxelo e rápidamente reproducible para todos os membros do noso equipo de traballo.

Cos comandos seguintes podemos comprobar que se está a executar un servidor LAMP nunha máquina virtual con:

• 1GB de RAM
• 2 cpus
• 2 interfaces de rede
• co DocumentRoot do servidor web accesible vía o cartafol local ./www.:

~/Vagrant/WEB$ vagrant ssh
vagrant@web:~$ sudo netstat -putan
vagrant@web:~$ ip -c -br addr 
vagrant@web:~$ cat /proc/cpuinfo | grep processor | wc -l
vagrant@web:~$ free -h
vagrant@web:~$ df -h
vagrant@web:~$ curl 192.168.56.11
vagrant@web:~$ mysql -u root -p 

E podemos acceder ó servidor web:

• a través da IP do equipo anfitrión (no meu caso 192.168.1.2 ou localhost) e porto 8080 para http
• a través da IP da rede só-anfitrión
• co do porto 4430 para https
• de adminer con https://localhost:4430/adminer.php

• 

  http://192.168.56.121/

• 

  http://localhost:8080

• 

  https://localhost:4430

• 

  https://localhost:4430/adminer.php

• 

  Tras autenticarse

O cartafol local www e /var/www/html (DocumentRoot de Apache) teñen o mesmo contido (index.php, info.php e adminer.php).

Se modificamos o ficheiro index.php (ou engadimos novas páxinas) no cartafol ./www do host (ou en /vagrant_www do guest), éstas poderán ser accesibles vía o servidor web Apache.

No caso de non querer que o cartafol do proxecto (onde está o Vagrantfile) se monte de xeito automático en /vagrant engadiremos no Vagrantfile:

config.vm.synced_folder ".", "/vagrant", disabled: true

Ás veces poden aparecer problemas de permisos nos cartafoles compartidos; xa que por defecto, Vagrant asígnalle como propietario/grupo a combinación vagrant/vagrant. Engadindo owner e group na definición do cartafol compartido poderemos asignar o propietario/grupo axeitado; por exemplo:

config.vm.synced_folder "./www", "/vagrant_www", owner: "root", group: "root", mount_options: ["dmode=755,fmode=644"]

Para rematar, indicar que o aprovisionamento ocorre únicamente en certos momentos da vida dun proxecto:

• No primeiro vagrant up cando se crea a contorna execútase o aprovisionamento. Unha vez creada a contorna, vagrant up limítase a iniciar as máquinas, salvo que se engada a opción --provision.
• Se facemos un vagrant provision nunha contorna en execución.
• Cando reiniciamos unha contorna con vagrant reload --provision.