Book Image

The DevOps 2.4 Toolkit

By : Viktor Farcic

Book Image

The DevOps 2.4 Toolkit

By: Viktor Farcic

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

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

Enabling Process Communication with Kube API Through Service Accounts

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

Defining Continuous Deployment

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

Packaging Kubernetes Applications

Packaging Kubernetes Applications

Creating a cluster

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

Distributing Kubernetes Applications

Distributing Kubernetes Applications

Creating a cluster and retrieving its IP

Using ChartMuseum

Using Monocular

Installing and Setting Up Jenkins

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

Creating a Continuous Deployment Pipeline with Jenkins

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

Continuous Delivery with Jenkins and GitOps

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?

Now It Is Your Turn

Now It Is Your Turn

Other Books You May Enjoy

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

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

Appendix B: Using Kubernetes Operations (kops)

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

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Enabling Process Communication with Kube API Through Service Accounts

Humans are not the only ones who rely on a cluster. Processes in containers often need to invoke Kube API as well. When using RBAC for authentication, we need to decide which users will have permissions to perform specific actions. The same holds true for the processes running inside containers.

When we (humans) try to access a Kubernetes cluster with RBAC enabled, we are authenticated as users. Our username provides an identity that API server uses to decide whether we are allowed to perform intended actions. Similarly processes running inside containers might also need to access the API. In such cases, they are authenticated as a specific ServiceAccount.

ServiceAccounts provide a mechanism to grant permissions to processes running inside containers. In many ways, ServiceAccounts are very similar to RBAC users...