PV217 Service Oriented Architecture

Project Information & Teams

Lectures 4,5,6 will have an hands-on approach towards the creation of microservices that can be used for the creation of the project in teams of three. To get in touch with Martin Stefanko directly if you need help with the project, you can create an account at https://quarkusio.zulipchat.com/login/
You can get in touch with Martin Stefanko via Zulip (https://quarkusio.zulipchat.com/login/).

Timeline

* by 25.9.2022 Teams of three formed. You can add your name/team to the following document: https://docs.google.com/spreadsheets/d/1lS52fzs9iqJz3ZvPp_GP0RwOqm1j-zvEbmTDJfEb72E/edit?usp=sharing

* 3.10 (lect4), 10.10 (lect5), 17.10 (lect6) hands-on lectures for the creation of microservices. Not obligatory, but If you want to follow the lectures by trying the examples, you can install upfront the pre-requisites on your machine: https://github.com/xstefank/pv217-microservices/blob/master/02-quarkus/prerequisites.adoc

* by 26.9.2022 Main project requirements presented and discussed with students.

* By 1.10.2022 all teams should have decided the domain of the system to be implemented, the project can start.

* ~~28.11.2022~~ 5.12.2022 Final projects presented.

Main Project Requirements

1. Pick some domain of the system under development that you agree within your team. This can be anything related to work, study, but also any domain that you think could be interesting for you. Examples can be an eshop, some platform to sell used items, platform to manage emergencies, etc... Anything that you think could be worth scaling-up with microservices and that can be interesting for some team members.
If you do not come up with some domain, do not worry, we will assign you some project description. Give also a name to your platform :)

After you have decided, you can add the project domain to the teams document: https://docs.google.com/spreadsheets/d/1lS52fzs9iqJz3ZvPp_GP0RwOqm1j-zvEbmTDJfEb72E/edit?usp=sharing

2. Create a repository on GitHub, in which you will collect the source code and the documentation about the project and collaborate within your team. Add the info about the repository to the Google document above.

3. Add to the repository a short description of the system, and the main requirements that you think are worth to be included for the project and how you would divide it into services (we will have more in the course, after the 4 technical lectures block).

4. Each student should take the responsibility of one/two microservices, there can be students that can take more responsibility on other implementation, like the monitoring part, testing, etc... you can also have students more into documentation/design if not confident with implementation, but at least everybody should get hands on some part of the system.

Technical Requirements

+ For the implementation, try to keep with the technology stack presented during the lecture Quarkus, Docker/Podman, etc... All the following points will be covered during the block lectures:
+ Have the API design & contract available in the project documentation or integrated in the Quarkus project (e.g., using https://swagger.io - https://quarkus.io/guides/openapi-swaggerui)
+ Have some monitoring part for the services collecting metrics about usage (https://quarkus.io/guides/microprofile-metrics);
+ Have at least one service that can show self-healing capabilities (https://quarkus.io/guides/microprofile-health);
+ All services have some meaningful tests running (https://quarkus.io/guides/getting-started-testing);
+ Have some simple database support for at least one service (https://quarkus.io/guides/hibernate-orm-panache);
+ Process monitoring data and visualization with Prometheus + Grafana (https://quarkus.io/guides/microprofile-metrics);
+ (optional) Use Jaeger for tracing (https://quarkus.io/guides/opentracing);
+ (optional) Use of Kafka for asynchronous messaging (https://quarkus.io/guides/kafka)
+ (optional) Use of authentication for some microservices with JWT (JSON Web Tokens);
+ (optional) The project can be deployed with Docker/Podman;
+ (optional) The project can be deployed on Kubernetes/Minikube or Openshift/CRC;
+ (optional) show the usage of native executable with GraalVM, discussing advantages/disadvantages (e.g., what are the performance improvement running the scenario you created);
+ (optional) Not directly covered in this course: however, if you have previous experience or want to try, you can showcase polyglot microservices (implemented in different programming languages/frameworks);

+ On your GitHub page of the project. give a i) description of the project, ii) a story/scenario of usage, iii) why you think a microservice architecture can be appropriate, iv) benefits of the using microservices in this project, v) drawbacks of microservices in this case.
+ Have a scenario that you can run that showcase some reactive properties of the system (those that you implemented): Responsiveness (quick response / always on), resiliency (self-healing service), elasticity (how the system can scale up/down when needed), message-driveness (asynchronous messages with loosely coupled / location-transparent services);