Instale um servidor Web do Apache com PHP e MariaDB Conectar o servidor Web Apache ao cluster de banco de dados

Instalar um servidor Web na instância do EC2

Instale um servidor Web na instância do EC2 criada em Executar uma instância do EC2. O servidor Web se conecta ao cluster de banco de dados do Amazon Aurora criada em Criar um cluster de banco de dados do Amazon Aurora.

Instale um servidor Web do Apache com PHP e MariaDB

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

Conecte-se à instância do EC2 que você criou anteriormente, seguindo as etapas em Conecte-se à instância do Linux.
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 yum update -y
```
Após a conclusão das atualizações, instale o software PHP usando o comando amazon-linux-extras install. Este comando instala vários pacotes de software e dependências relacionadas ao mesmo tempo.
```
sudo amazon-linux-extras install php8.0 mariadb10.5
```
Se receber um erro relatando sudo: amazon-linux-extras: command not found, isso significa que sua instância não foi iniciada com uma AMI do Amazon Linux 2. Em vez disso é, possível usar a AMI do Amazon Linux. Você pode visualizar sua versão do Amazon Linux usando o comando a seguir.
```
cat /etc/system-release
```
Para obter mais informações, consulte Atualização de software da instância.
Instale o servidor Web Apache.
```
sudo yum install -y httpd
```
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 um cluster de banco de dados (somente IPv4). 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.
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

Adicione o usuário ec2-user ao grupo apache.
```
sudo usermod -a -G apache ec2-user
```
Faça logout para atualizar as permissões e incluir o novo grupo apache.
```
exit
```
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
```
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
```
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 {} \;
```
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 obter mais informações, consulte Tutorial: Configurar o SSL/TLS com a AMI do Amazon Linux no Guia do Usuário do Amazon EC2.

Conectar o servidor Web Apache ao cluster de banco de dados

Depois, adicione o conteúdo ao servidor Web Apache que se conecta ao cluster de banco de dados do Amazon Aurora.

Como adicionar o conteúdo ao servidor Web Apache que se conecta ao cluster de banco de dados

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
```
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
```
Adicione o conteúdo a seguir ao arquivo dbinfo.inc. Aqui, db_instance_endpoint é o endpoint do gravador de cluster de banco de dados, sem a porta, e a senha mestre é a senha mestre do cluster 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.
```
<?php

define('DB_SERVER', 'db_cluster_writer_endpoint');
define('DB_USERNAME', 'tutorial_user');
define('DB_PASSWORD', 'master password');
define('DB_DATABASE', 'sample');

?>
                
```
Salve e feche o arquivo dbinfo.inc.
Altere o diretório para /var/www/html.
```
cd /var/www/html
```
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
                
```

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



<?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;
}
?>

Salve e feche o arquivo SamplePage.php.
Verifique se o servidor Web se conecta com êxito ao cluster de banco de dados, abrindo um navegador da Web e navegando até http://EC2 instance endpoint/SamplePage.php, por exemplo: http://ec2-55-122-41-31.us-west-2.compute.amazonaws.com/SamplePage.php.

É possível usar SamplePage.php para adicionar dados ao cluster 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 ao cluster de banco de dados e consulte a tabela.

Para informações sobre como se conectar a um cluster de banco de dados, consulte Como conectar-se a um cluster de bancos de dados Amazon Aurora.

Para garantir que o cluster de banco de dados seja o mais seguro possível, verifique se as fontes fora da VPC não podem se conectar ao cluster de banco de dados.

Depois de terminar de testar o servidor web e o banco de dados, é necessário excluir o cluster de banco de dados e a instância do Amazon EC2.

Para criar um cluster de banco de dados, siga as instruções em Excluir clusters de banco de dados e instâncias de banco de dados do Aurora. 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 no Guia do usuário do Amazon EC2.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Criar um cluster de banco de dados

Tutoriais e código de exemplo