Supervisor入門
Supervisorが失敗したプロセスを自動的に再起動し、Erlangアプリケーションの耐障害性と高可用性を確保する仕組みを学びます。
「Supervisor入門」はCoddyKit上の無料Erlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンです。 これはレッスン3/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはErlang OTP: Distributed & Fault-Tolerant Systems Programming学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースには全4レッスンが含まれています。
このレッスンの一部はまだ翻訳されておらず、英語で表示されています。
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!
AI チューターと学ぶ Erlang — 無料
ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。
- コース
- 12
- レッスン
- 48
よくある質問
「Supervisor入門」レッスンは無料ですか？
はい。「Supervisor入門」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースには全4レッスンが含まれています。
「Supervisor入門」で何を学びますか？
Supervisorが失敗したプロセスを自動的に再起動し、Erlangアプリケーションの耐障害性と高可用性を確保する仕組みを学びます。 ブラウザで直接実行するハンズオンコードでErlang OTP: Distributed & Fault-Tolerant Systems Programmingを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。
Erlang OTP: Distributed & Fault-Tolerant Systems Programmingを始めるのに経験は必要ですか？
事前経験は必要ありません。CoddyKitのErlang OTP: Distributed & Fault-Tolerant Systems Programmingは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン3/4です。
「Supervisor入門」レッスンにはどのくらい時間がかかりますか？
ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。
このErlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンでコードを書いて実行できますか？
はい。すべてのErlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。