Extraire du texte avec AWS Texttract à l’aide des fonctions d’étape AWS

introduction

Dans cet article, nous verrons comment extraire du texte d’une image avec AWS Textract, puis générer un fichier pdf et le télécharger dans le compartiment S3 à l’aide d’AWS Step Functions. Nous allons déployer une pile sans serveur avec trois fonctions lambda, une lambda déclenchera notre machine d’état de fonctions d’étape AWS et d’autres lambdas seront utilisées pour extraire le texte de l’image, générer le pdf, puis le télécharger dans le compartiment S3.

Configuration du projet

La structure de notre projet ressemblera à ceci :

Nous devrons mettre en place un projet sans serveur de base avec un sans serveur.yml et nos fonctions lambda, nous devons également installer aws-sdk pour interagir avec les services AWS, je n’entrerai pas dans les détails sur ce qui est sans serveur.yml est ou comment configurer un projet sans serveur, pour cela, vous pouvez consulter cet article.

Fichier sans serveur.yml

Commençons par définir notre sans serveur.yml fichier, nous irons étape par étape pour une explication plus facile.

Autorisations et configuration

service: aws-step-functions

plugins:
- serverless-step-functions

custom:
  stateMachineName: newStateMachine

provider:
  name: aws
  runtime: nodejs12.x
  iamRoleStatements:
    - Effect: Allow
      Action:
        - states:StartExecution
        - textract:DetectDocumentText
        - s3:Get*
        - s3:List*
        - s3:PutObject*
      Resource: "*"

Comprenons ce code en le décomposant

Plugins – Ici, nous définissons tous les plugins ou nous pouvons dire les modules de packages de nœuds que nous voulons utiliser avec notre projet sans serveur AWS, pour utiliser les fonctions d’étape AWS avec le framework sans serveur, nous avons besoin d’un plugin appelé serverless-step-functions.

Personnalisé – Ici, nous définissons toutes les propriétés que nous voulons référencer dans notre sans serveur.yml fichier, donc dans ce cas, nous définissons le nom de notre machine d’état, nous l’ajouterons également en tant que variable d’environnement plus tard dans notre configuration de fonction lambda.

Fournisseur – Ce bloc est utilisé pour définir toute la configuration, les paramètres, les autorisations, etc., les données associées, l’essentiel ici est que nous définissons nos autorisations dans ce bloc, nous devons définir toutes les autorisations pour les actions que nos fonctions Lambda effectueront , dans notre cas ce sont –

• Démarrage de la machine d’état des fonctions d’étape AWS.
• Utiliser AWS Text DetectDocumentText API pour extraire le texte d’une image.
• Obtenez l’image du compartiment S3 pour extraire le texte.
• Téléchargement du fichier pdf généré dans le compartiment S3.

Définition du bloc de fonctions d’étape

stepFunctions:
  stateMachines:
    newStateMachine:
      name: ${self:custom.stateMachineName}
      tracingConfig:
        enabled: true
      definition:
        Comment: Image extraction and pdf generation
        StartAt: extractText
        States:
          extractText:
            Type: Task
            Resource: !GetAtt extractText.Arn
            Next: generatePdf
          generatePdf:
            Type: Task
            Resource: !GetAtt generatePdf.Arn
            End: true
            Retry:
            - ErrorEquals: ['States.ALL']
              IntervalSeconds: 1
              MaxAttempts: 3
              BackoffRate: 2

Ce bloc sert à définir toutes nos étapes de fonctions d’étape AWS, paramètres, configuration, essayons de le comprendre en le décomposant

stateMachines – Ici, nous définissons toutes nos machines à états et leur configuration respective, dans notre cas nous n’utilisons qu’une seule machine à états.

Nom – Ce n’est que le nom de notre machine d’état, notez ici que nous référençons la propriété personnalisée que nous avons définie précédemment.

tracingConfig – Cette configuration définit si nous voulons activer ou non le traçage AWS X-Ray, il s’agit d’une préférence personnelle, nous pouvons également le désactiver.

définition – Dans ce bloc, nous définissons les étapes réelles de nos fonctions d’étape AWS.

Commencer à – Ceci est utilisé pour définir notre point de départ de la machine d’état, c’est-à-dire à partir de quelle étape notre machine d’état commencera à s’exécuter.

Nous définissons deux étapes dans cette machine d’état, la première étape appellera la fonction Lambda qui extraira le texte d’une image, et la deuxième étape appellera la fonction Lambda qui générera le fichier pdf avec le contenu texte de l’image et téléchargez ce fichier pdf dans le seau S3.

Ressource – Cette propriété est utilisée pour définir le nom de la ressource qui doit être appelée à cette étape, nous définissons donc ici le nom de notre fonction Lambda car nous voulons appeler nos fonctions Lambda sur nos deux étapes.

ErreurÉgal – Ici, nous définissons pour quelles étapes nous voulons réessayer si cela échoue pour une raison quelconque, nous ajoutons une nouvelle tentative pour toutes nos étapes.

Définition des fonctions Lambda

functions:
  extractText:
    handler: src/extractText/index.extractText
  
  generatePdf:
    handler: src/generatePdf/index.generatePdf

  triggerStateMachine:
    handler: src/triggerStateMachine/index.triggerStateMachine
    environment:
      stateMachineName: ${self:custom.stateMachineName}
      ACCOUNT_ID: ${aws:accountId}
    events:
      - s3:
          bucket: my-bucket-34
          event: s3:ObjectCreated:*
          existing: true

Nous définissons trois fonctions Lambda dont :

extraitTexte – Ce Lambda obtiendra l’image de S3 et extraira le texte de l’image à l’aide d’AWS Textract.

générerPdf – Ce Lambda recevra le texte extrait, puis il générera le fichier pdf avec ce texte et le téléchargera dans le compartiment S3.

triggerStateMachine – Nous avons besoin de ce lambda pour déclencher notre machine d’état.

événements – La dernière chose est d’attacher un événement S3 à notre fonction lambda afin qu’elle soit appelée dès qu’une nouvelle image est téléchargée dans le compartiment S3, ce bucket est le nom du bucket où nous allons télécharger les images, nous pouvons créer ce bucket manuellement depuis la console AWS puis mettre le même nom ici, le existing la propriété est définie sur true parce que ce bucket est déjà créé, si nous ne passons pas ce drapeau, ce modèle essaiera de créer le bucket.

Mettre tous ensemble

service: aws-step-functions

plugins:
- serverless-step-functions

custom:
  stateMachineName: newStateMachine

provider:
  name: aws
  runtime: nodejs12.x
  iamRoleStatements:
    - Effect: Allow
      Action:
        - states:StartExecution
        - textract:DetectDocumentText
        - s3:Get*
        - s3:List*
        - s3:PutObject*
      Resource: "*"

stepFunctions:
  stateMachines:
    newStateMachine:
      name: ${self:custom.stateMachineName}
      tracingConfig:
        enabled: true
      definition:
        Comment: Image extraction and pdf generation
        StartAt: extractText
        States:
          extractText:
            Type: Task
            Resource: !GetAtt extractText.Arn
            Next: generatePdf
          generatePdf:
            Type: Task
            Resource: !GetAtt generatePdf.Arn
            End: true
            Retry:
            - ErrorEquals: ['States.ALL']
              IntervalSeconds: 1
              MaxAttempts: 3
              BackoffRate: 2

functions:
  extractText:
    handler: src/extractText/index.extractText
  
  generatePdf:
    handler: src/generatePdf/index.generatePdf

  triggerStateMachine:
    handler: src/triggerStateMachine/index.triggerStateMachine
    environment:
      stateMachineName: ${self:custom.stateMachineName}
      ACCOUNT_ID: ${aws:accountId}
    events:
      - s3:
          bucket: my-bucket-34
          event: s3:ObjectCreated:*
          existing: true

Extraire le texte d’une image

Commençons par notre première fonction lambda qui est extractText, qui utilisera AWS Textract pour obtenir le texte d’une image téléchargée dans le compartiment S3, nous allons décomposer la fonction en plusieurs parties.

Importations

const AWS = require("aws-sdk");
const textract = new AWS.Textract();

Nous avons besoin aws-sdk et un exemple de Textract()

Obtenir du texte à partir d’une image

const { bucket, key } = event;
    try {
        const params = {
            Document: {
                S3Object: {
                    Bucket: bucket,
                    Name: key,
                }
            }
        };
 const response = await textract.detectDocumentText(params).promise();

Premièrement, nous recevons bucket et key de notre triggerStateMachine fonction lambda qui sera appelée lorsqu’un objet sera téléchargé dans notre compartiment S3 (nous en parlerons plus tard).

Nous appelons detectDocumentText API qui va extraire les informations d’une image et nous retourner les données dont nous avons besoin.

Collecte de données textuelles à partir de la réponse d’AWS Texttract

let text="";
  response.Blocks.forEach((data) => {
   if (data.BlockType === 'LINE') {
       text += `${data.Text} `;
    }
   })
return { key, pdfData: text };

Ici, nous parcourons simplement le tableau de réponses qui est renvoyé par l’appel de l’API Texttract, nous n’avons besoin que de données où BlockType est ‘LINE’ qui est chaque ligne de texte de l’image traitée. Nous ajoutons toutes les lignes de texte à une seule chaîne.

Après cela, nous renvoyons simplement ces données afin que notre prochain lambda dans les étapes de la machine d’état reçoive ces données pour générer le pdf et le télécharger dans le compartiment S3.

Fonction entière

const AWS = require("aws-sdk");
const textract = new AWS.Textract();

exports.extractText = async (event) => {
    const { bucket, key } = event;
    try {
        const params = {
            Document: {
                S3Object: {
                    Bucket: bucket,
                    Name: key,
                }
            }
        };
        const response = await textract.detectDocumentText(params).promise();
        let text="";
        response.Blocks.forEach((data) => {
            if (data.BlockType === 'LINE') {
                text += `${data.Text} `;
            }
        })
        return { key, pdfData: text };
    }
    catch (e) {
        console.log(e);
    }
}

Génération de PDF et téléchargement dans le compartiment S3

Dans cette fonction Lambda, nous allons créer un pdf avec les données que nous avons reçues de l’analyse d’image, puis télécharger ce pdf dans le compartiment S3.

Importations

const AWS = require("aws-sdk");
const PDFDocument = require("pdfkit")
const s3 = new AWS.S3();

Nous allons utiliser un npm appelé pdfkit pour rédiger et générer notre fichier pdf.

Écrire des données dans le fichier PDF

const { key, pdfData } = event;
const fileName="output.pdf";
const pdfPromise = await new Promise(resolve => {
const doc = new PDFDocument();

doc.text(pdfData);
doc.end();

const buffers = [];
doc.on("data", buffers.push.bind(buffers));
doc.on("end", () => {
  const pdfData = Buffer.concat(buffers);
  resolve(pdfData);
   });
});

Nous recevons une clé de fichier image et des données qui ont été renvoyées par notre extractText lambda, comprenons ce code étape par étape :

doc.text() – Il s’agit simplement d’écrire les données dans notre fichier pdf.

doc.end() – Ceci ferme le flux d’écriture.

Nous utilisons également des événements comme data et…