Run MicroShift on RHEL 10 / Fedora for Edge OpenShift

MicroShift is Red Hat’s lightweight OpenShift distribution designed for edge computing, IoT devices, and resource-constrained environments. While CRC (CodeReady Containers) runs a full OpenShift cluster for development, MicroShift strips the platform down to its core – a single-node Kubernetes with just enough OpenShift APIs to run containerized workloads on minimal hardware. This guide covers installing MicroShift on RHEL 10 and Fedora, configuring it, deploying workloads, and understanding when to choose it over CRC or full OKD.

What Is MicroShift

MicroShift is an OpenShift-derived Kubernetes distribution that runs on a single node with as little as 2 CPU cores and 2 GB of RAM. It packages the essential Kubernetes control plane components (API server, etcd, kubelet, CRI-O) into a single systemd service. Unlike full OpenShift, it omits the web console, Operators framework, S2I builds, and most of the multi-tenant infrastructure. What you get is a lightweight platform that speaks the Kubernetes API and supports standard workloads – pods, deployments, services, and routes.

MicroShift targets use cases like:

• Edge locations with limited bandwidth and compute
• IoT gateways running containerized data collection
• Retail point-of-sale systems
• Remote industrial sites
• Development environments where CRC’s 9 GB RAM requirement is too heavy

System Requirements

MicroShift’s resource requirements are modest compared to full OpenShift:

• CPU: 2 cores
• RAM: 2 GB minimum (3 GB recommended for running application workloads)
• Disk: 10 GB free
• OS: RHEL 9+, RHEL 10, or Fedora
• Container runtime: CRI-O (installed as a dependency)

MicroShift runs directly on the host – no VM required, unlike CRC. This is a significant advantage for edge hardware where virtualization overhead is unacceptable.

Install MicroShift on RHEL 10

MicroShift is distributed as RPM packages through the Red Hat repositories. First, ensure your RHEL system is registered and has an active subscription:

sudo subscription-manager status

Enable the MicroShift repository:

sudo subscription-manager repos --enable rhocp-4.17-for-rhel-10-x86_64-rpms
sudo subscription-manager repos --enable fast-datapath-for-rhel-10-x86_64-rpms

Install MicroShift:

sudo dnf install -y microshift

This pulls in CRI-O, openshift-clients (the oc CLI), and all required dependencies. Verify the package is installed:

rpm -q microshift

Install MicroShift on Fedora

On Fedora, MicroShift is available through the Fedora COPR repository. Enable the repository and install:

sudo dnf copr enable -y @redhat-et/microshift
sudo dnf install -y microshift

Install the OpenShift CLI tools:

sudo dnf install -y openshift-clients

Verify both packages are installed:

rpm -q microshift openshift-clients

Configure MicroShift

MicroShift configuration lives in /etc/microshift/config.yaml. The default configuration works for most local setups. Create or edit the file to customize networking, DNS, or cluster domain:

sudo mkdir -p /etc/microshift
sudo tee /etc/microshift/config.yaml > /dev/null <<'EOF'
dns:
  baseDomain: microshift.local
network:
  clusterNetwork:
    - cidr: 10.42.0.0/16
  serviceNetwork:
    - 10.43.0.0/16
node:
  hostnameOverride: "microshift-node"
  nodeIP: ""
EOF

If nodeIP is left empty, MicroShift uses the default route's interface IP. Set it explicitly if your machine has multiple network interfaces.

Configure the firewall to allow pod networking and API access:

sudo firewall-cmd --permanent --zone=trusted --add-source=10.42.0.0/16
sudo firewall-cmd --permanent --zone=trusted --add-source=10.43.0.0/16
sudo firewall-cmd --permanent --add-port=6443/tcp
sudo firewall-cmd --permanent --add-port=80/tcp
sudo firewall-cmd --permanent --add-port=443/tcp
sudo firewall-cmd --reload

Verify the firewall rules are active:

sudo firewall-cmd --list-all

Start MicroShift

Enable and start the MicroShift service:

sudo systemctl enable --now microshift

Check the service status:

sudo systemctl status microshift

You should see "active (running)". MicroShift takes 1-2 minutes to fully initialize the control plane and system pods. Monitor the startup progress in the journal:

sudo journalctl -u microshift -f

Wait until you see messages indicating the API server is ready. Then copy the kubeconfig to your user's home directory:

mkdir -p ~/.kube
sudo cp /var/lib/microshift/resources/kubeadmin/kubeconfig ~/.kube/config
sudo chown $USER:$USER ~/.kube/config
chmod 600 ~/.kube/config

Verify cluster access:

oc get nodes

You should see one node with "Ready" status. Check the system pods are running:

oc get pods -A

All pods in the openshift-dns, openshift-ingress, openshift-ovn-kubernetes, and openshift-service-ca namespaces should be in "Running" state.

Deploy a Workload

Create a namespace and deploy a test application:

oc create namespace demo
oc -n demo create deployment hello --image=registry.access.redhat.com/ubi9/httpd-24:latest --port=8080

Wait for the pod to start:

oc -n demo get pods -w

Once the pod shows "Running", expose it as a service and route:

oc -n demo expose deployment/hello --port=8080
oc -n demo expose service/hello --hostname=hello.microshift.local

Add the hostname to your local /etc/hosts file (since MicroShift does not include an external DNS):

echo "$(oc get nodes -o jsonpath='{.items[0].status.addresses[0].address}') hello.microshift.local" | sudo tee -a /etc/hosts

Test the application:

curl http://hello.microshift.local

You should get an HTTP response from the Apache server. This confirms that pod networking, services, and the OpenShift router are all functioning.

MicroShift vs CRC vs Full OKD

Choosing the right OpenShift variant depends on your use case:

Feature	MicroShift	CRC	OKD / OpenShift
Target use	Edge, IoT, minimal	Developer laptop	Production clusters
Minimum RAM	2 GB	9 GB	16 GB+ per node
Runs in VM	No (bare host)	Yes (libvirt)	Bare metal or cloud
Web console	No	Yes	Yes
Operators	No	Yes	Yes
S2I builds	No	Yes	Yes
Routes/Ingress	Yes	Yes	Yes
Multi-node	No	No	Yes
Auto-updates	Via rpm-ostree	crc upgrade	Cluster operator

Choose MicroShift when you are deploying to resource-constrained hardware, need a lightweight Kubernetes with OpenShift-compatible APIs, or want to avoid the overhead of a VM. Choose CRC when you need the full OpenShift developer experience locally (web console, operators, S2I). Choose OKD/OpenShift when you are running production workloads at scale.

Wrapping Up

MicroShift fills the gap between full OpenShift and plain Kubernetes for edge and resource-limited environments. Installation from RPM is straightforward on RHEL 10 and Fedora, it runs as a single systemd service, and standard oc/kubectl commands work against it. If you are building applications that need to run on edge hardware with the OpenShift API surface, MicroShift delivers that without the 9 GB RAM tax that CRC demands.