Installieren eines Apache-Webservers mit PHP und MariaDB Herstellen der Verbindung zwischen Ihrem Apache-Webserver und Ihrer DB-Instance

Installieren eines Webservers auf Ihrer EC2-Instance

Installieren Sie einen Webserver auf der EC2-Instance, die Sie in Starten einer EC2-Instance erstellt haben. Der Webserver stellt eine Verbindung mit der DB-Instance von Amazon RDS her, die Sie in Erstellen einer DB-Instance von Amazon RDS erstellt haben.

Installieren eines Apache-Webservers mit PHP und MariaDB

Stellen Sie eine Verbindung mit Ihrer EC2-Instance her und installieren Sie den Webserver.

So stellen Sie eine Verbindung mit Ihrer EC2-Instance her und installieren den Apache-Webserver mit PHP

Stellen Sie eine Verbindung mit der von Ihnen zuvor erstellten EC2-Instance her, indem Sie die Schritte unter Verbindung zu Ihrer Linux-Instance im Amazon-EC2-User-Benutzerhandbuch für Linux-Instances befolgen.

Wir empfehlen, dass Sie eine Verbindung mit Ihrer EC2-Instance mithilfe von SSH herstellen. Wenn das SSH-Client-Dienstprogramm unter Windows, Linux oder Mac installiert ist, können Sie mit dem folgenden Befehlsformat eine Verbindung mit der Instance herstellen:
```
ssh -i location_of_pem_file ec2-user@ec2-instance-public-dns-name
```
Nehmen wir zum Beispiel an, das ec2-database-connect-key-pair.pem in /dir1 unter Linux gespeichert und das öffentliche IPv4-DNS für Ihre EC2-Instance ec2-12-345-678-90.compute-1.amazonaws.com ist. Ihr SSH-Befehl würde wie folgt aussehen:
```
ssh -i /dir1/ec2-database-connect-key-pair.pem ec2-user@ec2-12-345-678-90.compute-1.amazonaws.com
```
Installieren Sie die neuesten Fehlerbehebungen und Sicherheitsupdates, indem Sie die Software auf Ihrer EC2-Instance aktualisieren. Verwenden Sie dazu den folgenden Befehl.

Anmerkung
Mit der Option -y werden die Updates installiert, ohne um Bestätigung zu bitten. Um Updates vor der Installation zu überprüfen, lassen Sie diese Option aus.
```
sudo dnf update -y
```
Nachdem die Aktualisierungen abgeschlossen sind, installieren Sie die Software von Apache-Webserver, PHP und MariaDB mit den folgenden Befehlen. Mit diesem Befehl werden gleichzeitig mehrere Softwarepakete und zugehörige Abhängigkeiten installiert.
MariaDB & MySQL
```
sudo dnf install -y httpd php php-mysqli mariadb105
```
PostgreSQL
```
sudo dnf install -y httpd php php-pgsql postgresql15
```
Wenn Sie eine Fehlermeldung erhalten, wurde Ihre Instance wahrscheinlich nicht mit einem Amazon-Linux-2023-AMI gestartet. Stattdessen verwenden Sie möglicherweise das Amazon-Linux-2-AMI. Sie können Ihre Version von Amazon Linux mit dem folgenden Befehl anzeigen.
```
cat /etc/system-release
```
Weitere Informationen finden Sie unter Aktualisieren der Software einer Instance.
Starten Sie den Webserver mithilfe des folgenden Befehls.
```
sudo systemctl start httpd
```
Sie können testen, ob Ihr Webserver richtig installiert und gestartet ist. Geben Sie dazu den öffentlichen DNS-Namen (Domain Name System) Ihrer EC2-Instance in die Adressleiste eines Webbrowsers ein, zum Beispiel: http://ec2-42-8-168-21.us-west-1.compute.amazonaws.com. Wenn Ihr Webserver ausgeführt wird, wird Ihnen die Apache-Testseite angezeigt.

Wenn Sie die Apache-Testseite nicht sehen, überprüfen Sie die Regeln für eingehenden Datenverkehr für die VPC-Sicherheitsgruppe, die Sie in erstellt habe Tutorial: Erstellen einer VPC zur Verwendung mit einer DB-Instance (nur IPv4). Stellen Sie sicher, dass die Regeln für eingehenden Datenverkehr eine Regel enthalten, die den HTTP-Zugriff (Port 80) für die IP-Adresse ermöglicht, um eine Verbindung mit dem Webserver herzustellen.

Anmerkung
Die Apache-Testseite wird nur angezeigt, wenn im Dokumentstammverzeichnis /var/www/html keine Inhalte vorhanden sind. Wenn Sie dem Dokumentstammverzeichnis Inhalte hinzugefügt haben, werden unter der öffentlichen DNS-Adresse Ihrer EC2-Instance Ihre Inhalte angezeigt. Bis zu diesem Zeitpunkt erscheinen sie auf der Apache-Testseite.
Konfigurieren Sie den Webserver so, dass er mit jedem Systemstart gestartet wird. Verwenden Sie hierzu den Befehl systemctl.
```
sudo systemctl enable httpd
```

Um für ec2-user die Verwaltung von Dateien im Standardstammverzeichnis Ihres Apache-Webservers zuzulassen, ändern Sie die Eigentümerschaft und die Berechtigungen für das Verzeichnis /var/www. Es gibt viele Möglichkeiten, um diese Aufgabe zu erfüllen. In diesem Tutorial fügen Sie ec2-user zur apache-Gruppe hinzu, geben der apache-Gruppe Eigentümerschaft über das Verzeichnis /var/www und weisen der Gruppe Schreibberechtigungen zu.

So legen Sie Dateiberechtigungen für den Apache-Webserver fest

Fügen Sie den Benutzer ec2-user zur Gruppe apache hinzu.
```
sudo usermod -a -G apache ec2-user
```
Melden Sie sich ab, um Ihre Berechtigungen zu aktualisieren und die neue Gruppe apache einzufügen.
```
exit
```
Melden Sie sich wieder an und überprüfen Sie mit dem Befehl apache, ob die Gruppe groups vorhanden ist.
```
groups
```
Die Ausgabe sieht folgendermaßen oder ähnlich aus:
```
ec2-user adm wheel apache systemd-journal
```
Ändern Sie die Besitzergruppe für das Verzeichnis /var/www und dessen Inhalte in die Gruppe apache.
```
sudo chown -R ec2-user:apache /var/www
```
Ändern Sie die Verzeichnisberechtigungen von /var/www und dessen Unterverzeichnissen, indem Sie Schreibberechtigungen für die Gruppe hinzufügen und die Gruppen-ID für zukünftige Unterverzeichnisse einrichten.
```
sudo chmod 2775 /var/www
find /var/www -type d -exec sudo chmod 2775 {} \;
```
Ändern Sie die Dateiberechtigungen für Dateien im Verzeichnis /var/www und dessen Unterverzeichnissen rekursiv, um Schreibberechtigungen für die Gruppe hinzuzufügen.
```
find /var/www -type f -exec sudo chmod 0664 {} \;
```

Jetzt kann ec2-user (und jedes künftige Mitglied der apache-Gruppe) im Dokumentstammverzeichnis von Apache Dateien hinzufügen, löschen und bearbeiten. Damit haben Sie die Möglichkeit, Inhalte hinzuzufügen, z. B. eine statische Website oder eine PHP-Anwendung.

Anmerkung

Ein Webserver, auf dem HTTP ausgeführt wird, bietet keine Transportsicherheit für die gesendeten oder empfangenen Daten. Wenn Sie über einen Webbrowser eine Verbindung mit einem HTTP-Server herstellen, sind viele Informationen überall auf dem Netzwerkpfad für Lauscher zugänglich. Zu diesen Informationen gehören die URLs, die Sie aufrufen, die Inhalte von Webseiten, die Sie empfangen, und die Inhalte (einschließlich Passwörtern) von HTML-Formularen.

Die bewährte Methode, Ihren Webserver abzusichern, besteht darin, Unterstützung für HTTPS (HTTP Secure) zu installieren. Dieses Protokoll schützt Ihre Daten mit SSL-/TLS-Verschlüsselung. Weitere Informationen finden Sie unter Tutorial: SSL/TLS mit dem Amazon Linux AMI konfigurieren im Amazon EC2-Benutzerhandbuch .

Herstellen der Verbindung zwischen Ihrem Apache-Webserver und Ihrer DB-Instance

Als Nächstes fügen Sie Ihrem Apache-Server, der mit Ihrer Amazon RDS-DB-Instance/dem verbunden ist, Inhalte hinzu.

So fügen Sie dem Apache-Server, der mit Ihrer -DB-Instance/dem verbunden ist, Inhalte hinzu

Während die Verbindung mit Ihrer EC2-Instance besteht, ändern Sie das Verzeichnis in /var/www und erstellen Sie ein neues Unterverzeichnis namens inc.
```
cd /var/www
mkdir inc
cd inc
```
Erstellen Sie im Verzeichnis inc eine neue Datei namens dbinfo.inc und bearbeiten Sie anschließend die Datei, indem Sie Nano (oder einen Editor Ihrer Wahl) aufrufen.
```
>dbinfo.inc
nano dbinfo.inc
```
Fügen Sie der Datei dbinfo.inc die folgenden Inhalte hinzu. In diesem Fall ist db_instance_endpoint Ihr DB-Instance-Endpunkt ohne den Port für Ihre DB-Instance.

Anmerkung
Es wird empfohlen, die Informationen zu Benutzername und Passwort in einem Ordner abzulegen, der nicht Teil des Dokumentstammverzeichnisses für Ihren Webserver ist. Auf diese Weise wird die Möglichkeit verringert, dass Ihre Sicherheitsinformationen offengelegt werden.
Stellen Sie sicher, dass Sie master password in Ihrer Anwendung in ein geeignetes Passwort ändern.
```
<?php

define('DB_SERVER', 'db_instance_endpoint');
define('DB_USERNAME', 'tutorial_user');
define('DB_PASSWORD', 'master password');
define('DB_DATABASE', 'sample');
?>
```
Speichern und schließen Sie die Datei dbinfo.inc. Wenn Sie Nano verwenden, speichern und schließen Sie die Datei mit Strg+S und Strg+X.
Ändern Sie das Verzeichnis in /var/www/html.
```
cd /var/www/html
```
Erstellen Sie im Verzeichnis html eine neue Datei namens SamplePage.php und bearbeiten Sie anschließend die Datei, indem Sie Nano (oder einen Editor Ihrer Wahl) aufrufen.
```
>SamplePage.php
nano SamplePage.php
```

Fügen Sie der Datei SamplePage.php die folgenden Inhalte hinzu:

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;

}
?>

Speichern und schließen Sie die Datei SamplePage.php.
Überprüfen Sie, ob Ihr Webserver erfolgreich eine Verbindung mit Ihrer DB-Instance herstellen kann, indem Sie einen Webbrowser öffnen und zu http://EC2 instance endpoint/SamplePage.php navigieren, beispielsweise: http://ec2-12-345-67-890.us-west-2.compute.amazonaws.com/SamplePage.php.

Sie können SamplePage.php verwenden, um Ihrer DB-Instance Daten hinzuzufügen. Die von Ihnen hinzugefügten Daten werden anschließend auf der Seite angezeigt. Wenn Sie überprüfen möchten, ob die Daten in die Tabelle eingefügt wurden, installieren Sie den MySQL-Client auf der Amazon-EC2-Instance. Stellen Sie dann eine Verbindung mit der DB-Instance her und führen Sie eine Abfrage der Tabelle aus.

Informationen zum Installieren des MySQL-Clients und zum Herstellen einer Verbindung mit einer DB-Instance finden Sie unter Verbinden mit einer DB-Instance, auf der die MySQL-Datenbank-Engine ausgeführt wird.

Um sicherzustellen, dass Ihre DB-Instance so sicher wie möglich ist, müssen Sie sich vergewissern, dass Quellen außerhalb der VPC keine Verbindungen mit Ihrer DB-Instance herstellen können.

Nachdem Sie Ihren Webserver und Ihre Datenbank getestet haben, sollten Sie Ihre DB-Instance und Ihre Amazon EC2-Instance löschen.

Um eine DB-Instance zu löschen, folgen Sie den Anweisungen in Löschen einer DB-Instance. Sie müssen keinen abschließenden Snapshot erstellen.
Um eine Amazon EC2-Instance zu beenden, folgen Sie den Anweisungen in Beenden Ihrer Instance im Amazon EC2-Benutzerhandbuch.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Erstellen einer DB-Instance.

Tutorial: Erstellen einer Lambda-Funktion für den Zugriff auf Ihre DB-Instance von Amazon RDS