Load Testing Feature (REF ISSUE #11)

[nikosmokas]

The feature will be broken down into microservices that will be used for other functionalities.

• 1. Queue Management Service
• 2. EC2 Management Service
• 3. Load Testing Execution Service
• 4. Result Aggregation Service

1. Queue Management Service

• Stack:
  • Spring Boot for API development
  • Redis or RabbitMQ for queue management (Java library: Lettuce or Spring Data Redis for Redis; Spring AMQP for RabbitMQ)
• API:
  • POST /queue: Adds a job to the queue.
  • GET /queue/status: Checks the status of the queue.
  • DELETE /queue: Dequeues a job and marks it for execution.
• Details:
  • Use Spring Boot to create a REST API.
  • Use Spring Data Redis for integrating Redis with Spring Boot, managing queues, and caching.
  • Optionally, use RabbitMQ if you need more advanced messaging capabilities.

2. EC2 Management Service

• Stack:
  • Spring Boot for API development
  • AWS SDK for Java for EC2 provisioning and termination
  • Terraform (optional) managed through Spring Boot using a subprocess call or a Java Terraform client.
• API:
  • POST /ec2/provision: Provisions EC2 instances.
  • DELETE /ec2/terminate: Terminates EC2 instances.
  • Internal Communication: Listens to messages from the Queue Management Service to decide when to spin up or tear down instances.
• Details:
  • Use Spring Boot to create REST endpoints for provisioning and terminating EC2 instances.
  • Use AWS SDK for Java to interact with AWS services.
  • Terraform can be invoked from within the Java application if you need infrastructure-as-code benefits.

3. Load Testing Execution Service

• Stack:
  • Spring Boot for API development and load test coordination
  • Apache JMeter or Gatling for load testing (Java-based tools)
  • Spring Boot Actuator for monitoring health and metrics
• Behavior:
  • Receives commands to start load testing, executes load tests using JMeter or Gatling, and sends results back to the Result Aggregation Service.
• Details:
  • Create a Spring Boot microservice that triggers JMeter or Gatling tests using command-line execution or a Java API wrapper.
  • The service can collect metrics and send them to the Result Aggregation Service.
  • Use Spring Boot Actuator for monitoring service health and performance metrics.

4. Result Aggregation Service

• Stack:
  • Spring Boot for API development
  • MongoDB (Java library: Spring Data MongoDB) or PostgreSQL (if relational storage is preferred)
• API:
  • POST /results: Accepts results data from the Load Testing Execution Service.
  • GET /results/:jobId: Retrieves aggregated results for a particular job.
• Details:
  • Use Spring Boot to create REST endpoints for storing and retrieving test results.
  • Integrate with MongoDB using Spring Data MongoDB for schema-less storage, or use Spring Data JPA with PostgreSQL if relational storage is needed.
  • Ensure results are aggregated and accessible through API endpoints.

Revised Example Workflow in a Microservices Architecture with Spring Boot

1. User Submits a Test:

   • The user submits a test through the frontend. The main API routes this request to the Queue Management Service.

2. Queue Management:

   • The Queue Management Service adds the test job to the queue (using Redis or RabbitMQ) and signals the EC2 Management Service to provision instances.

3. Provisioning:

   • The EC2 Management Service provisions EC2 instances using the AWS SDK for Java (or Terraform) and notifies the Load Testing Execution Service.

4. Load Testing Execution:

   • The Load Testing Execution Service runs the load tests on the provided URL using Apache JMeter or Gatling and streams or sends results back to the Result Aggregation Service.

5. Result Aggregation:

   • The Result Aggregation Service collects and processes the test results, making them available for querying.

6. Tear Down:

   • After the test, the Queue Management Service checks if more tests are pending. If not, the EC2 Management Service is instructed to terminate the instances.

7. User Receives Results:

   • The frontend polls or is notified by the main API when the results are ready, and the user can view the aggregated data.

Additional Enhancements with Spring Boot:

• Containerization and Orchestration:

  • Each microservice can be containerized using Docker and managed with Kubernetes (K8s). Spring Boot applications are easy to package into containers and deploy in a Kubernetes cluster.

• Monitoring and Observability:

  • Use Prometheus to collect metrics from the microservices. Leverage Spring Boot Actuator to expose metrics in a format compatible with Prometheus.
  • Use Grafana to visualize these metrics and monitor the health and performance of each microservice.

Spring Boot Configuration and Best Practices:

• Configuration Management:

  • Use Spring Cloud Config for managing configurations across multiple environments (e.g., dev, staging, production).

• Service Discovery:

  • Use Spring Cloud Netflix Eureka or Consul for service discovery if dynamic scaling or service registry is needed.

• API Gateway:

  • Consider using Spring Cloud Gateway to handle routing, load balancing, and authentication for the microservices.

• Security:

  • Use Spring Security to secure the APIs, ensuring that communication between microservices is secure and authenticated.

[nikosmokas]

Queue Management Service:

Build the jar file

./mvnw clean package

Build the Docker image

docker build -t queue-management-service .

Run the Docker container

docker run --name redis -p 6379:6379 -d redis
docker run -p 8080:8080 --name queue-management-service --link redis:redis queue-management-service