แกแขแแขแแแก แแแ แแแแแ แแแแแแแแ แกแแแชแแแแฃแ แแ แแฃแ แกแแก แกแขแฃแแแแขแแแแกแแแแก
แแแขแ แแแแแแแแ แแแแ แแ แแแก AWS Lambda-แแ แแแกแจแขแแแฃแ แแแแก, แจแแกแ แฃแแแแแก, แแแแแแแแกแ แแ แแแแจแ แแแแแแแแแแ แแ แแฃแแแแช แขแ แแแแแแแแแ แแแแฎแแแแแก แแแแฃแจแแแแแแก แจแแกแแซแแแแแแแแกแแแแก. แแแแกแแแแแก แแฅแแแ แแ แแญแแ แแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแ แแแ, แ แแแแแแแช แกแแ แแแกแ แแฃแจแแแแก. แแ autoscaling แแแซแแแแ แกแแจแฃแแแแแแก แแแแแกแแฎแฃแ แแ แแแแกแแแแ แแ แแแ แแฃแ แแแแฎแแแแแก แฌแแแจแ. แแคแแฅแ แแ, AWS Lambda แกแแแแ แแแแแแแ แจแแแซแแแแ แแฌแแแแก แแ แ-แแ แ แงแแแแแแ แแแแฃแแแ แฃแ AWS แกแแ แแแกแก.
AWS แแแแแแ
AWS Lambda แแ แแก แแแแแแแแแแ แแ แแแแขแแ แแแฃแแ แกแแ แแแ แแก แแแ แแจแ แแแแแแแแแแ แกแแ แแแกแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแฃแจแแแ แแแแ แกแแ แแแ แแแแก แฃแแ แฃแแแแแงแแคแแก แแ แแแ แแแแก แแแ แแจแ แแ แแแแคแแ แแแแแ แกแฎแแ AWS แกแแ แแแกแแแ แแแ แแแแฃแแ แแแแแแแก แแแแแงแแแแแแ. Lambda แแแขแแแแขแฃแ แแ แแแกแฃแฎแแแก แกแฎแแแแแกแฎแแ แแแแแแแแแก (แ.แฌ. แขแ แแแแ แแแ), แ แแแแ แแชแแ HTTP แแแแฎแแแแแแ Amazon API Gateway-แแก แแแจแแแแแแ, แแแแแชแแแแแแก แชแแแแแแแแแ Amazon S3 แแแแแฃแแแแจแ แแ Amazon DynamoDB แชแฎแ แแแแแจแ; แแ แจแแแแซแแแแ แแแฃแจแแแ แแฅแแแแ แแแแ API แแแ แแแแก แแแจแแแแแแ AWS SDK-แแก แแ แแแแแแแ แแแแแก แแแแแกแแแแแแก แแแแแงแแแแแแ AWS Step Functions-แจแ.
Lambda แแฌแแ แแแแแก แแแแก แแแฆแแ แฎแแแแแกแแฌแแแแ แแแแแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแ แแ แกแ แฃแแแ แแ แแก แแแกแฃแฎแแกแแแแแแแ แซแแ แแแแแ แแแแขแคแแ แแแก แแแแแแแกแขแ แแ แแแแแ, แแแ แจแแ แแก แกแแ แแแ แแกแ แแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแแแแ, แ แแกแฃแ แกแแแแก แฃแแ แฃแแแแแงแแคแแแ, แแแขแแแแขแฃแ แแแกแจแขแแแแ แแแแแ, แแแแแก แแแแแขแแ แแแแแ แแ แแแแแแแแ. แแแฃ, แแฅแแแ แฃแแ แแแแ แฃแแแ แแขแแแ แแแ แแฅแแแแ แแแแ แแ แแแแแแแคแแแฃแ แแ แแ แ แแแแ แแ แ แแแแก แฃแแแ แจแแกแ แฃแแแแก. แแแแแก แแฎแ แแ, แกแแ แแแกแ แแแ แฃแแแแก แแแก แแแจแแแแแแ แแ แฃแแ แฃแแแแแงแแคแก แแฅแแแแ แแแแแแแชแแแก แแแฆแแ แฎแแแแแกแแฌแแแแแแแแก.
แ แแแแก แแแแแแแแแ แแแแแแแแ?
AWS Lambda แแ แแก แแแกแแฎแแ แฎแแแแแ แแแแแแแแแแ แแแแขแคแแ แแ, แ แแแแแแช แจแแกแแคแแ แแกแแ แกแฎแแแแแกแฎแแ แแแแแงแแแแแแก แจแแแแฎแแแแแแแกแแแแก, แแฃ แแฅแแแแ แแแแแก แแแ แแ แแแจแแแแแก แแ แ แแฎแแ แแแญแแ แแแแ แกแแ แแแกแแก แแแแ . แแฃ แแกแฃแ แ แคแแแฃแกแแ แแแ แแแแฎแแแแแ แแฅแแแแก แแแแแ แแ แแแแแแก แแแแแแแแ, แกแแ แแแ แแก แจแแแแ แฉแฃแแแแแก, แฃแแ แฃแแแแแงแแคแแกแ แแ แกแแแแแ แแแแก แแฃแแกแแ แกแแแแแก แแ แแก แแแแแแ แฃแ แคแแกแแ, AWS Lambda แแแแแแแแแ แแแแแกแแแแแแ.
Lambda แแแแแแฃแ แแ แแ แแแ แแแแ แแแแก แแแขแแ แคแแแกแแแแก แจแแกแแฅแแแแแแ แแ API Gateway-แแแ แแ แแแ แแแแแงแแแแแแกแแก แจแแแแซแแแแ แแแแจแแแแแแแแแ แจแแแแชแแ แแ แฎแแ แฏแแแ แแ แฃแคแ แ แกแฌแ แแคแแ แแแฎแแแแ แแแแแ แแ. แแ แกแแแแแก แแแแแแแก แคแฃแแฅแชแแแแแก แแ แแแ แแแแขแ แแแแก แแแแแงแแแแแแก แกแฎแแแแแกแฎแแ แแแ แกแแ แแแ แแก แแแ แแจแ แแ แฅแแขแแฅแขแฃแ แแก แแ แแแแแแแแแกแแแแก - แงแแแแแก แจแแฃแซแแแ แแแ แฉแแแก แ แแแแ แจแแกแแคแแ แแกแ แแแแแกแ แแแแแแแแ แแแแแแแแแแ แ.
Lambda แแแซแแแแ แกแแจแฃแแแแแแก แจแแแกแ แฃแแแ แแแแแแแแแแแก แคแแ แแ แกแแแฅแขแ แ. แแแ แแแแ, CloudWatch-แแก แแฎแแ แแแญแแ แแก แฌแงแแแแแแ, แจแแแแซแแแแ แจแแฅแแแแ แแแแแแแแฃแแ แแแแชแแแแแ แแ แแแขแแแแขแแแแ แแแ แแแแแแแแฃแแแฃแ แ แแ แแชแแกแแแ. แแ แแ แกแแแแแก แจแแแฆแฃแแแแแ แกแแ แแแกแแก แแแแแงแแแแแแก แแฃแแแแแกแ แแ แแแขแแแกแแแแแแแ (แแฎแแแแแแแแแจแ แแแแฆแแแ แแแฎแกแแแ แแแแก แแแฎแแแ แแแ แแ แแ แ) แแ แแ แแคแแ แ แแแจแแแ แฎแแแก แกแแกแขแแแแขแแฃแ แแ แแแฃแจแแแ แแแแแแแแ แแแคแฃแซแแแแฃแ แกแ แฃแแคแแกแแแแ แแแแ แแกแแ แแแกแแ.
แแฅ แจแแแแซแแแแ แจแแฅแแแแ แกแแ แแแกแแ แแ แแแแขแแ แแแฃแแ แแแฅแแแแแแแแ, แ แแแแแแแช แแฃแแแแแแ แแ แแฃแจแแแแก. แขแแแแฃแ แ แแแแแแแแแ แแแแแกแแฎแฃแแแแแก แแแกแจแขแแแแ แแแ. แแแแแฌแแแแแฃแแ แกแแกแขแแแแแแก แจแแแแฎแแแแแจแแช แแ, แแแแแแแก แคแฃแแฅแชแแแแ แ แฉแแแ แแฅแขแฃแแแฃแ แ.
แแกแ แ แแ, แแฃ แแ แแกแฃแ แ แแแฃแแแแแแแแ แแแแแแแแแแ แ แแกแฃแ แกแแแแก แแแแแฌแแแแแแก แแ แแแ แแแแก, แกแชแแแแ AWS Lambda; แแฃ แแ แแญแแ แแแแแ แแซแแแ, แ แแกแฃแ แกแแ แแแขแแแกแแฃแ แ แแแแแแแแแแ, แแกแแแ แกแชแแแแ AWS Lambda; แแฃ แแฅแแแแ แแแแ แแแ แแแแฃแแแ แแฃแจแแแแก, แแกแแ, แฃแแแ แกแชแแแแ AWS Lambda.
แฃแกแแคแ แแฎแแแแแก
แฏแแ แฏแแ แแแแ แแ แแ แแก แแ แแขแแแแแ แฃแกแแคแ แแฎแแแแแกแแแ แแแแแแจแแ แแแแ. แแแแ แแก แแฎแ แแ, แแแแแแแแ แแ แแแแแแแก แแ แแแแแ แจแแแ แแ แแชแแกแ แแ แแแแฎแแ แชแแแแแแแก แแแฎแแกแแแแแแแแ แแแคแแ แฃแแแ AWS Lambda-แก แแแ แแฃแแ แแแจแแแแแก แแแ แแแแก แแแแฎแแแ แแแแแกแแแ, แฆแ แฃแแแแแแแ แฃแกแแคแ แแฎแแแแแก แแแแแแ แแ แแแแแแแ แแแฆแแแฃแแ แฌแแกแ แจแแฃแกแแแแแ แฎแแแแ.
AWS แกแแ แแแกแแแแก แฃแแแขแแกแแแแก แแกแแแแกแแ, Lambda แฃแแ แฃแแแแแงแแคแแแแ แฃแกแแคแ แแฎแแแแแกแ แแ แจแแกแแแแแแกแแแแก แกแแแ แแ แกแแคแฃแซแแแแแ AWS-แกแ แแ แแแแฎแแแ แแแแแก แจแแ แแก. แแก แแ แแแชแแแ แแแชแแ แแแก แแแแแแขแแก แแแแ แแชแแฃแ แแแขแแแ แแแแก, แแแแแแแแ AWS แแฆแแแก แแแแแแแแแแก แกแแ แแแกแแก แแแแแแแแแขแแแแก แจแแแแ แฉแฃแแแแแก, แแแแแแแกแขแ แแ แแแแกแ แแ แแแแแขแแ แแแแแก แจแแกแแฎแแ - แแแกแแแแซแแแ แแแแ แแชแแฃแแ แกแแกแขแแแแแแ แแ แแแ แขแฃแแแแแแชแแแก แคแแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแฅแขแแแแแแก แคแแแแแฃแ แฃแกแแคแ แแฎแแแแแแแ.
แแแแแ แแขแฃแแแ AWS Lambda-แแ แกแแฃแแ แแกแแก, AWS แแแกแฃแฎแแกแแแแแแแแ แซแแ แแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก, แแกแแชแแ แแแฃแแ แซแแ แแแแแ แกแแ แแแกแแแแก, แแแแ แแชแแฃแแ แกแแกแขแแแแก แแ แแแแแแแชแแแก แแแแขแคแแ แแแก แแแ แแแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแแแแขแ แแแกแฃแฎแแกแแแแแแแแ แแแกแ แแแแแก แฃแกแแคแ แแฎแแแแแแ, แแแแคแแแแแชแแแแฃแ แ แแแแแชแแแแแแก แจแแแแฎแแแแ, แแแกแแ แฌแแแแแแก แแแแขแ แแแแ, แแกแแแ Lambda แกแแ แแแกแกแ แแ แ แแกแฃแ แกแแแแ (Identity and Access Management, IAM), แแแ แจแแ แแก แแแแแงแแแแแฃแแ แคแฃแแฅแชแแแแแก แคแแ แแแแแจแ.
แฅแแแแแ แแแชแแแฃแแ แแแแแ แแแ แแแแฉแแแแแแก แกแแแ แแ แแแกแฃแฎแแกแแแแแแแแแก แแแแแแก, แ แแแแ แช แแก แแฎแแแ AWS Lambda-แก. AWS แแแกแฃแฎแแกแแแแแแแแ แแ แแก แแแ แแแฏแแกแคแแ แ แแ แแแแฎแแแ แแแแแแ แแแกแฃแฎแแกแแแแแแแแ แแฃแ แฏแ. แ แแแแ แช แฎแแแแแ, AWS แฃแคแ แ แแแข แแแกแฃแฎแแกแแแแแแแแแก แแฆแแแก แกแแ แแแกแแ แแแแแแแแแฃแ แแแแแแแชแแแแแ.
แแแแแแ แแแฃแแ แแแกแฃแฎแแกแแแแแแแแแก แแแแแแ, แ แแแแแแช แแแแแแงแแแแแ AWS Lambda-แกแแแแก
แแแแแแ แแแจแแแแแก แแ แ
Lambda-แก แแแแแแ แ แฃแแแ แแขแแกแแแ แแก แแ แแก, แ แแ แแฅแแแแ แกแแฎแแแแ แคแฃแแฅแชแแแก แจแแกแ แฃแแแแแ แกแแ แแแกแ แแแแแ แแแแแงแแคแก แกแแญแแ แ แ แแกแฃแ แกแแแก. แแฅแแแ แจแแแแซแแแแ แแแแแแแ แแแชแแแแ แแ แแแกแ แแ แซแแแแกแฎแแแแแก แแแแแ แแแ แกแแกแขแแแแก แแแแแแแกแขแ แแ แแแแแ แแ แคแแแฃแกแแ แแแ แแแแฎแแแแแ แแแแแแก แแแแแแแกแ แแ แแแแแ แแแแแ.
แแแแแแ แกแแ แแแกแ แแแงแแคแแแแ แแ แแแแแแคแ แแแแแแ. แแแ แแแแ แแ แแก แกแแแแแขแ แแแ แแแแแแคแ แแแแแ. แแแแแแแแแแก แแแฎแแแแแ, แกแแแแแขแ แแแ แแแแแแคแ แแแแแ แแ แแก แฅแกแแแแก แแแฌแแแ, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ แกแแกแแแแแแ แขแ แแคแแแแก แขแ แแแกแแแ แขแแ แแแแแ แแ แแแ แจแ แฃแขแแแแชแแแแ. แแก แแ แแก แซแแ แแแแแ แแแแแแแแแขแ, แ แแแแแแช แแฆแแแก แแแแแแแฃแ แแแแแฌแงแแแขแแแแแแแก แกแแแฃแจแแ แแแขแแแ แแแแก แฃแแ แฃแแแแแงแแคแแก, แแแแกแแฎแฃแ แแแแกแ แแ แแแแแฌแแแแแแก แจแแกแแฎแแ. แแแ แแ แแแแกแ, แกแแแแแขแ แแแ แกแแแ แขแงแ แแแฅแแแแแแก แ แแแแ แช แแแแแฌแงแแแขแแก แแแแฌแแแแแแแก แฅแกแแแแก แขแแแแแแแแ, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ แขแ แแคแแแแก แแแ แจแ แฃแขแแแแชแแแกแ แแ แแแ แแแแแ.
แแแแ แ แกแแแ แขแงแ แแ แแก แแแแแชแแแแ แกแแแ แขแงแ. แแแก, แแกแแแ แ แแแแ แช แกแแแแแขแ แแแ แแแแแแคแ แแแแแก, แแฅแแก แแแแแกแ แแแแชแแแแแ. แกแแแแแขแ แแแ แกแแแ แขแงแ แฃแแ แฃแแแแแงแแคแก API-แแแก แคแฃแแฅแชแแแแแก แแแ แแแแกแแแแก (CreateFunction, UpdateFunctionCode) แแ แแแแแขแ แแแแแก, แแฃ แ แแแแ แแแฃแแแแจแแ แแแแ Lambda แกแฎแแ AWS แกแแ แแแกแแแก. แแแแแชแแแแ แกแแแ แขแงแ แแแแแขแ แแแแแก Invoke API-แก, แ แแแแแแช แแฎแแ แชแแแแแแก Lambda แคแฃแแฅแชแแแแก. แคแฃแแฅแชแแแก แแแแแซแแฎแแแแก แจแแแแแ, แกแแแแแขแ แแแ แกแแแ แขแงแ แแแแแงแแคแก แแ แแ แฉแแแก แแ แกแแแฃแ แแแจแแแแแก แแแ แแแแก, แ แแแแแแช แฌแแแแกแฌแแ แแ แแก แแแแแแแแแฃแแ แแ แคแฃแแฅแชแแแกแแแแก แแ แจแแแแแ แแฎแแ แชแแแแแแก แแแกแจแ แแ แกแแแฃแ แแแแก.
AWS Lambda แแฎแแ แก แฃแญแแ แก แกแฎแแแแแกแฎแแ แแ แแแ แแแแ แแแแก แแแแแก, แแแ แจแแ แแก Java 8, Python 3.7, Go, NodeJS 8, .NET Core 2 แแ แกแฎแแ, แแแแ แจแแกแแแแแแกแ แแแจแแแแแก แแแ แแแแจแ. AWS แ แแแฃแแแ แฃแแแ แแแแฎแแแแก แแแ, แแแ แชแแแแแก แฃแกแแคแ แแฎแแแแแก แแแขแฉแแแก แแ แแฎแแ แชแแแแแแก แกแฎแแ แขแแฅแแแแฃแ แแฅแขแแแแแแแก แแ แแแ แแแแจแ. Lambda แแแซแแแแ แกแแจแฃแแแแแแก แแแแแแงแแแแ แกแฎแแ แแแแแแช, แแ แแแ แแแแ, แ แแ แแฅแแแ แแแแแ แแแแแฎแแ แชแแแแแแ แจแแกแแแแแแก แแแจแแแแแก. แจแแแแแ แแ แแแแแฌแแแ แแแ แฃแแแ แแแก แแแแแแแ, แฃแกแแคแ แแฎแแแแแก แแแแแขแแ แแแแแก แฉแแแแแแ.
แ แแแแ แแฃแจแแแแก แแก แงแแแแแคแแ แ แแ แ แแแแ แจแแแกแ แฃแแแแก แกแแ แแแกแ แแฅแแแแก แคแฃแแฅแชแแแแก?
แแแแแแฃแแ แคแฃแแฅแชแแ แแฃแจแแแแก แแ แ แแ แ แแแแแแแแ แแแแแงแแคแแ แแแ แแแแจแ, แ แแแแแแช แแ แกแแแแแก แแฎแแแแ แแ แคแฃแแฅแชแแแก แกแแชแแชแฎแแแก แแแแแแแแแแแจแ แแ แจแแแแแ แแแแแแแฃแ แแแฃแแแ. แแแแแแฃแแ แแแ แแแ แแฎแแ แชแแแแแแก แแฎแแแแ แแ แ แแแ แก แแ แแแ แแฃแแแ, แแแแ แแ แแก แฎแแแแฎแแ แแแแแแงแแแแแ, แแฃ แแ แกแแแแแก แ แแแแแแแแ แกแแ แแฃแแ แแแ แ แแแแแ แคแฃแแฅแชแแแแ. แงแแแแ แแแจแแแแแก แแแ แแแ แแฃแจแแแแก แแแ แขแฃแแแฃแ แแแแฅแแแแแแ แขแแฅแแแแแก แแแ แขแฃแแแแแแชแแแ - แ.แฌ. microVMs. แแแแแแฃแแ microVM แแแแญแแแ แแแแแ แแขแฃแ AWS แแแแแ แแจแก แแ แแแกแ แฎแแแแฎแแ แแแแแงแแแแแ แจแแกแแซแแแแแแแ แแ แแแแแ แแจแจแ แกแฎแแแแแกแฎแแ แคแฃแแฅแชแแแแแก แจแแกแแกแ แฃแแแแแแ. MicroVM-แแแ แจแแคแฃแแฃแแแ Lambda Worker แขแแฅแแแแแก แแแแขแคแแ แแแก แกแแแจแแแแแแ แแแแแแแจแ, แ แแแแแกแแช แคแแแแก แแ แแแ แแแแก AWS. แแ แแ แแ แแแแแ แแแจแแแแแก แแ แ แแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แกแฎแแแแแกแฎแแ แคแฃแแฅแชแแแ แแ แแ แช microVM-แแแแ แฃแแแแแแฃแ แ แกแฎแแแแแกแฎแแ AWS แแแแแ แแจแแแแกแแแแก.
AWS แแแแแแแก แแแแแแชแแแก แแแแแแ
แกแแแฃแจแแ แแ แแแก แแแ แแแแก แแแแแแชแแ แฎแแ แชแแแแแแแ แ แแแแแแแแ แแแฅแแแแแแแก แแแแแงแแแแแแ. แแแแแแฃแแ แแแ แแแแก แแแแ แแแแแแ แแ แแก แจแแแแแแ แแแแแแแแแขแแแแก แชแแแแแฃแแ แแกแแแแ:
- แคแฃแแฅแชแแแก แแแแ
- แคแฃแแฅแชแแแกแแแแก แจแแ แฉแแฃแแ แแแแแกแแแแ แ แแแแแแ แคแแแ
- แคแฃแแฅแชแแแก แจแแกแ แฃแแแแแก แแแ แแแ
- แแแแแแแแฃแ แ แแแแฎแแแ แแแแแก แกแแแ แชแ Amazon Linux-แแ แแแคแฃแซแแแแฃแแ
แจแแแแแแ แแแฅแแแแแแแแ แแแแแแงแแแแแ แจแแกแ แฃแแแแแก แกแฎแแแแแกแฎแแ แแแ แแแแก แแแแแแ แแแแกแแแแก:
- cgroups - แแฆแฃแแแแก แฌแแแแแแก CPU-แแ, แแแฎแกแแแ แแแแแ, แกแแชแแแแ แแ แฅแกแแแแก แ แแกแฃแ แกแแแแ แแแแแแฃแแ แแแจแแแแแก แแแ แแแแกแแแแก;
- แกแแฎแแแแ แกแแแ แชแแแแ - แแ แแชแแกแแก ID-แแแแก, แแแแฎแแแ แแแแแก ID-แแแแก, แฅแกแแแแก แแแขแแ แคแแแกแแแแก แแ แกแฎแแ แ แแกแฃแ แกแแแแก แแแฏแแฃแคแแแ Linux-แแก แแแ แแแแก แแแแ . แแแแแแฃแแ แแแจแแแแแก แแ แ แแแแแก แกแแแฃแแแ แกแแฎแแแแ แกแแแ แชแแจแ;
- seccomp-bpf - แแฆแฃแแแแก แกแแกแขแแแฃแ แแแ แแแก, แ แแแแแแแช แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแจแแแแแก แแ แแก;
- iptables แแ แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแแแ - แจแแกแ แฃแแแแแก แแแ แแแแก แแ แแแแแแแแกแแแ แแแแแแชแแ;
- chroot - แฃแแ แฃแแแแแงแแคแก แจแแแฆแฃแแฃแ แฌแแแแแแก แซแแ แแแแ แคแแแแฃแ แกแแกแขแแแแแ.
AWS แกแแแฃแแ แแแแก แแแแแแชแแแก แขแแฅแแแแแแแแแแแ แแ แแแ, แแก แแแฅแแแแแแแแ แฃแแ แฃแแแแแงแแคแแ แแฃแจแแแแแก แแ แแแก แกแแแแแแ แแแแชแแแแแแแแแก. แแ แแแแ แแแแแแ แแแฃแ แแแ แแแแก แแ แจแแฃแซแแแ แฌแแแแแ แแ แจแแชแแแแแก แแแแแชแแแแแ แกแฎแแ แแแ แแแแแแ.
แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแ แแ แแ แแแแแ AWS แแแแแ แแจแแก แแ แแแแแฏแแ แแแ แแแจแแแแ แจแแแซแแแแ แแ แ microVM-แแ, แแ แแแแแแ แจแแแแฎแแแแแจแ แแ แจแแแซแแแแ microVM-แแแแก แแแแแแ แแแ แกแฎแแแแแกแฎแแ AWS แแแแแ แแจแแแก แจแแ แแก. AWS Lambda แแงแแแแแก แแฎแแแแ แแ แแแฅแแแแแแก microVM-แแแแก แแแแแแ แแแแกแแแแก: EC2 แแแกแขแแแชแแแแ แแ Firecracker. แกแขแฃแแ แแแแก แแแแแแชแแ แแแแแแแจแ EC2 แแแแแแแแแแแ แแแคแฃแซแแแแฃแแ 2015 แฌแแแแแ แแ แกแแแแแก. Firecracker แแ แแก แแฎแแแ แฆแแ แแแแแก แฐแแแแ แแแแแ แ, แ แแแแแแช แกแแแชแแแแฃแ แแ แจแแฅแแแแแแ AWS-แแก แแแแ แกแแ แแแ แแก แแแ แแจแ แกแแแฃแจแแ แแแขแแแ แแแแกแแแแก แแ แแแแแแ แแ 2018 แฌแแแก. แคแแแแแฃแ แ แแแแ แแขแฃแ แ, แ แแแแแแช แแฃแจแแแแก microVM-แแแแ, แแแฌแแแแแแ แแแขแแแ แแแแก แจแแ แแก แกแฎแแแแแกแฎแแ แแแแแ แแจแแแแ.
แแแ แแแแก แแ แแ แแชแแกแแก แแแแแแแ แแแแแก แจแแแแฎแแ
แแแฃแฎแแแแแแ แแแแกแ, แ แแ Lambda แแแจแแแแแก แแ แ แฃแแแแแแฃแ แแ แกแฎแแแแแกแฎแแ แคแฃแแฅแชแแแกแแแแก, แแแ แจแแฃแซแแแแ แแ แแ แแ แแแแแ แคแฃแแฅแชแแแก แแแแแแแ แแแแ แแแแแซแแฎแแแ, แ แแช แแแจแแแแก, แ แแ แแแจแแแแแก แแ แ แจแแแซแแแแ แแแแ แซแแแแแก แ แแแแแแแแ แกแแแแแก แแแแแแแแแแแจแ แแแแแแแฃแ แแแแแแ.
แแแแแแฃแ Lambda Runtime-แก แแฅแแก แฉแแกแแฌแแ แ แคแแแแฃแ แ แกแแกแขแแแ, แ แแแแแแช แฎแแแแแกแแฌแแแแแแ /tmp แแแ แแฅแขแแ แแแจแ. แแแก แจแแแแแ แกแแ แฌแแแแแ แจแแฃแซแแแแแแแ แกแฎแแ แแแจแแแแแก แแ แแแแแแแ. แ แแช แจแแแฎแแแ แแ แแชแแกแแก แแแแแแแ แแแแแก แแแแ แแแแแแก, แคแแแแแแ แฉแแฌแแ แแแ /tmp แแ แกแแแแแก แแแจแแแแแก แแแ แแแแก แแแแแ แกแแกแแชแแชแฎแแ แชแแแแแกแแแแก. แแก แกแแจแฃแแแแแแก แแแซแแแแ แแแแ แแแแแก แแ แแแแแ แแแ แแก แจแแแแแแแ, แ แแช แแแแกแแแฃแแ แแแแ แกแแกแแ แแแแแแ แซแแแ แแแฆแแ แแแฃแแ แแแแ แแชแแแแแกแแแแก, แ แแแแ แแชแแ แแแแฅแแแแแแชแแแแแแแแก แแแแแแแแแก แฉแแขแแแ แแแ.
แแแ แแก แแแแแชแแแแ แแแแแชแแแ
Invoke API แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแ แ แแแแแจแ: แแแแแแแแก แ แแแแแ แแ แแแแฎแแแแแก แแแกแฃแฎแแก แ แแแแแ. แแแแแแแแก แ แแแแแจแ, แแแ แ แแแแขแแแ แ แแแจแ แจแแแแแแแ แจแแกแ แฃแแแแแกแแแแก. แแแแฎแแแแ-แแแกแฃแฎแแก แ แแแแแจแ แคแฃแแฅแชแแ แแซแแฎแแแ แแแแแแขแแแฃแ แแ แแแฌแแแแแฃแแ แแแขแแแ แแแแ, แ แแก แจแแแแแแแช แแแกแฃแฎแ แแ แฃแแแแแ. แแ แแแ แจแแแแฎแแแแแจแ, แคแฃแแฅแชแแ แแฃแจแแแแก Lambda แแแ แแแแจแ, แแแแ แแ แกแฎแแแแแกแฎแแ แแแขแแแ แแแแก แแแแแแแแแ.
แแแแฎแแแแ-แแแกแฃแฎแแก แแแ แแแแก แแ แแก, แแแขแแแ แแแ แแแแแแแแแ แแแแฎแแแแแก แแแแฃแจแแแแแแก API-แแแ (API Caller), แ แแแแ แแชแแ AWS API Gateway แแ AWS SDK, แแแขแแแ แแแแก แแแแแแกแแ แจแ แแ แจแแแแแ Lambda Invoke Service-แจแ. แแก แฃแแแแแกแแแแแ แแแแกแแแฆแแ แแแก แจแแกแแคแแ แแก แแแ แแแแก แคแฃแแฅแชแแแก แจแแกแแกแ แฃแแแแแแ แแ แแแแแกแชแแแก แแแขแแแ แแแแก แแฅ แแแ แแก แแแกแแกแ แฃแแแแแแ. แแแขแแแ แแแแก แแแแแแกแแ แ แแฆแแแก TLS-แแ แแแชแฃแ แขแ แแคแแแก แแแขแแ แแแขแแ. แขแ แแคแแแ แแแแแแ แกแแ แแแกแจแ โ แแแขแแแ แแแแก แแแแแแกแแ แแก แจแแแแแ โ แแแแแก แจแแแ VPC-แจแ แแแแแ แแขแฃแ AWS แ แแแแแแจแ.
AWS Lambda แแแ แแก แแแแฃแจแแแแแแก แแแแแแ: แแแแฎแแแแ-แแแกแฃแฎแแก แ แแแแแ
แฆแแแแกแซแแแแแก แแแ แแแ แจแแแซแแแแ แแแแฎแแ แชแแแแแแก แแแฃแงแแแแแแแแ แแ แแแแแแขแแก แ แแแจแ. แแแแแแ แ แจแแแแฎแแแแแจแ, แ แแแ แฎแแ แชแแแแแแแ Amazon SQS-แแก (Amazon Simple Queue Service) แแแแแงแแแแแแ, แ แแแแแแช แแแแแกแชแแแก แแแ แแแก แแแแแแ แแแ แแก แจแแกแ แฃแแแแแก แกแแ แแแกแแ แจแแแ แแแแแ แแก แแ แแชแแกแแก แแแจแแแแแแ. แแแแแชแแแฃแแ แขแ แแคแแแ แแแชแฃแแแ TLS-แแ แแ แแ แแ แแก Amazon SQS-แจแ แจแแแแฎแฃแแ แแแแแชแแแแแแก แแแแแขแแแแแ แแแจแแคแแ แ.
แฆแแแแกแซแแแแแก แแแ แแแ แแ แแแ แฃแแแแก แแแกแฃแฎแแแก - Lambda Worker แฃแแ แแแแ แฃแแฃแแแแแแงแแคแก แแแกแฃแฎแแแแก แแแแแกแแแแ แแแคแแ แแแชแแแก. แแแแแแแแแแ แแแคแฃแซแแแแฃแแ แแแ แแแ Amazon S3-แแแ, Amazon SNS-แแแ, CloudWatch-แแแ แแ แกแฎแแ แฌแงแแ แแแแแแแ แแฃแจแแแแแแ Lambda-แก แแแแ แแแแแแแแก แ แแแแแจแ. แแแ แแแ Amazon Kinesis แแ DynamoDB แแแแแแแแแแแ, SQS แ แแแแแ, Application Load Balancer แแ API Gateway แแแ แแแ แแฃแจแแแแแแ แแแแฎแแแแ-แแแกแฃแฎแแก แ แแแแแจแ.
แแแแแขแแ แแแแ
แจแแแแซแแแแ แแแแแแแก แคแฃแแฅแชแแแแแก แแแแแขแแ แแแแ แแ แแฃแแแขแ แกแฎแแแแแกแฎแแ AWS แแแฅแแแแแแแแแกแ แแ แกแแ แแแกแแแแก แแแแแงแแแแแแ, แแแ แจแแ แแก แจแแแแแแ.
Amazon CloudWatch
แแแ แแแแแก แกแฎแแแแแกแฎแแ แกแขแแขแแกแขแแแแก, แ แแแแ แแชแแ แแแแฎแแแแแแแก แ แแแแแแแแ, แ แแแแแแ แแ แ แแแกแญแแ แแ แแแแฎแแแแแก แจแแกแ แฃแแแแแก แแ แแ แแแแฎแแแแแแแก แ แแแแแแแแแก, แ แแแแแแแช แแแ แแแฎแแ แฎแแ.
Amazon CloudTrail
แกแแจแฃแแแแแแก แแแซแแแแ แจแแฎแแแแแ แกแแกแขแแแแจแ, แแฃแแแแแแ แแแแแขแ แแแแ แแ แจแแแแแฎแแ แแแแแ แแจแแก แแฅแขแแแแแแก แแแคแแ แแแชแแ, แ แแแแแแช แแแแแแจแแ แแแฃแแแ แแฅแแแแก AWS แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแ. แแฅแแแ แแแฅแแแแแ AWS Management Console-แแก, AWS SDK-แแก, แแ แซแแแแแแก แฎแแแแก แฎแแแกแแฌแงแแแแแก แแ แกแฎแแ AWS แกแแ แแแกแแแแก แแแแแงแแแแแแ แจแแกแ แฃแแแแฃแแ แฅแแแแแแแแแก แกแ แฃแแ แแกแขแแ แแ.
AWS แ แแแขแแแแ
แฃแแ แฃแแแแแงแแคแก แกแ แฃแ แฎแแแแแแแแแก แแฅแแแแก แแแแแแแชแแแจแ แแแแฎแแแแแก แแแแฃแจแแแแแแก แงแแแแ แแขแแแแ แแแกแ แจแแแ แแแแแแแแแขแแแแก แ แฃแฅแแก แกแแคแฃแซแแแแแ. แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแแแแ แแแแแแแชแแแแ แแแแแแแแ แแแแก แแ แแก แแ แฌแแ แแแแแแก แแแ แแแแจแ.
AWS แแแแคแแแฃแ แแชแแ
แแฅแแแ แจแแซแแแแ แแแแแงแฃแ แ แแแแแแแ แแแแแแแก แคแฃแแฅแชแแแก แแแแคแแแฃแ แแชแแแก (แแแ แจแแ แแก แฌแแจแแแก) แชแแแแแแแแแก แแ แแแจแแแแแก แแ แแแแก, แขแแแแแก, แแแแแฃแจแแแแแแแก แกแแฎแแแแแก, แแแแแก แแแแแก, แแแฎแกแแแ แแแแก แแแแแฌแแแแแแก, แแ แแแก แแแแฌแฃแ แแแก แแแ แแแแขแ แแแก แแ แแแแแฃแ แแแขแฃแแแแแก แแแ แแแแขแ แแแก, แแกแแแ Lambda IAM-แแก แจแแกแ แฃแแแแแก แ แแแก, แฅแแแฅแกแแแแแก แแ แฃแกแแคแ แแฎแแแแแก แฏแแฃแคแแก แแแแจแแ แแแก. .
แแแกแแแแ
AWS Lambda แแแแแแแแแ แแแกแขแ แฃแแแแขแแแแก แแซแแแแ แแแแแแแฅแขแก แฃแกแแคแ แแฎแ แแ แแแกแจแขแแแแ แแแแแ แแแแแแแชแแแแแก แจแแกแแฅแแแแแแ. AWS Lambda-แจแ แฃแกแแคแ แแฎแแแแแกแ แแ แจแแกแแแแแแกแแแแก แแ แแแแแ แแ แแฅแขแแแ แแแแแแ, แ แแช แกแฎแแ AWS แกแแ แแแกแแแจแ, แแฃแแชแ แแ แแก แแแแแแแแแแกแแแ. 2019 แฌแแแก แแแ แขแแก แแแแแแแ แแแแแ, Lambda แจแแแกแแแแแแแ SOC 1, SOC 2, SOC 3, PCI DSS, แฏแแแแ แแแแแแแก แแแแฆแแแแแก แแแ แขแแแแแฃแ แแแแกแ แแ แแแแแ แแจแแแแแแแฃแแแแแก แแฅแขแแก (HIPAA) แจแแกแแแแแแกแแแแก แแ แกแฎแแ แ แแแฃแแแชแแแแก. แแกแ แ แแ, แ แแแแกแแช แคแแฅแ แแแ แแฅแแแแ แจแแแแแแ แแแแแแแชแแแก แแแแฎแแ แชแแแแแแแแ, แแแแแฎแแแแ AWS Lambda แกแแ แแแกแ - แแก แจแแแซแแแแ แกแแฃแแแแแกแแ แแแแ แแแก แแฅแแแแก แแแแชแแแแก.
แฌแงแแ แ: www.habr.com