But what about the deployment of a microservice in Docker? How can we build a deployable docker container which includes the microservice we are working on?
Actually, it is a very easy task. It is sufficient to develop the microservice by following some simple rules and your docker image will be ready in few seconds!
Rule 1 : you need a Dockerfile for building an image of your microservice
First of all, create a file named Dockerfile in your working directory and write the following lines:
FROM jolielang/jolie-docker-deployer
MAINTAINER SURNAME NAME
where SURNAME, NAME and EMAIL must be replaced with the maintainer's surname, name and email respectively. The Dockerfile will be used by Docker for building the image related to your microservice. As you can see, the image you are creating is layered upon a previously created image called jolielang/jolie-docker-deployer.
You can find this image in the docker hub of jolielang here. Such a docker image, is prepared for facilitating the deployment of a jolie microservice as a docker image. In order to use it in the right way, just follow the next rules. As an example, let me suppose to deploy the following microservice saved in file helloservice.ol:
interface HelloInterface {
RequestResponse:
hello( string )( string )
}
execution{ concurrent }
inputPort Hello {
Location: "socket://localhost:8000"
Protocol: sodep
Interfaces: HelloInterface
}
main {
hello( request )( response ) {
response = request
}
}
Rule 2 : EXPOSE inputPorts ports
Remember that all the inputPorts of your microservice must be reached from outside the container, thus you need to expose them in the Dockerfile.
In the example the inputPort is located at localhost:8000, thus we need to add EXPOSE 8000 in the Dockerfile. So, your Dockerfile now becomes like this:
FROM jolielang/jolie-docker-deployer
MAINTAINER SURNAME NAME
EXPOSE 8000
Rule 3 : COPY the files of your project and define the main.ol
Now, everything is quite done for preparing the image, we just need to copy the files of the project in the docker image. When doing this, pay attention to rename the file which must be run with the name main.ol.
FROM jolielang/jolie-docker-deployer
MAINTAINER SURNAME NAME
EXPOSE 8000
COPY helloservice.ol main.ol
Building your image
When the Dockerfile is ready we can build the docker image of the microservice. In order to do this you just need to run the following command within your working directory which also contains the Dockerfile.
docker build -t hello .
where hello is the name we give to the image. Once it is finished, you can easily check the presence of the image in the local registry by running the following command:
docker images
Running a container
Now, starting from the image, you can run all the containers you want. A container can be run by launching the following command:
docker run --name hello-cnt -p 8000:8000 hello
where hello-cnt is the name we give to the container. Note that the parameter -p allows you to map the microservice port (8000) to the port 8000 of your localhost. You can check that the container is running just launching the following command which lists all the running containers:
docker ps
Your microservice is now deployed and it is listening for requests at port 8000. You can just try to invoke it with a client like the following one. Remember to launch the client in a separate shell of your localhost!
include "console.iol"
interface HelloInterface {
RequestResponse:
hello( string )( string )
}
outputPort Hello {
Location: "socket://localhost:8000"
Protocol: sodep
Interfaces: HelloInterface
}
main {
hello@Hello( "hello" )( response );
println@Console( response )()
}
Advanced settings
So far, we have deployed a very simple service but, usually we deal with microservices that are more complicated than the hello service presented before. In particular, it is very common the case where some constants or outputPort locations must be defined at deploying time. In order to show this point, let me now consider the following service:
interface HelloPlusInterface {
RequestResponse:
helloPlus( string )( string )
}
interface HelloInterface {
RequestResponse:
hello( string )( string )
}
execution{ concurrent }
constants {
CUSTOM_MESSAGE = " :plus!"
}
outputPort Hello {
Location: "socket://localhost:8000"
Protocol: sodep
Interfaces: HelloInterface
}
inputPort HelloPlus {
Location: "socket://localhost:8001"
Protocol: sodep
Interfaces: HelloPlusInterface
}
main {
helloPlus( request )( response ) {
hello@Hello( request )( response );
response = response + CUSTOM_MESSAGE
}
}
This is a very simple microservice which has a dependency on the previous one. Indeed, in order to implement its operation helloPlus, it requires to invoke the operation hello of the previously deployed microservice. Moreover, it uses a constants CUSTOM_MESSAGE for defining a string to be added to the response string.
Usually, we would like that some of these parameters can be defined at deploying time because they directly deal with the architectural context where the microservice will run. Thus, we would like to create an image which is configurable when it is run as a container. How can we achieve this?
Rule 4 : Prepare constants to be defined at deploying time
The image jolielang/jolie-docker-deployer we prepared for deploying microservice has been built with some specific scripts which are executed before running the main.ol. These scripts just read the environment variables passed to the docker container and transform them in a file of constants which must be read by your microservice. The most important facts we need to know here are:
- Only the environment variables prefixed with JDEP_ will be processed
- The processed environment variables will be collected in a file of constants named dependencies.iol. If it exists it will be overwritten.
interface HelloPlusInterface {
RequestResponse:
helloPlus( string )( string )
}
interface HelloInterface {
RequestResponse:
hello( string )( string )
}
include "dependencies.iol"
execution{ concurrent }
outputPort Hello {
Location: JDEP_HELLO_LOCATION
Protocol: sodep
Interfaces: HelloInterface
}
inputPort HelloPlus {
Location: "socket://localhost:8001"
Protocol: sodep
Interfaces: HelloPlusInterface
}
main {
helloPlus( request )( response ) {
hello@Hello( request )( response );
response = response + JDEP_CUSTOM_MESSAGE
}
}
As you can notice here there are two constants JDEP_HELLO_LOCATION and JDEP_CUSTOM_MESSAGE which require to be defined at the start of the microservice. They must be defined in the file dependencies.iol which MUST BE included in your microservice. This file just contains the declaration of the two constants.
constants {
JDEP_HELLO_LOCATION = "socket://localhost:8000",
JDEP_CUSTOM_MESSAGE = " :plus!"
}
During the development keep this file in your project and collect here all the constants you want to define at deploying time. When the service will be run in the container this file will be overwritten thus, you don't need to copy it into the docker image.
The Dockerfile of the helloPlus service is very similar to the previous one:
FROM jolielang/jolie-docker-deployer
MAINTAINER SURNAME NAME
EXPOSE 8001
COPY helloservicePlus.ol main.ol
We can create the image with the same command used before, but where the name is hello-plus.
docker build -t hello_plus .
Configuring the container
Now, we just need to know how to pass the constants to the running container and everything is done. Docker allows to pass environment variables with the parameter -e available for command run. Thus the command is:
docker run --name hello-plus-cnt -p 8001:8001 -e JDEP_HELLO_LOCATION="socket://172.17.0.4:8000" -e JDEP_CUSTOM_MESSAGE=" :plus!" hello_plus
where hello-plus-cnt is the name we give to the container. Note that the constant JDEP_HELLO_LOCATION is set to "socket://172.17.0.4:8000" where the IP is set to 172.17.0.4. It is just an example, here you need to specify the IP that Docker assigned to the container hello-cnt which is executing the service hello.ol. You can retrieve it just launching the following command:
docker inspect --format '{{ .NetworkSettings.IPAddress }}' hello-cnt
Once the hello-plus-cnt container is running, you can simply invoke it with the following client:
include "console.iol"
interface HelloPlusInterface {
RequestResponse:
helloPlus( string )( string )
}
outputPort HelloPlus {
Location: "socket://localhost:8001"
Protocol: sodep
Interfaces: HelloPlusInterface
}
main {
helloPlus@HelloPlus( "hello" )( response );
println@Console( response )()
}
Conclusion
In this post I show how it is possible to deploy a microservice developed with Jolie as a docker container. The procedure is very easy, just pay attention to inputPorts and the constants you want to configure at deploying time. For all the other things you can just rely on the Jolie language. Don't forget that you can also exploit embedding for packaging more microservices into one, thus deploying all of them inside the same container if necessary.
Enjoy!
