💡Building Microservices Architecture using Docker, CI/CD, RabbitMQ and caching with Redis.

📅 Deadline: 28th April, 2024.

System Overview:

The Healthcare Appointment Scheduling System is a robust and scalable application designed to streamline the appointment scheduling process for healthcare providers and patients. It leverages microservices architecture using Docker, implements CI/CD pipelines for seamless deployment, integrates RabbitMQ for asynchronous communication, utilizes Redis for caching patient data and appointment schedules, implements rate limiting to manage system load, and incorporates a custom API gateway for secure and efficient communication between services.

Requirements Analysis:

• Functional Requirements -
  • Authentication and authorization for healthcare providers and patients.
  • Ability for patients to schedule appointments with healthcare providers.
  • Support for selecting preferred providers, specifying appointment types, and viewing available time slots.
  • Sending email to patients and providers for appointment confirmations, reminders, and cancellations.
  • Management of billing information for appointments.
  • Storage and retrieval of patients' electronic health records (EHR).
  • Role based access control to ensure only authorized healthcare providers can view patient records.
  • Utilization of Redis as a caching layer to store frequently accessed patient data, appointment schedules, and EHRs.
  • Implementation of rate limiting in the API Gateway to prevent abuse and ensure fair usage of system resources.
  • Development of a custom API gateway to centralize authentication, routing, and rate limiting functionalities.
  • Setup of CI/CD pipelines using GitHub Actions to automate the build, test, and deployment processes for each microservice and publish them to Dockerhub.
  • Ensuring continuous delivery and integration of new features and updates.
  • Facilitating seamless onboarding, maintenance, and troubleshooting of the system.
• Non-Functional Requirements -
  1. Performance -
     • The system should be able to handle a large number of concurrent users without significant degradation in response time.
     • The average response time for critical operations (e.g., scheduling appointments, retrieving health records) should be below a certain threshold (e.g., 500 milliseconds).
  2. Scalability -
     • The system should be designed to scale horizontally to accommodate growing user and data volumes.
     • It should support elasticity, allowing resources to be dynamically allocated and deallocated based on demand.
  3. Reliability -
     • The system be highly available, minimizing downtime, with an uptime of at least 99.9%.
     • It should be resilient to failures, with built-in redundancy and failover mechanisms to ensure continuous operation.
     • Data integrity should be maintained at all times, with appropriate backup and recovery procedures in place.
  4. Security -
     • User authentication and authorization should be implemented securely, following industry best practices.
     • Patient health records and sensitive information should be encrypted both in transit and at rest.
     • The system should be protected against common security threats such as cross-site scripting (XSS), SQL injection, and unauthorized access.
  5. Maintainability -
     • The system should be modular and well-organized, with clear separation of concerns between components.
     • Automated testing and continuous integration practices should be employed to facilitate code maintenance and updates.

Data Model Design:

This is the general data model which reflects our requirements -

Database:

Although our data model has relational characteristics, it's not essential to store all data in a single database. Doing so could constrain scalability and create performance bottlenecks.

Instead, we'll distribute the data across multiple services, each responsible for managing specific tables. For our needs, we can employ either a relational database like PostgreSQL or a distributed NoSQL solution like Apache Cassandra. This approach optimizes both performance and scalability.

Architecture:

We will be using Microservices Architecture since it will make it easier to horizontally scale and decouple our services. Each service will have ownership of its own data model. Let's try to divide our system into some core services.

Services: