Recommendation for dumb simple http server?

The most barebones may be this HTTP server — OTP 29.0.2 (inets 9.7.1)

As for recommended, considering you’re using Elixir, I’d say Plug v1.20.2 — Documentation with GitHub - elixir-plug/plug_cowboy: Plug adapter for the Cowboy web server · GitHub, but that escapes your requirements I’m afraid.

Depends on how much time you want to spend on it and how deep into the rabbit hole you want to go I guess. Unless you want to know how exactly does cowboy work, plug is super simple.

What do you consider basics?

Just these:

Just an idea, but if you don’t need to do any special processing, wouldn’t using nginx or caddy be more than enough for you?

I am looking for small, programmable components. Nginx/Caddy are harder to program compared to builtin Elixir/Erlang libs.

You might want to check out bandit as an alternative to Cowboy. It should be simpler to understand although it is much less battle tested.

I like elli (GitHub - elli-lib/elli: Simple, robust and performant Erlang web server · GitHub) which I’ve used in erlang many times. It is OK to use from elixir as well. In my opinion it is very easy to understand. The implementation is very readable (if you read erlang).

It just does the basics though and you must be prepared to add some middleware or write your own if you need more functionality.

To get started (well, you should read the README.md from their github and follow any links. One of the best things as well is to look in the source for the example callback. I find it is the best place to look to see what is possible):

in mix.exs add {:elli, "~> 3.3.0"} to dependencies.

Write a simple call back module to handle your requests:

defmodule YourApp.ElliHandler do
  @behaviour :elli_handler
  @staticpath "/some/good/path"
  @impl :elli_handler
  @doc """
  The handle/2 function is one of the callbacks.
  It takes the request and returns a response.
  
  It can serve static files via sendfile by just
  returning {:ok, [], {:file, filename}}
  """
  def handle(req, _args) do
    # Split up the method and path and delegate to other functions
    # which uses pattern matching to match on the path. The path
    # is a list of parts of the url split by "/"
    handle(:elli_request.method(req), :elli_request.path(req), req)
  end

  @doc """
  If the paths is /static/<filename>. Serve the file if it exists
  TODO: fix content-type
  """
  defp handle(:'GET', ["static", filename], _req) do
    path = File.join(@staticpath, filename)
    if File.exists(path) do
      {:ok, [], {:file, path}}
    else
      {404, [], "Not Found"}
    end
  end
  defp handle(:'GET', ["dynamic", "user", id], _req) do
    {:ok, [{"Content-Type", "plain/text"}], "User is #{id}"}
  end
  defp handle(_, _, _req) do
    {404, [], "Not Found"}
  end

  @impl :elli_handler
  @doc """
  Will be called during many events of the request cycle. Can be used to hook in to many things
  or not be used at all.
  """
  def handle_event(_event, _data, _args) do
    :ok
  end
end

And hook it up in your supervision tree:

  @impl true
  def start(_type, _args) do
    children = [
      %{
        id: :elli,
        start: {:elli, :start_link, [ [ callback: YourApp.ElliHandler, port: 3000  ]]}
      }
    ]
    opts = [strategy: :one_for_one, name: YourApp.Supervisor]
    Supervisor.start_link(children, opts)
  end

Single file Phoenix server: phoenix.exs · GitHub.

Interesting blog post I ran across:

https://tylerpachal.medium.com/creating-an-http-server-using-pure-otp-c600fb41c972