Initial commit: Complete Software Architecture course with 11 modules

- Added comprehensive course structure with 11 modules
- Included theoretical content, practical examples, and tasks
- Multi-language code examples (Java, Rust, Node.js, Python)
- Detailed analysis of architectural approaches and trade-offs
- Complete caching strategies documentation
- Architecture examples from real-world systems (Twitter, Netflix, Uber)
- Structured navigation and learning path
- Ready for educational use
This commit is contained in:
Alexander Abakumov committed 2025-09-09 22:08:07 +03:00
commit 15e744da49
107 files changed
+61762

No files matched your search

@@ -0,0 +1,844 @@
# Примеры архитектур известных систем
## Навигация
- [🏠 Главная страница курса](../../../README.md)
- [📚 Модуль 1](../README.md)
---
## Twitter
### Обзор системы
Twitter - социальная сеть для микроблогинга, где пользователи публикуют короткие сообщения (твиты) до 280 символов.
### Архитектурный стиль
- **Микросервисная архитектура** с event-driven подходом
- **Гибридная архитектура**: комбинация микросервисов и монолитных компонентов
- **CQRS** (Command Query Responsibility Segregation) для разделения чтения и записи
### Архитектурная диаграмма
```mermaid
graph TB
subgraph "Twitter Architecture"
subgraph "Client Layer"
Web[Web App]
Mobile[Mobile App]
API_Client[API Clients]
end
subgraph "API Gateway"
LB[Load Balancer]
Gateway[API Gateway]
end
subgraph "Core Services"
Timeline[Timeline Service]
Tweet[Tweet Service]
User[User Service]
Search[Search Service]
Media[Media Service]
end
subgraph "Data Layer"
MySQL[(MySQL)]
Redis[(Redis)]
ES[(Elasticsearch)]
S3[(AWS S3)]
end
subgraph "Message Queue"
Kafka[Apache Kafka]
end
end
Web --> LB
Mobile --> LB
API_Client --> LB
LB --> Gateway
Gateway --> Timeline
Gateway --> Tweet
Gateway --> User
Gateway --> Search
Gateway --> Media
Timeline --> Redis
Timeline --> MySQL
Tweet --> MySQL
Tweet --> Kafka
User --> MySQL
Search --> ES
Media --> S3
Kafka --> Timeline
```
### Основные компоненты
#### 1. Timeline Service
- **Назначение**: Генерация персональных лент пользователей
- **Технологии**: Scala, Finagle
- **Особенности**:
- Реалтайм генерация лент
- Кэширование популярного контента
- Асинхронная обработка
#### 2. Tweet Service
- **Назначение**: Создание, хранение и распространение твитов
- **Технологии**: Scala, MySQL, Redis
- **Особенности**:
- Fan-out паттерн для распространения
- Шардирование по user_id
- Event sourcing для аудита
#### 3. User Service
- **Назначение**: Управление пользователями и профилями
- **Технологии**: Scala, MySQL
- **Особенности**:
- Аутентификация и авторизация
- Управление подписками
- Профильная информация
#### 4. Search Service
- **Назначение**: Поиск по твитам и пользователям
- **Технологии**: Elasticsearch, Scala
- **Особенности**:
- Индексирование в реальном времени
- Полнотекстовый поиск
- Геопространственный поиск
#### 5. Media Service
- **Назначение**: Обработка изображений и видео
- **Технологии**: Scala, AWS S3
- **Особенности**:
- Загрузка и оптимизация медиа
- CDN для быстрой доставки
- Метаданные медиафайлов
### Качественные атрибуты
#### Производительность
- **Время отклика**: < 200ms для timeline
- **Пропускная способность**: 6,000 твитов/сек
- **Метрики**:
- 99.9% запросов < 1 секунды
- Кэш hit rate > 95%
#### Масштабируемость
- **Горизонтальное масштабирование**: Все сервисы масштабируются независимо
- **Шардирование**: Данные разделены по user_id
- **Кэширование**: Многоуровневое кэширование (Redis, CDN)
#### Надежность
- **Доступность**: 99.9% uptime
- **Отказоустойчивость**: Graceful degradation при сбоях
- **Резервирование**: Multi-region deployment
#### Безопасность
- **Аутентификация**: OAuth 2.0
- **Шифрование**: TLS для всех соединений
- **Аудит**: Логирование всех действий
### Архитектурные решения
#### 1. Fan-out Pattern
```scala
// Упрощенный пример fan-out для твитов
class TweetFanoutService {
def fanoutTweet(tweet: Tweet, followers: List[UserId]): Unit = {
followers.par.foreach { followerId =>
timelineService.addToTimeline(followerId, tweet)
}
}
}
```
#### 2. Event Sourcing
```scala
// События для аудита твитов
sealed trait TweetEvent
case class TweetCreated(tweetId: String, userId: String, content: String) extends TweetEvent
case class TweetDeleted(tweetId: String, userId: String) extends TweetEvent
case class TweetLiked(tweetId: String, userId: String) extends TweetEvent
```
#### 3. CQRS Implementation
```scala
// Command side - запись
class TweetCommandHandler {
def createTweet(command: CreateTweetCommand): Unit = {
// Валидация и создание твита
val tweet = Tweet(command.content, command.userId)
tweetRepository.save(tweet)
eventBus.publish(TweetCreated(tweet.id, tweet.userId, tweet.content))
}
}
// Query side - чтение
class TimelineQueryService {
def getTimeline(userId: String): List[Tweet] = {
// Чтение из оптимизированного read store
timelineRepository.findByUserId(userId)
}
}
```
---
## Netflix
### Обзор системы
Netflix - стриминговая платформа для видео контента с более чем 200 миллионами подписчиков по всему миру.
### Архитектурный стиль
- **Микросервисная архитектура** с cloud-native подходом
- **Event-driven architecture** с Apache Kafka
- **Serverless** компоненты для обработки медиа
### Архитектурная диаграмма
```mermaid
graph TB
subgraph "Netflix Architecture"
subgraph "Client Layer"
Web[Web Browser]
Mobile[Mobile App]
TV[Smart TV]
Console[Gaming Console]
end
subgraph "CDN Layer"
CloudFront[AWS CloudFront]
OpenConnect[Open Connect]
end
subgraph "API Gateway"
Zuul[Zuul Gateway]
Eureka[Eureka Registry]
end
subgraph "Microservices"
User[User Service]
Content[Content Service]
Recommendation[Recommendation Service]
Playback[Playback Service]
Billing[Billing Service]
end
subgraph "Data Layer"
Cassandra[(Cassandra)]
Elasticsearch[(Elasticsearch)]
Redis[(Redis)]
S3[(AWS S3)]
end
subgraph "ML Pipeline"
Spark[Apache Spark]
TensorFlow[TensorFlow]
Kafka[Apache Kafka]
end
end
Web --> CloudFront
Mobile --> CloudFront
TV --> OpenConnect
Console --> CloudFront
CloudFront --> Zuul
OpenConnect --> Zuul
Zuul --> Eureka
Eureka --> User
Eureka --> Content
Eureka --> Recommendation
Eureka --> Playback
Eureka --> Billing
User --> Cassandra
Content --> Elasticsearch
Recommendation --> Redis
Playback --> Redis
Billing --> Cassandra
Content --> S3
Playback --> S3
Recommendation --> Spark
Spark --> TensorFlow
Kafka --> Recommendation
```
### Основные компоненты
#### 1. API Gateway
- **Назначение**: Единая точка входа для всех клиентов
- **Технологии**: Zuul, Spring Cloud Gateway
- **Особенности**:
- Маршрутизация запросов
- Аутентификация и авторизация
- Rate limiting и throttling
#### 2. User Service
- **Назначение**: Управление пользователями и подписками
- **Технологии**: Java, Spring Boot, Cassandra
- **Особенности**:
- Профили пользователей
- Управление подписками
- Предпочтения контента
#### 3. Content Service
- **Назначение**: Управление каталогом контента
- **Технологии**: Java, Spring Boot, Elasticsearch
- **Особенности**:
- Метаданные фильмов и сериалов
- Поиск и фильтрация
- Многоязычная поддержка
#### 4. Recommendation Service
- **Назначение**: Персональные рекомендации
- **Технологии**: Python, TensorFlow, Apache Spark
- **Особенности**:
- Machine Learning модели
- A/B тестирование
- Real-time рекомендации
#### 5. Playback Service
- **Назначение**: Воспроизведение видео
- **Технологии**: Java, Spring Boot, Redis
- **Особенности**:
- Управление сессиями просмотра
- Адаптивная потоковая передача
- Аналитика просмотров
#### 6. CDN (Content Delivery Network)
- **Назначение**: Доставка видео контента
- **Технологии**: AWS CloudFront, Open Connect
- **Особенности**:
- Глобальная сеть серверов
- Кэширование популярного контента
- Оптимизация для мобильных устройств
### Качественные атрибуты
#### Производительность
- **Время отклика**: < 100ms для API
- **Пропускная способность**: Миллионы запросов в минуту
- **Видео качество**: Адаптивная потоковая передача
#### Масштабируемость
- **Горизонтальное масштабирование**: Все сервисы масштабируются автоматически
- **Multi-region**: Развертывание в нескольких регионах AWS
- **Auto-scaling**: Автоматическое масштабирование на основе нагрузки
#### Надежность
- **Доступность**: 99.99% uptime
- **Fault tolerance**: Circuit breaker pattern
- **Disaster recovery**: Multi-region backup
#### Безопасность
- **DRM**: Защита контента от пиратства
- **Аутентификация**: OAuth 2.0 + JWT
- **Шифрование**: End-to-end шифрование
### Архитектурные решения
#### 1. Circuit Breaker Pattern
```java
@Component
public class RecommendationServiceClient {
@CircuitBreaker(name = "recommendation-service")
@Retry(name = "recommendation-service")
public List<Movie> getRecommendations(String userId) {
return recommendationService.getRecommendations(userId);
}
}
```
#### 2. Event-Driven Architecture
```java
// Событие просмотра фильма
@Component
public class PlaybackEventHandler {
@EventListener
public void handleMovieWatched(MovieWatchedEvent event) {
// Обновление рекомендаций
recommendationService.updateUserPreferences(
event.getUserId(),
event.getMovieId()
);
// Аналитика
analyticsService.recordView(event);
}
}
```
#### 3. Caching Strategy
```java
@Service
public class ContentService {
@Cacheable(value = "popular-movies", key = "#region")
public List<Movie> getPopularMovies(String region) {
return contentRepository.findPopularByRegion(region);
}
@CacheEvict(value = "popular-movies", allEntries = true)
public void updateMoviePopularity(String movieId) {
// Обновление популярности
}
}
```
---
## Uber
### Обзор системы
Uber - платформа для заказа поездок, которая соединяет водителей и пассажиров в реальном времени.
### Архитектурный стиль
- **Микросервисная архитектура** с domain-driven design
- **Event-driven architecture** для real-time обработки
- **CQRS** для разделения команд и запросов
### Архитектурная диаграмма
```mermaid
graph TB
subgraph "Uber Architecture"
subgraph "Client Layer"
Rider[Rider App]
Driver[Driver App]
Web[Web Dashboard]
end
subgraph "API Gateway"
LB[Load Balancer]
Gateway[API Gateway]
end
subgraph "Core Services"
Dispatch[Dispatch Service]
Trip[Trip Service]
Payment[Payment Service]
User[User Service]
Notification[Notification Service]
Map[Map Service]
end
subgraph "Data Layer"
PostgreSQL[(PostgreSQL)]
MongoDB[(MongoDB)]
Redis[(Redis)]
PostGIS[(PostGIS)]
end
subgraph "Message Queue"
Kafka[Apache Kafka]
end
subgraph "External Services"
Maps[Google Maps API]
Payment_Gateway[Payment Gateway]
SMS[SMS Service]
Push[Push Notification]
end
end
Rider --> LB
Driver --> LB
Web --> LB
LB --> Gateway
Gateway --> Dispatch
Gateway --> Trip
Gateway --> Payment
Gateway --> User
Gateway --> Notification
Gateway --> Map
Dispatch --> Redis
Dispatch --> Kafka
Trip --> PostgreSQL
Trip --> Kafka
Payment --> PostgreSQL
User --> MongoDB
Notification --> Kafka
Map --> PostGIS
Map --> Redis
Map --> Maps
Payment --> Payment_Gateway
Notification --> SMS
Notification --> Push
Kafka --> Notification
Kafka --> Trip
```
### Основные компоненты
#### 1. Dispatch Service
- **Назначение**: Сопоставление водителей и пассажиров
- **Технологии**: Go, Redis, Kafka
- **Особенности**:
- Real-time геолокация
- Алгоритмы сопоставления
- Load balancing
#### 2. Trip Service
- **Назначение**: Управление поездками
- **Технологии**: Java, Spring Boot, PostgreSQL
- **Особенности**:
- Жизненный цикл поездки
- Расчет стоимости
- Отслеживание статуса
#### 3. Payment Service
- **Назначение**: Обработка платежей
- **Технологии**: Java, Spring Boot, PostgreSQL
- **Особенности**:
- Интеграция с платежными системами
- Расчет комиссий
- Обработка возвратов
#### 4. User Service
- **Назначение**: Управление пользователями
- **Технологии**: Go, MongoDB
- **Особенности**:
- Профили водителей и пассажиров
- Аутентификация
- Рейтинги и отзывы
#### 5. Notification Service
- **Назначение**: Отправка уведомлений
- **Технологии**: Go, Kafka, Firebase
- **Особенности**:
- Push уведомления
- SMS и email
- Персонализация
#### 6. Map Service
- **Назначение**: Картографические данные
- **Технологии**: Go, Redis, PostGIS
- **Особенности**:
- Геокодирование
- Маршрутизация
- Трафик в реальном времени
### Качественные атрибуты
#### Производительность
- **Время отклика**: < 50ms для dispatch
- **Пропускная способность**: Миллионы запросов в минуту
- **Real-time**: Обновления каждые 3 секунды
#### Масштабируемость
- **Горизонтальное масштабирование**: Все сервисы масштабируются независимо
- **Sharding**: Данные разделены по регионам
- **Caching**: Агрессивное кэширование геоданных
#### Надежность
- **Доступность**: 99.9% uptime
- **Fault tolerance**: Graceful degradation
- **Data consistency**: Eventual consistency
#### Безопасность
- **Аутентификация**: Multi-factor authentication
- **Геолокация**: Защита персональных данных
- **Платежи**: PCI DSS compliance
### Архитектурные решения
#### 1. Event Sourcing для поездок
```java
// События поездки
public class TripEvent {
private String tripId;
private String eventType;
private LocalDateTime timestamp;
private Map<String, Object> data;
}
// Обработчик событий
@Component
public class TripEventHandler {
@EventHandler
public void handleTripStarted(TripStartedEvent event) {
// Уведомление водителя и пассажира
notificationService.notifyTripStarted(event.getTripId());
// Обновление статуса
tripService.updateStatus(event.getTripId(), TripStatus.IN_PROGRESS);
}
}
```
#### 2. CQRS для геоданных
```java
// Command side
@Service
public class LocationCommandService {
public void updateDriverLocation(String driverId, Location location) {
// Обновление в write store
locationRepository.updateDriverLocation(driverId, location);
// Публикация события
eventBus.publish(new LocationUpdatedEvent(driverId, location));
}
}
// Query side
@Service
public class LocationQueryService {
public List<Driver> findNearbyDrivers(Location passengerLocation) {
// Чтение из оптимизированного read store
return locationReadRepository.findNearbyDrivers(passengerLocation);
}
}
```
#### 3. Saga Pattern для поездок
```java
@Component
public class TripSaga {
@SagaOrchestrationStart
public void startTrip(TripRequestedEvent event) {
// 1. Найти водителя
dispatchService.findDriver(event.getPassengerId())
.thenAccept(driver -> {
// 2. Создать поездку
tripService.createTrip(event.getPassengerId(), driver.getId());
});
}
@SagaOrchestrationStep
public void handleDriverAccepted(DriverAcceptedEvent event) {
// 3. Подтвердить поездку
tripService.confirmTrip(event.getTripId());
}
}
```
---
## Сравнительная диаграмма архитектурных паттернов
```mermaid
graph TB
subgraph "Architectural Patterns Comparison"
subgraph "Twitter - Event-Driven + CQRS"
T1[Timeline Service]
T2[Tweet Service]
T3[User Service]
T4[Search Service]
T5[Media Service]
TK[Kafka Events]
TR[Redis Cache]
TM[MySQL]
end
subgraph "Netflix - Cloud-Native + ML"
N1[User Service]
N2[Content Service]
N3[Recommendation Service]
N4[Playback Service]
N5[Billing Service]
NC[CDN]
NK[Kafka]
NCass[Cassandra]
end
subgraph "Uber - DDD + Real-time"
U1[Dispatch Service]
U2[Trip Service]
U3[Payment Service]
U4[User Service]
U5[Notification Service]
U6[Map Service]
UK[Kafka]
UPG[PostgreSQL]
UMG[MongoDB]
end
end
T1 -.-> TK
T2 -.-> TK
T3 -.-> TM
T4 -.-> TM
T5 -.-> TM
N1 -.-> NK
N2 -.-> NCass
N3 -.-> NK
N4 -.-> NCass
N5 -.-> NCass
U1 -.-> UK
U2 -.-> UK
U3 -.-> UPG
U4 -.-> UMG
U5 -.-> UK
U6 -.-> UPG
```
## Сравнительная таблица архитектур
| Система | Архитектурный стиль | Основные технологии | Особенности |
|---------|-------------------|-------------------|-------------|
| **Twitter** | Микросервисы + CQRS | Scala, MySQL, Redis | Fan-out pattern, Event sourcing |
| **Netflix** | Микросервисы + Cloud-native | Java, Spring Boot, AWS | CDN, ML рекомендации |
| **Uber** | Микросервисы + DDD | Go, Java, PostgreSQL | Real-time геолокация, Saga pattern |
---
## Диаграмма ключевых архитектурных паттернов
```mermaid
graph TB
subgraph "Key Architectural Patterns"
subgraph "Microservices Pattern"
MS1[Service A]
MS2[Service B]
MS3[Service C]
MS4[Service D]
MSG[API Gateway]
MSL[Load Balancer]
end
subgraph "Event-Driven Pattern"
ED1[Event Producer]
ED2[Event Bus/Kafka]
ED3[Event Consumer A]
ED4[Event Consumer B]
ED5[Event Consumer C]
end
subgraph "CQRS Pattern"
CQRS_C[Command Side]
CQRS_Q[Query Side]
CQRS_WS[(Write Store)]
CQRS_RS[(Read Store)]
CQRS_E[Event Bus]
end
subgraph "Caching Strategy"
CACHE_L1[L1 Cache<br/>Application]
CACHE_L2[L2 Cache<br/>Redis]
CACHE_L3[L3 Cache<br/>CDN]
CACHE_DB[(Database)]
end
end
MSL --> MSG
MSG --> MS1
MSG --> MS2
MSG --> MS3
MSG --> MS4
ED1 --> ED2
ED2 --> ED3
ED2 --> ED4
ED2 --> ED5
CQRS_C --> CQRS_WS
CQRS_C --> CQRS_E
CQRS_E --> CQRS_Q
CQRS_Q --> CQRS_RS
CACHE_L1 --> CACHE_L2
CACHE_L2 --> CACHE_L3
CACHE_L3 --> CACHE_DB
```
## Ключевые паттерны и решения
### 1. Микросервисная архитектура
- **Преимущества**: Независимое развертывание, масштабируемость
- **Недостатки**: Сложность, network latency
- **Применение**: Все три системы используют микросервисы
### 2. Event-Driven Architecture
- **Преимущества**: Слабая связанность, масштабируемость
- **Недостатки**: Сложность отладки, eventual consistency
- **Применение**: Twitter (твиты), Netflix (просмотры), Uber (события поездок)
### 3. CQRS (Command Query Responsibility Segregation)
- **Преимущества**: Оптимизация для чтения и записи
- **Недостатки**: Сложность, eventual consistency
- **Применение**: Twitter (timeline), Uber (геолокация)
### 4. Caching Strategies
- **Redis**: Для быстрого доступа к данным
- **CDN**: Для статического контента
- **Application Cache**: Для часто используемых данных
### 5. Database Patterns
- **Sharding**: Разделение данных по ключам
- **Read Replicas**: Для масштабирования чтения
- **Event Sourcing**: Для аудита и восстановления
---
## Диаграмма процесса анализа архитектуры
```mermaid
flowchart TD
A[Выбор системы] --> B[Изучение документации]
B --> C[Анализ технических блогов]
C --> D[Изучение open-source компонентов]
D --> E[Определение доменов]
E --> F[Выделение сервисов]
F --> G[Анализ взаимодействий]
G --> H[Оценка производительности]
H --> I[Анализ масштабируемости]
I --> J[Проверка надежности]
J --> K[Оценка безопасности]
K --> L[Изучение паттернов]
L --> M[Анализ технологий]
M --> N[Выявление trade-offs]
N --> O[Создание диаграммы]
O --> P[Документирование решений]
P --> Q[Финальный отчет]
style A fill:#e1f5fe
style Q fill:#c8e6c9
style O fill:#fff3e0
```
## Рекомендации для анализа
### 1. Выберите систему
- Изучите публичную информацию о архитектуре
- Проанализируйте технические блоги компании
- Изучите open-source компоненты
### 2. Определите компоненты
- Выделите основные домены
- Определите границы сервисов
- Проанализируйте взаимодействие
### 3. Оцените качественные атрибуты
- Производительность (метрики, нагрузки)
- Масштабируемость (как система растет)
- Надежность (обработка сбоев)
- Безопасность (защита данных)
### 4. Изучите архитектурные решения
- Паттерны проектирования
- Технологические выборы
- Trade-offs и компромиссы
---