Observação:

Este tutorial requer acesso ao Oracle Cloud. Para se cadastrar em uma conta gratuita, consulte Conceitos básicos do Oracle Cloud Infrastructure Free Tier.
Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Proteger Web Services do Kubernetes usando o Controlador de Entrada do Nginx, o Proxy OAuth2 e os Domínios de Identidade da Oracle

Introdução

A proteção de serviços Web hospedados no Kubernetes deve ser fácil. Se seu aplicativo não tem suporte incorporado para integração externa do Provedor de Identidades (IdP) ou você precisa de uma solução de Sign-On Único (SSO) para simplificar o gerenciamento e reduzir a necessidade de mecanismos de autenticação individuais por serviço, o Proxy OAuth2 oferece a flexibilidade de conectar qualquer aplicativo a quase qualquer Provedor de Identidades (IdP).

OAuth2 O proxy atua como um proxy reverso sentado na frente dos seus serviços do Kubernetes. Ele intercepta o tráfego, redireciona os usuários para um servidor de autorização externo (como Okta ou GitHub) para log-in e valida tokens de acesso antes de encaminhar solicitações aos serviços de backend.

Objetivo

Implante um aplicativo Web simples no Kubernetes, exponha-o usando o Controlador de Entrada do Nginx e configure o Proxy OAuth2 para usar os Domínios de Identidade da Oracle como IdP.

Pré-requisitos

Acesso a uma tenancy do Oracle Cloud Infrastructure (OCI).
Um cluster do Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) configurado para usar uma sub-rede pública para balanceadores de carga.
(Opcional) Acesso para atualizar registros de um domínio do DNS (Sistema de Nomes de Domínio).

Tarefa 1: Criar um Cluster do OKE

Faça log-in na Console do OCI, navegue até Oracle Container Engine for Kubernetes e clique em Criar.
No assistente Criar cluster, clique em Criação Rápida.
Especifique as seguintes informações e clique em Próximo.
- Nome: Informe o nome do cluster.
- Versão do Kubernetes: Selecione a versão que você deseja usar.
- Pontos finais da API Kubernetes: Selecione Ponto final público.
- Tipo de nó: Selecione Gerenciado.
- Nós de trabalho do Kubernetes: Selecione Trabalhadores privados.
- Contagem de nós: 1.
Verifique e clique em Criar Cluster. Aguarde até que o cluster fique disponível.
Atualize a lista de segurança associada à sub-rede de serviço.
1. Clique na Sub-rede de serviço.
2. Clique em Security List e adicione as regras a seguir.
  - Entrada:
  - Saída:
Atualize a lista de segurança associada à sub-rede de nós de trabalho para permitir conexões dos balanceadores de carga.
1. Clique no nome da VCN.
2. Em Recursos, selecione Listas de Segurança e clique na lista de segurança dos nós.
3. Adicione a seguinte regra de entrada à lista de segurança de nós.
4. Clique em Adicionar Regras de Entrada.

Tarefa 2: Configurar o controlador de entrada do Nginx

Quando o cluster estiver disponível, você poderá acessá-lo usando o OCI Cloud Shell. Clique em Acessar Cluster e copie e execute o comando a seguir no OCI Cloud Shell.
Execute o comando kubectl get node para obter a lista de nós disponíveis.
Adicione o repositório helm do Nginx Ingress Controller. Para obter mais informações, consulte Visão Geral do Controlador NGINX de Entrada e helm.
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
```

Crie o arquivo 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"

Implante o Controlador de Entrada do Nginx.

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

Salve o arquivo yaml a seguir chamado 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"

Crie os recursos do aplicativo.
```
kubectl apply -f application.yaml
```
Crie um registro de DNS para o endereço IP público associado ao balanceador de carga.
- Obtenha o endereço IP público do balanceador 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
```
- Crie o registro de DNS. Se você não tiver um servidor DNS, dependeremos do serviço DNS curinga gratuito nip.io.
Nesse caso, o FQDN é 158-180-61-74.nip.io.

Salve o arquivo yaml a seguir chamado ingress.yaml.

Observação: certifique-se de atualizar as entradas de host com seu 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

Execute o comando a seguir para criar o recurso de entrada.
```
kubectl apply -f ingress.yaml
```

Teste a conectividade com o serviço.

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

Tarefa 3: Configurar um Aplicativo Confidencial nos Domínios de Identidade da Oracle

Navegue até Domínios de Identidade da Oracle na Console do OCI e clique no domínio OracleIdentityCloudService.
Selecione Aplicativos Integrados no menu esquerdo e clique em Adicionar aplicativo.
Selecione Aplicativo Confidencial e clique em Iniciar workflow.
Digite o Nome, Descrição e clique em Próximo.
Configure os parâmetros oAuth do aplicativo.
1. Na seção Autorização, selecione Código de autorização.
2. Informe os seguintes URLs e clique em Próximo.
  - URL de Redirecionamento: https://<YOUR-FQDN>/oauth2/callback.
  - URL de redirecionamento após log-out: https://<YOUR-FQDN>.
  - URL de Log-out: https://<YOUR-FQDN>/oauth2/sign_out.
Em Política da camada Web, selecione Ignorar e fazer mais tarde e clique em Finalizar.
Click Activate to enable the application.
Navegue até Grupos no menu esquerdo e associe os grupos de usuários com permissão para autenticação a este aplicativo.
Anote o ID do Cliente e o Segredo do Cliente.
Clique no domínio OracleIdentityCloudService e expanda o URL do Domínio.

Por exemplo: o URL do Domínio de Identidades será https://idcs-01234567890abcdef.identity.oraclecloud.com (nós removemos o número da porta).

Tarefa 4: Implantar o Proxy OAuth2

Estamos usando o Proxy OAuth2 para tratar a complexidade do OAuth2 ou do OpenID Connect (OIDC) e garantir que todas as solicitações encaminhadas para os aplicativos sejam autenticadas.

Salve o arquivo yaml a seguir chamado oauth2-proxy.yaml e substitua os placeholders pelos valores aplicáveis.

Observação:

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

Implante o Proxy OAuth2 no OKE.

kubectl apply -f oauth2-proxy.yaml

Confirme se o pod está em execução.

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

Configure o Nginx para usar o Proxy OAuth2 para autenticação de solicitação.

Atualize o arquivo ingress.yaml com as anotações de autenticação.

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

Tente se conectar ao seu aplicativo. Você deverá ser redirecionado para a página de autenticação da Oracle. Depois que a autenticação for bem-sucedida, você deverá ser redirecionado ao seu aplicativo.

Há dois cabeçalhos que identificam o usuário autenticado.
```
"x-auth-request-user": "xxxx@oracle.com"
"x-auth-request-email": "xxxx@oracle.com"
```
Para sair do aplicativo, você pode ir para /oauth2/sign_out em sua página.
```
https://<YOUR-FQDN>/oauth2/sign_out
```
Problema Conhecido: O redirecionamento pós-saída não está funcionando. Esse problema é rastreado aqui: Adicione um parâmetro id_token_hint ao URL do provedor de log-out do provedor OIDC.

Tarefa 5: Limpar Recursos

Execute o comando a seguir para excluir todos os recursos implantados do Kubernetes.

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

Exclua o aplicativo dos Domínios de Identidades da Oracle.
Exclua o cluster do OKE.
Exclua a VCN criada para o cluster do OKE.
Observação:
- Você precisa aguardar o término da exclusão do cluster e do pool de nós do OKE.
- O nome da VCN contém o nome do cluster do OKE: oke-vcn-quick-<oke-cluster-name>-<random-string>.

Confirmação

Autor - Andrei Ilas (Arquiteto de Nuvem Principal)

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

Título e Informações de Copyright

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

F96457-01

April 2024

Oracle e/ou suas empresas afiliadas.