The Kubernetes Workshop: Learn how to build and run highly scalable workloads on Kubernetes

Cover
FM
Copyright
Table of Contents
Preface
Chapter 1: Introduction to Kubernetes and Containers
	Introduction
	The Evolution of Software Development
	Virtual Machines versus Containers
	Docker Basics
		What\'s behind docker run?
		Dockerfiles and Docker Images
		Exercise 1.01: Creating a Docker Image and Uploading It to Docker Hub
		Exercise 1.02: Running Your First Application in Docker
	The Essence of Linux Container Technology
		Namespace
		Exercise 1.03: Joining a Container to the Network Namespace of Another Container
		Cgroups
		Containerization: The Mindset Change
			Several Applications in One Container
			One Application in One Container
			A Comparison of These Approaches
	The Need for Container Orchestration
		Container Interactions
		Network and Storage
		Resource Management and Scheduling
		Failover and Recovery
		Scalability
		Service Exposure
		Delivery Pipeline
		Orchestrator: Putting All the Things Together
	Welcome to the Kubernetes World
		Activity 1.01: Creating a Simple Page Count Application
	Summary
Chapter 2: An Overview of Kubernetes
	Introduction
	Setting up Kubernetes
		An Overview of Minikube
		Exercise 2.01: Getting Started with Minikube and Kubernetes Clusters
	Kubernetes Components Overview
		etcd
		API Server
		Scheduler
		Controller Manager
		Where Is the kubelet?
		kube-proxy
	Kubernetes Architecture
		Container Network Interface
	Migrating Containerized Application to Kubernetes
		Pod Specification
		Applying a YAML Manifest
		Exercise 2.02: Running a Pod in Kubernetes
		Service Specification
		Exercise 2.03: Accessing a Pod via a Service
		Services and Pods
	Delivering Kubernetes-Native Applications
		Exercise 2.04: Scaling a Kubernetes Application
	Pod Life Cycle and Kubernetes Components
		Exercise 2.05: How Kubernetes Manages a Pod\'s Life Cycle
		Activity 2.01: Running the Pageview App in Kubernetes
		A Glimpse into the Advantages of Kubernetes for Multi-Node Clusters
	Summary
Chapter 3: kubectl – Kubernetes Command Center
	Introduction
	How kubectl Communicates with Kubernetes
	Setting up Environments with Autocompletion and Shortcuts
		Exercise 3.01: Setting up Autocompletion
		Setting up the kubeconfig Configuration File
	Common kubectl Commands
		Frequently Used kubectl Commands to Create, Manage, and Delete Kubernetes Objects
		Walkthrough of Some Simple kubectl Commands
			Some Useful Flags for the get Command
	Populating Deployments in Kubernetes
		Exercise 3.02: Creating a Deployment
		Exercise 3.03: Updating a Deployment
		Exercise 3.04: Deleting a Deployment
		Activity 3.01: Editing a Live Deployment for a Real-Life Application
	Summary
Chapter 4: How to Communicate with Kubernetes (API Server)
	Introduction
	The Kubernetes API Server
	Kubernetes HTTP Request Flow
		Authentication
		Authorization
		Admission Control
		Exercise 4.01: Starting Minikube with a Custom Set of Modules
		Validation
	The Kubernetes API
		Tracing kubectl HTTP Requests
		API Resource Type
	Scope of API Resources
		Namespace-Scoped Resources
		Cluster-Scoped Resources
	API Groups
		Core Group
		Named Group
		System-Wide
	API Versions
		Exercise 4.02: Getting Information about API Resources
		How to Enable/Disable API Resources, Groups, or Versions
		Exercise 4.03: Enabling and Disabling API Groups and Versions on a Minikube Cluster
	Interacting with Clusters Using the Kubernetes API
		Accessing the Kubernetes API Server Using kubectl as a Proxy
		Creating Objects Using curl
		Exercise 4.04: Creating and Verifying a Deployment Using kubectl proxy and curl
	Direct Access to the Kubernetes API Using Authentication Credentials
		Method 1: Using Client Certificate Authentication
		Method 2: Using a ServiceAccount Bearer Token
		Activity 4.01: Creating a Deployment Using a ServiceAccount Identity
	Summary
Chapter 5: Pods
	Introduction
	Pod Configuration
		Exercise 5.01: Creating a Pod with a Single Container
		Name
		Namespace
		Exercise 5.02: Creating a Pod in a Different Namespace by Specifying the Namespace in the CLI
		Exercise 5.03: Creating a Pod in a Different Namespace by Specifying the Namespace in the Pod Configuration YAML file
		Exercise 5.04: Changing the Namespace for All Subsequent kubectl Commands
		Node
		Status
		Containers
		Exercise 5.05: Using CLI Commands to Create a Pod Running a Container
		Exercise 5.06: Creating a Pod Running a Container That Exposes a Port
		Exercise 5.07: Creating a Pod Running a Container with Resource Requirements
		Exercise 5.08: Creating a Pod with Resource Requests That Can\'t Be Met by Any of the Nodes
		Exercise 5.09: Creating a Pod with Multiple Containers Running inside It
	Life Cycle of a Pod
		Phases of a Pod
	Probes/Health Checks
		Types of Probes
			Liveness Probe
			Readiness Probe
		Configuration of Probes
		Implementation of Probes
			Command Probe
			HTTP Request Probe
			TCP Socket Probe
			Restart Policy
		Exercise 5.10: Creating a Pod Running a Container with a Liveness Probe and No Restart Policy
		Exercise 5.11: Creating a Pod Running a Container with a Liveness Probe and a Restart Policy
		Exercise 5.12: Creating a Pod Running a Container with a Readiness Probe
		Best Practices While Using Probes
		Activity 5.01: Deploying an Application in a Pod
	Summary
Chapter 6: Labels and Annotations
	Introduction
	Labels
		Constraints for Labels
			Label Keys
			Label Values
		Why Do We Need Labels?
			Organizing Pods by Organization/Team/Project
			Running Selective Pods on Specific Nodes
		Exercise 6.01: Creating a Pod with Labels
		Exercise 6.02: Adding Labels to a Running Pod
		Exercise 6.03: Modifying And/Or Deleting Existing Labels for a Running Pod
		Selecting Kubernetes Objects Using Label Selectors
			Equality-Based Selectors
		Exercise 6.04: Selecting Pods Using Equality-Based Label Selectors
			Set-Based Selectors
		Exercise 6.05: Selecting Pods Using Set-Based Label Selectors
		Exercise 6.06: Selecting Pods Using a Mix of Label Selectors
	Annotations
		Constraints for Annotations
			Annotation Keys
			Annotation Values
		Use Case for Annotations
		Exercise 6.07: Adding Annotations to Help with Application Debugging
		Working with Annotations
		Activity 6.01: Creating Pods with Labels/Annotations and Grouping Them as per Given Criteria
	Summary
Chapter 7: Kubernetes Controllers
	Introduction
	ReplicaSets
		ReplicaSet Configuration
			Replicas
			Pod Template
			Pod Selector
		Exercise 7.01: Creating a Simple ReplicaSet with nginx Containers
			Labels on the ReplicaSet
			Selectors for the ReplicaSet
			Replicas
			Pods Status
			Pods Template
			Events
		Exercise 7.02: Deleting Pods Managed by a ReplicaSet
		Exercise 7.03: Creating a ReplicaSet Given That a Matching Pod Already Exists
		Exercise 7.04: Scaling a ReplicaSet after It Is Created
	Deployment
		Deployment Configuration
			Strategy
		Exercise 7.05: Creating a Simple Deployment with Nginx Containers
			Labels and Annotations on the Deployment
			Selectors for the Deployment
			Replicas
		Rolling Back a Deployment
		Exercise 7.06: Rolling Back a Deployment
	StatefulSets
		StatefulSet Configuration
			Use Cases for StatefulSets
	DaemonSets
		Use Cases for DaemonSets
		DaemonSet Configuration
	Jobs
		Job Configuration
			A Use Case for Jobs in Machine Learning
		Exercise 7.07: Creating a Simple Job That Finishes in Finite Time
		Activity 7.01: Creating a Deployment Running an Application
	Summary
Chapter 8: Service Discovery
	Introduction
	Service
		Service Configuration
		Types of Services
		NodePort Service
		Exercise 8.01: Creating a Simple NodePort Service with Nginx Containers
		ClusterIP Service
			Service Configuration
		Exercise 8.02: Creating a Simple ClusterIP Service with Nginx Containers
			Choosing a Custom IP Address for the Service
		Exercise 8.03: Creating a ClusterIP Service with a Custom IP
		LoadBalancer Service
		ExternalName Service
	Ingress
		Activity 8.01: Creating a Service to Expose the Application Running on a Pod
	Summary
Chapter 9: Storing and Reading Data on Disk
	Introduction
	Volumes
		How to Use Volumes
		Defining Volumes
		Mounting Volumes
		Types of Volumes
			emptyDir
			hostPath
		Exercise 9.01: Creating a Pod with an emptyDir Volume
		Exercise 9.02: Creating a Pod with an emptyDir Volume Shared by Three Containers
	Persistent Volumes
		PersistentVolume Configuration
			storageClassName
			capacity
			volumeMode
			accessModes
			persistentVolumeReclaimPolicy
		PV Status
		PersistentVolumeClaim Configuration
			storageClassName
			resources
			volumeMode
			accessMode
			selectors
		How to Use Persistent Volumes
			Step 1 – Provisioning the Volume
			Step 2 – Binding the Volume to a Claim
			Step 3 – Using the Claim
		Exercise 9.03: Creating a Pod That Uses PersistentVolume for Storage
	Dynamic Provisioning
		Activity 9.01: Creating a Pod That Uses a Dynamically Provisioned PersistentVolume
	Summary
Chapter 10: ConfigMaps and Secrets
	Introduction
	What Is a ConfigMap?
		Exercise 10.01: Creating a ConfigMap from Literal Values and Mounting It on a Pod Using Environment Variables
		Defining a ConfigMap from a File and Loading It onto a Pod
		Exercise 10.02: Creating a ConfigMap from a File
		Exercise 10.03: Creating a ConfigMap from a Folder
	What Is a Secret?
		Secret versus ConfigMap
		Exercise 10.04: Defining a Secret from Literal Values and Loading the Values onto the Pod as an Environment Variable
		Exercise 10.05: Defining a Secret from a File and Loading the Values onto the Pod as a File
		Exercise 10.06: Creating a TLS Secret
		Exercise 10.07: Creating a docker-registry Secret
		Activity 10.01: Using a ConfigMap and Secret to Promote an Application through Different Stages
	Summary
Chapter 11: Build Your Own HA Cluster
	Introduction
	How the Components of Kubernetes Work Together to Achieve High Availability
		etcd
		Networking and DNS
		Nodes\' and Master Servers\' Locations and Resources
		Container Network Interface and Cluster DNS
		Container Runtime Interfaces
		Container Storage Interfaces
	Building a High-Availability Focused Kubernetes Cluster
		Self-Managed versus Vendor-Managed Kubernetes Solutions
		kops
		Other Commonly Used Tools
		Authentication and Identity in Kubernetes
		Exercise 11.01: Setting up Our Kubernetes Cluster
		Kubernetes Service Accounts
		Exercise 11.02: Deploying an Application on Our HA Cluster
		Activity 11.01: Testing the Resilience of a Highly Available Cluster
		Deleting Our Cluster
	Summary
Chapter 12: Your Application and HA
	Introduction
	An Overview of Infrastructure Life Cycle Management
	Terraform
		Exercise 12.01: Creating an S3 Bucket with Terraform
		Exercise 12.02: Creating a Cluster with EKS Using Terraform
	Kubernetes Ingress
	Highly Available Applications Running on Top of Kubernetes
		Exercise 12.03: Deploying a Multi-Replica Non-HA Application in Kubernetes
	Working with Stateful Applications
		The CI/CD Pipeline
		Exercise 12.04: Deploying an Application with State Management
		Activity 12.01: Expanding the State Management of Our Application
	Summary
Chapter 13: Runtime and Network Security in Kubernetes
	Introduction
	Threat Modeling
		The 4Cs of Cloud Native Security
	Cluster Security
	Kubernetes RBAC
		Role
		RoleBinding
		ClusterRole
		ClusterRoleBinding
		Some Important Notes about RBAC Policies
		ServiceAccount
		Exercise 13.01: Creating a Kubernetes RBAC ClusterRole
	NetworkPolicies
		Exercise 13.02: Creating a NetworkPolicy
	PodSecurityPolicy
		Exercise 13.03: Creating and Testing a PodSecurityPolicy
		Activity 13.01: Securing Our App
	Summary
Chapter 14: Running Stateful Components in Kubernetes
	Introduction
	Stateful Apps
	Understanding StatefulSets
		Deployments versus StatefulSets
	Further Refactoring Our Application
		Exercise 14.01: Deploying a Counter App with a MySQL Backend
		Exercise 14.02: Testing the Resilience of StatefulSet Data in PersistentVolumes
	Helm
		Exercise 14.03: Chart-ifying Our Redis-Based Counter Application
		Activity 14.01: Chart-ifying Our StatefulSet Deployment
	Summary
Chapter 15: Monitoring and Autoscaling in Kubernetes
	Introduction
	Kubernetes Monitoring
		Kubernetes Metrics API/Metrics Server
		Prometheus
		Grafana
		Monitoring Your Applications
		Exercise 15.01: Setting up the Metrics Server and Observing Kubernetes Objects
	Autoscaling in Kubernetes
		HorizontalPodAutoscaler
		Exercise 15.02: Scaling Workloads in Kubernetes
		ClusterAutoscaler
		Exercise 15.03: Configuring the ClusterAutoscaler
		Activity 15.01: Autoscaling Our Cluster Using ClusterAutoscaler
		Deleting Your Cluster Resources
	Summary
Chapter 16: Kubernetes Admission Controllers
	Introduction
	How Admission Controllers Work
	Creating Controllers with Custom Logic
		The Mutating Admission Webhook
		The Validating Admission Webhook
	How a Webhook Works
		Exercise 16.01: Modifying a ConfigMap Object through a Patch
		Guidelines for Building a Mutating Admission WebHook
		Exercise 16.02: Deploying a Webhook
		Configuring the Webhook to Work with Kubernetes
		How to Encode a Certificate in Base64 Format
		Activity 16.01: Creating a Mutating Webhook That Adds an Annotation to a Pod
	Validating a Webhook
		Coding a Simple Validating WebHook
		Activity 16.02: Creating a Validating Webhook That Checks for a Label in a Pod
		Controlling the Effect of a Webhook on Selected Namespaces
		Exercise 16.03: Creating a Validating Webhook with the Namespace Selector Defined
	Summary
Chapter 17: Advanced Scheduling in Kubernetes
	Introduction
	The Kubernetes Scheduler
	The Pod Scheduling Process
		Filtering
		Scoring
		Assigning
		Timeline of Pod Scheduling
	Managing the Kubernetes Scheduler
		Node Affinity and Anti-Affinity
		Exercise 17.01: Running a Pod with Node Affinity
	Pod Affinity and Anti-Affinity
		Exercise 17.02: Running Pods with Pod Affinity
	Pod Priority
		Exercise 17.03: Pod Priority and Preemption
	Taints and Tolerations
		Exercise 17.04: Taints and Tolerations
	Using a Custom Kubernetes Scheduler
		Activity 17.01: Configuring a Kubernetes Scheduler to Schedule Pods
	Summary
Chapter 18: Upgrading Your Cluster without Downtime
	Introduction
	The Need to Upgrade Your Kubernetes Cluster
	Kubernetes Components – Refresher
		A Word of Caution
	The Upgrade Process
		Some Considerations for kops
		An overview of the Upgrade Process
		The Importance of Automation
		Backing up the etcd Datastore
		Exercise 18.01: Taking a Snapshot of the etcd Datastore
		Draining a Node and Making It Non-Schedulable
		Exercise 18.02: Draining All the Pods from the Nodes
	Upgrading Kubernetes Master Components
		Exercise 18.03: Upgrading Kubernetes Master Components
	Upgrading Kubernetes Worker Nodes
		Exercise 18.04: Upgrading the Worker Nodes
		Activity 18.01: Upgrading the Kubernetes Platform from Version 1.15.7 to 1.15.10
	Summary
Chapter 19: Custom Resource Definitions in Kubernetes
	Introduction
	What Is a Custom Controller?
		The Relationship between a CRD, a CR, and a Controller
	Standard Kubernetes API Resources
	Why We Need Custom Resources?
		Example Use Case 1
		Example Use Case 2
		Example Use Case 3
	How Our Custom Resources Are Defined
		apiVersion
		kind
		spec
		namespaceName and podLiveForThisMinutes
		The Definition of a CRD
		Exercise 19.01: Defining a CRD
		Exercise 19.02: Defining a CR Using a CRD
		Writing the Custom Controller
			The Components of the Custom Controller
		Activity 19.01: CRD and Custom Controller in Action
		Adding Data to Our Custom Resource
		Exercise 19.03: Adding Custom Information to the CR List Command
	Summary
Index