Dans le monde du développement logiciel moderne, l'intégration continue (CI) et le déploiement continu (CD) sont devenus des pratiques incontournables pour garantir la qualité et l'agilité des livraisons. Ce guide pratique vous accompagnera dans la mise en place d'un pipeline CI/CD robuste pour vos projets .NET, en exploitant les meilleures pratiques DevOps.
Les fondamentaux du CI/CD
L'intégration continue consiste à automatiser l'intégration des modifications de code dans un référentiel partagé, tandis que le déploiement continu permet d'automatiser la mise en production du code validé. Ces pratiques s'appuient sur plusieurs concepts clés :
- Automatisation des builds
- Tests automatisés
- Déploiements reproductibles
- Monitoring continu
Configuration d'un pipeline CI/CD avec Azure DevOps
Voici un exemple de configuration YAML pour Azure Pipelines :
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
variables:
solution: '/.sln'
buildPlatform: 'Any CPU'
buildConfiguration: 'Release'
steps:
- task: NuGetToolInstaller@1
- task: NuGetCommand@2
inputs:
restoreSolution: '$(solution)'
- task: VSBuild@1
inputs:
solution: '$(solution)'
platform: '$(buildPlatform)'
configuration: '$(buildConfiguration)'
- task: VSTest@2
inputs:
platform: '$(buildPlatform)'
configuration: '$(buildConfiguration)'
Tests automatisés dans le pipeline
Les tests unitaires sont essentiels dans un pipeline CI/CD. Voici un exemple avec xUnit :
public class OrderServiceTests
{
[Fact]
public async Task CreateOrder_ValidData_ReturnsOrderId()
{
// Arrange
var orderService = new OrderService();
var orderData = new OrderDto
{
CustomerId = 1,
Products = new[] { new ProductDto { Id = 1, Quantity = 2 } }
};
// Act
var result = await orderService.CreateOrderAsync(orderData);
// Assert
Assert.NotEqual(0, result.OrderId);
}
}
Containerisation avec Docker
Exemple de Dockerfile pour une application ASP.NET Core :
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "./"]
RUN dotnet restore "MyApp.csproj"
COPY . .
RUN dotnet build "MyApp.csproj" -c Release -o /app/build
FROM build AS publish
RUN dotnet publish "MyApp.csproj" -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]
Monitoring et observabilité
Configuration du monitoring avec Application Insights :
public void ConfigureServices(IServiceCollection services)
{
services.AddApplicationInsightsTelemetry(Configuration["ApplicationInsights:InstrumentationKey"]);
services.AddSingleton();
services.AddHealthChecks()
.AddSqlServer(Configuration["ConnectionStrings:DefaultConnection"])
.AddRedis(Configuration["Redis:ConnectionString"]);
}
Bonnes pratiques de sécurité
- Utilisation de secrets sécurisés
- Scan de vulnérabilités
- Tests de pénétration automatisés
public class SecretManager
{
private readonly IConfiguration _configuration;
public SecretManager(IConfiguration configuration)
{
_configuration = configuration;
}
public async Task GetSecretAsync(string secretName)
{
var keyVaultClient = new KeyVaultClient(
new KeyVaultClient.AuthenticationCallback(
async (authority, resource, scope) =>
{
var credential = new DefaultAzureCredential();
var token = await credential.GetTokenAsync(
new TokenRequestContext(new[] { "https://vault.azure.net/.default" }));
return token.Token;
}));
var secret = await keyVaultClient.GetSecretAsync(_configuration["KeyVault:Url"], secretName);
return secret.Value;
}
}
Gestion des erreurs et résilience
Implémentation de la résilience avec Polly :
public static class ResiliencePolicies
{
public static IAsyncPolicy GetRetryPolicy()
{
return HttpPolicyExtensions
.HandleTransientHttpError()
.WaitAndRetryAsync(3, retryAttempt =>
TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
}
public static IAsyncPolicy GetCircuitBreakerPolicy()
{
return HttpPolicyExtensions
.HandleTransientHttpError()
.CircuitBreakerAsync(5, TimeSpan.FromSeconds(30));
}
}
Conclusion
La mise en place d'un pipeline CI/CD robuste nécessite une attention particulière à l'automatisation, aux tests, à la sécurité et au monitoring. Les outils et pratiques présentés dans ce guide vous permettront de construire un processus de livraison continue fiable et efficace pour vos applications .NET.
Points clés à retenir :
- Automatisation complète du pipeline
- Tests exhaustifs à chaque étape
- Sécurité intégrée dès le début
- Monitoring proactif
- Gestion efficace des erreurs