A Azure Functions teljesítményének és megbízhatóságának javítása
Ez a cikk útmutatást nyújt a kiszolgáló nélküli függvényalkalmazások teljesítményének és megbízhatóságának javításához. Általánosabb Azure Functions ajánlott eljárásokért lásd: Azure Functions ajánlott eljárások.
Az alábbiakban a kiszolgáló nélküli megoldások Azure Functions használatával történő összeállításához és kialakításához ajánlott eljárásokat talál.
Kerülje a hosszú ideig futó függvényeket
A nagyméretű, hosszú ideig futó függvények váratlan időtúllépési problémákat okozhatnak. Ha többet szeretne megtudni egy adott üzemeltetési csomag időtúllépéseiről, tekintse meg a függvényalkalmazás időtúllépési időtartamát ismertető cikket.
A függvények sok Node.js függőség miatt nagy méretűvé válhatnak. A függőségek importálása megnövekedett betöltési időt is okozhat, ami váratlan időtúllépéseket eredményezhet. A függőségek explicit módon és implicit módon is betölthetők. A kód által betöltött egyetlen modul saját további modulokat is betölthet.
Amikor csak lehetséges, bontsa újra a nagy függvényeket kisebb függvénykészletekké, amelyek együttműködnek, és gyorsan visszaadják a válaszokat. Egy webhook- vagy HTTP-triggerfüggvényhez például egy bizonyos időkorláton belül nyugtázási válaszra lehet szükség; gyakori, hogy a webhookok azonnali választ igényelnek. A HTTP-eseményindító hasznos adatait továbbíthatja egy üzenetsorba, amelyet egy üzenetsor-eseményindító függvény dolgoz fel. Ezzel a módszerrel késleltetheti a tényleges munkát, és azonnali választ adhat vissza.
Győződjön meg arról, hogy a háttérfeladatok befejeződnek
Amikor a függvény elindítja a feladatokat, visszahívásokat, szálakat és folyamatokat, a függvénykód visszaadása előtt be kell fejeződniük. Mivel a Functions nem követi nyomon ezeket a háttérszálakat, a webhely leállítása a háttérszál állapotától függetlenül történhet, ami nem kívánt viselkedést okozhat a függvényekben.
Ha például egy függvény elindít egy háttérfeladatot, és a feladat befejezése előtt sikeres választ ad vissza, a Functions-futtatókörnyezet a végrehajtást sikeresnek tekinti, függetlenül a háttérfeladat eredményétől. Ha ez a háttérfeladat nélkülözhetetlen munkát végez, előfordulhat, hogy a webhely leállítása előzi meg, így a munka ismeretlen állapotban marad.
Függvények közötti kommunikáció
Durable Functions és az Azure Logic Apps több függvény közötti állapotváltások és kommunikáció kezelésére készült.
Ha nem Durable Functions vagy Logic Apps használatával integrálható több függvénnyel, a legjobb, ha tárolósorokat használ a függvények közötti kommunikációhoz. A fő ok az, hogy a tárolási üzenetsorok olcsóbbak és sokkal egyszerűbbek, mint a többi tárolási lehetőség.
A tárolási üzenetsor egyes üzenetei legfeljebb 64 KB méretűek. Ha nagyobb üzeneteket kell átadnia a függvények között, egy Azure Service Bus üzenetsor használható a Standard szinten akár 256 KB-os, a Prémium szinten pedig akár 100 MB méretű üzenetek támogatására.
A Service Bus-témakörök akkor hasznosak, ha a feldolgozás előtt üzenetszűrésre van szükség.
Az eseményközpontok a nagy mennyiségű kommunikáció támogatásához hasznosak.
Állapot nélküli függvények írása
A függvények állapot nélkülinek és idempotensnek kell lenniük, ha lehetséges. Társítson minden szükséges állapotinformációt az adataihoz. Egy feldolgozott rendelésnek például valószínűleg van egy társított state tagja. Egy függvény feldolgozhat egy sorrendet az adott állapot alapján, miközben maga a függvény állapot nélküli marad.
Az idempotens függvények különösen ajánlottak időzítő eseményindítókkal. Ha például van valamije, amelynek mindenképpen naponta egyszer kell futnia, írja meg, hogy a nap folyamán bármikor fusson ugyanazokkal az eredményekkel. A függvény kiléphet, ha egy adott napra nincs munka. Ha egy előző futtatás nem fejeződött be, a következő futtatásnak ott kell lennie, ahol abbahagyta. Ez különösen fontos az olyan üzenetalapú kötések esetében, amelyek újrapróbálkoznak a hibával. További információ: Azure Functions tervezése azonos bemenethez.
Védelmi függvények írása
Tegyük fel, hogy a függvény bármikor kivételt tapasztalhat. Úgy tervezheti meg a függvényeket, hogy a következő végrehajtás során az előző feladatponttól folytassa a műveletet. Vegyünk egy forgatókönyvet, amely a következő műveleteket igényli:
- 10 000 sor lekérdezése egy adatbázisban.
- Hozzon létre egy üzenetsort az egyes sorokhoz a sor további feldolgozásához.
A rendszer összetettségétől függően előfordulhat, hogy az alárendelt szolgáltatások rosszul viselkednek, hálózatkimaradások vagy kvótakorlátok érik el stb. Ezek mindegyike bármikor hatással lehet a függvényére. A függvényeket úgy kell megterveznie, hogy felkészüljenek rá.
Hogyan reagál a kód, ha hiba történik, miután 5000 ilyen elemet szúrt be egy feldolgozási várólistába? Egy befejezett készlet elemeinek nyomon követése. Ellenkező esetben a következő alkalommal ismét beszúrhatja őket. Ez a dupla beszúrás komoly hatással lehet a munkafolyamatra, ezért a függvényeket idempotenssé teheti.
Ha egy üzenetsorelem már fel lett dolgozva, hagyja, hogy a függvény műveletmentes legyen.
Használja ki a Azure Functions platformon használt összetevőkhöz már megadott védelmi intézkedéseket. Lásd például az Azure Storage-üzenetsor eseményindítóinak és kötéseinek dokumentációjában a méregsorüzenetek kezelését ismertető cikket.
HTTP-alapú függvények esetén fontolja meg az API-verziószámozási stratégiák használatát az Azure API Management használatával. Ha például frissítenie kell a HTTP-alapú függvényalkalmazást, helyezze üzembe az új frissítést egy külön függvényalkalmazásban, és API Management változatokkal vagy verziókkal irányítsa az ügyfeleket az új verzióra vagy változatra. Ha az összes ügyfél a verziót vagy a változatot használja, és nem marad több végrehajtás az előző függvényalkalmazáson, megszüntetheti az előző függvényalkalmazást.
A függvények szervezetének ajánlott eljárásai
A megoldás részeként több függvényt is fejleszthet és tehet közzé. Ezeket a függvényeket gyakran egyetlen függvényalkalmazásban kombinálják, de külön függvényalkalmazásokban is futtathatók. A Prémium és dedikált (App Service) üzemeltetési csomagokban több függvényalkalmazás is megoszthatja ugyanazokat az erőforrásokat, ha ugyanabban a csomagban fut. A függvények és függvényalkalmazások csoportosítása hatással lehet a teljes megoldás teljesítményére, méretezésére, konfigurálására, üzembe helyezésére és biztonságára. Nincsenek olyan szabályok, amelyek minden forgatókönyvre vonatkoznak, ezért a függvények tervezésekor és fejlesztésekor vegye figyelembe az ebben a szakaszban található információkat.
Függvények rendszerezése a teljesítmény és a skálázás érdekében
Minden létrehozott függvény rendelkezik memóriaigényrel. Bár ez a helyigény általában kicsi, a függvényalkalmazáson belül túl sok függvény miatt az alkalmazás lassabban indul el az új példányokon. Ez azt is jelenti, hogy a függvényalkalmazás teljes memóriahasználata magasabb lehet. Nehéz megmondani, hogy hány függvénynek kell lennie egyetlen alkalmazásban, ami az adott számítási feladattól függ. Ha azonban a függvény sok adatot tárol a memóriában, érdemes lehet kevesebb függvényt használni egyetlen alkalmazásban.
Ha több függvényalkalmazást futtat egyetlen Prémium csomagban vagy dedikált (App Service) csomagban, ezek az alkalmazások mind ugyanazokat az erőforrásokat osztják meg, amelyeket a csomaghoz rendeltek. Ha egy olyan függvényalkalmazással rendelkezik, amely sokkal nagyobb memóriaigényű, mint a többi, az aránytalan mennyiségű memóriaerőforrást használ minden olyan példányon, amelyre az alkalmazást üzembe helyezik. Mivel így az egyes példányokon kevesebb memória áll rendelkezésre a többi alkalmazás számára, érdemes lehet egy ehhez hasonló, nagy memóriahasználatú függvényalkalmazást futtatni a saját különálló üzemeltetési csomagjában.
Megjegyzés
A használatalapú csomag használatakor azt javasoljuk, hogy minden alkalmazást mindig a saját csomagjában helyezzen el, mivel az alkalmazások skálázása mindenképpen egymástól függetlenül történik. További információ: Több alkalmazás ugyanabban a csomagban.
Fontolja meg, hogy a függvényeket különböző terhelési profilokkal szeretné-e csoportosítani. Ha például van egy függvénye, amely több ezer üzenetsorüzenetet dolgoz fel, és egy másikat, amelyet csak alkalmanként hívnak meg, de magas memóriaigényekkel rendelkezik, érdemes lehet külön függvényalkalmazásokban üzembe helyezni őket, hogy saját erőforráskészleteket kaphassanak, és egymástól függetlenül méretezzék őket.
Függvények rendszerezése konfigurációhoz és üzembe helyezéshez
A függvényalkalmazások rendelkeznek egy host.json fájllal, amely a függvénytriggerek és a Azure Functions futtatókörnyezet speciális viselkedésének konfigurálására szolgál. A fájl módosításai az host.json alkalmazás összes függvényére vonatkoznak. Ha vannak olyan függvényei, amelyekhez egyéni konfigurációkra van szükség, érdemes lehet áthelyezni őket a saját függvényalkalmazásukba.
A helyi projekt összes függvénye együtt lesz üzembe helyezve fájlkészletként az Azure-beli függvényalkalmazásban. Előfordulhat, hogy egyes függvényeket külön kell üzembe helyeznie, vagy egyes függvényekhez az üzembehelyezési pontokhoz hasonló funkciókat kell használnia, másokat nem. Ilyen esetekben ezeket a függvényeket (külön kódprojektekben) különböző függvényalkalmazásokban kell üzembe helyeznie.
Függvények rendszerezése jogosultságok szerint
A kapcsolati sztringek és az alkalmazásbeállításokban tárolt egyéb hitelesítő adatok a függvényalkalmazásban lévő összes függvénynek ugyanazokat az engedélyeket biztosítják a társított erőforrásban. A hitelesítő adatokat nem használó függvények külön függvényalkalmazásba való áthelyezésével minimalizálhatja az adott hitelesítő adatokhoz való hozzáféréssel rendelkező függvények számát. A különböző függvényalkalmazások függvényei között mindig használhat olyan technikákat, mint a függvényláncolás .
Ajánlott skálázhatósági eljárások
Számos tényező befolyásolja a függvényalkalmazás példányainak méretezését. A részleteket a függvényskálázás dokumentációjában találja. Az alábbiakban néhány ajánlott eljárást követünk a függvényalkalmazások optimális méretezhetőségének biztosításához.
Kapcsolatok megosztása és kezelése
Amikor csak lehetséges, használja újra a külső erőforrások kapcsolatait. Tekintse meg, hogyan kezelheti a kapcsolatokat Azure Functions.
Tárfiókok megosztásának elkerülése
Függvényalkalmazás létrehozásakor társítania kell azt egy tárfiókkal. A tárfiók kapcsolata az AzureWebJobsStorage alkalmazásbeállításban marad fenn.
A teljesítmény maximalizálása érdekében minden függvényalkalmazáshoz használjon külön tárfiókot. Ez különösen akkor fontos, ha Durable Functions vagy Event Hub által aktivált függvényekkel rendelkezik, amelyek nagy mennyiségű tárolási tranzakciót hoznak létre. Ha az alkalmazáslogika közvetlenül (a Storage SDK használatával) vagy az egyik tárolókötésen keresztül kommunikál az Azure Storage-ral, egy dedikált tárfiókot kell használnia. Ha például egy Event Hub által aktivált függvény ír adatokat a Blob Storage-ba, használjon két tárfiókot– az egyiket a függvényalkalmazáshoz, a másikat pedig a függvény által tárolt blobokhoz.
Ne keverje a teszt- és éles kódot ugyanabban a függvényalkalmazásban
A függvényalkalmazáson belüli függvények erőforrásokat osztanak meg. A memória például meg van osztva. Ha éles környezetben használ függvényalkalmazást, ne adjon hozzá teszttel kapcsolatos függvényeket és erőforrásokat. Váratlan többletterhelést okozhat az éles kód végrehajtása során.
Legyen óvatos, mit tölt be az éles függvényalkalmazásokba. A memória átlaga az alkalmazás minden egyes függvényében történik.
Ha egy megosztott szerelvényre több .NET-függvény hivatkozik, helyezze egy közös megosztott mappába. Ellenkező esetben véletlenül üzembe helyezheti ugyanannak a binárisnak a több verzióját, amelyek eltérően viselkednek a függvények között.
Ne használjon részletes naplózást az éles kódban, ami negatív hatással van a teljesítményre.
Aszinkron kód használata, de kerülje a hívások blokkolását
Az aszinkron programozás ajánlott eljárás, különösen az I/O-műveletek blokkolása esetén.
A C#-ban mindig ne hivatkozzon a tulajdonságra vagy a Result hívási Wait metódusra egy Task példányon. Ez a megközelítés szálkimerüléshez vezethet.
Tipp
Ha HTTP- vagy WebHook-kötéseket szeretne használni, tervezze meg, hogy elkerülje a portfogyást, amelyet a nem megfelelő példányosítás HttpClientokozhat. További információ: Kapcsolatok kezelése Azure Functions.
Több feldolgozófolyamat használata
Alapértelmezés szerint a Functions bármely gazdagéppéldánya egyetlen feldolgozófolyamatot használ. A teljesítmény javítása érdekében, különösen az egyszálas futtatókörnyezetek, például a Python esetében, használja a FUNCTIONS_WORKER_PROCESS_COUNT a gazdagépenkénti munkavégző folyamatok számának (akár 10) növeléséhez. Azure Functions ezután megpróbálja egyenletesen elosztani az egyidejű függvényhívásokat ezeken a feldolgozókon.
A FUNCTIONS_WORKER_PROCESS_COUNT beállítás a Functions által az alkalmazás igény szerinti horizontális felskálázásakor létrehozott összes gazdagépre érvényes.
Üzenetek fogadása kötegben, amikor csak lehetséges
Egyes eseményindítók, például az Event Hub lehetővé teszik egy üzenetköteg fogadását egyetlen hívásban. Az üzenetek kötegelése sokkal jobb teljesítményt nyújt. A fájl maximális kötegméretét a host.jsonhost.json referenciadokumentációban leírtak szerint konfigurálhatja.
C#-függvények esetén a típust egy erősen beírt tömbre módosíthatja. A metódus aláírása EventData sensorEvent helyett például a következő lehet EventData[] sensorEvent: . Más nyelvek esetén explicit módon be kell állítania a számosság tulajdonságot a function.jsonmany fájlban, hogy engedélyezze a kötegelést az itt látható módon.
A gazdagép viselkedésének konfigurálása az egyidejűség jobb kezelése érdekében
A host.json függvényalkalmazásban található fájl lehetővé teszi a gazdagép futtatókörnyezetének és az eseményindító viselkedésének konfigurálását. A kötegelési viselkedés mellett számos eseményindító egyidejűségét is kezelheti. A beállítások értékeinek módosítása gyakran segíthet az egyes példányok megfelelő méretezésében a meghívott függvények igényeinek megfelelően.
A host.json fájl beállításai az alkalmazás összes függvényére érvényesek, a függvény egyetlen példányán belül. Ha például két HTTP-függvényt és maxConcurrentRequests 25-ös kérést tartalmazó függvényalkalmazással rendelkezik, bármelyik HTTP-eseményindító kérése beleszámít a megosztott 25 egyidejű kérésbe. Ha a függvényalkalmazás 10 példányra van skálázva, a tíz függvény gyakorlatilag 250 egyidejű kérést engedélyez (példányonként 10 példány * 25 egyidejű kérés).
A host.json konfigurációs cikkben további gazdagépkonfigurációs beállítások találhatók.
Következő lépések
További információkat találhat az alábbi forrásokban: