forked from ravendb/book
-
Notifications
You must be signed in to change notification settings - Fork 0
/
todo.txt
224 lines (155 loc) · 12.6 KB
/
todo.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
### Performance tracking
## Closing thoughts
TODO:
```
openssl s_client and in general, pointing out that it can be used to debug SSL issues
Upgrading applications in production
- multi versioning
- patching data
- changing indexes
Required permissions
- Files
- Note running as a service vs. running as admin
Delayed external replication - how to switch over to the delay copy
Deploying with RavenHQ
```
Things to cover
Chapter 6:
//TODO: image of a database graph
//TODO: Figure of 5 nodes cluster and 2 db nodes up, 1 rehab, 1 promotable.
TODO:
- Waiting for replication or indexing
Talk about unique constraints
### Part I - The basics of RavenDB
Focus: Developers
This is the part you will want new hires to read before starting to work with an application using RavenDB, it
contains a practical discussion on how to build an application using RavenDB. We'll skip theory, concepts and
background information in favor of getting things done, those will be discussed in the next part.
*[Chapter 2](#zero-to-ravendb) - Zero to RavenDB -* focuses on setting you up with a RavenDB instance.
The client API and its basic usage is also cover, as well as document identifier generation and test RavenDB
based application. The studio and some key concepts are introduced.
*[Chapter 3](#modeling) - Modeling documents -* Goes in depth into how to structure your entities and documents, the impact
of various RavenDB features on the structure of your documents and how you should handle common modeling scenarios.
*[Chapter 4](#client-api) - Deep dive into the RavenDB Client API -* explores more advanced client scenarios, such as lazy
requests, patching, concurrency, listeners, bulk inserts, streaming queries and using persistent subscriptions.
### Part II - Ravens everywhere
Focus: Architects
This part focuses on the theory of building robust and high performance systems using RavenDB. We'll go directly
to working with a cluster of RavenDB nodes on commodity hardware, discuss data and work distribution across
the cluster and how to best structure your systems to take advantage of what RavenDB brings to the table.
*[Chapter 5](#clustering-setup) -* Clustering Setup - walks through the steps of setting up a cluster of RavenDB
nodes and working with a clustered database. High availability and load balancing features in RavenDB will also
be discussed.
*[Chapter 6](#clustering-deep-dive) -* Clustering Deep Dive - takes you through the RavenDB clustering behavior,
how it works and how the both servers & clients are working together to give you a seamless distributed
experience. We'll also discuss error handling and recovery in a clustered environment.
*[Chapter 7](#integrations) -* Integrating with the Outside World - explores using RavenDB alongside additional
systems, for integrating with legacy systems, working with dedicated reporting databases, ETL process, long
running background tasks and in general how to make RavenDB fit better inside your environment.
*[Chapter 8](#clustering-scenarios) -* Clusters Topologies - guides you through setting up several different
clustering topologies and their pros and cons. This is intended to serve as a set of blueprints for architects to
start from when they begin building a system.
### Part III - Indexing
Focus: Developers, Architects
This part discusses how data is indexed by RavenDB, allowing quick retrieval of information, whether it is a single
document or aggregated data spanning years. We'll cover all the different indexing methods in RavenDB and how
each of them can be used to implement the features you want in your systems.
*[Chapter 9](#map-indexes) - Simple Indexes -* introduces indexes and their usage in RavenDB. Even though we
have performed queries and worked with the data, we haven't actually dealt with indexes directly so far. Now is
the time to lift the curtain and see how RavenDB is searching for information and what it means for your
applications.
*[Chapter 11](#full-text-search) -* Full Text Search - takes a step beyond just querying the raw data and shows
how you can search your entities using powerful full text queries. We'll talk about the full text search
options RavenDB provides, using analyzers to customize this for different usages and languages.
*[Chapter 13](#multi-map-N-load-doc) -* Complex indexes - goes beyond simple indexes and shows how to
query over multiple collections at the same time. We will also see how we can piece together data
from related documents at indexing time and have RavenDB keep the index consistent for us.
*[Chapter 13](#map-reduce) -* Map/Reduce - gets into data aggregation and how using Map/Reduce indexes allows
you to get instant results over very large data sets with very little cost, this making reporting style
queries cheap and accessible at any scale. Beyond simple aggregation, Map/Reduce in RavenDB also allows you to
reshape the data coming from multiple source into a single whole, regardless of complexity.
*[Chapter 14](#facets) -* Facet and Dynamic Aggregation - steps beyond static aggregation provided by Map/Reduce,
giving you the ability to run dynamic aggregation queries on your data, or just facet your search results making
it easier for the user to find what they are looking for.
*[Chapter 15](#recursive-map-reduce) -* Artificial Documents and Recursive Map/Reduce - guides you through using
indexes to _generate_ documents, instead of the other way around, and then use that for both normal operations and
supporing recursive Map/Reduce, subscriptions over aggregated data and even more complex reporting scenarios.
*[Chapter 16](#query-optimizier) -* The Query Optimizer - takes you into the RavenDB query optimizer, index
management and how RavenDB is treating indexes from the inside out. We'll see the kind of machinery that is
running behind the scenes to get everything going so that when you a query is made, the results are there at once.
*[Chapter 17](#ravendb-lucene-usage) -* RavenDB Lucene Usage - goes into (quite gory) details about how RavenDB
is making use of Lucene to implement its indexes. This is intended mostly for people who need to know what exactly
is going on and how does everything fit together. This is how the sausage is made.
*[Chapter 18](#advanced-indexes) -* Advanced Indexing Techniques - dig into some specific usages of indexes that
are a bit... outside the norm.
Using spatial queries to find geographical information, generating dynamic suggestions on the fly, returning
highlighted results for full text search queries, transforming query results on the server and more.
All the things that you would use once in a blue moon, but when you need them you _really_ need them.
### Part IV - Operations
Focus: Operations
This part deals with running and supporting a RavenDB cluster or clusters in production. From how you spin a new
cluster to decommissioning a downed node to tracking down performance problems. We'll learn all that you need (and
then a bit more) to understand what is going on with RavenDB and how to customize its behavior to fit your own
environment.
*[Chapter 19](#prod-deploy) - Deploying to Production -* guides you through several production deployment
options, including all the gory details about how to spin up a cluster and keep it healthy and happy. We'll
discuss deploying to anything from a container swarm to bare metal, the networking requirements and configuration
you need, security implications and anything else that the operation teams will need to comfortably support a
RavenDB cluster in that hard land called production.
*[Chapter 20](#security) - Security -* focuses solely on security. How you can control who can access which
database, running an encrypted database for highly sensitive information and securing a RavenDB instance that is
exposed to the wild world.
*[Chapter 21](#high-availablity) - High Availability -* brings failure to the table, repeatedly. We'll discuss
how RavenDB handles failures in production, how to understand, predict and support RavenDB in keeping all of your
databases accessible and _fast_ in production, even in the face of various errors and disasters.
*[Chapter 22](#disaster-recovery) - Recovering from Disasters -* covers what happens after disaster strikes.
When machines melt down and go poof, or someone issues the wrong command and the data just goes into the
incinerator. Yep, this is where we talk about backups and restore and all the various reasons why operations
consider them sacred.
*[Chapter 23](#monitoring) - Monitoring -* covers how to monitor and support a RavenDB cluster in
production. We'll see how RavenDB externalizes its own internal state and behavior for the admins to look at and
how to make sense out of all of this information.
*[Chapter 24](#performance-tracking) - Tracking Performance -* gets into why a particular query or a node isn't
performing up to spec. We'll discuss how one would track down such an issue and find the root cause responsible for
such a behavior, a few common reasons why such things happen and how to avoid or resolve them.
*[Chapter 26](#stroage-layout) - Storage Considerations -* discusses how RavenDB is storing the data on disk, how
it allocates storage and arrange the data internally. We'll talk about how it impacts operational decisions and
persistence decisions.
### Part V - Implementation Details
Focus: RavenDB Core Team, RavenDB Support Engineers, Developers who wants to read the code
This part is the orientation guide that we throw at new hires when we sit them in front of the code. It is full of
implementation details and background information that you probably don't need if all you want to know is how to
build an awesome system on top of RavenDB.
On the other hand, if you want to go through the code and understand why RavenDB is doing something in a particular
way, this part will likely answer all those questions.
*[Chapter 27](#blittable) - The Blittable Format -* gets into the details of how RavenDB represents JSON
documents internally, how we handle this particular format and how to work with it.
*[Chapter 28](#voron) - The Voron Storage Engine -* breaks down the low-level storage engine we use to put
bits on the disk. We'll walk through how it works, the various features it offers and most importantly, why it
had ended up in this way. A lot of the discussion is going to be driven by performance consideration, extremely
low-level and full of operating system and hardware minutiae.
*[Chapter 29](#tx-merger) - The Transaction Merger -* built on top of Voron, the transaction merger comprises
one of the major ways in which RavenDB is able to provide high performance. We'll discuss how it came about, how
it is actually used and what it means in terms of the actual code using it.
*[Chapter 30](#rachis) - The Rachis Consensus -* talks about how RavenDB is using the Raft consensus protocol
to connect together different nodes in the cluster, how they interact with one another and the internal
details of how it all comes together (falls apart and recovers again).
*[Chapter 31](#cluster-state-machine) - Cluster State Machine -* brings the discussion one step higher by talking
about how RavenDB uses the result of the distributed consensus to actually manage all the nodes in the cluster
and how we can reliably arrive to the same decision on each node independently.
*[Chapter 32](#landlord) - Lording over Databases -* peeks inside a single node and explores how a database
is managed inside that node. More importantly, how we are dealing with multiple databases on the same node and
what kind of impact each database can have on its neighbors.
*[Chapter 31](#replication) - Replication -* dives into the details of how RavenDB manages multi master
distributed database. We'll go over change vectors which ensure conflict detection (and aid in its resolution)
and how the data is actually being replicated between the different nodes in a database group.
*[Chapter 33](#architecture) - Internal Architecture -* gives you the overall view of the internal architecture
of RavenDB. How it is built from the inside, and the reasoning why the pieces came together in the way they did.
We'll cover both high-level architecture concepts and micro architecture of the common building blocks in the
project.
### Part VI - Parting
This part summarizes the entire book and provide some insight about what our future vision for RavenDB is.
*[Chapter 34](#vnext) - What comes next -* discusses our (very rough) plans for the next major version and
the basic roadmap for RavenDB.
*[Chapter 35](#summary) - Are we there yet? Yes! -* summarize the book and let you go and actually
start _using_ all of this awesome information.