Despliegue de aplicaciones .NET en Azure: guía completa

Introducción

Microsoft Azure ofrece un ecosistema rico y potente para alojar tus aplicaciones .NET. Gracias a la integración nativa entre .NET y Azure, puedes desplegar fácilmente tus aplicaciones y beneficiarte de una escalabilidad automática, una alta disponibilidad y una seguridad reforzada. Esta guía te presenta las distintas opciones de despliegue y las mejores prácticas para optimizar tus aplicaciones .NET en la nube.

Requisitos previos

Antes de empezar, asegúrate de contar con:

• Una cuenta de Azure (puedes crear una cuenta gratuita en azure.microsoft.com)
• El SDK de .NET instalado en tu máquina de desarrollo
• Azure CLI o Azure PowerShell instalado (opcional, pero recomendado)
• Visual Studio 2022 o Visual Studio Code con la extensión de Azure
• Git para el control de versiones

Azure App Service para aplicaciones web .NET

Azure App Service es la solución PaaS (Platform as a Service) ideal para alojar tus aplicaciones web ASP.NET y ASP.NET Core.

Creación de un App Service desde el portal de Azure

1. Inicia sesión en el portal de Azure
2. Haz clic en “Crear un recurso” > “Web” > “App Service”
3. Completa la información básica:
   • Grupo de recursos: crea uno nuevo o utiliza uno existente
   • Nombre de la aplicación: debe ser único en todo Azure
   • Publicar: selecciona “Código”
   • Pila en tiempo de ejecución: elige ”.NET 6” (o la versión que utilices)
   • Sistema operativo: Windows o Linux
   • Región: elige la más cercana a tus usuarios
   • Plan de App Service: selecciona un plan existente o crea uno nuevo
4. Haz clic en “Revisar y crear” y después en “Crear”

Despliegue desde Visual Studio

1. Abre tu solución en Visual Studio
2. Haz clic con el botón derecho en el proyecto web y selecciona “Publicar”
3. Elige “Azure” como destino
4. Selecciona “Azure App Service” y, a continuación, la instancia que acabas de crear
5. Configura los parámetros de despliegue y haz clic en “Publicar”

Despliegue mediante Azure DevOps

# azure-pipelines.yml
trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

variables:
  buildConfiguration: 'Release'
  webAppName: 'votre-app-service'

steps:
- task: UseDotNet@2
  inputs:
    packageType: 'sdk'
    version: '6.x'

- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: true

- task: AzureWebApp@1
  inputs:
    azureSubscription: 'votre-connexion-azure'
    appName: '$(webAppName)'
    package: '$(Build.ArtifactStagingDirectory)/*.zip'

Configuración del entorno

Utiliza los ajustes de la aplicación para configurarla sin necesidad de recompilar:

1. En el portal de Azure, accede a tu App Service
2. En “Configuración” > “Configuración de la aplicación”, añade tus variables de entorno
3. Por ejemplo, para una cadena de conexión a una base de datos:
   • Nombre: ConnectionStrings__DefaultConnection
   • Valor: tu cadena de conexión

Azure Functions para microservicios serverless

Azure Functions permite ejecutar fragmentos de código sin gestionar la infraestructura subyacente.

Creación de una Function App

// Function App simple que responde a las solicitudes HTTP
public static class HttpExample
{
    [FunctionName("HttpExample")]
    public static async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
        ILogger log)
    {
        log.LogInformation("C# HTTP trigger function processed a request.");

        string name = req.Query["name"];
        
        string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
        dynamic data = JsonConvert.DeserializeObject(requestBody);
        name = name ?? data?.name;
        
        string responseMessage = string.IsNullOrEmpty(name)
            ? "Cette fonction HTTP a été exécutée avec succès. Passez un nom dans la requête pour obtenir un message personnalisé."
            : $"Bonjour, {name}. Cette fonction HTTP a été exécutée avec succès.";
            
        return new OkObjectResult(responseMessage);
    }
}

Despliegue de Azure Functions

Desde Visual Studio

1. Crea un proyecto de Azure Functions
2. Desarrolla tus funciones
3. Haz clic con el botón derecho en el proyecto > “Publicar”
4. Elige Azure como destino
5. Selecciona o crea una Function App

Con Azure CLI

# Iniciar sesión en Azure
az login

# Crear un grupo de recursos (si es necesario)
az group create --name MonGroupeDeRessources --location francecentral

# Crear una Function App
az functionapp create --resource-group MonGroupeDeRessources --consumption-plan-location francecentral --runtime dotnet --functions-version 4 --name MonAppDeFonctions --storage-account monstockage

# Desplegar el código
func azure functionapp publish MonAppDeFonctions

Contenerización con Docker y Azure Container Registry

La contenerización de tus aplicaciones .NET ofrece portabilidad y coherencia entre entornos.

Creación de un Dockerfile para ASP.NET Core

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MonApp.csproj", "./"]
RUN dotnet restore "MonApp.csproj"
COPY . .
RUN dotnet build "MonApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MonApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MonApp.dll"]

Creación y uso de Azure Container Registry (ACR)

# Crear un registro de contenedores
az acr create --resource-group MonGroupeDeRessources --name monregistre --sku Basic

# Iniciar sesión en el registro
az acr login --name monregistre

# Construir la imagen de Docker
docker build -t monapp:v1 .

# Etiquetar la imagen para ACR
docker tag monapp:v1 monregistre.azurecr.io/monapp:v1

# Subir la imagen a ACR
docker push monregistre.azurecr.io/monapp:v1

Despliegue en Azure App Service con contenedores

# Habilitar el acceso de administrador para el registro
az acr update -n monregistre --admin-enabled true

# Obtener las credenciales del registro
az acr credential show -n monregistre

# Crear un plan de App Service compatible con contenedores
az appservice plan create --resource-group MonGroupeDeRessources --name MonPlanAppService --is-linux --sku B1

# Crear un App Service que utilice el contenedor
az webapp create --resource-group MonGroupeDeRessources --plan MonPlanAppService --name MonAppWeb --deployment-container-image-name monregistre.azurecr.io/monapp:v1

# Configurar las credenciales del registro
az webapp config container set --name MonAppWeb --resource-group MonGroupeDeRessources --docker-custom-image-name monregistre.azurecr.io/monapp:v1 --docker-registry-server-url https://monregistre.azurecr.io --docker-registry-server-user monregistre --docker-registry-server-password <mot-de-passe>

Azure Kubernetes Service (AKS) para aplicaciones .NET

AKS es ideal para aplicaciones complejas que requieren una orquestación avanzada de contenedores.

Despliegue de una aplicación .NET en AKS

1. Crea un clúster de AKS:

az aks create --resource-group MonGroupeDeRessources --name MonClusterAKS --node-count 2 --enable-addons monitoring --generate-ssh-keys

2. Conéctate al clúster:

az aks get-credentials --resource-group MonGroupeDeRessources --name MonClusterAKS

3. Crea un archivo de despliegue de Kubernetes (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: monapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: monapp
  template:
    metadata:
      labels:
        app: monapp
    spec:
      containers:
      - name: monapp
        image: monregistre.azurecr.io/monapp:v1
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: monapp
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: monapp

4. Despliega la aplicación en AKS:

kubectl apply -f deployment.yaml

5. Comprueba que el servicio es accesible:

kubectl get services monapp

Bases de datos de Azure para aplicaciones .NET

Azure SQL Database con Entity Framework Core

1. Crea una base de datos de Azure SQL desde el portal de Azure

2. Configura la cadena de conexión en tu aplicación:

// appsettings.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=tcp:monserveur.database.windows.net,1433;Database=maBaseDeDonnees;User ID=monutilisateur;Password=monMotDePasse;Encrypt=true;Connection Timeout=30;"
  }
}

3. Utiliza Entity Framework Core para conectarte:

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
    
    // ...
}

Azure Cosmos DB para NoSQL

// Configuración del cliente de Cosmos DB
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<CosmosClient>(serviceProvider => {
        var configuration = serviceProvider.GetRequiredService<IConfiguration>();
        var cosmosDbSection = configuration.GetSection("CosmosDb");
        var endpoint = cosmosDbSection["Endpoint"];
        var key = cosmosDbSection["Key"];
        
        return new CosmosClient(endpoint, key);
    });
    
    services.AddSingleton<IDocumentRepository, CosmosDbRepository>();
}

CI/CD para aplicaciones .NET con GitHub Actions

Workflow de GitHub Actions para App Service

# .github/workflows/azure-webapps-dotnet.yml
name: .NET Core CI/CD pour Azure Web App

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

env:
  AZURE_WEBAPP_NAME: votre-app-service
  AZURE_WEBAPP_PACKAGE_PATH: '.'
  DOTNET_VERSION: '6.0.x'

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    
    - name: Configurer .NET Core
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}
    
    - name: Restaurer les dépendances
      run: dotnet restore
    
    - name: Build
      run: dotnet build --configuration Release --no-restore
    
    - name: Test
      run: dotnet test --no-restore --verbosity normal
    
    - name: Publish
      run: dotnet publish -c Release -o ${{env.AZURE_WEBAPP_PACKAGE_PATH}}/myapp
    
    - name: Déployer sur Azure Web App
      uses: azure/webapps-deploy@v2
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: ${{env.AZURE_WEBAPP_PACKAGE_PATH}}/myapp

Supervisión y diagnóstico

Application Insights para la monitorización

1. Crea un recurso de Application Insights en el portal de Azure

2. Integra Application Insights en tu aplicación:

// Program.cs (.NET 6)
var builder = WebApplication.CreateBuilder(args);

// Añadir Application Insights
builder.Services.AddApplicationInsightsTelemetry();

// ...

var app = builder.Build();

3. Añade logs personalizados:

// En un controlador o servicio
public class MonController : Controller
{
    private readonly ILogger<MonController> _logger;
    
    public MonController(ILogger<MonController> logger)
    {
        _logger = logger;
    }
    
    public IActionResult Index()
    {
        _logger.LogInformation("La page d'accueil a été visitée");
        return View();
    }
}

4. Visualiza las métricas en el portal de Azure Application Insights

Seguridad de las aplicaciones .NET en Azure

Uso de Azure Key Vault

1. Crea un almacén de claves en el portal de Azure

2. Concede los permisos a tu aplicación:

az keyvault set-policy --name MonCoffre --object-id <object-id-de-votre-app> --secret-permissions get list

3. Integra Key Vault en tu aplicación:

// Program.cs
var builder = WebApplication.CreateBuilder(args);

// Añadir la configuración de Azure Key Vault
builder.Configuration.AddAzureKeyVault(
    new Uri($"https://{builder.Configuration["KeyVault:VaultName"]}.vault.azure.net/"),
    new DefaultAzureCredential());

Implantación de Azure AD B2C para la autenticación

// Program.cs
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAdB2C"));

// ...

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

Optimización de costes

Consejos para reducir los costes en Azure

1. Elegir el nivel de precios adecuado:

   • Utiliza los niveles Free y Shared para el desarrollo
   • Considera Basic/Standard para producción de tamaño pequeño o mediano

2. Escalar automáticamente:

   • Configura el autoescalado según las necesidades

   az monitor autoscale create --resource-group MonGroupeDeRessources --resource monappservice --resource-type "Microsoft.Web/sites" --name autoscale-config --min-count 1 --max-count 5 --count 1

3. Utilizar instancias reservadas para obtener ahorros a largo plazo

4. Activar Azure Cost Management para supervisar y optimizar los gastos

5. Limpiar periódicamente los recursos no utilizados

Buenas prácticas para .NET en Azure

1. Arquitectura cloud-native:

   • Diseña pensando en la resiliencia y la escalabilidad
   • Utiliza arquitecturas serverless cuando sea apropiado

2. Configuración externalizada:

   • Almacena los parámetros en Azure App Configuration o Key Vault
   • Utiliza variables de entorno para las configuraciones específicas

3. Monitorización completa:

   • Integra Application Insights desde el principio
   • Configura alertas para las métricas críticas

4. Pruebas automatizadas:

   • Incluye pruebas de carga específicamente para Azure
   • Utiliza entornos de prueba y de preproducción

5. Infrastructure as Code (IaC):

   • Utilice Azure Resource Manager (ARM) o Terraform

   // ejemplo de plantilla ARM
   {
     "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
     "contentVersion": "1.0.0.0",
     "parameters": {
       "appServiceName": {
         "type": "string",
         "metadata": {
           "description": "Nom de l'App Service"
         }
       }
     },
     "resources": [
       {
         "type": "Microsoft.Web/serverfarms",
         "apiVersion": "2020-06-01",
         "name": "[parameters('appServiceName')]",
         "location": "[resourceGroup().location]",
         "sku": {
           "name": "B1",
           "tier": "Basic"
         }
       }
     ]
   }

Conclusión

Azure ofrece un ecosistema rico e integrado para sus aplicaciones .NET, que permite cubrir todo el ciclo de vida del desarrollo. Al combinar los servicios de Azure con las buenas prácticas de desarrollo en .NET, puede crear aplicaciones robustas, eficientes y escalables.

Las herramientas y los servicios presentados en esta guía son solo el comienzo de lo que Azure puede ofrecer a los desarrolladores .NET. No dude en explorar más y en combinar distintos servicios para responder a las necesidades específicas de su aplicación.

Recursos adicionales

• Documentación oficial de Azure para .NET
• Ejemplos de código .NET en Azure
• Arquitectura de referencia para .NET en Azure
• Cloud Adoption Framework
• Azure Friday (vídeos)