∴ikura

Serving Erlang

Since OTP is such a powerful tool for
creating servers, not surprising, I’m
constantly installing Erlang on new
hardware & virtualware.

I do this often, but not to a degree that
warrants using a container solution, like
docker.
There’s always a few
gotchas with installing OTP to, say,
Digital Ocean. But
after so many installations, my process
is pretty solid.

A reference

After I fire up a fresh server, a prerequisite
is to get users & timezones sussed out. I like to
front-load annoying things right away. Then,
using
this guide,
I’ve borrowed this & that to slightly harden
the server, though I only go all in with this
when the situation
truly requires it.

Assuming we are shelled in for the first time
as root to a Ubuntu machine, I add a new user
(dale) via the following:

Next, NTP & timezones need to be set up so our
service won’t give us surprises down the road. There
are a few tools (even graphical ones) to perform this
task, but the following are the ones I use all the
time:

One can go whole hog with securing a server. But for
nine out of ten servers, the requirements are such
that a simple firewall will suffice. Using Ubuntu’s
ufw tool, we’ll open ssh, and a few other
ports.

You can glance at your handiwork with sudo ufw show added.
If everything is to your liking, solidifying your new firewall
is just one more step:

$ sudo ufw enable

With that, our basic firewall is in place. You can list your
configuration at any time with sudo ufw status.

Langs

Before we install any languages we love, we should handle
the language we take for granted: our spoken one. While
the King’s English is for some, American English will
suit me just fine (choose the one you prefer, of course).

To see what your OS installation has available to use,
you can perform locale -a to take a gander at all the
possible languages. If your language isn’t there, you will
have to install it.

The server’s current language can be displayed via locale.
If it isn’t to your liking, perform the following:

$ sudo locale-gen fr_FR.UTF-8
$ sudo dpkg-reconfigure locales

…where the argument to the first is an example of French/UTF-8.
All said & done, if you cat /etc/default/locale, you should see the
environment variables looking something like the following:

LC_ALL=fr_FR.UTF-8
LANG=fr_FR.UTF-8

You can edit that file by hand if you’re ever stuck & need
to coerce things a bit.

The not-so-fun stuff

If you perform openssl version, and what’s yielded is
‘not found’ or you’re shown a version that’s tremendously bygone,
it’s time to update OpenSSL. You can’t do much in
OTP without a new-ish version of it humming away, so let’s
jump on that pro-actively.

First, we should get a sense for any installation of OpenSSL
already in place (if indeed it’s installed at all). The following
can prove helpful:

$ apt-cache policy libssl-dev

If, again, nothing shows up, we should proceed with an install/update:

$ sudo apt install openssl libssl-dev

The interwebs are filled to the brim with helpful resources for those
who march down this thorny path. Also note for later, the yield of
the following:

OTP at last

With those four things behind us, it’s time to fill our
hearts with something warm; let’s install Erlang! There
are binaries, and pre-built packages out there, but we
will take the worse-case scenario and build a somewhat
new (at the time of writing) installation of OTP from
source.

First, let’s install some GNU goodies. We need a C compiler
& make. We can install those with ‘apt’ as follows:

$ sudo apt install gcc
$ sudo apt install make

You’ll also want to install ncurses, fop, xsltproc & odbc support:

$ sudo apt install libncurses5-dev fop xsltproc unixodbc-dev

Next, let’s create a corner for ourselves to work in:

$ cd; mkdir src; cd src

Moving along, let’s grab OTP from erlang.org :

$ wget erlang.org/download/otp_src_19.3.tar.gz

Finally, we can configure, make & install OTP. You can configure
it with this guide
by your side, or just do as follows:

N.B.The—with-sslvalue is
known from the aboveapt-file list libssl-devyield. Adjust
yours accordingly.

And with that, you are ready to go. Fire up an Erlang shell to make
sure everything is working okay. You can do that like this:

$ erl
1> application:start(crypto). % How did we do?
2> init:stop().

If everything went smoothly, you are in good shape and won’t need to
do much else for serving up oodles of OTP goodness.

Optional

I use relx for my release handling, and install it globally. If
you’d like to leverage this great tool, you can install it in the
following way. Note that this tool will probably be bundled into
OTP one day, but for the time being, relx is quasi third-party.