K8s Deployment中的变量插值：如何在字符串值内部传入变量

Great question! When you need to inject variables into string values within a Kubernetes Deployment—whether for command arguments, configuration files, or dynamic service endpoints—there are a few practical, battle-tested approaches. Let’s walk through each with clear examples:

1. Shell-Based Interpolation for Commands/Args #

If you’re working with container commands or arguments, the simplest way is to leverage shell parsing to expand environment variables. Kubernetes won’t automatically interpolate ${VAR} syntax on its own, so you need to wrap your command in a shell (like sh -c) to make this work.

Example Deployment snippet:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: my-image:latest
        env:
        - name: SERVICE_HOST
          value: "api.example.com"
        - name: SERVICE_PORT
          value: "8080"
        # Use sh -c to let the shell interpolate variables into the string
        command: ["sh", "-c", "echo Connecting to http://${SERVICE_HOST}:${SERVICE_PORT} && ./my-app"]

2. Inject Variables into Configuration Files #

For cases where you need variables inside config files (e.g., a .ini, .yaml, or .conf file), use an init container with envsubst to generate a fully interpolated config before your main container starts.

Step 1: Create a ConfigMap Template #

First, define a ConfigMap with your template file (using ${VAR} placeholders):

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config-template
data:
  app.conf: |
    [server]
    endpoint = http://${SERVICE_HOST}:${SERVICE_PORT}
    timeout = 30s
    log_level = ${LOG_LEVEL}

Step 2: Use an Init Container to Generate the Final Config #

Update your Deployment to include an init container that runs envsubst to replace placeholders with actual environment variables:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      initContainers:
      - name: config-generator
        image: alpine:latest # Alpine includes envsubst by default
        command: ["sh", "-c"]
        args:
        - envsubst < /config-templates/app.conf > /config/app.conf
        env:
        - name: SERVICE_HOST
          value: "api.example.com"
        - name: SERVICE_PORT
          value: "8080"
        - name: LOG_LEVEL
          value: "info"
        volumeMounts:
        - name: config-template
          mountPath: /config-templates
        - name: config-volume
          mountPath: /config
      containers:
      - name: my-app-container
        image: my-image:latest
        volumeMounts:
        - name: config-volume
          mountPath: /app/config # Path where your app reads config files
      volumes:
      - name: config-template
        configMap:
          name: app-config-template
      - name: config-volume
        emptyDir: {} # Temporary volume to share the interpolated config

3. Helm Template Interpolation (If Using Helm) #

If you manage your Kubernetes resources with Helm, you can use Helm’s built-in template syntax to interpolate variables directly in your Deployment manifest before it’s applied to the cluster.

Example Deployment template:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-my-app
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
        env:
        - name: SERVICE_ENDPOINT
          # Interpolate Helm values directly into the string
          value: "http://{{ .Values.service.host }}:{{ .Values.service.port }}"
        command: ["sh", "-c", "echo Using endpoint: ${SERVICE_ENDPOINT} && ./my-app"]

Then define your values in values.yaml:

replicaCount: 1
image:
  repository: my-image
  tag: latest
service:
  host: api.example.com
  port: 8080

Key Notes to Avoid Pitfalls #

• Kubernetes Doesn’t Auto-Interpolate: Never put ${VAR} directly in an environment variable’s value field unless you plan to parse it via a shell—Kubernetes will treat it as a literal string.
• Downward API for Pod Metadata: If you need to inject pod-specific metadata (like pod name, namespace, or node IP), use the Kubernetes Downward API to populate environment variables, then use the methods above to interpolate them into strings.

内容的提问来源于stack exchange，提问作者edmamerto