如何从缓存加载OIDC配置认证GKE集群并调用K8s API

针对你的场景——OIDC认证配置存储在MongoDB并已加载到自定义ClientConfig结构体，但oidc-auth-plugin不支持直接读取缓存配置，以下是几种可行的解决思路：

方案1：动态生成临时kubeconfig文件，复用kubectl/oidc-auth-plugin逻辑 #

既然kubectl oidc login支持通过--login-config读取标准格式的配置文件，我们可以把缓存中的ClientConfig转换成标准的ClientConfig YAML结构，生成临时文件后调用认证命令，再用生成的凭证访问集群。

具体步骤： #

1. 映射自定义结构体到标准YAML格式
   把缓存中的ClientConfig字段对应到官方.kube/config的ClientConfig结构：

   // 假设已从MongoDB加载到clientConfig变量（自定义ClientConfig类型）
   standardConfig := map[string]interface{}{
       "kind":       "ClientConfig",
       "apiVersion": clientConfig.ApiVersion,
       "spec": map[string]interface{}{
           "name":                        clientConfig.ServerName,
           "server":                      clientConfig.ServerURL,
           "certificateAuthorityData":    clientConfig.CertificateAuthorityData,
           "authentication": []map[string]interface{}{
               {
                   "name": "oidc",
                   "oidc": map[string]interface{}{
                       "clientID":                 clientConfig.ClientID,
                       "clientSecret":             clientConfig.ClientSecret,
                       "issuerURI":                clientConfig.Endpoint.IssuerURL,
                       "kubectlRedirectURI":       clientConfig.RedirectURL,
                       "cloudConsoleRedirectURI":  clientConfig.CloudConsoleRedirectURI,
                       "scopes":                   strings.Join(clientConfig.Scopes, ","),
                       "userClaim":                clientConfig.UserClaim,
                       "userPrefix":               clientConfig.UserPrefix,
                       "groupsClaim":              clientConfig.GroupsClaim,
                   },
               },
           },
           "preferredAuthentication": clientConfig.PreferredAuthentication,
       },
   }
   

2. 生成临时配置文件
   创建临时文件并写入转换后的YAML内容：

   import (
       "gopkg.in/yaml.v2"
       "io/ioutil"
       "os"
       "strings"
   )
   
   tempFile, err := ioutil.TempFile("", "kube-login-config-*.yaml")
   if err != nil {
       // 处理错误
   }
   defer os.Remove(tempFile.Name()) // 认证完成后自动清理临时文件
   
   yamlData, err := yaml.Marshal(standardConfig)
   if err != nil {
       // 处理错误
   }
   _, err = tempFile.Write(yamlData)
   tempFile.Close()
   

3. 执行kubectl认证命令
   通过Go的os/exec调用认证命令，完成后即可正常访问集群：

   import "os/exec"
   
   cmd := exec.Command("kubectl", "oidc", "login", "--login-config", tempFile.Name(), "--cluster", clientConfig.ServerName)
   cmd.Stdout = os.Stdout
   cmd.Stderr = os.Stderr
   err = cmd.Run()
   if err != nil {
       // 处理认证错误
   }
   

方案2：直接在Go代码中集成OIDC认证逻辑，无需依赖oidc-auth-plugin #

利用Go生态的OIDC和OAuth2库，直接从缓存配置获取Token，构建K8s Client访问API。

具体步骤： #

1. 初始化OIDC提供者与OAuth2配置

   import (
       "context"
       "golang.org/x/oauth2"
       "github.com/coreos/go-oidc/v3/oidc"
       k8s "k8s.io/client-go/kubernetes"
       "k8s.io/client-go/rest"
       "k8s.io/apimachinery/pkg/apis/meta/v1"
   )
   
   ctx := context.Background()
   provider, err := oidc.NewProvider(ctx, clientConfig.Endpoint.IssuerURL)
   if err != nil {
       // 处理错误
   }
   
   oauth2Config := oauth2.Config{
       ClientID:     clientConfig.ClientID,
       ClientSecret: clientConfig.ClientSecret,
       RedirectURL:  clientConfig.RedirectURL,
       Endpoint:     provider.Endpoint(),
       Scopes:       append(clientConfig.Scopes, oidc.ScopeOpenID),
   }
   

2. 完成OIDC授权流程获取Token
   引导用户完成浏览器授权，用授权码交换Token并验证：

   // 生成授权URL，引导用户访问获取授权码code
   authURL := oauth2Config.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
   
   // 用授权码交换Token
   token, err := oauth2Config.Exchange(ctx, code)
   if err != nil {
       // 处理错误
   }
   
   // 验证ID Token合法性
   verifier := provider.Verifier(&oidc.Config{ClientID: clientConfig.ClientID})
   _, err = verifier.Verify(ctx, token.Extra("id_token").(string))
   if err != nil {
       // 处理错误
   }
   

3. 构建K8s REST Client
   将Token配置到K8s客户端，支持自动刷新Token：

   restConfig := &rest.Config{
       Host:        clientConfig.ServerURL,
       TLSClientConfig: rest.TLSClientConfig{
           CAData: []byte(clientConfig.CertificateAuthorityData),
       },
   }
   
   // 配置自动刷新Token的Transport
   restConfig.Wrap(func(rt http.RoundTripper) http.RoundTripper {
       return &oauth2.Transport{
           Source: oauth2Config.TokenSource(ctx, token),
           Base:   rt,
       }
   })
   
   clientSet, err := k8s.NewForConfig(restConfig)
   if err != nil {
       // 处理错误
   }
   
   // 调用K8s API示例：获取所有命名空间
   nsList, err := clientSet.CoreV1().Namespaces().List(ctx, v1.ListOptions{})
   

方案3：扩展oidc-auth-plugin支持缓存配置（进阶） #

如果必须依赖oidc-auth-plugin，可以修改其源码添加缓存读取逻辑：

1. 克隆oidc-auth-plugin源码仓库
2. 在配置加载模块中添加读取自定义ClientConfig缓存的逻辑（如从内存或MongoDB直接读取）
3. 重新编译插件并替换原二进制文件
4. 配置kubectl使用修改后的插件，指定缓存加载参数

内容的提问来源于stack exchange，提问作者overexchange