Jak wykonać OCR dokumentów w AWS Lambda

Updated: 4 czerwca 2026

Ten artykuł instruktażowy zawiera przewodnik krok po kroku dotyczący konfiguracji funkcji AWS Lambda przy użyciu IronOCR. Postępując zgodnie z tym przewodnikiem, dowiesz się, jak skonfigurować IronOCR i efektywnie odczytywać dokumenty przechowywane w zasobniku S3.

Jak wykonać OCR dokumentów w AWS Lambda

Pobierz bibliotekę C# do wykonywania OCR na dokumentach
Utwórz i wybierz szablon projektu
Zmodyfikuj kod FunctionHandler
Skonfiguruj i wdroż projekt
Wywołaj funkcję i sprawdź wyniki w S3

Instalacja

Ten artykuł wykorzystuje kosz S3, więc wymagany jest pakiet AWSSDK.S3.

Jeśli korzystasz z IronOCR ZIP, konieczne jest ustawienie folderu tymczasowego.

// Set temporary folder path and log file path for IronOCR.
var awsTmpPath = @"/tmp/";
IronOcr.Installation.InstallationPath = awsTmpPath;
IronOcr.Installation.LogFilePath = awsTmpPath;

// Set temporary folder path and log file path for IronOCR.
var awsTmpPath = @"/tmp/";
IronOcr.Installation.InstallationPath = awsTmpPath;
IronOcr.Installation.LogFilePath = awsTmpPath;

' Set temporary folder path and log file path for IronOCR.
Dim awsTmpPath As String = "/tmp/"
IronOcr.Installation.InstallationPath = awsTmpPath
IronOcr.Installation.LogFilePath = awsTmpPath

' Set temporary folder path and log file path for IronOCR.
Dim awsTmpPath As String = "/tmp/"
IronOcr.Installation.InstallationPath = awsTmpPath
IronOcr.Installation.LogFilePath = awsTmpPath

Start using IronOCR in your project today with a free trial.

Pierwszy krok:

Utwórz projekt AWS Lambda

Dzięki Visual Studio tworzenie kontenerowej funkcji AWS Lambda jest łatwym procesem:

Zainstaluj zestaw narzędzi AWS Toolkit dla Visual Studio.
Wybierz "Projekt AWS Lambda (.NET Core – C#)".
Wybierz szablon ".NET 8 (obraz kontenera)", a następnie kliknij "Zakończ".

Wybierz obraz kontenera

Dodaj zależności pakietów

Korzystanie z biblioteki IronOCR w .NET 8 nie wymaga instalowania dodatkowych zależności w celu użycia na AWS Lambda. Zmodyfikuj plik Dockerfile projektu, wprowadzając następujące zmiany:

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

# Update all installed packages
RUN dnf update -y

WORKDIR /var/task

# Copy build artifacts from the host machine into the Docker image
COPY "bin/Release/lambda-publish" .

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

# Update all installed packages
RUN dnf update -y

WORKDIR /var/task

# Copy build artifacts from the host machine into the Docker image
COPY "bin/Release/lambda-publish" .

Text

Modyfikacja kodu FunctionHandler

W tym przykładzie pobierany jest obraz z zasobnika S3, przetwarzany, a następnie zapisywany jako plik PDF z możliwością wyszukiwania z powrotem do tego samego zasobnika. Ustawienie folderu tymczasowego jest niezbędne podczas korzystania z IronOCR ZIP, ponieważ biblioteka IronOCR wymaga uprawnień do zapisu w celu skopiowania folderu uruchomieniowego z bibliotek DLL.

using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;
using IronOcr;
using System;
using System.IO;
using System.Threading.Tasks;

// 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 IronOcrZipAwsLambda
{
    public class Function
    {
        // Initialize the S3 client with a specific region endpoint
        private static readonly IAmazonS3 _s3Client = new AmazonS3Client(Amazon.RegionEndpoint.APSoutheast1);

        /// <summary>
        /// Function handler to process OCR on the PDF stored in S3.
        /// </summary>
        /// <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
        public async Task FunctionHandler(ILambdaContext context)
        {
            // Set up necessary paths for IronOCR
            var awsTmpPath = @"/tmp/";
            IronOcr.Installation.InstallationPath = awsTmpPath;
            IronOcr.Installation.LogFilePath = awsTmpPath;

            // Set license key for IronOCR
            IronOcr.License.LicenseKey = "IRONOCR-MYLICENSE-KEY-1EF01";

            string bucketName = "deploymenttestbucket"; // Your bucket name
            string pdfName = "sample";
            string objectKey = $"IronPdfZip/{pdfName}.pdf";
            string objectKeyForSearchablePdf = $"IronPdfZip/{pdfName}-SearchablePdf.pdf";

            try
            {
                // Retrieve the PDF file from S3
                var pdfData = await GetPdfFromS3Async(bucketName, objectKey);

                // Initialize IronTesseract for OCR processing
                IronTesseract ironTesseract = new IronTesseract();
                OcrInput ocrInput = new OcrInput();
                ocrInput.LoadPdf(pdfData);
                OcrResult result = ironTesseract.Read(ocrInput);

                // Log the OCR result
                context.Logger.LogLine($"OCR result: {result.Text}");

                // Upload the searchable PDF to S3
                await UploadPdfToS3Async(bucketName, objectKeyForSearchablePdf, result.SaveAsSearchablePdfBytes());
                context.Logger.LogLine($"PDF uploaded successfully to {bucketName}/{objectKeyForSearchablePdf}");
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}");
            }
        }

        /// <summary>
        /// Retrieves a PDF from S3 and returns it as a byte array.
        /// </summary>
        private async Task<byte[]> GetPdfFromS3Async(string bucketName, string objectKey)
        {
            var request = new GetObjectRequest
            {
                BucketName = bucketName,
                Key = objectKey
            };

            using (var response = await _s3Client.GetObjectAsync(request))
            using (var memoryStream = new MemoryStream())
            {
                await response.ResponseStream.CopyToAsync(memoryStream);
                return memoryStream.ToArray();
            }
        }

        /// <summary>
        /// Uploads the generated searchable PDF back to S3.
        /// </summary>
        private async Task UploadPdfToS3Async(string bucketName, string objectKey, byte[] pdfBytes)
        {
            using (var memoryStream = new MemoryStream(pdfBytes))
            {
                var request = new PutObjectRequest
                {
                    BucketName = bucketName,
                    Key = objectKey,
                    InputStream = memoryStream,
                    ContentType = "application/pdf"
                };

                await _s3Client.PutObjectAsync(request);
            }
        }
    }
}

using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;
using IronOcr;
using System;
using System.IO;
using System.Threading.Tasks;

// 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 IronOcrZipAwsLambda
{
    public class Function
    {
        // Initialize the S3 client with a specific region endpoint
        private static readonly IAmazonS3 _s3Client = new AmazonS3Client(Amazon.RegionEndpoint.APSoutheast1);

        /// <summary>
        /// Function handler to process OCR on the PDF stored in S3.
        /// </summary>
        /// <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
        public async Task FunctionHandler(ILambdaContext context)
        {
            // Set up necessary paths for IronOCR
            var awsTmpPath = @"/tmp/";
            IronOcr.Installation.InstallationPath = awsTmpPath;
            IronOcr.Installation.LogFilePath = awsTmpPath;

            // Set license key for IronOCR
            IronOcr.License.LicenseKey = "IRONOCR-MYLICENSE-KEY-1EF01";

            string bucketName = "deploymenttestbucket"; // Your bucket name
            string pdfName = "sample";
            string objectKey = $"IronPdfZip/{pdfName}.pdf";
            string objectKeyForSearchablePdf = $"IronPdfZip/{pdfName}-SearchablePdf.pdf";

            try
            {
                // Retrieve the PDF file from S3
                var pdfData = await GetPdfFromS3Async(bucketName, objectKey);

                // Initialize IronTesseract for OCR processing
                IronTesseract ironTesseract = new IronTesseract();
                OcrInput ocrInput = new OcrInput();
                ocrInput.LoadPdf(pdfData);
                OcrResult result = ironTesseract.Read(ocrInput);

                // Log the OCR result
                context.Logger.LogLine($"OCR result: {result.Text}");

                // Upload the searchable PDF to S3
                await UploadPdfToS3Async(bucketName, objectKeyForSearchablePdf, result.SaveAsSearchablePdfBytes());
                context.Logger.LogLine($"PDF uploaded successfully to {bucketName}/{objectKeyForSearchablePdf}");
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}");
            }
        }

        /// <summary>
        /// Retrieves a PDF from S3 and returns it as a byte array.
        /// </summary>
        private async Task<byte[]> GetPdfFromS3Async(string bucketName, string objectKey)
        {
            var request = new GetObjectRequest
            {
                BucketName = bucketName,
                Key = objectKey
            };

            using (var response = await _s3Client.GetObjectAsync(request))
            using (var memoryStream = new MemoryStream())
            {
                await response.ResponseStream.CopyToAsync(memoryStream);
                return memoryStream.ToArray();
            }
        }

        /// <summary>
        /// Uploads the generated searchable PDF back to S3.
        /// </summary>
        private async Task UploadPdfToS3Async(string bucketName, string objectKey, byte[] pdfBytes)
        {
            using (var memoryStream = new MemoryStream(pdfBytes))
            {
                var request = new PutObjectRequest
                {
                    BucketName = bucketName,
                    Key = objectKey,
                    InputStream = memoryStream,
                    ContentType = "application/pdf"
                };

                await _s3Client.PutObjectAsync(request);
            }
        }
    }
}

Imports Amazon.Lambda.Core
Imports Amazon.S3
Imports Amazon.S3.Model
Imports IronOcr
Imports System
Imports System.IO
Imports System.Threading.Tasks

' 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 IronOcrZipAwsLambda
	Public Class [Function]
		' Initialize the S3 client with a specific region endpoint
		Private Shared ReadOnly _s3Client As IAmazonS3 = New AmazonS3Client(Amazon.RegionEndpoint.APSoutheast1)

		''' <summary>
		''' Function handler to process OCR on the PDF stored in S3.
		''' </summary>
		''' <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
		Public Async Function FunctionHandler(ByVal context As ILambdaContext) As Task
			' Set up necessary paths for IronOCR
			Dim awsTmpPath = "/tmp/"
			IronOcr.Installation.InstallationPath = awsTmpPath
			IronOcr.Installation.LogFilePath = awsTmpPath

			' Set license key for IronOCR
			IronOcr.License.LicenseKey = "IRONOCR-MYLICENSE-KEY-1EF01"

			Dim bucketName As String = "deploymenttestbucket" ' Your bucket name
			Dim pdfName As String = "sample"
			Dim objectKey As String = $"IronPdfZip/{pdfName}.pdf"
			Dim objectKeyForSearchablePdf As String = $"IronPdfZip/{pdfName}-SearchablePdf.pdf"

			Try
				' Retrieve the PDF file from S3
				Dim pdfData = Await GetPdfFromS3Async(bucketName, objectKey)

				' Initialize IronTesseract for OCR processing
				Dim ironTesseract As New IronTesseract()
				Dim ocrInput As New OcrInput()
				ocrInput.LoadPdf(pdfData)
				Dim result As OcrResult = ironTesseract.Read(ocrInput)

				' Log the OCR result
				context.Logger.LogLine($"OCR result: {result.Text}")

				' Upload the searchable PDF to S3
				Await UploadPdfToS3Async(bucketName, objectKeyForSearchablePdf, result.SaveAsSearchablePdfBytes())
				context.Logger.LogLine($"PDF uploaded successfully to {bucketName}/{objectKeyForSearchablePdf}")
			Catch e As Exception
				context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}")
			End Try
		End Function

		''' <summary>
		''' Retrieves a PDF from S3 and returns it as a byte array.
		''' </summary>
		Private Async Function GetPdfFromS3Async(ByVal bucketName As String, ByVal objectKey As String) As Task(Of Byte())
			Dim request = New GetObjectRequest With {
				.BucketName = bucketName,
				.Key = objectKey
			}

			Using response = Await _s3Client.GetObjectAsync(request)
			Using memoryStream As New MemoryStream()
				Await response.ResponseStream.CopyToAsync(memoryStream)
				Return memoryStream.ToArray()
			End Using
			End Using
		End Function

		''' <summary>
		''' Uploads the generated searchable PDF back to S3.
		''' </summary>
		Private Async Function UploadPdfToS3Async(ByVal bucketName As String, ByVal objectKey As String, ByVal pdfBytes() As Byte) As Task
			Using memoryStream As New MemoryStream(pdfBytes)
				Dim request = New PutObjectRequest With {
					.BucketName = bucketName,
					.Key = objectKey,
					.InputStream = memoryStream,
					.ContentType = "application/pdf"
				}

				Await _s3Client.PutObjectAsync(request)
			End Using
		End Function
	End Class
End Namespace

Imports Amazon.Lambda.Core
Imports Amazon.S3
Imports Amazon.S3.Model
Imports IronOcr
Imports System
Imports System.IO
Imports System.Threading.Tasks

' 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 IronOcrZipAwsLambda
	Public Class [Function]
		' Initialize the S3 client with a specific region endpoint
		Private Shared ReadOnly _s3Client As IAmazonS3 = New AmazonS3Client(Amazon.RegionEndpoint.APSoutheast1)

		''' <summary>
		''' Function handler to process OCR on the PDF stored in S3.
		''' </summary>
		''' <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
		Public Async Function FunctionHandler(ByVal context As ILambdaContext) As Task
			' Set up necessary paths for IronOCR
			Dim awsTmpPath = "/tmp/"
			IronOcr.Installation.InstallationPath = awsTmpPath
			IronOcr.Installation.LogFilePath = awsTmpPath

			' Set license key for IronOCR
			IronOcr.License.LicenseKey = "IRONOCR-MYLICENSE-KEY-1EF01"

			Dim bucketName As String = "deploymenttestbucket" ' Your bucket name
			Dim pdfName As String = "sample"
			Dim objectKey As String = $"IronPdfZip/{pdfName}.pdf"
			Dim objectKeyForSearchablePdf As String = $"IronPdfZip/{pdfName}-SearchablePdf.pdf"

			Try
				' Retrieve the PDF file from S3
				Dim pdfData = Await GetPdfFromS3Async(bucketName, objectKey)

				' Initialize IronTesseract for OCR processing
				Dim ironTesseract As New IronTesseract()
				Dim ocrInput As New OcrInput()
				ocrInput.LoadPdf(pdfData)
				Dim result As OcrResult = ironTesseract.Read(ocrInput)

				' Log the OCR result
				context.Logger.LogLine($"OCR result: {result.Text}")

				' Upload the searchable PDF to S3
				Await UploadPdfToS3Async(bucketName, objectKeyForSearchablePdf, result.SaveAsSearchablePdfBytes())
				context.Logger.LogLine($"PDF uploaded successfully to {bucketName}/{objectKeyForSearchablePdf}")
			Catch e As Exception
				context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}")
			End Try
		End Function

		''' <summary>
		''' Retrieves a PDF from S3 and returns it as a byte array.
		''' </summary>
		Private Async Function GetPdfFromS3Async(ByVal bucketName As String, ByVal objectKey As String) As Task(Of Byte())
			Dim request = New GetObjectRequest With {
				.BucketName = bucketName,
				.Key = objectKey
			}

			Using response = Await _s3Client.GetObjectAsync(request)
			Using memoryStream As New MemoryStream()
				Await response.ResponseStream.CopyToAsync(memoryStream)
				Return memoryStream.ToArray()
			End Using
			End Using
		End Function

		''' <summary>
		''' Uploads the generated searchable PDF back to S3.
		''' </summary>
		Private Async Function UploadPdfToS3Async(ByVal bucketName As String, ByVal objectKey As String, ByVal pdfBytes() As Byte) As Task
			Using memoryStream As New MemoryStream(pdfBytes)
				Dim request = New PutObjectRequest With {
					.BucketName = bucketName,
					.Key = objectKey,
					.InputStream = memoryStream,
					.ContentType = "application/pdf"
				}

				Await _s3Client.PutObjectAsync(request)
			End Using
		End Function
	End Class
End Namespace

Przed blokiem try plik "sample.pdf" jest określony do odczytu z katalogu IronPdfZip. Nastepnie metoda GetPdfFromS3Async jest uzywana do pobrania bajtow PDF, ktory jest przekazywany do metody LoadPdf.

Zwiększ pamięć i limit czasu

Ilość pamięci przydzielonej w funkcji Lambda będzie się różnić w zależności od rozmiaru przetwarzanych dokumentów i liczby dokumentów przetwarzanych jednocześnie. Jako wartosc bazowa ustaw pamiec na 512 MB i limit czasu na 300 sekund w aws-lambda-tools-defaults.json.

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

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

JSON

Gdy pamięć jest niewystarczająca, program wyświetli błąd: "Runtime zakończył działanie z błędem: sygnał: zabity". Zwiększenie rozmiaru pamięci może rozwiązać ten problem. Więcej szczegółów można znaleźć w artykułe dotyczącym rozwiązywania problemów: AWS Lambda — sygnał zakończenia działania środowiska uruchomieniowego: Killed.

Opublikuj

Aby opublikować w Visual Studio, kliknij prawym przyciskiem myszy na projekt i wybierz "Publish to AWS Lambda...", a następnie skonfiguruj niezbędne ustawienia. Więcej informacji na temat publikowania funkcji Lambda można znaleźć na stronie internetowej AWS.

Wypróbuj!

Funkcję Lambda można aktywować za pomocą konsoli Lambda lub programu Visual Studio.

Często Zadawane Pytania

Jak mogę przeprowadzić OCR na dokumentach w AWS przy użyciu języka C#?

Możesz użyć IronOCR do przeprowadzenia OCR na dokumentach przechowywanych w zasobnikach Amazon S3, integrując go z AWS Lambda. Wymaga to utworzenia funkcji Lambda w języku C#, która pobiera dokumenty z S3, przetwarza je za pomocą IronOCR, a następnie przesyła wyniki z powrotem do S3.

Jakie kroki trzeba wykonać, żeby skonfigurować OCR na AWS Lambda w języku C#?

Aby skonfigurować OCR w AWS Lambda przy użyciu języka C#, należy pobrać bibliotekę IronOCR, utworzyć projekt AWS Lambda w Visual Studio, skonfigurować moduł obsługi funkcji tak, aby wykorzystywał IronOCR do przetwarzania, a następnie wdrożyć funkcję. Taka konfiguracja pozwala na konwersję obrazów do plików PDF z możliwością wyszukiwania.

Jaka jest zalecana konfiguracja do uruchamiania OCR w AWS Lambda?

Aby uzyskać optymalną wydajność podczas uruchamiania OCR za pomocą IronOCR w AWS Lambda, zaleca się ustawienie przydziału pamięci na co najmniej 512 MB oraz limitu czasu na 300 sekund. Te ustawienia pomagają w zarządzaniu przetwarzaniem dużych lub wielu dokumentów.

Jak poradzić sobie z komunikatem „Runtime exited with error: signal: killed” w AWS Lambda?

Ten błąd często oznacza, że funkcja Lambda wyczerpała przydzieloną jej pamięć. Zwiększenie przydziału pamięci w konfiguracji funkcji Lambda może rozwiązać ten problem, zwłaszcza podczas przetwarzania dużych dokumentów za pomocą IronOCR.

Czy mogę przetestować lokalnie moją funkcję OCR AWS Lambda przed wdrożeniem?

Tak, możesz przetestować swoją funkcję OCR AWS Lambda lokalnie, korzystając z zestawu narzędzi AWS Toolkit for Visual Studio. Zestaw ten zapewnia lokalne środowisko do symulacji wykonywania funkcji Lambda, umożliwiając debugowanie i udoskonalanie funkcji przed wdrożeniem.

Jaki jest cel pliku Dockerfile w projekcie AWS Lambda?

Plik Dockerfile w projekcie AWS Lambda służy do tworzenia obrazu kontenera, który definiuje środowisko wykonawcze i zależności dla funkcji Lambda. Dzięki temu funkcja posiada wszystkie komponenty niezbędne do prawidłowego działania w AWS.

Czy potrzebuję dodatkowych zależności, aby korzystać z IronOCR w .NET 8 na AWS Lambda?

Podczas korzystania z .NET 8 na AWS Lambda nie są wymagane żadne dodatkowe zależności poza biblioteką IronOCR i niezbędnymi pakietami AWS SDK. Upraszcza to proces integracji w celu wykonywania zadań OCR.

Jakie są warunki wstępne integracji C# OCR z AWS Lambda?

Przed zintegrowaniem C# OCR z AWS Lambda należy zainstalować AWS SDK dla S3, bibliotekę IronOCR oraz AWS Toolkit dla Visual Studio. Potrzebny będzie również skonfigurowany zasób S3 do przechowywania i pobierania dokumentów.

How do I log OCR results in an AWS Lambda function using IronOCR?

In your AWS Lambda function, use the Lambda context's `Logger.LogLine` method to log OCR results. This allows you to track and verify the OCR output processed by IronOCR.

Is it necessary to install additional dependencies for IronOCR in .NET 8 when deploying to AWS Lambda?

No additional dependencies are required for utilizing the IronOCR library in a .NET 8 AWS Lambda project, aside from setting the correct paths and configuring necessary packages like AWSSDK.S3 for S3 operations.

Curtis Chau

Czat z zespołem inżynierów teraz

Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.

...

Czytaj więcej