# 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*.