HighLoad - Highly Loaded Computing Systems
The course is taught to first-year master's students
About the program
The course is aimed at developing and operating highly loaded distributed microservice systems, with an emphasis on scalability, fault tolerance and performance optimization. Key topics and practices related to HighLoad:
Key aspects of the HighLoad course
- Load testing and optimization
- Using K6 to model the load (inserting/reading data in different proportions) and analyze response time.
- Plotting graphs of performance dependence on resources (CPU, RAM) and setting up limits in Docker/Kubernetes.
- Automating filling of test data before load (Python + Faker).
- Scalability and resource management
- Setting up CPU/MEM limits for containers (Docker Compose, Kubernetes).
- Using Horizontal Pod Autoscaler (HPA) in Kubernetes for automatic scaling under load.
- Testing scenarios with different balance of operations (95% read / 5% write, etc.).
- Caching and reducing the load on the database
- Implementation of data caching in microservices (HashMap → Redis in LAB18).
- Optimizing queries to PostgreSQL by caching statistics and frequently used data.
- Fault tolerance and resilience to load spikes
- Resilience4j integration for retry, circuit breaker and error management when services fail.
- readiness/liveness probes setup in Kubernetes for automatic recovery of unhealthy pods.
- Working with distributed systems
- Using Apache Kafka for asynchronous data processing and load decomposition.
- Performance testing with Kafka (consumer parallelism, topic partitioning).
Practical tools and technologies
- K6 — load testing.
- Kubernetes (k3s) — orchestration, autoscaling (HPA), resource management.
- Redis — data caching.
- Resilience4j — protection against failures in microservices.
- Prometheus/Grafana — metrics monitoring (in LAB19).
- Docker Compose — local testing under load.
Course Goal
To prepare students to create systems that can withstand high loads, due to:
- Accurate calculation of resources (CPU/MEM).
- Efficient scaling.
- Optimization of data access (caching, asynchrony).
- Ensuring fault tolerance and automatic recovery.
The course combines theoretical knowledge with practice, including the implementation of real-life HighLoad architecture scenarios.