Erlang OTP: Distributed & Fault-Tolerant Systems Programming · 课时

分布式 Mnesia 与复制

配置 Mnesia 以支持分布式运行，包括在集群中复制数据并实现容错存储。

分布式 Mnesia 与复制 是 CoddyKit 上的免费 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Intro to Distributed Mnesia

Welcome to the final lesson on Mnesia! So far, we've explored Mnesia's fundamentals and how to manage data with transactions. Now, let's unlock its true power: distributed operation.

Distributed Mnesia allows your database to span multiple Erlang nodes, offering incredible benefits for fault tolerance and scalability. Imagine your data staying available even if some servers go down!

Core Concept: Node List

For Mnesia to operate across multiple nodes, it needs to know which nodes are part of its cluster. This is managed through an explicit node list.

Each Mnesia instance on a node is aware of the other nodes.
It uses Erlang's built-in distribution mechanism to communicate.
Data can be replicated to or stored on specific nodes in this list.

Without this configuration, Mnesia would only run locally on a single node.

Initializing a Distributed Database

Setting up a distributed Mnesia cluster involves a few key steps:

Start Erlang Nodes: Launch each Erlang VM with a unique name (e.g., erl -sname node1@host -setcookie mysecret).
Connect Nodes: Ensure all nodes can communicate using net_adm:ping/1.
Create Schema: Use mnesia:create_schema/1 on all participating nodes, passing a list of all node names.
Start Mnesia: Call mnesia:start/0 on each node.

This establishes the foundation for your distributed database.

Code: Basic Mnesia Start

This example shows the basic steps to initialize and start Mnesia. In a real distributed setup, you'd run these on each connected node after creating the schema.

-module(mnesia_starter).
-export([start/0, stop/0, create_schema/0]).

% To run this in a shell:
% erl -sname mynode@localhost -setcookie mysecret
% c(mnesia_starter).
% mnesia_starter:create_schema().
% mnesia_starter:start().

create_schema() ->
    io:format("Creating Mnesia schema on ~p...\n", [node()]),
    % For a multi-node setup, list all node names here:
    % mnesia:create_schema(['node1@host', 'node2@host']).
    mnesia:create_schema([node()]).

start() ->
    io:format("Starting Mnesia on ~p...\n", [node()]),
    mnesia:start().

stop() ->
    io:format("Stopping Mnesia on ~p...\n", [node()]),
    mnesia:stop().

Creating Distributed Tables

Once your Mnesia cluster is set up, you define tables. The key difference for distributed tables is specifying the node_list when creating them.

The node_list attribute determines which nodes will store copies of the table.
You can specify different types of copies (disc_copies, ram_copies, disc_only_copies) for each node.
This allows fine-grained control over data placement and replication.

Mnesia ensures that the table schema is consistent across all nodes in the node_list.

Code: Distributed Table Definition

This example shows how to define a table, specifying that it should have disk copies on specific nodes. In a real scenario, 'node1@host' and 'node2@host' would be actual Erlang node names.

-module(distributed_table_def).
-export([create_user_table/0, start_mnesia/0, stop_mnesia/0]).

create_user_table() ->
    io:format("Attempting to create 'user_info' table...\n"),
    % In a distributed system, this list would contain
    % actual node names, e.g., ['node1@host', 'node2@host'].
    % For this runnable demo, we'll use the current node.
    NodeList = [node()], 

    mnesia:create_table(user_info, [
        {attributes, [id, name, email]},
        {disc_copies, NodeList} % Data stored on these nodes
    ]),
    io:format("Table 'user_info' created (or already exists) \n    with disc_copies on ~p.\n", [NodeList]).

start_mnesia() ->
    mnesia:start().

stop_mnesia() ->
    mnesia:stop().

% To run this:
% 1. Start Erlang shell: erl -sname mynode@localhost -setcookie mysecret
% 2. Compile: c(distributed_table_def).
% 3. Run: distributed_table_def:start_mnesia().
% 4. Run: distributed_table_def:create_user_table().

Replication Types: Disc vs. RAM

Mnesia offers different replication strategies for your table copies:

disc_copies: Data is stored on disk and loaded into RAM on startup. Provides persistence and fault tolerance.
ram_copies: Data is only stored in RAM. Fastest access but data is lost if the node crashes (unless replicated elsewhere).
disc_only_copies: Data is only stored on disk and not loaded into RAM. Slowest access, but uses minimal RAM.

Choosing the right type depends on your persistence, performance, and memory requirements.

Distributed Data Consistency

When you write data to a distributed Mnesia table, Mnesia ensures atomicity across all nodes involved in the transaction. This means:

A transaction either commits successfully on all relevant nodes, or it rolls back on all of them.
Mnesia handles the complexities of two-phase commit protocols behind the scenes.

This guarantees that your data remains consistent, even when spread across a cluster.

Managing Cluster Membership

Erlang's dynamic nature extends to Mnesia clusters. You can add or remove nodes from a running system without downtime.

Use mnesia:change_table_copy_type/3 or mnesia:add_table_copy/2 to add new copies of a table to a node.
Use mnesia:delete_table_copy/2 to remove a copy from a node.

These operations allow you to scale your Mnesia cluster horizontally or perform maintenance.

Fault Tolerance through Replication

This is where distributed Mnesia truly shines! By replicating data across multiple nodes, your system becomes highly fault-tolerant.

If a node with a disc_copies table fails, other nodes with copies can continue serving requests.
Mnesia automatically synchronizes data when a failed node recovers and rejoins the cluster.
You can design your system to withstand multiple node failures based on your replication strategy.

This 'always-on' capability is crucial for critical applications.

Check Your Understanding

Which Mnesia table copy type offers the fastest read/write access but loses data if the node crashes and no other copies exist?

Recap: Distributed Mnesia

Congratulations! You've now learned about configuring and managing distributed Mnesia.

We covered how to set up Mnesia across multiple Erlang nodes.
You saw how to define tables with node_list for distribution.
We explored different replication types: disc_copies, ram_copies, and disc_only_copies.
Finally, you understand how Mnesia ensures consistency and provides fault tolerance through replication.

Mnesia is a powerful tool for building robust, scalable, and fault-tolerant distributed applications in Erlang.

常见问题解答

「分布式 Mnesia 与复制」课时是免费的吗？

是的 — 「分布式 Mnesia 与复制」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课程的其余内容，请升级到 CoddyKit PRO。 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课程共包含 4 节课。

「分布式 Mnesia 与复制」这节课中我会学到什么？

配置 Mnesia 以支持分布式运行，包括在集群中复制数据并实现容错存储。你通过在浏览器中直接运行的动手代码来练习 Erlang OTP: Distributed & Fault-Tolerant Systems Programming，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「分布式 Mnesia 与复制」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课中编写并运行代码吗？

能。每节 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Erlang OTP: Distributed & Fault-Tolerant Systems Programming