Continuous Delivery in Java

735 Pages·2018·7.2 MB·English

by  Abraham MarГ­n-PГ©rez & Daniel Bryant [Abraham MarГ­n-PГ©rez]

1. Forewords

2. Preface

a. Why Did We Write This Book?

b. Why You Should Read This Book

c. What This Book Is Not

d. Conventions Used in This Book

e. Using Code Examples

f. O’Reilly Safari

g. How to Contact Us

h. Acknowledgments

3. 1. Continuous Delivery: Why and What

a. Setting the Scene

b. Enabling Developers: The Why

i. Rapid Feedback Reduces Context Switching

ii. Automatic, Repeatable, and Reliable Releases

iii. Codifying the Definition of “Done”

c. Exploring a Typical Build Pipeline: The What

i. Core Build Pipeline Stages

ii. Impact of Container Technology

iii. Changes with Contemporary Architectures

d. Summary

4. 2. Evolution of Java Development

a. Requirements of Modern Java Applications

i. Need for Business Speed and Stability

ii. Rise of the API Economy

iii. Opportunities and Costs of the Cloud

iv. Modularity Redux: Embracing Small Services

v. Impact on Continuous Delivery

b. Evolution of Java Deployment Platforms

i. WARs and EARs: The Era of Application Server

Dominance

ii. Executable Fat JARs: Emergence of Twelve-Factor Apps

iii. Container Images: Increasing Portability (and Complexity)

iv. Function as a Service: The Emergence of “Serverless”

v. Impact of Platforms on Continuous Delivery

c. DevOps, SRE, and Release Engineering

i. Development and Operations

ii. Site Reliability Engineering

iii. Release Engineering

iv. Shared Responsibility, Metrics, and Observability

d. Summary

5. 3. Designing Architecture for Continuous Delivery

a. Fundamentals of Good Architecture

i. Loose Coupling

ii. High Cohesion

iii. Coupling, Cohesion, and Continuous Delivery

b. Architecture for Business Agility

i. Bad Architecture Limits Business Velocity

ii. Complexity and Cost of Change

c. Best Practices for API-Driven Applications

i. Build APIs “Outside-In”

ii. Good APIs Assist Continuous Testing and Delivery

d. Deployment Platforms and Architecture

i. Designing Cloud-Native “Twelve-Factor” Applications

ii. Cultivating Mechanical Sympathy

iii. Design and Continually Test for Failure

e. The Move Toward Small Services

i. Challenges for Delivering Monolithic Applications

ii. Microservices: SOA Meets Domain-Driven Design

iii. Functions, Lambdas, and Nanoservices

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

g. Summary

6. 4. Deployment Platforms, Infrastructure, and Continuous Delivery of

Java Apps

a. Functionality Provided by a Platform

b. Essential Development Processes

c. Traditional Infrastructure Platforms

i. Traditional Platform Components

ii. Challenges with Traditional Infrastructure Platforms

iii. Benefits of Being Traditional

iv. CI/CD on Traditional Infrastructure Platforms

d. Cloud (IaaS) Platform

i. Looking Inside the Cloud

ii. Cloud Challenges

iii. Benefits of the Cloud

iv. Continuously Delivering into the Cloud

e. Platform as a Service

i. Peeking Inside a PaaS

ii. PaaS Challenges

iii. Benefits of PaaS

iv. CI/CD and PaaS

f. Containers (Docker)

i. Container Platform Components

ii. Container Challenges

iii. Container Benefits

iv. Continuously Delivering Containers

g. Kubernetes

i. Core Concepts of Kubernetes

ii. Kubernetes Challenges

iii. Benefits of Kubernetes

iv. Continuous Delivery on Kubernetes

h. Functionas-a-Service/Serverless Functions

i. FaaS Concepts

ii. Challenges of FaaS

iii. FaaS Benefits

iv. CI/CD and FaaS

i. Working with Infrastructure as Code

j. Summary

7. 5. Building Java Applications

a. Breaking Down the Build Process

b. Automating the Build

i. Build Dependencies

ii. External Dependencies

iii. Multimodule Projects

iv. Multiple Repositories (or a Monorepo)?

v. Plugins

vi. Releasing and Publishing Artifacts

c. Java Build Tooling Overview

i. Ant

ii. Maven

iii. Gradle

iv. Bazel, Pants, and Buck

v. Other JVM Build Tools: SBT and Leiningen

vi. Make

d. Choosing a Build Tool

e. Summary

8. 6. Additional Build Tooling and Skills

a. Linux, Bash, and Basic CLI Commands

i. Users, Permissions, and Groups

ii. Working with the Filesystem

iii. Viewing and Editing Text

iv. Joining Everything Together: Redirects, Pipes, and Filters

v. Searching and Manipulating Text: grep, awk, and sed

vi. Diagnostic Tooling: top, ps, netstat, and iostat

b. HTTP Calls and JSON Manipulation

i. curl

ii. HTTPie

iii. jq

c. Basic Scripting

i. xargs

ii. Pipes and Filters

iii. Loops

iv. Conditionals

d. Summary

9. 7. Packaging Applications for Deployment

a. Building a JAR: Step-by-Step

b. Building a Fat Executable “Uber” JAR

i. Maven Shade Plugin

ii. Building Spring Boot Uber JARs

c. Skinny JARs—Deciding Not to Build Fat JARs

d. Building WAR Files

e. Packaging for the Cloud

i. Cooking Configuration: Baking or Frying Machines

ii. Building RPMs and DEBs OS Packages

iii. Additional OS Package Build Tools (with Windows

Support)

iv. Creating Machine Images for Multiple Clouds with Packer

v. Additional Tools for Creating Machine Images

f. Building Containers

i. Creating Container Images with Docker

ii. Fabricating Docker Images with fabric8

g. Packaging FaaS Java Applications

h. Summary

10. 8. Working Locally (Like It Was Production)

a. Challenges with Local Development

b. Mocking, Stubbing, and Service Virtualization

i. Pattern #1: Profiles, Mocks, and Stubs

ii. Mocking with Mockito

iii. Pattern #2: Service Virtualization and API Simulation

iv. Virtualizing Services with Hoverfly

c. VMs: Vagrant and Packer

i. Installing Vagrant

ii. Creating a Vagrantfile

iii. Pattern #3: Production-in-a-Box

d. Containers: Kubernetes, minikube, and Telepresence

i. Introducing the “Docker Java Shop” Sample App

ii. Building Java Applications and Container Images

iii. Deploying into Kubernetes

iv. Simple Smoke Test

v. Building the Remaining Applications

vi. Deploying the Entire Java Application in Kubernetes

vii. Viewing the Deployed Application

viii. Telepresence: Working Remotely, Locally

ix. Pattern #4: Environment Leasing

e. FaaS: AWS Lamba and SAM Local

i. Installing SAM Local

ii. AWS Lambda Scaffolding

iii. Testing AWS Lambda Event Handling

iv. Smoke Testing with SAM Local

f. FaaS: Azure Functions and VS Code

i. Installing Azure Function Core Tools

ii. Building and Testing Locally

iii. Testing Remotely, Locally Using VS Code

g. Summary

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

Pipeline

a. Why Continuous Integration?

b. Implementing CI

c. Centralized Versus Distributed Version-Control Systems

d. Git Primer

i. Core Git CLI Commands

ii. Hub: An Essential Tool for Git and GitHub

e. Working Effectively with DVCS

i. Trunk-based Development

ii. Feature Branching

iii. Gitflow

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

f. Code Reviews

i. What to Look For

ii. Automation: PMD, Checkstyle, and FindBugs

iii. Reviewing Pull Requests

g. Automating Builds

i. Jenkins

h. Getting Your Team Onboard

i. Merge Code Regularly

ii. “Stop the Line!”: Managing Broken Builds

iii. Don’t @Ignore Tests

iv. Keep the Build Fast

i. CI of the Platform (Infrastructure as Code)

j. Summary

12. 10. Deploying and Releasing from the Pipeline

a. Introducing the Extended Java Shop Application

b. Separating Deployment and Release

c. Deploying Applications

i. Creating a Container Image

ii. Deployment Mechanisms

iii. It All Starts (and Ends) with Health Checks

iv. Deployment Strategies

v. Working with Unmanaged Clusters

vi. Changing Databases

d. Releasing Functionality

i. Feature Flags

ii. Semantic Versioning (semver)

iii. Backward Compatibility and Versions in APIs

iv. Multiple-Phase Upgrades

e. Managing Configuration and Secrets

i. “Baked-In” Configuration

ii. Externalized Configuration

iii. Handling Secrets

f. Summary

13. 11. Functional Testing: Correctness and Acceptance

a. Why Test Software?

b. What to Test? Introducing Agile Testing Quadrants

c. Continuous Testing