Navigating Kubernetes: Forecastle's Unified Dashboard for Application Management

Introduction

In the vast ocean of Kubernetes and OpenShift, managing multiple applications across different namespaces can feel like navigating without a compass. For us, as developers and system administrators, the challenge isn’t just deploying applications but also efficiently accessing and managing them. This is where Forecastle, developed by Stakater, steps in as the lighthouse guiding the way.

The Problem

Managing and accessing a multitude of applications on Kubernetes and OpenShift often involves:

1. Lack of Visibility: We face difficulties in tracking applications deployed across multiple namespaces and clusters.

2. Operational Inefficiencies: Time-consuming configurations and potential errors come up when manually managing access to essential tools like CI/CD pipelines, monitoring systems, and more.

3. Collaboration Barriers: It’s challenging to provide a unified tool access point for diverse teams working on different aspects of the infrastructure.

These issues hinder productivity and can lead to significant delays in response times during critical operations.

The Solution: Forecastle

Forecastle emerges as a solution designed to conquer these challenges. It’s a dynamic dashboard that not only enhances visibility but also simplifies managing applications deployed on clusters. Here’s how Forecastle addresses the core issues:

1. Unified Control Panel: It aggregates all applications, whether they are running on Kubernetes or externally, into a single, searchable dashboard.

2. Dynamic Discovery: By using annotations on Ingresses, Forecastle automatically discovers and lists applications, making them instantly accessible.

3. Customizable Interface: We can customize the dashboard to reflect our operational needs and aesthetic preferences, enhancing both functionality and user experience.

Learn more about how Forecastle serves as an automated service dashboard in this detailed blog post.

How Forecastle Works

Forecastle integrates seamlessly with Kubernetes/OpenShift. Here’s a brief look at its operational mechanics:

1. Annotations: By adding specific annotations to ingresses, applications are automatically discovered and made visible on the Forecastle dashboard.

2. ForecastleApp CRD: This custom resource definition (CRD) allows for the dynamic addition of applications, further extending Forecastle’s capabilities beyond native apps.

Step-by-Step Setup Guide

Setting up Forecastle is straightforward. Here’s a simplified guide to get started:

1. Deployment via Helm:

• Run the command: helm install forecastle stakater/forecastle

• Customize the deployment by modifying the values.yaml file to suit your needs.

  
  

2. Manual Kubernetes Manifests:

• Apply the Forecastle deployment manifest using: kubectl apply -f https://raw.githubusercontent.com/stakater/Forecastle/master/deployments/kubernetes/forecastle.yaml

3. Verify Installation:

• Access the Forecastle dashboard through the provided URL to view all registered applications.

Real-World Application Example

Let’s proceed with a hands-on demonstration of how to use Forecastle.

Pre-requisites

1. Forecastle installed

2. Ingress controller installed (for this demo, we will use nginx ingress controller)

For the demo, we will use Goldpinger as an example application.

Step-by-Step Instructions to Deploy Goldpinger and View It on Forecastle Dashboard

Step 1: Create a Namespace

• Begin by creating a dedicated namespace for Goldpinger:

kubectl create namespace goldpinger-demo

Step 2: Deploy Goldpinger

• Deploy Goldpinger using the Helm chart provided by the project:

helm repo add goldpinger https://bloomberg.github.io/goldpinger 
helm install goldpinger goldpinger/goldpinger --namespace goldpinger-demo

Step 3: Create a Service

• Ensure the Helm chart has set up a service to expose Goldpinger. Check the service:

kubectl get services -n goldpinger-demo

Step 4: Create an Ingress

• If external access is required and not set up by the Helm chart, create an ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  annotations:
	forecastle.stakater.com/expose: "true"
  name: goldpinger
  namespace: goldpinger-demo
spec:
  ingressClassName: nginx
  rules:
  - http:
  	paths:
  	- backend:
      	service:
        	name: goldpinger
        	port:
          	number: 8081
    	path: /
    	pathType: Prefix

• Apply the ingress

kubectl apply -f goldpinger-ingress.yaml

Step 5: Access the Forecastle Dashboard

• Once the ingress is annotated, open your Forecastle dashboard. We should see the Goldpinger application listed. Click on it to access the interactive map of our cluster's nodes. Here is a screenshot from the Goldpinger Application.
  

Conclusion

Forecastle isn’t just another tool; it’s a strategic solution designed to enhance the way teams interact with Kubernetes environments. By simplifying the complexities of application management, Forecastle allows us to focus more on innovation and less on navigation. To ensure your applications are always up and running, consider pairing it with Ingress Monitor Controller for robust monitoring and alerting.

Get Involved

Explore Forecastle further on Stakater’s GitHub and consider contributing to its development. Join the community to help enhance this pivotal tool for Kubernetes and OpenShift application management.

References

1. https://github.com/stakater/Forecastle
   

2. https://playbook.stakater.com/content/tools/global/forecastle/developer-documentation.html
   

3. https://playbook.stakater.com/content/processes/deployment/forecastle.html

4. https://www.stakater.com/