ஆம், வர்ஜீனியா, *இஸ்* ஏ சாண்டா கிளாஸ் 2023 இல் இணைய கட்டமைப்புகளுக்கு இடையே உள்ள வேறுபாடு
உள்ளடக்கம்
- அறிமுகம்
- சோதனை
- PHP/Laravel
- தூய PHP
- லாரவெல்லை மீண்டும் பார்க்கிறேன்
- ஜாங்கோ
- குடுவை
- ஸ்டார்லெட்
- Node.js/ExpressJS
- துரு/ஆக்டிக்ஸ்
- தொழில்நுட்ப கடன்
- வளங்கள்
அறிமுகம்
எனது சமீபத்திய வேலை நேர்காணல்களில் ஒன்றிற்குப் பிறகு, நான் விண்ணப்பித்த நிறுவனம் இன்னும் ஒரு தசாப்தத்திற்கு முன்பு நான் முயற்சித்த PHP கட்டமைப்பான Laravel ஐப் பயன்படுத்துகிறது என்பதை அறிந்து நான் ஆச்சரியப்பட்டேன். அது அந்தக் காலத்திற்கு ஒழுக்கமானதாக இருந்தது, ஆனால் தொழில்நுட்பம் மற்றும் ஃபேஷனில் ஒரே நிலையானது இருந்தால், அது தொடர்ச்சியான மாற்றம் மற்றும் பாணிகள் மற்றும் கருத்துகளின் மறுஉருவாக்கம் ஆகும். நீங்கள் ஒரு ஜாவாஸ்கிரிப்ட் புரோகிராமராக இருந்தால், இந்த பழைய நகைச்சுவையை நீங்கள் அறிந்திருக்கலாம்.
புரோகிராமர் 1: "இந்த புதிய ஜாவாஸ்கிரிப்ட் கட்டமைப்பை நான் விரும்பவில்லை!"
புரோகிராமர் 2: "கவலைப்படத் தேவையில்லை. ஆறு மாதங்கள் காத்திருங்கள், அதற்குப் பதிலாக இன்னொருவர் வருவார்!"
ஆர்வத்தின் காரணமாக, பழையதையும் புதியதையும் சோதனைக்கு உட்படுத்தும்போது என்ன நடக்கிறது என்பதைப் பார்க்க முடிவு செய்தேன். நிச்சயமாக, இணையம் வரையறைகள் மற்றும் உரிமைகோரல்களால் நிரம்பியுள்ளது, அவற்றில் மிகவும் பிரபலமானதாக இருக்கலாம் TechEmpower Web Framework Benchmarks இங்கே . இன்று அவர்களைப் போல சிக்கலான எதையும் நாங்கள் செய்யப் போவதில்லை. நாங்கள் விஷயங்களை அழகாகவும் எளிமையாகவும் வைத்திருப்போம், இதனால் இந்த கட்டுரை மாறாது போர் மற்றும் அமைதி , நீங்கள் படித்து முடித்த நேரத்தில் விழித்திருப்பதற்கான ஒரு சிறிய வாய்ப்பு உங்களுக்கு கிடைக்கும். வழக்கமான எச்சரிக்கைகள் பொருந்தும்: இது உங்கள் கணினியில் ஒரே மாதிரியாக வேலை செய்யாமல் போகலாம், வெவ்வேறு மென்பொருள் பதிப்புகள் செயல்திறனைப் பாதிக்கலாம், மேலும் ஷ்ரோடிங்கரின் பூனை உண்மையில் ஒரு ஜாம்பி பூனையாக மாறியது, அது அதே நேரத்தில் பாதி உயிருடன் பாதி இறந்துவிட்டது.
சோதனை
சுற்றுச்சூழல் சோதனை
இந்தச் சோதனைக்காக, இங்கே காட்டப்பட்டுள்ளபடி, மஞ்சாரோ லினக்ஸ் இயங்கும் சிறிய i5 ஐக் கொண்டு எனது மடிக்கணினியைப் பயன்படுத்துவேன்.
╰─➤ uname -a
Linux jimsredmi 5.10.174-1-MANJARO #1 SMP PREEMPT Tuesday Mar 21 11:15:28 UTC 2023 x86_64 GNU/Linux
╰─➤ cat /proc/cpuinfo
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 126
model name : Intel(R) Core(TM) i5-1035G1 CPU @ 1.00GHz
stepping : 5
microcode : 0xb6
cpu MHz : 990.210
cache size : 6144 KB
கையில் உள்ள பணி
ஒவ்வொரு கோரிக்கைக்கும் எங்கள் குறியீடு மூன்று எளிய பணிகளைக் கொண்டிருக்கும்:
- குக்கீயிலிருந்து தற்போதைய பயனரின் அமர்வு ஐடியைப் படிக்கவும்
- தரவுத்தளத்திலிருந்து கூடுதல் தகவலை ஏற்றவும்
- அந்த தகவலை பயனருக்குத் திருப்பி அனுப்பவும்
இது என்ன வகையான முட்டாள்தனமான சோதனை, நீங்கள் கேட்கலாம்? சரி, இந்தப் பக்கத்திற்கான பிணைய கோரிக்கைகளைப் பார்த்தால், அதையே செய்யும் sessionvars.js எனப்படும் ஒன்றை நீங்கள் கவனிப்பீர்கள்.
நீங்கள் பார்க்கிறீர்கள், நவீன வலைப்பக்கங்கள் சிக்கலான உயிரினங்கள், மேலும் பொதுவான பணிகளில் ஒன்று தரவுத்தள சேவையகத்தில் அதிக சுமைகளைத் தவிர்க்க சிக்கலான பக்கங்களைத் தேக்குவது.
ஒவ்வொரு முறையும் ஒரு சிக்கலான பக்கத்தை மீண்டும் ரெண்டர் செய்தால், ஒவ்வொரு முறையும் ஒரு பயனர் அதைக் கோரினால், ஒரு வினாடிக்கு 600 பயனர்களுக்கு மட்டுமே சேவை செய்ய முடியும்.
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1/system/index.en.html
Running 10s test @ http://127.0.0.1/system/index.en.html
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 186.83ms 174.22ms 1.06s 81.16%
Req/Sec 166.11 58.84 414.00 71.89%
6213 requests in 10.02s, 49.35MB read
Requests/sec: 619.97
Transfer/sec: 4.92MB
ஆனால் இந்தப் பக்கத்தை ஒரு நிலையான HTML கோப்பாக தேக்ககப்படுத்தி, Nginxஐ பயனருக்கு சாளரத்தின் வழியாக விரைவாக தூக்கி எறிய அனுமதித்தால், நாம் ஒரு வினாடிக்கு 32,000 பயனர்களுக்கு சேவை செய்யலாம், செயல்திறனை 50x மடங்கு அதிகரிக்கும்.
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1/system/index.en.html
Running 10s test @ http://127.0.0.1/system/index.en.html
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 3.03ms 511.95us 6.87ms 68.10%
Req/Sec 8.20k 1.15k 28.55k 97.26%
327353 requests in 10.10s, 2.36GB read
Requests/sec: 32410.83
Transfer/sec: 238.99MB
நிலையான index.en.html என்பது அனைவருக்கும் செல்லும் பகுதியாகும், மேலும் பயனரால் வேறுபடும் பகுதிகள் மட்டுமே sessionvars.js இல் அனுப்பப்படும். இது தரவுத்தள சுமையைக் குறைப்பது மட்டுமல்லாமல், எங்கள் பயனர்களுக்கு சிறந்த அனுபவத்தை உருவாக்குகிறது, ஆனால் க்ளிங்கோன்கள் தாக்கும் போது வார்ப் கோர் மீறலில் எங்கள் சேவையகம் தன்னிச்சையாக ஆவியாகும் குவாண்டம் நிகழ்தகவுகளையும் குறைக்கிறது.
குறியீடு தேவைகள்
ஒவ்வொரு கட்டமைப்பிற்கும் திரும்பிய குறியீட்டிற்கு ஒரு எளிய தேவை இருக்கும்: "எண்ணிக்கை என்பது x" என்று கூறிப் பயனர் எத்தனை முறை பக்கத்தைப் புதுப்பித்துள்ளார்கள் என்பதைக் காட்டவும். விஷயங்களை எளிமையாக வைத்திருக்க, நாங்கள் இப்போது ரெடிஸ் வரிசைகள், குபெர்னெட்ஸ் கூறுகள் அல்லது AWS லாம்ப்டாஸ் ஆகியவற்றிலிருந்து விலகி இருப்போம்.
ஒவ்வொரு பயனரின் அமர்வுத் தரவும் PostgreSQL தரவுத்தளத்தில் சேமிக்கப்படும்.
மேலும் இந்த தரவுத்தள அட்டவணை ஒவ்வொரு சோதனைக்கு முன்பும் துண்டிக்கப்படும்.
பாஃபெரா முழக்கம் எளிமையானது ஆனால் பயனுள்ளது... எப்படியும் இருண்ட காலவரிசைக்கு வெளியே...
உண்மையான சோதனை முடிவுகள்
PHP/Laravel
சரி, இப்போது நாம் இறுதியாக நம் கைகளை அழுக்காக்க ஆரம்பிக்கலாம். லாராவெல் இசையமைப்பாளர் மற்றும் கைவினைஞர்களின் ஒரு கூட்டமாக இருப்பதால், அதன் அமைப்பை நாங்கள் தவிர்ப்போம். கட்டளைகள்.
முதலில், எங்கள் தரவுத்தள அமைப்புகளை .env கோப்பில் அமைப்போம்
DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=sessiontest
DB_USERNAME=sessiontest
DB_PASSWORD=sessiontest
ஒவ்வொரு கோரிக்கையையும் எங்கள் கட்டுப்படுத்திக்கு அனுப்பும் ஒரு ஒற்றை பின்னடைவு வழியை அமைப்போம்.
Route::fallback(SessionController::class);
எண்ணிக்கையைக் காட்ட கட்டுப்படுத்தியை அமைக்கவும். Laravel, முன்னிருப்பாக, தரவுத்தளத்தில் அமர்வுகளை சேமிக்கிறது. இதுவும் வழங்குகிறது session() எங்கள் அமர்வு தரவுகளுடன் இடைமுகமாக செயல்படும், எனவே எங்கள் பக்கத்தை வழங்குவதற்கு இரண்டு கோடுகள் மட்டுமே தேவைப்பட்டது.
class SessionController extends Controller
{
public function __invoke(Request $request)
{
$count = session('count', 0);
$count += 1;
session(['count' => $count]);
return 'Count is ' . $count;
}
}
php-fpm மற்றும் Nginx ஐ அமைத்த பிறகு, எங்கள் பக்கம் அழகாக இருக்கிறது...
╰─➤ php -v
PHP 8.2.2 (cli) (built: Feb 1 2023 08:33:04) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.2, Copyright (c) Zend Technologies
with Xdebug v3.2.0, Copyright (c) 2002-2022, by Derick Rethans
╰─➤ sudo systemctl restart php-fpm
╰─➤ sudo systemctl restart nginx
குறைந்த பட்சம் சோதனை முடிவுகளை நாம் பார்க்கும் வரை...
PHP/Laravel
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1
Running 10s test @ http://127.0.0.1
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 1.08s 546.33ms 1.96s 65.71%
Req/Sec 12.37 7.28 40.00 56.64%
211 requests in 10.03s, 177.21KB read
Socket errors: connect 0, read 0, write 0, timeout 176
Requests/sec: 21.04
Transfer/sec: 17.67KB
இல்லை, அது எழுத்துப்பிழை அல்ல. எங்களின் சோதனை இயந்திரம் ஒரு சிக்கலான பக்கத்தை ரெண்டரிங் செய்யும் வினாடிக்கு 600 கோரிக்கைகளிலிருந்து... வினாடிக்கு 21 கோரிக்கைகள் ரெண்டரிங் "எண்ணிக்கை 1".
அதனால் என்ன தவறு நடந்தது? எங்கள் PHP நிறுவலில் ஏதேனும் தவறு உள்ளதா? php-fpm உடன் இடைமுகப்படுத்தும்போது Nginx எப்படியாவது குறைகிறதா?
தூய PHP
இந்தப் பக்கத்தை தூய PHP குறியீட்டில் மீண்டும் செய்வோம்.
<?php
// ====================================================================
function uuid4()
{
return sprintf(
'%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
mt_rand(0, 0xffff), mt_rand(0, 0xffff),
mt_rand(0, 0xffff),
mt_rand(0, 0x0fff) | 0x4000,
mt_rand(0, 0x3fff) | 0x8000,
mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
);
}
// ====================================================================
function Query($db, $query, $params = [])
{
$s = $db->prepare($query);
$s->setFetchMode(PDO::FETCH_ASSOC);
$s->execute(array_values($params));
return $s;
}
// ********************************************************************
session_start();
$sessionid = 0;
if (isset($_SESSION['sessionid']))
{
$sessionid = $_SESSION['sessionid'];
}
if (!$sessionid)
{
$sessionid = uuid4();
$_SESSION['sessionid'] = $sessionid;
}
$db = new PDO('pgsql:host=127.0.0.1 dbname=sessiontest user=sessiontest password=sessiontest');
$data = 0;
try
{
$result = Query(
$db,
'SELECT data FROM usersessions WHERE uid = ?',
[$sessionid]
)->fetchAll();
if ($result)
{
$data = json_decode($result[0]['data'], 1);
}
} catch (Exception $e)
{
echo $e;
Query(
$db,
'CREATE TABLE usersessions(
uid TEXT PRIMARY KEY,
data TEXT
)'
);
}
if (!$data)
{
$data = ['count' => 0];
}
$data['count']++;
if ($data['count'] == 1)
{
Query(
$db,
'INSERT INTO usersessions(uid, data)
VALUES(?, ?)',
[$sessionid, json_encode($data)]
);
} else
{
Query(
$db,
'UPDATE usersessions
SET data = ?
WHERE uid = ?',
[json_encode($data), $sessionid]
);
}
echo 'Count is ' . $data['count'];
Laravel இல் நான்கு வரி குறியீடுகள் (மற்றும் ஒரு முழு கட்டமைப்பு வேலைகள்) செய்ததைச் செய்ய இப்போது 98 கோடுகளின் குறியீட்டைப் பயன்படுத்தியுள்ளோம். (நிச்சயமாக, நாம் சரியான பிழை கையாளுதல் மற்றும் பயனர் எதிர்கொள்ளும் செய்திகளை செய்திருந்தால், இது வரிகளின் எண்ணிக்கையை விட இரண்டு மடங்கு அதிகமாக இருக்கும்.) ஒருவேளை நாம் வினாடிக்கு 30 கோரிக்கைகளை செய்யலாம்?
PHP/Pure PHP
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1
Running 10s test @ http://127.0.0.1
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 140.79ms 27.88ms 332.31ms 90.75%
Req/Sec 178.63 58.34 252.00 61.01%
7074 requests in 10.04s, 3.62MB read
Requests/sec: 704.46
Transfer/sec: 369.43KB
ஐயோ! எங்கள் PHP நிறுவலில் எந்தத் தவறும் இல்லை என்பது போல் தெரிகிறது. தூய PHP பதிப்பு வினாடிக்கு 700 கோரிக்கைகளை செய்கிறது.
PHP இல் எந்த தவறும் இல்லை எனில், ஒருவேளை நாம் Laravel ஐ தவறாக உள்ளமைத்தோமா?
லாரவெல்லை மீண்டும் பார்க்கிறேன்
உள்ளமைவுச் சிக்கல்கள் மற்றும் செயல்திறன் உதவிக்குறிப்புகளுக்கு இணையத்தைத் தேடிய பிறகு, ஒவ்வொரு கோரிக்கைக்கும் அவற்றைச் செயலாக்குவதைத் தவிர்க்க, கட்டமைப்பு மற்றும் வழித் தரவைத் தேக்ககப்படுத்துவது மிகவும் பிரபலமான இரண்டு நுட்பங்களாகும். எனவே, அவர்களின் ஆலோசனையைப் பெற்று, இந்த உதவிக்குறிப்புகளை முயற்சிப்போம்.
╰─➤ php artisan config:cache
INFO Configuration cached successfully.
╰─➤ php artisan route:cache
INFO Routes cached successfully.
கட்டளை வரியில் எல்லாம் நன்றாக இருக்கிறது. அளவுகோலை மீண்டும் செய்வோம்.
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1
Running 10s test @ http://127.0.0.1
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 1.13s 543.50ms 1.98s 61.90%
Req/Sec 25.45 13.39 50.00 55.77%
289 requests in 10.04s, 242.15KB read
Socket errors: connect 0, read 0, write 0, timeout 247
Requests/sec: 28.80
Transfer/sec: 24.13KB
சரி, இப்போது செயல்திறனை வினாடிக்கு 21.04லிருந்து 28.80 ஆக உயர்த்தியுள்ளோம், இது கிட்டத்தட்ட 37% வியத்தகு உயர்வு! எந்தவொரு மென்பொருள் தொகுப்பிற்கும் இது மிகவும் சுவாரசியமாக இருக்கும்.
இந்தச் சோதனையில் ஏதேனும் தவறு இருப்பதாக நீங்கள் நினைத்தால், லூசிண்டா PHP கட்டமைப்பின் ஆசிரியரிடம் பேச வேண்டும். அவரது சோதனை முடிவுகளில், அவர் லூசிண்டா லாரவேலை அடிக்கிறார் HTML கோரிக்கைகளுக்கு 36x மற்றும் JSON கோரிக்கைகளுக்கு 90x.
Apache மற்றும் Nginx இரண்டிலும் எனது சொந்த கணினியில் சோதனை செய்த பிறகு, நான் அவரை சந்தேகிக்க எந்த காரணமும் இல்லை. Laravel உண்மையில் நியாயமானவர் என்று மெதுவாக! PHP அவ்வளவு மோசமாக இல்லை, ஆனால் ஒவ்வொரு கோரிக்கையிலும் Laravel சேர்க்கும் கூடுதல் செயலாக்கம் அனைத்தையும் நீங்கள் சேர்த்தவுடன், 2023 இல் Laravel ஐ ஒரு தேர்வாகப் பரிந்துரைப்பது எனக்கு மிகவும் கடினமாக உள்ளது.
ஜாங்கோ
PHP/Wordpress கணக்குகள் இணையத்தில் உள்ள அனைத்து இணையதளங்களிலும் சுமார் 40% , இது மிகவும் மேலாதிக்க கட்டமைப்பாக உள்ளது. தனிப்பட்ட முறையில் இருப்பினும், அந்த அசாதாரண நல்ல உணவை உண்பதற்காக எனக்கு திடீரென கட்டுப்பாடற்ற உந்துதல் இருப்பதைக் காட்டிலும், புகழ் என்பது தரமாக மொழிபெயர்க்கப்பட வேண்டிய அவசியமில்லை என்பதைக் காண்கிறேன். உலகின் மிகவும் பிரபலமான உணவகம் ... மெக்டொனால்டு' நாங்கள் ஏற்கனவே தூய PHP குறியீட்டை சோதித்திருப்பதால், நாங்கள் Wordpress ஐயே சோதிக்கப் போவதில்லை, ஏனெனில் Wordpress சம்பந்தப்பட்ட எதுவும் சந்தேகத்திற்கு இடமின்றி சுத்தமான PHP மூலம் நாம் கவனித்த வினாடிக்கு 700 கோரிக்கைகளை விட குறைவாக இருக்கும்.
ஜாங்கோ என்பது நீண்ட காலமாக இருக்கும் மற்றொரு பிரபலமான கட்டமைப்பாகும். நீங்கள் கடந்த காலத்தில் இதைப் பயன்படுத்தியிருந்தால், நீங்கள் விரும்பியபடி எல்லாவற்றையும் கட்டமைப்பது எவ்வளவு எரிச்சலூட்டும் அதனுடன் அதன் அற்புதமான தரவுத்தள நிர்வாக இடைமுகத்தையும் நீங்கள் விரும்பி நினைவில் வைத்திருக்கலாம். 2023 ஆம் ஆண்டில் ஜாங்கோ எவ்வளவு சிறப்பாக செயல்படுகிறது என்பதைப் பார்ப்போம், குறிப்பாக பதிப்பு 4.0 இல் சேர்க்கப்பட்டுள்ள புதிய ASGI இடைமுகத்துடன்.
ஜாங்கோவை அமைப்பது என்பது லாராவெல் அமைப்பதைப் போன்றது. சலிப்பான உள்ளமைவைத் தவிர்த்துவிட்டு நேராக பார்வையை அமைப்பதற்குச் செல்வோம்.
from django.shortcuts import render
from django.http import HttpResponse
# =====================================================================
def index(request):
count = request.session.get('count', 0)
count += 1
request.session['count'] = count
return HttpResponse(f"Count is {count}")
லாராவெல் பதிப்பைப் போலவே நான்கு வரி குறியீடுகளும் இருக்கும். அது எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்.
╰─➤ python --version
Python 3.10.9
Python/Django
╰─➤ gunicorn --access-logfile - -k uvicorn.workers.UvicornWorker -w 4 djangotest.asgi
[2023-03-21 15:20:38 +0800] [2886633] [INFO] Starting gunicorn 20.1.0
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000/sessiontest/
Running 10s test @ http://127.0.0.1:8000/sessiontest/
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 277.71ms 142.84ms 835.12ms 69.93%
Req/Sec 91.21 57.57 230.00 61.04%
3577 requests in 10.06s, 1.46MB read
Requests/sec: 355.44
Transfer/sec: 148.56KB
ஒரு வினாடிக்கு 355 கோரிக்கைகளில் மோசமாக இல்லை. இது தூய PHP பதிப்பின் செயல்திறனில் பாதி மட்டுமே, ஆனால் இது லாராவெல் பதிப்பை விட 12 மடங்கு அதிகம். ஜாங்கோ vs. லாரவெல் போட்டியே இல்லை என்று தெரிகிறது.
குடுவை
பெரிய எல்லாவற்றையும்-சமையலறை-மடு கட்டமைப்புகள் தவிர, சிறிய கட்டமைப்புகள் உள்ளன, அவை சில அடிப்படை அமைப்பைச் செய்கின்றன, அதே நேரத்தில் மீதமுள்ளவற்றைக் கையாள உங்களை அனுமதிக்கின்றன. பிளாஸ்க் மற்றும் அதன் ASGI இணையான குவார்ட் ஆகியவை பயன்படுத்த சிறந்த ஒன்றாகும். என் சொந்தம் PaferaPy கட்டமைப்பு பிளாஸ்கின் மேல் கட்டப்பட்டுள்ளது, எனவே செயல்திறனைப் பராமரிக்கும் போது விஷயங்களைச் செய்வது எவ்வளவு எளிது என்பதை நான் நன்கு அறிவேன்.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# Session benchmark test
import json
import psycopg
import uuid
from flask import Flask, session, redirect, url_for, request, current_app, g, abort, send_from_directory
from flask.sessions import SecureCookieSessionInterface
app = Flask('pafera')
app.secret_key = b'secretkey'
dbconn = 0
# =====================================================================
@app.route('/', defaults={'path': ''}, methods = ['GET', 'POST'])
@app.route('/<path:path>', methods = ['GET', 'POST'])
def index(path):
"""Handles all requests for the server.
We route all requests through here to handle the database and session
logic in one place.
"""
global dbconn
if not dbconn:
dbconn = psycopg.connect('dbname=sessiontest user=sessiontest password=sessiontest')
cursor = dbconn.execute('''
CREATE TABLE IF NOT EXISTS usersessions(
uid TEXT PRIMARY KEY,
data TEXT
)
''')
cursor.close()
dbconn.commit()
sessionid = session.get('sessionid', 0)
if not sessionid:
sessionid = uuid.uuid4().hex
session['sessionid'] = sessionid
cursor = dbconn.execute("SELECT data FROM usersessions WHERE uid = %s", [sessionid])
row = cursor.fetchone()
count = json.loads(row[0])['count'] if row else 0
count += 1
newdata = json.dumps({'count': count})
if count == 1:
cursor.execute("""
INSERT INTO usersessions(uid, data)
VALUES(%s, %s)
""",
[sessionid, newdata]
)
else:
cursor.execute("""
UPDATE usersessions
SET data = %s
WHERE uid = %s
""",
[newdata, sessionid]
)
cursor.close()
dbconn.commit()
return f'Count is {count}'
நீங்கள் பார்க்க முடியும் என, பிளாஸ்க் ஸ்கிரிப்ட் தூய PHP ஸ்கிரிப்டை விட சிறியது. நான் பயன்படுத்திய அனைத்து மொழிகளிலும், தட்டச்சு செய்யப்பட்ட விசை அழுத்தங்களின் அடிப்படையில் பைதான் மிகவும் வெளிப்படையான மொழியாக இருப்பதைக் கண்டேன். பிரேஸ்கள் மற்றும் அடைப்புக்குறிகள் இல்லாமை, பட்டியலிடுதல் மற்றும் டிக்டெய்ன் புரிஹென்ஷன்கள், மற்றும் அரைப்புள்ளிகளை விட உள்தள்ளலின் அடிப்படையில் தடுப்பது ஆகியவை பைத்தானை அதன் திறன்களில் எளிமையாகவும் சக்திவாய்ந்ததாகவும் ஆக்குகின்றன.
துரதிர்ஷ்டவசமாக, பைதான் எவ்வளவு மென்பொருள் எழுதப்பட்டிருந்தாலும், அங்குள்ள மெதுவான பொது நோக்க மொழியாகவும் உள்ளது. பைதான் லைப்ரரிகளின் எண்ணிக்கை ஒரே மாதிரியான மொழிகளை விட நான்கு மடங்கு அதிகமாக உள்ளது மற்றும் ஏராளமான டொமைன்களை உள்ளடக்கியது, இருப்பினும் NumPy போன்ற முக்கிய இடங்களுக்கு வெளியே பைதான் வேகமானது அல்லது செயல்திறன் கொண்டது என்று யாரும் கூற மாட்டார்கள்.
நமது பிளாஸ்க் பதிப்பு எங்களுடைய முந்தைய கட்டமைப்புகளுடன் எவ்வாறு ஒப்பிடுகிறது என்பதைப் பார்ப்போம்.
Python/Flask
╰─➤ gunicorn --access-logfile - -w 4 flasksite:app
[2023-03-21 15:32:49 +0800] [2856296] [INFO] Starting gunicorn 20.1.0
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000
Running 10s test @ http://127.0.0.1:8000
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 91.84ms 11.97ms 149.63ms 86.18%
Req/Sec 272.04 39.05 380.00 74.50%
10842 requests in 10.04s, 3.27MB read
Requests/sec: 1080.28
Transfer/sec: 333.37KB
எங்கள் ஃபிளாஸ்க் ஸ்கிரிப்ட் உண்மையில் எங்கள் தூய PHP பதிப்பை விட வேகமானது!
இதைப் பார்த்து நீங்கள் ஆச்சரியப்பட்டால், நாங்கள் குனிகார்ன் சேவையகத்தைத் தொடங்கும் போது எங்கள் பிளாஸ்க் பயன்பாடு அதன் அனைத்து துவக்கம் மற்றும் உள்ளமைவைச் செய்கிறது என்பதை நீங்கள் உணர வேண்டும், அதே நேரத்தில் ஒவ்வொரு முறையும் புதிய கோரிக்கை வரும்போது PHP ஸ்கிரிப்டை மீண்டும் செயல்படுத்துகிறது. ஏற்கனவே காரை ஸ்டார்ட் செய்து சாலையோரம் காத்திருக்கும் இளம், ஆர்வமுள்ள டாக்ஸி ஓட்டுநராக பிளாஸ்க் இருப்பதற்குச் சமமானவர், அதே சமயம் PHP என்பது தனது வீட்டில் அழைப்பு வரும் வரை காத்திருந்து அதன் பிறகுதான் ஓட்டும் பழைய ஓட்டுநராகும். உங்களை அழைத்துச் செல்ல. பழைய பள்ளி பையனாக இருந்து, சாதாரண HTML மற்றும் SHTML கோப்புகளுக்கு PHP ஒரு அற்புதமான மாற்றமாக இருந்த நாட்களில் இருந்து வருகிறது, எவ்வளவு நேரம் கடந்துவிட்டது என்பதை உணர சற்று வருத்தமாக இருக்கிறது, ஆனால் வடிவமைப்பு வேறுபாடுகள் உண்மையில் PHP க்கு கடினமாக உள்ளது. Python, Java மற்றும் Node.js சேவையகங்களுக்கு எதிராக போட்டியிடுங்கள், அவை நினைவகத்தில் இருக்கும் மற்றும் ஒரு வித்தைக்காரரின் வேகமான எளிமையுடன் கோரிக்கையை கையாளுகின்றன.
ஸ்டார்லெட்
பிளாஸ்க் இதுவரை எங்களின் வேகமான கட்டமைப்பாக இருக்கலாம், ஆனால் இது உண்மையில் மிகவும் பழைய மென்பொருள். பைதான் சமூகம் ஓரிரு ஆண்டுகளுக்கு முன்பு புதிய ஒத்திசைவற்ற ASGI சேவையகங்களுக்கு மாறியது, நிச்சயமாக, நானே அவர்களுடன் இணைந்துவிட்டேன்.
Pafera கட்டமைப்பின் புதிய பதிப்பு, PaferaPyAsync , ஸ்டார்லெட்டை அடிப்படையாகக் கொண்டது. Quart எனப்படும் Flask இன் ASGI பதிப்பு இருந்தாலும், Quart மற்றும் Starlette இடையே உள்ள செயல்திறன் வேறுபாடுகள், அதற்கு பதிலாக Starlette இல் எனது குறியீட்டை மறுவடிவமைக்க எனக்கு போதுமானதாக இருந்தது.
சமச்சீரற்ற நிரலாக்கமானது பலரைப் பயமுறுத்துகிறது, ஆனால் இது உண்மையில் கடினமான கருத்தாக இல்லை, ஏனென்றால் ஒரு தசாப்தத்திற்கு முன்னர் இந்த கருத்தை பிரபலப்படுத்திய Node.js தோழர்களுக்கு நன்றி.
மல்டித்ரெடிங், மல்டிபிராசசிங், டிஸ்ட்ரிப்ட் கம்ப்யூட்டிங், ப்ராமிஸ் செயினிங் மற்றும் பல அனுபவமிக்க புரோகிராமர்களை முன்கூட்டியே வயோதிபமாக்கிய மற்றும் வறண்டு போன அந்த வேடிக்கையான நேரங்கள் அனைத்திற்கும் நாங்கள் ஒத்துழைத்தோம். இப்போது நாம் தட்டச்சு செய்கிறோம் async எங்கள் செயல்பாடுகளுக்கு முன்னால் மற்றும் await செயல்படுத்த சிறிது நேரம் எடுக்கும் எந்த குறியீட்டின் முன். இது வழக்கமான குறியீட்டை விட உண்மையில் மிகவும் சொற்பொழிவாக உள்ளது, ஆனால் ஒத்திசைவு பழமையானவை, செய்தி அனுப்புதல் மற்றும் வாக்குறுதிகளைத் தீர்ப்பதைக் காட்டிலும் பயன்படுத்த மிகவும் குறைவான எரிச்சலூட்டும்.
எங்கள் ஸ்டார்லெட் கோப்பு இதுபோல் தெரிகிறது:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# Session benchmark test
import json
import uuid
import psycopg
from starlette.applications import Starlette
from starlette.responses import Response, PlainTextResponse, JSONResponse, RedirectResponse, HTMLResponse
from starlette.routing import Route, Mount, WebSocketRoute
from starlette_session import SessionMiddleware
dbconn = 0
# =====================================================================
async def index(R):
global dbconn
if not dbconn:
dbconn = await psycopg.AsyncConnection.connect('dbname=sessiontest user=sessiontest password=sessiontest')
cursor = await dbconn.execute('''
CREATE TABLE IF NOT EXISTS usersessions(
uid TEXT PRIMARY KEY,
data TEXT
)
''')
await cursor.close()
await dbconn.commit()
sessionid = R.session.get('sessionid', 0)
if not sessionid:
sessionid = uuid.uuid4().hex
R.session['sessionid'] = sessionid
cursor = await dbconn.execute("SELECT data FROM usersessions WHERE uid = %s", [sessionid])
row = await cursor.fetchone()
count = json.loads(row[0])['count'] if row else 0
count += 1
newdata = json.dumps({'count': count})
if count == 1:
await cursor.execute("""
INSERT INTO usersessions(uid, data)
VALUES(%s, %s)
""",
[sessionid, newdata]
)
else:
await cursor.execute("""
UPDATE usersessions
SET data = %s
WHERE uid = %s
""",
[newdata, sessionid]
)
await cursor.close()
await dbconn.commit()
return PlainTextResponse(f'Count is {count}')
# *********************************************************************
app = Starlette(
debug = True,
routes = [
Route('/{path:path}', index, methods = ['GET', 'POST']),
],
)
app.add_middleware(
SessionMiddleware,
secret_key = 'testsecretkey',
cookie_name = "pafera",
)
நீங்கள் பார்க்க முடியும் என, இது எங்கள் பிளாஸ்க் ஸ்கிரிப்ட்டிலிருந்து ஓரிரு ரூட்டிங் மாற்றங்களுடன் நகலெடுக்கப்பட்டு ஒட்டப்பட்டுள்ளது. async/await முக்கிய வார்த்தைகள்.
நகலெடுத்து ஒட்டப்பட்ட குறியீட்டை உண்மையில் நமக்கு எவ்வளவு முன்னேற்றம் அளிக்க முடியும்?
Python/Starlette
╰─➤ gunicorn --access-logfile - -k uvicorn.workers.UvicornWorker -w 4 starlettesite:app 130 ↵
[2023-03-21 15:42:34 +0800] [2856220] [INFO] Starting gunicorn 20.1.0
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000
Running 10s test @ http://127.0.0.1:8000
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 21.85ms 10.45ms 67.29ms 55.18%
Req/Sec 1.15k 170.11 1.52k 66.00%
45809 requests in 10.04s, 13.85MB read
Requests/sec: 4562.82
Transfer/sec: 1.38MB
எங்களிடம் ஒரு புதிய சாம்பியன் இருக்கிறார், பெண்கள் மற்றும் தாய்மார்களே! எங்களின் முந்தைய உயர்வானது, வினாடிக்கு 704 கோரிக்கைகள் என்ற எங்களின் தூய PHP பதிப்பாகும், இது எங்கள் பிளாஸ்க் பதிப்பால் வினாடிக்கு 1080 கோரிக்கைகளில் முந்தியது. எங்கள் ஸ்டார்லெட் ஸ்கிரிப்ட் முந்தைய போட்டியாளர்களை நொடிக்கு 4562 கோரிக்கைகளில் நசுக்குகிறது, அதாவது தூய PHP ஐ விட 6x முன்னேற்றம் மற்றும் Flask ஐ விட 4x முன்னேற்றம்.
நீங்கள் இன்னும் உங்கள் WSGI பைதான் குறியீட்டை ASGI க்கு மாற்றவில்லை என்றால், இப்போது தொடங்குவதற்கு நல்ல நேரமாக இருக்கலாம்.
Node.js/ExpressJS
இதுவரை, நாங்கள் PHP மற்றும் Python கட்டமைப்புகளை மட்டுமே உள்ளடக்கியுள்ளோம். இருப்பினும், உலகின் பெரும் பகுதியினர் ஜாவா, டாட்நெட், நோட்.ஜே.எஸ், ரூபி ஆன் ரெயில்ஸ் மற்றும் பிற தொழில்நுட்பங்களை தங்கள் இணையதளங்களுக்கு பயன்படுத்துகின்றனர். இது எந்த வகையிலும் உலகின் அனைத்து சுற்றுச்சூழல் அமைப்புகள் மற்றும் பயோம்கள் பற்றிய விரிவான கண்ணோட்டம் அல்ல, எனவே கரிம வேதியியலுக்கு நிகரான நிரலாக்கத்தை செய்வதைத் தவிர்க்க, குறியீட்டை தட்டச்சு செய்ய எளிதான கட்டமைப்பை மட்டுமே நாங்கள் தேர்வு செய்வோம். இதில் ஜாவா கண்டிப்பாக இல்லை.
உங்கள் K&R C அல்லது Knuth களின் நகலின் அடியில் நீங்கள் மறைந்திருக்கவில்லை எனில் கணினி நிரலாக்க கலை கடந்த பதினைந்து ஆண்டுகளாக, நீங்கள் Node.js பற்றி கேள்விப்பட்டிருக்கலாம். ஜாவாஸ்கிரிப்ட்டின் தொடக்கத்திலிருந்தே நம்மில் இருப்பவர்கள், நவீன ஜாவாஸ்கிரிப்ட்டின் நிலையைப் பார்த்து நம்பமுடியாத அளவிற்கு பயந்து, ஆச்சரியப்படுகிறோம், அல்லது இரண்டுமே இல்லை உலாவிகளாக. எல்லாவற்றிற்கும் மேலாக, எங்களிடம் சொந்த 64 பிட் முழு எண்களும் இப்போது மொழியில் உள்ளன! இதுவரை 64 பிட் மிதவைகளில் சேமிக்கப்படும் அனைத்தையும் விட இது மிகவும் சிறந்தது!
ExpressJS அநேகமாக பயன்படுத்த எளிதான Node.js சேவையகம், எனவே எங்கள் கவுண்டருக்கு சேவை செய்ய விரைவான மற்றும் அழுக்கு Node.js/ExpressJS பயன்பாட்டைச் செய்வோம்.
/**********************************************************************
* Simple session test using ExpressJS.
**********************************************************************/
var L = console.log;
var uuid = require('uuid4');
var express = require('express');
var session = require('express-session');
var MemoryStore = require('memorystore')(session);
var { Client } = require('pg')
var db = 0;
var app = express();
const PORT = 8000;
//session middleware
app.use(
session({
secret: "secretkey",
saveUninitialized: true,
resave: false,
store: new MemoryStore({
checkPeriod: 1000 * 60 * 60 * 24 // prune expired entries every 24h
})
})
);
app.get('/',
async function(req,res)
{
if (!db)
{
db = new Client({
user: 'sessiontest',
host: '127.0.0.1',
database: 'sessiontest',
password: 'sessiontest'
});
await db.connect();
await db.query(`
CREATE TABLE IF NOT EXISTS usersessions(
uid TEXT PRIMARY KEY,
data TEXT
)`,
[]
);
};
var session = req.session;
if (!session.sessionid)
{
session.sessionid = uuid();
}
var row = 0;
let queryresult = await db.query(`
SELECT data::TEXT
FROM usersessions
WHERE uid = $1`,
[session.sessionid]
);
if (queryresult && queryresult.rows.length)
{
row = queryresult.rows[0].data;
}
var count = 0;
if (row)
{
var data = JSON.parse(row);
data.count += 1;
count = data.count;
await db.query(`
UPDATE usersessions
SET data = $1
WHERE uid = $2
`,
[JSON.stringify(data), session.sessionid]
);
} else
{
await db.query(`
INSERT INTO usersessions(uid, data)
VALUES($1, $2)`,
[session.sessionid, JSON.stringify({count: 1})]
);
count = 1;
}
res.send(`Count is ${count}`);
}
);
app.listen(PORT, () => console.log(`Server Running at port ${PORT}`));
பைதான் பதிப்புகளைக் காட்டிலும் இந்தக் குறியீடு எழுதுவது உண்மையில் எளிதாக இருந்தது, இருப்பினும் பயன்பாடுகள் பெரிதாகும்போது நேட்டிவ் ஜாவாஸ்கிரிப்ட் அசாத்தியமாகிறது, மேலும் டைப்ஸ்கிரிப்ட் போன்ற இதை சரிசெய்யும் அனைத்து முயற்சிகளும் பைத்தானை விட மிக சொற்பொழிவாற்றுகின்றன.
இது எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்!
Node.js/ExpressJS
╰─➤ node --version v19.6.0
╰─➤ NODE_ENV=production node nodejsapp.js 130 ↵
Server Running at port 8000
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000
Running 10s test @ http://127.0.0.1:8000
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 90.41ms 7.20ms 188.29ms 85.16%
Req/Sec 277.15 37.21 393.00 81.66%
11018 requests in 10.02s, 3.82MB read
Requests/sec: 1100.12
Transfer/sec: 390.68KB
நீங்கள் Node.js' வி8 ஜாவாஸ்கிரிப்ட் எஞ்சினுடன் கூகுள் செய்த அற்புதமான வேலையின் காரணமாக அந்தக் கதைகள் பெரும்பாலும் உண்மையாக இருக்கின்றன. இந்த விஷயத்தில், எங்கள் விரைவு பயன்பாடு பிளாஸ்க் ஸ்கிரிப்டை விட சிறப்பாக செயல்பட்டாலும், அதன் ஒற்றை திரிக்கப்பட்ட தன்மையை ஸ்டார்லெட் நைட் பயன்படுத்திய நான்கு ஒத்திசைவு செயல்முறைகளால் தோற்கடிக்கப்படுகிறது, அவர் "நி!"
இன்னும் சில உதவிகளைப் பெறுவோம்!
╰─➤ pm2 start nodejsapp.js -i 4
[PM2] Spawning PM2 daemon with pm2_home=/home/jim/.pm2
[PM2] PM2 Successfully daemonized
[PM2] Starting /home/jim/projects/paferarust/nodejsapp.js in cluster_mode (4 instances)
[PM2] Done.
┌────┬──────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼──────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ nodejsapp │ default │ N/A │ cluster │ 37141 │ 0s │ 0 │ online │ 0% │ 64.6mb │ jim │ disabled │
│ 1 │ nodejsapp │ default │ N/A │ cluster │ 37148 │ 0s │ 0 │ online │ 0% │ 64.5mb │ jim │ disabled │
│ 2 │ nodejsapp │ default │ N/A │ cluster │ 37159 │ 0s │ 0 │ online │ 0% │ 56.0mb │ jim │ disabled │
│ 3 │ nodejsapp │ default │ N/A │ cluster │ 37171 │ 0s │ 0 │ online │ 0% │ 45.3mb │ jim │ disabled │
└────┴──────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
சரி! இப்போது அது நான்கு போரில் சமமான நான்கு! அளவுகோலாக இருக்கட்டும்!
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000
Running 10s test @ http://127.0.0.1:8000
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 45.09ms 19.89ms 176.14ms 60.22%
Req/Sec 558.93 97.50 770.00 66.17%
22234 requests in 10.02s, 7.71MB read
Requests/sec: 2218.69
Transfer/sec: 787.89KB
இன்னும் ஸ்டார்லெட்டின் மட்டத்தில் இல்லை, ஆனால் ஐந்து நிமிட ஜாவாஸ்கிரிப்ட் ஹேக்கிற்கு இது மோசமானதல்ல. எனது சொந்த சோதனையில் இருந்து, இந்த ஸ்கிரிப்ட் உண்மையில் தரவுத்தள இடைமுகம் மட்டத்தில் சற்று பின்வாங்கப்படுகிறது, ஏனெனில் பைத்தானுக்கு psycopg இருப்பதைப் போல node-postgres எங்கும் திறமையாக இல்லை. தரவுத்தள இயக்கியாக sqlite க்கு மாறுவது, அதே ExpressJS குறியீட்டிற்கு வினாடிக்கு 3000 கோரிக்கைகளை வழங்குகிறது.
கவனிக்க வேண்டிய முக்கிய விஷயம் என்னவென்றால், பைத்தானின் வேகம் மெதுவாக இருந்தாலும், ASGI கட்டமைப்புகள் சில பணிச்சுமைகளுக்கு Node.js தீர்வுகளுடன் போட்டியிடும்.
துரு/ஆக்டிக்ஸ்
எனவே இப்போது, நாங்கள் மலையின் உச்சியை நெருங்கி வருகிறோம், மேலும் மலையின் அடிப்படையில், எலிகள் மற்றும் ஆண்களால் பதிவுசெய்யப்பட்ட மிக உயர்ந்த பெஞ்ச்மார்க் மதிப்பெண்களை நான் சொல்கிறேன்.
இணையத்தில் கிடைக்கும் பெரும்பாலான கட்டமைப்பு வரையறைகளை நீங்கள் பார்த்தால், மேலே ஆதிக்கம் செலுத்தும் இரண்டு மொழிகள் இருப்பதை நீங்கள் கவனிப்பீர்கள்: C++ மற்றும் Rust. நான் 90 களில் இருந்து C++ உடன் பணிபுரிந்தேன், மேலும் MFC/ATL ஐ உருவாக்குவதற்கு முன்பே எனது சொந்த Win32 C++ கட்டமைப்பையும் வைத்திருந்தேன், எனவே எனக்கு மொழியுடன் நிறைய அனுபவம் உள்ளது. உங்களுக்கு ஏற்கனவே தெரிந்திருக்கும் போது, ஏதாவது ஒன்றை வேலை செய்வது மிகவும் வேடிக்கையாக இல்லை, எனவே அதற்கு பதிலாக நாங்கள் ஒரு ரஸ்ட் பதிப்பைச் செய்யப் போகிறோம். ;)
நிரலாக்க மொழிகளைப் பொறுத்தவரை ரஸ்ட் ஒப்பீட்டளவில் புதியது, ஆனால் லினஸ் டொர்வால்ட்ஸ் ரஸ்ட்டை லினக்ஸ் கர்னல் நிரலாக்க மொழியாக ஏற்றுக்கொள்வதாக அறிவித்தபோது அது எனக்கு ஆர்வமாக இருந்தது. பழைய புரோகிராமர்களான எங்களைப் பொறுத்தவரை, இது அமெரிக்க அரசியலமைப்பில் ஒரு புதிய திருத்தமாக இருக்கும் என்று கூறுவது போலவே இருக்கிறது.
இப்போது, நீங்கள் ஒரு அனுபவமிக்க புரோகிராமராக இருக்கும்போது, இளையவர்களைப் போல நீங்கள் வேகமாக அலைக்கழிக்க மாட்டீர்கள், இல்லையெனில் மொழி அல்லது நூலகங்களில் ஏற்படும் விரைவான மாற்றங்களால் நீங்கள் எரிந்து போகலாம். (AngularJS இன் முதல் பதிப்பைப் பயன்படுத்திய எவரும் நான் எதைப் பற்றி பேசுகிறேன் என்பதை அறிவார்கள்.) ரஸ்ட் இன்னும் ஓரளவு அந்த சோதனை வளர்ச்சி நிலையில் உள்ளது, மேலும் இணையத்தில் உள்ள பல குறியீடு எடுத்துக்காட்டுகள் கூட இல்லை என்பது எனக்கு வேடிக்கையாக இருக்கிறது. தொகுப்புகளின் தற்போதைய பதிப்புகளுடன் இனி தொகுக்கவும்.
இருப்பினும், ரஸ்ட் பயன்பாடுகளால் காட்டப்படும் செயல்திறனை மறுக்க முடியாது. நீங்கள் ஒருபோதும் முயற்சிக்கவில்லை என்றால் ripgrep அல்லது fd-கண்டுபிடி பெரிய மூலக் குறியீடு மரங்களில், நீங்கள் கண்டிப்பாக அவர்களுக்கு ஒரு சுழல் கொடுக்க வேண்டும். அவை பெரும்பாலான லினக்ஸ் விநியோகங்களுக்கு தொகுப்பு மேலாளரிடமிருந்தும் கிடைக்கின்றன. நீங்கள் ரஸ்டுடன் செயல்திறனுக்காக வார்த்தைகளை பரிமாறிக் கொள்கிறீர்கள்... a நிறைய a க்கான verbosity நிறைய செயல்திறன்.
ரஸ்டுக்கான முழுமையான குறியீடு சற்று பெரியது, எனவே தொடர்புடைய ஹேண்ட்லர்களை இங்கே பார்ப்போம்:
// =====================================================================
pub async fn RunQuery(
db: &web::Data<Pool>,
query: &str,
args: &[&(dyn ToSql + Sync)]
) -> Result<Vec<tokio_postgres::row::Row>, tokio_postgres::Error>
{
let client = db.get().await.unwrap();
let statement = client.prepare_cached(query).await.unwrap();
client.query(&statement, args).await
}
// =====================================================================
pub async fn index(
req: HttpRequest,
session: Session,
db: web::Data<Pool>,
) -> Result<HttpResponse, Error>
{
let mut count = 1;
if let Some(sessionid) = session.get::<String>("sessionid")?
{
let rows = RunQuery(
&db,
"SELECT data
FROM usersessions
WHERE uid = $1",
&[&sessionid]
).await.unwrap();
if rows.is_empty()
{
let jsondata = serde_json::json!({
"count": 1,
}).to_string();
RunQuery(
&db,
"INSERT INTO usersessions(uid, data)
VALUES($1, $2)",
&[&sessionid, &jsondata]
).await
.expect("Insert failed!");
} else
{
let jsonstring:&str = rows[0].get(0);
let countdata: CountData = serde_json::from_str(jsonstring)?;
count = countdata.count;
count += 1;
let jsondata = serde_json::json!({
"count": count,
}).to_string();
RunQuery(
&db,
"UPDATE usersessions
SET data = $1
WHERE uid = $2
",
&[&jsondata, &sessionid]
).await
.expect("Update failed!");
}
} else
{
let sessionid = Uuid::new_v4().to_string();
let jsondata = serde_json::json!({
"count": 1,
}).to_string();
RunQuery(
&db,
"INSERT INTO usersessions(uid, data)
VALUES($1, $2)",
&[&sessionid, &jsondata]
).await
.expect("Insert failed!");
session.insert("sessionid", sessionid)?;
}
Ok(HttpResponse::Ok().body(format!(
"Count is {:?}",
count
)))
}
இது Python/Node.js பதிப்புகளை விட மிகவும் சிக்கலானது...
Rust/Actix
╰─➤ cargo run --release
[2023-03-21T23:37:25Z INFO actix_server::builder] starting 4 workers
Server running at http://127.0.0.1:8888/
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8888
Running 10s test @ http://127.0.0.1:8888
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 9.93ms 3.90ms 77.18ms 94.87%
Req/Sec 2.59k 226.41 2.83k 89.25%
102951 requests in 10.03s, 24.59MB read
Requests/sec: 10267.39
Transfer/sec: 2.45MB
மற்றும் மிகவும் செயல்திறன்!
Actix/deadpool_postgres ஐப் பயன்படுத்தும் எங்கள் ரஸ்ட் சர்வர் எங்களின் முந்தைய சாம்பியனான Starlette ஐ +125%, ExpressJS ஐ +362%, மற்றும் தூய PHP ஐ +1366% மூலம் எளிதாக வென்றது. (பார்ஃபார்மென்ஸ் டெல்டாவை லாராவெல் பதிப்பில் வாசிப்பவருக்கு ஒரு பயிற்சியாக விட்டுவிடுகிறேன்.)
6502 அசெம்பிளிக்கு வெளியே நான் பார்த்த எதையும் விட ரஸ்ட் மொழியைக் கற்றுக்கொள்வது மற்ற மொழிகளைக் காட்டிலும் மிகவும் கடினமாக இருப்பதைக் கண்டேன் உங்கள் PHP சேவையகமாக பயனர்கள், பின்னர் தொழில்நுட்பங்களை மாற்றுவதன் மூலம் ஏதாவது பெறலாம். அதனால்தான் பாஃபெரா கட்டமைப்பின் அடுத்த பதிப்பு ரஸ்ட்டின் அடிப்படையில் இருக்கும். கற்றல் வளைவு ஸ்கிரிப்டிங் மொழிகளை விட அதிகமாக உள்ளது, ஆனால் செயல்திறன் மதிப்புக்குரியதாக இருக்கும். ரஸ்ட்டைக் கற்றுக்கொள்வதற்கு உங்களால் நேரத்தை ஒதுக்க முடியாவிட்டால், Starlette அல்லது Node.js இல் உங்கள் தொழில்நுட்ப அடுக்கை அடிப்படையாகக் கொள்வதும் மோசமான முடிவு அல்ல.
தொழில்நுட்ப கடன்
கடந்த இருபது ஆண்டுகளில், மலிவான நிலையான ஹோஸ்டிங் தளங்களிலிருந்து LAMP அடுக்குகளுடன் பகிர்ந்த ஹோஸ்டிங்கிற்கு VPSகளை AWS, Azure மற்றும் பிற கிளவுட் சேவைகளுக்கு வாடகைக்கு எடுத்துள்ளோம். இப்போதெல்லாம், வசதியான கிளவுட் சேவைகளின் வருகையானது மெதுவான சேவையகங்கள் மற்றும் பயன்பாடுகளில் அதிக வன்பொருளை எறிவதை எளிதாக்கியதால், கிடைக்கக்கூடிய அல்லது மலிவானவை என்று யாரைக் கண்டறிந்து வடிவமைப்பு முடிவுகளை எடுப்பதில் பல நிறுவனங்கள் திருப்தி அடைந்துள்ளன. இது நீண்ட கால தொழில்நுட்பக் கடனின் செலவில் பெரும் குறுகிய கால ஆதாயங்களை அவர்களுக்கு அளித்துள்ளது.
70 ஆண்டுகளுக்கு முன்பு சோவியத் யூனியனுக்கும் அமெரிக்காவுக்கும் இடையே பெரும் விண்வெளிப் போட்டி இருந்தது. சோவியத்துகள் பெரும்பாலான ஆரம்ப மைல்கற்களை வென்றனர். அவர்கள் ஸ்புட்னிக்கில் முதல் செயற்கைக்கோள், லைக்காவில் விண்வெளியில் முதல் நாய், லூனா 2 இல் முதல் சந்திரன் விண்கலம், யூரி ககாரின் மற்றும் வாலண்டினா தெரேஷ்கோவாவில் விண்வெளியில் முதல் ஆணும் பெண்ணும், மற்றும் பல...
ஆனால் அவர்கள் மெதுவாக தொழில்நுட்பக் கடனைக் குவித்தனர்.
இந்த சாதனைகள் ஒவ்வொன்றிலும் சோவியத்துகள் முதலிடம் பெற்றிருந்தாலும், அவர்களின் பொறியியல் செயல்முறைகள் மற்றும் இலக்குகள் நீண்ட கால சாத்தியக்கூறுகளை விட குறுகிய கால சவால்களில் கவனம் செலுத்த காரணமாக இருந்தது. அவர்கள் ஒவ்வொரு முறை குதித்தபோதும் வெற்றி பெற்றார்கள், ஆனால் அவர்கள் மிகவும் சோர்வாகவும் மெதுவாகவும் இருந்தனர், அதே நேரத்தில் அவர்களின் எதிரிகள் பூச்சுக் கோட்டை நோக்கி தொடர்ந்து முன்னேறினர்.
நீல் ஆம்ஸ்ட்ராங் சந்திரனில் தனது வரலாற்றுப் படிகளை நேரடி தொலைக்காட்சியில் எடுத்தவுடன், அமெரிக்கர்கள் முன்னிலை வகித்தனர், பின்னர் சோவியத் திட்டம் தடுமாறியதால் அங்கேயே தங்கினர். நீண்ட காலத்திற்கு சரியான பழக்கவழக்கங்கள் மற்றும் உத்திகளை உருவாக்கத் தவறிய நிலையில், அடுத்த பெரிய விஷயம், அடுத்த பெரிய ஊதியம் அல்லது அடுத்த பெரிய தொழில்நுட்பத்தில் கவனம் செலுத்தும் நிறுவனங்களை விட இது வேறுபட்டதல்ல.
சந்தைக்கு முதலில் இருப்பது, அந்த சந்தையில் நீங்கள் ஆதிக்கம் செலுத்தும் வீரராக மாறுவீர்கள் என்று அர்த்தமல்ல. மாற்றாக, விஷயங்களைச் சரியாகச் செய்ய நேரம் ஒதுக்குவது வெற்றிக்கு உத்தரவாதம் அளிக்காது, ஆனால் நீண்ட கால சாதனைகளுக்கான வாய்ப்புகளை நிச்சயமாக அதிகரிக்கிறது. உங்கள் நிறுவனத்திற்கான தொழில்நுட்ப முன்னணியில் நீங்கள் இருந்தால், உங்கள் பணிச்சுமைக்கான சரியான திசையையும் கருவிகளையும் தேர்வு செய்யவும். செயல்திறன் மற்றும் செயல்திறனைப் பதிலாக பிரபலத்தை அனுமதிக்காதீர்கள்.
வளங்கள்
Rust, ExpressJS, Flask, Starlette மற்றும் Pure PHP ஸ்கிரிப்ட்களைக் கொண்ட 7z கோப்பைப் பதிவிறக்க வேண்டுமா?
ஆசிரியரைப் பற்றி |
|
|
ஜிம் 90 களில் IBM PS/2 ஐப் பெற்றதிலிருந்து நிரலாக்கத்தில் ஈடுபட்டுள்ளார். இன்றுவரை, அவர் HTML மற்றும் SQL ஐ கையால் எழுத விரும்புகிறார், மேலும் அவரது வேலையில் செயல்திறன் மற்றும் சரியான தன்மையில் கவனம் செலுத்துகிறார். |
