Comprehensive VPA Implementation Guide

1. VPA Core Components

VPA Controller Service

// VPAControllerService.java
package com.example.vpa.core;
import io.kubernetes.client.openapi.ApiClient;
import io.kubernetes.client.openapi.ApiException;
import io.kubernetes.client.openapi.apis.CoreV1Api;
import io.kubernetes.client.openapi.models.V1Pod;
import io.kubernetes.client.openapi.models.V1PodList;
import io.kubernetes.client.openapi.models.V1Container;
import io.kubernetes.client.openapi.models.V1ResourceRequirements;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.time.Instant;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
@Service
public class VPAControllerService {
private static final Logger logger = LoggerFactory.getLogger(VPAControllerService.class);
private final CoreV1Api coreV1Api;
private final MetricsService metricsService;
private final RecommendationEngine recommendationEngine;
private final VPAConfiguration config;
private final Map<String, VPARecommendation> recommendations = new ConcurrentHashMap<>();
private final Map<String, PodResourceUsage> podUsageHistory = new ConcurrentHashMap<>();
public VPAControllerService(ApiClient apiClient, 
MetricsService metricsService,
RecommendationEngine recommendationEngine,
VPAConfiguration config) {
this.coreV1Api = new CoreV1Api(apiClient);
this.metricsService = metricsService;
this.recommendationEngine = recommendationEngine;
this.config = config;
}
@Scheduled(fixedRateString = "${vpa.update-interval:300000}") // 5 minutes
public void updateRecommendations() {
try {
logger.info("Starting VPA recommendation update cycle");
// Get all pods in the namespace
V1PodList podList = coreV1Api.listNamespacedPod(
config.getNamespace(), 
null, null, null, null, 
config.getVpaSelector(), 
null, null, null, null, null);
for (V1Pod pod : podList.getItems()) {
processPod(pod);
}
logger.info("VPA recommendation update cycle completed. Processed {} pods", 
podList.getItems().size());
} catch (ApiException e) {
logger.error("Failed to update VPA recommendations", e);
}
}
private void processPod(V1Pod pod) {
String podName = pod.getMetadata().getName();
String namespace = pod.getMetadata().getNamespace();
try {
// Collect current resource usage
PodResourceUsage currentUsage = metricsService.getPodResourceUsage(podName, namespace);
// Store usage history
storeUsageHistory(podName, currentUsage);
// Generate recommendation
VPARecommendation recommendation = generateRecommendation(pod, currentUsage);
// Store recommendation
recommendations.put(podName, recommendation);
// Apply recommendation if auto-update is enabled
if (config.isAutoUpdateEnabled() && shouldApplyRecommendation(recommendation)) {
applyRecommendation(pod, recommendation);
}
logger.debug("Processed pod: {} - CPU: {} -> {}, Memory: {} -> {}", 
podName,
formatResource(currentUsage.getCpuUsage()), 
formatResource(recommendation.getTargetCpu()),
formatResource(currentUsage.getMemoryUsage()),
formatResource(recommendation.getTargetMemory()));
} catch (Exception e) {
logger.error("Failed to process pod: {}", podName, e);
}
}
private void storeUsageHistory(String podName, PodResourceUsage currentUsage) {
PodUsageHistory history = podUsageHistory.computeIfAbsent(podName, 
k -> new PodUsageHistory());
history.addUsage(currentUsage);
// Keep only recent history
history.trimHistory(config.getHistoryWindow());
}
private VPARecommendation generateRecommendation(V1Pod pod, PodResourceUsage currentUsage) {
String podName = pod.getMetadata().getName();
PodUsageHistory history = podUsageHistory.get(podName);
return recommendationEngine.generateRecommendation(pod, currentUsage, history);
}
private boolean shouldApplyRecommendation(VPARecommendation recommendation) {
if (!recommendation.isValid()) {
return false;
}
// Check if recommendation is significantly different from current
double cpuChange = Math.abs(recommendation.getTargetCpu() - recommendation.getCurrentCpu());
double memoryChange = Math.abs(recommendation.getTargetMemory() - recommendation.getCurrentMemory());
boolean significantChange = cpuChange > recommendation.getCurrentCpu() * config.getMinChangeThreshold() ||
memoryChange > recommendation.getCurrentMemory() * config.getMinChangeThreshold();
// Check confidence level
boolean confident = recommendation.getConfidence() > config.getMinConfidence();
// Check if within safety bounds
boolean withinBounds = !recommendation.exceedsSafetyLimits();
return significantChange && confident && withinBounds;
}
private void applyRecommendation(V1Pod pod, VPARecommendation recommendation) {
try {
String podName = pod.getMetadata().getName();
String namespace = pod.getMetadata().getNamespace();
// Update pod resources (this would typically be done via patch)
updatePodResources(pod, recommendation);
logger.info("Applied VPA recommendation for pod: {} - CPU: {}, Memory: {}", 
podName, recommendation.getTargetCpu(), recommendation.getTargetMemory());
} catch (Exception e) {
logger.error("Failed to apply VPA recommendation for pod: {}", 
pod.getMetadata().getName(), e);
}
}
private void updatePodResources(V1Pod pod, VPARecommendation recommendation) throws ApiException {
// This is a simplified implementation
// In production, you would use strategic merge patch or update the deployment
String podName = pod.getMetadata().getName();
String namespace = pod.getMetadata().getNamespace();
// Get the deployment name from pod labels
Map<String, String> labels = pod.getMetadata().getLabels();
String deploymentName = labels.get("app");
if (deploymentName != null) {
updateDeploymentResources(namespace, deploymentName, recommendation);
}
}
private void updateDeploymentResources(String namespace, String deploymentName, 
VPARecommendation recommendation) {
// Implementation to update deployment resources
// This would involve updating the deployment spec with new resource requests/limits
logger.info("Would update deployment {}/{} with CPU: {}, Memory: {}", 
namespace, deploymentName, 
recommendation.getTargetCpu(), recommendation.getTargetMemory());
}
private String formatResource(double value) {
if (value < 1000) {
return String.format("%.0fm", value);
} else {
return String.format("%.2f", value / 1000);
}
}
public VPARecommendation getRecommendation(String podName) {
return recommendations.get(podName);
}
public Map<String, VPARecommendation> getAllRecommendations() {
return new HashMap<>(recommendations);
}
public PodUsageHistory getPodUsageHistory(String podName) {
return podUsageHistory.get(podName);
}
public VPAStatus getVPAStatus() {
return new VPAStatus(
recommendations.size(),
podUsageHistory.size(),
Instant.now(),
calculateAverageRecommendation()
);
}
private Map<String, Double> calculateAverageRecommendation() {
double avgCpu = recommendations.values().stream()
.mapToDouble(VPARecommendation::getTargetCpu)
.average()
.orElse(0.0);
double avgMemory = recommendations.values().stream()
.mapToDouble(VPARecommendation::getTargetMemory)
.average()
.orElse(0.0);
return Map.of(
"cpu", avgCpu,
"memory", avgMemory
);
}
}

2. Data Models

Resource Usage Models

// PodResourceUsage.java
package com.example.vpa.model;
import java.time.Instant;
public class PodResourceUsage {
private String podName;
private String namespace;
private double cpuUsage; // in millicores
private double memoryUsage; // in MiB
private double cpuRequest;
private double memoryRequest;
private double cpuLimit;
private double memoryLimit;
private Instant timestamp;
public PodResourceUsage(String podName, String namespace, 
double cpuUsage, double memoryUsage,
double cpuRequest, double memoryRequest,
double cpuLimit, double memoryLimit) {
this.podName = podName;
this.namespace = namespace;
this.cpuUsage = cpuUsage;
this.memoryUsage = memoryUsage;
this.cpuRequest = cpuRequest;
this.memoryRequest = memoryRequest;
this.cpuLimit = cpuLimit;
this.memoryLimit = memoryLimit;
this.timestamp = Instant.now();
}
// Getters
public String getPodName() { return podName; }
public String getNamespace() { return namespace; }
public double getCpuUsage() { return cpuUsage; }
public double getMemoryUsage() { return memoryUsage; }
public double getCpuRequest() { return cpuRequest; }
public double getMemoryRequest() { return memoryRequest; }
public double getCpuLimit() { return cpuLimit; }
public double getMemoryLimit() { return memoryLimit; }
public Instant getTimestamp() { return timestamp; }
public double getCpuUtilization() {
return cpuRequest > 0 ? (cpuUsage / cpuRequest) * 100 : 0;
}
public double getMemoryUtilization() {
return memoryRequest > 0 ? (memoryUsage / memoryRequest) * 100 : 0;
}
public boolean isOverutilized() {
return getCpuUtilization() > 80 || getMemoryUtilization() > 80;
}
public boolean isUnderutilized() {
return getCpuUtilization() < 20 && getMemoryUtilization() < 20;
}
}
// PodUsageHistory.java
package com.example.vpa.model;
import java.time.Duration;
import java.time.Instant;
import java.util.*;
import java.util.concurrent.ConcurrentLinkedDeque;
public class PodUsageHistory {
private final Deque<PodResourceUsage> usageHistory = new ConcurrentLinkedDeque<>();
private final int maxHistorySize = 1000;
public void addUsage(PodResourceUsage usage) {
usageHistory.addFirst(usage);
// Maintain history size limit
while (usageHistory.size() > maxHistorySize) {
usageHistory.removeLast();
}
}
public void trimHistory(Duration window) {
Instant cutoff = Instant.now().minus(window);
usageHistory.removeIf(usage -> usage.getTimestamp().isBefore(cutoff));
}
public List<PodResourceUsage> getRecentUsage(Duration duration) {
Instant cutoff = Instant.now().minus(duration);
return usageHistory.stream()
.filter(usage -> usage.getTimestamp().isAfter(cutoff))
.toList();
}
public PodResourceUsage getPeakUsage(Duration duration) {
List<PodResourceUsage> recentUsage = getRecentUsage(duration);
if (recentUsage.isEmpty()) {
return null;
}
PodResourceUsage peakUsage = recentUsage.get(0);
for (PodResourceUsage usage : recentUsage) {
if (usage.getCpuUsage() > peakUsage.getCpuUsage() && 
usage.getMemoryUsage() > peakUsage.getMemoryUsage()) {
peakUsage = usage;
}
}
return peakUsage;
}
public ResourceStatistics calculateStatistics(Duration duration) {
List<PodResourceUsage> recentUsage = getRecentUsage(duration);
if (recentUsage.isEmpty()) {
return new ResourceStatistics(0, 0, 0, 0, 0, 0);
}
double avgCpu = recentUsage.stream()
.mapToDouble(PodResourceUsage::getCpuUsage)
.average()
.orElse(0.0);
double avgMemory = recentUsage.stream()
.mapToDouble(PodResourceUsage::getMemoryUsage)
.average()
.orElse(0.0);
double p95Cpu = calculatePercentile(recentUsage, 
usage -> usage.getCpuUsage(), 95);
double p95Memory = calculatePercentile(recentUsage,
usage -> usage.getMemoryUsage(), 95);
double maxCpu = recentUsage.stream()
.mapToDouble(PodResourceUsage::getCpuUsage)
.max()
.orElse(0.0);
double maxMemory = recentUsage.stream()
.mapToDouble(PodResourceUsage::getMemoryUsage)
.max()
.orElse(0.0);
return new ResourceStatistics(avgCpu, avgMemory, p95Cpu, p95Memory, maxCpu, maxMemory);
}
private <T> double calculatePercentile(List<PodResourceUsage> usageList, 
java.util.function.Function<PodResourceUsage, Double> extractor,
double percentile) {
List<Double> values = usageList.stream()
.map(extractor)
.sorted()
.toList();
if (values.isEmpty()) {
return 0.0;
}
int index = (int) Math.ceil(percentile / 100.0 * values.size());
return values.get(Math.min(index, values.size() - 1));
}
public int size() {
return usageHistory.size();
}
}
// ResourceStatistics.java
package com.example.vpa.model;
public class ResourceStatistics {
private final double avgCpu;
private final double avgMemory;
private final double p95Cpu;
private final double p95Memory;
private final double maxCpu;
private final double maxMemory;
public ResourceStatistics(double avgCpu, double avgMemory, 
double p95Cpu, double p95Memory,
double maxCpu, double maxMemory) {
this.avgCpu = avgCpu;
this.avgMemory = avgMemory;
this.p95Cpu = p95Cpu;
this.p95Memory = p95Memory;
this.maxCpu = maxCpu;
this.maxMemory = maxMemory;
}
// Getters
public double getAvgCpu() { return avgCpu; }
public double getAvgMemory() { return avgMemory; }
public double getP95Cpu() { return p95Cpu; }
public double getP95Memory() { return p95Memory; }
public double getMaxCpu() { return maxCpu; }
public double getMaxMemory() { return maxMemory; }
}

VPA Recommendation Models

// VPARecommendation.java
package com.example.vpa.model;
import java.time.Instant;
public class VPARecommendation {
private String podName;
private String namespace;
private double currentCpu;
private double currentMemory;
private double targetCpu;
private double targetMemory;
private double targetCpuLimit;
private double targetMemoryLimit;
private double confidence;
private RecommendationType type;
private Instant timestamp;
private String reason;
public VPARecommendation(String podName, String namespace,
double currentCpu, double currentMemory,
double targetCpu, double targetMemory,
double confidence, RecommendationType type,
String reason) {
this.podName = podName;
this.namespace = namespace;
this.currentCpu = currentCpu;
this.currentMemory = currentMemory;
this.targetCpu = targetCpu;
this.targetMemory = targetMemory;
this.targetCpuLimit = targetCpu * 2; // Default limit: 2x request
this.targetMemoryLimit = targetMemory * 1.5; // Default limit: 1.5x request
this.confidence = confidence;
this.type = type;
this.timestamp = Instant.now();
this.reason = reason;
}
// Getters
public String getPodName() { return podName; }
public String getNamespace() { return namespace; }
public double getCurrentCpu() { return currentCpu; }
public double getCurrentMemory() { return currentMemory; }
public double getTargetCpu() { return targetCpu; }
public double getTargetMemory() { return targetMemory; }
public double getTargetCpuLimit() { return targetCpuLimit; }
public double getTargetMemoryLimit() { return targetMemoryLimit; }
public double getConfidence() { return confidence; }
public RecommendationType getType() { return type; }
public Instant getTimestamp() { return timestamp; }
public String getReason() { return reason; }
public boolean isValid() {
return targetCpu > 0 && targetMemory > 0 && 
confidence >= 0 && confidence <= 1;
}
public boolean exceedsSafetyLimits() {
// Safety limits to prevent excessive resource allocation
return targetCpu > 4000 || // 4 CPU cores
targetMemory > 8192; // 8 GiB memory
}
public double getCpuChangePercentage() {
return currentCpu > 0 ? ((targetCpu - currentCpu) / currentCpu) * 100 : 0;
}
public double getMemoryChangePercentage() {
return currentMemory > 0 ? ((targetMemory - currentMemory) / currentMemory) * 100 : 0;
}
public boolean isSignificantChange() {
return Math.abs(getCpuChangePercentage()) > 10 || 
Math.abs(getMemoryChangePercentage()) > 10;
}
}
// RecommendationType.java
package com.example.vpa.model;
public enum RecommendationType {
OPTIMAL,    // Optimal resource allocation
CONSERVATIVE, // Conservative allocation with safety margin
AGGRESSIVE, // Aggressive allocation for performance
MAINTENANCE // No change needed
}

3. Recommendation Engine

// RecommendationEngine.java
package com.example.vpa.core;
import com.example.vpa.model.*;
import io.kubernetes.client.openapi.models.V1Pod;
import org.springframework.stereotype.Component;
import java.time.Duration;
@Component
public class RecommendationEngine {
private final VPAConfiguration config;
public RecommendationEngine(VPAConfiguration config) {
this.config = config;
}
public VPARecommendation generateRecommendation(V1Pod pod, 
PodResourceUsage currentUsage,
PodUsageHistory history) {
String podName = pod.getMetadata().getName();
String namespace = pod.getMetadata().getNamespace();
// Calculate statistics over different time windows
ResourceStatistics shortTermStats = history.calculateStatistics(Duration.ofHours(1));
ResourceStatistics mediumTermStats = history.calculateStatistics(Duration.ofHours(6));
ResourceStatistics longTermStats = history.calculateStatistics(Duration.ofHours(24));
// Generate recommendation based on strategy
switch (config.getRecommendationStrategy()) {
case CONSERVATIVE:
return generateConservativeRecommendation(podName, namespace, currentUsage, 
shortTermStats, mediumTermStats, longTermStats);
case AGGRESSIVE:
return generateAggressiveRecommendation(podName, namespace, currentUsage,
shortTermStats, mediumTermStats, longTermStats);
case BALANCED:
default:
return generateBalancedRecommendation(podName, namespace, currentUsage,
shortTermStats, mediumTermStats, longTermStats);
}
}
private VPARecommendation generateBalancedRecommendation(String podName, String namespace,
PodResourceUsage currentUsage,
ResourceStatistics shortTerm,
ResourceStatistics mediumTerm,
ResourceStatistics longTerm) {
// Use P95 of medium-term usage with safety buffer
double targetCpu = calculateTargetCpu(mediumTerm, currentUsage);
double targetMemory = calculateTargetMemory(mediumTerm, currentUsage);
double confidence = calculateConfidence(shortTerm, mediumTerm, longTerm);
String reason = generateReason(shortTerm, mediumTerm, longTerm);
return new VPARecommendation(podName, namespace,
currentUsage.getCpuRequest(), currentUsage.getMemoryRequest(),
targetCpu, targetMemory, confidence, RecommendationType.OPTIMAL, reason);
}
private VPARecommendation generateConservativeRecommendation(String podName, String namespace,
PodResourceUsage currentUsage,
ResourceStatistics shortTerm,
ResourceStatistics mediumTerm,
ResourceStatistics longTerm) {
// Use P95 of long-term usage with larger safety buffer
double targetCpu = calculateTargetCpu(longTerm, currentUsage) * 1.2; // 20% buffer
double targetMemory = calculateTargetMemory(longTerm, currentUsage) * 1.3; // 30% buffer
double confidence = calculateConfidence(shortTerm, mediumTerm, longTerm) * 0.9; // Lower confidence
String reason = "Conservative recommendation based on long-term usage patterns";
return new VPARecommendation(podName, namespace,
currentUsage.getCpuRequest(), currentUsage.getMemoryRequest(),
targetCpu, targetMemory, confidence, RecommendationType.CONSERVATIVE, reason);
}
private VPARecommendation generateAggressiveRecommendation(String podName, String namespace,
PodResourceUsage currentUsage,
ResourceStatistics shortTerm,
ResourceStatistics mediumTerm,
ResourceStatistics longTerm) {
// Use P95 of short-term usage with minimal buffer
double targetCpu = calculateTargetCpu(shortTerm, currentUsage) * 1.05; // 5% buffer
double targetMemory = calculateTargetMemory(shortTerm, currentUsage) * 1.1; // 10% buffer
double confidence = calculateConfidence(shortTerm, mediumTerm, longTerm);
String reason = "Aggressive recommendation optimized for recent performance";
return new VPARecommendation(podName, namespace,
currentUsage.getCpuRequest(), currentUsage.getMemoryRequest(),
targetCpu, targetMemory, confidence, RecommendationType.AGGRESSIVE, reason);
}
private double calculateTargetCpu(ResourceStatistics stats, PodResourceUsage currentUsage) {
// Use P95 CPU usage with minimum and maximum bounds
double baseCpu = stats.getP95Cpu();
// Ensure minimum CPU allocation
double minCpu = config.getMinCpu();
baseCpu = Math.max(baseCpu, minCpu);
// Add safety buffer
baseCpu *= config.getCpuSafetyMargin();
// Round to nearest 25m for Kubernetes compatibility
return Math.ceil(baseCpu / 25) * 25;
}
private double calculateTargetMemory(ResourceStatistics stats, PodResourceUsage currentUsage) {
// Use P95 memory usage with minimum and maximum bounds
double baseMemory = stats.getP95Memory();
// Ensure minimum memory allocation
double minMemory = config.getMinMemory();
baseMemory = Math.max(baseMemory, minMemory);
// Add safety buffer
baseMemory *= config.getMemorySafetyMargin();
// Round to nearest 32Mi for Kubernetes compatibility
return Math.ceil(baseMemory / 32) * 32;
}
private double calculateConfidence(ResourceStatistics shortTerm,
ResourceStatistics mediumTerm,
ResourceStatistics longTerm) {
// Calculate confidence based on data consistency across time windows
double shortMediumDiff = calculateStatsDifference(shortTerm, mediumTerm);
double mediumLongDiff = calculateStatsDifference(mediumTerm, longTerm);
// Lower difference = higher confidence
double consistencyScore = 1.0 - (shortMediumDiff + mediumLongDiff) / 2.0;
// Consider data volume (more data = higher confidence)
double dataVolumeScore = Math.min(1.0, mediumTerm.getAvgCpu() > 0 ? 1.0 : 0.5);
return (consistencyScore + dataVolumeScore) / 2.0;
}
private double calculateStatsDifference(ResourceStatistics stats1, ResourceStatistics stats2) {
double cpuDiff = Math.abs(stats1.getAvgCpu() - stats2.getAvgCpu()) / 
Math.max(stats1.getAvgCpu(), stats2.getAvgCpu());
double memoryDiff = Math.abs(stats1.getAvgMemory() - stats2.getAvgMemory()) / 
Math.max(stats1.getAvgMemory(), stats2.getAvgMemory());
return (cpuDiff + memoryDiff) / 2.0;
}
private String generateReason(ResourceStatistics shortTerm,
ResourceStatistics mediumTerm,
ResourceStatistics longTerm) {
StringBuilder reason = new StringBuilder();
if (shortTerm.getMaxCpu() > mediumTerm.getMaxCpu() * 1.5) {
reason.append("Recent CPU spikes detected. ");
}
if (mediumTerm.getAvgCpu() > longTerm.getAvgCpu() * 1.2) {
reason.append("Medium-term CPU usage trending upward. ");
}
if (shortTerm.getP95Memory() > mediumTerm.getP95Memory() * 1.3) {
reason.append("Recent memory usage increases observed. ");
}
if (reason.length() == 0) {
reason.append("Stable usage patterns observed.");
}
return reason.toString();
}
}

4. Metrics Service

// MetricsService.java
package com.example.vpa.core;
import com.example.vpa.model.PodResourceUsage;
import io.kubernetes.client.openapi.ApiClient;
import io.kubernetes.client.openapi.ApiException;
import io.kubernetes.client.openapi.apis.CoreV1Api;
import io.kubernetes.client.openapi.models.V1Pod;
import io.kubernetes.client.openapi.models.V1Container;
import io.kubernetes.client.openapi.models.V1ResourceRequirements;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import java.util.Map;
@Service
public class MetricsService {
private static final Logger logger = LoggerFactory.getLogger(MetricsService.class);
private final CoreV1Api coreV1Api;
private final MetricsCollector metricsCollector;
public MetricsService(ApiClient apiClient, MetricsCollector metricsCollector) {
this.coreV1Api = new CoreV1Api(apiClient);
this.metricsCollector = metricsCollector;
}
public PodResourceUsage getPodResourceUsage(String podName, String namespace) {
try {
// Get pod details
V1Pod pod = coreV1Api.readNamespacedPod(podName, namespace, null);
// Get current resource usage from metrics server
Map<String, Double> currentUsage = metricsCollector.getPodMetrics(podName, namespace);
// Extract resource requests and limits
ResourceAllocation allocation = extractResourceAllocation(pod);
return new PodResourceUsage(
podName, namespace,
currentUsage.getOrDefault("cpu", 0.0),
currentUsage.getOrDefault("memory", 0.0),
allocation.cpuRequest,
allocation.memoryRequest,
allocation.cpuLimit,
allocation.memoryLimit
);
} catch (ApiException e) {
logger.error("Failed to get resource usage for pod: {}/{}", namespace, podName, e);
throw new RuntimeException("Failed to get pod resource usage", e);
}
}
private ResourceAllocation extractResourceAllocation(V1Pod pod) {
double cpuRequest = 0;
double memoryRequest = 0;
double cpuLimit = 0;
double memoryLimit = 0;
for (V1Container container : pod.getSpec().getContainers()) {
V1ResourceRequirements resources = container.getResources();
if (resources != null) {
if (resources.getRequests() != null) {
cpuRequest += parseCpu(resources.getRequests().get("cpu"));
memoryRequest += parseMemory(resources.getRequests().get("memory"));
}
if (resources.getLimits() != null) {
cpuLimit += parseCpu(resources.getLimits().get("cpu"));
memoryLimit += parseMemory(resources.getLimits().get("memory"));
}
}
}
return new ResourceAllocation(cpuRequest, memoryRequest, cpuLimit, memoryLimit);
}
private double parseCpu(String cpu) {
if (cpu == null) return 0;
if (cpu.endsWith("m")) {
return Double.parseDouble(cpu.substring(0, cpu.length() - 1));
} else {
return Double.parseDouble(cpu) * 1000; // Convert cores to millicores
}
}
private double parseMemory(String memory) {
if (memory == null) return 0;
if (memory.endsWith("Ki")) {
return Double.parseDouble(memory.substring(0, memory.length() - 2)) / 1024; // Convert to MiB
} else if (memory.endsWith("Mi")) {
return Double.parseDouble(memory.substring(0, memory.length() - 2));
} else if (memory.endsWith("Gi")) {
return Double.parseDouble(memory.substring(0, memory.length() - 2)) * 1024;
} else {
// Assume bytes
return Double.parseDouble(memory) / (1024 * 1024);
}
}
private static class ResourceAllocation {
final double cpuRequest;
final double memoryRequest;
final double cpuLimit;
final double memoryLimit;
ResourceAllocation(double cpuRequest, double memoryRequest, 
double cpuLimit, double memoryLimit) {
this.cpuRequest = cpuRequest;
this.memoryRequest = memoryRequest;
this.cpuLimit = cpuLimit;
this.memoryLimit = memoryLimit;
}
}
}
// MetricsCollector.java
package com.example.vpa.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
@Component
public class MetricsCollector {
private static final Logger logger = LoggerFactory.getLogger(MetricsCollector.class);
public Map<String, Double> getPodMetrics(String podName, String namespace) {
// In production, this would integrate with Kubernetes Metrics Server
// or Prometheus to get actual resource usage
// Mock implementation for demonstration
Map<String, Double> metrics = new HashMap<>();
// Simulate CPU usage in millicores
metrics.put("cpu", Math.random() * 500 + 100); // 100-600 millicores
// Simulate memory usage in MiB
metrics.put("memory", Math.random() * 200 + 50); // 50-250 MiB
logger.debug("Collected metrics for pod {}/{}: CPU={}, Memory={}", 
namespace, podName, metrics.get("cpu"), metrics.get("memory"));
return metrics;
}
}

5. VPA Configuration

// VPAConfiguration.java
package com.example.vpa.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.time.Duration;
@Component
@ConfigurationProperties(prefix = "vpa")
public class VPAConfiguration {
private boolean enabled = true;
private String namespace = "default";
private String vpaSelector = "vpa-enabled=true";
private boolean autoUpdateEnabled = false;
private Duration updateInterval = Duration.ofMinutes(5);
private Duration historyWindow = Duration.ofHours(24);
// Recommendation settings
private RecommendationStrategy recommendationStrategy = RecommendationStrategy.BALANCED;
private double minChangeThreshold = 0.1; // 10% minimum change
private double minConfidence = 0.7; // 70% minimum confidence
// Resource bounds
private double minCpu = 10; // 10m CPU
private double minMemory = 32; // 32Mi memory
private double maxCpu = 4000; // 4 CPU cores
private double maxMemory = 8192; // 8Gi memory
// Safety margins
private double cpuSafetyMargin = 1.2; // 20% buffer
private double memorySafetyMargin = 1.3; // 30% buffer
// Getters and setters
public boolean isEnabled() { return enabled; }
public void setEnabled(boolean enabled) { this.enabled = enabled; }
public String getNamespace() { return namespace; }
public void setNamespace(String namespace) { this.namespace = namespace; }
public String getVpaSelector() { return vpaSelector; }
public void setVpaSelector(String vpaSelector) { this.vpaSelector = vpaSelector; }
public boolean isAutoUpdateEnabled() { return autoUpdateEnabled; }
public void setAutoUpdateEnabled(boolean autoUpdateEnabled) { this.autoUpdateEnabled = autoUpdateEnabled; }
public Duration getUpdateInterval() { return updateInterval; }
public void setUpdateInterval(Duration updateInterval) { this.updateInterval = updateInterval; }
public Duration getHistoryWindow() { return historyWindow; }
public void setHistoryWindow(Duration historyWindow) { this.historyWindow = historyWindow; }
public RecommendationStrategy getRecommendationStrategy() { return recommendationStrategy; }
public void setRecommendationStrategy(RecommendationStrategy recommendationStrategy) { this.recommendationStrategy = recommendationStrategy; }
public double getMinChangeThreshold() { return minChangeThreshold; }
public void setMinChangeThreshold(double minChangeThreshold) { this.minChangeThreshold = minChangeThreshold; }
public double getMinConfidence() { return minConfidence; }
public void setMinConfidence(double minConfidence) { this.minConfidence = minConfidence; }
public double getMinCpu() { return minCpu; }
public void setMinCpu(double minCpu) { this.minCpu = minCpu; }
public double getMinMemory() { return minMemory; }
public void setMinMemory(double minMemory) { this.minMemory = minMemory; }
public double getMaxCpu() { return maxCpu; }
public void setMaxCpu(double maxCpu) { this.maxCpu = maxCpu; }
public double getMaxMemory() { return maxMemory; }
public void setMaxMemory(double maxMemory) { this.maxMemory = maxMemory; }
public double getCpuSafetyMargin() { return cpuSafetyMargin; }
public void setCpuSafetyMargin(double cpuSafetyMargin) { this.cpuSafetyMargin = cpuSafetyMargin; }
public double getMemorySafetyMargin() { return memorySafetyMargin; }
public void setMemorySafetyMargin(double memorySafetyMargin) { this.memorySafetyMargin = memorySafetyMargin; }
public enum RecommendationStrategy {
CONSERVATIVE, BALANCED, AGGRESSIVE
}
}

6. VPA Status and Monitoring

// VPAStatus.java
package com.example.vpa.model;
import java.time.Instant;
import java.util.Map;
public class VPAStatus {
private final int monitoredPods;
private final int recommendationsGenerated;
private final Instant lastUpdate;
private final Map<String, Double> averageRecommendations;
private final String status;
public VPAStatus(int monitoredPods, int recommendationsGenerated,
Instant lastUpdate, Map<String, Double> averageRecommendations) {
this.monitoredPods = monitoredPods;
this.recommendationsGenerated = recommendationsGenerated;
this.lastUpdate = lastUpdate;
this.averageRecommendations = averageRecommendations;
this.status = calculateStatus();
}
// Getters
public int getMonitoredPods() { return monitoredPods; }
public int getRecommendationsGenerated() { return recommendationsGenerated; }
public Instant getLastUpdate() { return lastUpdate; }
public Map<String, Double> getAverageRecommendations() { return averageRecommendations; }
public String getStatus() { return status; }
private String calculateStatus() {
if (monitoredPods == 0) return "INACTIVE";
if (recommendationsGenerated == 0) return "COLLECTING_DATA";
return "ACTIVE";
}
public Map<String, Object> toMap() {
return Map.of(
"monitoredPods", monitoredPods,
"recommendationsGenerated", recommendationsGenerated,
"lastUpdate", lastUpdate.toString(),
"averageRecommendations", averageRecommendations,
"status", status
);
}
}

7. REST Controller for VPA

Pyroscope Profiling in Java
Explains how to use Pyroscope for continuous profiling in Java applications, helping developers analyze CPU and memory usage patterns to improve performance and identify bottlenecks.
https://macronepal.com/blog/pyroscope-profiling-in-java/

OpenTelemetry Metrics in Java: Comprehensive Guide
Provides a complete guide to collecting and exporting metrics in Java using OpenTelemetry, including counters, histograms, gauges, and integration with monitoring tools. (MACRO NEPAL)
https://macronepal.com/blog/opentelemetry-metrics-in-java-comprehensive-guide/

OTLP Exporter in Java: Complete Guide for OpenTelemetry
Explains how to configure OTLP exporters in Java to send telemetry data such as traces, metrics, and logs to monitoring systems using HTTP or gRPC protocols. (MACRO NEPAL)
https://macronepal.com/blog/otlp-exporter-in-java-complete-guide-for-opentelemetry/

Thanos Integration in Java: Global View of Metrics
Explains how to integrate Thanos with Java monitoring systems to create a scalable global metrics view across multiple Prometheus instances.

https://macronepal.com/blog/thanos-integration-in-java-global-view-of-metrics

Time Series with InfluxDB in Java: Complete Guide (Version 2)
Explains how to manage time-series data using InfluxDB in Java applications, including storing, querying, and analyzing metrics data.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide-2

Time Series with InfluxDB in Java: Complete Guide
Provides an overview of integrating InfluxDB with Java for time-series data handling, including monitoring applications and managing performance metrics.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide

Implementing Prometheus Remote Write in Java (Version 2)
Explains how to configure Java applications to send metrics data to Prometheus-compatible systems using the remote write feature for scalable monitoring.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide-2

Implementing Prometheus Remote Write in Java: Complete Guide
Provides instructions for sending metrics from Java services to Prometheus servers, enabling centralized monitoring and real-time analytics.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide

Building a TileServer GL in Java: Vector and Raster Tile Server
Explains how to build a TileServer GL in Java for serving vector and raster map tiles, useful for geographic visualization and mapping applications.

https://macronepal.com/blog/building-a-tileserver-gl-in-java-vector-and-raster-tile-server

Indoor Mapping in Java
Explains how to create indoor mapping systems in Java, including navigation inside buildings, spatial data handling, and visualization techniques.