With Project Flogo you can visually create Ultralight Edge Microservices and run them anywhere. But what if you want to run those incredibly light microservices using one of the most powerful container management platforms, Kubernetes?
Prerequisites
As described on the Kubernetes website
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery.
If you haven’t set up your own Kubernetes cluster yet, I can absolutely recommend looking at minikube. The team has made an amazing effort to make it super easy to run your own cluster locally with minimal installation effort.
As Kubernetes is meant for containerized apps it means we’ll have to create a Docker image from our Flogo app and push it to a registry accessible to the Kubernetes cluster. In the examples below I’ll make use of Docker Cloud, but depending on your preference you can pick any container registry.
The Flogo app
As the post is more about running the app on Kubernetes than it is on how to create the apps, I’ve simply used the tutorial in the Flogo documentation. This app has a simple HTTP receiver listening on port 8080 and sends back a default string. If you want to use a different app that is of course possible as well!
Create a Docker image
Flogo describes itself as an _Ultralight Edge Microservices Framework_, so containerizing the apps built with it shouldn’t add too much overhead. Luckily today you have a whole bunch of small base containers available, ranging from alpine to debian (with jessie-slim). My three favorites being:
$ docker images
debian jessie-slim a870c469749c 10 days ago 79.1MB
alpine latest 053cde6e8953 11 days ago 3.97MB
bitnami/minideb latest c5693017e0d4 3 weeks ago 53.6MB
The app I have, compiled to run on Linux, is about 7.4MB and because I want to keep the overhead as low as possible I’ll use alpine for this one. Combining alpine with my Flogo app should result in an image of about 12MB, which I think is pretty good. To build an image we need a Dockerfile:
# Dockerfile for flogoapp
# VERSION 0.0.1
# The FROM instruction initializes a new build stage and sets the Base Image for subsequent instructions.
# We’re using alpine because of the small size
FROM alpine
# The ADD instruction copies new files, directories or remote file URLs from <src> and adds them to the filesystem of the image at the path <dest>.
# We’ll add the flogoapp, built using the Web UI, to the working directory
ADD flogoapp.dms .
# The EXPOSE instruction informs Docker that the container listens on the specified network ports at runtime.
# The app we’re using listens on port 8080 by default
EXPOSE 8080
# The main purpose of a CMD is to provide defaults for an executing container.
# In our case we simply want to run the app
CMD ./flogoapp.dms
To build an app out of this you can simply run the command:
docker build . -t <your username>/flogoalpine
In my case that ended up with quite a small image, at roughly the size I expected it to be!
REPOSITORY TAG IMAGE ID CREATED SIZE
retgits/flogoalpine latest e7bc672e009e About an hour ago 11.7MB
As mentioned I’ll make use of Docker Cloud to push my images to so that the Kubernetes cluster can access them. One simple command makes the image available :-)
docker push <your username>/flogoalpine
That takes care of the Docker part, let’s get over to Kubernetes!
Create a “Deployment”
The Deployment in Kubernetes is a controller which provides declarative updates for Pods and ReplicaSets. Essentially speaking it gives you the ability to declaratively update your apps, meaning zero downtime!
A sample `deployment.yaml` file could like like below. This will create a Deployment on Kubernetes, with a single replica (so one instance of our app running) where the container will have the name `flogoapp` and it will pull the `<image name>` as the container to run. Pay special attention to the `containerPort` as that will make sure that the port will be accessible from the outside (though still within the cluster)
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: flogoapp-deployment
spec:
replicas: 1
template:
metadata:
labels:
app: flogoapp
spec:
containers:
- name: flogoapp
image: <image name>
imagePullPolicy: Always
ports:
- containerPort: 8080
To now create a deployment you can run
kubectl create -f deployment.yaml
Within the kubectl cli tool, or using the dashboard, you can see the status of your deployments:
$ kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
flogoapp-deployment 1 1 1 1 50m
Our app is running! Now we need to make sure we can access it from the outside as well…
Create a “Service”
The Kubernetes documentation has an excellent explanation on why you need Services, so I’ll let them tell the story
Kubernetes Pods are mortal. They are born and when they die, they are not resurrected. ReplicationControllers in particular create and destroy Pods dynamically (e.g. when scaling up or down or when doing rolling updates). While each Pod gets its own IP address, even those IP addresses cannot be relied upon to be stable over time. This leads to a problem: if some set of Pods (let’s call them backends) provides functionality to other Pods (let’s call them frontends) inside the Kubernetes cluster, how do those frontends find out and keep track of which backends are in that set?
So the services logically group pods together and make sure that even when a pod goes away you don’t have to change IP addresses. A service can have a lot of different capabilities and many more configuration options, so let’s create one that is fairly simple.
The below `service.yaml` file simply defines the service `flogoapp` that directly binds port 8080 of the app we have deployed to port 30061 that we can access from outside of the cluster.
apiVersion: v1
kind: Service
metadata:
name: flogoapp
labels:
app: flogoapp
spec:
selector:
app: flogoapp
ports:
-
port: 8080
protocol: TCP
nodePort: 30061
type: LoadBalancer
To create the service in Kubernetes you can simply run:
kubectl create -f service.yaml
Within the kubectl cli tool, or using the dashboard, you can see the status of your services just like your deployments:
$ kubectl get services
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
flogoapp LoadBalancer 10.0.0.110 <pending> 8989:30061/TCP 1h
kubernetes ClusterIP 10.0.0.1 <none> 443/TCP 1d
And that takes care of the exposing the app outside of the cluster as well. So we have one final task!
Access your app!
Accessing the app is quite simple now. First we need the external IP address from the Kubernetes cluster. If you’re running minikube you can get that by running `minikube ip`. with cURL you can now invoke the API from the app and see the internal Flogo ID of the app.
$ curl http://192.168.99.100:30061/helloworld
{“id”:”006257ffaf5fb1e9621914dcd0203af8"}
Conclusion
We’ve taken a simple Flogo app, added that app into a Docker container and deployed that to Kubernetes. By itself Flogo is incredibly powerful and lightweight. Combining that with the power and flexibility of Kubernetes gives you the power to run ultralight microservices on a very cool and powerful platform. If you want to try out Project Flogo, visit our web page or GitHub project.