服务器之家：专注于服务器技术及软件下载分享
分类导航

云服务器|WEB服务器|FTP服务器|邮件服务器|虚拟主机|服务器安全|DNS服务器|服务器知识|Nginx|IIS|Tomcat|

服务器之家 - 服务器技术 - 服务器知识 - K8S自定义Webhook实现认证管理

K8S自定义Webhook实现认证管理

2021-12-08 22:46运维开发故事乔克 服务器知识

在Kubernetes中，APIServer是整个集群的中枢神经，它不仅连接了各个模块，更是为整个集群提供了访问控制能力。这篇文章主要和大家讨论认证环节。

K8S自定义Webhook实现认证管理

大家好，我是乔克。

在Kubernetes中，APIServer是整个集群的中枢神经，它不仅连接了各个模块，更是为整个集群提供了访问控制能力。

Kubernetes API的每个请求都要经过多阶段的访问控制才会被接受，包括认证、授权、准入，如下所示。

K8S自定义Webhook实现认证管理

客户端(普通账户、ServiceAccount等)想要访问Kubernetes中的资源，需要通过经过APIServer的三大步骤才能正常访问，三大步骤如下：

  1. Authentication 认证阶段：判断请求用户是否为能够访问集群的合法用户。如果用户是个非法用户，那 apiserver会返回一个 401 的状态码，并终止该请求;
  2. 如果用户合法的话，我们的 apiserver 会进入到访问控制的第二阶段 Authorization：授权阶段。在该阶段中apiserver 会判断用户是否有权限进行请求中的操作。如果无权进行操作，apiserver 会返回 403的状态码，并同样终止该请求;
  3. 如果用户有权进行该操作的话，访问控制会进入到第三个阶段：AdmissionControl。在该阶段中 apiserver 的admission controller 会判断请求是否是一个安全合规的请求。如果最终验证通过的话，访问控制流程才会结束。

这篇文章主要和大家讨论认证环节。

认证

Kubernetes中支持多种认证机制，也支持多种认证插件，在认证过程中，只要一个通过则表示认证通过。

常用的认证插件有：

  • X509证书
  • 静态Token
  • ServiceAccount
  • OpenID
  • Webhook
  • .....

这里不会把每种认证插件都介绍一下，主要讲讲Webhook的使用场景。

在企业中，大部分都会有自己的账户中心，用于管理员工的账户以及权限，而在K8s集群中，也需要进行账户管理，如果能直接使用现有的账户系统是不是会方便很多?

K8s的Webhook就可以实现这种需求，Webhook是一个HTTP回调，通过一个条件触发HTTP POST请求发送到Webhook 服务端，服务端根据请求数据进行处理。

下面就带大家从0到1开发一个认证服务。

开发Webhook

简介

WebHook的功能主要是接收APIServer的认证请求，然后调用不同的认证服务进行认证，如下所示。

K8S自定义Webhook实现认证管理

这里只是做一个Webhook的例子，目前主要实现了Github和LDAP认证，当然，认证部分的功能比较单一，没有考虑复杂的场景。

Webhook开发

开发环境

K8S自定义Webhook实现认证管理

构建符合规范的Webhook

在开发Webhook的时候，需要符合Kubernetes的规范，具体如下：

  • URL：https://auth.example.com/auth
  • Method：POST
  • Input参数
  1. {
  2. "apiVersion": "authentication.k8s.io/v1beta1",
  3. "kind": "TokenReview",
  4. "spec": {
  5. "token": "<持有者令牌>"
  6. }
  7. }
  • Output参数

如果成功会返回：

  1. {
  2. "apiVersion": "authentication.k8s.io/v1beta1",
  3. "kind": "TokenReview",
  4. "status": {
  5. "authenticated": true,
  6. "user": {
  7. "username": "janedoe@example.com",
  8. "uid": "42",
  9. "groups": [
  10. "developers",
  11. "qa"
  12. ],
  13. "extra": {
  14. "extrafield1": [
  15. "extravalue1",
  16. "extravalue2"
  17. ]
  18. }
  19. }
  20. }
  21. }

如果不成功，会返回：

  1. {
  2. "apiVersion": "authentication.k8s.io/v1beta1",
  3. "kind": "TokenReview",
  4. "status": {
  5. "authenticated": false
  6. }
  7. }

远程服务应该会填充请求的 status 字段，以标明登录操作是否成功。

开发认证服务

(1)创建项目并初始化go mod

  1. # mkdir kubernetes-auth-webhook
  2. # cd kubernetes-auth-webhook
  3. # go mod init

(2)在项目根目录下创建webhook.go，写入如下内容

  1. package main
  3. import (
  4. "encoding/json"
  5. "github.com/golang/glog"
  6. authentication "k8s.io/api/authentication/v1beta1"
  7. "k8s.io/klog/v2"
  8. "net/http"
  9. "strings"
  10. )
  12. type WebHookServer struct {
  13. server *http.Server
  14. }
  16. func (ctx *WebHookServer) serve(w http.ResponseWriter, r *http.Request) {
  17. // 从APIServer中取出body
  18. // 将body进行拆分, 取出type
  19. // 根据type, 取出不同的认证数据
  20. var req authentication.TokenReview
  21. decoder := json.NewDecoder(r.Body)
  22. err := decoder.Decode(&req)
  23. if err != nil {
  24. klog.Error(err, "decoder request body error.")
  25. req.Status = authentication.TokenReviewStatus{Authenticated: false}
  26. w.WriteHeader(http.StatusUnauthorized)
  27. _ = json.NewEncoder(w).Encode(req)
  28. return
  29. }
  30. // 判断token是否包含':'
  31. // 如果不包含，则返回认证失败
  32. if !(strings.Contains(req.Spec.Token, ":")) {
  33. klog.Error(err, "token invalied.")
  34. req.Status = authentication.TokenReviewStatus{Authenticated: false}
  35. //req.Status = map[string]interface{}{"authenticated": false}
  36. w.WriteHeader(http.StatusUnauthorized)
  37. _ = json.NewEncoder(w).Encode(req)
  38. return
  39. }
  40. // split token, 获取type
  41. tokenSlice := strings.SplitN(req.Spec.Token, ":", -1)
  42. glog.Infof("tokenSlice: ", tokenSlice)
  43. hookType := tokenSlice[0]
  44. switch hookType {
  45. case "github":
  46. githubToken := tokenSlice[1]
  47. err := authByGithub(githubToken)
  48. if err != nil {
  49. klog.Error(err, "auth by github error")
  50. req.Status = authentication.TokenReviewStatus{Authenticated: false}
  51. w.WriteHeader(http.StatusUnauthorized)
  52. _ = json.NewEncoder(w).Encode(req)
  53. return
  54. }
  55. klog.Info("auth by github success")
  56. req.Status = authentication.TokenReviewStatus{Authenticated: true}
  57. w.WriteHeader(http.StatusOK)
  58. _ = json.NewEncoder(w).Encode(req)
  59. return
  60. case "ldap":
  61. username := tokenSlice[1]
  62. password := tokenSlice[2]
  63. err := authByLdap(username, password)
  64. if err != nil {
  65. klog.Error(err, "auth by ldap error")
  66. req.Status = authentication.TokenReviewStatus{Authenticated: false}
  67. //req.Status = map[string]interface{}{"authenticated": false}
  68. w.WriteHeader(http.StatusUnauthorized)
  69. _ = json.NewEncoder(w).Encode(req)
  70. return
  71. }
  72. klog.Info("auth by ldap success")
  73. req.Status = authentication.TokenReviewStatus{Authenticated: true}
  74. //req.Status = map[string]interface{}{"authenticated": true}
  75. w.WriteHeader(http.StatusOK)
  76. _ = json.NewEncoder(w).Encode(req)
  77. return
  78. }
  79. }

主要是解析认证的请求Token，然后将Token进行拆分判断是需要什么认证，Token的样例如下：

  • Github认证：github:
  • LDAP认证：ldap::

这样就可以获取到用户想用哪种认证，再掉具体的认证服务进行处理。

(3)创建github.go，提供github认证方法

  1. package main
  3. import (
  4. "context"
  5. "github.com/golang/glog"
  6. "github.com/google/go-github/github"
  7. "golang.org/x/oauth2"
  8. )
  10. func authByGithub(token string) (err error) {
  11. glog.V(2).Info("start auth by github......")
  12. tokenSource := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
  13. tokenClient := oauth2.NewClient(context.Background(), tokenSource)
  14. githubClient := github.NewClient(tokenClient)
  15. _, _, err = githubClient.Users.Get(context.Background(), "")
  16. if err != nil {
  17. return err
  18. }
  19. return nil
  20. }

可以看到，这里仅仅做了一个简单的Token认证，认证的结果比较粗暴，如果err=nil，则表示认证成功。

(4)创建ldap.go，提供ldap认证

  1. package main
  3. import (
  4. "crypto/tls"
  5. "errors"
  6. "fmt"
  7. "github.com/go-ldap/ldap/v3"
  8. "github.com/golang/glog"
  9. "k8s.io/klog/v2"
  10. "strings"
  11. )
  13. var (
  14. ldapUrl = "ldap://" + "192.168.100.179:389"
  15. )
  17. func authByLdap(username, password string) error {
  18. groups, err := getLdapGroups(username, password)
  19. if err != nil {
  20. return err
  21. }
  22. if len(groups) > 0 {
  23. return nil
  24. }
  26. return fmt.Errorf("No matching group or user attribute. Authentication rejected, Username: %s", username)
  27. }
  29. // 获取user的groups
  30. func getLdapGroups(username, password string) ([]string, error) {
  31. glog.Info("username:password", username, ":", password)
  32. var groups []string
  34. config := &tls.Config{InsecureSkipVerify: true}
  35. ldapConn, err := ldap.DialURL(ldapUrl, ldap.DialWithTLSConfig(config))
  36. if err != nil {
  37. glog.V(4).Info("dial ldap failed, err: ", err)
  38. return groups, err
  39. }
  40. defer ldapConn.Close()
  42. binduser := fmt.Sprintf("CN=%s,ou=People,dc=demo,dc=com", username)
  44. err = ldapConn.Bind(binduser, password)
  45. if err != nil {
  46. klog.V(4).ErrorS(err, "bind user to ldap error")
  47. return groups, err
  48. }
  50. // 查询用户成员
  51. searchString := fmt.Sprintf("(&(objectClass=person)(cn=%s))", username)
  52. memberSearchAttribute := "memberOf"
  53. searchRequest := ldap.NewSearchRequest(
  54. "dc=demo,dc=com",
  55. ldap.ScopeWholeSubtree,
  56. ldap.NeverDerefAliases,
  57. 0,
  58. 0,
  59. false,
  60. searchString,
  61. []string{memberSearchAttribute},
  62. nil,
  63. )
  64. searchResult, err := ldapConn.Search(searchRequest)
  65. if err != nil {
  66. klog.V(4).ErrorS(err, "search user properties error")
  67. return groups, err
  68. }
  69. // 如果没有查到结果，返回失败
  70. if len(searchResult.Entries[0].Attributes) < 1 {
  71. return groups, errors.New("no user in ldap")
  72. }
  73. entry := searchResult.Entries[0]
  74. for _, e := range entry.Attributes {
  75. for _, attr := range e.Values {
  76. groupList := strings.Split(attr, ",")
  77. for _, g := range groupList {
  78. if strings.HasPrefix(g, "cn=") {
  79. group := strings.Split(g, "=")
  80. groups = append(groups, group[1])
  81. }
  82. }
  83. }
  84. }
  85. return groups, nil
  86. }

这里的用户名是固定了的，所以不适合其他场景。

(5)创建main.go入口函数

  1. package main
  3. import (
  4. "context"
  5. "flag"
  6. "fmt"
  7. "github.com/golang/glog"
  8. "net/http"
  9. "os"
  10. "os/signal"
  11. "syscall"
  12. )
  14. var port string
  16. func main() {
  17. flag.StringVar(&port, "port", "9999", "http server port")
  18. flag.Parse()
  19. // 启动httpserver
  20. wbsrv := WebHookServer{server: &http.Server{
  21. Addr: fmt.Sprintf(":%v", port),
  22. }}
  23. mux := http.NewServeMux()
  24. mux.HandleFunc("/auth", wbsrv.serve)
  25. wbsrv.server.Handler = mux
  27. // 启动协程来处理
  28. go func() {
  29. if err := wbsrv.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
  30. glog.Errorf("Failed to listen and serve webhook server: %v", err)
  31. }
  32. }()
  34. glog.Info("Server started")
  36. // 优雅退出
  37. signalChan := make(chan os.Signal, 1)
  38. signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
  39. <-signalChan
  41. glog.Infof("Got OS shutdown signal, shutting down webhook server gracefully...")
  42. _ = wbsrv.server.Shutdown(context.Background())
  43. }

到此整个认证服务就开发完毕了，是不是很简单?

Webhook测试

APIServer添加认证服务

使用Webhook进行认证，需要在kube-apiserver里开启，参数如下：

  • --authentication-token-webhook-config-file 指向一个配置文件，其中描述 如何访问远程的 Webhook 服务
  • --authentication-token-webhook-config-file 指向一个配置文件，其中描述 如何访问远程的 Webhook 服务

配置文件使用 kubeconfig 文件的格式。文件中，clusters 指代远程服务，users 指代远程 API 服务 Webhook。配置如下：

(1)、将配置文件放到相应的目录

  1. # mkdir /etc/kubernetes/webhook
  2. # cat >> webhook-config.json
  3. {
  4. "kind": "Config",
  5. "apiVersion": "v1",
  6. "preferences": {},
  7. "clusters": [
  8. {
  9. "name": "github-authn",
  10. "cluster": {
  11. "server": "http://10.0.4.9:9999/auth"
  12. }
  13. }
  14. ],
  15. "users": [
  16. {
  17. "name": "authn-apiserver",
  18. "user": {
  19. "token": "secret"
  20. }
  21. }
  22. ],
  23. "contexts": [
  24. {
  25. "name": "webhook",
  26. "context": {
  27. "cluster": "github-authn",
  28. "user": "authn-apiserver"
  29. }
  30. }
  31. ],
  32. "current-context": "webhook"
  33. }
  34. EOF

(2)在kube-apiserver中添加配置参数

  1. # mkdir /etc/kubernetes/backup
  2. # cp /etc/kubernetes/manifests/kube-apiserver.yaml /etc/kubernetes/backup/kube-apiserver.yaml
  3. # cd /etc/kubernetes/manifests/
  4. # cat kube-apiserver.yaml
  5. apiVersion: v1
  6. kind: Pod
  7. metadata:
  8. annotations:
  9. kubeadm.kubernetes.io/kube-apiserver.advertise-address.endpoint: 10.0.4.9:6443
  10. creationTimestamp: null
  11. labels:
  12. component: kube-apiserver
  13. tier: control-plane
  14. name: kube-apiserver
  15. namespace: kube-system
  16. spec:
  17. containers:
  18. - command:
  19. - kube-apiserver
  20. - ......
  21. - --authentication-token-webhook-config-file=/etc/config/webhook-config.json
  22. image: registry.cn-hangzhou.aliyuncs.com/google_containers/kube-apiserver:v1.22.0
  23. imagePullPolicy: IfNotPresent
  24. ......
  25. volumeMounts:
  26. ......
  27. - name: webhook-config
  28. mountPath: /etc/config
  29. readOnly: true
  30. hostNetwork: true
  31. priorityClassName: system-node-critical
  32. securityContext:
  33. seccompProfile:
  34. type: RuntimeDefault
  35. volumes:
  36. ......
  37. - hostPath:
  38. path: /etc/kubernetes/webhook
  39. type: DirectoryOrCreate
  40. name: webhook-config
  41. status: {}

ps: 为了节约篇幅，上面省略了部分配置。

当修改完过后，kube-apiserver会自动重启。

测试Github认证

(1)在github上获取Token，操作如图所示

K8S自定义Webhook实现认证管理

(2)配置kubeconfig，添加user

  1. # cat ~/.kube/config
  2. apiVersion: v1
  3. ......
  4. users:
  5. - name: joker
  6. user:
  7. token: github:ghp_jevHquU4g43m46nczWS0ojxxxxxxxxx

(3)用Joker用户进行访问

返回结果如下，至于报错是因为用户的权限不足。

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

可以在webhook上看到日志信息，如下：

  1. # ./kubernetes-auth-webhook
  2. I1207 15:37:29.531502 21959 webhook.go:55] auth by github success

从日志和结果可以看到，使用Github认证是OK的。

测试LDAP认证

LDAP简介

LDAP是协议，不是软件。

LDAP是轻量目录访问协议，英文全称是Lightweight Directory Access Protocol，一般都简称为LDAP。按照我们对文件目录的理解，ldap可以看成一个文件系统，类似目录和文件树。

OpenLDAP是常用的服务之一，也是我们本次测试的认证服务。

安装OpenLDAP

OpenLDAP的安装方式有很多，可以使用容器部署，也可以直接安装在裸机上，这里采用后者。

  1. # yum install -y openldap openldap-clients openldap-servers
  2. # systemctl start slapd
  3. # systemctl enable slapd

默认配置文件，位于/etc/openldap/slapd.d, 文件格式为LDAP Input Format (LDIF)， ldap目录特定的格式。这里不对配置文件做太多的介绍，有兴趣可以自己去学习学习【1】。

在LDAP上配置用户

(1)导入模板

  1. ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/cosine.ldif
  2. ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/nis.ldif
  3. ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/inetorgperson.ldif

(2)创建base组织

  1. # cat base.ldif
  2. dn: dc=demo,dc=com
  3. objectClass: top
  4. objectClass: dcObject
  5. objectClass: organization
  6. o: ldap测试组织
  7. dc: demo
  9. dn: cn=Manager,dc=demo,dc=com
  10. objectClass: organizationalRole
  11. cn: Manager
  12. description: 组织管理人
  14. dn: ou=People,dc=demo,dc=com
  15. objectClass: organizationalUnit
  16. ou: People
  18. dn: ou=Group,dc=demo,dc=com
  19. objectClass: organizationalUnit
  20. ou: Group

使用ldapadd添加base。

  1. ldapadd -x -D cn=admin,dc=demo,dc=com -w admin -f base.ldif

(3)添加成员

  1. # cat adduser.ldif
  2. dn: cn=jack,ou=People,dc=demo,dc=com
  3. changetype: add
  4. objectClass: inetOrgPerson
  5. cn: jack
  6. departmentNumber: 1
  7. title: 大牛
  8. userPassword: 123456
  9. sn: Bai
  10. mail: jack@demo.com
  11. displayName: 中文名

使用ldapadd执行添加。

  1. ldapadd -x -D cn=admin,dc=demo,dc=com -w admin -f adduser.ldif

(4)将用户添加到组

  1. # cat add_member_group.ldif
  2. dn: cn=g-admin,ou=Group,dc=demo,dc=com
  3. changetype: modify
  4. add: member
  5. member: cn=jack,ou=People,dc=demo,dc=com

使用ldapadd执行添加。

  1. ldapadd -x -D cn=admin,dc=demo,dc=com -w admin -f add_member_group.ldif

配置kubeconfig，进行ldap认证测试

(1)修改~/.kube/config配置文件

  1. # cat ~/.kube/config
  2. apiVersion: v1
  3. ......
  4. users:
  5. - name: joker
  6. user:
  7. token: github:ghp_jevHquU4g43m46nczWS0oxxxxxxxx
  8. - name: jack
  9. user:
  10. token: ldap:jack:123456

(2)使用kubectl进行测试

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

webhook服务日志如下：

  1. # ./kubernetes-auth-webhook
  2. I1207 16:09:09.292067 7605 webhook.go:72] auth by ldap success

通过测试结果可以看到使用LDAP认证测试成功。

总结

使用Webhook可以很灵活的将K8S的租户和企业内部账户系统进行打通，这样可以方便管理用户账户。

不过上面开发的Webhook只是一个简单的例子，验证方式和手法都比较粗暴，CoreOS开源的Dex【2】是比较不错的产品，可以直接使用。

本文转载自微信公众号「运维开发故事」

K8S自定义Webhook实现认证管理

原文链接：https://mp.weixin.qq.com/s/JCIO08FbKAePZ2FBvlvZDw

  • Kubernetes
  • k8s
  • Webhook

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    443 　 2008 　 2375 　 硬件冗余技术 　 网站备份 　 AH00023 　 KB967723 　 服务器技术 　 FTP 　 计划任务 　 云服务器 　 ARM服务器 　 无法运行 　 硬盘 　 视频服务器 　 访问速度 　 香港服务器租用 　 专线服务器 　 CN2 　 Linux之父 　 Vps 　 服务器集群技术 　 刀片服务器 　 机架服务器 　 服务器虚拟化 　 服务器租用 　 服务器托管 　 服务器租用价格 　 m6米乐官方网站 　 Server2003 　
    © 2019-2023 服务器之家(www.zzvips.com) 版权所有关于我们联系我们版权申明网站地图