OpenShift Developer Console Overview

Learn how to use the OpenShift Developer Console to deploy, manage, monitor, and troubleshoot Spring Boot applications with real-world enterprise examples and architecture diagrams.

Introduction

Managing containerized applications using only command-line tools can become challenging as applications grow. OpenShift provides a Developer Console, a modern web-based interface that allows developers to deploy, monitor, troubleshoot, and manage applications without remembering dozens of CLI commands.

The Developer Console is designed for application developers, while the Administrator Console focuses on cluster administration.

In this article, you'll learn how to navigate the OpenShift Developer Console and understand the most important features you'll use every day.

Learning Objectives

By the end of this article, you will understand:

What is the OpenShift Developer Console?
Developer vs Administrator Perspective
Dashboard overview
Topology View
Project navigation
Workloads
Builds
Pipelines
Monitoring
Logs
Terminal
Real-world development workflow

What is the OpenShift Developer Console?

The Developer Console is a web-based interface that simplifies application development on OpenShift.

Instead of executing multiple CLI commands, developers can:

Deploy applications
Create Projects
View Pods
Monitor deployments
Access application logs
Open Pod terminals
Trigger builds
Configure routes
View application topology

Think of it as a graphical interface for managing cloud-native applications.

Developer Console Architecture

flowchart TD
    DEV["Developer"]

    BROWSER["Browser"]

    CONSOLE["OpenShift Developer Console"]

    API["OpenShift API Server"]

    subgraph OCP["OpenShift Cluster"]
        DEPLOY["Deployment"]
        PODS["Pods"]
        SERVICE["Service"]
    end

    DEV --> BROWSER
    BROWSER --> CONSOLE
    CONSOLE --> API
    API --> DEPLOY
    DEPLOY --> PODS
    PODS --> SERVICE

The console communicates with the OpenShift API Server to perform all operations.

Developer vs Administrator Perspective

OpenShift provides two user perspectives.

Developer	Administrator
Build Applications	Manage Cluster
Deploy Workloads	Configure Nodes
View Logs	Configure Networking
Create Routes	Manage Storage
Monitor Applications	Manage Security
Pipelines	Cluster Configuration

Developers spend most of their time in the Developer Perspective.

Developer Console Home

The home page provides quick access to:

Projects
Topology
Add Application
Pipelines
Builds
Monitoring
Search
Notifications

flowchart TD
    CONSOLE["Developer Console"]
    DASH["Dashboard"]

    TOPO["Topology"]
    ADD["Add Application"]
    PIPE["Pipelines"]
    BUILD["Builds"]
    MON["Monitoring"]
    SEARCH["Search"]
    NOTIFY["Notifications"]
    PROJ["Projects"]

    CONSOLE --> DASH

    DASH --> PROJ
    DASH --> TOPO
    DASH --> ADD
    DASH --> PIPE
    DASH --> BUILD
    DASH --> MON
    DASH --> SEARCH
    DASH --> NOTIFY

OpenShift Navigation

The left navigation panel contains the most frequently used sections.

Developer Perspective

├── Topology
├── Observe
├── Search
├── Add
├── Helm
├── Pipelines
├── Builds
├── Project
├── Administrator

Each section provides a different view of your application.

Project Selector

The Project selector allows developers to switch between environments.

Example:

payment-dev

payment-qa

payment-uat

payment-prod

Always verify the selected Project before deploying changes.

Topology View

Topology is one of the most useful features of OpenShift.

It visually displays:

Applications
Pods
Services
Routes
Build Configurations

flowchart TD

SpringBootApp

--> Deployment

Deployment --> Pod1

Deployment --> Pod2

Pod1 --> Service

Pod2 --> Service

Service --> Route

Route --> Browser

Developers can immediately understand application relationships.

Add Page

The Add page allows developers to deploy applications.

Available options include:

Import from Git
Container Image
YAML
Helm Chart
Developer Catalog
Database Templates

flowchart LR
    DEV["Developer"]
    GIT["Git Repository"]
    BUILD["BuildConfig / Pipeline"]
    IMAGE["Image Registry"]
    DEPLOY["Deployment"]
    POD["Pods"]
    SERVICE["Service"]
    ROUTE["Route"]
    USER["End User"]

    DEV --> GIT
    GIT --> BUILD
    BUILD --> IMAGE
    IMAGE --> DEPLOY
    DEPLOY --> POD
    POD --> SERVICE
    SERVICE --> ROUTE
    ROUTE --> USER

Import from Git

One of the most commonly used deployment methods.

Steps:

Enter Git Repository URL.
OpenShift detects the application type.
Build starts automatically.
Image is created.
Application is deployed.

No manual Docker build is required.

Topology Example

Imagine a banking application.

flowchart TD
    CLIENT["Customer"]

    GW["API Gateway"]

    PAY["Payment Service"]
    ACC["Account Service"]
    CUST["Customer Service"]

    DB[("Oracle Database")]

    CLIENT --> GW

    GW --> PAY
    GW --> ACC
    GW --> CUST

    PAY --> DB
    ACC --> DB
    CUST --> DB

The Topology View makes service dependencies easy to visualize.

Workloads

The Workloads section displays:

Deployments
Pods
ReplicaSets
Jobs
CronJobs

Developers can:

Scale applications
Restart Pods
View events
Check status

Pod Details

Selecting a Pod displays:

Pod Status
Events
Logs
Terminal
YAML
Metrics

Developers can troubleshoot applications directly from the console.

Viewing Logs

Logs help diagnose application issues.

Example:

INFO Spring Boot Started

INFO Connected to Database

INFO Kafka Consumer Running

ERROR Connection Timeout

Developers no longer need to SSH into servers.

Terminal Access

Each running Pod provides a terminal.

Example tasks:

Verify files
Test connectivity
Execute Linux commands
Check environment variables

ls

pwd

env

java -version

Monitoring

The Observe section displays:

CPU Usage
Memory Usage
Network Traffic
Pod Status
Restart Count

flowchart TD

Metrics

--> CPU

Metrics

--> Memory

Metrics

--> Network

Metrics

--> Storage

Monitoring helps identify performance bottlenecks.

Pipelines

OpenShift Pipelines automate application deployment.

flowchart LR

Git

--> Build

--> Test

--> Image

--> Deploy

--> Production

Developers can monitor every pipeline stage from the console.

Search Feature

The Search page quickly locates resources.

Example:

Search:

payment

Results:

Pod
Service
Deployment
Route
ConfigMap

This saves significant troubleshooting time.

Observe Dashboard

The Observe section provides:

Application Metrics
Pod Health
Cluster Events
Resource Consumption

Developers can determine whether performance issues are caused by:

CPU
Memory
Network
Storage

Real-Time Banking Example

Suppose the Payment Service experiences high traffic.

Developer Workflow:

flowchart LR
    ALERT["Alert"]
    CONSOLE["Open Developer Console"]
    TOPOLOGY["Topology"]
    PAYMENT["Payment Service"]
    LOGS["Pod Logs"]
    METRICS["Metrics"]
    SCALE["Scale Application"]

    ALERT --> CONSOLE
    CONSOLE --> TOPOLOGY
    TOPOLOGY --> PAYMENT
    PAYMENT --> LOGS
    LOGS --> METRICS
    METRICS --> SCALE

Everything can be managed from the Developer Console without logging into cluster nodes.

Spring Boot Deployment Workflow

flowchart LR
    DEV["Developer"]
    GIT["Git Repository"]
    PIPE["OpenShift Pipeline (Tekton/Jenkins)"]
    REG["Image Registry"]

    subgraph OCP["OpenShift Cluster"]
        DEPLOY["Deployment"]
        PODS["Spring Boot Pods"]
        SERVICE["Service"]
        ROUTE["Route"]
    end

    USER["Browser"]

    DEV --> GIT
    GIT --> PIPE
    PIPE --> REG
    REG --> DEPLOY
    DEPLOY --> PODS
    PODS --> SERVICE
    SERVICE --> ROUTE
    ROUTE --> USER

The console displays every stage visually.

Best Practices

Organize applications using Projects.
Use meaningful application names.
Regularly monitor Pod metrics.
Review Pod logs before restarting applications.
Verify deployments using the Topology View.
Use Pipelines for automated deployments.
Avoid manual changes in Production.
Monitor application health after every deployment.

Common Mistakes

Deploying into the wrong Project.
Ignoring Pod restart counts.
Viewing outdated logs.
Forgetting to expose a Route.
Not checking Events when a Pod fails.
Using the Administrator Perspective for normal development tasks.

Advantages of the Developer Console

Easy to learn
Visual application topology
Simplified deployments
Integrated monitoring
Built-in logging
Terminal access
Pipeline management
Faster troubleshooting
Better developer productivity

Summary

The OpenShift Developer Console simplifies cloud-native application development by providing a powerful web interface for deploying, managing, monitoring, and troubleshooting applications.

Key takeaways:

The Developer Perspective is designed for application developers.
The Topology View provides a visual representation of deployed applications.
Developers can deploy applications directly from Git repositories.
Logs, metrics, and terminals are accessible from the browser.
Pipelines automate deployments and improve release quality.
The console significantly improves developer productivity in enterprise environments.

Interview Questions

What is the OpenShift Developer Console?
What is the difference between Developer and Administrator perspectives?
What is the Topology View?
How do you deploy an application from Git?
Where can you view Pod logs?
How do you access a Pod terminal?
What metrics are available in the Observe section?
What is the purpose of OpenShift Pipelines?
How does the Search page help developers?
Why is the Developer Console preferred over CLI for many day-to-day tasks?

Loading likes...

Comments

Share a question, correction, or practical insight about this article.

Loading approved comments...