Platform features · Netherlands

Everything you can build, run and use on GRN.CLOUD

Compute, Kubernetes, virtualisation, storage, databases, networking, application delivery and AI on one European platform. Every capability on this page is a resource in the same cluster API, on the same infrastructure, under one identity model.

  • OpenShift, OKD & Kubernetes
  • KubeVirt virtual machines
  • Ceph, NVMe & S3 storage
  • NVIDIA GPUs
  • Dutch jurisdiction
GRN.CLOUD platform · one control planePLATFORM STACKYour workloadsContainers · VMs · functions · modelsYOU OPERATECluster & app platformOpenShift / OKD / Kubernetes · KubeVirt · KnativeGRN-MANAGEDData servicesCeph block & file · S3 object · PostgreSQL · MariaDB · RedisGRN-MANAGEDNetwork fabricNetworkPolicy · MetalLB/BGP · Gateway API · SubmarinerGRN-MANAGEDSites & hardwareThree zones per site · Netherlands · 100% renewableGRN-MANAGED

The platform

One platform, not a catalogue of separate products

GRN.CLOUD runs on distributed OpenShift and Kubernetes clusters in the Netherlands. Compute, storage, networking and data services are objects in the same cluster API, so a virtual machine, a container and a serverless function share one control plane, one RBAC model, one network fabric and one storage layer.

Compute

Compute & virtualisation

Three ways to run a workload on the same infrastructure: virtual machines, containers and serverless functions. Moving between them is a change of packaging, not a change of provider.

Virtual machines run through KubeVirt as Kubernetes objects — a VirtualMachine is scheduled, networked and given storage by the same primitives as a pod. Traditional VMs and cloud-native workloads share one cluster, one API and one set of policies.

  • KubeVirt
  • Knative
  • QEMU/KVM
  • HPA
Virtual machines

Windows and Linux guests as Kubernetes objects. Create, start, stop, snapshot and template from the console or the API.

Containers

Declarative Deployments with rolling updates, automatic restart of failed containers and horizontal pod autoscaling.

Serverless functions

Knative Serving and Eventing. Idle revisions scale to zero and reactivate on a request or an event.

Worker node families

CPU-optimised, memory-optimised and network-optimised pools. GPU nodes available for accelerated workloads.

Live migration & HA

Running VMs move between nodes for planned maintenance, and restart in a healthy zone after an unplanned node or zone loss.

Dedicated hardware

Bare-metal workers for workloads that need hardware-level control, local NVMe or physical isolation.

Container platform

Kubernetes & containers

A managed cluster with a highly available control plane. GRN runs the control plane, the upgrades and the storage, networking, observability and backup plumbing. You keep cluster-admin and standard kubectl, Helm and GitOps.

Pick the distribution that matches your stack: OKE (vanilla Kubernetes), OKD (open-source OpenShift) or OCP (Red Hat OpenShift). All three are CNCF-conformant — the same Kubernetes API, the same tooling, no proprietary control surface.

  • OKE · OKD · OCP
  • HyperShift
  • Gateway API
  • Argo CD
Your choice of distribution

Vanilla Kubernetes (OKE), open-source OpenShift (OKD) or Red Hat OpenShift (OCP). CNCF-conformant in every case.

Hosted control plane

HyperShift runs the API server, etcd and console as pods. No control-plane nodes to operate — or to pay for.

Worker pools

KubeVirt VM workers on VPC, or bare-metal workers on DPC. Pools are sized and scaled independently.

Namespaces, RBAC & quotas

Multi-tenancy with roles, role bindings, service accounts and per-namespace resource limits.

Ingress & load balancing

Gateway API for hostname and path routing; MetalLB provides LoadBalancer services on bare metal, advertised with BGP.

Workload scheduling

Topology spread across three availability zones, pod disruption budgets and readiness-gated rolling updates.

Storage integration

CSI-provisioned Ceph and OpenEBS volumes with snapshots and online expansion, requested by PersistentVolumeClaim.

Managed lifecycle

Provisioning, version upgrades, security patching and backup of the control plane and nodes.

Developer platform

Application development

Deploy from a marketplace entry, a container image, a Helm chart, an Operator or your own Git repository. Everything the platform creates is a standard Kubernetes object you can inspect, edit or export.

Marketplace entries ship as templates with defaults for storage, networking and resource requests, so an application reaches a running state without assembling every component by hand. It is deployed into your own project and stays yours to configure.

  • GitLab
  • Tekton
  • Argo CD
  • Keycloak
  • Helm
Application marketplace

Databases, web servers, developer tools, collaboration and AI applications as ready-to-deploy templates.

Source control

A managed GitLab instance with repositories, merge requests, CI runners and a container registry.

CI/CD pipelines

Tekton pipelines build, test and push images as Kubernetes resources, next to the workloads they produce.

GitOps

Argo CD reconciles manifests, Helm charts and Operators from your Git repository continuously.

In-browser IDE

Development workspaces without setting up a local toolchain.

Identity for your apps

Keycloak provides authentication and single sign-on for the applications you deploy.

Data

Storage

Block, file and object storage provisioned as Kubernetes objects through CSI drivers. Applications request storage with a PersistentVolumeClaim or an ObjectBucketClaim; the platform provisions, binds and attaches it.

The three types are three access contracts, not three quality levels. Every tier uses the same interface, so moving between them is a StorageClass change rather than an application change.

  • Ceph
  • OpenEBS
  • NooBaa S3
  • CSI
Block · RWO

Raw volumes with exclusive access and the shortest path to disk. Databases, message brokers and VM disks.

File · RWX

A shared POSIX filesystem mounted read-write by many pods across nodes at once. Shared document roots and upload directories.

Object · S3

S3-compatible buckets over HTTPS, reachable in or out of the cluster. Backups, artifacts, datasets and media.

Local NVMe

Low-latency local volumes for the most I/O-sensitive workloads, where latency matters more than shared placement.

Replicated & durable tiers

Ceph replicates volumes across availability zones, so a zone can be lost without losing data.

Data services

Dynamic provisioning, snapshots and clones, and online volume expansion without downtime.

Data services

Databases

PostgreSQL, MariaDB and Redis, deployed and operated on the platform. Operators run them as StatefulSets on persistent volumes, so they get the same scheduling, self-healing, monitoring and backup as any other workload.

We handle provisioning, replication, failover, patching and backups. You get an endpoint, your schema and your data.

  • PostgreSQL
  • MariaDB
  • Redis
PostgreSQL

Relational and transactional workloads, APIs and analytics. MVCC concurrency with point-in-time recovery.

MariaDB

Web applications and general relational workloads, with replication and transactional durability.

Redis

Caching, sessions, queues and low-latency lookups, with replication and failover.

High availability

Replication with automated failover managed by the operator, across availability zones.

Backup & restore

Scheduled backups, volume snapshots and point-in-time recovery to object storage.

Monitoring & alerting

Database health, replication lag and resource metrics in the platform monitoring stack.

Connectivity

Networking

Networking is part of the platform, configured with Kubernetes objects rather than a parallel proprietary console. Firewalling, load balancing, VPN termination, multi-cluster connectivity and VM networks are all resources in the cluster API.

That means network configuration lives in Git next to the application it belongs to, is applied by the same pipeline, and is portable to any conformant cluster.

  • NetworkPolicy
  • MetalLB · BGP
  • Submariner
  • cert-manager
  • External-DNS
Firewalling

Kubernetes NetworkPolicy enforced in the data plane. A default-deny namespace admits only the connections it declares.

Load balancing

MetalLB assigns external addresses to LoadBalancer services and advertises them with BGP; routers spread flows using ECMP.

Anycast & failover

The same service address is announced from more than one location; withdrawn announcements converge traffic onto healthy paths.

Ingress, DNS & TLS

Gateway API routing, cluster DNS for service discovery, cert-manager for certificates and External-DNS for records.

Private networks

VXLAN private subnets, and user-defined networks (UDN) that give virtual machines their own layer-2 or layer-3 segments.

VPN

OpenVPN and WireGuard run as ordinary cluster workloads, for remote administrative access and site-to-site links.

Multi-cluster

Submariner and BGP EVPN connect clusters across zones, sites and on-premises, with cross-cluster service discovery.

Availability zones

Three independent zones per regional site, each with its own power, cooling, uplinks and network fabric.

Security

Security & identity

Security here is a set of standard Kubernetes primitives applied in layers, not a single product with a badge on it. Each one is inspectable, expressible in Git and enforced by the cluster rather than by convention.

Isolation is a choice you make per workload: a namespace on shared infrastructure, a dedicated cluster, or dedicated bare-metal hosts.

  • RBAC
  • NetworkPolicy
  • Keycloak
  • Red Hat ACM / ACS
RBAC

Roles, role bindings and service accounts scoped per namespace. Access is granted explicitly, and every grant is a reviewable object.

Namespace isolation

Each tenant or environment gets its own namespace with quotas, limits and opt-in cross-namespace traffic.

Micro-segmentation

NetworkPolicy selects pods by label rather than IP, down to a single service, with no implicit trust from a shared network.

Secrets

Credentials are Kubernetes Secrets mounted or injected at runtime, not baked into images.

TLS everywhere

cert-manager issues and renews certificates automatically for routes and internal services.

Private endpoints

Services reachable only over a VPN tunnel are never exposed by a public route.

Policy & posture

Red Hat Advanced Cluster Management and Advanced Cluster Security enforce policy and report posture across clusters.

Jurisdiction

Infrastructure is owned and operated in the Netherlands, under Dutch and EU law.

Machine learning

AI / ML

An open-source ML platform on the same clusters as everything else. Notebook, pipeline, training run, registered model and served endpoint are all Kubernetes workloads, scheduled by the same control plane and secured by the same RBAC.

GPUs are scheduled as a shared cluster resource rather than pinned to a machine, and training data and checkpoints stay on EU-resident object storage.

  • OpenShift AI / OpenDataHub
  • Kubeflow Pipelines
  • KServe
  • NVIDIA GPU
Workbenches

Jupyter notebooks from curated, versioned images, isolated per user, with data connections configured up front.

Pipelines

Kubeflow Pipelines turn interactive notebook code into repeatable, distributed training runs.

Model serving

KServe inference endpoints, ModelMesh for density, and canary rollout with rollback.

Model registry

Versioned models tracked from experiment through to the endpoint serving them.

GPU partitioning

NVIDIA GPUs, MIG-partitionable, requested like any other resource so capacity is shared rather than stranded.

EU-resident data

Datasets and checkpoints on S3-compatible storage, and inference served from infrastructure in the Netherlands.

Day two

Observability, backup & operations

The operational layer runs across every cluster and is operated by GRN. These are platform capabilities, available to the workloads you deploy without assembling a monitoring or backup stack first.

  • Prometheus
  • Grafana
  • Loki
  • Velero
Metrics

Prometheus metrics for clusters, nodes and workloads, with Grafana dashboards and central metrics aggregation.

Logging

Centralised log aggregation with Loki across clusters.

Alerting

Alerts on cluster, node, workload and database health, routed to your team.

Backup & restore

Velero backs up cluster resources and persistent volumes, and restores them into the same or another cluster.

Snapshots & replication

Volume snapshots for point-in-time copies; Ceph replicates data across availability zones synchronously.

Lifecycle management

Managed version upgrades and security patching of nodes and the control plane, on a schedule you agree.

Interfaces

Automation & developer access

Everything on this page is an API object, so you can operate the platform with the tools your engineering team already uses. There is no proprietary control surface you have to learn or automate around.

Anything the web console does, the Kubernetes API does — which is what makes the platform scriptable, reviewable in Git and portable off it.

  • kubectl · oc
  • Helm
  • Argo CD
  • Flux
  • MCP
Kubernetes API

The primary interface. Every workload, volume, route and policy is a resource you can create, inspect and version.

Web console

Cluster, workload, virtual machine and storage management in the browser, for the things that are faster to click.

CLI

Standard kubectl and oc against your cluster, with no wrapper tool in between.

Helm

Chart-based packaging and release management for your own and third-party applications.

GitOps

Argo CD is provided and operated; Flux is supported as a customer-installed alternative.

MCP

Model Context Protocol access, so AI assistants and agents can work against the platform directly.

Infrastructure

The same capabilities, on the isolation level you need

Every capability above runs across all three infrastructure models. What changes is how much of the hardware is yours — not which features you get.

Shared

Public Cloud

Shared infrastructure with application-level control and RBAC isolation. Suited to developers, smaller workloads, and development and test environments.

Public Cloud →
Dedicated compute

Virtual Private Cloud

Dedicated compute with cluster-level control and kernel isolation, on KubeVirt VM workers. Suited to teams running production workloads.

Virtual Private Cloud →
Dedicated hardware

Dedicated Private Cloud

Fully dedicated hardware with bare-metal workers, local NVMe and an isolated network, for demanding, regulated or high-control workloads.

Dedicated Private Cloud →

Building a complete environment rather than a single cluster? See the Virtual DataCenter. For rates and instance sizing, see pricing.

One platform, in the Netherlands, on renewable power

Compute, Kubernetes, storage, databases, networking and AI on infrastructure that answers to European law. Standard APIs throughout, so what you build here is not locked in here.

Free during the Alpha phase · no credit card required