En kubernetes: cómo configurar mtls en ingress controller nginx para path /api y root path / sin Autenticación Port https

Para configurar mTLS (Mutual Transport Layer Security) en un Ingress Controller de Nginx en Kubernetes para los paths /api y root path / sin autenticación y en el puerto HTTPS, puedes seguir estos pasos:

1. Asegúrate de tener un certificado SSL/TLS válido para tu dominio. Puedes obtener uno de una entidad certificadora confiable o utilizar Let's Encrypt.

2. Configura el Secret de Kubernetes con tu certificado TLS. Puedes crear un archivo YAML similar al siguiente ejemplo:

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: tls-secret
  namespace: default
type: kubernetes.io/tls
data:
  tls.crt: <base64-encoded-certificate>
  tls.key: <base64-encoded-private-key>
```

Reemplaza `<base64-encoded-certificate>` y `<base64-encoded-private-key>` con los valores en base64 de tu certificado y clave privada respectivamente.

3. Crea un archivo de configuración para Nginx que incluya la configuración necesaria para habilitar mTLS y el Ingress Controller. Puedes crear un archivo similar al siguiente ejemplo:

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-config
  namespace: default
data:
  nginx.conf: |
    worker_processes auto;
    events {
      worker_connections 1024;
    }
    
    http {
      include /etc/nginx/mime.types;
      default_type application/octet-stream;

      ssl_certificate /etc/nginx/certs/tls.crt;
      ssl_certificate_key /etc/nginx/certs/tls.key;

      server {
        listen 443 ssl;

        location /api {
          # Configuración específica para /api sin mTLS si es necesario

          # ...
        }

        location / {
          # Configuración específica para el root path sin mTLS si es necesario

          # ...
        }
      }
    }
```

Reemplaza `/etc/nginx/certs/tls.crt` y `/etc/nginx/certs/tls.key` con las rutas correspondientes a los archivos del Secret creado en el paso 2.

4. Crea un Deployment y un Service para tu Ingress Controller de Nginx utilizando la imagen `nginxinc/nginx-ingress`. Puedes utilizar un archivo YAML similar al siguiente ejemplo:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-ingress-controller
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-ingress-controller
  template:
    metadata:
      labels:
        app: nginx-ingress-controller
    spec:
      containers:
        - name: nginx-ingress-controller
          image: nginxinc/nginx-ingress:1.13.12
          args:
            - /nginx-ingress-controller
            - --configmap=$(POD_NAMESPACE)/nginx-config
          env:
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
          ports:
            - containerPort: 80
            - containerPort: 443

---

apiVersion: v1
kind: Service
metadata:
  name: nginx-ingress-service
  namespace: default
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
    - port: 443
      targetPort: 443
      protocol: TCP
  selector:
    app: nginx-ingress-controller
```

Este archivo creará un Deployment con un pod utilizando la imagen de Nginx Ingress Controller y un Service para exponer el controlador.

5. Crea un Ingress para tu aplicación que especifique las reglas necesarias para los paths /api y root path /. Puedes utilizar un archivo YAML similar al siguiente ejemplo:

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app-ingress
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  tls:
    - secretName: tls-secret
      hosts:
        - example.com
  rules:
    - host: example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api-service
                port:
                  number: 8080
          - path: /
            pathType: Prefix
            backend:
              service:
                name: root-service
                port:
                  number: 8080
```

Reemplaza `example.com` con tu dominio y `api-service` y `root-service` con los nombres de tus servicios correspondientes.

6. Aplica los archivos YAML creados en los pasos anteriores utilizando el comando `kubectl apply -f <nombre-archivo.yaml>`.

Estos pasos deberían configurar mTLS en tu Ingress Controller de Nginx en Kubernetes para los paths /api y root path / sin autenticación y en el puerto HTTPS.