Datn 20211 20173401 3.4m

ĐẠI HỌC BÁCH KHOA HÀ NỘI
ĐỒ ÁN TỐT NGHIỆP
XÂY DỰNG HỆ THỐNG CẢNH BÁO

TRÊN LUỒNG TIN TUYỂN DỤNG THU
THẬP TỪ INTERNET:
KHỐI CÔNG VIỆC SỐ 1
NGUYỄN VĂN TIẾN

tien.nv173401@sis.hust.edu.vn
Ngành Công nghệ thông tin

Chuyên ngành Khoa học máy tính
Giảng viên hướng dẫn: TS. Trần Việt Trung

Chữ ký của GVHD
Trường: Công nghệ Thông tin và Truyền thông –

Đại học Bách khoa Hà Nội
HÀ NỘI, 12/2021
ĐỀ TÀI TỐT NGHIỆP
1. Thông tin về sinh viên

Họ và Tên: NGUYỄN VĂN TIẾN
Điện thoại liên lạc: 0966288130
Email: tien.nv173401@sis.hust.edu.vn
Lớp: KHMT.03 – K62
Hệ đào tạo: Kỹ sư chính quy
Đồ án tốt nghiệp được thực hiện tại: Trường Công nghệ Thông tin và Truyền
thông - Đại học Bách khoa Hà Nội
Thời gian thực hiện đồ án: Học kỳ 20211.
2. Mục đích và nội dung ĐATN
Thiết kế, xây dựng và triển khai hệ thống cảnh báo dựa trên luồng tin tuyển
dụng thu thập từ internet.
3. Các nhiệm vụ cụ thể của ĐATN
• Xây dựng mô-đun xử lý, quản lý dữ liệu hỗ trợ truy vấn dữ liệu việc làm.
• Thiết kế và xây dựng giao diện website hỗ trợ người dùng tương tác với
hệ thống
4. Lời cam đoan của sinh viên
Em tên là Nguyễn Văn Tiến xin cam đoan đề tài ĐATN: “xây dựng hệ thống
cảnh báo dựa trên luồng tin tuyển dụng thu thập từ internet: Khối công việc số
1” là một công trình nghiên cứu độc lập dưới sự hướng dẫn của giáo viên
hướng dẫn: TS Trần Việt Trung. Ngoài ra không có bất cứ sự sao chép của
người khác. Đề tài, nội dung báo cáo thực tập là sản phẩm mà em đã nỗ lực
nghiên cứu trong quá trình học tập tại trường. Các số liệu, kết quả trình bày
trong báo cáo là hoàn toàn trung thực, em xin chịu hoàn toàn trách nhiệm, kỷ
luật của bộ môn và nhà trường đề ra nếu như có vấn đề xảy ra.”
Giáo viên hướng dẫn

Ký và ghi rõ họ tên
Lời cảm ơn
Chặng đường 5 năm học ở Bách khoa chuẩn bị tới hồi kết, cảm xúc lúc này thật
lẫn lộn. Vừa vui vì sắp chinh phục được ngôi trường nổi tiếng “tạch môn là
chuyện thường”, cũng vừa tự hào vì chưa bị “tạch” môn nào ở nơi đây.
Để hoàn thành được đồ án này, sự động viên, đóng góp ý kiến từ gia đình, thầy
cô và bạn bè là không thể thiếu đối với một sinh viên còn non trẻ.
Lời đầu tiên em xin dành lời cảm ơn chân thành nhất đến TS. Trần Việt Trung
cùng anh Nguyễn Hoàng Long đã tận tình chỉ bảo, hướng dẫn và định hướng suốt
quãng thời gian em thực hiện đồ án để đồ án được hoàn thành một cách tốt nhất.
Con cảm ơn mẹ đã tần tảo gánh vác trọng trách của cả bố để nuôi con ăn học 16
năm nay. Cảm ơn mẹ đã đặt niềm tin nơi con, luôn quan tâm và động viên con
suốt những tháng ngày học tập xa nhà. Cảm ơn anh em chí cốt (Bách, Trang,
Lim…) trong mái nhà Hội Sinh viên, những người bạn đầu tiên trong quãng thời
gian sinh viên ngắn ngủi. Tiếp theo là tập thể lớp CNTT11, những đồng chí siêu
lầy nhưng cũng rất tình cảm, đoàn kết làm mình đánh tan được suy nghĩ lên đại
học sẽ không thân với lớp, tuy giờ đây trên danh nghĩa không còn chung lớp
nhưng chắc chắn sẽ còn mãi mãi là anh em. Cảm ơn những người anh em
LamTran Company đã bên cạnh tôi những kì cuối đại học, tuy nhóm toàn người
giỏi làm tôi khá áp lực nhưng tôi vẫn quý anh em lắm.
5 năm học không dài nhưng cũng đủ để cho em những trải nghiệm quý giá,
những mối quan hệ mà suốt quãng đời còn lại có thể không tìm được. Suốt hành
trình, phần tốt có, phần dở có, nhưng quan trọng hơn hết là bài học mang lại. Xin
cảm ơn Bách khoa, cảm ơn những con người nơi đây đã tạo nên một Bách khoa
“chất” đến thế. Hy vọng lần bảo vệ đồ án tốt nghiệp này sẽ diễn ra thuận lợi, để
sau này mỗi khi gặp khó khăn, tôi có thể tự tin rằng "Đến Bách Khoa còn có thể
tốt nghiệp được thì chẳng phải ngán việc gì cả".
Xin cảm ơn vì tất cả!
Tạm biệt và hẹn gặp lại.
Hà Nội, ngày 23 tháng 01 năm 2022
Nguyễn Văn Tiến

Tóm tắt nội dung đồ án
Thị trường việc làm ở Việt Nam ngày càng phát triển một cách nhanh chóng và
đa dạng cùng với thời kỳ đổi mới, hội nhập sâu và rộng, mở ra nhiều cơ hội cho
người lao động. Cùng với, thời đại công nghệ 4.0 đã có nhiều ứng dụng thực tiễn,
người dùng đã có thể tìm kiếm trên internet các công việc ứng với bản thân. Tuy
nhiên, trên thực tế, một bộ phận lớn người tìm việc vẫn chưa tìm được công việc
phù hợp với nhu cầu, cùng với việc mất nhiều thời gian, công sức để tìm kiếm.
Để giải quyết các vấn đề này, đồ án hướng tới việc xây dựng một hệ thống cảnh
báo dựa trên luồng tin tuyển dụng thu thập từ internet. Với mục tiêu giảm bớt
công sức, thời gian cho người tìm việc, đồ án đóng vai trò như một nền tảng cho
phép người dùng tùy biến, tìm kiếm một cách tự động các thông tin tuyển dụng.
Để thực hiện điều này, đồ án sử dụng các kiến thức liên quan đến dữ liệu lớn như
Apache Spark, Apache Kafka cùng các công cụ xây dựng website như FastAPI,
Angular.
Tuy mới chỉ được triển khai trên quy mô nhỏ nhưng kết quả đạt được của đồ án
đã phần nào chứng minh được khả năng giải quyết được các vấn đề vừa đặt ra
phía trên.
Sinh viên thực hiện

Ký và ghi rõ họ tên
MỤC LỤC
MỤC LỤC ....................................................................................................................... v

DANH MỤC HÌNH VẼ ................................................................................................ vii
DANH MỤC BẢNG....................................................................................................... ix
CHƯƠNG 1. GIỚI THIỆU ĐỀ TÀI ............................................................................. 1
1.1 Đặt vấn đề ................................................................................................................ 1
1.1.1 Thực trạng thị trường tuyển dụng lao động hiện nay .............................. 1
1.1.2 Website việc làm yourway và các khó khăn trong việc tìm kiếm dữ liệu
2
1.2 Mục tiêu và phạm vi đề tài ....................................................................................... 2
1.2.1 Mục tiêu của đồ án .................................................................................. 2
1.2.2 Phạm vi đề tài .......................................................................................... 3
1.3 Định hướng giải pháp ............................................................................................... 3
1.4 Bố cục đồ án ............................................................................................................. 4
CHƯƠNG 2. CƠ SỞ LÝ THUYẾT VÀ CÔNG NGHỆ .............................................. 6
2.1 Hệ thống phân tán .................................................................................................... 6
2.2 Nền tảng Spark: tính toán trên cụm dữ liệu lớn ....................................................... 7
2.2.1 Lý thuyết xử lý luồng liên tục ................................................................. 7
2.2.2 Apache Spark .......................................................................................... 8
2.2.3 Giới thiệu Spark Structured Streaming ................................................. 10
2.3 Nền tảng Kafka: truyền tải thông điệp phân tán .................................................... 13
2.3.1 Giới thiệu Kafka .................................................................................... 13
2.3.2 Mô hình cấu trúc Kafka......................................................................... 14
2.4 Framework FastAPI: xây dựng hệ thống API ........................................................ 15
2.5 Angular: xây dựng giao diện website..................................................................... 17
CHƯƠNG 3. XÂY DỰNG ỨNG DỤNG WEB TƯƠNG TÁC NGƯỜI DÙNG ..... 18
3.1 Phân tích thiết kế .................................................................................................... 18
3.1.1 Phân tích ca sử dụng ............................................................................. 18
3.1.2 Phân tích quy trình nghiệp vụ ............................................................... 26
3.1.3 Phân tích sơ đồ lớp ................................................................................ 28
3.1.4 Thiết kế giao diện mô phỏng ................................................................. 29
3.1.5 Lựa chọn kiến trúc phần mềm ............................................................... 31
3.2 Triển khai hệ thống website ................................................................................... 32
3.3 Giao diện ứng dụng ................................................................................................ 33
3.3.1 Giao diện thêm luồng dữ liệu ................................................................ 33
3.3.2 Giao diện quản lý luồng dữ liệu ............................................................ 34
3.3.3 Giao diện quản lý công việc liên tục ..................................................... 35
3.3.4 Các giao diện chức năng khác ............................................................... 35
CHƯƠNG 4. THIẾT KẾ VÀ XÂY DỰNG HỆ THỐNG QUẢN LÝ, XỬ LÝ DỮ
LIỆU............................................................................................................................... 38
4.1 Kiến trúc tổng quan hệ thống ................................................................................. 38
4.2 Phát triển hệ thống quản lý và xử lý dữ liệu .......................................................... 40
4.2.1 Kết nối các luồng dữ liệu đầu vào ......................................................... 42
4.2.2 Tạo lược đồ luồng dữ liệu ..................................................................... 44
4.2.3 Xử lý truy vấn trên các luồng dữ liệu trong công việc Spark ............... 47
4.2.4 Chuẩn bị dữ liệu kết quả để gửi đến người dùng .................................. 48
4.3 Triển khai hệ thống quản lý, xử lý dữ liệu ............................................................. 50
4.4 Kết quả và đánh giá ................................................................................................ 51
CHƯƠNG 5. KẾT LUẬN ............................................................................................ 55
5.1 Kết luận .................................................................................................................. 55
5.2 Hướng phát triển trong tương lai ........................................................................... 55
TÀI LIỆU THAM KHẢO ............................................................................................ 56
DANH MỤC HÌNH VẼ
Hình 1.1: Lực lượng lao động Việt Nam theo quý, năm 2020 và 2021 ........................... 1
Hình 2.1: Minh họa stream processing ............................................................................. 7
Hình 2.2: Thành phần Spark ............................................................................................. 8
Hình 2.3: Mô hình dữ liệu cơ bản của Structured Streaming ......................................... 10
Hình 2.4: Mô hình hoạt động của chương trình Strucuted streaming ............................ 11
Hình 2.5: Vai trò của Apache Kafka trong hệ thống ...................................................... 13
Hình 2.6: Mô hình cấu trúc kafka đơn giản .................................................................... 14
Hình 2.7: Mô hình cấu trúc kafka chi tiết ....................................................................... 14
Hình 2.8: Giao diện quản lý các api trong ứng dụng được viết bằng FastAPI ............... 15
Hình 2.9: Kiến trúc angular ............................................................................................ 17
Hình 3.1: Biểu đồ use case tổng quan hệ thống web. (Màu xanh là các use case sinh
viên thực hiện, màu tím là các use case thực hiện bởi sinh viên Vũ Minh Hiếu)........... 18
Hình 3.2: Biểu đồ use case thêm luồng dữ liệu .............................................................. 20
Hình 3.3: Biểu đồ use case quản lý công việc liên tục ................................................... 23
Hình 3.4: Biểu đồ use case quản lý các luồng dữ liệu .................................................... 24
Hình 3.5: Biểu đồ tuần tự use case “Thêm luồng dữ liệu” ............................................. 26
Hình 3.6: Biểu đồ tuần tự use case “Thêm luồng dữ liệu” ............................................. 27
Hình 3.7: Biểu đồ tuần tự use case “Quản lý luồng dữ liệu” .......................................... 27
Hình 3.8: Sơ đồ lớp ca sử dụng “Thêm luồng dữ liệu” .................................................. 28
Hình 3.9: Sơ đồ lớp ca sử dụng “Quản lý công việc liên tục” ........................................ 28
Hình 3.10: Sơ đồ lớp ca sử dụng “Quản lý luồng dữ liệu” ............................................. 29
Hình 3.11: Mô phỏng giao diện kết nối cơ sở dữ liệu .................................................... 29
Hình 3.12: Mô phỏng giao diện thêm luồng dữ liệu ....................................................... 30
Hình 3.13: Mô phỏng giao diện quản lý luồng dữ liệu ................................................... 30
Hình 3.14: Mô phỏng giao diện quản lý công việc liên tục ............................................ 30
Hình 3.15: Kiến trúc client – server ................................................................................ 31
Hình 3.16: Mô hình MVC (Model – View – Controller) ............................................... 31
Hình 3.17: Giao diện thêm luồng dữ liệu ....................................................................... 33
Hình 3.18: Giao diện quản lý luồng dữ liệu ................................................................... 34
Hình 3.19: Giao diện xem bản ghi luồng dữ liệu............................................................ 34
Hình 3.20: Giao diện quản lý công việc liên tục ............................................................ 35
Hình 3.21: Giao diện cấu hình hệ thống ......................................................................... 36
Hình 3.22: Giao diện thêm câu truy vấn ......................................................................... 36
Hình 3.23: Giao diện quản lý câu truy vấn ..................................................................... 37
Hình 4.1: Kiến trúc tổng quan hệ thống quản lý, xử lý dữ liệu (Màu hồng đậm là các
phần chức năng sinh viên thực hiện, màu vàng là các phần chức năng thực hiện bởi sinh
viên Vũ Minh Hiếu) ........................................................................................................ 38
Hình 4.2: Kiến trúc mô-đun Công cụ xử lý dữ liệu phân tán ......................................... 40
Hình 4.3: Vai trò của Job Spark trong hệ thống ............................................................. 40
Hình 4.4: Cách hoạt động của Mô-đun Công cụ xử lý dữ liệu phân tán ........................ 41
Hình 4.5: Vai trò của Kafka trong hệ thống ................................................................... 42
Hình 4.6: Đoạn mã đọc dữ liệu đầu vào từ Kafka .......................................................... 44
Hình 4.7: Đoạn mã tạo lược đồ dữ liệu trong công việc Spark ...................................... 45
Hình 4.8: Đoạn mã tạo tự động lược đồ từ bảng dữ liệu ................................................ 46
Hình 4.9: Đoạn mã đọc dữ liệu bằng SQL của job Spark............................................... 48
Hình 4.10: Chuẩn bị dữ liệu kết quả ............................................................................... 48
Hình 4.11: Đoạn mã cấu hình gửi dữ liệu đầu ra ............................................................ 49
Hình 4.12: Gửi trả dữ liệu đầu ra .................................................................................... 49
Hình 4.13: Thêm luồng dữ liệu công việc ...................................................................... 51
Hình 4.14: Kết quả luồng dữ liệu được thêm ................................................................. 52
Hình 4.15: Thêm truy vấn ............................................................................................... 52
Hình 4.16: Kết quả thêm truy vấn................................................................................... 52
Hình 4.17: Quản lý công việc Spark ............................................................................... 53
Hình 4.18: Khởi động công việc thành công .................................................................. 53
Hình 4.19: Kết quả được gửi đến người dùng qua email................................................ 54
DANH MỤC BẢNG
Bảng 2.1: So sánh FastAPI, Django và Flask ................................................................. 16
Bảng 3.1: Đặc tả use case “Thêm luồng dữ liệu” ........................................................... 21
Bảng 3.2: Mô tả các trường trong lược đồ dữ liệu .......................................................... 22
Bảng 3.3: Đặc tả use case “Quản lý công việc liên tục” ................................................. 24
Bảng 3.4: Đặc tả use case “Quản lý các luồng dữ liệu” ................................................. 25
Bảng 3.5: Chi tiết các gói, thư viện cài đặt cho hệ thống ............................................... 32
Bảng 4.1: Các gói, thư viện cần cho cài đặt hệ thống quản lý, xử lý dữ liệu ................. 50
DANH SÁCH THUẬT NGỮ VÀ TỪ VIẾT TẮT
Thuật ngữ Ý nghĩa, mô tả
CSDL Cơ sở dữ liệu
RDD Resilient Distributed Datasets
Tập dữ liệu được phân phối có khả năng phục hồi
SQL Structured Query Language
Framework Khung làm việc
CHƯƠNG 1. GIỚI THIỆU ĐỀ TÀI
1.1 Đặt vấn đề
1.1.1 Thực trạng thị trường tuyển dụng lao động hiện nay
Hiện nay dịch bệnh COVID-19 đã diễn ra liên tục trong vòng 2 năm qua đã khiến
kinh tế Việt Nam nói riêng và thế giới nói chung gặp nhiều khó khăn. Rất nhiều
công ty tập đoàn trên thế giới cũng vô cùng khó khăn, rơi vào khủng hoảng vì
các đợt giãn cách phong tỏa thời gian dài. Các chuỗi cung ứng vận chuyển giữa
các vùng bị đứt gãy cũng như khó khăn trong việc lưu thông khiến cho giá cả leo
thang. Gây nên cơn khủng hoàng việc làm trên toàn cầu nói chung và Việt Nam
nói riêng. Đại dịch COVID-19 đã khiến hàng triệu lao động mất việc làm cũng
như thiếu việc làm tại Việt Nam. Theo số liệu Tổng cục Thống kê Việt Nam (Tài
liệu tham khảo [2]) đưa ra trung bình trong 9 tháng năm 2021, số người thất
nghiệp trong độ tuổi lao động lên tới hơn 1,3 triệu người tăng hơn rất nhiều so
với cùng kì năm ngoái. Đồng thời tỉ lệ thất nghiệp trong độ tuổi 15-24 tuổi lên tới
7,9% đặc biệt hơn là khu vực thành thị lên tới 10,79%. Các con số đều tăng hơn
so với thời điểm trước khi đại dịch xảy ra cho thấy đại dịch đã ảnh hưởng rất lớn
tới người lao động cũng như các đơn vị công ty tuyển dụng việc làm.
Hình 1.1: Lực lượng lao động Việt Nam theo quý, năm 2020 và 2021
Hơn nữa khi đại dịch lan rộng đã khiến đất nước phải giãn cách, phong tỏa nhiều
khu vực. Vô hình chung cũng gây khó khăn cho các công ty trong việc tuyển
dụng tìm nhân sự duy trì hoạt động cho bộ máy công ty. Các công ty cũng như
người lao động phải phỏng vấn và duy trì kết nối hoàn toàn trên môi trường
Internet. Từ đó chúng ta cũng nhận thấy nhiều bất cập về lượng thông tin tuyển
dụng, thông tin ứng tuyển tìm việc chưa được khai thác triệt để, người lao động
không thể tìm kiếm chính xác được các thông tin tuyển dụng phù hợp hay nhà
tuyển dụng cũng khó có khả năng tìm ra các ứng viên tiềm năng. Người lao động
Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 1

cũng như công ty tuyển dụng phải liên tục tìm kiếm trên mạng Internet gây lãng
phí thời gian và chi phí vận hành.
1.1.2 Website việc làm yourway và các khó khăn trong việc tìm kiếm dữ liệu
Yourway là một website tìm kiếm việc làm đã được xây dựng thành công với các
chức năng cho phép người dùng đăng tin tuyển dụng (dành cho các công ty), tìm
kiếm và đăng bài tìm việc (dành cho cá nhân có nhu cầu), xem thống kê số liệu
việc làm dưới dạng trực quan biểu đồ. Với những gì đã được xây dựng, website
phần nào đã thực hiện việc kết nối người cần tìm việc và doanh nghiệp, tổ chức
muốn tuyển nhân viên. Tuy nhiên bên cạnh đó, với cách tìm việc truyền thống thì
vẫn còn những hạn chế nhất định.
• Đầu tiên là việc tìm kiếm thủ công theo phương thức truyền thống (tìm
kiếm bằng tên, lọc khoảng lương, khu vực, …) mất tương đối thời gian.
Đồng thời mỗi khi truy cập lại để tìm kiếm, người dùng lại phải thực hiện
lại một loạt các thao tác vừa đề cập. Như vậy là rất tốn thời gian và công
sức
• Bên cạnh đó, việc gửi thông tin tuyển dụng đến người dùng theo lịch đã
được một số các trang web việc làm tương tự phục vụ (linkedin.com,
indeed.com, …) nhưng lại khá cứng nhắc khi chỉ đưa một vài thông tin
cho người dùng chọn. Đây là vấn đề khiến cho đôi khi có những công việc
chưa thực sự phù hợp với mong muốn được gửi đến người dùng.
1.2 Mục tiêu và phạm vi đề tài
1.2.1 Mục tiêu của đồ án
Tính năng thông báo dữ liệu đến người dùng đã có ở nhiều hệ thống website. Tuy
nhiên lại chưa giải quyết được vấn đề tùy biến cho người dùng. Trong đồ án này,
sinh viên hướng tới giải quyết bài toán truy vấn dữ liệu sử dụng công nghệ dữ
liệu lớn. Với mục tiêu khắc phục những hạn chế, khó khăn của các phương pháp
truy vấn cũ như giảm bớt thao tác người dùng, tùy biến được truy vấn tốt hơn,
lưu trữ hiệu quả.
Từ những vấn đề đã nêu ở phần 1.1, mục tiêu được đặt ra cho đồ án này là xây
dựng hệ thống cảnh báo dữ liệu một cách liên tục trên luồng dữ liệu tuyển dụng.
Hệ thống này sẽ có các khả năng giải quyết các vấn đề như sau:
• Khả năng xử lý dữ liệu liên tục, người dùng chỉ cần thực hiện truy vấn
một lần và hệ thống lưu lại để xử lý cho các lần sau.
• Tính năng gửi dữ liệu định kì theo mong muốn tuần suất nhận thông báo
của người dùng
• Khả năng cho phép người dùng tùy chỉnh các điều kiện truy vấn trên
luồng dữ liệu
• Giao diện website giúp cho người dùng có thể xây dựng câu truy vấn một
cách đơn giản, cấu hình và quan sát hệ thống một cách trực quan

Mở rộng hơn, với các tính năng bên trên, hệ thống hướng đến theo dạng một dịch
vụ có thể tích hợp vào bất kì hệ thống truy vấn nào để xử lý dữ liệu cho người
dùng.
1.2.2 Phạm vi đề tài
Mặc dù hướng đến là một hệ thống tích hợp được với nhiều hệ thống xử lý, truy
vấn dữ liệu khác, nhưng trong phạm vi đồ án này, hệ thống mới chỉ được tích
hợp với dữ liệu của website yourway, bản thử cũng sử dụng dữ liệu thật của
website này để thực hiện.
Đồ án này được thực hiện bởi nhóm gồm có 2 sinh viên là Nguyễn Văn Tiến và
Vũ Minh Hiếu. Phần việc cụ thể phân chia để xây dựng hệ thống được trình bày
như bên dưới:
Hệ thống
Sinh viên
Quản lý và xử lý dữ liệu Website tương tác người dùng
Kết nối các luồng dữ liệu đầu vào Chức năng kết nối CSDL
Tạo lược đồ luồng dữ liệu Chức năng thêm luồng dữ liệu
Nguyễn
Xử lý truy vấn trên các luồng dữ liệu Chức năng quản lý các luồng dữ
Văn Tiến
trong công việc Spark liệu
20173401
Chuẩn bị dữ liệu kết quả để gửi đến Chức năng quản lý công việc liên
người dùng tục
Quản lý các truy vấn Chức năng thêm truy vấn
Vũ Minh Cấu hình hệ thống Chức năng quản lý truy vấn
Hiếu Cấu trúc dữ liệu đầu vào Chức năng cấu hình hệ thống
20168683 Lập lịch xử lý kết quả truy vấn
1.3 Định hướng giải pháp

Từ những vấn đề trong thực tế cuộc sống khi người tìm việc không thể liên tục
truy cập các website tuyển dụng để thực hiện liên tục việc tìm kiếm một công
việc phù hợp với bản thân nhiều ngày cũng như cập nhật các tin tuyển dụng một
cách nhanh nhất. Để tăng tính thực tế và ứng dụng thực tiễn, đồ án tập trung phát
triển hệ thống tổng hợp, xử lý và thông báo kết quả xử lý của dòng dữ liệu liên
tục về công việc trên nền tảng hệ thống đã có sẵn của yourway.vn. Vì vậy nhóm
em đã phát triển hệ thống giúp đỡ các người dùng có khả năng đưa ra yêu cầu tìm
kiếm một lần và nhận lại theo lịch trình được định sẵn danh sách các kết quả theo
yêu cầu tìm kiếm đó với các dữ liệu mới nhất. Từ đó giúp tích kiệm thời gian cho
người dùng, tự động hóa khả năng nhận kết quả của người dùng theo hướng chủ
động gửi kết quả đó tới từng thông tin liên lạc của người dùng.

Để giải quyết các vấn đề trên, hệ thống tổng thể được chia thành 2 phần trong đồ
án này là:
• Hệ thống 1: Hệ thống website tương tác nhằm mục đích giúp người dùng
dễ dàng hơn trong việc tương tác hệ thống
• Hệ thống 2: Hệ thống quản lý, xử lý dữ liệu thực hiện nhiệm vụ chính liên
quan đến dữ liệu và trả kết quả cho người dùng
Về phần công nghệ, sinh viên sử dụng công nghệ:
• Xử lý dữ liệu lớn: Apache Spark và Apache Kafka.
o Apache Spark là một mã nguồn mở xử lý dữ liệu trên quy mô lớn.
Với khả năng tính toán song song, giao diện lập trình dễ dàng và
khả năng chịu lỗi tốt, Apache Spark đang đi đầu trong xu hướng xử
lý dữ liệu lớn.
o Apache Kafka là một nền tảng truyền tải dữ liệu phân tán. Tốc độ
và khả năng chịu lỗi của Apache Kafka đang dần thay thế cho hệ
thống truyền tin truyền thống.
• Hệ thống web: framework FastAPI và Angular
o FastAPI là một khung làm việc xây dựng các RESTful API trên
ngôn ngữ lập trình Python. FastAPI là một công nghệ mới với
những cải tiến để phát triển nhanh và dễ bảo trì hơn với các công
nghệ đời cũ hơn.
o Angular là một khung làm việc mạnh mẽ dùng để xây dựng giao
diện website được phát triển bởi Google.
• Cơ sở dữ liệu: MySQL – một trong những CSDL phổ biến nhất hiện nay.
Kết quả thu được sau khi sinh viên thực hiện đồ án này là một hệ thống cảnh báo
dữ liệu bằng công nghệ dữ liệu lớn. Bên cạnh đó là những kiến thức thu được khi
giải quyết bài toán.
1.4 Bố cục đồ án
Dựa vào các vấn đề tồn tại và hướng tiếp cận được đề xuất để giải quyết bài
toán ở phần trước, các phần tiếp theo của đồ án tốt nghiệp này được tổ chức như
sau:
Chương 2. Cơ sở lý thuyết và công nghệ: đề cập đến các định nghĩa, giải thích
lý thuyết các nên tảng phân tán cũng như xử lý dữ liệu lớn đồng thời cũng giới
thiệu các công cụ sử dụng trong mã nguồn hệ thống. Chương này sẽ bao gồm 4
phần chính. Phần đầu sẽ trình bày các lý thuyết hệ thống phân tán, phần tiếp theo
sẽ trình bày về nền tảng spark, đặc tả các chức năng, và phần cuối cùng sẽ trình
bày về các yêu cầu phi chức năng của hệ thống.

Chương 3. Thiết kế và xây dựng hệ thống quản lý, xử lý dữ liệu: trình bày chi
tiết về hệ thống ứng dụng, phân tích sâu hơn về từng mô-đun trong hệ thống qua
kiến trúc cũng như công nghệ sử dụng.
Chương 4. Xây dựng ứng dụng web tương tác người dùng: trình bày về giao
diện với người dùng, giúp hệ thống tương tác dễ hơn với người dùng. Ngoài ra,
chương này còn đề cập đến kết quả kiểm thử cũng như một vài đánh giá sơ bộ về
hệ thống.
Chương 5. Kết luận: tổng kết các kết quả đạt được cũng như trình bày các hạn
chế còn tồn tại, đồng thời định hướng phát triển trong tương lai.

CHƯƠNG 2. CƠ SỞ LÝ THUYẾT VÀ CÔNG NGHỆ
2.1 Hệ thống phân tán
Hệ thống phân tán (Distributed Systems [1]) là tập hợp các máy tính được kết nối
với nhau bởi một mạng máy tính và được cài đặt phần mềm hệ phân tán. Hệ phân
tán là một hệ thống có chức năng và dữ liệu phân tán trên các trạm (máy tính)
được kết nối với nhau bởi một mạng máy tính.
Hệ phân tán là một tập hợp các máy tính độc lập, mạng máy tính và phần mềm
giao tiếp với người dùng như một hệ thống nhất toàn vẹn.
Đặc điểm của hệ phân tán 4 đặc trưng của hệ phân tán bao gồm:
• Tính chia sẻ tài nguyên: Giữa các máy tính trong hệ phân tán có thể
chia sẻ (sử dụng chung) mà không bị hạn chế bởi địa lý. Quản lý tài
nguyên ở đây bao gồm lập kế hoạch và dự phòng, đặt tên các lớp tài
nguyên, cho phép tài nguyên được truy cập từ nơi khác, ánh xạ tên tài
nguyên vào địa chỉ truyền thông ...
• Tính khả mở: là tính dễ dàng mở rộng phần cứng và phần mềm của
hệ thống máy tính. Nói một cách khác, tính khả mở của hệ thống phân
tán mang ý nghĩa bao hàm tính dễ dàng cấu hình cả phần cứng lẫn
phần mềm của nó.
• Tính trong suốt: Tính trong suốt được hiểu như là sự che khuất đi các
thành phần của hệ thống máy tính (phần cứng và phần mềm) đối với
người sử dụng và những người lập trình ứng dụng. Người sử dụng có
quyền truy cập đến dữ liệu đặt tại một điểm dữ liệu ở xa một cách tự
động nhờ hệ thống mà không cần biết đến sự phân tán của tất cả dữ
liệu trên mạng. Hệ thống tạo cho người dùng cảm giác là dữ liệu được
coi như đặt tại máy tính cục bộ của mình.
• Tính co giãn: Tính co giãn của hệ phán tán được thể hiện qua:
o Qui mô: Khi số lượng người dùng và tài nguyên thay đổi hệ phân
tán phải thích nghi được.
o Không gian địa lý: Khi vùng địa lý có tài nguyên và người sử dụng
thay đổi.
o Tổ chức: Khi tổ chức kết cấu của hệ thay đổi
Các thành phần hệ phân tán:
• Phần cứng hệ phân tán
Bao gồm máy chủ và các hệ thống máy con được đặt ở những vị trí khác
nhau và kết nối với nhau qua mạng máy tính.
• Phần mềm hệ phân tán
o Hệ điều hành phân tán (Distributed Operating Systems): Hệ điều
hành gắn chặt với hệ thống phần cứng (máy đa vi xử lý hoặc máy
tính đồng bộ)

o Hệ điều hành mạng (Network Operating Systems): cài đặt trên máy
tính cục bộ. Cung cấp dịch vụ cục bộ cho các máy tính khác.
o Phần mềm truy gian (Middleware): Cài đặt các dịch vụ cơ bản để
thực hiên, phát triển các ứng dụng.
2.2 Nền tảng Spark: tính toán trên cụm dữ liệu lớn
2.2.1 Lý thuyết xử lý luồng liên tục
Xử lý luồng liên tục (Stream processing [3]) là xử lý dữ liệu ngay khi nó xuất
hiện trong hệ thống, mở rộng hơn nữa thì stream processing có khả năng làm việc
với luồng dữ liệu vô hạn, quá trình tính toán xảy ra liên tục
Hình 2.1: Minh họa stream processing
Stream processing có thể được sử dụng ở bất cứ hệ thống nào cần sự phản hồi
nhanh từ một sự kiện gửi đến. Số lượng các sự kiện này thường rất nhiều, không
giới hạn và liên tục được hệ thống xử lý.
Stream processing ra đời giúp chúng ta giải quyết được bài toán khó khăn trong
việc xử lý dữ liệu. Phương thức này được sử dụng khi
• Cần một phương pháp để gửi dữ liệu đến bộ lưu trữ trung tâm một cách
nhanh chóng
• Bởi vì máy móc thường xuyên gặp lỗi nên cần có cách thức sao chép dữ
liệu nhằm giúp cho khi xảy ra sự cố, không bị downtime hoặc mất dữ liệu.
• Cần có tiềm năng mở rộng quy mô đáp ứng bất kỳ lượng người dùng mà
không cần phải theo dõi các ứng dụng khác nhau. Hoặc cần cung cấp dữ
liệu cho bất kỳ ai trong một tổ chức mà không cần theo dõi xem ai đã và
chưa được xem dữ liệu.
Một vài ví dụ của stream processing là Apache Spark, Apache Storm, Apache
Flink và Apache Kafka.

2.2.2 Apache Spark
2.2.2.1. Giới thiệu sơ lược Apache Spark
Apache Spark [6] (viết tắt là Spark) là một trong những công cụ xử lý dữ liệu liên
tục tốt nhất, phổ biến nhất hiện nay. Spark cũng bao gồm những thư viện phục vụ
cho việc xử lý song song dữ liệu trên các cụm máy tính. Là một sản phẩm mã
nguồn mở, Spark cũng có một cộng đồng phát triển mạnh mẽ, đồng thời cũng hỗ
trợ các ngôn ngữ xử lý dữ liệu phổ biến như Python, Java, Scala và R. Ngoài ra
nó còn bao gồm nhiều thư viện phong phú cho nhiều công việc khác nhau từ truy
xuất dữ liệu (SQL), xử lý dữ liệu dạng dòng (Stream) cho đến những tác vụ trong
học máy.
Hình 2.2: Thành phần Spark
Apache Spark cung cấp 4 thành phần riêng biệt được sử dụng như thư viện dành
cho các tác vụ cụ thể: Spark SQL, Spark MLlib, Spark Streaming và GraphX. Dù
sử dụng API từ thư viện nào để viết chương trình Spark thì cũng được Spark
chuyển đổi thành các biểu đồ tính toán tương ứng (DAG). Điều đó có nghĩa bất
kể mã nguồn được viết cho chương trình của Spark sử dụng các API được cung
cấp thông qua các ngôn ngữ lập trình được hỗ trợ như Python, Java hay Scala thì
mã nguồn cơ bản cũng sẽ được phân tách thành các mã bytecode rất nhỏ và được
được thực thi tại các worker trên cụm máy chủ. Điều này làm cho nó trở thành
một hệ thống dễ dàng bắt đầu và mở rộng quy mô xử lý dữ liệu lớn trên quy mô
cực lớn.
Sơ lược về các thư viện mà Spark cung cấp như sau:
• Spark SQL: là một thành phần nằm trên Spark Core, giới thiệu một
khái niệm trừu tượng hóa dữ liệu mới gọi là SchemaRDD, cung cấp hỗ
trợ cho dữ liệu có cấu trúc và bán cấu trúc. Hỗ trợ thực hiện tốt các
truy vấn trên dữ liệu có cấu trúc từ nhiều nguồn đa dạng như CSV,
text, JSON, Avro, ORC, Parquet, ...
• Spark MLlib: Hỗ trợ cho các tác vụ về học máy, cung cấp các thuật
toán cơ bản trong học máy tính toán phân tán trên Spark tận dụng khả
năng tính toán tốc độ cao nhờ distributed memory-based của kiến trúc
Spark.
• Spark Streaming: tận dụng khả năng lập lịch memory-base của Spark
Core để thực hiện streaming analytics. Nó lấy dữ liệu theo mini-

batches và thực hiện các phép biến đổi RDD (Bộ dữ liệu phân tán có
khả năng phục hồi) trên các mini-batches dữ liệu đó.
• GraphX: Sử dụng trong các thao tác với dữ liệu dạng đồ thị và thực
hiện các phép toán song song với đồ thị.
2.2.2.2. Dataframe và Dataframe API
Dataframe là một loại lập trình trừu tượng ở trong thành phần Spark SQL, nó khá
giống với pandas (một thư viện chuyên xử lý dữ liệu của ngôn ngữ python)
DataFrames ở một số định dạng và toán tử. Các dataframe khá giống với các
bảng trong cơ sở dữ liệu quan hệ với dữ liệu nằm trong các hàng và cột, mỗi cột
sẽ xác định một kiểu dữ liệu ví dụ như: số thực, dạng chuỗi ký tự, mảng, ...
Ngoài ra dataframe còn cung cấp schema mô tả về kiểu dữ liệu trong các cột của
dataframe.
DataFrame API là một phần nằm trong thư viện Spark SQL, API cung cấp này
các phương thức để làm việc với các dataframe của Spark một cách đơn giản
thông qua sử dụng các ngôn ngữ lập trình thông dụng mà Spark hỗ trợ.
2.2.2.3. Một số khái niệm trong chương trình Spark
Một số khái niệm quan trọng của một chương trình
• Application: Một chương trình được xây dựng trên Spark bằng việc sử
dụng các api mà nó cung cấp. Một chương trình sẽ bao gồm thành
chính như sau:
o The Spark driver: Chịu trách nhiệm như trình điều khiển cho các
thực thi trong chương trình Spark và quản lý các trạng thái thái
của cụm Spark.
o The Spark executors: là tiến trình thực thi công việc mà được
giao bởi Spark driver, báo cáo về trạng thái của những công việc
o The cluster manager: Chịu trách nhiệm về mặt quản lý tài nguyên
vật lý của cụm mà chương trình Spark sẽ thực thi trên đó.
• Spark job: Mỗi một chương trình Spark sẽ được chia thành các job nhỏ
hơn, mỗi một job chính là chuỗi các phương thức transformation được
kết thúc bằng một phương thức action, mỗi một job sẽ được chuyển
thành một DAG tương ứng.
• Spark Stages: Trong mỗi job sẽ được chia thành các stage một cách
tuần tự, việc chia stage ở đây dựa trên việc xem xét các operation nào
có thể được thực hiện trên các partition dữ liệu song song hay tuần tự.
Các narrow transformations sẽ được nhóm lại thành cùng một stage vì
khi thực hiện các narrow transformation thì dữ liệu giữa các partition
không cần phải phân tán lại.
• Spark task: Mỗi stage cấu thành từ các task (một đơn vị thực thi), mỗi
task sẽ được gắn với một nhân ở executor và làm việc trên một
partition của dữ liệu. các task sẽ được gửi các executor để thực hiện

việc tính toán song song. Thực chất mỗi task tách ra từ một stage chính
là cùng một công việc nhưng được thực hiện song song trên các
partition dữ liệu khác nhau.
2.2.3 Giới thiệu Spark Structured Streaming
Như đã giới thiệu ở phần trên, Spark hỗ trợ 4 loại thư viện cho 4 bài toán riêng
biệt là Spark SQL, Spark Streaming, Spark MLlib và GraphX. Để giải quyết
được mục tiêu ở chương 1, cần phải có một ứng dụng xử lý liên tục được dữ liệu
mà vẫn có thể thao tác với cấu trúc của chúng. Ở phiên bản Apache Spark 2.0 đã
cho ra mắt một công cụ mới đặt tên là Structured Streaming [7] (luồng có cấu
trúc). Mục tiêu chính là giúp dễ dàng hơn trong việc xây dựng các ứng dụng phát
trực tuyến end-to-end, tích hợp với hệ thống lưu trữ, phục vụ và các công việc
hàng loạt theo cách nhất quán và có khả năng chịu lỗi.
Spark Structured Streaming đã được giới thiệu trong Spark 2.0 như một phần của
dự án Apache Spark như một công cụ xử lý luồng theo lô vi mô. Nó được đánh
dấu là ổn định trong Spark 2.2.
Structured Streaming hoạt động trên công cụ SQL của Spark (Spark SQL). Trong
Structured Streaming, các phép chuyển đổi (transformations), tổng hợp
(aggregations), cửa sổ thời gian sự kiện (event-time-windows), tất cả đều hoạt
động trên Dataframe/Dataset, tức là dữ liệu sẽ ở dạng bảng không giới hạn độ lớn
và sẽ được thay đổi theo từng lô vi mô. Vì vậy, có thể sử dụng lại cùng một logic
dành cho xử lý hàng loạt trong Spark Streaming.
Hình 2.3: Mô hình dữ liệu cơ bản của Structured Streaming [9]
Trên hình có thể thấy mỗi bản ghi dữ liệu mới được đưa vào chương trình
structured streaming theo dòng dữ liệu. Mỗi bản ghi này được tính như một hàng
(row) được thêm vào một bảng không giới hạn (unbounded table).
Các dữ liệu này được xử lý, truy vấn (query). Một truy vấn trên đầu vào sẽ tạo ra
"Bảng kết quả" (Result table). Mỗi khoảng thời gian kích hoạt (giả sử, cứ sau 1
giây), các hàng mới sẽ được nối vào Bảng đầu vào, cuối cùng sẽ cập nhật Bảng
kết quả như dưới đây.

Hình 2.4: Mô hình hoạt động của chương trình Strucuted streaming [9]
Các kết quả đầu ra này (Output) được định nghĩa là những gì được ghi ra bộ nhớ
ngoài. Đầu ra có thể được xác định ở một số chế độ như sau:
• Chế độ Hoàn thành (Complete mode) - Toàn bộ bảng kết quả được cập
nhật sẽ được ghi vào bộ nhớ ngoài. Trình kết nối lưu trữ quyết định cách
xử lý việc ghi toàn bộ bảng.
• Chế độ Nối thêm (Append mode) - Chỉ các hàng mới được thêm vào bảng
kết từ lần xử lý cuối cùng sẽ được ghi vào bộ nhớ ngoài. Điều này chỉ áp
dụng cho các truy vấn mà các hàng hiện có trong bảng kết quả sẽ không
thay đổi.
• Chế độ Cập nhật (Update mode) - Chỉ những hàng đã được cập nhật trong
bảng kết quả kể từ lần kích hoạt cuối cùng sẽ được ghi vào bộ nhớ ngoài
(khả dụng kể từ Spark 2.1.1). Lưu ý rằng điều này khác với Chế độ hoàn
thành ở chỗ chế độ này chỉ xuất ra các hàng đã thay đổi kể từ lần kích hoạt
cuối cùng.
Structured Streaming hỗ trợ đọc dữ liệu từ nhiều nguồn đầu vào như:
• Tệp (File Source)
• Kafka – Một công cụ chuyên dùng để truyền tải thông điệp phân tán (sẽ
được trình bày ở phần sau)
• Socket
• Rate
Điều này giúp cho Structured Streaming linh hoạt với nhiều dạng lưu trữ dữ liệu.
Ưu điểm của Structured Streaming:
• Xử lý thời gian sự kiện (Event Time Processing):

Structured Streaming có thể xử lý dữ liệu dựa trên thời gian sự kiện, tức là khi dữ
liệu được tạo ra chứ không phải khi dữ liệu đến công cụ xử lý. Điều này đạt được
bằng cách sử dụng trường thời gian trong dữ liệu. Đồng thời cũng giúp xử lý dữ
liệu theo thứ tự ngay cả khi thời gian đến của dữ liệu đến bộ máy xử lý không
theo thứ tự.
• Hình mờ (Watermarks):
Structured Streaming hỗ trợ watermarks, tức là thời gian trễ tối đa mà dữ liệu có
thể đến. Vì vậy, phát trực tuyến có cấu trúc có thể giữ dữ liệu cũ trong một
khoảng thời gian nhất định
• Xử lý luồng trên công cụ SQL:
Structured Streaming là công cụ xử lý luồng đầu tiên được xây dựng trên Spark
SQL. Vì thế, công cụ này cũng hỗ trợ các API của Dataframe / Dataset, từ đó đơn
giản và quen thuộc hơn để sử dụng. Ngoài ra, Structured Streaming cũng có thể
tận dụng tối ưu hóa công cụ Spark SQL.

2.3 Nền tảng Kafka: truyền tải thông điệp phân tán
2.3.1 Giới thiệu Kafka
Apache Kafka [8] là một nền tảng truyền thông điệp (message) phân tán. Được
LinkedIn phát triển để giải quyết những nhu cầu thực tế của hệ thống của họ.
Kafka xử lý hàng đợi theo cơ chế publish - subscribe, có hàng đợi mạnh mẽ có
thể xử lý khối lượng dữ liệu lớn và cho phép bạn truyền thông điệp từ end-point
này đến end-point khác. Các thông điệp của Kafka được lưu trữ trên disk và được
nhân bản trong Cluster để tránh mất dữ liệu.
Lợi ích của Kafka
• Reliability: Kafka được phân tán (distribute), phân chia (partition), đồng
bộ (replicate) và chịu lỗi (fault tolerance).
• Scalability: Kafka có thể mở rộng dễ dàng mà không bị downtime.
• Durability: Thông điệp được lưu trữ trên disk trong thời gian dài.
• Performance: Kafka có thông lượng cao trong cả publish-subscribe thông
điệp. Nó duy trì được độ ổn định kể cả khi lưu trữ đến hàng TeraByte
thông điệp.
Hình 2.5: Vai trò của Apache Kafka trong hệ thống
Ứng dụng của Kafka:

• Quản lý log tập trung: Kafka có thể được sử dụng để thu thập log từ
nhiều dịch vụ khác nhau và làm cho chúng luôn sẵn sàng để các
consumer có thể đọc.
• Xử lý luồng: Các framework thông dụng như Storm, Spark đọc dữ liệu từ
các topic, xử lý chúng và ghi dữ liệu đã xử lý vào một topic mới để cho
người dùng và các ứng dụng khác sử dụng dữ liệu mới đó.

2.3.2 Mô hình cấu trúc Kafka
Hình 2.6: Mô hình cấu trúc kafka đơn giản
Hình 2.7: Mô hình cấu trúc kafka chi tiết
Như 2 ảnh trên, cấu trúc của kafka bao gồm các thành phần chính sau:
• Producer: Một producer có thể là bất kì ứng dụng nào có chức năng xuất
bản tin nhắn vào một topic.
• Messages: Messages đơn thuần là byte array và nhà phát triển có thể sử
dụng chúng để lưu bất kì sự vật với bất kì định dạng nào - thông thường là
String, JSON và Avro
• Topic: Một topic là một danh mục hoặc feed name nơi mà bản ghi được
xuất bản.
• Partitions: Các topic được chia nhỏ vào các đoạn khác nhau, các đoạn
này được gọi là partition

• Consumer: Một consumer có thể là bất kì ứng dụng nào có chức năng
đăng ký lắng nghe vào một topic và tiêu thụ các tin nhắn.
• Broker: Cụm Kafka là một tập các máy chủ, mỗi một tập này được gọi là
1 broker
• Zookeeper: được dùng để quản lý và bố trí các broker.
2.4 Framework FastAPI: xây dựng hệ thống API
FastApi [4] là một web framework dùng để xây dựng hệ thống API có hiệu năng
cao, thực hành đơn giản nhưng cũng hỗ trợ tốt cho việc làm sản phẩm. FastAPI
được viết trên ngôn ngữ lập trình python sử dụng chuẩn ASGI để giao tiếp giữa
web server và ứng dụng python.
• Đặc điểm:
- Nhanh: Hiệu suất cao ngang với ngôn ngữ lập trình NodeJS và Go.
- Thực hành nhanh: Code nhanh hơn, tốc độ code các tính năng tăng
khoảng 200 đến 300%.
- Ít lỗi hơn: do đơn giản nên giảm số lỗi của developper đến 40%.
- Dễ: được thiết kế sao cho dễ dùng dễ học.
- Ngắn: Tối thiểu việc lặp code. Các tham số truyền vào có nhiều tính
năng. Ít lỗi.
- Mạnh mẽ: hiệu năng mạnh mẽ, có thể tương tác API qua giao diện
trực quan.
Hình 2.8: Giao diện quản lý các api trong ứng dụng được viết bằng FastAPI
• Là một framework mới (ra mắt vào năm 2018), FastAPI thừa kế những
điểm mạnh và khắc phục các điểm yếu của các framework trước đó với
nhiệm vụ tương tự (Django, flask).
Dưới đây là một số so sánh tổng quan FastAPI với 2 framework trước đó
là Django và flask:

Django Flask FastAPI
Cũng được hỗ trợ Cộng đồng của FastAPI

Cộng đồng Hỗ trợ bởi nhiều thư viện vì nhiều nhưng là khá mới, do vậy số
hỗ trợ có cộng đồng từ lâu không bằng lượng thư viện hỗ trợ khá
Django ít
Phiên bản Tất cả phiên bản:

Tất cả phiên bản: 2x, 3x Chỉ cho python3.x
python 2x, 3x
Là framework có hiệu
Do hỗ trợ nhiều feature nên
Performance khá năng cao nhất trong các
Hiệu năng perfomance của Django
cao framework python hiện
không được cao
tại
ORM Django ORM Flask-sqlachemy Sqlachemy
Async Hỗ trợ từ Django 3.x Chưa hỗ trợ Tương thích hoàn toàn
Builtin
Có Không Không
Admin UI
Project Có, chỉ cần run python

Không Không
Frame manage startapp yourapp
Không – đây là hạn chế

của một microframework
Python shell Có Có
so với các framework
thực thụ
Phổ biến nhất là sử dụng

Django-rest-framework, với
Tài liệu mô Sử dụng Flask- Mặc định đã tích hợp sẵn
Swagger thì dùng django-
tả OpenAPI restplus Swagger và Redoc
rest-swagger với python2.x,
dùng drf-yasg với python3.x
Bảng 2.1: So sánh FastAPI, Django và Flask
Ta có thể thấy framework FastAPI [4] đạt hiệu năng cao nhất và ít hạn chế hơn
so với 2 sản phẩm trước đó.

2.5 Angular: xây dựng giao diện website
Angular [5] là một JavaScript framework dùng để viết giao diện web (Front-end).
Đây là một sản phẩm được viết bởi Misko Hevery và một người bạn của anh là
Adam Abrons. Sau đó, chính thức ra mắt vào 20/10/2010. Hiện tại, sản phẩm này
đang được Google duy trì để xây dựng các Single Page Application (SPA) bằng
JavaScript, HTML và TypeScript. Angular cung cấp các tính năng tích hợp cho
animation, http service và có các tính năng như auto-complete, navigation,
toolbar, menus, Code được viết bằng TypeScript, biên dịch thành JavaScript và
hiển thị tương tự trong trình duyệt.
Hình 2.9: Kiến trúc angular
Đến nay Angular đã được phát triển đến nhiều phiên bản, mới nhất là Angular
13.
Công thức cấu thành Angular có thể hiểu đơn giản như sau:
Angular Application = Component + Component + Component … + services
Trong đó: Component = Template + Class + Metadữ liệu
Angular có những ưu điểm:

• Ứng dụng được giảm tối đa kích thước và tăng tối đa hiệu suất.
• HTML linh hoạt hơn.
• Code HTML mạnh mẽ hơn với những đặc trưng như IF, FOR, LOCAL
VARIABLES, …
• Dễ dàng hiển thị các trường từ dữ liệu model của website và theo dõi
những thay đổi, cập nhật lại từ người dùng nhờ binding dữ liệu.
• Xây dựng và tái sử dụng nội dung nhờ vào những khối module độc lập.
• Nhanh chóng giải quyết các bài toán logic nhờ back- end service hỗ trợ
giao tiếp.

CHƯƠNG 3. XÂY DỰNG ỨNG DỤNG WEB TƯƠNG TÁC
NGƯỜI DÙNG
3.1 Phân tích thiết kế
Hệ thống website sẽ có những chức năng giúp người dùng tương tác với hệ thống
quản lý, xử lý dữ liệu. Phần dưới sẽ phân tích sâu hơn từng chức năng sinh viên
thực hiện.
3.1.1 Phân tích ca sử dụng
Phần thiết kế dưới đây chỉ rõ hệ thống website cần có những chức năng thế nào
để đáp ứng được yêu cầu đặt ra. Thiết kế dựa theo những tính năng của hệ thống
quản lý, xử lý dữ liệu và yêu cầu ban đầu của đồ án.
3.1.1.1. Biểu đồ use case tổng quan hệ thống
Hình 3.1: Biểu đồ use case tổng quan hệ thống web. (Màu xanh là các use case sinh
viên thực hiện, màu tím là các use case thực hiện bởi sinh viên Vũ Minh Hiếu)
Website cung cấp các ca sử dụng về cách thêm luồng dữ liệu, truy vấn và cách để
quản lý thông qua việc hiển thị các tùy chọn và bảng để quản lý. Sau đây sinh
viên sẽ đi làm rõ ca sử dụng phân tích dữ liệu của hệ thống từ đó giúp xác định
được bài toán cụ thể cần giải quyết của mô-đun quản lý và xử lý dữ liệu.
Trên Hình 3.1 là biểu đồ phân tích use case tổng quát của website, dựa vào đó ta
thấy website cung cấp 8 chức năng chính để tạo nên các một luồng dữ liệu hoàn
chỉnh bao gồm: “Kết nối CSDL”, “Thêm luồng dữ liệu”, “Thêm truy vấn”, “Cấu

hình hệ thống”, “Quản lý công việc liên tục”, “Quản lý các luồng dữ liệu”, “Quản
lý các truy vấn” và “Gửi kết quả truy vấn”.
• Kết nối CSDL: Cấu hình thông tin để kết nối đến CSDL mà hệ thống cần
dùng.
• Thêm luồng dữ liệu: Định nghĩa luồng dữ liệu lấy từ đâu, tên luồng dữ
liệu và lược đồ dữ liệu mà luồng dữ liệu sẽ truyền đi.
• Thêm truy vấn: Chức năng tạo câu truy vấn người dùng muốn thực hiện
trên luồng dữ liệu. Người dùng có 2 lựa chọn là câu truy vấn nâng cao và
câu truy vấn dạng chọn. Dạng nâng cao cho phép người dùng tự nhập câu
truy vấn dạng SQL để thực thi trên structured streaming. Dạng chọn cho
phép người dùng chọn những thông tin của một câu truy vấn mà không
cần phải nhập, dạng này cho phép người dùng chọn trường muốn truy vấn
(có trong lược đồ dữ liệu), những bảng muốn truy vấn, điều kiện lọc dữ
liệu… Sau đó người dùng cần chọn nơi dữ liệu sẽ trả ra (chọn topic kafka)
và thời gian để nhận kết quả hệ thống xử lý. Các câu truy vấn được tạo lưu
vào CSDL MySQL dưới định dạng SQL.
• Cấu hình hệ thống: Do hệ thống có sử dụng kết hợp của nhiều công nghệ
với nhau nên để quản lý dễ dàng hơn thì cần có một chức năng cấu hình
những thông tin của từng công nghệ. Cụ thể sẽ có cấu hình của Spark,
Kafka, Mail, Telegram. Các thông tin cần thiết thông tin xác thực, cấu
hình khi kết nối đều được lưu ở đây.
• Quản lý công việc liên tục: Đây chính là chức năng quản lý trạng thái
của job Spark (công việc liên tục) và các dịch vụ kết nối cùng như Kafka,
Spark, MySQL. Do hệ thống chỉ gửi lên một job duy nhất nên ở đây có
thêm chức năng “Khởi động công việc” và “Dừng công việc” để tiện trong
việc chủ động thao tác hơn.
• Quản lý các luồng dữ liệu: Sau khi tạo được các luồng dữ liệu, đôi khi
vẫn cần phải chỉnh sửa một số thông tin như topic kafka đầu vào và lược
đồ dữ liệu. Cụ thể sẽ được sinh viên trình bày bên dưới.
• Quản lý các truy vấn: Là chức năng xem các câu truy vấn đã được tạo.
Kết quả sẽ phải được hiển thị theo dạng bảng để dễ quan sát hơn.
• Gửi kết quả truy vấn: Là chức năng đặc biệt với tác nhân là hệ thống, hệ
thống sẽ tự động gửi dữ liệu đã được xử lý đến cho người dùng theo một
lịch cụ thể của từng câu truy vấn. Người dùng chỉ cần thêm câu truy vấn
và tần suất nhận kết quả tương ứng.
Từ phạm vi đã nêu ở mục 1.2.2, trong đồ án này sinh viên sẽ chỉ tập trung làm rõ
các usecase “Thêm luồng dữ liệu”, “Quản lý công việc liên tục”, “Quản lý các
luồng dữ liệu”.

3.1.1.2. Ca sử dụng thêm luồng dữ liệu
Hình 3.2: Biểu đồ use case thêm luồng dữ liệu
Hình 3.2 mô tả các chức năng cụ thể trong chức năng “Thêm luồng dữ liệu”. Để
tạo được một luồng dữ liệu, nhất thiết cần tên luồng dữ liệu (chức năng “Đặt tên
luồng dữ liệu”), topic Kafka đầu vào (chức năng “Chọn topic Kafka đầu vào”) và
lược đồ dữ liệu (Chức năng “Tạo lược đồ dữ liệu”).
• Đặt tên luồng dữ liệu: Mỗi luồng dữ liệu đều cần một định danh để ánh
xạ đến một topic kafka dữ liệu đầu vào
• Chọn topic Kafka đầu vào: Topic này lưu trữ những message chứa dữ
liệu của luồng như đã nói ở các phần trước
• Tạo lược đồ dữ liệu: Mỗi tin nhắn chứa dữ liệu đều phải có chung một
lược đồ để hệ thống có thể lấy dữ liệu cần thiết. Lược đồ này được lưu
theo dạng là một bảng trong CSDL MySQL. Từ đó mỗi trường dữ liệu sẽ
có tên và kiểu dữ liệu. Dữ liệu sẽ có cấu trúc và chặt chẽ hơn. Yêu cầu cụ
thể với lược đồ dữ liệu được trình bày ở bảng 3.2.
Dưới đây là đặc tả ca sử dụng “Thêm luồng dữ liệu”

Mã Use case UC001 Tên Use case Thêm luồng dữ liệu
Tác nhân Người dùng
Tiền điều kiện Kết nối CSDL thành công
Luồng sự kiện
chính STT Thực hiện Hành động
(Thành công) 1 Người dùng Chọn chức năng Thêm luồng dữ liệu
2 Hệ thống Hiển thị giao diện Thêm luồng dữ liệu
Nhập định danh luồng dữ liệu viết liền
3 Người dùng
không dấu
4 Người dùng Tạo topic kafka đầu vào
5 Người dùng Chọn topic Kafka đầu vào

Kiểm tra xem và trả về tin nhắn có trong
6 Hệ thống
topic kafka đã được người dùng chọn
Thêm các trường dữ liệu trong lược đồ của
7 Người dùng
luồng dữ liệu
8 Người dùng Yêu cầu thêm luồng dữ liệu
Hiển thị tạo luồng thành công và chuyển
9 Hệ thống
hướng tới trang quản lý luồng dữ liệu
Luồng sự kiện
thay thế STT Thực hiện Hành động
Hệ thống Cảnh báo: Topic đã chọn không lưu tin
6a
nhắn nào
Hệ thống Thông báo lỗi: Topic đã chọn không tồn
6b
tại trong Kafka
9a Hệ thống Thông báo lỗi: Đặt tên luồng sai
9b Hệ thống Thông báo lỗi: Tạo lược đồ dữ liệu thất bại
Hậu điều kiện Không
Bảng 3.1: Đặc tả use case “Thêm luồng dữ liệu”
* Bảng dưới đây trình bày các yếu tố mô tả mỗi trường trong lược đồ dữ liệu, từ
đây hệ thống có thể tạo bảng trong CSDL ứng với luồng dữ liệu:

STT Yếu tố Mô tả Bắt buộc? Điều kiện hợp lệ Ví dụ
Tên trường dữ Là tên viết liền id
1 Tên trường Có
liệu không dấu
Kiểu dữ liệu của Thuộc một trong INT
trường dữ liệu các loại INT,
DATETIME,
Kiểu dữ
2 Có VARCHAR,
liệu
FLOAT, TEXT,
TIMESTAMP,
DATE
Độ dài lớn nhất 11
3 Độ dài có thể cho giá trị Không
lưu
Là khoá chính khi Giá trị True/False True
4 PK thêm bảng trong Không
CSDL
Là ràng buộc Giá trị True/False True
5 NN không được để Không
trống trường này
Là ràng buộc giá Giá trị True/False True
6 UQ Không
trị duy nhất
Khi để trống -Chỉ áp dụng cho True
trường này thì tự kiểu dữ liệu INT
7 AI Không
động tăng giá trị - Giá trị
lên 1 True/False
Giá trị mặc định
8 Default khi nếu để trống Không
trường này
Ghi chú cho
9 Comment Không
trường
Bảng 3.2: Mô tả các trường trong lược đồ dữ liệu

3.1.1.3. Ca sử dụng quản lý công việc liên tục
Hình 3.3: Biểu đồ use case quản lý công việc liên tục
Hình 3.3 mô tả các chức năng cụ thể trong chức năng “Quản lý công việc liên
tục”. Chức năng này chủ yếu sẽ cho người dùng quản lý được trạng thái của job
một cách trực quan nhất. Các chức năng con bao gồm:
• Xem trạng thái, nhật ký: Người dùng có thể xem trạng thái của các công
nghệ dùng trong hệ thống. Có 2 trạng thái cơ bản là “Stopped” và
“Running” lần lượt chỉ việc dịch vụ đó đang dừng hay đang chạy bình
thường. Ngoài ra người dùng cũng có thể xem được nhật ký của công việc
liên tục từ đó có thể tìm ra lỗi tại sao job chạy không thành công.
• Khởi động/dừng công việc: Khởi động hoặc dừng việc xử lý dữ liệu
ngay lập tức mà không phải đợi đến lịch đã cấu hình trước.
• Thay đổi lịch khởi động công việc: Do hệ thống đặt sẵn lịch khởi động
lại của job là 0 giờ đêm nên có thể tùy từng hệ thống mà không hợp lý.
Điều này dẫn đến việc người dùng muốn sửa đổi lịch chạy của job. Chức
năng này hỗ trợ yêu cầu đó của người dùng.
Dưới đây là đặc tả ca sử dụng “Quản lý công việc liên tục”
Mã Use case UC002 Tên Use case Quản lý công việc liên tục

Luồng sự kiện
(Thành công) Người dùng Chọn chức năng Quản lý công việc liên
1
tục
Hệ thống Hiển thị giao diện Quản lý công việc liên
2
tục
3 Người dùng Chọn biểu tượng trạng thái của Spark
Hệ thống Chuyển hướng đến trang nhật ký của công
4
việc liên tục
Luồng sự kiện
3a Người dùng Chọn lịch khởi động lại của công việc
4a Người dùng Chọn lưu lịch khởi động
5a Hệ thống Thông báo lưu thành công
3b Người dùng Chọn khởi động công việc
Khởi động công việc và hiển thị định danh
4b Hệ thống luồng hoạt động của công việc trên máy
lên màn hình
Bảng 3.3: Đặc tả use case “Quản lý công việc liên tục”
3.1.1.4. Ca sử dụng quản lý các luồng dữ liệu
Hình 3.4: Biểu đồ use case quản lý các luồng dữ liệu
Hình 3.4 mô tả các chức năng cụ thể trong chức năng “Quản lý các luồng dữ
liệu”. Chức năng này người dùng có thể xem được hệ thống đang có những luồng
dữ liệu nào, đến từ đâu và thực hiện một số sửa đổi cho luồng.

• Xem dữ liệu: Đôi khi người dùng muốn xem luồng dữ liệu đang có những
dữ liệu thế nào. Chức năng này giúp hiển thị dữ liệu trong topic Kafka đầu
vào.
• Sửa luồng: Chức năng giúp người dùng sửa được đổi được thông tin
luồng như topic kafka đầu vào, lược đồ dữ liệu.
• Xóa luồng: Chức năng xóa đi luồng đang có.
Dưới đây là đặc tả ca sử dụng “Quản lý luồng dữ liệu”
Mã Use case UC003 Tên Use case Quản lý luồng dữ liệu
Luồng sự kiện
(Thành công) 1 Người dùng Chọn chức năng Quản lý luồng dữ liệu
2 Hệ thống Hiển thị giao diện Quản lý luồng dữ liệu
3 Người dùng Chọn tính năng sửa luồng
4 Hệ thống Hiển thị giao diện sửa luồng
Luồng sự kiện
3a Người dùng Chọn tính năng xem dữ liệu
4a Hệ thống Hiển thị giao diện xem dữ liệu
Hệ thống Thông báo lỗi: Luồng dữ liệu không lưu
4a1
dữ liệu nào
3b Người dùng Chọn tính năng xóa luồng dữ liệu
4b Hệ thống Thông báo: Xóa thành công luồng dữ liệu
Bảng 3.4: Đặc tả use case “Quản lý các luồng dữ liệu”

3.1.2 Phân tích quy trình nghiệp vụ
3.1.2.1. Thêm luồng dữ liệu
Hình 3.5: Biểu đồ tuần tự use case “Thêm luồng dữ liệu”

3.1.2.2. Quản lý công việc liên tục
Hình 3.6: Biểu đồ tuần tự use case “Thêm luồng dữ liệu”
3.1.2.3. Quản lý luồng dữ liệu
Hình 3.7: Biểu đồ tuần tự use case “Quản lý luồng dữ liệu”

3.1.3 Phân tích sơ đồ lớp
3.1.3.4. Thêm luồng dữ liệu
Hình 3.8: Sơ đồ lớp ca sử dụng “Thêm luồng dữ liệu”
3.1.3.5. Quản lý công việc liên tục
Hình 3.9: Sơ đồ lớp ca sử dụng “Quản lý công việc liên tục”

3.1.3.6. Quản lý luồng dữ liệu
Hình 3.10: Sơ đồ lớp ca sử dụng “Quản lý luồng dữ liệu”
3.1.4 Thiết kế giao diện mô phỏng

3.1.4.7. Mô phỏng giao diện kết nối cơ sở dữ liệu
Hình 3.11: Mô phỏng giao diện kết nối cơ sở dữ liệu

3.1.4.8. Mô phỏng giao diện thêm luồng dữ liệu
Hình 3.12: Mô phỏng giao diện thêm luồng dữ liệu
3.1.4.9. Mô phỏng giao diện quản lý luồng dữ liệu
Hình 3.13: Mô phỏng giao diện quản lý luồng dữ liệu
3.1.4.10. Mô phỏng giao diện quản lý công việc liên tục
Hình 3.14: Mô phỏng giao diện quản lý công việc liên tục

3.1.5 Lựa chọn kiến trúc phần mềm
Tổng quan, hệ thống được thiết kế theo mô hình Client – Server. Các thiết bị
đóng vai trò là máy khách gửi yêu cầu (request) tới máy chủ, máy chủ xử lý và
gửi phản hồi (response) trở lại cho máy khách. Kiến trúc Client – Server được
biểu diễn ở hình dưới.
Hình 3.15: Kiến trúc client – server
Trong đồ án, sinh viên áp dụng MVC cho việc phát triển ứng dụng web. MVC là
viết tắt của Model – View – Controller là một kiến trúc phần mềm hay mô hình
thiết kế được sử dụng trong kỹ thuật phần mềm. Nó giúp cho nhà phát triển tách
ứng dụng ra thành ba thành phần khác nhau. Mỗi thành phần có một nhiệm vụ
riêng biệt và độc lập. Model là thành phần chưa tất cả các nghiệp vụ logic,
phương thức xử lý, truy xuất cơ sở dữ liệu, đối tượng mô tả dữ liệu như các
Class, hàm xử lý. View đảm nhận việc hiển thị thông tin, tương tác với người
dùng, nơi chứa tất cả các đối tượng GUI (Graphic User Interface). Controller giữ
nhiệm vụ điều hướng các yêu cầu (request) từ người dùng và gọi đúng những
phương thức xử lý chúng. Hình sau minh hoạ cho mô hình MVC.
Hình 3.16: Mô hình MVC (Model – View – Controller)

3.2 Triển khai hệ thống website
Hệ thống được triển khai thử nghiệm trên máy tính cá nhân của sinh viên với
thông tin cấu hình như sau:
i. 01 CPU intel Core i5 10400, 6 lõi
ii. 02 RAM, tổng dung lượng 16GB
iii. Hệ điều hành MacOS phiên bản Bigsur 11.1
iv. MySQL phiên bản 5.7
• Về phía luồng logic hệ thống, hệ thống được cài đặt Python3.7 và một số gói,
thư viện như dưới bảng 3.4.
STT Tên gói, thư viện Lệnh cài đặt
1 Fastapi pip3 install fastapi
2 Apscheduler pip3 install apscheduler
3 Sqlalchemy pip3 install sqlalchemy
4 python-dotenv pip3 install python-dotenv
5 mysqlclient pip3 install mysqlclient
6 uvicorn[standard] pip3 install uvicorn[standard]
7 pydantic pip3 install pydantic
8 starlette pip3 install starlette

Bảng 3.5: Chi tiết các gói, thư viện cài đặt cho hệ thống
• Về phía giao diện, hệ thống sử dụng framework AngularJS phiên bản 12.1.0
với các gói. Để cài đặt, cần chuẩn bị dịch vụ npm và typescript phiên bản
4.3.5. Giao diện được xây dựng dựa trên mã nguồn mở của tác giả akveo.

3.3 Giao diện ứng dụng
Dưới đây là giao diện ứng dụng khi được hoàn thành. Giao diện được chia thành
2 phần chính là thanh menu hiển thị các chức năng trên website (nằm bên trái) và
giao diện cụ thể chức năng (ở bên phải màn hình).
3.3.1 Giao diện thêm luồng dữ liệu
Hình 3.17: Giao diện thêm luồng dữ liệu
Hình 3.11 hiển thị giao diện màn thêm luồng dữ liệu. Người dùng cần các bước
• Đặt tên luồng dữ liệu, chọn topic Kafka và cấu hình lược đồ dữ liệu. Nếu
chưa có topic tồn tại, có thể chọn nút “Create topic” để tạo topic mới, phù hợp
với mong muốn. Sau khi chọn topic xong, hệ thống sẽ trả về lược đồ dữ liệu
ứng với tin nhắn mới nhất trong topic đó.
• Ô “Message sample” để hiển thị tin nhắn mới nhất trong topic, người dùng có
thể nhìn vào đó và thấy các trường và kiểu dữ liệu đang có. Lược đồ sẽ được
tự động tạo xuống bên dưới, người dùng lúc này có thể chỉnh sửa (thêm, xóa)
thuộc tính các trường.
• Giao diện lược đồ được lấy ý tưởng từ giao diện phpmyadmin với 2 trường
bắt buộc là Name và Type lần lượt là tên và kiểu dữ liệu của trường đó. Tiếp
theo là các thông tin và ràng buộc bổ sung như khóa chính (PK – primary
key), không để trống (NN – not null), duy nhất (UQ – unique) và tự động tăng
(AI – Auto increment). Dưới cùng là chọn công cụ lưu trữ (Storage engine)
và kiểu ký tự lưu (Collation) cũng là tùy chọn cho bảng cần tạo.

3.3.2 Giao diện quản lý luồng dữ liệu
3.3.2.1. Giao diện quản lý
Hình 3.18: Giao diện quản lý luồng dữ liệu
Hình 3.12 hiển thị các luồng dữ liệu dưới dạng bảng. Mỗi dòng là một luồng dữ
liệu với các thông tin tên luồng và topic Kafka tương ứng. Khi nhấn vào một
luồng, hệ thống sẽ chuyển hướng qua. Ở bên phải mỗi dòng, 2 nút mũi tên và
thùng rác lần lượt là các chức năng xem dữ liệu trong luồng và xóa luồng.
3.3.2.2. Giao diện xem bản ghi dữ liệu của một luồng
Hình 3.19: Giao diện xem bản ghi luồng dữ liệu
Sau khi nhấn vào nút mũi tên ở màn quản lý luồng dữ liệu, màn hình sẽ được
chuyển hướng tới màn xem dữ liệu như Hình 3.13. Các dữ liệu sẽ được tự động
hiển thị theo trường dữ liệu tồn tại trong tin nhắn Kafka. Nhìn vào các dữ liệu
hiển thị, người dùng có thể xác định được luồng đang hoạt động chính xác và dữ
liệu đang truyền đến là đúng.

3.3.3 Giao diện quản lý công việc liên tục
Hình 3.20: Giao diện quản lý công việc liên tục
Trên Hình 3.14, giao diện chức năng quản lý công việc liên tục được hiển thị.
Đầu tiên, tên của công việc lưu dùng để gửi lên máy chủ Spark được hiển thị ở ô
trên cùng “job name”. Tiếp theo là các trạng thái của các dịch vụ kết nối tới hệ
thống và trạng thái của công việc trên Spark. Có 2 trạng thái là “Stopped” và
“Running” với các màu vàng và xanh tương ứng để thể hiện cho tình trạng đã
dừng hay là đang chạy. Khi ấn vào vòng tròn “Job streaming”, một cửa sổ khác
được bật ra trên trình duyệt, người dùng có thể xem được nhật ký đang hạy của
công việc này, từ đó dễ dàng hơn trong việc kiểm soát lỗi. Tiếp phía bên dưới là
chức năng lập lịch khởi động lại cho công việc liên tục. Có 2 dạng là chọn nhanh
(quick schedule) và chọn thủ công (manual schedule). Người dùng chọn lịch khởi
động lại công việc rồi ấn nút “SAVE” để lưu lại lịch này. Sau đó lịch sẽ được cập
nhật cho công việc.
3.3.4 Các giao diện chức năng khác
Dưới đây là giao diện của các chức năng khác trong hệ thống. Các chức năng cơ
bản bao gồm “Cấu hình hệ thống”, “Thêm câu truy vấn” và “Quản lý truy vấn”.
Các chức năng này do sinh viên Vũ Minh Hiếu thực hiện.

3.3.4.3. Giao diện cấu hình hệ thống
Hình 3.21: Giao diện cấu hình hệ thống
3.3.4.4. Giao diện thêm câu truy vấn
Hình 3.22: Giao diện thêm câu truy vấn

3.3.4.5. Giao diện quản lý câu truy vấn
Hình 3.23: Giao diện quản lý câu truy vấn

CHƯƠNG 4. THIẾT KẾ VÀ XÂY DỰNG HỆ THỐNG
QUẢN LÝ, XỬ LÝ DỮ LIỆU
4.1 Kiến trúc tổng quan hệ thống
Để giải quyết được vấn đề được nêu ra ở chương 1, hệ thống quản lý, xử lý dữ
liệu cần phải được thiết kế sao cho đáp ứng được các yêu cầu:
• Xử lý dữ liệu liên tục
• Gửi dữ liệu định kì theo tuần suất nhận thông báo của người dùng muốn
• Tùy chỉnh các điều kiện truy vấn trên luồng dữ liệu
Mô hình kiến trúc tổng thể hệ thống dưới đây sẽ giải quyết được vấn đề vừa nêu:
Hình 4.1: Kiến trúc tổng quan hệ thống quản lý, xử lý dữ liệu (Màu tím là các phần
chức năng sinh viên thực hiện, màu vàng là các phần chức năng thực hiện bởi sinh viên
Vũ Minh Hiếu)
Mô tả các thành phần có mặt tại sơ đồ kiến trúc hệ thống quản lý, xử lý dữ liệu
(Hình 4.1):
• Tin tức tuyển dụng, CV ứng tuyển: Các dữ liệu thông tin tuyển dụng,
thông tin ứng viên có được từ hệ thống thông tin việc làm yourway.vn
• Kafka (Công cụ truyền tải dữ liệu phân tán): Là thành phần module
truyền tải dữ liệu phân tán. Đảm nhiệm truyền tải các tin tuyển dụng,
thông tin ứng viên đồng thời cả kết quả của các truy vấn từ người dùng.

• Xác định cấu trúc luồng dữ liệu đầu vào: Đảm nhiệm xác định cấu
trúc luồng dữ liệu tuyển dụng, ứng viên và khởi tạo các bảng cấu trúc dữ
liệu luồng tại CSDL. Từ đó đưa ra tổng hợp các trường của luồng dữ
liệu, các kiểu dữ liệu của trường
• Khởi tạo truy vấn người dùng: Các truy vấn trên luồng dữ liệu do
người dùng thực hiện khởi tạo tại website. Câu truy vấn có thể được tùy
chỉnh linh hoạt theo nhu cầu với các tùy chọn truy vấn tìm kiếm có điều
kiện trên luồng (WHERE, HAVING BY), truy vấn tổng hợp (GROUP
BY), truy vấn sắp xếp (ORDER BY).
• Hệ thống website tương tác người dùng: Giao diện thân thiện trực
quan hỗ trợ người dùng khả năng tương tác với các thành phần hệ thống
quản lý, xử lý dữ liệu thông qua các API.
• API Services: Tập hợp các API hỗ quá trình giao tiếp giữa hệ thống
website tương tác người dùng và hệ thống quản lý, xử lý dữ liệu.
• MySQL: Cơ sở dữ liệu được dùng lưu trữ các thông tin cấu hình, câu
truy vấn người dùng, cấu trúc các luồng dữ liệu.
• Spark (Công cụ xử lý dữ liệu phân tán): Thành phần xử lý dữ liệu
phân tán. Đảm nhiệm trách nhiệm tương tác với các luồng dữ liệu liên
tục, xử lý các yêu cầu truy vấn và trả kết quả tới Kafka.
o Kết nối luồng dữ liệu đầu vào: Đảm nhiệm đọc các luồng dữ
liệu liên tục từ Kafka. Nhận về các dữ liệu từ luồng dữ liệu.
o Tạo lược đồ luồng dữ liệu: Xây dựng lược đồ cấu trúc luồng dữ
liệu liên tục nhận được từ CSDL.
o Xử lý truy vấn trên các luồng dữ liệu trong công việc Spark:
Xây dựng mã nguồn bằng các hàm của Spark, thực hiện xử lý các
truy vấn của người dùng.
o Chuẩn bị dữ liệu kết quả để gửi đến người dùng: Gửi kết quả
xử lý truy vấn tới các topic được người dùng cài đặt khi khởi tạo
truy vấn.
• Module lập lịch và nhận - gửi dữ liệu truy vấn: Module lập lịch xử lý
các dữ liệu kết quả truy vấn của người dùng. Ứng dụng thư viện
ApScheduler của ngôn ngữ Python.
o Khởi tạo lịch trình: Khởi tạo một lịch trình xử lý các kết quả
truy vấn cho mỗi truy vấn ngay sau khi yêu cầu khởi tạo truy vấn
của người dùng thành công và được lưu tại CSDL.
o Tiến trình nhận, gửi kết quả truy vấn: Tiến trình do Khởi tạo
lịch trình tạo ra mỗi khi người dùng thêm một câu truy vấn. Tiến
trình thực hiện nhận dữ liệu topic Kafka chứa các kết quả truy
vấn được người dùng cài đặt khi thêm mới truy vấn.
• Email: Các phương thức gửi kết quả truy vấn tới người dùng do người
dùng lựa chọn khi khởi tạo truy vấn.

4.2 Phát triển hệ thống quản lý và xử lý dữ liệu
Để xây dựng được hệ thống quản lý và xử lý dữ liệu, mô-đun Công cụ xử lý dữ
liệu phân tán được chia thành các phần riêng rẽ như sau:
- Kết nối các luồng dữ liệu đầu vào
- Tạo lược đồ luồng dữ liệu
- Xử lý truy vấn trên các luồng dữ liệu trong công việc Spark
- Chuẩn bị dữ liệu kết quả để gửi đến người dùng
Hình 4.2: Kiến trúc mô-đun Công cụ xử lý dữ liệu phân tán
Nhận thấy những thế mạnh của Structured Streaming đã đề cập đến ở phần trước
rất phù hợp với yêu cầu bài toán như: truy vấn, xử lý theo cấu trúc, kết hợp nhiều
đầu vào và tùy chỉnh được cả đầu ra. Sinh viên chọn công nghệ này làm phần lõi
để xây dựng mô-đun Công cụ xử lý dữ liệu phân tán.
Hình 4.3: Vai trò của Job Spark trong hệ thống
Giả sử trong thực tế, có một số sinh viên có các nhu cầu:

1. Tìm kiếm các công việc với mức lương (“salary”) lớn hơn 18 (triệu)
2. Thống kê số lượng công việc theo từng tên công ty (“company_name”)
3. Thống kê tổng số công việc có trong CSDL của trang web yourway
Như trên Hình 4.3, hệ thống trợ giúp các sinh viên này tạo các câu truy vấn dưới
dạng SQL tương ứng như trên hình (query_1, query_2, query_3). Luồng thực
hiện xử lý các truy vấn như sau:
• Bước đầu tiên Spark lấy dữ liệu công việc từ topic job_yourway làm
đầu vào
• Tạo lược đồ dữ liệu trong Spark ứng với dữ liệu công việc
• Tiếp theo, Spark tiếp tục tải các câu truy vấn đã được người dùng tạo
(lưu trong CSDL). Spark thực hiện truy vấn các câu truy vấn này trên
dữ liệu đã lấy từ topic job_yourway.
• Khi truy vấn xong, Spark trả lại kết quả đến topic output_query_1,
output_query_2 – là topic lưu kết quả truy vấn của câu
Nhưng một vấn đề phát sinh với cách làm này là làm sao để câu truy vấn SQL
kia có thể được cập nhật lên mô-đun Spark. Giả sử khi ta thêm một câu truy vấn
trong CSDL, Spark lúc này vẫn đang chạy độc lập, như vậy Spark chưa kịp cập
nhật thêm câu truy vấn mới để thực hiện yêu cầu.
Hình 4.4: Cách hoạt động của Mô-đun Công cụ xử lý dữ liệu phân tán
Giải pháp buộc phải sử dụng là hủy job Spark đang chạy đó và gửi lên một job
Spark mới. Nhưng nếu cứ mỗi lần thêm một câu truy vấn, ta hủy job Spark, thì
dẫn đến tình trạng quá tải nếu liên tục có câu truy vấn mới!
Để xử lý khó khăn này, sinh viên đưa ra phương án khởi động lại job Spark (gửi
lại) vào giữa đêm (00:00) mỗi ngày (như Hình 4.4). Lúc này các luồng dữ liệu
mới, các câu truy vấn sẽ được cập nhật lại, xử lý và xây dựng ra một tệp python
mới, khởi động lại mô-đun Công cụ xử lý dữ liệu phân tán (Spark) (trong thực tế

khi thực hiện, hệ thống cho phép người dùng tùy chỉnh khi nào thì mô-đun Spark
khởi động lại).
4.2.1 Kết nối các luồng dữ liệu đầu vào
Việc có rất nhiều luồng dữ liệu cùng đổ vào hệ thống khiến cho việc kiểm soát,
quản lý các luồng này thật sự khó khăn! Cần phải biết luồng dữ liệu xuất phát từ
đâu và không bị nhầm lẫn giữa các luồng.
Vấn đề như vậy được mô-đun “Công cụ truyền tải dữ liệu phân tán” với vai trò là
kênh giao tiếp với dữ liệu và cụ thể là Kafka giải quyết tốt. Tại đây, dữ liệu
được lưu dưới dạng các “message” trong các topic, mỗi luồng dữ liệu sẽ tương
ứng với một topic.
Những topic chứa dữ liệu đầu vào này được đưa đến một công việc spark hoạt
động trên máy chủ Spark. Sau đó dữ liệu đã được xử lý sẽ được chuyển đến một
topic khác trong Kafka. Từ đây các consumer thực hiện công việc lấy dữ liệu xử
lý xong và đưa đến người dùng qua mô-đun “Tiến trình nhận, gửi kết quả truy
vấn”. Hình dưới đây mô tả việc lấy dữ liệu từ Kafka khi hệ thống chạy:
Hình 4.5: Vai trò của Kafka trong hệ thống
Trong đó:
• Producer 1, 2, 3, 4 là các thực thể gửi dữ liệu đến cho các luồng dữ liệu.
Một topic có thể có nhiều producer cùng gửi dữ liệu đến. Trên hình
Producer 1 nhận nhiệm vụ gửi dữ liệu công việc đến topic job_yourway,
Producer 2, 3 gửi dữ liệu cv đến topic cv_yourway và Producer 4 gửi dữ
liệu các bài đăng đến cho topic post_yourway.
• Kết nối luồng dữ liệu đầu vào: nhận nhiệm vụ giao tiếp với các luồng dữ
liệu này với các câu truy vấn của người dùng.

Mỗi luồng dữ liệu đầu vào sẽ được truyền qua một topic trong Kafka đã được
chọn trước. Dữ liệu này được truyền dưới dạng json như là bản ghi trong cơ sở
dữ liệu, dưới đây là một ví dụ:
{
"id": 23,
"company_name": "Yourway",
"company_address": "Hai Ba Trung",
"salary": 30,
"ages": "25-30",
"education_level": "Đại học",
"position": "IT technician",
"job_attribute": "Toàn thời gian",
"year_experiences": 3,
"application_deadline": "02/02/2022"
}
Với các trường:
• “id”: Mã định danh công ty

• “company_name”: tên công ty
• “company_address”: địa chỉ công ty
• “salary”: mức lương
• “ages”: độ tuổi yêu cầu
• “education_level”: trình độ học vấn
• “position”: vị trí công việc
• “job_attribute”: loại công việc (bán thời gian/toàn thời gian)
• “year_experiences”: số năm kinh nghiệm
• “application_deadline”: Thời hạn ứng tuyển
Đầu tiên để lấy được dữ liệu từ Kafka, Spark sử dụng một cú pháp rất ngắn gọn
và dễ hiểu, thể hiện dưới Hình 4.6 như sau:

Hình 4.6: Đoạn mã đọc dữ liệu đầu vào từ Kafka
Ban đầu, cần khởi tạo một thực thể “spark” là SparkSession để có thể giao tiếp
với máy chủ Spark. Sau đó có thể cấu hình một số đặc tính như LogLevel để giới
hạn mức độ nhật ký của công việc. Spark hỗ trợ một tính năng readStream giúp
cho Job Spark có thể đọc được luồng dữ liệu liên tục từ Kafka. Ngoài ra,
readStream còn có thể đọc từ một số định dạng khác như Socket, Tệp, … Như
trên Hình 4.6 ta chỉ cần khai báo định dạng nguồn và topic Kafka là có thể đọc
được dữ liệu từ đó.
Như Hình 4.4 đã trình bày, mỗi khi có luồng dữ liệu mới thì khi khởi động lại,
Spark tự động cấu hình thêm các luồng đó. Do đó, có thể nhân rộng hơn để đọc
được từ nhiều topic, từ đó việc kết nối dữ liệu từ các luồng dữ liệu đã được giải
quyết.
4.2.2 Tạo lược đồ luồng dữ liệu
Spark Structured Streaming coi mỗi luồng dữ liệu từ Kafka là một bảng dữ liệu
với dữ liệu liên tục được thêm vào. Để có thể coi như là một bảng dữ liệu, mỗi
bản ghi đọc ra từ Kafka được cố định các trường dữ liệu trước. Tuy nhiên, các
trường dữ liệu này chứa thông tin của tin nhắn trong Kafka chứ không phải các
trường chứ trong tin nhắn. Như vậy, để có thể xử lý được dữ liệu công việc mong
muốn, cần phải đọc dữ liệu dưới dạng một lược đồ tương ứng với dữ liệu truyền
tới. Lược đồ này được lưu bằng lược đồ bảng trong CSDL ứng với luồng dữ liệu
việc làm này.

Hình 4.7: Đoạn mã tạo lược đồ dữ liệu trong công việc Spark
Trên Hình 4.7 biểu diễn việc chuyển đổi dữ liệu đọc được từ Kafka thành dạng
bảng với lược đồ định sẵn.
• Bước 1: định nghĩa lược đồ dựa theo lược đồ của bảng dữ liệu ứng với
luồng lưu trong CSDL.
• Bước 2: Vì được gửi dưới dạng tin nhắn trong Kafka và Structured
Streaming đọc dữ liệu dưới dạng bảng nên lúc này bảng dữ liệu chỉ tồn tại
cột key, value, offset, partition, timestamp, timestampType, topic là các
thông tin của tin nhắn. Do đó, muốn xử lý được dữ liệu ta cần một bước
chuyển dữ liệu sang dạng bảng với hàm from_json. Từ đây, với một cột
data sẽ được tự động tạo thêm các cột như trong schema_job đã định
nghĩa, mỗi cột chứa giá trị của trường tương ứng trong chuỗi json. Vì sau
đó sinh viên không sử dụng các thông tin tin nhắn nên chỉ lựa chọ các
trường có trong lược đồ qua hàm “select” (select("data.*")).
• Bước 3: Tạo bảng tạm thời TempView có tên là “job_yourway” (trùng tên
với topic Kafka) để phục vụ truy vấn.
Để tạo được lược đồ cố định trong tệp công việc Spark như trên Hình 4.7, khi tạo
ra tệp này, cần phải đọc được lược đồ từ bảng lưu lược đồ của luồng dữ liệu này.
Mỗi khi khởi động lại mô-đun Spark, hệ thống kiểm soát việc thêm luồng hoặc
xoá luồng dữ liệu bằng cách kiểm tra các bảng trong CSDL với tên có tiền tố là
“dbstreaming_streaming_”. Mỗi bảng này sẽ ứng với một luồng dữ liệu, các lược
đồ sẽ được lấy dựa trên lược đồ của bảng tương ứng trong CSDL. Đoạn mã dưới
Hình 4.8 dưới đây thể hiện việc này:

Hình 4.8: Đoạn mã tạo tự động lược đồ từ bảng dữ liệu
• Đầu tiên dựa vào phương thức Inspector.get_columns - thư viện

sqlalchemy (python3), có thể lấy được thông tin các cột của một bảng nhất
định. Có nhiều thông tin tương ứng với từng trường nhưng hệ thống chỉ
cần lấy kiểu dữ liệu của trường ra.
Ví dụ thông tin cột company_name:
Trên đây là các thông tin với trường dữ liệu kiểu VARCHAR.
o “name”: tên trường
o “type”: kiểu dữ liệu trong sqlalchemy
o “default”: dữ liệu mặc định

o “comment”: ghi chú
o “nullable”: có cho phép trống hay không
• Từ các thông tin này, với mỗi cột hệ thống sử dụng một từ điển có trước
(MAP_SQLALCHEMY_TYPE_TO_SPARK_SQL_TYPE) để có thể ánh xạ kiểu
dữ liệu của trường đó phù hợp với pyspark.
4.2.3 Xử lý truy vấn trên các luồng dữ liệu trong công việc Spark
Để thao tác với dữ liệu một cách mượt mà, dễ dàng nhất, người ta sử dụng một
ngôn ngữ đặc thù là SQL. Cũng vì thế mà để Spark là một công cụ mạnh khi thao
tác với dữ liệu thì không thể thiếu được mô-đun Spark SQL. Và Structured
Streaming thừa kế từ Spark SQL nên tất nhiên cũng có tính năng thao tác với
SQL. Dựa vào tính năng này, hệ thống cung cấp chức năng tương ứng, cho phép
người dùng tạo câu truy vấn có dạng SQL để truy vấn lên các “bảng” dữ liệu đã
lấy được ở phần trước. Và như vậy cách xử lý dữ liệu đơn giản được đưa về
phương thức truy vấn trên nhiều bảng có sẵn bằng SQL.
Như trình bày ở phần trước, Spark sẽ được khởi động lại theo một lịch cố định.
Khi khởi động lại Spark sẽ tải lại các truy vấn mới hoặc xóa các truy vấn người
dùng xóa đi rồi khởi động lại.

Hình 4.9: Đoạn mã đọc dữ liệu bằng SQL của job Spark
Như trong hình, ta thấy được các bước cơ bản để truy vấn dữ liệu trong job
Spark:
• Bước 1: Thực thi câu truy vấn của người dùng qua phương thức sql – một
tính năng của Spark SQL. Từ đây biến “data” sẽ lưu kết quả mong muốn
của người dùng.
• Bước 2: Để gửi lại được đến Kafka, cần phải chuyển lại dữ liệu theo đúng
định dạng key – value. Ta có hàm ngược lại là to_json thực hiện công việc
nén các cột lại thành một chuỗi json làm giá trị cho cột value mới. Tương
tự với cột key hệ thống sẽ lấy mặc định giá trị cột này là query_x với x là
định danh câu truy vấn trong CSDL
4.2.4 Chuẩn bị dữ liệu kết quả để gửi đến người dùng
Ở phần trên đã đề cập đến việc xử lý dữ liệu bằng SQL, việc còn lại là chuyển dữ
liệu đầu ra đến một topic Kafka đã được định nghĩa.
Hình 4.10: Chuẩn bị dữ liệu kết quả

Mỗi câu truy vấn công việc, Spark sẽ gửi trả ra một topic độc lập đã được chọn
trước. Trên đây, hai topic output_query_1 và output_query_2 lần lượt là 2 topic
chứa kết quả của 2 câu query_1, query_2 đã trình bày ở phía trên.
Hình 4.11: Đoạn mã cấu hình gửi dữ liệu đầu ra
Trên Hình 4.11, đoạn mã trình bày việc Spark sử dụng phương thức writeStream,
với format Kafka và truyền dữ liệu ra topic tương ứng.
Dữ liệu gửi ra này sẽ được mô-đun “Tiến trình nhận, gửi kết quả truy vấn” do
sinh viên Hiếu thực hiện xử lý tiếp. Cụ thể được trình bày dưới Hình 4.12.
Hình 4.12: Gửi trả dữ liệu đầu ra
Mỗi câu truy vấn tương ứng với một “lịch” ở trong hệ thống này. Ngay sau khi
thêm câu truy vấn, một tiến trình được lập để đợi đến khi đúng thời điểm thì thực
thi công việc lấy dữ liệu từ topic Kafka. Sau đó trả về cho người dùng qua các
phương tiện tùy theo lựa chọn ban đầu khi tạo câu truy vấn của người dùng.

4.3 Triển khai hệ thống quản lý, xử lý dữ liệu
Sau khi phân tích thiết kế hệ thống quản lý, xử lý dữ liệu hoàn tất, sinh viên thực
hiện cài đặt thử nghiệm hệ thống trên máy tính cục bộ với cấu hình:
• 01 CPU intel Core i5 10400, 6 lõi
• 02 RAM, tổng dung lượng 16GB
• Hệ điều hành MacOS phiên bản Bigsur 11.1
Ngoài ra các ứng dụng dữ liệu lớn được cài đặt:
• Apache Spark: phiên bản 3.1.2 với lệnh cài đặt: brew install spark
• Apache Kafka: phiên bản 2.8.0 với lệnh cài đặt: brew install kafka
Để tương tác được với các ứng dụng dữ liệu lớn, hệ thống sử dụng python3.7 làm
công cụ triển khai hệ thống. Các gói, thư viện cần cài đặt là:
STT Tên gói, thư viện Lệnh cài đặt
1 Pyspark pip3 install pyspark==3.1.2
2 Confluent-kafka pip3 install confluent-kafka
3 sqlparse pip3 install sqlparse

Bảng 4.1: Các gói, thư viện cần cho cài đặt hệ thống quản lý, xử lý dữ liệu

4.4 Kết quả và đánh giá
Một luồng hoàn chỉnh để người dùng sử dụng hệ thống và nhận được kết quả sẽ
được thực hiện theo các bước sau:
• Bước 1: Kết nối cơ sở dữ liệu:
• Bước 2: Thêm luồng dữ liệu, cụ thể là luồng dữ liệu công việc
Hình 4.13: Thêm luồng dữ liệu công việc
Sau khi thêm, kết quả được hiển thị như sau:

Hình 4.14: Kết quả luồng dữ liệu được thêm
• Bước 2: Thêm câu truy vấn lọc các công việc có địa chỉ ở khu vực Hai Bà
Trưng và mức lương trên 18 triệu
Hình 4.15: Thêm truy vấn
Kết quả khi thêm truy vấn
Hình 4.16: Kết quả thêm truy vấn

• Bước 3: Sau khi đã có luồng truy vấn và câu truy vấn trên luồng, thực
hiện khởi động công việc Spark:
Hình 4.17: Quản lý công việc Spark
• Bước 4: Kiểm tra công việc đã được khởi động thành công và không có
lỗi gì
Hình 4.18: Khởi động công việc thành công
• Bước 5: Sau khi thực hiện được một luồng dữ liệu hệ thống hoàn chỉnh,
kết quả của các câu truy vấn là các bản ghi dữ liệu, các thông tin mong
muốn sẽ được gửi đến người dùng qua các phương thức người dùng chọn
(mail, telegram, ...). Hình dưới đây biểu thị kết quả được gửi dưới dạng
email cho người dùng.

Hình 4.19: Kết quả được gửi đến người dùng qua email
• Do hạn chế về tài chính, hệ thống mới chỉ được triển khai dưới dạng
standalone dưới máy tính của sinh viên. Hệ thống chịu tải được xấp xỉ
1000 câu truy vấn và 20 luồng dữ liệu liên tục, không bị ngắt giữa chừng.

CHƯƠNG 5. KẾT LUẬN
5.1 Kết luận
Như vậy, theo mục tiêu được đặt ra ban đầu của đồ án, sinh viên đã nghiên cứu
và phát triển thành công được hệ thống cảnh báo dựa trên luồng dữ liệu việc làm.
Mặc dù sản phẩm chưa được triển khai trên nhiều cụm máy chủ để phát huy rõ
năng lực của công cụ phân tán Spark ngoài ra cũng chưa thực nghiệm nhiều trên
thực tế. Tuy nhiên kết quả này là toàn bộ công sức hiểu, nghiên cứu và học hỏi
của sinh viên trong suốt quá trình thực hiện đồ án tốt nghiệp này. Kết quả từ đồ
án sẽ là tiền đề, là nền móng cho sinh viên phát triển và cải tiến hệ thống trong
tương lai. Qua quá trình làm đồ án sinh viên cũng tự học và gặt hái được một số
thành quả.
Về kiến thức
• Tìm hiểu áp dụng các thư viện và công nghệ xử lý phân tán như Spark,
công nghệ xử lý dữ liệu liên tục như kafka, cho mô-đun xử lý dữ liệu phân
tán
• Kỹ năng xây dựng và triển khai tác vụ xử lý trong môi trường phân tán.
• Kỹ năng thiết kế hệ thống cho cơ sở dữ liệu hỗ trợ phân tích.
• Kỹ năng lập trình web, UI/UX
Về sản phẩm
• Mô-đun phân tích dữ liệu có khả năng xử lý các tập dữ liệu lớn
• Xử lý dữ liệu liên tục và trả ra kết quả cho người dùng dưới dạng email
• Giao diện website thân thiện, dễ hiểu, đáp ứng các tính năng cho hệ thống
5.2 Hướng phát triển trong tương lai
Từ mô-đun đã triển khai, trong thời gian tương lai, sinh viên mong muốn sẽ cải
tiến và mở rộng thêm số lượng máy chủ thực hiện tác vụ, cũng như chức năng
phân tích giúp mô hệ thống phục vụ tốt hơn cho việc đưa ra được số liệu tốt nhất
về thị trường tuyển dụng lao động Việt Nam, nhằm đưa đến nhiều thông tin giá
trị cho người lao động cũng như các nhà tuyển dụng. Một số công việc định
hướng để phát triển mô-đun trong tương lai đó là:
• Đưa hệ thống lên môi trường nền tảng đám mây (như AWS, Google
cloud, Azure …). Xây dựng cụm các máy chủ và kiểm thử hiệu năng hệ
thống.
• Phục vụ thêm nhiều dạng câu truy vấn ngoài select để người dùng có thể
tùy biến nhiều hơn với dữ liệu đã có.

TÀI LIỆU THAM KHẢO
[1] N. Naem, “Tổng quan về hệ phân tán - Distributed Systems,”. Available:

https://viblo.asia/p/serie-he-phan-tan-1-tong-quan-ve-he-phan-tan-distributed-
systems-924lJxAXKPM. [Đã truy cập 01 2022].
[2] T. C. T. KÊ, “Thông cáo báo chí tình hình lao động việc làm quý III và 9 tháng năm
2021,” [Trực tuyến]. Available: https://www.gso.gov.vn/du-lieu-va-so-lieu-thong-
ke/2021/10/thong-cao-bao-chi-tinh-hinh-lao-dong-viec-lam-quy-iii-va-9-thang-nam-
2021/. [Đã truy cập 01 2022].
[3] Gavin, "Khái niệm về Stream Processing,". Available: https://viblo.asia/p/khai-
niem-ve-stream-processing-GrLZDexelk0. [Đã truy cập 1 2022].
[4] Đ. H. Long, "Vì sao chọn FastAPI,". Available: https://viblo.asia/p/vi-sao-chon-
fastapi-gGJ59M6D5X2. [Đã truy cập 1 2022].
[5] N. C. S. B, “Giới thiệu tổng quan về Angular,”. Available: https://viblo.asia/p/gioi-
thieu-tong-quan-ve-angular-07LKX9j2ZV4. [Đã truy cập 1 2022].
[6] T. D. ,. J. T. ,. B. Y. ,. S. Z. ,. R. X. A. G. ,. I. S. ,. M. Z. Michael Armbrust,
"Structured Streaming: A Declarative API for Real-Time Applications in Apache
Spark," 2018.
[7] Loki, "Giới thiệu về Apache Kafka," 10 2018. Available:
https://123host.vn/tailieu/kb/vps/gioi-thieu-ve-kafka.html. [Đã truy cập 1 2022].
[8] M. M. I. MateiZaharia, “Spark: Cluster Computing with Working Sets,”
USENIXHotCloud, 2010.
[9] "Structured Streaming Programming Guide,". Available:
https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html.

Datn 20211 20173401 3.4m

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Datn 20211 20173401 3.4m

Uploaded by

Copyright:

Available Formats

ĐẠI HỌC BÁCH KHOA HÀ NỘI

XÂY DỰNG HỆ THỐNG CẢNH BÁO

NGUYỄN VĂN TIẾN

Ngành Công nghệ thông tin

Giảng viên hướng dẫn: TS. Trần Việt Trung

Trường: Công nghệ Thông tin và Truyền thông –

1. Thông tin về sinh viên

Giáo viên hướng dẫn

Hà Nội, ngày 23 tháng 01 năm 2022

Nguyễn Văn Tiến

Sinh viên thực hiện

MỤC LỤC ....................................................................................................................... v

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 1

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 2

1.3 Định hướng giải pháp

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 3

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 4

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 5

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 6

Hình 2.1: Minh họa stream processing

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 7

Hình 2.2: Thành phần Spark

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 8

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 9

Hình 2.3: Mô hình dữ liệu cơ bản của Structured Streaming [9]

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 10

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 11

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 12

Hình 2.5: Vai trò của Apache Kafka trong hệ thống

Ứng dụng của Kafka:

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 13

Hình 2.6: Mô hình cấu trúc kafka đơn giản

Hình 2.7: Mô hình cấu trúc kafka chi tiết

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 14

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 15

Cũng được hỗ trợ Cộng đồng của FastAPI

Phiên bản Tất cả phiên bản:

Project Có, chỉ cần run python

Không – đây là hạn chế

Phổ biến nhất là sử dụng

Bảng 2.1: So sánh FastAPI, Django và Flask

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 16

Hình 2.9: Kiến trúc angular

Angular có những ưu điểm:

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 17

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 18

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 19

Hình 3.2: Biểu đồ use case thêm luồng dữ liệu

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 20

5 Người dùng Chọn topic Kafka đầu vào

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 21

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 22

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 23

3.1.1.4. Ca sử dụng quản lý các luồng dữ liệu

Hình 3.4: Biểu đồ use case quản lý các luồng dữ liệu

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 24

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 25

Hình 3.5: Biểu đồ tuần tự use case “Thêm luồng dữ liệu”

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 26

Hình 3.6: Biểu đồ tuần tự use case “Thêm luồng dữ liệu”

3.1.2.3. Quản lý luồng dữ liệu

Hình 3.7: Biểu đồ tuần tự use case “Quản lý luồng dữ liệu”

Sinh viên: Nguyễn Văn Tiến – 20173401 – Khóa 62 27