Autenticação segura de cliente com OIDC

Considerações

Ao ativar a autenticação OIDC, considere o seguinte:

• Fornecedores de identidade: você deve ter um fornecedor de identidade (IdP) OIDC pré-existente e configurado. O Operador Kubernetes não gerencia o IdP em si.

• Autorização: o operador do Kubernetes configura a autenticação (verificação de identidade) via OIDC. A autorização (contribuição de permissões) é tratada pelo mapeamento de declarações OIDC para funções do MongoDB dentro do recurso personalizado do MongoDB .

• Federação: o MongoDB oferece suporte ao Workload Identity Federation (para autenticação de máquina para máquina) e ao Workforce Identity Federation (para autenticação de usuário humano).

• Criptografia TLS: para melhorar a segurança, é altamente recomendável implantar um conjunto de réplicas criptografadas por TLS ou um cluster fragmentado criptografado por TLS. Enquanto a comunicação OIDC com seu provedor de identidade é protegida por HTTPS, habilitar TLS em seu recurso MongoDB criptografa a conexão entre seu aplicação cliente e o banco de dados. Isso protege o token OIDC e todo o outro tráfego do banco de dados contra ataques de rede.

Pré-requisitos gerais

Antes de configurar a autenticação OIDC para seus sistemas MongoDB , conclua as seguintes tarefas:

• Certifique-se de implementar o recurso de banco de dados MongoDB Enterprise . Os bancos de dados da MongoDB Community não suportam autenticação OIDC.

• Implemente o conjunto de réplicas ou implemente o cluster fragmentado cuja autenticação de cliente você deseja proteger com o OpenID Connect.

Detalhes de configuração OIDC

Noções básicas sobre os modelos de autorização OIDC

A configuração do OIDC no MongoDB combina dois conceitos-chave: o método de federação e o tipo de autorização.

Gerenciamento de funções e permissões do OIDC

Depois de configurar um provedor OIDC, você deve conceder permissões. O método que você usa para fazer isso depende do authorizationType que você selecionou.

roles:
 - role: "idp-human-users/app-devs" # Maps the "app-devs" group from the IdP
   db: "admin"
   roles:
     - role: "readWrite"
       db: "app-data"

Configurar autenticação de cliente OIDC para um conjunto de réplicas

Siga estas etapas para configurar o OIDC para um conjunto de réplicas.

apiVersion: mongodb.com/v1
kind: MongoDB
metadata:
  name: my-oidc-replicaset
spec:
  type: ReplicaSet
  members: 3
  version: 7.0.11-ent
  opsManager:
    configMapRef:
      name: <my-project-configmap>
  credentials: <my-credentials-secret>
  security:
    authentication:
      modes: ["SCRAM", "OIDC"]
      oidcProviderConfigs:
        - configurationName: "idp-human-users"
          issuerURI: "https://<your-idp-domain>"
          clientId: "<your-client-id>"
          audience: "api://default"
          groupsClaim: "groups"
          authorizationMethod: "WorkforceIdentityFederation"
          authorizationType: "GroupMembership"
    roles:
      - role: "idp-human-users/app-devs"
        db: "admin"
        roles:
          - role: "readWrite"
            db: "app-data"

apiVersion: mongodb.com/v1
kind: MongoDB
metadata:
  name: my-oidc-replicaset
spec:
  type: ReplicaSet
  members: 3
  version: 7.0.11-ent
  opsManager:
    configMapRef:
      name: <my-project-configmap>
  credentials: <my-credentials-secret>
  security:
    authentication:
      modes: ["SCRAM", "OIDC"]
      oidcProviderConfigs:
        - configurationName: "billing-service-auth"
          issuerURI: "https://<your-idp-uri>"
          clientId: "<billing-service-client-id>"
          audience: "mongodb-api"
          userClaim: "sub"
          authorizationMethod: "WorkloadIdentityFederation"
          authorizationType: "UserID"

apiVersion: mongodb.com/v1
kind: MongoDB
metadata:
  name: my-oidc-replicaset
spec:
  type: ReplicaSet
  members: 3
  version: 7.0.11-ent
  opsManager:
    configMapRef:
      name: <my-project-configmap>
  credentials: <my-credentials-secret>
  security:
    authentication:
      modes: ["SCRAM", "OIDC"]
      oidcProviderConfigs:
        - configurationName: "idp-special-user"
          issuerURI: "https://<your-idp-domain>"
          clientId: "<your-client-id>"
          audience: "api://default"
          userClaim: "sub"
          authorizationMethod: "WorkforceIdentityFederation"
          authorizationType: "UserID"

apiVersion: mongodb.com/v1
kind: MongoDB
metadata:
  name: my-oidc-replicaset
spec:
  type: ReplicaSet
  members: 3
  version: 7.0.11-ent
  opsManager:
    configMapRef:
      name: <my-project-configmap>
  credentials: <my-credentials-secret>
  security:
    authentication:
      modes: ["SCRAM", "OIDC"]
      oidcProviderConfigs:
        - configurationName: "reporting-services"
          issuerURI: "https://<your-idp-uri>"
          clientId: "<reporting-services-client-id>"
          audience: "mongodb-api"
          groupsClaim: "service-roles"
          authorizationMethod: "WorkloadIdentityFederation"
          authorizationType: "GroupMembership"
    roles:
      - role: "reporting-services/report-generators"
        db: "admin"
        roles:
          - role: "read"
            db: "sales-data"

kubectl apply -f <your-replica-set-file>.yaml

kubectl get mdb <resource-name> -o yaml -w

Configurar autenticação de cliente OIDC para um cluster fragmentado

Use o exemplo a seguir para configurar o OIDC para um cluster fragmentado. Os princípios e opções de configuração são idênticos a um conjunto de réplicas.

apiVersion: mongodb.com/v1
kind: MongoDB
metadata:
  name: my-oidc-shardedcluster
spec:
  type: ShardedCluster
  shardCount: 2
  mongodsPerShardCount: 3
  mongosCount: 2
  configServerCount: 3
  version: 7.0.11-ent
  opsManager:
    configMapRef:
      name: <my-project-configmap>
  credentials: <my-credentials-secret>
  security:
    authentication:
      modes: ["SCRAM", "OIDC"]
      oidcProviderConfigs:
        # Provider 1: For human users (Workforce/Group)
        - configurationName: "idp0-human-users"
          issuerURI: "https://<your-idp0-domain>"
          clientId: "<human-users-client-id>"
          audience: "api://default"
          groupsClaim: "groups"
          authorizationMethod: "WorkforceIdentityFederation"
          authorizationType: "GroupMembership"
        # Provider 2: For service accounts (Workload/UserID)
        - configurationName: "service-accounts"
          issuerURI: "https://<your-idp-uri>"
          clientId: "<services-client-id>"
          audience: "mongodb-api"
          userClaim: "sub"
          authorizationMethod: "WorkloadIdentityFederation"
          authorizationType: "UserID"
    roles:
      # Role mapping for the human user group
      - role: "idp0-human-users/db-admins"
        db: "admin"
        roles:
          - role: "readWriteAnyDatabase"
            db: "admin"

Solução de problemas do OIDC

• Validar manualmente o token JSON web token: Use uma ferramenta para decodificar o token OIDC.

  • Declarações principais: certifique-se de que as declarações iss (emissor) e aud (audiência) no token correspondam exatamente à configuração do provedor de OIDC. Verifique se o token não expirou (declaração exp).

  • Declarações de usuário/grupo esperadas: verifique se as declarações esperadas para identidade de usuário (userClaim) e grupos (groupsClaim) estão presentes no token e contêm os valores corretos.

• Verificar Formato de Nome de Usuário para Autenticação do UserID: O nome de usuário MongoDBUser deve estar no formato exato <configurationName>/<userClaimValue>. O <configurationName> deve corresponder ao nome do provedor OIDC em seu recurso do MongoDB.

• Confirmar que o banco de dados $external é usado: para autorização UserID, o recurso MongoDBUser deve especificar db: "$external". Os usuários autenticados por uma fonte externa são sempre resolvidos por meio desse banco de dados virtual.

• Verificar mapeamento de função de grupo para autenticação do GroupMembership: verifique se a função definida na seção spec.security.roles do recurso do MongoDB está formatada corretamente como <configurationName>/<groupName>, onde <groupName> corresponde exatamente a um grupo no groupsClaim do JSON web token.

• Validar permissões de função atribuídas: verifique se as funções do MongoDB atribuídas ao usuário ou grupo do OIDC realmente concedem as permissões necessárias (por exemplo, readWrite no banco de dados correto).

• Verificar Referência do Recurso MongoDBUser: Para autorização do UserID, certifique-se de que o spec.mongodbResourceRef.name no recurso MongoDBUser aponte corretamente para o nome do seu sistema do MongoDB.