Gestionar extensiones PHP es tan fácil como PIE

Creo que nunca ha habido un mejor momento para ser desarrollador PHP. Tal vez tengo gafas de color de rosa, o tal vez simplemente no he experimentado suficiente dolor histórico, pero FrankenPHP ha dado al lenguaje un nuevo tiempo de ejecución rápido como el rayo, y las aplicaciones PHP ahora se pueden construir de forma nativa para dispositivos Android y iOS de forma gratuita con NativePHP.

En este artículo, vamos a ver el Instalador PHP para Extensiones (PIE) y crear una extensión PHP personalizada.

Gestores de paquetes y extensiones en PHP

A menudo experimento asentimientos cómplices cuando el tema de Compositor . Esto suele ir acompañado de la afirmación de que "PHP tiene el mejor gestor de paquetes". Debido a las robustas características de Composer, no creo que haya nunca experimentado dificultades con él. Pensé: "¿Qué circunstancias del ecosistema nos dan herramientas como esta?". Sin menospreciar la inmensa cantidad de trabajo de Nils y Jordi que lo hizo posible, pero también he notado que PHP tiende a tener muchas herramientas de facto, que menos es más. Composer es nuestro gestor de paquetes de facto. Compara eso con, digamos, Node o Python, donde los desarrolladores tienen que tener el dedo en el pulso para ver lo que viene después y lo que la comunidad decide que "es lo mejor". Aparecen nuevas herramientas en un intento de solucionar las limitaciones de la situación actual.

Which JavaScript manager is it this week?Compositor sustituido PEAR. Pero para extensiones C en PHP, siempre ha sido PECL. En el mismo ciclo de vida, parece que ahora tenemos nuestra nueva "extensión de-facto extensión en la forma de PIE. Antes de entrar de lleno en cómo utilizarlo y qué puede hacer, he pensado que lo mejor era hacer algunas preguntas candentes a su autor, James Titcumb.

De PEAR a PECL y a PIE: la perspectiva del autor

PECL y PEAR tienen una relación un tanto confusa. Cómo y cuándo surgió PECL?

PEAR (PHP Extension and Application Repository) se fundó en 1999 como herramienta y sistema de distribución de código PHP. Funcionalmente, hace lo que Composer hace ahora, pero con un enfoque ligeramente diferente. PECL fue una rama de eso; una herramienta independiente para conectarse a los canales de PEAR y construir extensiones. Este material es extremadamente arcaico, y mientras PEAR ha sido eclipsado por Composer, PECL ha sido, hasta hace poco, la forma estándar de instalar extensiones PHP.

Dado que PECL existe desde siempre, ¿por qué aquí y ahora para PIE?

El proyecto PIE está financiado en parte por la Sovereign Tech Agency, un programa del Gobierno alemán para promover y garantizar la sostenibilidad a largo plazo de las tecnologías de código abierto. PECL ha sido históricamente difícil de mantener, es muy inferior en términos de gestión de dependencias en comparación con Composer, y requiere el mantenimiento de la infraestructura. El número de personas que conocen el funcionamiento de esa infraestructura es preocupantemente reducido. Así que, en línea con el objetivo de la Fundación PHP de reducir el "factor bus" para PECL y su infraestructura asociada, nació PIE, con el objetivo de resolver estos problemas.

Mis fuentes confidenciales me informan de que usted trabaja para la "Fundación PHP". Qué es eso y a qué se dedica?

La Fundación PHP es una organización creada inicialmente porque un grupo de personas se reunió al darse cuenta de que el número de personas que trabajaban activamente en PHP era muy bajo, dos, y luego se redujo a una en un momento dado. El objetivo es garantizar la sostenibilidad a largo plazo del lenguaje de programación PHP, algo importante si se tiene en cuenta que gran parte de la web se ejecuta en sistemas PHP. Uno de los cometidos de la fundación es emplear a desarrolladores para que trabajen en PHP y su ecosistema cercano. buscando patrocinadores.

¿Qué novedades podemos esperar para 2026?

Un gran impulso en la actual serie en desarrollo PIE 1.4 es asegurar que PIE funcione mejor con los sistemas de instalación de extensiones existentes que anteriormente envolvían PECL o tenían su propia manera de hacer las cosas (como en Docker), así como para eliminar algunas de las molestias de los usuarios finales que necesitan instalar requisitos previos (tales como herramientas de compilación, bibliotecas del sistema, etc.). También vamos a proporcionar experimentalmente binarios ejecutables pre-construidos de PIE utilizando una herramienta llamada Static PHP. Hay mucho más en el horizonte también. El objetivo final es que PIE sustituya completamente a PECL, y estamos trabajando para conseguirlo.

Tutorial: Uso de PIE para gestionar extensiones

Así pues, este tutorial consta de dos partes. En primer lugar, vamos a instalar PIE y utilizarlo para obtener una extensión de ejemplo. Luego pasaremos a cosas más complejas escribiendo nuestra propia extensión y haciendo que PIE la compile.

¿Cómo está tu C?

Así es. C. He hablado muchas veces con desarrolladores de otras comunidades lingüísticas, y a menudo se sorprenden bastante al enterarse por primera vez de que Rasmus Lerdorf construyó PHP como un lenguaje compilado desde C. Entonces, ¿para escribir una extensión de PHP que será usada por PIE? Sip, va a ser en C.

Instalación de PIE

PIE se presenta como un ejecutable PHAR (Agradecimiento a Davey Shafik por su increíble trabajo en llevar esto a PHP). Puede descargar el PHAR desde aquíy luego ponerlo en su PATH de ejecutable de línea de comandos para cualquier sistema operativo que esté usando.

Una vez que haya establecido un alias en su archivo shell RC o añadido PIE a su ruta, puede utilizarlo para instalar una extensión de ejemplo. Haremos esto primero, antes de crear la nuestra.

pie install asgrim/example_pie_extension

Composer, but slightly different!Fantástico, ya está instalado. Es hora de comprobar si funciona: crea un nuevo archivo PHP y añade lo siguiente:

test.php

<?php
    example_pie_extension_test();

Salidas:

php test.php

Hello, world!

Ah, el viejo clásico. Ahora estamos cocinando.

Escribir nuestra propia extensión PHP

Aquellos familiarizados con Laravel conocerán el infame dd() helper. Ejecuta tanto var_dump()y luego die(). Este código se encuentra en el núcleo de Laravel, pero ¿y si decidimos codificar nuestra propia extensión para tener esta función de forma nativa en tiempo de ejecución de PHP? ¡Eso es exactamente lo que vamos a hacer!

Empiece por crear una carpeta de proyecto. Por ejemplo:

mkdir native_dd
cd native_dd && touch native_dd.c

Espero que tengas instaladas las extensiones de lenguaje C en tu IDE.

Hemos creado native_dd.c. Como ya estamos en la tierra de C, ¡es hora de empezar a codificar con el motor Zend!

#include "php.h"
#include <ext/standard/php_var.h>
#include "php_native_dd.h"

PHP_FUNCTION(native_dd)
{
   zval *value;

   ZEND_PARSE_PARAMETERS_START(1, 1)
       Z_PARAM_ZVAL(value)
   ZEND_PARSE_PARAMETERS_END();

   php_var_dump(value, 0);
  
   php_printf("\n");
   php_output_flush();

   zend_bailout();
}

ZEND_BEGIN_ARG_INFO(arginfo_native_dd_test, 0)
ZEND_END_ARG_INFO()

static const zend_function_entry native_dd_functions[] = {
   PHP_FE(native_dd, arginfo_native_dd_test)
   PHP_FE_END
};

zend_module_entry native_dd_module_entry = {
   STANDARD_MODULE_HEADER,
   "native_dd",
   native_dd_functions,
   NULL,
   NULL,
   NULL,
   NULL,
   NULL,
   "0.1.0",
   STANDARD_MODULE_PROPERTIES
};

ZEND_GET_MODULE(native_dd)

Hay varias cosas a tener en cuenta aquí. En primer lugar, para codificar una Función PHP, necesitas adherirte a la estructura que es usada por el Motor Zend. Puedes leer más sobre estos requisitos aquí: https://www.phpinternalsbook.com/php5/build_system/building_extensions.html.

Cuando tengamos todos los archivos que necesitamos, la estructura de archivos de tu proyecto debería tener este aspecto:

pietest/
  composer.json
  composer.lock
  config.m4
  native_dd.c
  php_native_dd.h
  test.php

No te preocupes si te faltan archivos en este punto; llegaremos a ellos.

El resumen es el siguiente:

• Debe incluir PHP primeroya que el orden de inclusión en C es importante

• Este módulo utiliza parte de la biblioteca estándar (php_var_dump()), por lo que es necesario importarla: #include <ext/standard/php_var.h>

• Es necesario incluir un archivo de cabecera para la función, más sobre esto en breve

• La nomenclatura utilizada para la capa API de PHP en C es PHP_FUNCTION() para la definición ZEND_BEGIN_ARG_INFO() y ZEND_END_ARG_INFO() para el detalle de los argumentos. zend_function_entry <your-module-name> con sufijo <your-module-name>_functions[] se usa con una macro PHP_FEque compila tu función a una función interna de Zend. Los últimos pasos son definir la función como un módulo con zend_module_entry y ZEND_GET_MODULE.

• php_var_dumpla misma función subyacente utilizada por PHP var_dump de PHP se importa y utiliza

• Se utiliza un equivalente de die() que es zend_bailout()

Comprensiblemente, la mayor parte de esto puede parecer extraño a los desarrolladores de PHP como yo. Familiarizarse con las peculiaridades de Zend Engine y las definiciones de API no es para los débiles de corazón, pero la parte realmente agradable viene con PIE.

El módulo requiere un archivo de cabecera y un archivo de configuración, así que cree un archivo config.m4 y un archivo php_native_dd.h archivo.

config.m4

PHP_ARG_ENABLE(native_dd, whether to enable native_dd,
[  --enable-native-dd   Enable native_dd])

if test "$PHP_NATIVE_DD" != "no"; then
    PHP_NEW_EXTENSION(native_dd, native_dd.c, $ext_shared)
fi


php_native_dd.h

#ifndef PHP_NATIVE_DD_H
#define PHP_NATIVE_DD_H

extern zend_module_entry native_dd_module_entry;
#define phpext_native_dd_ptr &native_dd_module_entry

#endif

Hace años, creo recordar que intenté compilar mi propio módulo y fracasé estrepitosamente con la plataforma en la que intentaba construirlo. Creo que por aquel entonces ni siquiera sabía cómo funcionaban cosas como GCC y MAKEFILEs.

Así que, ¿adivina qué vamos a hacer ahora? Así es, usar PIE para que haga todo el trabajo duro.

La compilación asombrosamente fácil ...

... si tienes todo configurado correctamente.

PIE requiere varias bibliotecas a nivel de sistema operativo, así que asegúrese de tener todo lo necesario.

Para los autores de extensiones, su código C se trata como cualquier otra dependencia, utilizando Composer. Nuestro código composer.json de nuestro código tiene este aspecto:

{
   "name": "jimseconde/nativedd",
   "description": "A Native dd() helper for core PHP to be installed with PIE",
   "authors": [
       {
           "name": "jimseconde",
           "email": "jim.seconde@googlemail.com"
       }
   ],
   "require": {
       "php": "^8.3"
   },
   "type": "php-ext",
   "php-ext": {
       "extension-name": "native_dd"
   },
   "license": "MIT"
}

La parte importante aquí es typeque le dice a Composer que no es una dependencia de PHP, sino que php-ext lo define como una extensión. Debe acompañar esto con la extensión php-ext que define la extensión extension-name. Al ejecutar PIE con pie installel código PIE buscará en el archivo composer.json y lo construirá a partir de ahí:

pie install

Built, enabled, and loaded!Ahora, cree un archivo PHP de prueba y utilícelo.

<?php

$myVariable = "test string";
native_dd($myVariable);

Ejecutarlo, y:

php test.php

string(11) "test string"

Hecho.

Conclusión

Voy a admitir que nunca pensé que vería el día en que realmente podría codificar mis propias Funciones PHP. Verás en el proceso de construcción cuando ejecutes PIE (puedes agregar filtros de verbosidad a la línea de comandos con -v -vv etc para obtener más registros) que se encarga de muchas de cosas para que sea tan fácil ya sea bajar extensiones existentes o construir las tuyas propias. Para otros usos interesantes, puedo ver (por ejemplo) las extensiones personalizadas utilizadas para NativePHP construye que permitirá el acceso a todo tipo de API nativa dentro de un dispositivo o máquina.