# 安装 Kubebuilder
# ...

# 初始化项目
mkdir node-scaler-operator && cd node-scaler-operator
kubebuilder init --domain example.com --repo example.com/node-scaler-operator

# 创建 API (CRD 和 Controller)
kubebuilder create api --group scaler --version v1 --kind NodeScaler

// NodeScalerSpec defines the desired state of NodeScaler
type NodeScalerSpec struct {
    // NodeName is the name of the node to be scaled down.
    // +kubebuilder:validation:Required
    NodeName string `json:"nodeName"`
}

// NodeScalerStatus defines the observed state of NodeScaler
type NodeScalerStatus struct {
    // Phase indicates the current state of the scaling process.
    // e.g., "Pending", "Cordoning", "Draining", "Terminating", "Succeeded", "Failed"
    Phase string `json:"phase,omitempty"`
    // Message provides more details about the current phase.
    Message string `json:"message,omitempty"`
}

package controllers

import (
	"context"
	"fmt"
	"time"

	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/drain"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/log"

	scalerv1 "example.com/node-scaler-operator/api/v1"
)

// NodeScalerReconciler reconciles a NodeScaler object
type NodeScalerReconciler struct {
	client.Client
	Scheme    *runtime.Scheme
	Clientset *kubernetes.Clientset // Use clientset for drain helper
}

// CloudProvider is an interface for cloud-specific operations
type CloudProvider interface {
	TerminateNode(ctx context.Context, node *corev1.Node) error
}

// AwsCloudProvider is a sample implementation for AWS
type AwsCloudProvider struct{}

func (p *AwsCloudProvider) TerminateNode(ctx context.Context, node *corev1.Node) error {
	// IMPORTANT: Production code should use the AWS SDK for Go.
	// This is a placeholder for demonstration.
	// 1. Get instance ID from node.Spec.ProviderID
	// 2. Call EC2 TerminateInstances API
	log.FromContext(ctx).Info("Simulating node termination", "node", node.Name, "providerID", node.Spec.ProviderID)
	// Example: cmd := exec.Command("aws", "ec2", "terminate-instances", "--instance-ids", instanceID)
	// return cmd.Run()
	return nil
}

//+kubebuilder:rbac:groups=scaler.example.com,resources=nodescalers,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=scaler.example.com,resources=nodescalers/status,verbs=get;update;patch
//+kubebuilder:rbac:groups="",resources=nodes,verbs=get;list;watch;update;patch
//+kubebuilder:rbac:groups="",resources=pods,verbs=list;watch
//+kubebuilder:rbac:groups="",resources=pods/eviction,verbs=create

func (r *NodeScalerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	logger := log.FromContext(ctx)

	// 1. Fetch the NodeScaler instance
	scaler := &scalerv1.NodeScaler{}
	if err := r.Get(ctx, req.NamespacedName, scaler); err != nil {
		return ctrl.Result{}, client.IgnoreNotFound(err)
	}

	// If phase is already Succeeded or Failed, do nothing
	if scaler.Status.Phase == "Succeeded" || scaler.Status.Phase == "Failed" {
		return ctrl.Result{}, nil
	}

	// 2. Fetch the target Node
	node := &corev1.Node{}
	if err := r.Get(ctx, client.ObjectKey{Name: scaler.Spec.NodeName}, node); err != nil {
		if errors.IsNotFound(err) {
			logger.Error(err, "Target node not found")
			scaler.Status.Phase = "Failed"
			scaler.Status.Message = "Node not found."
			_ = r.Status().Update(ctx, scaler)
			return ctrl.Result{}, nil
		}
		return ctrl.Result{}, err
	}

	// 3. Cordon the node
	if !node.Spec.Unschedulable {
		logger.Info("Cordoning node...")
		scaler.Status.Phase = "Cordoning"
		scaler.Status.Message = "Marking node as unschedulable."
		if err := r.Status().Update(ctx, scaler); err != nil {
			return ctrl.Result{}, err
		}

		node.Spec.Unschedulable = true
		if err := r.Update(ctx, node); err != nil {
			logger.Error(err, "Failed to cordon node")
			return ctrl.Result{RequeueAfter: 10 * time.Second}, err
		}
		return ctrl.Result{Requeue: true}, nil
	}

	// 4. Drain the node
	if scaler.Status.Phase != "Draining" && scaler.Status.Phase != "Terminating" {
		logger.Info("Draining node...")
		scaler.Status.Phase = "Draining"
		scaler.Status.Message = "Evicting all pods from the node."
		if err := r.Status().Update(ctx, scaler); err != nil {
			return ctrl.Result{}, err
		}

		// Use the official drain helper
		drainer := &drain.Helper{
			Ctx:                 ctx,
			Client:              r.Clientset,
			Force:               true,
			IgnoreAllDaemonSets: true,
			DeleteEmptyDirData:  true,
			GracePeriodSeconds:  60,
			Out:                 logger.GetSink(),
			ErrOut:              logger.GetSink(),
		}

		if err := drain.RunNodeDrain(drainer, node.Name); err != nil {
			logger.Error(err, "Failed to drain node")
			scaler.Status.Phase = "Failed"
			scaler.Status.Message = fmt.Sprintf("Drain failed: %v", err)
			_ = r.Status().Update(ctx, scaler)
			return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
		}
		return ctrl.Result{Requeue: true}, nil
	}

	// 5. Terminate the node from cloud provider
	logger.Info("Terminating node from cloud provider...")
	scaler.Status.Phase = "Terminating"
	scaler.Status.Message = "Calling cloud provider to terminate the instance."
	if err := r.Status().Update(ctx, scaler); err != nil {
		return ctrl.Result{}, err
	}

	cloudProvider := &AwsCloudProvider{} // Replace with your provider
	if err := cloudProvider.TerminateNode(ctx, node); err != nil {
		logger.Error(err, "Failed to terminate node from cloud provider")
		scaler.Status.Phase = "Failed"
		scaler.Status.Message = fmt.Sprintf("Termination failed: %v", err)
		_ = r.Status().Update(ctx, scaler)
		return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
	}

	// 6. Finalize
	logger.Info("Node scaled down successfully")
	scaler.Status.Phase = "Succeeded"
	scaler.Status.Message = "Node has been cordoned, drained, and terminated."
	if err := r.Status().Update(ctx, scaler); err != nil {
		return ctrl.Result{}, err
	}

	return ctrl.Result{}, nil
}

// SetupWithManager sets up the controller with the Manager.
func (r *NodeScalerReconciler) SetupWithManager(mgr ctrl.Manager) error {
	// Get a clientset for the drain helper
	clientset, err := kubernetes.NewForConfig(mgr.GetConfig())
	if err != nil {
		return err
	}
	r.Clientset = clientset

	return ctrl.NewControllerManagedBy(mgr).
		For(&scalerv1.NodeScaler{}).
		Owns(&corev1.Node{}). // Watch Nodes owned by NodeScaler
		Complete(r)
}

# 运行测试
make test

// main.go
mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
    // ...
    LeaderElection:          true,
    LeaderElectionID:        "f8b9e5c5.example.com",
})

# 1. 构建并推送 Docker 镜像
make docker-build docker-push IMG=your-repo/node-scaler-operator:v0.0.1

# 2. 部署到集群
make deploy IMG=your-repo/node-scaler-operator:v0.0.1