深入探索Kubernetes与Docker分布式架构

需积分: 9 58 浏览量更新于2024-07-17 收藏 16.04MB PDF 举报

"Exploring Kubernetes" 是一本关于深入理解 Kubernetes 的书籍，由 Marko Lukša 编写，涵盖了从基础到高级的 Kubernetes 和 Docker 技术，旨在帮助读者掌握分布式架构的关键概念。本书分为多个章节，从基础开始介绍 Kubernetes（通常简称为 k8s），这是一个流行的开源容器编排系统，用于自动化容器化应用程序的部署、扩展和管理。Docker 是一种轻量级的虚拟化技术，使得应用可以以容器的形式打包和分发，与 Kubernetes 结合使用时，可以实现高效的云原生应用管理。 Chapter 2 可能会涉及 Kubernetes 的基本概念，包括工作节点（Nodes）、控制器（Controllers）、服务（Services）和部署（Deployments）。在这里，读者将学习如何配置和管理这些组件，以便在 Kubernetes 集群上运行应用程序。 Chapter 3 可能深入探讨了 Docker 容器的生命周期管理，包括构建 Docker 映像、推送至仓库以及在 Kubernetes 集群中拉取和运行这些映像。此外，可能还会介绍容器镜像的最佳实践和安全策略。 Chapter 4 可能涉及 Kubernetes 的扩展性和容错性，如副本集（ReplicaSets）确保应用实例的数量保持恒定，以及如何使用卷（Volumes）持久化数据。读者还将了解到如何使用滚动更新（Rolling Updates）和回滚（Rollbacks）策略来平滑地进行版本升级。 Chapter 5 可能会涵盖更高级的主题，如网络策略（Network Policies）以确保容器间的通信安全，以及服务发现机制，使集群内的服务能够相互找到并通信。此外，可能会讨论 Kubernetes 自动化扩展（Horizontal Pod Autoscaling, HPA）和资源调度（如通过调度器选择最佳节点运行Pod）。此书还强调了实际操作和实践经验，读者可以通过书中提供的案例研究和示例代码来加深对 Kubernetes 工作原理的理解。同时，作者可能分享了一些业界最佳实践，以帮助读者在自己的项目中有效地采用 Kubernetes。 “Exploring Kubernetes” 是一份全面的指南，适合希望理解和掌握 Kubernetes 及其与 Docker 结合使用的开发者和系统管理员。通过阅读这本书，读者将能够构建、部署和管理高度可扩展和可靠的分布式系统。

10 CHAPTER 2 First steps with Docker and Kubernetes

$ ps aux | grep app.js

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

root 382 0.0 0.1 676380 16504 ? Sl 12:31 0:00 node app.js

This proves that processes running in the container are running in the host OS. If you

have a keen eye, you may have noticed that the processes have different IDs inside the

container vs. on the host. The container is using its own PID Linux namespace and

has a completely isolated process tree, with its own sequence of numbers.

THE CONTAINER’S FILESYSTEM IS ALSO ISOLATED

Like having an isolated process tree, each container also has an isolated filesystem.

Listing the contents of the root directory inside the container will only show the files

in the container and will include all the files that are in the image plus any files that

are created while the container is running (log files and similar), as shown in the fol

lowing listing.

root@44d76963e8e1:/# ls /

app.js boot etc lib media opt root sbin sys usr

bin dev home lib64 mnt proc run srv tmp var

It contains the app.js file and other system directories that are part of the node:7 base

image you’re using. To exit the container, you exit the shell with the exit command

and you’ll be returned to your host machine (like logging out of an ssh session, for

example).

TIP Entering a running container like this is useful when debugging an app

running in a container. When something’s wrong, the first thing you’ll want

to explore is the actual state of the system your application sees. Keep in mind

that an application will not only see its own unique filesystem, but also pro-

cesses, users, hostname, and network interfaces.

2.1.7 Stopping and removing a container

To stop your app, you tell Docker to stop the

kubia-container

container:

$ docker stop kubia-container

This will stop the main process running in the container and consequently stop the

container, because no other processes are running inside the container. The con

tainer itself still exists and you can see it with

docker ps -a

. The

-a

option prints out

all the containers, those running and those that have been stopped. To truly remove a

container, you need to remove it with the

docker rm

command:

$ docker rm kubia-container

This deletes the container. All its contents are removed and it can’t be started again.

Listing 2.7 A container’s processes run in the host OS

Listing 2.8 A container has its own complete filesystem

Licensed to UNKNOWN UNKNOWN <pwareact2019@gmail.com>

11Creating, running, and sharing a container image

2.1.8 Pushing the image to an image registry

The image you’ve built so far has only been available on your local machine. To allow

you to run it on any other machine, you need to push the image to an external image

registry. For the sake of simplicity, you won’t set up a private image registry and will

instead push the image to Docker Hub (http://hub.docker.com), which is one of the

publicly available registries. Other widely used such registries are Quay.io and the

Google Container Registry.

Before you do that, you need to re-tag your image according to Docker Hub’s

rules. Docker Hub will allow you to push an image if the image’s repository name

starts with your Docker Hub ID. You create your Docker Hub ID by registering at

http://hub.docker.com. I’ll use my own ID (luksa) in the following examples. Please

change every occurrence with your own ID.

TAGGING AN IMAGE UNDER AN ADDITIONAL TAG

Once you know your ID, you’re ready to rename your image, currently tagged as

“kubia”, to “luksa/kubia” (replace luksa with your own Docker Hub ID):

$ docker tag kubia luksa/kubia

This doesn’t rename the tag; it creates an additional tag for the same image. You can

confirm this in the following listing by listing the images stored on your system with

the

docker images

command.

$ docker images | head

REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE

luksa/kubia latest d30ecc7419e7 About an hour ago 654.5 MB

kubia latest d30ecc7419e7 About an hour ago 654.5 MB

docker.io/node 7.0 04c0ca2a8dad 2 days ago 654.5 MB

...

As you can see, both

kubia

and

luksa/kubia

point to the same Image ID, so they’re in

fact one single image with two tags.

PUSHING THE IMAGE TO DOCKER HUB

Before you can push the image to Docker Hub, you need to log in under your user ID

with the

docker login

command. Once you’re logged in, you can finally push the

yourid/kubia

image to Docker Hub like this:

$ docker push luksa/kubia

RUNNING THE IMAGE ON A DIFFERENT MACHINE

After the push to Docker Hub is complete, the image will be available to everyone.

You can now run the image on any machine running Docker by executing the follow

ing command:

$ docker run -p 8080:8080 -d luksa/kubia

Listing 2.9 A container image can have multiple tags

Licensed to UNKNOWN UNKNOWN <pwareact2019@gmail.com>

12 CHAPTER 2 First steps with Docker and Kubernetes

It doesn’t get much simpler than that. And the best thing about this is that your applica-

tion will have the exact same environment every time and everywhere it’s run. If it ran

fine on your machine, it should run as well on every other Linux machine. No need to

worry about whether the host machine has Node.js installed or not. In fact, even if it

does, your app won’t use it, because it will use the one installed inside the image.

2.2 Setting up a Kubernetes cluster

Now that you have your app packaged inside a container image and made available

through Docker Hub, you can deploy it in a Kubernetes cluster instead of running it

in Docker directly. But first, you need to set up the cluster itself.

Setting up a full-fledged multi-node Kubernetes cluster isn’t a simple task, espe-

cially if you’re not well-versed in Linux and networking administration. A proper

Kubernetes install spans multiple physical or virtual machines and requires the net-

working to be set up properly, so that all the containers running inside the Kuber-

netes cluster can connect to each other through the same flat networking space.

A long list of methods exists for installing a Kubernetes cluster. These methods are

described in detail in the documentation at http://kubernetes.io. We’re not going to

list all of them here, because the list keeps evolving, but Kubernetes can be run on

your local development machine, your own organization’s cluster of machines, on

cloud providers providing virtual machines (Google Compute Engine, Amazon EC2,

Microsoft Azure, and so on) or by using a managed Kubernetes cluster such as Google

Container Engine.

In this chapter, we’ll cover two simple options for getting your hands on a running

Kubernetes cluster. You’ll see how to run a single-node Kubernetes cluster on your

local machine and how to get access to a hosted cluster running on Google Container

Engine (GKE).

A third option, which covers installing a cluster with the kubeadm tool, is explained

in appendix B. The instructions there show you how to set up a three-node 

Kubernetes cluster using virtual machines, but I suggest you try it only after reading

the first 11 chapters of the book.

Another option is to install Kubernetes on Amazon’s AWS (Amazon Web Services).

For this, you can look at the kops tool, which is built on top of kubeadm mentioned in

the previous paragraph, and is available at http://github.com/kubernetes/kops.

It helps you deploy production-grade, highly available Kubernetes clusters on AWS

and will eventually support other platforms as well (Google Container Engine,

VMware, vSphere, and so on).

2.2.1 Running a local single-node Kubernetes cluster with Minikube

The simplest and quickest way to a fully functioning Kubernetes cluster is by using

Minikube. Minikube is a package that sets up a single-node cluster that’s great for both

testing Kubernetes and developing apps locally.

Licensed to UNKNOWN UNKNOWN <pwareact2019@gmail.com>

13Setting up a Kubernetes cluster

Although we can’t show certain Kubernetes features related to managing apps on

multiple nodes, the single-node cluster should be enough for exploring most topics

discussed in this book.

INSTALLING MINIKUBE

Minikube is a single binary that needs to be downloaded and put onto your path. It’s

available for OSX, Linux, and Windows. To install it, the best place to start is to go to

the Minikube repository on GitHub (http://github.com/kubernetes/minikube) and

follow the instructions there.

For example, on OSX and Linux, Minikube can be downloaded and set up with a

single command. For OSX, this is what the command looks like:

$ curl -Lo minikube https://storage.googleapis.com/minikube/releases/

[CA]v0.18.0/minikube-darwin-amd64 && chmod +x minikube && sudo mv minikube

[CA]/usr/local/bin/

On Linux, you download a different release (replace “darwin” with “linux” in the

URL). On Windows, you can download the file manually, rename it to minikube.exe,

and put it onto your path. Minikube runs Kubernetes inside a VM run through either

VirtualBox or KVM, so you also need to install one of them before you can start the

Minikube cluster.

STARTING A KUBERNETES CLUSTER WITH MINIKUBE

Once you have Minikube installed locally, you can immediately start up the Kuber-

netes cluster with the command in the following listing.

$ minikube start

Starting local Kubernetes cluster...

Starting VM...

SSH-ing files into VM...

...

Kubectl is now configured to use the cluster.

Starting the cluster takes more than a minute, so don’t interrupt the command before

it completes.

INSTALLING THE KUBERNETES CLIENT (KUBECTL)

To interact with Kubernetes, you also need the kubectl CLI client. Again, all you need

to do is download it and put it on your path. The latest stable release for OSX, for

example, can be downloaded and installed with the following command:

$ curl -LO https://storage.googleapis.com/kubernetes-release/release

[CA] /$(curl -s https://storage.googleapis.com/kubernetes-release/release

[CA] /stable.txt)/bin/darwin/amd64/kubectl

[CA] && chmod +x kubectl

[CA] && sudo mv kubectl /usr/local/bin/

To download kubectl for Linux or Windows, replace

darwin

in the URL with either

linux

windows

Listing 2.10 Starting a Minikube virtual machine

Licensed to UNKNOWN UNKNOWN <pwareact2019@gmail.com>

14 CHAPTER 2 First steps with Docker and Kubernetes

NOTE If you’ll be using multiple Kubernetes clusters (for example, both

Minikube and GKE), refer to appendix A for information on how to set up

and switch between different kubectl contexts.

CHECKING TO SEE THE CLUSTER IS UP AND KUBECTL CAN TALK TO IT

To verify your cluster is working, you can use the

kubectl cluster-info

command in

the following listing.

$ kubectl cluster-info

Kubernetes master is running at https://192.168.99.100:8443

KubeDNS is running at https://192.168.99.100:8443/api/v1/proxy/...

kubernetes-dashboard is running at https://192.168.99.100:8443/api/v1/...

This shows the cluster is up. It shows the URLs of the various Kubernetes components,

including the API server and the web console.

TIP You can run

minikube ssh

to log into the Minikube VM and explore it

from the inside. For example, you may want to see what processes are run-

ning on the node.

2.2.2 Using a hosted Kubernetes cluster with Google Container Engine

If you want to explore a full-fledged multi-node Kubernetes cluster instead, you can

use a managed Google Container Engine (GKE) Kubernetes cluster. This way, you

don’t need to manually set up all the cluster nodes and networking, which is usually

too much for someone making their first steps with Kubernetes. Using a managed

solution such as GKE makes sure you don’t end up with a misconfigured, non-work

ing, or partially working cluster.

SETTING UP A GOOGLE CLOUD PROJECT AND DOWNLOADING THE NECESSARY CLIENT BINARIES

Before you can set up a new Kubernetes cluster, you need to set up your GKE environ-

ment. Because the process may change, I’m not listing the exact instructions here. To

get started, please follow the instructions at https://cloud.google.com/container-

engine/docs/before-you-begin.

Roughly, the whole procedure includes

1 Signing up for a Google account, in the unlikely case you don’t have one

already.

2 Creating a project in the Google Cloud Platform Console.

3 Enabling billing. This does require your credit card info, but Google provides a

12-month free trial. And they’re nice enough to not start charging automati-

cally after the free trial is over.)

4 Enabling the Container Engine API.

Listing 2.11 Displaying cluster information

Licensed to UNKNOWN UNKNOWN <pwareact2019@gmail.com>

剩余150页未读，继续阅读

wangyao98hf0508

粉丝: 0
资源: 1

深入探索Kubernetes与Docker分布式架构

springboot187社区养老服务平台的设计与实现.zip

HAL库STM32F103C8T6 IAP升级实验程序

操作系统实验-基于System V信号量的读者写者问题同步原理探讨

Web前端大作业-个人网页HTML+CSS+JavaScript（高分项目）

PSO优化CNN-LSTM做预测，即PSO-CNN-LSTM 优化的是隐藏层单元数目，初始学习率等网络参数 预测精度要高于CNN-LSTM

数据结构课设-C++小型图书馆管理系统-MySQL

Comsol光栅波导耦合器，耦合效率计算 经典复古小案例

TensorRTLLM为用户提供了一个简单易用的Python API来定义大型语言模型llm，并构建包含状态优化的Te.zip

springboot150基于springboot的贸易行业crm系统.zip

markdown编辑器，使用electron开发

最新资源

PSO优化CNN-LSTM做预测，即PSO-CNN-LSTM 优化的是隐藏层单元数目，初始学习率等网络参数预测精度要高于CNN-LSTM

Comsol光栅波导耦合器，耦合效率计算经典复古小案例