Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Ambiente di runtime PHP

Il runtime PHP è lo stack software responsabile dell'installazione del codice del servizio web e delle relative dipendenze e dell'esecuzione del servizio.

Per specificare PHP per l'ambiente standard di App Engine, dichiara il runtime nel file app.yaml. Ad esempio:

runtime: phpVERSION

Dove VERSION sono i numeri di versione di PHP MAJOR e MINOR. Ad esempio, per utilizzare l'ultima versione di PHP, PHP 8.5, specifica 85.

Per altre versioni di PHP supportate e la versione di Ubuntu corrispondente alla tua versione di PHP, consulta la pianificazione del supporto di runtime.

Versione PHP

L'ultima versione di PHP supportata è la 8.5. Il runtime PHP utilizza l'ultima release stabile della versione specificata nel file app.yaml. App Engine esegue automaticamente l'aggiornamento alle nuove versioni di rilascio delle patch, ma non aggiorna automaticamente la versione secondaria.

Ad esempio, la tua app potrebbe essere implementata in PHP 7.3.0 e versioni successive e aggiornata automaticamente alla versione 7.3.1, ma non verrà aggiornata automaticamente a PHP 7.4.0.

Avvio dell'app

Devi eseguire il deployment di un front controller per gestire tutto il routing delle richieste.

I seguenti esempi mostrano diversi modi per pubblicare la tua app:

Se la tua app contiene un file public/index.php o index.php, App Engine lo utilizza per pubblicare la tua app.

Ti consigliamo di utilizzare un framework, ad esempio Laravel, Symfony o Slim, perché fornisce un routing leggero per scrivere e implementare rapidamente app PHP. Vedi un esempio di controller frontale Slim.

Tuttavia, se stai eseguendo la migrazione di un'app legacy, consulta il seguente file index.php di esempio per importare i file PHP necessari e implementare manualmente il front controller:
```
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');
}
```
Se specifichi l'elemento facoltativo entrypoint nel file app.yaml, App Engine utilizza il comando nell'elemento entrypoint per pubblicare la tua app anziché utilizzare public/index.php o index.php:
```
    entrypoint: serve path/to/my/front/controller.php
```
Il campo entrypoint utilizza il comando serve integrato, che è un programma all'interno dei runtime PHP che avvia l'implementazione di php-fpm e un web server in background. Questo web server instrada tutto il traffico al file PHP fornito utilizzando il pattern di progettazione del controller frontale.

Il comando serve ha due flag facoltativi:
- --workers=N: specifica il numero N di worker php-fpm. Se non imposti il flag --workers, il comando serve stima il numero di worker in base alla quantità di memoria disponibile. Per ottenere risultati ottimali, imposta i valori del flag --workers nel comando serve e dell'elemento max_concurrent_requests in modo che corrispondano allo stesso numero.
- --enable-dynamic-workers: specifica che vuoi che i worker php-fpm vengano generati solo in base alle necessità. Il comportamento predefinito è utilizzare un criterio statico per i worker php-fpm. Puoi modificare il numero massimo di worker generati utilizzando il flag --workers=N. Per impostazione predefinita, il numero massimo di worker generati corrisponde a quello impostato dal criterio statico.
I flag facoltativi devono precedere il percorso del front controller:
```
    entrypoint: serve --workers=2 --enable-dynamic-workers path/to/index.php
```
Puoi eseguire il deployment di un processo worker a lunga esecuzione impostando l'elemento entrypoint sul percorso del file del processo worker:
```
    entrypoint: php long-running-worker-file.php
```
Se l'elemento entrypoint esegue uno script con un processo a esecuzione prolungata, come un worker Pub/Sub iscritto a un argomento, non utilizzare il comando serve.

Per saperne di più, consulta il riferimento app.yaml .

Estensioni attivate

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

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

Estensioni caricabili dinamicamente

Le seguenti estensioni possono essere caricate dinamicamente configurando php.ini:

Per attivare queste estensioni, aggiungi le direttive per queste nel file php.ini in extension, ad esempio:

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

Variabili di ambiente

Le seguenti variabili di ambiente vengono impostate dal runtime:

Variabile di ambiente	Descrizione
`GAE_APPLICATION`	L'ID della tua applicazione App Engine. Questo ID ha il prefisso "`region code`~", ad esempio "e~" per le applicazioni di cui è stato eseguito il deployment in Europa.
`GAE_DEPLOYMENT_ID`	L'ID del deployment corrente.
`GAE_ENV`	L'ambiente App Engine. Imposta su `standard`.
`GAE_INSTANCE`	L'ID dell'istanza su cui è attualmente in esecuzione il servizio.
`GAE_MEMORY_MB`	La quantità di memoria disponibile per il processo dell'applicazione, in MB.
`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, viene impostato su `default`.
`GAE_VERSION`	L'etichetta della versione attuale del servizio.
`GOOGLE_CLOUD_PROJECT`	L'ID progetto Google Cloud associato alla tua applicazione.
`PORT`	La porta che riceve le richieste HTTP.
`NODE_ENV` (disponibile solo nel runtime Node.js)	Imposta su `production` quando il servizio viene implementato.

Puoi definire variabili di ambiente aggiuntive nel file app.yaml, ma i valori sopra indicati non possono essere sostituiti, ad eccezione di NODE_ENV.

Proxy HTTPS e di forwarding

App Engine termina le connessioni HTTPS al bilanciatore del carico e inoltra le richieste alla tua applicazione. Alcune applicazioni devono determinare l'IP e il protocollo della richiesta originale. L'indirizzo IP dell'utente è disponibile nell'intestazione standard X-Forwarded-For. Le applicazioni che richiedono queste informazioni devono configurare il framework web in modo che consideri attendibile il proxy.

Filesystem

Il runtime include una directory /tmp scrivibile, mentre tutte le altre directory hanno accesso in sola lettura. La scrittura su /tmp occupa la memoria di sistema. Per ulteriori informazioni, vedi Supporto di tempnam() e sys_get_temp_dir().

Server di metadati

Ogni istanza della tua applicazione può utilizzare il server metadati di App Engine per eseguire query sulle informazioni sull'istanza e sul tuo progetto.

Puoi accedere al server di metadati tramite i seguenti endpoint:

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

Le richieste inviate al server dei metadati devono includere l'intestazione della richiesta Metadata-Flavor: Google. Questa intestazione indica che la richiesta è stata inviata con l'intenzione di recuperare i valori dei metadati.

La tabella seguente elenca gli endpoint in cui puoi effettuare richieste HTTP per metadati specifici:

Endpoint dei metadati	Descrizione
`/computeMetadata/v1/project/numeric-project-id`	Il numero di progetto assegnato al tuo progetto.
`/computeMetadata/v1/project/project-id`	L'ID progetto assegnato al tuo progetto.
`/computeMetadata/v1/instance/region`	La regione in cui è in esecuzione l'istanza.
`/computeMetadata/v1/instance/service-accounts/default/aliases`
`/computeMetadata/v1/instance/service-accounts/default/email`	L'email del account di servizio predefinito assegnato al tuo progetto.
`/computeMetadata/v1/instance/service-accounts/default/`	Elenca tutti i service account predefiniti per il tuo progetto.
`/computeMetadata/v1/instance/service-accounts/default/scopes`	Elenca tutti gli ambiti supportati per i service account predefiniti.
`/computeMetadata/v1/instance/service-accounts/default/token`	Restituisce il token di autenticazione che può essere utilizzato per autenticare l'applicazione in altre API Google Cloud.

Ad esempio, per recuperare l'ID progetto, invia una richiesta a http://metadata.google.internal/computeMetadata/v1/project/project-id.

Di seguito è riportato un esempio di come chiamare gli endpoint dei metadati utilizzando cURL o la libreria client di Google Cloud:

/**
 * 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);
}

Sessioni

PHP fornisce un livello di gestione delle sessioni che consente alle app web di conservare le informazioni sullo stato dell'utente tra le richieste. Le sessioni in App Engine funzionano in modo molto simile a quelle di qualsiasi altra app PHP.

Per impostare una variabile nella sessione di un utente, puoi utilizzare il seguente codice:

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

Il seguente codice stamperà Bar in una richiesta successiva dello stesso utente:

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

Per sessioni di durata più lunga, utilizza un servizio di archiviazione alternativo come Cloud SQL.

Chiavi $_SERVER speciali

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

GAE_APPLICATION: l'ID progetto dell'app corrente. Google Cloud
GAE_DEPLOYMENT_ID: ID del codice sorgente di cui è stato eseguito il deployment.
GAE_ENV: l'ambiente App Engine (standard o flessibile) in cui viene eseguita l'app.
GAE_INSTANCE: il nome dell'istanza attualmente in esecuzione.
GAE_MEMORY_MB: quantità di memoria disponibile per il processo dell'app, in MB.
GAE_RUNTIME: il runtime specificato nel file app.yaml, ad esempio php72.
GAE_SERVICE: nome del servizio attualmente di cui è stato eseguito il deployment.
GAE_VERSION: nome della versione attualmente di cui è stato eseguito il deployment.
GOOGLE_CLOUD_PROJECT - Google Cloud ID progetto.
HTTP_X_APPENGINE_CITY - Nome della città da cui ha avuto origine la richiesta. Ad esempio, una richiesta della città di Mountain View potrebbe avere il valore dell'intestazione mountain view.
HTTP_X_APPENGINE_CITYLATLONG - Latitudine e longitudine della città da cui ha avuto origine la richiesta. Questa stringa potrebbe essere simile a "37.386051,-122.083851" per una richiesta da Mountain View.
HTTP_X_APPENGINE_COUNTRY - Paese da cui ha avuto origine la richiesta, come codice paese ISO 3166-1 alpha-2. App Engine determina questo codice dall'indirizzo IP del client.
HTTP_X_APPENGINE_HTTPS - Verifica l'utilizzo di HTTPS.
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" indica la California, non il Canada.
HTTP_X_APPENGINE_USER_IP: l'indirizzo IP del client. Tieni presente che $_SERVER['HTTP_X_APPENGINE_USER_IP'] è l'unico modo in cui la tua app può recuperare l'indirizzo IP del client. La variabile $_SERVER['REMOTE_ADDR'] non è disponibile in App Engine.

Direttive con nuovi valori predefiniti di inizializzazione

La tabella seguente specifica le direttive i cui valori predefiniti di inizializzazione differiscono da quelli forniti con l'interprete PHP standard disponibile su php.net. Per trovare i valori predefiniti delle direttive non specificate nella tabella seguente, consulta Direttive php.ini.

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

Esegui l'override di queste direttive predefinite includendole in un file php.ini per la tua app.

Supporto di `tempnam()` e `sys_get_temp_dir()`

Le app App Engine vengono eseguite in un ambiente sandbox di sicurezza in cui solo la directory /tmp è scrivibile e archiviata nella RAM dell'istanza. 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 come i bucket Cloud Storage.

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 dell'esempio sarebbe quindi:

hello world

Gestione delle dipendenze con Composer

Per saperne di più, consulta la pagina Specifica delle dipendenze.