[[439204]]

大家好，我是喬克。

在Kubernetes中，APIServer是整個集群的中樞神經，它不僅連接了各個模塊，更是為整個集群提供了訪問控制能力。

Kubernetes API的每個請求都要經過多階段的訪問控制才會被接受，包括認證、授權、準入，如下所示。

客戶端(普通賬戶、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的認證請求，然后調用不同的認證服務進行認證，如下所示。

這里只是做一個Webhook的例子，目前主要實現了Github和LDAP認證，當然，認證部分的功能比較單一，沒有考慮復雜的場景。

Webhook開發

開發環境

構建符合規范的Webhook

在開發Webhook的時候，需要符合Kubernetes的規范，具體如下：

• URL：https://auth.example.com/auth
• Method：POST
• Input參數

{ 
  "apiVersion": "authentication.k8s.io/v1beta1", 
  "kind": "TokenReview", 
  "spec": { 
    "token": "<持有者令牌>" 
  } 
} 

• Output參數

如果成功會返回：

{ 
  "apiVersion": "authentication.k8s.io/v1beta1", 
  "kind": "TokenReview", 
  "status": { 
    "authenticated": true, 
    "user": { 
      "username": "janedoe@example.com", 
      "uid": "42", 
      "groups": [ 
        "developers", 
        "qa" 
      ], 
      "extra": { 
        "extrafield1": [ 
          "extravalue1", 
          "extravalue2" 
        ] 
      } 
    } 
  } 
} 

如果不成功，會返回：

{ 
  "apiVersion": "authentication.k8s.io/v1beta1", 
  "kind": "TokenReview", 
  "status": { 
    "authenticated": false 
  } 
} 

遠程服務應該會填充請求的 status 字段，以標明登錄操作是否成功。

開發認證服務

(1)創建項目并初始化go mod

# mkdir kubernetes-auth-webhook 
# cd kubernetes-auth-webhook 
# go mod init 

(2)在項目根目錄下創建webhook.go，寫入如下內容

package main 
 
import ( 
 "encoding/json" 
 "github.com/golang/glog" 
 authentication "k8s.io/api/authentication/v1beta1" 
 "k8s.io/klog/v2" 
 "net/http" 
 "strings" 
) 
 
type WebHookServer struct { 
 server *http.Server 
} 
 
func (ctx *WebHookServer) serve(w http.ResponseWriter, r *http.Request) { 
 // 從APIServer中取出body 
 // 將body進行拆分, 取出type 
 // 根據type, 取出不同的認證數據 
 var req authentication.TokenReview 
 decoder := json.NewDecoder(r.Body) 
 err := decoder.Decode(&req) 
 if err != nil { 
  klog.Error(err, "decoder request body error.") 
  req.Status = authentication.TokenReviewStatus{Authenticated: false} 
  w.WriteHeader(http.StatusUnauthorized) 
  _ = json.NewEncoder(w).Encode(req) 
  return 
 } 
 // 判斷token是否包含':' 
 // 如果不包含，則返回認證失敗 
 if !(strings.Contains(req.Spec.Token, ":")) { 
  klog.Error(err, "token invalied.") 
  req.Status = authentication.TokenReviewStatus{Authenticated: false} 
  //req.Status = map[string]interface{}{"authenticated": false} 
  w.WriteHeader(http.StatusUnauthorized) 
  _ = json.NewEncoder(w).Encode(req) 
  return 
 } 
 // split token, 獲取type 
 tokenSlice := strings.SplitN(req.Spec.Token, ":", -1) 
 glog.Infof("tokenSlice: ", tokenSlice) 
 hookType := tokenSlice[0] 
 switch hookType { 
 case "github": 
  githubToken := tokenSlice[1] 
  err := authByGithub(githubToken) 
  if err != nil { 
   klog.Error(err, "auth by github error") 
   req.Status = authentication.TokenReviewStatus{Authenticated: false} 
   w.WriteHeader(http.StatusUnauthorized) 
   _ = json.NewEncoder(w).Encode(req) 
   return 
  } 
  klog.Info("auth by github success") 
  req.Status = authentication.TokenReviewStatus{Authenticated: true} 
  w.WriteHeader(http.StatusOK) 
  _ = json.NewEncoder(w).Encode(req) 
  return 
 case "ldap": 
  username := tokenSlice[1] 
  password := tokenSlice[2] 
  err := authByLdap(username, password) 
  if err != nil { 
   klog.Error(err, "auth by ldap error") 
   req.Status = authentication.TokenReviewStatus{Authenticated: false} 
   //req.Status = map[string]interface{}{"authenticated": false} 
   w.WriteHeader(http.StatusUnauthorized) 
   _ = json.NewEncoder(w).Encode(req) 
   return 
  } 
  klog.Info("auth by ldap success") 
  req.Status = authentication.TokenReviewStatus{Authenticated: true} 
  //req.Status = map[string]interface{}{"authenticated": true} 
  w.WriteHeader(http.StatusOK) 
  _ = json.NewEncoder(w).Encode(req) 
  return 
 } 
} 

主要是解析認證的請求Token，然后將Token進行拆分判斷是需要什么認證，Token的樣例如下：

• Github認證：github:
• LDAP認證：ldap::

這樣就可以獲取到用戶想用哪種認證，再掉具體的認證服務進行處理。

(3)創建github.go，提供github認證方法

package main 
 
import ( 
 "context" 
 "github.com/golang/glog" 
 "github.com/google/go-github/github" 
 "golang.org/x/oauth2" 
) 
 
func authByGithub(token string) (err error) { 
 glog.V(2).Info("start auth by github......") 
 tokenSource := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token}) 
 tokenClient := oauth2.NewClient(context.Background(), tokenSource) 
 githubClient := github.NewClient(tokenClient) 
 _, _, err = githubClient.Users.Get(context.Background(), "") 
 if err != nil { 
  return err 
 } 
 return nil 
} 

可以看到，這里僅僅做了一個簡單的Token認證，認證的結果比較粗暴，如果err=nil，則表示認證成功。

(4)創建ldap.go，提供ldap認證

package main 
 
import ( 
 "crypto/tls" 
 "errors" 
 "fmt" 
 "github.com/go-ldap/ldap/v3" 
 "github.com/golang/glog" 
 "k8s.io/klog/v2" 
 "strings" 
) 
 
var ( 
 ldapUrl = "ldap://" + "192.168.100.179:389" 
) 
 
func authByLdap(username, password string) error { 
 groups, err := getLdapGroups(username, password) 
 if err != nil { 
  return err 
 } 
 if len(groups) > 0 { 
  return nil 
 } 
 
 return fmt.Errorf("No matching group or user attribute. Authentication rejected, Username: %s", username) 
} 
 
// 獲取user的groups 
func getLdapGroups(username, password string) ([]string, error) { 
 glog.Info("username:password", username, ":", password) 
 var groups []string 
 
 config := &tls.Config{InsecureSkipVerify: true} 
 ldapConn, err := ldap.DialURL(ldapUrl, ldap.DialWithTLSConfig(config)) 
 if err != nil { 
  glog.V(4).Info("dial ldap failed, err: ", err) 
  return groups, err 
 } 
 defer ldapConn.Close() 
 
 binduser := fmt.Sprintf("CN=%s,ou=People,dc=demo,dc=com", username) 
 
 err = ldapConn.Bind(binduser, password) 
 if err != nil { 
  klog.V(4).ErrorS(err, "bind user to ldap error") 
  return groups, err 
 } 
 
 // 查詢用戶成員 
 searchString := fmt.Sprintf("(&(objectClass=person)(cn=%s))", username) 
 memberSearchAttribute := "memberOf" 
 searchRequest := ldap.NewSearchRequest( 
  "dc=demo,dc=com", 
  ldap.ScopeWholeSubtree, 
  ldap.NeverDerefAliases, 
  0, 
  0, 
  false, 
  searchString, 
  []string{memberSearchAttribute}, 
  nil, 
 ) 
 searchResult, err := ldapConn.Search(searchRequest) 
 if err != nil { 
  klog.V(4).ErrorS(err, "search user properties error") 
  return groups, err 
 } 
 // 如果沒有查到結果，返回失敗 
 if len(searchResult.Entries[0].Attributes) < 1 { 
  return groups, errors.New("no user in ldap") 
 } 
 entry := searchResult.Entries[0] 
 for _, e := range entry.Attributes { 
  for _, attr := range e.Values { 
   groupList := strings.Split(attr, ",") 
   for _, g := range groupList { 
    if strings.HasPrefix(g, "cn=") { 
     group := strings.Split(g, "=") 
     groups = append(groups, group[1]) 
    } 
   } 
  } 
 } 
 return groups, nil 
} 

這里的用戶名是固定了的，所以不適合其他場景。

(5)創建main.go入口函數

package main 
 
import ( 
 "context" 
 "flag" 
 "fmt" 
 "github.com/golang/glog" 
 "net/http" 
 "os" 
 "os/signal" 
 "syscall" 
) 
 
var port string 
 
func main() { 
 flag.StringVar(&port, "port", "9999", "http server port") 
 flag.Parse() 
 // 啟動httpserver 
 wbsrv := WebHookServer{server: &http.Server{ 
  Addr: fmt.Sprintf(":%v", port), 
 }} 
 mux := http.NewServeMux() 
 mux.HandleFunc("/auth", wbsrv.serve) 
 wbsrv.server.Handler = mux 
 
 // 啟動協程來處理 
 go func() { 
  if err := wbsrv.server.ListenAndServe(); err != nil && err != http.ErrServerClosed { 
   glog.Errorf("Failed to listen and serve webhook server: %v", err) 
  } 
 }() 
 
 glog.Info("Server started") 
 
 // 優雅退出 
 signalChan := make(chan os.Signal, 1) 
 signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM) 
 <-signalChan 
 
 glog.Infof("Got OS shutdown signal, shutting down webhook server gracefully...") 
 _ = wbsrv.server.Shutdown(context.Background()) 
} 

到此整個認證服務就開發完畢了，是不是很簡單?

Webhook測試

APIServer添加認證服務

使用Webhook進行認證，需要在kube-apiserver里開啟，參數如下：

• --authentication-token-webhook-config-file 指向一個配置文件，其中描述 如何訪問遠程的 Webhook 服務
• --authentication-token-webhook-config-file 指向一個配置文件，其中描述 如何訪問遠程的 Webhook 服務

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

(1)、將配置文件放到相應的目錄

# mkdir /etc/kubernetes/webhook 
# cat >> webhook-config.json <EOF 
{ 
  "kind": "Config", 
  "apiVersion": "v1", 
  "preferences": {}, 
  "clusters": [ 
    { 
      "name": "github-authn", 
      "cluster": { 
        "server": "http://10.0.4.9:9999/auth" 
      } 
    } 
  ], 
  "users": [ 
    { 
      "name": "authn-apiserver", 
      "user": { 
        "token": "secret" 
      } 
    } 
  ], 
  "contexts": [ 
    { 
      "name": "webhook", 
      "context": { 
        "cluster": "github-authn", 
        "user": "authn-apiserver" 
      } 
    } 
  ], 
  "current-context": "webhook" 
} 
EOF 

 (2)在kube-apiserver中添加配置參數

# mkdir /etc/kubernetes/backup 
# cp /etc/kubernetes/manifests/kube-apiserver.yaml /etc/kubernetes/backup/kube-apiserver.yaml 
# cd /etc/kubernetes/manifests/ 
# cat kube-apiserver.yaml 
apiVersion: v1 
kind: Pod 
metadata: 
  annotations: 
    kubeadm.kubernetes.io/kube-apiserver.advertise-address.endpoint: 10.0.4.9:6443 
  creationTimestamp: null 
  labels: 
    component: kube-apiserver 
    tier: control-plane 
  name: kube-apiserver 
  namespace: kube-system 
spec: 
  containers: 
  - command: 
    - kube-apiserver 
    - ...... 
    - --authentication-token-webhook-config-file=/etc/config/webhook-config.json 
    image: registry.cn-hangzhou.aliyuncs.com/google_containers/kube-apiserver:v1.22.0 
    imagePullPolicy: IfNotPresent 
    ...... 
    volumeMounts: 
    ...... 
    - name: webhook-config 
      mountPath: /etc/config 
      readOnly: true 
  hostNetwork: true 
  priorityClassName: system-node-critical 
  securityContext: 
    seccompProfile: 
      type: RuntimeDefault 
  volumes: 
  ...... 
  - hostPath: 
      path: /etc/kubernetes/webhook 
      type: DirectoryOrCreate 
    name: webhook-config 
status: {} 

ps: 為了節約篇幅，上面省略了部分配置。

當修改完過后，kube-apiserver會自動重啟。

測試Github認證

(1)在github上獲取Token，操作如圖所示

(2)配置kubeconfig，添加user

# cat ~/.kube/config  
apiVersion: v1 
...... 
users: 
- name: joker 
  user: 
    token: github:ghp_jevHquU4g43m46nczWS0ojxxxxxxxxx 

(3)用Joker用戶進行訪問

返回結果如下，至于報錯是因為用戶的權限不足。

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

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

# ./kubernetes-auth-webhook  
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的安裝方式有很多，可以使用容器部署，也可以直接安裝在裸機上，這里采用后者。

# yum install -y openldap openldap-clients openldap-servers  
# systemctl start slapd 
# systemctl enable slapd 

默認配置文件，位于/etc/openldap/slapd.d, 文件格式為LDAP Input Format (LDIF)， ldap目錄特定的格式。這里不對配置文件做太多的介紹，有興趣可以自己去學習學習【1】。

在LDAP上配置用戶

(1)導入模板

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

(2)創建base組織

# cat base.ldif 
dn: dc=demo,dc=com 
objectClass: top 
objectClass: dcObject 
objectClass: organization 
o: ldap測試組織 
dc: demo 
 
dn: cn=Manager,dc=demo,dc=com 
objectClass: organizationalRole 
cn: Manager 
description: 組織管理人 
 
dn: ou=People,dc=demo,dc=com 
objectClass: organizationalUnit 
ou: People 
 
dn: ou=Group,dc=demo,dc=com 
objectClass: organizationalUnit 
ou: Group 

使用ldapadd添加base。

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

(3)添加成員

# cat adduser.ldif 
dn: cn=jack,ou=People,dc=demo,dc=com 
changetype: add 
objectClass: inetOrgPerson 
cn: jack 
departmentNumber: 1 
title: 大牛 
userPassword: 123456 
sn: Bai 
mail: jack@demo.com 
displayName: 中文名 

使用ldapadd執行添加。

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

(4)將用戶添加到組

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

使用ldapadd執行添加。

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

配置kubeconfig，進行ldap認證測試

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

# cat ~/.kube/config  
apiVersion: v1 
...... 
users: 
- name: joker 
  user: 
    token: github:ghp_jevHquU4g43m46nczWS0oxxxxxxxx 
- name: jack 
  user: 
    token: ldap:jack:123456 

(2)使用kubectl進行測試

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

webhook服務日志如下：

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

通過測試結果可以看到使用LDAP認證測試成功。

總結

使用Webhook可以很靈活的將K8S的租戶和企業內部賬戶系統進行打通，這樣可以方便管理用戶賬戶。

不過上面開發的Webhook只是一個簡單的例子，驗證方式和手法都比較粗暴，CoreOS開源的Dex【2】是比較不錯的產品，可以直接使用。

本文轉載自微信公眾號「運維開發故事」