What is Kubernetes? The reality of Day-2 enterprise fleet orchestration

AMLKey points:

• Standardize multi-cloud fleets: Move beyond single-cluster provisioning to global intent-based abstraction across AWS, GCP, and on-premises environments.
• Automate Day-2 operations: Eliminate manual YAML configuration drift for upgrades, network policies, and role-based access control (RBAC).
• Enforce FinOps governance: Implement agentic automation to reclaim idle cluster resources and control multi-cluster costs automatically.

What is Kubernetes? 

Kubernetes is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. Originally developed by Google, it serves as the foundational operating system for cloud-native infrastructure.

For platform engineering teams, Kubernetes abstracts the underlying compute instances (bare metal or virtual machines) into a unified resource pool. Instead of manually configuring individual servers, engineers declare the desired state of an application, and the Kubernetes control plane continuously monitors and reconciles the infrastructure to match that intent.

Understanding Kubernetes architecture is a mandatory starting point, but it barely scratches the surface of actual production deployments.

Core Kubernetes architectural components

To manage fleets at scale, platform architects must deeply understand the control plane and worker node mechanics.

The control plane

The control plane acts as the brain of the cluster, making global decisions about routing, scheduling, and scaling.

• kube-apiserver: The front end of the control plane. All administrative commands and cluster communications route through this API.
• etcd: A highly available key-value store containing all cluster configuration data and state.
• kube-scheduler: Watches for newly created Pods with no assigned node and selects a node for them to run on based on resource requirements.
• kube-controller-manager: Runs controller processes (like the Node controller and ReplicaSet controller) to regulate cluster state.

Worker nodes

Nodes execute the containerized workloads.

• kubelet: An agent running on each node ensuring containers are running in a Pod according to the declarative specifications.
• kube-proxy: Maintains network rules on nodes, allowing network communication to your Pods from inside or outside the cluster.

Day 2 Operations & Scaling Playbook

Go beyond ‘it works’. Learn how to run Kubernetes reliably, securely, and cost-effectively at scale using proven platform engineering patterns.

Download the full PDF!

The 1,000-cluster reality: moving from provisioning to fleet orchestration

Provisioning an EKS cluster via Terraform is straightforward. A standard declaration takes less than fifty lines of HCL:

Terraform
# Standard EKS provisioning is just the beginning
module "eks" {
  source          = "terraform-aws-modules/eks/aws"
  version         = "20.0.0"
  cluster_name    = "enterprise-fleet-01"
  cluster_version = "1.30"
  vpc_id          = module.vpc.vpc_id
  subnet_ids      = module.vpc.private_subnets
  
  eks_managed_node_groups = {
    general = {
      instance_types = ["m5.large"]
      min_size       = 2
      max_size       = 10
    }
  }
}

However, in enterprise environments, the operational reality changes drastically at scale. When your infrastructure footprint expands to dozens or hundreds of clusters spanning Amazon EKS, Google Kubernetes Engine (GKE), and on-premises environments, fundamental Kubernetes mechanics become operational bottlenecks.

A platform engineer updating a scaling policy or patching a critical vulnerability cannot manually execute kubectl commands across 100 clusters. Without an abstraction layer, teams suffer from localized security vulnerabilities, uncontrolled cloud waste, and severe Day-2 operations paralysis.

Why manual YAML fails at scale

In standard Kubernetes operations, engineers define desired states using YAML manifests. While functional for a single application, manual YAML management creates severe toil for enterprise SRE teams.

Consider a standard application deployment requiring a Pod specification, a Service, and an Ingress controller. If a platform team needs to deploy this across both AWS and GCP, the configuration instantly drifts due to provider-specific annotations.

YAML
# The configuration drift problem at scale
# GKE (GCP) requires specific class annotations
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: enterprise-api-ingress
  annotations:
    kubernetes.io/ingress.class: "gce"
spec:
  rules:
  - http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: enterprise-api
            port:
              number: 80

---
# EKS (AWS) requires entirely different annotations for the ALB
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: enterprise-api-ingress
  annotations:
    kubernetes.io/ingress.class: "alb"
    alb.ingress.kubernetes.io/scheme: "internet-facing"
    alb.ingress.kubernetes.io/target-type: "ip"

Duplicating and maintaining these provider-specific configurations across thousands of microservices leads to deployment bottlenecks. It also forces teams to rely on fragmented container management tools that fail to offer unified fleet governance.

🚀 Real-world proof

Alan struggled with sluggish scaling and a fragmented multi-cloud setup, demanding automated infrastructure abstraction.

Agentic fleet management with Qovery

To scale operations securely, enterprises must implement an intent-based abstraction layer over raw Kubernetes primitives. Using a modern Kubernetes management platform, you can orchestrate multi-cloud fleets without drowning in YAML.

Qovery acts as an agentic control plane, centralizing multi-cloud fleet management. Instead of writing provider-specific YAML for EKS or GKE, or constantly tweaking custom Karpenter configurations manually across clusters, developers declare application intent in a single .qovery.yml file. Qovery translates this intent, enforcing global RBAC, cost governance, and security policies automatically.

YAML
## .qovery.yml - Intent-based abstraction
# This single configuration deploys identically across EKS and GKE fleets
application:
  enterprise-api:
    build_mode: DOCKER
    cpu: 2000m
    memory: 4096MB
    ports:
      - 8080: true
    auto_preview: true # Agentic creation of ephemeral environments on PRs

By removing manual configuration, Qovery allows platform teams to shift focus from infrastructure troubleshooting to strategic FinOps and architectural scaling.

Managing 100+ K8s Clusters

From cluster sprawl to fleet harmony. Master the intent-based orchestration and predictive sizing required to build high-performing, AI-ready Kubernetes fleets.

Access the Strategic Guide!

FAQs

What are Day-2 operations in Kubernetes?

Day-2 operations refer to the ongoing maintenance of a Kubernetes environment after initial provisioning. This includes cluster upgrades, security patching, scaling configurations, cost management (FinOps), and observability across multi-cloud fleets.

How does Kubernetes handle multi-cloud fleet management?

Natively, Kubernetes does not manage fleets across multiple cloud providers; it manages single clusters. To operate fleets across AWS (EKS) and GCP (GKE) simultaneously, enterprises require an agentic control plane to abstract provider-specific configurations and enforce global governance.

Why is manual YAML management a risk for platform engineering?

Relying on manual YAML at scale causes configuration drift, deployment bottlenecks, and security vulnerabilities. Provider-specific requirements (like differing Ingress annotations for AWS vs. GCP) force engineers into repetitive toil rather than focusing on platform automation.