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

Translated

View the article in English

Cet article pratique fournit un guide complet pour configurer une fonction AWS Lambda à l'aide d'IronBarcode. Dans ce guide, vous apprendrez à configurer IronBarcode pour lire et écrire des codes-barres dans 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éez et choisissez le modèle de projet
Modifier le code de 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 AWSSDK.S3 package est requis.

Utilisation d'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

VB C#

Les Microsoft.ML.OnnxRuntime package est requis pour la lecture des codes-barres. Bien que l'écriture de codes-barres fonctionne bien sans cela, le mode par défaut pour la lecture repose sur l'apprentissage automatique.(ML). Si vous passez à un mode de lecture qui n'utilise pas le ML, le package n'est pas nécessaire.

Commencez à utiliser IronBarcode dans votre projet dès aujourd'hui avec un essai gratuit.

Première étape :

Créer un projet AWS Lambda

Avec Visual Studio, créer une AWS Lambda conteneurisée est un processus facile :

Installer leAWS Toolkit pour Visual Studio
Sélectionnez un 'Projet AWS Lambda(.NET Core - C#)'
Sélectionner un '.NET 8(Image de conteneur)'plan, puis sélectionnez 'Terminer'.

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 le configurer, mettez à jour le fichier Dockerfile du projet comme suit :


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

# installer les paquets nécessaires

RUN dnf update -y

WORKDIR /var/task

# Cette commande COPY copie les artefacts de build du projet Lambda .NET de la machine hôte dans l'image.

# La source du COPY doit correspondre à l'endroit où le projet .NET Lambda publie ses artefacts de construction.

Si la fonction Lambda est en cours de construction

# avec l'outil AWS .NET Lambda, le commutateur `--docker-host-build-output-dir` contrôle où le projet .NET Lambda

# sera construit.

Les modèles de projet Lambda .NET par défaut ont `--docker-host-build-output-dir`.

# définir dans le fichier aws-lambda-tools-defaults.json à "bin/Release/lambda-publish".

#

# Alternativement, une construction multistage Docker pourrait être utilisée pour construire le projet .NET Lambda à l'intérieur de l'image.

# Pour plus d'informations sur cette approche, consultez le fichier README.md du projet.

COPY "bin/Release/lambda-publish" .

Modifier le code FunctionHandler

Cet exemple génère un code-barres EAN8, le télécharge dans un bucket S3 et lit le code-barres nouvellement créé. Lors de l'utilisation d'IronBarcode ZIP, configurer le dossier temporaire est crucial car la bibliothèque nécessite des autorisations d'écriture pour copier le dossier d'exécution depuis les 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);

    /// <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
    /// <returns></returns>
    public async Task FunctionHandler(ILambdaContext context)
    {
        var awsTmpPath = @"/tmp/";
        IronBarCode.Installation.DeploymentPath = awsTmpPath;

        IronBarCode.License.LicenseKey = "IRONBARCODE-MYLICENSE-KEY-1EF01";

        string filename = Guid.NewGuid().ToString();

        string bucketName = "deploymenttestbucket";
        string objectKey = $"IronBarcodeZip/{filename}.png";

        try
        {
            // Creating a barcode is as simple as:
            var myBarcode = BarcodeWriter.CreateBarcode("1212345", BarcodeWriterEncoding.EAN8);

            // Use pdfData (byte array) as needed
            context.Logger.LogLine($"Barocde created.");

            // Upload the PDF to S3
            await UploadPngToS3Async(bucketName, objectKey, myBarcode.ToPngBinaryData());

            context.Logger.LogLine($"Barocde uploaded successfully to {bucketName}/{objectKey}");

            var resultFromByte = BarcodeReader.Read(myBarcode.ToPngBinaryData());

            foreach (var item in resultFromByte)
            {
                // Log the read value out
                context.Logger.LogLine($"Barcode value is = {item.Value}");
            }
        }
        catch (Exception e)
        {
            context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}");
        }
    }
    // Function to upload the PNG file to S3
    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);

    /// <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
    /// <returns></returns>
    public async Task FunctionHandler(ILambdaContext context)
    {
        var awsTmpPath = @"/tmp/";
        IronBarCode.Installation.DeploymentPath = awsTmpPath;

        IronBarCode.License.LicenseKey = "IRONBARCODE-MYLICENSE-KEY-1EF01";

        string filename = Guid.NewGuid().ToString();

        string bucketName = "deploymenttestbucket";
        string objectKey = $"IronBarcodeZip/{filename}.png";

        try
        {
            // Creating a barcode is as simple as:
            var myBarcode = BarcodeWriter.CreateBarcode("1212345", BarcodeWriterEncoding.EAN8);

            // Use pdfData (byte array) as needed
            context.Logger.LogLine($"Barocde created.");

            // Upload the PDF to S3
            await UploadPngToS3Async(bucketName, objectKey, myBarcode.ToPngBinaryData());

            context.Logger.LogLine($"Barocde uploaded successfully to {bucketName}/{objectKey}");

            var resultFromByte = BarcodeReader.Read(myBarcode.ToPngBinaryData());

            foreach (var item in resultFromByte)
            {
                // Log the read value out
                context.Logger.LogLine($"Barcode value is = {item.Value}");
            }
        }
        catch (Exception e)
        {
            context.Logger.LogLine($"[ERROR] FunctionHandler: {e.Message}");
        }
    }
    // Function to upload the PNG file to S3
    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)

		''' <param name="context">The ILambdaContext that provides methods for logging and describing the Lambda environment.</param>
		''' <returns></returns>
		Public Async Function FunctionHandler(ByVal context As ILambdaContext) As Task
			Dim awsTmpPath = "/tmp/"
			IronBarCode.Installation.DeploymentPath = awsTmpPath

			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 is as simple as:
				Dim myBarcode = BarcodeWriter.CreateBarcode("1212345", BarcodeWriterEncoding.EAN8)

				' Use pdfData (byte array) as needed
				context.Logger.LogLine($"Barocde created.")

				' Upload the PDF to S3
				Await UploadPngToS3Async(bucketName, objectKey, myBarcode.ToPngBinaryData())

				context.Logger.LogLine($"Barocde uploaded successfully to {bucketName}/{objectKey}")

				Dim resultFromByte = BarcodeReader.Read(myBarcode.ToPngBinaryData())

				For Each item In resultFromByte
					' Log the read value out
					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
		' Function to upload the PNG file to S3
		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

VB C#

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 transmis à la méthode Read pour lire le code-barres. Cela démontre que la fonction AWS Lambda est capable de lire les codes-barres.

La méthode Read accepte également un objet BarcodeReaderOptions, que vous pouvez personnaliser pour activer des fonctionnalités telles quelecture de plusieurs codes-barres, cibler des zones spécifiques, utilisant le traitement asynchrone et multithreadé, application de filtres de correction d'imageet bien d'autres choses encore.

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

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. Comme base, 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,

"Fonction-timeout" : 300

Lorsque la mémoire est insuffisante, le programme renverra 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 - Signal de sortie du runtime : Terminé.

Publier

Pour publier dans Visual Studio, faites un clic 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, consultez la pageSite web AWS.