सर्वरलेस फंक्शन और कोल्ड स्टार्ट

1) ठंड क्या है और यह क्यों होता है

1. मध्यम आवंटन (कंटेनर/माइक्रो-वीएम, रनटाइम लोडिंग)।

2. VPC/ENI प्राइमिंग, रहस्य, फ़ाइलें, कॉन्फ़िगरेशन।

3. कोड इनिशियलाइजेशन (मॉड्यूल का आयात, डेटाबेस से कनेक्शन, मॉडल लोड करना)।

4. हैंडलर निष्पादन।

गर्म शुरुआत (पुन: उपयोग) 1-3 कदम छोड़ देता है। डाउनटाइम के बाद, समानता बढ़ ने और कोड/कॉन्फिग अपडेट के साथ, चोटियों पर ठंड की शुरुआत की संभावना बढ़ जाती है।

2) कैसे मापना और लक्ष्य (SLO)

मेट्रिक्स: 'init _ अवधि' (प्रारंभिक), 'अवधि _ टोटल', "कोल्ड स्टार्ट का हिस्सा", p95/p99 विलंबता, डाउनटाइम के बाद निर्भरता से जुड़ ने में त्रुटि।

टेलीमेट्री हटाना: प्लेटफ़ॉर्म लॉग + अपना लेबल (उदाहरण के लिए, 'कोल्ड = ट्रू/फाल्स' अगर 'कॉनटेक्स्ट' है। IscoltStart 'या स्थैतिक बंद में अपना झंडा)।

SLO लक्ष्य (उदाहरण): API "लॉगिन" p95 ≤ 200 ms, कोल्ड शेयर ≤ 3%; पृष्ठभूमि नौकरियों - p95 ≤ 1 एस। "पैसे" मार्गों के लिए - अलग, अधिक कठोर।

3) ठंड में कमी के मुख्य लीवर

3. 1 संघटक नियंत्रण और हीटिंग

प्रोविजनल कॉन्सुरेंसी/मिन इंस्टेंस: एन गर्म वातावरण रखता है। महत्वपूर्ण पकड़ के लिए उपयोग करें।

वार्मर/वार्म-अप: श्रमिकों को गर्म रखने के लिए अनुसूचित कॉल (क्रोन/शेड्यूलर)। इसे समझदारी से करें (क्षेत्र, समय, भार)।

फट बफर्स: अपेक्षित चोटियों से पहले अग्रिम में संगामिति सीमा बढ़ाएं।

3. 2 पैकेजिंग और निर्भरता

छोटे तैनाती-कलाकृतियाँ: पेड़ को हिलाना, '-only prod' निर्भरता, बड़े होंठ के लिए परतें (AWS परतें)।

आलसी-इनिट: पहली पहुंच पर हैंडलर के अंदर भारी मॉड्यूल आयात करें; आलसी खुले कनेक्शन।

गर्म संसाधन: गर्म शुरुआत में पुन: उपयोग करने के लिए वैश्विक दायरे में कैश एसडीके/कनेक्शन क्लाइंट।

3. 3 नेटवर्क और वीपीसी

उन कार्यों के लिए वीपीसी के बिना जिन्हें गोपनीयता की आवश्यकता नहीं है (अन्यथा ईएनआई-अटैच दसियों को सैकड़ों एमएस में जोड़ ता है)।

यदि वीपीसी की आवश्यकता है, तो प्रदाता के वीपीसी अर्थव्यवस्था मोड (ईएनआई पूल/अनुकूलन), डेटाबेस के लिए प्रॉक्सी (आरडीएस प्रॉक्सी/क्लाउड एसक्यूएल ऑथ प्रॉक्सी) और कनेक्शन पूलिंग का उपयोग करें।

3. 4 भाषाएँ और रंडटाइम

नोड। js/Go सबसे तेज शुरू करें; अजगर - आमतौर पर तेज लेकिन बड़े आयात के प्रति संवेदनशील; जावा/.NET GraalVM/AOT और प्रोफाइलिंग के बिना भारी है।

जेवीएम के लिए, स्नैपस्टार्ट/सीआरएसी/ग्रेल नेटिव पर विचार करें; के लिए। नेट - छंटनी स्व-निहित।

3. 5 प्रारंभिक और राज्य

इनिशियलाइजेशन हुक (इनिट चरण) में महंगा प्रारंभ करें, न कि अनुरोध पथ में।

स्थानीय कैश (टीटीएल) के साथ कॉन्फ़िग/सीक्रेट की ऑन-डिमांड लोडिंग का उपयोग करें।

उपयोक्ता स्थिति को मेमोरी में संग्रहीत न करें - केवल कैश सिग्नल/कनेक्टर।

4) वास्तुशिल्प पैटर्न जो ठंड की शुरुआत के प्रभाव को कम करते हैं

4. 1 असिंक्रॉन और कतारें

हम अनुरोध स्वीकार करते हैं मान्य इसे कतार/बस (SQS/PubSub/Queue Storage) में रखें पृष्ठभूमि के साथ इसे प्रक्रिया का जवाब दें।

गैर-इंटरैक्टिव संचालन (भुगतान, रिपोर्ट, भारी गणना) के लिए उपयुक्त।

4. 2 प्रीकॉम्प्यूट/प्री-कैश

केवी/कैश/एज में ट्रिगर (क्रॉन/इवेंट) और भंडारण द्वारा अग्रिम में एक्सेस/निर्देशिका/फ़ीचर फ्लैग्स का सृजन।

4. 3 फैन-आउट/फैन-इन

हम एक लंबे ऑपरेशन को कई छोटे कार्यों (मैप/कम-जैसे) में विभाजित करते हैं - टाइमआउट और बार-बार ठंड का कम जोखिम।

4. 4 एज-ऑफ़लोड

आरटीटी को बचाने और मूल को अनलोड करने के लिए सबसे सरल चेक (JWT/HMAC, जियो-रीडायरेक्ट, एंटीबॉट) किनारे (वर्कर्स/फंक्शंस @ एज) पर किए जाते हैं।

5) अभ्यास: कॉन्फ़िग और तकनीक

5. 1 AWS लैम्ब्डा (प्रावधान + RDS प्रॉक्सी)

hcl
Terraform sketch: enable provisioned concurrency on the sales version of the resource "aws_lambda_provisioned_concurrency_config" "api" {
function_name = aws_lambda_function. api. function_name qualifier   = aws_lambda_alias. prod. name provisioned_concurrent_executions = 20
}

RDS Proxy for connection pool "aws_db_proxy" "rds_proxy" {
name          = "pg-proxy"
engine_family     = "POSTGRESQL"
idle_client_timeout  = 1800 require_tls      = true
}

js let pgClient ;//reuse between warm runs let cold = true;

exports. handler = async (event, ctx) => {
const isCold = cold; cold = false;
if (!pgClient) {
const { Client } = await import('pg');     // lazy import pgClient = new Client({ host: process. env. PG_PROXY, ssl: true });
await pgClient. connect();
}
const t0 = Date. now();
const data = await pgClient. query('select 1');
return {
statusCode: 200,
headers: { 'x-cold-start': String(isCold), 'x-elapsed-ms': String(Date. now()-t0) },
body: JSON. stringify({ ok: true })
};
};

5. 2 जीसीपी क्लाउड रन/क्लाउड फंक्शन (न्यूनतम उदाहरण)

yaml
Cloud Run service. yaml apiVersion: serving. knative. dev/v1 kind: Service metadata: { name: api }
spec:
template:
metadata:
annotations:
autoscaling. knative. dev/minScale: "5" # keep warm run containers. googleapis. com/cpu-throttling: "false"
spec:
containerConcurrency: 80 containers:
- image: gcr. io/proj/api:latest env:
- { name: DB_HOST, value: "10. 0. 0. 5" }

5. 3 एज़्योर फंक्शन्स (लेखन/प्रीवार्म)

लेकिन के साथ प्रीमियम/इलास्टिक योजनाएं; पूर्व-गर्म उदाहरण - भविष्यवाणी p95 संगामिति।

6) टाइमआउट, रिट्रीट, डेडलाइन

फ़ंक्शन के अंदर 'पर-हॉप टाइमआउट' को छोटा करते हुए हेडर ('x-dement-ms '/' grpc-timeout') के माध्यम से सामान्य समय सीमा (क्लाइंट-साइड) पास करें।

केवल पहचान संचालन के लिए दोहराता है; Idempotency-Key और deduplication का उपयोग करें।

सामने एपीआई के लिए - हेजिंग (p90 के बाद डुप्लिकेट अनुरोध) और लंबी दूरी की निर्भरता के लिए सर्किट ब्रेकर।

7) डेटाबेस/कैश/सीक्रेट के साथ काम करना

हजारों छोटे कनेक्शनों के बजाय पूल/प्रॉक्सी (RDS प्रॉक्सी/क्लाउड SQL प्रॉक्सी/pgbouncer)।

पृष्ठभूमि अद्यतन के साथ मेमोरी कैश में छोटा टीटीएल सीक्रेट +।

कैश (Redis/Memcatched/KV): इनिट पर "भारी" निर्देशिकाओं को लोड करना, लेकिन समय सीमा के साथ।

8) कोड संगठन और विधानसभा

संकीर्ण उपयोग-मामलों के लिए अलग हैंडलर; एक "मोटा" बंडल = लंबा इनिट।

ESBuild/Rollup: अप्रयुक्त को बाहर करें, केवल महत्वपूर्ण जोड़ें।

परतें/एक्सटेंशन - प्रदाता के कैश का पुन: उपयोग करने के लिए बड़े लिब्स (OpenSSL मॉडल, SDK) के लिए।

9) पीक परीक्षण और सिमुलेशन

"ठंड" का सिंथेटिक्स शुरू होता है: जबरन न्यूनतम उदाहरणों को बंद करें और चरणों में समानांतर यातायात चलाएं।

A/B: ठंड, p95, कनेक्शन त्रुटि के हिस्से की तुलना DB/रहस्य, लागतों से करें।

गेमडे: पीक लोड × 2 ऑल-टाइम हाई, वार्म-अप ऑफ से।

10) लागत (FinOps)

न्यूनतम उदाहरण/प्रावधानित संगति लागत - केवल गर्म मार्गों के लिए सक्षम।

रनटाइम कम करें: कैश, शॉर्ट टाइमआउट, अनावश्यक एसडीके से बचना।

एग्रेस पर विचार करें (बाहरी एपीआई को कॉल करें) और लॉगिंग (लॉग की मात्रा ठंडी चोटियों पर जल्दी बढ़ ती है)।

11) एंटीपैटर्न

दसियों मेगाबाइट निर्भरता के साथ एक अखंड हैंडलर।

प्रत्येक कॉल पर डेटाबेस के लिए अनिवार्य कनेक्शन (पुन: उपयोग/प्रॉक्सी के बिना)।

सभी कार्यों के लिए वीपीसी "बस मामले में।"

लॉन्ग टाइमआउट और ब्लाइंड रिट्रीट - "टेल्स" और फैंटम राइट-ऑफ।

घड़ी के चारों ओर "एक पंक्ति में सब कुछ" वार्मिंग।

अनुरोध पथ में गुप्त प्रारंभ (दाल init> 100 ms - init/cache में स्थानांतरण)।

12) आईगेमिंग/वित्त की विशिष्टताएं

मुद्रा पथ (जमा/निकासी): प्रावधान/न्यूनतम उदाहरण, अलग एसएलओ, समय की सख्त सीमा और पुनरावृत्ति (पहचान अनिवार्य है) रखें।

KYC/PSP: अस्थिर बाहरी API - कतार + कार्यकर्ता में रैप, सामने - 202/मतदान/वेबहुक पर।

नियामक और ऑडिट: अपरिवर्तनीय लॉग (WORM), इनबाउंड इवेंट लॉग 'Idempotency-Key', सहसंबंध 'ट्रेस _ id'।

डेटा रेजिडेंसी: उन कार्यों को तैनात करें जो क्षेत्रीय खातों/परियोजनाओं में पीआईआई की प्रक्रिया कर पीआईआई के साथ कोई धार कैश नहीं।

13) प्रोड रेडीनेस चेकलिस्ट

• SLI/SLO परिभाषित: p95/p99, ठंडा अंश, मार्ग लक्ष्य।
• महत्वपूर्ण कार्यों पर अनुमानित/न्यूनतम उदाहरण सक्षम हैं; संघटित भविष्यवाणी।
• बंडल कम से कम; भारी चेहरे परतों में किए जाते हैं; आलसी-आयात/आरंभीकरण।
• SDK/DB क्लाइंट का पुन: उपयोग करें; RDS/SQL प्रॉक्सी कॉन्फ़िगर है; कनेक्शन पूल।
• वीपीसी केवल जहां जरूरत है; ईएनआई/प्रॉक्सी अनुकूलित; प्रबंधक + स्थानीय टीटीएल कैश के माध्यम से रहस्य।
• टाइमआउट/डेडलाइन/रिट्रीट: बैकऑफ + जिटर; केवल पहचान दोहराता है।
• सिंथेटिक्स "कोल्ड" + लोड परीक्षण; ठंड और p99 के हिस्से में वृद्धि के लिए अलर्ट।
• रनबुक: प्रावधान कैसे बढ़ाएं, मिनस्केल को कैसे बदलें, गिरावट को कैसे शामिल करें।
• iGaming के लिए: अलग SLO/डैशबोर्ड "पैसे के तरीके", Idempotency-Key, WORM ऑडिट।

14) टीएल; डीआर

ठंड की शुरुआत अपरिहार्य है, लेकिन प्रबंधनीय: गर्म उदाहरणों को रखें जहां यह मायने रखता है, बंडल को कम करें, आलसी-इनिट लागू करें और कनेक्शन का पुन: उपयोग करें, अनावश्यक वीपीसी से बचें, लाइन/श्रमिकों में भारी संचालन करें और आसान का उपयोग करें। महत्वपूर्ण वित्तीय रास्तों के लिए - अलग एसएलओ, पहचान और सख्त समय; ठंड का हिस्सा मापते हैं और वार्मिंग को चालू करते हैं जहां यह भुगतान करता है।