This article explains how Kubernetes serves as a cloud‑native middle layer that abstracts servers and application services, detailing its control‑plane and node components, the role of pods, containers, and the kubectl tool, and walks through a typical service deployment and request flow.
This guide explains the architecture of VictoriaMetrics, details a step‑by‑step Helm deployment on a Kubernetes cluster, covers data collection from multiple clusters, storage persistence, Grafana dashboard setup, and alerting configuration using vmalert and webhook integration.
The article examines how CMDB can be combined with cloud‑native container architectures by leveraging Kubernetes init containers, lifecycle hooks (PostStart and PreStop), and an event‑monitoring‑to‑MQ pipeline, discussing the technical rationale, implementation details, advantages, and challenges of each approach.
Tracing the evolution of container technology—from the 1979 Unix chroot command, through Linux namespaces and cgroups, to LXC, Docker, and Kubernetes—this article explains each milestone’s role in isolation, resource control, and cloud-native orchestration, highlighting the shift toward managed cloud container services.
Bilibili migrated its Elasticsearch and ClickHouse clusters to Kubernetes using custom operators, CRDs, LVM‑based local storage, MacVLAN networking, and pod anti‑affinity, achieving higher resource utilization, isolation, and automation that cut server count, reduced latency spikes, and lowered operational costs dramatically.
The article explains that the kube‑apiserver’s built‑in LoopbackClient certificate expires after one year, causing API server failures in long‑running clusters, and examines the community’s support policies, recent Alibaba Cloud changes, and ongoing discussions about introducing a true Kubernetes LTS.
After four years running infrastructure at a fast‑growing startup, the author reviews almost every major decision—from choosing AWS over GCP and adopting EKS, RDS, and Redis, to automating post‑mortems with Slack bots, standardising IaC with Terraform and GitOps, and evaluating SaaS tools like DataDog, PagerDuty, and Notion—highlighting the benefits, regrets, and practical lessons learned.
This article explains how to combine Nvidia GPUs with Kubernetes, covering CUDA toolkits, device plugins, GPU virtualization techniques such as Time‑Slicing, MPS and MIG, and advanced scheduling options like Volcano, while also outlining practical deployment steps and performance considerations.
This tutorial explains how to install and configure Apache Flink in three deployment modes—Standalone, Hadoop YARN, and Kubernetes—covering node preparation, configuration files, package distribution, job submission, and monitoring through the Flink Web UI, with full command‑line examples and code snippets.
After fully containerizing their platform, the team tackled front‑line development scaling challenges by designing a custom elastic‑scaling solution that combines dual‑threshold and timed scaling, integrates hybrid‑cloud ClusterAutoScale, consolidates middleware resources, and implements a comprehensive K8s observability stack, delivering over 30% additional compute capacity and near‑perfect scaling reliability.
This article explains how to use Istio’s sourceLabels feature to achieve full‑chain gray deployments across multiple microservice versions, providing detailed configuration examples, deployment steps, testing procedures, and an analysis of its advantages and limitations.
This guide explains why multi‑cluster deployments are needed for high‑availability, describes Istio's flat and non‑flat network models with single or multiple control planes, and provides step‑by‑step scripts to create Kind clusters, install MetalLB, configure root CAs, deploy Istio, set up gateways, and verify regional load balancing and failover.
This article explains the roles of maxUnavailable and maxSurge in Kubernetes rolling updates, demonstrates their impact on update speed and service stability through multiple practical cases, and provides best‑practice guidelines for configuring these parameters to achieve smooth, reliable deployments.
This article explains the concept of graceful shutdown, outlines the standard steps, and presents detailed Kubernetes, Spring Boot, and Nacos case studies, followed by optimization techniques, code examples, and practical recommendations for handling MQ, scheduled tasks, and traffic control during service termination.
This article details how to transition a Dubbo 3.0 microservice architecture to an Istio service mesh on Kubernetes, covering code modifications, deployment configurations, sidecar injection, traffic management policies, and verification steps with practical YAML examples and log analysis.
This article explains how to configure Kubernetes Horizontal Pod Autoscaler (HPA) for automatic pod scaling, covering core concepts, metric selection, and two detailed YAML examples that demonstrate scaling based on CPU utilization and custom data‑processing rates.
This guide shows how to combine GitHub Codespaces, Docker‑in‑Docker, and KinD to create a fully functional, cloud‑based Kubernetes development environment that eliminates local setup, improves accessibility, and reduces costs, while providing step‑by‑step instructions and essential commands for deployment and testing.
This guide explores fifteen practical Kubernetes scheduling scenarios—from basic node selectors to custom schedulers and pod priority—providing detailed YAML configurations, code snippets, and best‑practice recommendations to help you optimize resource utilization, high availability, and workload placement across your cluster.
This article explains how Kubernetes supports GPU workloads for AI and machine learning, covering device plugins, pod GPU requests, oversubscription, security isolation, cloud‑provider node setup, and protecting GPU nodes from non‑GPU pods.
This article explains how the integration of sriov-network-operator and Kube-OVN automates the complex configuration and persistence of RDMA and SR‑IOV in Kubernetes, enabling high‑availability, multi‑tenant networking for AI distributed training workloads.
Zadig streamlines product delivery by offering a comprehensive version management and release process that guides engineers through creating versions, configuring environments, and executing production deployments for both K8s YAML and Helm Chart projects, enhancing transparency, control, and risk reduction.
This article provides a step‑by‑step tutorial on integrating the Apollo configuration center into SpringBoot applications, covering basic concepts, client design, environment, cluster and namespace management, Maven setup, Docker image creation, and deployment on Kubernetes for dynamic configuration updates.
This article explains how Istio automatically injects sidecar containers into Kubernetes pods, the iptables‑based traffic interception mechanism for inbound and outbound flows, and how to configure rules to exclude specific traffic from Envoy processing.
This guide explains how to configure Kubernetes Ingress Nginx to duplicate 100% of live application traffic from a production cluster to a staging cluster, enabling safe simulation testing and rapid performance troubleshooting without affecting end‑user responses.
When a Kubernetes pod repeatedly restarts, you can pinpoint the cause by inspecting events, describing the pod, and checking previous logs, then identify OOM kills caused by memory limits in the deployment.yaml and resolve it by increasing the memory limit and redeploying the pod.
This guide walks you through deploying OpenTelemetry in Kubernetes, covering the purpose of otel‑collector, installation via manifests or Helm, the three deployment patterns (No‑Collector, Agent, Gateway), running the otel‑demo, and detailed configuration of receivers, processors, exporters, connectors, extensions, and service pipelines.
This article provides a comprehensive, lightweight solution for collecting Kubernetes logs using Grafana Loki, covering its advantages, component comparison, deployment modes (All‑In‑One, microservices, bare‑metal), required configuration files, ConfigMap and PersistentVolume setup, Promtail installation, Helm deployment, and common troubleshooting steps.
Vivo’s online‑offline co‑location platform consolidates latency‑sensitive online services and batch offline workloads on shared Kubernetes nodes, using differentiated resource views, priority‑based QoS, and safety watermarks to boost CPU utilization from 13 % to 25 %, adding 20 000 cores and 50 TB memory for peak‑hour offline tasks.
This guide explains how to design and implement a unified cloud‑native serverless platform that runs seamlessly on public clouds and on‑premise IDC clusters using Alibaba Cloud ACK One, Kubernetes, and Knative, covering architecture, key components, deployment steps, and best‑practice recommendations.
This article provides a comprehensive technical overview of LiteIO, describing its core and CSI components, the complete volume lifecycle within Kubernetes, Disk‑Agent responsibilities, common implementation pitfalls, storage‑pool construction methods, and the design of the node‑disk‑controller, scheduler, and CSI modules.
After three years of hands‑on Kubernetes administration, the author shares ten practical lessons covering cloud‑hosted clusters, infrastructure‑as‑code, Helm chart usage, service mesh decisions, tool selection, resource limits, stateless design, HPA configuration, and upgrade strategies to help both newcomers and seasoned engineers manage clusters effectively.
This article explains how to measure the operations automation rate, outlines the challenges of manual ops, and provides a step‑by‑step guide to creating a coding‑based automation platform on Taishan‑Qilin, including formulas, code examples, deployment, and real‑world results.
This article explains Kubernetes container probes—Startup, Liveness, and Readiness—including their purposes, implementation methods (HTTP GET, TCP socket, exec), key configuration parameters, example YAML snippets, and practical recommendations for handling slow‑starting applications.
This article provides a comprehensive technical overview of LiteIO, describing its core and CSI components, their interactions, the complete volume lifecycle within Kubernetes, common implementation pitfalls, and configuration examples for storage pools and agents.
This guide explains how to implement a blue‑green deployment on Kubernetes with host‑ and path‑based routing, covering prerequisites, namespace creation, deployment manifests, service and ingress configuration, traffic switching, updates, verification, and rollback procedures.
This article details Kuaishou’s five‑year evolution of Flink, covering its background, production refactoring to Kubernetes, migration practices, and future improvements, highlighting architecture layers, resource management, observability, and testing strategies for large‑scale stream processing.
A Node.js service migrated to containers began experiencing intermittent timeouts and high CPU usage due to the default enableServiceLinks parameter injecting thousands of environment variables, and the analysis shows how to identify, reproduce, and resolve the issue with Kubernetes configuration and code adjustments.
This article examines the challenges of data‑intensive AI training on heterogeneous cloud‑native infrastructure and explains how the Fluid framework combined with JindoCache and KubeDL provides distributed caching, metadata acceleration, and seamless POSIX access to dramatically improve I/O performance, GPU utilization, and cost efficiency.
This article explains the challenges of manual operations, defines an automation‑rate metric, introduces the Tai‑Shan Kirin platform for self‑coded operational automation, provides step‑by‑step implementation guidance with code examples, and shares a case study demonstrating significant efficiency and stability gains.
This article explains how CoreDNS runs on a Caddy‑based HTTP/2 server in Kubernetes, how kubelet injects the cluster DNS IP into each container’s /etc/resolv.conf, and how different dnsPolicy settings (Default, ClusterFirst, ClusterFirstWithHostNet, None) affect the resolv.conf configuration, including key options and examples.
This article provides a comprehensive overview of Kubernetes, detailing its fundamental concepts, master‑worker architecture, networking model, security mechanisms, extensibility via custom resources, and an in‑depth examination of key source‑code modules such as kube‑apiserver, etcd, controller‑manager, scheduler, kubelet, and kube‑proxy, with links to the official repository.
This guide explains how to use Alibaba Cloud's ACK One platform to connect on‑premises and public‑cloud Kubernetes clusters, configure network interconnectivity, create multi‑cluster fleets, optionally deploy applications via GitOps, and manage traffic with a multi‑cluster gateway for seamless same‑city disaster recovery.
The article explains why passing tokens between microservices is a poor design, proposes exposing explicit userId parameters, describes unified authentication via an API gateway with Feign, Dubbo or Spring Boot Web implementations, compares their pros and cons, and shows how to integrate these patterns with Kubernetes and internal API path rules.
Tracing the history of containerization, this article explores how early file isolation with chroot evolved through namespaces and cgroups, leading to LXC, Docker’s lightweight application packaging, Kubernetes orchestration, and finally cloud-native services like Huawei CCE, highlighting each stage’s impact on modern software deployment.
This guide explains how to set up a Kubernetes pod to act as a Jenkins agent, covering prerequisites, deployment YAML, commands to launch and verify the pod and service, and the Jenkins UI configuration needed to connect the pod as a scalable CI/CD worker.
This article explains Kubernetes StatefulSet fundamentals, its headless service networking, access patterns, creation workflow, controller mechanics, and detailed procedures for updating, scaling, and deleting stateful pods with illustrative code examples.
Weaveworks, the company that coined the term GitOps, announced its closure due to unstable sales despite $10 million revenue, prompting industry analysis of GitOps’s commercial viability, competition with ArgoCD, and the future stewardship of the open‑source Flux project under CNCF.
This article explores multiple methods to specify custom DNS resolution inside Kubernetes containers, including editing /etc/hosts, using HostAliases, modifying the CoreDNS ConfigMap, applying custom DNS policies, and evaluating third‑party DNS plugins, with example manifests and code snippets.
This article introduces MetalLB, explains its deployment requirements, describes its Layer2 and BGP operation modes, provides step‑by‑step installation and configuration instructions for Kubernetes clusters, and demonstrates verification of the load‑balancing functionality.
This article explains the sidecar concept, compares it with SDK approaches, and provides detailed Kubernetes examples—including a log‑collection sidecar, a request‑forwarding sidecar, and an HTTP‑intercepting sidecar—complete with YAML manifests and Rust and Scala code to demonstrate implementation and deployment.
The article critiques token pass‑through for microservice authentication, explains why internal APIs should stay stateless, and presents unified authorization patterns using Spring Cloud Gateway with Feign, Dubbo, or a gateway‑less design, plus Kubernetes integration and trade‑offs.
This article explains Kubernetes Ingress fundamentals, compares major Ingress controllers such as Nginx, Kong, Traefik, HAProxy and APISIX, and details the internal architecture and Lua‑based extension points of the ingress‑nginx controller, providing a comprehensive guide for managing external traffic in cloud‑native environments.
Kubernetes events record state changes such as pod scheduling, image pulling, and failures, which can be inspected via kubectl but are retained only an hour, so tools like kube-eventer or kubernetes-event-exporter collect them for long‑term analysis, enabling monitoring of Warning types, failure reasons, and visualization through Grafana dashboards.
This guide walks through installing RabbitMQ, explaining its features and typical use cases, then details step‑by‑step deployment of a mirrored‑mode RabbitMQ cluster on Kubernetes using StatefulSets, NFS‑backed persistent storage, RBAC, and verification of cluster health and management operations.
This guide explains the concepts of IPv4/IPv6 dual‑stack networking, outlines two dual‑stack implementation methods, and provides step‑by‑step instructions to set up a Cilium‑enabled Kubernetes cluster using Kind, configure dual‑stack settings, deploy a demo app, and analyze routing behavior for both IP families.
This guide explains the background, architecture, common CRDs, installation steps, and practical usage of Prometheus‑Operator on Kubernetes, including how to create Deployments, Services, ServiceMonitors, and visualize collected metrics with Prometheus UI.
This guide shows how to use Alibaba Cloud Container Compute Service (ACS) to create a private Palworld game server with Kubernetes resources, cost‑effective serverless scaling, and optional best‑effort instances, including step‑by‑step commands and YAML configurations.
This article explains why keeping the client source IP in an Istio service mesh matters, outlines the reasons for IP loss, and provides step‑by‑step solutions for north‑south and east‑west traffic using Service settings, traffic policies, and Envoy headers.
This article details Ant Group's practical implementation of Service Level Objectives (SLO) and AIOps to achieve fine‑grained operations, covering SLO fundamentals, health‑score architecture, GitOps‑based data pipelines, error‑budget alerting, AI‑driven anomaly detection, fault localization techniques, and real‑world case studies on dashboards, Kubernetes SLOs, and emergency response workflows.
This guide explains how to use Argo Workflow on Alibaba Cloud ACK One to implement dynamic fan‑out/fan‑in DAGs, splitting large log files, running parallel map tasks, and aggregating results with a reduce step, including full YAML definitions and execution steps.
A pod in a Kubernetes cluster repeatedly restarted with exit code 137 despite staying well below its 6 Gi memory limit, prompting an investigation that uncovered the role of QoS classes, oom_score calculations, and node‑level memory pressure in the eviction process.
This guide demonstrates how to set up a Maven project with the Fabric8 Kubernetes Java client, configure minimal kubeconfig or ServiceAccount credentials, and use sample code to list namespaces, illustrating essential steps for connecting Java applications to a Kubernetes cluster with minimal configuration.
This guide shows how to deploy a cost‑effective, secure Stable Diffusion XL Turbo text‑to‑image service on an Alibaba Cloud ACK cluster using CPU‑only instances, Helm charts, and optional confidential TDX VM pools for protected inference.
This guide compiles a comprehensive set of kubectl and Docker commands for retrieving logs, sorting pods, managing secrets, cleaning resources, debugging, port forwarding, and performing cluster maintenance tasks, helping administrators streamline Kubernetes operations and troubleshoot issues effectively.
This article examines how a leading global industrial group leveraged a cloud‑native platform to design a disaster‑recovery solution that meets a sub‑2‑hour RTO and a 1‑minute RPO, detailing architecture, data‑layer strategies, middleware replication, application and access‑layer handling, and operational best practices.
This guide explains how to set up the high‑performance, cloud‑native LiteIO block storage service on a Kubernetes cluster, covering prerequisite VM preparation, kernel upgrade, Docker and Kubernetes installation, CRI configuration, LiteIO component deployment for both LVM and SPDK engines, and verification of Pods and PVCs.
Learn why ConfigMap and Secret are vital Kubernetes tools for managing non‑sensitive configuration and protecting sensitive data, explore common use cases like language settings and scaling, and follow best‑practice guidelines to secure and simplify your deployments.
The author shares how they passed the Certified Kubernetes Administrator exam with a 95 score, explains the certification’s scope, provides practical preparation tips, environment requirements, key study resources, and a concise strategy to quickly master the 17 recurring exam questions.
This article explains the internal workflow of the Kubernetes informer package in client-go, covering its architecture, key components such as Reflector, DeltaFIFO, and Indexer, and provides a step‑by‑step code example that demonstrates how informers are created, registered, started, and used to handle watch events efficiently.
This article explains why a Huawei OBS CSI plugin loses its s3fs process after a restart, causing "Transport endpoint is not connected" errors, and provides a step‑by‑step solution using client‑go to rebuild the mount and trigger kubelet remount via a liveness probe.
This article analyzes Kubernetes security threats from cloud, cluster, and container perspectives, enumerates high‑risk permissions, default privileged accounts, and insecure configurations, and provides concrete hardening steps such as least‑privilege RAM policies, etcd encryption, RBAC tightening, and workload isolation measures.
This guide compiles 100 practical kubectl commands that help you diagnose cluster information, pods, services, deployments, networking, storage, security, autoscaling, and many other Kubernetes components, providing a handy reference for effective cluster troubleshooting.
This guide explains why kubectl exec often fails under security best practices, introduces kubectl debug with ephemeral containers for root‑level troubleshooting, shows how to create and use debug containers, and outlines alternative non‑native methods and tools for inspecting live pods.
This article introduces five major open‑source storage solutions—OpenEBS, Rook, GlusterFS, Ceph, and LongHorn—explaining how each simplifies persistent data management for Kubernetes workloads while offering features such as replication, self‑healing, and multi‑node scalability.
This article reviews the OpenKruiseGame project and its dashboard, showing how cloud‑native containerization, multi‑cloud support, and automated CI/CD pipelines transform game server deployment, scaling, and management for both PvP and PvE titles.
LiteIO is an open‑source, high‑performance, cloud‑native block device service that uses NVMe‑oF and SPDK to provide point‑to‑point storage pooling, enabling efficient FinOps, serverless scaling, hot upgrades, zero‑copy I/O, snapshots, and thin provisioning for databases and applications in Kubernetes.
LiteIO is an open‑source, cloud‑native block device service that leverages NVMe‑oF and SPDK to provide high‑performance, scalable storage for Kubernetes‑based workloads, improving storage utilization and enabling FinOps‑driven cost efficiency across large‑scale production environments.
This comprehensive guide presents 200 essential Kubernetes interview questions covering fundamentals, architecture, real‑world scenarios, and advanced topics, complete with concise answers, diagrams, and practical insights to help candidates ace container orchestration interviews.
The article describes how a company implements an idle compute sharing feature for dedicated Kubernetes clusters, leveraging Karmada to allocate spare CPU and memory to offline workloads, thereby improving resource utilization, reducing costs, and outlining usage scenarios, configuration steps, technical architecture, and future plans.
Katalyst v0.4.0 introduces tidal colocation for mixed workloads, online resource overcommit, fine‑grained NUMA memory management, OOM priority enhancements, and topology‑aware scheduling, providing a comprehensive cost‑optimization solution for cloud‑native Kubernetes clusters.
This article provides a comprehensive tutorial on installing RedisInsight, configuring its environment variables, running it as a service or in Kubernetes, and using its GUI features to monitor and manage Redis instances, complete with code examples and deployment YAML.
The article details ByteDance’s Gödel Scheduler, a cloud‑native, distributed Kubernetes scheduler that unifies online and offline workloads, describing its architecture, enhanced features, performance gains, roadmap, and open‑source plans, including its multi‑instance design, optimistic concurrency, and rescheduling capabilities for improved throughput and scheduling quality.
This article details the end‑to‑end process of replacing low‑resolution SRTM data with 30‑meter ASTER elevation data, redesigning storage and access using JuiceFS, Go, and sync.Pool, and achieving sub‑millisecond latency for 1500 QPS in a Kubernetes environment.
This guide walks through setting up a fully automated CI/CD pipeline that pulls code from Git, builds it with Maven, packages the resulting JAR into a Docker image, pushes the image to a registry, and finally deploys or updates the service on Kubernetes using Jenkins pipelines and supporting scripts.
This article explains how to use Prometheus to collect, define, and alert on business‑level metrics in a Kubernetes environment, covering observability concepts, metric types, Go code examples, and scraping configurations for reliable monitoring.
The article forecasts rapid eBPF adoption across cloud‑native networking, mobile devices, and observability, highlights emerging eBPF marketplaces, discusses performance gains with NetKit and BIG TCP, predicts IPv6‑first Kubernetes clusters, AI‑assisted network troubleshooting, and the growing convergence of platform engineering and networking in 2024.
This guide explains how to use Nacos as a centralized configuration center in Spring Boot micro‑services, covering common pitfalls of static configs, best‑practice namespace/group/DataId design, dependency setup, YAML examples, security annotations, role‑based access, Dockerfile tweaks, CCE deployment, database schema, and Kubernetes manifests for test and production environments.
Batch jobs demand efficient resource use, but Kubernetes’ default scheduler struggles with large queues; Kube Queue, a cloud‑native AI suite component, introduces dedicated queues, flexible strategies, and quota management to automate scheduling, support multi‑tenant workloads, and improve cluster utilization.
This article provides a comprehensive guide to Ctrip’s open‑source Apollo configuration center, covering its core concepts, features, architecture, deployment dimensions, client design, code examples for a SpringBoot project, testing procedures, and Kubernetes deployment with Docker.
This article examines the urgent need for standardized, trustworthy computing power measurement, outlines narrow and broad measurement frameworks, and details a technical solution that integrates WASM virtual machines and blockchain with Kubernetes to achieve precise, tamper‑proof resource accounting for modern cloud‑native environments.
This article presents a comprehensive, lightweight Kubernetes log collection solution using Loki and Promtail, covering its advantages, architecture, deployment modes, detailed configuration files, Promtail setup, Grafana integration, alternative clients, Helm installation, and troubleshooting tips.
This article explains what Rancher is, how to check system and software versions, and provides a detailed step‑by‑step guide to install Docker, pull the Rancher image, run the container with proper parameters, and configure access, clusters, alerts, and custom settings.
Sealos public cloud faced massive multi‑tenant Ingress demands, security concerns, and performance bottlenecks, leading the team to systematically test Nginx, Envoy, APISIX, Cilium, Envoy Gateway, and finally adopt Higress for its stability, fast route activation, and low resource footprint.
This article examines lossless scaling techniques for high‑concurrency microservice architectures, detailing the challenges of expansion and contraction, early scaling approaches, and advanced optimizations such as delayed registration, readiness probes, eager‑load Ribbon, cache preloading, health‑check strategies, and asynchronous consumer handling to ensure high availability, performance, and cost efficiency.
This article provides a comprehensive guide to Meshery, an open‑source cloud‑native management platform, covering its architecture, deployment options, service‑mesh management, performance testing, and MeshMap visual collaboration features for Kubernetes environments.
This guide introduces RedisInsight, a powerful GUI for Redis, outlines its key features such as cluster support, visual data browsing, built‑in CLI, stream and log analysis, and provides step‑by‑step installation instructions for Linux, Kubernetes, and macOS, plus basic usage tips.
This article walks through deploying Apache APISIX and DeepFlow in a Kubernetes cluster, configuring eBPF‑based AutoTracing and OpenTelemetry integration, enabling Prometheus metrics, accessing logs and continuous profiling, and visualizing unified observability data via Grafana dashboards.
This guide introduces RedisInsight, outlines its key features, provides step‑by‑step installation on a physical server and via Kubernetes, explains environment configuration and startup, and demonstrates basic usage for monitoring and managing Redis instances through its graphical interface.
This article examines why most incidents occur during application rollout, analyzes the Kubernetes pod lifecycle for both startup and shutdown, identifies common zero‑downtime challenges, and presents concrete strategies—including active notifications, adaptive waiting, delayed registration, and readiness probes—to ensure lossless service upgrades and rollbacks.
This article explains why long‑running Kubernetes clusters can suffer memory‑leak errors and certificate expiration, and provides detailed, command‑line solutions including disabling kmem accounting, recompiling runc and kubelet, and extending certificate validity to ten years.
