Skip to content

CronJobs

Desarrollo del tema

La presente guía aborda la creacion y uso del componente CronJob de Kubernetes.

Laboratorio: Jobs

Descripción

La presente guía aborda la creacion y uso del componente Job de Kubernetes.

Objetivos

  • Crear un Job a partir de un archivo YAML
  • Administrar un Job con sus diferentes operaciones

Antes de comenzar

  • Contar con el acceso al ambiente de laboratorio

Conexión hacia cluster

  1. Ingrese al cluster asignado con las credenciales proporcionadas

  2. Obtenga el archivo kubeconfig posicionando sobre la carpeta a trabajar y cambiando su nombre a config 

    mv /path/to/kubeconfig ~/.kube/config

  3. Configure la variable KUBECONFIG 

    export KUBECONFIG=~/.kube/config

  4. Verifique el acceso mediante comandos 

    kubectl get namespaces
kubectl config set-context --current --namespace=userx

Inicio de laboratorio

  1. Cree una carpeta llamado jobs y ubíquese dentro de ella 

    mkdir jobs ; cd jobs

  2. Cree un archivo llamado job.yaml con el siguiente contenido: 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    apiVersion: batch/v1
kind: Job
metadata:
  name: node-job
  namespace: userx
spec:
  template:
    spec:
      restartPolicy: Never
      containers:

  3. Agregue al bloque de containers la lista de nombre node-job con la imagen alpine y el comando echo con el mensaje Starting Node Application Job 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    apiVersion: batch/v1
kind: Job
metadata:
  name: node-job
  namespace: userx
spec:
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: node-job
          image: alpine
          command: ["/bin/sh", "-c", "echo [$(date)] Starting Node Application Job; sleep 30; echo [$(date)] Stopping Node Application Job"]

  4. Levante el recurso 

    kubectl apply -f job.yaml

  5. Revise los Jobs en el namespace 

    kubectl get jobs

  6. Obtenga la informacion del Job 

    kubectl describe job node-job

  7. Revise los pods 

    kubectl get pods

  8. Obtenga el log del pod 

    # Cambie nombre-pod por el nombre real
kubectl logs nombre-pod -f

  9. Elimine el Job 

    kubectl delete -f job.yaml

  10. Agregue al archivo job.yaml el campo parallelism en spec 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    apiVersion: batch/v1
kind: Job
metadata:
  name: node-job
  namespace: userx
spec:
  parallelism: 2
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: node-job
          image: alpine
          command: ["/bin/sh", "-c", "echo [$(date)] Starting Node Application Job; sleep 30; echo [$(date)] Stopping Node Application Job"]

  11. Sincronize los cambios 

    kubectl apply -f job.yaml

  12. Revise los pods del namespaces 

    kubectl get pods

  13. Obtenga el log de uno de los pods 

    # Cambie nombre-pod por el nombre real
kubectl logs nombre-pod -f

  14. Elimine el Job 

    kubectl delete -f job.yaml

  15. Edite el archivo jobs.yaml agregando el campo completions con valor de 6 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
    apiVersion: batch/v1
kind: Job
metadata:
  name: node-job
  namespace: userx
spec:
  completions: 6
  parallelism: 2
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: node-job
          image: alpine
          command: ["/bin/sh", "-c", "echo [$(date)] Starting Node Application Job; sleep 30; echo [$(date)] Stopping Node Application Job"]

  16. Sincronize los cambios 

    kubectl apply -f job.yaml

  17. Revise los pods del namespace 

    kubectl get pods

  18. Obtenga el log de uno de los pods 

    # Cambie nombre-pod por el nombre real
kubectl logs nombre-pod -f

  19. Espere que se terminen de crear los 6 pods en estado Completed 

    kubectl get pods -w
^Ctrl+C

  20. Elimine el Job 

    kubectl delete -f job.yaml

  21. Agregue el campo ttlSecondsAfterFinished en spec 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
    apiVersion: batch/v1
kind: Job
metadata:
  name: node-job
  namespace: userx
spec:
  ttlSecondsAfterFinished: 60
  completions: 6
  parallelism: 2
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: node-job
          image: alpine
          command: ["/bin/sh", "-c", "echo [$(date)] Starting Node Application Job; sleep 30; echo [$(date)] Stopping Node Application Job"]

  22. Sincronize los cambios 

    kubectl apply -f job.yaml

  23. Revise los pods del namespace 

    kubectl get pods

  24. Obtenga el log de uno de los pods 

    # Cambie nombre-pod por el nombre real
kubectl logs nombre-pod -f

  25. Espere que se completen todos los pods y despues de 60 segundos se marquen como Terminating 

    kubectl get pods -w
^Ctrl+C
kubectl get pods

  26. Limpie el ambiente 

    kubectl delete -f job.yaml

Laboratorio: CronJobs

Descripción

La presente guía aborda la creacion y uso del componente CronJob de Kubernetes.

Objetivos

  • Crear un CronJob a partir de un archivo YAML
  • Administrar un CronJob con sus diferentes operaciones

Antes de comenzar

  • Contar con el acceso al ambiente de laboratorio

Inicio de laboratorio

  1. Cree un archivo llamado cronjob.yaml con el siguiente contenido 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    apiVersion: batch/v1
kind: CronJob
metadata:
  name: node-cronjob
  namespace: userx
spec:
  schedule: "* * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: Never
          containers:

  2. Cambie el valor de schedule por la expresion de cada 1 minuto (Cron Expressions Editor) 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    apiVersion: batch/v1
kind: CronJob
metadata:
  name: node-cronjob
  namespace: userx
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: Never
          containers:

  3. Agregue el contenido de containers del Job anterior 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
    apiVersion: batch/v1
kind: CronJob
metadata:
  name: node-cronjob
  namespace: userx
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: Never
          containers:
            - name: node-job
              image: alpine
              command: ["/bin/sh", "-c", "echo [$(date)] Starting Node Application Job; sleep 30; echo [$(date)] Stopping Node Application Job"]

  4. Levante el recurso 

    kubectl apply -f cronjob.yaml

  5. Revise los cronjobs en el namespace 

    kubectl get cronjobs

  6. Revise los jobs en el namespace (espere un minuto para que se genere el primer job) 

    kubectl get jobs -w
^Ctrl+C

  7. Revise los pods en el namespace 

    kubectl get pods

  8. Revise los logs del pod 

    # Cambie nombre-pod por el nombre real
kubectl logs nombre-pod -f

  9. Agregue al jobTemplate los parametros originales del Job de la guia anterior 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    apiVersion: batch/v1
kind: CronJob
metadata:
  name: node-cronjob
  namespace: userx
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      ttlSecondsAfterFinished: 60
      completions: 6
      parallelism: 2
      template:
        spec:
          restartPolicy: Never
          containers:
            - name: node-job
              image: alpine
              command: ["/bin/sh", "-c", "echo [$(date)] Starting Node Application Job; sleep 30; echo [$(date)] Stopping Node Application Job"]

  10. Sincronize los cambios 

    kubectl apply -f cronjob.yaml

  11. Revise los jobs en el namespace 

    kubectl get jobs -w
# Espere a revisar que se levanten nuevos jobs cada minuto
^Ctrl+C

  12. Revise los pods en el namespace 

    kubectl get pods -w
# Espere a revisar que los ultimos Pods esten en Completed
^Ctrl+C

  13. Agregue los parametros concurrencyPolicy: "Forbid" y successfulJobsHistoryLimit: 1 al spec del CronJob 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
    apiVersion: batch/v1
kind: CronJob
metadata:
  name: node-cronjob
  namespace: userx
spec:
  schedule: "*/1 * * * *"
  concurrencyPolicy: "Forbid"
  successfulJobsHistoryLimit: 1
  jobTemplate:
    spec:
      ttlSecondsAfterFinished: 60
      completions: 6
      parallelism: 2
      template:
        spec:
          restartPolicy: Never
          containers:
            - name: node-job
              image: alpine
              command: ["/bin/sh", "-c", "echo [$(date)] Starting Node Application Job; sleep 30; echo [$(date)] Stopping Node Application Job"]

  14. Sincronize los cambios 

    kubectl apply -f cronjob.yaml

  15. Revise los jobs en el namespace 

    kubectl get jobs -w
# Espere a revisar que se levanten nuevos jobs cada minuto
^Ctrl+C

  16. Revise los pods en el namespace 

    kubectl get pods -w
# Espere a revisar que los ultimos Pods esten en Completed
^Ctrl+C

  17. Limpie el ambiente 

    kubectl delete -f cronjob.yaml