Question

我有kubernetes工作需要不同的时间来完成。 4至8分钟。有什么方法我可以知道什么时候工作完成，而不是等待8分钟假设最坏的情况。我有一个测试用例，它执行以下操作：

1) Submits the kubernetes job.
2) Waits for its completion.
3) Checks whether the job has had the expected affect.

问题是在我提交kubernetes中的部署作业的java测试中，我等待8分钟，即使作业花费的时间少于完成，因为我没有办法监视作业的状态来自java测试。

Answer 1

<kube master>/apis/batch/v1/namespaces/default/jobs

端点列出了作业的状态。我已经解析了这个json，并检索了以“deploy ...”开头的最新运行作业的名称。

然后我们可以点击

<kube master>/apis/batch/v1/namespaces/default/jobs/<job name retrieved above>

监视状态字段值，如果作业成功，则显示如下

"status": {
    "conditions": [
      {
        "type": "Complete",
        "status": "True",
        "lastProbeTime": "2016-09-22T13:59:03Z",
        "lastTransitionTime": "2016-09-22T13:59:03Z"
      }
    ],
    "startTime": "2016-09-22T13:56:42Z",
    "completionTime": "2016-09-22T13:59:03Z",
    "succeeded": 1
  }

所以我们一直在轮询这个端点，直到它完成。希望这有助于某人。

Answer 2

$ kubectl wait --for=condition=complete --timeout=600s job/myjob

Answer 3

既然你说过Java;您可以使用fabric8中的kubernetes java绑定来启动作业并添加一个观察者：

KubernetesClient k = ...
k.extensions().jobs().load(yaml).watch (new Watcher <Job>() {

  @Override
  public void onClose (KubernetesClientException e) {}

  @Override
  public void eventReceived (Action a, Job j) {
    if(j.getStatus().getSucceeded()>0)
      System.out.println("At least one job attempt succeeded");
    if(j.getStatus().getFailed()>0)
      System.out.println("At least one job attempt failed");
  }
});

Answer 4

我发现使用job.getStatus（）进行轮询时JobStatus不会更新即使在使用kubectl从命令提示符处进行检查时状态发生了变化。

要解决此问题，请重新加载作业处理程序：

    client.extensions().jobs()
                       .inNamespace(myJob.getMetadata().getNamespace())
                       .withName(myJob.getMetadata().getName())
                       .get();

我检查工作状态的循环如下：

    KubernetesClient client = new DefaultKubernetesClient(config);
    Job myJob = client.extensions().jobs()
                      .load(new FileInputStream("/path/x.yaml"))
                      .create();
    boolean jobActive = true;
    while(jobActive){
        myJob = client.extensions().jobs()
                .inNamespace(myJob.getMetadata().getNamespace())
                .withName(myJob.getMetadata().getName())
                .get();
        JobStatus myJobStatus = myJob.getStatus();
        System.out.println("==================");
        System.out.println(myJobStatus.toString());

        if(myJob.getStatus().getActive()==null){
            jobActive = false;
        }
        else {
            System.out.println(myJob.getStatus().getActive());
            System.out.println("Sleeping for a minute before polling again!!");
            Thread.sleep(60000);
        }
    }

    System.out.println(myJob.getStatus().toString());

希望这会有所帮助

Answer 5

你没有提到实际检查工作完成情况，但是不要盲目等待并希望最好，你应该继续在循环中轮询工作status，直到它变为＆＃34;已完成＆＃34;

Answer 6

我不知道你在谈论什么样的任务，但让我们假设你正在运行一些pods

你可以做到

watch 'kubectl get pods | grep <name of the pod>'

或

kubectl get pods -w

当然，它不是全名，因为如果你运行nginx副本或部署你的pod会最终得到类似nginx-1696122428-ftjvy之类的东西，那么pod大多数时候会获得随机名称，所以你会想做< / p>

watch 'kubectl get pods | grep nginx'

您可以将 pods 替换为您正在执行的任何工作，即（rc，svc，deployments ....）

Answer 7

您可以使用NewSharedInformer方法来查看作业的状态。不确定如何用Java编写它，这是可以定期获取您的工作清单的golang示例：

    type ClientImpl struct {
        clients *kubernetes.Clientset
    }

    type JobListFunc func() ([]batchv1.Job, error)

var (
    jobsSelector = labels.SelectorFromSet(labels.Set(map[string]string{"job_label": "my_label"})).String()
)


    func (c *ClientImpl) NewJobSharedInformer(resyncPeriod time.Duration) JobListFunc {
        var once sync.Once
        var jobListFunc JobListFunc

        once.Do(
            func() {
                restClient := c.clients.BatchV1().RESTClient()
                optionsModifer := func(options *metav1.ListOptions) {
                    options.LabelSelector = jobsSelector
                }
                watchList := cache.NewFilteredListWatchFromClient(restClient, "jobs", metav1.NamespaceAll, optionsModifer)
                informer := cache.NewSharedInformer(watchList, &batchv1.Job{}, resyncPeriod)

                go informer.Run(context.Background().Done())

                jobListFunc = JobListFunc(func() (jobs []batchv1.Job, err error) {
                    for _, c := range informer.GetStore().List() {
                        jobs = append(jobs, *(c.(*batchv1.Job)))
                    }
                    return jobs, nil
                })
            })

        return jobListFunc
    }

然后在监视器中，您可以通过排列作业列表来检查状态：

 func syncJobStatus() {
    jobs, err := jobListFunc()
    if err != nil {
        log.Errorf("Failed to list jobs: %v", err)
        return
    }

    // TODO: other code

    for _, job := range jobs {
        name := job.Name
        // check status...
    }
}

监控kubernetes工作

7 个答案: