This article curates 15 top GitHub repositories offering structured DevOps learning paths, hands‑on exercises, project‑based tutorials, CI/CD and automation tools, as well as quick‑reference cheat sheets to help professionals deepen their operations expertise.
Learn step‑by‑step how to transition Calico’s data store from etcd to Kubernetes, covering prerequisite checks, locking the datastore, exporting and importing data, reconfiguring calicoctl, applying the new manifests, and unlocking the store, while highlighting benefits and tips for a smooth migration.
Korifi provides a Cloud Foundry‑style abstraction layer that simplifies Kubernetes application deployment and management, while OpenCost offers comprehensive, multi‑cloud cost visibility and optimization; together they enable developers to deploy apps easily, monitor pod‑level expenses, and make data‑driven resource allocation decisions.
This article explains how to install kubeseal and its controller, create and encrypt Kubernetes Secret manifests, apply sealed secrets, and provides useful tips on API routes, custom certificates, and RBAC to securely manage secrets in a cloud‑native environment.
This guide walks through installing calicoctl, a Calico command‑line tool for managing Kubernetes network policies, covering prerequisites, manifest deployment for both Kubernetes‑ and etcd‑backed data stores, verification commands, and practical tips for a smooth setup.
This article presents a comprehensive overview of building an enterprise‑level LLMOPS platform—including concept definitions, the relationship between LLMOPS, MLOps and intelligent agent platforms, four development tiers, architecture layers, core technical concerns, deployment options, and the benefits of cloud‑native AI development.
This article introduces Fabric8 Kubernetes Client's log APIs, demonstrates how to stream pod logs with watchLog, explains periodic log pulling with sinceSeconds, compares three deduplication strategies, and provides Java implementations using LinkedHashMap and LRU caches to reliably process Kubernetes logs.
This guide walks through preparing two CentOS 7.9 servers, installing Docker and Kubernetes 1.19 components, initializing a master node, joining a worker node, and validating the cluster with a sample Nginx deployment, including common troubleshooting tips.
This guide explains how to store Kubernetes event data in Elasticsearch, configure Logstash and Ruby filters for timestamp correction, and create a Grafana dashboard to visualize and analyze cluster events for improved monitoring and troubleshooting.
This guide walks through a complete one‑click Jenkins pipeline that pulls Spring Cloud source code from Git, builds it with Maven, packages the JAR into a Docker image, pushes the image to a registry, and finally deploys or updates the service on Kubernetes, covering SSH‑key setup, pipeline scripting, and Kubernetes resource definitions.
This article shares a candidate's interview experience at McDonald's China Technology R&D Center, detailing salary expectations, work schedule, and an extensive technical Q&A covering IoC/DI, MyBatis, JVM memory and garbage‑collection algorithms, MySQL storage engines, concurrency, locking, RPC, HTTPS, Docker/Kubernetes commands, and Git workflows, while also including some promotional material.
This article provides a comprehensive overview of Kubernetes, covering its cloud‑native architecture, core components such as API Server, Scheduler, Controller Manager, etcd, kubelet and kube‑proxy, and explains the workflow that enables automated deployment, scaling and management of containerized applications.
OpenKruise 1.8, the latest CNCF‑incubated cloud‑native automation suite, introduces in‑place vertical pod autoscaling, native StatefulSet volume expansion, AI‑aware WorkloadSpread, serverless probe support, sidecar gray‑release capabilities, and a Helm pre‑delete safety hook, all backed by detailed YAML examples and future roadmap.
This guide explains how to use the Kubernetes Resource Orchestrator (Kro) to define a reusable Resource Graph Definition for WordPress, install Minikube and Kro, and deploy multiple WordPress instances on a local Kubernetes cluster.
The article explains how the vivo Internet Big Data team containerized offline Spark jobs and deployed them with the Spark Operator on a mixed online‑offline Kubernetes cluster, using elastic scheduling and resource‑over‑subscription to boost CPU utilization by 30‑40% and handle over 100,000 daily tasks.
Learn step‑by‑step how to deploy the Elasticsearch‑exporter via Helm, configure Prometheus to scrape its metrics, and visualize them in Grafana, enabling comprehensive monitoring of Elasticsearch clusters for performance, health, and early issue detection in Kubernetes environments.
This article explains the key differences between K3s and standard Kubernetes, outlines why K3s is a lightweight distribution, and provides step‑by‑step instructions for installing K3s, accessing the cluster, adding nodes, and deploying services with examples and command‑line snippets.
This article presents a step‑by‑step guide for deploying and optimizing large‑language‑model inference across multiple GPU‑enabled nodes using ACK Gateway with Inference Extension, vLLM’s tensor‑ and pipeline‑parallel techniques, and Kubernetes resources such as LeaderWorkerSet, PVCs, and custom routing policies, followed by performance benchmarking and analysis.
This article introduces k8m, a lightweight AI‑enhanced console for Kubernetes that simplifies cluster management, installation, configuration, and daily operations, while offering features such as YAML auto‑translation, AI‑driven event and log diagnostics, command generation, multi‑cluster support, and role‑based access control.
This article explores the Model Context Protocol (MCP), the emerging “USB‑C” for AI, detailing its core advantages, implementation with Kubernetes, a six‑layer cloud‑native architecture, practical code examples, and developer guidelines for building AI‑powered, secure, and scalable services.
This article explains the challenges of live‑migrating KubeVirt virtual machines, how Kube‑OVN addresses network‑bridge limitations and IP changes, provides the required VM annotation, step‑by‑step migration commands, and details the multi‑stage migration process that keeps network interruption under 0.5 seconds with no TCP break.
This guide explains how Alibaba Cloud's ACK One registered cluster provides multi‑region serverless GPU compute scheduling, addressing AI workload elasticity by using region‑specific labels, ResourcePolicy, and the ack‑co‑scheduler to automatically balance resources across regions.
This article reviews nine practical container‑monitoring solutions—from Last9 and Prometheus to Dynatrace and Elastic Observability—detailing their key features, pricing, and why developers prefer them, and then offers comprehensive best‑practice guidance for metrics, tagging, alerts, and advanced observability strategies in Kubernetes‑driven cloud‑native deployments.
This guide explains how to set up HAProxy monitoring by configuring a Prometheus exporter, adding HAProxy targets to Prometheus, verifying metric collection, and visualizing the data in Grafana with a ready-made dashboard, ensuring reliable and performant services.
This article provides a detailed tutorial on Apollo, Ctrip’s open‑source distributed configuration center, covering its core concepts, features, model, four‑dimensional management, client design, deployment architecture, high‑availability considerations, step‑by‑step project creation, Spring Boot integration, Kubernetes deployment, and practical testing procedures.
This guide explains how to upgrade a Kubernetes cluster from v1.30.0 to v1.30.1 without service interruption by backing up etcd, checking health, planning the rollout, upgrading master nodes and Calico, and using rolling updates and Istio canary releases for seamless application migration.
This guide demonstrates how to use the Fabric8 OpenShift client DSL in Java to initialize an OpenShift client, create and manage resources such as DeploymentConfig, Route, BuildConfig, Project, ImageStream, and various policies, and perform listing and deletion operations with code examples.
This article explains how to use the Kubernetes Java client to create, approve, and deny CertificateSigningRequests, work with SharedInformers, list and delete resources with ListOptions and DeleteOptions, watch resources, retrieve logs, serialize objects to YAML, and run Pods, providing practical code examples and best‑practice recommendations.
The article examines three modern, cloud‑native and open‑source methods for deploying PostgreSQL—using the CloudNativePG operator on Kubernetes, leveraging Korifi’s self‑service platform, and adopting Neon’s compute‑storage separation—highlighting trends toward cloud‑native infrastructure, self‑service, and open‑source SaaS alternatives.
This article demonstrates how to use the Kubernetes Java client to retrieve metrics, manage resources, work with custom resource definitions, and operate both typed and untyped APIs, providing code examples for creating, listing, updating, deleting, and watching Kubernetes objects.
This article explains Kubernetes cluster security mechanisms, covering authentication methods, authorization strategies including RBAC, admission‑control plugins, service accounts, kubeconfig, and resource‑quota configurations to protect the API server and control access to cluster resources.
This article compares Spring Boot and Quarkus by outlining their architectures, running a reactive‑API benchmark with JMeter and VisualVM, presenting startup, build‑time, memory, CPU and response‑time results for JVM and native images, and offering a step‑by‑step guide for migrating Spring developers to Quarkus with code examples.
This guide walks you through enabling Kubernetes in Docker Desktop on Windows or macOS, covering prerequisite setup, configuring registry mirrors, loading required images via a PowerShell script, activating the K8s service, and accessing the Kubernetes Dashboard for cluster visualization.
This guide walks through enabling Kubernetes auditing, configuring the API server and audit policy, collecting logs with Filebeat, forwarding them via Logstash to Elasticsearch, and visualizing the audit data in Kibana, providing a complete cloud‑native logging pipeline.
This guide explains how Alibaba Cloud ACK Backup Center enables data protection, backup, and cross‑cluster migration of Kubernetes Persistent Volumes by leveraging the Data Protection feature, illustrating configuration steps, backup and restore workflows, and practical YAML examples.
AIOps leverages AI, big‑data analytics, and automation to address the growing complexity of campus IT operations, offering intelligent anomaly detection, automated root‑cause analysis, resource optimization, smart incident response, and AI‑enhanced security, as demonstrated in the Service One platform.
This guide shows how to use the Fabric8 Kubernetes Java client to load, create, apply, list, watch, and delete core Kubernetes objects such as EndpointSlice, PersistentVolumeClaim, PersistentVolume, NetworkPolicy, PodDisruptionBudget, and various RBAC resources, with complete code examples for each operation.
This guide walks you through setting the download region, installing KubeKey and required dependencies, generating a configuration file, creating a single‑node or multi‑node Kubernetes cluster with containerd, and verifying the deployment using kubectl, all with clear command examples and screenshots.
This article compares Spring Boot and Quarkus by describing their architectures, presenting a reactive test application that uses PostgreSQL, detailing a JMeter performance test plan, and analyzing results such as startup time, build size, CPU, memory, and response latency to help developers decide when to migrate from Spring Boot to Quarkus.
This guide demonstrates how to use the Fabric8 Java client to create, retrieve, update, list, watch, and delete common Kubernetes resources such as Job, CronJob, Namespace, ServiceAccount, Ingress, StatefulSet, and DaemonSet, providing code snippets for each operation.
This guide walks you through setting up a Kubernetes cluster, building and pushing a custom Nginx Docker image, creating Deployment, Service, and Ingress resources, and verifying external access to the frontend application.
Kustomize, built into kubectl, lets you declaratively manage Kubernetes YAML by organizing base resources, dynamically generating ConfigMaps and Secrets, applying transformers for environment‑specific tweaks, and optionally validating output, enabling a clean Base + Overlay workflow that reduces duplication and simplifies multi‑environment configuration.
This guide walks you through deploying the Kubernetes Event Exporter, packaging its Helm chart and Docker image, configuring Kafka TLS secrets, setting up Logstash to ingest events and forward them to Elasticsearch, creating an index template, and verifying the end‑to‑end pipeline.
JD Logistics transformed its one‑stop self‑service analytics platform, UData, by migrating from an integrated storage‑compute architecture to a storage‑compute separated design powered by StarRocks, achieving sub‑10‑second P95/P99 query latency, reducing storage costs by 90%, and cutting compute expenses around 30% while supporting massive data volumes.
This article details Kuaishou's migration of massive Redis clusters to Kubernetes using the KubeBlocks Operator, covering architecture, multi‑layer management requirements, federated cluster deployment, custom controllers, performance and stability considerations, and the resulting operational benefits.
This article explains the concept of canary (gray) releases, shows how to set up separate production and canary environments on Kubernetes, configure traffic splitting via Ingress annotations or headers, and automate the whole process with Argo Rollout, including detailed YAML examples and verification commands.
This guide walks you through installing Logstash on Kubernetes using Helm, configuring secure Kafka and Elasticsearch connections, setting resource limits, and verifying the deployment, enabling efficient real‑time collection, filtering, and indexing of container logs in a cloud‑native environment.
Chaos engineering, introduced by Netflix in 2011 to proactively inject failures and test system resilience, has evolved over the past decade into a widely adopted practice integrated with SRE, automation, AI, and Kubernetes, offering best‑practice guidelines and future trends for improving distributed system reliability.
This guide demonstrates how to use the Fabric8 Kubernetes Java client to load, create, retrieve, update, scale, watch, and delete ReplicationController, ConfigMap, and Secret resources, providing complete code examples and step‑by‑step commands for managing these objects across namespaces in a Kubernetes cluster.
This article provides a step‑by‑step guide to creating a Jenkins CI/CD pipeline for Java applications, covering environment setup, required plugins, project structure, CI stages such as code checkout, dependency installation, testing, SonarQube scanning, Docker image building and pushing, as well as CD stages including Helm chart creation, deployment, health checks, rollback, and maintenance‑window management.
This guide shows how to use nsenter to enter a container's network namespace for debugging, log into Kubernetes nodes via privileged pods, deploy a DaemonSet for persistent access, and compare nsenter with the newer kubectl debug temporary container approach.
This article demonstrates how to initialize a Kubernetes Java client, configure it with default or custom kubeconfig, and provides comprehensive DSL examples for managing Pods, Services, Deployments, ReplicaSets, including creation, listing, updating, watching, port forwarding, and cleanup, with full code snippets throughout.
KubeDoor 1.0 introduces a new architecture for unified multi‑Kubernetes monitoring, offering components for master and agent, flexible deployment options, Helm‑based installation, configurable storage and alerting settings, and detailed guidance on integrating with existing Prometheus/VictoriaMetrics setups while providing automatic peak‑usage data collection.
Monitoring Kubernetes is essential to detect resource contention, component failures, and network issues; it involves tracking core component metrics such as API server latency, etcd write times, scheduler delays, as well as node‑level CPU, memory, disk, and network statistics, pod health, and custom application metrics exposed via Prometheus exporters for comprehensive observability.
This guide explains why an EKS cluster can fail to provision EBS volumes due to a missing OIDC provider, describes the role of the aws_iam_openid_connect_provider resource, and provides step‑by‑step Terraform code to create the provider, configure IAM roles, and verify the fix.
This article demonstrates how to use the Python Kubernetes client to programmatically restart deployments, scale them, execute commands inside pods, apply node taints, retrieve cluster metrics, and convert between YAML/JSON and client objects, providing practical code examples for cloud‑native automation.
This guide explains how to deploy large language model inference services on a GPU-enabled Kubernetes cluster, configure ACK Gateway with AI Extension for intelligent routing and load balancing, and perform gray releases for both LoRA fine‑tuned models and base models such as QwQ‑32B and DeepSeek‑R1, including step‑by‑step commands and validation procedures.
This guide walks through configuring three Ubuntu servers, installing KubeKey, creating a Kubernetes v1.28.8 cluster with HAProxy load balancing, deploying a sample nginx workload, and verifying the installation using kubectl and curl, providing all necessary commands and configuration details for a successful deployment.
Scaling Kubernetes across dozens or hundreds of clusters requires standardized core services—networking, security, observability, and automation—so organizations should adopt templated configurations, GitOps tools, centralized monitoring, and automated certificate management to reduce complexity, improve security, and lower operational overhead.
This guide explains what the Kubernetes Dashboard is, outlines its key features, and provides step‑by‑step instructions using Helm to install, access, and secure the dashboard for visual cluster management and monitoring.
When using AWS EKS API authentication, many users encounter the “the server has asked for the client to provide credentials” error despite having AdministratorAccess, because the newer API mode requires explicit Access Entries for each IAM identity, a detail often missed in documentation and troubleshooting.
This tutorial demonstrates how to set up a local KinD cluster, configure authentication, use raw curl commands, and employ the official Kubernetes Python client to list pods, create deployments, watch events, and manage RBAC, providing a complete guide for automating Kubernetes operations with Python.
This guide demonstrates how to deploy the QwQ‑32B large language model on an Alibaba Cloud ACK cluster, configure OSS storage, enable the ACK Gateway with AI Extension, set up InferencePool and InferenceModel resources, and benchmark intelligent routing versus standard gateway routing, revealing latency and throughput improvements.
When a Kubernetes cluster grows, many teams expect faster performance, yet scaling often becomes slower due to hardware limits, network congestion, data‑sync overhead, load‑balancing misconfigurations, and component bottlenecks, and this article explains each cause and offers concrete optimization strategies.
This guide walks through checking the system environment, installing the NVIDIA Docker plugin, configuring Docker to use the NVIDIA runtime, verifying GPU access with Docker, deploying the NVIDIA device plugin on a Kubernetes cluster, and running GPU‑accelerated workloads in pods.
This guide walks you through installing Portainer, an open‑source Docker and Kubernetes management UI, checking system and Docker versions, running the Portainer server and agent containers, and accessing the web interface to manage local and remote container environments.
Quarkus, a Kubernetes‑native Java framework built for GraalVM and HotSpot, delivers millisecond startup, low memory usage, developer‑friendly features, and seamless integration with cloud‑native platforms, making it ideal for microservices, serverless, and modern cloud applications.
This guide walks through setting up a MySQL master‑slave replication cluster on Kubernetes using a StatefulSet, local persistent volumes, delayed binding StorageClass, ConfigMap, Secret, and Services, then verifies replication and demonstrates horizontal scaling of slave nodes.
This guide explains Kubernetes Service types, the role of MetalLB in providing LoadBalancer functionality for bare‑metal clusters, step‑by‑step installation, configuration of address pools, testing with a sample service, integration with Ingress, and an overview of the Calico network plugin for pod isolation.
Kubernetes 1.24 removed the Docker shim, prompting users to adopt Containerd, and this article compares Docker and Containerd commands, logs, configuration differences, and CNI networking, highlighting how Containerd interacts directly via CRI and reduces bugs.
This article compares Spring Boot and Quarkus across architecture, startup speed, memory usage, and native image support, presents a JMeter‑based performance test suite, shares migration tips for Spring developers, and provides concrete Java code examples for building reactive microservices on both frameworks.
This curriculum outlines a 25‑week advanced Java engineering program covering performance optimization, JVM internals, concurrency, distributed storage, MySQL and NoSQL databases, Docker, Kubernetes, microservices, Spring framework deep dives, Nginx, Elasticsearch, Redis, messaging systems, CI/CD tools, and hands‑on project implementation to build high‑performance, scalable backend systems.
This article provides a comprehensive overview of release engineering, covering branch models, naming conventions, merge processes, Git commit standards, CI/CD stage design, environment isolation, artifact management, product delivery steps, deployment strategies, and rollback procedures to ensure reliable software releases.
This guide walks you through installing ArgoCD on a Kubernetes cluster, creating a Helm chart, defining ArgoCD Application manifests, pushing resources to a Git repository, and using the ArgoCD UI to deploy, sync, and update applications, including version and replica changes via GitOps.
Argo Workflows is an open‑source, container‑native engine that runs on Kubernetes via Custom Resource Definitions, letting users declaratively define complex, step‑or DAG‑based pipelines—including CI/CD, data processing, and machine‑learning jobs—through reusable templates, with a server UI, controller, and pod architecture monitored by Prometheus.
Fault injection testing deliberately introduces failures into a system to assess its resilience, helping identify weak points, improve retry and timeout mechanisms, and ensure robust operation across software, protocol, and infrastructure layers, with practical guidance on processes, tools, and Kubernetes-specific practices.
This article details the challenges of traditional middleware operations, explains how Kubernetes and Operators were leveraged to build a unified, visual, and automated platform that standardizes, automates, and visualizes multi‑cloud resource management, and reports the significant efficiency, cost, and safety gains achieved across dozens of clusters.
This article explains how to use Alibaba Cloud Service Mesh (ASM) traffic‑scheduling suite to implement rich traffic‑control scenarios such as per‑user rate limiting, request queuing and priority scheduling in a Kubernetes environment, providing step‑by‑step deployment, configuration and verification instructions.
This article provides a comprehensive overview of Kubernetes fundamentals, covering core control‑plane and node components, key object differences such as Pod vs Deployment, Service types, ConfigMap vs Secret, scheduling, health checks, scaling, security, storage, and troubleshooting techniques.
This guide walks you through the prerequisites, Helm chart acquisition, private Harbor upload, TLS secret creation, detailed Helm values configuration, and final deployment and verification steps to set up a secure, production‑ready Kibana monitoring platform on a Kubernetes cluster.
This guide walks you through using Alibaba Cloud Container Compute Service (ACS) to provision GPU resources, prepare the QwQ-32B model, configure persistent storage, deploy the model with vLLM, set up OpenWebUI, verify the service, and optionally benchmark its performance, all with detailed commands and YAML examples.
The article explains why nvidia-smi cannot display GPU processes when run inside a container, analyzes the underlying pid‑namespace isolation and kernel‑level restrictions, and provides three practical solutions—including using hostPid, custom kernel interception modules, and the nvitop tool—plus a workaround for gpu‑operator deployments.
This guide explains how to deploy the QwQ-32B large language model using vLLM on an Alibaba Cloud ACK Kubernetes cluster, configure storage, set up OpenWebUI, enable ACK Gateway with AI Extension for intelligent routing, and benchmark the inference service performance.
This article explains Kubernetes StatefulSets, covering their core concepts, guarantees such as stable network IDs and persistent storage, the controller’s components, deployment workflow, typical use cases, best‑practice recommendations, and a detailed comparison with Deployments to help you manage stateful workloads effectively.
This article explains the fundamentals, components, workflow, configuration, best practices, and comparison with HPA for Kubernetes Vertical Pod Autoscaler (VPA), helping readers efficiently tune pod resources and improve cluster utilization.
This article explains common Kubernetes DNS resolution failures, both for external domains and internal service discovery addresses, and provides a step‑by‑step troubleshooting workflow that includes checking CoreDNS, examining resolv.conf, adjusting DNS settings, and recreating CoreDNS when necessary.
This guide explains what Portainer is, compares its Community and Business editions, details its core architecture, provides step‑by‑step installation using Docker, Docker‑Compose, and Docker‑Stack, and demonstrates key features such as dashboards, container, image, service, volume, and user management for Docker and Kubernetes environments.
The article introduces the Shift‑Down Security model for Kubernetes, explaining how moving security controls into the platform complements Shift‑Left practices, reduces vulnerabilities and configuration errors, and enables collaborative, automated, and adaptive protection across development, operations, and security teams in cloud‑native environments.
The Beidou Operations Management Platform, created by vivo’s Internet Server team, unifies management of over twenty Kubernetes clusters and tens of thousands of nodes, automates scaling, inspections, event collection, and Helm‑based application deployment, achieving more than 90% UI‑driven operations and dramatically improving stability and operational efficiency.
This article describes how JoinQuant built a cloud‑native quantitative research platform on Alibaba Cloud, identified performance, cost, data‑management, and security challenges, and solved them with Fluid’s JindoRuntime data‑caching, elastic scaling, and Python‑driven workflows, achieving dramatic speed and cost improvements.
This guide explains common Kubernetes DNS problems—including failure to resolve external domains, inter‑pod service discovery addresses, and related impacts on applications like Nginx reverse proxies—and provides step‑by‑step troubleshooting procedures such as checking CoreDNS, inspecting resolv.conf, and customizing dnsPolicy and dnsConfig in pod specifications.
This article explains the core principles, advantages, suitable scenarios, and step‑by‑step configuration of Calico's BGP mode, showing how it delivers high‑performance, scalable, and secure networking for large Kubernetes deployments.
This article explains Kubernetes NetworkPolicy concepts, syntax, and practical use cases, providing step‑by‑step YAML examples that show how to deny all traffic, allow intra‑namespace communication, restrict by labels, namespaces, IP ranges, and specific ports, plus key considerations for deployment.
The Koordinator v1.6 release introduces a suite of innovations—including GPU topology‑aware scheduling, end‑to‑end GPU & RDMA joint allocation, strong GPU isolation, differentiated GPU scoring, fine‑grained resource reservation, mixed‑workload QoS, and extensive scheduler and rescheduler optimizations—to efficiently manage heterogeneous resources in Kubernetes clusters for AI and high‑performance computing workloads.
NAVER migrated its massive analytics platform from ClickHouse to StarRocks, achieving dramatic improvements in multi‑table JOIN performance, real‑time aggregation speed, and horizontal scalability while simplifying data integration across heterogeneous sources on a Kubernetes‑based architecture.
This guide walks Kubernetes administrators through the full lifecycle of Process Exporter—from lightweight deployment and RBAC setup, through Prometheus Operator integration and Grafana dashboard creation, to detailed configuration and alerting—enabling precise process‑level monitoring and rapid root‑cause analysis.
This article explains how to build a comprehensive observability stack for Kubernetes APIServer using Prometheus metrics, access‑log analysis, SPL‑driven time‑series generation, anomaly detection, root‑cause drill‑down, and OpenTelemetry tracing to quickly locate and resolve service disruptions.
Cultured Code’s case study shows that replacing a Python 2 application with a Swift‑based service running on AWS‑hosted Kubernetes increased average response speed fourfold while reducing compute costs to one‑third, highlighting the appeal and challenges of using Swift for backend development.
This article examines a recurring Kubernetes node NotReady issue where nodes become ready for only three minutes after a kubelet restart, detailing the underlying PLEG mechanism, component interactions, and diagnostic steps to resolve the problem.
This article explains how to combine online services and offline tasks within a single Kubernetes cluster using offline‑online hybrid deployment, detailing its benefits such as cost savings and higher resource utilization, and walks through practical implementation methods like CronJobs, HPA, priority classes, node affinity, custom schedulers, and the open‑source Koordinator project, while also addressing associated challenges.
