Effortless observability for Django applications

Observability is critical for web operations to ensure that the application is working as expected and to identify any potential issues. However, setting up observability has traditionally been challenging because it can take hours to set up all the infrastructure, instrument your code and enable observability in production. But now there is a better way using native support for Django in Charmcraft and Rockcraft which has observability built in and ready to go!

In this post, we will start with a Django application built using the native support for Django in Rockcraft and Charmcraft

and deployed with Juju, and add observability to it using just a few commands. This shows a key benefit of bringing the Juju ecosystem (which includes most of the plumbing you’d expect from a modern cloud, like observability, databases, ingressing and so on) to a web application using charms as we will be able to set up observability in a matter of minutes rather than hours. Rockcraft and Charmcraft also natively support Flask, FastAPI and Go and the following instructions will work similarly for those as well.

We have set up a Django application by following the Write your first Kubernetes charm for a Django app tutorial, completing it up to finishing The development cycle section. By this stage, the Django app should be deployed, integrated with PostgreSQL and the Nginx ingress integrator, and should look something like this:

$ juju status --relations

Model               Controller      Cloud/Region        Version  SLA          Timestamp
django-hello-world  dev-controller  microk8s/localhost  3.6.3    unsupported  00:52:54+11:00

App                       Version  Status  Scale  Charm                     Channel        Rev  Address         Exposed  Message
django-hello-world                 active      1  django-hello-world                         1  10.152.183.175  no       
nginx-ingress-integrator  24.2.0   active      1  nginx-ingress-integrator  latest/stable  130  10.152.183.214  no       Ingress IP(s): 127.0.0.1
postgresql-k8s            14.15    active      1  postgresql-k8s            14/stable      495  10.152.183.83   no       

Unit                         Workload  Agent  Address      Ports  Message
django-hello-world/0*        active    idle   10.1.157.79         
nginx-ingress-integrator/0*  active    idle   10.1.157.78         Ingress IP(s): 127.0.0.1
postgresql-k8s/0*            active    idle   10.1.157.77         Primary

Integration provider                  Requirer                              Interface          Type     Message
django-hello-world:secret-storage     django-hello-world:secret-storage     secret-storage     peer     
nginx-ingress-integrator:ingress      django-hello-world:ingress            ingress            regular  
nginx-ingress-integrator:nginx-peers  nginx-ingress-integrator:nginx-peers  nginx-instance     peer     
postgresql-k8s:database               django-hello-world:postgresql         postgresql_client  regular  
postgresql-k8s:database-peers         postgresql-k8s:database-peers         postgresql_peers   peer     
postgresql-k8s:restart                postgresql-k8s:restart                rolling_op         peer     
postgresql-k8s:upgrade                postgresql-k8s:upgrade                upgrade            peer

At this point, if you send a request using curl, it should return Hello, world!

$ curl http://django-hello-world 
    --resolve django-hello-world:80:127.0.0.1 
Hello, world!

The next step is to deploy observability and integrate it with your Django app. For that, we need to enable a load balancer on Microk8s which is required for Traefik which will serve as ingress for the Canonical observability stack:

$ IPADDR=$(ip -4 -j route get 2.2.2.2 | jq -r '.[] | .prefsrc')
$ sudo microk8s enable metallb:$IPADDR-$IPADDR
$ microk8s status --wait-ready

Now we can deploy the Canonical Observability Stack which will deploy Grafana, Loki, Prometheus and Alertmanager as well as a catalogue to access all of the services and Traefik as an ingress:

$ juju deploy cos-lite --trust
$ juju integrate django-hello-world grafana
$ juju integrate django-hello-world prometheus
$ juju integrate django-hello-world loki

We have just tasked Juju with quite a bit so let’s give it a few minutes to complete. Meanwhile, we can monitor the progress:

$ juju status --watch 2s

Once everything is in active and idle, let’s take a look at the dashboards that have been created. Run the following command to retrieve the observability endpoints:

$ juju show-unit catalogue/0 | grep url
$ juju run grafana/leader get-admin-password

This will display a few URLs along with the default admin password. The one we are interested in has the grafana postfix and should look something like http://10.18.66.154/django-hello-world-grafana (your IP address will vary). To access the dashboards overview append the /dashboards postfix, then click General and select the Django Operator dashboard. You should see something like this:

Since we haven’t made any requests yet, the dashboard is currently reporting no activity. Let’s send the following curl command a few times to generate traffic:

$ curl http://django-hello-world --resolve django-hello-world:80:127.0.0.1 

Over the next few minutes, the data will update and should look something like this:

So far, we have successfully deployed our app and the observability stack – getting dashboards without having to define them ourselves! We can also access the application logs. To view them, select  django-hello-world from the dropdown menu next to the Juju application filter at the top of the page:

When you scroll down, you will see the logs of the application:

And that’s a wrap! We created a Django application and integrated it with observability. We explored the default dashboard giving us insights into how the application is being used, and also accessed the application logs. With a few commands we added a full suite of observability tools to our Django app without needing to manually handle the deployment and configuration of each of the apps. 

If you want to learn more about creating OCI images and charms for your Django apps, you can follow the Write your first Kubernetes charm for a Django app tutorial and take advantage of the complete Juju ecosystem. Feel free to reach out on our community matrix channel if you have any questions or would like to get in touch!