Abschnitt 16 · Lektion 5
Konfiguration
Zieht eine Anwendung vom eigenen Rechner auf einen Server um, muss man eine Handvoll Werte ändern. Wo die Datenbank liegt, wie die Seite heißt, ob Fehler auf der Seite stehen dürfen und unter welcher Adresse sie zu finden ist. Stehen diese Werte verstreut im Code, fängt mit jedem Umzug eine Suche an. Und dann gibt es noch Zugangsdaten, die gar nicht im Code stehen sollten.
Vier Werte in drei Dateien
<?php
declare(strict_types=1);
// Hier steht der Name des Ladens. Zweimal, weil er in den Titel
// und in die Ueberschrift gehoert.
function kopf(): string
{
return '<!doctype html>
<html lang="de">
<head><meta charset="utf-8"><title>Hofladen Musterdorf</title>
<style>body{font-family:system-ui,sans-serif;max-width:34rem;margin:2rem auto}</style></head>
<body>
<h1>Hofladen Musterdorf</h1>';
} <?php
declare(strict_types=1);
// Und hier steht, wo die Datenbank liegt, neben src/ und damit
// ausserhalb des oeffentlichen Ordners.
function datenbank(): PDO
{
$db = new PDO("sqlite:" . __DIR__ . "/../laden.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("CREATE TABLE IF NOT EXISTS waren (id INTEGER PRIMARY KEY, name TEXT NOT NULL, preis INTEGER NOT NULL)");
$db->exec("INSERT OR IGNORE INTO waren (id, name, preis) VALUES (1, 'Kaffee', 850), (2, 'Brot', 320)");
return $db;
} <?php
declare(strict_types=1);
// Und hier stehen die Adresse der Seite und die Betriebsart. Vier
// Werte, drei Dateien, und keine Datei weiss von den anderen. Wer die
// Anwendung auf einen Server bringt, aendert sie an fuenf Stellen,
// und keine Datei sagt ihm, wo die anderen stehen.
if ("entwicklung" === "entwicklung") {
ini_set("display_errors", "1");
error_reporting(E_ALL);
}
require __DIR__ . "/../src/kopf.php";
require __DIR__ . "/../src/datenbank.php";
$db = datenbank();
$anzahl = (int) $db->query("SELECT count(*) FROM waren")->fetchColumn();
echo kopf();
echo "\n <p>Waren im Laden: " . $anzahl . "</p>";
echo "\n <p>Bestellen unter http://localhost:3000/bestellen</p>";
echo "\n</body>\n</html>\n"; Im ersten Beispiel steht der Name des Ladens in src/kopf.php, und zwar zweimal. Der Pfad zur
Datenbank steht in src/datenbank.php, die Adresse der Seite und die Betriebsart stehen in
oeffentlich/index.php. Ziehst du die Anwendung um, änderst du also fünf Stellen in drei Dateien.
Der Schlüssel für einen Zahlungsdienst kommt gleich noch dazu.
Laufen tut die Anwendung. Nur bleibt bei so einer Suche gern etwas liegen. Du findest vier von fünf Stellen, und die Seite läuft trotzdem. Die fünfte fällt erst auf, wenn ein Besucher eine Fehlermeldung mit deinem Dateipfad sieht.
Alles an eine Stelle
<?php
declare(strict_types=1);
// Alles, was sich zwischen deinem Rechner und dem Server
// unterscheidet, an einer Stelle. Ein gewoehnliches Array, das die
// Datei zurueckgibt.
return [
"laden" => "Hofladen Musterdorf",
"adresse" => "http://localhost:3000",
"datenbank" => __DIR__ . "/laden.db",
"modus" => "entwicklung",
"zahlung_schluessel" => getenv("ZAHLUNG_SCHLUESSEL") ?: "",
]; <?php
declare(strict_types=1);
// Der Kopf weiss nicht mehr, wie der Laden heisst. Er bekommt es
// gesagt.
function kopf(array $konfig): string
{
$laden = htmlspecialchars($konfig["laden"], ENT_QUOTES, "UTF-8");
return '<!doctype html>
<html lang="de">
<head><meta charset="utf-8"><title>' . $laden . '</title>
<style>body{font-family:system-ui,sans-serif;max-width:34rem;margin:2rem auto}</style></head>
<body>
<h1>' . $laden . '</h1>';
} <?php
declare(strict_types=1);
// Und die Datenbankdatei weiss nicht mehr, wo sie liegt.
function datenbank(array $konfig): PDO
{
$db = new PDO("sqlite:" . $konfig["datenbank"], null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("CREATE TABLE IF NOT EXISTS waren (id INTEGER PRIMARY KEY, name TEXT NOT NULL, preis INTEGER NOT NULL)");
$db->exec("INSERT OR IGNORE INTO waren (id, name, preis) VALUES (1, 'Kaffee', 850), (2, 'Brot', 320)");
return $db;
} <?php
declare(strict_types=1);
// Dieselbe Anwendung, dieselbe Ausgabe. Nur steht jetzt oben eine
// Zeile, die alles holt, und darunter kein einziger fester Wert mehr.
$konfig = require __DIR__ . "/../konfiguration.php";
if ($konfig["modus"] === "entwicklung") {
ini_set("display_errors", "1");
error_reporting(E_ALL);
}
require __DIR__ . "/../src/kopf.php";
require __DIR__ . "/../src/datenbank.php";
$db = datenbank($konfig);
$anzahl = (int) $db->query("SELECT count(*) FROM waren")->fetchColumn();
$adresse = htmlspecialchars($konfig["adresse"], ENT_QUOTES, "UTF-8");
echo kopf($konfig);
echo "\n <p>Waren im Laden: " . $anzahl . "</p>";
echo "\n <p>Bestellen unter " . $adresse . "/bestellen</p>";
echo "\n</body>\n</html>\n"; Im zweiten Beispiel kommt Zeichen für Zeichen dieselbe Seite heraus. Dafür gibt es eine Datei mehr,
und in den anderen dreien steht kein einziger fester Wert mehr. konfiguration.php gibt ein Array
zurück, und wo etwas davon gebraucht wird, kommt es als Argument an.
Konstanten mit define wären bequemer, weil sie überall gelten. Sie gelten aber auch dort, wo
niemand sie erwartet. Weiterreichen kannst du sie nicht, überschreiben auch nicht. In einem Test
lassen sie sich deshalb nicht durch etwas anderes ersetzen, denn ein zweites define ändert nichts.
Das war schon in Lektion 2.6 so. Ein Array ist dagegen ein ganz gewöhnlicher Wert. Du kannst es
weiterreichen, und zwei davon können nebeneinander liegen. Nimmt eine Funktion es als Parameter,
steht schon in ihrer Signatur, dass sie Konfiguration braucht.
Die Konfiguration ist außerdem PHP und kein JSON. Sie darf also rechnen, __DIR__ einsetzen, eine
Umgebungsvariable lesen und einen Standardwert angeben. In einer JSON-Datei stünde der Pfad absolut,
und beim nächsten Umzug stimmte er nicht mehr.
Zwischen Entwicklung und Betrieb
<?php
declare(strict_types=1);
// Derselbe Fehler, zweimal ausgeloest, einmal je Betriebsart. Auf der
// Seite steht er nur einmal, im Protokoll des Servers zweimal. Das
// Protokoll liegt in /tmp/lern-web.log, und grep Warning holt die
// beiden Zeilen heraus.
$daten = ["titel" => "Notizbuch"];
echo "<!doctype html>\n<html lang=\"de\"><head><meta charset=\"utf-8\">";
echo "<title>Zwei Betriebsarten</title></head><body>\n";
foreach (["entwicklung", "betrieb"] as $modus) {
if ($modus === "entwicklung") {
ini_set("display_errors", "1");
error_reporting(E_ALL);
} else {
ini_set("display_errors", "0");
ini_set("log_errors", "1");
}
echo "<h2>Betriebsart " . $modus . "</h2>\n<p>Wert: ";
echo $daten["fehlt"];
echo "</p>\n";
}
echo "</body>\n</html>\n"; Der wichtigste Eintrag ist modus, denn an ihm hängt, was ein Besucher sieht, wenn etwas
schiefgeht. In den Abschnitten über Fehler und Sicherheit ging es darum, dass auf einem öffentlichen
Server display_errors aus und log_errors an gehört. Beim Entwickeln will man die Meldungen
dagegen direkt auf der Seite sehen.
Im dritten Beispiel passiert derselbe Fehler zweimal, einmal je Betriebsart. Im ersten Block steht
die Warnung mitten auf der Seite, im zweiten ist die Zeile leer. Im Protokoll des Servers,
/tmp/lern-web.log, stehen trotzdem beide Warnungen, und grep Warning /tmp/lern-web.log holt sie
ins Terminal. display_errors entscheidet also nur, ob die Meldung zusätzlich in der Ausgabe
landet. Ob sie protokolliert wird, regelt log_errors, und zwar ganz unabhängig davon.
Was nicht in die Konfiguration gehört
In die Konfiguration gehört, was die Anwendung beschreibt. Was sie geheim halten muss, gehört nicht
hinein. Also kein Datenbankpasswort, kein API-Schlüssel und auch nicht das Geheimnis, mit dem
Cookies signiert werden. Dass die Datei konfiguration.php heißt, ändert daran nichts. Der
Quelltext liegt in der Versionsverwaltung, wird kopiert, geteilt und in ein Backup gelegt, und
irgendwann liest ihn jemand, an den beim Schreiben keiner gedacht hat. Steht ein Passwort einmal in
der Versionsgeschichte, bekommst du es da auch nicht wieder heraus.
Für solche Werte nimmt man üblicherweise eine Umgebungsvariable (englisch environment variable).
Der Server setzt sie, PHP liest sie mit getenv("ZAHLUNG_SCHLUESSEL"), und in der Konfiguration
steht nur diese Zeile statt des Werts. Auf dem eigenen Rechner stehen die Werte oft in einer Datei
namens .env. Von selbst liest PHP sie nicht, dafür braucht es ein Paket oder eine Einstellung des
Servers. Aus der Versionsverwaltung nimmt man die Datei ausdrücklich heraus, bei Git über eine Datei
namens .gitignore, und zwar bevor zum ersten Mal ein echter Wert darin steht.
getenv gibt false zurück, wenn es die Variable nicht gibt. Geht dieser Wert an eine Funktion,
die einen Text erwartet, wird daraus ohne strict_types still ein leerer Text. Mit strict_types
bricht derselbe Aufruf mit einem TypeError ab. In der Konfiguration steht deshalb
getenv("ZAHLUNG_SCHLUESSEL") ?: "", und ?: aus Lektion 4.1 macht aus dem false an Ort und
Stelle einen leeren Text.
In der Aufgabe machst du aus fünf Konstanten der Notizanwendung ein Array. In einer davon steht ein Passwort.
Zum Mitnehmen
Was sich zwischen Rechner und Server unterscheidet, steht in einer Datei, die ein Array zurückgibt. Statt Konstanten, die überall gelten, reicht man dieses Array weiter. Die Betriebsart schaltet display_errors, und Zugangsdaten kommen aus einer Umgebungsvariable statt aus dem Quelltext.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, auf dem Server geprüft
Öffnet sich mit dem Basis Konto.