These days a common approach to microservice deployment is to ship them as a standalone binary package. The Uber Jars in the Java world are a prominent example. This simplifies operations - particularly when you are in a pre-Docker environment.
All it needs to run a microservice is a single Linux command line. As an old Linux guy I am delighted with this "back to the basics" approach.
A must-have feature for those kind of processes is the ability to configure the service via an external configuration file. Here, you often find the usual suspects like YAML, JSON or even INI.
This advice of the 12 factor manifesto made along existing config option more prominent again: good old environment variables.
This post shows a demo microservice which consists of three files:
- demoservice-starter.sh - starts demoservice.py and provides it with its configuration
- demoservice.cfg - the configuration file for this service consisting of shell variable definitions
- demoservice.py - the actual microservice (just a modified Flask "Hello World")
The service is started like this:
$ ./demoservice-starter.sh demoservice.cfg &
Outside to inside explaination:
demoservice-starter.sh
Line 6 reads in the config file provided as command line argument. Technically the content of demoservice.cfg is parsed and executed.
Remarkable here is that the environment variables created in line 6 are just visible for demoservice-starter.sh and its children but not for the rest of the Linux system. In contrast to a user or system "profile" file containing global environment variables this is a decentral, scoped approach to provide environment variables.
Line 7 then starts the microservice. In this case I use Gunicorn as server for my little Flask application. I use "&" to send the gunicorn process to the background and continue the script execution.
Line 8 stores the process id of my just started process. This PID variable is needed two times. On line 9 we enter a "wait" state until the gunicorn process exits. This is basically a more sophisticated version of an endless sleep loop. The latter one works as well but it requires more code ;)
To stop the microservice we just kill demoservice-starter.sh. However, the shell does not kill our gunicorn child process automatically.
To retrofit this behaviour we have to quickly discuss what kill actually does. This is what the man page says:
kill - send a signal to a process. The default signal for kill is TERM.
So when we kill demoservice-starter.sh we actually just send the TERM signal to the script. What we need to do now is to forward this signal to our child gunicorn process.
This is what line 4 does: When the script receives a TERM signal it kills the gunicorn process which then lets our "wait" command continue to the end of the script.
A quick note on line 2: Here we enable two features of the bash shell. "-a" automatically makes variables defined in the script available for child processes. Without "-a" we would need to prepend each variable in demoservice.cfg with a "export" statement.
The other feature is "stop script on error" by using "-e". This is very useful also for build scripts to safe yourself from each time manually checking exit codes.
