Rethinking the Database

ACID • Functional • Scalable • Programmable

https://www.datomic.com/

Transcript

1. Rethinking the Database ACID • Functional • Scalable • Programmable
2. SQL Database Challenges
3. Constrained Reads
4. Constrained Writes
5. Rigid Ops Storage Query I/O Tx Indexing
6. Rigid Model “Person can belong to multiple clubs” join table person table club table FK constraints foreign keys ids
7. Update In-Place x → y
8. Complexity
9. Complexity • Types • Inherent: inherent to the problem • Incidental: accidental, arising from naive or suboptimal implementation, often self-inflicted
10. Complexity • Major source of incidental complexity is conflating or combining orthogonal/independent concerns • Complect*: interleave, entwine, braid • Decomplect: To make simple by separating orthogonal concerns *Simple Made Easy (Rich Hickey, 2011)
11. Time and State
12. Time and State • Axioms • Time flows linearly in one direction • The world exists as a series of discrete, ordered states • The past is immutable • You cannot know the state of another process/ system instantaneously
13. Time and State • Consequences • There is no such thing as sharing current data, only the possibility of sharing consistent data • Current only exists on a single machine, on a single core, within a single thread • Or, you stop the world to emulate this
14. Time and State • Corollary: There is no such thing as stale data if it is part of a historical state (e.g., versioned/timestamped). • If consistency is a requirement for some datasource, then you need: • A single Source of Truth • Linearized writes
15. Databases are complex
16. Databases are complected
17. Transience Sharing Difficult Distribution Difficult Concurrency Difficult Access Pattern Eager Caching Difficult x → y
18. Old Assumptions • Memory is expensive • Storage is expensive • Machines are precious • Resources are dedicated
19. Datomic
20. Datomic • Functional • Local, lazy reads • Serialized ACID • Time-aware, accumulates changes • Elastic read scaling • Flexible, universal attribute schema • Programmable
21. [x, y] “then…”
22. Transience Persistence Sharing Difficult Trivial Distribution Difficult Trivial Concurrency Difficult Trivial Access Pattern Eager Eager or Lazy Caching Difficult Trivial
23. A Quick Tour
24. but first! Clojure syntax in a few slides
25. Scalar Types symbol blah keyword :thing string "hello, architects!" integer 12345 float 3.141 exponent notation 2e5 regular expression #"^hello,\s\w+" booleans true false undefined nil
26. Collections list '(1 2 3 "badger") vector [1 2 3 "squirrel!"] map {:name "Bob" :age 34} set #{"cat" "dog" "snake"}
27. Expressions (filter odd? (map inc [7 8 9 10 11 12])) => [9 11 13] (->> [7 8 9 10 11 12] (map inc) (filter odd?))
28. Special Forms (def symbol init?) define symbol (if test then else?) conditional, yields `then` or `else` (do exprs*) evaluate expressions, return last (let [bindings* ] exprs*) lexical context (quote form) yields an unevaluated form (unquote form) unquotes a quoted form (var symbol) the var object named by a symbol (fn name? ([params*] cond-map? exprs*)+) defines a function (loop [bindings* ] exprs*) like let, but provides a recursion target (recur exprs*) evaluates expressions and rebinds at recur point (throw expr) evaluates expr and throws result (try expr* catch-clause* finally-clause?) try/catch/finally semantics . new set! java[script] interop
29. (defn make-adder [inc-by] (fn [n] (+ inc-by n))) (def add3 (make-adder 3)) (add3 9) => 4
30. TL;DR Instead of this: foo(1, 2, bar(3, 4)); This: (foo 1 2 (bar 3 4))
31. Functional, Lazy, "Peers" (require '[datomic.api :as d]) ;; Connect to a remote database (def conn (d/connect "datomic:ddb://us-east-1/my-db")) ;; Fetch the current database value (def db (d/db conn)) ;; Evaluate a query (d/q <some query> db) ;; Join across multiple databases (d/q <some query> db1, db2) ;; Retrieve an entity (d/entity db <identifier>)
32. Functional, Lazy "Peers" ;; Connect to a remote database (def conn (d/connect "datomic:ddb://us-east-1/my-db")) mem sql dev cassandra Supports multiple storage backends
33. Functional, Lazy "Peers" ;; Fetch the current database value (def db (d/db conn)) Immutable, lazy database value at time t
34. Local Query ;; Evaluate a query (d/q <some query> db) Queries a database value, not a transient connection
35. Local Query ;; Join across multiple databases (d/q <some query> db1, db2) Query multiple, potentially disparate data sources
36. Entity API ;; Direct entity access (d/entity db <identifier>) Entity id or lookup ref Returns a lazy map of an entity's attributes
37. Serialized ACID Transactions ;; Direct entity access (def result (d/transact conn <some tx data>) Simple native data
38. Serialized ACID Transactions ;; Direct entity access (def result (d/transact conn <some tx data>) Enqueues transaction on transactor
39. Serialized ACID Transactions ;; Direct entity access (def result (d/transact conn <some tx data>) (keys @result) ! (:db-before :db-after :tx-data :tempids) Returns the database values before and after the transaction
40. Time-aware ;; View the db, as of a week ago (def db-before (d/as-of db <1 week ago>)) ;; Or, pretend to transact new data (def db-later (d/with db <proposed tx data>)) ;; History of a db, in its entirety (d/history db) ;; Listen for new changes (d/tx-report-queue conn) ;; Or, process old ones (d/tx-range (d/log conn) <1 week ago> nil)
41. Time-aware ;; View the db, as of a week ago (def db-before (d/as-of db <1 week ago>)) The database value as of a point in time
42. Time-aware ;; Or, pretend to transact new data (def db-later (d/with db <proposed tx data>)) A speculative database value
43. Time-aware ;; History of a db, in its entirety (d/history db) A database value with all historical events
44. Time-aware ;; Listen for new changes (d/tx-report-queue conn) Listen for changes made by other peers
45. Time-aware ;; Or, process old ones (d/tx-range (d/log conn) <1 week ago> nil) Look at a range of transactions from the transaction log
46. DB Server Query Trans- actions Indexing I/O Storage Cache App Process App Results Strings DDL + DML Traditional (SQL) Database • Query, indexing, transactions, I/O, and storage all colocated • Queries must be performed eagerly, for consistency • e.g., MVCC is transient historical state isolation only during query • Updates performed in-place • Complects reads and writes
47. Transactor Indexing Trans- actions Transactor Indexing Trans- actions Data Segments Peer App Process Peer Lib Query Cache App Live Index Comm Storage service (DynamoDB) Segment storage Standby Peer App Process Peer Lib Query Cache App Live Index Comm Peer App Process Peer Lib Query Cache App Live Index Comm elasticache cluster (optional) Data Segments Datomic Operational Model • Read/Query scales with the number of peers • Every peer sees completed transactions as of a particular point in time • Peers always see all transactions up to their time basis, in order, with no gaps • Peers can, optionally, coordinate on a time basis
48. Programmable ;; A simple function to perform a query (defn customers-who-bought [db product-id] (d/q '[:find ?customer :in $ ?id :where [?customer :customer/orders ?order] [?order :order/items ?item] [?item :product/id ?id]] db product-id))
49. Programmable ;; A simple function to perform a query (defn customers-who-bought [db product-id] (d/q '[:find ?customer :in $ ?id :where [?customer :customer/orders ?order] [?order :order/items ?item] [?item :product/id ?id]] db product-id)) Database value as an argument to the function
50. Programmable ;; A simple function to perform a query (defn customers-who-bought [db product-id] (d/q '[:find ?customer :in $ ?id :where [?customer :customer/orders ?order] [?order :order/items ?item] [?item :product/id ?id]] db product-id)) The query is data, not strings
51. Query
52. Datalog • Queries are expressed in Datalog • Equivalent to Relational Model + Recursion • No clause order dependency • Guaranteed termination • Pattern-matching style easy to learn
53. A Sample Database Entity Attribute Value Tx 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 93 :order/items 120 180 120 :product/id "PROD123" 141 120 :product/name "Generic Product" 141 120 :product/description "good for all the things" 141 ⋮ ⋮ ⋮ ⋮
54. A Sample Database Entity Attribute Value Tx Added? 72 :customer/email joe@foo.net 134 true 71 :customer/email ryan@example.com 148 true 72 :customer/email joe@foo.net 150 false 72 :customer/email joe@example.com 150 true 72 :customer/orders 93 180 true 72 :customer/orders 108 185 true 93 :order/items 120 180 true 120 :product/id "PROD123" 141 true 120 :product/name "Generic Product" 141 true 120 :product/description "good for all the things" 141 true ⋮ ⋮ ⋮ ⋮
55. A Sample Database Entity Attribute Value Tx Added? 72 :customer/email joe@foo.net 134 true 71 :customer/email ryan@example.com 148 true 72 :customer/email joe@foo.net 150 false 72 :customer/email joe@example.com 150 true 72 :customer/orders 93 180 true 72 :customer/orders 108 185 true 93 :order/items 120 180 true 120 :product/id "PROD123" 141 true 120 :product/name "Generic Product" 141 true 120 :product/description "good for all the things" 141 true ⋮ ⋮ ⋮ ⋮
56. Datoms [entity attribute value tx added?] • Entity: A unique entity id. • Attribute: Names a piece of data associated with an entity, has schema. • Value: A scalar or reference (type defined by the attribute's schema). • Tx: A transaction id. Refers to a transaction entity! • Added?: A boolean declaring whether this Datom is asserting or retracting a fact about its entity.
57. Data Patterns [:find ?customer :where [?customer :customer/orders ?order] [?order :order/items ?item] ] Data pattern [?item :product/id "PROD123"]
58. Data Patterns [?item :product/id "PROD123"] Variable Constant Constant [entity attribute value] [entity attribute value Tx Added?]
59. [?customer :customer/email ?email] “What are all customers' emails?” Data Patterns
60. Data Patterns [?customer :customer/email ?email] Entity Attribute Value Tx 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 ⋮ ⋮ ⋮ ⋮
61. “What is a specific customer's email?” Data Patterns [72 :customer/email ?email]
62. Data Patterns [72 :customer/email ?email] Entity Attribute Value Tx 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 ⋮ ⋮ ⋮ ⋮
63. “What attributes does entity 72 have?” Data Patterns [72 ?attribute]
64. Data Patterns [72 ?attribute] Entity Attribute Value Tx 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 ⋮ ⋮ ⋮ ⋮
65. “What attributes and values does customer 72 have?” Data Patterns [72 ?attribute ?value]
66. Data Patterns [72 ?attribute ?value] Entity Attribute Value Tx 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 ⋮ ⋮ ⋮ ⋮
67. Where Clause [:find ?customer ?email :where [?customer :customer/email ?email]]
68. Find Clause [:find ?customer ?email :where [?customer :customer/email ?email]]
69. Implicit Join [:find ?customer :where [?customer :customer/orders ?order] [?order :order/items ?item] [?item :product/id "PROD123"]]
70. Query API (d/q '[:find ?customer :where [?customer :customer/orders ?order] [?order :order/items ?item] [?item :product/id "PROD123"]] db)
71. Query API (d/q '[:find ?customer :where [?customer :customer/orders ?order] [?order :order/items ?item] [?item :product/id "PROD123"]] db) Query
72. Query API (d/q '[:find ?customer :where [?customer :customer/orders ?order] [?order :order/items ?item] [?item :product/id "PROD123"]] db …) Inputs
73. Parameterized Query (d/q '[:find ?customer :in $db ?product-id :where [?db ?customer :customer/orders ?order] [?db ?order :order/items ?item] [?db ?item :product/id ?product-id]] db, "PROD123")
74. Parameterized Query (d/q '[:find ?customer :in $ ?product-id :where [?customer :customer/orders ?order] [?order :order/items ?item] [?item :product/id ?product-id]] db, "PROD123") Implicit DB in clauses
75. Predicates [(> ?price 100.00)] Functional constraints that appear within a :where clause
76. Predicates (d/q '[:find ?product :where [?product :product/price ?price] [(> ?price 100.00)]] db) "Find all products that cost more than $100.00"
77. Functions [(shipping ?zipcode ?weight) ?cost] Take bound variables as input, bind variable with output.
78. Functions (defn shipping “Estimate the cost to ship goods to a given zip code.” [zipcode weight] (* (cost-per-lb-by-zip zipcode) weight)) Just a function
79. Functions (d/q '[:find ?customer ?product :where [?customer :customer/address ?addr] [?addr :address/zipcode ?zip] [?product :product/weight ?weight] [?product :product/price ?price] [(shipping ?zip ?weight) ?ship-cost] [(<= ?price ?ship-cost)]] db) “Find customer/product combos where shipping cost dominates the product price”
80. Functions (d/q '[:find ?customer ?product :where [?customer :customer/address ?addr] [?addr :address/zipcode ?zip] [?product :product/weight ?weight] [?product :product/price ?price] [(shipping ?zip ?weight) ?ship-cost] [(<= ?price ?ship-cost)]] db) Navigate from customer to zip code
81. Functions (d/q '[:find ?customer ?product :where [?customer :customer/address ?addr] [?addr :address/zipcode ?zip] [?product :product/weight ?weight] [?product :product/price ?price] [(shipping ?zip ?weight) ?ship-cost] [(<= ?price ?ship-cost)]] db) Retrieve product weights and prices
82. Functions (d/q '[:find ?customer ?product :where [?customer :customer/address ?addr] [?addr :address/zipcode ?zip] [?product :product/weight ?weight] [?product :product/price ?price] [(shipping ?zip ?weight) ?ship-cost] [(<= ?price ?ship-cost)]] db) Retrieve estimated shipping cost
83. Functions (d/q '[:find ?customer ?product :where [?customer :customer/address ?addr] [?addr :address/zipcode ?zip] [?product :product/weight ?weight] [?product :product/price ?price] [(shipping ?zip ?weight) ?ship-cost] [(<= ?price ?ship-cost)]] db) Constrain by price <= shipping cost
84. Entity API 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 93 :order/items 120 180 120 :product/id "PROD123" 141 120 :product/name "Generic Product" 141 120 :product/description "good for all the things" 141 ⋮ ⋮ ⋮ ⋮ (d/entity db <identifier>)
85. Entity API ⋮ ⋮ ⋮ ⋮ 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 ⋮ ⋮ ⋮ ⋮ (def result (d/entity db 72)) ! {:db/id 72 :customer/email "joe@example.com" :customer/orders [{:db/id 93} {:db/id 108}]} Lazy, immutable, map-like view of entity’s attributes & values
86. Entity API ⋮ ⋮ ⋮ ⋮ 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 ⋮ ⋮ ⋮ ⋮ (def result (d/entity db 72)) ! {:db/id 72 :customer/email "joe@example.com" :customer/orders [{:db/id 93} {:db/id 108}]} Lazy values as of db's time t
87. Entity API (-> result :customer/orders first :order/items) 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 93 :order/items 120 180 120 :product/id "PROD123" 141 120 :product/name "Generic Product" 141 120 :product/description "good for all the things" 141 ⋮ ⋮ ⋮ ⋮
88. Entity API (-> result :customer/orders first :order/items) 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 93 :order/items 120 180 120 :product/id "PROD123" 141 120 :product/name "Generic Product" 141 120 :product/description "good for all the things" 141 ⋮ ⋮ ⋮ ⋮
89. Entity API (-> result :customer/orders first :order/items) 71 :customer/email ryan@example.com 148 72 :customer/email joe@example.com 150 72 :customer/orders 93 180 72 :customer/orders 108 185 93 :order/items 120 180 120 :product/id "PROD123" 141 120 :product/name "Generic Product" 141 120 :product/description "good for all the things" 141 ⋮ ⋮ ⋮ ⋮
90. Entity API (-> result :customer/orders first :order/items) ! [{:db/id 120 :product/id "PROD123" :product/name "Generic Product" :product/description "good for all the things"}] ⋮ ⋮ ⋮ ⋮ 120 :product/id "PROD123" 141 120 :product/name "Generic Product" 141 120 :product/description "good for all the things" 141 ⋮ ⋮ ⋮ ⋮
91. Entity API (def product (d/entity db 120)) (-> product :order/_items) Navigate a relationship backwards “Find all orders that included product”
92. Pull API (d/pull db <pull-pattern> <entity-identifier>) declarative way to make hierarchical selections of information about entities
93. Pull API (d/pull db [:customer/email {:customer/orders [{:order/items [:product/name :product/description]}]}] 72) ! {:customer/email "joe@example.com" :customer/orders [{:order/items [{:product/name "Generic Product" :product/description "good for all the things"]} {:order/items [{:product/name "Another Product" :product/description "does some things"]}]}
94. Transactions
95. Transactions = Lists of Datoms [[:db/add John :user/friends Stu] [:db/retract John :user/friends Ryan]]
96. Transaction Datom Structure [op entity attr val]
97. Transaction Datom Structure [op entity attr val] :db/add :db/retract
98. Built-in Transaction Functions [:db.fn/retractEntity entity-id] [:db.fn/cas entity-id old-val new-val]
99. Built-in Transaction Functions [:db.fn/retractEntity john] expands to [[:db/retract john :user/friends bob] [:db/retract john :user/friends stu] [:db/retract john :user/email "john@example.com"] …]
100. Atomic Increment [:db/add ryan :account/balance <old> + 10] ?
101. Custom Transaction Functions [op ...] Provide a custom function
102. Custom Transaction Functions [:inc ryan :account/balance 10]
103. Custom Transaction Functions • Run inside transaction • Can access current DB-value • Expand into 1+ assertions/retractions
104. Custom Transaction Functions (defn inc [db e attr val] (let [entity (d/entity db e) prev (get entity attr)] [[:db/add e attr (+ prev val)]])) Just a function of the current db value and some args
105. Custom Transaction Functions (defn inc [db e attr val] (let [entity (d/entity db e) prev (get entity attr)] [[:db/add e attr (+ prev val)]])) Just a function of the current db value and some args
106. Custom Transaction Functions (defn inc [db e attr val] (let [entity (d/entity db e) prev (get entity attr)] [[:db/add e attr (+ prev val)]])) Just a function of the current db value and some args
107. Custom Transaction Functions (defn inc [db e attr val] (let [entity (d/entity db e) prev (get entity attr)] [[:db/add e attr (+ prev val)]])) Just a function of the current db value and some args
108. Custom Transaction Functions (defn inc [db e attr val] (let [entity (d/entity db e) prev (get entity attr)] [[:db/add e attr (+ prev val)]])) Just a function of the current db value and some args
109. Custom Transaction Functions [:inc ryan :account/balance 10] [:db/add ryan :account/balance 110]
110. Transaction data (let [joe "joe-tempid"] [[:db/add joe :user/name “Joe Smith”] [:db/add joe :user/email “joe@example.com”] [:db/add joe :user/website “solussd.io”]])
111. Short-form transaction [{:db/id "joe-tempid" :user/name “Joe Smith” :user/email “joe@example.com” :user/website “solussd.io”}] Expands to list of datoms
112. Reified Transactions Transactions are, themselves, reified as entities in the database {:db/txInstant #inst"2018-02-19T23:09:57.488-00:00"}
113. Reified Transactions Add annotations to transactions! [[:db/add "datomic.tx" :data/source "wikipedia"] <other tx data>] {:db/txInstant #inst"2018-02-19T23:09:57.488-00:00" :data/source "wikipedia"}
114. Schema
115. “Person can belong to multiple clubs” join table person table club table FK constraints foreign keys ids [?person :club ?club]
116. Modeling a Social Media Site • Users • Stories • Comments
117. Modeling News Stories Attribute Type Cardinality Component? Unique? :story/title string 1 :story/url string 1 :story/slug string 1 :news/comment ref many ✓ Schema defines type and other schema attributes at the attribute level
118. Modeling News Stories Attribute Type Cardinality Component? Unique? :story/title string 1 :story/url string 1 :story/slug string 1 :news/comment ref many ✓ {:db/ident :story/title :db/valueType :db.type/string :db/cardinality :db.cardinality/one …} Just short-form transaction data!
119. Modeling News Stories Attribute Type Cardinality Component? Unique? :story/title string 1 :story/url string 1 :story/slug string 1 :news/comment ref many ✓ {:db/ident :news/comment :db/valueType :db.type/ref :db/cardinality :db.cardinality/many :db/isComponent true …} The referenced entity is a component-of its parent
120. Schema is just data “What are all the attributes in the database?” [?e :db/valueType]
121. Modeling Users Attribute Type Cardinality Component? Unique? :user/fullName string 1 :user/email string 1 Identity :user/votes ref Many A user's email is unique and serves as an identity for the entity
122. Modeling Users Attribute Type Cardinality Component? Unique? :user/fullName string 1 :user/email string 1 Identity :user/votes ref Many {:db/ident :user/email :db/valueType :db.type/string :db/cardinality :db.cardinality/one :db/unique :db.unique/identity …} Could also be db.unique/value
123. Unique Identity Lookup entities by unique identifier (d/entity db [:user/email "joe@example.com"]) Lookup-ref
124. Modeling Comments Attribute Type Cardinality Component? Unique? :comment/body string 1 :comment/author ref 1 :news/comment ref Many ✓ "ref" type does not dictate attributes
125. Modeling Comments Attribute Type Cardinality Component? Unique? :comment/body string 1 :comment/author ref 1 :news/comment ref Many ✓ How do you ask for all of a user’s comments?
126. Relationships are Bi-directional ;; Get a comment’s author (:comment/author some-comment-entity) ;; Get an author’s comments (:comment/_author some-author-entity) Navigate a relationship backwards
127. Indexes Structure Name Included? Row EAVT All Datoms Column AEVT All Datoms Lookup AVET “Indexed” attributes Graph VAET :db.type/ref attributes
128. Modeling Comments Attribute Type Cardinality Component? Unique? :comment/body string 1 :comment/author ref 1 :news/comment ref Many ✓ How do you find all comments for a story?
129. Recursive Queries [(story-comment ?story ?comment) [?story :story/title] [?story :news/comment ?comment]] Base case: A story has a comment
130. Recursive Queries [(story-comment ?story ?comment) [?parent :news/comment ?comment] (story-comment ?story ?parent)] Recursive case: Comment is a child of a story-comment
131. Recursive Queries (def rules '[[(story-comment ?story ?comment) [?story :story/title] [?story :news/comment ?comment]] [(story-comment ?story ?comment) [?parent :news/comment ?comment] (story-comment ?story ?parent)]] (d/q '[:find ?comment :in $ % ?story :where [(story-comment ?story ?comment)]] db, rules story-id)
132. Topologies
133. Transactor Indexing Trans- actions Transactor Indexing Trans- actions Data Segments Peer App Process Peer Lib Query Cache App Live Index Comm Storage service (DynamoDB) Segment storage Standby Peer App Process Peer Lib Query Cache App Live Index Comm Peer App Process Peer Lib Query Cache App Live Index Comm elasticache cluster (optional) Data Segments Peers • Local query • High performance • Use arbitrary functions in query • "Heavy" peers • Peers are part of the database • Peers must run on the JVM
134. Transactor Indexing Trans- actions Transactor Indexing Trans- actions Data Segments Peer App Process Peer Lib Query Cache App Live Index Comm Storage service (DynamoDB) Segment storage Standby Peer App Process Peer Lib Query Cache App Live Index Comm Peer App Process Peer Lib Query Cache App Live Index Comm elasticache cluster (optional) Data Segments
135. Client/Peer Server • Clients, (not peers) • Peer server and clients scale separately • Good fit for lightweight / ephemeral clients • "Warm" caches on peer server(s) • Option for generic web-servers and specialized peer servers (e.g., products vs analytics) to increase cache hits • Scale up/down web-servers w/o sacrificing cache hits • Clients can be written in/for any language/ runtime
137. Datomic Cloud
138. Production CF Stack Storage CF Stack Many-DB Storage System DynamoDB EFS S3 client (outside VPC) Amazon VPC creds Bastion SSH Route 53 Transaction Log Indexes Cache Client (in VPC) CloudFormation Stack Tx Group Cluster Node Cluster Node Cluster Node SSD Cache ALB CloudFormation Stack Cluster Node Cluster Node Cluster Node Analytics Query CF Cluster Node Cluster Node Cluster Node Dev Query CF txes A Cloud Native Database • Distributed, Highly Available, Horizontally scalable • Managed: provisioning, scaling, and multi-region replication • DB performance tuning, resource provisioning, etc. are abstracted away • Less operational complexity (learn one DB, not two) • Cloud-managed auth • Encryption in flight and at rest
139. Production CF Stack Storage CF Stack Many-DB Storage System DynamoDB EFS S3 client (outside VPC) Amazon VPC creds Bastion SSH Route 53 Transaction Log Indexes Cache Client (in VPC) CloudFormation Stack Tx Group Cluster Node Cluster Node Cluster Node SSD Cache ALB CloudFormation Stack Cluster Node Cluster Node Cluster Node Analytics Query CF Cluster Node Cluster Node Cluster Node Dev Query CF txes
140. Questions? Based on Datomic for the 96% by Stuart Halloway and Datomic for the 96% Redux by Ryan Neufeld @solussd – contact@solussd.io