Quickly Stand Up Kubernetes with Azure Kubernetes Service

by Brandon Adams | Tuesday, Oct 1, 2019 | Azure Kubernetes Service

Getting started with Azure Kubernetes Service

Azure Kubernetes Service (AKS) is the managed Kubernetes distribution provided by Microsoft. It allows for seamless deployment of a managed Kubernetes cluster for containerized workloads. Microsoft has removed the headache of launching and configuring a cluster, while retaining the benefits of Kubernetes itself.

This post is a part of a series of posts outlining the ease of use of AKS; from launching your first cluster, deploying apps via Helm, and even CI/CD integration with Azure DevOps.

Related: What is Kubernetes?

Getting started

The easiest way to learn how to work with AKS is to spin up a cluster of your own, so that's what we're going to do. There are several ways to launch your first cluster. For first time users, using the dashboard is probably the easiest method; however, this can be tedious to replicate.

Azure Resource Manager (ARM) templates can become complicated for those unfamiliar with its syntax and structure, though it does offer a great degree of portability and flexibility for resource creation.

The az cli is a fantastic alternative, making the process scriptable and easy to understand. This is the method we will outline here, as it offers both the simplicity of the dashboard and the configurability of ARM templates. We'll be using it to build our AKS cluster, here are the installation instructions.

Azure and AKS CLI

Using the az CLI tool to create a cluster is as simple as finding the correct configuration options to use.

Using the az aks create --help will explain which items need to be supplied, as well provide several examples from we can work with. We will be going for simplicity here, there are more advanced options that will let us build a more complex cluster. These options will be enumerated in later posts.

You'll need to collect a few things before creating your cluster.

• Select a resource group for housing the cluster and related resources. You can use an existing one, or create one specifically for this cluster with the following command: az group create --name myResourceGroup --location eastus
• Select an instance size for your nodes. I've selected the Standard_D2s_v3 for its smaller size.

az Command

The below code sample creates a three node AKS cluster using the default kubenet networking plugin.

az aks create --name "dev01" \
--resource-group "BoxBoatRG" \
--generate-ssh-keys \
--node-count "3" \
--node-vm-size "Standard_D2s_v3" \
--enable-vmss \
--enable-addons "monitoring"

From the command above, we can see that there are two additional options: --enable-vmss and --enable-addons "monitoring". Using a Virtual Machine Scale Set (VMSS) allows for metrics-based autoscaling, while the monitoring addon creates a Logs Analytics workspace for storing system and container logs for the cluster. This is handled automatically by Azure.

We connect to this cluster by running a few more CLI commands:

• az aks install-cli: Downloads the kubectl CLI tool
• az aks get-credentials -n dev01 -g boxboatrg --admin: Downloads the correct kubectl config and loads it into the context. The --admin option sets up the current user with admin credentials. What this lets us do is run the kubectl binary to deploy our workloads.

Deploying a Sample App to Azure Kubernetes Service

Once we're connected, we can go ahead and deploy our application. We'll be using a simple hello world app (hello-boxboat) to test deploying to this cluster. The YAML spec (hello-aks.yaml) is posted below.

apiVersion: v1
kind: Service
metadata:
  name: hello-aks
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 80
  selector:
    app: hello-aks
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-aks
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-aks
  template:
    metadata:
      labels:
        app: hello-aks
    spec:
      containers:
      - name: hello-aks
        image: boxboat/hello-boxboat
        ports:
        - containerPort: 80

Simply copy and paste this YAML into a file called “hello-aks.yaml”, and deploy the application by executing kubectl apply -f hello-aks.yaml.

This creates a Kubernetes Deployment object for our application, and a LoadBalancer Service exposed on port 80. Using kubectl get svc hello-aks to find the public IP address and port, navigate to the endpoint to view the welcome page. Refreshing the page will allow for other hostnames to be displayed. And it's that simple! The app is up and running on our AKS cluster in seconds.

AKS Summary

As a recap, let's take a look back at the commands we ran from start to finish, to get an idea of how easy the process was.

• az aks create ... –> this created the AKS cluster
• az aks install-cli –> this downloaded the kubectl binary
• az aks get-credentials ... –> this downloaded credentials to remotely control the cluster
• kubectl apply ... –> this deployed our application

As we can see, launching a Kubernetes cluster with AKS is extremely easy. There are of course ways to make it much more complicated, such as using existing virtual networks and subnets, backing cluster authentication with Azure Active Directory, or deploying apps through Helm charts. These topics and more will be covered in future posts.