Conversion de documents avec la fonction Microsoft Azure

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 la fonction Azure.

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.
SDK .NET 6.
Aspose.PDF for .NET.

Créer des ressources Azure

Créer un compte de stockage

Allez sur le portail Azure (https://portal.azure.com).
Cliquez sur “Créer une ressource”.
Recherchez “Compte de stockage”.
Cliquez sur “Créer”.
Remplissez les détails :
- Abonnement : Choisissez votre abonnement.
- Groupe de ressources : Créez un nouveau ou sélectionnez un existant.
- Nom du compte de stockage : Entrez un nom unique.
- Région : Choisissez la région la plus proche.
- Performance : Standard.
- Redondance : LRS (Stockage redondant localement).
Cliquez sur “Vérifier + créer”.
Cliquez sur “Créer”.

Créer un conteneur

Ouvrez votre compte de stockage.
Allez dans “Conteneurs” sous “Stockage de données”.
Cliquez sur “+ Conteneur”.
Nommez-le “pdfdocs”.
Définissez le niveau d’accès public sur “Privé”.
Cliquez sur “Créer”.

Créer un projet

Créer un projet Visual Studio

Ouvrez Visual Studio 2022.
Cliquez sur “Créer un nouveau projet”.
Sélectionnez “Fonctions Azure”.
Nommez votre projet “PdfConverterAzure”.
Choisissez “.NET 6.0” ou plus récent et “Déclencheur HTTP”.
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-azurefunctions
code --install-extension ms-vscode.azure-account

Installer les outils de base Azure Functions :

npm install -g azure-functions-core-tools@4 --unsafe-perm true

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>
    <AzureFunctionsVersion>v4</AzureFunctionsVersion>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="4.1.1" />
    <PackageReference Include="Aspose.PDF" Version="24.10.0" />
    <PackageReference Include="Azure.Storage.Blobs" Version="12.14.1" />
    <PackageReference Include="Microsoft.Azure.WebJobs.Extensions.Storage" Version="5.0.1" />
  </ItemGroup>
</Project>

Installer les packages NuGet requis

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

Install-Package Aspose.PDF
Install-Package Azure.Storage.Blobs
Install-Package Microsoft.Azure.WebJobs.Extensions.Storage

Dans Visual Studio Code, exécutez :

dotnet restore

Configurer la connexion de stockage Azure

Obtenez les clés d’accès pour le compte de stockage sous Clés d’accès dans le portail Azure. Ces clés seront utilisées pour authentifier votre application.

Ouvrez local.settings.json :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "YOUR_STORAGE_CONNECTION_STRING",
        "FUNCTIONS_WORKER_RUNTIME": "dotnet",
        "ContainerName": "pdfdocs"
    }
}

Remplacez YOUR_STORAGE_CONNECTION_STRING par votre véritable chaîne de connexion de stockage depuis le portail Azure.

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”.
Définissez “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

Créez un nouveau fichier PdfConverter.cs :

using Azure.Storage.Blobs;
using System;
using System.IO;
using System.Threading.Tasks;

public class PdfConverter
{
    private readonly BlobContainerClient _containerClient;

    public PdfConverter(string connectionString, string containerName)
    {
        _containerClient = new BlobContainerClient(connectionString, containerName);
    }

    public async Task<string> ConvertToFormat(string sourceBlobName, string targetFormat)
    {
        // Download source PDF
        var sourceBlob = _containerClient.GetBlobClient(sourceBlobName);
        using var sourceStream = new MemoryStream();
        await sourceBlob.DownloadToAsync(sourceStream);
        sourceStream.Position = 0;

        // Open PDF document
        var document = new Aspose.Pdf.Document(sourceStream);

        // Create output stream
        using var outputStream = new MemoryStream();
        string targetBlobName = Path.GetFileNameWithoutExtension(sourceBlobName);

        // Convert based on format
        switch (targetFormat.ToLower())
        {
            case "docx":
                targetBlobName += ".docx";
                document.Save(outputStream, Aspose.Pdf.SaveFormat.DocX);
                break;

            case "html":
                targetBlobName += ".html";
                document.Save(outputStream, Aspose.Pdf.SaveFormat.Html);
                break;

            case "xlsx":
                targetBlobName += ".xlsx";
                document.Save(outputStream, Aspose.Pdf.SaveFormat.Excel);
                break;

            case "pptx":
                targetBlobName += ".pptx";
                document.Save(outputStream, Aspose.Pdf.SaveFormat.Pptx);
                break;

            case "jpeg":
            case "jpg":
                targetBlobName += ".jpg";
                foreach (var page in document.Pages)
                {
                    var jpegDevice = new Aspose.Pdf.Devices.JpegDevice(new Aspose.Pdf.Devices.Resolution(300));
                    jpegDevice.Process(page, outputStream);
                }
                break;

            default:
                throw new ArgumentException($"Unsupported format: {targetFormat}");
        }

        // Upload converted file
        outputStream.Position = 0;
        var targetBlob = _containerClient.GetBlobClient(targetBlobName);
        await targetBlob.UploadAsync(outputStream, true);

        return targetBlob.Uri.ToString();
    }
}

Créez un nouveau fichier ConvertPdfFunction.cs :

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;
using System;
using System.IO;
using Newtonsoft.Json;
using Microsoft.AspNetCore.Mvc;

public static class ConvertPdfFunction
{
    [FunctionName("ConvertPdf")]
    public static async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "post"), Route = "convert"] HttpRequest req,
        ILogger log)
    {
        try
        {
            // Read request body
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            dynamic data = JsonConvert.DeserializeObject(requestBody);

            string sourceBlob = data?.sourceBlob;
            string targetFormat = data?.targetFormat;

            if (string.IsNullOrEmpty(sourceBlob) || string.IsNullOrEmpty(targetFormat))
            {
                return new BadRequestObjectResult("Please provide sourceBlob and targetFormat");
            }

            // Get configuration
            string connectionString = Environment.GetEnvironmentVariable("AzureWebJobsStorage");
            string containerName = Environment.GetEnvironmentVariable("ContainerName");

            // Convert PDF
            var converter = new PdfConverter(connectionString, containerName);
            string resultUrl = await converter.ConvertToFormat(sourceBlob, targetFormat);

            return new OkObjectResult(new { url = resultUrl });
        }
        catch (Exception ex)
        {
            log.LogError(ex, "Error converting PDF");
            return new StatusCodeResult(500);
        }
    }
}

// Startup.cs
[assembly: FunctionsStartup(typeof(PdfConverterAzure.Functions.Startup))]
namespace PdfConverterAzure.Functions
{
    public class Startup : FunctionsStartup
    {
        public override void Configure(IFunctionsHostBuilder builder)
        {
            // Read configuration
            var config = builder.GetContext().Configuration;

            // Register services
            builder.Services.AddLogging();

            // Register Azure Storage
            builder.Services.AddSingleton(x => 
                new BlobServiceClient(config["AzureWebJobsStorage"]));

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

Tester localement

Dans Visual Studio :

Démarrez l’émulateur de stockage Azure.
Exécutez le projet dans Visual Studio.
Utilisez Postman ou curl pour tester :

curl -X POST http://localhost:7071/api/convert \
-H "Content-Type: application/json" \
-d '{"sourceBlob": "sample.pdf", "targetFormat": "docx"}'

Dans Visual Studio Code :

Démarrez l’application de fonction :

func start

Téléchargez un PDF pour tester :

az storage blob upload \
    --account-name $AccountName \
    --container-name pdfdocs \
    --name sample.pdf \
    --file /path/to/your/sample.pdf

Utilisez Postman ou curl pour tester :

curl -X POST http://localhost:7071/api/convert \
-H "Content-Type: application/json" \
-d '{"sourceBlob": "sample.pdf", "targetFormat": "docx"}'

Déployer sur Azure

Dans Visual Studio :

Cliquez avec le bouton droit sur le projet dans Visual Studio.
Sélectionnez “Publier”.
Choisissez “Application de fonction Azure”.
Sélectionnez votre abonnement.
Créez une nouvelle ou sélectionnez une application de fonction existante.
Cliquez sur “Publier”.

Dans Visual Studio Code :

Appuyez sur F1 ou Ctrl+Shift+P.
Sélectionnez “Fonctions Azure : Déployer sur l’application de fonction”.
Choisissez votre abonnement.
Sélectionnez l’application de fonction créée ci-dessus.
Cliquez sur “Déployer”.

Configurer l’application de fonction Azure

Allez sur le portail Azure.
Ouvrez votre application de fonction.
Allez dans “Configuration”.
Ajoutez des paramètres d’application :
- Clé : “ContainerName”.
- Valeur : “pdfdocs”.
Enregistrez les modifications.

Tester le service déployé

Utilisez Postman ou curl pour tester :

curl -X POST "https://your-function.azurewebsites.net/api/convert" \
     -H "x-functions-key: your-function-key" \
     -H "Content-Type: application/json" \
     -d '{"sourceBlob": "sample.pdf", "targetFormat": "docx"}'

Formats pris en charge

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

Dépannage

Options de configuration importantes

Ajouter une authentification :

[FunctionName("ConvertPdf")]
public async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "convert")] HttpRequest req,
    ClaimsPrincipal principal,
    ILogger log)
{
    // Check authentication
    if (!principal.Identity.IsAuthenticated)
    {
        return new UnauthorizedResult();
    }
    // ...
}

Pour les fichiers volumineux, envisagez :
- D’augmenter le délai d’expiration de la fonction.
- D’utiliser un plan de consommation avec plus de mémoire.
- D’implémenter un téléchargement/téléchargement par morceaux.
- D’ajouter un suivi de progression.

Conversion de documents avec Microsoft Azure App service