0

Akkahttp, Docker and Kubernetes

You wanna try out Kubernetes (k8s) locally in your linux? Here is how:

This post combines Akkahttp, Docker and Kubernetes on your linux dev machine. You may use this setup for development and debug purposes.

What is Akkahttp, Docker and Kubernetes?


  1. Akkahttp is made for building integration layers based on HTTP and as such tries to “stay on the sidelines”.


  2. Docker is an open-source project that automates the deployment of linux applications inside software containers.


  3. Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications.

akkahttp-playground is a simple project based on Akkahttp that exposes 2 endpoints to get & post data. Actually any web application that you can wrap into a docker image could be used here.
Using Docker as container format was a natural decision as there are so many resources on the web about docker for so many use cases and scenarios.
Kubernetes is a container cluster manager that allows you to run containers on different clouds including AWS , CoreOS and GCE and others.

Minikube allows you to run Kubernetes locally. Before you can follow the steps below, you need to make sure these tools and technologies exist on your linux:

Lets start up minikube in the directory of the akkahttp-playground clone:

minikube start

 

Now kubectl is configured to use the cluster.
You can run

minikube docker-env

to identify the IP address that sets up docker environment variables.

 

To set up the docker environment variables you run:

eval $(minikube docker-env)

 

The docker images that are created in the following steps shall be stored in a local docker registry – lets start one:

docker run -d -p 5000:5000 --name registry registry:2

 

Now its time to build the base docker image that is used for the akkahttp web app.

cd base/docker/java/

changes to the directory that contains the Dockerfile to build the java 8 base docker image:

docker build -t localhost:5000/java08:0.0.2 -f Dockerfile . && docker push localhost:5000/java08:0.0.2

 

The command above also pushes this image to the local docker registry.

 

 

The same approach is used for the scala/sbt docker image that is build on top of the java image:

cd ../scala/
docker build -t localhost:5000/scala:0.0.2 -f Dockerfile . && docker push localhost:5000/scala:0.0.2

 

You can go ahead to the project’s root directory

cd ../../..

 

Next steps would be to build the application, wrap it into a docker container and uploaded the image to the docker registry.
For that, there is the sbt-native-packager plugin that contains package formats including the docker plugin.
The build.sbt file contains the configuration to upload the docker image to the local registry.

sbt docker:publishLocal && sbt docker:publish

 

The akkahttp-playground docker container is now uploaded to the local private docker registry.

 

Now you should create user name & password used by minikube to pull the image:

docker login localhost:5000

should result in

Username (admin): [someuser]
Password: [somepassword]
Login Succeeded

 

 

Let’s tell minikube about those details:

kubectl create secret docker-registry myregistrykey --docker-server=localhost:5000 --docker-username=[someuser] --docker-password=[somepassword] --docker-email=[someemail]
kubectl get secrets

should show a respective item myregistrykey.

 

A kubernetes deployment works with pod config yaml files like this:

kubectl create -f pod-config.yaml

 

The status of the pod is available using the describe command:

kubectl describe pods/akkahttpplaygroundname

 

The output should be similar to

Name:		akkahttpplaygroundname
Namespace:	default
Node:		minikube/192.168.99.100
Start Time:	Thu, 13 Oct 2016 22:41:06 +0200
Labels:		
Status:		Running
IP:		172.17.0.5
...
Containers:
  akkahttpplayground:
    Container ID:		docker://e638961e5dd9db76e30643523b20330afeac752ff76f9468f5cec6dfbd725275
    Image:			localhost:5000/akkahttp-playground:0.0.1
...
26s	3s	3	{kubelet minikube}	spec.containers{akkahttpplayground}	Normal	Pulling	pulling image "localhost:5000/akkahttp-playground:0.0.1"
25s	3s	3	{kubelet minikube}	spec.containers{akkahttpplayground}	Normal	Pulled	Successfully pulled image "localhost:5000/akkahttp-playground:0.0.1"
3s	3s	1	{kubelet minikube}	spec.containers{akkahttpplayground}	Normal	Created	Created container with docker id 5ac511bf78d3; Security:[seccomp=unconfined]
3s	3s	1	{kubelet minikube}	spec.containers{akkahttpplayground}	Normal	Started	Started container with docker id 5ac511bf78d3

 

 

Similar to docker logs there is

kubectl logs akkahttpplaygroundname

 

The same output as with docker logs should be shown:

Server online at http://localhost:8181/hello
Hit ENTER to stop...

 

 

However, in order to access the service you should run

curl -v http://192.168.99.100:8181/hello

and should get

...
Connected to 192.168.99.100 (192.168.99.100) port 8181 (#0)
> GET /hello HTTP/1.1
> User-Agent: curl/7.35.0
> Host: 192.168.99.100:8181
> Accept: */*
>
< HTTP/1.1 200 OK
* Server akka-http/2.4.10 is not blacklisted
< Server: akka-http/2.4.10
< Date: Tue, 18 Oct 2016 08:34:39 GMT
< Content-Type: application/json
< Content-Length: 16
<
* Connection #0 to host 192.168.99.100 left intact
{"msg":"my msg"}

 

 

 

Access the service via localhost would not work because the eval command (3rd step) at the beginning applies to the whole docker setup.

When you are done with debugging or developing you may don't need the minikube anymore:

minikube delete

 

 

 

The step by step commands above described how to do use

  • akkhttp
  • docker
  • kubernetes/minikube

on your local linux environment.

You can also debug using docker without kubernetes/minikube:

docker run -dit -p 8181:8181 --name akkahttp-playground localhost:5000/akkahttp-playground:0.0.1
curl http://localhost:8181/hello

should return something like

{"msg":"my msg"}

(That assumes you did not adapt the docker daemon using the eval command above)

 

 

In case you want to run the scala code only, you could use:

sbt "run-main info.lotharschulz.MyService"

Runing the scala tests would be:

sbt [clean] test

 

 

You can also upload the docker images to other docker registries. You'd adapt build.sbt e.g.

 

The docker base images described above can be also accessed via docker hub:

 

 

 

Finally I wanna thank Tobias, Raffaele and Oleksii for their tips regarding kubectl describe, logs and eval.

My cloud is still called floppy disk 😉

Lothar Schulz

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.