แซแแแแแ แกแแกแแแแแแแแ, แ แแชแ แฎแแแ แแ แแก แงแแแแ แกแแญแแ แ แฌแแ แแแแแแ: แแแ แแ แแแแแแ แแ แ แแแฃแแ, แแแฎแแแแ แคแแแฅแแ แ, แแแแคแแ แขแฃแแ แแแฃแกแ, แ แแแแแแแแ แแแแแขแแแแแ แแแแแฃแแ แแ แ.แจ. แแก แจแแฃแแฉแแแแแแ แ แแ แแ แแแงแ แแแก แงแฃแ แแแฆแแแแก, แแแแ แแ แแแแคแแ แขแก แแแขแแแก แชแฎแแแ แแแแก. แแแแแ แแแแแแแ แกแฎแแแแแกแฎแแ แแแแแแฃแ แแ แแแกแแขแแ แแแแแแแชแแแแแแ แแแแแแจแแ แแแแ: แแ แซแแแ แแแ แแแแก แแแแแแญแแแแแกแแแแก, แกแฃแ แแแแก แแแแแก แจแแกแแแชแแ แแแแแ, แแแ แแแ แคแแแแแกแแแแก แแแแแกแแแแแแแแ, แแแฅแกแแแแแแแ, แแแ แฏแแแแแแ, แแแแแแงแแแแแแ แแ แ.แจ. แแแฅแแ แแ แแ?
แแแแฃแแแแแ แแแแแแ, แแแฎแแแแแแแ.
แแก แแกแแแแ - แฉแแแแ VPS แแชแแแแแ
แฉแแแ แฌแแแแแแแฎแแ แแแแ แ แกแขแแขแแ แแแแแฃแ แแแขแแแแกแ แแ แแแแฎแแแ แแแแแแแกแแแ, แ แแแแแแแช แฌแแ แแแแ 3-4 แฌแแแก แฌแแ แแแแก แจแแกแแฎแแ, แแฃ แ แแขแแ แแ แแ แแก แกแแญแแ แ แแแคแ VPS. แแกแแ, แแแจแแ VPS โแแ แแ แแแแแกแแแแกโ แฌแแแแแ แแแ แแแขแแแแ แแงแ แแ แแแ แจแแกแแแแแแแแแ แแแ แแแแฃแ แกแแแฃแจแแ แจแแกแแซแแแแแแแแแก. แแแแ แแ แแ แ แแชแแแแแ, แแแ แขแฃแแแฃแ แ แ แแกแฃแ แกแแแแก แฆแแ แแแฃแแแแ แฃแคแ แ แแ แฃแคแ แ แแชแแ แแแแ แแ แแแแจแ 30 แ แฃแแแแกแแแแก แฉแแแ แแแแ แแแ แ แจแแแแแแแแแแแ แแก:
- แแ แแชแแกแแ แ: Intel Xeon 2 GHz (1 แแแ แแแ)
- Linux แกแแกแขแแแ (Debian, Ubuntu, CentOS แแกแแ แฉแแแแ)
- 1 แแแแแงแแคแแแ IPv4 แแแกแแแแ แแ
- 10 GB แแแแแชแแแแ แจแแแแฎแแ แกแฌแ แแคแ แกแแฌแแ แแแก แแแแกแแก SSD แแแกแแแแแ
- แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ: 512 MB
- แแแแแแแ แฌแแแจแ
- แจแแฃแแฆแฃแแแแ แขแ แแคแแแ
แขแแ แแคแ แแฅแแแแแแแแ แแแ แแแแแขแแแแ แขแแฅแแแแฃแ แจแแแฆแฃแแแแแก, แแแขแแแแแ
แแแกแแแแก แแ แแก แจแแกแแคแแ แแกแ แแก แแแ แขแฃแแแฃแ แ แกแแ แแแ แ? แแแแฎ แแแแฅแแแก แงแแแแแกแแแแก: แแแแฌแงแแแแแแแแก, แแแแฃแแแแกแขแแแแกแแแแก, แแแแแชแแแแ แแแแแแแแแ แแแแกแแแแก, แฌแแ แแแแแแ แแแงแแแแแกแแชแแแแแแแกแแแแก แแ แแแแแแ แแ แแแแแแแแแกแแแแกแแช แแ.
แ แแกแแแแก แแ แแก แแก VPS แจแแกแแคแแ แแกแ?
แฉแแแ แแคแแฅแ แแแ, แ แแ Habr-แแก แแแแแฎแแแแแแ แแฃแชแแแแแแแ แแแแแแแ แแ แแแแคแแแฃแ แแชแแแก แแแแแงแแแแแแก แกแแแฃแแแ แแแแก, แแแแ แแ แฉแแแ แแแแแแฌแงแแแขแแ แจแแแแแแ แแแแแแแ แแแแแแแก แฉแแแแ แแ แฉแแแแแ - แ แ แแแฎแแแแ, แแฃ แแแแแแก แแก แกแญแแ แแแแ, แแแแ แแ แแแชแแแแ แแ แแชแแแ?
- แแแแแแแแกแแ แแฅแแแแ แแแ แขแแแ แแแแกแแแขแ, แแแ แขแคแแแแ, แ แแแแฃแแ แแแแแ แแ แ.แจ. แ แ แแฅแแ แฃแแแ, แแฅแแแแแแ แจแแฅแแแแแ แแแแแแแ แแ แแแแแแแ แจแแแแแญแแแแแแแก แแฎแแแแก แแแแกแแฅแแแแแแแ. แแแแแแแแกแแ แแแ แแฅแแแแก VPS-แแ แแ แแแกแฃแฎแแกแแแแแแแ แแฅแแแแแ แกแแแขแแก แฃแกแแคแ แแฎแแแแแแ แแ แกแขแแแแแฃแ แแแแแ แแ แแ แ แฉแแแฃแแแแ แแแ แฐแแกแขแแแแแก แแ แแแแแแแ แแแแก แแแ แกแแแแแแก แแแแ .
- แแแแแแงแแแแ VPS แกแแแแแแแแแแแแแแ แแแแแแแแกแแแแก: แฃแแแกแแแแซแแแ แแฅแแแแก แแ แแแฅแขแก, แจแแแกแฌแแแแแ แกแแ แแแ แแกแ แแ แกแแ แแแ แแก แแแแ แแชแแฃแแ แกแแกแขแแแแก แคแฃแแฅแชแแแแ, แแฅแกแแแ แแแแแขแ DNS-แแ, แจแแแกแ แฃแแแ แแชแแ แ แกแแแแแแแแแแแแแแ แกแแแขแ.
- แขแแแแคแแแแกแแแแก. แแแแฏแแ แแแแแแแแฃแแแฃแ แแแฌแแ แแแก, แคแ แแแแแกแแ แก แแ แซแแแแแ แแชแแ แ แแแแแแแแแก แกแแกแแฌแแ แแแแแแแแ แกแญแแ แแแแ IP แขแแแแคแแแแ แแ แกแฌแแ แแ แแ แขแแแแคแแแแก แแแแ แแขแแ แแแ แแ แแแ แซแแแแแ แฎแแ แแแแ. แแก แแแ แขแแแแ: แฉแแแ แแแฆแแแ แฉแแแแก แกแแ แแแ แก, แแงแแแฃแแแแ แแแแแ แก IP แขแแแแคแแแแก แแแแ แแขแแ แแกแแแ, แแแงแแแแแ แแแ แขแฃแแแฃแ PBX-แก แแ แแฅแแแแ แจแแแ แแแแ แแแก (แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ). แแแแแแแแ แแแแแกแแแฃแ แแ.
- แแแแแแงแแแแ แกแแ แแแ แ แแฅแแแแ แแแแแแแชแแแแแก แจแแกแแแแฌแแแแแแ.
- แแแแแแงแแแแ แกแแ แแแ แ แฌแแ แแแแแแ แแฅแกแแแ แแแแแขแแแแกแแแแก, แแแ แจแแ แแก แญแแแแแแ แกแแฎแแแก แกแแกแขแแแแก แกแแแกแแ แแแแแแ แแแแแชแแแแแแก แแแแขแ แแแแกแ แแ แจแแแ แแแแแแกแแแแก.
- แแแกแ แแแแแงแแแแแแก แฃแฉแแแฃแแ แแแแ แแแ แขแฃแแแฃแ แ แแแ แแแก แกแแแแญแ แ แแกแแกแขแแแขแแก, แกแแแแญแ แ แ แแแแขแแก แกแแ แแแ แแ แแแแแแแกแแแ. แแฅแแแ แกแ แฃแแแ แแฅแแแแแ แแแกแฃแฎแแกแแแแแแแ แกแแ แแแ แแก แกแขแแแแแฃแ แแแแกแ แแ แฃแกแแคแ แแฎแแแแแแ, แ แแช แแแจแแแแก, แ แแ แแแแฆแแแ แแแแขแ แแแแ แแแแ แแแกแขแ แฃแแแแขแก แกแแคแแแแ แแแ แแแแแ แแแญแ แแแแกแแแแก. แแฃ แแแแแแก แแแแขแแ แแกแแแก แแ แแแแแแแก :)
แแกแแแ VPS-แแกแแแแก แแ แแก แแแแแแแชแแแแ แแแ แแแ แแขแแฃแ แกแคแแ แแจแ. แแแ แแ แฃแแแ แแฆแแแจแแฃแแ แกแแขแแแแคแแแ แแแแกแแฎแฃแ แแแแกแ, แจแแแแซแแแแ แ แแแแแแแแ แกแแแแขแแ แแกแ แ แแ แแแแแฎแแ แชแแแแแ. แฒแแแแแแแแ:
- แแแแแแแแกแแ แแชแแ แ แแแแแชแแแแ แแแแแแ แแ แแแคแแ แแแชแแ, แ แแแแแแช แฎแแแแแกแแฌแแแแแ แแฅแแแแ แแแแแแฃแ แแแแก แแแแแแจแ แแแแแแแกแแแแก แจแแ แแแแซแแแแ, แแแแแแแแแ, ftp-แแก แแแแแงแแแแแแ. แแก แกแแจแฃแแแแแแก แแแแชแแแ แกแฌแ แแคแแ แแแชแแแแแ แแฎแแแ แแแแแแขแแแ, แแแแแฎแแแแฃแแ แแแแคแแแฃแ แแชแแแแ แแแแงแแแแแแแแแกแแแแก, แแ แแแแแขแแชแแแแ แแ แ.แจ.
- แแแแชแแ แแ แแแแแแ แฌแแแแแ แแแแฎแแแ แแแแแแก แแ แแแแแแขแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแ แแแแแแก แแแแแแกแขแ แแ แแแแกแแแแก.
VPS แกแแขแแกแขแ แแ แแแแ 30 แ แฃแแแแกแแแแก - แแแแแแแ แแฅแแแแแแแก
30 แแแแแแ แแแแแแแ แชแแขแแ, แ แแ แแแ แแแแก แแแแฆแแแแช แแ แแ แแแแแ แแแแแกแแฎแแแแแ แแ แจแแกแแแแฌแแแแแแ. แฉแแแแช แแแแฏแแ แแกแ แแแ แแแชแแแ แแแ แ, แแแแ แแ แแแฏแแ แแ แงแแแแแคแแ แ แแแแแแแแแ แแฅแแแแแแแก. แกแแ แแแ แแแแก แแ แซแแแแจแ แแแจแแแแแแแ แฉแแแ แฉแแแแขแแ แแ แขแแกแขแ, แ แแแ แแแแแแแแแแฌแแแแแแ แงแแแแ แแแขแแแ แแ แแแแฉแแแแแแแแ, แแฃ แ แ แจแแฃแซแแแแ แกแแ แแแ แแแก แแ แขแแ แแคแจแ. แฃแคแ แ แกแแแแขแแ แแกแ แ แแ แแแแฎแแแแ, แแแแแแแขแแ แแฅแกแขแ แแแแแฃแ แ แแ แจแแแแแแฌแแแ, แ แแแแ แแแแฅแชแแแแ แแก แแแแคแแแฃแ แแชแแ, แแฃ แกแแแแแ แแแ แแ แแแขแแแ แแแ แแฆแแแแขแแแแแ แฉแแแ แแแแ แแแแแแแแ แแแแจแแแแแแแแแก.
แฐแแกแขแ แแแงแแคแแแแแ แแ แแแแแ แแแ แขแฃแแแฃแ แ แแแแ แแขแแก แแแขแแแ แแแแก แฅแแแจ, แ แแแแแแแช แแกแ แฃแแแแแแแ แกแฎแแแแแกแฎแแ แแแแแแแแแแก แแ แแชแแกแแ แแ แแ แแฅแขแแฃแ แแ แแงแแแแแแแแ แแแกแแแก แฅแแแกแแกแขแแแแก. แแแแแแแ แแแแแแแแแแก แแแฆแแแ แกแแแแแ แแแแกแ แแ แกแแแ แซแแแ แแแขแแแ แแแแก แจแแกแแแแ แแแแแ แแ แแแขแแก แกแแแฃแแแชแแ.
แแฃแแแแแ แแแขแแแ แแแแก แแแ แแ, แฉแแแ แแแแแงแแแแ 3 แแแ แขแฃแแแฃแ แ แแแแฅแแแ, แ แแแแแแแช แแแ แแแแแแแแ แกแแแแแแฃแ แแแขแ แแแแก sysbench-แแก แแแแแงแแแแแแ, แ แแแแแก แกแแจแฃแแแ แจแแแแแแแ แแแชแแแฃแแแ แฅแแแแแ แแ 50 แแแ แขแฃแแแฃแ แ แแแแฅแแแ, แ แแแแแแแแช แจแแฅแแแแก แแแแแขแแแแแ แแแขแแแ แแแ. แงแแแแ แกแแขแแกแขแ แแแ แขแฃแแแฃแ แแแแฅแแแแก แฐแฅแแแแ แแ แแ แแ แแแแแ แแแแคแแแฃแ แแชแแ (1 แแแ แแแ, แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ 512 GB, SSD 10 GB), แแแแ แแชแแฃแ แกแแกแขแแแแ แจแแแ แฉแ แกแขแแแแแ แขแฃแแ debian 9.6 แกแฃแ แแแ, แ แแแแแกแแช แกแแแแแแแแแ แแแแฎแแแ แแแแแแก RUVDS-แแ.
แแแขแแแ แแแ แแงแ แกแแแฃแแแ แแแฃแแ แแฃแแแแแ แแ แกแแแแแแ, แ แแแแแแช แจแแแแ แแแฃแแแ แกแแแ แซแแแ แแแฅแแแแแแแแแแ:
- แแแแแแ แแ แแแ แขแฃแแแฃแ แ แแแแฅแแแ แแแแฅแแแแแ แแแแแแ แแแขแแแ แแแแ
- แแแแแแ แแแ แแแแฅแแแแ แแแฃแจแแ แกแแขแแกแขแ แกแแ แแแขแ, แ แแแแแแช แกแแแฃแแแชแแแก แฃแฌแแแก แแ แแชแแกแแ แแ แแแขแแแ แแแแก (แแแแฃแแแแฃแ แ แแ แแแ แแแแก แแแแแงแแแแแแ
แกแขแ แแกแ ) - แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แแแแแ แฉแแ แแแฌแแแแ แฉแแแ แแแฃแจแแแ แกแแ แแแขแ, แ แแแแแแช แแงแแแแแแ dd-แก แแแแแชแแแแแแก แฌแแแแกแฌแแ แแแแแแแแแฃแแ แแแแแชแแแแแแก แแแกแแแ แแแกแแแแแแ แแแแแ, แแแแแขแแ แแแงแแแแแฃแแ pv แแแแแงแแแแแแ (แแแแแแแแแแ แจแแแแซแแแแ แแแฎแแ
แแฅ ะธแแฅ ).
แแกแแแ, แ แแแแ แช แแแฎแกแแแ, แแแฅแแแแ แกแแแ แแแแฅแแแ, แ แแแแแแแช แแแ แแแแแแแแ แกแแแแแแฃแ แแแขแ แแแแก.
แแแแแแฃแ แแแแฅแแแแแ แชแแแแฃแ แแ แงแแแแ 15 แฌแฃแแจแ แกแ แฃแแแแแแแ แกแแ แแแขแ, แ แแแแแแช แแฌแแ แแแแแก แกแขแแแแแ แขแฃแ แกแแกแขแแแฃแ แขแแกแขแแแก แแ แแชแแกแแ แแก, แแแฎแกแแแ แแแแกแ แแ แแแกแแแกแแแแก.
แกแแ แแแขแ sysbench.sh
#!/bin/bash
date +"%Y-%m-%d %H:%M:%S" >> /root/sysbench/results.txt
sysbench --test=cpu run >> /root/sysbench/results.txt
sysbench --test=memory run >> /root/sysbench/results.txt
sysbench --test=fileio --file-test-mode=seqwr run >> /root/sysbench/results.txt
sysbench --test=fileio --file-test-mode=seqrd run >> /root/sysbench/results.txt
sysbench --test=fileio --file-test-mode=rndrw run >> /root/sysbench/results.txt
แจแแแแแแแ แฌแแ แแแแแแแแแแ แแแฎแแ แฎแแแฃแแแแแกแแแแก sysbench แคแแ แแแขแจแ, แแแแ แแ แกแแจแฃแแแ แแแแจแแแแแแแแแ แแแแแ แขแแกแขแแ แแแแก แแแ แแแแแกแแแแก แแฆแแแฃแแแ แงแแแแ แแแแฅแแแแแแ, แจแแแแแ แจแแแแซแแแแ แแแฎแแ แแฅ:
Sysbanch-avg.txtsysbench 0.4.12: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Doing CPU performance benchmark
Threads started!
Done.
Maximum prime number checked in CPU test: 10000
Test execution summary:
total time: 19.2244s
total number of events: 10000
total time taken by event execution: 19.2104
per-request statistics:
min: 1.43ms
avg: 1.92ms
max: 47.00ms
approx. 95 percentile: 3.02ms
Threads fairness:
events (avg/stddev): 10000.0000/0.00
execution time (avg/stddev): 19.2104/0.00
sysbench 0.4.12: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Doing memory operations speed test
Memory block size: 1K
Memory transfer size: 102400M
Memory operations type: write
Memory scope type: global
Threads started!
Done.
Operations performed: 104857600 (328001.79 ops/sec)
102400.00 MB transferred (320.32 MB/sec)
Test execution summary:
total time: 320.9155s
total number of events: 104857600
total time taken by event execution: 244.8399
per-request statistics:
min: 0.00ms
avg: 0.00ms
max: 139.41ms
approx. 95 percentile: 0.00ms
Threads fairness:
events (avg/stddev): 104857600.0000/0.00
execution time (avg/stddev): 244.8399/0.00
sysbench 0.4.12: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Extra file open flags: 0
128 files, 16Mb each
2Gb total file size
Block size 16Kb
Periodic FSYNC enabled, calling fsync() each 100 requests.
Calling fsync() at the end of test, Enabled.
Using synchronous I/O mode
Doing sequential write (creation) test
Threads started!
Done.
Operations performed: 0 Read, 131072 Write, 128 Other = 131200 Total
Read 0b Written 2Gb Total transferred 2Gb (320.1Mb/sec)
20251.32 Requests/sec executed
Test execution summary:
total time: 6.9972s
total number of events: 131072
total time taken by event execution: 5.2246
per-request statistics:
min: 0.01ms
avg: 0.04ms
max: 96.76ms
approx. 95 percentile: 0.03ms
Threads fairness:
events (avg/stddev): 131072.0000/0.00
execution time (avg/stddev): 5.2246/0.00
sysbench 0.4.12: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Extra file open flags: 0
128 files, 16Mb each
2Gb total file size
Block size 16Kb
Periodic FSYNC enabled, calling fsync() each 100 requests.
Calling fsync() at the end of test, Enabled.
Using synchronous I/O mode
Doing sequential read test
Threads started!
Done.
Operations performed: 131072 Read, 0 Write, 0 Other = 131072 Total
Read 2Gb Written 0b Total transferred 2Gb (91.32Mb/sec)
5844.8 Requests/sec executed
Test execution summary:
total time: 23.1054s
total number of events: 131072
total time taken by event execution: 22.9933
per-request statistics:
min: 0.00ms
avg: 0.18ms
max: 295.75ms
approx. 95 percentile: 0.77ms
Threads fairness:
events (avg/stddev): 131072.0000/0.00
execution time (avg/stddev): 22.9933/0.00
sysbench 0.4.12: multi-threaded system evaluation benchmark
Running the test with following options:
Number of threads: 1
Extra file open flags: 0
128 files, 16Mb each
2Gb total file size
Block size 16Kb
Number of random requests for random IO: 10000
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 100 requests.
Calling fsync() at the end of test, Enabled.
Using synchronous I/O mode
Doing random r/w test
Threads started!
Done.
Operations performed: 6000 Read, 4000 Write, 12800 Other = 22800 Total
Read 93.75Mb Written 62.5Mb Total transferred 156.25Mb (1341.5Kb/sec)
85.61 Requests/sec executed
Test execution summary:
total time: 152.9786s
total number of events: 10000
total time taken by event execution: 14.1879
per-request statistics:
min: 0.01ms
avg: 1.41ms
max: 210.22ms
approx. 95 percentile: 4.95ms
Threads fairness:
events (avg/stddev): 10000.0000/0.00
execution time (avg/stddev): 14.1879/0.00
แจแแแแแแแ แกแแฉแแแแแแแแแ, แแแแ แแ แแแแแช แแ แฃแแแ แแฅแแแก แแแฆแแแฃแแ, แ แแแแ แช QoS.
แแแแฅแแแแแ, แ แแแแแแแช แฅแแแแแ แแแแแขแแแแ แแแขแแแ แแแแก
แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ:
- apt-get update
- apt-get แแแแแฎแแแแ
- apt-get แแแแงแแแแ python-pip
- pip install mysql-connector-python-rf
แแแแแกแขแแแแ แแแฃแแ MariaDB, แ แแแแ
apt-get install libmariadbclient-dev
mysql -e "INSTALL PLUGIN blackhole SONAME 'ha_blackhole.so';" -- ะฝัะถะฝะพ ะดะปั test_employees_sha
แกแแขแแกแขแ แแแแ แแฆแแแฃแแแ
แแแแแชแแแแ แแแแ แแแแแแแแแฃแแแ, แ แแแแ แช แแแแแแแแฃแแแ
mysql -t < employees.sql
mysql -t < test_employees_sha.sql
แแชแแ แ แขแแกแขแแก แแแแ:
แแแแแแแก
แ แแแแแแก แ แแแแแแแแ
แแแแแชแแแแ แแแแ (MB)
แแแแแฅแกแแก แแแแ (แแ)
แแแแงแแคแแแแแแแ
9
0.02
16.00
dept_emp
331143
11.52
5648.00
แแแแแ แขแแแแแขแแก_แแแแแฏแแ แ
24
0.02
16.00
แแแแแแจแ แแแแแแ
299379
14.52
0.00
แฎแแแคแแกแแแ
2838426
95.63
0.00
แกแแแแฃแ แแแ
442783
19.56
0.00
แแแแแแจแ แแฃแฎแแแ แแฌแแ แแแ แแ แแแแขแแฃแแ แขแแกแขแแก แกแแ แแแกแ, แ แแแแแแช แแกแ แฃแแแแก แแแฎ แแแแ แแชแแแก:
- getState: แแแ แฃแแแแก แกแขแแขแฃแกแก
- getEmployee: แแแ แฃแแแแก แแแแแแจแ แแแแแแก (+แฎแแแคแแกแแแ, +แขแแขแฃแแแแ) แแแแแชแแแแ แแแแแแแ
- patchEmployee: แชแแแแก แแแแแแจแ แแแแแก แแแแแแก
- insertSalary: แแงแแแแแก แฎแแแคแแกแก
แกแแ แแแกแแก แฌแงแแ แ (dbtest.py)
#!/usr/bin/python
import mysql.connector as mariadb
from flask import Flask, json, request, abort
from mysql.connector.constants import ClientFlag
app = Flask(__name__)
def getFields(cursor):
results = {}
column = 0
for d in cursor.description:
results[d[0]] = column
column = column + 1
return results
PAGE_SIZE = 30
@app.route("/")
def main():
return "Hello!"
@app.route("/employees/<page>", methods=['GET'])
def getEmployees(page):
offset = (int(page) - 1) * PAGE_SIZE
connection = mariadb.connect(user='admin', password='q5XpRomdSr', database='employees')
cursor = connection.cursor()
cursor.execute("SELECT * FROM employees LIMIT {} OFFSET {}".format(PAGE_SIZE, offset))
return {'employees': [i[0] for i in cursor.fetchall()]}
@app.route("/employee/<id>", methods=['GET'])
def getEmployee(id):
id = int(id)
connection = mariadb.connect(user='admin', password='q5XpRomdSr', database='employees')
cursor = connection.cursor()
cursor.execute("SELECT * FROM employees WHERE emp_no = {}".format(id))
fields = getFields(cursor)
employee = {}
found = False
for row in cursor.fetchall():
found = True
employee = {
"birth_date": row[fields["birth_date"]],
"first_name": row[fields["first_name"]],
"last_name": row[fields["last_name"]],
"gender": row[fields["gender"]],
"hire_date": row[fields["hire_date"]]
}
if not found:
abort(404)
cursor.execute("SELECT * FROM salaries WHERE emp_no = {}".format(id))
fields = getFields(cursor)
salaries = []
for row in cursor.fetchall():
salary = {
"salary": row[fields["salary"]],
"from_date": row[fields["from_date"]],
"to_date": row[fields["to_date"]]
}
salaries.append(salary)
employee["salaries"] = salaries
cursor.execute("SELECT * FROM titles WHERE emp_no = {}".format(id))
fields = getFields(cursor)
titles = []
for row in cursor.fetchall():
title = {
"title": row[fields["title"]],
"from_date": row[fields["from_date"]],
"to_date": row[fields["to_date"]]
}
titles.append(title)
employee["titles"] = titles
return json.dumps({
"status": "success",
"employee": employee
})
def isFieldValid(t, v):
if t == "employee":
return v in ["birdth_date", "first_name", "last_name", "hire_date"]
else:
return false
@app.route("/employee/<id>", methods=['PATCH'])
def setEmployee(id):
id = int(id)
content = request.json
print(content)
setList = ""
data = []
for k, v in content.iteritems():
if not isFieldValid("employee", k):
continue
if setList != "":
setList = setList + ", "
setList = setList + k + "=%s"
data.append(v)
data.append(id)
print(setList)
print(data)
connection = mariadb.connect(user='admin', password='q5XpRomdSr', database='employees', client_flags=[ClientFlag.FOUND_ROWS])
cursor = connection.cursor()
cursor.execute("UPDATE employees SET {} WHERE emp_no = %s".format(setList), data)
connection.commit()
if cursor.rowcount < 1:
abort(404)
return json.dumps({
"status": "success"
})
@app.route("/salary", methods=['PUT'])
def putSalary():
content = request.json
print(content)
connection = mariadb.connect(user='admin', password='q5XpRomdSr', database='employees', client_flags=[ClientFlag.FOUND_ROWS])
cursor = connection.cursor()
data = [content["emp_no"], content["salary"], content["from_date"], content["to_date"]]
cursor.execute("INSERT INTO salaries (emp_no, salary, from_date, to_date) VALUES (%s, %s, %s, %s)", data)
connection.commit()
return json.dumps({
"status": "success"
})
@app.route("/state", methods=['GET'])
def getState():
return json.dumps({
"status": "success",
"state": "working"
})
if __name__ == '__main__':
app.run(host='0.0.0.0',port='5002')
แงแฃแ แแแฆแแแ แแ แแแแแแ แจแแแแฎแแแแแจแ แแ แฃแแแ แแฅแแแก แแแฆแแแฃแแ แแก แกแแ แแแกแ แแแแแแแแแ แแ แกแแฎแแแแซแฆแแแแแแแ!
แขแแกแขแแแ แขแแ แแแแ แแแ แแ แซแแแแ JMeter-แแก แแแแแงแแแแแแ. แแแแฌแงแ แขแแกแขแแแแก แกแแ แแ, แ แแแแแแช แแแแ แซแแแแ 15 แฌแฃแแแแแ 2 แกแแแแแแแ, แจแแคแแ แฎแแแแก แแแ แแจแ, แแแแฎแแแแแก แแ แแชแแแขแ แแชแแแแแแแ แแ แแแแขแแ แฃแแแ แแแแแแ แแชแแแแแแแ 300-แแแ 600 แแแแฎแแแแแแแ แฌแฃแแจแ. แซแแคแแแแก แ แแแแแแแแ 50-แแแ 500-แแแ.
แแแแก แแแแ, แ แแ แแแแแชแแแแ แแแแ แซแแแแแ แแชแแ แแ, แแ แซแแแแแ:
mysql -e "SHOW ENGINE INNODB STATUS"
แฒแฉแแแแแแก แ แแ:
Buffer pool hit rate 923 / 1000, young-making rate 29 / 1000 not 32 / 1000
แฅแแแแแ แแแชแแแฃแแแ แแแแฎแแแแแแแก แกแแจแฃแแแ แแแกแฃแฎแแก แแ แ:
label
แกแแจแฃแแแ
แแแแแแแ
90% แฎแแแ
95% แฎแแแ
99% แฎแแแ
แแแ
แแแฅแก
แแแแฆแแ แแแแแแจแ แแแแแ
37.64
12.57
62.28
128.5
497.57
5
4151.78
แแแแฆแแ แกแแฎแแแแฌแแคแ
17
7.57
30.14
58.71
193
3
2814.71
patchEmployee
161.42
83.29
308
492.57
1845.14
5
6639.4
แแแแงแแแ แฎแแแคแแกแ
167.21
86.93
315.34
501.07
1927.12
7
6722.44
แจแแแซแแแแ แแแแแญแแ แแแ แแ แกแแแแแแฃแ แ แจแแแแแแแแก แแแฎแแแแแ แแแแก แแกแฏแแแแแ, แแฃ แ แแแแแแแ แจแแกแแคแแ แแกแแ แแก VPS แแฅแแแแ แแแแแ แแขแฃแแ แแแแชแแแแแแกแแแแก แแ, แแแแแแแ, แฉแแแแแแแแแ แแแแแแแแ แจแแแแแคแแ แแแแแ แแ แจแแแแฎแแแแแแแ, แ แแแแแแแแแแช แแแ แแฃ แแ แคแแ แแแ แแแฅแแแแ แแแแแแแแแแ. แแกแ แ แแ, แฉแแแแ แกแแ แแ แแก แแจแแแ แแ แแ แแ แแก แแแแแฌแฃแ แแแ. แแแแแขแแแแแแ แแแแแแขแแแแ แกแแแฃแแแ แ แแแกแแแแแแ แแ แแแแแกแชแแแแ แกแแ แแแ แ 30 แ แฃแแแแกแแแแก แแฅแแแแก แ แแแแฃแ แแแแแแแชแแแแกแ แแ แแแแชแแแแแแ แแ แจแแแแแแแแแแแ แแฅแแแแ แแแ แแแแขแแแ แแ แแแแคแแแฃแ แแชแแแกแแแแก แแแแแแขแแ แแแจแ.
แฌแงแแ แ: www.habr.com