PHP-Laufzeitumgebung

Die PHP-Laufzeit ist das Softwarepaket, das für die Installation des Codes Ihres Webdienstes und der Abhängigkeiten sowie für die Ausführung Ihres Dienstes verantwortlich ist.

Zur Angabe von PHP für die App Engine-Standardumgebung deklarieren Sie die Laufzeit in der Datei app.yaml. Beispiele:

runtime: phpVERSION

Dabei ist VERSION die PHP-Versionsnummern MAJOR und MINOR. Wenn Sie beispielsweise die aktuelle PHP-Version (PHP 8.3) verwenden möchten, geben Sie 83 an.

Informationen zu anderen unterstützten PHP-Versionen und zur entsprechenden Ubuntu-Version für Ihre PHP-Version finden Sie im Zeitplan für den Laufzeitsupport. Beispiel: .

PHP-Version

Die PHP-Laufzeit verwendet den neuesten stabilen Release der Version, die in der Datei app.yaml angegeben ist. App Engine wird automatisch auf neue Patchrelease-Versionen aktualisiert. Die Nebenversion wird jedoch nicht automatisch aktualisiert.

Beispiel: Eine mit PHP 7.3.0 bereitgestellte Anwendung wird später automatisch auf Version 7.3.1 aktualisiert, aber nicht auf PHP 7.4.0.

Appstart

Zur Verarbeitung von sämtlichem Anfragerouting muss ein Front-Controller bereitgestellt werden.

Die folgenden Beispiele zeigen verschiedene Möglichkeiten, wie Sie Ihre Anwendung bereitstellen können:

Wenn Ihre Anwendung eine public/index.php- oder index.php-Datei enthält, verwendet App Engine diese Datei zur Bereitstellung Ihrer Anwendung.

Wir empfehlen einen Framework wie Laravel, Symfony oder Slim zu verwenden, da sie einfache Routings bieten, um PHP-Anwendungen schnell zu schreiben und bereitzustellen. Unter Front-Controller mit Slim finden Sie ein Beispiel.

Wenn Sie jedoch eine Legacy-Anwendung migrieren, sehen Sie sich die folgende Beispieldatei index.php an, um die benötigten PHP-Dateien zu importieren und den Front-Controller manuell zu implementieren:
```
switch (@parse_url($_SERVER['REQUEST_URI'])['path']) {
    case '/':
        require 'homepage.php';
        break;
    case '/contact.php':
        require 'contact.php';
        break;
    default:
        http_response_code(404);
        exit('Not Found');
}
```
Wenn Sie das optionale Feld entrypoint in Ihrer app.yaml-Datei verwenden, verwendet App Engine den Befehl im entrypoint-Element, um Ihre App bereitzustellen, und nicht public/index.php oder index.php:
```
    entrypoint: serve path/to/my/front/controller.php
```
Das Feld entrypoint verwendet den integrierten Befehl serve. Dieser ist ein Programm innerhalb der PHP-Laufzeit, das die php-fpm-Implementierung und einen Webserver im Hintergrund startet. Der Webserver leitet den gesamten Traffic mithilfe des Designmusters des Front-Controllers an die bereitgestellte PHP-Datei weiter.

Der Befehl serveserve hat zwei optionale Flags:
- --workers=N: Gibt die Anzahl N der php-fpm-Worker an. Wenn Sie das Flag --workers nicht festlegen, wird die Anzahl der Worker vom Befehl serve anhand der verfügbaren Speichermenge geschätzt. Die besten Ergebnisse erzielen Sie, wenn Sie für die Werte des Flags --workers im Befehl serve und im Element max_concurrent_requests die gleiche Zahl festlegen.
- --enable-dynamic-workers: Gibt an, dass die php-fpm-Worker nur bei Bedarf erzeugt werden sollen. Standardmäßig wird für die php-fpm-Worker eine statische Richtlinie verwendet. Mit dem Flag --workers=N können Sie die maximale Anzahl von erstellten Workern ändern. Standardmäßig entspricht die maximale Anzahl von erstellten Workern der in der statischen Richtlinie festgelegten Anzahl.
Die optionalen Flags müssen vor dem Pfad des Front-Controllers stehen:
```
    entrypoint: serve --workers=2 --enable-dynamic-workers path/to/index.php
```
Wenn Sie einen lang andauernden Worker-Prozess bereitstellen möchten, geben Sie bei dem Element entrypoint den Dateipfad des Worker-Prozesses an:
```
    entrypoint: php long-running-worker-file.php
```
Verwenden Sie nicht den Befehl serve, wenn von dem Element entrypoint ein Skript mit lang andauerndem Prozess wie ein Pub/Sub-Worker mit abonniertem Thema ausgeführt wird.

Weitere Informationen finden Sie in der app.yaml-Referenz.

Aktivierte Erweiterungen

Die folgenden Erweiterungen wurden in der PHP-Laufzeit für App Engine aktiviert:

BCMath
bz2
Calendar
core
cgi
ctype
cURL
date
dba
dom
enchant
Exif
fcgi
fileinfo
filter
FTP
GD
gettext
GMP
hash
iconv
intl
json
LDAP
libxml
mbstring
MYSQLi
mysqlnd
MySQL (PDO)
OPcache
OpenSSL
PCNTL
pcre
PDO
pgsql
Phar
posix
PostgreSQL (PDO)
Reflection
session
Shmop
SimpleXML
SOAP
Sockets
sodium (PHP 8.x only, not available for PHP 7.x)
SPL
SQLite (PDO)
SQLite3
standard
test
tidy
tokenizer
XML
XMLreader
XMLrpc (PHP 7.x only, not available for PHP 8.x)
XMLwriter
XSL
zend
Zip
Zlib

Dynamisch ladbare Erweiterungen

Die folgenden Erweiterungen können durch entsprechende Konfiguration von php.ini dynamisch geladen werden:

Fügen Sie zum Aktivieren dieser Erweiterungen in der Datei php.ini unter extension Anweisungen hinzu. Zum Beispiel:

extension=memcached.so
extension=grpc.so
extension=protobuf.so
extension=mongodb.so
extension=imagick.so
extension=opencensus.so
extension=redis.so

[opentelemetry]
extension=opentelemetry.so

Umgebungsvariablen

Folgende Umgebungsvariablen werden durch die Laufzeit festgelegt:

Umgebungsvariable	Beschreibung
`GAE_APPLICATION`	ID der App Engine-Anwendung. Diese ID hat das Präfix „`region code`~”, z. B. „e~” für Anwendungen, die in Europa bereitgestellt werden.
`GAE_DEPLOYMENT_ID`	ID der aktuellen Bereitstellung.
`GAE_ENV`	App Engine-Umgebung. Legen Sie `standard` fest.
`GAE_INSTANCE`	ID der Instanz, auf der Ihr Dienst gerade ausgeführt wird.
`GAE_MEMORY_MB`	Größe des für den Anwendungsprozess verfügbaren Speichers in MB
`GAE_RUNTIME`	Laufzeit, die in der Datei `app.yaml` angegeben ist.
`GAE_SERVICE`	Dienstname, der in der Datei `app.yaml` angegeben ist. Wenn kein Dienstname angegeben ist, wird als Wert `default` festgelegt.
`GAE_VERSION`	Aktuelle Versionsbezeichnung Ihres Dienstes.
`GOOGLE_CLOUD_PROJECT`	Google Cloud-Projekt-ID, die der Anwendung zugeordnet ist.
`PORT`	Port, der HTTP-Anfragen empfängt.
`NODE_ENV` (nur in der Node.js-Laufzeit verfügbar)	Erhält den Wert `production`, wenn der Dienst bereitgestellt wird.

Sie können in der Datei app.yaml weitere Umgebungsvariablen definieren. Die oben angegebenen Werte können aber mit Ausnahme von NODE_ENV nicht überschrieben werden.

HTTPS und Weiterleitungsproxys

App Engine terminiert HTTPS-Verbindungen am Load-Balancer und leitet Anfragen an die Anwendung weiter. Einige Anwendungen müssen die ursprüngliche Anfrage-IP-Adresse und das Protokoll bestimmen. Die IP-Adresse des Nutzers ist im Standardheader X-Forwarded-For verfügbar. Bei Anwendungen, die diese Informationen benötigen, sollte das Web-Framework so konfiguriert werden, dass dem Proxy vertraut wird.

Dateisystem

Die Laufzeit enthält das beschreibbare Verzeichnis /tmp. Alle anderen Verzeichnisse sind schreibgeschützt. Beim Schreiben in /tmp wird Systemspeicher belegt. Weitere Informationen finden Sie unter tempnam()- und sys_get_temp_dir()-Support.

Metadatenserver

Jede Instanz einer Anwendung kann mit dem App Engine-Metadatenserver Informationen über die Instanz und das Projekt abfragen.

Sie können auf den Metadatenserver über die folgenden Endpunkte zugreifen:

http://metadata
http://metadata.google.internal

An den Metadatenserver gesendete Anfragen müssen den Anfrageheader Metadata-Flavor: Google enthalten. Dieser Header gibt an, dass die Anfrage zum Abrufen von Metadatenwerten gesendet wurde.

In der folgenden Tabelle sind die Endpunkte aufgeführt, an die Sie HTTP-Anfragen für bestimmte Metadaten senden können:

Metadatenendpunkt	Beschreibung
`/computeMetadata/v1/project/numeric-project-id`	Projektnummer, die Ihrem Projekt zugewiesen ist.
`/computeMetadata/v1/project/project-id`	Projekt-ID, die Ihrem Projekt zugewiesen ist.
`/computeMetadata/v1/instance/region`	Region, in der die Instanz ausgeführt wird.
`/computeMetadata/v1/instance/service-accounts/default/aliases`
`/computeMetadata/v1/instance/service-accounts/default/email`	E-Mail-Adresse des Standarddienstkontos, die Ihrem Projekt zugewiesen ist.
`/computeMetadata/v1/instance/service-accounts/default/`	Listet alle Standarddienstkonten für Ihr Projekt auf.
`/computeMetadata/v1/instance/service-accounts/default/scopes`	Listet alle unterstützten Bereiche für die Standarddienstkonten auf.
`/computeMetadata/v1/instance/service-accounts/default/token`	Gibt das Authentifizierungstoken zurück, mit dem Ihre Anwendung gegenüber anderen Google Cloud APIs authentifiziert werden kann.

Wenn Sie z. B. Ihre Projekt-ID abrufen möchten, senden Sie eine Anfrage an http://metadata.google.internal/computeMetadata/v1/project/project-id.

Nachfolgend ist ein Beispiel für das Aufrufen der Metadatenendpunkte mithilfe von cURL oder der Google Cloud-Clientbibliothek:

/**
 * Requests a key from the Metadata server using the Google Cloud SDK. Install
 * the Google Cloud SDK by running "composer install google/cloud"
 *
 * @param $metadataKey the key for the metadata server
 */
function request_metadata_using_google_cloud($metadataKey)
{
    $metadata = new Google\Cloud\Core\Compute\Metadata();
    $metadataValue = $metadata->get($metadataKey);

    return $metadataValue;
}

/**
 * Requests a key from the Metadata server using cURL.
 *
 * @param $metadataKey the key for the metadata server
 */
function request_metadata_using_curl($metadataKey)
{
    $url = 'http://metadata/computeMetadata/v1/' . $metadataKey;

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_HTTPHEADER, array('Metadata-Flavor: Google'));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
    return curl_exec($ch);
}

Sitzungen

PHP bietet eine Sitzungsverwaltungsebene, mit der Webanwendungen Informationen zum Nutzerstatus zwischen Anfragen speichern können. Sitzungen in App Engine laufen weitgehend wie Sitzungen in anderen PHP-Anwendungen ab.

Mit dem folgenden Code können Sie in der Sitzung eines Nutzers eine Variable festlegen:

session_start();
$_SESSION['Foo'] = 'Bar';

Mit dem folgenden Code wird auf eine weitere Anfrage desselben Nutzers Bar ausgegeben:

session_start();
print $_SESSION['Foo']; // prints Bar

Bei längeren Sitzungen sollten Sie einen alternativen Speicherdienst wie Cloud SQL verwenden.

Spezielle $_SERVER-Schlüssel

Mit PHP wird das spezielle Array $_SERVER[] im Bereich von Anfragen verfügbar. Neben den Standard-CGI-Parametern ergänzt App Engine einige weitere nützliche Schlüssel:

GAE_APPLICATION: Google Cloud-Projekt-ID der aktuellen Anwendung
GAE_DEPLOYMENT_ID: Quellcode-ID
GAE_ENV: App Engine-Standardumgebung oder flexible App Engine-Umgebung, in der die Anwendung ausgeführt wird
GAE_INSTANCE: Name der aktuell ausgeführten Instanz
GAE_MEMORY_MB: Menge des für den Anwendungsprozess verfügbaren Speichers in MB
GAE_RUNTIME: Die in Ihrer app.yaml-Datei angegebene Laufzeit, z. B. php72
GAE_SERVICE: Name des aktuell bereitgestellten Dienstes
GAE_VERSION: Name der aktuell bereitgestellten Version
GOOGLE_CLOUD_PROJECT: Google Cloud-Projekt-ID
HTTP_X_APPENGINE_CITY: Name der Stadt, aus der die Anfrage stammt So kann z. B. eine Anfrage aus der Stadt Mountain View den Header-Wert "mountain view" enthalten.
HTTP_X_APPENGINE_CITYLATLONG: Breiten- und Längengrad der Stadt, von der die Anfrage stammt. Für eine Anfrage aus Mountain View kann dieser String etwa "37.386051,-122.083851" lauten.
HTTP_X_APPENGINE_COUNTRY: Das Land, aus dem die Anfrage stammt, als Ländercode gemäß ISO 3166-1 Alpha-2. App Engine ermittelt diesen Code anhand der IP-Adresse des Clients.
HTTP_X_APPENGINE_HTTPS: Bestätigt die HTTPS-Nutzung
HTTP_X_APPENGINE_REGION: Name der Region, aus der die Anfrage stammt. Die Interpretation dieses Werts hängt von dem unter X-Appengine-Country angegebenen Land ab. Wenn als Land z. B. "US" und als Region "ca" festgelegt ist, steht "ca" für "Kalifornien", nicht für "Kanada".
HTTP_X_APPENGINE_USER_IP: IP-Adresse des Clients Beachten Sie, dass $_SERVER['HTTP_X_APPENGINE_USER_IP'] die einzige Möglichkeit ist, die IP-Adresse des Clients von Ihrer Anwendung abzurufen. Die Variable $_SERVER['REMOTE_ADDR'] ist in App Engine nicht verfügbar.

Anweisungen mit neuen Initialisierungsstandards

In der folgenden Tabelle sind die Anweisungen aufgeführt, deren standardmäßigen Initialisierungswerte von den Anweisungen des PHP-Standardinterpreters abweichen, der über php.net verfügbar ist. Die Standardwerte für Anweisungen, die nicht in der folgenden Tabelle angegeben sind, finden Sie unter php.ini-Anweisungen.

Anweisung	Standardwert in App Engine
`expose_php`	`Off`
`memory_limit`	`-1`
`max_execution_time`	`0`
`error_reporting`	`E_ALL & ~E_DEPRECATED & ~E_STRICT`
`display_errors`	`Off`
`display_startup_errors`	`Off`
`log_errors`	`On`
`log_errors_max_len`	`0`
`ignore_repeated_errors`	`Off`
`ignore_repeated_source`	`Off`
`html_errors`	`Off`
`opcache.enable`	`On`
`opcache.validate_timestamps`	`Off`
`opcache.memory_consumption`	`32`

Sie können diese Standardanweisungen überschreiben, indem Sie diese in eine php.ini-Datei für Ihre Anwendung einschließen.

Unterstützung für `tempnam()` und `sys_get_temp_dir()`

App Engine-Anwendungen werden in einer Sicherheits-Sandbox ausgeführt, in der nur das Verzeichnis /tmp beschreibbar ist und im RAM der Instanz gespeichert wird. Die App Engine-Version von tempnam() gibt daher eine speicherinterne temporäre Datei zurück, die in eine permanente Speicherlösung wie Cloud Storage-Buckets geschrieben werden kann.

Das folgende Beispiel zeigt, wie Sie mithilfe von file_put_contents() und fwrite() in die speicherinterne temporäre Datei schreiben.

<?php
$dir = sys_get_temp_dir();
$tmp = tempnam($dir, "foo");
file_put_contents($tmp, "hello");
$f = fopen($tmp, "a");
fwrite($f, " world");
fclose($f);
echo file_get_contents($tmp);

Die erwartete Ausgabe des Beispiels ist:

hello world

Abhängigkeiten mit Composer verwalten

Weitere Informationen finden Sie auf der Seite Abhängigkeiten angeben.