Cómo configurar los hosts virtuales Apache en la instancia de Ubuntu EC2 usando Terraform

“Para alojar múltiples sitios web, los administradores generalmente configuran el alojamiento virtual en una sola máquina. En el alojamiento virtual, podemos usar un alojamiento "basado en IP" o un "basado en el nombre."En el alojamiento" basado en IP ", tenemos direcciones IP distintas para cada sitio web. En el caso de alojamiento "basado en nombres", tenemos múltiples nombres ejecutados en cada dirección IP."

¿Qué cubriremos??

En esta guía, veremos cómo podemos configurar hosts virtuales en un Amazon EC2 Ubuntu 22.04 instancia. En este laboratorio, utilizaremos el alojamiento virtual basado en nombres. Usaremos Terraform para implementar la infraestructura deseada.

Descripción general del laboratorio

En este laboratorio, crearemos dos hosts virtuales; dominio1 y dominio2. Instalaremos un servidor web Apache en nuestra máquina Ubuntu. Cada host virtual tiene un índice diferente.archivo html con el contenido: “Este es el host virtual 1."Para Domain1 y" Este es el host virtual 2."Para dominio2.

En lugar de registrar el nombre de dominio para cada host, estamos utilizando la dirección IP localhost para asignar los nombres de dominio. Esto se puede hacer modificando el archivo "hosts". Para simplificar la implementación de esta infraestructura, hemos dividido la configuración general en múltiples archivos. De esta manera, nos salvaremos de la torpeza del código. Contornos de los archivos utilizados aquí:

1. datos del usuario.mierda: Contiene el script necesario para instalar y configurar el servidor web Apache en la instancia de Ubuntu.
2. Secgrp.TF: Crea un grupo de seguridad para ser utilizado con la instancia. Este grupo de seguridad permitirá que SSH y HTTP ingresen el tráfico a la instancia.
3. dominio_2.conf y dominio_1.confusión: Contiene la configuración del host virtual.
4. principal.TF: El punto de entrada principal/principal para todos los .archivos tf.

Configuración de la configuración

Paso 1. Primero creemos un directorio de trabajo que mantendrá todo nuestro .Archivos TF:

$ mkdir demo

Paso 2. Crea los data de usuario.Archivo SH:

$ nano userData.mierda

Ahora pegue las siguientes líneas dentro:

#!/bin/bash
actualización de sudo apt-get
sudo apt -get actualización -y
sudo apt -get install apache2 -y
sudo systemctl reiniciar apache2
sudo sh -c "echo 127.0.0.1 www.dominio1.com >> /etc /hosts "
sudo sh -c "echo 127.0.0.1 www.dominio2.com >> /etc /hosts "
sudo mkdir -p/var/www/domain_1/public_html
sudo mkdir -p/var/www/domain_2/public_html
sudo chown -r $ user: $ user/var/www/domain_1/public_html
sudo chown -r $ user: $ user/var/www/domain_2/public_html
sudo chmod -r 755 /var /www
sudo echo “Este es el host virtual 1.">/Var/www/domain_1/public_html/index.html
sudo echo “Este es virtual host 2.">/Var/www/domain_2/public_html/index.html
sudo cp/home/ubuntu/domain_1.conf/etc/apache2/sites-disponible/dominio_1.confusión
sudo cp/home/ubuntu/domain_2.conf/etc/apache2/sites-disponible/dominio_2.confusión
sudo a2ensite dominio_1.confusión
sudo a2ensite dominio_2.confusión
sudo a2dissite 000 default.confusión
sudo systemctl reiniciar apache2

En el script anterior, instalamos un servidor web de Apache y modificamos el archivo del host para asignar la dirección localhost a los nombres de dominio de los dos hosts virtuales que queremos configurar. Además, hemos configurado el servidor web para los nuevos sitios web y deshabilitado el predeterminado.

Paso 3. Crea el SECGRP.El archivo TF permite el tráfico de ingreso SSH y HTTP desde cualquier lugar y el tráfico saliente a cualquier lugar.

$ nano secgrp.TF

Pegar las siguientes líneas dentro:

recurso "AWS_SECURITY_GROUP" "Demo-SG"
nombre = "Sec-Grpg"
Descripción = "Permitir el tráfico HTTP y SSH a través de Terraform"
ingreso
from_port = 80
to_port = 80
Protocol = "TCP"
CIDR_BLOCKS = ["0.0.0.0/0 "]

ingreso
from_port = 22
to_port = 22
Protocol = "TCP"
CIDR_BLOCKS = ["0.0.0.0/0 "]

salida
from_port = 0
to_port = 0
Protocolo = "-1"
CIDR_BLOCKS = ["0.0.0.0/0 "]

Etapa 4. Para la configuración del host virtual, cree dos archivos: Domain_1.conf y dominio_2.confusión. Tenga en cuenta la ubicación de la raíz del documento en cada archivo.

I. $ nano dominio_1.confusión

ServerAdmin [email protected]
Servidor Name Domain1
Serveralias www.dominio1.comunicarse
Documentroot/var/www/domain_1/public_html
ErrorLog $ apache_log_dir/error.registro

II. $ nano dominio_2.confusión

ServerAdmin [email protected]
Servidor Name Domain2
Serveralias www.dominio2.comunicarse
Documentroot/var/www/domain_2/public_html
ErrorLog $ apache_log_dir/error.registro
CustomLog $ apache_log_dir/access.registro combinado

Paso 5. Finalmente, crea el principal.TF para completar la declaración de infraestructura:

$ nano principal.TF
Proveedor "AWS"
región = "US-East-1"

Recurso "AWS_Instance" "WebServer"
ami = "AMI-09D56F8956AB235B3"
instance_type = "t2.micro"
key_name = "Nombre de tu-EC2-Key-Pair"
vpc_security_group_ids = [aws_security_group.sg de demostración.identificación]
asociado_public_ip_address = true
Provisor "Archivo"
fuente = "Domain_1.conf "
destino = "/home/ubuntu/domain_1.conf "
conexión
type = "ssh"
usuario = "Ubuntu"
private_key = "$ file ("/path/to // ec2-keypair.Pem ")"
host = "$ self.public_dns "


Provisor "Archivo"
fuente = "Domain_2.conf "
destino = "/home/ubuntu/domain_2.conf "
conexión
type = "ssh"
usuario = "Ubuntu"
private_key = "$ file ("/path/to // ec2-keypair.Pem ")"
host = "$ self.public_dns "


user_data = "$ archivo (" userData.sh ")"
etiquetas =
Nombre = "VirtualHosts"


Salida "iPaddress"
valor = "$ aws_instance.Servidor web.public_ip "

En lo anterior .Archivo TF, hemos utilizado el proveedor de archivos para copiar el "dominio.confusiónArchivo de nuestro sistema local a la instancia de EC2. Este "dominio.confusión"Se utilizará como un archivo de plantilla para hacer archivos de host virtuales específicos de dominio, yo.mi., "Dominio_1.conf "y" dominio_2.conf ".

Paso 6. Todos nuestros archivos de configuración están listos ahora; Ahora es el momento de implementar esta configuración. Inicializar el directorio del proyecto usando:

$ Terraform init

Finalmente, cree el proyecto ejecutando el comando:

$ Terraform se aplica

Ingrese "Sí" en la terminal cuando se le pide. Desde su instancia de EC2, use el comando "CURL" para ver qué muestra cada dirección de dominio:

Conclusión

El alojamiento virtual es una técnica muy eficiente para administrar múltiples sitios web desde un solo servidor. En este laboratorio, hemos visto cómo se puede usar Terraform para implementar una infraestructura simple de dos host. Intente que esta configuración sea más escalable implementando módulos Terraform.