Exercise

In this exercise, you will create a Job to dump a MongoDB database. You will then create a CronJob to perform dumps at regular intervals.

1. Creating a MongoDB Pod

In a file named mongo-pod.yaml, define the specification for a Pod named db based on the mongo:4.0 image, then create this Pod.

Note: you can also create this Pod using the imperative command kubectl run

2. Exposing the MongoDB Database

In a file named mongo-svc.yaml, define the specification for a Service named db of type clusterIP to expose the previous Pod inside the cluster. Then create this Service.

Note: MongoDB listens by default on port 27017

Note: you can also create this Service using the imperative command kubectl expose

3. Adding a Label to One of the Cluster Nodes

In the following questions, you will run a Job to dump the previously created database and a CronJob to perform this action at regular intervals. To ensure that the different dumps are created on the same node’s filesystem, add the label app=dump to one of your cluster’s nodes:

kubectl label node NODE_NAME app=dump

Note: in a production context, we would ensure the dump is sent directly to external storage (NFS, S3, …).

4. Defining a Job to Dump the Database

In a file named mongo-dump-job.yaml, define the specification for a Job that launches a Pod based on mongo:4.0.

Use the nodeSelector property to deploy the Pod on the previously labeled node (you can use the kubectl explain ... command to learn how to define this property).

The Pod launched by the Job must also define a volume to persist data in the /dump directory of the node it runs on. You will use the volumes instruction in the Pod specification part:

volumes:
- name: dump
  hostPath:
    path: /dump

The mongo container of this Pod must mount this volume in its /dump directory. You will use the volumeMounts instruction in the mongo container specification:

volumeMounts:
- name: dump
  mountPath: /dump

Additionally, ensure that the Pod’s container runs the following command to create the /dump/db.gz file containing the database dump.

/bin/bash -c mongodump --gzip --host db --archive=/dump/db.gz

Note: this command uses the mongodump binary present in the mongo:4.0 image. The container will connect to the db service you launched previously.

Then launch this Job and verify that the Pod launched by this Job ran correctly.

5. Defining a CronJob to Perform Database Dumps at Regular Intervals

In a file named mongo-dump-cronjob.yaml, define the specification for a CronJob that performs a mongo dump every minute.

Use the nodeSelector property to deploy the Pod on the previously labeled node (you can use the kubectl explain ... command to learn how to define this property).

To preserve the different dumps, make the Pod’s container run the following command (this adds a timestamp to the generated dump filename):

/bin/bash -c mongodump --gzip --host db --archive=/dump/$(date +"%Y%m%dT%H%M%S")-db.gz

Then launch this CronJob.

6. Verifying the Dumps

Launch a test Pod ensuring it is scheduled on the node with the label app: dump and has access to the /dump directory of this node.

From a shell in this Pod, verify that the dumps have been created.

7. Verifying the Dumps (Alternative Method)

Use the kubectl debug command to launch an alpine pod on one of your cluster nodes.

8. Finally, delete the previous Job and CronJob.

apiVersion: v1             
kind: Pod                  
metadata:
  name: db
  labels:
    app: db
spec:
  containers:
  - name: mongo
    image: mongo:4.0

kubectl apply -f mongo-pod.yaml

kubectl run db --image=mongo:4.0

apiVersion: v1
kind: Service
metadata:
  name: db
spec:
  selector:
    app: db
  type: ClusterIP
  ports:
  - port: 27017

kubectl apply -f mongo-svc.yaml

kubectl expose pod/db --port 27017 --target-port 27017

apiVersion: batch/v1
kind: Job
metadata:
  name: dump
spec:
  template:
    spec:
      restartPolicy: Never
      nodeSelector:
        app: dump
      containers:
      - name: mongo
        image: mongo:4.0
        command:
        - /bin/bash
        - -c
        - mongodump --gzip --host db --archive=/dump/db.gz
        volumeMounts:
        - name: dump
          mountPath: /dump
      volumes:
      - name: dump
        hostPath:
          path: /dump

kubectl apply -f mongo-dump-job.yaml

$ kubectl get po
NAME         READY   STATUS      RESTARTS   AGE
dump-r5jg6   0/1     Completed   0          32s

$ kubectl logs dump-r5jg6
2022-05-24T20:23:23.865+0000	writing admin.system.version to archive '/dump/db.gz'
2022-05-24T20:23:23.870+0000	done dumping admin.system.version (1 document)

apiVersion: batch/v1
kind: CronJob
metadata:
  name: dump
spec:
  schedule: "* * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          nodeSelector:
            app: dump
          containers:
          - name: mongo
            image: mongo:4.0
            command:
            - /bin/bash
            - -c
            - mongodump --gzip --host db --archive=/dump/$(date +"%Y%m%dT%H%M%S")-db.gz
            volumeMounts:
            - name: dump
              mountPath: /dump
          restartPolicy: OnFailure
          volumes:
          - name: dump
            hostPath:
              path: /dump

kubectl apply -f mongo-dump-cronjob.yaml

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: test
spec:
  nodeSelector:
    app: dump
  containers:
  - name: test
    image: alpine:3.15
    command:
    - "sleep"
    - "10000"
    volumeMounts:
    - name: dump
      mountPath: /dump
  volumes:
  - name: dump
    hostPath:
      path: /dump
EOF

kubectl exec -ti test -- sh

# ls /dump
20220524T202900-db.gz  20220524T203000-db.gz  20220524T203100-db.gz  db.gz

kubectl debug node/NODE_NAME -it --image=alpine

kubectl delete job/dump cj/dump po/test po/db svc/db