Что такое BASE в БД?

BASE в БД: противопоставление ACID

Что такое BASE

BASE — это аббревиатура для более слабого набора гарантий консистентности данных, в отличие от ACID. Она означает:

• B — Basically Available (Базово доступная)
• A — Soft state (Мягкое состояние)
• E — Eventual consistency (Итоговая консистентность)

ESPERто, противоположная ACID, которую гарантируют традиционные SQL базы данных.

ACID vs BASE

┌─────────────────────────────────────────────────────┐
│ ACID (SQL базы: PostgreSQL, MySQL, Oracle)          │
├─────────────────────────────────────────────────────┤
│ Atomicity    — Либо всё, либо ничего                │
│ Consistency  — Данные ВСЕГДА консистентны           │
│ Isolation    — Транзакции не мешают друг другу      │
│ Durability   — Данные не теряются                    │
└─────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐
│ BASE (NoSQL базы: MongoDB, Cassandra, DynamoDB)     │
├─────────────────────────────────────────────────────┤
│ Basically Available   — System работает ВСЕГДА      │
│ Soft State           — Данные могут быть несогласованными │
│ Eventual Consistency — Консистентность со временем  │
└─────────────────────────────────────────────────────┘

1. Basically Available

Система должна быть доступна, даже при сбое:

// ACID подход:
const transfer = async (fromId: string, toId: string, amount: number) => {
  // Если система не может гарантировать консистентность,
  // она может вернуть ошибку и отказать в операции
  try {
    await db.transaction(async (trx) => {
      await trx('accounts').update({ balance: db.raw('balance - ?', [amount]) })
        .where('id', fromId);
      await trx('accounts').update({ balance: db.raw('balance + ?', [amount]) })
        .where('id', toId);
    });
  } catch (e) {
    // ACID: если сбой — откатываем обе операции
    throw e;
  }
};

// BASE подход:
const transferBase = async (fromId: string, toId: string, amount: number) => {
  // Даже если система в стрессе, мы обрабатываем запрос
  // Консистентность придёт позже
  await events.publish({
    type: 'TRANSFER_INITIATED',
    fromId,
    toId,
    amount,
    timestamp: Date.now()
  });
  
  // Возвращаем успех клиенту сразу
  return { status: 'accepted', transferId: uuid() };
};

Результат:

• ACID: если одна нода упала, система может быть недоступна
• BASE: если одна нода упала, другие работают, консистентность потом

2. Soft State (Мягкое состояние)

Данные могут быть временно несогласованными:

// Пример: изменение профиля пользователя

// ACID подход (SQL):
const updateProfile = async (userId: string, newData: any) => {
  // Либо все данные обновлены, либо ничего
  await db('users').update(newData).where('id', userId);
  
  // После этой строки ВСЕ читающие запросы видят новые данные
  const user = await db('users').where('id', userId).first();
  return user; // 100% новые данные
};

// BASE подход (DynamoDB, MongoDB с eventual consistency):
const updateProfileBase = async (userId: string, newData: any) => {
  // Записываем в мастер
  await dynamodb.update({
    TableName: 'users',
    Key: { id: userId },
    AttributeUpdates: newData
  });
  
  // Возвращаем успех, но данные не везде ещё обновлены
  return { status: 'accepted' };
  
  // background: асинхронно реплицируем на read replicas
  // На replicas данные может быть 100ms - 1 сек запаздывают
};

Проблема:

const scenario = async () => {
  // Пользователь обновил имя в профиле
  await updateProfileBase(userId, { name: 'Jane' });
  
  // Микросекунду спустя читает свой профиль (случайно попал на другую реплику)
  const profile = await db.read('users').where('id', userId).first();
  
  console.log(profile.name); // Может быть 'John' (старое значение!)
  // Это нормально для BASE систем
};

3. Eventual Consistency

Консистентность придёт со временем, но КОГДА?

// Пример: like на посте в социальной сети

// Архитектура:
const likePost = async (userId: string, postId: string) => {
  // Шаг 1: записываем в быстрый write-optimized store
  await fast_write_store.insert('likes', {
    userId,
    postId,
    timestamp: Date.now()
  });
  
  // Клиент видит like сразу! +1
  return { status: 'liked' };
};

// Background job (eventual consistency процесс):
const reconcileLikes = async () => {
  // Каждые 5 секунд перемешиваем likes в основную БД
  const recentLikes = await fast_write_store.getAll('likes', {
    where: { processed: false }
  });
  
  // Обновляем счётчик likes в main database
  for (const like of recentLikes) {
    await mainDb('posts')
      .update({ likes_count: db.raw('likes_count + 1') })
      .where('id', like.postId);
    
    await fast_write_store.update('likes', { processed: true })
      .where('id', like.id);
  }
};

// Результат:
// - Клиент видит +1 сразу (fast)
// - Likes_count в DB обновляется через 5-10 секунд (eventual)
// - Но в итоге ВСЁ консистентно

Где используется BASE

1. NoSQL базы (MongoDB, Cassandra, DynamoDB)

// MongoDB с eventual consistency:
db.collection('users').updateOne(
  { _id: userId },
  { $set: { lastSeenAt: Date.now() } },
  { writeConcern: 1 } // Не ждём репликации, возвращаем сразу
);

// Реальность: данные пишутся на primary,
// реплицируются на secondary через 100-500ms

2. Event sourcing + CQRS

// Event store (append-only, всё быстро)
const events = [
  { type: 'UserCreated', userId: '1', name: 'John' },
  { type: 'UserUpdated', userId: '1', name: 'Jane' },
  { type: 'UserDeleted', userId: '1' }
];

// Projection (read model) обновляется асинхронно
const projections = {
  // В начале проекция может быть inconsistent
  // Но событиями она обновляется в real-time
};

3. Distributed систем (микросервисы)

// Service A: обновляет inventory
await inventoryService.updateStock(productId, -1);

// Service B: сразу видит обновление? НЕТ!
// А только СОБЫТИЕМ что inventory изменился
const event = await eventBus.publish('InventoryUpdated', {
  productId,
  newStock: 99
});

// Service B получит событие асинхронно (seconds later)
await shoppingCartService.onInventoryUpdated(event);

ACID vs BASE: Когда что использовать

╔════════════════════════════════════════════════════╗
║ Используй ACID (SQL базы) когда:                   ║
╠════════════════════════════════════════════════════╣
║ • Финтех (деньги), банки — консистентность КРИТИЧНА║
║ • Медицинские системы — точность данных            ║
║ • Accounting, billing — не терпит ошибок            ║
║ • Когда consistency > availability                 ║
║                                                    ║
║ Примеры: PostgreSQL, MySQL, Oracle                 ║
╚════════════════════════════════════════════════════╝

╔════════════════════════════════════════════════════╗
║ Используй BASE (NoSQL) когда:                      ║
╠════════════════════════════════════════════════════╣
║ • High-scale системы (миллионы записей)            ║
║ • Социальные сети (likes, comments)                ║
║ • Analytics и логирование                          ║
║ • Когда availability > consistency                 ║
║ • Временные несогласованности допустимы            ║
║                                                    ║
║ Примеры: MongoDB, Cassandra, DynamoDB              ║
╚════════════════════════════════════════════════════╝

Реальный пример: Бюджет 50$ на AWS

// ACID (SQL на AWS RDS):
// - Многие читающие запросы → нужны replicas
// - Replicas дорогие ($50/месяц за read replica)
// - Scaling вертикальный (bigger machines)

// BASE (DynamoDB на AWS):
// - Платишь за прочитанные/написанные операции
// - Масштабируется автоматически
// - На $50 можешь обработать миллионы операций

Мой опыт использования BASE

// В production использую BASE для:
1. Activity feeds (like, follow, comment)
   - Eventual consistency: OK
   - High-scale: нужна

2. Analytics
   - Потеря 1-2% данных: OK
   - Real-time ненужен

3. Cache invalidation
   - Мягкое состояние: нормально
   - Быстрота: критична

// Использую ACID для:
1. Payment processing
   - Every cent must match
   - Eventual consistency: NO!

2. User profiles
   - Чувствительные данные
   - Должны быть точными

Главный вывод

BASE — это не плохо, это просто другой trade-off:

• Sacrifice: immediate consistency
• Gain: availability, scalability, speed

Для большинства операций в modern системах это справедливый обмен. Но для финансовых данных ACID незаменим.