# Programemos.net — Contenido completo para LLMs

> Blog de programación en español sobre .NET, Azure, arquitectura de software e IA.
> Autor: Jose Antonio Arias (@josearias210)
> URL: https://programemos.net
> Feed RSS: https://programemos.net/rss.xml
> Sitemap: https://programemos.net/sitemap-index.xml
> Actualizado: 2026-11-15

---

## Mapa temático

- [.NET y arquitectura](https://programemos.net/pilares/dotnet-arquitectura/): backend, diseño, calidad y mantenimiento de aplicaciones .NET.
- [Azure, DevOps y operación](https://programemos.net/pilares/azure-devops-operacion/): identidad, despliegue, seguridad y operación de sistemas en producción.
- [IA empresarial y sistemas de agentes](https://programemos.net/pilares/ia-empresarial-agentes/): IA aplicada con gobernanza, memoria, herramientas, observabilidad y control.

---

## Infraestructura como código: el cambio que falta en tu pull request

URL: https://programemos.net/infraestructura-como-codigo-azure-bicep/
Fecha: 2026-11-04
Categorías: Azure, Programación, Opiniones
Descripción: El código pasa por el pipeline y la infraestructura queda a mano. Cómo incluir un Azure Storage con Bicep en el mismo pull request y coordinar su entrega.

El pipeline terminó en verde. La aplicación ya está desplegada. Alguien intenta guardar un documento y aparece el detalle que faltaba: nadie creó la cuenta de Azure Storage que necesita la nueva funcionalidad.

Es un escenario fácil de reconocer cuando automatizamos la aplicación, pero seguimos preparando su entorno a mano. El código pasó por un pull request, pruebas y un despliegue. La infraestructura quedó en una tarea que decía «recordar configurar esto en Azure».

**Si una funcionalidad depende de un recurso o de una configuración, ese cambio también forma parte de su entrega.** Por eso creo que deberíamos conversar sobre infraestructura como código desde que empezamos a trabajar con CI/CD, junto con la compilación y las pruebas.

La entrega continua puede abarcar una API escrita en C#, una aplicación Python o una [aplicación móvil que llega a Google Play](https://programemos.net/devops-dotnet-maui-android-google-play/). También puede abarcar los recursos que permiten que esas aplicaciones funcionen. En Azure tenemos herramientas para llevar esa parte al mismo proceso.

## El cambio que quedó fuera del pull request

Pensemos en una aplicación que incorpora la carga de documentos. En desarrollo alguien crea el almacenamiento desde el portal de Azure. Prueba la funcionalidad, funciona y abre el pull request con el código.

Quien lo revisa puede comprobar cómo se guarda el archivo y cómo se manejan los errores. Pero la cuenta de almacenamiento, sus opciones y el acceso que necesitará la aplicación no aparecen en el cambio. Al preparar otro ambiente hay que reconstruir esas decisiones preguntando o recorriendo pantallas.

Lo mismo ocurre con el escalado de un servicio o una asignación de permisos pendiente. La lista de pasos manuales empieza a crecer alrededor del despliegue. Si uno se olvida, podemos terminar investigando la aplicación cuando lo que falta es preparar su entorno.

Los cambios temporales complican más la situación. Se modifica una opción para resolver una urgencia, queda funcionando y después nadie recuerda si debía conservarse. El siguiente ambiente se prepara con otro valor. Ya tenemos diferencias que el repositorio no explica.

La infraestructura como código permite expresar el estado que queremos mantener en archivos versionados. Así podemos revisar qué recurso necesita una funcionalidad, qué propiedades cambian y por qué, antes de llevarlo a un ambiente. La memoria de quien hizo clic deja de ser el único registro de esa decisión.

## En Azure, empezaría con Bicep

[Terraform](https://developer.hashicorp.com/terraform/intro) permite definir infraestructura mediante archivos declarativos y llevarlos a un flujo de revisión y despliegue. Si un equipo ya trabaja con él, la idea de este artículo se aplica igual.

Para un desarrollo nuevo centrado en Azure, mi recomendación es **Bicep**. Es un lenguaje declarativo con tipos: describimos los recursos y sus propiedades, y Azure Resource Manager se encarga del despliegue.

Conviene precisar los nombres. ARM es Azure Resource Manager, el servicio que administra los recursos. Las plantillas ARM se escriben en JSON; Bicep ofrece otra sintaxis y se compila a esas plantillas. La [documentación de Bicep](https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/overview) explica esa relación.

Yo evitaría escribir las plantillas JSON a mano en un desarrollo nuevo porque Bicep resulta más conciso y facilita revisar la definición. Esa preferencia tiene un motivo bastante práctico: si esperamos que la infraestructura pase por un pull request, nos conviene que el equipo pueda leerla y discutirla.

## El Azure Storage que necesita la aplicación

Volvamos a la carga de documentos. Junto al código de la funcionalidad podríamos agregar este archivo:

```bicep title="infra/main.bicep"
param location string = resourceGroup().location
param storageAccountName string = 'docs${uniqueString(resourceGroup().id)}'

resource documentsStorage 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: storageAccountName
  location: location
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
  properties: {
    supportsHttpsTrafficOnly: true
    minimumTlsVersion: 'TLS1_2'
    allowBlobPublicAccess: false
  }
}

output storageAccountId string = documentsStorage.id
```

Es un ejemplo ilustrativo, contrastado con la [referencia del recurso](https://learn.microsoft.com/en-us/azure/templates/microsoft.storage/2023-05-01/storageaccounts), con API `2023-05-01`. No lo he compilado ni desplegado para este artículo.

Aquí ya hay decisiones que antes podían quedar escondidas en el portal: el tipo de cuenta, la redundancia `Standard_LRS`, el uso obligatorio de HTTPS, TLS mínimo 1.2 y la desactivación del acceso anónimo a blobs. El nombre se deriva del identificador del resource group para mantenerlo estable al repetir el despliegue sobre ese grupo.

El ejemplo crea la cuenta; todavía faltan el contenedor de documentos, la identidad y los permisos que utilizará la aplicación, su configuración de conexión y las reglas de red que requiera el entorno. Desactivar el acceso anónimo a blobs no equivale a restringir el acceso de red. Esas decisiones también deben quedar explícitas al completar la funcionalidad.

En el pull request ya podemos preguntar si esa redundancia sirve para el ambiente, quién va a acceder y qué configuración recibirá la aplicación. La revisión tiene algo concreto sobre lo que trabajar, además del código que sube archivos.

## Llevar el archivo al pipeline

Guardar Bicep en Git nos da seguimiento. Para reducir los pasos olvidados también hay que ejecutarlo como parte de la entrega.

Supongamos un resource group existente llamado `rg-documentos-dev`, una identidad del pipeline autenticada en la suscripción correcta y permisos para desplegar. Con Azure CLI 2.75.0 o posterior, el flujo puede mostrar primero los cambios previstos:

```bash
az deployment group what-if --resource-group rg-documentos-dev --template-file infra/main.bicep
```

La operación [what-if](https://learn.microsoft.com/en-us/azure/azure-resource-manager/bicep/deploy-what-if) consulta el entorno y anticipa cambios sin aplicarlos. Sirve para revisarlos, aunque tiene limitaciones y puede mostrar diferencias que no terminarán siendo cambios efectivos. No la trataría como una prueba de que la aplicación funcionará.

Después de la revisión y de la aprobación que corresponda al ambiente, el paso que aplica la infraestructura sería:

```bash
az deployment group create --name documentos-infra --resource-group rg-documentos-dev --template-file infra/main.bicep --mode Incremental
```

Estos comandos ilustran los pasos del pipeline; no se han ejecutado aquí. El resultado esperado del segundo es una cuenta creada con la configuración declarada, o la actualización de esa misma cuenta al volver a desplegarla.

Para esta funcionalidad, ordenaría la entrega así: validar el cambio, revisar la infraestructura prevista, aplicarla y, si termina correctamente, desplegar la aplicación con su configuración. Después comprobaría una carga de documentos con la identidad real de la aplicación. Si falla la preparación del recurso, la nueva versión no debería continuar como si ya tuviera su dependencia disponible.

**Un mismo pull request permite revisar juntos los cambios; el pipeline tiene que coordinar su aplicación.** No se convierten en una operación atómica por estar en el mismo repositorio. Si el despliegue de la aplicación falla después, la cuenta puede haber quedado creada y habrá que decidir cómo continuar.

Tampoco usaría esta definición mínima para adoptar a ciegas una cuenta existente. En el [modo incremental de ARM](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/deployment-modes), las propiedades omitidas de un recurso que se vuelve a desplegar pueden restablecerse a sus valores por defecto. Antes de incorporarlo, hay que recoger la configuración que queremos conservar.

## Qué hacemos con los cambios urgentes

Puede seguir siendo necesario intervenir en el portal durante un incidente. El problema aparece cuando esa intervención se queda allí y el archivo describe otra cosa.

Después de resolver la urgencia, el equipo debe decidir si conserva el cambio. Si lo conserva, lo incorpora a Bicep y lo revisa; si era temporal, prepara su retirada. La próxima comparación con `what-if` puede ayudar a ver diferencias, pero el archivo no vigila Azure por estar guardado en Git: hace falta ejecutar la comparación y atender sus resultados.

Empezaría por el recurso que ya necesita la siguiente funcionalidad, con un alcance claro y una revisión de su configuración. Intentar trasladar toda la suscripción de golpe puede convertir una mejora concreta en un proyecto difícil de terminar.

Para mí, pensar en DevOps también exige mirar esa parte del despliegue. Si el código necesita almacenamiento para guardar documentos, entregar la funcionalidad incluye preparar ese almacenamiento y comprobar que puede utilizarlo. Esa dependencia merece el mismo seguimiento que el código que la consume.

---

## Revisar un artículo sin reescribirlo: IA con Microsoft Foundry

URL: https://programemos.net/microsoft-decision-1-decisiones-ia/
Fecha: 2026-10-21
Categorías: IA, Azure, Programación
Descripción: Cómo aplicar Microsoft-Decision-1 a una revisión editorial: decisiones rápidas, costes bajos y un ejemplo para entender cuándo conviene esta IA.

Un borrador puede estar bien escrito y contar algo que yo nunca dije. Puede explicar correctamente una tecnología y exagerar los resultados del ejemplo. O puede desarrollar una buena idea durante varias páginas sin responder la pregunta que abrió al principio.

Para revisar eso necesitamos interpretar el texto. Pero la aplicación que organiza el proceso editorial tiene una necesidad más concreta: **decidir si una versión puede continuar, necesita correcciones o debe volver al autor**.

Ahí es donde me interesa Microsoft-Decision-1, el modelo de decisión disponible en Microsoft Foundry. Permite pedir juicios acotados que el software puede combinar, sin convertir cada comprobación en otra página de observaciones generadas.

Voy a llevarlo al problema de revisar los artículos de este blog. El ejemplo adapta ese flujo editorial a Microsoft-Decision-1; las solicitudes y respuestas que aparecen son ilustrativas, no el resultado de una integración ejecutada. La idea es entender qué haría cada pieza y por qué esta clase de IA puede resultar útil en una aplicación cotidiana.

## La pregunta que necesita el programa

Cuando le pedimos a un LLM «revisa este artículo», podemos recibir una respuesta útil, pero amplia: comentarios, recomendaciones, cambios de estilo y quizá una nueva versión del texto. Todo eso tiene sentido si queremos trabajar sobre la redacción.

Para controlar el flujo conviene separar preguntas más pequeñas:

- ¿El borrador respeta la información que proporcionó el autor?
- ¿El ejemplo permite entender la decisión técnica?
- ¿Hay evidencia suficiente para sostener una cifra?

La primera puede terminar en una opción; la segunda, en una puntuación; la tercera, en una señal para detener la revisión y pedir una fuente. El resultado útil está en lo que puede hacer el programa después de recibir esas respuestas.

Según la [documentación de Microsoft-Decision-1](https://learn.microsoft.com/en-us/azure/foundry/foundry-models/how-to/use-foundry-models-microsoft-decision), la API recibe un `state` con texto o JSON y preguntas de tres tipos:

| Tipo | Qué permite preguntar | Qué devuelve |
| --- | --- | --- |
| `noul` | Si se cumple una condición | Una probabilidad entre 0 y 1 |
| `choice` | Cuál de varias opciones corresponde | Una elección y probabilidades por opción |
| `score` | Cuánto cumple un criterio | Una puntuación y una distribución por niveles |

El modelo no redacta una justificación libre. Por eso no le pediría que proponga cómo mejorar un párrafo: esa tarea sigue correspondiendo a quien escribe o a un modelo generativo.

## Un ejemplo: detectar una promesa que la fuente no sostiene

Supongamos que la información original de un artículo dice:

> El proceso sigue en pruebas. Todavía no hemos medido el ahorro.

Pero el borrador termina afirmando:

> El sistema ya redujo un 90 % el coste en producción.

La frase puede sonar convincente y estar perfectamente escrita. El problema es que convirtió una prueba sin mediciones en un resultado de producción. Un corrector ortográfico no va a encontrar ese salto.

Para plantearlo con Microsoft-Decision-1, separaría el borrador de su fuente y definiría qué respuestas acepta la aplicación:

```json
{
  "model": "evaluador-editorial",
  "state": {
    "fuente": "El proceso sigue en pruebas. No hemos medido el ahorro.",
    "borrador": "El sistema ya redujo un 90 % el coste en producción."
  },
  "questions": {
    "fidelidad": {
      "type": "choice",
      "instructions": "Contrasta el borrador con la fuente del autor.",
      "criteria": {
        "fiel": "Conserva los hechos y el alcance de la fuente.",
        "contradice_fuente": "Cambia hechos o atribuye resultados incompatibles con la fuente.",
        "informacion_insuficiente": "La fuente no permite comprobar la afirmación."
      }
    }
  }
}
```

`evaluador-editorial` representa el nombre de un deployment en Foundry. La solicitud se envía al endpoint `/providers/microsoft/v1/systemone` del recurso; no es una llamada a un endpoint de chat.

La parte relevante de una salida ilustrativa podría verse así:

```json
{
  "type": "choice",
  "choice": "contradice_fuente",
  "probabilities": {
    "fiel": 0.01,
    "contradice_fuente": 0.97,
    "informacion_insuficiente": 0.02
  }
}
```

Con ese resultado, el programa puede marcar la afirmación para corregirla. Si la información es insuficiente, puede devolverla al autor para que aporte la fuente. Ninguna de esas acciones requiere generar otro artículo.

**La opción elegida sirve para dirigir el trabajo; las probabilidades ayudan a decidir cuándo conviene intervenir.** Ese 0,97 del ejemplo no es una garantía de acierto. Antes de automatizar habría que comprobar cómo se comporta la pregunta con borradores propios, especialmente en los casos ambiguos.

## Evaluar varias cosas sin perder las responsabilidades

Una contradicción evidente es un caso fácil de explicar. La revisión completa tendría preguntas sobre la utilidad del ejemplo, la claridad del argumento y el respaldo de las conclusiones. Cada una necesitaría criterios concretos, porque «¿está bien el artículo?» deja demasiado espacio a la interpretación.

Por ejemplo, para puntuar un caso práctico podríamos distinguir entre mencionar una herramienta, mostrar cómo se utiliza y explicar por qué esa elección resuelve el problema presentado. Una nota alta debería significar algo reconocible para quien revisa el resultado.

Después combinaría las respuestas en código. Una buena puntuación de claridad no debería compensar una contradicción con la fuente. Y si el modelo no tiene información suficiente, la aplicación debería poder dejar el caso pendiente en lugar de forzar una aprobación.

El flujo quedaría así:

1. El agente prepara el borrador a partir de la idea y las fuentes.
2. Microsoft-Decision-1 evalúa preguntas delimitadas sobre ese material.
3. El código aplica la política editorial a las respuestas.
4. El agente corrige los defectos identificados y el autor resuelve las dudas que requieren su criterio.

![Ejemplo editorial con Microsoft-Decision-1: el agente redacta, el modelo evalúa y el código decide si recomendar, corregir o consultar al autor](https://programemos.net/images/microsoft-decision-1-evaluacion-editorial.webp)

*Adaptación del flujo editorial a Microsoft-Decision-1: evaluar, aplicar una política y decidir el siguiente paso.*

La recomendación de contenido tampoco publica el artículo. Esa sigue siendo otra decisión del proceso.

Este reparto da continuidad a lo que expliqué en [No todo necesita agentes de IA](https://programemos.net/no-todo-necesita-agentes-ia-criterio-ingenieria/): si la condición es exacta, la dejo en código. No usaría Microsoft-Decision-1 para comprobar las dimensiones de una imagen o averiguar si el sitio compila. Su lugar está en las comprobaciones que necesitan interpretar significado.

## Qué cambia cuando cada decisión cuesta muy poco

Microsoft publica una tarifa de **0,042 USD por millón de tokens de entrada y sin cobro de tokens de salida**. El precio está en el [anuncio del modelo](https://commandline.microsoft.com/microsoft-decision-1-model-foundry/), consultado el 22 de octubre de 2026.

Si una revisión consume 10.000 tokens entre contenido, contexto e instrucciones, esta sería la cuenta del modelo:

| Revisiones | Tokens de entrada | Coste a esa tarifa |
| --- | ---: | ---: |
| 1 | 10.000 | 0,00042 USD |
| 1.000 | 10 millones | 0,42 USD |
| 100.000 | 1.000 millones | 42 USD |

Son estimaciones de una carga supuesta, no facturas del blog. Tampoco incluyen otros servicios, reintentos o intervención humana.

La oportunidad aparece cuando dejamos de evaluar solo unos pocos elementos porque cada revisión exige una conversación generativa extensa. Podemos plantearnos revisar cada respuesta de soporte, clasificar cada comentario o priorizar solicitudes a medida que llegan.

Un LLM pequeño también puede resultar económico y devolver JSON. La comparación debe hacerse con la misma tarea y una calidad suficiente. Lo que me interesa de un modelo de decisión es pagar por el juicio que necesita la aplicación, sin generar una explicación que después nadie va a utilizar.

En un blog pequeño, el ahorro absoluto puede ser modesto. En un sistema con miles de comprobaciones diarias, esa elección empieza a afectar qué automatizaciones merece la pena construir. De todos modos, enviar contexto de más sigue costando: una tarifa baja no vuelve necesario todo el material que podríamos adjuntar.

## La rapidez se nota cuando hay que esperar varias veces

Microsoft informa de una latencia mediana aproximadamente **35 veces menor que la de GPT-6 Sol** en sus pruebas de decisiones estructuradas. Es una comparación del proveedor para esas condiciones, no una medición nuestra ni una promesa sobre cualquier aplicación.

Para una revisión ocasional quizá unos segundos no cambien mucho. Pero si una solicitud pasa por clasificación, selección de un flujo y evaluación de una respuesta antes de terminar, cada espera se suma a la experiencia del usuario.

Ahí veo el valor de una decisión rápida. Puede formar parte del recorrido habitual de la aplicación, sin obligar a esperar una explicación extensa en cada paso. Aun así, mediría la llamada completa desde el servicio que la consume: la red, el tamaño del contexto y la concurrencia también cuentan.

La misma clase de uso ya tiene un ejemplo documentado por Microsoft: XBOX Research clasificó más de 10.000 comentarios y reseñas en temas definidos por investigadores. La utilidad estaba en ordenar el material para analizarlo, no en escribir una respuesta para cada comentario. Es una prueba interna descrita en el anuncio, no una experiencia de este blog.

## Dónde encaja frente a otras alternativas

Yo elegiría la herramienta según el tipo de pregunta:

| Necesidad | Opción que evaluaría primero |
| --- | --- |
| Comprobar permisos, formatos o rangos exactos | Código y validadores deterministas |
| Clasificar un dominio estable con suficientes ejemplos propios | Un clasificador especializado |
| Interpretar texto y elegir entre opciones delimitadas | Un modelo de decisión como Microsoft-Decision-1 |
| Redactar, explicar o resolver un problema abierto | Un LLM generativo |

Frente a otros modelos de decisión, la razón práctica para probar Microsoft-Decision-1 sería su encaje en Foundry. Para un equipo que ya trabaja en Azure, permite integrar esa capacidad en ese entorno, con autenticación mediante Microsoft Entra ID. Después tocaría comprobar las preguntas con datos propios: estar en el mismo ecosistema facilita la integración, pero no decide la calidad por nosotros.

Antes de incorporarlo empezaría por una comprobación fácil de revisar, como la contradicción entre fuente y borrador. Reuniría ejemplos correctos, incorrectos y dudosos, y observaría tanto los errores como los casos que devuelve al autor. Una salida bien formada también puede contener una decisión equivocada.

**La oportunidad está en construir aplicaciones donde la IA ayuda a elegir qué ocurre después.** Revisar un borrador, ordenar una cola o filtrar una respuesta son funciones útiles aunque no produzcan contenido nuevo. Microsoft-Decision-1 ofrece una pieza para ese trabajo; definir bien las opciones y decidir qué errores podemos tolerar sigue siendo responsabilidad de quien diseña la aplicación.

---

## Kafka y .NET: por qué es el estándar de los eventos y cómo sacarle provecho

URL: https://programemos.net/kafka-dotnet-pragmatico/
Fecha: 2026-09-18
Categorías: Arquitectura de Software, Programación
Descripción: Por qué Kafka se usa tanto en arquitecturas de eventos y cómo sacarle provecho desde .NET: log, particiones, offsets y código con Confluent.Kafka.

Kafka aparece en casi toda conversación de arquitectura de eventos. A veces con motivo; otras porque a alguien le sonó bien en una reunión. Y ahí está el primer problema: la mayoría de los equipos lo evalúa como si fuera una cola de mensajes rápida, y con esa lectura termina usándolo mal o descartándolo sin entenderlo.

Mi postura es simple: **Kafka no es una cola con esteroides. Es un log distribuido donde los mensajes no se borran al consumirse.** Esa diferencia explica por qué domina el streaming de eventos desde hace años, define las reglas de su modelo y marca cómo sacar provecho real desde .NET con poco código.

## Kafka no es una cola, es un log

En una cola tradicional, cuando un consumidor confirma un mensaje, este desaparece. En Kafka, el mensaje se escribe en un log inmutable y permanece según la política de retención: horas, días o para siempre. Consumir no es quitar; es mover un puntero.

Ese puntero es el **offset**: la posición de un mensaje dentro de una **partición**. Un **tópico** se divide en particiones, cada una es un log ordenado e independiente, y un **grupo de consumo** reparte esas particiones entre sus consumidores: una partición se la lleva un solo consumidor del grupo a la vez.

![Diagrama de productores .NET escribiendo en un tópico de Kafka con tres particiones y dos grupos de consumo con offsets independientes](https://programemos.net/images/kafka-dotnet-pragmatico-particiones.webp)

*Cada grupo avanza su propio offset por partición y puede volver a leer los eventos que sigan retenidos en el log.*

De ese modelo salen las dos consecuencias que definen todo lo demás:

- **La partición es la unidad de orden y de paralelismo.** Dentro de una partición hay orden garantizado; entre particiones, no. Si necesitas orden por cliente, la clave de partición debe ser el cliente. Y el paralelismo máximo de un grupo es el número de particiones: con tres particiones, un cuarto consumidor del mismo grupo se queda de brazos cruzados.
- **El replay aprovecha los eventos retenidos.** Un consumidor nuevo, un bug corregido o una vista a reconstruir pueden rebobinar el offset y reprocesar los registros que sigan disponibles. La [política del tópico](https://kafka.apache.org/43/configuration/topic-configs/#cleanup.policy) puede eliminar segmentos por tiempo o tamaño, o compactar registros conservando el último valor por clave. El reprocesamiento también consume lectura, red y capacidad del consumidor. Si alguna vez rompiste un proceso a las 3 a.m. y necesitabas reconstruir su estado, sabes cuánto vale disponer de ese historial.

Cambiar de mentalidad —de cola a log— es el 80% de la curva de aprendizaje de Kafka. El resto es API.

## Por qué se usa tanto

No es moda ni marketing. Son propiedades concretas que resuelven problemas reales:

- **Rendimiento.** Escrituras secuenciales a disco, agrupación de mensajes en lotes y envíos por bloques del lado del cliente sostienen cientos de miles de eventos por segundo en hardware modesto. En un clúster bien dimensionado, los millones no son exóticos.
- **Desacoplamiento temporal.** El productor no necesita que el consumidor esté disponible. El consumidor puede estar caído, desplegando o en mantenimiento y procesar los eventos al volver, siempre que sigan dentro de la retención configurada. Si queda rezagado más allá de esa ventana, puede perder acceso a registros que todavía no había leído.
- **Fan-out natural.** Varios grupos de consumo leen el mismo flujo con offsets independientes. Un mismo evento alimenta facturación, analítica y notificaciones sin duplicar publicaciones ni acoplarse entre sí.
- **Reprocesabilidad.** Replay, auditoría, event sourcing, reconstruir proyecciones. El log es la fuente de verdad y las vistas son derivadas.
- **Ecosistema.** Kafka Connect para integrar bases de datos y sistemas externos, procesamiento con Kafka Streams o Flink, y Schema Registry para versionar contratos.

Un punto de operación que antes frenaba adopciones: desde Kafka 4.0 ya no existe ZooKeeper; el clúster se coordina solo con KRaft. Levantar un clúster de desarrollo es hoy un contenedor, no un zoo.

Visto fríamente, Kafka gana porque convierte un problema de integración punto a punto —donde cada conexión nueva es una condición más que puede fallar— en un problema de escribir y leer un log. El costo de agregar un servicio al ecosistema deja de crecer con cada par de sistemas que se hablan.

## Cómo lo aprovecha .NET

El cliente de referencia en .NET es [Confluent.Kafka](https://www.nuget.org/packages/Confluent.Kafka), un binding maduro sobre librdkafka que corre en Linux, Windows y macOS. Y aquí hay una coincidencia afortunada: el modelo de Kafka mapea directo a lo que la plataforma ya tiene.

El productor cabe en pocas líneas:

```csharp
using Confluent.Kafka;

var config = new ProducerConfig
{
    BootstrapServers = "localhost:9092",
    EnableIdempotence = true
};

using var producer = new ProducerBuilder<string, string>(config).Build();

await producer.ProduceAsync("pedidos", new Message<string, string>
{
    Key = pedido.ClienteId,
    Value = JsonSerializer.Serialize(pedido)
});
```

`EnableIdempotence = true` evita duplicados cuando el cliente reintenta tras un timeout. Y fíjense en la `Key`: es lo que decide la partición. Mismo cliente, misma partición, mismo orden.

El consumidor es un bucle, y el sitio natural en ASP.NET Core o en un Worker Service es un `BackgroundService`:

```csharp
public class FacturacionConsumer : BackgroundService
{
    private readonly IConsumer<string, string> _consumer;
    private readonly IServiceProvider _services;

    public FacturacionConsumer(IServiceProvider services)
    {
        _services = services;
        _consumer = new ConsumerBuilder<string, string>(new ConsumerConfig
        {
            BootstrapServers = "localhost:9092",
            GroupId = "facturacion",
            AutoOffsetReset = AutoOffsetReset.Earliest,
            EnableAutoOffsetStore = false
        }).Build();

        _consumer.Subscribe("pedidos");
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var result = _consumer.Consume(stoppingToken);
            var pedido = JsonSerializer.Deserialize<PedidoCreado>(result.Message.Value);

            using var scope = _services.CreateScope();
            await ProcesarPedido(pedido!, scope.ServiceProvider, stoppingToken);

            _consumer.StoreOffset(result);
        }
    }
}
```

**NOTA**: el código omite manejo de errores, logging y configuración; es de referencia, no para copiar a producción tal cual.

El detalle que importa está en el par `EnableAutoOffsetStore = false` y `StoreOffset` después de procesar: el offset solo avanza cuando el mensaje ya se procesó. Eso da semántica *at-least-once*: si el proceso muere a mitad, otro consumidor retoma desde el último offset confirmado. Con el auto-commit por defecto puedes perder mensajes: la aplicación muere después del commit y antes de procesar.

Para JSON con esquema versionado, el paquete [Confluent.SchemaRegistry.Serdes.Json](https://www.nuget.org/packages/Confluent.SchemaRegistry.Serdes.Json) integra con Schema Registry; en producción, Avro o Protobuf son la opción habitual.

Para desarrollo, el propio proyecto publica una imagen que levanta un nodo en modo KRaft con un solo comando:

```bash
docker run -d --name kafka -p 9092:9092 apache/kafka:4.3.1
```

## Las reglas del modelo que te ahorran dolores

Kafka no es difícil; es estricto. El lenguaje del modelo impone reglas, y respetarlas desde el primer día ahorra semanas:

- **El consumidor debe ser idempotente.** At-least-once significa que los duplicados no son un bug, son parte de la garantía. Deduplica por identificador de negocio o haz que el efecto sea repetible.
- **Diseña la clave de partición antes de escribir el productor.** Cambiar el particionado con datos ya en el log redistribuye mensajes entre particiones y rompe el orden por clave.
- **Dimensiona las particiones al inicio.** Son tu techo de paralelismo por grupo, y añadirlas después sobre un tópico con claves es una operación que no perdona.
- **Gestiona los rebalances.** Cuando un consumidor entra o sale del grupo, las particiones se reasignan. Registra un `SetPartitionsRevokedHandler` para confirmar offsets pendientes en el corte.
- **Versiona los contratos.** En un log duradero, los mensajes viejos conviven con los nuevos durante meses. Schema Registry con Avro o Protobuf evita que un cambio de campo rompa a los consumidores a medianoche.
- **No pidas consultas al log.** Kafka no es una base de datos consultable. Si necesitas consultar estado, construye una proyección: el consumidor materializa su vista en su propio almacén.

## Cuándo sí y cuándo no

Lo usaría cuando hay varios servicios integrados por eventos, volumen serio de mensajes, necesidad de replay o auditoría, pipelines de streaming o event sourcing. También cuando el desacoplamiento temporal es el requisito dominante: sistemas que deben seguir funcionando aunque una pieza esté caída.

No lo haría la primera opción cuando:

- El volumen es bajo y solo hay un productor y un consumidor: RabbitMQ o Azure Service Bus resuelven con menos operación.
- Lo que necesitas es una cola de trabajo con confirmación por mensaje: ahí las colas tradicionales son más directas. Para trabajos en segundo plano dentro de una sola aplicación .NET, ni siquiera hace falta un broker.
- Es un equipo pequeño sin experiencia operando clústeres: el costo de operación —discos, monitoreo, rebalances, capacidad— es real y no desaparece por ser open source.

En el mundo Azure hay un punto medio pragmático: Event Hubs habla el protocolo de Kafka, así que el mismo código de `Confluent.Kafka` apunta a un servicio gestionado sin montar clúster. Y Confluent Cloud hace lo mismo como servicio dedicado.

La pregunta que haría antes de instalar nada: **¿necesitas volver a leer eventos ya procesados, con varios grupos independientes y orden dentro de cada partición?** Ahí evaluaría Kafka —o una alternativa gestionada—, dimensionando la retención y el costo de operación. Si solo necesitas conservar trabajo pendiente hasta que un consumidor vuelva, una cola persistente también puede resolverlo; [Azure Service Bus](https://learn.microsoft.com/en-us/azure/service-bus-messaging/message-expiration), por ejemplo, conserva mensajes sujetos a su tiempo de vida. Sobrevivir a la caída de un consumidor no basta por sí solo para justificar Kafka.

Si quieres seguir aprendiendo sobre estos temas, te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

- [Documentación de Apache Kafka](https://kafka.apache.org/documentation/)
- [.NET Client for Apache Kafka (Confluent)](https://docs.confluent.io/kafka-clients/dotnet/current/overview.html)
- [Descargas y versiones de Apache Kafka](https://kafka.apache.org/downloads)

---

## .NET y robótica: ya va siendo hora de salir del CRUD

URL: https://programemos.net/dotnet-robotica-del-crud-al-hardware/
Fecha: 2026-09-04
Categorías: Programación, Opiniones
Descripción: De la frustración con Arduino a un lector de huellas en minería: lo que el hardware me enseñó sobre contexto, y dónde encaja .NET en la robótica.

Cuando quise empezar con el hardware, pensé en un Arduino. Fue frustrante. Venía de trabajar con computadoras y de quejarme, a veces, de que tenían poca memoria o pocos recursos. Acercarme a un dispositivo de ese tamaño me hizo poner esas quejas en perspectiva.

Pero lo que más me hizo pensar fue descubrir cuánto tenía que aprender además de programar. **El hardware me obligó a mirar problemas que desde el software daba por resueltos, o que ni siquiera había considerado.**

Por eso me interesa que quienes trabajamos con .NET nos acerquemos más a la robótica y a los dispositivos físicos. Hay herramientas para entrar desde C#, y hay novedades interesantes. Pero antes de hablar de ellas, quiero contar una experiencia que explica mejor por qué creo que vale la pena.

## Cuando un lector de huellas parecía una buena idea

Una vez trabajé con un sistema que utilizaba un lector de huellas para registrar asistencia. Desde el punto de vista del software, la decisión parecía bastante acertada: identificar a una persona y registrar su entrada.

El detalle era dónde se iba a utilizar. Muchas de esas personas trabajaban en minería, y las condiciones de sus manos y sus huellas dificultaban el uso del lector. En ese contexto, elegir la huella como mecanismo de asistencia terminó siendo una solución menos adecuada de lo que parecía al pensar solamente en la aplicación.

A eso se sumaba que la conectividad de la zona tampoco era buena.

Podías tener bien resuelta la lógica del registro y seguir teniendo un problema para tomar asistencia. La aplicación dependía de que una persona pudiera identificarse con ese dispositivo, en esas condiciones, y de una conectividad que no podíamos dar por sentada.

**Habíamos elegido una solución que parecía correcta desde el software, pero el contexto físico tenía mucho que decir.**

Esa experiencia me dejó una forma distinta de mirar estas decisiones. Antes de discutir cómo guardar el registro, había que entender quién iba a poner la mano en el lector, en qué condiciones lo haría y qué ocurriría cuando la lectura o la conexión fallaran.

La lección tampoco es descartar los lectores de huellas en cualquier escenario. Es probar la elección con las personas y las condiciones del lugar donde se va a usar. En nuestro caso, esa combinación importaba más de lo que la solución de software dejaba ver.

## El mundo físico agrega variables que no estamos mirando

Cuando programamos, solemos buscar condiciones reproducibles. Con las mismas entradas y el mismo estado, esperamos obtener el mismo resultado. El software también tiene concurrencia, redes y fallos difíciles de reproducir; aun así, muchas veces podemos aislar el problema y controlar buena parte del entorno de una prueba.

Con hardware de por medio, es más fácil creer que estamos repitiendo las mismas condiciones cuando en realidad algo cambió. La posición de una mano, el contacto con un sensor o la alimentación de un dispositivo pueden afectar el resultado.

Eso obliga a revisar nuestras suposiciones. Que el código siga igual no significa que todo el sistema esté en el mismo estado.

Mi acercamiento a Arduino empezó por la frustración con los recursos disponibles. El aprendizaje iba más allá de ahorrar memoria: tenía que entender mejor el dispositivo y lo que ocurría a su alrededor. Resolver el problema exigía ampliar lo que estaba dispuesto a observar.

Y ahí veo una buena razón para tocar hardware, incluso si después seguimos dedicándonos al backend. **Te acostumbra a preguntar qué estás dejando fuera de tu modelo del problema.** En el sistema de asistencia, las manos de los trabajadores eran parte del sistema tanto como la base de datos.

## Dónde encajan .NET y la robótica en todo esto

Acercarnos a ese mundo desde C# es posible. Las [bibliotecas .NET IoT de Microsoft](https://learn.microsoft.com/en-us/dotnet/iot/) incluyen `System.Device.Gpio` e `Iot.Device.Bindings`, con ejemplos para trabajar con sensores y placas como Raspberry Pi. Hay que comprobar la compatibilidad concreta de la placa y sus periféricos, pero tenemos una entrada desde un lenguaje conocido.

Para microcontroladores compatibles existe [.NET nanoFramework](https://docs.nanoframework.net/content/introduction/why-use-nanoframework.html), con su propio runtime y sus restricciones. Eso no significa que cualquier Arduino ejecute .NET, ni que podamos llevar una aplicación ASP.NET a un microcontrolador. Elegir el dispositivo sigue siendo una decisión técnica.

En robótica industrial también hay un espacio para C#. Un ejemplo reciente es ABB: [RobotStudio utiliza .NET 10 desde la versión 2026.1](https://library.e.abb.com/public/db6ae87c1cf9468bba3faa01b094fb3b/RobotStudio%202026.2%20Release%20Notes.pdf). Aquí .NET participa en el entorno de ingeniería y sus extensiones; los programas del robot siguen teniendo su propio lenguaje y controlador.

Lo interesante para nosotros es que podemos aprovechar lo que ya sabemos para entrar en otro dominio. Después tocará aprender sensores, coordenadas, movimiento o electrónica, según el proyecto. C# nos ayuda a empezar; entender el equipo y su entorno nos permite avanzar.

## Un ejemplo reciente que conecta con ese aprendizaje

Hay un [trabajo publicado el 13 de agosto de 2026](https://arxiv.org/abs/2608.21417) que conecta un modelo de lenguaje con RobotStudio mediante MCP. Genera programas en RAPID, el lenguaje de robots de ABB, y usa la simulación para ejecutarlos y corregirlos.

El detalle que me interesa es que aparecen errores que no se resuelven mirando solamente el texto del programa: una altura incorrecta al soltar una pieza o una posición que el robot no puede alcanzar. La evaluación se hizo en una celda simulada y mantiene la necesidad de preparación y supervisión experta.

Eso conecta con lo que aprendí con el lector de huellas: para evaluar una solución necesitas observar lo que ocurre cuando intenta cumplir su función. En aquel caso, con las personas que iban a usarla. En este, con el comportamiento que representa la simulación, antes de pasar al equipo real.

El [puente descrito en el estudio](https://arxiv.org/html/2608.21417v1) conecta un servidor MCP con un add-in de RobotStudio mediante una API HTTP local. El repositorio que citan los autores ya no está accesible durante esta revisión, así que no lo presento como código disponible para reproducir el experimento. Para desarrollar o migrar un add-in en C# a RobotStudio 2026, hay que revisar la [guía de migración de ABB a .NET 10](https://developercenter.robotstudio.com/api/robotstudio/articles/Introduction/DotNetMigration.html).

Tenemos, entonces, un caso concreto de C# participando en robótica. Y también una buena muestra de cuánto trabajo queda después de generar código.

## Antes de construir la interfaz, entender qué puede fallar

Si hoy planteara un proyecto pequeño con un sensor y un actuador, empezaría por comprobar el comportamiento físico. Qué detecta el sensor, cuándo deja de detectarlo y cómo sé que ocurrió el movimiento esperado. La interfaz vendría después de entender eso.

Una forma de ordenar las responsabilidades sería esta:

![Aplicación C# para órdenes y estado, control local para límites y temporización, y sensores y actuadores que permiten medir el resultado físico](https://programemos.net/images/dotnet-robotica-del-crud-al-hardware-responsabilidades.webp)

*Esquema conceptual para un montaje: enviar una orden y comprobar su resultado son responsabilidades diferentes.*

La aplicación puede pedir una operación. El control local necesita decidir si puede ejecutarla y utilizar las lecturas disponibles para comprobar qué pasó. Si una respuesta se pierde, repetir la orden a ciegas podría repetir también el movimiento.

En el caso de la asistencia, ese mismo hábito de pensar en los fallos lleva a preguntas muy concretas: cómo se registra a alguien cuando el lector no consigue identificarlo, qué pasa sin conexión y cómo se evita perder o duplicar registros al recuperarla. Son preguntas que hay que resolver con el proceso de trabajo y con quienes lo usan.

Para aprender, empezaría con un montaje pequeño y de baja energía. Para una máquina con exigencias estrictas de tiempo o seguridad, haría falta evaluar los controladores y mecanismos adecuados. Saber C# no sustituye ese conocimiento, y tampoco conviene forzar .NET en cada parte del sistema.

Lo que sí podemos llevar desde el primer día es la costumbre de comprobar nuestras suposiciones. Probar el dispositivo en el entorno previsto, observar sus fallos y ajustar la solución antes de darla por buena.

## Ahí es donde nuestro análisis tiene más valor

Creo que esto cobra más importancia con la IA. Cada vez podemos delegar más trabajo de implementación y obtener código con menos esfuerzo. Mi impresión es que, en tareas concretas, ya nos está obligando a revisar cuánto de nuestro valor profesional apoyábamos en escribir ese código.

Pero alguien tiene que detectar que un lector de huellas puede ser una mala elección para esas personas. Alguien tiene que preguntar por la conectividad antes de diseñar un flujo que dependa de ella. Y alguien tiene que ir al lugar, escuchar y comprobar si la solución realmente sirve.

La IA puede ayudarnos a analizar esas situaciones si le damos el contexto. **Reconocer qué contexto falta y buscarlo sigue siendo una responsabilidad nuestra.** Una implementación impecable puede resolver con mucha eficiencia un problema que entendimos mal.

Por eso quiero acercarme más al hardware e invito a otros desarrolladores .NET a hacer lo mismo. Mi experiencia al empezar fue frustrante, pero me hizo pensar de otra manera. Nos viene bien trabajar con algo que nos obligue a levantar la mirada del código y prestar atención a las condiciones en las que vive la gente que lo usa.

El siguiente aprendizaje puede empezar con un sensor. Y puede terminar cambiando cómo elegimos la solución completa.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## Cuando un grafo no debe recordarlo todo: memoria híbrida para un agente personal en .NET

URL: https://programemos.net/memoria-hibrida-agente-personal-dotnet/
Fecha: 2026-08-25
Categorías: IA, Arquitectura de Software, Programación
Descripción: Cómo combiné Graphiti, FalkorDB y RAG para consultar exámenes médicos históricos sin pagar el costo de convertir cada conversación en un grafo.

Durante un tiempo consulté mis exámenes médicos de la forma más directa posible: le entregaba los archivos a ChatGPT o a la IA que estuviera usando y hacía mis preguntas.

Funcionaba, pero cada examen nuevo hacía crecer el problema. Había que volver a extraer información de imágenes y PDF, el contexto consumía más tokens y la respuesta no siempre priorizaba el resultado más reciente. Podía reconocer que dos hematologías hablaban de los mismos indicadores, pero eso no garantizaba que entendiera bien su evolución.

Terminé construyendo una solución con un grafo temporal. Después descubrí que tampoco tenía sentido guardar cada mensaje de la conversación dentro de ese grafo. Mi solución final fue menos pura y bastante más útil: **Graphiti y FalkorDB para el conocimiento médico histórico; un RAG más simple para la memoria conversacional**.

> **Aviso:** este artículo describe una experiencia personal de arquitectura de software. No es una recomendación médica, no interpreta resultados clínicos y no pretende sustituir la evaluación, el diagnóstico ni el tratamiento de un profesional de la salud. Ninguna decisión médica debería tomarse basándose únicamente en las respuestas de este agente.

Lo comparto porque es un buen ejemplo de cómo una arquitectura cambia cuando deja de ser un tutorial y empieza a encontrarse con datos, costos y decisiones reales.

## El primer ahorro fue dejar de procesar los archivos una y otra vez

Mi primer problema no era todavía el RAG ni el grafo. Eran los documentos.

Los resultados venían en imágenes y PDF. Si se los entregaba directamente al modelo en cada conversación, repetía un trabajo que ya había hecho antes: OCR, interpretación del formato y extracción de valores. Además del consumo de tokens, cada nueva extracción podía introducir pequeñas diferencias.

Por eso separé la ingestión de la consulta. Procesé cada archivo una sola vez, extraje el contenido, normalicé los datos y retiré la información identificable antes de usarla en el flujo de IA. Los archivos originales siguen siendo la fuente, pero el agente trabaja con una representación textual y estructurada preparada de antemano.

Esa decisión parece pequeña, pero cambió el sistema. Ya no estaba preguntando sobre una colección de documentos heterogéneos. Estaba consultando datos que podían relacionarse y ordenarse.

Aquí también hay un límite importante: retirar nombres o identificadores directos no convierte automáticamente un conjunto de datos médicos en anónimo. La privacidad depende de qué otros atributos se conserven, dónde se procese la información y quién pueda acceder. En mi caso, la reducción y protección de esos datos forman parte del pipeline, no son una propiedad mágica del OCR.

## Un RAG puede recuperar datos, pero el tiempo hay que modelarlo

El siguiente paso natural fue un RAG clásico. Troceas el contenido, generas embeddings y recuperas los fragmentos más parecidos a la pregunta.

Eso funciona muy bien cuando la pregunta es semántica: «¿qué decía el informe sobre determinado indicador?». El problema aparece cuando la intención real es temporal y relacional: «¿cómo evolucionó este valor?», «¿qué cambió desde el examen anterior?» o «¿cuál es el resultado vigente?».

Un RAG no es incapaz de responder esas preguntas. Puedes guardar fechas como metadata, filtrar, reordenar por recencia y diseñar una estrategia de recuperación específica. Pero si la relación entre exámenes, indicadores, episodios y fechas es central para el dominio, terminas reconstruyendo parte de ese modelo en cada consulta.

En mis pruebas, la similitud semántica no siempre coincidía con la prioridad que yo necesitaba. Un resultado anterior podía parecer más relevante por su redacción, aunque el examen reciente fuera el que debía dominar la respuesta. El problema no era que el vector store estuviera fallando. **Yo le estaba pidiendo que resolviera una estructura temporal que no había modelado de forma explícita.**

## Graphiti resolvió la historia, no el costo de escribirla

Ahí entró [Graphiti](https://github.com/getzep/graphiti), un framework para construir grafos de contexto temporales. Lo ejecuté sobre [FalkorDB](https://docs.falkordb.com/), que actúa como base de datos de grafos.

La idea de los episodios encajaba especialmente bien con mis exámenes. En Graphiti, un episodio representa un evento de ingestión, conserva el momento de referencia y mantiene la procedencia de las entidades y relaciones que se derivaron de él. Los hechos pueden tener ventanas de validez, de modo que el sistema no solo sabe qué relación existe, sino cuándo era válida y qué información la reemplazó.

En vez de tener fragmentos aislados, pasé a tener conceptos conectados: examen, fecha, tipo de prueba, indicador, valor y relación con resultados anteriores. Eso hizo más naturales las preguntas históricas y redujo el trabajo necesario durante la recuperación.

Pero apareció la pregunta incómoda: **¿de verdad cada mensaje del chat merecía convertirse en conocimiento del grafo?**

Agregar un episodio no es una simple escritura. Graphiti usa modelos para extraer entidades, resolver duplicados, construir relaciones y actualizar la dimensión temporal. Esa ingestión tiene un costo en tokens, latencia y cómputo. Para los exámenes históricos tenía sentido pagarlo una vez: eran datos valiosos, con relaciones duraderas y que no iban a cambiar retroactivamente.

Para una conversación cotidiana, no siempre.

Cuando intenté guardar cada intervención como un episodio, estaba pagando el proceso más costoso del grafo por mensajes cuya utilidad podía durar solo unos minutos. La recuperación era rápida, pero la escritura continua convertía la memoria conversacional en una decisión económicamente difícil de defender.

## La arquitectura híbrida fue la respuesta pragmática

La solución no fue abandonar el grafo. Fue dejar de pedirle que almacenara todo.

Construí el grafo con el conjunto histórico de exámenes y lo mantuve como la fuente especializada para preguntas médicas temporales y relacionales. Para los mensajes de la conversación usé una memoria RAG más sencilla, pensada para recuperar contexto reciente o intercambios anteriores sin extraer un nuevo subgrafo en cada turno.

![Arquitectura híbrida donde los exámenes procesados alimentan un grafo temporal y las conversaciones un RAG antes de llegar al agente .NET](https://programemos.net/images/memoria-hibrida-agente-personal-dotnet-arquitectura.webp)

*El grafo conserva el conocimiento histórico estable; el RAG conversacional absorbe la memoria de mayor rotación.*

El flujo quedó dividido por la naturaleza del dato:

* **Documentos médicos históricos:** OCR, normalización, reducción de datos identificables e ingestión en Graphiti sobre FalkorDB.
* **Conversaciones:** fragmentación, embeddings y recuperación desde un índice más barato de actualizar.
* **Consulta:** el agente decide qué memoria necesita, recupera contexto de una o ambas fuentes y construye la respuesta.

Esta separación también deja una regla para el futuro. Un nuevo examen sí puede justificar un episodio porque agrega hechos que deben relacionarse con la historia anterior. Un «gracias» o una pregunta de seguimiento no necesita pasar por el mismo pipeline.

No es una arquitectura universal. Si tienes pocos documentos, pocas consultas y ninguna pregunta temporal, probablemente basta con cargar los archivos o usar un RAG bien diseñado. Tampoco usaría un grafo si no hay relaciones que valga la pena atravesar. El costo de construir y operar esa capa tiene que devolver algo concreto.

## El agente sigue siendo software, y ahí .NET importa

Implementé la capa conversacional con [Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/). El framework me permitió integrar el modelo, las herramientas y las dos fuentes de memoria desde .NET, sin convertir la solución en un conjunto de scripts desconectados.

Durante las pruebas consumí el agente desde una interfaz web de chat. Me servía para conversar con él y validar el comportamiento, pero esa no es la aplicación final que tengo en mente.

El destino real es una aplicación que construí para consumir varios agentes propios y que comentaré en otro artículo. En ese escenario elegí [A2A](https://a2a-protocol.org/latest/specification/) porque necesito que la aplicación descubra las capacidades de cada agente y se comunique con todos mediante un contrato común. No lo agregué porque estuviera de moda ni porque mejorara la memoria: lo agregué porque existe una frontera real entre la aplicación cliente y varios agentes independientes.

Aquí conviene separar dos piezas que trabajan juntas. **A2A define cómo se presentan y se comunican los agentes; [OAuth 2.0](https://oauth.net/2/) controla quién está autorizado para acceder y con qué permisos.** En mi caso, la aplicación usa OAuth para obtener acceso a esos agentes, mientras A2A resuelve el intercambio entre ellos. La propia especificación de A2A permite declarar esquemas OAuth 2.0 dentro de la `Agent Card`.

Por eso A2A tiene sentido en este caso particular. Para probar un único agente desde un chat web habría podido usar un endpoint convencional. Cuando una aplicación debe integrarse con varios agentes, la interoperabilidad y la autorización dejan de ser detalles y pasan a formar parte de la arquitectura.

Lo menciono porque todavía aparece la idea de que trabajar con IA implica abandonar el ecosistema .NET. Para entrenamiento de modelos, Python mantiene una posición dominante. Para integrar agentes con servicios, persistencia, observabilidad, autenticación y protocolos, la conversación es otra.

Hoy hablamos más de modelos, agentes y protocolos que de lenguajes. Pero detrás de cada demo que llega a producción siguen existiendo decisiones de software. Alguien tiene que diseñar la ingestión, controlar el costo, proteger los datos, observar el sistema y decidir qué merece convertirse en memoria.

En mi caso, pude hacerlo con .NET y exponerlo sin encerrar el agente dentro de ese stack. Para mí, esa es una señal mucho más importante que cualquier comparación superficial de lenguajes.

La versión corta de esta historia podría sonar así: «construí un agente con Graphiti, FalkorDB, RAG y .NET». Pero lo valioso no fue conectar esas piezas.

Lo valioso fue descubrir dónde dejaba de compensar cada una.

El OCR repetido desperdiciaba trabajo. El RAG simple no expresaba por sí solo la historia que necesitaba consultar. El grafo temporal resolvió las relaciones y la vigencia, pero resultaba demasiado costoso para convertir cada mensaje en conocimiento estructurado. La arquitectura híbrida apareció cuando dejé de buscar una sola herramienta para todas las memorias.

Esa es la diferencia entre leer un tutorial y operar algo propio. En el tutorial todas las piezas parecen necesarias. En un sistema real, la pregunta es cuáles merecen seguir ahí cuando empiezas a pagar por cada decisión.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [Graphiti: temporal context graphs for AI agents](https://github.com/getzep/graphiti)
* [Graphiti: ejemplo oficial de incorporación de episodios](https://github.com/getzep/graphiti/blob/main/examples/quickstart/quickstart_neo4j.py)
* [FalkorDB documentation](https://docs.falkordb.com/)
* [Microsoft Agent Framework documentation](https://learn.microsoft.com/en-us/agent-framework/)
* [A2A Protocol specification](https://a2a-protocol.org/latest/specification/)

---

## DevOps también llega a la tienda: CI/CD con .NET MAUI y Android

URL: https://programemos.net/devops-dotnet-maui-android-google-play/
Fecha: 2026-08-19
Categorías: Programación, Opiniones
Descripción: DevOps con .NET MAUI no termina al generar un AAB: exige entender firma, tracks y promoción de versiones antes de automatizar Google Play.

Para mí, DevOps es una cultura, no un puesto. Pero este artículo no va a convertir esa frase en otra discusión sobre cómo debe llamarse cada rol. Me interesa algo más práctico: **entender que DevOps no termina en los servidores ni pertenece únicamente a las aplicaciones web**.

Estamos tan acostumbrados a construir y desplegar aplicaciones web que muchas veces reducimos la entrega a ejecutar el último comando del pipeline. Compilamos, publicamos y desplegamos en un App Service. O copiamos el artefacto a un VPS y reiniciamos un servicio. Como conocemos ese camino, lo resumimos en un paso y dejamos de pensar en todo lo que existe alrededor.

Ahí está la trampa. **El comando de despliegue no es el proceso de entrega**.

Todo lo que deba entregarse de forma repetible en algún destino puede entrar en una conversación DevOps. Ese destino puede ser un clúster, una cuenta de almacenamiento, un dispositivo industrial o una tienda de aplicaciones. Como parte de la entrega continua, nuestra responsabilidad también es conocer cómo funciona ese destino y diseñar el flujo alrededor de sus restricciones.

Con .NET MAUI el ejemplo es bastante claro. No vamos a desplegar un sitio web. Vamos a compilar una aplicación Android, validarla, firmar un Android App Bundle y llevarlo a Google Play. La tienda es parte de nuestro entorno de entrega.

## La entrega continua no siempre termina en un servidor

Cuando hablamos de CI/CD solemos imaginar un flujo que toma el código, crea una imagen de contenedor y la despliega en algún servidor. Ese es un caso común, no la definición completa.

En Azure App Service, por ejemplo, las herramientas abstraen una parte importante del proceso. El pipeline puede autenticarse, publicar el artefacto y desplegarlo en la Web App o en un deployment slot. Eso no significa que no existan decisiones sobre configuración, migraciones, health checks o rollback. Significa que conocemos mejor ese modelo y el camino suele resultarnos familiar.

Con una tienda móvil la conversación cambia. Antes de publicar debemos entender la identidad de firma, la diferencia entre upload key y app signing key, el `versionCode`, los tracks de prueba, los testers, las revisiones, las políticas y la promoción hacia producción. No porque Google Play sea peor. El problema es otro: **el deployment target tiene un modelo operativo diferente**.

En una aplicación móvil cambia el destino, pero no cambia la responsabilidad. Seguimos necesitando responder preguntas conocidas:

- ¿El código compila y las pruebas pasan?
- ¿Podemos generar siempre el mismo tipo de artefacto?
- ¿Quién puede firmarlo y con qué identidad?
- ¿A qué entorno o grupo de usuarios se entrega primero?
- ¿Cómo promovemos una versión sin reconstruir algo distinto?
- ¿Qué hacemos si la entrega falla o Google Play la rechaza?
- ¿Qué track representa QA, preproducción o producción para nuestro equipo?

Aquí también conviene separar términos cercanos. La **integración continua** valida cada cambio y evita que acumulemos sorpresas. La **entrega continua** mantiene la aplicación en condiciones de ser liberada y puede llevarla automáticamente a un entorno previo, como el track interno de Google Play. Cuando cada cambio aprobado llega automáticamente a los usuarios de producción, hablamos con más precisión de **despliegue continuo**.

Los dos últimos conceptos comparten las siglas CD y por eso se mezclan con frecuencia. No me preocupa convertirlo en una pelea semántica. Me preocupa que llamemos entrega continua a un pipeline que solo deja un archivo perdido entre los artefactos. Un `.aab` compilado es un resultado técnico; una versión disponible para probar o publicar ya forma parte de un proceso de entrega.

## El destino también forma parte del diseño

Este no es un tutorial sobre cómo abrir una cuenta de Google Play, completar la ficha de la aplicación o resolver cada pantalla de Play Console. Ese proceso tiene sus propias reglas y cambia con el tiempo. Repetirlo paso a paso nos alejaría del punto que quiero discutir.

Lo que sí debemos entender es el modelo de releases del sitio donde vamos a desplegar. Google Play no organiza el ciclo con ambientes llamados literalmente `QA`, `staging` y `production`. Ofrece [tracks de prueba](https://support.google.com/googleplay/android-developer/answer/9845334) con distintos niveles de exposición:

- `internal` permite distribuir versiones rápidamente a un grupo pequeño para las primeras validaciones.
- `closed` permite probar con grupos controlados y ampliar la validación sin exponer la versión a todo el público.
- `open` funciona como una prueba más amplia a la que pueden incorporarse usuarios.
- `production` es el track disponible para los usuarios finales y también permite hacer [staged rollouts](https://support.google.com/googleplay/android-developer/answer/6346149) en las actualizaciones.

Esos tracks no deciden nuestro proceso. Lo decidimos nosotros. Un equipo puede usar `internal` como QA y `closed` como preproducción. Otro puede mantener varios closed tracks para grupos o funcionalidades distintas. Una aplicación pequeña quizá solo necesite `internal` antes de producción. La herramienta ofrece mecanismos; la estrategia de entrega sigue siendo una decisión de ingeniería.

Aquí está el detalle importante: no deberíamos tomar un pipeline web, cambiar el último comando y asumir que ya entendimos DevOps para aplicaciones móviles. Primero debemos definir quién recibe cada versión, qué validaciones permiten promoverla, qué credencial puede hacerlo y cómo actuamos cuando la versión tiene un problema.

Para este ejemplo voy a usar el track `internal` como primer destino desplegable. El flujo será deliberadamente sencillo:

1. Cada pull request restaura dependencias, ejecuta pruebas y compila el target Android.
2. Cada cambio aceptado en `main` vuelve a validar la aplicación.
3. El pipeline genera un `.aab` firmado con la **upload key**.
4. GitHub Actions conserva ese bundle como artefacto trazable.
5. La misma ejecución lo publica en el track `internal` de Google Play.
6. La promoción hacia producción queda separada y puede requerir aprobación.

Google Play usa [Play App Signing](https://developer.android.com/studio/publish/app-signing): nosotros firmamos el bundle con la clave de carga y Google administra la clave con la que se firman los APK que finalmente reciben los dispositivos. La diferencia importa. La clave privada no debe vivir en el repositorio ni copiarse de manera informal entre equipos.

El track interno no es un simple directorio temporal. Es un destino de despliegue administrado por Google Play, con testers y versiones propias. Producción es otro destino. La infraestructura no tiene que ser un servidor para que exista una estrategia de ambientes.

Para seguir el ejemplo usaré .NET 10 y estos valores de muestra:

```text
Proyecto MAUI: src/MyApp/MyApp.csproj
Proyecto de pruebas: tests/MyApp.Tests/MyApp.Tests.csproj
Target Android: net10.0-android
ApplicationId: net.programemos.myapp
Destino inicial: Google Play Internal Testing
```

Debes sustituir las rutas y el `ApplicationId` por los de tu proyecto. Ese identificador tiene que coincidir exactamente con el package name registrado en Google Play.

## Lo que el pipeline debe conocer antes de ejecutar

No voy a explicar paso a paso cómo crear la aplicación o la cuenta en Google Play. No es el objetivo de este artículo ni quiero convertirlo en un tutorial de Android. Pero tampoco voy a esconder esos requisitos detrás del YAML, porque el pipeline depende de ellos.

Antes de automatizar debemos saber, como mínimo, que:

- la aplicación debe existir en Play Console y su package name debe coincidir con nuestro `ApplicationId`;
- la acción de publicación que usaremos presupone una primera carga manual del APK o AAB para registrar ese package en Play Console;
- Play App Signing y la upload key forman parte del modelo de confianza de la publicación;
- la service account necesita permisos sobre la aplicación y los tracks que realmente utilizará;
- los testers y tracks deben estar definidos según el flujo de validación del equipo;
- las políticas, declaraciones y revisiones de Google Play pueden detener una release aunque el pipeline esté en verde.

Automatizar no significa que una plataforma externa deje de tener reglas. Significa que entendemos esas reglas lo suficiente para convertirlas en un proceso repetible.

En la práctica, el pipeline presupone que la aplicación ya existe en Play Console, que la configuración obligatoria está completa y que Play App Signing está activo. Las cuentas personales creadas después del 13 de noviembre de 2023 deben cumplir los [requisitos de pruebas para acceder a producción](https://support.google.com/googleplay/android-developer/answer/14151465): actualmente, una prueba cerrada con al menos 12 testers inscritos durante 14 días continuos antes de solicitar ese acceso. El pipeline no evita políticas, revisiones ni declaraciones pendientes de la tienda.

Luego genera una upload key. Este comando se ejecuta una vez, no en cada build:

```bash
keytool -genkeypair -v \
  -keystore upload.keystore \
  -alias upload \
  -keyalg RSA \
  -keysize 2048 \
  -validity 10000
```

Guarda una copia recuperable del keystore y sus contraseñas fuera de GitHub. Perder la clave de carga tiene solución mediante el proceso de restablecimiento de Google Play, pero convertir eso en el procedimiento normal agrega una fricción completamente innecesaria.

Después prepara el acceso automatizado:

1. Habilita Google Play Developer API en un proyecto de Google Cloud.
2. Crea una service account.
3. Invita su correo desde **Users and permissions** de Play Console.
4. Dale acceso únicamente a esta aplicación y concede [**View app information and download bulk reports (read only)** junto con **Release apps to testing tracks**](https://support.google.com/googleplay/android-developer/answer/9844686), que es el permiso que permite crear y desplegar releases de prueba. No concedas **Release to production** a esta identidad.
5. Crea en GitHub el Environment `google-play-internal`.
6. Agrega los secretos de firma y publicación dentro de ese Environment.
7. Protege `main` con un ruleset o branch protection que exija el check [**Validate Android app** antes del merge](https://docs.github.com/en/pull-requests/reference/status-checks).

La [guía de Google Play Developer API](https://developers.google.com/android-publisher/getting_started) explica la relación entre Google Cloud, la service account y Play Console. No le daría permiso de producción a una credencial cuyo único trabajo es entregar versiones internas. Ese límite no es decoración de seguridad: expresa qué parte del release process puede ejecutar esa identidad.

Estos son los secretos que usará el workflow:

| Secreto | Contenido |
| --- | --- |
| `ANDROID_KEYSTORE_BASE64` | `upload.keystore` convertido a Base64 |
| `ANDROID_KEY_ALIAS` | Alias de la upload key, por ejemplo `upload` |
| `ANDROID_KEY_PASSWORD` | Contraseña de la clave |
| `ANDROID_STORE_PASSWORD` | Contraseña del keystore |
| `GOOGLE_PLAY_SERVICE_ACCOUNT_JSON` | JSON completo de la service account |

En PowerShell puedes obtener el valor Base64 del keystore así:

```powershell
[Convert]::ToBase64String([IO.File]::ReadAllBytes("./upload.keystore"))
```

El Base64 no cifra el keystore. Solo permite almacenarlo como texto dentro de un secreto. La protección real está en el control de acceso al Environment, el alcance mínimo de la service account y el respaldo seguro de la clave.

Para mantener el ejemplo legible usaré el JSON de la service account como secreto. Es válido, pero sigue siendo una credencial de larga duración. En una organización que ya trabaje con OIDC preferiría Workload Identity Federation y credenciales temporales; la acción también admite ese flujo. No voy a desarrollarlo aquí porque cambia la autenticación, no la idea central del release pipeline.

## Un pipeline de GitHub Actions para demostrarlo

Ahora sí podemos bajar la idea a código. Crea `.github/workflows/android-ci-cd.yml` con este flujo y adapta las rutas del bloque `env`:

```yaml
name: Android CI/CD

on:
  pull_request:
  push:
    branches: [main]
  workflow_dispatch:

permissions:
  contents: read

env:
  DOTNET_VERSION: '10.0.x'
  MAUI_PROJECT: 'src/MyApp/MyApp.csproj'
  TEST_PROJECT: 'tests/MyApp.Tests/MyApp.Tests.csproj'
  ANDROID_TFM: 'net10.0-android'
  APPLICATION_ID: 'net.programemos.myapp'

jobs:
  validate:
    name: Validate Android app
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

      - name: Setup .NET
        uses: actions/setup-dotnet@d4c94342e560b34958eacfc5d055d21461ed1c5d # v5.0.0
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      - name: Install .NET MAUI Android workload
        run: dotnet workload install maui-android

      - name: Restore
        run: |
          dotnet restore "$MAUI_PROJECT"
          dotnet restore "$TEST_PROJECT"

      - name: Test
        run: dotnet test "$TEST_PROJECT" --configuration Release --no-restore

      - name: Build Android target
        run: >-
          dotnet build "$MAUI_PROJECT"
          --framework "$ANDROID_TFM"
          --configuration Release
          --no-restore

  deliver-internal:
    name: Deliver to Google Play Internal
    if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main'
    needs: validate
    runs-on: ubuntu-latest
    environment: google-play-internal
    concurrency:
      group: ${{ github.repository }}-google-play-internal
      queue: max

    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

      - name: Setup .NET
        uses: actions/setup-dotnet@d4c94342e560b34958eacfc5d055d21461ed1c5d # v5.0.0
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      - name: Install .NET MAUI Android workload
        run: dotnet workload install maui-android

      - name: Restore app
        run: dotnet restore "$MAUI_PROJECT"

      - name: Define version
        shell: bash
        run: |
          echo "VERSION_CODE=$((10000 + GITHUB_RUN_NUMBER))" >> "$GITHUB_ENV"
          echo "DISPLAY_VERSION=1.0.${GITHUB_RUN_NUMBER}" >> "$GITHUB_ENV"

      - name: Restore signing material
        shell: bash
        env:
          ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
          ANDROID_STORE_PASSWORD: ${{ secrets.ANDROID_STORE_PASSWORD }}
        run: |
          umask 077
          printf '%s' "$ANDROID_KEYSTORE_BASE64" | base64 --decode > "$RUNNER_TEMP/upload.keystore"
          printf '%s' "$ANDROID_KEY_PASSWORD" > "$RUNNER_TEMP/key-pass.txt"
          printf '%s' "$ANDROID_STORE_PASSWORD" > "$RUNNER_TEMP/store-pass.txt"

      - name: Publish signed Android App Bundle
        shell: bash
        env:
          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
        run: |
          dotnet publish "$MAUI_PROJECT" \
            --framework "$ANDROID_TFM" \
            --configuration Release \
            --no-restore \
            -p:ApplicationId="$APPLICATION_ID" \
            -p:ApplicationVersion="$VERSION_CODE" \
            -p:ApplicationDisplayVersion="$DISPLAY_VERSION" \
            -p:AndroidPackageFormats=aab \
            -p:AndroidKeyStore=true \
            -p:AndroidSigningKeyStore="$RUNNER_TEMP/upload.keystore" \
            -p:AndroidSigningKeyAlias="$ANDROID_KEY_ALIAS" \
            -p:AndroidSigningKeyPass="file:$RUNNER_TEMP/key-pass.txt" \
            -p:AndroidSigningStorePass="file:$RUNNER_TEMP/store-pass.txt"

      - name: Keep signed bundle as workflow artifact
        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
        with:
          name: android-signed-aab-${{ github.run_number }}
          path: '**/bin/Release/${{ env.ANDROID_TFM }}/publish/*-Signed.aab'
          if-no-files-found: error

      - name: Upload to Google Play Internal Testing
        uses: r0adkll/upload-google-play@e738b9dd8f2476ea806d921b64aacd24f34515a5 # v1.1.5
        with:
          serviceAccountJsonPlainText: ${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT_JSON }}
          packageName: ${{ env.APPLICATION_ID }}
          releaseFiles: '**/bin/Release/${{ env.ANDROID_TFM }}/publish/*-Signed.aab'
          tracks: internal
          status: completed
```

La [documentación de .NET MAUI](https://learn.microsoft.com/en-us/dotnet/maui/android/deployment/publish-cli?view=net-maui-10.0) recomienda ejecutar `dotnet publish` sobre el proyecto de la aplicación, no sobre toda la solución, y permite pasar las contraseñas de firma mediante archivos. Esto último evita colocarlas directamente como propiedades visibles del comando.

El `ApplicationVersion` merece atención. Google Play exige que cada nueva entrega use un [`versionCode` superior](https://developer.android.com/studio/publish/versioning). Usar `GITHUB_RUN_NUMBER` con un desplazamiento sencillo mantiene el ejemplo legible. En un producto con más de un pipeline o con una numeración existente, define una estrategia compartida para no generar colisiones.

![Flujo de entrega de una aplicación .NET MAUI desde GitHub hasta un bundle firmado, Google Play Internal Testing y los teléfonos de prueba](https://programemos.net/images/devops-dotnet-maui-android-google-play-flujo.webp)

*El destino cambia: repositorio, validación, firma, track interno y finalmente usuarios. La responsabilidad de entrega sigue siendo la misma.*

El último paso usa la acción mantenida en [`r0adkll/upload-google-play`](https://github.com/r0adkll/upload-google-play), que llama a Google Play Developer API. Todas las acciones del ejemplo están [fijadas a commits completos](https://docs.github.com/en/actions/reference/security/secure-use) para ejecutar exactamente el código revisado; los comentarios conservan la versión legible y facilitan actualizaciones controladas. En una organización también usaría únicamente acciones aprobadas por el equipo.

La concurrencia serializa las publicaciones al track interno. La API de Google Play trabaja con edits y dos releases simultáneas pueden entrar en conflicto; `queue: max` conserva las ejecuciones pendientes y las procesa en orden en lugar de lanzar varios deployments al mismo destino a la vez.

Hay otra frontera de confianza que el YAML no puede resolver solo. Durante `dotnet publish`, el proyecto MSBuild se ejecuta en el mismo runner que contiene la upload key. Por eso proteger `main`, revisar cambios en el proyecto y en el workflow, limitar quién puede aprobar el Environment y exigir el status check no son controles opcionales alrededor del pipeline: son parte de la protección de la firma.

Lo valioso de este workflow no es que tenga pocas líneas. Es que representa decisiones que tomamos antes: el pull request solo valida, `main` genera una release firmada, la credencial solo puede entregar a testing y el primer deployment target es `internal`. Si copiamos los comandos sin entender esas decisiones, tendremos automatización, pero no necesariamente un buen proceso de entrega.

## Llevar una versión a la tienda no termina el trabajo

El workflow informa si un pull request está roto, pero no bloquea el merge por sí solo. Cuando `main` exige **Validate Android app** como required status check, un cambio que no restaura, no pasa las pruebas o no compila no puede fusionarse por la vía normal. Después del merge, el cambio aceptado termina disponible para testers internos. Eso ya es mucho más útil que producir manualmente un `.aab`, buscarlo en una carpeta y subirlo desde una computadora personal.

Pero no confundiría automatización con madurez. Todavía quedan decisiones de producto y operación:

- Las pruebas unitarias no sustituyen una prueba real en dispositivos y versiones de Android relevantes.
- Google Play puede detener una entrega por políticas, permisos sensibles o formularios pendientes.
- Un lanzamiento móvil no tiene el mismo rollback inmediato de un servidor; muchas veces corregimos publicando una versión nueva con un `versionCode` superior.
- El track interno valida distribución, no demuestra por sí solo que la aplicación funciona bien para usuarios reales.
- Promover automáticamente a producción solo tiene sentido si el equipo tiene pruebas, telemetría y capacidad de respuesta acordes con ese riesgo.

Yo empezaría con entrega automática al track interno. Después agregaría un Environment separado para producción, permisos distintos y una aprobación antes de promover la versión ya validada. Los [GitHub Environments](https://docs.github.com/en/actions/concepts/workflows-and-actions/deployment-environments) permiten aplicar revisores, restricciones de ramas y secretos por destino.

No porque poner una aprobación haga al proceso más DevOps. Lo hace razonable cuando la tienda, las políticas y la experiencia del usuario introducen un costo de recuperación diferente.

La pregunta incómoda no es si sabemos escribir el comando que sube un `.aab`. Es si entendemos qué ocurre después de ejecutarlo. Quién recibe la versión, qué versión obtiene un tester elegible para varios tracks, cómo se incrementa el `versionCode`, qué señales observamos y qué capacidad real tenemos para corregir un fallo.

Para mí, esa es la idea que vale la pena conservar: DevOps no depende de que exista un servidor al final del diagrama. Depende de que el equipo piense cómo un cambio se integra, se valida, se entrega y se opera. En .NET MAUI, Google Play forma parte del sistema de entrega y su track `production` es uno de nuestros deployment targets de producción.

El pipeline no es el objetivo. El objetivo es que llevar una aplicación desde el código hasta las manos de quien la usa deje de ser una ceremonia manual y se convierta en un proceso confiable.

Si quieres profundizar en esta forma de pensar, también puedes leer [La IA no acabó con DevOps: nos obliga a volver a entregar valor](https://programemos.net/ia-cambio-devops-entrega-valor/).

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## No todo necesita agentes de IA: el criterio de ingeniería sigue importando

URL: https://programemos.net/no-todo-necesita-agentes-ia-criterio-ingenieria/
Fecha: 2026-08-06
Categorías: Opiniones, IA, Programación
Descripción: Los agentes de IA pueden elevar la calidad, pero también el costo y la complejidad. Cómo decidir cuándo usarlos y cuándo basta algo más simple.

Hay algo que se está repitiendo mucho con la IA: como ahora podemos crear agentes para casi todo, empezamos a tratar cada tarea como si necesitara uno. Y si un agente funciona, parece que el siguiente paso natural es montar cinco más para que se revisen entre ellos.

Yo no lo veo así.

He visto usar el modelo más caro disponible para redactar un mensaje de commit. También he visto tareas pequeñas pasar por agentes, handoffs y revisiones que cuestan más que resolver el problema directamente. Técnicamente funciona, pero eso no la convierte en una buena decisión.

En ingeniería no basta con decir que el problema quedó resuelto. También importan el costo, la confiabilidad, el tiempo y la complejidad que dejamos detrás. Para mí, ahí está el valor del criterio técnico: **saber qué conviene automatizar y hasta dónde tiene sentido hacerlo**.

## Lo que realmente significa dejar de leer el código

Robert C. Martin, el autor de *Clean Code*, ha dicho que ya no lee el código que producen sus agentes. La frase suena extrema, sobre todo viniendo de alguien que pasó años hablando sobre cómo escribir código para que otros pudieran entenderlo.

Ahora bien, su proceso no consiste en pedir código y aceptarlo a ciegas. En [SwarmForge](https://github.com/unclebob/swarm-forge) hay especificaciones, TDD, pruebas de aceptación, cobertura, mutation testing, métricas de complejidad, revisión arquitectónica y QA. Hay prompts, pero también scripts y comprobaciones deterministas.

Es decir, Martin no dejó de revisar. Cambió lo que revisa y la forma de obtener confianza.

En esa parte estoy de acuerdo. La IA puede producir más código del que una persona alcanza a leer con atención. Si intentamos revisar manualmente cada línea, la revisión termina siendo el cuello de botella y, muchas veces, un trámite. El problema es convertir esa forma de trabajo en una solución general.

## Una buena solución también puede ser demasiado

El flujo más completo de SwarmForge separa el trabajo entre seis agentes: uno especifica, otro programa, otro limpia, uno revisa arquitectura, otro endurece las pruebas y uno hace QA. Para un proyecto grande, con suficiente riesgo y varias tareas que realmente se pueden separar, puedo entenderlo.

Para resolver una función pequeña, no.

Ahí ya no estamos hablando de calidad. Estamos metiendo una capa de coordinación que también consume tokens, tiempo y contexto. Cada agente tiene que entender el trabajo, recibir un handoff, revisar algo y dejar información para el siguiente. Todo eso tiene un costo aunque no aparezca dentro del código final.

El propio repositorio ofrece flujos de dos, cuatro y seis agentes según el tamaño del trabajo. Me parece una decisión razonable porque reconoce algo que a veces olvidamos: más agentes no significa automáticamente mejor ingeniería.

Lo mismo aplica al ejemplo del commit. Si solo necesito resumir un cambio en una línea, quizá basta con una plantilla, un modelo más económico o escribirlo yo mismo. No necesito darle acceso a medio repositorio al modelo más costoso para ahorrarme unos segundos.

## Lo determinista no debería gastar tokens por costumbre

Muchas de las comprobaciones que rodean a un agente no necesitan otro agente. Ejecutar pruebas, validar el formato de un handoff, medir cobertura, correr el linter o comprobar que un archivo existe son tareas deterministas.

Si puedo expresar la regla de forma exacta, prefiero ponerla en código:

- un hook de Git para una validación local;
- un linter o analizador estático para reglas de código;
- una prueba automatizada para comportamiento verificable;
- un pipeline para bloquear cambios que no cumplen condiciones;
- un script pequeño para formatos y archivos obligatorios.

Luego puedo usar un agente para interpretar el resultado, investigar un fallo o proponer una corrección. Ahí sí aporta. Lo que no tiene sentido es pagar razonamiento generativo para decidir algo que un `if` puede responder siempre de la misma manera.

### Un caso real: este blog

Este mismo blog me sirve como ejemplo. Desde que [lo migré de WordPress a Astro](https://programemos.net/de-wordpress-a-astro-con-ia/), he ido separando las decisiones editoriales de las validaciones que puede ejecutar una herramienta. Para crear o reescribir un artículo sí uso un agente, porque hay que entender una idea, ordenar argumentos, revisar fuentes y tomar decisiones. No todo eso se puede reducir a una regla.

Pero no uso otro agente para decidir si el `seoTitle` es demasiado largo, si falta una imagen o si la hero mide `720x340`. Tampoco le pregunto a una IA si el sitio compila. Esas comprobaciones ya tienen una respuesta exacta y las ejecuto así:

```bash
node ./scripts/validate-blog-post.mjs --file src/content/blog/no-todo-necesita-agentes-ia-criterio-ingenieria.mdx
pnpm build
git diff --check
```

El validador comprueba el frontmatter, las rutas de las imágenes, sus copias y las dimensiones de la hero. El build verifica el sitio real. Si algo falla, entonces el agente puede leer el resultado y corregirlo. La decisión importante fue separar lo que necesita criterio de lo que simplemente necesita una condición que siempre se cumpla.

![Árbol de decisión que separa validaciones deterministas, tareas simples para un agente y problemas complejos para varios agentes](https://programemos.net/images/no-todo-necesita-agentes-ia-criterio-ingenieria-decision.webp)

*La cantidad de agentes debería responder a la complejidad y al riesgo del problema, no a la novedad de la herramienta.*

Mi regla se puede resumir así:

```text
Regla estable y repetible       -> script, prueba o pipeline
Tarea acotada con ambigüedad    -> un agente
Trabajo complejo e independiente -> varios agentes
Seguridad, dinero o datos       -> revisión humana explícita
```

No es una fórmula matemática. Es una forma rápida de evitar que la herramienta más llamativa se convierta automáticamente en la primera opción.

No empezaría por la orquestación para después buscarle un problema.

## No revisar todo tampoco significa no revisar nada

Tampoco quiero defender la revisión tradicional como si funcionara perfectamente. Un pull request con miles de líneas no se revisa de verdad mirando el diff durante unos minutos. Se aprueba, pero eso no quiere decir que alguien entendió cada cambio.

Ahora, pasar de ahí a no revisar nada también es un extremo. Las pruebas verifican lo que pensamos en probar. La cobertura dice qué código se ejecutó, no si el comportamiento es correcto. El mutation testing ayuda, pero tampoco conoce todas las reglas del negocio. Ninguna métrica puede decidir por nosotros si una arquitectura tiene sentido para la empresa que la va a mantener.

Yo haría la revisión proporcional al riesgo. Una actualización mecánica de dependencias no merece la misma atención que un cambio en autenticación, dinero, permisos, concurrencia o migración de datos.

Pondría la atención humana en:

- la especificación y los criterios de aceptación;
- los límites de seguridad y los permisos;
- las decisiones arquitectónicas difíciles de revertir;
- los cambios de datos y contratos públicos;
- las partes donde un fallo tiene consecuencias importantes;
- el comportamiento real del sistema una vez desplegado.

El resto puede apoyarse mucho más en automatización. No necesito leer todo con la misma intensidad, pero sí necesito saber dónde un error sería costoso y dónde las validaciones automáticas no son suficientes.

## Clean Code fue una referencia, no una receta

Nunca he sido muy fanático de seguir *Clean Code* al pie de la letra. Tiene cosas buenas y puso sobre la mesa ideas importantes sobre legibilidad y diseño. Mi problema siempre ha sido tratar el libro como una receta.

Sobre el papel muchas reglas se ven correctas. En la práctica, aplicarlas sin contexto puede terminar en más capas, más abstracciones y más código para mantener. Ya pasaba con la arquitectura antes de la IA. Ahora corremos el riesgo de hacer lo mismo con el proceso de desarrollo: agregar agentes y controles porque se ven bien en el diagrama, no porque el problema los necesite.

Además, para llegar al punto de no leer el código primero necesitas mucho criterio. Hay que saber qué restricciones definir, qué medir, qué riesgo no cubren las pruebas y qué decisiones no conviene delegar. Copiar un framework es fácil. Saber si ese framework es demasiado para tu problema es otra cosa.

Para mí, ahí está el valor del background técnico. No en saber configurar la mayor cantidad de agentes, sino en reconocer cuándo esa complejidad no devuelve nada.

## El criterio es parte de la solución

Antes de añadir otro agente a un flujo, me haría preguntas bastante simples:

- ¿Qué riesgo concreto reduce?
- ¿Qué puede hacer mejor que una prueba, un script o un único agente?
- ¿Cuánto contexto, tiempo y dinero consume?
- ¿Cómo sabremos que tomó una decisión incorrecta?
- ¿Quién entiende y mantiene el proceso cuando falle?
- ¿El problema tiene suficiente tamaño o paralelismo para justificar la coordinación?

Si no tengo respuestas claras, probablemente estoy comprando complejidad sin saber qué valor me devuelve.

No creo que el camino sea leer manualmente cada línea producida por IA. Tampoco creo que sea entregar todo a una cadena de agentes y confiar en que más pasos significan más calidad. Hay cosas que conviene delegar, cosas que conviene validar con herramientas y cosas que todavía necesitan una decisión humana.

La ingeniería no es solamente lograr que algo funcione. Es lograrlo con un costo razonable, con suficiente confianza y sin dejar un sistema que nadie entiende. Los agentes pueden ayudar mucho, pero decidir cuánto es suficiente sigue siendo nuestro trabajo.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## Después de DevOps viene la ingeniería de producto

URL: https://programemos.net/devops-ingenieria-producto-ia/
Fecha: 2026-07-30
Categorías: IA, Opiniones, Programación
Descripción: La IA está reduciendo las fronteras entre desarrollo, operaciones y negocio. El perfil que gana valor es el ingeniero de producto.

Durante buena parte de mi carrera me he definido como desarrollador .NET y como alguien que trabaja en DevOps. Pero si miro cómo ha cambiado mi trabajo en los últimos años, la balanza se inclina cada vez menos hacia una tecnología concreta y cada vez más hacia una responsabilidad completa sobre lo que entregamos.

Para mí, esa es la conversación importante sobre la inteligencia artificial.

Se habla mucho de cuánto código puede generar, si hay que revisarlo y si un agente reemplazará a un programador. Todo eso forma parte del cambio, pero ya hay demasiadas discusiones centradas en el código. Lo interesante es lo que viene después: **cuando producir software se vuelve más barato, el valor se mueve hacia entender el producto, operar el sistema y responder por el resultado**.

Mi lectura es que DevOps fue una transición en esa dirección. El ingeniero de producto será el perfil que termine de juntar esas piezas.

## El cambio ya se veía antes de la IA

Cuando empecé a trabajar como desarrollador, gran parte de mi identidad profesional estaba ligada al stack. Era desarrollador .NET. Otros eran programadores Java, PHP o JavaScript. La tecnología decía bastante sobre el trabajo que hacíamos y sobre las vacantes a las que podíamos aplicar.

Con el tiempo empecé a participar más en despliegues, infraestructura, seguridad, observabilidad y automatización. No fue un cambio de profesión. Fue una consecuencia natural de llevar el software hasta producción.

Ahí entendí que completar una funcionalidad no era terminar el trabajo. También había que conseguir que se desplegara de forma segura, saber qué hacer cuando fallara, vigilar sus costos y comprobar que realmente resolviera el problema.

Por eso la balanza se fue inclinando hacia DevOps. No porque programar dejara de importar, sino porque el código era una parte cada vez más pequeña de la responsabilidad completa.

La IA acelera esa tendencia. Hoy puede ayudar a escribir una clase, preparar un pipeline, generar infraestructura o investigar un error. Mañana hará más. Pero el cambio de fondo ya había empezado: las empresas no necesitan código por el código mismo. Necesitan productos que funcionen, que se puedan operar y que produzcan algún resultado.

## DevOps tampoco es el destino final

DevOps ganó valor porque eliminó una separación artificial. Durante años actuamos como si desarrollo terminara cuando el código llegaba a un repositorio y desde ahí comenzara el problema de otra persona.

Eso nunca funcionó demasiado bien.

Un equipo podía entregar una aplicación técnicamente correcta que fuera difícil de desplegar, imposible de observar o demasiado costosa de mantener. DevOps nos obligó a mirar el ciclo completo y a entender que construir y operar no eran dos trabajos aislados.

Pero ahora corremos el riesgo de convertir DevOps en otra especialidad cerrada. Si pensamos que consiste en escribir YAML, administrar pipelines, preparar manifiestos o levantar infraestructura, la IA también reducirá buena parte de ese trabajo. Igual que ocurre con el código, el artefacto se vuelve más fácil de producir.

Ya escribí sobre por qué [la IA no acaba con DevOps, sino que lo obliga a volver a la entrega de valor](https://programemos.net/ia-cambio-devops-entrega-valor/). Este artículo parte de ahí y da un paso más: incluso el término DevOps puede quedarse corto cuando la persona todavía recibe decisiones de producto tomadas por otros y solo se responsabiliza por ejecutarlas bien.

La siguiente frontera no está entre desarrollo y operaciones. Está entre tecnología y producto.

## La IA reduce las fronteras entre especialidades

Antes necesitábamos repartir muchas tareas porque cada una consumía bastante tiempo y exigía herramientas distintas. Una persona escribía el backend, otra preparaba la interfaz, otra configuraba el pipeline y otra analizaba lo que pedía el negocio.

La especialización seguirá existiendo. Un sistema financiero no deja de necesitar seguridad, ni una plataforma de gran escala deja de necesitar personas con profundidad en redes, datos o rendimiento. El punto no es que ahora todos sepamos de todo.

El cambio es que la IA permite que una persona cubra una porción más amplia del proceso sin quedarse atrapada en cada detalle mecánico. Puede entender un repositorio que no conoce, crear una primera versión, automatizar parte del despliegue, consultar la telemetría y ajustar la solución. Lo que antes pasaba por varias colas de trabajo puede ocurrir dentro de un mismo ciclo.

![Evolución desde trabajar sobre el código de forma aislada hasta conectar automatización, operación y métricas de producto](https://programemos.net/images/devops-ingenieria-producto-ia-flujo.webp)

*La IA reduce el costo de producir artefactos. El valor se mueve hacia conectar el problema, la entrega y el resultado.*

Eso no elimina al equipo. Lo vuelve más importante. La diferencia es que las personas ya no necesitan organizarse alrededor de cada herramienta, sino alrededor del problema que intentan resolver.

Aquí también aparece una responsabilidad nueva: construir los mecanismos que permitan usar la IA con confianza. Reglas, pruebas, permisos, observabilidad y límites operativos forman parte del trabajo. Pero no son el centro del artículo ni deberían convertirse en otro fin técnico. Sirven para que podamos delegar ejecución sin perder control sobre el producto.

La investigación de [DORA sobre desarrollo asistido por IA](https://dora.dev/research/2025/dora-report/) usa una idea que resume bien este punto: la IA actúa como un amplificador. Una organización con objetivos claros, buenos ciclos de feedback y una plataforma confiable puede avanzar más rápido. Una organización desordenada solo produce desorden con mayor velocidad.

## Qué entiendo por ingeniero de producto

Un ingeniero de producto es un perfil técnico que no mide su trabajo por la cantidad de código, tickets o despliegues que completa. Se responsabiliza por resolver un problema y cerrar el ciclo.

Eso significa entender qué necesita el usuario, participar en la decisión de qué construir, elegir una solución técnica razonable, llevarla a producción y mirar qué ocurrió después. Si la funcionalidad se desplegó perfectamente pero nadie la usa, el trabajo no fue exitoso.

No es un product manager que aprendió a programar. Tampoco es un desarrollador full stack con un título nuevo. La diferencia está en el tipo de responsabilidad.

El ingeniero de producto combina:

- **Conocimiento técnico**, para construir soluciones que se puedan mantener y operar.
- **Criterio de producto**, para distinguir una necesidad real de una lista de funcionalidades.
- **Lectura del negocio**, para entender qué resultado justifica el esfuerzo y el costo.
- **Capacidad operativa**, para desplegar, observar y corregir lo que ocurre en producción.
- **Comunicación**, para trabajar directamente con usuarios, producto, diseño y otras especialidades.

No tiene que ser la persona más profunda en cada área. De hecho, pretender que una sola persona reemplace a todo el equipo sería una mala interpretación. Necesita profundidad suficiente en algunas capacidades y amplitud para conectar las demás.

Para mí, el cambio más importante es dejar de pensar: “mi parte ya está lista”. El ingeniero de producto puede pedir ayuda a especialistas, pero no entrega la responsabilidad junto con el ticket.

## Las vacantes cambiarán después que el trabajo

Creo que veremos menos perfiles definidos solamente por una tecnología y más búsquedas que mezclen ingeniería, producto y negocio. No estoy seguro de que en un año desaparezcan las vacantes de desarrollador .NET, JavaScript o PHP. Las empresas y sus títulos cambian más lento que las herramientas.

Pero el trabajo detrás de esas vacantes sí está cambiando.

Una empresa puede seguir publicando una posición para desarrollador .NET, aunque espere que esa persona use IA, converse con usuarios, entienda el despliegue, mire métricas y participe en decisiones que antes pertenecían a otras funciones. El nombre será el mismo durante un tiempo. La expectativa no.

También seguirán existiendo especialistas. No todo producto necesita el mismo nivel de amplitud y no todo sistema permite que una sola persona recorra el ciclo completo. En organizaciones grandes habrá equipos de plataforma, seguridad, datos y confiabilidad. La ingeniería de producto no elimina esas disciplinas; evita que el producto se pierda entre ellas.

El riesgo está en el otro extremo: convertir “ingeniero de producto” en una forma elegante de pedir que una persona haga cinco trabajos. Si el cambio solo sirve para reducir equipo y acumular responsabilidades, no estamos creando un perfil mejor. Estamos creando agotamiento.

La idea tiene sentido cuando la IA y la plataforma reducen de verdad la carga mecánica, el equipo conserva apoyo especializado y la persona gana capacidad para tomar decisiones. Sin eso, el título es solo marketing para una vacante.

## Ya no quiero definirme por la herramienta

Sigo siendo desarrollador .NET. Sigo trabajando con DevOps. Esa experiencia no desaparece ni pierde valor.

Lo que cambia es dónde pongo la identidad profesional. .NET es una capacidad. DevOps me enseñó a llevar una solución hasta producción. La ingeniería de producto junta esa base técnica con la pregunta que siempre debió estar primero: ¿qué problema estamos resolviendo y cómo sabemos que lo resolvimos?

La IA hará más corta una parte importante del camino. Nos ayudará con código, infraestructura, pruebas, análisis y operación. No creo que eso reduzca el trabajo a escribir prompts. Al contrario, nos obliga a ampliar el campo de visión.

El perfil que gana valor no es el que compite con la IA para producir más artefactos. Es el que entiende al usuario, usa la tecnología disponible, conecta las piezas y se responsabiliza por el resultado.

Para mí, DevOps no desaparece. Se integra. Y el lugar donde termina integrándose es la ingeniería de producto.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## La IA no acabó con DevOps: nos obliga a volver a entregar valor

URL: https://programemos.net/ia-cambio-devops-entrega-valor/
Fecha: 2026-07-17
Categorías: Opiniones, IA, Programación
Descripción: La IA automatiza manifiestos y pipelines, pero DevOps sigue siendo esencial: el trabajo cambia hacia seguridad, confiabilidad y entrega de valor.

Se habla mucho de si la IA acabó con el rol del programador. Para mí, esa conversación parte de una definición demasiado pequeña del trabajo. La ingeniería de software nunca fue solamente escribir código.

Con DevOps estamos cometiendo el mismo error.

Si reducimos DevOps a escribir manifiestos, mantener scripts de infraestructura o crear archivos YAML para un pipeline, entonces sí: una parte importante de ese trabajo será automatizada. Pero ese nunca fue el punto. DevOps no nació para producir YAML. Su propósito siempre fue **garantizar una entrega de valor continua, segura y confiable**.

Yo diría que la IA no elimina ese propósito. Al contrario, nos obliga a volver a él.

## DevOps nunca fue mover código del punto A al punto B

Durante mucho tiempo asociamos DevOps con la parte más visible del proceso: preparar un pipeline, desplegar una aplicación, ejecutar pruebas, configurar infraestructura o crear automatizaciones.

Todo eso forma parte del trabajo, pero no es el resultado. Un pipeline en verde solo demuestra que se cumplieron unas condiciones que nosotros mismos definimos. No garantiza que el cambio aporte valor, que los permisos sean correctos, que podamos recuperarnos de un fallo o que sepamos qué está ocurriendo en producción.

Aquí está el detalle importante: **el artefacto no es el trabajo**.

El manifiesto, el script y el flujo de CI/CD son medios. El trabajo real es construir un camino que nos permita cambiar el software con confianza. Detectar errores temprano, reducir el riesgo de cada despliegue, proteger información sensible, responder ante incidentes y aprender de lo que ocurre en producción: eso también es DevOps.

Visto así, DevOps no desaparece porque una IA pueda escribir un flujo en segundos. Lo que pierde valor es escribirlo manualmente y creer que ahí terminó nuestro trabajo.

## La IA cambia dónde debemos poner el esfuerzo

Hoy una herramienta de IA puede generar una primera versión de un pipeline, un Dockerfile o una configuración de infraestructura como código. En muchos casos lo hará más rápido que nosotros y con una sintaxis bastante correcta. No tengo problema en admitirlo: ya no tiene mucho sentido gastar nuestra energía en recordar cada propiedad de un YAML.

Pero una configuración puede ser válida y seguir siendo una mala decisión para nuestro sistema. Puede conceder permisos excesivos, exponer secretos, duplicar costos, ignorar una ruta de recuperación o agregar una complejidad operativa que el equipo no necesita. La IA puede conocer la sintaxis; no necesariamente conoce nuestro contexto.

Ahí es donde cambia la conversación. No pasamos de hacer DevOps a no hacerlo. Pasamos de producir cada instrucción manualmente a **orquestar y supervisar el sistema de entrega completo**.

![Evolución del trabajo DevOps desde escribir artefactos hasta supervisar una entrega de valor segura y confiable](https://programemos.net/images/ia-cambio-devops-entrega-valor-flujo.webp)

*La IA reduce el esfuerzo mecánico; el criterio operativo sigue siendo responsabilidad del equipo.*

Para mí, el tiempo que ganamos debería ir a preguntas con mucho más impacto:

- ¿Qué pasa si este despliegue falla a la mitad?
- ¿Cómo comprobamos que la nueva versión funciona para usuarios reales?
- ¿Podemos revertir el cambio sin improvisar durante un incidente?
- ¿Los permisos son los mínimos necesarios?
- ¿Qué señales nos avisan antes de que el problema llegue al cliente?
- ¿El costo operativo de esta solución tiene sentido para el valor que entrega?

La IA también puede ayudarnos con estas preguntas, por supuesto. Pero la responsabilidad sobre la decisión y sus consecuencias sigue siendo nuestra. Si el despliegue rompe producción, no sirve de mucho decir que el manifiesto lo generó una herramienta.

## La migración de este blog me lo dejó claro

Cuando [migré este blog de WordPress a Astro](https://programemos.net/de-wordpress-a-astro-con-ia/), todavía no existía GitHub Agentic Workflows. Para automatizar algunas verificaciones, monté procesos que ejecutaban herramientas como Codex o Copilot desde el pipeline. En esencia, el control era un prompt: le explicaba qué debía revisar y esperaba que actuara como yo tenía en mente.

Al principio parecía funcionar. El código no se rompía y visualmente el blog se veía bien. Pero por debajo empezaron a aparecer decisiones que yo no había pedido. Un proceso que debía crear un issue podía tocar otros o crear más de uno. No era necesariamente un error de sintaxis. Era el resultado de poner una tarea no determinista dentro del flujo sin suficientes límites alrededor.

Con la migración del contenido pasó algo parecido. Algunas imágenes no seguían un estándar y afectaban el rendimiento. Quedaron enlaces rotos. Los artículos se ordenaron alfabéticamente cuando debían ordenarse por fecha. La página se veía correcta, pero el proceso no estaba entregando el resultado que yo necesitaba.

Esa fue la trampa: confundir **“se ve bien”** con **“el sistema funciona bien”**.

Mi trabajo real no terminó siendo programar cada workflow ni escribir cada paso de la migración. Fue definir qué debía conservarse, qué estructura quería, cómo debían tratarse las imágenes, qué validaciones tenían que pasar y qué cosas la IA no podía decidir por su cuenta. En WordPress muchas de esas responsabilidades estaban resueltas por plugins. Al pasar a Astro, tuve que hacerlas explícitas.

Por eso terminé creando skills y validaciones para que la IA trabajara dentro de un proceso conocido. Y por eso [GitHub Agentic Workflows](https://programemos.net/github-agentic-workflows-ia-controlada/) me pareció un avance importante: no porque convierta al agente en determinista, sino porque permite rodearlo de permisos acotados, salidas seguras y controles más claros.

El mismo criterio aplica a los requisitos: si el repositorio y Jira cuentan historias distintas, el agente no puede adivinar cuál manda. En [Spec-Driven Development y la transición organizacional](https://programemos.net/spec-driven-development-transicion-organizacional/) explico por qué hace falta definir un único *System of Record* antes de automatizar esa sincronización.

Ese cambio resume bastante bien lo que intento explicar en este artículo. Mi valor no estuvo en escribir todas las instrucciones. Estuvo en orquestar la migración, detectar lo que parecía correcto pero no lo era y convertir mis expectativas en un proceso repetible.

## El perfil que solo produce artefactos pierde valor

Aquí aparece una comparación incómoda con el rol del programador. Si una persona se define únicamente como alguien que convierte una tarea en líneas de código, la IA reduce mucho el valor de esa ejecución aislada. Si alguien en DevOps se define únicamente como quien recibe una aplicación y la lleva del punto A al punto B, ocurre lo mismo.

No creo que eso signifique que esas personas dejan de ser necesarias de un día para otro. Significa que el mercado va a valorar menos la ejecución mecánica y más el criterio que la rodea.

El perfil que gana importancia entiende por qué existe el pipeline, qué riesgos controla y qué necesita el equipo para entregar con confianza. Puede hablar de seguridad, escalabilidad, observabilidad, costos y recuperación. También sabe cuándo una automatización ayuda y cuándo estamos agregando infraestructura solo para sentir que el proceso es más profesional.

Esto no significa que ahora todos debamos ser especialistas profundos en Kubernetes, redes y seguridad. Ese sería otro extremo. Los sistemas complejos siguen necesitando especialistas y equipos de plataforma. Lo que ya no podemos hacer es tratar la operación como una caja negra que pertenece exclusivamente a otro equipo.

## De roles separados a una ingeniería más íntegra

Durante años dividimos el desarrollo en categorías cada vez más específicas: frontend, backend, QA, infraestructura y operaciones. Esa especialización resolvió problemas reales y seguirá siendo necesaria. El problema aparece cuando la división nos hace creer que nuestra responsabilidad termina al pasarle el trabajo a la siguiente persona.

La IA está empujando en la dirección contraria. Al reducir el costo de muchas tareas especializadas, hace viable que un ingeniero participe en una parte más amplia del ciclo de vida del software. No necesita dominar cada área al mismo nivel, pero sí entender cómo su decisión llega a producción y qué ocurre después.

Por eso me parece útil pensar en un perfil con forma de **E**: amplitud en varias capacidades, profundidad real en algunas y capacidad de conectar el trabajo entre disciplinas. No me interesa tanto discutir la letra. Me interesa la idea detrás de ella: volver a una ingeniería de software más íntegra.

Desde esa perspectiva, DevOps no es un paso final ni un ticket que delegamos al equipo de infraestructura. Es parte del núcleo de nuestras habilidades como ingenieros. Diseñar una funcionalidad sin pensar cómo desplegarla, observarla y recuperarla es dejar el trabajo incompleto.

## DevOps cambia para volver a su propósito

Tampoco conviene exagerar y decir que la IA ya puede operar cualquier sistema sin intervención humana. En entornos regulados, plataformas críticas o infraestructuras grandes, la experiencia especializada importa incluso más. No delegaría una decisión sensible a una herramienta que no conoce todas las restricciones del negocio ni carga con las consecuencias de un fallo.

Pero sí debemos aceptar que escribir artefactos dejó de ser el centro del rol. Aferrarnos a esa parte sería como defender que programar consiste en teclear cada línea a mano.

La oportunidad está en usar la IA para eliminar fricción y dedicar más capacidad a lo que siempre debió importar: crear procesos de entrega simples, seguros, observables y confiables. Procesos que permitan aportar valor de manera continua, no solamente mover paquetes entre entornos.

Para mí, esa es la reflexión. DevOps cambió, sí, pero para obligarnos a volver a su propósito. Quien solo escribía manifiestos tendrá que evolucionar. Quien entienda cómo entregar software con confianza tendrá más valor, no menos.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## Spec-Driven Development y el reto real de la transición organizacional

URL: https://programemos.net/spec-driven-development-transicion-organizacional/
Fecha: 2026-07-08
Categorías: Arquitectura de Software, Opiniones, IA
Descripción: Adoptar SDD en empresas con Jira o Azure DevOps no es un reto técnico. Es un problema de gobernanza, System of Record y gestión del cambio.

Este artículo no es una crítica a Spec-Driven Development. Es una reflexión sobre un problema que he visto repetirse en proyectos empresariales reales: la mayoría de los equipos que intentan adoptar SDD no fracasan por escribir malas especificaciones. Fracasan porque nadie definió qué pasa con Jira.

Trabajando con equipos reales, no en proyectos personales de laboratorio, he observado un patrón consistente. Las organizaciones empiezan a explorar herramientas de IA para desarrollo, descubren el valor de trabajar guiadas por especificaciones y comienzan a mantener archivos Markdown en el repositorio. Al mismo tiempo, Jira o Azure DevOps siguen siendo el centro operativo del equipo: épicas, historias, prioridades, sprints. En pocos meses aparece el problema que nadie anticipó: dos sistemas que describen el mismo trabajo, evolucionando por separado.

## El problema no es SDD. Es la gobernanza de la información

Cuando las especificaciones del repositorio no están sincronizadas con las historias de Jira, los documentos de Confluence y lo que el cliente envió por correo, no tienes un problema de metodología. Tienes un problema de gobernanza.

La proliferación de fuentes de la verdad no es exclusiva de SDD. Existe en cualquier organización que crece sin definir quién tiene autoridad sobre cada artefacto. Lo que SDD hace es visibilizar ese problema más rápido, porque propone mover una fuente relevante de información al repositorio, donde antes no vivía.

Vale la pena aclarar un punto técnico: Spec-Driven Development no obliga a que las especificaciones existan como archivos Markdown dentro del código. Esa es la implementación que popularizaron muchas herramientas actuales porque resulta conveniente para trabajar con Git y con modelos de IA. El principio es trabajar guiados por especificaciones. Dónde viven esas especificaciones es una decisión de arquitectura de información, no un dogma del enfoque.

## La discusión equivocada

He escuchado muchas veces el debate planteado como "¿Jira o Markdown?". Creo que esa pregunta está mal formulada.

No es una competencia entre herramientas. Es una pregunta de gobernanza: ¿cuál es la fuente oficial de la verdad dentro de esta organización, y cómo evitamos mantener dos sistemas sincronizados a mano?

Defender una herramienta específica sin responder esa pregunta es decorar el problema, no resolverlo.

## Definir un único System of Record

La recomendación que he visto funcionar con mayor consistencia es esta: define un único System of Record y automatiza la generación o sincronización del resto de los artefactos.

Si la organización decide que Jira es la fuente de verdad, las especificaciones para la IA deberían generarse automáticamente desde allí. Si la organización adoptó completamente SDD y el repositorio es el centro, entonces Jira debería reflejar el estado del trabajo derivado de esas especificaciones, no duplicarlo.

Lo que no funciona es dejar que ambos sistemas evolucionen manualmente en paralelo. Eso no es una estrategia de transición; es deuda de información acumulándose.

![Diagrama de un único System of Record: Jira o el repositorio como fuente principal generando automáticamente el resto de artefactos](https://programemos.net/images/spec-driven-development-transicion-organizacional-system-of-record.webp)

*El System of Record centraliza la verdad. El resto de artefactos se genera o sincroniza desde allí.*

## El factor humano

Los desarrolladores tendemos a pensar desde lo técnico. Cuando aparece una solución mejor, asumimos que la organización debería adoptarla de inmediato. Esa asunción subestima cómo funcionan realmente las empresas.

Las organizaciones no cambian solo por razones técnicas. Cambian cuando hay cultura, personas, procesos, tolerancia al riesgo y gestión del cambio alineados. Una transición que ignora esas variables puede ser técnicamente correcta y organizacionalmente desastrosa.

En ese contexto también está ocurriendo algo relevante en los perfiles profesionales. Con la IA aparecen roles más orientados al producto, capaces de combinar conocimiento técnico, negocio y especificaciones. La frontera entre desarrollador, analista funcional y product manager empieza a difuminarse en algunos equipos. Eso es real y vale la pena seguirlo de cerca.

Pero no significa que todas las organizaciones vayan a transformarse de forma inmediata. Existen estructuras que llevan muchos años funcionando de una manera determinada, con personas que tienen expertise real en esos procesos. Cualquier transición que no considere esa realidad generará resistencia antes que adopción.

No voy a afirmar que Scrum, Jira o los roles tradicionales van a desaparecer, porque eso sería una predicción sin respaldo. Lo que sí puedo decir es que la industria está evolucionando y que el trabajo del ingeniero incluye diseñar transiciones ordenadas, no solo construir el estado futuro.

## Por qué OpenSpec intenta ser un puente

Esta reflexión influyó directamente en cómo se diseñó OpenSpec. Una de las decisiones explícitas fue mantenerlo simple para reducir la fricción de adopción. No buscaba construir el framework de SDD más completo ni más estricto posible.

Herramientas como GitHub Spec Kit proponen un proceso muy estructurado y disciplinado. Para organizaciones que ya adoptaron completamente SDD, ese nivel de formalidad puede ser exactamente lo que necesitan. Pero en equipos que están comenzando esa transición, el mismo nivel de estructura puede convertirse en una barrera de entrada.

No porque el enfoque sea incorrecto, sino porque el grado de estructura debe corresponder al nivel de madurez de la organización. Un proceso demasiado exigente para el momento equivocado produce abandono, no adopción.

OpenSpec intenta funcionar como un puente entre ambos mundos: suficientemente simple para equipos en transición, suficientemente útil para seguir aportando valor a medida que la organización madura.

## La pregunta que vale la pena hacerse

El éxito de Spec-Driven Development no dependerá únicamente de escribir mejores especificaciones. Dependerá de cómo los equipos integren ese paradigma con los procesos que ya tienen, sin perder alineación, trazabilidad ni colaboración.

La pregunta correcta no es si Jira, Azure DevOps o Markdown es la mejor herramienta. La pregunta correcta es: **¿cuál es el System of Record de tu organización, y qué se genera automáticamente desde allí?**

Mientras esa pregunta no tenga respuesta clara, la adopción de SDD genera más fricción de la que elimina.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## De repositorio base a skill: cómo llevo mis patrones .NET a la IA

URL: https://programemos.net/repositorio-base-a-skill-net-ia/
Fecha: 2026-06-15
Categorías: IA, Arquitectura de Software, Opiniones, Programación
Descripción: Pasé de mantener repositorios base de .NET a darle un skill al agente con mis patrones. Por qué la IA todavía necesita tu criterio cuando programas backend.

Durante varios años arrastré la misma costumbre: tener un repositorio base de .NET con mis patrones, mis librerías favoritas y las buenas prácticas que fui recogiendo proyecto tras proyecto. Cuando llegaba uno nuevo, clonaba ese repositorio y empezaba el ritual: crear archivos, borrar otros, renombrar, quitar lo que no aplicaba y añadir lo que faltaba.

Era útil, pero tedioso. Ningún proyecto tenía exactamente las mismas características, así que el repositorio base nunca encajaba al 100%. Siempre tocaba acomodarlo a mano.

Ese repositorio terminó siendo un skill. Y ese cambio dice bastante sobre cómo estamos programando hoy.

## De arquitectura limpia a vertical slice, y aún así el repositorio molestaba

Mi primer repositorio base estaba montado sobre arquitectura limpia. Capas marcadas, separación estricta, todo en su sitio. Con el tiempo me fui moviendo hacia [Vertical Slice](https://programemos.net/vertical-slice-dotnet-pragmatismo/), por razones que ya conté en otro artículo: menos choques, PR más cortos y el foco puesto en el caso de uso, no en respetar la plantilla.

El cambio ayudó con un problema concreto. Al organizar por features autocontenidas, ya no tenía que arrastrar tantas capas compartidas entre proyectos distintos. Cada caso de uso vivía junto, así que recortar lo que sobraba era más limpio.

Pero el repositorio base seguía ahí. Aunque la arquitectura fuera más modular, yo seguía clonando, renombrando y borrando. Vertical Slice redujo la fricción de mantener la estructura; no eliminó la fricción de arrancar cada proyecto desde una copia que nunca calzaba del todo.

La pregunta incómoda era simple: ¿de verdad necesitaba seguir cargando un repositorio entero para transmitir algo que, en el fondo, eran decisiones y convenciones?

## Dejé de copiar un repositorio y empecé a darle un skill al agente

La respuesta fue dejar de tratar mis patrones como archivos y empezar a tratarlos como criterio escrito.

En lugar de un repositorio base, escribí un skill: un archivo de contexto en Markdown que describe cómo quiero que se construya una aplicación .NET. Cómo organizo las features, qué librerías uso y para qué, cómo nombro las cosas, cuándo sí meto una abstracción y cuándo no. Se lo entrego al agente y, a partir de ahí, genera el código siguiendo mis convenciones en vez de las suyas.

No es magia ni una plantilla mágica. Es la diferencia entre copiar carpetas y entregar el criterio que hay detrás de esas carpetas.

El resultado lo publiqué como [dotnet-vertical-slice-best-practices](https://github.com/josearias210/dotnet-vertical-slice-best-practices), una skill instalable desde [skills.sh](https://www.skills.sh/josearias210/dotnet-vertical-slice-best-practices). Si alguien quiere probarla, puede agregarla con:

```bash
npx skills add josearias210/dotnet-vertical-slice-best-practices
```

El punto no es vender Vertical Slice como la respuesta universal. El punto es otro: empaquetar mi criterio técnico para que un agente no arranque desde defaults genéricos cuando le pido construir un backend en .NET.

Por eso la skill no se queda en "usa Vertical Slice". También documenta decisiones sobre Minimal APIs, CQRS con MediatR, validación, errores esperados, migraciones de EF Core, composición de solución, paquetes centralizados y hasta el flujo de build con GitHub Actions. Esas son decisiones que normalmente estaban escondidas en mi repositorio base o en mi cabeza.

![Comparación entre clonar un repositorio base y copiar archivos por proyecto frente a darle un skill con patrones al agente para que genere la feature](https://programemos.net/images/repositorio-base-a-skill-net-ia-flujo.webp)

*Antes copiaba y acomodaba un repositorio entero. Ahora el criterio vive en un skill y el agente genera la feature en mi estilo.*

Soy consciente de que esto puede sonar contradictorio con algo que ya he dicho. Cuando hablé del [subsidio de la IA](https://programemos.net/subsidio-ia-automatizar-tareas-repetitivas/) comenté mis reservas sobre los skills enormes que documentan cada detalle del proyecto, porque los modelos actuales ya descubren buena parte de esos patrones leyendo el código. Y lo mantengo.

La diferencia es el objetivo. Una cosa es documentar de más por miedo, repitiendo lo que el agente puede deducir solo. Otra es darle el criterio que de verdad cambia el resultado: decisiones de arquitectura, convenciones y excepciones que no están escritas en ningún archivo del proyecto nuevo porque el proyecto todavía no existe. Ese skill no sustituye lo que el modelo ya sabe; le da lo que no puede adivinar.

No digo que mis patrones sean los mejores. Cada quien tiene su criterio y el mío seguirá cambiando. Pero creo que esta es la forma razonable de empezar y mantener un desarrollo en .NET hoy: ni escribir todo desde cero, que ya no tiene mucho sentido, ni dejar que la IA decida sola.

## La IA no elige .NET por ti, y ahí está el riesgo

Hay que ser honestos con una cosa. Si le pides a un agente que te genere un backend sin más contexto, no siempre va a asumir .NET como primera opción. Tiende a tirar por pilas más genéricas según el modelo, el prompt y los ejemplos que tenga más cerca. Y si tu mundo es .NET, eso no es lo que quieres.

Ese sesgo es justamente otra razón para tener un skill. No solo fija mis patrones: fija el lenguaje y el ecosistema. Le dice al agente que aquí se trabaja en .NET, con sus convenciones, no con la opción genérica que elegiría por su cuenta.

Y hay un punto más delicado. Todavía no podemos confiarnos de que la IA produzca código 100% fiable. Si le pides código en un lenguaje que dominas, detectas el error de un vistazo. Si se lo pides en uno que no manejas bien, puede colar fallos sutiles que ni siquiera reconoces como fallos.

Por muchas bases sólidas de programación que tengas, hay detalles muy puntuales de cada lenguaje que solo se aprenden trabajando años con él. En un ecosistema tan fuertemente tipado como .NET, esos detalles importan: comportamientos del runtime, sobrecargas, nulabilidad, `async`/`await`, cómo se evalúa una consulta de EF Core. Cosas que no se ven en una buena práctica general, sino en la cicatriz de haberlas sufrido.

Por eso, aunque suene contradictorio para algunos, si vas a trabajar el backend en .NET, mi recomendación es que sigas en .NET aunque la IA escriba el código. No para presumir el stack, sino porque necesitas el criterio para revisar lo que genera. Pedirle código en un lenguaje que no dominas te deja sin la capacidad de detectar cuándo se equivocó.

## No es soltar el volante, es darle dirección

Para mí este es el equilibrio que tiene sentido ahora. No tiene mucho caso escribir cada línea desde cero, pero tampoco podemos quitar las dos manos del volante. La IA hace el trabajo con nosotros, supervisada por nosotros, y el skill es la forma de inyectarle nuestro criterio antes de que empiece.

Esto no reemplaza nada de lo que ya debería existir. Las pruebas, la revisión y un buen proceso de entrega continua siguen siendo necesarios; ahí no cambia el juego. Lo que digo es más acotado: a nivel de codificación, darle al agente tus patrones es el mínimo esfuerzo que deberíamos hacer si queremos que el resultado se parezca a lo que construiríamos nosotros. Es la misma idea de [meter la IA dentro de un proceso controlado](https://programemos.net/github-agentic-workflows-ia-controlada/) en vez de soltarla a ciegas, solo que aplicada al momento de escribir el código.

Un skill tampoco es gratis. Hay que mantenerlo: cuando cambia mi criterio o la versión del framework, el skill se queda viejo igual que se quedaba viejo el repositorio base. La diferencia es que mantener un texto con decisiones es más barato que mantener una copia de archivos que toca reacomodar en cada proyecto. Y si mis patrones están mal, el skill propaga ese error con eficiencia; por eso sigue dependiendo de mi juicio, no lo sustituye.

No fue dejar de programar en .NET ni delegar el criterio. Fue ponerlo por escrito una vez para no reconstruirlo a mano en cada proyecto, y quedarme con la parte que de verdad me corresponde: decidir y revisar. El volante sigue siendo mío.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Artefacto reproducible

La guía [dotnet-vertical-slice-best-practices](https://github.com/josearias210/dotnet-vertical-slice-best-practices) acompaña esta idea como una skill ejecutable para backends .NET 10 y C# 14 con Vertical Slice, CQRS, EF Core 10, PostgreSQL, validación y OpenTelemetry. El repositorio incluye validación continua y documenta pruebas opcionales con `WebApplicationFactory`, Testcontainers y Respawn.

Se instala siguiendo su README. No es un generador mágico: sigue requiriendo entender el sistema donde se aplica. Última verificación: agosto de 2026.

---

## Agentes serverless en Azure Functions: Microsoft mueve el foco del código al agente

URL: https://programemos.net/azure-functions-agentes-serverless-runtime/
Fecha: 2026-06-10
Categorías: Azure, IA, Arquitectura de Software, Programación
Descripción: Mi lectura del runtime de agentes serverless en Azure Functions: Microsoft pone al agente primero, pero el código y la ingeniería de software siguen importando.

Hay algo en el nuevo runtime de agentes serverless de Azure Functions que me parece más importante que la lista de triggers, herramientas o conectores.

Microsoft está moviendo el centro de la conversación. Hasta ahora pensábamos primero en la Function, el handler y el código que recibía un evento. Ahora la propuesta es pensar primero en el agente: qué intenta resolver, cuándo debe ejecutarse, qué instrucciones necesita y a qué capacidades puede acceder.

Después viene el código, si hace falta.

Ese cambio me parece interesante porque **el agente se convierte en la unidad de trabajo que Azure Functions descubre, registra, dispara y ejecuta**. Ya no es solamente algo externo que llama una Function o usa una Function como herramienta.

La propuesta es `markdown-first`: defines el agente en un archivo `.agent.md`, declaras su trigger en el frontmatter y escribes sus instrucciones en Markdown. El runtime se ocupa de componer el modelo, las herramientas, las skills y el trigger. Cuando existe una conversación de varios turnos, también puede recuperar y persistir su historial de sesión.

No conviene exagerarlo. El runtime está en **preview** y actualmente la aplicación es un proyecto Python. Pero la dirección sí vale la pena analizarla porque acerca dos mundos que normalmente terminamos pegando a mano: agentes y procesamiento orientado a eventos. También revela cómo Microsoft quiere que construyamos parte de estas soluciones: menos código ceremonial alrededor del agente y más intención explícita sobre lo que el agente debe hacer.

## La novedad no es ejecutar IA en una Function

Ejecutar una llamada a un modelo desde Azure Functions no es nuevo. Tampoco lo es usar una Function como herramienta de un agente.

Lo interesante es que ahora un archivo puede declarar un agente completo:

```markdown title="resumen-diario.agent.md"
---
name: Resumen diario
description: Resume los eventos técnicos pendientes y prepara un reporte.

trigger:
  type: timer_trigger
  args:
    schedule: "0 0 15 * * *"
---

Revisa los eventos técnicos pendientes.
Agrupa los problemas por severidad y prepara un resumen breve.
Incluye los riesgos que requieran atención del equipo.
```

El frontmatter indica **cuándo** se ejecuta. El cuerpo en Markdown indica **qué debe hacer**.

Cuando arranca la Function App, el runtime lee los `.agent.md`, carga la configuración compartida, descubre herramientas y skills, valida la composición y registra los triggers. Cuando ocurre el evento, construye y ejecuta el agente mediante Microsoft Agent Framework.

La aplicación mínima sigue teniendo piezas conocidas de Azure Functions como `host.json`, `requirements.txt` y `function_app.py`. La diferencia es que este último puede reducirse a crear la aplicación configurada por el runtime:

```python title="function_app.py"
from azure_functions_agents import create_function_app

app = create_function_app()
```

Eso elimina bastante código de infraestructura, pero también mueve más comportamiento hacia configuración y convenciones del runtime.

La complejidad no desaparece. Cambia de lugar.

## Los eventos pasan a iniciar agentes

Para mí, aquí está la parte importante.

Un chatbot empieza normalmente porque alguien escribe un mensaje. Un agente de negocio no siempre funciona así. Puede tener que reaccionar cuando llega una orden, cambia un documento, aparece una alerta o se cumple una hora determinada.

El runtime permite usar triggers conocidos de Azure Functions como:

* HTTP
* Timer
* Queue Storage
* Blob Storage
* Event Grid
* Service Bus

También contempla eventos provenientes de servicios conectados, por ejemplo mensajes, correos o cambios en aplicaciones empresariales cuando el conector correspondiente los soporta.

![Diagrama donde eventos HTTP, programados y de colas activan un agente en Azure Functions que usa MCP, skills, herramientas Python y ejecución aislada](https://programemos.net/images/azure-functions-agentes-serverless-flujo.webp)

*El runtime convierte los triggers de Azure Functions en puntos de entrada para agentes con herramientas y capacidades configuradas.*

Esto encaja especialmente bien cuando el evento necesita **razonamiento o selección dinámica de herramientas**. Por ejemplo, una alerta que debe correlacionarse con incidentes anteriores, consultar varios sistemas y decidir si escalar.

Pero si cada mensaje de una cola siempre termina ejecutando tres pasos conocidos en el mismo orden, probablemente no necesitas un agente. Necesitas una Function o un workflow determinista.

Poner un modelo en medio de un proceso predecible añade costo, latencia y una nueva forma de fallar sin aportar necesariamente una mejor decisión.

## La apuesta de Microsoft: el agente primero

Para mí, esta es la lectura más interesante del runtime.

Microsoft no está diciendo que el código dejó de importar. Está proponiendo que, para este tipo de aplicación, **el código ya no tiene que ser la primera abstracción que veamos**.

En una Function tradicional empiezas normalmente por una función, un trigger, parámetros y servicios. Aquí empiezas por otra pregunta: ¿qué agente necesito y qué resultado espero de él?

El archivo `.agent.md` se convierte en la pieza principal. El trigger, el modelo y las capacidades se configuran alrededor de sus instrucciones. El código aparece cuando el comportamiento propio del negocio no cabe razonablemente en MCP, conectores, skills o ejecución aislada.

Me gusta esa dirección porque obliga a expresar mejor la intención. También me genera una reserva: un archivo Markdown puede hacer que el sistema parezca más simple de lo que realmente es. Cuando el agente tiene permisos para enviar correos, crear tickets, consultar datos o ejecutar código, ya no estamos escribiendo solo instrucciones. Estamos definiendo comportamiento operativo.

La propuesta intenta que las capacidades comunes no tengan que implementarse todas como clientes personalizados.

Un agente puede descubrir servidores MCP remotos desde `mcp.json`, cargar instrucciones reutilizables desde carpetas de skills y ejecutar Python en sesiones aisladas de Azure Container Apps. Para lógica propia del negocio, puedes agregar herramientas Python en `tools/`.

La estructura puede verse así:

```text
mi-agente/
├── function_app.py
├── resumen-diario.agent.md
├── agents.config.yaml
├── mcp.json
├── host.json
├── requirements.txt
├── skills/
│   └── respuesta-incidentes/
│       └── SKILL.md
└── tools/
    └── crear_ticket.py
```

Las cinco opciones no resuelven lo mismo:

| Capacidad | Cuándo la usaría |
| --- | --- |
| MCP remoto | Una capacidad ya vive en otro servicio o debe compartirse entre aplicaciones. |
| Conectores | Necesito acciones o eventos de sistemas empresariales sin mantener cada cliente API. |
| Skills | Quiero instrucciones de dominio reutilizables que el agente cargue cuando correspondan. |
| Herramientas Python | La lógica es propia de esta aplicación y necesita código explícito. |
| Sandbox | El agente debe ejecutar código potencialmente no confiable en un entorno aislado. |

El runtime hace disponibles por defecto varias capacidades descubiertas y permite excluirlas por agente. Eso es cómodo, pero yo sería conservador: **un agente no debería heredar una herramienta solo porque está disponible en el proyecto**. Cuantas más acciones tenga, mayor es la superficie de permisos, errores y decisiones difíciles de evaluar.

Aquí es donde "menos código" no puede convertirse en "menos revisión". Las descripciones de las herramientas, los esquemas de parámetros, los permisos y las instrucciones pasan a ser parte del contrato del sistema, aunque no estén escritos como una clase o una interfaz.

## Lo operativo sigue importando

La ventaja real de apoyarse en Azure Functions no es que el prompt viva en Markdown. Es reutilizar un modelo operativo conocido: escalado orientado a eventos, identidad administrada, red, Application Insights y despliegue como Function App.

En Flex Consumption, Microsoft destaca `scale-to-zero`, facturación por segundo, integración con redes virtuales e identidades administradas. Para interacciones de varios turnos, el runtime guarda el historial de sesión en Blob Storage usando la cuenta configurada en `AzureWebJobsStorage`.

Eso reduce piezas, pero no evita las decisiones serias:

* El `scale-to-zero` no garantiza costo irrelevante si cada ejecución llama modelos y herramientas varias veces.
* La identidad administrada simplifica secretos, pero todavía debes asignar permisos mínimos a modelos, Storage, MCP y sandboxes.
* El historial persistido necesita políticas de retención, clasificación de datos y revisión de privacidad.
* Una ejecución de agente puede durar y variar mucho más que una Function determinista.
* La observabilidad debe explicar tanto el trigger como las decisiones y llamadas del agente.

También hay una interfaz de chat y APIs integradas de chat y streaming. La propia documentación recomienda esas superficies para desarrollo, pruebas y diagnóstico, no como interfaz principal de producción. El endpoint MCP es distinto: sirve para exponer la composición del agente a clientes MCP y está protegido por una system key, salvo que la aplicación configure acceso anónimo.

## Cuándo sí lo usaría

Veo un buen encaje en agentes que reaccionan a eventos y necesitan combinar contexto con acciones:

* clasificación y escalamiento de incidentes
* resúmenes programados que consultan varias fuentes
* procesamiento de correos o mensajes con decisiones posteriores
* conciliaciones donde aparecen excepciones que requieren razonamiento
* automatizaciones empresariales apoyadas en conectores y MCP

En esos casos, Azure Functions ya resuelve una parte importante del problema: cómo iniciar el trabajo, escalarlo, identificarlo y observarlo. El runtime agrega la composición del agente encima de esa base.

No lo usaría todavía para un núcleo transaccional que exige resultados totalmente deterministas, ni movería a esta abstracción una Function que solo transforma un mensaje y escribe una salida conocida. En ese segundo caso, incluso Microsoft señala la extensión MCP de Azure Functions como un punto de partida más simple si lo único que necesitas es exponer funciones deterministas como herramientas para otro cliente de IA.

Tampoco basaría una plataforma crítica en este runtime sin aceptar que está en preview y que sus capacidades, nombres de configuración y conectores compatibles pueden cambiar antes de disponibilidad general.

Y hay otro límite concreto: si el equipo trabaja principalmente con .NET, hoy tendrá que decidir si introducir un proyecto Python para adoptar este runtime compensa el beneficio. Microsoft Agent Framework participa en la ejecución, pero la anatomía documentada para esta preview es la de una aplicación Python de Azure Functions.

Lo valioso no es poder escribir un prompt en Markdown. Eso por sí solo no mejora una arquitectura ni convierte una automatización en un agente.

Lo valioso es que Microsoft está tratando de llevarnos a pensar en la intención del agente antes que en el código del handler: declarar que reacciona a un evento y darle acceso controlado a herramientas, skills, estado e identidad sin construir manualmente todo el pegamento operativo.

La idea tiene sentido porque Azure Functions ya entiende eventos. El runtime está intentando que también entienda agentes como una unidad nativa de ejecución.

Mi recomendación sería probarlo en automatizaciones internas y procesos con revisión humana, donde el razonamiento tenga valor y el impacto de un error esté acotado. Mediría latencia, costo por ejecución, calidad de decisiones y facilidad de diagnóstico antes de llevarlo a un flujo crítico.

Y mantendría una regla sencilla: si la parte más importante del sistema sigue siendo una secuencia conocida de pasos, escribiría código. Si la parte importante es interpretar contexto, elegir capacidades y decidir una acción dentro de límites claros, entonces sí empezaría a pensar en el agente como la unidad de trabajo.

No porque los agentes serverless sean una mala idea. El problema es otro: **serverless resuelve cómo ejecutar y escalar; no resuelve por sí solo cómo confiar en una decisión probabilística**.

Si quieres seguir aprendiendo sobre estos temas, te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [Uso de modelos y herramientas de IA en Azure Functions](https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-ai-enabled-apps)
* [Triggers y bindings de Azure Functions](https://learn.microsoft.com/en-us/azure/azure-functions/functions-triggers-bindings)
* [Sesiones de intérprete de código en Azure Container Apps](https://learn.microsoft.com/en-us/azure/container-apps/sessions-code-interpreter)
* [A2A y Microsoft Agent Framework en .NET](https://programemos.net/a2a-microsoft-agent-framework-dotnet/)

---

## El subsidio de la IA se está acabando. Y no es algo malo.

URL: https://programemos.net/subsidio-ia-automatizar-tareas-repetitivas/
Fecha: 2026-06-10
Categorías: IA, Opiniones, Programación
Descripción: Una experiencia real sobre cómo usar un agente para entender una tarea repetitiva, convertirla en un script reutilizable y dejar de gastar tokens sin necesidad.

Quiero contar una experiencia sencilla que me hizo pensar bastante sobre cómo estamos usando la inteligencia artificial en el desarrollo.

Durante estos últimos años nos acostumbramos a pagar una suscripción y usar la IA sin mirar demasiado el consumo. Abríamos conversaciones, cargábamos contexto, conectábamos herramientas y dejábamos que el agente trabajara. No era gratis, pero se sentía bastante cerca.

Eso está empezando a cambiar.

Desde el 1 de junio de 2026, GitHub Copilot pasó de contar solicitudes premium a medir el uso por tokens y convertirlo en GitHub AI Credits. La suscripción sigue existiendo e incluye consumo. La diferencia es que ahora una conversación corta y una sesión larga de un agente no cuestan lo mismo.

No quiero convertir esto en un artículo sobre los precios de GitHub. El cambio solo hace más visible algo que ya deberíamos estar pensando: **no todo lo que puede hacer un agente necesita seguir haciéndose con un agente**.

## El problema no son las skills

En una empresa donde trabajé se usaban mucho las skills y los archivos Markdown para darle contexto a la IA. Algunas eran bastante grandes. Explicaban los patrones del proyecto, comandos, decisiones y casi cualquier detalle que pudiera ayudar al agente.

Eso puede estar bien. Tengo mis reservas porque creo que los modelos actuales ya pueden descubrir una parte importante de esos patrones leyendo el proyecto, pero entiendo el motivo. Para el equipo funcionaba como una red de seguridad.

Pero ese no es el punto que quiero discutir.

Lo que me llamó la atención fue otra cosa: empezamos a usar agentes para tareas que eran útiles, pero también completamente repetitivas. La IA las resolvía bien y ahorraba tiempo. El problema es que nadie se detenía a pensar si, después de resolverlas una vez, todavía hacía falta volver a cargar todo ese contexto.

A veces nos quedamos con la primera mejora. Pasamos de hacerlo manualmente a pedírselo a la IA, y como ya era más cómodo, dejamos de buscar una solución mejor.

## El caso de los comentarios de Sonar

Había un proceso relacionado con comentarios de Sonar en los pull requests. En algunos casos las personas cerraban esos comentarios para poder continuar con el pull request.

Cuando digo cerrar, no me refiero a resolver el hallazgo. Me refiero literalmente a cerrar el comentario. No voy a discutir aquí si eso era correcto o no. Era lo que se hacía en la empresa y alguien tenía que completar el proceso.

Al principio se hacía a mano. Después algunas personas empezaron a usar un agente conectado mediante MCP. Le indicaban el pull request, el agente buscaba los comentarios y los cerraba.

Era útil. Mucho mejor que entrar comentario por comentario.

Pero cada vez había que iniciar una conversación, entregar el contexto, dejar que el agente consultara las herramientas y esperar el resultado. Funcionaba, aunque en el fondo siempre estaba haciendo lo mismo.

La tarea tenía varios pasos y llamadas a APIs, pero no estaba tomando una decisión especialmente compleja. Recibía el identificador del issue y del pull request, buscaba los comentarios y ejecutaba la misma acción.

Ahí fue cuando pensé: esto no necesita una conversación cada vez. Necesita parámetros.

## Usé la IA para crear el script

Primero le pedí al agente que hiciera el proceso completo para un pull request. Quería comprobar que entendía las APIs, la autenticación y el orden de los pasos.

Cuando terminó, le pedí algo más: que generara un script de PowerShell con el mismo proceso y que dejara parametrizados los identificadores necesarios.

Lo hizo prácticamente al primer intento.

A partir de ahí ya no tenía que volver a pedirle lo mismo. Ejecutaba el script, pasaba los parámetros y listo. El resultado era el mismo, pero ya no había que reconstruir el contexto ni consumir tokens para repetir una tarea que conocíamos.

![Flujo donde un agente entiende una tarea una vez, genera un script parametrizado y sale de las ejecuciones repetitivas](https://programemos.net/images/subsidio-ia-agente-a-script.webp)

*La IA ayudó a entender y construir el proceso. El script se quedó con la parte repetitiva.*

Para mí, ahí estuvo la parte realmente valiosa de usar IA.

No fue que cerrara los comentarios más rápido. Fue que me ayudó a convertir un proceso que no conocía bien en una automatización que podía ejecutar sin ella.

Yo no tuve que investigar desde cero cada endpoint ni pelear demasiado con PowerShell. La IA redujo el esfuerzo inicial. Pero una vez que ese conocimiento estaba en el script, mantener al agente en el medio ya no aportaba mucho.

## Un script tampoco es gratis

Esto no significa que todo deba terminar en un script.

El script hay que mantenerlo. Si cambia la API, puede romperse. También necesita manejo de errores, autenticación y una forma segura de trabajar con credenciales. La diferencia es que su comportamiento es más directo y se puede probar con facilidad.

Tampoco hace falta convertir cada automatización en una aplicación completa con interfaz, base de datos y despliegue. En este caso PowerShell era suficiente. En otro puede ser una herramienta de línea de comandos, una GitHub Action o una aplicación pequeña.

Lo importante es no agregar más aparato del necesario.

Yo mantendría al agente cuando la tarea realmente necesita interpretar información, investigar un repositorio, trabajar con excepciones difíciles o elegir entre acciones según el contexto. Ahí un script lleno de condiciones puede terminar siendo peor.

Ya había comentado algo parecido al hablar de [agentes serverless en Azure Functions](https://programemos.net/azure-functions-agentes-serverless-runtime/): si el proceso es una secuencia conocida de pasos, escribiría código. Si necesita interpretar contexto y decidir qué hacer, entonces sí pensaría en un agente.

No son bandos. Hay tareas para cada herramienta.

## El punto que me interesa

Creo que el aumento de los costos de la IA puede tener un efecto positivo: obligarnos a pensar un poco más antes de abrir otra conversación.

No porque pedirle cosas pequeñas a la IA esté mal. Yo también la uso para tareas simples cuando me ahorra tiempo. Pero a veces la comodidad nos vuelve un poco perezosos. Repetimos la misma conversación varias veces aunque la primera respuesta ya contenía todo lo necesario para construir algo permanente.

Lo he visto incluso con tareas tan pequeñas como crear un commit. Se le pide al agente que lo haga, luego se corrige el mensaje, se ajustan los archivos y se mantiene una conversación para algo que quizá era más rápido hacer directamente. Puede tener sentido en un flujo grande. Para un cambio mínimo, no siempre.

Mi criterio ahora es bastante sencillo: si la IA resuelve una tarea y noto que la siguiente ejecución será prácticamente igual, intento convertir esa solución en un script o una herramienta. Si aparece una excepción que sí requiere razonamiento, vuelvo al agente.

El subsidio de la IA puede estar acabándose. No creo que eso signifique que vayamos a usarla menos, sino que tendremos que usarla mejor.

En mi caso, la mejor parte de esta experiencia no fue automatizar una tarea con IA. Fue usar la IA una vez para no necesitarla cada vez.

Si quieres seguir aprendiendo sobre estos temas, te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [GitHub Copilot is moving to usage-based billing](https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/)
* [Models and pricing for GitHub Copilot](https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing)
* [Usage-based billing for individuals](https://docs.github.com/en/copilot/concepts/billing/usage-based-billing-for-individuals)

---

## A2A y Microsoft Agent Framework en .NET: agentes que hablan entre sí sin casarte con un stack

URL: https://programemos.net/a2a-microsoft-agent-framework-dotnet/
Fecha: 2026-05-31
Categorías: IA, Programación, Arquitectura de Software
Descripción: Qué es A2A, por qué importa para agentes IA y cómo implementarlo desde .NET con Microsoft Agent Framework para consumir y exponer agentes interoperables.

Cuando hablamos de agentes de IA, normalmente pensamos en prompts, herramientas, memoria, `function calling` o `MCP`.

Pero hay otro problema que empieza a aparecer cuando el sistema deja de ser una demo: **¿cómo se comunican agentes creados por equipos distintos, en lenguajes distintos o incluso en plataformas distintas?**

Ahí entra `A2A`, o `Agent2Agent`.

No lo veo como "otro protocolo de moda". Lo veo más como una señal de madurez del ecosistema. Si los agentes van a salir del experimento local y van a convivir en empresas reales, necesitan algo más que llamadas HTTP improvisadas entre servicios.

Y aquí es donde, para mí, cambia la conversación. Ya no estamos hablando del demo bonito donde todo corre en el mismo `Program.cs`. Estamos hablando de sistemas donde hay equipos, permisos, despliegues, contratos, versionado y dependencias que no controlas completamente.

## Qué es A2A en pocas palabras

`A2A` es un protocolo abierto para que un agente pueda hablar con otro agente.

La idea no es obligarte a usar la misma librería en todos lados. Es más bien lo contrario: que un agente en .NET pueda comunicarse con otro hecho en Python, con otro framework o con una plataforma externa, siempre que ambos respeten el mismo contrato.

La forma más simple de verlo es esta:

* un agente publica una especie de carta de presentación
* otro agente lee esa carta
* entiende qué capacidades hay disponibles
* sabe a qué URL llamar
* y conversa usando un formato conocido

Esa carta se llama `Agent Card`.

No es una metáfora perfecta, pero ayuda: la `Agent Card` es como cuando un servicio te dice "esto hago, aquí estoy, esta es mi versión, estas son mis capacidades y así puedes hablar conmigo".

Después de eso vienen los mensajes, las tareas y el streaming. Pero la idea base es bastante humana: presentarse bien para que otro sistema pueda colaborar contigo sin tener que adivinar cómo funcionas.

## Por qué esto sí tiene sentido

En una empresa real no todo vive en el mismo proceso, ni en el mismo repositorio, ni bajo el mismo equipo.

Un agente de soporte puede necesitar consultar a un agente de facturación. Un agente interno puede delegar validaciones a un agente de compliance. Un agente construido en .NET puede tener que hablar con un agente especializado que otro equipo ya resolvió en Python.

Sin un estándar, cada integración se vuelve una negociación distinta:

* endpoint custom
* payload custom
* autenticación custom
* manejo de errores custom
* streaming custom
* versión custom

Y ya sabemos cómo termina eso: integraciones frágiles, difíciles de probar y llenas de "esto solo funciona si lo llamas exactamente así".

`A2A` intenta poner orden en esa parte. No reemplaza la arquitectura. No reemplaza la seguridad. No reemplaza el criterio técnico. Pero sí reduce el pegamento artesanal cuando el problema real es conectar agentes entre fronteras.

Por eso me gusta explicarlo con una imagen mental sencilla: A2A no es "el cerebro" del sistema. Es más bien el idioma común y la tarjeta de presentación para que los agentes puedan encontrarse y colaborar.

## A2A no es MCP

Aquí conviene separar conceptos.

`MCP` se enfoca en cómo un modelo o agente usa herramientas, datos o recursos externos. Por ejemplo: acceder a archivos, consultar una base de datos, llamar una API o usar una herramienta concreta.

`A2A` se enfoca en cómo un agente habla con otro agente.

La diferencia parece pequeña, pero arquitectónicamente no lo es.

MCP responde mejor a esta pregunta:

> ¿Cómo le doy herramientas a mi agente?

A2A responde mejor a esta otra:

> ¿Cómo hago que mi agente delegue trabajo a otro agente remoto?

Se complementan. No son bandos.

Y para mí ese detalle es importante porque evita una confusión que ya se está volviendo común: querer meter todos los problemas de agentes dentro de un solo protocolo.

## Dónde entra Microsoft Agent Framework

Aquí es donde .NET empieza a ponerse interesante.

`Microsoft Agent Framework` ya venía empujando una idea que me gusta: tratar los agentes como sistemas de software, no como scripts con prompts.

Con A2A, el framework facilita dos caminos:

* Consumir un agente remoto A2A como si fuera un `AIAgent`.
* Exponer un agente .NET existente como endpoint A2A.

Eso es lo valioso.

No tienes que reescribir toda tu aplicación para "soportar A2A". El framework intenta que el agente remoto se sienta como una abstracción normal dentro de tu código .NET.

Si tuviera que resumirlo visualmente, lo pensaría así: **un agente publica su tarjeta, otro agente la lee y a partir de ahí recién empieza la conversación o la delegación**.

![Diagrama de A2A donde un agente publica su Agent Card y otro agente la lee antes de enviar mensajes o tareas](https://programemos.net/images/a2a-dotnet-flujo-agentes.webp)

*A2A no es solo intercambio de mensajes: primero hay descubrimiento por Agent Card y después colaboración entre agentes.*

## Consumir un agente A2A desde .NET

Supongamos que tienes un agente remoto publicado con A2A. Puede estar hecho en .NET, Python o cualquier tecnología que implemente el protocolo.

Desde .NET, el flujo básico es descubrir su `Agent Card` y envolverlo como un `AIAgent`.

Primero instalas el paquete del cliente A2A:

```bash
dotnet add package Microsoft.Agents.AI.A2A --prerelease
```

```csharp title="Consumir un agente remoto A2A"
using A2A;
using Microsoft.Agents.AI;

A2ACardResolver resolver = new(new Uri("https://agente-remoto.ejemplo.com"));

AIAgent agente = await resolver.GetAIAgentAsync();

AgentResponse respuesta = await agente.RunAsync(
    "Revisa si esta solicitud cumple con las reglas internas de compliance.");

Console.WriteLine(respuesta.Text);
```

La parte interesante no es que el código sea corto. Eso siempre se puede maquillar en un ejemplo.

Lo interesante es el modelo mental: **el agente remoto entra en tu aplicación como una pieza consumible**, no como una integración inventada desde cero.

También puedes usar streaming cuando el trabajo necesita ir entregando avances:

```csharp title="Streaming desde un agente A2A"
await foreach (AgentResponseUpdate update in agente.RunStreamingAsync(
    "Genera un análisis técnico de este documento."))
{
    if (!string.IsNullOrWhiteSpace(update.Text))
    {
        Console.Write(update.Text);
    }
}
```

Eso abre escenarios más reales: procesamiento de documentos, análisis largos, revisión de casos, tareas internas y flujos donde no quieres bloquear al usuario sin feedback.

## Exponer tu agente .NET como A2A

El otro lado también importa.

Si ya tienes un agente creado con `Microsoft Agent Framework`, puedes publicarlo para que otros sistemas lo llamen usando A2A.

Para ASP.NET Core, el paquete que habilita el hosting A2A es este:

```bash
dotnet add package Microsoft.Agents.AI.Hosting.A2A.AspNetCore --prerelease
```

Este ejemplo está simplificado, pero muestra la idea:

```csharp title="Program.cs"
using A2A.AspNetCore;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting;
using Microsoft.Extensions.AI;

var builder = WebApplication.CreateBuilder(args);

IChatClient chatClient = CrearChatClient(builder.Configuration);
builder.Services.AddSingleton(chatClient);

var agente = builder.AddAIAgent(
    name: "compliance-review",
    instructions: """
    Eres un agente de revisión de compliance.
    Evalúa solicitudes internas y responde con riesgos, observaciones y recomendación.
    """);

var app = builder.Build();

app.MapA2A(agente, path: "/a2a/compliance", agentCard: new()
{
    Name = "Compliance Review Agent",
    Description = "Revisa solicitudes internas y devuelve riesgos de compliance.",
    Version = "1.0"
});

app.Run();

static IChatClient CrearChatClient(IConfiguration configuration)
{
    // En producción aquí configuras Azure OpenAI, Microsoft Foundry,
    // OpenAI u otro proveedor compatible con Microsoft.Extensions.AI.
    throw new NotImplementedException();
}
```

El punto no es copiar y pegar esto tal cual en producción. El punto es ver la dirección: tu agente .NET puede quedar disponible como un servicio interoperable, con una tarjeta de descubrimiento y un contrato estándar.

Desde ahí ya entran las decisiones serias:

* autenticación
* autorización
* rate limiting
* observabilidad
* versionado
* timeouts
* manejo de errores
* contratos de entrada y salida

Porque A2A estandariza la comunicación, pero no te exime de diseñar bien el sistema.

La documentación oficial de Microsoft muestra este mismo enfoque con `MapA2A`: registras el agente, defines el `agentCard` y expones un endpoint A2A desde ASP.NET Core. También muestra que puedes consultar la tarjeta del agente y llamar al endpoint usando el formato de mensajes del protocolo.

## Cuándo usar A2A y cuándo no

Aquí es donde hay que bajar un poco el entusiasmo.

Yo usaría A2A cuando hay una frontera real:

* otro equipo mantiene el agente
* el agente vive en otro servicio
* necesitas interoperar con otra tecnología
* hay agentes de terceros
* necesitas descubrir capacidades sin acoplarte al código interno

Pero si todos tus agentes viven en la misma aplicación, mismo equipo, mismo despliegue y mismo proceso, probablemente `agents as tools` o una composición local sea más simple.

No todo necesita A2A.

Meter un protocolo distribuido donde no hay frontera real solo añade latencia, fallos de red, versionado y complejidad operativa.

Y esto es importante decirlo porque con IA se está repitiendo un patrón que ya vimos con microservicios: agarrar una solución pensada para fronteras reales y meterla en cualquier sitio porque suena más avanzado.

Cuando ya cruzas esa frontera, ahí sí cambia la historia. En ese punto A2A deja de ser una curiosidad y empieza a parecerse más a una pieza de integración: no porque haga el sistema simple, sino porque evita que cada equipo invente su propio protocolo para lo mismo.

## Mi lectura como desarrollador .NET

Para mí, la relevancia de A2A en .NET no está en escribir "mi primer agente que habla con otro agente".

Eso es la demo.

La relevancia está en que Microsoft Agent Framework empieza a darle al ecosistema .NET una forma razonable de integrarse en sistemas multiagente sin quedarse encerrado en un stack.

Y eso importa para nosotros como desarrolladores backend.

Porque el valor profesional no va a estar en decir "sé crear un chatbot". Eso ya se está comoditizando.

El valor va a estar en saber diseñar sistemas donde agentes, herramientas, workflows, permisos, auditoría y servicios reales convivan sin volverse una caja negra imposible de mantener.

A2A no resuelve todo eso.

Pero sí resuelve una parte muy concreta: **cómo hacer que los agentes se entiendan cuando cruzan fronteras**.

Y Microsoft Agent Framework lo vuelve mucho más natural para quienes trabajamos con .NET.

Por eso creo que vale la pena mirarlo desde ya. No para meterlo en todos los proyectos, sino para tenerlo en la cabeza cuando el problema deje de ser "tengo un agente" y pase a ser "tengo varios agentes que necesitan colaborar sin depender todos del mismo stack".

Ahí A2A empieza a tener sentido.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [A2A Protocol Specification](https://a2a-protocol.org/latest/specification/)
* [Agent-to-Agent en Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/journey/agent-to-agent)
* [A2A Agent en Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/agents/providers/agent-to-agent)
* [A2A Integration en Microsoft Agent Framework para C#](https://learn.microsoft.com/en-us/agent-framework/integrations/a2a?tabs=dotnet-cli%2Cuser-secrets&pivots=programming-language-csharp)
* [A2A v1 en Microsoft Agent Framework para .NET](https://devblogs.microsoft.com/agent-framework/a2a-v1-is-here-cross-platform-agent-communication-in-microsoft-agent-framework-for-net/)

---

## Claude SDK para C#: una señal interesante para el ecosistema .NET

URL: https://programemos.net/claude-sdk-csharp-dotnet/
Fecha: 2026-05-27
Categorías: IA, Opiniones, Programación
Descripción: Anthropic ya ofrece un SDK oficial para C#. Analizo qué significa para .NET, la IA aplicada y las aplicaciones empresariales modernas que integran Claude.

Anthropic ya documenta un SDK para C# y, aunque puede parecer una noticia pequeña, creo que vale la pena mirarla con calma.

No porque un SDK cambie por sí solo el futuro de .NET. Tampoco porque ahora todo proyecto de IA tenga que usar Claude desde C#. Sería exagerado plantearlo así.

Lo interesante es otra cosa: en una etapa donde muchas herramientas de IA aparecen primero para Python y JavaScript, ver soporte oficial para C# confirma que .NET sigue siendo un ecosistema que vale la pena atender.

Y aquí conviene aclarar algo: antes de esto ya existían formas de usar Claude desde C#. Se podía trabajar directamente contra la API REST, crear un cliente propio con `HttpClient` o usar librerías comunitarias. La novedad no es que C# pueda hablar con Claude por primera vez. La novedad es que ahora hay un SDK documentado por Anthropic para hacerlo desde .NET.

Y para quienes seguimos construyendo software de negocio con .NET, es una señal que merece atención.

## El contexto importa

Si hablamos de IA, Python tiene una posición muy fuerte. Es normal. Buena parte del ecosistema de modelos, experimentación, notebooks y ciencia de datos se mueve allí.

JavaScript y TypeScript también suelen aparecer temprano en casi cualquier SDK moderno, porque están en el frontend, en Node.js, en tooling y en muchas plataformas de automatización.

Eso no está mal. Tiene sentido desde el punto de vista del mercado.

Pero el software empresarial no desapareció. Las APIs, workers, integraciones internas, procesos de negocio, sistemas de facturación, CRMs, ERPs y aplicaciones corporativas siguen existiendo. Muchas de esas soluciones están escritas en C# y se mantienen durante años.

Por eso me parece relevante que Anthropic haya dado ese paso. No porque antes fuera imposible integrar Claude en C#, sino porque un SDK oficial cambia el tipo de soporte y de confianza que puedes esperar al llevar esa integración a una aplicación real. Que exista un SDK documentado para C# no convierte a .NET en el centro del mundo de la IA, pero sí reconoce que hay proyectos reales donde C# sigue siendo una plataforma natural.

## Qué trae el SDK

Según la documentación oficial, el paquete `Anthropic` permite consumir la API de Claude desde aplicaciones C# y expone algunas piezas que encajan bien con aplicaciones .NET:

* Modelos tipados para solicitudes y respuestas.
* Streaming con `IAsyncEnumerable`.
* Manejo de errores propio del SDK.
* Configuración de tiempos de espera y reintentos.
* Integración con `Microsoft.Extensions.AI` mediante `IChatClient`.
* Paquetes separados para escenarios como Bedrock, Vertex AI, Foundry y Claude Platform on AWS.

La integración con `IChatClient` me parece especialmente importante. No porque sea algo mágico, sino porque acerca Claude a las abstracciones que Microsoft viene impulsando para trabajar con IA en .NET.

Eso ayuda a que una integración con IA no quede como un bloque aislado en el código, sino como una pieza que puede convivir mejor con el resto del ecosistema.

![Flujo entre una aplicación .NET, el SDK de Anthropic y la API de Claude](https://programemos.net/images/claude-sdk-csharp-flujo.webp)

*El valor no está solo en llamar a Claude, sino en poder integrarlo dentro de aplicaciones .NET con herramientas del propio ecosistema.*

## Un ejemplo mínimo

La instalación es directa desde NuGet:

```bash
dotnet add package Anthropic
```

Y una llamada básica desde C# se ve así:

```csharp title="Program.cs"
using Anthropic;
using Anthropic.Models.Messages;

var apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");
if (string.IsNullOrWhiteSpace(apiKey))
{
    Console.WriteLine("Configura ANTHROPIC_API_KEY antes de ejecutar el ejemplo.");
    return;
}

AnthropicClient client = new() { ApiKey = apiKey };

MessageCreateParams parameters = new()
{
    MaxTokens = 800,
    Model = Model.ClaudeOpus4_7,
    Messages =
    [
        new()
        {
            Role = Role.User,
            Content = "Explica en dos párrafos por qué un SDK oficial para C# importa en aplicaciones empresariales .NET."
        }
    ]
};

var response = await client.Messages.Create(parameters);
Console.WriteLine(response);
```

Antes de ejecutar el ejemplo, configura la variable de entorno:

```powershell
$env:ANTHROPIC_API_KEY = "tu_api_key"
dotnet run
```

El ejemplo no pretende ser una arquitectura completa ni una recomendación de producción. Solo deja claro que ya hay un camino oficial para usar Claude desde C#, además de las alternativas que ya existían antes.

## Lo que no conviene exagerar

Aquí también hay que mantener los pies en la tierra.

Un SDK no decide la arquitectura de una aplicación. Tampoco reemplaza la evaluación normal que deberíamos hacer antes de meter IA en un sistema: costos, privacidad, seguridad, trazabilidad, latencia, disponibilidad y mantenimiento.

Además, la propia documentación indica que el SDK está en beta. Eso no lo descalifica, pero sí invita a revisarlo con el criterio normal de cualquier dependencia nueva: probarlo, leer sus límites y no asumir estabilidad perfecta desde el primer día.

Por eso no conviene presentarlo como una revolución para .NET. No lo es.

Lo publicaría como una nota de lectura profesional: una señal más de que el ecosistema .NET sigue teniendo espacio en la conversación de IA aplicada.

## Por qué sí me parece una buena noticia

Mi punto es sencillo: no todo lo relacionado con IA termina en un notebook, ni todo sistema moderno se construye alrededor de JavaScript.

Hay una parte enorme del software que sigue viviendo en backends, servicios, procesos de negocio e integraciones empresariales. En ese terreno, .NET tiene una presencia fuerte y una cultura de ingeniería bastante madura.

Que Claude tenga un SDK para C# facilita la integración, sí, pero el punto principal no es la comodidad. El punto principal es que C# sigue siendo suficientemente importante como para recibir soporte directo de proveedores relevantes de IA.

Para mí, esa es la lectura más razonable:

* Python seguirá siendo muy fuerte para investigación, prototipos y ciencia de datos.
* JavaScript seguirá siendo clave por su alcance en web y herramientas.
* .NET seguirá siendo relevante donde importa construir, integrar y mantener software de negocio.

No son mundos excluyentes. Son herramientas distintas para contextos distintos.

## Mi lectura final

Este artículo no debería vender la idea de que el SDK de Anthropic cambia el panorama completo de .NET. Eso sería inflar demasiado una noticia puntual.

Pero sí creo que merece comentarse porque apunta a algo que a veces se olvida en medio del ruido: la IA no vive solo en demos, notebooks o aplicaciones pequeñas. También tiene que integrarse en sistemas existentes, con reglas de negocio, seguridad, despliegues, auditoría y mantenimiento.

En ese mundo, .NET sigue siendo una opción muy seria.

Por eso me parece una buena noticia ver un SDK de Claude para C#. No por nostalgia ni por apego a una tecnología, sino por una razón bastante práctica: cuando hablamos de IA aplicada a software real, C# todavía tiene mucho que aportar.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [Documentación oficial del SDK de Claude para C#](https://platform.claude.com/docs/en/api/sdks/csharp)
* [Paquete Anthropic en NuGet](https://www.nuget.org/packages/Anthropic)
* [Modelos de Claude y recomendaciones de IDs estables](https://docs.anthropic.com/en/docs/about-claude/models/overview)

---

## Cuando Azure Functions dejó de tener sentido en Kubernetes

URL: https://programemos.net/azure-functions-kubernetes-webapi-workers-cronjobs/
Fecha: 2026-05-22
Categorías: Azure, Arquitectura de Software, Programación, Opiniones
Descripción: Por qué migramos Azure Functions en AKS a Web APIs, workers y CronJobs para reducir acoplamiento, tamaño de imagen y complejidad operativa.

Durante bastante tiempo usamos **Azure Functions** para resolver muchos procesos dentro de nuestros proyectos. Tenía sentido. Si necesitábamos exponer algo por HTTP, una Function. Si había un evento de Event Grid, una Function. Si llegaba un mensaje por Service Bus, otra Function. Si algo tenía que ejecutarse cada cierto tiempo, Timer Trigger.

Ese modelo funciona muy bien cuando realmente estás usando Azure Functions como producto gestionado de Azure.

Pero el contexto cambió.

El proyecto se movió a **Kubernetes**. Ya no estábamos desplegando esas piezas como recursos nativos de Azure Functions, sino como contenedores dentro de AKS. Y ahí empezó la pregunta incómoda: si todo corre como imagen Docker dentro de Kubernetes, ¿de verdad necesitamos seguir cargando el runtime de Azure Functions para cada caso?

La respuesta, en nuestro caso, fue no.

No porque Azure Functions sea malo. Al contrario, sigue siendo una herramienta muy buena. El problema era otro: **dentro de Kubernetes, varias de esas Functions ya no estaban aprovechando lo suficiente del modelo serverless como para justificar el runtime adicional, el acoplamiento y la complejidad operativa**.

## El problema no era Azure Functions, era el contexto

Azure Functions brilla cuando te quita trabajo operativo: triggers, bindings, escalado, integración con el portal, diagnóstico, despliegue sencillo y modelo serverless.

Pero cuando lo llevas a Kubernetes, la conversación cambia.

Microsoft documenta que puedes ejecutar contenedores de Azure Functions en Kubernetes, incluso usando KEDA para escalado basado en eventos. Pero también deja claro que ese escenario tiene soporte comunitario o de mejor esfuerzo, y que el equipo queda responsable de mantener sus propios contenedores de Functions dentro del clúster.

Además, si usas imágenes custom de Azure Functions, también tienes que mantener la imagen base actualizada. Microsoft publica actualizaciones periódicas del runtime y de seguridad, pero si tu contenedor no se reconstruye y redespliega, te puedes quedar corriendo sobre una base vieja.

Entonces, visto fríamente, estábamos pagando varias capas:

* Kubernetes.
* Nuestra imagen Docker.
* El runtime de Azure Functions.
* Las extensiones y bindings de Functions.
* La lógica real de negocio.

Y en muchos casos la capa de Functions ya no era la que estaba aportando más valor.

## La conversión que hicimos

La migración no fue un "reescribamos todo". Fue más bien traducir cada tipo de Function a la primitiva que mejor encajaba en Kubernetes.

![Diagrama de migración desde Azure Functions hacia Web API, Worker y CronJob en Kubernetes](https://programemos.net/images/azure-functions-kubernetes-migracion-flujo.webp)

*La migración no fue eliminar capacidades, sino mover cada responsabilidad a una primitiva más natural en Kubernetes.*

La equivalencia quedó más o menos así:

| Antes | Después |
| --- | --- |
| HTTP Trigger | ASP.NET Core Web API |
| Event Grid Trigger | Endpoint HTTP en Web API |
| Service Bus Trigger | Worker o consola .NET usando Azure.Messaging.ServiceBus |
| Timer Trigger | Kubernetes CronJob |

Esto parece un cambio pequeño, pero operacionalmente cambia bastante.

Un HTTP Trigger de Functions y un endpoint de Web API pueden resolver lo mismo desde fuera: reciben una petición y responden. Pero si el resto del sistema ya vive en ASP.NET Core, si el pipeline ya está preparado para APIs, si el monitoreo ya mira deployments y pods, entonces convertirlo en Web API reduce fricción.

Con Event Grid pasó algo parecido. Si usas el trigger nativo, Azure Functions te resuelve parte de la integración. Al pasarlo a Web API, tienes que implementar el endpoint de validación de la suscripción y procesar el payload. Pero en la práctica no fue una complicación enorme: es recibir el evento de validación, responder el `validationCode` y luego manejar los eventos reales.

Y hay una ventaja muy concreta: un endpoint HTTP normal es más fácil de probar, versionar, simular y automatizar dentro de un equipo que ya trabaja con APIs.

## Service Bus: menos acoplamiento y más control

El caso de **Service Bus** fue uno de los más interesantes.

Con Azure Functions, el binding de Service Bus te da muchas cosas listas: concurrencia, auto-complete, renovación de locks, manejo del mensaje y configuración vía `host.json`. Eso es cómodo. Pero también te acopla al modelo de extensiones de Functions.

Al migrarlo a una aplicación .NET normal, pudimos usar directamente la librería nativa:

```csharp title="Worker.cs"
var processor = client.CreateProcessor("orders", new ServiceBusProcessorOptions
{
    AutoCompleteMessages = false,
    MaxConcurrentCalls = 8
});

processor.ProcessMessageAsync += async args =>
{
    await ProcessOrder(args.Message);
    await args.CompleteMessageAsync(args.Message);
};

processor.ProcessErrorAsync += args =>
{
    logger.LogError(args.Exception, "Error procesando mensaje de Service Bus");
    return Task.CompletedTask;
};

await processor.StartProcessingAsync();
```

Esto no significa que desaparezca la responsabilidad. Al contrario: ahora tienes que entender mejor cómo procesas mensajes, cuándo completas, cuándo abandonas, cómo manejas errores y cuánta concurrencia permites.

Pero también ganas control.

Ya no dependes tanto de la versión del binding de Azure Functions ni del runtime para usar las capacidades del SDK. Puedes usar directamente `Azure.Messaging.ServiceBus`, actualizarlo con el ritmo del proyecto y modelar el worker como una aplicación .NET normal.

Para mí, ese punto es importante. Si ya estás en Kubernetes, muchas veces prefiero una aplicación explícita, aburrida y fácil de ejecutar, que una abstracción que fue muy útil en Azure Functions pero que dentro del clúster empieza a sentirse como una capa de más.

Eso sí, una cosa es el ejemplo mínimo y otra producción. En un worker real hay que cuidar `graceful shutdown`, `CancellationToken`, `StopProcessingAsync`, renovación de locks, DLQ, `backoff` y trazabilidad por mensaje. Azure Functions te escondía parte de esa complejidad; al salirte del runtime, esa responsabilidad vuelve a ser tuya.

## KEDA cambió la conversación

La migración a consola o worker no significó dejar procesos prendidos todo el día esperando mensajes.

Aquí entró **KEDA**.

En vez de tener una Function o un worker permanentemente vivo escuchando una cola, usamos escalado basado en la cantidad de mensajes. KEDA puede mirar una cola o suscripción de Azure Service Bus y levantar pods cuando hay trabajo pendiente. Cuando no hay mensajes, puede volver a cero.

Ese cambio fue clave.

Porque ahí la optimización ya no fue solo conceptual. También fue operativa: menos consumo, menos pods activos sin necesidad y mejor alineación con la carga real.

Un ejemplo simplificado de la idea sería este:

```yaml title="scaledobject-servicebus.yaml"
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: order-worker
spec:
  scaleTargetRef:
    name: order-worker
  minReplicaCount: 0
  maxReplicaCount: 10
  triggers:
    - type: azure-servicebus
      metadata:
        queueName: orders
        namespace: my-servicebus-namespace
        messageCount: "5"
```

No estoy diciendo que esta sea la única forma correcta. Puedes usar `ScaledObject`, `ScaledJob` o un modelo distinto según el tipo de procesamiento. El punto es otro: **Kubernetes ya tenía una forma natural de expresar ese comportamiento**, sin necesidad de mantener el runtime de Functions como intermediario.

## Timer Trigger vs CronJob

Los Timer Trigger también fueron una conversión natural.

Si algo se ejecutaba cada cierto tiempo, lo movimos a **Kubernetes CronJob**. Otra vez, no porque Timer Trigger sea malo. Simplemente, si el despliegue, monitoreo y ejecución ya están en Kubernetes, un CronJob se entiende rápido:

```yaml title="report-cronjob.yaml"
apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-report
spec:
  schedule: "0 3 * * *"
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: daily-report
              image: myregistry.azurecr.io/daily-report:1.0.0
```

Aquí también hay que ser honestos: un CronJob no es exactamente lo mismo que un Timer Trigger. Kubernetes tiene su propia semántica de concurrencia y sus propios matices. La propia documentación advierte que, bajo ciertas circunstancias, un CronJob puede crear dos Jobs o ninguno. Por eso conviene diseñar estos procesos como **idempotentes** y pensar en `concurrencyPolicy`, reintentos, ventanas perdidas y observabilidad.

Pero como modelo operativo, encajaba mejor con el nuevo contexto.

## El beneficio más visible: imágenes más pequeñas

Otro beneficio importante fue el tamaño de las imágenes.

Cuando partes de una imagen de Azure Functions, no solo llevas tu código. También llevas lo necesario para ejecutar el runtime de Functions. Eso tiene sentido si quieres ejecutar Functions. Pero si al final tu proceso es una Web API, un worker o una consola, puedes partir de una imagen base más ajustada al caso real.

Eso reduce peso, superficie y tiempos asociados al ciclo de build y despliegue.

No siempre el tamaño de la imagen es el problema principal. Pero cuando tienes muchos procesos pequeños, esa diferencia se acumula.

## Lo que ganamos

Al final, la mejora no vino de una sola cosa. Vino de sumar varias decisiones pequeñas:

* Menos runtime innecesario dentro de AKS.
* Imágenes Docker más pequeñas y enfocadas.
* Menor acoplamiento a bindings y extensiones de Azure Functions.
* Uso directo de librerías .NET como `Azure.Messaging.ServiceBus`.
* Mejor testabilidad en endpoints HTTP y Event Grid.
* CronJobs expresados como recursos nativos de Kubernetes.
* Escalado con KEDA basado en mensajes reales.
* Un modelo operativo más uniforme para el equipo.

Y esto último pesa mucho. A veces la optimización no es solo CPU o memoria. A veces la optimización es que el equipo entienda mejor lo que está desplegando, cómo probarlo y cómo diagnosticarlo cuando falla.

## Lo que tuvimos que asumir

Migrar fuera de Azure Functions también nos obligó a hacer explícitas varias responsabilidades: manejo de retries, idempotencia, `graceful shutdown`, DLQ, `health checks`, métricas por mensaje, configuración de KEDA y mantenimiento de manifests. No fue solo quitar runtime; fue mover responsabilidad desde el framework hacia nuestra arquitectura.

Para algunos equipos eso es una mala noticia. Para otros, especialmente si ya operan AKS con naturalidad, es simplemente volver explícita una complejidad que ya existía.

## Dónde no haría esta migración

No convertiría esto en una regla universal.

Si estás usando Azure Functions como producto gestionado, con consumo serverless, integración directa con Azure, bindings que te ahorran código y poco interés en administrar infraestructura, Azure Functions sigue siendo una excelente opción.

Tampoco migraría solo por moda. Si tu Function App funciona bien, el equipo la entiende y no tienes dolor operativo, moverla a Kubernetes puede ser simplemente cambiar un problema por otro.

Y aquí hay un punto intermedio que sí vale la pena mencionar: **Azure Container Apps**. Si el objetivo es seguir usando Azure Functions en contenedores sin operar directamente el clúster, Azure Container Apps puede ser una alternativa más natural. En nuestro caso, el punto era distinto: el sistema ya estaba operando sobre AKS, con pipelines, observabilidad y despliegues Kubernetes existentes.

Pero cuando ya estás en AKS, ya tienes pipeline de contenedores, ya usas observabilidad de Kubernetes y ya estás pagando el costo de operar el clúster, vale la pena hacerse la pregunta:

**¿Azure Functions sigue aportando suficiente valor aquí, o solo quedó como una capa heredada?**

En nuestro caso, la respuesta fue clara.

Migrar a Web APIs, workers y CronJobs nos dio más control, menos acoplamiento y una forma más natural de operar dentro de Kubernetes. No fue una pelea contra Azure Functions. Fue aceptar que una herramienta excelente en un contexto puede dejar de ser la mejor decisión en otro.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [Linux container support in Azure Functions](https://learn.microsoft.com/en-us/azure/azure-functions/container-concepts)
* [Azure Container Apps hosting of Azure Functions](https://learn.microsoft.com/en-us/azure/azure-functions/functions-container-apps-hosting)
* [Azure Service Bus bindings for Azure Functions](https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-service-bus)
* [ServiceBusProcessorOptions.MaxConcurrentCalls](https://learn.microsoft.com/en-us/dotnet/api/azure.messaging.servicebus.servicebusprocessoroptions.maxconcurrentcalls)
* [Message transfers, locks, and settlement in Azure Service Bus](https://learn.microsoft.com/en-us/azure/service-bus-messaging/message-transfers-locks-settlement)
* [Receive Azure Event Grid events to an HTTP endpoint](https://learn.microsoft.com/en-us/azure/event-grid/receive-events)
* [Azure Service Bus scaler en KEDA](https://keda.sh/docs/2.18/scalers/azure-service-bus/)
* [Kubernetes CronJob](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/)

---

## GitHub Agentic Workflows: automatizar con IA sin soltar el control

URL: https://programemos.net/github-agentic-workflows-ia-controlada/
Fecha: 2026-05-13
Categorías: IA, Opiniones, Programación
Descripción: Qué son GitHub Agentic Workflows, cómo amplían GitHub Actions y por qué sus permisos mínimos, safe outputs y revisión reducen el riesgo de la IA.

Hay una idea alrededor de la inteligencia artificial aplicada al desarrollo que me parece especialmente importante, y no es "que el agente escriba más código".

Es otra: **que la IA trabaje dentro de un proceso controlado**.

Por eso **GitHub Agentic Workflows** me parece una de las propuestas más interesantes que ha mostrado GitHub últimamente.

No porque sea vistosa, sino porque apunta a algo mucho más serio: **automatizar tareas de repositorio con agentes de IA dentro de GitHub Actions, con guardrails reales y una separación explícita entre pensar y ejecutar**.

Para mí, ahí está una parte importante del futuro de la programación y también de la integración continua.

> **Estado en agosto de 2026:** GitHub Agentic Workflows está en *public preview*. La sintaxis y las capacidades pueden cambiar; actualiza `gh aw`, compila de nuevo el workflow y revisa el archivo generado cada vez que modifiques el Markdown.

## El error de pensar solo en autonomía

Durante meses hemos visto demos donde alguien escribe una instrucción amplia y la IA empieza a tocar archivos, ejecutar comandos y resolver tareas. Es llamativo. También es fácil de vender.

Pero en un entorno real eso no basta.

La pregunta no debería ser solamente:

* ¿Qué tan autónomo puede ser el agente?

La pregunta correcta es:

* ¿Qué puede leer?
* ¿Qué salida puede proponer?
* ¿Qué permisos reales tiene?
* ¿Quién aplica los cambios?
* ¿Qué controles existen si el agente se confunde o es manipulado?

Ahí es donde GitHub me parece que está mostrando una dirección mucho más madura.

GitHub Agentic Workflows no nace como un chat con más permisos. Nace como **automatización de repositorios en Markdown**, ejecutada por agentes dentro de GitHub Actions y compilada luego a workflows endurecidos. La idea es que puedas expresar una intención en lenguaje natural, pero que el sistema la convierta en un flujo operativo con límites claros.

Eso cambia por completo el marco de la conversación.

## Qué son y cómo se diferencian de GitHub Actions

GitHub Actions ejecuta pasos deterministas que defines en YAML. Agentic Workflows añade una capa donde describes en Markdown un objetivo que requiere razonamiento; la herramienta `gh aw` lo compila a un workflow de Actions bloqueado (`.lock.yml`). El resultado sigue ejecutándose sobre la infraestructura y los eventos de Actions, pero el agente decide cómo investigar dentro de los límites declarados.

Pero lo que realmente me interesa no es la lista de casos de uso. Es **cómo** lo hace.

GitHub Agentic Workflows parte de una idea que considero correcta: el agente **no debería escribir directamente sobre el repositorio**. El agente observa, razona y propone. Luego otro paso, aislado y con permisos acotados, decide si aplica esa salida.

Ese diseño importa mucho.

Porque evita una trampa común: asumir que "más autonomía" equivale automáticamente a "más productividad". A veces solo equivale a más superficie de riesgo.

La arquitectura combina token de solo lectura, aislamiento, control de red, `safe outputs` procesados por un job separado y detección de amenazas antes de aplicar resultados. La configuración concreta puede evolucionar durante la preview, por lo que no conviene confiar en una lista memorizada: hay que revisar el workflow compilado y sus permisos efectivos.

Para mí, esa arquitectura es el corazón de la propuesta.

### Un ejemplo simple: un reporte diario con salida segura

El ejemplo más fácil para entender la diferencia es uno muy simple.

Supongamos que un equipo quiere un reporte diario del estado del repositorio. No quiere abrirle la puerta a un agente con permisos de escritura libres. Solo quiere que lea issues, pull requests y actividad reciente, y que proponga un issue nuevo con el resumen.

Con GitHub Agentic Workflows, el flujo se puede describir en Markdown con frontmatter. Simplificando la idea:

```md title=".github/workflows/daily-status.md"
---
on:
  schedule: daily

permissions:
  contents: read
  issues: read
  pull-requests: read

safe-outputs:
  create-issue:
    title-prefix: "[team-status] "
    labels: [report, daily-status]
---

## Daily Issues Report

Create a daily status report for the team as a GitHub issue.
Include recent repository activity, progress tracking and actionable next steps.
```

Este ejemplo es poderoso justamente porque **no parece una demo agresiva**.

El agente recibe permisos de lectura. No recibe secretos ni un token de escritura. Produce una salida estructurada. Otro job decide si puede crear el issue y bajo qué restricciones.

Ese es el diferencial.

No estamos diciendo "agente, haz lo que haga falta". Estamos diciendo: **lee este contexto, razona, genera esta clase de salida y el sistema solo permitirá esa operación concreta**.

Para empezar, GitHub documenta este flujo básico:

```bash
gh extension install github/gh-aw
gh aw init
gh aw compile
```

Desde junio de 2026, los repositorios de organizaciones también pueden usar el `GITHUB_TOKEN` integrado para Copilot CLI, con `copilot-requests: write` y la política de facturación correspondiente. Otros motores, como Claude Code, OpenAI Codex o Gemini CLI, requieren configurar su propia credencial como secreto. En ambos casos conviene revisar permisos y presupuesto por ejecución.

![Flujo de GitHub Agentic Workflows con agente aislado, salida segura, detección de amenazas y aplicación controlada](https://programemos.net/images/github-agentic-workflows-flujo-seguro.webp)

*El agente propone; el workflow validado decide qué salida puede aplicarse y con qué permisos.*

### Esto es más importante que un chat con permisos

Aquí está la parte que más me interesa.

No creo que el camino correcto sea poner a un agente frente a una consola con demasiada libertad y confiar en que el prompt sea suficiente control.

Eso puede funcionar en tareas personales, en exploración o en prototipos. Pero cuando hablamos de equipos, repositorios reales y procesos de entrega, hace falta otra cosa.

Hace falta:

* permisos mínimos
* outputs permitidos de forma explícita
* separación entre análisis y escritura
* compilación y endurecimiento del workflow
* red de seguridad contra prompt injection y abuso de herramientas
* supervisión humana cuando el impacto lo requiere

GitHub Agentic Workflows está intentando meter la IA justo ahí: **dentro del sistema de automatización, no por fuera de él**.

Y eso me parece clave.

La IA se vuelve mucho más valiosa cuando entra al proceso existente sin romper sus controles.

## Por qué esto toca directamente a CI/CD

La integración continua siempre ha consistido en bajar riesgo:

* detectar errores rápido
* validar cambios antes de integrarlos
* estandarizar pasos repetibles
* evitar que el resultado dependa solo de memoria humana

Agentic Workflows encaja sorprendentemente bien con esa filosofía.

No reemplaza CI/CD. Lo extiende.

La propia documentación lo presenta como una forma de sumar `Continuous AI` a la automatización determinista que ya tenemos. Y eso me parece una descripción bastante acertada.

Puedes imaginar flujos pensados para:

* preparar cambios pequeños a partir de issues claros
* analizar fallos recurrentes de CI
* producir reportes diarios del estado del repositorio
* mantener documentación o clasificar issues
* revisar tendencias sin tener que programar cada rama condicional a mano

Pero el punto importante es que no deberían operar fuera del flujo de entrega. Deberían operar **a través** del flujo.

Por eso me parece tan potente que GitHub haya llevado esta conversación al terreno de los workflows. No está presentando la IA solo como asistente individual, sino como **una nueva capa de automatización gobernada**.

También existe un costo operativo. Cada ejecución consume minutos de Actions y uso del modelo; un disparador demasiado amplio puede convertir una prueba útil en ruido o gasto. Empezaría con un repositorio no crítico, ejecución manual o programada, límites bajos y una única salida segura. Solo ampliaría permisos después de observar falsos positivos, costo y valor generado.

### Lo que esto cambia frente a Azure DevOps

Ya había escrito que GitHub me parece hoy la apuesta más clara de Microsoft en la plataforma de desarrollo. Este tema lo refuerza todavía más.

Azure DevOps sigue siendo fuerte en planificación y mantiene un [roadmap activo](https://learn.microsoft.com/es-es/azure/devops/release-notes/features-timeline), incluso con Copilot Code Reviews para Azure Repos y un MCP Server remoto. No está abandonado. Aun así, la experiencia agéntica más integrada alrededor del repositorio está avanzando primero en GitHub.

Está pasando en GitHub.

No solo porque tenga Copilot o más anuncios alrededor de agentes, sino porque está mostrando una manera concreta de **llevar la IA al proceso de entrega sin destruir las barreras de seguridad que los equipos necesitan**.

Eso no es una función más. Es una visión.

Y, sinceramente, me parece una visión más alineada con lo que viene.

## El futuro no es soltar el volante

No creo que el futuro del desarrollo sea pedirle a una IA que haga "todo" mientras los equipos esperan a ver qué ocurrió.

Creo que el futuro va por otro lado:

* agentes más capaces
* procesos más explícitos
* permisos más estrechos
* outputs seguros
* validaciones más integradas
* humanos revisando decisiones que importan

La IA no elimina la necesidad de ingeniería. La vuelve más visible.

Porque si un agente puede actuar, entonces también tenemos que diseñar mejor sus bordes.

Por eso me gustó tanto esta dirección de GitHub. No por el espectáculo de automatizar, sino por la disciplina de **automatizar con límites**.

Para mí, esa es la manera correcta de llevar agentes al desarrollo real.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [Desarrollar Agentic Workflows en GitHub Actions](https://docs.github.com/es/actions/tutorials/develop-agentic-workflows-in-github-actions)
* [Crear GitHub Agentic Workflows](https://docs.github.com/es/copilot/how-tos/github-agentic-workflows/creating-github-agentic-workflows)
* [Arquitectura de seguridad](https://github.github.com/gh-aw/introduction/architecture/)
* [Safe outputs](https://github.github.com/gh-aw/reference/safe-outputs/)
* [Autenticación sin un PAT](https://github.blog/changelog/2026-06-11-agentic-workflows-no-longer-need-a-personal-access-token/)

---

## Azure DevOps vs GitHub: cuál elegir en 2026

URL: https://programemos.net/azure-devops-vs-github-ecosistema-microsoft/
Fecha: 2026-05-05
Categorías: General, IA, Opiniones
Descripción: Comparo Azure DevOps y GitHub en planificación, CI/CD, IA y migración para decidir qué plataforma conviene adoptar en un proyecto nuevo.

He estado observando algo en el ecosistema de herramientas de desarrollo de Microsoft que al principio era difícil de articular con exactitud. No hay un anuncio oficial que mande a abandonar Azure DevOps. De hecho, su [roadmap de 2026](https://learn.microsoft.com/es-es/azure/devops/release-notes/features-timeline) mantiene inversiones en Azure Boards, Pipelines, seguridad y revisiones con Copilot.

Pero la dirección de ambas plataformas no se siente igual. Azure DevOps sigue evolucionando para la base instalada; GitHub concentra más impulso alrededor del repositorio, la colaboración y los agentes de IA. Si tengo que elegir para un proyecto nuevo, empiezo por GitHub. Si ya existe una operación madura sobre Azure Boards y Pipelines, no migraría solo por moda.

## La diferencia real entre Azure DevOps y GitHub

La cantidad de funcionalidades nuevas en GitHub durante el último año ha sido notable.

GitHub Actions ya es mucho más que una alternativa a Azure Pipelines. Tiene integración directa con el repositorio, las revisiones, los issues y la automatización. Azure DevOps ofrece esas capacidades en una suite más amplia, con una separación más marcada entre Boards, Repos, Pipelines, Test Plans y Artifacts.

Pero lo que realmente marca un antes y un después es la integración con IA. No me refiero solo a Copilot como autocompletado de código. Me refiero a algo más concreto: **agentes de IA que pueden tomar un issue abierto, escribir código, crear commits y abrir un pull request de forma autónoma**. Eso no es un asistente. Eso es un cambio en cómo funciona el flujo de desarrollo.

Lo que me parece más interesante no es solo que existan agentes, sino cómo GitHub está pensando en darles estructura para que funcionen bien. [GitHub Agentic Workflows](https://docs.github.com/es/actions/tutorials/develop-agentic-workflows-in-github-actions), actualmente en *public preview*, integra agentes con rieles claros dentro de GitHub Actions. No como un generador de código suelto, sino con contexto, visibilidad y control en cada paso.

Y todo esto ocurre dentro de la misma plataforma, sin saltar a otra herramienta.

| Si tu prioridad es... | Empezaría por... | Motivo |
| --- | --- | --- |
| Repositorio, pull requests, Actions y agentes en un mismo lugar | GitHub | La experiencia de desarrollo y la inversión en IA están más integradas |
| Backlogs jerárquicos, capacidad, sprints y trazabilidad formal | Azure DevOps | Azure Boards conserva un modelo de planificación más completo |
| Mantener procesos empresariales ya estabilizados | Azure DevOps o un modelo híbrido | Migrar tiene costo y no siempre produce valor inmediato |
| Crear una plataforma nueva sin dependencias heredadas | GitHub | Reduce fricción y deja una ruta más directa hacia Copilot y automatización agéntica |

## Dónde Azure DevOps sigue siendo superior

No voy a ser injusto. Azure DevOps es una plataforma madura que he usado extensamente en entornos corporativos, y ha cumplido muy bien su función.

Hay un área donde sigue siendo claramente superior: **la planificación del trabajo**.

Azure Boards tiene un modelo de gestión del trabajo mucho más completo que lo que GitHub ofrece hoy con Issues, Projects y Milestones. Épicas, *user stories*, tareas anidadas, sprints con capacidad del equipo, backlogs jerárquicos. Está diseñado para organizaciones que necesitan estructura y trazabilidad real en sus procesos, no solo para equipos que trabajan en proyectos open source.

Y lo interesante es que no tienes que elegir uno u otro para esto: Azure Boards se puede integrar directamente con repositorios de GitHub. Puedes tener la gestión de trabajo en Azure DevOps y el código en GitHub, y funcionan bien juntos.

![Comparación de capacidades entre Azure DevOps y GitHub en CI/CD, planificación e IA](https://programemos.net/images/azure-devops-github-comparacion.webp)

*Dónde gana cada plataforma en el ecosistema Microsoft hoy*

Si trabajas en una empresa con procesos formales de gestión de proyectos y sprints estructurados, Azure DevOps Boards todavía no tiene un equivalente directo en GitHub.

Fuera de eso, la brecha se está ampliando en la dirección contraria.

## ¿Está Microsoft apostando por GitHub?

La pregunta que me genera todo esto es bastante concreta: **¿está Microsoft apostando estratégicamente por GitHub como su plataforma principal de desarrollo?**

Mi lectura es que sí, especialmente para el código y la experiencia diaria del desarrollador. Es una interpretación de las inversiones visibles, no un anuncio de retirada de Azure DevOps.

La señal es clara: GitHub ya no es solo un lugar donde se guarda código. Se ha convertido en la plataforma central del ecosistema de desarrollo de Microsoft, y especialmente en el punto de entrada a todo lo que tiene que ver con inteligencia artificial.

Azure DevOps sigue activo y su roadmap demuestra que recibe funciones nuevas. Microsoft está llevando Copilot Code Reviews a Azure Repos, mejorando la integración entre Azure Boards y GitHub y preparando un MCP Server remoto. Hay un segmento enorme de empresas con procesos definidos, flujos establecidos y equipos que no van a migrar fácilmente. Microsoft tiene razones para invertir en ambas plataformas.

La diferencia está en el centro de gravedad. GitHub es donde la integración entre repositorio, comunidad, Copilot, Actions y agentes se siente más natural. Azure DevOps sigue siendo una buena plataforma empresarial, pero ya no asumiría que debe ser la opción predeterminada solo por trabajar con Azure o .NET.

En mi caso, ese cambio ya está pasando. Los proyectos nuevos que inicio los llevo directamente a GitHub. No porque Azure DevOps sea malo, sino porque GitHub hoy ofrece un ecosistema más completo y más alineado con hacia dónde va la industria.

## No te cases con las herramientas

Este desplazamiento me parece una señal importante para todos nosotros.

Hace no mucho tiempo, GitHub no era una alternativa seria frente a Azure DevOps en CI/CD. Si alguien en un equipo enterprise hubiera propuesto migrar de Azure Pipelines a GitHub Actions hace tres años, la respuesta habría sido escéptica, con razón.

Hoy, esa percepción ha cambiado completamente. Y probablemente seguirá cambiando.

Y aquí hay algo que me resulta familiar. Lo mismo pasó con Team Foundation Server, el sistema de control de versiones de Microsoft. Nunca hubo un anuncio oficial diciendo "dejen de usar TFVC y migren a Git". Pero poco a poco, la energía, las integraciones y las nuevas funcionalidades fueron apareciendo en Git. Y al final, la mayoría terminamos migrando, no porque alguien lo ordenara, sino porque la dirección estaba clara.

No afirmaría que Azure DevOps repetirá exactamente esa historia. Sí creo que vale la pena revisar cada año si la razón para seguir ahí es una ventaja concreta o simplemente la inercia.

El ecosistema tecnológico —especialmente todo lo que rodea a la inteligencia artificial— está evolucionando demasiado rápido para aferrarse a una herramienta por costumbre o por comodidad. Lo que hace un año no era competitivo puede convertirse en el estándar en meses.

Eso no significa estar migrando todo constantemente. Significa mantenerse observando, evaluando y tomando decisiones con criterio. No con inercia.

Si estás evaluando una migración, empieza con un inventario, un piloto y una prueba de trazabilidad. GitHub ofrece [GitHub Enterprise Importer para migrar desde Azure DevOps](https://docs.github.com/es/migrations/ado/migrate-your-repositories-from-azure-devops-to-github), pero mover repositorios no resuelve automáticamente Boards, permisos, paquetes, pipelines ni hábitos del equipo.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [Roadmap oficial de Azure DevOps](https://learn.microsoft.com/es-es/azure/devops/release-notes/features-timeline)
* [Integración de Azure Boards con GitHub](https://learn.microsoft.com/es-es/azure/devops/boards/github/features-timeline?view=azure-devops)
* [Diferencias entre Azure DevOps y GitHub](https://docs.github.com/es/migrations/ado/key-differences-between-azure-devops-and-github)
* [Migrar repositorios desde Azure DevOps](https://docs.github.com/es/migrations/ado/migrate-your-repositories-from-azure-devops-to-github)

---

## Microsoft Agent Framework en .NET: lo que nadie te dice sobre agentes en producción

URL: https://programemos.net/microsoft-agent-framework-dotnet-agentes/
Fecha: 2026-04-11
Categorías: IA, Opiniones, Programación
Descripción: Análisis de Microsoft Agent Framework .NET y los problemas reales de llevar agentes a producción: gobernanza, memoria, observabilidad y control.

Microsoft ha lanzado la primera versión estable de su Agent Framework. Y, más allá del sello de estable, como programadores .NET debemos empezar a mirar esto de cerca.
Porque cuando un agente entra en una empresa deja de ser una demo simpática. Pasa a ser un sistema que necesita control, memoria, observabilidad y gobernanza.

Yo ya había jugado con este framework cuando todavía estaba en preview, así que esta opinión no nace solo del anuncio de salida.

No empecé a mirarlo ahora. La versión estable, más que descubrírmelo, me confirmó que Microsoft quiere empujar esto en serio y que merece la pena pararse a evaluar hacia dónde apunta.

## El problema real: demo vs producción

No me interesa tanto el titular de "nuevo framework". Me interesa otra cosa: **qué problemas está intentando reconocer como reales**.

Porque la mayoría del contenido que veo sobre agentes sigue girando alrededor de demos personales, asistentes simpáticos y flujos que funcionan muy bien... hasta que intentas meterlos en una empresa de verdad.

Y ahí cambia todo.

Hay una diferencia enorme entre:

* Un agente demo
* Un agente en producción

La demo impresiona rápido, pero en producción te obliga a responder preguntas que el hype prefiere evitar.

Por eso `Microsoft Agent Framework` me parece relevante. No porque venga a resolver mágicamente el problema, sino porque, por fin, empieza a tratar los agentes como lo que realmente son cuando salen del laboratorio: **sistemas de software con memoria, herramientas, estado, control, auditoría y coste**.

Y aquí quiero dejar una cosa clara. No estoy menospreciando el trabajo de proyectos como `OpenClaw`.

De hecho, buena parte de estas opiniones empezaron cuando instalé `OpenClaw` en una `Raspberry Pi 5` y lo probé pensando que, en el fondo, tampoco era una aplicación tan compleja: un LLM con muchas `skills` y poco más.

Llegué a pensar que podía replicarlo sin demasiada dificultad. Y ahí fue donde me llevé el golpe.

Justo intentando algo así empecé a encontrarme con muchos de los problemas que comento en este artículo.

No porque la tecnología estuviera mal, sino porque **desarrollar algo así es bastante menos trivial de lo que parece desde fuera**.

En mi caso, ese choque fue lo que me sirvió de base para entender mejor los problemas que luego aparecen cuando te enfrentas a agentes en entornos empresariales.

## Qué aporta Microsoft Agent Framework

Durante bastante tiempo, en .NET hemos tenido capacidad para jugar con IA. Eso no faltaba. Podíamos usar modelos, integrar herramientas, probar `Semantic Kernel`, mirar `AutoGen` y montar cosas interesantes.

El problema aparecía cuando queríamos pasar del experimento a algo más serio. Ahí todo se volvía más difuso: muchas piezas, demasiadas decisiones dispersas y bastante trabajo manual para llegar a una arquitectura medio coherente.

Por eso creo que este framework sí importa. Según la documentación oficial, Microsoft separa de forma bastante clara:

* **Agentes** para interacción con LLMs, herramientas y contexto.
* **Workflows** para procesos con pasos explícitos, rutas tipadas, *checkpointing* y escenarios de *human in the loop*.

Eso suena a texto de documentación. Pero traducido a lenguaje de ingeniería significa algo bastante útil: **ya no todo debe resolverse con "más prompt" y más autonomía del modelo**. Podemos distinguir mejor entre razonamiento abierto y control de ejecución.

Y eso, para mí, es el aporte más importante del framework: no solo mezcla bastante bien ideas de `Semantic Kernel` y `AutoGen`, sino que además introduce `workflows` explícitos y una conversación más seria sobre estado, ejecución y persistencia.

Y eso es exactamente lo que necesitábamos.

No veo este lanzamiento como "otro SDK más". Lo veo como la síntesis pendiente entre lo que `Semantic Kernel` aportaba en ecosistema y lo que `AutoGen` aportaba en orquestación. No digo que la síntesis ya sea perfecta. Pero **la dirección sí me parece correcta**.

## Los 4 problemas reales de los agentes en producción

La mayoría del contenido sobre agentes está pensado para demos. Y eso tiene sentido: una demo es lo que mejor entra por los ojos.

Pero una demo no te obliga a responder preguntas incómodas.

Y aquí está también parte de mi crítica.

No va contra proyectos como `OpenClaw`, ni contra el trabajo que hay detrás, que me parece bastante más serio de lo que mucha gente cree.

Mi crítica va más al uso que se hace de ellos y a cómo, a veces, se presentan casi como si fueran la prueba de que construir agentes fuera poco más que ensamblar piezas ya existentes.

No funciona así.

Por ejemplo:

* ¿Qué herramientas puede ejecutar ese agente y cuáles no?
* ¿Quién autorizó esa acción?
* ¿Qué hizo exactamente el modelo antes de tomar esa decisión?
* ¿Cuánto costó esa interacción?
* ¿Qué parte del contexto se guardó y por qué?
* ¿Cómo recuperas un flujo cuando el modelo falla a mitad de proceso?

Ahí empieza el mundo real. Y ahí también empieza la distancia entre alguien que conecta un LLM y alguien que diseña un sistema serio alrededor de él.

Y lo que más me sorprende no es que una persona no técnica simplifique todo esto. Eso es normal.

Lo que me sigue sorprendiendo es ver a gente técnica hablando de agentes como si todos estos problemas fueran detalles menores o una fase posterior que ya se resolverá sola.

### 1. Gobernanza

En entornos enterprise no todos los agentes pueden ejecutar todo. Y no todos los usuarios deberían poder disparar las mismas capacidades.

Eso parece obvio cuando hablamos de APIs tradicionales. Pero curiosamente, en agentes, mucha gente actúa como si el modelo fuera una especie de operador neutral al que basta con darle herramientas y ya.

Y no. En una empresa, un agente no puede vivir como un asistente simpático con acceso libre a herramientas. Necesita límites, permisos, aprobaciones y trazabilidad. Si no hay control, no hay sistema. Hay riesgo operativo.

Si un agente puede consultar datos, lanzar procesos, escribir en sistemas o invocar herramientas sensibles, necesitas como mínimo:

* Control de acceso por rol.
* Restricción de herramientas.
* Aprobaciones en acciones delicadas.
* Auditoría de qué pasó, quién lo activó y qué ejecutó realmente el sistema.

Y aquí es donde me parece interesante que Microsoft hable de `workflows`, de `human in the loop`, de `approvals`, de estado persistente y de trazabilidad con OpenTelemetry.

No porque eso cierre el problema por sí solo, sino porque **por fin reconoce que el problema existe**.

Ese es el tipo de detalle que separa un juguete de una plataforma útil.

### 2. Observabilidad

Aquí soy bastante radical: **un agente sin trazas es una caja negra**.

Y si no puedes observar lo que hace el agente, no deberías ponerlo en producción.

No basta con ver la respuesta final bonita. Necesitas poder responder preguntas mucho menos agradables:

* ¿Qué herramientas ejecutó?
* ¿En qué orden?
* ¿Qué decisión tomó el modelo antes de llamar a esa herramienta?
* ¿Cuántos tokens consumió?
* ¿Cuánto tardó cada paso?
* ¿Dónde falló?

![Esquema de un sistema de agentes enterprise con gobernanza, observabilidad, memoria y control de ejecución](https://programemos.net/images/agent-framework-memoria-decisiones.webp)

*Cuando un agente sale de la demo, entran en juego gobernanza, observabilidad, memoria y control de ejecución.*

Eso implica `logging` estructurado, trazabilidad, métricas y correlación entre pasos.

Implica saber si el problema fue el modelo, el contexto, la herramienta, una política de aprobación o simplemente una mala decisión de diseño.

Y vuelvo al punto anterior: me parece buena señal que Microsoft esté metiendo observabilidad y estado como parte del discurso del framework.

Porque en producción un agente no es solo una interfaz conversacional. Es una cadena de decisiones que tienes que poder inspeccionar.

### 3. Memoria

Cuando se habla de memoria, mucha gente se queda en la versión más superficial del concepto: "el agente recuerda cosas".

Sí. Claro. Pero eso no dice nada útil.

La memoria no es una feature. Es una decisión de arquitectura.

Guardar contexto no es diseñar memoria. Diseñar memoria es decidir **qué se guarda, cuánto tiempo vive, cuándo vuelve al contexto y cuánto cuesta mantenerlo**.

> “El problema no es que un agente tenga memoria. El problema es decidir qué merece quedarse, qué debe resumirse y qué no debería volver nunca al contexto.”

Yo suelo pensarlo así:

* Memoria corta → útil para conversación y contexto inmediato.
* Memoria persistente → útil cuando hay historial, personalización o trazabilidad.
* Memoria resumida → útil cuando el contexto crece pero no quieres pagar tokens sin control.
* Memoria por rol o tarea → útil cuando no todo el contexto debe reinyectarse siempre.

Y si eliges mal, el impacto es inmediato:

* Más tokens.
* Más latencia.
* Peor calidad de respuesta.
* Más dificultad para depurar por qué el agente decidió algo raro.

Lo que me gusta es que el framework ya habla de sesiones, `memory & persistence` y proveedores de contexto.

Y aquí conviene no confundirse: que el framework hable de memoria, estado o `workflows` no significa que el problema esté resuelto. Significa solo que Microsoft, esta vez sí, está mirando el problema correcto.

### 4. Control de ejecución

Aquí es donde desaparece el hype y empieza el trabajo de ingeniería.

Cuando construyes agentes de verdad aparecen problemas menos vistosos, pero mucho más importantes:

* Optimización de tokens.
* Compresión de contexto.
* Manejo de errores del modelo.
* Reintentos y recuperación de estado.
* Decidir cuándo usar `tools`, cuándo `function calling` y cuándo un `workflow` determinista.
* Limitar el perímetro de ejecución para que el agente no haga más de la cuenta.

Y aquí también conviene decir algo incómodo: no todo necesita multiagentes.

De hecho, muchas veces meter más agentes solo compra más latencia, más coordinación y más coste.

## Modelo mental de un agente en producción

Si tuviera que resumirlo mucho, para mí un agente en producción es esto:

* Un `LLM` para razonar.
* `Tools` para actuar.
* Memoria para mantener contexto útil.
* Gobernanza para poner límites.
* Observabilidad para entender qué está haciendo realmente.

Si falta una de esas piezas, normalmente no tienes un agente enterprise. Tienes una demo con más o menos ambición.

## Decisiones arquitectónicas clave

Aquí es donde, para mí, se separa un enfoque serio de uno improvisado.

Si ya tienes lógica de negocio clara, integraciones definidas y reglas conocidas, muchas veces prefiero:

* `tools` bien delimitadas
* `workflows` para pasos deterministas
* memoria mínima necesaria
* aprobaciones donde el riesgo lo exija

A partir de ahí ya decides si te compensa dejar más autonomía al modelo, introducir `function calling` en escenarios concretos o separar responsabilidades en subagentes.

Y solo entonces, si aporta de verdad, dar más autonomía al modelo.

Sé que hay quien dirá que eso suena menos futurista. Puede ser.

Pero en una empresa seria normalmente no te pagan por hacer la demo más vistosa. Te pagan por diseñar algo que no explote a la primera semana.

## Ahí cambia el rol del desarrollador

Hoy cualquiera puede conectar un LLM. Eso ya no es diferencial.

Lo difícil ahora es otra cosa:

* Diseñar sistemas robustos.
* Controlar el comportamiento del agente.
* Optimizar costes sin destruir calidad.
* Gobernar herramientas, permisos y memoria.
* Hacer que todo eso sea observable, recuperable y mantenible.

Ahí está, para mí, el valor profesional real.

Por eso creo que este tipo de artículo importa más que otro tutorial de "cómo crear tu primer agente".

El futuro no va a pertenecer a quien sepa pegar cuatro llamadas a un modelo. Va a pertenecer a quien entienda cómo convertir eso en un sistema con criterio de ingeniería.

## El punto que me interesa

`Microsoft Agent Framework` no me parece perfecto. Todavía habrá que ver cuánto madura y cuánto de su promesa aguanta cuando salgamos del ejemplo bonito.

Pero sí me parece que está bien enfocado. Y eso es importante.

Porque construir agentes no es difícil en concepto. Lo difícil es la verdad incómoda que casi nadie cuenta: gobernanza, observabilidad, memoria, control de ejecución, recuperación de estado y coste.

El futuro no pasa simplemente por usar agentes. Pasa por saber diseñarlos bien cuando aparecen los problemas de verdad: permisos, memoria, coste, observabilidad, errores y control de ejecución.

Por eso creo que Microsoft va en la dirección correcta. No porque ya haya resuelto el problema, sino porque al menos está apuntando al problema correcto.

Y ojalá eso nos empuje también a diseñar agentes con más criterio de arquitectura: menos asistentes genéricos y más sistemas capaces de convivir con gobernanza, observabilidad, memoria y control real en entornos enterprise.

El futuro no es construir agentes.

Es saber gobernarlos.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

* [Microsoft Agent Framework documentation](https://learn.microsoft.com/en-us/agent-framework/)
* [Microsoft Agent Framework Overview](https://learn.microsoft.com/en-us/agent-framework/overview/)
* [Introducing Microsoft Agent Framework: The Open-Source Engine for Agentic AI Apps](https://devblogs.microsoft.com/foundry/introducing-microsoft-agent-framework-the-open-source-engine-for-agentic-ai-apps/)

---

## Migré mi blog de WordPress a Astro. La IA ayudó.

URL: https://programemos.net/de-wordpress-a-astro-con-ia/
Fecha: 2026-03-19
Categorías: General, Programación, IA
Descripción: Cómo migré este blog de WordPress a Astro en una noche usando IA como compañero, no como reemplazo, y por qué eso cambió mi forma de escribir.

Este artículo es un poco diferente. No voy a hablar de .NET, ni de patrones, ni de arquitectura empresarial.

Quiero contar algo que hice hace unos días. No es nada revolucionario, pero sí refleja bien cómo está cambiando nuestra forma de trabajar con la IA. No es un "la IA hace todo". Es más bien un "la IA me quita trabajo que realmente no quiero hacer".

## El blog que llevaba años igual

Este blog estaba en WordPress desde hace más de dos años. Lo típico: plugins de SEO, formularios de contacto, suscripciones, publicación de artículos. WordPress funcionaba bien para lo que necesitaba.

Pero había algo que siempre me frenaba cuando pensaba en migrar: el esfuerzo. Convertir el contenido, las imágenes, el SEO, replicar el diseño… era demasiado trabajo para algo que no era prioridad. Había considerado varias opciones — plataformas tipo Medium (pierdes control), algo custom (demasiado tiempo), sitios estáticos (buena idea, pero nunca era el momento). Y así se quedó, en idea, durante mucho tiempo.

Lo que cambió no fue WordPress. Fue que con IA ese esfuerzo dejó de ser un bloqueante.

## La IA como compañero, no como protagonista

Aquí es donde entra la IA, pero no como protagonista.

No fue "hazme todo". Fue más bien como hablar con un compañero. Le expliqué el contexto: cómo estaba el blog, qué quería lograr, qué no quería complicar. Le dije que no soy frontend, que no quería invertir semanas en esto, y que el objetivo era escribir más, no mantener más.

De ahí salió la recomendación: **Astro**. Me lo explicaron de forma simple y suficiente para decidir: contenido estático, poco JavaScript, buen performance. No necesitaba volverme experto. Solo necesitaba entender si tenía sentido para lo que quería.

Y lo tenía.

## El experimento que terminó en producción

Esto empezó como una prueba de una noche. La idea era ver si funcionaba sin comprometerme demasiado.

El proceso fue más o menos así: le pedí a la IA que hiciera scraping de mi blog y generara el markdown de cada artículo. Luego un proceso aparte para descargar y convertir las imágenes — ahí tuve un problema con las imágenes lazy que no cargaban, pero fue cuestión de darle más tiempo de espera al scraper. Con el contenido listo, monté la estructura base en Astro y fui ajustando estilos y detalles visuales.

El resultado fue bueno. No perfecto, pero lo suficientemente bueno. Y algo que no esperaba: al no estar amarrado a un template de WordPress, pude hacer pequeños cambios de diseño que antes no eran viables sin tocar PHP o instalar otro plugin.

Y ahí pasó lo que no esperaba: **lo que era un experimento terminó siendo la migración real**. Porque ya estaba el 70% hecho y el 30% restante era trabajo que de todas formas iba a tener que hacer. No tenía sentido volver atrás.

Sé que hay quien dirá que también existe un plugin para exportar artículos de WordPress, o que hay otras formas de hacerlo. Puede ser. Pero ese no es el punto. El punto es que antes esto no me parecía viable ni rentable en tiempo. Ahora sí.

## Qué cambió realmente

Antes, escribir un artículo implicaba: escribir el contenido, pensar en SEO, ajustar formato, revisar plugins, publicar.

Ahora hago esto: escribo el contenido. Y listo.

Todo lo demás lo delego. No a "la IA que lo hace todo", sino a herramientas que me ayudan a no perder tiempo en lo que no me aporta. Yo sigo escribiendo, pensando, estructurando ideas. Pero ya no me preocupo por cómo queda el HTML, optimizaciones básicas o tareas repetitivas.

## Despliegue y rendimiento

El despliegue lo hice en Cloudflare Pages. Sin complicaciones, gratis, mismo dominio. Y el resultado en rendimiento fue bastante mejor que antes.

![PageSpeed Insights desktop después de migrar a Astro](https://programemos.net/images/pagespeed-desktop.webp)

*Resultado desktop después de la migración*

En móvil el resultado fue igual de bueno, que es donde más se nota la diferencia con WordPress.

![PageSpeed Insights móvil después de migrar a Astro](https://programemos.net/images/pagespeed-movil.webp)

*Resultado móvil después de la migración*

En WordPress había invertido tiempo intentando mejorar el rendimiento — plugins de caché, optimización de imágenes, ajustes varios — y nunca logré acercarme a esto. Sí, sé que comparar WordPress con un sitio estático no es justo. Son enfoques distintos. Pero el punto no es la comparación técnica: es que antes no tenía el tiempo ni los conocimientos para ejecutar esa migración. Ahora sí.

## El punto que me interesa

Tengo este blog porque quiero escribir. Porque quiero compartir. Porque quiero expresar ideas.

Todo lo demás —SEO, formato, publicación, optimización— es trabajo necesario, pero no es el centro. Es soporte. Y ese soporte es justo lo que decidí delegar.

No porque la IA lo haga mejor que yo. Sino porque hacerlo yo no me aporta nada. Y el tiempo que me ahorro lo invierto en lo único que sí me importa: escribir.

No porque sea mejor. Sino porque es mío.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## Menos Infraestructura, Más Valor: Repensando la Arquitectura RAG en .NET

URL: https://programemos.net/gemini-file-search-dotnet-rag/
Fecha: 2025-12-13
Categorías: Arquitectura de Software, IA, Programación
Descripción: Analiza cómo la API Files de Gemini simplifica la arquitectura RAG en .NET, reduciendo infraestructura sin sacrificar capacidad de búsqueda semántica.

Si siguen este blog, saben que aquí no nos quedamos en el «Hola Mundo». Nos gusta hablar de **arquitectura** y de las decisiones difíciles que hay detrás del código. Hoy vamos a analizar una herramienta que nos plantea un dilema interesante sobre la complejidad accidental en nuestros proyectos de IA.

## El panorama real de .NET y la IA

Primero, pongamos los puntos sobre las íes. Existe el mito de que .NET está «atrás» en Inteligencia Artificial. Si hablamos de **entrenamiento de modelos** y ciencia de datos pura, es cierto: Python es el rey.

Pero cuando hablamos de **Ingeniería de IA, Orquestación y Agentes**, la historia es diferente. Con herramientas como **Semantic Kernel** y el **Microsoft Agent Framework**, el ecosistema .NET está al nivel de los mejores. Tenemos la capacidad de construir sistemas robustos. La pregunta es: ¿siempre _necesitamos_ construir el sistema completo?

## El costo oculto del RAG «Artesanal»

Implementar **RAG (Retrieval-Augmented Generation)** en producción es mucho más que enviar un prompt. Si decides hacerlo «a mano», asumes la carga de una infraestructura compleja:

1.  **Chunking:** Decidir cómo trocear la información.
2.  **Embeddings:** Generar y actualizar los vectores.
3.  **Vector Store:** Mantener una base de datos (Pinecone, Qdrant) y pagar por ella.

A menudo terminamos con una arquitectura pesada solo para funcionalidades sencillas.

![RAG Tradicional](https://programemos.net/images/Gemini_Generated_Image_5vfb9z5vfb9z5vfb-1024x559-png.webp)

*RAG Tradicional*

## La Alternativa Pragmática: Gemini File Search

Aquí entra **Gemini File Search**. Véanlo no como una librería más, sino como una decisión de arquitectura: **Serverless RAG**. Delegamos la gestión del índice y la recuperación a Google, convirtiendo un problema de infraestructura en una simple llamada de API.

## El Negocio manda: Privacidad vs. Comodidad

Antes de emocionarnos con la facilidad técnica, hay que pasar por el filtro más importante: **La realidad del negocio.**

En escenarios reales, las decisiones de arquitectura no siempre se basan en qué tecnología es más fácil de usar o cuál tiene mejor _chunking_. A menudo, la decisión la dicta el departamento legal o de seguridad.

Si trabajas en banca, salud o gobierno, subir documentos sensibles a un almacenamiento gestionado por un tercero (como el File Store de Gemini) puede ser **inviable por regulaciones de privacidad**.

**Seamos claros: subir contratos confidenciales de tu empresa o datos personales de clientes a una nube pública sin permiso es probablemente la forma más rápida que existe de actualizar tu estado en LinkedIn a «Open to Work». 😅**

En esos casos, donde los datos no pueden salir del perímetro, la comodidad de la API de Google pasa a segundo plano y **estás obligado** a montar tu propia infraestructura (un RAG artesanal on-premise o un Azure AI Search aislado en una VNET), no por gusto técnico, sino por obligación.

## La Regla de Oro: Entender antes de Abstraer

Dicho lo anterior, si el negocio lo permite y decides usar esta herramienta, **no lo hagas a ciegas.**

Lo que nos define como ingenieros es entender qué estamos abstrayendo.

*   El **Chunking** es crítico.
*   La estrategia de recuperación define la calidad de la respuesta.

Esto aplica para todo: si usas **Gemini File Search**, delegas la ingestión, la indexación y la recuperación en un servicio gestionado, pero conservas algunas decisiones. La [configuración de chunking](https://ai.google.dev/gemini-api/docs/file-search#chunking-configuration) permite definir el máximo de tokens por fragmento y su solapamiento mediante `chunking_config`. Ese control no equivale a implementar tu propio pipeline de recuperación. Y aun con herramientas más configurables como **Azure AI Search**, de nada sirve tener 100 opciones si no entiendes los fundamentos del RAG.

Un mal arquitecto usa Gemini porque «es fácil». Un buen arquitecto lo usa porque evaluó privacidad, control y costos, y decidió que era la pieza correcta para el rompecabezas.

## La Evidencia: Simplicidad en Código

Si has validado los requisitos de privacidad y técnicos, fíjate en la limpieza que logramos en el backend. Todo el ciclo de vida se reduce a unas pocas líneas

**NOTA**: Este no mejor código, se omiten validaciones, es solo de referencia y no debe usarse para producción así.

```csharp
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Mscc.GenerativeAI;

var apiKey = "TU_KEY_GEMINI_CLOUD";
var filePath = "ejemplo_instalacion.txt";
var question = "¿Cuáles son los requisitos de instalación según este documento?";

var googleAi = new GoogleAI(apiKey!);
var model = googleAi.GenerativeModel(Model.Gemini25Flash);
var fileSearchStores = googleAi.FileSearchStoresModel();

// Aquí se crea el storage
var store = await fileSearchStores.Create(new FileSearchStore { DisplayName = "demo-store" });
var uploadResponse = await googleAi.UploadFile(filePath, Path.GetFileName(filePath));
var fileResource = uploadResponse.File!;
while (fileResource.State == StateFileResource.Processing)
{
	await Task.Delay(TimeSpan.FromSeconds(2));
	fileResource = await googleAi.GetFile(fileResource.Name);
}

// Aquí se agrega el archivo
await fileSearchStores.ImportFile(store.Name!, fileResource);
while (true)
{
	var current = await fileSearchStores.Get(store.Name!);
	if ((current.PendingDocumentsCount ?? 0) == 0)
	{
		break;
	}

	await Task.Delay(TimeSpan.FromSeconds(2));
}

// Aquí se hace la consulta
var request = new GenerateContentRequest
{
	Contents =
    [
        new() {
			Role = Role.User,
			Parts = [new TextData { Text = question }]
		}
	],
	Tools =
    [
        new Tool
		{
			FileSearch = new FileSearch
			{
				FileSearchStoreNames = [store.Name!]
			}
		}
	]
};

var response = await model.GenerateContent(request);

Console.WriteLine($"Pregunta: {question}", question);
Console.WriteLine($"Respuesta: {response.Text?.Trim() ?? "(sin texto)"}");
```

¿Vieron lo limpio que quedó el código? Eso sí, **siempre recordando que ya hicimos la tarea previa de evaluar si esto es lo que el negocio necesita**. Pero fíjense en un detalle clave: **no estamos usando una API especial ni un modelo distinto**. Es la misma API de Gemini de toda la vida. Lo único que hacemos es avisarle que tiene una `Tool` (herramienta) nueva disponible. El modelo sigue siendo el mismo, pero ahora tiene la capacidad de consultar esos documentos por su cuenta si lo necesita. Nos ahorramos todo el «pasamanos» de traer los datos y pegarlos en el prompt manualmente.

Si alguna vez sufrieron manteniendo un RAG artesanal, saben que quitarse ese dolor de cabeza no tiene precio.

## Conclusión

Gemini File Search es una herramienta poderosa para eliminar deuda técnica en MVPs y aplicaciones de uso general. Pero no es una excusa para ignorar cómo funcionan los datos por debajo ni para saltarse las reglas del negocio.

Úsala cuando la agilidad sea la prioridad y la privacidad lo permita. Para todo lo demás, el ecosistema .NET tiene las herramientas para construir lo que necesites a medida.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## Vertical Slice en .NET: cuándo usarlo y cuándo no

URL: https://programemos.net/vertical-slice-dotnet-pragmatismo/
Fecha: 2025-09-30
Categorías: Arquitectura de Software, Opiniones, Programación
Descripción: Cómo aplicar Vertical Slice en .NET sin dogmas: estructura por casos de uso, EF Core, límites, ventajas y situaciones donde conviene otra opción.

Vertical Slice Architecture organiza una aplicación por casos de uso, no por capas técnicas. En .NET eso suele significar que `CrearPedido` conserva cerca su endpoint, validación, handler y acceso a datos. La búsqueda también aparece como *vertical slicing*, pero la decisión importante no es el nombre: es si esa estructura reduce el costo de cambiar una funcionalidad.

Mi enfoque es pragmático: **programamos para resolver problemas reales**. A veces nos aferramos a plantillas “porque así es el patrón” y terminamos defendiendo la forma en vez del resultado. En mi experiencia, pensar por casos de uso baja el ruido, reduce choques entre personas y pone el foco en entregar valor.

## Qué significa Vertical Slice en .NET

Vertical Slice organiza el código alrededor de cada caso de uso —por ejemplo, `CrearPedido` o `ConsultarFactura`— en lugar de repartirlo primero entre controladores, servicios y repositorios compartidos. Una feature puede contener su endpoint, validación, handler y acceso a datos, mientras los aspectos realmente transversales conservan convenciones comunes.

```text
Features/
  Pedidos/
    Crear/
      Endpoint.cs
      Command.cs
      Handler.cs
      Validator.cs
    Consultar/
      Endpoint.cs
      Query.cs
      Handler.cs
```

No es «poner todo en un archivo» ni eliminar el dominio. La idea es que un cambio funcional atraviese una porción estrecha y cohesionada del sistema. Antes de elegir una estructura, pregúntate:

*   **¿Aporta claridad?** ¿Alguien nuevo ubica rápido dónde tocar?
*   **¿Nos hace más rápidos sin perder calidad?**
*   **¿Reduce riesgos de verdad** (no escenarios hipotéticos)?
*   **¿Sirve al cliente hoy**, no a un “quizás” de mañana?

Si no, suena a **formalismo**. Y el formalismo se paga caro en tiempo y mantenimiento.

### Una historia de equipo

En un equipo con capas muy marcadas, casi cada PR tocaba “services” y “repositories” compartidos: **choques constantes** y discusiones sobre “¿dónde debería ir?”. Al movernos a **features autocontenidas**, las PR se volvieron **más cortas** y rara vez chocábamos. El caso de uso “se leía solo”.

![Comparación visual de una arquitectura organizada por capas y otra organizada por funcionalidades verticales](https://programemos.net/images/Vertical-Slice-en-NET-png.webp)

*El cambio importante no es el diagrama: es reducir el número de capas compartidas que toca cada caso de uso.*

## El punto que destapa todo: EF Core, repositorio y unidad de trabajo

Suele pasar: se crea un repositorio y una unidad de trabajo encima de Entity Framework Core solo para “respetar el patrón”. ¿El costo? Mucho trámite que pasa llamadas sin aportar. Peor: al imponer ese repositorio encima de EF, te obligas a agregar ahí todos los métodos de consulta que el caso de uso necesite. Aparecen cinco consultas distintas… y terminas parchando la interfaz o multiplicando métodos. Resultado: recortas el potencial de EF Core (consultas expresivas, proyecciones, filtros encadenados) y conviertes algo potente en una API limitada.

> “Si agregas esa abstracción porque de verdad crees que en el futuro vas a cambiar a otro motor de base de datos, ok, tiene sentido (aunque en la práctica es raro). Lo acepto: válido aunque no coincida al 100%. Pero si la razón es solo ‘porque el patrón lo dice’, ahí está mal.”

En un enfoque por **features**, inyectar el DbContext en el lugar del caso de uso te deja **todo el poder del ORM** a mano: consultas claras, proyecciones directas y menos capas de por medio. Eso acelera y baja la parafernalia.

**¿Cuándo sí haría un repositorio/unidad de trabajo?**

*   Si tienes **más de una fuente de datos real** (EF + Dapper + servicio externo) y alternas según escenario.
*   Si un agregado con **invariantes** gana legibilidad y pruebas más limpias con un repositorio explícito.
*   Si expones un **puerto de aplicación** de alto nivel que ordena el lenguaje del negocio.

Fuera de eso, envolver por costumbre te frena y te limita sin beneficio claro.

### Señales de que puede ayudarte

*   ¿Hay **conflictos de merge** por tocar capas compartidas?
*   ¿Las PR son **largas y difusas** por “protocolo” de capas?
*   ¿Necesitas **consultas ricas** y tu repositorio se vuelve un cajón de sastre?
*   ¿El equipo invierte horas defendiendo **plantillas**, no resultados?

Si marcaste varias, prueba a organizar **por features** y a **evitar capas por costumbre**. Mide después: PR más cortas, menos choques, menos burocracia.

## Cuándo sí y cuándo no

No digo que [Vertical Slice](https://www.jimmybogard.com/vertical-slice-architecture/) sea “mejor para todos”. Tiene sus problemas: puede aparecer duplicación si nadie decide cuándo factorizar, el cross-cutting se dispersa si no hay convenciones (validación, logging, seguridad), y en equipos grandes conviene acordar nombres y ubicación para no perder descubribilidad. Hay que vigilarlo.

### Lo que uso en el día a día

En mi práctica diaria uso una **mezcla**: features verticales en la aplicación, **principios** de Clean para mantener el **dominio** independiente y una **infraestructura** clara para lo técnico (persistencia, cache, mensajería, auth). Funciona porque cuida los **principios** sin caer en rigidez de manual.

### Criterios de excepción

*   **Abstrae** cuando haya **variabilidad real** (hoy EF, mañana otra cosa) o cuando el contrato de negocio gane **claridad**.
*   **No abstraigas** cuando sea solo “por tradición” y te quite el poder de la herramienta (como EF Core) sin un beneficio claro.
*   **Factoriza** duplicación cuando **duela** (mantenimiento, bugs, coste), no antes.

## Otros ejemplos donde el pragmatismo debe ganar

**1) CRUD simple “vitaminado” con Clean, CQRS y eventos de dominio**  
He visto apps que son altas/bajas/modificaciones sin reglas complicadas, pero se les cuelga todo el aparato: CQRS completo, Clean con muchas capas, eventos por todos lados. Resultado: más trámite que valor.

*   **Cuándo sí**: necesitas escala clara (lecturas y escrituras con ritmos muy distintos), auditoría fina o proyecciones complejas que justifican separar rutas y modelos.
*   **Cuándo no**: CRUD directo con validaciones básicas y poco volumen. Empieza simple; añade piezas si el **dolor** aparece.

**2) Microservicios para un sistema local, pequeño y de mantenimiento**  
Para una empresa local con un módulo de back-office acotado, irse a microservicios por defecto suele sumar sobrecarga operativa (infra, observabilidad, despliegues, resiliencia, consistencia distribuida) sin retorno claro.

*   **Cuándo sí**: equipos múltiples con ritmos de despliegue independientes, bounded contexts bien definidos, requerimientos fuertes de aislamiento y escalado por partes.
*   **Cuándo no**: un equipo pequeño, alcance reducido y dependencias simples. Un monolito modular llega más lejos de lo que parece.

**3) “Usar MediatR = hacer CQRS”**  
MediatR no es sinónimo de CQRS. Es una librería que implementa el patrón mediador y ofrece cosas útiles (handlers, notificaciones, behaviours).

*   **Si solo lo usas** para separar comandos/consultas sin aprovechar behaviours, notificaciones o eventos, quizá estás añadiendo una dependencia que no te hace falta: crea interfaces simples y listo.
*   **Si sí lo usas** para mediador real (behaviours transversales, eventos de dominio, notificaciones), entonces tiene sentido: centralizas transversales y ordenas el flujo.

## Para cerrar

[Vertical Slice](https://www.jimmybogard.com/vertical-slice-architecture/) y Clean no son bandos; son **herramientas** para mirar el mismo problema. Lo importante es el **pragmatismo**: elegir lo que hace al equipo **más claro, más rápido y más efectivo** para el cliente **hoy**. Si la única defensa de una decisión es “porque el patrón”, sospecha: quizá no es la mejor decisión para tu contexto.  

Si quieres seguir aprendiendo sobre estos temas, te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

*   [Vertical Slice Milan Jovanovic](https://www.milanjovanovic.tech/blog/vertical-slice-architecture)
*   [Vertical Slice Jimmy Bogard](https://www.jimmybogard.com/vertical-slice-architecture/)

### Ejemplo reproducible

La [plantilla VerticalSliceClean.Template](https://github.com/josearias210/VerticalSliceClean.Template) aplica estas decisiones en una API .NET 10 con EF Core, MediatR, FluentValidation, Serilog y OpenTelemetry. Incluye Docker Compose, pruebas y workflows de build. Para probarla: clona el repositorio, instala el SDK .NET 10 y ejecuta `docker compose -f docker-compose.local.yml up -d`.

Es una base para APIs, no una solución de dominio ni una sustitución de revisión de seguridad. Última verificación: agosto de 2026.

---

## Azure Cosmos DB y la gestión de permisos

URL: https://programemos.net/azure-cosmos-db-y-la-gestion-de-permisos/
Fecha: 2024-04-23
Categorías: Azure
Descripción: Explora estrategias para gestionar permisos en Azure Cosmos DB y proteger tus datos de forma eficiente en tus aplicaciones .NET

En esta publicación, exploraremos Azure Cosmos DB y la gestión de permisos. Como un servicio de base de datos NoSQL, Azure Cosmos DB ofrece diversas opciones para garantizar la protección de los datos. Entre estas opciones se encuentran las [llaves](https://learn.microsoft.com/en-us/azure/cosmos-db/secure-access-to-data?tabs=using-primary-key#primary-keys), [Control de acceso basado en roles (RBAC)](https://learn.microsoft.com/en-us/azure/cosmos-db/secure-access-to-data?tabs=using-primary-key#rbac) y [tokens de recursos](https://learn.microsoft.com/en-us/azure/cosmos-db/secure-access-to-data?tabs=using-primary-key#resource-tokens), que son los principales mecanismos que nos permiten controlar el acceso a los datos de manera efectiva.

Los _tokens_ de recursos son un modelo de permisos específico de Azure Cosmos DB, permite otorgar acceso granular a los datos a usuarios y aplicaciones. Este enfoque es particularmente útil cuando se desea proporcionar acceso a clientes no confiables, ya que elimina la necesidad de compartir claves principales, entre las ventajas de utilizar _tokens_ de recursos se encuentran la facilidad de administración, la posibilidad de revocar _tokens_ individualmente y la granularidad del control de acceso.

## Actualización 2026: evita claves en aplicaciones y clientes

Las claves del ejemplo sirven para explicar la API de permisos, pero no deberían viajar en una aplicación cliente ni quedar en el código fuente. En servicios que se ejecutan en Azure, prioriza Microsoft Entra ID con identidad administrada y control de acceso basado en roles (RBAC). Conserva los _resource tokens_ para escenarios donde necesites delegar acceso acotado a un cliente no confiable, con una vigencia y un alcance deliberadamente limitados.

Antes de diseñar el flujo, revisa la [guía de acceso seguro a los datos de Azure Cosmos DB](https://learn.microsoft.com/azure/cosmos-db/secure-access-to-data). Valida también el modelo de consistencia, la clave de partición y la telemetría: los permisos correctos no sustituyen esas decisiones de diseño.

## Estructura de los permisos en Azure Cosmos DB

La estructura de permisos en Azure Cosmos DB está diseñada de manera jerárquica para facilitar la gestión. La jerarquía comprende los siguientes niveles: bases de datos, usuarios, permisos.

Cada nivel se identifica por un nombre único, que se utiliza para construir _URI_ de solicitudes _HTTP_ para acceder a los recursos. Por ejemplo:

`https://{databaseaccount}.documents.azure.com/dbs/{db-id}/users/{user-name}/permissions/{permission-name}`

Esta estructura de permisos se refleja en el _SDK V3_ para ._NET_, lo que facilita la creación, asignación y administración de permisos mediante código _C#_. La comprensión de la estructura de permisos es fundamental para entender cómo es la jerarquía de las clases que componen el _SDK_ para ._NET_.

## Creando aplicaciones con Azure Cosmos DB y protección de datos

### Simulación de una aplicación real

En este escenario, vamos a simular una aplicación (en nuestro caso, una aplicación de consola) que consta de dos flujos o procesos distintos. El primero estará dedicado a la gestión de permisos, que incluirá la creación de usuarios y la asignación de permisos. El segundo flujo será responsable de consultar los datos, limitados por los permisos establecidos anteriormente

Un escenario más realista implicaría tener una WebAPI que se encargue de gestionar los permisos y genere los _tokens_ que devolverá al cliente para que pueda realizar sus operaciones posteriores. Con este diseño, garantizamos que las claves de acceso están en nuestra aplicación de confianza y que el cliente solo tendrá un _token_ que limitará el acceso a la información según sus permisos. En nuestro caso, hemos creado una aplicación muy simple, ya que nos enfocaremos únicamente en la gestión de permisos.

Hemos configurado una instancia de Azure Cosmos DB en la que hemos creado una base de datos llamada «_database1_«. Dentro de esta base de datos, hemos definido una colección denominada «_products_«, que utiliza el campo «_clientId_» como clave de partición. Esto nos permite organizar eficientemente los permisos según el cliente al que pertenecen.

### Proceso de gestión de permisos

En este proceso, vamos a gestionar la creación de usuarios y permisos en Azure Cosmos DB. A continuación, vamos escribir el código necesario paso a paso y explicaremos su funcionamiento.

#### Creando la instancia de CosmosClient

Lo primero que vamos hacer es crear una instancia de _CosmosClient_ que es la que usaremos para conectarnos a nuestra instancia de Azure Cosmos DB.

```csharp
string key = "{PRIMARY_KEY}";
string accountEndpoint = "https://{AZURE_COSMOS_DB_NAME}-cosomodb.documents.azure.com:443";
using CosmosClient cosmosClient = new CosmosClient(accountEndpoint , key);
```

Inicialmente, establecemos una instancia de _CosmosClient_ utilizando el _accountEndpoint_ y la _key_, que pueden ser obtenidos desde el portal de Azure, accediendo al recurso correspondiente.

![Azure Cosmos DB](https://programemos.net/images/Portal-Cosmos-1024x626-jpg.webp)

Azure Cosmos DB

¿Por qué necesitamos utilizar la _key_ en este paso inicial? Esto se debe a que nuestra primera tarea es configurar los permisos y usuarios, lo cual requiere ciertos privilegios específicos.

Ahora lo que debemos hacer es acceder a la base datos.

```csharp
Database database = cosmosClient.GetDatabase(databaseId);
```

Hasta este punto, si has trabajado con Azure Cosmos DB en el pasado, es probable que estés familiarizado con este proceso, ya que es fundamental para iniciar las operaciones CRUD en la base de datos seleccionada. Ahora que nos conectamos a la base de datos, debemos crear el usuario y los permisos.

**NOTA**: En este ejemplo se esta usando el nuget _[Microsoft.Azure.Cosmos](https://www.nuget.org/packages/Microsoft.Azure.Cosmos)_ que nos permite trabajar con la versión 3 del _SDK_ para ._NET_ de Azure Cosmos DB.

#### Creando el usuario y el permiso

Ahora, procedemos con la creación del usuario. Supongamos que el nombre del usuario es «client1».

```csharp
User client1= await database.CreateUserAsync("client1");
```

En el código anterior, estamos creando un usuario dentro de la base de datos de Azure Cosmos DB.

Para establecer el permiso, necesitamos obtener primero la instancia del contenedor asociado a la colección a la cual aplicaremos el permiso. En nuestro caso, esta colección se denomina «_products_«.

```csharp
Container container = database.GetContainer("products");
```

Ahora creamos el permiso.

```csharp
string permissionId = "client1_product";
await client1.CreatePermissionAsync(
        new PermissionProperties(
            id: permissionId,
            permissionMode: PermissionMode.Read,
            container: container,
            resourcePartitionKey: new PartitionKey("client1")));
```

Lo primero es generar un _permissionId_, este valor debe ser único, es el nombre con el que se va identificar el permiso, para simplificar solo concatenamos el nombre del usuario y nombre del contenedor.

En _permissionMode_ se debe especificar que tipo de permiso es, solo hay 2 disponibles, _READ_ y _ALL_, como deseamos que solo sea de lectura especificamos _READ_.

En _container_ especificamos la instancia del contenedor que obtuvimos previamente a la cual queremos aplicar el permiso.

Por ultimo, tenemos _resourcePartitionKey_, aquí debemos indicar el valor del _PartitionKey_, como dijimos previamente, se esta segmentando por _clientId_, entonces para nuestro caso es «client1». El usuario y la partición no se requieren que sean igual, simplemente por comodidad se esta haciendo de esta manera.

Listo, con esto hemos creado un permiso con el identificador «client1\_product» que permite a un usuario «client1» acceso de lectura al contenedor «_product_«.

Si ejecutas el código anterior la primera vez funcionará sin problema, pero las ejecuciones posteriores probablemente no. Esto se debe que no existe _CreateOrUpdateUser_ ni _CreateOrUpdatePermission_, los métodos que usamos asumen que el usuario y permiso no están creados, si alguno ya existe previamente se va generar un error de duplicado, por eso se debe validar previamente si existen, lo cual nos lleva al siguiente problema, los métodos _GetUser_ y _GetPermission_ son los métodos que se usan respectivamente para obtener un usuario/permiso creado previamente, pero en caso que no exista, se obtendrá un error de elemento no encontrado.

Ahora teniendo en cuenta lo anterior, una solución es trabajar con _try/catch_ y manejar el tipo de error para hacer una implementación más robusta. A continuación vamos a reescribir el código anterior para hacer las mejoras previamente mencionadas.

```csharp
using System.Net;
using Microsoft.Azure.Cosmos;

string userId = "client1";
string containerId = "products";
string databaseId = "database1";
string partitionKeyValue = "client1";

string key = "{PRIMARY_KEY}";
string accountEndpoint = new("https://{AZURE_COSMOS_DB_NAME}-cosomodb.documents.azure.com:443/");

CosmosClient cosmosClient = new CosmosClient(accountEndpoint, key);
Database database = cosmosClient.GetDatabase(databaseId);
Container container = database.GetContainer(containerId);

User user;

try
{
    user = await database.GetUser(userId).ReadAsync();
}
catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
{
    user = await database.CreateUserAsync(userId);
}

string permissionId = $"{user}_{containerId}";
try
{
    await user.GetPermission(permissionId).ReadAsync();
}
catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
{
    await user.CreatePermissionAsync(
        new PermissionProperties(
            id: $"{user}_{containerId}",
            permissionMode: PermissionMode.Read,
            container: container,
            resourcePartitionKey: new PartitionKey(partitionKeyValue)));
}
```

El código anterior solo es un ejemplo de una posible implementación, **no es necesariamente la más optima.** En una implementación real, probablemente obtendrías un _clientId_ desde los _Claims_ del usuario y ese seria el valor del _userId_ para que usaríamos.

### Proceso de acceso a datos usando token de recursos en Azure Cosmos DB

Ahora vamos a crear el proceso para consultar los datos usando el _token_ de recurso para hacer las operaciones y garantizar la protección de datos.

El proceso es muy simple, para limitar las operaciones a los permisos otorgados solo debemos crear el una instancia de cliente de cosmos usando _token_ de permiso en vez de llave primaria, algo similar a lo siguiente.

```csharp
string token= "{TOKEN_PERMISSION}";
string accountEndpoint = "https://{AZURE_COSMOS_DB_NAME}-cosomodb.documents.azure.com:443";
using CosmosClient cosmosClient = new CosmosClient(accountEndpoint , token);
```

Con esto, garantizamos que se aplique la protección de datos según hemos configurado en los permisos. **Fácil. ¿Verdad?** bueno realmente no, porque te estarás preguntando ¿Como obtengo el _token_? bueno, este es el primer aspecto que no me gusta, debemos crear previamente una instancia de cosmos usando la llave primaria para poder obtener el permiso y posteriormente el _token_.

```csharp
using Microsoft.Azure.Cosmos;

string userId = "client1";
string databaseId = "database1";
string containerId = "products";
string key = "{PRIMARY_KEY}";
string accountEndpoint = new("https://{AZURE_COSMOS_DB_NAME}-cosomodb.documents.azure.com:443/");

// Obtenemos el token
CosmosClient cosmosClientAdmin = new CosmosClient(accountEndpoint, key);
Database database = cosmosClientAdmin.GetDatabase(databaseId);

// Como te comente antes los permisos están asociados a un usuario, por eso accedemos antes a este recurso.
User user = database.GetUser(userId);

// Obtenemos permiso, debemos buscar usando el "permissionId" creado previamente.
PermissionProperties permission = await user.GetPermission($"{user}_{containerId}").ReadAsync();

// Creamos una instancia de Cosmos limitada por permisos.
CosmosClient cosmosClientUser1 = new CosmosClient(accountEndpoint, permission.Token);
```

Un aspecto adicional que tampoco me agrada es que no se pueden crear una instancia _CosmosClient_ usando más de un _token_, lo que significa que por ejemplo en un caso de negocio que requiere acceder 2 contenedores a vez, deberás crear una instancia adicional de _CosmosClient_ con el _token_ asociado al otro permiso.

La implementación anterior **no es la más optima**, porque deberíamos considerar los casos que un permiso no exista previamente.

## Conclusión

La protección de datos usando _token_ de recurso es un mecanismo útil, debemos evaluar los casos de uso en donde podemos usarlo de manera eficiente, también debemos considerar algunas características adicionales como el uso de caché para reutilizar las instancias de _CosmosClient_. Y como todo en este mundo, nunca existe la solución perfecta universal, debemos evaluar nuestro requerimientos y tomar la decisiones si esta funcionalidad nos ayuda a solventar un problema a nuestro cliente.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

[Microsoft Learn](https://learn.microsoft.com/en-us/azure/cosmos-db/secure-access-to-data?tabs=using-primary-key)

---

## AzureWebJobsStorage con identidad administrada

URL: https://programemos.net/acceso-a-azure-storage-desde-azure-function-identidades-administradas/
Fecha: 2024-03-17
Categorías: Azure
Descripción: Configura AzureWebJobsStorage con una identidad administrada en Azure Functions, elimina secretos y asigna los roles mínimos que requiere el runtime.

`AzureWebJobsStorage` no tiene que guardar una cadena de conexión. Azure Functions puede usar una identidad administrada para acceder al almacenamiento del runtime y eliminar ese secreto de la configuración. Es distinto de la conexión que tu propio código usa para leer o escribir blobs, explicada en la [publicación anterior](/azure-blob-storage-e-identidades-administradas/).

## Entendiendo el funcionamiento de las Azure Functions

Cuando creamos un proyecto de Azure Function y trabajamos localmente con un almacenamiento(_Azurite_), se genera un archivo llamado _local.settings.json_. Este archivo tendrá una estructura similar a la siguiente:

```csharp
{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet"
  }
}
```

Me gustaría enfocarme en el parámetro _AzureWebJobsStorage_, el cual representa la cadena de conexión de una cuenta de almacenamiento que el entorno de ejecución de Azure Functions utiliza para realizar operaciones de coordinación general. Algunas de esta operaciones incluyen la administración de claves, la gestión de desencadenadores, temporizadores y los puntos de comprobación de Event Hubs.

En otras palabras, este parámetro representa la cuenta de almacenamiento que el entorno de Azure Functions utiliza internamente para almacenar información necesaria para su correcto funcionamiento. Por ejemplo, cuando se trabaja con Azure Function Durable, se generan tablas específicas utilizadas para el registro y control de actividades ejecutadas.

Cuando se utiliza _UseDevelopmentStorage=true_, se hace referencia al emulador Azurite, el cual se emplea para el desarrollo local de Azure Storage. Sin embargo, en producción, esta configuración debería apuntar a una cadena de conexión de una cuenta de almacenamiento real en Azure. Es fundamental comprender que esta cuenta de almacenamiento es utilizada por el entorno de ejecución de Azure Functions sin importar el tipo de desencadenador que se esté utilizando. Por eso al momento de crear el proyecto de Azure Function se solicita que indiquemos una cuenta de almacenamiento.

## Modificando nuestra Azure Function

Por defecto, Azure Functions obtiene una cadena de conexión desde `AzureWebJobsStorage`. En Azure podemos reemplazarla por una configuración basada en identidad. Para una cuenta en la nube pública, sin DNS personalizado, la forma más simple con la identidad asignada por el sistema es:

```csharp
{
  "AzureWebJobsStorage__accountName": "<storage_account_name>"
}
```

Las URI separadas para Blob, Queue y Table siguen siendo útiles en nubes soberanas o cuando existe un DNS personalizado:

```csharp
{
  "AzureWebJobsStorage__blobServiceUri": "https://<storage_account_name>.blob.core.windows.net",
  "AzureWebJobsStorage__queueServiceUri": "https://<storage_account_name>.queue.core.windows.net",
  "AzureWebJobsStorage__tableServiceUri": "https://<storage_account_name>.table.core.windows.net"
}
```

Si usamos una identidad administrada asignada por el usuario, añadimos su identificador de cliente:

```csharp
{
  "AzureWebJobsStorage__clientId":"<Client_ID>",
  "AzureWebJobsStorage__credential":"managedidentity"
}
```

El resultado para una cuenta estándar sería:

```csharp
{
  "AzureWebJobsStorage__accountName": "<storage_account_name>",
  "AzureWebJobsStorage__credential": "managedidentity",
  "AzureWebJobsStorage__clientId": "<client_id>"
}
```

Después eliminamos la configuración original `AzureWebJobsStorage`, porque ya no queremos que el host encuentre una cadena con la clave de la cuenta.

> Esta configuración pertenece al entorno de Azure. Microsoft indica que no se debe establecer `AzureWebJobsStorage__credential` durante el desarrollo local. En `local.settings.json` conserva `AzureWebJobsStorage: UseDevelopmentStorage=true` para trabajar con Azurite y no subas ese archivo al repositorio.

## Asignación de permisos a la entidad administrada de nuestra Azure Function

La identidad necesita permisos de plano de datos sobre la cuenta. Para el almacenamiento del host, el punto de partida documentado es **Storage Blob Data Owner**. Eso no significa asignar el rol genérico **Owner** de Azure ni conceder control total sobre toda la suscripción.

Para el caso de la cuenta de almacenamiento usada por Azure Function también necesitamos conceder permisos necesarios para las operaciones administrativas (Crear leer, escribir etc.). Por ejemplo, las Azure Fuction Durable generan varias tablas para control de sus actividad, por lo cual necesitaría permiso para esta acción de crear y escribir una tabla en la cuenta de almacenamiento.

Cada disparador de función(_trigger_) utiliza de manera diferente el recuso de almacenamiento, por lo cual debemos asignar permisos que cubran cada una de las necesidades. Eso nos obligaría a estudiar el funcionamiento interno funciones y entender como usan el recurso de almacenamiento. Pero como Microsoft nos quiere facilitar el trabajo, ellos generaron una tabla donde se explica el permiso necesario según el disparador que usemos (En enlace de referencia puedes ver la tabla).

![Permisos requeridos para las Azure Function](https://programemos.net/images/imagen-png.webp)

Los roles adicionales dependen de las extensiones y disparadores. Por ejemplo, un Blob trigger puede requerir también **Storage Account Contributor** y **Storage Queue Data Contributor** sobre la cuenta usada por `AzureWebJobsStorage`. Durable Functions y otros bindings tienen necesidades distintas: consulta la tabla oficial y asigna únicamente lo que usa tu aplicación.

Con la información de la tabla anterior puedes ir al recurso de almacenamiento y conceder los roles requeridos por nuestra aplicación.

## Límites y comprobaciones antes de desplegar

Comprueba que las versiones de tus extensiones admiten conexiones basadas en identidad. Si el plan usa Azure Files para contenido, ten presente que esa conexión no admite identidad administrada en todos los escenarios y puede seguir necesitando una cadena. En Linux Consumption, el despliegue también puede requerir un paquete externo cuando `AzureWebJobsStorage` usa identidad.

La mejora de seguridad es real: eliminamos una clave con acceso amplio y pasamos a una identidad auditable, revocable y limitada por roles. La configuración correcta no consiste en dar más permisos hasta que funcione, sino en entender qué usa el host y aplicar mínimo privilegio.

## Referencias

*   [Crear una Function App sin secretos de almacenamiento](https://learn.microsoft.com/es-es/azure/azure-functions/functions-identity-based-connections-tutorial)
*   [Configuración de AzureWebJobsStorage](https://learn.microsoft.com/es-es/azure/azure-functions/functions-app-settings#azurewebjobsstorage)
*   [Consideraciones de almacenamiento para Azure Functions](https://learn.microsoft.com/es-es/azure/azure-functions/storage-considerations)

---

## Firma Digital de Documentos PDF con .NET

URL: https://programemos.net/firma-digital-de-documentos-pdf-con-net/
Fecha: 2024-02-16
Categorías: Programación
Descripción: Firma digital en PDF con .NET y C#: Aprende a garantizar autenticidad e integridad. Desde certificados hasta la aplicación de firmas.

Cuando un documento PDF necesita demostrar quién lo firmó y si fue alterado, una imagen de una firma no es suficiente. En este artículo veremos cómo implementar una firma digital en documentos PDF utilizando .NET y C#.

Antes de empezar con en el código, resulta fundamental tener una comprensión básica de los elementos esenciales necesarios para su implementación. En este artículo, no vamos a profundizar en explicar minuciosamente su funcionamiento ni abordar todos los conceptos vinculados con este proceso, ya que eso extendería considerablemente el contenido. Por el momento, nos enfocaremos exclusivamente en el proceso de firma de documentos PDF

## ¿Qué es la Firma Digital?

La firma digital es un mecanismo criptográfico que asegura la autenticidad e integridad de un documento electrónico. Al igual que una firma manuscrita, la firma digital proporciona una manera de verificar la identidad del firmante y garantizar que el contenido del documento no ha sido alterado desde su firma. A continuación, revisaremos algunos elementos que son necesarios para este proceso.

### Certificado Digital

Un certificado es esencial para la firma digital, actúa como un «Sello» que verifica la identidad del firmante. Los certificados digitales suelen ser emitidos por autoridades de certificación confiables.

### Obtención del Certificado Digital

El primer paso es obtener un certificado digital. Este certificado será la pieza fundamental para garantizar la autenticidad y la integridad de los documentos PDF que firmaremos. Existen diversas formas de adquirir un certificado, pero los más recomendado es obtenerlo a través de una Autoridad de Certificación (CA) reconocida. Esto asegura que nuestro certificado sea confiable para las aplicaciones y evita las advertencias comunes asociadas similares a las ocurridas con los certificados auto-firmado.

#### Opción 1: Obtención a Través de una Autoridad de Certificación (CA) Reconocida

La mejor opción para obtener un certificado digital es a través de una autoridad de certificación reconocida. Este proceso implica validar la identidad del solicitante, lo que resulta en un certificado confiable y ampliamente aceptado en entornos empresariales y de seguridad.

#### Opción 2: Certificado Auto-Firmado

Para simplificar el proceso, en nuestro caso, optaremos por obtener un certificado auto-firmado mediante el uso de Internet Information Services (IIS). Es importante tener en cuenta que aunque este método es más sencillo, los certificados auto-firmado pueden generar advertencias en algunas aplicaciones debido a su naturaleza de no ser validados por una autoridad de certificación(CA) reconocida.

Abrimos nuestro Internet Information Services (IIS) y nos dirigimos a «certificados de servidor»

![Certificados](https://programemos.net/images/certificados-1024x237-png.webp)

_Certificados_

Luego, en la parte superior derecha seleccionamos que deseamos un certificado auto-firmado.

![Crear Certificados Auto-Firmados](https://programemos.net/images/autofirmar-png.webp)

_Crear Certificados Auto-Firmados_

Seleccionamos el nombre que deseamos que tenga nuestro archivo PFX.

![Crear Certificado](https://programemos.net/images/certificado-png.webp)

_Crear Certificado_

Con esto ya hemos creado nuestro certificado auto-firmado, pero ahora debemos exportarlo para poder usarlo en nuestra aplicación.

![Seleccionar la ruta y contraseña para exportar el certificado PFX](https://programemos.net/images/Exportar1-png.webp)

_Exportar Certificado_

Nos va solicitar donde deseamos guardarlo y que contraseña queremos usar.

![Exportar Certificado](https://programemos.net/images/Exportar2-png.webp)

_Exportar Certificado_

Este proceso nos va generar un archivo PKCS#12 con la extensión PFX. Aunque este método puede ser adecuado para propósitos de prueba o desarrollo, se recomienda siempre el uso de certificados emitidos por una autoridad de certificación (CA) reconocida en entornos de producción para garantizar la máxima confianza y seguridad.

## Firma Digital usando .NET

### Requisitos Previos

En este ejemplo trabajamos con una aplicación de consola en .NET 8 y [iTextSharp 5.5.13.3](https://www.nuget.org/packages/iTextSharp/5.5.13.3). El código se conserva porque explica el flujo y sigue recibiendo búsquedas, pero hay una decisión técnica que no debes ignorar: **iTextSharp 5 está en fin de vida** y el propio paquete recomienda usar iText en proyectos nuevos. Revisa también su licencia AGPL o comercial antes de incorporarlo a un producto.

### Obtención del Certificado Digital Desde el archivo extensión PFX

Ahora vamos a firma un documento PDF usando nuestro certificado, lo primero que necesitamos hacer es cargar nuestro certificado, El código siguiente tenemos una clase que obtiene el certificado de un archivo de tipo PKCS#12.

```csharp
namespace Secure;

using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.X509;
using System.IO;
using System.Linq;

public class Certificate
{
    public X509Certificate[] Chain { get; private set; }
    public AsymmetricKeyParameter Key { get; private set; }

    public Certificate(string certificate, string password)
    {
        using var file = File.OpenRead(certificate);
        Pkcs12Store store = new(file, password.ToCharArray());
        string alias = GetCertificateAlias(store);

        Key = store.GetKey(alias).Key;
        Chain = store.GetCertificateChain(alias).Select(x => x.Certificate).ToArray();
    }

    private string GetCertificateAlias(Pkcs12Store store)
    {
        foreach (string currentAlias in store.Aliases)
        {
            if (store.IsKeyEntry(currentAlias))
            {
                return currentAlias;
            }
        }

        throw new InvalidOperationException("No se encontró una entrada de clave en el almacén.");
    }
}

```

El constructor de la clase recibe la ruta del nuestro certificado y la clave que protege al archivo PKCS#12. En nuestro caso es la misma clave que ingresamos a exportar el certificado desde Internet Information Services (IIS).

Debemos recordar que el archivo PKCS#12 no solo tiene el certificado, también tiene otros archivos como por ejemplo la llave publica, aunque normalmente solo trae una, puede almacenar varias, por eso se usa la clave y un alias para poder obtener el que necesitamos.

### Firmar el Documento PDF

A diferencia del proceso de obtener certificado digital, vamos a ir paso a paso explicando cada línea de código que usamos para firmar el documento. Vamos a crear un método llamado _SignPdf_ que va recibir la ruta del archivo a firmar, la ruta para el archivo firmado, la ruta del certificado y la contraseña.

```csharp
void SignPdf(string sourcePathPdf, string targetPathPdf, string certificatePath, string password)
{
}
```

Lo primero que vamos hacer es obtener el certificado usando la clase que creamos en la sección anterior.

```csharp
 Certificate certificate= new(certificatePath, password);
```

Ahora debemos cargar el documento PDF, para eso usamos librería [iTextSharp](https://www.nuget.org/packages/iTextSharp).

```csharp
 using var reader = new PdfReader(sourcePathPdf);
 using var writer = new FileStream(targetPathPdf, FileMode.Create, FileAccess.Write);
```

Cuando firmamos el documento PDF no es necesario que sea visible la firma, eso queda registrado en las propiedades del PDF, pero si podemos generar una especie de sello visible en el documento, para esto debemos configurar como y donde queremos que se visualice.

```csharp
  int nsejeX = 400;
  int nsejeY = 30;
            
  using var stamper = PdfStamper.CreateSignature(reader, writer, '\0', null, true);
  stamper.SignatureAppearance.SetVisibleSignature( new Rectangle(nsejeX, nsejeY, nsejeX + 150, nsejeY + 50), 1, "Signature");
```

Estamos configurando para que aparezca en la hoja 1 del documento PDF, además estamos diciendo que aparezca en la parte inferior derecha (Para eso son esos cálculos), en forma rectangular, además en nombre del campo que va tener la firma dentro de las propiedades del documento va ser «Signature».

Podemos especificar varias configuraciones adicionales si lo deseamos, como por ejemplo el «Certification Level».

```csharp
var signature = stamper.SignatureAppearance;
signature.CertificationLevel = PdfSignatureAppearance.CERTIFIED_NO_CHANGES_ALLOWED;
```

Ahora necesitamos configurar toda la información que vamos usar para la firma, incluyendo el algoritmo de HASH a usar.

```csharp
 var signatureKey = new PrivateKeySignature(certificate.Key, DigestAlgorithms.SHA256);
 var signatureChain = certificate.Chain;
 var standard = CryptoStandard.CADES;
```

Finalmente firmamos el documento PDF.

```csharp
MakeSignature.SignDetached(signature, signatureKey, signatureChain, null, null, null, 0, standard);
```

Con todo lo anterior ya tenemos un proceso completo de firma. El código completo para la clase Signature seria el siguiente:

```csharp
namespace Secure;

using iTextSharp.text;
using iTextSharp.text.pdf;
using iTextSharp.text.pdf.security;

public class Signature
{
    public void SignPdf(string sourcePathPdf, string targetPathPdf, string certificatePath, string password)
    {
        Certificate certificado = new(certificatePath, password);

        int nsejeX = 400;
        int nsejeY = 30;

        using var reader = new PdfReader(sourcePathPdf);
        using var writer = new FileStream(targetPathPdf, FileMode.Create, FileAccess.Write);
        using var stamper = PdfStamper.CreateSignature(reader, writer, '\0', null, true);
        stamper.SignatureAppearance.SetVisibleSignature(new Rectangle(nsejeX, nsejeY, nsejeX + 150, nsejeY + 50), 1, "Signature");

        var signature = stamper.SignatureAppearance;
        signature.CertificationLevel = PdfSignatureAppearance.CERTIFIED_NO_CHANGES_ALLOWED;

        var signatureKey = new PrivateKeySignature(certificado.Key, DigestAlgorithms.SHA256);
        var signatureChain = certificado.Chain;
        var standard = CryptoStandard.CADES;

        MakeSignature.SignDetached(signature, signatureKey, signatureChain, null, null, null, 0, standard);
    }
}
```

Ahora desde nuestro _Program.cs_ podemos llamar nuestro método de firma.

```csharp
Signature signature = new();
signature.SignPdf(sourcePathPdf, targetPathPdf, certificatePath, password);
```

El resultado seria algo similar a lo siguiente:

![PDF Firmado](https://programemos.net/images/PDF-firmado-1024x461-png.webp)

_PDF Firmado_

Ya tenemos un PDF firmado, donde la firma es visible en el lugar que le indicamos, y si entramos a la opciones de firmas del lector de PDF (En este caso [Adobe Acrobat](https://acrobat.adobe.com/es/es/)) nos dirá que el documento está firmado con un certificado y nos mostrará información de la firma y podremos comprobar si el documento es del autor que creemos y sin fue modificado posteriormente, es posible que si usaste un certificado auto-firmado y no lo has instalado localmente, entonces puede aparecerte algunas advertencias.

## Lo que debes cuidar en producción

El ejemplo demuestra cómo aplicar una firma, pero una solución empresarial necesita más controles:

* guarda la clave privada en un almacén seguro o HSM; no distribuyas el PFX junto con la aplicación;
* obtiene la contraseña desde un gestor de secretos y evita registrarla en logs;
* usa un certificado emitido para el propósito y la identidad correctos, no uno autofirmado de desarrollo;
* define si necesitas sello de tiempo, validación de revocación y firmas de larga duración;
* valida la licencia y planifica la migración desde iTextSharp 5 antes de empezar un desarrollo nuevo.

Una imagen visible no prueba la identidad por sí sola. La confianza depende de la clave privada, la cadena del certificado, la política de validación y la capacidad del receptor para verificar todo el conjunto.

## Referencias

* [Paquete iTextSharp y aviso de fin de vida](https://www.nuget.org/packages/iTextSharp)
* [Fundamentos de firmas digitales](https://learn.microsoft.com/en-us/dotnet/standard/security/cryptographic-signatures)

---

## Hangfire en ASP.NET Core: trabajos en segundo plano

URL: https://programemos.net/tareas-en-segundo-plano-con-hangfire/
Fecha: 2023-12-28
Categorías: Programación
Descripción: Configura Hangfire en ASP.NET Core y ejecuta trabajos persistentes, retrasados, recurrentes y encadenados con criterios para producción.

Hangfire resuelve un problema concreto en ASP.NET Core: sacar de una petición HTTP el trabajo que no necesita terminar antes de responder. Enviar un correo, procesar un archivo o reintentar una integración son buenos ejemplos.

A diferencia de lanzar un `Task.Run`, Hangfire serializa el trabajo y lo guarda para que pueda sobrevivir a reinicios, registrar su estado y reintentarse. Esa persistencia es útil, pero no elimina las decisiones de operación: un trabajo puede ejecutarse más de una vez, fallar a mitad o quedarse esperando un recurso externo.

## Qué es Hangfire y cómo funciona

Hangfire administra trabajos en segundo plano desde que se crean hasta que se ejecutan. Incluye persistencia, estados, reintentos y un Dashboard operativo. No sustituye una arquitectura de mensajería distribuida en todos los escenarios, pero resulta práctico cuando el trabajo pertenece a la misma aplicación .NET.

Su arquitectura tiene tres piezas:

*   **Cliente**: crea el trabajo y lo envía al almacenamiento.
*   **Almacenamiento**: conserva la definición, el estado y la información necesaria para procesarlo.
*   **Servidor**: obtiene trabajos del almacenamiento y los ejecuta. En una aplicación pequeña, el mismo proceso puede actuar como cliente y servidor.

![Flujo entre el cliente, el almacenamiento y el servidor de Hangfire](https://programemos.net/images/hangfire-workflow.png)

_Arquitectura básica de Hangfire_

> En el texto uso “trabajo”, que corresponde al término *job* de Hangfire. En artículos antiguos también lo llamaba “tarea”; aquí se refieren al mismo proceso en segundo plano.

## Configurar Hangfire en ASP.NET Core

Para reproducir el ejemplo instala [Hangfire.AspNetCore](https://www.nuget.org/packages/Hangfire.AspNetCore) y [Hangfire.MemoryStorage](https://www.nuget.org/packages/Hangfire.MemoryStorage). En producción instala el proveedor correspondiente al almacenamiento elegido, como SQL Server o Redis.

En `Program.cs`, registra Hangfire y levanta un servidor:

```csharp title="Program.cs"
builder.Services.AddHangfire(configuration => configuration.UseMemoryStorage());
builder.Services.AddHangfireServer();
```

El almacenamiento en memoria reduce el ruido del ejemplo, pero **no es una opción de producción**: al reiniciar la aplicación se pierde su estado. Para una aplicación real, usa almacenamiento persistente, mueve el trabajo a una clase inyectable y no serialices secretos ni información sensible en sus argumentos.

## Tipos de trabajos en Hangfire

### Trabajo inmediato o *fire-and-forget*

Un trabajo inmediato se crea sin esperar su resultado. Hangfire lo almacena y devuelve un identificador que permite seguir su estado.

```csharp
app.MapPost("/notificacion", () =>
{
    var jobId = BackgroundJob.Enqueue(() => SendEmail());
    return Results.Accepted(value: new { jobId });
});
```

`Enqueue` no espera a que `SendEmail` termine. La API puede responder mientras un servidor de Hangfire procesa el trabajo.

### Trabajos retrasados

Un trabajo retrasado establece un tiempo mínimo antes de que pueda comenzar:

```csharp
app.MapPost("/espera", () =>
{
    var jobId = BackgroundJob.Schedule(
        () => SendEmail(),
        TimeSpan.FromSeconds(10));
    return Results.Accepted(value: new { jobId });
});
```

El término **mínimo** importa: la ejecución depende del sondeo, la disponibilidad del servidor y la carga. No uses un trabajo retrasado como si fuera un temporizador de tiempo real.

### Trabajos recurrentes

`RecurringJob.AddOrUpdate` registra un trabajo con una frecuencia equivalente a cron:

```csharp
app.MapPost("/recurrente", () =>
{
    RecurringJob.AddOrUpdate(
        "send-email",
        () => SendEmail(),
        Cron.Minutely);
    return Results.NoContent();
});
```

El identificador `send-email` debe ser estable y único. Volver a llamar `AddOrUpdate` con ese identificador actualiza la definición existente en vez de crear otra.

### Continuaciones

Una continuación crea un trabajo que depende de otro:

```csharp
app.MapPost("/continuation", () =>
{
    var jobId = BackgroundJob.Enqueue(() => SendEmail());
    BackgroundJob.ContinueJobWith(jobId, () => CrearLog());
    return Results.Accepted(value: new { jobId });
});
```

En un flujo real también debes decidir qué debe pasar con la continuación si el primer trabajo falla.

## Proteger el Dashboard de Hangfire

En desarrollo puedes activar el Dashboard desde `Program.cs`:

```csharp
app.UseHangfireDashboard();
```

La interfaz permite inspeccionar argumentos, reintentar, eliminar y disparar trabajos. No debe quedar expuesta públicamente. En ASP.NET Core, configura autenticación antes del Dashboard y exige una política:

```csharp title="Program.cs"
app.UseAuthentication();
app.UseAuthorization();

app.MapHangfireDashboard("/hangfire")
    .RequireAuthorization("HangfireDashboard");
```

La política debe limitar el acceso a operadores autorizados. Permitir a cualquier usuario autenticado sigue siendo demasiado amplio para muchas aplicaciones.

![Dashboard de Hangfire con el estado de los trabajos](https://programemos.net/images/image-1024x412-png.webp)

_Dashboard de Hangfire_

## Llevar Hangfire a producción

Antes de desplegar revisaría, como mínimo:

*   almacenamiento persistente y copias de seguridad
*   idempotencia ante reintentos o ejecuciones duplicadas
*   timeouts, cancelación y política de reintentos
*   colas y cantidad de workers según el tipo de carga
*   autorización del Dashboard y ausencia de secretos en argumentos
*   logs, métricas, alertas y correlación con la petición original

Usaría Hangfire cuando una aplicación .NET necesita trabajos persistentes, reintentos y operación visible sin introducir todavía una plataforma de mensajería completa. No lo elegiría por defecto para integrar muchos servicios independientes, mover grandes volúmenes de eventos o resolver flujos que requieren garantías distribuidas más estrictas.

La decisión clave no es solo “ejecutar después”, sino definir qué ocurre cuando el trabajo falla o se repite. Hangfire aporta la infraestructura; esas decisiones siguen siendo responsabilidad del equipo.

Si quieres seguir aprendiendo sobre estos temas, te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

*   [ASP.NET Core Applications](https://docs.hangfire.io/en/latest/getting-started/aspnet-core-applications.html)
*   [Invocar métodos en segundo plano](https://docs.hangfire.io/en/latest/background-methods/calling-methods-in-background.html)
*   [Configurar y proteger el Dashboard](https://docs.hangfire.io/en/latest/configuration/using-dashboard.html)

---

## Entiende el Proceso de Ejecución: Funcionamiento de las Aplicaciones .NET

URL: https://programemos.net/entiende-el-proceso-de-ejecucion-funcionamiento-de-las-aplicaciones-net/
Fecha: 2023-11-21
Categorías: General, Programación
Descripción: Entiende cómo se ejecuta una aplicación ASP.NET Core: puertos de Kestrel, perfiles de launchSettings.json y configuración del entorno al desplegar.

En este artículo, mi objetivo es que entendamos ciertos aspectos relacionados con la ejecución de una aplicación ._NET_. _¿Ejecutar una aplicación .NET?_ Sí, has leído correctamente; eso es lo que busco lograr. Aunque pueda sorprenderte, hay algunos desarrolladores que no comprenden algunos aspectos que suceden durante este proceso.

Esto genera algunas dificultades que se hacen evidentes, por ejemplo, al intentar ejecutar una aplicación ._NET_ con un servidor proxy inverso (como __[NGINX](https://www.nginx.com/)__ ) y no comprender por qué la aplicación falla o no funciona como se espera.

## **Explorando** la estructura de un proyecto .NET

Primero quiero que analicemos qué archivos se generan cuando creamos un proyecto ._NET_. En este caso usare _NET 7_ y haré todo por consola usando los comandos de _dotnet_.

`dotnet new webapi -n myapp -o myapp -minimal --no-openapi`

Al ejecutar el comando anterior estoy generando un proyecto del tipo WebApi. Los parámetros adicionales se utilizan para definir el nombre del directorio de salida, el nombre del proyecto, excluir la configuración Swagger y optar por el esquema de Minimal API. Estos parámetros los incluyo con el propósito de minimizar la cantidad de código generado. Mi intención es que comprendas con claridad qué estamos utilizando y por qué.

![Estructura del Proyecto](https://programemos.net/images/estructura-del-proyecto-png.webp)

_Estructura del Proyecto_

No se creó una carpeta «_Controllers_» debido al uso de Minimal API.

Ahora, para mantener la simplicidad del proyecto, mi primer ajuste consistirá en reemplazar el contenido del archivo `Program.cs`. Este cambio busca eliminar el código innecesario y agregar un endpoint que responda con una cadena de texto indicando «home» cuando se accede a la raíz del sitio.

![Program.cs](https://programemos.net/images/Program-png.webp)

_Program.cs_

En realidad, lo que estoy haciendo es eliminar el código innecesario y añadir un endpoint que responderá con una cadena de texto que dice «home» cuando se accede a la raíz del sitio. Este paso tiene como objetivo mantener la claridad y concisión en el proyecto, eliminando cualquier elemento que no sea esencial para nuestro propósito.

Ahora, procederemos a ejecutar la aplicación utilizando el comando de _dotnet run_

![dotnet run](https://programemos.net/images/run-default-png.webp)

_dotnet run_

Efectivamente, al dirigirnos al navegador y acceder a la URL que se indica, podremos visualizar el resultado de la ejecución.

![http://localhost:5247](https://programemos.net/images/home_prueba-png.webp)

_http://localhost:5247_

## **Analizando lo ocurrido hasta ahora**

En este punto, nos sumergimos en una serie de preguntas clave que nos ayudarán a desentrañar el funcionamiento de este proceso.

### **¿Por qué se utiliza ese puerto?**

Cuando creamos una aplicación que escucha peticiones _HTTP_, se configura un puerto aleatorio para recibir estas solicitudes. Es crucial recordar que dos aplicaciones no pueden escuchar en el mismo puerto simultáneamente.

### **¿Cómo la herramienta determina qué puerto utilizar?**

La información sobre qué puerto utilizar se encuentra en el archivo `properties/launchSettings.json`. Aquí, se definen los perfiles que podemos emplear para ejecutar nuestra aplicación. En nuestro ejemplo, esto es lo que tenemos.

![launchSettings.json](https://programemos.net/images/launchSettings-json-png.webp)

_launchSettings.json_

Este archivo contiene tres perfiles _(http, https e IIS Express_), cada uno con configuraciones específicas. Nos centraremos en la propiedad `_applicationUrl_`, donde se indica al servidor _Kestrel_ (para _http_ y _https_) qué puerto y _URL_ utilizar para recibir peticiones. Al ejecutar `dotnet run`, por defecto, se toma el primer perfil de la lista, configurando así `http://localhost:5247`.

  
Si utilizamos _Visual Studio_, tenemos la capacidad de elegir el perfil que deseamos emplear. En este entorno, observaremos los mismos perfiles que se muestran en el archivo `` `properties/launchSettings.json` ``.

![Visual Studio](https://programemos.net/images/visual-studio-png.webp)

_Visual Studio_

En el entorno de Visual Studio, contamos con la capacidad de agregar o eliminar perfiles según nuestras preferencias. Asimismo, tenemos la libertad de modificar perfiles existentes; por ejemplo, podemos asignar un puerto diferente, siempre asegurándonos de no seleccionar uno que ya esté en uso por otra aplicación en nuestro sistema operativo. Además de estas personalizaciones, también podemos configurar variables de entorno según nuestras necesidades.

Es crucial destacar un punto clave antes de proseguir: este archivo, ``` `` `properties/launchSettings.json` `` ```, se utiliza exclusivamente por la herramienta `dotnet` y los editores de código como _Visual Studio._ Es importante tener en cuenta que los servidores _IIS_ ignoran estas configuraciones. Aunque existen métodos para configurar otros servidores _HTTP_, no se considera la opción ideal.

###   
¿Es imprescindible el archivo launchSettings.json en las aplicaciones .NET?

No, no lo es. Tenemos la libertad de eliminarlo si así lo deseamos, y nuestra aplicación continuará ejecutándose.

### Entonces, ¿qué configuraciones se utilizan?

En el caso de no emplear un perfil de configuración específico con dotnet y no especificar parámetros adicionales durante la ejecución, se recurrirá a las configuraciones predeterminadas. Ahora que hemos eliminado el archivo, procedamos a ejecutar nuevamente el comando `dotnet run`.

![dotnet run](https://programemos.net/images/run-default-png.webp)

_dotnet run_

Ahora observamos que la aplicación está escuchando peticiones en _http://localhost_ en el puerto 5000, que son los valores predeterminados para este tipo de aplicación .NET. Además, notamos que el entorno ahora está configurado como «Production».

### ¿Qué sucede si no estamos utilizando el archivo launchSettings.json y deseamos emplear un puerto diferente?

Al revisar la documentación de `dotnet run`, encontraremos varios parámetros adicionales que podemos utilizar. En este caso, quiero destacar el uso de `--urls`.

`dotnet run --urls "http://localhost:5247"`

Con este comando, indicamos la _URL_ y el puerto que deben ser utilizados. Para escuchar en varias direcciones, se separan con punto y coma dentro del mismo argumento, por ejemplo: `dotnet run --urls "http://localhost:5247;http://localhost:5248"`, como explica la [documentación de endpoints de Kestrel](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel/endpoints?view=aspnetcore-10.0). Esto resultará en un comportamiento similar al que teníamos anteriormente con el archivo ``` `` `properties/launchSettings.json` `` ```.

### ¿Es obligatorio el archivo appsettings.json?

No, no lo es. A diferencia del archivo anterior, es probable que este te resulte más familiar, ya que permite incluir configuraciones de manera sencilla. Por defecto, se crea un archivo con configuraciones para definir el nivel del registro (logs de la aplicación) que deseamos tener. Asimismo, si el archivo no existe, ._NET_ proporciona valores predeterminados para estas configuraciones.

###   
¿Es obligatorio el archivo .sln?

No, no lo es. El archivo _sln_ es utilizado para agrupar varios proyectos dentro de una misma solución. Cuando creamos nuestro primer proyecto, se genera automáticamente un archivo _sln_ que incluye la referencia al proyecto recién creado. Sin embargo, un proyecto (_csproj_) puede existir de manera independiente, sin depender de un archivo _sln_. En nuestro caso, dado que solo tenemos un proyecto, también podríamos eliminar el archivo _sln_.

Veamos cómo queda la nueva estructura del proyecto después de este ajuste.

![Mi Proyecto Simplificado](https://programemos.net/images/simplicado-png.webp)

_Mi Proyecto Simplificado_

Ahora contamos únicamente con dos archivos, los cuales son los verdaderamente necesarios. Todo lo demás puede ser configurado de otras maneras en tiempo de ejecución.

## **¿De qué sirve haber reducido la aplicación?**

Ahora te preguntarás, **¿de qué sirve haber reducido la aplicación?** En realidad, mi objetivo es comprendamos un poco más acerca de lo que ocurre en la ejecución de una aplicación ._NET_ (sin adentrarnos más de lo necesario).

En muchas ocasiones, la falta de comprensión de este proceso aparentemente simple es la causa de horas de frustración para muchos desarrolladores al intentar desplegar sus aplicaciones. Un escenario de ejemplo común que observo es cuando se desea implementar una aplicación con _Docker_, se agrega un _[NGINX](https://www.nginx.com/)_ al frente de la aplicación y, de repente, la aplicación no responde en un puerto o una _URL_ específica. En ocasiones, el administrador del proxy solicita cambios en la configuración del servidor HTTP para que responda y acepte solicitudes de ciertos orígenes, entre otros. Esto son cosas que no nos preocuparía tanto si por ejemplo se despegara en un _App Service en Azure_, ya que ellos nos abstrae de esta responsabilidad.

Si comprendemos claramente todo lo que hemos discutido hoy, será mucho más sencillo resolver este tipo de problemas.

## Conclusión

Si bien los editores y herramientas nos proporcionan numerosas configuraciones que aumentan nuestra productividad, es fundamental tener un entendimiento básico de lo que sucede en el fondo. Comprender este proceso no solo facilitará nuestras vidas como desarrolladores de código, sino que también será invaluable en los procesos de entrega y soporte de aplicaciones. La combinación de conocimientos profundos y el uso eficiente de herramientas nos posiciona para abordar desafíos de implementación y mantenimiento con mayor eficacia.

Te invito a ver mis otros [artículos](https://programemos.net/).

---

## Genera Ingresos con tu Aplicación MAUI: Descubre Cómo Mostrar Anuncios de Google AdMob

URL: https://programemos.net/genera-ingresos-con-tu-aplicacion-maui-descubre-como-mostrar-anuncios-de-google-admob/
Fecha: 2023-10-21
Categorías: Programación
Descripción: Configura Google AdMob en una aplicación .NET MAUI para Android, desde el registro y los bloques de anuncios hasta la integración del banner.

Con la evolución constante de MAUI, cada vez más empresas usan esta tecnología para desarrollar sus aplicaciones móviles. A medida que la demanda de este tipo de aplicaciones crece, también aumenta el interés en utilizarlas como una fuente de ingresos mediante la publicidad. En este contexto, aprender a integrar anuncios de Google [AdMob](https://admob.google.com) en tu aplicación MAUI no solo es relevante, sino también esencial para maximizar el potencial de tus desarrollos y generar ingresos de manera efectiva. En este artículo, exploraremos cómo puedes mostrar anuncios de [AdMob](https://admob.google.com) en tu aplicación MAUI, permitiéndote monetizar tu trabajo y alcanzar un público más amplio.

Existen muchas maneras de agregar publicidad en nuestras aplicaciones, siendo actualmente [AdMob](https://admob.google.com) la más popular. Por tal motivo en este artículo te explicaremos cómo podemos usarla para agregar publicidad en nuestras aplicaciones MAUI.

## Aclarando algunos conceptos

Antes de empezar vamos a definir brevemente algunos conceptos que debemos tener claros.

**MAUI**: Es una plataforma de desarrollo de aplicaciones multiplataforma que permite a los desarrolladores crear aplicaciones que se ejecuten en Windows, macOS, iOS y Android.

  
**AdMob**: Es una plataforma de publicidad que permite entre otras cosas a los desarrolladores de aplicaciones móviles mostrar anuncios en sus aplicaciones. [AdMob](https://admob.google.com) es propiedad de Google y es una de las plataformas de publicidad móvil más populares del mundo.

## Configurar tu cuenta de AdMob

Lo primero que necesitamos es registrarnos en Google [AdMob](https://admob.google.com), posterior a ese veremos una pantalla de bienvenida. A continuación debemos ir al menú y buscar la opción «Aplicaciones» y luego seleccionar «_Crear nuevo aplicación_«.

![AdMod](https://programemos.net/images/admod1-1024x461-png.webp)

_Panel principal de AdMob_

En primer paso cuando estemos creando la aplicación es indicar en que plataforma estamos trabajando; para nuestro caso elegimos Android, luego nos debemos indicar si la aplicación ya se encuentra ya publicada en la tienda, **lo más recomendable es que antes de hacer estas configuraciones la aplicación ya se encuentre publicada**, eso va facilitar mucho el proceso de validación, si tu aplicación no está disponible en ninguna tienda admitida todavía, puedes volver y [vincularla a alguna más tarde](https://support.google.com/admob/answer/10037806).

Como se mencionó antes, lo más recomendado es que la aplicación ya esté en alguna tienda antes de hacer estos pasos, por lo cual es el proceso que haremos en este artículo.

![Formulario de AdMob para registrar una aplicación Android](https://programemos.net/images/admod2-1-png.webp)

_Configurando una aplicación_

Completado el formulario anterior debes esperar unos días que tu aplicación sea admitida, Luego de la aprobación veras un mensaje similar al siguiente en tu panel de [AdMob](https://admob.google.com).

![Panel de una aplicación aprobada en Google AdMob](https://programemos.net/images/imagen-png.webp)

_Panel de la aplicación_

Los pasos anteriores fueron requeridos para registrar y vincular nuestra aplicación publicada a [AdMob](https://admob.google.com). Pero aún no hemos definido los anuncios que deseamos mostrar. Para configurar los anuncios ingresamos al panel de nuestra aplicación y hacemos clic a la opción de «_Añadir un bloque de anuncios_«.

![Opción para crear un bloque de anuncios en AdMob](https://programemos.net/images/imagen-2-1024x444-png.webp)

_Crear un bloque de anuncio_

A continuación debemos seleccionar el tipo de anuncio que deseamos usar, se muestra una descripción breve de cómo funciona cada una de las opciones disponibles, la selección la haremos en base al comportamiento que deseamos que tenga el anuncio a mostrarse. Para este ejemplo usaremos el «Banner».

![Tipos de bloques de anuncios disponibles en AdMob](https://programemos.net/images/imagen-3-1024x372-png.webp)

_Tipo de anuncios_

En la [página](https://support.google.com/admob/answer/6128738?hl=es) oficial podemos ver la explicación detallada de cada tipo de anuncio. También puede tener varios anuncios por aplicación.

A continuación debemos ingresar un nombre, este solo se usa para mostrarse en nuestra cuenta de [AdMob](https://admob.google.com), también existen algunas opciones avanzadas que podemos configurar, por ejemplo tipo de anuncio (texto, video etc) o los CPM que deseamos manejar entre otras opciones.

![Configuración de un bloque de anuncios tipo banner en AdMob](https://programemos.net/images/imagen-4-1024x481-png.webp)

_Configuración del anuncio_

Finalmente obtendremos 2 códigos que debemos configurar en nuestra aplicación MAUI, el primero es el código que representa nuestra aplicación, el segundo hace referencia al banner que hemos creado, recuerda que podemos tener más de un banner por aplicación.

![Identificadores de aplicación y bloque de anuncios generados por AdMob](https://programemos.net/images/imagen-5-png.webp)

_Códigos generados por [AdMob](https://admob.google.com)_

## Configurar nuestra aplicación MAUI para el uso de AdMob

Creamos un proyecto de MAUI, en mi caso estoy utilizando la versión NET 7. Recordemos que para este tutorial nos vamos a enfocar solo en la implementación para Android. Para iOS se requiere unos cambios adicionales en el _Info.plist_.

Lo primero que hacemos es instalar el paquete de NuGet _Plugin.MauiMTAdmob_, esto nos va permitir integrar nuestra aplicación con [AdMob](https://admob.google.com) de manera simple.

![Instalación del paquete Plugin.MauiMTAdmob desde NuGet](https://programemos.net/images/imagen-6-1024x304-png.webp)

Ahora debemos editar el archivo «_MauiProgram.cs»_ para incluir el uso del nuestro paquete de [AdMob](https://admob.google.com).

![Configuración del paquete de AdMob en MauiProgram.cs](https://programemos.net/images/imagen-8-png.webp)

_MauiProgram.cs_

Ahora debemos configurar el código de nuestra aplicación de [AdMob](https://admob.google.com) en nuestro proyecto Android, abrimos nuestro archivo «_AndroidManifest.xml_» y dentro de las etiquetas de _application_ debemos configurar el código que [AdMob](https://admob.google.com) nos genero previamente(Debe reemplazar el valor mostrado en la imagen con su código de aplicación de [AdMob](https://admob.google.com) ).

![Identificador de la aplicación AdMob configurado en AndroidManifest.xml](https://programemos.net/images/imagen-7-png.webp)

_AndroidManifest.xml_

A continuación debemos preparar nuestra aplicación MAUI para que use [AdMob](https://admob.google.com), para esto debemos agregar la siguiente configuración en _«MainActivity.cs»_

![Inicialización de Google Mobile Ads en MainActivity.cs](https://programemos.net/images/imagen-9-png.webp)

_MainActivity.cs_

Con todas las configuraciones previas, ya estamos listos para agregar publicidad en nuestra página.

## Agregar la publicidad de AdMob en nuestras páginas

Todo lo que hemos hecho hasta ahora es preparar nuestra aplicación para integrarse con [AdMob](https://admob.google.com) , pero aún no hemos configurado dónde y cuándo se va mostrar el anuncio. Al instalar el NuGet y agregar la referencia en nuestra página (Línea 6 de la imagen siguiente) tenemos acceso a un control que va mostrar la publicidad. Para posicionar el banner de publicidad lo hacemos igual como se hace con cualquier otro control de MAUI.

A continuación se muestra un ejemplo de cómo agregar un control de publicidad. La propiedad más importante es «AdsId» porque aquí debemos indicar el código del anuncio que se generó en [AdMob](https://admob.google.com).

![Control de banner AdMob agregado a una página XAML de .NET MAUI](https://programemos.net/images/imagen-10-png.webp)

_MainPage.xaml_

**NOTA**: Existen algunos [códigos](https://developers.google.com/admob/android/test-ads?hl=es-419) que ofrece [AdMob](https://admob.google.com) que podemos usar nuestra fase de desarrollo, se recomienda usarlo mientras se hacen pruebas. Google tiene políticas de uso de [AdMob](https://admob.google.com) , cualquier incumplimiento puede causar que no se muestre la publicidad o el bloqueo de la cuenta.

Como estándar el banner se coloca en la parte superior o inferior para no molestar al usuario, pero podemos colocarlo donde se desee, también podemos configurar cuando se muestra cuando se oculta.

![Aplicación mostrando publicidad en MAUI](https://programemos.net/images/imagen-11-png.webp)

_Aplicación mostrando publicidad._

## Conclusiones

MAUI poco a poco se está dando espacio en el mercado como alternativa en el desarrollo de las aplicaciones, por eso si eres programador .NET es una buena alternativa para tener en cuenta.

Te invito a ver mis otros [artículos](https://programemos.net/).

---

## Mi experiencia con el AZ-204 en español

URL: https://programemos.net/mi-experiencia-con-el-az-204-en-espanol/
Fecha: 2023-10-02
Categorías: General
Descripción: Mi experiencia presentando el examen AZ-204 (Developing Solutions for Microsoft Azure) en español: preparación, tips y qué esperar el día del examen.

En Septiembre del 2023 presenté el examen AZ-204 ([Developing Solutions for Microsoft Azure](https://learn.microsoft.com/en-us/credentials/certifications/exams/az-204/)) en español y deseo compartir como fue esa experiencia, en un [artículo](https://programemos.net/mi-experiencia-con-el-az-400-en-espanol/) anterior comenté mi historia con el [AZ-400](https://learn.microsoft.com/en-us/credentials/certifications/exams/az-400/), si no las has leído aun te recomiendo que lo haga antes de seguir con esta publicación ya que muchas cosas las voy a omitir porque las expliqué a detalle en ese artículo.

## Mi contexto antes del AZ-204

Fue mi primera vez enfrentándome al examen AZ-204, aunque no era mi primera experiencia con certificaciones. En enero de 2023, ya había presentado el [AZ-400](https://learn.microsoft.com/en-us/credentials/certifications/exams/az-400/) y compartido mi [experiencia](https://programemos.net/mi-experiencia-con-el-az-400-en-espanol/). Pensé que sería algo similar, pero me encontré con problemas y novedades que no había experimentado antes.

Presenté este examen en español debido a que no tengo un dominio el inglés, también opté por la modalidad desde casa, ya que en mi localidad no hay centros cercanos para realizar el examen de manera presencial. Mi objetivo era aprobar este examen, ya que sabía que al obtener tanto el [AZ-400](https://learn.microsoft.com/en-us/credentials/certifications/exams/az-400/) como el AZ-204 obtendría la certificación «[Microsoft Certified: DevOps Engineer Expert](https://learn.microsoft.com/en-us/certifications/devops-engineer/).»

![Microsoft Certified: DevOps Engineer Expert](https://programemos.net/images/devops_expert-png.webp)

Microsoft Certified: DevOps Engineer Expert

## ¿Cuales fueron las dificultades?

### Problemas con las traducciones

Uno de los desafíos que enfrenté fue relacionado con las traducciones, algunas traducciones no fueron muy entendibles. En ciertas ocasiones, me vi obligado a cambiar al inglés para entender claramente lo que se estaba preguntando, especialmente en los casos prácticos. Si no lo sabías, al elegir presentar el examen en español, existe un botón que permite cambiar todo al inglés y luego regresar al español. En el caso del [AZ-400](https://learn.microsoft.com/en-us/credentials/certifications/exams/az-400/) este inconveniente no se presentó; la mayoría de las traducciones tenían sentido al leerlas en español.

### Selección de respuesta en ingles

En segundo lugar, me enfrenté a un problema vinculado con la traducción de las opciones de las respuestas en los menús desplegables. Al cambiar al inglés, los controles para seleccionar las respuestas quedaban desactivados. En otras palabras, tenía que regresar al idioma original de la pregunta para poder marcar alguna opción. Este inconveniente fue especialmente notorio en las opciones desplegables, donde no me permitía ver las traducciones, al desactivarse el control impedía que pudiera desplegar las opciones y ver cuál era su traducción. Esta limitación resultó bastante frustrante y complicó la elección de respuestas.

Con respecto a bloquear los controles cuando se aplica la traducción me parece una decisión equivocada, no veo sentido a esto.

## ¿Que novedades tenemos?

### Acceso a [Microsoft Learn](https://learn.microsoft.com/es-es/training/)

Una de las novedades que quiero destacar es la posibilidad de acceder a [Microsoft Learn](https://learn.microsoft.com/es-es/training/) durante el examen. Al presionar sobre el botón que dice «_Microsoft Learn_«, la pantalla se divide en dos: una mitad muestra el examen y la otra [Microsoft Learn](https://learn.microsoft.com/es-es/training/). Aquí, puedes realizar todas las búsquedas que necesites (sin salir del dominio de [Microsoft Learn](https://learn.microsoft.com/es-es/training/)). Posteriormente, investigué un poco y descubrí que esta opción está disponible para todos los exámenes, excepto para los de nivel fundamentos por ahora.

### Pausas durante el examen

Otra novedad importante es la opción de «pausa». Al activar esta función, puedes levantarte de tu asiento y salir del alcance de la cámara, por ejemplo, para ir al baño o abrir la puerta. La pausa no detiene el reloj del examen. **Debes tenerlo en consideración si decides utilizarla. Además, no podrás ver preguntas anteriores, aunque las marcaras previamente como «Por revisar».**

## Qué sigue siendo útil de esta experiencia

Las novedades que comenté son muy recientes, que no sabía que existían y me sorprendieron en el examen.

Considero que la disponibilidad de [Microsoft Learn](https://learn.microsoft.com/es-es/training/) es extremadamente importante y cambiará radicalmente nuestro enfoque para prepararnos para el examen. Si hubiera sabido de esta opción, habría dedicado tiempo a aprender cómo buscar contenido de manera más eficiente en esa plataforma. Además, habría desarrollado una estrategia para identificar qué temas explorar y cuándo hacerlo. Dado que el tiempo promedio asignado por pregunta es de solo 2 minutos, invertir demasiado tiempo en búsquedas en [Microsoft Learn](https://learn.microsoft.com/es-es/training/) podría significar que no alcancemos a responder todas las preguntas.

Establecer una estrategia cuidadosa para aprovechar al máximo [Microsoft Learn](https://learn.microsoft.com/es-es/training/) puede marcar una diferencia significativa en el resultado.

Confío en que este artículo, junto con el [anterior](https://programemos.net/mi-experiencia-con-el-az-400-en-espanol/), sea valioso y útil para aquellos que se están preparando para presentar el examen. Desde mi experiencia personal, creo que incluso a pesar de mis críticas hacia algunas traducciones, si no tienes un dominio del inglés, presentar el examen en español es una opción válida.

Lo compartido representa mi experiencia en 2023. La posibilidad de consultar Learn, las pausas, la interfaz y las traducciones pueden cambiar. En 2026, además, la fecha de retiro de AZ-204 cambia por completo la decisión: valida primero que todavía puedas agendarlo y que encaje en tu ruta de certificación.

Te invito a ver mis otros [artículos](https://programemos.net/).

## Referencias

* [Guía oficial y fecha de retiro de AZ-204](https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/az-204)
* [Examen AZ-204](https://learn.microsoft.com/en-us/credentials/certifications/exams/az-204/)

---

## Acceso seguro a Azure Blob Storage: Implementación de identidades administradas

URL: https://programemos.net/azure-blob-storage-e-identidades-administradas/
Fecha: 2023-05-20
Categorías: Azure
Descripción: Uso de Identidades administradas en Azure Blob Storage para garantizar un acceso seguro y sin contraseñas a los recursos.

En este artículo vamos a utilizar identidades administradas para acceder a recursos de Azure de manera segura, sin necesidad de utilizar credenciales. Cuando se trata de acceder a Azure Blob Storage, uno de los enfoques más utilizados es aprovechar las identidades administradas. Este enfoque es especialmente útil cuando los recursos que necesitan acceder corren en Azure, como Azure Functions. Al utilizar una identidad administrada, se evita la necesidad de lidiar con contraseñas o secretos directamente. En este artículo, nos enfocaremos en la implementación de identidades administradas por el sistema, aunque el proceso para utilizar una identidad administrada por el usuario es similar.

En este artículo, implementaremos una solución práctica utilizando una WebAPI de un solo endpoint en Azure Function. El objetivo de esta WebAPI será leer el contenido de un archivo y devolverlo en la respuesta. Veremos cómo utilizar las identidades administradas en Azure Blob Storage para lograr un acceso seguro y sin contraseñas a los archivos en cuestión.

## Actualización 2026: identidad, roles y secretos

El patrón del ejemplo sigue siendo válido: una identidad administrada obtiene un token y Azure RBAC autoriza el acceso a datos. En proyectos nuevos, usa `DefaultAzureCredential` para que el mismo código funcione con credenciales de desarrollo locales y con la identidad administrada al desplegarse. No incluyas claves de cuenta, cadenas de conexión ni archivos de credenciales en el repositorio.

Asigna el rol de datos en el alcance más pequeño posible. Para una lectura de blobs, `Storage Blob Data Reader` suele ser suficiente; no confundas los roles de plano de administración con los roles de datos. La [guía actual de autorización para Blob Storage](https://learn.microsoft.com/azure/storage/blobs/authorize-access-azure-active-directory) describe los roles y los escenarios compatibles.

## Configurando la Azure Function

Para implementar la funcionalidad de lectura de archivos y devolución de contenido al cliente, crearemos una Azure Function. En nuestro caso, hemos creado una función llamada _«_AuthFunction20230517223943″.

![Azure Function](https://programemos.net/images/function-vista-1024x159-png.webp)

_Azure Function_

Es importante tener en cuenta que, por defecto, las Azure Functions no tienen una identidad administrada asignada. Para habilitar una identidad administrada y asociarla directamente con nuestra Azure Function, seguiremos estos pasos:

1.  **Acceder a la configuración de identidad:** En el menú de opciones de la función, seleccionaremos «Identity» para acceder a la configuración de identidad.
2.  **Configurar una identidad administrada por sistema:** Como vamos a utilizar una identidad administrada por sistema, cambiaremos el estado a «Activado». Esto creará automáticamente una identidad asociada a nuestra Azure Function.

Al seguir los pasos anteriores deberíamos ver algo similar a lo siguiente:

![Identidad Administrada](https://programemos.net/images/identidad-1024x698-png.webp)

_Identidad Administrada por el Sistema_

## Preparando la cuenta de Azure Blob Storage

Para comenzar, es importante definir la cuenta de almacenamiento de Azure a la cual nos conectaremos. En nuestro caso, hemos creado una cuenta llamada «misarchivos».

![Mis Archivos en Blob Storage](https://programemos.net/images/mis-archivos-1024x384-png.webp)

_Mis Archivos_

Ahora procederemos a crear un contenedor en nuestra cuenta de almacenamiento. Un contenedor, que se asemeja a una carpeta en un sistema de archivos tradicional, será utilizado para almacenar todos los documentos que vamos a leer. En este caso, nombraremos nuestro contenedor como «Documentos».

![Documentos](https://programemos.net/images/container-1024x365-png.webp)

_Documentos_

Una vez que hemos creado el contenedor «Documentos», procederemos a crear los archivos que vamos a leer desde nuestra aplicación. En este caso, vamos a crear un archivo llamado «prueba.txt». Es importante asegurarnos de que el acceso a este archivo no sea público, sino protegido o privado. Esto nos permitirá validar la autenticación con la identidad administrada sin necesidad de una contraseña. Si el acceso fuera público, se generaría una URL pública que permitiría acceder al archivo sin ninguna autenticación adicional.

![prueba.txt](https://programemos.net/images/contenido-1024x372-png.webp)

_Prueba_.txt

### Configuración de permisos en Azure Blog Storage usando la identidad administrada

Ahora nos queda un paso crucial: otorgar permisos a la identidad administrada para que pueda acceder a los archivos en la cuenta de almacenamiento. Para lograr esto, asignaremos un rol específico al usuario dentro del almacenamiento. Es esencial seleccionar un rol que permita las acciones necesarias. En nuestro caso, utilizaremos el rol _«_Storage Blob Data Reader», que otorga permisos de lectura de datos sobre los blobs en el almacenamiento. Al asignar este rol a la identidad administrada, garantizamos que tenga los privilegios adecuados para obtener los archivos que necesitamos.

![Roles](https://programemos.net/images/Rol-1024x385-png.webp)

_Roles_

Ahora es el momento de asignar el rol a la identidad administrada asociada a nuestra Azure Function. Esta identidad será la encargada de acceder al archivo en la cuenta de almacenamiento. Al otorgarle el rol adecuado, estamos concediendo los permisos necesarios a nuestra aplicación para que pueda consultar el archivo sin problemas.

![Identidad Administrada por el Sistema](https://programemos.net/images/asignacion-1024x379-png.webp)

_Identidad Administrada por el Sistema_

## Creando la aplicación que consulta el Azure Blog Storage usando identidad administrada

Como mencioné anteriormente, primero crearemos la aplicación que nos permitirá acceder al contenido del archivo. En este caso, utilizaremos una Azure Function con un desencadenador de tipo HTTP. Esta función responderá a las solicitudes HTTP y devolverá el contenido del archivo solicitado. Es una aplicación de ejemplo, no una arquitectura recomendada para entregar archivos en producción: aquí mantendremos el flujo simple para concentrarnos en la autenticación.

En este ejemplo creamos un proyecto de Azure Function y creamos el endpoint que devolverá el contenido del archivo.

```csharp
namespace Auth.Function;
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Azure.Storage.Blobs;
using Azure.Identity;
using Azure.Storage.Blobs.Models;
public class ReadFile
{
    private readonly BlobServiceClient blobServiceClient;
    private readonly string accountStorageName = "misarchivos";
    public ReadFile() => this.blobServiceClient = new BlobServiceClient(new Uri($"https: //{accountStorageName}.blob.core.windows.net"), new DefaultAzureCredential());
    [FunctionName("ReadFile")]
    public async Task<IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", Route = "prueba")] HttpRequest req, ILogger log)
    {
        string blobName = "prueba.txt";
        string containerName = "documentos";
        BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
        BlobClient blobClient = containerClient.GetBlobClient(blobName);
        BlobDownloadResult downloadResult = await blobClient.DownloadContentAsync();
        return new OkObjectResult(downloadResult.Content.ToString());
    }
}

```

### Funcionalidad del código anterior: Estableciendo conexión segura y autenticada con Azure Blob Storage

En el código anterior, hemos creado una función que responde a las solicitudes «GET» enviadas a la URL «/api/prueba». Esta función se encarga de establecer una conexión con una cuenta de almacenamiento llamada «misarchivos». A continuación, busca un contenedor específico llamado «documentos» y lee el contenido de un archivo denominado «prueba.txt». Finalmente, este contenido se envía como respuesta al cliente que realizó la solicitud.

En esta sección, nos centraremos en la línea de código específico que establece la conexión segura y autenticada con Azure Blob Storage. Evitaremos adentrarnos demasiado en los detalles de las Azure Function o la estructura de la cuenta de almacenamiento. En cambio, nos enfocaremos en comprender lo que ocurre en la siguiente linea:

```csharp
 this.blobServiceClient = new BlobServiceClient(new Uri($"https ://{accountStorageName}.blob.core.windows.net"), new DefaultAzureCredential());
```

La línea de código mencionada establece una conexión segura con Azure Blob Storage utilizando una identidad administrada. La instancia de `BlobServiceClient` se crea pasando la URI de la cuenta de almacenamiento de Azure Blob Storage y una instancia de `[DefaultAzureCredential](https://learn.microsoft.com/en-us/dotnet/api/overview/azure/identity-readme)`. La identidad administrada, en este caso, es utilizada como parte de la autenticación para acceder a los recursos de Azure Blob Storage. La ventaja de utilizar una identidad administrada es que no es necesario gestionar ni exponer credenciales en el código, lo que mejora la seguridad y simplifica el proceso de autenticación.

Supongo que en este punto te estarás preguntando lo mismo que yo cuando vi este código por primera vez ¿Dónde estoy indicando que estoy usando identidad administrada? ¿Qué identidad administrada estoy usando? Bueno, eso es la magia de usar [](https://learn.microsoft.com/es-es/dotnet/api/azure.identity.defaultazurecredential?view=azure-dotnet)`` `[DefaultAzureCredential](https://learn.microsoft.com/en-us/dotnet/api/overview/azure/identity-readme)` `` de la librería _[Azure.Identity](https://learn.microsoft.com/es-es/dotnet/api/overview/azure/identity-readme)_.

_[Azure.Identity](https://learn.microsoft.com/es-es/dotnet/api/overview/azure/identity-readme)_ es un proceso que simplifica la autenticación en Azure. Esta clase selecciona automáticamente la identidad o las credenciales adecuadas según el entorno de ejecución. Por ejemplo, si estás en Azure, utilizará las credenciales de la identidad administrada o el certificado de la máquina virtual. Si estás desarrollando localmente, puede utilizar las credenciales almacenadas en el archivo de configuración o las variables de entorno. En resumen, [](https://learn.microsoft.com/es-es/dotnet/api/azure.identity.defaultazurecredential?view=azure-dotnet)`` `[DefaultAzureCredential](https://learn.microsoft.com/en-us/dotnet/api/overview/azure/identity-readme)` `` simplifica la gestión de las credenciales de autenticación al seleccionar automáticamente las más apropiadas según el contexto de ejecución.

Entonces, para responder a las 2 preguntas que planteamos antes, cuando nuestra aplicación esté corriendo en Azure Function, [](https://learn.microsoft.com/es-es/dotnet/api/azure.identity.defaultazurecredential?view=azure-dotnet)`` `[DefaultAzureCredential](https://learn.microsoft.com/en-us/dotnet/api/overview/azure/identity-readme)` `` tomara la identidad administrada que está asociada a este recurso. [](https://learn.microsoft.com/es-es/dotnet/api/azure.identity.defaultazurecredential?view=azure-dotnet)`` `[DefaultAzureCredential](https://learn.microsoft.com/en-us/dotnet/api/overview/azure/identity-readme)` `` permite especificar cuál queremos usar, pero eso es útil cuando usamos identidades administradas por el usuario.

### Publicando nuestra aplicación

Vamos a probar nuestra aplicación directamente en Azure, para eso hacemos el despliegue, puedes usar el mecanismo con el que estés familiarizado o sea más fácil para ti, en mi caso yo recomiendo usar Visual Studio, una vez completado el despliegue veremos nuestra Function ejecutándose en Azure.

![Azure Function](https://programemos.net/images/function-vista-1024x159-png.webp)

_Azure Function_

Finalmente para concluir probamos nuestro web api, para eso podemos ingresar a la function y luego a la opción de Code + Test, así comprobaremos que el contenido del archivo es devuelto por el Web Api.

![Probando nuestra API](https://programemos.net/images/prueba-1024x378-png.webp)

_Probando nuestra API_

Aunque en este ejemplo nos enfocamos al uso de la identidad administrada para acceder al Azure Account Storage, el proceso para acceder a los otros recursos es muy similar e incluso igual en muchos casos.

## Bonus:

En la siguiente [publicación](https://programemos.net/acceso-a-azure-storage-desde-azure-function-identidades-administradas/), puedes ver cómo podemos mejorar aún más la seguridad al configurar la cuenta de almacenamiento usada por Azure Function(_Runtime_) en su operación administrativas, para el uso de entidades administradas en lugar de cadenas de conexión.

## Conclusión

La implementación de identidades administradas en Azure Blob Storage ofrece una solución segura y eficiente para el acceso a archivos en la nube. Mediante la configuración adecuada de permisos y la asignación de roles a la identidad administrada, podemos garantizar que nuestras aplicaciones accedan de forma autorizada a los recursos de almacenamiento sin necesidad de contraseñas explícitas. Esta práctica simplifica la gestión de acceso y mejora la seguridad, brindando tranquilidad a los desarrolladores y administradores de sistemas. Al utilizar identidades administradas, podemos proteger nuestros datos y mantener un entorno de almacenamiento en la nube más seguro y confiable.

Si quieres seguir aprendiendo sobre estos temas te invito a ver mis otras [publicaciones](https://programemos.net/).

---

## Cómo usar Microsoft Entra ID para autenticarse en Azure SQL Server

URL: https://programemos.net/configurar-azure-active-directory-en-azure-sql-server/
Fecha: 2023-05-14
Categorías: Azure
Descripción: Guía para configurar Microsoft Entra ID en Azure SQL Server y establecer autenticación segura sin contraseñas tradicionales.

Azure SQL Server es una base de datos relacional en la nube que permite a los usuarios almacenar y administrar grandes cantidades de datos de manera segura y escalable. Configurar Azure Active Directory en Azure SQL Server es una parte fundamental para establecer un sistema de autenticación seguro y confiable que garantice la privacidad de los datos.

Si bien la forma más común de autenticarse en Azure SQL Server es mediante el uso de un usuario y contraseña de SQL, en este artículo te mostraremos una alternativa utilizando Azure Active Directory. Aprenderás cómo configurar y utilizar Azure Active Directory para autenticarte de manera efectiva en Azure SQL Server.

Azure Active Directory es una solución de autenticación basada en la nube que brinda una plataforma escalable y segura para la gestión de identidades. Al utilizar Azure Active Directory para autenticarte en Azure SQL Server, podrás proteger tus datos contra posibles amenazas como la suplantación de identidad y garantizar su seguridad.

## Actualización 2026: Microsoft Entra ID y acceso con privilegios mínimos

Azure Active Directory ahora se denomina **Microsoft Entra ID**. Los nombres que aparecen en las capturas pertenecen a la interfaz de 2023, pero el objetivo no cambia: configurar un administrador de Microsoft Entra para el servidor, crear usuarios o grupos contenidos en cada base de datos y otorgar únicamente los permisos requeridos.

Para aplicaciones, evita el flujo `Active Directory Password` y no guardes contraseñas de usuarios en cadenas de conexión. Prioriza identidades administradas, identidades de carga de trabajo o autenticación interactiva según el tipo de aplicación. Consulta la [documentación vigente de autenticación de Microsoft Entra para Azure SQL](https://learn.microsoft.com/azure/azure-sql/database/authentication-aad-overview) antes de adaptar los pasos del portal.

## Configuración de Azure Active Directory

En este ejemplo, crearemos un grupo denominado «groupsql» de [AAD](https://azure.microsoft.com/en-ca/products/active-directory/) y lo estableceremos como «Azure Active Directory Admin». De esta manera, los usuarios que pertenezcan a este grupo podrán administrar nuestro servidor de Azure SQL Server.

Para comenzar, accedemos a nuestra cuenta de Azure y nos dirigimos a la sección de Azure Active Directory. Luego, seleccionamos la opción de «Grupos» y procedemos a agregar el grupo que necesitamos para nuestros fines específicos.

![Creando grupo de AAD](https://programemos.net/images/msedge_0AenapWLLD-1024x709-png.webp)

_Creando Grupo de [AAD](https://azure.microsoft.com/en-ca/products/active-directory/)_

Ahora agregaremos el usuario «sqluser», quien ya ha sido creado previamente. Si lo deseas, puedes utilizar otro usuario existente o crear uno nuevo.

![Usuario sqluser](https://programemos.net/images/sqluser-1024x733-png.webp)

_Usuario sqluser_

Es posible que la creación de un usuario en Azure Active Directory requiera algunas tareas adicionales, dependiendo de las políticas de seguridad de la empresa. Por ejemplo, es posible que se requiera cambiar la contraseña del usuario o configurar la autenticación en dos pasos. Si es necesario realizar estas tareas, es importante seguir los pasos específicos para hacerlo en Azure Active Directory. Esto garantizará que la autenticación sea segura y efectiva.

Luego debemos agregar el usuario al grupo que creamos previamente.

![Agregamos Usuario al Grupo](https://programemos.net/images/Agregamos-usuario-al-grupo-1024x378-png.webp)

_Agregamos un Usuario al Grupo_

## Configurar la base datos de Azure SQL Server

En este caso, vamos a utilizar una base de datos que contiene una tabla de «users» ya creada previamente. A través de Azure Active Directory, vamos a consultar los registros que contiene.

![Base de datos de prueba seleccionada en Azure SQL](https://programemos.net/images/DB-Pruebas-1024x294-png.webp)

_Base Datos de Prueba_

Para poder conectarnos usando el mecanismo de Azure Active Directory, es necesario seguir los siguientes pasos:

### Configurar las reglas de firewall del servidor de base de datos

Al crear un servidor de base de datos en Azure, por defecto, se establece una regla de firewall que solo permite el acceso desde las direcciones IP configuradas en la lista de permitidos. Si se intenta acceder a la base de datos desde una dirección IP no autorizada, se recibirá un mensaje de error.

En nuestro caso, como vamos a correr una aplicación desde nuestra computadora local, es necesario agregar la dirección IP pública de nuestra máquina a las reglas de firewall del servidor de base de datos. De esta manera, se permitirá la conexión que proviene de nuestra máquina. Este paso no es exclusivo de una conexión a través de Azure Active Directory: también se aplica a la autenticación mediante nombre de usuario y contraseña de SQL Server.

Para configurar las reglas de firewall del servidor de base de datos en Azure, es necesario acceder a las opciones de «Networking» de nuestro servidor. Allí encontraremos la sección «Firewall» donde podemos agregar reglas para permitir o denegar conexiones entrantes al servidor de base de datos. Si nuestra aplicación se conectará desde una máquina personal, es importante agregar la dirección IP pública de dicha máquina a las reglas de firewall para permitir la conexión. Una forma sencilla de hacerlo es mediante la opción «Add your client IP» que agregará automáticamente la dirección IP pública de la máquina desde donde se está realizando la configuración.

![Firewall](https://programemos.net/images/My-Firewall-1024x538-png.webp)

_Configuración del Firewall_

### Configurar el Azure Active Directory Admin

El Azure Active Directory Admin en Azure SQL Server es un rol especial que otorga permisos de administración sobre el servidor y las bases de datos. Al configurar este rol, se establece una conexión entre Azure Active Directory y el servidor de base de datos, lo que permite gestionar y controlar el acceso de los usuarios a la instancia de Azure SQL Server de manera centralizada. Esto proporciona una mayor seguridad y control sobre quién tiene privilegios de administración y acceso a los recursos.

Continuando con la configuración, accedemos al menú de opciones de Azure SQL Server y seleccionamos la opción «Azure Active Directory». Aquí configuraremos el grupo «groupsql» que previamente hemos creado. Esta configuración permitirá establecer una integración entre Azure Active Directory y el servidor de base de datos, brindando a los usuarios del grupo «groupsql» acceso y permisos específicos sobre la instancia de Azure SQL Server.

![Azure Active Directory](https://programemos.net/images/Azure-Active-Directory-1024x433-png.webp)

_Azure Active Directory_

La configuración de Azure Active Directory en conjunto con el grupo «groupsql» asegurará que los usuarios designados tengan el acceso adecuado a la base de datos y puedan realizar las operaciones necesarias según sus responsabilidades. Esto brinda un mayor control sobre la seguridad y la administración de la instancia de Azure SQL Server.

Es importante tener en cuenta que si al crear el servidor de base de datos se seleccionó la opción de «Solo autenticación SQL», al configurar el Azure Active Directory Admin se nos pedirá habilitar la opción de Azure Active Directory. En este caso, debemos asegurarnos de seleccionar «Sí» para habilitar la integración de Azure Active Directory en el servidor de base de datos.

Esta configuración permitirá que Azure Active Directory Admin sea el administrador principal del servidor y las bases de datos, brindando mayor control sobre los accesos y permisos de los usuarios. Al habilitar Azure Active Directory en un servidor que inicialmente fue configurado solo con autenticación SQL, se amplían las opciones de autenticación y se fortalece la seguridad y la gestión de identidades en la instancia de Azure SQL Server.

## Cómo conectarse a la base de datos con Azure Active Directory

Ahora que hemos completado la configuración, es natural preguntarse: «¿Cómo puedo conectarme ahora?». Las opciones para conectarse utilizando Azure Active Directory son bastante similares a las que se utilizan con la autenticación de usuario y contraseña de SQL. Por ejemplo, si estás intentando conectarte con un cliente como Azure Data Studio, deberás seleccionar el tipo de autenticación «Azure Active Directory» y proporcionar un usuario que pertenezca al grupo que hemos configurado previamente. Un ejemplo de cómo se vería esto es el siguiente:

![Azure Data Studio](https://programemos.net/images/SQLDataStudio-png.webp)

_Azure Data Studio_

Otra opción para conectarse a la base de datos es mediante el uso de una cadena de conexión. En este caso, la estructura de la cadena es muy similar a la que se utiliza para la autenticación SQL, pero se agrega un parámetro adicional: _Authentication=»Active Directory Password_«. El resultado final sería algo similar a lo siguiente:

```
Server=tcp:{your_server};Initial Catalog=prueba;Persist Security Info=False;User ID={your_username};Password={your_password};MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Authentication="Active Directory Password";
```

Esta información también se puede obtener en Azure, específicamente en la sección de «Settings» y luego en «Connection Strings». Ahí encontrarás las opciones de conexión disponibles, incluyendo las relacionadas con Azure Active Directory.

![Cadena de Conexión](https://programemos.net/images/ConnectionsString-1024x446-png.webp)

_Cadena de Conexión_

## Conexión segura a Azure SQL Server con Azure Active Directory: Ejemplo en C#

Ahora que hemos completado la configuración necesaria y sabemos cómo obtener una cadena de conexión basada en la autenticación de Azure Active Directory, vamos a realizar un ejemplo práctico. A continuación, se muestra un ejemplo de una aplicación de consola en C# utilizando .NET 7 que consultará los usuarios de la base de datos:

```csharp
using Microsoft.Data.SqlClient;

string connectionString = "Your Connection String"; // Reemplace con su cadena de conexión real
using (SqlConnection connection = new(connectionString))
{
    string query = "SELECT Id, Email, Name FROM Users";
    SqlCommand command = new(query, connection);

    connection.Open();
    SqlDataReader reader = command.ExecuteReader();

    while (reader.Read())
    {
        Guid id = reader.GetGuid(0);
        string email = reader.GetString(1);
        string name = reader.GetString(2);

        Console.WriteLine("Id: {0}, Email: {1}, Name: {2}", id, email, name);
    }
    reader.Close();
}
```

  
El resultado de la ejecución sería el siguiente:

![Aplicación Resultado](https://programemos.net/images/Aplicacion-de-AAD-png.webp)

_Aplicación Resultado_

## Conclusión

La implementación de Azure Active Directory para la autenticación en Azure SQL Server brinda numerosos beneficios, como una capa adicional de seguridad, la gestión centralizada de identidades y la protección contra amenazas como la suplantación de identidad, permite establecer conexiones seguras y gestionar eficientemente los permisos de acceso a la base de datos. En definitiva, Azure Active Directory mejora la experiencia de autenticación, simplifica la administración de identidades y fortalece la protección de los datos en entornos de Azure SQL Server.

Sin embargo, es importante tener en consideración que al configurar el Azure Active Directory Admin, estamos otorgando permisos de administración sobre el servidor de base de datos. Esto puede no ser adecuado en todos los casos, ya que puede haber escenarios donde se requiera un control más granular de los permisos. Siempre es necesario evaluar cuidadosamente los requisitos específicos de seguridad y acceso de nuestra aplicación y determinar si la solución de utilizar Azure Active Directory se ajusta a nuestras necesidades.

Te invito a ver mis otros [artículos](https://programemos.net/).

## Referencias

[Microsoft Learn](https://learn.microsoft.com/es-es/azure/azure-sql/database/authentication-aad-overview?view=azuresql)

---

## ¿Reglas o herramientas? El pensamiento crítico en la arquitectura de software

URL: https://programemos.net/reglas-o-herramientas-pensamiento-critico-arquitectura-software/
Fecha: 2023-04-06
Categorías: Arquitectura de Software
Descripción: Reflexión sobre la importancia del pensamiento crítico en la arquitectura de software y la toma de decisiones.

En este artículo, te quiero dar una reflexión crítica sobre la arquitectura de software, un tema de gran relevancia en el mundo del desarrollo de software. En Internet, podemos encontrar una gran cantidad de información sobre patrones de diseño, arquitecturas limpias, [DDD](https://learn.microsoft.com/es-es/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/ddd-oriented-microservice), [CQRS](https://learn.microsoft.com/es-es/azure/architecture/patterns/cqrs) y muchos otros. Hay muchos tutoriales en los que se habla de estos temas y se ofrecen ejemplos de su implementación en código. En mi opinión, muchos de estos tutoriales son excelentes.

Pero siento que se centran únicamente en los aspectos técnicos y en las ventajas de implementar estas soluciones, sin dejar espacio para la crítica. Esto puede generar una idealización del uso de estas herramientas o estrategias, impidiéndonos verlas como lo que realmente son: referencias que podemos utilizar, en lugar de reglas estrictas que debemos seguir al pie de la letra.

## Historia de mi primera base datos en el mundo real

En esta sección, me apartaré brevemente del mundo de la arquitectura de software(Desde perspectiva del código) y compartiré un caso personal que ilustra lo que mencioné anteriormente. Trataré de explicarlo de forma clara y simple para que sea fácil de entender para todos, sin necesidad de conocimientos técnicos avanzados.

Me enseñaron de manera idealista (Mundo perfecto sobre el papel) que una base datos debe distribuir los datos en varias tablas, y que no deberían duplicarse campos en otra tabla porque podría generar inconsistencia.

La primera vez que diseñe una base datos en el mundo real no era muy grande, pero si tenías varias tablas, para una pantalla de un módulo de aplicación se necesitaba incluir el nombre de la empresa, pero para poder acceder a ese campo tenía que pasar por el join de 5 tablas que no necesitaba, solo era para llegar al campo empresaId y luego obtener de la tabla empresa el nombre.

![Modelo Empresa](https://programemos.net/images/Modelo-Empresa-1024x151-png.webp)

Modelo de Empresa

Como se podría deducir, el campo empresaId solamente estaba presente en una tabla, lo que causaba que la consulta fuera muy lenta en su ejecución, y con mis limitados conocimientos en ese entonces no sabía cómo solucionarlo. Fue entonces cuando alguien me sugirió:

_«Agrega ese campo empresaId en todas las tablas, esto reducirá la cantidad de joins necesarios y hará que la consulta sea más rápida. Además, ten en cuenta que esta pantalla no será la única que utilizará ese campo»._

Al escuchar esa solución, me parecía inaceptable, porque en mi mundo ideal de teoría de base de datos consideraba que esto era una mala práctica. Para mí, las reglas de modelado de bases de datos no indicaban agregar campos duplicados en varias tablas.

Si hubiera entendido que evitar duplicar campos en otras tablas era una estrategia para evitar posibles inconsistencias, en lugar de una regla que debía seguirse ciegamente, no me habría cerrado a la posibilidad de encontrar una solución y ampliar mis opciones.

## ¿Este caso como se relaciona con la arquitectura software?

En la arquitectura de software ocurre lo mismo: a menudo se ven como reglas a seguir paso a paso, cuando en realidad son herramientas que podemos utilizar según las necesidades. Por eso, en este primer artículo, quise presentar el contexto e invitar a un poco de pensamiento crítico.

Al igual que en mi experiencia personal, la arquitectura de software también puede volverse compleja y abrumadora. Cuando se trata de tomar decisiones de arquitectura, puede ser tentador seguir patrones de diseño y reglas preestablecidas sin cuestionarlas. Pero cada proyecto de software es único y requiere una solución específica. El pensamiento crítico nos permite analizar y evaluar las opciones disponibles.

También es muy importante recordar que la arquitectura de software es como una caja de herramientas: tenemos muchos elementos, pero no estamos obligados a usarlos todos solo porque sí. Solo debemos utilizar aquellos que se ajusten y nos ayuden a resolver un problema, esa es su razón de existir, no son para generar una complicación adicional innecesariamente en nuestra aplicación.

## Conclusión

Creo que es más valioso comprender el contexto del conocimiento y su verdadero propósito, en lugar de enfocarnos únicamente en su implementación. En el campo de la arquitectura de software, existen muchos tutoriales en línea que detallan cómo implementar una determinada técnica de programación paso a paso, pero es más importante comprender por qué y el cuándo de su aplicación. Esto requiere de un pensamiento crítico y consideración de factores como los humanos, económicos y temporales, que influyen en la toma de decisiones.

En las próximas publicaciones, empezaré a exponer mis críticas específicas sobre las arquitecturas limpias [DDD](https://learn.microsoft.com/es-es/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/ddd-oriented-microservice) y [CQRS](https://learn.microsoft.com/es-es/azure/architecture/patterns/cqrs). Mientras te invito a ver mis otras [publicaciones](https://programemos.net/).

## Librería y ejemplo verificable

La librería [josearias210.DDD](https://github.com/josearias210/DDD) reúne utilidades C# para entidades, objetos de valor, reglas de negocio y eventos de dominio. Está publicada como paquete NuGet, incluye integración continua y puede instalarse con `Install-Package josearias210.DDD`.

Es un ejemplo pequeño para discutir reglas y objetos de valor; no pretende imponer DDD completo ni justificar capas que el problema no necesita. Última verificación: agosto de 2026.

---

## Examen AZ-400 en español: mi experiencia y cómo prepararlo

URL: https://programemos.net/mi-experiencia-con-el-az-400-en-espanol/
Fecha: 2023-02-07
Categorías: General
Descripción: Experiencia real con el examen AZ-400 en español, preparación, traducciones y qué revisar en la guía oficial actualizada antes de presentarlo.

En febrero de 2023 presenté y aprobé al primer intento el examen AZ-400 ([Designing and Implementing Microsoft DevOps Solutions](https://learn.microsoft.com/es-es/credentials/certifications/exams/az-400/)) en español. Comparto la experiencia porque encontré pocas referencias de personas que lo hubieran presentado en este idioma.

La experiencia del día del examen sigue siendo útil, pero el temario no es el mismo. Microsoft actualizó la versión en inglés el 27 de julio de 2026 y avisa que las versiones localizadas suelen tardar aproximadamente ocho semanas en recibir los cambios. Antes de estudiar, revisa la fecha de la [guía oficial de AZ-400](https://learn.microsoft.com/es-es/credentials/certifications/resources/study-guides/az-400).

## Mi contexto antes del AZ-400

Era la primera vez que presentaba un examen de certificación, aunque ya tenía varios años desarrollando aplicaciones .NET y algo de experiencia con Azure. No me había animado antes porque donde vivo no hay centros cercanos y sentía que mi nivel de inglés no era suficiente.

La opción de presentarlo desde casa y en español eliminó esas dos barreras. Además, tenía un voucher que había recibido al completar módulos de [Microsoft Learn](https://learn.microsoft.com/es-es/), así que decidí intentarlo. AZ-400 es el examen requerido para la certificación [Microsoft Certified: DevOps Engineer Expert](https://learn.microsoft.com/es-es/credentials/certifications/devops-engineer/).

![Insignia de la certificación Microsoft Certified DevOps Engineer Expert](https://programemos.net/images/devops_expert-png.webp)

_Microsoft Certified: DevOps Engineer Expert_

## Cómo preparé el examen AZ-400

¿Por qué empecé por AZ-400? La razón principal es sencilla: el voucher solo servía para ese examen. También me ayudó que ya usaba Azure DevOps en el trabajo, por lo que una parte del terreno no me resultaba desconocida.

Puedes presentar AZ-400 directamente, como hice yo. Sin embargo, **aprobar el examen y obtener la certificación completa no son lo mismo**. La página de DevOps Engineer Expert sigue indicando una certificación Associate como prerrequisito. AZ-204 y Azure Developer Associate se retiraron el 31 de julio de 2026, por lo que no conviene seguir una ruta antigua de memoria: confirma en la página oficial qué prerrequisitos están vigentes cuando vayas a registrarte.

Para estudiar empecé por los módulos de Microsoft Learn en español. El problema fue la traducción de conceptos técnicos. Aunque no domino el inglés, los nombres de servicios y operaciones los conozco en inglés: hablamos de *commit* y *push*, no de “comprometer” y “empujar”. Por eso comparaba ambas versiones cuando un término me parecía extraño.

También compré un curso en inglés y usé subtítulos automáticos. No fue una experiencia perfecta, pero me sirvió para escuchar los términos en el idioma en que los utilizaba en el trabajo. Hoy añadiría la evaluación de práctica, el sandbox oficial y ejercicios reales con GitHub y Azure DevOps.

### Qué estudiar según el temario actual

Desde julio de 2026, Microsoft distribuye el examen aproximadamente así:

*   procesos y comunicaciones: 10-15 %
*   estrategia de control de código fuente: 10-15 %
*   pipelines de compilación y entrega: 50-55 %
*   seguridad y cumplimiento: 10-15 %
*   instrumentación: 5-10 %

No estudiaría esos porcentajes como compartimentos aislados. Practicaría un flujo completo: repositorio, estrategia de ramas, pipeline, secretos, despliegue, controles de seguridad, observabilidad y retroalimentación. La mitad del peso está en pipelines, pero el examen evalúa decisiones de DevOps, no solo sintaxis YAML.

## Presentarlo desde casa y en español

Al agendar el examen remoto me preocupaba la comunicación con la persona que supervisaría la sesión. El examen estaba disponible en español, pero no encontré esa misma opción para el supervisor. Mi duda era muy práctica: ¿qué pasaría si me daba una instrucción y yo no la entendía?

Me conecté media hora antes. Descargué la aplicación del proveedor, probé micrófono, cámara y conexión, tomé las fotos requeridas del documento de identidad y del espacio de trabajo, y esperé la validación. Ya había ejecutado las pruebas técnicas varios días antes.

Un consejo que me ayudó fue dejar el escritorio completamente limpio: sin reloj, teléfono, monitores adicionales, pizarras ni objetos que pudieran generar una revisión. En mi caso todo se validó y el examen comenzó sin necesidad de conversar con el supervisor. Esa fue mi experiencia en 2023, no una garantía de que el proceso actual sea idéntico.

La sorpresa importante apareció en la primera pregunta: podía ver la pregunta y las respuestas en inglés y luego volver al español. Eso resolvió mi principal preocupación. Cuando una traducción técnica resultaba ambigua, comprobaba el texto original y continuaba.

Pude completar el examen sin contratiempos y lo aprobé al primer intento.

## Lo que haría hoy para preparar AZ-400

Empezaría por la guía oficial y comprobaría su fecha. Después usaría este orden:

1. Revisar el temario y marcar qué áreas ya utilizo en proyectos reales.
2. Completar los módulos oficiales y la evaluación de práctica.
3. Probar el sandbox para conocer la interfaz antes del examen.
4. Implementar al menos un pipeline completo con seguridad y observabilidad.
5. Estudiar los nombres técnicos en inglés aunque vaya a presentar en español.

Evitaría depender de bancos de preguntas memorizadas. Pueden dar una falsa sensación de avance y no preparan para escenarios donde hay que elegir entre varias soluciones razonables.

Mi experiencia no sustituye la guía actual. Lo que sí se mantiene es la ventaja de llegar con práctica en GitHub, Azure DevOps, seguridad, entrega y observabilidad. Presentarlo en español reduce una barrera, pero entender el vocabulario técnico en inglés sigue ayudando mucho.

También puedes revisar mi [experiencia con AZ-204](https://programemos.net/mi-experiencia-con-el-az-204-en-espanol/). Si quieres seguir aprendiendo sobre estos temas, te invito a ver mis otras [publicaciones](https://programemos.net/).

## Referencias

*   [Página oficial del examen AZ-400](https://learn.microsoft.com/es-es/credentials/certifications/exams/az-400/)
*   [Guía de estudio AZ-400](https://learn.microsoft.com/es-es/credentials/certifications/resources/study-guides/az-400)
*   [DevOps Engineer Expert y sus requisitos](https://learn.microsoft.com/es-es/credentials/certifications/devops-engineer/)
*   [Prepararse con el sandbox del examen](https://learn.microsoft.com/es-es/credentials/certifications/prepare-exam)

---

## Notificaciones Push con Firebase, Azure Function y MAUI

URL: https://programemos.net/notificaciones-push-firebase-azure-function-maui/
Fecha: 2022-12-26
Categorías: Programación
Descripción: Vamos a usar Firebase, MAUI y Azure Function para crear un flujo de envío y recepción de notificaciones push para Android.

En esta publicación vamos a configurar un proyecto Firebase que sirva de centro de notificaciones push, adicionalmente vamos a crear una API con Azure Function que usaremos para enviar notificaciones y finalmente crearemos una aplicación Android usando MAUI que va a recibir los mensajes que son enviados por la API.

## Actualización 2026: límites de este ejemplo y seguridad

El flujo conceptual con Firebase Cloud Messaging (FCM) continúa siendo útil, pero las pantallas, dependencias y requisitos de Android cambian con frecuencia. Usa este artículo para entender la integración y contrasta cada paso con la [documentación actual de FCM](https://firebase.google.com/docs/cloud-messaging) y las versiones compatibles de .NET MAUI.

La clave privada de la cuenta de servicio mostrada más adelante es un secreto de producción: no la distribuyas con la aplicación móvil, no la confirmes en Git y no la expongas desde un endpoint. Guárdala en un almacén de secretos, limita su acceso y haz que solo el backend autenticado envíe notificaciones. Los clientes deben registrar y renovar sus tokens de FCM, porque pueden cambiar o dejar de ser válidos.

![Infraestructura para Notificaciones Push](https://programemos.net/images/Notificaciones-Push-1024x331-png.webp)

_Infraestructura para Notificaciones Push_

El flujo para enviar un mensaje sería similar al siguiente:

No quiero entrar en detalle de cómo funciona el servicio «Messaging» de Firebase; ya que la [documentación](https://firebase.google.com/docs/cloud-messaging) se explica a detalle. Lo que por ahora necesitamos saber es que con este servicio podemos enviar mensajes directo a un cliente específico o podemos crear filtros para enviarlo a un grupo de cliente que cumple con ciertas condiciones, ejemplo podemos crear un [tópico](https://firebase.google.com/docs/cloud-messaging/topic-messaging) y enviar un mensaje el cual será recibido solo por los clientes que están suscritos a ese [tópico](https://firebase.google.com/docs/cloud-messaging/topic-messaging). Este enfoque es el que vamos a usar en nuestro ejemplo.

## Configuración de Firebase

Lo primero que necesitamos es hacer algunas configuraciones en la [consola](https://console.firebase.google.com/) de Firebase para preparar todo lo necesario para enviar y recibir notificaciones push, por eso debemos crear un proyecto nuevo y registrar una aplicación para Android.

### Crear un nuevo proyecto en Firebase

Necesitamos crear un nuevo proyecto en la [consola](https://console.firebase.google.com/) de Firebase.

![Empezar a Crear Proyecto en Firebase](https://programemos.net/images/notificacion_boton_crear_proyecto-png.webp)

_Crear proyecto en la consola de Firebase_

El primer paso es establecer el nombre del proyecto. Puede contener espacios si lo deseamos.

![Nombre del Proyecto Firebase](https://programemos.net/images/notificacion_crear_proyecto-png.webp)

_Nombre del Proyecto Firebase_

Luego se nos preguntara si deseamos configurar algunas opciones de analítica, eso no es necesario en nuestro caso, finalmente confirmamos la creación del proyecto.

![Confirmar Creación del Proyecto Firebase](https://programemos.net/images/notificacion_confirmar_crear_proyecto-png.webp)

_Confirmar Creación del Proyecto Firebase_

Ahora se nos mostrará el proyecto creado y los servicios que tenemos disponibles.

![Vista Proyecto Firebase Creado](https://programemos.net/images/notificacion_app_firebase-1024x451-png.webp)

_Vista Proyecto Firebase Creado_

### Creación de la aplicación para Android en Firebase

Dentro del proyecto que creamos vamos a crear una nueva aplicación Android.

![Empezar a Crear Aplicación Android en Firebase](https://programemos.net/images/notificacion_comenzar_app-1024x571-png.webp)

_Crear una Aplicación Android_

El primer paso es definir el nombre del paquete de la aplicación, est**o es muy importante que el nombre que indiquemos aquí debe ser el mismo nombre de paquete que indicamos en la aplicación Android**. Opcionalmente, recomendamos colocar un sobrenombre de aplicación.

Vamos a omitir el certificado, ya que esta aplicación la vamos a instalar en nuestro teléfono Android para pruebas y no va a ser publicada en la tienda.

![Registro aplicación Firebase](https://programemos.net/images/notificacion_registro_app-png.webp)

_Registro aplicación Firebase_

En siguiente paso nos dará la opción de descargar el archivo _google-services.json_ que usaremos más tarde. Es importante descargarlo y guárdalo en un lugar seguro. Luego podemos dar siguiente hasta llegar al botón para confirmar el registro de la aplicación.

![Descargar Google Services en Firebase](https://programemos.net/images/notificacion_google_service-png.webp)

_Descargar Google Services en Firebase_

El archivo anterior será usado por la aplicación Android para su configuración. Adicionalmente, necesitamos una configuración para Firebase Admin SDK, el cual se usara nuestra aplicación servidor para poder enviar los mensajes a través de Firebase. Para esto debemos volver a las configuraciones generales del proyecto.

![Firebase Configuraciones Generales](https://programemos.net/images/firebase_configuraciones-1024x254-png.webp)

_Firebase Configuraciones Generales_

Luego debemos ir a la pestaña _«Cuenta de Servicio»_. Y presionamos sobre el botón «Generar nueva clave privada».

![Cuenta Servicio](https://programemos.net/images/cuenta_servicio-1024x409-png.webp)

_Cuenta de Servicio_

Firebase nos da la opción descargar la configuración y nos da una advertencia que guardemos bien el archivo porque no se va a poder descargar nuevamente el mismo archivo. Si lo pierdes debes generar uno nuevo y actualizar la información en la aplicación que crearemos más adelante.

![Generar nueva clave privada ](https://programemos.net/images/sdk_admin_configuracion-1024x499-png.webp)

_Generar nueva clave privada_

¡Listo! Con esto ya hemos configurado todo lo requerido para comenzar a generar nuestra API y aplicación Android.

## Creamos la Aplicación Android Usando MAUI para recibir las notificaciones push

Para este ejemplo estoy utilizando Microsoft Visual Studio Community 2022 (64 bits) – Versión 17.4.2 en español. Para mantener todo junto vamos a generar una solución en blanco y más adelantes agregaremos 2 proyectos, uno para Servidor que envía los mensajes(Azure Function) y otro para la aplicación móvil Android (MAUI). El código completo de ambos proyectos aparece a lo largo del artículo, así que puedes reconstruir la solución paso a paso desde aquí.

Creemos la Solución en Blanco, vamos a nombrarlo como _NotificationsPush.Maui_.

![Crear Solución en Blanco](https://programemos.net/images/Notificacion_Solucion-1024x120-png.webp)

_Crear Solución en Blanco_

Vamos a generar la aplicación Android y agregaremos una opción para suscribirse a un tópico de notificaciones llamados “Bienvenidos” para recibir todos los mensajes que sean enviados por el servidor, luego serán mostrados como notificaciones Push.

Ahora debemos hacer clic derecho sobre la solución y buscar la opción agregar _Nuevo Proyecto_.

![Agregar proyecto MAUI](https://programemos.net/images/notificacion_agregar_proyecto_maui-png.webp)

_Agregar proyecto MAUI_

Seleccionamos el tipo proyecto _Aplicación .NET MAUI_. Cuando solicite el nombre del proyecto puedes colocar el que desees, por ahora nosotros usaremos _NotificationsPush.Maui_.

![Crear una aplicación maui](https://programemos.net/images/notificacion_maui-1024x422-png.webp)

_Crear una aplicación MAUI_

Seleccionamos .NET 6 como versión del framework.

![Version Framework](https://programemos.net/images/version_framework-png.webp)

_Versión Framework_

Al final debería tener algo similar a lo siguiente.

![Proyecto MAUI creado](https://programemos.net/images/notificaciones_proyecto_maui_creado-png.webp)

_Proyecto MAUI creado_

Ahora necesitas agregar en la raíz del proyecto el archivo de configuraciones _google-services.json_ que descargamos durante la configuración de la aplicación en Firebase.

![Google Services Configuración](https://programemos.net/images/notificaciones_google_services-png.webp)

_Google Services Configuración_

Los cambios más complicados los vamos a hacer en el archivo _NotificationsPush.Maui.cspro_j por eso trataremos de ir poco a poco, empezamos con ver el archivo original generado.

![NotificationsPush.Maui.csproj](https://programemos.net/images/notificaciones_condicionales-1024x617-png.webp)

_NotificationsPush.Maui.csproj_

Como podemos ver tenemos etiquetas _TargetFrameworks_ y _SupportedOSPlatformVersion_ donde estamos indicando las plataformas que vamos a soportar. Lo primero que vamos a hacer es quitar el soporte a todas las plataformas, excepto la de Android (Porque este post solo enfoca esta).

Haremos los cambios necesarios para pasar de soportes para varias plataformas del archivo actual…

![NotificationsPush.Maui.csproj con soporte a todas las plataformas](https://programemos.net/images/notificacion_proyecto_plataformas_antes-1024x676-png.webp)

_NotificationsPush.Maui.csproj con soporte a todas las plataformas_

A solo soporte para Android, para esto es necesario remover todas las referencias hacia las demás plataformas.

![NotificationsPush.Maui.csproj con soporte para Android](https://programemos.net/images/notificacion_proyecto_plataformas_despues-1024x587-png.webp)

_NotificationsPush.Maui.csproj con soporte para Android_

Un paso muy importante es cambiar el _ApplicationId_, esto es porque es la variable que se usa para definir el nombre del paquete Android, debe coincidir con el mismo nombre que se configuró en el nombre de paquete de aplicación para Android, en nuestro caso es _net.programemos.pushnotificaciones_.

![ApplicationId](https://programemos.net/images/notificaciones_nombre_paquete-1024x539-png.webp)

_Variable ApplicationId_

Para finalizar necesitamos agregar estas 3 secciones de _ItemGroup_.

![NotificationsPush.Maui.csproj](https://programemos.net/images/notificaciones_condicionales-1024x617-png.webp)

_NotificationsPush.Maui.csproj_

### ¿Y esto último para que es?

*   La primera sección es para instalar el paquete NuGet que vamos a utilizar llamado _Plugin.Firebase_ (También lo puedes instalar desde gestor de paquetes NuGet igual que cualquier otro)
*   La segunda sección es para que la configuración de _google-services.json_ solo se incluya cuando se compila para Android
*   La tercera es para incluir paquetes NuGet adicionales que solo son requeridos para Android

Con esto ya tendremos listo el archivo _NotificationsPush.Maui.csproj_.

Ahora, como solo estamos dando soporte a Android, debemos eliminar las carpetas de las plataformas que ya no vamos a utilizar.

![Plataformas Disponibles](https://programemos.net/images/notificaiones_borrar_plataformas-png.webp)

_Plataformas Soportadas_

El próximo archivo que vamos a editar será el _AndroidManifest.xml_ vamos a agregar algunos permisos y configuraciones que permiten que la aplicación reciba notificaciones. El archivo original debería verse similar a esto:

```xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
	<application android:allowBackup="true" android:icon="@mipmap/appicon" android:roundIcon="@mipmap/appicon_round" android:supportsRtl="true"></application>
	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
	<uses-permission android:name="android.permission.INTERNET" />
</manifest>
```

Luego de agregar código requerido debería verse de la siguiente manera.

```xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
	<application android:allowBackup="true" android:icon="@mipmap/appicon" android:roundIcon="@mipmap/appicon_round" android:supportsRtl="true">
		<receiver
			android:name="com.google.firebase.iid.FirebaseInstanceIdInternalReceiver"
			android:exported="false" />
		<receiver
			android:name="com.google.firebase.iid.FirebaseInstanceIdReceiver"
			android:exported="true"
			android:permission="com.google.android.c2dm.permission.SEND">
			<intent-filter>
				<action android:name="com.google.android.c2dm.intent.RECEIVE" />
				<action android:name="com.google.android.c2dm.intent.REGISTRATION" />
				<category android:name="${applicationId}" />
			</intent-filter>
		</receiver>
	</application>
	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
	<uses-permission android:name="android.permission.INTERNET" />
</manifest>
```

Aprovechando que estamos en el proyecto de Android vamos a modificar el archivo _MainActivity.cs_ originalmente el archivo debería verse así:

```csharp
using Android.App;
using Android.Content.PM;
using Android.OS;
namespace NotificationsPush.Maui
{
    [Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize | ConfigChanges.Density)]
    public class MainActivity : MauiAppCompatActivity
    {
    }
}
```

Vamos a agregar algunas funciones que nos van a permitir manejar las notificaciones cuando son recibidas.

```csharp
using Android.App;
using Android.Content;
using Android.Content.PM;
using Android.OS;
using Plugin.Firebase.CloudMessaging;
namespace NotificationsPush.Maui
{
    [Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize | ConfigChanges.Density)]
    public class MainActivity : MauiAppCompatActivity
    {
        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);
            HandleIntent(Intent);
            CreateNotificationChannelIfNeeded();
        }
        protected override void OnNewIntent(Intent intent)
        {
            base.OnNewIntent(intent);
            HandleIntent(intent);
        }
        private static void HandleIntent(Intent intent)
        {
            FirebaseCloudMessagingImplementation.OnNewIntent(intent);
        }
        private void CreateNotificationChannelIfNeeded()
        {
            if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
            {
                CreateNotificationChannel();
            }
        }
        private void CreateNotificationChannel()
        {
            var channelId = $"{PackageName}.general";
            var notificationManager = (NotificationManager)GetSystemService(NotificationService);
            var channel = new NotificationChannel(channelId, "General", NotificationImportance.Default);
            notificationManager.CreateNotificationChannel(channel);
            FirebaseCloudMessagingImplementation.ChannelId = channelId;
        }
    }
}
```

Ahora debemos modificar el archivo _MauiProgram.cs_, el archivo original debería verse similar a este.

```csharp
namespace NotificationsPush.Maui
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureFonts(fonts =>
                {
                    fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                    fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
                });
            return builder.Build();
        }
    }
}
```

Luego de los cambios para hacer registro del servicio de notificaciones quedaría algo similar a lo siguiente:

```csharp
using Microsoft.Maui.LifecycleEvents;
using Plugin.Firebase.Auth;
using Plugin.Firebase.Shared;
using Plugin.Firebase.Android;
namespace NotificationsPush.Maui
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .RegisterFirebaseServices()
                .ConfigureFonts(fonts =>
                {
                    fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                    fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
                });
            return builder.Build();
        }
        private static MauiAppBuilder RegisterFirebaseServices(this MauiAppBuilder builder)
        {
            builder.ConfigureLifecycleEvents(events =>
            {
                events.AddAndroid(android => android.OnCreate((activity, state) =>
                    CrossFirebase.Initialize(activity, state, CreateCrossFirebaseSettings())));
            });
            builder.Services.AddSingleton(_ => CrossFirebaseAuth.Current);
            return builder;
        }
        private static CrossFirebaseSettings CreateCrossFirebaseSettings()
        {
            return new CrossFirebaseSettings(isAuthEnabled: true, isCloudMessagingEnabled: true);
        }
    }
}
```

### ¿Qué hicimos en estos últimos pasos?

Todo lo que hicimos hasta ahora es para configurar el servicio y procesos que manejaran las notificaciones en Android. Estos pasos siempre los debemos hacer para preparar nuestra aplicación, para trabajar con notificaciones, en todos nuestras aplicaciones será igual.

Lo que vamos a hacer a continuación ya son las modificaciones propias de nuestra aplicación (De nuestro negocio) ya será nuestra lógica personalizada. Crearemos una interfaz de usuario con 2 botones, uno será para suscribirnos a un tópico de notificaciones llamado «Bienvenido» y otro botón para cancelar la suscripción y dejar de recibir mensajes.

Vamos a crear la interfaz gráfica con la que va a interactuar el usuario, abrimos el archivo _MainPage.xaml_ y agregamos el siguiente código.

```xml
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage
    x:Class="NotificationsPush.Maui.MainPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
    <ScrollView>
        <VerticalStackLayout
            Padding="30,0"
            Spacing="25"
            VerticalOptions="Center">
            <Image
                HeightRequest="200"
                HorizontalOptions="Center"
                Source="dotnet_bot.png" />
            <Label
                x:Name="Status"
                FontSize="32"
                HorizontalOptions="Center"
                SemanticProperties.HeadingLevel="Level1"
                Text="No estas suscrito" />
            <Button
                x:Name="SubscribeBtn"
                Clicked="OnSubscribeClicked"
                HorizontalOptions="Center"
                Text="Subscribe" />
            <Button
                x:Name="UnSubscribeBtn"
                Clicked="OnUnSubscribeClicked"
                HorizontalOptions="Center"
                Text="Unsubscribe" />
        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

```

Con el código anterior creamos los 2 botones que mencionamos anteriormente, adicionalmente se incluyo una etiqueta para saber el estatus de la suscripción y una imagen solo para que se vea más agradable. Ya tenemos la interfaz de usuario, ahora es hora definir la lógica que hará que la interfaz de usuario funcione, vamos al archivo _MainPage.xaml.cs_ y agregamos lo siguiente:

```csharp
    private async void OnSubscribeClicked(object sender, EventArgs e)
    {
        await CrossFirebaseCloudMessaging.Current.CheckIfValidAsync();
        await CrossFirebaseCloudMessaging.Current.SubscribeToTopicAsync("Bienvenido");
        this.Status.Text = "Ahora estas suscrito";
        await DisplayAlert("Bienvenido", "Te has suscrito al tema de Bienvenido", "OK");
    }
    private async void OnUnSubscribeClicked(object sender, EventArgs e)
    {
        await CrossFirebaseCloudMessaging.Current.UnsubscribeFromTopicAsync("Bienvenido");
        this.Status.Text = "Ya no estas suscrito";
        await DisplayAlert("Bienvenido", "Te has dado de baja del tema de Bienvenido", "OK");
    }
```

En el código anterior creamos los eventos que ocurren al presionar los botones, puedes ver que se usa la librería de Firebase para suscribirse al tópico para escuchar los mensajes, también observamos que en ningún momento estamos creando algún código para gestionar notificación, todo esto fue lo que sé en los archivos dentro de Android debido a que este ocurre en segundo plano.

**¡Felicitaciones!** Has terminado de crear una aplicación Android con la capacidad de recibir notificaciones, si corremos la aplicación veremos algo similar a lo siguiente:

Para probar las notificaciones push **debes hacerlo en un dispositivo físico real**. En emulador nunca va a funcionar (Algunos dicen que si instalas Google Play las notificaciones push funcionarán en el emulador, pero yo en lo personal nunca hice la prueba).

![Aplicación Android](https://programemos.net/images/notificacion_android-png.webp)

_Aplicación Android_

## Creamos el Servidor para el envío de Notificaciones Push

Estamos listo para recibir las notificaciones en nuestra aplicación Android, ahora es hora de crear una API que nos permita enviar los mensajes. Será bastante sencillo, simplemente tendrá un endpoint que usaremos para enviar las notificaciones. Lo primero que necesitamos es agregar un proyecto de Azure Functions a nuestra solución. En nuestro caso lo llamaremos _NotificationsPush.Server_. En este caso usamos NET 7.

![Azure Function Proyecto](https://programemos.net/images/proyecto_server-png.webp)

_Azure Function Proyecto_

Lo primero que vamos a hacer es instalar NuGet requerido para trabajar con el SDK de Firebase llamado _«FirebaseAdmin»_. En este ejemplo vamos a usar la versión 2.3.0.

![Nuget FirebaseAdmin](https://programemos.net/images/nuget_firebaseadmin-1024x385-png.webp)

_Nuget FirebaseAdmin_

Ahora debemos hacer es configurar nuestra aplicación con el archivo generado al crear las llaves en Firebase y descargamos previamente, Esta configuración lo vamos a hacer en _«Program.cs»._ El SDK nos da varias opciones para su configuración usando el archivo JSON previamente descargado.

Por simplificar vamos a colocar las configuraciones directamente en código (Esto es una mala práctica, pero lo hago para mantener el ejemplo simple). Los datos mostrados en las configuraciones fueron modificados y no son reales, solo los dejos de referencia. Debe reemplazar los datos con la configuración del archivo JSON descargado en la configuración de llaves para SDK.

```csharp
using FirebaseAdmin;
using Google.Apis.Auth.OAuth2;
using Microsoft.Extensions.Hosting;
var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .Build();
string jsonData = @"{
                  'type': 'service_account',
                  'project_id': 'message-push-195b5',
                  'private_key_id': '7673e1b3e4aa63aacdef2a2a83a59c4d92c40a33',
                  'private_key': '-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDnl00iNzSwJjkk\nibYzeUP6t67Q316raLXD8wQs7ovev+aW0s8E3e77HWxZUKD5wIvJRsIWCEUkfA72\n2g+smPNMq+X/AKR2Q7zPxqCWR6BrHCyA4unGDmVF1vDCEGM7q2M4IDNkHuEkl4Ig\nwcPIldrRD3Hz01K8JwZ6FOFOMJpFUM9uT8ZHa5WBpzyWVN15WHGDpTTiGq1IRw2W\n9irtzdlxTNKAriQ2nyus5AMGlvEF1V984IZbcSNQTvTpg37c2reBI4FwTULRP6bs\ncQo1vcQjDBXdat9b71/+wg==\n-----END PRIVATE KEY-----\n',
                  'client_email': 'firebase-adminsdk-bpkgb@message-push-195b5.iam.gserviceaccount.com',
                  'client_id': '888879189536215730976',
                  'auth_uri': 'https://accounts.google.com/o/oauth2/auth',
                  'token_uri': 'https://oauth2.googleapis.com/token',
                  'auth_provider_x509_cert_url': 'https://www.googleapis.com/oauth2/v1/certs',
                  'client_x509_cert_url': 'https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-bpkgb%40message-push-195b5.iam.gserviceaccount.com'
                }";
if (FirebaseApp.DefaultInstance == null)
{
    FirebaseApp.Create(new AppOptions()
    {
        Credential = GoogleCredential.FromJson(jsonData)
    });
}
host.Run();
```

Lo que hacemos en código anterior es carga la configuración requerida por el SDK de Firebase y la establecemos sin aún no existe una configuración anterior, ahora creamos un nuevo archivo llamado _«Notifications.cs»_ donde colocaremos la función que será el endpoint que usaremos para enviar mensajes. Luego reemplazamos su contenido con el siguiente.

```csharp
namespace NotificationsPush.Server;
using System.Net;
using FirebaseAdmin.Messaging;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
public class NotificationMessage
{
    public string Message { get; set; }
}
public class Notifications
{
    private readonly ILogger logger;
    public Notifications(ILoggerFactory loggerFactory)
    {
        this.logger = loggerFactory.CreateLogger<Notifications>();
    }
    [Function("SendNotifications")]
    public async Task<HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = "notificaciones")] HttpRequestData req)
    {
        this.logger.LogInformation("Preparando el envio del mensaje...");
        StreamReader sr = new(req.Body);
        var notificationMessage = JsonConvert.DeserializeObject<NotificationMessage>(sr.ReadToEnd());
        var message = new Message()
        {
            Topic = "Bienvenido",
            Notification = new Notification()
            {
                Title = "Bienvenido",
                Body = notificationMessage.Message ?? "Bienvenido usuario",
            }
        };
        string result = await FirebaseMessaging.DefaultInstance.SendAsync(message);
        this.logger.LogInformation($"Respuesta: {result}");
        var response = req.CreateResponse(HttpStatusCode.OK);
        response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
        response.WriteString("Mensaje enviado");
        return response;
    }
}
```

El código anterior crea un endpoint que recibe un campo llamado «Message» donde establecemos el mensaje de texto que deseamos enviar a nuestro usuario, el SDK nos permite varias maneras de segmentar a cuáles usuarios llegara el mensaje. Nosotros lo vamos a hacer el tópico llamado **Bienvenido** (línea 64).

¡**Felicitaciones!** Has creado un servidor para envío de notificaciones push a cliente Android. Esto es el ejemplo básico, pero puedes personalizarlo de la manera que desees o necesites. Ahora es momento de probar todo junto.

## Momentos de probar nuestro flujo de notificaciones push

Debemos pasar nuestra aplicación MAUI a nuestro celular. Hay varias maneras, la más fácil es activar el modo desarrollador de Android y usar el cable USB para depurar la aplicación desde Visual Studio en nuestro teléfono.

Cuando la aplicación esté corriendo en el móvil debemos presionar sobre el botón de suscribirse.

![Aplicación Android](https://programemos.net/images/notificacion_android-png.webp)

_Aplicación Android_

Ahora ejecutamos la aplicación servidor que es nuestra API para envío de mensajes.

![Aplicación Servidor Ejecutando](https://programemos.net/images/notificaciones_server_ejecutando-png.webp)

_Aplicación Servidor Ejecutando_

Ahora debemos un enviar una solicitud a nuestro servidor. La opción más fácil es usar Postman. Debemos comprobar que en la consola nos muestre que el mensaje se envió correctamente.

![Enviar Mensaje con Postman al Servidor](https://programemos.net/images/notificaciones_postman-1024x309-png.webp)

_Enviar Mensaje con Postman al Servidor_

Ahora verificamos en nuestro teléfono que el mensaje fue recibido.

![Notificación Recibida en el Móvil](https://programemos.net/images/notificacion_recibida-461x1024-jpg.webp)

_Notificación Recibida en el Móvil_

¡**Felicitaciones!** Creaste un flujo de envío y recepción de notificaciones push, usando Firebase, Azure Function, MAUI. Esto es la base, de aquí en adelante puedes agregar y personalizar todo lo que necesites, por ejemplo agregar una imagen para se vea más agradable el mensaje, ejecutar una acción al hacer clic sobre la notificación push, entre muchas otras cosas.

## Conclusión

El uso de notificaciones push es algo fundamental en toda aplicaciones móvil, nos permiten mantener una comunicación con los usuarios, además es una gran herramienta de negocio si se usa correctamente, los servicios y herramientas que vimos permiten una implementar sencilla de esto, permitiéndonos concentrarnos en lo que más importa; nuestra aplicación y nuestros usuarios.

Recuerda que tienes el código completo de la Azure Function y de la aplicación MAUI dentro del propio artículo. Te invito a ver mis otras [publicaciones](https://programemos.net).

---
