A long time ago, I wrote a blog post about assigning managed identities to pods in Azure Kubernetes Services (AKS) to authenticate to Azure Storage. The implementation was based on the aad-pod-identity project on GitHub. You can look at the walkthrough to see how it worked.
Microsoft recently released a preview that enables you to turn on pod identity during cluster creation. It uses the same building blocks as before but makes it fully supported and part of AKS (although preview now). To create a basic cluster with pod identity enabled, you can use the following commands:
az group create -n RESOURCEGROUP -l LOCATION az aks create -g RESOURCEGROUP -n CLUSTERNAME --enable-managed-identity --enable-pod-identity --network-plugin azure
Note: you need to use Azure CNI networking here; kubenet will not work
Before you deploy the cluster, make sure you follow the prerequisites in the documentation (Before you begin). At the time of writing (December 2020), the section in the documentation that tells you how to create the AKS cluster does not use the Azure CNI plugin. Make sure you add that!
What does –enable-pod-identity do?
When you use –enable-pod-identity, you should see nmi pods on your cluster in the kube-system namespace:
These pods are created from a DaemonSet so you will have one pod per cluster node (Linux nodes only ). When your application wants to use a managed identity, it does a request to the Instance Metadata Service (IMDS) endpoint which is 169.254.169.254. Requests to that IP address are intercepted by the NMI pods via iptables rules. The NMI pod that intercepts the request then makes an Azure AD Authentication Library (ADAL) request to Azure AD to obtain a token for the managed identity and returns it to your application.
Next to the NMI pods, other things are added as well, such as custom resource definitions. Some of those are discussed below.
How to request the token?
It’s great to know that the NMI pods intercept requests to the IMDS endpoint but how do you make such a request? I put together a small example in Python in the following git repository: https://github.com/gbaeke/python-msi. The code is in the rg-api folder in server.py:
from azure.identity import DefaultAzureCredential from azure.mgmt.resource import ResourceManagementClient, SubscriptionClient from fastapi import FastAPI app = FastAPI() try: credentials = DefaultAzureCredential() subscription_client = SubscriptionClient(credentials) subscription = next(subscription_client.subscriptions.list()) subscription_id = subscription.subscription_id resource_client = ResourceManagementClient(credentials, subscription_id) except: print("error obtaining credentials") @app.get("/") def read_root(): groups= try: for resource_group in resource_client.resource_groups.list(): groups.append(resource_group.name) except: print("error obtaining groups") return groups
The code does the following:
- use the azure-identity Python library to obtain credentials via DefaultAzureCredential() function. Note that that function tries multiple authentication options. If you run the code on your local computer and you are logged on to Azure with the Azure CLI, it will also work
- use the azure-mgmt-resource Python library to enumerate resource groups in the current subscription
- create a very simple API with FastAPI to ask for the list of resource groups; we can use a kubectl port forward later to obtain the JSON response; if authentication fails, the call will return an empty list instead of HTTP errors as you normally would
On my system, this is the result of the call when pod identity is working:
The repo also contains a Dockerfile to build a container with the app. I built and pushed that container to Docker Hub as gbaeke/rgapi.
Creating and using the identity
If we want the pod that runs the above code to use a specific identity, we have to create the identity and then tell the pod to use it. To create the managed identity, use the following command:
az identity create --resource-group rg-clu-msi --name rgapi
The output of this command contains an id field that we need in another command later. The result of the above command is a User Assigned Managed Identity called rgapi. I already granted the Contributor role at the subscription level.
Note that this has nothing to do with AKS. To create a pod identity to use in AKS, you will need to run another command:
az aks pod-identity add --resource-group rg-clu-msi --cluster-name clu-msi --namespace rgapi --name rgapi --identity-resource-id "id field from previous command"
The above command creates a pod identity called rgapi in the namespace rgapi. This namespace will be created if it does not exist. You can see the pod identity by running the below command:
kubectl get azureidentities.aadpodidentity.k8s.io
If you look inside such an object, you would find the reference to the managed identity by its resource id (the id field from earlier). There are other custom resource definitions used by pod identity that we will not bother with now.
Now we need to create a pod and associate it with the pod identity. You can do so with the following YAML:
apiVersion: v1 kind: Pod metadata: name: rgapi namespace: rgapi labels: aadpodidbinding: rgapi spec: containers: - name: rgapi image: gbaeke/rgapi nodeSelector: kubernetes.io/os: linux
The important bit above is the aadpodidbinding label which refers to the pod identity we created earlier. When the above pod gets scheduled, it will call out to the IMDS endpoint. You should see that in the logs of the NMI pod on the same node as your application pod. For example:
no clientID or resourceID in request. rgapi/rgapi has been matched with azure identity rgapi/rgapi status (200) took 12677813 ns for req.method=GET reg.path=/metadata/identity/oauth2/token req.remote=10.240.0.36
The first line indicates that I did not specifically set a clientID in my request but that the request is matched to the rgapi identity. The second line shows the NMI pod requesting a token for the identity from the Azure AD token endpoint.
Great! We now have a pod running that can retrieve resource groups with our custom managed identity. We did not have to add credentials manually or grab them from Key Vault. Our pod automatically picks up the pod identity. 🎉
Although it is still not super simple (is identity ever simple really?), the new method to enable pod identities is a definite improvement. It is currently in preview so it should not be used in production. Once it goes GA however, you will have a fully supported method of using user assigned managed identity with your pods and use specific identities per pod following least privilege methods.