Work with big data applications by using Spring Cloud Data Flow as a unified, distributed and extensible system for data ingestion and integration, real-time analytics and data processing pipelines, batch processing, and data export. With this book, you will develop a foundation for creating applications that use real-time data streaming by combining different technologies and use the full power of Spring Cloud Data Flow.
The first part of the book begins with an overview of the cloud, microservices, and big data, before moving on to the Spring projects essential to modern big data applications in Java: Spring Integration, Spring Batch, Spring Cloud Stream, and Spring Cloud Task. The second part of the book covers the internals of Spring Cloud Data Flow, giving you the insights and knowledge required to build the applications you need. You'll learn how to use Spring Data Flow's DSL and how to integrate with third-party cloud platform solutions, such as Cloud Foundry and Kubernetes.
Finally, the book covers Spring Cloud Data Flow applications to impart practical, useful skills for real-world applications of the technologies covered throughout the rest of the book.
What you will learn:
See the Spring Cloud Data Flow internals
Master Spring Cloud Data Flow architecture, data processing, and DSL
Integrate Spring Cloud Data Flow with Cloud Foundry, and Kubernetes
Use Spring Cloud Data Flow local server, Cloud Foundry, and more
Discover the Spring Cloud Data Flow applications and how to use them
Work with source, processor, sink, tasks, Spring Flo and its GUI, and analytics via the new Micrometer stack for realtime visibility with Prometheus and Grafana

Get an easy introduction to reactive streams in Java to handle concurrency, data streams, and the propagation of change in today's applications. This compact book includes in-depth introductions to RxJava, Akka Streams, and Reactor, and integrates the latest related features from Java 9 and 11, as well as reactive streams programming with the Android SDK.
Reactive Streams in Java explains how to manage the exchange of stream data across an asynchronous boundary―passing elements on to another thread or thread-pool―while ensuring that the receiving side is not forced to buffer arbitrary amounts of data which can reduce application efficiency. After reading and using this book, you'll be proficient in programming reactive streams for Java in order to optimize application performance, and improve memory management and data exchanges.

Take your distributed applications to the next level and see what the reference architectures associated with microservices can do for you. This book begins by showing you the distributed computing architecture landscape and provides an in-depth view of microservices architecture. Following this, you will work with CQRS, an essential pattern for microservices, and get a view of how distributed messaging works. Moving on, you will take a deep dive into Spring Boot and Spring Cloud.
Coming back to CQRS, you will learn how event-driven microservices work with this pattern, using the Axon 2 framework. This takes you on to how transactions work with microservices followed by advanced architectures to address non-functional aspects such as high availability and scalability. In the concluding part of the book you develop your own microservices application using the Axon framework and true BASE transactions, while making it as secure as possible.
You will:
Shift from monolith architecture to microservices
Build solid architectures without ACID-compliant databases
Work with transactional systems
Discover the high availability principles in microservices

A developer-focused guide to writing applications using Spring Boot. You'll learn how to bypass the tedious configuration steps so that you can concentrate on your application's behavior.
Spring Boot in Action is a developer-focused guide to writing applications using Spring Boot. In it, you?ll learn how to bypass configuration steps so you can focus on your application?s behavior. Spring expert Craig Walls uses interesting and practical examples to teach you both how to use the default settings effectively and how to override and customize Spring Boot for your unique environment. Along the way, you?ll pick up insights from Craig?s years of Spring development experience.

Spring Microservices in Action teaches you how to build microservice-based applications using Java and the Spring platform. You'll learn to do microservice design as you build and deploy your first Spring Cloud application. Throughout the book, carefully selected real-life examples expose microservice-based patterns for configuring, routing, scaling, and deploying your services. You'll see how Spring's intuitive tooling can help augment and refactor existing applications with micro services.

Microservices in Action is a practical book about building and deploying microservice-based applications. Written for developers and architects with a solid grasp of service-oriented development, it tackles the challenge of putting microservices into production.

About the Book
RxJava for Android Developers begins by inviting you to think about programming and data the reactive way. This engaging, hands-on essential reference introduces you to the central pattern of RxJava for Android, then explains the View Model before exploring highly sought-after app features like chat clients and elegant transitions. Finally, you'll look at high-level design concerns and architectural approaches and frameworks that work well with Functional Reactive Programming (FRP) thinking.
What's inside
An introduction to reactive programming
Easier thread management
Improving UI responsiveness
Thinking asynchronously
Building a working chat client

Network applications must handle events intelligently and efficiently, establishing priorities, resolving conflicts, and managing resources to avoid blocks, dropouts, and the other jams that occur in high-traffic environments. Netty is a Java-based networking framework designed to handle asynchronous network events smoothly so your applications are easy to write and maintain. The framework hides all the boilerplate and low-level code from you, making it possible to keep your business-logic separate and reusable, even in different network transports and protocols. Netty has built-in support for many protocols i.e. HTTP, SPDY, and WebSockets.
Netty in Action introduces the Netty framework and shows you how to incorporate it into your Java network applications. You'll learn to write highly-scalable applications without the need to dive into the low-level non-blocking APIs at the core of Java. You'll learn how to think in an asynchronous way as you work through numerous hands-on examples. You'll follow numerous examples that show you how to use Netty while you master the best practices of large-scale network apps.

Perimeter defenses guarding your network aren’t as secure as you might think. Hosts behind the firewall have no defenses of their own, so when a host in the "trusted" zone is breached, access to your data center is not far behind. This practical book introduces you to the zero trust model, a method that treats all hosts as if they’re internet-facing, and considers the entire network to be compromised and hostile.
Authors Evan Gilman and Doug Barth show you how zero trust lets you focus on building strong authentication, authorization, and encryption throughout, while providing compartmentalized access and better operational agility. You’ll learn the architecture of a zero trust network, including how to build one using currently available technology.
Understand how the zero trust model embeds security within the system’s operation, rather than layering it on top
Examine the fundamental concepts at play in a zero trust network, including network agents and trust engines
Use existing technology to establish trust among the actors in a network
Learn how to migrate from a perimeter-based network to a zero trust network in production
Explore case studies of zero trust on the client side (Google) and on the server (PagerDuty)

Is microservice architecture right for your organization? Microservices have many benefits, but they also come with their own set of drawbacks. With this updated edition, Java developers and architects will learn how to navigate popular application frameworks such Spring Boot and MicroProfile to deploy and manage microservices at scale with Linux containers. This hands-on, example-driven guide provides step-by-step instructions to help you get started.
Adopting microservices requires much more than changes to your technology. Author Rafael Benevides, director of developer experience at Red Hat, also examines the organizational agility necessary to deliver these services. This concise ebook shows you how rapid feedback cycles, autonomous teams, and shared purpose are key to making microservices work.
Learn why microservices require you to think differently about building, deploying, and operating cloud-native applications
Design microservices using the popular Spring Boot and Eclipse MicroProfile frameworks
Build an API gateway with Apache Camel to help clients access microservices
Use Docker and Kubernetes to deploy microservices, regardless of language
Run microservices at scale using cluster management, failover, and load-balancing techniques
Use OpenTracing to monitor requests, response time, and the path of particular invocations

Fun guide to learning Bayesian statistics and probability through unusual and illustrative examples.
Probability and statistics are increasingly important in a huge range of professions. But many people use data in ways they don't even understand, meaning they aren't getting the most from it. Bayesian Statistics the Fun Way will change that.
This book will give you a complete understanding of Bayesian statistics through simple explanations and un-boring examples. Find out the probability of UFOs landing in your garden, how likely Han Solo is to survive a flight through an asteroid shower, how to win an argument about conspiracy theories, and whether a burglary really was a burglary, to name a few examples.
By using these off-the-beaten-track examples, the author actually makes learning statistics fun. And you'll learn real skills, like how to:
- How to measure your own level of uncertainty in a conclusion or belief
- Calculate Bayes theorem and understand what it's useful for
- Find the posterior, likelihood, and prior to check the accuracy of your conclusions
- Calculate distributions to see the range of your data
- Compare hypotheses and draw reliable conclusions from them
Next time you find yourself with a sheaf of survey results and no idea what to do with them, turn to Bayesian Statistics the Fun Way to get

Serverless Architectures on AWS, Second Edition teaches you how to design, secure, and manage serverless backend APIs for web and mobile applications on the AWS platform. You'll get going quickly with this book's relevant real-world examples, code listings, diagrams, and clearly-described architectures that you can readily apply to your own work. You’ll master serverless systems using AWS Lambda and the myriad of other services on the AWS platform.
This new edition has been fully updated to reflect the newest serverless design best practices and changes to AWS, including covering DynamoDB, Cognito, Google Firestore, AWS Elementals MediaConvert, Step Functions, and much more. There are also three new chapters dedicated to black belt tricks for Lambda, using patterns, and even DevOps for serverless applications.
what's inside
First steps with serverless computing
The principles of serverless design
Transitioning from servers to services
Important patterns and architectures
Writing AWS Lambda functions and using the API Gateway
Securing, deploying, and managing your finished architecture

Summary
Testing Java Microservices teaches you to implement unit and integration tests for microservice systems running on the JVM. You'll work with a microservice environment built using Java EE, WildFly Swarm, and Docker. You'll learn how to increase your test coverage and productivity, and gain confidence that your system will work as you expect.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the Technology
Microservice applications present special testing challenges. Even simple services need to handle unpredictable loads, and distributed message-based designs pose unique security and performance concerns. These challenges increase when you throw in asynchronous communication and containers.
About the Book
Testing Java Microservices teaches you to implement unit and integration tests for microservice systems running on the JVM. You'll work with a microservice environment built using Java EE, WildFly Swarm, and Docker. You'll advance from writing simple unit tests for individual services to more-advanced practices like chaos or integration tests. As you move towards a continuous-delivery pipeline, you'll also master live system testing using technologies like the Arquillian, Wiremock, and Mockito frameworks, along with techniques like contract testing and over-the-wire service virtualization. Master these microservice-specific practices and tools and you'll greatly increase your test coverage and productivity, and gain confidence that your system will work as you expect.
What's Inside
Test automation
Integration testing microservice systems
Testing container-centric systems
Service virtualization

Access the power of bare-metal systems programming with Scala Native, an ahead-of-time Scala compiler. Without the baggage of legacy frameworks and virtual machines, Scala Native lets you re-imagine how your programs interact with your operating system. Compile Scala code down to native machine instructions; seamlessly invoke operating system APIs for low-level networking and IO; control pointers, arrays, and other memory management techniques for extreme performance; and enjoy instant start-up times. Skip the JVM and improve your code performance by getting close to the metal.
Developers generally build systems on top of the work of those who came before, accumulating layer upon layer of abstraction. Scala Native provides a rare opportunity to remove layers. Without the JVM, Scala Native uses POSIX and ANSI C APIs to build concise, expressive programs that run unusually close to bare metal. Scala Native compiles Scala code down to native machine instructions instead of JVM bytecode. It starts up fast, without the sluggish warm-up phase that's common for just-in-time compilers. Scala Native programs can seamlessly invoke operating system APIs for low-level networking and IO. And Scala Native lets you control pointers, arrays, and other memory layout types for extreme performance.
Write practical, bare-metal code with Scala Native, step by step. Understand the foundations of systems programming, including pointers, arrays, strings, and memory management. Use the UNIX socket API to write network client and server programs without the sort of frameworks higher-level languages rely on. Put all the pieces together to design and implement a modern, asynchronous microservice-style HTTP framework from scratch.
Take advantage of Scala Native's clean, modern syntax to write lean, high-performance code without the JVM.

Languages may come and go, but the relational database endures. Learn how to use Ecto, the premier database library for Elixir, to connect your Elixir and Phoenix apps to databases. Get a firm handle on Ecto fundamentals with a module-by-module tour of the critical parts of Ecto. Then move on to more advanced topics and advice on best practices with a series of recipes that provide clear, step-by-step instructions on scenarios commonly encountered by app developers. Co-authored by the creator of Ecto, this title provides all the essentials you need to use Ecto effectively.
Elixir and Phoenix are taking the application development world by storm, and Ecto, the database library that ships with Phoenix, is going right along with them. There are plenty of examples that show you the basics, but to use Ecto to its full potential, you need to learn the library from the ground up.
This definitive guide starts with a tour of the core features of Ecto - repos, queries, schemas, changesets, transactions - gradually building your knowledge with tasks of ever-increasing complexity. Along the way, you'll be learning by doing - a sample application handles all the boilerplate so you can focus on getting Ecto into your fingers.
Build on that core knowledge with a series of recipes featuring more advanced topics. Change your pooling strategy to maximize your database's efficiency. Use nested associations to handle complex table relationships. Add streams to handle large result sets with ease. Based on questions from Ecto users, these recipes cover the most common situations developers run into.
Whether you're new to Ecto, or already have an app in production, this title will give you a deeper understanding of how Ecto works, and help make your database code cleaner and more efficient.
What You Need:
To follow along with the book, you should have Erlang/OTP 19+ and Elixir 1.4+ installed. The book will guide you through setting up a sample application that integrates Ecto.

Programmers don't just use Kotlin, they love it. Even Google has adopted it as a first-class language for Android development. With Kotlin, you can intermix imperative, functional, and object-oriented styles of programming and benefit from the approach that's most suitable for the problem at hand. Learn to use the many features of this highly concise, fluent, elegant, and expressive statically typed language with easy-to-understand examples. Learn to write easy-to-maintain, high-performing JVM and Android applications, create DSLs, program asynchrony, and much more.
Kotlin is a highly concise, elegant, fluent, and expressive statically typed multi-paradigm language. It is one of the few languages that compiles down to both Java bytecode and JavaScript. You can use it to build server-side, front-end, and Android applications. With Kotlin, you need less code to accomplish your tasks, while keeping the code type-safe and less prone to error. If you want to learn the essentials of Kotlin, from the fundamentals to more advanced concepts, you've picked the right book.
Fire up your favorite IDE and practice hundreds of examples and exercises to sharpen your Kotlin skills. Learn to build standalone small programs to run as scripts, create type safe code, and then carry that knowledge forward to create fully object-oriented and functional style code that's easier to extend. Learn how to program with elegance but without compromising efficiency or performance, and how to use metaprogramming to build highly expressive code and create internal DSLs that exploit the fluency of the language. Explore coroutines, program asynchrony, run automated tests, and intermix Kotlin with Java in your enterprise applications.
This book will help you master one of the few languages that you can use for the entire full stack - from the server to mobile devices - to create performant, concise, and easy to maintain applications.

You’ve learned everything there is to know about Kubernetes. Now it’s time to put that knowledge into practice. With this practical book, tech leads, DevOps engineers, developers, and architects will learn real-world best practices for putting Kubernetes into action with actual applications. You’ll understand how to build and deploy complete solutions in Kubernetes—everything from CI/CD to application design, deployments, and experiments. You’ll also learn how other companies have delivered solutions in Kubernetes.

Neural networks are getting smaller. Much smaller. The OK Google team, for example, has run machine learning models that are just 14 kilobytes in size—small enough to work on the digital signal processor in an Android phone. With this practical book, you’ll learn about TensorFlow Lite for Microcontrollers, a miniscule machine learning library that allows you to run machine learning algorithms on tiny hardware.
Authors Pete Warden and Daniel Situnayake explain how you can train models that are small enough to fit into any environment, including small embedded devices that can run for a year or more on a single coin cell battery. Ideal for software and hardware developers who want to build embedded devices using machine learning, this guide shows you how to create a TinyML project step-by-step. No machine learning or microcontroller experience is necessary.
Learn practical machine learning applications on embedded devices, including simple uses such as speech recognition and gesture detection
Train models such as speech, accelerometer, and image recognition, you can deploy on Arduino and other embedded platforms
Understand how to work with Arduino and ultralow-power microcontrollers
Use techniques for optimizing latency, energy usage, and model and binary size

Functional programming is more than just writing the same old code in Scala, Clojure, or Haskell. To grok FP—to really get it—you need to rewire your brain to see the world differently. We're here to help you flip the switch. Grokking Functional Programming teaches you first to break down problems in a new way so you can approach them from a FP mindset. Following carefully-selected examples with thorough, carefully-paced explanations, you'll immerse yourself in FP concept by concept. Along the way, exercises, checks for understanding, and even the occasional puzzler give you opportunities to think and practice what you're learning.
what's inside
Designing with functions instead of objects
Multiple learning approaches to help you grok each new concept
A practical programming-first teaching style
Programming with immutable collections
Writing concurrent programs with a functional style

Kafka in Action is a practical, hands-on guide to building Kafka-based data pipelines. Filled with real-world use cases and scenarios, this book probes Kafka's most common use cases, ranging from simple logging through managing streaming data systems for message routing, analytics, and more. Starting with an overview of Kafka's core concepts, you'll immediately learn how to set up and execute basic data movement tasks and how to record and consume streaming data. As you move through the examples in this book, you'll learn the skills you need to work in a Kafka focused team with the ability to handle both developer and admin based tasks. At the end of this book, you'll be more than ready to dig into even more advanced Kafka topics on your own, and happily able to use Kafka in your day-to-day workflow.
what's inside
Understanding Kafka's concepts
Implementing Kafka as a message queue
Setting up and executing basic ETL tasks
Recording and consuming streaming data
Working with Kafka producers and consumers from Java applications
Using Kafka as part of a large data project team
Performing Kafka developer and admin tasks