Kubernetes deployment con Ingress, Configmap y Secrets

Esto funciona para:
Minikube (con MetalLB o Tunnel)
K3s / Kind + MetalLB
Clusters bare-metal
Clouds (EKS, GKE, AKS, DO, Linode…)

Incluye:
✔ Namespace
✔ ConfigMap
✔ Secret
✔ Deployment
✔ Service
✔ Ingress
✔ NGINX Ingress Controller expuesto por LoadBalancer

Todo lo necesario para tener tu aplicación accesible desde Internet / LAN.

📦 ESTRUCTURA FINAL DE MANIFIESTOS
k8s/
├── 00-namespace.yaml
├── 01-configmap.yaml
├── 02-secret.yaml
├── 03-deployment.yaml
├── 04-service.yaml
├── 05-ingress.yaml
└── 10-ingress-controller.yaml

Puedes guardar estos archivos y aplicar todo con:

kubectl apply -f k8s/

🟦 00-namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: myapp-namespace

🟦 01-configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
  namespace: myapp-namespace
data:
  APP_ENV: "production"
  APP_MESSAGE: "Hola desde ConfigMap!"

🟦 02-secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: myapp-secret
  namespace: myapp-namespace
type: Opaque
data:
  DB_PASSWORD: c3VwZXJwYXNzd29yZA==  # superpassword
  API_KEY: YXBpa2V5MTIzNDU=

🟦 03-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
  namespace: myapp-namespace
spec:
  replicas: 2
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: juanjo/myapp:1.0
          ports:
            - containerPort: 8080
          env:
            - name: APP_ENV
              valueFrom:
                configMapKeyRef:
                  name: myapp-config
                  key: APP_ENV

            - name: APP_MESSAGE
              valueFrom:
                configMapKeyRef:
                  name: myapp-config
                  key: APP_MESSAGE

            - name: DB_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: myapp-secret
                  key: DB_PASSWORD

            - name: API_KEY
              valueFrom:
                secretKeyRef:
                  name: myapp-secret
                  key: API_KEY

          readinessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 5

          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 10

🟦 04-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: myapp-service
  namespace: myapp-namespace
spec:
  selector:
    app: myapp
  ports:
    - port: 80
      targetPort: 8080
  type: ClusterIP

🟦 05-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  namespace: myapp-namespace
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
    - host: myapp.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: myapp-service
                port:
                  number: 80

📌 Podrás acceder con:

http://myapp.example.com

(Lo apuntas a la IP pública del LoadBalancer).

🟥 10-ingress-controller.yaml (NGINX expuesto hacia el exterior por LoadBalancer)

Este incluye:

✔ Deployment del controller
✔ Service tipo LoadBalancer
✔ IngressClass (nginx)

📄 Este archivo hace que tu Ingress sea accesible desde fuera del cluster.

apiVersion: v1
kind: Namespace
metadata:
  name: ingress-nginx
---
apiVersion: ingress-nginx.cloud/v1
kind: IngressClass
metadata:
  name: nginx
spec:
  controller: k8s.io/ingress-nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ingress-nginx-controller
  namespace: ingress-nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ingress-nginx-controller
  template:
    metadata:
      labels:
        app: ingress-nginx-controller
    spec:
      serviceAccountName: ingress-nginx
      containers:
      - name: controller
        image: registry.k8s.io/ingress-nginx/controller:v1.11.0
        args:
        - "/nginx-ingress-controller"
        - "--ingress-class=nginx"
        ports:
        - containerPort: 80
        - containerPort: 443
---
apiVersion: v1
kind: Service
metadata:
  name: ingress-nginx-controller
  namespace: ingress-nginx
spec:
  type: LoadBalancer
  selector:
    app: ingress-nginx-controller
  ports:
  - name: http
    port: 80
    targetPort: 80
  - name: https
    port: 443
    targetPort: 443

ACCESO DESDE EL EXTERIOR

🔵 1. En cloud (EKS, GKE, AKS, DO, Linode…)
Con LoadBalancer, simplemente:

kubectl get svc -n ingress-nginx

Verás:
ingress-nginx-controller LoadBalancer EXTERNAL-IP 34.122.93.10

Entonces accedes directamente: http://34.122.93.10

O en tu DNS:
myapp.example.com -> 34.122.93.10

🔵 2. En Minikube
Activa MetalLB o usa Tunnel:

Opción A: Minikube Tunnel (más simple)
minikube tunnel

Te aparecerá una IP EXTERNAL-IP para el LoadBalancer:

Ejemplo:
192.168.49.100

Accede:
http://192.168.49.100

🔵 3. Bare-metal / k3s / kind + MetalLB
Si usas MetalLB, asignará una IP externa al LoadBalancer.

Ejemplo:
kubectl get svc -n ingress-nginx
ingress-nginx-controller LoadBalancer 192.168.1.220

Acceso:
http://192.168.1.220

Y si usas dominio:
myapp.example.com A 192.168.1.220