I’ve spent a long time watching teams pay cloud prices for steady workloads that could sit on their own iron. The part worth keeping from the cloud isn’t the brand. It’s the habit: declare what you want, apply it, and let a control plane chase that state.

That’s what kcore is for. You install it on physical hosts. You run VMs with Cloud Hypervisor. Then you add the pieces people usually buy as separate products: shared block storage, VM high availability, Kubernetes on the same nodes, and databases that live on the host OS—not in a guest you babysit by hand.

This isn’t a feature dump for 0.8.0 alone. It’s the shape of the platform as it stands now.

One fleet, not five appliances
A lot of “private cloud” stacks are a hypervisor, a SAN, a Kubernetes distro, a database appliance, and a pile of glue. Each one has its own upgrade story and its own identity model.

kcore keeps one membership list. Nodes are kcoreOS. You talk to a controller with kctl, Terraform, the dashboard, or MCP. VMs, Ceph, Kubernetes, and PostgreSQL clusters are resources on that same API surface. You don’t stand up a second estate every time you need a new layer.

Shared storage (the thing people mean by vSAN)
Local disks are still fine. Filesystem, LVM, and ZFS keep guest disks on the host that runs the VM. Use that when latency matters and you’re happy pinning a guest to a machine.

When you want disks that survive a host loss—and guests that move without a block copy—you declare a CephCluster. That’s kcore SAN: OSDs on data disks, a replicated pool, RBD images as VM disks. Default pool keeps three copies and accepts writes with two.

Cold drain and live migration use the same image on the destination. You’re not rsyncing a 500 GB disk across the floor. That is the practical meaning of “vSAN” here: shared Ceph RBD, declared in YAML, not a fibre-channel catalog from 2008.

HA for virtual machines
Shared disks alone don’t restart a guest. HA does.

When a host stops heartbeating, the controller marks it lost, fences its Ceph clients so a returning node can’t write stale disks, then restarts protected VMs on survivors. Priority and admission control decide who gets capacity first. Placement gates stop a rebooted host from auto-starting a guest the controller already moved.

Protection is honest in the listings: Ceph-backed VMs are protected; local-only disks are not. You see that before the outage, not after.

Kubernetes on the same metal
You don’t need a second rack for Kubernetes. kctl kubernetes apply takes a KubernetesCluster manifest and puts kubelet, etcd, and the API server on members you already trust. Same certificates story as the rest of the cluster. Same ops tooling.

The point is sequencing. Run VMs first. Add Kubernetes when a workload earns it. You’re not forced into “everything is a pod” on day one.

PostgreSQL as a cluster, on the host
0.8.0 ships bare-metal PostgreSQL with Patroni: a PostgresqlCluster with a primary, streaming standbys, and etcd voters on kcoreOS nodes. Create, update, upgrade, and switchover go through the controller. Cluster updates wait for a safe Patroni switchover before a node reboot.

This isn’t “Postgres in a VM you manage like 2012.” It’s a declared service next to the hypervisor, with kctl pg-cluster, the dashboard, and MCP on the same path.

There’s also a simpler single-node PostgreSQL resource for cases that don’t need Patroni. Use the cluster kind when you care about failover.

ClickHouse (designed, not on main yet)
ClickHouse follows the same bare-metal pattern on paper: shards, replicas, Keeper, rolling ops that keep a replica of each shard up. That work is designed and prototyped; it isn’t what you get from the public v0.8.0 tag today. If you need OLAP on the host OS the same way as Postgres, watch that space—don’t plan a migration on a blog promise.

How you operate it
Desired state is text. YAML and Terraform both work. Updates are a release tag: canary node first, soak, then the rest, with automatic revert if the node doesn’t come back healthy. Paying subscribers can take the enterprise channel for prebuilt packages ahead of the public tag.

Provisioning (bare-metal image/boot/power) and Vault (backup) are separate products with their own versions. They plug into the same story when you need day-0 iron or ransomware-resistant copies.

Who this is for
Teams leaving VMware or a rising cloud bill who still want an API, not a console-only hypervisor
Operators who want VMs and Kubernetes on one set of hosts
People who say “SAN” and mean replicated block that moves with the guest
Anyone who wants Postgres failover declared next to the cluster, not as a side project.

Where to start
Release: https://github.com/kcorehypervisor/kcore/releases/tag/v0.8.0
Docs: https://kcorehypervisor.com/docs/
SAN: https://kcorehypervisor.com/docs/user/storage-vsan.html
HA: https://kcorehypervisor.com/docs/user/ha-vms.html
Kubernetes: https://kcorehypervisor.com/docs/user/kubernetes.html
PostgreSQL: https://kcorehypervisor.com/docs/user/postgresql.html
Install the ISO, make a small Ceph pool if you have three hosts, put a disposable VM on RBD, kill a node on purpose, and watch HA. Then decide whether the rest of the platform fits—not from a slide deck, from that run.