BoxBoat Blog
Service updates, customer stories, and tips and tricks for effective DevOps
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 thekubectl
CLI toolaz aks get-credentials -n dev01 -g boxboatrg --admin
: Downloads the correctkubectl
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 thekubectl
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 clusteraz aks install-cli
–> this downloaded thekubectl
binaryaz aks get-credentials ...
–> this downloaded credentials to remotely control the clusterkubectl 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.