Can you set dynamic values in Kubernetes YAML files?

Introduction

Kubernetes has become an industry standard for deploying and managing containerized applications at scale. While Kubernetes offers robust solutions, developers often encounter the question: Can you set dynamic values in Kubernetes YAML files? This tutorial explores various methods to manage and set dynamic values in Kubernetes configurations.

YAML, which stands for Yet Another Markup Language, is mainly used to write configuration files. Typically, these files contain static content, but there might be scenarios where you need to parameterize your Kubernetes configurations. Let’s take a look at how this can be achieved.

Using Environment Variables

One of the most straightforward methods to set dynamic values in your Kubernetes configuration files is by using environment variables.

apiVersion: v1
kind: Pod
metadata:
  name: env-demo-pod
spec:
  containers:
  - name: demo-container
    image: nginx
    env:
    - name: DEMO_GREETING
      value: 'Hello from the environment variable!'

When you apply this manifest, the container will have an environment variable called DEMO_GREETING with the value of ‘Hello from the environment variable!’. This method is quite simple but doesn’t provide much flexibility for more complex scenarios.

Using ConfigMaps

To manage dynamic content that can be updated without changing the pod spec, you can use ConfigMaps.

apiVersion: v1
kind: ConfigMap
metadata:
  name: example-configmap
data:
  application.properties: |
    greetings=dynamicValue

Then you can reference it in your pods like this:

apiVersion: v1
kind: Pod
metadata:
  name: config-demo-pod
spec:
  containers:
  - name: demo-container
    image: nginx
    env:
    - name: GREETINGS
      valueFrom:
        configMapKeyRef:
          name: example-configmap
          key: application.properties

Here, the environment variable GREETINGS will receive the value from the example-configmap.

Using Secrets

Secrets are similar to ConfigMaps but are designed to hold sensitive information. Here is a simple example of a secret and how to use it:

apiVersion: v1
kind: Secret
metadata:
  name: example-secret
type: Opaque
data:
  password: 

Once the secret is created, you can inject the value into the pod:

apiVersion: v1
kind: Pod
metadata:
  name: secret-demo-pod
spec:
  containers:
  - name: demo-container
    image: nginx
    env:
    - name: PASSWORD
      valueFrom:
        secretKeyRef:
          name: example-secret
          key: password

The environment variable PASSWORD will be populated with the password from the example-secret.

Using Templating Engines

For complex configuration needs, templating engines like Helm can dynamically generate Kubernetes manifests. Helm utilizes a chart, which is a collection of files that describe a related set of Kubernetes resources.

# Inside the values.yaml
favorite:
  drink: coffee
  food: pizza

# Inside the templates/pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: example-with-helm
spec:
  containers:
  - name: helm-container
    image: nginx
    env:
    - name: FAVORITE_DRINK
      value: {{ .Values.favorite.drink }}
    - name: FAVORITE_FOOD
      value: {{ .Values.favorite.food }}

By using Helm, you can run helm install my-chart . --set favorite.drink=tea, and your manifest will have the environment variable FAVORITE_DRINK set to “tea”.

Using Kustomize

Kustomize provides a different approach to managing Kubernetes objects with YAML files. It lets you customize raw, template-free YAML files for multiple purposes, leaving the original YAML untouched and usable as is.

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
configMapGenerator:
- name: example-configmap
  literals:
  - MY_DYNAMIC_VALUE=dynamicValue

This Kustomization generates a ConfigMap that can then be used in a Pod.

Advanced Usage: Using Operators and Custom Controllers

For situations where you need high degrees of flexibility and programmability, you may consider building custom operators or controllers. These are programs that extend Kubernetes to manage custom resources dynamically based on more complex business logic.

The operator can watch for changes in your custom resources and update your deployments, services, and other Kubernetes objects with the required values in real time.

This concludes the advanced techniques for setting dynamic values in Kubernetes YAML files.

Conclusion

Dynamic values in Kubernetes configurations provide flexibility, allowing you to manage applications more effectively. With this knowledge, developers can utilize the full capabilities of Kubernetes to manage configuration complexity and deploy apps that are both dynamic and secure.