func (r *ImoocPodReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
  logger := r.Log.WithValues("imoocpod", req.NamespacedName)
  logger.Info("start reconcile")

  // your logic here

  // fetch the ImoocPod instance
  instance := &batchv1alpha1.ImoocPod{}
  if err := r.Client.Get(ctx, req.NamespacedName, instance); err != nil {
    if errors.IsNotFound(err) {
      return ctrl.Result{}, nil
    }
    return ctrl.Result{}, err
  }

  // Define a new Pod object
  pod := newPodForCR(instance)

  // Set ImoocPod instance as the owner and controller
  if err := controllerutil.SetControllerReference(instance, pod, r.Scheme); err != nil {
    return ctrl.Result{}, err
  }

  // Check if this Pod already exists
  found := &corev1.Pod{}
  logger.Info("try to retrieve pods " + pod.Name + " " + pod.Namespace)
  err := r.Client.Get(ctx, types.NamespacedName{Name: pod.Name, Namespace: pod.Namespace}, found)
  if err != nil && errors.IsNotFound(err) {
    logger.Info("Create a new Pod " + pod.Name)
    if err := r.Client.Create(ctx, pod); err != nil {
      return ctrl.Result{}, err
    }
    return ctrl.Result{}, nil
  } else if err != nil {
    return ctrl.Result{}, err
  }

  logger.Info("skip reconcile: Pod already exists")

  return ctrl.Result{}, nil
}

func newPodForCR(cr *batchv1alpha1.ImoocPod) *corev1.Pod {
  labels := map[string]string{"app": cr.Name}
  return &corev1.Pod{
    ObjectMeta: metav1.ObjectMeta{
      Name:      cr.Name + "-pod",
      Namespace: cr.Namespace,
      Labels:    labels,
    },
    Spec: corev1.PodSpec{
      Containers: []corev1.Container{
        {
          Name:    "busybox",
          Image:   "busybox",
          Command: []string{"sleep", "3600"},
        },
      },
    },
  }
}

//+kubebuilder:rbac:groups="",resources=pods,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups="",resources=pods/status,verbs=get

// ImoocPodSpec defines the desired state of ImoocPod
type ImoocPodSpec struct {
        // INSERT ADDITIONAL SPEC FIELDS - desired state of cluster
        // Important: Run "make" to regenerate code after modifying this file

        Replicas int `json:"replicas"`
}

// ImoocPodStatus defines the observed state of ImoocPod
type ImoocPodStatus struct {
        // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
        // Important: Run "make" to regenerate code after modifying this file

        Replicas int      `json:"replicas"`
        PodNames []string `json:"podNames"`
}

func (r *ImoocPodReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
  logger := r.Log.WithValues("imoocpod", req.NamespacedName)
  logger.Info("start reconcile")

  // fetch the ImoocPod instance
  instance := &batchv1alpha1.ImoocPod{}
  if err := r.Client.Get(ctx, req.NamespacedName, instance); err != nil {
    if errors.IsNotFound(err) {
      return ctrl.Result{}, nil
    }
    return ctrl.Result{}, err
  }

  // 1. 获取 name 对应的所有的 pod 的列表
  lbls := labels.Set{"app": instance.Name}
  existingPods := &corev1.PodList{}
  if err := r.Client.List(ctx, existingPods, &client.ListOptions{
    Namespace: req.Namespace, LabelSelector: labels.SelectorFromSet(lbls)}); err != nil {
    logger.Error(err, "fetching existing pods failed")
    return ctrl.Result{}, err
  }

  // 2. 获取 pod 列表中的 pod name
  var existingPodNames []string
  for _, pod := range existingPods.Items {
    if pod.GetObjectMeta().GetDeletionTimestamp() != nil {
      continue
    }
    if pod.Status.Phase == corev1.PodRunning || pod.Status.Phase == corev1.PodPending {
      existingPodNames = append(existingPodNames, pod.GetObjectMeta().GetName())
    }
  }

  // 3. 更新当前状态信息
  currStatus := batchv1alpha1.ImoocPodStatus{
    Replicas: len(existingPodNames),
    PodNames: existingPodNames,
  }
  if !reflect.DeepEqual(instance.Status, currStatus) {
    instance.Status = currStatus
    if err := r.Client.Status().Update(ctx, instance); err != nil {
      logger.Error(err, "update pod failed")
      return ctrl.Result{}, err
    }
  }

  // 4. pod.Spec.Replicas > 运行中的 len(pod.replicas)，比期望值小，需要 scale up create
  if instance.Spec.Replicas > len(existingPodNames) {
    logger.Info(fmt.Sprintf("creating pod, current and expected num: %d %d", len(existingPodNames), instance.Spec.Replicas))
    pod := newPodForCR(instance)
    if err := controllerutil.SetControllerReference(instance, pod, r.Scheme); err != nil {
      logger.Error(err, "scale up failed: SetControllerReference")
      return ctrl.Result{}, err
    }
    if err := r.Client.Create(ctx, pod); err != nil {
      logger.Error(err, "scale up failed: create pod")
      return ctrl.Result{}, err
    }
  }

  // 5. pod.Spec.Replicas < 运行中的 len(pod.replicas)，比期望值大，需要 scale down delete
  if instance.Spec.Replicas < len(existingPodNames) {
    logger.Info(fmt.Sprintf("deleting pod, current and expected num: %d %d", len(existingPodNames), instance.Spec.Replicas))
    pod := existingPods.Items[0]
    existingPods.Items = existingPods.Items[1:]
    if err := r.Client.Delete(ctx, &pod); err != nil {
      logger.Error(err, "scale down faled")
      return ctrl.Result{}, err
    }
  }

  return ctrl.Result{Requeue: true}, nil
}

func newPodForCR(cr *batchv1alpha1.ImoocPod) *corev1.Pod {
  labels := map[string]string{"app": cr.Name}
  return &corev1.Pod{
    ObjectMeta: metav1.ObjectMeta{
      GenerateName: cr.Name + "-pod",
      Namespace:    cr.Namespace,
      Labels:       labels,
    },
    Spec: corev1.PodSpec{
      Containers: []corev1.Container{
        {
          Name:    "busybox",
          Image:   "busybox",
          Command: []string{"sleep", "3600"},
        },
      },
    },
  }
}