តារាងមាតិកា

ទិដ្ឋភាពទូទៅ ការណែនាំអំពីការដំឡើង ការកំណត់រចនាសម្ព័ន្ធ IAM មុខងារ Lambda ច្រក API ការបង្ករព្រឹត្តិការណ៍ ការដាក់ឱ្យដំណើរការ ការត្រួតពិនិត្យ

ការបញ្ចូលគ្នា

ការណែនាំអំពីការបញ្ចូល AWS Lambda Serverless

បង្កើតប្រព័ន្ធផ្សព្វផ្សាយដែលដំណើរការដោយព្រឹត្តិការណ៍ជាមួយ AWS Lambda។ បង្កើតសញ្ញាដល់បូតផ្សព្វផ្សាយនៅពេលមានសញ្ញាអ្នកលក់ធំ ដំណើរការស្ទ្រីមទិន្នន័យជាពេលវេលាពិត និងធ្វើឱ្យស្វ័យប្រវត្តិនូវលំហូរការងារស្មុគស្មាញដោយមិនចាំបាច់គ្រប់គ្រងហេដ្ឋារចនាសម្ព័ន្ធ។

បានបោះពុម្ពផ្សាយនៅថ្ងៃទី 21 ខែមីនា ឆ្នាំ 2026 • 17 នាទីអាន • កម្រិតខ្ពស់

អត្ថប្រយោជន៍នៃស្ថាបត្យកម្ម Serverless

AWS Lambda អនុញ្ញាតឱ្យអ្នកដំណើរការកូដដោយមិនចាំបាច់គ្រប់គ្រងម៉ាស៊ីនបម្រើ។ ល្អឥតខ្ចោះសម្រាប់ការបញ្ចូលគ្នានៃ Smart Money API ពីព្រោះអ្នកគ្រាន់តែបង់សម្រាប់ពេលវេលាប្រតិបត្តិ។ នៅពេលដែលសញ្ញាអ្នកលក់ធំមកដល់ Lambda នឹងភ្ញាក់ឡើង ដំណើរការវា ប្រហែលជាបង្កើតការផ្សព្វផ្សាយ បន្ទាប់មកត្រឡប់ទៅដេកវិញ។

អត្ថប្រយោជន៍សំខាន់ៗ

មិនចាំបាច់គ្រប់គ្រងម៉ាស៊ីនបម្រើ — AWS ដោះស្រាយការធ្វើមាត្រដ្ឋាន និងហេដ្ឋារចនាសម្ព័ន្ធ
ប្រសិទ្ធភាពថ្លៃដើម — បង់សម្រាប់រាល់ 100ms នៃការប្រតិបត្តិ $0.20 សម្រាប់ការហៅ 1 លានដង
ការធ្វើមាត្រដ្ឋានស្វ័យប្រវត្តិ — ដោះស្រាយស្វ័យប្រវត្តិនូវការកើនឡើងនៃចរាចរណ៍
ពេលវេលាពន្យារទាប — បង្កើតសញ្ញាក្នុងរយៈពេលមិល្លីវិនាទីបន្ទាប់ពីសញ្ញាមកដល់
ការបញ្ចូលគ្នាជាមួយសេវាកម្ម AWS — ភ្ជាប់ទៅ DynamoDB, SNS, SQS, S3, CloudWatch
ការកត់ត្រាដែលមានជាមុន — ការបញ្ចូលគ្នាជាមួយ CloudWatch សម្រាប់ការបំបាត់កំហុស និងការត្រួតពិនិត្យ

ការដំឡើងស្ថាប័ន៖ មូលនិធិគ្រីបតូដំណើរការមុខងារ Lambda 3៖ Signal Processor (ផ្ទៀងផ្ទាត់ និងច្រោះសញ្ញា) Trade Executor (ដាក់ការបញ្ជាទិញ) និង Risk Monitor (ពិនិត្យដែនកំណត់តំណែង)។ ទាំងអស់ដែលបង្កើតដោយអន្តរកម្មវ៉ែបហុករបស់ Smart Money API។ ថ្លៃសរុប៖ $12/ខែសម្រាប់ការហៅ 10 លានដង។

ករណីប្រើប្រាស់ធម្មតា

ដំណើរការសញ្ញាអ្នកលក់ធំ និងផ្ញើទៅបូតផ្សព្វផ្សាយ
ផ្ទៀងផ្ទាត់សញ្ញាទាក់ទងនឹងដែនកំណត់ហានិភ័យមុនពេលប្រតិបត្តិ
កត់ត្រាសញ្ញាទាំងអស់ទៅ DynamoDB សម្រាប់ការវិភាគប្រវត្តិសាស្ត្រ
ផ្ញើការជូនដំណឹងទៅក្រុមតាមរយៈ SNS ឬ Slack
វិភាគលំនាំសញ្ញា និងធ្វើបច្ចុប្បន្នភាពប៉ារ៉ាម៉ែត្រយុទ្ធសាស្ត្រ

ការដំឡើង AWS ដំបូង

ជំហានទី 1៖ បង្កើតគណនី AWS

បង្កើតគណនី AWS នៅ aws.amazon.com។ កម្រិតឥតគិតថ្លៃរួមមានការហៅ Lambda 1 លានដងក្នុងមួយខែ ល្អសម្រាប់ការធ្វើតេស្ត។

ជំហានទី 2៖ ចូលប្រើកុងសូល Lambda

ចូលទៅកាន់ AWS Console ទៅកាន់សេវាកម្ម Lambda។ ចុច "Create function"។

ជំហានទី 3៖ ជ្រើសរើសពេលវេលាដំណើរការ

ជ្រើសរើស Python 3.11 (ផ្តល់អនុសាសន៍សម្រាប់ការផ្សព្វផ្សាយគ្រីបតូ)។ Node.js 18 ក៏ដំណើរការបានដែរ។ ជៀសវាងពេលវេលាដំណើរការចាស់ពីព្រោះពួកវាអាចមានគ្រោះថ្នាក់សុវត្ថិភាព។

ជំហានទី 4៖ កំណត់រចនាសម្ព័ន្ធតួនាទីប្រតិបត្តិ

Lambda ត្រូវការតួនាទី IAM ដែលមានសិទ្ធិសមស្រប។ សូមមើលផ្នែកការកំណត់រចនាសម្ព័ន្ធ IAM ខាងក្រោម។

ទទួលបានសោ API របស់អ្នកក្នុងរយៈពេល 30 វិនាទី

ភ្ជាប់ការបញ្ចូលគ្នានេះទៅនឹងទិន្នន័យផ្ទាល់ក្នុងរយៈពេលប៉ុន្មាននាទី។ សោ API ឥតគិតថ្លៃ 100 ការហៅ/ថ្ងៃ មិនចាំបាច់ប្រើកាត។

ទទួលបានសោ API របស់អ្នក →

តួនាទី និងសិទ្ធិ IAM

គោលនយោបាយសិទ្ធិអប្បបរមា

បង្កើតគោលនយោបាយ IAM ដែលមានតែសិទ្ធិចាំបាច់ប៉ុណ្ណោះ (គោលការណ៍នៃសិទ្ធិអប្បបរមា)៖

គោលនយោបាយ IAM Lambda
{
 "Version": "2012-10-17",
 "Statement": [
    {
 "Effect": "Allow",
 "Action": [
 "logs:CreateLogGroup",
 "logs:CreateLogStream",
 "logs:PutLogEvents"
      ],
 "Resource": "arn:aws:logs:*:*:*"
    },
    {
 "Effect": "Allow",
 "Action": ["dynamodb:PutItem"],
 "Resource": "arn:aws:dynamodb:us-east-1:*:table/whale-signals"
    }
  ]
}

ការអនុវត្តល្អបំផុត

ប្រើតួនាទីដាច់ដោយឡែក — មុខងារ Lambda ផ្សេងគ្នាគួរមានតួនាទីផ្សេងគ្នា
សិទ្ធិអប្បបរមា — ផ្តល់តែសិទ្ធិដែលចាំបាច់ប៉ុណ្ណោះ
ជៀសវាង * wildcards — បញ្ជាក់ធនធានពិតប្រាកដជំនួស
បង្វិលពាក្យសម្ងាត់ — ផ្ទុកសោ API នៅក្នុង AWS Secrets Manager មិនមែននៅក្នុងកូដទេ

ការសរសេរមុខងារ Lambda

មុខងារទី 1៖ Signal Processor

ទទួលវ៉ែបហុកពី Smart Money API ផ្ទៀងផ្ទាត់សញ្ញា កត់ត្រាទៅ DynamoDB៖

lambda_handler.py
import json, boto3, os
from datetime import datetime
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('whale-signals')
def lambda_handler(event, context):
 try:
        body = json.loads(event['body'])
        signal = body['signal_type']
        confidence = float(body['confidence'])
 # Only process high-confidence signals
 if confidence < 0.70:
 return {'statusCode': 200, 'body': 'Ignored'}
 # Log to DynamoDB
        table.put_item(Item={
 'timestamp': datetime.now().isoformat(),
 'signal': signal,
 'confidence': confidence
        })
 return {'statusCode': 200, 'body': បានដំណើរការ}
 លើកលែងតែ ករណីលើកលែង ជា e:
        បោះពុម្ព(f'កំហុស៖ {e}')
 ត្រឡប់ {'statusCode': 500, 'body': 'កំហុស'}

មុខងារទី 2៖ អ្នកអនុវត្តពាណិជ្ជកម្ម

ទទួលសញ្ញាដែលបានផ្ទៀងផ្ទាត់ ពិនិត្យដែនកំណត់ហានិភ័យ ដាក់ពាណិជ្ជកម្មជាមួយ API ប្តូរប្រាក់៖

ផ្ទៀងផ្ទាត់ទំហំតំណែងទាក់ទងនឹងសមតុល្យគណនី
ពិនិត្យកម្រិតខាតបង់ និងយកប្រាក់ចំណេញ
ហៅ API ប្តូរប្រាក់ដើម្បីដាក់ការបញ្ជាទិញដែនកំណត់
កត់ត្រាការអនុវត្តទៅការតាមដានសាកល្បង
ផ្ញើការបញ្ជាក់ទៅ Slack

មុខងារទី 3៖ មន្ទីរត្រួតពិនិត្យហានិភ័យ

ដំណើរការជាប្រចាំ (រៀងរាល់ 5 នាទី) ដើម្បីពិនិត្យហានិភ័យផែនការ៖

សួរសំណួរទៅតំណែងបើកទាំងអស់
គណនាដែលតា និងហ្គាម៉ារបស់ផែនការ
ប្រសិនបើហានិភ័យ > កម្រិតកំណត់ កាត់បន្ថយតំណែង
ជូនដំណឹងដល់ក្រុមប្រសិនបើដែនកំណត់ហានិភ័យត្រូវបានរំលោភ

ការកំណត់ API Gateway

ការបង្កើតចំណុចបញ្ចប់ HTTP

API Gateway បង្ហាញ Lambda ជាចំណុចបញ្ចប់ HTTP ដែល Smart Money API អាចធ្វើ webhook ទៅ៖

បង្កើត REST API ថ្មីនៅក្នុង API Gateway
បង្កើតវិធីសារ POST ដែលចង់បញ្ជាក់ទៅមុខងារ Lambda
កំណត់រចនាសម្ព័ន្ធប្រភេទសមាហរណកម្ម = មុខងារ Lambda
ដាក់ឱ្យដំណើរការទៅដំណាក់កាល (ឧទាហរណ៍ "production")
ចម្លង URL៖ https://xyz.execute-api.us-east-1.amazonaws.com/production

ការផ្ទៀងផ្ទាត់សោ API

ការពារចំណុចបញ្ចប់ជាមួយសោ API ដើម្បីឱ្យមានតែ Smart Money API អាចហៅវា៖

សុវត្ថិភាព API Gateway
បង្កើតសោ API នៅក្នុងកុងសូល API Gateway
បង្កើតផែនការប្រើប្រាស់ ភ្ជាប់សោ API
បើកការតម្រូវឱ្យមានសោ API លើវិធីសារ
Smart Money API រួមបញ្ចូលសោនៅក្នុងក្បាល៖ x-api-key

ការកំណត់រចនាសម្ព័ន្ធ CORS

ប្រសិនបើហៅពីកម្មវិធីរុករក បើក CORS៖

Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: Content-Type
Access-Control-Allow-Methods: POST

ស្ថាបត្យកម្មដែលដំណើរការដោយព្រឹត្តិការណ៍

Smart Money Webhook → API Gateway → Lambda

ការហៅដំណើរការដំណាលគ្នា។ សញ្ញាមកដល់ Lambda ដំណើរការភ្លាមៗ ត្រឡប់ការឆ្លើយតបទៅ Smart Money API។

ការដំណើរការតាមកាលវិភាគ (EventBridge)

ដំណើរការ Lambda តាមកាលវិភាគ (ឧទាហរណ៍ មន្ទីរត្រួតពិនិត្យហានិភ័យរៀងរាល់ 5 នាទី)៖

ក្បួន EventBridge
កាលវិភាគ៖ rate(5 នាទី)
គោលដៅ៖ មុខងារ Lambda risk-monitor

ការរួមបញ្ចូលជួរដេក SQS

សម្រាប់សញ្ញាបរិមាណខ្ពស់ ប្រើជួរដេក SQS ជាប៉ុស្តិ៍៖

Smart Money API → ប្រធានបទ SNS → ជួរដេក SQS
Lambda ពិនិត្យជួរដេករៀងរាល់ 10 វិនាទី
ដំណើរការសញ្ញាតាមល្បឿនរបស់អ្នក
ការពារកុំឱ្យ Lambda មានការលំបាក

ការដាក់ឱ្យដំណើរការ និងការគ្រប់គ្រង

ការប្រើ SAM (គំរូកម្មវិធីឥតម៉ាស៊ីន)

ដាក់ឱ្យដំណើរការហេដ្ឋារចនាសម្ព័ន្ធជាកូដដោយប្រើ AWS SAM៖

sam-template.yaml
AWSTemplateFormatVersion៖ '2010-09-09'
បំលែង៖ AWS::Serverless-2016-10-31
ធនធាន៖
  ProcessSignalFunction៖
    ប្រភេទ៖ AWS::Serverless::Function
    លក្ខណៈសម្បត្តិ៖
      អ្នកគ្រប់គ្រង៖ index.lambda_handler
      ពេលដំណើរការ៖ python3.11
      ពេលវេលាអស់៖ 10
      ព្រឹត្តិការណ៍៖
        ApiEvent៖
          ប្រភេទ៖ Api
          លក្ខណៈសម្បត្តិ៖
            ផ្លូវ៖ /webhook
            វិធីសារ៖ POST

ការគ្រប់គ្រងកំណែ និង CI/CD

ប្រើ GitHub + AWS CodePipeline សម្រាប់ការដាក់ឱ្យដំណើរការដោយស្វ័យប្រវត្តិ៖

រុញកូដទៅឃ្លាំង GitHub
CodePipeline រកឃើញការបញ្ចូល
CodeBuild ដំណើរការការធ្វើតេស្ត និងកញ្ចប់
CodeDeploy ដាក់ឱ្យដំណើរការទៅ Lambda
ការត្រឡប់ក្រោយដោយស្វ័យប្រវត្តិប្រសិនបើបរាជ័យ

អថេរបរិស្ថាន

ផ្ទុកអាថ៌កំបាំងនៅក្នុង AWS Secrets Manager មិនមែននៅក្នុងកូដ៖

SMART_MONEY_API_KEY — ទាញយកពី Secrets Manager នៅក្នុង Lambda
EXCHANGE_API_KEY — ផ្ទុកដោយសុវត្ថិភាព
DYNAMODB_TABLE — យោងពីប៉ារ៉ាម៉ែត្រ CloudFormation

ការត្រួតពិនិត្យ និងការកែកំហុស

កំណត់ហេតុ CloudWatch

Lambda កត់ត្រាដោយស្វ័យប្រវត្តិទៅ CloudWatch។ ពិនិត្យកំណត់ហេតុសម្រាប់កំហុស៖

ចុចមុខងារនៅក្នុងកុងសូល Lambda
ទៅផ្ទាំងត្រួតពិនិត្យ → មើលកំណត់ហេតុនៅក្នុង CloudWatch
ស្វែងរកកំហុស ឬករណីលើកលែង

រង្វាស់ផ្ទាល់ខ្លួន

រុញរង្វាស់ផ្ទាល់ខ្លួនទៅ CloudWatch ដើម្បីត្រួតពិនិត្យ៖

រង្វាស់ផ្ទាល់ខ្លួន
cloudwatch = boto3.client('cloudwatch')
cloudwatch.put_metric_data(
  Namespace='SmartMoney',
  MetricData=[{
 'MetricName': 'SignalsProcessed',
 'Value': 1
  }]
)

ការជូនដំណឹង CloudWatch

ជូនដំណឹងនៅពេលមុខងារ Lambda បរាជ័យ ឬយឺត៖

អត្រាកំហុស > 1%
រយៈពេល > 5 វិនាទី
ការកាត់បន្ថយល្បឿនកើតឡើង
កំហុសពេលវេលាអស់

ការតាមដាន X-Ray

បើក X-Ray សម្រាប់ការតាមដានចែកចាយទូទាំងសេវាកម្ម៖

មើលពេលវេលាដែលត្រូវការសម្រាប់ប្រតិបត្តិការនីមួយៗ
កំណត់ចំណុចចង្អៀត
កែសម្រួលបញ្ហារួមបញ្ចូល

ការយល់ដឹងប្រតិបត្តិការ៖ កំហុស Lambda ដែលថ្លៃជាងគេមិនមែនជាថ្លៃដើមគណនាទេ - វាជាបញ្ហាដែលបណ្តាលឱ្យមានការធ្វើដូចខុស។ វិនិយោគយ៉ាងខ្លាំងលើការតាមដាន ការកត់ត្រា និងការធ្វើតេស្ត។ ការចំណាយ ៥០ដុល្លារ/ខែលើ CloudWatch ប្រសើរជាងការចំណាយ ៥,០០០ដុល្លារលើកំហុសធ្វើដូច។

សាងសង់ហេដ្ឋារចនាសម្ព័ន្ធធ្វើដូចដោយគ្មានម៉ាស៊ីនបម្រើ

ដំណើរការប្រព័ន្ធធ្វើដូចដែលបណ្តាលដោយព្រឹត្តិការណ៍នៅលើ AWS Lambda។ ដំណើរការសញ្ញា whale អនុវត្តការធ្វើដូច និងតាមដានហានិភ័យដោយមិនចាំបាច់គ្រប់គ្រងម៉ាស៊ីនបម្រើ។

មើលគម្រោងតម្លៃ

គម្រោង Pro ត្រូវបានណែនាំសម្រាប់ការផ្ញើ webhook។ ថ្លៃដើម Lambda៖ ~១-៥ដុល្លារ/ខែសម្រាប់បរិមាណធ្វើដូចធម្មតា។