Deploying and Managing Operational Tooling (Prometheus and Grafana) via the Plural Marketplace

Your observability stack is critical for any Kubernetes environment. Tools like Prometheus and Grafana give you visibility into system health, helping you debug failures and optimize operations with concrete metrics and trends. However, deploying and managing these tools at scale can quickly drain resources.

Whether you're using Helm charts in Rancher or operators in OpenShift, you're stuck with manual processes that often lead to version drifts, inconsistent configurations, and a pile of YAML files to maintain over time.

In this article, you'll deploy a standard Prometheus and Grafana stack in minutes using the Plural integrated application marketplace, contrasting this one-click experience with the manual Helm chart management in Rancher and operator installations in OpenShift.

Understanding Why Observability Stack Management Is Still Painful

On paper, deploying your observability tools in Kubernetes is fairly straightforward; take a Helm chart, tweak some values for your environment, and you're good to go. However, this manual process doesn't scale well. You have more deployments to tweak across environments, and these deployments need to be interconnected. Each upgrade or configuration change can feel like a mini project.

With tools like Rancher, you get simpler deployments and management, but you still need to manually tweak templates, manage value overrides, and lifecycle coordination across your Kubernetes clusters. OpenShift's operator framework gives you more automation but comes with its own learning curve. You often find yourself managing custom resource definitions (CRDs) with limited customization options, making it hard to optimize observability for custom alert rules, external storage, or custom dashboards.

Adding to your management burden, observability tools constantly evolve with plugin updates, breaking changes in underlying exporters, and security patches. Each update becomes your problem to coordinate without disrupting operations. Teams commonly end up building internal tooling to manage what should be infrastructure concerns, spending time on maintenance instead of delivering value.

Introducing Plural: A Marketplace for Kubernetes Apps

If all that feels like too much, there's a better alternative: Plural.

Plural is an open source orchestrator with production-grade deployments of popular Kubernetes tools, including observability services like Prometheus and Grafana. Instead of wrangling Helm values or building deployment tooling from scratch, Plural gives you declarative GitOps workflows that deploy and maintain your stack in a predictable and repeatable way.

The Plural service catalog provides curated, preconfigured tools that are production-hardened with integrated monitoring, logging, and GitOps-ready workflows.

You get built-in support for your architecture, including storage options (PostgreSQL or object storage), secrets management, and direct integrations to your Kubernetes clusters. Whether you're running your own cloud instance (Amazon Elastic Kubernetes Service (Amazon EKS), Google Kubernetes Engine (GKE), or bare-metal Kubernetes) or using Plural cloud instances, Plural cuts through management complexity, security risks, and deployment overhead. The results speak for themselves: 95 percent drop in operational costs, 50 percent reduction in engineering time spent on maintenance, and over thirty times ROI within three years.

Deploying and Managing Operational Tooling via Plural

If that sounds too good to be true, let's use Plural to provision and manage a Kubernetes cluster at scale.

Before you begin, make sure you have the following prerequisites:

• Access to a Kubernetes cluster: Plural is compatible with your cloud (GKE, Amazon EKS, Azure Kubernetes Service (AKS)) and on-premise clusters. It can also be utilized for edge devices and local setups.
• The Plural CLI installed, with your account details authenticated: The Plural CLI is available across Linux, macOS, and Windows systems.
• A GitHub account: Plural is a GitOps-centric platform, so you need an account to deploy your assets declaratively.
• Helm, Terraform, and kubectl installed: These tools are utilized in Plural operations and are helpful when setting up your local Kubernetes environment.

Deploying Prometheus and Grafana with Plural

With your development environment setup and credentials to your cluster system (eg  GKE), you can start setting up Plural and deploying your observability stack.

Use the Plural quick command plural up to configure your Kubernetes environment and provision the necessary files and folders with Terraform:

With this command, a Kubernetes cluster is provisioned on your device or cloud system:

Plural also populates your repository with starter files that create components within your cluster and lay the foundation for more deployments:

Now, log onto the Plural platform and navigate to your cluster Console. There, you find an intuitive interface where you can manage all aspects of your cluster. For instance, you can see all the starter components that have been deployed and their progress:

This is a responsive view that changes as you add new components to your repository or tweak your repo assets.

On the Plural platform, navigate to the Self service catalog:

You see categories of deployments that are available to be added to your repository via pull requests (PRs). Because you're setting up an observability stack, let's deploy an ingress and ExternalDNS (under the network category) through the Plural platform. Clicking the deployment offerings takes you through a wizard where you can add necessary configurations for your deployment:

Completing the wizard triggers a PR in your repository. Once you merge it, Plural begins provisioning the resources you deployed according to the instructions in your repository. Follow this process for both the ingress and ExternalDNS. This sets up an integrated load balancer and DNS deployment, giving you accessible domains for your Grafana and Prometheus stack:

The same process works for deploying Grafana and Prometheus. Go to the devops category under the Self Service catalog:

Let's start with deploying Prometheus:

Initially, set the cluster you want the Prometheus instance to monitor; then set the host domain (fully qualified domain name) for your Prometheus configuration. Use the DNS name from the ExternalDNS you just set:

The wizard sets up the repository details needed to make the Prometheus PR, such as your repository slug and branch name. Repeat the same process with the Grafana wizard:

With these PRs, your cluster is provisioned with all the required dependencies for a successful Prometheus and Grafana deployment. Scraping targets are set, ingress paths to both your Prometheus and Grafana deployments are made, and you get authentication and storage. This ensures your new components are production-ready to integrate with any existing monitoring and alerting infrastructure you have available.

Note: Deploying with plural up --cloud automatically provisions this monitoring stack with preconfigured networking, so you get observability out of the box. 

Comparing Plural vs. Rancher vs. OpenShift

Most Kubernetes enterprise platforms promise efficiency and easier management, but that's not always the case, especially at scale. Let's see how Rancher, OpenShift, and Plural stack up when deploying and managing infrastructure across multiple clusters and services.

Rancher and Helm

Using Helm and Rancher for your Kubernetes infrastructure can help you quickly deploy clusters and applications across multiple environments. Helm charts give you a templated experience for reproducible results. However, this combination is largely do-it-yourself. You're responsible for manually managing your Helm charts, ensuring version compatibilities, configuration values, and deployed services are in sync across your infrastructure. It works until it doesn't, with minor chart changes breaking your continuous integration, continuous delivery (CI/CD) automation and no default GitOps model to ease maintenance and ensure reproducibility across your Kubernetes environments.

OpenShift Operators

OpenShift operators were created to reduce the amount of manual processes needed in your Kubernetes environments. The operator framework gives you automation capabilities for the creation, configuration, and management of your Kubernetes applications, allowing you to quickly and efficiently install, update, and monitor your Kubernetes environments. However, this comes with trade-offs, such as vendor lock-in. The operator feature is tightly integrated within the OpenShift ecosystem. The operator's scope can also limit the customizations you can have within your Kubernetes environment.

Plural

Plural is GitOps-first out of the box. It delivers production-ready clusters and services with security best practices factored in. With the marketplace model, you get fleshed-out services that you can attach to your Kubernetes environments quickly, reducing your time to deploy and ensuring standardized Kubernetes environments across your organization. With Plural, you get infrastructure stacks (observability, data engineering, devops, etc.) in an integrated platform, maintained via declarative code with your repository. Plural is built around open source and cloud-native tooling, ensuring you can scale without any vendor friction or price gouging.

Conclusion

Observability can make or break your software operations, especially when you're running Kubernetes infrastructure. One minor change can lead to a cascading failure that keeps repeating until you step in to fix it.

In this article, you looked at how to deploy observability tools using Plural and saw just how much easier it is to maintain your infrastructure at scale.

Plural is an open source enterprise platform for Kubernetes infrastructure. It offers a modern, GitOps-integrated process that can ease your engineering woes with Kubernetes infrastructure. With its marketplace of production-ready software, you can deploy faster and keep things consistent across your clusters.

Ready to see what Plural can do? Check out our demos and grab a thirty-day trial today. Get started with your first Stack and see the difference for yourself.