Convertendo Documentos com a função Microsoft Azure

Este artigo fornece instruções detalhadas passo a passo para converter documentos PDF no Microsoft Azure usando Aspose.PDF for .NET e a função Azure.

Pré-requisitos

Visual Studio 2022 Community Edition com desenvolvimento Azure instalado ou Visual Studio Code.
Conta Azure: Você precisa de uma assinatura Azure, crie uma conta gratuita antes de começar.
.NET 6 SDK.
Aspose.PDF for .NET.

Criar Recursos do Azure

Criar Conta de Armazenamento

Vá para o Portal do Azure (https://portal.azure.com).
Clique em “Criar um recurso”.
Pesquise por “Conta de armazenamento”.
Clique em “Criar”.
Preencha os detalhes:
- Assinatura: Escolha sua assinatura.
- Grupo de recursos: Crie novo ou selecione existente.
- Nome da conta de armazenamento: Insira um nome único.
- Região: Escolha a região mais próxima.
- Desempenho: Padrão.
- Redundância: LRS (armazenamento localmente redundante).
Clique em “Revisar + criar”.
Clique em “Criar”.

Criar Contêiner

Abra sua conta de armazenamento.
Vá para “Contêineres” em “Armazenamento de dados”.
Clique em “+ Contêiner”.
Nomeie como “pdfdocs”.
Defina o nível de acesso público como “Privado”.
Clique em “Criar”.

Criar Projeto

Criar Projeto no Visual Studio

Abra o Visual Studio 2022.
Clique em “Criar um novo projeto”.
Selecione “Azure Functions”.
Nomeie seu projeto como “PdfConverterAzure”.
Escolha “.NET 6.0” ou posterior e “gatilho HTTP”.
Clique em “Criar”.

Criar Projeto no Visual Studio Code

Instalar Pré-requisitos

Extensões do Visual Code:

code --install-extension ms-dotnettools.csharp
code --install-extension ms-azuretools.vscode-azurefunctions
code --install-extension ms-vscode.azure-account

Instale o Azure Functions Core Tools:

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

Instale o Azure CLI:

Windows: Baixe do site da Microsoft.
macOS: brew install azure-cli.
Linux: curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash.

Configurar Projeto

Abra o projeto no Visual Studio Code:

code .

Adicione pacotes NuGet criando/atualizando 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>

Instalar Pacotes NuGet Necessários

No Visual Studio, abra o Console do Gerenciador de Pacotes e execute:

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

No Visual Studio Code, execute:

dotnet restore

Configurar Conexão de Armazenamento do Azure

Obtenha as Chaves de Acesso para a conta de armazenamento em Chaves de acesso no Portal do Azure. Essas chaves serão usadas para autenticar seu aplicativo.

Abra local.settings.json:

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

Substitua YOUR_STORAGE_CONNECTION_STRING pela sua string de conexão de armazenamento real do Portal do Azure.

Configurar Licença Aspose

No Visual Studio:

Copie seu arquivo de licença Aspose.PDF para o projeto.
Clique com o botão direito no arquivo de licença e selecione “Propriedades”.
Defina “Copiar para o Diretório de Saída” como “Copiar sempre”.
Adicione o código de inicialização da licença no Program.cs:

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

Criar código

Crie um novo arquivo 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();
    }
}

Crie um novo arquivo 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");
        }
    }
}

Testar Localmente

No Visual Studio:

Inicie o Emulador de Armazenamento do Azure.
Execute o projeto no Visual Studio.
Use Postman ou curl para testar:

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

No Visual Studio Code:

Inicie o aplicativo de função:

func start

Faça o upload de um PDF para testar:

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

Use Postman ou curl para testar:

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

Implantar no Azure

No Visual Studio:

Clique com o botão direito no projeto no Visual Studio.
Selecione “Publicar”.
Escolha “Aplicativo de Função do Azure”.
Selecione sua assinatura.
Crie novo ou selecione o Aplicativo de Função existente.
Clique em “Publicar”.

No Visual Studio Code:

Pressione F1 ou Ctrl+Shift+P.
Selecione “Azure Functions: Implantar no Aplicativo de Função”.
Escolha sua assinatura.
Selecione o aplicativo de função criado acima.
Clique em “Implantar”.

Configurar Aplicativo de Função do Azure

Vá para o Portal do Azure.
Abra seu Aplicativo de Função.
Vá para “Configuração”.
Adicione configurações de aplicativo:
- Chave: “ContainerName”.
- Valor: “pdfdocs”.
Salve as alterações.

Testar o Serviço Implantado

Use Postman ou curl para testar:

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"}'

Formatos Suportados

A lista de formatos suportados pode ser encontrada aqui.

Solução de Problemas

Opções de Configuração Importantes

Adicione autenticação:

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

Para arquivos grandes, considere:
- Aumentar o tempo limite da função.
- Usar um plano de consumo com mais memória.
- Implementar upload/download em partes.
- Adicionar rastreamento de progresso.

Convertendo Documentos com o Microsoft Azure App Service