Part 1 Introduction
CHAPTER 01 Containers and Kubernetes
1.1 Overview of Container Technology
What is a container?
Flow of container application development
1.2 Overview of Kubernetes
Managing container operations in a distributed environment
Features of Kubernetes
Introduction to Kubernetes
Kubernetes Use Cases
1.3 Summary

CHAPTER 02 Setting Up a Kubernetes Environment
2.1 Container Application Development Flow
Development and Operation Flow Using Kubernetes
Kubernetes-related services on Azure
2.2 Preparing the development environment
Install Visual Studio Code
Installing Azure CLI Commands
Installing the Kubectl Command
Using Azure Cloud Shell
2.3 Building and Publishing Container Images
Azure Container Registry
Building and sharing container images using ACR
2.4 Creating a Kubernetes Cluster Using Azure
Building a Cluster Using AKS
Basic cluster operations using kubectl commands
2.5 Summary

CHAPTER 03 Let's Move Kubernetes
3.1 Deploying the Application
Basic flow of deployment
3.2 Creating a manifest file
Setting up a container application
Setting up the service
3.3 Creating Resources in a Cluster
Deploying the application
Open the service
3.4 Verifying the operation of the application
3.5 Summary


Part 2 Basics
CHAPTER 04 The Essentials of Kubernetes
4.1 Kubernetes Concepts
Immutable Infrastructure
Declarative settings
Self-healing function
4.2 Kubernetes Architecture
Scheduling and Discovery
Kubernetes server configuration
Components of Kubernetes
Credentials to access the cluster
4.3 Kubernetes Resources
Running the application (Pod/ReplicaSet/Deployment)
Network Management (Service/Ingress)
Managing application configuration information (ConfigMap/Secrets)
Batch Job Management (Job/CronJob)
4.4 Manifest File
Manifest file basics
YAML grammar
4.5 Managing Resources Using Labels
Label
Finding resources using LabelSelector
4.6 Resource Isolation in Kubernetes
4.7 Summary

CHAPTER 05 Running Container Applications
5.1 Managing Container Applications Using Pods
ford
Manifest file
Create, change, and delete pods
Ford's design patterns
5.2 Ford's scheduling structure
How are pods placed?
How do I decide on which nodes to deploy a pod?
Explicitly set the node that moves the pod
5.3 Move the pod efficiently
Check the CPU and memory resources of the node
Allocate memory and CPU required for the pod
Setting the upper limits of the pod's memory and CPU
What happens if a pod fails?
Pod's priority (QoS)
5.4 Let's monitor the pod
Monitoring container applications
Check the return value of an HTTP request
Check if a connection can be made via TCP Socket
Check the execution result of the command
5.5 Manage multiple pods with ReplicaSet
ReplicaSet
Manifest file
Creating, modifying, and deleting replica sets
How do I control the state within a cluster?
What happens if a pod fails?
What happens to pods if a node fails?
5.6 Let's change the number of pods depending on the load.
Scalability
Manually scale the pod horizontally
Automatically scale pods horizontally
Structure of HPA
5.7 Summary

CHAPTER 06 APPLICATION DEPLOYMENT
6.1 Deploying Applications Using Deployment
The concept of application version upgrade
Deployment
Manifest file
Create, change, and delete deployments
6.2 Deployment Structure
How updates are handled
Rollout
Rollback
Rollout conditions
Rolling update control
Blue/Green Deployment
6.3 Manage application settings information
Managing application settings information
Reference ConfigMap values
Password and Key Management
Reference Secrets values
6.4 Summary


Part 3: Practical
CHAPTER 07 Architecture and Design Principles
7.1 Kubernetes Architecture
Relationship with infrastructure
7.2 Kubernetes Design Principles
Reconciliation Loops and Level Trigger Logic
API's watch option
Event Chain
7.3 Building Services and Products
Kubernetes Conformance Partner
Infrastructure required for a Kubernetes cluster
Tasks required to build a Kubernetes cluster
AKS Architecture and Cloud Controller Manager
7.4 Summary

CHAPTER 08 Availability
8.1 Availability of Kubernetes
Master availability (both active etcd and API Server)
Master availability (active/standby components)
Node availability
How to distribute the number of points? (Master)
How to distribute the number of nodes? (Node)
8.2 Infrastructure Perspective
Blast Radius
Software-based Blast Radius
Layout example
Deployment with physical servers in mind
Rack-conscious layout
Data center-conscious deployment
Deployment with wide-area disaster in mind
AKS deployment example
8.3 Summary

CHAPTER 09 Scalability
9.1 Horizontal Autoscaling of Kubernetes Nodes
Cluster Autoscaler
9.2 Cluster Autoscaler in AKS
Creates a Pending state
Introduction of Cluster Autoscaler
Node scale-out
Setting upper and lower limits for the number of nodes
Node scale in
Infrastructure manipulation permissions and secret management
9.3 Other Autoscale
Integration of HPA and Cluster Autoscaler
Autoscaling using metrics outside of Kubernetes
9.4 Summary

CHAPTER 10 Maintainability
10.1 Updates and Upgrades Required for Kubernetes Operations
10.2 Server Update
Devices that minimize the impact of node restarts
Cordon/Uncordon
Drain
PodDisruptionBudget
To automatically perform a node restart
10.3 Kubernetes Component Updates
Example using kubeadm (v1.10 -> v1.11)
Upgrade Strategy (In Place)
Upgrade Strategy (Blue/Green Deployment)
10.4 Summary

CHAPTER 11 Resource Separation (Security)
11.1 Units of Separation for Kubernetes Resources
People, organizations, and responsibilities
Pros and Cons of Cluster Separation
11.2 Separation using namespaces
Namespace organization
11.3 Kubernetes Accounts
User Account
Service Account
11.4 Authentication and Authorization in Kubernetes
certification
impression
Admission Control
11.5 RBAC (Role Based Access Control)
Resource representation and manipulation
Role and RoleBinding
Linking Users and Roles
Linking a service account and a role
11.6 Limits on resource usage
LimitRange
ResourceQuota
Distinction between three upper limit setting functions
11.7 Summary

CHAPTER 12 Observability
12.1 What is observability?
Background of the term's birth
Observability of Kubernetes environments
12.2 Observation Objects and Methods
Metric
log
Distributed tracing
12.3 Representative software and services
12.4 Metrics Collection and Visualization, Log Analysis in AKS
Azure Monitor
Azure Monitor for Containers
Azure Log Analytics
12.5 Summary


APPENDIX Command Reference
A.1 kubectl commands
A.2 Azure CLI Commands

Introduction to Building Infrastructure with Kubernetes

This book is an introductory book that explains the basic structure of Kubernetes.
Kubernetes contains many abstract concepts, which can be a bit daunting for beginners to learn. However, this book explains how it works internally and why it behaves that way, using easy-to-understand words and illustrations.
It also provides detailed explanations of practical concepts that must be reviewed when actually introducing a system, such as system availability, scalability, and maintainability.


Kubernetes is sophisticated open-source software packed with know-how for running containers in distributed systems.
Because excellent engineers from around the world are actively involved in its development and development is still in progress, it is not possible to cover all its features in this book.
However, I hope that this book will provide an opportunity to share the fundamental concepts and continue to learn about Kubernetes as it evolves together with you, the readers.

[Keywords covered in the book]
- Overview of container technology and Kubernetes
- Creating a Kubernetes cluster using Azure
- Deployment of the application
- Managing container applications using pods
- Managing multiple pods with ReplicaSet
- Deploying applications using deployment
- Availability of Kubernetes
- Updates and upgrades required for Kubernetes operation
- Authentication and Authorization in Kubernetes
- AKS metrics collection and visualization, log analysis