Elixir และ Phoenix Framework คืออะไร? สอนสร้าง Real-time Web App ด้วย Erlang VM 2026

ในโลกของการพัฒนา Web Application ที่ต้องการรองรับผู้ใช้งานจำนวนมากแบบ Real-time ไม่ว่าจะเป็นระบบ Chat, Live Dashboard หรือ Multiplayer Game มีเทคโนโลยีหนึ่งที่โดดเด่นอย่างมากคือ Elixir ร่วมกับ Phoenix Framework ซึ่งทำงานบน Erlang VM (BEAM) ที่ได้รับการพิสูจน์มากว่า 30 ปีในระบบ Telecom ที่ต้องการ Uptime สูงมาก

บทความนี้จะพาคุณทำความรู้จัก Elixir ตั้งแต่พื้นฐานไปจนถึงการสร้าง Real-time Web App ด้วย Phoenix Framework ครอบคลุม OTP, LiveView, Ecto และ Deployment สำหรับปี 2026 โดยเฉพาะ หากคุณสนใจเรื่อง การจัดการ API Versioning สำหรับ Backend ก็สามารถอ่านบทความแนะนำเพิ่มเติมได้

อ่านเพิ่ม: Rust สำหรับ Backend สอน Axum และ Actix-web สร้าง API ที่เร็ว · อ่านเพิ่ม: WebAssembly (Wasm) คืออะไร? เปิดโลก High-Performance Web App · อ่านเพิ่ม: Edge Computing คืออะไร? สอนสร้าง Edge Application ด้วย Cloud

Elixir คืออะไร?

Elixir และ Phoenix Framework คืออะไร? สอนสร้าง Real-time Web App ด้วย Erlang VM 2026

Elixir เป็นภาษาโปรแกรมมิ่งแบบ Functional ที่สร้างโดย Jose Valim ในปี 2012 โดย Valim เป็นอดีต Core Contributor ของ Ruby on Rails ที่ต้องการแก้ปัญหา Concurrency และ Scalability ที่ Ruby มีข้อจำกัด เขาจึงสร้าง Elixir ให้มี Syntax ที่สวยงามคล้าย Ruby แต่ทำงานบน BEAM VM (Erlang Virtual Machine) ที่มีความแข็งแกร่งระดับ Telecom

Elixir ถูกออกแบบมาเพื่อสร้าง Distributed, Fault-tolerant Application ที่สามารถรองรับ Connection พร้อมกันได้หลายล้าน Connection โดยใช้ทรัพยากรน้อย ทำให้บริษัทขนาดใหญ่อย่าง Discord, Pinterest และ Bleacher Report เลือกใช้ Elixir ในระบบ Production ของตน

ทำไมต้อง Elixir?

Concurrency ระดับสูง: รองรับ Process นับล้านพร้อมกันบน BEAM VM
Fault Tolerance: ระบบ Supervisor ช่วย Restart Process ที่ล้มเหลวอัตโนมัติ
Scalability: กระจายงานข้ามหลาย Node ได้ง่ายด้วย Distribution ในตัว
Syntax สวยงาม: ได้แรงบันดาลใจจาก Ruby ทำให้อ่านง่ายและเขียนสนุก
Ecosystem แข็งแกร่ง: Phoenix Framework, Ecto, Nerves สำหรับ IoT
Hot Code Swapping: อัปเดต Code ได้โดยไม่ต้องหยุดระบบ

Erlang VM (BEAM) — หัวใจของ Elixir

BEAM (Bogdan/Bjorn's Erlang Abstract Machine) คือ Virtual Machine ที่ Erlang และ Elixir ทำงานอยู่ สร้างโดย Ericsson ตั้งแต่ปี 1986 สำหรับระบบ Telecom ที่ต้องการ Uptime 99.9999999% (nine nines) หรือหยุดทำงานไม่เกิน 31 มิลลิวินาทีต่อปี

เนื้อหาเกี่ยวข้อง — Java Micronaut Remote Work Setup

คุณสมบัติเด่นของ BEAM

Lightweight Processes: แต่ละ Process ใช้ Memory เพียง 2-3 KB (เทียบกับ OS Thread ที่ใช้ 1-2 MB) ทำให้สร้าง Process ได้หลายล้านตัวบนเครื่องเดียว
Preemptive Scheduling: BEAM จัดการ Schedule Process เองอัตโนมัติ ไม่มี Process ไหนผูกขาด CPU ได้
Garbage Collection แบบ Per-Process: GC ทำทีละ Process ไม่กระทบ Process อื่น ทำให้ไม่มี Stop-the-world GC
Distribution: เชื่อมต่อหลาย BEAM Node เข้าด้วยกันได้ง่าย ส่ง Message ข้าม Node เหมือนส่งภายใน Node เดียวกัน
Hot Code Loading: โหลด Code เวอร์ชันใหม่ได้โดยไม่ต้อง Restart ระบบ

รู้หรือไม่: WhatsApp เคยรองรับผู้ใช้กว่า 2 ล้าน Connection พร้อมกันบนเซิร์ฟเวอร์เดียวด้วย Erlang/BEAM ก่อนที่จะถูก Facebook ซื้อกิจการ

Elixir พื้นฐาน — Syntax และ Concept สำคัญ

การติดตั้ง Elixir

# macOS

brew install elixir



# Ubuntu/Debian

sudo apt install elixir erlang



# Windows — ดาวน์โหลดจาก elixir-lang.org



# ตรวจสอบเวอร์ชัน

elixir --version

iex  # Interactive Elixir Shell

ตัวแปรและ Data Types

# Elixir เป็นภาษา Dynamic Typing

name = "SiamCafe"          # String

age = 10                   # Integer

pi = 3.14                  # Float

active = true              # Boolean

status = :ok               # Atom (คล้าย Symbol ใน Ruby)



# Collections

list = [1, 2, 3, 4, 5]            # List (Linked List)

tuple = {:ok, "success", 200}     # Tuple (Fixed-size)

map = %{name: "Bom", lang: "Elixir"}  # Map (Key-Value)

keyword = [host: "localhost", port: 4000]  # Keyword List

Pattern Matching — หัวใจของ Elixir

ใน Elixir เครื่องหมาย = ไม่ใช่ Assignment แต่เป็น Pattern Matching ซึ่งเป็น Concept ที่ทรงพลังมาก

# Pattern Matching พื้นฐาน

{:ok, result} = {:ok, "Hello"}     # result = "Hello"

{:error, msg} = {:error, "Not found"}  # msg = "Not found"



# Destructuring List

[head | tail] = [1, 2, 3, 4]       # head = 1, tail = [2, 3, 4]

[a, b | rest] = [10, 20, 30, 40]   # a = 10, b = 20, rest = [30, 40]



# Pattern Matching ใน Function

defmodule Greeter do

  def hello("Admin"), do: "Welcome back, Admin!"

  def hello(name), do: "Hello, #{name}!"

  def hello(_), do: "Hello, stranger!"

end



Greeter.hello("Admin")   # "Welcome back, Admin!"

Greeter.hello("Bom")     # "Hello, Bom!"



# Guard Clauses

defmodule Math do

  def classify(n) when n > 0, do: :positive

  def classify(0), do: :zero

  def classify(n) when n < 0, do: :negative

end

Pipe Operator — |>

Pipe Operator เป็นฟีเจอร์ที่ทำให้ Elixir อ่านง่ายมาก โดยส่งผลลัพธ์ของฟังก์ชันก่อนหน้าเป็น Argument แรกของฟังก์ชันถัดไป

แนะนำเพิ่มเติม — คู่มือเทรดจาก SiamCafeBook

# แบบไม่ใช้ Pipe (อ่านยาก)

String.upcase(String.trim(String.replace("  hello world  ", " ", "-")))



# แบบใช้ Pipe (อ่านง่ายมาก)

"  hello world  "

|> String.replace(" ", "-")

|> String.trim()

|> String.upcase()

# ผลลัพธ์: "HELLO-WORLD"



# ใช้ Pipe กับ Enum

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

|> Enum.filter(fn x -> rem(x, 2) == 0 end)

|> Enum.map(fn x -> x * x end)

|> Enum.sum()

# ผลลัพธ์: 4 + 16 + 36 + 64 + 100 = 220

Immutability

ทุกอย่างใน Elixir เป็น Immutable คือข้อมูลที่สร้างแล้วจะไม่ถูกเปลี่ยนแปลง เมื่อ "แก้ไข" จะได้ข้อมูลชุดใหม่ สิ่งนี้ทำให้ Concurrent Programming ปลอดภัยมาก เพราะไม่มี Shared Mutable State

original = [1, 2, 3]

new_list = [0 | original]  # [0, 1, 2, 3] — original ไม่เปลี่ยน



map = %{a: 1, b: 2}

updated = %{map | a: 10}    # %{a: 10, b: 2} — map เดิมไม่เปลี่ยน

Phoenix Framework — Web Framework สำหรับ Elixir

Phoenix Framework เป็น Web Framework สำหรับ Elixir ที่สร้างโดย Chris McCord ในปี 2014 ได้แรงบันดาลใจจาก Ruby on Rails แต่มีประสิทธิภาพสูงกว่ามากเนื่องจากทำงานบน BEAM VM โดย Phoenix สามารถรองรับ WebSocket Connection ได้กว่า 2 ล้าน Connection พร้อมกันบนเซิร์ฟเวอร์เดียว

สร้างโปรเจกต์ Phoenix

# ติดตั้ง Phoenix Generator

mix archive.install hex phx_new



# สร้างโปรเจกต์ใหม่

mix phx.new my_app

cd my_app



# ตั้งค่า Database

mix ecto.create



# เริ่ม Development Server

mix phx.server

# เปิด http://localhost:4000

โครงสร้างโปรเจกต์ Phoenix

my_app/

├── lib/

│   ├── my_app/            # Business Logic (Context)

│   │   ├── accounts.ex    # Accounts Context

│   │   └── accounts/

│   │       └── user.ex    # User Schema

│   ├── my_app_web/        # Web Layer

│   │   ├── controllers/   # Controllers

│   │   ├── live/          # LiveView modules

│   │   ├── components/    # Reusable Components

│   │   ├── router.ex      # Routes

│   │   └── endpoint.ex    # HTTP Endpoint

│   └── my_app_web.ex

├── priv/

│   ├── repo/migrations/   # Database Migrations

│   └── static/            # Static Assets

├── test/                  # Tests

├── config/                # Configuration

└── mix.exs                # Project Definition

Router และ Controller

# lib/my_app_web/router.ex

defmodule MyAppWeb.Router do

  use MyAppWeb, :router



  pipeline :browser do

    plug :accepts, ["html"]

    plug :fetch_session

    plug :put_root_layout, html: {MyAppWeb.Layouts, :root}

    plug :protect_from_forgery

    plug :put_secure_browser_headers

  end



  pipeline :api do

    plug :accepts, ["json"]

  end



  scope "/", MyAppWeb do

    pipe_through :browser

    get "/", PageController, :home

    resources "/users", UserController

    live "/dashboard", DashboardLive

  end



  scope "/api", MyAppWeb.API do

    pipe_through :api

    resources "/posts", PostController, except: [:new, :edit]

  end

end



# lib/my_app_web/controllers/user_controller.ex

defmodule MyAppWeb.UserController do

  use MyAppWeb, :controller

  alias MyApp.Accounts



  def index(conn, _params) do

    users = Accounts.list_users()

    render(conn, :index, users: users)

  end



  def show(conn, %{"id" => id}) do

    user = Accounts.get_user!(id)

    render(conn, :show, user: user)

  end



  def create(conn, %{"user" => user_params}) do

    case Accounts.create_user(user_params) do

      {:ok, user} ->

        conn

        |> put_flash(:info, "User created successfully.")

        |> redirect(to: ~p"/users/#{user}")

      {:error, changeset} ->

        render(conn, :new, changeset: changeset)

    end

  end

end

Phoenix LiveView — Real-time UI โดยไม่ต้องเขียน JavaScript

Phoenix LiveView เป็นฟีเจอร์ที่ทำให้ Phoenix โดดเด่นที่สุดในปี 2026 โดย LiveView ช่วยให้สร้าง Rich Interactive UI ที่อัปเดตแบบ Real-time ผ่าน WebSocket โดยไม่ต้องเขียน JavaScript เลย ทุกอย่างเป็น Server-side Rendering ที่ส่งเฉพาะส่วนที่เปลี่ยนแปลงผ่าน WebSocket ไปยัง Client

เนื้อหาเกี่ยวข้อง — บทความที่เกี่ยวข้อง: EVPN Fabric Developer Experience DX

ตัวอย่าง LiveView: Real-time Counter

# lib/my_app_web/live/counter_live.ex

defmodule MyAppWeb.CounterLive do

  use MyAppWeb, :live_view



  def mount(_params, _session, socket) do

    {:ok, assign(socket, count: 0)}

  end



  def handle_event("increment", _params, socket) do

    {:noreply, update(socket, :count, &(&1 + 1))}

  end



  def handle_event("decrement", _params, socket) do

    {:noreply, update(socket, :count, &(&1 - 1))}

  end



  def render(assigns) do

    ~H"""

    <div class="counter">

      <h1>Count: <%= @count %></h1>

      <button phx-click="decrement">-</button>

      <button phx-click="increment">+</button>

    </div>

    """

  end

end

ตัวอย่าง LiveView: Real-time Search

defmodule MyAppWeb.SearchLive do

  use MyAppWeb, :live_view

  alias MyApp.Products



  def mount(_params, _session, socket) do

    {:ok, assign(socket, query: "", results: [])}

  end



  def handle_event("search", %{"query" => query}, socket) do

    results = Products.search(query)

    {:noreply, assign(socket, query: query, results: results)}

  end



  def render(assigns) do

    ~H"""

    <form phx-change="search" phx-debounce="300">

      <input type="text" name="query" value={@query}

             placeholder="ค้นหาสินค้า..." />

    </form>

    <ul>

      <li :for={product <- @results}>

        <%= product.name %> - <%= product.price %> บาท

      </li>

    </ul>

    """

  end

end

ข้อดีของ LiveView: ลด Complexity ของ Frontend ได้มาก ไม่ต้องสร้าง REST API แยก ไม่ต้องจัดการ State ทั้งฝั่ง Client และ Server แยกกัน ทุกอย่างอยู่ใน Elixir Module เดียว

Phoenix Channels — WebSocket สำหรับ Real-time Communication

Channels เป็นระบบ WebSocket ใน Phoenix ที่ใช้สำหรับ Real-time Communication ระหว่าง Client และ Server เหมาะสำหรับ Chat, Notifications และ Live Updates

# lib/my_app_web/channels/room_channel.ex

defmodule MyAppWeb.RoomChannel do

  use MyAppWeb, :channel



  def join("room:" <> room_id, _params, socket) do

    {:ok, assign(socket, :room_id, room_id)}

  end



  def handle_in("new_msg", %{"body" => body}, socket) do

    broadcast!(socket, "new_msg", %{body: body, user: socket.assigns.user})

    {:noreply, socket}

  end



  def handle_in("typing", _params, socket) do

    broadcast_from!(socket, "typing", %{user: socket.assigns.user})

    {:noreply, socket}

  end

end

Ecto — Database Layer สำหรับ Elixir

Ecto เป็น Database Wrapper และ Query Generator สำหรับ Elixir ไม่ใช่ ORM แบบดั้งเดิม แต่เป็น Data Mapping Library ที่เน้น Explicit และ Composable Queries สนับสนุน PostgreSQL, MySQL, SQLite และ Database อื่นๆ

Schema และ Changeset

# lib/my_app/accounts/user.ex

defmodule MyApp.Accounts.User do

  use Ecto.Schema

  import Ecto.Changeset



  schema "users" do

    field :name, :string

    field :email, :string

    field :age, :integer

    field :role, :string, default: "user"

    has_many :posts, MyApp.Blog.Post

    timestamps()

  end



  def changeset(user, attrs) do

    user

    |> cast(attrs, [:name, :email, :age, :role])

    |> validate_required([:name, :email])

    |> validate_format(:email, ~r/@/)

    |> validate_inclusion(:role, ["user", "admin", "moderator"])

    |> validate_number(:age, greater_than: 0, less_than: 150)

    |> unique_constraint(:email)

  end

end

Changeset เป็น Concept ที่ทรงพลังมากใน Ecto ทำหน้าที่ Validate และ Track การเปลี่ยนแปลงของข้อมูลก่อนบันทึกลง Database ทำให้เราสามารถตรวจสอบข้อมูลได้อย่างละเอียดก่อนที่จะ Insert หรือ Update จริง

แนะนำเพิ่มเติม — บทวิเคราะห์จาก XM Signal

Migration

# สร้าง Migration

mix ecto.gen.migration create_users



# priv/repo/migrations/20260410_create_users.exs

defmodule MyApp.Repo.Migrations.CreateUsers do

  use Ecto.Migration



  def change do

    create table(:users) do

      add :name, :string, null: false

      add :email, :string, null: false

      add :age, :integer

      add :role, :string, default: "user"

      timestamps()

    end



    create unique_index(:users, [:email])

    create index(:users, [:role])

  end

end



# รัน Migration

mix ecto.migrate

Query

import Ecto.Query



# Query พื้นฐาน

users = Repo.all(User)

user = Repo.get!(User, 1)

user = Repo.get_by!(User, email: "bom@example.com")



# Composable Queries

query =

  from u in User,

    where: u.age > 18,

    where: u.role == "admin",

    order_by: [desc: u.inserted_at],

    limit: 10,

    select: %{name: u.name, email: u.email}



admins = Repo.all(query)



# Dynamic Query Building

defmodule MyApp.Accounts do

  def list_users(filters \\ %{}) do

    User

    |> filter_by_role(filters["role"])

    |> filter_by_age(filters["min_age"])

    |> Repo.all()

  end



  defp filter_by_role(query, nil), do: query

  defp filter_by_role(query, role) do

    from u in query, where: u.role == ^role

  end



  defp filter_by_age(query, nil), do: query

  defp filter_by_age(query, min_age) do

    from u in query, where: u.age >= ^min_age

  end

end

OTP — Open Telecom Platform

OTP (Open Telecom Platform) เป็นชุดเครื่องมือและ Design Pattern จาก Erlang ที่ Elixir สืบทอดมา ประกอบด้วย Behaviour สำเร็จรูปสำหรับสร้าง Concurrent และ Fault-tolerant Application

GenServer — Generic Server

GenServer เป็น Behaviour พื้นฐานที่สุดใน OTP ใช้สำหรับสร้าง Process ที่มี State และรับ-ส่ง Message ได้

เนื้อหาเกี่ยวข้อง — บทความที่เกี่ยวข้อง: Talos Linux IoT Gateway

defmodule MyApp.Cache do

  use GenServer



  # Client API

  def start_link(opts \\ []) do

    GenServer.start_link(__MODULE__, %{}, name: __MODULE__)

  end



  def get(key) do

    GenServer.call(__MODULE__, {:get, key})

  end



  def put(key, value) do

    GenServer.cast(__MODULE__, {:put, key, value})

  end



  # Server Callbacks

  @impl true

  def init(state) do

    {:ok, state}

  end



  @impl true

  def handle_call({:get, key}, _from, state) do

    {:reply, Map.get(state, key), state}

  end



  @impl true

  def handle_cast({:put, key, value}, state) do

    {:noreply, Map.put(state, key, value)}

  end

end



# การใช้งาน

MyApp.Cache.put("user:1", %{name: "Bom"})

MyApp.Cache.get("user:1")  # %{name: "Bom"}

Supervisor — ผู้ดูแล Process

Supervisor ทำหน้าที่ดูแล Process ลูก (Child Process) เมื่อ Process ลูกตัวใดล้มเหลว Supervisor จะ Restart ให้อัตโนมัติตาม Strategy ที่กำหนด

defmodule MyApp.Application do

  use Application



  def start(_type, _args) do

    children = [

      MyApp.Repo,                    # Database

      MyAppWeb.Endpoint,             # Web Server

      MyApp.Cache,                   # Custom Cache

      {MyApp.Worker, [interval: 5000]},  # Background Worker

      {Task.Supervisor, name: MyApp.TaskSupervisor}

    ]



    opts = [strategy: :one_for_one, name: MyApp.Supervisor]

    Supervisor.start_link(children, opts)

  end

end



# Supervisor Strategies:

# :one_for_one  — Restart เฉพาะ Process ที่ล้มเหลว

# :one_for_all  — Restart ทุก Process เมื่อมี 1 ตัวล้มเหลว

# :rest_for_one — Restart Process ที่ล้มเหลวและทุกตัวที่เริ่มหลังจากมัน

Concurrency Model — Process และ Message Passing

Elixir ใช้ Actor Model สำหรับ Concurrency โดยแต่ละ Process เป็นหน่วยอิสระที่มี State ของตัวเอง สื่อสารกันผ่าน Message Passing ไม่มี Shared Memory ทำให้ปลอดภัยจาก Race Condition

# สร้าง Process

pid = spawn(fn ->

  receive do

    {:hello, name} -> IO.puts("Hello, #{name}!")

    {:bye, name} -> IO.puts("Goodbye, #{name}!")

  end

end)



# ส่ง Message

send(pid, {:hello, "Bom"})  # พิมพ์ "Hello, Bom!"



# Task — Async/Await Pattern

task = Task.async(fn ->

  # งานที่ใช้เวลานาน

  :timer.sleep(2000)

  fetch_data_from_api()

end)



result = Task.await(task, 5000)  # รอผลลัพธ์ (timeout 5 วินาที)



# Task.async_stream — ประมวลผลขนานหลายรายการ

urls = ["https://api1.com", "https://api2.com", "https://api3.com"]



results =

  urls

  |> Task.async_stream(fn url -> HTTPoison.get!(url) end, max_concurrency: 10)

  |> Enum.map(fn {:ok, result} -> result end)

Elixir Process ไม่ใช่ OS Process: Process ใน Elixir เป็น Lightweight Process ที่จัดการโดย BEAM VM ใช้ Memory เพียง 2-3 KB ต่อ Process สามารถสร้างได้หลายล้านตัวบนเครื่องเดียว ต่างจาก OS Process หรือ Thread ที่หนักกว่ามาก

Deployment — การ Deploy Elixir Application

Elixir Releases

Elixir Release เป็นวิธีสร้าง Self-contained Package ที่รวม Erlang Runtime ไว้ด้วย ทำให้ Deploy ได้โดยไม่ต้องติดตั้ง Elixir/Erlang บนเซิร์ฟเวอร์ปลายทาง

# สร้าง Release

MIX_ENV=prod mix release



# รัน Release

_build/prod/rel/my_app/bin/my_app start    # เริ่มทำงาน

_build/prod/rel/my_app/bin/my_app stop     # หยุด

_build/prod/rel/my_app/bin/my_app restart  # Restart

_build/prod/rel/my_app/bin/my_app remote   # เชื่อมต่อ Console

Docker สำหรับ Phoenix

# Dockerfile

FROM elixir:1.17-alpine AS build

RUN apk add --no-cache build-base git

WORKDIR /app

ENV MIX_ENV=prod



COPY mix.exs mix.lock ./

RUN mix deps.get --only prod

RUN mix deps.compile



COPY lib lib

COPY priv priv

COPY config config

COPY assets assets



RUN mix assets.deploy

RUN mix compile

RUN mix release



# Runtime Stage

FROM alpine:3.19 AS app

RUN apk add --no-cache libstdc++ openssl ncurses-libs

WORKDIR /app

COPY --from=build /app/_build/prod/rel/my_app ./



ENV PHX_HOST=example.com

ENV PORT=4000

EXPOSE 4000



CMD ["bin/my_app", "start"]

Elixir vs Go vs Node.js สำหรับ Real-time App

คุณสมบัติ	Elixir/Phoenix	Go	Node.js
Concurrency Model	BEAM Processes (Actor)	Goroutines (CSP)	Event Loop + Workers
WebSocket Support	Phoenix Channels (Built-in)	ต้องใช้ Library	Socket.IO / ws
Fault Tolerance	OTP Supervisor (Built-in)	ต้องจัดการเอง	PM2 / Cluster
Real-time UI	LiveView (ไม่ต้องเขียน JS)	ไม่มี Built-in	ต้องใช้ React/Vue
Hot Code Reload	รองรับ (BEAM Feature)	ไม่รองรับ	ไม่รองรับ (ต้อง Restart)
Learning Curve	ปานกลาง (FP Concepts)	ต่ำ	ต่ำ
Ecosystem	เล็กแต่คุณภาพสูง	ใหญ่	ใหญ่มาก
Use Case หลัก	Real-time, Chat, IoT	Microservices, CLI	Web App, API

Nerves — Elixir สำหรับ IoT

Nerves เป็น Framework ที่ช่วยให้เขียนซอฟต์แวร์สำหรับ Embedded Device (เช่น Raspberry Pi) ด้วย Elixir โดยสร้าง Firmware Image ที่มี Linux Kernel + BEAM VM + Application ของคุณ ขนาดเพียง 30-40 MB

# สร้างโปรเจกต์ Nerves

mix nerves.new my_iot_device --target rpi4

cd my_iot_device



# Build Firmware

export MIX_TARGET=rpi4

mix deps.get

mix firmware



# Flash ลง SD Card

mix burn



# หรือ OTA Update

mix firmware

mix upload nerves-device.local

Nerves รวม Elixir เข้ากับ IoT ได้อย่างลงตัว เพราะ BEAM VM มี Fault Tolerance ในตัว ถ้า Process ใดล้มเหลว Supervisor จะ Restart ให้อัตโนมัติ เหมาะกับ IoT Device ที่ต้องทำงาน 24 ชั่วโมงโดยไม่มีคน Monitor ตลอดเวลา

เนื้อหาเกี่ยวข้อง — ทำความเข้าใจ Nebula Overlay Network Architecture Design Pattern — คู่มือฉบับสมบูรณ์ 2026

บริษัทที่ใช้ Elixir ในระบบ Production

Discord: รองรับผู้ใช้กว่า 150 ล้านคน ใช้ Elixir สำหรับระบบ Real-time Messaging โดยแต่ละ Guild (Server) เป็น GenServer Process ที่จัดการ State ของ Chat Room
Pinterest: ใช้ Elixir สำหรับ API Service ที่รับ Request หลายหมื่น Request ต่อวินาที ลด Server จาก 200 เครื่องเหลือ 20 เครื่อง
Bleacher Report: เปลี่ยนจาก Ruby on Rails มาเป็น Elixir/Phoenix ลด Server จาก 150 เครื่องเหลือ 5 เครื่อง
PepsiCo: ใช้ Elixir สำหรับ eCommerce Platform ที่รองรับ Traffic สูงในช่วง Super Bowl
Brex: FinTech Startup มูลค่ากว่า 12 พันล้านดอลลาร์ ใช้ Elixir เป็นภาษาหลัก
Fly.io: Platform สำหรับ Deploy Application ทั่วโลก สร้างด้วย Elixir ทั้งหมด

เส้นทางการเรียนรู้ Elixir และ Phoenix

ขั้นที่ 1: พื้นฐาน Elixir

เรียนรู้ Syntax พื้นฐาน: ตัวแปร, Data Types, Functions
เข้าใจ Pattern Matching และ Pipe Operator
ฝึกใช้ Enum, Stream และ Recursion
เข้าใจ Immutability และ Functional Programming

ขั้นที่ 2: Phoenix Framework

สร้างโปรเจกต์ Phoenix แรก
เรียนรู้ Router, Controller, View
ใช้ Ecto สำหรับ Database (Schema, Changeset, Migration)
สร้าง CRUD Application

ขั้นที่ 3: Real-time และ OTP

เรียนรู้ Phoenix LiveView
ใช้ Phoenix Channels สำหรับ WebSocket
เข้าใจ GenServer และ Supervisor
สร้าง Real-time Chat หรือ Dashboard

ขั้นที่ 4: Production

เรียนรู้ Testing (ExUnit)
Deployment ด้วย Release และ Docker
ศึกษา Telemetry สำหรับ Monitoring
เรียนรู้ Distribution และ Clustering

แหล่งเรียนรู้แนะนำ

Elixir School (elixirschool.com): บทเรียนออนไลน์ฟรี ครอบคลุมทุกหัวข้อ
Programming Elixir (Dave Thomas): หนังสือสำหรับ Programmer ที่มีประสบการณ์
Programming Phoenix LiveView (Bruce Tate): เจาะลึก LiveView
Elixir Forum (elixirforum.com): ชุมชนที่ Active และเป็นมิตรมาก
Exercism Elixir Track: แบบฝึกหัดเขียน Code สำหรับฝึกฝน

สรุป

Elixir และ Phoenix Framework เป็นตัวเลือกที่ยอดเยี่ยมสำหรับการสร้าง Real-time Web Application ในปี 2026 ด้วยพลังของ BEAM VM ที่ผ่านการพิสูจน์มากว่า 30 ปี ทำให้ได้ระบบที่ Concurrent, Fault-tolerant และ Scalable อย่างแท้จริง โดยเฉพาะ Phoenix LiveView ที่ช่วยลด Complexity ของ Frontend ได้อย่างมาก ไม่ต้องเขียน JavaScript Framework แยกสำหรับ Real-time UI

แม้ Ecosystem จะเล็กกว่า Node.js หรือ Go แต่คุณภาพของ Library และชุมชนนั้นยอดเยี่ยม บริษัทใหญ่อย่าง Discord และ Pinterest ที่เลือกใช้ Elixir ก็พิสูจน์แล้วว่าภาษานี้พร้อมสำหรับ Production ระดับ Scale ใหญ่ หากคุณกำลังมองหา Technology ใหม่ที่จะเปลี่ยนวิธีคิดเกี่ยวกับ Web Development ลอง Elixir และ Phoenix Framework ดู แล้วคุณจะประทับใจในพลังของ Functional Programming บน BEAM VM

สำหรับผู้ที่ต้องการเรียนรู้เรื่อง Backend เพิ่มเติม แนะนำให้อ่านบทความ กลยุทธ์จัดการ API Versioning ที่จะช่วยให้คุณออกแบบ API ที่ดีขึ้น รวมถึงบทความ Zig Programming Language สำหรับอีกมุมมองของ Systems Programming

Elixir และ Phoenix Framework คืออะไร? สอนสร้าง Real-time Web App ด้วย Erlang VM 2026

Elixir คืออะไร?

ทำไมต้อง Elixir?

Erlang VM (BEAM) — หัวใจของ Elixir

คุณสมบัติเด่นของ BEAM

Elixir พื้นฐาน — Syntax และ Concept สำคัญ

การติดตั้ง Elixir

ตัวแปรและ Data Types

Pattern Matching — หัวใจของ Elixir

Pipe Operator — |>

Immutability

Phoenix Framework — Web Framework สำหรับ Elixir

สร้างโปรเจกต์ Phoenix

โครงสร้างโปรเจกต์ Phoenix

Router และ Controller

Phoenix LiveView — Real-time UI โดยไม่ต้องเขียน JavaScript

ตัวอย่าง LiveView: Real-time Counter

ตัวอย่าง LiveView: Real-time Search

Phoenix Channels — WebSocket สำหรับ Real-time Communication

Ecto — Database Layer สำหรับ Elixir

Schema และ Changeset

Migration

Query

OTP — Open Telecom Platform

GenServer — Generic Server

Supervisor — ผู้ดูแล Process

Concurrency Model — Process และ Message Passing

Deployment — การ Deploy Elixir Application

Elixir Releases

Docker สำหรับ Phoenix

Elixir vs Go vs Node.js สำหรับ Real-time App

Nerves — Elixir สำหรับ IoT

บริษัทที่ใช้ Elixir ในระบบ Production

เส้นทางการเรียนรู้ Elixir และ Phoenix

ขั้นที่ 1: พื้นฐาน Elixir

ขั้นที่ 2: Phoenix Framework

ขั้นที่ 3: Real-time และ OTP

ขั้นที่ 4: Production

แหล่งเรียนรู้แนะนำ

สรุป

บทความที่เกี่ยวข้อง

แนะนำจากเครือข่าย SiamCafe

บทความที่เกี่ยวข้อง