Note:

Este tutorial requiere acceso a Oracle Cloud. Para registrarse en una cuenta gratuita, consulte Introducción a la capa gratuita de Oracle Cloud Infrastructure.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al completar el laboratorio, sustituya estos valores por otros específicos de su entorno en la nube.

Protección de servicios web de Kubernetes mediante el controlador de entrada de Nginx, el proxy OAuth2 y los dominios de identidad de Oracle

Introducción

La protección de los servicios web alojados de Kubernetes debe ser fácil. Tanto si la aplicación carece de soporte incorporado para la integración del proveedor de identidad externo (IdP) como si necesita una solución de conexión única (SSO) para simplificar la gestión y reducir la necesidad de mecanismos de autenticación individuales por servicio, el proxy OAuth2 ofrece la flexibilidad de conectar cualquier aplicación a casi cualquier proveedor de identidad (IdP).

OAuth2 El proxy actúa como un proxy inverso frente a los servicios de Kubernetes. Intercepta el tráfico, redirige a los usuarios a un servidor de autorización externo (como Okta o GitHub) para conectarse y valida los tokens de acceso antes de reenviar las solicitudes a los servicios de backend.

Objetivo

Despliegue una aplicación web sencilla en Kubernetes, exponga la aplicación mediante el controlador de entrada de Nginx y configure el proxy OAuth2 para utilizar los dominios de identidad de Oracle como IdP.

Requisitos

Acceso a un arrendamiento de Oracle Cloud Infrastructure (OCI).
Cluster de Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) configurado para utilizar una subred pública para equilibradores de carga.
(Opcional) Acceso para actualizar registros para un dominio del sistema de nombres de dominio (DNS).

Tarea 1: Creación de un cluster de OKE

Conéctese a la consola de OCI, vaya a Oracle Container Engine for Kubernetes y haga clic en Crear.
En el asistente Crear cluster, haga clic en Creación rápida.
Introduzca la siguiente información y haga clic en Siguiente.
- Nombre: introduzca el nombre del cluster.
- Versión de Kubernetes: seleccione la versión que desea utilizar.
- Puntos finales de API de Kubernetes: seleccione Punto final público.
- Tipo de nodo: seleccione Gestionado.
- Nodos de trabajo de Kubernetes: seleccione Trabajadores privados.
- Recuento de nodos: 1.
Revise y haga clic en Crear cluster. Espere a que el cluster esté disponible.
Actualice la lista de seguridad asociada a la subred del servicio.
1. Haga clic en la subred de servicio.
2. Haga clic en Security List (Lista de seguridad) y agregue las siguientes reglas.
  - Ingress:
  - Salida:
Actualice la lista de seguridad asociada a la subred de nodos de trabajador para permitir conexiones desde los equilibradores de carga.
1. Haga clic en el nombre de la VCN.
2. En Recursos, seleccione Listas de seguridad y haga clic en la lista de seguridad de nodos.
3. Agregue la siguiente regla de entrada a la lista de seguridad de nodos.
4. Haga clic en Agregar reglas de entrada.

Tarea 2: Configuración del controlador de entrada de Nginx

Una vez que el cluster esté disponible, puede acceder al cluster mediante OCI Cloud Shell. Haga clic en Acceder a cluster y copie y ejecute el siguiente comando en OCI Cloud Shell.
Ejecute el comando kubectl get node para obtener la lista de nodos disponibles.
Agregue el repositorio de cascos del controlador de entrada de Nginx. Para obtener más información, consulte Visión general del controlador NGINX de entrada y helm.
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
```

Cree el archivo values-override.yaml.

controller:
  allowSnippetAnnotations: true
  service:
    annotations:
      oci.oraclecloud.com/load-balancer-type: "lb"
      service.beta.kubernetes.io/oci-load-balancer-backend-protocol: "TCP"
      service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
      service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "10"
      service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "10"

Despliegue el controlador de entrada de Nginx.

helm install ingress-nginx ingress-nginx/ingress-nginx -f values-override.yaml

Guarde el siguiente archivo yaml denominado application.yaml.

---
# Create ClusterIP service
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  labels:
    app: httpbin
spec:
  ports:
  - port: 5000
    targetPort: 5000
  selector:
    app: httpbin
---
# Deployment of a sample web application
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
spec:
  replicas: 2
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      containers:
      - image: mendhak/http-https-echo
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 5000
        env:
        - name: HTTP_PORT
          value: "5000"

Cree los recursos de aplicación.
```
kubectl apply -f application.yaml
```
Cree un registro DNS para la dirección IP pública asociada al equilibrador de carga.
- Obtenga la dirección IP pública del equilibrador de carga.
```
$ kubectl get svc ingress-nginx-controller
NAME                       TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)                      AGE
ingress-nginx-controller   LoadBalancer   10.96.152.30   158.180.61.74   80:31957/TCP,443:30838/TCP   32s
```
- Cree el registro de DNS. Si no tiene un servidor DNS, nos basaremos en el servicio DNS comodín gratuito nip.io.
En este caso, el FQDN es 158-180-61-74.nip.io.

Guarde el siguiente archivo yaml denominado ingress.yaml.

Nota: Asegúrese de actualizar las entradas de host con el FQDN.

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: httpbin-ingress-nginx
spec:
  ingressClassName: nginx
  tls:
  - hosts:
      - "<YOUR-FQDN>"
  rules:
    - host: "<YOUR-FQDN>"
      http:
        paths:
          - pathType: Prefix
            path: "/"
            backend:
              service:
                name: httpbin
                port:
                  number: 5000

Ejecute el siguiente comando para crear el recurso de entrada.
```
kubectl apply -f ingress.yaml
```

Pruebe la conectividad con el servicio.

$ curl -k https://<YOUR-FQDN> 
{
  "path": "/",
  "headers": {
    "host": "158-180-61-74.nip.io",
    "x-request-id": "b0320217391a922acecbfe10758b3ffe",
    "x-real-ip": "10.0.10.167",
    "x-forwarded-for": "10.0.10.167",
    "x-forwarded-host": "158-180-61-74.nip.io",
    "x-forwarded-port": "443",
    "x-forwarded-proto": "https",
    "x-forwarded-scheme": "https",
    "x-scheme": "https",
    "user-agent": "curl/7.87.0",
    "accept": "*/*"
  },
  "method": "GET",
  "body": "",
  "fresh": false,
  "hostname": "158-180-61-74.nip.io",
  "ip": "10.0.10.167",
  "ips": [
    "10.0.10.167"
  ],
  "protocol": "https",
  "query": {},
  "subdomains": [
    "158-180-61-74"
  ],
  "xhr": false,
  "os": {
    "hostname": "httpbin-644874bcdb-ll4mb"
  },
  "connection": {}
}

Tarea 3: Configuración de una aplicación confidencial en dominios de identidad de Oracle

Vaya a Dominios de identidad de Oracle en la consola de OCI y haga clic en el dominio OracleIdentityCloudService.
Seleccione Aplicaciones integradas en el menú de la izquierda y haga clic en Agregar aplicación.
Seleccione Aplicación Confidencial y haga clic en Iniciar Flujo de Trabajo.
Introduzca el nombre, la descripción y haga clic en Siguiente.
Configure los parámetros oAuth de la aplicación.
1. En la sección Autorización, seleccione Código de autorización.
2. Introduzca las siguientes URL y haga clic en Siguiente.
  - URL de redirección: https://<YOUR-FQDN>/oauth2/callback.
  - URL de redirección posterior a la desconexión: https://<YOUR-FQDN>.
  - URL de desconexión: https://<YOUR-FQDN>/oauth2/sign_out.
En Política de nivel web, seleccione Omitir y hacer más tarde y haga clic en Terminar.
Haga clic en Activar para activar la aplicación.
Vaya a Grupos en el menú de la izquierda y asocie los grupos de usuarios que pueden autenticarse con esta aplicación.
Tenga en cuenta el ID de Cliente y el Secreto de Cliente.
Haga clic en el dominio OracleIdentityCloudService y expanda la URL de dominio.

Por ejemplo: la URL de dominio de identidad será https://idcs-01234567890abcdef.identity.oraclecloud.com (se borra el número de puerto).

Tarea 4: Despliegue del proxy OAuth2

Estamos utilizando el proxy OAuth2 para manejar la complejidad de OAuth2 o OpenID Connect (OIDC) y garantizar que todas las solicitudes reenviadas a las aplicaciones se autentican.

Guarde el siguiente archivo yaml denominado oauth2-proxy.yaml y sustituya los marcadores de posición por los valores aplicables.

Nota:

<Identity Domain URL>: https://idcs-01234567890abcdef.identity.oraclecloud.com/

<Identity Domain FQDN>: idcs-01234567890abcdef.identity.oraclecloud.com

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    k8s-app: oauth2-proxy
  name: oauth2-proxy
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: oauth2-proxy
  template:
    metadata:
      labels:
        k8s-app: oauth2-proxy
    spec:
      containers:
      - args:
        - --provider=oidc
        - --provider-display-name="Oracle Identity Domains"
        - --oidc-issuer-url=<Identity Domain URL>
        - --redirect-url=https://<YOUR-FQDN>/oauth2/callback
        - --upstream=file:///dev/null
        - --http-address=0.0.0.0:4180
        - --email-domain=*
        - --set-xauthrequest=true
        - --session-cookie-minimal=true
        - --whitelist-domain=<Identity Domain FQDN>
        env:
        - name: OAUTH2_PROXY_CLIENT_ID
          value: "<APPLICATION_CLIENT_ID>"
        - name: OAUTH2_PROXY_CLIENT_SECRET
          value: "<APPLICATION_CLIENT_SECRET>"
        # docker run -ti --rm python:3-alpine python -c 'import secrets,base64; print(base64.b64encode(base64.b64encode(secrets.token_bytes(16))));'     
        - name: OAUTH2_PROXY_COOKIE_SECRET
          value: "<OUTPUT_OF_THE_ABOVE_DOCKER_COMMAND>"
        image: quay.io/oauth2-proxy/oauth2-proxy:latest
        imagePullPolicy: Always
        name: oauth2-proxy
        ports:
        - containerPort: 4180
          protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  labels:
    k8s-app: oauth2-proxy
  name: oauth2-proxy
spec:
  ports:
  - name: http
    port: 4180
    protocol: TCP
    targetPort: 4180
  selector:
    k8s-app: oauth2-proxy
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: oauth2-proxy
  annotations:
    nginx.ingress.kubernetes.io/configuration-snippet: |
      set $xheader "";
      if ( $request_uri = "/oauth2/sign_out" ){
        set $xheader "https://<Identity Domain FQDN>/oauth2/v1/userlogout;
      }
      proxy_set_header X-Auth-Request-Redirect ${xheader};
spec:
  ingressClassName: nginx
  rules:
  - host: <YOUR-FQDN>
    http:
      paths:
      - path: /oauth2
        pathType: Prefix
        backend:
          service:
            name: oauth2-proxy
            port:
              number: 4180
  tls:
  - hosts:
    - <YOUR-FQDN>

Despliegue el proxy OAuth2 en OKE.

kubectl apply -f oauth2-proxy.yaml

Confirme que el pod se está ejecutando.

kubectl get pods -l k8s-app=oauth2-proxy

Configure Nginx para utilizar el proxy OAuth2 para la autenticación de solicitudes.

Actualice el archivo ingress.yaml con las anotaciones de autenticación.

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: httpbin-ingress-nginx
  annotations:
    nginx.ingress.kubernetes.io/auth-url: "https://$host/oauth2/auth"
    nginx.ingress.kubernetes.io/auth-signin: "https://$host/oauth2/start?rd=$escaped_request_uri"
    nginx.ingress.kubernetes.io/auth-response-headers: "x-auth-request-user, x-auth-request-email"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
      - "<YOUR-FQDN>"
  rules:
    - host: "<YOUR-FQDN>"
      http:
        paths:
          - pathType: Prefix
            path: "/"
            backend:
              service:
                name: httpbin
                port:
                  number: 5000

Intente conectarse a la aplicación. Se le debe redirigir a la página de autenticación de Oracle. Una vez que la autenticación se haya realizado correctamente, se le redirigirá a la aplicación.

Hay dos cabeceras que identifican al usuario autenticado.
```
"x-auth-request-user": "xxxx@oracle.com"
"x-auth-request-email": "xxxx@oracle.com"
```
Para desconectarse de la aplicación, puede ir a /oauth2/sign_out en la página.
```
https://<YOUR-FQDN>/oauth2/sign_out
```
Problema conocido: el redireccionamiento posterior a la desconexión no funciona. Se realiza un seguimiento de este problema aquí: Agregar un parámetro id_token_hint a la URL del proveedor de desconexión para el proveedor de OIDC.

Tarea 5: Limpiar recursos

Ejecute el siguiente comando para suprimir todos los recursos desplegados de Kubernetes.

kubectl delete -f oauth2-proxy.yaml -f ingress.yaml -f application.yaml
helm uninstall ingress-nginx

Suprima la aplicación de los dominios de identidad de Oracle.
Suprima el cluster de OKE.
Suprima la VCN creada para el cluster de OKE.
Nota:
- Debe esperar a que finalice la supresión del cluster y el pool de nodos de OKE.
- El nombre de la VCN contiene el nombre del cluster de OKE: oke-vcn-quick-<oke-cluster-name>-<random-string>.

Agradecimientos

Autor: Andrei Ilas (Arquitecto principal de la nube)

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.

Título e Información de Copyright

Secure Kubernetes Web Services using Nginx Ingress Controller, OAuth2 Proxy, and Oracle Identity Domains

F96451-01

April 2024

Oracle y/o sus filiales.