DEV Community: Álvaro A. Quirós López

Runnerty y Cypress para comprobar que tu app está online

Álvaro A. Quirós López — Wed, 21 Apr 2021 09:22:08 +0000

Do you want to read this article in English?

Cypress es una herramienta para hacer tests e2e que ha revolucionado el panorama de los tests que ha conseguido facilitar la configuración, escritura, ejecución y depuración de este tipo de tests.

¿Qué vamos a ver en este artículo?

Vamos a ver cómo podemos desarrollar unos tests con Cypress y planificarlos con Runnerty para chequear el estado de nuestra app o web.

Para quien no lo conozca, Runnerty, es una tecnología "low code" que permite integrar y automatizar aplicaciones online & offline, infraestructura de sistemas y servicios con terceros de manera simple, rápida y segura, creando flujos de trabajo y ofreciendo una nueva forma de desarrollar.

Si quieres saber un poco más acerca de por qué deberías usarlo, aquí te dejo este post 👀.

Show me the code!

En la web de Cypress podemos encontrar documentación y casos de ejemplo muy útiles, os dejo enlace para que le echéis un ojo, muy interesante: https://docs.cypress.io/guides/getting-started/writing-your-first-test.

Nosotros vamos a ejecutarlo directamente desde un proyecto de Runnerty, para dejarlo listo y planificado para que se lance cada X horas contra nuestra web en producción 😎.

Setup

En primer lugar vamos a crear el proyecto de Runnerty

npx runnerty-cli new runnerty-cypress-test

🔎 Nota: Antes de continuar, yo siempre enlazo mis proyectos de Runnerty con la plataforma, para gestionarlo desde ahí.
Solo entras en Runnerty Platform, creas el proyecto y copias el API key generado en nuestro archivo config.json, es muy sencillo (y gratis, claro 😉).

Una vez creado el proyecto, usamos el CLI de Runnerty para añadirle Cypress:

Desde dentro de nuestro proyecto ejecutamos:

npx runnerty-cli add @runnerty/executor-cypress

Esto nos habrá dejado el proyecto listo para empezar a usar Cypress y un Workflow de ejemplo de Runnerty con los procesos de ejemplo listos para probar.

También nos habrá creado un script en nuestro package.json para ejecutar Cypress.

Nuestros tests están en la carpeta por defecto que Cypress crea para sus tests. Dentro tendremos los 2 tests creados:

./cypress/integration/sample-a.spec.js
./cypress/integration/sample-a.spec.js

Estos tests, como veis, son extremadamente sencillos, aunque no estemos muy acostumbrados podremos saber qué hacen:

describe('Runnerty IO Home Test A', () => {
 beforeEach(() => {
   cy.visit('/');
 });

 it('Should have a h1 with the text "Log in" [A-1]', () => {
   cy.get('h1').contains('Log in');
 });

 it('Should fail (Fail forced) [A-2]', () => {
   cy.get('#mat-input-0').type(Cypress.env('username'));
   cy.get('#mat-input-1').type(Cypress.env('password'));
   expect(true).to.equal(false);
 });
});

Lo "único" que hacen estos tests es conectarse a app.runnerty.io, variable que, por cierto, está definida en el archivo cypress.json y en el primer bloque comprueba la página tiene un un 'h1' con el texto 'Log in' y un segundo caso que después de escribir en el campo usuario y contraseña falla intencionadamente con un

expect(true)to.equal(false);

Podemos probar nuestros tests con Cypress con el comando:

npm run cypress:open

Veremos 2 test de ejemplo desde la consola de Cypress

Una vez lanzados desde esta consola, podremos ver su ejecución:

Planificar tests con Runnerty

🔎 Nota: Para quien no esté familiarizado con la sintaxis de Runnerty, os recomiendo este artículo de introducción.

Nosotros "simplemente" vamos a aprovechar estos tests y meterlos en la planificación de Runnerty. El CLI de Runnerty ya nos ha creado un plan de ejemplo plan_executor-cypress_sample.json con 2 procesos para ejecutar los 2 tests, solo tenemos que copiarlo y pegarlos en nuestro plan.json

...
"processes": [
  {
    "id": "CYPRESS_SIMPLE_SPEC_B_TEST",
    "name": "CYPRESS SIMPLE SPEC B TEST",
    "exec": {
      "id": "cypress_default",
      "spec": "./cypress/integration/sample-b.spec.js"
    }
  },
  {
    "id": "CYPRESS_SIMPLE_INTEGRATION_TESTS_1_FAIL",
    "name": "CYPRESS SIMPLE INTEGRATION TESTS 1 FAIL",
    "depends_process": ["CYPRESS_SIMPLE_SPEC_B_TEST"],
    "exec": {
      "id": "cypress_default",
      "browser": "chrome",
      "config": {
        "video": true
      }
    }
  }
]
...

También vamos a cambiar el scheduler para que se ejecute cada hora, no hace falta que se ejecuten todos los tests cada minuto 😉.

...
"triggers": [
  {
    "id": "schedule_default",
     "schedule_interval": "0 */1 * * *"
   }
],
...

🤔 Recuerda conectar el proyecto con Runnerty Platform para poder ejecutar la cadena desde ahí y ver qué ha pasado.

Ya solo tenemos que arrancar Runnerty 🎉

npm start

Ahora podemos entrar en Runnerty Platform, seleccionar nuestro proyecto, ir al listado de cadenas y forzar que se lancen nuestros tests (para no esperar a la siguiente hora a que se ejecuten).

Y veremos cómo se van ejecutando nuestros tests cada hora o cada vez que los lancemos nosotros manualmente.

Si entramos al detalle, veremos que el primer test ha pasado correctamente pero que el segundo ha fallado (intencionadamente).

TLDR;

Con Runnerty podemos automatizar nuestros tests de Cypress para tener control en todo momento de que nuestra plataforma no tiene ningún problema.

Os dejo este repo para que os lo descargáis y con un npm start veréis que cada 5 min tenéis runnerty.io funcionando 🚀.

https://github.com/alo/runnerty-cypress

¿Y ahora?

Te animo a que le eches un ojo y si te parece interesante puedes apoyarnos en Github ⭐️ o mandarnos un mensaje por Twitter.

enjoy

¡La versión 3 de Runnerty ya está disponible!

Álvaro A. Quirós López — Tue, 16 Mar 2021 08:30:40 +0000

Tras 1 año de desarrollo, lanzamos al mundo una nueva versión de Runnerty, la versión 3. Un año de desarrollo da para mucho y más si está en las manos de nuestro CTO, Carlos Carmona.

English version here.

Teníamos varias líneas de desarrollo abiertas, queríamos refactorizar algunas funcionalidades completamente, hacer ese código más legible en algunos puntos, más modular en otros y optimizarlo, queríamos sacar nuevas funcionalidades, pero, sobre todo, queríamos hacerlo más low code, más fácil para nosotros, los desarrolladores. Sin olvidar que Runnerty gestiona millones de procesos diarios, ¡no queremos ~muchos~ breaking changes!

Puedes empezar a utilizar Runnerty ahora y comenzar a desarrollar sus flujos de trabajo y tener su sistema supervisado y bajo control.

Refactor y optimización

Todavía teníamos algún Async / Await pendiente… probar y actualizar nuestras dependencias, y de paso darle un repaso al código en general, ver que todo está bonito.
Hemos desarrollado esos tests que faltaban y aprovechamos para mejorar el rendimiento en algunos puntos que teníamos identificados (y en algunos que no ☺️)

De paso hemos introducido Synk como herramienta para el monitoreo de seguridad de código, llevábamos probándola hace un tiempo y nos ha parecido útil para el proyecto.

Nuevas funcionalidades

Intérprete

Runnerty está provisto de un intérprete que permite ejecutar funciones sobre cualquier dato que intervenga en el flujo, operaciones con fechas, matemáticas, criptográficas o incluso operación de evaluación que suelen utilizarse en la definición de dependencias complejas, pues en esta nueva versión, hemos optimizado nuestro intérprete y hemos añadido un par de funciones nuevas:

UUID (v1-5)
HTML ESCAPE/UNESCAPE

Calendarios

Hemos mejorado el completo sistema de calendarios, que permiten que nuestros workflows tengan por ejemplo en cuenta los festivos. Hemos mejorado el acceso, lectura y parseo de calendarios ICS y hemos añadido acceso vía URL a los mismos.

Outputs de procesos

El tratamiento de los datos de salida de un proceso es algo muy interesante a la hora de definir nuestros flujos de trabajo, pues te permiten preparar la entrada para el siguiente proceso. En Runnerty V3, ahora tenemos la posibilidad de filtrar y ordenar la salida de un proceso directamente en su planificación 🤩

Namespaces

Para contextualizar nuestras cadenas. Ahora podemos hacer que Runnerty lance sólo los workflows de un determinado Namespace o al revés, excluyendo uno o varios Namespaces. También en Runnerty Platform tendrá funcionalidades de filtrado por Namespace para visualizar solo las que te interesen.

runnerty --namespace SALES,DWH
runnerty --exclude_namespace EXPERIMENTAL

Metadatos en las cadenas

Metadatos para especificar información relevante de la cadena. Muy interesante para el mantenimiento de cualquier plataforma, si una cadena falla, ¿a quién llamo?, ¿puedo volver a lanzarla?, ¿es prioritaria?

Mejoras para el desarrollo con Runnerty

Pero bueno, aquí es donde realmente vamos a notar la diferencia, no hay duda.

Mejoras en la documentación

Todo empieza por la documentación. Primero hemos cambiado la herramienta que usábamos para documentar, necesitábamos ser más ágiles en este sentido, ahora usamos Docusaurus, y nos encanta. Ahora lo tenemos más fácil y de paso hemos añadido versionado de documentación, podéis echarle un vistazo aquí.

Hemos intentado hacerla más clara y precisa. En muchos casos hemos introducido ejemplos y le estamos dando caña al blog para que haya más y más casos de uso.

Si quieres echarnos una mano, suscríbete y comparte, ¡nos ayuda un montón!

Mejoras en los mensajes

Mensajes de error y avisos más claros (y más bonitos)
Nuestro cli nos va a avisar si hay una versión de Runnerty más reciente y si hay alguna incompatibilidad con la versión de NodeJS. Además hemos mejorado algunos mensajes para que sean más descriptivos, por ejemplo, si intentamos forzar la ejecución de una cadena que no existe.

Scaffolds 🔥

Pero, lo que para mí es un “game changer”, la introducción de scaffolds. Ahora, a través del CLI de Runnerty, podrás añadir módulos a tu proyecto.

Nota: Recuerda que puedes instalar runnerty-cli o usarlo directamente con npx

npm i -g runnerty runnerty-cli

Creamos nuestro proyecto de Runnerty

npx runnerty-cli new my-awesome-project

Para usar los scaffolds, simplemente ejecuta el commando add de nuestro cli y el módulo que quieres instalar, vamos a ver un ejemplo con Cypress

npx runnerty-cli add @runnerty/executor-cypress

Y nuestro proyecto tendrá el módulo instalado en nuestro package.json, con un ejemplo de configuración en nuestro config.json y un workflow de ejemplo para incluirlo en nuestros workflows 😎

Con Runnerty, Runnerty CLI y este módulo de Cypress, podemos tener nuestra web o plataforma monitorizada en cuestión de pocos minutos 🪄, ¡os debo ese post demostrándolo!

Espero que lo disfrutéis y ya sabéis, ¡estamos encantados de recibir vuestro feedback!

Si os ha interesado y queréis saber cómo empezar a usar Runnerty, aquí os dejo un artículo que escribimos hace unos días.

Enjoy

¿Cómo empezar a usar Runnerty?

Álvaro A. Quirós López — Thu, 11 Feb 2021 19:32:21 +0000

Runnerty es una tecnología "low code" que permite integrar y automatizar aplicaciones online & offline, infraestructura de sistemas y servicios con terceros de manera simple, rápida y segura, creando flujos de trabajo y ofreciendo una nueva forma de desarrollar.

Si quieres saber un poco más acerca de por qué deberías ~~probarlo~~ usarlo, aquí te dejo este post 👀.

En este artículo vamos a ver algunos conceptos básicos de Runnerty, como crear nuestro primer proyecto y cómo conectarnos con "Runnerty Platform".

Algunos conceptos básicos
Crear nuestro primer proyecto Runnerty
Estructura del proyecto
Conectar con Runnerty Platform 🚀
Lanzar nuestro primer proceso
Extra ball: Añadir un segundo proceso y visualizarlo en la plataforma.

1. Conceptos básicos 📕

Cadenas o workflows

Son una agrupación de procesos que tienen sentido en un determinado contexto. Esto puede ser tan amplio como que puedes crear una cadena para comprobar que tu web está online, crear una cadena para recoger los pedidos de tu e-commerce y comunicarlos al proveedor que corresponda o crear cadenas de ETL para tu Data Warehouse. Runnerty nos brinda muchas funcionalidades que harán que definir estos workflows sea súper ágil y totalmente escalable, definir dependencias entre complejos, pasar valores de unos a otros o incluso evaluarlos para decidir qué “camino seguir” son solo algunas de sus posibilidades.

🔨 Ejecutores

Cada uno de los procesos de nuestra cadena, ejecutará una acción específica a través de estos módulos. Podemos usar ejecutores muy genéricos, como el de Shell, que te permite ejecutar cualquier comando por consola u otros muy específicos que nos permiten realizar acciones muy concretas, como por ejemplo comunicarnos con una empresa de reparto como MRW o Fedex.

📢 Notificadores

Como su propio nombre indica, nos van a mantener informados en todo momento, cuando empieza o acaba una cadena o un proceso concreto, si se está reintentando o si ha fallado. Podemos mandar un correo, un sms o mensaje por Telegram o conectarlo directamente con nuestro sistema de incidencias.

🏁 Triggers

Estos módulos se encargan de lanzar nuestros workflows. Puede ser algo planificado, puede ser cuando se reciba un archivo en un ftp ...

Nota 🔎: Ejecutores, notificadores y triggers son módulos, puedes desarrollar los tuyos muy fácilmente para que puedas llevar el potencial de Runnerty a donde quieras.

2. No te lo cuento, te lo enseño 👩‍💻👨‍💻

Lo único que necesitamos antes de empezar es tener instalada la versión LTS de NodeJS (V 14+). Si no la tienes, puedes descargártela aquí.

Runnerty

Lo primero, es instalar Runnerty como paquete global

npm install -g runnerty

Una vez instalado, podemos crear nuestro primer proyecto Runnerty

runnerty new my-awesome-project

🎉 ¡Ya tenemos nuestro primer proyecto Runnerty!

3. Estructura de nuestro proyecto 🔎

Es un proyecto muy sencillo, vamos a centrarnos en los 2 archivos básicos de Runnerty:

config.json
plan.json

Config

En el config.json vamos a tener 3 secciones donde iremos añadiendo las configuraciones de nuestros 3 tipos de módulos (triggers, notificadores y ejecutores). Los que ves en el ejemplo son solo un identificador y un nombre para usarlo en nuestros workflows, en caso de que el módulo necesitara algún dato más, aquí sería donde se lo indicaríamos, como por ejemplo una cuenta de correo, un usuario y contraseña, etc.

{
  "triggers": [
    {
      "id": "schedule_default",
      "type": "@runnerty-trigger-schedule"
    }
  ],
  "executors": [
    {
      "id": "shell_default",
      "type": "@runnerty-executor-shell"
    }
  ],
  "notifiers": [
    {
      "id": "console_default",
      "type": "@runnerty-notifier-console"
    }
  ]
}

Plan

En el plan es donde definimos nuestros workflows 😎
Podemos ver varias secciones:

{
  "chains": [
    {
      "id": "CHAIN_ONE",
      "name": "Chain one sample",
      "triggers": [
        ...
      ],
      "notifications": {
        ...
      },
      "defaults_processes": {
        ...
      },
      "processes": [
        ...
      ]
    }
  ]
}

Cadenas (chains)

Dentro de cada cadena, además de un nombre y una identificación, tendremos 4 secciones

1 - Triggers, lo que dispara nuestro workflow, en este caso hemos usado el plugin planificador y hemos configurado que se ejecute el proceso cada minuto.

...
"triggers": [
  {
    "id": "schedule_default",
    "schedule_interval": "*/1 * * * *"
  }
],
...

Nota 🔎: Este módulo usa nomenclatura cron estándar.

2 - Notificadores, Las notificaciones propias de nuestra workflow, en este caso vemos que nos va a avisar cuando empiece la cadena, cuando termine y si falla.

...
"notifications": {
  "on_start": [
    {
      "id": "console_default",
      "message": "@GETDATE('YYYY-MM-DD HH:mm:ss') START OF THE CHAIN: @GV(CHAIN_ID)"
    }
  ],
  "on_end": [
    {
      "id": "console_default",
      "message": "@GETDATE('YYYY-MM-DD HH:mm:ss') END OF THE CHAIN: @GV(CHAIN_ID)"
    }
  ],
  "on_fail": [
    {
      "id": "console_default",
      "message": "@GETDATE('YYYY-MM-DD HH:mm:ss') FAIL OF THE CHAIN: @GV(CHAIN_ID)",
      "mode": "error"
    }
  ]
},
...

Nota 🔎: Ya podemos ver algunas funciones propias de Runnerty, como GETDATE() que nos va a devolver la fecha con la máscara que definamos o la de GV (get value) que en este caso nos va a devolver el identificador de la cadena. Hay muchos más, aquí te dejo enlace a la documentación.

3 - Defaults (opcional). Muchas veces es muy útil definir unos valores por defecto para todos los procesos, para eso tenemos esta sección. Todos los procesos por defecto tendrán estas notificaciones configuradas, aunque siempre podemos sobrescribirlas dentro del propio proceso.

"defaults_processes": {
  "notifications": {
    "on_start": [
      {
        "id": "console_default",
        "message": "@GETDATE('YYYY-MM-DD HH:mm:ss') START: PROCESS @GV(PROCESS_ID)"
      }
    ],
    "on_fail": [
      {
        "id": "console_default",
        "message": "@GETDATE('YYYY-MM-DD HH:mm:ss') ERROR: PROCESS @GV(PROCESS_ID): @GV(PROCESS_EXEC_ERR_OUTPUT)",
        "mode": "error"
      }
    ],
    "on_end": [
      {
        "id": "console_default",
        "message": "@GETDATE('YYYY-MM-DD HH:mm:ss') END: PROCESS @GV(PROCESS_ID)"
      }
    ]
  }
},

4 - Procesos

La propiedades más comunes que podemos ver dentro de un proceso (además de su nombre y su identificador), son las siguientes propiedades:

exec
output

...
"processes": [
  {
    "id": "PROCESS_ONE",
    "name": "Process One",
    "exec": {
      ...
    },
    "output": [
      ...
    ]
  },
  ...
]
...

4.1 - La propiedad exec donde vamos a indicar qué ejecutor de nuestro config.json queremos usar y donde vamos a indicarle los valores necesarios para que se ejecute. En este caso, como vamos a usar el ejecutor de Shell, solo necesitamos indicarle el comando que queremos que ejecute.

...
{
  "id": "PROCESS_ONE",
  "name": "Process One",
  "exec": {
    "id": "shell_default",
    "command": "echo Runnerty: hello world!"
  },
  "output": [
    ...
  ]
},
...

4.2 - La propiedad output, donde tratamos la salida del proceso. En este ejemplo vamos a escribir en un fichero de log el resultado de la ejecución.

{
  "id": "PROCESS_ONE",
  "name": "Process One",
  "exec": {
    ...
  },
  "output": [
    {
      "file_name": "./@GETVALUE(PROCESS_ID).log",
      "write": [
        "EXECUTION @GV(PROCESS_ID) - AT @GETDATE('YYYY-MM-DD HH:mm:ss')\n @GV(PROCESS_EXEC_ERR_OUTPUT) @GV(PROCESS_EXEC_MSG_OUTPUT)"
      ],
      "concat": true,
      "maxsize": "10mb"
    }
  ]
},

Nota 🔎: Es interesante saber que puedes definir el tamaño máximo de tu archivo de log y evitar así problemas de espacio.

4.3 - Como comentamos antes, también podemos configurarle notificaciones concretas para este proceso, por ahora vamos a dejar esta propiedad vacía porque tenemos las notificaciones por defecto configuradas.

4. Conectar con Runnerty Platform 🚀

Vamos a conectar nuestro proyecto con Runnerty Platform para que sea más sencilla la visualización y podamos sacarle el máximo rendimiento a Runnerty. Este paso es opcional, pero te lo recomiendo, vas a disfrutar Runnerty mucho más 😊🔥.

Nos logeamos en la plataforma
Creamos el proyecto, seleccionando la opción Nuevo proyecto
Simplemente añadimos el API Key generado a nuestro archivo config.json

{
  "general": {
    "runnerty.io": {
      "apikey": "NUESTRO_TOKEN"
    }
  },
  "triggers": [...],
  "executors": [...],
  "notifiers": [...]
}

So simple 😊!

5. ¡Echar a andar nuestra cadena!

Ahora solo nos falta echar a andar nuestra cadena y ver qué sucede. Tan sencillo como ejecutar el siguiente comando:

runnerty

Si todo está correcto, ¿por qué no iba a estarlo?, veremos el siguiente mensaje en nuestra consola:

> runnerty

info: RUNNERTY v3.0.0 RUNNING - TIME...: Thu Jan 14 2021 10:29:23 GMT+0100 (hora estándar de Europa central)
info: Successful access to runnerty.io (websockets)

En este proyecto base, tenemos configurado que cada minuto se ejecute nuestro workflow, que en este caso solo muestra un mensaje por consola, y podremos ver como se han ido sustituyendo los valores.

info: 2021-01-14 10:30:00 START OF THE CHAIN: CHAIN_ONE
info: 2021-01-14 10:30:00 START: PROCESS PROCESS_ONE
info: 2021-01-14 10:30:00 END: PROCESS PROCESS_ONE

Pero, vamos a verlo en la plataforma, se acabaron los logs interminables

Iremos viendo cada una de las ejecuciones de nuestro workflow. Tenemos muchas opciones interesantes que ya explicaremos en otra ocasión, como relanzar nuestro workflow desde la plataforma en cualquier momento o ver el detalle de la ejecución.

6. Extra ball: Añadir un segundo proceso y visualizarlo en la plataforma.

Creamos un segundo proceso (copiamos el primero y le cambiamos el id y en name y le añadimos la propiedad depends_process para indicarle que depende del proceso anterior. Así de fácil...

...
"processes": [
  {
    "id": "PROCESS_ONE",
    "name": "Process One",
    "exec": {...},
    "output": [...]
  },
  {
    "id": "PROCESS_TWO",
    "name": "Process 2",
    "depends_process": ["PROCESS_ONE"],
    "exec": {
      "id": "shell_default",
      "command": "echo Runnerty: Process 2 depends on process 1!"
    },
    "output": [...]
  }
]
...

🎉 ¡Hemos creado nuestro primer workflow con dependencia entre procesos!

Ahora, si le echas un vistazo a la visualización de la cadena en la plataforma, verás esa dependencia

Obviamente, no estamos exprimiendo el potencial de Runnerty en este ejemplo tan básico, pero podemos hacer flujos de trabajo tan complejos como seas capaz de diseñar.

Empieza a delegar en Runnerty procesos de tu ecosistema y hazlo escalable y seguro 🔥.

Te animo a que le eches un ojo y si te parece interesante puedes apoyarnos en Github ⭐️ o mandarnos un mensaje por Twitter.

¿Por qué usar Runnerty?

Álvaro A. Quirós López — Mon, 18 Jan 2021 15:29:35 +0000

Cada día nacen nuevos proyectos tecnológicos, más complejos y conectados con más servicios y aplicaciones de terceros. Modelos de negocio que cada día dan servicio a más usuarios en una lucha constante de mejora en su puesta de valor. Esto conlleva un elevado coste (tiempo, recursos dedicados y dinero) en su desarrollo y en su mantenimiento.

Ya no hablamos de aplicaciones web, plataformas de venta online o aplicaciones móviles, hablamos de ecosistemas de software.

Runnerty es una tecnología que propone una nueva manera de desarrollar, creando una capa de abstracción en la que integrar y automatizar un ecosistema de software, delegando en ella gran parte de tu lógica de negocio, evitando problemas de escalabilidad, seguridad y mantenimiento, haciendo mucho más evolucionable futuros desarrollos, ahorrando tiempo y recursos.

Entonces, ¿qué es Runnerty?

Runnerty es una tecnología "low code" que permite integrar y automatizar aplicaciones online & offline, infraestructura de sistemas y servicios con terceros de manera simple, rápida y segura, creando flujos de trabajo y ofreciendo una nueva forma de desarrollar.

Da igual el tamaño de tu aplicación o plataforma e incluso el estado del desarrollo en el que se encuentre, seguramente Runnerty pueda facilitarte las cosas, darle robustez a tu sistema y darte cierta agilidad extra a la hora de evolucionarlo.

Puedes usar Runnerty de muchas maneras, desde automatización de procesos de desarrollo, como tareas de CD/CI o mantenimiento de bases de datos, hasta tareas de muy alto nivel como la comunicación directa con clientes o empresas de reparto, puedes mandarle los pedidos de tu tienda online a SEUR, por ejemplo.

Algunas de sus principales funcionalidades

Gestión de dependencias (complejas si es necesario)

Quizás lo más básico de Runnerty, poder diseñar un flujo de trabajo, que los procesos tengan sentido entre sí. Pero, no solo controla cuando se acaba un proceso para que empiece el siguiente, sino que puede hacer evaluaciones complejas, esperar a que terminen varios procesos para ejecutar un proceso u otro, hacerlo cuando acaban bien, hacerlo cuando acaban mal, crear todo tipo de vinculaciones en base al resultado del proceso, etc...

Sistema de notificaciones

Runnerty te mantiene informado wherever / whenever de cualquier evento que se produzca en tus flujos de trabajo de manera sencilla. Mediante notificaciones por email, sms, Telegram, Slack... o a cualquier plataforma que tú elijas, Y, cómo no, desde Runnerty Platform, dándote la libertad que necesitas.

Sistema de reintentos

Puedes definir cuántas veces quieres que se reintente un proceso antes de darse por fallido y cuánto tiempo quieres que pase entre reintentos.

Gestión de logs

Para evitar mantenimiento de servidores, Runnerty se ocupa de gestionar el tamaño máximo de los logs y la ubicación. Solucionamos problemas de gestión de espacio por logs de procesos que no te imaginas ni que existen.

Y si la cosa se pone seria…

No importa el tamaño del proyecto y su complejidad, no hay límites. Cuando el trabajo se pone serio Runnerty cuenta con funcionalidades avanzadas que harán de la gestión de millones procesos algo rutinario.

Sistema de colas de procesos

Puedes definir diferentes colas y que los procesos se ejecuten en el orden de llegada a las mismas.

Sistema de prioridades entre procesos

Cuando tienes muchos procesos es normal que haya varios que estén listos para ejecutarse al mismo tiempo, con Runnerty puedes establecer prioridades para que se ejecuten los que consideres más importantes primero.

Y algo más ...

Además de todo esto, Runnerty ofrece un servicio en la nube, lo que permite visualizar todo tu sistema de manera gráfica, intuitiva y personalizada.

¿Y ahora?

Si quieres empezar a usar Runnerty, te dejo este artículo para que le eches un ojo

Te animo a que le eches un ojo y si te parece interesante puedes apoyarnos en Github ⭐️ o mandarnos un mensaje por Twitter.