Volcengine Kubernetes Engine
Volcengine Kubernetes Engine
Volcengine Kubernetes Engine
Document
Volcengine Kubernetes Engine
What's New
History feature release notes
Kubernetes version release notes
Containerd runtime release notes
Add-on release notes
Monitoring add-ons
Scheduling add-ons
DNS add-ons
Security add-ons
GPU add-ons
Sandbox add-on
Security announcements
Product Announcement
Historical announcements
Overview
Getting started
User guide
Clusters
Creating clusters
Connecting to clusters
Upgrading clusters
Node pool
Creating node pools
Scaling out/in node pools
Nodes
Authorization management
Image
Namespaces
Networking
Cluster network
Container Network
Service
LoadBalancer
CLB
Ingress
APIG Ingress
ALB Ingress
Customize ALB Ingress forwarding rules
Certificate and security
CLB Ingress
Nginx Ingress
Gateway API
Workloads
Creating workloads
Configure workloads
Pods
Configuration management
Image acceleration
Storage
FSX client
EBS Volumes
TOS Volumes
NAS volumes
FSX access methods
NFS access methods
EFS volumes
vePFS volumes
FSX access methods
vePFS Client access methods
NFS access methods
CloudFS volumes
Local volumes
Autoscale
Node autoscaler
Workload autoscaler
Horizontal Pod Autoscaler (HPA)
Cron Horizontal Pod Autoscaler (CronHPA)
Intelligent Horizontal Pod Autoscaler (IHPA)
Horizontal Pod Autoscaler based on event-driven (KEDA)
Add-on management
Network add-ons
Storage add-ons
Monitoring add-ons
Scheduling add-ons
DNS add-ons
GPU add-ons
Core add-ons
Sandbox add-on
Upgrading add-ons
Heterogeneous computing
NVIDIA GPU
mGPU scheduling
RDMA high-performance computing
Scheduling management
Topology-aware scheduling
QoS-aware scheduling
Observability
Log management
Basic observation
Setup & Configuration
Cluster observation
Storage observation
Other observation
Using metrics
Full stack observation
Alert management
Diagnosis and inspection
Node check and self-healing
Application center
Backup center
Stability
Large-scale cluster management
Best practices
Authorization
Clusters
Nodes and node pools
Networking
Storage
Scheduling
Observability
Solution
Security and compliance
API reference
Cluster management
NodePool management
Node management
Virtual nodes management
Add-on management
Tag management
Access policy management
Instance images management
Cloud native observability
Inspection and diagnosis
Task management
Volcengine Container Instance
Appendix
SDK reference
Development guide
Terraform
FAQs
General FAQs
Cluster FAQ
cluster management
cluster network
cluster upgrade
Node and Node pool FAQs
Authorization FAQs
Workload FAQs
Service and Ingress FAQs
Storage FAQs
Heterogeneous computing FAQs
Observability FAQs
Quota FAQs
Add-on FAQs
Cloud-native AI
ServingKit
LLM applications
ComfyUI application
Deploying the Al inference application through Helm
Deepseek practices
Qwen practices
Kimi practice
Seed practices
Best practices
DeepSeek model deployment
GLM model deployment
MiniMax model deployment
Qwen model deployment
Kimi model deployment
Volcengine Container Instance
What's new
Historical feature release notes
Product Announcement
Overview
Billing
User guide
Integrating with VCI
Virtual node
VKE cluster uses virtual nodes
Self-managed/third-party cluster uses virtual node
Creating an instance
General purpose instance
GPU-accelerated computing instance
VCI Agent Sandbox
Startup acceleration
E2B-based management
Upgrade guide
Networking
Monitoring
Scheduling
Container configuration
VCI Image Cache
Best practices
Security and compliance
FAQs
- Documentation
Volcengine Kubernetes EngineVolcengine Kubernetes EngineUser guideAutoscaleWorkload autoscalerHorizontal Pod Autoscaler based on event-driven (KEDA)Autoscaling based on APIG network metrics
Copy page
Download PDFHorizontal Pod Autoscaler based on event-driven (KEDA)
Autoscaling based on APIG network metrics
Copy pageDownload PDFAutoscaling based on APIG network metrics
Volcengine Kubernetes Engine (VKE) supports workload autoscaling through KEDA, the event-driven autoscaler add-on, which helps users reduce costs. This topic describes how to achieve workload autoscaling based on network metrics provided by API Gateway (APIG).
Background information
KEDA functions as an event-driven autoscaling add-on supported by VKE, which can be connected to multiple data sources and scale out workloads from zero and scale in workloads to zero. By leveraging the network request metrics provided by APIG, KEDA can scale in workloads to zero or scale out workloads from zero. This effectively reduces cloud costs during the idle period, enhances elasticity, and improves service competitiveness.
Prerequisites
- A cluster has been created and needs to be running on Kubernetes v1.24 or later. For details, see Creating clusters.
- The keda add-on has been installed in the cluster. For details, see Installing add-ons.
- The apig-controller add-on has been installed in the cluster to connect to APIG. For details, see Installing add-ons.
- A Volcengine Managed Service for Prometheus (VMP) workspace has been created, and basic authentication has been enabled. For more information, see Creating workspaces.
- Cloud native observability has been enabled for the cluster. For details, see Enabling observability.
Procedure
Step 1: Create an application and a service
Deploy an application and a service in the cluster. The following sample code demonstrates how to deploy NGINX.
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx
namespace: default
spec:
replicas: 2
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: doc-cn-beijing.cr.volces.com/vke/nginx-demo:v1.0
ports:
- containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
name: nginx
namespace: default
spec:
internalTrafficPolicy: Cluster
ipFamilies:
- IPv4
ipFamilyPolicy: SingleStack
ports:
- name: http
port: 80
protocol: TCP
targetPort: 80
selector:
app: nginx
sessionAffinity: None
type: ClusterIP
Step 2: Create an APIG Ingress
Create an APIG Ingress in the cluster in the console. This topic takes the domain name example.com as an example. For detailed instructions, see Creating APIG Ingresses in the console.
Step 3: Enable APIG instance monitoring
- Log in to APIG console.
- In the left navigation bar, click Instance management. On the page that appears, click the name of the target instance to go to the instance details page.
- Click the Monitoring data tab, and click Bind now.
- In the pop-up dialog box, select the created VMP workspace, and click Confirm. Enable APIG instance monitoring and save the monitoring data in the specified VMP workspace.
warning
The APIG instance and the VKE cluster must be bound to the same VMP workspace.
Step 4: Create a KEDA scaling object
- After you install the KEDA add-on, you need to use a secret to configure the basic authentication information for the VMP workspace. The example is as follows:
apiVersion: v1
kind: Secret
metadata:
name: keda-prom-secret
namespace: default
data:
username: "YWRtaW4=" # The VMP workspace username after Base64 encoding. In this example, "YWRtaW4=" indicates admin.
password: "YWRtaW4xMjM0" # The VMP workspace password after Base64 encoding. In this example, "YWRtaW4xMjM0" indicates admin1234.
- Create an authentication CustomResourceDefinition (CRD) for KEDA to enable KEDA to access the VMP workspace. The example is as follows:
apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
name: keda-prom-creds
namespace: default
spec:
secretTargetRef:
- parameter: username
name: keda-prom-secret
key: username
- parameter: password
name: keda-prom-secret
key: password
- Create a KEDA autoscaling object ScaledObject.
- serverAddress indicates the query address of the VMP workspace. For details, see Obtaining workspace addresses.
- query indicates the query metric. In this example, the sum(rate(istio_requests_total[1m])) metric is selected, which indicates the total number of APIG requests. request_host indicates the external access address that corresponds to the APIG Ingress associated with APIG. In this example, example.com is used.
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: apig-scaledobject
namespace: default
spec:
scaleTargetRef:
name: nginx
pollingInterval: 15
# The critical definition for scaling from 0 to 1 with KEDA.
idleReplicaCount: 0
# The observation window for scaling in replicas from 1 to 0.
cooldownPeriod: 30
# The observation window that is triggered after cooldownPeriod is created for the first time.
initialCooldownPeriod: 0
# The minimum number of replicas (HPA).
minReplicaCount: 1
# The maximum number of replicas (HPA).
maxReplicaCount: 2
triggers:
- type: prometheus
metadata:
serverAddress: http://query.prometheus-cn-beijing.ivolces.com/workspaces/5c0***
threshold: '1'
query: sum(rate(istio_requests_total{request_host="example.com"}[1m])) by (request_host)
authModes: "basic"
authenticationRef:
name: keda-prom-creds
Result validation
Checking whether the workloads decline to zero
- Log in to VKE console.
- In the left navigation bar, click Cluster.
- In the cluster list, click the name of the target cluster.
- In the left navigation bar of the cluster management page, click Monitoring center > Dashboard.
- In the dashboard list on the left side, click Workload monitoring > Deployment monitoring. After you select a namespace and a workload, you can view the monitoring dashboard for the specified workload.
In the monitoring dashboard, you can see that when the workload is created, two replicas are configured. After the KEDA autoscaling object is created, the scaling metric for the workload is 0. Therefore, the number of replicas is changed to the value of idleReplicaCount in the autoscaling object ScaledObject of KEDA, which indicates that the replicas automatically decline to 0.
Checking whether the workloads are scaled out from zero
Use the following command to access applications in the cluster by using APIG Ingress. http://14.***.***.*** indicates the external IP address of the APIG instance. To obtain the IP address, see Obtaining gateway addresses.
curl -H "Host: example.com" http://14.***.***.***
Expected result: The corresponding application cannot be accessed and the system displays a backend error because the number of replicas for the backend workloads is zero.
no healthy upstream
In addition, when you view the observability dashboard or corresponding metrics in the APIG console or VMP console, you can view request quantity metrics.
When KEDA in the cluster detects an increase in external metrics, it will scale out backend workloads from zero. Scaling from zero to ready incurs a 15-20 second delay, during which requests are not served.
After the scale-out is complete, use the following command to access the applications in the cluster as expected.
curl -H "Host: example.com" http://14.***.***.***
Expected result: Workloads can be accessed as expected through the APIG Ingress.
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>
After external requests are handled, the workloads decline to zero again, effectively reducing cloud costs during the idle period.
View the autoscaling monitoring dashboard for information about workload scale-out and scale-in.
Last updated: 2026.07.24 14:51:38
All rights reserved © Beijing Volcano Engine Technology Co., Ltd2024
