נבדק לאחרונה: מאי 2026
מדריך מקוצר ובר-סריקה לדפוסי ארכיטקטורה שמבחן DVA-C02 בודק. קראו מלמעלה למטה, או דלגו לסעיף.
יעד קריאה יציב בזמן שאתה מעלה קוד Lambda חדש.
פרסם גרסאות ממוספרות ובלתי ניתנות לשינוי; חשוף alias שמצביע על גרסה. הקוראים מפעילים את ARN ה-alias.
למה: גרסאות הן תמונות מצב קפואות של קוד + תצורה; aliases מספקים הפניה עקיפה כך שהקוראים לעולם אינם מפעילים את `$LATEST` ישירות.
השקה הדרגתית של גרסת Lambda חדשה עם ביטול אוטומטי במקרה של שגיאות.
Alias עם ניתוב גרסאות משוקלל (לדוגמה, 90/10). CodeDeploy `LambdaCanary10Percent5Minutes` או `LambdaLinear*` מעביר תעבורה ומנטר התראות CloudWatch.
למה: העברת תעבורה מובנית + ביטול מונחה התראות מבטלים את הצורך בלוגיקת Canary מקודדת ידנית.
הזרקת תצורה (כתובת URL של DB, דגלי תכונות) ללא פריסות מחדש.
משתני סביבה של Lambda. מוצפנים במנוחה באמצעות KMS; ניתן להפנות ל-CMK מותאם אישית להצפנה נוספת במעבר בעת השליפה.
שיתוף NumPy / pandas / סביבת ריצה משותפת בין הרבה פונקציות Lambda.
ארוז כשכבת Lambda (Lambda Layer); עד 5 שכבות לפונקציה, סה"כ 250 MB לא מכווץ. ARN מגוון לכל שכבה.
Lambda סינכרוני רגיש לזמן השהיה - אסורות התחלות קרות.
Provisioned Concurrency ב-alias. מאתחל מראש N סביבות הרצה; תשלום לפי GB-שנייה.
למה: מבטל התחלה קרה בעלות צפויה. הגדר קנה מידה אוטומטי (application auto-scaling) ב-alias כדי להתגמש עם העומס.
Lambda ב-Java או Python עם קוד אתחול כבד; דרושה התחלה קרה מהירה ללא תשלום עבור Provisioned Concurrency.
אפשר SnapStart בגרסה שפורסמה. AWS מצלם את סביבת הריצה המאותחלת ומחדש ממנה.
למה: חינם עבור Java; מחויב לפי שחזור עבור Python/.NET. מקצר התחלות קרות משניות ל-<1 שניות ללא עלות סרק.
Lambda צריך לצרוך Kinesis stream / DynamoDB Stream / SQS queue / MSK topic.
מיפוי מקור אירועים (מבוסס משיכה). Lambda בודק; גודל אצווה + חלון אצווה מקסימלי מכוונים תפוקה לעומת זמן השהיה. כשל → DLQ דרך יעד On-Failure.
למה: עבור מקורות משיכה, השירות אינו יכול להפעיל ישירות את Lambda; המיפוי הוא מתאם הבדיקה של Lambda.
ניתוב הצלחה/כישלון של Lambda אסינכרוני ללא Lambda DLQ.
יעדי OnSuccess / OnFailure על הפונקציה. יעדים: SNS, SQS, EventBridge, Lambda אחר. כולל הקשר קריאה.
למה: יעדים לוכדים את האירוע המלא + התגובה; DLQ מדור קודם לוכד רק את ה-payload של האירוע.
בחר סוג API Gateway עבור API REST חדש.
HTTP API: זול יותר, מהיר יותר, אימות JWT מובנה, פשוט יותר. REST API: תכונות מלאות (mapping templates, request validators, WAF, private endpoints, X-Ray, API caching).
למה: ברירת המחדל היא HTTP API אלא אם אתה זקוק לתכונה ייחודית ל-REST. ממשקי WebSocket API הם מוצר נפרד עבור יישומים בזמן אמת עם מצב.
קידום שינויים ב-API מ-dev ← test ← prod ללא פריסה מחדש של ממשקי API נפרדים.
Stages על API יחיד. פרוס stage כדי לפרסם; משתני stage מכילים ערכים ספציפיים לסביבה כמו שמות alias של Lambda.
Lambda ב-backend מצפה לצורה שונה מזו שהלקוח שולח.
Request/response mapping template (REST API בלבד). VTL עם `$input`, `$context`, `$util` לטרנספורמציה של JSON.
למה: Mapping templates פועלים ב-API Gateway - ללא קפיצת Lambda נוספת, ללא זמן השהיה או עלות נוספים.
אמת token מותאם אישית (לא Cognito, לא IAM) לפני ניתוב הבקשה.
Lambda authorizer. סוג TOKEN קורא כותרת; סוג REQUEST קורא את הקשר הבקשה המלא. מחזיר מדיניות IAM + principalId. נשמר במטמון לכל זהות למשך TTL.
אמת JWT של Cognito User Pool בכל בקשה.
Cognito User Pool authorizer (REST) או JWT authorizer (HTTP). API Gateway מאמת את ה-token; אין צורך ב-Lambda.
למה: אימות מקומי זול ומהיר יותר מאשר Lambda authorizer למקרה ה-JWT הנפוץ.
בקרת מצערת / מכסה עבור צרכן API שותף.
Usage Plan + API Key. התוכנית מקשרת מפתחות ל-stage עם הגבלת קצב (בקשות/שנייה) + burst + מכסה (בקשות/יום או חודש).
הפחתת עומס ה-backend עבור בקשות GET חוזרות ונשנות.
מטמון ברמת ה-stage (REST API). TTL ניתן להגדרה; מפתח המטמון נגזר ממתודה + נתיב + פרמטרי שאילתה/כותרת נבחרים.
עדכן פריט רק אם מתקיים תנאי מוקדם (לדוגמה, status == "PENDING").
PutItem/UpdateItem עם `ConditionExpression`. כשל מעלה `ConditionalCheckFailedException`.
למה: בדיקה בצד השרת מונעת מצבי מירוץ של read-modify-write ללא צורך בנעילה.
הכל או כלום על פני מספר פריטי DynamoDB.
`TransactWriteItems` / `TransactGetItems`. עד 100 פריטים / 4 MB; עלות כפולה של WCU/RCU לעומת כתיבות/קריאות רגילות.
הגדלת מונה ללא read-modify-write.
UpdateExpression `ADD count :inc`. השרת מיישם את הדלתא באופן אטומי.
חזור על מערך תוצאות שאילתה/סריקה גדול.
`LastEvaluatedKey` מהתגובה → `ExclusiveStartKey` בקריאה הבאה עד שייעדר. הגבלה באמצעות פרמטר `Limit`.
זקוק לתבנית גישה נוספת מעבר למפתח הראשי.
GSI: מפתח מחיצה ומיון חלופי, עקביות בסופו של דבר, קיבולת נפרדת, ניתן להוספה בכל עת. LSI: אותו מפתח מחיצה, מפתח מיון חלופי, אופציה לעקביות חזקה, חייב להיווצר ביצירת הטבלה.
אינדקס רק פריטים שיש להם תכונה מסוימת (לדוגמה, רק הזמנות ACTIVE).
אינדקס דליל: השמט את התכונה מפריטים שברצונך להחריג. פריטים ללא התכונה המאונדקסת לא מופיעים ב-GSI/LSI.
קריאה/כתיבה המונית של פריטים רבים.
`BatchGetItem` (עד 100 פריטים / 16 MB) ו-`BatchWriteItem` (עד 25 פריטים / 16 MB). לא אטומי; כשלים חלקיים מוחזרים ב-`UnprocessedItems`.
מניעת עדכונים אבודים מכתיבים מקבילים.
תכונת גרסה + `ConditionExpression: version = :v`. כתיבות שנכשלו מנוסות מחדש על ידי קריאה חוזרת.
הפעל פעולות בהמשך הזרם על כל שינוי ב-DynamoDB.
DynamoDB Streams + מיפוי מקור אירועים של Lambda. תצוגת זרם: NEW_IMAGE / OLD_IMAGE / NEW_AND_OLD_IMAGES / KEYS_ONLY.
דפדפן מעלה/מוריד ישירות ל-S3 ללא שהשרת שלך מתווך בייטים.
SDK `getSignedUrl` עבור GET או PUT. תוקף עד 7 ימים כאשר נחתם על ידי משתמש IAM (sigv4); קצר יותר עבור סשנים הנגזרים מתפקיד.
למה: מוריד רוחב פס מה-backend שלך; ה-URL הוא יכולת זמנית המוגבלת לאובייקט אחד + מתודה.
העלאת קובץ גדול (≫100 MB) באופן אמין מה-SDK.
`CreateMultipartUpload` → `UploadPart` מקביל → `CompleteMultipartUpload`. מנהל העברות ברמה גבוהה של ה-SDK מטפל בגודל החלקים באופן אוטומטי.
למה: נדרש >5 GB; מומלץ ≥100 MB. חלקים שנכשלו מועלים מחדש באופן עצמאי. הגדר lifecycle להפסיק העלאות מרובות חלקים לא שלמות כדי לשחרר שטח אחסון.
הפעל קוד כאשר אובייקט נוצר/נמחק ב-S3.
התראות אירועים של S3 → Lambda / SNS / SQS / EventBridge. סינון לפי prefix ו-suffix.
אפליקציית דפדפן מאחזרת מ-S3 על פני מקורות (`fetch('https://bucket.s3...')`); CORS preflight נכשל.
הגדר כללי CORS לדלי: מקורות מותרים, מתודות (GET/PUT), כותרות, וכותרות חשופות.
סנן שורות מאובייקט CSV/JSON/Parquet בגודל 50 GB מבלי להוריד אותו.
S3 Select עם SQL. מחזיר שורות תואמות בלבד; תשלום עבור סריקה + בייטים מוחזרים.
כניסה של משתמש מלקוח מובייל/ווב ציבורי ללא שליחת הסיסמה.
Cognito User Pool עם זרימת `USER_SRP_AUTH`. הלקוח מחשב הוכחת SRP; ה-backend לעולם אינו רואה את הסיסמה. מחזיר ID + access + refresh tokens.
משתמש מאוחד (Google/Apple/Cognito UP) זקוק לפרטי כניסה זמניים של AWS כדי לקרוא לממשקי AWS API ישירות מאפליקציה ניידת.
Cognito Identity Pool. מחליף token של ספק זהויות ← תפקיד IAM ← פרטי כניסה זמניים של AWS דרך STS.
למה: User Pools מאמתים משתמשים; Identity Pools מאשרים להם גישה למשאבי AWS.
בחר סוג זרימת עבודה של Step Functions.
Standard: ארוך טווח (≤שנה), בדיוק פעם אחת, $0.025/1k מעברים, היסטוריה מלאה. Express: ≤5 דקות, לפחות פעם אחת או לכל היותר פעם אחת, מחויב לפי בקשה + משך זמן; עבור ETL/streaming בנפח גבוה.
שלב זרימת עבודה נכשל; רוצה ניסיון חוזר עם backoff וניתוב למצב התאוששות.
מערך `Retry` (לכל מצב, עם `BackoffRate` + `MaxAttempts`) ו-`Catch` לניתוב כשל סופי. התאמה לפי `ErrorEquals` (לדוגמה, `States.TaskFailed`, שמות שגיאות מותאמים אישית).
החל את אותה זרימת עבודה על כל פריט במערך, עם הגבלת מקביליות.
מצב Map עם `ItemsPath` ו-`MaxConcurrency`. Distributed Map מטפל ביותר מ-10k פריטים עם קלט מגובה S3.
הפעל Lambda לפי לוח זמנים של cron או התאמה לאירועים נכנסים.
כלל EventBridge. לוח זמנים: `rate(...)` או `cron(...)`. תבנית: מסנן אירועי JSON; התאמה למקור, סוג פרט, שדות פרט.
נתב אירועים מ-SQS / Kinesis / DynamoDB Streams / MSK ליעד עם סינון + טרנספורמציה אופציונליים.
EventBridge Pipes. מקור ← מסנן ← העשרה (Lambda/Step Functions) ← יעד. אין צורך ב-Lambda למקרים הפשוטים.
עיבוד הודעות בסדר קפדני לכל לקוח, עם ביטול כפילויות.
תור SQS FIFO. `MessageGroupId` מחלק את הסדר (מקביליות לכל קבוצה); `MessageDeduplicationId` (או ביטול כפילויות מבוסס תוכן) משמיט כפילויות תוך 5 דקות.
צרכן מושך הודעה אך קורס לפני מחיקתה.
ההודעה מוסתרת למשך VisibilityTimeout שניות, ואז מופיעה שוב למסירה חוזרת. כוונן לזמן העיבוד הארוך ביותר הצפוי + חיץ.
למה: קצר מדי ← עיבוד כפול. ארוך מדי ← התאוששות איטית בקריסה. ChangeMessageVisibility מאריך את הזמן בטיפול אם נדרש.
אירוע אחד חייב להגיע למספר צרכנים (Lambdas / SQS queues / HTTP endpoints).
נושא SNS עם מספר מנויים. מדיניות סינון מנויים מנתבת רק הודעות תואמות לכל מנוי.
כוונן את קיבולת Kinesis Data Streams עבור תפוקת כתיבה.
כל shard = 1 MB/s או 1000 רשומות/s פנימה, 2 MB/s החוצה. הוסף shards (פיצול) או השתמש במצב On-Demand עבור קנה מידה אוטומטי.
קוד ב-EC2 / ECS task / Lambda זקוק לגישה ל-AWS - ללא מפתחות מוטמעים.
צרף תפקיד IAM באמצעות פרופיל מופע (EC2) או תפקיד משימה/ביצוע (ECS/Lambda). ה-SDK שולף פרטי כניסה זמניים משירות המטא-נתונים; מסתובב אוטומטית.
גישה בין חשבונות מקוד אפליקציה או CLI.
`sts:AssumeRole` מה-principal הקורא. מדיניות האמון של תפקיד היעד מפרטת את הקורא כ-`Principal`. מחזיר פרטי כניסה זמניים (מקסימום 12 שעות).
AssumeRole בין חשבונות נכשל - נראה שההרשאה נכונה.
יש להגדיר את שניהם: מדיניות אמון בתפקיד היעד מפרטת את הקורא כ-Principal; מדיניות הזהות של הקורא מאפשרת `sts:AssumeRole` ב-ARN של תפקיד היעד.
למה: אמון = מי יכול להניח. הרשאה = מה הם יכולים לעשות לאחר ההנחה. כל אחד חסר ← AccessDenied.
מדיניות המעניקה למשתמשים גישה רק לתיקיה שלהם ב-S3.
השתמש ב-`${aws:username}` או `${aws:PrincipalTag/X}` ב-ARNs של המשאבים: `arn:aws:s3:::bucket/${aws:username}/*`.
אפשר לצוות לנהל בעצמו תפקידי IAM, אך הגבל את ההרשאות שהם יכולים להעניק.
מדיניות Permission boundary על תפקיד היוצר של הצוות. כל תפקיד שהם יוצרים עם ה-boundary יקבל את החיתוך של מדיניות הזהות + ה-boundary כהרשאות אפקטיביות.
הגבל פעולה לפי כתובת IP מקור / VPC / אזור / MFA.
`Condition` במדיניות: `aws:SourceIp`, `aws:SourceVpc`, `aws:SourceVpce`, `aws:RequestedRegion`, `aws:MultiFactorAuthPresent`.
לקוח SPA / מובייל לעומת שירות בצד השרת הקורא ל-Cognito.
לקוחות ציבוריים (SPA, מובייל) ← לקוח אפליקציה ללא סוד. לקוחות חסויים (שרת) ← לקוח אפליקציה עם סוד; הלקוח חייב לכלול `SECRET_HASH` (HMAC של שם משתמש + clientId).
הבחנה בין Cognito ID token ל-Access token ל-Refresh token.
ID = הצהרות זהות משתמש (לצרוך בלקוח). Access = הרשאה מוגבלת ל-APIs. Refresh = השגת ID/access tokens חדשים. כולם JWTs למעט Refresh.
ממשק משתמש לכניסה/הרשמה מובנה ללא בניית טפסים.
Cognito Hosted UI. זרימת authorization-code של OAuth2: הפניה מחדש ל-`/oauth2/authorize` ← כתובת URL של callback עם `code` ← החלפה ב-`/oauth2/token`.
הצפנת סוד קטן (≤4 KB) ישירות באמצעות KMS.
`kms:Encrypt` מחזיר blob של טקסט מוצפן המכיל את ה-ARN של המפתח. `kms:Decrypt` משחזר טקסט רגיל אם למתקשר יש הרשאה ו-(אם צוין) `EncryptionContext` תואם.
הצפנת נתונים גדולים באמצעות KMS מבלי לחרוג ממגבלת ה-4 KB של הצפנה ישירה.
הצפנת מעטפה. `GenerateDataKey` מחזיר plaintext + DEK מוצפן; הצפנת נתונים מקומית עם DEK, אחסון DEK המוצפן לצד הנתונים, וזריקת DEK ב-plaintext.
למה: KMS אוכף בקרת גישה על ה-DEK הקטן; הצפנה בכמות גדולה מתרחשת באופן מקומי במהירות קו.
הענקת גישה מוגבלת בזמן ל-CMK ל-principal אחר ללא עריכת מדיניות מפתח.
צור הענקת `kms:CreateGrant` המגדירה פעולות + מקבל הענקה. בטל באמצעות `RetireGrant`.
הפנה למפתח KMS בעקיפין כך שה-CMK הבסיסי יכול להסתובב ללא שינויי קוד.
השתמש ב-`alias/my-key` (או `arn:aws:kms:region:acct:alias/my-key`). עדכן את ה-alias להצביע על CMK חדש; הצרכנים ממשיכים לעבוד.
בחר אחסון פרטי כניסה.
Secrets Manager: סיבוב מובנה, אינטגרציה טבעית עם RDS/Redshift/DocumentDB, $0.40/secret/חודש. Parameter Store SecureString: שכבה חינמית (Standard), ללא סיבוב מובנה, נתיבים מרובדת `/app/env/key`.
סובב פרטי כניסה של RDS באופן אוטומטי.
סיבוב מקומי של Secrets Manager (Lambda מנוהל) עבור Aurora/RDS/DocumentDB/Redshift. תבנית master/user משתמשת בסוד master נפרד לסיבוב סוד המשתמש.
אחסן ערך תצורה עם הצפנת KMS במנוחה ב-Parameter Store.
סוג פרמטר SecureString. ציין `--key-id` עבור CMK מותאם אישית; אחרת משתמש ב-`aws/ssm`. פענוח דורש `kms:Decrypt` ב-CMK.
הגבל גישה ל-CloudFront למשתמשים מאומתים.
Signed URLs (משאב יחיד) או signed cookies (מספר משאבים, SPAs/streaming). חתום באמצעות צמד מפתחות של CloudFront המאוחסן כמפתח ציבורי בקבוצת מפתחות של CloudFront.
בחר הצפנת S3 בצד השרת.
SSE-S3 (מנוהל AES-256, ברירת מחדל), SSE-KMS (CMK, ביקורת דרך CloudTrail, מדיניות מפתח), SSE-C (מפתחות שסופקו על ידי לקוח, אתה מנהל), DSSE-KMS (שכבה כפולה לתאימות גבוהה).
מצא תפקידים/מדיניות המעניקים גישה מחוץ לחשבון או שהם עם הרשאות יתר.
IAM Access Analyzer. ממצאים על גישה חיצונית; יצירת מדיניות מהיסטוריית CloudTrail עבור התאמה מדויקת של פחות הרשאות.
משתנה סביבה של Lambda מכיל ערך רגיש.
Lambda מצפין משתני סביבה במנוחה באמצעות KMS כברירת מחדל. לבקרת in-transit/at-decrypt, הגדר CMK מותאם אישית והשתמש בעזרי ההצפנה בקונסולה כדי לשלוח ciphertext מוצפן מראש.
דפדפן ← API Gateway עם כותרת `Authorization` נחסם על ידי preflight.
הוסף מתודת OPTIONS (אינטגרציה מדמה). אפשר `Authorization` ב-`Access-Control-Allow-Headers`; אפשר קוראים ב-`Access-Control-Allow-Origin`.
חתום על בקשת HTTP מותאמת אישית לשירות AWS מקוד שאינו SDK.
Sigv4: גזור מפתח חתימה מסוד + תאריך + אזור + שירות; צור בקשה קנונית; חתום; הוסף כותרות `Authorization`, `X-Amz-Date`, `X-Amz-Security-Token`.
הנח תפקיד רחב אך צמצם אותו עבור סשן ספציפי.
`AssumeRole` עם `Policy` (מדיניות סשן מוטמעת) מגבילה עוד יותר את ההרשאות האפקטיביות: חיתוך של מדיניות התפקיד + מדיניות הסשן.
גישה ל-S3 נדחתה למרות שמדיניות IAM מאפשרת אותה.
גם מדיניות הדלי וגם מדיניות הזהות מוערכות. דחייה מפורשת בכל מקום מנצחת. הגדרות Block Public Access יכולות גם לבטל אישור.
בנה צינור CI/CD: מקור ← בנייה ← בדיקה ← פריסה עם אישור ידני ב-prod.
שלבי CodePipeline, כל אחד עם פעולה אחת או יותר. פעולת אישור ידני בין Test ל-Deploy. מקור = CodeCommit / GitHub / S3 / ECR.
הגדר שלבי בנייה עבור CodeBuild.
`buildspec.yml` בשורש הריפו. שלבים: `install`, `pre_build`, `build`, `post_build`. פלטים: `artifacts.files`, `cache.paths`. משתני סביבה דרך `env.variables` או הפניות ל-Parameter Store/Secrets Manager.
העבר תעבורת Lambda ב-10% ואז ב-100% עם ביטול אוטומטי בהתראות.
CodeDeploy עם `LambdaCanary10Percent5Minutes` / `10Percent10Minutes` / `10Percent15Minutes` / `10Percent30Minutes`. הגדר התראות CloudWatch ב-DeploymentGroup.
השקת Lambda הדרגתית במרווחים שווים.
`LambdaLinear10PercentEvery1Minute` / `2Minutes` / `3Minutes` / `10Minutes`. כל מרווח מעביר +10% עד 100%.
פריסת Blue/green עבור שירות ECS מאחורי ALB.
CodeDeploy Compute Platform = ECS. יוצר קבוצת משימות ירוקה; ה-ALB מעביר את המאזין לקבוצת יעד ירוקה; אישור ידני אופציונלי לפני העברת התעבורה ולפני סיום הכחול.
עדכון צי EC2 ללא השבתה מלאה של הצי.
פריסה במקום עם תצורות `OneAtATime` / `HalfAtATime` / `AllAtOnce`. ווים של Auto Scaling Group משהים השקת מופעים חדשים במהלך הפריסה.
אירוח רפוזיטורי Git בתוך AWS עם גישה נשלטת IAM.
CodeCommit. אימות: מפתחות SSH לכל משתמש IAM, פרטי כניסה HTTPS Git לכל משתמש IAM, או עוזר פרטי כניסה של AWS CLI. מפעילים דרך SNS / Lambda בדחיפה.
בחר כלי IaC לאפליקציה serverless.
CDK: שפות תכנות (TS/Python/Java/Go/.NET), מבני אפליקציה מלאים, תבניות מרובות משאבים. SAM: הרחבת YAML של CFN, מתמקד ב-serverless, פשוט יותר. שניהם מקומפלים ל-CloudFormation.
הגדר ערימת Lambda + API Gateway + DynamoDB עם YAML מינימלי.
`Transform: AWS::Serverless-2016-10-31`. משאבים: `AWS::Serverless::Function`, `Api`, `SimpleTable`. `sam build` → `sam deploy --guided`.
בנה מבנה קוד CDK.
`App` מכיל stack אחד או יותר (`Stack`s). כל Stack מכיל constructs (L1/L2/L3). `cdk synth` → תבנית CFN. `cdk deploy` פורס דרך CFN.
בחר רמת construct של CDK.
L1 = CFN גולמי (`CfnXxx`). L2 = עטיפות מנוהלות עם ברירות מחדל בטוחות (נפוצות ביותר). L3 = תבניות המשלבות מספר משאבים עבור ארכיטקטורות מלאות (לדוגמה, `LambdaRestApi`).
תצוגה מקדימה של שינויים לפני יישום על ערימת CloudFormation.
`create-change-set` ← סקור JSON של תוספות/שינויים/החלפות ← `execute-change-set`. פעולות החלפה גורמות ליצירה מחדש של משאבים.
עדכון ערימה נכשל באמצע הדרך.
CloudFormation מבצע rollback אוטומטי אלא אם `DisableRollback` הוא true. נתקע ב-`UPDATE_ROLLBACK_FAILED`? השתמש ב-`ContinueUpdateRollback` עם `ResourcesToSkip`.
מניעת עדכון בשוגג של משאב קריטי (לדוגמה, RDS DB) במהלך עדכוני ערימה.
מדיניות ערימה: JSON השולל `Update:Replace` ו-`Update:Delete` על ה-ID הלוגי של המשאב. עקוף עם override מפורש בעדכון ספציפי.
שימוש חוזר בתשתית על פני ערימות.
ערימות מקוננות (`AWS::CloudFormation::Stack` עם `TemplateURL`) לשימוש חוזר בבעלות הורה אחד. בין ערימות באמצעות Outputs + `Fn::ImportValue` לחיבור הדוק יותר בין ערימות נפרדות.
הזרקת ערך Parameter Store או secret של Secrets Manager לתוך תבנית CFN.
`{{resolve:ssm:/path/to/param}}`, `{{resolve:ssm-secure:/path}}`, `{{resolve:secretsmanager:secret-id:SecretString:json-key}}`. נפתר בזמן הפריסה.
בחר מדיניות פריסה של Elastic Beanstalk.
All-at-once (המהירה ביותר, זמן השבתה), Rolling (אין מופעים נוספים, קיבולת חלקית), Rolling with additional batch (אין אובדן קיבולת, עלות נוספת), Immutable (ASG חדש, הבטוחה ביותר), Blue/Green (סביבה נפרדת, החלף CNAMEs).
התאמה אישית של סביבת Elastic Beanstalk (חבילות, קבצים, פקודות קונטיינר).
`ebextensions/*.config.` YAML בחבילת המקור. פלטפורמות חדשות יותר: `platform/hooks/`. סקריפטים של shell עבור מחזור החיים של prebuild/predeploy/postdeploy.
זקוק לחפץ Lambda יציב, שאינו משתנה לעולם.
פרסם גרסה ממוספרת. קוד + רוב התצורה (זיכרון, timeout, משתני סביבה, שכבות) קופאים. `$LATEST` ניתן לשינוי; גרסאות ממוספרות אינן.
דחוף תמונת Docker ל-ECR עבור ECS / EKS / Lambda.
`aws ecr get-login-password | docker login` → `docker tag` → `docker push`. תמונות קונטיינר של Lambda: תמונה נמשכת פעם אחת בפריסה; התמונה המתויגת חייבת להיות באותו אזור.
הפעל אצווה חד פעמית לעומת שירות ווב ארוך טווח ב-ECS.
RunTask = משימה בודדת, מסתיימת ויוצאת. Service = שומר על N משימות רצויות, מפעיל מחדש כשלים, משתלב עם ALB/NLB.
הפחת עלות מחשוב לעומסי עבודה של ECS עמידים בפני תקלות.
ספק קיבולת Fargate Spot. שלב עם Fargate רגיל באמצעות משקלים ובסיס. משימות עשויות להיקטע עם אזהרה של 2 דקות.
עקוב אחר בקשה שמתפצלת בין Lambda ← DynamoDB ← HTTP חיצוני.
קטעי X-Ray לפי קפיצת שירות, תת-קטעים עבור קריאות בהמשך. מפת שירות מדמיינת טופולוגיה + זמן השהיה. כללי דגימה מגבילים את הנפח.
צרף נתונים הניתנים לחיפוש לעומת נתוני עזר לעקבת X-Ray.
Annotations: מאונדקסים, ניתנים לסינון בקונסולה (לדוגמה, `customerId`, `tier`). Metadata: לא מאונדקסים, צורה חופשית (גוף בקשה, גוף תגובה לצורך איתור באגים).
עלות X-Ray גבוהה בייצור.
כלל דגימה מותאם אישית. ברירת מחדל: 1 בקשה/שנייה ראשונה + 5% נוספים. כללים תואמים לפי שירות / נתיב URL / מתודה.
שלף יומני Lambda עבור שגיאות בשעה האחרונה, מקובצים לפי דלי של 5 דקות.
CloudWatch Logs Insights: `fields @timestamp, @message | filter @message like /ERROR/ | stats count() by bin(5m)`.
צור מדד מותאם אישית מתבנית יומן (לדוגמה, ספירה של `OutOfMemoryError`).
Metric filter על קבוצת היומנים. תבנית תואמת אירועי יומן; המסנן יוצר מדד CloudWatch מותאם אישית שתוכל להתריע עליו.
פלט מדדים מותאמים אישית מ-Lambda ללא קריאת API נפרדת של `PutMetricData`.
Embedded Metric Format: כתוב JSON מובנה ל-stdout; CloudWatch מנתח יומנים ויוצר מדדים. זול יותר ואסינכרוני.
למה: מפריד את נתיב המדד מנתיב הבקשה; אין זמן השהיה של API או הרשאת IAM נוספת.
האפליקציה פולטת מדדים מותאמים אישית ברזולוציה גבוהה בכל שנייה.
`PutMetricData` עם `StorageResolution=1` עבור גרנולריות של שנייה אחת. רזולוציה סטנדרטית היא 60 שניות; רזולוציה גבוהה עולה יותר.
התחלות קרות של Lambda פוגעות ביעדי זמן השהיה p99.
Provisioned Concurrency לעומס צפוי. SnapStart עבור קוד Java/Python עם אתחול כבד. תלויות דקות, השתמש ב-ARM/Graviton, העבר את האתחול הכבד מחוץ למטפל.
בחר זיכרון Lambda לעלות/זמן השהיה הטובים ביותר.
זיכרון גם מגדיל CPU + רשת. השתמש במכונת המצבים AWS Lambda Power Tuning כדי לסרוק זיכרון ולמצוא את נקודת המפגש הטובה ביותר עבור עומס העבודה שלך.
הפעלת Lambda ארוכה חורגת מהמגבלה הקשה של 15 דקות.
פרק ל-Step Functions; העבר ל-Fargate (זמן ריצה ארוך) או Batch (HPC). המקסימום של Lambda הוא 900 שניות; לא ניתן למשא ומתן.
`TooManyRequestsException` מ-Lambda; הושגה מגבלת מקביליות.
Reserved concurrency לכל פונקציה (מגביל + שומר) או בקש הגדלת מגבלה ברמת החשבון. הפעלות אסינכרוניות נכנסות לתור ומנוסות מחדש; הפעלות סינכרוניות גורמות לשגיאה.
DynamoDB מחזיר `ProvisionedThroughputExceededException`.
CloudWatch `WriteThrottleEvents` / `ReadThrottleEvents`. עבור למצב On-Demand, הגדל קיבולת שהוקצתה, או תקן מחיצה חמה עם עיצוב מפתח טוב יותר.
מפתח מחיצה אחד מקבל תעבורה לא פרופורציונלית; throttling תחת עומס כולל נמוך.
עצב מחדש את מפתח המחיצה עם קרדינליות גבוהה. עבור כתיבות: הוסף קידומת עם shard אקראי (לדוגמה, `shard#user`); עבור קריאות: scatter-gather על פני shards.
זקוק לזמן השהיה של קריאת DynamoDB במיקרו-שניות ללא שינוי לוגיקת האפליקציה.
DAX cluster + DAX SDK כתחליף ל-DynamoDB SDK. קריאות מוגשות ממטמון בזיכרון; כתיבות כותבות דרך לטבלה.
בחר אסטרטגיית מטמון עבור ElastiCache / DAX.
טעינה עצלה (cache miss ← DB ← מילוי מטמון): מטמון רק נתונים מבוקשים, אך נוטה להתיישנות. כתיבה דרך (כתיבה למטמון + DB בכל כתיבה): תמיד טרי, אך לכתיבות יש עלות נוספת. TTL מגביל התיישנות בכל מקרה.
API Gateway מחזיר 429 Too Many Requests.
רמת חשבון ברירת מחדל: 10,000 בקשות/שנייה + 5,000 burst. עקיפות לכל stage ולכל method; throttling לכל מפתח באמצעות Usage Plans לבקרת רמת שותפים.
שגיאות שירות AWS זמניות במהלך תעבורה כבדה.
ה-AWS SDK מנסה מחדש אוטומטית עם exponential backoff + jitter. הגדר `RetryMode = adaptive` או `standard`; כוונן `maxAttempts`.
CloudFront מגיש תוכן מיושן לאחר פריסה.
בטל תוקף נתיבים (`/index.html`, `/*`) - מחויב לכל נתיב מעבר ל-1000/חודש חינם. עדיף: שמות קבצים מגוונים (`app.abc123.js`) כך שהמטמון יעקף באופן טבעי.