慎重选用 Runtime 类框架开发 K8s apiserver

 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

package main

import (
	_ "k8s.io/client-go/plugin/pkg/client/auth" // register auth plugins
	"k8s.io/component-base/logs"
	"k8s.io/klog/v2"
	"sigs.k8s.io/apiserver-runtime/pkg/builder"
	"sigs.k8s.io/apiserver-runtime/sample/pkg/apis/sample/v1alpha1"
	"sigs.k8s.io/apiserver-runtime/sample/pkg/generated/openapi"
)

func main() {
	logs.InitLogs()
	defer logs.FlushLogs()

	err := builder.APIServer.
		WithOpenAPIDefinitions("sample", "v0.0.0", openapi.GetOpenAPIDefinitions).
		WithResource(&v1alpha1.Flunder{}). // namespaced resource
		WithResource(&v1alpha1.Fischer{}). // non-namespaced resource
		WithResource(&v1alpha1.Fortune{}). // resource with custom rest.Storage implementation
		WithLocalDebugExtension().
		Execute()
	if err != nil {
		klog.Fatal(err)
	}
}

 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

func main() {
    defer logs.FlushLogs()

    logOpts := logs.NewOptions()

    err := builder.APIServer.
        WithAdditionalSchemeInstallers(func(s *runtime.Scheme) error {
            return hellov1.AddDefaultingFuncs(s)
        }).
        WithOpenAPIDefinitions("hello.zeng.dev-server", "v0.1.0", openapi.GetOpenAPIDefinitions).
        // customize backed storage (can be replace with any implemention instead of etcd
        // normally use WithResourceAndStorage is ok
        // we choose WithResourceAndHandler only because WithResourceAndStorage don't support shortNames
        WithResourceAndHandler(&resource.Foo{}, func(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) (rest.Storage, error) {
            obj := &resource.Foo{}
            gvr := obj.GetGroupVersionResource()
            s := &restbuilder.DefaultStrategy{
                Object:         obj,
                ObjectTyper:    scheme,
                TableConvertor: rest.NewDefaultTableConvertor(gvr.GroupResource()),
            }
            store := &genericregistry.Store{
                NewFunc:                   obj.New,
                NewListFunc:               obj.NewList,
                PredicateFunc:             s.Match,
                DefaultQualifiedResource:  gvr.GroupResource(),
                CreateStrategy:            s,
                UpdateStrategy:            s,
                DeleteStrategy:            s,
                StorageVersioner:          gvr.GroupVersion(),
                SingularQualifiedResource: (resource.Foo{}).GetSingularQualifiedResource(),
                TableConvertor:            (resource.Foo{}),
            }

            options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: func(obj runtime.Object) (labels.Set, fields.Set, error) {
                accessor, ok := obj.(metav1.ObjectMetaAccessor)
                if !ok {
                    return nil, nil, fmt.Errorf("given object of type %T does implements metav1.ObjectMetaAccessor", obj)
                }
                om := accessor.GetObjectMeta()
                return om.GetLabels(), fields.Set{
                    "metadata.name":      om.GetName(),
                    "metadata.namespace": om.GetNamespace(),
                }, nil
            }}

            if err := store.CompleteWithOptions(options); err != nil {
                return nil, err
            }
            return &fooStorage{store}, nil
        }).
        WithOptionsFns(func(so *builder.ServerOptions) *builder.ServerOptions {
            // do log opts trick
            logs.InitLogs()
            logsapi.ValidateAndApply(logOpts, utilfeature.DefaultFeatureGate)
            return so
        }).
        WithFlagFns(func(ss *pflag.FlagSet) *pflag.FlagSet {
            logsapi.AddFlags(logOpts, ss)
            return ss
        }).
        Execute()
        ...
}