Continuous Delivery in Java 1st edition by Daniel Bryant, Abraham Marín Pérez ISBN 1491986026 978-1491986028

1. Continuous Delivery: Why and What

Setting the Scene

Enabling Developers: The Why

Rapid Feedback Reduces Context Switching

Automatic, Repeatable, and Reliable Releases

Codifying the Definition of “Done”

Exploring a Typical Build Pipeline: The What

Core Build Pipeline Stages

Impact of Container Technology

Changes with Contemporary Architectures

Summary

2. Evolution of Java Development

Requirements of Modern Java Applications

Need for Business Speed and Stability

Rise of the API Economy

Opportunities and Costs of the Cloud

Modularity Redux: Embracing Small Services

Impact on Continuous Delivery

Evolution of Java Deployment Platforms

WARs and EARs: The Era of Application Server Dominance

Executable Fat JARs: Emergence of Twelve-Factor Apps

Container Images: Increasing Portability (and Complexity)

Function as a Service: The Emergence of “Serverless”

Impact of Platforms on Continuous Delivery

DevOps, SRE, and Release Engineering

Development and Operations

Site Reliability Engineering

Release Engineering

Shared Responsibility, Metrics, and Observability

Summary

3. Designing Architecture for Continuous Delivery

Fundamentals of Good Architecture

Loose Coupling

High Cohesion

Coupling, Cohesion, and Continuous Delivery

Architecture for Business Agility

Bad Architecture Limits Business Velocity

Complexity and Cost of Change

Best Practices for API-Driven Applications

Build APIs “Outside-In”

Good APIs Assist Continuous Testing and Delivery

Deployment Platforms and Architecture

Designing Cloud-Native “Twelve-Factor” Applications

Cultivating Mechanical Sympathy

Design and Continually Test for Failure

The Move Toward Small Services

Challenges for Delivering Monolithic Applications

Microservices: SOA Meets Domain-Driven Design

Functions, Lambdas, and Nanoservices

Architecture: “The Stuff That’s Hard to Change”

Summary

4. Deployment Platforms, Infrastructure, and Continuous Delivery of Java Apps

Functionality Provided by a Platform

Essential Development Processes

Traditional Infrastructure Platforms

Traditional Platform Components

Challenges with Traditional Infrastructure Platforms

Benefits of Being Traditional

CI/CD on Traditional Infrastructure Platforms

Cloud (IaaS) Platform

Looking Inside the Cloud

Cloud Challenges

Benefits of the Cloud

Continuously Delivering into the Cloud

Platform as a Service

Peeking Inside a PaaS

PaaS Challenges

Benefits of PaaS

CI/CD and PaaS

Containers (Docker)

Container Platform Components

Container Challenges

Container Benefits

Continuously Delivering Containers

Kubernetes

Core Concepts of Kubernetes

Kubernetes Challenges

Benefits of Kubernetes

Continuous Delivery on Kubernetes

Function-as-a-Service/Serverless Functions

FaaS Concepts

Challenges of FaaS

FaaS Benefits

CI/CD and FaaS

Working with Infrastructure as Code

Summary

5. Building Java Applications

Breaking Down the Build Process

Automating the Build

Build Dependencies

External Dependencies

Multimodule Projects

Multiple Repositories (or a Monorepo)?

Plugins

Releasing and Publishing Artifacts

Java Build Tooling Overview

Ant

Maven

Gradle

Bazel, Pants, and Buck

Other JVM Build Tools: SBT and Leiningen

Make

Choosing a Build Tool

Summary

6. Additional Build Tooling and Skills

Linux, Bash, and Basic CLI Commands

Users, Permissions, and Groups

Working with the Filesystem

Viewing and Editing Text

Joining Everything Together: Redirects, Pipes, and Filters

Searching and Manipulating Text: grep, awk, and sed

Diagnostic Tooling: top, ps, netstat, and iostat

HTTP Calls and JSON Manipulation

curl

HTTPie

jq

Basic Scripting

xargs

Pipes and Filters

Loops

Conditionals

Summary

7. Packaging Applications for Deployment

Building a JAR: Step-by-Step

Building a Fat Executable “Uber” JAR

Maven Shade Plugin

Building Spring Boot Uber JARs

Skinny JARs—Deciding Not to Build Fat JARs

Building WAR Files

Packaging for the Cloud

Cooking Configuration: Baking or Frying Machines

Building RPMs and DEBs OS Packages

Additional OS Package Build Tools (with Windows Support)

Creating Machine Images for Multiple Clouds with Packer

Additional Tools for Creating Machine Images

Building Containers

Creating Container Images with Docker

Fabricating Docker Images with fabric8

Packaging FaaS Java Applications

Summary

8. Working Locally (Like It Was Production)

Challenges with Local Development

Mocking, Stubbing, and Service Virtualization

Pattern #1: Profiles, Mocks, and Stubs

Mocking with Mockito

Pattern #2: Service Virtualization and API Simulation

Virtualizing Services with Hoverfly

VMs: Vagrant and Packer

Installing Vagrant

Creating a Vagrantfile

Pattern #3: Production-in-a-Box

Containers: Kubernetes, minikube, and Telepresence

Introducing the “Docker Java Shop” Sample App

Building Java Applications and Container Images

Deploying into Kubernetes

Simple Smoke Test

Building the Remaining Applications

Deploying the Entire Java Application in Kubernetes

Viewing the Deployed Application

Telepresence: Working Remotely, Locally

Pattern #4: Environment Leasing

FaaS: AWS Lamba and SAM Local

Installing SAM Local

AWS Lambda Scaffolding

Testing AWS Lambda Event Handling

Smoke Testing with SAM Local

FaaS: Azure Functions and VS Code

Installing Azure Function Core Tools

Building and Testing Locally

Testing Remotely, Locally Using VS Code

Summary

9. Continuous Integration: The First Steps in Creating a Build Pipeline

Why Continuous Integration?

Implementing CI

Centralized Versus Distributed Version-Control Systems

Git Primer

Core Git CLI Commands

Hub: An Essential Tool for Git and GitHub

Working Effectively with DVCS

Trunk-based Development

Feature Branching

Gitflow

No One-Size Fits All: How to Choose a Branching Strategy

Code Reviews

What to Look For

Automation: PMD, Checkstyle, and FindBugs

Reviewing Pull Requests

Automating Builds

Jenkins

Getting Your Team Onboard

Merge Code Regularly

“Stop the Line!”: Managing Broken Builds

Don’t @Ignore Tests

Keep the Build Fast

CI of the Platform (Infrastructure as Code)

Summary

10. Deploying and Releasing from the Pipeline

Introducing the Extended Java Shop Application

Separating Deployment and Release

Deploying Applications

Creating a Container Image

Deployment Mechanisms

It All Starts (and Ends) with Health Checks

Deployment Strategies

Working with Unmanaged Clusters

Changing Databases

Releasing Functionality

Feature Flags

Semantic Versioning (semver)

Backward Compatibility and Versions in APIs

Multiple-Phase Upgrades

Managing Configuration and Secrets

“Baked-In” Configuration

Externalized Configuration

Handling Secrets

Summary

11. Functional Testing: Correctness and Acceptance

Why Test Software?

What to Test? Introducing Agile Testing Quadrants

Continuous Testing

Building the Right Feedback Loop

Turtles All the Way Down

Synthetic Transactions

End-to-End Testing

Acceptance Testing

Behavior-Driven Development

Stubbing or Virtualizing Third-Party Services

Bringing It All Together

Consumer-Driven Contracts

RESTful API Contracts

Message Contracts

Component Testing

Embedded Data Stores

In-Memory Message Queues

Test Doubles

Creating Internal Resources/Interfaces

In-Process Versus Out-Of-Process

Integration Testing

Verifying External Interactions

Testing Fault Tolerance

Unit Testing

Sociable Unit Testing

Solitary Unit Testing

Dealing with Flaky Tests

Data

Resource That Is Not Available Yet

Nondeterministic Events

If Nothing Else Works

Testing Outside-In Versus Testing Inside-Out

Outside-In

Inside-Out

Putting It All Together Within the Pipeline

How Much Testing Is Enough?

Summary

12. System-Quality Attributes Testing: Validating Nonfunctional Requirements

Why Test Nonfunctional Requirements?

Code Quality

Architectural Quality

ArchUnit: Unit-Testing Architecture

Generate Design-Quality Metrics with JDepend

Performance and Load Testing

Basic Performance Testing with Apache Benchmark

Load Testing with Gatling

Security, Vulnerabilities, and Threats

Code-Level Security Verification

Dependency Verification

Deployment Platform-Specific Security Issues

Next Steps: Threat Modeling

Chaos Testing

Causing Chaos in Production (Bring in the Monkeys)

Causing Chaos in Preproduction

How Much NFR Testing Is Enough?

Summary

13. Observability: Monitoring, Logging, and Tracing

Observability and Continuous Delivery

Why Observe?

What to Observe: Application, Network, and Machine

How to Observe: Monitoring, Logging, and Tracing

Alerting

Designing Systems for Observability

Metrics

Type of Metrics

Dropwizard Metrics

Spring Boot Actuator

Micrometer

Best Practices with Metrics

Logging

Forms of Logging

SLF4J

Log4j 2

Logging Best Practices

Request Tracing

Traces, Spans, and Baggage

Java Tracing: OpenZipkin, Spring Sleuth, and OpenCensus

Recommended Practices for Tracing

Exception Tracking

Airbrake

System-Monitoring Tooling

collectd

rsyslog

Sensu

Collection and Storage

Prometheus

Elastic-Logstash-Kibana

Visualization

Visualization for Business

Operational Visualization

Visualization for Developers

Summary

14. Migrating to Continuous Delivery

Continuous Delivery Capabilities

Picking Your Migration Project

Situational Awareness

The Cynefin Framework and Continuous Delivery

All Models Are Wrong, Some Are Useful

Bootstrapping Continuous Delivery

Measuring Continuous Delivery

Start Small, Experiment, Learn, Share, and Repeat

Increase Adoption: Leading Change

Additional Guidance and Tips

Bad Practices and Common Antipatterns

Ugly Architecture: To Fix, or Not to Fix

Summary

15. Continuous Delivery and Continuous Improvement

Start from Where You Are

Build on Solid Technical Foundations

Continuously Deliver Value (Your Highest Priority)

Increase Shared Responsibility of Software

Promote Fast Feedback and Experimentation

Expand Continuous Delivery in an Organization

Continuous Improvement

Summary

Index