ConfigMaps અને Secrets workloads માં configuration inject કરવા માટે કેવી રીતે કામ કરે છે?

Question

IT Interview Practice · Accepted Answer

**ConfigMaps** અને **Secrets** configuration ને container images થી અલગ કરે છે, જેથી એ જ image dev, staging, અને production માં અલગ-અલગ settings સાથે ચાલે. ConfigMaps **non-sensitive** config ધરાવે છે; Secrets **sensitive** data (passwords, tokens, keys) ધરાવે છે અને તેમને વધુ કાળજીથી handle કરવામાં આવે છે.

## વિચાર: config ને image ની બહાર રાખો

```text
Image = code (immutable, built once).  Config = per-environment values.
Baking config into the image is an anti-pattern (rebuild per env, secrets leak).
→ Store config in ConfigMaps/Secrets, inject at runtime as env vars or files.
```

## 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 values

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
stringData:            # અહીં plaintext; etcd માં base64-encoded સ્વરૂપે સંગ્રહાય
  DB_PASSWORD: "s3cr3t"
  DB_USER: "appuser"
```

```bash
# સામાન્ય રીતે git માં secrets commit ન થાય તે માટે imperatively બનાવાય:
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 is base64-ENCODED, not encrypted, by default.
  → Enable ENCRYPTION AT REST for etcd (EncryptionConfiguration).
  → Restrict access with RBAC (who can 'get secrets').
  → Prefer external managers (Vault, cloud Secrets Manager) or sealed secrets.
  → Never commit real Secret manifests to git.
Env-var config is read ONCE at container start; mounted files can update live.
```

## આ શા માટે મહત્વનું છે

configuration ને code થી અલગ કરવું એ એક કેન્દ્રિય operational પ્રથા છે, અને ConfigMaps તથા Secrets એ છે જેના દ્વારા Kubernetes તેને અમલમાં મૂકે છે, તેથી તેમને સમજવું આવશ્યક middle-level જ્ઞાન છે. environment-ચોક્કસ settings ને image માં bake કરવું એ anti-pattern છે — તે દરેક environment દીઠ rebuild ને ફરજ પાડે છે અને secrets લીક થવાનું જોખમ ઊભું કરે છે — તેથી Kubernetes તમને એક જ immutable image રાખવા અને runtime પર configuration inject કરવા દે છે: non-sensitive values (log levels, feature flags, config files) માટે **ConfigMaps** અને sensitive data (passwords, tokens, keys) માટે **Secrets**. તેમને consume કરવાની બે રીતો જાણવી — **environment variables** તરીકે (`configMapKeyRef`/`secretKeyRef` દ્વારા વ્યક્તિગત keys, કે `envFrom` દ્વારા બધા keys) અને **mounted files** તરીકે (આ સૂક્ષ્મતા સાથે કે env vars startup પર એક જ વાર વંચાય છે જ્યારે mounted files live update થઈ શકે છે) — એ વાસ્તવિક એપ્લિકેશનો deploy કરવા માટે રોજિંદું વ્યાવહારિક જ્ઞાન છે. એટલું જ મહત્વનું છે એ security ચેતવણીઓ સમજવી જે ઘણા engineers ને ગૂંચવે છે: Secret data default માં માત્ર **base64-encoded છે, encrypted નથી**, તેથી તેને ખરેખર સુરક્ષિત કરવા માટે etcd માટે **encryption at rest** સક્ષમ કરવું, **RBAC** થી access પ્રતિબંધિત કરવો, Secret manifests ને version control માં commit કરવાનું ટાળવું, અને ઘણી વાર બાહ્ય secret manager ને integrate કરવું જરૂરી છે. કારણ કે લગભગ દરેક workload ને per-environment configuration અને credentials જોઈએ છે, અને કારણ કે Secrets ને ખોટી રીતે handle કરવું એ સામાન્ય અને ગંભીર security ખામી છે, ConfigMaps અને Secrets ની મજબૂત સમજ Kubernetes પર એપ્લિકેશનો સલામત અને યોગ્ય રીતે ચલાવવા માટે પાયાની છે.

વિચાર: config ને image ની બહાર રાખો

ConfigMap: non-sensitive settings

Secret: sensitive values

Pod માં inject કરવું: env vars તરીકે કે files તરીકે

Secrets વિશે મહત્વની ચેતવણીઓ

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો