Hantera stora meddelanden i arbetsflöden med segmentering i Azure Logic Apps

Gäller för: Azure Logic Apps (Förbrukning + Standard)

Azure Logic Apps har olika storleksgränser för meddelandeinnehållet som åtgärderna kan hantera i logikappens arbetsflöden. Dessa gränser varierar beroende på både logikappens resurstyp och den miljö där ett arbetsflöde körs. Begränsningar bidrar också till att minska eventuella omkostnader som uppstår vid lagring och bearbetning av stora meddelanden. Mer information om begränsningar för meddelandestorlek finns i Meddelandegränser i Azure Logic Apps.

Om du använder inbyggda HTTP-åtgärder eller specifika åtgärder för hanterade anslutningsappar för att arbeta med meddelanden som är större än standardgränserna kan du aktivera segmentering. Den här metoden delar upp ett stort meddelande i mindre meddelanden, så att du fortfarande kan överföra stora filer under specifika förhållanden.

För dessa inbyggda HTTP-åtgärder och specifika åtgärder för hanterade anslutningsappar i Azure Logic Apps är uppdelning i delar det enda sättet att bearbeta stora meddelanden. Antingen måste det underliggande HTTP-meddelandeutbytet mellan Azure Logic Apps och andra tjänster använda segmentering, eller så måste anslutningarna som skapats av de hanterade anslutningsprogrammen ha stöd för segmentering.

Den här artikeln innehåller en översikt över vad stora meddelanden betyder, hur segmentering fungerar och hur du konfigurerar segmentering av åtgärder som stöds i Azure Logic Apps.

Vad gör meddelandena "stora"?

Meddelanden är stora baserat på den tjänst som hanterar dessa meddelanden. Den exakta storleksgränsen för stora meddelanden skiljer sig mellan Azure Logic Apps- och anslutningsåtgärder. Varken Azure Logic Apps eller anslutningskontakter kan direkt hantera stora meddelanden utan att dela upp dem.

Information om storleksgränsen för Azure Logic Apps-meddelanden finns i Begränsningar och konfiguration för Azure Logic Apps. För varje anslutnings meddelandestorleksgräns, se anslutningsreferens.

Segmenterad meddelandehantering för Azure Logic Apps

Azure Logic Apps kan inte direkt använda utdata från segmenterade meddelanden som är större än meddelandestorleksgränsen. Endast åtgärder som stöder segmentering kan komma åt meddelandeinnehållet i dessa utdata. En åtgärd som hanterar stora meddelanden måste uppfylla något av följande villkor:

• Åtgärden måste ha inbyggt stöd för segmentering när åtgärden tillhör en anslutning.
• Åtgärden måste ha stöd för segmentering aktiverat i åtgärdens körningskonfiguration.

Annars får du ett körfel när du försöker komma åt stort innehåll.

Chunkad meddelandehantering för kontakter

Tjänster som kommunicerar med Azure Logic Apps kan ha sina egna storleksgränser för meddelanden. Dessa gränser är ofta mindre än gränsen för Azure Logic Apps. Om en anslutningsapp till exempel stöder segmentering kan en anslutningsapp betrakta ett 30 MB-meddelande som stort, medan Azure Logic Apps inte gör det. För att uppfylla den här anslutningsappens gräns delar Azure Logic Apps upp alla meddelanden som är större än 30 MB i mindre segment.

För anslutningar som stöder segmentering är det underliggande segmenteringsprotokollet osynligt för slutanvändare. Alla anslutningsappar stöder inte segmentering. Anslutningar som inte stöder detta genererar körfel när inkommande meddelanden överskrider storleksgränserna för anslutningar.

För åtgärder som stöder och är aktiverade för segmentering kan du inte använda utlösarkroppar, variabler och uttryck som triggerBody()?['Content']. Om du använder någon av dessa indata förhindras segmenteringsåtgärden. Använd i stället åtgärden Komponera. Mer specifikt skapar du ett body fält med hjälp av åtgärden Komponera för att lagra utdata från trigger-kroppen, variabeln, uttrycket och så vidare, till exempel:

"Compose": {
    "inputs": {
        "body": "@variables('myVar1')"
    },
    "runAfter": {
        "Until": [
            "Succeeded"
        ]
    },
    "type": "Compose"
},

Om du vill referera till data använder du uttrycket body('Compose')i segmenteringsåtgärden, till exempel:

"Create_file": {
    "inputs": {
        "body": "@body('Compose')",
        "headers": {
            "ReadFileMetadataFromServer": true
        },
        "host": {
            "connection": {
                "name": "@parameters('$connections')['sftpwithssh_1']['connectionId']"
            }
        },
        "method": "post",
        "path": "/datasets/default/files",
        "queries": {
            "folderPath": "/c:/test1/test1sub",
            "name": "tt.txt",
            "queryParametersSingleEncoded": true
        }
    },
    "runAfter": {
        "Compose": [
            "Succeeded"
        ]
    },
    "runtimeConfiguration": {
        "contentTransfer": {
            "transferMode": "Chunked"
        }
    },
    "type": "ApiConnection"
},

Konfigurera segmentering över HTTP

I allmänna HTTP-scenarier kan du dela upp stora innehållshämtningar och uppladdningar via HTTP så att arbetsflödet kan utbyta stora meddelanden med en extern slutpunkt. Du måste dela upp meddelanden på det sätt som Azure Logic Apps förväntar sig.

Om en extern slutpunkt har konfigurerats för segmentnedladdningar eller uppladdningar segmenterar HTTP-åtgärderna i arbetsflödet automatiskt stora meddelanden. Annars måste du konfigurera stöd för segmentering på slutpunkten. Om du inte äger eller kontrollerar slutpunkten kanske du inte kan konfigurera segmentering.

Om en HTTP-åtgärd inte redan har segmentering aktiverat måste du konfigurera segmentering via åtgärdens runTimeConfiguration egenskap. Du kan konfigurera den här egenskapen i åtgärdsdefinitionen med hjälp av kodvisningsredigeraren enligt beskrivningen senare eller i arbetsflödesdesignern enligt beskrivningen här:

1. I designern väljer du HTTP-åtgärden för att öppna åtgärdsinformationsfönstret och väljer sedan Inställningar.

2. Under Innehållsöverföring anger du Tillåt segmentering till På.

   

3. Om du vill slutföra konfigurationen av segmentering för nedladdningar eller uppladdningar fortsätter du med följande avsnitt.

Ladda ned innehåll i segment

När du laddar ned innehåll från en extern slutpunkt med hjälp av en HTTP GET-begäran skickar många externa slutpunkter stora meddelanden automatiskt i segment. Det här beteendet kräver att slutpunkten stöder partiella innehållsbegäranden eller segmenterade nedladdningar. Om en åtgärd i arbetsflödet skickar en HTTP GET-begäran om att ladda ned innehåll från en extern slutpunkt, och slutpunkten svarar med statuskoden 206 Partiellt innehåll , innehåller svaret segmenterat innehåll.

Azure Logic Apps kan inte styra om en extern slutpunkt stöder partiella innehållsbegäranden. När den begärande åtgärden i arbetsflödet får det första svaret med statuskoden 206 Partiellt innehåll skickar åtgärden automatiskt flera begäranden om att ladda ned allt innehåll.

Om du vill kontrollera om en extern slutpunkt stöder partiellt innehåll skickar du en HTTP HEAD-begäran som ber om ett svar med endast statusraden och rubrikavsnittet, vilket utelämnar svarstexten. Den här begäran hjälper dig att avgöra om svaret innehåller Accept-Ranges huvud.

Om slutpunkten stöder partiellt innehåll som segmenterade nedladdningar men inte skickar segmenterat innehåll kan du föreslå det här alternativet genom att ange Range rubriken i DIN HTTP GET-begäran.

Följande steg beskriver den process som Azure Logic Apps använder för att ladda ned segmenterat innehåll från en extern slutpunkt till ditt arbetsflöde:

1. I arbetsflödet skickar en åtgärd en HTTP GET-begäran till slutpunkten.

   Begärandehuvudet kan också innehålla ett Range fält som beskriver ett byteintervall för att begära innehållssegment.

2. Slutpunkten svarar med 206 statuskoden och en HTTP-meddelandetext.

   Information om innehållet i det här segmentet visas i svarets Content-Range rubrik. Den här informationen innehåller information som hjälper Azure Logic Apps att fastställa början och slutet för segmentet, plus den totala storleken på hela innehållet innan segmenteringen.

3. Åtgärden skickar automatiskt uppföljande HTTP GET-begäranden tills allt innehåll hämtas.

Till exempel visar följande åtgärdsdefinition en HTTP GET-begäran som anger Range headern. Rubriken föreslår att slutpunkten svarar med segmenterat innehåll:

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

GET-begäran anger Range rubriken till bytes=0-1023 för att ange byteintervallet. Om slutpunkten stöder begäranden om partiellt innehåll svarar slutpunkten med ett innehållssegment från det begärda intervallet. Baserat på slutpunkten kan det exakta formatet för Range rubrikfältet skilja sig åt.

Ladda upp innehåll i segment

Om du vill ladda upp innehåll i segment från en HTTP-åtgärd måste du konfigurera stöd för segmentering genom att ange åtgärdens runtimeConfiguration egenskap. Med den här inställningen kan åtgärden starta segmenteringsprotokollet.

Åtgärden kan sedan skicka ett första POST- eller PUT-meddelande till den externa slutpunkten. När slutpunkten svarar med en föreslagen segmentstorlek följer åtgärden upp genom att skicka HTTP PATCH-begäranden som innehåller innehållssegmenten.

Följande steg beskriver den detaljerade process som Azure Logic Apps använder för att ladda upp segmenterat innehåll från en åtgärd i arbetsflödet till en extern slutpunkt:

1. I arbetsflödet skickar en åtgärd en första HTTP POST- eller PUT-begäran med en tom meddelandetext.

   Begärandehuvudet innehåller följande information om innehållet som logikappen vill ladda upp i segment:

   Fält för begärandehuvud	Värde	Typ	Beskrivning
   x-ms-transfer-mode	Uppdelad	Sträng	Anger att innehållet laddas upp i segment
   x-ms-content-length	< innehållslängd>	Integer	Hela innehållsstorleken i byte före segmentering

2. Slutpunkten svarar med 200 lyckad statuskod och följande information:

   Fält för sidhuvud för slutpunktssvar	Typ	Krävs	Beskrivning
   Plats	Sträng	Ja	Url-platsen där HTTP PATCH-meddelanden ska skickas
   x-ms-chunk-size	Integer	Nej	Den föreslagna segmentstorleken i byte

3. Arbetsflödesåtgärden skapar och skickar uppföljande HTTP PATCH-meddelanden, var och en med följande information:

   • Ett innehållssegment baserat på x-ms-chunk-size eller en internt beräknad storlek tills allt innehåll som summerar x-ms-content-length laddas upp sekventiellt

   • Följande rubrikinformation om innehållssegmentet som skickas i varje PATCH-meddelande:

     Fält för begärandehuvud	Värde	Typ	Beskrivning
     Content-Range	< omfång>	Sträng	Byteintervallet för det aktuella innehållssegmentet, inklusive startvärdet, slutvärdet och den totala innehållsstorleken, till exempel: bytes=0-1023/10100
     Innehållstyp	< innehållstyp>	Sträng	Typ av segmenterat innehåll
     Innehållslängd	< innehållslängd>	Sträng	Längden i byte för den aktuella delen

4. Efter varje PATCH-begäran bekräftar slutpunkten kvittot för varje segment genom att svara med 200 statuskoden och följande svarshuvuden:

   Fält för sidhuvud för slutpunktssvar	Typ	Krävs	Beskrivning
   Intervall	Sträng	Ja	Byteintervallet för innehåll som tas emot av slutpunkten, till exempel: bytes=0-1023
   x-ms-chunk-size	Integer	Nej	Den föreslagna segmentstorleken i byte

Följande åtgärdsdefinition visar till exempel en HTTP POST-begäran om att ladda upp segmenterat innehåll till en slutpunkt. I åtgärdens runTimeConfiguration egenskap contentTransfer anges transferMode egenskapen till chunked:

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