Azure Managed Kubernetes is a fully managed container orchestration service that simplifies the deployment, management, and scaling of containerized applications.
It's a game-changer for businesses looking to modernize their infrastructure and accelerate their digital transformation. With Azure Managed Kubernetes, you can focus on writing code, not managing infrastructure.
The service is built on top of Kubernetes, the industry-standard container orchestration system, and provides a highly available, scalable, and secure environment for running containerized applications.
Azure Managed Kubernetes supports a wide range of container runtimes, including Docker and containerd.
What Is AKS?
AKS is a managed Kubernetes service that simplifies deploying, managing, and scaling containerized applications using Kubernetes.
It's essentially a tool that automates many of the tasks involved in creating and maintaining Kubernetes clusters, making it more accessible to those with limited knowledge of Kubernetes.
AKS Automatic is a feature that takes care of everything from infrastructure provisioning to scaling and upgrading, so you don't have to worry about those technical details.
This means that even those without extensive experience with Kubernetes can create and manage sophisticated clusters, while still allowing experts to work with the Kubernetes API if needed.
With AKS Automatic, you can create and manage clusters using a user-friendly interface, without having to manually configure every setting.
Cluster Configuration
You can create a cluster with AKS in either Automatic or Standard mode. The Automatic mode provides a more fully managed experience, managing cluster configuration, including nodes, scaling, security, and other preconfigured settings.
AKS Automatic is both CLI and GUI-driven, allowing developers and engineers to create, configure and maintain Kubernetes clusters and applications using the Azure portal's graphical user interface.
Node Configuration
A node is a crucial part of an AKS cluster, and it's essential to understand how to configure them for optimal performance.
Each node is an Azure virtual machine (VM) that runs Kubernetes node components. You can choose from a variety of VM sizes, which define CPUs, memory, size, and storage type available.
The VM size you choose depends on the workload requirements and the number of pods you plan to run on each node. For more information, see Supported VM sizes in Azure Kubernetes Service (AKS).
You can choose from Ubuntu Linux, Azure Linux, or Windows Server 2022 as the node OS for your cluster. For Linux node pools, AKS supports Ubuntu 22.04 and Azure Linux 2.0. For Windows node pools, AKS supports Windows Server 2022 as the default OS.
Here's a brief overview of the components that run on each node:
Node Resource Group
When creating an AKS cluster in an Azure resource group, a second resource group is automatically created, known as the node resource group.
This resource group contains all the infrastructure resources associated with the cluster, including virtual machines (VMs), virtual machine scale sets, and storage.
The node resource group is created by the AKS resource provider, which handles the underlying infrastructure for the cluster.
You can't provide your own name for the AKS node resource group, it's automatically created by the AKS resource provider.
However, you can modify tags and other properties of the resources in the AKS node resource group.
This means you have some control over the configuration of the underlying infrastructure, even if you can't choose the name of the resource group itself.
Here are the answers to some common questions about the AKS node resource group:
- Why are two resource groups created with AKS?
- Can I provide my own name for the AKS node resource group?
- Can I modify tags and other properties of the resources in the AKS node resource group?
The answers are: two resource groups are created to separate the cluster resources from the underlying infrastructure, you can't provide your own name, and yes, you can modify tags and other properties.
Configuring Access
Configuring access for your cluster is a crucial step in making your application available to the world. AKS Automatic manages ingress access, so you don't have to worry about it.
AKS Automatic will expose your application on the internet securely according to a DNS name, making it accessible to anyone with an internet connection.
You have two options for creating a DNS name for your application - AKS Automatic will create one automatically, or you can declare a custom DNS name.
Supported Versions
You can find the supported Kubernetes versions by checking the AKS Kubernetes Release Calendar.
The AKS Kubernetes Release Calendar is the go-to resource for determining which versions are supported.
Only Microsoft Azure's Kubernetes versions are supported in AKS.
Installations must be upgraded to the next release within three months after a new release is available.
Node Management
Each AKS cluster has at least one node, which is an Azure virtual machine (VM) that runs Kubernetes node components. The node is essentially the foundation of your cluster, ensuring that containers are running in a pod thanks to the kubelet component.
The kubelet, kube-proxy, and container runtime are the key components that run on each node. The kubelet ensures that containers are running in a pod, the kube-proxy is a network proxy that maintains network rules on nodes, and the container runtime manages the execution and lifecycle of containers.
You can group nodes of the same configuration into node pools, which contain the underlying virtual machine scale sets and virtual machines (VMs) that run your applications. System node pools serve the primary purpose of hosting critical system pods, such as CoreDNS and konnectivity, while user node pools host your application pods.
Nodes
Each AKS cluster has at least one node, which is an Azure virtual machine (VM) that runs Kubernetes node components.
A node in AKS is essentially a virtual machine that hosts various Kubernetes components. The kubelet, kube-proxy, and container runtime are some of the key components that run on each node.
The kubelet ensures that containers are running in a pod, which is a logical grouping of one or more containers.
The kube-proxy is a network proxy that maintains network rules on nodes, allowing containers to communicate with each other.
The container runtime manages the execution and lifecycle of containers, making it a crucial component of the node.
Here's a breakdown of the key components that run on each node:
OS Disks
OS disks are used in AKS clusters or node pools when ephemeral OS disks aren't supported and a default OS disk size isn't specified.
Default OS disk sizing is only used in specific situations, such as when creating new clusters or node pools.
For new clusters or node pools, default OS disk sizing is the default choice when ephemeral OS disks aren't supported and no default OS disk size is specified.
To learn more about default OS disk sizing and ephemeral OS disks, check out the relevant documentation.
To create node pools in AKS, follow the steps outlined in the Create node pools in AKS section.
To manage node pools in AKS, refer to the Manage node pools in AKS section.
Pods and Namespaces
Pods are a fundamental concept in Azure Managed Kubernetes, allowing you to group one or more containers that share the same network and storage resources.
A pod typically has a 1:1 mapping with a container, but you can run multiple containers in a pod.
You can think of a pod as a logical host for your containers, providing them with a shared environment.
Here are the default namespaces created in an AKS cluster:
Container Runtime
Container runtime is software that executes containers and manages container images on a node. It abstracts away sys-calls or OS-specific functionality to run containers on Linux or Windows.
For Linux node pools, containerd is used on Kubernetes version 1.19 and higher. Containerd is generally available for Windows Server 2019 and 2022 node pools, and it's the only runtime option on Kubernetes version 1.23 and higher.
Container runtime plays a crucial role in container management.
Pods
A pod is a group of one or more containers that share the same network and storage resources.
Pods can have a 1:1 mapping with a container, but you can also run multiple containers in a pod.
This means you can have multiple services or applications running together in the same pod, making it a convenient way to deploy and manage related containers.
A pod's specification determines how to run the containers within it, which is defined by its own set of resources and constraints.
In practice, this allows you to create a pod that can run multiple containers together, each with its own unique characteristics and requirements.
Namespaces
Namespaces are a fundamental concept in Kubernetes, and understanding them is crucial for managing your AKS cluster effectively.
The default namespace is created automatically in an AKS cluster, allowing you to start using cluster resources without having to create a new namespace.
You can use the default namespace to create, view, or manage access to resources, but keep in mind that it's not the only namespace available.
By default, four namespaces are created in an AKS cluster: default, kube-node-lease, kube-public, and kube-system.
Here's a brief description of each namespace:
The kube-system namespace is particularly interesting, as it's used by Kubernetes to manage cluster resources.
Frequently Asked Questions
What is the difference between Kubernetes and Azure Kubernetes?
Kubernetes is a platform for running containerized workloads, while Azure Kubernetes Service (AKS) is a managed service that provides a Kubernetes platform on Azure. Understanding the difference between the two can help you choose the best solution for your cloud-native applications.
Which Kubernetes cluster components are managed by Azure in AKS?
In Azure Kubernetes Service (AKS), Azure manages the control plane, which includes Kubernetes objects and worker nodes. This means you don't have to worry about configuring or managing these components yourself.
Sources
- https://learn.microsoft.com/en-us/azure/aks/core-aks-concepts
- https://www.navisite.com/blog/managed-azure-kubernetes-services/
- https://products.vshn.ch/kubernetes/aks.html
- https://thenewstack.io/introducing-aks-automatic-managed-kubernetes-for-developers/
- https://azure.microsoft.com/en-us/products/kubernetes-service
Featured Images: pexels.com