Comment configurer les hôtes virtuels Apache sur une instance Ubuntu EC2 à l'aide de Terraform

«Afin d'accueillir plusieurs sites Web, les administrateurs configurent généralement l'hébergement virtuel sur une seule machine. Dans l'hébergement virtuel, nous pouvons utiliser un hébergement «basé sur IP» ou un «nom basé sur le nom.«Dans l'hébergement« basé sur IP », nous avons des adresses IP distinctes pour chaque site Web. Dans le cas de l'hébergement «basé sur le nom», nous avons plusieurs noms exécutés sur chaque adresse IP."

Que couvrirons-nous?

Dans ce guide, nous verrons comment nous pouvons configurer des hôtes virtuels sur un Amazon EC2 Ubuntu 22.04 instance. Dans ce laboratoire, nous utiliserons l'hébergement virtuel basé sur les noms. Nous utiliserons Terraform pour déployer l'infrastructure souhaitée.

Aperçu du laboratoire

Dans ce laboratoire, nous créerons deux hôtes virtuels; Domain1 et Domain2. Nous installerons un serveur Web Apache sur notre machine Ubuntu. Chaque hôte virtuel a un index différent.Fichier HTML avec le contenu: «Ceci est l'hôte virtuel 1.”Pour Domain1 et« Ceci est Virtual Host 2.”Pour Domain2.

Au lieu d'enregistrer le nom de domaine pour chaque hôte, nous utilisons l'adresse IP localhost pour mapper les noms de domaine. Cela peut être fait en modifiant le fichier «hôtes». Pour simplifier le déploiement de cette infrastructure, nous avons divisé la configuration globale en fichiers multiples. De cette façon, nous nous sauverons de la maladresse du code. COMPRIGNEMENT des fichiers utilisés ici:

1. données d'utilisateur.shot: Contient le script nécessaire pour installer et configurer le serveur Web Apache sur l'instance Ubuntu.
2. secgrp.TF: Crée un groupe de sécurité à utiliser avec l'instance. Ce groupe de sécurité permettra au SSH et au HTTP de pénétrer le trafic vers l'instance.
3. domain_2.conf et domain_1.confli: Contient une configuration d'hôte virtuelle.
4. principal.TF: Le point d'entrée primaire / principal pour tous les .Fichiers TF.

Configuration de la configuration

Étape 1. Laissez-nous d'abord un répertoire de travail qui gardera tous nos .Fichiers TF:

$ Mkdir Demo

Étape 2. Créer le userdata.fichier sh:

$ nano userdata.shot

Collez maintenant les lignes suivantes à l'intérieur:

#!/ bac / bash
Mise à jour Sudo apt-get
Sudo apt-get upgrade -y
sudo apt-get install apache2 -y
sudo systemctl redémarrer apache2
sudo sh -c "echo 127.0.0.1 www.domaine1.com >> / etc / hôtes "
sudo sh -c "echo 127.0.0.1 www.domaine2.com >> / etc / hôtes "
sudo mkdir -p / var / www / domain_1 / public_html
sudo mkdir -p / var / www / domain_2 / public_html
Sudo Chown -r $ utilisateur: $ utilisateur / var / www / domain_1 / public_html
sudo chown -r $ utilisateur: $ utilisateur / var / www / domain_2 / public_html
sudo chmod -r 755 / var / www
sudo echo «Ceci est l'hôte virtuel 1.”> / Var / www / domain_1 / public_html / index.html
sudo echo «Ceci est un hôte virtuel 2.”> / Var / www / domain_2 / public_html / index.html
sudo cp / home / ubuntu / domain_1.conf / etc / apache2 / sites-disponible / domain_1.confli
sudo cp / home / ubuntu / domain_2.conf / etc / apache2 / sites-disponible / domain_2.confli
Sudo A2ensite Domain_1.confli
sudo a2ensite domain_2.confli
sudo a2dissite 000 déficientes.confli
sudo systemctl redémarrer apache2

Dans le script ci-dessus, nous avons installé un serveur Web Apache et modifié le fichier de l'hôte pour cartographier l'adresse localhost aux deux noms de domaine d'hôtes virtuels que nous voulons configurer. De plus, nous avons configuré le serveur Web pour les nouveaux sites Web et désactivé le par défaut.

Étape 3. Créer le secgrp.Fichier TF pour permettre à SSH et HTTP de pénétrer le trafic de n'importe où et du trafic sortant vers n'importe où.

$ nano secgrp.TF

Collez les lignes suivantes à l'intérieur:

ressource "aws_security_group" "Demo-sg"
name = "sec-grpg"
Description = "Autoriser le trafic HTTP et SSH via Terraform"
entrave
From_port = 80
to_port = 80
protocole = "TCP"
cidr_blocks = ["0.0.0.0/0 "]

entrave
From_port = 22
to_port = 22
protocole = "TCP"
cidr_blocks = ["0.0.0.0/0 "]

sortie
From_port = 0
to_port = 0
protocole = "-1"
cidr_blocks = ["0.0.0.0/0 "]

Étape 4. Pour la configuration virtuelle de l'hôte, créez deux fichiers: domaine_1.conf et domain_2.confli. Remarque l'emplacement de la racine du document dans chaque fichier.

je. $ nano domain_1.confli

ServerAdmin Admin @ Domain1.com
Domaine de nom de serveur1
Serveralias www.domaine1.com
DocumentRoot / var / www / domain_1 / public_html
ErrorLog $ apache_log_dir / erreur.enregistrer

Ii. $ nano domain_2.confli

ServerAdmin admin @ domain2.com
ServerName Domain2
Serveralias www.domaine2.com
Documentroot / var / www / domain_2 / public_html
ErrorLog $ apache_log_dir / erreur.enregistrer
Customlog $ apache_log_dir / accès.journal combiné

Étape 5. Enfin, créez le principal.TF pour terminer la déclaration d'infrastructure:

$ nano main.TF
fournisseur "aws"
région = "US-East-1"

ressource "aws_instance" "webserver"
ami = "AMI-09D56F8956AB235B3"
instance_type = "t2.micro "
key_name = "name-of-your-ec2-key-pair"
vpc_security_group_ids = [aws_security_group.démo-sg.identifiant]
associé_public_ip_address = true
provisoire "fichier"
source = "domain_1.conf
destination = "/ home / ubuntu / domain_1.conf
connexion
type = "ssh"
user = "ubuntu"
private_key = "$ file (" / path / to // ec2-keypair.pem ")"
host = "$ self.public_dns "


provisoire "fichier"
source = "domain_2.conf
destination = "/ home / ubuntu / domain_2.conf
connexion
type = "ssh"
user = "ubuntu"
private_key = "$ file (" / path / to // ec2-keypair.pem ")"
host = "$ self.public_dns "


user_data = "$ file (" userdata.sh ")"
tags =
Name = "virtualhosts"


sortie "iPaddress"
value = "$ aws_instance.serveur Web.public_ip "

Au dessus .Fichier TF, nous avons utilisé le provisoire de fichiers pour copier le «domaine.confli»Fichier de notre système local à l'instance EC2. Ce "domaine.confli"Sera utilisé comme fichier de modèle pour fabriquer des fichiers hôte virtuels spécifiques au domaine, i.e., «Domain_1.conf ”et" Domain_2.conf.

Étape 6. Tous nos fichiers de configuration sont prêts maintenant; Il est maintenant temps de déployer cette configuration. Initialiser le répertoire du projet en utilisant:

$ Terraform init

Enfin, construisez le projet en exécutant la commande:

$ terraform s'applique

Entrez «oui» sur le terminal lorsqu'on lui a demandé. À partir de votre instance EC2, utilisez la commande «Curl» pour voir ce que chaque adresse de domaine affiche:

Conclusion

L'hébergement virtuel est une technique très efficace pour gérer plusieurs sites Web à partir d'un seul serveur. Dans ce laboratoire, nous avons vu comment Terraform peut être utilisé pour déployer une simple infrastructure à deux hôtes. Essayez de rendre cette configuration plus évolutive en implémentant des modules Terraform.