How do you monitor the performance of an application component that is not always on and has no visible infrastructure behind it but is still a key part of your overall application and affects your SLOs? Server that is not a server? OpsCruise provides native integration with serverless services and includes it in its end-to-end proactive and actionable observability.
Monitoring Edge Clouds without the Added Performance Overhead
The Rise of Serverless
Serverless computing, or more accurately “Function as a Service (FaaS)” is gaining more adoption given its attraction to developers who would prefer to focus on writing application code and not the required infrastructure. The pay-as-you-go method cuts costs drastically and makes it possible for startups to create and deploy software for a fraction of the cost. All major cloud vendors, AWS, Azure, and Google, as well Oracle and IBM now offer FaaS, since AWS Lambda introduction in 2015..Gartner estimates that between 2020 and 2025, 20% of organizations globally will migrate to serverless computing.
Serverless Poses Observability Challenges
Serverless is a misnomer. Your function is running on a server and related infrastructure managed by the cloud vendor, but neither developer nor SRE has visibility to it. This causes multiple challenges in observability and the required management and control which you get from running on infrastructure you can manage.
First, while you can push your code easily to your cloud provider after testing locally on your own machine, you have very limited visibility into how it will work in production. The process is incredibly tedious as you may have to iterate to get the desired performance and scalability addings overhead and costs. Second, every cloud vendor uses different configuration, e.g., setting memory limits and CPU, different orchestration, and exposes different metrics. Third, how does one know if your function is behaving as expected if you don't have visibility into its underpinnings. Fourth, since instrumentation of the function may be proprietary to the cloud vendor, understanding whether it is the cause of application performance becomes harder.
See It All with Real-time Application and Service Maps
While serverless components pose challenges to traditional monitoring vendors, OpsCruise leverages its automated discovery and real-time application map creation approach as it does with all microservices, whether Kubernetes, SaaS, or serverless. Building on and extending its real-time Flow Tracing approach, OpsCruise can recognize the presence of an “on” serverless component with which any microservice interacts. Overlaying with metrics exposed by the cloud vendor, it can build the real-time application map.
Thereby, OpsCruise immediately identifies the serverless component and treats it as a first class citizen of the Kubernetes estate, including showing traffic flows in and out as well as performance. As with other microservices, all key serverless metrics, as provided by the cloud vendor, can now be cohesively tied into the application map including specific ones on events, logs, execution performance, concurrency, memory alerts, etc.
ML-Driven Predictive Anomaly Detection
Routine monitoring of metrics provided by the cloud vendor is all well and good, but how do you know if your cloud vendor is performing as expected on your function calls? OpsCruise’s predictive behavior model used for Kubernetes services can be extended to serverless components as well.
Treating serverless as custom microservice whose metrics and configurations are specific to the vendor, behavior models for the component can provide clues when the cloud vendor is behaving correctly, This enables predictive anomaly detection across your application for any type of microservice, ones with infrastructure or without.
Automated Causal Analysis
With its understanding of application structure and dependencies, real-time monitoring of performance using Flow Analytics, and predictive anomaly detection, OpsCruise’s automated causal analysis process extends to serverless microservices as well. For example, latency SLO breaches caused by slow execution of a serverless component will be identified. Additionally, if the serverless component is the bottleneck, associated and relevant logs and events can be surfaced to indicate why the function performance has degraded.
All your functions in one place
Aggregate critical serverless metrics in one place for a birds-eye view. Optimize serverless function performance by filtering to functions that are generating errors, high latency, or cold starts. Alert on memory, timeout, and allocated concurrency metrics to avoid poor end user experiences. Identify high-level function issues, then pivot to invocation traces and logs with one click.
End-to-end monitoring for serverless functions
Now you can simplify serverless function incident diagnosis. Isolate an individual customer request and drill down to the associated logs and metrics for the full story. Alert your on-call teams with ML-based anomaly, outlier, and forecasting monitors. Search and filter using tags like service, customer, or error code to troubleshoot ephemeral functions.
Native integrations to serverless services
Access logs, metrics and tracing data all in one place without any code instrumentation and no setup changes. OpsCruise is the least intrusive monitoring platform for serverless infrastructures.