Como configurar os hosts virtuais do Apache na instância do Ubuntu EC2 usando o Terraform

“Para hospedar vários sites, os administradores geralmente configuram a hospedagem virtual em uma única máquina. Na hospedagem virtual, podemos usar uma hospedagem "baseada em IP" ou um "baseado em nomes."Na hospedagem" baseada em IP ", temos endereços IP distintos para cada site. No caso de hospedagem "baseada em nome", temos vários nomes em execução em cada endereço IP.”

O que vamos cobrir?

Neste guia, veremos como podemos configurar hosts virtuais em um Amazon EC2 Ubuntu 22.04 instância. Neste laboratório, usaremos a hospedagem virtual baseada em nomes. Usaremos a Terraform para implantar a infraestrutura desejada.

Visão geral do laboratório

Neste laboratório, criaremos dois hosts virtuais; domain1 e domain2. Instalaremos um servidor da Web Apache em nossa máquina Ubuntu. Cada host virtual tem um índice diferente.Arquivo HTML com o conteúdo: “Este é o host virtual 1.”Para domain1 e“ Este é o host virtual 2.”Para domínio2.

Em vez de registrar o nome de domínio para cada host, estamos usando o endereço IP do host local para mapear os nomes de domínio. Isso pode ser feito modificando o arquivo "hosts". Para simplificar a implantação desta infraestrutura, dividimos a configuração geral em vários arquivos. Dessa forma, nos salvaremos da falta de jeito de código. Contornos dos arquivos usados ​​aqui:

1. dados do usuário.sh: Contém o script necessário para instalar e configurar o servidor da web Apache na instância do Ubuntu.
2. secgrp.tf: Cria um grupo de segurança a ser usado com a instância. Este grupo de segurança permitirá que o SSH e o HTTP entrem no tráfego na instância.
3. domain_2.conf e domain_1.conf: Contém configuração do host virtual.
4. principal.tf: O ponto de entrada primário/principal para todos os .arquivos TF.

Configurando a configuração

Passo 1. Vamos primeiro criar um diretório de trabalho que mantenha todos os nossos .arquivos TF:

$ MKDIR Demo

Passo 2. Crie os dados do usuário.Arquivo SH:

$ nano userData.sh

Agora cole as seguintes linhas dentro dele:

#!/BIN/BASH
Atualização de sudo apt-get
sudo apt -get upgrade -y
sudo apt -get install apache2 -y
sudo systemctl reiniciar apache2
sudo sh -c "eco 127.0.0.1 www.domain1.com >> /etc /hosts "
sudo sh -c "eco 127.0.0.1 www.domain2.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 é o host virtual 1.”>/Var/www/domain_1/public_html/index.html
sudo echo “Este é o host virtual 2.”>/Var/www/domain_2/public_html/index.html
sudo cp/home/ubuntu/domain_1.conf/etc/apache2/sites-available/domain_1.conf
sudo cp/home/ubuntu/domain_2.conf/etc/apache2/sites-available/domain_2.conf
Sudo domínio A2ensite_1.conf
SUDO A2ensite domain_2.conf
sudo a2dissite 000-default.conf
sudo systemctl reiniciar apache2

No script acima, instalamos um servidor da web do Apache e modificamos o arquivo do host para mapear o endereço do local para os dois nomes de domínio dos hosts virtuais que queremos configurar. Além disso, configuramos o servidor da web para os novos sites e desativou o padrão.

etapa 3. Crie o SECGRP.arquivo TF para permitir o tráfego de entrada de ssh e http de qualquer lugar e tráfego de saída para qualquer lugar.

$ nano secgrp.tf

Cole as seguintes linhas dentro dele:

Recurso "AWS_SECURITY_GROUP" "Demo-SG"
name = "sec-grpg"
Descrição = "Permitir tráfego HTTP e SSH via Terraform"
Ingressão
de_port = 80
to_port = 80
protocolo = "tcp"
cidr_blocks = ["0.0.0.0/0 "]

Ingressão
de_port = 22
to_port = 22
protocolo = "tcp"
cidr_blocks = ["0.0.0.0/0 "]

saída
de_port = 0
to_port = 0
protocolo = "-1"
cidr_blocks = ["0.0.0.0/0 "]

Passo 4. Para configuração do host virtual, crie dois arquivos: domain_1.conf e domain_2.conf. Observe o local da raiz do documento em cada arquivo.

EU. $ nano domain_1.conf

ServerAdmin [email protected]
ServerName Domain1
Serveralias www.domain1.com
Documentroot/var/www/domain_1/public_html
ErrorLog $ apache_log_dir/erro.registro

Ii. $ nano domain_2.conf

ServerAdmin [email protected]
ServerName Domain2
Serveralias www.domain2.com
Documentroot/var/www/domain_2/public_html
ErrorLog $ apache_log_dir/erro.registro
CustomLog $ apache_log_dir/acesso.log combinado

Etapa 5. Finalmente, crie o principal.TF para concluir a declaração de infraestrutura:

$ nano Main.tf
Provedor "AWS"
região = "US-leste-1"

Recurso "AWS_INSTANCE" "WebServer"
ami = "ami-09d56f8956ab235b3"
instance_type = "T2.micro "
key_name = "Nome-do-your-ec2-key-par"
vpc_security_group_ids = [AWS_SECURITY_GROUP.Demo-sg.eu ia]
associado_public_ip_address = true
provisionista "arquivo"
fonte = "domain_1.confis "
destino = "/home/ubuntu/domain_1.confis "
conexão
type = "ssh"
user = "Ubuntu"
private_key = "$ file ("/caminho/para // ec2-keypair.Pem ")"
host = "$ self.public_dns "


provisionista "arquivo"
fonte = "domain_2.confis "
destino = "/home/ubuntu/domain_2.confis "
conexão
type = "ssh"
user = "Ubuntu"
private_key = "$ file ("/caminho/para // ec2-keypair.Pem ")"
host = "$ self.public_dns "


user_data = "$ file (" userData.sh ")"
tags =
Nome = "Virtualhosts"


saída "ipaddress"
value = "$ aws_instance.servidor web.IP Público"

No acima .Arquivo TF, usamos o provisionista de arquivo para copiar o “domínio.conf”Arquivo do nosso sistema local para a instância do EC2. Esse "domínio.conf”Será usado como um arquivo de modelo para criar arquivos de host virtual específicos do domínio, i i.e., “Domain_1.conf ”e“ domain_2.conf ”.

Etapa 6. Todos os nossos arquivos de configuração estão prontos agora; agora é hora de realmente implantar esta configuração. Inicialize o diretório do projeto usando:

$ Terraform init

Por fim, construa o projeto executando o comando:

$ Terraform se aplica

Digite "sim" no terminal quando perguntado. Na sua instância do EC2, use o comando "Curl" para ver o que cada endereço de domínio está exibindo:

Conclusão

Hosting virtual é uma técnica muito eficiente para gerenciar vários sites de um único servidor. Neste laboratório, vimos como o Terraform pode ser usado para implantar uma infraestrutura simples de dois host. Tente tornar essa configuração mais escalável, implementando módulos Terraform.