Hinweis: PHP 5 hat am 30. Januar 2024 das Ende des Supports erreicht. Ihre vorhandenen PHP 5-Anwendungen werden weiterhin ausgeführt und erhalten Traffic. App Engine kann die erneute Bereitstellung von Anwendungen, die Laufzeiten verwenden, jedoch nach dem Enddatum des Supports blockieren. Wir empfehlen die Migration zur neuesten unterstützten Version von PHP.

Diese Seite wurde von der Cloud Translation API übersetzt.

PHP 5-Laufzeitumgebung

Mit App Engine können Sie Webanwendungen mithilfe der Programmiersprache PHP erstellen. Ihre PHP-Anwendung wird in der skalierbaren Google-Infrastruktur ausgeführt und nutzt umfangreiche nichtflüchtige Speicher und Dienste.

PHP-Laufzeit auswählen

App Engine führt PHP-Webanwendungen mit einem PHP-Interpreter der Version 5.5.34 aus. Hinweis: Unter Linux müssen Sie PHP auch lokal installieren, um Ihre PHP-Anwendungen ausführen zu können.

Fügen Sie der Datei app.yaml Folgendes hinzu, um Ihre Anwendung so einzurichten, dass sie die PHP-Laufzeitumgebung verwendet:

runtime: php55
api_version: 1
...

Das erste Element (runtime) wählt die PHP-Laufzeitumgebung aus.

Das zweite Element (api_version) wählt aus, welche Version der PHP-Laufzeitumgebung verwendet werden soll. Derzeit ist für App Engine nur eine Version der PHP-Umgebung (1) vorhanden. Wenn durch künftige Änderungen die Version nicht mehr abwärtskompatibel ist, wird das App Engine-Team eine neue Versionskennung festlegen. Ihre Anwendung verwendet dann weiterhin die ausgewählte Version, bis Sie die api_version-Einstellung ändern und Ihre Anwendung noch einmal hochladen.

Weitere Informationen zur Datei app.yaml und zum Bereitstellen Ihrer Anwendung in App Engine finden Sie in der Referenz zu app.yaml und unter PHP-Anwendung bereitstellen.

Sandbox

Damit App Engine Anfragen für Anwendungen auf mehrere Webserver verteilen und verhindern kann, dass sich Anwendungen gegenseitig stören, wird die Anwendung in einer isolierten "Sandbox"-Umgebung ausgeführt. In dieser Umgebung kann die Anwendung Programmcode ausführen, die Mail-, URL-Abruf- und Nutzerdienste von App Engine verwenden sowie die Webanfrage des Nutzers prüfen und die Antwort vorbereiten.

Folgendes ist mit einer App Engine-Anwendung nicht möglich:

In das Dateisystem schreiben. PHP-Anwendungen können mit Google Cloud Storage nichtflüchtige Dateien speichern. Das Lesen des Dateisystems ist zulässig. Dabei sind alle Anwendungsdateien verfügbar, die mit der Anwendung hochgeladen wurden.
Langsame Antworten. Eine an eine Anwendung gerichtete Webanfrage muss innerhalb weniger Sekunden verarbeitet werden. Prozesse mit langen Antwortzeiten werden beendet, damit der Webserver nicht überlastet wird.
Andere Arten von Systemaufrufen durchführen.

Automatisches Laden von Klassen

Sowohl Klassen der PHP-Standardbibliothek (Standard PHP Library, SPL) als auch alle Klassen, die Teil des SDK für App Engine sind, werden bei Bedarf automatisch geladen. Das bedeutet, dass Sie keine include- oder require-Anweisungen ganz oben in Ihren PHP-Skripts verwenden müssen.

Standardmäßig werden Klassen nur dann automatisch geladen, wenn sie in Dateien definiert sind, die sich im Stammverzeichnis des SDK für App Engine und in Ihrer lokalen PHP-Installation befinden, sofern dies über --php_executable_path festgelegt wurde.

Mit set_include_path können Sie Ihrem PHP-Skript weitere Pfade zum automatischen Laden von Klassen hinzufügen:

set_include_path('my_additional_path' . PATH_SEPARATOR . get_include_path());

Aktivierte Erweiterungen

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

apc
bcmath
Kalender
Core
ctype
Datum
dom
ereg
exif
Filter
ftp
gd
Hash
iconv
json
libxml
mailparse
mbstring
mcrypt
memcache
memcached
mysql
mysqli
mysqlnd
OAuth
openssl
pcre
PDO
pdo_mysql
Reflexion
Sitzung
shmop
SimpleXML
soap
sockets (für Anwendungen mit aktivierter Abrechnung)
SPL
Standard
tokenizer
xml
xmlreader
xmlwriter
xsl
ZIP
zlib

Dynamisch ladbare Erweiterungen

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

cURL: Diese Erweiterung verwendet den Socket-Dienst für Anfragen. Dabei gelten die Kontingente und Einschränkungen dieses Dienstes. Weitere Informationen finden Sie unter Ausgehende Anfragen.
MongoDB (nur auf Englisch verfügbar): Mit dieser Erweiterung kann ein Entwickler eine Verbindung zu einer vorhandenen MongoDB-Instanz herstellen. Sie verwendet für Anfragen den Socket-Dienst. Dabei gelten die Kontingente und Einschränkungen dieses Dienstes.
ImageMagick
intl
fileinfo

Zur Aktivierung dieser Erweiterungen fügen Sie Ihrer Datei php.ini unter extension Anweisungen hinzu, wie im Folgenden dargestellt:

extension = "curl.so"
extension = "mongo.so"
extension = "imagick.so"
extension = "intl.so"
extension = "fileinfo.so"

Sitzungen

Die meisten Webanwendungen benötigen eine Möglichkeit, Informationen zum Nutzerstatus zwischen Anfragen zu speichern. PHP bietet dazu eine zweckmäßige Ebene zur Sitzungsverwaltung. Sitzungen in App Engine laufen weitgehend wie Sitzungen in anderen PHP-Anwendungen ab.

So legen Sie eine Variable in einer Nutzersitzung fest:

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

Und so legen Sie eine Variable für eine nachfolgende Anfrage desselben Nutzers fest:

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

Standardmäßig verwendet die App Engine-Laufzeit Memcache zum Speichern von Sitzungsinformationen mithilfe der Klasse MemcacheSessionHandler. Sie können dieses Verhalten ändern. Geben Sie dazu Ihren eigenen Sitzungs-Handler mit der PHP-Methode session_set_save_handler() an. Memcache ermöglicht das schnelle Speichern und Abrufen von Sitzungsdaten und minimiert so den Aufwand für Ihre Anfrage. Allerdings werden Daten in App Engine-Memcache möglicherweise regelmäßig gelöscht, sodass alle Sitzungsinformationen verloren gehen können. Bei längeren Sitzungen ist deshalb die Verwendung eines alternativen Speicherdienstes, wie z. B. Cloud SQL, möglicherweise von Vorteil.

Spezielle $_SERVER-Schlüssel

PHP stellt das spezielle Array $_SERVER[] im Anfragebereich zur Verfügung. Zusätzlich zu den Standard-CGI-Parametern fügt App Engine einige weitere hilfreiche Schlüssel hinzu.

APPLICATION_ID: Die ID der Anwendung, die beim Erstellen der Anwendung festgelegt wurde, z. B. "mein-wordpress".
AUTH_DOMAIN: Domain, die für die Authentifizierung der Nutzer mit der Users API verwendet wird. Auf appspot.com gehostete Anwendungen haben eine AUTH_DOMAIN von gmail.com und akzeptieren jedes Google-Konto. Die AUTH_DOMAIN von Anwendungen, die mit Google Arbeitsbereich auf einer benutzerdefinierten Domain gehostet werden, entspricht derjenigen der benutzerdefinierten Domain.
CURRENT_VERSION_ID: Die Haupt- und Nebenversion der aktuell ausgeführten Anwendung im Format "X.Y". Die Hauptversionsnummer ("X") ist in der Datei app.yaml der Anwendung angegeben. Die Nebenversionsnummer ("Y") wird beim Hochladen der einzelnen Versionen der Anwendung in App Engine automatisch festgelegt. Auf dem Entwicklungs-Webserver ist die Nebenversion immer "1".
DEFAULT_VERSION_HOSTNAME: Der Hostname der Standardversion dieser Anwendung, z. B. "my-php-app.uc.r.appspot.com".
HTTP_X_APPENGINE_CITY: Name der Stadt, aus der die Anfrage stammt So kann z. B. eine Anfrage aus der Stadt Mountain View den Headerwert "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_REGION: Der 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".
USER_EMAIL: Gibt die E-Mail-Adresse des Nutzers zurück, wenn er mit der Users API authentifiziert wurde. Für Anwendungen sollte zur Namensanzeige der Alias verwendet werden.
USER_ID: Wenn die E-Mail-Adresse mit einem Google-Konto verknüpft ist, gibt "user_id" die eindeutige permanente ID des Nutzers als String zurück. Diese ID ist für den Nutzer immer gleich, unabhängig davon, ob der Nutzer seine E-Mail-Adresse ändert.
USER_IS_ADMIN: Ist 1, wenn der angemeldete Nutzer auch ein Administrator der Anwendung ist und wenn er mit der Users API authentifiziert wurde, sonst 0.
USER_NICKNAME: Für Nutzer von Google-Konten ist der Nickname entweder der Namensteil der E-Mail-Adresse des Nutzers, wenn sich die Adresse in derselben Domain wie die Anwendung befindet, oder andernfalls die vollständige E-Mail-Adresse des Nutzers.
USER_ORGANIZATION: Eine Anwendung mit der Einstellung für Google-Konten kann ermitteln, ob der aktuell angemeldete Nutzer ein persönliches Google-Konto oder ein Konto verwendet, das von einer Google Workspace-Domain verwaltet wird.

Geändertes Verhalten von `PHP_SELF` und `SCRIPT_NAME` in 1.9.0

Die Implementierung von $_SERVER['SCRIPT_NAME'] und $_SERVER['PHP_SELF'] vor der Version 1.9.0 unterscheidet sich erheblich von der Implementierung in den Versionen 1.9.0 und höher. Die Änderungen wurden im Einklang mit der Apache-Implementierung vorgenommen, die für PHP-Anwendungen allgemein Voraussetzung ist.

Die im Folgenden aufgeführten Beispiele zeigen den Unterschied.

Vor 1.9.0	Nach 1.9.0
app.yaml: - url: /.* script: index.php
REQUEST_URI: / SCRIPT_FILENAME: /path/to/index.php SCRIPT_NAME: / PHP_SELF: /	REQUEST_URI: / SCRIPT_FILENAME: /path/to/index.php SCRIPT_NAME: /index.php PHP_SELF: /index.php
REQUEST_URI: /bar SCRIPT_FILENAME: /path/to/index.php SCRIPT_NAME: /bar PHP_SELF: /bar	REQUEST_URI: /bar SCRIPT_FILENAME: /path/to/index.php SCRIPT_NAME: /index.php PHP_SELF: /index.php
REQUEST_URI: /index.php/foo/bar SCRIPT_FILENAME: /path/to/index.php SCRIPT_NAME: /index.php/foo/bar PHP_SELF: /index.php/foo/bar	REQUEST_URI: /index.php/foo/bar SCRIPT_FILENAME: /path/to/index.php SCRIPT_NAME: /index.php PHP_SELF: /index.php/foo/bar
REQUEST_URI: /test.php/foo/bar SCRIPT_FILENAME: /path/to/index.php SCRIPT_NAME: /test.php/foo/bar PHP_SELF: /test.php/foo/bar	REQUEST_URI: /test.php/foo/bar SCRIPT_FILENAME: /path/to/index.php SCRIPT_NAME: /index.php PHP_SELF: /index.php
app.yaml: - url: /.* script: foo/index.php
REQUEST_URI: /bar SCRIPT_FILENAME: /path/to/foo/index.php SCRIPT_NAME: /bar PHP_SELF: /bar	REQUEST_URI: /bar SCRIPT_FILENAME: /path/to/foo/index.php SCRIPT_NAME: /foo/index.php PHP_SELF: /foo/index.php

Anweisungen mit neuen Initialisierungsstandards

Die folgende Tabelle enthält die Anweisungen, deren standardmäßige Initialisierungswerte von den Standardwerten des PHP-Standardinterpreters von php.net abweichen. Sie können diese Standardanweisungen durch Einbinden in eine Datei php.ini überschreiben.

Anweisung	Standardwert in App Engine
`detect_unicode`	`false`
`session.gc_maxlifetime`	`600`
`session.cookie_secure`	`600`
`session.cookie_httponly`	`1`
`session.use_only_cookies`	`1`
`display_errors`	`0`
`display_startup_errors`	`0`
`html_errors`	`0`
`log_errors`	`1`
`file_uploads`	`0`
`upload_max_filesize`	`262144`
`max_file_uploads`	`0`
`date.timezone`	`UTC`
`sendmail_path`	`null`
`allow_url_fopen`	`1`
`allow_url_include`	`0`
`enable_dl`	`0`
`expose_php`	`Off`
`register_globals`	`Off`
`magic_quotes_gpc`	`0`
`mysqlnd.collect_statistics`	`0`
`mysql.allow_local_infile`	`0`
`mysqli.allow_local_infile`	`0`

Deaktivierte Funktionen

Aus Sicherheitsgründen bzw. aus Gründen der Kompatibilität mit der Ausführungsumgebung von App Engine wurden einige PHP-Funktionen deaktiviert. Ein Teil dieser Funktionen kann in der Datei php.ini Ihrer Anwendung explizit wieder aktiviert werden.

Dauerhaft deaktivierte Funktionen

Die folgenden Funktionen wurden in App Engine dauerhaft deaktiviert:

disk_free_space()
disk_total_space()
diskfreespace()
escapeshellarg() and escapeshellcmd()
exec()
highlight_file()
lchgrp(), lchown(), link(), and symlink()
passthru()
pclose() and popen()
proc_close(), prog_get_status(), proc_nice(), proc_open(), and proc_terminate()
set_time_limit()
shell_exec()
show_source()
system()

App Engine enthält keine pcntl-Erweiterung. Dadurch stehen die von pcntl bereitgestellten Funktionen nicht für PHP-Anwendungen zur Verfügung, die in App Engine ausgeführt werden.

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

App Engine-Anwendungen werden in einer Sicherheits-Sandbox ausgeführt, die das Schreiben in das lokale Dateisystem verhindert. Die App Engine-Version von tempnam() gibt deshalb eine speicherinterne temporäre Datei zurück, die in eine permanente Speicherlösung wie Google 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

Teilweise eingeschränkte Funktionen

Die Laufzeit von App Engine für PHP unterstützt nicht den Mustermodifikator /e der Funktionen preg_replace() und mb_ereg_replace(). In der Dokumentation zu PREG_REPLACE_EVAL finden Sie den Hinweis zu veralteten Versionen und ein Beispiel dafür, wie Sie Ihren Code zur Verwendung von preg_replace_callback() aktualisieren.

Manuell aktivierbare Funktionen

Die folgende Liste enthält die PHP-Funktionen, die manuell aktiviert werden müssen. Dazu verwenden Sie die Anweisung google_app_engine.enable_functions in der php.ini Ihrer Anwendung:

gc_collect_cycles(), gc_enable(), gc_disable() und gc_enabled()
getmypid()
getmyuid() und getmygid()
getrusage()
getmyinode()
get_current_user()
libxml_disable_entity_loader()*
parse_str()
phpinfo()
phpversion()
php_uname()
php_sapi_name()

Die Funktionen lassen sich auch manuell deaktivieren. Dafür verwenden Sie die Anweisung disable_functions in der php.ini Ihrer Anwendung.

Funktionen, bei denen die Abrechnung aktiviert sein muss

Die folgenden Funktionen verwenden Sockets und sind daher nur für Anwendungen verfügbar, für die die Abrechnung aktiviert ist.

Alle Netzwerkfunktionen außer gethostname()
Alle Socket-Funktionen
Alle FTP-Funktionen
cURL (außer cURL Lite)
MongoDB
TCP/IP-Verbindungen zu MySQL-Servern (Cloud SQL kann nur mit einem UNIX-Socket verwendet werden)

Streamunterstützung

Unterstützte PHP-E/A-Stream-Wrapper

Die folgenden PHP-E/A-Stream-Wrapper werden unterstützt:

php://input
php://output
php://memory
php://temp

Stream-Wrapper

Viele Funktionen in PHP wie etwa fopen() oder file_get_contents() nutzen die Streamingschnittstelle von PHP zur Unterstützung unterschiedlicher Protokolle.

Die folgende Liste führt die integrierten Stream-Wrapper auf, die automatisch in der App Engine-Laufzeit registriert werden und dort verfügbar sind.

file://
glob://
http:// (verhält sich wie der integrierte HTTP-Stream-Handler von PHP, verwendet aber den URL-Abrufdienst von App Engine)
https:// (verwendet den URL-Abrufdienst von App Engine)
ftp://
gs:// (Stream-Handler für Google Cloud Storage)
zlib://

Im Folgenden finden Sie eine Liste integrierter Stream-Handler, die in App Engine nicht unterstützt werden und deren Registrierung aufgehoben wurde.

data://
expect://
ogg://
phar://
rar://
ssh2://

Deaktivierte Stream-Transporte

Die im Folgenden aufgeführten Stream-Transporte wurden deaktiviert.

ssl
sslv2
sslv3
tcp
tls
udg
udp
unix

Reines PHP

Der gesamte Code für die PHP-Laufzeitumgebung muss komplett in PHP geschrieben sein. Mit App Engine können Sie keine eigenen C-Erweiterungen hochladen.

Die Umgebung enthält die PHP-Standardbibliothek. Manche Erweiterungen wurden deaktiviert, da ihre Kernfunktionen nicht von App Engine unterstützt werden. Hierzu zählen die Netzwerkfunktionen sowie das Schreiben in das Dateisystem.

Sie können auch andere reine PHP-Bibliotheken in Ihre Anwendung aufnehmen. Dazu platzieren Sie den Code im Verzeichnis Ihrer Anwendung, in dem sich auch die Datei app.yaml befindet.

Beispielsweise können Sie im Anwendungsverzeichnis einen symbolischen Link erstellen, der auf das Verzeichnis einer Bibliothek verweist. Diesem Link wird dann gefolgt und die Bibliothek in Ihre Anwendung aufgenommen, wenn Sie sie in App Engine bereitstellen.

Sie können PHP-Bibliotheken auch mithilfe von php.ini- und PHP-include-Anweisungen in Ihren Code aufnehmen. Wir empfehlen aber die Verwendung eines PHP-Tools zur Abhängigkeitsverwaltung, wie z. B. Composer.

Beispiele:

Wenn Sie das Stammverzeichnis Ihrer Anwendung in die Anweisung include_path Ihrer Datei php.ini aufnehmen:
```
include_path=".:/[ROOT_DIR]/myapp"
```
Sie können dann die Anweisung include oder die Anweisung include_once für die Einbindung von PHP-Dateien relativ zu Ihrem include_path verwenden:
```
include_once 'myfile.php';
```
Bei Verwendung von Composer zur Einbindung der reinen PHP-Bibliotheken fügen Sie einfach eine einzelne Datei hinzu, nachdem Ihre Abhängigkeiten installiert wurden:
```
require_once 'vendor/autoload.php';
```
Wenn Sie die Abhängigkeiten Ihrer Anwendung mit Composer installieren, werden alle Pakete dem Anwendungsverzeichnis unter vendor hinzugefügt. Dort wird auch die Datei autoload.php generiert.

Tools

Das SDK für App Engine umfasst Tools zum Testen der Anwendung und zum Hochladen von Anwendungsdateien.

Während der Testphase führt der Entwicklungsserver Ihre Anwendung auf Ihrem lokalen Computer aus.

Das gcloud-Tool steuert alle Befehlszeileninteraktionen mit Ihrer Anwendung, die in App Engine ausgeführt wird. Mit gcloud app deploy laden Sie z. B. Ihre Anwendung in App Engine hoch oder aktualisieren einzelne Konfigurationsdateien. Sie haben auch die Möglichkeit, die Logdaten Ihrer Anwendung aufzurufen und damit die Leistung Ihrer Anwendung mit Ihren eigenen Tools zu analysieren.

Quellcode des PHP-Interpreters

Sie können den Quellcode für den PHP-Interpreter von App Engine aus dem appengine-php-Repository in GitHub herunterladen.

Gleichzeitigkeit und Latenz

Die Latenz Ihrer Anwendung hat den größten Einfluss auf die Anzahl der Instanzen, die für die Verarbeitung Ihres Traffics erforderlich ist. Wenn Sie Anfragen schnell verarbeiten, kann eine einzelne Instanz viele Anfragen bewältigen.

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_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.

Sie können zusätzliche Umgebungsvariablen in Ihrer app.yaml-Datei definieren. Die oben genannten Werte können jedoch nicht überschrieben werden.