Programando en C# no. 14: gRPC con .NET

 

En el post pasado vimos cómo crear un sencillo proyecto tipo cliente-servidor con .Net y gRPC.

Continuando con el tema vamos a recordar un poco.

• gRPC es una tecnología moderna ideal para microservicios de alto rendimiento, escalables y seguros. 
• Protobuff es el mecanismo de serialización que usa gRPC. 
• HTTP/2 como protocolo de comunicación, el cual prioriza solicitudes, permite la comprensión de encabezados, multiplexación (múltiples llamadas simultáneas) y tiene mayor seguridad.

Creando un proyecto cliente-servidor en .Net (C#)

Crearemos un proyecto cliente-servidor en el cual el cliente mandará un número entero y el servidor evaluará si es mayor o no a 100.

1. Creamos nuestro proyecto servidor:

$ dotnet new grpc -o GrpcServer

2. Entramos al directorio creado y agregamos los siguientes Nuget:

Por línea de comandos:

$ dotnet add package Grpc.AspNetCore
$ dotnet add package Google.Protobuf
$ dotnet add package Grpc.Tools

Desde el archivo ``GrpcServer.csproj``:

<ItemGroup>
  <PackageReference Include="Grpc.AspNetCore" Version="2.60.0" />
  <PackageReference Include="Google.Protobuf" Version="3.25.0" />
  <PackageReference Include="Grpc.Tools" Version="2.60.0" PrivateAssets="All" />
</ItemGroup>

Ejecutar esto para descargar paquetes:

$ dotnet restore

3. Crearemos un archivo *.proto, el cual tendrá el un servicio llamado Validar y un método llamado EsMayorQue100 que recibirá un NumeroRequest y devolverá un NumeroResponse.

Protos\validar.proto

syntax = "proto3";

option csharp_namespace = "GrpcDemo";

package validar;

service Validar {
  rpc EsMayorQue100 (NumeroRequest) returns (NumeroResponse);
}

message NumeroRequest {
  int32 valor = 1;
}

message NumeroResponse {
  bool es_mayor = 1;
}

4. Editamos el archivo ``GrpcServer.csproj`` para agregar el archivo *.proto:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <!--<Protobuf Include="Protos\greet.proto" GrpcServices="Server" />-->
	<Protobuf Include="Protos\validar.proto" GrpcServices="Server" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Google.Protobuf" Version="3.34.1" />
    <PackageReference Include="Grpc.AspNetCore" Version="2.76.0" />
    <PackageReference Include="Grpc.Tools" Version="2.78.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
  </ItemGroup>

</Project>

5. Creamos el servicio:

ValidarService.cs

using GrpcDemo;
using Grpc.Core;

public class ValidarService : Validar.ValidarBase
{
    public override Task<NumeroResponse> EsMayorQue100(NumeroRequest request, ServerCallContext context)
    {
        bool resultado = request.Valor > 100;
        return Task.FromResult(new NumeroResponse { EsMayor = resultado });
    }
}

6. El programa principal del servidor será el siguiente:

Program.cs

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddGrpc();
var app = builder.Build();
app.MapGrpcService<ValidarService>();
app.Run();

Ahora vamos por el proyecto cliente.

7. Creamos el proyecto:

$ dotnet new console -o GrpcClient

8. Nos ubicamos en el directorio creado. Y configuramos el archivo ``GrpcClient.csproj``:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  
  
  
  <ItemGroup>
  <Protobuf Include="..\GrpcServer\Protos\validar.proto" GrpcServices="Client" />
</ItemGroup>
<ItemGroup>
  <PackageReference Include="Grpc.Net.Client" Version="2.60.0" />
  <PackageReference Include="Google.Protobuf" Version="3.34.1" />
  <PackageReference Include="Grpc.Tools" Version="2.78.0" PrivateAssets="All" />
</ItemGroup>


</Project>

Ejecutar esto para descargar paquetes:

$ dotnet restore

9. El programa principal del cliente será este:

Program.cs

using Grpc.Net.Client;
using GrpcDemo;

class Program
{
    static async Task Main(string[] args)
    {
        using var channel = GrpcChannel.ForAddress("http://localhost:5203");
        var client = new Validar.ValidarClient(channel);

        Console.Write("Ingrese un número: ");
        int numero = int.Parse(Console.ReadLine());

        var response = await client.EsMayorQue100Async(new NumeroRequest { Valor = numero });
        Console.WriteLine($"¿Es mayor a 100? {response.EsMayor}");
    }
}

10. Ejecutamos el servidor:

$ dotnet run --project GrpcServer

11. Ejecutamos el cliente:

$ dotnet run --project GrpcClient

Si todo va bien veremos esto en el servidor:

info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5203
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]

Del lado del cliente:

Ingrese un número: 23
¿Es mayor a 100? False

Podemos modificar el programa cliente de tal manera que solicite salir o continuar.

using Grpc.Net.Client;
using GrpcDemo;

class Program
{
    static async Task Main(string[] args)
    {
        using var channel = GrpcChannel.ForAddress("http://localhost:5203");
        var client = new Validar.ValidarClient(channel);

        string continuar;
        do
        {
            Console.Write("Ingrese un número: ");
            int numero = int.Parse(Console.ReadLine());

            var response = await client.EsMayorQue100Async(new NumeroRequest { Valor = numero });
            Console.WriteLine($"¿Es mayor a 100? {response.EsMayor}");
            Console.WriteLine();

            Console.Write("¿Desea continuar [s-n]? ");
            continuar = Console.ReadLine()?.Trim().ToLower();
            Console.WriteLine();

        } while (continuar == "s");

        Console.WriteLine("Adios");
    }
}

Salida:

Ingrese un número: 23
¿Es mayor a 100? False

¿Desea continuar [s-n]? s 
Ingrese un número: 200
¿Es mayor a 100? True 

¿Desea continuar [s-n]? n 
Adios

¡Hemos creado un proyecto cliente-servidor con gRPC y .NET!

Continuaremos con este tema en próximas entregas.

Enlaces:

https://codemonkeyjunior.blogspot.com/2026/02/grpc-una-alternativa-para-servicios-de.html
https://alquimistadecodigo.blogspot.com/2026/03/grpc-con-go.html
https://alquimistadecodigo.blogspot.com/2026/03/grpc-con-python.html

Una comparativa entre C# y Beef

Como vimos en una entrega anterior, Beef es un lenguaje de programación similar a C#. Con la peculiaridad que al instalarlo nos provee de su propio IDE.

Observemos un ejemplo. El clásico programa "Hola, mundo" escrito en Beef(lang):

HolaMundo.bf

using System;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Hola, mundo en Beef!");
    }
}

Cualquier despistado diría que está escrito en C#, pero no nos confiemos en lo que vemos. Ahora observemos el mismo programa escrito en C#.

Program.cs

using System;

class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Hola, mundo en C#!");
    }
}

La diferencia entre un programa y el otro es casi nula. Para hacer una comparativa entre estos dos lenguajes nos enfocaremos en:

1. Paradigma que usan.
2. Características más importantes.
3. Tipos de datos que manejan.
4. Sus estructuras de control.
5. Funciones y procedimientos.
6. Estructuras de datos.
7. Manejo de errores.

Aquí podemos observar el IDE de Beef.

Comparativa entre C# y Beef

1. Paradigma.

• Ambos lenguajes son multiparadigma. 
• Lo que sugiere que puedes crear programas con paradigma estructurado, funcional y orientado a objetos.

2. Principales características.

De C#:

• Orientado a Objetos (POO). 
• Seguridad de Tipos (Strongly Typed).
• Multiplataforma.
• Gestión Automática de Memoria.
• Orientado a Componentes.
• Integración con .NET. 
• Sintaxis Moderna y Limpia. 
• Interoperabilidad. 
• Programación Asíncrona. 
• LINQ (Language Integrated Query).

De Beef:

• Sintaxis y Estructura. 
• Alto Rendimiento. 
• Productividad del Desarrollador. 
• Gestión de Memoria. 
• Características Modernas. 
• Seguridad en Depuración. 
• Compilación e IDE.

3. Tipos de datos.

Observemos una tabla comparativa.

Categoría	C#	Beef
Booleano	bool	bool
Enteros con signo	sbyte, short, int, long, nint	int8, int16, int32, int64, int
Enteros sin signo	byte, ushort, uint, ulong, nuint	uint8, uint16, uint32, uint64, uint
Punto flotante	float, double, decimal	float, double
Caracteres	char	char8, char16, char32
Cadenas	string	No hay tipo nativo, se usan arrays de char*
Referencia / Objeto	object, dynamic, delegate	structs (colecciones definidas por el usuario)
Especiales	void, nullable types (ej. int?)	void

C# es más rico que Beef en tipos de referencia y abstracciones de alto nivel.

Categoría	C#	Beef
Booleano	// C# bool flag = true;	// Beef bool flag = true;
Enteros con signo	// C# int x = -42; long y = 123456789;	// Beef int32 x = -42; int64 y = 123456789;
Enteros sin signo	// C# uint a = 42; byte b = 255;	// Beef uint32 a = 42; uint8 b = 255;
Punto flotante	// C# float pi = 3.14f; double e = 2.718; decimal money = 99.99m;	// Beef float pi = 3.14f; double e = 2.718;
Caracteres	// C# char letter = 'A';	// Beef char16 letter = 'A';
Cadenas	// C# string name = "Carlos";	// Beef char8* name = "Carlos";
Referencia / Objeto	// C# object obj = new object(); delegate void MyDelegate();	// Beef struct Point { int x; int y; } Point p = .(10, 20);
Especiales	// C# void DoSomething() { } int? maybe = null;	// Beef void DoSomething() { }

4. Estructuras de control.

Observemos la siguiente tabla comparativa entre C# y Beef.

Estructura	C#	Beef
Condicional if/else	// C# if (x > 10) { Console.WriteLine("Mayor a 10"); } else { Console.WriteLine("Menor o igual a 10"); }	// Beef if (x > 10) { Console.WriteLine("Mayor a 10"); } else { Console.WriteLine("Menor o igual a 10"); }
switch / match	// C# switch (day) { case 1: Console.WriteLine("Lunes"); break; case 2: Console.WriteLine("Martes"); break; default: Console.WriteLine("Otro día"); break; }	// Beef switch (day) { case 1: Console.WriteLine("Lunes"); break; case 2: Console.WriteLine("Martes"); break; default: Console.WriteLine("Otro día"); break; }
Bucle for	// C# for (int i = 0; i < 5; i++) { Console.WriteLine(i); }	// Beef for (int i = 0; i < 5; i++) { Console.WriteLine(i); }
Bucle while	// C# while (x < 10) { x++; }	// Beef while (x < 10) { x++; }
Bucle do-while	// C# do { x++; } while (x < 10);	// Beef do { x++; } while (x < 10);
foreach	// C# foreach (var item in list) { Console.WriteLine(item); }	// Beef for (var item in list) { Console.WriteLine(item); }
break / continue	// C# for (int i = 0; i < 10; i++) { if (i == 5) break; if (i % 2 == 0) continue; Console.WriteLine(i); }	// Beef for (int i = 0; i < 10; i++) { if (i == 5) break; if (i % 2 == 0) continue; Console.WriteLine(i); }

La sintaxis de estructuras de control en Beef es prácticamente idéntica a la de C#, lo que facilita la transición entre ambos lenguajes.

La diferencia más notable está en el uso de foreach : en C# existe como palabra reservada, mientras que en Beef se usa un for con iteración directa sobre colecciones.

Ambos lenguajes soportan break y continue dentro de bucles, así como switch con casos y default.

5. Funciones y procedimientos.

Concepto	C#	Beef
Función simple	// C# int Sumar(int a, int b) { return a + b; }	// Beef int Sumar(int a, int b) { return a + b; }
Procedimiento (sin retorno)	// C# void MostrarMensaje(string msg) { Console.WriteLine(msg); }	// Beef void MostrarMensaje(String msg) { Console.WriteLine(msg); }
Parámetros por referencia	// C# void Incrementar(ref int x) { x++; }	// Beef void Incrementar(ref int x) { x++; }
Parámetros opcionales	// C# void Saludar(string nombre = "Invitado") { Console.WriteLine($"Hola {nombre}"); }	// Beef void Saludar(String nombre = "Invitado") { Console.WriteLine("Hola " + nombre); }
Funciones anónimas / lambdas	// C# Func cuadrado = x => x * x;	// Beef function int(int) cuadrado = (x) => x * x;
Funciones dentro de estructuras/clases	// C# class Persona { public void Hablar() { Console.WriteLine("Hola!"); } }	// Beef struct Persona { public void Hablar() { Console.WriteLine("Hola!"); } }

6. Estructuras de datos.

Observemos la siguiente tabla comparativa.

Estructura	C#	Beef
Arreglos	// C# int[] numeros = {1, 2, 3};	// Beef int[] numeros = .(1, 2, 3);
Listas dinámicas	// C# List lista = new List(); lista.Add(10);	// Beef List lista = new List(); lista.Add(10);
Diccionarios / Mapas	// C# Dictionary edades = new Dictionary(); edades["Ana"] = 25;	// Beef Dictionary edades = new Dictionary(); edades["Ana"] = 25;
Conjuntos	// C# HashSet conjunto = new HashSet(); conjunto.Add(5);	// Beef HashSet conjunto = new HashSet(); conjunto.Add(5);
Pilas (Stack)	// C# Stack pila = new Stack(); pila.Push(1);	// Beef Stack pila = new Stack(); pila.Push(1);
Colas (Queue)	// C# Queue cola = new Queue(); cola.Enqueue(2);	// Beef Queue cola = new Queue(); cola.Enqueue(2);
Estructuras definidas por el usuario	// C# struct Punto { public int X; public int Y; }	// Beef struct Punto { public int X; public int Y; }

7. Manejo de errores.

Observemos la siguiente tabla comparativa.

Concepto	C#	Beef
Bloque básico try-catch	// C# try { int x = int.Parse("abc"); } catch (FormatException ex) { Console.WriteLine("Error de formato: " + ex.Message); }	// Beef try { int x = int.Parse("abc"); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); }
try-catch-finally	// C# try { var file = File.Open("data.txt", FileMode.Open); } catch (IOException ex) { Console.WriteLine("Error de E/S: " + ex.Message); } finally { Console.WriteLine("Liberando recursos..."); }	// Beef try { var file = File.Open("data.txt", FileMode.Open); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } finally { Console.WriteLine("Liberando recursos..."); }
Lanzar excepciones	// C# throw new InvalidOperationException("Operación inválida");	// Beef throw new Exception("Operación inválida");
Excepciones personalizadas	// C# class MiExcepcion : Exception { public MiExcepcion(string msg) : base(msg) { } }	// Beef struct MiExcepcion : Exception { public this(String msg) : base(msg) { } }

Ejemplo. Crear un procedimiento donde se calcule el nuevo salario de una persona. Si el empleado es casado, tiene un salario menor a $30000.00 se le de un aumento del 0.05, en caso contrario solo será del 0.01.

En Beef:

        static void CalculoSalario()
	{
	        Console.WriteLine("\t [ Calculando nuevo salario en Beef  ]");
	        int edad = 0;
		String nombre = scope String();
		String edo_civil = scope String();
		double salario_bruto = 0;
		double salario_neto = 0;

		Console.WriteLine("Introduce tu nombre:");
		Console.ReadLine(nombre); // escribe en el buffer 'nombre'

		Console.WriteLine("Introduce tu edad:");
		String edadStr = scope String();
		Console.ReadLine(edadStr);
		edad = int.Parse(edadStr);

		Console.WriteLine("Introduce tu estado civil:");
		Console.ReadLine(edo_civil);

		Console.WriteLine("Introduce tu salario bruto:");
		String salarioStr = scope String();
		Console.ReadLine(salarioStr);
		salario_bruto = double.Parse(salarioStr);

		if (salario_bruto < 30000)
		{
		    if (edo_civil == "casado")
		    {
		        salario_bruto += salario_bruto * 0.05;
		    }
		    else
		    {
		        salario_bruto += salario_bruto * 0.01;
		    }

		    if (edad > 40)
		    {
		        salario_bruto += salario_bruto * 0.05;
		    }
		    else
		    {
		        salario_bruto += salario_bruto * 0.01;
		    }
		}

		salario_neto = salario_bruto;
		Console.WriteLine("Salario neto: {0}", salario_neto);
	}

En C#:

public static void CalculoSalario()
    {
        Console.WriteLine("\t [ Calculando nuevo salario en C# ]");
        int edad = 0;
        string nombre = "";
        string edo_civil = "";
        double salario_bruto = 0;
        double salario_neto = 0;

        Console.WriteLine("Introduce tu nombre:");
        nombre = Console.ReadLine();

        Console.WriteLine("Introduce tu edad:");
        string edadStr = Console.ReadLine();
        edad = int.Parse(edadStr);

        Console.WriteLine("Introduce tu estado civil:");
        edo_civil = Console.ReadLine();

        Console.WriteLine("Introduce tu salario bruto:");
        string salarioStr = Console.ReadLine();
        salario_bruto = double.Parse(salarioStr);

        if (salario_bruto < 30000)
        {
            if (edo_civil == "casado")
            {
                salario_bruto += salario_bruto * 0.05;
            }
            else
            {
                salario_bruto += salario_bruto * 0.01;
            }

            if (edad > 40)
            {
                salario_bruto += salario_bruto * 0.05;
            }
            else
            {
                salario_bruto += salario_bruto * 0.01;
            }
        }

        salario_neto = salario_bruto;
        Console.WriteLine("Salario neto: {0}", salario_neto);
      
    }

Salida:

         [ Calculando nuevo salario en C# ]
Introduce tu nombre:
Thomas Muller
Introduce tu edad:
34
Introduce tu estado civil:
casado
Introduce tu salario bruto:
29000
Salario neto: 30754.5

Como hemos visto, Beef es un lenguaje de programación que toma inspiración del lenguaje C#. Tanto su sitaxis como tipos de datos. Paradigma y esencia.

Sin embargo, C# es mucho más rico, más completo. Si tuvieras que elegir un lenguaje para crear un nuevo proyecto, C# sería mejor opción, pero Beef no se queda atrás, apenas comienza.

Continuaremos con esta serie de lenguajes de programación.

Enlaces:

https://www.beeflang.org/
https://dotnet.microsoft.com/es-es/languages/csharp
https://codemonkeyjunior.blogspot.com/2026/02/beef-y-c3-dos-lenguajes-de-programacion.html

WebSockets con Mojolicious

En esta ocasión veremos un ejemplo sencillo de WebSockets con Mojolicious.

Como vimos en entregas pasadas:

• Mojolicious un framework para Perl
• Creando una aplicación IMC con Mojolicious

Mojolicious es un framework para Perl que es similar a Dancer2, pero más completo. Además nos permite trabajar con WebSockets, que es el tema que vamos a ver. Como vimos en una entrega anterior, los WebSockets son un protocolo que permite comunicación bidireccional en tiempo real entre cliente y servidor, a diferencia de HTTP que funciona en modo solicitud-respuesta.

Observemos el siguiente código.

web_socket.pl

use Mojolicious::Lite -signatures;

# Renderiza la plantilla "index.html.ep" desde la seccion 
get '/' => sub ($c) {
  $c->render(template => 'index');
};

# Servicio WebSocket usado por la plantilla para extraer el título del sitio web
websocket '/title' => sub ($c) {
  $c->on(message => sub ($c, $msg) {
    my $title = $c->ua->get($msg)->result->dom->at('title')->text;
    $c->send($title);
  });
};

app->start;
__DATA__

@@ index.html.ep
% my $url = url_for 'title';
<script>
  const ws = new WebSocket('<%= $url->to_abs %>');
  ws.onmessage = function (event) { document.body.innerHTML += event.data };
  ws.onopen    = function (event) { ws.send('https://www.wikipedia.org') };
</script>

En este programa Perl hacemos uso del Framework Mojolicious. Donde se mostrará una sencilla página HTML que obtendrá el nombre del sitio web definido dentro de la función ws.send("web_page"). En este caso obtendremos el título de la página de Wikipedia.

Lo ejecutaremos de la siguiente manera:

$ perl web_socket.pl daemon -l http://*:8080

Abrimos un navegador en la ruta: http://127.0.0.1:8080/

También podemos ejecutar de este modo:

$ morbo web_socket.pl

En este caso, abrimos un navegador en la ruta: http://127.0.0.1:3000/

Salida:

[2026-03-16 15:55:15.56279] [27716] [info] Listening at "http://*:8080"
Web application available at http://127.0.0.1:8080
[2026-03-16 15:55:50.81445] [27716] [trace] [1ODKO9_D-nZZ] GET "/"
[2026-03-16 15:55:50.81945] [27716] [trace] [1ODKO9_D-nZZ] Routing to a callback
[2026-03-16 15:55:50.82339] [27716] [trace] [1ODKO9_D-nZZ] Rendering template "index.html.ep" from DATA section
[2026-03-16 15:55:50.82998] [27716] [trace] [1ODKO9_D-nZZ] 200 OK (0.015422s, 64.842/s)
[2026-03-16 15:55:51.40533] [27716] [trace] [ThnOL6K5Pt-k] GET "/title"
[2026-03-16 15:55:51.40978] [27716] [trace] [ThnOL6K5Pt-k] Routing to a callback
[2026-03-16 15:55:51.41264] [27716] [trace] [ThnOL6K5Pt-k] 101 Switching Protocols (0.00707s, 141.443/s)

En la página se verá el nombre de "Wikipedia".

Hagamos algo más complicado. Crear una aplicación que reciba peticiones y responda dinámicamente. Esto con ayuda de los WebSockets.

web_sockets.pl

use Mojolicious::Lite -signatures;

# Ruta normal para probar
get '/' => sub ($c) {
  $c->render(template => 'index');
};

# Endpoint WebSocket
websocket '/echo' => sub ($c) {
  $c->on(message => sub ($c, $msg) {
    # Responde con el mismo mensaje recibido
    $c->send("Servidor recibió: $msg");
  });
};

app->start;

__DATA__

@@ index.html.ep
<!DOCTYPE html>
<html>
  <head><title>Codemonkey Junior WebSocket con Mojolicious</title></head>
  <body>
    <h1>WebSocket con Mojolicious</h1>
    <script>
      // Conectar al servidor WebSocket
      const ws = new WebSocket('<%= url_for("echo")->to_abs %>');
      
      ws.onopen = function() {
        ws.send("¡Hola desde el cliente!");
      };
      
      ws.onmessage = function(event) {
        document.body.innerHTML += "<p>" + event.data + "</p>";
      };
    </script>
  </body>
</html>

Ejecutamos:

$ morbo web_sockets.pl

Abrimos un navegador en la ruta: http://127.0.0.1:3000/

Salida:

Web application available at http://127.0.0.1:3000
[2026-03-16 16:16:20.73121] [-15804] [trace] [2NKo74iWOXU_] GET "/"
[2026-03-16 16:16:20.73267] [-15804] [trace] [2NKo74iWOXU_] Routing to a callback
[2026-03-16 16:16:20.73900] [-15804] [trace] [2NKo74iWOXU_] Rendering template "index.html.ep" from DATA section
[2026-03-16 16:16:20.74582] [-15804] [trace] [2NKo74iWOXU_] 200 OK (0.014579s, 68.592/s)
[2026-03-16 16:16:21.61504] [-15804] [trace] [u4UBFpSvNxLo] GET "/echo"
[2026-03-16 16:16:21.61669] [-15804] [trace] [u4UBFpSvNxLo] Routing to a callback
[2026-03-16 16:16:21.61922] [-15804] [trace] [u4UBFpSvNxLo] 101 Switching Protocols (0.004105s, 243.605/s)

Se abrirá una página web con el mensaje:

WebSocket con Mojolicious
Servidor recibió: ¡Hola desde el cliente!

Mojolicious permite construir aplicaciones más complejas: broadcasting a múltiples clientes, integración con Minion para tareas en segundo plano, o extracción de datos en tiempo real desde APIs externas.

Estos son solo ejemplos básicos de uso de WebSockets y Mojolicious.

En próximas entregas veremos esto más a fondo.

Enlaces:

https://mojolicious.org/
https://mojolicious.io/