Quick Start Kubernetes E-Book

Nigel Poulton

• Herausgeber: WS
• Kategorie: Fachliteratur
• Sprache: Englisch

Seitenzahl: 80

Veröffentlichungsjahr: 2023

Beschreibung

2025 Edition - Fully Updated for the Latest Kubernetes versions and features!
Are you ready to take your tech career to the next level? Curious about Kubernetes but don't know where to start? Look no further!
Quick Start Kubernetes by best-selling author Nigel Poulton is the ultimate beginner's guide to Kubernetes - the revolutionary technology driving the future of modern applications and infrastructure.
Whether you're a newcomer or looking to expand your expertise, this concise hands-on book will take you from zero to Kubernetes-ready in just 100 pages - no prior experience required!
What you'll learn:
- The fundamentals: What Kubernetes is and why it matters
- The critical role of Kubernetes in modern infrastructure and applications
Real-world skills you'll gain:
- Set up Kubernetes on your laptop and in the cloud
- Containerize applications
- Deploy, manage, and scale applications on Kubernetes
- Configure Kubernetes to self-heal applications
- Perform rolling updates like a pro
Nigel's straightforward explanations cut through the jargon, helping you grasp even the most complex concepts with ease. This is more than just a book - it's a practical guide designed to get your hands dirty with real-world tasks.
Why choose this book?
- Fast and focused: Gain actionable Kubernetes knowledge in 100 pages
- Superbly organised: Everything in one place, in order, packed with easy-to-follow examples
- Hands-on learning: Step-by-step exercises ensure you retain what you learn
- Career-boosting insights: Master the skills hiring managers are looking for
When you're done, you won't just understand Kubernetes - you'll have the confidence to apply it in the real world and unlock exciting career opportunities.
Get started today with Kubernetes and take the first step toward advancing your tech career!

Leseprobe

Quick Start

Kubernetes

2025 Edition

The fastest way to get your head around Kubernetes!

Nigel Poulton @nigelpoulton

About the author

Nigel Poulton (@nigelpoulton)

Nigel is a technology geek who is passionate about learning new technologies and making them easier for others to learn. He's the author of best-selling books on Docker and Kubernetes, and is the author of AI Explained: Facts, Fiction, and Future, an exciting read into the impacts of AI on society and the future of humanity. .

Nigel is a Docker Captain and has held senior technology roles at large and small enterprises.

In his free time, he listens to audiobooks and watches science fiction. He wishes he lived in the future and could explore space-time, the universe, and other mind-bending phenomena. He's passionate about learning, cars, and football (soccer). He lives in England with his fabulous wife and three children.

•LinkedIn: Nigel Poulton

•Web: nigelpoulton.com

•BlueSky: @nigelpoulton

•X: @nigelpoulton

•Email: [email protected]

Table of Contents

About the book

Chapter overview

What you’ll learn

Will the book make you a Kubernetes expert

Will you know what you’re talking about when you finish the book

Editions

Terminology and responsible language

Feedback

The sample app

1: What is Kubernetes

Microservices

Cloud-native

Orchestration

Other useful Kubernetes things to know

Chapter summary

2: Why Kubernetes is so important

Why the cloud providers need Kubernetes

Why users need Kubernetes

Chapter Summary

3: Kubernetes architecture

Control plane nodes and worker nodes

Hosted Kubernetes

Managing Kubernetes with the

kubectl

command line tool

Chapter summary

4: Getting Kubernetes

Install Docker and

kubectl

with Docker Desktop

Create a multi-node Kubernetes cluster with Docker Desktop

Create a multi-node Kubernetes cluster in the Civo Cloud

Get the sample app

Chapter summary

5: Containerizing an app

Pre-requisites

The sample app

Containerize the app

Share the image on a registry

Chapter summary

6: Running an app on Kubernetes

Pre-reqs

Deploy the app to Kubernetes

Connect to the app

Clean-up

Chapter summary

7: Self-healing

Intro to Kubernetes Deployments

Self-heal from an app failure

Self-heal from a worker node failure

Chapter summary

8: Scaling the app

Pre-requisites

Scale an application up

Scale an application down

Chapter summary

9: Performing a rolling update

Pre-requisites

Deploy the rollout

Clean-up

Chapter summary

10: What next

Books

Video courses

Events

Show some love

Let’s connect

Appendix A: Lab code

Chapter 5: Creating a containerized app

Chapter 6: Running an app on Kubernetes

Chapter 7: Adding self-healing

Chapter 8: Scaling the app

Chapter 9: Performing a rolling update

Terminology

More from the author

Landmarks

Begin Reading

About the book

This book has two goals:

Get you up-to-speed with Kubernetes fastExplain everything as clearly as possible

I’ve carefully chosen the most important topics and hand-crafted every chapter and example so the book is fun and engaging while you learn.

You’ll love the book if you’re in a hands-on role and just getting started with Kubernetes. You’ll also love it if you work in technical marketing, sales, management, architecture, operations, and more.

Chapter overview

The book has nine main chapters packed with theory and hands-on demos.

Chapter 1: Introduces you to the concepts and clarifies important jargonChapter 2: Explains why Kubernetes is so importantChapter 3: Gets you up-to-speed with the main components of KubernetesChapter 4: Shows you how to get KubernetesChapter 5: Walks you through containerizing a simple appChapter 6: Deploys the containerized app to KubernetesChapter 7: Demonstrates self-healing from various application and infrastructure failuresChapter 8: Shows you how to scale an app up and downChapter 9: Rounds everything out with a zero-downtime rolling update

What you’ll learn

You’ll learn why we have Kubernetes, what it is, and where it’s going.

On the theory front, you’ll learn about microservices, orchestration, why Kubernetes is the OS of the cloud, and Kubernetes architecture. On the hands-on front, you’ll build a cluster, containerize an app, deploy it, break it, see Kubernetes fix it, scale it, and perform a rolling update.

And as this is a quick start guide, you’ll be up-to-speed in no time.

Will the book make you a Kubernetes expert

No, but it will kickstart you on your journey to becoming an expert.

Will you know what you’re talking about when you finish the book

Yes, you’ll know more than enough to start deploying and managing simple apps on Kubernetes.

Editions

The following English language editions are available on Amazon and all good book retailers:

PaperbackEbook

Several translations and an audio version are also available.

Terminology and responsible language

Throughout the book, I capitalize Kubernetes API objects. Wow, we haven’t even started, and I’m throwing jargon around!

Put more simply, I spell Kubernetes features, such as Pods and Services, with a capital letter. This helps you know when I’m talking about a Kubernetes “Pod” and not a “pod” of whales.

The book also follows guidelines from the Inclusive Naming Initiative, which promotes responsible language.

Feedback

If you like the book and it helps your career, share the love by recommending it to a friend and leaving a review on Amazon, Goodreads, or wherever you buy your books.

For other feedback, you can reach me at [email protected].

The sample app

This is a hands-on book with a sample web app.

You can find the app and all supporting files on GitHub at:

https://github.com/nigelpoulton/qsk-book/

Don’t stress about the app and GitHub if you’re not a developer. The focus of the book is Kubernetes, and we explain everything as we go. You also don’t need to be a GitHub expert.

The code for the app is in the App folder and comprises the following files.

app.js: The main application filebootstrap.css: Design template for the application’s web pagepackage.json: List of application dependenciesviews: Folder with the contents of the application’s web pageDockerfile: Tells Docker how to containerize the app

If you want to download the app now, run the following command. You’ll need git installed on your machine. Later in the book we’ll show you how to get git and download the app.

$ git clone https://github.com/nigelpoulton/qsk-book.git $ cd qsk-book

Finally, I update the application and dependencies every year to keep it clean and hopefully free from vulnerabilities.

1: What is Kubernetes

Kubernetes is an orchestrator of cloud-native microservices applications.

That’s a lot of jargon, so let’s explain the following terms:

MicroservicesCloud-nativeOrchestration

Microservices

In the past, we built and deployed monolithic applications. That’s jargon for complex applications where every feature is developed, deployed, and managed as a single large object.

Figure 1.1 shows a monolithic app with six features — web front end, authentication, middleware, logging, data store, and reporting. These are built, deployed, and managed as a single large application, meaning if you need to change any part, you need to change it all.

Figure 1.1

As a quick example, if you need to update the reporting feature, you need to take the entire app down and update the whole thing. This leads to high-risk updates requiring months of advanced planning and implementation over long weekends.

However, the pain of monolithic applications doesn’t stop there. If you want to scale a single feature, you have to scale the whole thing.

On the flip side, microservices applications take the same set of features and treats each as its own small application. Another word for “small” is “micro”, and another word for “application” is “service”. Hence, the term microservice.

If you look closely at Figure 1.2, you’ll see it’s the same application as Figure 1.1. The only difference is that each feature is developed independently, each is deployed independently, and each can be updated and scaled independently. But they work together to create the same application experience.

The most common pattern is developing and deploying each microservice as its own container. This way, if you need to scale the reporting service, you just add more reporting containers. If you need to update the reporting service, deploy a new reporting container and delete the old one.

Figure 1.2

We loosely couple each microservice over the network, and each one exposes an API that others can consume. These two principles allow us to change individual microservices without affecting others.

The following car analogy might help if you’re new to the concept of APIs.

Cars come in all shapes and sizes — sports cars, SUVs, trucks, petrol, diesel, electric, hybrid, hydrogen fuel cell, etc. However, these differences are hidden from drivers behind a standard set of controls, including a steering wheel and foot pedals. In this model, the steering wheel and foot pedals are the car’s API — how we consume its capabilities. This means a driver can get into any car in the world and be able to drive it. For example, I learned to drive in a front-wheel-drive petrol-engine car with the steering wheel on the right and a manual gearbox. However, I can step into an all-wheel drive electric car with the steering wheel on the left and be able to drive it without having to learn any new skills.