配置密钥存储

要设立OIDC JSON web token和Kubernetes身份验证：

1. 运行以下命令，为挂载路径启用OIDC JSON web token身份验证。 如果设置了多个Kubernetes集群，则必须为每个集群的挂载路径启用OIDC JSON web token身份验证。

   vault auth enable -path=jwt-kube01 jwt

2. 运行以下命令以允许对kube01.internal.io集群上的OIDC发现 URL 进行未经身份验证的访问：

   $ kubectl create clusterrolebinding oidc-reviewer  \
     --clusterrole=system:service-account-issuer-discovery \
     --group=system:unauthenticated

3. 运行以下命令以指示 HashiCorp Vault 信任该集群。https://kube01.internal.io/ 集群的颁发者必须与 的 OIDC 发现文档中的URL匹配。.well-known/openid-configuration

   curl https://kube01.internal.io/.well-known/openid-configuration | jq .issuer
   https://kube01.internal.io/
   vault write auth/jwt-kube01/config jwks_url="https://kube01.internal.io/openid/v1/jwks"

4. 创建策略，允许访问要向集群公开的密钥。

   以下示例创建您在后续步骤中指定的external-secrets策略。

   echo external-secrets-policy.hcl
   path "secret/data/kube01/external-secrets/*" {
     capabilities = ["read"]
   }

5. 运行以下命令创建 HashiCorp Vault角色，并将Kubernetes服务帐户绑定到该角色，从而限制该服务帐户在 HashiCorp Vault 中的访问权限。

   以下命令为jwt-kube01-system vault受众创建 JWT ( OIDC ) 类型的 角色。该命令指定sub 用户声明和 命名空间中的default Kubernetes服务帐户作为绑定主题。此命令将角色与mongodb-atlas-system external-secretsHashiCorp Vault 中的 策略权限设立绑定。

   vault write auth/jwt-kube01/role/jwt-kube01-system role_type="jwt" bound_audiences=vault \
     user_claim="sub" bound_subject="system:serviceaccount:mongodb-atlas-system:default" \
     policies="external-secrets"

6. 运行命令为外部密钥操作符创建另一个角色，以访问default命名空间。

   以下命令为jwt-kube01-default vault受众创建 JWT ( OIDC ) 类型的 角色。此命令指定sub 用户声明和 命名空间中的default Kubernetes服务帐户作为绑定主题。此命令将角色与default external-secretsHashiCorp Vault 中的 策略权限设立绑定。

   vault write auth/jwt-kube01/role/jwt-kube01-default role_type="jwt" bound_audiences=vault \
     user_claim="sub" bound_subject="system:serviceaccount:default:default" \
     policies="external-secrets"

7. 确保系统服务帐户成功运行OIDC身份验证：

   export TEST_JWT_TOKEN=$(kubectl -n mongodb-atlas-system create token default --audience "vault")
   vault write auth/jwt-kube01/login role=jwt-kube01-system jwt=$(TEST_JWT_TOKEN)

   Atlas Kubernetes Operator返回系统服务帐户的OIDC JSON web token凭证。

8. 确保为默认服务帐户成功运行OIDC身份验证：

   export TEST_JWT_TOKEN=$(kubectl -n default create token default --audience "vault")
   vault write auth/jwt-kube01/login role=jwt-kube01-default jwt=$(TEST_JWT_TOKEN)

   Atlas Kubernetes Operator返回默认服务帐户的OIDC JSON web token凭证。

要设立Kubernetes身份验证，请执行以下操作：

1. 运行以下命令，为挂载路径启用Kubernetes身份验证。 如果设立了多个Kubernetes集群，则必须为每个集群的挂载路径启用Kubernetes身份验证。

   vault auth enable -path=jwt-kube01 kubernetes

   与 Helm 一起安装时，它会自动配置集群角色绑定。

2. 创建策略，允许访问权限要公开给集群的密钥。

   以下示例创建了在后续步骤中使用的策略vault-secret 。它使用vault ，这是一个绑定到 Helm Chart CSI提供商设置的 HashiCorp Vault 服务帐户的Kubernetes密钥。

   echo vault-secret.yaml
   apiVersion: v1
   kind: Secret
   metadata:
     name: vault
     annotations:
       kubernetes.io/service-account.name: vault
   type: kubernetes.io/service-account-token
   $ kubectl apply -f vault-secret.yaml

3. 运行以下命令以信任Kubernetes集群并使用Kubernetes身份验证：

   export VAULT_JWT ?= $(shell kubectl get secret/vault -o jsonpath='{.data.token}' |base64 -d)

   vault write auth/k8s-kube01/config kubernetes_host="kube01.internal.io" token_reviewer_jwt=$(VAULT_JWT)

4. 运行以下命令创建 HashiCorp Vault角色，并将Kubernetes服务帐户绑定到该角色，从而限制该服务帐户在 HashiCorp Vault 中的访问权限。

   以下命令在k8s-kube01 上创建绑定到auth/k8s-kube01 或 命名空间中Kubernetes服务帐户的default mongodb-atlas-system角色。此角色与secrets-store HashiCorp Vault 中的 权限策略相关联。

   vault write auth/k8s-kube01/role/k8s-kube01-role \
     bound_service_account_names=default,mongodb-atlas-operator \
     bound_service_account_namespaces=default,mongodb-atlas-system \
     policies=secrets-store

   策略必须存在并允许访问权限密钥。 以下示例策略允许访问权限kube01/secrets-store路径下的 KV v 2密钥：

   path "secret/data/kube01/secrets-store/*" {
     capabilities = ["read"]
   }

5. 确保系统服务帐户成功运行Kubernetes身份验证：

   export TEST_JWT_TOKEN=$( kubectl create -n mongodb-atlas-system token mongodb-atlas-operator)
   vault write auth/jwt-kube01/login role=jwt-kube01-system jwt=$(TEST_JWT_TOKEN)

6. 确保默认帐户的Kubernetes身份验证成功运行：

   export TEST_JWT_TOKEN=$(kubectl -n default create token default)
   vault write auth/jwt-kube01/login role=jwt-kube01-default jwt=$(TEST_JWT_TOKEN)

要使用外部密钥操作符预配密钥，请执行以下操作：

1. 在mongodb-atlas-system命名空间中为default服务帐户部署SecretStore自定义资源：

   $ cat external-secrets/vault-system.yaml
   apiVersion: external-secrets.io/v1beta1
   kind: SecretStore
   metadata:
     name: vault-store
     namespace: mongodb-atlas-system
   spec:
     provider:
       vault:
         server: "https://vault.internal.io"
         path: "secret"
         version: "v2"
         auth:
           jwt:
             path: "jwt-kube01"
             role: "jwt-kube01-system"
             kubernetesServiceAccountToken:
               expirationSeconds: 600
               serviceAccountRef:
                 name: "default"
                 audiences:
                 - vault
   $ kubectl apply -f external-secrets/vault-system.yaml

2. 在default命名空间中为default服务帐户部署SecretStore自定义资源：

   $ cat external-secrets/vault-default.yaml
   apiVersion: external-secrets.io/v1beta1
   kind: SecretStore
   metadata:
     name: vault-store
     namespace: default
   spec:
     provider:
       vault:
         server: "https://vault.internal.io"
         path: "secret"
         version: "v2"
         auth:
           jwt:
             path: "jwt-kube01"
             role: "jwt-role"
             kubernetesServiceAccountToken:
               expirationSeconds: 600
               serviceAccountRef:
                 name: "default"
                 audiences:
                 - vault
   $ kubectl apply -f external-secrets/vault-default.yaml

3. 部署引用包含 API 密钥的密钥的ExternalSecret自定义资源。 您必须将spec.target.template.metadata.labels设置为atlas.mongodb.com/type ，值为credentials ，Atlas Kubernetes Operator 才能找到外部密钥 操作符 创建的密钥。

   在运行以下命令之前，请确保 HashiCorp Vault 已在 Kv V2 路径secret/data/kube01/external-secrets/atlas-account 中填充具有以下属性的密钥：

   • orgId

   • publicApiKey

   • privateApiKey

   $ cat external-secrets/atlas.yaml
   apiVersion: external-secrets.io/v1beta1
   kind: ExternalSecret
   metadata:
     name: atlas
     namespace: mongodb-atlas-system
   spec:
       refreshInterval: "15s"
       secretStoreRef:
         name: vault-store
         kind: SecretStore
       target:
         name: mongodb-atlas-operator-api-key
         template:
           metadata:
             labels:
               atlas.mongodb.com/type: credentials
       data:
       - secretKey: orgId
         remoteRef:
           key: secret/data/kube01/external-secrets/atlas-account
           property: orgId
       - secretKey: publicApiKey
         remoteRef:
           key: secret/data/kube01/external-secrets/atlas-account
           property: publicApiKey
       - secretKey: privateApiKey
         remoteRef:
           key: secret/data/kube01/external-secrets/atlas-account
           property: privateApiKey
     $ kubectl apply -f external-secrets/atlas.yaml

   此命令在 命名空间中创建Kubernetes密钥 mongodb-atlas-operator-api-keymongodb-atlas-system。

4. 部署引用包含数据库用户档案的密钥的ExternalSecret自定义资源。 您必须将spec.target.template.metadata.labels设置为atlas.mongodb.com/type ，值为credentials ，Atlas Kubernetes Operator 才能找到外部密钥 Operator 创建的密钥。

   在运行以下命令之前，请确保 HashiCorp Vault 已在 Kv V 路径 中使用2 secret/data/kube01/external-secrets/db-userpassword属性填充密钥。

   $ cat external-secrets/dbuser.yaml
   apiVersion: external-secrets.io/v1beta1
   kind: ExternalSecret
   metadata:
     name: dbuser
     namespace: default
   spec:
       refreshInterval: "15s"
       secretStoreRef:
         name: vault-store
         kind: SecretStore
       target:
         name: dbuser-password
         template:
           metadata:
             labels:
               atlas.mongodb.com/type: credentials
       data:
       - secretKey: password
         remoteRef:
           key: secret/data/kube01/external-secrets/db-user
           property: password
     $ kubectl apply -f external-secrets/atlas.yaml

5. 确保运行以下命令时按预期返回密钥：

   $ kubectl get -n mongodb-atlas-system secrets/mongodb-atlas-operator-api-key

   $ kubectl get -n default secrets/dbuser-password

要使用密钥存储 CSI 预配密钥，请执行以下操作：

1. 在mongodb-atlas-system命名空间中部署SecretProviderClass自定义资源。 您必须设立spec.secretObjects.labels设置为atlas.mongodb.com/type ，值为credentials ， Atlas Kubernetes Operator才能找到密钥存储 CSI 创建的密钥。

   在运行以下命令之前，请确保 HashiCorp Vault 已在 Kv V2 路径secret/data/kube01/external-secrets/atlas-account 中填充具有以下属性的密钥：

   • orgId

   • publicApiKey

   • privateApiKey

   $ cat secrets-store/atlas.yaml
   apiVersion: secrets-store.csi.x-k8s.io/v1
   kind: SecretProviderClass
   metadata:
     name: atlas
     namespace: mongodb-atlas-system
   spec:
     provider: vault
     secretObjects:
     - data:
       - key: orgId
         objectName: atlas-org
       - key: publicApiKey
         objectName: atlas-pub-key
       - key: privateApiKey
         objectName: atlas-secret-key
       secretName: mongodb-atlas-operator-api-key
       type: Opaque
       labels:
         atlas.mongodb.com/type: credentials
     parameters:
       vaultAddress: https://vault.internal.io
       vaultKubernetesMountPath: k8s-kube01
       roleName: k8s-kube01-role
       objects: |
         - objectName: atlas-org
           secretPath: secret/data/kube01/secrets-store/atlas-account
           secretKey: orgId
         - objectName: atlas-pub-key
           secretPath: secret/data/kube01/secrets-store/atlas-account
           secretKey: publicApiKey
         - objectName: atlas-secret-key
           secretPath: secret/data/kube01/secrets-store/atlas-account
           secretKey: privateApiKey
   $ kubectl apply -f secrets-store/atlas.yaml

   此命令在 命名空间中创建Kubernetes密钥 mongodb-atlas-operator-api-keymongodb-atlas-system。

2. 运行以下命令，添加挂载所需密钥的 Pod：

   $ cat secrets-store/ako-patch.yaml
     template:
       spec:
         containers:
         - name: system-secret-placeholder
           image: mongodb/atlas
           command: ["sleep", "infinity"]
           volumeMounts:
           - name: secrets-store-mount
             mountPath: "/mnt/secrets-store"
             readOnly: true
         volumes:
           - name: secrets-store-mount
             csi:
               driver: secrets-store.csi.k8s.io
               readOnly: true
               volumeAttributes:
                 secretProviderClass: atlas
   $ kubectl apply -f secrets-store/ako-patch.yaml

3. 部署引用包含数据库用户凭证的密钥的SecretProviderClass自定义资源。 您必须设立spec.target.template.metadata.labels设置为atlas.mongodb.com/type （值为credentials ， Atlas Kubernetes Operator才能找到密钥存储 CSI 创建的密钥。

   在运行以下命令之前，请确保 HashiCorp Vault 已在 Kv V 路径 中使用2 secret/data/kube01/external-secrets/db-userpassword属性填充密钥。

   $ cat external-secrets/dbuser.yaml
   apiVersion: external-secrets.io/v1beta1
   kind: SecretProviderClass
   metadata:
     name: dbuser
     namespace: default
   spec:
     provider: vault
     secretObjects:
     - data:
       - key: password
         objectName: dbuser
       secretName: dbuser-password
       type: Opaque
       labels:
         atlas.mongodb.com/type: credentials
    parameters:
       vaultAddress: https://vault.internal.io
       vaultKubernetesMountPath: k8s-kube01
       roleName: k8s-kube01-role
       objects: |
         - objectName: "dbuser"
           secretPath: "secret/data/kube01/secrets-store/db-user"
           secretKey: "password"
   $ kubectl apply -f secrets-store/dbuser.yaml

4. 运行以下命令以创建secret-placeholder Sentinel Pod，确保密钥存储 CSI驾驶员获取dbuserKubernetes并将其同步到凭证 ：

   $ cat secrets-store/placeholder.yaml
   kind: Pod
   apiVersion: v1
   metadata:
     name: secret-placeholder
   spec:
     containers:
     - image: mongodb/atlas
       command: ["sleep", "infinity"]
       name: secret-placeholder
       volumeMounts:
       - name: secrets-store-mount
         mountPath: "/mnt/secrets-store"
         readOnly: true
     volumes:
       - name: secrets-store-mount
         csi:
           driver: secrets-store.csi.k8s.io
           readOnly: true
           volumeAttributes:
             secretProviderClass: dbuser
   $ kubectl apply -f secrets-store/placeholder.yaml

5. 确保运行以下命令时按预期返回密钥：

   $ kubectl get -n mongodb-atlas-system secrets/mongodb-atlas-operator-api-key

   $ kubectl get -n default secrets/dbuser-password