Logo

菜单

发布于 2026-01-06 1 阅读
0

Kubernetes for Everyone: A Step-by-Step Guide for Beginners

Kubernetes 入门指南：一步一步教你上手

目录

  1. 介绍
  2. 第一章：了解基础知识
  3. 第二章：搭建环境
  4. 第三章：你的第一个 Kubernetes 部署
  5. 第四章：探索 Kubernetes 特性
  6. 第五章：管理 Kubernetes
  7. 第六章：最佳实践和技巧
  8. 结论
  9. 附录

介绍

欢迎来到 Kubernetes 的世界！

如果你是新手，可能会被各种专业术语和 Kubernetes 的强大功能弄得有点不知所措。这完全正常。Kubernetes 的确是一个强大的工具，但它并不一定令人望而生畏。

本指南旨在成为您掌握 Kubernetes 之旅的友好伙伴。

什么是Kubernetes？

Kubernetes 是一个开源平台，可自动部署、扩展和管理容器化应用程序。Kubernetes 由 Google 开发，已成为容器编排的事实标准。它简化了管理跨多个环境分布的应用程序的复杂任务，确保应用程序高效可靠地运行。

为什么要学习 Kubernetes？

学习 Kubernetes 将为你开启无限机遇。以下是它值得你投入时间学习的原因：

  • 行业标准： Kubernetes 在科技行业得到广泛应用。无论您是希望提升职业发展还是增强现有技能，Kubernetes 都是您简历上的宝贵资产。

  • 可扩展性：借助 Kubernetes，生产环境中的应用程序管理变得更加轻松高效。它能够无缝处理扩展，确保您的应用程序可以轻松应对不断增长的流量。

  • 弹性： Kubernetes 会自动监控应用程序的运行状况，并替换或重启发生故障的容器。这种内置的弹性意味着更少的停机时间和更高的可靠性，从而为用户带来更佳的使用体验。

  • 可移植性： Kubernetes 可在不同的环境上运行——本地部署、云端或混合部署。这种灵活性使您可以将应用程序运行在最合适的位置。

初学者之旅

刚开始接触 Kubernetes 可能会觉得难以上手，但只要采用结构化的方法，它就变得易于管理。

我们将从基础知识入手，把复杂的概念拆解成易于理解的部分。您将学习什么是容器，以及它们与传统虚拟机的区别。我们将逐步搭建您的环境，以便您可以在自己的机器上进行操作。

看完本指南，您将在 Kubernetes 上部署您的第一个应用程序，并探索其一些强大的功能。

记住，每个专家都曾是新手。慢慢来，实践所学，不要害怕犯错。Kubernetes 是一个庞大的生态系统，但有了这份指南，你将拥有一个坚实的基础。

第一章：了解基础知识

学习 Kubernetes 需要对一些基础概念有扎实的掌握。

我们将首先了解什么是容器以及它们为何至关重要。然后，我们将继续解释 Kubernetes 本身的关键概念。

到最后，你将掌握足够的知识，自信地驾驭 Kubernetes 环境。

什么是容器？

容器会将应用程序及其所有依赖项、库和运行所需的配置文件打包在一起。它们在开发和部署的不同阶段创建一致的环境。

容器是便携、轻便且自给自足的单元，可以在任何地方运行——从你的笔记本电脑到功能强大的云服务器。

与传统虚拟机 (VM) 不同，容器共享宿主机操作系统内核。这使得它们在资源利用率和速度方面更加高效。您可以在单个虚拟机上运行多个容器，每个容器都相互隔离且轻​​量级，从而确保您的应用程序兼具可扩展性和可移植性。

为了更好地理解容器，让我们来分析一下它们的主要优点：

  • 一致性：容器确保应用程序无论部署在何处都能以相同的方式运行。这种一致性减少了因环境差异而导致的错误。

  • 效率：由于容器共享宿主机操作系统内核，因此它们比虚拟机更轻量级。这意味着更快的启动速度和更高的资源利用率。

  • 可扩展性：容器可以通过添加更多容器实例轻松实现水平扩展。Kubernetes 负责编排，确保您的应用程序能够应对不断增加的负载。

  • 隔离：容器提供进程和文件系统隔离，通过将潜在威胁限制在各个容器内来提高安全性。

Docker 和容器运行时简介

为了管理这些容器，我们需要一个容器运行时环境。

Docker 是完成这项工作最知名的工具。Docker 提供了一种使用容器轻松创建、部署和运行应用程序的方法。

但 Docker 只是众多容器运行时之一。其他的还包括 containerd 和 CRI-O，它们也在 Kubernetes 生态系统中被广泛使用。

创建 Docker 容器时，首先要编写 Dockerfile 文件。这个简单的脚本定义了应用程序所需的运行环境。

您将 Dockerfile 构建成一个镜像，该镜像就是您的应用程序的一个快照。最后，您将该镜像作为容器运行。以下是该过程的简要概述：

  1. 创建 Dockerfile：定义基础镜像、应用程序代码、依赖项以及任何需要的配置。

  2. 构建镜像：使用 Docker CLI 从 Dockerfile 构建镜像。

  3. 运行容器：使用 Docker CLI 从镜像启动容器。您的应用程序现在正在隔离环境中运行。

Kubernetes 的关键概念

既然你已经了解了容器，我们来谈谈 Kubernetes。Kubernetes 可以自动部署、扩展和管理容器化应用程序。

  1. 豆荚

    • Kubernetes 中最小的可部署单元。一个 Pod 可以包含一个或多个容器，这些容器共享存储、网络以及运行容器的规范。
    • Pod 是短暂存在的。当它们终止时，Kubernetes 会用新的实例替换它们，从而保持所需的状态。

  2. 节点

    • 构成 Kubernetes 集群的物理机或虚拟机。每个节点运行 Pod，并由 Kubernetes 控制平面进行管理。
    • 节点可以是工作节点（应用程序运行所在的节点）或主节点（管理工作节点的节点）。
    • 每个节点都有一个 kubelet，它是一个与控制平面通信的代理，确保容器按预期运行。

  3. 集群

    • Kubernetes 管理的节点集合。一个集群至少包含一个主节点和多个工作节点。
    • 集群的控制平面管理应用程序的整体健康状况和生命周期，协调节点和 Pod 之间的工作。

  4. 服务

    • Kubernetes 服务是一种抽象的方式，用于暴露运行在多个 Pod 上的应用程序。Kubernetes 服务可以对请求进行负载均衡，从而确保对应用程序的可靠访问。
    • 服务能够实现应用程序不同部分之间的通信，无论是在集群内部还是集群外部。
    • 服务类型有多种，例如 ClusterIP（只能在集群内访问）、NodePort（可通过每个节点上的端口访问）和 LoadBalancer（可通过外部负载均衡器访问）。

  5. 部署

    • 部署机制是一个更高层次的抽象层，用于管理 Pod 的部署和扩展。部署确保应用程序运行的副本数量正确。
    • 它们使得发布更新和在出现问题时回滚更改变得容易。
    • 部署使用副本集来维护所需的 pod 副本数量，并方便滚动更新。

  6. 副本集

    • 副本集组件可确保在任何给定时间运行指定数量的 Pod 副本。部署时使用副本集来维护应用程序的预期状态。
    • 它们会监控 pod 的运行状况，并根据需要创建新的 pod 来替换发生故障的实例。

吊舱：最小的可部署单元

Pod 代表集群中正在运行的进程的单个实例。

Pod 封装了一个或多个容器、存储资源、唯一的网络 IP 地址以及控制容器运行方式的选项。即使您的应用程序包含多个容器，Kubernetes 也能将它们作为一个整体在 Pod 中进行管理。

例如，您可能有一个运行 Web 服务器容器的 Pod 和一个处理日志记录的 Sidecar 容器。这两个容器共享同一个网络命名空间，这意味着它们可以通过 localhost 轻松地相互通信。

节点：Kubernetes 的主力军

节点是 Kubernetes 的核心。每个节点运行容器运行时环境，以及一个名为 kubelet 的代理程序，该程序与控制平面通信，确保容器按预期运行。节点可以是物理机，也可以是虚拟机，具体取决于您的配置。

除了 kubelet 之外，节点还会运行网络代理（kube-proxy），该代理维护网络规则，用于将流量路由和负载均衡到相应的 pod。

集群：概览

Kubernetes 集群是 Kubernetes 运行的整个系统。它包括所有节点、控制平面以及协同工作以管理容器化应用程序的各种组件。

控制平面负责监督集群，管理 pod 的生命周期，扩展应用程序，并确保一切顺利运行。

控制平面包含几个关键组件：

  • API 服务器： Kubernetes 控制平面的前端。它暴露了 Kubernetes API，是管理集群的主要入口点。

  • 调度器：根据资源可用性和其他约束条件，确定哪些节点将运行新创建的 Pod。

  • 控制器管理器：运行用于调节集群状态的控制器，例如节点控制器、复制控制器等。

  • etcd：一个分布式键值存储系统，用于保存集群的状态和配置数据。

服务：您申请的粘合剂

Kubernetes 中的服务为访问一组 Pod 提供了一个稳定的端点。

这种抽象将客户端与各个 pod 实例解耦，允许替换或扩展 pod 而不会影响服务端点。

例如，如果你的 Web 应用程序运行在多个 Pod 中，服务可以对这些 Pod 之间的传入流量进行负载均衡，从而确保高可用性和可靠性。服务还可以简化应用程序不同部分之间的通信管理。

部署和副本集：确保达到预期状态

部署是更高级别的抽象，用于管理应用程序的发布和扩展。它们使用副本集来确保在任何给定时间运行所需数量的 Pod 副本。部署简化了更新和回滚，使您能够以最小的中断来管理应用程序的变更。

部署定义了应用程序的预期状态，例如副本数量、要使用的容器镜像以及任何更新策略。Kubernetes 会持续监控部署并进行调整以匹配预期状态。

把所有东西整合起来

理解这些核心概念将为您的 Kubernetes 之旅奠定基础。Kubernetes 乍看之下可能很复杂，但将其分解成易于管理的部分后，就会变得容易上手。掌握了这些知识，您就可以深入学习 Kubernetes 的实际应用，并充满信心地部署应用程序了。

接下来，请牢记这些概念。它们是其他一切的基础。掌握了这些基础知识，你就可以深入探索 Kubernetes 的世界了。

第二章：搭建环境

现在你已经对 Kubernetes 的基本概念有了扎实的了解，是时候搭建你的环境了。

本章将指导您完成必要的先决条件以及在本地计算机上安装 Kubernetes。

读完本章，您将拥有一个可用的 Kubernetes 设置，可以按照本指南的其余部分进行操作。

先决条件

在开始安装过程之前，您需要确保拥有合适的工具并满足系统要求。

必要的软件和工具

  1. Docker：

    • Docker 对于创建和管理容器至关重要。如果您尚未安装 Docker，可以从Docker 官网下载。
    • Docker Desktop 适用于 Windows 和 macOS，而 Docker Engine 可以安装在 Linux 发行版上。

  2. 迷你库贝：

    • Minikube 是一个用于搭建本地 Kubernetes 集群的工具。它会在本地机器的虚拟机中运行一个单节点 Kubernetes 集群。
    • 您可以从Minikube 发布页面下载 Minikube 。

  3. kubectl：

    • kubectl是用于与 Kubernetes API 服务器交互的命令行工具。它用于在 Kubernetes 上部署和管理应用程序。
    • kubectl 可以使用各种包管理器进行安装，也可以直接从Kubernetes 发布页面进行安装。

  4. 虚拟化软件：

    • Minikube 需要虚拟机管理程序 (hypervisor) 来创建虚拟机。在 Windows 系统上，可以使用 Hyper-V 或 VirtualBox。在 macOS 系统上，可以使用 HyperKit、VirtualBox 或 VMware Fusion。在 Linux 系统上，KVM 是一个常见的选择。
    • 请确保您的计算机 BIOS/UEFI 设置中已启用虚拟化支持。

系统要求

  • 操作系统：

    • Minikube 支持 Windows、macOS 和多种 Linux 发行版。请确保您的操作系统已更新至最新版本，以避免兼容性问题。

  • 硬件：

    • CPU：建议使用多核处理器。Minikube 运行虚拟机，这可能会占用大量 CPU 资源。
    • 内存：建议至少配备 8GB 内存。Minikube 和 Docker 会占用大量内存，尤其是在运行多个容器时。
    • 磁盘空间：请确保您有足够的磁盘空间用于 Docker 镜像和 Minikube。建议至少预留 20GB 的可用空间。

在本地安装 Kubernetes

在本地计算机上设置 Kubernetes 的方法有很多种。本指南将重点介绍如何使用 Minikube，但您也可以考虑使用 Kind（Docker 中的 Kubernetes）或 k3s（轻量级 Kubernetes 发行版）等工具。

安装 Minikube

请按照以下步骤在本地计算机上安装 Minikube：

  1. 下载 Minikube：

    • 访问Minikube 发布页面，下载适用于您操作系统的最新版本。
    • 对于 macOS 和 Linux 系统，您可以使用 Homebrew 等软件包管理器或直接下载。对于 Windows 系统，您可以使用 Chocolatey 或下载可执行文件。

  2. 安装 Minikube：

    • 视窗：
     choco install minikube

  • macOS：

    ```sh
brew install minikube
```

  • Linux：

     curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
 chmod +x minikube
 sudo mv minikube /usr/local/bin/

  1. 启动 Minikube：

    • 打开终端或命令提示符，运行以下命令启动 Minikube：
     minikube start
  • Minikube 将下载必要的镜像并启动本地 Kubernetes 集群。此过程可能需要几分钟时间。

  1. 验证 Minikube 安装：

    • 要验证 Minikube 是否正常运行，请使用以下命令：
     minikube status
  • 您应该可以看到 Minikube 组件的状态，表明集群正在运行。

安装 kubectl

kubectl 是用于与 Kubernetes 集群交互的命令行工具。请按照以下步骤安装 kubectl：

  1. 下载 kubectl：

    • 访问Kubernetes 发布页面，下载与您的操作系统匹配的版本。
    • 您可以使用软件包管理器进行安装，也可以直接下载二进制文件。

  2. 安装 kubectl：

    • 视窗：
     choco install kubernetes-cli

  • macOS：

     brew install kubectl

  • Linux：

     curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
 chmod +x kubectl
 sudo mv kubectl /usr/local/bin/

  1. 验证 kubectl 安装：

    • 要验证 kubectl 是否已正确安装，请使用以下命令：
     kubectl version --client
  • 您应该能看到 kubectl 的版本信息，确认它已安装并正在运行。

验证安装

Minikube 和 kubectl 安装完毕后，是时候验证您的 Kubernetes 设置了。

  1. 检查 Minikube 集群：

    • 运行以下命令以获取 Kubernetes 节点的状态：
     kubectl get nodes
  • 您应该会看到一个节点列表，其中包括 Minikube 节点，其状态为“就绪”。

  1. 部署测试应用程序：

    • 让我们部署一个简单的应用程序，以确保一切运行正常。使用以下命令创建部署：
     kubectl create deployment hello-minikube --image=k8s.gcr.io/echoserver:1.10

  • 公开部署以创建服务：

     kubectl expose deployment hello-minikube --type=NodePort --port=8080

  1. 访问测试应用程序：

    • 要访问该应用程序，您需要 Minikube 服务的 URL。运行以下命令：
     minikube service hello-minikube --url
  • 在浏览器中打开显示的 URL。您应该会看到来自 echoserver 应用程序的简单响应，确认您的 Kubernetes 配置正常运行。

现在，您的本地计算机上已经搭建好了一个可用的 Kubernetes 环境。有了这个环境，您就可以继续学习本指南的其余部分，并获得 Kubernetes 的实际操作经验。

随着学习的进行，您将使用此本地集群来部署和管理应用程序，探索 Kubernetes 的功能，并了解 Kubernetes 如何自动管理容器化应用程序。

第三章：你的第一个 Kubernetes 部署

Kubernetes 环境搭建完毕，现在可以部署你的第一个应用程序了。

本章将指导您创建一个简单的应用程序，使用 Docker 将其容器化，并将其部署到 Kubernetes 上。

最终，您将拥有一个由 Kubernetes 管理的运行应用程序。

创建一个简单的应用程序

我们将从创建一个简单的Node.js应用程序开始。这需要编写一个Dockerfile来容器化该应用程序，并将Docker镜像推送到容器镜像仓库。

编写一个简单的 Dockerfile

  1. 创建应用程序：

    • 为你的项目创建一个新目录，并进入该目录：
     mkdir my-k8s-app
 cd my-k8s-app

    这将创建一个名为 `<directory_name>` 的新目录my-k8s-app并进入该目录。

  • 初始化一个新的Node.js项目并安装Express.js：

     npm init -y
 npm install express

    npm init -y使用默认设置初始化一个新的 Node.js 项目，并创建一个package.json文件。npm install express安装 Express.js 库，这是一个用于 Node.js 的 Web 框架。

  • 创建一个名为 `<filename>` 的文件app.js，并在其中添加以下代码：

     const express = require('express');
 const app = express();
 const port = 3000;

 app.get('/', (req, res) => {
   res.send('Hello, Kubernetes!');
 });

 app.listen(port, () => {
   console.log(`App listening at http://localhost:${port}`);
 });

    这是一个简单的 Express.js 应用程序，它监听 3000 端口，当通过根 URL 访问时，它会响应“Hello, Kubernetes!”。

  1. 创建 Dockerfile：

    • 在同一目录下，创建一个名为 `.htm` 的文件Dockerfile，并添加以下内容：
     # Use the official Node.js image as the base image
 FROM node:18-alpine

 # Set the working directory inside the container
 WORKDIR /usr/src/app

 # Copy package.json and package-lock.json
 COPY package*.json ./

 # Install the dependencies
 RUN npm install

 # Copy the application code
 COPY . .

 # Expose the port the app runs on
 EXPOSE 3000

 # Command to run the application
 CMD ["node", "app.js"]
  • FROM node:18-alpine指定要使用的基础镜像，即官方的 Node.js 镜像。
  • WORKDIR /usr/src/app设置容器内的工作目录。
  • COPY package*.json ./package.json将文件复制package-lock.json到工作目录中。
  • RUN npm install安装以下列出的依赖项package.json。
  • COPY . .将整个项目目录复制到工作目录中。
  • EXPOSE 3000指定容器监听端口 3000。
  • CMD ["node", "app.js"]指定容器启动时要运行的命令，即app.js使用 Node.js 运行该文件。

构建并推送 Docker 镜像

  1. 构建 Docker 镜像：

    • 运行以下命令构建 Docker 镜像：
     docker build -t my-k8s-app .

    这条命令告诉 Docker 从当前目录中的 Dockerfile 构建一个镜像，并将其标记为my-k8s-app。

  2. 将 Docker 镜像推送到容器镜像仓库：

    • 首先，登录您的 Docker Hub 帐户（或其他容器注册表，例如 GitHub Container Registry）：
     docker login

    此命令会提示您输入 Docker Hub 凭据以登录。

  • 使用您的 Docker Hub 用户名为镜像添加标签：

     docker tag my-k8s-app <your-docker-hub-username>/my-k8s-app

    此命令会为镜像添加一个包含您的 Docker Hub 用户名的新名称，使其在注册表中唯一。

  • 将镜像推送到 Docker Hub：

     docker push <your-docker-hub-username>/my-k8s-app

    此命令会将镜像上传到您的 Docker Hub 仓库，使其可供 Kubernetes 集群访问。请将 `<your-docker-hub-username>` 替换<your-docker-hub-username>为您实际的 Docker Hub 用户名。

在 Kubernetes 上部署您的应用程序

现在你已经有了 Docker 镜像，是时候将其部署到 Kubernetes 上了。这需要为部署和服务创建 YAML 配置文件，并使用以下命令应用这些配置kubectl。

创建部署和服务 YAML 文件

  1. 创建部署配置：

    • 创建一个名为 `<filename>` 的文件deployment.yaml，并添加以下内容：
     apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: my-k8s-app-deployment
 spec:
   replicas: 2
   selector:
     matchLabels:
       app: my-k8s-app
   template:
     metadata:
       labels:
         app: my-k8s-app
     spec:
       containers:
       - name: my-k8s-app
         image: <your-docker-hub-username>/my-k8s-app
         ports:
         - containerPort: 3000
  • apiVersion: apps/v1指定要使用的 API 版本。
  • kind: Deployment表示此配置适用于部署资源。
  • metadata包括部署名称。
  • spec指定部署的期望状态，包括副本数、用于标识 pod 的选择器和 pod 模板。
  • template定义要创建的 pod，包括标签、容器规范和要使用的容器镜像。
  • ports指定要暴露的容器端口。

  1. 创建服务配置：

    • 创建一个名为 `<filename>` 的文件service.yaml，并添加以下内容：
     apiVersion: v1
 kind: Service
 metadata:
   name: my-k8s-app-service
 spec:
   type: NodePort
   selector:
     app: my-k8s-app
   ports:
     - protocol: TCP
       port: 80
       targetPort: 3000
       nodePort: 30036
  • apiVersion: v1指定要使用的 API 版本。
  • kind: Service表示此配置是针对服务资源的。
  • metadata包括服务名称。
  • spec指定服务的期望状态，包括类型、用于标识 pod 的选择器以及要公开的端口。
  • type: NodePort在每个节点的 IP 地址上，通过静态端口暴露该服务。
  • ports定义端口映射：port是服务上的端口，targetPort是容器上的端口，nodePort是节点上的端口。

使用以下方式应用配置kubectl

  1. 应用部署配置：

    • 运行以下命令以应用部署配置：
     kubectl apply -f deployment.yaml

    此命令创建在 中定义的部署deployment.yaml，部署指定数量的 pod 副本以及定义的配置。

  2. 应用服务配置：

    • 运行以下命令以应用服务配置：
     kubectl apply -f service.yaml

    此命令创建在 中定义的服务service.yaml，并通过指定的服务配置公开已部署的应用程序。

验证部署

  1. 检查部署状态：

    • 使用以下命令检查部署状态：
     kubectl get deployments

    此命令列出当前命名空间中的所有部署，显示所需的副本数和当前副本数，以及它们的可用性状态。

  2. 检查 Pod 的状态：

    • 使用以下命令检查 Pod 的状态：
     kubectl get pods

    此命令列出当前命名空间中的所有 pod，显示其状态、就绪状态和使用年限。

  3. 访问应用程序：

    • 要访问您的应用程序，请运行以下命令以获取 Minikube 服务 URL：
     minikube service my-k8s-app-service --url

    此命令会返回用于访问服务的 URL。请在 Web 浏览器中打开显示的 URL。您应该会看到“Hello, Kubernetes!”消息，这表明您的应用程序已成功部署并在 Kubernetes 上运行。

在本章中，您已经创建、容器化并部署了您的第一个 Kubernetes 应用程序。这一基础性经验将帮助您了解 Kubernetes 如何管理容器化应用程序，并为在后续章节中探索更高级的功能奠定基础。

第四章：探索 Kubernetes 特性

在前几章中，我们搭建了 Kubernetes 环境并部署了第一个应用程序。现在，让我们来探索 Kubernetes 的一些强大功能。

这些功能使您能够更有效地管理应用程序，确保它们可以扩展、无缝更新和可靠地交互。

我们将介绍应用程序的扩展、更新、Kubernetes 中的网络以及服务网格简介。

扩展应用程序

Kubernetes 的优势之一是能够动态扩展应用程序以满足不同的负载需求。

利用副本进行水平扩展

水平扩展允许您动态地添加或删除应用程序的实例（pod）。

这样有助于通过将传入流量分配到多个 pod 来管理负载，防止任何单个实例过载。

它还通过维护应用程序的多个副本来确保高可用性；如果一个 pod 发生故障，其他 pod 将继续处理请求，从而最大限度地减少停机时间并提高弹性。

  1. 扩大规模：

    • 编辑部署以增加副本数：
     kubectl scale deployment my-k8s-app-deployment --replicas=4

    此命令将部署扩展到 4 个副本。Kubernetes 将创建额外的 Pod 以满足此需求，并将它们分布在可用的节点上。

  2. 缩小规模：

    • 修改部署配置以减少副本数量：
     kubectl scale deployment my-k8s-app-deployment --replicas=2

    此命令会将部署规模缩减至 2 个副本。Kubernetes 将终止多余的 Pod，从而在确保应用程序稳定性的同时，维持所需的部署状态。

  3. 检查部署状态：

    • 查看当前部署状态：
     kubectl get deployments

    此命令显示所需的副本数和当前的副本数，使您可以在扩展或缩减时监控变化。

  4. 监控舱：

    • 列出所有豆荚：
     kubectl get pods

    此命令列出集群中的所有 Pod。您将看到 Pod 的数量根据您的扩​​缩容命令而增加或减少。

更新应用程序

Kubernetes 通过滚动更新实现应用程序的无缝更新，确保更新期间零停机时间。

滚动更新和回滚

  1. 更新部署：

    • 设置新的图像版本：
     kubectl set image deployment/my-k8s-app-deployment my-k8s-app=<your-docker-hub-username>/my-k8s-app:v2

    此命令会将部署更新为使用新版本的镜像（v2）。Kubernetes 会逐步用新 Pod 替换旧 Pod，从而保持服务的可用性。

  2. 关注更新：

    • 查看部署状态：
     kubectl rollout status deployment/my-k8s-app-deployment

    该命令显示滚动更新的进度，指示更新何时完成并突出显示任何问题。

  3. 必要时回滚：

    • 撤销部署更新：
     kubectl rollout undo deployment/my-k8s-app-deployment

    如果在更新过程中出现问题，此命令会将部署还原到以前的版本，从而确保应用程序的稳定性。

  4. 请验证新版本：

    • 访问应用程序：在 Web 浏览器中打开服务 URL 以验证更改。您应该会看到新版本正在运行，这确认更新已成功。

Kubernetes 中的网络

网络是 Kubernetes 的核心方面，它确保 Pod 之间以及 Pod 与外部客户端之间能够有效地通信。

了解服务、入口控制器和网络

  1. 服务：

    • 集群IP：
      • 提供集群内部访问，是内部通信的默认类型。
    • 节点端口：
      • 在每个节点的 IP 地址上通过静态端口公开服务，这对于开发和测试非常有用。
    • 负载均衡器：
      • 使用云提供商的负载均衡器来暴露服务，非常适合具有稳定外部 IP 的生产环境。

  2. 入口控制器：

    • 管理对服务的外部访问，通常为 HTTP 和 HTTPS。
    • 允许基于主机名或路径进行流量路由，提供 SSL 终止和负载均衡。
    • 常用的控制器包括 NGINX Ingress Controller 和 Traefik。

使用 LoadBalancer 和 Ingress 设置外部访问

  1. 创建 Ingress 资源：

    • 创造ingress.yaml：
     apiVersion: networking.k8s.io/v1
 kind: Ingress
 metadata:
   name: my-k8s-app-ingress
 spec:
   rules:
   - host: myapp.example.com
     http:
       paths:
       - path: /
         pathType: Prefix
         backend:
           service:
             name: my-k8s-app-service
             port:
               number: 80

    此配置将流量从myapp.example.com路由到my-k8s-app-service。

  2. 应用 Ingress 配置：

    • 运行命令：
     kubectl apply -f ingress.yaml

    这将创建 Ingress 资源，从而允许通过指定的域名进行外部访问。

  3. 配置 DNS：

    • 请确保您的 DNS 指向 Ingress 控制器的 IP 地址。
    • 通过域名访问您的应用程序（例如，myapp.example.com）。

服务网格

服务网格提供高级网络功能，改善 Kubernetes 集群内微服务之间的通信。

服务网格简介（例如，Istio、Linkerd）

  1. 伊斯蒂奥：

    • 增强交通管理、政策执行和遥测数据收集。
    • 支持高级路由、故障注入和重试。
    • 收集指标、日志和跟踪信息，用于监控微服务。

  2. 链接：

    • 强调简洁性和性能。
    • 提供可观测性、可靠性和安全性功能。
    • 轻量级，适合规模较小的集群或需要简单操作的环境。

基本概念和用例

  1. 交通管理：

    • 控制服务之间的流量。
    • 实现路由、负载均衡和容错功能。
    • 适用于金丝雀发布、A/B 测试和流量拆分。

  2. 安全：

    • 执行服务通信策略。
    • 启用双向 TLS，实现安全的服务间通信。
    • 确保流量加密和访问控制。

  3. 可观测性：

    • 收集指标、日志和跟踪信息以进行监控。
    • 提供对应用程序性能和行为的深入分析。
    • 可用于排查问题、识别性能瓶颈和监控服务运行状况。

通过了解这些 Kubernetes 特性，您可以构建强大、可扩展且安全的应用程序。

这些功能不仅可以增强应用程序的功能，还可以简化管理并提高可靠性。

随着课程的进行，您将获得这些功能的实际操作经验，从而巩固您的理解，并为学习更高级的主题做好准备。

第五章：管理 Kubernetes

在前几章中，我们探讨了如何在 Kubernetes 中部署应用程序、扩展、更新和联网。现在，让我们重点关注 Kubernetes 的管理。这包括监控和日志记录、处理持久存储以及有效地管理配置。

监控和日志记录

监控和日志记录对于维护应用程序的健康和性能至关重要。它们可以帮助您了解应用程序的运行状况，并在出现问题时提供深入的分析。

让我们试着理解为什么监控和日志记录如此重要，以及如何实际应用它们。

为什么监控和记录至关重要

监控和日志记录就像应用程序基础设施的耳目，能够让您了解应用程序及其底层系统的内部运行情况。以下是它们不可或缺的原因：

  1. 主动问题检测：

    • 通过持续监控 CPU 使用率、内存使用率和请求延迟等指标，您可以及时发现异常情况，避免其演变成重大问题。例如，如果您发现内存使用率持续上升，则可能有助于您在内存泄漏导致应用程序崩溃之前将其解决。

  2. 性能优化：

    • 监控有助于识别性能瓶颈。例如，如果某个微服务延迟过高，您可以调查并优化代码，或者分配更多资源来提升其性能。

  3. 产能规划：

    • 通过分析历史数据，您可以预测未来的资源需求并进行相应的规划。这可以确保您的基础架构能够随着应用程序的增长高效扩展，避免资源不足和资源过度配置的情况。

  4. 根本原因分析：

    • 当出现问题时，日志可以提供详细的故障信息。例如，如果部署失败，日志可以显示错误消息和堆栈跟踪，帮助精确定位故障原因，从而加快问题解决速度。

  5. 合规与审计：

    • 为了遵守行业法规，日志记录通常是必需的。它有助于维护活动审计跟踪，例如访问日志、配置更改和数据修改。

真实案例

假设有一个运行在 Kubernetes 上的电商应用。在购物旺季，该应用会经历流量激增。如果没有适当的监控和日志记录，您可能直到应用运行缓慢或崩溃才会注意到负载增加，从而导致销售损失和糟糕的用户体验。

通过有效的监控和记录：

  1. 主动警报：

    • 当 CPU 使用率超过 80% 并持续 5 分钟以上时，您的监控系统会发出警报。届时，您可以决定是否增加资源以应对增加的负载。

  2. 性能仪表盘：

    • Grafana 控制面板显示实时指标，例如请求速率、响应时间和错误率。您注意到支付服务比平时慢，于是进一步调查。

  3. 详细日志：

    • 日志显示，支付服务在调用外部 API 时超时。通过检查日志，您发现外部 API 负载过重，并调整了应用程序以更优雅地处理此类情况。

  4. 历史分析：

    • 旺季过后，您需要分析收集到的数据，以了解流量模式并规划未来的可扩展性改进。

通过建立强大的监控和日志记录机制，您可以确保应用程序即使在意外情况下也能保持高性能和可靠性。

用于监控的工具

  1. 普罗米修斯：

    • 概述：
      • Prometheus 是一个开源的监控和告警工具包。它按给定的时间间隔从配置的目标收集指标，评估规则表达式，显示结果，并在满足条件时触发警报。
    • 设置 Prometheus：
      • 创建一个配置文件（prometheus.yml）来定义抓取目标。
       global:
     scrape_interval: 15s

   scrape_configs:
     - job_name: 'kubernetes-apiservers'
       kubernetes_sd_configs:
         - role: endpoints
       relabel_configs:
         - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
           action: keep
           regex: default;kubernetes;https

  • 使用 Kubernetes 清单部署 Prometheus：

       apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: prometheus-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: prometheus
     template:
       metadata:
         labels:
           app: prometheus
       spec:
         containers:
         - name: prometheus
           image: prom/prometheus
           args:
           - "--config.file=/etc/prometheus/prometheus.yml"
           - "--storage.tsdb.path=/prometheus/"
           volumeMounts:
           - name: config-volume
             mountPath: /etc/prometheus
           volumes:
           - name: config-volume
             configMap:
               name: prometheus-config

  1. 格拉法纳：

    • 概述：
      • Grafana是一个用于监控和可观测性的开源平台。当连接到受支持的数据源时，它能为Web提供图表、图形和警报。
    • 设置 Grafana：
      • 使用 Kubernetes 清单部署 Grafana：
       apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: grafana-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: grafana
     template:
       metadata:
         labels:
           app: grafana
       spec:
         containers:
         - name: grafana
           image: grafana/grafana
           ports:
           - containerPort: 3000
  • 在 Grafana 中将 Prometheus 配置为数据源，以可视化指标。

  1. OpenTelemetry：

    • 概述：
      • OpenTelemetry 是一套工具、API 和 SDK 的集合，用于检测、生成、收集和导出遥测数据（指标、日志和跟踪）以进行分析。
    • 设置 OpenTelemetry：
      • 使用 Kubernetes 清单部署 OpenTelemetry Collector：
       apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: otel-collector
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: otel-collector
     template:
       metadata:
         labels:
           app: otel-collector
       spec:
         containers:
         - name: otel-collector
           image: otel/opentelemetry-collector
           ports:
           - containerPort: 55680
           volumeMounts:
           - name: config-volume
             mountPath: /etc/otel-collector-config
           volumes:
           - name: config-volume
             configMap:
               name: otel-collector-config

访问日志和故障排除

  1. 使用 kubectl 日志：

    • 特定 Pod 的访问日志：
     kubectl logs <pod-name>

    此命令从特定 pod 获取日志，帮助您排查应用程序问题。

  2. 使用日志堆栈：

    • 使用 Fluentd、Elasticsearch 和 Kibana (EFK) 搭建日志记录堆栈：
      • Fluentd：从各种来源收集日志。
      • Elasticsearch：存储和索引日志。
      • Kibana：日志可视化。
      • 使用 Kubernetes 清单部署 Fluentd：
       apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: fluentd
   spec:
     selector:
       matchLabels:
         app: fluentd
     template:
       metadata:
         labels:
           app: fluentd
       spec:
         containers:
         - name: fluentd
           image: fluent/fluentd
           volumeMounts:
           - name: varlog
             mountPath: /var/log
           volumes:
           - name: varlog
             hostPath:
               path: /var/log
  • 配置 Fluentd 将日志发送到 Elasticsearch 并在 Kibana 中可视化。

持久存储

Kubernetes 提供了管理有状态应用程序持久存储的机制。这对于需要在重启和升级后保持状态的应用程序至关重要。持久存储确保容器终止或重新调度时数据不会丢失。

为什么持久存储至关重要

  1. 有状态应用程序：

    • 数据库（例如 MySQL、PostgreSQL）和文件存储服务（例如 NFS、Ceph）等应用程序需要在 Pod 重启后保留数据。持久化存储可确保即使运行应用程序的 Pod 被重新创建，数据仍然可用。

  2. 数据持久性：

    • 持久存储通过将数据存储在可靠的存储后端（例如云存储服务、网络文件系统或本地磁盘）上，从而提供数据持久性。这确保数据不会因瞬时故障或 Pod 重新调度而丢失。

  3. 备份和恢复：

    • 借助持久存储，您可以实施备份和恢复策略来保护数据。这对于需要将数据恢复到先前状态的灾难恢复场景至关重要。

  4. 一致的数据访问：

    • 持久存储允许多个 Pod 以一致的方式访问相同的数据。这对于需要共享存储的应用程序非常有用，例如内容管理系统或协作工具。

  5. 可扩展性：

    • Kubernetes 允许您独立于计算资源扩展存储资源。这意味着您可以随着数据量的增长增加存储容量，而不会影响应用程序的性能。

真实案例

假设有一个运行在 Kubernetes 上的内容管理系统 (CMS)。该 CMS 需要存储用户上传的文件，例如图片和文档。

如果没有持久存储，当存储这些文件的 pod 终止或重新调度时，这些文件将会丢失，从而导致数据丢失和糟糕的用户体验。

使用 Kubernetes 持久存储：

  1. 持续性体积（PV）：

    • 您创建了一个由云存储服务支持的 PV，以确保存储的可靠性和持久性。

  2. 持续销量声明（PVC）：

    • CMS应用程序通过创建PVC来请求存储空间。Kubernetes会自动将PVC绑定到相应的PV，从而为应用程序提供必要的存储空间。

  3. 数据持久性：

    • 用户上传的文件存储在 PV 中，确保在 pod 重启和重新调度事件后文件仍能保留。

  4. 持续访问：

    • CMS应用程序的多个实例可以访问同一存储，从而实现负载均衡和高可用性。

  5. 备份和恢复：

    • PV数据会定期备份并存储在安全位置。一旦发生故障，数据可以快速恢复，最大限度地减少停机时间和数据丢失。

理解这些概念，可以确保您的有状态应用程序具有满足用户期望所需的可靠性、持久性和可扩展性。

持续销量 (PV) 和持续销量声明 (PVC) 简介

  1. 持续性体积（PV）：

    • 概述：
      • PV是集群中的存储资源。它们可以由不同的存储系统提供支持，例如NFS、iSCSI或云存储。
    • 创建PV：
     apiVersion: v1
 kind: PersistentVolume
 metadata:
   name: my-pv
 spec:
   capacity:
     storage: 1Gi
   accessModes:
     - ReadWriteOnce
   persistentVolumeReclaimPolicy: Retain
   hostPath:
     path: "/mnt/data"

  2. 持续销量声明（PVC）：

    • 概述：
      • PVC（用户请求存储请求）是用户提出的储能请求，它们会消耗光伏资源。
    • 制作PVC：
     apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   accessModes:
     - ReadWriteOnce
   resources:
     requests:
       storage: 1Gi

  3. PV和PVC的结合：

    • 装订过程：
      • 创建 PVC 时，Kubernetes 会根据请求的存储大小和访问模式查找匹配的 PV。找到匹配项后，PVC 会绑定到该 PV，从而使 Pod 可以使用该存储。

在您的应用中使用光伏电池和聚氯乙烯

  1. 使用 PVC 的部署示例：

    • 创建部署（app-deployment.yaml）：
     apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: my-app
 spec:
   replicas: 1
   selector:
     matchLabels:
       app: my-app
   template:
     metadata:
       labels:
         app: my-app
     spec:
       containers:
       - name: my-app
         image: my-app-image
         volumeMounts:
         - mountPath: "/data"
           name: my-storage
       volumes:
       - name: my-storage
         persistentVolumeClaim:
           claimName: my-pvc

  2. 应用部署：

    • 运行命令：
     kubectl apply -f app-deployment.yaml

    此命令使用 PVC 部署应用程序，确保应用程序可以访问持久存储。

配置管理

安全高效地管理配置和密钥对于应用程序部署至关重要。

使用 ConfigMap 和 Secrets

  1. 配置映射：

    • 概述：
      • ConfigMap 用于以键值对的形式存储非机密数据。它们可用于将特定于环境的配置与容器镜像解耦。
    • 创建 ConfigMap：
     apiVersion: v1
 kind: ConfigMap
 metadata:
   name: my-config
 data:
   APP_ENV: "production"
   APP_DEBUG: "false"

  2. 秘密：

    • 概述：
      • 密钥用于存储敏感数据，例如密码、OAuth令牌和SSH密钥。它们采用base64编码以确保安全性。
    • 创造秘密：
     apiVersion: v1
 kind: Secret
 metadata:
   name: my-secret
 type: Opaque
 data:
   username: YWRtaW4=
   password: MWYyZDFlMmU2N2Rm

应用程序配置管理最佳实践

  1. 将配置与代码解耦：

    • 将配置信息存储在 ConfigMap 和 Secret 中，使其与容器镜像分离。这样，您就可以独立于应用程序代码来管理配置。

  2. 使用环境变量：

    • 将配置值作为环境变量注入到容器中。这种方法灵活便捷，无需修改应用程序代码即可轻松更新配置。

  3. 保守秘密：

    • 使用 Kubernetes Secrets 存储敏感数据，并确保实施访问控制策略。定期轮换 Secrets 并审核其使用情况，以维护安全性。

  4. 版本控制配置：

    • 将 ConfigMap 和 Secret 存储在版本控制系统中。这样可以跟踪更改、回滚到以前的配置，并保持部署之间的一致性。

遵循这些管理技巧，您将确保您的 Kubernetes 应用程序得到良好的监控、安全的存储和高效的配置。

这些技能对于维持稳健可靠的生产环境至关重要。

随着学习的深入，您将把这些实践应用到实际场景中，从而增强您对 Kubernetes 集群管理的理解和能力。

第六章：最佳实践和技巧

在前几章中，我们介绍了如何在 Kubernetes 中部署和管理应用程序。现在，让我们重点关注最佳实践和技巧，以确保您的 Kubernetes 集群安全、高效且易于维护。请记住，虽然最佳实践通常是最佳方法，但有时可能需要一些“个性化调整”来满足您的特定需求。

安全最佳实践

安全在任何系统中都至关重要，Kubernetes 也不例外。保护 Kubernetes 集群涉及多个层面，从访问控制到数据安全。

保护您的 Kubernetes 集群

  1. 网络策略：

    • 使用网络策略来控制 Pod 之间的流量。这可以限制通信路径并减少攻击面。
    • 例子：
     apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
 metadata:
   name: deny-all
   namespace: default
 spec:
   podSelector: {}
   policyTypes:
   - Ingress
   - Egress
   ingress: []
   egress: []

    该策略拒绝默认命名空间中的所有入站和出站流量。

  2. Pod 安全策略：

    • 为您的 Pod 强制执行安全上下文，以确保它们以所需的最低权限运行。
    • 例子：
     apiVersion: policy/v1beta1
 kind: PodSecurityPolicy
 metadata:
   name: restricted
 spec:
   privileged: false
   runAsUser:
     rule: MustRunAsNonRoot
   seLinux:
     rule: RunAsAny
   supplementalGroups:
     rule: MustRunAs
     ranges:
     - min: 1
       max: 65535
   fsGroup:
     rule: MustRunAs
     ranges:
     - min: 1
       max: 65535

    该策略强制规定 pod 必须以非 root 用户身份运行，且不具有特权。

管理密钥和配置

  1. Kubernetes Secrets：

    • 将密码和 API 密钥等敏感信息存储在 Kubernetes Secrets 中，而不是以明文形式存储在配置文件中。
    • 例子：
     apiVersion: v1
 kind: Secret
 metadata:
   name: my-secret
 type: Opaque
 data:
   username: YWRtaW4=
   password: MWYyZDFlMmU2N2Rm

    此密钥存储 base64 编码的凭据。

  2. 配置映射：

    • 使用 ConfigMap 存储非敏感的配置数据。这有助于将配置与代码解耦。
    • 例子：
     apiVersion: v1
 kind: ConfigMap
 metadata:
   name: my-config
 data:
   APP_ENV: "production"
   APP_DEBUG: "false"

  3. 大公司的例子：

    • Google 和其他科技巨头经常使用与 Kubernetes 集成的密钥管理工具（例如 HashiCorp Vault）来安全地管理密钥。

实施基于角色的访问控制（RBAC）

  1. RBAC概述：

    • RBAC 允许您定义角色并将其分配给用户或组，从而根据角色控制对 Kubernetes 资源的访问。
     apiVersion: rbac.authorization.k8s.io/v1
 kind: Role
 metadata:
   namespace: default
   name: pod-reader
 rules:
 - apiGroups: [""]
   resources: ["pods"]
   verbs: ["get", "watch", "list"]

    此角色授予对默认命名空间中 Pod 的读取权限。

  2. 角色绑定：

    • 将角色绑定到用户或用户组。
     apiVersion: rbac.authorization.k8s.io/v1
 kind: RoleBinding
 metadata:
   name: read-pods
   namespace: default
 subjects:
 - kind: User
   name: jane
   apiGroup: rbac.authorization.k8s.io
 roleRef:
   kind: Role
   name: pod-reader
   apiGroup: rbac.authorization.k8s.io

    此绑定授予pod-reader用户该角色jane。

  3. 大公司的例子：

    • 像微软这样的企业广泛使用基于角色的访问控制 (RBAC) 来在其 Kubernetes 环境中实施细粒度的访问控制。

优化资源利用

资源优化是确保 Kubernetes 应用高效运行、降低成本并提升性能的关键。有效的资源优化包括管理 CPU、内存和存储资源，以确保应用拥有良好运行所需的资源，同时避免过度配置，从而防止不必要的成本。

详细概述

  1. 了解资源请求和限制：

    • 资源请求：
      • 资源请求指定容器所需的最小 CPU 和内存量。Kubernetes 使用这些值将 Pod 调度到具有足够资源的节点上。
       resources:
     requests:
       memory: "64Mi"
       cpu: "250m"

  • 此配置要求容器拥有 64Mi 内存和 250m CPU。

    • 资源限制：
      • 资源限制规定了容器可以使用的最大 CPU 和内存量。这有助于防止单个容器垄断节点上的资源。
       resources:
     limits:
       memory: "128Mi"
       cpu: "500m"

  • 此配置将容器的内存限制为 128Mi，CPU 限制为 500m。

  1. 自动扩缩容：

    • 水平舱自动扩缩器 (HPA)：
      • HPA 会根据观察到的 CPU 利用率或其他指标自动调整 Pod 副本数量。这确保您的应用程序能够横向扩展以应对负载增加，并在负载降低时缩减副本数量。
       apiVersion: autoscaling/v1
   kind: HorizontalPodAutoscaler
   metadata:
     name: my-app-hpa
   spec:
     scaleTargetRef:
       apiVersion: apps/v1
       kind: Deployment
       name: my-app
     minReplicas: 1
     maxReplicas: 10
     targetCPUUtilizationPercentage: 50

  • 此 HPA 配置可确保部署规模在 1 到 10 个副本之间扩展，目标是将 CPU 利用率保持在 50%。

    • 垂直舱自动扩缩器（VPA）：
      • VPA 会根据观察到的使用情况自动调整 pod 的资源请求和限制，确保每个 pod 都拥有最佳的资源量。
       apiVersion: autoscaling.k8s.io/v1
   kind: VerticalPodAutoscaler
   metadata:
     name: my-app-vpa
   spec:
     targetRef:
       apiVersion: "apps/v1"
       kind:       Deployment
       name:       my-app
     updatePolicy:
       updateMode: "Auto"

  • 此 VPA 配置会自动调整部署中 pod 的资源请求和限制。

  1. 资源配额和限制：

    • 资源配额：
      • 资源配额限制了命名空间内的总资源消耗量。这有助于防止单个命名空间消耗集群中的所有资源。
       apiVersion: v1
   kind: ResourceQuota
   metadata:
     name: compute-resources
   spec:
     hard:
       requests.cpu: "1"
       requests.memory: "1Gi"
       limits.cpu: "2"
       limits.memory: "2Gi"
  • 此资源配额确保 CPU 请求总数不超过 1 个核心，内存请求不超过 1Gi，CPU 限制不超过 2 个核心，内存限制不超过 2Gi。

实用性和益处

  • 高效利用：
    • 优化资源使用可确保每个应用程序都能获得正常运行所需的资源，而不会过度配置，从而节省成本。
  • 性能提升：
    • 通过微调资源请求和限制，您可以防止资源争用，从而确保应用程序运行流畅且性能可预测。
  • 可扩展性：
    • 自动伸缩机制（HPA 和 VPA）使您的应用程序能够动态地处理不同的负载，从而确保高可用性和响应能力。
  • 成本管理：
    • 资源优化直接影响成本管理，尤其是在云环境中，资源按使用量计费。高效的资源利用能够显著节省成本。

现实生活中的例子：Netflix

Netflix是一家知名公司，其基础设施广泛使用Kubernetes。以下是Netflix如何优化资源利用：

  1. 动态缩放：

    • Netflix 同时使用水平 Pod 自动扩缩容 (HPA) 和定制的自动扩缩容解决方案，根据需求动态扩展其服务。这确保了他们能够在高峰时段应对流量高峰，并在非高峰时段缩减服务规模以节省成本。

  2. 资源请求和限制：

    • 他们会精心设置容器的资源请求和限制，以确保高效利用。通过分析历史使用数据，他们会根据应用程序的实际需求微调这些值，避免过度配置。

  3. 监测与分析：

    • Netflix 采用先进的监控和分析工具，持续监控资源使用情况和应用程序性能。这使他们能够做出数据驱动的决策，从而优化资源分配并提升性能。

  4. 自定义自动缩放：

    • Netflix 开发了自定义自动扩缩容算法，除了 CPU 和内存之外，还会考虑请求速率和响应时间等各种指标，从而做出更明智的扩缩容决策。

  5. 成本管理：

    • 通过优化资源利用，Netflix显著降低了云基础设施成本。他们采用精细的成本管理措施，确保每一分钱的投入都能带来最大价值。

GitOps

GitOps 是一种现代化的持续交付和 Kubernetes 管理方法，它使用 Git 作为单一数据源。

GitOps 简介（例如 ArgoCD、Flux）

  1. GitOps概述：

    • GitOps uses Git repositories to manage Kubernetes resources, ensuring that the desired state of your cluster is defined in Git.
    • Tools like ArgoCD and Flux automate the synchronization between Git and your Kubernetes cluster.

  2. ArgoCD:

    • Overview:
      • ArgoCD is a declarative GitOps continuous delivery tool for Kubernetes.
    • Setting up ArgoCD:
      • Deploy ArgoCD using a Kubernetes manifest:
       apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: argocd-server
     labels:
       app: argocd
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: argocd
     template:
       metadata:
         labels:
           app: argocd
       spec:
         containers:
         - name: argocd-server
           image: argoproj/argocd
           ports:
           - containerPort: 8080
  • Connect ArgoCD to your Git repository to manage your Kubernetes resources.

  1. Flux:

    • Overview:
      • Flux is a set of continuous and progressive delivery solutions for Kubernetes that are open and extensible.
    • Setting up Flux:
      • Install Flux using the Flux CLI:
       flux install

Implementing continuous delivery with GitOps

  1. Define your desired state in Git:

    • Store Kubernetes manifests in a Git repository, representing the desired state of your cluster.
    • Example repository structure:
     ├── base
 │   ├── deployment.yaml
 │   ├── service.yaml
 └── overlays
     ├── production
     │   └── kustomization.yaml
     └── staging
         └── kustomization.yaml

  2. Automate deployments:

    • Use ArgoCD or Flux to monitor the Git repository and automatically apply changes to your Kubernetes cluster when updates are pushed to the repository.
    • Example:
     apiVersion: argoproj.io/v1alpha1
 kind: Application
 metadata:
   name: my-app
   namespace: argocd
 spec:
   project: default
   source:
     repoURL: 'https://github.com/my-org/my-repo'
     targetRevision: HEAD
     path: overlays/production
   destination:
     server: 'https://kubernetes.default.svc'
     namespace: default
   syncPolicy:
     automated:
       prune: true
       selfHeal: true

  3. Benefits of GitOps:

    • Consistency and reliability: Changes to your cluster are version-controlled and auditable.
    • Automation: Reduces manual intervention, decreasing the likelihood of errors.
    • Collaboration: Teams can collaborate on infrastructure changes using familiar Git workflows.

  4. Example from big companies:

    • Companies like Intuit and Ticketmaster use GitOps to manage their Kubernetes infrastructure, achieving consistent and reliable deployments at scale.

Now, you can ensure your Kubernetes cluster is secure, efficient, and maintainable.

Remember that while these practices provide a solid foundation, there may be instances where you need to adapt them to fit your unique requirements.

Combining best practices with your personal touch will help you create a robust Kubernetes environment tailored to your needs.

Conclusion

As we conclude this guide on Kubernetes, it's essential to reflect on the key points we've covered and consider the next steps for your Kubernetes journey. Remember, while this guide provides a solid foundation, Kubernetes is a vast ecosystem, and continued learning is crucial.

Summary of key points

  1. Understanding Kubernetes Basics:

    • We started by understanding the core concepts of Kubernetes, such as containers, pods, nodes, and clusters. These are the building blocks that make Kubernetes a powerful orchestration platform.

  2. Setting Up Your Environment:

    • You learned how to set up a Kubernetes environment using Minikube, Docker, and kubectl. This setup provides a local playground to experiment with Kubernetes.

  3. Deploying Applications:

    • We walked through deploying a simple Node.js application on Kubernetes, covering how to create Docker images, push them to a container registry, and deploy them using Kubernetes manifests.

  4. Exploring Kubernetes Features:

    • We explored advanced features such as scaling applications, performing rolling updates, and managing networking with services and Ingress controllers. These features ensure your applications are robust and scalable.

  5. Managing Kubernetes:

    • We discussed monitoring and logging to keep your applications healthy, handling persistent storage with PVs and PVCs, and managing configurations with ConfigMaps and Secrets.

  6. Best Practices:

    • We highlighted best practices for securing your Kubernetes cluster, optimizing resource usage, and implementing GitOps for continuous delivery. Following these practices helps in maintaining a secure, efficient, and maintainable Kubernetes environment.

Next steps

As you continue learning on Kubernetes, there are several advanced topics and resources you can explore to deepen your knowledge and skills.

  1. Advanced Topics to Explore:

    • Kubernetes Operators:
      • Operators extend Kubernetes functionality by managing complex applications and automating operational tasks. They enable custom resource management, making it easier to deploy and maintain stateful applications.
    • Helm:
      • Helm is a package manager for Kubernetes that simplifies the deployment and management of applications. It uses charts to define, install, and upgrade complex Kubernetes applications.
    • Advanced Networking:
      • Explore advanced networking concepts like service meshes, network policies, and multi-cluster networking to improve application communication and security.

  2. Recommended Resources and Communities for Further Learning:

    • Kubernetes Documentation:
    • Kubernetes Slack:
      • Join the Kubernetes Slack community to connect with other Kubernetes users and experts.
    • Online Courses:
      • Platforms like Coursera offer courses on Kubernetes, covering beginner to advanced topics.
    • Books:
      • Consider reading books like "Kubernetes Up & Running" by Kelsey Hightower, Brendan Burns, and Joe Beda for in-depth knowledge.
    • Meetups and Conferences:
      • Attend local Kubernetes meetups or conferences to network and learn from the community.

Note: This guide is a starting point for your Kubernetes journey. While it provides essential knowledge and practical steps, Kubernetes is a complex system that requires continuous learning and experimentation. Always refer to the latest official documentation and resources, and tailor your setup to meet your specific needs and use cases.

As you proceed, don't hesitate to explore, experiment, and ask questions. The Kubernetes community is vast and supportive, and there are many resources available to help you along the way. Happy Kubernetes learning!

Appendix

Glossary of Kubernetes terms

  1. Cluster:

    • A set of nodes (machines) that run containerized applications managed by Kubernetes. It includes at least one master node and several worker nodes.

  2. Node:

    • A single machine in a Kubernetes cluster. Nodes can be physical or virtual. Each node runs pods and is managed by the master node.

  3. Pod:

    • The smallest deployable unit in Kubernetes, which can contain one or more containers. Pods share storage, network, and a specification for how to run the containers.

  4. Container:

    • A lightweight, portable, and self-sufficient unit that includes everything needed to run a piece of software, including the code, runtime, system tools, libraries, and settings.

  5. Deployment:

    • A Kubernetes object that manages the deployment and scaling of a set of identical pods. Deployments provide declarative updates to applications.

  6. Service:

    • An abstraction that defines a logical set of pods and a policy to access them. Services enable communication between different parts of an application and external clients.

  7. Ingress:

    • A collection of rules that allow inbound connections to reach the cluster services. Ingress can provide load balancing, SSL termination, and name-based virtual hosting.

  8. ConfigMap:

    • A Kubernetes object used to store non-confidential configuration data in key-value pairs. ConfigMaps are used to decouple configuration from application code.

  9. Secret:

    • A Kubernetes object used to store sensitive information, such as passwords, OAuth tokens, and SSH keys. Secrets are base64-encoded to ensure security.

  10. Persistent Volume (PV):

    • A piece of storage in the cluster that has been provisioned by an administrator or dynamically provisioned using Storage Classes. PVs provide persistent storage for pods.

  11. Persistent Volume Claim (PVC):

    • A request for storage by a user. PVCs consume PV resources and provide a way for pods to use persistent storage.

  12. Horizontal Pod Autoscaler (HPA):

    • A Kubernetes object that automatically adjusts the number of pod replicas based on observed CPU utilization or other metrics.

  13. Vertical Pod Autoscaler (VPA):

    • A Kubernetes object that automatically adjusts the resource requests and limits of pods based on observed usage.

  14. Role-Based Access Control (RBAC):

    • A method of regulating access to Kubernetes resources based on the roles assigned to users and groups.

  15. Namespace:

    • A Kubernetes object that provides a way to divide cluster resources between multiple users. Namespaces are intended for use in environments with many users spread across multiple teams.

Useful commands and shortcuts

  1. Basic Commands:

    • Get cluster information:
     kubectl cluster-info

  • Get nodes:

     kubectl get nodes

  1. Working with Pods:

    • List all pods:
     kubectl get pods

  • Describe a pod:

     kubectl describe pod <pod-name>

  • Delete a pod:

     kubectl delete pod <pod-name>

  1. Deployments:

    • Apply a deployment:
     kubectl apply -f <deployment-file.yaml>

  • Scale a deployment:

     kubectl scale deployment <deployment-name> --replicas=<number>

  • Update a deployment image:

     kubectl set image deployment/<deployment-name> <container-name>=<image-name>:<tag>

  1. Services:

    • List services:
     kubectl get services

  • Describe a service:

     kubectl describe service <service-name>

  1. Logs:

    • View pod logs:
     kubectl logs <pod-name>

  • Stream pod logs:

     kubectl logs -f <pod-name>

  1. ConfigMaps and Secrets:

    • Create a ConfigMap:
     kubectl create configmap <config-name> --from-literal=<key>=<value>

  • Create a Secret:

     kubectl create secret generic <secret-name> --from-literal=<key>=<value>

  1. Namespaces:

    • List namespaces:
     kubectl get namespaces

  • Create a namespace:

     kubectl create namespace <namespace-name>

  1. RBAC:

    • Create a role:
     apiVersion: rbac.authorization.k8s.io/v1
 kind: Role
 metadata:
   namespace: default
   name: pod-reader
 rules:
 - apiGroups: [""]
   resources: ["pods"]
   verbs: ["get", "watch", "list"]

  • Bind a role:

     apiVersion: rbac.authorization.k8s.io/v1
 kind: RoleBinding
 metadata:
   name: read-pods
   namespace: default
 subjects:
 - kind: User
   name: jane
   apiGroup: rbac.authorization.k8s.io
 roleRef:
   kind: Role
   name: pod-reader
   apiGroup: rbac.authorization.k8s.io

This appendix serves as a quick reference to help you understand key Kubernetes terms and efficiently use common commands. Keep this handy as you work with Kubernetes, and refer back to it whenever you need a refresher or quick command lookup.

Stay connected

If you enjoyed this article, feel free to connect with me on various platforms:

Your feedback and questions are always welcome.

If you like, you can support my work here

文章来源：https://dev.to/digitalpollution/kubernetes-for-everyone-a-step-by-step-guide-for-beginners-1p3c
500 followers!😱?...
Neovim 基本命令/速成课程