Introduzione ai supervisor
Scopra come i supervisor riavviino automaticamente i processi non riusciti, garantendo tolleranza ai guasti e alta disponibilità nelle applicazioni Erlang
Introduzione ai supervisor è 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.
Meet Erlang Supervisors
In Erlang, processes are designed to crash! But who handles the mess? That's where Supervisors come in.
A supervisor is a special Erlang process whose job is to start, stop, and monitor other processes, called its children.
If a child process crashes, the supervisor automatically restarts it. This makes your applications incredibly resilient and fault-tolerant!
Why Fault Tolerance Matters
Imagine a web server process handling user requests. What happens if it crashes due to an error?
- Without a supervisor, the server stops, and users lose service.
- With a supervisor, the crashed process is detected and restarted instantly, often without users even noticing!
This "let it crash" philosophy, combined with supervisors, is key to Erlang's legendary reliability.
How Supervisors Work
Supervisors are part of Erlang's Open Telecom Platform (OTP) framework. They follow a simple hierarchy:
- A supervisor has a list of child processes it's responsible for.
- Each child is defined by a child specification.
- If a child terminates unexpectedly, the supervisor steps in to restart it according to a defined strategy.
They form "supervision trees" where supervisors can supervise other supervisors.
Defining Child Processes
Before a supervisor can manage a process, it needs to know how to start it. This is done via a child specification.
A child spec is a record (or map) containing details like:
id: A unique name for the child.start: The module, function, and arguments to call to start the process.restart: When and how to restart (e.g.,permanent,temporary).type: Whether it's aworkeror anothersupervisor.
Restart Strategy: One For One
Supervisors use restart strategies to decide what to do when a child crashes. The most common is one_for_one.
With one_for_one:
- If a child process terminates, only that specific child process is restarted.
- Other sibling processes managed by the same supervisor are unaffected.
This strategy is ideal when children are independent and a failure in one doesn't impact the others.
Our First Supervised Worker
Let's create a simple Erlang module that will act as a worker process. It will just start, print a message, and then we'll make it crash.
-module(my_worker).
-behaviour(gen_server).
-export([start_link/0, init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
-export([crash_me/0]).
start_link() ->
gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
init([]) ->
io:format("Worker started!~n", []),
{ok, #{}}.
handle_call(crash, _From, State) ->
io:format("Worker told to crash!~n", []),
exit(reason_for_crash),
{reply, ok, State};
handle_call(_Request, _From, State) ->
{noreply, State}.
handle_cast(_Msg, State) ->
{noreply, State}.
handle_info(_Info, State) ->
{noreply, State}.
terminate(_Reason, _State) ->
io:format("Worker terminating!~n", []).
code_change(_OldVsn, State, _Extra) ->
{ok, State}.
crash_me() ->
gen_server:call(?MODULE, crash).Setting up Our Supervisor
Now, let's create a supervisor module that will manage our my_worker. We'll specify the one_for_one restart strategy.
-module(my_supervisor).
-behaviour(supervisor).
-export([start_link/0, init/1]).
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
init([]) ->
WorkerSpec = #{
id => my_worker,
start => {my_worker, start_link, []},
restart => permanent,
type => worker,
shutdown => 5000,
via => [{local, my_worker}]
},
Children = [WorkerSpec],
Strategy = #{
strategy => one_for_one,
intensity => 10,
period => 1
},
{ok, {Strategy, Children}}.Launching the Application
To see our supervisor in action, we need to start it. We can do this directly from the Erlang shell or a main application module.
Here's how to start it and check its children:
-module(app_starter).
-export([start/0, stop/0]).
start() ->
my_supervisor:start_link(),
io:format("Supervisor started. Worker should be running.~n", []).
stop() ->
supervisor:stop(my_supervisor),
io:format("Supervisor stopped.~n", []).
% To run this in the shell:
% 1. Compile: c(my_worker), c(my_supervisor), c(app_starter).
% 2. Start: app_starter:start().
% 3. Crash: my_worker:crash_me().
% 4. Observe restarts!Witnessing Fault Tolerance
After compiling and running app_starter:start()., you should see "Worker started!". Now, call my_worker:crash_me(). in the shell.
What happens?
- The worker process will terminate ("Worker terminating!").
- The supervisor detects the crash and restarts the worker.
- You'll see "Worker started!" again, demonstrating automatic recovery!
This shows the power of supervisors in keeping your system running even when individual components fail.
Supervisor Check-up
Which of the following statements correctly describe the purpose or behavior of an Erlang supervisor with a one_for_one restart strategy?
Supervisors: Your Reliability Hero
Great job! You've learned the fundamentals of Erlang supervisors:
- They are special processes that monitor and restart child processes.
- They ensure fault tolerance and high availability by automatically recovering from crashes.
- Child specifications define how supervisors manage their children.
- The
one_for_onestrategy restarts only the failed child.
Supervisors are a cornerstone of robust Erlang/OTP applications. Next, we'll explore more advanced restart strategies!
Domande Frequenti
La lezione «Introduzione ai supervisor» è gratuita?
Sì — il testo completo di «Introduzione ai supervisor» è 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 «Introduzione ai supervisor»?
Scopra come i supervisor riavviino automaticamente i processi non riusciti, garantendo tolleranza ai guasti e alta disponibilità nelle applicazioni Erlang 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 «Introduzione ai supervisor»?
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
- Comprendere OTP e i behavior
- Implementazione del behavior GenServer
- Introduzione ai supervisor
- Costruire applicazioni e release OTP