How to analyze Java application performance with async-profiler in Amazon EKS

Analyzing the performance of a full-stack application (Java and Angular) running on Amazon EKS requires a combined approach, as async-profiler is primarily focused on the Java backend. Async-Profiler is a low-overhead sampling profiler for Java applications running on the HotSpot JVM. For the Angular frontend, you’ll primarily rely on browser developer tools and potentially some Angular-specific profiling techniques. Container startup performance presents a significant challenge for Java-angular applications running on Kubernetes, particularly during scaling events and recovery scenarios. Performance profiling in containerized Java applications has long presented significant challenges. Async-profiler, a lightweight sampling solution that offers an interesting approach for Java workloads running on Amazon Elastic Kubernetes Service (Amazon EKS). Eliminating traditional Safepoint bias issues enables more accurate performance analysis. To analyze Java application performance with async-profiler in Amazon EKS (Elastic Kubernetes Service), need to follow below steps — 1. Environment Setup Prerequisites AWS Account with EKS access Java 21 Spring Boot backend application Angular frontend application AWS Cloud-Shell for environment bootstrapping Amazon EKS cluster Initial Setup Steps 1. Deploy Infrastructure: Using eksctl to create EKS cluster eksctl create cluster — name full-stack-cluster — region your-region 2. Configure Container Registry: Create repositories in Amazon ECR for both frontend and backend images Push your container images to ECR 2. Application Containerization Backend (Java) Containerization FROM openjdk:21-jdk AS builder WORKDIR /app COPY . /app RUN ./mvnw clean package FROM openjdk:21-jre RUN apt-get update && apt-get install -y async-profiler COPY — from=builder /app/target/app.jar /app/app.jar ENTRYPOINT [“java”, “-agentpath:/async-profiler/libasyncProfiler.so=start,event=cpu,file=/tmp/profile.html”, “-jar”, “/app/app.jar”] Frontend (Angular) Containerization FROM node:latest AS builder WORKDIR /app COPY . . RUN npm install RUN npm run build — prod FROM nginx:alpine COPY — from=builder /app/dist/* /usr/share/nginx/html/ 3. Performance Monitoring Setup Backend Profiling 1. Configure Async-Profiler deployment.yaml spec: containers: — name: backend env: — name: JAVA_TOOL_OPTIONS value: “-agentpath:/async-profiler/libasyncProfiler.so=start,event=cpu,file=/tmp/profile.html” 2. Enable Continuous Profiling volumeMounts: — name: profiles mountPath: /tmp/profiles volumes: — name: profiles persistentVolumeClaim: claimName: s3-profile-storage Frontend Monitoring 1. Install Angular DevTools Add Chrome DevTools extension for Angular performance monitoring Enable performance tracking in your Angular application: // main.ts if (environment.production) { enableProdMode(); if (window) { window.console.log = () => {}; } } 4. Data Collection and Analysis Backend Performance Analysis 1. CPU Profiling: Access the pod kubectl exec -it — /bin/bash Start profiling jcmd 1 AsyncProfiler:start,event=cpu,file=/tmp/cpu-profile.html 2. Memory Analysis: Heap allocation profiling jcmd 1 AsyncProfiler:start,event=alloc,file=/tmp/heap-profile.html Frontend Performance Analysis 1. Use Chrome Dev-Tools: Open Chrome Dev-Tools (F12) Navigate to Performance tab Record page load and user interactions 2. Angular-Specific Metrics: Monitor change detection cycles Track component render times Analyze bundle sizes 5. Visualization and Monitoring Integrated Monitoring Setup 1.Configure Grafana Dashboard: grafana-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: grafana spec: template: spec: containers: — name: grafana image: grafana/grafana 2. Set up Prometheus: Deploy Prometheus for metrics collection Configure scrape targets for both frontend and backend Performance Data Visualization 1. Create Custom Dashboards: Backend metrics (response times, CPU usage) Frontend metrics (page load times, component performance) End-to-end transaction traces 6. Optimization Process 1. Analyze Bottlenecks: Review Flame Graphs from Async-Profiler Check Angular Dev-Tools reports Examine end-to-end transaction traces 2. Implement Improvements: Optimize database queries Implement caching where appropriate Reduce bundle sizes Optimize Angular change detection 3. Verify Improvements: Re-run profiling after changes Compare before/after metrics Monitor user experience metrics 7. Cleanup Remove profiling data kubectl exec -it — rm /tmp/profile.html Delete monitoring resources kubectl delete -f grafana-deployment.yaml kubectl delete -f prometheus-deployment.yaml Delete EKS cluster eksctl delete cluster — name full-stack-cluster Conclusion: Async-Profiler is a powerful tool for profiling Java applications, identifying performance bottlenecks such as high CPU usage, memory leaks, and i

May 18, 2025 - 15:24

How to analyze Java application performance with async-profiler in Amazon EKS

Analyzing the performance of a full-stack application (Java and Angular) running on Amazon EKS requires a combined approach, as async-profiler is primarily focused on the Java backend. Async-Profiler is a low-overhead sampling profiler for Java applications running on the HotSpot JVM. For the Angular frontend, you’ll primarily rely on browser developer tools and potentially some Angular-specific profiling techniques. Container startup performance presents a significant challenge for Java-angular applications running on Kubernetes, particularly during scaling events and recovery scenarios.

Performance profiling in containerized Java applications has long presented significant challenges. Async-profiler, a lightweight sampling solution that offers an interesting approach for Java workloads running on Amazon Elastic Kubernetes Service (Amazon EKS). Eliminating traditional Safepoint bias issues enables more accurate performance analysis.

To analyze Java application performance with async-profiler in Amazon EKS (Elastic Kubernetes Service), need to follow below steps —

1. Environment Setup

Prerequisites

AWS Account with EKS access
Java 21 Spring Boot backend application
Angular frontend application
AWS Cloud-Shell for environment bootstrapping
Amazon EKS cluster
Initial Setup Steps

1. Deploy Infrastructure:

Using eksctl to create EKS cluster
eksctl create cluster — name full-stack-cluster — region your-region

2. Configure Container Registry:

Create repositories in Amazon ECR for both frontend and backend images
Push your container images to ECR

2. Application Containerization

Backend (Java) Containerization

FROM openjdk:21-jdk AS builder
WORKDIR /app
COPY . /app
RUN ./mvnw clean package
FROM openjdk:21-jre
RUN apt-get update && apt-get install -y async-profiler
COPY — from=builder /app/target/app.jar /app/app.jar
ENTRYPOINT [“java”, “-agentpath:/async-profiler/libasyncProfiler.so=start,event=cpu,file=/tmp/profile.html”, “-jar”, “/app/app.jar”]

Frontend (Angular) Containerization

FROM node:latest AS builder
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build — prod
FROM nginx:alpine
COPY — from=builder /app/dist/* /usr/share/nginx/html/

3. Performance Monitoring Setup

Backend Profiling
1. Configure Async-Profiler

deployment.yaml
spec:
containers:
— name: backend
env:
— name: JAVA_TOOL_OPTIONS
value: “-agentpath:/async-profiler/libasyncProfiler.so=start,event=cpu,file=/tmp/profile.html”

2. Enable Continuous Profiling

volumeMounts:
— name: profiles
mountPath: /tmp/profiles
volumes:
— name: profiles
persistentVolumeClaim:
claimName: s3-profile-storage

Frontend Monitoring
1. Install Angular DevTools

Add Chrome DevTools extension for Angular performance monitoring
Enable performance tracking in your Angular application:

// main.ts
if (environment.production) {
enableProdMode();
if (window) {
window.console.log = () => {};
}
}

4. Data Collection and Analysis

Backend Performance Analysis
1. CPU Profiling:

Access the pod
kubectl exec -it — /bin/bash
Start profiling
jcmd 1 AsyncProfiler:start,event=cpu,file=/tmp/cpu-profile.html

2. Memory Analysis:

Heap allocation profiling
jcmd 1 AsyncProfiler:start,event=alloc,file=/tmp/heap-profile.html

Frontend Performance Analysis
1. Use Chrome Dev-Tools:

Open Chrome Dev-Tools (F12)
Navigate to Performance tab
Record page load and user interactions

2. Angular-Specific Metrics:

Monitor change detection cycles
Track component render times
Analyze bundle sizes

5. Visualization and Monitoring

Integrated Monitoring Setup
1.Configure Grafana Dashboard:

grafana-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: grafana
spec:
template:
spec:
containers:
— name: grafana
image: grafana/grafana

2. Set up Prometheus:

Deploy Prometheus for metrics collection
Configure scrape targets for both frontend and backend

Performance Data Visualization
1. Create Custom Dashboards:

Backend metrics (response times, CPU usage)
Frontend metrics (page load times, component performance)
End-to-end transaction traces

6. Optimization Process

1. Analyze Bottlenecks:

Review Flame Graphs from Async-Profiler
Check Angular Dev-Tools reports
Examine end-to-end transaction traces

2. Implement Improvements:

Optimize database queries
Implement caching where appropriate
Reduce bundle sizes
Optimize Angular change detection

3. Verify Improvements:

Re-run profiling after changes
Compare before/after metrics
Monitor user experience metrics

7. Cleanup

Remove profiling data
kubectl exec -it — rm /tmp/profile.html
Delete monitoring resources
kubectl delete -f grafana-deployment.yaml
kubectl delete -f prometheus-deployment.yaml
Delete EKS cluster
eksctl delete cluster — name full-stack-cluster

Conclusion:
Async-Profiler is a powerful tool for profiling Java applications, identifying performance bottlenecks such as high CPU usage, memory leaks, and inefficient thread execution.

For Angular, browser-based profiling tools like Chrome DevTools help uncover slow rendering, excessive API calls, and unnecessary change detection cycles.

Automating profiling and integrating it into CI/CD pipelines ensures ongoing performance health and early detection of regressions.

By combining Async-Profiler, Angular debugging techniques, and AWS observability tools, teams can proactively improve performance, reduce latency, and optimize cloud resources for a smoother user experience.