# Getting started with Kubernetes on Azure

- URL: https://baeke.info/2017/03/17/getting-started-with-kubernetes-on-azure/
- Author: Geert Baeke
- Published: March 17, 2017
- Topics: azure, containers, iot, kubernetes
- Outdated: Azure Container Service (az acs) was retired and replaced by AKS.

As you may or may not know, at [Xylos](http://www.xylos.com "Xylos") we have developed an IoT platform to support sensor networks of any kind. The back-end components are microservices running as containers on [Rancher](http://www.rancher.com "Rancher"), a powerful and easy to use container orchestration tool. In the meantime, we are constantly evaluating other ways of orchestrating containers and naturally, Azure Container Services is one of the options. Recently, Microsoft added support for Kubernetes so we decided to check that out.

Instead of the default “look, here’s how you deploy an nginx container”, we will walk through an example of an extremely simple microservices application written in [Go](http://golang.org) with the help of [go-micro](https://github.com/micro/micro "go-micro"), a microservices toolkit. Now, I have to warn you that I am quite the newbie when it comes to Go and go-micro. If you have remarks about the code, just let me know. This post will not explain the Go services however, so let’s focus on deploying a Kubernetes cluster first and deploying the finished containers. Subsequent posts will talk about the services in more detail.

With the help of Azure CLI 2.0, deploying Kubernetes could not be simpler. You will find full details about installation on [https://docs.microsoft.com/en-us/cli/azure/install-azure-cli](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli). The CLI runs on Windows, Linux and macOS. For this post, I used macOS. If you are a bit unsure about how the Azure CLI works, check out this post: [https://docs.microsoft.com/en-us/cli/azure/get-started-with-azure-cli](https://docs.microsoft.com/en-us/cli/azure/get-started-with-azure-cli).

After installation, use `az login` to authenticate and `az account` to set the default subscription. After that you are all set to deploy Kubernetes. First, create a resource group for the cluster:

`az group create --name=rgname --location=westeurope`

After the above command (use any name as resource group), use the following command to create a Kubernetes cluster with only one master and two agents and use a small virtual machine size. We do this to keep costs down while testing.

`az acs create --orchestrator-type=kubernetes --resource-group=rgname --name=clustername --generate-ssh-keys --agent-count=2 --master-count=1 --agent-vm-size=Standard_A1_v2`

**Tip:** to know the other virtual machine sizes in a region (like westeurope) use `az vm list-sizes --location=westeurope`

Note that in the az acs command, we auto-generate SSH keys. These are used to interact with the cluster and you can of course create your own. When you use generate-ssh-keys, you will find them in your home folder in the .ssh folder (id\_rsa and id\_rsa.pub files).

Now you need a way to administer the Kubernetes cluster. You do that with the `kubectl` command-line tool. Get `kubectl` with the following command:

`az acs kubernetes install-cli`

The kubectl tool needs a configuration file that instructs the tool where to connect and the credentials to use. Just use the following command to get this configured:

`az acs kubernetes get-credentials --resource-group=rgname --name=clustername`

Running the above command creates a config file in the .kube folder of your home folder. In the config file, you will see a https location that kubectl connects to, in addition to user information such as a user name and certificates.

Now, as a test, lets deploy a part of the microservices application that exposes a REST API endpoint to the outside world (I call it the data API). To do so, do the following:

`kubectl create -f https://raw.githubusercontent.com/gbaeke/go-data/master/go-data-dep.yaml`

The above command creates a deployment from a configuration file that makes sure that there are two containers running that use the image gbaeke/go-data. Each container runs in its own pod. You can check this like so:

`kubectl get pods`

You will see something like:

![image-2](https://baeke.info/_astro/2017-03-pods.D9k7XHY9_cTyJN.webp)

Run `kubectl get deployment` to see the deployment. Use `kubectl describe deployment dataapi`to obtain more details about the deployment.

You will not be able to access this API from the outside world. To do this, let’s create a service of type LoadBalancer which will also configure an Azure load balancer automatically (could have been done from the YAML file as well):

`kubectl expose deployments dataapi --port=8080 --type=LoadBalancer`

You can check the service with `kubectl get service`. After a while and by running the last command again, the external IP will appear. You should now be able to hit the service with curl like so:

`curl http://IP_of_service:8080/data/device1`

No matter what device id you type at the end, you will always get **Device active: false** because the device API has not been deployed yet. How the data API talks to the device API and how they use service registration in Kubernetes will be discussed in another post.

**Tip**: for those that cannot wait, just run `kubectl create -f https://raw.githubusercontent.com/gbaeke/go-device/master/go-device-dep.yaml` and then use curl again with device1 at the end (should return true). The above command deploys the device API so that the data API can find and use it to check if a device exists.