Cómo usar IronWord en AWS Lambda

Residencia de datos y LOPDGDD

La LOPDGDD, en línea con el RGPD, exige que los datos personales de ciudadanos españoles y de la UE se transfieran a terceros países únicamente bajo garantías adecuadas. AWS dispone de regiones en la UE que facilitan el cumplimiento:

• AWS Región EU-WEST-3 (París) y AWS Región EU-CENTRAL-1 (Fráncfort): estas regiones mantienen los datos dentro del Espacio Económico Europeo (EEE), lo que simplifica el cumplimiento LOPDGDD/RGPD para documentos Word con datos personales (NIF, contratos de trabajo, nóminas).
• AWS Región EU-SOUTH-2 (España — Madrid): desde 2022, AWS dispone de una región en España (ap-southeast-2 / eu-south-2) que permite a las empresas españolas mantener todos los datos en territorio nacional, eliminando fricciones con la AEPD respecto a transferencias internacionales.

Para pipelines de IronWord que procesan documentos con datos personales protegidos por la LOPDGDD (nóminas, contratos, historiales médicos), se recomienda configurar el cliente S3 apuntando explícitamente a la región de Madrid o Fráncfort:

// Usar la región de Madrid para cumplimiento LOPDGDD de datos personales españoles
private static readonly IAmazonS3 _s3Client = new AmazonS3Client(Amazon.RegionEndpoint.EUSouth2);

// Usar la región de Madrid para cumplimiento LOPDGDD de datos personales españoles
private static readonly IAmazonS3 _s3Client = new AmazonS3Client(Amazon.RegionEndpoint.EUSouth2);

' Usar la región de Madrid para cumplimiento LOPDGDD de datos personales españoles
Private Shared ReadOnly _s3Client As IAmazonS3 = New AmazonS3Client(Amazon.RegionEndpoint.EUSouth2)

ENS (Esquema Nacional de Seguridad) para la Administración Pública

Las Administraciones Públicas españolas y sus proveedores de servicios cloud deben cumplir con el ENS (Esquema Nacional de Seguridad, aprobado por el Real Decreto 311/2022). AWS cuenta con la certificación ENS de nivel Alto para sus servicios en las regiones de la UE, lo que permite a las entidades públicas españolas desplegar funciones Lambda que procesen documentos Word sensibles con plena conformidad ENS.

Al configurar IronWord en Lambda para entornos de la Administración Pública española, debéis tener en cuenta los controles ENS aplicables:

• Cifrado en reposo y en tránsito: los buckets S3 que almacenan documentos Word deben tener cifrado SSE-S3 o SSE-KMS habilitado.
• Registro de auditoría: AWS CloudTrail debe estar activo para registrar todas las operaciones sobre los documentos Word procesados.
• Control de acceso: las políticas IAM deben seguir el principio de mínimo privilegio, limitando el acceso a los buckets S3 únicamente a las funciones Lambda autorizadas.

Generación de documentos fiscales AEAT en AWS Lambda

Un caso de uso común para empresas españolas es la generación serverless de documentos Word relacionados con la AEAT:

• Facturas Facturae en Lambda: generación automática de copias de representación DOCX de facturas Facturae activada por eventos de S3 o SNS cuando se procesa un nuevo registro de facturación en el ERP.
• Modelos de declaración AEAT: generación de borradores de modelos 303 (IVA trimestral) y 347 (operaciones con terceros) en formato Word para revisión contable antes del envío electrónico.
• SII (Suministro Inmediato de Información): generación automática de informes Word de cumplimiento SII como parte de pipelines Lambda activados diariamente.

// Ejemplo: generar informe SII en Lambda con IronWord
var doc = new WordDocument();
Paragraph encabezado = new Paragraph(new TextContent(
    $"Informe SII - Período {DateTime.Now:MM/yyyy} - NIF: B12345678"));
doc.AddParagraph(encabezado);
// Agregar registros de facturas emitidas/recibidas del período...
doc.SaveAs(localPath);

// Ejemplo: generar informe SII en Lambda con IronWord
var doc = new WordDocument();
Paragraph encabezado = new Paragraph(new TextContent(
    $"Informe SII - Período {DateTime.Now:MM/yyyy} - NIF: B12345678"));
doc.AddParagraph(encabezado);
// Agregar registros de facturas emitidas/recibidas del período...
doc.SaveAs(localPath);

Imports System

' Ejemplo: generar informe SII en Lambda con IronWord
Dim doc As New WordDocument()
Dim encabezado As New Paragraph(New TextContent($"Informe SII - Período {DateTime.Now:MM/yyyy} - NIF: B12345678"))
doc.AddParagraph(encabezado)
' Agregar registros de facturas emitidas/recibidas del período...
doc.SaveAs(localPath)

TicketBAI en AWS Lambda (País Vasco)

Las empresas con sede en Bizkaia, Gipuzkoa o Araba sujetas al sistema TicketBAI pueden usar funciones Lambda con IronWord para generar automáticamente las representaciones visuales DOCX de los tickets y facturas TicketBAI como parte del pipeline de facturación serverless, almacenándolas en S3 para consulta y archivo.

Crear un proyecto de AWS Lambda

Usa Visual Studio para crear un proyecto containerizado AWS Lambda:

1. Instala el AWS Toolkit para Visual Studio
2. Selecciona Proyecto AWS Lambda (.NET Core - C#)
3. Elige el blueprint .NET 8 (Imagen de Contenedor) y termina la configuración
4. Selecciona imagen de contenedor como el tipo de despliegue

Agregar dependencias de paquetes

Añade los paquetes IronWord y AWSSDK.S3 a tu proyecto a través de NuGet. La biblioteca IronWord funciona sin problemas en AWS Lambda con la configuración correcta. Ejecuta el siguiente comando para instalar IronWord en tu proyecto AWS sin problemas:

Install-Package IronWord

Actualiza el Dockerfile de tu proyecto para usar la imagen base de .NET 8 Lambda y copia tus artefactos de construcción:

FROM public.ecr.aws/lambda/dotnet:8

RUN dnf update -y

WORKDIR /var/task

COPY "bin/Release/lambda-publish"  .

Modificar el código del FunctionHandler

A continuación se muestra un ejemplo de una función Lambda que crea un documento simple de Word, lo guarda como un archivo .docx y lo sube a un bucket S3.

using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;
using IronWord;
using IronWord.Models;
using System.Text;

// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace IronWordAwsLambda;

public class Function
{
    private static readonly IAmazonS3 _s3Client = new AmazonS3Client(Amazon.RegionEndpoint.APSoutheast1);

    public async Task FunctionHandler(ILambdaContext context)
    {
        var awsTmpPath = @"/tmp/";
        License.LicenseKey = "YOUR-LICENSE-KEY"; // Replace if you have one

        string filename = Guid.NewGuid() + ".docx";
        string localPath = Path.Combine(awsTmpPath, filename);
        string bucketName = "your-s3-bucket-name";
        string objectKey = $"IronWordAwsLambda/{filename}";

        try
        {
            // Create Word Document
            var doc = new WordDocument();
            Paragraph paragraph = new Paragraph(new TextContent("Hello from IronWord on AWS Lambda!"));
            doc.AddParagraph(paragraph);
            doc.SaveAs(localPath);

            context.Logger.LogLine("Word document created.");

            // Upload to S3
            byte[] fileBytes = await File.ReadAllBytesAsync(localPath);
            await UploadToS3Async(bucketName, objectKey, fileBytes);

            context.Logger.LogLine($"Document uploaded to S3: {bucketName}/{objectKey}");
        }
        catch (Exception ex)
        {
            context.Logger.LogLine($"[ERROR] {ex.Message}");
        }
    }

    private async Task UploadToS3Async(string bucketName, string objectKey, byte[] fileBytes)
    {
        using var stream = new MemoryStream(fileBytes);
        var request = new PutObjectRequest
        {
            BucketName = bucketName,
            Key = objectKey,
            InputStream = stream,
            ContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
        };
        await _s3Client.PutObjectAsync(request);
    }
}

using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;
using IronWord;
using IronWord.Models;
using System.Text;

// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace IronWordAwsLambda;

public class Function
{
    private static readonly IAmazonS3 _s3Client = new AmazonS3Client(Amazon.RegionEndpoint.APSoutheast1);

    public async Task FunctionHandler(ILambdaContext context)
    {
        var awsTmpPath = @"/tmp/";
        License.LicenseKey = "YOUR-LICENSE-KEY"; // Replace if you have one

        string filename = Guid.NewGuid() + ".docx";
        string localPath = Path.Combine(awsTmpPath, filename);
        string bucketName = "your-s3-bucket-name";
        string objectKey = $"IronWordAwsLambda/{filename}";

        try
        {
            // Create Word Document
            var doc = new WordDocument();
            Paragraph paragraph = new Paragraph(new TextContent("Hello from IronWord on AWS Lambda!"));
            doc.AddParagraph(paragraph);
            doc.SaveAs(localPath);

            context.Logger.LogLine("Word document created.");

            // Upload to S3
            byte[] fileBytes = await File.ReadAllBytesAsync(localPath);
            await UploadToS3Async(bucketName, objectKey, fileBytes);

            context.Logger.LogLine($"Document uploaded to S3: {bucketName}/{objectKey}");
        }
        catch (Exception ex)
        {
            context.Logger.LogLine($"[ERROR] {ex.Message}");
        }
    }

    private async Task UploadToS3Async(string bucketName, string objectKey, byte[] fileBytes)
    {
        using var stream = new MemoryStream(fileBytes);
        var request = new PutObjectRequest
        {
            BucketName = bucketName,
            Key = objectKey,
            InputStream = stream,
            ContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
        };
        await _s3Client.PutObjectAsync(request);
    }
}

Imports Amazon.Lambda.Core
Imports Amazon.S3
Imports Amazon.S3.Model
Imports IronWord
Imports IronWord.Models
Imports System.Text

' Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
<Assembly: LambdaSerializer(GetType(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))>

Namespace IronWordAwsLambda

	Public Class [Function]
		Private Shared ReadOnly _s3Client As IAmazonS3 = New AmazonS3Client(Amazon.RegionEndpoint.APSoutheast1)

		Public Async Function FunctionHandler(ByVal context As ILambdaContext) As Task
			Dim awsTmpPath = "/tmp/"
			License.LicenseKey = "YOUR-LICENSE-KEY" ' Replace if you have one

			Dim filename As String = Guid.NewGuid().ToString() & ".docx"
			Dim localPath As String = Path.Combine(awsTmpPath, filename)
			Dim bucketName As String = "your-s3-bucket-name"
			Dim objectKey As String = $"IronWordAwsLambda/{filename}"

			Try
				' Create Word Document
				Dim doc = New WordDocument()
				Dim paragraph As New Paragraph(New TextContent("Hello from IronWord on AWS Lambda!"))
				doc.AddParagraph(paragraph)
				doc.SaveAs(localPath)

				context.Logger.LogLine("Word document created.")

				' Upload to S3
				Dim fileBytes() As Byte = Await File.ReadAllBytesAsync(localPath)
				Await UploadToS3Async(bucketName, objectKey, fileBytes)

				context.Logger.LogLine($"Document uploaded to S3: {bucketName}/{objectKey}")
			Catch ex As Exception
				context.Logger.LogLine($"[ERROR] {ex.Message}")
			End Try
		End Function

		Private Async Function UploadToS3Async(ByVal bucketName As String, ByVal objectKey As String, ByVal fileBytes() As Byte) As Task
			Dim stream = New MemoryStream(fileBytes)
			Dim request = New PutObjectRequest With {
				.BucketName = bucketName,
				.Key = objectKey,
				.InputStream = stream,
				.ContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
			}
			Await _s3Client.PutObjectAsync(request)
		End Function
	End Class
End Namespace

Aumentar la memoria y el tiempo de espera

Debido a que el procesamiento de documentos puede ser intensivo en memoria, aumenta la memoria de la función Lambda a al menos 512 MB y el tiempo de espera a 300 segundos en aws-lambda-tools-defaults.json:

{
  "function-memory-size": 512,
  "function-timeout": 300
}

Si encuentras errores como Runtime exited with error: signal: killed, aumenta la memoria u optimiza tu código.

Publicar

Para publicar tu función Lambda:

• Haz clic derecho en tu proyecto en Visual Studio
• Selecciona Publicar en AWS Lambda...
• Sigue el asistente y configura los ajustes según sea necesario

¡Pruébalo!

Invoca la función Lambda a través de la Consola AWS Lambda o Visual Studio. Después de la ejecución, verifica tu bucket S3 para el documento de Word recién creado.