Quickstart: Develop on Azure Kubernetes Service (AKS) with Helm

Helm is an open-source packaging tool that helps you install and manage the lifecycle of Kubernetes applications. Similar to Linux package managers like APT and Yum, Helm manages Kubernetes charts, which are packages of pre-configured Kubernetes resources.

In this quickstart, you'll use Helm to package and run an application on AKS. For more details on installing an existing application using Helm, see Install existing applications with Helm in AKS.


Create an Azure Container Registry

You'll need to store your container images in an Azure Container Registry (ACR) to run your application in your AKS cluster using Helm. Provide your own registry name unique within Azure and containing 5-50 alphanumeric characters. Only lowercase characters are allowed. The Basic SKU is a cost-optimized entry point for development purposes that provides a balance of storage and throughput.

The below example uses the az acr create command to create an ACR named myhelmacr in myResourceGroup with the Basic SKU.

az group create --name myResourceGroup --location eastus
az acr create --resource-group MyResourceGroup --name myhelmacr --sku Basic

Your output will be similar to the following example output. Take note of your loginServer value for your ACR since you'll use it in a later step.

  "adminUserEnabled": false,
  "creationDate": "2019-06-11T13:35:17.998425+00:00",
  "id": "/subscriptions/<ID>/resourceGroups/MyResourceGroup/providers/Microsoft.ContainerRegistry/registries/MyHelmACR",
  "location": "eastus",
  "loginServer": "myhelmacr.azurecr.io",
  "name": "MyHelmACR",
  "networkRuleSet": null,
  "provisioningState": "Succeeded",
  "resourceGroup": "MyResourceGroup",
  "sku": {
    "name": "Basic",
    "tier": "Basic"
  "status": null,
  "storageAccount": null,
  "tags": {},
  "type": "Microsoft.ContainerRegistry/registries"

Create an AKS cluster

Your new AKS cluster needs access to your ACR to pull the container images and run them.

Use the az aks create command to create an AKS cluster called myAKSCluster and the --attach-acr parameter to grant the cluster access to the myhelmacr ACR.

az aks create --resource-group myResourceGroup --name myAKSCluster --location eastus --attach-acr myhelmacr --generate-ssh-keys

Connect to your AKS cluster

To connect a Kubernetes cluster locally, use the Kubernetes command-line client, kubectl. kubectl is already installed if you use Azure Cloud Shell.

  1. Install kubectl locally using the az aks install-cli command.

    az aks install-cli
  2. Configure kubectl to connect to your Kubernetes cluster using the az aks get-credentials command. The following command gets credentials for the AKS cluster named myAKSCluster in myResourceGroup:

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

Download the sample application

This quickstart uses the Azure Vote application. Clone the application from GitHub and navigate to the azure-vote directory using the following commands:

git clone https://github.com/Azure-Samples/azure-voting-app-redis.git
cd azure-voting-app-redis/azure-vote/

Build and push the sample application to the ACR

Using the preceding Dockerfile, run the az acr build command to build and push an image to the registry. The . at the end of the command provides the location of the source code directory path (in this case, the current directory). The --file parameter takes in the path of the Dockerfile relative to this source code directory path.

az acr build --image azure-vote-front:v1 --registry myhelmacr --file Dockerfile .


In addition to importing container images into your ACR, you can also import Helm charts into your ACR. For more information, see Push and pull Helm charts to an Azure container registry.

Create your Helm chart

  1. Generate your Helm chart using the helm create command.
helm create azure-vote-front
  1. Update azure-vote-front/Chart.yaml to add a dependency for the redis chart from the https://charts.bitnami.com/bitnami chart repository and update appVersion to v1. For example:


The container image versions shown in this guide have been tested to work with this example but may not be the latest version available.

apiVersion: v2
name: azure-vote-front
description: A Helm chart for Kubernetes

  - name: redis
    version: 17.3.17
    repository: https://charts.bitnami.com/bitnami

# This is the version number of the application being deployed. This version number should be
# incremented each time you make changes to the application.
appVersion: v1
  1. Update your helm chart dependencies using the helm dependency update command.
helm dependency update azure-vote-front
  1. Update azure-vote-front/values.yaml with the following changes:
  • Add a redis section to set the image details, container port, and deployment name.
  • Add a backendName for connecting the frontend portion to the redis deployment.
  • Change image.repository to <loginServer>/azure-vote-front.
  • Change image.tag to v1.
  • Change service.type to LoadBalancer.

For example:

# Default values for azure-vote-front.
# This is a YAML-formatted file.
# Declare variables to be passed into your templates.

replicaCount: 1
backendName: azure-vote-backend-master
    registry: mcr.microsoft.com
    repository: oss/bitnami/redis
    tag: 6.0.8
  fullnameOverride: azure-vote-backend
    enabled: false

  repository: myhelmacr.azurecr.io/azure-vote-front
  pullPolicy: IfNotPresent
  tag: "v1"
  type: LoadBalancer
  port: 80
  1. Add an env section to azure-vote-front/templates/deployment.yaml for passing the name of the redis deployment.
        - name: {{ .Chart.Name }}
            {{- toYaml .Values.securityContext | nindent 12 }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          - name: REDIS
            value: {{ .Values.backendName }}

Run your Helm chart

  1. Install your application using your Helm chart using the helm install command.
helm install azure-vote-front azure-vote-front/
  1. It takes a few minutes for the service to return a public IP address. Monitor progress using the kubectl get service command with the --watch argument.
$ kubectl get service azure-vote-front --watch
NAME               TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)        AGE
azure-vote-front   LoadBalancer   <pending>       80:32021/TCP   6s
azure-vote-front   LoadBalancer   80:32021/TCP   2m6s
  1. Navigate to your application's load balancer in a browser using the <EXTERNAL-IP> to see the sample application.

Delete the cluster

Use the az group delete command to remove the resource group, the AKS cluster, the container registry, the container images stored in the ACR, and all related resources.

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


If the AKS cluster was created with system-assigned managed identity (default identity option used in this quickstart), the identity is managed by the platform and doesn't require removal.

If the AKS cluster was created with service principal as the identity option instead, the service principal used by the AKS cluster isn't removed when you delete the cluster. For steps on how to remove the service principal, see AKS service principal considerations and deletion.

Next steps

For more information about using Helm, see the Helm documentation.