DEV Community: Dante C. Lobato

Estamos construyendo el internet del pasado (y no lo sabemos)

Dante C. Lobato — Fri, 20 Mar 2026 22:51:24 +0000

El otro día estaba platicando con un amigo - esos ratos en la oficina, cuando todo urge pero nada avanza - y nos pusimos a divagar sobre cómo se vería internet dentro de cinco, diez años. Y de repente, me di cuenta de algo que suena a herejía pero que cada vez veo más cerca: estamos construyendo el internet del pasado, y ni siquiera lo sabemos.

Hablemos claro. ¿Cuándo fue la última vez que entraste a la pagina web de tu abogado o tu barbero por gusto? ¿Que abriste una tienda de Shopify, un WooCommerce o una Tiendanube porque sí, sin que Google te obligara a pasar por ahí para encontrar una respuesta? A mí me está pasando cada vez menos. Y no soy el único.

Veo el tráfico cayendo en sitios que antes eran inamovibles. StackOverflow ya lo vivió: la gente prefiere preguntarle a ChatGPT antes que navegar por threads de 2012 con screenshots borrosos. Y eso - eso - es solo el principio. Perplexity ya navega por ti. Los navegadores de OpenAI integran la IA directamente. Grok, Gemini, Claude... todos quieren ser la puerta de entrada, no el pasillo por donde caminas.

El hábito está cambiando, y cuando el hábito cambia, la arquitectura debe cambiar con él.

Pensé en mi propio blog. En mi trabajo. En ese ecommerce que alguien está construyendo ahora mismo con PrestaShop, pensando en breakpoints mobile y en que el botón de compra sea del color exacto que convierte. Y me dio escalofríos pensar: ¿Y si estamos optimizando para el usuario equivocado?

Porque mira, yo creo - y aquí me pongo un poco conspiranoico pero espero que conmigo - que la siguiente evolución no es hacer webs más bonitas, más rápidas, más adaptadas a móvil. Eso ya es el pasado. La próxima generación de internet será para inteligencias artificiales, no para humanos.

Suena raro, ¿no? Pero piénsalo. Si mañana la gente prefiere decirle a su asistente "comprame unos tenis para correr, talla 9, que cuesten menos de mil pesos y sean buenos para asfalto" en lugar de abrir Amazon o Mercado Libre y filtrar 47 opciones... ¿para quién estamos haciendo la interfaz gráfica? ¿Para quién escribimos el copy persuasivo de la página de inicio?

Yo creo que ya no hay vuelta atrás. Y no digo que vayamos a desaparecer - Amazon no va a cerrar mañana, ni tu blog favorito se evaporará. Pero el tráfico, esa atención escurridiza que tanto nos cuesta captar, se va a mover. De los buscadores a los LLMs. De las pantallas a los prompts.

Entonces, ¿qué hacemos? ¿Nos cruzamos de brazos?

No. Preparamos el terreno.

Yo veo el futuro así: dejaremos de hablar de "experiencia de usuario" (UX) para empezar a hablar de "experiencia de máquina" (MX, si quieres ponerle nombre cool). Ya no será tanto sobre cómo se ve tu sitio, sino sobre cómo tu contenido se consume. APIs limpias, datos estructurados que las IAs puedan entender sin tener que scrapear tu HTML como si fuera 1999, estándares nuevos que alguien más inteligente que yo inventará pronto para que los agentes de IA puedan "comprar" en tu tienda, "leer" tu artículo, "citar" tu investigación, sin que un humano pase siquiera por tu URL.

Es como cuando pasamos de tener carpetas físicas a tener bases de datos. O de las páginas estáticas a las dinámicas. Es otro salto.

Amazon tendrá que adaptarse. Mercado Libre. Tu blog de cocina. Mi sitio. Los diarios. Todos. Porque el negocio ya no será "traer gente a mi terreno", sino "estar presente donde la gente ya está conversando con su IA de confianza".

Y mira, no quiero sonar apocalíptico. No hay que tener miedo. Pero sí hay que dejar de pintar paredes en un edificio que se está mudando de dirección.

Así que estoy pensando en empezar a construir diferente. No sé exactamente cómo se ve aún - estoy explorando, como todos - pero sé que implica dejarnos de obsesiones con el pixel perfect y empezar a pensar en estándares, en accesibilidad máquina-máquina, en ser relevantes no solo cuando alguien hace clic, sino cuando alguien pregunta.

El internet no se acaba. Solo crece una piel nueva. Y yo quiero estar ahí cuando la IA sea quien navegue por nosotros, no al revés.

¿Tú qué piensas? ¿Ya te está pasando que prefieres preguntarle a Claude o a ChatGPT antes que googlear? Me leo en los comentarios.

HPSR Proxy Stack: Tu Propio Servidor Proxy HTTPS con Docker, Squid y Certificados SSL Válidos

Dante C. Lobato — Mon, 10 Nov 2025 00:37:21 +0000

HPSR Proxy Stack es una solución open-source que convierte cualquier VPS en un servidor proxy HTTPS profesional con certificados SSL válidos de Let's Encrypt, autenticación HTTP Basic y cifrado TLS 1.2+. Todo automatizado con Docker y listo en menos de 10 minutos.

¿Qué es HPSR Proxy Stack?

Es un stack completo basado en Docker que combina las mejores herramientas open-source:

Squid Proxy: El servidor proxy HTTP/HTTPS más robusto y confiable
Stunnel: Túnel SSL/TLS para cifrado end-to-end con certificados válidos
Let's Encrypt: Certificados SSL gratuitos reconocidos por todos los navegadores
Dante SOCKS5: Servidor SOCKS5 opcional para casos de uso avanzados
Docker Compose: Orquestación simple de todos los servicios

Todo preconfigurado con scripts de instalación automatizados y listo para producción.

¿Por Qué Necesitas tu Propio Proxy?

1. Privacidad y Control Total

Los proxies comerciales registran y venden tu información. Con tu propio servidor, tú controlas 100% de tus datos, logs y políticas de acceso.

2. Evitar Restricciones y Censura

Redes corporativas, universidades y algunos países bloquean sitios web. Un proxy HTTPS en puerto 443 con certificado SSL válido es prácticamente imposible de bloquear porque parece tráfico HTTPS normal.

3. Seguridad en Redes Públicas

En cafeterías, aeropuertos y hoteles, tu tráfico viaja cifrado con TLS desde tu dispositivo hasta tu VPS, protegiéndote completamente de ataques man-in-the-middle.

4. IP Estable para Desarrollo

Web scraping sin límites de rate limiting
Testing de APIs desde IP confiable
Automatización sin bloqueos
IP fija para whitelisting en servicios

5. Costo-Beneficio Superior

Por $100-200/mes tienes ancho de banda ilimitado, mientras que servicios comerciales cobran $1000-10000/mes con límites restrictivos.

Por Qué el Puerto 443 es Clave

El puerto 443 es el estándar mundial para HTTPS. Bloquearlo significaría:

❌ Sin acceso a banca online
❌ Sin compras en Amazon
❌ Sin Gmail o Office 365
❌ Sin WhatsApp Web
❌ Sin redes sociales

Por eso tu proxy es imposible de detectar o bloquear - aparece como tráfico HTTPS legítimo con certificado válido.

Casos de Uso Reales

Para Desarrolladores

# Testing de APIs con IP estable
curl --proxy https://user:pass@proxy.tudominio.com:443 \
     https://api.ejemplo.com/v1/endpoint

# Web scraping con Python
import requests
proxies = {
    'http': 'https://user:pass@proxy.tudominio.com:443',
    'https': 'https://user:pass@proxy.tudominio.com:443'
}
response = requests.get('https://ejemplo.com', proxies=proxies)

Para Equipos Remotos

Control centralizado del tráfico corporativo
IP fija para servicios que requieren whitelist
Auditoría de accesos (opcional)
Sin licencias por usuario

Para Freelancers y Nómadas Digitales

Trabajar seguro desde cualquier WiFi público
Acceder a recursos geo-restringidos
Mantener la misma IP sin importar ubicación
Protección contra espionaje en redes comprometidas

Arquitectura Técnica

HPSR Proxy Stack usa una arquitectura en capas para máxima seguridad:

┌─────────────┐    HTTPS:443    ┌──────────┐    HTTP:3128    ┌───────┐
│  Navegador  │ ───────────────► │ Stunnel  │ ──────────────► │ Squid │ ──► Internet
│   Cliente   │  Certificado SSL  │   TLS    │    Internal    │ Proxy │
└─────────────┘    Let's Encrypt └──────────┘                 └───────┘

Flujo de conexión:

Cliente se conecta al puerto 443 (HTTPS estándar)
Stunnel presenta certificado SSL válido de Let's Encrypt
Stunnel descifra TLS y reenvía a Squid (interno)
Squid valida credenciales HTTP Basic
Squid procesa la petición y la envía a Internet
Respuesta regresa cifrada al cliente

Ventajas de esta arquitectura:

✅ Certificados SSL reconocidos universalmente
✅ Puerto 443 estándar (imposible de bloquear)
✅ Compatible con todos los navegadores nativamente
✅ Sin necesidad de software cliente especial
✅ Renovación automática de certificados cada 90 días

Requisitos del Sistema

Opción 1: VPS en la Nube (Recomendado)

Especificaciones mínimas:

CPU: 1 vCore
RAM: 512 MB (1 GB recomendado para mejor rendimiento)
Almacenamiento: 10 GB SSD
Ancho de banda: Idealmente ilimitado (mínimo 1TB/mes)
Sistema operativo: Ubuntu 22.04/24.04 LTS o Debian 11/12
Puertos necesarios: 80 (Let's Encrypt), 443 (proxy)

IONOS.mx - Recomendación Especial

Si estás en México o Latinoamérica, IONOS.mx ofrece:

Servidores en México (menor latencia)
Soporte técnico en español 24/7
Facturación en pesos mexicanos con RFC
Tráfico generoso incluido
Panel de control en español

Obtén tu VPS en IONOS.mx →

Proveedores recomendados:

Hetzner Cloud - Desde €4.51/mes - 20TB tráfico incluido
DigitalOcean - Desde $6/mes - Interface simple
Vultr - Desde $5/mes - 25+ ubicaciones globales
Oracle Cloud - Tier gratuito perpetuo disponible

Opción 2: Homelab (Avanzado)

Requisitos para servidor casero:

IP pública estática o DDNS configurado
Puertos 80 y 443 abiertos en router/firewall
Conexión estable con UPS recomendado
Upload mínimo 10 Mbps (50+ ideal)
Uptime 99%+ para uso confiable

Software Prerequisito

Obligatorio antes de instalar:

Docker y Docker Compose - Sigue mi guía completa de Docker en Ubuntu
Dominio propio - Desde $1/año (Namecheap, Cloudflare, Porkbun)
Acceso root/sudo al servidor vía SSH

Instalación Completa Paso a Paso

Paso 1: Preparar el Servidor

Si no tienes Docker instalado, primero sigue mi guía de Docker en Ubuntu 24.04. Es prerequisito obligatorio.

Paso 2: Configurar DNS

En tu proveedor de dominios, crea un registro A:

Tipo: A
Nombre: proxy (o cualquier subdominio)
Valor: IP_DE_TU_VPS
TTL: 300 (5 minutos para cambios rápidos)

Ejemplos de dominios válidos:

proxy.tuempresa.com
secure.tudominio.net
gateway.ejemplo.dev
vpn.tunombre.io

Verifica que resuelve correctamente:

dig +short proxy.tudominio.com
# Debe mostrar la IP de tu VPS

Paso 3: Instalar HPSR Proxy Stack

# Clonar el repositorio
git clone https://github.com/hopsersmerk/hpsr-proxy-stack.git
cd hpsr-proxy-stack

# Ejecutar script de configuración SSL
sudo bash setup-ssl.sh

# El script te pedirá:
# 1. Tu dominio completo (ej: proxy.tudominio.com)
# 2. Automáticamente:
#    - Verificará DNS
#    - Obtendrá certificado SSL de Let's Encrypt
#    - Configurará stunnel con TLS 1.2+
#    - Creará credenciales por defecto
#    - Configurará renovación automática

# Iniciar todos los servicios
docker compose up -d

# Verificar que todo está corriendo
docker ps
# Debes ver 4 contenedores: stunnel-https, squid-proxy, socks5-proxy, stunnel-socks

Paso 4: Verificar Funcionamiento

# Test desde el servidor
curl --proxy https://proxyuser:changeme123@proxy.tudominio.com:443 \
     https://ifconfig.me

# Respuesta esperada: la IP de tu VPS

# Test con headers HTTP
curl -v --proxy https://proxyuser:changeme123@proxy.tudominio.com:443 \
     https://httpbin.org/headers

Paso 5: Cambiar Credenciales (IMPORTANTE)

Las credenciales por defecto son proxyuser:changeme123. Cámbialas inmediatamente:

# Método automatizado (recomendado)
sudo bash setup-squid-auth.sh
# Te pedirá nuevo usuario y contraseña

# Reiniciar servicios con nuevas credenciales
docker compose restart squid-proxy stunnel-https

Configuración en Navegadores y Aplicaciones

Chrome/Edge con Proxy SwitchyOmega (Recomendado)

Instalar Proxy SwitchyOmega
Click en el ícono → Options
New profile → Nombre: Mi Proxy → Proxy Profile
Configuración del proxy:
- Protocol: HTTPS
- Server: proxy.tudominio.com
- Port: 443
En la sección Authentication:
- Username: tuusuario
- Password: tucontraseña
Apply changes
Activar desde el ícono de la extensión

Firefox con FoxyProxy

Instalar FoxyProxy Standard
Click en el ícono → Options
Add → Manual Proxy Configuration:
- Title: Mi Proxy Seguro
- Type: HTTP (Firefox maneja HTTPS como HTTP)
- Hostname: proxy.tudominio.com
- Port: 443
- Username: tuusuario
- Password: tucontraseña
Save y activar el perfil

Configuración para Terminal/CLI

Variables de entorno (Linux/Mac):

# Agregar a ~/.bashrc o ~/.zshrc
export HTTP_PROXY="https://usuario:contraseña@proxy.tudominio.com:443"
export HTTPS_PROXY="https://usuario:contraseña@proxy.tudominio.com:443"
export NO_PROXY="localhost,127.0.0.1"

# Aplicar cambios
source ~/.bashrc

Para Git:

git config --global http.proxy https://usuario:contraseña@proxy.tudominio.com:443
git config --global https.proxy https://usuario:contraseña@proxy.tudominio.com:443

# Para desactivar
git config --global --unset http.proxy
git config --global --unset https.proxy

Para Docker:

# Crear/editar ~/.docker/config.json
{
  "proxies": {
    "default": {
      "httpProxy": "https://usuario:contraseña@proxy.tudominio.com:443",
      "httpsProxy": "https://usuario:contraseña@proxy.tudominio.com:443"
    }
  }
}

Uso de SOCKS5 (Opcional)

HPSR Proxy Stack también incluye un servidor SOCKS5 (Dante). Para usarlo con túnel SSH:

# Crear túnel SSH (dejar terminal abierta)
ssh -N -L 1080:localhost:1080 usuario@proxy.tudominio.com

# En otra terminal, probar SOCKS5
curl --proxy socks5h://proxyuser:changeme123@localhost:1080 https://ifconfig.me

Configurar en navegador:

Tipo: SOCKS5
Host: localhost
Puerto: 1080
Usuario: proxyuser
Contraseña: changeme123

Solución de Problemas Comunes

Error 407 - Proxy Authentication Required

# Credenciales incorrectas. Solución:
sudo bash setup-squid-auth.sh  # Recrear credenciales
docker compose restart squid-proxy stunnel-https

El proxy no responde

# 1. Verificar firewall
sudo ufw status
sudo ufw allow 443/tcp
sudo ufw allow 80/tcp  # Necesario para Let's Encrypt

# 2. Verificar que el dominio resuelve
dig +short proxy.tudominio.com

# 3. Reiniciar servicios
docker compose down
docker compose up -d

# 4. Ver logs para diagnóstico
docker compose logs -f

Error de certificado SSL

# Verificar certificado
sudo certbot certificates

# Si expiró, renovar manualmente
sudo certbot renew
docker compose restart stunnel-https stunnel-socks

Verificar logs específicos

# Logs de Stunnel (maneja SSL)
docker logs stunnel-https

# Logs de Squid (proxy HTTP)
docker logs squid-proxy

# Logs en tiempo real
docker compose logs -f

Preguntas Frecuentes

¿Es legal tener mi propio proxy?

Absolutamente sí. Es tu servidor, tu conexión. Úsalo responsablemente y respeta las leyes locales y términos de servicio de los sitios web.

¿Cuántos usuarios simultáneos soporta?

VPS básico ($5/mes): 5-10 usuarios navegación normal
VPS 2GB RAM: 20-30 usuarios
VPS 4GB+ RAM: 50+ usuarios
El límite real es el ancho de banda

¿Es más rápido que VPN?

Sí, porque:

No hay overhead de cifrado VPN (solo TLS estándar)
IP dedicada sin compartir recursos
Puedes elegir VPS cerca de tu ubicación
Sin throttling artificial

¿Funciona en móviles?

Sí, compatible con:

iOS: Apps como Shadowrocket, Surge
Android: ProxyDroid, Drony, configuración nativa
Windows/Mac/Linux: Configuración de sistema

¿Qué pasa si bloquean el puerto 443?

Prácticamente imposible. Bloquear 443 = no más Internet seguro. Si sucede (muy raro), puedes cambiar el puerto en docker-compose.yml.

¿Se renueva solo el certificado SSL?

Sí, el script configura un cron job que renueva automáticamente cada 60 días y reinicia los servicios.

Conclusión

HPSR Proxy Stack te da control total sobre tu tráfico web con seguridad empresarial por una fracción del costo de servicios comerciales. Con certificados SSL válidos, cifrado TLS 1.2+, y configuración automatizada, es la solución perfecta para quien valora su privacidad y necesita un proxy confiable.

Lo mejor: es 100% open-source, sin telemetría, sin límites artificiales, y completamente bajo tu control.

¿Necesitas Ayuda Profesional?

Si requieres asistencia Agenda una consultoría conmigo →

Recursos

📦 Repositorio en GitHub - Código fuente y actualizaciones
🐳 Guía de Docker - Prerequisito necesario
🐛 Reportar Issues - Bugs y mejoras
⭐ Dale estrella en GitHub - Apoya el proyecto

Si esta guía te fue útil, compártela con la comunidad. Tu apoyo mantiene el proyecto activo y mejorado.

.NET: La Plataforma Ideal para Microservicios en 2025

Dante C. Lobato — Thu, 07 Aug 2025 22:25:36 +0000

El Renacimiento de .NET

Si todavía piensas que .NET es pesado, lento y exclusivo de Windows, es hora de actualizar tu perspectiva. La transformación que ha experimentado .NET en los últimos años no solo lo ha convertido en una opción viable para microservicios, sino en una de las mejores alternativas disponibles en el mercado actual.

Adiós al Pasado: .NET Core y el Nuevo Paradigma de Rendimiento

La Evolución que Cambió Todo

El punto de inflexión llegó con .NET Core en 2016, y se consolidó con .NET 5+ (ahora simplemente ".NET"). Microsoft reescribió completamente la plataforma desde cero con tres objetivos claros:

Multiplataforma real: Corre nativamente en Linux, macOS y Windows
Optimización extrema: Diseñado para contenedores y la nube
Open Source: Desarrollo transparente con contribuciones de la comunidad

Los Números No Mienten

Los benchmarks de TechEmpower (una de las pruebas de rendimiento más respetadas en la industria) consistentemente posicionan a ASP.NET Core en el top 10 de frameworks más rápidos del mundo, superando a la mayoría de sus competidores directos:

Requests por segundo: ASP.NET Core maneja hasta 7+ millones de requests/segundo en pruebas de plaintext
Latencia: Consistentemente menor que Java Spring Boot y órdenes de magnitud mejor que Node.js
Uso de memoria: Optimizaciones en .NET 8 reducen el consumo hasta un 40% comparado con versiones anteriores

.NET vs Todos los demas

.NET vs Java

Ventajas de .NET sobre Java:

Menor ceremonia: Menos boilerplate code. Con minimal APIs en .NET 8, puedes crear un microservicio completo en menos de 10 líneas
Mejor gestión de memoria: El Garbage Collector de .NET está más optimizado para cargas de trabajo modernas
Async/Await nativo: Programación asíncrona más elegante y eficiente que el modelo de Java
Tiempo de inicio más rápido: Con Native AOT, .NET puede compilar a código nativo con tiempos de inicio de ~10ms

Ejemplo práctico:

// Microservicio completo en .NET 8
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/api/products", async (ProductDb db) => 
    await db.Products.ToListAsync());

app.Run();

Intenta hacer algo equivalente en Spring Boot con la misma simplicidad.

.NET vs Node.js (JavaScript/TypeScript)

Donde .NET supera a Node.js:

Rendimiento crudo: .NET es 2-3x más rápido en operaciones CPU-intensivas
Type Safety real: C# ofrece un sistema de tipos robusto desde el día uno
Multithreading verdadero: .NET maneja threads reales, no solo el event loop de Node
Ecosistema empresarial maduro: Herramientas de debugging, profiling y monitoring superiores
Menor consumo de memoria: Un microservicio .NET típico usa 50-70% menos RAM que su equivalente en Node

.NET vs Go

Áreas donde .NET compite fuertemente con Go:

Productividad del desarrollador: C# es más expresivo y tiene mejor tooling
Ecosistema más rico: NuGet tiene librerías maduras para prácticamente todo
LINQ: Manipulación de datos que Go simplemente no puede igualar
Integración con servicios cloud: Azure SDK es excepcional, y AWS/GCP SDKs son de primera clase

Con Native AOT, .NET ahora ofrece:

Binarios self-contained de ~10-30MB
Tiempos de inicio sub-segundo
Sin dependencia del runtime (similar a Go)

.NET vs Python

Superioridad clara de .NET:

Rendimiento: .NET es 10-50x más rápido que Python en la mayoría de escenarios
Concurrencia real: Threading y async/await verdaderos vs el GIL de Python
Type Safety: Detección de errores en tiempo de compilación
Escalabilidad: Python simplemente no puede manejar la carga que .NET soporta

Python es excelente para prototipos y data science, pero para microservicios en producción, .NET es objetivamente superior.

Características Killer de .NET para Microservicios

1. gRPC de Primera Clase

.NET tiene el mejor soporte para gRPC de cualquier plataforma mainstream:

// Servicio gRPC en 3 líneas
app.MapGrpcService<GreeterService>();
app.MapGet("/", () => "gRPC service running");
app.Run();

2. Minimal APIs

Crea APIs RESTful con mínimo código y máximo rendimiento:

app.MapPost("/orders", async (Order order, OrderService service) =>
{
    var result = await service.CreateAsync(order);
    return Results.Created($"/orders/{result.Id}", result);
});

3. Native AOT (Ahead-of-Time Compilation)

Compila tu microservicio a código nativo:

Binarios de 10-30MB
Inicio en <50ms
Sin JIT, sin runtime
Perfecto para funciones serverless y contenedores

4. Contenedores Optimizados

Imágenes Docker minúsculas con .NET 8:

FROM mcr.microsoft.com/dotnet/nightly/runtime-deps:8.0-alpine
COPY app /app
ENTRYPOINT ["/app/myservice"]
# Imagen final: ~15MB

5. Observabilidad Integrada

OpenTelemetry, métricas, logs estructurados y health checks vienen incluidos:

builder.Services.AddHealthChecks()
    .AddCheck<DatabaseHealthCheck>("database");

app.MapHealthChecks("/health");

El Ecosistema Cloud-Native de .NET

Kubernetes y .NET: Una Combinación Perfecta

KEDA: Auto-scaling basado en eventos funciona perfectamente con .NET
Dapr: Runtime para microservicios diseñado con .NET en mente
Service Mesh: Integración seamless con Istio, Linkerd
Helm Charts: Templates optimizados para aplicaciones .NET

Herramientas Específicas para Microservicios

MassTransit/NServiceBus: Message brokers empresariales
Polly: Resiliencia y manejo de fallos
Ocelot: API Gateway nativo de .NET
Orleans: Framework de actores para sistemas distribuidos
YARP: Reverse proxy de alto rendimiento

Casos de Éxito Reales

Empresas que han migrado a microservicios .NET con resultados espectaculares:

Stack Overflow: Maneja 5.9 mil millones de page views al año con solo 9 servidores web
Alibaba: Procesa millones de transacciones con .NET Core
UPS: Modernizó su infraestructura crítica con microservicios .NET
Siemens: Redujo costos de infraestructura en 40% migrando a .NET Core

Desarrollo Productivo: La Ventaja Oculta

Hot Reload

Modifica tu código mientras el servicio está corriendo:

dotnet watch run

Herramientas de Primera Clase

Visual Studio/VS Code: IDEs gratuitos y poderosos
Rider: Para los fans de JetBrains
CLI potente: Todo desde la terminal si lo prefieres

Testing Integrado

[Fact]
public async Task GetProducts_ReturnsOkResult()
{
    await using var app = new WebApplicationFactory<Program>();
    var client = app.CreateClient();

    var response = await client.GetAsync("/api/products");

    response.StatusCode.Should().Be(HttpStatusCode.OK);
}

Por Qué .NET en 2025

La Realidad Actual

.NET es más rápido que Java Spring, Node.js y Python para microservicios
Consume menos memoria que prácticamente todas las alternativas mainstream
Inicia más rápido con Native AOT que incluso aplicaciones Go
Es verdaderamente multiplataforma y cloud-native
Tiene mejor tooling y experiencia de desarrollo

El Único "Pero"

Si tu equipo ya domina Go y necesitas lo último en simplicidad minimalista, Go sigue siendo una opción válida. Pero si valoras productividad, ecosistema maduro y rendimiento de clase mundial, .NET es superior.

El Momento es Ahora

Los días de .NET Framework pesado y exclusivo de Windows quedaron en el pasado. El .NET moderno es:

Ligero: Contenedores de 15MB, microservicios que usan 20MB de RAM
Rápido: Top 10 en benchmarks globales de rendimiento
Moderno: Cloud-native, contenedores, Kubernetes, serverless
Productivo: Menos código, mejor tooling, desarrollo más rápido
Gratuito y Open Source: Sin costos de licencia, desarrollo transparente

Si estás evaluando tecnologías para tu próxima arquitectura de microservicios, debes a tu equipo y a tu empresa considerar seriamente .NET. Los números, las características y los casos de éxito hablan por sí mismos.

La pregunta no es "¿Por qué .NET?"

La pregunta es "¿Por qué NO .NET?"

¿Listo para comenzar? Descarga .NET 8 hoy mismo y construye tu primer microservicio en minutos. Tu infraestructura (y tu billetera) te lo agradecerán.

Guía Completa para Instalar y Configurar Docker en Ubuntu 24.04

Dante C. Lobato — Sun, 23 Feb 2025 17:14:51 +0000

Docker es una plataforma de contenedorización que permite empaquetar y distribuir aplicaciones junto con sus dependencias en entornos aislados. Este enfoque garantiza la portabilidad y escalabilidad de los servicios, facilitando el despliegue en distintos sistemas operativos y arquitecturas sin incurrir en problemas de compatibilidad.

Este documento detalla un proceso meticuloso de instalación de Docker en Ubuntu 24.04, optimizado para entornos de desarrollo y producción.

Paso 1: Actualización del Sistema y Dependencias Necesarias

Antes de proceder con la instalación de Docker, es fundamental asegurarse de que el sistema operativo está completamente actualizado. Además, se requieren ciertos paquetes esenciales que facilitarán la autenticación y la gestión de paquetes durante la instalación.

sudo apt-get update && sudo apt-get upgrade -y

sudo apt-get install -y ca-certificates curl gnupg

Estos paquetes incluyen herramientas críticas para descargar e instalar software de fuentes seguras y verificadas.

Paso 2: Configuración del Almacén de Claves GPG

Docker emplea una firma digital para garantizar la integridad y autenticidad de sus paquetes. Para ello, es necesario configurar un directorio específico donde almacenar la clave GPG.

sudo install -m 0755 -d /etc/apt/keyrings

Este paso protege las claves contra accesos no autorizados y asegura su correcta utilización.

Paso 3: Descarga y Configuración de la Clave GPG

El siguiente comando descarga la clave de firma digital de Docker, la convierte al formato adecuado y la almacena en el directorio configurado previamente.

curl -fsSL <https://download.docker.com/linux/ubuntu/gpg> | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Paso 4: Ajuste de Permisos para la Clave

Para permitir el acceso a la clave durante la instalación y futuras actualizaciones, es necesario otorgarle permisos de lectura.

sudo chmod a+r /etc/apt/keyrings/docker.gpg

Este ajuste garantiza que cualquier proceso del sistema pueda acceder a la clave cuando sea necesario.

Paso 5: Configuración del Repositorio Oficial de Docker

Para obtener las versiones más recientes y estables de Docker, se debe añadir su repositorio oficial a la lista de fuentes de paquetes de Ubuntu.

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] <https://download.docker.com/linux/ubuntu> $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Paso 6: Actualización del Índice de Paquetes

Tras agregar el repositorio de Docker, es necesario actualizar el índice de paquetes del sistema para que los cambios surtan efecto.

sudo apt-get update

Paso 7: Instalación de Docker y Componentes Relacionados

La instalación de Docker implica descargar e instalar múltiples paquetes esenciales para su funcionamiento. Esto incluye el motor de Docker, herramientas de gestión de contenedores y soporte para Docker Compose.

sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Paso 8: Inicialización y Configuración del Servicio Docker

Una vez instalado, Docker no se inicia automáticamente. Es necesario activarlo y configurar su ejecución automática en cada arranque del sistema.

sudo systemctl start docker

Para verificar que el servicio está corriendo correctamente:

sudo systemctl status docker

Para garantizar que Docker se inicie en cada reinicio del sistema:

sudo systemctl enable docker

Paso 9: Validación de la Instalación de Docker

Para comprobar que Docker está correctamente instalado y operativo, se recomienda ejecutar un contenedor de prueba. Este comando descargará una imagen básica y mostrará un mensaje de confirmación si todo está en orden.

sudo docker run hello-world

Adicionalmente, para verificar qué contenedores están en ejecución en el sistema:

sudo docker ps

Si la instalación se ha realizado correctamente, el mensaje de confirmación indicará que Docker está listo para ser utilizado.

Paso 10: Configuración de Permisos para Uso sin `sudo` (Recomendado)

Por defecto, los comandos de Docker requieren permisos administrativos. Para permitir su uso sin necesidad de sudo, es posible añadir el usuario actual al grupo de Docker.

sudo usermod -aG docker $USER

Tras realizar este cambio, se recomienda cerrar sesión y volver a iniciarla para aplicar la nueva configuración. Como alternativa, se puede ejecutar:

newgrp docker

Esta configuración facilita el uso de Docker en entornos de desarrollo sin necesidad de conceder permisos de superusuario de manera constante.

Conclusión

Siguiendo estos pasos, Docker quedará completamente configurado y operativo en Ubuntu 24.04. Gracias a su capacidad de aislamiento y despliegue eficiente, se convierte en una herramienta fundamental para desarrolladores y administradores de sistemas que buscan optimizar el proceso de implementación y gestión de aplicaciones en entornos escalables. ¡Empieza a construir tu infraestructura con Docker hoy mismo!

Guía Completa: Instalación y Configuración de NGINX en Ubuntu 24.04

Dante C. Lobato — Thu, 13 Feb 2025 21:39:17 +0000

NGINX es un servidor web y proxy inverso ampliamente utilizado debido a su arquitectura eficiente y su capacidad para gestionar múltiples conexiones simultáneamente con un bajo consumo de recursos. Es una alternativa sólida a servidores tradicionales como Apache, especialmente en entornos que requieren alto rendimiento y escalabilidad.

Para desarrolladores que trabajan con C# y .NET, NGINX es una solución ideal para la implementación de aplicaciones ASP.NET Core en Linux. Su capacidad para manejar solicitudes HTTP, realizar balanceo de carga y optimizar caché, además de su compatibilidad con TLS/SSL, lo convierten en una opción robusta para entornos de producción.

Comparación entre NGINX y Apache

Característica	NGINX	Apache
Modelo de Procesamiento	Basado en eventos (asíncrono)	Basado en procesos (hilos)
Rendimiento	Óptimo para múltiples conexiones concurrentes	Menor rendimiento en tráfico alto
Uso de memoria	Bajo	Alto
Soporte para .NET	Excelente como proxy inverso para ASP.NET Core	Requiere configuración adicional
Configuración	Modular y flexible	Más convencional, basada en archivos
Balanceo de carga	Integrado	Requiere módulos externos
Seguridad	Mayor robustez contra ataques DDoS	Menos eficiente en mitigación
Soporte HTTP/3	Nativo	Requiere módulos adicionales

NGINX es la opción ideal para entornos de alto tráfico y despliegues de aplicaciones modernas en Linux. En esta guía, exploraremos su instalación y configuración en Ubuntu 24.04.

Requisitos Previos

Antes de proceder, verifica lo siguiente:

Ubuntu 24.04 instalado.
Privilegios de sudo para ejecutar comandos administrativos.
Conexión a Internet para descargar los paquetes requeridos.

Paso 1: Actualización del Sistema

Antes de instalar cualquier software, es recomendable actualizar el sistema. Ejecuta:

sudo apt update && sudo apt upgrade -y

Para eliminar paquetes obsoletos y liberar espacio:

sudo apt autoremove -y

Paso 2: Instalación de NGINX

NGINX está disponible en los repositorios oficiales de Ubuntu. Para instalarlo, usa:

sudo apt install nginx -y

Para verificar la versión instalada:

nginx -v

Paso 3: Iniciar y Habilitar NGINX

Para iniciar el servicio:

sudo systemctl start nginx

Para que se ejecute automáticamente al iniciar el sistema:

sudo systemctl enable nginx

Verifica su estado con:

sudo systemctl status nginx

Paso 4: Configuración del Firewall

Si UFW está habilitado, permite el tráfico web con:

sudo ufw allow 'Nginx Full'

Para verificar que se aplicó correctamente:

sudo ufw status

Paso 5: Validación de la Instalación

Para confirmar que NGINX está funcionando, abre un navegador y accede a:

http://tu_direccion_ip

Si estás trabajando en una PC local o en un entorno de desarrollo, usa:

http://localhost

Si todo está configurado correctamente, verás la página de bienvenida de NGINX.

Para conocer la dirección IP del servidor, usa:

ip a | grep inet

Para verificar logs y detectar posibles errores:

sudo journalctl -u nginx --since "1 hour ago"

Paso 6: Administración de NGINX

Algunos comandos útiles:

Reiniciar NGINX:

sudo systemctl restart nginx

Recargar configuración sin interrumpir conexiones:

sudo systemctl reload nginx

Detener el servicio:

sudo systemctl stop nginx

Ver logs de errores:

sudo tail -f /var/log/nginx/error.log

Configuración Avanzada

Opciones adicionales para mejorar el rendimiento y seguridad de NGINX:

Servidores virtuales: Para alojar múltiples aplicaciones en un solo servidor.
Habilitar HTTPS con Let's Encrypt: Protección con cifrado SSL/TLS.
Optimización del rendimiento: Ajustes en /etc/nginx/nginx.conf.
Implementación de proxy inverso: Distribución de tráfico a backend.
Limitación de tráfico: Medidas contra ataques DDoS y fuerza bruta.

Para configuraciones más avanzadas, consulta la documentación oficial de NGINX.

Conclusión

Has instalado y configurado NGINX en Ubuntu 24.04 con éxito. Ahora puedes utilizarlo como servidor web, proxy inverso o balanceador de carga según tus necesidades.

NGINX es una herramienta versátil con una comunidad activa de soporte, ideal para entornos de producción exigentes. Con una configuración adecuada, puedes maximizar su rendimiento y seguridad.

Integración de Tailwind CSS 4.0 en .NET 9: Guía práctica para proyectos MVC

Dante C. Lobato — Mon, 10 Feb 2025 03:38:06 +0000

Introducción

Tailwind CSS es un framework de CSS basado en utilidades diseñado para construir interfaces de usuario modernas con rapidez y eficiencia. La versión 4.0 introduce optimizaciones significativas en rendimiento y nuevas funcionalidades que simplifican el desarrollo front-end.

En esta guía, exploraremos cómo integrar Tailwind CSS 4.0 en un proyecto MVC de .NET 9, utilizando Tailwind CLI para gestionar los estilos de manera eficiente.

Puedes acceder al código fuente completo en GitHub: https://github.com/hopsersmerk/TailwindCSS-NET9-MVC.

Requisitos previos

Antes de comenzar, asegúrate de tener instaladas las siguientes herramientas:

.NET SDK 9 (Descargar .NET SDK)
Node.js y npm (Descargar Node.js)

Paso 1: Creación de un proyecto MVC en .NET 9

Ejecuta los siguientes comandos en la terminal para generar un nuevo proyecto MVC:

mkdir tailwindcss40
cd tailwindcss40
dotnet new mvc

Esto creará una estructura de proyecto basada en MVC dentro de la carpeta tailwindcss40.

Paso 2: Inicialización de npm en el proyecto

Tailwind CSS requiere Node.js y npm para la gestión de dependencias. Dentro del directorio del proyecto, ejecuta:

npm init -y

Esto generará un archivo package.json con la configuración predeterminada de npm.

Paso 3: Instalación de Tailwind CSS

Instala Tailwind CSS y Tailwind CLI ejecutando el siguiente comando:

npm install -D tailwindcss @tailwindcss/cli

Paso 4: Creación del archivo de estilos de Tailwind CSS

Crea la carpeta css dentro de wwwroot:

mkdir wwwroot/css

Dentro de wwwroot/css, crea un archivo llamado tailwind.css e incluye la siguiente línea:

@import "tailwindcss";

Paso 5: Compilación de Tailwind CSS

Para generar los estilos CSS compilados, ejecuta el siguiente comando:

npx @tailwindcss/cli -i ./wwwroot/css/tailwind.css -o ./wwwroot/css/hopsersmerk.css

Este comando procesa el archivo fuente de Tailwind y genera hopsersmerk.css en wwwroot/css/.

Configuración en `package.json`

Para facilitar futuras ejecuciones, agrega estos scripts en package.json:

"scripts": {
  "build:css": "npx @tailwindcss/cli -i ./wwwroot/css/tailwind.css -o ./wwwroot/css/hopsersmerk.css",
  "watch:css": "npx @tailwindcss/cli -i ./wwwroot/css/tailwind.css -o ./wwwroot/css/hopsersmerk.css --watch"
}

Para compilar manualmente:

npm run build:css

Para compilar en modo observador y actualizar automáticamente los cambios:

npm run watch:css

Paso 6: Integración de Tailwind CSS en la plantilla de la aplicación

Abre Views/Shared/_Layout.cshtml y agrega la referencia al CSS compilado dentro del <head>:

<link href="~/css/hopsersmerk.css" rel="stylesheet" />

Esto garantiza que los estilos de Tailwind CSS se apliquen en toda la aplicación.

Paso 7: Verificación de la integración

Modifica Views/Home/Index.cshtml y agrega un encabezado con clases de Tailwind para comprobar que está funcionando:

<h1 class="text-3xl font-bold text-center text-blue-600">¡Tailwind CSS está funcionando!</h1>

Ejecuta el proyecto con:

dotnet run

Luego, abre https://localhost:5001 (o el puerto indicado en la terminal) y verifica que los estilos de Tailwind CSS se apliquen correctamente.

Conclusión

Siguiendo estos pasos, has configurado exitosamente Tailwind CSS 4.0 con Tailwind CLI en un proyecto MVC de .NET 9. Esta configuración optimiza la gestión de estilos y facilita el mantenimiento del código.

Para más información y personalización avanzada, consulta la documentación oficial de Tailwind CSS.