Egyidejűség az Azure Functionsben

  • Cikk

Ez a cikk az Eseményvezérelt eseményindítók egyidejű viselkedését ismerteti az Azure Functionsben. Emellett egy új dinamikus modellt is bemutat az egyidejűségi viselkedés optimalizálásához.

A Functions üzemeltetési modellje lehetővé teszi több függvényhívás egyidejű futtatását egyetlen számítási példányon. Vegyük például azt az esetet, amikor három különböző függvényt használ a függvényalkalmazásban, amelyek vertikálisan felskálázhatók, és több példányon futnak. Ebben a forgatókönyvben minden függvény minden olyan virtuálisgép-példány meghívását dolgozza fel, amelyen a függvényalkalmazás fut. A függvényhívások egyetlen példányon ugyanazokon a virtuálisgép-számítási erőforrásokon alapulnak, mint például a memória, a PROCESSZOR és a kapcsolatok. Ha az alkalmazás dinamikus csomagban (Használat vagy Prémium) van üzemeltetve, a platform a bejövő események száma alapján felfelé vagy lefelé skálázza a függvényalkalmazás-példányok számát. További információ: Eseményvezérelt skálázás). Ha dedikált (App Service-) csomagban üzemelteti a függvényeket, manuálisan konfigurálhatja a példányokat, vagy beállíthat egy automatikus méretezési sémát.

Mivel egyszerre több függvényhívás is futtatható az egyes példányokon, minden függvénynek szabályoznia kell, hogy hány egyidejű meghívást dolgoz fel egyszerre.

Statikus egyidejűség

Számos eseményindító támogatja a gazdagépszintű statikus konfigurációs modellt, amely a példányonkénti egyidejűség megadására szolgál az adott eseményindító-típushoz. A Service Bus-eseményindító például egy MaxConcurrentCalls és egy MaxConcurrentSessions beállítást is biztosít a host.json fájlban. Ezek a beállítások együttesen szabályozzák az egyes függvények által az egyes példányokon egyidejűleg futó üzenetek maximális számát. Más triggertípusok beépített mechanizmusokkal rendelkeznek a példányok közötti terheléselosztási meghívásokhoz. Az Event Hubs és az Azure Cosmos DB például partícióalapú sémát használ.

Az egyidejűségi konfigurációt támogató triggertípusok esetében van egy alapértelmezett viselkedés, amelyet felülbírálhat a függvényalkalmazás host.json fájljában. Ezek a beállítások, amelyek az összes futó példányra vonatkoznak, lehetővé teszik a függvények maximális egyidejűségének szabályozását az egyes példányokon. Ha például a függvény processzor- vagy erőforrásigényes, az egyidejűség korlátozását is választhatja, hogy a példányok kifogástalan állapotban maradjanak. Hasonlóképpen, ha a függvény egy szabályozott alsóbb rétegbeli szolgáltatásra irányuló kéréseket küld, érdemes megfontolnia az egyidejűség korlátozását is.

Bár az ilyen egyidejűségi konfigurációk lehetővé teszik bizonyos triggerek viselkedésének szabályozását, például a függvények szabályozását, nehéz lehet meghatározni ezeknek a beállításoknak az optimális értékeit. A terheléstesztelés próba- és hibafolyamatán keresztül általában elfogadható értékeket kell létrehoznia. A csatlakoztatott szolgáltatásokból érkező események száma napról napra változhat, még akkor is, ha egy adott terhelésprofilhoz tartozó értékhalmazt határoz meg. Ez a variabilitás azt jelenti, hogy az alkalmazás gyakran nem optimális értékekkel fut. Előfordulhat például, hogy a függvényalkalmazás a hét utolsó napján különösen nagy terhelésű üzeneteket dolgoz fel, ami megköveteli az egyidejűség szabályozását. A hét hátralévő részében azonban az üzenet hasznos adatai egyszerűbbek, ami azt jelenti, hogy a hét többi részében magasabb egyidejűségi szintet használhat.

Ideális esetben azt szeretnénk, hogy a rendszer lehetővé tegye a példányok számára, hogy a lehető legtöbb munkát dolgozzák fel, miközben az egyes példányok kifogástalan állapotban és késésben vannak, és ezt a dinamikus egyidejűséget tervezték.

Dinamikus egyidejűség

A Functions mostantól egy dinamikus egyidejűségi modellt biztosít, amely leegyszerűsíti az egyidejűség konfigurálását az ugyanabban a csomagban futó összes függvényalkalmazáshoz.

Feljegyzés

A dinamikus egyidejűség jelenleg csak az Azure Blob-, az Azure Queue- és a Service Bus-eseményindítók esetében támogatott, és az alábbi bővítménytámogatási szakaszban felsorolt verziókat kell használnia.

Juttatások

A dinamikus egyidejűség a következő előnyöket nyújtja:

  • Egyszerűsített konfiguráció: Többé nem kell manuálisan meghatároznia az eseményindítónkénti egyidejűségi beállításokat. A rendszer idővel megtanulja a számítási feladat optimális értékeit.
  • Dinamikus kiigazítások: Az egyidejűség dinamikusan, valós időben állítható be, ami lehetővé teszi, hogy a rendszer alkalmazkodjon a változó terhelési mintákhoz az idő függvényében.
  • Példányállapot-védelem: A futtatókörnyezet korlátozza az egyidejűséget olyan szintekre, amelyeken a függvényalkalmazás-példányok kényelmesen kezelhetők. Ez megvédi az alkalmazást attól, hogy túlterhelje magát azáltal, hogy több munkát végez, mint kellene.
  • Továbbfejlesztett átviteli sebesség: Az általános átviteli sebesség javul, mert az egyes példányok nem végeznek több munkát, mint amennyit gyorsan feldolgozhatnak. Ez lehetővé teszi a munka terheléselosztását a példányok között. A nagyobb terheléseket kezelő függvények esetében az egyidejűség az alapértelmezett konfigurációs értékeken túli értékekre növelhető, ami nagyobb átviteli sebességet eredményez.

Dinamikus egyidejűségi konfiguráció

A dinamikus egyidejűség a host.json fájl gazdagépszintjén engedélyezhető. Amikor engedélyezte a függvényalkalmazás által a dinamikus egyidejűséget támogató kötésbővítményeket, szükség szerint dinamikusan módosítsa az egyidejűséget. A dinamikus egyidejűségi beállítások felülbírálják a dinamikus egyidejűséget támogató eseményindítók manuálisan konfigurált egyidejűségi beállításait.

Alapértelmezés szerint a dinamikus egyidejűség le van tiltva. Ha engedélyezve van a dinamikus egyidejűség, az egyidejűség minden függvénynél 1-nél kezdődik, és a gazdagép által meghatározott optimális értékhez van igazítva.

A függvényalkalmazásban a következő beállítások hozzáadásával engedélyezheti a dinamikus egyidejűséget a host.json fájlban:

    { 
        "version": "2.0", 
        "concurrency": { 
            "dynamicConcurrencyEnabled": true, 
            "snapshotPersistenceEnabled": true 
        } 
    }

Ha SnapshotPersistenceEnabled ez trueaz alapértelmezett érték, a rendszer rendszeresen megőrzi a tanult egyidejűségi értékeket a tárolóban, így az új példányok az 1-től kezdődő és a tanulás újrakezdése helyett ezekből az értékekből indulnak ki.

Egyidejűség-kezelő

A színfalak mögött, ha a dinamikus egyidejűség engedélyezve van, egy egyidejűség-kezelő folyamat fut a háttérben. Ez a kezelő folyamatosan figyeli a példányok állapotmetrikáit, például a processzor- és szálkihasználtságot, és szükség szerint módosítja a szabályozásokat. Ha egy vagy több szabályozás engedélyezve van, a függvény egyidejűsége mindaddig vissza lesz állítva, amíg a gazdagép ismét kifogástalan állapotba nem kerül. Ha a szabályozások le vannak tiltva, az egyidejűség növekedhet. A különböző heurisztikus módszerek segítségével intelligensen állíthatja be az egyidejűséget a szabályozások alapján, szükség szerint felfelé vagy lefelé. Idővel az egyes függvények egyidejűsége egy adott szintre stabilizálódik.

Az egyidejűségi szinteket az egyes függvények kezelik. Így a rendszer egyensúlyban van az olyan erőforrás-igényes függvények között, amelyek alacsony szintű egyidejűséget igényelnek, és a magasabb egyidejűséget képes kezelni képes egyszerűsített függvények között. Az egyes függvények egyidejűségének egyensúlya segít fenntartani a függvényalkalmazás-példány általános állapotát.

Ha engedélyezve van a dinamikus egyidejűség, dinamikus egyidejűségi döntéseket fog látni a naplókban. A naplók például akkor jelennek meg, ha a különböző szabályozások engedélyezve vannak, és ha az egyidejűség az egyes függvények esetében felfelé vagy lefelé van állítva. Ezek a naplók a Traces tábla Host.Concurrency napló kategóriájában vannak megírva.

Bővítménytámogatás

A dinamikus egyidejűség engedélyezve van egy függvényalkalmazás esetében a gazdagép szintjén, és a dinamikus egyidejűséget támogató bővítmények ebben a módban futnak. A dinamikus egyidejűség megköveteli a gazdagép és az egyes triggerbővítmények közötti együttműködést. Csak a következő bővítmények felsorolt verziói támogatják a dinamikus egyidejűséget.

Azure Queues

Az Azure Queue Storage-eseményindító saját üzenet-lekérdezési ciklussal rendelkezik. Statikus konfiguráció használatakor az egyidejűséget a BatchSize/NewBatchThreshold konfigurációs beállítások szabályozzák. Dinamikus egyidejűség használatakor a rendszer figyelmen kívül hagyja ezeket a konfigurációs értékeket. A dinamikus egyidejűség integrálva van az üzenethurokba, így az iterációnként lekért üzenetek száma dinamikusan módosul. Ha engedélyezve vannak a szabályozások (a gazdagép túlterhelt), az üzenetek feldolgozása felfüggesztve lesz, amíg le nem tiltja a szabályozásokat. Ha a szabályozások le vannak tiltva, az egyidejűség növekedni fog.

A várólista dinamikus egyidejűségének használatához a tárbővítmény 5.x-es verzióját kell használnia.

Azure Blobs

Az Azure Blob Storage-eseményindító belsőleg ugyanazt az infrastruktúrát használja, amelyet az Azure Queue Trigger használ. Amikor új/frissített blobokat kell feldolgozni, a rendszer egy platform által felügyelt vezérlősorba írja az üzeneteket, és az üzenetsor feldolgozása a QueueTriggerhez használt logikával történik. Ha a dinamikus egyidejűség engedélyezve van, a vezérlősor feldolgozásának egyidejűsége dinamikusan lesz felügyelve.

A blobok dinamikus egyidejűségének használatához a tárbővítmény 5.x-es verzióját kell használnia.

Service Bus

A Service Bus-eseményindító jelenleg három végrehajtási modellt támogat. A dinamikus egyidejűség az alábbiak szerint befolyásolja ezeket a végrehajtási modelleket:

  • Önálló küldési témakör/üzenetsor feldolgozása: A függvény minden hívása egyetlen üzenetet dolgoz fel. Statikus konfiguráció használatakor az egyidejűséget a MaxConcurrentCalls konfigurációs beállítás szabályozza. Dinamikus egyidejűség használatakor a konfigurációs érték figyelmen kívül lesz hagyva, és az egyidejűség dinamikusan módosul.
  • Munkamenet-alapú egyszeri küldési témakör/üzenetsor feldolgozása: A függvény minden hívása egyetlen üzenetet dolgoz fel. A témakör/üzenetsor aktív munkameneteinek számától függően minden példány egy vagy több munkamenetet ad bérbe. Az egyes munkamenetekben lévő üzeneteket a rendszer sorosan dolgozza fel, hogy garantálhassa a munkamenetek sorrendjét. Ha nem dinamikus egyidejűséget használ, az egyidejűséget a MaxConcurrentSessions beállítás szabályozza. Ha engedélyezve van a dinamikus egyidejűség, MaxConcurrentSessions a rendszer figyelmen kívül hagyja, és az egyes példányok által feldolgozott munkamenetek száma dinamikusan módosul.
  • Kötegelt feldolgozás: A függvény minden egyes meghívása egy üzenetköteget dolgoz fel, amelyet a MaxMessageCount beállítás szabályoz. Mivel a köteghívások sorosak, a köteg által aktivált függvény egyidejűsége mindig egy, és a dinamikus egyidejűség nem érvényes.

Ahhoz, hogy a Service Bus-eseményindító dinamikus egyidejűséget használhasson, a Service Bus bővítmény 5.x-es verzióját kell használnia.

Következő lépések

További információkat találhat az alábbi forrásokban: