AWS Music Subscription Application

Project Overview

The AWS Music Subscription Application is a comprehensive project developed using various AWS services to provide users with a seamless music subscription experience. The application allows users to register, login, subscribe to music, and query music based on title, artist, and year.

Technologies Used

• AWS EC2: The application is hosted on an Amazon EC2 instance, providing a scalable and reliable infrastructure for running the backend server.
• AWS S3: Amazon S3 is used to store and serve the artist images, ensuring fast and efficient delivery of media assets to the application.
• AWS API Gateway: API Gateway is utilized to create and manage the APIs that enable communication between the frontend and backend components of the application.
• AWS Lambda: Lambda functions are employed to handle specific backend tasks, such as querying the music database and updating user subscriptions, allowing for serverless computing and automatic scaling.
• AWS DynamoDB: DynamoDB, a NoSQL database service, is used to store and retrieve user information, music metadata, and subscription details, providing fast and scalable data storage.
• Python: The backend server is implemented using the Python programming language, leveraging the Flask framework for building the RESTful API endpoints.
• HTML/CSS/JavaScript: The frontend of the application is built using HTML for structure, CSS for styling, and JavaScript for interactivity and communication with the backend API.

Features

• User Registration and Login: Users can create an account by providing their email, username, and password. They can then log in to the application using their credentials, which are securely stored and authenticated using DynamoDB.
• Music Subscription Management: Once logged in, users can browse and subscribe to various music tracks. They can view their subscribed music, including the title, artist, and year, and also remove subscriptions as desired. The subscription information is stored in DynamoDB for efficient retrieval and management.
• Music Querying: The application provides a powerful music querying feature that allows users to search for music based on title, artist, and year. The backend server handles these queries by interacting with the music metadata stored in DynamoDB, returning the relevant results to the frontend for display.
• Integration with AWS Services: The project seamlessly integrates various AWS services to leverage their capabilities. EC2 hosts the backend server, S3 stores and serves artist images, API Gateway manages the API endpoints, Lambda functions handle specific backend tasks, and DynamoDB stores and retrieves data. This integration ensures scalability, reliability, and efficient performance of the application.

Code Snippets

Here are a few code snippets that demonstrate the key functionalities of the application:

User Registration

The following code snippet shows the backend API endpoint for user registration:

@app.route("/register", methods=["POST"])
def register():
    data = request.get_json()
    email = data.get("email")
    username = data.get("username")
    password = data.get("password")

    # Check if user exists in DynamoDB
    response = table.get_item(Key={"email": email})

    if "Item" in response:
        return jsonify({"message": "User already exists"}), 409

    # Add user to DynamoDB
    table.put_item(Item={"email": email, "user_name": username, "password": password})

    return jsonify({"message": "User created successfully"}), 201

Music Querying

The following code snippet demonstrates the backend API endpoint for querying music based on title, artist, and year:

@app.route("/query", methods=["POST"])
def query():
    data = request.get_json()
    title = data.get("title", "")
    year = data.get("year", "")
    artist = data.get("artist", "")

    music_table = dynamodb.Table("music")

    filter_expression = None

    if title:
        filter_expression = Attr("title").begins_with(title)

    if year:
        year_filter = Attr("year").begins_with(year)
        filter_expression = filter_expression & year_filter if filter_expression else year_filter

    if artist:
        artist_filter = Attr("artist").begins_with(artist)
        filter_expression = filter_expression & artist_filter if filter_expression else artist_filter

    if filter_expression:
        response = music_table.scan(FilterExpression=filter_expression)
        items = response["Items"]
    else:
        response = music_table.scan()
        items = response["Items"]

    return jsonify({"results": items})

Setup and Deployment

1. Set up the necessary AWS services, including EC2 for hosting the backend server, S3 for storing artist images, API Gateway for managing API endpoints, Lambda for serverless computing, and DynamoDB for data storage.
2. Deploy the application files to the appropriate AWS services. The backend server code (music_server.py) should be deployed to an EC2 instance, while the frontend files (index.html, register.html, main.html, and associated CSS and JavaScript files) can be served from an S3 bucket or any other web hosting service.
3. Configure the necessary permissions and settings for each AWS service. Set up appropriate IAM roles and policies to grant the required access permissions to the EC2 instance, Lambda functions, and DynamoDB tables. Configure the API Gateway to map the API endpoints to the corresponding backend server routes.
4. Access the application through the provided URL. Users can register, log in, subscribe to music, and query music using the intuitive web interface.

Future Enhancements

• Implement user profile management, allowing users to update their information and preferences.
• Add music playback functionality to enable users to listen to their subscribed music directly within the application.
• Integrate with a music streaming service API to provide a larger library of music tracks and enhance the user experience.
• Implement music recommendations based on user preferences and listening history using machine learning algorithms.
• Enhance the user interface with more interactive features, such as music visualizations and social sharing options.

Project Resources

• GitHub Repository
• AWS Documentation

The AWS Music Subscription Application demonstrates the power and flexibility of combining various AWS services to build a scalable and feature-rich music platform. By leveraging the capabilities of EC2, S3, API Gateway, Lambda, and DynamoDB, the application provides a seamless music subscription experience to users while ensuring efficient performance and data management.

If you have any questions or would like to discuss the project further, please feel free to reach out. Let's explore how we can leverage AWS services to create innovative solutions in the world of music and beyond.