EchoScribe is a modern, scalable blogging platform, built as a microservices architecture using .NET 8. This project showcases best practices in developing RESTful APIs, microservices orchestration, and cloud-native application development.
- Microservices architecture with individual services for Users, Blogs, and Comments.
- RESTful API endpoints implemented with .NET 8 minimal APIs.
- Robust data persistence with PostgreSQL.
- Asynchronous communication and message queuing (e.g., RabbitMQ/Kafka).
- Containerization with Docker and orchestration with Kubernetes.
- Comprehensive unit and integration testing with NUnit.
- CI/CD integration using Azure DevOps pipelines.
- Container management using Kubernetes configures with Helm charts.
- Global exception handling and robust logging.
- UserService: Manages user information and authentication.
- BlogService: Handles blog post creation, updates, and retrieval.
- CommentService: Manages comments on blog posts.
- ApiGateway: A central point for routing requests to respective services.
These instructions will get a copy of EchoScribe up and running on your local machine for development and testing purposes.
-
Clone the repository:
git clone https://github.com/rootiovo/echoscribe.git
-
Navigate to the service directory (e.g., UserService) you want to run:
cd EchoScribe.UserService/src/EchoScribe.UserService.API -
Build and run the service:
dotnet build dotnet run
-
Repeat steps 2 and 3 for other services, or use Docker Compose at the root:
docker-compose up
Execute the following commands to run the automated tests for EchoScribe.
dotnet test EchoScribe.UserService.Testsdotnet test EchoScribe.UserService.IntegrationTestsEchoScribe employs a robust CI/CD pipeline using GitHub Actions, ensuring that every commit and pull request is built, tested, and, upon merge, automatically deployed to an Amazon EKS (Elastic Kubernetes Service) cluster. This setup guarantees a consistent and reliable delivery process, essential for maintaining high-quality software.
- Automated Builds: On every push and pull request to the
mainbranch, the code is automatically built to check for compilation errors. - Testing: The pipeline runs all unit and integration tests, ensuring that new changes do not break existing functionality.
- Coding Standards Check: StyleCop is integrated into the pipeline to enforce coding standards and maintain code quality.
- Automated Deployment: Merged changes are automatically deployed to the Amazon EKS cluster, ensuring that the latest version of the application is always running.
- Build: The application is compiled to check for any compilation errors.
- Test: NUnit is used to run all unit and integration tests.
- StyleCop Check: Coding standards are enforced through automated checks, ensuring adherence to best practices.
- Deployment: Upon successful completion of the above steps, the application is deployed to Amazon EKS.
- The application uses Kubernetes manifests for deployment, ensuring scalable and manageable orchestration.
- The CI/CD pipeline is configured with necessary AWS credentials for secure deployment to the EKS cluster.
- For local development, developers can use Docker Compose to run the application in a containerized environment.
- The production deployment is handled through the CI/CD pipeline, ensuring a consistent and reliable process from development to production.
This CI/CD process forms the backbone of EchoScribe's development workflow, embodying best practices in continuous integration and deployment.
If you like my work and want to support me, consider buying me a coffee!
Contributions to EchoScribe are welcome! Please read CONTRIBUTING.md for details on our code of conduct and the process for submitting pull requests.
EchoScribe is licensed under the MIT License - see the LICENSE.md file for details.
- Thanks to all contributors and supporters of the EchoScribe project.