Mnesia distribuita e replica
Configuri Mnesia per il funzionamento distribuito, inclusi la replica dei dati e l’archiviazione tollerante ai guasti in un cluster
Mnesia distribuita e replica è una lezione Erlang OTP: Distributed & Fault-Tolerant Systems Programming gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Erlang OTP: Distributed & Fault-Tolerant Systems Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Erlang OTP: Distributed & Fault-Tolerant Systems Programming include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
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/1on all participating nodes, passing a list of all node names. - Start Mnesia: Call
mnesia:start/0on 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_listattribute 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/3ormnesia:add_table_copy/2to add new copies of a table to a node. - Use
mnesia:delete_table_copy/2to 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_copiestable 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_listfor distribution. - We explored different replication types:
disc_copies,ram_copies, anddisc_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.
Domande Frequenti
La lezione «Mnesia distribuita e replica» è gratuita?
Sì — il testo completo di «Mnesia distribuita e replica» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Erlang OTP: Distributed & Fault-Tolerant Systems Programming, passa a CoddyKit PRO. Il corso Erlang OTP: Distributed & Fault-Tolerant Systems Programming include 4 lezioni in totale.
Cosa imparerò in «Mnesia distribuita e replica»?
Configuri Mnesia per il funzionamento distribuito, inclusi la replica dei dati e l’archiviazione tollerante ai guasti in un cluster Eserciti Erlang OTP: Distributed & Fault-Tolerant Systems Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Erlang OTP: Distributed & Fault-Tolerant Systems Programming?
Non è richiesta alcuna esperienza precedente. Erlang OTP: Distributed & Fault-Tolerant Systems Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Mnesia distribuita e replica»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Erlang OTP: Distributed & Fault-Tolerant Systems Programming?
Sì. Ogni lezione Erlang OTP: Distributed & Fault-Tolerant Systems Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Fondamenti e schema di Mnesia
- Transazioni e manipolazione dei dati
- Mnesia distribuita e replica
- Indicizzazione di Mnesia e ottimizzazione delle query