Elixir Server: Hello World With User IP (Simple Guide)

Aug 16, 2025 by Sebastian Müller 55 views

Elixir Server: 'Hello World' and User IP

Hey guys! Let's dive into creating a simple Elixir server that responds with "Hello World" and the user's IP address. This is a fantastic way to get your feet wet with Elixir and understand how to handle basic web requests. We'll break down each step, making it super easy to follow along, even if you're new to Elixir.

Setting Up Your Elixir Environment

First things first, before we jump into coding, let's make sure you've got Elixir installed and set up. If you're an Elixir newbie, don't worry, it's not as scary as it sounds! Elixir is built on top of the Erlang VM, known for its fault tolerance and concurrency, which makes it perfect for building robust web applications.

If you've already got Elixir installed, awesome! You can skip this part. If not, here's a quick guide on getting it up and running. Elixir installation typically involves using a package manager specific to your operating system. For example, on macOS, you can use Homebrew; on Debian/Ubuntu, you can use apt-get; and on Windows, you can use the Elixir installer. Once you've got your package manager sorted, just follow the instructions on the official Elixir website for your OS. They have super clear, step-by-step guides that will walk you through the process. Remember to check your installation by running elixir -v and iex in your terminal. You should see the Elixir and Erlang versions printed if everything's set up correctly. If you encounter any issues, the Elixir community is super helpful, so don't hesitate to reach out on forums or Stack Overflow.

Creating Your Elixir Project

Once Elixir is installed, the next step is to create a new project. This is where your server code will live. Elixir uses a build tool called Mix, which makes project creation a breeze. Open your terminal and navigate to the directory where you want to create your project. Then, run the command mix new hello_world_server. Mix will generate a bunch of files and directories for you, setting up the basic structure of an Elixir application. This includes a mix.exs file, which is the heart of your project's configuration, and a lib directory where your Elixir modules will reside. It's like magic, but it's actually just Mix doing its job! After running the command, navigate into your new project directory using cd hello_world_server. Now, you're ready to start building your server.

Understanding the Project Structure

Take a moment to explore the project structure that Mix has generated. Inside the lib directory, you'll find a module named after your project (in this case, HelloWordServer). This is where you'll define your server logic. The mix.exs file is crucial; it defines your project's dependencies, version, and other important settings. You'll also find a test directory for your tests (though we won't be diving into testing in this article, it's good to know it's there!). Mix also sets up a deps directory, which will hold any external libraries you add to your project. Think of it as the place where your project's dependencies live. Understanding this structure is key to building well-organized Elixir applications. It keeps your code clean and manageable, especially as your projects grow in complexity. So, take a peek around and familiarize yourself with the layout – it'll make your Elixir journey much smoother.

Building the 'Hello World' Server

Alright, let's get to the fun part: writing the code! We're going to use Plug and Cowboy to create our server. Plug is a specification for building web applications in Elixir, and Cowboy is a fast and lightweight web server that implements Plug. Think of Plug as the blueprint and Cowboy as the actual builder. They work together seamlessly to handle web requests.

Adding Dependencies

First, we need to add Plug and Cowboy as dependencies to our project. Open your mix.exs file. You'll see a deps function – this is where you list the libraries your project needs. Add the following lines to the deps function:

{:plug, "~> 1.4"},
{:cowboy, "~> 2.0"}

These lines tell Mix that your project depends on Plug version 1.4 or higher and Cowboy version 2.0 or higher. The ~> operator means “compatible with,” so Mix will fetch the latest versions that are compatible with the specified versions. Once you've added these lines, save the mix.exs file and run mix deps.get in your terminal. This command tells Mix to fetch and install the dependencies listed in your mix.exs file. It's like telling your project to go shopping for the tools it needs. Mix will download the dependencies and store them in the deps directory. Now, your project is equipped with Plug and Cowboy, ready to build a web server!

Creating the Router

Next, we'll create a router. In Plug, a router is a module that defines how incoming requests are handled. It's like a traffic controller for your web server, directing requests to the appropriate handlers. Create a new file in your lib directory called hello_world_server_router.ex. Inside this file, define a module that uses the Plug.Router behavior:

defmodule HelloWorldServer.Router do
 use Plug.Router

 plug :match
 plug :dispatch

 get "/", do: (conn) ->
 conn
 |> Plug.Conn.put_resp_content_type("text/plain")
 |> Plug.Conn.send_resp(200, "Hello World!\nYour IP Address is: #{Plug.Conn.remote_ip(conn)}")
 |> Plug.Conn.halt()
 end

 match _, do: (conn) ->
 Plug.Conn.send_resp(conn, 404, "Not Found")
 end
end

Let's break this down. The use Plug.Router line brings in the router functionality. The plug :match and plug :dispatch lines are essential; they tell Plug to match the incoming request to a route and then dispatch it to the appropriate handler. The get "/", do: line defines a route for GET requests to the root path ("/"). When a request hits this route, the code inside the do block is executed. This code builds a response with the content type set to text/plain, a status code of 200 (OK), and the message "Hello World!" along with the user's IP address. The Plug.Conn.remote_ip(conn) function retrieves the IP address from the connection. Finally, Plug.Conn.halt() stops the processing of the request, ensuring that the response is sent immediately. The match _, do: line acts as a catch-all, sending a 404 (Not Found) response for any unmatched routes. This ensures that your server handles unexpected requests gracefully. So, with this router in place, your server knows exactly how to respond to requests for the root path and how to handle any other requests that come its way.

Creating the Application Supervisor

Now, we need to create an application supervisor. In Elixir, supervisors are a crucial part of the fault-tolerance story. They're responsible for starting, stopping, and restarting parts of your application. Think of them as the managers of your application processes, ensuring that everything runs smoothly. Open your lib/hello_world_server/application.ex file. This file was generated by Mix when you created the project. Inside this file, you'll find a module that defines your application's behavior. We need to modify the start function to start our Cowboy server.

Replace the existing start function with the following:

 def start(_type, _args) do
 children = [
 {Plug.Cowboy, scheme: :http, plug: HelloWorldServer.Router, options: [port: 4000]}
 ]

 opts = [strategy: :one_for_one, name: HelloWorldServer.Supervisor]
 Supervisor.start_link(children, opts)
 end

This code defines a supervisor that starts a single child: our Cowboy server. The Plug.Cowboy child is configured with a few options. The scheme: :http option specifies that we're using HTTP. The plug: HelloWorldServer.Router option tells Cowboy to use our router module to handle requests. The options: [port: 4000] option sets the server to listen on port 4000. The strategy: :one_for_one option tells the supervisor that if one child fails, only that child should be restarted. This is a common strategy for web applications. The name: HelloWorldServer.Supervisor option gives the supervisor a name, which can be useful for monitoring and management. By setting up this supervisor, you're ensuring that your server will be automatically restarted if it crashes, making your application more resilient. So, with this in place, your application is ready to handle the unexpected and keep on serving.

Running Your Elixir Server

We're almost there! Now, it's time to run your server and see the magic happen. Open your terminal, navigate to your project directory, and run the command iex -S mix. This command starts the Elixir interactive shell (iex) and tells Mix to compile and run your application. Mix will compile your code, start your application supervisor, and launch the Cowboy server.

Accessing Your Server

Once the server is running, open your web browser and navigate to http://localhost:4000. You should see the "Hello World!" message along with your IP address. If you're accessing the server from the same machine, your IP address will likely be 127.0.0.1. If you're accessing it from another machine on your network, you'll see the IP address of the machine running the server. If you don't see the message, double-check your code for any typos or errors. Also, make sure that nothing else is running on port 4000, as this could prevent your server from starting. If you encounter any issues, don't hesitate to consult the Elixir and Plug documentation, or reach out to the Elixir community for help. They're a friendly bunch and always willing to assist. So, go ahead, give it a try and bask in the glory of your working Elixir server!

Testing from Another Device

To test your server from another device on the same network, you'll need to find the IP address of the machine running the server. On most operating systems, you can find this by opening a terminal and running a command like ipconfig (on Windows) or ifconfig (on macOS and Linux). Look for the IP address associated with your network interface (usually something like 192.168.1.x or 10.0.0.x). Once you have the IP address, open a web browser on the other device and navigate to http://<server_ip>:4000, replacing <server_ip> with the IP address you found. You should see the same "Hello World!" message and the IP address of the device making the request. This is a great way to ensure that your server is accessible from other devices on your network. If you're planning to deploy your server to the internet, you'll need to configure your network and firewall to allow traffic on port 4000. But for now, testing it locally is a great first step. So, grab another device, give it a try, and see your server in action from different perspectives!

Conclusion

And there you have it! You've successfully created a simple Elixir server that responds with "Hello World" and the user's IP address. This is just the beginning of your Elixir journey. There's so much more to explore, from building complex web applications with Phoenix to leveraging Elixir's concurrency features for distributed systems. But this little project is a great stepping stone.

Remember, Elixir is a powerful and elegant language, and with practice, you'll be building amazing things in no time. Keep experimenting, keep learning, and most importantly, keep having fun! If you enjoyed this tutorial, consider exploring more advanced topics like Phoenix, Ecto, and OTP. These tools will help you build even more sophisticated applications. And don't forget to join the Elixir community – it's a fantastic resource for learning and getting help. So, go forth and build, my friends! The world of Elixir awaits!