Nota: PHP 5 ha raggiunto la fine del supporto il 30 gennaio 2024. Le applicazioni PHP 5 esistenti continueranno a essere eseguite e a ricevere traffico. Tuttavia, App Engine potrebbe bloccare il ri deployment di applicazioni che utilizzano runtime dopo la data di fine del supporto. Ti consigliamo di eseguire la migrazione all'ultima versione supportata di PHP.

Ambiente di runtime PHP 5

Con App Engine, puoi creare applicazioni web utilizzando il linguaggio di programmazione PHP. L'applicazione PHP viene eseguita sull'infrastruttura scalabile di Google e utilizza servizi e archiviazione permanenti su larga scala.

Selezione del runtime PHP

App Engine esegue l'applicazione web PHP utilizzando un interprete della versione PHP 5.5.34. Nota: su Linux devi anche installare PHP in locale per poter eseguire le app PHP.

Per impostare l'app per l'utilizzo del runtime PHP, aggiungi quanto segue al file app.yaml:

runtime: php55
api_version: 1
...

Il primo elemento, runtime, seleziona l'ambiente di runtime PHP.

Il secondo elemento, api_version, seleziona la versione dell'ambiente di runtime PHP da utilizzare. Al momento della stesura di questo articolo, App Engine ha una sola versione dell'ambiente PHP, 1. In caso di modifiche future che potrebbero non essere compatibili con le versioni precedenti, il team di App Engine utilizzerà un nuovo identificatore di versione. La tua app continuerà a utilizzare la versione selezionata finché non modificherai l'impostazione api_version e non caricherai l'app.

Per ulteriori informazioni sul file app.yaml e su come eseguire il deployment della tua applicazione in App Engine, consulta gli argomenti Riferimento app.yaml e Deployment di un'app PHP.

La sandbox

Per consentire ad App Engine di distribuire le richieste delle applicazioni su più server web e per impedire a un'applicazione di interferire con un altro, l'applicazione viene eseguita in un ambiente "sandbox" limitato. In questo ambiente, l'applicazione può eseguire codice, utilizzare la posta di App Engine, recuperare URL e utilizzare i servizi, esaminare la richiesta web dell'utente e preparare la risposta.

Un'applicazione App Engine non può:

di scrivere nel file system. Le applicazioni PHP possono utilizzare Google Cloud Storage per l'archiviazione dei file permanenti. La lettura dal file system è consentita e sono disponibili tutti i file dell'applicazione caricati con l'applicazione.
risponde lentamente. Le richieste web inviate a un'applicazione devono essere gestite entro pochi secondi. I processi che richiedono molto tempo per rispondere vengono terminati per evitare di sovraccaricare il server web.
altri tipi di chiamate di sistema.

Caricamento automatico del corso

Sia le classi SPL (Standard PHP Library) sia le classi che fanno parte dell'SDK per App Engine vengono caricate automaticamente quando necessario. Ciò significa che non è necessario utilizzare le istruzioni include o require nella parte superiore degli script PHP.

Per impostazione predefinita, il caricamento automatico delle classi viene eseguito solo per le classi definite nei file che risiedono nella directory radice dell'SDK per la root di App Engine (e, se è stato specificato da --php_executable_path, nell'installazione PHP locale).

Per aggiungere altri percorsi da cercare per il caricamento automatico dei corsi, utilizza set_include_path nello script PHP.

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

Estensioni attivate

Le seguenti estensioni sono state abilitate nel runtime PHP per App Engine:

APC
bcmath
calendario
Core
Tipo C
date
dom
Ereg
EXIF
filtro
ftp
gd
cancelletto
Icona V
json
libxml
analisi postale
mbstring
mcrypt
memcache
memcached
mysql
mysqli
Mysqlnd
OAuth
openssl
PCRE
DOP
pdo_mysql
Riflessione
sessione
shmop
SimpleXML
sapone
socket (per le app abilitate per la fatturazione)
SPL
standard
tokenizzatore
xml
lettore xml
xmlwriter
xsl
zip
zlib

Estensioni caricabili dinamicamente

Le seguenti estensioni possono essere caricate in modo dinamico configurando php.ini.

cURL: questa estensione utilizza il servizio socket per effettuare richieste ed è soggetta alla quota e alle limitazioni di tale servizio. Per ulteriori informazioni, consulta Richieste in uscita.
MongoDB: questa estensione consente a uno sviluppatore di connettersi a un'istanza MongoDB esistente. Utilizza il servizio socket per effettuare richieste ed è soggetto alla quota e alle limitazioni di tale servizio.
ImageMagick
intl
infofile

Per attivare queste estensioni, aggiungi le relative istruzioni nel file php.ini in extension, in questo modo:

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

Sessioni

La maggior parte delle applicazioni web ha bisogno di un modo per conservare le informazioni sullo stato degli utenti tra una richiesta e l'altra. PHP offre un comodo livello di gestione delle sessioni. Le sessioni in App Engine funzionano in modo molto simile alle sessioni in qualsiasi altra applicazione PHP.

Impostazione di una variabile nella sessione di un utente:

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

A una successiva richiesta dello stesso utente:

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

Per impostazione predefinita, il runtime App Engine utilizza memcache per archiviare le informazioni sulle sessioni utilizzando la classe MemcacheSessionHandler. Puoi modificare questo comportamento specificando il tuo gestore di sessioni utilizzando il metodo session_set_save_handler() di PHP. Memcache consente di salvare e recuperare rapidamente i dati delle sessioni, il che significa che l'overhead per la tua richiesta è minimo. Tuttavia, i dati in App Engine Memcache potrebbero essere svuotati periodicamente, il che significa che tutte le informazioni sulla sessione andranno perse. Per le sessioni di maggiore durata, è preferibile utilizzare un servizio di archiviazione alternativo come Cloud SQL.

Chiavi speciali $_SERVER

PHP rende disponibile l'array $_SERVER[] speciale nell'ambito della richiesta. Oltre ai parametri CGI standard, App Engine aggiunge altre chiavi utili.

APPLICATION_ID. L'app_id dell'applicazione impostato al momento della creazione, ad esempio my-wordpress
AUTH_DOMAIN. Il dominio utilizzato per autenticare gli utenti con l'API Users. Le app ospitate su appspot.com hanno AUTH_DOMAIN di gmail.com e accettano qualsiasi account Google. Le app ospitate su un dominio personalizzato che utilizza Google Workspace hanno un dominio AUTH_DOMAIN uguale al dominio personalizzato
CURRENT_VERSION_ID: la versione principale e secondaria dell'applicazione al momento in esecuzione, denominata "X.Y". Il numero di versione principale ("X") è specificato nel file app.yaml dell'app. Il numero di versione secondaria ("Y") viene impostato automaticamente quando ogni versione dell'app viene caricata in App Engine. Sul server web di sviluppo, la versione secondaria è sempre "1".
DEFAULT_VERSION_HOSTNAME: il nome host della versione predefinita di questa applicazione, ad esempio my-php-app.uc.r.appspot.com.
HTTP_X_APPENGINE_CITY: nome della città da cui ha avuto origine la richiesta. Ad esempio, una richiesta proveniente dalla città di Mountain View potrebbe avere come intestazione il valore mountain view.
HTTP_X_APPENGINE_CITYLATLONG: latitudine e longitudine della città da cui ha avuto origine la richiesta. La stringa potrebbe essere simile a "37.386051,-122.083851" per una richiesta proveniente da Mountain View.
HTTP_X_APPENGINE_COUNTRY: il paese da cui ha avuto origine la richiesta, indicato come codice paese ISO 3166-1 alpha-2. App Engine determina questo codice dall'indirizzo IP del client.
HTTP_X_APPENGINE_REGION: nome della regione da cui ha avuto origine la richiesta. Questo valore ha senso solo nel contesto del paese in X-Appengine-Country. Ad esempio, se il paese è "US" e la regione è "ca", "ca" significa "California", non Canada.
USER_EMAIL: restituisce l'indirizzo email dell'utente, se è stato autenticato utilizzando l'API Users. Le applicazioni devono utilizzare un nickname per i nomi visualizzabili.
USER_ID. Se l'indirizzo email è associato a un Account Google, user_id restituisce l'ID univoco permanente dell'utente, una str. Se sono stati autenticati mediante l'API Users. Questo ID è sempre lo stesso per l'utente, indipendentemente dal fatto che quest'ultimo modifichi il proprio indirizzo email.
USER_IS_ADMIN: 1 se l'utente che ha eseguito l'accesso è anche un amministratore dell'applicazione, se è stato autenticato utilizzando l'API Users. 0 in caso contrario.
USER_NICKNAME. Per gli utenti di Google Account, il nickname è costituito dalla porzione "nome" dell'indirizzo email dell'utente, se l'indirizzo si trova nello stesso dominio dell'applicazione, oppure dall'indirizzo email completo dell'utente.
USER_ORGANIZATION: un'applicazione che utilizza l'impostazione Account Google può determinare se l'utente che ha eseguito l'accesso utilizza un Account Google personale o un account gestito da un dominio Google Workspace.

Comportamento di `PHP_SELF` e `SCRIPT_NAME` aggiornato nella versione 1.9.0

L'implementazione di $_SERVER['SCRIPT_NAME'] e $_SERVER['PHP_SELF'] prima della versione 1.9.0 differisce in modo significativo dalla versione 1.9.0 e successive. Le modifiche sono state apportate in modo da essere coerenti con l'implementazione Apache generalmente prevista dalle applicazioni PHP.

I seguenti esempi mostrano la differenza.

Prima della versione 1.9.0	Dopo 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

Istruzioni con nuovi valori predefiniti di inizializzazione

In questa tabella sono specificate le istruzioni le cui impostazioni predefinite di inizializzazione sono diverse dai valori predefiniti forniti con l'interprete PHP standard disponibile in php.net. Puoi ignorare queste istruzioni predefinite includendole in un file php.ini per la tua applicazione.

Istruzione	Valore predefinito 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`

Funzioni disattivate

Per motivi di sicurezza o per la compatibilità con l'ambiente di esecuzione di App Engine, alcune funzioni PHP sono state disabilitate. Alcune di queste funzioni possono essere riattivate esplicitamente nel file php.ini per la tua applicazione.

Funzioni disattivate definitivamente

Le seguenti funzioni sono state disabilitate in modo permanente in App Engine:

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 non include l'estensione pcntl, pertanto le funzioni fornite da pcntl non sono disponibili per le app PHP in esecuzione in App Engine.

Assistenza `tempnam()` e `sys_get_temp_dir()`

Le app di App Engine vengono eseguite in una sandbox per la sicurezza che non consente la scrittura nel file system locale. Per questo motivo, la versione di App Engine di tempnam() restituisce un file temporaneo in memoria che può essere scritto in una soluzione di archiviazione permanente, ad esempio i bucket Google Cloud Storage in un secondo momento.

Ecco un esempio di come scrivere nel file temporaneo in memoria utilizzando file_put_contents() e fwrite().

<?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);

L'output previsto dall'esempio sarebbe quindi:

hello world

Funzioni parzialmente limitate

App Engine per il runtime PHP non supporta il modificatore di pattern /e delle funzioni preg_replace() e mb_ereg_replace(). Consulta la documentazione di PREG_REPLACE_EVAL per l'avviso sul ritiro e un esempio di come aggiornare il codice per utilizzare invece preg_replace_callback().

Funzioni che è possibile abilitare manualmente

Questo elenco specifica la funzione PHP che deve essere attivata manualmente utilizzando l'istruzione google_app_engine.enable_functions nel file php.ini della tua applicazione.

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

Puoi anche disabilitare manualmente le funzioni utilizzando l'istruzione disable_functions nel file php.ini della tua applicazione.

Funzioni che richiedono l'abilitazione della fatturazione

Le seguenti funzioni utilizzano i socket e, pertanto, sono disponibili solo per le app abilitate per la fatturazione.

tutte le funzioni di rete eccetto gethostname()
tutte le funzioni socket
Tutte le funzioni FTP
cURL, a meno che non utilizzi cURL Lite
MongoDB
Connessioni TCP/IP ai server MySQL (Cloud SQL può essere utilizzato solo con un socket UNIX)

Supporto dello streaming

Wrapper stream I/O PHP supportati

Sono supportati i seguenti wrapper di flusso I/O PHP:

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

Wrapper dei flussi

Molte funzioni in PHP, come fopen() o file_get_contents(), sfruttano l'interfaccia dei flussi di PHP per supportare protocolli diversi.

Di seguito è riportato un elenco di wrapper dei flussi integrati che vengono registrati automaticamente e sono disponibili nel runtime di App Engine.

file://
glob://
http:// (si comporta come il gestore di stream http integrato di PHP, ma utilizza il servizio URLfetch di App Engine)
https:// (utilizza il servizio URLfetch di App Engine)
ftp://
gs:// (gestore dei flussi per Google Cloud Storage)
zlib://

Di seguito è riportato un elenco di gestori dei flussi integrati che non sono supportati in App Engine e per cui è stata annullata la registrazione.

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

Trasporti dei flussi disattivati

I seguenti trasporti di flussi sono stati disabilitati.

ssl
sslv2
sslv3
tcp
tls
udg
udp
unix

PHP puro

Tutto il codice per l'ambiente di runtime PHP deve essere PHP puro. App Engine non ti consente di caricare le tue estensioni C.

L'ambiente include la libreria standard PHP. Alcune estensioni sono state disabilitate perché le loro funzioni principali non sono supportate da App Engine, ad esempio il networking e la scrittura nel file system.

Puoi includere altre librerie PHP purhe nella tua applicazione inserendo il codice nella directory dell'applicazione, che è la stessa che contiene il file app.yaml.

Ad esempio, puoi creare un link simbolico nella directory dell'applicazione che rimanda alla directory di una libreria. Questo link viene seguito e la libreria viene inclusa nell'applicazione quando esegui il deployment su App Engine.

Puoi anche includere librerie PHP specificando nel codice le istruzioni php.ini e includendo le istruzioni PHP include. Tuttavia, l'alternativa preferita è utilizzare uno strumento di gestione delle dipendenze PHP come Composer.

Esempi:

Se includi la directory root dell'applicazione nell'istruzione include_path del file php.ini:
```
include_path=".:/[ROOT_DIR]/myapp"
```
Puoi quindi utilizzare le istruzioni include o include_once per includere i file PHP relativi a include_path:
```
include_once 'myfile.php';
```
Se scegli di utilizzare Composer per includere le librerie PHP pure, puoi semplicemente includere un singolo file dopo l'installazione delle dipendenze:
```
require_once 'vendor/autoload.php';
```
Quando utilizzi Composer per installare le dipendenze dell'applicazione, tutti i pacchetti vengono aggiunti nella directory dell'applicazione in vendor, dove viene generato anche il file autoload.php.

Strumenti

L'SDK per App Engine include strumenti per testare l'applicazione e caricare i relativi file.

Il server di sviluppo esegue l'applicazione sul computer locale per testare l'applicazione.

Lo strumento gcloud gestisce tutte le interazioni dalla riga di comando con l'applicazione in esecuzione su App Engine. Puoi utilizzare gcloud app deploy per caricare la tua applicazione in App Engine o per aggiornare singoli file di configurazione. Puoi anche visualizzare i dati dei log dell'app per analizzarne le prestazioni utilizzando i tuoi strumenti.

Codice sorgente dell'interprete PHP

Puoi scaricare il codice sorgente per l'interprete PHP di App Engine nel repository appengine-php in GitHub.

Contemporaneità e latenza

La latenza dell'applicazione ha l'impatto maggiore sul numero di istanze necessarie per gestire il traffico. Se elabori le richieste rapidamente, una singola istanza può gestire molte richieste.

Variabili di ambiente

Le seguenti variabili di ambiente sono impostate dal runtime:

Variabile di ambiente	Descrizione
`GAE_APPLICATION`	L'ID della tua applicazione App Engine. Questo ID è preceduto dal prefisso "`region code`~", ad esempio "e~" per le applicazioni distribuite in Europa.
`GAE_DEPLOYMENT_ID`	L'ID del deployment corrente.
`GAE_ENV`	L'ambiente App Engine. Impostato su `standard`.
`GAE_INSTANCE`	L'ID dell'istanza su cui il servizio è attualmente in esecuzione.
`GAE_RUNTIME`	Il runtime specificato nel file `app.yaml`.
`GAE_SERVICE`	Il nome del servizio specificato nel file `app.yaml`. Se non viene specificato alcun nome del servizio, è impostato su `default`.
`GAE_VERSION`	L'etichetta della versione corrente del servizio.
`GOOGLE_CLOUD_PROJECT`	L'ID progetto Google Cloud associato alla tua applicazione.
`PORT`	La porta che riceve le richieste HTTP.

Puoi definire variabili di ambiente aggiuntive nel file app.yaml, ma i valori precedenti non possono essere sostituiti.