Release Lifecycle Management

The Release Lifecycle Management tools run pre/post-deployment tasks and checks for your existing cloud-native deployments to make them more robust. This tutorial introduces these tools.

This tutorial assumes you have already completed the Getting started with Keptn Observability exercise. Please ensure you’ve finished that before attempting this exercise.

Keptn Pre and Post Deployment Tasks

When Keptn is successfully monitoring your deployments, it can also run arbitrary tasks and SLO evaluations for you either pre-deployment or post-deployment as specified in the pod template specs of your Workloads (Deployments, StatefulSets, DaemonSets, and ReplicaSets).

Pre and post deployments can also run on a KeptnApp level. A KeptnApp groups multiple workloads into a single application. See annotations to KeptnApp

Prerequisites: Deploy webhook sink

During this exercise, you will configure Keptn to trigger a webhook before and after a deployment has completed successfully.

For demo purposes, a place is required to which those requests are sent. To implement this:

1. Install the open source webhook.site tool.

   This provides a place on your cluster to which web requests are sent and from which they can be viewed.

2. Execute the following commands to apply the web hook:

   Note: If you have your own endpoint, you can skip this step.

   kubectl apply -f https://raw.githubusercontent.com/webhooksite/webhook.site/master/kubernetes/namespace.yml
   kubectl apply -f https://raw.githubusercontent.com/webhooksite/webhook.site/master/kubernetes/redis.deployment.yml
   kubectl apply -f https://raw.githubusercontent.com/webhooksite/webhook.site/master/kubernetes/laravel-echo-server.deployment.yml
   kubectl apply -f https://raw.githubusercontent.com/webhooksite/webhook.site/master/kubernetes/webhook.deployment.yml
   kubectl apply -f https://raw.githubusercontent.com/webhooksite/webhook.site/master/kubernetes/service.yml
   

3. Wait until all pods are running in the webhook namespace then port-forward and view the webhook sink page:

   kubectl -n webhook wait --for=condition=Ready pods --all
   kubectl -n webhook port-forward svc/webhook 8084
   

4. Open a browser and go to http://localhost:8084

5. You should see a page like this with a unique URL (your ID will be different than the example).

   

Make a note of that unique URL.

Verify Webhook Sink

Open a new browser table and go to your unique URL. The page should remain blank, but when toggling back to http://localhost:8084, you should see a new entry.

Each request sent to that unique URL will be logged here.

Add a Post Deployment Task

Add a task which will trigger after a deployment.

Change UUID to whatever value you have. Apply this manifest:

---
apiVersion: lifecycle.keptn.sh/v1alpha3
kind: KeptnTaskDefinition
metadata:
  name: send-event
  namespace: keptndemo
spec:
  retries: 0
  timeout: 5s
  container:
    name: curlcontainer
    image: curlimages/curl:latest
    args: [
        '-X',
        'POST',
        'http://webhook.webhook.svc.cluster.local:8084/YOUR-UUID-HERE',
        '-H',
        'Content-Type: application/json',
        '-d',
        '{ "from": "keptn send-event" }'
    ] 

Verify it works

Verify that the KeptnTaskDefinition resource shown above actually works.

Trigger an on-demand task execution to verify that the job and pod are working correctly.

In the following steps we will have Keptn orchestrate this for us automatically.

Apply this manifest:

---
apiVersion: lifecycle.keptn.sh/v1alpha3
kind: KeptnTask
metadata:
  name: runsendevent1
  namespace: keptndemo
spec:
  taskDefinition: send-event
  context:
    appName: "my-test-app"
    appVersion: "1.0.0"
    objectType: ""
    taskType: ""
    workloadName: "my-test-workload"
    workloadVersion: "1.0.0"

If it works, kubectl -n keptndemo get jobs should show:

NAME                  COMPLETIONS   DURATION   AGE
runsendevent1-*****   1/1           6s         2m

kubectl -n keptndemo get pods will show the successfully executed pod.

The webhook sync should show this:

Incidentally, this is exactly how you can use Keptn with applications deployed outside of Kubernetes.

Note: If you want to trigger this task multiple times, you must change the value of the name field in the KeptnTask resource each time.

For example, change runsendevent1 to runsendevent2.

Ask Keptn to trigger task after Deployment

Annotate the demo application Deployment manifest to have Keptn automatically trigger the task after every deployment.

Recall the Deployment from the Observability Getting started guide.

Add a new label so the labels section looks like this:

...
labels:
    app.kubernetes.io/part-of: keptndemoapp
    app.kubernetes.io/name: nginx
    app.kubernetes.io/version: 0.0.2
    keptn.sh/post-deployment-tasks: "send-event"
...

Increase the version number to 0.0.2 and re-apply the manifest.

Here is a full version of the new YAML:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: keptndemo
  labels:
    app.kubernetes.io/name: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: nginx
  template:
    metadata:
      labels:
        app.kubernetes.io/part-of: keptndemoapp
        app.kubernetes.io/name: nginx
        app.kubernetes.io/version: 0.0.2
        keptn.sh/post-deployment-tasks: "send-event"
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Best Practice: Start with post deployment tasks. Pre-deployment tasks can potentially block deployments (see below).

What Happens Next?

1. The deployment is applied.
2. When the pods are running, Keptn automatically creates a KeptnTask resource for version 0.0.2 of this KeptnApp.
3. The KeptnTask creates a Kubernetes Job.
4. The Kubernetes Job creates a Kubernetes Pod.
5. The Pod runs curl and sends a new event to the event sink.

Pre-deployment Tasks

Keptn Tasks can also be executed pre-deployment (before the pods are scheduled). Do this by using the keptn.sh/pre-deployment-tasks label or annotation.

Note: If a pre-deployment task fails, the Pod remains in a Pending state.

Further Information

You can do much more with KeptnTask resources. See the pre and post deployment checks page and the Deployment tasks page to find out more.

What’s next?

Keptn can also run simple pre- and post-deployment SLO evaluations.

Continue the Keptn learning journey by adding evaluations. See the Evaluations for more information.