apiVersion: extensions/v1beta1kind: Deployment metadata:  name: nginx-deploymentspec:  replicas: 2  template:    metadata:      labels:        app: nginx    spec:      containers:      - name: nginx        image: nginx:1.8.0        ports:        - containerPort: 80

apiVersion: apps/v1kind: StatefulSetmetadata:  name: my-statefulsetspec:  serviceName: "my-service"  replicas: 3  selector:    matchLabels:      app: my-app  template:    metadata:      labels:        app: my-app    spec:      containers:      - name: my-container        image: my-image:1.0        volumeMounts:        - name: my-storage          mountPath: /data  volumeClaimTemplates:  - metadata:      name: my-storage    spec:      accessModes: ["ReadWriteOnce"]      resources:        requests:          storage: 1Gi

apiVersion: apps/v1kind: DaemonSetmetadata:  name: my-daemonsetspec:  selector:    matchLabels:      app: my-daemon  template:    metadata:      labels:        app: my-daemon    spec:      containers:      - name: my-daemon-container        image: my-daemon-image:1.0

apiVersion: batch/v1kind: Jobmetadata:  name: my-jobspec:  template:    spec:      containers:      - name: my-container        image: my-job-image:1.0      restartPolicy: OnFailure

apiVersion: batch/v1kind: CronJobmetadata:  name: my-cronjobspec:  schedule: "*/5 * * * *"  jobTemplate:    spec:      template:        spec:          containers:          - name: my-container            image: my-cronjob-image:1.0          restartPolicy: OnFailure

for {actualState := GetResourceActualState(rsvc)// 控制器模板定义    expectState := GetResourceExpectState(rsvc)     if actualState == expectState {        // do nothing} else {// 编排逻辑，调谐的最终结果一般是对被控制对象的某种写操作，比如增/删/改 Pod        Reconcile(rsvc)     }}

# 常见项目目录并初始化为go项目mkdir -p myappgo mod init github.com/mypaas/app
# 初始化控制器项目kubebuilder init --domain mypaas.io
# 生成应用资源对象App控制器相关模板代码kubebuilder create api --group auth --version v1 --kind App

---apiVersion: apiextensions.k8s.io/v1kind: CustomResourceDefinitionmetadata:  annotations:    controller-gen.kubebuilder.io/version: v0.10.0  creationTimestamp: null  name: apps.auth.mypass.iospec:  group: auth.mypass.io  names:    kind: App    listKind: AppList    plural: apps    singular: app  scope: Namespaced  versions:  - additionalPrinterColumns:    - jsonPath: .status.replicas      name: replicas      type: integer    name: v1beta1    schema:      openAPIV3Schema:        description: App is the Schema for the apps API        properties:          apiVersion:            description: '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'            type: string          kind:            description: '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'            type: string          metadata:            type: object          spec:            description: AppSpec defines the desired state of App            properties:              enable_ingress:                type: boolean              enable_service:                type: boolean              image:                type: string              replicas:                format: int32                type: integer            required:            - enable_service            - image            - replicas            type: object          status:            description: AppStatus defines the observed state of App            properties:              replicas:                description: 'INSERT ADDITIONAL STATUS FIELD - define observed state                  of cluster Important: Run "make" to regenerate code after modifying                  this file 应用状态'                format: int32                type: integer            required:            - replicas            type: object        type: object    served: true    storage: true    subresources:      status: {}

/*Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.*/
// +k8s:deepcopy-gen=package// +groupName=cebpaas.io
// Package v1alpha1 is the v1alpha1 version of the API.package v1

package v1
import (  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1")
// +genclient// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// App is the Schema for the apps APItype App struct {  metav1.TypeMeta   `json:",inline"`  metav1.ObjectMeta `json:"metadata,omitempty"`
  Spec   AppSpec   `json:"spec,omitempty"`  Status AppStatus `json:"status,omitempty"`}
// EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!// NOTE: json tags are required.  Any new fields you add must have json tags for the fields to be serialized.
// AppSpec defines the desired state of Apptype AppSpec struct {  EnableIngress bool   `json:"enable_ingress,omitempty"`  EnableService bool   `json:"enable_service"`  Replicas      int32  `json:"replicas"`  Image         string `json:"image"`}
// AppStatus defines the observed state of Apptype AppStatus struct {  // 应用状态  Replicas int32 `json:"replicas"`}
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// AppList contains a list of Apptype AppList struct {  metav1.TypeMeta `json:",inline"`  metav1.ListMeta `json:"metadata,omitempty"`  Items           []App `json:"items"`}

package v1
import (  "github.com/mypaas/app/pkg/apis/auth"  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"  "k8s.io/apimachinery/pkg/runtime"  "k8s.io/apimachinery/pkg/runtime/schema")
// SchemeGroupVersion is group version used to register these objectsvar SchemeGroupVersion = schema.GroupVersion{Group: auth.GroupName, Version: "v1"}
// Kind takes an unqualified kind and returns back a Group qualified GroupKindfunc Kind(kind string) schema.GroupKind {  return SchemeGroupVersion.WithKind(kind).GroupKind()}
// Resource takes an unqualified resource and returns a Group qualified GroupResourcefunc Resource(resource string) schema.GroupResource {  return SchemeGroupVersion.WithResource(resource).GroupResource()}
var (  // SchemeBuilder initializes a scheme builder  SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)  // AddToScheme is a global function that registers this API group & version to a scheme  AddToScheme = SchemeBuilder.AddToScheme)
// Adds the list of known types to Scheme.func addKnownTypes(scheme *runtime.Scheme) error {  scheme.AddKnownTypes(SchemeGroupVersion,    &App{},    &AppList{},  )  metav1.AddToGroupVersion(scheme, SchemeGroupVersion)  return nil}

package auth
// GroupName is the group name used in this packageconst (  GroupName = "mypaas.io")

 /*  Copyright The Kubernetes Authors.
  Licensed under the Apache License, Version 2.0 (the "License");  you may not use this file except in compliance with the License.  You may obtain a copy of the License at
      http://www.apache.org/licenses/LICENSE-2.0
  Unless required by applicable law or agreed to in writing, software  distributed under the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the specific language governing permissions and  limitations under the License.  */

//go:build tools  // +build tools
  package tools
  import _ "k8s.io/code-generator"

#!/usr/bin/env bash
set -o errexitset -o nounsetset -o pipefail
SCRIPT_ROOT=$(dirname "${BASH_SOURCE[0]}")/..CODEGEN_PKG=${CODEGEN_PKG:-$(cd "${SCRIPT_ROOT}"; ls -d -1 ./vendor/k8s.io/code-generator 2>/dev/null || echo ../code-generator)}
echo ${SCRIPT_ROOT}echo ${CODEGEN_PKG}
bash "${CODEGEN_PKG}"/generate-groups.sh "deepcopy,client,informer,lister" \  github.com/mypaas/app/pkg/generated github.com/mypaas/app/pkg/apis \  auth:v1 \  --go-header-file "${SCRIPT_ROOT}"/hack/boilerplate.go.txt

set -o errexit  set -o nounset  set -o pipefail
  SCRIPT_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
  DIFFROOT="${SCRIPT_ROOT}/pkg"  TMP_DIFFROOT="${SCRIPT_ROOT}/_tmp/pkg"  _tmp="${SCRIPT_ROOT}/_tmp"
  cleanup() {    rm -rf "${_tmp}"  }  trap "cleanup" EXIT SIGINT
  cleanup
  mkdir -p "${TMP_DIFFROOT}"  cp -a "${DIFFROOT}"/* "${TMP_DIFFROOT}"
  "${SCRIPT_ROOT}/hack/update-codegen.sh"  echo "diffing ${DIFFROOT} against freshly generated codegen"  ret=0  diff -Naupr "${DIFFROOT}" "${TMP_DIFFROOT}" || ret=$?  cp -a "${TMP_DIFFROOT}"/* "${DIFFROOT}"  if [[ $ret -eq 0 ]]  then    echo "${DIFFROOT} up to date."  else    echo "${DIFFROOT} is out of date. Please run hack/update-codegen.sh"    exit 1  fi

# 将项目代码移动至GOPATH路径下mkdir -p $GOPATH/src/github.com/mypaas/app# 生成vendorgo mod vendor# 生成代码sh hack/update-codegen.sh

/*Copyright 2023 xxxxx@126.com.
Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.*/
package controllers
import (  "context"  "fmt"  "github.com/cebpaas/app/controllers/utils"  appsv1 "k8s.io/api/apps/v1"  corev1 "k8s.io/api/core/v1"  networkv1 "k8s.io/api/networking/v1"  "k8s.io/apimachinery/pkg/api/errors"  "k8s.io/apimachinery/pkg/types"  "k8s.io/client-go/tools/record"  "reflect"  "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"  "sigs.k8s.io/controller-runtime/pkg/event"  "sigs.k8s.io/controller-runtime/pkg/log"  "sigs.k8s.io/controller-runtime/pkg/predicate"  "time"
  authv1beta1 "github.com/cebpaas/app/api/v1beta1"  "k8s.io/apimachinery/pkg/runtime"  ctrl "sigs.k8s.io/controller-runtime"  "sigs.k8s.io/controller-runtime/pkg/client")
// AppReconciler reconciles a App objecttype AppReconciler struct {  client.Client  Scheme   *runtime.Scheme  Recorder record.EventRecorder}
//+kubebuilder:rbac:groups=auth.cebpass.io,resources=apps,verbs=get;list;watch;create;update;patch;delete//+kubebuilder:rbac:groups=auth.cebpass.io,resources=apps/status,verbs=get;update;patch//+kubebuilder:rbac:groups=auth.cebpass.io,resources=apps/finalizers,verbs=update
// Reconcile is part of the main kubernetes reconciliation loop which aims to// move the current state of the cluster closer to the desired state.// TODO(user): Modify the Reconcile function to compare the state specified by// the App object against the actual cluster state, and then// perform operations to make the cluster state reflect the state specified by// the user.//// For more details, check Reconcile and its Result here:// - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.13.1/pkg/reconcilefunc (r *AppReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {  logger := log.FromContext(ctx)  app := &authv1beta1.App{}
  logger.Info("enter....................")
  // 从缓存中获取app  if err := r.Get(ctx, req.NamespacedName, app); err != nil {    return ctrl.Result{}, client.IgnoreNotFound(err)  }
  // 非删除app操作  if app.ObjectMeta.DeletionTimestamp.IsZero() {    // 设置finalizer    if app.Finalizers == nil {      fmt.Println("finalizers...................")      app.Finalizers = append(app.Finalizers, "finalizer.app.cebpaas.io")      if err := r.Update(ctx, app); err != nil {        r.Recorder.Event(app, corev1.EventTypeWarning, "update error", fmt.Sprintf("Failed to update App: %s", app.Name))        return ctrl.Result{}, err      }
      r.Recorder.Event(app, corev1.EventTypeNormal, "update finalizer", fmt.Sprintf("Successfully to update App:%s Finalizer", app.Name))      return ctrl.Result{}, nil    }
    d := &appsv1.Deployment{}    // deploy处理    deployment := utils.NewDeployment(app)    if err := r.Get(ctx, req.NamespacedName, d); err != nil {      // 如果k8s中不存在deploy，则创建deployment      if errors.IsNotFound(err) {        // 设置deployment的属主，便于垃圾回收和事件触发        if err := controllerutil.SetControllerReference(app, deployment, r.Scheme); err != nil {          return ctrl.Result{}, err        }
        if err := r.Create(ctx, deployment); err != nil {          logger.Error(err, "create deploy failed")          return ctrl.Result{}, err        }      }
      return ctrl.Result{}, err    } else {      // 当image或者replicas发生变化，才会更新deployment      if app.Spec.Replicas != *(d.Spec.Replicas) || app.Spec.Image != d.Spec.Template.Spec.Containers[0].Image {        if err := r.Update(ctx, deployment); err != nil {          return ctrl.Result{}, err        }      }    }
    // service处理    service := utils.NewService(app)
    s := &corev1.Service{}    if err := r.Get(ctx, types.NamespacedName{Name: app.Name, Namespace: app.Namespace}, s); err != nil {      // 如果没有找到service，而且启动service开关，则创建      if errors.IsNotFound(err) && app.Spec.EnableService {        if err := controllerutil.SetControllerReference(app, service, r.Scheme); err != nil {          return ctrl.Result{}, err        }
        if err := r.Create(ctx, service); err != nil {          logger.Error(err, "create service failed")          return ctrl.Result{}, err        }      }
      // 如果err不是not found，而且启动service，需要重试      if !errors.IsNotFound(err) && app.Spec.EnableService {        return ctrl.Result{}, err      }
    } else {      // k8s存在service且开启service开关      if app.Spec.EnableService {        logger.Info("skip update service")      } else {        // service存在，但关闭service开关，则删除service        if err := r.Delete(ctx, s); err != nil {          return ctrl.Result{}, err        }      }    }
    // ingress处理    ingress := utils.NewIngress(app)    i := &networkv1.Ingress{}    if err := r.Get(ctx, types.NamespacedName{Name: app.Name, Namespace: app.Namespace}, i); err != nil {      // ingress不存在且开启ingress开关，则创建ingress      if errors.IsNotFound(err) && app.Spec.EnableIngress {        if err := controllerutil.SetControllerReference(app, ingress, r.Scheme); err != nil {          return ctrl.Result{}, err        }
        if err := r.Create(ctx, ingress); err != nil {          logger.Error(err, "create ingress failed")          return ctrl.Result{}, err        }      }
      // 非不存在错误且开启ingress，需要重试      if !errors.IsNotFound(err) && app.Spec.EnableIngress {        return ctrl.Result{}, err      }    } else {      // 开启ingress开关，则不做任何操作      if app.Spec.EnableIngress {        logger.Info("skip update ingress")      } else {        // 关闭ingress开关，则删除ingress        if err := r.Delete(ctx, i); err != nil {          return ctrl.Result{}, err        }      }    }
    // 更新app的状态：需要判断真实状态和期望状态，不一致,再更新，否则会导致循环触发。    if app.Status.Replicas != d.Status.AvailableReplicas {      app.Status.Replicas = d.Status.AvailableReplicas      if err := r.Status().Update(ctx, app); err != nil {        return ctrl.Result{}, err      }    }
    return ctrl.Result{}, nil
    // 删除app操作: 删除后的清理工作  } else {    fmt.Println("starting to handler something.")    time.Sleep(time.Second * 5)
    app.Finalizers = nil    if err := r.Update(ctx, app); err != nil {      return ctrl.Result{}, err    }
    return ctrl.Result{}, nil  }}
// SetupWithManager sets up the controller with the Manager.func (r *AppReconciler) SetupWithManager(mgr ctrl.Manager) error {  return ctrl.NewControllerManagedBy(mgr).    For(&authv1beta1.App{}).WithEventFilter(&EventResource{}).    // 只会watch属主为app的Deployment    Owns(&appsv1.Deployment{}).    // 只会watch属主为app的Ingress    Owns(&networkv1.Ingress{}).    // 只会watch属主为app的Service    Owns(&corev1.Service{}).    Complete(r)}
type EventResource struct {  predicate.Funcs}
func (rl *EventResource) Update(e event.UpdateEvent) bool {  newObj := e.ObjectNew.(*authv1beta1.App)  // delete事件-----> update事件  if newObj.DeletionTimestamp != nil {    return true  }
  oldObj := e.ObjectOld.(*authv1beta1.App)
  if reflect.DeepEqual(newObj.Spec, oldObj.Spec) {    // 更新状态
    return false  }
  return true}

# 安装crd到kubernetesmake install
# 启动控制器make run

kubectl apply -f config/samples/ingress_v1beta1_app.yaml# yaml文件内容apiVersion: auth.mypaas.app/v1kind: Appmetadata:   labels:      app.kubernetes.io/name: app   name: app-samplespec:   # TODO(user): Add fields here   image: nginx:latest   replicas: 3   enable_ingress: false   enable_service: false