Questa pagina è stata tradotta dall'API Cloud Translation.

Ambiente di runtime PHP

Il runtime PHP è lo stack software responsabile dell'installazione il codice e le sue dipendenze ed eseguire il servizio.

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

runtime: phpVERSION

dove VERSION è il numero di versione di PHP MAJOR e MINOR. Ad esempio, per utilizzare la versione più recente di PHP, PHP 8.3, specifica 83.

Per altre versioni PHP supportate e la versione di Ubuntu corrispondente alla tua versione PHP, consulta la pianificazione dell'assistenza per il runtime.

Versione PHP

Il runtime PHP utilizza la release stabile più recente della versione specificata nel file app.yaml. App Engine si aggiorna automaticamente alla nuova patch di release, ma non aggiornerà automaticamente la versione secondaria.

Ad esempio, il deployment dell'app potrebbe essere eseguito automaticamente a PHP 7.3.0 e versioni successive aggiornato alla versione 7.3.1, ma non verrà automaticamente aggiornato a PHP 7.4.0.

Avvio dell'app

Dovrai implementare un controller frontale per gestire tutto il routing delle richieste.

I seguenti esempi mostrano diversi modi per pubblicare l'app:

Se l'app contiene un file public/index.php o index.php: App Engine utilizza questo file per gestire la tua app.

Ti consigliamo di utilizzare un framework, come Laravel, Symfony o Slim, in quanto fornisce un routing leggero per scrivere e implementare rapidamente le app PHP. Ecco un esempio di controller frontale Slim.

Tuttavia, se stai eseguendo la migrazione di un'app precedente, consulta il seguente file index.php di esempio per importare i file PHP di cui hai bisogno 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 gestire anziché utilizzare public/index.php o index.php:
```
    entrypoint: serve path/to/my/front/controller.php
```
Il campo entrypoint usa il comando serve integrato, che è un programma all'interno dei runtime PHP che avvia l'implementazione php-fpm server web 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. In caso contrario imposta il flag --workers, il comando serve indovina il numero in base alla quantità di memoria disponibile. Per risultati ottimali, imposta i valori per il flag --workers nel comando serve e nell'elemento max_concurrent_requests in modo che siano uguali.
- --enable-dynamic-workers: specifica che vuoi php-fpm far crescere i lavoratori solo se necessario. L'impostazione predefinita è l'utilizzo di un criterio statico per i worker php-fpm. Puoi modificare il numero massimo numero di worker generati utilizzando il flag --workers=N. Per impostazione predefinita il numero massimo di worker generati è quello predefinito dalla rete .
I flag facoltativi devono precedere il percorso del controller principale:
```
    entrypoint: serve --workers=2 --enable-dynamic-workers path/to/index.php
```
Puoi eseguire il deployment di un processo worker a lunga esecuzione impostando entrypoint al percorso file del processo worker:
```
    entrypoint: php long-running-worker-file.php
```
Se l'elemento entrypoint esegue uno script con un processo a lungo termine, come un worker Pub/Sub iscritto a un argomento, non utilizzare il comando serve.

Per ulteriori informazioni, consulta Riferimento app.yaml .

Estensioni attive

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 in modo dinamico configurando php.ini:

Per attivare queste estensioni, aggiungi istruzioni corrispondenti nel file php.ini sotto 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 è preceduto da "`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. Impostato 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 di applicazione, in MB.
`GAE_RUNTIME`	Il tempo di esecuzione specificato nel file `app.yaml`.
`GAE_SERVICE`	Il nome del servizio specificato nel file `app.yaml`. Se non viene specificato alcun nome di servizio, viene 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.
`NODE_ENV` (disponibile solo nel runtime Node.js)	Imposta su `production` quando il servizio viene disegnato.

Puoi definisci altre variabili di ambiente nel file app.yaml, ma non è possibile eseguire l'override dei valori precedenti, ad eccezione di NODE_ENV.

Proxy HTTPS e di inoltro

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

Filesystem

Il runtime include una directory /tmp scrivibile, con tutte le altre directory che hanno accesso di sola lettura. La scrittura in /tmp occupa memoria di sistema. Per ulteriori informazioni, consulta l'assistenza tempnam() e sys_get_temp_dir().

Server metadati

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

Puoi accedere al server dei 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 per i quali è possibile effettuare richieste HTTP metadati specifici:

Endpoint dei metadati	Descrizione
`/computeMetadata/v1/project/numeric-project-id`	Il numero del progetto assegnato al tuo progetto.
`/computeMetadata/v1/project/project-id`	L'ID progetto assegnato al 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'indirizzo email dell'account di servizio predefinito assegnato al progetto.
`/computeMetadata/v1/instance/service-accounts/default/`	Elenca tutti gli account di servizio predefiniti per il progetto.
`/computeMetadata/v1/instance/service-accounts/default/scopes`	Elenca tutti gli ambiti supportati per gli account di servizio predefiniti.
`/computeMetadata/v1/instance/service-accounts/default/token`	Restituisce il token di autenticazione che può essere utilizzato per autenticare la tua applicazione ad 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 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. Lavoro delle sessioni in App Engine in modo molto simile alle sessioni in 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 verrà stampato Bar su una richiesta successiva dello stesso utente:

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

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

Chiavi speciali $_SERVER

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 Google Cloud dell'app corrente.
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: nome dell'istanza in esecuzione corrente.
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 di cui è stato eseguito il deployment.
GAE_VERSION - Nome della versione di cui è stato eseguito il deployment.
GOOGLE_CLOUD_PROJECT: ID progetto Google Cloud.
HTTP_X_APPENGINE_CITY: il nome della città da cui ha avuto origine la richiesta. Ad esempio, una richiesta dalla città di Mountain View potrebbe avere l'intestazione Value Mountain View.
HTTP_X_APPENGINE_CITYLATLONG: latitudine e longitudine della città da cui l'origine della richiesta. Questa stringa potrebbe essere "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: il nome della regione da cui è stata originata 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", quella "ca" significa "California", non Canada.
HTTP_X_APPENGINE_USER_IP: l'indirizzo IP del client. Tieni presente che $_SERVER['HTTP_X_APPENGINE_USER_IP'] è l'unico modo che la tua app può recuperare all'indirizzo IP del client. La variabile $_SERVER['REMOTE_ADDR'] non è disponibile in App Engine.

Direttive con nuove impostazioni predefinite di inizializzazione

La tabella seguente specifica le istruzioni le cui impostazioni predefinite di inizializzazione sono diverse da In dotazione con l'interprete PHP standard disponibile su php.net. Per trovare i valori predefiniti per le istruzioni non specificate nella tabella seguente, fai riferimento a Istruzioni 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`

Sostituisci queste istruzioni predefinite includendole in un elemento php.ini relativo alla tua app.

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

Le app App Engine vengono eseguite in una sandbox di sicurezza in cui solo la directory /tmp è scrivibile e archiviata nella RAM dell'istanza. Per questo motivo, la versione di tempnam() di App Engine 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 scrittura 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:

hello world

Gestione delle dipendenze con Composer

Per ulteriori informazioni, consulta la pagina Specificare le dipendenze.