Megjegyzés
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhat bejelentkezni vagy módosítani a címtárat.
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhatja módosítani a címtárat.
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. Az Azure Functions ajánlott eljárásainak általánosabb halmazát az Azure Functions ajánlott eljárásaiban tekintheti meg.
Az alábbiakban ajánlott eljárásokat találja a kiszolgáló nélküli megoldások Azure Functions használatával történő elkészítéséhez és kialakításához.
Kerülje a hosszú ideig futó függvényeket
A nagy, hosszan 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.
A függvények sok Node.js függőség miatt nagyok lehetnek. 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 és implicit módon is betöltődnek. A kód által betöltött egyetlen modul saját további modulokat is betölthet.
Amikor csak lehetséges, a nagyméretű függvényeket alakítsa át kisebb függvénykészletekké, amelyek együttműködnek, és gyorsan visszaadják a válaszokat. Egy webhook- vagy HTTP-eseményindító függvény például egy bizonyos időn belül nyugtázási választ igényelhet; gyakori, hogy a webhookok azonnali választ igényelnek. Az HTTP-eseményindító hasznos adatait átadhatja egy üzenetsorba, amelyet egy üzenetsor-eseményindító függvény dolgoz fel. Ezzel a módszerrel elhalaszthatja 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, azokat a függvénykód visszatérése előtt végre kell hajtani. Mivel a Functions nem követi ezeket a háttérszálakat, a webhely leállítása a háttérszál állapotától függetlenül előfordulhat, ami nem szándékos működé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 a háttérfeladat eredményétől függetlenül sikeresnek tekinti. Ha ez a háttérfeladat alapvető munkát végez, előfordulhat, hogy a webhely leállítása előzményként jelenik meg, így a munka ismeretlen állapotban marad.
Funkciók közötti kommunikáció
A Durable Functions és az Azure Logic Apps az állapotváltások és a több függvény közötti kommunikáció kezelésére készült.
Ha nem használ Durable Functions-t vagy Logic Apps-t a több függvénnyel való integrációhoz, akkor legjobb, ha tárolási sorokat alkalmaz a függvények közötti kommunikációhoz. A fő ok az, hogy a tárolási üzenetsorok olcsóbbak és sokkal könnyebben építhetők ki, mint más tárolási lehetőségek.
A társor egyes üzenetei legfeljebb 64 KB méretűek. Ha nagyobb üzeneteket kell átadnia a függvények között, egy Azure Service Bus-üzenetsorsal akár 256 KB-os üzenetméretet is támogathat a Standard szinten, és akár 100 MB-ot is a Prémium szinten.
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 hasznosak a nagy mennyiségű kommunikáció támogatásához.
Írj állapot nélküli függvényeket.
A függvények állapot nélkülinek és idempotensnek kell lenniük, ha lehetséges. Társítsa a szükséges állapotadatokat az adataival. Egy feldolgozott rendelésnek például valószínűleg van egy társított state tagja. A függvények feldolgozhatnak egy sorrendet az adott állapot alapján, míg 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 valami, amit mindenképpen naponta egyszer kell futtatnia, írja meg, hogy a nap folyamán bármikor fusson ugyanazokkal az eredményekkel. A függvény végrehajtását befejezheti, ha egy adott napon nincs munka. Ha egy előző futtatás nem fejeződött be, a következő futtatásnak onnan kell folytatnia, ahol abbahagyta. Ez különösen fontos az üzenetalapú kötések esetében, amelyek hibás működés esetén újrapróbálkoznak. További információ: Az Azure Functions tervezése azonos bemenethez.
Védekező függvények írása
Tegyük fel, hogy a függvény bármikor kivételt tapasztalhat. Úgy tervezze meg a függvényeket, hogy a következő végrehajtás során az előző hibaponttól folytathassa a végrehajtást. Fontolja meg az alábbi műveleteket igénylő forgatókönyvet:
- 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 hibásan működnek, hálózatkimaradások következnek be, vagy a kvótahatárok elérése történik stb. Ezek mindegyike bármikor hatással lehet a funkcióra. A függvényeket úgy kell megterveznie, hogy felkészüljenek rá.
Hogyan reagál a kód, ha hiba történik 5,000 elemnek a feldolgozásra váró sorba való beszúrása után? A befejezett készlet elemeinek nyomon követése. Ellenkező esetben legközelebb 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 már feldolgoztak egy sorban álló elemet, állítsa be a függvényt no-opértékre.
Használja ki az Azure Functions platformon használt összetevőkhöz már megadott védelmi intézkedéseket. Lásd például az Azure Storage Queue eseményindítóinak és kötéseinek dokumentációjában szereplő méreg üzenetsor-üzenetek kezelését.
A HTTP-alapú függvények esetében fontolja meg az API verziószámozási stratégiáit az Azure API Managementtel. 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 minden ü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ásban, megszüntetheti az előző függvényalkalmazást.
A függvények szervezésének legjobb gyakorlatai
A megoldás részeként több függvényt is fejleszthet és tehet közzé. Ezek a függvények gyakran egyetlen függvényalkalmazásba vannak kombinálva, de külön függvényalkalmazásokban is futtathatók. Prémium és dedikált (App Service) hosztingtervekben több funkcióalkalmazás is megoszthatja ugyanazokat az erőforrásokat, ugyanabban a csomagban futva. A függvények és függvényalkalmazások csoportosítása befolyásolhatja a teljes megoldás teljesítményét, skálázását, konfigurációját, üzembe helyezését és biztonságát. 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ényhez és a skálázáshoz
Minden létrehozott függvény memóriaigényű. Bár ez a lábnyom általában kicsi, ha egy függvényalkalmazásban túl sok függvény található, 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 Premium-csomagban vagy dedikált (App Service-) csomagban, ezek az alkalmazások 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, aránytalan mennyiségű memóriaerőforrást használ minden olyan példányon, amelyre az alkalmazás telepítve van. Mivel így kevesebb memória áll rendelkezésre a többi alkalmazás számára az egyes példányokon, érdemes lehet egy ilyen 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 javasoljuk, hogy minden alkalmazást mindig a saját csomagjában helyezzen el, mivel az alkalmazások skálázása egyébként is 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 üzenetsort dolgoz fel, és egy másikat, amelyet csak alkalmanként hívnak, 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 skálázzák őket.
Függvények rendszerezése a konfigurációhoz és telepítéshez
A függvényalkalmazások rendelkeznek egy host.json fájllal, amely a függvényindítók és az 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, amelyek egyéni konfigurációkat igényelnek, é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 külön kell üzembe helyeznie az egyes függvényeket, vagy egyes függvények üzembehelyezési pontjait 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 az összes függvény számára azonos engedélyeket adnak meg a kapcsolódó erőforráson belül. 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ásokban lévő függvények közötti adatátadáshoz 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 függvényméretezés dokumentációja tartalmazza a részleteket. Az alábbiakban néhány ajánlott eljárás található 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. Megtudhatja, hogyan kezelheti a kapcsolatokat az Azure Functionsben.
Tárfiókok megosztásának kerülése
Függvényalkalmazás létrehozásakor társítania kell azt egy tárfiókkal. A tárfiók-kapcsolat 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 a megközelítés különösen akkor fontos, ha Durable Functions vagy Event Hubs á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-tal, egy dedikált tárfiókot kell használnia. Ha például egy eseményközpont által aktivált függvény adatokat ír a blobtároló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.
Teszt- és éles kód vegyítésének kerülése ugyanabban a függvényalkalmazásban
A függvényalkalmazásban lévő 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.
Ügyeljen arra, hogy mit tölt be az éles környezetű függvényalkalmazásaiba. Az alkalmazásban a memória minden egyes függvényre számítva kerül átlagolásra.
Ha egy megosztott assemblyre több .NET-függvény hivatkozik, helyezze egy közös 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, mivel ez negatívan befolyásolja a teljesítményt.
Aszinkron kód használata, de a hívások blokkolásának kerülése
Az aszinkron programozás ajánlott eljárás, különösen az I/O-műveletek blokkolása esetén.
C#-ban mindig kerülje a Result tulajdonságra való hivatkozást vagy a Wait metódus hívását egy Task példányon. Ez a megközelítés menetkimerüléshez vezethet.
Jótanács
Ha HTTP- vagy WebHook-kötéseket szeretne használni, tervezze meg, hogy elkerülje a portkimerülést, amelyet a nem megfelelő példányosítás HttpClientokozhat. További információ: Kapcsolatok kezelése az Azure Functionsben.
Több munkafolyamat használata
Alapértelmezés szerint a Functions bármely gazdagéppéldánya egyetlen munkafolyamatot használ. A teljesítmény növelése érdekében, különösen az egy szálat használó futtatókörnyezetek - mint például a Python - esetében, használja a FUNCTIONS_WORKER_PROCESS_COUNT beállítást a gazdagépenkénti feldolgozói folyamatok számának növeléséhez, legfeljebb 10-re. Az 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 batchelve, ha 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ással. Az üzenetek kötegelésének teljesítménye sokkal jobb. 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 típusos tömbre módosíthatja. A metódus aláírása EventData sensorEvent helyett például az is lehet EventData[] sensorEvent. Más nyelvek esetében explicit módon be kell állítania a számosság tulajdonságát a function.jsonmany kötegelés engedélyezéséhez 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ás fájlja 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 skálázásában 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 vonatkoznak, a függvény egyetlen példányán belül. Ha például két HTTP-függvényt tartalmazó függvényalkalmazással rendelkezik, és maxConcurrentRequests a kérések értéke 25, akkor a http-eseményindítókra irányuló kérések a megosztott 25 egyidejű kérésbe beleszámítanak. 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).
Az egyéb gazdagép-konfigurációs beállításokat a host.json konfigurációs cikkben találja.
Következő lépések
További információt a következő források tartalmaznak: