Aviso: En los próximos meses, reorganizaremos el sitio de documentación de App Engine para facilitar la búsqueda de contenido y alinearlo mejor con el resto de los productos de Google Cloud. El mismo contenido estará disponible, pero la navegación ahora coincidirá con el resto de los productos de Cloud.

Dado que la versión 5.5 de PHP ya no es compatible con la comunidad, recomendamos que las apps nuevas usen el entorno de ejecución de PHP 7+.

Entorno de ejecución de PHP 5

Con App Engine, puedes compilar aplicaciones web con el lenguaje de Programación PHP. Tu aplicación de PHP se ejecuta en la infraestructura escalable de Google y usa servicios y almacenamiento continuos a gran escala.

Consulta la guía de introducción de PHP para obtener una introducción al desarrollo de aplicaciones web con PHP y App Engine.

Cómo seleccionar el entorno de ejecución de PHP

App Engine ejecuta tu aplicación web de PHP con un intérprete de PHP versión 5.5.34. Nota: En Linux, también debes instalar PHP de forma local para ejecutar las apps de PHP.

Para configurar tu app a fin de que use el entorno de ejecución de PHP, agrega lo siguiente al archivo app.yaml:

runtime: php55
api_version: 1
...

El primer elemento, runtime, selecciona el entorno de ejecución de PHP.

El segundo elemento, api_version, selecciona la versión del entorno de ejecución de PHP que se usará. En el momento en que se escribe este documento, App Engine solo tiene una versión del entorno de PHP, que es la 1. Si existieran cambios futuros que puedan no ser compatibles con versiones anteriores, el equipo de App Engine usará un identificador de la versión nueva. La app seguirá usando la versión seleccionada hasta que cambies la configuración de api_version y subas tu app.

Para obtener más información sobre el archivo app.yaml y cómo implementar la app en App Engine, consulta los temas Implementa una app de PHP y Referencia de app.yaml.

Zona de pruebas

La aplicación se ejecuta en un entorno de "zona de pruebas" restringido con el objetivo de permitir que App Engine distribuya solicitudes para aplicaciones en varios servidores web y evitar que una aplicación interfiera en otra. En este entorno, la aplicación puede ejecutar el código, usar el correo electrónico de App Engine, el servicio de recuperación de URL y servicios de usuario. Además, examina la solicitud web del usuario y prepara la respuesta.

Una aplicación de App Engine no puede hacer lo siguiente:

Escribir en el sistema de archivos. Las aplicaciones de PHP pueden usar Google Cloud Storage para almacenar archivos persistentes. La lectura del sistema de archivos está permitida y todos los archivos de aplicación subidos con esta están disponibles.
responder lentamente. Una solicitud web a una aplicación debe manejarse en cuestión de segundos. Los procesos que tardan mucho tiempo en responder se finalizan para evitar una sobrecarga del servidor web.
Hacer otro tipo de llamadas al sistema.

Carga de clases automática

Las clases de la biblioteca estándar de PHP (SPL) y cualquier otra clase que forme parte del SDK de App Engine se cargan de forma automática cuando es necesario. Esto significa que no tienes que usar declaraciones include o require en la parte superior de las secuencias de comandos de PHP.

De forma predeterminada, la carga de clases automática se realizará solo en las clases definidas en los archivos que residen en el directorio raíz del SDK en la raíz de App Engine (y, si --php_executable_path lo especificó, en tu instalación de PHP local).

Usa set_include_path en la secuencia de comandos PHP a fin de agregar más rutas de acceso que se buscarán para la carga de clases automática.

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

Extensiones habilitadas

Las siguientes extensiones se habilitaron en el entorno de ejecución de PHP para App Engine:

apc
bcmath
calendario
Core
ctype
fecha
dom
ereg
exif
filtro
ftp
gd
hash
iconv
json
libxml
mailparse
mbstring
mcrypt
Memcache
Memcached
mysql
mysqli
mysqlnd
OAuth
openssl
pcre
PDO
pdo_mysql
Reflexión
sesión
shmop
SimpleXML
soap
sockets (para las aplicaciones con facturación habilitada)
SPL
estándar
tokenizer
xml
xmlreader
xmlwriter
xsl
zip
zlib

Extensiones de carga dinámica

Si se configura php.ini, las siguientes extensiones se pueden cargar de forma dinámica:

cURL: Esta extensión usa el servicio de socket para realizar solicitudes y está sujeta a la cuota y las restricciones de ese servicio. Consulta Solicitudes salientes para obtener más información.
MongoDB: Esta extensión permite a un desarrollador conectarse a una instancia MongoDB existente. Usa el servicio de socket para realizar solicitudes y está sujeta a la cuota y las restricciones de ese servicio.
ImageMagick
intl
fileinfo

Para habilitar estas extensiones, agrégales directivas en tu archivo php.ini en extension de la siguiente manera:

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

Sesiones

La mayoría de las aplicaciones web necesitan una forma de preservar la información del estado de usuario entre las solicitudes. PHP proporciona una capa de administración de sesiones convenientes. Las sesiones en App Engine funcionan de forma similar a las sesiones de cualquier otra aplicación de PHP.

Cómo configurar una variable en la sesión de un usuario:

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

En una solicitud posterior que realiza el mismo usuario:

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

De forma predeterminada, el entorno de ejecución de App Engine usará Memcache para almacenar información de sesión mediante la clase MemcacheSessionHandler. Puedes ajustar este comportamiento si especificas tu propio controlador de sesión mediante el método session_set_save_handler() de PHP. Memcache permite guardar los datos de la sesión y recuperarlos con rapidez, lo que significa que la sobrecarga en tu solicitud será mínima. Sin embargo, los datos en Memcache de App Engine podrían limpiarse de forma periódica, lo que significa que la información de cualquier sesión se perderá. Para las sesiones que duran más, puede ser preferible usar un servicio de almacenamiento alternativo como Cloud SQL.

Claves $_SERVER especiales

En PHP, se encuentra disponible un arreglo $_SERVER[] especial en el permiso de la solicitud. Además de los parámetros de CGI estándar, App Engine agrega algunas claves útiles.

APPLICATION_ID: Es el app_id del conjunto de aplicaciones establecido cuando se creó la app, p. ej., my-wordpress.
AUTH_DOMAIN: Es el dominio que se usa para autenticar usuarios con la API de usuarios. Las apps alojadas en appspot.com tienen un AUTH_DOMAIN de gmail.com y aceptan cualquier Cuenta de Google. Las apps alojadas en un dominio personalizado mediante Google Workspace tienen un AUTH_DOMAIN igual al dominio personalizado.
CURRENT_VERSION_ID: Es la versión principal y secundaria de la aplicación que se encuentra en ejecución, como “X.Y”. El número de la versión principal (“X”) se especifica en el archivo app.yaml de la app. El número de la versión secundaria (“Y”) se configura de forma automática cuando cada versión de la aplicación se sube a App Engine. En el servidor web de desarrollador, la versión secundaria siempre es “1”.
DEFAULT_VERSION_HOSTNAME: Es el nombre de host de la versión predeterminada de esta aplicación, p. ej., my-php-app.uc.r.appspot.com.
HTTP_X_APPENGINE_CITY: Es el nombre de la ciudad donde se originó la solicitud. Por ejemplo, una solicitud de la ciudad de Mountain View podría tener el valor de encabezado de Mountain View.
HTTP_X_APPENGINE_CITYLATLONG: La latitud y longitud de la ciudad donde se originó la solicitud. Esta string podría verse así: “37.386051,-122.083851” para una solicitud de Mountain View.
HTTP_X_APPENGINE_COUNTRY: País donde se originó la solicitud, como un código de país ISO 3166-1 Alfa-2. App Engine define este código a partir de la dirección IP del cliente.
HTTP_X_APPENGINE_REGION: Es el nombre de la región donde se originó la solicitud. Este valor solo tiene sentido en el contexto del país en X-Appengine-Country. Por ejemplo, si el país es “EE.UU.” y la región es “ca”, significa “California”, no Canadá.
USER_EMAIL: Muestra la dirección de correo electrónico del usuario si se ha autenticado con la API de usuarios. Las aplicaciones deben usar sobrenombres para los nombres que se visualizan.
USER_ID: Si la dirección de correo electrónico está asociada a una Cuenta de Google, user_id muestra el ID permanente único del usuario, un archivo str (si se autenticaron mediante la API de usuarios). Este ID siempre es el mismo para el usuario, sin importar si este cambia su dirección de correo electrónico.
USER_IS_ADMIN: Es 1 si el usuario con el que se accedió también es un administrador de la aplicación, si se autenticó con la API de usuarios. En caso contrario, es 0.
USER_NICKNAME: Para los usuarios con Cuentas de Google, el sobrenombre es la parte del “nombre” de la dirección de correo electrónico del usuario si la dirección está en el mismo dominio que la aplicación o, de lo contrario, la dirección de correo electrónico completa del usuario.
USER_ORGANIZATION: Una aplicación que usa la configuración de Cuentas de Google puede determinar si el usuario registrado en este momento usa una Cuenta de Google personal o una administrada por un dominio de Google Workspace.

Comportamientos `PHP_SELF` y `SCRIPT_NAME` actualizados en 1.9.0

La implementación de $_SERVER['SCRIPT_NAME'] y $_SERVER['PHP_SELF'] antes de la versión 1.9.0 es muy diferente de la versión 1.9.0 y posteriores. Los cambios se realizaron para ser coherentes con la implementación de Apache que, por lo general, esperan las aplicaciones de PHP.

En los siguientes ejemplos, se muestra la diferencia.

Antes de 1.9.0	Después de 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

Directivas con nuevos valores predeterminados de inicialización

En esta tabla, se especifican las directivas cuyos valores predeterminados de inicialización son distintos a los valores predeterminados proporcionados con el intérprete estándar de PHP disponible en php.net. Puedes anular estas directivas predeterminadas si las incluyes en un archivo php.ini de la aplicación.

Directiva	Valor predeterminado en 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`

Funciones inhabilitadas

Ya sea por motivos de seguridad o por compatibilidad con el entorno de ejecución de App Engine, se han inhabilitado algunas funciones de PHP. Algunas de estas se pueden volver a habilitar de manera explícita en el archivo php.ini para tu aplicación.

Funciones inhabilitadas de forma definitiva

Las siguientes funciones se inhabilitaron de forma definitiva en 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 no incluye la extensión pcntl y, por lo tanto, las funciones que proporciona pcntl no están disponibles para las apps con PHP que se ejecutan en App Engine.

Asistencia para `tempnam()` y `sys_get_temp_dir()`

Las aplicaciones de App Engine se ejecutan en una zona de pruebas de seguridad que no permite la escritura en el sistema de archivos local. Por este motivo, la versión de tempnam() de App Engine muestra un archivo temporal en memoria que se puede escribir luego en una solución de almacenamiento permanente, como los depósitos de Google Cloud Storage.

El siguiente es un ejemplo de cómo realizar operaciones de escritura en el archivo temporal en la memoria mediante file_put_contents() y 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);

El resultado esperado del ejemplo sería el siguiente:

hello world

Funciones restringidas de manera parcial

El entorno de ejecución de App Engine para PHP no es compatible con el modificador de patrones /e de las funciones preg_replace() y mb_ereg_replace(). Consulta la documentación de PREG_REPLACE_EVAL para ver la notificación de baja y un ejemplo de cómo actualizar tu código a fin de usar preg_replace_callback() en su lugar.

Funciones que se pueden habilitar de forma manual

En esta lista, se especifica la función de PHP que debe habilitarse de forma manual mediante la directiva google_app_engine.enable_functions en el archivo php.ini de la aplicación.

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

También puedes inhabilitar funciones de forma manual mediante la directiva disable_functions en el archivo php.ini de la aplicación.

Funciones que requieren que la facturación esté habilitada

Las siguientes funciones usan Sockets y, por lo tanto, solo están disponibles para aplicaciones con facturación habilitada.

Todas las funciones de red excepto gethostname()
Todas las funciones de sockets
Todas las Funciones de FTP
cURL, a menos que se use cURL Lite
MongoDB
Las conexiones TCP/IP a los servidores de MySQL (Cloud SQL se puede usar solo con un socket UNIX)

Compatibilidad de flujo

Wrappers de flujo PHP E/S compatibles

Los siguientes wrappers de flujo PHP E/S son compatibles:

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

Wrappers de transmisión

Muchas funciones en PHP, como fopen() o file_get_contents(), aprovechan la interfaz de transmisiones de PHP para admitir distintos protocolos.

La siguiente es una lista de wrappers de flujo integrados que se registran de forma automática y están disponibles en el entorno de ejecución de App Engine.

file://
glob://
http:// (se comporta como el controlador de transmisiones de http integrado de PHP, pero usa el servicio URLfetch de App Engine)
https:// (usa el servicio URLfetch de App Engine)
ftp://
gs:// (el controlador de transmisiones de Google Cloud Storage)
zlib://

La siguiente es una lista de controladores de transmisión integrados que no son compatibles con App Engine y no se han registrado.

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

Transportes de flujo inhabilitados

Los siguientes transportes de flujo se han inhabilitado

ssl
sslv2
sslv3
tcp
tls
udg
udp
unix

PHP pura

Todos los códigos para el entorno de ejecución de PHP deben ser PHP puras. App Engine no permite que subas tus propias extensiones C.

El entorno incluye la biblioteca estándar de PHP. Algunas extensiones se han inhabilitado debido a que sus funciones principales no son compatibles con App Engine, como las herramientas de redes y la escritura en el sistema de archivos.

Puedes incluir otras bibliotecas PHP puras para la aplicación a través del código en el directorio de la aplicación, que es el mismo que contiene el archivo app.yaml.

Por ejemplo, puedes crear un vínculo simbólico en el directorio de la aplicación que se oriente a un directorio de la biblioteca. Se sigue ese vínculo y se incluye esa biblioteca en la aplicación cuando implementas en App Engine.

También puedes incluir bibliotecas PHP si especificas las directivas php.ini e incluyes las declaraciones include de PHP en el código. Sin embargo, la alternativa preferida es usar una herramienta de administración de dependencias de PHP, como Composer.

Ejemplos:

Si incluyes el directorio raíz de la aplicación en la directiva include_path del archivo php.ini, ejecuta el siguiente comando:
```
include_path=".:/[ROOT_DIR]/myapp"
```
Luego, puedes usar las declaraciones include o include_once para incluir archivos PHP relacionados con include_path:
```
include_once 'myfile.php';
```
Si eliges usar Composer para incluir tus bibliotecas PHP puras, incluye un archivo único después de que se hayan instalado la dependencias:
```
require_once 'vendor/autoload.php';
```
Cuando usas Composer para instalar las dependencias de la aplicación, se agregan todos los paquetes en el directorio de la aplicación en vendor, que es también donde se genera el archivo autoload.php.

Herramientas

El SDK para App Engine incluye herramientas que te permiten probar tu aplicación y subir sus archivos.

El servidor de desarrollo ejecuta la aplicación en tu computadora local para probarla.

La herramienta de gcloud controla toda la interacción entre la línea de comandos y la aplicación que se ejecuta en App Engine. Usa gcloud app deploy para subir la aplicación a App Engine o para actualizar archivos de configuración individuales. También puedes visualizar los datos de registro de la app, de modo que puedas analizar su rendimiento con tus propias herramientas.

Código fuente intérprete de PHP

Puedes descargar el código fuente para el intérprete de PHP de App Engine en el repositorio appengine-php en GitHub.

Simultaneidad y latencia

La latencia de tu aplicación tiene el mayor impacto en la cantidad de instancias necesarias para entregar tu tráfico. Si procesas las solicitudes con rapidez, una sola instancia puede manejar muchas solicitudes.

Variables de entorno

El entorno de ejecución configura las siguientes variables del entorno:

Variable del entorno	Descripción
`GAE_APPLICATION`	ID de tu aplicación de App Engine. Este ID tiene el prefijo “`region code`~”, como “e~”, para aplicaciones implementadas en Europa.
`GAE_DEPLOYMENT_ID`	ID de la implementación actual.
`GAE_ENV`	Entorno de App Engine. Se define en `standard`.
`GAE_INSTANCE`	ID de la instancia en la que se está ejecutando tu servicio.
`GAE_RUNTIME`	Entorno de ejecución especificado en el archivo `app.yaml`.
`GAE_SERVICE`	Nombre de servicio especificado en el archivo `app.yaml`. Si no se especifica un nombre de servicio, se asigna `default`.
`GAE_VERSION`	Etiqueta de la versión actual de tu servicio.
`GOOGLE_CLOUD_PROJECT`	ID del proyecto de Cloud asociado a tu aplicación.
`PORT`	Puerto que recibe las solicitudes HTTP.

Puedes definir variables de entorno adicionales en tu archivo app.yaml, pero los valores anteriores no se pueden anular.