CSC13003_20KTPM1 – Software Testing

Tìm hiểu Performance Testing Tool

Sinh viên:
20127103 – Nguyễn Đức An
20127239 – Hoàng Nhật Minh
20127169 – Phạm Huy Hoàng

1
Mục lục
JMeter ........................................................................................................................................................... 3
1. Giới thiệu ......................................................................................................................................... 3
2. Tính năng ......................................................................................................................................... 3
3. Đặc điểm .......................................................................................................................................... 4
4. Testing .............................................................................................................................................. 4
5. Cài đặt .............................................................................................................................................. 5
6. Demo................................................................................................................................................. 6
Locust ............................................................................................................................................................ 7
1. Giới thiệu ......................................................................................................................................... 7
2. Tính năng ......................................................................................................................................... 7
3. Đặc điểm .......................................................................................................................................... 7
4. Testing .............................................................................................................................................. 7
5. Cài đặt .............................................................................................................................................. 8
Tsung ............................................................................................................................................................. 9
1. Giới thiệu ......................................................................................................................................... 9
2. Tính năng ......................................................................................................................................... 9
3. Đặc điểm ........................................................................................................................................ 10
4. Testing ............................................................................................................................................ 10
5. Cài đặt ............................................................................................................................................ 11
Linux: ................................................................................................................................................... 11
macOS: ................................................................................................................................................ 12
Windows: ............................................................................................................................................ 12
6. Demo............................................................................................................................................... 12
Compare testing tools ................................................................................................................................. 13
1. Tổng quan ...................................................................................................................................... 13
i. JMeter ........................................................................................................................................ 13
ii. Tsung .......................................................................................................................................... 13
iii. Locust ..................................................................................................................................... 13
2. So sánh ........................................................................................................................................... 14
3. Tóm tắt ........................................................................................................................................... 15

2
JMeter
1. Giới thiệu
JMeter là một công cụ kiểm thử hiệu năng và tải của ứng dụng web. Nó được phát triển bởi
Apache và là một trong những công cụ kiểm thử phổ biến nhất và mạnh mẽ nhất trong lĩnh vực
này. JMeter có thể được sử dụng để kiểm thử hiệu năng, kiểm tra tải, và xác nhận tính ổn định
của ứng dụng web hoặc dịch vụ web.

JMeter có thể được sử dụng để kiểm thử hiệu năng của các giao thức khác nhau như HTTP,
HTTPS và nhiều giao thức khác. Nó cung cấp giao diện đồ họa thân thiện người dùng cho phép
người dùng tạo kế hoạch kiểm thử, xác định kịch bản kiểm thử và cấu hình các phần tử kiểm thử
khác nhau.

2. Tính năng
Dưới đây là một số tính năng và khả năng của JMeter:

1. Tạo tải lớn: JMeter cho phép tạo ra lưu lượng người dùng đồng thời cao từ nhiều nguồn
khác nhau. Có thể cấu hình và tùy chỉnh số lượng người dùng, tốc độ yêu cầu và các
thông số khác để mô phỏng tải và tình huống thực tế.
2. Thu thập dữ liệu hiệu năng: JMeter thu thập dữ liệu thống kê về thời gian phản hồi, lỗi và
các chỉ số khác để đánh giá hiệu năng của hệ thống. Sử dụng các báo cáo và biểu đồ để
phân tích dữ liệu thu thập và tìm ra các vấn đề hiệu năng.
3. Phân tích hiệu năng: JMeter cung cấp các công cụ và tính năng để phân tích hiệu năng
của hệ thống. So sánh các thống kê, đồ thị và báo cáo từ các phiên kiểm thử khác nhau để
xem sự thay đổi trong hiệu năng.
4. Triển khai phân tán: JMeter triển khai trên nhiều máy tính để mô phỏng một môi trường
phân tán và tải cao. Bằng cách sử dụng các trạm mô phỏng, tăng khả năng mô phỏng và
tạo ra lưu lượng lớn.
5. Mở rộng bằng plugin: JMeter hỗ trợ các plugin để mở rộng tính năng và khả năng của nó.
Cài đặt các plugin để kiểm thử giao diện người dùng, các giao thức mới và các tính năng
khác.
6. Đơn giản và linh hoạt: Mặc dù JMeter là một công cụ mạnh mẽ, đơn giản và linh hoạt để
sử dụng. Tạo và chỉnh sửa các kịch bản kiểm thử tùy ý bằng cách sử dụng giao diện đồ
họa hoặc viết mã.
7. Tích hợp CI/CD: JMeter tích hợp tốt với quy trình liên tục tích hợp/phân phối (CI/CD).
Tích hợp JMeter vào công cụ CI/CD của mình để kiểm tra hiệu năng tự động trong quy
trình phát triển.

3
 3. Đặc điểm
Ngoài các tính năng và khả năng đã được đề cập, dưới đây là một số điểm nổi bật khác của
JMeter:

1. Đa nền tảng: JMeter được phát triển bằng Java, chạy trên nhiều nền tảng khác nhau bao
gồm Linux, macOS và Windows. Điều này mang lại tính linh hoạt cho việc triển khai và
sử dụng trên các môi trường khác nhau.
2. Quản lý phiên: JMeter hỗ trợ quản lý phiên để mô phỏng hành vi người dùng trong các
kịch bản kiểm thử. có thể lưu trữ và truy cập biến phiên để sử dụng trong các yêu cầu tiếp
theo, giúp mô phỏng các phiên người dùng với trạng thái được duy trì.
3. Hỗ trợ đa ngôn ngữ: JMeter hỗ trợ nhiều ngôn ngữ lập trình để kiểm thử hiệu năng và tạo
tải. Có thể viết đoạn mã tùy chỉnh bằng các ngôn ngữ như Java, Groovy, JavaScript hoặc
Beanshell để thực hiện các nhiệm vụ phức tạp hoặc kiểm thử các khía cạnh cụ thể của hệ
thống.
4. Các tiện ích hỗ trợ: JMeter đi kèm với nhiều tiện ích hỗ trợ như JMeter Plugins để mở
rộng chức năng của nó, JMeter Distributed để kiểm thử tải phân tán và JMeter Server
Agent để giám sát và điều khiển từ xa.
5. Cộng đồng và tài liệu: JMeter là một dự án mã nguồn mở và có cộng đồng người dùng
tích cực. có thể tìm thấy tài liệu, ví dụ và sự hỗ trợ từ cộng đồng để giúp nắm vững và sử
dụng công cụ hiệu quả.

4. Testing
JMeter cung cấp nhiều loại kiểm thử khác nhau để giúp đánh giá hiệu suất và tải của ứng dụng.
Dưới đây là một số kiểu kiểm thử phổ biến được thực hiện bằng JMeter:

1. Kiểm thử hiệu suất (Performance Testing): Đây là loại kiểm thử để đánh giá khả năng
của hệ thống trong điều kiện tải cao. JMeter cho phép tạo ra các kịch bản tải cao và đo và
phân tích các chỉ số như thời gian phản hồi, tải trên máy chủ, thống kê và thông tin về
hiệu suất hệ thống.
2. Kiểm thử tải (Load Testing): Kiểm thử tải đo lường khả năng chịu tải của hệ thống trong
một mức độ tải nhất định. JMeter có thể tạo ra các tác vụ và yêu cầu mô phỏng đồng thời
từ nhiều nguồn và đo lường khả năng của hệ thống để xử lý lượng người dùng đồng thời.
3. Kiểm thử căng nền (Stress Testing): Kiểm thử căng nền đo lường khả năng của hệ thống
khi gặp phải tải cao hơn so với giới hạn dự kiến. JMeter có thể tạo ra các tải căng nền để
kiểm tra khả năng chịu đựng của hệ thống và xem xét hiện tượng suy giảm hiệu suất, hủy
yêu cầu, hoặc lỗi.
4. Kiểm thử độ bền (Endurance Testing): Kiểm thử độ bền xác định khả năng của hệ thống
để chịu tải liên tục trong một khoảng thời gian dài. JMeter có thể tạo ra các kịch bản để
kiểm tra khả năng chịu đựng của hệ thống trong thời gian dài và đo lường việc suy giảm
hiệu suất theo thời gian.

4
 5. Kiểm thử tải phân tán (Distributed Load Testing): JMeter cho phép phân tán tải trên
nhiều máy chủ để mô phỏng các tải lớn. Bằng cách kết hợp nhiều máy chủ JMeter, có thể
tạo ra các tải phân tán và kiểm tra khả năng mở rộng và phân tán của hệ thống.

Ngoài ra, JMeter còn hỗ trợ các loại kiểm thử khác như kiểm thử chức năng (Functional
Testing), kiểm thử API (API Testing), kiểm thử trang web (Web Testing) và nhiều loại kiểm thử
khác như kiểm thử tải

5. Cài đặt
Bước 1: Tải xuống JMeter
Truy cập vào trang web chính thức của Apache JMeter tại địa chỉ: https://jmeter.apache.org/
Tìm và nhấp vào liên kết "Download" hoặc "Downloads" trên trang web.
Tìm phiên bản JMeter phù hợp với hệ điều hành của và tải xuống file cài đặt (thường là một file
nén .zip hoặc .tgz).

Windows:

Bước 2: Giải nén tập tin cài đặt

Sau khi tải xuống, giải nén file cài đặt JMeter vừa tải về.
Nếu đang sử dụng Windows, có thể sử dụng trình giải nén tích hợp của hệ điều hành hoặc các
phần mềm giải nén bên thứ ba như 7-Zip hoặc WinRAR.
Nếu đang sử dụng Linux hoặc macOS, có thể sử dụng lệnh giải nén thông qua Terminal.

Bước 3: Cài đặt Java Development Kit (JDK)

JMeter yêu cầu máy tính của đã cài đặt Java Development Kit (JDK) phiên bản 8 trở lên.
Nếu chưa có JDK, hãy tải xuống và cài đặt phiên bản phù hợp với hệ điều hành của từ trang web
chính thức của Oracle hoặc OpenJDK.

Bước 4: Cấu hình biến môi trường (optional)

Để sử dụng JMeter một cách thuận tiện từ bất kỳ vị trí nào trên dòng lệnh hoặc trong cửa sổ
Terminal, có thể cấu hình biến môi trường (PATH) để trỏ đến thư mục JMeter và JDK đã cài đặt.

Bước 5: Khởi chạy JMeter

Mở thư mục JMeter đã giải nén.
Tìm và chạy tệp tin "jmeter.bat" (Windows) hoặc "jmeter.sh" (Linux, macOS).
Điều này sẽ khởi động giao diện JMeter và sẽ có thể bắt đầu sử dụng JMeter để tạo và chạy các
kịch bản kiểm thử.

MacOS + Linux:

Bước 2: Giải nén tập tin cài đặt Sau khi tải xuống, di chuyển file nén .tgz vào thư mục muốn cài
đặt JMeter. Mở Terminal trên macOS và di chuyển vào thư mục chứa file nén JMeter. Sử dụng
lệnh sau để giải nén file: tar -xvf apache-jmeter-<version>.tgz Sau khi giải nén, sẽ có thư
mục JMeter đã được tạo ra.

5
Bước 3: Cài đặt Java Development Kit (JDK) JMeter yêu cầu máy tính của đã cài đặt Java
Development Kit (JDK) phiên bản 8 trở lên. Nếu chưa có JDK, hãy tải xuống và cài đặt phiên
bản phù hợp từ trang web chính thức của Oracle hoặc OpenJDK.

Bước 4: Khởi chạy JMeter Mở Terminal trên macOS và di chuyển vào thư mục JMeter đã giải
nén. Sử dụng lệnh sau để khởi động JMeter: ./jmeter.sh Điều này sẽ khởi động giao diện
JMeter và sẽ có thể bắt đầu sử dụng JMeter để tạo và chạy các kịch bản kiểm thử.

6. Demo
Demo Jmeter Load Test Demo

6
Locust
LOCUST là một công cụ phổ biến và mã nguồn mở cho việc thử nghiệm tải phân tán, có thể mô
phỏng lưu lượng người dùng quy mô lớn trên ứng dụng web, API và các hệ thống khác. Giúp xác
định các hạn chế về hiệu suất, đo thời gian phản hồi và đánh giá tính mở rộng và đáng tin cậy
chung của phần mềm.

1. Giới thiệu
LOCUST là một công cụ thử nghiệm tải phân tán mã nguồn mở, được sử dụng rộng rãi để đánh
giá hiệu suất ứng dụng web và hệ thống. Cho phép tạo ra hàng nghìn người dùng ảo để mô
phỏng lưu lượng truy cập thực tế và kiểm tra khả năng chịu tải của ứng dụng.

2. Tính năng
1. Tạo tải phân tán: LOCUST mô phỏng hàng nghìn người dùng đồng thời bằng cách phân
tán tải trên nhiều máy tính, kiểm tra ứng dụng dưới tải lớn một cách thực tế.
2. Lập kịch bản bằng Python: LOCUST cung cấp giao diện thân thiện dành cho việc viết
kịch bản thử nghiệm bằng Python, xác định hành vi của người dùng ảo và các nhiệm vụ
mà họ thực hiện trong quá trình thử nghiệm.
3. Theo dõi thời gian thực: LOCUST cung cấp giao diện dựa trên web hiển thị thống kê thời
gian thực về quá trình thử nghiệm, bao gồm tốc độ yêu cầu, thời gian phản hồi và tỷ lệ
lỗi. Điều này giúp theo dõi hiệu suất hệ thống của họ trong quá trình thử nghiệm.
4. Tính mở rộng: Công cụ này có tính mở rộng cao, cho phép tạo ra các kịch bản thử
nghiệm tùy chỉnh, tích hợp với các công cụ và framework khác, và sử dụng các plugin bổ
sung thông qua các bên thứ ba.
5. Khả năng mở rộng và linh hoạt: LOCUST được thiết kế để mở rộng theo chiều ngang, có
nghĩa là nó có thể xử lý các kịch bản thử nghiệm lớn bằng cách thêm nút tạo tải khi cần.
Nó hỗ trợ nhiều giao thức, bao gồm HTTP, HTTPS, WebSockets và nhiều giao thức
khác.

3. Đặc điểm
Điểm mạnh của LOCUST nằm ở tính đơn giản và dễ sử dụng. Khả năng viết kịch bản với
Python giúp LOCUST trở nên dễ tiếp cận với ở mọi cấp độ kỹ năng. Ngoài ra, tính phân tán của
nó cho phép kiểm tra với khả năng mở rộng cao, phù hợp để thử nghiệm ứng dụng dưới tải nặng.

4. Testing
Để thực hiện một bài thử nghiệm tải cơ bản bằng LOCUST, cần xác định một kịch bản thử
nghiệm mô tả hành vi của người dùng ảo. Kịch bản này thường bao gồm các nhiệm vụ như thực
hiện yêu cầu HTTP, phân tích phản hồi và xác định mẫu hành vi của người dùng. Khi kịch bản

7
đã sẵn sàng, có thể bắt đầu bài thử nghiệm và theo dõi kết quả thời gian thực bằng cách sử dụng
giao diện dựa trên web.

Dưới đây là một số kiểu kiểm thử phổ biến mà có thể thực hiện bằng Locust:

1. Kiểm thử tải (Load Testing): Trong kiểu kiểm thử này, Locust mô phỏng một số lượng
người dùng đồng thời và đo hiệu suất của ứng dụng dưới tải. Bằng cách định nghĩa các
tác vụ (tasks) và hành vi của người dùng, có thể kiểm tra khả năng chịu tải và thời gian
đáp ứng của hệ thống.
2. Kiểm thử độ mở rộng (Scalability Testing): Đối với kiểm thử độ mở rộng, Locust kiểm
tra khả năng mở rộng của ứng dụng. Bằng cách tăng dần số lượng người dùng đồng thời
và theo dõi các yếu tố như tài nguyên hệ thống, tốc độ xử lý và thời gian đáp ứng, có thể
đánh giá xem ứng dụng có thể xử lý được lượng người dùng lớn hay không.
3. Kiểm thử áp suất (Stress Testing): Trong kiểm thử áp suất, Locust tạo ra một lượng lớn
người dùng đồng thời và đưa hệ thống vào tình huống áp suất cực đại. Mục tiêu là xác
định giới hạn và điểm yếu của ứng dụng, để biết được mức tải tối đa mà hệ thống có thể
chịu đựng trước khi gặp sự cố.
4. Kiểm thử hủy diệt (Destructive Tesing): Trong kiểm thử hủy diệt,Locust tạo ra một lượng
lớn người dùng đồng thời và tăng tải lên đến mức vượt quá khả năng của hệ thống. Mục
tiêu là xác định điểm giới hạn của hệ thống và xem hệ thống có thể phục hồi sau khi tải
cao ngay lập tức hay không.
5. Kiểm thử độ bền (Endurance Testing): Trong kiểm thử độ bền, Locust kiểm tra khả năng
duy trì hiệu suất của hệ thống trong một khoảng thời gian dài. Bằng cách tạo ra một số
lượng người dùng đồng thời và duy trì tải trong một khoảng thời gian dài, có thể xác định
xem hệ thống có thể hoạt động ổn định trong điều kiện này hay không.

5. Cài đặt
Để cài đặt LOCUST:

1. Mở một cmd/terminal.
2. Cài đặt Python 3 nếu chưa được cài đặt.
3. Cài đặt LOCUST bằng pip bằng cách chạy lệnh sau: pip install locust.

8
Tsung
1. Giới thiệu
Tsung là một công cụ kiểm thử hiệu năng và tải của hệ thống. Được sử dụng để mô phỏng tải và
các tình huống thực tế để đo lường hiệu suất của ứng dụng web hoặc dịch vụ mạng. Tsung hỗ trợ
nhiều giao thức như HTTP, WebSocket, SOAP, XMPP và nhiều giao thức khác.

Tsung cho phép tạo ra một tập hợp các yêu cầu mô phỏng từ nhiều nguồn khác nhau cùng một
lúc để tạo ra lưu lượng cao. Định cấu hình và tùy chỉnh các yêu cầu, số lượng người dùng đồng
thời, tốc độ yêu cầu và nhiều thông số khác. Công cụ này thu thập dữ liệu thống kê về thời gian
phản hồi, số lỗi và các chỉ số khác để đánh giá hiệu suất của hệ thống.

Tsung có thể được triển khai trên nhiều máy tính để mô phỏng một môi trường phân tán và tải
cao. Cho phép giám sát và phân tích hiệu suất hệ thống khi đối mặt với các tình huống tải cao.

Tsung là một công cụ mã nguồn mở, miễn phí và được phát triển bởi cộng đồng. Rất hữu ích cho
việc xác định giới hạn và tìm hiểu hiệu suất của ứng dụng hoặc dịch vụ mạng và có thể hỗ trợ
trong việc điều chỉnh và tối ưu hóa hệ thống.

2. Tính năng
Tsung là công cụ kiểm thử hiệu năng và tải mạnh mẽ, được phát triển bằng ngôn ngữ Erlang.
Được thiết kế để mô phỏng lưu lượng người dùng đồng thời lớn và các hành vi giao tiếp phức
tạp trong môi trường ứng dụng web hoặc dịch vụ mạng. Tsung tập trung chủ yếu vào việc kiểm
thử và mô phỏng tải trên phía máy chủ (backend) của ứng dụng hoặc dịch vụ mạng.

Dưới đây là một số tính năng và khả năng của Tsung:

1. Giao thức hỗ trợ: Tsung hỗ trợ nhiều giao thức như HTTP, HTTPS, WebSocket, … và
PostgreSQL. Điều này cho phép kiểm tra hiệu suất của các ứng dụng web, ứng dụng di
động, dịch vụ trò chuyện, email và cơ sở dữ liệu.
2. Tạo tải lớn: Tsung giúp tạo ra lưu lượng người dùng đồng thời lớn từ nhiều nguồn khác
nhau để mô phỏng một môi trường thực tế. Định cấu hình số lượng người dùng, tốc độ
yêu cầu và phân bổ tải trọng để kiểm tra khả năng chịu tải của hệ thống.
3. Kịch bản kiểm thử linh hoạt: Bằng cách sử dụng ngôn ngữ mô tả XML, để tạo ra các kịch
bản kiểm thử linh hoạt để mô phỏng các hành vi giao tiếp phức tạp giữa người dùng và
ứng dụng. Định nghĩa các yêu cầu HTTP, các tình huống đồng thời, xử lý cookie, gửi dữ
liệu biểu mẫu và thực hiện các yêu cầu động.
4. Giám sát và thu thập dữ liệu: Tsung cung cấp các công cụ để giám sát và thu thập dữ liệu
hiệu suất hệ thống. Thu thập dữ liệu về thời gian phản hồi, số lỗi, băng thông, thống kê
CPU và các chỉ số khác. Các dữ liệu này giúp đánh giá hiệu suất của hệ thống và xác
định các vấn đề tiềm ẩn.

9
 5. Mô phỏng môi trường phân tán: Tsung cho phép triển khai trên nhiều máy tính để mô
phỏng một môi trường phân tán và tải cao. Bằng cách phân phối nguồn tải và sử dụng các
cổng kết nối khác nhau để tạo ra một lưu lượng lớn từ nhiều nguồn và giám sát tất cả các
thành phần trong hệ thống.

Tsung là một công cụ mạnh mẽ để kiểm tra hiệu suất và chịu tải của hệ thống. Cung cấp khả
năng mô phỏng môi trường thực tế và các tình huống tải cao để có thể đánh giá và tối ưu hóa
hiệu suất ứng dụng hoặc dịch vụ mạng.

Tuy nhiên, Tsung không cung cấp các tính năng chuyên sâu cho việc kiểm thử giao diện người
dùng (frontend) của ứng dụng. Để kiểm tra hiệu suất và chất lượng giao diện người dùng, hãy sử
dụng các công cụ khác như Selenium, JMeter, Gatling hoặc các công cụ kiểm thử hiệu suất
chuyên dụng cho frontend.

Với việc kết hợp sử dụng Tsung và các công cụ kiểm thử frontend, giúp thực hiện một quá trình
kiểm thử toàn diện hơn cho cả phía backend và frontend của ứng dụng hoặc dịch vụ mạng.

3. Đặc điểm
Ngoài những tính năng và khả năng đã đề cập ở trên, dưới đây là một số điểm nổi bật khác của
Tsung:

1. Đa nền tảng: Tsung được phát triển bằng ngôn ngữ Erlang, cho phép nó chạy trên nhiều
nền tảng, bao gồm Linux, macOS và Windows. Điều này mang lại sự linh hoạt cho việc
triển khai và sử dụng công cụ trên các môi trường khác nhau.
2. Quản lý phiên: Tsung hỗ trợ quản lý phiên để mô phỏng hành vi người dùng trong các
kịch bản kiểm thử. Lưu trữ và truy cập các biến phiên để sử dụng trong các yêu cầu sau
này, giúp mô phỏng tình huống người dùng duy trì trạng thái trong phiên làm việc.
3. Đa ngôn ngữ: Tsung hỗ trợ nhiều ngôn ngữ lập trình khác nhau để kiểm tra hiệu suất và
tải. Viết các đoạn mã tùy chỉnh trong các ngôn ngữ như Erlang, Perl, Lua hoặc Python để
thực hiện các tác vụ phức tạp hoặc kiểm tra những khía cạnh đặc biệt của hệ thống.
4. Tiện ích hỗ trợ: Tsung đi kèm với nhiều plugin hỗ trợ như Tsung Recorder để ghi lại các
hoạt động trình duyệt và tạo kịch bản kiểm thử, Tsung Monitor để giám sát trực tiếp hiệu
suất hệ thống trong quá trình thử nghiệm, Tsung Stats để phân tích và hiển thị dữ liệu
thống kê thu thập được.
5. Cộng đồng và tài liệu: Tsung là một dự án mã nguồn mở và có một cộng đồng sử dụng và
đóng góp tích cực. có thể tìm thấy tài liệu hướng dẫn, ví dụ và hỗ trợ từ cộng đồng để
giúp nắm bắt và sử dụng công cụ hiệu quả.

4. Testing
Tsung là một công cụ kiểm thử tải phân tán mạnh mẽ, cho phép tạo ra các kịch bản phức tạp để
kiểm thử hiệu năng và tải của ứng dụng web. Dưới đây là một số kiểu kiểm thử phổ biến mà có
thể thực hiện bằng Tsung:

10
 1. Kiểm thử tải (Load Testing):
o Tạo một kịch bản Tsung đơn giản để gửi yêu cầu HTTP GET đến một URL cụ
thể.
o Cấu hình số lượng người dùng và tần suất gửi yêu cầu để tạo ra tải trên ứng dụng
web.
o Theo dõi các chỉ số hiệu năng như thời gian phản hồi, tải trung bình và tải tối đa
để đánh giá hiệu suất của hệ thống.
2. Kiểm thử tải phân tán (Distributed Load Testing):
o Sử dụng Tsung để phân phối tải trên nhiều máy chủ để mô phỏng tải đồng thời từ
nhiều nguồn khác nhau.
o Tạo cấu hình Tsung Controller và Tsung Agents để phân phối tải và thu thập kết
quả từ các máy chủ khác nhau.
o Điều chỉnh số lượng và tần suất yêu cầu từ các máy khách khác nhau để đạt được
tải phân tán và kiểm tra khả năng mở rộng của ứng dụng.
3. Kiểm thử tải phức tạp (Complex Load Testing):
o Tạo các kịch bản phức tạp với các tương tác đa bước như đăng nhập, thao tác trên
giao diện người dùng, gửi yêu cầu POST, v.v.
o Sử dụng khả năng điều khiển và xử lý kịch bản của Tsung để mô phỏng các hành
vi người dùng thực tế trên ứng dụng web.
o Theo dõi và phân tích các chỉ số hiệu năng như thời gian phản hồi, thống kê lỗi,
hiệu suất cơ sở dữ liệu, và các thông số khác để đánh giá sự ổn định và khả năng
chịu tải của ứng dụng.
4. Kiểm thử tải theo thời gian thực (Real-time Load Testing):
o Sử dụng tính năng theo dõi thời gian thực của Tsung để theo dõi hiệu năng và tải
trên ứng dụng web trong thời gian thực.
o Theo dõi các chỉ số hiệu năng, đồ thị tải và cảnh báo tức thì để phát hiện và giải
quyết các vấn đề hiệu suất ngay lập tức.

5. Cài đặt
Để tải và cài đặt Tsung:

Linux:

1. Mở Terminal.
2. Sử dụng trình quản lý gói của hệ thống (ví dụ: apt, yum, dnf) để cài đặt Erlang/OTP (nếu
chưa có).

sudo apt-get update

sudo apt-get install erlang -y
sudo apt-get install libyaml-dev -y
sudo apt-get install gnuplot libtemplate-perl libssl-dev autoconf -y
// Without python
sudo apt install python3
sudo apt install python3-pip

11
 3. Sau khi Erlang/OTP đã được cài đặt, chạy lệnh sau để cài đặt Tsung:

sudo apt install tsung

(Thay "apt" bằng trình quản lý gói tương ứng nếu sử dụng trình quản lý gói khác như
yum hoặc dnf.)

macOS:

1. Mở Terminal.
2. Cài đặt Homebrew nếu chưa có. Truy cập trang web Homebrew (https://brew.sh) và làm
theo hướng dẫn cài đặt.
3. Sau khi Homebrew đã được cài đặt, chạy lệnh sau để cài đặt Erlang/OTP:s

brew install erlang

4. Tiếp theo, chạy lệnh sau để cài đặt Tsung:

brew install tsung

Windows:

1. Truy cập trang web chính thức của Erlang (https://www.erlang.org) và tải xuống phiên
bản Erlang/OTP phù hợp cho hệ điều hành Windows.
2. Chạy trình cài đặt Erlang/OTP và làm theo hướng dẫn để hoàn tất quá trình cài đặt.
3. Truy cập trang web chính thức của Tsung (https://tsung.erlang-projects.org) và tải xuống
phiên bản Tsung phù hợp cho Windows.
4. Giải nén tệp nén Tsung vào thư mục muốn cài đặt.
5. Thiết lập biến môi trường "ERLANG_HOME" trỏ đến thư mục cài đặt Erlang/OTP.
6. Đảm bảo thư mục "bin" của Erlang và Tsung đã được thêm vào biến môi trường "Path".
7. Bây giờ có thể chạy Tsung từ Command Prompt hoặc PowerShell bằng cách gõ lệnh
"tsung".

Sau khi đã cài đặt Tsung, có thể tạo và cấu hình các tệp kiểm thử Tsung để thực hiện các kiểm
tra hiệu suất và tải mạnh trên ứng dụng hoặc dịch vụ mạng của mình.

6. Demo
Chạy demo sử dụng tsung load test performace - YouTube

12
Compare testing tools
1. Tổng quan
JMeter, Tsung và Locust là ba công cụ kiểm thử phổ biến được sử dụng cho kiểm thử hiệu năng
và tải của ứng dụng web. Mỗi công cụ có những đặc điểm riêng, phù hợp với các yêu cầu và mục
tiêu kiểm thử khác nhau. Dưới đây là một tóm tắt tổng quan chi tiết về từng công cụ:

i. JMeter

• JMeter là một công cụ mạnh mẽ và đa tính năng được sử dụng rộng rãi trong kiểm thử
hiệu năng và tải của ứng dụng web.
• Nó có giao diện người dùng thân thiện và cung cấp một loạt các thành phần tích hợp,
giúp tạo và thực thi kế hoạch kiểm thử dễ dàng hơn.
• JMeter hỗ trợ nhiều giao thức như HTTP, HTTPS, FTP, JDBC, SOAP, REST và nhiều
giao thức khác, và có khả năng xử lý các kịch bản phức tạp.
• Nó có mô hình kiến trúc client-server truyền thống, có thể xử lý đồng thời một số lượng
lớn người dùng.
• JMeter có một cộng đồng lớn và hỗ trợ plugin phong phú, cho phép người dùng mở rộng
chức năng và tùy chỉnh các kịch bản kiểm thử của mình.

ii. Tsung

• Tsung là một công cụ kiểm thử tải phân tán, tập trung vào khả năng mở rộng và kiểm thử
hiệu năng của ứng dụng web.
• Nó là một công cụ dòng lệnh và yêu cầu người dùng làm việc với cấu hình dựa trên
XML.
• Tsung tập trung chủ yếu vào các giao thức HTTP, HTTPS và WebDAV và cung cấp tính
linh hoạt trong việc cấu hình hành vi người dùng.
• Với kiến trúc phân tán, Tsung cho phép phân phối tải trên nhiều máy chủ và có khả năng
mô phỏng số lượng người dùng đồng thời lớn hơn so với JMeter.
• Tsung cung cấp nhiều tùy chọn cấu hình và kiểm soát chặt chẽ hơn so với JMeter.

iii. Locust

• Locust là một công cụ đơn giản và dễ sử dụng, nổi bật với tính đơn giản và tiếp cận dễ
dàng cho các nhà phát triển.
• Nó cho phép người dùng viết các kịch bản kiểm thử bằng mã Python, giúp tận dụng tối
đa các kỹ năng lập trình hiện có của nhà phát triển.
• Locust có khả năng mô phỏng hàng ngàn người dùng đồng thời và cung cấp một giao
diện web để theo dõi và phân tích kết quả kiểm thử.
• Mặc dù Locust không cung cấp nhiều tính năng phức tạp như JMeter hoặc Tsung, nhưng
nó là một công cụ linh hoạt và dễ sử dụng cho các kiểm thử đơn giản và có quy mô nhỏ.

13
 2. So sánh
Tsung, JMeter và Locust là các công cụ kiểm thử phổ biến được sử dụng cho kiểm thử hiệu năng
và tải của ứng dụng web. Mặc dù chúng phục vụ mục đích tương tự, nhưng có một số khác biệt
giữa chúng.

1. Thao tác:
o JMeter: JMeter có giao diện người dùng thân thiện và cung cấp một loạt các thành
phần tích hợp, giúp tạo và thực thi kế hoạch kiểm thử dễ dàng hơn. Nó có độ cong
học cao hơn so với hai công cụ khác.
o Tsung: Tsung là một công cụ dòng lệnh với cấu hình dựa trên XML. Nó đòi hỏi
một số kiến thức kỹ thuật để thiết lập và cấu hình kịch bản kiểm thử.
o Locust: Locust là một công cụ tương đối mới nhưng đã được ưa chuộng nhờ tính
đơn giản và dễ sử dụng. Nó cho phép viết các kịch bản kiểm thử bằng mã Python,
giúp các nhà phát triển dễ tiếp cận.
2. Giao thức được hỗ trợ:
o JMeter: JMeter hỗ trợ một loạt giao thức, bao gồm HTTP, HTTPS, FTP, JDBC,
SOAP, REST và nhiều giao thức khác. Nó có khả năng xử lý các kịch bản phức
tạp và hỗ trợ nhiều plugin.
o Tsung: Tsung tập trung chủ yếu vào các giao thức HTTP, HTTPS và WebDAV.
Nó có thể mô phỏng hàng ngàn người dùng đồng thời và cung cấp tính linh hoạt
trong việc cấu hình hành vi người dùng.
o Locust: Locust được thiết kế chủ yếu cho các ứng dụng và API dựa trên giao thức
HTTP. Nó hỗ trợ các giao thức khác thông qua thư viện của bên thứ ba nhưng có
thể yêu cầu tuỳ chỉnh bổ sung.
3. Kiến trúc và hiệu năng:
o JMeter: JMeter có mô hình kiến trúc client-server truyền thống, trong đó các
request được thực thi trên các thread riêng biệt. Nó có khả năng xử lý đồng thời
một số lượng lớn người dùng. Tuy nhiên, với tải lớn, JMeter có thể gặp phải hiệu
suất giảm do tài nguyên hạn chế trên một máy.
o Tsung: Tsung có kiến trúc phân tán, cho phép phân phối tải trên nhiều máy chủ.
Nó có khả năng mô phỏng số lượng người dùng đồng thời lớn hơn so với JMeter
và có khả năng mở rộng tốt khi số lượng người dùng tăng.
o Locust: Locust cũng có kiến trúc phân tán và hỗ trợ mô phỏng hàng ngàn người
dùng đồng thời. Với cách tiếp cận sự kiện và sử dụng greenlets, Locust tiêu thụ ít
tài nguyên hệ thống hơn và có thể xử lý tải lớn một cách hiệu quả.
4. Ngôn ngữ kịch bản kiểm thử:
o JMeter: JMeter sử dụng giao diện đồ họa để tạo và quản lý kịch bản kiểm thử. Nó
cung cấp các thành phần dựng sẵn và điều khiển logic để xây dựng các kịch bản
phức tạp. Người dùng không cần biết lập trình để sử dụng JMeter. Ngoài ra, cũng
hỗ trợ việc viết mã thông qua Beanshell hoặc JavaScript.
o Tsung: Tsung sử dụng cấu hình XML để định nghĩa các kịch bản kiểm thử. Điều
này yêu cầu người dùng có kiến thức về cấu trúc và cú pháp XML. Người dùng
có thể chỉ định các yêu cầu HTTP, thời gian chờ, số lượng người dùng, và các

14
 hoạt động tùy chỉnh khác trong tệp cấu hình. Tsung cung cấp nhiều tùy chọn cấu
hình và kiểm soát chặt chẽ hơn so với JMeter.
o Locust: Locust sử dụng Python làm ngôn ngữ kịch bản kiểm thử. Người dùng có
thể viết mã Python để xác định các hành vi người dùng và tải lên ứng dụng. Điều
này đòi hỏi người dùng có kiến thức về Python.
5. Tính linh hoạt:
o JMeter: JMeter cung cấp một loạt các plugin và tùy chọn tùy chỉnh để mở rộng
chức năng. Người dùng có thể viết mã thông qua Beanshell hoặc JavaScript để
thực hiện các kịch bản phức tạp hơn.
o Tsung: Tsung cho phép tùy chỉnh thông qua tệp cấu hình XML và hooks. Người
dùng có thể thêm mã và thư viện tùy chỉnh để thực hiện các hoạt động phức tạp
hơn trong kịch bản kiểm thử.
o Locust: Locust cho phép viết kịch bản kiểm thử bằng mã Python, cho phép tùy
chỉnh linh hoạt và tích hợp dễ dàng với các thư viện và framework Python hiện
có.
6. Khả năng mở rộng:
o JMeter: JMeter có một hệ sinh thái phong phú các plugin, cho phép người dùng
mở rộng chức năng và tùy chỉnh các kịch bản kiểm thử của mình. Nó cung cấp
các trình nghe, các điều kiện, và các bộ định thời tích hợp sẵn.
o Tsung: Tsung cho phép tùy chỉnh thông qua các tệp cấu hình XML, nơi người
dùng có thể xác định các kịch bản kiểm thử và hành vi. Nó cung cấp hooks để
thêm mã và thư viện tùy chỉnh.
o Locust: Locust cung cấp tính linh hoạt và khả năng mở rộng bằng cách cho phép
người dùng viết kịch bản kiểm thử của mình bằng mã Python. Nó tích hợp tốt với
các thư viện và framework Python hiện có.

3. Tóm tắt
• Thao tác:
o JMeter: Giao diện người dùng thân thiện, dễ sử dụng.
o Tsung: Dòng lệnh, cấu hình dựa trên XML, yêu cầu kiến thức kỹ thuật.
o Locust: Đơn giản, dễ sử dụng, viết mã Python.
• Giao thức được hỗ trợ:
o JMeter: Hỗ trợ nhiều giao thức, plugin phong phú.
o Tsung: Tập trung chủ yếu vào HTTP, HTTPS, WebDAV.
o Locust: Chủ yếu hỗ trợ giao thức HTTP, có thể cần tuỳ chỉnh cho các giao thức
khác.
• Kiến trúc và hiệu năng:
o JMeter: Kiến trúc client-server, xử lý đồng thời lớn nhưng có thể gặp giảm hiệu
suất với tải lớn.
o Tsung: Kiến trúc phân tán, phân phối tải trên nhiều máy chủ, mô phỏng hàng
ngàn người dùng đồng thời, khả năng mở rộng tốt.
o Locust: Kiến trúc phân tán, mô phỏng hàng ngàn người dùng đồng thời, tiêu thụ ít
tài nguyên, xử lý tải lớn hiệu quả.
• Ngôn ngữ kịch bản kiểm thử:

15
 o JMeter: Giao diện đồ họa, hỗ trợ viết mã thông qua Beanshell, JavaScript.
o Tsung: Cấu hình XML, yêu cầu kiến thức về XML.
o Locust: Viết kịch bản bằng Python, yêu cầu kiến thức về Python.
• Tính linh hoạt:
o JMeter: Có plugin và tùy chọn tùy chỉnh, hỗ trợ mã thông qua Beanshell,
JavaScript.
o Tsung: Tùy chỉnh thông qua cấu hình XML và hooks.
o Locust: Tùy chỉnh linh hoạt bằng việc viết mã Python, tích hợp dễ dàng với các
thư viện và framework Python.
• Khả năng mở rộng:
o JMeter: Có hệ sinh thái plugin phong phú.
o Tsung: Tùy chỉnh thông qua cấu hình XML và hooks.
o Locust: Tích hợp tốt với các thư viện và framework Python hiện có.

Tóm lại, JMeter là công cụ mạnh mẽ và đa tính năng với cộng đồng lớn và hỗ trợ plugin phong
phú. Tsung tập trung vào khả năng mở rộng và kiểm thử tải phân tán. Locust nổi bật với tính đơn
giản và dễ sử dụng, đặc biệt đối với các nhà phát triển đã quen với mã Python.

16