Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Dokumente mit asynchronen Operationen verarbeiten Amazon Textract kann Text in mehrseitigen Dokumenten im PDF- oder TIFF-Format erkennen und analysieren. Dies schließt Rechnungen und Belege ein. Die Verarbeitung von mehrseitigen Dokumenten ist ein asynchroner Vorgang. Die asynchrone Verarbeitung von Dokumenten ist nützlich für die Verarbeitung großer, mehrseitiger Dokumente. Beispielsweise dauert die Verarbeitung einer PDF-Datei mit über 1.000 Seiten eine Weile. Durch die asynchrone Verarbeitung der PDF-Datei kann Ihre Anwendung andere Aufgaben ausführen, während sie auf den Abschluss des Prozesses wartet. In diesem Abschnitt wird beschrieben, wie Sie Amazon Textract verwenden können, um Text in einem mehrseitigen oder einseitigen Dokument asynchron zu erkennen und zu analysieren. Mehrseitige Dokumente müssen im PDF- oder TIFF-Format vorliegen. Einzelseitige Dokumente, die mit asynchronen Operationen verarbeitet werden, können im JPEG-, PNG-, TIFF- oder PDF-Format vorliegen. Sie können asynchrone Operationen von Amazon Textract für die folgenden Zwecke verwenden: + Texterkennung — Sie können Zeilen und Wörter in einem mehrseitigen Dokument erkennen. Die asynchronen Operationen sind[StartDocumentTextDetection](API_StartDocumentTextDetection.md)und[GetDocumentTextDetection](API_GetDocumentTextDetection.md)aus. Weitere Informationen finden Sie unter [Erkennen von Text](how-it-works-detecting.md) . + Textanalyse — Sie können Beziehungen zwischen erkanntem Text in einem mehrseitigen Dokument identifizieren. Die asynchronen Operationen sind[StartDocumentAnalysis](API_StartDocumentAnalysis.md)und[GetDocumentAnalysis](API_GetDocumentAnalysis.md)aus. Weitere Informationen finden Sie unter [Analysieren von Dokumenten](how-it-works-analyzing.md) . + Kostenanalyse — Sie können Datenbeziehungen auf mehrseitigen Rechnungen und Belegen identifizieren. Amazon Textract behandelt jede Rechnung oder eine Belegseite eines mehrseitigen Dokuments als Einzelbeleg oder Rechnung. Es behält den Kontext nicht von einer Seite zur anderen eines mehrseitigen Dokuments bei. Die asynchronen Operationen sind[StartExpenseAnalysis](API_StartExpenseAnalysis.md)und[GetExpenseAnalysis](API_GetExpenseAnalysis.md)aus. Weitere Informationen finden Sie unter [Analysieren von Rechnungen und Belegen](invoices-receipts.md) . **Topics** + [ # Asynchrone Operationen von Amazon Textract aufrufen ](api-async.md) + [ # Konfigurieren von Amazon Textract für asynchrone Vorgänge ](api-async-roles.md) + [ # Erkennen oder Analysieren von Text in einem mehrseitigen Dokument ](async-analyzing-with-sqs.md) + [ # Amazon Textract Ergebnisbenachrichtigung ](async-notification-payload.md) # Asynchrone Operationen von Amazon Textract aufrufen Amazon Textract bietet eine asynchrone API, mit der Sie mehrseitige Dokumente im PDF- oder TIFF-Format verarbeiten können. Sie können auch asynchrone Operationen verwenden, um einseitige Dokumente im JPEG-, PNG-, TIFF- oder PDF-Format zu verarbeiten. Die Informationen in diesem Thema verwenden Texterkennungsvorgänge, um zu zeigen, wie asynchrone Operationen von Amazon Textract verwendet werden. Derselbe Ansatz funktioniert mit den Textanalyseoperationen von[StartDocumentAnalysis](API_StartDocumentAnalysis.md)und[GetDocumentAnalysis](API_GetDocumentAnalysis.md)aus. Es funktioniert auch gleich mit[StartExpenseAnalysis](API_StartExpenseAnalysis.md)und[GetExpenseAnalysis](API_GetExpenseAnalysis.md)aus. Ein Beispiel finden Sie unter [Erkennen oder Analysieren von Text in einem mehrseitigen Dokument](async-analyzing-with-sqs.md). Amazon Textract verarbeitet asynchron ein Dokument, das in einem Amazon S3 S3-Bucket gespeichert ist. Sie beginnen mit der Verarbeitung, indem Sie ein`Start`Betrieb, wie[StartDocumentTextDetection](API_StartDocumentTextDetection.md)aus. Der Erledigungsstatus der Anfrage wird in einem Amazon Simple Notification Service (Amazon SNS) -Thema veröffentlicht. Um den Erledigungsstatus aus dem Amazon-SNS-Thema zu erhalten, können Sie eine Amazon Simple Queue Service (Amazon SQS) -Warteschlange oder eineAWS LambdaFunktion. Sobald Sie den Erledigungsstatus bekommen haben, rufen Sie eine `Get`-Operation auf, wie z. B. [GetDocumentTextDetection](API_GetDocumentTextDetection.md), um die Ergebnisse der Anfrage zu erhalten. Die Ergebnisse asynchroner Anrufe werden standardmäßig verschlüsselt und 7 Tage lang in einem Bucket im Besitz von Amazon Textract gespeichert, es sei denn, Sie geben einen Amazon S3 S3-Bucket mit einem Vorgang an`OutputConfig`Argument. Die folgende Tabelle zeigt die entsprechenden Start- und Abgabevorgänge für die verschiedenen von Amazon Textract unterstützten asynchronen Verarbeitungstypen: **API-Operationen für Asynchrone Operationen von Amazon Textract starten/abrufen** | Art der Verarbeitung | API starten | Erhalten einer API | | --- | --- | --- | | Texterkennung | StartDocumentTextDetection | GetDocumentTextDetection | | Textanalyse | StartDocumentAnalysis | GetDocumentAnalysis | | Kostenanalyse | StarteExpenseAnalysis | getExpenseAnalysis | Für ein Beispiel, das verwendetAWS LambdaFunktionen finden Sie unter[Dokumentenverarbeitung im großen Maßstab mit Amazon Textract](https://github.com/aws-samples/amazon-textract-serverless-large-scale-document-processing)aus. Im folgenden Diagramm wird der Vorgang zur Erkennung von Dokumenttext in einem Dokumentbild, das in einem Amazon-S3-Bucket gespeichert ist, zeigt. Im Diagramm erhält eine Amazon SQS SQS-Warteschlange den Erledigungsstatus aus dem Amazon SNS SNS-Thema. ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/textract/latest/dg/images/asynchronous.png) Der im vorhergehenden Diagramm angezeigte Prozess ist für die Analyse von Text und Rechnungen/Belegen identisch. Sie beginnen mit der Analyse von Text, indem Sie anrufen[StartDocumentAnalysis](API_StartDocumentAnalysis.md)und analysieren Sie Rechnungen/Quittungen, indem Sie anrufen[StartExpenseAnalysis](API_StartExpenseAnalysis.md)Sie erhalten die Ergebnisse, indem Sie anrufen[GetDocumentAnalysis](API_GetDocumentAnalysis.md)oder[GetExpenseAnalysis](API_GetExpenseAnalysis.md)beziehungsweise. ## Starten der Texterkennung Sie starten eine Amazon Textract--Texterkennungsanforderung, indem Sie aufrufen[StartDocumentTextDetection](API_StartDocumentTextDetection.md)aus. Im Folgenden sehen Sie ein Beispiel für eine JSON-Anforderung, die von `StartDocumentTextDetection` übergeben wird. ``` { "DocumentLocation": { "S3Object": { "Bucket": "bucket", "Name": "image.pdf" } }, "ClientRequestToken": "DocumentDetectionToken", "NotificationChannel": { "SNSTopicArn": "arn:aws:sns:us-east-1:nnnnnnnnnn:topic", "RoleArn": "arn:aws:iam::nnnnnnnnnn:role/roleTopic" }, "JobTag": "Receipt" } ``` Der Eingabeparameter`DocumentLocation`liefert den Dateinamen des -Dokuments und den Amazon S3 S3-Bucket, aus dem sie abgerufen werden kann.`NotificationChannel`enthält den Amazon-Ressourcennamen (ARN) des Amazon-SNS-Themas, das Amazon Textract benachrichtigt, wenn die Anfrage zur Texterkennung beendet ist. Das Amazon SNS SNS-Thema muss sich in derselben AWS-Region befinden wie der Amazon Textract Textract-Endpunkt, den Sie aufrufen.`NotificationChannel`enthält auch den ARN für eine Rolle, die es Amazon Textract erlaubt, das Amazon SNS SNS-Thema zu veröffentlichen. Sie erteilen Amazon Textract Textract-Veröffentlichungsberechtigungen für Ihre Amazon SNS SNS-Themen, indem Sie eine IAM-Servicerolle erstellen. Weitere Informationen finden Sie unter [Konfigurieren von Amazon Textract für asynchrone Vorgänge](api-async-roles.md) . Sie können auch einen optionalen Eingabeparameter angeben,`JobTag`, der es Ihnen ermöglicht, den Auftrag oder Gruppen von Aufträgen im Erledigungsstatus zu identifizieren, der im Amazon-SNS-Thema veröffentlicht ist. Sie können beispielsweise die Verwendung von`JobTag`um die Art des zu bearbeitenden Dokuments zu ermitteln, z. B. ein Steuerformular oder eine Quittung. Um ein versehentliches doppeltes Ausführen von Analyseaufträgen zu vermeiden, können Sie optional ein idempotentes Token, `ClientRequestToken`, bereitstellen. Wenn Sie einen Wert angeben für`ClientRequestToken`, der`Start`-Operation gibt das Gleiche zurück`JobId`für mehrere identische Anrufe an die`Start`Betrieb, wie`StartDocumentTextDetection`aus. Ein Token `ClientRequestToken` hat eine Lebensdauer von 7 Tagen. Nach 7 Tagen können Sie es wiederverwenden. Wenn Sie das Token während der Token-Lebensdauer wiederverwenden, geschieht folgendes: + Wenn Sie das Token mit der gleichen `Start`-Operation und den gleichen Eingabeparametern wiederverwenden, wird dieselbe `JobId` zurückgegeben. Der Auftrag wird nicht erneut ausgeführt und Amazon Textract sendet keinen Erledigungsstatus an das registrierte Amazon SNS SNS-Thema. + Wenn Sie das Token mit der gleichen `Start`-Operation und einer geringfügigen Änderung der Eingabeparameter wiederverwenden, wird eine `idempotentparametermismatchexception`-Ausnahme (HTTP-Statuscode: 400) ausgelöst. + Wenn Sie das Token mit einer anderen `Start`-Operation wiederverwenden, ist die Operation erfolgreich. Ein weiterer optionaler Parameter ist verfügbar`OutputConfig`, mit dem Sie einstellen können, wo Ihre Ausgabe platziert wird. Standardmäßig speichert Amazon Textract die Ergebnisse intern und kann nur von den API-Vorgängen abrufen aufgerufen werden. mit`OutputConfig`aktiviert, können Sie den Namen des Buckets festlegen, an den die Ausgabe gesendet wird, und das Dateipräfix der Ergebnisse, in dem Sie Ihre Ergebnisse herunterladen können. Darüber hinaus können Sie die`KMSKeyID`Parameter an einen vom Kunden verwalteten Schlüssel, um Ihre Ausgabe zu verschlüsseln. Ohne diesen Parametersatz verschlüsselt Amazon Textract serverseitig mit demVon AWS verwalteter Schlüsselfür Amazon S3 **Anmerkung** Bevor Sie diesen Parameter verwenden, stellen Sie sicher, dass Sie die PutObject-Berechtigung für den Ausgabe-Bucket haben Stellen Sie außerdem sicher, dass Sie über die Berechtigungen Decrypt, ReEncrypt, GenerateDataKey und DescribeKey verfügen für dieAWS KMSSchlüssel, wenn Sie sich entscheiden, ihn zu verwenden. Die Antwort auf die `StartDocumentTextDetection`-Operation ist eine Auftrags-ID (`JobId`). Verwenden von`JobId`Um Anfragen zu verfolgen und die Analyseergebnisse zu erhalten, nachdem Amazon Textract den Status der Fertigstellung im Amazon-SNS-Thema veröffentlicht hat. Im Folgenden wird ein Beispiel gezeigt: ``` {"JobId":"270c1cc5e1d0ea2fbc59d97cb69a72a5495da75851976b14a1784ca90fc180e3"} ``` Wenn Sie gleichzeitig zu viele Jobs starten, rufen Sie an`StartDocumentTextDetection`RAISE ein`LimitExceededException`-Ausnahme (HTTP-Statuscode: 400), bis die Anzahl der gleichzeitig ausgeführten Aufträge unter dem Amazon Textract Texttract-Service-Limit liegt. Wenn Sie feststellen, dass LimitExceededException-Ausnahmen bei Teilaktivitäten ausgelöst werden, empfiehlt sich für die Verwaltung eingehender Anforderungen die Verwendung einer Amazon SQS SQS-Warteschlange. KontaktAWSSupport, wenn Sie feststellen, dass Ihre durchschnittliche Anzahl gleichzeitiger Anforderungen nicht von einer Amazon SQS SQS-Warteschlange verwaltet werden kann und Sie weiterhin erhalten`LimitExceededException`Ausnahmen. ## Abrufen des Erledigungsstatus einer Amazon Textract Textract-Analyseanforderung Amazon Textract sendet eine Benachrichtigung über den Abschluss der Analyse an das registrierte Amazon SNS SNS-Thema. Die Benachrichtigung enthält die Auftrags-ID und den Erledigungsstatus der Operation in einer JSON-Zeichenfolge. Eine erfolgreiche Anfrage zur Texterkennung hat eine`SUCCEEDED`Status. Das folgende Ergebnis zeigt beispielsweise die erfolgreiche Verarbeitung eines Texterkennungsauftrags. ``` { "JobId": "642492aea78a86a40665555dc375ee97bc963f342b29cd05030f19bd8fd1bc5f", "Status": "SUCCEEDED", "API": "StartDocumentTextDetection", "JobTag": "Receipt", "Timestamp": 1543599965969, "DocumentLocation": { "S3ObjectName": "document", "S3Bucket": "bucket" } } ``` Weitere Informationen finden Sie unter [Amazon Textract Ergebnisbenachrichtigung](async-notification-payload.md) . Verwenden Sie eine der folgenden Optionen, um die Statusinformationen zu erhalten, die im Amazon-SNS-Thema von Amazon SNS-Thema von Amazon Textract veröffentlicht werden: + **AWS Lambda**— Sie können eine abonnierenAWS Lambda-Funktion, die Sie in ein Amazon SNS SNS-Thema schreiben. Die Funktion wird aufgerufen, wenn Amazon Textract das Amazon SNS SNS-Thema darüber informiert, dass die Anfrage abgeschlossen ist. Verwenden Sie eine Lambda-Funktion, wenn Sie serverseitigen Code zur Verarbeitung der Ergebnisse einer Texterkennungsanforderung benötigen. Sie können beispielsweise serverseitigen Code verwenden, um das Bild mit Anmerkungen zu versehen oder einen Bericht über den erkannten Text zu erstellen, bevor die Informationen an eine Client-Anwendung zurückgegeben werden. + **Amazon SQS**- Sie können eine Amazon SQS SQS-Warteschlange für ein Amazon SNS SNS-Thema abonnieren. Sie fragen dann die Amazon SQS SQS-Warteschlange ab, um den von Amazon Textract veröffentlichten Erledigungsstatus abzurufen, wenn eine Anfrage zur Texterkennung abgeschlossen ist. Weitere Informationen finden Sie unter [Erkennen oder Analysieren von Text in einem mehrseitigen Dokument](async-analyzing-with-sqs.md) . Verwenden Sie eine Amazon SQS SQS-Warteschlange, wenn Sie Amazon Textract Textract-Operationen nur von einer Client-Anwendung aus aufrufen möchten. **Wichtig** Wir raten davon ab, den Status der Auftragserfüllung durch wiederholtes Aufrufen des Amazon Textract`Get`verwenden. Dies liegt daran, dass Amazon Textract die`Get`-Betrieb, wenn zu viele Anfragen gestellt werden. Wenn Sie mehrere Dokumente gleichzeitig verarbeiten, ist es einfacher und effizienter, eine SQS-Warteschlange für die Erledigungsbenachrichtigung zu überwachen, als Amazon Textract nach dem Status jedes Auftrags einzeln abzufragen. ## Ergebnisse der Amazon Textract Textract-Texterkennung abrufen Um die Ergebnisse einer Texterkennungsanforderung zu erhalten, stellen Sie zunächst sicher, dass der Erledigungsstatus, der aus dem Amazon-SNS-Thema abgerufen wird, lautet`SUCCEEDED`aus. Rufen Sie dann `GetDocumentTextDetection` auf, wodurch der Wert `JobId` übergeben wird, den `StartDocumentTextDetection` zurückgibt. Die JSON-Ausgabe sieht folgendermaßen oder ähnlich aus: ``` { "JobId": "270c1cc5e1d0ea2fbc59d97cb69a72a5495da75851976b14a1784ca90fc180e3", "MaxResults": 10, "SortBy": "TIMESTAMP" } ``` `JobId`ist der Bezeichner für den Texterkennungsvorgang. Da die Texterkennung große Datenmengen erzeugen kann, verwenden Sie`MaxResults`um die maximale Anzahl der Ergebnisse anzugeben, die in einem einzigen`Get`verwenden. Der Standardwert für`MaxResults`ist 1.000. Wenn Sie einen Wert größer als 1.000 angeben, werden nur 1.000 Ergebnisse zurückgegeben. Wenn die Operation nicht alle Ergebnisse zurückgibt, wird ein Paginierungs-Token für die nächste Seite zurückgegeben. Um die nächste Ergebnisseite abzurufen, geben Sie das Token in der`NextToken`-Parameter. **Anmerkung** Amazon Textract bewahrt die Ergebnisse asynchroner Operationen für 7 Tage auf. Nach dieser Zeit können Sie die Ergebnisse nicht mehr abrufen. Die`GetDocumentTextDetection`Die Operation Response JSON ähnelt dem folgenden Beispiel. Die Gesamtzahl der erkannten Seiten wird in zurückgegeben`DocumentMetadata`aus. Der erkannte Text wird im`Blocks`Array. Weitere Informationen zu`Block`objekte, siehe[Antwortobjekte für Texterkennung und Dokumentanalyse](how-it-works-document-layout.md)aus. ``` { "DocumentMetadata": { "Pages": 1 }, "JobStatus": "SUCCEEDED", "Blocks": [ { "BlockType": "PAGE", "Geometry": { "BoundingBox": { "Width": 1.0, "Height": 1.0, "Left": 0.0, "Top": 0.0 }, "Polygon": [ { "X": 0.0, "Y": 0.0 }, { "X": 1.0, "Y": 0.0 }, { "X": 1.0, "Y": 1.0 }, { "X": 0.0, "Y": 1.0 } ] }, "Id": "64533157-c47e-401a-930e-7ca1bb3ac3fa", "Relationships": [ { "Type": "CHILD", "Ids": [ "4297834d-dcb1-413b-8908-3b96866ebbb5", "1d85ba24-2877-4d09-b8b2-393833d769e9", "193e9c47-fd87-475a-ba09-3fda210d8784", "bd8aeb62-961b-4b47-b78a-e4ed9eeecd0f" ] } ], "Page": 1 }, { "BlockType": "LINE", "Confidence": 53.301639556884766, "Text": "ellooworio", "Geometry": { "BoundingBox": { "Width": 0.9999999403953552, "Height": 0.5365243554115295, "Left": 0.0, "Top": 0.46347561478614807 }, "Polygon": [ { "X": 0.0, "Y": 0.46347561478614807 }, { "X": 0.9999999403953552, "Y": 0.46347561478614807 }, { "X": 0.9999999403953552, "Y": 1.0 }, { "X": 0.0, "Y": 1.0 } ] }, "Id": "4297834d-dcb1-413b-8908-3b96866ebbb5", "Relationships": [ { "Type": "CHILD", "Ids": [ "170c3eb9-5155-4bec-8c44-173bba537e70" ] } ], "Page": 1 }, { "BlockType": "LINE", "Confidence": 89.15632629394531, "Text": "He llo,", "Geometry": { "BoundingBox": { "Width": 0.33642634749412537, "Height": 0.49159330129623413, "Left": 0.13885067403316498, "Top": 0.17169663310050964 }, "Polygon": [ { "X": 0.13885067403316498, "Y": 0.17169663310050964 }, { "X": 0.47527703642845154, "Y": 0.17169663310050964 }, { "X": 0.47527703642845154, "Y": 0.6632899641990662 }, { "X": 0.13885067403316498, "Y": 0.6632899641990662 } ] }, "Id": "1d85ba24-2877-4d09-b8b2-393833d769e9", "Relationships": [ { "Type": "CHILD", "Ids": [ "516ae823-3bab-4f9a-9d74-ad7150d128ab", "6bcf4ea8-bbe8-4686-91be-b98dd63bc6a6" ] } ], "Page": 1 }, { "BlockType": "LINE", "Confidence": 82.44834899902344, "Text": "worlo", "Geometry": { "BoundingBox": { "Width": 0.33182239532470703, "Height": 0.3766750991344452, "Left": 0.5091826915740967, "Top": 0.23131252825260162 }, "Polygon": [ { "X": 0.5091826915740967, "Y": 0.23131252825260162 }, { "X": 0.8410050868988037, "Y": 0.23131252825260162 }, { "X": 0.8410050868988037, "Y": 0.607987642288208 }, { "X": 0.5091826915740967, "Y": 0.607987642288208 } ] }, "Id": "193e9c47-fd87-475a-ba09-3fda210d8784", "Relationships": [ { "Type": "CHILD", "Ids": [ "ed135c3b-35dd-4085-8f00-26aedab0125f" ] } ], "Page": 1 }, { "BlockType": "LINE", "Confidence": 88.50325775146484, "Text": "world", "Geometry": { "BoundingBox": { "Width": 0.35004907846450806, "Height": 0.19635874032974243, "Left": 0.527581512928009, "Top": 0.30100569128990173 }, "Polygon": [ { "X": 0.527581512928009, "Y": 0.30100569128990173 }, { "X": 0.8776305913925171, "Y": 0.30100569128990173 }, { "X": 0.8776305913925171, "Y": 0.49736443161964417 }, { "X": 0.527581512928009, "Y": 0.49736443161964417 } ] }, "Id": "bd8aeb62-961b-4b47-b78a-e4ed9eeecd0f", "Relationships": [ { "Type": "CHILD", "Ids": [ "9e28834d-798e-4a62-8862-a837dfd895a6" ] } ], "Page": 1 }, { "BlockType": "WORD", "Confidence": 53.301639556884766, "Text": "ellooworio", "Geometry": { "BoundingBox": { "Width": 1.0, "Height": 0.5365243554115295, "Left": 0.0, "Top": 0.46347561478614807 }, "Polygon": [ { "X": 0.0, "Y": 0.46347561478614807 }, { "X": 1.0, "Y": 0.46347561478614807 }, { "X": 1.0, "Y": 1.0 }, { "X": 0.0, "Y": 1.0 } ] }, "Id": "170c3eb9-5155-4bec-8c44-173bba537e70", "Page": 1 }, { "BlockType": "WORD", "Confidence": 88.46246337890625, "Text": "He", "Geometry": { "BoundingBox": { "Width": 0.15350718796253204, "Height": 0.29955607652664185, "Left": 0.13885067403316498, "Top": 0.21856294572353363 }, "Polygon": [ { "X": 0.13885067403316498, "Y": 0.21856294572353363 }, { "X": 0.292357861995697, "Y": 0.21856294572353363 }, { "X": 0.292357861995697, "Y": 0.5181190371513367 }, { "X": 0.13885067403316498, "Y": 0.5181190371513367 } ] }, "Id": "516ae823-3bab-4f9a-9d74-ad7150d128ab", "Page": 1 }, { "BlockType": "WORD", "Confidence": 89.8501968383789, "Text": "llo,", "Geometry": { "BoundingBox": { "Width": 0.17724157869815826, "Height": 0.49159327149391174, "Left": 0.2980354428291321, "Top": 0.17169663310050964 }, "Polygon": [ { "X": 0.2980354428291321, "Y": 0.17169663310050964 }, { "X": 0.47527703642845154, "Y": 0.17169663310050964 }, { "X": 0.47527703642845154, "Y": 0.6632899045944214 }, { "X": 0.2980354428291321, "Y": 0.6632899045944214 } ] }, "Id": "6bcf4ea8-bbe8-4686-91be-b98dd63bc6a6", "Page": 1 }, { "BlockType": "WORD", "Confidence": 82.44834899902344, "Text": "worlo", "Geometry": { "BoundingBox": { "Width": 0.33182239532470703, "Height": 0.3766750991344452, "Left": 0.5091826915740967, "Top": 0.23131252825260162 }, "Polygon": [ { "X": 0.5091826915740967, "Y": 0.23131252825260162 }, { "X": 0.8410050868988037, "Y": 0.23131252825260162 }, { "X": 0.8410050868988037, "Y": 0.607987642288208 }, { "X": 0.5091826915740967, "Y": 0.607987642288208 } ] }, "Id": "ed135c3b-35dd-4085-8f00-26aedab0125f", "Page": 1 }, { "BlockType": "WORD", "Confidence": 88.50325775146484, "Text": "world", "Geometry": { "BoundingBox": { "Width": 0.35004907846450806, "Height": 0.19635874032974243, "Left": 0.527581512928009, "Top": 0.30100569128990173 }, "Polygon": [ { "X": 0.527581512928009, "Y": 0.30100569128990173 }, { "X": 0.8776305913925171, "Y": 0.30100569128990173 }, { "X": 0.8776305913925171, "Y": 0.49736443161964417 }, { "X": 0.527581512928009, "Y": 0.49736443161964417 } ] }, "Id": "9e28834d-798e-4a62-8862-a837dfd895a6", "Page": 1 } ] } ``` # Konfigurieren von Amazon Textract für asynchrone Vorgänge Die folgenden Verfahren zeigen Ihnen, wie Sie Amazon Textract für die Verwendung mit einem Amazon Simple Notification Service (Amazon SNS) -Thema und einer Amazon-Simple-Queue-Service-Warteschlange (Amazon SQS) konfigurieren. **Anmerkung** Wenn Sie diese Anweisungen verwenden, um das[Erkennen oder Analysieren von Text in einem mehrseitigen Dokument](async-analyzing-with-sqs.md)Beispiel müssen Sie die Schritte 3 — 6 nicht ausführen. Das Beispiel enthält Code zum Erstellen und Konfigurieren des Amazon SNS SNS-Themas und die Amazon SQS SQS-Warteschlange. **So konfigurieren Sie Amazon Textract** 1. Einrichten einesAWS-Konto für den Zugriff auf Amazon Textract. Weitere Informationen finden Sie unter [Schritt 1: Einrichten eines AWS-Kontos und Erstellen eines IAM-Benutzers](setting-up.md) . Stellen Sie sicher, dass der Benutzer mindestens über die folgenden Berechtigungen verfügt: + AmazonTextractFullAccess + AmazonS3ReadOnlyAccess + AmazonSNSFullAccess + AmazonSQSFullAccess 1. Installieren und konfigurieren Sie das erforderliche AWS-SDK. Weitere Informationen finden Sie unter [Schritt 2: Einrichten derAWS CLIundAWS-SDKs](setup-awscli-sdk.md) . 1. [Erstellen Sie ein Amazon SNS-Thema.](https://docs.aws.amazon.com/sns/latest/dg/sns-tutorial-create-topic.html)aus. Stellen Sie dem Themennamen voran*AmazonTextract*aus. Notieren Sie den ARN (Amazon-Ressourcenname). Stellen Sie sicher, dass sich das -Thema in derselben -Region befindet wie dasAWSEndpunkt, den Sie mit Ihrem AWS-Konto verwenden. 1. [Erstellen einer Amazon SQS SQS-Standardwarteschlange](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-create-queue.html)indem Sie die[Amazon SQS SQS-Konsole](https://console.aws.amazon.com/sqs/)aus. Notieren Sie den ARN der Warteschlange. 1. [Abonnieren Sie die Warteschlange zum Thema](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-subscribe-queue-sns-topic.html), das Sie in Schritt 3 erstellt haben. 1. [Erteilen Sie die Berechtigung für das Amazon SNS SNS-Thema zum Senden von Nachrichten an die Amazon SQS SQS-Warteschlange](https://docs.aws.amazon.com/sns/latest/dg/subscribe-sqs-queue-to-sns-topic.html)aus. 1. Erstellen Sie eine IAM-Servicerolle, um Amazon Textract Zugriff auf Ihre Amazon SNS SNS-Themen zu gewähren. Notieren Sie sich den Amazon-Ressourcennamen (ARN) der Service-Rolle. Weitere Informationen finden Sie unter [Amazon Textract Zugriff auf Ihr Amazon SNS SNS-Thema gewähren](#api-async-roles-all-topics) . 1. [Fügen Sie die folgende Inlinerichtlinie hinzu](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console)an den IAM-Anwender, den Sie in Schritt 1 erstellt haben. ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "MySid", "Effect": "Allow", "Action": "iam:PassRole", "Resource": "Service role ARN from step 7" } ] } ``` Geben Sie der Inlinerichtlinie einen Namen. 1. Jetzt können Sie die Beispiele in ausführen[Erkennen oder Analysieren von Text in einem mehrseitigen Dokument](async-analyzing-with-sqs.md)aus. ## Amazon Textract Zugriff auf Ihr Amazon SNS SNS-Thema gewähren Amazon Textract benötigt die Berechtigung, eine Nachricht an Ihr Amazon SNS SNS-Thema zu senden, wenn ein asynchroner Vorgang abgeschlossen ist. Sie verwenden eine IAM-Servicerolle, um Amazon Textract Zugriff auf das Amazon SNS SNS-Thema zu gewähren. Wenn Sie das Amazon SNS SNS-Thema erstellen, müssen Sie dem Themennamen vorangestellt werden**AmazonTextract**—beispielsweise**AmazonTextractMyTopicName**aus. 1. Melden Sie sich bei der IAM-Konsole an ([https://console.aws.amazon.com/iam](https://console.aws.amazon.com/iam)). 1. Wählen Sie im Navigationsbereich **Roles** aus. 1. Wählen Sie **Create role (Rolle erstellen)** aus. 1. Wählen Sie unter **Select type of trusted entity (Typ der vertrauenswürdigen Entität wählen)** die Option **AWS service (Service)** aus. 1. Für**Wählen Sie den Service aus, der diese Rolle verwendet**, wählen**Textract**aus. 1. Wählen Sie **Weiter**. **Berechtigungen**. 1. Stellen Sie sicher, dass die**AmazonTextractServiceRole**Die Richtlinie wurde in die Liste der angehängten Richtlinien aufgenommen. Um die Richtlinie in der Liste anzuzeigen, geben Sie einen Teil des Richtliniennamens in der**Filtern von Richtlinien**aus. 1. Wählen Sie **Weiter**. **Tags**. 1. Sie müssen keine Tags hinzufügen, wählen Sie also**Weiter: Prüfen**. 1. Geben Sie im Bereich **Review (Prüfen)** für **Role name (Rollenname)** einen Namen für die Rolle ein (z. B. `TextractRole`). In :**Rollenbeschreibung**aktualisieren Sie die Beschreibung für die Rolle und wählen Sie dann**Erstellen einer -Rolle**aus. 1. Wählen Sie die neue Rolle aus, um die Detailseite der Rolle zu öffnen. 1. Kopieren Sie unter **Summary (Übersicht)**den **Role ARN (Rollen-ARN)**-Wert und speichern Sie ihn. 1. Wählen Sie **Trust Relationships (Vertrauensbeziehungen)** aus. 1. Klicken Sie auf**Bearbeiten von Vertrauensstellungen**und stellen Sie sicher, dass die Vertrauensrichtlinie wie folgt aussieht. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "textract.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` 1. Wählen Sie **Update Trust Policy**. # Erkennen oder Analysieren von Text in einem mehrseitigen Dokument Dieses Verfahren zeigt Ihnen, wie Sie Text in einem mehrseitigen Dokument mithilfe von Amazon Textract Textract-Erkennungsvorgängen, einem in einem Amazon S3 S3-Bucket gespeicherten Dokument, einem Amazon SNS SNS-Thema und einer Amazon SQS SQS-Warteschlange erkennen oder analysieren. Die Verarbeitung von mehrseitigen Dokumenten ist ein asynchroner Vorgang. Weitere Informationen finden Sie unter [Asynchrone Operationen von Amazon Textract aufrufen](api-async.md) . Sie können die Art der Verarbeitung auswählen, die der Code ausführen soll: Texterkennung, Textanalyse oder Kostenanalyse. Die Verarbeitungsergebnisse werden in einem Array von[Block](API_Block.md)-Objekte, die sich je nach Art der Verarbeitung unterscheiden, die Sie verwenden. Um Text in mehrseitigen Dokumenten zu erkennen oder zu analysieren, gehen Sie wie folgt vor: 1. Erstellen Sie das Amazon SNS SNS-Thema und die Amazon SQS SQS-Warteschlange. 1. Abonnieren Sie die Warteschlange das -Thema. 1. Erteilen Sie dem -Thema die Berechtigung zum Senden von Nachrichten an die Warteschlange. 1. Beginnen Sie mit der Verarbeitung des Dokuments Verwenden Sie die entsprechende Operation für die von Ihnen gewählte Analysetyp: + [StartDocumentTextDetection](API_StartDocumentTextDetection.md)für Aufgaben zur Texterkennung. + [StartDocumentAnalysis](API_StartDocumentAnalysis.md)für Textanalyseaufgaben. + [StartExpenseAnalysis](API_StartExpenseAnalysis.md)für Aufgabenanalyseaufgaben. 1. Holen Sie sich den Status der Erledigung aus der Amazon SQS SQS-Warteschlange. Der Beispielcode verfolgt die Job-ID (`JobId`) das wird von der`Start`verwenden. Sie liefert nur die Ergebnisse für übereinstimmende Auftragskennungen, die aus dem Erledigungsstatus gelesen werden. Dies ist wichtig, wenn andere Anwendungen die gleiche Warteschlange und das gleiche Thema verwenden. Der Einfachheit halber werden in diesem Beispiel Aufträge gelöscht, die nicht übereinstimmen. Ziehen Sie in Betracht, die gelöschten Aufträge zur weiteren Untersuchung zu einer Amazon SQS SQS-Warteschlange für unzustellbare Nachrichten hinzufügen. 1. Rufen Sie die Verarbeitungsergebnisse ab und zeigen Sie sie an, indem Sie die entsprechende Operation für den ausgewählten Analysetyp aufrufen: + [GetDocumentTextDetection](API_GetDocumentTextDetection.md)für Aufgaben zur Texterkennung. + [GetDocumentAnalysis](API_GetDocumentAnalysis.md)für Textanalyseaufgaben. + [GetExpenseAnalysis](API_GetExpenseAnalysis.md)für Aufgabenanalyseaufgaben. 1. Löschen Sie das Amazon SNS SNS-Thema und die Amazon SQS SQS-Warteschlange. ## Durchführen von asynchronen Operationen Der Beispielcode für dieses Verfahren wird in Java, Python und demAWS CLIaus. Bevor Sie beginnen, installieren Sie das entsprechendeAWSSDK. Weitere Informationen finden Sie unter [Schritt 2: Einrichten derAWS CLIundAWS-SDKs](setup-awscli-sdk.md) . **So erkennen oder analysieren Sie Text in einem mehrseitigen Dokument** 1. Konfigurieren Sie den Benutzerzugriff auf Amazon Textract und konfigurieren Sie Amazon Textract Textract-Zugriff auf Amazon SNS. Weitere Informationen finden Sie unter [Konfigurieren von Amazon Textract für asynchrone Vorgänge](api-async-roles.md) . Um dieses Verfahren abzuschließen, benötigen Sie ein mehrseitiges Dokument im PDF-Format. Überspringen Sie die Schritte 3 — 6, da der Beispielcode das Amazon SNS SNS-Thema und die Amazon SQS SQS-Warteschlange erstellt und konfiguriert. Wenn kompletIm Beispiel der CLI müssen Sie keine SQS-Warteschlange einrichten. 1. Laden Sie eine mehrseitige Dokumentdatei im PDF- oder TIFF-Format in Ihren Amazon S3 S3-Bucket hoch. (Einzelseitige Dokumente im JPEG-, PNG-, TIFF- oder PDF-Format können ebenfalls verarbeitet werden). Detaillierte Anweisungen finden Sie unter[Hochladen von Objekten in Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/UploadingObjectsintoAmazonS3.html)im*Amazon Simple Storage Service — Benutzerhandbuch*aus. 1. Verwenden Sie FolgendesAWS SDK für Java, SDK for Python (Boto3) oderAWS CLICode, um entweder Text zu erkennen oder Text in einem mehrseitigen Dokument zu analysieren. In der`main`Funktion: + Ersetzen Sie den Wert von`roleArn`In dem IAM-Rollen-ARN, in dem Sie gespeichert haben[Amazon Textract Zugriff auf Ihr Amazon SNS SNS-Thema gewähren](api-async-roles.md#api-async-roles-all-topics)aus. + Ersetzen Sie die Werte von`bucket`und`document`Mit dem Bucket-Namen und dem Namen der Dokumentdatei, die Sie in Schritt 2 angegeben haben. + Ersetzen Sie den Wert des`type`Eingabeparameter des`ProcessDocument`-Funktion mit der Art der Verarbeitung, die Sie ausführen möchten. Verwenden von`ProcessType.DETECTION`um Text zu erkennen. Verwenden von`ProcessType.ANALYSIS`um Text zu analysieren. + Ersetzen Sie für das Python-Beispiel den Wert von`region_name`mit der Region, in der Ihr Kunde tätig ist. Für denAWS CLIBeispiel, führen Sie folgende Schritte aus: + Beim Anrufen[StartDocumentTextDetection](API_StartDocumentTextDetection.md), ersetzen Sie den Wert von`bucket-name`Ersetzen Sie den Namen Ihres S3-Buckets und ersetzen Sie`file-name`Mit dem Namen der Datei, die Sie in Schritt 2 angegeben haben. Geben Sie die Region Ihres Buckets an, indem Sie ersetzen`region-name`mit dem Namen Ihrer Region. Beachten Sie, dass das CLI-Beispiel SQS nicht verwendet. + Beim Anrufen[GetDocumentTextDetection](API_GetDocumentTextDetection.md)ersetzen`job-id-number`mit dem`job-id`zurückgegeben von[StartDocumentTextDetection](API_StartDocumentTextDetection.md)aus. Geben Sie die Region Ihres Buckets an, indem Sie ersetzen`region-name`mit dem Namen Ihrer Region. ------ #### [ Java ] ``` package com.amazonaws.samples; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import com.amazonaws.auth.policy.Condition; import com.amazonaws.auth.policy.Policy; import com.amazonaws.auth.policy.Principal; import com.amazonaws.auth.policy.Resource; import com.amazonaws.auth.policy.Statement; import com.amazonaws.auth.policy.Statement.Effect; import com.amazonaws.auth.policy.actions.SQSActions; import com.amazonaws.services.sns.AmazonSNS; import com.amazonaws.services.sns.AmazonSNSClientBuilder; import com.amazonaws.services.sns.model.CreateTopicRequest; import com.amazonaws.services.sns.model.CreateTopicResult; import com.amazonaws.services.sqs.AmazonSQS; import com.amazonaws.services.sqs.AmazonSQSClientBuilder; import com.amazonaws.services.sqs.model.CreateQueueRequest; import com.amazonaws.services.sqs.model.Message; import com.amazonaws.services.sqs.model.QueueAttributeName; import com.amazonaws.services.sqs.model.SetQueueAttributesRequest; import com.amazonaws.services.textract.AmazonTextract; import com.amazonaws.services.textract.AmazonTextractClientBuilder; import com.amazonaws.services.textract.model.Block; import com.amazonaws.services.textract.model.DocumentLocation; import com.amazonaws.services.textract.model.DocumentMetadata; import com.amazonaws.services.textract.model.GetDocumentAnalysisRequest; import com.amazonaws.services.textract.model.GetDocumentAnalysisResult; import com.amazonaws.services.textract.model.GetDocumentTextDetectionRequest; import com.amazonaws.services.textract.model.GetDocumentTextDetectionResult; import com.amazonaws.services.textract.model.NotificationChannel; import com.amazonaws.services.textract.model.Relationship; import com.amazonaws.services.textract.model.S3Object; import com.amazonaws.services.textract.model.StartDocumentAnalysisRequest; import com.amazonaws.services.textract.model.StartDocumentAnalysisResult; import com.amazonaws.services.textract.model.StartDocumentTextDetectionRequest; import com.amazonaws.services.textract.model.StartDocumentTextDetectionResult; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper;; public class DocumentProcessor { private static String sqsQueueName=null; private static String snsTopicName=null; private static String snsTopicArn = null; private static String roleArn= null; private static String sqsQueueUrl = null; private static String sqsQueueArn = null; private static String startJobId = null; private static String bucket = null; private static String document = null; private static AmazonSQS sqs=null; private static AmazonSNS sns=null; private static AmazonTextract textract = null; public enum ProcessType { DETECTION,ANALYSIS } public static void main(String[] args) throws Exception { String document = "document"; String bucket = "bucket"; String roleArn="role"; sns = AmazonSNSClientBuilder.defaultClient(); sqs= AmazonSQSClientBuilder.defaultClient(); textract=AmazonTextractClientBuilder.defaultClient(); CreateTopicandQueue(); ProcessDocument(bucket,document,roleArn,ProcessType.DETECTION); DeleteTopicandQueue(); System.out.println("Done!"); } // Creates an SNS topic and SQS queue. The queue is subscribed to the topic. static void CreateTopicandQueue() { //create a new SNS topic snsTopicName="AmazonTextractTopic" + Long.toString(System.currentTimeMillis()); CreateTopicRequest createTopicRequest = new CreateTopicRequest(snsTopicName); CreateTopicResult createTopicResult = sns.createTopic(createTopicRequest); snsTopicArn=createTopicResult.getTopicArn(); //Create a new SQS Queue sqsQueueName="AmazonTextractQueue" + Long.toString(System.currentTimeMillis()); final CreateQueueRequest createQueueRequest = new CreateQueueRequest(sqsQueueName); sqsQueueUrl = sqs.createQueue(createQueueRequest).getQueueUrl(); sqsQueueArn = sqs.getQueueAttributes(sqsQueueUrl, Arrays.asList("QueueArn")).getAttributes().get("QueueArn"); //Subscribe SQS queue to SNS topic String sqsSubscriptionArn = sns.subscribe(snsTopicArn, "sqs", sqsQueueArn).getSubscriptionArn(); // Authorize queue Policy policy = new Policy().withStatements( new Statement(Effect.Allow) .withPrincipals(Principal.AllUsers) .withActions(SQSActions.SendMessage) .withResources(new Resource(sqsQueueArn)) .withConditions(new Condition().withType("ArnEquals").withConditionKey("aws:SourceArn").withValues(snsTopicArn)) ); Map queueAttributes = new HashMap(); queueAttributes.put(QueueAttributeName.Policy.toString(), policy.toJson()); sqs.setQueueAttributes(new SetQueueAttributesRequest(sqsQueueUrl, queueAttributes)); System.out.println("Topic arn: " + snsTopicArn); System.out.println("Queue arn: " + sqsQueueArn); System.out.println("Queue url: " + sqsQueueUrl); System.out.println("Queue sub arn: " + sqsSubscriptionArn ); } static void DeleteTopicandQueue() { if (sqs !=null) { sqs.deleteQueue(sqsQueueUrl); System.out.println("SQS queue deleted"); } if (sns!=null) { sns.deleteTopic(snsTopicArn); System.out.println("SNS topic deleted"); } } //Starts the processing of the input document. static void ProcessDocument(String inBucket, String inDocument, String inRoleArn, ProcessType type) throws Exception { bucket=inBucket; document=inDocument; roleArn=inRoleArn; switch(type) { case DETECTION: StartDocumentTextDetection(bucket, document); System.out.println("Processing type: Detection"); break; case ANALYSIS: StartDocumentAnalysis(bucket,document); System.out.println("Processing type: Analysis"); break; default: System.out.println("Invalid processing type. Choose Detection or Analysis"); throw new Exception("Invalid processing type"); } System.out.println("Waiting for job: " + startJobId); //Poll queue for messages List messages=null; int dotLine=0; boolean jobFound=false; //loop until the job status is published. Ignore other messages in queue. do{ messages = sqs.receiveMessage(sqsQueueUrl).getMessages(); if (dotLine++<40){ System.out.print("."); }else{ System.out.println(); dotLine=0; } if (!messages.isEmpty()) { //Loop through messages received. for (Message message: messages) { String notification = message.getBody(); // Get status and job id from notification. ObjectMapper mapper = new ObjectMapper(); JsonNode jsonMessageTree = mapper.readTree(notification); JsonNode messageBodyText = jsonMessageTree.get("Message"); ObjectMapper operationResultMapper = new ObjectMapper(); JsonNode jsonResultTree = operationResultMapper.readTree(messageBodyText.textValue()); JsonNode operationJobId = jsonResultTree.get("JobId"); JsonNode operationStatus = jsonResultTree.get("Status"); System.out.println("Job found was " + operationJobId); // Found job. Get the results and display. if(operationJobId.asText().equals(startJobId)){ jobFound=true; System.out.println("Job id: " + operationJobId ); System.out.println("Status : " + operationStatus.toString()); if (operationStatus.asText().equals("SUCCEEDED")){ switch(type) { case DETECTION: GetDocumentTextDetectionResults(); break; case ANALYSIS: GetDocumentAnalysisResults(); break; default: System.out.println("Invalid processing type. Choose Detection or Analysis"); throw new Exception("Invalid processing type"); } } else{ System.out.println("Document analysis failed"); } sqs.deleteMessage(sqsQueueUrl,message.getReceiptHandle()); } else{ System.out.println("Job received was not job " + startJobId); //Delete unknown message. Consider moving message to dead letter queue sqs.deleteMessage(sqsQueueUrl,message.getReceiptHandle()); } } } else { Thread.sleep(5000); } } while (!jobFound); System.out.println("Finished processing document"); } private static void StartDocumentTextDetection(String bucket, String document) throws Exception{ //Create notification channel NotificationChannel channel= new NotificationChannel() .withSNSTopicArn(snsTopicArn) .withRoleArn(roleArn); StartDocumentTextDetectionRequest req = new StartDocumentTextDetectionRequest() .withDocumentLocation(new DocumentLocation() .withS3Object(new S3Object() .withBucket(bucket) .withName(document))) .withJobTag("DetectingText") .withNotificationChannel(channel); StartDocumentTextDetectionResult startDocumentTextDetectionResult = textract.startDocumentTextDetection(req); startJobId=startDocumentTextDetectionResult.getJobId(); } //Gets the results of processing started by StartDocumentTextDetection private static void GetDocumentTextDetectionResults() throws Exception{ int maxResults=1000; String paginationToken=null; GetDocumentTextDetectionResult response=null; Boolean finished=false; while (finished==false) { GetDocumentTextDetectionRequest documentTextDetectionRequest= new GetDocumentTextDetectionRequest() .withJobId(startJobId) .withMaxResults(maxResults) .withNextToken(paginationToken); response = textract.getDocumentTextDetection(documentTextDetectionRequest); DocumentMetadata documentMetaData=response.getDocumentMetadata(); System.out.println("Pages: " + documentMetaData.getPages().toString()); //Show blocks information List blocks= response.getBlocks(); for (Block block : blocks) { DisplayBlockInfo(block); } paginationToken=response.getNextToken(); if (paginationToken==null) finished=true; } } private static void StartDocumentAnalysis(String bucket, String document) throws Exception{ //Create notification channel NotificationChannel channel= new NotificationChannel() .withSNSTopicArn(snsTopicArn) .withRoleArn(roleArn); StartDocumentAnalysisRequest req = new StartDocumentAnalysisRequest() .withFeatureTypes("TABLES","FORMS") .withDocumentLocation(new DocumentLocation() .withS3Object(new S3Object() .withBucket(bucket) .withName(document))) .withJobTag("AnalyzingText") .withNotificationChannel(channel); StartDocumentAnalysisResult startDocumentAnalysisResult = textract.startDocumentAnalysis(req); startJobId=startDocumentAnalysisResult.getJobId(); } //Gets the results of processing started by StartDocumentAnalysis private static void GetDocumentAnalysisResults() throws Exception{ int maxResults=1000; String paginationToken=null; GetDocumentAnalysisResult response=null; Boolean finished=false; //loops until pagination token is null while (finished==false) { GetDocumentAnalysisRequest documentAnalysisRequest= new GetDocumentAnalysisRequest() .withJobId(startJobId) .withMaxResults(maxResults) .withNextToken(paginationToken); response = textract.getDocumentAnalysis(documentAnalysisRequest); DocumentMetadata documentMetaData=response.getDocumentMetadata(); System.out.println("Pages: " + documentMetaData.getPages().toString()); //Show blocks, confidence and detection times List blocks= response.getBlocks(); for (Block block : blocks) { DisplayBlockInfo(block); } paginationToken=response.getNextToken(); if (paginationToken==null) finished=true; } } //Displays Block information for text detection and text analysis private static void DisplayBlockInfo(Block block) { System.out.println("Block Id : " + block.getId()); if (block.getText()!=null) System.out.println("\tDetected text: " + block.getText()); System.out.println("\tType: " + block.getBlockType()); if (block.getBlockType().equals("PAGE") !=true) { System.out.println("\tConfidence: " + block.getConfidence().toString()); } if(block.getBlockType().equals("CELL")) { System.out.println("\tCell information:"); System.out.println("\t\tColumn: " + block.getColumnIndex()); System.out.println("\t\tRow: " + block.getRowIndex()); System.out.println("\t\tColumn span: " + block.getColumnSpan()); System.out.println("\t\tRow span: " + block.getRowSpan()); } System.out.println("\tRelationships"); List relationships=block.getRelationships(); if(relationships!=null) { for (Relationship relationship : relationships) { System.out.println("\t\tType: " + relationship.getType()); System.out.println("\t\tIDs: " + relationship.getIds().toString()); } } else { System.out.println("\t\tNo related Blocks"); } System.out.println("\tGeometry"); System.out.println("\t\tBounding Box: " + block.getGeometry().getBoundingBox().toString()); System.out.println("\t\tPolygon: " + block.getGeometry().getPolygon().toString()); List entityTypes = block.getEntityTypes(); System.out.println("\tEntity Types"); if(entityTypes!=null) { for (String entityType : entityTypes) { System.out.println("\t\tEntity Type: " + entityType); } } else { System.out.println("\t\tNo entity type"); } if(block.getBlockType().equals("SELECTION_ELEMENT")) { System.out.print(" Selection element detected: "); if (block.getSelectionStatus().equals("SELECTED")){ System.out.println("Selected"); }else { System.out.println(" Not selected"); } } if(block.getPage()!=null) System.out.println("\tPage: " + block.getPage()); System.out.println(); } } ``` ------ #### [ AWS CLI ] DieserAWS CLIstartet die asynchrone Erkennung von Text in einem angegebenen Dokument. Sie gibt zurück.`job-id`das kann verwendet werden, um die Ergebnisse des Nachweises neu zu erstellen. ``` aws textract start-document-text-detection --document-location "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"file-name\"}}" --region region-name ``` DieserAWS CLIgibt die Ergebnisse für einen asynchronen Amazon Textract Textract-Vorgang zurück, wenn sie mit einem`job-id`aus. ``` aws textract get-document-text-detection --region region-name --job-id job-id-number ``` Wenn Sie auf einem Windows-Gerät auf die CLI zugreifen, verwenden Sie doppelte Anführungszeichen anstelle von einfachen Anführungszeichen und entgehen Sie den inneren doppelten Anführungszeichen durch umgekehrten Schrägstrich (d. h.\$1), um eventuell auftretende Parserfehler zu beheben. Ein Beispiel finden Sie nachfolgend. ``` aws textract start-document-text-detection --document-location "{\"S3Object\":{\"Bucket\":\"bucket\",\"Name\":\"document\"}}" --region region-name ``` ------ #### [ Python ] ``` import boto3 import json import sys import time class ProcessType: DETECTION = 1 ANALYSIS = 2 class DocumentProcessor: jobId = '' region_name = '' roleArn = '' bucket = '' document = '' sqsQueueUrl = '' snsTopicArn = '' processType = '' def __init__(self, role, bucket, document, region): self.roleArn = role self.bucket = bucket self.document = document self.region_name = region self.textract = boto3.client('textract', region_name=self.region_name) self.sqs = boto3.client('sqs') self.sns = boto3.client('sns') def ProcessDocument(self, type): jobFound = False self.processType = type validType = False # Determine which type of processing to perform if self.processType == ProcessType.DETECTION: response = self.textract.start_document_text_detection( DocumentLocation={'S3Object': {'Bucket': self.bucket, 'Name': self.document}}, NotificationChannel={'RoleArn': self.roleArn, 'SNSTopicArn': self.snsTopicArn}) print('Processing type: Detection') validType = True if self.processType == ProcessType.ANALYSIS: response = self.textract.start_document_analysis( DocumentLocation={'S3Object': {'Bucket': self.bucket, 'Name': self.document}}, FeatureTypes=["TABLES", "FORMS"], NotificationChannel={'RoleArn': self.roleArn, 'SNSTopicArn': self.snsTopicArn}) print('Processing type: Analysis') validType = True if validType == False: print("Invalid processing type. Choose Detection or Analysis.") return print('Start Job Id: ' + response['JobId']) dotLine = 0 while jobFound == False: sqsResponse = self.sqs.receive_message(QueueUrl=self.sqsQueueUrl, MessageAttributeNames=['ALL'], MaxNumberOfMessages=10) if sqsResponse: if 'Messages' not in sqsResponse: if dotLine < 40: print('.', end='') dotLine = dotLine + 1 else: print() dotLine = 0 sys.stdout.flush() time.sleep(5) continue for message in sqsResponse['Messages']: notification = json.loads(message['Body']) textMessage = json.loads(notification['Message']) print(textMessage['JobId']) print(textMessage['Status']) if str(textMessage['JobId']) == response['JobId']: print('Matching Job Found:' + textMessage['JobId']) jobFound = True self.GetResults(textMessage['JobId']) self.sqs.delete_message(QueueUrl=self.sqsQueueUrl, ReceiptHandle=message['ReceiptHandle']) else: print("Job didn't match:" + str(textMessage['JobId']) + ' : ' + str(response['JobId'])) # Delete the unknown message. Consider sending to dead letter queue self.sqs.delete_message(QueueUrl=self.sqsQueueUrl, ReceiptHandle=message['ReceiptHandle']) print('Done!') def CreateTopicandQueue(self): millis = str(int(round(time.time() * 1000))) # Create SNS topic snsTopicName = "AmazonTextractTopic" + millis topicResponse = self.sns.create_topic(Name=snsTopicName) self.snsTopicArn = topicResponse['TopicArn'] # create SQS queue sqsQueueName = "AmazonTextractQueue" + millis self.sqs.create_queue(QueueName=sqsQueueName) self.sqsQueueUrl = self.sqs.get_queue_url(QueueName=sqsQueueName)['QueueUrl'] attribs = self.sqs.get_queue_attributes(QueueUrl=self.sqsQueueUrl, AttributeNames=['QueueArn'])['Attributes'] sqsQueueArn = attribs['QueueArn'] # Subscribe SQS queue to SNS topic self.sns.subscribe( TopicArn=self.snsTopicArn, Protocol='sqs', Endpoint=sqsQueueArn) # Authorize SNS to write SQS queue policy = """{{ "Version":"2012-10-17", "Statement":[ {{ "Sid":"MyPolicy", "Effect":"Allow", "Principal" : {{"AWS" : "*"}}, "Action":"SQS:SendMessage", "Resource": "{}", "Condition":{{ "ArnEquals":{{ "aws:SourceArn": "{}" }} }} }} ] }}""".format(sqsQueueArn, self.snsTopicArn) response = self.sqs.set_queue_attributes( QueueUrl=self.sqsQueueUrl, Attributes={ 'Policy': policy }) def DeleteTopicandQueue(self): self.sqs.delete_queue(QueueUrl=self.sqsQueueUrl) self.sns.delete_topic(TopicArn=self.snsTopicArn) # Display information about a block def DisplayBlockInfo(self, block): print("Block Id: " + block['Id']) print("Type: " + block['BlockType']) if 'EntityTypes' in block: print('EntityTypes: {}'.format(block['EntityTypes'])) if 'Text' in block: print("Text: " + block['Text']) if block['BlockType'] != 'PAGE': print("Confidence: " + "{:.2f}".format(block['Confidence']) + "%") print('Page: {}'.format(block['Page'])) if block['BlockType'] == 'CELL': print('Cell Information') print('\tColumn: {} '.format(block['ColumnIndex'])) print('\tRow: {}'.format(block['RowIndex'])) print('\tColumn span: {} '.format(block['ColumnSpan'])) print('\tRow span: {}'.format(block['RowSpan'])) if 'Relationships' in block: print('\tRelationships: {}'.format(block['Relationships'])) print('Geometry') print('\tBounding Box: {}'.format(block['Geometry']['BoundingBox'])) print('\tPolygon: {}'.format(block['Geometry']['Polygon'])) if block['BlockType'] == 'SELECTION_ELEMENT': print(' Selection element detected: ', end='') if block['SelectionStatus'] == 'SELECTED': print('Selected') else: print('Not selected') def GetResults(self, jobId): maxResults = 1000 paginationToken = None finished = False while finished == False: response = None if self.processType == ProcessType.ANALYSIS: if paginationToken == None: response = self.textract.get_document_analysis(JobId=jobId, MaxResults=maxResults) else: response = self.textract.get_document_analysis(JobId=jobId, MaxResults=maxResults, NextToken=paginationToken) if self.processType == ProcessType.DETECTION: if paginationToken == None: response = self.textract.get_document_text_detection(JobId=jobId, MaxResults=maxResults) else: response = self.textract.get_document_text_detection(JobId=jobId, MaxResults=maxResults, NextToken=paginationToken) blocks = response['Blocks'] print('Detected Document Text') print('Pages: {}'.format(response['DocumentMetadata']['Pages'])) # Display block information for block in blocks: self.DisplayBlockInfo(block) print() print() if 'NextToken' in response: paginationToken = response['NextToken'] else: finished = True def GetResultsDocumentAnalysis(self, jobId): maxResults = 1000 paginationToken = None finished = False while finished == False: response = None if paginationToken == None: response = self.textract.get_document_analysis(JobId=jobId, MaxResults=maxResults) else: response = self.textract.get_document_analysis(JobId=jobId, MaxResults=maxResults, NextToken=paginationToken) # Get the text blocks blocks = response['Blocks'] print('Analyzed Document Text') print('Pages: {}'.format(response['DocumentMetadata']['Pages'])) # Display block information for block in blocks: self.DisplayBlockInfo(block) print() print() if 'NextToken' in response: paginationToken = response['NextToken'] else: finished = True def main(): roleArn = '' bucket = '' document = '' region_name = '' analyzer = DocumentProcessor(roleArn, bucket, document, region_name) analyzer.CreateTopicandQueue() analyzer.ProcessDocument(ProcessType.DETECTION) analyzer.DeleteTopicandQueue() if __name__ == "__main__": main() ``` ------ #### [ Node.JS ] Ersetzen Sie in diesem Beispiel den Wert von`roleArn`In dem IAM-Rollen-ARN, in dem Sie gespeichert haben[Amazon Textract Zugriff auf Ihr Amazon SNS SNS-Thema gewähren](api-async-roles.md#api-async-roles-all-topics)aus. Ersetzen Sie die Werte von`bucket`und`document`Mit dem Bucket-Namen und dem Namen der Dokumentdatei, die Sie in Schritt 2 oben angegeben haben. Ersetzen Sie den Wert von`processType`mit der Art der Verarbeitung, die Sie für das Eingabedokument verwenden möchten. Ersetzen Sie abschließend den Wert von`REGION`mit der Region, in der Ihr Kunde tätig ist. ``` // snippet-start:[sqs.JavaScript.queues.createQueueV3] // Import required AWS SDK clients and commands for Node.js import { CreateQueueCommand, GetQueueAttributesCommand, GetQueueUrlCommand, SetQueueAttributesCommand, DeleteQueueCommand, ReceiveMessageCommand, DeleteMessageCommand } from "@aws-sdk/client-sqs"; import {CreateTopicCommand, SubscribeCommand, DeleteTopicCommand } from "@aws-sdk/client-sns"; import { SQSClient } from "@aws-sdk/client-sqs"; import { SNSClient } from "@aws-sdk/client-sns"; import { TextractClient, StartDocumentTextDetectionCommand, StartDocumentAnalysisCommand, GetDocumentAnalysisCommand, GetDocumentTextDetectionCommand, DocumentMetadata } from "@aws-sdk/client-textract"; import { stdout } from "process"; // Set the AWS Region. const REGION = "us-east-1"; //e.g. "us-east-1" // Create SNS service object. const sqsClient = new SQSClient({ region: REGION }); const snsClient = new SNSClient({ region: REGION }); const textractClient = new TextractClient({ region: REGION }); // Set bucket and video variables const bucket = "bucket-name"; const documentName = "document-name"; const roleArn = "role-arn" const processType = "DETECTION" var startJobId = "" var ts = Date.now(); const snsTopicName = "AmazonTextractExample" + ts; const snsTopicParams = {Name: snsTopicName} const sqsQueueName = "AmazonTextractQueue-" + ts; // Set the parameters const sqsParams = { QueueName: sqsQueueName, //SQS_QUEUE_URL Attributes: { DelaySeconds: "60", // Number of seconds delay. MessageRetentionPeriod: "86400", // Number of seconds delay. }, }; // Process a document based on operation type const processDocumment = async (type, bucket, videoName, roleArn, sqsQueueUrl, snsTopicArn) => { try { // Set job found and success status to false initially var jobFound = false var succeeded = false var dotLine = 0 var processType = type var validType = false if (processType == "DETECTION"){ var response = await textractClient.send(new StartDocumentTextDetectionCommand({DocumentLocation:{S3Object:{Bucket:bucket, Name:videoName}}, NotificationChannel:{RoleArn: roleArn, SNSTopicArn: snsTopicArn}})) console.log("Processing type: Detection") validType = true } if (processType == "ANALYSIS"){ var response = await textractClient.send(new StartDocumentAnalysisCommand({DocumentLocation:{S3Object:{Bucket:bucket, Name:videoName}}, NotificationChannel:{RoleArn: roleArn, SNSTopicArn: snsTopicArn}})) console.log("Processing type: Analysis") validType = true } if (validType == false){ console.log("Invalid processing type. Choose Detection or Analysis.") return } // while not found, continue to poll for response console.log(`Start Job ID: ${response.JobId}`) while (jobFound == false){ var sqsReceivedResponse = await sqsClient.send(new ReceiveMessageCommand({QueueUrl:sqsQueueUrl, MaxNumberOfMessages:'ALL', MaxNumberOfMessages:10})); if (sqsReceivedResponse){ var responseString = JSON.stringify(sqsReceivedResponse) if (!responseString.includes('Body')){ if (dotLine < 40) { console.log('.') dotLine = dotLine + 1 }else { console.log('') dotLine = 0 }; stdout.write('', () => { console.log(''); }); await new Promise(resolve => setTimeout(resolve, 5000)); continue } } // Once job found, log Job ID and return true if status is succeeded for (var message of sqsReceivedResponse.Messages){ console.log("Retrieved messages:") var notification = JSON.parse(message.Body) var rekMessage = JSON.parse(notification.Message) var messageJobId = rekMessage.JobId if (String(rekMessage.JobId).includes(String(startJobId))){ console.log('Matching job found:') console.log(rekMessage.JobId) jobFound = true // GET RESUlTS FUNCTION HERE var operationResults = await GetResults(processType, rekMessage.JobId) //GET RESULTS FUMCTION HERE console.log(rekMessage.Status) if (String(rekMessage.Status).includes(String("SUCCEEDED"))){ succeeded = true console.log("Job processing succeeded.") var sqsDeleteMessage = await sqsClient.send(new DeleteMessageCommand({QueueUrl:sqsQueueUrl, ReceiptHandle:message.ReceiptHandle})); } }else{ console.log("Provided Job ID did not match returned ID.") var sqsDeleteMessage = await sqsClient.send(new DeleteMessageCommand({QueueUrl:sqsQueueUrl, ReceiptHandle:message.ReceiptHandle})); } } console.log("Done!") } }catch (err) { console.log("Error", err); } } // Create the SNS topic and SQS Queue const createTopicandQueue = async () => { try { // Create SNS topic const topicResponse = await snsClient.send(new CreateTopicCommand(snsTopicParams)); const topicArn = topicResponse.TopicArn console.log("Success", topicResponse); // Create SQS Queue const sqsResponse = await sqsClient.send(new CreateQueueCommand(sqsParams)); console.log("Success", sqsResponse); const sqsQueueCommand = await sqsClient.send(new GetQueueUrlCommand({QueueName: sqsQueueName})) const sqsQueueUrl = sqsQueueCommand.QueueUrl const attribsResponse = await sqsClient.send(new GetQueueAttributesCommand({QueueUrl: sqsQueueUrl, AttributeNames: ['QueueArn']})) const attribs = attribsResponse.Attributes console.log(attribs) const queueArn = attribs.QueueArn // subscribe SQS queue to SNS topic const subscribed = await snsClient.send(new SubscribeCommand({TopicArn: topicArn, Protocol:'sqs', Endpoint: queueArn})) const policy = { Version: "2012-10-17", Statement: [ { Sid: "MyPolicy", Effect: "Allow", Principal: {AWS: "*"}, Action: "SQS:SendMessage", Resource: queueArn, Condition: { ArnEquals: { 'aws:SourceArn': topicArn } } } ] }; const response = sqsClient.send(new SetQueueAttributesCommand({QueueUrl: sqsQueueUrl, Attributes: {Policy: JSON.stringify(policy)}})) console.log(response) console.log(sqsQueueUrl, topicArn) return [sqsQueueUrl, topicArn] } catch (err) { console.log("Error", err); } } const deleteTopicAndQueue = async (sqsQueueUrlArg, snsTopicArnArg) => { const deleteQueue = await sqsClient.send(new DeleteQueueCommand({QueueUrl: sqsQueueUrlArg})); const deleteTopic = await snsClient.send(new DeleteTopicCommand({TopicArn: snsTopicArnArg})); console.log("Successfully deleted.") } const displayBlockInfo = async (block) => { console.log(`Block ID: ${block.Id}`) console.log(`Block Type: ${block.BlockType}`) if (String(block).includes(String("EntityTypes"))){ console.log(`EntityTypes: ${block.EntityTypes}`) } if (String(block).includes(String("Text"))){ console.log(`EntityTypes: ${block.Text}`) } if (!String(block.BlockType).includes('PAGE')){ console.log(`Confidence: ${block.Confidence}`) } console.log(`Page: ${block.Page}`) if (String(block.BlockType).includes("CELL")){ console.log("Cell Information") console.log(`Column: ${block.ColumnIndex}`) console.log(`Row: ${block.RowIndex}`) console.log(`Column Span: ${block.ColumnSpan}`) console.log(`Row Span: ${block.RowSpan}`) if (String(block).includes("Relationships")){ console.log(`Relationships: ${block.Relationships}`) } } console.log("Geometry") console.log(`Bounding Box: ${JSON.stringify(block.Geometry.BoundingBox)}`) console.log(`Polygon: ${JSON.stringify(block.Geometry.Polygon)}`) if (String(block.BlockType).includes('SELECTION_ELEMENT')){ console.log('Selection Element detected:') if (String(block.SelectionStatus).includes('SELECTED')){ console.log('Selected') } else { console.log('Not Selected') } } } const GetResults = async (processType, JobID) => { var maxResults = 1000 var paginationToken = null var finished = false while (finished == false){ var response = null if (processType == 'ANALYSIS'){ if (paginationToken == null){ response = textractClient.send(new GetDocumentAnalysisCommand({JobId:JobID, MaxResults:maxResults})) }else{ response = textractClient.send(new GetDocumentAnalysisCommand({JobId:JobID, MaxResults:maxResults, NextToken:paginationToken})) } } if(processType == 'DETECTION'){ if (paginationToken == null){ response = textractClient.send(new GetDocumentTextDetectionCommand({JobId:JobID, MaxResults:maxResults})) }else{ response = textractClient.send(new GetDocumentTextDetectionCommand({JobId:JobID, MaxResults:maxResults, NextToken:paginationToken})) } } await new Promise(resolve => setTimeout(resolve, 5000)); console.log("Detected Documented Text") console.log(response) //console.log(Object.keys(response)) console.log(typeof(response)) var blocks = (await response).Blocks console.log(blocks) console.log(typeof(blocks)) var docMetadata = (await response).DocumentMetadata var blockString = JSON.stringify(blocks) var parsed = JSON.parse(JSON.stringify(blocks)) console.log(Object.keys(blocks)) console.log(`Pages: ${docMetadata.Pages}`) blocks.forEach((block)=> { displayBlockInfo(block) console.log() console.log() }) //console.log(blocks[0].BlockType) //console.log(blocks[1].BlockType) if(String(response).includes("NextToken")){ paginationToken = response.NextToken }else{ finished = true } } } // DELETE TOPIC AND QUEUE const main = async () => { var sqsAndTopic = await createTopicandQueue(); var process = await processDocumment(processType, bucket, documentName, roleArn, sqsAndTopic[0], sqsAndTopic[1]) var deleteResults = await deleteTopicAndQueue(sqsAndTopic[0], sqsAndTopic[1]) } main() ``` ------ 1. Führen Sie den Code aus. Die Operation kann einige Zeit in Anspruch nehmen. Nach Abschluss des Vorgangs wird eine Liste der Blöcke für erkannten oder analysierten Text angezeigt. # Amazon Textract Ergebnisbenachrichtigung Amazon Textract veröffentlicht die Ergebnisse einer Amazon Textract Textract-Analyseanfrage, einschließlich des Status der Erledigung, an ein Amazon Simple Notification Service (Amazon SNS) -Thema. Um die Benachrichtigung von einem Amazon-SNS-Thema zu erhalten, verwenden Sie eine Amazon SQS SQS-Warteschlange oder eineAWS LambdaFunktion. Weitere Informationen finden Sie unter [Asynchrone Operationen von Amazon Textract aufrufen](api-async.md) . Ein Beispiel finden Sie unter [Erkennen oder Analysieren von Text in einem mehrseitigen Dokument](async-analyzing-with-sqs.md). Die Ergebnisse weisen das folgende JSON-Format auf: ``` { "JobId": "String", "Status": "String", "API": "String", "JobTag": "String", "Timestamp": Number, "DocumentLocation": { "S3ObjectName": "String", "S3Bucket": "String" } } ``` In dieser Tabelle werden die verschiedenen Parameter innerhalb einer Amazon Textract Textract-Antwort beschrieben. | Parameter | Beschreibung | | --- | --- | | JobId | Die eindeutige Kennung, die Amazon Textract dem Job zuweist. Sie stimmt mit einer Auftragskennung überein, die von einem`Start`Betrieb, wie[StartDocumentTextDetection](API_StartDocumentTextDetection.md)aus. | | Status | Der Status des Auftrags. Gültige Werte sind Succeed, Failed oder Error. | | API | Die Amazon Textract Textract-Operation, die zur Analyse des Eingabedokuments verwendet wird, wie z. B.[StartDocumentTextDetection](API_StartDocumentTextDetection.md)oder[StartDocumentAnalysis](API_StartDocumentAnalysis.md)aus. | | JobTag | Die vom Benutzer angegebene Kennung für den Auftrag. Sie geben an`JobTag`in einem Anruf bei der`Start`Betrieb, wie[StartDocumentTextDetection](API_StartDocumentTextDetection.md)aus. | | Zeitstempel | Der Unix-Zeitstempel, der angibt, wann der Job abgeschlossen wurde, wird in Millisekunden zurückgegeben. | | documentLocation | Details zu dem Dokument, das verarbeitet wurde. Umfasst den Dateinamen und den Amazon S3 S3-Bucket, in dem die Datei gespeichert ist. |