Conversion de documents avec Microsoft Azure App service

Cet article fournit des instructions détaillées étape par étape pour convertir des documents PDF dans Microsoft Azure en utilisant Aspose.PDF for .NET et Azure App service.

Prérequis

Visual Studio 2022 Community Edition avec développement Azure installé ou Visual Studio Code.
Compte Azure : Vous avez besoin d’un abonnement Azure, créez un compte gratuit avant de commencer.
.NET 6 SDK.
Aspose.PDF for .NET.

Créer des ressources Azure

Créer un App Service

Allez sur le portail Azure (https://portal.azure.com).
Créez un nouveau groupe de ressources.
Créez un nouveau App Service :
- Choisissez le runtime .NET 6 (LTS).
- Sélectionnez le niveau de tarification approprié.
Créez une ressource Application Insights pour la journalisation.

Créer un projet

Créer un projet Visual Studio

Ouvrez Visual Studio 2022.
Cliquez sur “Créer un nouveau projet”.
Sélectionnez “ASP.NET Core Web API”.
Nommez votre projet “PdfConversionService”.
Sélectionnez “.NET 6.0” ou version ultérieure.
Cliquez sur “Créer”.

Créer un projet Visual Studio Code

Installer les prérequis

Extensions Visual Code :

code --install-extension ms-dotnettools.csharp
code --install-extension ms-azuretools.vscode-azureappservice

Installer Azure CLI :

Windows : Téléchargez depuis le site de Microsoft.
macOS : brew install azure-cli.
Linux : curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash.

Configurer le projet

Ouvrez le projet dans Visual Studio Code :

code .

Ajoutez des packages NuGet en créant/mis à jour PdfConverterApp.csproj :

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Aspose.PDF" Version="24.10.0" />
    <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.22.0" />
    <PackageReference Include="Microsoft.Extensions.Logging.AzureAppServices" Version="8.0.10" />
  </ItemGroup>
</Project>

Ajoutez la configuration :

// .vscode/launch.json
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": ".NET Core Launch (web)",
            "type": "coreclr",
            "request": "launch",
            "preLaunchTask": "build",
            "program": "${workspaceFolder}/bin/Debug/net6.0/PdfConversionService.dll",
            "args": [],
            "cwd": "${workspaceFolder}",
            "stopAtEntry": false,
            "env": {
                "ASPNETCORE_ENVIRONMENT": "Development"
            }
        }
    ]
}

Créez la structure du projet :

mkdir Controllers
touch Controllers/PdfController.cs

Installer les packages NuGet requis

Dans Visual Studio, ouvrez la console du gestionnaire de packages et exécutez :

Install-Package Aspose.PDF
Install-Package Microsoft.ApplicationInsights.AspNetCore
Install-Package Microsoft.Extensions.Logging.AzureAppServices

Dans Visual Studio Code, exécutez :

dotnet restore

Configurer la licence Aspose

Dans Visual Studio :

Copiez votre fichier de licence Aspose.PDF dans le projet.
Cliquez avec le bouton droit sur le fichier de licence et sélectionnez “Propriétés”.
Réglez “Copier dans le répertoire de sortie” sur “Toujours copier”.
Ajoutez le code d’initialisation de la licence dans le Program.cs :

var license = new Aspose.Pdf.License();
license.SetLicense("Aspose.PDF.lic");

Créer le code

Dans Visual Studio :

Cliquez avec le bouton droit sur le dossier Controllers.
Ajouter → Nouvel élément → Contrôleur API - Vide.
Nommez votre fichier “PdfController.cs”.

// PdfController.cs
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly ILogger<PdfController> _logger;

    public PdfController(ILogger<PdfController> logger)
    {
        _logger = logger;
    }

    [HttpPost("convert")]
    public async Task<IActionResult> ConvertPdf(
        IFormFile file,
        [FromQuery] string outputFormat = "docx")
    {
        try
        {
            if (file == null || file.Length == 0)
            {
                return BadRequest("No file uploaded");
            }

            // Validate input file is PDF
            if (!file.ContentType.Equals("application/pdf", StringComparison.OrdinalIgnoreCase))
            {
                return BadRequest("File must be a PDF");
            }

            using var inputStream = file.OpenReadStream();
            using var document = new Aspose.Pdf.Document(inputStream);
            using var outputStream = new MemoryStream();

            switch (outputFormat.ToLower())
            {
                case "docx":
                    document.Save(outputStream, Aspose.Pdf.SaveFormat.DocX);
                    return File(outputStream.ToArray(),
                        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
                        "converted.docx");

                case "html":
                    document.Save(outputStream, Aspose.Pdf.SaveFormat.Html);
                    return File(outputStream.ToArray(),
                        "text/html",
                        "converted.html");

                case "jpg":
                case "jpeg":
                    var jpegDevice = new Aspose.Pdf.Devices.JpegDevice();
                    jpegDevice.Process(document.Pages[1], outputStream);
                    return File(outputStream.ToArray(),
                        "image/jpeg",
                        "converted.jpg");

                case "png":
                    var pngDevice = new Aspose.Pdf.Devices.PngDevice();
                    pngDevice.Process(document.Pages[1], outputStream);
                    return File(outputStream.ToArray(),
                        "image/png",
                        "converted.png");

                default:
                    return BadRequest("Unsupported output format");
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error converting PDF");
            return StatusCode(500, "Internal server error");
        }
    }
}

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

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Add logging
builder.Services.AddApplicationInsightsTelemetry();
builder.Services.AddLogging(logging =>
{
    logging.AddConsole();
    logging.AddDebug();
    logging.AddAzureWebAppDiagnostics();
});

var app = builder.Build();

// Initialize license
var license = new Aspose.Pdf.License();
license.SetLicense("Aspose.PDF.lic");

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

Configurer les paramètres de l’application

Ouvrez appsettings.json.
Ajoutez la configuration :

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ApplicationInsights": {
    "ConnectionString": "Your-Connection-String"
  }
}

Remplacez Your-Connection-StringG par votre véritable chaîne de connexion depuis le portail Azure.

Tester localement

Dans Visual Studio :

Appuyez sur F5 pour exécuter l’application.
L’interface Swagger s’ouvrira.
Testez le point de terminaison /api/pdf/convert :
- Cliquez sur “Essayez-le”.
- Téléchargez un fichier PDF.
- Sélectionnez le format de sortie.
- Exécutez et vérifiez la conversion.

Dans Visual Studio Code :

dotnet run

curl -X POST "https://localhost:5001/api/pdf/convert?outputFormat=docx" \
     -F "file=@sample.pdf" \
     -o converted.docx

Déployer sur Azure

Dans Visual Studio :

Cliquez avec le bouton droit sur le projet.
Sélectionnez “Publier”.
Choisissez “Azure” comme cible.
Sélectionnez “Azure App Service (Windows)”.
Sélectionnez votre abonnement et App Service.
Cliquez sur “Publier”.

Dans Visual Studio Code :

dotnet publish -c Release

az webapp deployment source config-zip \
    --resource-group $resourceGroup \
    --name $appName \
    --src bin/Release/net6.0/publish.zip

az webapp deploy \
    --resource-group $resourceGroup \
    --name $appName \
    --src-path "Aspose.PDF.lic" \
    --target-path "site/wwwroot/Aspose.PDF.lic"

Configurer Azure App Service

Allez sur le portail Azure.
Ouvrez votre App Service.

Configurez les paramètres :

App Settings:
- WEBSITE_RUN_FROM_PACKAGE=1
- ASPNETCORE_ENVIRONMENT=Production

Tester le service déployé

Utilisez Postman ou curl pour tester :

curl -X POST "https://your-app.azurewebsites.net/api/pdf/convert?outputFormat=docx" \
     -F "file=@sample.pdf" \
     -o converted.docx

Formats pris en charge

La liste des formats pris en charge peut être trouvée ici.

Dépannage

Options de configuration importantes

Limites de taille de fichier Ajoutez au web.config :

<configuration>
  <system.webServer>
    <security>
      <requestFiltering>
        <requestLimits maxAllowedContentLength="104857600" />
      </requestFiltering>
    </security>
  </system.webServer>
</configuration>

CORS (si nécessaire) Dans Program.cs :

builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowSpecificOrigin",
        builder => builder
            .WithOrigins("https://your-frontend-domain.com")
            .AllowAnyMethod()
            .AllowAnyHeader());
});

Authentification (si nécessaire)

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options => {
        // Configure JWT options
    });

Conversion de documents avec la fonction Microsoft Azure