Continuous Delivery with Docker and Jenkins: Create secure applications by building complete CI/CD pipelines

Cover
Title page
Copyright and Credits
Dedication
Contributors
Table of Contents
Preface
Section 1 – Setting Up the Environment
Chapter 1: Introducing Continuous Delivery
	Understanding CD
		The traditional delivery process
		The benefits of CD
		Success stories
	The automated deployment pipeline
		Continuous integration
		Automated acceptance testing
		Configuration management
	Prerequisites to CD
		Organizational prerequisites
		Technical and development prerequisites
	Combining CD and microservices
	Building the CD process
		Introducing tools
		Creating a complete CD system
	Summary
	Questions
	Further reading
Chapter 2: Introducing Docker
	Technical requirements
	What is Docker?
		Containerization versus virtualization
		The need for Docker
		Kittens and cattle
		Alternative containerization technologies
	Installing Docker
		Prerequisites for Docker
		Installing on a local machine
		Installing on a server
	Running Docker hello-world
	Docker components
		Docker client and server
		Docker images and containers
	Docker applications
	Building Docker images
		docker commit
		Dockerfile
		Complete Docker 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
	Summary
	Exercises
	Questions
	Further reading
Chapter 3: Configuring Jenkins
	Technical requirements
	What is Jenkins?
	Installing Jenkins
		Installing Jenkins with Docker
		Installing Jenkins with dedicated packages
		Initial configuration
		Installing Jenkins in Kubernetes
		Jenkins in the cloud
	Jenkins – Hello World
	Jenkins architecture
		Master and agents
		Scalability
		Test and production instances
		Sample architecture
	Configuring agents
		Communication protocols
		Setting agents
		Testing agents
		Comparing Docker pipeline builds and Docker agents
	Custom Jenkins images
		Building the Jenkins agent
		Building the Jenkins master
	Configuration and management
		Plugins
		Security
		Backup
		Jenkins Blue Ocean UI
	Summary
	Exercises
	Questions
	Further reading
Section 2 – Architecting and Testing an Application
Chapter 4: Continuous Integration Pipeline
	Technical requirements
	Introducing pipelines
		The pipeline structure
		A multi-stage Hello World
		The pipeline syntax
	The commit pipeline
		Checkout
		Compile
		Unit tests
		Jenkinsfile
	Code-quality stages
		Code coverage
		Static code analysis
		SonarQube
	Triggers and notifications
		Triggers
		Notifications
	Team development strategies
		Development workflows
		Adopting continuous integration
		Jenkins multi-branch
		Non-technical requirements
	Summary
	Exercises
	Questions
	Further reading
Chapter 5: Automated Acceptance Testing
	Technical requirements
	Introducing acceptance testing
	Installing and using the Docker Registry
		The artifact repository
		Installing a Docker Registry
		Using the Docker Registry
	Acceptance tests in the Jenkins pipeline
		The Docker build stage
		The Docker push stage
		The acceptance testing stage
	Writing acceptance tests
		Writing user-facing tests
		Using the acceptance testing framework
		Acceptance test-driven development
	Summary
	Exercises
	Questions
	Further reading
Chapter 6: Clustering with Kubernetes
	Technical requirements
	Server clustering
		Introducing server clustering
	Introducing Kubernetes
		Kubernetes features overview
	Kubernetes installation
		Kubernetes client
		Kubernetes server
		Verifying the Kubernetes setup
	Using Kubernetes
		Deploying an application
		Deploying a Kubernetes Service
		Exposing an application
	Advanced Kubernetes
		Scaling an application
		Updating an application
		Rolling updates
		Kubernetes objects and workloads
	Application dependencies
		The Kubernetes DNS resolution
		Multiapplication system overview
		Multiapplication system implementation
		Multiapplication system testing
	Alternative cluster management systems
		Docker Swarm
		Apache Mesos
		Comparing features
	Summary
	Exercises
	Questions
	Further reading
Section 3 – Deploying an Application
Chapter 7: Configuration Management with Ansible
	Technical requirements
	Introducing configuration management
		Traits of good configuration management
		Overview of configuration management tools
	Installing Ansible
		Ansible server requirements
		Ansible installation
	Using Ansible
		Creating an inventory
		Ad hoc commands
		Playbooks
		Roles
	Deployment with Ansible
		Installing Hazelcast
		Deploying a web service
		Running the deployment
	Ansible with Docker and Kubernetes
		Benefits of Ansible
		The Ansible Docker playbook
		The Ansible Kubernetes playbook
	Introducing IaC
		Benefits of IaC
		Tools for IaC
	Introduction to Terraform
		Understanding Terraform
		Installing Terraform
		Using Terraform
		Terraform and Kubernetes
	Summary
	Exercises
	Questions
	Further reading
Chapter 8: Continuous Delivery Pipeline
	Technical requirements
	Environments and infrastructure
		Types of environments
		Environments in continuous delivery
		Securing environments
	Non-functional testing
		Types of non-functional test
		Non-functional challenges
	Application versioning
		Versioning strategies
		Versioning in the Jenkins pipeline
	Completing the continuous delivery pipeline
		Inventory
		Versioning
		The remote staging environment
		The acceptance testing environment
		Release
		Smoke testing
		Complete Jenkinsfile
	Summary
	Exercises
	Questions
	Further reading
Chapter 9: Advanced Continuous Delivery
	Technical requirements
	Managing database changes
		Understanding schema updates
		Changing the database in continuous delivery
		Avoiding a shared database
		Preparing test data
	Pipeline patterns
		Parallelizing pipelines
		Reusing pipeline components
		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
	Summary
	Exercises
	Questions
	Further reading
Best Practices
	Practice 1 – Own the 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 – Incorporate traceability
	Practice 8 – Integrate often
	Practice 9 – Only build binaries once
	Practice 10 – Release often
Assessments
	Chapter 1: Introducing Continuous Delivery
	Chapter 2: Introducing Docker
	Chapter 3: Configuring Jenkins
	Chapter 4: Continuous Integration Pipeline
	Chapter 5: Automated Acceptance Testing
	Chapter 6: Clustering with Kubernetes
	Chapter 7: Configuration Management with Ansible
	Chapter 8: Continuous Delivery Pipeline
	Chapter 9: Advanced Continuous Delivery
Index
About Packt
Other Books You May Enjoy