Convertir Documentos con Microsoft Azure App Service

Este artículo proporciona instrucciones detalladas paso a paso para convertir documentos PDF en Microsoft Azure utilizando Aspose.PDF for .NET y Azure App Service.

Requisitos Previos

Visual Studio 2022 Community Edition con desarrollo de Azure instalado o Visual Studio Code.
Cuenta de Azure: Necesitas una suscripción de Azure, crea una cuenta gratuita antes de comenzar.
.NET 6 SDK.
Aspose.PDF for .NET.

Crear Recursos de Azure

Crear App Service

Ve al Portal de Azure (https://portal.azure.com).
Crea un nuevo Grupo de Recursos.
Crea un nuevo App Service:
- Elige el runtime .NET 6 (LTS).
- Selecciona el nivel de precios apropiado.
Crea un recurso de Application Insights para el registro.

Crear Proyecto

Crear Proyecto en Visual Studio

Abre Visual Studio 2022.
Haz clic en “Crear un nuevo proyecto”.
Selecciona “ASP.NET Core Web API”.
Nombra tu proyecto “PdfConversionService”.
Selecciona “.NET 6.0” o posterior.
Haz clic en “Crear”.

Crear Proyecto en Visual Studio Code

Instalar Requisitos Previos

Extensiones de Visual Code:

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

Instalar Azure CLI:

Windows: Descarga desde el sitio web de Microsoft.
macOS: brew install azure-cli.
Linux: curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash.

Configurar Proyecto

Abre el proyecto en Visual Studio Code:

code .

Agrega paquetes NuGet creando/actualizando 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>

Agrega configuración:

// .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"
            }
        }
    ]
}

Crea la estructura del proyecto:

mkdir Controllers
touch Controllers/PdfController.cs

Instalar Paquetes NuGet Requeridos

En Visual Studio abre la Consola del Administrador de Paquetes y ejecuta:

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

En Visual Studio Code ejecuta:

dotnet restore

Configurar Licencia de Aspose

En Visual Studio:

Copia tu archivo de licencia de Aspose.PDF al proyecto.
Haz clic derecho en el archivo de licencia y selecciona “Propiedades”.
Establece “Copiar en el Directorio de Salida” en “Copiar siempre”.
Agrega el código de inicialización de la licencia en Program.cs:

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

Crear código

En Visual Studio:

Haz clic derecho en la carpeta Controllers.
Agrega → Nuevo Elemento → Controlador API - Vacío.
Nombra tu archivo “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();

Configurar ajustes de la aplicación

Abre appsettings.json.
Agrega configuración:

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

Reemplaza Your-Connection-StringG con tu cadena de conexión real del Portal de Azure.

Probar Localmente

En Visual Studio:

Presiona F5 para ejecutar la aplicación.
Se abrirá la interfaz de usuario de Swagger.
Prueba el endpoint /api/pdf/convert:
- Haz clic en “Probar”.
- Sube un archivo PDF.
- Selecciona el formato de salida.
- Ejecuta y verifica la conversión.

En Visual Studio Code:

dotnet run

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

Desplegar en Azure

En Visual Studio:

Haz clic derecho en el proyecto.
Selecciona “Publicar”.
Elige “Azure” como destino.
Selecciona “Azure App Service (Windows)”.
Selecciona tu suscripción y App Service.
Haz clic en “Publicar”.

En 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"

Configurar Azure App Service

Ve al Portal de Azure.
Abre tu App Service.

Configura los ajustes:

App Settings:
- WEBSITE_RUN_FROM_PACKAGE=1
- ASPNETCORE_ENVIRONMENT=Production

Probar el Servicio Desplegado

Usa Postman o curl para probar:

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

Formatos Soportados

La lista de formatos soportados se puede encontrar aquí.

Solución de Problemas

Opciones de Configuración Importantes

Límites de Tamaño de Archivo Agrega a web.config:

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

CORS (si es necesario) En Program.cs:

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

Autenticación (si es necesario)

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

Convertir Documentos con la función de Microsoft Azure