Verarbeiten von großen Nachrichten durch Blockerstellung in Azure Logic AppsHandle large messages with chunking in Azure Logic Apps

Beim Verarbeiten von Nachrichten begrenzt Logic Apps Nachrichteninhalt auf eine maximale Größe.When handling messages, Logic Apps limits message content to a maximum size. Dieser Grenzwert ermöglicht ein Verringern des Mehraufwands, der durch das Speichern und Verarbeiten von großen Nachrichten verursacht wird.This limit helps reduce overhead created by storing and processing large messages. Sollen Nachrichten verarbeitet werden, die größer sind, als dieser Grenzwert angibt, kann Logic Apps eine große Nachricht durch Blockerstellung in kleinere Nachrichten aufteilen.To handle messages larger than this limit, Logic Apps can chunk a large message into smaller messages. Auf diese Weise können Sie weiterhin große Dateien unter bestimmten Bedingungen mit Logic Apps übertragen.That way, you can still transfer large files using Logic Apps under specific conditions. Bei der Kommunikation mit anderen Diensten über Connectors oder HTTP kann Logic Apps große Nachrichten verarbeiten, jedoch nur in Blöcken.When communicating with other services through connectors or HTTP, Logic Apps can consume large messages but only in chunks. Diese Bedingung bedeutet, dass auch Connectors Blockerstellung unterstützen müssen oder der zugrunde liegende HTTP-Nachrichtenaustausch zwischen Logic Apps und diesen Diensten Blockerstellung verwenden muss.This condition means connectors must also support chunking, or the underlying HTTP message exchange between Logic Apps and these services must use chunking.

In diesem Artikel wird gezeigt, wie Sie die Blockerstellung für Aktionen im Zusammenhang mit Nachrichten einrichten, deren Größe den Grenzwert übersteigt.This article shows how you can set up chunking for actions handling messages that are larger than the limit. Logik-App-Trigger unterstützen die Blockerstellung aufgrund des Mehraufwands für den Austausch mehrerer Nachrichten nicht.Logic App triggers don't support chunking because of the increased overhead of exchanging multiple messages.

Was macht Nachrichten „groß“?What makes messages "large"?

Nachrichten sind „groß“ in Bezug auf den Dienst, von dem diese Nachrichten verarbeitet werden.Messages are "large" based on the service handling those messages. Die genaue Größenbeschränkung für große Nachrichten ist zwischen Logic Apps und Connectors unterschiedlich.The exact size limit on large messages differs across Logic Apps and connectors. Sowohl Logic Apps als auch Connectors können große Nachrichten nicht direkt verarbeiten, weshalb diese in Blöcke aufgeteilt werden müssen.Both Logic Apps and connectors can't directly consume large messages, which must be chunked. Informationen zur Logic Apps-Größenbeschränkung für Nachrichten finden Sie unter Grenzwerte und Konfigurationsinformationen für Azure Logic Apps.For the Logic Apps message size limit, see Logic Apps limits and configuration. Informationen zu der Nachrichtengrößenbeschränkung für jeden Connector finden Sie in den speziellen technischen Details der Connectors.For each connector's message size limit, see the connector's specific technical details.

Logic Apps-Verarbeitung von Nachrichten, die in Blöcke aufgeteilt sindChunked message handling for Logic Apps

Logic Apps kann Ausgaben von Nachrichten, die wegen der Überschreitung der Nachrichtengrößenbeschränkung in Blöcke aufgeteilt wurden, nicht direkt verwenden.Logic Apps can't directly use outputs from chunked messages that are larger than the message size limit. Nur Aktionen, die Blockerstellung unterstützen, können auf die Nachrichteninhalte in diesen Ausgaben zugreifen.Only actions that support chunking can access the message content in these outputs. Daher muss eine Aktion, die große Nachrichten verarbeitet, eines dieser Kriterien erfüllen:So, an action that handles large messages must meet either these criteria:

  • Systemeigene Unterstützung für Blockerstellung, wenn diese Aktion zu einem Connector gehört.Natively support chunking when that action belongs to a connector.
  • In der Laufzeitkonfiguration dieser Aktion muss die Unterstützung von Blockerstellung aktiviert sein.Have chunking support enabled in that action's runtime configuration.

Andernfalls erhalten Sie einen Laufzeitfehler, wenn Sie versuchen, auf große Inhaltsausgaben zuzugreifen.Otherwise, you get a runtime error when you try to access large content output. Informationen dazu, wie Blockerstellung aktiviert wird, finden Sie unter Einrichten der Blockerstellungsunterstützung.To enable chunking, see Set up chunking support.

Connector-Verarbeitung von Nachrichten, die in Blöcke aufgeteilt sindChunked message handling for connectors

Dienste, die mit Logic Apps kommunizieren, haben möglicherweise eigene Nachrichtengrößenbeschränkungen.Services that communicate with Logic Apps can have their own message size limits. Diese Beschränkungen sind häufig kleiner als die Logic Apps-Beschränkung.These limits are often smaller than the Logic Apps limit. Nehmen Sie beispielsweise an, dass ein Connector, der Blockerstellung unterstützt, eine 30-MB-Nachricht als groß einstuft, während Logic Apps dies nicht tut.For example, assuming that a connector supports chunking, a connector might consider a 30-MB message as large, while Logic Apps does not. Um dieser Beschränkung des Connectors zu genügen, teilt Logic Apps jede Nachricht, die größer als 30 MB ist, in kleinere Blöcke auf.To comply with this connector's limit, Logic Apps splits any message larger than 30 MB into smaller chunks.

Für Connectors, die Blockerstellung unterstützen, ist das zugrunde liegende Blockerstellungsprotokolls für Endbenutzer nicht sichtbar.For connectors that support chunking, the underlying chunking protocol is invisible to end users. Allerdings unterstützen nicht alle Connectors Blockerstellung, sodass diese Connectors Laufzeitfehler generieren, wenn eingehende Nachrichten die Größenbeschränkungen des jeweiligen Connectors überschreiten.However, not all connectors support chunking, so these connectors generate runtime errors when incoming messages exceed the connectors' size limits.

Hinweis

Bei Aktionen mit Segmentierung können Sie den Triggertext nicht übergeben oder Ausdrücke wie @triggerBody()?['Content'] verwenden.For actions that use chunking, you can't pass the trigger body or use expressions such as @triggerBody()?['Content'] in those actions. Stattdessen können Sie für Textdatei- oder JSON-Dateiinhalte die Aktionen Verfassen oder Create a variable (Variable erstellen) verwenden, um den Inhalt zu verarbeiten.Instead, for text or JSON file content, you can try using the Compose action or create a variable to handle that content. Wenn der Triggertext andere Inhaltstypen wie beispielsweise Mediendateien enthält, müssen Sie weitere Schritte ausführen, um diesen Inhalt zu verarbeiten.If the trigger body contains other content types, such as media files, you need to perform other steps to handle that content.

Einrichten von Blockerstellung über HTTPSet up chunking over HTTP

In generischen HTTP-Szenarien können Sie herunter- oder hochzuladende Objekte mit großen Inhalten über HTTP aufteilen, sodass Ihre Logik-App und ein Endpunkt große Nachrichten austauschen können.In generic HTTP scenarios, you can split up large content downloads and uploads over HTTP, so that your logic app and an endpoint can exchange large messages. Allerdings müssen Sie Nachrichten so in Blöcke aufteilen, wie dies von Logic Apps erwartet wird.However, you must chunk messages in the way that Logic Apps expects.

Ist für einen Endpunkt Blockerstellung für Downloads oder Uploads aktiviert, werden große Nachrichten von den HTTP-Aktionen in Ihrer Logik-App automatisch in Blöcke aufgeteilt.If an endpoint has enabled chunking for downloads or uploads, the HTTP actions in your logic app automatically chunk large messages. Andernfalls müssen Sie Blockerstellungsunterstützung auf dem Endpunkt einrichten.Otherwise, you must set up chunking support on the endpoint. Wenn Sie den Endpunkt oder Connector nicht besitzen oder steuern, haben Sie möglicherweise keine Möglichkeit, Blockerstellung einzurichten.If you don't own or control the endpoint or connector, you might not have the option to set up chunking.

Außerdem müssen Sie, wenn eine HTTP-Aktion Blockerstellung noch nicht unterstützt, Blockerstellung auch in runTimeConfiguration-Eigenschaft der Aktion einrichten.Also, if an HTTP action doesn't already enable chunking, you must also set up chunking in the action's runTimeConfiguration property. Sie können diese Eigenschaft innerhalb der Aktion festlegen, entweder direkt im Codeansicht-Editor, wie dies weiter unten beschrieben ist, oder im Designer für Logik-Apps, wie dies hier beschrieben ist:You can set this property inside the action, either directly in the code view editor as described later, or in the Logic Apps Designer as described here:

  1. Wählen Sie in der oberen rechten Ecke der HTTP-Aktion die Ellipsenschaltfläche ( ... ) aus, und wählen Sie dann Einstellungen aus.In the HTTP action's upper-right corner, choose the ellipsis button (...), and then choose Settings.

    Menü „Einstellungen“ für die Aktion öffnen

  2. Legen Sie unter Inhaltsübertragung die Option Segmentierung zulassen auf Ein fest.Under Content Transfer, set Allow chunking to On.

    Aktivieren von Segmentierung (Blockerstellung)

  3. Setzen Sie das Einrichten der Segmentierung (Blockerstellung) für Downloads oder Uploads fort, indem Sie die Schritte in den folgenden Abschnitten ausführen.To continue setting up chunking for downloads or uploads, continue with the following sections.

Herunterladen von Inhalten in BlöckenDownload content in chunks

Viele Endpunkte senden große Nachrichten, wenn diese über eine HTTP-GET-Anforderung heruntergeladen werden, automatisch in Blöcken.Many endpoints automatically send large messages in chunks when downloaded through an HTTP GET request. Damit in Blöcken vorliegende (segmentierte) Nachrichten von einem Endpunkt über HTTP heruntergeladen werden können, muss der Endpunkt partielle Inhaltsanforderungen oder segmentierte Downloads unterstützen.To download chunked messages from an endpoint over HTTP, the endpoint must support partial content requests, or chunked downloads. Wenn Ihre Logik-App eine HTTP-GET-Anforderung zum Herunterladen von Inhalt an einen Endpunkt sendet und der Endpunkt mit dem Statuscode „206“ antwortet, enthält die Antwort segmentierten Inhalt.When your logic app sends an HTTP GET request to an endpoint for downloading content, and the endpoint responds with a "206" status code, the response contains chunked content. Logic Apps kann nicht steuern, ob ein Endpunkt partielle Anforderungen unterstützt.Logic Apps can't control whether an endpoint supports partial requests. Wenn Ihre Logik-App aber die erste „206“-Antwort empfangen hat, sendet sie automatisch mehrere Anforderungen, um den gesamten Inhalt herunterzuladen.However, when your logic app gets the first "206" response, your logic app automatically sends multiple requests to download all the content.

Um zu überprüfen, ob ein Endpunkt partiellen Inhalt unterstützen kann, senden Sie eine HEAD-Anforderung.To check whether an endpoint can support partial content, send a HEAD request. Über diese Anforderung können Sie ermitteln, ob die Antwort den Accept-Ranges-Header enthält.This request helps you determine whether the response contains the Accept-Ranges header. Auf diese Weise können Sie, wenn der Endpunkt segmentierte Downloads unterstützt, aber keinen segmentierten Inhalt sendet, diese Option vorschlagen, indem Sie den Range-Header in Ihrer HTTP-GET-Anforderung festlegen.That way, if the endpoint supports chunked downloads but doesn't send chunked content, you can suggest this option by setting the Range header in your HTTP GET request.

In den folgenden Schritten ist die Vorgehensweise ausführlich beschrieben, in der Logic Apps segmentierten Inhalt von einem Endpunkt in Ihre Logik-App herunterlädt:These steps describe the detailed process Logic Apps uses for downloading chunked content from an endpoint to your logic app:

  1. Ihre Logik-App sendet eine HTTP-GET-Anforderung an den Endpunkt.Your logic app sends an HTTP GET request to the endpoint.

    Der Anforderungsheader kann optional ein Range-Feld enthalten, in dem ein Bytebereich für das Anfordern von Inhaltsblöcken beschrieben ist.The request header can optionally include a Range field that describes a byte range for requesting content chunks.

  2. Der Endpunkt antwortet mit dem Statuscode „206“ und einem HTTP-Nachrichtentext.The endpoint responds with the "206" status code and an HTTP message body.

    Details über den Inhalt in diesem Block (Segment) werden im Content-Range-Header der Antwort angezeigt. Dazu gehören auch die Informationen, anhand denen Logic Apps den Anfang und das Ende des Blocks sowie die Gesamtgröße ermittelt, die der Inhalt vor der Blockerstellung hatte.Details about the content in this chunk appear in the response's Content-Range header, including information that helps Logic Apps determine the start and end for the chunk, plus the total size of the entire content before chunking.

  3. Ihre Logik-App sendet automatisch entsprechende weitere HTTP-GET-Anforderungen.Your logic app automatically sends follow-up HTTP GET requests.

    Ihre Logik-App sendet weitere GET-Anforderungen, bis der gesamte Inhalt abgerufen ist.Your logic app sends follow-up GET requests until the entire content is retrieved.

Zum Beispiel ist in dieser Aktionsdefinition eine HTTP GET-Anforderung zu sehen, in der der Range-Header festgelegt wird.For example, this action definition shows an HTTP GET request that sets the Range header. Im Header wird vorgeschlagen, dass der Endpunkt mit segmentiertem Inhalt antworten soll:The header suggests that the endpoint should respond with chunked content:

"getAction": {
    "inputs": {
        "headers": {
            "Range": "bytes=0-1023"
        },
       "method": "GET",
       "uri": "http://myAPIendpoint/api/downloadContent"
    },
    "runAfter": {},
    "type": "Http"
}

Die GET-Anforderung legt den „Range“-Header auf „bytes=0-1023“ fest, was der Bereich für Bytes ist.The GET request sets the "Range" header to "bytes=0-1023", which is the range of bytes. Wenn der Endpunkt Anforderungen zu partiellem Inhalt unterstützt, antwortet er mit einem Inhaltsblock aus dem angeforderten Bereich.If the endpoint supports requests for partial content, the endpoint responds with a content chunk from the requested range. Je nach Endpunkt kann das genaue Format für das „Range“-Headerfeld unterschiedlich sein.Based on the endpoint, the exact format for the "Range" header field can differ.

Hochladen von Inhalten in BlöckenUpload content in chunks

Damit in einer HTTP-Aktion segmentierter Inhalt hochgeladen werden kann, muss Blockerstellungsunterstützung für die Aktion über deren runtimeConfiguration-Eigenschaft aktiviert sein.To upload chunked content from an HTTP action, the action must have enabled chunking support through the action's runtimeConfiguration property. Diese Einstellung versetzt die Aktion in die Lage, das Blockerstellungsprotokoll zu starten.This setting permits the action to start the chunking protocol. Ihre Logik-App kann dann eine erste POST- oder PUT-Nachricht an den Zielendpunkt senden.Your logic app can then send an initial POST or PUT message to the target endpoint. Nachdem der Endpunkt mit einer vorgeschlagenen Blockgröße (Segmentgröße) geantwortet hat, sendet Ihre Logik-App im Anschluss HTTP-PATCH-Anforderungen, die die Inhaltsblöcke enthalten.After the endpoint responds with a suggested chunk size, your logic app follows up by sending HTTP PATCH requests that contain the content chunks.

In den folgenden Schritten ist die Vorgehensweise ausführlich beschrieben, in der Logic Apps segmentierten Inhalt von Ihrer Logik-App in einen Endpunkt hochlädt:These steps describe the detailed process Logic Apps uses for uploading chunked content from your logic app to an endpoint:

  1. Ihre Logik-App sendet eine erste HTTP-POST- oder -PUT-Anforderung mit einem leeren Nachrichtentext.Your logic app sends an initial HTTP POST or PUT request with an empty message body. Die Anforderungsheader enthält diese Informationen zu dem Inhalt, den Ihre Logik-App in Blöcken hochladen möchte:The request header, includes this information about the content that your logic app wants to upload in chunks:

    Logic Apps-Feld für AnforderungsheaderLogic Apps request header field valueValue typeType BESCHREIBUNGDescription
    x-ms-transfer-modex-ms-transfer-mode chunkedchunked StringString Gibt an, dass der Inhalt in Blöcken (Segmenten) hochgeladen wirdIndicates that the content is uploaded in chunks
    x-ms-content-lengthx-ms-content-length <Inhaltslänge><content-length> IntegerInteger Der Gesamtgröße des Inhalts in Bytes vor der BlockerstellungThe entire content size in bytes before chunking
  2. Der Endpunkt antwortet mit dem Erfolgsstatuscode „200“ und diesen optionalen Informationen:The endpoint responds with "200" success status code and this optional information:

    Endpunktfeld für AntwortheaderEndpoint response header field typeType ErforderlichRequired BESCHREIBUNGDescription
    x-ms-chunk-sizex-ms-chunk-size IntegerInteger NeinNo Der vorgeschlagene Blockgröße in BytesThe suggested chunk size in bytes
    LocationLocation StringString JaYes Die URL-Adresse, an die die HTTP-PATCH-Nachrichten gesendet werden sollenThe URL location where to send the HTTP PATCH messages
  3. Ihre Logik-App erstellt und sendet nacheinander HTTP-PATCH-Nachrichten, wobei jede Nachricht diese Informationen enthält:Your logic app creates and sends follow-up HTTP PATCH messages - each with this information:

    • Einen Inhaltsblock, dessen Größe dem Wert von x-ms-chunk-size oder einem intern berechneten Wert entspricht, bis der gesamte Inhalt entsprechend x-ms-content-length sequenziell hochgeladen istA content chunk based on x-ms-chunk-size or some internally calculated size until all the content totaling x-ms-content-length is sequentially uploaded

    • Im Header sind diese Details zu dem Inhaltsblock enthalten, der in der jeweiligen PATCH-Nachricht gesendet wurde:These header details about the content chunk sent in each PATCH message:

      Logic Apps-Feld für AnforderungsheaderLogic Apps request header field valueValue typeType BESCHREIBUNGDescription
      Content-RangeContent-Range <Bereich><range> StringString Der Bytebereich für den aktuellen Inhaltsblock, einschließlich des Anfangswerts, des Endwerts und der Gesamtgröße des Inhalts, zum Beispiel: „bytes=0-1023/10100“The byte range for the current content chunk, including the starting value, ending value, and the total content size, for example: "bytes=0-1023/10100"
      Content-TypeContent-Type <Inhaltstyp><content-type> StringString Der Typ des segmentierten (in Blöcke aufgeteilten) InhaltsThe type of chunked content
      Content-LengthContent-Length <Inhaltslänge><content-length> StringString Die Länge des aktuellen Blocks in BytesThe length of size in bytes of the current chunk
  4. Nach jeder PATCH-Anforderung bestätigt der Endpunkt den Empfang des entsprechenden Blocks durch Antworten mit dem Statuscode „200“ und den folgenden Antwortheadern:After each PATCH request, the endpoint confirms the receipt for each chunk by responding with the "200" status code and the following response headers:

    Endpunktfeld für AntwortheaderEndpoint response header field typeType ErforderlichRequired BESCHREIBUNGDescription
    BereichRange StringString JaYes Der Bytebereich für Inhalt, der vom Endpunkt empfangen wurde, z. B.: „bytes=0-1023“The byte range for content that has been received by the endpoint, for example: "bytes=0-1023"
    x-ms-chunk-sizex-ms-chunk-size IntegerInteger NeinNo Der vorgeschlagene Blockgröße in BytesThe suggested chunk size in bytes

In dieser Aktionsdefinition ist z. B. eine HTTP-POST-Anforderung gezeigt, in der segmentierter Inhalt an einen Endpunkt hochgeladen wird.For example, this action definition shows an HTTP POST request for uploading chunked content to an endpoint. In der runTimeConfiguration-Eigenschaft der Aktion wird die contentTransfer-Eigenschaft transferMode auf chunked festgelegt:In the action's runTimeConfiguration property, the contentTransfer property sets transferMode to chunked:

"postAction": {
    "runtimeConfiguration": {
        "contentTransfer": {
            "transferMode": "chunked"
        }
    },
    "inputs": {
        "method": "POST",
        "uri": "http://myAPIendpoint/api/action",
        "body": "@body('getAction')"
    },
    "runAfter": {
    "getAction": ["Succeeded"]
    },
    "type": "Http"
}