Cloud Native DevOps with Kubernetes, 2nd Edition

Book description

Kubernetes has become the operating system of today's cloud native world, providing a reliable and scalable platform for running containerized workloads. In this friendly, pragmatic book, cloud experts Justin Domingus and John Arundel show your development and operations staff what Kubernetes can do--and what you can do with it.

This updated second edition guides you through the growing Kubernetes ecosystem and provides practical solutions to everyday problems using tools currently in use in the software industry. You'll walk through an example containerized application running in Kubernetes step-by-step, from the development environment through the continuous deployment pipeline, with patterns you can use for your own applications. Make your development teams lean, fast, and effective by adopting Kubernetes and DevOps principles.

  • Understand containers and Kubernetes--no experience necessary
  • Run your own applications on managed cloud Kubernetes services or on-premises environments
  • Design your own cloud native services and infrastructure
  • Use Kubernetes to manage resource usage and the container lifecycle
  • Optimize clusters for cost, performance, resilience, capacity, and scalability
  • Learn the best tools for developing, testing, and deploying your applications
  • Apply the latest industry practices for observability and monitoring
  • Secure your containers and clusters in production

Publisher resources

View/Submit Errata

Table of contents

  1. 1. Revolution in the Cloud
    1. The Creation of the Cloud
      1. Buying Time
      2. Infrastructure as a Service
    2. The Dawn of DevOps
      1. Improving Feedback Loops
      2. What Does DevOps Mean?
      3. Infrastructure as Code
      4. Learning Together
    3. The Coming of Containers
      1. The State of the Art
      2. Thinking Inside the Box
      3. Putting Software in Containers
      4. Plug and Play Applications
    4. Conducting the Container Orchestra
    5. Kubernetes
      1. From Borg to Kubernetes
      2. Why Kubernetes?
      3. Will Kubernetes Disappear?
      4. Kubernetes Is Not a Panacea
    6. Cloud Native
    7. The Future of Operations
      1. Distributed DevOps
      2. Some Things Will Remain Centralized
      3. Developer Productivity Engineering
      4. You Are the Future
    8. Summary
  2. 2. First Steps with Kubernetes
    1. Running Your First Container
      1. Installing Docker Desktop
      2. What Is Docker?
      3. Running a Container Image
    2. The Demo Application
      1. Looking at the Source Code
      2. Introducing Go
      3. How the Demo App Works
    3. Building a Container
      1. Understanding Dockerfiles
      2. Minimal Container Images
      3. Running docker image build
      4. Naming Your Images
      5. Port Forwarding
    4. Container Registries
      1. Authenticating to the Registry
      2. Naming and Pushing Your Image
      3. Running Your Image
    5. Hello, Kubernetes
      1. Running the Demo App
      2. If the Container Doesn’t Start
    6. Minikube
    7. Summary
  3. 3. Getting Kubernetes
    1. Cluster Architecture
      1. The Control Plane
      2. Node Components
      3. High Availability
    2. The Costs of Self-Hosting Kubernetes
      1. It’s More Work Than You Think
      2. It’s Not Just About the Initial Setup
      3. Tools Don’t Do All the Work for You
      4. Kubernetes The Hard Way
      5. Kubernetes Is Hard
      6. Administration Overhead
      7. Start with Managed Services
    3. Managed Kubernetes Services
      1. Google Kubernetes Engine (GKE)
      2. Cluster Autoscaling
      3. Autopilot
      4. Amazon Elastic Kubernetes Service (EKS)
      5. Azure Kubernetes Service (AKS)
      6. IBM Cloud Kubernetes Service
      7. DigitalOcean Kubernetes
    4. Kubernetes Installers
      1. kops
      2. Kubespray
      3. kubeadm
      4. Rancher Kubernetes Engine (RKE)
      5. Puppet Kubernetes Module
    5. Buy or Build: Our Recommendations
      1. Run Less Software
      2. Use Managed Kubernetes if You Can
      3. But What About Vendor Lock-in?
      4. Bare-Metal and On-Prem
      5. Multi-Cloud Kubernetes Clusters
      6. OpenShift
      7. Anthos
      8. Use Standard Kubernetes Self-Hosting Tools if You Must
    6. Clusterless Container Services
      1. Amazon Fargate
      2. Azure Container Instances (ACI)
      3. Google Cloud Run
    7. Summary
  4. 4. Working with Kubernetes Objects
    1. Deployments
      1. Supervising and Scheduling
      2. Restarting Containers
      3. Creating Deployments
    2. Pods
    3. ReplicaSets
    4. Maintaining Desired State
    5. The Kubernetes Scheduler
    6. Resource Manifests in YAML Format
      1. Resources Are Data
      2. Deployment Manifests
      3. Using kubectl apply
      4. Service Resources
      5. Querying the Cluster with kubectl
      6. Taking Resources to the Next Level
    7. Helm: A Kubernetes Package Manager
      1. Installing Helm
      2. Installing a Helm Chart
      3. Charts, Repositories, and Releases
      4. Listing Helm Releases
    8. Summary
  5. 5. Managing Resources
    1. Understanding Resources
      1. Resource Units
      2. Resource Requests
      3. Resource Limits
      4. Quality of Service
      5. Keep Your Containers Small
    2. Managing the Container Life Cycle
      1. Liveness Probes
      2. Probe Delay and Frequency
      3. Other Types of Probes
      4. Readiness Probes
      5. Startup Probes
      6. gRPC Probes
      7. File-Based Readiness Probes
      8. minReadySeconds
      9. Pod Disruption Budgets
    3. Using Namespaces
      1. Working with Namespaces
      2. What Namespaces Should I Use?
      3. Service Addresses
      4. Resource Quotas
      5. Default Resource Requests and Limits
    4. Optimizing Cluster Costs
      1. Kubecost
      2. Optimizing Deployments
      3. Optimizing Pods
      4. Vertical Pod Autoscaler
      5. Optimizing Nodes
      6. Optimizing Storage
      7. Cleaning Up Unused Resources
      8. Checking Spare Capacity
      9. Using Reserved Instances
      10. Using Preemptible (Spot) Instances
      11. Keeping Your Workloads Balanced
    5. Summary

Product information

  • Title: Cloud Native DevOps with Kubernetes, 2nd Edition
  • Author(s): Justin Domingus, John Arundel
  • Release date: May 2022
  • Publisher(s): O'Reilly Media, Inc.
  • ISBN: 9781098116767