Seriously Good Software takes you on a journey through software development best practices as you develop a simple inefficient implementation into a robust, professional-quality application. The deceptively-simple problem—balancing water levels in multiple connected containers—presents some interesting complexities as you optimize the code for speed, efficiency, and durability. Author Marco Faella’s passion for teaching shines bright as you learn to assess performance and write thread-safe code that’s easily readable, testable, and maintainable. Along the way, you’ll gain a keen sense of the trade-offs inherent to every programming task, no matter how simple.
Each chapter contains hands-on exercises with complete, clear solutions that relate the techniques to real-world applications. Occasional pop quizzes ensure you’ve got a firm grasp on the concepts as you go along. When you’re done with this book, evaluating software qualities, considering tradeoffs and operational constraints, and asking all the right questions will be a reflex!
what's inside
Evaluating software qualities
Distinguishing between qualities that are internal, external, functional, and non-functional
Assessing tradeoffs and interactions between software qualities
Fulfilling different quality objectives for a single unifying task
Hands-on exercises and detailed solutions
Exercises covering the inner workings of the Java API

Learn dbatools in a Month of Lunches is a practical hands-on guide to automating SQL Server with PowerShell and the awesome dbatools module. You’ll master techniques you can immediately put into practice, from daily duties like backups and restores right through to performing security audits. Stabilize and standardize your SQL server environment, and simplify your tasks by building automation, alerting, and reporting with this powerful tool. Each lesson delivers another skill that you can use to speed through your core tasks as a SQL Server DBA!
what's inside
Installing dbatools in secure environments
Bulk-import any type of data into SQL Server
Instance-to-instance and customized migrations
Schedule and monitor PowerShell tasks in SQL Server Agent

Book Description
Microservices architecture allows developers to build and maintain applications with ease, and enterprises are rapidly adopting it to build software using Spring Boot as their default framework. With this book, you'll learn how to efficiently build and deploy microservices using Spring Boot.
This microservices book will take you through tried and tested approaches to building distributed systems and implementing microservices architecture in your organization. Starting with a set of simple cooperating microservices developed using Spring Boot, you'll learn how you can add functionalities such as persistence, make your microservices reactive, and describe their APIs using Swagger/OpenAPI. As you advance, you'll understand how to add different services from Spring Cloud to your microservice system. The book also demonstrates how to deploy your microservices using Kubernetes and manage them with Istio for improved security and traffic management. Finally, you'll explore centralized log management using the EFK stack and monitor microservices using Prometheus and Grafana.
By the end of this book, you'll be able to build microservices that are scalable and robust using Spring Boot and Spring Cloud.
What you will learn
Build reactive microservices using Spring Boot
Develop resilient and scalable microservices using Spring Cloud
Use OAuth 2.0/OIDC and Spring Security to protect public APIs
Implement Docker to bridge the gap between development, testing, and production
Deploy and manage microservices using Kubernetes
Apply Istio for improved security, observability, and traffic management

The world’s most valuable resource is data. Companies across all industry verticals are using data-driven insights as a key competitive advantage. But the time required for transforming raw data to insights can take days or weeks when you want it in minutes or hours. Data scientists spend nearly 80% of their time in data engineering, rather than developing insights. And most organizations can't scale their data science teams fast enough to keep up with growing business needs for better, faster insights.
This book will help data engineers, data scientists, and data team managers address these issues by building a self-service data science platform that democratizes the ability to extract insights from the data to everyone in the organization. Data scientists, software engineers, product managers, and marketers can use it to discover, transform, and analyze data and publish automated insights in production.
This book is not:
A deep dive into the “shiny new” technologies, or any one specific technology
A silver bullet technology for building a self-service portal. Organizations differ in their maturity, people, process, and technology and require tailored solutions
This book is:
A collection of must-have operational capabilities for building a self-service data portal
A blueprint for achieving better and faster insights
A process for democratizing data engineering expertise across an organization
A practical and indispensable guide for any decision-maker, implementer, or strategist working with an organization’s data science platform

Penetrating Enterprise Networks is a hands-on guide to running your own penetration test on an enterprise network. After setting up a virtual environment to use as your lab, you’ll work step-by-step through every stage of a professional pentest, from information gathering to seizing control of a vulnerable system. You’ll learn a repeatable process you can use to identify valuable targets within a typical enterprise environment, perform controlled exploitation of critical security weaknesses, elevate network level privileges, and pivot laterally through the network. Finally, you’ll learn how to write up your findings in a clear and actionable report, to ensure a system can be protected against the weaknesses you’ve identified.
what's inside
Set up a virtual pentest lab using Ubuntu Linux
Identify internal weaknesses on compromised systems
Exploit network vulnerabilities to compromise Windows and Linux
Establish persistent re-entry back into compromised targets
Elevate your privileges to become a domain administrator

Create database designs that scale, meet business requirements, and inherently work toward keeping your data structured and usable in the face of changing business models and software systems.
This book is about database design theory. Design theory is the scientific foundation for database design, just as the relational model is the scientific foundation for database technology in general. Databases lie at the heart of so much of what we do in the computing world that negative impacts of poor design can be extraordinarily widespread.
This second edition includes greatly expanded coverage of exotic and little understood normal forms such as: essential tuple normal form (ETNF), redundancy free normal form (RFNF), superkey normal form (SKNF), sixth normal form (6NF), and domain key normal form (DKNF). Also included are new appendixes, including one that provides an in-depth look into the crucial notion of data consistency. Sequencing of topics has been improved, and many explanations and examples have been rewritten and clarified based upon the author’s teaching of the content in instructor-led courses.
This book aims to be different from other books on design by bridging the gap between the theory of design and the practice of design. The book explains theory in a way that practitioners should be able to understand, and it explains why that theory is of considerable practical importance. Reading this book provides you with an important theoretical grounding on which to do the practical work of database design. Reading the book also helps you in going to and understanding the more academic texts as you build your base of knowledge and expertise. Anyone with a professional interest in database design can benefit from using this book as a stepping-stone toward a more rigorous design approach and more lasting database models.
What You Will Learn
Understand what design theory is and is not
Be aware of the two different goals of normalization
Know which normal forms are truly significant
Apply design theory in practice
Be familiar with techniques for dealing with redundancy
Understand what consistency is and why it is crucially important

并发编程相比 Java 中其他知识点的学习门槛较高，从而导致很多人望而却步。但无论是职场面试，还是高并发/ 高流量系统的实现，却都离不开并发编程，于是能够真正掌握并发编程的人成为了市场迫切需求的人才。
《Java并发编程之美》通过图文结合、通俗易懂的讲解方式帮助大家完成多线程并发编程从入门到实践的飞跃！《Java并发编程之美》分为三部分，第一部分为Java 并发编程基础篇，主要讲解Java 并发编程的基础知识、线程有关的知识和并发编程中的其他相关概念，这些知识在高级篇都会有所使用，掌握了本篇的内容，就为学习高级篇奠定了基础；第二部分为Java 并发编程高级篇，讲解了Java 并发包中核心组件的实现原理，让读者知其然，也知其所以然，熟练掌握本篇内容，对我们在日常开发高并发、高流量的系统时会大有裨益；第三部分为Java 并发编程实践篇，主要讲解并发组件的使用方法，以及在使用过程中容易遇到的问题和解决方法。
《Java并发编程之美》适合Java 初级、中高级研发工程师，对Java 并发编程感兴趣，以及希望探究JUC 包源码原理的人员阅读。

In Designing Cloud Data Platforms, you’ll learn how to integrate data from multiple sources into a single, cloud-based, modern data platform. Drawing on their real-world experiences designing cloud data platforms for dozens of organizations, cloud data experts Danil Zburivsky and Lynda Partner take you through a six-layer approach to creating cloud data platforms that maximizes flexibility and manageability and reduces costs. Starting with foundational principles, you’ll learn how to get data into your platform from different databases, files, and APIs, the essential practices for organizing and processing that raw data, and how to best take advantage of the services offered by major cloud vendors. As you progress past the basics you’ll take a deep dive into advanced topics to get the most out of your data platform, including real-time data management, machine learning analytics, schema management, and more.
what's inside
The tools of different public cloud for implementing data platforms
Best practices for managing structured and unstructured data sets
Machine learning tools that can be used on top of the cloud
Cost optimization techniques

Fully updated and upgrade for the latest version of Spring, Spring Microservices in Action, Second Edition is an expanded revision of a Manning bestseller. In it, you’ll learn how to build microservice-based applications using Java and the Spring platform and how to efficiently monitor and log your microservices operations. 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 microservices and how Spring Cloud Gateway makes it easy to handle multiple APIs with a single tool. You’ll also pick up best practices for using Spring with modern deployment platforms based on Kubernetes and Istio.
what's inside
Core microservice design principles
Microservices best practices
Using docker containers to run microservices
Managing configuration with Spring Cloud Config and Hashicorp Vault for sensitive information
Client-side resiliency with Hystrix, and Ribbon
Managing application metrics with Prometheus and Grafana
Intelligent routing using Spring Cloud Gateway
Distributed tracing with Spring Cloud Sleuth, Zipkin and ELK Stack
Deploying Spring Cloud applications with Kubernetes and Istio

Many organizations are running applications in cloud native environments, using containers and orchestration to facilitate scalability and resilience. But how do you know whether your deployment is secure? To fully grasp the security implications of containers and their operation, you need an understanding of what they are and how they work.
This practical book dives into the underlying technologies and components that these systems rely on to leave you better equipped to assess the security risks and potential solutions applicable to your environment. Author Liz Rice explores the building blocks and security boundaries commonly used in container-based systems and how they’re constructed in Linux.

PySpark in Action is a carefully engineered tutorial that helps you use PySpark to deliver your data-driven applications at any scale. This clear and hands-on guide shows you how to enlarge your processing capabilities across multiple machines with data from any source, ranging from Hadoop-based clusters to Excel worksheets. You’ll learn how to break down big analysis tasks into manageable chunks and how to choose and use the best PySpark data abstraction for your unique needs. By the time you’re done, you’ll be able to write and run incredibly fast PySpark programs that are scalable, efficient to operate, and easy to debug.
what's inside
Packaging your PySpark code
Managing your data as it scales across multiple machines
Re-writing Pandas, R, and SAS jobs in PySpark
Troubleshooting common data pipeline problems
Creating reliable long-running jobs

本书以图配文，详细说明了服务器端网络架构的基础技术和设计要点。基础设计是服务器端网络架构最重要的一个阶段。本书就立足于基础设计的设计细分项目，详细介绍各细分项目的相关技术和设计要点。全书共分为5章，分别讲述进行物理设计、逻辑设计、安全设计和负载均衡设计、高可用性设计以及管理设计时所必需的技术和设计要点。

API Security in Action shows you how to create secure web APIs that you can confidently share with your business partners and expose for public usage. Security expert Neil Madden takes you under the hood of modern API security concepts, including token-based authentication for flexible multi-user security, bootstrapping a secure environment in a Kubernetes microservices architecture, and using lightweight cryptography to secure an IoT device. Chapter-by-chapter, you’ll build new layers of security onto a basic social network API, mastering techniques to protect against increasingly complex threat models and hostile environments. When you’re done, you’ll have the practical skills to design and implement APIs that are safe from most common attacks and are ready for the threats of tomorrow.
what's inside
The main API security controls: authentication, authorization, audit logging, rate limiting, and encryption
Token-based authentication in web browsers and mobile clients
Cloud Key Management Services in a Kubernetes environment
Delegated authorization using OAuth 2.0

The command-line interface is making a comeback. That's because developers know that all the best features of your operating system are hidden behind a user interface designed to help average people use the computer. But you're not the average user, and the CLI is the most efficient way to get work done fast. Turn tedious chores into quick tasks: read and write files, manage complex directory hierarchies, perform network diagnostics, download files, work with APIs, and combine individual programs to create your own workflows. Put down that mouse, open the CLI, and take control of your software development environment.
No matter what language or platform you're using, you can use the CLI to create projects, run servers, and manage files. You can even create new tools that fit right in with grep, sed, awk, and xargs. You'll work with the Bash shell and the most common command-line utilities available on macOS, Windows 10, and many flavors of Linux.
Create files without opening a text editor. Manage complex directory strutures and move around your entire file system without touching the mouse. Diagnose network issues and interact with APIs. Chain several commands together to transform data, and create your own scripts to automate repetitive tasks. Make things even faster by customizing your environment, creating shortcuts, and integrating other tools into your environment. Hands-on activities and exercises will cement your newfound knowledge and give you the confidence to use the CLI to its fullest potential. And if you're worried you'll wreck your system, this book walks you through creating an Ubuntu virtual machine so you can practice worry-free.
Dive into the CLI and join the thousands of other devs who use it every day.

Whether you want to automate tasks, analyze data, parse logs, talk to network services, or address other systems requirements, writing your own command-line tool may be the fastest - and perhaps the most fun - way to do it. The Go programming language is a great choice for developing tools that are fast, reliable, and cross-platform. Create command-line tools that work with files, connect to services, and even manage external processes, all while using tests and benchmarks to ensure your programs are fast and correct.
When you want to develop cross platform command-line tools that are fast and reliable, use Go, a modern programming language that combines the reliability of compiled languages with the ease of use and flexibility of dynamic typed languages. Work through practical examples to develop elegant and efficient tools by applying Go's rich standard library, its built in support for concurrency, and its expressive syntax. Use Go's integrated testing capabilities to automatically test your tools, ensuring they work reliably even across code refactoring.
Develop CLI tools that interact with your users by using common input/output patterns, including environment variables and flags. Handle files to read or persist data, and manipulate paths consistently in cross-platform scenarios. Control processes and handle signals, and use a benchmark driven approach and Go's concurrency primitives to create tools that perform well. Use powerful external libraries such as Cobra to create modern and flexible tools that handle subcommands, and develop tools that interact with databases, APIs, and network services. Finally, leverage what you learned by tackling additional challenges at the end of each chapter.
What You Need:
Go 1.8 or higher, an internet connection to download the example files and additional libraries, and a text editor to write your programs.

Key Features
Get to grips with the microservice architecture and build enterprise-ready microservice applicationsLearn design patterns and the best practices while building a microservice applicationObtain hands-on techniques and tools to create high-performing microservices resilient to possible fails
Book Description
Microservices are a hot trend in the development world right now. Many enterprises have adopted this approach to achieve agility and the continuous delivery of applications to gain a competitive advantage. This book will take you through different design patterns at different stages of the microservice application development along with their best practices.
Microservice Patterns and Best Practices starts with the learning of microservices key concepts and showing how to make the right choices while designing microservices. You will then move onto internal microservices application patterns, such as caching strategy, asynchronism, CQRS and event sourcing, circuit breaker, and bulkheads. As you progress, you'll learn the design patterns of microservices.
The book will guide you on where to use the perfect design pattern at the application development stage and how to break monolithic application into microservices. You will also be taken through the best practices and patterns involved while testing, securing, and deploying your microservice application. At the end of the book, you will easily be able to create interoperable microservices, which are testable and prepared for optimum performance.
What you will learn
How to break monolithic application into microservicesImplement caching strategies, CQRS and event sourcing, and circuit breaker patternsIncorporate different microservice design patterns, such as shared data, aggregator, proxy, and chainedUtilize consolidate testing patterns such as integration, signature, and monkey testsSecure microservices with JWT, API gateway, and single sign onDeploy microservices with continuous integration or delivery, Blue-Green deployment
Who This Book Is For
This book is for architects and senior developers who would like implement microservice design patterns in their enterprise application development. The book assumes some prior programming knowledge.
Table of Contents
Understanding the Microservice ConceptsThe Microservice ToolsInternal PatternsMicroservice EcosystemShared Data Microservice Design PatternAggregator Microservice Design PatternProxy Microservice Design PatternChained Microservice Design PatternBranch Microservice Design PatternAsynchronous Messaging Microservice Design PatternMicroservices Working TogetherTesting MicroservicesMonitoring Security, and Deployment

Kubernetes has fundamentally changed the way DevOps teams create, manage, and operate container-based applications, but as with any production process, you can never provide enough security. This practical ebook walks you through Kubernetes security features—including when to use what—and shows you how to augment those features with container image best practices and secure network communication.
Liz Rice from Aqua Security and Michael Hausenblas from Red Hat not only describe practical security techniques for Kubernetes but also maintain an accompanying website. Developers will learn how to build container images with security in mind, and ops folks will pick up techniques for configuring and operating a Kubernetes cluster more securely.
Explore security concepts including defense in depth, least privilege, and limiting the attack surface
Safeguard clusters by securing worker nodes and control plane components, such as the API server and the etcd key value store
Learn how Kubernetes uses authentication and authorization to grant fine-grained access
Secure container images against known vulnerabilities and abuse by third parties
Examine security boundaries and policy enforcement features for running containers securely
Learn about the options for handling secret information such as credentials
Delve into advanced topics such as monitoring, alerting, and auditing, as well as sandboxing and runtime protection

Kubernetes is quickly changing the way organizations deliver applications. Broadly supported by the community and a growing list of vendors, this open source platform has become a core component in the digital transformation of enterprises worldwide. Getting started with this container orchestration system can be tricky, but with this practical ebook, developers and operators will learn how to use Kubernetes to deliver existing applications—or more resilient cloud-native applications—with speed and efficiency.
Brad Topol, Jake Kitchener, and Michael Elder from IBM show you how to run stateful workloads on Kubernetes to transform the way you manage your core enterprise middleware. You’ll also learn how to configure security policies, manage auto-scaling, and integrate storage into your cluster. If you’re new to Kubernetes, you’ll gain a solid understanding of the system’s fundamental concepts. Experienced users will focus on ways to create enterprise quality Kubernetes applications in private, public, and hybrid cloud environments.
Get started with Kubernetes and enter the brave new world of automated container deployment, scaling, and management. This ebook shows you how.
Explore Kubernetes architecture, deployment options, and core concepts such as Pods, ReplicaSets, and Services
Dive into advanced capabilities such as load balancing, volume support, and configuration primitives
Create an example enterprise-level production application, complete with microservices, namespaces, a database, and a web frontend
Learn how container images and Kubernetes support DevOps and continuous delivery principles
Focus on application operations such as microservices health management and log collection and analysis
Learn why hybrid cloud environments are ideal for transitioning operations from on-premises to the cloud

Great software architects aren’t born. They are a product of decades of building real-life solutions and relentless learning. They become really good at their trade closer to the retirement age. But most startups are fostered by young entrepreneurs who dare to try but lack the experience. They also lack the $$ to hire a silver-haired architect to join their team from day one. Left to their own faculties, the entrepreneurs and their engineering teams quickly get on the path of learning from their own mistakes. Eventually, they discover this is the most expensive way of learning. Over time they get better, and some become the true masters of the craft – but way too late to make a difference for their early-day projects.This book is meant to break the vicious circle. It isn’t a textbook, at least not in the traditional sense. It is a business-centric practical guide to software architecture, intended for software engineers, technology executives, students of computer science, and tech-savvy entrepreneurs who want to de-risk their entrepreneurial endeavors or to fast-track their careers in software engineering. The recipes in this book are highly practical, battle-tested, and current for building mid- to large-scale systems in 2019.

Righting Software presents the proven, structured, and highly engineered approach to software design that renowned architect Juval Löwy has practiced and taught around the world. Although companies of every kind have successfully implemented his original design ideas across hundreds of systems, these insights have never before appeared in print.
Based on first principles in software engineering and a comprehensive set of matching tools and techniques, Löwy’s methodology integrates system design and project design. First, he describes the primary area where many software architects fail and shows how to decompose a system into smaller building blocks or services, based on volatility. Next, he shows how to flow an effective project design from the system design; how to accurately calculate the project duration, cost, and risk; and how to devise multiple execution options.
The method and principles in Righting Software apply regardless of your project and company size, technology, platform, or industry. Löwy starts the reader on a journey that addresses the critical challenges of software development today by righting software systems and projects as well as careers–and possibly the software industry as a whole. Software professionals, architects, project leads, or managers at any stage of their career will benefit greatly from this book, which provides guidance and knowledge that would otherwise take decades and many projects to acquire.