HTTPD - Servidor Web Apache2 (Apache2 Web Server)
Tags: devops, distributedsystems, asf
Published: 2023-05-24 21:25:47

<a href="https://hub.docker.com/_/httpd"><img src="https://cdn.worldvectorlogo.com/logos/apache-13.svg" align="right" height="77">

Dentre os programas mais utilizados em servidores da internet em todo o mundo está o **Apache**. Para começar este tópico, precisamos entender o que é o **Apache** e o papel que ele desempenha em servidores.
  
O **Apache**, também conhecido como **Httpd**, é um _servidor HTTP_ ou, como muitos chamam, um servidor Web (Web Server). Ele é responsável por receber e processar requisições enviadas por clientes HTTP. Quando acessamos um site, do outro lado estamos sendo atendidos por um servidor HTTP.

Os **Servidores HTTP** são executados em processos do tipo background, ou seja, sem intervenção manual de um administrador para responder às solicitações recebidas.

O Apache se destaca por ser um software de alta confiabilidade, gratuito e de código-fonte aberto, permitindo que qualquer pessoa possa modificá-lo para uso pessoal ou contribuir com melhorias para a comunidade de usuários.
  
Sobre o processamento de um servidor Apache rodando, quando chega uma requisição, esse processo cria um novo processo e trata essa requisição, depois mata esse processo e fica tudo certo. Só que isso é muito custoso. Criar um processo, fazer a mudança de contexto de um processo para o outro e depois matar um processo. Isso é uma tarefa custosa. Outros servidores web, resolveram esse processo, você verá a diferença com Nginx.
  
<img src="https://upload.wikimedia.org/wikipedia/commons/d/db/Apache_Software_Foundation_Logo_%282016%29.svg" align="right" height="177">
  
O Apache é mantido pela **The Apache Software Foundation** e um grande número de programadores contribui com o seu desenvolvimento. Como possui diversos módulos opcionais para variadas funcionalidades, tem grande versatilidade.
  
> **Atenção**: É importante frisar que diferentes distribuições Linux utilizam distintos esquemas de organização das configurações do Apache. Neste tema, abordaremos a organização usada nas distribuições baseadas no Debian, como a Ubuntu Linux.

Mais importante do que entender a organização é compreender a lógica de administração. Assim, você saberá do que precisa quando se deparar com uma distribuição que utiliza um esquema diferente.
  
## INSTALAÇÃO DO APACHE
<div align="center"><img src="https://upload.wikimedia.org/wikipedia/commons/1/10/Apache_HTTP_server_logo_%282019-present%29.svg" height="177"></div><br />

Geralmente, o Apache pode ser instalado por dois caminhos:
  
<details><summary><b title="(click to open)">Caminho 1</b></summary>
  
Baixando seu código-fonte e compilando-o. Apesar de existir farta documentação, é uma atividade mais complexa e exige a instalação prévia de bibliotecas, compiladores etc. Em geral, é a opção para usuários avançados e em casos mais específicos.
  
</details>  
  
<details><summary><b title="(click to open)">Caminho 2</b></summary>

O segundo caminho, mais simples, é a instalação por meio de pacotes fornecidos pelas principais distribuições Linux. Os pacotes já trazem o programa pronto para executar, além de bibliotecas e outras dependências. As rotinas de atualização também são facilitadas, assim como a instalação de módulos opcionais.
  
</details>  
  
A instalação do Apache na distribuição Ubuntu/Debian Linux é feita com o comando:

```sh
sudo apt install apache2 \ 
  sudo service apache2 start \
  sudo service apache2 -h \
  sudo service apache2 -v \
  sudo service apache2 status
```
  
Caso queira instalar o Apache na distribuição Fedora/CentOS/Red Hat Enterprise Linux é feita com o comando:
  
```sh
sudo yum install httpd \
  sudo systemctl enable httpd \
  sudo systemctl start httpd
```
  
Caso esteja instalando pelo código-fonte: https://httpd.apache.org/docs/2.4/en/install.html
  
O ‘apt’ é o programa gerenciador de pacotes usado pelo Ubuntu. Ele irá obter na internet os pacotes do Apache e fará sua instalação. Após isso, o Apache estará configurado com uma página inicial de demonstração, que pode ser acessada a partir de outro computador.

Usando o comando `ip addr`, obtenha o endereço IP do servidor. Em outra máquina, na mesma rede, abra um navegador (Internet Explorer, Firefox, Chrome) e digite o endereço do servidor. Exemplo: http://192.168.1.70
  
Mas, no meu caso, farei simplesmente no localhost, cujo basta somente dar o comando `sudo service apache2 start`, com o endereço: http://127.0.0.1

![Sem título](https://user-images.githubusercontent.com/61624336/183773307-5b48cf7e-14a1-493c-88d5-a966a5ca7402.png)

> Ao aparecer essa tela, isso significa que seu web server está funcionando corretamente!
  
### Alterar a página inicial do Apache:

```sh
sudo nano /var/www/html/index.html
```
  
### Configuração do Apache
  
```sh
cd /etc/apache2/ && ls
```
  
```sh
sudo nano /etc/apache2/apache2.conf
```
  
```sh
sudo nano /etc/apache2/ports.conf
```
  
### Mudando a porta do Apache
  
[![Apache2.conf](https://img.shields.io/badge/-apache2.conf-fff?style=social&logo=Apache&logoColor=D22128)](#)
  
```apache
Listen 801
```

> Após mudar o endereço da porta, você deve reiniciar o Apache!
  
Antes, era comum escrever toda a configuração do Apache em um único arquivo, como o ‘/etc/httpd.conf’.

O problema dessa abordagem é que, quanto mais sites eram criados no servidor, maior ficava esse arquivo, até ser impraticável administrá-lo. Para piorar, aumentavam as chances de se cometer um erro acidental na configuração, afetando todo o servidor.

Não era incomum o servidor sair do ar, e consequentemente todos os sites hospedados, por um erro acidental, muitas vezes difícil de ser diagnosticado.
  
> Para facilitar a administração, a configuração do Apache passou a ser modularizada, composta por diversos arquivos, organizados por tipo de configuração, em diretórios específicos.

Uma árvore de diretórios de configuração típica está representada a seguir:

<pre>
/etc/apache2/
├── conf-available
├── conf-enabled
├── mods-available
├── mods-enabled
├── sites-available
└── sites-enabled
</pre>

### Arquivos do Apache
No diretório '/etc/apache2' estão localizados arquivos com configurações globais do Apache. Entre eles:  
- [![.RB](https://img.shields.io/badge/-ports.conf-fff?style=social&logo=Apache&logoColor=D22128)](#) , em que são declaradas as portas TCP que o Apache abre para receber solicitações – Por padrão, `80` para HTTP e `443` para HTTPS.
- [![.RB](https://img.shields.io/badge/-apache2.conf-fff?style=social&logo=Apache&logoColor=D22128)](#) , o arquivo principal de configuração. Mas, nenhuma configuração deve ser incluída aqui. Por padrão, esse arquivo contém instruções para que as configurações sejam obtidas nos demais arquivos e diretórios.

### Divisão dos diretórios em grupos
Dentro de `/etc/apache2` há seis diretórios, divididos em três grupos:
- `conf` - Para configurações gerais do Apache.
- `mods` - Para configuração de módulos.
- `sites` - Para configuração de sites.
  
### Leitura dos arquivos
Para cada um desses grupos, há um diretório ‘available’ (disponível) e um ‘enabled’ (habilitado). Quando o Apache é iniciado, ele lê todos os arquivos dos diretórios ‘enabled’:
  
- `/etc/apache2/conf-enabled`
- `/etc/apache2/mods-enable`
- `/etc/apache2/sites-enabled`
  
Cada um dos arquivos presentes nesses diretórios será lido e sua configuração carregada pelo Apache. Se listarmos, porém, o conteúdo de qualquer um desses diretórios, veremos que todos os seus arquivos são, na verdade, links.

<pre>
$ ls –l /etc/apache2/conf-enabled
lrwxrwxrwx 1 root root 30 May 26 12:53 charset.conf -> ../conf-available/charset.conf
lrwxrwxrwx 1 root root 44 May 26 12:53 localized-error-pages.conf -> ../conf-available/localized-
lrwxrwxrwx 1 root root 46 May 26 12:53 other-vhosts-access-log.conf -> ../conf-available/other-
lrwxrwxrwx 1 root root 31 May 26 12:53 security.conf -> ../conf-available/security.conf
lrwxrwxrwx 1 root root 36 May 26 12:53 serve-cgi-bin.conf -> ../conf-available/serve-cgi-bin.conf
</pre>
  
Observe o `l` no início de cada linha, indicando que se trata de links simbólicos.

Todos os links no diretório `conf-enabled` apontam para arquivos que estão no respectivo diretório `conf-available`. 

Mas por que essa organização? Para permitir que as configurações possam ser escritas livremente e só ativadas quando desejado. Um arquivo nos diretórios 'available' não será lido pelo Apache. Isso permite que escrevamos uma configuração, mas só a ative posteriormente, criando o link em ‘enabled’ para esse arquivo.

Assim, o Apache pode trazer diversas configurações de módulos opcionais que permanecerão inativas até que o administrador as ative manualmente. Isso vale para as configurações de site. É possível retirar um site do ar meramente apagando o ‘link’ da configuração deste, não sendo necessário editar arquivos com outras configurações.

Nos diretórios ‘available’ estarão os arquivos de texto com as configurações, ativas ou não. Nos diretórios ‘enabled’ existirão apenas links para as configurações ativas.

> **Exemplo**: O arquivo `/etc/apache2/mods-available/ssl.conf` possui configurações para ativar o protocolo criptografado HTTPS. Se o seu servidor não vai utilizar esse recurso, não há necessidade de ter esse módulo habilitado. Por outro lado, para ativar o HTTPS, basta criar o link no diretório ‘enabled’ e o recurso estará disponível para uso.
  
> **Importante**: O nome dos arquivos de configuração deve terminar com `.conf`.
  
## ATIVANDO E DESATIVANDO MÓDULOS, CONFIGURAÇÕES E SITES
Sabemos que para ativar as configurações devem ser criados links nos diretórios ‘enabled’ apontando para arquivos no diretório ‘available’. No entanto, o Apache traz comandos que facilitam essa tarefa:
  
<details><summary><b title="(click to open)"><code>a2enconf</code> e <code>a2disconf</code></b></summary>

O comando `a2enconf` habilita (enable) as configurações, enquanto o `a2disconf` as desabilita (disable). Exemplo de uso: 

```sh
sudo a2enconf charset
```
  
O nome da configuração é passado no argumento, e a terminação `.conf` dos arquivos pode ser omitida. 

Nesse exemplo, foi ativada a configuração `charset`. O programa criou o link: `/etc/apache2/conf-enabled/charset.conf` apontando para `/etc/apache2/conf-available/charset.conf`
  
Os comandos para habilitar e desabilitar módulos e sites são semelhantes.
  
</details>  
  
<details><summary><b title="(click to open)"><code>a2enmod</code> e <code>a2dismod</code></b></summary>
  
O comando `a2enmod` habilita módulos opcionais do Apache, enquanto o `a2dismod` desabilita.

</details>
    
<details><summary><b title="(click to open)"><code>a2ensite</code> e <code>a2dissite</code></b></summary>
  
O comando `a2ensite` habilita sites, enquanto o `a2dissite` desabilita.

</details>
  
> Após qualquer alteração nas configurações, é necessário avisar ao Apache para que ele as releia ou reinicie o processo.
  
Para as tarefas de controle do processo do Apache existe o comando `apache2ctl`, que oferece diversas opções. Entre elas:
  
```sh
apache2ctl start
```

Inicia o processo do Apache, retornando erro se o processo já estiver executando.

```sh
apache2ctl restart
```

Encerra e reinicia o processo do Apache. Não deve ser usado apenas para carregar novas configurações, pois as requisições em andamento serão interrompidas imediatamente. Deve-se usar com cuidado, já que eventuais erros de configuração poderão impedir o processo de reiniciar, deixando-o parado.

```sh
apache2ctl configtest
```

Executa uma análise dos arquivos de configuração do Apache em busca de erros de sintaxe, sem interferir com o processo em execução. Deve-se observar que nem todo erro será detectável por esse teste.

```sh
apache2ctl graceful
```
  
Envia um sinal para o Apache reiniciar, relendo os arquivos de configuração, porém sem interromper as requisições em andamento. Se o processo não estava em execução, ele é iniciado. Também é possível que erros na configuração impeçam o processo de reiniciar, deixando-o parado.

```sh
apache2ctl stop
```

Encerra o processo do Apache. Nenhuma nova requisição será recebida e os usuários receberão um aviso do tipo “servidor inacessível”.

```sh
apache2ctl status
```
  
Exibe informações sobre o processo em execução do Apache. Há também o argumento `fullstatus`, com informações detalhadas sobre as requisições sendo atendidas (requer o módulo `mod_status` habilitado).

Como já vimos, quando o Apache é instalado é feita uma configuração inicial com uma página de teste. O nome do arquivo deste site pode variar dependendo da distribuição Linux.

Nas distribuições Debian e Ubuntu, esse arquivo é o `/etc/apache2/sites-enables/000-default.conf` e seu conteúdo é reproduzido a seguir:
  
[![Apache2.conf](https://img.shields.io/badge/-apache2.conf-fff?style=social&logo=Apache&logoColor=D22128)](#)

```vim
<VirtualHost *:80>
        # The ServerName directive sets the request scheme, hostname and port that
        # the server uses to identify itself. This is used when creating
        # redirection URLs. In the context of virtual hosts, the ServerName
        # specifies what hostname must appear in the request's Host: header to
        # match this virtual host. For the default virtual host (this file) this
        # value is not decisive as it is used as a last resort host regardless.
        # However, you must set it for any further virtual host explicitly.
        #ServerName www.example.com

        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/html

        # Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
        # error, crit, alert, emerg.
        # It is also possible to configure the loglevel for particular
        # modules, e.g.
        #LogLevel info ssl:warn

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined

        # For most configuration files from conf-available/, which are
        # enabled or disabled at a global level, it is possible to
        # include a line for only one particular virtual host. For example the
        # following line enables the CGI configuration for this host only
        # after it has been globally disabled with "a2disconf".
        #Include conf-available/serve-cgi-bin.conf
</VirtualHost>
```

O arquivo parece grande, mas repare que muitas linhas começam com o caractere ‘#’. Toda linha iniciada com o ‘#’ é considerada comentário e não é lida pelo Apache. As linhas em branco também são ignoradas.

> **Atenção**: A maioria dos arquivos de configuração no Linux usa essa mesma lógica, assim, é fácil inserir textos, comentários e observações para serem lidos por pessoas e não pela máquina.

Portanto, desse arquivo, o que será efetivamente lido pelo Apache é somente isso:

[![Apache2.conf](https://img.shields.io/badge/-apache2.conf-fff?style=social&logo=Apache&logoColor=D22128)](#)

```vim
<VirtualHost *:80>
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/html
        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>  
```

> Uma diretiva importante na configuração do Apache é a `< VirtualHost >`, que nos possibilita configurar o endereço do servidor que irá responder por um site e a respectiva porta. Essa diretiva é uma das mais importantes na configuração de um site no Apache. Por meio dela é possível definir o endereço pelo qual o servidor irá responder e a porta que será usada. Sites que atendem pelos protocolos HTTP (porta `80`) e HTTPS (porta `443`) precisarão ser definidos com duas diretivas, uma para cada porta.

> Uma diretiva importante de configuração do Apache é a `DocumentRoot`, usada na definição de sites. Essa diretiva tem como objetivo indicar o diretório onde estão os arquivos que compõem determinado site. Ou seja, informa ao Apache em qual diretório do sistema está a raiz do site, ou seja, todo e qualquer recurso acessível pelo site deverá estar nesse diretório.
## EXAMINANDO O ARQUIVO DE CONFIGURAÇÃO
Antes de analisar o significado de cada uma dessas linhas, precisamos ter em mente qual é o objetivo dessa configuração: trata-se de uma configuração inicial, com uma página simples de demonstração, a única presente no servidor.

Em um servidor com vários sites, existirão vários arquivos de configuração semelhantes a esse, um para cada site.
  
### `<VirtualHost *:80>`
A diretiva `<VirtualHost>` permite configurar os endereços e as portas em que o site responde. 

Um servidor Linux pode ser configurado com diversos endereços IP.  O Apache permite que determinados sites respondam em somente um desses endereços. É possível, por exemplo, designar um endereço IP para cada site. A desvantagem desse tipo de configuração é que você precisará de novos endereços para cada novo site, o que nem sempre é possível. 

A configuração mais usada hoje consiste em um único endereço IP sendo usado para atender a diversos sites. 

Nessa linha de `<VirtualHost>`, o `*:80` significa que o site responderá em todos os endereços IP do servidor e na porta `80`. 

Lembre-se que a porta `80` é a padrão (*well known port*) para o protocolo HTTP, assim como a porta `443` é a padrão para o protocolo HTTPS. A princípio, qualquer porta pode ser utilizada pelo Apache, se já não estiver em uso por outro processo. Mas será necessário divulgar, além do endereço, o número da porta para compor a URL.

Por exemplo, se for usada a porta `8000`, a URL será: http://www.meusite.com:<b>8000</b>
  
### `ErrorLog /var/log/apache/error.log`
A diretiva `ErrorLog` define em que arquivo serão gravados os registros (logs) de erro. A cada erro ocorrido, uma nova linha é gerada nesse arquivo, com as informações sobre ele, além de data e hora.

### `ServerAdmin webmaster@localhost`
Informação que será passada a um cliente em caso de erro no acesso ao site, contendo um e-mail para contato.

### `CustomLog /var/log/apache/access.log combined`
A diretiva `CustomLog` define em que arquivo serão gravados os registros de acesso aos sites. O parâmetro `combined` define um formato predeterminado para esses registros.

### `DocumentRoot /var/www/html`
Uma das configurações mais importantes de um site é onde está seu conteúdo. Nesse caso, o diretório `/var/www/html`.

## A DIRETIVA `DIRECTORYINDEX`
O acesso a um site é sempre feito por meio de uma URL (Uniform Resource Locator) digitada no navegador. A URL é, em resumo, uma frase que contém todas as informações para localizar um recurso como site ou arquivo.
  
> **Exemplo**: http://site-exemplo.com/info.html
  
Nessa URL constam o protocolo (HTTP), o endereço do site (`site-exemplo.com`) e o nome do recurso procurado (`info.html`). O cliente (navegador) se conecta ao servidor do site e requisita o recurso `info.html`. Nesse exemplo, o servidor Apache buscaria o arquivo `info.html` no diretório do site e o enviaria ao cliente.

Muitas vezes, porém, usamos uma URL sem indicar um recurso, como em `http://site-exemplo.com`.
  
Nesses casos, como o Apache sabe que arquivo buscar?

Para esta função, há a diretiva `DirectoryIndex`, que permite definir um ou mais arquivos que serão procurados pelo Apache, em ordem.
  
> **Exemplo**: `DirectoryIndex principal.html` define o nome do arquivo a ser procurado.
>
> `DirectoryIndex principal.html opcional.html` o Apache procurará o arquivo `principal.html`. Se não encontrar, irá procurar o `opcional.html`.
  
Na ausência dessa diretiva, o Apache assume como padrão o arquivo `index.html`.

## <a href="https://play.yduqs.videolib.live/index.html?token=4118b3a8b85f439c8b4cd63d306e8e0e">CONFIGURANDO DOIS SITES (Múltiplos)</a> NO MESMO SERVIDOR APACHE
  
<div align="center"><img src="https://user-images.githubusercontent.com/61624336/199121160-c169c713-3206-4344-a25a-b6e6a8c075b4.jpg" height="277"></div><br />

Atualmente, é muito comum um servidor hospedar diversos sites independentes utilizando somente um endereço IP (`192.168.0.30`). A diretiva `Servername` permite determinar na configuração do site o nome (domínio) pelo qual ele responderá.
  
> Mas é importante lembrar que o cliente deverá conseguir resolver esse nome, assim, não basta configurar o Apache para responder por ele, também é preciso registrá-lo em um <a href="">servidor DNS</a>.

Vamos simular a configuração de dois sites em um servidor Apache?

Na tabela a seguir, relacionaremos todas as informações necessárias para a configuração:
  
<table>
  <tr>
    <td></td>
    <td>Site A</td>
    <td>Site B</td>
  </tr>
  
  <tr>
    <td>Nome (domínio) do site</td>
    <td>www.site-test1.com</td>
    <td>www.site-teste2.com</td>
  </tr>
  
  <tr>
    <td>Diretório com o conteúdo do site</td>
    <td>/var/www/site-teste1</td>
    <td>/var/www/site-teste2</td>
  </tr>
    
  <tr>
    <td>Arquivo "principal" (DirectoryIndex)</td>
    <td>index.html</td>
    <td>default.htm</td>
  </tr>
    
  <tr>
    <td>Arquivo de configuração (/etc/apache2/sites-available)</td>
    <td>site-teste1.conf</td>
    <td>site-teste2.conf</td>
  </tr>
  
</table>

### Criando os diretórios para os sites
Também é necessário colocar o conteúdo. Nesse exemplo, copiaremos o arquivo de demonstração (`/var/www/html/index.html`) para este fim.

```sh
sudo mkdir /var/www/site-teste1
```

```sh
sudo cp /var/www/html/index.html /var/www/site-teste1
```

```sh
sudo mkdir /var/www/site-teste2
```

```sh
sudo cp /var/www/html/index.html /var/www/site-teste2/default.htm
```

Repare que, no segundo exemplo, o arquivo foi copiado mudando o nome para `default.htm`. 

**Lembre-se**: O nome e o caminho do arquivo HTML de demonstração, que usamos como base, variam conforme a distribuição Linux. Qualquer arquivo HTML pode ser usado como conteúdo nesse teste.

**Importante**: O Apache é executado por um usuário com poucos privilégios. O nome do usuário varia com a distribuição Linux: `www-data`, `apache` etc. É importante que os arquivos nos diretórios dos sites (`/var/www/site-teste1` etc.) possam ser lidos pelo usuário do Apache. Uma opção é garantir que os arquivos possuam permissão de leitura para outros e os diretórios, permissões de leitura `r` e de acesso `x` também para outros.
  
### Criando os arquivos de configuração para os sites
Usando um editor de textos, como o Vim ou nano, criamos o arquivo `/etc/apache2/sites-available/site-teste1.conf` e o preenchemos com o seguinte conteúdo:
  
[![Apache2.conf](https://img.shields.io/badge/-site_teste1.conf-fff?style=social&logo=Apache&logoColor=D22128)](#)

```vim
<VirtualHost *:80>
        ServerName www.site-teste1.com
        ServerAdmin webmaster@site-teste1.com
        DocumentRoot /var/www/site-teste1
        DirectoryIndex index.html
        ErrorLog /var/log/apache2/site-teste1-error.log
        CustomLog /var/log/apache2/site-teste1-access.log combined
</VirtualHost>
```

Do mesmo modo, criamos o arquivo `/etc/apache2/sites-available/site-teste2.conf` e o preenchemos:

[![Apache2.conf](https://img.shields.io/badge/-site_teste2.conf-fff?style=social&logo=Apache&logoColor=D22128)](#)

```vim
<VirtualHost *:80>
        ServerName www.site-teste1.com
        ServerAdmin webmaster@site-teste2.com
        DocumentRoot /var/www/site-teste2
        DirectoryIndex index.html
        ErrorLog /var/log/apache2/site-teste1-error.log
        CustomLog /var/log/apache2/site-teste1-access.log combined
</VirtualHost>
```
  
### Habilitando os sites
```sh
sudo a2ensite site-teste1
```
  
```sh
sudo a2ensite site-teste2
```

### Enviando um sinal para o Apache reler as configurações
```sh
sudo apache2ctl graceful
```

É possível acessar os novos sites a partir de um navegador, simulando o acesso de um usuário comum. Isso poderá ser feito a partir de um computador executando o sistema operacional Windows.

No entanto, é preciso que o navegador consiga resolver os nomes dos sites para o endereço do servidor Apache. Como os domínios dos sites que criamos não existem na internet, será necessário “enganar” o Windows.

> O procedimento a seguir deve ser feito com cautela, pois pode causar danos ao Windows. Será necessário que o usuário tenha permissão de administrador do sistema.

1. Execute o editor notepad como administrador.
2. Abra o arquivo `C:\Windows\System32\drivers\etc\HOSTS`
3. Inclua as seguintes linhas, trocando o endereço IP pelo endereço IP do servidor Apache que você obteve com o comando `ip addr`.

```
192.168.1.70 www.site-teste1.com
192.168.1.70 www.site-teste2.com
```

> Salve o arquivo. Não se esqueça de desfazer essa configuração após terminar seus testes.

Essa alteração fará com que o Windows reconheça os endereços dos novos sites, mesmo que eles não existam na internet.

No seu computador com Windows, abra um navegador de sua preferência. Digite os sites configurados: www.site-teste1.com e www.site-teste2.com.

Os dois sites serão exibidos da mesma maneira, pois o conteúdo é o mesmo, obtido na página de demonstração. Mesmo sem conhecer HTML, edite esses arquivos e faça uma pequena alteração no texto deles. Recarregue as páginas no seu navegador e veja as alterações. Confira alguns exemplos e aproveite para praticar!

### Prática 1 - Apache2
Na configuração dos sites, indicamos arquivos de log em que o Apache incluirá os registros de acessos, um por linha:

Busque esses arquivos e veja o seu conteúdo. Observe o formato e as informações que ele contém. Você pode usar o comando `less ARQUIVO`. 

### Prática 2 - Apache2
Vamos acessar um recurso que não existe no servidor e veremos o que acontece:

No seu navegador, busque um recurso inexistente no site. Por exemplo, digite a URL: `http://www.site-teste1.com/abc.html`

Como não existe um recurso com o nome `abc.html`, o Apache retornará uma página com o conhecido `erro 404` (recurso não encontrado). 

### Habilitanto o HTTPS - Apache2
Uma limitação do protocolo HTTP é que ele não conta com a criptografia dos dados para tráfegos, sendo possível que um terceiro consiga interceptar as informações transmitidas e até modificá-las. Para resolver essa fragilidade, foi criado o protocolo HTTPS que é, basicamente, o protocolo HTTP com uma camada adicional de criptografia.

Atualmente, é considerado obrigatório que um site utilize o HTTPS se transmite dados pessoais de um usuário, solicita senhas, cartão de crédito etc.

O **HTTPS** é simples de configurar no Apache, mas pode parecer complicado porque se baseia em **certificação digital** e são necessárias algumas ações, além da simples configuração de um arquivo.

Em poucas palavras, o **certificado digital** é como um documento autenticado no cartório, afirmando que você é realmente quem diz ser. O cartório desse exemplo são as autoridades certificadoras (CA).

O processo de obtenção de um certificado deve seguir alguns passos:

- Criação das chaves criptográficas (pública e privada). 
- Elaboração da requisição de certificado (CSR).
- Envio da requisição (CSR) a uma autoridade certificadora (CA).
- Emissão do certificado pela autoridade certificadora (CA).
- Instalação do certificado digital emitido pela autoridade certificadora (CA). 
- É importante lembrar que a maioria das autoridades certificadoras cobra pelo serviço, já que precisa realizar verificações de segurança. O valor varia dependendo do tipo de certificado solicitado e da autoridade certificadora. 

Vamos habilitar o protocolo HTTPS no site `www.site-teste1.com`. Nessa atividade, assumiremos o papel da autoridade certificadora, gerando um certificado do tipo **self­-signed** (assinado por mim). Na prática, esse tipo de certificado não é reconhecido por nenhum navegador e sempre será exibido um aviso de segurança. 

Lembre-se de que esse é um procedimento simplificado, pois nosso objetivo é a configuração do Apache. Sempre que for gerar um certificado, leia as instruções da autoridade certificadora escolhida, que costuma disponibilizar procedimentos detalhados.

Para gerar nosso **certificado self-signed**, usaremos o comando a seguir (tudo em uma única linha):

```sh
sudo openssl req -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout /etc/ssl/private/site-teste1.key -out /etc/ssl/certs/site-teste1.crt
```

Se o comando `openssl` não for encontrado, será necessário instalar esse pacote de software. Verifique a documentação da distribuição Linux que estiver usando.

Por exemplo: No Ubuntu Linux, a instalação é feita com o comando:

```sh
sudo apt install openssl
```

O comando `openssl` é uma ferramenta para gerenciamento, entre outras coisas, de chaves criptográficas. Nessa única linha estamos gerando as chaves (criptografia RSA de 2048 bits), preparando a requisição e emitindo um certificado com 365 dias de validade.

Chegou o momento de entrar com os dados do novo certificado:

```
Country Name (2 letter code) [AU]:BR
State or Province Name (full name) [Some-State]:Rio de Janeiro
Locality Name (eg, city) []:Nome da cidade
Organization Name (eg, company) []:Minha Empresa LTDA
Organizational Unit Name (eg, section) []:Departamento de TI
Common Name (e.g. server FQDN or YOUR name) []:www.site-teste1.com
Esse é o endereço do seu site.
Email Address []: Não é necessário preencher o e-mail.
```

Ao término, dois arquivos são gerados nos caminhos indicados: a chave criptográfica e o certificado digital. Nesse exemplo foram escolhidos os diretórios `/etc/ssl/private` e `/etc/ssl/certs`, padrão na distribuição Ubuntu, porém você pode criar outro diretório para esses arquivos.

**Atenção**: O arquivo `site-teste1.key` contém a chave privada do seu certificado e deve ser protegido ao máximo, pois um invasor será capaz de decifrar a comunicação do servidor, além de forjar um site com o mesmo domínio. É recomendável que o arquivo possua proprietário e grupo `root` e permissão do tipo `400` ou `600`. Sempre confira a segurança das suas chaves privadas!

A **chave pública** está armazenada junto ao certificado digital, e ambos são entregues aos usuários quando se conectam ao servidor.

O próximo passo é configurar o Apache:

Habilite o módulo de ssl do Apache (SSL é a camada criptográfica usada pelo HTTPS).

```sh
a2enmod ssl
```

Inclua o seguinte conteúdo no final do arquivo de configuração, sem modificar o conteúdo que já existe (`/etc/apache2/sites-available/site-teste1.conf`).

```xml
<VirtualHost *:443>
ServerName www.site-teste1.com 
ServerAdmin webmaster@site-teste1.com
DocumentRoot /var/www/site-teste1
DirectoryIndex index.html
ErrorLog /var/log/apache2/site-teste1-error.log
CustomLog /var/log/apache2/site-teste1-access.log combined
 
SSLEngine on
SSLCertificateFile      /etc/ssl/certs/site-teste1.crt
SSLCertificateKeyFile /etc/ssl/private/site-teste1.key 
</VirtualHost>
```

Repare que é um conjunto de diretivas iguais às já existentes com quatro diferenças: a primeira é a porta `443` na diretiva `<VirtualHost>` – lembrando que o **protocolo HTTPS tem porta padrão 443**; as outras são as três últimas linhas, onde a diretiva `SSLEngine` ativa o uso da camada SSL e as demais indicam onde estão a chave e o certificado digital.

Carregue a nova configuração no Apache:

```sh
apache2ctl graceful
```

<img src="https://user-images.githubusercontent.com/61624336/203377361-d11b1a75-8c81-4e3a-b1f0-94a39a27d953.jpg" align="right">
	
Acesse o site: `https://www.site-teste1.com`. (Atenção ao https)

Uma mensagem de segurança será exibida, afinal o certificado não foi emitido por uma CA conhecida e confiável. Selecione a opção para acessar assim mesmo. Você deverá ver o seu site. A diferença é que agora toda a comunicação ocorreu por um canal criptografado.

No navegador, peça para exibir o certificado digital do site e veja os dados que foram digitados na requisição:

Repita o procedimento e habilite o HTTPS também para o domínio `www.site-teste2.com`.

### REFERÊNCIAS
- APACHE HTTP SERVER PROJECT. Documentação do servidor HTTP Apache versão 2.4. Consultado em meio eletrônico em: 17 jul. 2020.
- MAXWELL, S. Administração de sistemas Unix. 1. ed. Rio de Janeiro: Ciência Moderna, 2003.
- MOTA FILHO, J. Descobrindo o Linux: Entenda o Sistema Operacional GNU/Linux. 3. ed. São Paulo: Novatec, 2012.
- PETERSEN, R. Ubuntu 18.04 LTS Server: Administration and Reference. 1. ed. Surfing Turtle Press, 2018. 
- UBUNTU SERVER GUIDE.  HTTPD Apache2 Web server. Consultado em meio eletrônico em: 17 jul. 2020.\
- UBUNTU DOCUMENTATION. Ubuntu desktop guide. Consultado em meio eletrônico em: 17 jul. 2020.