ការបង្រៀនអំពីការបង្កើតកម្មវិធីនៅលើ Amazon Web Services (AWS)
Amazon Web Services (AWS) គឺជាវេទិកាកុំព្យូទ័រលើពពកដ៏ពេញនិយមបំផុតមួយរបស់ពិភពលោក។ ជាមួយ AWS អ្នកអាចបង្កើត និងដំណើរការកម្មវិធីដោយមិនចាំបាច់ទិញម៉ាស៊ីនមេរូបវន្ត ការរៀបចំទំហំម៉ាស៊ីនមេ ឬការថែរក្សាហេដ្ឋារចនាសម្ព័ន្ធផ្ទាល់ខ្លួនរបស់អ្នកឡើយ។ អត្ថបទនេះនឹងណែនាំអ្នកអំពីការបង្កើតកម្មវិធីសាមញ្ញមួយនៅលើ AWS ដោយប្រើវិធីសាស្រ្តទូទៅមួយ៖ ការដាក់ពង្រាយ កម្មវិធីគេហទំព័រ ដោយប្រើសេវាកម្មគណនា (EC2) មូលដ្ឋានទិន្នន័យដែលបានគ្រប់គ្រង (RDS) ជាជម្រើសមួយ និងការផ្ទុក និងដែនប្រសិនបើចាំបាច់។ ខណៈពេលដែលឧទាហរណ៍ខាងក្រោមនេះគឺទូទៅ អ្នកអាចអនុវត្តវាចំពោះកម្មវិធីជាច្រើនប្រភេទ។
-
១. ការរៀបចំដំបូង៖ គណនី និងគោលគំនិតជាមូលដ្ឋាន
មុនពេលអ្នកចាប់ផ្តើម ត្រូវប្រាកដថាអ្នកមានគណនី AWS។ សេវាកម្ម AWS ជាច្រើនផ្តល់ជូន Free Tier (ឥតគិតថ្លៃក្នុងដែនកំណត់ជាក់លាក់) ដែលល្អឥតខ្ចោះសម្រាប់ការអនុវត្ត។
គោលគំនិតសំខាន់ៗមួយចំនួនដែលអ្នកត្រូវយល់៖
– តំបន់៖ ទីតាំងមជ្ឈមណ្ឌលទិន្នន័យ AWS (ឧទាហរណ៍៖ Singapore/ap-southeast-1)។ ជ្រើសរើសតំបន់ដែលនៅជិតបំផុតសម្រាប់ភាពយឺតយ៉ាវទាប។
– IAM (ការគ្រប់គ្រងអត្តសញ្ញាណ និងការចូលប្រើ)៖ ប្រព័ន្ធគ្រប់គ្រងការចូលប្រើ។ ការអនុវត្តល្អបំផុត៖ កុំប្រើគណនី root សម្រាប់ការងារប្រចាំថ្ងៃ។
– VPC (Virtual Private Cloud)៖ បណ្តាញនិម្មិតមួយដែលសេវាកម្មរបស់អ្នកដំណើរការ។
– ក្រុមសុវត្ថិភាព៖ “ជញ្ជាំងភ្លើង” ដើម្បីគ្រប់គ្រងការចូល/ចេញចូលពីម៉ាស៊ីនមេ។
តាមរយៈការយល់ដឹងអំពីរឿងទាំងបួននេះ វានឹងកាន់តែងាយស្រួលសម្រាប់អ្នកក្នុងការរុករកមូលដ្ឋានគ្រឹះនៃ AWS។
-
2. បង្កើតអ្នកប្រើប្រាស់ IAM និងគណនីដែលមានសុវត្ថិភាព
សុវត្ថិភាពតែងតែជាអាទិភាពលេខមួយរបស់យើង។ ចូលទៅក្នុង AWS Console ជា root បន្ទាប់មក៖
1. បើកសេវាកម្ម IAM។
២. បង្កើតអ្នកប្រើប្រាស់ថ្មី (ឧ. `admin-dev`) ហើយធីកប្រអប់ Provide user access to the AWS Management Console។
៣. ផ្តល់ការអនុញ្ញាត៖ សម្រាប់ការអនុវត្ត អ្នកអាចប្រើ AdministratorAccess (ទោះបីជានៅក្នុងគម្រោងពិតប្រាកដវាគួរតែមានកម្រិតជាងនេះក៏ដោយ)។
៤. បើកមុខងារ MFA (ការផ្ទៀងផ្ទាត់ពហុកត្តា) ដើម្បីបង្កើនសុវត្ថិភាព។
នៅពេលរួចរាល់ សូមចាកចេញពី root ហើយចូលដោយប្រើអ្នកប្រើប្រាស់ IAM ដែលទើបបង្កើតថ្មី។
-
៣. កំណត់ស្ថាបត្យកម្មកម្មវិធី
សម្រាប់ការបង្រៀននេះ យើងនឹងបង្កើតស្ថាបត្យកម្មសាមញ្ញមួយ៖
– EC2 : ដំណើរការកម្មវិធីគេហទំព័រ (ឧ. Node.js/Express, Python Flask ឬ PHP)។
– RDS ជាជម្រើស៖ គ្រប់គ្រងមូលដ្ឋានទិន្នន័យ MySQL/PostgreSQL ដូច្នេះទិន្នន័យត្រូវបានរក្សាទុកយ៉ាងស្អាត។
– S3 (ស្រេចចិត្ត): រក្សាទុកឯកសារឋិតិវន្តដូចជារូបភាព ឯកសារ ឬការបម្រុងទុក។
– ផ្លូវលេខ ៥៣ (ស្រេចចិត្ត): គ្រប់គ្រងដែន។
– CloudWatch៖ ការត្រួតពិនិត្យជាមូលដ្ឋាន។
ប្រសិនបើអ្នកទើបតែចាប់ផ្តើម សូមផ្តោតលើ EC2 ដើម្បីដំណើរការកម្មវិធីរបស់អ្នកជាមុនសិន។
-
៤. បង្កើតម៉ាស៊ីនបម្រើ EC2
ក) បង្កើតឧទាហរណ៍មួយ
១. ចូលទៅក្នុងសេវាកម្ម EC2។
2. ចុច បើកដំណើរការ Instance ។
៣. ជ្រើសរើសប្រព័ន្ធប្រតិបត្តិការ ឧទាហរណ៍ Ubuntu Server 22.04 LTS។
៤. ជ្រើសរើសប្រភេទ instance៖ សម្រាប់ Free Tier សូមប្រើ `t2.micro` ឬ `t3.micro` (អាស្រ័យលើភាពអាចរកបាន)។
៥. បង្កើត ឬជ្រើសរើសគូសោ (ឧ. `aws-key.pem`)។ រក្សាឯកសារ `.pem` ឲ្យមានសុវត្ថិភាព ព្រោះវានឹងត្រូវបានប្រើសម្រាប់ SSH។
ខ) ការកំណត់រចនាសម្ព័ន្ធបណ្តាញ និងជញ្ជាំងភ្លើង
– ត្រូវប្រាកដថា instance ស្ថិតនៅក្នុង VPC លំនាំដើម (សម្រាប់តែការអនុវត្តប៉ុណ្ណោះ)។
– កំណត់ក្រុមសុវត្ថិភាព៖
– ច្រក 22 (SSH) តែប៉ុណ្ណោះពី IP របស់អ្នក (ឧ. `My IP`)
– ច្រក 80 (HTTP) នៃ `0.0.0.0/0` (សាធារណៈ)
– ច្រក 443 (HTTPS) ពី `0.0.0.0/0` ប្រសិនបើប្រើ SSL នៅពេលក្រោយ
ចំណាំ៖ ការបើក SSH ជាសាធារណៈមានហានិភ័យ។ ត្រូវដាក់កម្រិតអាសយដ្ឋាន IP ជានិច្ច។
ចុច Launch ហើយរង់ចាំឱ្យ instance ដំណើរការ។
-
៥. ចូលទៅកាន់ម៉ាស៊ីនបម្រើតាមរយៈ SSH
នៅលើ Windows អ្នកអាចប្រើ WSL ឬ PuTTY។ នៅលើ macOS/Linux អ្នកអាចធ្វើវាដោយផ្ទាល់ពី terminal។
១. ផ្លាស់ប្តូរលេខកូដអនុញ្ញាត៖
“`បាស
chmod 400 aws-key.pem
“ `
2. SSH ទៅកាន់ម៉ាស៊ីនមេ (ប្រើ Public IPv4 ពី EC2)៖
“`បាស
ssh -i aws-key.pem ubuntu@PUBLIC_IP
“ `
ប្រសិនបើទទួលបានជោគជ័យ អ្នកស្ថិតនៅលើម៉ាស៊ីនមេ AWS Ubuntu។
-
៦. ដំឡើងម៉ាស៊ីនបម្រើបណ្ដាញ និងកម្មវិធី Runtime
នេះជាឧទាហរណ៍សម្រាប់កម្មវិធី Node.js ព្រោះវាត្រូវបានគេប្រើប្រាស់យ៉ាងទូលំទូលាយសម្រាប់គេហទំព័រទំនើប។
ក) ធ្វើបច្ចុប្បន្នភាព និងដំឡើង dependencies
“`បាស
ធ្វើឱ្យទាន់សម័យ sudo apt និង & ធ្វើឱ្យប្រសើរឡើង audo apt -y
sudo apt ដំឡើង -y curl git
“ `
ខ) ដំឡើង Node.js (កំណែ LTS)
“`បាស
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash –
sudo apt install-y nodejs
node - v
npm -v
“ `
-
៧. បង្កើតកម្មវិធីសាមញ្ញមួយ
បង្កើតថតឯកសារគម្រោង៖
“`បាស
mkdir myapp និង cd myapp
npm init -y
npm ដំឡើងរហ័ស
“ `
បង្កើតឯកសារ `index.js`៖
«`js
const express = ត្រូវការ ("express");
const app = express();
app.get(“/”, (តម្រូវការ, res) => {
res.send(“សួស្តី! កម្មវិធីរបស់អ្នកកំពុងដំណើរការលើ AWS EC2។”);
});
app.listen(3000, () => console.log(“ម៉ាស៊ីនបម្រើកំពុងដំណើរការលើច្រក 3000”));
“ `
ដំណើរការកម្មវិធី៖
“`បាស
សន្ទស្សន៍ណូត.js
“ `
សាកល្បងចូលប្រើពីកម្មវិធីរុករកតាមអ៊ីនធឺណិត៖
– `http://PUBLIC_IP:3000`
ទោះយ៉ាងណាក៏ដោយ ច្រក 3000 បច្ចុប្បន្នមិនទាន់បើកនៅក្នុងក្រុមសុវត្ថិភាពនៅឡើយទេ។ អ្នកអាច៖
១) បើកច្រក ៣០០០ នៅក្នុងក្រុមសុវត្ថិភាព ឬ
2) ប្រើប្រូកស៊ីបញ្ច្រាស (ត្រូវបានណែនាំច្រើនជាង) ដើម្បីឱ្យកម្មវិធីនៅតែស្ថិតនៅលើច្រកខាងក្នុង ប៉ុន្តែអាចចូលប្រើបានតាមរយៈច្រក 80/443។
-
៨. ការប្រើប្រាស់ Nginx ជា Reverse Proxy (ចូលប្រើតាមរយៈច្រក 80)
ដំឡើង Nginx៖
“`បាស
sudo apt ដំឡើង -y nginx
sudo systemctl បើក nginx
sudo systemctl start nginx
“ `
កំណត់រចនាសម្ព័ន្ធ Nginx៖
“`បាស
sudo nano /etc/nginx/sites-available/myapp
“ `
ខ្លឹមសារនៃការកំណត់រចនាសម្ព័ន្ធ៖
"`nginx
server {
listen 80;
ឈ្មោះម៉ាស៊ីនបម្រើ _;
ទីតាំង / {
proxy_pass http://127.0.0.1:3000;
ប្រូកស៊ី_http_កំណែ 1.1;
proxy_set_header ធ្វើឱ្យប្រសើរឡើង $http_upgrade;
ការតភ្ជាប់ proxy_set_header 'ធ្វើឱ្យប្រសើរឡើង';
proxy_set_header ម៉ាស៊ីន $host;
ប្រូកស៊ី_ឃ្លាំងសម្ងាត់_ផ្លូវវាង $http_ធ្វើឱ្យប្រសើរឡើង;
}
}
“ `
បើកការកំណត់រចនាសម្ព័ន្ធ៖
“`បាស
sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl ផ្ទុក nginx ឡើងវិញ
“ `
ឥឡូវនេះចូលប្រើ៖
– `http://PUBLIC_IP/`
កម្មវិធីនេះដំណើរការលើច្រក 3000 ប៉ុន្តែសាធារណជនចូលប្រើវាតាមរយៈច្រក 80។
-
៩. ដំណើរការកម្មវិធីជាប់លាប់ជាមួយ PM2
ដើម្បីការពារកម្មវិធីពីការគាំងនៅពេល SSH ត្រូវបានផ្តាច់ សូមប្រើ PM2៖
“`បាស
sudo npm ដំឡើង -g pm2
pm2 ចាប់ផ្តើម index.js –ឈ្មោះ myapp
pm2 រក្សាទុក
ការចាប់ផ្តើម pm2
“ `
ពាក្យបញ្ជា `pm2 startup` នឹងផ្តល់ការណែនាំបន្ថែម។ ដំណើរការពាក្យបញ្ជាដែលបានបង្ហាញ ដើម្បីឱ្យកម្មវិធីដំណើរការដោយស្វ័យប្រវត្តិ នៅពេលដែលម៉ាស៊ីនមេចាប់ផ្តើមឡើងវិញ។
-
១០. (ស្រេចចិត្ត) ការបន្ថែមមូលដ្ឋានទិន្នន័យជាមួយ RDS
ប្រសិនបើកម្មវិធីរបស់អ្នកតម្រូវឱ្យមានមូលដ្ឋានទិន្នន័យ RDS ធ្វើឱ្យវាងាយស្រួល ពីព្រោះ AWS គ្រប់គ្រងការបម្រុងទុក ការបំណះ និងការធ្វើមាត្រដ្ឋាន។
ជំហានខ្លីៗ៖
១. បើកសេវាកម្ម RDS → បង្កើតមូលដ្ឋានទិន្នន័យ។
2. ជ្រើសរើស MySQL ឬ PostgreSQL (ច្បាប់ Free Tier មាននៅលើការកំណត់រចនាសម្ព័ន្ធជាក់លាក់)។
៣. កំណត់ឈ្មោះអ្នកប្រើប្រាស់/ពាក្យសម្ងាត់។
៤. ត្រូវប្រាកដថា RDS instance ស្ថិតនៅក្នុង VPC ដូចគ្នានឹង EC2។
៥. កំណត់ក្រុមសុវត្ថិភាព RDS ឱ្យទទួលយកតែការតភ្ជាប់ពីក្រុមសុវត្ថិភាព EC2 (មិនមែនពីសាធារណជនទេ)។
នៅពេលដែលមូលដ្ឋានទិន្នន័យដំណើរការ សូមចាប់យកចំណុចបញ្ចប់ RDS ហើយភ្ជាប់ទៅវាពីកម្មវិធីរបស់អ្នកដោយប្រើកម្មវិធីបញ្ជាមូលដ្ឋានទិន្នន័យ។
-
១១. (ស្រេចចិត្ត) បើកដំណើរការ HTTPS ជាមួយវិញ្ញាបនបត្រ SSL
សម្រាប់ការផលិត HTTPS គឺចាំបាច់។ វិធីសាស្ត្រធម្មតា៖
– ប្រើប្រាស់ដូមេន (ឧ. ពីផ្លូវលេខ 53 ឬអ្នកចុះបញ្ជីផ្សេងទៀត)។
– ដំឡើង SSL តាមរយៈ Let's Encrypt (Certbot) នៅលើ EC2។
សរុបមក៖
“`បាស
sudo apt ដំឡើង -y certbot python3-certbot-nginx
sudo certbot –nginx
“ `
សូមអនុវត្តតាមអ្នកជំនួយការដើម្បីជ្រើសរើសដែន និងបើកការបញ្ជូនបន្ត HTTPS។
-
១២. ការត្រួតពិនិត្យ និងការចំណាយ
AWS ផ្តល់ជូន CloudWatch ដើម្បីមើលរង្វាស់ដូចជា CPU បណ្តាញ និងកំណត់ហេតុជាក់លាក់។ អ្នកក៏នឹងចង់តាមដានការចំណាយរបស់អ្នកដើម្បីជៀសវាងការខកខានផងដែរ។
គន្លឹះសំខាន់ៗ៖
– បើកសំឡេងរោទិ៍សម្រាប់ការគិតប្រាក់នៅក្នុង CloudWatch (ឧ. សំឡេងរោទិ៍ប្រសិនបើការគិតប្រាក់លើសពី $5)។
- បិទឧបករណ៍នៅពេលមិនប្រើប្រាស់។
– លុបធនធានដែលមិនប្រើ (ឧបករណ៍រក្សាលំនឹងបន្ទុក, EBS, Elastic IP, Snapshots) ព្រោះវាអាចនៅតែត្រូវចំណាយ។
-
Penutup
សូមអបអរសាទរ! អ្នកបានរៀនមូលដ្ឋានគ្រឹះនៃការបង្កើតកម្មវិធីនៅលើ AWS ដោយប្រើ EC2 ការដំណើរការ កម្មវិធីគេហទំព័រ ការដំឡើងប្រូកស៊ីបញ្ច្រាស Nginx និងការធ្វើឱ្យវាដំណើរការជានិច្ចជាមួយ PM2។ អ្នកក៏ទទួលបានទិដ្ឋភាពទូទៅនៃសេវាកម្មបន្ថែមដូចជា RDS សម្រាប់មូលដ្ឋានទិន្នន័យ S3 សម្រាប់ការផ្ទុក និងវិញ្ញាបនបត្រ HTTPS សម្រាប់សុវត្ថិភាពផងដែរ។
ប្រសិនបើអ្នកចង់ឡើងកម្រិត ជំហានបន្ទាប់ជាធម្មតាគឺ៖
– ការដាក់ពង្រាយដោយស្វ័យប្រវត្តិជាមួយ CI/CD (GitHub Actions + SSH ឬ AWS CodeDeploy)
– ការប្រើប្រាស់កុងតឺន័រជាមួយ Docker និងការរៀបចំដូចជា ECS ឬ EKS
– ការប្រើប្រាស់ស្ថាបត្យកម្មគ្មានម៉ាស៊ីនមេជាមួយ Lambda + API Gateway។
ប្រសិនបើអ្នកចង់ សូមបញ្ជាក់ប្រភេទកម្មវិធីដែលអ្នកកំពុងបង្កើត (Node.js, Laravel, Django, React ។ល។) និងគោលបំណងដែលបានគ្រោងទុករបស់វា (ការបង្ហាញ ការផលិត ទ្រង់ទ្រាយធំ)។ ខ្ញុំអាចប្ដូរតាមបំណងនូវការបង្រៀនជាមួយនឹងជំហានជាក់លាក់បន្ថែមទៀត។
