Kubernetes via Docker Compose

Kubernetes Logo

So I’ve decided to revisit my Kubernetes development cluster setup. The Mark 2 setup uses Docker Compose to launch the Kubernetes cluster in Docker.

To try it out, clone the GitHub repository:

git clone https://github.com/vyshane/docker-compose-kubernetes.git

The project also comes with:

Starting Kubernetes on Linux

On Linux we’ll run Kubernetes using a local Docker Engine. You will also need Docker Compose as well as the kubectl tool. To launch the cluster:

./kube-up.sh

Starting Kubernetes on OS X

On OS X we’ll launch Kubernetes inside a boot2docker VM via Docker Machine. You will need to have Docker Machine (v0.5.0 or newer), Docker Compose, and the kubectl tool installed locally. First start your boot2docker VM:

docker-machine start <name>
eval "$(docker-machine env $(docker-machine active))"

Then, launch the Kubernetes cluster in boot2docker via Docker Machine:

./kube-up.sh

The script will set up port forwarding so that you can use kubectl locally without having to ssh into boot2docker.

Checking if Kubernetes Is Running

kubectl cluster-info
Kubernetes master is running at http://localhost:8080
KubeUI is running at http://localhost:8080/api/v1/proxy/namespaces/kube-system/services/kube-ui

Accessing Kube UI

You can access Kube UI at http://localhost:8080/ui.

To destroy the cluster

./kube-down.sh

This will also remove any services, replication controllers and pods that are running in the cluster.

Full Post + Comments

Setting up a Kubernetes Cluster using CoreOS on VMWare Fusion

Kubernetes Logo

I recently wanted to set up a local Kubernetes cluster for development on my Mac. I tried many howtos in various state of staleness and brokenness. The official Vagrant setup didn’t even work for me on OS X until yesterday.

While I was happy that the Vagrant setup was working again, my preferred development environment was on CoreOS via VMWare Fusion. The following is what worked for me. I’ve put together information from the Kubernetes “CoreOS Multinode Cluster” guide and the CoreOS “Running CoreOS on VMware” documentation.

Getting the latest CoreOS VMWare image

First, get the latest VMWare image for the CoreOS channel that you want. E.g. for the beta channel:

curl -LO http://beta.release.core-os.net/amd64-usr/current/coreos_production_vmware_ova.ova

Creating a virtual machine for the Kubernetes master

Open the downloaded file using VMWare Fusion. VMWare will create a .vmwarevm from the .ova. Give your virtual machine a name, e.g. “Kubernetes Master”.

We’ll use Cloud-Config to customise this CoreOS instance upon boot, turning it into our Kubernetes cluster master. Download the master.yaml file from the Kubernetes CoreOS getting started guide

Then create an .iso that VMWare can use as a config drive for the virtual machine.

mkdir -p /tmp/new-drive/openstack/latest/
cp master.yaml /tmp/new-drive/openstack/latest/user_data
hdiutil makehybrid -iso -joliet -joliet-volume-name "config-2" \ 
  -joliet -o master.iso /tmp/new-drive

You can get the virtual machine to access the .iso by going to the VM’s Settings, then CD/DVD (IDE).

Creating a Kubernetes minion virtual machine

Open the downloaded .ova file again using VMWare Fusion. Give your virtual machine a name, e.g. “Kubernetes Node 1″.

Download the node.yaml file from the Kubernetes CoreOS getting started guide. Edit the file and replace all instances of with the IP address of the master node. Then create a node config-drive.

mkdir -p /tmp/new-drive/openstack/latest/
cp node.yaml /tmp/new-drive/openstack/latest/user_data
hdiutil makehybrid -iso -joliet -joliet-volume-name "config-2" \ 
  -joliet -o node.iso /tmp/new-drive

Boot your Kubernetes node image using node.iso as a config drive. You can create multiple nodes and they will connect to the master.

Testing it out

Once you have both the master and minion up, you can use kubectl to check on the cluster.

kubectl -s <master-ip-address>:8080 get nodes

Full Post + Comments

Android bitmap image resource sizes for the different screen pixel densities

Here’s a handy table that you can refer to when creating image bitmap resources for your Android app.

Qualifier Approximate dpi Scaling ratio
ldpi 120 Baseline
mdpi 160 43 * ldpi
hdpi 240 64 * mdpi
xhdpi 320 86 * hdpi
xxhdpi 480 128 * xhdpi
xxxhdpi 640 1612 * xxhdpi
nodpi N/A Not scaled
tvdpi 213 1.33 * mdpi

xxxhdpi is only used for launch icons.

Source: Android Developer Guide: Providing Alternative Resources

Full Post + Comments

Where the magic happens

Home office

The man cave.

Full Post + Comments

Alexis, born 01/11/2014

Alexis

Full Post + Comments

The best read-it-later implementation that will never be

Google already has the tech to build the best read-it-later service bar none. It understands web content like no other and can even crawl JavaScript applications. Google can unshackle content that I actually want to read from all the surrounding noise.

Google can, but unfortunately it won’t. Doing so would anger content owners, the people that Google relies on to display its ads. And that’s a pity.

Full Post + Comments

Elixir Notes

Elixir books

I’ve been learning myself some Elixir lately. Unfortunately, I’ve only been able to sip while I really want to be gulping the stuff down. There aren’t enough hours in a day. Sometimes a week passes between study sessions and it’s hard for me to find my bearings when I come back to the language after a break. So I’ve started writing some study notes. I find that it helps me internalise the syntax and makes what I’m learning more sticky. The result is more than just a cheat sheet, but remains easy to glance through.

It’s a work in progress, but might be useful to somebody: Elixir notes.

Elixir is a functional, meta-programming aware language built on top of the Erlang VM. It is a dynamic language that focuses on tooling to leverage Erlang’s abilities to build concurrent, distributed and fault-tolerant applications with hot code upgrades.

Full Post + Comments

Using Retrofit and RxJava to interact with web services on Android

Retrofit from Square, and RxJava from Netflix, are a great combo for interacting with web services on Android.

Retrofit

Retrofit is a REST client for Android and Java. It allows you to turn a REST API into a Java interface by using annotations to describe the HTTP requests. It can then generate an implementation of the interface for you. This means that you can go from:

GET /users/{userId}/posts

to:

webService.fetchUserPosts(userId)

in a few lines of code. Retrofit is very easy to use and it comes with RxJava integration.

RxJava

RxJava is a Java implementation of Rx, the Reactive Extensions library from the .NET world. It allows you to compose asynchronous and event-based programs in a declarative manner. Let’s say that you want to implement something like this:

  • Start observing our current location. When a location change happens, in parallel
    • Send a web service request A
    • Send a web service request B
      • Using the result from B, send a web service request C
  • When the results for both A and C are back, update the UI

RxJava allows you to write out your program pretty much as above. It abstracts out concerns about things like threading, synchronization, thread-safety, concurrent data structures, and non-blocking I/O. You can tell RxJava to observe the location changes and perform the web service requests in a background thread, and pass you the final results in the UI thread. If any exceptions are thrown at any point in the chain of events, you get told about it in one convenient place. You’re not drowning in a spaghetti of onSuccess and onError callbacks. You’re building pipelines.

I’m sold. Show me the code!

Sounds good? I’ve got some code to get you started. RexWeather is a simple app that demonstrates the use of Retrofit and RxJava on Android. The app queries the current location, then fetches the current weather and seven day forecast from OpenWeatherMap.

Screenshot of RexWeather

You can grab the Android Studio project from GitHub. The code is BSD-licensed, so feel free to use and share.

Full Post + Comments

Being a Programmer

Book Covers

Being a programmer means that my default state is to be at the edge of my current capabiliy. I’m rarely in any sort of comfort zone, and looking around the Internet, I’m constantly reminded of just how much I still have to learn.

There is a level of sharing in our profession that allows us to literally look at master craftsmen as they are building their best work. There is a huge body of open source work where we can see every line of code added and removed. Commit messages tell us the justification for every single change made to the codebase, all the way back to the very first line written. And on top of that, we can read about the design decisions as they are hashed out in online discussions. No matter how good we become, the open nature of the Internet rams home the harsh truth: someone, somewhere, has the expertise to expose us as mere imposters.

Ours is a commitment to lifelong learning and sometimes it can feel like an endless slog. However, if we embrace our never ending education, we can thrive and grow not just as craftsmen, but as humans. I’ve noticed that good programmers have a deep intellectual self-confidence. One that comes through doing something over and over again, constantly. Good programmers know that they can learn just about anything if they apply their mind to it. No, it won’t be easy. No deep insight comes easily. But it can be done. They know because they do it all the time.

Full Post + Comments

RubyMotion 3.0 to bring Android support

RubyMotion allows developers to use Ruby to write iOS and OS X applications. It uses an LLVM-based static compiler to compile apps down to machine code.

With the next major version, RubyMotion looks to take on Xamarin in the cross platform game. Due later this year, RubyMotion 3.0 will add support for the Android platform.

RubyMotion Logo

Ruby is, in my opinion, a more pleasant language than either Java or Objective-C. However, that in itself was not a good enough reason for me to pick it over Objective-C for my iOS work. Would I use it for Android apps? They promise that performance should not be an issue. RubyMotion compiles down to machine code on Android too. The ability to share code between platforms makes it somewhat more attractive, but it also brings up comparison with the more mature Xamarin stack. While Ruby is nice, Xamarin has C#, which is also a nice(er) language (than Java). And how about the ability to use F# in Xamarin? Functional programming is the new black isn’t it?

It looks like one thing will carry over from iOS and OS X to Android though: The eye-twitch inducing fact that ruby code favours liberal use of underscores while the Android framework, like Cocoa Touch, is firmly in the camel case camp.

Full Post + Comments