K8s 多版本 API 转换最佳实践

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

~/x-kubernetes/api# tree hello.zeng.dev/ # here defines the external API
hello.zeng.dev/
├── v1
│   └── types.go                         # here defines the v1 kinds
└── v2
    └── types.go                         # here defines the v2 kinds
---
~/x-kubernetes/api-aggregation-lib# tree pkg/api/ # here defines the internal API and the conversion
pkg/api/
└── hello.zeng.dev
    ├── v1
    │   └── conversion.go                         # here defines v1 🔄 internal
    ├── v2
    │   └── zz_generated.conversion.go            # here defines v2 🔄 internal
    └── types.go                                  # here defines the internal version

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

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: foos.hello.zeng.dev
spec:
  group: hello.zeng.dev
  names:
    kind: Foo
    ...
  versions:
  - name: v1
    served: true
-   storage: true
+   storage: false
    ...
+ - name: v2
+   served: true
+   storage: true
+   additionalPrinterColumns: '{...}'
+   schema:
+     openAPIV3Schema: {}

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

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: foos.hello.zeng.dev
spec:
  group: hello.zeng.dev
  names:
    kind: Foo
    ...
  scope: Namespaced
  conversion:
    strategy: Webhook # or None
    webhook:  # webhook config when strategy is 'Webhook'
      clientConfig:
        caBundle: '...'
        service:
          name: foo-crd-converter
          namespace: default
          path: /convert/hello.zeng.dev
          port: 443
      conversionReviewVersions:
      - v1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

~/x-kubernetes/api/crdconversion# tree internal/api/ # here defines the internal API and the conversion
internal/api/
└── hello.zeng.dev
    ├── install
    │   └── install.go     # here defines helper funcs for Scheme installation
    ├── v1
    │   └── conversion.go  # here defines v1 🔄 internal
    ├── v2
    │   └── zz_generated.conversion.go  # here defines v2 🔄 internal
    └── types.go  # here defines the internal version

 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

import(
    apix "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/install"
    apixv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/runtime/schema"
    kjson "k8s.io/apimachinery/pkg/runtime/serializer/json"
    "k8s.io/apimachinery/pkg/runtime/serializer/versioning"

    helloinstall "github.com/phosae/x-kubernetes/api/crdconversion/internal/api/hello.zeng.dev/install"
)

var (
	scheme          = runtime.NewScheme()
	kjsonSerializer = kjson.NewSerializer(kjson.DefaultMetaFactory, scheme, scheme, false)
)

func init() {
	apix.Install(scheme)
	metav1.AddMetaToScheme(scheme)
	helloinstall.Install(scheme)
)

func ConvertHello(req *apixv1.ConversionRequest) (*apixv1.ConversionResponse, error) {
	resp := apixv1.ConversionResponse{}

	desiredGV, err := schema.ParseGroupVersion(req.DesiredAPIVersion)
	...

	groupVersioner := schema.GroupVersions([]schema.GroupVersion{desiredGV})
	codec := versioning.NewCodec(
		kjsonSerializer,                       // decoder
		kjsonSerializer,                       // encoder
		runtime.UnsafeObjectConvertor(scheme), // convertor
		scheme,                                // creator
		scheme,                                // typer
		nil,                                   // defaulter
		groupVersioner,                        // encodeVersion
		runtime.InternalGroupVersioner,        // decodeVersion
		scheme.Name(),                         // originalSchemeName
	)

	convertedObjects := make([]runtime.RawExtension, len(req.Objects))
	for i, raw := range req.Objects {
		decodedObject, _, err := codec.Decode(raw.Raw, nil, nil)
		if err != nil {
			return nil, fmt.Errorf("failed to decode into apiVersion: %v", err)
		}
		buf := bytes.Buffer{}
		if err := codec.Encode(decodedObject, &buf); err != nil {
			return nil, fmt.Errorf("failed to convert to desired apiVersion: %v", err)
		}
		convertedObjects[i] = runtime.RawExtension{Raw: buf.Bytes()}
	}
	resp.ConvertedObjects = convertedObjects
	return &resp, nil
}