Kubernetes Expertise

Kubernetes is our daily production tool: our platforms run on clusters we administer in Europe. Expertise shows at the first real incident : and we've met ours.

The problem you're facing

Many providers "know Kubernetes" from deploying it once. The difference shows at the first incident: a pod in CrashLoopBackOff, a NotReady node : either you know, or you search the Internet while production is down.

Our answer

We administer production clusters: upgrades, hardening, monitoring, troubleshooting and scaling. And we operate the cluster for you if you wish : or train your teams.

RKE2: a Kubernetes distribution built for production

We deploy our clusters with RKE2, Rancher's security-focused Kubernetes distribution. RKE2 tracks upstream Kubernetes releases closely, ships containerd rather than Docker, and applies settings aligned with CIS recommendations by default. Control plane components (API server, scheduler, controller manager, etcd) run as supervised static pods, which keeps upgrades and troubleshooting simple.

The choice isn't ideological: RKE2 installs reproducibly, suits isolated or sensitive environments, and doesn't lock you in. An RKE2 cluster is a standard Kubernetes cluster: your manifests, Helm charts and tools work the same way, and you can change operator if you wish.

  • Highly available control plane (at least 3 etcd nodes)
  • CIS security profiles and admission policies
  • containerd and CNI networking (Canal or Cilium as needed)
  • Rolling upgrades, node by node, without downtime

Rancher: managing one or many clusters

When you run several clusters (production, staging, per-client or per-team environments), Rancher provides a single console: access management, projects and namespaces, workload visibility and an application catalogue. We use it to give your teams the right level of autonomy without multiplying administrator accounts.

Rancher integrates with your directory (LDAP, Active Directory, OIDC), so rights are granted per team and an access can be revoked in one place. For multi-site organisations, it also simplifies managing clusters spread across our Paris, Frankfurt and Zürich datacenters.

Helm and GitOps: reproducible deployments

Every component we install on a cluster (ingress controller, cert-manager, monitoring, backup, storage) is described as a versioned Helm chart. Your applications can follow the same model: one chart per service, values per environment, and a full history of what was deployed.

We recommend a GitOps approach, with Argo CD for example: the desired state of the cluster lives in a Git repository, and every change goes through code review. During an incident, rolling back means reverting a commit. It is also the best possible documentation of your platform.

High availability at every layer

Cluster high availability isn't limited to the control plane. We handle it layer by layer: several control nodes on separate physical machines, worker nodes sized to absorb the loss of one of them, replicated persistent storage, and redundant load balancers in front of the cluster.

On the application side, we help you use Kubernetes' native mechanisms: multiple replicas, anti-affinity rules so instances don't all land on the same node, PodDisruptionBudgets so maintenance never takes the service down, and properly tuned liveness and readiness probes.

  • Control nodes on separate physical servers
  • Replicated persistent storage (Ceph RBD or equivalent)
  • etcd backups and application backups (Velero)
  • Horizontal pod autoscaling based on load

Monitoring and observability

Every cluster we run comes with Prometheus and Grafana: node, pod, control plane and storage metrics, ready-made dashboards and alerts tuned to flag real problems rather than drown the on-call engineer in noise. Logs are centralised so the thread of an incident can be followed.

Alerts go to our on-call engineers, 24 hours a day, 7 days a week. You keep access to the dashboards to follow your own application indicators, and we can add your business metrics to the same tools.

Production operations: what we handle

Running Kubernetes in production is mostly about well-kept routine: applying security updates, renewing certificates, watching capacity, testing restores, following the version lifecycle (a Kubernetes minor release is only maintained for about a year). We carry out these tasks on a schedule agreed with you, with announced maintenance windows.

We also work on existing setups: auditing a cluster deployed by another team, upgrading an outdated version, migrating a cluster managed by a hyperscaler to our European infrastructure, or supporting a team that wants to keep control of deployments while delegating the infrastructure.

Cluster security

A Kubernetes cluster exposes a broad attack surface: the API, nodes, container images, secrets and traffic between services. We reduce it layer by layer. API access goes through your directory with RBAC roles limited to what is strictly necessary, and administrative rights are logged. Network policies (NetworkPolicy) isolate namespaces and only allow the expected flows between services.

Admission policies prevent privileged or non-compliant containers from being deployed, images come from controlled registries and are scanned for known vulnerabilities, and secrets are encrypted at rest in etcd, with the option of moving them to a dedicated vault. The nodes themselves are hardened and updated on the same schedule as the rest of the infrastructure.

  • RBAC linked to your directory, logged administrative access
  • NetworkPolicy: namespace isolation
  • Admission policies and image scanning
  • Secrets encrypted at rest, external vault possible

Kubernetes or virtual machines?

Kubernetes isn't an end in itself. For a stable monolithic application with a database, one or two well-administered virtual machines are often simpler and cheaper. Kubernetes comes into its own when you have several services, frequent deployments, scaling needs, or several environments to keep identical.

Our advice is therefore pragmatic: we assess your context and will tell you frankly if a classic Proxmox infrastructure fits your need better. Both approaches also coexist very well on the same private cloud.

What LaMeDuSe Cloud takes care of

  • Cluster architecture adapted to your context
  • Hardened deployment: RBAC, NetworkPolicies, Pod Security
  • Complete monitoring (Prometheus, Grafana, Loki)
  • Planned and tested upgrades
  • Velero backups and restore
  • Troubleshooting by production SREs
  • Training and knowledge transfer

Our methodology

  1. 1

    Context audit

    Volumes, criticality, hardware constraints and goals: context dictates the architecture.

  2. 2

    Tailored architecture

    Argued recommendations, sized for your real loads and peaks.

  3. 3

    Implementation

    Deployment by teams who run the same stack on their own production.

  4. 4

    Handover

    Documentation, training and knowledge transfer for your autonomy.

Technologies

Proxmox VE & Proxmox Backup ServerKubernetes (kubeadm)Ceph, ZFSPrometheus, GrafanaAnsible, Terraform

Security

Hardened baseline configuration, secrets managed off the servers, encrypted backups and regular restore tests.

Hosting & infrastructure

Our own production runs on these technologies in our European datacenters: expertise is proven by operations.

Maintenance

Version tracking, security watch and support by the teams who administer the same stack daily.

Why LaMeDuSe Cloud

Our own services run on Kubernetes in our European datacenters: every problem we know how to diagnose, we met on our own clusters first.

Frequently asked questions

Yes: configuration, security (RBAC, exposures, secrets), workload health, monitoring, backups. The report prioritises real risks : not a generic best-practices list.

Yes: kubeadm clusters on your servers, hyperscaler clusters, hybrid environments. Operating principles are the same everywhere : monitoring and procedures follow.

Planned cycle: release notes review, staging test, node-by-node updates with validation between each. Deprecated API versions are handled before, not after.

Yes: hands-on training on your cluster or ours, with real operations (deploy, debug, upgrade) rather than slides. The goal is your autonomy, not dependency.