workloadsలోకి configuration inject చేయడానికి ConfigMaps మరియు Secrets ఎలా పనిచేస్తాయి?

Question

IT Interview Practice · Accepted Answer

**ConfigMaps** మరియు **Secrets** container images నుండి configurationను వేరుచేస్తాయి, తద్వారా ఒకే image dev, staging, మరియు productionలో వేర్వేరు settingsతో నడుస్తుంది. ConfigMaps **non-sensitive** config కలిగి ఉంటాయి; Secrets **sensitive** data (passwords, tokens, keys) కలిగి ఉంటాయి మరియు మరింత జాగ్రత్తగా handle చేయబడతాయి.

## ఆలోచన: configను image నుండి బయటకు

```text
Image = code (immutable, ఒకసారి build). Config = per-environment విలువలు.
imageలో config bake చేయడం ఒక anti-pattern (environmentకి rebuild, secrets leak).
→ configను ConfigMaps/Secretsలో నిల్వ చేయి, runtimeలో env vars లేదా filesగా inject చేయి.
```

## ConfigMap: non-sensitive settings

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  LOG_LEVEL: "info"
  FEATURE_X: "true"
  app.properties: |
    timeout=30
    retries=3
```

## Secret: sensitive విలువలు

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
stringData:            # ఇక్కడ plaintext; etcdలో base64-encoded గా నిల్వ
  DB_PASSWORD: "s3cr3t"
  DB_USER: "appuser"
```

```bash
# secrets git‌కు commit చేయకుండా సాధారణంగా imperativeగా సృష్టిస్తారు:
kubectl create secret generic db-secret \
  --from-literal=DB_USER=appuser --from-literal=DB_PASSWORD=s3cr3t
```

## Podలోకి inject: env vars లేదా filesగా

```yaml
spec:
  containers:
    - name: app
      image: myapp:1.0
      env:
        - name: LOG_LEVEL                 # ConfigMap నుండి ఒక key
          valueFrom:
            configMapKeyRef: { name: app-config, key: LOG_LEVEL }
        - name: DB_PASSWORD               # Secret నుండి ఒక key
          valueFrom:
            secretKeyRef: { name: db-secret, key: DB_PASSWORD }
      envFrom:
        - configMapRef: { name: app-config }   # అన్ని keysను env varsగా import చేయి
      volumeMounts:
        - name: config-vol
          mountPath: /etc/config           # configను filesగా mount చేయి
  volumes:
    - name: config-vol
      configMap: { name: app-config }
```

## Secrets గురించి ముఖ్యమైన హెచ్చరికలు

```text
⚠ Secret data default‌గా base64-ENCODED, encrypted కాదు.
  → etcd కోసం ENCRYPTION AT REST enable చేయి (EncryptionConfiguration).
  → RBACతో access పరిమితం చేయి ('get secrets' ఎవరు చేయగలరో).
  → external managers (Vault, cloud Secrets Manager) లేదా sealed secrets ఇష్టపడు.
  → నిజమైన Secret manifestsను git‌కు ఎప్పుడూ commit చేయకు.
Env-var config container start‌లో ఒకసారి చదవబడుతుంది; mounted files live update కాగలవు.
```

## ఇది ఎందుకు ముఖ్యం

configurationను code నుండి వేరు చేయడం ఒక ప్రధాన operational practice, మరియు ConfigMaps మరియు Secrets అనేవి Kubernetes దాన్ని ఎలా అమలు చేస్తుందో, కాబట్టి వాటిని అర్థం చేసుకోవడం అత్యవసరమైన middle-level జ్ఞానం. environment-specific settingsను ఒక imageలో bake చేయడం ఒక anti-pattern — ఇది environmentకి rebuild బలవంతం చేసి secrets leak చేసే ప్రమాదం ఉంది — కాబట్టి Kubernetes మీకు ఒకే immutable image ఉంచి runtimeలో configuration inject చేయనిస్తుంది: non-sensitive విలువల కోసం **ConfigMaps** (log levels, feature flags, config files) మరియు sensitive data కోసం **Secrets** (passwords, tokens, keys). వాటిని consume చేసే రెండు మార్గాలు తెలుసుకోవడం — **environment variables**గా (`configMapKeyRef`/`secretKeyRef` ద్వారా వ్యక్తిగత keys, లేదా `envFrom` ద్వారా అన్ని keys) మరియు **mounted files**గా (env vars startupలో ఒకసారి చదవబడతాయి while mounted files live update కాగలవు అనే సూక్ష్మతతో) — నిజ applications deploy చేయడానికి రోజువారీ ఆచరణాత్మక జ్ఞానం. అంతే ముఖ్యం చాలా engineersను తడబడేలా చేసే security caveats అర్థం చేసుకోవడం: Secret data default‌గా కేవలం **base64-encoded, encrypted కాదు**, కాబట్టి దాన్ని నిజంగా రక్షించడానికి etcd కోసం **encryption at rest** enable చేయడం, **RBAC**తో access పరిమితం చేయడం, Secret manifestsను version controlకు commit చేయకుండా ఉండటం, మరియు తరచుగా ఒక external secret manager integrate చేయడం అవసరం. దాదాపు ప్రతి workloadకు per-environment configuration మరియు credentials అవసరం కాబట్టి, మరియు Secrets తప్పుగా handle చేయడం ఒక సాధారణ మరియు తీవ్రమైన security gap కాబట్టి, ConfigMaps మరియు Secrets మీద గట్టి పట్టు Kubernetesలో applications సురక్షితంగా మరియు సరిగ్గా నడపడానికి పునాది.

ఆలోచన: configను image నుండి బయటకు

ConfigMap: non-sensitive settings

Secret: sensitive విలువలు

Podలోకి inject: env vars లేదా filesగా

Secrets గురించి ముఖ్యమైన హెచ్చరికలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు