Absolutely, I've successfully set up this exact workflow to load-test PCF-hosted microservices using JMeter on PKS. Below's a practical, step-by-step guide based on that hands-on experience:

Prerequisites #

• A healthy PKS cluster (verify this with pks clusters and confirm your cluster shows as READY)
• kubectl configured to access your PKS cluster
• A robust JMeter Docker image optimized for Kubernetes deployments (I rely on a widely-used, community-maintained image for this setup)

Step 1: Prepare Kubernetes Manifests #

JMeter uses a master-slave architecture for distributed testing, so we'll create manifests to deploy each component on PKS:

1.1 Isolate Resources with a Namespace #

Create jmeter-namespace.yaml to keep JMeter resources separate:

apiVersion: v1
kind: Namespace
metadata:
  name: jmeter

1.2 JMeter Master Deployment #

The master handles test orchestration and hosts the GUI. Create jmeter-master.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jmeter-master
  namespace: jmeter
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jmeter
      role: master
  template:
    metadata:
      labels:
        app: jmeter
        role: master
    spec:
      containers:
      - name: jmeter-master
        image: justb4/jmeter:latest
        ports:
        - containerPort: 60000
        - containerPort: 5985
        command: ["jmeter", "-Dserver.rmi.localport=60000", "-Dserver_port=1099"]

1.3 JMeter Slave StatefulSet #

Slaves generate the actual load. Adjust the replica count based on your testing needs. Create jmeter-slaves.yaml:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: jmeter-slave
  namespace: jmeter
spec:
  serviceName: jmeter-slaves
  replicas: 3
  selector:
    matchLabels:
      app: jmeter
      role: slave
  template:
    metadata:
      labels:
        app: jmeter
        role: slave
    spec:
      containers:
      - name: jmeter-slave
        image: justb4/jmeter:latest
        command: ["jmeter-server", "-Dserver.rmi.localport=60000", "-Dserver_port=1099"]

1.4 Headless Service for Slave Discovery #

This lets the master automatically find all slave pods. Create jmeter-slave-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: jmeter-slaves
  namespace: jmeter
spec:
  clusterIP: None
  ports:
  - port: 1099
    name: jmeter-rmi
  - port: 60000
    name: jmeter-rmi-local
  selector:
    app: jmeter
    role: slave

Step 2: Deploy to PKS #

Apply all manifests in order to set up the JMeter cluster:

kubectl apply -f jmeter-namespace.yaml
kubectl apply -f jmeter-slave-service.yaml
kubectl apply -f jmeter-slaves.yaml
kubectl apply -f jmeter-master.yaml

Verify all pods are running successfully:

kubectl get pods -n jmeter

Step 3: Access the JMeter GUI #

Since the master runs inside the PKS cluster, use port forwarding to access the GUI on your local machine:

kubectl port-forward <jmeter-master-pod-name> 5985:5985 -n jmeter

Replace <jmeter-master-pod-name> with the actual pod name from the previous get pods output. Open your browser and navigate to http://localhost:5985 to launch the JMeter GUI.

Step 4: Configure Test Plan for PCF Microservices #

• Add an HTTP Request sampler to your test plan, targeting your PCF microservice's route (format: <app-name>.<pcf-system-domain>)
• Work with your PCF admin to update security groups and allow incoming traffic from the PKS cluster's IP range – this ensures JMeter can reach your microservices.

Step 5: Run Distributed Load Tests #

• In the JMeter GUI, go to Options > Remote Start and select all slave pods (you can use the headless service name jmeter-slaves.jmeter.svc.cluster.local to target all slaves at once)
• Once the test completes, copy results from the master pod to your local machine with:

kubectl cp <jmeter-master-pod-name>:/results/<test-result-file>.jtl ./local-results.jtl -n jmeter

Key Tips for Smooth Execution #

• Resource Allocation: Adjust CPU/memory requests/limits in the manifests based on your load scale. PKS supports namespace-level resource quotas to prevent resource contention.
• Persistent Storage: Attach a PersistentVolumeClaim to the master deployment to persist test results across pod restarts.
• Network Peering: If your PKS and PCF environments are in separate networks, ensure they're peered to avoid latency issues during testing.

内容的提问来源于stack exchange，提问作者vaquar khan