Data is getting bigger, arriving faster, and coming in varied formats—and it all needs to be processed at scale for analytics or machine learning. How can you process such varied data workloads efficiently? Enter Apache Spark.
Updated to emphasize new features in Spark 2.x., this second edition shows data engineers and scientists why structure and unification in Spark matters. Specifically, this book explains how to perform simple and complex data analytics and employ machine-learning algorithms. Through discourse, code snippets, and notebooks, you’ll be able to:
Learn Python, SQL, Scala, or Java high-level APIs: DataFrames and Datasets
Peek under the hood of the Spark SQL engine to understand Spark transformations and performance
Inspect, tune, and debug your Spark operations with Spark configurations and Spark UI
Connect to data sources: JSON, Parquet, CSV, Avro, ORC, Hive, S3, or Kafka
Perform analytics on batch and streaming data using Structured Streaming
Build reliable data pipelines with open source Delta Lake and Spark
Develop machine learning pipelines with MLlib and productionize models using MLflow
Use open source Pandas framework Koalas and Spark for data transformation and feature engineering

Grokking Streaming Systems helps you unravel what streaming systems are, how they work, and whether they’re right for your business. Written to be tool-agnostic, you’ll be able to apply what you learn no matter which framework you choose. You’ll start with the key concepts and then work your way through increasingly complex examples, including tracking a real-time count of IoT sensor events and detecting fraudulent credit card transactions in real-time. You’ll even be able to easily experiment with your own streaming system, by downloading the custom-built and super-simplified streaming framework designed for this book. By the time you’re done, you’ll be able to easily assess the capabilities of streaming frameworks, and solve common challenges that arise when building streaming systems.
what's inside
Implement and troubleshoot streaming systems
Design streaming systems for complex functionalities
Assess parallelization requirements
Spot networking bottlenecks and resolve back pressures
Group data for high-performance systems
Handle delayed events in real-time systems

在当今整个中国社会都处于互联网转型的浪潮中，不管是政府职能单位、业务规模庞大的央企，还是面临最激烈竞争的零售行业都处于一个重要的转折点，这个转折对企业业务模式带来了冲击，当然也给企业的信息中心部门带来了挑战：如何构建IT系统架构更好地满足互联网时代下企业业务发展的需要。阿里巴巴的共享服务理念以及企业级互联网架构建设的思路，给这些企业带来了不少新的思路，这也是我最终决定写这本书的最主要原因。本书从阿里巴巴启动中台战略说起，详细阐述了共享服务理念给企业业务发展带来的业务价值。接着会分享阿里巴巴在建设共享服务体系时如何进行技术框架的选择，哪些重要的技术平台支撑起了共享服务体系，这也是迄今为止对阿里巴巴集团中间件体系对外最全面系统的介绍。除了技术层面之外，本书还分享了阿里巴巴内部的一些经验和实践，如组织的架构和体制如何更好地支持共享服务体系的持续发展。

本书全面系统地介绍SpringCloud及其在微服务架构中的应用。全书共13章，第1章介绍微服务架构相关的基本概念；第2章介绍SpringCloud中包含的组件以SpringCloud约定的上下文；第3章介绍SpringCloud的基础：SpringBoot，包括如何构建一个SpringBoot服务、SpringBoot的配置文件和Actuator提供的监控管理端点；第4至第13章详细讲解SpringCloud组件，包括：Eureka（服务注册与发现）、OpenFeign（声明式Restful客户端）、Hystrix（断路器）、Ribbon（客户端负载均衡器）、Gateway（API网关）、Config（配置中心)、Stream（消息驱动）、Bus（消息总线）、Security（认证与授权）、Sleuth（服务链路追踪）。本书为读者揭开了SpringCloud组件实现的技术内幕，并提供了进阶应用的思路，可以作为使用SpringCloud进行微服务架构实践的参考书。

《架构修炼之道——亿级网关、平台开放、分布式、微服务、容错等核心技术修炼实践》结合实际的生产实践，分别对网关、平台开放、分布式、MQ、RPC、I/O、微服务、容错的内容做了详细介绍。其中的内容不限于概念，而是会下沉到实践背后的感悟与总结。比如本书详细阐述了网关系统是如何“抗量”，又是如何容错的，以及在每次大促中的备战经验。其他内容也是如此，基于实践，源于实践，比如微服务的实战案例、MQ的各种功能场景、消息推送的实践等讲的皆是实践之道。希望读者可以通过《架构修炼之道——亿级网关、平台开放、分布式、微服务、容错等核心技术修炼实践》了解互联网常用架构知识背后的原理及解决问题之道。
《架构修炼之道——亿级网关、平台开放、分布式、微服务、容错等核心技术修炼实践》中介绍的网关、分布式、MQ等知识背后的原理，对于每一位互联网研发人员都有很大的参考意义。

微服务和Docker容器技术是目前分布式架构中常用的主流技术，结合Kubernetes强大的容器服务编排与调度能力，中小企业能够简单快速地构建自己的分布式互联网架构系统。本书结合实际生产项目的架构重构过程和经验，详细介绍从单体架构过渡到微服务容器化的分布式架构的各个方面，主要包括微服务开发和运维技术栈的选型、Spring Cloud微服务开发、Rancher和Kubernetes生产离线环境下的安装与部署、微服务的容器化与服务编排、日志调用链的采集和展示、基于Prometheus的系统监控，以及微服务的持续集成等要点。本书基于Spring Boot、Spring Cloud、Docker、Rancher、Kubernetes等技术，主要提供从设计、开发、部署到运维的微服务容器化的生产环境整体解决方案。
《微服务容器化开发实战》内容通俗易懂，每章都结合实际生产项目进行讲解，特别适合将Spring Cloud、Docker和Kubernetes等技术应用到生产中的技术管理人员、架构师与开发人员阅读，也适合微服务、容器化的入门读者阅读。本书还可作为微服务、容器化的运维人员，以及对相关技术感兴趣的人员的参考用书

Learn Kubernetes in a Month of Lunches is a task-focused guide to getting up and running with Kubernetes—fast! Following a proven and popular teaching approach honed by author Elton Stoneman, you'll progress quickly from the basics to production deployment. Each lesson is focused on practical ways to apply Kubernetes, including portable apps that work anywhere Kubernetes runs and how to run different architectures on a single cluster. All patterns are easy to apply to your own projects whatever your background. Sample apps demonstrate Kubernetes for .NET, Java, Go, or Node.JS, on varied architectures including small and large applications, monoliths and microservices, and both stateful and stateless components. By the time you’re done, you’ll be able to use Kubernetes as the platform for multiple application types, from legacy apps to serverless functions.
what's inside
Deploying and manage applications on Kubernetes clusters
Defining applications in Kubernetes YAML format
Kubernetes app lifecycle, from packaging to rollbacks
Self-healing and scalable apps
Securing a Kubernetes cluster
Using Kubernetes as a platform for new technologies
Exercises introducing all new concepts

Getting Started with Kubernetes: With examples in Google Kubernetes Engine is a hands-on guide to taking your first steps into Kubernetes using the powerful Google Kubernetes Engine service. It lays out a map for taking an application, containerizing it, and then deploying it onto Kubernetes. You’ll learn best practice techniques for a stable and long-term Kubernetes deployment, including scaling and capacity planning, saving money by optimizing resource consumption, and tricks to make your day-to-day monitoring easier such as debugging code in the cloud. Kubernetes is the future of app development, so make sure you’re ahead of the curve —get started with Kubernetes today!
what's inside
Benefits of switching to Kubernetes
Containerize a web application with Docker
Host a containerized app on Kubernetes with a public cloud service
Save money and improve performance with cloud native technologies
Make your deployments reliable and fault tolerant without constant monitoring and intervention
Prepare your deployments to scale without a redesign
Monitor, debug and tune application deployments on Kubernetes in the cloud

If you’re training a machine learning model but aren’t sure how to put it into production, this book will get you there. Kubeflow provides a collection of cloud native tools for different stages of a model’s lifecycle, from data exploration, feature preparation, and model training to model serving. This guide helps data scientists build production-grade machine learning implementations with Kubeflow and shows data engineers how to make models scalable and reliable.
Using examples throughout the book, authors Holden Karau, Trevor Grant, Ilan Filonenko, Richard Liu, and Boris Lublinsky explain how to use Kubeflow to train and serve your machine learning models on top of Kubernetes in the cloud or in a development environment on-premises.
Understand Kubeflow’s design, core components, and the problems it solves
Learn how to set up Kubeflow on a cloud provider or on an in-house cluster
Train models using Kubeflow with popular tools including scikit-learn, TensorFlow, and Apache Spark
Learn how to add custom stages such as serving and prediction
Keep your model up-to-date with Kubeflow Pipelines
Understand how to validate machine learning pipelines

In Chaos Engineering: Crash test your applications you’ll learn to design and execute controlled failure experiments that reveal the hidden problems in your software. Using a toolbox of open source tools, you’ll inject system-shaking failures at every level—from your Docker containers, to your Kubernetes deployment, to the UI. You’ll learn Linux monitoring for observing system metrics and evaluating your results, and even how to apply Chaos Engineering to make your human teams more reliable and resilient to handling failures. Best of all, all tools and examples come with a downloadable Linux VM image, letting you easily experiment without risk to your own systems.
what's inside
Design, run and analyze Chaos Engineering experiments
See how applications react to a database connections latency
Experiment with Docker container isolation
Test software running on Kubernetes and the platform itself
Inject failure into software running in the HVM

With over 75 million downloads per month, Spring Boot is the most widely used Java framework available. Its ease and power have revolutionized application development from monoliths to microservices. Yet Spring Boot’s simplicity can also be confusing. How do developers learn enough to be productive immediately? This practical book shows you how to use this framework to write successful mission-critical applications.
Mark Heckler from VMware, the company behind Spring, guides you through Spring Boot’s architecture and approach, along with topics such as debugging, testing, and deployment. If you want to develop cloud native Java or Kotlin applications with Spring Boot rapidly and effectively—using reactive programming, building APIs, and creating database access of all kinds—this book is for you.
Learn how Spring Boot simplifies cloud native application development and deployment
Build reactive applications and extend communication across the network boundary to create distributed systems
Understand how Spring Boot’s architecture and approach increases developer productivity and application portability
Deploy Spring Boot applications for production workloads rapidly and reliably
Monitor application and system health for optimal performance and reliability
Debug, test, and secure cloud-based applications painlessly

The AWS Certified Developer Associate certification demonstrates your expertise in developing, deploying, and maintaining applications on the world’s leading cloud platform, Amazon Web Services. AWS Certified Developer Associate Cert Guide is the comprehensive self-study resource for the updated version of Amazon’s valuable new exam.
Designed for all AWS Certified Developer Associate candidates, this guide covers every exam objective concisely and logically, with extensive teaching features designed to promote retention and understanding. You’ll find:
Hands-on labs you can perform with a free AWS account
Real-world examples throughout
Pre-chapter quizzes to assess knowledge upfront, and efficiently focus your study
Foundation topics sections that explain concepts and configurations, and link theory to practice
Key topics sections calling attention to every figure, table, and list you must know
Exam Preparation sections with additional chapter review features
Final preparation chapter with tools and resources to help you craft review and test-taking strategies and optimize study time
A customizable practice test library
This guide’s comprehensive, developer-focused, real-world coverage addresses all exam topics related to:
AWS authentication, identity and access management
Computing services
Data storage, processing, and transformation
AWS developer tools
DevOps: CI/CD in the cloud
AWS Cloud9 and CodeStar
Migrating, refactoring, monitoring, and troubleshooting AWS code

Building RESTful web services can be tough as there are countless standards and ways to develop API. In modern architectures such as microservices, RESTful APIs are common in communication, making idiomatic and scalable API development crucial. This book covers basic through to advanced API development concepts and supporting tools.
You'll start with an introduction to REST API development before moving on to building the essential blocks for working with Go. You'll explore routers, middleware, and available open source web development solutions in Go to create robust APIs, and understand the application and database layers to build RESTful web services. You'll learn various data formats like protocol buffers and JSON, and understand how to serve them over HTTP and gRPC. After covering advanced topics such as asynchronous API design and GraphQL for building scalable web services, you'll discover how microservices can benefit from REST. You'll also explore packaging artifacts in the form of containers and understand how to set up an ideal deployment ecosystem for web services. Finally, you'll cover the provisioning of infrastructure using infrastructure as code (IaC) and secure your REST API.
By the end of the book, you'll have intermediate knowledge of web service development and be able to apply the skills you've learned in a practical way.
What you will learn
Explore the fundamentals of API development and web services
Understand the various building blocks of API development in Go
Use superior open source solutions for representational state transfer (REST) API development
Scale a service using microservices and asynchronous design patterns
Deliver containerized artifacts to the Amazon Web Services (AWS) Cloud
Get to grips with API security and its implementation

The Tao of Microservices guides you on the path to understanding and building microservices. Based on the invaluable experience of microservices guru Richard Rodger, this book exposes the thinking behind microservice designs. You'll master individual concepts like asynchronous messaging, service APIs, and encapsulation as you learn to apply microservices architecture to real-world projects. Along the way, you'll dig deep into detailed case studies with source code and documentation and explore best practices for team development, planning for change, and tool choice.
what's inside
Principles of the microservice architecture
Breaking down real-world case studies
Implementing large-scale systems
When not to use microservices

Secure, monitor, and test your cloud-native applications using the Service Mesh architecture
Key Features
Manage your cloud-native applications with ease using the service mesh architecture
Learn about Istio, Linkerd, and Consul - the three primary open-source service mesh providers
Includes tips and best practices for building secure, high-performance microservices
Book Description
A microservices-based application helps DevOps and continuous delivery, but it adds the complexity of testing and observability. Implementation of a service mesh architecture allows you to secure, manage, and scale your microservices more efficiently. Through practical examples, this book shows you how to install, configure and deploy an efficient service mesh for microservices in a Kubernetes environment.
With this book, you will get a hands-on introduction to the concept of cloud-native application management and the service mesh architecture. It introduces you to three major service mesh providers, namely Istio, Linkerd, and Consul. You will explore their capabilities such as traffic management, monitoring, security, telemetry, certificate authority, sidecar injections, observability and many more.
By the end of this book, you will develop the necessary skills to manage modern microservices-based applications.
What you will learn
Learn Service Mesh control and data plane concepts
Learn about the service mesh architecture with hands-on examples
Compare Istio, Linkerd, and Consul
Differentiate capabilities for the three service mesh providers
Develop and manage your microservices applications with ease
Explore Service Mesh features like Traffic management, Service discovery, Resiliency and many more
Who This Book Is For
The book is for solution architects, network administrators, as well as DevOps and site reliability engineers who are new to the cloud native framework. This book will help the audience to pursue a lucrative career in DevOps and especially Operations. A high-level understanding of Kubernetes and cloud-native microservices knowledge is preferred to get the most out of this book.

Spring Security in Action shows you how to use Spring Security to create applications you can be confident will withstand even the most dedicated attacks. Starting with essential “secure by design” principles, you’ll learn common software vulnerabilities and how to avoid them right from the design stage. Through hands-on projects, including a web application and a microservices architecture, you’ll learn to manage system users, configure secure endpoints, and use, OAuth2 and OpenID Connect for authentication and authorization. As you go, you’ll learn how to adapt Spring Security to different architectures, such as configuring Spring Security for Reactive applications and container-based applications orchestrated with Kubernetes. When you’re done, you’ll have a complete understanding of how to use Spring Security to protect your Java enterprise applications from common threats and attacks.
what's inside
The principles of secure by design
The architecture of Spring Security
Spring Security contracts for password encoding, cryptography, and authentication
Applying Spring Security to different architecture styles

Bring agility, cost savings, and a competitive edge to your business by migrating your IT infrastructure to AWS. Ideal for executive leadership, senior leadership, and engineering and IT managers, this practical book examines the advantages, disadvantages, and common pitfalls possible when moving your operations to the cloud.
Author Jeff Armstrong brings years of practical hands-on experience helping dozens of enterprises make this corporate change. You’ll explore real-world examples of how organizations have made—or attempted to make—this wide-ranging transition. With this guide, you’ll be better prepared to objectively evaluate your migration before, during, and after the process so you can ensure success.
By the end of this book, you’ll understand:
Benefits and drawbacks of migrating to AWS
Risks to your business and technology
Methods for properly accessing workloads
How to build a business case for this move
How to create a solid migration plan
How to identify low hanging fruit for refactoring

In a microservices architecture, the whole is indeed greater than the sum of its parts. But in practice, individual microservices can inadvertently impact others and alter the end user experience. Effective microservices architectures require standardization on an organizational level with the help of a platform engineering team.
This practical book provides a series of progressive steps that platform engineers can apply technically and organizationally to achieve highly resilient Java applications. Author Jon Schneider covers many effective SRE practices from companies leading the way in microservices adoption. You’ll examine several patterns that were created after much trial and error in recent years, complete with Java code examples.
Chapters are organized according to specific patterns, including:
Application Metrics: Availability, debuggability, and Micrometer
Debugging with observability: Three pillars of observability; components of a distributed trace
Charting and alerting: Building effective charts; KPIs for Java microservices
Safe multi-cloud delivery: Automated canary analysis
Source code observability: The problem of dependencies; API utilization
Traffic management: Concurrency of systems; platform, gateway, and client-side load balancing

Dominated by streaming data and events, the next generation of software development optimizes not only how technology interacts but also how businesses integrate with one another to meet customer needs. This phenomenon, called flow, consists of patterns and standards that determine which activity and related data is communicated between parties over the internet.
This book explores the critical implications of that evolution: What happens when event and data stream standards help you discover new activity sources to enhance existing businesses or drive new markets? What technologies and architectural patterns can position your company for opportunities enabled by flow?
James Urquhart, global field CTO at Pivotal Cloud Foundry, guides enterprise architects, software developers, and product managers through:
The business imperative for flow
Why worldwide flow is likely to happen
The factors that will enable flow in next 5–10 years
What you can do to take advantage of worldwide flow as it evolves
A Wardley map exploration that shows why worldwide flow is predictable