Jak skonfigurować wirtualne hosty Apache w instancji Ubuntu EC2 za pomocą Terraform

„Aby hostować wiele stron internetowych, administratorzy zwykle konfigurują hosting wirtualny na jednym komputerze. W hostingu wirtualnym możemy użyć hostingu „opartego na IP” lub „opartej na nazwie.”W hostingu„ opartym na IP ”mamy odrębne adresy IP dla każdej strony internetowej. W przypadku hostingu „opartego na nazwach” mamy wiele nazw działających na każdym adresie IP."

Co obejmiemy?

W tym przewodniku zobaczymy, jak możemy skonfigurować wirtualne hosty na Amazon EC2 Ubuntu 22.04 Instancja. W tym laboratorium będziemy używać wirtualnego hostingu opartego na nazwiskach. Użyjemy Terraform do wdrożenia pożądanej infrastruktury.

Przegląd laboratorium

W tym laboratorium utworzymy dwa wirtualne hosty; domain1 i domena2. Zainstalujemy serwer WWW Apache na naszym komputerze Ubuntu. Każdy wirtualny host ma inny indeks.Plik HTML z treścią: „To jest wirtualny host 1.”Dla domain1 i„ To jest wirtualny host 2.„Dla domeny2.

Zamiast rejestrować nazwę domeny dla każdego hosta, używamy adresu IP LocalHost, aby zmapować nazwy domeny. Można to zrobić, modyfikując plik „hosty”. Aby uprościć wdrożenie tej infrastruktury, podzieliliśmy ogólną konfigurację na wiele plików. W ten sposób uratujemy się przed niezdarnością kodu. Zarysy plików używanych tutaj:

1. dane użytkownika.cii: Zawiera skrypt potrzebny do instalacji i konfigurowania serwera WWW Apache w instancji Ubuntu.
2. secgrp.tf: Tworzy grupę bezpieczeństwa do użycia z instancją. Ta grupa bezpieczeństwa pozwoli SSH i HTTP na wnikanie ruchu do instancji.
3. domain_2.conf i domain_1.conf: Zawiera wirtualną konfigurację hosta.
4. główny.tf: Główny/główny punkt wejścia dla wszystkich .Pliki TF.

Konfigurowanie konfiguracji

Krok 1. Najpierw stwórzmy działający katalog, który zatrzyma wszystkie nasze .Pliki TF:

Demo $ mkdir

Krok 2. Utwórz użytkownika.Plik SH:

$ nano UserData.cii

Teraz wklej następujące linie w nim:

#!/bin/bash
Sudo apt-get Aktualizacja
sudo apt -get aktualiza
sudo apt -get instaluj apache2 -y
sudo systemctl restart apache2
sudo sh -c "echo 127.0.0.1 www.domena1.com >> /etc /hosts "
sudo sh -c "echo 127.0.0.1 www.domena2.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 „To jest wirtualny host 1.">/Var/www/domain_1/public_html/index.html
sudo echo „To jest wirtualny host 2.”>/Var/www/domain_2/public_html/index.html
sudo cp/home/ubuntu/domain_1.conf/etc/apache2/witryny-dostępny/domain_1.conf
sudo cp/home/ubuntu/domain_2.conf/etc/apache2/witryny-dostępny/domain_2.conf
sudo a2ensite domain_1.conf
sudo a2ensite domain_2.conf
sudo a2dissite 000-default.conf
sudo systemctl restart apache2

W powyższym skrypcie zainstalowaliśmy serwer WWW Apache i zmodyfikowaliśmy plik hosta, aby zmapować adres LocalHost do dwóch nazwy domeny hostów wirtualnych, które chcemy skonfigurować. Ponadto skonfigurowaliśmy serwer WWW dla nowych stron internetowych i wyłączyliśmy domyślną.

Krok 3. Utwórz secgrp.plik TF, aby umożliwić SSH i HTTP wnikanie ruchu z dowolnego miejsca i ruchu wychodzącego do dowolnego miejsca.

$ nano secgrp.tf

Wklej następujące linie w nim:

Zasób „aws_security_group” „demo-sg”
name = "sec-grpg"
Opis = "Zezwalaj na ruch HTTP i SSH przez Terraform"
wnikanie
from_port = 80
to_port = 80
protokół = "tcp"
cidr_blocks = ["0.0.0.0/0 "]

wnikanie
from_port = 22
to_port = 22
protokół = "tcp"
cidr_blocks = ["0.0.0.0/0 "]

egress
from_port = 0
to_port = 0
protokół = "-1"
cidr_blocks = ["0.0.0.0/0 "]

Krok 4. W przypadku wirtualnej konfiguracji hosta utwórz dwa pliki: domain_1.Conf i domain_2.conf. Zwróć uwagę na lokalizację główną dokumentu w każdym pliku.

I. $ nano domain_1.conf

ServerAdmin [email protected]
Servername Domain1
Serveralias www.domena1.com
DocumentRoot/var/www/domain_1/public_html
ErrorLog $ apache_log_dir/error.dziennik

Ii. $ nano domain_2.conf

ServerAdmin [email protected]
Servername Domain2
Serveralias www.domena2.com
DocumentRoot/var/www/domain_2/public_html
ErrorLog $ apache_log_dir/error.dziennik
CustomLog $ apache_log_dir/access.Log łącznie

Krok 5. Na koniec stwórz główną.TF Aby ukończyć deklarację infrastruktury:

$ nano main.tf
Dostawca „AWS”
region = „US-East-1”

Zasób „AWS_INSTANCE” „WebServer”
ami = "AMI-09D56F8956AB235B3"
instance_type = "t2.mikro "
key_name = "name-of-your-ec2-key-para"
vpc_security_group_ids = [AWS_Security_Group.Demo-SG.ID]
associate_public_ip_address = true
Provisioner „File”
źródło = "domain_1.konf ”
miejsce docelowe = "/home/ubuntu/domain_1.konf ”
połączenie
type = "ssh"
user = "Ubuntu"
private_key = "$ plik ("/ścieżka/do // ec2-keypair.PEM ")"
host = "$ self.public_dns "


Provisioner „File”
źródło = "domain_2.konf ”
miejsce docelowe = "/home/ubuntu/domain_2.konf ”
połączenie
type = "ssh"
user = "Ubuntu"
private_key = "$ plik ("/ścieżka/do // ec2-keypair.PEM ")"
host = "$ self.public_dns "


user_data = "$ plik (" userData.cii")"
tagi =
Name = "VirtualHosts"


Wyjście „iPaddress”
wartość = "$ AWS_Instance.serwer internetowy.public_ip "

W powyższym .plik tf użyliśmy przepisu pliku do skopiowania „domena.conf”Plik z naszego systemu lokalnego do instancji EC2. Ten "domena.conf”Będzie używany jako plik szablonu do tworzenia wirtualnych plików hosta specyficznego dla domeny, i.mi., „Domain_1.conf ”i„ domain_2.konf ”.

Krok 6. Wszystkie nasze pliki konfiguracyjne są teraz gotowe; Nadszedł czas, aby faktycznie wdrożyć tę konfigurację. Zainicjuj katalog projektu za pomocą:

$ Terraform init

Na koniec zbuduj projekt, uruchamiając polecenie:

$ Terraform Zastosuj

Wprowadź „Tak” na terminalu, gdy zapytano. Z instancji EC2 użyj polecenia „Curl”, aby zobaczyć, co wyświetla każdy adres domeny:

Wniosek

Wirtualne hosting to bardzo wydajna technika zarządzania wieloma stronami internetowymi z jednego serwera. W tym laboratorium widzieliśmy, w jaki sposób Terraform można wykorzystać do wdrażania prostej infrastruktury dwupoziomowej. Staraj się, aby ta konfiguracja była bardziej skalowalna, wdrażając moduły Terraform.