package v1alpha1
 
import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" 

type ProjectSpec struct {
  Replicas int `json:"replicas"`
}
 
type Project struct {
  metav1.TypeMeta   `json:",inline"`
  metav1.ObjectMeta `json:"metadata,omitempty"`
  Spec ProjectSpec `json:"spec"`
}
 
type ProjectList struct {
    metav1.TypeMeta `json:",inline"`
    metav1.ListMeta `json:"metadata,omitempty"`
    Items []Project `json:"items"`
}

package v1alpha1

import "k8s.io/apimachinery/pkg/runtime"

// DeepCopyInto 把一个对象的所有属性复制给此对象类型的指针
func (in *Project) DeepCopyInto(out *Project) {
	out.TypeMeta = in.TypeMeta
	out.ObjectMeta = in.ObjectMeta
	out.Spec = ProjectSpec{
		Replicas: in.Spec.Replicas,
	}
}

// DeepCopyObject 返回一个对象类型
func (in *Project) DeepCopyObject() runtime.Object {
	out := Project{}
	in.DeepCopyInto(&out)

	return &out
}

// DeepCopyObject 返回一个对像类型
func (in *ProjectList) DeepCopyObject() runtime.Object {
	out := ProjectList{}
	out.TypeMeta = in.TypeMeta
	out.ListMeta = in.ListMeta

	if in.Items != nil {
		out.Items = make([]Project, len(in.Items))
		for i := range in.Items {
			in.Items[i].DeepCopyInto(&out.Items[i])
		}
	}

	return &out
}

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
type Project struct {
    // ...
}

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
type ProjectList struct {
    // ...
}

package v1alpha1

import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

//go:generate controller-gen object paths=$GOFILE

// ...

package v1alpha1

import (
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

const GroupName = "example-gzh.com"
const GroupVersion = "v1alpha1"

var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: GroupVersion}

var (
	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
	AddToScheme   = SchemeBuilder.AddToScheme
)

func addKnownTypes(scheme *runtime.Scheme) error {
	scheme.AddKnownTypes(SchemeGroupVersion,
		&Project{},
		&ProjectList{},
	)

	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
	return nil
}

package main

import (
	"flag"
	"log"

	"ks.io/apimachinery/pkg/runtime/schema"
	"ks.io/apimachinery/pkg/runtime/serializer"

	"github.com/double12gzh/k8s-demo/api/types/valpha"
	"ks.io/client-go/kubernetes/scheme"
	"ks.io/client-go/rest"
	"ks.io/client-go/tools/clientcmd"
)

var kubeconfig string

func init() {
	flag.StringVar(&kubeconfig, "kubeconfig", "", "path to Kubernetes config file")
	flag.Parse()
}

func main() {
	var config *rest.Config
	var err error

	if kubeconfig == "" {
		log.Printf("using in-cluster configuration")
		config, err = rest.InClusterConfig()
	} else {
		log.Printf("using configuration from '%s'", kubeconfig)
		config, err = clientcmd.BuildConfigFromFlags("", kubeconfig)
	}

	if err != nil {
		panic(err)
	}

	valpha.AddToScheme(scheme.Scheme)

	crdConfig := *config
	crdConfig.ContentConfig.GroupVersion = &schema.GroupVersion{Group: valpha.GroupName, Version: valpha.GroupVersion}
	crdConfig.APIPath = "/apis"
	crdConfig.NegotiatedSerializer = serializer.NewCodecFactory(scheme.Scheme)
	crdConfig.UserAgent = rest.DefaultKubernetesUserAgent()

	exampleRestClient, err := rest.UnversionedRESTClientFor(&crdConfig)
	if err != nil {
		panic(err)
	}
}

result := v1alpha1.ProjectList{}
err := exampleRestClient.Get().Resource("projects").Do().Into(&result)

package valpha

import (
	"github.com/double12gzh/k8s-demo/api/types/valpha"
	"ks.io/apimachinery/pkg/runtime/schema"
	"ks.io/client-go/kubernetes/scheme"
	"ks.io/client-go/rest"
)

type ExampleVAlphaInterface interface {
	Projects(namespace string) ProjectInterface
}

type ExampleVAlphaClient struct {
	restClient rest.Interface
}

func NewForConfig(c *rest.Config) (*ExampleVAlphaClient, error) {
	config := *c
	config.ContentConfig.GroupVersion = &schema.GroupVersion{Group: valpha.GroupName, Version: valpha.GroupVersion}
	config.APIPath = "/apis"
	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
	config.UserAgent = rest.DefaultKubernetesUserAgent()

	client, err := rest.RESTClientFor(&config)
	if err != nil {
		return nil, err
	}

	return &ExampleVAlphaClient{restClient: client}, nil
}

func (c *ExampleVAlphaClient) Projects(namespace string) ProjectInterface {
	return &projectClient{
		restClient: c.restClient,
		ns:         namespace,
	}
}

package valpha

import (
	"github.com/double12gzh/k8s-demo/api/types/valpha"
	metav "ks.io/apimachinery/pkg/apis/meta/v"
	"ks.io/apimachinery/pkg/watch"
	"ks.io/client-go/kubernetes/scheme"
	"ks.io/client-go/rest"
)

type ProjectInterface interface {
	List(opts metav.ListOptions) (*valpha.ProjectList, error)
	Get(name string, options metav.GetOptions) (*valpha.Project, error)
	Create(*valpha.Project) (*valpha.Project, error)
	Watch(opts metav.ListOptions) (watch.Interface, error)
	// ...
}

type projectClient struct {
	restClient rest.Interface
	ns         string
}

func (c *projectClient) List(opts metav.ListOptions) (*valpha.ProjectList, error) {
	result := valpha.ProjectList{}
	err := c.restClient.
		Get().
		Namespace(c.ns).
		Resource("projects").
		VersionedParams(&opts, scheme.ParameterCodec).
		Do().
		Into(&result)

	return &result, err
}

func (c *projectClient) Get(name string, opts metav.GetOptions) (*valpha.Project, error) {
	result := valpha.Project{}
	err := c.restClient.
		Get().
		Namespace(c.ns).
		Resource("projects").
		Name(name).
		VersionedParams(&opts, scheme.ParameterCodec).
		Do().
		Into(&result)

	return &result, err
}

func (c *projectClient) Create(project *valpha.Project) (*valpha.Project, error) {
	result := valpha.Project{}
	err := c.restClient.
		Post().
		Namespace(c.ns).
		Resource("projects").
		Body(project).
		Do().
		Into(&result)

	return &result, err
}

func (c *projectClient) Watch(opts metav.ListOptions) (watch.Interface, error) {
	opts.Watch = true
	return c.restClient.
		Get().
		Namespace(c.ns).
		Resource("projects").
		VersionedParams(&opts, scheme.ParameterCodec).
		Watch()
}

package main

import (
	"fmt"

	clientValpha "github.com/double12gzh/k8s-demo/clientset/valpha"
)

// ...

func main() {
	// ...

	clientSet, err := clientValpha.NewForConfig(config)
	if err != nil {
		panic(err)
	}

	projects, err := clientSet.Projects("default").List(metav.ListOptions{})
	if err != nil {
		panic(err)
	}

	fmt.Printf("projects found: %+v\n", projects)
}

package main

import (
	"time"

	"github.com/double12gzh/k8s-demo/api/types/valpha"
	client_valpha "github.com/double12gzh/k8s-demo/clientset/valpha"
	metav "ks.io/apimachinery/pkg/apis/meta/v"
	"ks.io/apimachinery/pkg/runtime"
	"ks.io/apimachinery/pkg/util/wait"
	"ks.io/apimachinery/pkg/watch"
	"ks.io/client-go/tools/cache"
)

func WatchResources(clientSet client_valpha.ExampleVAlphaInterface) cache.Store {
	projectStore, projectController := cache.NewInformer(
		&cache.ListWatch{
			ListFunc: func(lo metav.ListOptions) (result runtime.Object, err error) {
				return clientSet.Projects("some-namespace").List(lo)
			},
			WatchFunc: func(lo metav.ListOptions) (watch.Interface, error) {
				return clientSet.Projects("some-namespace").Watch(lo)
			},
		},
		&valpha.Project{},
		*time.Minute,
		cache.ResourceEventHandlerFuncs{},
	)

	go projectController.Run(wait.NeverStop)
	return projectStore
}

store := WatchResource(clientSet)
project := store.GetByKey("some-namespace/some-project").(*v1alpha1.Project)