Skip to content
TheChatArchiveThe Chat Archive
Qwenqwen-max-2025-01-25· Alibaba (Qwen)Hugging Face LMArena Human Preference 140K

Hey mate, I need a simple app that makes a request to a REST endpoint, gets the response…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-235b-a22b-no-thinking’s answer.
  1. User

    Hey mate, I need a simple app that makes a request to a REST endpoint, gets the response (JSON) and stores it in Redis instance. It should run on a schedule (let's say once per hour). How can I implement such a solution using AWS services? Provide me with a few examples, describe every example, try to get as simple setups as possible. Thanks!

  2. Qwen Assistant

    Certainly! Below is a detailed explanation of how you can implement the described solution using AWS services. I'll provide two simple setups, each leveraging different AWS services to achieve the goal. Both solutions will involve making a REST API request, processing the JSON response, and storing it in a Redis instance, all while running on a schedule.


    Solution 1: Using AWS Lambda and Amazon ElastiCache for Redis

    Overview

    This setup uses AWS Lambda for the scheduled task, Amazon ElastiCache (Redis) for storage, and an HTTP client within the Lambda function to make the REST API request. The scheduling is handled by Amazon EventBridge (formerly CloudWatch Events).

    Steps to Implement

    1. Set Up Amazon ElastiCache for Redis:

      • Go to the AWS Management Console and navigate to ElastiCache.
      • Create a Redis cluster with default settings. Note the endpoint URL (e.g., my-redis-cluster.xxxxxx.ng.0001.use1.cache.amazonaws.com:6379).
      • Ensure the security group allows inbound access from your Lambda function's VPC or public internet (if not using a VPC).
    2. Create an AWS Lambda Function:

      • Navigate to the Lambda service in the AWS Console.
      • Create a new Lambda function with Python 3.x as the runtime.
      • Add the following code to the function:
      import json
      import redis
      import requests
      
      REDIS_HOST = 'my-redis-cluster.xxxxxx.ng.0001.use1.cache.amazonaws.com'
      REDIS_PORT = 6379
      API_URL = 'https://api.example.com/data'  # Replace with your REST API endpoint
      
      def lambda_handler(event, context):
          try:
              # Make the REST API request
              response = requests.get(API_URL)
              data = response.json()
      
              # Connect to Redis and store the data
              r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, decode_responses=True)
              r.set('api_response', json.dumps(data))
      
              return {
                  'statusCode': 200,
                  'body': 'Data successfully stored in Redis'
              }
          except Exception as e:
              return {
                  'statusCode': 500,
                  'body': f'Error: {str(e)}'
              }
      
      • Install the requests and redis libraries by packaging them with your Lambda deployment package or using AWS Lambda Layers.
    3. Schedule the Lambda Function:

      • Go to Amazon EventBridge in the AWS Console.
      • Create a new rule with a schedule expression like rate(1 hour) to trigger the Lambda function every hour.
      • Link the rule to your Lambda function as the target.
    4. Test the Setup:

      • Manually invoke the Lambda function to ensure it works as expected.
      • Verify that the data is stored in Redis by connecting to the Redis instance and checking the key api_response.

    Solution 2: Using AWS Fargate and Amazon ElastiCache for Redis

    Overview

    This setup uses AWS Fargate (a serverless compute engine for containers) to run a Docker container that performs the task. The container runs periodically using Amazon EventBridge Scheduler. This approach is more suitable if you prefer containerized workloads.

    Steps to Implement

    1. Set Up Amazon ElastiCache for Redis:

      • Follow the same steps as in Solution 1 to create a Redis cluster.
    2. Create a Docker Image:

      • Write a Python script (app.py) to handle the REST API request and Redis storage:
      import json
      import redis
      import requests
      import os
      import time
      
      REDIS_HOST = os.getenv('REDIS_HOST')
      REDIS_PORT = int(os.getenv('REDIS_PORT'))
      API_URL = os.getenv('API_URL')
      
      def main():
          while True:
              try:
                  # Make the REST API request
                  response = requests.get(API_URL)
                  data = response.json()
      
                  # Connect to Redis and store the data
                  r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, decode_responses=True)
                  r.set('api_response', json.dumps(data))
      
                  print("Data successfully stored in Redis")
              except Exception as e:
                  print(f"Error: {str(e)}")
              time.sleep(3600)  # Sleep for 1 hour
      
      if __name__ == "__main__":
          main()
      
      • Create a Dockerfile to containerize the application:
      FROM python:3.9-slim
      WORKDIR /app
      COPY . /app
      RUN pip install requests redis
      CMD ["python", "app.py"]
      
      • Build and push the Docker image to Amazon Elastic Container Registry (ECR).
    3. Set Up AWS Fargate:

      • Create an ECS cluster in the Amazon ECS console.
      • Define a task definition that uses the Docker image from ECR.
      • Configure environment variables (REDIS_HOST, REDIS_PORT, API_URL) in the task definition.
    4. Schedule the Task:

      • Use Amazon EventBridge Scheduler to trigger the ECS task every hour.
      • Configure the scheduler to start the ECS task with the appropriate task definition.
    5. Test the Setup:

      • Run the ECS task manually to verify that it works.
      • Check the Redis instance to confirm that the data is stored correctly.

    Comparison of Solutions

    FeatureSolution 1 (Lambda + Redis)Solution 2 (Fargate + Redis)
    Ease of SetupSimple, fully managed by AWSRequires Docker and ECS knowledge
    ScalabilityLimited to Lambda execution limitsHighly scalable with ECS
    CostLower cost for infrequent tasksHigher cost due to container usage
    FlexibilityLimited to Lambda runtimeFull control over container runtime

    Recommendation

    If simplicity and low cost are your priorities, go with Solution 1 (Lambda + Redis). If you need more flexibility or plan to expand the application in the future, consider Solution 2 (Fargate + Redis).

    Let me know if you need further clarification or assistance with implementation!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.