Nota

Questa esercitazione richiede l'accesso a Oracle Cloud. Per iscriverti a un account gratuito, consulta Inizia a utilizzare Oracle Cloud Infrastructure Free Tier.
Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti di Oracle Cloud Infrastructure. Al termine del laboratorio, sostituisci questi valori con quelli specifici del tuo ambiente cloud.

Proteggi i servizi Web Kubernetes utilizzando il controller di entrata Nginx, il proxy OAuth2 e i domini di Identity Oracle

Introduzione

La protezione dei servizi Web in hosting Kubernetes deve essere semplice. Se la tua applicazione non dispone del supporto integrato per l'integrazione di provider di identità esterno (IdP) o hai bisogno di una soluzione Single Sign-On (SSO) per semplificare la gestione e ridurre la necessità di singoli meccanismi di autenticazione per servizio, OAuth2 Proxy offre la flessibilità di connettere qualsiasi applicazione a quasi tutti i provider di identità (IdP).

OAuth2 Il proxy funge da proxy inverso davanti ai servizi Kubernetes. Intercetta il traffico, reindirizza gli utenti a un server di autorizzazione esterno (come Okta o GitHub) per il login e convalida i token di accesso prima di inoltrare le richieste ai servizi backend.

Obiettivo

Distribuire una semplice applicazione Web in Kubernetes, esporla utilizzando il controller di entrata Nginx e configurare il proxy OAuth2 in modo che utilizzi i domini di Identity Oracle come IdP.

Prerequisiti

Accesso a una tenancy Oracle Cloud Infrastructure (OCI).
Un cluster OKE (Oracle Cloud Infrastructure Container Engine for Kubernetes) configurato per utilizzare una subnet pubblica per i load balancer.
(Facoltativo) Accesso per aggiornare i record per un dominio DNS (Domain Name System).

Task 1: creare un cluster OKE

Eseguire il login a OCI Console, passare a Oracle Container Engine for Kubernetes e fare clic su Crea.
Nella procedura guidata Crea cluster fare clic su Creazione rapida.
Immettere le informazioni riportate di seguito e fare clic su Successivo.
- Nome: immettere il nome del cluster.
- Versione Kubernetes: selezionare la versione che si desidera utilizzare.
- Endpoint API Kubernetes: selezionare endpoint pubblico.
- Tipo di nodo: selezionare Gestito.
- Nodi di lavoro Kubernetes: selezionare Lavoratori privati.
- Conteggio nodi: 1.
Rivedere e fare clic su Crea cluster. Attendere che il cluster diventi disponibile.
Aggiornare la lista di sicurezza associata alla subnet del servizio.
1. Fare clic su Subnet di servizio.
2. Fare clic su Elenco di sicurezza e aggiungere le regole riportate di seguito.
  - Ingresso:
  - Uscita:
Aggiornare la lista di sicurezza associata alla subnet dei nodi di lavoro per consentire le connessioni dai load balancer.
1. Fare clic sul nome della VCN.
2. In Risorse selezionare Elenchi di sicurezza e fare clic sulla lista di sicurezza dei nodi.
3. Aggiungere la seguente regola di entrata alla lista di sicurezza dei nodi.
4. Fare clic su Aggiungi regole di entrata.

Task 2: impostare il controller di entrata Nginx

Una volta che il cluster è disponibile, puoi accedervi utilizzando OCI Cloud Shell. Fare clic su Accedi al cluster, quindi copiare ed eseguire il comando seguente in OCI Cloud Shell.
Eseguire il comando kubectl get node per ottenere la lista dei nodi disponibili.
Aggiungere il repository helm del controller di entrata Nginx. Per ulteriori informazioni, vedere Panoramica del controller NGINX in entrata e helm.
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
```

Creare il file 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"

Distribuire il controller di entrata Nginx.

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

Salvare il file yaml seguente denominato 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"

Creare le risorse dell'applicazione.
```
kubectl apply -f application.yaml
```
Crea un record DNS per l'indirizzo IP pubblico associato al load balancer.
- Recupera l'indirizzo IP pubblico del load balancer.
```
$ 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
```
- Creare il record DNS. Se non si dispone di un server DNS, il servizio DNS con caratteri jolly è gratuito nip.io.
In questo caso il nome FQDN è 158-180-61-74.nip.io.

Salvare il file yaml seguente denominato ingress.yaml.

Nota: assicurarsi di aggiornare le voci host con il nome 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

Eseguire il comando seguente per creare la risorsa in entrata.
```
kubectl apply -f ingress.yaml
```

Eseguire il test della connettività al servizio.

$ 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": {}
}

Task 3: impostare un'applicazione riservata nei domini di Identity Oracle

Passare a Domini di Identity Oracle nella console OCI e fare clic sul dominio OracleIdentityCloudService.
Selezionare Applicazioni integrate dal menu a sinistra, quindi fare clic su Aggiungi applicazione.
Selezionare Applicazione riservata e fare clic su Avvia workflow.
Immettere il nome, la descrizione e fare clic su Successivo dell'applicazione.
Configurare i parametri oAuth dell'applicazione.
1. Nella sezione Autorizzazione, selezionare Codice autorizzazione.
2. Immettere gli URL riportati di seguito e fare clic su Successivo.
  - URL di reindirizzamento: https://<YOUR-FQDN>/oauth2/callback.
  - URL di reindirizzamento dopo logout: https://<YOUR-FQDN>.
  - URL di logout: https://<YOUR-FQDN>/oauth2/sign_out.
In Criterio livello Web, selezionare Ignora ed esegui in seguito e fare clic su Fine.
Fare clic su Attiva per abilitare l'applicazione.
Passare a Gruppi nel menu a sinistra e associare i gruppi di utenti autorizzati a eseguire l'autenticazione a questa applicazione.
Prendere nota di Client ID e Client Secret.
Fare clic sul dominio OracleIdentityCloudService ed espandere l'URL del dominio.

Ad esempio: l'URL del dominio di Identity sarà https://idcs-01234567890abcdef.identity.oraclecloud.com (il numero di porta viene rimosso).

Task 4: distribuire il proxy OAuth2

Stiamo utilizzando il proxy OAuth2 per gestire la complessità OAuth2 o OpenID Connect (OIDC) e garantire l'autenticazione di tutte le richieste inoltrate alle applicazioni.

Salvare il file yaml seguente denominato oauth2-proxy.yaml e sostituire i segnaposto con i valori applicabili.

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>

Distribuire il proxy OAuth2 in OKE.

kubectl apply -f oauth2-proxy.yaml

Verificare che il pod sia in esecuzione.

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

Configurare Nginx in modo che utilizzi il proxy OAuth2 per l'autenticazione delle richieste.

Aggiornare il file ingress.yaml con le annotazioni di autenticazione.

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

Provare a connettersi all'applicazione. Si dovrebbe essere reindirizzati alla pagina di autenticazione Oracle. Una volta completata l'autenticazione, è necessario essere reindirizzati all'applicazione.

Esistono due intestazioni che identificano l'utente autenticato.
```
"x-auth-request-user": "xxxx@oracle.com"
"x-auth-request-email": "xxxx@oracle.com"
```
Per uscire dall'applicazione, è possibile accedere a /oauth2/sign_out nella pagina.
```
https://<YOUR-FQDN>/oauth2/sign_out
```
Problema noto: il reindirizzamento successivo alla disconnessione non funziona. Questo problema viene registrato qui: aggiungere un parametro id_token_hint all'URL del provider di logout per il provider OIDC.

Task 5: Cancella risorse

Eseguire il comando riportato di seguito per eliminare tutte le risorse distribuite Kubernetes.

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

Eliminare l'applicazione dai domini di Identity Oracle.
Eliminare il cluster OKE.
Eliminare la VCN creata per il cluster OKE.
Nota:
- È necessario attendere la fine dell'eliminazione del cluster OKE e del pool di nodi.
- Il nome della VCN contiene il nome del cluster OKE: oke-vcn-quick-<oke-cluster-name>-<random-string>.

Conferme

Autore - Andrei Ilas (Principal Cloud Architect)

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare un Oracle Learning Explorer.

Per la documentazione del prodotto, visita l'Oracle Help Center.

Titolo e informazioni sul copyright

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

F96454-01

April 2024

Oracle e/o relative consociate.