Jak korzystać z IronWord na AWS Lambda

Updated: 4 czerwca 2026

Ten artykuł zawiera kompleksowy przewodnik po konfiguracji funkcji AWS Lambda przy użyciu IronWord. Dowiesz się, jak skonfigurować IronWord do tworzenia i edycji dokumentów Worda w środowisku AWS Lambda.

Jak korzystać z IronWord na AWS Lambda

Pobierz i dodaj IronWord do swojego projektu
Utwórz projekt AWS Lambda za pomocą programu Visual Studio
Zmodyfikuj kod FunctionHandler, aby generował dokumenty WORD
Skonfiguruj i wdróż projekt za pomocą kontenera Docker
Wywołaj funkcję Lambda i sprawdź pliki wyjściowe w S3

Instalacja

Ponieważ w tym przykładzie będziemy odczytywać/zapisywać dokumenty WORDa do zasobnika S3, wymagany jest pakiet NuGet AWSSDK.S3.

Korzystanie z pakietu ZIP IronWord w AWS Lambda

Podczas korzystania z pakietu ZIP IronWord ważne jest, aby ustawić tymczasową ścieżkę wdrożenia, ponieważ AWS Lambda posiada system plików tylko do odczytu, z wyjątkiem folderu /tmp/. Należy skonfigurować IronWord tak, aby używał tego folderu dla swoich plików uruchomieniowych:

var awsTmpPath = @"/tmp/";

var awsTmpPath = @"/tmp/";

Integracja IronWord z AWS

Utwórz projekt AWS Lambda

Użyj programu Visual Studio, aby utworzyć projekt AWS Lambda w kontenerze:

Zainstaluj zestaw narzędzi AWS Toolkit dla Visual Studio
Wybierz projekt AWS Lambda (.NET Core - C#)
Wybierz schemat .NET 8 (obraz kontenera) i zakończ konfigurację
Wybierz obraz kontenera jako typ wdrożenia

Dodaj zależności pakietów

Dodaj pakiety IronWord i AWSSDK.S3 do swojego projektu za pośrednictwem NuGet. Biblioteka IronWord działa płynnie na AWS Lambda przy prawidłowej konfiguracji. Uruchom następujące polecenie, aby płynnie zainstalować IronWord w swoim projekcie AWS:

PM > Install-Package IronWord

Install-Package IronWord

Zaktualizuj plik Dockerfile swojego projektu, aby używać obrazu bazowego .NET 8 Lambda, i skopiuj artefakty kompilacji:

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

URUCHOM dnf update -y

WORKDIR /var/task

COPY "bin/Release/lambda-publish"  .

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

URUCHOM dnf update -y

WORKDIR /var/task

COPY "bin/Release/lambda-publish"  .

Text

Modyfikacja kodu FunctionHandler

Poniżej znajduje się przykładowa funkcja Lambda, która tworzy prosty dokument WORD, zapisuje go jako plik .docx i przesyła do zasobnika 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(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 As 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(bucketName As String, objectKey As String, fileBytes As Byte()) As Task
            Using stream As New MemoryStream(fileBytes)
                Dim request As New PutObjectRequest With {
                    .BucketName = bucketName,
                    .Key = objectKey,
                    .InputStream = stream,
                    .ContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
                }
                Await _s3Client.PutObjectAsync(request)
            End Using
        End Function

    End Class

End Namespace

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(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 As 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(bucketName As String, objectKey As String, fileBytes As Byte()) As Task
            Using stream As New MemoryStream(fileBytes)
                Dim request As New PutObjectRequest With {
                    .BucketName = bucketName,
                    .Key = objectKey,
                    .InputStream = stream,
                    .ContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
                }
                Await _s3Client.PutObjectAsync(request)
            End Using
        End Function

    End Class

End Namespace

Zwiększ pamięć i limit czasu

Ponieważ przetwarzanie dokumentów może wymagać dużej ilości pamięci, zwiększ pamięć funkcji Lambda do co najmniej 512 MB, a limit czasu do 300 sekund w pliku aws-lambda-tools-defaults.json:

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

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

JSON

Jeśli napotkasz błędy typu "Runtime exited with error: signal: killed", zwiększ ilość pamięci lub zoptymalizuj kod.

Opublikuj

Aby opublikować swoją funkcję Lambda:

Kliknij prawym przyciskiem myszy swój projekt w Visual Studio
Wybierz opcję "Opublikuj w AWS Lambda..."
Postępuj zgodnie z instrukcjami kreatora i skonfiguruj ustawienia zgodnie z potrzebami

Wypróbuj!

Wywołaj funkcję Lambda za pomocą konsoli AWS Lambda lub programu Visual Studio. Po wykonaniu sprawdź w swoim zasobniku S3 nowo utworzony dokument WORD.

Często Zadawane Pytania

Czym jest IronWord i w jaki sposób może usprawnić przetwarzanie dokumentów WORDa w AWS Lambda?

IronWord to potężne narzędzie do przetwarzania dokumentów WORD, a po zintegrowaniu z AWS Lambda oferuje skalowalne i wydajne zarządzanie dokumentami, umożliwiając automatyzację i usprawnienie zadań związanych z dokumentami WORD.

Jak zintegrować IronWord z AWS Lambda?

Aby zintegrować IronWord z AWS Lambda, należy zainstalować pakiet IronWord w środowisku AWS Lambda, skonfigurować niezbędne uprawnienia oraz wdrożyć kod funkcji wykorzystujący funkcje IronWord do przetwarzania dokumentów.

Jakie są zalety korzystania z IronWord na AWS Lambda?

Korzystanie z IronWord na AWS Lambda pozwala wykorzystać architekturę bezserwerową do przetwarzania dokumentów WORD, zapewniając skalowalność, opłacalność i mniejsze obciążenie związane z zarządzaniem infrastrukturą.

Czy mogę zautomatyzować zadania związane z dokumentami WORDa za pomocą IronWord na AWS Lambda?

Tak, można zautomatyzować różne zadania związane z dokumentami Word, takie jak tworzenie, modyfikowanie i konwersja, korzystając z IronWord w ramach funkcji AWS Lambda.

Czy można obsługiwać duże dokumenty WORDa za pomocą IronWord na AWS Lambda?

IronWord został zaprojektowany do wydajnej obsługi dużych dokumentów WORDa, a w połączeniu z AWS Lambda może przetwarzać dokumenty w sposób skalowalny, w zależności od konfiguracji Lambda.

Jakie operacje na dokumentach WORDa może wykonywać IronWord w AWS Lambda?

IronWord może wykonywać różne operacje na dokumentach Worda, w tym edycję, formatowanie, wyodrębnianie tekstu i konwersję dokumentów do różnych formatów, a wszystko to w środowisku AWS Lambda.

Czy istnieją jakieś wymagania wstępne dotyczące wdrożenia IronWord na AWS Lambda?

Przed wdrożeniem IronWord na AWS Lambda upewnij się, że posiadasz konto AWS, znasz konfigurację AWS Lambda oraz masz skonfigurowane wszelkie niezbędne role i uprawnienia IAM.

W jaki sposób IronWord obsługuje aktualizacje i konserwację w AWS Lambda?

IronWord jest regularnie aktualizowany w celu zapewnienia kompatybilności i poprawy wydajności. W środowisku AWS Lambda można łatwo zaktualizować pakiet wdrożeniowy do najnowszej wersji IronWord, aby zachować optymalną funkcjonalność.

Jakie wsparcie jest dostępne w zakresie korzystania z IronWord z AWS Lambda?

Iron Software zapewnia dokumentację i wsparcie, aby pomóc użytkownikom w integracji i korzystaniu z IronWord na AWS Lambda, gwarantując, że można efektywnie wykorzystać jego możliwości do potrzeb związanych z przetwarzaniem dokumentów.

What should I do if I encounter errors while using IronWord on AWS Lambda?

If you encounter errors like 'Runtime exited with error: signal: killed,' try increasing the memory allocation or optimizing your code for better performance.

Kye Stuart

Czat z zespołem inżynierów teraz

Autor tekstów technicznych

Kye Stuart łączy pasję do kodowania i umiejętność pisania w Iron Software. Ukończył naukę w Yoobee College w zakresie wdrażania oprogramowania, teraz przekształcając złożone koncepcje technologiczne w jasne materiały edukacyjne. Kye ceni sobie ciągłe naukę i chętnie podejmuje nowe wyzwania technologiczne.

...

Czytaj więcej