Learning DevOps: Continuously Deliver Better Software

Cover
Copyright
Credits
Preface
Table of Contents
Module 1
Chapter 1: Introduction to DevOps and Continuous Delivery
	Introducing DevOps
	How fast is fast?
	The Agile wheel of wheels
	Beware the cargo cult Agile fallacy
	DevOps and ITIL
	Summary
Chapter 2: A View from Orbit
	The DevOps process and Continuous Delivery – an overview
	Release management
	Scrum, Kanban, and the delivery pipeline
	Wrapping up – a complete example
	Identifying bottlenecks
	Summary
Chapter 3: How DevOps Affects Architecture
	Introducing software architecture
	The monolithic scenario
	Architecture rules of thumb
	The separation of concerns
	The principle of cohesion
	Coupling
	Back to the monolithic scenario
	A practical example
	Three-tier systems
	The presentation tier
	The logic tier
	The data tier
	Handling database migrations
	Rolling upgrades
	Hello world in Liquibase
	The changelog file
	The pom.xml file
	Manual installation
	Microservices
	Interlude – Conway\'s Law
	How to keep service interfaces forward compatible
	Microservices and the data tier
	DevOps, architecture, and resilience
	Summary
Chapter 4: Everything is Code
	The need for source code control
	The history of source code management
	Roles and code
	Which source code management system?
	A word about source code management system migrations
	Choosing a branching strategy
	Branching problem areas
	Artifact version naming
	Choosing a client
	Setting up a basic Git server
	Shared authentication
	Hosted Git servers
	Large binary files
	Trying out different Git server implementations
	Docker intermission
	Gerrit
	The pull request model
	GitLab
	Summary
Chapter 5: Building the Code
	Why do we build code?
	The many faces of build systems
	The Jenkins build server
	Managing build dependencies
	The final artifact
	Cheating with FPM
	Continuous Integration
	Continuous Delivery
	Jenkins plugins
	The host server
	Build slaves
	Software on the host
	Triggers
	Job chaining and build pipelines
	A look at the Jenkins filesystem layout
	Build servers and infrastructure as code
	Build phases
	Alternative build servers
	Collating quality measures
	About build status visualization
	Taking build errors seriously
	Robustness
	Summary
Chapter 6: Testing the Code
	Manual testing
	Pros and cons with test automation
	Unit testing
	JUnit in general and JUnit in particular
	Mocking
	Test Coverage
	Automated integration testing
	Performance testing
	Automated acceptance testing
	Automated GUI testing
	Integrating Selenium tests in Jenkins
	JavaScript testing
	Testing backend integration points
	Test-driven development
	REPL-driven development
	A complete test automation scenario
	Summary
Chapter 7: Deploying the Code
	Why are there so many deployment systems?
	Virtualization stacks
	Executing code on the client
	The Puppet master and Puppet agents
	Ansible
	PalletOps
	Deploying with Chef
	Deploying with SaltStack
	Salt versus Ansible versus Puppet versus PalletOps execution models
	Vagrant
	Deploying with Docker
	Comparison tables
	Cloud solutions
	AWS
	Azure
	Summary
Chapter 8: Monitoring the Code
	Nagios
	Munin
	Ganglia
	Graphite
	Log handling
	Summary
Chapter 9: Issue Tracking
	What are issue trackers used for?
	Some examples of workflows and issues
	What do we need from an issue tracker?
	Problems with issue tracker proliferation
	All the trackers
	Summary
Chapter 10: The Internet of Things and DevOps
	Introducing the IoT and DevOps
	The future of the IoT according to the market
	Machine-to-machine communication
	IoT deployment affects software architecture
	IoT deployment security
	Okay, but what about DevOps and the IoT again?
	A hands-on lab with an IoT device for DevOps
	Summary
Module 2
Chapter 1: Basic Command Line Tools
	Introduction
	Controlling network interfaces
	Monitoring network details with the IP command
	Monitoring connections using the ss command
	Gathering basic OS statistics
	Viewing historical resource usage with SAR
	Installing and configuring a Git client
	Creating an SSH key for Git
	Using ssh-copy-id to copy keys
	Creating a new Git repository
	Cloning an existing Git repository
	Checking changes into a Git repository
	Pushing changes to a Git remote
	Creating a Git branch
Chapter 2: Ad Hoc Tasks with Ansible
	Introduction
	Installing an Ansible control node on Ubuntu
	Installing an Ansible control node on CentOS
	Creating an Ansible inventory
	Using the raw module to install python-simplejson
	Installing packages with Ansible
	Restarting services using Ansible
	Executing freeform commands with Ansible
	Managing users with Ansible
	Managing SSH keys with Ansible
Chapter 3: Automatic Host builds
	Introduction
	Creating an Apt mirror using aptly
	Automated installation using PXE boot and a Preseed file
	Automating post-installation tasks
Chapter 4: Virtualization with VMware ESXi
	Introduction
	Installing ESXi
	Installing and using the vSphere Client
	Allowing SSH access to ESXi
	Creating a new guest
	Allocating resources to a guest
	Using the ESXi command line to start, stop, and destroy guests
	Managing command-line snapshots
	Tuning the host for guest performance
Chapter 5: Automation with Ansible
	Introduction
	Installing Ansible
	Creating a scaffold Playbook
	Creating a common role
	Creating a webserver using Ansible and Nginx
	Creating an application server role using Tomcat and Ansible
	Installing MySQL using Ansible
	Installing and managing HAProxy with Ansible
	Using ServerSpec to test your Playbook
Chapter 6: Containerization with Docker
	Introduction
	Installing Docker
	Pulling an image from the public Docker registry
	Performing basic Docker operations
	Running a container interactively
	Creating a Dockerfile
	Running a container in detached mode
	Saving and restoring a container
	Using the host only network
	Running a private Docker registry
	Managing images with a private registry
Chapter 7: Using Jenkins for Continuous Deployment
	Introduction
	Installing Jenkins
	Installing the Git plugin
	Installing a Jenkins slave
	Creating your first Jenkins job
	Building Docker containers using Jenkins
	Deploying a Java application to Tomcat with zero downtime using Ansible
Chapter 8: Metric Collection with InfluxDB
	Introduction
	Installing InfluxDB
	Creating a new InfluxDB database
	Logging events with the InfluxDB REST API
	Gathering host statistics with Telegraf
	Exploring data with the InfluxDB data explorer
	Installing Grafana
	Creating dashboards with Grafana
Chapter 9: Log Management
	Introduction
	Centralizing logs with Syslog
	Using syslog templates
	Managing log rotation with the Logrotate utility
	Installing ElasticSearch, Logstash, and Kibana
	Importing logs into Elasticsearch with Logstash
	Using Kibana queries to explore data
	Using Kibana queries to examine data
Chapter 10: Monitoring with Sensu
	Introduction
	Installing a Sensu server
	Installing a Sensu client
	Installing check prerequisites
	Finding community checks
	Adding a DNS check
	Adding a disk check
	Adding a RAM check
	Adding a process check
	Adding a CPU check
	Creating e-mail alerts
	Creating SMS alerts
	Using Ansible to install Sensu
Chapter 11: IAAS with Amazon AWS
	Introduction
	Signing up for AWS
	Setting up IAM
	Creating your first security group
	Creating your first EC2 host
	Using Elastic Load Balancers
	Managing DNS with route53
	Using Ansible to create EC2 hosts
Chapter 12: Application Performance Monitoring with New Relic
	Introduction
	Signing up for a New Relic account
	Installing the New Relic Java agent
	Using the performance overview
	Locating performance bottlenecks with Transaction Traces
	Observing database performance with New Relic
	Release performance monitoring with New Relic
	Server Monitoring with New Relic
Module 3
Chapter 1: Evolution of a Software House
	A brief history of ACME systems
	ACME systems version 1.0
	ACME systems version 2.0
	ACME systems version 3.0
	ACME systems version 4.0
	The evolution in a nutshell
	Summary
Chapter 2: No Pain, No Gain
	Elephant in the room
	Defining the rules
	Including (almost) everyone
	Openness, transparency, and honesty
	The great elephant disclosure
	Summary
Chapter 3: Plan of Attack
	Setting and communicating the goal and vision
	Standardizing vocabulary and language
	A business change project in its own right
	The merits of a dedicated team
	The importance of evangelism
	Courage and determination
	Understanding the cost
	Seeking advice from others
	Summary
Chapter 4: Culture and Behaviors
	All roads lead to culture
	An open, honest, and safe environment
	Encouraging and embracing collaboration
	Fostering innovation and accountability at grass roots
	The blame culture
	Building trust-based relationships across organizational boundaries
	Rewarding good behaviors and success
	Recognizing dev and ops teams are incentivized can have an impact
	Embracing change and reducing risk
	Being transparent
	Summary
Chapter 5: Approaches, Tools, and Techniques
	Engineering best practice
	How many environments are enough?
	Developing against a production-like environment
	CD tooling
	The cloud
	Monitoring
	When a simple manual process is also an effective tool
	Summary
Chapter 6: Hurdles Along the Way
	What are the potential issues you need to look out for?
	Summary
Chapter 7: Vital Measurements
	Measuring effective engineering best practice
	Measuring the real world
	Summary
Chapter 8: Are We There Yet?
	Reflect on where you are now
	Streaming
	A victim of your own success
	[P]lan, [D]o, [C]heck, [A]djust
	Exit stage left
	Rest on your laurels (not)
	Summary
Chapter 9: The Future is Bright
	Expanding your horizon
	Expanding beyond software delivery
	What about me?
	What have you learned?
	Summary
Appendix A: Some Useful Information
	Tools
	People
	Recommended reading
Appendix B: Where Am I on the Evolutionary Scale?
Appendix C: Retrospective Games
	The timeline game
	StoStaKee
Appendix D: Vital Measurements Expanded
	Code complexity – some science
	Code versus comments
	Embedding monitoring into your software
Bibliography