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

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?

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.