Nội dung
- Yêu cầu - Bước 1 - Cài đặt MemSQL - Bước 2 - Chạy Điểm chuẩn - Bước 3 - Tương tác với MemSQL qua mysql-client - Bước 4 - Chèn và truy vấn JSON - Kết luận

Thứ tư, 30/09/2015 | 00:00 GMT+7

Cách cài đặt MemSQL trên Ubuntu 14.04

MemSQL là một loại database trong bộ nhớ có thể đọc và ghi nhanh hơn database truyền thống. Mặc dù nó là một công nghệ mới, nhưng nó sử dụng giao thức MySQL, vì vậy nó cảm thấy rất quen thuộc khi làm việc với nó.

Được viết với sự cộng tác của MemSQL

MemSQL đã chấp nhận các khả năng mới nhất của MySQL với các tính năng hiện đại, như hỗ trợ JSON và khả năng nâng cấp dữ liệu. Một trong những lợi thế lớn nhất của MemSQL so với MySQL là khả năng chia một truy vấn duy nhất trên nhiều nút, được gọi là xử lý song song hàng loạt , dẫn đến truy vấn đọc nhanh hơn nhiều.

Trong hướng dẫn này, ta sẽ cài đặt MemSQL trên một server Ubuntu 14.04 duy nhất, chạy các điểm chuẩn hiệu suất và chơi với việc chèn dữ liệu JSON thông qua client MySQL dòng lệnh.

Yêu cầu

Để làm theo hướng dẫn này, bạn cần :

Một Ubuntu 14.04 x64 Server với RAM ít nhất 8 GB
User không phải root có quyền sudo mà bạn có thể cài đặt theo hướng dẫn Cài đặt server ban đầu với Ubuntu 14.04

Bước 1 - Cài đặt MemSQL

Trong phần này, ta sẽ chuẩn bị môi trường làm việc để cài đặt MemSQL.

Phiên bản mới nhất của MemSQL được liệt kê trên trang download của họ . Ta sẽ download và cài đặt MemSQL Ops, là một chương trình quản lý việc download và chuẩn bị server của bạn để chạy MemSQL một cách chính xác. Phiên bản mới nhất của MemSQL Ops tại thời điểm viết bài này là 4.0.35.

Đầu tiên, download file gói cài đặt của MemSQL từ trang web của họ.

wget http://download.memsql.com/memsql-ops-4.0.35/memsql-ops-4.0.35.tar.gz

Tiếp theo, extract gói.

tar -xzf memsql-ops-4.0.35.tar.gz

Extract gói đã tạo một folder có tên là memsql-ops-4.0.35 . Lưu ý tên folder có số version , vì vậy nếu bạn download version mới hơn những gì hướng dẫn này chỉ định, bạn sẽ có một folder với version bạn đã download .

Thay đổi các folder vào folder này.

cd memsql-ops-4.0.35

Sau đó, chạy lệnh cài đặt , là một phần của gói cài đặt mà ta vừa extract .

sudo ./install.sh

Bạn sẽ thấy một số kết quả từ tập lệnh. Sau một lúc, nó sẽ hỏi bạn nếu bạn chỉ muốn cài đặt MemSQL trên server này. Ta sẽ xem xét cài đặt MemSQL trên nhiều máy trong một hướng dẫn trong tương lai. Vì vậy, với mục đích của hướng dẫn này, hãy nói có bằng lệnh y .

Đầu ra và nhắc lệnh cài đặt

. . . Do you want to install MemSQL on this host only? [y/N] y  2015-09-04 14:30:38: Jd0af3b [INFO] Deploying MemSQL to 45.55.146.81:3306 2015-09-04 14:30:38: J4e047f [INFO] Deploying MemSQL to 45.55.146.81:3307 2015-09-04 14:30:48: J4e047f [INFO] Downloading MemSQL: 100.00% 2015-09-04 14:30:48: J4e047f [INFO] Installing MemSQL 2015-09-04 14:30:49: Jd0af3b [INFO] Downloading MemSQL: 100.00% 2015-09-04 14:30:49: Jd0af3b [INFO] Installing MemSQL 2015-09-04 14:31:01: J4e047f [INFO] Finishing MemSQL Install 2015-09-04 14:31:03: Jd0af3b [INFO] Finishing MemSQL Install Waiting for MemSQL to start...

Đến đây bạn có một cụm MemSQL được triển khai đến server Ubuntu của bạn! Tuy nhiên, từ các bản ghi ở trên, bạn sẽ nhận thấy rằng MemSQL đã được cài đặt hai lần.

MemSQL có thể chạy với hai role khác nhau: một nút tổng hợp và một nút lá. Lý do tại sao MemSQL được cài đặt hai lần là vì nó cần ít nhất một nút tổng hợp và ít nhất một nút lá để một cụm hoạt động.

Nút tổng hợp là giao diện của bạn với MemSQL. Đối với thế giới bên ngoài, nó trông rất giống MySQL: nó lắng nghe trên cùng một cổng và bạn có thể kết nối các công cụ mong đợi để nói chuyện với MySQL và các thư viện MySQL tiêu chuẩn với nó. Công việc của người tổng hợp là biết về tất cả các node lá MemSQL, xử lý các client MySQL và dịch các truy vấn của họ sang MemSQL.

Một nút lá thực sự lưu trữ dữ liệu. Khi nút lá nhận được yêu cầu từ nút tổng hợp để đọc hoặc ghi dữ liệu, nó sẽ thực hiện truy vấn đó và trả kết quả cho nút tổng hợp. MemSQL cho phép bạn chia sẻ dữ liệu của bạn trên nhiều server và mỗi nút lá có một phần dữ liệu đó. (Ngay cả với một nút lá đơn, dữ liệu cũng được phân chia trong nút lá đó.)

Khi bạn có nhiều nút lá, trình tổng hợp chịu trách nhiệm dịch các truy vấn MySQL sang tất cả các node lá có liên quan đến truy vấn đó. Sau đó, nó nhận các phản hồi từ tất cả các node lá và tổng hợp kết quả thành một truy vấn trả về client MySQL của bạn. Đây là cách các truy vấn song song được quản lý.

Cài đặt server đơn của ta có trình tổng hợp và nút lá chạy trên cùng một máy, nhưng bạn có thể thêm nhiều nút lá khác trên nhiều máy khác.

Bước 2 - Chạy Điểm chuẩn

Hãy xem MemSQL có thể hoạt động nhanh như thế nào bằng cách sử dụng công cụ MemSQL Ops, được cài đặt như một phần của lệnh cài đặt của MemSQL.

Trong trình duyệt web , truy cập http:// your_server_ip :9000

Công cụ MemSQL Ops cung cấp cho bạn tổng quan về cụm của bạn. Ta có 2 nút MemSQL: bộ tổng hợp chính và nút lá.

Hãy thực hiện bài kiểm tra tốc độ trên nút MemSQL một máy của ta . Nhấp vào Kiểm tra tốc độ từ menu bên trái, sau đó nhấp vào BẮT ĐẦU KIỂM TRA . Đây là một ví dụ về kết quả mà bạn có thể thấy:

Kết quả ví dụ kiểm tra tốc độ

Ta sẽ không trình bày cách cài đặt MemSQL trên nhiều server trong hướng dẫn này, nhưng để so sánh, đây là điểm chuẩn từ một cụm MemSQL với ba nút Ubuntu 14.04 8GB (một nút tổng hợp và hai nút lá):

Bằng cách tăng gấp đôi số lượng nút lá, ta đã có thể tăng gần gấp đôi tỷ lệ chèn của bạn . Bằng cách nhìn vào các phần Đọc hàng , ta có thể thấy rằng cụm ba nút của ta có thể đọc đồng thời nhiều hơn 12 triệu hàng so với cụm nút đơn trong cùng một khoảng thời gian.

Bước 3 - Tương tác với MemSQL qua mysql-client

Đối với khách hàng, MemSQL trông giống như MySQL; cả hai đều nói cùng một giao thức. Để bắt đầu nói chuyện với cụm MemSQL của ta , hãy cài đặt một client mysql.

Đầu tiên, hãy cập nhật apt để ta cài đặt ứng dụng client mới nhất trong bước tiếp theo.

sudo apt-get update

Bây giờ, hãy cài đặt một client MySQL. Điều này sẽ cung cấp cho ta một lệnh mysql để thực thi.

sudo apt-get install mysql-client-core-5.6

Bây giờ ta đã sẵn sàng kết nối với MemSQL bằng client MySQL. Ta sẽ kết nối với quyền là user root với server lưu trữ 127.0.0.1 (là địa chỉ IP localhost của ta ) trên cổng 3306. Ta cũng sẽ tùy chỉnh thông báo nhắc cho memsql> .

mysql -u root -h 127.0.0.1 -P 3306 --prompt="memsql> "

Bạn sẽ thấy một vài dòng kết xuất theo sau là dấu nhắc memsql> .

Hãy liệt kê các database .

show databases;

Bạn sẽ thấy kết quả này.

Đầu ra database

+--------------------+ | Database           | +--------------------+ | information_schema | | memsql             | | sharding           | +--------------------+ 3 rows in set (0.01 sec)

Tạo một database mới được gọi là hướng dẫn .

create database tutorial;

Sau đó chuyển sang sử dụng database mới bằng lệnh use .

use tutorial;

Tiếp theo, ta sẽ tạo một bảng users sẽ có id một trường email . Ta phải chỉ định một kiểu cho hai trường này. Hãy đặt id là bigint và gửi email một varchar có độ dài là 255. Ta cũng sẽ cho database biết rằng trường id là khóa chính và trường email không được rỗng.

create table users (id bigint auto_increment primary key, email varchar(255) not null);

Bạn có thể nhận thấy thời gian thực hiện kém ở lệnh cuối cùng đó (15 - 20 giây). Có một lý do chính khiến MemSQL chậm tạo bảng mới này: tạo mã.

Về cơ bản, MemSQL sử dụng tạo mã để thực thi các truy vấn. Điều này nghĩa là khi nào gặp một loại truy vấn mới, MemSQL cần tạo và biên dịch mã đại diện cho truy vấn. Mã này sau đó được chuyển đến cụm để thực thi. Điều này giúp tăng tốc độ xử lý dữ liệu thực tế, nhưng có một khoản chi phí để chuẩn bị. MemSQL làm những gì có thể để sử dụng lại các truy vấn được tạo trước, nhưng các truy vấn mới có cấu trúc chưa bao giờ được nhìn thấy sẽ bị chậm lại.

Quay lại bảng user của ta , hãy xem định nghĩa bảng.

describe users;

Đầu ra định nghĩa bảng

+-------+--------------+------+------+---------+----------------+ | Field | Type         | Null | Key  | Default | Extra          | +-------+--------------+------+------+---------+----------------+ | id    | bigint(20)   | NO   | PRI  | NULL    | auto_increment | | email | varchar(255) | NO   |      | NULL    |                | +-------+--------------+------+------+---------+----------------+ 2 rows in set (0.00 sec)

Bây giờ, hãy chèn một số email mẫu vào bảng user . Cú pháp này giống như cú pháp mà ta có thể sử dụng cho database MySQL.

insert into users (email) values ('one@example.com'), ('two@example.com'), ('three@example.com');

Chèn kết quả email

Query OK, 3 rows affected (1.57 sec) Records: 3  Duplicates: 0  Warnings: 0

Bây giờ hãy truy vấn bảng user .

select * from users;

Bạn có thể xem dữ liệu ta vừa nhập:

Đầu ra bảng user

+----+-------------------+ | id | email             | +----+-------------------+ |  2 | two@example.com   | |  1 | one@example.com   | |  3 | three@example.com | +----+-------------------+ 3 rows in set (0.07 sec)

Bước 4 - Chèn và truy vấn JSON

MemSQL cung cấp một kiểu JSON, vì vậy trong bước này, ta sẽ tạo một bảng sự kiện để sử dụng các sự kiện đến. Bảng này sẽ có trường id (giống như ta đã làm cho user ) và event , sẽ là một loại JSON.

create table events (id bigint auto_increment primary key, event json not null);

Hãy chèn một vài sự kiện. Trong JSON, ta sẽ tham chiếu đến một trường email , lần lượt, tham chiếu trở lại ID của những user mà ta đã chèn trong bước 3.

insert into events (event) values ('{"name": "sent email", "email": "one@example.com"}'), ('{"name": "received email", "email": "two@example.com"}');

Bây giờ ta có thể xem qua các sự kiện mà ta vừa chèn.

select * from events;

Đầu ra bảng sự kiện

+----+-----------------------------------------------------+ | id | event                                               | +----+-----------------------------------------------------+ |  2 | {"email":"two@example.com","name":"received email"} | |  1 | {"email":"one@example.com","name":"sent email"}     | +----+-----------------------------------------------------+ 2 rows in set (3.46 sec)

Tiếp theo, ta có thể truy vấn tất cả các sự kiện có thuộc tính JSON name là văn bản “email đã nhận”.

select * from events where event::$name = 'received email';

Đầu ra truy vấn "đã nhận email"

+----+-----------------------------------------------------+ | id | event                                               | +----+-----------------------------------------------------+ |  2 | {"email":"two@example.com","name":"received email"} | +----+-----------------------------------------------------+ 1 row in set (5.84 sec)

Hãy thử thay đổi truy vấn đó để tìm những người có thuộc tính name là văn bản “email đã gửi”.

select * from events where event::$name = 'sent email';

Đầu ra truy vấn "đã gửi email"

+----+-------------------------------------------------+ | id | event                                           | +----+-------------------------------------------------+ |  1 | {"email":"one@example.com","name":"sent email"} | +----+-------------------------------------------------+ 1 row in set (0.00 sec)

Truy vấn mới nhất này chạy nhanh hơn nhiều so với truy vấn trước đó. Điều này là do ta chỉ thay đổi một tham số trong truy vấn, vì vậy MemSQL có thể bỏ qua quá trình tạo mã.

Hãy làm điều gì đó nâng cao cho database SQL phân tán: hãy nối hai bảng trên các khóa không phải khóa chính trong đó một giá trị của phép nối được lồng trong một giá trị JSON nhưng lọc trên một giá trị JSON khác.

Đầu tiên, ta sẽ yêu cầu tất cả các trường của bảng user có bảng sự kiện được tham gia bằng cách trùng với email có tên sự kiện là “email đã nhận”.

select * from users left join events on users.email = events.event::$email where events.event::$name = 'received email';

Đầu ra trường "email đã nhận"

+----+-----------------+------+-----------------------------------------------------+ | id | email           | id   | event                                               | +----+-----------------+------+-----------------------------------------------------+ |  2 | two@example.com |    2 | {"email":"two@example.com","name":"received email"} | +----+-----------------+------+-----------------------------------------------------+ 1 row in set (14.19 sec)

Tiếp theo, hãy thử truy vấn tương tự, nhưng chỉ lọc các sự kiện “email đã gửi”.

select * from users left join events on users.email = events.event::$email where events.event::$name = 'sent email';

Đầu ra trường "email đã gửi"

+----+-----------------+------+-------------------------------------------------+ | id | email           | id   | event                                           | +----+-----------------+------+-------------------------------------------------+ |  1 | one@example.com |    1 | {"email":"one@example.com","name":"sent email"} | +----+-----------------+------+-------------------------------------------------+ 1 row in set (0.01 sec)

Giống như trước đây, truy vấn thứ hai nhanh hơn nhiều so với truy vấn đầu tiên. Lợi ích của việc tạo mã được đền đáp khi thực thi trên hàng triệu hàng, như ta đã thấy trong điểm chuẩn. Tính linh hoạt khi sử dụng database SQL mở rộng hiểu JSON và cách kết hợp tùy ý giữa các bảng là một tính năng user mạnh mẽ.

Kết luận

Bạn đã cài đặt MemSQL, chạy điểm chuẩn về hiệu suất của nút, tương tác với nút của bạn thông qua ứng dụng client MySQL tiêu chuẩn và chơi với một số tính năng nâng cao không có trong MySQL. Đây hẳn là một trải nghiệm tốt về những gì database SQL trong bộ nhớ có thể làm cho bạn.

Vẫn còn rất nhiều điều để tìm hiểu về cách MemSQL thực sự phân phối dữ liệu , cách cấu trúc bảng để có hiệu suất tối đa, cách mở rộng MemSQL trên nhiều nút, cách sao chép dữ liệu để có tính khả dụng cao và cách bảo mật MemSQL.

Tags:

Các tin liên quan