init

2025-12-18 21:13:49 +03:00
parent 84b934036b
commit 030af7ca83
45 changed files with 3106 additions and 0 deletions
--- a/transport/README.md
+++ b/transport/README.md
@@ -0,0 +1,256 @@
+# 🚗 Система мониторинга транспорта
+
+Веб-система для мониторинга местоположения транспортных средств в реальном времени.
+
+## 🛠 Технологии
+
+- **Backend**: FastAPI, SQLAlchemy, PostgreSQL
+- **Frontend**: Vue 3, Leaflet, Naive UI
+- **Инфраструктура**: Docker, Nginx
+
+## 🚀 Быстрый старт
+
+### Требования
+- Docker 20.10+
+- Docker Compose 2.0+
+
+### Запуск (пошагово)
+
+```bash
+# 1. Перейти в папку проекта
+cd transport
+
+# 2. Собрать и запустить все сервисы
+docker-compose up --build -d
+
+# 3. Проверить что все сервисы запущены
+docker-compose ps
+
+# Должно быть 4 сервиса в статусе "Up":
+#   - transport-nginx-1
+#   - transport-backend-1
+#   - transport-frontend-1
+#   - transport-postgres-1
+
+# 4. Проверить что API работает
+curl http://localhost/api/vehicles
+
+# Должен вернуть JSON со списком транспорта
+
+# 5. Открыть приложение в браузере
+open http://localhost
+```
+
+### Запуск симулятора
+
+В **отдельном терминале** запустить симулятор данных:
+
+```bash
+docker-compose exec backend python -m simulator.run
+```
+
+Симулятор будет:
+- Генерировать координаты для 5 транспортных средств
+- Отправлять данные каждые 2 секунды
+- Имитировать движение, остановки, изменение скорости
+
+Для остановки: `Ctrl+C`
+
+### Доступ
+
+| Сервис | URL |
+|--------|-----|
+| Приложение | http://localhost |
+| API | http://localhost/api/ |
+| API Docs (Swagger) | http://localhost/api/docs |
+| WebSocket | ws://localhost/ws/positions |
+
+## 🔧 Полезные команды
+
+```bash
+# Посмотреть логи всех сервисов
+docker-compose logs -f
+
+# Посмотреть логи только backend
+docker-compose logs -f backend
+
+# Перезапустить сервис
+docker-compose restart backend
+
+# Остановить все сервисы
+docker-compose down
+
+# Остановить и удалить данные (включая БД)
+docker-compose down -v
+
+# Пересобрать конкретный сервис
+docker-compose up --build backend -d
+```
+
+## 📡 Работа с API
+
+### Создать транспорт
+```bash
+curl -X POST http://localhost/api/vehicles \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Автобус А-999", "type": "bus"}'
+```
+
+### Отправить позицию
+```bash
+curl -X POST http://localhost/api/ingest/position \
+  -H "Content-Type: application/json" \
+  -d '{
+    "vehicle_id": 1,
+    "lat": 55.0304,
+    "lon": 82.9204,
+    "speed": 45.5,
+    "heading": 180
+  }'
+```
+
+### Получить список транспорта
+```bash
+curl http://localhost/api/vehicles
+```
+
+### Получить историю позиций
+```bash
+curl "http://localhost/api/vehicles/1/positions?from=2025-12-18T00:00:00"
+```
+
+### Получить события
+```bash
+curl http://localhost/api/events
+```
+
+## 📁 Структура проекта
+
+```
+transport/
+├── docker-compose.yml      # Конфигурация Docker
+├── nginx/                  # Nginx конфигурация
+│   ├── nginx.conf
+│   └── conf.d/default.conf
+├── backend/
+│   ├── Dockerfile
+│   ├── requirements.txt
+│   ├── app/               # FastAPI приложение
+│   │   ├── main.py        # Точка входа
+│   │   ├── models/        # SQLAlchemy модели
+│   │   ├── schemas/       # Pydantic схемы
+│   │   ├── routers/       # API эндпоинты
+│   │   └── services/      # Бизнес-логика
+│   ├── alembic/           # Миграции БД
+│   └── simulator/         # Симулятор данных
+│       └── run.py
+└── frontend/
+    ├── Dockerfile
+    ├── package.json
+    └── src/
+        ├── main.js
+        ├── App.vue        # Главный компонент
+        └── components/    # Vue компоненты
+            ├── MapView.vue
+            ├── VehicleList.vue
+            ├── VehicleCard.vue
+            ├── TrackHistory.vue
+            └── EventFeed.vue
+```
+
+## 🔌 REST API
+
+| Метод | URL | Описание |
+|-------|-----|----------|
+| GET | /api/vehicles | Список транспорта с последними позициями |
+| GET | /api/vehicles/{id} | Информация о конкретном ТС |
+| POST | /api/vehicles | Создать новое ТС |
+| PUT | /api/vehicles/{id} | Обновить ТС |
+| DELETE | /api/vehicles/{id} | Удалить ТС |
+| GET | /api/vehicles/{id}/positions | История позиций ТС |
+| POST | /api/ingest/position | Принять новую позицию |
+| GET | /api/events | Список событий |
+
+### Типы транспорта
+
+| type | Иконка |
+|------|--------|
+| `bus` | 🚌 |
+| `truck` | 🚚 |
+| `car` | 🚗 |
+
+## 📨 WebSocket API
+
+Подключение: `ws://localhost/ws/positions`
+
+### Формат сообщений
+
+**Обновление позиции:**
+```json
+{
+  "type": "position_update",
+  "data": {
+    "vehicle_id": 1,
+    "lat": 55.0304,
+    "lon": 82.9204,
+    "speed": 45.5,
+    "heading": 180,
+    "timestamp": "2025-12-18T12:00:00Z"
+  }
+}
+```
+
+**Событие:**
+```json
+{
+  "type": "event",
+  "data": {
+    "id": 1,
+    "vehicle_id": 1,
+    "type": "OVERSPEED",
+    "payload": {"speed": 95, "limit": 60},
+    "timestamp": "2025-12-18T12:00:00Z"
+  }
+}
+```
+
+### Типы событий
+
+| Тип | Описание |
+|-----|----------|
+| `OVERSPEED` | Превышение скорости (> 60 км/ч) |
+| `LONG_STOP` | Остановка более 5 минут |
+| `CONNECTION_LOST` | Нет данных более 5 минут |
+
+## 🐛 Troubleshooting
+
+### API возвращает 404
+```bash
+# Проверить что backend запущен
+docker-compose ps
+
+# Перезапустить nginx
+docker-compose restart nginx
+```
+
+### Нет данных на карте
+```bash
+# Проверить что симулятор запущен
+docker-compose exec backend python -m simulator.run
+
+# Проверить логи backend
+docker-compose logs -f backend
+```
+
+### Ошибка подключения к БД
+```bash
+# Проверить что postgres запущен
+docker-compose ps postgres
+
+# Посмотреть логи postgres
+docker-compose logs postgres
+```
+
+## 📝 Лицензия
+
+MIT
--- a/transport/backend/Dockerfile
+++ b/transport/backend/Dockerfile
@@ -0,0 +1,18 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Run migrations and start server
+CMD ["sh", "-c", "alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload"]
--- a/transport/backend/alembic.ini
+++ b/transport/backend/alembic.ini
@@ -0,0 +1,42 @@
+[alembic]
+script_location = alembic
+prepend_sys_path = .
+version_path_separator = os
+
+sqlalchemy.url = postgresql://postgres:postgres@postgres:5432/transport
+
+[post_write_hooks]
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
--- a/transport/backend/alembic/env.py
+++ b/transport/backend/alembic/env.py
@@ -0,0 +1,61 @@
+import os
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# Import models to ensure they are registered with Base
+from app.database import Base
+from app.models import Vehicle, Position, Event
+
+config = context.config
+
+# Override sqlalchemy.url from environment if available
+database_url = os.getenv("DATABASE_URL")
+if database_url:
+    config.set_main_option("sqlalchemy.url", database_url)
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = Base.metadata
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode."""
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
--- a/transport/backend/alembic/script.py.mako
+++ b/transport/backend/alembic/script.py.mako
@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}
--- a/transport/backend/alembic/versions/001_initial.py
+++ b/transport/backend/alembic/versions/001_initial.py
@@ -0,0 +1,75 @@
+"""Initial migration
+
+Revision ID: 001
+Revises:
+Create Date: 2025-12-18
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '001'
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Create vehicles table
+    op.create_table(
+        'vehicles',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('name', sa.String(100), nullable=False),
+        sa.Column('type', sa.String(50), nullable=True, default='car'),
+        sa.Column('created_at', sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint('id')
+    )
+
+    # Create positions table
+    op.create_table(
+        'positions',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('vehicle_id', sa.Integer(), nullable=False),
+        sa.Column('timestamp', sa.DateTime(), nullable=False),
+        sa.Column('lat', sa.Float(), nullable=False),
+        sa.Column('lon', sa.Float(), nullable=False),
+        sa.Column('speed', sa.Float(), nullable=True, default=0.0),
+        sa.Column('heading', sa.Float(), nullable=True, default=0.0),
+        sa.ForeignKeyConstraint(['vehicle_id'], ['vehicles.id'], ondelete='CASCADE'),
+        sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index('idx_positions_vehicle_ts', 'positions', ['vehicle_id', 'timestamp'])
+
+    # Create events table
+    op.create_table(
+        'events',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('vehicle_id', sa.Integer(), nullable=False),
+        sa.Column('timestamp', sa.DateTime(), nullable=False),
+        sa.Column('type', sa.String(50), nullable=False),
+        sa.Column('payload', postgresql.JSONB(), nullable=True, default={}),
+        sa.ForeignKeyConstraint(['vehicle_id'], ['vehicles.id'], ondelete='CASCADE'),
+        sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index('idx_events_vehicle_ts', 'events', ['vehicle_id', 'timestamp'])
+    op.create_index('idx_events_type', 'events', ['type'])
+
+    # Insert demo vehicles
+    op.execute("""
+        INSERT INTO vehicles (name, type, created_at) VALUES
+        ('Автобус А-101', 'bus', NOW()),
+        ('Автобус А-102', 'bus', NOW()),
+        ('Грузовик Г-201', 'truck', NOW()),
+        ('Легковой Л-301', 'car', NOW()),
+        ('Легковой Л-302', 'car', NOW())
+    """)
+
+
+def downgrade() -> None:
+    op.drop_table('events')
+    op.drop_table('positions')
+    op.drop_table('vehicles')
--- a/transport/backend/app/init.py
+++ b/transport/backend/app/init.py
--- a/transport/backend/app/config.py
+++ b/transport/backend/app/config.py
@@ -0,0 +1,16 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    database_url: str = "postgresql://postgres:postgres@localhost:5432/transport"
+
+    # Event detection settings
+    long_stop_minutes: int = 5
+    overspeed_limit: float = 60.0  # km/h
+    connection_lost_minutes: int = 5
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()
--- a/transport/backend/app/database.py
+++ b/transport/backend/app/database.py
@@ -0,0 +1,23 @@
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
+from sqlalchemy.orm import DeclarativeBase
+
+from app.config import settings
+
+# Convert postgresql:// to postgresql+asyncpg://
+database_url = settings.database_url.replace("postgresql://", "postgresql+asyncpg://")
+
+engine = create_async_engine(database_url, echo=False)
+
+async_session_maker = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+async def get_db() -> AsyncSession:
+    async with async_session_maker() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
--- a/transport/backend/app/main.py
+++ b/transport/backend/app/main.py
@@ -0,0 +1,50 @@
+import asyncio
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.routers import vehicles, positions, events
+from app.websocket import router as ws_router
+from app.services.connection_checker import connection_checker_loop
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup: запуск фоновых задач
+    task = asyncio.create_task(connection_checker_loop())
+    yield
+    # Shutdown: остановка фоновых задач
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+
+
+app = FastAPI(
+    title="Transport Monitoring API",
+    description="API для системы мониторинга транспорта",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(vehicles.router, prefix="/vehicles", tags=["vehicles"])
+app.include_router(positions.router, tags=["positions"])
+app.include_router(events.router, prefix="/events", tags=["events"])
+app.include_router(ws_router)
+
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}
--- a/transport/backend/app/models/init.py
+++ b/transport/backend/app/models/init.py
@@ -0,0 +1,5 @@
+from app.models.vehicle import Vehicle
+from app.models.position import Position
+from app.models.event import Event
+
+__all__ = ["Vehicle", "Position", "Event"]
--- a/transport/backend/app/models/event.py
+++ b/transport/backend/app/models/event.py
@@ -0,0 +1,24 @@
+from datetime import datetime
+from sqlalchemy import DateTime, String, ForeignKey, Index
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.database import Base
+
+
+class Event(Base):
+    __tablename__ = "events"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    vehicle_id: Mapped[int] = mapped_column(ForeignKey("vehicles.id", ondelete="CASCADE"))
+    timestamp: Mapped[datetime] = mapped_column(DateTime, nullable=False, default=datetime.utcnow)
+    type: Mapped[str] = mapped_column(String(50), nullable=False)  # LONG_STOP, OVERSPEED, CONNECTION_LOST
+    payload: Mapped[dict] = mapped_column(JSONB, default=dict)
+
+    # Relationships
+    vehicle: Mapped["Vehicle"] = relationship(back_populates="events")
+
+    __table_args__ = (
+        Index("idx_events_vehicle_ts", "vehicle_id", "timestamp"),
+        Index("idx_events_type", "type"),
+    )
--- a/transport/backend/app/models/position.py
+++ b/transport/backend/app/models/position.py
@@ -0,0 +1,24 @@
+from datetime import datetime
+from sqlalchemy import DateTime, Float, ForeignKey, Index
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.database import Base
+
+
+class Position(Base):
+    __tablename__ = "positions"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    vehicle_id: Mapped[int] = mapped_column(ForeignKey("vehicles.id", ondelete="CASCADE"))
+    timestamp: Mapped[datetime] = mapped_column(DateTime, nullable=False, default=datetime.utcnow)
+    lat: Mapped[float] = mapped_column(Float, nullable=False)
+    lon: Mapped[float] = mapped_column(Float, nullable=False)
+    speed: Mapped[float] = mapped_column(Float, default=0.0)  # km/h
+    heading: Mapped[float] = mapped_column(Float, default=0.0)  # 0-360 degrees
+
+    # Relationships
+    vehicle: Mapped["Vehicle"] = relationship(back_populates="positions")
+
+    __table_args__ = (
+        Index("idx_positions_vehicle_ts", "vehicle_id", "timestamp"),
+    )
--- a/transport/backend/app/models/vehicle.py
+++ b/transport/backend/app/models/vehicle.py
@@ -0,0 +1,18 @@
+from datetime import datetime
+from sqlalchemy import String, DateTime
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.database import Base
+
+
+class Vehicle(Base):
+    __tablename__ = "vehicles"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(100), nullable=False)
+    type: Mapped[str] = mapped_column(String(50), default="car")  # car, bus, truck
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+
+    # Relationships
+    positions: Mapped[list["Position"]] = relationship(back_populates="vehicle", cascade="all, delete-orphan")
+    events: Mapped[list["Event"]] = relationship(back_populates="vehicle", cascade="all, delete-orphan")
--- a/transport/backend/app/routers/init.py
+++ b/transport/backend/app/routers/init.py
--- a/transport/backend/app/routers/events.py
+++ b/transport/backend/app/routers/events.py
@@ -0,0 +1,61 @@
+from datetime import datetime
+from typing import Optional
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy import select, desc
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models import Event
+from app.schemas import EventResponse
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[EventResponse])
+async def get_events(
+    type: Optional[str] = None,
+    vehicle_id: Optional[int] = None,
+    from_time: Optional[datetime] = Query(None, alias="from"),
+    to_time: Optional[datetime] = Query(None, alias="to"),
+    limit: int = Query(100, le=1000),
+    db: AsyncSession = Depends(get_db)
+):
+    """Получить список событий"""
+    query = select(Event)
+
+    if type:
+        query = query.where(Event.type == type)
+    if vehicle_id:
+        query = query.where(Event.vehicle_id == vehicle_id)
+    if from_time:
+        query = query.where(Event.timestamp >= from_time)
+    if to_time:
+        query = query.where(Event.timestamp <= to_time)
+
+    query = query.order_by(desc(Event.timestamp)).limit(limit)
+
+    result = await db.execute(query)
+    events = result.scalars().all()
+
+    return events
+
+
+@router.get("/vehicles/{vehicle_id}/events", response_model=list[EventResponse])
+async def get_vehicle_events(
+    vehicle_id: int,
+    type: Optional[str] = None,
+    limit: int = Query(100, le=1000),
+    db: AsyncSession = Depends(get_db)
+):
+    """Получить события конкретного транспортного средства"""
+    query = select(Event).where(Event.vehicle_id == vehicle_id)
+
+    if type:
+        query = query.where(Event.type == type)
+
+    query = query.order_by(desc(Event.timestamp)).limit(limit)
+
+    result = await db.execute(query)
+    events = result.scalars().all()
+
+    return events
--- a/transport/backend/app/routers/positions.py
+++ b/transport/backend/app/routers/positions.py
@@ -0,0 +1,103 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy import select, desc, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models import Vehicle, Position
+from app.schemas import PositionResponse, PositionIngest
+from app.services.websocket_manager import manager
+from app.services.event_detector import detect_events
+
+router = APIRouter()
+
+
+@router.get("/vehicles/{vehicle_id}/positions", response_model=list[PositionResponse])
+async def get_vehicle_positions(
+    vehicle_id: int,
+    from_time: Optional[datetime] = Query(None, alias="from"),
+    to_time: Optional[datetime] = Query(None, alias="to"),
+    limit: int = Query(1000, le=10000),
+    db: AsyncSession = Depends(get_db)
+):
+    """Получить историю позиций транспортного средства"""
+    # Check vehicle exists
+    result = await db.execute(select(Vehicle).where(Vehicle.id == vehicle_id))
+    if not result.scalar_one_or_none():
+        raise HTTPException(status_code=404, detail="Vehicle not found")
+
+    # Build query
+    query = select(Position).where(Position.vehicle_id == vehicle_id)
+
+    if from_time:
+        query = query.where(Position.timestamp >= from_time)
+    if to_time:
+        query = query.where(Position.timestamp <= to_time)
+
+    query = query.order_by(desc(Position.timestamp)).limit(limit)
+
+    result = await db.execute(query)
+    positions = result.scalars().all()
+
+    return positions
+
+
+@router.get("/vehicles/{vehicle_id}/last-position", response_model=Optional[PositionResponse])
+async def get_last_position(vehicle_id: int, db: AsyncSession = Depends(get_db)):
+    """Получить последнюю позицию транспортного средства"""
+    result = await db.execute(
+        select(Position)
+        .where(Position.vehicle_id == vehicle_id)
+        .order_by(desc(Position.timestamp))
+        .limit(1)
+    )
+    position = result.scalar_one_or_none()
+
+    if not position:
+        return None
+
+    return position
+
+
+@router.post("/ingest/position", response_model=PositionResponse, status_code=201)
+async def ingest_position(position: PositionIngest, db: AsyncSession = Depends(get_db)):
+    """Принять новую позицию от трекера/симулятора"""
+    # Check vehicle exists
+    result = await db.execute(select(Vehicle).where(Vehicle.id == position.vehicle_id))
+    vehicle = result.scalar_one_or_none()
+
+    if not vehicle:
+        raise HTTPException(status_code=404, detail="Vehicle not found")
+
+    # Get previous position for event detection
+    prev_result = await db.execute(
+        select(Position)
+        .where(Position.vehicle_id == position.vehicle_id)
+        .order_by(desc(Position.timestamp))
+        .limit(1)
+    )
+    prev_position = prev_result.scalar_one_or_none()
+
+    # Create new position
+    db_position = Position(
+        vehicle_id=position.vehicle_id,
+        timestamp=position.timestamp or datetime.utcnow(),
+        lat=position.lat,
+        lon=position.lon,
+        speed=position.speed,
+        heading=position.heading
+    )
+    db.add(db_position)
+    await db.commit()
+    await db.refresh(db_position)
+
+    # Detect events
+    events = await detect_events(db, vehicle, db_position, prev_position)
+
+    # Broadcast to WebSocket clients
+    await manager.broadcast_position(db_position)
+    for event in events:
+        await manager.broadcast_event(event)
+
+    return db_position
--- a/transport/backend/app/routers/vehicles.py
+++ b/transport/backend/app/routers/vehicles.py
@@ -0,0 +1,139 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import select, desc
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models import Vehicle, Position
+from app.schemas import VehicleCreate, VehicleUpdate, VehicleResponse, VehicleWithPosition
+from app.schemas.vehicle import LastPosition
+
+router = APIRouter()
+
+
+def get_vehicle_status(last_position: Optional[Position], now: datetime) -> str:
+    if not last_position:
+        return "offline"
+
+    time_diff = now - last_position.timestamp
+    if time_diff > timedelta(minutes=5):
+        return "offline"
+    elif last_position.speed < 2:
+        return "stopped"
+    else:
+        return "moving"
+
+
+@router.get("", response_model=list[VehicleWithPosition])
+async def get_vehicles(db: AsyncSession = Depends(get_db)):
+    """Получить список всех транспортных средств с последними позициями"""
+    result = await db.execute(select(Vehicle))
+    vehicles = result.scalars().all()
+
+    response = []
+    now = datetime.utcnow()
+
+    for vehicle in vehicles:
+        # Get last position
+        pos_result = await db.execute(
+            select(Position)
+            .where(Position.vehicle_id == vehicle.id)
+            .order_by(desc(Position.timestamp))
+            .limit(1)
+        )
+        last_pos = pos_result.scalar_one_or_none()
+
+        vehicle_data = VehicleWithPosition(
+            id=vehicle.id,
+            name=vehicle.name,
+            type=vehicle.type,
+            created_at=vehicle.created_at,
+            last_position=LastPosition(
+                lat=last_pos.lat,
+                lon=last_pos.lon,
+                speed=last_pos.speed,
+                heading=last_pos.heading,
+                timestamp=last_pos.timestamp
+            ) if last_pos else None,
+            status=get_vehicle_status(last_pos, now)
+        )
+        response.append(vehicle_data)
+
+    return response
+
+
+@router.get("/{vehicle_id}", response_model=VehicleWithPosition)
+async def get_vehicle(vehicle_id: int, db: AsyncSession = Depends(get_db)):
+    """Получить информацию о транспортном средстве"""
+    result = await db.execute(select(Vehicle).where(Vehicle.id == vehicle_id))
+    vehicle = result.scalar_one_or_none()
+
+    if not vehicle:
+        raise HTTPException(status_code=404, detail="Vehicle not found")
+
+    # Get last position
+    pos_result = await db.execute(
+        select(Position)
+        .where(Position.vehicle_id == vehicle.id)
+        .order_by(desc(Position.timestamp))
+        .limit(1)
+    )
+    last_pos = pos_result.scalar_one_or_none()
+    now = datetime.utcnow()
+
+    return VehicleWithPosition(
+        id=vehicle.id,
+        name=vehicle.name,
+        type=vehicle.type,
+        created_at=vehicle.created_at,
+        last_position=LastPosition(
+            lat=last_pos.lat,
+            lon=last_pos.lon,
+            speed=last_pos.speed,
+            heading=last_pos.heading,
+            timestamp=last_pos.timestamp
+        ) if last_pos else None,
+        status=get_vehicle_status(last_pos, now)
+    )
+
+
+@router.post("", response_model=VehicleResponse, status_code=201)
+async def create_vehicle(vehicle: VehicleCreate, db: AsyncSession = Depends(get_db)):
+    """Создать новое транспортное средство"""
+    db_vehicle = Vehicle(**vehicle.model_dump())
+    db.add(db_vehicle)
+    await db.commit()
+    await db.refresh(db_vehicle)
+    return db_vehicle
+
+
+@router.put("/{vehicle_id}", response_model=VehicleResponse)
+async def update_vehicle(vehicle_id: int, vehicle: VehicleUpdate, db: AsyncSession = Depends(get_db)):
+    """Обновить транспортное средство"""
+    result = await db.execute(select(Vehicle).where(Vehicle.id == vehicle_id))
+    db_vehicle = result.scalar_one_or_none()
+
+    if not db_vehicle:
+        raise HTTPException(status_code=404, detail="Vehicle not found")
+
+    update_data = vehicle.model_dump(exclude_unset=True)
+    for field, value in update_data.items():
+        setattr(db_vehicle, field, value)
+
+    await db.commit()
+    await db.refresh(db_vehicle)
+    return db_vehicle
+
+
+@router.delete("/{vehicle_id}", status_code=204)
+async def delete_vehicle(vehicle_id: int, db: AsyncSession = Depends(get_db)):
+    """Удалить транспортное средство"""
+    result = await db.execute(select(Vehicle).where(Vehicle.id == vehicle_id))
+    db_vehicle = result.scalar_one_or_none()
+
+    if not db_vehicle:
+        raise HTTPException(status_code=404, detail="Vehicle not found")
+
+    await db.delete(db_vehicle)
+    await db.commit()
--- a/transport/backend/app/schemas/init.py
+++ b/transport/backend/app/schemas/init.py
@@ -0,0 +1,9 @@
+from app.schemas.vehicle import VehicleCreate, VehicleUpdate, VehicleResponse, VehicleWithPosition
+from app.schemas.position import PositionCreate, PositionResponse, PositionIngest
+from app.schemas.event import EventResponse
+
+__all__ = [
+    "VehicleCreate", "VehicleUpdate", "VehicleResponse", "VehicleWithPosition",
+    "PositionCreate", "PositionResponse", "PositionIngest",
+    "EventResponse"
+]
--- a/transport/backend/app/schemas/event.py
+++ b/transport/backend/app/schemas/event.py
@@ -0,0 +1,14 @@
+from datetime import datetime
+from typing import Any
+from pydantic import BaseModel
+
+
+class EventResponse(BaseModel):
+    id: int
+    vehicle_id: int
+    timestamp: datetime
+    type: str
+    payload: dict[str, Any]
+
+    class Config:
+        from_attributes = True
--- a/transport/backend/app/schemas/position.py
+++ b/transport/backend/app/schemas/position.py
@@ -0,0 +1,29 @@
+from datetime import datetime
+from typing import Optional
+from pydantic import BaseModel
+
+
+class PositionBase(BaseModel):
+    lat: float
+    lon: float
+    speed: float = 0.0
+    heading: float = 0.0
+
+
+class PositionCreate(PositionBase):
+    vehicle_id: int
+    timestamp: Optional[datetime] = None
+
+
+class PositionIngest(PositionBase):
+    vehicle_id: int
+    timestamp: Optional[datetime] = None
+
+
+class PositionResponse(PositionBase):
+    id: int
+    vehicle_id: int
+    timestamp: datetime
+
+    class Config:
+        from_attributes = True
--- a/transport/backend/app/schemas/vehicle.py
+++ b/transport/backend/app/schemas/vehicle.py
@@ -0,0 +1,38 @@
+from datetime import datetime
+from typing import Optional
+from pydantic import BaseModel
+
+
+class VehicleBase(BaseModel):
+    name: str
+    type: str = "car"
+
+
+class VehicleCreate(VehicleBase):
+    pass
+
+
+class VehicleUpdate(BaseModel):
+    name: Optional[str] = None
+    type: Optional[str] = None
+
+
+class VehicleResponse(VehicleBase):
+    id: int
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class LastPosition(BaseModel):
+    lat: float
+    lon: float
+    speed: float
+    heading: float
+    timestamp: datetime
+
+
+class VehicleWithPosition(VehicleResponse):
+    last_position: Optional[LastPosition] = None
+    status: str = "unknown"  # moving, stopped, offline
--- a/transport/backend/app/services/init.py
+++ b/transport/backend/app/services/init.py
--- a/transport/backend/app/services/connection_checker.py
+++ b/transport/backend/app/services/connection_checker.py
@@ -0,0 +1,83 @@
+"""
+Фоновая задача для проверки потери связи с объектами.
+Создаёт события CONNECTION_LOST если нет данных более N минут.
+"""
+
+import asyncio
+from datetime import datetime, timedelta
+from sqlalchemy import select, desc
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import async_session_maker
+from app.models import Vehicle, Position, Event
+from app.config import settings
+from app.services.websocket_manager import manager
+
+
+async def check_connections():
+    """Проверить все объекты на потерю связи"""
+    async with async_session_maker() as db:
+        # Получить все объекты
+        result = await db.execute(select(Vehicle))
+        vehicles = result.scalars().all()
+
+        now = datetime.utcnow()
+        threshold = now - timedelta(minutes=settings.connection_lost_minutes)
+
+        for vehicle in vehicles:
+            # Получить последнюю позицию
+            pos_result = await db.execute(
+                select(Position)
+                .where(Position.vehicle_id == vehicle.id)
+                .order_by(desc(Position.timestamp))
+                .limit(1)
+            )
+            last_pos = pos_result.scalar_one_or_none()
+
+            if not last_pos:
+                continue
+
+            # Проверить, прошло ли достаточно времени
+            if last_pos.timestamp < threshold:
+                # Проверить, не было ли уже события CONNECTION_LOST за последние N минут
+                event_result = await db.execute(
+                    select(Event)
+                    .where(Event.vehicle_id == vehicle.id)
+                    .where(Event.type == "CONNECTION_LOST")
+                    .where(Event.timestamp > threshold)
+                    .limit(1)
+                )
+                existing_event = event_result.scalar_one_or_none()
+
+                if not existing_event:
+                    # Создать событие
+                    minutes_ago = (now - last_pos.timestamp).total_seconds() / 60
+                    event = Event(
+                        vehicle_id=vehicle.id,
+                        timestamp=now,
+                        type="CONNECTION_LOST",
+                        payload={
+                            "last_seen": last_pos.timestamp.isoformat(),
+                            "minutes_ago": round(minutes_ago, 1),
+                            "lat": last_pos.lat,
+                            "lon": last_pos.lon
+                        }
+                    )
+                    db.add(event)
+                    await db.commit()
+                    await db.refresh(event)
+
+                    # Отправить через WebSocket
+                    await manager.broadcast_event(event)
+                    print(f"⚠️ CONNECTION_LOST: {vehicle.name} (нет данных {minutes_ago:.0f} мин)")
+
+
+async def connection_checker_loop():
+    """Бесконечный цикл проверки соединений"""
+    print("🔍 Connection checker started")
+    while True:
+        try:
+            await check_connections()
+        except Exception as e:
+            print(f"Connection checker error: {e}")
+        await asyncio.sleep(60)  # Проверять каждую минуту
--- a/transport/backend/app/services/event_detector.py
+++ b/transport/backend/app/services/event_detector.py
@@ -0,0 +1,55 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models import Vehicle, Position, Event
+from app.config import settings
+
+
+async def detect_events(
+    db: AsyncSession,
+    vehicle: Vehicle,
+    current: Position,
+    previous: Optional[Position]
+) -> list[Event]:
+    """Обнаружение событий на основе новой позиции"""
+    events = []
+
+    # Check for overspeed
+    if current.speed > settings.overspeed_limit:
+        event = Event(
+            vehicle_id=vehicle.id,
+            timestamp=current.timestamp,
+            type="OVERSPEED",
+            payload={
+                "speed": current.speed,
+                "limit": settings.overspeed_limit,
+                "lat": current.lat,
+                "lon": current.lon
+            }
+        )
+        db.add(event)
+        await db.commit()
+        await db.refresh(event)
+        events.append(event)
+
+    # Check for long stop (if speed is 0 and was 0 for a while)
+    if previous and current.speed < 2 and previous.speed < 2:
+        time_diff = current.timestamp - previous.timestamp
+        if time_diff >= timedelta(minutes=settings.long_stop_minutes):
+            event = Event(
+                vehicle_id=vehicle.id,
+                timestamp=current.timestamp,
+                type="LONG_STOP",
+                payload={
+                    "duration_minutes": time_diff.total_seconds() / 60,
+                    "lat": current.lat,
+                    "lon": current.lon
+                }
+            )
+            db.add(event)
+            await db.commit()
+            await db.refresh(event)
+            events.append(event)
+
+    return events
--- a/transport/backend/app/services/websocket_manager.py
+++ b/transport/backend/app/services/websocket_manager.py
@@ -0,0 +1,63 @@
+import json
+from datetime import datetime
+from typing import Set
+from fastapi import WebSocket
+
+from app.models import Position, Event
+
+
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: Set[WebSocket] = set()
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections.add(websocket)
+
+    def disconnect(self, websocket: WebSocket):
+        self.active_connections.discard(websocket)
+
+    async def broadcast(self, message: dict):
+        """Отправить сообщение всем подключенным клиентам"""
+        disconnected = set()
+        for connection in self.active_connections:
+            try:
+                await connection.send_json(message)
+            except Exception:
+                disconnected.add(connection)
+
+        # Remove disconnected clients
+        self.active_connections -= disconnected
+
+    async def broadcast_position(self, position: Position):
+        """Отправить обновление позиции"""
+        message = {
+            "type": "position_update",
+            "data": {
+                "vehicle_id": position.vehicle_id,
+                "lat": position.lat,
+                "lon": position.lon,
+                "speed": position.speed,
+                "heading": position.heading,
+                "timestamp": position.timestamp.isoformat()
+            }
+        }
+        await self.broadcast(message)
+
+    async def broadcast_event(self, event: Event):
+        """Отправить событие"""
+        message = {
+            "type": "event",
+            "data": {
+                "id": event.id,
+                "vehicle_id": event.vehicle_id,
+                "type": event.type,
+                "payload": event.payload,
+                "timestamp": event.timestamp.isoformat()
+            }
+        }
+        await self.broadcast(message)
+
+
+# Global instance
+manager = ConnectionManager()
--- a/transport/backend/app/websocket.py
+++ b/transport/backend/app/websocket.py
@@ -0,0 +1,18 @@
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+from app.services.websocket_manager import manager
+
+router = APIRouter()
+
+
+@router.websocket("/ws/positions")
+async def websocket_endpoint(websocket: WebSocket):
+    """WebSocket эндпоинт для получения обновлений позиций в реальном времени"""
+    await manager.connect(websocket)
+    try:
+        while True:
+            # Keep connection alive, wait for messages (ping/pong)
+            data = await websocket.receive_text()
+            # Can handle client messages here if needed
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
--- a/transport/backend/requirements.txt
+++ b/transport/backend/requirements.txt
@@ -0,0 +1,11 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+sqlalchemy==2.0.23
+alembic==1.12.1
+asyncpg==0.29.0
+psycopg2-binary==2.9.9
+pydantic==2.5.2
+pydantic-settings==2.1.0
+python-multipart==0.0.6
+websockets==12.0
+httpx==0.25.2
--- a/transport/backend/simulator/init.py
+++ b/transport/backend/simulator/init.py
--- a/transport/backend/simulator/run.py
+++ b/transport/backend/simulator/run.py
@@ -0,0 +1,121 @@
+"""
+Симулятор движения транспортных средств.
+Генерирует реалистичные данные о перемещении объектов.
+"""
+
+import asyncio
+import random
+import math
+import httpx
+from datetime import datetime
+
+# Backend API URL (внутри Docker сети, без /api — root_path только для nginx)
+API_URL = "http://backend:8000"
+
+# Начальные координаты (Новосибирск - центр)
+START_COORDS = [
+    (55.0304, 82.9204),  # Центр
+    (55.0411, 82.9344),  # Север
+    (55.0198, 82.9064),  # Юг
+    (55.0350, 82.8904),  # Запад
+    (55.0250, 82.9504),  # Восток
+]
+
+
+class VehicleSimulator:
+    def __init__(self, vehicle_id: int, start_lat: float, start_lon: float):
+        self.vehicle_id = vehicle_id
+        self.lat = start_lat
+        self.lon = start_lon
+        self.speed = random.uniform(20, 60)  # km/h
+        self.heading = random.uniform(0, 360)  # degrees
+        self.is_stopped = False
+        self.stop_duration = 0
+
+    def update(self):
+        """Обновить позицию транспортного средства"""
+        # Случайная остановка
+        if not self.is_stopped and random.random() < 0.02:  # 2% шанс остановиться
+            self.is_stopped = True
+            self.stop_duration = random.randint(5, 30)  # секунд
+            self.speed = 0
+
+        if self.is_stopped:
+            self.stop_duration -= 1
+            if self.stop_duration <= 0:
+                self.is_stopped = False
+                self.speed = random.uniform(20, 60)
+
+        if not self.is_stopped:
+            # Случайное изменение направления
+            self.heading += random.uniform(-15, 15)
+            self.heading = self.heading % 360
+
+            # Случайное изменение скорости
+            self.speed += random.uniform(-5, 5)
+            self.speed = max(10, min(90, self.speed))  # Ограничение 10-90 км/ч
+
+            # Расчёт нового положения
+            # Примерно: 1 градус широты = 111 км, 1 градус долготы = 111 * cos(lat) км
+            speed_ms = self.speed / 3.6  # м/с
+            distance = speed_ms * 2  # за 2 секунды
+
+            # Перевод в градусы
+            delta_lat = (distance * math.cos(math.radians(self.heading))) / 111000
+            delta_lon = (distance * math.sin(math.radians(self.heading))) / (111000 * math.cos(math.radians(self.lat)))
+
+            self.lat += delta_lat
+            self.lon += delta_lon
+
+        return {
+            "vehicle_id": self.vehicle_id,
+            "lat": round(self.lat, 6),
+            "lon": round(self.lon, 6),
+            "speed": round(self.speed, 1),
+            "heading": round(self.heading, 1),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+
+
+async def send_position(client: httpx.AsyncClient, position: dict):
+    """Отправить позицию на сервер"""
+    try:
+        response = await client.post(f"{API_URL}/ingest/position", json=position)
+        if response.status_code == 201:
+            print(f"✓ Vehicle {position['vehicle_id']}: ({position['lat']}, {position['lon']}) @ {position['speed']} km/h")
+        else:
+            print(f"✗ Vehicle {position['vehicle_id']}: Error {response.status_code}")
+    except Exception as e:
+        print(f"✗ Vehicle {position['vehicle_id']}: {e}")
+
+
+async def main():
+    print("🚗 Запуск симулятора транспорта...")
+    print(f"📡 API URL: {API_URL}")
+
+    # Создаём симуляторы для каждого транспортного средства
+    simulators = []
+    for i, (lat, lon) in enumerate(START_COORDS, start=1):
+        sim = VehicleSimulator(vehicle_id=i, start_lat=lat, start_lon=lon)
+        simulators.append(sim)
+        print(f"  → Vehicle {i}: начальная позиция ({lat}, {lon})")
+
+    print("\n🔄 Начинаем отправку данных (Ctrl+C для остановки)...\n")
+
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        while True:
+            # Обновляем и отправляем позиции всех транспортных средств
+            tasks = []
+            for sim in simulators:
+                position = sim.update()
+                tasks.append(send_position(client, position))
+
+            await asyncio.gather(*tasks)
+            await asyncio.sleep(2)  # Интервал 2 секунды
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n\n⏹ Симулятор остановлен")
--- a/transport/docker-compose.yml
+++ b/transport/docker-compose.yml
@@ -0,0 +1,57 @@
+version: '3.8'
+
+services:
+  nginx:
+    image: nginx:1.25-alpine
+    ports:
+      - "3000:80"
+    volumes:
+      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./nginx/conf.d:/etc/nginx/conf.d:ro
+    depends_on:
+      - backend
+      - frontend
+    restart: unless-stopped
+
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    volumes:
+      - ./backend:/app  # Для разработки — изменения без пересборки
+    environment:
+      - DATABASE_URL=postgresql://postgres:postgres@postgres:5432/transport
+      - PYTHONUNBUFFERED=1
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: unless-stopped
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    environment:
+      - VITE_API_URL=/api
+      - VITE_WS_URL=/ws
+    restart: unless-stopped
+
+  postgres:
+    image: postgres:15-alpine
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=transport
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+
+volumes:
+  postgres_data:
--- a/transport/docs/TECHNICAL_SPECIFICATION.md
+++ b/transport/docs/TECHNICAL_SPECIFICATION.md
@@ -0,0 +1,477 @@
+# Техническое задание
+## Система мониторинга транспорта в реальном времени
+
+---
+
+## 1. Общие сведения
+
+| Параметр | Значение |
+|----------|----------|
+| Название проекта | Transport Monitoring System |
+| Тип | Учебный проект |
+| Версия ТЗ | 1.0 |
+| Дата | 2025-12-18 |
+| Срок разработки | 2 недели |
+| Frontend фреймворк | Vue 3 (выбран) |
+
+---
+
+## 2. Цели и задачи проекта
+
+### 2.1 Цель
+Разработка веб-системы для мониторинга местоположения транспортных средств в реальном времени с визуализацией на карте и хранением истории перемещений.
+
+### 2.2 Задачи
+- Отображение текущего положения транспорта на интерактивной карте
+- Обновление позиций в реальном времени (WebSocket)
+- Хранение и просмотр истории перемещений
+- Генерация событий (остановки, превышение скорости)
+- Симуляция данных для демонстрации работы системы
+
+---
+
+## 3. Технологический стек
+
+### 3.1 Backend
+| Компонент | Технология | Версия |
+|-----------|------------|--------|
+| Язык | Python | 3.11+ |
+| Фреймворк | FastAPI | 0.104+ |
+| ORM | SQLAlchemy | 2.0+ |
+| Миграции | Alembic | 1.12+ |
+| База данных | PostgreSQL | 15+ |
+| WebSocket | FastAPI WebSockets | встроено |
+
+### 3.2 Frontend
+| Компонент | Технология | Версия |
+|-----------|------------|--------|
+| Фреймворк | Vue 3 | 3.4+ |
+| Сборщик | Vite | 5.0+ |
+| Карты | Leaflet | 1.9+ |
+| UI-компоненты | Naive UI | 2.35+ |
+| HTTP-клиент | Axios | 1.6+ |
+
+### 3.3 Инфраструктура
+| Компонент | Технология |
+|-----------|------------|
+| Контейнеризация | Docker + Docker Compose |
+| Reverse Proxy | Nginx 1.25+ |
+| Тайлы карты | OpenStreetMap |
+
+### 3.4 Nginx (Reverse Proxy)
+Nginx выступает единой точкой входа:
+- `/` → статика Vue (production) или проксирование на Vite (development)
+- `/api/*` → проксирование на FastAPI backend
+- `/ws/*` → проксирование WebSocket на backend
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                        Nginx (:80)                          │
+├─────────────────────────────────────────────────────────────┤
+│  /              →  Frontend (статика или Vite dev:5173)     │
+│  /api/*         →  Backend (FastAPI :8000)                  │
+│  /ws/*          →  Backend WebSocket (:8000)                │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 4. Функциональные требования
+
+### 4.1 Модуль "Диспетчер" (главный экран)
+
+#### FR-1.1 Карта
+- [ ] Отображение интерактивной карты на базе Leaflet + OSM
+- [ ] Маркеры транспортных средств с иконками по типу (автобус, грузовик, легковой)
+- [ ] Всплывающая подсказка при наведении на маркер (название, скорость)
+- [ ] Центрирование карты по выбранному объекту
+
+#### FR-1.2 Список объектов
+- [ ] Боковая панель со списком всех транспортных средств
+- [ ] Поиск/фильтрация по названию
+- [ ] Индикатор статуса: движется (зелёный), стоит (жёлтый), нет связи (серый)
+- [ ] Клик по объекту — выделение на карте + открытие карточки
+
+#### FR-1.3 Карточка объекта
+- [ ] Название и тип ТС
+- [ ] Текущие координаты (lat, lon)
+- [ ] Скорость (км/ч)
+- [ ] Направление движения (heading)
+- [ ] Время последней точки
+- [ ] Статус (движется/стоит)
+
+### 4.2 Модуль "История движения"
+
+#### FR-2.1 Запрос истории
+- [ ] Выбор временного диапазона: 30 мин / 1 час / 24 часа / произвольный
+- [ ] Кнопка "Показать трек"
+
+#### FR-2.2 Отображение трека
+- [ ] Полилиния маршрута на карте
+- [ ] Цветовая индикация скорости (опционально)
+- [ ] Маркеры начала и конца маршрута
+
+#### FR-2.3 Таблица точек
+- [ ] Список точек: время, координаты, скорость
+- [ ] Клик по строке — центрирование карты на точке
+- [ ] Экспорт в CSV (опционально)
+
+### 4.3 Модуль "Реалтайм обновления"
+
+#### FR-3.1 WebSocket соединение
+- [ ] Автоматическое подключение при загрузке страницы
+- [ ] Переподключение при обрыве связи
+- [ ] Индикатор статуса соединения в UI
+
+#### FR-3.2 Обновление данных
+- [ ] Плавное перемещение маркеров при получении новых координат
+- [ ] Обновление данных в карточке объекта
+- [ ] Обновление статусов в списке объектов
+
+### 4.4 Модуль "События"
+
+#### FR-4.1 Типы событий
+- [ ] `LONG_STOP` — остановка более N минут (настраиваемый порог)
+- [ ] `OVERSPEED` — превышение скорости (порог настраивается)
+- [ ] `CONNECTION_LOST` — нет данных более 5 минут
+
+#### FR-4.2 Лента событий
+- [ ] Панель с последними событиями (10-20 штук)
+- [ ] Фильтр по типу события
+- [ ] Клик по событию — переход к объекту на карте
+
+### 4.5 Модуль "Симулятор"
+
+#### FR-5.1 Генерация данных
+- [ ] Python-скрипт для имитации движения N объектов
+- [ ] Реалистичное движение по координатам (не телепортация)
+- [ ] Случайные остановки и изменения скорости
+- [ ] Отправка данных через REST API или WebSocket
+
+---
+
+## 5. Архитектура системы
+
+### 5.1 Общая схема
+```
+                              ┌─────────────────┐
+                              │                 │
+                              │     Nginx       │ :80
+                              │  (reverse proxy)│
+                              │                 │
+                              └────────┬────────┘
+                                       │
+                    ┌──────────────────┼──────────────────┐
+                    │ /api, /ws        │ /                │
+                    ▼                  │                  ▼
+┌─────────────────┐ │  ┌─────────────────┐     ┌─────────────────┐
+│                 │ │  │                 │     │                 │
+│   Симулятор     │────▶   Backend       │     │   Frontend      │
+│   (Python)      │POST│   (FastAPI)     │     │   (Vue 3)       │
+│                 │    │   :8000         │     │   :5173 (dev)   │
+└─────────────────┘    └────────┬────────┘     └─────────────────┘
+                                │
+                                │ SQL
+                                ▼
+                       ┌─────────────────┐
+                       │                 │
+                       │   PostgreSQL    │ :5432
+                       │                 │
+                       └─────────────────┘
+```
+
+### 5.2 Структура проекта
+```
+transport/
+├── docker-compose.yml
+├── docs/
+│   └── TECHNICAL_SPECIFICATION.md
+├── nginx/
+│   ├── nginx.conf           # Основной конфиг
+│   ├── conf.d/
+│   │   └── default.conf     # Конфиг сервера
+│   └── Dockerfile           # (опционально, для кастомизации)
+├── backend/
+│   ├── Dockerfile
+│   ├── requirements.txt
+│   ├── alembic/
+│   │   └── versions/
+│   ├── alembic.ini
+│   ├── app/
+│   │   ├── __init__.py
+│   │   ├── main.py              # FastAPI приложение
+│   │   ├── config.py            # Настройки
+│   │   ├── database.py          # Подключение к БД
+│   │   ├── models/
+│   │   │   ├── __init__.py
+│   │   │   ├── vehicle.py
+│   │   │   ├── position.py
+│   │   │   └── event.py
+│   │   ├── schemas/
+│   │   │   ├── __init__.py
+│   │   │   ├── vehicle.py
+│   │   │   ├── position.py
+│   │   │   └── event.py
+│   │   ├── routers/
+│   │   │   ├── __init__.py
+│   │   │   ├── vehicles.py
+│   │   │   ├── positions.py
+│   │   │   └── events.py
+│   │   ├── services/
+│   │   │   ├── __init__.py
+│   │   │   ├── event_detector.py
+│   │   │   └── websocket_manager.py
+│   │   └── websocket.py         # WS эндпоинт
+│   └── simulator/
+│       └── run.py               # Симулятор данных
+├── frontend/
+│   ├── Dockerfile
+│   ├── package.json
+│   ├── vite.config.js
+│   ├── index.html
+│   └── src/
+│       ├── main.js
+│       ├── App.vue
+│       ├── components/
+│       │   ├── MapView.vue
+│       │   ├── VehicleList.vue
+│       │   ├── VehicleCard.vue
+│       │   ├── TrackHistory.vue
+│       │   └── EventFeed.vue
+│       ├── composables/
+│       │   ├── useWebSocket.js
+│       │   └── useVehicles.js
+│       └── stores/
+│           └── vehicles.js
+└── README.md
+```
+
+---
+
+## 6. API спецификация
+
+### 6.1 REST API
+
+#### Транспортные средства
+
+| Метод | Эндпоинт | Описание |
+|-------|----------|----------|
+| GET | `/api/vehicles` | Список всех ТС |
+| GET | `/api/vehicles/{id}` | Информация о ТС |
+| POST | `/api/vehicles` | Создать ТС |
+| PUT | `/api/vehicles/{id}` | Обновить ТС |
+| DELETE | `/api/vehicles/{id}` | Удалить ТС |
+
+#### Позиции
+
+| Метод | Эндпоинт | Описание |
+|-------|----------|----------|
+| GET | `/api/vehicles/{id}/positions` | История позиций ТС |
+| POST | `/api/ingest/position` | Принять новую позицию |
+| GET | `/api/vehicles/{id}/last-position` | Последняя позиция ТС |
+
+**Query параметры для `/api/vehicles/{id}/positions`:**
+- `from` — начало периода (ISO 8601)
+- `to` — конец периода (ISO 8601)
+- `limit` — максимум записей (default: 1000)
+
+#### События
+
+| Метод | Эндпоинт | Описание |
+|-------|----------|----------|
+| GET | `/api/events` | Список событий |
+| GET | `/api/vehicles/{id}/events` | События конкретного ТС |
+
+**Query параметры для `/api/events`:**
+- `type` — тип события (LONG_STOP, OVERSPEED, CONNECTION_LOST)
+- `from` / `to` — временной диапазон
+- `limit` — максимум записей
+
+### 6.2 WebSocket API
+
+#### Подключение
+```
+ws://localhost/ws/positions
+```
+*(Nginx проксирует на backend:8000)*
+
+#### Формат сообщений (сервер → клиент)
+```json
+{
+  "type": "position_update",
+  "data": {
+    "vehicle_id": 1,
+    "lat": 55.7558,
+    "lon": 37.6173,
+    "speed": 45.5,
+    "heading": 180,
+    "timestamp": "2025-12-18T12:00:00Z"
+  }
+}
+```
+
+```json
+{
+  "type": "event",
+  "data": {
+    "id": 123,
+    "vehicle_id": 1,
+    "type": "OVERSPEED",
+    "payload": {"speed": 95, "limit": 60},
+    "timestamp": "2025-12-18T12:00:00Z"
+  }
+}
+```
+
+---
+
+## 7. Структура базы данных
+
+### 7.1 Таблица `vehicles`
+| Поле | Тип | Описание |
+|------|-----|----------|
+| id | SERIAL PRIMARY KEY | Идентификатор |
+| name | VARCHAR(100) NOT NULL | Название/номер ТС |
+| type | VARCHAR(50) | Тип: bus, truck, car |
+| created_at | TIMESTAMP | Дата создания |
+
+### 7.2 Таблица `positions`
+| Поле | Тип | Описание |
+|------|-----|----------|
+| id | SERIAL PRIMARY KEY | Идентификатор |
+| vehicle_id | INTEGER FK | Ссылка на vehicles |
+| timestamp | TIMESTAMP NOT NULL | Время фиксации |
+| lat | DOUBLE PRECISION | Широта |
+| lon | DOUBLE PRECISION | Долгота |
+| speed | REAL | Скорость (км/ч) |
+| heading | REAL | Направление (0-360) |
+
+**Индексы:**
+- `idx_positions_vehicle_ts` ON (vehicle_id, timestamp DESC)
+
+### 7.3 Таблица `events`
+| Поле | Тип | Описание |
+|------|-----|----------|
+| id | SERIAL PRIMARY KEY | Идентификатор |
+| vehicle_id | INTEGER FK | Ссылка на vehicles |
+| timestamp | TIMESTAMP NOT NULL | Время события |
+| type | VARCHAR(50) NOT NULL | Тип события |
+| payload | JSONB | Дополнительные данные |
+
+**Индексы:**
+- `idx_events_vehicle_ts` ON (vehicle_id, timestamp DESC)
+- `idx_events_type` ON (type)
+
+---
+
+## 8. Нефункциональные требования
+
+### 8.1 Производительность
+- Система должна поддерживать минимум 100 одновременных объектов
+- Частота обновления позиций: 1 раз в 1-2 секунды на объект
+- Время отклика API: < 500 мс для 95% запросов
+
+### 8.2 Надёжность
+- WebSocket должен автоматически переподключаться при обрыве
+- При недоступности БД — graceful degradation с логированием ошибок
+
+### 8.3 Развёртывание
+- Запуск всей системы одной командой: `docker-compose up`
+- Автоматическое применение миграций при старте
+
+### 8.4 Безопасность (упрощённо для учебного проекта)
+- CORS настроен для локальной разработки
+- Валидация входных данных на уровне Pydantic-схем
+- (Опционально) Базовая авторизация через API-ключ
+
+---
+
+## 9. Этапы разработки
+
+### Этап 1: Инфраструктура
+- [ ] Настройка Docker Compose (Nginx + PostgreSQL + backend + frontend)
+- [ ] Конфигурация Nginx (проксирование /api, /ws, статика)
+- [ ] Базовая структура FastAPI приложения
+- [ ] Подключение к БД, настройка Alembic
+- [ ] Базовая структура Vue-приложения
+
+### Этап 2: CRUD и карта
+- [ ] Модели и миграции для vehicles, positions
+- [ ] REST API для vehicles
+- [ ] Endpoint POST /ingest/position
+- [ ] Фронт: отображение карты с маркерами
+- [ ] Фронт: список объектов + карточка
+
+### Этап 3: Реалтайм
+- [ ] WebSocket manager на бэкенде
+- [ ] Broadcast новых позиций всем клиентам
+- [ ] Фронт: подключение к WS, обновление маркеров
+- [ ] Симулятор: базовая версия
+
+### Этап 4: История и события
+- [ ] GET /vehicles/{id}/positions с фильтрами
+- [ ] Модель events + детектор событий
+- [ ] Фронт: отображение трека на карте
+- [ ] Фронт: таблица точек + лента событий
+
+### Этап 5: Финализация
+- [ ] Улучшение UI/UX
+- [ ] Доработка симулятора (реалистичные маршруты)
+- [ ] Тестирование под нагрузкой (100 объектов)
+- [ ] Документация для запуска и демонстрации
+
+---
+
+## 10. Запуск проекта
+
+### Требования
+- Docker 20.10+
+- Docker Compose 2.0+
+
+### Команды
+```bash
+# Клонировать репозиторий
+git clone <repo-url>
+cd transport
+
+# Запустить всё
+docker-compose up --build
+
+# Доступ (всё через Nginx на порту 80)
+# Приложение:    http://localhost
+# API:           http://localhost/api
+# API Docs:      http://localhost/api/docs
+# WebSocket:     ws://localhost/ws/positions
+
+# Запустить симулятор (в отдельном терминале)
+docker-compose exec backend python -m simulator.run
+```
+
+### Docker Compose сервисы
+| Сервис | Порт (внутренний) | Порт (внешний) | Описание |
+|--------|-------------------|----------------|----------|
+| nginx | 80 | 80 | Reverse proxy, точка входа |
+| backend | 8000 | - | FastAPI, доступен только через nginx |
+| frontend | 5173 (dev) | - | Vue dev server, доступен только через nginx |
+| postgres | 5432 | 5432* | База данных |
+
+*Порт PostgreSQL открыт наружу для удобства разработки (подключение через IDE/DBeaver)
+
+---
+
+## 11. Критерии приёмки
+
+| № | Критерий | Приоритет |
+|---|----------|-----------|
+| 1 | Карта отображается с маркерами объектов | Обязательно |
+| 2 | Позиции обновляются в реальном времени (WS) | Обязательно |
+| 3 | История движения показывается на карте | Обязательно |
+| 4 | Система запускается через docker-compose up | Обязательно |
+| 5 | Симулятор генерирует тестовые данные | Обязательно |
+| 6 | Лента событий отображается | Желательно |
+| 7 | Поддержка 100+ объектов без лагов | Желательно |
+| 8 | Экспорт истории в CSV | Опционально |
+
+---
+
+*Документ составлен: 2025-12-18*
--- a/transport/frontend/Dockerfile
+++ b/transport/frontend/Dockerfile
@@ -0,0 +1,16 @@
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Install dependencies
+COPY package*.json ./
+RUN npm install
+
+# Copy source code
+COPY . .
+
+# Expose Vite dev server port
+EXPOSE 5173
+
+# Start Vite dev server with host flag for Docker
+CMD ["npm", "run", "dev", "--", "--host", "0.0.0.0"]
--- a/transport/frontend/index.html
+++ b/transport/frontend/index.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="ru">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Мониторинг транспорта</title>
+    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>
--- a/transport/frontend/package.json
+++ b/transport/frontend/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "transport-monitoring-frontend",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "vue": "^3.4.0",
+    "axios": "^1.6.0",
+    "leaflet": "^1.9.4",
+    "naive-ui": "^2.35.0",
+    "pinia": "^2.1.7",
+    "@vueuse/core": "^10.7.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^4.5.0",
+    "vite": "^5.0.0"
+  }
+}
--- a/transport/frontend/src/App.vue
+++ b/transport/frontend/src/App.vue
@@ -0,0 +1,289 @@
+<template>
+  <n-config-provider :theme="darkTheme">
+    <n-layout class="app-layout">
+      <!-- Заголовок -->
+      <n-layout-header class="app-header">
+        <div class="header-content">
+          <h1>🚗 Мониторинг транспорта</h1>
+          <n-space>
+            <n-tag :type="wsConnected ? 'success' : 'error'" size="small">
+              {{ wsConnected ? '● Онлайн' : '○ Офлайн' }}
+            </n-tag>
+            <n-tag type="info" size="small">
+              Объектов: {{ vehicles.length }}
+            </n-tag>
+          </n-space>
+        </div>
+      </n-layout-header>
+
+      <n-layout has-sider class="app-content">
+        <!-- Боковая панель -->
+        <n-layout-sider
+          :width="320"
+          :collapsed-width="0"
+          show-trigger="bar"
+          bordered
+        >
+          <div class="sidebar-content">
+            <!-- Поиск -->
+            <n-input
+              v-model:value="searchQuery"
+              placeholder="Поиск по названию..."
+              clearable
+              class="search-input"
+            >
+              <template #prefix>
+                <span>🔍</span>
+              </template>
+            </n-input>
+
+            <!-- Список транспорта -->
+            <VehicleList
+              :vehicles="filteredVehicles"
+              :selected-id="selectedVehicleId"
+              @select="selectVehicle"
+            />
+
+            <!-- Карточка выбранного объекта -->
+            <VehicleCard
+              v-if="selectedVehicle"
+              :vehicle="selectedVehicle"
+              @show-track="showTrack"
+            />
+
+            <!-- История трека -->
+            <TrackHistory
+              v-if="currentTrack"
+              :track="currentTrack"
+              @close="currentTrack = null"
+              @select-point="centerOnPoint"
+            />
+
+            <!-- Лента событий -->
+            <EventFeed
+              :events="recentEvents"
+              :vehicles="vehicles"
+              @select-vehicle="selectVehicle"
+            />
+          </div>
+        </n-layout-sider>
+
+        <!-- Карта -->
+        <n-layout-content>
+          <MapView
+            ref="mapRef"
+            :vehicles="vehicles"
+            :selected-id="selectedVehicleId"
+            :track="currentTrack"
+            @select="selectVehicle"
+          />
+        </n-layout-content>
+      </n-layout>
+    </n-layout>
+  </n-config-provider>
+</template>
+
+<script setup>
+import { ref, computed, onMounted, onUnmounted } from 'vue'
+import { darkTheme } from 'naive-ui'
+import axios from 'axios'
+import MapView from './components/MapView.vue'
+import VehicleList from './components/VehicleList.vue'
+import VehicleCard from './components/VehicleCard.vue'
+import TrackHistory from './components/TrackHistory.vue'
+import EventFeed from './components/EventFeed.vue'
+
+// State
+const vehicles = ref([])
+const selectedVehicleId = ref(null)
+const searchQuery = ref('')
+const wsConnected = ref(false)
+const recentEvents = ref([])
+const currentTrack = ref(null)
+const mapRef = ref(null)
+
+let ws = null
+
+// Computed
+const filteredVehicles = computed(() => {
+  if (!searchQuery.value) return vehicles.value
+  const query = searchQuery.value.toLowerCase()
+  return vehicles.value.filter(v =>
+    v.name.toLowerCase().includes(query)
+  )
+})
+
+const selectedVehicle = computed(() =>
+  vehicles.value.find(v => v.id === selectedVehicleId.value)
+)
+
+// Methods
+const fetchVehicles = async () => {
+  try {
+    const response = await axios.get('/api/vehicles')
+    vehicles.value = response.data
+  } catch (error) {
+    console.error('Failed to fetch vehicles:', error)
+  }
+}
+
+const fetchEvents = async () => {
+  try {
+    const response = await axios.get('/api/events', {
+      params: { limit: 20 }
+    })
+    recentEvents.value = response.data
+  } catch (error) {
+    console.error('Failed to fetch events:', error)
+  }
+}
+
+const selectVehicle = (id) => {
+  selectedVehicleId.value = id
+  currentTrack.value = null
+
+  if (id && mapRef.value) {
+    const vehicle = vehicles.value.find(v => v.id === id)
+    if (vehicle?.last_position) {
+      mapRef.value.centerOn(vehicle.last_position.lat, vehicle.last_position.lon)
+    }
+  }
+}
+
+const showTrack = async (vehicleId, minutes = 30) => {
+  try {
+    const from = new Date(Date.now() - minutes * 60 * 1000).toISOString()
+    const response = await axios.get(`/api/vehicles/${vehicleId}/positions`, {
+      params: { from }
+    })
+    currentTrack.value = {
+      vehicleId,
+      positions: response.data.reverse() // От старых к новым
+    }
+  } catch (error) {
+    console.error('Failed to fetch track:', error)
+  }
+}
+
+const centerOnPoint = (point) => {
+  if (mapRef.value && point) {
+    mapRef.value.centerOn(point.lat, point.lon, 16)
+  }
+}
+
+const connectWebSocket = () => {
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
+  ws = new WebSocket(`${protocol}//${window.location.host}/ws/positions`)
+
+  ws.onopen = () => {
+    wsConnected.value = true
+    console.log('WebSocket connected')
+  }
+
+  ws.onmessage = (event) => {
+    const message = JSON.parse(event.data)
+
+    if (message.type === 'position_update') {
+      updateVehiclePosition(message.data)
+    } else if (message.type === 'event') {
+      addEvent(message.data)
+    }
+  }
+
+  ws.onclose = () => {
+    wsConnected.value = false
+    console.log('WebSocket disconnected, reconnecting...')
+    setTimeout(connectWebSocket, 3000)
+  }
+
+  ws.onerror = (error) => {
+    console.error('WebSocket error:', error)
+  }
+}
+
+const updateVehiclePosition = (data) => {
+  const vehicle = vehicles.value.find(v => v.id === data.vehicle_id)
+  if (vehicle) {
+    vehicle.last_position = {
+      lat: data.lat,
+      lon: data.lon,
+      speed: data.speed,
+      heading: data.heading,
+      timestamp: data.timestamp
+    }
+    vehicle.status = data.speed > 2 ? 'moving' : 'stopped'
+  }
+}
+
+const addEvent = (data) => {
+  recentEvents.value.unshift(data)
+  if (recentEvents.value.length > 20) {
+    recentEvents.value.pop()
+  }
+}
+
+// Lifecycle
+onMounted(() => {
+  fetchVehicles()
+  fetchEvents()
+  connectWebSocket()
+})
+
+onUnmounted(() => {
+  if (ws) {
+    ws.close()
+  }
+})
+</script>
+
+<style>
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+html, body, #app {
+  height: 100%;
+  width: 100%;
+}
+
+.app-layout {
+  height: 100vh;
+}
+
+.app-header {
+  padding: 12px 20px;
+  background: #1e1e2e;
+  border-bottom: 1px solid #333;
+}
+
+.header-content {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.header-content h1 {
+  font-size: 18px;
+  font-weight: 600;
+  color: #fff;
+}
+
+.app-content {
+  height: calc(100vh - 56px);
+}
+
+.sidebar-content {
+  padding: 12px;
+  height: 100%;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.search-input {
+  flex-shrink: 0;
+}
+</style>
--- a/transport/frontend/src/components/EventFeed.vue
+++ b/transport/frontend/src/components/EventFeed.vue
@@ -0,0 +1,153 @@
+<template>
+  <n-card title="События" size="small" class="event-feed">
+    <template #header-extra>
+      <n-select
+        v-model:value="filterType"
+        :options="filterOptions"
+        size="tiny"
+        style="width: 100px"
+        placeholder="Все"
+        clearable
+      />
+    </template>
+
+    <n-scrollbar style="max-height: 200px">
+      <div
+        v-for="event in filteredEvents"
+        :key="event.id"
+        class="event-item"
+        @click="handleClick(event)"
+      >
+        <div class="event-icon">
+          {{ getIcon(event.type) }}
+        </div>
+        <div class="event-content">
+          <div class="event-title">
+            {{ getTitle(event) }}
+          </div>
+          <div class="event-meta">
+            <span class="event-vehicle">{{ getVehicleName(event.vehicle_id) }}</span>
+            <span class="event-time">{{ formatTime(event.timestamp) }}</span>
+          </div>
+        </div>
+      </div>
+
+      <n-empty v-if="filteredEvents.length === 0" description="Нет событий" size="small" />
+    </n-scrollbar>
+  </n-card>
+</template>
+
+<script setup>
+import { ref, computed } from 'vue'
+
+const props = defineProps({
+  events: {
+    type: Array,
+    default: () => []
+  },
+  vehicles: {
+    type: Array,
+    default: () => []
+  }
+})
+
+const emit = defineEmits(['select-vehicle'])
+
+const filterType = ref(null)
+
+const filterOptions = [
+  { label: '⚠️ Скорость', value: 'OVERSPEED' },
+  { label: '⏸️ Остановка', value: 'LONG_STOP' },
+  { label: '📡 Связь', value: 'CONNECTION_LOST' }
+]
+
+const filteredEvents = computed(() => {
+  if (!filterType.value) return props.events
+  return props.events.filter(e => e.type === filterType.value)
+})
+
+const getIcon = (type) => {
+  const icons = {
+    OVERSPEED: '⚠️',
+    LONG_STOP: '⏸️',
+    CONNECTION_LOST: '📡'
+  }
+  return icons[type] || '📌'
+}
+
+const getTitle = (event) => {
+  const titles = {
+    OVERSPEED: `Превышение: ${event.payload?.speed?.toFixed(0) || '?'} км/ч`,
+    LONG_STOP: `Остановка: ${event.payload?.duration_minutes?.toFixed(0) || '?'} мин`,
+    CONNECTION_LOST: 'Потеря связи'
+  }
+  return titles[event.type] || event.type
+}
+
+const getVehicleName = (vehicleId) => {
+  const vehicle = props.vehicles.find(v => v.id === vehicleId)
+  return vehicle?.name || `#${vehicleId}`
+}
+
+const formatTime = (timestamp) => {
+  const date = new Date(timestamp)
+  return date.toLocaleTimeString('ru-RU', {
+    hour: '2-digit',
+    minute: '2-digit'
+  })
+}
+
+const handleClick = (event) => {
+  emit('select-vehicle', event.vehicle_id)
+}
+</script>
+
+<style scoped>
+.event-feed {
+  flex: 1;
+  min-height: 0;
+}
+
+.event-item {
+  display: flex;
+  gap: 10px;
+  padding: 8px 4px;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+  cursor: pointer;
+  border-radius: 4px;
+  transition: background 0.2s;
+}
+
+.event-item:hover {
+  background: rgba(59, 130, 246, 0.1);
+}
+
+.event-item:last-child {
+  border-bottom: none;
+}
+
+.event-icon {
+  font-size: 18px;
+}
+
+.event-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.event-title {
+  font-size: 13px;
+}
+
+.event-meta {
+  display: flex;
+  justify-content: space-between;
+  font-size: 11px;
+  color: #888;
+  margin-top: 2px;
+}
+
+.event-vehicle {
+  color: #6b9eff;
+}
+</style>
--- a/transport/frontend/src/components/MapView.vue
+++ b/transport/frontend/src/components/MapView.vue
@@ -0,0 +1,204 @@
+<template>
+  <div ref="mapContainer" class="map-container"></div>
+</template>
+
+<script setup>
+import { ref, onMounted, watch, defineExpose } from 'vue'
+import L from 'leaflet'
+
+const props = defineProps({
+  vehicles: {
+    type: Array,
+    default: () => []
+  },
+  selectedId: {
+    type: Number,
+    default: null
+  },
+  track: {
+    type: Object,
+    default: null
+  }
+})
+
+const emit = defineEmits(['select'])
+
+const mapContainer = ref(null)
+let map = null
+const markers = new Map()
+let trackLine = null
+
+// Иконки для разных типов и статусов
+const createIcon = (type, status, isSelected) => {
+  const colors = {
+    moving: '#22c55e',
+    stopped: '#eab308',
+    offline: '#6b7280'
+  }
+
+  const icons = {
+    bus: '🚌',
+    truck: '🚚',
+    car: '🚗'
+  }
+
+  const color = colors[status] || colors.offline
+  const icon = icons[type] || icons.car
+  const size = isSelected ? 36 : 28
+  const border = isSelected ? '3px solid #3b82f6' : '2px solid #fff'
+
+  return L.divIcon({
+    className: 'vehicle-marker',
+    html: `
+      <div style="
+        width: ${size}px;
+        height: ${size}px;
+        background: ${color};
+        border-radius: 50%;
+        border: ${border};
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: ${size * 0.5}px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+        cursor: pointer;
+      ">
+        ${icon}
+      </div>
+    `,
+    iconSize: [size, size],
+    iconAnchor: [size / 2, size / 2]
+  })
+}
+
+const initMap = () => {
+  map = L.map(mapContainer.value, {
+    center: [55.0304, 82.9204], // Новосибирск
+    zoom: 13,
+    zoomControl: true
+  })
+
+  L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+    attribution: '© OpenStreetMap contributors'
+  }).addTo(map)
+}
+
+const updateMarkers = () => {
+  if (!map) return
+
+  // Обновляем существующие и добавляем новые маркеры
+  props.vehicles.forEach(vehicle => {
+    if (!vehicle.last_position) return
+
+    const { lat, lon } = vehicle.last_position
+    const isSelected = vehicle.id === props.selectedId
+
+    if (markers.has(vehicle.id)) {
+      // Обновляем существующий маркер
+      const marker = markers.get(vehicle.id)
+      marker.setLatLng([lat, lon])
+      marker.setIcon(createIcon(vehicle.type, vehicle.status, isSelected))
+    } else {
+      // Создаём новый маркер
+      const marker = L.marker([lat, lon], {
+        icon: createIcon(vehicle.type, vehicle.status, isSelected)
+      })
+
+      marker.on('click', () => {
+        emit('select', vehicle.id)
+      })
+
+      // Всплывающая подсказка
+      marker.bindTooltip(`
+        <strong>${vehicle.name}</strong><br>
+        Скорость: ${vehicle.last_position.speed.toFixed(1)} км/ч
+      `, { direction: 'top', offset: [0, -10] })
+
+      marker.addTo(map)
+      markers.set(vehicle.id, marker)
+    }
+  })
+
+  // Удаляем маркеры для несуществующих объектов
+  const vehicleIds = new Set(props.vehicles.map(v => v.id))
+  markers.forEach((marker, id) => {
+    if (!vehicleIds.has(id)) {
+      map.removeLayer(marker)
+      markers.delete(id)
+    }
+  })
+}
+
+const updateTrack = () => {
+  if (!map) return
+
+  // Удаляем старый трек
+  if (trackLine) {
+    map.removeLayer(trackLine)
+    trackLine = null
+  }
+
+  // Добавляем новый трек
+  if (props.track && props.track.positions.length > 0) {
+    const points = props.track.positions.map(p => [p.lat, p.lon])
+
+    trackLine = L.polyline(points, {
+      color: '#3b82f6',
+      weight: 4,
+      opacity: 0.8
+    }).addTo(map)
+
+    // Маркеры начала и конца
+    if (points.length > 1) {
+      L.circleMarker(points[0], {
+        radius: 8,
+        color: '#22c55e',
+        fillColor: '#22c55e',
+        fillOpacity: 1
+      }).bindTooltip('Начало').addTo(map)
+
+      L.circleMarker(points[points.length - 1], {
+        radius: 8,
+        color: '#ef4444',
+        fillColor: '#ef4444',
+        fillOpacity: 1
+      }).bindTooltip('Конец').addTo(map)
+    }
+
+    // Подгоняем карту под трек
+    map.fitBounds(trackLine.getBounds(), { padding: [50, 50] })
+  }
+}
+
+const centerOn = (lat, lon, zoom = 15) => {
+  if (map) {
+    map.setView([lat, lon], zoom)
+  }
+}
+
+// Expose methods
+defineExpose({ centerOn })
+
+// Watchers
+watch(() => props.vehicles, updateMarkers, { deep: true })
+watch(() => props.selectedId, updateMarkers)
+watch(() => props.track, updateTrack, { deep: true })
+
+// Lifecycle
+onMounted(() => {
+  initMap()
+  updateMarkers()
+})
+</script>
+
+<style scoped>
+.map-container {
+  width: 100%;
+  height: 100%;
+}
+
+:deep(.vehicle-marker) {
+  background: transparent;
+  border: none;
+}
+</style>
--- a/transport/frontend/src/components/TrackHistory.vue
+++ b/transport/frontend/src/components/TrackHistory.vue
@@ -0,0 +1,155 @@
+<template>
+  <n-card title="История трека" size="small" class="track-history" v-if="track">
+    <template #header-extra>
+      <n-space>
+        <n-button size="tiny" @click="exportCsv">📥 CSV</n-button>
+        <n-button size="tiny" @click="$emit('close')">✕</n-button>
+      </n-space>
+    </template>
+
+    <div class="track-info">
+      <n-tag type="info" size="small">
+        {{ track.positions.length }} точек
+      </n-tag>
+      <n-tag type="success" size="small" v-if="track.positions.length > 0">
+        {{ formatDuration }}
+      </n-tag>
+    </div>
+
+    <n-data-table
+      :columns="columns"
+      :data="track.positions"
+      :max-height="200"
+      size="small"
+      :row-key="row => row.id"
+      :row-class-name="getRowClassName"
+      @update:checked-row-keys="handleRowClick"
+      striped
+    />
+  </n-card>
+</template>
+
+<script setup>
+import { computed, h } from 'vue'
+import { NTag } from 'naive-ui'
+
+const props = defineProps({
+  track: {
+    type: Object,
+    default: null
+  }
+})
+
+const emit = defineEmits(['close', 'select-point'])
+
+const columns = [
+  {
+    title: 'Время',
+    key: 'timestamp',
+    width: 80,
+    render(row) {
+      return formatTime(row.timestamp)
+    }
+  },
+  {
+    title: 'Координаты',
+    key: 'coords',
+    width: 140,
+    render(row) {
+      return `${row.lat.toFixed(4)}, ${row.lon.toFixed(4)}`
+    }
+  },
+  {
+    title: 'Скорость',
+    key: 'speed',
+    width: 70,
+    render(row) {
+      const speed = row.speed.toFixed(0)
+      const type = row.speed > 60 ? 'error' : row.speed > 0 ? 'success' : 'default'
+      return h(NTag, { size: 'small', type }, { default: () => `${speed}` })
+    }
+  }
+]
+
+const formatTime = (timestamp) => {
+  const date = new Date(timestamp)
+  return date.toLocaleTimeString('ru-RU', {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  })
+}
+
+const formatDuration = computed(() => {
+  if (!props.track || props.track.positions.length < 2) return ''
+
+  const positions = props.track.positions
+  const start = new Date(positions[0].timestamp)
+  const end = new Date(positions[positions.length - 1].timestamp)
+  const diffMs = end - start
+  const diffMins = Math.round(diffMs / 60000)
+
+  if (diffMins < 60) return `${diffMins} мин`
+  const hours = Math.floor(diffMins / 60)
+  const mins = diffMins % 60
+  return `${hours}ч ${mins}м`
+})
+
+const getRowClassName = (row, index) => {
+  return 'track-row'
+}
+
+const handleRowClick = (keys) => {
+  // Найти точку по индексу и отправить событие
+  if (keys.length > 0) {
+    const point = props.track.positions.find(p => p.id === keys[0])
+    if (point) {
+      emit('select-point', point)
+    }
+  }
+}
+
+const exportCsv = () => {
+  if (!props.track || props.track.positions.length === 0) return
+
+  const headers = ['Время', 'Широта', 'Долгота', 'Скорость (км/ч)', 'Направление']
+  const rows = props.track.positions.map(p => [
+    new Date(p.timestamp).toISOString(),
+    p.lat,
+    p.lon,
+    p.speed,
+    p.heading
+  ])
+
+  const csv = [headers, ...rows].map(row => row.join(',')).join('\n')
+  const blob = new Blob([csv], { type: 'text/csv;charset=utf-8;' })
+  const url = URL.createObjectURL(blob)
+
+  const link = document.createElement('a')
+  link.href = url
+  link.download = `track_${props.track.vehicleId}_${new Date().toISOString().slice(0, 10)}.csv`
+  link.click()
+
+  URL.revokeObjectURL(url)
+}
+</script>
+
+<style scoped>
+.track-history {
+  flex-shrink: 0;
+}
+
+.track-info {
+  display: flex;
+  gap: 8px;
+  margin-bottom: 10px;
+}
+
+:deep(.track-row) {
+  cursor: pointer;
+}
+
+:deep(.track-row:hover) {
+  background: rgba(59, 130, 246, 0.1) !important;
+}
+</style>
--- a/transport/frontend/src/components/VehicleCard.vue
+++ b/transport/frontend/src/components/VehicleCard.vue
@@ -0,0 +1,111 @@
+<template>
+  <n-card :title="vehicle.name" size="small" class="vehicle-card">
+    <template #header-extra>
+      <n-tag :type="getStatusType(vehicle.status)" size="small">
+        {{ getStatusText(vehicle.status) }}
+      </n-tag>
+    </template>
+
+    <div class="card-content" v-if="vehicle.last_position">
+      <div class="info-row">
+        <span class="label">📍 Координаты:</span>
+        <span class="value">
+          {{ vehicle.last_position.lat.toFixed(5) }},
+          {{ vehicle.last_position.lon.toFixed(5) }}
+        </span>
+      </div>
+
+      <div class="info-row">
+        <span class="label">🚀 Скорость:</span>
+        <span class="value">{{ vehicle.last_position.speed.toFixed(1) }} км/ч</span>
+      </div>
+
+      <div class="info-row">
+        <span class="label">🧭 Направление:</span>
+        <span class="value">{{ vehicle.last_position.heading.toFixed(0) }}°</span>
+      </div>
+
+      <div class="info-row">
+        <span class="label">🕐 Обновлено:</span>
+        <span class="value">{{ formatTime(vehicle.last_position.timestamp) }}</span>
+      </div>
+
+      <n-divider />
+
+      <n-space>
+        <n-button size="small" @click="$emit('show-track', vehicle.id, 30)">
+          Трек 30 мин
+        </n-button>
+        <n-button size="small" @click="$emit('show-track', vehicle.id, 60)">
+          Трек 1 час
+        </n-button>
+      </n-space>
+    </div>
+
+    <n-empty v-else description="Нет данных о позиции" size="small" />
+  </n-card>
+</template>
+
+<script setup>
+defineProps({
+  vehicle: {
+    type: Object,
+    required: true
+  }
+})
+
+defineEmits(['show-track'])
+
+const getStatusType = (status) => {
+  const types = {
+    moving: 'success',
+    stopped: 'warning',
+    offline: 'default'
+  }
+  return types[status] || 'default'
+}
+
+const getStatusText = (status) => {
+  const texts = {
+    moving: 'Движется',
+    stopped: 'Остановлен',
+    offline: 'Нет связи'
+  }
+  return texts[status] || 'Неизвестно'
+}
+
+const formatTime = (timestamp) => {
+  const date = new Date(timestamp)
+  return date.toLocaleTimeString('ru-RU', {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  })
+}
+</script>
+
+<style scoped>
+.vehicle-card {
+  flex-shrink: 0;
+}
+
+.card-content {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.info-row {
+  display: flex;
+  justify-content: space-between;
+  font-size: 13px;
+}
+
+.label {
+  color: #888;
+}
+
+.value {
+  font-family: monospace;
+}
+</style>
--- a/transport/frontend/src/components/VehicleList.vue
+++ b/transport/frontend/src/components/VehicleList.vue
@@ -0,0 +1,121 @@
+<template>
+  <n-card title="Транспорт" size="small" class="vehicle-list">
+    <n-scrollbar style="max-height: 250px">
+      <div
+        v-for="vehicle in vehicles"
+        :key="vehicle.id"
+        class="vehicle-item"
+        :class="{ selected: vehicle.id === selectedId }"
+        @click="$emit('select', vehicle.id)"
+      >
+        <div class="vehicle-icon">
+          {{ getIcon(vehicle.type) }}
+        </div>
+        <div class="vehicle-info">
+          <div class="vehicle-name">{{ vehicle.name }}</div>
+          <div class="vehicle-speed" v-if="vehicle.last_position">
+            {{ vehicle.last_position.speed.toFixed(1) }} км/ч
+          </div>
+          <div class="vehicle-speed" v-else>Нет данных</div>
+        </div>
+        <div class="vehicle-status">
+          <n-badge
+            :type="getStatusType(vehicle.status)"
+            :value="getStatusText(vehicle.status)"
+          />
+        </div>
+      </div>
+
+      <n-empty v-if="vehicles.length === 0" description="Нет объектов" />
+    </n-scrollbar>
+  </n-card>
+</template>
+
+<script setup>
+defineProps({
+  vehicles: {
+    type: Array,
+    default: () => []
+  },
+  selectedId: {
+    type: Number,
+    default: null
+  }
+})
+
+defineEmits(['select'])
+
+const getIcon = (type) => {
+  const icons = {
+    bus: '🚌',
+    truck: '🚚',
+    car: '🚗'
+  }
+  return icons[type] || '🚗'
+}
+
+const getStatusType = (status) => {
+  const types = {
+    moving: 'success',
+    stopped: 'warning',
+    offline: 'default'
+  }
+  return types[status] || 'default'
+}
+
+const getStatusText = (status) => {
+  const texts = {
+    moving: 'Едет',
+    stopped: 'Стоит',
+    offline: 'Офлайн'
+  }
+  return texts[status] || 'Неизвестно'
+}
+</script>
+
+<style scoped>
+.vehicle-list {
+  flex-shrink: 0;
+}
+
+.vehicle-item {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 10px;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.vehicle-item:hover {
+  background: rgba(255, 255, 255, 0.05);
+}
+
+.vehicle-item.selected {
+  background: rgba(59, 130, 246, 0.2);
+  border: 1px solid rgba(59, 130, 246, 0.5);
+}
+
+.vehicle-icon {
+  font-size: 24px;
+}
+
+.vehicle-info {
+  flex: 1;
+}
+
+.vehicle-name {
+  font-weight: 500;
+  font-size: 14px;
+}
+
+.vehicle-speed {
+  font-size: 12px;
+  color: #888;
+}
+
+.vehicle-status {
+  flex-shrink: 0;
+}
+</style>
--- a/transport/frontend/src/main.js
+++ b/transport/frontend/src/main.js
@@ -0,0 +1,11 @@
+import { createApp } from 'vue'
+import { createPinia } from 'pinia'
+import naive from 'naive-ui'
+import App from './App.vue'
+
+const app = createApp(App)
+
+app.use(createPinia())
+app.use(naive)
+
+app.mount('#app')
--- a/transport/frontend/vite.config.js
+++ b/transport/frontend/vite.config.js
@@ -0,0 +1,13 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+
+export default defineConfig({
+  plugins: [vue()],
+  server: {
+    host: '0.0.0.0',
+    port: 5173,
+    watch: {
+      usePolling: true
+    }
+  }
+})
--- a/transport/nginx/conf.d/default.conf
+++ b/transport/nginx/conf.d/default.conf
@@ -0,0 +1,51 @@
+# Upstream definitions
+upstream backend {
+    server backend:8000;
+}
+
+upstream frontend {
+    server frontend:5173;
+}
+
+server {
+    listen 80;
+    server_name localhost;
+
+    # Frontend (Vue dev server)
+    location / {
+        proxy_pass http://frontend;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    # Backend API (strip /api prefix)
+    location /api/ {
+        proxy_pass http://backend/;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    # WebSocket
+    location /ws {
+        proxy_pass http://backend;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        # WebSocket timeout settings
+        proxy_read_timeout 86400;
+        proxy_send_timeout 86400;
+    }
+}
--- a/transport/nginx/nginx.conf
+++ b/transport/nginx/nginx.conf
@@ -0,0 +1,29 @@
+user  nginx;
+worker_processes  auto;
+
+error_log  /var/log/nginx/error.log notice;
+pid        /var/run/nginx.pid;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+
+    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                      '$status $body_bytes_sent "$http_referer" '
+                      '"$http_user_agent" "$http_x_forwarded_for"';
+
+    access_log  /var/log/nginx/access.log  main;
+
+    sendfile        on;
+    keepalive_timeout  65;
+
+    # Gzip compression
+    gzip  on;
+    gzip_types text/plain text/css application/json application/javascript text/xml application/xml;
+
+    include /etc/nginx/conf.d/*.conf;
+}