Dynamic Resource Adjustment

Ever had to restart a critical database pod just to give it more memory? 🔥 For years, this has been a massive pain point in Kubernetes. A simple kubectl apply to change CPU or memory meant one thing: a restart. ❌ The Old Way: Stateless apps: Annoying. Stateful apps (databases, ML jobs): A disruptive, downtime-causing event that breaks SLOs. We all built complex, brittle workarounds. Not anymore. The In-Place Pod Resize feature (now in Beta and on-by-default in K8s 1.33+) is one of the biggest "quality of life" improvements for SREs I've seen. You can now change a pod's resource requests and limits without a restart. 🚀 Why This Is a Game-Changer: Zero-Downtime Vertical Scaling: Give that hot database pod more CPU during a spike, then scale it back down... without dropping a single connection. Smarter Resource Management: Perfect for ML pipelines (CPU-heavy ingest, memory-heavy training). You can now adjust resources on the fly. VPA Gets a Superpower: This was the missing piece for the Vertical Pod Autoscaler. VPA can now try an in-place resize first, making autoscaling stateful workloads finally viable. 💡 How It Works (The Gist): You can now define a resizePolicy for your containers: restartPolicy: NotRequired: (Ideal for CPU) The kubelet just updates the cgroups. No restart. restartPolicy: RestartContainer: (Often needed for memory) K8s gracefully restarts only that container to apply the new limits. This moves scaling from a disruptive "recreate" operation to a dynamic "update" operation. It's a massive win for reliability and efficiency. Where will you use this feature first? Let me know in the comments! 👇

QoS-based Resource Optimization - Intelligent RAN Automation Series AI-Enabled Radio Optimization One of the most interesting Open RAN use cases is QoS-based Resource Optimization. The idea is simple: radio resources are limited, traffic demand is dynamic, and not all users, services, or slices have the same priority. A static configuration may work under normal conditions, but it can fall short when congestion appears in a specific area or time window. This is where O-RAN adds value. With the SMO, Non-RT RIC, Near-RT RIC, and E2 Nodes working together, the network can move from fixed behavior to policy-driven, closed-loop optimization: 🔵The SMO collects observability data and monitors performance. 🔵The Non-RT RIC analyzes QoS-related metrics and determines when default behavior is no longer enough. 🔵Through the A1 interface, it sends policies to the Near-RT RIC. 🔵The Near-RT RIC translates those policies into near-real-time actions over E2. 🔵The E2 Node / gNB adjusts Radio Resource Management (RRM) behavior to better meet the intended service outcome. At the technical level, this use case is tightly connected to 5G Quality of Service Identifier (5QI), QoS flows, slice isolation, and PRB allocation. In practice, it can mean dynamically changing how resources are shared across users or slices so that critical services keep the required throughput, delay, or reliability even under stress. A strong example is emergency communications: if multiple video feeds compete for limited radio resources, the network can temporarily prioritize the most important feed while demoting others based on policy and service intent. What makes this powerful is not only prioritization itself, but the intelligence layer behind it: measure -> analyze -> decide -> enforce -> verify. That is why this use case fits perfectly into the broader vision of AI-enabled radio optimization in Open RAN. 𝘚𝘓𝘈 (𝘚𝘦𝘳𝘷𝘪𝘤𝘦 𝘓𝘦𝘷𝘦𝘭 𝘈𝘨𝘳𝘦𝘦𝘮𝘦𝘯𝘵): 𝘋𝘦𝘧𝘪𝘯𝘦𝘴 𝘵𝘩𝘦 𝘱𝘦𝘳𝘧𝘰𝘳𝘮𝘢𝘯𝘤𝘦 𝘨𝘶𝘢𝘳𝘢𝘯𝘵𝘦𝘦𝘴 𝘦𝘹𝘱𝘦𝘤𝘵𝘦𝘥 𝘧𝘳𝘰𝘮 𝘵𝘩𝘦 𝘯𝘦𝘵𝘸𝘰𝘳𝘬. 📎𝗥𝗲𝗹𝗮𝘁𝗲𝗱 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 𝘕𝘰𝘵𝘦: 𝘖𝘱𝘦𝘯 𝘙𝘈𝘕 𝘚𝘔𝘖 & 𝘛𝘩𝘦 𝘙𝘐𝘊 https://lnkd.in/eMiTV9rP 𝘙𝘈𝘕 𝘐𝘯𝘵𝘦𝘭𝘭𝘪𝘨𝘦𝘯𝘵 𝘊𝘰𝘯𝘵𝘳𝘰𝘭𝘭𝘦𝘳 (𝘙𝘐𝘊): 𝘗𝘰𝘸𝘦𝘳𝘪𝘯𝘨 𝘵𝘩𝘦 𝘉𝘳𝘢𝘪𝘯 𝘰𝘧 𝘖𝘱𝘦𝘯 𝘙𝘈𝘕 https://lnkd.in/eihnWNTt 𝘕𝘰𝘵𝘦𝘴 𝘰𝘯 𝘕𝘰𝘯-𝘙𝘛 𝘙𝘐𝘊 https://lnkd.in/eyHkzgHr 𝘕𝘰𝘵𝘦𝘴 𝘰𝘯 𝘕𝘦𝘢𝘳-𝘙𝘛 𝘙𝘐𝘊 https://lnkd.in/ezwF4iGx 𝗖𝗵𝗲𝗰𝗸 𝗼𝘂𝘁 𝗺𝘆 𝗻𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿 𝑆𝑒𝑟𝑔𝑖𝑜'𝑠 𝑇𝑒𝑐ℎ 𝐵𝑖𝑡𝑒𝑠 & 𝑁𝑜𝑡𝑒𝑠 https://lnkd.in/efjF7yKr #5G #5GNR #LTE #4G #ORAN #OpenRAN #RFOptimization #RF

Tackling one of industrial recommendation's toughest problems: the semantic gap between multi-objective ranking and single-objective retrieval. Researchers from Kuaishou Technology just released MPFormer, a dynamic multi-task Transformer framework now serving 400M+ daily active users. Here's what makes it interesting: The Core Challenge: Traditional systems run separate retrieval models for each objective (CTR, watch duration, conversions), leading to linear resource scaling and fragmented information flows. This creates a fundamental mismatch with downstream multi-objective rankers. Technical Architecture: The framework uses an objective-conditioned attention mechanism that jointly encodes user behavior sequences with task-specific semantics. Instead of maintaining K separate models, it processes multiple objectives through shared query-key-value projections in the attention layers, reducing complexity from O(K·(n²d+nd²)) to O((n+K)d²+(n+K)²d). On the item side, task-independent MLPs generate specialized embeddings for each objective, preventing gradient interference while enabling targeted feature adaptation. The user tower combines RMS normalization with causal masked self-attention, extracting objective-specific representations from a unified sequence encoding. Dynamic Quota Allocation: Rather than fixed retrieval quotas, the system learns per-item weights supervised by downstream ranking scores. At inference, it aggregates these weights across recent user interactions to personalize candidate distribution across objectives in real-time. The Results: - 60% reduction in training resources versus independent models - 67% cut in inference costs through unified architecture - 21.8% improvement in multi-objective exposure rates - Stable 80ms P99 latency at 1.2M QPS - 0.43% increase in total watch time What's particularly clever: they intentionally exclude user/device IDs from representations to prevent embedding collapse into simplistic ID mappings, forcing the model to learn richer semantic features instead. The framework maintains K independent ANN indices but dynamically adjusts retrieval quotas based on learned user preferences, achieving personalization without sacrificing the computational efficiency of embedding-based retrieval.

With Kubernetes version 1.33[beta] we can now resize container resources without restarting our pods.For this, we have to use the subresource=resize flag in the kubectl command. To illustrate, if we have a running nginx pod and we have to update it's CPU request to 2 and it's limits to 4 then will run the command -  kubectl patch pod nginx --subresource resize --patch '{"spec":{"containers":[{"name":"nginx","resources":{"requests":{"cpu":"2"},"limits":{"cpu":"4"}}}]}}' NOTE: The kubectl client version must be at least v1.32 to use the --subresource=resize flag. After this, we can check the Pod resize status. The status will be either - 1. type: PodResizePending - The Kubelet cannot immediately grant the request. The message field provides an explanation of why and it can be - - Infeasible - The requested resize is impossible on the current node (for example, requesting more resources than the node has). Deferred - The requested resize is currently not possible, but might become feasible later (for example if another pod is removed). The Kubelet will retry the resize. 2. type: PodResizeInProgress - The resize request has been accepted, and resources have been allocated, but the changes are still being applied. Now, look at the perks of this Dynamic Resource Resizing - 1. No Downtime - The biggest advantages of this feature is that no pod restart is required. This means you can make resource adjustments without disrupting running applications, ensuring that uptime and availability are maintained at all times.2. Real-Time Resource Adjustment - We can quickly respond to changes in our application's workload by dynamically resizing resources. Whether we're scaling up for traffic spikes or scaling down to save costs.3. Simplified Operations - Manual intervention to restart pods or adjust resources becomes a thing of the past. Kubernetes will handle resource resizing automatically as part of its regular scheduling cycle, making operations smoother and less error-prone. 4. Flexible Scaling in Production - Kubernetes makes it easier to handle unpredictable workloads. Instead of guessing the ideal resources for a pod during deployment, we can make adjustments based on real-time usage, ensuring that our containerized applications are always running with the right resources. I hope you found this post insightful. #kubernetes #devops

Setting static CPU and memory requests in Kubernetes is often guesswork. Too low and you get throttling or OOMKills. Too high and you waste capacity. The Vertical Pod Autoscaler helps, but traditionally required pod restarts to apply changes. VPA v1.5.0 with Kubernetes 1.33 introduces InPlaceOrRecreate mode, which can adjust resource requests on running containers without disrupting the pod. This enables a practical strategy: start with minimal requests and let VPA right-size them dynamically. Anup Dubey shows the setup and explains how VPA makes its recommendations. https://lnkd.in/eD_8SSvW

Researchers might have solved one of AI deployment's biggest headaches. Large language models are powerful, but they come with a brutal trade-off: you either commit to a fixed computational budget upfront, or you train multiple versions of your model for different scenarios. Both approaches are expensive and inflexible. The deployment challenge is real. A model trained on massive GPU clusters needs to run everywhere - from high-end servers to resource-constrained edge devices. Traditional solutions force you to either compress models individually for each target (expensive) or design specialized architectures from scratch (limiting). Nested Subspace Networks (NSNs) introduce a fundamentally different approach. By re-parameterizing linear layers to satisfy a "nested subspace property," a single trained model can dynamically adjust its computational cost at inference time across a continuous spectrum of budgets. Think of it as having hundreds of models in one, where each smaller model is mathematically contained within the larger ones. By doing this, researchers achieved a 50% reduction in inference FLOPs with only a 5 percentage point accuracy loss. More importantly, NSNs can be surgically applied to existing pre-trained models like Pythia-2.8B, GPT-Neo-2.7B, and Gemma-2B without retraining from scratch. This could reshape how we think about model deployment. Instead of maintaining multiple model versions or accepting rigid performance-efficiency trade-offs, practitioners might soon deploy single adaptive models that respond to real-time resource constraints. ↓ 𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

New technique that allows LLMs to dynamically adjust the amount of computation they use based on the difficulty of a problem. This approach enables models to "think" longer for harder questions, similar to human reasoning, improving accuracy without wasting resources on simple tasks. As people start to pay more attention to LLM cost and efficiency in production, this along with techniques like Speculative Cascades (https://lnkd.in/gHKRin72) & SLMs will become increasingly important. ➡️ Massachusetts Institute of Technology article - https://lnkd.in/gVDPyhUX ➡️ arxiv paper - https://lnkd.in/gg7JZiVJ

Post 48: Real-Time Cloud & DevOps Scenario Scenario: Your organization uses Azure Kubernetes Service (AKS) for container orchestration. Recently, your production cluster experienced intermittent downtime due to excessive pod restarts and unbalanced node resource utilization. As a DevOps engineer, your task is to optimize AKS performance through effective autoscaling, monitoring, and node pool management. Solution Highlights: ✅ Enable Cluster Autoscaler Configure the AKS Cluster Autoscaler to dynamically adjust the number of nodes based on workload demands. This prevents over-provisioning and ensures sufficient capacity during traffic spikes. az aks nodepool update \ --resource-group myResourceGroup \ --cluster-name myAKSCluster \ --name nodepool1 \ --enable-cluster-autoscaler \ --min-count 2 \ --max-count 10 ✅ Use Multiple Node Pools Separate workloads by creating dedicated node pools for production, testing, or GPU workloads. This isolates critical services from resource-hungry pods and ensures workload prioritization. ✅ Implement Horizontal Pod Autoscaler (HPA) Enable HPA to scale pods automatically based on CPU, memory, or custom metrics: apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler metadata: name: webapp-hpa spec: scaleTargetRef: apiVersion: apps/v1 kind: Deployment name: webapp minReplicas: 2 maxReplicas: 10 metrics: - type: Resource resource: name: cpu target: type: Utilization averageUtilization: 70 ✅ Use Pod Disruption Budgets (PDBs) Define PDBs to control how many pods can be taken down during node upgrades or rescheduling, ensuring high availability. ✅ Monitor and Optimize with Azure Monitor Integrate Azure Monitor and Container Insights to track CPU/memory utilization, restart counts, and cluster health in real time. Set alerts for anomalies or sustained high resource usage. ✅ Optimize Node Sizing and Scheduling Use taints and tolerations to ensure pods are placed efficiently based on workload type and resource needs. ✅ Perform Regular Node Pool Upgrades Keep AKS versions up to date to benefit from performance improvements and security patches. Automate upgrades using Azure DevOps Pipelines. Outcome: Improved AKS performance, stability, and cost-efficiency. Balanced workloads across nodes with automatic scaling and proactive monitoring. 💬 How do you handle scaling and stability in Kubernetes clusters? Share your strategies below! ✅ Follow CareerByteCode for daily real-time Cloud & DevOps scenarios. Let’s scale smarter together! #DevOps #Azure #AKS #Kubernetes #Autoscaling #CloudComputing #Monitoring #PerformanceOptimization #RealTimeScenarios #CloudEngineering #LinkedInLearning @CareerByteCode CareerByteCode

How DDMRP works (in 5 steps): 1. Strategic Positioning: Decide where to place buffers (raw materials, WIP, finished goods). 2. Buffer Profiles & Levels: Set minimum–maximum ranges using actual consumption, variability, and lead times. 3. Dynamic Adjustments: Buffers auto-adjust as demand changes. 4. Demand-Driven Planning: System recommends only what is truly needed to protect flow. 5. Visible Execution Signals: Red / Yellow / Green signals tell planners what to act on right now. Why warehouses love it: - Fewer stock-outs - Faster turns - Less excess and obsolete inventory - Clear priorities for the floor - Better OTIF - Less chaos and firefighting