នៅពេលដែលវិញ្ញាបនបត្រ SSL ត្រូវបានចេញ វាចាំបាច់ត្រូវដាក់ឱ្យប្រើប្រាស់នៅលើ Server បណ្តាញ ដើម្បីបើកការភ្ជាប់ HTTPS ។ បន្ទាប់ពីការចេញ អាជ្ញាធរវិញ្ញាបនបត្រ (ដូចជា Comodo/Sectigo) នឹងផ្ញើអ៊ីមែលឯកសារវិញ្ញាបនបត្រ។ លើសពីនេះ ឯកសារទាំងនេះនឹងអាចទាញយកបានពីគណនី 1Byte របស់អ្នក ដូចដែលបានពណ៌នា នៅទីនេះ.
អត្ថបទនេះនឹងគ្របដណ្តប់លើការអនុវត្តវិញ្ញាបនបត្រសម្រាប់ Node.js និង Express. អ្នកអាចលោតទៅផ្នែកដែលសមស្របពីតារាងមាតិកាខាងក្រោម។
បច្ចុប្បន្ន កំណែ LTS របស់ Node.js គឺ 10.15.0 ហើយកំណែចុងក្រោយបំផុតរបស់ Express គឺ 4.16.4 ។ កំណែទាំងនេះនឹងត្រូវបានប្រើ និងយោងទៅទូទាំងការណែនាំនេះ។
ចំណាំ (Note)៖ ការណែនាំនេះក៏សន្មត់ថាការយល់ដឹងជាមូលដ្ឋាននៃ JavaScript ចាប់តាំងពី Node.js គឺជាបរិយាកាសដំណើរការ JavaScript ក៏ដូចជាគោលគំនិត Node.js និង/ឬ Express ។
តម្រូវការទុកជាមុន
ការដំឡើងវិញ្ញាបនបត្រ SSL ទាមទារឯកសារវិញ្ញាបនបត្រដែលផ្តល់ដោយអាជ្ញាធរវិញ្ញាបនបត្រ ក៏ដូចជា Private Key ដែលត្រូវគ្នាសម្រាប់វិញ្ញាបនបត្រ SSL ។
ឯកសារទាំងនេះគួរតែត្រូវបានផ្ទុកឡើងទៅកាន់ Server របស់អ្នក (ឬគ្រប់ទីកន្លែងដែលកម្មវិធី Node.js មានទីតាំង) មុនពេលបន្តទៅជំហានបន្ទាប់៖
- Certificate (ធម្មតាជា .crt file).
- CA bundle/chain (ធម្មតាជា .ca-bundle file).
- Private key (ធម្មតាជា .key file).
Private Key ត្រូវបានបង្កើតមុនពេលដំណើរការវិញ្ញាបនបត្រ ជាធម្មតានៅពេលតែមួយជាមួយនឹងសំណើចុះហត្ថលេខាលើវិញ្ញាបនបត្រ (CSR)។ ទោះបីជាអ្នកមាន Private Key ក៏ដោយ វាមានតម្លៃពិនិត្យមើលថាវាត្រឹមត្រូវដោយផ្គូផ្គងវាជាមួយវិញ្ញាបនបត្រ SSL របស់អ្នកនៅក្នុង ឧបករណ៍នេះ.
សូមចំណាំ៖ ខណៈដែលឯកសារអាចត្រូវបានដាក់ទៅក្នុងថតណាមួយ សូមប្រាកដថាថតដែលកាន់ Private Key មិនជាសាធារណៈ។ សោឯកជនមានន័យថាត្រូវបានរក្សាទុកដោយសុវត្ថិភាពនៅលើ Server ដោយគ្មានការចូលប្រើជាសាធារណៈណាមួយឡើយ។
ក្នុងករណីដែល Private Key ត្រូវបានបាត់បង់ ឬមិនមានវិធីដើម្បីទាញយកវាមកវិញ អ្នកតែងតែអាចចេញវិញ្ញាបនបត្ររបស់អ្នកឡើងវិញដោយប្រើថ្មីនូវគូ CSR និង key ។
វាក្យស័ព្ទ៖ នៅពេលទាញយកឯកសារវិញ្ញាបនបត្រពីគណនី 1Byte អ្នកក៏នឹងទទួលបានឯកសារ .p7b (PKCS#7) ផងដែរ។ ឯកសារនេះមិនមែនជា Private Key ទេ ហើយនឹងមិនត្រូវការសម្រាប់ការដំឡើងទេ។
FURTHER READING: |
| 1. ការដំឡើងវិញ្ញាបនបត្រ SSL នៅលើ Webmin |
| 2. ការដំឡើង វិញ្ញាបនប័ត្រ SSL នៅលើ ប្រព័ន្ធប្រតិបត្តិការ Sun Java ក្នុង Web Server 7.x |
| 3. ការដំឡើងវិញ្ញាបនបត្រ SSL នៅក្នុង Vesta CP |
នាំចូលឯកសារវិញ្ញាបនបត្រទៅក្នុងកម្មវិធីរបស់អ្នក
សមត្ថភាព Node.js SSL/TLS គឺផ្អែកលើ OpenSSL Library ដូច្នេះវាមានភាពបត់បែនតាមរបៀបដែលវាទទួលយកឯកសារវិញ្ញាបនបត្រ SSL ។ ឯកសារអាចត្រូវបានអានជា Buffer បណ្ដោះអាសន្ន ឬជាអត្ថបទ (បញ្ជាក់ការអ៊ិនកូដ UTF-8) ដោយប្រើ FS (ប្រព័ន្ធឯកសារ) ឬអាចត្រូវបានផ្តល់ជូនយ៉ាងសាមញ្ញជាខ្សែអក្សរដែលមានលេខកូដវិញ្ញាបនបត្រក្នុងទម្រង់ PEM ។
ក្នុងករណីភាគច្រើន វិធីត្រង់បំផុតគឺពេញចិត្ត នោះគឺការអានឯកសារវិញ្ញាបនបត្រ SSL ពីប្រព័ន្ធឯកសារដូចបានបង្ហាញខាងក្រោម៖
| const fs = require('fs');const cert = fs.readFileSync('./path/to/the/cert.crt'); const ca = fs.readFileSync('./path/to/the/ca.crt'); const key = fs.readFileSync('./path/to/the/private.key'); |
ផ្លូវទៅកាន់ឯកសារទាំងនេះអាចទាក់ទង ឬដាច់ខាត។ មានភាពសេរីក្នុងការប្រើប្រាស់ Path ម៉ូឌុលដើម្បីបង្កើតផ្លូវជំនួសឱ្យការប្រើខ្សែអក្សរសាមញ្ញ។
ខាងក្រោមនេះជាឧទាហរណ៍នៃការដំឡើងពេលឯកសារកំពុងត្រូវបានផ្ទុក៖
ក្នុងឧទាហរណ៍នេះ SSL ថតត្រូវបានបង្កើតជាពិសេសសម្រាប់ឯកសារដែលទាក់ទងនឹង SSL ហើយឯកសារត្រូវបានអានពីវា។ វិញ្ញាបនបត្រ CA និងលេខថេរមានតំណាងរៀងៗខ្លួននៃវិញ្ញាបនបត្រ SSL កញ្ចប់ CA និងឯកសារ Private Key។
វាក្យស័ព្ទ៖ វិញ្ញាបនបត្រជាច្រើននៅក្នុងឯកសារតែមួយ (ដែលជាធម្មតាត្រូវការសម្រាប់ឯកសារកញ្ចប់ CA) ត្រូវបានគាំទ្រពី Node.js កំណែ 5.2.0 ។ ប្រសិនបើអ្នកកំពុងប្រើកំណែមុនរបស់ Node.js អ្នកនឹងត្រូវផ្តល់បណ្តុំនៃវិញ្ញាបនបត្រ CA ដូចបានបង្ហាញខាងក្រោម។
កំណែរបស់ Node.js ដែលអ្នកបានដំឡើងអាចត្រូវបានពិនិត្យដោយដំណើរការ node - v.
ប្រសិនបើអ្នកកំពុងប្រើ Node.js 5.2.0 ឬខ្ពស់ជាងនេះ អ្នកអាចរំលងផ្នែកនេះ ហើយលោតត្រង់ទៅចំណងជើង HTTPS នៅលើ Node.js or HTTPS នៅលើ Express នៅក្នុងអត្ថបទនេះ។
ក្នុងករណីដែលអ្នកកំពុងប្រើកំណែ Node.js មុន 5.2.0 អ្នកអាចធ្វើតាមការណែនាំខាងក្រោមដើម្បីបំបែកកញ្ចប់ CA ទៅជាវិញ្ញាបនបត្រ SSL ដាច់ដោយឡែក។
អ្នកអាចបំបែកឯកសារ .ca-bundle ដោយដៃទៅជាឯកសារវិញ្ញាបនបត្រដាច់ដោយឡែក ដោយប្រើកម្មវិធីនិពន្ធអត្ថបទណាមួយ ហើយផ្ទុកពួកវាទៅក្នុង Array មួយ។ ឬអ្នកអាចបំបែកឯកសារ .ca-bundle នៅក្នុងកម្មវិធីរបស់អ្នក។ ឧទាហរណ៍នៃទាំងពីរត្រូវបានផ្តល់ជូនខាងក្រោម:
ការប្រើប្រាស់ឯកសារវិញ្ញាបនបត្រ CA ច្រើន៖
| const ca = [ fs.readFileSync('./ssl/CAcert1.crt'), fs.readFileSync('./ssl/CAcert2.crt') ]; |
ប្រសិនបើអ្នកបំបែកឯកសារដោយដៃ ត្រូវប្រាកដថាផ្តល់ឱ្យពួកគេតាមលំដាប់ដូចគ្នាដែលពួកគេស្ថិតនៅក្នុងឯកសារ .ca-bundle ។
ការបំបែកឯកសារនៅក្នុងកម្មវិធី៖
| const caBundle = fs.readFileSync('./ssl/example.ca-bundle', { encoding:'utf8′}); const ca = caBundle.split('—–END CERTIFICATE—–\r\n').map(cert => cert +'—–END CERTIFICATE—–\r\n'); // យើងត្រូវដកចេញធាតុបន្ថែមមួយ ដែលមានវត្តមានដោយសារ // បន្ទាត់បន្ថែមនៅចុងបញ្ចប់នៃឯកសារ។ // នេះអាចឬមិនចាំបាច់អាស្រ័យលើការធ្វើទ្រង់ទ្រាយ // នៃឯកសារ .ca-bundle របស់អ្នក។ ca.pop(); console.log(ca); |
លទ្ធផលនៃការដំណើរការកូដខាងលើគួរតែជា Array នៃវិញ្ញាបនបត្រដូចបានបង្ហាញខាងក្រោម៖
HTTPS នៅលើ Node.js
ការបង្កើត HTTPS server
HTTPS Server ត្រូវបានបង្កើតដោយប្រើ https.createServer() method ដែលយកវត្ថុជម្រើសជាអាគុយម៉ង់ទីមួយរបស់វា ហើយសំណើអ្នកស្តាប់ការហៅត្រឡប់មកវិញជាលើកទីពីរ។ វត្ថុជម្រើសគួរតែមានលក្ខណៈសម្បត្តិដូចខាងក្រោមៈ
- cert – វិញ្ញាបនបត្រ
- ca – the CA bundle (chain) ផ្តល់ជូនក្នុងឯកសារមួយ ឬជា Array
- កូនសោ - កូនសោឯកជន
ជម្រើសបន្ថែមអាចត្រូវបានបន្ថែមទៅ Object ប្រសិនបើចាំបាច់។
សូមចំណាំ៖ ប្រសិនបើអ្នកមានវិញ្ញាបនបត្រក្នុងទម្រង់ .pfx (PKCS#12) អ្នកអាចប្រើវាដោយផ្តល់នូវវត្ថុជម្រើសជាមួយនឹងលក្ខណៈសម្បត្តិ pfx ដែលមានឯកសារ pfx និងលក្ខណសម្បត្តិឃ្លាសម្ងាត់ប្រសិនបើចាំបាច់។
ដូចរាល់ដង អ្នកអាចបង្កើតវត្ថុមុនពេលហៅវិធីសាស្ត្រ ឬអ្នកអាចឆ្លងកាត់វត្ថុអនាមិកជាមួយនឹងលក្ខណៈសម្បត្តិដែលត្រូវការ ដែលបង្ហាញខាងក្រោម៖
| អនុញ្ញាតឱ្យជម្រើស = { cert: cert, // fs.readFileSync('./ssl/example.crt'); ca: ca, // fs.readFileSync('./ssl/example.ca-bundle'); គន្លឹះ៖ គន្លឹះ // fs.readFileSync('./ssl/example.key'); }; // មិនអីទេ៖ https.createServer({cert, ca, key}, (req, res) => { … const httpsServer = https.createServer(ជម្រើស, (req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/html'); res.end(" ម៉ាស៊ីនមេ HTTPS កំពុងដំណើរការ ”); }); |
នៅទីបញ្ចប់ boilerplate server code គួរតែមើលទៅដូចនេះ៖
នៅទីនេះយើងនាំចូលឯកសារវិញ្ញាបនបត្រចូលទៅក្នុងវត្ថុមួយនៅលើបន្ទាត់ 7-11 បន្ទាប់មកបញ្ជូនវត្ថុនេះទៅវិធីបង្កើត Server នៅលើបន្ទាត់ទី 13 ដែលបង្កើត HTTPS server ហើយចុងក្រោយគេហៅថា ស្តាប់() method នៅលើបន្ទាត់ 19 ដើម្បីចាប់ផ្តើម Server។
ត្រូវប្រាកដថាចាប់ផ្តើមកម្មវិធី Node.js របស់អ្នកឡើងវិញ ប្រសិនបើវាដំណើរការរួចហើយ ដើម្បីអនុវត្តការផ្លាស់ប្តូរ។ ដើម្បីចាប់ផ្តើមកម្មវិធី អ្នកគ្រាន់តែអាចដំណើរការ ថ្នាំង .js នៅក្នុងថតជាមួយកម្មវិធីរបស់អ្នក កន្លែងណា .js គឺជាឯកសារចាប់ផ្តើមកម្មវិធីរបស់អ្នក។
នេះបញ្ចប់ការដំឡើង! អ្នកអាចប្រើឧបករណ៍ខាងក្រោមដើម្បីពិនិត្យមើលការដំឡើងវិញ្ញាបនបត្រ SSL ដោយបញ្ចូលឈ្មោះម៉ាស៊ីនដែលត្រូវគ្នា និងច្រកដែលអ្នកកំពុងប្រើ៖ https://decoder.link
បញ្ជូនបន្តទៅ HTTPS
ដើម្បីប្តូរទិសសំណើ HTTP ទៅ HTTPS អ្នកក៏នឹងត្រូវដំឡើង HTTP server ជាមួយ របស់ HTTP ម៉ូឌុល។
សរុបមក ការបញ្ជូនបន្តសំណើ HTTP ទៅ URL មួយផ្សេងទៀត ទាមទាររឿងពីរ៖ លេខកូដឆ្លើយតបដែលត្រូវគ្នា (301 ឬ 302) និងចំណងជើង HTTP "ទីតាំង" ជាមួយ URL ដែលគួរប្រើជំនួសវិញ។
ខាងក្រោមអ្នកអាចរកឃើញឧទាហរណ៍អំពីរបៀបដែល HTTP server បែបនេះអាចត្រូវបានតំឡើង៖
| const http = ទាមទារ('http'); const hostname = 'ឧទាហរណ៍domain.com'; const httpServer = http.createServer((req, res) => { res.statusCode = 301; res.setHeader('ទីតាំង', `https://${hostname}${req.url}`); res.end(); // ត្រូវប្រាកដថាហៅ send() ឬ end() ដើម្បីផ្ញើការឆ្លើយតប }); httpServer.listen(80); |
ក្នុងឧទាហរណ៍ខាងលើ យើងក៏ឆ្លងកាត់ URL ដែលបានស្នើសុំពី req.url ផងដែរ។
ប្រសិនបើអ្នកកំពុងបម្រើមាតិកាទាំងអស់តាមរយៈ HTTP ពីមុន ហើយចង់ប្តូរទៅ HTTPS ហើយរៀបចំការបញ្ជូនបន្ត មធ្យោបាយងាយស្រួលបំផុតគួរតែគ្រាន់តែផ្លាស់ប្តូរ HTTP server របស់អ្នកទៅ HTTP server ហើយ បង្កើត HTTP server បន្ថែម ដែលនឹងបញ្ជូនសំណើ។
ខាងក្រោមអ្នកអាចឃើញសំណើដែលបានធ្វើឡើងចំពោះ HTTP server បែបនេះជាមួយនឹង URL ផ្ទាល់ខ្លួន៖
ហើយបន្ទាប់មកបានឆ្លងកាត់យ៉ាងត្រឹមត្រូវទៅ HTTPS server:
HTTPS នៅលើ Express
ការដំឡើងកម្មវិធី HTTPS ជាមួយ Express
ការប្រើប្រាស់ HTTPS ជាមួយ Express តម្រូវឱ្យបង្កើតម៉ាស៊ីនមេ HTTPS ជាមួយ HTTPS ម៉ូឌុលពី Node.js ។ កម្មវិធី Express របស់អ្នកគួរតែត្រូវបានបញ្ជូនទៅជាប៉ារ៉ាម៉ែត្រ https.createServer() method:
| const https = require('https'); const express = require('express'); // const httpsOptions = {cert, ca, key}; const app = express(); const httpsServer = https.createServer(httpsOptions, កម្មវិធី); // កូដកម្មវិធីរបស់អ្នកនៅទីនេះ httpsServer.listen(443, 'ឧទាហរណ៍domain.com'); |
ប៉ារ៉ាម៉ែត្រ httpsOptions គឺជាវត្ថុដូចគ្នាបេះបិទទៅនឹងវត្ថុដែលបានប្រើនៅក្នុងផ្នែកនៃការណែនាំនេះ៖ ការបង្កើតម៉ាស៊ីនមេ HTTPS នៅក្នុងអត្ថបទនេះ។
ឧទាហរណ៍នៃកូដពេញលេញដើម្បីបង្កើតកម្មវិធី HTTPS Express ត្រូវបានបង្ហាញខាងក្រោម៖
នៅចំណុចនេះ អ្នកនឹងមានកម្មវិធី Express ដែលអាចចូលប្រើបានតាមរយៈ HTTPS ។ ចំណាំថាកម្មវិធីឧទាហរណ៍ដែលបានរៀបរាប់ខាងលើនឹងស្តាប់តែសំណើ HTTPS នៅលើច្រកដែលបានបញ្ជាក់។ ប្រសិនបើអ្នកក៏ត្រូវការកម្មវិធីរបស់អ្នកដើម្បីស្តាប់សំណើ HTTP ដែរ អ្នកនឹងត្រូវដំឡើង HTTP server តាមរបៀបស្រដៀងគ្នាដោយប្រើ http.createServer() ពីទំព័រ របស់ HTTP ម៉ូឌុល។
ត្រូវប្រាកដថាចាប់ផ្តើមកម្មវិធីរបស់អ្នកឡើងវិញប្រសិនបើវាកំពុងដំណើរការរួចហើយ ដើម្បីអនុវត្តការផ្លាស់ប្តូរ។ ដើម្បីចាប់ផ្តើមកម្មវិធីឡើងវិញ អ្នកគ្រាន់តែអាចដំណើរការ ថ្នាំង .js នៅក្នុងថតជាមួយកម្មវិធីរបស់អ្នក។
ឧបករណ៍នេះអាចត្រូវបានប្រើដើម្បីពិនិត្យមើលការដំឡើងវិញ្ញាបនបត្រ SSL៖ https://ssl-checker.1byte.com/
ប្រើប្រាស់ជំនាញ Cloud Computing ដ៏រឹងមាំរបស់ 1Byte ដើម្បីជំរុញអាជីវកម្មរបស់អ្នកតាមរបៀបដ៏ធំមួយ
1Byte ផ្តល់ពេញលេញ domain សេវាកម្មចុះឈ្មោះដែលរួមមានបុគ្គលិកគាំទ្រដោយយកចិត្តទុកដាក់ ការថែទាំអតិថិជនដែលមានការអប់រំ ការចំណាយសមរម្យ ក៏ដូចជា ក domain ឧបករណ៍ស្វែងរកតម្លៃ។
បង្កើនសុវត្ថិភាពលើអ៊ីនធឺណិតរបស់អ្នកជាមួយនឹងសេវាកម្ម SSL របស់ 1Byte ។ ការការពារដែលមិនអាចប្រៀបផ្ទឹមបាន ការរួមបញ្ចូលដោយគ្មានថ្នេរ និងសន្តិភាពនៃចិត្តសម្រាប់ដំណើរឌីជីថលរបស់អ្នក។
មិនថា cloud server កញ្ចប់ដែលអ្នកជ្រើសរើស អ្នកអាចពឹងផ្អែកលើ 1Byte សម្រាប់ភាពជឿជាក់ ភាពឯកជន សុវត្ថិភាព និងបទពិសោធន៍គ្មានភាពតានតឹង ដែលមានសារៈសំខាន់សម្រាប់អាជីវកម្មជោគជ័យ។
ការជ្រើសរើសពួកយើងជាអ្នកផ្តល់សេវាបង្ហោះចែករំលែករបស់អ្នកអនុញ្ញាតឱ្យអ្នកទទួលបានតម្លៃដ៏ល្អឥតខ្ចោះសម្រាប់ប្រាក់របស់អ្នក ខណៈពេលដែលរីករាយនឹងកម្រិតគុណភាព និងមុខងារដូចគ្នានឹងជម្រើសដែលមានតម្លៃថ្លៃជាង។
តាមរយៈកម្មវិធីដែលមានភាពបត់បែនខ្ពស់ 1Byte ដ៏ទំនើប cloud hosting ផ្តល់ដំណោះស្រាយដ៏អស្ចារ្យដល់អាជីវកម្មខ្នាតតូច និងមធ្យមលឿនជាងមុន សុវត្ថិភាពជាងមុន និងក្នុងតម្លៃកាត់បន្ថយ។
បន្តនាំមុខការប្រកួតប្រជែងជាមួយនឹងសេវាកម្មបង្ហោះ WordPress ប្រកបដោយភាពច្នៃប្រឌិតរបស់ 1Byte ។ ផែនការដែលសំបូរទៅដោយលក្ខណៈពិសេសរបស់យើង និងភាពជឿជាក់ដែលមិនអាចប្រៀបផ្ទឹមបានធានាថាគេហទំព័ររបស់អ្នកមានភាពលេចធ្លោ និងផ្តល់នូវបទពិសោធន៍អ្នកប្រើប្រាស់ដែលមិនអាចបំភ្លេចបាន។
ក្នុងនាមជាដៃគូ AWS ផ្លូវការ ទំនួលខុសត្រូវចម្បងមួយរបស់យើងគឺជួយអាជីវកម្មក្នុងការធ្វើទំនើបកម្មប្រតិបត្តិការរបស់ពួកគេ និងប្រើប្រាស់ច្រើនបំផុតក្នុងការធ្វើដំណើររបស់ពួកគេទៅកាន់ពពកជាមួយ AWS ។
Redirecting ទៅ HTTPS ជាមូយ Express
ដើម្បីប្តូរទិសសំណើ HTTP ណាមួយទៅ HTTPS អ្នកក៏នឹងត្រូវមាន HTTP Server ដែលកំពុងដំណើរការដែលអាចស្តាប់សំណើ HTTP បាន។ Server គួរតែត្រូវបានបង្កើតដោយប្រើ របស់ HTTP ម៉ូឌុល ហើយបានឆ្លងកាត់កម្មវិធី Express របស់អ្នកជាប៉ារ៉ាម៉ែត្រមួយតាមរបៀបដែលកម្មវិធីត្រូវបានបញ្ជូនសម្រាប់ HTTPS server.
ដើម្បីបង្កើតការបញ្ជូនបន្តទៅ HTTPS អ្នកអាចរៀបចំមុខងារ middleware ដែលនឹងពិនិត្យមើលថាតើសំណើត្រូវបានធ្វើឡើងតាមរយៈ HTTP ហើយប្តូរទិសវាទៅ HTTPS ប្រសិនបើវាកើតឡើង។ ខាងក្រោមនេះគឺជាឧទាហរណ៍នៃ middleware បែបនេះដោយប្រើឧបករណ៍ភ្ជាប់មកជាមួយ redirect() method ពី Express:
| app.use((req, res, បន្ទាប់) => { if(req.protocol === 'http') { res.redirect(301, `https://${req.headers.host}${req.url}`); } បន្ទាប់ (); }); |
ខាងក្រោមនេះជាឧទាហរណ៍នៃកូដកម្មវិធី Express ពេញលេញដែលប្រើ HTTPS និងប្តូរទិសសំណើ HTTP ទាំងអស់ទៅ HTTPS៖
នៅក្នុងកូដខាងលើ យើងរៀបចំកម្មវិធី Express របស់យើងនៅលើបន្ទាត់ទី 16 បន្ទាប់មកបានបង្កើត HTTP និង HTTPS servers នៅលើបន្ទាត់ទី 17 និង 18។ បន្ទាត់ 20-25 បង្កើតកម្មវិធីកណ្តាលដែលប្តូរទិសសំណើ HTTP ទៅ HTTPS ។ ជាចុងក្រោយ ជាឧទាហរណ៍ យើងរៀបចំកូដ Server មួយចំនួននៅលើបន្ទាត់ 30-35 ហើយចាប់ផ្តើម HTTP Server និង HTTPS ដោយហៅ listen() method របស់ពួកគេនៅលើបន្ទាត់ 37 និង 38 ។
ខាងក្រោមអ្នកអាចឃើញរូបថតអេក្រង់ដែលបង្ហាញពីសំណើ HTTP សម្រាប់ទាំងឯកសារ static និង URLs ផ្ទាល់ខ្លួន ដែលត្រូវបានប្តូរទិសត្រឹមត្រូវ។
ឯកសារឋិតិវន្ត៖
URLs ផ្ទាល់ខ្លួន៖
សូមចំណាំ៖ ប្រសិនបើ Node.js ត្រូវបានដំឡើងជា virtual environment នៅលើ 1Byte shared hosting – វាមិនអាចដំឡើងវិញ្ញាបនបត្រ SSL នៅលើវាបានទេ ផ្ទុយទៅវិញ វិញ្ញាបនបត្រអាចជា ដំឡើងយ៉ាងងាយស្រួលតាមរយៈ cPanel.