Usando Iron.io IronWorker

Iron.io es una plataforma de procesamiento de trabajos sin servidor diseñada para un alto rendimiento y concurrencia. Construido alrededor de contenedores Docker, la plataforma en sí es independiente del idioma. Podemos usarlo para ejecutar prácticamente cualquier lenguaje de programación, incluido PHP.

Existen tres características principales de la plataforma Iron.io:

  • IronWorker: este es un servicio elástico de tareas/trabajo tipo cola que escala el procesamiento
  • IronMQ: este es un servicio de colas de mensajes diseñado para sistemas distribuidos
  • IronCache: esta es una tienda de clave/valor elástica y duradera

Si bien no podemos ejecutar PHP en tiempo real dentro de la plataforma Iron.io, podríamos utilizar su función IronWorker para aplicaciones de tipo tarea / cola.
Suponiendo que tengamos una cuenta Iron.io abierta y el servidor Ubuntu con Docker instalado, podremos seguir los siguientes pasos que describen el flujo de trabajo de IronWorker.

Comenzamos haciendo clic en el botón Nuevo proyecto debajo del panel de Iron.io. Esto abre una pantalla simple, donde todo lo que necesitamos es ingresar el nombre del proyecto:

Una vez creado el proyecto, podemos hacer clic en el enlace de configuración del proyecto. Esto abre una pantalla con varios datos, incluidos los parámetros de autenticación / configuración:

Necesitaremos estos parámetros ya que configuraremos el archivo iron.json más adelante. Con esta información disponible, estamos listos para proceder con los bits de la aplicación.
En cuanto a la aplicación, comenzamos instalando la herramienta de consola de iron:

curl -sSL https://cli.iron.io/install | sh

Una vez instalado, el comando iron debería estar disponible a través de la consola, como se muestra en la siguiente captura de pantalla:

Ahora estamos listos para lanzar nuestra primera aplicación Iron.

Suponiendo que tenemos un directorio limpio donde queremos colocar nuestros archivos de aplicación, comenzamos agregando composer.json con el siguiente contenido:

{
"require": {
"iron-io/iron_worker": "2.0.4",
"iron-io/iron_mq": "2.*",
"wp-cli/php-cli-tools": "~0.10.3"
}
}

Aquí, solo le estamos diciendo a Composer qué bibliotecas utilizar:

Luego creamos Dockerfile con su contenido de la siguiente manera:

FROM iron/php
WORKDIR /app
ADD . /app
ENTRYPOINT ["php", "greet.php"]

Estas instrucciones de Dockerfile ayudan a Docker a crear automáticamente la imagen necesaria para nosotros.
Luego agregamos el archivo greet.payload.json con su contenido de la siguiente manera:

{
"name": "John"
}

Esto no es realmente una parte necesaria del proceso, pero lo estamos utilizando para simular la carga que recibe nuestra aplicación.

Luego agregamos el archivo greet.php con su contenido de la siguiente manera:

<?php
require 'vendor/autoload.php';
$payload = IronWorker\Runtime::getPayload(true);
echo 'Welcome ', $payload['name'], PHP_EOL;

El archivo greet.php es nuestra aplicación real. El trabajo que se crea en el servicio IronWorker estará haciendo cola y ejecutando esta aplicación. La aplicación en sí es simple; simplemente toma el valor de una variable de carga denominada nombre, y la repite. Esto debería ser suficiente para nuestros propósitos de demostración de IronWorker.
Luego creamos el archivo iron.json con un contenido similar, de la siguiente manera:

{
"project_id": "589dc552827e8d00072c7e11",
"token": "Gj5vBCht0BP9MeBUNn5g"
}

Nos aseguramos de pegar project_id y el token obtenido de la pantalla de configuración del Proyecto dentro del panel de Iron.io.
Con estos archivos en su lugar, hemos definido nuestra aplicación y ahora estamos listos para iniciar las tareas relacionadas con Docker. La idea general es que primero crearemos una imagen local de Docker para fines de prueba. Una vez que hayamos terminado con la prueba, empujaremos la imagen de Docker al repositorio de Docker y luego configuraremos la plataforma Iron.io para usar la imagen del repositorio de Docker para alimentar su trabajo IronWorker.
Ahora podemos instalar nuestras dependencias de trabajo en Docker, según lo establecido por el archivo composer.json. Lo haremos ejecutando el siguiente comando:

docker run --rm -v "$PWD":/worker -w /worker iron/php:dev composer install

El resultado debe mostrar las dependencias de instalación de Composer, como puede ver en la siguiente captura de pantalla:

Una vez que Composer haya terminado de instalar las dependencias, debemos probar para ver si nuestra aplicación se está ejecutando. Podemos hacer esto a través del siguiente comando:

docker run --rm -e "PAYLOAD_FILE=greet.payload.json" -v "$PWD":/worker -w
/worker iron/php php greet.php

El resultado resultante del comando anterior debe ser una cadena de bienvenida de John, como se muestra en esta captura de pantalla:

Esto confirma que nuestra imagen de Docker funciona correctamente, y ahora estamos listos para compilarla y desplegarla en https://hub.docker.com.

Docker Hub, disponible en https://hub.docker.com, es un servicio basado en la nube que proporciona una solución centralizada para la imagen del contenedor
administración. Si bien es un servicio comercial, hay un repositorio gratuito plan disponible.

Suponiendo que hayamos abierto una cuenta de Docker Hub, ejecutar el siguiente comando a través de la consola nos marcaría como conectados:

docker login --username=ajzele

Donde ajzele es el nombre de usuario que debe reemplazarse con el nuestro:

Ahora podemos empaquetar nuestra imagen Docker ejecutando el siguiente comando:

docker build -t ajzele/greet:0.0.1 .

Este es un comando de compilación estándar que creará una imagen ajzele/greet, marcada con la versión 0.0.1:

Con la imagen ahora creada, deberíamos probarla antes de enviarla al Docker Hub.
La ejecución del siguiente comando confirma que nuestra imagen ajzele/greet recién creada funciona bien:

docker run --rm -it -e "PAYLOAD_FILE=greet.payload.json" ajzele/greet:0.0.1

El resultado de Welcome John confirma que nuestra imagen ahora está lista para implementarse en Docker Hub, lo que se puede hacer con el siguiente comando:

docker push ajzele/greet:0.0.1

Una vez que se realiza el proceso de inserción, deberíamos poder ver nuestra imagen en el panel de Docker Hub:

Unos cuantos pasos hasta ahora, pero ya casi estamos allí. Ahora que nuestra aplicación está disponible como una imagen de Docker en el repositorio de Docker Hub, podemos volver a centrarnos en la plataforma Iron.io. La herramienta de consola de iron que instalamos al principio del proceso puede registrar la imagen de Docker Hub como un nuevo trabajador en Iron.io tablero:

iron register ajzele/greet:0.0.1

La siguiente captura de pantalla muestra el resultado de este comando:

En este punto, deberíamos ver al trabajador ajzele/greet debajo de la pestaña Iron.io
TAREAS del tablero de instrumentos:

Aunque el trabajador está registrado, no se ejecuta en este momento. La plataforma Iron.io nos permite ejecutar al trabajador como una tarea programada o en cola.

La tarea programada, como se muestra en la siguiente captura de pantalla, nos permite elegir la imagen Docker registrada junto con el tiempo de ejecución y algunas otras opciones:

La tarea en cola, como se muestra en la siguiente captura de pantalla, también nos permite elegir la imagen Docker registrada, pero esta vez sin ninguna configuración de tiempo específica:

Usando la herramienta de consola de iron, podemos crear tanto el horario como las tareas de la cola basadas en el ajzele/greet worker.
El siguiente comando crea una tarea programada basada en el trabajador ajzele/greet:

iron worker schedule --payload-file greet.payload.json -startat="
2017-02-12T14:16:28+00:00" ajzele/greet

El parámetro start-at define una hora en el formato RFC3339.

Para obtener más información sobre el formato RFC3339, consulte https://tools.ietf.org/html/rfc3339.

La siguiente captura de pantalla muestra el resultado del comando anterior:

El panel de Iron.io ahora debería mostrar esto como una nueva entrada en la sección TAREAS PROGRAMADAS:

Cuando llegue el momento programado, la plataforma Iron.io ejecutará esta tarea programada.
El siguiente comando crea una tarea en cola basada en el trabajador ajzele/greet:

iron worker queue --payload-file greet.payload.json --wait ajzele/greet

La siguiente captura de pantalla muestra el resultado de este comando:

El panel Iron.io registra cada tarea ejecutada al aumentar el contador Completo (que actualmente muestra 3 en la siguiente captura de pantalla) en la sección TAREAS:

Al ingresar al ajzele/greet worker se revelan detalles detrás de cada trabajo, tanto programados como en cola:

Hasta ahora, ha aprendido cómo crear una imagen Docker de una aplicación PHP, empujarla al Docker Hub, registrarla en la plataforma Iron.io y comenzar a programar y poner en cola las tareas.
La parte sobre las tareas de programación y colas puede ser un poco complicada ya que lo estábamos haciendo desde la consola y no desde el código PHP.
Afortunadamente, el archivo composer.json hace referencia a todas las bibliotecas que necesitamos para poder programar y poner en cola tareas desde el código PHP. Supongamos, por un momento, que tomamos los archivos iron.json y composer.json y pasamos a un archivo completamente diferente al servidor, tal vez incluso nuestra máquina de desarrollo local. Todo lo que necesitamos hacer es ejecutar la instalación del compositor en la consola y crear el archivo index.php con el contenido de la siguiente manera:

<?php
require ‘./vendor/autoload.php’;
$worker = new IronWorker\IronWorker();
$worker->postScheduleAdvanced(
‘ajzele/greet’,
[‘name’ => ‘Mariya’],
‘2017-02-12T14:33:39+00:00’);
$worker->postTask(
‘ajzele/greet’,
[‘name’ => ‘Alice’]
);

Una vez que se ejecuta este código, creará una tarea programada y una en cola, tal como lo hace la herramienta de consola de iron.
Si bien es posible que no alojemos una aplicación PHP completa, la plataforma Iron.io hace que crear y ejecutar varios trabajos aislados sea fácil y sin complicaciones, lo que brinda a los desarrolladores una experiencia sin servidor que vale la pena.

Comparte