Instale um servidor Web do Apache com PHP e MariaDB Conectar o servidor Web Apache à instância 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 à instância de banco de dados do Amazon RDS criada em Criar uma instância de banco de dados do Amazon RDS.

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 Conectar-se a uma instância do Linux no Guia do usuário do Amazon EC2 para instâncias do Linux.

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
```
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
```
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.
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). 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 ter 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 à instância de banco de dados

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

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 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');
?>
```
Salve e feche o arquivo dbinfo.inc. Se você estiver usando nano, salve e feche o arquivo usando Ctrl+S e Ctrl+X.
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:

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;

}
?>

Salve e feche o arquivo SamplePage.php.
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 Conexão a uma instância de banco de dados executando o mecanismo de banco de dados do MySQL.

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. 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 uma instância de banco de dados

Tutorial: Criar uma função do Lambda para acessar a instância de banco de dados do Amazon RDS