Today we are excited to announce the SignalFx integration for Cloud Run and Cloud Run on GKE. This integration provides end-to-end visibility into the performance of serverless workloads, Istio service mesh, and Kuberntes clusters – all from a unified SignalFx platform.

What is Cloud Run

Cloud Run is a serverless platform based on Knative, the Kubernetes-based open API and runtime environment for serverless. Google Cloud offers fully managed Cloud Run environment or as an add-on within Google Kubernetes Engine (GKE) cluster with Cloud Run on GKE. Knative can also be deployed on self-managed, cloud or on-premises clusters.

Kubernetes has emerged as a de-facto standard for container orchestration. 83% of respondents to the latest CNCF survey cited Kubernetes as their choice for container management. Kubernetes, however, has remained as the platform to orchestrate and manage containers, not code. DevOps teams are still responsible to do the heavy-lifting in how the containers are built, run, scaled (up or down), and sent traffic to. Knative and Cloud Run aim to shoulder some of these responsibilities.

Knative addresses the entire application lifecycle – packaging, deploying, serving traffic, scaling and enabling applications to produce or consume events:

Building:

Knative provides capabilities to build the application from source code (from repositories such as git) to deployable containers.

Serving:

Serves traffic to the Knative workloads by enforcing routing policies to shape traffic to multiple revisions of the serverless workload. Serving also automatically scales based on load, including scale-to-zero when there is no load.

Eventing:

Knative Eventing enables applications to produce or consume events. It receives events from pluggable event sources (e.g. GithHub, Kubernetes events, WebSockets, etc.), abstracts event sources so that Knative workloads interact with Knative events, and provides delivery via integrating with various pub/sub broker services.

Knative and Cloud Run provide a consistent, standard way for building, deploying, and managing serverless and event-driven applications.

Introducing SignalFx integration for Knative, Cloud Run and Cloud Run on GKE

SignalFx provides end-to-end visibility to the entire Knative stack – Kubernetes platform, Istio service mesh, and Knative workloads all via a unified, single-pane-of-glass:

  • The integration starts with Kubernetes monitoring leveraging open source SignalFx Smart Agent deployed on every Kubernetes node as a DaemonSet
  • Istio service mesh metrics and Knative workload traces are ingested by SignalFx Istio Mixer adopter
  • Knative metrics are seamlessly ingested via Prometheus exporters
  • Knative workloads leverage SignalFx open source function wrappers to create OpenTracing compliant spans for distributed tracing and transactional visibility

For fully managed Cloud Run environments, SignalFx integrates with Google Stackdriver APIs to get relevant metrics.

Pre-built dashboards for out-of-the-box, real-time visibility

SignalFx provides out of the box visibility into the performance of various revisions of Knative / Cloud Run serverless workloads.

Using the pre-built dashboards customers can quickly visualize the number of serverless workloads deployed, request volume per revision, request size and errors.

Knative Scaling

In Knative / Cloud Run environments each workload revision is automatically scaled to the number of container instances needed to handle all incoming requests.

When more instances are processing requests, more CPU and memory will be used, likely resulting in higher costs. Cloud Run provides a concurrency setting that specifies the maximum number of requests that can be sent at the same time to a given container instance to manage costs. SignalFx provides real-time visibility into observed and targeted concurrency as well as the resources such as CPU and memory allocations.

Comprehensive Kubernetes Monitoring

SignalFx’s Streaming Architecture provides real-time visibility into Kubernetes deployments. Advanced analytics enable our customers to quickly slice and dice by namespace, cluster, deployment or service labels to get relevant Kubernetes insights specific to Knative deployments.

Get Started with monitoring Knative and Google Cloud Run 

Knative and Cloud Run provide the flexibility to run serverless workloads on Google Cloud or self-managed Kubernetes cluster. SignalFx provides comprehensive monitoring for every layer of the Knative stack with out-of-the-box visibility, real-time monitoring and precise alerting on the performance of your serverless workloads.

Get started by signing up for a free trial of SignalFx or join our weekly Live Demo to see the platform in action.

 

 



About the authors

Amit Sharma

Amit Sharma is the Director of Product Marketing at SignalFx. He has over ten years of experience in software development, product management, and product marketing. Prior to joining SignalFx, Amit led product marketing at AppDynamics and Cisco. He did his MSCE from Arizona State University and an MBA from UC Berkeley Haas School of Business.

Ryan Powers

Ryan is a Product Marketing Director at SignalFx. Previous to SignalFx, Ryan worked at VMware within the IoT product group. Before VMware, Ryan worked as a Software Engineer at the NASA Johnson Space Center in the Technology & Innovation Group.

Enjoyed this blog post? Sign up for our blog updates