Automatically Updating Pods when ConfigMaps Change

Question

Pulumi · Accepted Answer

When you're working with Kubernetes and Pulumi, you might find that you need to automatically update Pods when the associated ConfigMaps change. This is an essential feature in Kubernetes, as it ensures that your applications are using the most up-to-date configurations without requiring a manual Pod restart.

Pulumi, combined with Kubernetes resources, makes this side of configuration management streamlined. You can leverage the `ConfigMap` resource from the Kubernetes API to create and manage your application’s configuration data. When a `ConfigMap` is updated, Kubernetes does not automatically propagate these changes to Pods. However, you can design your application to watch for changes in the ConfigMap and respond accordingly.

One common approach is to use Kubernetes features like `RollingUpdate` for a Deployment, where you can update the `ConfigMap` and then trigger an update of the Deployment that mounts that `ConfigMap`. Pods will be replaced with new ones according to your update strategy, which can pick up the changes in the `ConfigMap`.

Let's see how you can define the ConfigMap and a Deployment that uses it. This program uses the Pulumi Kubernetes provider to manage these resources.

First, create a new file `index.ts` and write the following TypeScript program inside:

```typescript
import * as k8s from '@pulumi/kubernetes';

// Create a ConfigMap with initial data.
const cm = new k8s.core.v1.ConfigMap("app-cm", {
    metadata: { name: "app-config" },
    data: {
        "config": "initial config data",
    },
});

// Create a Deployment that mounts the ConfigMap as a volume.
const appLabels = { app: "app" };
const deployment = new k8s.apps.v1.Deployment("app-deploy", {
    metadata: { labels: appLabels },
    spec: {
        selector: { matchLabels: appLabels },
        replicas: 2,
        template: {
            metadata: { labels: appLabels },
            spec: {
                containers: [{
                    name: "app",
                    image: "nginx:1.14.2",
                    ports: [{ containerPort: 80 }],
                    volumeMounts: [{
                        name: "config-volume",
                        mountPath: "/etc/config",
                    }],
                }],
                volumes: [{
                    name: "config-volume",
                    configMap: {
                        name: cm.metadata.name,
                    },
                }],
            },
        },
    },
});

// Export the ConfigMap name and the Deployment name
export const configMapName = cm.metadata.name;
export const deploymentName = deployment.metadata.name;
```

In this program, a `ConfigMap` named `app-config` is created, holding some configuration data. Then, a `Deployment` is defined with Pods that have the `ConfigMap` mounted as a volume at `/etc/config`. Each time you change and update the data in the `ConfigMap`, you will need to update the `Deployment` to pick up the changes.

To apply changes to the `ConfigMap` and trigger a rolling update of the Deployment, you could manually patch the Deployment or set an environment variable in the Deployment that uses a value from the ConfigMap. However, an update to a ConfigMap referenced in a Deployment spec triggers a rolling update if and only if other parts of the Pod template are also changed, so you’d increment some other part of the Pod template like an annotation:

```typescript
// Import current timestamp to force a rolling update.
import { format } from "date-fns";

// Add an annotation to the Pod template with the current timestamp.
// This will force a rolling update on ConfigMap changes.
const deploymentWithRollingUpdate = new k8s.apps.v1.Deployment("app-deploy-update", {
    metadata: { labels: appLabels },
    spec: {
        // Rest of the Deployment spec...
        template: {
            metadata: { 
                labels: appLabels,
                annotations: {
                    "pulumi.com/update-timestamp": format(new Date(), "yyyy-MM-dd'T'HH:mm:ssXXX")
                },
            },
            // Rest of the Pod template spec...
        },
    },
});
```

The use of `date-fns` is to format the current date and time, which acts as a unique value to trigger the update. This hack ensures that Kubernetes recognizes a change in the Pod template and triggers a rolling update. However, please note that this method might not be ideal for every use case as it will restart pods on every run of Pulumi regardless of whether the ConfigMap content has changed.

This should set you on the right path to automatically updating your Kubernetes Pods when the associated ConfigMap changes using Pulumi. You can adapt this basic pattern to fit your particular application’s needs.