n8n: una herramienta para crear agentes de automatización

n8n es una herramienta (o plataforma) de automatización de flujos de trabajo de código abierto que permite conectar aplicaciones y servicios para automatizar tareas repetitivas sin necesidad de programar.

Permite la automatización de flujos de trabajo centrada en integrar aplicaciones y servicios (como APIs, bases de datos, o herramientas como Slack) mediante una interfaz visual.

Con n8n se trabaja de forma visual mediante flujos (workflows).

Es ideal para automatizar procesos de negocio, notificaciones o flujos de datos entre aplicaciones sin necesidad de programar.

n8n automatiza flujos de trabajo entre apps y es más accesible para no programadores.

Ejemplos de uso:

• Detectar un nuevo issue en GitHub y crear una tarea en Trello. 
• Conectar GitHub con Slack para notificar commits.

Caso de uso: Automatizar notificaciones de nuevos commits en GitHub.

• Nodo 1: GitHub Trigger Configura un nodo que detecta nuevos commits en un repositorio de GitHub. 
• Nodo 2: Discord o Slack Conecta un nodo que envía un mensaje a un canal de Discord o Slack con detalles del commit (autor, mensaje, enlace). 
• Flujo: GitHub → Detecta nuevo commit → Envía notificación a Discord/Slack. Esto ayuda a mantener al equipo informado sin intervención manual, y se configura visualmente en n8n.

Enlaces:

https://n8n.io/

Composer, un administrador de dependencias para PHP

Composer es un administrador de dependencias para PHP que rastrea las dependencias locales de sus proyectos y bibliotecas. Para quienes usan Java, Composer vendría siendo algo como Maven o como CPAN para los programadores Perl.

Se usa en los principales frameworks web modernos para PHP (como Laravel, Symfony, etc.). Para descargarlo debemos ir a este sitio: https://getcomposer.org/download/

También existe una imagen Docker de Composer:

$ docker pull composer/composer
$ docker run --rm -it -v "$(pwd):/app" composer/composer install

Pero, antes de hacer nada, ¿Para qué sirve Composer?

Como desarrolladores PHP, nos ayuda a:

• Resolver las dependencias para paquetes PHP.
• Cargar automáticamente paquetes de PHP.
• Mantener todos los paquetes actualizados.

Una vez instalado, verificamos:

$ composer --version

Si todo va bien, mostrará versión instalada.

A continuación una pequeña lista de comandos más usados de Composer

Comandos más usados de Composer

Obtener ayuda:

$ composer --help

Listar comandos disponibles:

$ composer list

Obtener información de Composer:

$ composer about

Inicializa un nuevo proyecto con un archivo composer.json :

$ composer init

Instala un paquete y lo añade a composer.json :

$ composer require [paquete]

Ejemplo:

$ composer require monolog/monolog

Instala todas las dependencias listadas en composer.json :

$ composer install

Actualiza las dependencias a sus versiones más recientes compatibles :

$ composer update

Desinstala un paquete y lo elimina de composer.json :

$ composer remove [paquete]

Ejemplo:

$ composer remove monolog/monolog

Regenera el archivo de autoloading (vendor/autoload.php):

$ composer dump-autoload

Diagnosticar el sistema para identificar errores comunes:

$ composer diagnose

También es usado para crear proyectos. Veamos un ejemplo de como crear un proyecto Symfony:

$ composer create-project symfony/skeleton:"7.3.x-dev" miproyecto

Esto nos creará un proyecto Symfony, para ejecutar la aplicación debemos ejecutar este comando:

$ symfony server:start

Abrimos el navegador en la dirección: http://localhost:8000/

Continuaremos con esta serie sobre PHP y sus herramientas.

Enlaces:

https://getcomposer.org
https://www.codementor.io/@jadjoubran/php-tutorial-getting-started-with-composer-8sbn6fb6t

Un framework web ligero para PHP: CodeIgniter

Según el sitio oficial:

CodeIgniter es un potente framework PHP de tamaño muy reducido, creado para desarrolladores que necesitan un conjunto de herramientas simple y elegante para crear aplicaciones web con todas las funciones.

Características:

• Ligero: footprint pequeño (~2MB). 
• MVC: soporta el patrón Modelo-Vista-Controlador. 
• Fácil configuración: mínima configuración inicial. 
• Rendimiento: optimizado para alta velocidad. 
• Seguridad: incluye herramientas para proteger contra CSRF, XSS, y validación de datos. 
•  Documentación clara: guías detalladas y comunidad activa. 
•  Flexibilidad: no impone estructuras rígidas, compatible con PHP 7.4+.

Como ya es habitual en este blog crearemos un sencillo ejemplo usando ahora este micro framework.

Usaremos Composer para crear el proyecto.

Creando un proyecto con CodeIgniter(y Composer)

Creamos el proyecto:

$ composer create-project codeigniter4/appstarter hola-mundo

Nos ubicamos en el directorio creado:

$ cd hola-mundo

Copiamos el archivo env a .env

$ cp env .env

Editamos el archivo .env y descomentamos y ajustamos la variable app.baseURL para que quede de la siguiente manera:

app.baseURL = 'http://localhost:8080'

Ejecutamos la aplicación:

$ php spark serve

Abrimos el navegador en la dirección:

http://localhost:8080

¡Hemos creado nuestra primera aplicación usando CodeIgniter y Compose!

En algunos casos deberás editar el archivo php.ini y descomentar extension=intl (quitando el ;) :

extension=intl

Ejecutar este comando e iniciar de nuevo el server:

$ compose install
$ php spark serve

Enlaces:

https://www.codeigniter.com/

Conociendo Laravel: un framework para PHP

Laravel es un framework de PHP para desarrollar aplicaciones web, conocido por su sintaxis elegante, herramientas integradas y enfoque en la simplicidad y robustez. Facilita tareas como autenticación, enrutamiento, sesiones y más.

Si ya contamos con PHP y Composer instalados podemos crear un proyecto de la siguiente forma:

$ composer global require laravel/installer

Creamos un directorio y nos ubicamos en este:

$ mkdir proyecto
$ cd proyecto

Verificamos instalación:

$ laravel  --version

Creamos el proyecto:

$ laravel  new generador

Esto nos mostrará un prompt, elegiremos todo por default. Si todo va bien, se generará nuestro proyecto.

Nos ubicamos en el directorio creado (generador):

$ cd generador

Instalamos las dependencias y ejecutamos la aplicación:

$ npm install && npm run build
$ composer run dev

Si todo va bien, abriremos el navegador en la dirección:

http://localhost:5173/

¡Hemos creado nuestra primera aplicación con Laravel!

Enlaces:

https://laravel.com/

Slim framework: un micro framework para PHP

Slim es un micro framework PHP que le ayuda a escribir rápidamente aplicaciones web y API simples pero potentes.

Requisitos:

• Si no se tiene PHP instalado, instalarlo. 
• Si no se tiene Composer, instalarlo.

PHP:

https://www.php.net/downloads.php

Composer:

https://getcomposer.org/download/

Nota: Durante la instalación se te pedirá un proxy. Si no lo tienes, omite el paso y continua. También requerirás reiniciar tu máquina.

Instalando Slim Framework

Comprobamos la instalación de PHP y Composer:

$ php --version

$ composer --version

Creamos un directorio, nos posicionamos sobre este y generamos el proyecto:

$ mkdir proyecto-slim
$ cd proyecto-slim
$ composer create-project slim/slim-skeleton generator

Una vez generado, nos ubicamos en el directorio creado:

$ cd generator

index.php

Ejecutamos el proyecto:

$ php -S localhost:8081 -t public

¡Hemos creado nuestro primer proyecto con Slim Framework!

Hay otra forma de instalar y crear un proyecto. Debemos crear un directorio y ubicarnos en el.

$ mkdir proyecto
$ cd proyecto

Instalamos lo necesario para trabajar con Slim Framework:

$ composer require slim/slim
$ composer require slim/psr7

Se creará un directorio vendor y dos archivos (composer.json y composer.lock).

Verificamos el archivo JSON (vendor/composer.json):

{
    "require": {
        "slim/slim": "^4.0",
        "slim/psr7": "^1.0"
    }
}

Creamos un archivo index.php

<?php
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

require __DIR__ . '/vendor/autoload.php';

$app = AppFactory::create();

$app->get('/', function (Request $request, Response $response, array $args) {
    $response->getBody()->write("¡Hola, Slim Framework!");
    return $response;
});

$app->run();

Ejecutamos la aplicación:

$ php -S localhost:8081

Tendremos ejecutandose nuestra aplicación en la dirección:

http://localhost:8081/

Algunas impresiones:

• Para ser un "micro" framework se genera todo un proyecto con muchos directorios y archivos "innecesarios". 
• Habrá que realizar un escudriñamiento más a fondo para ver cuales son sus puntos fuertes y de donde flaquea.

Enlaces:

https://www.slimframework.com/
https://getcomposer.org/download/

Un vistazo a Apache Struts Framework

Apache Struts es un framework MVC gratuito y de código abierto para crear aplicaciones web Java elegantes y modernas.

Prioriza las convenciones sobre la configuración, es extensible mediante una arquitectura de plugins e incluye plugins compatibles con REST, AJAX y JSON.

Es utilizado para desarrollar aplicaciones web basadas en la arquitectura MVC (Modelo-Vista-Controlador).

Struts fue muy popular antes de la llegada de Spring Framework y sobre todo de Spring Boot. Sin embargo, debido a su gran rendimiento aún es usado en muchas empresas.

Requerimientos:

• JDK 8 o superior. 
• Apache Maven 3.8.6 o superior. 
• Tener nociones de Java y JSP.
• Se puede usar un IDE como Eclipse, Visual Studio Code o cualquier otro.
• Sirve de mucho conocer algo de Spring Boot.

Nosotros usaremos la terminal para crear y ejecutar el proyecto.

Creando nuestra primera aplicación con Apache Struts2

Vamos a crear una sencilla aplicación de "Hola, mundo".

Creamos el proyecto Apache Struts2 con Maven y nos ubicamos en el directorio creado:

$ mvn archetype:generate -B 
  -DgroupId=org.cursomaven 
  -DartifactId=auditor -DarchetypeGroupId=org.apache.struts  
  -DarchetypeArtifactId=struts2-archetype-blank 
  -DinteractiveMode=false
$ cd auditor 

Abrimos el proyecto. Tendrá más o menos está estructura de carpetas:

auditor/ 
   pom.xml
   src/
     main/
       webapp/
          index.html
          WEB-INF/
           example/
           web.xml 
       resources/
          example.xml
          log4j2.xml
          struts.xml
       java/

Debemos eliminar los archivos innecesarios como: Login.java, HelloWorld.java, ExampleSupport.java. Esto para que solo quede una nueva clase llamada HolaMundo.java. Esto en la carpeta de java/org/cursomaven/example:

package org.cursomaven.example;


import com.opensymphony.xwork2.ActionSupport;


public class HolaMundo extends ActionSupport{

    public String execute() throws Exception {
        setMessage(getText(MESSAGE));
        return SUCCESS;
    }

    public static final String MESSAGE = "HolaMundo.message";
    
   
    private String message;

   
    public String getMessage() {
        return message;
    }

  
    public void setMessage(String message) {
        this.message = message;
    }
}

Tambien eliminaremos las páginas JSP del directorio webapp/WEB-INF/example. Esto para que solo quede una página JSP llamada HolaMundo.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
    <title><s:text name="HolaMundo.message"/></title>
</head>

<body>
<h2><s:property value="message"/></h2>

</body>
</html>

Editamos los archivos: package.properties y example.xml. Los cuales se encuentran en los directorios src/main/resources y src/main/resources/org/cursomaven/example

package.properties

server.port= 8081
HolaMundo.message =Bienvenido a ApacheStruts2.

example.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">
<!-- 
  - This file is included by the struts.xml file as an example
  - of how to break up the configuration file into multiple files.
-->
<struts>
    <package name="example" namespace="/example" extends="struts-default">

        <default-action-ref name="HolaMundo" />

        <action name="HolaMundo" class="org.cursomaven.example.HolaMundo">
            <result>/WEB-INF/example/HolaMundo.jsp</result>
        </action>


        <!-- Add additional "example" package actions here. -->

    </package>
</struts>

Tambien editamos el archivo XML struts.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.enable.DynamicMethodInvocation" value="false"/>
    <constant name="struts.devMode" value="true"/>

    <include file="example.xml"/>

    <package name="default" namespace="/" extends="struts-default">

        <default-action-ref name="index"/>

        <action name="index">
            <result type="redirectAction">
                <param name="actionName">HolaMundo</param>
                <param name="namespace">/example</param>
            </result>
        </action>

    </package>

    <!-- Add addition packages and configuration here. -->
</struts>

Construimos con Maven:

$ mvn clean install -X

Ejecutamos con el servidor emembido Jetty:

$ mvn jetty:run -Djetty.port=8081

Abrimos el navegador en la dirección:

http://localhost:8081/auditor/example/HolaMundo

¡Hemos creado nuestra primera aplicación con Apache Struts2!

Continuaremos con esta serie sobre Frameworks web en próximas entregas.

Enlaces:

https://struts.apache.org/index.html

Dancer2: un framework web para Perl

Dancer2 es el framework web ligero de nueva generación para Perl. Esta herramienta proporciona una interfaz CLI atractiva y fácilmente extensible.

Veremos cómo instalarlo y crear un ejemplo sencillo.

Instalación de Dancer2

Abre una terminal y escribe esto:

$ cpan

Entrarás a CPAN, ahora instalamos Dancer2:

cpan> i Dancer2

Comenzará el proceso de descarga e instalación. Esperamos un poco (pueden ser algunos minutos).

Cuando finalice verificamos la instalación:

$ dancer2 version

Obtener ayuda:

$ dancer2 --help

Para crear un proyecto:

$ dancer2 gen -a MyWeb::App

Esto te creará un proyecto web con Dancer2.

Nos ubicamos en el directorio creado y ejecutamos la aplicación:

$ cd MyWeb-App
$ plackup -r bin/app.psgi

Abrimos un navegador en la siguiente dirección:

https://0.0.0.0:5000

Ahora crearemos un sencillo programa web sin la necesidad de crear un proyecto completo.

Un Hola, mundo con Dancer2

Creamos un sencillo script para el clásico "Hola, mundo".

dancr.pl

#!/usr/bin/env perl
use Dancer2;
get '/' => sub {
    return 'Hola, mundo con Dancer2';
};
start;

Ejecutamos el script:

$ perl dancr.pl

Abrimos un navegador en la dirección:

http://localhost:3000/

¡Hemos creado nuestra primera aplicación con Dancer2!

continuaremos con este tema en próximas entregas.

Enlaces:

https://perldancer.org/
https://medium.com/lets-fill-the-gap/dancer2-introduction-and-installation-8444079355fd