Video
Đăng bởi Ban biên tập OpenER ·
Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
You guys can hear, uh, it's got a long lost brother or something. Lindsay I deal with, who wants his money or whatever his problem.
Các em nghe được chứ? Ừm, nó có một người anh em thất lạc từ lâu hay sao đó. Lindsay mà tôi làm việc cùng, người muốn lấy lại tiền của mình hay vấn đề gì đó của anh ta.
Sorry, a lot to cover today and next class, because we're trying to wrap up the end of the semester.
Xin lỗi, hôm nay và buổi sau có rất nhiều nội dung cần học, vì chúng ta đang cố gắng kết thúc phần cuối học kỳ.
But before we jump into the course material, again, for you guys in the course, Project 4 will be due on September 7th.
Nhưng trước khi vào nội dung bài học, một lần nữa, với các em trong lớp, Project 4 sẽ đến hạn vào ngày 7 tháng 9.
That link there will take you to the recitation from last week with the slides and all that.
Đường liên kết đó sẽ dẫn các em đến buổi thảo luận tuần trước, có slide và các tài liệu khác.
Homework 6 will go out later today, and that will be due on the same date, on December 7th. And the final exam is December 11th.
Homework 6 sẽ được đăng vào cuối ngày hôm nay, và hạn nộp cũng cùng ngày, tức là ngày 7 tháng 12. Còn bài thi cuối kỳ là ngày 11 tháng 12.
I'll post on Piazza this week, I'll post the final exam study guide along with the practice exam. Again, please don't make travel plans before this date because we won't be able to reschedule you.
Tuần này tôi sẽ đăng lên Piazza, tôi sẽ đăng hướng dẫn ôn tập cho bài thi cuối kỳ cùng với đề thi thử. Một lần nữa, đừng lên kế hoạch đi lại trước ngày này vì chúng tôi sẽ không thể sắp xếp lại lịch thi cho các em.
And then if you're, as I said last class, we'll be teaching 445 and 645 again next semester.
Và như tôi đã nói ở buổi trước, chúng tôi sẽ lại dạy 445 và 645 vào học kỳ sau.
If you love the class and can't get enough of it, please sign up to be a TA.
Nếu các em yêu thích môn học và chưa thấy đủ, hãy đăng ký làm TA.
If you hate BusTub and think it's the worst code you've ever seen in your life, then also sign up for a TA, because we want your opinion on how to fix things.
Nếu các em ghét BusTub và nghĩ đó là đoạn mã tệ nhất mình từng thấy trong đời, thì cũng hãy đăng ký làm TA, vì chúng tôi muốn nghe ý kiến của các em về cách sửa nó.
Any questions about any of these? Yes?
Có câu hỏi nào về những điều này không? Mời em?
The question is, how many pages for the cheat sheet for the final exam? It'll be the same as the midterm. The final exam will cover basically from the midterm until next class.
Câu hỏi là: tờ ghi chú cho bài thi cuối kỳ được mang bao nhiêu trang? Sẽ giống như bài thi giữa kỳ. Bài thi cuối kỳ về cơ bản sẽ bao gồm nội dung từ sau giữa kỳ đến buổi học sau.
It's a cumulative, not in the sense of like, am I gonna ask you specific questions like buffer pool stuff that we covered during the midterm, but you gotta know what SQL is, you gotta know what relational algebra is, because that's the background you need to understand all these other things.
Nó mang tính tích lũy, nhưng không phải theo nghĩa là tôi sẽ hỏi các em những câu cụ thể như về buffer pool mà chúng ta đã học trước giữa kỳ, nhưng các em phải biết SQL là gì, đại số quan hệ là gì, vì đó là kiến thức nền cần thiết để hiểu tất cả những thứ khác.
But the emphasis will be on things that came after the midterm. Other questions?
Nhưng trọng tâm sẽ là những nội dung sau giữa kỳ. Còn câu hỏi nào khác không?
And then it's a three hour, the slot is three hours, but it'll be the same, it'd be roughly the same length as it would have been on the midterm, so that you can complete it in an hour and 20 minutes.
Và thời gian thi là ba tiếng, khung giờ là ba tiếng, nhưng đề sẽ giống, độ dài sẽ xấp xỉ như bài giữa kỳ, để các em có thể hoàn thành trong một giờ 20 phút.
But if you want to take the full three hours, go for it. Okay? All right, database talks we have coming up.
Nhưng nếu muốn dùng đủ ba tiếng thì cứ làm. Được chứ? Được rồi, các buổi nói chuyện về cơ sở dữ liệu sắp tới.
Today, after class, we have a guy in the UK building a system called XTDB. This is a time series database system.
Hôm nay, sau giờ học, có một người ở Anh đang xây dựng một hệ thống tên là XTDB. Đây là một hệ cơ sở dữ liệu chuỗi thời gian.
We haven't really talked about time series too much, but it's basically, think of like, you're keeping track of time as a first class concept on tuples inside your database system.
Chúng ta chưa nói nhiều về chuỗi thời gian, nhưng về cơ bản, hãy hình dung là bạn theo dõi thời gian như một khái niệm hạng nhất trên các tuple bên trong hệ cơ sở dữ liệu của mình.
And I think what's cool that they can do is they can do multi-dimensional time. So we'll cover that.
Và tôi nghĩ điều thú vị là họ có thể xử lý thời gian đa chiều. Vậy nên chúng ta sẽ tìm hiểu phần đó.
Then a week from now, we'll have the guys from Snowflake building this thing called Apache Polaris. It's the catalog, it's an open source re-implementation of the Apache Iceberg catalog.
Rồi một tuần nữa, sẽ có những người từ Snowflake xây dựng thứ gọi là Apache Polaris. Đó là catalog, một bản triển khai lại mã nguồn mở của catalog Apache Iceberg.
Again, the background was Snowflake tried to buy Iceberg for $600 million. Databricks caught wind of that and came in and blew them out and paid for $1 billion for the Iceberg team.
Bối cảnh là Snowflake đã cố mua Iceberg với giá 600 triệu đô la. Databricks nghe được tin đó, nhảy vào và vượt mặt họ và trả 1 tỉ đô la cho đội ngũ Iceberg.
It was a company that had 40 people, had some revenue, but not $1 billion worth of revenue, and they got bought by Databricks. And then Snowflake made their own open source version called Polaris.
Đó là một công ty có 40 người, có chút doanh thu, nhưng doanh thu không đáng giá 1 tỉ đô la, và họ đã bị Databricks mua lại. Sau đó Snowflake làm phiên bản mã nguồn mở của riêng mình tên là Polaris.
But again, it's not to say that Snowflake is incompatible with Iceberg, just they weren't able to buy the Iceberg people.
Nhưng một lần nữa, không có nghĩa là Snowflake không tương thích với Iceberg, chỉ là họ không mua được những người làm Iceberg.
And then we had an addendum to the schedule for the seminar series this semester. There's an Apache project called Fluce.
Và chúng ta có một phần bổ sung cho lịch trình của chuỗi seminar học kỳ này. Có một dự án của Apache tên là Fluce.
I actually don't know what this does, but they sent me a lot of emails begging me to give a talk. So we'll figure out what they're gonna do.
Thật ra tôi không biết nó làm gì, nhưng họ gửi cho tôi rất nhiều email nài nỉ tôi cho họ thuyết trình. Nên chúng ta sẽ xem họ định làm gì.
I've never heard of it prior to them reaching out to me, and then I've never run across anybody using it.
Tôi chưa từng nghe đến nó trước khi họ liên hệ với tôi, và cũng chưa từng gặp ai dùng nó.
And that'll be, the Fluce talk will be the last talk for the semester, and then we'll kick off the seminar series in the spring.
Và buổi nói chuyện về Fluce sẽ là buổi cuối cùng của học kỳ, rồi chúng ta sẽ khởi động chuỗi seminar vào học kỳ mùa xuân.
Again, even if you graduate and leave CMU, if you still want to be involved and watch these videos on Zoom, please join us. A lot of my former students show up on these things.
Một lần nữa, ngay cả khi các bạn đã tốt nghiệp và rời CMU, nếu vẫn muốn tham gia và xem các video này trên Zoom, xin mời cứ tham gia cùng chúng tôi. Rất nhiều cựu sinh viên của tôi vẫn tham dự những buổi này.
Alright, so here's where we're at for this semester. What have we accomplished so far? As I said at the end of last class, we now know how to build a single-node database system.
Được rồi, đây là chỗ chúng ta đang đứng trong học kỳ này. Cho đến giờ chúng ta đã đạt được những gì? Như tôi đã nói ở cuối buổi học trước, giờ chúng ta đã biết cách xây dựng một hệ cơ sở dữ liệu đơn nút.
We know how to make it transactional, how to make it fault-tolerant, we know how to run queries on it, do some query planning for the SQL queries that show up.
Chúng ta biết cách làm cho nó hỗ trợ giao dịch, chịu lỗi, biết cách chạy truy vấn trên đó, và lập kế hoạch truy vấn cho các câu truy vấn SQL gửi đến.
And so now this class and next class is to now discuss at a high level what distributed database systems look like. And again, the databases themselves are hard to understand and build correctly.
Và bây giờ buổi này và buổi sau là để thảo luận ở mức tổng quan xem các hệ cơ sở dữ liệu phân tán trông như thế nào. Một lần nữa, bản thân cơ sở dữ liệu đã khó hiểu và khó xây dựng đúng.
And distributed databases just make this all even harder. That's why we do single-node stuff first, get the fundamentals down, and then we can understand how to make things distributed.
Và cơ sở dữ liệu phân tán làm mọi thứ càng khó hơn. Đó là lý do chúng ta học đơn nút trước, nắm vững nền tảng, rồi mới có thể hiểu cách làm cho mọi thứ phân tán.
And it's the basic, the same architecture we've been talking about, but now it's split across two or more nodes.
Về cơ bản vẫn là kiến trúc mà chúng ta đã nói đến, nhưng giờ nó được chia ra trên hai nút trở lên.
And the questions we're going to talk about today and next class is how we're actually going to be communicating across these nodes, whether we're going from the top down, or we're coming from the bottom up, or actually something more in the middle, where we're coordinating across the buffer pools, for example.
Và những câu hỏi chúng ta sẽ bàn hôm nay và buổi sau là làm thế nào để thực sự giao tiếp giữa các nút này, dù chúng ta đi từ trên xuống, hay từ dưới lên, hoặc thực ra là ở đâu đó giữa hai hướng, chẳng hạn khi phối hợp giữa các buffer pool.
So all the things that we talked about this entire semester, like how to run queries fast, how to make sure that if you crash and come back, you don't lose any data, all of that is still applicable here.
Vì vậy tất cả những gì chúng ta đã nói trong suốt học kỳ này, như cách chạy truy vấn nhanh, cách đảm bảo rằng nếu hệ thống bị sập rồi khởi động lại, bạn không mất dữ liệu nào, tất cả đều vẫn áp dụng ở đây.
It's just now we're talking about how to do this across multiple machines.
Chỉ là bây giờ chúng ta nói về cách làm điều đó trên nhiều máy.
Then also recall we had the discussion when we talked about parallel query execution on a single node. We made the distinction between parallel database systems and distributed database systems.
Ngoài ra hãy nhớ lại chúng ta đã thảo luận khi nói về thực thi truy vấn song song trên một nút. Chúng ta đã phân biệt giữa hệ cơ sở dữ liệu song song và hệ cơ sở dữ liệu phân tán.
And I said in a parallel database system, think of that like a single machine.
Và tôi đã nói rằng hệ cơ sở dữ liệu song song thì hãy hình dung như một máy đơn.
It could have multiple cores, multiple CPU sockets, and the communication between these different workers in our database would be very fast and assumed reliable.
Nó có thể có nhiều lõi, nhiều socket CPU, và việc giao tiếp giữa các worker khác nhau này trong cơ sở dữ liệu của chúng ta sẽ rất nhanh và được giả định là đáng tin cậy.
We can send messages over an IPC from one process or one thread to the next, and it's guaranteed to show up.
Chúng ta có thể gửi thông điệp qua IPC từ một tiến trình hay một luồng sang cái tiếp theo, và chắc chắn nó sẽ đến nơi.
If it doesn't show up, then our CPU is melting down, we have other problems. So now for distributed database systems, now we can't ignore some of the things we could ignore in parallel databases.
Nếu nó không đến, thì CPU của chúng ta đang cháy chảy rồi, ta có những vấn đề khác. Còn bây giờ với các hệ cơ sở dữ liệu phân tán, chúng ta không thể bỏ qua một số điều mà ta có thể bỏ qua trong cơ sở dữ liệu song song.
For example, we can't assume that communicating between the nodes is going to be fast.
Ví dụ, ta không thể giả định rằng việc giao tiếp giữa các nút sẽ nhanh.
Because I might have to go around to the other side of the planet, and now you're limited by the speed of light, and that can take 100, 300 milliseconds.
Vì tôi có thể phải đi vòng sang bên kia hành tinh, và lúc đó bạn bị giới hạn bởi tốc độ ánh sáng, và việc đó có thể mất 100, 300 mili giây.
Worst case scenario, up in the tens of seconds, or even minutes if things get lost and things recover in weird ways.
Trường hợp xấu nhất, lên đến hàng chục giây, hoặc thậm chí vài phút nếu mọi thứ bị thất lạc và phục hồi theo những cách kỳ lạ.
And so not only is communication between the workers going to be much slower, orders of magnitude slower, it's also potentially unreliable.
Vì vậy, không chỉ việc giao tiếp giữa các worker chậm hơn nhiều, chậm hơn nhiều bậc độ lớn, mà nó còn có thể không đáng tin cậy.
Meaning we could send a message from one node to the next, and that message may not show up. Because the network got severed, the packet got dropped, whatever.
Nghĩa là ta có thể gửi một thông điệp từ nút này sang nút kia, và thông điệp đó có thể không đến nơi. Vì mạng bị đứt, gói tin bị rớt, hay vì lý do nào đó.
Or, in some cases, and this is sometimes common too, is that I send my message to the other worker, or to the other node, and it's running Go or Java, pick your favorite memory managed environment, and then the garbage collector kicks in.
Hoặc, trong một số trường hợp, và điều này đôi khi cũng phổ biến, là tôi gửi thông điệp cho worker kia, hay nút kia, và nó đang chạy Go hoặc Java, cứ chọn môi trường quản lý bộ nhớ tự động mà bạn thích, rồi bộ thu gom rác bắt đầu chạy.
Like in the JVM, if you have a huge heap, the garbage collector can block all execution for like, I don't know, 10, 30 seconds? Worst case scenario.
Như trong JVM, nếu bạn có một heap rất lớn, bộ thu gom rác có thể chặn toàn bộ việc thực thi trong khoảng, tôi không biết nữa, 10, 30 giây? Trường hợp xấu nhất.
So now it looks like that node doesn't exist anymore, but it's just waiting to clean some stuff up before it can process your message. So now how do you actually want to handle that?
Lúc này trông như nút đó không còn tồn tại nữa, nhưng thực ra nó chỉ đang chờ dọn dẹp một số thứ trước khi có thể xử lý thông điệp của bạn. Vậy bây giờ bạn thực sự muốn xử lý chuyện đó thế nào?
So if you take a distributed systems course, they talk a lot about consensus Protocols, Paxos, Raft, things like that. All that is going to be applicable here. We'll build up to that.
Nếu bạn học một môn về hệ phân tán, họ nói rất nhiều về các giao thức đồng thuận, Paxos, Raft, những thứ như vậy. Tất cả những thứ đó sẽ áp dụng được ở đây. Chúng ta sẽ xây dựng dần tới đó.
We first want to understand what the architecture of our data system is going to look like.
Trước tiên ta muốn hiểu kiến trúc của hệ thống dữ liệu sẽ trông như thế nào.
And then we'll apply these different techniques to layer on top of them and make these things more reliable and fault tolerant. So this is what I've already said before.
Rồi sau đó ta áp dụng các kỹ thuật khác nhau này, xếp chồng lên trên chúng và làm cho các hệ thống này đáng tin cậy hơn và chịu lỗi tốt hơn. Đây là điều tôi đã nói trước đây.
Because we're going multi-node doesn't mean we can throw away the entire textbook or everything we talked about this entire semester. All the things we talked about so far matter in this world as well.
Việc chúng ta chuyển sang nhiều nút không có nghĩa là có thể vứt bỏ toàn bộ giáo trình hay mọi thứ chúng ta đã nói suốt cả học kỳ này. Tất cả những gì ta đã nói đến giờ vẫn quan trọng trong thế giới này.
It's just everything's more complicated now because we're dealing with multiple hardware, multiple machines, potentially running in different data centers, and in some cases with disparate hardware resources.
Chỉ là mọi thứ giờ phức tạp hơn vì chúng ta phải làm việc với nhiều phần cứng, nhiều máy, có thể chạy ở các trung tâm dữ liệu khác nhau, và trong một số trường hợp với tài nguyên phần cứng không đồng nhất.
Like my node over in that other data center there might have fewer cores than I do.
Như nút của tôi ở trung tâm dữ liệu khác kia có thể có ít lõi hơn tôi.
So now I've got to consider that in how I do my query optimization, my planning, how I'm going to maybe run my concurrency protocol, what transactions should run where.
Vì vậy giờ tôi phải cân nhắc điều đó trong cách tôi tối ưu hóa truy vấn, lập kế hoạch, cách tôi có thể sẽ chạy giao thức điều khiển đồng thời, giao dịch nào nên chạy ở đâu.
All that we have to deal with.
Tất cả những điều đó chúng ta đều phải xử lý.
So there's some high-level design decisions we're going to cover in the next two lectures of how to build a distributed data system.
Vậy có một số quyết định thiết kế ở mức cao mà chúng ta sẽ đề cập trong hai bài giảng tới về cách xây dựng một hệ thống dữ liệu phân tán.
The first is going to be: how does an application find the data? If now my database can be split across multiple nodes or managed by multiple nodes, who does the application actually talk to?
Điều đầu tiên là: ứng dụng tìm dữ liệu bằng cách nào? Nếu giờ đây cơ sở dữ liệu của tôi có thể được chia ra trên nhiều nút hoặc được nhiều nút quản lý, thì ứng dụng thực sự giao tiếp với nút nào?
It was simple when it was one node. I just connect to it through whatever the communication protocol, the network protocol that the data center exposed to me.
Khi chỉ có một nút thì mọi thứ rất đơn giản. Tôi chỉ việc kết nối tới nó qua bất kỳ giao thức truyền thông nào, giao thức mạng mà trung tâm dữ liệu cung cấp cho tôi.
I know my data is going to be there. But now if my data is split across multiple machines, how do I go and find it?
Tôi biết dữ liệu của mình sẽ nằm ở đó. Nhưng bây giờ nếu dữ liệu của tôi bị chia ra trên nhiều máy, thì làm sao tôi đi tìm nó?
And where do I send the actual queries to do it? Then we're going to talk about how we want to divide the resources of the database system across these different workers or nodes.
Và tôi gửi các truy vấn thực sự tới đâu để làm việc đó? Sau đó, chúng ta sẽ nói về cách muốn phân chia tài nguyên của hệ quản trị cơ sở dữ liệu cho các worker hay nút khác nhau này.
How do we split things up on a per table basis?
Chúng ta chia mọi thứ theo từng bảng như thế nào?
And then how does the application know that I split things up a certain way, if at all, to go find the data that needs to run a query?
Và sau đó ứng dụng làm sao biết được rằng tôi đã chia theo một cách nào đó, nếu có chia, để đi tìm dữ liệu cần thiết cho việc chạy một truy vấn?
And then when a query shows up on one of these workers in our distributed system, how are they going to execute that query?
Và khi một truy vấn đến một trong các worker này trong hệ thống phân tán của chúng ta, chúng sẽ thực thi truy vấn đó như thế nào?
Especially if the data that the query needs to access isn't on the machine that my query is actually running.
Đặc biệt nếu dữ liệu mà truy vấn cần truy cập không nằm trên máy mà truy vấn của tôi đang chạy.
Do I send the query to where the data is located, or I pull the data to where I'm located, where my query is executing, and run things there?
Tôi gửi truy vấn tới nơi đặt dữ liệu, hay kéo dữ liệu về nơi tôi đang ở, nơi truy vấn đang thực thi, rồi chạy mọi thứ tại đó?
And then, of course, again, as I sort of said, in the world of distributed systems, this matters a lot. The distributed system is basically a database system, at the end of the day.
Và tất nhiên, như tôi đã nói, trong thế giới các hệ thống phân tán, điều này rất quan trọng. Suy cho cùng, hệ thống phân tán về cơ bản vẫn là một hệ quản trị cơ sở dữ liệu.
So how do we make sure that we guarantee consistency and correctness across our entire database system so that the application doesn't deal with any of the anomalies and issues that we've talked about before?
Vậy làm sao đảm bảo được tính nhất quán và tính đúng đắn trên toàn bộ hệ cơ sở dữ liệu của chúng ta để ứng dụng không phải xử lý bất kỳ dị thường và vấn đề nào mà chúng ta đã nói trước đây?
And in some systems, they're just going to throw caution to the wind and say, well, you know, guaranteeing consistency and correctness is hard, so we're not going to really do it.
Và ở một số hệ thống, họ cứ mặc kệ rủi ro và nói rằng, bạn biết đấy, đảm bảo tính nhất quán và tính đúng đắn là khó, nên chúng tôi sẽ không thực sự làm điều đó.
We're not going to do it immediately. And then what are the implications of that in your application?
Chúng tôi sẽ không làm ngay lập tức. Vậy hệ quả của điều đó đối với ứng dụng của bạn là gì?
So for today's lecture, it's going to be some hodgepodge of ideas of building up the basics of what a distributed database system is going to look like for us.
Với bài giảng hôm nay, sẽ là một tập hợp các ý tưởng khá tạp nham để xây dựng những điều cơ bản về việc một hệ cơ sở dữ liệu phân tán sẽ trông như thế nào với chúng ta.
And then next class, we'll go in more detail on how we're going to do distributed concurrency control and how we're going to run distributed OLAP queries, so distributed analytical queries, or how do we do joins across multiple nodes, for example.
Và sang buổi sau, chúng ta sẽ đi sâu hơn vào cách thực hiện điều khiển đồng thời phân tán và cách chạy các truy vấn OLAP phân tán, tức là các truy vấn phân tích phân tán, hoặc ví dụ như cách thực hiện phép nối trên nhiều nút.
So first, we'll talk about what the high-level system architectures could look like. Then we'll talk about how to split up the data in our partitioning schemes.
Đầu tiên, chúng ta sẽ nói về kiến trúc hệ thống ở mức cao có thể trông như thế nào. Sau đó, chúng ta sẽ nói về cách chia nhỏ dữ liệu trong các lược đồ phân vùng.
Then we'll talk about replication, How to make sure that if we have multiple copies of data, which we need for fault tolerance, those are going to be in sync, and then we'll segue into how to do transactions across these things.
Tiếp theo, chúng ta sẽ nói về sao chép dữ liệu (replication), tức là làm sao đảm bảo rằng nếu có nhiều bản sao của dữ liệu, mà ta cần để chịu lỗi, thì các bản sao đó sẽ được đồng bộ, và rồi chúng ta sẽ chuyển sang cách thực hiện giao dịch trên các thành phần này.
Again, another key difference about distributed databases and parallel databases is that with parallel databases, you're adding more resources to get better performance. In a distributed database system, we want to do that as well.
Một khác biệt quan trọng nữa giữa cơ sở dữ liệu phân tán và cơ sở dữ liệu song song là với cơ sở dữ liệu song song, bạn thêm tài nguyên để có hiệu năng tốt hơn. Với hệ cơ sở dữ liệu phân tán, chúng ta cũng muốn làm như vậy.
We want to add more resources to get better performance. But sometimes you also want to add more resources so we get better fault tolerance or availability.
Chúng ta muốn thêm tài nguyên để có hiệu năng tốt hơn. Nhưng đôi khi bạn cũng muốn thêm tài nguyên để có khả năng chịu lỗi hoặc tính sẵn sàng tốt hơn.
So if one node goes down, the application can still keep running and query the database.
Vì vậy nếu một nút bị hỏng, ứng dụng vẫn có thể tiếp tục chạy và truy vấn cơ sở dữ liệu.
Again, if it's a parallel database running on a single box, it's kind of hard to do. So the first thing we're going to discuss is what the system architecture is going to look like.
Còn nếu là cơ sở dữ liệu song song chạy trên một máy duy nhất thì khá khó làm được điều này. Vậy điều đầu tiên chúng ta sẽ thảo luận là kiến trúc hệ thống sẽ trông như thế nào.
And this is going to specify, or this is going to determine, how the resources that are available to us on a machine, on a computing machine, how they're going to be accessed and maintained by the database system, and then how these resources are going to communicate with each other.
Và điều này sẽ quy định, hay xác định, cách các tài nguyên mà chúng ta có trên một máy, trên một máy tính, được hệ quản trị cơ sở dữ liệu truy cập và quản lý như thế nào, và các tài nguyên này giao tiếp với nhau ra sao.
And you can sort of think of it like the CPU is obviously the central processing unit, but it's the computational unit on a single node in our system, but it has to have memory, it has to have disk.
Bạn có thể hình dung như thế này: CPU rõ ràng là đơn vị xử lý trung tâm, là đơn vị tính toán trên một nút của hệ thống, nhưng nó phải có bộ nhớ, phải có đĩa.
The question is where is the disk and where is the memory amongst other nodes in the system? So this terminology goes back to the 1980s.
Câu hỏi là đĩa nằm ở đâu và bộ nhớ nằm ở đâu so với các nút khác trong hệ thống? Thuật ngữ này có từ những năm 1980.
It's the definition of these categories of what these databases look like. So without you knowing it, everything we've talked about this semester so far is called a shared everything system.
Đó là định nghĩa các loại cơ sở dữ liệu này trông như thế nào. Vậy là, mà có thể bạn không biết, mọi thứ chúng ta đã nói trong học kỳ này cho đến giờ được gọi là hệ thống shared everything.
And the idea is that on a single node, it has the CPU, and the CPU can talk to its own memory and can talk to its own disk.
Ý tưởng là trên một nút duy nhất có CPU, và CPU có thể truy cập bộ nhớ riêng và đĩa riêng của nó.
Everything is encapsulated on a single box.
Mọi thứ nằm gọn trong một máy.
A shared nothing system is where there are individual nodes that each have their own CPU, their own local memory, and their own local disk.
Hệ thống shared nothing là hệ thống gồm các nút riêng lẻ, mỗi nút có CPU riêng, bộ nhớ cục bộ riêng và đĩa cục bộ riêng.
And the only way they can communicate with other nodes in our distributed system is through some high-level network up above.
Và cách duy nhất để chúng giao tiếp với các nút khác trong hệ thống phân tán là thông qua một mạng ở mức cao phía trên.
So basically, the CPU on one node can't read into the memory or disk of another node directly.
Về cơ bản, CPU trên một nút không thể đọc trực tiếp vào bộ nhớ hay đĩa của nút khác.
It has to send a message that the CPU then processes on the other node and say, "Hey, I want this block of data," or "I want you to do this for me," and gets back the result.
Nó phải gửi một thông điệp để CPU trên nút kia xử lý, kiểu như: "Này, tôi muốn khối dữ liệu này," hoặc "tôi muốn bạn làm việc này giúp tôi," rồi nhận lại kết quả.
This network most often is going to be TCP/IP. There are some systems where they can do UDP. Some systems can do more fancy things like Mellanox, RDMA.
Mạng này thường là TCP/IP. Có một số hệ thống dùng được UDP. Một số hệ thống làm được những thứ cao cấp hơn như Mellanox, RDMA.
But in general, assume they're just opening up TCP sockets and sending messages back and forth. Another architecture is called shared disk.
Nhưng nhìn chung, hãy cứ giả sử chúng chỉ mở các TCP socket và gửi thông điệp qua lại. Một kiến trúc khác được gọi là shared disk.
And this is where every node is going to have its own CPU and own memory.
Ở đây, mỗi nút có CPU và bộ nhớ riêng.
But the database, the primary resting location of the database, is now going to be on some global disk that all the nodes can read and write to.
Nhưng cơ sở dữ liệu, tức nơi lưu trữ chính của cơ sở dữ liệu, giờ sẽ nằm trên một đĩa toàn cục nào đó mà tất cả các nút đều có thể đọc và ghi.
So now, if I want to send a message to another node, you still would do TCP up above, but if I want to read data on another node, I don't have to go over TCP/IP to communicate with the other nodes.
Vậy bây giờ, nếu tôi muốn gửi một thông điệp đến nút khác, bạn vẫn dùng TCP ở phía trên, nhưng nếu tôi muốn đọc dữ liệu trên một nút khác, tôi không cần đi qua TCP/IP để giao tiếp với các nút đó.
I go directly down to the disk and go and get it.
Tôi đi thẳng xuống đĩa và lấy dữ liệu về.
And then this one is theoretical. It's in the academic literature, but I'm not aware of any data system that actually does this outside of the high-performance computing world, scientific stuff.
Còn kiến trúc này thì mang tính lý thuyết. Nó có trong các tài liệu học thuật, nhưng tôi không biết hệ thống dữ liệu nào thực sự làm vậy ngoài lĩnh vực điện toán hiệu năng cao, các ứng dụng khoa học.
It's called shared memory.
Nó được gọi là shared memory.
Basically, every node only has a stateless CPU, and then the memory and the disk is shared across all the different nodes.
Về cơ bản, mỗi nút chỉ có một CPU không lưu trạng thái, còn bộ nhớ và đĩa được chia sẻ giữa tất cả các nút.
This question is, isn't a shared everything system fundamentally a shared memory system? Just think about having multiple nodes. If I have multiple of these, shared everything, then I'm essentially shared nothing.
Câu hỏi này là, hệ thống shared everything về bản chất chẳng phải là hệ thống shared memory sao? Hãy nghĩ đến việc có nhiều nút. Nếu tôi có nhiều hệ thống shared everything như vậy, thì về cơ bản tôi đang ở shared nothing.
Because again, the CPU can't read and write to the disk or memory on the other nodes without going to the network at the top.
Vì một lần nữa, CPU không thể đọc và ghi vào đĩa hay bộ nhớ của các nút khác nếu không đi qua mạng ở phía trên.
The question is, is shared everything fundamentally a single machine? Yes.
Câu hỏi là, shared everything về bản chất có phải là một máy đơn không? Đúng vậy.
The question is, are we treating shared disks as having multiple disks, meaning like I'm showing one, but it can have more? Yeah, we'll get there. Yes.
Câu hỏi là, chúng ta có coi shared disk là có nhiều đĩa không, nghĩa là tôi đang vẽ một đĩa, nhưng nó có thể có nhiều hơn? Vâng, chúng ta sẽ đến phần đó. Vâng.
But it looks logically as one disk that everyone can read and write to. S3, yes. They're correct. We're getting there. S3 would be shared disk.
Nhưng về mặt logic, nó trông như một đĩa duy nhất mà mọi người đều đọc và ghi được. S3, đúng vậy. Bạn nói đúng. Chúng ta sẽ đến phần đó. S3 là shared disk.
The question is, for shared nothing, is the network what? Sorry?
Câu hỏi là, với shared nothing, mạng là gì? Xin lỗi, bạn nói gì?
For ingress? For data coming in?
Cho ingress? Cho dữ liệu đi vào?
We haven't talked about what we're communicating with. Let's say a query shows up on one of these nodes, this middle node here, and that query needs to read data on this other node.
Chúng ta chưa nói về việc đang giao tiếp với cái gì. Giả sử một truy vấn đến một trong các nút này, nút ở giữa đây, và truy vấn đó cần đọc dữ liệu trên nút kia.
It can't go reach into that other node and it's into a disk directly, or its memory, and go read stuff.
Nó không thể với tới nút kia và truy cập trực tiếp vào đĩa, hay bộ nhớ của nút đó, để đọc dữ liệu.
It's got to send a message that the CPU then processes and says, oh, they want this data, let me send it back over to you.
Nó phải gửi một thông điệp để CPU xử lý rồi nói: ồ, họ muốn dữ liệu này, để tôi gửi lại cho bạn.
So, shared everything is most common because most people build a single-node database system first. For shared nothing, this was the way you would build a distributed database going back to the 1980s.
Vậy, shared everything là phổ biến nhất vì hầu hết mọi người xây dựng hệ cơ sở dữ liệu một nút trước. Còn shared nothing, đây là cách bạn xây dựng một cơ sở dữ liệu phân tán từ những năm 1980.
The guy that invented Postgres, Mike Stonebraker, wrote a paper in 1986. Sort of touting the advantages of shared nothing systems, and this is how people built basically shared nothing systems for 20, 30 years.
Người phát minh ra Postgres, Mike Stonebraker, đã viết một bài báo năm 1986. Nhằm đề cao những ưu điểm của các hệ thống shared nothing, và đó là cách mọi người xây dựng các hệ thống shared nothing trong 20, 30 năm.
The popularity is on the decline now because of the cloud, things like S3 and other distributed architectures. Most of the newer systems today are going to be shared disk.
Hiện nay mức độ phổ biến của nó đang giảm dần vì đám mây, như S3 và các kiến trúc phân tán khác. Hầu hết các hệ thống mới ngày nay đều theo kiểu shared disk.
The question is, is Spanner shared nothing or shared disk? Spanner is shared nothing. But it reads and writes from Borg, the distributed file system, so the lines get blurred.
Câu hỏi là: Spanner là shared nothing hay shared disk? Spanner là shared nothing. Nhưng nó đọc và ghi từ Borg, hệ thống tệp phân tán, nên ranh giới bị mờ đi.
As far as I know, nobody does this, so we're not going to spend any time on it. So, shared nothing.
Theo tôi biết thì không ai làm kiểu này, nên chúng ta sẽ không dành thời gian cho nó. Vậy, shared nothing.
Shared nothing, again, is every single node has its own local disk and own local memory, and then any time you need to communicate with another node, you've got to send a message over that network.
Shared nothing, nhắc lại, là mỗi một nút có đĩa cục bộ riêng và bộ nhớ cục bộ riêng, và bất cứ khi nào bạn cần giao tiếp với một nút khác, bạn phải gửi một thông điệp qua mạng đó.
So, again, you can't just go reach down into the other node and get the data you want.
Vậy nên, nhắc lại, bạn không thể cứ thế với tay vào nút kia và lấy dữ liệu mình muốn.
So, this is going to get the best performance you can have in a distributed data system, because every node can process the data that it just has, and it's going to be the most efficient way to access things, because I don't have to go reach in other nodes, go get the data that I need, and go process everything I need locally.
Vậy, cách này sẽ cho hiệu năng tốt nhất mà một hệ dữ liệu phân tán có thể có, vì mỗi nút có thể xử lý dữ liệu mà nó đang có, và đây sẽ là cách truy cập hiệu quả nhất, vì tôi không phải với sang các nút khác để lấy dữ liệu cần thiết, mà xử lý mọi thứ cần thiết ngay tại chỗ.
The challenge is going to be, and this is why in the cloud world the shared disk is more popular, that this can be harder to scale out.
Thách thức là, và đây là lý do trong thế giới đám mây shared disk phổ biến hơn, cách này có thể khó mở rộng quy mô (scale out) hơn.
If I want to add new nodes, I can't just say, you have new nodes, now point to the same shared disk.
Nếu tôi muốn thêm nút mới, tôi không thể chỉ nói: bạn có các nút mới, giờ hãy trỏ đến cùng một đĩa dùng chung.
I actually get to physically move data. We'll see in a second. Next slide.
Thực tế là tôi phải di chuyển dữ liệu về mặt vật lý. Lát nữa ta sẽ thấy. Slide tiếp theo.
So, that's why this is going to get the best performance, but if I have to start adding and dropping nodes, either because I want to scale up and add more machines, or scale out and add more machines, or because a node goes down and I've got to recover from it, then this is probably problematic.
Vì vậy cách này cho hiệu năng tốt nhất, nhưng nếu tôi phải bắt đầu thêm và bớt nút, hoặc vì muốn scale up và thêm nhiều máy hơn, hoặc scale out và thêm nhiều máy hơn, hoặc vì một nút bị hỏng và tôi phải khôi phục, thì điều này có lẽ sẽ gây rắc rối.
So, again, there's a lot of systems in this space. I can't say anyone is more popular than others, but this is basically how people build.
Vậy, có rất nhiều hệ thống trong lĩnh vực này. Tôi không thể nói hệ nào phổ biến hơn hệ nào, nhưng về cơ bản đây là cách người ta xây dựng.
People say they have a distributed data system from the 80s or 90s or mid-2000s, it's going to be shared nothing. Alright, so here's what it looks like.
Nếu ai đó nói họ có một hệ dữ liệu phân tán từ thập niên 80 hoặc 90 hoặc giữa những năm 2000, thì nó sẽ là shared nothing. Được rồi, đây là hình dạng của nó.
So, we have the application server, and then it can communicate to some kind of catalog metadata thing, And again, this could be just another node in a system, could be a centralized node, we'll get to that architecture in a second.
Chúng ta có máy chủ ứng dụng, và nó có thể giao tiếp với một thành phần danh mục siêu dữ liệu nào đó, Và nhắc lại, đây có thể chỉ là một nút khác trong hệ thống, có thể là một nút tập trung, chúng ta sẽ nói về kiến trúc đó sau ít phút.
But the case is, this is going to say, here's how to go find the data you're looking for. And then say we want to run a query, get ID equals 200.
Nhưng vấn đề là, nó sẽ cho biết cách tìm dữ liệu mà bạn đang cần. Rồi giả sử ta muốn chạy một truy vấn, lấy ID bằng 200.
So each node would have, again, a partition or a different subset of the total table, or the total amount of data in our database.
Vậy mỗi nút sẽ có, nhắc lại, một phân vùng hay một tập con khác nhau của toàn bộ bảng, hay toàn bộ lượng dữ liệu trong cơ sở dữ liệu của ta.
For now, let's say we only have one table, and it has IDs from 1 to 300.
Tạm thời, giả sử ta chỉ có một bảng, với các ID từ 1 đến 300.
So, if I want to, again, I know I want to access ID equals 200, I know this node is maintaining this data, so I send my query to that node, and it can process it and return the result, no problem there.
Vậy nếu tôi muốn truy cập ID bằng 200, và tôi biết nút này đang giữ dữ liệu đó, thì tôi gửi truy vấn đến nút đó, và nó có thể xử lý rồi trả về kết quả, không có vấn đề gì.
But then the challenge is going to be if I want to start doing things like, I want to get ID equals 100 and ID equals 200 in the same query, and I send the query to the first node here.
Nhưng thách thức sẽ xuất hiện nếu tôi muốn làm những việc như, lấy ID bằng 100 và ID bằng 200 trong cùng một truy vấn, và tôi gửi truy vấn đến nút đầu tiên ở đây.
The different nodes are aware of the topology of the database, of the partition scheme that's defined in the catalog, and again, we'll cover that in a second.
Các nút khác nhau đều biết cấu trúc liên kết của cơ sở dữ liệu, tức là sơ đồ phân vùng được định nghĩa trong catalog, và một lát nữa chúng ta sẽ nói về phần đó.
So, it knows that the top node doesn't have ID equals 200, so it has to send a message down here to say, I need ID equals 200, and it could either tell the node down below, run this query, or this portion of the query, give me ID 200, and give me back the result, or it could actually just send the actual data itself up,
Vì vậy, nó biết nút trên cùng không có ID bằng 200, nên nó phải gửi một thông điệp xuống dưới này để nói rằng, tôi cần ID bằng 200, và nó có thể bảo nút ở dưới là hãy chạy truy vấn này, hoặc phần này của truy vấn, đưa tôi ID 200 và trả kết quả lại cho tôi, hoặc nó cũng có thể chỉ cần gửi chính dữ liệu đó lên,
and then let the node in the top process the data. Right?
rồi để nút ở trên xử lý dữ liệu. Đúng không?
Now, again, the challenge I was saying is that this is going to get great performance if all your queries are only accessing data that's on each individual node, but when I want to scale out, meaning I want to add a new machine, then the problem is then I have to move data around.
Bây giờ, như tôi đã nói, thách thức là cách này sẽ cho hiệu năng rất tốt nếu mọi truy vấn của bạn chỉ truy cập dữ liệu nằm trên từng nút riêng lẻ, nhưng khi tôi muốn mở rộng quy mô, nghĩa là thêm một máy mới, thì vấn đề là tôi phải di chuyển dữ liệu.
So, if I add a new node in the middle here, I've got to now take half the data that I had in the node at the bottom, half of the data that I had in the node at the top, and copy that into the middle one here.
Vì vậy, nếu tôi thêm một nút mới ở giữa đây, giờ tôi phải lấy một nửa dữ liệu của nút ở dưới, một nửa dữ liệu của nút ở trên, và sao chép vào nút ở giữa này.
And then you update the catalog service and say, "Here's the data that's moved around, so if anybody comes looking for that data, we'll find it."
Rồi bạn cập nhật dịch vụ catalog và nói rằng, "Đây là dữ liệu đã được di chuyển, nên nếu ai tìm dữ liệu đó thì chúng ta sẽ tìm thấy."
Yes. So, the question is, would the application server know the data ranges? Ideally, no. Some systems, yes, but ideally, no.
Vâng. Câu hỏi là máy chủ ứng dụng có biết các khoảng dữ liệu không? Lý tưởng thì không. Một số hệ thống thì có, nhưng lý tưởng thì không.
Again, if you think about it in SQL, the same query that I could write on a database that runs on a single box, that same query should still work in a distributed database system.
Nếu bạn nghĩ về nó trong SQL, cùng một truy vấn mà tôi có thể viết trên cơ sở dữ liệu chạy trên một máy đơn, thì truy vấn đó vẫn phải chạy được trong một hệ cơ sở dữ liệu phân tán.
It should be completely transparent to me how the data is moving around. So, my example at the beginning, it connected to the application server. Some systems will do that.
Việc dữ liệu được di chuyển thế nào phải hoàn toàn trong suốt đối với tôi. Trong ví dụ ở đầu, nó kết nối đến máy chủ ứng dụng. Một số hệ thống sẽ làm như vậy.
You can go to the application server and say, "Where's my data going to be?"
Bạn có thể đến máy chủ ứng dụng và hỏi: "Dữ liệu của tôi sẽ nằm ở đâu?"
In other systems, you could just send it to any one of these nodes, and they know where the data is, because it's in the catalog. And the catalog is just another database.
Ở các hệ thống khác, bạn có thể gửi đến bất kỳ nút nào trong số này, và chúng biết dữ liệu ở đâu, vì nó nằm trong catalog. Và catalog chỉ là một cơ sở dữ liệu khác.
We haven't really talked about catalogs too much, but you have your data, the user data, the application data, and then you have this metadata catalog that keeps track of, here's the tables I have, here's the schemas that they have, the columns I have, the constraints.
Chúng ta chưa nói nhiều về catalog, nhưng bạn có dữ liệu của mình, dữ liệu người dùng, dữ liệu ứng dụng, và rồi bạn có catalog siêu dữ liệu này để theo dõi, đây là các bảng tôi có, đây là các lược đồ của chúng, các cột tôi có, các ràng buộc.
Well, now we can also start putting things like, here's the partitioning scheme, or here's my layout of my data, my topology of my network.
Giờ đây chúng ta cũng có thể đưa vào đó những thứ như sơ đồ phân vùng, hoặc cách bố trí dữ liệu của tôi, cấu trúc liên kết mạng của tôi.
And then the same sort of transactional guarantees you want for regular application data, you want that to be in your catalog data too.
Và những đảm bảo giao dịch tương tự mà bạn muốn có cho dữ liệu ứng dụng thông thường, bạn cũng muốn có cho dữ liệu catalog.
The question is, how should I maintain indexes in this?
Câu hỏi là: tôi nên duy trì các chỉ mục trong trường hợp này như thế nào?
So, in some cases where ID equals this range here, Each node in this environment would have an index just for the data that they have.
Vậy, trong một số trường hợp khi ID nằm trong khoảng này ở đây, mỗi nút trong môi trường này sẽ có một chỉ mục chỉ dành cho phần dữ liệu mà nó nắm giữ.
And again, if all my queries are like, get ID equals 200, get ID equals 100, I can look at the SQL query, figure out what data it actually needs, send the data to that node, and that node can then look up in its own slice of the index.
Và một lần nữa, nếu tất cả truy vấn của tôi đều kiểu như lấy ID bằng 200, lấy ID bằng 100, tôi có thể xem câu truy vấn SQL, xác định xem nó thực sự cần dữ liệu nào, gửi yêu cầu đến nút đó, và nút đó sẽ tra cứu trong phần chỉ mục của riêng nó.
So, each node has a portion of the total index.
Như vậy, mỗi nút giữ một phần của toàn bộ chỉ mục.
There's also the case where you may have secondary indexes, where you may have things that don't align up with how you're splitting up the data, and that you've got to put either on one node that everyone goes to and talks to, or you replicate it across all nodes.
Cũng có trường hợp bạn có các chỉ mục phụ, tức là những thứ không khớp với cách bạn chia nhỏ dữ liệu, và bạn phải đặt chúng trên một nút duy nhất để mọi người đều đến đó truy cập, hoặc sao chép chúng sang tất cả các nút.
The question is, if I insert something and it has to, because this node is full, we'll cover that in a second, how we handle partitioning, we'll talk about that in a second.
Câu hỏi là, nếu tôi chèn một thứ gì đó và nó phải, vì nút này đã đầy, lát nữa chúng ta sẽ nói đến, cách chúng ta xử lý việc phân vùng, lát nữa chúng ta sẽ bàn.
Depending on the partitioning scheme, depending on your criteria, when you actually want to move data, you make that decision when you want to do that.
Tùy vào lược đồ phân vùng, tùy vào tiêu chí của bạn, khi bạn thực sự muốn di chuyển dữ liệu, bạn đưa ra quyết định đó vào lúc bạn muốn làm.
And then depending on the partitioning scheme, like consistent hashing or rendezvous hashing, some nodes make it, some schemes make it very easy to move data around.
Và tùy vào lược đồ phân vùng, như consistent hashing hay rendezvous hashing, một số lược đồ giúp việc di chuyển dữ liệu rất dễ dàng.
This is just like a toy example. I'm doing range partitioning here. But I would say, what you're talking about is actually what MongoDB did in the early days.
Đây chỉ là một ví dụ đơn giản. Ở đây tôi đang dùng phân vùng theo khoảng. Nhưng tôi sẽ nói rằng, điều bạn đang nói thực ra chính là những gì MongoDB đã làm trong những ngày đầu.
Part of the reason MongoDB got popular in the early 2010s was they had this capability of auto-sharding.
Một phần lý do MongoDB trở nên phổ biến vào đầu những năm 2010 là nhờ khả năng auto-sharding.
So they had the ability to do exactly as you were saying: oh, my shard gets too full, all the queries are going here, they could split off a chunk of it and rebalance things automatically.
Họ có khả năng làm đúng như bạn nói: ồ, shard của tôi quá đầy, mọi truy vấn đều đổ về đây, họ có thể tách một phần ra và tự động cân bằng lại.
But it was a total hack because they didn't guarantee that the catalog was in sync with the data that got moved.
Nhưng đó hoàn toàn là một cách chắp vá vì họ không đảm bảo rằng danh mục luôn đồng bộ với dữ liệu đã được di chuyển.
So you may have two copies of the data on two nodes or two partitions, and two different queries might update the same thing and get incorrect results.
Vì vậy bạn có thể có hai bản sao của dữ liệu trên hai nút hoặc hai phân vùng, và hai truy vấn khác nhau có thể cập nhật cùng một thứ và cho kết quả sai.
Or they took a lock on the entire database and then moved things around. That's another way to handle it. Yes?
Hoặc họ khóa toàn bộ cơ sở dữ liệu rồi mới di chuyển dữ liệu. Đó là một cách xử lý khác. Bạn hỏi đi?
So for this query here, ID equals 100 and ID equals 200. Say it's one query: SELECT star FROM table WHERE ID IN (100, 200).
Với truy vấn này, ID bằng 100 và ID bằng 200. Giả sử đó là một truy vấn: SELECT * FROM table WHERE ID IN (100, 200).
So your question is, why didn't the node at the top send the query down here, or what? Sorry.
Vậy câu hỏi của bạn là, tại sao nút ở trên cùng không gửi truy vấn xuống đây, hay là gì? Xin lỗi.
Oh, the question is, why didn't the... Good point. Why didn't this node here send the ID equals 200 sub-result back to the application server?
À, câu hỏi là, tại sao nút... Ý hay đấy. Tại sao nút này ở đây không gửi kết quả con của ID bằng 200 trở lại máy chủ ứng dụng?
Because of the way the application server communicates with the data server. Say this is one query, right? SELECT star, not two gets, right?
Vì cách máy chủ ứng dụng giao tiếp với máy chủ dữ liệu. Giả sử đây là một truy vấn, đúng không? SELECT *, chứ không phải hai lệnh get, đúng không?
They send one SELECT query to one node, and then the call-and-response protocol of JDBC or ODBC is that I'm going to get one result back with all the tuples that I want from my query.
Họ gửi một truy vấn SELECT đến một nút, và giao thức yêu cầu-phản hồi của JDBC hoặc ODBC là tôi sẽ nhận lại một kết quả duy nhất với tất cả các tuple mà tôi muốn từ truy vấn của mình.
The applications aren't written such that you can send one query and now get two things back, right? It's just not how people write these codes.
Các ứng dụng không được viết theo kiểu gửi đi một truy vấn rồi nhận về hai thứ, đúng không? Người ta đơn giản là không viết code như vậy.
And in the same way, you can change the API to do that, but the client drivers support this. But it's the thing I was saying before.
Tương tự, bạn có thể thay đổi API để làm điều đó, và các client driver có hỗ trợ việc này. Nhưng đó là điều tôi đã nói lúc nãy.
If I write the same query and it runs on a single node, it should behave... I should get back roughly approximately the same result I would if it's even across multiple nodes.
Nếu tôi viết cùng một truy vấn và nó chạy trên một nút duy nhất, thì nó phải hoạt động... Tôi phải nhận lại gần như xấp xỉ cùng một kết quả như khi nó chạy trên nhiều nút.
The database itself should be treated as... Yeah, that's the point of SQL. SQL, you don't know how the data is being split up.
Bản thân cơ sở dữ liệu nên được coi như... Vâng, đó chính là mục đích của SQL. Với SQL, bạn không biết dữ liệu được chia nhỏ như thế nào.
So my SQL query gets sent to the server, and the server then decides how to farm it out across the different nodes. And then the application shouldn't know, shouldn't care.
Vậy truy vấn SQL của tôi được gửi đến máy chủ, và máy chủ sẽ quyết định phân phát nó ra các nút khác nhau như thế nào. Còn ứng dụng thì không cần biết, cũng không cần quan tâm.
The question is, should I think of these nodes as being all homogeneous, or would there be a master or primary node? Not yet.
Câu hỏi là, liệu ta nên coi các nút này đều đồng nhất với nhau, hay sẽ có một nút master hoặc nút primary? Chưa đến phần đó.
For this example, the key thing about these examples, I'm trying to show that every node has a slice of the database, And the other node at the top can't just go down and go look at it.
Với ví dụ này, điều quan trọng của các ví dụ này là tôi muốn cho thấy mỗi nút có một phần của cơ sở dữ liệu, và nút ở trên cùng không thể cứ thế đi xuống và xem phần đó được.
It has to send messages.
Nó phải gửi thông điệp.
Let me keep going, and then it'll come up. So again, if I add a new node, I got to move things around.
Để tôi nói tiếp, rồi phần đó sẽ được đề cập. Vậy nên, nếu tôi thêm một nút mới, tôi phải di chuyển dữ liệu qua lại.
So, shared disk, and the idea here is that every node in my system is going to have its own local CPU, own local memory.
Tiếp theo là shared disk, và ý tưởng ở đây là mỗi nút trong hệ thống của tôi sẽ có CPU cục bộ và bộ nhớ cục bộ riêng.
They are going to have local disk, too, like directly attached storage, like an SSD. But that's only really used for caching. If my memory gets filled, I want to spill to that.
Chúng cũng sẽ có đĩa cục bộ, tức là bộ lưu trữ gắn trực tiếp, như SSD. Nhưng nó thực sự chỉ được dùng để cache. Nếu bộ nhớ của tôi đầy, tôi muốn đẩy dữ liệu tràn sang đó.
The primary source location of the database is going to be down on this shared disk infrastructure down below. And as they pointed out, oh, is this S3? Yes.
Nơi lưu trữ nguồn chính của cơ sở dữ liệu sẽ nằm trên hạ tầng đĩa dùng chung ở bên dưới này. Và như bạn đã chỉ ra, ồ, đây có phải S3 không? Đúng vậy.
This is going to be some distributed file system or distributed object store, like Amazon S3 or Azure Blobstore or GCS, Cloud Compute Storage, Google.
Đây sẽ là một hệ thống tệp phân tán hoặc kho lưu trữ đối tượng phân tán, như Amazon S3, Azure Blobstore hay GCS, Cloud Compute Storage của Google.
The basic idea is that it's this single logical device where all the nodes can read and write to. And that's considered the primary resting database, the resting location of the database.
Ý tưởng cơ bản là đây là một thiết bị logic duy nhất mà tất cả các nút đều có thể đọc và ghi. Và đó được coi là cơ sở dữ liệu chính lưu cố định, tức là nơi cơ sở dữ liệu nằm cố định.
So when people talk about data lakes or serverless systems, it looks a lot like this.
Vì vậy khi người ta nói về data lake hay các hệ thống serverless, thì nó trông rất giống thế này.
And again, most of the newer distributed systems built in the last 10 years, especially for analytical workloads, like the Snowflakes, the Databricks, the Fireballs, the Yellow Bricks and all those guys, all of them are going to look a lot like this.
Và một lần nữa, hầu hết các hệ thống phân tán mới được xây dựng trong 10 năm qua, đặc biệt là cho các tải công việc phân tích, như Snowflake, Databricks, Fireball, Yellowbrick và những hệ thống như vậy, tất cả đều trông rất giống thế này.
So now the architecture is basically the same as before, but now we have this shared storage thing in the back. And a query shows up.
Vậy bây giờ kiến trúc về cơ bản giống như trước, nhưng giờ chúng ta có thêm thành phần lưu trữ dùng chung ở phía sau. Và một truy vấn xuất hiện.
In this case here, we're ignoring the fact, how do we find where the node I want to communicate with is? I'm assuming it's been told through the catalog service or some front end.
Trong trường hợp này, chúng ta bỏ qua việc làm sao tìm ra nút mà tôi muốn giao tiếp nằm ở đâu? Tôi giả định là nó đã được thông báo qua dịch vụ catalog hoặc một front end nào đó.
And now this query wants to get ID 101. It goes to the catalog and says, who's responsible for this? Where do I go find this data?
Và giờ truy vấn này muốn lấy ID 101. Nó đến catalog và hỏi: ai chịu trách nhiệm phần này? Tôi tìm dữ liệu này ở đâu?
Now I can make a request for a page or a block or a file, whatever, from the distributed file system. And it makes a copy of that and brings it back into its memory.
Giờ tôi có thể gửi yêu cầu lấy một trang, một block hay một tệp, gì cũng được, từ hệ thống tệp phân tán. Nó tạo một bản sao và đưa về bộ nhớ của mình.
So same here, I get 102. I know it's on page XYZ, so I go to my storage device and go and get it.
Ở đây cũng vậy, tôi lấy 102. Tôi biết nó nằm ở trang XYZ, nên tôi đến thiết bị lưu trữ của mình và lấy nó.
And then now, when I add a new node in my distributed system, unlike before in shared nothing where I had to copy data around, now I only have to do a logical assignment in the catalog to say this new node is now responsible for data found within some range or some partition.
Và giờ, khi tôi thêm một nút mới vào hệ thống phân tán, không như trước đây ở shared nothing, nơi tôi phải sao chép dữ liệu qua lại, giờ tôi chỉ cần thực hiện một phép gán logic trong catalog để nói rằng nút mới này giờ chịu trách nhiệm cho dữ liệu nằm trong một khoảng hoặc một phân vùng nào đó.
So I don't have to move any data when I add this new node.
Vì vậy tôi không phải di chuyển bất kỳ dữ liệu nào khi thêm nút mới này.
It's just now all the other nodes need to be aware that this node in the middle now is responsible for Q101, whereas before the one at the top was.
Chỉ là giờ tất cả các nút khác cần biết rằng nút ở giữa này giờ chịu trách nhiệm cho Q101, trong khi trước đó là nút ở trên cùng.
The question is, do we need to have different nodes be responsible for different ranges? Can't just be any node can handle any possible data?
Câu hỏi là: có cần để các nút khác nhau chịu trách nhiệm các khoảng khác nhau không? Sao không để nút nào cũng xử lý được mọi dữ liệu?
If you start doing updates to that data, how do I know, if I update on this node here, who has a copy of that data and make sure that they see it?
Nếu bạn bắt đầu cập nhật dữ liệu đó, làm sao tôi biết, nếu tôi cập nhật trên nút này, ai đang giữ bản sao của dữ liệu đó để đảm bảo họ nhìn thấy nó?
Because again, when it was all in a single box and I update something, it's like the global data that everyone sees.
Vì như trước đây, khi mọi thứ nằm trong một máy và tôi cập nhật gì đó, nó là dữ liệu toàn cục mà ai cũng thấy.
But if this bottom guy here updates Q102, but then the nodes at the top have a copy of Q102 as well, how do I make sure that they get notified that they have the latest version?
Nhưng nếu nút ở dưới cùng này cập nhật Q102, mà các nút ở trên cũng có một bản sao của Q102, làm sao tôi đảm bảo họ được thông báo rằng họ đang có phiên bản mới nhất?
What's that? Locking on what? Yes? Yes? Yes? Where's the lock?
Gì cơ? Khóa trên cái gì? Vâng? Vâng? Vâng? Khóa ở đâu?
Everywhere? So that means if I want to lock one thing, I got to broadcast to everyone I hold the lock for it? Is that not a good idea?
Ở mọi nơi? Vậy nghĩa là nếu tôi muốn khóa một thứ, tôi phải thông báo cho mọi người rằng tôi đang giữ khóa của nó? Đó không phải là ý hay sao?
Can it be a primary node or master node? Yes, we'll get there in a second. This is the exact thing I was just saying. So say I now update page 101.
Có thể dùng một nút chính hoặc nút master không? Vâng, chúng ta sẽ đến phần đó ngay. Đây chính xác là điều tôi vừa nói. Giả sử giờ tôi cập nhật trang 101.
I write right to the page here, but now I got to notify potentially everyone else to say, "If you have a copy of page ABC, I've updated 101 in this way."
Tôi ghi thẳng vào trang ở đây, nhưng giờ tôi phải thông báo cho có thể là tất cả các nút khác rằng: "Nếu bạn có bản sao của trang ABC, tôi đã cập nhật 101 theo cách này."
And so that any time that they go read this data, they would know that they have to go fetch the latest version, either from the node that's responsible for it or from the shared disk.
Để bất cứ khi nào họ đọc dữ liệu này, họ sẽ biết rằng họ phải đi lấy phiên bản mới nhất, từ nút chịu trách nhiệm về nó hoặc từ đĩa dùng chung.
We'll cover how we do it in a second.
Chúng ta sẽ nói cách làm ngay sau đây.
The other great thing about shared disk architectures too, and again, this is why they are so prominent now in the cloud, is that this storage is basically infinite.
Một điểm tuyệt vời khác của kiến trúc shared disk, và đây cũng là lý do chúng rất phổ biến trên đám mây hiện nay, là dung lượng lưu trữ này về cơ bản là vô hạn.
Meaning if I want to add additional capacity, that's trivial to do in S3 because I give Amazon more money and I get more space.
Nghĩa là nếu tôi muốn thêm dung lượng, thì việc đó rất đơn giản trên S3, vì tôi trả Amazon thêm tiền và tôi có thêm dung lượng.
Your credit card will run out of money before Amazon runs out of storage space for you.
Thẻ tín dụng của bạn sẽ hết tiền trước khi Amazon hết dung lượng lưu trữ cho bạn.
And again, if I add more capacity, I don't have to move things around or even take nodes offline in the same way that I would have in a shared nothing system.
Và một lần nữa, nếu tôi thêm dung lượng, tôi không phải di chuyển dữ liệu hay thậm chí đưa các nút ngoại tuyến như tôi phải làm trong hệ thống shared nothing.
If I want to add new disks to shared nothing, I got to go physically add that into the box itself.
Nếu tôi muốn thêm đĩa mới vào shared nothing, tôi phải đích thân gắn nó vào trong chính cái máy đó.
The question is, why is the performance in a shared disk architecture worse than a shared nothing architecture? Because I got to communicate with some other device to get the data that I need.
Câu hỏi là, tại sao hiệu năng của kiến trúc shared disk lại kém hơn kiến trúc shared nothing? Vì tôi phải giao tiếp với một thiết bị khác để lấy dữ liệu mình cần.
And for OLTP, the way you get around that, you just have every node cache it.
Và với OLTP, cách để khắc phục là cho mỗi nút lưu đệm dữ liệu đó.
But then you still have to care about, if I update things, I still have to make it back out here.
Nhưng bạn vẫn phải quan tâm đến việc, nếu tôi cập nhật dữ liệu, tôi vẫn phải ghi nó ngược ra ngoài đây.
The question is, is the slowdown due to the overhead of the network IO for updating disks? Yes.
Câu hỏi là, sự chậm đi có phải do chi phí IO mạng khi cập nhật đĩa không? Đúng vậy.
Also, again, if I have a transaction that touches multiple nodes and I go, say, commit, I got to get everyone to agree that now it's okay to commit this.
Ngoài ra, nếu tôi có một giao dịch động đến nhiều nút và tôi nói là commit, tôi phải khiến mọi người đồng ý rằng giờ có thể commit giao dịch này.
So now I'm sending you a message. I got to wait for you to come back and acknowledge that you got my commit message. That becomes problematic as well.
Vậy là tôi gửi cho bạn một thông điệp. Tôi phải chờ bạn phản hồi và xác nhận rằng bạn đã nhận được thông điệp commit của tôi. Điều đó cũng trở nên rắc rối.
But that's going to happen in shared nothing or shared disk as well. Shared disk specifically, it's going to have the overhead of communicating to disk somewhere else.
Nhưng điều đó xảy ra ở cả shared nothing lẫn shared disk. Riêng với shared disk, sẽ có thêm chi phí giao tiếp với đĩa ở một nơi khác.
So we've sort of been talking about this concept as well, like how we're actually now going to execute queries, whether it's shared disk or shared nothing.
Chúng ta cũng đã nói qua khái niệm này, về việc thực sự sẽ thực thi truy vấn như thế nào, dù là shared disk hay shared nothing.
And it has to do with when a query shows up on a node and I recognize that the data I need on that node for this particular query isn't local to me, either because it's not in my local cache or it's not in my local disk because I'm responsible for it.
Nó liên quan đến lúc một truy vấn đến một nút và tôi nhận ra rằng dữ liệu tôi cần trên nút đó cho truy vấn này không nằm cục bộ, hoặc vì nó không có trong bộ nhớ đệm cục bộ của tôi hoặc không nằm trên đĩa cục bộ vì tôi không phụ trách phần đó.
It's on some other node or the shared disk architecture, some remote storage device.
Nó nằm ở một nút khác, hoặc với kiến trúc shared disk thì là một thiết bị lưu trữ từ xa.
How am I going to actually, how do I decide whether I want to pull the data to me so I can run my query or I push my query, or the portion of the query I want to execute, to where the data is actually residing?
Vậy tôi sẽ thực sự làm thế nào, làm sao tôi quyết định kéo dữ liệu về phía mình để chạy truy vấn, hay đẩy truy vấn của tôi, hoặc phần truy vấn tôi muốn thực thi, đến nơi dữ liệu thực sự đang nằm?
So the two approaches, again, push versus pull.
Vậy có hai cách tiếp cận, lại là đẩy so với kéo.
So pushing the query to the data means that I can carve off either the entire, take the entire query or a portion of the query and send it to wherever the data is located.
Đẩy truy vấn đến dữ liệu nghĩa là tôi có thể tách ra toàn bộ, lấy toàn bộ truy vấn hoặc một phần của truy vấn và gửi nó đến nơi dữ liệu đang nằm.
And assuming I have compute capacity or some computing resource, like something that can execute things on the, where the data is located, I can then run the portion of the query that I need on that remote storage and then have it send back to me the result of that computation.
Và giả sử tôi có năng lực tính toán hoặc một tài nguyên tính toán nào đó, tức là thứ gì đó có thể thực thi các thao tác tại nơi dữ liệu nằm, thì tôi có thể chạy phần truy vấn mà tôi cần trên thiết bị lưu trữ từ xa đó rồi để nó gửi lại cho tôi kết quả của phép tính đó.
Pulling the data to the query means that I'm going to, the data is at some other location, I'm basically going to copy the bytes out directly to where my node is over the network so that then I can run as if I had the data locally for me already.
Kéo dữ liệu về phía truy vấn nghĩa là tôi sẽ, dữ liệu đang ở một vị trí khác, Về cơ bản, tôi sẽ sao chép trực tiếp các byte về node của tôi qua mạng để sau đó tôi có thể chạy như thể dữ liệu đã nằm sẵn ở máy cục bộ.
Again, these are not mutually exclusive. The lines get blurry because, in some of these systems, the storage layer can actually do some computation.
Một lần nữa, những cách này không loại trừ lẫn nhau. Ranh giới trở nên mờ nhạt vì trong một số hệ thống này, tầng lưu trữ thực ra có thể thực hiện một số tính toán.
So just taking S3 for example, S3, although they've, it's not deprecated, but if you sign up for a new account today, you can't get this, but if you have an existing account with AWS as of last year, you can get this, but they have a feature called S3 select, where you can send a request to S3 and say, go get this data for me,
Lấy S3 làm ví dụ, S3, tuy họ đã, không hẳn là ngừng hỗ trợ, nhưng nếu hôm nay bạn đăng ký tài khoản mới thì bạn không dùng được tính năng này, nhưng nếu bạn có tài khoản AWS từ trước, tính đến năm ngoái, thì bạn vẫn dùng được, họ có một tính năng gọi là S3 select, trong đó bạn gửi yêu cầu đến S3 và nói: hãy lấy dữ liệu này cho tôi,
but then you also tag along a SQL query that then does some processing on the node where the data is actually being stored and then they send back to you the subset of the result.
nhưng đồng thời bạn đính kèm một truy vấn SQL để xử lý một phần ngay trên node nơi dữ liệu thực sự đang được lưu trữ rồi họ gửi lại cho bạn tập con của kết quả.
So you can use it for filtering, you obviously can't do joins or more complex computation, but you can push down predicates to S3 so that now you pay less egress costs, the network transfer costs going from S3 to your storage device.
Vậy bạn có thể dùng nó để lọc, rõ ràng bạn không thể thực hiện join hay các phép tính phức tạp hơn, nhưng bạn có thể đẩy các predicate xuống S3 để trả ít phí egress hơn, tức là chi phí truyền tải mạng từ S3 đến thiết bị lưu trữ của bạn.
Yes. The question is, why do they deprecate it? I don't know. Do I think it's a bad, the question is, do I think it's a bad idea?
Vâng. Câu hỏi là tại sao họ ngừng hỗ trợ nó? Tôi không biết. Tôi có nghĩ đó là ý tưởng tồi không? Câu hỏi là tôi có nghĩ đó là ý tưởng tồi không?
Do I think it's a bad business idea or do I think it's a bad database idea?
Tôi nghĩ đó là ý tưởng kinh doanh tồi hay ý tưởng cơ sở dữ liệu tồi?
I think it's a bad database idea because this is super useful, but I don't know many systems that actually use it. But it makes sense, right?
Tôi nghĩ đó là ý tưởng cơ sở dữ liệu tồi vì nó cực kỳ hữu ích, nhưng tôi không biết nhiều hệ thống thực sự dùng nó. Nhưng nó hợp lý, đúng không?
If I have a, you know, a bunch of, I have one petabyte of data on S3 and I don't want to have to transfer all that to me if I can do some pushdowns on predicates.
Nếu tôi có, bạn biết đấy, một loạt dữ liệu, giả sử một petabyte trên S3 và tôi không muốn phải truyền toàn bộ chỗ đó về nếu tôi có thể đẩy các predicate xuống.
Now again, you can't, how do you say this?
Nhưng, nói sao nhỉ?
The question is, the issue is now that a core component of your database is now outside your control. Yes. But like, how do you say this?
Câu hỏi là, vấn đề là lúc này một thành phần cốt lõi của cơ sở dữ liệu nằm ngoài tầm kiểm soát của bạn. Vâng. Nhưng, nói sao nhỉ?
And I know I made a big deal out of saying like don't trust the OS, the OS is going to ruin our lives. And now I'm saying go trust Amazon to do something, right?
Tôi biết mình đã nhấn mạnh rất nhiều rằng đừng tin tưởng hệ điều hành, hệ điều hành sẽ phá hỏng cuộc đời chúng ta. Còn giờ tôi lại nói hãy tin Amazon làm việc gì đó, đúng không?
So it depends on what you're trying to do. For some things, yes. For some things, no. This might be a good idea, right? For simple things, maybe it's okay.
Nên điều đó tùy vào việc bạn định làm gì. Với một số việc thì được. Với một số việc thì không. Đây có thể là ý hay, đúng không? Với những việc đơn giản, có lẽ ổn.
But like, and assuming you can parallelize it enough, like assuming you can, you can have enough concurrent requests of different S3 buckets and they can all do the processing parallel, right?
Nhưng giả sử bạn có thể song song hóa đủ, giả sử bạn có thể gửi đủ số yêu cầu đồng thời đến các S3 bucket khác nhau và tất cả cùng xử lý song song, đúng không?
So now I can take my single box that has maybe like, you know, 20 cores. But if I have a thousand outstanding requests S3, I don't think they let you do that.
Khi đó tôi có một máy đơn, có thể chỉ khoảng 20 lõi. Nhưng nếu tôi có một nghìn yêu cầu đang chờ xử lý tới S3, tôi không nghĩ họ cho phép làm vậy.
But like I could have all of them run as if there was a thousand cores filtering at the same time. Now you pay for that, right?
Nhưng giả sử tất cả chạy như thể có một nghìn lõi cùng lọc dữ liệu một lúc. Dĩ nhiên bạn phải trả tiền cho việc đó.
And it might be cheaper to do the processing yourself, but then you've got to account for like the cost of moving the petabyte of data out of S3 to you.
Và có thể tự xử lý sẽ rẻ hơn, nhưng khi đó bạn phải tính đến chi phí di chuyển một petabyte dữ liệu từ S3 về chỗ bạn.
But then you can cache that in the local SSD, but now you've got to pay for that to caching. You know what I mean? Like there's tradeoffs to all these things.
Nhưng sau đó bạn có thể lưu đệm nó trên SSD cục bộ, nhưng giờ bạn lại phải trả tiền cho việc caching đó. Ý tôi là bạn hiểu chứ? Mọi thứ này đều có sự đánh đổi.
Assuming that you, it doesn't get evicted because you brought something else in. Right? All the bufferable stuff we talked about before still matters. Yes.
Với giả định là dữ liệu đó không bị loại ra vì bạn đã đưa thứ khác vào. Đúng không? Tất cả những gì về buffer mà chúng ta đã nói trước đó vẫn còn quan trọng. Vâng, mời bạn.
The question is, without the, without doing this S3 select, is there a way to get this, achieve this on the data center side where you don't have to maybe pull the entire buckets in?
Câu hỏi là, nếu không có, nếu không dùng S3 Select này, liệu có cách nào để đạt được điều này ở phía trung tâm dữ liệu mà không cần phải kéo toàn bộ các bucket về không?
Yes. So it's all the same stuff we talked about before. Like just because it's running on S3 doesn't change like that we care about indexes, we care about filters, the zomap stuff.
Có. Tất cả vẫn là những thứ chúng ta đã nói trước đó. Việc nó chạy trên S3 không làm thay đổi việc chúng ta quan tâm đến chỉ mục, bộ lọc, và zone map.
Like if I have enough metadata up in my database system about what's in my S3 buckets, I can make more precise decisions on what data I'm actually feeding it.
Chẳng hạn nếu tôi có đủ siêu dữ liệu ở phía hệ quản trị cơ sở dữ liệu về những gì có trong các S3 bucket, tôi có thể đưa ra quyết định chính xác hơn về dữ liệu mà tôi thực sự cung cấp cho nó.
Absolutely yes. But like, you know, someone has to write that logic and it'll be in the data center. And it assumes that you even have that metadata to begin with.
Chắc chắn là có. Nhưng bạn biết đấy, ai đó phải viết phần logic đó và nó sẽ nằm ở trung tâm dữ liệu. Và nó còn giả định là ngay từ đầu bạn đã có siêu dữ liệu đó.
If someone's putting down Parquet files in buckets you've never seen before, you don't have any metadata until you go actually read it.
Nếu ai đó đặt các file Parquet vào những bucket mà bạn chưa từng thấy, bạn sẽ không có siêu dữ liệu nào cho đến khi thực sự đọc nó.
But then you go read the footer and that'll give you the metadata that way. So then you read less and decide whether you need to read the rest of the file.
Nhưng sau đó bạn đọc footer và nó sẽ cho bạn siêu dữ liệu theo cách đó. Như vậy bạn đọc ít hơn và quyết định xem có cần đọc phần còn lại của file hay không.
What's that? You gotta read the footer and bring it into the database server side. But that footer's gonna be, I don't know, a megabyte of that.
Gì cơ? Bạn phải đọc footer và đưa nó về phía máy chủ cơ sở dữ liệu. Nhưng footer đó chắc chỉ khoảng một megabyte thôi.
But again, all the same stuff we talked about before.
Nhưng một lần nữa, vẫn là tất cả những thứ chúng ta đã nói trước đó.
Like, I want to do predicate pushdown, projection pushdown, I want to use zone maps and other filters to decide what's the bare minimum data I need to read.
Chẳng hạn, tôi muốn làm predicate pushdown, projection pushdown, tôi muốn dùng zone map và các bộ lọc khác để quyết định lượng dữ liệu tối thiểu tuyệt đối mà tôi cần đọc.
Just because it's S3 versus a local disk in the same box, all the same principles apply. Now it's just harder.
Dù là S3 hay đĩa cục bộ trong cùng một máy, tất cả các nguyên tắc đều áp dụng như nhau. Chỉ là bây giờ nó khó hơn.
In the case of Microsoft, they have, you know, not as sophisticated as S3, but it's basically the same idea.
Trong trường hợp của Microsoft, họ có, tuy không phức tạp bằng S3, nhưng về cơ bản là cùng một ý tưởng.
The idea here is that I know that I want to run this query here and the data I need for that query is down below.
Ý tưởng ở đây là tôi biết mình muốn chạy truy vấn này và dữ liệu cần cho truy vấn nằm ở bên dưới.
Rather than moving all the data up to compute this join up into the node at the top, I'll send down a plan fragment and say, "Hey, I want to do this join in R and S.
Thay vì chuyển toàn bộ dữ liệu lên tầng tính toán để thực hiện phép join này ở nút trên cùng, tôi sẽ gửi xuống một plan fragment và nói: "Này, tôi muốn thực hiện phép join này giữa R và S.
I know you have the data in the range between 101 and 200.
Tôi biết bạn có dữ liệu trong khoảng từ 101 đến 200.
Compute the local join in this node down here and then send me up now the result of the join, or at least the partial result of the join."
Hãy tính phép join cục bộ ở nút phía dưới này rồi gửi lên cho tôi kết quả của phép join, hoặc ít nhất là kết quả một phần của phép join."
And then I can combine together the result in the node at the top. Now again, I'm showing this in a shared-nothing architecture, but the same concept applies in a shared-disk architecture.
Sau đó tôi có thể kết hợp các kết quả lại ở nút trên cùng. Một lần nữa, tôi đang minh họa điều này trong kiến trúc shared-nothing, nhưng khái niệm tương tự cũng áp dụng cho kiến trúc shared-disk.
It's just more readily apparent that you can do it this way.
Chỉ là việc có thể làm theo cách này hiện ra rõ ràng hơn.
In a shared-disk system, the idea is that the nodes are responsible for managing some logical portion of the data, but the final physical resting place of that data is going to be out on the disk.
Trong một hệ thống shared-disk, ý tưởng là các nút chịu trách nhiệm quản lý một phần logic của dữ liệu, nhưng nơi lưu trữ vật lý cuối cùng của dữ liệu đó sẽ nằm trên đĩa.
In this case here, assuming there's nothing in our local caches, this query shows up and I want to do the same join I was doing before.
Trong trường hợp này, giả sử không có gì trong bộ nhớ đệm cục bộ của chúng ta, truy vấn này xuất hiện và tôi muốn thực hiện phép join giống như trước đó.
But the node at the top will say, "I know the node at the bottom is responsible for data within this range, so rather than me pulling from the shared disk and computing the join at the top, I'm going to send my plan fragment down to the bottom guy to help them compute the partial result of the join."
Nhưng nút ở trên cùng sẽ nói: "Tôi biết nút ở dưới cùng chịu trách nhiệm về dữ liệu trong khoảng này, nên thay vì tôi kéo dữ liệu từ đĩa dùng chung và tính phép join ở trên cùng, tôi sẽ gửi plan fragment của mình xuống cho nút ở dưới để nó giúp tính kết quả riêng phần của phép join."
It knows how to go out to the shared disk, the shared storage, and get all the data it needs, bring that copy back into its local cache.
Nó biết cách ra đĩa dùng chung, tức là kho lưu trữ dùng chung, lấy toàn bộ dữ liệu nó cần, rồi mang bản sao đó về bộ nhớ đệm cục bộ của mình.
Then the bottom guy here computes the portion of the join that it's responsible for, sends the result up to the node at the top, and the node at the top then can either union the results together and produce the final result, or if there's additional things it wants to do as part of the query, it knows how to then further process them as needed.
Sau đó nút ở dưới tính phần của phép join mà nó chịu trách nhiệm, gửi kết quả lên nút ở trên cùng, và nút ở trên cùng khi đó có thể hợp (union) các kết quả lại với nhau để tạo ra kết quả cuối cùng, hoặc nếu nó muốn làm thêm những việc khác như một phần của truy vấn, thì nó biết cách xử lý thêm khi cần.
So again, another key distinction here in a shared-disk with the shared-nothing architecture: in a shared-disk architecture, I'm showing the same partitioning ranges that we had in shared-nothing, but again, this is a logical partitioning.
Vậy một lần nữa, một điểm khác biệt then chốt ở đây giữa shared-disk và kiến trúc shared-nothing: trong kiến trúc shared-disk, tôi đang hiển thị các khoảng phân vùng giống như trong shared-nothing, nhưng đây là phân vùng logic.
So the final data is going to always be on shared disk. We're saying that for this point in time, this node at the bottom is responsible for the data within this range.
Dữ liệu cuối cùng sẽ luôn nằm trên đĩa dùng chung. Chúng ta chỉ nói rằng tại thời điểm này, nút ở dưới cùng chịu trách nhiệm về dữ liệu trong khoảng này.
So if an update comes along, we know that it has to go to this node here, because that'll be, again, the primary or the master, whatever you want to call it.
Nên nếu có một bản cập nhật đến, ta biết nó phải đi tới nút này, vì đó là nút chính, hay master, gọi sao cũng được.
That's where the change has to apply first, And then this node is responsible for making sure that things get propagated to the other nodes in the cluster or the system.
Đó là nơi thay đổi phải được áp dụng đầu tiên, và sau đó nút này chịu trách nhiệm đảm bảo các thay đổi được lan truyền đến những nút khác trong cụm hay hệ thống.
Yes.
Vâng.
Boom. Next slide. How are we starting to partition things? So again, we want to split the database across multiple resources, disk or nodes or processes.
Xong. Slide tiếp theo. Chúng ta bắt đầu phân vùng mọi thứ như thế nào? Một lần nữa, ta muốn chia cơ sở dữ liệu ra nhiều tài nguyên, đĩa, nút hoặc tiến trình.
In my examples here, I'm showing we're partitioning on keys within the table. This is sort of fine-grained partitioning.
Trong các ví dụ ở đây, tôi đang phân vùng theo các khóa trong bảng. Đây là kiểu phân vùng mịn (fine-grained).
We're trying to say, I'm going to pick one or more columns in my tables, and that's going to be the partitioning key, and I'll use whatever the partitioning mechanism I'm going to have to then decide what partition it's going to get assigned to.
Ta nói rằng tôi sẽ chọn một hoặc nhiều cột trong bảng, và đó sẽ là khóa phân vùng, rồi tôi dùng bất kỳ cơ chế phân vùng nào mà tôi có để quyết định dữ liệu sẽ được gán vào phân vùng nào.
It doesn't have to be that fine-grained. It can be more coarse-grained, like in Yellowbrick and Snowflake, they partition on files.
Không nhất thiết phải mịn như vậy. Có thể thô hơn (coarse-grained), như ở Yellowbrick và Snowflake, họ phân vùng theo tệp.
A bunch of Parquet files sitting in S3, and they're going to say which node is going to be responsible for that.
Một loạt tệp Parquet nằm trong S3, và họ sẽ chỉ định nút nào chịu trách nhiệm cho chúng.
And the idea is that if I partition my database across these different disjoint subsets, they're not always disjoint, they usually are, then I just write my query against that data.
Ý tưởng là nếu tôi phân vùng cơ sở dữ liệu của mình thành các tập con rời nhau này, không phải lúc nào cũng rời nhau, nhưng thường là vậy, thì tôi chỉ việc viết truy vấn trên dữ liệu đó.
There's something that's coordinating, figuring out where the data is all being located.
Có một thành phần điều phối, xác định dữ liệu đang nằm ở đâu.
It knows how to send the plan fragments to those nodes that are responsible for those partitions to compute some portion of the query, and then I know how to combine the results back together to produce the final result.
Nó biết cách gửi các plan fragment đến những nút đó chịu trách nhiệm cho các phân vùng đó để tính một phần của truy vấn, và sau đó tôi biết cách kết hợp các kết quả lại với nhau để tạo ra kết quả cuối cùng.
In the case of shared-nothing, it's going to be physically partitioned.
Với shared-nothing, dữ liệu sẽ được phân vùng theo kiểu vật lý.
The data itself, the final resting place or the primary storage location of the data, is going to be within the partition running on a single node.
Bản thân dữ liệu, nơi lưu trữ cuối cùng hay vị trí lưu trữ chính của dữ liệu, nằm trong phân vùng chạy trên một nút duy nhất.
In the case of shared-disk, it's logical partitioning in that we're saying that some node in our system is responsible for that partition of the data, but the final resting place has to be back on shared-disk.
Với shared-disk, đó là phân vùng logic, nghĩa là chúng ta nói rằng một nút nào đó trong hệ thống của chúng ta chịu trách nhiệm cho phân vùng dữ liệu đó, nhưng nơi lưu trữ cuối cùng vẫn phải là shared-disk.
You sort of think of, in a shared-disk architecture, the nodes themselves are stateless, meaning if one of those guys gets killed and crashes and comes back, I don't lose any data, because the shared-disk is the final resting place for it, and I know that's always going to be there, as long as my credit card still works with Amazon.
Các bạn có thể hình dung, trong kiến trúc shared-disk, bản thân các nút là không lưu trạng thái (stateless), nghĩa là nếu một trong số chúng bị tắt, bị sập rồi chạy lại, tôi không mất dữ liệu nào cả, vì shared-disk là nơi lưu trữ cuối cùng của dữ liệu, và tôi biết dữ liệu luôn ở đó, miễn là thẻ tín dụng của tôi vẫn dùng được với Amazon.
Yes?
Em hỏi à?
Alright, so the question is, during the entire semester I keep saying, here's the file layout, and within that there's pages, and the pages have a lot of page architecture, and now I keep mentioning Parquet.
Được rồi, câu hỏi là, suốt học kỳ tôi cứ nói, đây là cách bố trí tệp, bên trong có các trang, và các trang có nhiều kiến trúc trang, và bây giờ tôi lại cứ nhắc đến Parquet.
Why do I mention that in the context of distributed databases? Parquet files are just an open-source columnar file format that are very common in distributed shared-disk OLAP systems.
Tại sao tôi nhắc đến nó trong bối cảnh cơ sở dữ liệu phân tán? Tệp Parquet chỉ là một định dạng tệp dạng cột mã nguồn mở rất phổ biến trong các hệ OLAP shared-disk phân tán.
What Parquet allows you to do is, you can have one application create a bunch of data and just write it to S3, without going through the database server, and then the database server can run the queries on it.
Parquet cho phép một ứng dụng tạo ra một lượng dữ liệu rồi ghi thẳng lên S3, mà không cần đi qua máy chủ cơ sở dữ liệu, sau đó máy chủ cơ sở dữ liệu có thể chạy truy vấn trên đó.
So it's a file format, and it's very common to use this in a shared-disk cloud system, like Lakehouse systems.
Vậy nó là một định dạng tệp, và rất hay được dùng trong hệ thống đám mây shared-disk, như các hệ thống Lakehouse.
It doesn't have to be, and everything I've said so far is, I'm not defining what's actually in the data I'm storing in the shared-disk, or even in the shared-nothing system.
Không nhất thiết phải vậy, và mọi điều tôi nói từ đầu đến giờ là, tôi không xác định chính xác dữ liệu tôi lưu trong shared-disk là gì, hay cả trong hệ thống shared-nothing.
I'm just mentioning Parquet as an example of what people would do in the cloud systems.
Tôi chỉ nhắc đến Parquet như một ví dụ về việc người ta làm trong các hệ thống đám mây.
But it's still going to be, at the high level, it's still going to be all the stuff we talked about the entire semester.
Nhưng ở mức tổng quan, nó vẫn sẽ là tất cả những gì chúng ta đã học suốt học kỳ.
It's going to be a PAX layout, or it's going to be a slotted page, or LSM.
Đó sẽ là bố cục PAX, hoặc slotted page, hoặc LSM.
So, the question is why? The statement is, it's not true that the files are always going to come from an outside application. Yes.
Vậy câu hỏi là tại sao? Nhận định là, không đúng khi nói các tệp luôn đến từ một ứng dụng bên ngoài. Vâng.
Most of the data will come through into the database server as inserts, especially in OLTP, we're just going to write that in. That doesn't change.
Phần lớn dữ liệu sẽ đi vào máy chủ cơ sở dữ liệu dưới dạng các lệnh insert, đặc biệt trong OLTP, chúng ta cứ ghi thẳng vào. Điều đó không thay đổi.
Parquet? I wouldn't say Parquet is random, it's used everywhere. And old, I mean, it's, I mean...
Parquet? Tôi không nói Parquet là ngẫu nhiên, nó được dùng ở khắp nơi. Và cũ rồi, ý tôi là, tức là...
The question, file format for in this class?
Câu hỏi về định dạng tệp trong lớp này phải không?
So, a statement is, is it not true that a customized file format will be better than a general-purpose, open-source file format?
Vậy nhận định là, có đúng là một định dạng tệp tùy biến sẽ tốt hơn một định dạng tệp mã nguồn mở, đa dụng không?
For, it depends on, I mean, it's a cop-out. It depends on the workload, it depends on the data, it depends on where the environment is that you're actually running your data system.
Câu trả lời là, tùy thôi, tôi biết là nghe như né tránh. Nó tùy vào khối lượng công việc, tùy vào dữ liệu, tùy vào môi trường mà bạn thực sự chạy hệ thống dữ liệu của mình.
Right? So, what's that?
Đúng không? Bạn hỏi gì nhỉ?
Yeah, so, we'll get to this at the end, but there's a philosophical discussion to be had about where to spend your energy when you're building a new database system.
Vâng, cuối buổi chúng ta sẽ quay lại vấn đề này, nhưng có một cuộc thảo luận mang tính triết lý về việc nên dồn sức vào đâu khi xây dựng một hệ cơ sở dữ liệu mới.
So, Snowflake famously decided, we're not going to go shared-nothing, we're going to be shared-disk. I'll get to your answer about the file format in a second.
Snowflake nổi tiếng với quyết định này: không đi theo shared-nothing mà chọn shared-disk. Lát nữa tôi sẽ trả lời câu hỏi của bạn về định dạng tệp.
But Snowflake said, we're not going to, we don't want to be shared-nothing, because if I'm shared-nothing, then I got to build, basically, a distributed...
Snowflake nói rằng họ không muốn dùng shared-nothing, vì nếu dùng shared-nothing, thì về cơ bản tôi phải xây dựng một hệ phân tán...
I got to make sure that, like, my storage is fault-tolerant and sync and keep these things, you know, synchronized and things like that. And they decided they're not going to do that.
Tôi phải đảm bảo lưu trữ của mình chịu được lỗi và đồng bộ, giữ cho những thứ này được đồng bộ với nhau, đại loại vậy. Và họ quyết định không làm như thế.
They said, we're going to build everything off of S3 and just, you know, put caching in front of that on these stateless nodes so that we can run, you know, hide the latency cost of doing this.
Họ nói, chúng ta sẽ xây dựng mọi thứ trên S3 và đặt bộ nhớ đệm phía trước trên các nút không lưu trạng thái này để có thể chạy, và che giấu chi phí độ trễ của việc này.
And then, the thought was, let's spend all our energy, Snowflake's energy, on engineering time, on making this thing as fast as possible.
Ý tưởng là dồn toàn bộ sức lực của Snowflake, thời gian kỹ thuật, vào việc làm cho hệ thống nhanh nhất có thể.
And then, we'll put caching in front of that to hide this latency. And then, as Amazon makes this better, we'll get that, you know, get that benefit for free.
Sau đó đặt bộ nhớ đệm phía trước để che giấu độ trễ này. Và khi Amazon cải thiện S3, chúng ta được hưởng lợi ích đó miễn phí.
So, that was one of the smart things that they did in the early days. Now, again, that kind of goes against what I said before, where, like, we want to control everything.
Đó là một trong những việc khôn ngoan họ đã làm từ những ngày đầu. Nhưng điều này lại đi ngược với những gì tôi nói trước đó, khi tôi nói rằng ta muốn kiểm soát mọi thứ.
But for distributed OLAP, it's kind of, you know, it's okay to do that. Because, again, if I'm a startup, it's one less thing I have to build.
Tuy nhiên với OLAP phân tán thì làm vậy cũng ổn. Vì nếu là một công ty khởi nghiệp, thì đó là một thứ ít hơn mà tôi phải xây.
Amazon's going to put a bunch of engineers making this work really great. For OLTP, maybe less so, because I really care about, like, performance, latency stuff.
Amazon sẽ dùng cả đội kỹ sư để làm cho nó hoạt động thật tốt. Với OLTP thì có lẽ không hẳn vậy, vì tôi rất quan tâm đến hiệu năng và độ trễ.
All right, so now your question about the file format thing, right? So, if I could, like, how do I say this?
Được rồi, giờ đến câu hỏi của bạn về định dạng tệp. Để xem nên nói thế nào nhỉ?
Database systems are usually trying to be the general purpose software that can accommodate as many application scenarios as possible. And hardware, you know, discrepancies in different hardware characteristics, in different operating environments, right?
Các hệ cơ sở dữ liệu thường cố gắng trở thành phần mềm đa dụng có thể đáp ứng càng nhiều kịch bản ứng dụng càng tốt. Và cả những khác biệt về đặc tính phần cứng, trong các môi trường vận hành khác nhau, đúng không?
So, it is true that if I have an application that I could build a database server that could serve one application, I can build a, you know, an optimized, customized version of everything we've talked about the entire semester and make that one application run as fast as possible.
Vì vậy, đúng là nếu tôi có một ứng dụng, tôi có thể xây một máy chủ cơ sở dữ liệu chỉ phục vụ một ứng dụng đó, tôi có thể xây một phiên bản được tối ưu, tùy biến của mọi thứ chúng ta đã nói suốt học kỳ và làm cho ứng dụng duy nhất đó chạy nhanh nhất có thể.
Absolutely, yes, it could be. If you're trying to make it a general purpose, though, that's actually not feasible.
Chắc chắn rồi, điều đó hoàn toàn có thể. Nếu bạn cố làm cho nó đa dụng, thì thực ra điều đó không khả thi.
So, now you've got to make decisions of what's the, sort of, what's the lowest common denominator I would need to be able to support a larger application so that I can sell my database system and then not have, you know, huge performance bottlenecks.
Vì vậy, bây giờ bạn phải đưa ra quyết định xem đâu là, đâu là mẫu số chung nhỏ nhất mà tôi cần để có thể hỗ trợ một ứng dụng lớn hơn để tôi có thể bán hệ cơ sở dữ liệu của mình mà không gặp phải những nút thắt cổ chai hiệu năng khổng lồ.
So, you said Parquet is OLAP. Parquet came out in 2011, 2013, right? So, it's 12 years old now.
Vậy, bạn nói Parquet là OLAP. Parquet ra đời năm 2011, 2013 gì đó, đúng không? Vậy là nó đã 12 tuổi rồi.
At the time, that was considered a state-of-the-art file format because everyone was storing things in JSON or CSVs, right? So, you're beating those.
Vào thời điểm đó, nó được coi là một định dạng tệp tiên tiến nhất vì ai cũng lưu dữ liệu bằng JSON hoặc CSV, đúng không? Vậy là bạn vượt trội hơn những định dạng đó.
But then now, are there better compression protocols and more advanced ways of accessing columnar data? Yes, and Parquet has not really kept up with that.
Nhưng bây giờ, liệu có các giao thức nén tốt hơn và những cách truy cập dữ liệu dạng cột tiên tiến hơn không? Có, và Parquet thực sự đã không theo kịp những điều đó.
And that's why there's, like, Vortex and all these other file formats that are coming along.
Và đó là lý do có Vortex và tất cả những định dạng tệp khác đang xuất hiện.
But again, I'm only bringing that up to say, in a, in the cloud and distributed data systems for analytical workloads, oftentimes what's going to be in the storage layer is going to be a bunch of Parquet files.
Nhưng một lần nữa, tôi chỉ nhắc đến điều đó để nói rằng, trong các hệ thống dữ liệu đám mây và phân tán cho khối lượng công việc phân tích, thường thì thứ nằm trong tầng lưu trữ sẽ là một loạt tệp Parquet.
And can you build better ones? Yes. And the Spiral guys and others are trying to do that.
Và bạn có thể xây dựng những định dạng tốt hơn không? Có. Và nhóm Spiral cùng những người khác đang cố gắng làm điều đó.
All right, so, partitioning. All right, so, there's one basic way to do partitioning, which is to do table partitioning.
Được rồi, vậy là phân vùng. Được rồi, có một cách cơ bản để phân vùng, đó là phân vùng theo bảng.
Meaning, like, I'll have one node be responsible for one table and another node be responsible for another table. And I literally split up that coarse-grained. And you need more coarse-grained.
Nghĩa là, tôi sẽ cho một nút chịu trách nhiệm một bảng và một nút khác chịu trách nhiệm một bảng khác. Tức là tôi chia nhỏ dữ liệu theo đúng nghĩa đen ở mức thô. Và có thể còn thô hơn nữa.
Like, I have one node be responsible for a database. This data is one node responsible for that database.
Chẳng hạn, tôi cho một nút chịu trách nhiệm một cơ sở dữ liệu. Dữ liệu này do một nút chịu trách nhiệm cho cơ sở dữ liệu đó.
Of course, if and now I need to access data across multiple tables, across multiple databases, if I'm doing this naive scheme, it becomes problematic.
Tất nhiên, nếu bây giờ tôi cần truy cập dữ liệu trên nhiều bảng, trên nhiều cơ sở dữ liệu, thì với cách làm ngây thơ này sẽ nảy sinh vấn đề.
But in some scenarios, this works out just fine. So, again, same idea. This has two tables, one and two.
Nhưng trong một số tình huống, cách này vẫn ổn. Vậy, cùng ý tưởng đó. Ở đây có hai bảng, một và hai.
And I'm literally going to take all the data from the first table, put it in one node here, all the data in the second table, put it in another node here.
Và tôi sẽ lấy toàn bộ dữ liệu từ bảng thứ nhất, đặt vào một nút ở đây, toàn bộ dữ liệu của bảng thứ hai, đặt vào một nút khác ở đây.
As long as my query is only accessing data in one table, then I'm happy. I'm great.
Miễn là truy vấn của tôi chỉ truy cập dữ liệu trong một bảng thì tôi hài lòng. Tuyệt vời.
Of course, now, if my table doesn't fit on a single partition, then this becomes problematic and I've got to do something else.
Tất nhiên, bây giờ nếu bảng của tôi không vừa trong một phân vùng đơn, thì điều này trở nên có vấn đề và tôi phải làm cách khác.
So, I've come across this, actually, with people using Mongo, where they had the regular database where most of the application data was partitioned in the way we'll talk about in the next slide.
Thực ra tôi đã gặp trường hợp này với những người dùng Mongo, họ có cơ sở dữ liệu thông thường trong đó phần lớn dữ liệu ứng dụng được phân vùng theo cách chúng ta sẽ nói ở slide tiếp theo.
But then they had one table that was basically a log for the application. They only inserted into it and they never read it.
Nhưng họ có một bảng về cơ bản là nhật ký của ứng dụng. Họ chỉ chèn vào đó và không bao giờ đọc nó.
So, they wanted to put that table or collection, in Mongo parlance, on a single partition or single node by itself because they just inserted and make that run as fast as possible and didn't interfere with any other updates and any other nodes.
Vì vậy, họ muốn đặt bảng đó, hay collection theo cách gọi của Mongo, trên một phân vùng đơn hay một nút riêng vì họ chỉ chèn dữ liệu và muốn nó chạy nhanh nhất có thể và không can thiệp vào các cập nhật khác hay các node khác.
So, this is not that common, but some systems do let you do this. And in some cases, we'll see this when we talk about OLAP queries next class.
Vì vậy, cách này không phổ biến lắm, nhưng một số hệ thống cho phép bạn làm vậy. Và trong một số trường hợp, chúng ta sẽ thấy điều này khi nói về các truy vấn OLAP ở buổi học tới.
Instead of just putting, you know, you put the entire table at a node, but you'll make a replica of it on every node because it's like something really small, like a zip code table.
Thay vì chỉ đặt, bạn biết đấy, đặt toàn bộ bảng ở một node, thì bạn sẽ tạo một bản sao của nó trên mọi node vì nó là thứ rất nhỏ, như bảng mã bưu chính (zip code).
There's only like 35,000 records. That's not that big. And I'll make a copy of that on every single node.
Chỉ có khoảng 35.000 bản ghi. Không lớn lắm. Và tôi sẽ tạo một bản sao của nó trên từng node.
So, any time a query wants to run, it always can be the local copy of that table.
Vì vậy, bất cứ khi nào một truy vấn muốn chạy, nó luôn có thể dùng bản sao cục bộ của bảng đó.
The question is, doesn't that introduce also the cost of updates every time? Yeah, but like for some cases, those tables aren't updated that often.
Câu hỏi là: như vậy chẳng phải mỗi lần cập nhật cũng phát sinh thêm chi phí sao? Đúng, nhưng với một số trường hợp, các bảng đó không được cập nhật thường xuyên.
The postal service updates the zip code table four times a year. Not that often.
Bưu điện cập nhật bảng mã bưu chính bốn lần một năm. Không thường xuyên lắm.
Alright, so what is most common and what people normally think about in distributing this is doing what's called horizontal partitioning. And in the NoSQL guys, they'll call this sharding. It's basically the same thing.
Được rồi, vậy điều phổ biến nhất và là điều mọi người thường nghĩ đến khi phân tán là thực hiện cái gọi là phân vùng ngang (horizontal partitioning). Còn những người làm NoSQL thì gọi là sharding. Về cơ bản là như nhau.
And then we're going to split the...
Và sau đó chúng ta sẽ chia...
We'll show an example of doing sort of fine grained horizontal partitioning where within one table we're going to look at some partitioning column or columns and we're going to use that to decide how we're going to split things up.
Chúng ta sẽ cho xem một ví dụ về phân vùng ngang chi tiết hơn, trong đó, bên trong một bảng, ta sẽ xét một cột phân vùng hoặc nhiều cột và dùng nó để quyết định cách chia dữ liệu.
And the goal here is we want to split the data up according to some other bunch of objectives, like make sure every node has the same amount of data.
Và mục tiêu ở đây là chia dữ liệu theo một số mục tiêu khác, chẳng hạn đảm bảo mỗi node có cùng lượng dữ liệu.
Make sure that every node is going to run the same amount of queries.
Đảm bảo mỗi node chạy cùng số lượng truy vấn.
You may have one node have a small amount of data, but it gets all the queries and so therefore you don't want to put more data on it because that'll slow down, that'll sort of overwhelm it.
Có thể một node chứa ít dữ liệu, nhưng nhận hết các truy vấn, và do đó bạn không muốn đặt thêm dữ liệu lên nó vì sẽ làm nó chậm đi, sẽ làm nó quá tải.
So, the two most common schemes to do horizontal partitioning is to do hash partitioning and range partitioning. Range partitioning we've already seen.
Vậy, hai cách phổ biến nhất để phân vùng ngang là phân vùng băm (hash partitioning) và phân vùng theo khoảng (range partitioning). Phân vùng theo khoảng thì chúng ta đã thấy rồi.
I just took discrete subsets of values that are continuous ranges within my key space of a column and I'm just assigning those to different nodes.
Tôi lấy các tập con rời rạc của các giá trị là những khoảng liên tục trong không gian khóa của một cột và gán chúng cho các node khác nhau.
And how you come up with the optimal ranges depends on what your objective function is. Predicate partitioning, horizontal partitioning is not that common.
Còn cách tìm ra các khoảng tối ưu thì phụ thuộc vào hàm mục tiêu của bạn là gì. Phân vùng theo vị từ (predicate partitioning), phân vùng ngang, thì không phổ biến lắm.
The basic idea is that you just define where clauses to say where name equals Andy and age equals 1, 2, 3, that goes to this node, and then where name equals Andy and age equals 4, 5, 6, that goes to another node.
Ý tưởng cơ bản là bạn chỉ cần định nghĩa các mệnh đề where, chẳng hạn where name bằng Andy và age bằng 1, 2, 3 thì đi đến node này, còn where name bằng Andy và age bằng 4, 5, 6 thì đi đến node khác.
Basically defining the where clauses and how to split data up. And then round robin partitioning is just assigning some tuples or files or data to one node in a round robin fashion.
Về cơ bản là định nghĩa các mệnh đề where và cách chia dữ liệu. Còn phân vùng vòng tròn (round robin) chỉ là gán các tuple, tệp hoặc dữ liệu cho các node theo kiểu xoay vòng.
Like I said, hashing and range partitioning is more common. So, say this is our table. Again, we have four columns here and we're going to pick one of them as the partitioning key.
Như tôi đã nói, phân vùng băm và phân vùng theo khoảng phổ biến hơn. Giả sử đây là bảng của chúng ta. Một lần nữa, ở đây có bốn cột và ta sẽ chọn một trong số đó làm khóa phân vùng.
It could be multiple ones. Usually it's the primary key, but it doesn't always have to be.
Cũng có thể là nhiều cột. Thường đó là khóa chính, nhưng không nhất thiết phải như vậy.
And then now, if we're doing hash partitioning, what we're going to do is, for every single tuple, we're going to take whatever the value is for that partitioning column, partitioning key, and we're going to hash it, mod by the number of partitions we have in our system, in this case, 4.
Và bây giờ, nếu chúng ta dùng phân vùng băm (hash partitioning), thì với mỗi tuple, chúng ta sẽ lấy giá trị của cột phân vùng đó, tức khóa phân vùng, rồi băm nó, lấy modulo cho số phân vùng có trong hệ thống, trong trường hợp này là 4.
And then that's going to determine how we're going to assign the data from these different tuples to these different partitions.
Kết quả đó sẽ quyết định cách chúng ta gán dữ liệu từ các tuple khác nhau này vào các phân vùng khác nhau.
And if most of my queries just have the partition key in the where clause, then this is going to be fantastic for me, because I can just look at the catalog and say, well, I know what the key, I know the value being used for the partition key, look up in my where clause, I hash it in the same way I did for when I moved the data in the beginning,
Và nếu hầu hết các truy vấn của tôi chỉ có khóa phân vùng trong mệnh đề where, thì điều này sẽ rất tuyệt vời, vì tôi chỉ cần xem catalog và nói rằng, tôi biết khóa, tôi biết giá trị được dùng cho khóa phân vùng, tra trong mệnh đề where của tôi, tôi băm nó theo đúng cách đã làm khi chuyển dữ liệu vào lúc ban đầu,
and that's going to tell me which node has the data that I'm looking for.
và nó sẽ cho tôi biết nút nào chứa dữ liệu mà tôi đang tìm.
So for shared disk, basic idea looks like this. I want to get ID equals 1, assuming I've done some amount of partitioning.
Với shared disk, ý tưởng cơ bản trông như thế này. Tôi muốn lấy ID bằng 1, giả sử tôi đã phân vùng ở một mức nào đó.
And it knows that it can get data from the different nodes that it needs.
Và nó biết có thể lấy dữ liệu cần thiết từ các nút khác nhau.
In this case here, if I had to get multiple keys and one of these keys aren't in my node that I need, then I know I need to go communicate with the guy at the top, either to send the query that I want it to run for me, or pull the data down that I need to then run things locally.
Trong trường hợp này, nếu tôi phải lấy nhiều khóa và một trong các khóa này không nằm trên nút của tôi, thì tôi biết mình cần liên lạc với nút ở phía trên, hoặc là gửi truy vấn để nó chạy giúp tôi, hoặc là kéo dữ liệu cần thiết về để chạy cục bộ.
And again, this is logical partitioning because the final resting place of the data is out here on the shared disk.
Và đây vẫn là phân vùng logic vì nơi lưu trữ cuối cùng của dữ liệu là ở ngoài đây, trên đĩa dùng chung.
The final resting place of the data is actually on the nodes themselves, so depending on the queries I'm executing, I know how to route the things to go get the data that I need.
Nơi lưu trữ cuối cùng của dữ liệu thực ra là trên chính các nút, nên tùy theo các truy vấn tôi thực thi, tôi biết cách định tuyến để đi lấy dữ liệu mình cần.
We've already covered this. In the case of hash partitioning, what's one key problem with this approach?
Chúng ta đã nói về điều này rồi. Với phân vùng băm, một vấn đề then chốt của cách tiếp cận này là gì?
So the question is, any other query that doesn't have the partition key has to get broadcast to everyone. Yes.
Vậy câu hỏi là, bất kỳ truy vấn nào khác không có khóa phân vùng thì phải được broadcast tới tất cả. Đúng.
Or, if I have the partitioning key but I do a range query, then that's going to break me as well, because now if it's partition key between 1 and 1,000, I may not have a continuous range, so I don't know what the data is actually going to be located when I'm just hashing things.
Hoặc, nếu tôi có khóa phân vùng nhưng lại thực hiện truy vấn khoảng, thì điều đó cũng làm hỏng cách này, vì giờ nếu khóa phân vùng nằm giữa 1 và 1.000, tôi có thể không có một khoảng liên tục, nên tôi không biết dữ liệu thực sự nằm ở đâu khi tôi chỉ băm.
So this doesn't work, again, if it's very fine-grained and you're doing things that aren't exactly the quality predicate I need for my lookup. What's another problem with this? Boom.
Vì vậy cách này không hiệu quả nếu nó quá chi tiết và bạn thực hiện những việc không phải là vị từ so sánh bằng chính xác cho việc tra cứu của tôi. Còn vấn đề nào khác không? Đây rồi.
Another partition shows up, another node shows up, or one of these partitions dies, and then now before when I was taking the hash and modding my 4, now I've got to go through and mod by 5, and now the location of the data may change because what partition gets mapped to has changed.
Một phân vùng khác xuất hiện, một nút khác xuất hiện, hoặc một trong các phân vùng này chết, và bây giờ, trước đây tôi lấy giá trị băm rồi modulo 4, giờ tôi phải làm lại và modulo 5, và vị trí của dữ liệu có thể thay đổi vì phân vùng được ánh xạ tới đã thay đổi.
Right?
Đúng không?
So in range partitioning, it's going to have the same problem, because if I add a new node, then I have to start shuffling ranges around, and it may not be isolated to just moving Data from a single partition.
Với phân vùng theo khoảng, cũng sẽ gặp vấn đề tương tự, vì nếu tôi thêm một nút mới, thì tôi phải bắt đầu xáo trộn các dải khóa, và việc đó có thể không chỉ giới hạn ở việc di chuyển dữ liệu từ một phân vùng duy nhất.
Yes. Can you use stable partitioning? Next slide. Alright, so there's two ways to get around this problem.
Vâng. Bạn có thể dùng phân vùng ổn định không? Slide tiếp theo. Được rồi, có hai cách để giải quyết vấn đề này.
And the first would be consistent hashing, which was the hot thing 10 years ago or so, and then the next one would be rendezvous hashing, and consistent hashing is a subset of rendezvous hashing, but consistent hashing is neat and was pretty cool when it came out.
Cách đầu tiên là consistent hashing, thứ từng rất thịnh hành khoảng 10 năm trước, và cách tiếp theo là rendezvous hashing, và consistent hashing là một tập con của rendezvous hashing, nhưng consistent hashing rất hay và khá tuyệt vào lúc nó ra đời.
When Amazon created DynamoDB in the 2000s, they put a paper out and said we're using consistent hashing, because it was a MIT paper from 1999 to 2000 that talked about this in a project called Chord.
Khi Amazon tạo ra DynamoDB vào những năm 2000, họ công bố một bài báo và nói rằng họ đang dùng consistent hashing, vì đó là một bài báo của MIT từ khoảng năm 1999 đến 2000 nói về điều này trong một dự án có tên là Chord.
And so a lot of these distributed databases, the NoSQL guys, the shared-nothing systems that came out around 2010 or so, they're all going to be using this technique.
Và vì thế rất nhiều cơ sở dữ liệu phân tán này, các hệ NoSQL, các hệ shared-nothing xuất hiện vào khoảng năm 2010, tất cả đều sử dụng kỹ thuật này.
Actually, show of hands, who here has heard of consistent hashing before? Less than half. Okay.
Thực ra, giơ tay xem nào, ở đây ai đã từng nghe về consistent hashing rồi? Chưa đến một nửa. Được rồi.
So the basic idea is that the key range is going to be a circle from 0 to 1, and the idea is that when I hash something, it's going to tell me where I'm going to land in the circle, and then I just move forward along the circle until I find the next node, going in a clockwise fashion, or the next partition, and that's going to determine where the data I'm looking for can be found,
Ý tưởng cơ bản là dải khóa sẽ là một vòng tròn từ 0 đến 1, và ý tưởng là khi tôi băm một thứ gì đó, nó sẽ cho tôi biết tôi rơi vào vị trí nào trên vòng tròn, rồi tôi chỉ việc đi tiếp theo vòng tròn cho đến khi gặp nút kế tiếp, theo chiều kim đồng hồ, hoặc phân vùng kế tiếp, và đó sẽ xác định nơi có thể tìm thấy dữ liệu tôi cần,
or where the data I want to insert should be located.
hoặc nơi dữ liệu tôi muốn chèn vào nên được đặt.
So say we have three partitions, P1, P2, P3, and then now I want to hash P1, and I hash it and then make it between the value range 0 and 1.
Giả sử ta có ba phân vùng P1, P2, P3, và giờ tôi muốn băm P1, tôi băm nó rồi đưa về khoảng giá trị từ 0 đến 1.
So I'm going to land somewhere in the circle, and then now I know I just need to scan forward in clockwise fashion, and whatever partition I find along the ring of the circle at that point is where my data should be located.
Vậy là tôi sẽ rơi vào đâu đó trên vòng tròn, và giờ tôi biết chỉ cần quét tiếp theo chiều kim đồng hồ, và phân vùng nào tôi gặp dọc theo vòng tròn tại điểm đó thì dữ liệu của tôi sẽ nằm ở đó.
Same thing if I hash P2 over here, I land at some point in the circle and then I have to again scan up and try to find my next partition.
Tương tự nếu tôi băm P2 ở đây, tôi rơi vào một điểm nào đó trên vòng tròn rồi lại phải quét tiếp lên và cố tìm phân vùng kế tiếp của mình.
So you sort of think the gap here between the two partitions along the circle, this corresponds to the data that they're responsible for.
Vậy bạn có thể hình dung khoảng cách giữa hai phân vùng dọc theo vòng tròn, tương ứng với dữ liệu mà chúng chịu trách nhiệm.
So P1 is responsible for everything going backwards up to P3, P3 is responsible for everything going backwards to P2, and so forth.
Vậy P1 chịu trách nhiệm mọi thứ ngược về phía sau cho đến P3, P3 chịu trách nhiệm mọi thứ ngược về phía sau đến P2, và cứ thế.
Alright, so how does this solve this partitioning thing that we talked about when I add a new partition? Well, say I add a new partition P4 down here.
Được rồi, vậy cách này giải quyết vấn đề phân vùng mà ta đã nói khi thêm một phân vùng mới như thế nào? Giả sử tôi thêm một phân vùng mới P4 ở dưới này.
Then I know that the only thing I need to move is the data that P3 was managing when I cut its part of the circle in half.
Thì tôi biết thứ duy nhất cần di chuyển là dữ liệu mà P3 đang quản lý khi tôi cắt phần vòng tròn của nó làm đôi.
And so all the data now from P4 to P2, that needs to get moved out of P3 and go now to P4. And everybody else on the circle doesn't get affected by this.
Và như vậy toàn bộ dữ liệu từ P4 đến P2, cần được chuyển ra khỏi P3 và giờ chuyển sang P4. Còn mọi nút khác trên vòng tròn không bị ảnh hưởng.
Likewise, I add P5 up here, same thing, I split it and move the data around. And I keep doing it like this.
Tương tự, tôi thêm P5 ở trên này, cũng vậy, tôi chia nó ra và di chuyển dữ liệu. Và tôi cứ tiếp tục như thế.
So then the data structure you're going to use, I think they use a red black tree or something, you need a data structure that everyone keeps coordinated to keep track of, like, here's where, here's what the current ring looks like and here's the partitions that are available to you when you do these lookups.
Vậy cấu trúc dữ liệu mà bạn sẽ dùng, Tôi nghĩ họ dùng cây đỏ-đen hoặc đại loại thế, bạn cần một cấu trúc dữ liệu mà mọi nút cùng giữ đồng bộ để theo dõi, kiểu như, đây là vị trí, đây là hình dạng hiện tại của vòng và đây là các phân vùng mà bạn có thể dùng khi thực hiện các lần tra cứu này.
The question is, in this example here, this is not required that the partitions are equally distributed in the data.
Câu hỏi là, trong ví dụ này, không bắt buộc các phân vùng phải phân bố đều trên dữ liệu.
Yeah, so the way you get around that one is that you have virtual partitions, where you know that multiple partitions around the ring will be assigned to a single node.
Đúng vậy, cách để giải quyết điều đó là dùng các phân vùng ảo, trong đó bạn biết rằng nhiều phân vùng trên vòng sẽ được gán cho một nút duy nhất.
And if you have enough of those, then assuming you're not terribly skewed, right, assuming that your partition key isn't just a value one, everyone has the same value, then you know things will be distributed enough for you.
Và nếu bạn có đủ nhiều phân vùng như vậy, giả sử dữ liệu không bị lệch quá nặng, tức là giả sử khóa phân vùng của bạn không chỉ có giá trị một, mọi bản ghi đều có cùng một giá trị, thì bạn biết dữ liệu sẽ được phân bố đủ đều.
All right, so another thing that they can do, and we'll talk about replication in a second, is that I can now use the ring to help keep track of where data should be replicated to.
Được rồi, một điều nữa mà họ có thể làm, và lát nữa chúng ta sẽ nói về sao chép dữ liệu, là bây giờ tôi có thể dùng vòng này để giúp theo dõi nơi dữ liệu cần được sao chép tới.
So say I want to insert data into my database. When I first hash it, it's going to land it, tell me it goes into P1.
Giả sử tôi muốn chèn dữ liệu vào cơ sở dữ liệu. Khi băm lần đầu, nó sẽ rơi vào vị trí cho biết nó thuộc P1.
But then I follow along the ring and say I want to replicate this three times because I only have three copies of the data. We'll talk about how we handle that in a second.
Rồi tôi đi tiếp dọc theo vòng và giả sử muốn sao chép ba lần vì tôi chỉ có ba bản sao của dữ liệu. Lát nữa chúng ta sẽ nói cách xử lý việc đó.
So I know that the primary location of the data should be in P1.
Vậy tôi biết vị trí chính của dữ liệu là ở P1.
I'm also going to make a copy into P6 and P2 because they're now the next keys I see in, or the next partitions I see along the ring.
Tôi cũng sẽ tạo một bản sao vào P6 và P2 vì chúng là các khóa tiếp theo tôi gặp, hay các phân vùng tiếp theo tôi gặp dọc theo vòng.
And then now when I want to do a lookup, I look for, you know, looking for key one, it hashes, lands at this point in the ring, and I know I can either look at any of these three copies of the data of these different partitions to find the thing that I'm looking for.
Và bây giờ khi tôi muốn tra cứu, tôi tìm, ví dụ như tìm khóa một, nó được băm, rơi vào điểm này trên vòng, và tôi biết mình có thể xem bất kỳ bản nào trong ba bản sao của dữ liệu ở các phân vùng khác nhau này để tìm thứ mình cần.
We'll talk about how in sync these things are going to be. In the NoSQL world, when I do a write into P1, it's not going to immediately get propagated to P6 or P2.
Chúng ta sẽ nói về mức độ đồng bộ của các bản sao này. Trong thế giới NoSQL, khi tôi ghi vào P1, nó sẽ không được lan truyền ngay tới P6 hoặc P2.
And then now I get into inconsistent issues, which goes back to ACID stuff we were talking about a few more lectures. We'll cover that in a second.
Và khi đó tôi gặp các vấn đề về tính không nhất quán, điều này quay lại phần ACID mà chúng ta đã nói cách đây vài bài giảng. Lát nữa chúng ta sẽ đề cập đến.
So as I said, Amazon uses this approach in DynamoDB. But then that was in the paper they put out.
Như tôi đã nói, Amazon dùng cách tiếp cận này trong DynamoDB. Nhưng đó là trong bài báo họ công bố.
In the later follow-up paper they put out four or five years ago, they announced they weren't using this, but consistent hashing is used in a lot of systems.
Trong bài báo tiếp theo họ công bố cách đây bốn hoặc năm năm, họ thông báo là không còn dùng cách này, nhưng băm nhất quán được dùng trong rất nhiều hệ thống.
Snowflake is going to use this to assign files to workers, or data partitions to workers. CacheBase uses this internally. Cassandra uses this for distributing key.
Snowflake dùng nó để gán các tệp cho các worker, hoặc gán các phân vùng dữ liệu cho các worker. CacheBase dùng nó bên trong. Cassandra dùng nó để phân phối khóa.
React was a start-up out of Boston that was a distributed key value store. And they went under ten years ago.
Riak là một công ty khởi nghiệp ở Boston, làm một kho khóa-giá trị phân tán. Và họ đã phá sản cách đây mười năm.
You can see in the logo right here, you can see the ring, and then they had the fan out of the partitions being replicated along that ring.
Bạn có thể thấy ngay trên logo này, bạn thấy cái vòng, và sau đó họ có phần tỏa ra của các phân vùng được nhân bản dọc theo vòng đó.
So their logo was indicating they were using consistent hashing. I think consistent hashing was invented at MIT in '97, '98.
Vậy logo của họ cho thấy họ đang dùng consistent hashing. Tôi nghĩ consistent hashing được phát minh tại MIT vào khoảng năm '97, '98.
But a year before that, there was another paper that came out on a technique called rendezvous hashing. And I think the theory shows that consistent hashing is a specialized subset of rendezvous hashing.
Nhưng một năm trước đó, đã có một bài báo khác công bố về một kỹ thuật gọi là rendezvous hashing. Và tôi nghĩ về mặt lý thuyết người ta chỉ ra rằng consistent hashing là một tập con đặc biệt của rendezvous hashing.
The basic idea here is that for every single key we want to hash, or we want to assign to a partition in our database, we're going to generate multiple hashes for it, where for each hash, we're going to append the partition ID, or the node identifier of the different nodes we have in our cluster.
Ý tưởng cơ bản ở đây là với mỗi khóa mà ta muốn băm, hay muốn gán vào một phân vùng trong cơ sở dữ liệu, ta sẽ tạo ra nhiều giá trị băm cho nó, trong đó với mỗi giá trị băm, ta sẽ nối thêm ID của phân vùng, hoặc định danh của từng nút khác nhau trong cụm của ta.
And then we're going to choose the one that assigns the key to a partition for the one that has the highest hash value.
Và sau đó ta sẽ chọn cái gán khóa vào phân vùng ứng với giá trị băm cao nhất.
So, say again, here's our data, we want to hash, we want to use this column here as the partition key.
Nói lại lần nữa, đây là dữ liệu của ta, ta muốn băm, ta muốn dùng cột này làm khóa phân vùng.
So what we're going to do is, we take the key here, and we're going to hash it, but we're going to concatenate the key value, in this case A, along with some representation of the node or the partition identifier.
Vậy ta sẽ lấy khóa ở đây, và ta sẽ băm nó, nhưng ta sẽ nối giá trị khóa, trong trường hợp này là A, với một biểu diễn nào đó của nút hoặc định danh phân vùng.
Like, you're literally just smashing the bytes together, and then you're hashing it. And then you're going to get a bunch of hash values come out of that.
Tức là bạn cứ ghép các byte lại với nhau theo đúng nghĩa đen, rồi băm nó. Và bạn sẽ nhận được một loạt giá trị băm từ đó.
And then now what you're going to do, for all the other keys, you're just going to choose whatever the one, the hash value that has the highest one, and that tells you what node or partition the key should be assigned to.
Và bây giờ, với tất cả các khóa khác, bạn chỉ cần chọn cái nào, giá trị băm nào cao nhất, và nó cho bạn biết khóa nên được gán vào nút hay phân vùng nào.
And so now, if I add a new key, I just do the same thing, and I end up with a rank order like this, and that determines where it goes.
Và giờ nếu tôi thêm một khóa mới, tôi chỉ làm y như vậy, và tôi có một thứ hạng như thế này, và nó quyết định khóa đi đâu.
And again, the problem we're trying to solve is, if I add or remove partitions or nodes in my system, I don't want to have to move everything around.
Và một lần nữa, vấn đề ta đang cố giải quyết là, nếu tôi thêm hoặc bớt phân vùng hay nút trong hệ thống, tôi không muốn phải di chuyển mọi thứ.
So the way that basically works: if I add another node, then I just do all the hashing again, and it may be the case that some of the data will get moved, but some of the data will still be the same, because it's going to be based on the ranking of the hash values when I run this.
Cách nó hoạt động về cơ bản là: nếu tôi thêm một nút khác, thì tôi chỉ băm lại tất cả, và có thể một phần dữ liệu sẽ bị di chuyển, nhưng một phần dữ liệu vẫn giữ nguyên, vì nó dựa trên thứ hạng của các giá trị băm khi tôi chạy việc này.
So in the case here of D, going back here, before I added node 4, it was assigned node 2, but now when I hash D with node 4, it turns out node 4 is the highest ranked hash value, so then I only have to move key D to that new partition.
Vậy với trường hợp D ở đây, quay lại đây, trước khi tôi thêm nút 4, nó được gán cho nút 2, nhưng giờ khi tôi băm D với nút 4, hóa ra nút 4 có giá trị băm xếp hạng cao nhất, nên tôi chỉ phải chuyển khóa D sang phân vùng mới đó.
So this is going to be faster lookups, because it's log n to go find the data you want, whereas in the case of hashing, I think it's log n.
Như vậy tra cứu sẽ nhanh hơn, vì để tìm dữ liệu bạn muốn chỉ mất log n, trong khi với trường hợp băm kia, tôi nghĩ là log n.
Sorry, it's O(N), whereas this is log n.
Xin lỗi, là O(N), còn cách này là log n.
So the next thing we need to talk about is how we're going to make multiple copies of data, in either the entire tables, the individual records or files, it doesn't matter what it is, how we're going to make copies of that data and put it across multiple nodes, so that again, if one of those nodes crashes, we don't have to stop the world, we don't have to take the whole system down waiting for that node to recover,
Vậy điều tiếp theo ta cần bàn là làm thế nào ta tạo nhiều bản sao của dữ liệu, dù là toàn bộ các bảng, từng bản ghi hay tệp, không quan trọng nó là gì, làm thế nào ta tạo các bản sao của dữ liệu đó và đặt chúng trên nhiều nút, để nếu một trong những node đó bị sập, chúng ta không phải dừng toàn bộ hệ thống, không phải hạ cả hệ thống xuống để chờ node đó phục hồi,
we can keep up and running.
mà vẫn có thể tiếp tục chạy.
So most databases in the world that are going to be distributed databases, meaning running on one or more machines, or two or more machines, are going to be doing basic replication.
Vì vậy, hầu hết các cơ sở dữ liệu phân tán trên thế giới, nghĩa là chạy trên một hoặc nhiều máy, hoặc hai máy trở lên, đều sẽ thực hiện replication cơ bản.
So it'll still be a shared everything box running on a single node, but then they'll do replication to propagate the changes on that one node to another node, or multiple nodes, so that if the main node, the primary node, goes down, I can just recover, Promote the replicas to become the new primary.
Nên nó vẫn là một hệ thống shared everything chạy trên một node duy nhất, nhưng sau đó họ sẽ làm replication để truyền các thay đổi trên node đó sang một node khác, hoặc nhiều node, để nếu node chính, tức primary node, bị sập, tôi có thể phục hồi ngay, nâng các replica lên làm primary mới.
So everything we're talking about here is still going to be applicable to whether you partition databases or non-partition databases, whether it's shared nothing or shared disk, you still want to do all these things.
Vì vậy mọi thứ chúng ta đang nói ở đây vẫn sẽ áp dụng được cho dù bạn phân vùng cơ sở dữ liệu hay không phân vùng, cho dù là shared nothing hay shared disk, bạn vẫn muốn làm tất cả những việc này.
So the first question is, what's the configuration of this replication scheme going to look like? How are we going to then propagate changes from one node to another node?
Vậy câu hỏi đầu tiên là, cấu hình của lược đồ replication này sẽ trông như thế nào? Làm thế nào để truyền các thay đổi từ node này sang node khác?
When should those changes get applied? And how are transactions or queries updating the data, and then for it to be determined how to propagate those changes?
Khi nào các thay đổi đó nên được áp dụng? Và các giao dịch hay truy vấn cập nhật dữ liệu sẽ như thế nào, và sau đó quyết định cách truyền các thay đổi đó?
So let me go through each of these. So the first question is, for any piece of data, who is responsible for it?
Vậy tôi sẽ đi qua từng câu hỏi. Câu hỏi đầu tiên là, với bất kỳ phần dữ liệu nào, ai chịu trách nhiệm về nó?
And where could multiple copies of that piece of data exist?
Và nhiều bản sao của phần dữ liệu đó có thể nằm ở đâu?
And so primary replica is the most common one, where for any single object in our database, some node or partition is now considered the primary location of it.
Primary replica là lựa chọn phổ biến nhất, trong đó với mỗi đối tượng trong cơ sở dữ liệu, một node hoặc partition nào đó được coi là vị trí chính của nó.
Again, whether it's on shared disk or shared nothing, it doesn't matter. It knows that any write or any modification I want to make to that object has to go to that primary node.
Một lần nữa, dù là shared disk hay shared nothing thì cũng không quan trọng. Hệ thống biết rằng mọi thao tác ghi hay sửa đổi mà tôi muốn thực hiện trên đối tượng đó đều phải đi đến primary node.
And then that primary node is responsible for propagating those changes to that object, to any replica that's falling along behind it.
Và primary node đó chịu trách nhiệm truyền các thay đổi trên đối tượng đó đến mọi replica đang theo sau nó.
And then if and when the primary goes down, then we run what's called leader election, where we determine what's going to be the new primary for any object.
Và nếu primary bị sập, khi đó chúng ta chạy cái gọi là leader election, để xác định primary mới cho bất kỳ đối tượng nào.
And this basically looks like a transaction as we had before. Think of it as a table that says, for any object, here's the primary node responsible for it.
Về cơ bản điều này giống một giao dịch như chúng ta đã học trước đây. Hãy hình dung nó như một bảng cho biết, với mỗi đối tượng, đây là primary node chịu trách nhiệm về nó.
So I just run a transaction on that, decide how to update that atomically, decide to promote a new primary.
Vậy tôi chỉ cần chạy một giao dịch trên đó, quyết định cách cập nhật nó một cách nguyên tử, quyết định nâng một primary mới lên.
And then this is where Paxos and Raft come in to do that kind of thing, or two-phase commit.
Và đây là chỗ Paxos và Raft xuất hiện để làm việc kiểu này, hoặc two-phase commit.
Another choice that's less common is to do multi-primary, where an object can exist at any location in our distributed system, And therefore it can be updated by one of these nodes.
Một lựa chọn khác ít phổ biến hơn là multi-primary, trong đó một đối tượng có thể tồn tại ở bất kỳ vị trí nào trong hệ thống phân tán của chúng ta, và do đó nó có thể được cập nhật bởi bất kỳ node nào trong số này.
And then I've got to resolve any conflicts I have if two nodes update the same object. How do I decide which should be the latest version that successfully commits?
Và khi đó tôi phải giải quyết mọi xung đột xảy ra nếu hai node cập nhật cùng một đối tượng. Làm sao để quyết định cái nào nên là phiên bản mới nhất được commit thành công?
So as I said, primary replica is the most common one. People are running Postgres in enterprise settings. Most Postgres instances are running on a single box, and they'll be doing something like this.
Như tôi đã nói, primary replica là mô hình phổ biến nhất. Người ta chạy Postgres trong môi trường doanh nghiệp. Hầu hết các instance Postgres chạy trên một máy duy nhất, và chúng sẽ hoạt động đại loại như thế này.
So all the reads and writes can go to the primary, and then when transactions commit, or as changes are being applied, they propagate to the replicas.
Tất cả các thao tác đọc và ghi đều có thể đi đến primary, rồi khi các giao dịch commit, hoặc khi các thay đổi đang được áp dụng, chúng được lan truyền sang các replica.
And in some systems, you can actually then run read-only queries on the replicas.
Và ở một số hệ thống, bạn thực sự có thể chạy các truy vấn chỉ đọc trên các replica.
If you know your queries aren't going to update any data, you can hand them off to the read replicas, and that way you don't interfere with anything on the primary.
Nếu bạn biết các truy vấn của mình sẽ không cập nhật dữ liệu nào, bạn có thể chuyển chúng cho các read replica, và như vậy bạn không gây ảnh hưởng gì đến primary.
The writes go as fast as possible, so you want to offload them from the primary if you can.
Các thao tác ghi chạy nhanh nhất có thể, nên nếu được thì bạn muốn giảm tải các truy vấn đọc khỏi primary.
But again, depending on how you're propagating updates, which I'll talk about in a second, the reads on the replicas might be reading stale data. And again, for some applications, that might be okay.
Nhưng một lần nữa, tùy vào cách bạn lan truyền các cập nhật, mà lát nữa tôi sẽ nói tới, các thao tác đọc trên replica có thể đọc phải dữ liệu cũ. Và với một số ứng dụng, điều đó có thể chấp nhận được.
What's less common is to do multi-primary, and this is where reads and writes can go to any node on any object, and then now the nodes are responsible for communicating and coordinating with each other, or through a centralized coordinator, to determine which writes should succeed and which writes should not succeed.
Ít phổ biến hơn là mô hình multi-primary, trong đó đọc và ghi có thể đi đến bất kỳ node nào, trên bất kỳ đối tượng nào, và lúc này các node có trách nhiệm giao tiếp và phối hợp với nhau, hoặc thông qua một bộ điều phối tập trung, để xác định thao tác ghi nào nên thành công và thao tác ghi nào không.
And if one thing gets written at the bottom, you know that it wants to get propagated to the top. Or likewise, the other way. Yes. Yes.
Và nếu có thứ gì được ghi ở dưới, thì bạn biết là nó cần được lan truyền lên trên. Hoặc ngược lại. Vâng. Vâng.
The question is, I said in primary replica, you want to do a leader election. Why would you ever want to change the names of the primaries?
Câu hỏi là: tôi nói với primary replica thì cần bầu chọn leader. Tại sao lại phải đổi primary?
This node catches on fire, goes down, crashes. Which one is now the new primary? Right?
Node này bốc cháy, sập, hỏng. Vậy node nào giờ là primary mới? Đúng không?
And then now you got, say, this node goes down, the two replicas say they're both going to be the primary.
Rồi giả sử node này sập, hai replica đều nói rằng mình sẽ làm primary.
You only want one of them to win, so you need a leader election for that. Yes.
Bạn chỉ muốn một trong hai thắng, nên cần bầu chọn leader cho việc đó. Vâng.
The question is, in a multi-primary, what's an example you would want one write to succeed on one node and not the other?
Câu hỏi là, trong multi-primary, ví dụ nào cho thấy bạn muốn một thao tác ghi thành công trên node này mà không thành công trên node kia?
Say you're trying to guarantee the ordering of transactions, serializable, and you and I write to the same thing at the same time, only one of them should succeed.
Giả sử bạn muốn đảm bảo thứ tự của các giao dịch, tức serializable, và bạn với tôi cùng ghi vào một thứ vào cùng lúc, thì chỉ một trong hai được thành công.
Or say we write to two things at the same time. You write two things, I write two things.
Hoặc giả sử chúng ta ghi vào hai thứ cùng lúc. Bạn ghi hai thứ, tôi ghi hai thứ.
So I should see all my writes, all your writes, and not a mix of the two. So one of those transactions has to fail.
Vậy tôi phải thấy toàn bộ các lần ghi của tôi, hoặc toàn bộ của bạn, chứ không phải lẫn lộn cả hai. Nên một trong các giao dịch đó phải thất bại.
And that's going to be the two-phase locking or OCC, all the stuff we talked about before. Yes.
Và đó sẽ là two-phase locking hoặc OCC, tất cả những thứ chúng ta đã nói trước đây. Vâng.
The question is, should you use something like multi-Paxos? Yes. Next class.
Câu hỏi là: có nên dùng thứ như multi-Paxos không? Có. Buổi sau.
What's that? The question is, if I'm doing 2PL, where do I store the locks? A few more slides. Let me switch to K-safety.
Gì cơ? Câu hỏi là, nếu tôi dùng 2PL thì lưu các lock ở đâu? Còn vài slide nữa. Để tôi chuyển sang K-safety.
Let's talk about the propagation scheme, and then I'll get to your question. K-safety is basically how many replicas do I have to have in order to stay up.
Hãy nói về cơ chế lan truyền, rồi tôi sẽ trả lời câu hỏi của bạn. K-safety về cơ bản là số bản sao tối thiểu tôi phải có để hệ thống vẫn tiếp tục hoạt động.
So if I have three copies of the data, and my K-safety factor is one, meaning I need to have at least one copy of the data live.
Giả sử tôi có ba bản sao của dữ liệu, và hệ số K-safety của tôi là một, nghĩa là tôi cần có ít nhất một bản sao dữ liệu còn hoạt động.
So if two nodes go down, rather than me still taking updates to update the database, I say I'm not in a safe mode right now, I'm going to stop the system, don't take any new updates, because I don't want to make changes to my node, and then have that node go down and end up losing them.
Vậy nếu hai nút bị sập, thay vì tiếp tục nhận các cập nhật để cập nhật cơ sở dữ liệu, tôi sẽ nói rằng lúc này tôi không ở chế độ an toàn, tôi sẽ dừng hệ thống, không nhận thêm cập nhật nào nữa, vì tôi không muốn thực hiện thay đổi trên nút của mình, rồi nút đó sập và cuối cùng làm mất các thay đổi ấy.
So you can specify how many machines need to be up, or how many copies of data you need to have in order for the system to stay online.
Vì vậy bạn có thể chỉ định cần có bao nhiêu máy đang hoạt động, hoặc cần có bao nhiêu bản sao dữ liệu để hệ thống tiếp tục trực tuyến.
Alright, so if we update data on a node, whether it's multi-primary or primary replica, and again, in a multi-primary world, you still can have replicas.
Được rồi, vậy nếu chúng ta cập nhật dữ liệu trên một nút, dù là multi-primary hay primary replica, và nhắc lại, trong thế giới multi-primary, bạn vẫn có thể có các bản sao.
Every primary can have its own bunch of replicas that keeps this thing as well. They're not mutually exclusive.
Mỗi primary có thể có một nhóm bản sao riêng để lưu giữ dữ liệu này. Chúng không loại trừ lẫn nhau.
Now the question is, if I update something on the primary, should I wait until the replicas acknowledge that they got those writes before I tell the outside world that your transaction has succeeded, or your update has succeeded?
Giờ câu hỏi là, nếu tôi cập nhật một thứ trên primary, tôi có nên đợi các bản sao xác nhận là chúng đã nhận được các thao tác ghi đó trước khi thông báo cho bên ngoài rằng giao dịch của bạn đã thành công, hay cập nhật của bạn đã thành công không?
So, if you're going to wait, this is called synchronous propagation, strong consistency.
Nếu bạn chờ, thì đây gọi là truyền bá đồng bộ (synchronous propagation), tức tính nhất quán mạnh.
And the idea is that my transaction did a bunch of updates on this node here, that's the primary, it has a replica behind it.
Ý tưởng là giao dịch của tôi đã thực hiện một loạt cập nhật trên nút này, đó là primary, và phía sau nó có một bản sao.
I'm going to propagate those changes to the replica, I'm going to tell it to flush, and I have to wait until the replica comes back and says, "Yes, I got your changes, and they're durable on disk, I flushed them on disk."
Tôi sẽ truyền các thay đổi đó sang bản sao, tôi sẽ yêu cầu nó flush, và tôi phải đợi cho đến khi bản sao phản hồi: "Vâng, tôi đã nhận được các thay đổi của bạn, và chúng đã bền vững trên đĩa, tôi đã flush chúng xuống đĩa."
And so the primary has to wait, and then once it finishes, it sends the acknowledgment and says, "The thing you asked me to write to disk, I wrote to disk successfully."
Vì vậy primary phải đợi, và khi xong, nó gửi xác nhận và nói: "Thứ bạn yêu cầu tôi ghi xuống đĩa, tôi đã ghi xuống đĩa thành công."
And then, and only then, do you tell the outside world your transaction has committed.
Và sau đó, và chỉ khi đó, bạn mới báo cho bên ngoài biết giao dịch của bạn đã commit.
And if you have multiple replicas in different locations, they all, if you want things to be very strong consistency, they all have to agree that this transaction is committing.
Và nếu bạn có nhiều bản sao ở các vị trí khác nhau, tất cả chúng, nếu bạn muốn tính nhất quán thật mạnh, thì tất cả đều phải đồng ý rằng giao dịch này đang commit.
We'll talk about how we're going to do that in the next class, before you tell the outside world you committed.
Chúng ta sẽ nói về cách thực hiện điều đó trong buổi học tới, trước khi bạn báo cho bên ngoài biết là bạn đã commit.
And that way, if the primary goes down, or, you know, the changes have been applied to the replica, yes. Question, is this two-phase commit?
Và như vậy, nếu primary bị sập, hoặc, bạn biết đấy, các thay đổi đã được áp dụng lên bản sao, vâng, mời bạn. Câu hỏi: đây có phải là two-phase commit không?
Two-phase commit is one way to do this, yes.
Two-phase commit là một cách để làm điều này, đúng vậy.
The key idea is that I'm waiting for everyone to come back and say, "Yep, I got what you wanted," and before you tell the outside world you committed.
Ý tưởng chính là tôi đợi mọi bên phản hồi và nói: "Vâng, tôi đã nhận được điều bạn muốn", và việc này diễn ra trước khi bạn báo cho bên ngoài là đã commit.
Asynchronous would be, the outside world tells me I want to commit, I can send a message to the replica and say, "Hey, I got this change, go ahead and commit the change for me," but I'm not going to wait for it to come back.
Còn bất đồng bộ là khi bên ngoài nói với tôi rằng họ muốn commit, tôi có thể gửi một thông điệp đến bản sao và nói: "Này, tôi nhận được thay đổi này, hãy commit thay đổi đó giúp tôi", nhưng tôi sẽ không đợi nó phản hồi.
I'm going to immediately tell you, say, "Yep, I got your change," right? And then, eventually, this thing will flush.
Tôi sẽ nói ngay với bạn rằng: "Vâng, tôi đã nhận được thay đổi của bạn," đúng không? Và rồi, cuối cùng thì phần này cũng sẽ được flush.
Of course, now, there's a brief window where, like, if this thing crashes, and maybe this thing crashes, but I've already told you your transaction committed, then I come back and it's gone, right?
Tất nhiên, bây giờ sẽ có một khoảng thời gian ngắn mà, nếu nút này gặp sự cố, và có thể là nút này gặp sự cố, nhưng tôi đã nói với bạn là giao dịch của bạn đã commit rồi, rồi tôi quay lại thì nó biến mất, đúng không?
Because maybe, maybe I wrote to the log on this guy here, right?
Vì có thể, có thể tôi đã ghi vào log trên nút này, đúng không?
And say it's a shared-nothing system, the log is on the local box, but that node gets nuked, the log is gone, and now your change, you know, didn't actually get propagated to everyone else, and you go try to read it, it's not there anymore.
Và giả sử đây là hệ thống shared-nothing, log nằm trên máy cục bộ, nhưng nút đó bị xoá sạch, log mất luôn, và giờ thay đổi của bạn, bạn biết đấy, thực ra chưa được lan truyền tới các nút khác, và bạn thử đọc nó thì nó không còn ở đó nữa.
So the NoSQL guys were all about this thing, because they said, "Oh, we don't want to wait for transactions to commit," we didn't even have really notion of transactions, whereas if you care about, you know, really care about not losing data, you want to do the thing at the top.
Những người làm NoSQL từng rất chuộng cách này, vì họ nói: "Ồ, chúng tôi không muốn chờ giao dịch commit," thậm chí họ còn chẳng có khái niệm giao dịch thực sự, trong khi nếu bạn quan tâm, thực sự quan tâm đến việc không mất dữ liệu, thì bạn sẽ muốn làm cách ở phía trên.
You can play games about things, like, I'm showing only, you know, one primary and one replica, you could say, well, I have one primary and three replicas, and as long as two of my replicas come back and say they got my change, then I'm not going to wait for the third one, right?
Bạn có thể xoay xở một chút, ví dụ tôi chỉ đang vẽ, một primary và một replica, bạn có thể nói, tôi có một primary và ba replica, và miễn là hai replica phản hồi rằng đã nhận được thay đổi của tôi, thì tôi sẽ không chờ replica thứ ba nữa, đúng không?
You could do that and try to, you know, reduce the time, amount of time you have to wait.
Bạn có thể làm vậy để cố gắng, giảm thời gian bạn phải chờ.
So, okay.
Vâng, được rồi.
Propagation timing just basically says when do you actually send the, coming back here, when do you actually send the changes from the primary to the replica?
Propagation timing về cơ bản cho biết khi nào bạn thực sự gửi, quay lại đây, khi nào bạn thực sự gửi các thay đổi từ primary đến replica?
So you could do this continuously, so every single time you do an update in the middle of a transaction, you propagate that change to the other node, And then, and then that way when you go to commit, it's basically applied all the changes and just sending the commit message.
Bạn có thể làm liên tục, tức là mỗi lần bạn cập nhật giữa chừng một giao dịch, bạn lan truyền thay đổi đó sang nút kia, Và như vậy, khi bạn commit, về cơ bản mọi thay đổi đã được áp dụng và chỉ cần gửi thông điệp commit.
Or if you do it upon commit, you basically stage all the updates on the primary, and then only when you get the commit message from the, from the application, then you send all the updates you want to have applied to the replicas, along with the commit message.
Hoặc nếu làm khi commit, về cơ bản bạn tạm giữ mọi cập nhật trên primary, và chỉ khi nhận được thông điệp commit từ ứng dụng, thì bạn mới gửi tất cả các cập nhật muốn áp dụng tới các replica, cùng với thông điệp commit.
You have to wait longer for them to apply the changes and come back to you, but the idea here is that you don't have to ask them to abort and roll anything back.
Bạn phải chờ lâu hơn để chúng áp dụng thay đổi và phản hồi lại, nhưng ý tưởng ở đây là bạn không phải yêu cầu chúng abort và rollback bất cứ thứ gì.
Most systems do the top one and not the bottom one.
Hầu hết các hệ thống dùng cách ở trên chứ không dùng cách ở dưới.
Alright, so I'll come back next class and I'll talk about active-active versus active-passive, but I want to talk about a bunch of these things that have been coming up, like, okay, well, what's the, what's the architecture of the distributed system?
Được rồi, vậy buổi sau tôi sẽ quay lại và nói về active-active so với active-passive, nhưng tôi muốn nói về một loạt vấn đề đã xuất hiện, kiểu như, được rồi, vậy kiến trúc của hệ thống phân tán là gì?
Who's talking to what? Is there something in the, you know, is there a centralized piece that can coordinate everything that we want to do?
Ai nói chuyện với ai? Có thứ gì đó trong hệ thống, bạn biết đấy, có một thành phần tập trung có thể điều phối mọi việc chúng ta muốn làm không?
And then this will segue into distributed concurrency control in the next class. So, if all the transactions need to update only data on a single box, that's easy to do, right?
Và điều này sẽ dẫn sang điều khiển đồng thời phân tán ở buổi sau. Vậy, nếu mọi giao dịch chỉ cần cập nhật dữ liệu trên một máy duy nhất, thì việc đó dễ thực hiện, đúng không?
Every box can just run its own, you know, local, you know, local concurrency control. It doesn't need to coordinate with anybody else, right, ignoring replica stuff.
Mỗi máy có thể tự chạy cơ chế, bạn biết đấy, điều khiển đồng thời cục bộ của riêng nó. Nó không cần phối hợp với bất kỳ ai khác, đúng không, bỏ qua chuyện bản sao.
It just applies all its changes and commits and done.
Nó chỉ áp dụng mọi thay đổi, commit, và xong.
It's when I have to start touching data across multiple nodes, especially if I have replicas, and I want to make sure that those guys are all agreeing that we're committing transactions together, then I need a mechanism to coordinate all that, right?
Vấn đề chỉ xuất hiện khi tôi phải bắt đầu truy cập dữ liệu trên nhiều nút, đặc biệt nếu tôi có các bản sao, và tôi muốn đảm bảo rằng tất cả các nút đó đều đồng ý là chúng ta cùng commit các giao dịch, thì khi đó tôi cần một cơ chế để phối hợp tất cả những việc này, đúng không?
And there's two approaches. One is to use a centralized coordinator.
Có hai cách tiếp cận. Một là dùng một bộ điều phối tập trung.
Think of this like a global traffic cop that has a complete understanding of all the transactions that are running in my system at any given time, And it's where I can store my locks if I want to in that centralized location, or it can be completely decentralized and have the nodes themselves decide how they're going to, you know, choose when to commit.
Hãy hình dung nó như một cảnh sát giao thông toàn cục nắm được toàn bộ các giao dịch đang chạy trong hệ thống của tôi tại bất kỳ thời điểm nào, và đó cũng là nơi tôi có thể lưu các khóa nếu muốn, ở vị trí tập trung đó, hoặc cách kia là hoàn toàn phi tập trung và để chính các nút tự quyết định cách thức, bạn biết đấy, chọn thời điểm commit.
Now, you still can do a leader election in a centralized architecture, because one node has to say, "This is what we want to do," but there isn't going to be a complete global view of all the transactions running in the system.
Giờ đây, bạn vẫn có thể bầu chọn leader trong kiến trúc phi tập trung, vì phải có một nút nói: "Đây là việc chúng ta muốn làm", nhưng sẽ không có một cái nhìn toàn cục đầy đủ về tất cả các giao dịch đang chạy trong hệ thống.
So, in a centralized architecture, you have this sort of coordinator sitting on the side, and say my query, my transaction wants to show up and want to touch data in these three partitions.
Vậy, trong kiến trúc tập trung, bạn có một bộ điều phối đặt ở bên cạnh, và giả sử truy vấn, giao dịch của tôi xuất hiện và muốn truy cập dữ liệu trong ba phân vùng này.
So, I'm first going to send my lock request for the data I want to access, and this is going to be done because I'm sending the query, and this thing knows how to parse that query and break it up, or it can say explicitly, "I want to lock data at these partitions within these ranges or these values" or something, right?
Trước hết, tôi sẽ gửi yêu cầu khóa cho dữ liệu mà tôi muốn truy cập, và điều này được thực hiện vì tôi gửi truy vấn, và bộ điều phối biết cách phân tích truy vấn đó và chia nhỏ nó ra, hoặc tôi có thể nói rõ ràng rằng, "Tôi muốn khóa dữ liệu tại các phân vùng này, trong những khoảng hoặc những giá trị này" chẳng hạn, đúng không?
There's some lock request to a coordinator up above.
Có một yêu cầu khóa nào đó gửi lên bộ điều phối ở phía trên.
And then, now, this is maintaining this lock information, sends back the acknowledgement to the application that you got this, you acquired these locks that you wanted, and then now the application can send whatever queries it wants to the partitions to do whatever it needed.
Và rồi, bộ điều phối này duy trì thông tin về khóa, gửi lại xác nhận cho ứng dụng rằng bạn đã nhận được, bạn đã có được những khóa mà bạn muốn, và sau đó ứng dụng có thể gửi bất kỳ truy vấn nào mà nó muốn tới các phân vùng để làm những gì nó cần.
And then, now, when it wants to go to commit, it has to go to the coordinator and says, "Hey, I want to commit my transaction, here's what I did."
Và rồi, khi nó muốn commit, nó phải đến bộ điều phối và nói: "Này, tôi muốn commit giao dịch của mình, đây là những gì tôi đã làm."
The coordinator is then responsible for communicating with the other partitions and say, "Hey, this transaction made some changes on you, is it safe to commit this?"
Sau đó bộ điều phối chịu trách nhiệm liên lạc với các phân vùng khác và hỏi: "Này, giao dịch này đã thay đổi một số thứ trên bạn, commit nó có an toàn không?"
And they're all running their own local concurrency protocol to decide what's allowed to commit or not.
Và tất cả chúng đều chạy giao thức điều khiển đồng thời cục bộ của riêng mình để quyết định cái gì được phép commit hay không.
And then, if they send back the acknowledgement that, you know, that this transaction is allowed to commit, then, only then, the coordinator can send back the response to the application that said you're allowed to commit.
Và rồi, nếu chúng gửi lại xác nhận rằng, giao dịch này được phép commit, thì chỉ khi đó, bộ điều phối mới có thể gửi phản hồi lại cho ứng dụng rằng bạn được phép commit.
This is how people built distributed databases back in the 80s or 90s.
Đây là cách người ta xây dựng các cơ sở dữ liệu phân tán hồi những năm 80 hay 90.
There was a bunch of products that were called, in the old days, they were called TP monitor, or they still are called TP monitors, but it stood for, in the old days, it stood for Telecom Processing Monitor.
Ngày xưa có một loạt sản phẩm được gọi là TP monitor, hoặc hiện nay vẫn gọi là TP monitor, nhưng ban đầu nó viết tắt cho Telecom Processing Monitor.
And then, over time, the acronym just got changed to be Transaction Processing Monitor. But it's basically a centralized coordinator that knows how to run distributed transactions across multiple nodes.
Rồi theo thời gian, từ viết tắt này được đổi thành Transaction Processing Monitor. Nhưng về cơ bản, đó là một bộ điều phối tập trung biết cách chạy các giao dịch phân tán trên nhiều nút.
And then, in the 90s, there was an effort to standardize the protocol in which you can have a TP monitor communicate with the different partitions.
Sau đó, vào những năm 90, có một nỗ lực chuẩn hóa giao thức để một TP monitor có thể giao tiếp với các phân vùng khác nhau.
These things called XA, OpenXA or something, yeah, OpenXA, it was like a transaction protocol that says, basically, do 2PL coordination across different devices, or different systems.
Thứ này gọi là XA, OpenXA hay gì đó, đúng rồi, OpenXA, nó là một giao thức giao dịch, về cơ bản quy định rằng hãy thực hiện điều phối 2PL trên các thiết bị hoặc hệ thống khác nhau.
You could have your TP monitor, the coordinator at the top, communicate with an Oracle database and a TimeSend database, or a nonstop SQL database, and knew how to do distributed transactions across them.
Bạn có thể có TP monitor, bộ điều phối ở trên cùng, giao tiếp với một cơ sở dữ liệu Oracle và một cơ sở dữ liệu TimesTen, hoặc một cơ sở dữ liệu NonStop SQL, và biết cách thực hiện giao dịch phân tán giữa chúng.
And everyone was still running their own local thing. BEA was another famous one. That got bought by Oracle. I know the founder of BEA. The dude's amazing. He's hilarious.
Và mỗi hệ thống vẫn tự chạy phần việc cục bộ của mình. BEA là một cái tên nổi tiếng khác. Công ty đó bị Oracle mua lại. Tôi biết người sáng lập BEA. Ông ấy tuyệt vời lắm. Rất hài hước.
He wrote one of the first databases on Solaris in the 1980s at Sun. TransArc was founded by, actually came out of the Andrew File System project here at CMU, the Andrew project.
Ông ấy viết một trong những cơ sở dữ liệu đầu tiên trên Solaris vào thập niên 1980 tại Sun. TransArc được sáng lập bởi thực ra xuất phát từ dự án Andrew File System ở CMU này, dự án Andrew.
And this was founded by Jeff Ebinger in the self-engineering department, and got bought by IBM. I don't think it's still around.
Và nó do Jeff Eppinger sáng lập ở khoa kỹ thuật phần mềm, rồi bị IBM mua lại. Tôi nghĩ giờ nó không còn nữa.
And then, OMID is a TP monitor for running transactions on HBase and other systems. This is not that common. What is more common is using a middleware approach.
Còn OMID là một TP monitor để chạy giao dịch trên HBase và các hệ thống khác. Cách này không phổ biến lắm. Phổ biến hơn là dùng cách tiếp cận middleware.
It's basically the same thing.
Về cơ bản thì cũng như vậy.
It's just now all the queries go to the centralized thing directly, and this is responsible for routing all the queries and maintaining the lock table and sending all the requests to the different nodes as needed.
Chỉ khác là bây giờ mọi truy vấn đều đi thẳng đến thành phần tập trung này, và nó chịu trách nhiệm định tuyến mọi truy vấn, duy trì bảng khóa và gửi các yêu cầu đến những nút khác nhau khi cần.
So it looks like a single database server instance into the application server, but behind the scenes, it's coordinating across these different nodes.
Vì vậy, với máy chủ ứng dụng, nó trông như một thể hiện máy chủ cơ sở dữ liệu duy nhất, nhưng ở phía sau, nó đang điều phối giữa các nút khác nhau này.
This is what Google did back in the day when they started out on MySQL, before Spanner. They basically did the same thing. This is also what Facebook does still today.
Đây là điều Google đã làm ngày trước khi mới bắt đầu với MySQL, trước Spanner. Về cơ bản họ làm y như vậy. Facebook ngày nay vẫn làm như thế.
Facebook runs the largest MySQL cluster, and it's basically using a middleware approach to look like a single logical database. Alright, last slide: the centralized coordinator.
Facebook chạy cụm MySQL lớn nhất, và về cơ bản dùng cách tiếp cận middleware để trông như một cơ sở dữ liệu logic duy nhất. Được rồi, slide cuối: bộ điều phối tập trung.
Basically, the idea is that you can start a transaction request to any node. Somehow, there's a leader election to decide that this node is going to be responsible for coordinating everything.
Ý tưởng là bạn có thể bắt đầu một yêu cầu giao dịch tới bất kỳ nút nào. Bằng cách nào đó, có một cuộc bầu chọn leader để quyết định nút này sẽ chịu trách nhiệm điều phối mọi thứ.
The application can then send requests either to individual nodes or even to the leader and let the leader route things for you.
Ứng dụng khi đó có thể gửi yêu cầu đến từng nút riêng lẻ hoặc thậm chí đến leader và để leader định tuyến giúp bạn.
But when it comes time to commit, the leader is responsible for interacting with the other partitions that are involved in this transaction and saying, "Is this transaction allowed to commit, yes or no?"
Nhưng đến lúc commit, leader chịu trách nhiệm tương tác với các phân vùng khác có tham gia giao dịch này và nói rằng, "Giao dịch này có được phép commit hay không?"
And we'll talk about in the next class how we're actually going to run this. Alright, so I'm going to skip federated databases in the next class.
Và ở buổi học tiếp theo, chúng ta sẽ nói về cách thực sự chạy việc này. Được rồi, tôi sẽ bỏ qua cơ sở dữ liệu liên kết (federated database) ở buổi học tiếp theo.
Basically, it's the middleware approach, but the idea is that instead of having all the nodes that you're talking to be the same database system, like it's MySQL, just different copies of it, or different instances running different nodes, I can have a federated database.
Về cơ bản, đó là cách tiếp cận middleware, nhưng ý tưởng là thay vì để tất cả các nút mà bạn giao tiếp đều là cùng một hệ cơ sở dữ liệu, chẳng hạn là MySQL, chỉ là các bản sao khác nhau của nó, hoặc các thực thể khác nhau chạy trên các nút khác nhau, thì tôi có thể dùng một cơ sở dữ liệu liên kết.
I can have a single view into this middleware that then knows how to take a single query and send the request to whatever database server you want to connect this to.
Tôi có thể có một góc nhìn duy nhất vào middleware này, và nó biết cách nhận một truy vấn duy nhất rồi gửi yêu cầu đến bất kỳ máy chủ cơ sở dữ liệu nào mà bạn muốn kết nối.
So it looks like your Mongo database, your MySQL database, your Postgres database all look like a single database system, but this middleware is hiding all that from you.
Vì vậy, cơ sở dữ liệu Mongo, MySQL của bạn, cơ sở dữ liệu Postgres của bạn trông như một hệ cơ sở dữ liệu duy nhất, nhưng middleware này che giấu tất cả những điều đó với bạn.
These are not that common, they don't work very well, but this is an idea that's been around for a while, and this goes back to the 1990s.
Những hệ này không phổ biến lắm, chúng hoạt động không tốt lắm, nhưng đây là một ý tưởng đã có từ lâu, từ những năm 1990.
Alright, so let me just quickly talk about this, and this will take us to the next class.
Được rồi, để tôi nói nhanh về phần này, và nó sẽ dẫn chúng ta sang buổi học tiếp theo.
So, say now I want to run a transaction that wants to talk to data across two different nodes or different partitions.
Giả sử bây giờ tôi muốn chạy một giao dịch cần truy cập dữ liệu trên hai nút hoặc hai phân vùng khác nhau.
Things are easy if they're only touching one thing at a time, but as soon as I have to start touching data that is at different nodes, then this becomes problematic, because now we have to do two-phase locking or OCC, whatever we talked about before, and now I have to worry about deadlocks and all the things we talked about on a single node.
Mọi thứ dễ dàng nếu mỗi lần chỉ chạm vào một thứ, nhưng ngay khi tôi phải bắt đầu truy cập dữ liệu nằm ở các nút khác nhau, thì việc này trở nên rắc rối, vì giờ chúng ta phải dùng khóa hai pha hoặc OCC, bất cứ thứ gì chúng ta đã nói trước đây, và giờ tôi phải lo về bế tắc và tất cả những vấn đề chúng ta đã nói trên một nút đơn.
I've got to make this work in a distributed environment.
Tôi phải làm cho nó hoạt động trong môi trường phân tán.
And if they're in the same rack, then yeah, communication would be kind of fast, but if I'm running across a wide area network, across wide geographical regions like US East, US West, and AWS, then this is hard.
Và nếu chúng ở cùng một rack thì đúng, giao tiếp sẽ khá nhanh, nhưng nếu tôi chạy qua mạng diện rộng, qua các vùng địa lý rộng như US East, US West và AWS, thì việc này khó.
So that's where we'll pick up next class.
Vì vậy đó là nơi chúng ta sẽ tiếp tục ở buổi sau.
We'll talk about how we do distributed OLTP systems and distributed OLAP systems to do joins across different nodes, but everything we talked about today is the foundation of building an initial distributed OLTP system.
Chúng ta sẽ nói về cách làm các hệ OLTP phân tán và các hệ OLAP phân tán để thực hiện phép join giữa các nút khác nhau, nhưng mọi thứ chúng ta nói hôm nay là nền tảng để xây dựng một hệ OLTP phân tán ban đầu.
Any questions? In the back, yes. Say it again?
Có câu hỏi nào không? Ở phía cuối, vâng. Bạn nói lại được không?
Is there any existing implementation of a federated database? So, Trino or Presto will kind of give you this now with using connectors.
Có triển khai nào hiện có của cơ sở dữ liệu liên kết không? Trino hoặc Presto hiện nay phần nào cho bạn điều này bằng cách dùng connector.
Postgres foreign data wrappers are essentially kind of doing the same thing now too.
Postgres foreign data wrapper về cơ bản giờ cũng đang làm điều tương tự.
The problem is, what you want to do is, a query shows up, and then whatever the middleware system is, they would know, oh, you want to touch data at this database system, and instead of then carving off what are the parts of the query that need to run in that system, and trying to push down predicates, projections, try to send down a query request that's specialized to that, whatever the target data system is, oftentimes they can't do that,
Vấn đề là, thứ bạn muốn là khi một truy vấn đến, thì dù hệ middleware là gì, nó cũng sẽ biết, à, bạn muốn truy cập dữ liệu ở hệ cơ sở dữ liệu này, và thay vì tách ra những phần nào của truy vấn cần chạy trong hệ đó, và cố đẩy xuống các vị từ, các phép chiếu, cố gửi xuống một yêu cầu truy vấn chuyên biệt cho hệ dữ liệu đích, thì thường chúng không làm được điều đó,
and it's usually like a select star query to suck all the data up.
và thường là một truy vấn select star để hút toàn bộ dữ liệu lên.
That's the big challenge there, because you end up building the lowest common denominator for the wide variety of systems you can support. Okay? In the back, yes.
Đó là thách thức lớn ở đây, vì cuối cùng bạn xây dựng ra mẫu số chung thấp nhất cho rất nhiều loại hệ thống mà bạn có thể hỗ trợ. Được chưa? Bạn ở phía sau, mời bạn.
Question: are parallel databases essentially the same as shared-disk databases? Yes.
Câu hỏi: cơ sở dữ liệu song song về cơ bản có giống cơ sở dữ liệu shared-disk không? Có.
And you can argue also, too, that a parallel database where you're actually, like, a NAS or a storage attack network, is that the same thing? Sort of, yes.
Và bạn cũng có thể lập luận rằng một cơ sở dữ liệu song song mà thực tế bạn dùng, kiểu như một NAS hay một mạng lưu trữ (storage area network), thì có giống nhau không? Ở mức nào đó thì có.
But we'll see next class, you can actually have different architectures where the write-ahead log is distributed to the shared disk, and you still then coordinate across them.
Nhưng như chúng ta sẽ thấy ở buổi sau, thực ra có thể có những kiến trúc khác trong đó write-ahead log được phân tán lên đĩa dùng chung, và bạn vẫn phải phối hợp giữa chúng.
It's slightly different, but at a high level, yes. Like, if I have a single box that has, like, 20 CPU sockets in it, is that the same thing as a distributed database?
Có hơi khác một chút, nhưng nhìn ở mức tổng quát thì có. Chẳng hạn, nếu tôi có một máy đơn có tới 20 socket CPU, thì nó có giống một cơ sở dữ liệu phân tán không?
At a high level, yes. But some architecture decisions you make can be different. Okay, alright guys, have a good holiday. See you on Monday next week.
Ở mức tổng quát thì có. Nhưng một số quyết định về kiến trúc mà bạn đưa ra có thể khác nhau. Được rồi, các bạn nghỉ lễ vui vẻ nhé. Hẹn gặp lại các bạn vào thứ Hai tuần sau.
Music Music Music Music Music Music Music
Nhạc nhạc Nhạc nhạc nhạc nhạc nhạc
Music Music
Nhạc nhạc
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.