Continuous Delivery with Docker and Jenkins电子书

Title Page

Copyright

Continuous Delivery with Docker and Jenkins

Credits

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Dedication

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

Introducing Continuous Delivery

What is Continuous Delivery?

The traditional delivery process

Introducing the traditional delivery process

Shortcomings of the traditional delivery process

Benefits of Continuous Delivery

Success stories

The automated deployment pipeline

Continuous Integration

Automated acceptance testing

The Agile testing matrix

The testing pyramid

Configuration management

Prerequisites to Continuous Delivery

Organizational prerequisites

DevOps culture

Client in the process

Business decisions

Technical and development prerequisites

Building the Continuous Delivery process

Introducing tools

Docker ecosystem

Jenkins

Ansible

GitHub

Java/Spring Boot/Gradle

The other tools

Creating a complete Continuous Delivery system

Introducing Docker

Configuring Jenkins

Continuous Integration Pipeline

Automated acceptance testing

Configuration management with Ansible/Continuous Delivery pipeline

Clustering with Docker Swarm/Advanced Continuous Delivery

Summary

Introducing Docker

What is Docker?

Containerization versus virtualization

The need for Docker

Environment

Isolation

Organizing applications

Portability

Kittens and cattle

Alternative containerization technologies

Docker installation

Prerequisites for Docker

Installing on a local machine

Docker for Ubuntu

Docker for Linux

Docker for Mac

Docker for Windows

Testing Docker installation

Installing on a server

Dedicated server

Running Docker hello world>

Docker components

Docker client and server

Docker images and containers

Docker applications

Building images

Docker commit

Dockerfile

Complete Docker application

Write the application

Prepare the environment

Build the image

Run the application

Environment variables

Docker container states

Docker networking

Running services

Container networks

Exposing container ports

Automatic port assignment

Using Docker volumes

Using names in Docker

Naming containers

Tagging images

Docker cleanup

Cleaning up containers

Cleaning up images

Docker commands overview

Exercises

Summary

Configuring Jenkins

What is Jenkins?

Jenkins installation

Requirements for installation

Installing on Docker

Installing without Docker

Initial configuration

Jenkins hello world

Jenkins architecture

Master and slaves

Scalability

Vertical scaling

Horizontal scaling

Test and production instances

Sample architecture

Configuring agents

Communication protocols

Setting agents

Permanent agents

Configuring permanent agents

Understanding permanent agents

Permanent Docker agents

Configuring permanent Docker agents

Understanding permanent Docker agents

Jenkins Swarm agents

Configuring Jenkins Swarm agents

Understanding Jenkins Swarm agents

Dynamically provisioned Docker agents

Configuring dynamically provisioned Docker agents

Understanding dynamically provisioned Docker agents

Testing agents

Custom Jenkins images

Building Jenkins slave

Building Jenkins master

Configuration and management

Plugins

Security

Backup

Blue Ocean UI

Exercises

Summary

Continuous Integration Pipeline

Introducing pipelines

Pipeline structure

Multi-stage Hello World

Pipeline syntax

Sections

Directives

Steps

Commit pipeline

Checkout

Creating a GitHub repository

Creating a checkout stage

Compile

Creating a Java Spring Boot project

Pushing code to GitHub

Creating a compile stage

Unit test

Creating business logic

Writing a unit test

Creating a unit test stage

Jenkinsfile

Creating Jenkinsfile

Running pipeline from Jenkinsfile

Code quality stages

Code coverage

Adding JaCoCo to Gradle

Adding a code coverage stage

Publishing the code coverage report

Static code analysis

Adding the Checkstyle configuration

Adding a static code analysis stage

Publishing static code analysis reports

SonarQube

Triggers and notifications

Triggers

External

Polling SCM

Scheduled build

Notifications

Email

Group chat

Team space

Team development strategies

Development workflows

Trunk-based workflow

Branching workflow

Forking workflow

Adopting Continuous Integration

Branching strategies

Feature toggles

Jenkins Multibranch

Non-technical requirements

Exercises

Summary

Automated Acceptance Testing

Introducing acceptance testing

Docker registry

Artifact repository

Installing Docker registry

Docker Hub

Private Docker registry

Installing the Docker registry application

Adding a domain certificate

Adding an access restriction

Other Docker registries

Using Docker registry

Building an image

Pushing the image

Pulling the image

Acceptance test in pipeline

The Docker build stage

Adding Dockerfile

Adding the Docker build to the pipeline

The Docker push stage

Acceptance testing stage

Adding a staging deployment to the pipeline

Adding an acceptance test to the pipeline

Adding a cleaning stage environment

Docker Compose

What is Docker Compose?

Installing Docker Compose

Defining docker-compose.yml

Using the docker-compose command

Building images

Scaling services

Acceptance testing with Docker Compose

Using a multi-container environment

Adding a Redis client library to Gradle

Adding a Redis cache configuration

Adding Spring Boot caching

Checking the caching environment

Method 1 – Jenkins-first acceptance testing

Changing the staging deployment stage

Changing the acceptance test stage

Method 2 – Docker-first acceptance testing

Creating a Dockerfile for acceptance test

Creating docker-compose.yml for acceptance test

Creating an acceptance test script

Running the acceptance test

Changing the acceptance test stage

Comparing method 1 and method 2

Writing acceptance tests

Writing user-facing tests

Using the acceptance testing framework

Creating acceptance criteria

Creating step definitions

Running an automated acceptance test

Acceptance test-driven development

Exercises

Summary

Configuration Management with Ansible

Introducing configuration management

Traits of good configuration management

Overview of configuration management tools

Installing Ansible

Ansible server requirements

Ansible installation

Docker-based Ansible client

Using Ansible

Creating inventory

Ad hoc commands

Playbooks

Defining a playbook

Executing the playbook

Playbook's idempotency

Handlers

Variables

Roles

Understanding roles

Ansible Galaxy

Deployment with Ansible

Installing Redis

Deploying a web service

Configuring a project to be executable

Changing the Redis host address

Adding calculator deployment to the playbook

Running deployment

Ansible with Docker

Benefits of Ansible

Ansible Docker playbook

Installing Docker

Running Docker containers

Using Docker Compose

Exercises

Summary

Continuous Delivery Pipeline

Environments and infrastructure

Types of environment

Production

Staging

QA

Development

Environments in Continuous Delivery

Securing environments

Nonfunctional testing

Types of nonfunctional test

Performance testing

Load testing

Stress testing

Scalability testing

Endurance testing

Security testing

Maintainability testing

Recovery testing

Nonfunctional challenges

Application versioning

Versioning strategies

Versioning in the Jenkins pipeline

Complete Continuous Delivery pipeline

Inventory

Acceptance testing environment

Release

Smoke testing

Complete Jenkinsfile

Exercises

Summary

Clustering with Docker Swarm

Server clustering

Introducing server clustering

Introducing Docker Swarm

Docker Swarm features overview

Docker Swarm in practice

Setting up a Swarm

Adding worker nodes

Deploying a service

Scaling service

Publishing ports

Advanced Docker Swarm

Rolling updates

Draining nodes

Multiple manager nodes

Scheduling strategy

Docker Compose with Docker Swarm

Introducing Docker Stack

Using Docker Stack

Specifying docker-compose.yml

Running the docker stack command

Verifying the services and containers

Removing the stack

Alternative cluster management systems

Kubernetes

Apache Mesos

Comparing features

Scaling Jenkins

Dynamic slave provisioning

Jenkins Swarm

Comparison of dynamic slave provisioning and Jenkins Swarm

Exercises

Summary

Advanced Continuous Delivery

Managing database changes

Understanding schema updates

Introducing database migrations

Using Flyway

Configuring Flyway

Defining the SQL migration script

Accessing database

Changing database in Continuous Delivery

Backwards-compatible changes

Non-backwards-compatible changes

Adding a new column to the database

Changing the code to use both columns

Merging the data in both columns

Removing the old column from the code

Dropping the old column from the database

Separating database updates from code changes

Avoiding shared database

Preparing test data

Unit testing

Integration/acceptance testing

Performance testing

Pipeline patterns

Parallelizing pipelines

Reusing pipeline components

Build parameters

Shared libraries

Creating a shared library project

Configure the shared library in Jenkins

Use shared library in Jenkinsfile

Rolling back deployments

Adding manual steps

Release patterns

Blue-green deployment

Canary release

Working with legacy systems

Automating build and deployment

Automating tests

Refactoring and introducing new features

Understanding the human element

Exercises

Summary

Best practices

Practice 1 – own process within the team!

Practice 2 – automate everything!

Practice 3 – version everything!

Practice 4 – use business language for acceptance tests!

Practice 5 – be ready to roll back!

Practice 6 – don't underestimate the impact of people

Practice 7 – build in traceability!

Practice 8 – integrate often!

Practice 9 – build binaries only once!

Practice 10 – release often!