Client客户端对象

package main

import (
    "context"
    "fmt"

    metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
)

func main() {

    // 加载 kubeconfig 文件，生成 config 对象
    config, err := clientcmd.BuildConfigFromFlags("https://10.244.244.201:6443", "/root/.kube/config")
    if err != nil {
        panic(err)
    }

    // 通过 config 对象得到 ClientSet 客户端对象
    clientSet, err := kubernetes.NewForConfig(config)
    if err != nil {
        panic(err)
    }

    // 使用 ClientSet 客户端对象通过资源函数进行 Pod 资源的访问
    pod, err := clientSet.CoreV1().
        Pods("dev-container").
        Get(context.Background(), "dev-container-0", metaV1.GetOptions{})
    if err != nil {
        panic(err)
    }

    // 打印 pod 的状态信息
    fmt.Println(pod.Status.String())

}

// BuildConfigFromFlags is a helper function that builds configs from a master
// url or a kubeconfig filepath. These are passed in as command line flags for cluster
// components. Warnings should reflect this usage. If neither masterUrl or kubeconfigPath
// are passed in we fallback to inClusterConfig. If inClusterConfig fails, we fallback
// to the default config.
func BuildConfigFromFlags(masterUrl, kubeconfigPath string) (*restclient.Config, error) {
    if kubeconfigPath == "" && masterUrl == "" {
        klog.Warning("Neither --kubeconfig nor --master was specified.  Using the inClusterConfig.  This might not work.")
        kubeconfig, err := restclient.InClusterConfig()
        if err == nil {
            return kubeconfig, nil
        }
        klog.Warning("error creating inClusterConfig, falling back to default config: ", err)
    }
    return NewNonInteractiveDeferredLoadingClientConfig(
        &ClientConfigLoadingRules{ExplicitPath: kubeconfigPath},
        &ConfigOverrides{ClusterInfo: clientcmdapi.Cluster{Server: masterUrl}}).ClientConfig()
}

// ClientConfig implements ClientConfig
func (config *DirectClientConfig) ClientConfig() (*restclient.Config, error) {
    // check that getAuthInfo, getContext, and getCluster do not return an error.
    // Do this before checking if the current config is usable in the event that an
    // AuthInfo, Context, or Cluster config with user-defined names are not found.
    // This provides a user with the immediate cause for error if one is found
    configAuthInfo, err := config.getAuthInfo()
    if err != nil {
        return nil, err
    }

    _, err = config.getContext()
    if err != nil {
        return nil, err
    }

    configClusterInfo, err := config.getCluster()
    if err != nil {
        return nil, err
    }

    if err := config.ConfirmUsable(); err != nil {
        return nil, err
    }

    clientConfig := &restclient.Config{}
    clientConfig.Host = configClusterInfo.Server
    if configClusterInfo.ProxyURL != "" {
        u, err := parseProxyURL(configClusterInfo.ProxyURL)
        if err != nil {
            return nil, err
        }
        clientConfig.Proxy = http.ProxyURL(u)
    }

    clientConfig.DisableCompression = configClusterInfo.DisableCompression

    if config.overrides != nil && len(config.overrides.Timeout) > 0 {
        timeout, err := ParseTimeout(config.overrides.Timeout)
        if err != nil {
            return nil, err
        }
        clientConfig.Timeout = timeout
    }

    if u, err := url.ParseRequestURI(clientConfig.Host); err == nil && u.Opaque == "" && len(u.Path) > 1 {
        u.RawQuery = ""
        u.Fragment = ""
        clientConfig.Host = u.String()
    }
    if len(configAuthInfo.Impersonate) > 0 {
        clientConfig.Impersonate = restclient.ImpersonationConfig{
            UserName: configAuthInfo.Impersonate,
            UID:      configAuthInfo.ImpersonateUID,
            Groups:   configAuthInfo.ImpersonateGroups,
            Extra:    configAuthInfo.ImpersonateUserExtra,
        }
    }

    // only try to read the auth information if we are secure
    if restclient.IsConfigTransportTLS(*clientConfig) {
        var err error
        var persister restclient.AuthProviderConfigPersister
        if config.configAccess != nil {
            authInfoName, _ := config.getAuthInfoName()
            persister = PersisterForUser(config.configAccess, authInfoName)
        }
        userAuthPartialConfig, err := config.getUserIdentificationPartialConfig(configAuthInfo, config.fallbackReader, persister, configClusterInfo)
        if err != nil {
            return nil, err
        }
        mergo.Merge(clientConfig, userAuthPartialConfig, mergo.WithOverride)

        serverAuthPartialConfig, err := getServerIdentificationPartialConfig(configAuthInfo, configClusterInfo)
        if err != nil {
            return nil, err
        }
        mergo.Merge(clientConfig, serverAuthPartialConfig, mergo.WithOverride)
    }

    return clientConfig, nil
}

package main

import (
    "fmt"

    "k8s.io/apimachinery/pkg/runtime/schema"
    "k8s.io/client-go/discovery"
    "k8s.io/client-go/tools/clientcmd"
)

func main() {

    // 加载 kubeconfig 文件，生成 config 对象
    config, err := clientcmd.BuildConfigFromFlags("https://10.244.244.201:6443", "/root/.kube/config")
    if err != nil {
        panic(err)
    }

    // discovery.NewDiscoveryClientForConfig 函数
    // 通过 config 实例化 discoveryClient 对象
    discoveryClient, err := discovery.NewDiscoveryClientForConfig(config)
    if err != nil {
        panic(err)
    }

    // discoveryClient.ServerGroupsAndResources 函数
    // 返回 API Server 所支持的资源组、资源版本、资源信息
    _, APIResourceList, err := discoveryClient.ServerGroupsAndResources()
    if err != nil {
        panic(err)
    }

    // 输出所有资源信息
    for _, list := range APIResourceList {
        gv, err := schema.ParseGroupVersion(list.GroupVersion)
        if err != nil {
            panic(err)
        }

        for _, resource := range list.APIResources {
            fmt.Printf("NAME: %v, GROUP: %v, VERSION: %v \n", resource.Name, gv.Group, gv.Version)
        }
    }

}

// NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. This client
// can be used to discover supported resources in the API server.
// NewDiscoveryClientForConfig is equivalent to NewDiscoveryClientForConfigAndClient(c, httpClient),
// where httpClient was generated with rest.HTTPClientFor(c).
func NewDiscoveryClientForConfig(c *restclient.Config) (*DiscoveryClient, error) {
    config := *c
    if err := setDiscoveryDefaults(&config); err != nil {
        return nil, err
    }
    httpClient, err := restclient.HTTPClientFor(&config)
    if err != nil {
        return nil, err
    }
    return NewDiscoveryClientForConfigAndClient(&config, httpClient)
}

// NewDiscoveryClientForConfigAndClient creates a new DiscoveryClient for the given config. This client
// can be used to discover supported resources in the API server.
// Note the http client provided takes precedence over the configured transport values.
func NewDiscoveryClientForConfigAndClient(c *restclient.Config, httpClient *http.Client) (*DiscoveryClient, error) {
    config := *c
    if err := setDiscoveryDefaults(&config); err != nil {
        return nil, err
    }
    client, err := restclient.UnversionedRESTClientForConfigAndClient(&config, httpClient)
    return &DiscoveryClient{restClient: client, LegacyPrefix: "/api", UseLegacyDiscovery: false}, err
}