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 Azure

OpenShift 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
      Service

Each 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 servers

For example:

ASP.NET Core Web API
       |
       +----> IIS
       |
       +----> Azure App Service
       |
       +----> Docker
       |
       +----> AKS
       |
       +----> ARO

So .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 Database

ARO 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
   |
   +-- Operators

Node

A node is a machine that runs workloads.

Worker Node
   |
   +-- Pod
   +-- Pod
   +-- Pod

Pod

A Pod is the basic Kubernetes/OpenShift unit in which containers run.

For a simple .NET API:

Pod
 |
 +-- .NET Container

If you have three replicas:

Pod 1 → .NET API
Pod 2 → .NET API
Pod 3 → .NET API

Deployment

Defines how your application should be deployed.

For example:

replicas: 3

means we want three instances.

Service

Provides stable networking to the Pods.

             Service
                |
       +--------+--------+
       |        |        |
      Pod      Pod      Pod

Route

OpenShift Route exposes an application outside the cluster.

Internet
   |
   ↓
OpenShift Route
   |
   ↓
Service
   |
   ↓
Pods

7. 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 Service

Suppose the Order Service is built using:

ASP.NET Core Web API
.NET 10
C#
Entity Framework Core
SQL Server
Docker

We want:

                 Client
                   |
                   ↓
              OpenShift
                   |
             Order Service
                   |
        +----------+----------+
        |          |          |
        ↓          ↓          ↓
    Payment    Inventory   Notification

8. Create the .NET API

Create the project:

dotnet new webapi -n OrderService
cd OrderService

Example 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/1001

returns:

{
  "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
   ↓
Pod

10. Build the Docker Image

docker build -t orderservice:1.0 .

Test locally:

docker run -p 8080:8080 orderservice:1.0

Then:

http://localhost:8080/api/orders/1001

11. Push Image to Container Registry

In an enterprise environment, you could use a container registry such as:

Azure Container Registry

Conceptually:

docker tag orderservice:1.0 \
    myregistry.azurecr.io/orderservice:1.0

docker push \
    myregistry.azurecr.io/orderservice:1.0

Now 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: 3

OpenShift will run three Pods.

             Order Service
                   |
       +-----------+-----------+
       |           |           |
       ↓           ↓           ↓
     Pod 1       Pod 2       Pod 3

If 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: 8080

Now:

Service
   |
   +---- Pod 1
   |
   +---- Pod 2
   |
   +---- Pod 3

The 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: 8080

The resulting flow is:

Client
  |
  | HTTPS
  ↓
OpenShift Route
  |
  ↓
Service
  |
  +--------+--------+
  |        |        |
 Pod 1    Pod 2    Pod 3

15. Deploy Using `oc`

OpenShift provides the oc command-line client.

For example:

oc login <your-cluster>

Create/select a project:

oc new-project ecommerce

Deploy:

oc apply -f deployment.yaml

Service:

oc apply -f service.yaml

Route:

oc apply -f route.yaml

Check Pods:

oc get pods

Example:

NAME                             READY   STATUS
order-service-7c8d9f7c5d-abc12   1/1     Running
order-service-7c8d9f7c5d-def34   1/1     Running
order-service-7c8d9f7c5d-ghi56   1/1     Running

16. What Happens When Traffic Increases?

Suppose:

Normal traffic
   ↓
3 Pods

During a festival sale:

Traffic increases
       ↓
Autoscaling
       ↓
5 Pods
       ↓
10 Pods

Conceptually:

              Service
                 |
       +---------+---------+
       |         |         |
      Pod       Pod       Pod
       |         |         |
       +---------+---------+
                 |
            More traffic
                 ↓
          Additional Pods

This 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 /health

can 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: 5

There 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-string

20. Secrets

Never put passwords directly into:

Dockerfile
Git repository
deployment.yaml
source code

Instead 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 = 3

You can scale manually:

oc scale deployment/order-service --replicas=5

Now:

Order Service
     |
     +-- Pod 1
     +-- Pod 2
     +-- Pod 3
     +-- Pod 4
     +-- Pod 5

In 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 → v1

You deploy:

v2

The 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 → v2

This 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 Bus

Each microservice can have:

.NET API
   ↓
Docker Image
   ↓
Container Registry
   ↓
OpenShift Deployment
   ↓
Pods
   ↓
Service
   ↓
Route

24. 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 Azure

So 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 Kubernetes

ARO

Better suited when:

I have many containerized services
        ↓
I need Kubernetes/OpenShift
        ↓
I need enterprise container orchestration

Don'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
       ↓
Routes

28. 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
+
Azure

For example:

.NET 10
   ↓
ASP.NET Core
   ↓
Red Hat UBI-based container
   ↓
OpenShift
   ↓
Azure Red Hat OpenShift

Red 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
    |
    ↓
Pods

For example:

docker build -t orderservice:1.0 .
docker push myregistry.azurecr.io/orderservice:1.0

oc apply -f deployment.yaml

In 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 → Failed

The desired state says:

replicas = 3

The orchestration layer can create another Pod:

Pod 1 → Running
Pod 2 → Running
Pod 3 → Failed
Pod 4 → Starting

Eventually:

Pod 1 → Running
Pod 2 → Running
Pod 4 → Running

The 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/CD

32. 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 platforms

The correct architecture decision is:

Business Requirements
        ↓
Non-functional Requirements
        ↓
Platform Requirements
        ↓
Choose Hosting Platform

Not:

.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 API

and your requirement is simply:

Host the API

ARO could be unnecessary complexity.

You might choose:

Azure App Service

instead.

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
              │
              ↓
           Azure

ARO 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
       ↓
Users

The 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”.

Pages

Monday, August 31, 2026

Azure Red Hat OpenShift (ARO) with .NET Core — Complete Guide with Real-Time Example

1. What is Azure Red Hat OpenShift?

2. Why do we need OpenShift?

3. Is Azure OpenShift mandatory for .NET Core?

❌ No.

4. Why would an enterprise choose ARO?

1. Kubernetes

2. Enterprise OpenShift platform

3. Managed platform

4. Containerized microservices

5. Scaling

6. Security and identity

7. CI/CD

8. Hybrid-cloud strategy

5. ARO Architecture

6. Important OpenShift Terminology

Cluster

Node

Pod

Deployment

Service

Route

7. Real-Time .NET Microservices Example

8. Create the .NET API

9. Containerize the .NET Application

10. Build the Docker Image

11. Push Image to Container Registry

12. Deploy the .NET Application to OpenShift

13. Create an OpenShift Service

14. Expose the API using an OpenShift Route

15. Deploy Using oc

16. What Happens When Traffic Increases?

17. Health Checks

18. Configure Kubernetes/OpenShift Probes

Liveness

Readiness

19. Configuration Management

20. Secrets

21. Scaling a .NET Microservice

22. Rolling Deployment

23. Real-Time E-Commerce Architecture

24. How .NET and OpenShift Work Together

25. OpenShift vs AKS

26. OpenShift vs Azure App Service

Azure App Service

ARO

27. OpenShift vs Docker

28. Why .NET Applications Work Well on OpenShift

29. CI/CD Pipeline

30. What Happens When a Pod Fails?

31. Production Architecture

32. Is ARO Mandatory in Microservices?

❌ No.

33. When Should You Choose ARO?

Enterprise OpenShift standardization

Kubernetes + OpenShift ecosystem

Managed Azure deployment

Large microservices platform

Hybrid-cloud consistency

Enterprise security/governance

34. When Should You NOT Choose ARO?

35. ARO Interview Question

Q: Is Azure Red Hat OpenShift mandatory for .NET Core?

Answer:

36. The Most Important Concept

37. Final Summary

Official references

Don't Copy

15. Deploy Using `oc`