Name: Continuous Delivery with Docker and Jenkins
Author: Rafał Leszko
ISBN: 9781787126145

微信读书书城Continuous Delivery with Docker and Jenkins

首页我的书架登录

翻译完成

切换

Continuous Delivery with Docker and Jenkins

Rafał Leszko

扉页
cover
+书签
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!

简介

版权

Continuous Delivery with Docker and Jenkins