Расскажи про свой стек технологий

Мой стек технологий

Как опытный Python Developer с 10+ годами опыта, я работал с многообразием технологий. Вот мой текущий и исторический стек:

Backend/API

Python 3.9+

Вся работа идёт на современных версиях Python с type hints и async/await.

from typing import Optional, List
from dataclasses import dataclass
from datetime import datetime

@dataclass
class User:
    id: int
    name: str
    email: Optional[str] = None
    created_at: datetime = datetime.now()

FastAPI — для REST API

Максимально использую для production систем. Причины:

• Автоматическое свагирование
• Встроенная валидация через Pydantic
• Асинхронность из коробки
• Отличная документация

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post("/items")
async def create_item(item: Item):
    return {"name": item.name, "price": item.price}

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

Django — для более сложных систем

Использую, когда нужна ORM с автоматическими миграциями и admin интерфейс. Последний опыт — Django 4.2.

from django.db import models
from django.contrib import admin

class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

admin.site.register(Post)

SQLAlchemy — для ORM

Особенно люблю его гибкость и поддержку raw SQL когда нужно:

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import Session
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String, unique=True)

engine = create_engine("postgresql://user:password@localhost/db")
Base.metadata.create_all(engine)

Базы данных

PostgreSQL — основная БД

Это мой выбор номер один для production. Использую:

• JSON/JSONB для гибких схем
• Full-text search
• Window functions
• Partitioning для больших таблиц

-- Пример: полнотекстовый поиск
SELECT id, title, 
       ts_rank(tsv, query) as rank
FROM articles,
     plainto_tsquery('russian', 'python') query
WHERE tsv @@ query
ORDER BY rank DESC;

Redis — для кеширования и очередей

Использую для:

• Session storage
• Rate limiting
• Cache слой
• Message queue

import redis
from functools import wraps

redis_client = redis.Redis(host='localhost', port=6379)

def cached(ttl=3600):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            key = f"{func.__name__}:{args}:{kwargs}"
            result = redis_client.get(key)
            if result:
                return json.loads(result)
            result = func(*args, **kwargs)
            redis_client.setex(key, ttl, json.dumps(result))
            return result
        return wrapper
    return decorator

MongoDB — для нестандартизированных данных

Использовал в проектах, где структура данных динамична.

Очереди задач

Celery — распределённые задачи

Для асинхронных операций: отправка писем, обработка медиа, тяжёлые вычисления.

from celery import Celery
import smtplib

app = Celery('tasks', broker='redis://localhost:6379')

@app.task(bind=True, max_retries=3)
def send_email_task(self, email, subject, body):
    try:
        # Отправка письма
        pass
    except Exception as exc:
        raise self.retry(exc=exc, countdown=60)

# Использование
send_email_task.delay('user@example.com', 'Subject', 'Body')

RabbitMQ — message broker

Вспомогательный инструмент для критичных систем, где нужна высокая надёжность.

Асинхронность и Concurrency

asyncio — встроенная асинхронность

Для I/O-bound операций всегда выбираю async:

import asyncio
import aiohttp

async def fetch_urls(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(url) for url in urls]
        responses = await asyncio.gather(*tasks)
        return [await r.text() for r in responses]

asyncio.run(fetch_urls(['http://example.com'] * 10))

Multiprocessing — для CPU-bound операций

Когда нужна истинная параллелизм:

from multiprocessing import Pool

def cpu_bound_task(n):
    return sum(i**2 for i in range(n))

with Pool(4) as p:
    results = p.map(cpu_bound_task, [10**7] * 4)

Testing

pytest — основной тестовый фреймворк

import pytest
from unittest.mock import Mock, patch

def test_user_creation():
    user = User(name="Alice", email="alice@example.com")
    assert user.name == "Alice"

@pytest.mark.asyncio
async def test_async_function():
    result = await async_function()
    assert result is not None

@patch('module.external_api')
def test_with_mock(mock_api):
    mock_api.return_value = {"status": "ok"}
    assert call_function() == {"status": "ok"}

pytest-cov — для coverage отчётов

Цель: минимум 80-90% покрытие критичного кода.

Логирование и мониторинг

Structlog или logging с JSON output

import logging
import json

logger = logging.getLogger(__name__)

logger.info("User login", extra={
    "user_id": 123,
    "ip": "192.168.1.1",
    "timestamp": datetime.now().isoformat()
})

Sentry — обработка ошибок в production

import sentry_sdk

sentry_sdk.init(
    dsn="https://key@sentry.io/project",
    environment="production",
    traces_sample_rate=0.1
)

Prometheus + Grafana — метрики и визуализация

Для мониторинга производительности и SLA.

DevOps и Deploy

Docker — контейнеризация

FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0"]

Docker Compose — для локальной разработки

Kubernetes — для production (опыт с Helm charts)

GitHub Actions — CI/CD

name: Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.11'
      - name: Install dependencies
        run: pip install -r requirements.txt
      - name: Run tests
        run: pytest --cov

Frontend (когда нужно)

React / Vue.js — для web интерфейсов

Tailwind CSS — для стилизации

TypeScript — обязательно для больших проектов

interface User {
  id: number;
  name: string;
  email: string;
}

const getUser = async (id: number): Promise<User> => {
  const response = await fetch(`/api/users/${id}`);
  return response.json();
};

Инструменты и практики

Git — контроль версий

Ruff / Black — форматирование кода

MyPy — статическая типизация

Pre-commit — хуки перед коммитом

Make — automation скриптов

Почему именно эти технологии?

1. Python — мощный, читаемый, экосистема для всего
2. FastAPI — скорость разработки + production-ready
3. PostgreSQL — надежная, мощная, масштабируемая
4. Redis — простой и быстрый для кеша
5. Docker — reproducible environments
6. pytest — простой и мощный тестовый фреймворк

Что я постоянно учу

• Новые версии Python (3.12+)
• Pydantic v2
• Rust для performance-critical частей
• GraphQL как альтернативу REST
• Machine Learning инструменты (когда релевантно)

Мой стек выбран на основе опыта, production-ready требований и лучших практик индустрии. Я не привязан к конкретной технологии и готов учить новые инструменты, если они лучше решают проблему.