Book Overview & Buying
Table Of Contents

The DevOps 2.4 Toolkit

By : Viktor Farcic

Buy this Book

The DevOps 2.4 Toolkit

By: Viktor Farcic

Buy this Book

Overview of this book

Building on The DevOps 2.3 Toolkit: Kubernetes, Viktor Farcic brings his latest exploration of the Docker technology as he records his journey to continuously deploying applications with Jenkins into a Kubernetes cluster. The DevOps 2.4 Toolkit: Continuously Deploying Applications with Jenkins to a Kubernetes Cluster is the latest book in Viktor Farcic’s series that helps you build a full DevOps Toolkit. This book guides readers through the process of building, testing, and deploying applications through fully automated pipelines. Within this book, Viktor will cover a wide-range of emerging topics, including an exploration of continuous delivery and deployment in Kubernetes using Jenkins. It also shows readers how to perform continuous integration inside these clusters, and discusses the distribution of Kubernetes applications, as well as installing and setting up Jenkins. Work with Viktor and dive into the creation of self-adaptive and self-healing systems within Docker.

Free Chapter

Deploying Stateful Applications at Scale

Creating a cluster

Using StatefulSets to run Stateful applications

Using Deployments to run Stateful applications at scale

Using StatefulSets to run Stateful applications at scale

Using sidecar containers to initialize applications

To StatefulSet or not to StatefulSet

What now?

Enabling Process Communication with Kube API Through Service Accounts

Creating a cluster

Configuring Jenkins Kubernetes plugin

Exploring the default ServiceAccount

Creating ServiceAccounts

Configuring Jenkins Kubernetes plugin with ServiceAccounts

Using ServiceAccounts from side-car containers

What now?

Defining Continuous Deployment

To continuously deliver or to continuously deploy?

Defining continuous deployment goals

Defining continuous deployment steps

Creating a cluster

Creating Namespaces dedicated to continuous deployment processes

Defining a Pod with the tools

Executing continuous integration inside containers

Running functional tests

Creating production releases

Deploying to production

Running production tests

Cleaning up pipeline leftovers

Did we do it?

What now?

Packaging Kubernetes Applications

Creating a cluster

What Is Helm?

Installing Helm

Installing Helm Charts

Customizing Helm installations

Rolling back Helm revisions

Using YAML values to customize Helm installations

Creating Helm Charts

Exploring files that constitute a Chart

Upgrading Charts

Helm vs. OpenShift templates

What now?

Distributing Kubernetes Applications

Creating a cluster and retrieving its IP

Using ChartMuseum

Using Monocular

What now?

Installing and Setting Up Jenkins

Creating a Cluster and retrieving its IP

Running Jenkins

Using Pods to run tools

Running builds in different Namespaces

Creating nodes for building container images

Testing Docker builds outside the cluster

Automating Jenkins installation and setup

What now?

Creating a Continuous Deployment Pipeline with Jenkins

Exploring the continuous deployment process

Creating a cluster

Installing Jenkins

Defining the build stage

Defining the functional testing stage

Defining the release stage

Defining the deploy stage

What are we missing in our pipeline?

Reusing pipeline snippets through global pipeline libraries

Consulting global pipeline libraries documentation

Using Jenkins file and Multistage builds

What now?

Continuous Delivery with Jenkins and GitOps

Creating a cluster

Defining the whole production environment

What is the continuous delivery pipeline?

Exploring application's repository and preparing the environment

Switching from Scripted to Declarative Pipeline

Demystifying Declarative Pipeline through a practical example

Creating and running a continuous delivery job

What is GitOps and do we want it?

Upgrading the production environment using GitOps practices

Creating a Jenkins job that upgrades the whole production environment

Automating upgrade of the production environment

High-level overview of the continuous delivery pipeline

To continuously deploy or to continuously deliver?

What now?

Now It Is Your Turn

Contributions

Other Books You May Enjoy

Leave a review - let other readers know what you think

Appendix A: Installing kubectl and Creating a Cluster with minikube

Running Kubernetes Cluster Locally

Installing kubectl

Installing Minikube

Creating a local Kubernetes cluster with Minikube

What Now?

Appendix B: Using Kubernetes Operations (kops)

Preparing for the cluster setup

Creating a Kubernetes cluster in AWS

Installing Ingress and Tiller (server side Helm)

Destroying the cluster

Creating a cluster

We'll start the practical section of the chapter by going to the vfarcic/k8s-specs repository and by making sure that we have the latest revision.

All the commands from this chapter are available in the 07-jenkins-cdp.sh (https://gist.github.com/vfarcic/d0cbca319360eb000098383a09fd65f7) Gist.

 1  cd k8s-specs
 2
 3  git pull

Next, we'll merge your go-demo-3 fork with the upstream. If you forgot the commands, they are available in the go-demo-3-merge.sh (https://gist.github.com/vfarcic/171172b69bb75903016f0676a8fe9388) gist.

It is imperative that you change all the references of vfarcic/go-demo-3 to the address of the image in your Docker Hub account. If, for example, your hub user is jdoe, you should change all vfarcic/go-demo-3 references to jdoe/go-demo-3. Even though I invite you to apply the modifications to all the files of the repository, the...

Tech Concepts

Programming languages

Tech Tools