Ai Analytics in Production PDF
Ai Analytics in Production PDF
Production
How to Make It Work
The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. AI and Analytics
in Production, the cover image, and related trade dress are trademarks of O’Reilly
Media, Inc.
The views expressed in this work are those of the authors, and do not represent the
publisher’s views. While the publisher and the authors have used good faith efforts
to ensure that the information and instructions contained in this work are accurate,
the publisher and the authors disclaim all responsibility for errors or omissions,
including without limitation responsibility for damages resulting from the use of or
reliance on this work. Use of the information and instructions contained in this
work is at your own risk. If any code samples or other technology this work contains
or describes is subject to open source licenses or the intellectual property rights of
others, it is your responsibility to ensure that your use thereof complies with such
licenses and/or rights.
This work is part of a collaboration between O’Reilly and MapR. See our statement of
editorial independence.
Unless otherwise noted, images copyright Ted Dunning and Ellen Friedman.
978-1-492-04408-6
[LSI]
Table of Contents
Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v
1. Is It Production-Ready?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
What Does Production Really Mean? 4
Why Multitenancy Matters 16
Simplicity Is Golden 18
Flexibility: Are You Ready to Adapt? 19
Formula for Success 20
iii
Geo-Distribution and a Global Data Fabric 68
Implications for Streaming 70
How This Works: Core MapR Technology 72
Beyond Files: Tables, Streams, Audits, and Object Tiering 74
5. Design Patterns. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Internet of Things Data Web 79
Data Warehouse Optimization 83
Extending to a Data Hub 86
Stream-Based Global Log Processing 89
Edge Computing 93
Customer 360 94
Recommendation Engine 98
Marketing Optimization 100
Object Store 102
Stream of Events as a System of Record 103
Table Transformation and Percolation 111
A. Appendix. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
iv | Table of Contents
Preface
v
design, planning, and execution of large data systems for production
(Chapter 2). You will learn how to reduce risk while maintaining
innovative approaches and flexibility. We offer a pragmatic
approach, taking into account that winning systems must be cost
effective and make sense as sustainable, practical, and profitable
business solutions.
From there, the book digs into specific examples, based on real-
world experience with customers who are successfully using big data
in production. Chapter 3 focuses on the special case of machine
learning and AI in production, given that this topic is gaining in
widespread popularity. Chapter 4 describes an example technology
of a data platform with the necessary technical capabilities to sup‐
port emerging trends for large-scale data in production.
With this foundational knowledge in hand, you’ll be set in the last
part of the book to explore in Chapter 5 a range of design patterns
that are working well for the customers in production we see across
various sectors. You can customize these patterns to fit your own
needs as you build and adapt production systems. Chapter 6 offers a
variety of specific tips for best practice and how to avoid “gotchas”
as you move to production.
We hope you find this content makes production easier and more
effective in your own business setting.
—Ted Dunning and Ellen Friedman
September 2018
vi | Preface
CHAPTER 1
Is It Production-Ready?
Big data has grown up. Many people are already harvesting huge
value from large-scale data via data-intensive applications in pro‐
duction. If you’re not yet doing that or not doing it successfully,
you’re missing out. This book aims to help you design and build
production-ready systems that deliver value from large-scale data.
We offer practical advice on how to do this based on what we’ve
observed across a wide range of industries.
The first thing to keep in mind is that finding value isn’t just about
collecting and storing a lot of data, although that is an essential part
of it. Value comes from acting on that data, through data-intensive
applications that connect to real business goals. And this means that
you need to identify practical actions that can be taken in response
to the insights revealed by these data-driven applications. A report
by itself is not an action; instead, you need a way to connect the
results to value-based business goals, whether internal or customer
facing. For this to work in production, the entire pipeline—from
data ingestion, through processing and analytic applications to
action—must be doable in a predictable, dependable, and cost-
effective way.
1
Big data isn’t just big. It’s much more than just an
increase in data volume. When used to full advantage,
big data offers qualitative changes as well as quantita‐
tive. In aggregate, data often has more value than just
the sum of the parts. You often can ask—and, if you’re
lucky, answer—questions that could not have been
addressed previously.
2 | Chapter 1: Is It Production-Ready?
Figure 1-1. Successful production projects harvest the potential value
in large-scale data in businesses as diverse as financial services, agri-
tech, and transportation. Data-intensive applications are specific for
each industry, but there are many similarities in basic goals and chal‐
lenges for production.
Is It Production-Ready? | 3
There is no magic formula for success in production, however. Suc‐
cess requires making good choices about how to design a
production-capable architecture, how to handle data and build
effective applications, and what the right technologies and organiza‐
tional culture are to fit your particular business. There are several
themes that stand out among those organizations that are doing this
successfully: what “production” really is, why multitenancy matters,
the importance and power of simplicity and the value of flexibility.
It’s not a detailed or exhaustive list, but we think these ideas make a
big difference as you go to production, so we touch on them in this
chapter and then dig deeper throughout the rest of the book as to
how you can best address them.
Let’s begin by taking a look at what production is. We have a bit of a
different view than what is traditionally meant by production. This
new view can help you be better prepared as you tackle the challenge
of production in large-scale, modern systems.
4 | Chapter 1: Is It Production-Ready?
The key is to correctly identify what really matters, to document
(formalize) the promises you are making to address these issues, and
to have a way to monitor whether the promises are met. This some‐
what different view of production—the making and keeping of
promises for processes essential to your business—helps to ensure
that you take into account all aspects of what matters for production
to be successful across a complete pipeline rather than focusing on
just one step. This view also helps you to future-proof your systems
so that you can take advantage of new opportunities in a practical,
timely, and cost-effective way. We have more to say about that later,
but first, think about the idea that “in production” is about much
more than just the deployment of applications.
6 | Chapter 1: Is It Production-Ready?
Which email is the best performer? Look at the dashboard showing
the number of responses per hour in Figure 1-2. You can see that it
makes option C appear to be the best by far. Moreover, if all we have
is the number of responses in the most recent hour, this is the only
question we can ask and the only answer we can get. But it is really
misleading. It is only telling us which email performs best at tnow and
that’s not what we want to know.
Figure 1-2. A dashboard shows current click rates. In this graph, option
C seems to be doing better than either A or B. Such a dashboard can be
dangerously misleading because it shows no history.
There is a lot more to the story. Plotting the response rate against
time gives us a very different view, as shown in the top graph in
Figure 1-3. Now we see that each email was sent at different times,
which means that the instantaneous response rate at tnow is mostly
just a measure of which email was most recently sent. Accumulating
total responses instead of instantaneous response rate doesn’t fix
things, because that just gives a big advantage to the email that was
sent first instead of most recently.
In contrast to comparing instantaneous rates as in the upper panel
of Figure 1-3, by aligning these response curves according to their
launch times we get a much better picture of what is happening, as
shown in the lower panel. Doing this requires that we retain a his‐
tory of click rates as well as record the events corresponding to each
email’s launch.
8 | Chapter 1: Is It Production-Ready?
do the same analysis on the same summarized data as they had
always done and getting results that are no different. But the alterna‐
tive approach of recording masses of detailed events inevitably
results in a lot more data. That is, often, big data.
10 | Chapter 1: Is It Production-Ready?
Additional issues to consider in production planning are the range
of applications that you’ll want to run and how you can do this relia‐
bly and without resulting in cluster sprawl or a nightmare of admin‐
istration. We touch on these challenges in the sections on
multitenancy and simplicity in this chapter as well as with the solu‐
tions introduced in Chapter 2.
Reliability Is a Must
Reliability is important even during development stages of a project
in order to make efficient use of developer time and resources, but
obviously pressures change as work goes into production. This
change is especially true for reliability. One way to think of the dif‐
ference between a production-ready project and one that is not
ready is to compare the behavior of a professional musician to an
amateur. The amateur musician practices a song until they can play
it through without a mistake. In contrast, the professional musician
practices until they cannot play it wrong. It’s the same with data and
software. Development is the process of getting software to work.
Production is the process of setting up a system so that it (almost)
never fails.
Issues of reliability for Hadoop-based systems built on HDFS might
have left some people thinking that big data systems are not suitable
for serious production deployments, especially for mission-critical
processes, but this should not be generalized to all big data systems.
That’s a key point to keep in mind: big data does not equal Hadoop.
Reliability is not the only issue that separates these systems, but it is
an important one. Well-designed big data systems can be relied on
with extreme confidence. Here’s an example for which reliability and
extreme availability are absolutely required.
Figure 1-4. UIDAI runs the Aadhaar project whose goal is to provide a
unique 12-digit identification number plus biometric data for authen‐
tication to every one of the roughly 1.2 billion people in India. (Figure
based on image by Christian Als/Panos Pictures.)
12 | Chapter 1: Is It Production-Ready?
From a technical point of view, what are the requirements for such
an impressive big data project? For this project to be successful in
production, reliability and availability are a must. Aadhaar must
meet strict SLAs for availability of the authentication service every
day, at any time, across India. The authentication process, which
involves a profile look-up, supports thousands of concurrent trans‐
actions with end-to-end response times on the order of 100 milli‐
seconds. The authentication system was originally designed to run
on Apache Hadoop and Apache HBase, but the system was neither
fast enough nor reliable enough, even with multiple redundant data‐
centers. Late in 2014, the authentication service was moved to a
MapR platform to make use of MapR-DB, a NoSQL data base that
supports the HBase API but avoids compaction delays. Since then,
there has been no downtime, and India has reaped the benefits of
this successful big data project in production.
14 | Chapter 1: Is It Production-Ready?
sequences for lost time and lost morale when systems are down, but
these pale in comparison to the consequences for unreliability in
production because of the more immediate impact on critical busi‐
ness function. Reliability also applies to data safety, and, as we men‐
tioned earlier, data can have in-production pressures much sooner
than code does. Because the focus in production shifts to minimiz‐
ing risk, it’s often good to consider the so-called “blast radius” or
impact of a failure. The blast radius is generally much more limited
for application failures than for an underlying platform failure, so
the requirements for stability are higher for the platform.
Furthermore, the potential blast radius is larger for multitenant sys‐
tems, but this can have a paradoxical effect on overall business risk.
It might seem that the simple solution here is to avoid multitenancy
to minimize blast radius, but that’s not the best answer. If you don’t
make use of multitenancy, you are missing out on some substantial
advantages of a modern big data system. The trick is to pick a very-
high-reliability data platform to set up an overall multitenant design
but to logically isolate systems at the application level, as we explain
later in this chapter.
16 | Chapter 1: Is It Production-Ready?
makes collaboration more effective while helping to keep overall
architectures simple. A well-designed multitenant system is also bet‐
ter positioned to support development and deployment of your sec‐
ond (and third, and so on) big data project by taking advantage of
sunk costs. That is, you can do all of this if your platform makes
multitenancy safe and practical. Some large platforms don’t have
robust controls over access or might not properly isolate resource-
hungry applications from one another or from delay-sensitive appli‐
cations. The ability to control data placement is also an important
requirement of a data platform suitable for multitenancy.
Multitenancy also serves as a key strategy because many high-value
applications are also the ones that pose the highest development
risk. Taking advantage of the sunk costs of a platform intended for
current production or development by using it for speculative
projects allows high-risk/high-reward projects to proceed to a go/
no-go decision without large upfront costs. That means experimen‐
tation with new ideas is easier because projects can fail fast and
cheap. Multitenancy also allows much less data duplication, thus
driving down amortized cost, which again allows more experimen‐
tation.
Putting lots of applications onto a much smaller single cluster
instead of a number of larger clusters can pose an obvious risk, as
well. That is, outage in a cluster that supports a large number of
applications can be very serious because all of those applications are
subject to failure if the platform fails. It will also be possible (no
matter the system) for some applications to choke off access to criti‐
cal resources unless you have suitable operational controls and
platform-level controls. This means that you should not simply put
lots of applications on a single cluster without considering the
increased reliability required of a shared platform. We explain how
to deal with this risk in Chapter 2.
If you are thinking it’s too risky or too complicated to use a truly
multitenant system, look more closely at your design and the capa‐
bilities of your underlying platform and other tools: multitenancy is
practical to achieve, and it’s definitely worth it, but it won’t happen
by accident. We talk more about how to achieve it in later chapters.
18 | Chapter 1: Is It Production-Ready?
well-designed big data system does not take an army of administra‐
tors to maintain.
20 | Chapter 1: Is It Production-Ready?
CHAPTER 2
Successful Habits for Production
21
example, a 2018 Gartner report stated that only 17% of Hadoop-
based systems were deployed successfully into production, accord‐
ing to the customers surveyed (“Enabling Essential Data
Governance for Successful Big Data Architecture”). This made us
curious: Why are some people in production successfully and others
are not? In this chapter, we report the basic habits we observe in
organizations that are winning in production.
As with a piece of cloth, you can identify or isolate any single fiber
of many, and yet together they act as one thing. A data fabric works
best when it is under one system of administration and the same
security mechanisms.
Edge Computing
Increasingly, it is important to be able to handle large volumes of
Internet of Things (IoT) data from many sensors being generated at
a high rate. In some cases, this data needs to be moved to data cen‐
ters; in other cases, it’s desirable to be able to do some edge process‐
ing near the data source and then move the results or partially
processed data to other data centers. We find customers who need to
do this in industries like telecommunications, oil and gas explora‐
tion, mining, manufacturing, utilities companies, medical technol‐
ogy, transportation and shipping, online global services, and even
smart shops in physical retail locations where real-time interactive
engagement with shoppers is the goal.
Note that POSIX file access is effectively the same as allowing con‐
ventional databases because Postgres, MariaDB, mySQL, Vertica,
Sybase, Oracle, Hana, and many others all run on POSIX files.
It is also common that companies have distributed operations that
are distant from one another. Even if operations are not geo-
distributed, it is common to have a combination of on-premises
compute plus cloud compute or to require cloud vendor neutrality.
Some companies have a need for edge computing near the source of
data on a factory line, on trucks or ships, or in the field. All of these
require that the data platform grow beyond a single cluster at a sin‐
gle location to support a bona fide data fabric.
This leads to the next requirement:
• Put data where you want it but allow computation where you
need it. This includes supporting data structures that span mul‐
tiple clusters with simple consistency models.
One fact of life for modern businesses is that they need to explore
and (as soon as possible) exploit machine learning and AI to help
automate business decisions, particularly high-volume decisions
that are difficult for humans to make. Machine learning systems
require access to data from a variety of sources and have many par‐
ticularly stressful I/O patterns. Essentially all emerging machine
learning frameworks use standard file access APIs, but they often
use certain capabilities such as randomly reading data from very
large files that ordinary I/O systems find difficult to support.
What you need to handle all these situations, including edge deploy‐
ments, is to make sure your data platform is designed to handle geo-
distribution of data and computation in a cost-effective way that is
reliable and meets SLAs. That means having effective and easily
administered ways to mirror data (files, tables and streams) and
preferably to have efficient geo-distributed stream and table replica‐
tion as well. The same platform should extend across multiple cen‐
ters and be able to interact with Kubernetes across these geo-
distributed locations. It’s not just about data storage but also about
built-in capabilities to coordinate data functions and computation
across these locations securely. This use of edge computing is a basic
idea that is described in more detail as one of the design patterns
presented in Chapter 5.
The good news is that even though widespread use of Kubernetes in
on-premises data centers is a relatively new, it is spreading rapidly.
And for cloud deployments, Kubernetes already is, as of this writing,
the native language of two of the three major cloud vendors, so
using it in the cloud isn’t a problem. The issue is to plan in advance
Streaming is not the only way to build a data fabric, but stream-
based architectures are a very natural fit for a fabric, especially with
efficient stream replication, as mentioned in the previous section. In
addition, message stream transport can provide the lightweight con‐
nection needed between services of a microservices style of work
(see also “Streaming Microservices” by Dunning and Friedman in
Springer’s Encyclopedia of Big Data Technologies [2018]). The role of
the connector, in this case a message stream, is to provide isolation
DataOps
DataOps extends the flexibility of a DevOps approach by adding
data-intensive skills such as data science and data engineering—
skills that are needed not only for development but also to deploy
and maintain data-intensive applications in production. The driving
idea behind DataOps, as with DevOps, is simple but powerful: if you
assemble cross-skill teams and get them focused on a shared goal
(such as a microservice), you get much better cooperation and col‐
laboration, which in turn leads to more effective use of everyone’s
time. DataOps cuts across “skill guilds” to get people working
together in a more goal-focused and agile manner for data-intensive
projects. Figure 2-8 schematically illustrates the organization of
DataOps teams.
The key ingredients for DataOps are the right mix of skills, the con‐
cept of pulling together toward the common goal as opposed to
strict reporting based on departmental divides and much better
communication. Better communication is natural in this design
because it changes the normal lines of communication and avoids
great walls between skills that can be caused by slow-downs waiting
for interdepartmental decisions.
A DataOps style of work does not mean having to hire lots of new
people for each role. Generally, it involves rearranging assignments
to better focus people in cross-functional teams. In some cases, peo‐
ple with particular data skills (such as data scientists or machine
learning experts) might be temporarily embedded in an operations/
engineering team. The mix of roles will naturally evolve as you go
from development teams to production teams. Generally, there are
fewer data scientists in a production team than in a development or
exploration team.
45
neither a checklist of how to build an AI or machine learning system
nor a detailed lesson in data science. It is a collection of key insights
that you could put to advantage in your own situation. Hopefully
you’ll find something useful whether you’re a seasoned data scientist
or someone just starting out.
Often people think of the algorithm used for learning as the thing
that matters most for a successful machine learning system. But for
serious AI and machine learning systems in production, the logistics
of machine learning—managing data at all stages and multiple mod‐
els—has far more impact on success than does the specific choice of
learning algorithm or the model itself. Put another way, if you train
the best possible model, but you cannot handle the logistics in a reli‐
able, agile, and predictable way, you will be worse off than if you
have a mediocre model and good logistics.
90% of the effort in successful machine learning is not about the algo‐
rithm or the model or the learning. It’s about the logistics.
—From Machine Learning Logistics by Dunning and Friedman
(O’Reilly, 2017)
Our data science friends tend to keep at least four or five favorite AI
and machine learning tools in their tool kit because no single spe‐
cialty tool or algorithm is the best fit for every situation. In addition,
an organization likely will have more than one machine learning
project in play at a given time. But the need to effectively handle
logistics cuts across all these choices, and the logistical issues are
surprisingly similar. That makes the data platform itself, working in
concert with Kubernetes, the best tool for AI and machine learning
overall. That’s good news. You don’t need to handle all this at the
application level or build a separate system for each project. This, in
turn, frees up data scientists and data engineers to focus more on the
goals of the AI or machine learning itself. (For more on this topic,
see the article “TensorFlow, MXNet, Caffe, H2O: Which ML Tool is
Best?”). In addition to the platform and application orchestration
technologies, you will need an architectural design that simplifies
logistics, supports multiple models and multiple teams easily, and
gives you agility to respond quickly as the world (and data) changes,
as indeed it will.
Logistics are not the only issue that matters for success. Connecting
AI and machine learning projects to real business value is of huge
importance. And the social structure of your organization makes a
One thing that is surprisingly easy to forget when you get into the
details of making a model work is that a machine learning system
must connect to practical action that supports business goals. The
model might come up with a clever answer, but what action will you
take based on those insights? Or better, what action will be taken
automatically? Remember: a report is not an action. A machine
learning model that does not connect to practical actions for the
business is like a well-tuned motor spinning out of gear and thus
ineffective.
We close this discussion on getting value from machine learning
with an example that shows that there can be more than one level of
insight from a machine learning system. If you ask the right ques‐
tion and have access to the right data to support it, you could find
more valuable insights than you originally expect.
But how much more valuable is it to prevent the fraud from taking
place at all? Often (in a manner analogous to the preventive mainte‐
nance example), there are clues in behavior in advance of a fraud
attempt, perhaps seconds or minutes before the fraud event or dur‐
ing the transaction itself. With the right model, you might be able to
recognize a significant pattern in the window of time prior to the
fraud attempt, back when you could prevent the fraud and thus pre‐
vent any loss, as suggested by part B of Figure 3-1. To build a pre‐
vention model, you need to correlate what you knew at the moment
of prevention with the later outcome. But that is difficult, particu‐
larly because you can’t know to collect the data before you see the
fraud.
This situation happens commonly in the real world and is even
more challenging with many users and frauds at different times.
This means that the prevention windows all happen at different
times, as shown in Figure 3-2.
The approach that gives you the best option in situations such as
these is to have retained event data even in advance of detecting
fraud. You need a comprehensive system of record that stores every‐
thing you knew and could have used. With a data platform having
capabilities such as we described in Chapter 2, this is surprisingly
doable. You can use something like change data capture (CDC) to
record changes in a table or, even better, a streaming system of
record. We describe both of these design patterns in Chapter 5. But
the key lesson here is that you need to have arranged to collect data
without knowing in advance exactly when data will be required. If
you don’t do this, you must extrapolate back to each prediction
point from the current time, which inevitably results in poorer
results.
The data you retain (and have access to) changes the
questions that you can ask.
It’s not usually possible to save absolutely all raw data, but there are
technologies that make it reasonable and affordable to save large
amounts of historical data, including files or streams, and make that
data accessible to multiple users. To make it truly accessible, the data
platform should make it easy to document and locate data versions
and the organization needs to cultivate good data habits.
Remembering history
The process of building a new model is often highly iterative, which
often results in problems if the development history of a model is
not well documented. The issue is that problems in models are often
quite subtle and that can make them difficult to pin down. For
instance, there can be a bug in feature extraction code that gets
“fixed” in a way that makes the feature less useful to a model. Or
training data from a particular time period might be polluted by a
bot gaming your product. This is particularly problematic when
there are lots of design iterations. Unless you keep careful track so
that you can go back and test for bad assumptions, you can spend a
lot of time in the weeds. Is the training data collection broken? Is
feature extraction behaving wrongly? Is the training process being
stopped too soon? Or too late? Being able to exactly replicate past
work is incredibly important. It’s good practice to preserve your
code and snapshot your training data.
Rendezvous Architecture
Rendezvous architecture is a fairly new streaming microservices
architecture that takes advantage of key capabilities in a modern
data platform combined with containerization and Kubernetes to
provide a framework for deploying models. This design was intro‐
duced in 2017 and already has been implemented (and in some
cases with parts in production) by several groups we are aware of,
including teams at Lightbend, Adatis, and a large US financial com‐
pany. Rendezvous has been described in detail in our short book
Machine Learning Logistics: Model Management in the Real World,
(O’Reilly, 2017) and “Rendezvous Architecture” is an entry in The
Encyclopedia of Big Data Technologies, Sherif Sakr and Albert
Zomaya (eds.) (Springer International Publishing, 2018).
Rendezvous helps deploy models that solve synchronous decision‐
ing problems. The key characteristic is that the amount of request,
context, and state information for each request is relatively small, as
is the result. Systems of this type include credit risk analysis for
loans, flagging potential fraud in medical claims, marketing
response prediction, customer churn prediction, detection of energy
theft from smart meters, and systems to classify images through
deep learning models. Autonomous driving is a good example of a
problem that is not appropriate for rendezvous because the context
is large (the entire recent history, the physical state of the car, and
the contents of memory) and the responses are not bounded. Cer‐
Figure 3-4. You can add a decoy and a canary model to a rendezvous
architecture. The decoy archives input data for later use in training
and debugging. The canary provides a useful real-time comparison for
baseline behavior of both input data and other models.
You probably didn’t wake up this morning thinking, “I’m gonna get
me a global namespace!” But you likely do want the things it can
make possible for your production systems. What makes this and
other capabilities of a data platform interesting is knowing how they
can help in getting systems into reliable production. This isn’t always
obvious, especially as new technologies offer features that are just
that, new. In this chapter, we describe one example technology: the
MapR data platform. Most of the insights we’ve discussed so far, plus
the design patterns we describe in the next chapter, are based on
watching how people build successful production systems, and this
is the platform they used.
Only a few of the design patterns we describe in Chapter 5 abso‐
lutely require capabilities unique to MapR, but all of them demon‐
strate good practice in pushing platform-appropriate functions
down to the platform rather than trying to implement them at the
application level. That’s an important general lesson regardless of the
platform you use.
Understanding how the MapR data platform works will make it eas‐
ier to see the key ideas in the design patterns. Once you see that,
you’ll understand how to adapt them to your own needs. We also
think you might find this technology interesting in its own right.
Toward that goal, we use the first half of the current chapter to give
you a grounding in some key capabilities of the MapR platform in
the context of production deployments and then go on in the sec‐
ond half of this chapter to describe the underlying technology.
65
Fundamental features of the MapR platform—files,
tables, and streams—are all engineered together into a
single technology, part of the same code and able to
run on the same cluster instead of being separate sys‐
tems that work together via connectors.
With an HDFS cluster, you have directories for organizing files but
no analogous way to organize tables or streams short of proliferating
lots of small special purpose clusters. If you use Apache Kafka for
stream transport you can assign data to topics, but you don’t have
any good way to avoid topic name collision between applications.
You may also have noticed in Figure 4-1 that the path name is divi‐
ded into a cluster name (the /mapr/se1 part) and a volume mount
point part (the /user/tdunning part). MapR-FS has something
called a volume, which is essentially a directory with specialized
management capabilities that enable scalability, disaster recovery,
and multitenancy capabilities. To users and applications, volumes
Figure 4-2. The streams and tables in one MapR cluster can be replica‐
ted to streams and tables in other clusters to form a coherent data fab‐
ric. This replication allows multimaster updates. Either or both clusters
could be in an on-premises data center or hosted in a public cloud.
Data can also be moved between clusters in your data fabric using
volume mirroring, and mirroring to a remote cluster sets you up for
disaster recovery. We describe the details of how mirroring and
stream/table replication work later.
You can connect small footprint MapR clusters to the data fabric
forming an Internet of Things (IoT) edge. This makes it feasible to
collect data from many distributed sources and, if desirable, do pro‐
cessing, aggregation, or data modeling at the edge rather than hav‐
ing to move all data back to a central cluster. Edge Computing is one
of the basic design patterns that we describe in Chapter 5.
The way that MapR streams are embedded in the MapR file system
also means that pieces of topic partitions are distributed across the
cluster. With Kafka, partition replicas are restricted to a single
machine. That limitation makes a practical difference. With MapR
streams it is reasonable to set the TTL to months, years, or even for‐
ever, thus providing a long-term, replayable, event-by-event history.
This playback capability is needed for use cases that employ the
design pattern we call Streaming System of Record. We mentioned
this approach in the use cases described in Figure 2-6, where a mes‐
sage stream with a long TTL might serve as the system of record for
security analytics.
Keep in mind that MapR streams being a first-class part of the file
system means that you don’t need a separate cluster just for stream
transport as you do with Kafka. Every stream in a MapR cluster is the
equivalent of an entire cluster of Kafka brokers. You can have as many
streams on a MapR cluster as you like, each containing hundreds of
thousands of topics or more. The more familiar a person is with
Kafka, the harder it can be for them to realize that with MapR you
don’t need a separate cluster for stream transport; you stream mes‐
sages on the same cluster where your Flink, Spark, or other applica‐
tions are hosted. This reduces operational complexity by avoiding a
network bottleneck. This difference was highlighted in a discussion
Message Streams
In MapR-FS, message streams are first-class objects, as are files and
tables. You can write to and read from message streams using the
Apache Kafka API, although the implementation of message streams
in MapR-FS shares no code with Kafka itself.
Each stream logically contains of a number of topics, themselves
divided, Kafka-style, into partitions. Messages within partitions are
ordered. Topics in different streams are, however, completely inde‐
pendent. This allows two instances of the same application to run
independently using different streams, even though they might use
the same topic names. To achieve the same level of isolation while
avoiding the risk of topic name collision, two Kafka-based applica‐
tions would have to use separate Kafka clusters.
Physically, MapR streams are implemented on top of the primitive
B-tree structures in MapR by using a combination of topic, parti‐
tion, and message offset as the key for a batch of messages. The
batching of messages allows very high write and read throughput,
whereas the unification of the entire stream in a single distributed
data structure means that the same low-level mechanisms for dis‐
tributing table and file operations can be repurposed for streams.
Auditing
In earlier chapters, we talked about the importance of having fine-
grained control over data and applications and that requires know‐
ing what is going on. Transparency into your systems helps with this
in situations such as finding bottlenecks such as described at the end
of Chapter 2.
With MapR, it is possible to turn on selective levels of audit infor‐
mation for any volumes in a system. With auditing enabled, infor‐
mation about object creation, deletion, update, or reads can be sent
to a message stream in an easily parsed JSON format.
You can use audit information in a variety of ways, the most obvious
being monitoring of data creation and access. This is very useful
when combined with automated anomaly detection in which a pre‐
dictive model examines access and creation of data for plausibility
against historical patterns.
You can use audit information in other ways. For instance, by moni‐
toring audit streams, a metadata extraction program can be notified
about new files that must be analyzed or modified files whose meta‐
data needs updating. You could imagine the creation of thumbnails
for videos being triggered this way or the extraction of plain texts
from PDF documents. Audit streams are also excellent ways to trig‐
ger indexing of files for search purposes.
Now that you have a good grounding in the habits that are charac‐
teristic of successful large-scale production deployments and an
understanding of some of the capabilities to look for in data plat‐
form and containerization technologies with which you build your
systems, it’s useful to see how that comes to life in real-world situa‐
tions. In this chapter, we present a collection of design patterns you
can use across a wide range of use cases. These patterns are not
industry specific and may be combined in a variety of ways to
address particular business goals. Most important, these design pat‐
terns are not theoretical. We base them on what we see customers
doing in successful large-scale production systems.
Your challenge is to figure out how you can put these powerful
underlying patterns to use in your own situation. As you read this
chapter, you may find it useful to skim the first paragraph of each
design pattern to find those that relate to your needs.
79
feature of such a system is to build what is known as a digital shadow
of each thing for informational purposes or diagnostics. Other goals
include computing aggregate statistics of product feature usage and
distribution of product updates.
The most important constraints in this design pattern are data secu‐
rity, scale and reliability in a difficult and nearly uncontrolled work‐
ing environment.
Figure 5-1 shows a basic design that is common for this pattern. The
process starts at the device, of which there might be hundreds—or
hundreds of millions. Each device records status and sensor data for
central analysis but also needs to get software and configuration
updates. These updates may be targeted to one particular device or
class of devices. It is almost universal that the data produced by the
device must be kept private and that device data and software
updates must be unforgeable.
The lower panel of Figure 5-2 shows an alternative design for a non-
MapR platforms. The goal is the same, but there are some variations
in how the data is ingested for ETL and how the refined data is
The topics used to write these messages to the log stream are com‐
monly composed using a combination of the data center name, the
name of the node running the application generating the log mes‐
sage, and possibly a message type. Message types are commonly
used to distinguish different kinds of log lines or to differentiate
between different kinds of measurements that might be contained in
the log lines.
So far, there is little advantage in writing log messages to a stream.
There are clear differences, however, because message streams can
be easily replicated to a central data center with minimal configura‐
tion or setup, as shown in Figure 5-5.
Edge Computing | 93
Figure 5-6 shows an outline of the common structure of all of these
systems.
Customer 360
The goal of a Customer 360 pattern is to establish a high-
performance, consolidated store of complete histories for every cus‐
tomer. When this is done and the entire history for a single
customer is viewed as a single consistent list of events, many kinds
of processing become enormously simpler. The basic idea is that the
nonrelational, highly flexible nature of state-of-the-art big data
allows dramatically simpler interpretation of the data without hav‐
Customer 360 | 95
Figure 5-7. In a Customer 360 system, all kinds of information for a
single customer are collected into a reference database and kept in a
way so that customer histories can be accessed very quickly and with
comprehensive retrieval of all desired data. In practice, internal cus‐
tomers of the data have specialized enough needs that it pays to extract
views of the reference database into smaller, special-purpose subdata‐
bases.
Customer 360 | 97
Recommendation Engine
The motivation for building a recommendation engine generally is to
improve customer experience by better understanding what will
appeal to particular customers. This is done by an analysis of the
customers’ preferences communicated through their actions. The
improved experience can result in increased sales, longer retention
for services, stickier websites, or higher efficiency for marketing
spend. In short, happier customers generally result in improved
business and customers who find things they like tend to be happier.
Big data systems provide an excellent platform for building and
deploying a recommendation system, particularly because good rec‐
ommendation requires very large datasets to train a model. You can
build and deploy a simple but very powerful recommender easily by
exploiting search technology running on a data platform. In fact,
such a recommender can be much simpler than you might think.
Let’s take a look at how that works.
The goal of a recommendation engine is to present customers with
opportunities that they might not otherwise find by normal brows‐
ing and searching. This is done by using historical user behavior for
the entire population of users to find patterns that are then cross-
referenced to the recent behavior of a specific user. Recommenda‐
tions can be presented to users explicitly in the form of a list of
recommended items or offers but can also be used more subtly to
make a user’s overall experience more relevant to what they want to
do. As an example, a “What’s New” page could literally just show
new items in reverse chronological order of introduction, or it could
show all items introduced recently ordered by a recommendation
engine. The latter approach tends to engage users more strongly.
There are two major kinds of recommendation systems that are
commonly used in production. One is based on machine learning,
typically using an algorithm called alternating least squares. This sys‐
tem tends to be more complex and deploying the recommendations
requires a specialized recommender engine. The other major kind is
based solely on counting how many times different items co-occur
in users’ activity histories. This result of this co-occurrence analysis
is then inserted into a conventional search engine, often a preexist‐
ing one for deployment of recommendations in production. The
second approach is much simpler than the first and the difference in
performance (if any) is typically not very significant.
Recommendation Engine | 99
would analyze past behavior of one type to make recommendations
of a different type. An example would be using past behavior con‐
sisting of reading reviews for a product to recommend purchase of
that item or others. Using multiple cross-occurrences together with
co-occurrence is a valuable way to improve recommender perfor‐
mance.
Marketing Optimization
The goal of Marketing Optimization is to understand what causes
customers to ultimately buy products across both marketing and
sales cycles. In very few businesses, the marketing that get customers
to engage with a company and the sales process that ensues are rela‐
Object Store
The goal of a large Object Store is to store a large number of data
objects that need to be accessed individually, often by name, but that
are not necessarily of interest for wholesale analysis. This has wide
utility in a number of businesses. One common use case is in finan‐
cial companies where all emails, text messages, phone calls, and
even recordings of meetings may be recorded this way and retained
for potential use in proving regulatory compliance. In such a case, it
is important for all of the saved objects to be accessible via standard
file APIs so that standard software for, say, voice-to-text conversion
can be used. Another use case is for media streaming for which a
large number of video or audio files would be stored in different ver‐
sions in different encodings. Typically, there would be a large num‐
ber of thumbnail images or other extracted information associated
with each media item. Commonly, these related files would be
arranged in directories, and it is very useful to have automated ways
to replicate data to other clusters in other data centers and to allow
web servers to read files directly.
In terms of how the objects in an object store are stored, the sim‐
plest possible implementation is to simply store all objects as indi‐
vidual files, one per object, rather than a database. This is
particularly true because large objects, often over a megabyte on
average, are relatively common. Often the underlying purpose for a
large object store is to provide access to media such as videos or
audio recordings; sometimes the objects have to do with messaging
systems or systems data. Typically, the number of objects is in the
tens of millions to tens of billions, and the sizes of the objects
involved range from tens of kilobytes to hundreds of megabytes.
One common requirement is to make objects accessible on the web.
Downtime is typically unacceptable in these systems, and 99.9th per‐
centile response, exclusive of transmission time, must typically be in
the tens of milliseconds.
Figure 5-10. You can use business events to populate databases with
current estimates of the business state. Pausing the update of the data‐
base can give snapshots of historical states. Ordinary databases nor‐
mally cannot give you this historical view.
Figure 5-11. Critical subsystems are systems that both use and update
state, emitting business events in the process. Each such system sends
all such events to a business-wide stream of record that can provide a
scalable and inspectable implementation of critical business processes.
You need to consider possible race conditions, but you can avoid this
potential problem with good design.
In this pattern, one table is considered the master copy of the data.
Changes to this table are inserted into a stream using whatever CDC
system is available for the master table. These changes are best
stored in a stream so that you can back up and replay them at any
time. The first consumer in the figure of these changes is a so-called
snapshot service. The point of the snapshot service is to make and
save copies of the master table at different points in time. Each of
these snapshots includes the stream offset of the last change in the
snapshot. This allows you to quickly construct a current copy of the
database by copying the snapshot and replaying all changes starting
from the offset specified in the snapshot table. This initialization is
illustrated in Figure 5-14 with a dashed line.
Percolation can be very handy when you have a system that inserts
data into a table, but you don’t want to have that system spend the
time to compute the fully elaborated form of that data. With perco‐
lation, the basic data source can be kept very simple, and all the
work of elaborating the data beyond the original form can be
deferred out of the critical path. Percolation can also become a dan‐
gerous data pattern if the changes are not idempotent or if the per‐
colated changes cause more percolation. If you find yourself
building elaborate patterns of percolation, you probably will be hap‐
pier with streaming system of record pattern.
115
want to be successful quickly, it helps to focus initially on one spe‐
cific use for this new technology.
Don’t expect to know at the start all the different ways that you
might eventually want to use machine learning or advanced analyt‐
ics. Instead, examine your needs (immediate or long-term goals),
pick one need that offers a near-term advantage, and begin planning
your initial project. As your team becomes familiar with what is fea‐
sible and with the ecosystem tools required for your specific goal,
you’ll be well positioned to try other things as you see new ways in
which advanced analytical systems may be useful to you.
There’s no single starting point that’s best for everyone. In Chap‐
ter 5, we describe some common design patterns for machine learn‐
ing and advanced analytics. Many of those would make reasonable
first projects. As you consider where to begin, whether it comes
from our list or not, make sure that there is a good match between
what you need done and what such a system does well. For your first
project, don’t think about picking the right tool for the job; be a bit
opportunistic and pick the right job for the tool.
By focusing on one specific goal to start with, the learning curve that
you face can be a little less steep. For example, for your first project,
you might want to pick one with a fairly short development horizon.
You can more quickly see whether your planning is correct, deter‐
mine if your architectural flow is effective, and begin to gain famili‐
arity with what you can actually achieve. This approach can also get
you up and running quickly and let you develop the expertise
needed to handle the later, larger, and likely more critical projects.
Many if not most of the successful and large-scale data systems
today started with a single highly focused project. That first project
led in a natural way to the next project and the next one after that.
There is a lot of truth in the idea that big data didn’t cause these sys‐
tems to be built, but that instead, building them created big data. As
soon as there is a cluster available, you begin to see the possibilities
of working with much larger (and new) datasets. As soon as you can
build and deploy machine learning models, you begin to see places
to use such models everywhere. It is amazing to find out how many
people had analytical projects in their hip pocket and how much
value can be gained from bringing them to life.
Tip #5: Monitor for Changes in the World and Your Data | 121
ticularly true of large-scale systems, systems that are in long-term
production, systems that get information from the internet, and sys‐
tems that have adversaries such as fraudsters. The data you see in
your system is very unlikely to be static. It will likely change due to
updated formats, new data, loss of data sources, or enemy (or com‐
petitor or fraudster) actions.
Recognizing that this is inevitable, it is important that you be pre‐
pared and that you watch for what comes your way. There are many
techniques to look for shifts of this sort, but here are two particular
techniques that are relatively easy but still provide substantial value.
The first method is to look at the shape of your incoming data. You
can do this by clustering your input data to find patterns of highly
related input features. Later, for each new data point, you find which
cluster the new data point is closest to and how far it is from the
center of that cluster. This method reduces multidimensional input
data into a one-dimensional signal and reduces the problem of
monitoring your input data to that of monitoring one-dimensional
signals (the distances) and arrival times (when points are added to
each cluster). You also can use more advanced kinds of autoencod‐
ers, but the key is reducing complex input into a (mathematically)
simpler discrepancy score for monitoring. You can find more infor‐
mation about monitoring for change this way in our book Practical
Machine Learning: A New Look at Anomaly Detection (O’Reilly,
2014).
A second technique involves looking at the distribution of scores
that come out of your machine learning models. Because these mod‐
els learn regularities in your input data, the score distributions are
important indicators of what is happening in general in your data
and changes in those distributions can be important leading indica‐
tors of changes that might cause problems for your system. You can
learn more about monitoring machine learning models in our book
Machine Learning Logistics: Model Management in the Real World
(O’Reilly, 2017).
{
"VIN":"3FAFW33407M000098",
"manufacturer":"Ford",
"model": {
"base": "Ford F-Series, F-350",
"options": ["Crew Cab", "4WD", "Dual Rear Wheels"]
},
"engine":{
"class": "V6,Essex",
"displacement": "3.8 L",
"misc": ["EFI","Gasoline","190hp"]
},
"year":2007
}
Nested data formats such as JSON (shown in Example 6-1) are very
expressive and help future-proof your applications by making data
format migration safer and easier. Social media sources and web-
oriented APIs such as Twitter streams often use JSON for just this
reason.
Nested data provides you with some interesting new options. Think
of this analogy: Nested data is like a book. A book is a single thing,
but it contains subsets of content at different levels, such as chapters,
figure legends, and individual sentences. Nested data can be treated
as a unit, but the data at each internal layer can also be used in detail
if desired.
Nested data formats such as JSON or Parquet combine flexibility
with performance. A key benefit of this flexibility is future-proofing
your applications. Old applications will silently ignore new data
fields, and new applications can still read old data. Combined with a
little bit of discipline, these methods lead to very flexible and robust
interfaces. This style of data structure migration was pioneered by
Google and has proved very successful in a wide range of compa‐
nies.
Besides future-proofing, nested data formats let you encapsulate
structures. Just as with programming languages, encapsulation
allows data to be more understandable and allows you to hide irrele‐
Additional Resources
These resources will help you to build production artificial intelli‐
gence and analytics systems:
127
• Streaming Architecture: New Designs Using Apache Kafka and
MapR Streams (March 2016)
• Sharing Big Data Safely: Managing Data Security (September
2015)
• Real-World Hadoop (January 2015)
• Time Series Databases: New Ways to Store and Access Data
(October 2014)
• Practical Machine Learning: A New Look at Anomaly Detection
(June 2014)
• Practical Machine Learning: Innovations in Recommendation
(January 2014)