Using KubeVault operator
You need to be familiar with the following CRDs:
Let’s enable and configure Azure secret engine by deploying the following SecretEngine yaml:
apiVersion: engine.kubevault.com/v1alpha1
kind: SecretEngine
metadata:
name: azure-engine
namespace: demo
spec:
vaultRef:
name: vault
azure:
credentialSecret: azure-cred
To configure the Azure secret engine, you need to provide azure credentials through a Kubernetes secret.
apiVersion: v1
kind: Secret
metadata:
name: azure-cred
namespace: demo
data:
client-secret: eyJtc2ciOiJleGFtcGxlIn0=
subscription-id: eyJtc2ciOiJleGFtcGxlIn0=
client-id: eyJtc2ciOiJleGFtcGxlIn0=
tenant-id: eyJtc2ciOiJleGFtcGxlIn0=
Let’s deploy SecretEngine:
$ kubectl apply -f docs/examples/guides/secret-engines/azure/azureCred.yaml
secret/azure-cred created
$ kubectl apply -f docs/examples/guides/secret-engines/azure/azureSecretEngine.yaml
secretengine.engine.kubevault.com/azure-engine created
Wait till the status become Success:
$ kubectl get secretengines -n demo
NAME STATUS
azure-engine Success
A sample AzureRole object is given below:
apiVersion: engine.kubevault.com/v1alpha1
kind: AzureRole
metadata:
name: azure-role
namespace: demo
spec:
vaultRef:
name: vault
applicationObjectID: c1cb042d-96d7-423a-8dba-243c2e5010d3
ttl: 1h
Let’s deploy AzureRole:
$ kubectl apply -f docs/examples/guides/secret-engines/azure/azureRole.yaml
azurerole.engine.kubevault.com/azure-role created
$ kubectl get azureroles -n demo
NAME STATUS
azure-role Success
You can also check from Vault that the role is created.
To resolve the naming conflict, name of the role in Vault will follow this format: k8s.{clusterName}.{metadata.namespace}.{metadata.name}.
Don’t have Vault CLI? Download and configure it as described here
$ vault list azure/roles
Keys
----
k8s.-.demo.azure-role
$ vault read azure/roles/k8s.-.demo.azure-role
Key Value
--- -----
application_object_id c1cb042d-96d7-423a-8dba-243c2e5010d3
azure_roles <nil>
max_ttl 0s
ttl 1h
For more detailed explanation visit Vault official website
Using Vault CLI
You can also use Vault CLI to enable and configure the Azure secret engine.
Don’t have Vault CLI? Download and configure it as described here
To generate secret from the Azure secret engine, you need to perform the following steps.
- Enable Azure Secret Engine: To enable Azure secret engine run the following command.
$ vault secrets enable azure
Success! Enabled the azure secrets engine at: azure/
- Configure the secrets engine: Configure the secrets engine with account credentials
$ vault write azure/config \
subscription_id=$AZURE_SUBSCRIPTION_ID \
tenant_id=$AZURE_TENANT_ID \
client_id=$AZURE_CLIENT_ID \
client_secret=$AZURE_CLIENT_SECRET
Success! Data written to: azure/config
- Configure a role: Configure a role called “my-role” with an existing service principal:
$ vault write azure/roles/k8s.-.demo.azure-role \
application_object_id=c1cb042d-96d7-423a-8dba-243c2e5010d3 \
ttl=1h
Success! Data written to: azure/roles/k8s.-.demo.azure-role
$ vault list azure/roles
Keys
----
k8s.-.demo.azure-role
$ vault read azure/roles/k8s.-.demo.azure-role
Key Value
--- -----
application_object_id c1cb042d-96d7-423a-8dba-243c2e5010d3
azure_roles <nil>
max_ttl 0s
ttl 1h
If you use Vault CLI to enable and configure the Azure secret engine then you need to update the vault policy for the service account ‘vault’ created during vault server configuration and add the permission to read at “azure/roles/*” with previous permissions. That is why it is recommended to use the KubeVault operator because the operator updates the policies automatically when needed.
Find how to update the policy for service account in here.
For more detailed explanation visit Vault official website
Mount secrets into a Kubernetes pod
Since Kubernetes 1.14, storage.k8s.io/v1beta1 CSINode and CSIDriver objects were introduced. Let’s check CSIDriver and CSINode are available or not.
$ kubectl get csidrivers
NAME CREATED AT
secrets.csi.kubevault.com 2019-12-09T04:32:50Z
$ kubectl get csinodes
NAME CREATED AT
2gb-pool-57jj7 2019-12-09T04:32:52Z
2gb-pool-jrvtj 2019-12-09T04:32:58Z
So, we can create StorageClass now.
Create StorageClass
Create StorageClass object with the following content:
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
name: vault-azure-storage
annotations:
storageclass.kubernetes.io/is-default-class: "false"
provisioner: secrets.csi.kubevault.com
parameters:
ref: demo/vault # namespace/AppBinding, we created vault server configuration
engine: Azure # vault engine name
role: k8s.-.demo.azure-role # role name on vault which you want get access
path: azure # specify the secret engine path, default is azure
$ kubectl apply -f docs/examples/guides/secret-engines/azure/storageClass.yaml
storageclass.storage.k8s.io/vault-azure-storage created
Test & Verify
Let’s create a separate namespace called trial for testing purpose.
$ kubectl create ns trial
namespace/trail created
Create PVC
Create a PersistentVolumeClaim with the following data. This makes sure a volume will be created and provisioned on your behalf.
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: csi-pvc-azure
namespace: trial
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 100Mi
storageClassName: vault-azure-storage
$ kubectl apply -f docs/examples/guides/secret-engines/azure/pvc.yaml
persistentvolumeclaim/csi-pvc-azure created
Create VaultPolicy and VaultPolicyBinding for Pod’s Service Account
Let’s say pod’s service account name is pod-sa located in trial namespace. We need to create a VaultPolicy and a VaultPolicyBinding so that the pod has access to read secrets from the Vault server.
apiVersion: policy.kubevault.com/v1alpha1
kind: VaultPolicy
metadata:
name: azure-se-policy
namespace: demo
spec:
vaultRef:
name: vault
# Here, azure secret engine is enabled at "azure".
# If the path was "demo-se", policy should be like
# path "demo-se/*" {}.
policyDocument: |
path "azure/*" {
capabilities = ["create", "read"]
}
---
apiVersion: policy.kubevault.com/v1alpha1
kind: VaultPolicyBinding
metadata:
name: azure-se-role
namespace: demo
spec:
vaultRef:
name: vault
policies:
- ref: azure-se-policy
subjectRef:
kubernetes:
serviceAccountNames:
- "pod-sa"
serviceAccountNamespaces:
- "trial"
Let’s create VaultPolicy and VaultPolicyBinding:
$ kubectl apply -f docs/examples/guides/secret-engines/azure/vaultPolicy.yaml
vaultpolicy.policy.kubevault.com/azure-se-policy created
$ kubectl apply -f docs/examples/guides/secret-engines/azure/vaultPolicyBinding.yaml
vaultpolicybinding.policy.kubevault.com/azure-se-role created
Check if the VaultPolicy and the VaultPolicyBinding are successfully registered to the Vault server:
$ kubectl get vaultpolicy -n demo
NAME STATUS AGE
azure-se-policy Success 8s
$ kubectl get vaultpolicybinding -n demo
NAME STATUS AGE
azure-se-role Success 10s
Create Service Account for Pod
Let’s create the service account pod-sa which was used in VaultPolicyBinding. When a VaultPolicyBinding object is created, the KubeVault operator create an auth role in the Vault server. The role name is generated by the following naming format: k8s.(clusterName or -).namespace.name. Here, it is k8s.-.demo.azure-se-role. We need to provide the auth role name as service account annotations while creating the service account. If the annotation secrets.csi.kubevault.com/vault-role is not provided, the CSI driver will not be able to perform authentication to the Vault.
apiVersion: v1
kind: ServiceAccount
metadata:
name: pod-sa
namespace: trial
annotations:
secrets.csi.kubevault.com/vault-role: k8s.-.demo.azure-se-role
$ kubectl apply -f docs/examples/guides/secret-engines/azure/podServiceAccount.yaml
serviceaccount/pod-sa created
Create Pod
Now we can create a Pod which refers to this volume. When the Pod is created, the volume will be attached, formatted and mounted to the specific container.
apiVersion: v1
kind: Pod
metadata:
name: mypod
namespace: trial
spec:
containers:
- name: mypod
image: busybox
command:
- sleep
- "3600"
volumeMounts:
- name: my-vault-volume
mountPath: "/etc/azure"
readOnly: true
serviceAccountName: pod-sa # service account that was created
volumes:
- name: my-vault-volume
persistentVolumeClaim:
claimName: csi-pvc-azure
$ kubectl apply -f docs/examples/guides/secret-engines/azure/pod.yaml
pod/mypod created
Check if the Pod is running successfully, by running:
$ kubectl get pods -n trial
NAME READY STATUS RESTARTS AGE
mypod 1/1 Running 0 27s
Verify Secret
If the Pod is running successfully, then check inside the app container by running
$ kubectl exec -it -n trial mypod sh
/ # ls /etc/azure/
client_id client_secret
/ # cat /etc/azure/client_id
2b871d4a-757e-4b2f-bc78*************/ #
/ # cat /etc/azure/client_secret
9d7ce30a-4fa5-a*********************/ #
/ # exit
So, we can see that the secret client_id and client_secret are mounted into the pod, where the secret key is mounted as file and the value is the content of that file.
Cleaning up
To clean up the Kubernetes resources created by this tutorial, run:
$ kubectl delete ns demo
namespace "demo" deleted
$ $ kubectl delete ns trial
namespace "trial" deleted
