Comment lire et écrire des codes-barres sur AWS Lambda

Q: Comment puis-je modifier le code du FunctionHandler dans AWS Lambda pour les tâches de codes-barres ?

Modifiez le code du FunctionHandler pour créer et lire des codes-barres en utilisant IronBarcode. Assurez-vous de définir la clé de licence IronBarcode et de configurer le dossier temporaire pour le bon fonctionnement des fichiers ZIP d'IronBarcode.

Curtis Chau

Updated: 4 juin 2026

Cet article indique comment configurer une fonction AWS Lambda en utilisant IronBarcode. Dans ce guide, vous apprendrez à configurer IronBarcode pour lire et écrire des codes-barres vers un compartiment S3.

Comment lire et écrire des codes-barres sur AWS Lambda

Téléchargez une bibliothèque C# pour lire et écrire des codes-barres
Créer et choisir le modèle de projet
Modifier le code du FunctionHandler
Configurer et déployer le projet
Invoquer la fonction et vérifier les résultats dans S3

Installation

Cet article utilisera un compartiment S3, donc le package AWSSDK.S3 est requis.

Utiliser IronBarcode Zip

Si vous utilisez IronBarcode ZIP, il est essentiel de définir le dossier temporaire.

var awsTmpPath = @"/tmp/";
IronBarCode.Installation.DeploymentPath = awsTmpPath;

var awsTmpPath = @"/tmp/";
IronBarCode.Installation.DeploymentPath = awsTmpPath;

Dim awsTmpPath = "/tmp/"
IronBarCode.Installation.DeploymentPath = awsTmpPath

Dim awsTmpPath = "/tmp/"
IronBarCode.Installation.DeploymentPath = awsTmpPath

Le package Microsoft.ML.OnnxRuntime est requis pour lire les codes-barres. Bien que l'écriture de codes-barres fonctionne sans cela, le mode par défaut pour la lecture repose sur le machine learning (ML). Si vous passez à un mode de lecture qui ne nécessite pas de ML, le package n'est pas nécessaire.

Créer un projet AWS Lambda

Avec Visual Studio, créer un AWS Lambda containerisé est un processus simple :

Installer le AWS Toolkit pour Visual Studio
Sélectionnez un 'Projet AWS Lambda (.NET Core - C#)'
Sélectionnez un modèle '.NET 8 (Image de Conteneur)', puis sélectionnez 'Terminer'.

Sélectionnez l'image du conteneur

Ajouter des dépendances de package

La bibliothèque IronBarcode dans .NET 8 fonctionne sur AWS Lambda sans nécessiter de dépendances supplémentaires. Pour l'installer, mettez à jour le fichier Docker du projet comme suit :

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

# Install necessary packages
RUN dnf update -y

WORKDIR /var/task

# This COPY command copies the .NET Lambda project's build artifacts from the host machine into the image. 
# The source of the COPY should match where the .NET Lambda project publishes its build artifacts. If the Lambda function is being built 
# with the AWS .NET Lambda Tooling, the `--docker-host-build-output-dir` switch controls where the .NET Lambda project
# will be built. The .NET Lambda project templates default to having `--docker-host-build-output-dir`
# set in the aws-lambda-tools-defaults.json file to "bin/Release/lambda-publish".
#
# Alternatively Docker multi-stage build could be used to build the .NET Lambda project inside the image.
# For more information on this approach check out the project's README.md file.
COPY "bin/Release/lambda-publish"  .

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

# Install necessary packages
RUN dnf update -y

WORKDIR /var/task

# This COPY command copies the .NET Lambda project's build artifacts from the host machine into the image. 
# The source of the COPY should match where the .NET Lambda project publishes its build artifacts. If the Lambda function is being built 
# with the AWS .NET Lambda Tooling, the `--docker-host-build-output-dir` switch controls where the .NET Lambda project
# will be built. The .NET Lambda project templates default to having `--docker-host-build-output-dir`
# set in the aws-lambda-tools-defaults.json file to "bin/Release/lambda-publish".
#
# Alternatively Docker multi-stage build could be used to build the .NET Lambda project inside the image.
# For more information on this approach check out the project's README.md file.
COPY "bin/Release/lambda-publish"  .

Text

Modifier le code de FunctionHandler

Cet exemple génère un code-barres EAN8, le télécharge vers un compartiment S3 et lit le code-barres nouvellement créé. Lors de l'utilisation d'IronBarcode ZIP, il est crucial de configurer le dossier temporaire car la bibliothèque a besoin de permissions d'écriture pour copier le dossier runtime à partir des DLLs.

using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;
using IronBarCode;

// 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 IronBarcodeZipAwsLambda;

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

    /// <summary>
    /// AWS Lambda Function Handler. It generates a barcode, uploads it to S3, and then reads it.
    /// </summary>
    /// <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
    public async Task FunctionHandler(ILambdaContext context)
    {
        var awsTmpPath = @"/tmp/";
        IronBarCode.Installation.DeploymentPath = awsTmpPath;

        // Set your IronBarcode license key here
        IronBarCode.License.LicenseKey = "IRONBARCODE-MYLICENSE-KEY-1EF01";

        string filename = Guid.NewGuid().ToString();
        string bucketName = "deploymenttestbucket";
        string objectKey = $"IronBarcodeZip/{filename}.png";

        try
        {
            // Creating a barcode with EAN8 encoding
            var myBarcode = BarcodeWriter.CreateBarcode("1212345", BarcodeWriterEncoding.EAN8);

            context.Logger.LogLine($"Barcode created.");

            // Upload the PNG image of the barcode to the specified S3 bucket
            await UploadPngToS3Async(bucketName, objectKey, myBarcode.ToPngBinaryData());
            context.Logger.LogLine($"Barcode uploaded successfully to {bucketName}/{objectKey}");

            // Read and log the barcode value from the PNG binary data
            var resultFromByte = BarcodeReader.Read(myBarcode.ToPngBinaryData());
            foreach (var item in resultFromByte)
            {
                context.Logger.LogLine($"Barcode value is = {item.Value}");
            }
        }
        catch (Exception e)
        {
            context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}");
        }
    }

    /// <summary>
    /// Uploads a PNG byte array to the specified S3 bucket.
    /// </summary>
    /// <param name="bucketName">The name of the S3 bucket.</param>
    /// <param name="objectKey">The object key for the uploaded file in the bucket.</param>
    /// <param name="pdfBytes">Byte array of the PNG to be uploaded.</param>
    private async Task UploadPngToS3Async(string bucketName, string objectKey, byte[] pdfBytes)
    {
        using (var memoryStream = new MemoryStream(pdfBytes))
        {
            var request = new PutObjectRequest
            {
                BucketName = bucketName,
                Key = objectKey,
                InputStream = memoryStream,
                ContentType = "image/png",
            };

            await _s3Client.PutObjectAsync(request);
        }
    }
}

using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;
using IronBarCode;

// 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 IronBarcodeZipAwsLambda;

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

    /// <summary>
    /// AWS Lambda Function Handler. It generates a barcode, uploads it to S3, and then reads it.
    /// </summary>
    /// <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
    public async Task FunctionHandler(ILambdaContext context)
    {
        var awsTmpPath = @"/tmp/";
        IronBarCode.Installation.DeploymentPath = awsTmpPath;

        // Set your IronBarcode license key here
        IronBarCode.License.LicenseKey = "IRONBARCODE-MYLICENSE-KEY-1EF01";

        string filename = Guid.NewGuid().ToString();
        string bucketName = "deploymenttestbucket";
        string objectKey = $"IronBarcodeZip/{filename}.png";

        try
        {
            // Creating a barcode with EAN8 encoding
            var myBarcode = BarcodeWriter.CreateBarcode("1212345", BarcodeWriterEncoding.EAN8);

            context.Logger.LogLine($"Barcode created.");

            // Upload the PNG image of the barcode to the specified S3 bucket
            await UploadPngToS3Async(bucketName, objectKey, myBarcode.ToPngBinaryData());
            context.Logger.LogLine($"Barcode uploaded successfully to {bucketName}/{objectKey}");

            // Read and log the barcode value from the PNG binary data
            var resultFromByte = BarcodeReader.Read(myBarcode.ToPngBinaryData());
            foreach (var item in resultFromByte)
            {
                context.Logger.LogLine($"Barcode value is = {item.Value}");
            }
        }
        catch (Exception e)
        {
            context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}");
        }
    }

    /// <summary>
    /// Uploads a PNG byte array to the specified S3 bucket.
    /// </summary>
    /// <param name="bucketName">The name of the S3 bucket.</param>
    /// <param name="objectKey">The object key for the uploaded file in the bucket.</param>
    /// <param name="pdfBytes">Byte array of the PNG to be uploaded.</param>
    private async Task UploadPngToS3Async(string bucketName, string objectKey, byte[] pdfBytes)
    {
        using (var memoryStream = new MemoryStream(pdfBytes))
        {
            var request = new PutObjectRequest
            {
                BucketName = bucketName,
                Key = objectKey,
                InputStream = memoryStream,
                ContentType = "image/png",
            };

            await _s3Client.PutObjectAsync(request);
        }
    }
}

Imports Amazon.Lambda.Core
Imports Amazon.S3
Imports Amazon.S3.Model
Imports IronBarCode

' 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 IronBarcodeZipAwsLambda

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

		''' <summary>
		''' AWS Lambda Function Handler. It generates a barcode, uploads it to S3, and then reads it.
		''' </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
			Dim awsTmpPath = "/tmp/"
			IronBarCode.Installation.DeploymentPath = awsTmpPath

			' Set your IronBarcode license key here
			IronBarCode.License.LicenseKey = "IRONBARCODE-MYLICENSE-KEY-1EF01"

			Dim filename As String = Guid.NewGuid().ToString()
			Dim bucketName As String = "deploymenttestbucket"
			Dim objectKey As String = $"IronBarcodeZip/{filename}.png"

			Try
				' Creating a barcode with EAN8 encoding
				Dim myBarcode = BarcodeWriter.CreateBarcode("1212345", BarcodeWriterEncoding.EAN8)

				context.Logger.LogLine($"Barcode created.")

				' Upload the PNG image of the barcode to the specified S3 bucket
				Await UploadPngToS3Async(bucketName, objectKey, myBarcode.ToPngBinaryData())
				context.Logger.LogLine($"Barcode uploaded successfully to {bucketName}/{objectKey}")

				' Read and log the barcode value from the PNG binary data
				Dim resultFromByte = BarcodeReader.Read(myBarcode.ToPngBinaryData())
				For Each item In resultFromByte
					context.Logger.LogLine($"Barcode value is = {item.Value}")
				Next item
			Catch e As Exception
				context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}")
			End Try
		End Function

		''' <summary>
		''' Uploads a PNG byte array to the specified S3 bucket.
		''' </summary>
		''' <param name="bucketName">The name of the S3 bucket.</param>
		''' <param name="objectKey">The object key for the uploaded file in the bucket.</param>
		''' <param name="pdfBytes">Byte array of the PNG to be uploaded.</param>
		Private Async Function UploadPngToS3Async(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 = "image/png"
				}

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

Imports Amazon.Lambda.Core
Imports Amazon.S3
Imports Amazon.S3.Model
Imports IronBarCode

' 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 IronBarcodeZipAwsLambda

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

		''' <summary>
		''' AWS Lambda Function Handler. It generates a barcode, uploads it to S3, and then reads it.
		''' </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
			Dim awsTmpPath = "/tmp/"
			IronBarCode.Installation.DeploymentPath = awsTmpPath

			' Set your IronBarcode license key here
			IronBarCode.License.LicenseKey = "IRONBARCODE-MYLICENSE-KEY-1EF01"

			Dim filename As String = Guid.NewGuid().ToString()
			Dim bucketName As String = "deploymenttestbucket"
			Dim objectKey As String = $"IronBarcodeZip/{filename}.png"

			Try
				' Creating a barcode with EAN8 encoding
				Dim myBarcode = BarcodeWriter.CreateBarcode("1212345", BarcodeWriterEncoding.EAN8)

				context.Logger.LogLine($"Barcode created.")

				' Upload the PNG image of the barcode to the specified S3 bucket
				Await UploadPngToS3Async(bucketName, objectKey, myBarcode.ToPngBinaryData())
				context.Logger.LogLine($"Barcode uploaded successfully to {bucketName}/{objectKey}")

				' Read and log the barcode value from the PNG binary data
				Dim resultFromByte = BarcodeReader.Read(myBarcode.ToPngBinaryData())
				For Each item In resultFromByte
					context.Logger.LogLine($"Barcode value is = {item.Value}")
				Next item
			Catch e As Exception
				context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}")
			End Try
		End Function

		''' <summary>
		''' Uploads a PNG byte array to the specified S3 bucket.
		''' </summary>
		''' <param name="bucketName">The name of the S3 bucket.</param>
		''' <param name="objectKey">The object key for the uploaded file in the bucket.</param>
		''' <param name="pdfBytes">Byte array of the PNG to be uploaded.</param>
		Private Async Function UploadPngToS3Async(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 = "image/png"
				}

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

Avant le bloc try, la destination du fichier est définie sur le répertoire IronBarcodeZip, avec un nom généré comme un identifiant unique global (GUID). La méthode CreateBarcode est utilisée pour générer le code-barres. Ensuite, le tableau d'octets PNG est passé à la méthode Read pour lire le code-barres. Cela démontre que la fonction AWS Lambda est capable de lire des codes-barres.

La méthode Read accepte également un objet BarcodeReaderOptions, que vous pouvez personnaliser pour activer des fonctionnalités telles que la lecture de plusieurs codes-barres, le ciblage de zones spécifiques, l'utilisation du traitement asynchrone et multithread, l'application de filtres de correction d'image, et bien plus.

Augmenter la mémoire et le délai d'expiration

La quantité de mémoire allouée dans la fonction Lambda variera en fonction de la taille des documents traités et du nombre de documents traités simultanément. En standard, réglez la mémoire à 512 Mo et le délai d'attente à 300 secondes dans aws-lambda-tools-defaults.json.

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

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

JSON

Lorsque la mémoire est insuffisante, le programme génère l'erreur : 'Runtime exited with error: signal: killed.' Augmenter la taille de la mémoire peut résoudre ce problème. Pour plus de détails, consultez l'article de dépannage : AWS Lambda - Runtime Exited Signal: Killed.

Publier

Pour publier dans Visual Studio, cliquez avec le bouton droit sur le projet et sélectionnez 'Publier sur AWS Lambda...', puis configurez les paramètres nécessaires. Pour en savoir plus sur la publication d'une Lambda, visitez le site AWS.

Essayez-le!

Vous pouvez activer la fonction Lambda soit via la console Lambda soit via Visual Studio.

Questions Fréquemment Posées

Comment configurer la lecture et l'écriture de codes-barres sur AWS Lambda ?

Pour configurer la lecture et l'écriture de codes-barres sur AWS Lambda, utilisez la bibliothèque IronBarcode en la téléchargeant et en créant un projet AWS Lambda avec Visual Studio. Modifiez le code du FunctionHandler pour gérer les opérations de codes-barres, configurez les paramètres du projet et déployez-le. Assurez-vous que les dépendances de package nécessaires, comme AWSSDK.S3, sont incluses.

Quels packages sont requis pour le traitement des codes-barres sur AWS Lambda ?

Pour le traitement des codes-barres sur AWS Lambda, incluez le package AWSSDK.S3 pour les interactions S3 et éventuellement le package Microsoft.ML.OnnxRuntime pour la lecture avancée de codes-barres avec apprentissage automatique, ce qui peut ne pas être nécessaire si vous utilisez des méthodes standard de lecture de codes-barres.

Comment puis-je modifier le code du FunctionHandler dans AWS Lambda pour les tâches de codes-barres ?

Modifiez le code du FunctionHandler pour créer et lire des codes-barres en utilisant IronBarcode. Assurez-vous de définir la clé de licence IronBarcode et de configurer le dossier temporaire pour le bon fonctionnement des fichiers ZIP d'IronBarcode.

Comment augmenter la mémoire et le délai d'attente pour une fonction AWS Lambda traitant des codes-barres ?

Ajustez les paramètres de mémoire et de délai d'attente dans le fichier aws-lambda-tools-defaults.json en définissant la taille de la mémoire de la fonction sur 512 Mo et le délai d'expiration sur 300 secondes pour répondre aux besoins de traitement des codes-barres avec IronBarcode.

Comment publier une fonction Lambda en utilisant Visual Studio pour le traitement des codes-barres ?

Publiez la fonction Lambda en cliquant avec le bouton droit sur le projet dans Visual Studio, en sélectionnant 'Publier vers AWS Lambda...' et en configurant les paramètres. Suivez la documentation AWS pour les étapes détaillées, en vous assurant qu'IronBarcode est correctement configuré.

Comment puis-je tester la fonction AWS Lambda déployée pour les opérations de codes-barres ?

Testez la fonction Lambda en l'activant via la console AWS Lambda ou directement depuis Visual Studio, en vous assurant qu'IronBarcode fonctionne correctement et que les tâches de traitement des codes-barres sont effectuées comme prévu.

Quel est le rôle du Dockerfile dans la configuration du traitement des codes-barres sur AWS Lambda ?

Le Dockerfile aide à mettre à jour les packages nécessaires et à copier les artefacts de construction du projet .NET Lambda dans l'image, facilitant ainsi le traitement fluide des codes-barres avec IronBarcode sur AWS Lambda.

Pourquoi est-il important de définir le dossier temporaire lors de l'utilisation de bibliothèques de codes-barres sur AWS Lambda ?

Définir le dossier temporaire est essentiel car IronBarcode nécessite des droits d'écriture pour l'opération ZIP, garantissant que les dossiers d'exécution sont correctement copiés depuis les DLLs pour une opération fluide sur AWS Lambda.

Puis-je personnaliser la lecture des codes-barres sur AWS Lambda ?

Oui, IronBarcode permet la personnalisation de la lecture des codes-barres en utilisant BarcodeReaderOptions, ce qui inclut la lecture de plusieurs codes-barres, le ciblage de zones spécifiques, l'activation du traitement asynchrone et l'application de filtres de correction d'image.

Que dois-je faire si je rencontre l'erreur 'Runtime exited with error: signal: killed' pendant le traitement des codes-barres ?

Cette erreur suggère une allocation de mémoire insuffisante. Augmentez la mémoire de la fonction Lambda dans le fichier aws-lambda-tools-defaults.json pour résoudre le problème lors de l'utilisation d'IronBarcode.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.

...