 Thank you, Kavisha. Hi everybody. Kubernetes is a unique beast which consists of a multi-layered web of resources and services. Achieving observability is a daunting task, even for the best and brightest among us. This presentation will give you a high-level overview and some implementation approaches to achieve observability in Kubernetes. So let's first look into what is observability. To understand observability, the observability as well as monitoring is used interchangeably. Although there is a subtle difference between them, while observability actually talks about the ability of internal to assess the internal system state based on the data it provides monitoring deals with the collection and analysis of data pulled from the infrastructure. So observability will help you to gain deeper insight to health and status of different application and resources across infrastructure. This help to proactively detect abnormalities, analyze and analyze issues and resolve them. So the three pillars of observability are logs, metrics and traces. I will discuss that later. Let's move into the monitoring. So the foundation of observability is monitoring which involves pulling and analyzing data from your infrastructure. So it started with SNMP, the simple network protocol since back in 1988, where we used to get information about the network, say for example like every 10 seconds or 30 seconds. Now there are much more newer protocols available such as the OpenConfig, GPRPC network management interface protocol that can provide much more real-time information. Okay, telemetry and APM, application performance monitoring also type of monitoring. It's a bit advanced type of monitoring, especially telemetry focuses on collecting information from distributed system while the APM is focused on more application level. Let's look at what are the different types of levels of Kubernetes monitoring. So there are two types of Kubernetes monitoring available, two levels of Kubernetes monitoring available. One is the cluster level which focuses on the node information, the pod information and the cluster resource level utilization. And the pod level focuses more on the container level, especially on the application as well as the container level information. Okay, let's see why this monitoring is so important. So in cloud native or microservices apps are very complex and you got a lot of moving parts. When an issue occurs, it's very difficult to pinpoint and identify the issue. So monitoring is important for reliability as well as troubleshooting. Secondly, knowing your infrastructure will help you to optimize your hardware. Thirdly, public cloud, if you are using a public cloud infrastructure, you will play the cost will play a major role. So having insights into the Kubernetes environment will help you to reduce the cloud spending. Some instances you may be using Kubernetes in a multi-tenant or you are providing it to your internal customers. So in that case, having insights will help you to charge back or show back to your internal customers. Finally, observability is actually a cornerstone for your security strategy. So you will be able to identify any malicious ingress and egress traffic or any unwanted pods and services that is running in your environment. All right, so there are some challenges that comes through with this observability as well. So one is the amount of data. So you get data from your nodes, you get data from your pods, the flow data, so much of data that you have to manage. And secondly, you also have difficulty because it's a distributed system. You have so many moving parts. Getting this full picture also is a bit of a challenge that you will face as well. Finally, because Kubernetes is a declarative in nature, you can actually define how you want the pods to run and create it. So that actually might give a false positive, especially when it comes to performance. All right, so the best practices. When it comes to best practices, firstly, the granular resources like the CPU, memory, load, those things are very important but can be very complex and convoluted. So to easily identify the microservice issue, the API metrics are the main part. So what you can use is like the request rate, the call error, latency, that will help you to quickly identify the degrading components in your microservice. Another aspect is the high disk usage. So that's a very common issue that you will come across. So there's no straight away magical solution. Just make sure when it hits about 70 to 80% of your storage, notify it, take some actions. So even though the end user experience is not built into Kubernetes, it's also most very important and a best practice to understand and monitor end users experience and address issues so that the end user can provide you positive feedback as well. And if you're running in public cloud, you have to make sure you adhere to the best practices of the cloud in terms of access and identity, cost, network performance, etc. All right, let's get back to the three pillars of observability. As I mentioned, it's very important when you create and implement your observability for Kubernetes. So for the first pillar is logs. The log, basically a log is a representation of a discrete event. In most cases, it describes what will happen with your service. Log will produce in multiple ways in Kubernetes, especially. So you will have cluster related log, you will have pod related logs, you will have application related logs, network and all that. So you have to have a mechanism to collect all these logs and push it to a central analytic server. Second pillar is a matrix. So matrix is a numerical representation of data measured over a period of time. Say for example, how many 200 requests did I get in last 30 seconds? And the last one is the tracing. Tracing is a mechanism that will help you to track end to end, end to end and identify. So your whole transaction you can manage end to, you can track it end to end and identify troubleshoot the issue. All right, so let's look at a sample of purpose built observability platform for Kubernetes. So this one, we have three layers. So the first layer is the telemetry collection. So this is where you collect various flows and different data. And the second layer will give you the analytic and visibility, where the different analysis can be performed. So you could even put some machine learning, machine learn anomaly detection, and finally on the security and troubleshooting layer. Tools for implementing Kubernetes observability includes first, at the bare minimum, you can have Kubernetes dashboard. Kubernetes dashboard will you give you a bare minimum information about the deployment of application into pods, application running in pods, issue this application running in the pods resource utilization. So that this can be used as a bare minimum observability tool. Secondly, Prometheus is a collection and storage of observability data. So it provides you with a multi-dimensional data model with time series format. And it provides also provides a query language called from QL to analyze. Further, several modes can be available with different type of graphs, as well as dashboards. Prometheus can be integrated with many things like the Grafana and all that as well. So on Grafana side, it'll give you a visualizing observability data. So it Grafana gives you a data-rich dashboard and using information sources like the Prometheus, like I just mentioned. And it also provides you built-in dashboards for Kubernetes, like actually four dashboards. One is the cluster dashboard, node dashboard, port then container dashboard, as well as the deployment dashboard. Further, Grafana has a few more plugins that, for example, Grafana low key also can give you a similar observability to your Kubernetes environment. And Yeager is a distributed system tracking tracing system for Kubernetes. They actually came from Uber's engineering team it gives you end to end tracing solution. So it helps you to monitor troubleshoot transactions in a complex distributed system and help you to identify the root causes as well as optimize performance and latencies and monitor distributed transactions as well. Further, finally the elastic stack. Elastic stack includes elastic search, which is the analytical engine and logstash and beats captures and sends the log to elastic search and Kibana, you can use it to get the dashboards. You can also drop logstash and beats and combine it with something like a fluent. Then you get a EFK stack, which also will give you a stack for you to implement your observability in Kubernetes. With that, because of the scale of modern infrastructure and the dynamic neighbor nature of Kubernetes, observability is a critical component. And the three pillars I mentioned that is the log metrics phrasing will not only help you to increase the observability, but also help you to gain insights to your infrastructure, regardless of your technology set that you use. The tools mentioned here are the de facto standard tools used by the cloud native community and implementing them will help you to gain observability in your Kubernetes environment. Thank you and have a pleasant day.