# Tutorial: crie um servidor Web e uma instância de banco de dados do Amazon RDS
<a name="TUT_WebAppWithRDS"></a>

Este tutorial mostra como instalar um servidor web Apache com PHP e criar um banco de dados MariaDB, MySQL ou PostgreSQL. O servidor web é executado em uma instância do Amazon EC2 usando o Amazon Linux 2023, e você pode escolher entre uma instância de banco de dados do MySQL ou PostgreSQL. Tanto a instância do Amazon EC2 quanto a instância de banco de dados são executadas em uma virtual private cloud (VPC) com base no serviço da Amazon VPC. 

**Importante**  
Não há cobrança para criar uma conta da AWS. No entanto, ao concluir este tutorial, é possível gerar custos para os recursos da AWS que você usa. Se esses recursos não forem mais necessários após a conclusão do tutorial, você poderá excluí-los.

**nota**  
Este tutorial funciona com Amazon Linux 2023 e pode não funcionar para outras versões do Linux.

No tutorial a seguir, crie uma instância do EC2 que usa a VPC, as sub-redes e o grupo de segurança padrão para a sua Conta da AWS. Este tutorial mostra como criar a instância de banco de dados e configurar automaticamente a conectividade com a instância do EC2 que você criou. Depois, o tutorial mostra como instalar o servidor Web na instância do EC2. Conecte o servidor Web à instância de banco de dados na VPC usando o endpoint da instância de banco de dados.

1. [Iniciar uma instância do EC2 para se conectar à instância de banco de dados](CHAP_Tutorials.WebServerDB.LaunchEC2.md)

1. [Criar uma instância de banco de dados do Amazon RDS](CHAP_Tutorials.WebServerDB.CreateDBInstance.md)

1. [Instalar um servidor Web na instância do EC2](CHAP_Tutorials.WebServerDB.CreateWebServer.md)

O diagrama a seguir mostrará a configuração quando o tutorial estiver completo.

![\[Cenário de VPC única\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/con-VPC-sec-grp.png)


**nota**  
Depois de concluir o tutorial, haverá uma sub-rede pública e privada em cada zona de disponibilidade na sua VPC. Este tutorial usa a VPC padrão para sua Conta da AWS e configura automaticamente a conectividade entre sua instância do EC2 e a instância de banco de dados. Se você preferir configurar uma nova VPC para esse cenário, conclua as tarefas em [Tutorial: Criar uma VPC para usar com uma instância de banco de dados (somente IPv4)](CHAP_Tutorials.WebServerDB.CreateVPC.md).

# Iniciar uma instância do EC2 para se conectar à instância de banco de dados
<a name="CHAP_Tutorials.WebServerDB.LaunchEC2"></a>

Crie uma instância do Amazon EC2 na sub-rede pública da VPC.

**Para iniciar uma instância do EC2**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. No canto superior direito do Console de gerenciamento da AWS, escolha a Região da AWS em que você deseja criar a instância do EC2.

1. Escolha **Painel EC2** e **Executar instância**, conforme mostrado a seguir.  
![\[Painel do EC2\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_11.png)

1. Escolha as configurações a seguir na página **Iniciar uma instância**.

   1. Em **Name and tags** (Nome e etiquetas), em **Name** (Nome), insira **tutorial-ec2-instance-web-server**.

   1. Em **Imagens de aplicações e sistemas operacionais (imagem de máquina da Amazon)**, selecione **Amazon Linux** e, depois, **AMI do Amazon Linux 2023**. Mantenha os padrões nas outras opções.  
![\[Escolha uma Imagem de máquina da Amazon\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_12.png)

   1. Em **Instance type (Tipo de instância)**, escolha **t2.micro**.

   1. Em **Key pair (login)** (Par de chaves (login)), escolha um **Key pair name** (Nome do par de chaves) para usar um par de chaves existente. Para criar um par de chaves para a instância do Amazon EC2, escolha **Create new key pair** (Criar um novo key pair), depois use a janela **Create key pair** (Criar par de chaves) para criá-lo.

      Consulte mais informações sobre como criar um par de chaves em [Criar um par de chaves](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html#create-a-key-pair) no *Guia do usuário do Amazon EC2*.

   1. Em **Network settings** (Configurações de rede), defina esses valores e mantenha os outros valores como padrão:
      + Para **Allow SSH traffic from** (Permitir tráfego SSH de), escolha a origem das conexões SSH com a instância do EC2.

        Você pode escolher **My IP** (Meu IP) se o endereço IP exibido estiver correto para conexões SSH.

        Caso contrário, determine o endereço IP a ser usado para se conectar a instâncias do EC2 em sua VPC usando Secure Shell (SSH). Para determinar seu endereço IP público, em uma janela ou guia diferente do navegador, é possível usar o serviço em [https://checkip.amazonaws.com](https://checkip.amazonaws.com). Um exemplo de endereço IP: `203.0.113.25/32`.

        Em muitos casos, você pode se conectar por meio de um provedor de serviços de Internet (ISP) ou atrás de um firewall sem um endereço IP estático. Em caso afirmativo, determine o intervalo de endereços IP utilizado por computadores cliente.
**Atenção**  
Se usar `0.0.0.0/0` para acesso do SSH, você possibilitará que todos os endereços IP acessem suas instâncias públicas usando SSH. Essa abordagem é aceitável por um período curto em um ambiente de teste, mas não é seguro em ambientes de produção. Em produção, autorize somente um endereço IP específico ou um intervalo de endereços para acessar suas instâncias usando SSH.
      + Ative **Allow HTTPs traffic from the internet** (Permitir tráfego HTTPs da Internet).
      + Ative **Allow HTTP traffic from the internet** (Permitir tráfego HTTP da Internet).  
![\[Configurar os detalhes da instância\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_14.png)

   1. Mantenha os valores padrão para as seções restantes.

   1. Revise um resumo da configuração da instância no painel **Summary** (Resumo) e, quando você estiver pronto, escolha **Launch instance** (Iniciar instância).

1. Na página **Status de inicialização**, anote o identificador de sua nova instância do EC2, por exemplo: `i-1234567890abcdef0`.  
![\[Identificador de instância do EC2 na página Status de inicialização.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/getting-started-ec2-id.png)

1. Selecione o identificador de instância do EC2 para abrir a lista de instâncias do EC2 e, depois, selecione sua instância do EC2.

1. Na guia **Detalhes**, observe os seguintes valores, necessários ao se conectar utilizando SSH:

   1. No **Resumo da instância**, observe o valor do **DNS IPv4 público**.  
![\[Nome do DNS público do EC2 na guia Detalhes da página Instâncias.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/easy-create-ec2-public-dns.png)

   1. Em **Detalhes da instância**, observe o valor do **nome do par de chaves**.  
![\[Nome do par de chaves do EC2 na guia Detalhes da página Instâncias.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/easy-create-ec2-key-pair.png)

1. Aguarde até **Instance state** (Estado da instância) exibir **Running** (Em execução) para a instância antes de continuar.

1. Completa [Criar uma instância de banco de dados do Amazon RDS](CHAP_Tutorials.WebServerDB.CreateDBInstance.md).

# Criar uma instância de banco de dados do Amazon RDS
<a name="CHAP_Tutorials.WebServerDB.CreateDBInstance"></a>

Crie uma instância de banco de dados do RDS para MariaDB, do RDS para MySQL ou do RDS para PostgreSQL que mantenha os dados usados por uma aplicação web. 

------
#### [ RDS for MariaDB ]

**Como criar uma instância do MariaDB**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. No canto superior direito do Console de gerenciamento da AWS, confira a Região da AWS. Deve ser a mesma em que você criou sua instância do EC2.

1. No painel de navegação, escolha **Databases** (Bancos de dados).

1. Selecione **Criar banco de dados**.

1. Na página **Criar banco de dados**, escolha **Criação padrão**.

1. Em **Opções do mecanismo**, escolha **MariaDB**.  
![\[Selecionar tipo de mecanismo\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/tutorial-create-mariadb.png)

1. Em **Modelos**, escolha **Nível gratuito** ou **Sandbox**. **Nível gratuito** aparece para contas do plano gratuito. **Sandbox** aparece para contas do plano pago.  
![\[Selecionar modelo\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/tutorial-create-template.png)

1. Na seção **Availability and durability** (Disponibilidade e durabilidade), mantenha as opções padrão.

1. Na seção **Settings (Configurações)**, defina estes valores:
   + **DB instance identifier** (Identificador da instância de banco de dados): digite **tutorial-db-instance**.
   + **Master username** (Nome de usuário principal): digite **tutorial\$1user**.
   + **Auto generate a password** (Gerar uma senha automaticamente): desabilite a opção.
   + **Master password** (Senha principal): digite uma senha.
   + **Confirm password (Confirmar senha)** – digite novamente a senha.  
![\[Seções de configurações\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Settings.png)

1. Na seção **Instance configuration** (Configuração da instância), defina estes valores:
   + **Classes com capacidade de intermitência (inclui classes t)**
   + **db.t3.micro**  
![\[Seção Instance configuration (Configuração da instância)\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_DB_instance_micro.png)

1. Na seção **Storage** (Armazenamento), mantenha os padrões.

1. Na seção **Connectivity** (Conectividade), defina esses valores e mantenha os outros valores como padrão:
   + Em **Compute resource** (Recurso de computação), escolha **Connect to an EC2 compute resource** (Conectar-se a um recurso de computação do EC2).
   + Em **EC2 instance** (Instância do EC2), escolha a instância do EC2 criada anteriormente, como **tutorial-ec2-instance-web-server**.  
![\[Seção de conectividade\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Connectivity.png)

1. Na seção **Autenticação de banco de dados**, verifique se **a autenticação de senha** está selecionada.

1. Abra a seção **Additional configuration (Configuração adicional)** e insira **sample** em **Initial database name (Nome do banco de dados inicial)**. Mantenha as configurações padrão para as outras opções.

1. Para criar a instância do MariaDB, escolha **Criar banco de dados**.

   Sua nova instância de banco de dados é exibida na lista **Databases (Bancos de dados)** com o status **Creating (Criando)**.

1. Aguarde o **Status** de sua nova instância de banco de dados ser mostrado como **Available (Disponível)**. Escolha o nome da instância de banco de dados para mostrar os detalhes.

1. Na seção **Connectivity & security (Conectividade e segurança)**, visualize o **Endpoint** e a **Port (Porta)** da instância de banco de dados.  
![\[Detalhes da instância de banco de dados\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Endpoint_Port.png)

   Anote o endpoint e a porta de sua instância de banco de dados. Use essas informações para conectar o servidor Web à instância de banco de dados.

1. Completa [Instalar um servidor Web na instância do EC2](CHAP_Tutorials.WebServerDB.CreateWebServer.md).

------
#### [ RDS for MySQL ]

**Para criar uma instância de banco de dados MySQL**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. No canto superior direito do Console de gerenciamento da AWS, confira a Região da AWS. Deve ser a mesma em que você criou sua instância do EC2.

1. No painel de navegação, escolha **Databases** (Bancos de dados).

1. Selecione **Criar banco de dados**.

1. Na página **Criar banco de dados**, escolha **Criação padrão**.

1. Em **Opções de mecanismo**, selecione **MySQL**.  
![\[Selecionar tipo de mecanismo\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/tutorial-create-mysql.png)

1. Em **Modelos**, escolha **Nível gratuito** ou **Sandbox**. **Nível gratuito** aparece para contas do plano gratuito. **Sandbox** aparece para contas do plano pago.  
![\[Selecionar modelo\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/tutorial-create-template.png)

1. Na seção **Availability and durability** (Disponibilidade e durabilidade), mantenha as opções padrão.

1. Na seção **Settings (Configurações)**, defina estes valores:
   + **DB instance identifier** (Identificador da instância de banco de dados): digite **tutorial-db-instance**.
   + **Master username** (Nome de usuário principal): digite **tutorial\$1user**.
   + **Auto generate a password** (Gerar uma senha automaticamente): desabilite a opção.
   + **Master password** (Senha principal): digite uma senha.
   + **Confirm password (Confirmar senha)** – digite novamente a senha.  
![\[Seções de configurações\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Settings.png)

1. Na seção **Instance configuration** (Configuração da instância), defina estes valores:
   + **Classes com capacidade de intermitência (inclui classes t)**
   + **db.t3.micro**  
![\[Seção Instance configuration (Configuração da instância)\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_DB_instance_micro.png)

1. Na seção **Storage** (Armazenamento), mantenha os padrões.

1. Na seção **Connectivity** (Conectividade), defina esses valores e mantenha os outros valores como padrão:
   + Em **Compute resource** (Recurso de computação), escolha **Connect to an EC2 compute resource** (Conectar-se a um recurso de computação do EC2).
   + Em **EC2 instance** (Instância do EC2), escolha a instância do EC2 criada anteriormente, como **tutorial-ec2-instance-web-server**.  
![\[Seção de conectividade\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Connectivity.png)

1. Na seção **Autenticação de banco de dados**, verifique se **a autenticação de senha** está selecionada.

1. Abra a seção **Additional configuration (Configuração adicional)** e insira **sample** em **Initial database name (Nome do banco de dados inicial)**. Mantenha as configurações padrão para as outras opções.

1. Para criar sua instância de Bancos de Dados MySQL, escolha **Create database (Criar banco de dados)**.

   Sua nova instância de banco de dados é exibida na lista **Databases (Bancos de dados)** com o status **Creating (Criando)**.

1. Aguarde o **Status** de sua nova instância de banco de dados ser mostrado como **Available (Disponível)**. Escolha o nome da instância de banco de dados para mostrar os detalhes.

1. Na seção **Connectivity & security (Conectividade e segurança)**, visualize o **Endpoint** e a **Port (Porta)** da instância de banco de dados.  
![\[Detalhes da instância de banco de dados\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Endpoint_Port.png)

   Anote o endpoint e a porta de sua instância de banco de dados. Use essas informações para conectar o servidor Web à instância de banco de dados.

1. Completa [Instalar um servidor Web na instância do EC2](CHAP_Tutorials.WebServerDB.CreateWebServer.md).

------
#### [ RDS for PostgreSQL ]

**Criar uma instância de banco de dados do PostgreSQL**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. No canto superior direito do Console de gerenciamento da AWS, confira a Região da AWS. Deve ser a mesma em que você criou sua instância do EC2.

1. No painel de navegação, escolha **Databases** (Bancos de dados).

1. Selecione **Criar banco de dados**.

1. Na página **Criar banco de dados**, escolha **Criação padrão**.

1. Em **Opções de mecanismo**, escolha **PostgreSQL**.  
![\[Selecionar tipo de mecanismo\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/tutorial-create-postgres.png)

1. Em **Modelos**, escolha **Nível gratuito** ou **Sandbox**. **Nível gratuito** aparece para contas do plano gratuito. **Sandbox** aparece para contas do plano pago.  
![\[Selecionar modelo\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/tutorial-create-template.png)

1. Na seção **Availability and durability** (Disponibilidade e durabilidade), mantenha as opções padrão.

1. Na seção **Settings (Configurações)**, defina estes valores:
   + **DB instance identifier** (Identificador da instância de banco de dados): digite **tutorial-db-instance**.
   + **Master username** (Nome de usuário principal): digite **tutorial\$1user**.
   + **Auto generate a password** (Gerar uma senha automaticamente): desabilite a opção.
   + **Master password** (Senha principal): digite uma senha.
   + **Confirm password (Confirmar senha)** – digite novamente a senha.  
![\[Seções de configurações\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Settings.png)

1. Na seção **Instance configuration** (Configuração da instância), defina estes valores:
   + **Classes com capacidade de intermitência (inclui classes t)**
   + **db.t3.micro**  
![\[Seção Instance configuration (Configuração da instância)\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_DB_instance_micro.png)

1. Na seção **Storage** (Armazenamento), mantenha os padrões.

1. Na seção **Connectivity** (Conectividade), defina esses valores e mantenha os outros valores como padrão:
   + Em **Compute resource** (Recurso de computação), escolha **Connect to an EC2 compute resource** (Conectar-se a um recurso de computação do EC2).
   + Em **EC2 instance** (Instância do EC2), escolha a instância do EC2 criada anteriormente, como **tutorial-ec2-instance-web-server**.  
![\[Seção de conectividade\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Connectivity.png)

1. Na seção **Autenticação de banco de dados**, verifique se **a autenticação de senha** está selecionada.

1. Abra a seção **Additional configuration (Configuração adicional)** e insira **sample** em **Initial database name (Nome do banco de dados inicial)**. Mantenha as configurações padrão para as outras opções.

1. Para criar uma instância de banco de dados do PostgreSQL, escolha **Criar banco de dados**.

   Sua nova instância de banco de dados é exibida na lista **Databases (Bancos de dados)** com o status **Creating (Criando)**.

1. Aguarde o **Status** de sua nova instância de banco de dados ser mostrado como **Available (Disponível)**. Escolha o nome da instância de banco de dados para mostrar os detalhes.

1. Na seção **Connectivity & security (Conectividade e segurança)**, visualize o **Endpoint** e a **Port (Porta)** da instância de banco de dados.  
![\[Detalhes da instância de banco de dados\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Endpoint_Port_postgres.png)

   Anote o endpoint e a porta de sua instância de banco de dados. Use essas informações para conectar o servidor Web à instância de banco de dados.

1. Completa [Instalar um servidor Web na instância do EC2](CHAP_Tutorials.WebServerDB.CreateWebServer.md).

------

# Instalar um servidor Web na instância do EC2
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer"></a>

Instale um servidor Web na instância do EC2 criada em [Iniciar uma instância do EC2 para se conectar à instância de banco de dados](CHAP_Tutorials.WebServerDB.LaunchEC2.md). O servidor Web se conecta à instância de banco de dados do Amazon RDS criada em [Criar uma instância de banco de dados do Amazon RDS](CHAP_Tutorials.WebServerDB.CreateDBInstance.md). 

## Instale um servidor Web do Apache com PHP e MariaDB
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer.Apache"></a>

Conecte-se à sua instância do EC2 e instale o servidor Web.

**Para conectar-se à sua instância do EC2 e instalar o servidor na web com PHP**

1. Conecte-se à instância do EC2 que você criou anteriormente, seguindo as etapas em [Conecte-se à sua instância do Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) no *Guia do usuário do Amazon EC2*.

   Recomendamos que você se conecte à sua instância do EC2 utilizando SSH. Se o utilitário cliente SSH estiver instalado no Windows, Linux ou Mac, você poderá se conectar à instância utilizando o seguinte formato de comando:

   ```
   ssh -i location_of_pem_file ec2-user@ec2-instance-public-dns-name
   ```

   Por exemplo, suponha que `ec2-database-connect-key-pair.pem` esteja armazenado em `/dir1` no Linux e que o DNS IPv4 público para sua instância do EC2 seja `ec2-12-345-678-90.compute-1.amazonaws.com`. Seu comando SSH teria a seguinte aparência:

   ```
   ssh -i /dir1/ec2-database-connect-key-pair.pem ec2-user@ec2-12-345-678-90.compute-1.amazonaws.com
   ```

1. Obtenha as últimas correções de bugs e atualizações de segurança atualizando o software na instância do EC2. Para fazer isso, execute o seguinte comando.
**nota**  
A opção `-y` instala as atualizações sem solicitar confirmação. Para examinar atualizações antes da instalação, omita essa opção.

   ```
   sudo dnf update -y
   ```

1. Após a conclusão das atualizações, instale o servidor web Apache, o PHP e o software MariaDB ou PostgreSQL utilizando os comandos a seguir. Este comando instala vários pacotes de software e dependências relacionadas ao mesmo tempo.

------
#### [ MariaDB & MySQL ]

   ```
   sudo dnf install -y httpd php php-mysqli mariadb105
   ```

------
#### [ PostgreSQL ]

   ```
   sudo dnf install -y httpd php php-pgsql postgresql15
   ```

------

   Se você receber um erro, isso significa que sua instância provavelmente não foi iniciada com uma AMI do Amazon Linux 2023. Em vez disso é, possível utilizar a AMI do Amazon Linux 2. Você pode visualizar sua versão do Amazon Linux usando o comando a seguir.

   ```
   cat /etc/system-release
   ```

   Para ter mais informações, consulte [Atualização de software da instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-updates.html).

1. Inicie o servidor Web com o comando mostrado a seguir.

   ```
   sudo systemctl start httpd
   ```

   É possível testar se o servidor Web está instalado e se foi iniciado corretamente. Para fazer isso, insira o nome de Domain Name System (DNS) público da instância do EC2 na barra de endereços de um navegador da web, por exemplo: `http://ec2-42-8-168-21.us-west-1.compute.amazonaws.com`. Se o seu servidor na web estiver em execução, você verá a página de teste do Apache. 

   Se você não vir a página de teste do Apache, verifique as regras de entrada para o grupo de segurança da VPC criado no [Tutorial: Criar uma VPC para usar com uma instância de banco de dados (somente IPv4)](CHAP_Tutorials.WebServerDB.CreateVPC.md). Verifique se as regras de entrada incluem uma regra que permita o acesso HTTP (porta 80) ao endereço IP para se conectar ao servidor da Web.
**nota**  
A página de teste do Apache aparece apenas quando não há conteúdo no diretório raiz do documento, `/var/www/html`. Depois de adicionar o conteúdo ao diretório raiz de documentos, o conteúdo aparecerá no endereço DNS público da instância do EC2. Antes desse ponto, ele aparece na página de teste do Apache.

1. Configure o servidor Web para começar com cada inicialização do sistema usando o comando `systemctl`.

   ```
   sudo systemctl enable httpd
   ```

Para permitir que `ec2-user` gerencie arquivos no diretório raiz padrão de servidor Web do Apache, modifique a propriedade e as permissões do diretório `/var/www`. Existem diversas maneiras de realizar essa tarefa. Neste tutorial, você adiciona o usuário `ec2-user` ao grupo `apache` para dar ao grupo `apache` a propriedade do diretório `/var/www` e atribuir permissões de gravação ao grupo.

**Para definir as permissões de arquivos para o servidor na web Apache**

1. Adicione o usuário `ec2-user` ao grupo `apache`.

   ```
   sudo usermod -a -G apache ec2-user
   ```

1. Faça logout para atualizar as permissões e incluir o novo grupo `apache`.

   ```
   exit
   ```

1. Faça login novamente e verifique se o grupo `apache` existe com o comando `groups`.

   ```
   groups
   ```

   A saída será semelhante à seguinte:

   ```
   ec2-user adm wheel apache systemd-journal
   ```

1. Altere a propriedade do grupo do diretório `/var/www` e o seu conteúdo para o grupo `apache`.

   ```
   sudo chown -R ec2-user:apache /var/www
   ```

1. Altere as permissões do diretório do `/var/www` e dos subdiretórios para adicionar permissões de gravação do grupo e definir o ID do grupo em subdiretórios criados futuramente.

   ```
   sudo chmod 2775 /var/www
   find /var/www -type d -exec sudo chmod 2775 {} \;
   ```

1. Altere recursivamente as permissões de arquivos do diretório `/var/www` e os subdiretórios para adicionar permissões de gravação.

   ```
   find /var/www -type f -exec sudo chmod 0664 {} \;
   ```

Agora, `ec2-user` (e todos os outros membros do grupo `apache`) pode adicionar, excluir e editar arquivos na raiz do documento Apache. Isso possibilita que você adicione conteúdo, como um site estático ou uma aplicação PHP. 

**nota**  
Um servidor web que executa o protocolo HTTP não fornece nenhuma segurança de transporte para os dados que envia ou recebe. Quando você se conecta a um servidor HTTP usando um navegador da Web, muitas informações ficam visíveis para os espiões em qualquer ponto da rede. Essas informações incluem os URLs que você acessa, o conteúdo de páginas da web recebido e o conteúdo (inclusive senhas) de todos os formulários HTML.   
A prática recomendada para proteger o servidor da Web é instalar suporte para HTTPS (HTTP seguro). Esse protocolo protege seus dados com criptografia SSL/TLS. Para ter mais informações, consulte [Tutorial: Configurar o SSL/TLS com a AMI do Amazon Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/SSL-on-amazon-linux-ami.html) no *Guia do Usuário do Amazon EC2*.

## Conectar o servidor Web Apache à instância de banco de dados
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer.PHPContent"></a>

Depois, adicione o conteúdo ao servidor Web Apache que se conecta à instância de banco de dados do Amazon RDS.

**Como adicionar o conteúdo ao servidor Web Apache que se conecta à instância de banco de dados**

1. Enquanto estiver conectado à instância do EC2, altere o diretório para `/var/www` e crie um novo subdiretório chamado `inc`.

   ```
   cd /var/www
   mkdir inc
   cd inc
   ```

1. Crie um novo arquivo no diretório `inc` chamado `dbinfo.inc` e edite o arquivo chamando nano (ou o editor de sua escolha).

   ```
   >dbinfo.inc
   nano dbinfo.inc
   ```

1. Adicione o conteúdo a seguir ao arquivo `dbinfo.inc`. Aqui, *db\$1instance\$1endpoint* é o endpoint de instância de banco de dados, sem a porta, para sua instância de banco de dados.
**nota**  
Recomendamos colocar as informações de nome de usuário e senha em uma pasta que não faça parte da raiz do documento do servidor Web. Isso reduz a possibilidade de suas informações de segurança serem expostas.  
Altere `master password` para uma senha adequada em sua aplicação.

   ```
   <?php
   
   define('DB_SERVER', 'db_instance_endpoint');
   define('DB_USERNAME', 'tutorial_user');
   define('DB_PASSWORD', 'master password');
   define('DB_DATABASE', 'sample');
   ?>
   ```

1. Salve e feche o arquivo `dbinfo.inc`. Se você estiver usando nano, salve e feche o arquivo usando Ctrl\$1S e Ctrl\$1X.

1. Altere o diretório para `/var/www/html`.

   ```
   cd /var/www/html
   ```

1. Crie um novo arquivo no diretório `html` chamado `SamplePage.php` e edite o arquivo chamando nano (ou o editor de sua escolha).

   ```
   >SamplePage.php
   nano SamplePage.php
   ```

1. Adicione o conteúdo a seguir ao arquivo `SamplePage.php`:

------
#### [ MariaDB & MySQL ]

   ```
   <?php include "../inc/dbinfo.inc"; ?>
   <html>
   <body>
   <h1>Sample page</h1>
   <?php
   
     /* Connect to MySQL and select the database. */
     $connection = mysqli_connect(DB_SERVER, DB_USERNAME, DB_PASSWORD);
   
     if (mysqli_connect_errno()) echo "Failed to connect to MySQL: " . mysqli_connect_error();
   
     $database = mysqli_select_db($connection, DB_DATABASE);
   
     /* Ensure that the EMPLOYEES table exists. */
     VerifyEmployeesTable($connection, DB_DATABASE);
   
     /* If input fields are populated, add a row to the EMPLOYEES table. */
     $employee_name = htmlentities($_POST['NAME']);
     $employee_address = htmlentities($_POST['ADDRESS']);
   
     if (strlen($employee_name) || strlen($employee_address)) {
       AddEmployee($connection, $employee_name, $employee_address);
     }
   ?>
   
   <!-- Input form -->
   <form action="<?PHP echo $_SERVER['SCRIPT_NAME'] ?>" method="POST">
     <table border="0">
       <tr>
         <td>NAME</td>
         <td>ADDRESS</td>
       </tr>
       <tr>
         <td>
           <input type="text" name="NAME" maxlength="45" size="30" />
         </td>
         <td>
           <input type="text" name="ADDRESS" maxlength="90" size="60" />
         </td>
         <td>
           <input type="submit" value="Add Data" />
         </td>
       </tr>
     </table>
   </form>
   
   <!-- Display table data. -->
   <table border="1" cellpadding="2" cellspacing="2">
     <tr>
       <td>ID</td>
       <td>NAME</td>
       <td>ADDRESS</td>
     </tr>
   
   <?php
   
   $result = mysqli_query($connection, "SELECT * FROM EMPLOYEES");
   
   while($query_data = mysqli_fetch_row($result)) {
     echo "<tr>";
     echo "<td>",$query_data[0], "</td>",
          "<td>",$query_data[1], "</td>",
          "<td>",$query_data[2], "</td>";
     echo "</tr>";
   }
   ?>
   
   </table>
   
   <!-- Clean up. -->
   <?php
   
     mysqli_free_result($result);
     mysqli_close($connection);
   
   ?>
   
   </body>
   </html>
   
   
   <?php
   
   /* Add an employee to the table. */
   function AddEmployee($connection, $name, $address) {
      $n = mysqli_real_escape_string($connection, $name);
      $a = mysqli_real_escape_string($connection, $address);
   
      $query = "INSERT INTO EMPLOYEES (NAME, ADDRESS) VALUES ('$n', '$a');";
   
      if(!mysqli_query($connection, $query)) echo("<p>Error adding employee data.</p>");
   }
   
   /* Check whether the table exists and, if not, create it. */
   function VerifyEmployeesTable($connection, $dbName) {
     if(!TableExists("EMPLOYEES", $connection, $dbName))
     {
        $query = "CREATE TABLE EMPLOYEES (
            ID int(11) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
            NAME VARCHAR(45),
            ADDRESS VARCHAR(90)
          )";
   
        if(!mysqli_query($connection, $query)) echo("<p>Error creating table.</p>");
     }
   }
   
   /* Check for the existence of a table. */
   function TableExists($tableName, $connection, $dbName) {
     $t = mysqli_real_escape_string($connection, $tableName);
     $d = mysqli_real_escape_string($connection, $dbName);
   
     $checktable = mysqli_query($connection,
         "SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_NAME = '$t' AND TABLE_SCHEMA = '$d'");
   
     if(mysqli_num_rows($checktable) > 0) return true;
   
     return false;
   }
   ?>
   ```

------
#### [ PostgreSQL ]

   ```
   <?php include "../inc/dbinfo.inc"; ?>
   
   <html>
   <body>
   <h1>Sample page</h1>
   <?php
   
   /* Connect to PostgreSQL and select the database. */
   $constring = "host=" . DB_SERVER . " dbname=" . DB_DATABASE . " user=" . DB_USERNAME . " password=" . DB_PASSWORD ;
   $connection = pg_connect($constring);
   
   if (!$connection){
    echo "Failed to connect to PostgreSQL";
    exit;
   }
   
   /* Ensure that the EMPLOYEES table exists. */
   VerifyEmployeesTable($connection, DB_DATABASE);
   
   /* If input fields are populated, add a row to the EMPLOYEES table. */
   $employee_name = htmlentities($_POST['NAME']);
   $employee_address = htmlentities($_POST['ADDRESS']);
   
   if (strlen($employee_name) || strlen($employee_address)) {
     AddEmployee($connection, $employee_name, $employee_address);
   }
   
   ?>
   
   <!-- Input form -->
   <form action="<?PHP echo $_SERVER['SCRIPT_NAME'] ?>" method="POST">
     <table border="0">
       <tr>
         <td>NAME</td>
         <td>ADDRESS</td>
       </tr>
       <tr>
         <td>
       <input type="text" name="NAME" maxlength="45" size="30" />
         </td>
         <td>
       <input type="text" name="ADDRESS" maxlength="90" size="60" />
         </td>
         <td>
       <input type="submit" value="Add Data" />
         </td>
       </tr>
     </table>
   </form>
   <!-- Display table data. -->
   <table border="1" cellpadding="2" cellspacing="2">
     <tr>
       <td>ID</td>
       <td>NAME</td>
       <td>ADDRESS</td>
     </tr>
   
   <?php
   
   $result = pg_query($connection, "SELECT * FROM EMPLOYEES");
   
   while($query_data = pg_fetch_row($result)) {
     echo "<tr>";
     echo "<td>",$query_data[0], "</td>",
          "<td>",$query_data[1], "</td>",
          "<td>",$query_data[2], "</td>";
     echo "</tr>";
   }
   ?>
   </table>
   
   <!-- Clean up. -->
   <?php
   
     pg_free_result($result);
     pg_close($connection);
   ?>
   </body>
   </html>
   
   
   <?php
   
   /* Add an employee to the table. */
   function AddEmployee($connection, $name, $address) {
      $n = pg_escape_string($name);
      $a = pg_escape_string($address);
      echo "Forming Query";
      $query = "INSERT INTO EMPLOYEES (NAME, ADDRESS) VALUES ('$n', '$a');";
   
      if(!pg_query($connection, $query)) echo("<p>Error adding employee data.</p>"); 
   }
   
   /* Check whether the table exists and, if not, create it. */
   function VerifyEmployeesTable($connection, $dbName) {
     if(!TableExists("EMPLOYEES", $connection, $dbName))
     {
        $query = "CREATE TABLE EMPLOYEES (
            ID serial PRIMARY KEY,
            NAME VARCHAR(45),
            ADDRESS VARCHAR(90)
          )";
   
        if(!pg_query($connection, $query)) echo("<p>Error creating table.</p>"); 
     }
   }
   /* Check for the existence of a table. */
   function TableExists($tableName, $connection, $dbName) {
     $t = strtolower(pg_escape_string($tableName)); //table name is case sensitive
     $d = pg_escape_string($dbName); //schema is 'public' instead of 'sample' db name so not using that
   
     $query = "SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_NAME = '$t';";
     $checktable = pg_query($connection, $query);
   
     if (pg_num_rows($checktable) >0) return true;
     return false;
   
   }
   ?>
   ```

------

1. Salve e feche o arquivo `SamplePage.php`.

1. Verifique se o servidor Web se conecta com êxito à instância de banco de dados, abrindo um navegador da Web e navegando até `http://EC2 instance endpoint/SamplePage.php`, por exemplo: `http://ec2-12-345-67-890.us-west-2.compute.amazonaws.com/SamplePage.php`.

É possível usar `SamplePage.php` para adicionar dados à instância de banco de dados. Os dados que você adicionar serão exibidos na página. Para verificar se os dados foram inseridos na tabela, instale o cliente MySQL na instância do Amazon EC2. Depois, conecte-se à instância de banco de dados e consulte a tabela. 

Para obter informações sobre como instalar o cliente MySQL e conectar-se a uma instância de banco de dados, consulte [Conectar-se à instância de banco de dados do MySQL](USER_ConnectToInstance.md).

Para garantir que a instância de banco de dados seja o mais seguro possível, verifique se as fontes fora da VPC não podem se conectar à instância de banco de dados. 

Depois de terminar de testar o servidor web e o banco de dados, é necessário excluir a instância de banco de dados e a instância do Amazon EC2.
+ Para excluir uma instância de banco de dados, siga as instruções em [Excluir uma instância de banco de dados](USER_DeleteInstance.md). Não é necessário criar um snapshot final.
+ Para encerrar uma instância do Amazon EC2, siga as instruções em [Encerrar a instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) no *Guia do usuário do Amazon EC2*.