shared images fix

content/posts/2024-07-10-deploy-blazor-azure-app-services.es.md

@@ -0,0 +1,153 @@
+---
+layout: post
+title: "Despliegue de aplicaciones Blazor en Azure App Services"
+author: Christian Amado
+date: 2024-07-10 00:00:00 -0400
+category: [Desarrollo de software]
+tags: [Web Development,Blazor,.NET]
+thumbnail-img: /img/posts/thumbnails/dotnet.png
+cover-img: /img/posts/cover/dotnet.png
+share_img: /img/posts/shared/dotnet.jpg
+---
+
+**Blazor**, el framework moderno basado en **.NET**, permite a los desarrolladores crear aplicaciones web interactivas utilizando **C#**. Combinado con **Azure App Services**, puedes desplegar aplicaciones de manera sencilla, escalable y segura. En este artículo, exploraremos los pasos para desplegar aplicaciones **Blazor (Server y WebAssembly)** en **Azure App Services**, acompañado de ejemplos detallados y buenas prácticas para garantizar un despliegue óptimo.
+
+<!--more-->
+
+## ¿Qué es Azure App Services?
+
+**Azure App Services** es una plataforma de alojamiento en la nube totalmente administrada que soporta aplicaciones web, móviles y *API*. Sus principales características incluyen:
+
+1. **Despliegue rápido**: Permite subir aplicaciones directamente desde tu entorno de desarrollo.
+2. **Escalabilidad**: Ajusta los recursos según la demanda.
+3. **Seguridad**: Ofrece integración con certificados SSL y autenticación.
+4. **Compatibilidad con varias tecnologías**: Soporta .NET, Node.js, Python, Java y más.
+
+
+## Crear y configurar un Azure App Service
+
+### Paso 1: Crear un recurso en Azure
+
+1. Inicia sesión en el [portal de Azure](https://portal.azure.com).
+2. Selecciona **Crear un recurso** y busca **App Service**.
+3. Completa los detalles:
+   - **Nombre**: `blazor-app-service`.
+   - **Pila de runtime**: .NET 9.
+   - **Sistema operativo**: Windows o Linux.
+   - **Plan de App Service**: Selecciona un plan según tus necesidades (recomendado: Plan de consumo para pruebas o B1 para producción).
+
+### Paso 2: Configurar el entorno de despliegue
+
+1. Habilita la autenticación si es necesario.
+2. Configura las variables de entorno requeridas por la aplicación.
+
+## Despliegue de Blazor Server en Azure App Services
+
+### Paso 1: Crear una aplicación Blazor Server
+
+1. Genera un nuevo proyecto Blazor Server:
+   ```
+   dotnet new blazorserver -o BlazorServerApp
+   ```
+2. Navega al directorio del proyecto:
+   ```
+   cd BlazorServerApp
+   ```
+3. Ejecuta la aplicación localmente:
+   ```
+   dotnet run
+   ```
+
+### Paso 2: Publicar la aplicación
+
+1. Publica la aplicación:
+   ```
+   dotnet publish -c Release -o ./publish
+   ```
+2. Verifica los archivos generados en el directorio `publish`.
+
+### Paso 3: Desplegar a Azure
+
+1. Usa el CLI de Azure para iniciar sesión:
+   ```
+   az login
+   ```
+2. Despliega la aplicación:
+   ```
+   az webapp deploy --resource-group MyResourceGroup --name blazor-app-service --src-path ./publish
+   ```
+
+
+## Despliegue de Blazor WebAssembly en Azure App Services
+
+### Paso 1: Crear una aplicación Blazor WebAssembly
+
+1. Genera un nuevo proyecto:
+   ```
+   dotnet new blazorwasm -o BlazorWebAssemblyApp
+   ```
+2. Habilita el modo PWA si es necesario:
+   ```
+   dotnet new blazorwasm -o BlazorPWA --pwa
+   ```
+3. Ejecuta la aplicación localmente:
+   ```
+   dotnet run
+   ```
+
+### Paso 2: Publicar la aplicación
+
+1. Publica la aplicación:
+   ```
+   dotnet publish -c Release -o ./publish
+   ```
+
+### Paso 3: Configurar y desplegar
+
+1. Asegúrate de que el servidor web esté configurado para servir contenido estático desde el directorio `wwwroot`.
+2. Usa Azure CLI o el portal de Azure para subir los archivos.
+
+#### Subir archivos usando Azure Storage
+
+1. Crea una cuenta de almacenamiento:
+   ```
+   az storage account create --name mystorageaccount --resource-group MyResourceGroup --location eastus --sku Standard_LRS
+   ```
+2. Usa `azcopy` para subir los archivos:
+   ```
+   azcopy copy ./publish/wwwroot https://mystorageaccount.blob.core.windows.net/$web --recursive
+   ```
+
+
+## Buenas prácticas para despliegues en Azure App Services
+
+1. **Configurar entornos**:
+   - Usa `appsettings.json` para gestionar configuraciones por entorno.
+2. **Escalabilidad**:
+   - Configura escalado automático para manejar incrementos de tráfico.
+3. **Seguridad**:
+   - Habilita HTTPS y usa certificados SSL.
+4. **Monitorización**:
+   - Usa Application Insights para supervisar el rendimiento.
+5. **Optimizar el tamaño de la aplicación**:
+   - Habilita compresión y minimización de archivos.
+
+
+## Resolución de problemas comunes
+
+### Error 500: "Internal Server Error"
+- **Causa**: Configuraciones incorrectas en `appsettings.json`.
+- **Solución**: Verifica las rutas y las claves de configuración.
+
+### "Failed to Start" en Blazor Server
+- **Causa**: Problemas de dependencias no satisfechas.
+- **Solución**: Revisa las dependencias en el archivo `csproj`.
+
+### Archivos estáticos no encontrados en Blazor WebAssembly
+- **Causa**: Configuración errónea del servidor.
+- **Solución**: Asegúrate de que el servidor apunte al directorio `wwwroot`.
+
+
+## Conclusión
+
+Desplegar aplicaciones **Blazor** en **Azure App Services** es un proceso directo que se beneficia de las capacidades robustas de Azure para escalar, monitorear y proteger aplicaciones. Siguiendo las mejores prácticas y resolviendo problemas comunes, puedes garantizar un despliegue exitoso y mantener tus aplicaciones funcionando de manera eficiente. ¡Explora **Azure App Services** y lleva tus aplicaciones **Blazor** al siguiente nivel!

content/posts/2024-07-24-microservices-deno-azure.es.md

@@ -0,0 +1,160 @@
+---
+layout: post
+title: "Creación de microservicios con Deno y Azure Functions"
+author: Christian Amado
+date: 2024-07-24 00:00:00 -0400
+category: [Desarrollo de software]
+tags: [Web Development,Deno,Azure]
+thumbnail-img: /img/posts/thumbnails/deno.png
+cover-img: /img/posts/cover/deno.png
+share_img: /img/posts/shared/deno.jpg
+---
+
+En el mundo moderno del desarrollo de software, los microservicios han revolucionado la forma de construir y desplegar aplicaciones escalables. Al combinar **Deno**, una plataforma de runtime moderna basada en **JavaScript** y **TypeScript**, con **Azure Functions**, una solución serverless flexible de **Microsoft**, los desarrolladores pueden crear microservicios rápidos, seguros y eficientes. Este artículo te guiará paso a paso en el proceso de crear microservicios utilizando estas tecnologías, destacando buenas prácticas, ejemplos prácticos y el uso de **Visual Studio Code** como herramienta principal.
+
+<!--more-->
+
+## Introducción a los microservicios
+
+### ¿Qué son los microservicios?
+
+Los microservicios son un estilo arquitectónico que divide las aplicaciones en servicios independientes, cada uno responsable de una funcionalidad específica. Estos servicios se comunican entre sí mediante protocolos ligeros como **HTTP** o **gRPC**.
+
+### Beneficios de los microservicios
+
+1. **Escalabilidad independiente**: Cada microservicio puede escalarse según sus necesidades.
+2. **Facilidad de despliegue**: Permite actualizar y desplegar partes de la aplicación sin afectar al sistema completo.
+3. **Mantenibilidad**: Facilita la organización del código y la colaboración en equipos grandes.
+
+
+## Introducción a Deno y Azure Functions
+
+### ¿Qué es Deno?
+
+Deno es un runtime para JavaScript y TypeScript creado por Ryan Dahl, el creador de Node.js. Algunas de sus principales características incluyen:
+
+- **Seguridad**: Permisos de ejecución para controlar el acceso a archivos, redes y entornos.
+- **Soporte nativo de TypeScript**.
+- **Gestor de dependencias integrado**: No requiere archivos como `package.json`.
+- **APIs modernas**: Inspiradas en las especificaciones del navegador.
+
+### ¿Qué es Azure Functions?
+
+Azure Functions es un servicio serverless que permite ejecutar código en la nube sin necesidad de gestionar infraestructura. Ofrece:
+
+- **Ejecución bajo demanda**: Facturación basada en el tiempo de ejecución.
+- **Integraciones nativas**: Con Azure Blob Storage, Cosmos DB y otros servicios.
+- **Compatibilidad con varios lenguajes**: Como JavaScript, Python, C# y TypeScript.
+
+
+## Configuración del entorno
+
+### Requisitos previos
+
+1. **Instalar Deno**:
+   ```
+   curl -fsSL https://deno.land/x/install/install.sh | sh
+   ```
+2. **Instalar Azure Functions Core Tools**:
+   ```
+   npm install -g azure-functions-core-tools@4 --unsafe-perm true
+   ```
+3. **Instalar Visual Studio Code**.
+4. **Configurar la extensión de Azure Functions en VS Code**.
+
+### Crear un nuevo proyecto con Azure Functions
+
+1. Crea un directorio para tu proyecto:
+   ```
+   mkdir microservices-deno
+   cd microservices-deno
+   ```
+2. Inicializa un nuevo proyecto:
+   ```
+   func init --worker-runtime custom --language typescript
+   ```
+3. Agrega una nueva función HTTP:
+   ```
+   func new --template "HTTP trigger" --name MyMicroservice
+   ```
+
+## Crear un microservicio con Deno y Azure Functions
+
+### Configuración inicial
+
+1. Modifica el archivo `MyMicroservice/index.ts` para usar Deno:
+   ```
+   import { serve } from "https://deno.land/[email protected]/http/server.ts";
+
+   serve(async (req) => {
+       const url = new URL(req.url);
+       if (url.pathname === "/api/MyMicroservice") {
+           return new Response("Hello from Deno and Azure Functions!", {
+               status: 200,
+               headers: { "Content-Type": "text/plain" },
+           });
+       }
+       return new Response("Not Found", { status: 404 });
+   });
+   ```
+
+2. Configura los permisos necesarios en el archivo `deno.json`:
+   ```
+   {
+       "tasks": {
+           "start": "deno run --allow-net index.ts"
+       }
+   }
+   ```
+
+### Probar el microservicio localmente
+
+1. Ejecuta la función localmente:
+   ```
+   func start
+   ```
+2. Accede a la URL generada, como `http://localhost:7071/api/MyMicroservice`.
+
+## Despliegue en Azure
+
+### Paso 1: Inicia sesión en Azure
+```
+az login
+```
+
+### Paso 2: Crear un recurso de Azure Functions
+
+```
+az functionapp create --resource-group MyResourceGroup --consumption-plan-location eastus --runtime custom --functions-version 4 --name MyDenoFunctionApp --storage-account MyStorageAccount
+```
+
+### Paso 3: Desplegar la función
+
+1. Publica tu función:
+   ```bash
+   func azure functionapp publish MyDenoFunctionApp
+   ```
+2. Verifica que tu función esté activa visitando la URL proporcionada por Azure.
+
+## Buenas prácticas
+
+1. **Seguridad**:
+   - Limita los permisos en Deno para garantizar la seguridad.
+   - Usa claves de API o tokens para proteger los endpoints.
+
+2. **Estructura del proyecto**:
+   - Organiza los microservicios en carpetas independientes para facilitar el mantenimiento.
+
+3. **Pruebas unitarias**:
+   - Usa bibliotecas como `deno test` para escribir pruebas y asegurar la calidad del código.
+
+4. **Monitorización**:
+   - Configura Azure Monitor para supervisar el rendimiento y detectar errores.
+
+5. **Optimizar la ejecución**:
+   - Minimiza las dependencias externas y cachea resultados frecuentes.
+
+
+## Conclusión
+
+La combinación de **Deno** y **Azure Functions** ofrece una solución moderna y eficiente para construir microservicios escalables y seguros. Con las herramientas adecuadas, como **Visual Studio Code**, y siguiendo buenas prácticas, puedes maximizar el potencial de tus proyectos serverless. Empieza hoy mismo a explorar estas tecnologías y lleva tus microservicios al siguiente nivel.