K8s 编程 - 2 - 编程基础

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

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

// 读取 config
kubeconfig = flag.String("kubeconfig", "~/.kube/config", "kubeconfig file") 
flag.Parse() 
config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig) 

// 创建 client set
clientset, err := kubernetes.NewForConfig(config) 

// 通过 client set 访问资源
pod, err := clientset.CoreV1().Pods("book").Get("example", metav1.GetOptions{})

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

// 读取 ServiceAccount 的目录创建 config
config, err := rest.InClusterConfig() 
if err != nil { 
    // 回滚使用 kubeconfig 文件创建 config
    kubeconfig := filepath.Join("~", ".kube", "config") 
    if envvar := os.Getenv("KUBECONFIG"); len(envvar) >0 { 
        kubeconfig = envvar 
    } 
    config, err = clientcmd.BuildConfigFromFlags("", kubeconfig) 
    if err != nil { 
        fmt.Printf("The kubeconfig cannot be loaded: %v\n", err 
        os.Exit(1) 
    } 
}

// 创建 client set
clientset, err := kubernetes.NewForConfig(config)

1
2
3
4

cfg, err := clientcmd.BuildConfigFromFlags("", *kubeconfig) 
cfg.AcceptContentTypes = "application/vnd.kubernetes.protobuf,application/json"   // 允许回复的格式
cfg.ContentType = "application/vnd.kubernetes.protobuf"  // 发送请求的格式
clientset, err := kubernetes.NewForConfig(cfg)

1
2
3
4
5
6
7
8

// Object interface must be supported by all API types registered with Scheme. Since objects in a scheme are
// expected to be serialized to the wire, the interface an Object must provide to the Scheme allows
// serializers to set the kind, version, and group the object is represented as. An Object may choose
// to return a no-op ObjectKindAccessor in cases where it is not expected to be serialized.
type Object interface {
	GetObjectKind() schema.ObjectKind
	DeepCopyObject() Object
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// All objects that are serialized from a Scheme encode their type information. This interface is used
// by serialization to set type information from the Scheme onto the serialized version of an object.
// For objects that cannot be serialized or have unique requirements, this interface may be a no-op.
type ObjectKind interface {
	// SetGroupVersionKind sets or clears the intended serialized kind of an object. Passing kind nil
	// should clear the current setting.
	SetGroupVersionKind(kind GroupVersionKind)
	// GroupVersionKind returns the stored group, version, and kind of an object, or an empty struct
	// if the object does not expose or provide these fields.
	GroupVersionKind() GroupVersionKind
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// TypeMeta describes an individual object in an API response or request
// with strings representing the type of the object and its API schema version.
// Structures that are versioned or persisted should inline TypeMeta.
//
// +k8s:deepcopy-gen=false
type TypeMeta struct {
	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated.
	// In CamelCase.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	// +optional
	Kind string `json:"kind,omitempty" protobuf:"bytes,1,opt,name=kind"`

	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	// +optional
	APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,2,opt,name=apiVersion"`
}

func (obj *TypeMeta) GetObjectKind() schema.ObjectKind { return obj }

1
2
3

apiVersion: v1
kind: Pod
# ...

 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

// ObjectMeta is metadata that all persisted resources must have, which includes all objects
// users must create.
type ObjectMeta struct {Clayton Coleman, 5 years ago: •  iQEcBAABCAAGBQJYfoneAAoJED0WkGtPHFyzBGEH/ROj…
	Name string `json:"name,omitempty" protobuf:"bytes,1,opt,name=name"`

	GenerateName string `json:"generateName,omitempty" protobuf:"bytes,2,opt,name=generateName"`

	Namespace string `json:"namespace,omitempty" protobuf:"bytes,3,opt,name=namespace"`

	// DEPRECATED
	SelfLink string `json:"selfLink,omitempty" protobuf:"bytes,4,opt,name=selfLink"`

	UID types.UID `json:"uid,omitempty" protobuf:"bytes,5,opt,name=uid,casttype=k8s.io/kubernetes/pkg/types.UID"`

	ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,6,opt,name=resourceVersion"`

	Generation int64 `json:"generation,omitempty" protobuf:"varint,7,opt,name=generation"`

	CreationTimestamp Time `json:"creationTimestamp,omitempty" protobuf:"bytes,8,opt,name=creationTimestamp"`

    DeletionTimestamp *Time `json:"deletionTimestamp,omitempty" protobuf:"bytes,9,opt,name=deletionTimestamp"`

	DeletionGracePeriodSeconds *int64 `json:"deletionGracePeriodSeconds,omitempty" protobuf:"varint,10,opt,name=deletionGracePeriodSeconds"`

	Labels map[string]string `json:"labels,omitempty" protobuf:"bytes,11,rep,name=labels"`

	Annotations map[string]string `json:"annotations,omitempty" protobuf:"bytes,12,rep,name=annotations"`

	OwnerReferences []OwnerReference `json:"ownerReferences,omitempty" patchStrategy:"merge" patchMergeKey:"uid" protobuf:"bytes,13,rep,name=ownerReferences"`

	Finalizers []string `json:"finalizers,omitempty" patchStrategy:"merge" protobuf:"bytes,14,rep,name=finalizers"`

	ClusterName string `json:"clusterName,omitempty" protobuf:"bytes,15,opt,name=clusterName"`

	ManagedFields []ManagedFieldsEntry `json:"managedFields,omitempty" protobuf:"bytes,17,rep,name=managedFields"`
}

 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

type Interface interface {
	Discovery() discovery.DiscoveryInterface
	AdmissionregistrationV1() admissionregistrationv1.AdmissionregistrationV1Interface
	AdmissionregistrationV1beta1() admissionregistrationv1beta1.AdmissionregistrationV1beta1Interface
	InternalV1alpha1() internalv1alpha1.InternalV1alpha1Interface
	AppsV1() appsv1.AppsV1Interface
	AppsV1beta1() appsv1beta1.AppsV1beta1Interface
	AppsV1beta2() appsv1beta2.AppsV1beta2Interface
	AuthenticationV1() authenticationv1.AuthenticationV1Interface
	AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface
	AuthorizationV1() authorizationv1.AuthorizationV1Interface
	AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface
	AutoscalingV1() autoscalingv1.AutoscalingV1Interface
	AutoscalingV2beta1() autoscalingv2beta1.AutoscalingV2beta1Interface
	AutoscalingV2beta2() autoscalingv2beta2.AutoscalingV2beta2Interface
	BatchV1() batchv1.BatchV1Interface
	BatchV1beta1() batchv1beta1.BatchV1beta1Interface
	CertificatesV1() certificatesv1.CertificatesV1Interface
	CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface
	CoordinationV1beta1() coordinationv1beta1.CoordinationV1beta1Interface
	CoordinationV1() coordinationv1.CoordinationV1Interface
	CoreV1() corev1.CoreV1Interface
	DiscoveryV1() discoveryv1.DiscoveryV1Interface
	DiscoveryV1beta1() discoveryv1beta1.DiscoveryV1beta1Interface
	EventsV1() eventsv1.EventsV1Interface
	EventsV1beta1() eventsv1beta1.EventsV1beta1Interface
	ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface
	FlowcontrolV1alpha1() flowcontrolv1alpha1.FlowcontrolV1alpha1Interface
	FlowcontrolV1beta1() flowcontrolv1beta1.FlowcontrolV1beta1Interface
	NetworkingV1() networkingv1.NetworkingV1Interface
	NetworkingV1beta1() networkingv1beta1.NetworkingV1beta1Interface
	NodeV1() nodev1.NodeV1Interface
	NodeV1alpha1() nodev1alpha1.NodeV1alpha1Interface
	NodeV1beta1() nodev1beta1.NodeV1beta1Interface
	PolicyV1() policyv1.PolicyV1Interface
	PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface
	RbacV1() rbacv1.RbacV1Interface
	RbacV1beta1() rbacv1beta1.RbacV1beta1Interface
	RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface
	SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1Interface
	SchedulingV1beta1() schedulingv1beta1.SchedulingV1beta1Interface
	SchedulingV1() schedulingv1.SchedulingV1Interface
	StorageV1beta1() storagev1beta1.StorageV1beta1Interface
	StorageV1() storagev1.StorageV1Interface
	StorageV1alpha1() storagev1alpha1.StorageV1alpha1Interface
}

1
2
3
4
5
6

type AppsV1beta1Interface interface {
	RESTClient() rest.Interface
	ControllerRevisionsGetter
	DeploymentsGetter
	StatefulSetsGetter
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// Interface captures the set of operations for generically interacting with Kubernetes REST apis.
type Interface interface {
	GetRateLimiter() flowcontrol.RateLimiter
	Verb(verb string) *Request
	Post() *Request
	Put() *Request
	Patch(pt types.PatchType) *Request
	Get() *Request
	Delete() *Request
	APIVersion() schema.GroupVersion
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// DeploymentsGetter has a method to return a DeploymentInterface.
// A group's client should implement this interface.
type DeploymentsGetter interface {
	Deployments(namespace string) DeploymentInterface
}

// DeploymentInterface has methods to work with Deployment resources.
type DeploymentInterface interface {
	Create(ctx context.Context, deployment *v1beta1.Deployment, opts v1.CreateOptions) (*v1beta1.Deployment, error)
	Update(ctx context.Context, deployment *v1beta1.Deployment, opts v1.UpdateOptions) (*v1beta1.Deployment, error)
	UpdateStatus(ctx context.Context, deployment *v1beta1.Deployment, opts v1.UpdateOptions) (*v1beta1.Deployment, error)
	Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
	DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
	Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.Deployment, error)
	List(ctx context.Context, opts v1.ListOptions) (*v1beta1.DeploymentList, error)
	Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta1.Deployment, err error)
	Apply(ctx context.Context, deployment *appsv1beta1.DeploymentApplyConfiguration, opts v1.ApplyOptions) (result *v1beta1.Deployment, err error)
	ApplyStatus(ctx context.Context, deployment *appsv1beta1.DeploymentApplyConfiguration, opts v1.ApplyOptions) (result *v1beta1.Deployment, err error)
	DeploymentExpansion
}

1
2
3
4
5
6
7

cfg, err := clientcmd.BuildConfigFromFlags("", *kubeconfig) 
cfg.AcceptContentTypes = "application/vnd.kubernetes.protobuf,application/json" 
cfg.UserAgent = fmt.Sprintf( 
    "book-example/v1.0 (%s/%s) kubernetes/v1.0", 
    runtime.GOOS, runtime.GOARCH 
) 
clientset, err := kubernetes.NewForConfig(cfg)

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

// Config holds the common attributes that can be passed to a Kubernetes
// client on initialization.
type Config struct { 
	// QPS indicates the maximum QPS to the master from this client.
    // If it's zero, the created RESTClient will use DefaultQPS: 5
    QPS float32 
	// Maximum burst for throttle.
	// If it's zero, the created RESTClient will use DefaultBurst: 10.
    Burst int 
	// The maximum length of time to wait before giving up on a server request.
	// A value of zero means no timeout.
    Timeout time.Duration 
    ... 
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import ( 
    // ... 
    "k8s.io/client-go/informers" 
) 
clientset, err := kubernetes.NewForConfig(config) 
// 创建 SharedInformerFactory：
informerFactory := informers.NewSharedInformerFactory(clientset, time.Second*30)
// 注册事件回调
podInformer := informerFactory.Core().V1().Pods() 
podInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{ 
    AddFunc: func(new interface{}) {...}, 
    UpdateFunc: func(old, new interface{}) {...}, 
    DeleteFunc: func(obj interface{}) {...}, 
})
// 启动
informerFactory.Start(wait.NeverStop)
// Cache 同步
informerFactory.WaitForCacheSync(wait.NeverStop) 
// 使用（纯内存的查询）
pod, err := podInformer.Lister().Pods("programming-kubernetes").Get("client-go")

1
2
3
4
5
6
7
8

type Interface interface {
	Add(item interface{})
	Len() int
	Get() (item interface{}, shutdown bool)
	Done(item interface{})
	ShutDown()
	ShuttingDown() bool
}

1
2
3
4
5
6
7

// DelayingInterface is an Interface that can Add an item at a later time. This makes it easier to
// requeue items after failures without ending up in a hot-loop.
type DelayingInterface interface {
	Interface
	// AddAfter adds an item to the workqueue after the indicated duration has passed
	AddAfter(item interface{}, duration time.Duration)
}

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

// RateLimitingInterface is an interface that rate limits items being added to the queue.
type RateLimitingInterface interface {
	DelayingInterface

	// AddRateLimited adds an item to the workqueue after the rate limiter says it's ok
	AddRateLimited(item interface{})

	// Forget indicates that an item is finished being retried.  Doesn't matter whether it's for perm failing
	// or for success, we'll stop the rate limiter from tracking it.  This only clears the `rateLimiter`, you
	// still have to call `Done` on the queue.
	Forget(item interface{})

	// NumRequeues returns back how many times the item was requeued
	NumRequeues(item interface{}) int
}

1

func DefaultControllerRateLimiter() *RateLimiter

1
2
3
4
5
6
7

// GroupVersionKind unambiguously identifies a kind.  It doesn't anonymously include GroupVersion
// to avoid automatic coercion.  It doesn't use a GroupVersion to avoid custom marshalling
type GroupVersionKind struct {
	Group   string
	Version string
	Kind    string
}

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

// GroupVersionResource unambiguously identifies a resource.  It doesn't anonymously include GroupVersion
// to avoid automatic coercion.  It doesn't use a GroupVersion to avoid custom marshalling
type GroupVersionResource struct {
	Group    string
	Version  string
	Resource string
}

// GroupKind specifies a Group and a Kind, but does not force a version.  This is useful for identifying
// concepts during lookup stages without having partially valid types
type GroupKind struct {
	Group string
	Kind  string
}

 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

// RESTMapper allows clients to map resources to kind, and map kind and version
// to interfaces for manipulating those objects. It is primarily intended for
// consumers of Kubernetes compatible REST APIs as defined in docs/devel/api-conventions.md.
//
// The Kubernetes API provides versioned resources and object kinds which are scoped
// to API groups. In other words, kinds and resources should not be assumed to be
// unique across groups.
//
// TODO: split into sub-interfaces
type RESTMapper interface {
	// KindFor takes a partial resource and returns the single match.  Returns an error if there are multiple matches
	KindFor(resource schema.GroupVersionResource) (schema.GroupVersionKind, error)

	// KindsFor takes a partial resource and returns the list of potential kinds in priority order
	KindsFor(resource schema.GroupVersionResource) ([]schema.GroupVersionKind, error)

	// ResourceFor takes a partial resource and returns the single match.  Returns an error if there are multiple matches
	ResourceFor(input schema.GroupVersionResource) (schema.GroupVersionResource, error)

	// ResourcesFor takes a partial resource and returns the list of potential resource in priority order
	ResourcesFor(input schema.GroupVersionResource) ([]schema.GroupVersionResource, error)

	// RESTMapping identifies a preferred resource mapping for the provided group kind.
	RESTMapping(gk schema.GroupKind, versions ...string) (*RESTMapping, error)
	// RESTMappings returns all resource mappings for the provided group kind if no
	// version search is provided. Otherwise identifies a preferred resource mapping for
	// the provided version(s).
	RESTMappings(gk schema.GroupKind, versions ...string) ([]*RESTMapping, error)

	ResourceSingularizer(resource string) (singular string, err error)
}

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

// RESTMapping contains the information needed to deal with objects of a specific
// resource and kind in a RESTful manner.
type RESTMapping struct {
	// Resource is the GroupVersionResource (location) for this endpoint
	Resource schema.GroupVersionResource

	// GroupVersionKind is the GroupVersionKind (data format) to submit to this endpoint
	GroupVersionKind schema.GroupVersionKind

	// Scope contains the information needed to deal with REST Resources that are in a resource hierarchy
	Scope RESTScope
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: groupName, Version: "v1alpha1"}

func init() {
	// We only register manually written functions here. The registration of the
	// generated functions takes place in the generated files. The separation
	// makes the code compile even when the generated files are missing.
	localSchemeBuilder.Register(addKnownTypes)
}

func addKnownTypes(scheme *runtime.Scheme) error {
	Scheme = scheme // Scheme 是全局的 Scheme 对象
	scheme.AddKnownTypes(SchemeGroupVersion,
		&TidbCluster{},  // 自定义的类型
	)

	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
	return nil
}

1
2
3

robj, err := t.scheme.New(gvk) // 得到 GVK 对应的空的对象

cobj, ok := robj.(*TidbCluster) // 类型断言得到具体的对象

 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

// AddKnownTypeWithName 注册 GVK 与类型（obj 的类型）
func (s *Scheme) AddKnownTypeWithName(gvk schema.GroupVersionKind, obj Object)

// AddKnownTypes 注册 GV 与其下的多个类型，Kind 就是类型的名字
func (s *Scheme) AddKnownTypes(gv schema.GroupVersion, types ...Object)

// KnownTypes 从 GV 中取出包含的类型
func (s *Scheme) KnownTypes(gv schema.GroupVersion) map[string]reflect.Type

// New 根据 GVK 创建一个对应类型的对象
func (s *Scheme) New(kind schema.GroupVersionKind) (Object, error)

// ObjectKinds 返回对象对应的可能的 GVK，如果是 unversioned object 返回 true，如果类型未注册返回错误
func (s *Scheme) ObjectKinds(obj Object) ([]schema.GroupVersionKind, bool, error)

// PreferredVersionAllGroups 返回每个 Group 的优先级最高 Version
func (s *Scheme) PreferredVersionAllGroups() []schema.GroupVersion

// PrioritizedVersionsForGroup 按照优先级顺序返回所有的 GroupVersion
func (s *Scheme) PrioritizedVersionsForGroup(group string) []schema.GroupVersion

// PrioritizedVersionsForGroup 按照优先级返回一个 group 所有的 version
func (s *Scheme) PrioritizedVersionsForGroup(group string) []schema.GroupVersion

// Recognizes GVK 是否是注册过的
func (s *Scheme) Recognizes(gvk schema.GroupVersionKind) bool

// SetVersionPriority 设置一个 Group 下的 Version 的优先级
// NOTE: versions 必须是同一个 Group 下的不同 Version
func (s *Scheme) SetVersionPriority(versions ...schema.GroupVersion) error

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

// AddConversionFunc 注册一个转换路径，对应 a 类型到 b 类型的转换，使用 fn 进行转换
func (s *Scheme) AddConversionFunc(a, b interface{}, fn conversion.ConversionFunc) error

func (s *Scheme) AddFieldLabelConversionFunc(gvk schema.GroupVersionKind, conversionFunc FieldLabelConversionFunc) error

func (s *Scheme) AddGeneratedConversionFunc(a, b interface{}, fn conversion.ConversionFunc) error

func (s *Scheme) AddIgnoredConversionType(from, to interface{}) error

// Convert 将 in 类型对象转换为 out 类型对象
func (s *Scheme) Convert(in, out interface{}, context interface{}) error

func (s *Scheme) ConvertFieldLabel(gvk schema.GroupVersionKind, label, value string) (string, string, error)

// ConvertToVersion 将 in 类型对象转化为 taget 指定的版本对象
func (s *Scheme) ConvertToVersion(in Object, target GroupVersioner) (Object, error)

1
2
3
4
5

// AddTypeDefaultingFunc 注册一个对象的默认值处理函数
func (s *Scheme) AddTypeDefaultingFunc(srcType Object, fn func(interface{}))

// Default 设置一个对象的默认值，就是使用注册的默认值处理函数
func (s *Scheme) Default(src Object)