Beginning Kubernetes on the Google Cloud Platform: A Guide to Automating Application Deployment, Scaling, and Management

ISBN-13: 9781484254905 / Angielski / Miękka / 2019 / 324 str.

Ernesto Garbarino

Opis

Beginning user level

Spis treści

Chapter 1: Introduction

Setting Up a Cluster

Listing Clusters

Deleting a Cluster

Getting Login Credentials

Installing Kubectl

Checking Kubectl Version

Using GCE Credentials

Clusters and Nodes

Nodes

Nodes’ Resource Consumption

Hello World Application

 

Chapter 2: Pods

The Fastest Way to Launch a Pod

Launching a Single Pod

Launching a Sigle Pod to Run a Command

Running a Pod Interactively

Interacting with an Existing Pod

Retrieving and Following Pod’s Logs

Interacting with a Pod’s TCP Port

Transferring Files From and To a Pod

Selecting a Pod’s Container

Troubleshooting Pods

Pod Manifests

Declaring Containers’ Network Ports

Setting Up the Container’s Environment

Overwriting The Container’s Command

Managing Containers’ CPU and RAM Requirements

Pod Volumes and Volume Mounts

External Volumes and Google Cloud Storage

Pod Health and Lifecycle

Namespaces

Labels

Annotations

 

Chapter 3: Deployments and Scaling

ReplicaSets

Our First Deployment

More on Listing Deployments

Deployments Manifests

Monitoring and Controlling a Deployment

Finding Out a Deployment’s ReplicaSets

Finding Out a ReplicaSet’s Pods

Deleting Deployments

Revision-Tracking vs Scaling-Only Deployments

Recreate Deployments

Rolling Update Deployments

The Pros and Cons of a Higher MaxSurge Value

The Pros and Cons of a High MaxUnavailable Value

Blue/Green Deployments

Summary of MaxSurge and MaxUnavailability Settings

Controlled Deployments

Rollout History

Rolling Back Deployments

The Horizontal Pod Autoscaler

Setting Up Autoscaling

Observing Autoscaling in Action

Scaling the Kubernetes Cluster Itself

 

Chapter 4: Service Discovery

Introduction

The Service Controller

Finding Pods’ IP Addresses

Accessing a Pod From Within Another Pod

Accessing Pod(s) From Within a LAN

Accessing Pod’s From The Internet

Listing All Running Services

Deleting a Service

Accessing Services in Different Namespaces

Exposing Services on a Different Port

Waiting for a Public IP Address To Be Assigned

Canary Releases

Canary Releases and Inconsistent Versions

Exposing Multiple Ports

Graceful Startup and Shutdown

Zero-Downtime Deployments

Pods’ Endpoints

Listing and Deleting Services

 

Chapter 5: ConfigMap and Secrets

Storing Configuration Properties in Kubernetes

Getting New Configuration Automatically

Picking Selected Properties From a ConfigMap

Passing ConfigMap’s values to a Pod’s Startup Arguments?

Updating a ConfigMap

Loading ConfigMap’s Properties From a File

Storing Large Text in a ConfigMap

Retrieving a Large File Stored in a ConfigMap

Live ConfigMap Updates

Storing Binary Data

Secrets

Difference Between ConfigMap and Secret Objects

Reading Properties From Secrets

Docker Registry Credentials

TLS Public Key Pair

Listing and Deleting ConfigMap and Secret Objects

 

Chapter 6: Jobs

One-off Process

Multiple Independent Processes

Multiple Coordinated Processes

Advanced Batch Scaling and Control

Waiting until a job completes

Timing out stuck jobs

Other Restart Policies

Managing and Deleted Jobs

Wrap-Up

 

Chapter 7: CronJobs

The Simplest Possible CronJob

Setting Up Recurring Tasks

Setting Up One-Off Tasks

Jobs History

Interacting with CronJob’s Jobs and Pods

Suspending a CronJob

Job Concurrency

Catching Up With Missed Sheduled Events

Management (Listing, Deleting and Suspending)

 

Chapter 8: DaemonSets

TCP-based Daemons

File System-based Daemons

Daemons that Run on Specific Nodes Only

Update Strategy

General Administration

Wrap Up

 

Chapter 9: StatefulSets

The Dumbest Key/Value Store In The World

Minimal StatefulSet Manifest

Sequential Pod Creation

Stable Network Identity

Headless Service

A Smart Client For a Dumb Key/Value Store

Controlling The Creation and Termination of a Backing Store

Order of Pod Life Cycle Events

Implementing Graceful Shutdown using Pod Life Cycle Hooks

Observing StatefulSet Failures

Scaling Up and Down

Scaling Down

Scaling Up

Conclusions on Scaling Up and Down Operations

Proper Statefulness: Persistence to Disk

Persistent Volume Claims

Wrap Up

O autorze

Ernesto Garbarino is a consultant specialized in the Digital, Cloud, and DevOps domains. His 20 year experience ranges from working with early start-ups and entrepreneurial organizations during the dot com era to senior consultancy work in blue chip industries including telecoms, logistics, and banking. 

Blurb

Use this beginner’s guide to understand and work with Kubernetes on the Google Cloud Platform and go from single monolithic Pods (the smallest unit deployed and managed by Kubernetes) all the way up to distributed, fault-tolerant stateful backing stores.

You need only a familiarity with Linux, Bash, and Python to successfully use this book. Proficiency in Docker or cloud technology is not required. You will follow a learn-by-doing approach, running small experiments and observing the effects.

Google open sourced Kubernetes in 2015 and now it is the standard in container orchestration and adopted by Microsoft (Azure PKS) and Amazon (AWS EKS) in the public cloud, and RedHat (OpenShift) and Pivotal (PKS) in the private cloud. Even though Kubernetes is offered by all of the market-leading cloud providers, the Google Cloud Platform (GCP) offers an integrated shell (Google Cloud Shell) and a $300 credit to get started, which makes it the ideal platform to not only learn Kubernetes but also to implement final production workloads.

You will:

• Set up a Kubernetes cluster in GCP
• Deploy simple Docker images using monolithic Pods
• Arrange highly available and highly scalable applications using Deployments
• Achieve zero-downtime deployments using the Service controller
• Externalize configuration using ConfigMaps and Secrets
• Set up batch processes and recurrent tasks using Jobs and CronJobs
• Install horizontal (sidecar pattern) services using DaemonSets
• Implement distributed, stateful backing stores using StatefulSets