问创建k8s资源并等到它完成后再继续到下一个

EN

reconcile.Result{Requeue: true}

// SetupWithManager sets up the controller with the Manager.
func (r *YourReconciler) SetupWithManager(mgr ctrl.Manager) error {
    return ctrl.NewControllerManagedBy(mgr).
        For(&yourapigroup.YourCustomResource{}).
        Owns(&appv1.Deployment{}).
        Complete(r)
}

package main

import (
    "context"
    "fmt"
    v1 "k8s.io/api/apps/v1"
    podv1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/fields"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/cache"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/client/config"
    "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
    "time"
)

const (
    namespace      = "default"
    deploymentName = "nginx"
)

func main() {
    cfg, err := config.GetConfig()
    if err != nil {
        panic(err)
    }

    clientset, err := kubernetes.NewForConfig(cfg)
    if err != nil {
        panic(err)
    }

    client, err := client.New(cfg, client.Options{})
    if err != nil {
        panic(err)
    }

    d := &v1.Deployment{
        ObjectMeta: metav1.ObjectMeta{
            Name:      deploymentName,
            Namespace: namespace,
        },
        Spec: v1.DeploymentSpec{
            Replicas: toInt32Ptr(2),
            Selector: &metav1.LabelSelector{
                MatchLabels: map[string]string{
                    "app": "nginx",
                },
            },
            Template: podv1.PodTemplateSpec{
                ObjectMeta: metav1.ObjectMeta{
                    Labels: map[string]string{
                        "app": "nginx",
                    },
                },
                Spec: podv1.PodSpec{
                    Containers: []podv1.Container{
                        {
                            Name:  "nginx",
                            Image: "nginx",
                        },
                    },
                },
            },
        },
    }

    fmt.Println("Deploying")
    _, err = controllerutil.CreateOrUpdate(context.TODO(), client, d, func() error {
        return nil
    })

    if err != nil {
        panic(err)
    }

    stop := make(chan struct{})

    watchList := cache.NewListWatchFromClient(clientset.AppsV1().RESTClient(), "deployments", namespace, fields.Everything())
    _, ctrl := cache.NewInformer(watchList, &v1.Deployment{}, time.Second, cache.ResourceEventHandlerFuncs{
        UpdateFunc: func(o, n interface{}) {
            newDeployment := n.(*v1.Deployment)
            if newDeployment.Name != deploymentName {
                return
            }

            if newDeployment.Status.ReadyReplicas > 0 {
                close(stop)
                return
            }

            return
        },
    })

    ctrl.Run(stop)
    fmt.Println("Deployment has at least 1 ready replica")
}

func toInt32Ptr(i int32) *int32 {
    return &i
}