Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Installieren eines Webservers auf Ihrer EC2-Instance
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer"></a>

Installieren Sie einen Webserver auf der EC2-Instance, die Sie in [Starten Sie eine EC2-Instance, um eine Verbindung mit Ihrer DB-Instance herzustellen.](CHAP_Tutorials.WebServerDB.LaunchEC2.md) 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](CHAP_Tutorials.WebServerDB.CreateDBInstance.md) erstellt haben. 

## Installieren eines Apache-Webservers mit PHP und MariaDB
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer.Apache"></a>

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

1. Stellen Sie eine Verbindung mit der von Ihnen zuvor erstellten EC2-Instance her, indem Sie die Schritte unter [Herstellen einer Verbindung zur Linux-Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) im *Amazon-EC2-Benutzerhandbuch* 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
   ```

1. Installieren Sie die neuesten Bugfixes 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
   ```

1. 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](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-updates.html).

1. 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: Eine VPC zur Verwendung mit einem  erstellen (IPv4 nur)](CHAP_Tutorials.WebServerDB.CreateVPC.md). 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.

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

1. Fügen Sie den Benutzer `ec2-user` zur Gruppe `apache` hinzu.

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

1. Melden Sie sich ab, um Ihre Berechtigungen zu aktualisieren und die neue Gruppe `apache` einzufügen.

   ```
   exit
   ```

1. 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
   ```

1. Ä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
   ```

1. Ä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 {} \;
   ```

1. Ä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 URLs die von Ihnen besuchten Websites, die Inhalte von Webseiten, die Sie erhalten, und die Inhalte (einschließlich Passwörter) aller HTML-Formulare.   
Die bewährte Methode, Ihren Webserver abzusichern, besteht darin, Unterstützung für HTTPS (HTTP Secure) zu installieren. Dieses Protokoll schützt Ihre Daten durch SSL/TLS Verschlüsselung. Weitere Informationen finden Sie unter [Tutorial: Configure SSL/TLS with the Amazon Linux AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/SSL-on-amazon-linux-ami.html) im *Amazon EC2 EC2-Benutzerhandbuch*.

## Herstellen der Verbindung zwischen Ihrem Apache-Webserver und Ihrer DB-Instance
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer.PHPContent"></a>

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

1. 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
   ```

1. 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
   ```

1. Fügen Sie der Datei `dbinfo.inc` die folgenden Inhalte hinzu. Hier *db\$1instance\$1endpoint* ist Ihr DB-Instance-Endpunkt, der , ohne den Port, für Ihren .
**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');
   ?>
   ```

1. Speichern und schließen Sie die Datei `dbinfo.inc`. Wenn Sie Nano verwenden, speichern und schließen Sie die Datei mit Strg\$1S und Strg\$1X.

1. Ändern Sie das Verzeichnis in `/var/www/html`.

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

1. 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
   ```

1. 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;
   
   }
   ?>
   ```

------

1. Speichern und schließen Sie die Datei `SamplePage.php`.

1. Ü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 [Herstellen einer Verbindung mit Ihrer MySQL-DB-Instance](USER_ConnectToInstance.md).

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](USER_DeleteInstance.md). Sie müssen keinen abschließenden Snapshot erstellen.
+ Um eine Amazon EC2-Instance zu beenden, folgen Sie den Anweisungen in [Beenden Ihrer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) im *Amazon EC2-Benutzerhandbuch*.