Important clarification: Azure Red Hat OpenShift (ARO) is not mandatory for .NET Core/.NET applications. It is an enterprise container platform that can be an excellent choice when an organization wants OpenShift/Kubernetes capabilities with Azure-managed infrastructure. Microsoft describes ARO as a fully managed OpenShift service jointly operated and supported by Microsoft and Red Hat. (Microsoft Learn)
1. What is Azure Red Hat OpenShift?
Azure Red Hat OpenShift (ARO) is Microsoft's managed Red Hat OpenShift service running on Azure.
In simple terms:
.NET Application
↓
Docker Container
↓
OpenShift
↓
Azure Red Hat OpenShift
↓
Microsoft AzureOpenShift extends Kubernetes with additional enterprise capabilities and developer/operator tooling. ARO gives you those OpenShift capabilities without requiring your team to manually operate the underlying OpenShift control plane and infrastructure. Microsoft and Red Hat jointly engineer, operate, and support the service. (Microsoft Learn)
ARO clusters are deployed into your Azure subscription, while Microsoft and Red Hat handle major platform-management responsibilities such as patching and monitoring of the managed cluster components. (Microsoft Learn)
2. Why do we need OpenShift?
Imagine an organization has 50 microservices:
API Gateway
|
+---------------+---------------+
| | |
Order Service Payment Service Customer Service
| | |
SQL DB SQL DB Redis
|
Notification
ServiceEach service may have:
Different deployments
Different versions
Different resource requirements
Multiple replicas
Health checks
Networking requirements
Secrets
Configuration
Logging
Monitoring
Autoscaling
Managing all of this manually becomes difficult.
A container orchestration platform can manage these workloads.
OpenShift provides Kubernetes-based orchestration plus additional platform capabilities. ARO packages this as a managed Azure service. (Microsoft Learn)
3. Is Azure OpenShift mandatory for .NET Core?
❌ No.
This is one of the most important points.
A .NET application can run on:
IIS
Azure App Service
Azure Container Apps
Azure Kubernetes Service
Azure Red Hat OpenShift
Windows Services
Linux
Docker
Virtual Machines
On-premises serversFor example:
ASP.NET Core Web API
|
+----> IIS
|
+----> Azure App Service
|
+----> Docker
|
+----> AKS
|
+----> AROSo .NET does not require OpenShift.
The decision depends on your organization's architecture, operational requirements, existing platform standards, compliance requirements, and team expertise.
4. Why would an enterprise choose ARO?
ARO becomes particularly interesting when an organization wants:
1. Kubernetes
OpenShift is built on Kubernetes.
2. Enterprise OpenShift platform
Organizations that already standardize on Red Hat OpenShift can use ARO while keeping their workloads on Azure.
3. Managed platform
Microsoft and Red Hat manage important parts of the platform, reducing the amount of cluster administration required from application teams. (Microsoft Learn)
4. Containerized microservices
.NET applications can be packaged as containers and deployed as independent workloads.
5. Scaling
Multiple replicas of a service can run simultaneously.
6. Security and identity
ARO supports integration with Microsoft Entra ID and Kubernetes RBAC. (Microsoft Learn)
7. CI/CD
It can be integrated with enterprise CI/CD pipelines.
8. Hybrid-cloud strategy
OpenShift can be useful for organizations that want consistency between OpenShift environments across different infrastructure.
5. ARO Architecture
A simplified architecture looks like this:
Internet
|
↓
Azure Front Door
|
↓
Application Gateway
|
↓
Azure Red Hat OpenShift
┌───────────────────┐
│ OpenShift │
│ Cluster │
│ │
│ ┌─────────────┐ │
│ │ Router │ │
│ └──────┬──────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ Service │ │
│ └──────┬──────┘ │
│ │ │
│ ┌─────┴─────┐ │
│ │ Pods │ │
│ │ │ │
│ │ .NET API │ │
│ │ .NET API │ │
│ │ .NET API │ │
│ └───────────┘ │
└───────────────────┘
|
Azure SQL DatabaseARO provides single-tenant, high-availability OpenShift clusters on Azure. (Microsoft Learn)
6. Important OpenShift Terminology
Before deploying .NET, understand these concepts.
Cluster
The complete OpenShift environment.
ARO Cluster
|
+-- Control Plane
|
+-- Worker Nodes
|
+-- Networking
|
+-- Storage
|
+-- OperatorsNode
A node is a machine that runs workloads.
Worker Node
|
+-- Pod
+-- Pod
+-- PodPod
A Pod is the basic Kubernetes/OpenShift unit in which containers run.
For a simple .NET API:
Pod
|
+-- .NET ContainerIf you have three replicas:
Pod 1 → .NET API
Pod 2 → .NET API
Pod 3 → .NET APIDeployment
Defines how your application should be deployed.
For example:
replicas: 3means we want three instances.
Service
Provides stable networking to the Pods.
Service
|
+--------+--------+
| | |
Pod Pod PodRoute
OpenShift Route exposes an application outside the cluster.
Internet
|
↓
OpenShift Route
|
↓
Service
|
↓
Pods7. Real-Time .NET Microservices Example
Let's design an e-commerce application.
We have:
E-Commerce
|
+-- Product Service
|
+-- Order Service
|
+-- Payment Service
|
+-- Inventory Service
|
+-- Notification ServiceSuppose the Order Service is built using:
ASP.NET Core Web API
.NET 10
C#
Entity Framework Core
SQL Server
DockerWe want:
Client
|
↓
OpenShift
|
Order Service
|
+----------+----------+
| | |
↓ ↓ ↓
Payment Inventory Notification8. Create the .NET API
Create the project:
dotnet new webapi -n OrderService
cd OrderServiceExample API:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();Controller:
using Microsoft.AspNetCore.Mvc;
namespace OrderService.Controllers;
[ApiController]
[Route("api/orders")]
public class OrdersController : ControllerBase
{
[HttpGet("{id}")]
public IActionResult GetOrder(int id)
{
return Ok(new
{
OrderId = id,
Product = "Laptop",
Quantity = 2,
Status = "Confirmed"
});
}
}Now:
GET /api/orders/1001returns:
{
"orderId": 1001,
"product": "Laptop",
"quantity": 2,
"status": "Confirmed"
}9. Containerize the .NET Application
OpenShift runs containerized workloads, so we can create a Docker image for our API.
Example Dockerfile:
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY . .
RUN dotnet restore
RUN dotnet publish -c Release \
-o /app/publish \
--no-restore
FROM mcr.microsoft.com/dotnet/aspnet:10.0
WORKDIR /app
COPY --from=build /app/publish .
EXPOSE 8080
ENTRYPOINT ["dotnet", "OrderService.dll"]The basic flow becomes:
C# Code
↓
dotnet publish
↓
Docker Image
↓
Container Registry
↓
OpenShift
↓
Pod10. Build the Docker Image
docker build -t orderservice:1.0 .Test locally:
docker run -p 8080:8080 orderservice:1.0Then:
http://localhost:8080/api/orders/100111. Push Image to Container Registry
In an enterprise environment, you could use a container registry such as:
Azure Container RegistryConceptually:
docker tag orderservice:1.0 \
myregistry.azurecr.io/orderservice:1.0
docker push \
myregistry.azurecr.io/orderservice:1.0Now the image is available to OpenShift.
12. Deploy the .NET Application to OpenShift
A Kubernetes/OpenShift Deployment could look like this:
apiVersion: apps/v1
kind: Deployment
metadata:
name: order-service
spec:
replicas: 3
selector:
matchLabels:
app: order-service
template:
metadata:
labels:
app: order-service
spec:
containers:
- name: order-service
image: myregistry.azurecr.io/orderservice:1.0
ports:
- containerPort: 8080
resources:
requests:
cpu: "250m"
memory: "256Mi"
limits:
cpu: "500m"
memory: "512Mi"Notice:
replicas: 3OpenShift will run three Pods.
Order Service
|
+-----------+-----------+
| | |
↓ ↓ ↓
Pod 1 Pod 2 Pod 3If one Pod becomes unavailable, the platform can maintain the desired replica state.
13. Create an OpenShift Service
Create:
apiVersion: v1
kind: Service
metadata:
name: order-service
spec:
selector:
app: order-service
ports:
- port: 80
targetPort: 8080Now:
Service
|
+---- Pod 1
|
+---- Pod 2
|
+---- Pod 3The application doesn't need to know which Pod receives the request.
14. Expose the API using an OpenShift Route
Example:
apiVersion: route.openshift.io/v1
kind: Route
metadata:
name: order-service
spec:
to:
kind: Service
name: order-service
port:
targetPort: 8080The resulting flow is:
Client
|
| HTTPS
↓
OpenShift Route
|
↓
Service
|
+--------+--------+
| | |
Pod 1 Pod 2 Pod 315. Deploy Using oc
OpenShift provides the oc command-line client.
For example:
oc login <your-cluster>Create/select a project:
oc new-project ecommerceDeploy:
oc apply -f deployment.yamlService:
oc apply -f service.yamlRoute:
oc apply -f route.yamlCheck Pods:
oc get podsExample:
NAME READY STATUS
order-service-7c8d9f7c5d-abc12 1/1 Running
order-service-7c8d9f7c5d-def34 1/1 Running
order-service-7c8d9f7c5d-ghi56 1/1 Running16. What Happens When Traffic Increases?
Suppose:
Normal traffic
↓
3 PodsDuring a festival sale:
Traffic increases
↓
Autoscaling
↓
5 Pods
↓
10 PodsConceptually:
Service
|
+---------+---------+
| | |
Pod Pod Pod
| | |
+---------+---------+
|
More traffic
↓
Additional PodsThis is one of the major advantages of container orchestration.
17. Health Checks
A production .NET application shouldn't simply be considered healthy because its process is running.
ASP.NET Core provides health-check support.
Example:
builder.Services.AddHealthChecks();
var app = builder.Build();
app.MapHealthChecks("/health");
app.MapControllers();
app.Run();Now:
GET /healthcan be used by the platform to determine application health.
18. Configure Kubernetes/OpenShift Probes
For example:
livenessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 10
periodSeconds: 10
readinessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 5
periodSeconds: 5There are two important concepts:
Liveness
"Is my application alive?"
Readiness
"Can my application receive traffic?"
This distinction is extremely important in microservices.
19. Configuration Management
Don't hard-code:
var connectionString =
"Server=production-server;Database=Orders...";Instead use configuration:
var connectionString =
builder.Configuration.GetConnectionString("OrdersDb");Environment-specific values can then be supplied through OpenShift configuration mechanisms.
For example:
env:
- name: ASPNETCORE_ENVIRONMENT
value: Production
- name: ConnectionStrings__OrdersDb
valueFrom:
secretKeyRef:
name: orders-db-secret
key: connection-string20. Secrets
Never put passwords directly into:
Dockerfile
Git repository
deployment.yaml
source codeInstead use a Secret.
Example:
oc create secret generic orders-db-secret \
--from-literal=connection-string="YOUR-CONNECTION-STRING"Then the application can consume it through an environment variable.
For enterprise Azure environments, you can also integrate workloads with Azure identity capabilities rather than relying on long-lived credentials. ARO supports managed and workload identities. (Microsoft Learn)
21. Scaling a .NET Microservice
Suppose:
Order Service
Current replicas = 3You can scale manually:
oc scale deployment/order-service --replicas=5Now:
Order Service
|
+-- Pod 1
+-- Pod 2
+-- Pod 3
+-- Pod 4
+-- Pod 5In production, autoscaling can be configured based on resource utilization and other supported metrics.
22. Rolling Deployment
Suppose version 1.0 is running:
Pod 1 → v1
Pod 2 → v1
Pod 3 → v1You deploy:
v2The platform can perform a rolling update rather than stopping every instance simultaneously.
Conceptually:
Pod 1 → v2
Pod 2 → v1
Pod 3 → v1
Pod 1 → v2
Pod 2 → v2
Pod 3 → v1
Pod 1 → v2
Pod 2 → v2
Pod 3 → v2This helps reduce application downtime during deployments.
23. Real-Time E-Commerce Architecture
Now let's put everything together.
Customers
|
↓
Azure Front Door
|
↓
OpenShift Route
|
↓
API Gateway
|
+---------------------+---------------------+
| | |
↓ ↓ ↓
Order Service Product Service Customer Service
| | |
↓ ↓ ↓
Payment Service Inventory Service Redis
|
↓
Notification Service
|
↓
Azure Service BusEach microservice can have:
.NET API
↓
Docker Image
↓
Container Registry
↓
OpenShift Deployment
↓
Pods
↓
Service
↓
Route24. How .NET and OpenShift Work Together
The relationship is important to understand:
.NET
↓
Application Framework
Docker
↓
Application Packaging
Kubernetes
↓
Container Orchestration
OpenShift
↓
Enterprise Kubernetes Platform
Azure Red Hat OpenShift
↓
Managed OpenShift on AzureSo ARO isn't replacing .NET.
It provides the platform on which your containerized .NET applications can run.
25. OpenShift vs AKS
This is a very common interview question.
| Feature | AKS | Azure Red Hat OpenShift |
|---|---|---|
| Technology | Kubernetes | OpenShift/Kubernetes |
| Azure managed service | Yes | Yes |
| Microsoft | Managed service | Jointly operated with Red Hat |
| Red Hat ecosystem | Not central | Strong |
| OpenShift tooling | No | Yes |
| Kubernetes workloads | Yes | Yes |
| .NET support | Yes | Yes |
| Enterprise OpenShift standard | No | Yes |
| Best fit | Azure/Kubernetes environments | Organizations standardized on OpenShift |
Microsoft explicitly describes ARO as an Azure-managed OpenShift service jointly engineered, operated, and supported by Microsoft and Red Hat. (Microsoft Learn)
26. OpenShift vs Azure App Service
These solve different problems.
Azure App Service
Best when:
I have a web application/API
↓
I want managed hosting
↓
I don't need KubernetesARO
Better suited when:
I have many containerized services
↓
I need Kubernetes/OpenShift
↓
I need enterprise container orchestrationDon't introduce OpenShift simply because you are using .NET.
27. OpenShift vs Docker
Another common misunderstanding:
Docker and OpenShift are not competitors in the same sense.
Docker packages the application.
OpenShift orchestrates containerized workloads.
.NET Application
↓
Docker Image
↓
OpenShift
↓
Pods
↓
Services
↓
Routes28. Why .NET Applications Work Well on OpenShift
Red Hat provides supported .NET container images and OpenShift guidance for .NET applications. For example, Red Hat's documentation describes dotnet SDK images and corresponding runtime/ASP.NET runtime image streams for OpenShift. (Red Hat Documentation)
That means an enterprise can standardize on:
.NET
+
Red Hat Enterprise Linux/UBI-based containers
+
OpenShift
+
AzureFor example:
.NET 10
↓
ASP.NET Core
↓
Red Hat UBI-based container
↓
OpenShift
↓
Azure Red Hat OpenShiftRed Hat's current documentation includes guidance for running .NET 10 on OpenShift and provides dotnet, dotnet-runtime, and dotnet-aspnet image streams. (Red Hat Documentation)
29. CI/CD Pipeline
A typical enterprise pipeline might look like:
Developer
|
↓
Git Repository
|
↓
CI Pipeline
|
+-- Build
+-- Unit Tests
+-- SonarQube
+-- Security Scan
+-- Docker Build
|
↓
Container Registry
|
↓
CD Pipeline
|
↓
ARO
|
↓
OpenShift Deployment
|
↓
PodsFor example:
docker build -t orderservice:1.0 .
docker push myregistry.azurecr.io/orderservice:1.0
oc apply -f deployment.yamlIn a real enterprise pipeline, image tags would normally be immutable version/build identifiers rather than simply latest.
30. What Happens When a Pod Fails?
Suppose:
Order Service
Pod 1 → Running
Pod 2 → Running
Pod 3 → FailedThe desired state says:
replicas = 3The orchestration layer can create another Pod:
Pod 1 → Running
Pod 2 → Running
Pod 3 → Failed
Pod 4 → StartingEventually:
Pod 1 → Running
Pod 2 → Running
Pod 4 → RunningThe application therefore doesn't have to manually detect and recreate failed instances.
31. Production Architecture
A mature enterprise architecture could look like:
Internet
|
↓
Azure Front Door
|
↓
WAF / Load Balancing
|
↓
Azure Red Hat OpenShift
|
+--------------+--------------+
| | |
↓ ↓ ↓
API Gateway Services Workers
| | |
| +-----+-----+ |
| | | | |
↓ ↓ ↓ ↓ ↓
Orders Payment Inventory Customer
|
↓
Azure Service Bus
|
↓
Notification Worker
|
↓
External Systems
Supporting services:
Azure SQL
Azure Cache for Redis
Azure Key Vault
Azure Container Registry
Application monitoring
Centralized logging
CI/CD32. Is ARO Mandatory in Microservices?
Again:
❌ No.
Microservices can run on:
AKS
ARO
Azure Container Apps
Docker Compose
ECS
GKE
Self-managed Kubernetes
Virtual Machines
Other container platformsThe correct architecture decision is:
Business Requirements
↓
Non-functional Requirements
↓
Platform Requirements
↓
Choose Hosting PlatformNot:
.NET
↓
Must use ARO ❌33. When Should You Choose ARO?
Choose ARO when your organization needs things such as:
Enterprise OpenShift standardization
Your company already uses OpenShift across environments.
Kubernetes + OpenShift ecosystem
You need OpenShift-specific platform capabilities and workflows.
Managed Azure deployment
You want OpenShift deployed into Azure while Microsoft and Red Hat handle important platform operations. (Microsoft Learn)
Large microservices platform
You have many containerized services and need centralized orchestration.
Hybrid-cloud consistency
You want an OpenShift-based application platform that can fit into broader hybrid-cloud strategies.
Enterprise security/governance
You need platform-level identity, RBAC, networking, policy, and operational controls.
34. When Should You NOT Choose ARO?
If you have:
One ASP.NET Core APIand your requirement is simply:
Host the APIARO could be unnecessary complexity.
You might choose:
Azure App Serviceinstead.
Likewise, if your team already has strong Azure Kubernetes expertise and doesn't need OpenShift, AKS may be a more natural choice.
35. ARO Interview Question
Q: Is Azure Red Hat OpenShift mandatory for .NET Core?
Answer:
No. Azure Red Hat OpenShift is not mandatory for .NET Core applications. .NET applications can run on Azure App Service, Azure Container Apps, AKS, virtual machines, Docker, and other platforms. ARO is a managed OpenShift platform on Azure and is mainly selected when an organization needs enterprise OpenShift/Kubernetes capabilities, OpenShift standardization, hybrid-cloud consistency, or specific operational and governance requirements.
That's the answer I'd recommend giving in a .NET Architect interview.
36. The Most Important Concept
Remember this hierarchy:
.NET
│
│ builds
↓
ASP.NET Core API
│
│ packaged as
↓
Docker Image
│
│ deployed to
↓
OpenShift
│
│ hosted on
↓
Azure Red Hat OpenShift
│
↓
AzureARO is the hosting/orchestration platform—not a requirement of the .NET framework.
37. Final Summary
Azure Red Hat OpenShift combines Azure + Red Hat OpenShift + Kubernetes-based container orchestration + managed platform operations. Microsoft says ARO provides fully managed OpenShift clusters, with Microsoft and Red Hat jointly engineering, operating, and supporting the service. (Microsoft Learn)
For a .NET microservices application:
.NET Microservice
↓
Docker Container
↓
Container Registry
↓
Azure Red Hat OpenShift
↓
OpenShift Deployment
↓
Pods
↓
Service
↓
Route
↓
UsersThe key takeaway is:
Don't choose ARO because you use .NET. Choose ARO when your application's operational, architectural, enterprise, or organizational requirements justify an OpenShift platform.
Official references
Azure Red Hat OpenShift — Microsoft Learn
Azure Red Hat OpenShift documentation
.NET on OpenShift — Red Hat documentation
Create an Azure Red Hat OpenShift cluster
If you're publishing this as a blog, a strong title would be “Azure Red Hat OpenShift (ARO) with .NET 10: Complete Guide to Deploying ASP.NET Core Microservices with Real-Time E-Commerce Example”.
