Configuration and Secrets

Versiones compatibles: Kubernetes 1.32, 1.33, 1.34 Última actualización: February 22, 2026

En Kubernetes, la gestión de configuración es una parte importante de administrar los ajustes de una aplicación por separado del código. En este capítulo, exploraremos en detalle los métodos de gestión de configuración de Kubernetes, incluidos ConfigMaps, Secrets, environment variables y el montaje de configuración mediante volumes.

Lab Environment Setup

Para seguir los ejemplos de este documento, necesitarás las siguientes herramientas y entorno:

Required Tools

kubectl v1.34 o superior
Un cluster Kubernetes funcional (EKS, minikube, kind, etc.)

Configuration Example Setup

bash

# Create namespace
kubectl create namespace config-demo

# Create ConfigMap
kubectl -n config-demo create configmap app-config \
  --from-literal=APP_ENV=production \
  --from-literal=APP_DEBUG=false \
  --from-literal=APP_PORT=8080

# Create Secret
kubectl -n config-demo create secret generic app-secrets \
  --from-literal=DB_USER=admin \
  --from-literal=DB_PASSWORD=s3cr3t \
  --from-literal=API_KEY=abcdef123456

# Create Pod using ConfigMap and Secret
kubectl -n config-demo apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: config-test-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: ["sh", "-c", "env | sort && sleep 3600"]
    env:
    - name: APP_ENV
      valueFrom:
        configMapKeyRef:
          name: app-config
          key: APP_ENV
    - name: DB_PASSWORD
      valueFrom:
        secretKeyRef:
          name: app-secrets
          key: DB_PASSWORD
  restartPolicy: Never
EOF

# Check Pod logs
kubectl -n config-demo logs config-test-pod

ConfigMap

Concepto clave: Los ConfigMaps almacenan datos de configuración en pares clave-valor, separando el código de la aplicación de la configuración.

Los ConfigMaps son objetos de API que almacenan datos de configuración en pares clave-valor. Usar ConfigMaps te permite separar los datos de configuración de las container images, lo que hace que las aplicaciones sean más portables.

ConfigMap vs Secret Comparison

Feature	ConfigMap	Secret
Purpose	General configuration data	Sensitive configuration data
Storage Format	Plain text	Base64 encoded (default)
Size Limit	1MB	1MB
Encryption	None by default	etcd encryption support
Volume Type	configMap	secret
Use Cases	Environment variables, config files	Passwords, tokens, certificates
Auto Update	Possible delay when volume mounted	Possible delay when volume mounted

ConfigMap Creation Methods

Los ConfigMaps se pueden crear de varias maneras:

Creación imperativa:

bash

# Create from literal values
kubectl create configmap my-config --from-literal=key1=value1 --from-literal=key2=value2

# Create from file
kubectl create configmap my-config --from-file=config.properties

# Create from directory
kubectl create configmap my-config --from-file=config-dir/

Creación declarativa:

yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
data:
  # Simple key-value pairs
  database.host: "mysql"
  database.port: "3306"

  # File-like configuration
  config.yaml: |
    server:
      port: 8080
    logging:
      level: INFO
    features:
      enabled: true

ConfigMap Usage Methods

Los ConfigMaps se pueden usar de las siguientes maneras:

Usar como environment variables:

yaml

apiVersion: v1
kind: Pod
metadata:
  name: config-env-pod
spec:
  containers:
  - name: app
    image: nginx
    env:
    # Single key-value reference
    - name: DB_HOST
      valueFrom:
        configMapKeyRef:
          name: my-config
          key: database.host
    # All key-value references
    envFrom:
    - configMapRef:
        name: my-config

ConfigMap Creation

Los ConfigMaps se pueden crear de varias maneras:

Imperative

bash

# Create from literal values
kubectl create configmap my-config --from-literal=key1=value1 --from-literal=key2=value2

# Create from file
kubectl create configmap my-config --from-file=config.properties

# Create from directory
kubectl create configmap my-config --from-file=config-dir/

Declarative

yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
data:
  # Simple key-value pairs
  key1: value1
  key2: value2
  # File-like configuration
  config.properties: |
    property1=value1
    property2=value2
  # JSON configuration
  config.json: |
    {
      "property1": "value1",
      "property2": "value2"
    }

ConfigMap Usage

Los ConfigMaps se pueden usar en Pods de las siguientes maneras:

Use as Environment Variables

yaml

apiVersion: v1
kind: Pod
metadata:
  name: configmap-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "env" ]
    env:
    # Use single key-value pair
    - name: SPECIAL_KEY
      valueFrom:
        configMapKeyRef:
          name: my-config
          key: key1
    # Use all key-value pairs as environment variables
    envFrom:
    - configMapRef:
        name: my-config
  restartPolicy: Never

Mount as Volume

yaml

apiVersion: v1
kind: Pod
metadata:
  name: configmap-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "ls /etc/config/" ]
    volumeMounts:
    - name: config-volume
      mountPath: /etc/config
  volumes:
  - name: config-volume
    configMap:
      name: my-config
  restartPolicy: Never

Mount Only Specific Keys

yaml

apiVersion: v1
kind: Pod
metadata:
  name: configmap-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "cat /etc/config/key1" ]
    volumeMounts:
    - name: config-volume
      mountPath: /etc/config
  volumes:
  - name: config-volume
    configMap:
      name: my-config
      items:
      - key: key1
        path: key1
  restartPolicy: Never

ConfigMap Updates

Cuando se actualiza un ConfigMap, el contenido del ConfigMap montado como volume se actualiza automáticamente. Sin embargo, los ConfigMaps usados como environment variables requieren reiniciar el Pod para actualizarse.

bash

kubectl edit configmap my-config

yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
data:
  key1: updated-value1
  key2: value2

bash

kubectl apply -f updated-configmap.yaml

Secret

Los Secrets son objetos de API que almacenan información sensible, como passwords, OAuth tokens y SSH keys. Los Secrets son similares a los ConfigMaps, pero proporcionan características de seguridad adicionales para almacenar datos sensibles.

Secret Types

Kubernetes proporciona varios tipos de secrets:

Opaque: Tipo predeterminado, almacena datos arbitrarios definidos por el usuario.
kubernetes.io/service-account-token: Almacena service account tokens.
kubernetes.io/dockercfg: Almacena la forma serializada del archivo .dockercfg.
kubernetes.io/dockerconfigjson: Almacena la forma serializada del archivo .docker/config.json.
kubernetes.io/basic-auth: Almacena credenciales para basic authentication.
kubernetes.io/ssh-auth: Almacena credenciales para SSH authentication.
kubernetes.io/tls: Almacena certificados y keys TLS.
bootstrap.kubernetes.io/token: Almacena datos de bootstrap token.

Secret Creation

Los Secrets se pueden crear de varias maneras:

Imperative

bash

# Create from literal values
kubectl create secret generic my-secret --from-literal=username=admin --from-literal=password=secret

# Create from files
kubectl create secret generic my-secret --from-file=username.txt --from-file=password.txt

# Create TLS secret
kubectl create secret tls my-tls-secret --cert=path/to/cert.crt --key=path/to/key.key

# Create Docker registry secret
kubectl create secret docker-registry my-registry-secret \
  --docker-server=DOCKER_REGISTRY_SERVER \
  --docker-username=DOCKER_USER \
  --docker-password=DOCKER_PASSWORD \
  --docker-email=DOCKER_EMAIL

Declarative

yaml

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  # base64 encoded values
  username: YWRtaW4=  # admin
  password: c2VjcmV0  # secret

O puedes usar el campo stringData para proporcionar valores sin codificar:

yaml

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
stringData:
  # Unencoded values
  username: admin
  password: secret

Secret Usage

Los Secrets se pueden usar en Pods de las siguientes maneras:

Use as Environment Variables

yaml

apiVersion: v1
kind: Pod
metadata:
  name: secret-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "env" ]
    env:
    # Use single key-value pair
    - name: USERNAME
      valueFrom:
        secretKeyRef:
          name: my-secret
          key: username
    # Use all key-value pairs as environment variables
    envFrom:
    - secretRef:
        name: my-secret
  restartPolicy: Never

Mount as Volume

yaml

apiVersion: v1
kind: Pod
metadata:
  name: secret-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "ls /etc/secret/" ]
    volumeMounts:
    - name: secret-volume
      mountPath: /etc/secret
  volumes:
  - name: secret-volume
    secret:
      secretName: my-secret
  restartPolicy: Never

Image Pull Secrets

yaml

apiVersion: v1
kind: Pod
metadata:
  name: private-image-pod
spec:
  containers:
  - name: private-image-container
    image: private-registry.example.com/my-app:v1
  imagePullSecrets:
  - name: my-registry-secret

Secret Security Considerations

Los Secrets se codifican en base64 de forma predeterminada, pero esto no es encryption. Para mejorar la seguridad de los secrets, considera los siguientes métodos:

etcd Encryption: Cifra los secrets almacenados en etcd.
RBAC: Restringe el acceso a los secrets.
Network Policies: Limita los Pods que pueden acceder a los secrets.
External Secret Management Tools: Usa herramientas externas de gestión de secrets como AWS Secrets Manager, HashiCorp Vault, etc.

etcd Encryption Configuration

yaml

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
    - secrets
    providers:
    - aescbc:
        keys:
        - name: key1
          secret: <base64 encoded key>
    - identity: {}

Environment Variables

Las environment variables son una forma sencilla de pasar información de configuración a los contenedores. Kubernetes proporciona varias formas de establecer environment variables.

Direct Setting

yaml

apiVersion: v1
kind: Pod
metadata:
  name: env-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "env" ]
    env:
    - name: ENVIRONMENT
      value: "production"
    - name: LOG_LEVEL
      value: "INFO"
  restartPolicy: Never

Setting from ConfigMap

yaml

apiVersion: v1
kind: Pod
metadata:
  name: env-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "env" ]
    env:
    - name: ENVIRONMENT
      valueFrom:
        configMapKeyRef:
          name: my-config
          key: environment
  restartPolicy: Never

Setting from Secret

yaml

apiVersion: v1
kind: Pod
metadata:
  name: env-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "env" ]
    env:
    - name: DATABASE_PASSWORD
      valueFrom:
        secretKeyRef:
          name: my-secret
          key: password
  restartPolicy: Never

Setting through Downward API

La Downward API te permite exponer información de Pods y contenedores como environment variables.

yaml

apiVersion: v1
kind: Pod
metadata:
  name: downward-api-pod
  labels:
    app: myapp
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "env" ]
    env:
    - name: POD_NAME
      valueFrom:
        fieldRef:
          fieldPath: metadata.name
    - name: POD_NAMESPACE
      valueFrom:
        fieldRef:
          fieldPath: metadata.namespace
    - name: POD_IP
      valueFrom:
        fieldRef:
          fieldPath: status.podIP
    - name: NODE_NAME
      valueFrom:
        fieldRef:
          fieldPath: spec.nodeName
    - name: CONTAINER_CPU_REQUEST
      valueFrom:
        resourceFieldRef:
          containerName: test-container
          resource: requests.cpu
  restartPolicy: Never

Mounting Configuration Through Volumes

Montar archivos de configuración en contenedores mediante volumes proporciona un método de gestión de configuración más flexible que las environment variables.

ConfigMap Volume

yaml

apiVersion: v1
kind: Pod
metadata:
  name: configmap-volume-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "ls -la /etc/config" ]
    volumeMounts:
    - name: config-volume
      mountPath: /etc/config
  volumes:
  - name: config-volume
    configMap:
      name: my-config
  restartPolicy: Never

Secret Volume

yaml

apiVersion: v1
kind: Pod
metadata:
  name: secret-volume-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "ls -la /etc/secret" ]
    volumeMounts:
    - name: secret-volume
      mountPath: /etc/secret
  volumes:
  - name: secret-volume
    secret:
      secretName: my-secret
  restartPolicy: Never

Specific File Mount

yaml

apiVersion: v1
kind: Pod
metadata:
  name: specific-file-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "cat /etc/config/config.properties" ]
    volumeMounts:
    - name: config-volume
      mountPath: /etc/config
  volumes:
  - name: config-volume
    configMap:
      name: my-config
      items:
      - key: config.properties
        path: config.properties
  restartPolicy: Never

Read-only Mount

yaml

apiVersion: v1
kind: Pod
metadata:
  name: readonly-mount-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "ls -la /etc/config" ]
    volumeMounts:
    - name: config-volume
      mountPath: /etc/config
      readOnly: true
  volumes:
  - name: config-volume
    configMap:
      name: my-config
  restartPolicy: Never

SubPath Mount

yaml

apiVersion: v1
kind: Pod
metadata:
  name: subpath-mount-pod
spec:
  containers:
  - name: test-container
    image: busybox
    command: [ "/bin/sh", "-c", "cat /etc/nginx/nginx.conf" ]
    volumeMounts:
    - name: config-volume
      mountPath: /etc/nginx/nginx.conf
      subPath: nginx.conf
  volumes:
  - name: config-volume
    configMap:
      name: my-config
  restartPolicy: Never

Configuration Best Practices

Considera las siguientes best practices al gestionar configuración en Kubernetes:

1. Separate Configuration from Code

Gestiona el código de la aplicación y la configuración por separado. Esto elimina la necesidad de reconstruir la aplicación cuando cambia la configuración.

2. Environment-Specific Configuration Management

Gestiona la configuración por separado para distintos entornos, como development, testing y production. Puedes usar namespaces para separar entornos y usar diferentes ConfigMaps y Secrets para cada entorno.

yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
  namespace: development
data:
  environment: development
  log_level: DEBUG
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
  namespace: production
data:
  environment: production
  log_level: INFO

3. Use Secrets for Sensitive Information

Usa siempre Secrets para almacenar información sensible, como passwords, API keys y certificados. Usa ConfigMaps solo para datos de configuración no sensibles.

4. Maintain Immutability

Al cambiar la configuración, crea una nueva versión en lugar de modificar la existente. Esto facilita los rollbacks y permite rastrear el historial de cambios de configuración.

yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config-v1
data:
  # Configuration data
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config-v2
data:
  # Updated configuration data

5. Restart Pods on Configuration Changes

La configuración usada como environment variables requiere reiniciar el Pod para actualizarse. Usa Deployments para realizar rolling updates.

bash

kubectl rollout restart deployment/my-deployment

6. Validate Configuration

Valida la configuración antes de aplicarla. Una configuración no válida puede provocar fallos en la aplicación.

7. Document Configuration

Documenta las opciones de configuración y sus efectos. Esto ayuda a los miembros del equipo a entender y gestionar la configuración.

Configuration Management in Amazon EKS

En Amazon EKS, puedes usar varios servicios de AWS además de las características básicas de gestión de configuración de Kubernetes para gestionar configuración y secrets. Esta sección cubre varias formas de gestionar configuración en EKS y la integración con servicios de AWS.

AWS Secrets Manager Integration

AWS Secrets Manager es un servicio que te permite almacenar y gestionar de forma segura credenciales de bases de datos, API keys y otra información secreta. En EKS, puedes usar External Secrets Operator o AWS Secrets and Configuration Provider (ASCP) para sincronizar secrets desde AWS Secrets Manager hacia Kubernetes secrets.

External Secrets Operator Installation

bash

# Install External Secrets Operator using Helm
helm repo add external-secrets https://charts.external-secrets.io
helm install external-secrets external-secrets/external-secrets \
  --namespace external-secrets \
  --create-namespace

Create SecretStore

yaml

apiVersion: external-secrets.io/v1beta1
kind: SecretStore
metadata:
  name: aws-secretsmanager
  namespace: my-namespace
spec:
  provider:
    aws:
      service: SecretsManager
      region: us-west-2
      auth:
        jwt:
          serviceAccountRef:
            name: my-serviceaccount

Create ExternalSecret

yaml

apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: database-credentials
  namespace: my-namespace
spec:
  refreshInterval: 1h
  secretStoreRef:
    name: aws-secretsmanager
    kind: SecretStore
  target:
    name: db-credentials
  data:
  - secretKey: username
    remoteRef:
      key: prod/db/credentials
      property: username
  - secretKey: password
    remoteRef:
      key: prod/db/credentials
      property: password

IRSA (IAM Roles for Service Accounts) Setup

External Secrets Operator necesita permisos de IAM adecuados para acceder a AWS Secrets Manager. Puedes usar IRSA para asociar IAM roles con Kubernetes service accounts.

bash

# Create OIDC provider
eksctl utils associate-iam-oidc-provider \
  --cluster my-cluster \
  --approve

# Create IAM role and service account
eksctl create iamserviceaccount \
  --cluster my-cluster \
  --namespace my-namespace \
  --name my-serviceaccount \
  --attach-policy-arn arn:aws:iam::aws:policy/SecretsManagerReadWrite \
  --approve

Using AWS Parameter Store

AWS Systems Manager Parameter Store es un servicio que te permite almacenar y gestionar jerárquicamente datos de configuración y valores secretos. Parameter Store es menos costoso que Secrets Manager y es adecuado para almacenar valores de configuración simples.

ASCP (AWS Secrets and Configuration Provider) Installation

bash

# Install ASCP
helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts
helm install csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver \
  --namespace kube-system

# Install AWS provider
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml

Create SecretProviderClass

yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: aws-parameters
  namespace: my-namespace
spec:
  provider: aws
  parameters:
    objects: |
      - objectName: /my-app/config/log-level
        objectType: ssmparameter
      - objectName: /my-app/config/environment
        objectType: ssmparameter

Using Parameter Store Values in Pods

yaml

apiVersion: v1
kind: Pod
metadata:
  name: parameter-store-pod
  namespace: my-namespace
spec:
  containers:
  - name: app
    image: my-app:latest
    volumeMounts:
    - name: parameters-store-volume
      mountPath: "/mnt/parameters"
      readOnly: true
  volumes:
  - name: parameters-store-volume
    csi:
      driver: secrets-store.csi.k8s.io
      readOnly: true
      volumeAttributes:
        secretProviderClass: aws-parameters

Dynamic Configuration with AWS AppConfig

AWS AppConfig es un servicio que gestiona y despliega configuración de aplicaciones. Usar AppConfig te permite actualizar configuración dinámicamente sin redesplegar aplicaciones.

AppConfig Agent Sidecar Pattern

yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  namespace: my-namespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: my-app:latest
        env:
        - name: CONFIG_PATH
          value: /config/config.json
        volumeMounts:
        - name: config-volume
          mountPath: /config
      - name: appconfig-agent
        image: public.ecr.aws/aws-appconfig/aws-appconfig-agent:2.0
        env:
        - name: AWS_APPCONFIG_EXTENSION_POLL_INTERVAL_SECONDS
          value: "45"
        - name: AWS_APPCONFIG_EXTENSION_POLL_TIMEOUT_SECONDS
          value: "15"
        - name: AWS_APPCONFIG_EXTENSION_HTTP_PORT
          value: "2772"
        - name: AWS_APPCONFIG_EXTENSION_PREFETCH_LIST
          value: '{"Applications":[{"ApplicationId":"MyApp","Environments":[{"EnvironmentId":"Production","Configurations":[{"ConfigurationProfileId":"MyConfig","VersionNumber":null}]}]}]}'
        volumeMounts:
        - name: config-volume
          mountPath: /config
      volumes:
      - name: config-volume
        emptyDir: {}

Configuration with EKS Fargate Profiles

Usar EKS Fargate te permite ejecutar Kubernetes Pods sin gestionar nodes. Puedes configurar el entorno de ejecución del Pod mediante Fargate profiles.

yaml

apiVersion: eks.amazonaws.com/v1beta1
kind: FargateProfile
metadata:
  name: my-profile
  namespace: my-namespace
spec:
  clusterName: my-cluster
  podExecutionRoleArn: arn:aws:iam::123456789012:role/my-pod-execution-role
  selectors:
  - namespace: my-namespace
    labels:
      environment: production
  subnets:
  - subnet-1234567890abcdef0
  - subnet-0abcdef1234567890

Secret Encryption with AWS KMS

Los Kubernetes secrets se codifican en base64 de forma predeterminada, lo cual no es encryption. Puedes usar AWS KMS (Key Management Service) para cifrar secrets en tu EKS cluster.

Create KMS Key

bash

# Create KMS key
aws kms create-key --description "EKS Secret Encryption Key"

# Store key ID
KEY_ID=$(aws kms create-key --query KeyMetadata.KeyId --output text)

# Create key alias
aws kms create-alias --alias-name alias/eks-secrets --target-key-id $KEY_ID

Apply Encryption Configuration to EKS Cluster

bash

# Apply encryption configuration
aws eks update-cluster-config \
  --name my-cluster \
  --encryption-config '[{"resources":["secrets"],"provider":{"keyArn":"arn:aws:kms:us-west-2:123456789012:key/'$KEY_ID'"}}]'

Secret Access Control with AWS IAM

Usar IRSA (IAM Roles for Service Accounts) para asociar IAM roles con Kubernetes service accounts permite que los Pods accedan de forma segura a servicios de AWS.

Create Service Account

yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-service-account
  namespace: my-namespace
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::123456789012:role/my-iam-role

Using Service Account in Pods

yaml

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
  namespace: my-namespace
spec:
  serviceAccountName: my-service-account
  containers:
  - name: app
    image: my-app:latest

EKS Configuration Best Practices

Considera las siguientes best practices al gestionar configuración en EKS:

Use IRSA: Usa siempre IRSA para otorgar permisos mínimos a Pods al acceder a servicios de AWS.
Encrypt Secrets: Usa KMS para cifrar secrets en tu EKS cluster.
External Secret Management: Usa servicios externos de gestión de secrets como AWS Secrets Manager o Parameter Store para gestionar información sensible.
Configuration Version Management: Usa AWS AppConfig o Parameter Store para gestionar versiones de configuración.
Environment-Specific Configuration Separation: Gestiona la configuración por separado para entornos de development, testing y production. Usa Kubernetes namespaces y AWS resource tags.
Minimize IAM Policies: Sigue el principio de mínimo privilegio al acceder a servicios de AWS.
Configuration Automation: Usa herramientas como AWS CloudFormation, AWS CDK o Terraform para automatizar la gestión de configuración.

EKS Configuration Management Tools

Veamos herramientas que ayudan a gestionar configuración en EKS:

AWS Controllers for Kubernetes (ACK)

ACK es una herramienta que te permite gestionar recursos de AWS desde Kubernetes. Usando ACK, puedes crear y gestionar recursos de AWS mediante Kubernetes manifests.

yaml

apiVersion: secretsmanager.services.k8s.aws/v1alpha1
kind: Secret
metadata:
  name: my-secret
spec:
  name: my-secret
  description: "My secret created via ACK"
  forceDeleteWithoutRecovery: true
  generateSecretString:
    excludeCharacters: "\"@/\\"
    excludePunctuation: true
    includeSpace: false
    passwordLength: 16

eksctl

eksctl es una herramienta de línea de comandos para crear y gestionar EKS clusters. Puedes usar eksctl para gestionar la configuración del cluster.

yaml

# cluster.yaml
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
  name: my-cluster
  region: us-west-2
secretsEncryption:
  keyARN: arn:aws:kms:us-west-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab

bash

eksctl create cluster -f cluster.yaml

AWS CDK

AWS CDK (Cloud Development Kit) es una herramienta para definir recursos de AWS usando lenguajes de programación. Puedes usar CDK para definir EKS clusters y recursos relacionados.

typescript

import * as cdk from 'aws-cdk-lib';
import * as eks from 'aws-cdk-lib/aws-eks';
import * as iam from 'aws-cdk-lib/aws-iam';

const app = new cdk.App();
const stack = new cdk.Stack(app, 'EksStack');

// Create EKS cluster
const cluster = new eks.Cluster(stack, 'Cluster', {
  version: eks.KubernetesVersion.V1_21,
  secretsEncryptionKey: new kms.Key(stack, 'Key'),
});

// Create service account
const serviceAccount = cluster.addServiceAccount('ServiceAccount', {
  name: 'my-service-account',
  namespace: 'my-namespace',
});

// Attach IAM policy
serviceAccount.role.addManagedPolicy(
  iam.ManagedPolicy.fromAwsManagedPolicyName('SecretsManagerReadWrite')
);

Conclusion

En este capítulo, aprendimos sobre los métodos de gestión de configuración de Kubernetes. Los ConfigMaps y Secrets proporcionan formas básicas de gestionar la configuración de aplicaciones, y puedes pasar esta configuración a los contenedores mediante environment variables y volumes. También cubrimos best practices de gestión de configuración y herramientas externas de gestión de configuración.

En entornos Amazon EKS, puedes lograr una gestión de configuración más potente y segura usando servicios de AWS junto con las características básicas de gestión de configuración de Kubernetes. Puedes gestionar secrets de forma segura integrando servicios como AWS Secrets Manager, Parameter Store, KMS e IAM, y otorgar permisos mínimos a Pods mediante IRSA. Además, puedes actualizar configuración dinámicamente sin redesplegar aplicaciones usando AWS AppConfig.

La gestión eficaz de configuración es importante para mejorar la mantenibilidad, escalabilidad y seguridad de las aplicaciones Kubernetes. Es importante elegir la estrategia de gestión de configuración adecuada para los requisitos de tu aplicación y seguir best practices. En entornos EKS, puedes crear soluciones de gestión de configuración más potentes mediante la integración con servicios de AWS.

En el próximo capítulo, aprenderemos sobre la seguridad de Kubernetes.

Quiz

Para comprobar lo que aprendiste en este capítulo, intenta el Configuration and Secrets Quiz.

Laboratorios integrales de observabilidad

Cuestionario de ArgoCD en detalle

Cuestionario de Istio detallado

Cuestionario de Linkerd detallado

Cuestionario de Cilium Service Mesh detallado

Profundización en Cilium

Profundización en Calico

Métricas

Registro

Trazado

Alertas

Laboratorios de observabilidad

ArgoCD

Gestión del tráfico

Seguridad

Observabilidad

Resiliencia

Avanzado

Guía comparativa

Métricas

Registro

Trazado

Alertas

Configuration and Secrets ​

Lab Environment Setup ​

Required Tools ​

Configuration Example Setup ​

Configuration Management at a Glance ​

Table of Contents ​

ConfigMap ​

ConfigMap vs Secret Comparison ​

ConfigMap Creation Methods ​

ConfigMap Usage Methods ​

ConfigMap Creation ​

Imperative ​

Declarative ​

ConfigMap Usage ​

Use as Environment Variables ​

Mount as Volume ​

Mount Only Specific Keys ​

ConfigMap Updates ​

Secret ​

Secret Types ​

Secret Creation ​

Imperative ​

Declarative ​

Secret Usage ​

Use as Environment Variables ​

Mount as Volume ​

Image Pull Secrets ​

Secret Security Considerations ​

etcd Encryption Configuration ​

Environment Variables ​

Direct Setting ​

Setting from ConfigMap ​

Setting from Secret ​

Setting through Downward API ​

Mounting Configuration Through Volumes ​

ConfigMap Volume ​

Secret Volume ​

Specific File Mount ​

Read-only Mount ​

SubPath Mount ​

Configuration Best Practices ​

1. Separate Configuration from Code ​

2. Environment-Specific Configuration Management ​

3. Use Secrets for Sensitive Information ​

4. Maintain Immutability ​

5. Restart Pods on Configuration Changes ​

6. Validate Configuration ​

7. Document Configuration ​

Configuration Management in Amazon EKS ​

AWS Secrets Manager Integration ​

External Secrets Operator Installation ​

Create SecretStore ​

Create ExternalSecret ​

IRSA (IAM Roles for Service Accounts) Setup ​

Using AWS Parameter Store ​

ASCP (AWS Secrets and Configuration Provider) Installation ​

Create SecretProviderClass ​

Configuration and Secrets

Lab Environment Setup

Required Tools

Configuration Example Setup

Configuration Management at a Glance

Table of Contents

ConfigMap

ConfigMap vs Secret Comparison

ConfigMap Creation Methods

ConfigMap Usage Methods

ConfigMap Creation

Imperative

Declarative

ConfigMap Usage

Use as Environment Variables

Mount as Volume

Mount Only Specific Keys

ConfigMap Updates

Secret

Secret Types

Secret Creation

Imperative

Declarative

Secret Usage

Use as Environment Variables

Mount as Volume

Image Pull Secrets

Secret Security Considerations

etcd Encryption Configuration

Environment Variables

Direct Setting

Setting from ConfigMap

Setting from Secret

Setting through Downward API

Mounting Configuration Through Volumes

ConfigMap Volume

Secret Volume

Specific File Mount

Read-only Mount

SubPath Mount

Configuration Best Practices

1. Separate Configuration from Code

2. Environment-Specific Configuration Management

3. Use Secrets for Sensitive Information

4. Maintain Immutability

5. Restart Pods on Configuration Changes

6. Validate Configuration

7. Document Configuration

Configuration Management in Amazon EKS

AWS Secrets Manager Integration

External Secrets Operator Installation

Create SecretStore

Create ExternalSecret

IRSA (IAM Roles for Service Accounts) Setup

Using AWS Parameter Store

ASCP (AWS Secrets and Configuration Provider) Installation

Create SecretProviderClass

Using Parameter Store Values in Pods

Dynamic Configuration with AWS AppConfig

AppConfig Agent Sidecar Pattern

Configuration with EKS Fargate Profiles

Secret Encryption with AWS KMS

Create KMS Key

Apply Encryption Configuration to EKS Cluster

Secret Access Control with AWS IAM

Create Service Account

Using Service Account in Pods

EKS Configuration Best Practices

EKS Configuration Management Tools

AWS Controllers for Kubernetes (ACK)

eksctl

AWS CDK

Conclusion

Quiz

References