DevOps Katas
DevOps Katas (DevOps Katas: Hands-On DevOps)
$19.99
Minimum price
$24.99
Suggested price
DevOps Katas

This book is 100% complete

Completed on 2018-06-03

About the Book

DevOps Katas: Hands-On DevOps is a collection of practical exercises that will teach you how to use three of the most important DevOps tools: Docker, Git, and Jenkins. Each set of katas will introduce you to the tool and its usage. The katas build on each other, so that after you're finished, you will have created a complete Continuous Integration / Continuous Delivery pipeline.

Many technical books are "walls of text," heavy on theory with exercises sprinkled throughout. Not so with DevOps Katas! Quite the opposite. DevOps Katas teaches by doing.

The katas in DevOps Katas are based on Code Katas, which in turn are inspired by the katas of martial arts: short, quick-to-practice exercises designed to be practiced regularly. Katas are broken into steps, each with a few commands. You'll execute the commands first, then learn what you did and why.

All of the software you'll need to practice DevOps Katas is free. It's also provided to you in the form of a free Learning Virtual Machine, available for download at www.devopskatas.com. The LVM is pre-loaded with everything you need. All you have to do is download and install Virtualbox. No installing, no configuring, just kata practice.

Table of Contents

  • Acknowledgements
  • Chapter 1: Introduction to DevOps
    • What is DevOps?
      • Culture
      • Process
      • Technology
      • DevOps Automation
  • Chapter 2: Getting Started With DevOps Katas
    • Introduction: Practice First
    • What is a Kata?
    • Kata Formatting and Conventions
    • Kata Practice Guidelines
      • Kata Practice Pages
      • Kata Practice Calendar
      • Kata Practice Tools
    • Setting up the DevOps Katas Learning Virtual Machine
      • Step 1: Install Virtualbox
      • Step 2: Download the LVM Image
      • Step 3: Import the LVM Image
      • Step 4: Run the LVM
    • Sample Kata
      • Step 1: Create a Directory
      • Step 2: Change to the firstkata Directory
      • Step 3: Create a File
      • Step 4: List the files in the firstkata directory
      • Step 5: Edit the file with the text editor
      • Step 6: Enter text into the file and save
  • Chapter 3: Containers and Docker
    • 1995 - 2002: Advent of the Internet
    • 2002: Virtualization
    • 2008: Containers
    • 2013: Docker
    • Containers and DevOps
      • Automation
      • Reliability
      • Portability
      • Scalability
      • Isolation
    • Docker and DevOps Katas
  • Chapter 4: Docker Katas
    • Docker Kata 1: The Basic Commands
      • Step 1: Running Your First Container
      • Step 2: Listing Containers
      • Step 3: Listing Images
      • Step 4: Running a Named Container
      • Step 5: Run a Container in Interactive Mode
      • Step 6: Remove all Containers and Images
    • Docker Kata 2: Disconnected Containers
      • Step 1: Run a “Disconnected” Container
      • Step 2: Execute Commands on a Running Container
      • Step 3: Connecting Interactively to a Running Container
    • Docker Kata 3: Container Volumes and Filesystem
      • Step 1: Container Filesystem Changes
      • Step 2: Run a Container With a Named Volume
      • Step 3: Share a Volume Between Containers
      • Step 4: Run a Container With a Host-Mounted Volume
    • Docker Kata 4: Running a Web Server in a Container
      • Step 1: Run a Web Server
      • Step 2: Run a Second Webserver on a Different Port
    • Docker Kata 5: Docker Networking
      • Step 1: List All Networks
      • Step 2: Ping Between Containers
      • Step 3: Create a User-Defined Network
      • Step 4: Run Containers on a User-Defined Network
    • Docker Kata 6: Creating Docker Images
      • Step 1: Creating an Image From a Modified Container
      • Step 2: Create an Image with a Dockerfile
  • Chatper 5: Source Control Management and Git
    • Source Control Tools
      • Centralized Version Control Systems (CVCS)
      • Distributed Version Control Systems (DVCS)
    • Introducing Git
    • Anatomy of a Git Repository
    • Sharing Code With Git
    • Merging and Branching in Git
    • Git Workflows
    • Git Tools
    • Git Uses
  • Chapter 6: Git Katas
    • Git Kata 1: New Local Repository
      • Step 1: Initialize a New Repository
      • Step 2: Stage Changes to a Repository
      • Step 3: Commit Changes to a Repository
      • Step 4: Making and Committing Changes to a File
    • Git Kata 2: Branches
      • Step 1: Listing and Creating Branches
      • Step 2: Switching Between Branches
      • Step 3: Committing to a Branch
    • Git Kata 3: Merging
      • Step 1: Merge Changes Between Branches
      • Step 2: Merging Branches With Divergent Histories
    • Git Kata 4: Merge Conflicts
      • Step 1: Modify the File in the master Branch
      • Step 2: Modify the File in newbranch
      • Step 3: Merge and Resolve Conflicts
    • Git Kata 5: Run a Git Server
      • Step 1: Install Gogs
      • Step 2: Create Admin Account
      • Step 3: Create a Repository
      • Step 4: Add Users
      • Step 5: Set Repository Permissions
    • Git Kata 6: Remote Repositories
      • Step 1: Initialize a New Repository
      • Step 2: Add a Remote Repository
      • Step 3: Push Commits to a Remote Repository
    • Git Kata 7: Collaboration
      • Step 1: Clone and Configure the Repository
      • Step 2: Make Changes as Ken and Push
      • Step 3: Make Changes as Carrie and Push
      • Step 4: Final Edits as Ken
    • Git Kata 8: Repository Forking and Pull Requests
      • Step 1: Create Cody’s Account in Gogs
      • Step 2: Transfer the web-storelist Repository to Cody
      • Step 3: Log in as Ken and Create a Fork
      • Step 4: Review the Pull Request as Cody and Accept
  • Chapter 7: Continuous Integration and Jenkins
    • Continuous Integration
    • Introducing Jenkins
  • Chapter 8: Jenkins Katas
    • Jenkins Kata 1: Setup
      • Step 1: Get the Administrator Key
      • Step 2: Install Jenkins
      • Step 3: Create Administrative User
      • Step 4: Start the Gogs Git Server
    • Jenkins Kata 2: Create A Job
      • Step 1: Create a New Job
      • Step 2: Set up Source Control Parameters
      • Step 3: Run the Job
    • Jenkins Kata 3: Build Steps
      • Step 1: Add a Build Step
      • Step 2: Build Step Result Codes
    • Jenkins Kata 4: Automated Testing
      • Step 1: Add a Build Step to Run the Test
      • Step 2: Make the Test Fail
      • Step 3: Fix the Code
    • Jenkins Kata 5: Integrate Git With Jenkins
      • Step 1: Install the Gogs Webhook Plugin
      • Step 2: Configure A Build Trigger
      • Step 3: Configure the Webhook in Gogs
      • Step 4: Test the Trigger
      • Step 5: Trigger a Job With a Push
    • Jenkins Kata 6: Docker Container Build Step
      • Step 1: Add a Dockerfile
      • Step 2: Install the Docker Plugin
      • Step 3: Run a Private Docker Registry
      • Step 4: Add a Docker Build Step
    • Jenkins Kata 7: Deploying Containers
      • Step 1: Add the Build Pipeline Plugin
      • Step 2: Define A DEV Environment Deployment Job
      • Step 3: Configure the DEV Deployment Job Trigger
      • Step 4: Define A QA Environment Deployment Job
      • Step 5: Define a Production Deployment Job
      • Step 6: Add a Pipeline View
  • DevOps Katas Practice Pages
    • Docker Katas Practice Pages
      • Docker Kata 1: The Basic Commands
      • Docker Kata 2: Disconnected Containers
      • Docker Kata 3: Container Volumes and Filesystem
      • Docker Kata 4: Running a Web Server in a Container
      • Docker Kata 5: Docker Networking
      • Docker Kata 6: Creating Docker Images
    • Git Katas Practice Pages
      • Git Kata 1: New Local Repository
      • Git Kata 2: Branches
      • Git Kata 3: Merging
      • Git Kata 4: Merge Conflicts
      • Git Kata 5: Run a Git Server
      • Git Kata 6: Remote Repositories
      • Git Kata 7: Collaboration
      • Git Kata 8: Repository Forking and Pull Requests
    • Jenkins Katas Practice Pages
      • Jenkins Kata 1: Setup
      • Jenkins Kata 2: Create a Job
      • Jenkins Kata 3: Build Steps
      • Jenkins Kata 4: Automated Testing
      • Jenkins Kata 5: Integrate Git With Jenkins
      • Jenkins Kata 6: Docker Container Build Step
      • Jenkins Kata 7: Deploying Containers
  • Notes

About the Author

Dave Swersky
Dave Swersky

Dave Swersky is a 20+ year veteran of the IT industry. He's an experienced software developer and TOGAF-certified Enterprise Architect.

Dave has focused on DevOps for over three years, as a central part of his work as an Architect and software developer. He has worked with major banks, energy companies, consulting firms, and the US Government on DevOps strategies and transformations.

The Leanpub 45-day 100% Happiness Guarantee

Within 45 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Write and Publish on Leanpub

Authors and publishers use Leanpub to publish amazing in-progress and completed ebooks, just like this one. You can use Leanpub to write, publish and sell your book as well! Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks. Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. It really is that easy.

Learn more about writing on Leanpub