Merge pull request #49 from DevOps-Cloud-Team5/SCRUM-92_cf

load testing, testing, tf doc

Author: MaxMB15

.github/workflows/cd.yml

@@ -50,6 +50,18 @@ jobs:
         chmod +x ./getEnv.sh && ./getEnv.sh
         python manage.py migrate
 
+    - name: Run DB migrations
+      run: |
+        source venv/bin/activate
+        chmod +x ./getEnv.sh && ./getEnv.sh
+        python manage.py migrate
+
+    - name: Run API Tests
+      run: |
+        source venv/bin/activate
+        chmod +x ./getEnv.sh && ./getEnv.sh
+        chmod +x ./test_backend.sh && ./test_backend.sh
+
     - name: Setup up Requirements
       run: |
         source venv/bin/activate

.github/workflows/cloudFormation.yml

@@ -95,6 +95,12 @@ jobs:
         chmod +x ./getEnv.sh && ./getEnv.sh
         python manage.py migrate
 
+    - name: Run API Tests
+      run: |
+        source venv/bin/activate
+        chmod +x ./getEnv.sh && ./getEnv.sh
+        chmod +x ./test_backend.sh && ./test_backend.sh
+
     - name: Setup up Requirements
       run: |
         source venv/bin/activate

terraform.md

@@ -0,0 +1,51 @@
+# Terraform AWS Lambda and API Gateway Configuration
+
+This Terraform configuration sets up an AWS infrastructure that includes Lambda functions and an API Gateway to expose those functions as HTTP endpoints. This is part of the backend for the `PLACEHOLDER_PROJECT_NAME` project.
+
+## Overview
+
+The configuration provisions the following resources:
+- AWS IAM Role and Policy for Lambda execution and CloudWatch logging.
+- AWS Lambda function to run the application code.
+- AWS API Gateway to expose the Lambda function via HTTP endpoints.
+- S3 Bucket Website Configuration for redirects.
+
+## Requirements
+
+- Terraform ~> 5.0
+- AWS Provider ~> 3.0
+- AWS CLI configured with appropriate access rights.
+
+## Usage
+
+To use this Terraform configuration:
+1. Ensure AWS CLI is configured with the necessary access credentials.
+2. Replace `PLACEHOLDER_PROJECT_NAME` and `PLACEHOLDER_REGION` with actual values in the configuration.
+3. Initialize Terraform:
+   ```bash
+   terraform init
+   ```
+4. Apply the Terraform configuration:
+   ```bash
+   terraform apply
+   ```
+
+## Resources
+
+- **aws_iam_role.lambda_role**: IAM Role for AWS Lambda execution with the necessary permissions.
+- **aws_lambda_function.app**: The Lambda function containing the backend logic.
+- **aws_api_gateway_rest_api.api**: The API Gateway setup for HTTP access to the Lambda function.
+- **aws_api_gateway_deployment.deployment**: Deployment instance for the API Gateway.
+- **aws_s3_bucket_website_configuration.redirect_bucket**: S3 Bucket configured for web hosting and redirects.
+- **aws_iam_policy.cloudwatch_logs**: IAM Policy for logging to AWS CloudWatch.
+- **aws_iam_role_policy_attachment.cloudwatch_logs_attachment**: Attaches the CloudWatch logging policy to the Lambda execution role.
+
+## Outputs
+
+- **api_url**: The URL of the deployed API Gateway endpoint. This URL is used to access the Lambda function over the web.
+
+## Notes
+
+- Ensure to replace `PLACEHOLDER_PROJECT_NAME` with your project's name to correctly configure resource names and references.
+- `PLACEHOLDER_REGION` should be replaced with the AWS region you intend to deploy your resources in.
+- It is recommended to manage sensitive information, such as AWS credentials and any other secrets, outside of this Terraform configuration for security reasons.

test_load.py

@@ -0,0 +1,92 @@
+import requests
+import concurrent.futures
+import time
+import sys
+
+# Redirect standard output to a file
+original_stdout = sys.stdout
+with open('test_load_details.txt', 'w') as f:
+    sys.stdout = f
+
+    # The URL of the endpoint you want to test
+    url = 'https://bmjg67cbef.execute-api.eu-central-1.amazonaws.com/prod/docs/'
+
+    # Function to make a single HTTP request
+    def make_request():
+        try:
+            start_time = time.time()
+            response = requests.get(url)  # You can change this to requests.post() if needed
+            end_time = time.time()
+
+            return {
+                'status_code': response.status_code,
+                'response_time': end_time - start_time
+            }
+        except Exception as e:
+            return {
+                'error': str(e)
+            }
+
+    # Number of requests you want to make (if negative, resort to time_limit)
+    num_requests = 12000
+
+    # Time limit for the load test (2 minutes)
+    time_limit = 120
+
+    # List to store response times and status codes
+    responses = []
+
+    # Record the start time of the load test
+    start_time = time.time()
+
+    # Use ThreadPoolExecutor to manage concurrent requests
+    if num_requests > 0:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:
+            future_to_request = {executor.submit(make_request): i for i in range(num_requests)}
+            for future in concurrent.futures.as_completed(future_to_request):
+                response = future.result()
+                responses.append(response)
+    else:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:
+            # Run the loop for time_limit
+            while time.time() - start_time < time_limit:
+                # Submit a new request
+                future = executor.submit(make_request)
+                # Get the result of the request and add it to the list of responses
+                try:
+                    response = future.result(timeout=1)  # Set a timeout for each request if needed
+                    responses.append(response)
+                except concurrent.futures.TimeoutError:
+                    responses.append({'error': 'Request timed out'})
+
+    # Record the end time of the load test
+    end_time = time.time()
+
+    # Calculate and print the total execution time of the load test
+    total_time = end_time - start_time
+    print(f"Total execution time: {total_time} seconds")
+
+    # Print the total number of requests
+    print(f"Total requests: {len(responses)} requests")
+
+    # Print the total number of successful requests
+    success_responses = sum(1 for d in responses if d.get('status_code') == 200)
+    print(f"Total successful requests: {success_responses} requests")
+
+    # Calculate and print the average response time
+    average_response_time = sum(d['response_time'] for d in responses if 'response_time' in d) / len(responses)
+    print(f"Average response time: {average_response_time} seconds")
+
+    # Calculate and print success rate
+    success_rate = 100.0 * (1.0 * success_responses / len(responses))
+    print(f"Success rate: {success_rate}%")
+
+    # Optionally, log the detailed responses or any errors encountered
+    for response in responses:
+        if 'error' in response:
+            print(f"Error: {response['error']}")
+        else:
+            print(f"Status Code: {response['status_code']}, Response Time: {response['response_time']} seconds")
+
+    # Reset standard output to original
+    sys.stdout = original_stdout