Using Finalizers

Finalizers allow controllers to implement asynchronous pre-delete hooks. Letsay you create an external resource such as a storage bucket for each object ofthe API type you are implementing and you would like to clean up the external resourcewhen the corresponding object is deleted from Kubernetes, you can use afinalizer to delete the external resource.

You can read more about the finalizers in the kubernetes reference docs. Section belowdemonstrates how to register and trigger pre-delete hooks in the Reconcilemethod of a controller.

Highlights:

  • If object is not being deleted and does not have the finalizer registered,then add the finalizer and update the object in kubernetes.
  • If object is being deleted and the finalizer is still present in finalizers list,then execute the pre-delete logic and remove the finalizer and update theobject.
  • You should implement the pre-delete logic in such a way that it is safe to invoke it multiple times for the same object.
  2. func (r *Reconciler) Reconcile(request reconcile.Request) (reconcile.Result, error) {
  3.     err := r.Get(context.TODO(), request.NamespacedName, instance)
  4.     if err != nil {
  5.         // handle error
  6.     }
  8.     // name of your custom finalizer
  9.     myFinalizerName := "storage.finalizers.example.com"
  11.     if instance.ObjectMeta.DeletionTimestamp.IsZero() {
  12.         // The object is not being deleted, so if it does not have our finalizer,
  13.         // then lets add the finalizer and update the object.
  14.         if !containsString(instance.ObjectMeta.Finalizers, myFinalizerName) {
  15.             instance.ObjectMeta.Finalizers = append(instance.ObjectMeta.Finalizers, myFinalizerName)
  16.             if err := r.Update(context.Background(), instance); err != nil {
  17.                 return reconcile.Result{}, err
  18.             }
  19.         }
  20.     } else {
  21.         // The object is being deleted
  22.         if containsString(instance.ObjectMeta.Finalizers, myFinalizerName) {
  23.             // our finalizer is present, so lets handle our external dependency
  24.             if err := r.deleteExternalDependency(instance); err != nil {
  25.                 // if fail to delete the external dependency here, return with error
  26.                 // so that it can be retried
  27.                 return reconcile.Result{}, err
  28.             }
  30.             // remove our finalizer from the list and update it.
  31.             instance.ObjectMeta.Finalizers = removeString(instance.ObjectMeta.Finalizers, myFinalizerName)
  32.             if err := r.Update(context.Background(), instance); err != nil {
  33.                 return reconcile.Result{}, err
  34.             }
  35.         }
  37.         // Our finalizer has finished, so the reconciler can do nothing.
  38.         return reconcile.Result{}, nil
  39.     }
  40.     ....
  41.     ....
  42. }
  44. func (r *Reconciler) deleteExternalDependency(instance *MyType) error {
  45.     log.Printf("deleting the external dependencies")
  46.     //
  47.     // delete the external dependency here
  48.     //
  49.     // Ensure that delete implementation is idempotent and safe to invoke
  50.     // multiple types for same object.
  51. }
  53. //
  54. // Helper functions to check and remove string from a slice of strings.
  55. //
  56. func containsString(slice []string, s string) bool {
  57.     for _, item := range slice {
  58.         if item == s {
  59.             return true
  60.         }
  61.     }
  62.     return false
  63. }
  65. func removeString(slice []string, s string) (result []string) {
  66.     for _, item := range slice {
  67.         if item == s {
  68.             continue
  69.         }
  70.         result = append(result, item)
  71.     }
  72.     return
  73. }