Introduction To Azure Kubernetes Service

In this article, we’ll learn about Azure Kubernetes Service in brief and go through a step-by-step process to deploy a Kubernetes Cluster in Azure, learn to scale the cluster, upgrade it, and then also learn to delete it after usage and is no longer in need. 

Let us imagine a scenario where developers are preparing for a demo. In this situation, there arise issues with different machines not being able to function as the software was with the original machine. “It was working in my machine” – is the most common dialogue we hear. In order to cater to this issue, we had a requirement of a proper system. In a nutshell, if an application has been built and is used in another system it might not function properly in the new environment. The key solutions that address this problem are, Virtual Machines and Containers. Learn about Virtual Machines from the previous article, Azure Compute


Containers can be defined as a unit of software that is executable where the application codes are packaged with the needed dependencies and libraries such that it can be run where ever needed from cloud to on-premises services. You can learn more about Containers and briefly about container orchestration from the previous article, Containers And Container-Orchestration In Azure.

Container Challenges 

Source: CNCF 2020 Survey Report 

We can see majority agree that complexity is the biggest challenge with deploying containers. Thus, this isn’t an easy topic by any means and can be overwhelming. But it also means, we can make it easier as we understand it a bit better.  

Differences between Virtual Machines and Containers

Virtual Machines (VM)  Containers
A virtual machine is the emulation or virtualization of an entire computer system. The Virtual Machines (VM) performs like a physical computer system altogether.    Containers can be defined as a unit of software that is executable where the application codes are packaged with the needed dependencies and libraries such that it can be run where ever needed from cloud to on-premises services. 
The entire computer system is virtualized.   Only the Operating System is virtualized.  
The size of VM is extremely large.   The size of Containers is extremely light ranging to just a few megabytes.  
Eg: Azure Virtual Machine, Vmware, etc.   Eg: Docker 

Benefits of Using Containers 

There is a huge benefit of using containers. It supports the use of different operating system, both on-prem and cloud services as well as can be used from applications with both monolith and microservices architecture. Moreover, multiple languages from Java, .NET, Python, Node are all supported too. Basically, any OS, anywhere, for any types of application architecture programmed in any Language. 


Docker is a platform that supports to development, ship, and run applications by delivering software in packages that are known as containers. 


Kubernetes provides the service to automate deployment, scale, and manage our containerized applications easily. This open-source container-orchestration software was developed and released by Google in 2014 and is currently looked over by Cloud Native Computing Foundation (CNCF). With the rise of microservices, there has also been a surge in the use of containers and thus the container orchestration – Kubernetes.  

Kubernetes is an orchestration tool and it enables high availability or no downtime. Moreover, it also provides scalability and high performance as well as supports disaster recovery – ie. backup and restore. More about Disaster Recovery and Business Continuity here

At present, the analogy of Cattle vs Pet has been imperative to understand to realize how Kubernetes should be used. The convention is that Kubernetes should be approached and treated like Cattle and not like pet. The analogy comes from the idea that pets are individually extremely important while cattle can be interchanged. Thus, the notion of shifting the production infrastructure into the cattle approach helps create high availability, reduced failure, and a rapid disaster recovery system with minimal downtime. Kubernetes has now become the gold standard for container orchestration mainly because it enables DevOps engineers to treat the containers like cattle.  

Basic Architecture of Kubernetes 

Source: Kubernetes 

The Cluster of Kubernetes architecture consists of Nodes, Control Plane, Controllers, Cloud Controller Manager, and Garbage Collection.  


A node can be a physical or virtual machine and depends on the cluster. The workload is run by Kubernetes by placing the containers into Pods to run on these nodes. Hence, these containers are inside and are running on the nodes. We can find out the status of the Node from the following command.  

kubectl describe node <insert-node-name-here> 

Control Plane 

The Control plane runs the cluster, and it includes the following.  

  • API Server 
  • Controller Manager 
  • Scheduler 
  • Etcd 

The API pattern on which node to control plane communicates is through “hub-and-spoke”. The API usages from the nodes terminates at this API Server whereas for the communication from control plane to node – there are two communication paths. One is from the API Server to the Kubelet Process that runs on node in the cluster and another is from API server to any node, service or pod through the API Server’s proxy functionality.  

Virtual Network between the control plane and node 

Moreover, SSH tunnels are provided by Kubernetes in order to protect communication paths between control plane and node. As of now, SSH Tunnels has been deprecated and TCP level proxy has substituted it.  

Monolith vs Microservice 

You can learn more about Monolith and Microservice architecture, from the previous article.  

Monolith  Microservice 
It is a traditional approach to design software.  It is comparatively a modern approach.  
A single-tiered software program designed in a manner where data access and user interface are all combined in one specific program on a single platform.  The application tiers are managed independently in the microservice architecture, each as separate units such that the units are in the different repositories each having its allocated resources for processor and memory. 
All the application tiers lie in the same unit and are managed in a singular repository sharing system resources such as processor and memory.    The APIs are well-defined to connect the units to each other. 
The programming language used for the entire application also relies on only one and the product is released using a single binary.     The entire application might use one or more programming languages and are released using each individual binary.    

Azure Kubernetes Service (AKS) 

Azure Kubernetes Service provided the facility to manage and deploy our containerized application with complete Kubernetes Service. It offers CI/ CD – Integrated Continuous Integration and Continuous Delivery, serverless architecture, and enterprise-level security for our applications. It provides features for Microservices, DevOps, and even support to train Machin Learning Models. Azure Kubernetes Service simplifies the deployment, management and operation of Kubernetes. Moreover, deployment and management of Kubernetes can be done with ease along with application made accessible to scale and run with confidence. Furthermore, the Kubernetes environment is secured and containerized application development is accelerated. Developers and DevOps engineers can work how they want with open-source tools and APIs as it is made extremely convenient to set up CI/CD in just a few clicks with AKS.  

The elements of orchestration, 

  • Scheduling 
  • Affinity / Anti-affinity 
  • Health Monitoring 
  • Failover 
  • Scaling 
  • Networking 
  • Service Discovery 
  • Coordinated App Upgrades 

Azure Container Instances (ACI) 

With Azure Container Instances, it is made easy to run the containers on Azure without managing servers. Containers can be run without managing servers and the agility is increased along with the applications secured by hypervisor isolation. More about ACI in Containers and Container Orchestration

How do we Deploy a Kubernetes Cluster in Azure?  

We can deploy a Kubernetes Cluster in Azure by simply following the below steps. All these commands are executed in Azure CLI.  

Create a resource group 

az group create 

Create AKS cluster 

az aks create 

Connect to Cluster 

az aks get-credentialscommand 

Now, the application can be Run

How can we scale a Cluster?  

The following tutorial works on Azure CLI version 2.0.53 and later versions. In order to check the current version of your Azure CLI, run az –version.  

To see the number and state of pods,

kubectl get nodes

With these commands, there’ll be an output that showcases front-end and back-end pod.  

NAME                               READY     STATUS    RESTARTS   AGE 

azure-vote-back-2549590172-4d2r5   1/1       Running   0          29m 

azure-vote-front-840927080-tf34m   1/1       Running   0          28m 

To manage change,

kubectl scale –-replicas=8 deployment/azure-vote-front 

This command scales the front-end pods to 8.  

Verify with,

kubectl get pods 

This command verifies AKS successfully and creates the additional pods with update to the cluster. 

kubectl get pods

                                    READY     STATUS    RESTARTS   AGE
azure-vote-back-2606967446-nmpcf    1/1       Running   0          15m
azure-vote-front-3309479140-2hfh0   1/1       Running   0          5m
azure-vote-front-3309479140-bzt05   1/1       Running   0          3m
azure-vote-front-3309479140-fvcvm   1/1       Running   0          2m
azure-vote-front-3309479140-hrbf2   1/1       Running   0          11m
azure-vote-front-3309479140-qphz8   1/1       Running   0          4m
azure-vote-front-3309479140-mnsf2   1/1       Running   0          1m
azure-vote-front-3309479140-rtyz8   1/1       Running   0          3m
azure-vote-front-3309479140-uwqf2   1/1       Running   0          6m
azure-vote-front-3309479140-poiz8   1/1       Running   0          2m


Horizontal pod autoscaling is supported by Kubernetes. Use the cluster autoscaler for automation purposes.  

How do we update a cluster? 

First of all, find out regarding the updates that are available.  

az aks get-upgrades 


az aks get-upgrades --resource-group myResourceGroup --name myAKSCluster 

And, when you can upgrade; 

To upgrade 

az aks upgrade  
    --resource-group myResourceGroup  
    --name myAKSCluster  
    --kubernetes-version KUBERNETES_VERSION 

Next, Validate the upgrade by checking with az aks show command. 

az aks show --resource-group myResourceGroup --name myAKSCluster --output table 


Name          Location    ResourceGroup    KubernetesVersion    ProvisioningState    Fqdn
------------  ----------  ---------------  -------------------  -------------------  ----------------------------------------------------------------
myAKSCluster  eastus      myResourceGroup  1.19.1               Succeeded  

Finally, to delete the cluster 

az group delete --name myResourceGroup --yes --no-wait 


Thus, in this article, we learned in brief about Azure Kubernetes Services, Containers, differences between virtual machines and containers, the benefits of using containers, and about Docker. Then we dived into Kubernetes, its basic architecture, and differentiated in brief about Monolith and Microservice. Finally, we went deep into Azure Kubernetes Service and learned to deploy Kubernetes cluster in Azure, scale the cluster, upgrade it, and then learned to delete it too. 

Show More

Related Articles

Leave a Reply

Your email address will not be published. Required fields are marked *