Note :

Ce tutoriel nécessite l'accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, voir Introduction à l' niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles propres à votre environnement en nuage.

Sécuriser les services Web de Kubernetes à l'aide du contrôleur de trafic entrant Nginx, du mandataire OAuth2 et des domaines d'identité Oracle

Présentation

La sécurisation des services Web hébergés par Kubernetes doit être facile. Que votre application ne prenne pas en charge l'intégration de fournisseur d'identités externe (IdP) ou que vous ayez besoin d'une solution d'authentification unique pour simplifier la gestion et réduire le besoin de mécanismes d'authentification individuels par service, le mandataire OAuth2 offre la flexibilité nécessaire pour connecter n'importe quelle application à presque n'importe quel fournisseur d'identités (IdP).

OAuth2 Le mandataire agit comme un mandataire inverse assis devant vos services Kubernetes. Il intercepte le trafic, redirige les utilisateurs vers un serveur d'autorisations externe (comme Okta ou GitHub) pour la connexion, et valide les jetons d'accès avant de transmettre les demandes aux services dorsaux.

Objectif

Déployez une application Web simple sur Kubernetes, exposez-la à l'aide du contrôleur de trafic entrant Nginx et configurez le mandataire OAuth2 pour utiliser les domaines d'identité Oracle en tant que IdP.

Préalables

Accès à une location Oracle Cloud Infrastructure (OCI).
Une grappe Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) configurée pour utiliser un sous-réseau public pour les équilibreurs de charge.
(Facultatif) Accès pour mettre à jour les enregistrements d'un domaine de système de noms de domaine (DNS).

Tâche 1 : Créer une grappe OKE

Connectez-vous à la console OCI, naviguez jusqu'à Oracle Container Engine for Kubernetes, puis cliquez sur Créer.
Dans l'assistant Créer une grappe, cliquez sur Création rapide.
Entrez les informations suivantes et cliquez sur Suivant.
- Nom : Entrez le nom de la grappe.
- Version de Kubernetes : Sélectionnez la version à utiliser.
- Points d'extrémité d'API Kubernetes : Sélectionnez Point d'extrémité public.
- Type de noeud : Sélectionnez Géré.
- Noeuds de travail Kubernetes : Sélectionnez Travailleurs privés.
- Nombre de noeuds : 1.
Vérifiez et cliquez sur Créer une grappe. Attendez que la grappe soit disponible.
Mettez à jour la liste de sécurité associée au sous-réseau de service.
1. Cliquez sur le sous-réseau de service.
2. Cliquez sur Liste de sécurité et ajoutez les règles suivantes.
  - Entrant :
  - Sortant :
Mettez à jour la liste de sécurité associée au sous-réseau de noeuds de travail pour autoriser les connexions à partir des équilibreurs de charge.
1. Cliquez sur le nom du réseau VCN.
2. Sous ressources, sélectionnez Listes de sécurité et cliquez sur la liste de sécurité des noeuds.
3. Ajoutez la règle de trafic entrant suivante à la liste de sécurité des noeuds.
4. Cliquez sur Ajouter des règles de trafic entrant.

Tâche 2 : Configurer le contrôleur de trafic entrant Nginx

Une fois la grappe disponible, vous pouvez y accéder à l'aide de Cloud Shell pour OCI. Cliquez sur Accéder à la grappe, puis copiez et exécutez la commande suivante dans OCI Cloud Shell.
Exécutez la commande kubectl get node pour obtenir la liste des noeuds disponibles.
Ajoutez le référentiel de commandes du contrôleur de trafic entrant Nginx. Pour plus d'informations, voir Aperçu du contrôleur NGINX entrant et Aide.
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
```

Créez le fichier 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"

Déployez le contrôleur de trafic entrant Nginx.

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

Enregistrez le fichier yaml suivant nommé 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"

Créez les ressources d'application.
```
kubectl apply -f application.yaml
```
Créez un enregistrement DNS pour l'adresse IP publique associée à l'équilibreur de charge.
- Obtenez l'adresse IP publique de l'équilibreur de charge.
```
$ 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
```
- Créez l'enregistrement DNS. Si vous n'avez pas de serveur DNS, nous comptons sur le service DNS générique gratuit nip.io.
Dans ce cas, le nom de domaine complet est 158-180-61-74.nip.io.

Enregistrez le fichier yaml suivant nommé ingress.yaml.

Note : Veillez à mettre à jour les entrées d'hôte avec votre nom de domaine complet.

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

Exécutez la commande suivante pour créer la ressource entrante.
```
kubectl apply -f ingress.yaml
```

Testez la connectivité au service.

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

Tâche 3 : Configurer une application confidentielle dans les domaines d'identité Oracle

Naviguez jusqu'à Domaines d'identité Oracle dans la console OCI et cliquez sur le domaine OracleIdentityCloudService.
Sélectionnez Applications intégrées dans le menu de gauche et cliquez sur Ajouter une application.
Sélectionnez Application confidentielle et cliquez sur Lancer le flux de travail.
Entrez le nom de l'application, la description et cliquez sur Suivant.
Configurez les paramètres oAuth de l'application.
1. Dans la section Autorisation, sélectionnez Code d'autorisation.
2. Entrez les URL suivantes et cliquez sur Suivant.
  - URL de redirection : https://<YOUR-FQDN>/oauth2/callback.
  - URL de redirection après déconnexion : https://<YOUR-FQDN>.
  - URL de déconnexion : https://<YOUR-FQDN>/oauth2/sign_out.
Dans Politique de niveau Web, sélectionnez Ignorer et effectuer plus tard et cliquez sur Terminer.
Cliquez sur Activer pour activer l'application.
Naviguez jusqu'à Groupes dans le menu de gauche et associez les groupes d'utilisateurs autorisés à s'authentifier à cette application.
Notez l'ID client et la clé secrète client.
Cliquez sur le domaine OracleIdentityCloudService et développez l'URL de domaine.

Par exemple : L'URL du domaine d'identité sera https://idcs-01234567890abcdef.identity.oraclecloud.com (nous supprimons le numéro de port).

Tâche 4 : Déployer le mandataire OAuth2

Nous utilisons le mandataire OAuth2 pour gérer la complexité de OAuth2 ou d'OpenID Connect (OIDC) et nous assurer que toutes les demandes transmises aux applications sont authentifiées.

Enregistrez le fichier yaml suivant nommé oauth2-proxy.yaml et remplacez les paramètres fictifs par les valeurs applicables.

Note :

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

Déployez le mandataire OAuth2 dans OKE.
```
kubectl apply -f oauth2-proxy.yaml
```
Vérifiez que le pod est en cours d'exécution.
```
kubectl get pods -l k8s-app=oauth2-proxy
```

Configurez Nginx pour utiliser le mandataire OAuth2 pour l'authentification de demande.

Mettez à jour le fichier ingress.yaml avec les annotations d'authentification.

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

Essayez de vous connecter à votre application. Vous devez être redirigé vers la page d'authentification d'Oracle. Une fois l'authentification réussie, vous devez être redirigé vers votre application.

Deux en-têtes identifient l'utilisateur authentifié.
```
"x-auth-request-user": "xxxx@oracle.com"
"x-auth-request-email": "xxxx@oracle.com"
```
Pour vous déconnecter de l'application, vous pouvez aller à /oauth2/sign_out sur votre page.
```
https://<YOUR-FQDN>/oauth2/sign_out
```
Problème connu : La redirection après déconnexion ne fonctionne pas. Ce problème fait l'objet d'un suivi ici : Ajoutez un paramètre id_token_hint à l'URL du fournisseur de déconnexion pour le fournisseur OIDC.

Tâche 5 : Nettoyer les ressources

Exécutez la commande suivante pour supprimer toutes les ressources déployées par Kubernetes.

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

Supprimez l'application des domaines d'identité Oracle.
Supprimez la grappe OKE.
Supprimez le VCN créé pour la grappe OKE.
Note :
- Vous devez attendre la fin de la suppression de la grappe et du groupe de noeuds OKE.
- Le nom du VCN contient le nom de la grappe OKE : oke-vcn-quick-<oke-cluster-name>-<random-string>.

Confirmation

Auteur - Andrei Ilas (architecte en nuage principal)

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.

Titre et droits d'auteur

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

F96452-01

April 2024

Oracle et/ou ses sociétés affiliées.