NoSQL devops #fail?

Soluções para produção

John D. Rowell

Show of hands

  • ACID?

Show of hands

  • Atomicity Consistency Isolation Durability

Show of hands

  • Atomicity Consistency Isolation Durability
  • Sharding? Consistent Hashing?

Show of hands

  • Atomicity Consistency Isolation Durability
  • Sharding? Consistent Hashing?
  • CAP?

Show of hands

  • Atomicity Consistency Isolation Durability
  • Sharding? Consistent Hashing?
  • Consistency Availability Partition-tolerance

Show of hands

  • Atomicity Consistency Isolation Durability
  • Sharding? Consistent Hashing?
  • Consistency Availability Partition-tolerance
  • Já usa NoSQL?

Objetivos

  • Apresentar alguns dbs NoSQL promissores

Objetivos

  • Apresentar alguns dbs NoSQL promissores
  • Identificar seus use cases
    • Volume de dados (RAM, disco, rede?)
    • Duração da consulta
    • Queries dinâmicos / opacidade

Objetivos

  • Apresentar alguns dbs NoSQL promissores
  • Identificar seus use cases
    • Volume de dados (RAM, disco, rede?)
    • Duração da consulta
    • Queries dinâmicos / opacidade
  • Status para desenvolvimento

Objetivos

  • Apresentar alguns dbs NoSQL promissores
  • Identificar seus use cases
    • Volume de dados (RAM, disco, rede?)
    • Duração da consulta
    • Queries dinâmicos / opacidade
  • Status para desenvolvimento
  • Status para produção

Salvatore Sanfilippo

VMware

Redis (C, BSD, 2009)

  • Chave/Valor + estruturas de dados em RAM

Redis (C, BSD, 2009)

  • Chave/Valor + estruturas de dados em RAM
  • BS Strings, lists, sets, sorted sets, hashes

Redis (C, BSD, 2009)

  • Chave/Valor + estruturas de dados em RAM
  • BS Strings, lists, sets, sorted sets, hashes
  • União, interseção, diferença, ordem

Redis (C, BSD, 2009)

  • Chave/Valor + estruturas de dados em RAM
  • BS Strings, lists, sets, sorted sets, hashes
  • União, interseção, diferença, ordem
  • Concorrência: single thread / async

Redis (C, BSD, 2009)

  • Chave/Valor + estruturas de dados em RAM
  • BS Strings, lists, sets, sorted sets, hashes
  • União, interseção, diferença, ordem
  • Concorrência: single thread / async
  • Replicação: master/slave/slave

Redis (C, BSD, 2009)

  • Chave/Valor + estruturas de dados em RAM
  • BS Strings, lists, sets, sorted sets, hashes
  • União, interseção, diferença, ordem
  • Concorrência: single thread / async
  • Replicação: master/slave/slave
  • Durabilidade: snapshot ou journal (AOF)

Redis (C, BSD, 2009)

  • Chave/Valor + estruturas de dados em RAM
  • BS Strings, lists, sets, sorted sets, hashes
  • União, interseção, diferença, ordem
  • Concorrência: single thread / async
  • Replicação: master/slave/slave
  • Durabilidade: snapshot ou journal (AOF)
  • Alta performance local: 100,000+ RW/s

Redis use cases

  • Session store (EXPIRE)

Redis use cases

  • Session store (EXPIRE)
  • Cache (memcached persistente)

Redis use cases

  • Session store (EXPIRE)
  • Cache (memcached persistente)
  • Message queue (lists/BLPOP) e.g. restmq

Redis use cases

  • Session store (EXPIRE)
  • Cache (memcached persistente)
  • Message queue (lists/BLPOP) e.g. restmq
  • Real-time analytics

Redis use cases

  • Session store (EXPIRE)
  • Cache (memcached persistente)
  • Message queue (lists/BLPOP) e.g. restmq
  • Real-time analytics
  • Capped logs

Redis use cases

  • Session store (EXPIRE)
  • Cache (memcached persistente)
  • Message queue (lists/BLPOP) e.g. restmq
  • Real-time analytics
  • Capped logs
  • Votação e agregação (polls)

Redis use cases

  • Session store (EXPIRE)
  • Cache (memcached persistente)
  • Message queue (lists/BLPOP) e.g. restmq
  • Real-time analytics
  • Capped logs
  • Votação e agregação (polls)
  • Chat / Suporte online

Redis para desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C, Lua, Haskell, Perl, PHP, outras

Redis para desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação

Redis para desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação
  • Transactions: MULTI/EXEC + status

Redis para desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação
  • Transactions: MULTI/EXEC + status
  • Denormalização, estrutura, performance

Redis para desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação
  • Transactions: MULTI/EXEC + status
  • Denormalização, estrutura, performance
  • Comunidade ativa (388 repos no Github)

Redis para desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação
  • Transactions: MULTI/EXEC + status
  • Denormalização, estrutura, performance
  • Comunidade ativa (388 repos no Github)
  • Protocolo simples -> bons drivers

Redis em produção

  • OLTP no master, DW nos slaves

Redis em produção

  • OLTP no master, DW nos slaves
  • Valores grandes em DS ou VM (threaded)

Redis em produção

  • OLTP no master, DW nos slaves
  • Valores grandes em DS ou VM (threaded)
  • 32 e 64bits (32bits economiza RAM)

Redis em produção

  • OLTP no master, DW nos slaves
  • Valores grandes em DS ou VM (threaded)
  • 32 e 64bits (32bits economiza RAM)
  • Performance: master não grava, slave fsync

Redis em produção

  • OLTP no master, DW nos slaves
  • Valores grandes em DS ou VM (threaded)
  • 32 e 64bits (32bits economiza RAM)
  • Performance: master não grava, slave fsync
  • Replicação slave/slave -> WAN

Redis em produção

  • OLTP no master, DW nos slaves
  • Valores grandes em DS ou VM (threaded)
  • 32 e 64bits (32bits economiza RAM)
  • Performance: master não grava, slave fsync
  • Replicação slave/slave -> WAN
  • Backup automático (FS slave), restore trivial

Redis em produção

  • OLTP no master, DW nos slaves
  • Valores grandes em DS ou VM (threaded)
  • 32 e 64bits (32bits economiza RAM)
  • Performance: master não grava, slave fsync
  • Replicação slave/slave -> WAN
  • Backup automático (FS slave), restore trivial
  • Failover manual, master down -> downtime

mongoDB (C++, AGPL, 2009)

  • Documentos JSON/BSON (<4MB)

mongoDB (C++, AGPL, 2009)

  • Documentos JSON/BSON (<4MB)
  • Queries dinâmicas, índices

mongoDB (C++, AGPL, 2009)

  • Documentos JSON/BSON (<4MB)
  • Queries dinâmicas, índices
  • BLOBs: GridFS

mongoDB (C++, AGPL, 2009)

  • Documentos JSON/BSON (<4MB)
  • Queries dinâmicas, índices
  • BLOBs: GridFS
  • Concorrência: mthread, R/W locks, JS lock

mongoDB (C++, AGPL, 2009)

  • Documentos JSON/BSON (<4MB)
  • Queries dinâmicas, índices
  • BLOBs: GridFS
  • Concorrência: mthread, R/W locks, JS lock
  • Multicore: satura reads, block c/ writes

mongoDB (C++, AGPL, 2009)

  • Documentos JSON/BSON (<4MB)
  • Queries dinâmicas, índices
  • BLOBs: GridFS
  • Concorrência: mthread, R/W locks, JS lock
  • Multicore: satura reads, block c/ writes
  • Replicação: master/slave(s), replica sets

mongoDB (C++, AGPL, 2009)

  • Documentos JSON/BSON (<4MB)
  • Queries dinâmicas, índices
  • BLOBs: GridFS
  • Concorrência: mthread, R/W locks, JS lock
  • Multicore: satura reads, block c/ writes
  • Replicação: master/slave(s), replica sets
  • Durabilidade: nenhuma (in-place writes)

mongoDB use cases

  • Novo "M" em LAMP

mongoDB use cases

  • Novo "M" em LAMP
  • Web: performance via zero-join + cache

mongoDB use cases

  • Novo "M" em LAMP
  • Web: performance via zero-join + cache
  • Schema free: CRM, shopping cart

mongoDB use cases

  • Novo "M" em LAMP
  • Web: performance via zero-join + cache
  • Schema free: CRM, shopping cart
  • Online gaming: game data + user profiles

mongoDB use cases

  • Novo "M" em LAMP
  • Web: performance via zero-join + cache
  • Schema free: CRM, shopping cart
  • Online gaming: game data + user profiles
  • GED: document store (BLOBs + metadata)

mongoDB use cases

  • Novo "M" em LAMP
  • Web: performance via zero-join + cache
  • Schema free: CRM, shopping cart
  • Online gaming: game data + user profiles
  • GED: document store (BLOBs + metadata)
  • Catálogos: livros, filmes, músicas

mongoDB use cases

  • Novo "M" em LAMP
  • Web: performance via zero-join + cache
  • Schema free: CRM, shopping cart
  • Online gaming: game data + user profiles
  • GED: document store (BLOBs + metadata)
  • Catálogos: livros, filmes, músicas
  • Capped logs (nativo)

mongoDB desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C++, C, Lua, Haskell, Perl, PHP, outras

mongoDB desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C++, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação

mongoDB desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C++, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação
  • Transactions: UPSERTs atômicos

mongoDB desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C++, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação
  • Transactions: UPSERTs atômicos
  • Stored procedures: Javascript no server

mongoDB desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C++, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação
  • Transactions: UPSERTs atômicos
  • Stored procedures: Javascript no server
  • Comunidade ativa (684 repos no Github)

mongoDB desenvolvimento

  • Linguagens: Ruby+EM, Python+Twisted, Javascript+node, Erlang, Clojure, Scala, Java, C++, C, Lua, Haskell, Perl, PHP, outras
  • Configuração fácil, inclusive replicação
  • Transactions: UPSERTs atômicos
  • Stored procedures: Javascript no server
  • Comunidade ativa (684 repos no Github)
  • API interna merece refactoring

mongoDB em produção

  • Writes só no master, auto-discovery

mongoDB em produção

  • Writes só no master, auto-discovery
  • GridFS é replicado, módulo Nginx

mongoDB em produção

  • Writes só no master, auto-discovery
  • GridFS é replicado, módulo Nginx
  • Somente 64bits (32bits <4GB) EC2 $$

mongoDB em produção

  • Writes só no master, auto-discovery
  • GridFS é replicado, módulo Nginx
  • Somente 64bits (32bits <4GB) EC2 $$
  • Sharding: heterogêneo, config complexa

mongoDB em produção

  • Writes só no master, auto-discovery
  • GridFS é replicado, módulo Nginx
  • Somente 64bits (32bits <4GB) EC2 $$
  • Sharding: heterogêneo, config complexa
  • Backup: mongodump e mongorestore

mongoDB em produção

  • Writes só no master, auto-discovery
  • GridFS é replicado, módulo Nginx
  • Somente 64bits (32bits <4GB) EC2 $$
  • Sharding: heterogêneo, config complexa
  • Backup: mongodump e mongorestore
  • Failover automático em replica sets :)

mongoDB em produção

  • Writes só no master, auto-discovery
  • GridFS é replicado, módulo Nginx
  • Somente 64bits (32bits <4GB) EC2 $$
  • Sharding: heterogêneo, config complexa
  • Backup: mongodump e mongorestore
  • Failover automático em replica sets :)
  • RS: sem auth, administração insuficiente

Riak (Erlang+C, Apache, 2009)

  • Ex-Akamai: Open Source + Enterprise

Riak (Erlang+C, Apache, 2009)

  • Ex-Akamai: Open Source + Enterprise
  • Use extenso de metadata. Links!

Riak (Erlang+C, Apache, 2009)

  • Ex-Akamai: Open Source + Enterprise
  • Use extenso de metadata. Links!
  • BLOBs: nativos (<100MB)

Riak (Erlang+C, Apache, 2009)

  • Ex-Akamai: Open Source + Enterprise
  • Use extenso de metadata. Links!
  • BLOBs: nativos (<100MB)
  • Replicação: cluster homogêneo, Dynamo

Riak (Erlang+C, Apache, 2009)

  • Ex-Akamai: Open Source + Enterprise
  • Use extenso de metadata. Links!
  • BLOBs: nativos (<100MB)
  • Replicação: cluster homogêneo, Dynamo
  • Durabilidade: por backend (0 a 10)

Riak (Erlang+C, Apache, 2009)

  • Ex-Akamai: Open Source + Enterprise
  • Use extenso de metadata. Links!
  • BLOBs: nativos (<100MB)
  • Replicação: cluster homogêneo, Dynamo
  • Durabilidade: por backend (0 a 10)
  • Shared nothing, escalabilidade horizontal

Riak latência e paralelismo

  • L1: 3 cycles
  • L2: 14 cycles
  • RAM: 250 cycles
  • DISK: 41,000,000 cycles
  • NETWORK: 240,000,000 cycles

Riak latência e paralelismo

  • L1: 3 cycles
  • L2: 14 cycles
  • RAM: 250 cycles
  • DISK: 41,000,000 cycles
  • NETWORK: 240,000,000 cycles
  • Riak: <1000 req/s, mas...

Riak latência e paralelismo

  • L1: 3 cycles
  • L2: 14 cycles
  • RAM: 250 cycles
  • DISK: 41,000,000 cycles
  • NETWORK: 240,000,000 cycles
  • Riak: <1000 req/s, mas...
  • Paralelismo: R/W em qualquer node!

Riak dados distribuídos

  • Controle de versão: Vector clocks

Riak dados distribuídos

  • Controle de versão: Vector clocks
  • Resolução de conflitos no aplicativo

Riak dados distribuídos

  • Controle de versão: Vector clocks
  • Resolução de conflitos no aplicativo
  • Escalando dados: re-balance automático

Riak dados distribuídos

  • Controle de versão: Vector clocks
  • Resolução de conflitos no aplicativo
  • Escalando dados: re-balance automático
  • Disponibilidade: hinted handoff

Riak dados distribuídos

  • Controle de versão: Vector clocks
  • Resolução de conflitos no aplicativo
  • Escalando dados: re-balance automático
  • Disponibilidade: hinted handoff
  • Consistência: eventual, mas =~ ms

Riak dados distribuídos

  • Controle de versão: Vector clocks
  • Resolução de conflitos no aplicativo
  • Escalando dados: re-balance automático
  • Disponibilidade: hinted handoff
  • Consistência: eventual, mas =~ ms
  • Durabilidade: tunable DW por bucket

Riak dados distribuídos

  • Controle de versão: Vector clocks
  • Resolução de conflitos no aplicativo
  • Escalando dados: re-balance automático
  • Disponibilidade: hinted handoff
  • Consistência: eventual, mas =~ ms
  • Durabilidade: tunable DW por bucket
  • Performance menos previsível

Riak use cases

  • S3-like: armazena e serve direto por HTTP

Riak use cases

  • S3-like: armazena e serve direto por HTTP
  • DW: grandes volumes, proc. offline

Riak use cases

  • S3-like: armazena e serve direto por HTTP
  • DW: grandes volumes, proc. offline
  • FTS: Riak Search, Lucene (beta fechado)

Riak use cases

  • S3-like: armazena e serve direto por HTTP
  • DW: grandes volumes, proc. offline
  • FTS: Riak Search, Lucene (beta fechado)
  • CDN: Replicação WAN (Enterprise)

Riak use cases

  • S3-like: armazena e serve direto por HTTP
  • DW: grandes volumes, proc. offline
  • FTS: Riak Search, Lucene (beta fechado)
  • CDN: Replicação WAN (Enterprise)
  • GED: document store (BLOBs + metadata)

Riak use cases

  • S3-like: armazena e serve direto por HTTP
  • DW: grandes volumes, proc. offline
  • FTS: Riak Search, Lucene (beta fechado)
  • CDN: Replicação WAN (Enterprise)
  • GED: document store (BLOBs + metadata)
  • Catálogos: livros, filmes, músicas

Riak em desenvolvimento

  • Linguagens: Ruby, Python, Javascript+node, Erlang, Java, PHP

Riak em desenvolvimento

  • Linguagens: Ruby, Python, Javascript+node, Erlang, Java, PHP
  • Protocolo HTTP/REST ou Protobuffs

Riak em desenvolvimento

  • Linguagens: Ruby, Python, Javascript+node, Erlang, Java, PHP
  • Protocolo HTTP/REST ou Protobuffs
  • Configuração média, exige estudo

Riak em desenvolvimento

  • Linguagens: Ruby, Python, Javascript+node, Erlang, Java, PHP
  • Protocolo HTTP/REST ou Protobuffs
  • Configuração média, exige estudo
  • Transactions: não

Riak em desenvolvimento

  • Linguagens: Ruby, Python, Javascript+node, Erlang, Java, PHP
  • Protocolo HTTP/REST ou Protobuffs
  • Configuração média, exige estudo
  • Transactions: não
  • Comunidade pequena (67 repos no Github)

Riak em desenvolvimento

  • Linguagens: Ruby, Python, Javascript+node, Erlang, Java, PHP
  • Protocolo HTTP/REST ou Protobuffs
  • Configuração média, exige estudo
  • Transactions: não
  • Comunidade pequena (67 repos no Github)
  • Buckets são só namespaces (gotcha!)

Riak em desenvolvimento

  • Linguagens: Ruby, Python, Javascript+node, Erlang, Java, PHP
  • Protocolo HTTP/REST ou Protobuffs
  • Configuração média, exige estudo
  • Transactions: não
  • Comunidade pequena (67 repos no Github)
  • Buckets são só namespaces (gotcha!)
  • Dados opacos, Map/Reduce e link walking

Riak em produção

  • Auto-healing, escala para cima e para baixo

Riak em produção

  • Auto-healing, escala para cima e para baixo
  • Bitcask (default) mantém chaves em RAM

Riak em produção

  • Auto-healing, escala para cima e para baixo
  • Bitcask (default) mantém chaves em RAM
  • 32 e 64bits

Riak em produção

  • Auto-healing, escala para cima e para baixo
  • Bitcask (default) mantém chaves em RAM
  • 32 e 64bits
  • Backup e restore: riak-admin

Riak em produção

  • Auto-healing, escala para cima e para baixo
  • Bitcask (default) mantém chaves em RAM
  • 32 e 64bits
  • Backup e restore: riak-admin
  • Join e leave: riak-admin

Riak em produção

  • Auto-healing, escala para cima e para baixo
  • Bitcask (default) mantém chaves em RAM
  • 32 e 64bits
  • Backup e restore: riak-admin
  • Join e leave: riak-admin
  • Pode ficar atrás de um load balancer

Riak em produção

  • Auto-healing, escala para cima e para baixo
  • Bitcask (default) mantém chaves em RAM
  • 32 e 64bits
  • Backup e restore: riak-admin
  • Join e leave: riak-admin
  • Pode ficar atrás de um load balancer
  • Distro binária com Erlang embutido

Mike Stonebraker
of PostgreSQL fame
VoltDB, LLC

VoltDB (Java/C++, GPL, 2010)

  • Somente OLTP, export para DW embutido

VoltDB (Java/C++, GPL, 2010)

  • Somente OLTP, export para DW embutido
  • Sintaxe SQL, stored procedures em Java

VoltDB (Java/C++, GPL, 2010)

  • Somente OLTP, export para DW embutido
  • Sintaxe SQL, stored procedures em Java
  • Eficiência: só 5% de overhead (!90%)

VoltDB (Java/C++, GPL, 2010)

  • Somente OLTP, export para DW embutido
  • Sintaxe SQL, stored procedures em Java
  • Eficiência: só 5% de overhead (!90%)
  • Concorrência: serial, sync, sem locks

VoltDB (Java/C++, GPL, 2010)

  • Somente OLTP, export para DW embutido
  • Sintaxe SQL, stored procedures em Java
  • Eficiência: só 5% de overhead (!90%)
  • Concorrência: serial, sync, sem locks
  • Durabilidade: RAM, escrita async em disco

VoltDB (Java/C++, GPL, 2010)

  • Somente OLTP, export para DW embutido
  • Sintaxe SQL, stored procedures em Java
  • Eficiência: só 5% de overhead (!90%)
  • Concorrência: serial, sync, sem locks
  • Durabilidade: RAM, escrita async em disco
  • Relacional: Schema* e topologia fixos

VoltDB (Java/C++, GPL, 2010)

  • Somente OLTP, export para DW embutido
  • Sintaxe SQL, stored procedures em Java
  • Eficiência: só 5% de overhead (!90%)
  • Concorrência: serial, sync, sem locks
  • Durabilidade: RAM, escrita async em disco
  • Relacional: Schema* e topologia fixos
  • Particionamento e sharding automáticos

VoltDB use cases

  • Transactions: banking, reservas, estoque

VoltDB use cases

  • Transactions: banking, reservas, estoque
  • Bolsa de valores: volume + transações

VoltDB use cases

  • Transactions: banking, reservas, estoque
  • Bolsa de valores: volume + transações
  • Real-time analytics: coletar + agregar

VoltDB use cases

  • Transactions: banking, reservas, estoque
  • Bolsa de valores: volume + transações
  • Real-time analytics: coletar + agregar
  • Online gaming: manter e distribuir estado

VoltDB use cases

  • Transactions: banking, reservas, estoque
  • Bolsa de valores: volume + transações
  • Real-time analytics: coletar + agregar
  • Online gaming: manter e distribuir estado
  • Telecom: conectar e tarifar ligações

VoltDB use cases

  • Transactions: banking, reservas, estoque
  • Bolsa de valores: volume + transações
  • Real-time analytics: coletar + agregar
  • Online gaming: manter e distribuir estado
  • Telecom: conectar e tarifar ligações
  • Social: distribuir feeds (e.g. Twitter)

VoltDB em desenvolvimento

  • Linguagens: Java, C++, Ruby, Erlang, Clojure, PHP

VoltDB em desenvolvimento

  • Linguagens: Java, C++, Ruby, Erlang, Clojure, PHP
  • Interface HTTP/JSON: qualquer linguagem

VoltDB em desenvolvimento

  • Linguagens: Java, C++, Ruby, Erlang, Clojure, PHP
  • Interface HTTP/JSON: qualquer linguagem
  • Configuração avançada, ciclos dump/reload

VoltDB em desenvolvimento

  • Linguagens: Java, C++, Ruby, Erlang, Clojure, PHP
  • Interface HTTP/JSON: qualquer linguagem
  • Configuração avançada, ciclos dump/reload
  • Transactions: ACID dentro de uma partição

VoltDB em desenvolvimento

  • Linguagens: Java, C++, Ruby, Erlang, Clojure, PHP
  • Interface HTTP/JSON: qualquer linguagem
  • Configuração avançada, ciclos dump/reload
  • Transactions: ACID dentro de uma partição
  • Comunidade inexistente (2 repos no Github)

VoltDB em desenvolvimento

  • Linguagens: Java, C++, Ruby, Erlang, Clojure, PHP
  • Interface HTTP/JSON: qualquer linguagem
  • Configuração avançada, ciclos dump/reload
  • Transactions: ACID dentro de uma partição
  • Comunidade inexistente (2 repos no Github)
  • Limitações, grandes mudanças entre versões
    (gotcha! gotcha!)

VoltDB em produção

  • RAM mínima recomendada: 4GB/node ($$)

VoltDB em produção

  • RAM mínima recomendada: 4GB/node ($$)
  • Sincronismo de clocks: NTP (mesmo server!)

VoltDB em produção

  • RAM mínima recomendada: 4GB/node ($$)
  • Sincronismo de clocks: NTP (mesmo server!)
  • Apenas 64bits, virtualização problemática

VoltDB em produção

  • RAM mínima recomendada: 4GB/node ($$)
  • Sincronismo de clocks: NTP (mesmo server!)
  • Apenas 64bits, virtualização problemática
  • Não suporta WAN (latência)

VoltDB em produção

  • RAM mínima recomendada: 4GB/node ($$)
  • Sincronismo de clocks: NTP (mesmo server!)
  • Apenas 64bits, virtualização problemática
  • Não suporta WAN (latência)
  • 1 partição por core, serializada

VoltDB em produção

  • RAM mínima recomendada: 4GB/node ($$)
  • Sincronismo de clocks: NTP (mesmo server!)
  • Apenas 64bits, virtualização problemática
  • Não suporta WAN (latência)
  • 1 partição por core, serializada
  • Replicar tabelas read-only em todos os nodes

VoltDB em produção

  • RAM mínima recomendada: 4GB/node ($$)
  • Sincronismo de clocks: NTP (mesmo server!)
  • Apenas 64bits, virtualização problemática
  • Não suporta WAN (latência)
  • 1 partição por core, serializada
  • Replicar tabelas read-only em todos os nodes
  • +Node: save/restore snapshot -> downtime

Perguntas?

John D. Rowell

github.com/jdrowell
me@jdrowell.com