Introdução aos supervisores
Descubra como os supervisores reiniciam automaticamente processos que falharam, garantindo tolerância a falhas e alta disponibilidade em seus aplicativos Erlang.
Introdução aos supervisores é uma aula grátis de Erlang OTP: Distributed & Fault-Tolerant Systems Programming no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Erlang OTP: Distributed & Fault-Tolerant Systems Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Erlang OTP: Distributed & Fault-Tolerant Systems Programming inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
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!
Aprenda Erlang com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 12
- Aulas
- 48
Perguntas Frequentes
A aula “Introdução aos supervisores” é grátis?
Sim — o texto completo de “Introdução aos supervisores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Erlang OTP: Distributed & Fault-Tolerant Systems Programming, atualize para CoddyKit PRO. O curso de Erlang OTP: Distributed & Fault-Tolerant Systems Programming inclui 4 aulas no total.
O que vou aprender em “Introdução aos supervisores”?
Descubra como os supervisores reiniciam automaticamente processos que falharam, garantindo tolerância a falhas e alta disponibilidade em seus aplicativos Erlang. Você pratica Erlang OTP: Distributed & Fault-Tolerant Systems Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Erlang OTP: Distributed & Fault-Tolerant Systems Programming?
Nenhuma experiência prévia é necessária. Erlang OTP: Distributed & Fault-Tolerant Systems Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Introdução aos supervisores”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Erlang OTP: Distributed & Fault-Tolerant Systems Programming?
Sim. Cada aula de Erlang OTP: Distributed & Fault-Tolerant Systems Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Compreendendo OTP e comportamentos
- Implementação do comportamento GenServer
- Introdução aos supervisores
- Criar Aplicações e Versões OTP