Persistentieren von Daten in einer PosgreSQL-Datenbank mit PHP

PHP ist eine weit verbreitete Server-Skriptsprache. Seine umfangreichen Fähigkeiten und sein geringes Gewicht machen es ideal für die Entwicklung von Web-Frontends, und obwohl es möglich ist, fortgeschrittene Strukturen darin zu erstellen, ist die grundlegende Verwendung auch leicht zu erlernen, was es auch für Anfänger zu einem guten Ausgangspunkt macht. Die Daten, die von der von uns erstellten Anwendung aufgezeichnet, verarbeitet, gesendet oder angezeigt werden, müssen jedoch irgendwo gespeichert werden. Ohne diese Daten ist unsere Webseite zustandslos. Wir können unsere Daten auf viele Arten speichern oder sogar nach Gebrauch verwerfen, aber die gängigste Methode besteht darin, sie in einer Datenbank zu speichern, die ausschließlich zu dem Zweck entwickelt wurde, Daten zuverlässig zu speichern und sie bei Bedarf so schnell wie möglich bereitzustellen.

In diesem Tutorial erstellen wir eine einfache Webseite zum Aufzeichnen und Anzeigen von Benutzerdaten. Wir werden ein PostgreSQL RDBMS als Backend verwenden und unsere Anwendung in PHP entwickeln, die auf einem Apache Webserver läuft. Auf diese Weise können wir von jedem gängigen Browser aus auf unsere Webanwendung zugreifen, um sie anzuzeigen oder zu unserer Benutzerdatenbank hinzuzufügen. Es liegt in der Natur der Webanwendung, dass viele Benutzer/Betreiber gleichzeitig damit arbeiten können, alles, was sie benötigen, ist ein Browser und ein Netzwerkzugriff auf unsere Anwendung.

In diesem Tutorial lernen Sie:

So installieren Sie die benötigten Pakete für die PostgreSQL-Verbindung in PHP
Erstellen der Datenbankseite der Anwendung
Codieren der Beispielanwendung
Bedienung und Überprüfung der Beispielanwendung

Aufzeichnen von Daten über den Browser.

Verwendete Softwareanforderungen und Konventionen

Hinweise zu Softwarekomponenten

Wir haben unsere Anwendung auf Ubuntu eingerichtet, aber im Grunde kann dieser Prozess auf jede Distribution portiert werden. Unterschiede gibt es in Paketmanagern und Paketnamen sowie in einigen Verzeichnispfaden. Beachten Sie auch, dass wir zwar die Versionen der oben genannten Softwarekomponenten verwenden, diese Anwendung jedoch mit kleinen Anpassungen auf verschiedenen Versionen der Komponenten aufgebaut werden kann. Einige Beispiele für andere Distributionen werden zum Vergleich beigefügt.

Möglicherweise stellen Sie fest, dass die Anwendung minimalistisch ist: Das ist Absicht. Ziel dieses Leitfadens ist es, die Grundprinzipien der Entwicklung einer Anwendung, die mit einer Datenbank kommunizieren kann, so einfach wie möglich zu veranschaulichen. Minimaler Code, minimale Komponenten. Verwenden Sie diesen Leitfaden nicht zum Erstellen von Produktionsanwendungen, da es an Sicherheitsmessungen, Wiederverwendbarkeit oder Optimierung mangelt.

Installieren der benötigten Pakete

Nach der Installation der PostgreSQL-Datenbank müssen wir nur noch PHP-Unterstützung hinzufügen. Dafür benötigen wir das Paket php-pgsql. Wir werden apt verwenden, um es zu installieren:

apt-get install php-pgsql

Einige Distributionen nennen es php7-pgsql und dergleichen, aber alle Paketmanager bieten eine Suchfunktion, so dass es einfach ist, das zu finden, was wir brauchen. So installieren Sie beispielsweise PostgreSQL auf RHEL8/centOS 8 Linux-Systemen.

Wir müssen auch PHP, einen Webserver und die Unterstützung von PHP auf dem Webserver installieren. Das sind nur noch zwei Pakete entfernt:

apt-get install apache2 libapache2-mod-php

Wir können beide Dienste starten, damit sie in den nächsten Schritten verfügbar sind. Dafür verwenden wir systemd.

systemctl start postgresql
systemclt start apache2

Erstellen der Datenbank und der benötigten Objekte

Die Datenbankseite unserer Anwendung besteht aus einer Datenbank, einer einzelnen Tabelle und einer Sequenz, um die automatische Zuweisung von Primärschlüsseln zu unterstützen.

Wir wechseln zum postgres-Benutzer:
```
su - postgres
```

Melden Sie sich bei der Datenbank an:

psql
psql (10.9 (Ubuntu 10.9-0ubuntu0.18.04.1))
Type "help" for help.

postgres=#

Erstellen Sie einen neuen Benutzer:

postgres=# create role exampleuser with login password 'ExamplePass';

Und eine Datenbank, in der der Besitzer festgelegt ist.

postgres=# create database exampledb owner exampleuser encoding 'UTF-8';

Nach dem Beenden des psql-Tools erstellen wir eine Textdatei namens example_table.sql mit folgendem Inhalt:

create sequence userid_seq start with 0 increment by 1 no maxvalue minvalue 0 cache 1;
alter sequence userid_seq owner to exampleuser;
create table users (
        userid numeric primary key default nextval('userid_seq'::regclass),
        username text not null,
        email text not null,
        registration_date timestamp default now()
);
alter table users owner to exampleuser;

Hier erstellen wir eine Sequenz in Zeile 1, die für jeden Datensatz in der Tabelle einen eindeutigen Primärschlüssel bereitstellt und dann seinen Besitz festlegt. Bei Zeile 3 erstellen wir eine Tabelle, die die Benutzerdaten enthält, die wir aufzeichnen und mit der Anwendung anzeigen werden. Wir legen Standardwerte für die Benutzer-ID und die registration_date fest und überlassen es der Datenbank, diese Felder für uns auszufüllen.

Wir laden die obige SQL-Datei in die neue Datenbank:

psql -d exampledb < example_table.sql 
CREATE SEQUENCE
ALTER SEQUENCE
CREATE TABLE
ALTER TABLE

Damit ist unsere Datenbank eingerichtet und bereit zu liefern. PostgreSQL 10.9 unter Ubuntu akzeptiert standardmäßig passwortgeschützte Anmeldungen auf dem Loopback-Gerät. Wenn Sie andere Versionen verwenden, müssen Sie möglicherweise die Datei pg_hba.conf ändern, um den Zugriff auf die Datenbank zu ermöglichen. In unserer Redmine-Installationsanleitung gibt es ein Beispiel, wie Sie das einrichten können.

Erstellen des Anwendungscodes

Obwohl es sicherlich viele großartige Tools gibt, die bei der Erstellung von funktionierendem Quellcode helfen, werden wir diese hier nicht behandeln, da dies die Komplexität dieses Leitfadens erhöhen würde. Wir erstellen eine Textdatei mit dem Namen recording.php im Standardverzeichnis DOCUMENT_ROOT Ubuntu 18, /var/www/html/. Bei anderen Distributionen könnte dies /srv/www/htdocs/ oder etwas anderes sein. Beziehen Sie sich auf die Konfiguration des Webservers, wenn Sie sich nicht sicher sind.

PHP ist eine Skriptsprache, was bedeutet, dass wir unseren Code nicht kompilieren müssen, sondern ihn einfach dem Webserver präsentieren, der ihn zur Laufzeit interpretiert.

Wir können einen Befehlszeilen-Texteditor wie vi oder nano verwenden, um die erwähnte PHP-Datei mit dem folgenden Quellcode zu füllen:

<!-- section 1 -->
<!DOCTYPE html>
<html>
<head>
<title>User recording page</title>
</head>
<body>
<p>Please fill out the below form and press submit to record the data.</p>
<!-- section 2 -->
<form name="record" action="recording.php" method="post">
<input type="text" name="username"><br>
<input type="text" name="email"><br>
<input type="submit" value="Submit"><br>
</form>
<hr>
<!--section 3 -->
<?php
/* section 4 */
$dbconn = pg_connect("host=127.0.0.1 port=5432 dbname=exampledb user=exampleuser password=ExamplePass");
if(!$dbconn) {
    die('Error connecting to database: ' . pg_last_error());
}
/* section 5 */
if(isset($_REQUEST["username"]) && isset($_REQUEST["email"])) {
    $un = pg_escape_string($_REQUEST["username"]);
    $mail = pg_escape_string($_REQUEST["email"]);
    $insert_res = pg_query("insert into users (userid, username, email, registration_date) values (default,'$un','$mail',default)");
    if(!$insert_res) {
        echo ("Error while inserting data: " . pg_last_error());
    } else {
        echo ("Recoring successful");
    }
}
/* section 6 */
$result = pg_query("SELECT * from users order by registration_date");

echo "<table border='1'>\n<tr><th>#</th><th>Username</th><th>E-mail address</th><th>Registration date</th></tr>\n";

while($row = pg_fetch_row($result)) {
  echo "<tr><td>" . $row[0] . "</td><td>" . $row[1] . "</td><td>" . $row[2] . "</td><td>" . $row[3] . "</td></tr>\n";
}
echo "</table>\n";
/* section 7 */
pg_close($dbconn);
?>
<!-- section 8 -->
</body>
</html>

Wir beginnen unseren Code als einfache statische HTML-Seite in Abschnitt 1. Wir erstellen in Abschnitt 2 ein Formular, das dem Benutzer die Möglichkeit bietet, Daten in der Anwendung aufzuzeichnen. Wir fragen nur nach einem Benutzernamen und einer E-Mail-Adresse. In Abschnitt 3 betten wir PHP-Code in die Seite ein. Abschnitt 4 erstellt die Datenbankverbindung anhand der Verbindungsinformationen, die wir im Datenbankschritt eingerichtet haben. Wenn die Verbindung nicht hergestellt werden kann, wird die Anwendung mit einer Fehlermeldung beendet.

In Abschnitt 5 verarbeiten wir alle Daten, die zur Verarbeitung gesendet werden, mit dem Formular, das wir in Abschnitt 2 erstellt haben. Wenn sowohl "Benutzername" als auch "E-Mail" gepostet werden, prüfen wir, ob sie nicht leer sind, und wenn nicht, fügen wir sie über unsere Datenbankverbindung in die Datenbank ein.

Unabhängig davon, ob wir gepostete Daten erhalten, werden wir in Abschnitt 6 die Datenbanktabelle nach bereits erfassten Benutzerdaten abfragen. Wir generieren den erforderlichen HTML-Code, um eine Tabelle mit den Daten bereitzustellen, die von der Datenbank zurückgegeben werden.

Bei Setion 7 schließen wir unsere Datenbankverbindung (bereinigen immer Objekte, die nicht mehr benötigt werden!), und bei Sektion 8 belassen wir den PHP-Code und beenden unsere Seite mit einfachen HTML-Tags. Und damit ist unsere Anwendung abgeschlossen, wir können sie verwenden.

Verwenden der Anwendung

Wir zeigen mit einem Browser auf http://localhost/recording.php. Die einzige Seite unserer Beispielanwendung wird angezeigt.

Die Tabelle "Benutzer" ist leer.

Wir können die Felder des Formulars mit zufälligen Daten füllen, um die Anwendung zu testen. Wenn Text in beide Felder eingefügt wird, können wir die Daten übermitteln.

Füllen Sie die Formularfelder mit Beispieldaten.

Nach dem Absenden zeigt die Seite das gleiche Formular, in dem wir unseren nächsten Benutzer erfassen können, und auch den bereits erfassten, der nach dem Einfügen aus der Datenbank abgefragt wird. Wir haben unser Ziel einer Anwendung zur Erfassung von Benutzerdaten erreicht.

Anwendung, die bereits erfasste Daten auflistet.

Wir können auch überprüfen, ob die Daten erfolgreich in der Datenbank gespeichert sind, indem wir psql verwenden:

psql -d exampledb
exampledb=# select * from users;
 userid | username |         email          |     registration_date      
--------+----------+------------------------+----------------------------
      0 | foobar   | foo.bar@maildomain.org | 2019-06-25 20:28:18.224375
(1 row)

Abschließende Gedanken

Wir haben eine Beispielanwendung mit Kenntnissen aus verschiedenen Bereichen erstellt, Datenbank, Webserver, das HTTP-Protokoll im Allgemeinen und natürlich die PHP-Entwicklung. Dieser Leitfaden soll zeigen, wie einfach es ist, mit der Vereinigung dieser Felder etwas Nützliches zu schaffen. Meine Hoffnung ist, dass dieser Leitfaden Anfängern helfen kann, einige der Aspekte der Entwicklung zu verstehen, und zeigen kann, dass es sich nicht um Weltraumwissenschaft handelt – wir haben nur hier und da ein paar Zeilen Code hinzugefügt, und das Ganze beginnt zusammenzuarbeiten.

Während diese Beispielanwendung ihren Demonstrationszweck erfüllt, schreien der Code und die gesamte Lösung natürlich nach Verbesserung. Um nur einige zu nennen...

Nichts hindert einen Betreiber daran, den genauen Benutzernamen und/oder die E-Mail-Adresse zweimal zu erfassen. Das würde zu redundanten Datensätzen führen. Dies kann sowohl auf der Datenbankseite (eindeutige Einschränkung) als auch auf der Anwendungsseite (Daten vor dem Einfügen überprüfen) gehandhabt werden.
Woher stammen die aufgezeichneten Daten? Was schützt die Anwendung vor einem böswilligen Akteur? Im Moment genügt nichts, ein einziges Shell-Skript, um es zu überlasten, nur die Standard-Abwehrmechanismen des Webservers sind vorhanden – aber das hindert mich nicht daran, die komplette Herr der Ringe-Trilogie 1000 Mal pro Minute in einem der Felder zu posten (nur Bandbreite). In diesem Zustand der Anwendung ist es einfach, die Festplatten unter der Datenbank mit zufälligen Daten zu füllen – hier kommt wieder die Überprüfung der Benutzereingaben ins Spiel, aber auch die Authentifizierung und Autorisierung.
Das Webdesign fehlt an dieser Stelle perfekt. Etwas CSS, etwas mehr Text, der die Arbeit des Bedieners erleichtert, nützliche Fehlermeldungen... Benutzerfreundlichkeit ist auch ein wichtiger Gesichtspunkt.
Natürlich ist das Aufzeichnen des Benutzernamens und der zugehörigen E-Mail-Adresse nur ein Beispiel, wir könnten den Vor- und Nachnamen aufzeichnen, die Telefonnummer vielleicht, mehr als eine E-Mail pro Benutzer... Alles andere, was nützlich ist, um es zu speichern.

Die Liste ließe sich endlos fortsetzen. Es liegt an Ihnen, dem Leser, Ihre eigene Anwendung zu verbessern. Wenn dieser Leitfaden Ihnen geholfen hat, den Weg der Entwicklung einzuschlagen, entweder als Hobby oder mit dem Ziel, ein Profi zu werden, dann hat er seinen Zweck gut erfüllt.