devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深入理解 Kubernetes 中的用户与身份认证授权

作者：知新_RL | 2024-05-16 12:51:58

赞

踩

kubelet user
❝

本文转自 Cylon 的博客，原文：https://www.cnblogs.com/Cylon/p/16905335.html，版权归原作者所有。欢迎投稿，投稿请添加微信好友：cloud-native-yang

本章主要简单阐述 kubernetes 认证相关原理，最后以实验来阐述 kubernetes 用户系统的思路。

主要内容：

  • 了解 kubernetes 各种认证机制的原理

  • 了解 kubernetes 用户的概念

  • 了解 kubernetes authentication webhook

  • 完成实验，如何将其他用户系统接入到 kubernetes 中的一个思路

Kubernetes 认证

在 Kubernetes apiserver 对于认证部分所描述的，对于所有用户访问 Kubernetes API（通过任何客户端，客户端库，kubectl 等）时都会经历 验证 (Authentication) , 授权 (Authorization), 和准入控制 (Admission control) 三个阶段来完成对 “用户” 进行授权，整个流程正如下图所示：

59785eefce91325a5e34cc14b5448646.png
图：Kubernetes API 请求的请求处理步骤图

其中在大多数教程中，在对这三个阶段所做的工作大致上为：

  • Authentication 阶段所指用于确认请求访问 Kubernetes API 用户是否为合法用户

  • Authorization 阶段所指的将是这个用户是否有对操作的资源的权限

  • Admission control 阶段所指控制对请求资源进行控制，通俗来说，就是一票否决权，即使前两个步骤完成

到这里了解到了 Kubernetes API 实际上做的工作就是 “人类用户” 与 kubernetes service account[1]；那么就引出了一个重要概念就是 “用户” 在 Kubernetes 中是什么，以及用户在认证中的也是本章节的中心。

在 Kubernetes 官方手册中给出了 ”用户“  的概念，Kubernetes 集群中存在的用户包括 ”普通用户“ 与 “service account” 但是 Kubernetes  没有普通用户的管理方式，只是将使用集群的证书 CA 签署的有效证书的用户都被视为合法用户。

那么对于使得 Kubernetes 集群有一个真正的用户系统，就可以根据上面给出的概念将 Kubernetes 用户分为 ”外部用户“ 与  ”内部用户“。如何理解外部与内部用户呢？实际上就是有 Kubernetes 管理的用户，即在 kubernetes 定义用户的数据模型这种为  “内部用户” ，正如 service account；反之，非 Kubernetes 托管的用户则为 ”外部用户“  这中概念也更好的对 kubernetes 用户的阐述。

对于外部用户来说，实际上 Kubernetes 给出了多种用户概念[2]，例如：

  • 拥有 kubernetes 集群证书的用户

  • 拥有 Kubernetes 集群 token 的用户（--token-auth-file 指定的静态 token）

  • 用户来自外部用户系统，例如 OpenID，LDAP，QQ connect, google identity platform 等

向外部用户授权集群访问的示例

场景 1：通过证书请求 k8s

该场景中 kubernetes 将使用证书中的 cn 作为用户，ou 作为组，如果对应 rolebinding/clusterrolebinding 给予该用户权限，那么请求为合法

  1. $ curl https://hostname:6443/api/v1/pods \
  2.  --cert ./client.pem \
  3.  --key ./client-key.pem \
  4.  --cacert ./ca.pem

接下来浅析下在代码中做的事情

确认用户是 apiserver 在 Authentication 阶段 做的事情，而对应代码在 pkg/kubeapiserver/authenticator[3] 下，整个文件就是构建了一系列的认证器，而 x.509 证书指是其中一个

  1. // 创建一个认证器，返回请求或一个k8s认证机制的标准错误
  2. func (config Config) New() (authenticator.Request, *spec.SecurityDefinitions, error) {
  3.  
  4. ...
  5.  
  6.  // X509 methods
  7.     // 可以看到这里就是将x509证书解析为user
  8.  if config.ClientCAContentProvider != nil {
  9.   certAuth := x509.NewDynamic(config.ClientCAContentProvider.VerifyOptions, x509.CommonNameUserConversion)
  10.   authenticators = append(authenticators, certAuth)
  11.  }
  12. ...

接下来看实现原理，NewDynamic 函数位于代码 k8s.io/apiserver/pkg/authentication/request/x509/x509.go[4]

通过代码可以看出，是通过一个验证函数与用户来解析为一个 Authenticator

  1. // NewDynamic returns a request.Authenticator that verifies client certificates using the provided
  2. // VerifyOptionFunc (which may be dynamic), and converts valid certificate chains into user.Info using the provided UserConversion
  3. func NewDynamic(verifyOptionsFn VerifyOptionFunc, user UserConversion) *Authenticator {
  4.  return &Authenticator{verifyOptionsFn, user}
  5. }

验证函数为 CAContentProvider 的方法，而 x509 部分实现为 k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_cafile_content.go.VerifyOptions[5]；可以看出返回是一个 x509.VerifyOptions + 与认证的状态

  1. // VerifyOptions provides verifyoptions compatible with authenticators
  2. func (c *DynamicFileCAContent) VerifyOptions() (x509.VerifyOptions, bool) {
  3.  uncastObj := c.caBundle.Load()
  4.  if uncastObj == nil {
  5.   return x509.VerifyOptions{}, false
  6.  }
  7.  
  8.  return uncastObj.(*caBundleAndVerifier).verifyOptions, true
  9. }

而用户的获取则位于  k8s.io/apiserver/pkg/authentication/request/x509/x509.go[6]；可以看出，用户正是拿的证书的 CN，而组则是为证书的 OU

  1. // CommonNameUserConversion builds user info from a certificate chain using the subject's CommonName
  2. var CommonNameUserConversion = UserConversionFunc(func(chain []*x509.Certificate) (*authenticator.Response, bool, error) {
  3.  if len(chain[0].Subject.CommonName) == 0 {
  4.   return nil, false, nil
  5.  }
  6.  return &authenticator.Response{
  7.   User: &user.DefaultInfo{
  8.    Name:   chain[0].Subject.CommonName,
  9.    Groups: chain[0].Subject.Organization,
  10.   },
  11.  }, true, nil
  12. })

由于授权不在本章范围内，直接忽略至入库阶段，入库阶段由 RESTStorageProvider[7] 实现 这里，每一个 Provider 都提供了 Authenticator 这里包含了已经允许的请求，将会被对应的 REST 客户端写入到库中

  1. type RESTStorageProvider struct {
  2.  Authenticator authenticator.Request
  3.  APIAudiences  authenticator.Audiences
  4. }
  5. // RESTStorageProvider is a factory type for REST storage.
  6. type RESTStorageProvider interface {
  7.  GroupName() string
  8.  NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, error)
  9. }

场景 2：通过 token

该场景中，当 kube-apiserver 开启了 --enable-bootstrap-token-auth 时，就可以使用 Bootstrap Token 进行认证，通常如下列命令，在请求头中增加 Authorization: Bearer <token> 标识

  1. $ curl https://hostname:6443/api/v1/pods \
  2.   --cacert ${CACERT} \
  3.   --header "Authorization: Bearer <token>" \

接下来浅析下在代码中做的事情

可以看到，在代码 pkg/kubeapiserver/authenticator.New()[8] 中当 kube-apiserver 指定了参数 --token-auth-file=/etc/kubernetes/token.csv" 这种认证会被激活

  1. if len(config.TokenAuthFile) > 0 {
  2.     tokenAuth, err := newAuthenticatorFromTokenFile(config.TokenAuthFile)
  3.     if err != nil {
  4.         return nil, nil, err
  5.     }
  6.     tokenAuthenticators = append(tokenAuthenticators, authenticator.WrapAudienceAgnosticToken(config.APIAudiences, tokenAuth))
  7. }

此时打开 token.csv 查看下 token 长什么样

  1. $ cat /etc/kubernetes/token.csv
  2. 12ba4f.d82a57a4433b2359,"system:bootstrapper",10001,"system:bootstrappers"

这里回到代码 k8s.io/apiserver/pkg/authentication/token/tokenfile/tokenfile.go.NewCSV[9] ，这里可以看出，就是读取 --token-auth-file= 参数指定的 tokenfile，然后解析为用户，record[1] 作为用户名，record[2] 作为 UID

  1. // NewCSV returns a TokenAuthenticator, populated from a CSV file.
  2. // The CSV file must contain records in the format "token,username,useruid"
  3. func NewCSV(path string) (*TokenAuthenticator, error) {
  4.  file, err := os.Open(path)
  5.  if err != nil {
  6.   return nil, err
  7.  }
  8.  defer file.Close()
  9.  
  10.  recordNum := 0
  11.  tokens := make(map[string]*user.DefaultInfo)
  12.  reader := csv.NewReader(file)
  13.  reader.FieldsPerRecord = -1
  14.  for {
  15.   record, err := reader.Read()
  16.   if err == io.EOF {
  17.    break
  18.   }
  19.   if err != nil {
  20.    return nil, err
  21.   }
  22.   if len(record) < 3 {
  23.    return nil, fmt.Errorf("token file '%s' must have at least 3 columns (token, user name, user uid), found %d", path, len(record))
  24.   }
  25.  
  26.   recordNum++
  27.   if record[0] == "" {
  28.    klog.Warningf("empty token has been found in token file '%s', record number '%d'", path, recordNum)
  29.    continue
  30.   }
  31.  
  32.   obj := &user.DefaultInfo{
  33.    Name: record[1],
  34.    UID:  record[2],
  35.   }
  36.   if _, exist := tokens[record[0]]; exist {
  37.    klog.Warningf("duplicate token has been found in token file '%s', record number '%d'", path, recordNum)
  38.   }
  39.   tokens[record[0]] = obj
  40.  
  41.   if len(record) >= 4 {
  42.    obj.Groups = strings.Split(record[3], ",")
  43.   }
  44.  }
  45.  
  46.  return &TokenAuthenticator{
  47.   tokens: tokens,
  48.  }, nil
  49. }

而 token file 中配置的格式正是以逗号分隔的一组字符串，

  1. type DefaultInfo struct {
  2.  Name   string
  3.  UID    string
  4.  Groups []string
  5.  Extra  map[string][]string
  6. }

这种用户最常见的方式就是 kubelet 通常会以此类用户向控制平面进行身份认证，例如下列配置

  1. KUBELET_ARGS="--v=0 \
  2.     --logtostderr=true \
  3.     --config=/etc/kubernetes/kubelet-config.yaml \
  4.     --kubeconfig=/etc/kubernetes/auth/kubelet.conf \
  5.     --network-plugin=cni \
  6.     --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.1 \
  7.     --bootstrap-kubeconfig=/etc/kubernetes/auth/bootstrap.conf"

/etc/kubernetes/auth/bootstrap.conf 内容，这里就用到了 kube-apiserver 配置的 --token-auth-file= 用户名，组必须为 system:bootstrappers。

  1. apiVersion: v1
  2. clusters:
  3. - cluster:
  4.     certificate-authority-data: ......
  5.     server: https://10.0.0.4:6443
  6.   name: kubernetes
  7. contexts:
  8. - context:
  9.     cluster: kubernetes
  10.     user: system:bootstrapper
  11.   name: system:bootstrapper@kubernetes
  12. current-context: system:bootstrapper@kubernetes
  13. kind: Config
  14. preferences: {}
  15. users:
  16. - name: system:bootstrapper

而通常在二进制部署时会出现的问题，例如下列错误

Unable to register node "hostname" with API server: nodes is forbidden: User "system:anonymous" cannot create resource "nodes" in API group "" at the cluster scope

而通常解决方法是执行下列命令，这里就是将 kubelet 与 kube-apiserver 通讯时的用户授权，因为 kubernetes 官方给出的条件是，用户组必须为 system:bootstrappers[10]

$ kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --group=system:bootstrappers

生成的 clusterrolebinding 如下

  1. apiVersion: rbac.authorization.k8s.io/v1
  2. kind: ClusterRoleBinding
  3. metadata:
  4.   creationTimestamp: "2022-08-14T22:26:51Z"
  5.   managedFields:
  6.   - apiVersion: rbac.authorization.k8s.io/v1
  7.     fieldsType: FieldsV1
  8.    ...
  9.     time: "2022-08-14T22:26:51Z"
  10.   name: kubelet-bootstrap
  11.   resourceVersion: "158"
  12.   selfLink: /apis/rbac.authorization.k8s.io/v1/clusterrolebindings/kubelet-bootstrap
  13.   uid: b4d70f4f-4ae0-468f-86b7-55e9351e4719
  14. roleRef:
  15.   apiGroup: rbac.authorization.k8s.io
  16.   kind: ClusterRole
  17.   name: system:node-bootstrapper
  18. subjects:
  19. - apiGroup: rbac.authorization.k8s.io
  20.   kind: Group
  21.   name: system:bootstrappers

上述就是 bootstrap token，翻译后就是引导 token，因为其做的工作就是将节点载入 Kubernetes 系统过程提供认证机制的用户。

❝

Notes：这种用户不存在与 kubernetes 内，可以算属于一个外部用户，但认证机制中存在并绑定了最高权限，也可以用来做其他访问时的认证

场景 3：serviceaccount

serviceaccount 通常为 API 自动创建的，但在用户中，实际上认证存在两个方向，一个是 --service-account-key-file 这个参数可以指定多个，指定对应的证书文件公钥或私钥，用以办法 sa 的 token

首先会根据指定的公钥或私钥文件生成 token

  1. if len(config.ServiceAccountKeyFiles) > 0 {
  2.     serviceAccountAuth, err := newLegacyServiceAccountAuthenticator(config.ServiceAccountKeyFiles, config.ServiceAccountLookup, config.APIAudiences, config.ServiceAccountTokenGetter)
  3.     if err != nil {
  4.         return nil, nil, err
  5.     }
  6.     tokenAuthenticators = append(tokenAuthenticators, serviceAccountAuth)
  7. }
  8. if len(config.ServiceAccountIssuers) > 0 {
  9.     serviceAccountAuth, err := newServiceAccountAuthenticator(config.ServiceAccountIssuers, config.ServiceAccountKeyFiles, config.APIAudiences, config.ServiceAccountTokenGetter)
  10.     if err != nil {
  11.         return nil, nil, err
  12.     }
  13.     tokenAuthenticators = append(tokenAuthenticators, serviceAccountAuth)
  14. }

对于  --service-account-key-file  他生成的用户都是 “kubernetes/serviceaccount”  , 而对于 --service-account-issuer 只是对 sa 颁发者提供了一个称号标识是谁，而不是统一的 “kubernetes/serviceaccount” ，这里可以从代码中看到，两者是完全相同的，只是称号不同罢了

  1. // newLegacyServiceAccountAuthenticator returns an authenticator.Token or an error
  2. func newLegacyServiceAccountAuthenticator(keyfiles []string, lookup bool, apiAudiences authenticator.Audiences, serviceAccountGetter serviceaccount.ServiceAccountTokenGetter) (authenticator.Token, error) {
  3.  allPublicKeys := []interface{}{}
  4.  for _, keyfile := range keyfiles {
  5.   publicKeys, err := keyutil.PublicKeysFromFile(keyfile)
  6.   if err != nil {
  7.    return nil, err
  8.   }
  9.   allPublicKeys = append(allPublicKeys, publicKeys...)
  10.  }
  11. // 唯一的区别 这里使用了常量 serviceaccount.LegacyIssuer
  12.  tokenAuthenticator := serviceaccount.JWTTokenAuthenticator([]string{serviceaccount.LegacyIssuer}, allPublicKeys, apiAudiences, serviceaccount.NewLegacyValidator(lookup, serviceAccountGetter))
  13.  return tokenAuthenticator, nil
  14. }
  15.  
  16. // newServiceAccountAuthenticator returns an authenticator.Token or an error
  17. func newServiceAccountAuthenticator(issuers []string, keyfiles []string, apiAudiences authenticator.Audiences, serviceAccountGetter serviceaccount.ServiceAccountTokenGetter) (authenticator.Token, error) {
  18.  allPublicKeys := []interface{}{}
  19.  for _, keyfile := range keyfiles {
  20.   publicKeys, err := keyutil.PublicKeysFromFile(keyfile)
  21.   if err != nil {
  22.    return nil, err
  23.   }
  24.   allPublicKeys = append(allPublicKeys, publicKeys...)
  25.  }
  26. // 唯一的区别 这里根据kube-apiserver提供的称号指定名称
  27.  tokenAuthenticator := serviceaccount.JWTTokenAuthenticator(issuers, allPublicKeys, apiAudiences, serviceaccount.NewValidator(serviceAccountGetter))
  28.  return tokenAuthenticator, nil
  29. }

最后根据 ServiceAccounts，Secrets 等值签发一个 token，也就是通过下列命令获取的值

$ kubectl get secret multus-token-v6bfg -n kube-system -o jsonpath={".data.token"}

场景 4：openid

OpenID Connect 是 OAuth2 风格，允许用户授权三方网站访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方网站或分享他们数据的所有内容，下面是一张 kubernetes 使用 OID 认证的逻辑图

a3c069f48c818ae6e883f6daf212f812.png
图：Kubernetes OID 认证

场景 5：webhook

webhook 是 kubernetes 提供自定义认证的其中一种，主要是用于认证 “不记名 token“ 的钩子，“不记名 token“ 将 由身份验证服务创建。当用户对 kubernetes 访问时，会触发准入控制，当对 kubernetes 集群注册了 authenticaion webhook 时，将会使用该 webhook 提供的方式进行身份验证时，此时会为您生成一个 token 。

如代码 pkg/kubeapiserver/authenticator.New()[11]  中所示 newWebhookTokenAuthenticator 会通过提供的 config (--authentication-token-webhook-config-file) 来创建出一个 WebhookTokenAuthenticator

  1. if len(config.WebhookTokenAuthnConfigFile) > 0 {
  2.     webhookTokenAuth, err := newWebhookTokenAuthenticator(config)
  3.     if err != nil {
  4.         return nil, nil, err
  5.     }
  6.  
  7.     tokenAuthenticators = append(tokenAuthenticators, webhookTokenAuth)
  8. }

下图是 kubernetes 中 WebhookToken 验证的工作原理

963ad58a9aa8cc18431921365c750cb8.png
图：kubernetes WebhookToken 验证原理

最后由 token 中的 authHandler，循环所有的 Handlers 在运行 AuthenticateToken 去进行获取用户的信息

  1. func (authHandler *unionAuthTokenHandler) AuthenticateToken(ctx context.Context, token string) (*authenticator.Response, bool, error) {
  2.    var errlist []error
  3.    for _, currAuthRequestHandler := range authHandler.Handlers {
  4.       info, ok, err := currAuthRequestHandler.AuthenticateToken(ctx, token)
  5.       if err != nil {
  6.          if authHandler.FailOnError {
  7.             return info, ok, err
  8.          }
  9.          errlist = append(errlist, err)
  10.          continue
  11.       }
  12.  
  13.       if ok {
  14.          return info, ok, err
  15.       }
  16.    }
  17.  
  18.    return nil, false, utilerrors.NewAggregate(errlist)
  19. }

而 webhook 插件也实现了这个方法 AuthenticateToken , 这里会通过 POST 请求，调用注入的 webhook，该请求携带一个 JSON 格式的 TokenReview 对象，其中包含要验证的令牌

  1. func (w *WebhookTokenAuthenticator) AuthenticateToken(ctx context.Context, token string) (*authenticator.Response, bool, error) {
  2.  
  3.     ....
  4.  
  5.   start := time.Now()
  6.   result, statusCode, tokenReviewErr = w.tokenReview.Create(ctx, r, metav1.CreateOptions{})
  7.   latency := time.Since(start)
  8. ...
  9. }

webhook token 认证服务要返回用户的身份信息[12]，就是上面 token 部分提到的数据结构（webhook 来决定接受还是拒绝该用户）

  1. type DefaultInfo struct {
  2.  Name   string
  3.  UID    string
  4.  Groups []string
  5.  Extra  map[string][]string
  6. }

场景 6：代理认证

实验：基于 LDAP 的身份认证

通过上面阐述，大致了解到 kubernetes 认证框架中的用户的分类以及认证的策略由哪些，实验的目的也是为了阐述一个结果，就是使用 OIDC/webhook 是比其他方式更好的保护，管理 kubernetes 集群。首先在安全上，假设网络环境是不安全的，那么任意 node 节点遗漏 bootstrap  token 文件，就意味着拥有了集群中最高权限；其次在管理上，越大的团队，人数越多，不可能每个用户都提供单独的证书或者 token，要知道传统教程中讲到 token 在 kubernetes 集群中是永久有效的，除非你删除了这个 secret/sa；而 Kubernetes 提供的插件就很好的解决了这些问题。

实验环境

  • 一个 kubernetes 集群

  • 一个 openldap 服务，建议可以是集群外部的，因为 webhook 不像 SSSD 有缓存机制，并且集群不可用，那么认证不可用，当认证不可用时会导致集群不可用，这样事故影响的范围可以得到控制，也叫最小化半径

  • 了解 ldap 相关技术，并了解 go ldap 客户端

实验大致分为以下几个步骤：

  • 建立一个 HTTP 服务器用于返回给 kubernetes Authenticaion 服务

  • 查询 ldap 该用户是否合法

    • 查询用户是否合法

    • 查询用户所属组是否拥有权限

实验开始

初始化用户数据

首先准备 openldap 初始化数据，创建三个 posixGroup 组，与 5 个用户 admin, admin1, admin11, searchUser, syncUser 密码均为 111，组与用户关联使用的 memberUid

  1. $ cat << EOF | ldapdelete -r  -H ldap://10.0.0.3 -D "cn=admin,dc=test,dc=com" -w 111
  2. dn: dc=test,dc=com
  3. objectClass: top
  4. objectClass: organizationalUnit
  5. objectClass: extensibleObject
  6. description: US Organization
  7. ou: people
  8.  
  9. dn: ou=tvb,dc=test,dc=com
  10. objectClass: organizationalUnit
  11. description: Television Broadcasts Limited
  12. ou: tvb
  13.  
  14. dn: cn=admin,ou=tvb,dc=test,dc=com
  15. objectClass: posixGroup
  16. gidNumber: 10000
  17. cn: admin
  18.  
  19. dn: cn=conf,ou=tvb,dc=test,dc=com
  20. objectClass: posixGroup
  21. gidNumber: 10001
  22. cn: conf
  23.  
  24. dn: cn=dir,ou=tvb,dc=test,dc=com
  25. objectClass: posixGroup
  26. gidNumber: 10002
  27. cn: dir
  28.  
  29. dn: uid=syncUser,ou=tvb,dc=test,dc=com
  30. objectClass: inetOrgPerson
  31. objectClass: organizationalPerson
  32. objectClass: person
  33. objectClass: posixAccount
  34. objectClass: shadowAccount
  35. objectClass: pwdPolicy
  36. pwdAttribute: userPassword
  37. uid: syncUser
  38. cn: syncUser
  39. uidNumber: 10006
  40. gidNumber: 10002
  41. homeDirectory: /home/syncUser
  42. loginShell: /bin/bash
  43. sn: syncUser
  44. givenName: syncUser
  45. memberOf: cn=confGroup,ou=tvb,dc=test,dc=com
  46.  
  47. dn: uid=searchUser,ou=tvb,dc=test,dc=com
  48. objectClass: inetOrgPerson
  49. objectClass: organizationalPerson
  50. objectClass: person
  51. objectClass: posixAccount
  52. objectClass: shadowAccount
  53. objectClass: pwdPolicy
  54. pwdAttribute: userPassword
  55. uid: searchUser
  56. cn: searchUser
  57. uidNumber: 10005
  58. gidNumber: 10001
  59. homeDirectory: /home/searchUser
  60. loginShell: /bin/bash
  61. sn: searchUser
  62. givenName: searchUser
  63. memberOf: cn=dirGroup,ou=tvb,dc=test,dc=com
  64.  
  65. dn: uid=admin1,ou=tvb,dc=test,dc=com
  66. objectClass: inetOrgPerson
  67. objectClass: organizationalPerson
  68. objectClass: person
  69. objectClass: posixAccount
  70. objectClass: shadowAccount
  71. objectClass: pwdPolicy
  72. pwdAttribute: userPassword
  73. uid: admin1
  74. sn: admin1
  75. cn: admin
  76. uidNumber: 10010
  77. gidNumber: 10000
  78. homeDirectory: /home/admin
  79. loginShell: /bin/bash
  80. givenName: admin
  81. memberOf: cn=adminGroup,ou=tvb,dc=test,dc=com
  82.  
  83. dn: uid=admin11,ou=tvb,dc=test,dc=com
  84. objectClass: inetOrgPerson
  85. objectClass: organizationalPerson
  86. objectClass: person
  87. objectClass: posixAccount
  88. objectClass: shadowAccount
  89. objectClass: pwdPolicy
  90. sn: admin11
  91. pwdAttribute: userPassword
  92. uid: admin11
  93. cn: admin11
  94. uidNumber: 10011
  95. gidNumber: 10000
  96. homeDirectory: /home/admin
  97. loginShell: /bin/bash
  98. givenName: admin11
  99. memberOf: cn=adminGroup,ou=tvb,dc=test,dc=com
  100.  
  101. dn: uid=admin,ou=tvb,dc=test,dc=com
  102. objectClass: inetOrgPerson
  103. objectClass: organizationalPerson
  104. objectClass: person
  105. objectClass: posixAccount
  106. objectClass: shadowAccount
  107. objectClass: pwdPolicy
  108. pwdAttribute: userPassword
  109. uid: admin
  110. cn: admin
  111. uidNumber: 10009
  112. gidNumber: 10000
  113. homeDirectory: /home/admin
  114. loginShell: /bin/bash
  115. sn: admin
  116. givenName: admin
  117. memberOf: cn=adminGroup,ou=tvb,dc=test,dc=com
  118. EOF

接下来需要确定如何为认证成功的用户，上面讲到对于 kubernetes 中用户格式为 v1.UserInfo 的格式，即要获得用户，即用户组，假设需要查找的用户为，admin，那么在 openldap 中查询 filter 如下：

"(|(&(objectClass=posixAccount)(uid=admin))(&(objectClass=posixGroup)(memberUid=admin)))"

上面语句意思是，找到 objectClass=posixAccount 并且 uid=admin 或者 objectClass=posixGroup 并且 memberUid=admin 的条目信息，这里使用 ”|“ 与 ”&“ 是为了要拿到这两个结果。

编写 webhook 查询用户部分

这里由于 openldap 配置密码保存格式不是明文的，如果直接使用 ”=“ 来验证是查询不到内容的，故直接多用了一次登录来验证用户是否合法

  1. func ldapSearch(username, password string) (*v1.UserInfo, error) {
  2.  ldapconn, err := ldap.DialURL(ldapURL)
  3.  if err != nil {
  4.   klog.V(3).Info(err)
  5.   return nil, err
  6.  }
  7.  defer ldapconn.Close()
  8.  
  9.  // Authenticate as LDAP admin user
  10.  err = ldapconn.Bind("uid=searchUser,ou=tvb,dc=test,dc=com", "111")
  11.  if err != nil {
  12.   klog.V(3).Info(err)
  13.   return nil, err
  14.  }
  15.  
  16.  // Execute LDAP Search request
  17.  result, err := ldapconn.Search(ldap.NewSearchRequest(
  18.   "ou=tvb,dc=test,dc=com",
  19.   ldap.ScopeWholeSubtree,
  20.   ldap.NeverDerefAliases,
  21.   0,
  22.   0,
  23.   false,
  24.   fmt.Sprintf("(&(objectClass=posixGroup)(memberUid=%s))", username), // Filter
  25.   nil,
  26.   nil,
  27.  ))
  28.  
  29.  if err != nil {
  30.   klog.V(3).Info(err)
  31.   return nil, err
  32.  }
  33.  
  34.  userResult, err := ldapconn.Search(ldap.NewSearchRequest(
  35.   "ou=tvb,dc=test,dc=com",
  36.   ldap.ScopeWholeSubtree,
  37.   ldap.NeverDerefAliases,
  38.   0,
  39.   0,
  40.   false,
  41.   fmt.Sprintf("(&(objectClass=posixAccount)(uid=%s))", username), // Filter
  42.   nil,
  43.   nil,
  44.  ))
  45.  
  46.  if err != nil {
  47.   klog.V(3).Info(err)
  48.   return nil, err
  49.  }
  50.  
  51.  if len(result.Entries) == 0 {
  52.   klog.V(3).Info("User does not exist")
  53.   return nil, errors.New("User does not exist")
  54.  } else {
  55.   // 验证用户名密码是否正确
  56.   if err := ldapconn.Bind(userResult.Entries[0].DN, password); err != nil {
  57.    e := fmt.Sprintf("Failed to auth. %s\n", err)
  58.    klog.V(3).Info(e)
  59.    return nil, errors.New(e)
  60.   } else {
  61.    klog.V(3).Info(fmt.Sprintf("User %s Authenticated successfuly!", username))
  62.   }
  63.   // 拼接为kubernetes authentication 的用户格式
  64.   user := new(v1.UserInfo)
  65.   for _, v := range result.Entries {
  66.    attrubute := v.GetAttributeValue("objectClass")
  67.    if strings.Contains(attrubute, "posixGroup") {
  68.     user.Groups = append(user.Groups, v.GetAttributeValue("cn"))
  69.    }
  70.   }
  71.  
  72.   u := userResult.Entries[0].GetAttributeValue("uid")
  73.   user.UID = u
  74.   user.Username = u
  75.   return user, nil
  76.  }
  77. }
编写 HTTP 部分

这里有几个需要注意的部分，即用户或者理解为要认证的 token 的定义，此处使用了 ”username@password“ 格式作为用户的辨别，即登录 kubernetes 时需要直接输入 ”username@password“ 来作为登录的凭据。

第二个部分为返回值，返回给 Kubernetes 的格式必须为 api/authentication/v1.TokenReview 格式，Status.Authenticated 表示用户身份验证结果，如果该用户合法，则设置 tokenReview.Status.Authenticated = true 反之亦然。如果验证成功还需要 Status.User 这就是在 ldapSearch

  1. func serve(w http.ResponseWriter, r *http.Request) {
  2.  b, err := ioutil.ReadAll(r.Body)
  3.  if err != nil {
  4.   httpError(w, err)
  5.   return
  6.  }
  7.  klog.V(4).Info("Receiving: %s\n", string(b))
  8.  
  9.  var tokenReview v1.TokenReview
  10.  err = json.Unmarshal(b, &tokenReview)
  11.  if err != nil {
  12.   klog.V(3).Info("Json convert err: ", err)
  13.   httpError(w, err)
  14.   return
  15.  }
  16.  
  17.  // 提取用户名与密码
  18.  s := strings.SplitN(tokenReview.Spec.Token, "@", 2)
  19.  if len(s) != 2 {
  20.   klog.V(3).Info(fmt.Errorf("badly formatted token: %s", tokenReview.Spec.Token))
  21.   httpError(w, fmt.Errorf("badly formatted token: %s", tokenReview.Spec.Token))
  22.   return
  23.  }
  24.  username, password := s[0], s[1]
  25.  // 查询ldap，验证用户是否合法
  26.  userInfo, err := ldapSearch(username, password)
  27.  if err != nil {
  28.   // 这里不打印日志的原因是 ldapSearch 中打印过了
  29.   return
  30.  }
  31.  
  32.  // 设置返回的tokenReview
  33.  if userInfo == nil {
  34.   tokenReview.Status.Authenticated = false
  35.  } else {
  36.   tokenReview.Status.Authenticated = true
  37.   tokenReview.Status.User = *userInfo
  38.  }
  39.  
  40.  b, err = json.Marshal(tokenReview)
  41.  if err != nil {
  42.   klog.V(3).Info("Json convert err: ", err)
  43.   httpError(w, err)
  44.   return
  45.  }
  46.  w.Write(b)
  47.  klog.V(3).Info("Returning: ", string(b))
  48. }
  49.  
  50. func httpError(w http.ResponseWriter, err error) {
  51.  err = fmt.Errorf("Error: %v", err)
  52.  w.WriteHeader(http.StatusInternalServerError) // 500
  53.  fmt.Fprintln(w, err)
  54.  klog.V(4).Info("httpcode 500: ", err)
  55. }

下面是完整的代码

  1. package main
  2.  
  3. import (
  4.  "encoding/json"
  5.  "errors"
  6.  "flag"
  7.  "fmt"
  8.  "io/ioutil"
  9.  "net/http"
  10.  "strings"
  11.  
  12.  "github.com/go-ldap/ldap"
  13.  "k8s.io/api/authentication/v1"
  14.  "k8s.io/klog/v2"
  15. )
  16.  
  17. var ldapURL string
  18.  
  19. func main() {
  20.  klog.InitFlags(nil)
  21.  flag.Parse()
  22.  http.HandleFunc("/authenticate", serve)
  23.  klog.V(4).Info("Listening on port 443 waiting for requests...")
  24.  klog.V(4).Info(http.ListenAndServe(":443", nil))
  25.  ldapURL = "ldap://10.0.0.10:389"
  26.  ldapSearch("admin", "1111")
  27. }
  28.  
  29. func serve(w http.ResponseWriter, r *http.Request) {
  30.  b, err := ioutil.ReadAll(r.Body)
  31.  if err != nil {
  32.   httpError(w, err)
  33.   return
  34.  }
  35.  klog.V(4).Info("Receiving: %s\n", string(b))
  36.  
  37.  var tokenReview v1.TokenReview
  38.  err = json.Unmarshal(b, &tokenReview)
  39.  if err != nil {
  40.   klog.V(3).Info("Json convert err: ", err)
  41.   httpError(w, err)
  42.   return
  43.  }
  44.  
  45.  // 提取用户名与密码
  46.  s := strings.SplitN(tokenReview.Spec.Token, "@", 2)
  47.  if len(s) != 2 {
  48.   klog.V(3).Info(fmt.Errorf("badly formatted token: %s", tokenReview.Spec.Token))
  49.   httpError(w, fmt.Errorf("badly formatted token: %s", tokenReview.Spec.Token))
  50.   return
  51.  }
  52.  username, password := s[0], s[1]
  53.  // 查询ldap，验证用户是否合法
  54.  userInfo, err := ldapSearch(username, password)
  55.  if err != nil {
  56.   // 这里不打印日志的原因是 ldapSearch 中打印过了
  57.   return
  58.  }
  59.  
  60.  // 设置返回的tokenReview
  61.  if userInfo == nil {
  62.   tokenReview.Status.Authenticated = false
  63.  } else {
  64.   tokenReview.Status.Authenticated = true
  65.   tokenReview.Status.User = *userInfo
  66.  }
  67.  
  68.  b, err = json.Marshal(tokenReview)
  69.  if err != nil {
  70.   klog.V(3).Info("Json convert err: ", err)
  71.   httpError(w, err)
  72.   return
  73.  }
  74.  w.Write(b)
  75.  klog.V(3).Info("Returning: ", string(b))
  76. }
  77.  
  78. func httpError(w http.ResponseWriter, err error) {
  79.  err = fmt.Errorf("Error: %v", err)
  80.  w.WriteHeader(http.StatusInternalServerError) // 500
  81.  fmt.Fprintln(w, err)
  82.  klog.V(4).Info("httpcode 500: ", err)
  83. }
  84.  
  85. func ldapSearch(username, password string) (*v1.UserInfo, error) {
  86.  
  87.  ldapconn, err := ldap.DialURL(ldapURL)
  88.  if err != nil {
  89.   klog.V(3).Info(err)
  90.   return nil, err
  91.  }
  92.  defer ldapconn.Close()
  93.  
  94.  // Authenticate as LDAP admin user
  95.  err = ldapconn.Bind("cn=admin,dc=test,dc=com", "111")
  96.  if err != nil {
  97.   klog.V(3).Info(err)
  98.   return nil, err
  99.  }
  100.  
  101.  // Execute LDAP Search request
  102.  result, err := ldapconn.Search(ldap.NewSearchRequest(
  103.   "ou=tvb,dc=test,dc=com",
  104.   ldap.ScopeWholeSubtree,
  105.   ldap.NeverDerefAliases,
  106.   0,
  107.   0,
  108.   false,
  109.   fmt.Sprintf("(&(objectClass=posixGroup)(memberUid=%s))", username), // Filter
  110.   nil,
  111.   nil,
  112.  ))
  113.  
  114.  if err != nil {
  115.   klog.V(3).Info(err)
  116.   return nil, err
  117.  }
  118.  
  119.  userResult, err := ldapconn.Search(ldap.NewSearchRequest(
  120.   "ou=tvb,dc=test,dc=com",
  121.   ldap.ScopeWholeSubtree,
  122.   ldap.NeverDerefAliases,
  123.   0,
  124.   0,
  125.   false,
  126.   fmt.Sprintf("(&(objectClass=posixAccount)(uid=%s))", username), // Filter
  127.   nil,
  128.   nil,
  129.  ))
  130.  
  131.  if err != nil {
  132.   klog.V(3).Info(err)
  133.   return nil, err
  134.  }
  135.  
  136.  if len(result.Entries) == 0 {
  137.   klog.V(3).Info("User does not exist")
  138.   return nil, errors.New("User does not exist")
  139.  } else {
  140.   // 验证用户名密码是否正确
  141.   if err := ldapconn.Bind(userResult.Entries[0].DN, password); err != nil {
  142.    e := fmt.Sprintf("Failed to auth. %s\n", err)
  143.    klog.V(3).Info(e)
  144.    return nil, errors.New(e)
  145.   } else {
  146.    klog.V(3).Info(fmt.Sprintf("User %s Authenticated successfuly!", username))
  147.   }
  148.   // 拼接为kubernetes authentication 的用户格式
  149.   user := new(v1.UserInfo)
  150.   for _, v := range result.Entries {
  151.    attrubute := v.GetAttributeValue("objectClass")
  152.    if strings.Contains(attrubute, "posixGroup") {
  153.     user.Groups = append(user.Groups, v.GetAttributeValue("cn"))
  154.    }
  155.   }
  156.  
  157.   u := userResult.Entries[0].GetAttributeValue("uid")
  158.   user.UID = u
  159.   user.Username = u
  160.   return user, nil
  161.  }
  162. }

部署 webhook

kubernetes 官方手册中指出，启用 webhook 认证的标记是在 kube-apiserver 指定参数 --authentication-token-webhook-config-file 。而这个配置文件是一个 kubeconfig 类型的文件格式[13]。

下列是部署在 kubernetes 集群外部的配置。

创建一个给 kube-apiserver 使用的配置文件 /etc/kubernetes/auth/authentication-webhook.conf

  1. apiVersion: v1
  2. kind: Config
  3. clusters:
  4. - cluster:
  5.     server: http://10.0.0.1:88/authenticate
  6.   name: authenticator
  7. users:
  8. - name: webhook-authenticator
  9. current-context: webhook-authenticator@authenticator
  10. contexts:
  11. - context:
  12.     cluster: authenticator
  13.     user: webhook-authenticator
  14.   name: webhook-authenticator@authenticator

修改 kube-apiserver 参数

  1. # 指向对应的配置文件
  2. --authentication-token-webhook-config-file=/etc/kubernetes/auth/authentication-webhook.conf
  3. # 这个是token缓存时间，指的是用户在访问API时验证通过后在一定时间内无需在请求webhook进行认证了
  4. --authentication-token-webhook-cache-ttl=30m
  5. # 版本指定为API使用哪个版本？authentication.k8s.io/v1或v1beta1
  6. --authentication-token-webhook-version=v1

启动服务后，创建一个 kubeconfig 中的用户用于验证结果

  1. apiVersion: v1
  2. clusters:
  3. - cluster:
  4.     certificate-authority-data: 
  5.     server: https://10.0.0.4:6443
  6.   name: kubernetes
  7. contexts:
  8. - context:
  9.     cluster: kubernetes
  10.     user: k8s-admin
  11.   name: k8s-admin@kubernetes
  12. current-context: k8s-admin@kubernetes
  13. kind: Config
  14. preferences: {}
  15. users:
  16. - name: admin
  17.   user: 
  18.     token: admin@111

验证结果

当密码不正确时，使用用户 admin 请求集群

  1. $ kubectl get pods --user=admin
  2. error: You must be logged in to the server (Unauthorized)

当密码正确时，使用用户 admin 请求集群

  1. $ kubectl get pods --user=admin
  2. Error from server (Forbidden): pods is forbidden: User "admin" cannot list resource "pods" in API group "" in the namespace "default"

可以看到 admin 用户是一个不存在与集群中的用户，并且提示没有权限操作对应资源，此时将 admin 用户与集群中的 cluster-admin 绑定，测试结果

  1. $ kubectl create clusterrolebinding admin \
  2.  --clusterrole=cluster-admin \
  3.  --group=admin

此时再尝试使用 admin 用户访问集群

  1. $ kubectl get pods --user=admin
  2. NAME                      READY   STATUS    RESTARTS   AGE
  3. netbox-85865d5556-hfg6v   1/1     Running   0          91d
  4. netbox-85865d5556-vlgr4   1/1     Running   0          91d

总结

kubernetes authentication  插件提供的功能可以注入一个认证系统，这样可以完美解决了 kubernetes 中用户的问题，而这些用户并不存在与 kubernetes 中，并且也无需为多个用户准备大量 serviceaccount 或者证书，也可以完成鉴权操作。首先返回值标准如下所示，如果 kubernetes 集群有对在其他用户系统中获得的 Groups 并建立了 clusterrolebinding 或 rolebinding 那么这个组的所有用户都将有这些权限。管理员只需要维护与公司用户系统中组同样多的 clusterrole 与 clusterrolebinding 即可

  1. type DefaultInfo struct {
  2.  Name   string
  3.  UID    string
  4.  Groups []string
  5.  Extra  map[string][]string
  6. }

对于如何将 kubernetes 与其他平台进行融合可以参考 基于 Kubernetes 的 PaaS 平台提供 dashboard 支持的一种方案[14]。

引用链接

[1]

kubernetes service account: https://kubernetes.io/docs/concepts/security/controlling-access/

[2]

Kubernetes 给出了多种用户概念: https://kubernetes.io/docs/reference/access-authn-authz/authentication/#users-in-kubernetes

[3]

pkg/kubeapiserver/authenticator: https://www.cnblogs.com/Cylon/p/pkg/kubeapiserver/authenticator

[4]

k8s.io/apiserver/pkg/authentication/request/x509/x509.go: https://github.com/kubernetes/kubernetes/blob/fdc77503e954d1ee641c0e350481f7528e8d068b/staging/src/k8s.io/apiserver/pkg/authentication/request/x509/x509.go#L126-L130

[5]

k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_cafile_content.go.VerifyOptions: https://github.com/kubernetes/kubernetes/blob/fdc77503e954d1ee641c0e350481f7528e8d068b/staging/src/k8s.io/apiserver/pkg/server/dynamiccertificates/dynamic_cafile_content.go#L253-L261

[6]

k8s.io/apiserver/pkg/authentication/request/x509/x509.go: https://github.com/kubernetes/kubernetes/blob/fdc77503e954d1ee641c0e350481f7528e8d068b/staging/src/k8s.io/apiserver/pkg/authentication/request/x509/x509.go#L248-L258

[7]

RESTStorageProvider: https://github.com/kubernetes/kubernetes/blob/fdc77503e954d1ee641c0e350481f7528e8d068b/pkg/controlplane/instance.go#L561

[8]

pkg/kubeapiserver/authenticator.New(): https://github.com/kubernetes/kubernetes/tree/fdc77503e954d1ee641c0e350481f7528e8d068b/pkg/kubeapiserver/authenticator

[9]

k8s.io/apiserver/pkg/authentication/token/tokenfile/tokenfile.go.NewCSV: https://github.com/kubernetes/kubernetes/blob/fdc77503e954d1ee641c0e350481f7528e8d068b/staging/src/k8s.io/apiserver/pkg/authentication/token/tokenfile/tokenfile.go#L45-L91

[10]

system:bootstrappers: https://kubernetes.io/docs/reference/access-authn-authz/authentication/#bootstrap-tokens

[11]

pkg/kubeapiserver/authenticator.New(): https://github.com/kubernetes/kubernetes/blob/fdc77503e954d1ee641c0e350481f7528e8d068b/pkg/kubeapiserver/authenticator

[12]

用户的身份信息: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#userinfo-v1beta1-authentication-k8s-io

[13]

kubeconfig 类型的文件格式: https://kubernetes.io/docs/reference/access-authn-authz/authentication/#webhook-token-authentication

[14]

基于 Kubernetes 的 PaaS 平台提供 dashboard 支持的一种方案: https://cylonchau.github.io/kubernetes-dashborad-based.html

04a5f781a4c2d20c3db7f5cc268860c1.gif

ddc496863b73dd1e6fcc5e744eeb4999.png

你可能还喜欢

点击下方图片即可阅读

彻底解决 K8s 节点本地存储被撑爆的问题

2022-11-22

4e4ed7ec0cc4920a9c68903124044f51.jpeg

Karmada 如何跨集群实现完整的自定义资源分发能力？

2022-11-21

f3e40a05c46c95f064d54455f02ab148.jpeg

Cilium 未来数据平面：支撑 100Gbit/s k8s 集群

2022-11-14

dc9079e0fe712e446c076165c3e61a8a.jpeg

Prometheus 官方记录片（中英双语），带你了解 Prometheus 的前世今生

2022-11-11

443fba863822e8b585eed40b8cecd8a0.jpeg

d5ffba4338c6c7578c791e95ab22babf.gif

云原生是一种信仰 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/578814
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。