kube-apiserver：Kubernetes API网关源码分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// APIServerConfig API服务器配置结构体
type APIServerConfig struct {
    // GenericConfig 通用服务器配置
    GenericConfig *genericapiserver.Config
    
    // ExtraConfig API服务器特定配置
    ExtraConfig ExtraConfig
}

// ExtraConfig API服务器扩展配置
type ExtraConfig struct {
    // APIResourceConfigSource API资源配置源
    // 定义哪些API组和版本被启用
    APIResourceConfigSource serverstorage.APIResourceConfigSource
    
    // StorageFactory 存储工厂
    // 负责创建各种资源的存储接口
    StorageFactory serverstorage.StorageFactory
    
    // EventTTL 事件生存时间
    // 控制Kubernetes事件在etcd中的保留时间
    EventTTL time.Duration
    
    // KubeletClientConfig kubelet客户端配置
    // API服务器与kubelet通信的配置
    KubeletClientConfig kubeletclient.KubeletClientConfig
    
    // EnableLogsSupport 是否启用日志支持
    // 控制是否支持通过API获取Pod日志
    EnableLogsSupport bool
    
    // ProxyTransport 代理传输配置
    // 用于代理请求到其他组件
    ProxyTransport http.RoundTripper
    
    // Tunneler SSH隧道管理器
    // 用于建立到节点的SSH隧道连接
    Tunneler tunneler.Tunneler
    
    // ServiceIPRange 服务IP范围
    // 定义Service ClusterIP的分配范围
    ServiceIPRange net.IPNet
    
    // SecondaryServiceIPRange 辅助服务IP范围
    // 用于双栈网络的IPv6服务IP分配
    SecondaryServiceIPRange net.IPNet
    
    // ServiceNodePortRange 服务NodePort范围
    // 定义NodePort类型服务的端口分配范围
    ServiceNodePortRange utilnet.PortRange
    
    // EndpointReconcilerType 端点协调器类型
    // 定义如何协调Service的Endpoints
    EndpointReconcilerType reconcilers.Type
    
    // MasterCount 主节点数量
    // 用于某些控制器的决策逻辑
    MasterCount int
    
    // ServiceAccountIssuer 服务账户令牌颁发者
    // JWT令牌的iss声明
    ServiceAccountIssuer serviceaccount.TokenGenerator
    
    // ServiceAccountMaxExpiration 服务账户令牌最大过期时间
    ServiceAccountMaxExpiration time.Duration
    
    // ExtendExpiration 是否自动延长令牌过期时间
    ExtendExpiration bool
    
    // ServiceAccountKeyFiles 服务账户密钥文件列表
    // 用于验证JWT令牌签名的公钥文件
    ServiceAccountKeyFiles []string
    
    // ServiceAccountLookup 是否启用服务账户查找
    // 控制是否验证令牌中的服务账户是否存在
    ServiceAccountLookup bool
    
    // ServiceAccountIssuerURL 服务账户颁发者URL
    // OIDC发现文档的URL
    ServiceAccountIssuerURL string
    
    // ServiceAccountJWKSURI JWKS端点URI
    // 用于获取令牌验证公钥的端点
    ServiceAccountJWKSURI string
    
    // ServiceAccountPublicKeys 服务账户公钥列表
    // 用于验证JWT令牌的公钥集合
    ServiceAccountPublicKeys []interface{}
    
    // VersionedInformers 版本化Informer工厂
    // 用于监听和缓存Kubernetes资源
    VersionedInformers clientgoinformers.SharedInformerFactory
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// Config 通用API服务器配置
type Config struct {
    // SecureServing HTTPS服务配置
    SecureServing *SecureServingInfo
    
    // Authentication 认证配置
    Authentication AuthenticationInfo
    
    // Authorization 授权配置
    Authorization AuthorizationInfo
    
    // LoopbackClientConfig 回环客户端配置
    // API服务器访问自身的客户端配置
    LoopbackClientConfig *restclient.Config
    
    // EgressSelector 出站连接选择器
    // 控制API服务器的出站网络连接
    EgressSelector *egressselector.EgressSelector
    
    // RuleResolver 规则解析器
    // 用于解析授权规则
    RuleResolver authorizer.RuleResolver
    
    // AdmissionControl 准入控制器
    // 请求的变更和验证逻辑
    AdmissionControl admission.Interface
    
    // CorsAllowedOriginList CORS允许的源列表
    // 跨源资源共享配置
    CorsAllowedOriginList []string
    
    // HSTSDirectives HTTP严格传输安全指令
    // 安全HTTP头配置
    HSTSDirectives []string
    
    // FlowControl 流量控制配置
    // API请求的优先级和公平性控制
    FlowControl utilflowcontrol.Interface
    
    // MaxRequestsInFlight 最大并发请求数
    // 限制同时处理的请求数量
    MaxRequestsInFlight int
    
    // MaxMutatingRequestsInFlight 最大并发变更请求数
    // 限制同时处理的变更请求数量
    MaxMutatingRequestsInFlight int
    
    // RequestTimeout 请求超时时间
    // HTTP请求的默认超时时间
    RequestTimeout time.Duration
    
    // GoawayChance HTTP/2 GOAWAY帧发送概率
    // 用于连接管理和负载均衡
    GoawayChance float64
    
    // LivezGracePeriod 存活检查宽限期
    // 服务器关闭时存活检查的宽限时间
    LivezGracePeriod time.Duration
    
    // ShutdownDelayDuration 关闭延迟时间
    // 服务器开始关闭前的延迟时间
    ShutdownDelayDuration time.Duration
    
    // JSONPatchMaxCopyBytes JSON Patch最大复制字节数
    // 限制JSON Patch操作的内存使用
    JSONPatchMaxCopyBytes int64
    
    // MaxRequestBodyBytes 最大请求体字节数
    // 限制HTTP请求体的大小
    MaxRequestBodyBytes int64
    
    // PublicAddress 公共访问地址
    // 服务器的外部可访问地址
    PublicAddress net.IP
    
    // EquivalentResourceRegistry 等效资源注册表
    // 用于资源转换和兼容性处理
    EquivalentResourceRegistry runtime.EquivalentResourceRegistry
    
    // StorageObjectCountTracker 存储对象计数跟踪器
    // 跟踪存储中各种资源的数量
    StorageObjectCountTracker flowcontrolrequest.StorageObjectCountTracker
    
    // APIServerID API服务器标识
    // 用于分布式系统中的服务器识别
    APIServerID string
    
    // StorageVersionManager 存储版本管理器
    // 管理资源的存储版本信息
    StorageVersionManager storageversion.Manager
    
    // Version 版本信息
    // API服务器的版本信息
    Version *version.Info
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// main kube-apiserver主函数入口
// 文件路径: cmd/kube-apiserver/apiserver.go
func main() {
    // 创建API服务器命令对象
    // 这个命令对象包含了所有的启动参数和配置选项
    command := app.NewAPIServerCommand()
    
    // 使用component-base的CLI运行器执行命令
    // 这提供了统一的命令行处理、信号处理和优雅关闭机制
    code := cli.Run(command)
    
    // 以返回的退出码结束程序
    // 0表示成功，非0表示错误
    os.Exit(code)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// NewAPIServerCommand 创建API服务器命令
// 文件路径: cmd/kube-apiserver/app/server.go
func NewAPIServerCommand() *cobra.Command {
    // 创建服务器运行选项
    // 包含所有命令行参数的默认值和验证规则
    s := options.NewServerRunOptions()
    
    // 设置信号上下文，用于优雅关闭
    ctx := genericapiserver.SetupSignalContext()
    
    // 获取特性门控组件注册表
    featureGate := s.GenericServerRunOptions.ComponentGlobalsRegistry.FeatureGateFor(basecompatibility.DefaultKubeComponent)

    cmd := &cobra.Command{
        Use: "kube-apiserver",
        Long: `The Kubernetes API server validates and configures data
for the api objects which include pods, services, replicationcontrollers, and
others. The API Server services REST operations and provides the frontend to the
cluster's shared state through which all other components interact.`,

        // 禁用在命令错误时打印使用说明
        SilenceUsage: true,
        
        // 预运行钩子：设置组件全局配置
        PersistentPreRunE: func(*cobra.Command, []string) error {
            // 设置组件全局注册表配置
            if err := s.GenericServerRunOptions.ComponentGlobalsRegistry.Set(); err != nil {
                return err
            }
            
            // 静默client-go警告
            // kube-apiserver的回环客户端不应记录自发出的警告
            rest.SetDefaultWarningHandler(rest.NoWarnings{})
            return nil
        },
        
        // 主运行函数
        RunE: func(cmd *cobra.Command, args []string) error {
            // 如果请求版本信息则打印并退出
            verflag.PrintAndExitIfRequested()
            
            // 获取命令行标志
            fs := cmd.Flags()
            
            // 尽早激活日志记录，然后显示最终日志配置的标志
            if err := logsapi.ValidateAndApply(s.Logs, featureGate); err != nil {
                return err
            }
            
            // 显示标志配置（用于调试）
            cliflag.PrintFlags(fs)

            // 设置默认选项值
            completedOptions, err := s.Complete()
            if err != nil {
                return err
            }

            // 验证配置选项
            if errs := completedOptions.Validate(); len(errs) != 0 {
                return utilerrors.NewAggregate(errs)
            }

            // 运行API服务器
            return Run(ctx, completedOptions)
        },
        
        // 参数验证函数
        Args: func(cmd *cobra.Command, args []string) error {
            for _, arg := range args {
                if len(arg) > 0 {
                    return fmt.Errorf("%q does not take any arguments, got %q", cmd.CommandPath(), args)
                }
            }
            return nil
        },
    }

    // 添加通用服务器标志
    fs := cmd.Flags()
    namedFlagSets := s.Flags()
    verflag.AddFlags(namedFlagSets.FlagSet("global"))
    globalflag.AddGlobalFlags(namedFlagSets.FlagSet("global"), cmd.Name(), logs.SkipLoggingConfigurationFlags())
    
    // 将命名标志集合添加到命令中
    for _, f := range namedFlagSets.FlagSets {
        fs.AddFlagSet(f)
    }

    // 添加使用帮助模板
    cols, _, _ := term.TerminalSize(cmd.OutOrStdout())
    cliflag.SetUsageAndHelpFunc(cmd, namedFlagSets, cols)

    return cmd
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

// Run 运行API服务器的主函数
// 文件路径: cmd/kube-apiserver/app/server.go
func Run(ctx context.Context, opts *options.CompletedOptions) error {
    // 创建API服务器配置
    config, err := CreateServerConfig(opts)
    if err != nil {
        return err
    }

    // 创建API服务器实例
    server, err := CreateAPIServer(config)
    if err != nil {
        return err
    }

    // 准备运行服务器
    prepared, err := server.PrepareRun()
    if err != nil {
        return err
    }

    // 运行服务器直到收到停止信号
    return prepared.Run(ctx)
}

// CreateServerConfig 创建服务器配置
func CreateServerConfig(opts *options.CompletedOptions) (*controlplane.CompletedConfig, error) {
    // 创建通用API服务器配置
    genericConfig, versionedInformers, storageFactory, err := controlplane.BuildGenericConfig(
        opts.CompletedOptions,
        []*runtime.Scheme{legacyscheme.Scheme, extensionsapiserver.Scheme, aggregatorscheme.Scheme},
        generatedopenapi.GetOpenAPIDefinitions,
    )
    if err != nil {
        return nil, err
    }

    // 设置OpenAPI配置
    if genericConfig.OpenAPIConfig != nil {
        genericConfig.OpenAPIConfig.Info.Title = "Kubernetes"
        genericConfig.OpenAPIConfig.DefaultResponse = &spec.Response{
            ResponseProps: spec.ResponseProps{
                Description: "Default Response.",
            },
        }
        genericConfig.OpenAPIConfig.Definitions = generatedopenapi.GetOpenAPIDefinitions(func(name string) spec.Ref {
            return spec.MustCreateRef("#/definitions/" + common.EscapeJsonPointer(name))
        })
    }

    // 创建控制平面配置
    config := &controlplane.Config{
        GenericConfig: genericConfig,
        ExtraConfig: controlplane.ExtraConfig{
            APIResourceConfigSource: storageFactory.APIResourceConfigSource,
            StorageFactory:         storageFactory,
            EventTTL:              opts.EventTTL,
            KubeletClientConfig:    opts.KubeletConfig,
            EnableLogsSupport:     opts.EnableLogsHandler,
            ProxyTransport:        opts.ProxyTransport,
        },
    }

    // 设置客户端CA配置
    if opts.ClientCAFile != "" {
        config.ExtraConfig.ClientCAProvider, err = dynamiccertificates.NewDynamicCAFromFile("client-ca-bundle", opts.ClientCAFile)
        if err != nil {
            return nil, err
        }
    }

    // 设置版本化Informers
    config.ExtraConfig.VersionedInformers = versionedInformers

    // 完成配置并返回
    return config.Complete(), nil
}

// CreateAPIServer 创建API服务器实例
func CreateAPIServer(config *controlplane.CompletedConfig) (*controlplane.Instance, error) {
    return config.New(controlplane.DefaultLegacyAPIPrefix)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// Request 认证请求结构体
// 文件路径: staging/src/k8s.io/apiserver/pkg/authentication/authenticator/interfaces.go
type Request interface {
    // AuthenticateRequest 认证HTTP请求
    // 参数:
    //   req - HTTP请求对象
    // 返回值:
    //   Response - 认证响应，包含用户信息
    //   bool - 认证是否成功
    //   error - 认证过程中的错误
    AuthenticateRequest(req *http.Request) (*Response, bool, error)
}

// Response 认证响应结构体
type Response struct {
    // User 认证成功的用户信息
    User user.Info
    
    // Audiences 令牌的受众列表
    // 用于验证JWT令牌的aud声明
    Audiences authenticator.Audiences
}

// Token 令牌认证器接口
type Token interface {
    // AuthenticateToken 认证令牌
    // 参数:
    //   ctx - 请求上下文
    //   token - 待认证的令牌字符串
    // 返回值:
    //   Response - 认证响应
    //   bool - 认证是否成功  
    //   error - 认证错误
    AuthenticateToken(ctx context.Context, token string) (*Response, bool, error)
}

// Password 密码认证器接口
type Password interface {
    // AuthenticatePassword 认证用户名密码
    // 参数:
    //   ctx - 请求上下文
    //   user - 用户名
    //   password - 密码
    // 返回值:
    //   Response - 认证响应
    //   bool - 认证是否成功
    //   error - 认证错误
    AuthenticatePassword(ctx context.Context, user, password string) (*Response, bool, error)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

// CAContentProvider CA内容提供者接口
// 文件路径: staging/src/k8s.io/apiserver/pkg/authentication/request/x509/x509.go
type CAContentProvider interface {
    // CurrentCABundleContent 获取当前CA证书包内容
    // 返回当前有效的CA证书PEM数据
    CurrentCABundleContent() []byte
}

// Verifier X.509证书验证器结构体
type Verifier struct {
    // roots 根证书池
    // 包含所有受信任的CA证书
    roots *x509.CertPool
    
    // getRoot 获取根证书的函数
    // 支持动态更新CA证书
    getRoot func() *x509.CertPool
    
    // maxChainLen 证书链最大长度
    // 防止过长的证书链导致性能问题
    maxChainLen int
}

// NewVerifier 创建X.509证书验证器
func NewVerifier(roots *x509.CertPool, caContentProvider CAContentProvider, maxChainLen int) *Verifier {
    var getRootCerts func() *x509.CertPool
    
    if caContentProvider != nil {
        // 如果提供了CA内容提供者，则支持动态CA更新
        getRootCerts = func() *x509.CertPool {
            // 获取当前CA证书内容
            caBundle := caContentProvider.CurrentCABundleContent()
            if len(caBundle) == 0 {
                return roots
            }
            
            // 创建新的证书池
            rootPool := x509.NewCertPool()
            if !rootPool.AppendCertsFromPEM(caBundle) {
                klog.Warning("Failed to parse CA bundle, using static roots")
                return roots
            }
            return rootPool
        }
    } else {
        // 使用静态根证书
        getRootCerts = func() *x509.CertPool {
            return roots
        }
    }
    
    return &Verifier{
        roots:       roots,
        getRoot:     getRootCerts,
        maxChainLen: maxChainLen,
    }
}

// AuthenticateRequest 认证X.509证书请求
func (v *Verifier) AuthenticateRequest(req *http.Request) (*authenticator.Response, bool, error) {
    // 检查是否为TLS连接
    if req.TLS == nil || len(req.TLS.PeerCertificates) == 0 {
        return nil, false, nil
    }
    
    // 获取客户端证书链
    chains := req.TLS.PeerCertificates
    if len(chains) > v.maxChainLen {
        return nil, false, fmt.Errorf("client certificate chain is too long: %d", len(chains))
    }
    
    // 验证证书链
    clientCert := chains[0]
    intermediates := x509.NewCertPool()
    for i := 1; i < len(chains); i++ {
        intermediates.AddCert(chains[i])
    }
    
    // 执行证书验证
    opts := x509.VerifyOptions{
        Roots:         v.getRoot(),
        Intermediates: intermediates,
        KeyUsages:     []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
    }
    
    if _, err := clientCert.Verify(opts); err != nil {
        return nil, false, err
    }
    
    // 从证书中提取用户信息
    user := &user.DefaultInfo{
        Name:   clientCert.Subject.CommonName,
        Groups: clientCert.Subject.Organization,
    }
    
    return &authenticator.Response{User: user}, true, nil
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

// TokenAuthenticator Bearer Token认证器
// 文件路径: staging/src/k8s.io/apiserver/pkg/authentication/request/bearertoken/bearertoken.go
type TokenAuthenticator struct {
    // auth 底层令牌认证器
    auth authenticator.Token
}

// New 创建Bearer Token认证器
func New(auth authenticator.Token) *TokenAuthenticator {
    return &TokenAuthenticator{auth}
}

// AuthenticateRequest 认证Bearer Token请求
func (a *TokenAuthenticator) AuthenticateRequest(req *http.Request) (*authenticator.Response, bool, error) {
    // 从Authorization头中提取Bearer Token
    auth := strings.TrimSpace(req.Header.Get("Authorization"))
    if auth == "" {
        return nil, false, nil
    }
    
    // 检查是否为Bearer Token格式
    parts := strings.SplitN(auth, " ", 3)
    if len(parts) < 2 || !strings.EqualFold(parts[0], "bearer") {
        return nil, false, nil
    }
    
    // 提取令牌字符串
    token := parts[1]
    if len(parts) == 3 {
        // 处理令牌中包含空格的情况
        token = fmt.Sprintf("%s %s", token, parts[2])
    }
    
    // 调用底层认证器进行令牌验证
    return a.auth.AuthenticateToken(req.Context(), token)
}

// ServiceAccountTokenAuthenticator ServiceAccount Token认证器
type ServiceAccountTokenAuthenticator struct {
    // keyResolver 密钥解析器
    // 用于获取验证JWT令牌的公钥
    keyResolver serviceaccount.TokenKeyResolver
    
    // validator 令牌验证器
    // 执行JWT令牌的签名验证和声明检查
    validator serviceaccount.TokenValidator
    
    // implicitAuds 隐式受众列表
    // 当令牌没有明确指定受众时使用的默认受众
    implicitAuds authenticator.Audiences
}

// NewServiceAccountTokenAuthenticator 创建ServiceAccount Token认证器
func NewServiceAccountTokenAuthenticator(
    keyResolver serviceaccount.TokenKeyResolver,
    validator serviceaccount.TokenValidator,
    implicitAuds authenticator.Audiences,
) *ServiceAccountTokenAuthenticator {
    return &ServiceAccountTokenAuthenticator{
        keyResolver:  keyResolver,
        validator:    validator,
        implicitAuds: implicitAuds,
    }
}

// AuthenticateToken 认证ServiceAccount Token
func (s *ServiceAccountTokenAuthenticator) AuthenticateToken(ctx context.Context, token string) (*authenticator.Response, bool, error) {
    // 解析JWT令牌
    claims, err := s.validator.Validate(ctx, token, s.keyResolver)
    if err != nil {
        return nil, false, err
    }
    
    // 验证令牌受众
    auds := s.implicitAuds
    if len(claims.Audience) > 0 {
        auds = authenticator.Audiences(claims.Audience)
    }
    
    // 构造用户信息
    // ServiceAccount的用户名格式: system:serviceaccount:{namespace}:{name}
    username := serviceaccount.MakeUsername(claims.Namespace, claims.ServiceAccountName)
    
    // ServiceAccount的用户组
    groups := serviceaccount.MakeGroupNames(claims.Namespace)
    
    user := &user.DefaultInfo{
        Name:   username,
        UID:    string(claims.ServiceAccountUID),
        Groups: groups,
        Extra:  make(map[string][]string),
    }
    
    // 添加额外的声明信息
    if claims.PodName != "" {
        user.Extra[serviceaccount.PodNameKey] = []string{claims.PodName}
    }
    if claims.PodUID != "" {
        user.Extra[serviceaccount.PodUIDKey] = []string{claims.PodUID}
    }
    
    return &authenticator.Response{
        User:      user,
        Audiences: auds,
    }, true, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// Authorizer 授权器接口
// 文件路径: staging/src/k8s.io/apiserver/pkg/authorization/authorizer/interfaces.go
type Authorizer interface {
    // Authorize 执行授权检查
    // 参数:
    //   ctx - 请求上下文
    //   a - 授权属性，包含用户、资源、动作等信息
    // 返回值:
    //   Decision - 授权决策(Allow/Deny/NoOpinion)
    //   string - 决策原因
    //   error - 授权过程中的错误
    Authorize(ctx context.Context, a Attributes) (Decision, string, error)
}

// Attributes 授权属性接口
type Attributes interface {
    // GetUser 获取用户信息
    GetUser() user.Info
    
    // GetVerb 获取操作动词(get, list, create, update, delete等)
    GetVerb() string
    
    // GetNamespace 获取命名空间
    GetNamespace() string
    
    // GetResource 获取资源类型
    GetResource() string
    
    // GetSubresource 获取子资源
    GetSubresource() string
    
    // GetName 获取资源名称
    GetName() string
    
    // GetAPIGroup 获取API组
    GetAPIGroup() string
    
    // GetAPIVersion 获取API版本
    GetAPIVersion() string
    
    // IsResourceRequest 是否为资源请求
    IsResourceRequest() bool
    
    // GetPath 获取请求路径(用于非资源请求)
    GetPath() string
}

// Decision 授权决策类型
type Decision int

const (
    // DecisionDeny 拒绝访问
    DecisionDeny Decision = iota
    
    // DecisionAllow 允许访问
    DecisionAllow
    
    // DecisionNoOpinion 无明确意见，需要其他授权器决策
    DecisionNoOpinion
)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

// RBACAuthorizer RBAC授权器结构体
// 文件路径: plugin/pkg/auth/authorizer/rbac/rbac.go
type RBACAuthorizer struct {
    // roleGetter 角色获取器
    // 用于获取Role和ClusterRole资源
    roleGetter RoleGetter
    
    // roleBindingLister 角色绑定列表器
    // 用于获取RoleBinding和ClusterRoleBinding资源
    roleBindingLister RoleBindingLister
    
    // clusterRoleGetter 集群角色获取器
    // 用于获取ClusterRole资源
    clusterRoleGetter ClusterRoleGetter
    
    // clusterRoleBindingLister 集群角色绑定列表器
    // 用于获取ClusterRoleBinding资源
    clusterRoleBindingLister ClusterRoleBindingLister
}

// NewRBACAuthorizer 创建RBAC授权器
func NewRBACAuthorizer(
    roleGetter RoleGetter,
    roleBindingLister RoleBindingLister, 
    clusterRoleGetter ClusterRoleGetter,
    clusterRoleBindingLister ClusterRoleBindingLister,
) *RBACAuthorizer {
    return &RBACAuthorizer{
        roleGetter:               roleGetter,
        roleBindingLister:        roleBindingLister,
        clusterRoleGetter:        clusterRoleGetter,
        clusterRoleBindingLister: clusterRoleBindingLister,
    }
}

// Authorize 执行RBAC授权检查
func (r *RBACAuthorizer) Authorize(ctx context.Context, requestAttributes authorizer.Attributes) (authorizer.Decision, string, error) {
    // 获取用户信息
    user := requestAttributes.GetUser()
    if user == nil {
        return authorizer.DecisionNoOpinion, "no user provided", nil
    }
    
    // 构建规则解析上下文
    ruleCheckingVisitor := &authorizingVisitor{
        requestAttributes: requestAttributes,
    }
    
    // 检查集群级别的角色绑定
    if err := r.visitRulesFor(ctx, user, "", ruleCheckingVisitor, ""); err != nil {
        return authorizer.DecisionNoOpinion, "", err
    }
    
    // 如果是资源请求，还需要检查命名空间级别的角色绑定
    if requestAttributes.IsResourceRequest() {
        namespace := requestAttributes.GetNamespace()
        if namespace != "" {
            if err := r.visitRulesFor(ctx, user, namespace, ruleCheckingVisitor, ""); err != nil {
                return authorizer.DecisionNoOpinion, "", err
            }
        }
    }
    
    // 根据访问结果返回决策
    if ruleCheckingVisitor.allowed {
        return authorizer.DecisionAllow, ruleCheckingVisitor.reason, nil
    }
    
    return authorizer.DecisionNoOpinion, "", nil
}

// visitRulesFor 访问用户在指定命名空间中的所有规则
func (r *RBACAuthorizer) visitRulesFor(ctx context.Context, user user.Info, namespace string, visitor RuleAccumulator, ownerChain string) error {
    // 检查用户是否匹配任何RoleBinding
    if len(namespace) > 0 {
        // 获取命名空间中的所有RoleBinding
        roleBindings, err := r.roleBindingLister.ListRoleBindings(namespace)
        if err != nil {
            return err
        }
        
        // 遍历RoleBinding，检查用户是否匹配
        for _, roleBinding := range roleBindings {
            subjectIndex, applies := appliesTo(user, roleBinding.Subjects, namespace)
            if !applies {
                continue
            }
            
            // 获取角色规则
            rules, err := r.GetRole(roleBinding, namespace)
            if err != nil {
                continue
            }
            
            // 访问规则
            if visitor.VisitRulesFor(user, namespace, roleBinding.Name, subjectIndex, rules) {
                return nil
            }
        }
    }
    
    // 检查用户是否匹配任何ClusterRoleBinding
    clusterRoleBindings, err := r.clusterRoleBindingLister.ListClusterRoleBindings()
    if err != nil {
        return err
    }
    
    // 遍历ClusterRoleBinding，检查用户是否匹配
    for _, clusterRoleBinding := range clusterRoleBindings {
        subjectIndex, applies := appliesTo(user, clusterRoleBinding.Subjects, namespace)
        if !applies {
            continue
        }
        
        // 获取集群角色规则
        rules, err := r.GetClusterRole(clusterRoleBinding)
        if err != nil {
            continue
        }
        
        // 访问规则
        if visitor.VisitRulesFor(user, namespace, clusterRoleBinding.Name, subjectIndex, rules) {
            return nil
        }
    }
    
    return nil
}

// authorizingVisitor 授权访问器，实现RuleAccumulator接口
type authorizingVisitor struct {
    // requestAttributes 请求属性
    requestAttributes authorizer.Attributes
    
    // allowed 是否被允许
    allowed bool
    
    // reason 允许的原因
    reason string
}

// VisitRulesFor 访问用户的规则
func (v *authorizingVisitor) VisitRulesFor(user user.Info, namespace, name string, subjectIndex int, rules []rbacv1.PolicyRule) bool {
    // 检查规则是否匹配当前请求
    for i := range rules {
        if RuleAllows(v.requestAttributes, &rules[i]) {
            v.allowed = true
            v.reason = fmt.Sprintf("RBAC: allowed by %s %q bound to %q", 
                getRoleBindingType(namespace), name, formatSubject(user, subjectIndex))
            return true
        }
    }
    return false
}

// RuleAllows 检查规则是否允许请求
func RuleAllows(requestAttributes authorizer.Attributes, rule *rbacv1.PolicyRule) bool {
    // 检查动词是否匹配
    if !VerbMatches(rule, requestAttributes.GetVerb()) {
        return false
    }
    
    if requestAttributes.IsResourceRequest() {
        // 资源请求：检查API组、资源、子资源、资源名称
        combinedResource := requestAttributes.GetResource()
        if len(requestAttributes.GetSubresource()) > 0 {
            combinedResource = requestAttributes.GetResource() + "/" + requestAttributes.GetSubresource()
        }
        
        if !APIGroupMatches(rule, requestAttributes.GetAPIGroup()) {
            return false
        }
        
        if !ResourceMatches(rule, combinedResource, requestAttributes.GetSubresource()) {
            return false
        }
        
        if !ResourceNameMatches(rule, requestAttributes.GetName()) {
            return false
        }
        
        return true
    }
    
    // 非资源请求：检查路径
    return NonResourceURLMatches(rule, requestAttributes.GetPath())
}