How do you detangle a monolithic system and migrate it to a microservices architecture? How do you do it while maintaining business-as-usual? As a companion to Sam Newman’s extremely popular Building Microservices, this new book details a proven method for transitioning an existing monolithic system to a microservice architecture.
With many illustrative examples, insightful migration patterns, and a bevy of practical advice to transition your monolith enterprise into a microservice operation, this practical guide covers multiple scenarios and strategies for a successful migration, from initial planning all the way through application and database decomposition. You’ll learn several tried and tested patterns and techniques that you can use as you migrate your existing architecture.
Ideal for organizations looking to transition to microservices, rather than rebuild
Helps companies determine whether to migrate, when to migrate, and where to begin
Addresses communication, integration, and the migration of legacy systems
Discusses multiple migration patterns and where they apply
Provides database migration examples, along with synchronization strategies
Explores application decomposition, including several architectural refactoring patterns
Delves into details of database decomposition, including the impact of breaking referential and transactional integrity, new failure modes, and more

You did it. You successfully transformed your application into a microservices architecture. But now that you’re running microservices across different environments—public to public, private to public, virtual machine to container—your cloud native software is beginning to encounter reliability issues.
How do you stay on top of this ever-increasing complexity? Simple: you run the Istio service mesh. With Istio, you’ll be able to manage traffic, control access, monitor, report, get telemetry data, manage quota, trace, and more with resilience across your microservice.
In this book, Matthew Baldwin and Lee Calcote explain why your services need a service mesh, and demonstrate how Istio fits into the lifecycle of a distributed application. You’ll learn about tools and APIs for enabling and managing many of the features found in Istio.
Explore the observability challenges Istio addresses
Learn about request routing, traffic shifting, fault injection, and other features essential to running a solid service mesh
Generate and collect telemetry information
Go through different deployment patterns including A/B, Blue/Green, and Canary
Learn examples of how to develop and deploy real-world applications with Istio support

or data engineers and researchers new to stream processing, this practical book provides a professional reference that focuses on Apache Heron. Authors Huijun Wu and Maosong Fu from Twitter provide the basic knowledge you need to get started with this real-time processing engine. Learn how Heron serves as a general-purpose, modular, and extensible platform that you can use to support common real-time analytics use cases.
Through the course of this book, you’ll discover approaches for tackling challenges in stream processing systems and applications. You’ll also understand how to build streaming applications that can benefit from Heron’s robustness, high performance, adaptability to cloud environments, and ease of use.
With this book, you’ll examine:
A complete study path that shows you how to develop stream processing systems
Heron’s data model, system, topology submission process, architecture, and components
How to compile the Heron source code
Methods for migrating Apache Storm’s topology to Heron
Heron components, including state manager, scheduler, topology master, stream manager, instance, metrics manager, and metrics cache
Heron tools, including tracker, UI, and explorer
New features, such as health manager, Python topology, delivery semantics, and API server

Over the past 10 years, distributed systems have become more fine-grained. From the large multi-million line long monolithic applications, we are now seeing the benefits of smaller self-contained services. Heavy-weight, hard to change Service Oriented Architectures are not the answer; instead we are now seeing finer-grained systems consisting of collaborating microservices. Easier to change, deploy, and if required retire, organizations which are in the right position to take advantage of them are yielding significant benefits.
This book takes an holistic view of the things you need to be cognizant of in order to pull this off. It covers just enough understanding of technology, architecture, operations and organization to show you how to move towards finer-grained systems.

Many enterprise applications intertwine code that defines an app’s behavior with code that defines its network communication and other non-functional concerns. The “service mesh” pattern, implemented by platforms like Istio, helps you push operational issues into the infrastructure so the application code is easier to understand, maintain, and adapt. Istio in Action teaches you how to implement a full-featured Istio-based service mesh to manage a microservices application. With the skills you learn in this comprehensive tutorial, you’ll be able to delegate the complex infrastructure of your cloud-native applications to Istio!
Istio in Action is a comprehensive guide to handling authentication, routing, retrying, load balancing, collecting data, security, and other common network-related tasks using the Istio service mesh platform. With author Christian Posta’s expert guidance, you’ll experiment with a basic service mesh as you explore the features of Envoy, Istio’s service proxy. With helpful diagrams and hands-on examples, you’ll learn how to use this open-source service mesh to control routing, secure container applications, and monitor network traffic. You’ll also bring Istio to legacy systems without changes to your applications and discover how to use Istio in a multi-cloud world with the data layer deployed on a cluster like Kubernetes.

Work with petabyte-scale datasets while building a collaborative, agile workplace in the process. This practical book is the canonical reference to Google BigQuery, the query engine that lets you conduct interactive analysis of large datasets. BigQuery enables enterprises to efficiently store, query, ingest, and learn from their data in a convenient framework. With this book, you’ll examine how to analyze data at scale to derive insights from large datasets efficiently.
Valliappa Lakshmanan, tech lead on Google Cloud Platform, and Jordan Tigani, engineering director for the BigQuery team, provide best practices in modern data warehousing within an autoscaled, serverless, public cloud. Whether you want to explore parts of BigQuery you’re not familiar with, or prefer to focus on specific tasks, this reference is indispensable.

Serverless computing greatly simplifies software development. Your team can focus solely on your application while the cloud provider manages the servers you need. This practical guide shows you step-by-step how to build and deploy complex applications in a flexible multicloud, multilanguage environment using Apache OpenWhisk. You’ll learn how this platform enables you to pursue a vendor-independent approach using preconfigured containers, microservices, and Kubernetes as your cloud operating system.
Michele Sciabarrà demonstrates how to build a serverless application using classical design patterns and the programming language or languages that best fit your task. You’ll start by building a simple serverless application hands-on before diving into the more complex aspects of the OpenWhisk platform.
Examine how OpenWhisk’s serverless architecture works, including the use of packages, actions, sequences, triggers, rules, and feeds
Learn how OpenWhisk compares to existing architectures, such as Java Enterprise Edition
Manipulate OpenWhisk features using the command-line interface or a JavaScript API
Design applications using common Gang of Four design patterns
Use architectural design patterns such as model-view-controller to combine several OpenWhisk actions
Learn how to test and debug your code in a serverless environment

The kinds of analysis and data sharing that takes place in modern business relies on fast, robust communications among computer systems. Network architects, network operators, and even the designers of distributed applications need to understand architecture and communications protocols in the data center. And best practices have changed radically over the past decade.
For the first time, you can find out what a modern data center looks like, thanks to this book by a leading network developer, Dinesh G. Dutt. This book offers both theory to ground your work and practical advice on topics, such as:
Connecting systems in modern data centers
Multitenancy
How to automate common practices
Proper monitoring
Choices in routing protocols

Terraform has become a key player in the DevOps world for defining, launching, and managing infrastructure as code (IAC) across a variety of cloud and virtualization platforms, including Azure, Google Cloud, DigitalOcean, and others. The updated second edition of this hands-on guide is fastest way to get up and running with Terraform.
Gruntwork co-founder Yevgeniy (Jim) Brikman walks you through dozens of code examples that demonstrate how to use Terraform’s simple, declarative programming language to deploy and manage infrastructure with just a few CLI commands. Whether you’re a novice developer, aspiring DevOps engineer, or veteran sysadmin, this book will take you from Terraform basics to running a full tech stack capable of supporting a massive amount of traffic and a large team of developers.

Most AWS Lambda books and introductions focus on Javascript and Python, but this book is written explicitly for Java developers who want to embrace the world of Serverless through AWS Lambda—without having to learn a new language on top of it. Serverless is a revolution in how we build and deploy software. It drastically reduces the complexity of building and operating applications, and reduces time-to-market and costs. AWS Lambda is Amazon’s Serverless "Functions-as-a-Service" platform, and is the core of most Serverless efforts ongoing today.

Kubernetes radically changes the way applications are built and deployed in the cloud. Since its introduction in 2014, this container orchestrator has become one of the largest and most popular open source projects in the world. The updated edition of this practical book shows developers and ops personnel how Kubernetes and container technology can help you achieve new levels of velocity, agility, reliability, and efficiency.
Kelsey Hightower, Brendan Burns, and Joe Beda—who’ve worked on Kubernetes at Google and beyond—explain how this system fits into the lifecycle of a distributed application. You’ll learn how to use tools and APIs to automate scalable distributed systems, whether it’s for online services, machine learning applications, or a cluster of Raspberry Pi computers.
Create a simple cluster to learn how Kubernetes works
Dive into the details of deploying an application using Kubernetes
Learn specialized objects in Kubernetes, such as DaemonSets, jobs, ConfigMaps, and secrets
Explore deployments that tie together the lifecycle of a complete application
Get practical examples of how to develop and deploy real-world applications in Kubernetes

Serverless computing is radically changing the way we build and deploy applications. With cloud providers running servers and managing machine resources, companies now can focus solely on the application’s business logic and functionality. This hands-on book shows experienced programmers how to build and deploy scalable machine learning and deep learning models using serverless architectures with Microsoft Azure.
You’ll learn step-by-step how to code machine learning into your projects using Python and pre-trained models that include tools such as image recognition, speech recognition, and classification. You’ll also examine issues around deployment and continuous delivery including scaling, security, and monitoring.
This book is divided into four parts:
Cloud-based development: learn the basics of serverless computing with machine learning, functions as a service (FaaS), and the use of APIs
Adding intelligence: create serverless applications using Azure Functions; learn how to use pre-built machine-learning and deep-learning models
Deployment and continuous delivery: get up to speed with Azure Kubernetes Service, as well as Azure Security Center, and Azure Monitoring
Application examples: deliver data at the edge, build conversational interfaces, and use convolutional neural networks for image classification

To build analytics tools that provide faster insights, knowing how to process data in real time is a must, and moving from batch processing to stream processing is absolutely required. Fortunately, the Spark in-memory framework/platform for processing data has added an extension devoted to fault-tolerant stream processing: Spark Streaming.
If you're familiar with Apache Spark and want to learn how to implement it for streaming jobs, this practical book is a must.
Understand how Spark Streaming fits in the big picture
Learn core concepts such as Spark RDDs, Spark Streaming clusters, and the fundamentals of a DStream
Discover how to create a robust deployment
Dive into streaming algorithmics
Learn how to tune, measure, and monitor Spark Streaming

Get started with Apache Flink, the open source framework that enables you to process streaming data—such as user interactions, sensor data, and machine logs—as it arrives. With this practical guide, you’ll learn how to use Apache Flink’s stream processing APIs to implement, continuously run, and maintain real-world applications.Authors Fabian Hueske, one of Flink’s creators, and Vasia Kalavri, a core contributor to Flink’s graph processing API (Gelly), explains the fundamental concepts of parallel stream processing and shows you how streaming analytics differs from traditional batch data analysis. Software engineers, data engineers, and system administrators will learn the basics of Flink’s DataStream API, including the structure and components of a common Flink streaming application.Solve real-world problems with Apache Flink’s DataStream APISet up an environment for developing stream processing applications for FlinkDesign streaming applications and migrate periodic batch workloads to continuous streaming workloadsLearn about windowed operations that process groups of recordsIngest data streams into a DataStream application and emit a result stream into different storage systemsImplement stateful and custom operators common in stream processing applicationsOperate, maintain, and update continuously running Flink streaming applicationsExplore several deployment options, including the setup of highly available installations

While Kubernetes has established itself as the industry standard for managing containers and their life cycles, there’s a definite need for good practices on how to write native applications. This practical guide shows application and infrastructure developers, DevOps practitioners, and site reliability engineers how to develop cloud native apps that run on Kubernetes.
Red Hat’s developer advocate Michael Hausenblas and senior software engineer Stefan Schimanski guide you through Kubernetes’ basic building blocks including the client-go API library, custom resources, and cloud native programming languages. This intermediate-level book requires a minimum understanding of development and system administration tools and practices such as package management, the Go programming language, and using Git.

The way developers design, build, and run software has changed significantly with the evolution of microservices and containers. These modern architectures use new primitives that require a different set of practices than most developers, tech leads, and architects are accustomed to. With this focused guide, Bilgin Ibryam and Roland Huß from Red Hat provide common reusable elements, patterns, principles, and practices for designing and implementing cloud-native applications on Kubernetes.
Each pattern includes a description of the problem and a proposed solution with Kubernetes specifics. Many patterns are also backed by concrete code examples. This book is ideal for developers already familiar with basic Kubernetes concepts who want to learn common cloud native patterns.
You’ll learn about the following pattern categories:
Foundational patterns cover the core principles and practices for building container-based cloud-native applications.
Behavioral patterns explore finer-grained concepts for managing various types of container and platform interactions.
Structural patterns help you organize containers within a pod, the atom of the Kubernetes platform.
Configuration patterns provide insight into how application configurations can be handled in Kubernetes.
Advanced patterns covers more advanced topics such as extending the platform with operators.

Book Description
Model serving is a critical but often underappreciated aspect of machine learning.Once you have built a model using your training data set, you need to packageand deploy (i.e., serve) it. It's a surprisingly complex task, in part because modeltraining is usually handled by data scientists, and model serving is the domain ofsoftware engineers. These two groups have different functions, concerns, andtools, so the handoff can be tricky. Plus, machine learning is a hot and fast-growing field, spawning a slew of new tools that require software engineers tocreate new model serving frameworks.
This book delves into the theory and practice of serving machine learning modelsin streaming applications. It proposes an overall architecture that implementscontrolled streams of both data and models that enables not only real-time modelserving, as part of processing input streams, but also real-time model updating. Italso covers:
Step-by- step options for exporting models in tensorflow and PMMLformats.
Implementation of model serving leveraging stream processing enginesand frameworks including Apache Flink, Apache Spark streaming, ApacheBeam, Apache Kafka streams, and Akka streams.
Monitoring approaches for model serving implementations.

Summary
Docker in Practice, Second Edition presents over 100 practical techniques, hand-picked to help you get the most out of Docker. Following a Problem/Solution/Discussion format, you'll walk through specific examples that you can use immediately, and you'll get expert guidance on techniques that you can apply to a whole range of scenarios.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the Technology
Docker's simple idea-wrapping an application and its dependencies into a single deployable container-created a buzz in the software industry. Now, containers are essential to enterprise infrastructure, and Docker is the undisputed industry standard. So what do you do after you've mastered the basics? To really streamline your applications and transform your dev process, you need relevant examples and experts who can walk you through them. You need this book.
About the Book
Docker in Practice, Second Edition teaches you rock-solid, tested Docker techniques, such as replacing VMs, enabling microservices architecture, efficient network modeling, offline productivity, and establishing a container-driven continuous delivery process. Following a cookbook-style problem/solution format, you'll explore real-world use cases and learn how to apply the lessons to your own dev projects.
What's inside
Continuous integration and delivery
The Kubernetes orchestration tool
Streamlining your cloud workflow
Docker in swarm mode
Emerging best practices and techniques
About the Reader
Written for developers and engineers using Docker in production.

Learn how to take full advantage of Apache Kafka, the distributed, publish-subscribe queue for handling real-time data feeds. With this comprehensive book, you'll understand how Kafka works and how it's designed. Authors Neha Narkhede, Gwen Shapira, and Todd Palino show you how to deploy production Kafka clusters; secure, tune, and monitor them; write rock-solid applications that use Kafka; and build scalable stream-processing applications.

Hobbyists, newcomers, and professionals alike can benefit from a fast, modern language; all you need is the right resource! Get Programming with Go provides a hands-on introduction to Go language fundamentals, serving as a solid foundation for your future programming projects. You'll master Go syntax, work with types and functions, and explore bigger ideas like state and concurrency, with plenty of exercises to lock in what you learn.