Esta página foi traduzida pela API Cloud Translation.

Ambiente de tempo de execução do PHP

O tempo de execução do PHP é a pilha de software responsável por instalar o código do seu serviço Web e as respetivas dependências, bem como executar o seu serviço.

Para especificar o PHP para o ambiente padrão do App Engine, declare o tempo de execução no ficheiro app.yaml. Por exemplo:

runtime: phpVERSION

Onde VERSION são os números das versões do PHP MAJOR e MINOR. Por exemplo, para usar a versão mais recente do PHP, o PHP 8.4, especifique 84.

Para outras versões do PHP suportadas e a versão correspondente do Ubuntu para a sua versão do PHP, consulte a programação de suporte de tempo de execução.

Versão do PHP

A versão do PHP mais recente suportada é a 8.4. O tempo de execução do PHP usa a versão estável mais recente da versão especificada no ficheiro app.yaml. O App Engine é atualizado automaticamente para novas versões de lançamento de patches, mas não atualiza automaticamente a versão secundária.

Por exemplo, a sua app pode ser implementada no PHP 7.3.0 e, posteriormente, atualizada automaticamente para a versão 7.3.1, mas não é atualizada automaticamente para o PHP 7.4.0.

Arranque da app

Tem de implementar um controlador frontal para processar todo o encaminhamento de pedidos.

Os exemplos seguintes mostram diferentes formas de publicar a sua app:

Se a sua app contiver um ficheiro public/index.php ou index.php, o App Engine usa este ficheiro para publicar a sua app.

Recomendamos que use uma framework, como Laravel, Symfony ou Slim, porque oferece um encaminhamento simples para escrever e implementar apps PHP rapidamente. Veja um exemplo de um controlador frontal Slim.

No entanto, se estiver a migrar uma app antiga, consulte o seguinte ficheiro de exemplo index.php para importar os ficheiros PHP de que precisa e implementar o controlador frontal manualmente:
```
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 especificar o elemento entrypoint opcional no ficheiro app.yaml, o App Engine usa o comando no elemento entrypoint para publicar a sua app em vez de usar public/index.php ou index.php:
```
    entrypoint: serve path/to/my/front/controller.php
```
O campo entrypoint usa o comando serve incorporado, que é um programa nos runtimes do PHP que inicia a implementação php-fpm e um servidor Web em segundo plano. Este servidor Web encaminha todo o tráfego para o ficheiro PHP fornecido através do padrão de design do controlador frontal.

O comando serve tem duas flags opcionais:
- --workers=N: especifica o número N de trabalhadores php-fpm. Se não definir a flag --workers, o comando serve adivinha o número de trabalhadores com base na quantidade de memória disponível. Para obter os melhores resultados, defina os valores do indicador --workers no comando serve e no elemento max_concurrent_requests para serem o mesmo número.
- --enable-dynamic-workers: especifica que quer que os trabalhadores php-fpm sejam gerados apenas conforme necessário. A predefinição é usar uma política estática para os trabalhadores php-fpm. Pode alterar o número máximo de trabalhadores gerados através da flag --workers=N. Por predefinição, o número máximo de trabalhadores gerados é o definido pela política estática.
As flags opcionais têm de aparecer antes do caminho do controlador frontal:
```
    entrypoint: serve --workers=2 --enable-dynamic-workers path/to/index.php
```
Pode implementar um processo de trabalho de execução prolongada definindo o elemento entrypoint para o caminho do ficheiro do processo de trabalho:
```
    entrypoint: php long-running-worker-file.php
```
Se o elemento entrypoint executar um script com um processo de execução prolongada, como um trabalhador do Pub/Sub subscrito num tópico, não use o comando serve.

Para mais informações, consulte a referência app.yaml .

Extensões ativadas

As seguintes extensões foram ativadas nos tempos de execução do PHP para o 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

Extensões carregáveis dinamicamente

As seguintes extensões são carregáveis dinamicamente através da configuração de php.ini:

Para ativar estas extensões, adicione diretivas para as mesmas no ficheiro php.ini sob extension, por exemplo:

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

Variáveis de ambiente

As seguintes variáveis de ambiente são definidas pelo tempo de execução:

Variável de ambiente	Descrição
`GAE_APPLICATION`	O ID da sua aplicação do App Engine. Este ID tem o prefixo "`region code`~", como "e~" para aplicações implementadas na Europa.
`GAE_DEPLOYMENT_ID`	O ID da implementação atual.
`GAE_ENV`	O ambiente do App Engine. Definido como `standard`.
`GAE_INSTANCE`	O ID da instância na qual o seu serviço está atualmente em execução.
`GAE_MEMORY_MB`	A quantidade de memória disponível para o processo da aplicação, em MB.
`GAE_RUNTIME`	O tempo de execução especificado no ficheiro `app.yaml`.
`GAE_SERVICE`	O nome do serviço especificado no ficheiro `app.yaml`. Se não for especificado nenhum nome de serviço, este é definido como `default`.
`GAE_VERSION`	A etiqueta da versão atual do seu serviço.
`GOOGLE_CLOUD_PROJECT`	O Google Cloud ID do projeto associado à sua aplicação.
`PORT`	A porta que recebe pedidos HTTP.
`NODE_ENV` (disponível apenas no tempo de execução do Node.js)	Definido como `production` quando o serviço é implementado.

Pode definir variáveis de ambiente adicionais no ficheiro app.yaml, mas os valores acima não podem ser substituídos, exceto o NODE_ENV.

HTTPS e proxies de encaminhamento

O App Engine termina as ligações HTTPS no equilibrador de carga e encaminha os pedidos para a sua aplicação. Algumas aplicações precisam de determinar o IP e o protocolo do pedido original. O endereço IP do utilizador está disponível no cabeçalho X-Forwarded-For padrão. As aplicações que requerem estas informações devem configurar a respetiva framework Web para confiar no proxy.

Sistema de ficheiros

O tempo de execução inclui um diretório /tmp gravável, com todos os outros diretórios a terem acesso só de leitura. A escrita para /tmp ocupa memória do sistema. Para mais informações, consulte o tempnam() e o apoio técnico do sys_get_temp_dir().

Servidor de metadados

Cada instância da sua aplicação pode usar o servidor de metadados do App Engine para consultar informações sobre a instância e o seu projeto.

Pode aceder ao servidor de metadados através dos seguintes pontos finais:

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

Os pedidos enviados para o servidor de metadados têm de incluir o cabeçalho do pedido Metadata-Flavor: Google. Este cabeçalho indica que o pedido foi enviado com a intenção de obter valores de metadados.

A tabela seguinte lista os pontos finais onde pode fazer pedidos HTTP para metadados específicos:

Ponto final de metadados	Descrição
`/computeMetadata/v1/project/numeric-project-id`	O número do projeto atribuído ao seu projeto.
`/computeMetadata/v1/project/project-id`	O ID do projeto atribuído ao seu projeto.
`/computeMetadata/v1/instance/region`	A região em que a instância está a ser executada.
`/computeMetadata/v1/instance/service-accounts/default/aliases`
`/computeMetadata/v1/instance/service-accounts/default/email`	O email da conta de serviço predefinido atribuído ao seu projeto.
`/computeMetadata/v1/instance/service-accounts/default/`	Apresenta todas as contas de serviço predefinidas do seu projeto.
`/computeMetadata/v1/instance/service-accounts/default/scopes`	Lista todos os âmbitos suportados para as contas de serviço predefinidas.
`/computeMetadata/v1/instance/service-accounts/default/token`	Devolve o token de autorização que pode ser usado para autenticar a sua aplicação noutras APIs Google Cloud.

Por exemplo, para obter o ID do projeto, envie um pedido para http://metadata.google.internal/computeMetadata/v1/project/project-id.

Segue-se um exemplo de como chamar os pontos finais de metadados através do cURL ou da biblioteca cliente da 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);
}

Sessões

O PHP fornece uma camada de gestão de sessões que permite que as apps Web preservem as informações do estado do utilizador entre pedidos. As sessões no App Engine funcionam de forma muito semelhante às sessões em qualquer outra app PHP.

Para definir uma variável na sessão de um utilizador, pode usar o seguinte código:

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

O seguinte código vai imprimir Bar, num pedido subsequente do mesmo utilizador:

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

Para sessões mais longas, use um serviço de armazenamento alternativo, como o Cloud SQL.

Chaves $_SERVER especiais

O PHP disponibiliza a matriz especial $_SERVER[] no âmbito do pedido. Além dos parâmetros CGI padrão, o App Engine adiciona algumas chaves úteis adicionais:

GAE_APPLICATION: ID do projeto da Google Cloud app atual.
GAE_DEPLOYMENT_ID: ID do código-fonte implementado.
GAE_ENV – O ambiente do App Engine (padrão ou flexível) onde a sua app é executada.
GAE_INSTANCE: nome da instância de execução atual.
GAE_MEMORY_MB - Quantidade de memória disponível para o processo da app, em MB.
GAE_RUNTIME - O tempo de execução especificado no seu ficheiro app.yaml, como php72.
GAE_SERVICE: nome do serviço implementado atualmente.
GAE_VERSION: nome da versão implementada atualmente.
GOOGLE_CLOUD_PROJECT - Google Cloud ID do projeto.
HTTP_X_APPENGINE_CITY - Nome da cidade de origem do pedido. Por exemplo, um pedido da cidade de Mountain View pode ter o valor do cabeçalho mountain view.
HTTP_X_APPENGINE_CITYLATLONG - Latitude e longitude da cidade de origem do pedido. Esta string pode ter o seguinte aspeto: "37.386051,-122.083851" para um pedido de Mountain View.
HTTP_X_APPENGINE_COUNTRY - País de origem do pedido, como um código do país da norma ISO 3166-1 alfa-2. O App Engine determina este código a partir do endereço IP do cliente.
HTTP_X_APPENGINE_HTTPS - Valida a utilização de HTTPS.
HTTP_X_APPENGINE_REGION - Nome da região de origem do pedido. Este valor só faz sentido no contexto do país em que o produto é vendidoX-Appengine-Country. Por exemplo, se o país for "US" e a região for "ca", esse "ca" significa "Califórnia" e não Canadá.
HTTP_X_APPENGINE_USER_IP: o endereço IP do cliente. Tenha em atenção que $_SERVER['HTTP_X_APPENGINE_USER_IP'] é a única forma de a sua app obter o endereço IP do cliente. A variável $_SERVER['REMOTE_ADDR'] não está disponível no App Engine.

Diretivas com novos valores predefinidos de inicialização

A tabela seguinte especifica as diretivas cujas predefinições de inicialização diferem das fornecidas com o intérprete PHP padrão disponível em php.net. Para encontrar os valores predefinidos das diretivas não especificadas na tabela seguinte, consulte as diretivas php.ini.

Diretiva	Valor predefinido no 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`

Substitua estas diretivas predefinidas incluindo-as num ficheiro php.ini para a sua app.

Compatibilidade com `tempnam()` e `sys_get_temp_dir()`

As apps do App Engine são executadas numa sandbox de segurança em que apenas o diretório /tmp é gravável e armazenado na RAM da instância. Por este motivo, a versão do App Engine de tempnam() devolve um ficheiro temporário na memória que pode ser escrito numa solução de armazenamento permanente, como contentores do Cloud Storage.

Segue-se um exemplo de como escrever no ficheiro temporário na memória através de 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);

O resultado esperado do exemplo seria:

hello world

Gerir dependências com o Composer

Para mais informações, consulte a página Especificar dependências.