Déploiement d’applications .NET sur Azure : Guide complet

Introduction

Microsoft Azure offre un écosystème riche et performant pour héberger vos applications .NET. Grâce à l’intégration native entre .NET et Azure, vous pouvez déployer facilement vos applications et profiter d’une scalabilité automatique, d’une haute disponibilité et d’une sécurité renforcée. Ce guide vous présente les différentes options de déploiement et les meilleures pratiques pour optimiser vos applications .NET dans le cloud.

Prérequis

Avant de commencer, assurez-vous d’avoir :

• Un compte Azure (vous pouvez créer un compte gratuit sur azure.microsoft.com)
• Le SDK .NET installé sur votre machine de développement
• Azure CLI ou Azure PowerShell installé (facultatif mais recommandé)
• Visual Studio 2022 ou Visual Studio Code avec l’extension Azure
• Git pour la gestion de versions

Azure App Service pour les applications web .NET

Azure App Service est la solution PaaS (Platform as a Service) idéale pour héberger vos applications web ASP.NET et ASP.NET Core.

Création d’une App Service depuis le portail Azure

1. Connectez-vous au Portail Azure
2. Cliquez sur “Créer une ressource” > “Web” > “App Service”
3. Complétez les informations de base :
   • Groupe de ressources : créez-en un nouveau ou utilisez un existant
   • Nom de l’application : doit être unique à travers Azure
   • Publier : sélectionnez “Code”
   • Pile d’exécution : choisissez ”.NET 6” (ou la version que vous utilisez)
   • Système d’exploitation : Windows ou Linux
   • Région : choisissez la plus proche de vos utilisateurs
   • Plan App Service : sélectionnez un plan existant ou créez-en un nouveau
4. Cliquez sur “Vérifier + créer” puis “Créer”

Déploiement depuis Visual Studio

1. Ouvrez votre solution dans Visual Studio
2. Cliquez-droit sur le projet web et sélectionnez “Publier”
3. Choisissez “Azure” comme cible
4. Sélectionnez “Azure App Service” puis l’instance que vous venez de créer
5. Configurez les paramètres de déploiement et cliquez sur “Publier”

Déploiement via 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'

Configuration de l’environnement

Utilisez les paramètres d’application pour configurer votre application sans recompilation :

1. Dans le portail Azure, accédez à votre App Service
2. Sous “Configuration” > “Paramètres d’application”, ajoutez vos variables d’environnement
3. Par exemple, pour une chaîne de connexion à une base de données :
   • Nom : ConnectionStrings__DefaultConnection
   • Valeur : votre chaîne de connexion

Azure Functions pour les microservices serverless

Azure Functions permet d’exécuter des portions de code sans gérer l’infrastructure sous-jacente.

Création d’une Function App

// Function App simple qui répond aux requêtes 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);
    }
}

Déploiement d’Azure Functions

Depuis Visual Studio

1. Créez un projet Azure Functions
2. Développez vos fonctions
3. Cliquez-droit sur le projet > “Publier”
4. Choisissez Azure comme cible
5. Sélectionnez ou créez une Function App

En utilisant Azure CLI

# Se connecter à Azure
az login

# Créer un groupe de ressources (si nécessaire)
az group create --name MonGroupeDeRessources --location francecentral

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

# Déployer le code
func azure functionapp publish MonAppDeFonctions

Conteneurisation avec Docker et Azure Container Registry

La conteneurisation de vos applications .NET offre portabilité et cohérence entre les environnements.

Création d’un Dockerfile pour 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"]

Création et utilisation d’Azure Container Registry (ACR)

# Créer un registre de conteneurs
az acr create --resource-group MonGroupeDeRessources --name monregistre --sku Basic

# Se connecter au registre
az acr login --name monregistre

# Construire l'image Docker
docker build -t monapp:v1 .

# Tagger l'image pour ACR
docker tag monapp:v1 monregistre.azurecr.io/monapp:v1

# Pousser l'image vers ACR
docker push monregistre.azurecr.io/monapp:v1

Déploiement sur Azure App Service avec des conteneurs

# Activer l'accès administrateur pour le registre
az acr update -n monregistre --admin-enabled true

# Obtenir les identifiants du registre
az acr credential show -n monregistre

# Créer une App Service Plan qui supporte les conteneurs
az appservice plan create --resource-group MonGroupeDeRessources --name MonPlanAppService --is-linux --sku B1

# Créer une App Service qui utilise le conteneur
az webapp create --resource-group MonGroupeDeRessources --plan MonPlanAppService --name MonAppWeb --deployment-container-image-name monregistre.azurecr.io/monapp:v1

# Configurer les identifiants du registre
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) pour les applications .NET

AKS est idéal pour les applications complexes nécessitant une orchestration avancée de conteneurs.

Déploiement d’une application .NET sur AKS

1. Créez un cluster AKS :

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

2. Connectez-vous au cluster :

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

3. Créez un fichier de déploiement 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. Déployez l’application sur AKS :

kubectl apply -f deployment.yaml

5. Vérifiez que le service est accessible :

kubectl get services monapp

Bases de données Azure pour les applications .NET

Azure SQL Database avec Entity Framework Core

1. Créez une base de données Azure SQL depuis le portail Azure

2. Configurez la chaîne de connexion dans votre application :

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

3. Utilisez Entity Framework Core pour vous connecter :

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

Azure Cosmos DB pour NoSQL

// Configuration du client 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 pour les applications .NET avec GitHub Actions

Workflow GitHub Actions pour 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

Surveillance et diagnostics

Application Insights pour le monitoring

1. Créez une ressource Application Insights dans le portail Azure

2. Intégrez Application Insights dans votre application :

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

// Ajouter Application Insights
builder.Services.AddApplicationInsightsTelemetry();

// ...

var app = builder.Build();

3. Ajoutez des logs personnalisés :

// Dans un contrôleur ou service
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. Visualisez les métriques dans le portail Azure Application Insights

Sécurisation des applications .NET sur Azure

Utilisation d’Azure Key Vault

1. Créez un coffre de clés dans le portail Azure

2. Accordez les permissions à votre application :

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

3. Intégrez Key Vault dans votre application :

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

// Ajouter la configuration Azure Key Vault
builder.Configuration.AddAzureKeyVault(
    new Uri($"https://{builder.Configuration["KeyVault:VaultName"]}.vault.azure.net/"),
    new DefaultAzureCredential());

Mise en place d’Azure AD B2C pour l’authentification

// 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();

Optimisation des coûts

Conseils pour réduire les coûts sur Azure

1. Choisir le bon niveau tarifaire :

   • Utilisez les niveaux Free et Shared pour le développement
   • Envisagez Basic/Standard pour la production de petite à moyenne taille

2. Mettre à l’échelle automatiquement :

   • Configurez l’autoscaling selon les besoins

   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. Utiliser les instances réservées pour des économies à long terme

4. Activer Azure Cost Management pour surveiller et optimiser les dépenses

5. Nettoyer les ressources inutilisées régulièrement

Bonnes pratiques pour .NET sur Azure

1. Architecture Cloud-Native :

   • Concevez pour la résilience et la scalabilité
   • Utilisez des architectures serverless quand c’est approprié

2. Configuration externalisée :

   • Stockez les paramètres dans Azure App Configuration ou Key Vault
   • Utilisez les variables d’environnement pour les configurations spécifiques

3. Monitoring complet :

   • Intégrez Application Insights dès le début
   • Configurez des alertes pour les métriques critiques

4. Tests automatisés :

   • Incluez des tests de charge spécifiquement pour Azure
   • Utilisez des environnements de test/préproduction

5. Infrastructure as Code (IaC) :

   • Utilisez Azure Resource Manager (ARM) ou Terraform

   // exemple de template 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"
         }
       }
     ]
   }

Conclusion

Azure offre un écosystème riche et intégré pour vos applications .NET, permettant de couvrir l’ensemble du cycle de vie de développement. En combinant les services Azure avec les bonnes pratiques de développement .NET, vous pouvez créer des applications robustes, performantes et évolutives.

Les outils et services présentés dans ce guide ne sont que le début de ce qu’Azure peut offrir aux développeurs .NET. N’hésitez pas à explorer davantage et à combiner différents services pour répondre aux besoins spécifiques de votre application.

Ressources supplémentaires

• Documentation officielle Azure pour .NET
• Exemples de code .NET sur Azure
• Architecture de référence pour .NET sur Azure
• Cloud Adoption Framework
• Azure Friday (vidéos)