Erlang OTP: Distributed & Fault-Tolerant Systems Programming · Lekcja

Tworzenie wydań Erlanga

Używaj narzędzi takich jak rebar3 i relx do łączenia aplikacji Erlang, jej zależności oraz środowiska uruchomieniowego Erlanga w samodzielne wydanie.

Tworzenie wydań Erlanga to bezpłatna lekcja Erlang OTP: Distributed & Fault-Tolerant Systems Programming na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Erlang OTP: Distributed & Fault-Tolerant Systems Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Erlang OTP: Distributed & Fault-Tolerant Systems Programming zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

What are Erlang Releases?

When you develop an Erlang application, it's a collection of modules and configuration files. To deploy it, you need to package it all up.

An Erlang Release is a self-contained, deployable package of your application, its dependencies, and optionally, a specific version of the Erlang Runtime System (ERTS).

It's like a standalone executable for your Erlang system.
It simplifies deployment by bundling everything needed to run.

Benefits of a Release

Why go through the effort of creating a release? Releases offer significant advantages for production systems:

Self-contained: Includes all necessary Erlang libraries and even the Erlang VM itself.
Simplified Deployment: Just copy the release folder to a server and start it.
Version Management: Each release has a clear version number, making upgrades and rollbacks easier.
Foundation for Live Upgrades: Releases are essential for Erlang's famous 'hot code loading' feature (covered in a later lesson!).

Meet rebar3

Building Erlang applications and releases manually can be complex. Fortunately, we have rebar3!

rebar3 is the standard build tool for Erlang. It handles:

Project creation and management
Dependency resolution
Compilation
Testing
And, crucially for this lesson, creating releases.

It streamlines the entire development and deployment workflow.

Your Erlang Application Code

Let's start with a very simple Erlang module. In a real application, this would be part of your overall system logic.

For demonstration, we'll create a module with a main/0 function, which can be run directly. This module will be included in our release.

-module(my_release_app).
-export([main/0]).

main() ->
    io:format("Hello from my Erlang release application!~n").

The Application Resource File

Every Erlang application has an application resource file (.app or .app.src). This file defines metadata about your application, such as its version, description, and which modules it depends on.

rebar3 uses the .app.src file to generate the final .app file during the build process.

{application, my_release_app,
 [{description, "My simple release app"},
  {vsn, "0.1.0"},
  {registered, []},
  {applications, [
    kernel,
    stdlib
  ]},
  {mod, {my_release_app, []}},
  {env, []}
 ]}.

Configuring the Release

To tell rebar3 how to build your release, you add a relx section to your rebar.config file. This configuration specifies:

The name and version of your release.
Which applications to include.
If the Erlang Runtime System (ERTS) should be bundled.

For development, we often don't include ERTS to save space.

{apps, [my_release_app]}.

{relx, [{release, {my_release_app, "0.1.0"}, [my_release_app]},
        {dev_mode, true},
        {include_erts, false},
        {extended_start_script, true}]}.

Building Your Release Bundle

With your application code, .app.src, and rebar.config in place, building the release is straightforward. rebar3 will compile your code, fetch dependencies, and package everything into a single directory.

This command does all the heavy lifting:

rebar3 release

Inside the Release Package

After running rebar3 release, you'll find your release in _build/default/rel/my_release_app/. The structure typically includes:

bin/: Contains the start script for your application.
lib/: All your application's compiled code and dependencies.
releases/: Release definitions and version information.
erts/: (Optional) The Erlang Runtime System if include_erts was true.

This organized structure makes deployment predictable and reliable.

Running Your Packaged App

Once built, you can start your Erlang application by executing the generated start script. This script handles starting the Erlang VM and loading your application.

Navigate to the release directory and use the bin/<release_name> script.

For our example, you would run (in a shell, not runnable in this environment):

_build/default/rel/my_release_app/bin/my_release_app start

Release Benefits Check

Creating an Erlang release is a crucial step for deployment. Which of the following are primary benefits of packaging an Erlang application as a release?

Recap: Erlang Releases

You've taken a big step towards deploying Erlang applications!

Erlang Releases package your app, its dependencies, and optionally ERTS.
rebar3 is the essential tool for building and managing releases.
The .app.src and rebar.config files define your application and release.
Releases simplify deployment, versioning, and enable powerful features like live upgrades.

Next, we'll dive into the fascinating world of hot code loading and how to perform live upgrades on running systems!

Często zadawane pytania

Czy lekcja „Tworzenie wydań Erlanga” jest bezpłatna?

Tak — pełny tekst „Tworzenie wydań Erlanga” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Erlang OTP: Distributed & Fault-Tolerant Systems Programming, przejdź na CoddyKit PRO. Kurs Erlang OTP: Distributed & Fault-Tolerant Systems Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Tworzenie wydań Erlanga”?

Używaj narzędzi takich jak rebar3 i relx do łączenia aplikacji Erlang, jej zależności oraz środowiska uruchomieniowego Erlanga w samodzielne wydanie. Ćwiczysz Erlang OTP: Distributed & Fault-Tolerant Systems Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Erlang OTP: Distributed & Fault-Tolerant Systems Programming?

Nie wymagamy żadnego doświadczenia. Erlang OTP: Distributed & Fault-Tolerant Systems Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Tworzenie wydań Erlanga”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Erlang OTP: Distributed & Fault-Tolerant Systems Programming?

Tak. Każda lekcja Erlang OTP: Distributed & Fault-Tolerant Systems Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Erlang OTP: Distributed & Fault-Tolerant Systems Programming