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 guideObservabilityApplication performance observability
Copy page
Download PDFObservability
Application performance observability
Copy pageDownload PDFApplication performance observability
VKE can be integrated with APMPlus to provide end-to-end application performance monitoring services for applications deployed in clusters. This topic describes how to deploy an application in a cluster and integrate the cluster with APMPlus trace monitoring.
Background
APMPlus is an APM service designed for application service quality, performance, and custom instrumentation. By leveraging advanced data collection and monitoring technologies, APMPlus provides enterprises with end-to-end application performance monitoring services. It covers both server-side monitoring, such as root cause analysis for AI large models, issue identification for LLM chains, and comprehensive monitoring of agents, and client-side monitoring for the app, WebPro, mini program, PC, and OS. It helps enterprises to enhance the efficiency of troubleshooting.
Application performance observability delivers benefits such as low integration costs and non-intrusive access. It supports end-to-end monitoring capabilities for basic resource performance, service, and code layer, and the health status of online application operations. It can be integrated with Java, Go, Python, and other applications, such as large models, LLMs, and agents, through methods such as a self-developed agent and OpenTelemetry for end-to-end monitoring, which provides richer capabilities for restoring abnormal scenarios. Core features include service monitoring, trace analysis, error analysis, log monitoring, custom monitoring, alerting tasks, and other features.
tip
Prerequisites
- The apmplus-opentelemetry-collector add-on has been installed. For details, see apmplus-opentelemetry-collector.
- APMPlus monitoring has been activated. For details, see Activating APMPlus monitoring.
- (Optional) An AMPlus workspace has been created. For details, see Workspace management.
Procedure
tip
You can enable application performance monitoring for different types of workloads when you create workloads, including Deployments, StatefulSets, Jobs, CronJobs, and DaemonSets. This topic provides an example of how to create a Deployment. For configuration methods for other types of workloads, see Workloads.
Configure through the console
- Go to the Deployment page.
- Log in to Volcengine Kubernetes Engine (VKE) console .
- In the left navigation bar, click Cluster.
- On the Cluster page, click the name of the cluster for which you need to create a Deployment.
- In the left navigation bar of the cluster management page, click Workload > Deployment.
- On the Deployment page, click Create Deployment.
- In the Container configuration step, enable Full-chain Application Performance Management, and specify monitoring-related parameters.
- ParameterDescriptionParameterDescriptionMonitor application typeSelect the application type to monitor. Currently supported types include Java, Python, and Node.js.APM workspace(Optional) Select a workspace to store monitoring data for data management and isolation. Each workspace has its own independent data reporting credentials, allowing unified management of traces, logs, and metrics based on the application affiliation attribute. For more details, see Workspace management.tipTo configure a workspace, upgrade the ampplus-opentelemetry-collector add-on to v3.1.0 or later. For details, see Add-on release notes.Monitor Service Name(Optional) Specify the name of the monitoring service. This name will be used as the monitoring task name for the current workload and will be displayed in the service list of the APMPlus console. This makes it easier for you to distinguish between different monitoring tasks.tipIf you do not enter a name, the system will use the workload name as the monitoring service name by default.
- After you specify other workload parameters, click Confirm to complete the configuration. For more parameter configurations, see Creating Deployments.
Configure through kubectl
tip
Before you start, make sure that the following conditions are met:
- The kubectl tool has been installed on your on-premises computer. For details, see Installing and configuring kubectl.
- The target cluster has been connected through kubectl. For details, see Connecting to clusters.
When creating workloads in the cluster using YAML, you can configure application performance observability via annotations. The sample YAML code varies slightly for different application types.
Java
Python
NodeJS
The sample configuration code of the Java application is as follows:
apiVersion: apps/v1
kind: Deployment
metadata:
name: deployment-demo # The Deployment name.
namespace: default # The namespace where the Deployment resides.
spec:
replicas: 1 # The number of replicas for the Deployment.
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
annotations:
instrumentation.apmplus.volcengine.com/inject-java: "true" # Enable APMPlus observability injection.
instrumentation.apmplus.volcengine.com/java-container-names: "nginx,myapp" # (Optional) Specify containers for which you want to implement injection.
apmplus.volcengine.com/service.name: "doc-pod-demo" # (Optional) Specify the service name of the workload in APMPlus. If you do not specify the name, the pod name is used as the server name by default.
spec:
containers:
- name: nginx # The container name.
image: doc-cn-beijing.cr.volces.com/vke/nginx-demo:v1.0 # The container image address and tag.
ports:
- containerPort: 80 # Exposed container port number
env: # Use environment variables to specify the service name of the container in APMPlus. This configuration prevails over the apmplus.volcengine.com/service.name configuration in the annotation.
- name: OTEL_SERVICE_NAME
value: "container-demo"
The sample configuration code of the Python application is as follows:
apiVersion: apps/v1
kind: Deployment
metadata:
name: deployment-demo # The Deployment name.
namespace: default # The namespace where the Deployment resides.
spec:
replicas: 1 # The number of replicas for the Deployment.
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
annotations:
instrumentation.apmplus.volcengine.com/inject-python: "true" # Enable APMPlus observability injection.
instrumentation.apmplus.volcengine.com/python-container-names: "nginx,myapp" # (Optional) Specify containers for which you want to implement injection.
apmplus.volcengine.com/service.name: "doc-pod-demo" # (Optional) Specify the service name of the workload in APMPlus. If you do not specify the name, the pod name is used as the server name by default.
spec:
containers:
- name: nginx # The container name.
image: doc-cn-beijing.cr.volces.com/vke/nginx-demo:v1.0 # The container image address and tag.
ports:
- containerPort: 80 # Exposed container port number
env: # Use environment variables to specify the service name of the container in APMPlus. This configuration prevails over the apmplus.volcengine.com/service.name configuration in the annotation.
- name: OTEL_SERVICE_NAME
value: "container-demo"
The sample configuration code of the NodeJS application is as follows:
apiVersion: apps/v1
kind: Deployment
metadata:
name: deployment-demo # The Deployment name.
namespace: default # The namespace where the Deployment resides.
spec:
replicas: 1 # The number of replicas for the Deployment.
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
annotations:
instrumentation.apmplus.volcengine.com/inject-nodejs: "true" # Enable APMPlus observability injection.
instrumentation.apmplus.volcengine.com/nodejs-container-names: "nginx,myapp" # (Optional) Specify containers for which you want to implement injection.
apmplus.volcengine.com/service.name: "doc-pod-demo" # (Optional) Specify the service name of the workload in APMPlus. If you do not specify the name, the pod name is used as the server name by default.
spec:
containers:
- name: nginx # The container name.
image: doc-cn-beijing.cr.volces.com/vke/nginx-demo:v1.0 # The container image address and tag.
ports:
- containerPort: 80 # Exposed container port number
env: # Use environment variables to specify the service name of the container in APMPlus. This configuration prevails over the apmplus.volcengine.com/service.name configuration in the annotation.
- name: OTEL_SERVICE_NAME
value: "container-demo"
If your workload has containers of different languages, you can inject annotations for different languages at the same time. The example is as follows:
template:
metadata:
labels:
app: nginx
annotations:
instrumentation.apmplus.volcengine.com/inject-java: "true" # Enable observability injection for the Java application.
instrumentation.apmplus.volcengine.com/java-container-names: "myapp" # Implement Java injection for the container named myapp.
instrumentation.apmplus.volcengine.com/inject-python: "true" # Enable observability injection for the Python application.
instrumentation.apmplus.volcengine.com/python-container-names: "myapp2" # Implement Python injection for the container named myapp2.
spec:
...
Validate results
- Log in to the APMPlus console.
- In the left navigation bar, click Server-side monitoring. On the page that appears, click Click to go to the service list to go to the server-side monitoring page.
- In the left navigation bar of the Service List page, click Service monitoring > Services. In the service list, you can view the name of the workload monitoring service in the cluster.
- Click the service name to view its detailed monitoring information. For more details, see Service monitoring.
Last updated: 2026.08.19 17:46:23
All rights reserved © Beijing Volcano Engine Technology Co., Ltd2024
