sábado, 18 de abril de 2026

Hablemos de Micronaut y Helidon

En la entrega anterior hablamos de Quarkus (Supersonic Subatomic Java), el cual es un framework cuya filosofía es trabajar en Cloud y forma de trabajo nos recuerda a Spring Boot (sin decir que los "copia").

Ahora hablaremos de Micronaut y Helidon.

Micronaut es un framework moderno, basado en JVM y de pila completa para la creación de aplicaciones modulares, de microservicios y sin servidor, fácilmente comprobables.

Para instalarlo hay varias formas: https://micronaut.io/download/

Helidon es una colección de bibliotecas Java para escribir microservicios que se ejecutan en un núcleo web rápido impulsado por Netty. Es pequeño, rápido y divertido de usar.

Tiene dos versiones:

  • Helidon SE. 
  • Helidon MP.

Existen varias formas de instalarlo, pero se recomienda instalar la herramienta CLI: https://helidon.io/docs/v4/about/cli

Ambos frameworks comparten similitudes y diferencias entre otras herramientas como Quarkus/RESTEasy y Spring Boot.

Observemos la siguiente tabla comparativa:

Característica Helidon Micronaut
Origen Desarrollado por Oracle Desarrollado por Object Computing, Inc. (OCI)
Arquitectura Dos sabores: Helidon SE (funcional, ligero) y Helidon MP (basado en MicroProfile) Diseñado desde cero para microservicios, con fuerte soporte a inyección de dependencias y AOP
Modelo de programación Funcional (SE) y MicroProfile (MP) Basado en anotaciones, DI y configuración simplificada
Soporte Cloud-Native Kubernetes-native, integración con GraalVM Optimizado para GraalVM y entornos serverless
Tiempo de arranque Muy rápido, especialmente con Helidon SE Extremadamente rápido, diseñado para aplicaciones serverless
Consumo de memoria Bajo, ideal para microservicios en contenedores Bajo, con optimizaciones para entornos de alta densidad
Compatibilidad Java EE, MicroProfile, integración con APIs estándar Compatibilidad con Spring, soporte para múltiples lenguajes JVM
Ventajas principales - Simplicidad con Helidon SE
- Estándares MicroProfile
- Integración nativa con Oracle Cloud
- Arranque ultrarrápido
- Bajo consumo de memoria
- Ecosistema activo y flexible
Similitudes - Ambos soportan GraalVM
- Orientados a microservicios cloud-native
- Bajo consumo de recursos
- Integración con Kubernetes y contenedores

Empezando con Micronaut

Con Chocolatey:

$ choco install micronaut

Con SDKMAN!:

$ sdk update
$ sdk install micronaut

Verificamos la instalación:

$ mn

Empezando con Helidon

Con Powershell:

$ PowerShell -Command Invoke-WebRequest -Uri "https://helidon.io/cli/latest/windows/helidon.exe" -OutFile "C:\Windows\system32\helidon.exe"

Con Linux bash:

$ curl -L -O https://helidon.io/cli/latest/linux/helidon
$ chmod +x ./helidon
$ sudo mv ./helidon /usr/local/bin/

Verificamos:

$ helidon version

Hemos instalado tanto Helidon como Micronaut.

Hola, mundo con Micronaut

1. Iniciamos un proyecto:

$ mn create-app hello-world

Nos ubicamos en el directorio creado.

2. Modificamos la clase ``HolaController.java``:

package com.inforhomex.app.controller;

import com.inforhomex.app.resource.HolaResource;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.MediaType;

/**
 * Clase controller de la aplicación.
 */
@Controller("/hola")
public class HolaController implements HolaResource{
	
    @Override
	@Get(produces = MediaType.TEXT_PLAIN)
    public String getSaludo(){
        return "¡Hola, mundo en Micronaut!";
    }
}

3. Construimos:

$ mvn clean install

4. Ejecutamos:

$ ./mvnw mn:run

Abrimos el navegador en la ruta: http://localhost:8080/hola

Salida:

¡Hola, mundo en Micronaut!

Hola, mundo con Helidon

1. Iniciamos un proyecto:

$ helidon init
$ cd holamundo-se

2. Modificamos la clase ``Main.java``, específicamente en este método:

 static void routing(HttpRouting.Builder routing) {
        routing
               .register("/greet", new GreetService())
               .get("/simple-greet", (req, res) -> res.send("Hola, mundo!")); 
    }

3. Construimos:

$ mvn clean package

4. Ejecutamos:

Abrimos el navegador en la ruta: http://localhost:8080/simple-greet

Salida:

Hola, mundo!

Continuaremos con este tema en próximas entregas.

Enlaces:


https://alquimistadecodigo.blogspot.com/2023/03/micronaut.html
https://alquimistadecodigo.blogspot.com/2025/04/helidon-instalando-el-cli.html


domingo, 12 de abril de 2026

Hablemos de Quarkus

Quarkus es un framework (creado por Red Hat) moderno de Java diseñado para optimizar aplicaciones en entornos de nube, contenedores y Kubernetes. Su principal ventaja es ofrecer tiempos de arranque ultrarrápidos y bajo consumo de memoria, lo que lo hace ideal para microservicios y arquitecturas serverless.

Diseñado para funcionar tanto en JVM tradicional como en compilaciones nativas con GraalVM. 

Compatible con librerías y estándares conocidos: Eclipse MicroProfile, Spring, RESTEasy (JAX-RS), Hibernate ORM (JPA), Apache Kafka, Infinispan, Camel, entre otros.

Su sistema de inyección de dependencias (CDI) y extensiones permite integrar fácilmente nuevas funcionalidades.

Lo podemos usar para:

  • Microservicios en Kubernetes: optimiza despliegues en contenedores con tiempos de arranque mínimos. 
  • Aplicaciones serverless: ideal para funciones que requieren ejecución rápida y eficiente. 
  • Aplicaciones reactivas y REST: soporta APIs modernas y comunicación asíncrona. 
  • Integración con bases de datos y mensajería: Hibernate, Kafka, PostgreSQL, entre otros. 
  • Desarrollo ágil: incluye un modo de desarrollo con recarga en caliente para iterar rápidamente.

Principales características:

  • Arranque ultrarrápido: aplicaciones listas en milisegundos. 
  • Consumo reducido de memoria: optimizado para entornos con recursos limitados. 
  • Compilación nativa con GraalVM: genera binarios ligeros y eficientes. 
  • Extensible: gran ecosistema de extensiones para añadir soporte a tecnologías populares. 
  • Developer Joy: herramientas integradas para mejorar la experiencia del desarrollador (live reload, CLI). 
  • Integración con la nube: pensado para Kubernetes, OpenShift y servicios cloud.

Para usar Quarkus lo puedes instalar de las siguientes formas:

Desde una terminal Linux, Mac OS, Windows (con WSL o Cygwin/MinGW):

$ curl -Ls https://sh.jbang.dev | bash -s - trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/
$ curl -Ls https://sh.jbang.dev | bash -s - app install --fresh --force quarkus@quarkusio

Con SDKMAN!:

$ sdk install quarkus

Con Powershell:

$ iex "& { $(iwr https://ps.jbang.dev) } trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/"
$ iex "& { $(iwr https://ps.jbang.dev) } app install --fresh --force quarkus@quarkusio"

Nota: También podemos crear un proyecto Quarkus usando Maven.

Verificamos la instalación:

$ quarkus --version

Emepzando con Quarkus

1. Vamos a abrir una terminal y tecleamos lo siguiente:

$ quarkus create && cd code-with-quarkus

Esto nos creará un proyecto y nos ubicará en el directorio principal.

2. Ejecutamos la aplicación:

$ quarkus dev

Si todo va bien, abrimos un navegador en la URL: http://localhost:8080/

Con esto hemos creado nuestra primera aplicación con Quarkus.

Este framework se podría considerar como el verdadero contendiente de Spring Boot dadas sus similitudes. Aunque existen otras alternativas como Helidon y Micronaut que no se quedan atrás.

En este blog ya hemos hablado de Quarkus indirectamente y vimos cómo es ideal para crear aplicaciones tipo REST.

En próximas entregas hablaremos un poco de Helidon y Micronaut.

Enlaces:

https://es.quarkus.io/
https://alquimistadecodigo.blogspot.com/2022/11/un-vistazo-quarkus-el-supersonic.html
https://code.quarkus.io/
https://alquimistadecodigo.blogspot.com/2023/01/quarkus-un-spring-boot-mejorado.html

lunes, 6 de abril de 2026

LLVM: una herramienta para crear compiladores

LLVM (Low Level Virtual Machine) es una infraestructura de compiladores que permite transformar y optimizar código de distintos lenguajes de programación. No es un compilador único, sino un conjunto de herramientas que sirven para crear compiladores, analizadores y optimizadores de código.

En este blog ya hemos hablado, burdamente, de lo que conforma un lenguaje de programación. Sin embargo, sería importante recordar algunos detalles.

Un compilador es un programa que traduce el código que escribes (por ejemplo en C, Rust o Java) a un lenguaje que la computadora entiende directamente: el código máquina. Ejemplo, tú escribes una receta en español, el compilador la traduce al "idioma" de la computadora para que pueda cocinarla.

Un analizador de código es la parte del compilador que lee y entiende tu código fuente. Verifica que lo que escribiste tenga sentido (sintaxis correcta, variables bien usadas, etc.). Es como un profesor que revisa tu redacción y te dice si las frases están bien construidas antes de publicarlas.

Un optimizador de código es una herramienta que mejora el código para que sea más rápido o consuma menos recursos. Reorganiza instrucciones, elimina pasos innecesarios y aprovecha mejor el hardware. Llanamente, el optimizador busca el camino más corto y rápido para llegar a algo.

Estos tres se relacionan de esta manera:

  • Analizador: entiende tu código y lo valida. 
  • Compilador: traduce ese código a instrucciones que la máquina entiende. 
  • Optimizador: pule esas instrucciones para que se ejecuten de la mejor manera posible.

LLVM al ser un conjunto de bibliotecas y herramientas que permiten construir compiladores y optimizadores no está limitado a un lenguaje específico; se usa en C, C++, Rust, Swift, Julia, Haskell, entre otros. Está diseñado como bloques reutilizables (frontends, optimizadores, backends).

¿Para qué sirve LLVM?

  • Compilación: Convierte código fuente en código máquina optimizado. 
  • Optimización: Mejora el rendimiento del código en tiempo de compilación y ejecución. 
  • Portabilidad: Permite que un mismo lenguaje se ejecute en múltiples plataformas. 
  • Experimentación: Ideal para investigadores y desarrolladores que quieren crear nuevos lenguajes o probar técnicas de optimización.
  • Ejemplo real: El compilador Clang (para C/C++/Objective-C) está construido sobre LLVM.

¿Qué hace LLVM?

  1. Traduce código a un lenguaje intermedio (LLVM IR) que es más fácil de analizar y optimizar. 
  2. Optimiza ese código para que sea más rápido y eficiente. 
  3. Genera código máquina para distintas arquitecturas (x86, ARM, etc.), lo que permite que tu programa corra en diferentes dispositivos.

LLVM es como el motor universal que hace funcionar muchos lenguajes modernos (Rust, Swift, Julia, Haskell).

Como desarrollador, puedes usarlo para compilar, optimizar y experimentar con lenguajes modernos o incluso crear el tuyo propio.

Probando LLVM

Vamos a comenzar instalandolo:

Linux:

$ sudo apt update
$ sudo apt install llvm clang

Windows:

$ choco install llvm

Vamos a crear un sencillo programa que verifique si un número entero es mayor a 100.

mayor.c

#include <stdio.h>

int main() {
    printf("\t Determinar si un número es mayor a 100 \n");
int numero = 120; if (numero > 100) { printf("El número es mayor que 100\n"); } else { printf("El número es menor o igual a 100\n"); } return 0; }

Compilams con la herramienta ``clang``:

$ clang mayor.c -o mayor

Creará un ejecutable:

$ ./mayor

Salida:

El número es mayor que 100

Ahora usaremos LLVM para ver el código intermedio (LLVM IR):

$ clang -S -emit-llvm mayor.c -o mayor.ll

Esto genera un archivo ``mayor.ll`` con el Intermediate Representation (IR). En ese archivo verás instrucciones más “básicas” que LLVM entiende, por ejemplo:

define i32 @main() {
entry:
  %numero = alloca i32, align 4
  store i32 120, i32* %numero, align 4
  %0 = load i32, i32* %numero, align 4
  %cmp = icmp sgt i32 %0, 100
  br i1 %cmp, label %if.then, label %if.else
  ...
}

Optimizamos el código:

$ clang -S -emit-llvm mayor.c -o mayor.ll

Esto genera una versión optimizada del IR, eliminando redundancias y mejorando el rendimiento.

Enlaces:

https://llvm.org/
https://codemonkeyjunior.blogspot.com/2024/02/lo-que-conforma-un-lenguaje-de.html
https://clang.llvm.org/
https://es.wikipedia.org/wiki/LLVM
https://www.reddit.com/r/ProgrammingLanguages/comments/kl7n03/what_is_meant_by_llvm_and_a_language_frontend/
https://aosabook.org/en/index.html

sábado, 4 de abril de 2026

WebAssembly con Dlang

WebAssembly es un lenguaje de bajo nivel, similar a ensamblador, diseñado para ser rápido de cargar y ejecutar en navegadores modernos. Su objetivo es permitir que aplicaciones escritas en distintos lenguajes se ejecuten en la web con velocidad casi nativa.

Los formatos que soporta son:

  • .wasm: un formato binario ejecutable. 
  •  .wat: un formato formato de texto legible.

Se complementa con JavaScript; permite invocar funciones WASM desde JS y viceversa. Y como vimos en este blog, también puedes optar por usar un lenguaje como Grain cuya compilación es directa a WASM.

¿Cuál es el objetivo de WebAssembly?

El objetivo de WebAssembly es compilar código escrito en lenguajes como Rust, C o C++ (entre otros) y transformarlo en un módulo .wasm que puede ejecutarse en navegadores o en entornos como Node.js con rendimiento cercano al nativo.

Flujo típico de trabajo con WebAssembly:

  1. Escribimos nuestro código en un lenguaje soportado (ej. Rust, C, C++, Go, AssemblyScript). 
  2. Compilamos ese código a WebAssembly y se generará un archivo .wasm
  3. Cargamos el módulo en tu aplicación web usando JavaScript. 
  4. Ejecutamos las funciones exportadas desde el módulo .wasm  como si fueran algo nativo.

¿Y qué con Dlang?

Dlang es un lenguaje similar al mítico y poderoso C. No solo en su sintaxis sino en su filosofía.

Dlang permite generar código WASM mediante la herramienta LDC.

Creando código WASM con Dlang

Crearemos una sencilla función llamada ``suma_wasm.d``.

extern(C): 

double suma(double a, double b) { return a + b; }

void _start() {}

Compilamos para generar el código WASM:

$ ldc2 -mtriple=wasm32-unknown-unknown-wasm -betterC suma_wasm.d

Ahora crearemos una página HTML para cargar el código WASM generado (suma_wasm.wasm).

index.html

<html>
  <head>
    <script>
      const request = new XMLHttpRequest();
      request.open('GET', 'suma_wasm.wasm');
      request.responseType = 'arraybuffer';
      request.onload = () => {
        console.log('respuesta recibida');
        const bytes = request.response;
        const importObject = {};
        WebAssembly.instantiate(bytes, importObject).then(result => {
          console.log('iniciado');
          const { exports } = result.instance;
          const r = exports.suma(33, 10.88);
          console.log('r = ' + r);
        });
      };
      request.send();
      console.log('solicitud enviada');
    </script>
  </head>
  <body>
    Código D desde WebAssembly
  </body>
</html>

Ahora ejecutaremos este comando para abrir la página web:

$ python -m http.server 8000

Abrimos un navegador en la ruta: http://localhost:8000

Salida:

solicitud enviada
respuesta recibida
iniciado
r = 43.88

WebAssembly permite que aplicaciones complejas escritas en lenguajes de alto nivel como D, C/C++, Rust, etc. se ejecuten en aplicaciones web a través de un compilado .wasm.

Imaginemos que hemos creado una aplicación para gestionar datos complejos en Rust o Java y la queremos ejecutar como una aplicación web. Con WebAssembly es posible. Se podrá compialr ese código y generar un archivo .wasm que podrá ser cargado en una página web.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://dlang.org/
https://webassembly.org/
https://wiki.dlang.org/Generating_WebAssembly_with_LDC
https://alquimistadecodigo.blogspot.com/2026/04/webassembly-con-rust.html


jueves, 2 de abril de 2026

Grain, un lenguaje para WebAssembly

Grain es un lenguaje de programación funcional, moderno y de código abierto, diseñado principalmente para compilarse a WebAssembly (Wasm), lo que le permite funcionar eficientemente tanto en navegadores web como en servidores. Su objetivo es hacer accesibles las características avanzadas de los lenguajes funcionales, siendo fácil de aprender, fuertemente tipado y flexible.

¿Qué es WebAssembly?

  • Un formato de instrucciones binarias para una máquina virtual basada en pila. 
  • Diseñado como un destino de compilación portátil para lenguajes de programación, lo que permite su implementación en la web para aplicaciones cliente y servidor.

Características más importantes:

  • Eficiente y rápido. 
  • Seguro. 
  • Abierto y depurable. 
  • Parte de la plataforma web abierta.

Grain es una alternativa directa a la compilación de código wasm. Si quieres usar lenguajes como C o C++ tendrías que usar https://emscripten.org/. Si quieres usar Python podrás elegir entre https://pyodide.org/en/stable/, https://github.com/wasmerio/py2wasm o https://pygame-web.github.io/. Entre otras alternativas dependiende el lenguaje de programación (Java, C#, Kotlin, Scala, Go, etc.).

Grain posee sus propias herramientas para compilar código y su línea de comandos.

Lo puedes instalar en sistemas Mac OS, Linux y Windows.  Si no deseas instalarlo, puede visitar este sitio y probar el lenguaje: https://grain-lang.org/try/

Otra forma de obtenerlo es con Node (V22 como mínima versión). Primero clonamos el repositorio:

$ git clone https://github.com/grain-lang/grain
$ cd grain

Una vez clonado el repositorio y ubicandonos en el directorio ejecutamose estos comandos para su construcción:

$ npm ci
$ npm run compiler build

Validamos la instalación:

$ grain --version

¡Tenemos instalado Grain en nuestro sistema!

Ahora demos un vistazo al lenguaje.

Al ser un lenguaje fuertemente tipado posee tipos básicos como Number, Bool, String y Char. Observemos la siguiente tabla:

Tipo Descripción Ejemplo
Number Representa números enteros o decimales. let x: Number = 42
Bool Valores booleanos: verdadero o falso. let flag: Bool = true
String Secuencia de caracteres, texto. let msg: String = "Hola Grain"
Char Un solo carácter Unicode. let letter: Char = 'A'

Grain usa la palabra clave ``let`` para introducir nuevos valores con un nombre determinado, a los que se les llama enlaces:

module Main

let numero = 42
let bandera = true
let saludo = "Bienvenido a Grain!"
and letra = 'A'

Hola mundo en Grain

Probemos el clásico programa "Hola, mundo" en este lenguaje.

holamundo.gr

module HolaMundo

print("Hola, mundo en Grain")

Para compilar y ejecutarlo directamente tecleamos:

$ grain holamundo.gr

Con pasos separados:

$ grain compile holamundo.gr 
# Te creará un archivo `holamundo.gr.wasm`
$ grain run holamundo.gr.wasm

Notar que te crea un archivo WASM ejecutable.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://grain-lang.org/
https://webassembly.org/
https://alquimistadecodigo.blogspot.com/2026/04/webassembly-hola-mundo-en-python-con.html




viernes, 27 de marzo de 2026

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


Hablemos de Micronaut y Helidon

En la entrega anterior hablamos de Quarkus (Supersonic Subatomic Java), el cual es un framework cuya filosofía es trabajar en Cloud y...

Etiquetas

Archivo del blog