谷歌-Kubenetes-引擎高级教程-全-

谷歌 Kubenetes 引擎高级教程（全）

原文：Pro Google Kubernetes Engine

协议：CC BY-NC-SA 4.0

一、GKE 简介

本书的第一章将向您介绍容器、微服务应用以及相关的监控和管理工具生态系统。它还着眼于容器及其周围的生态系统是如何组装的。涵盖了以下主题:

• Docker 简介

• Kubernetes 的概论

• 管理库帐户

• 容器生态系统的 GCP 容器解决方案

• 谷歌库比厄引擎

• 容器注册表

• 网络

• 云运行

• 安朵斯

Docker 简介

随着现代应用开发的容器化技术的兴起，Docker 现在被广泛用作容器化框架。容器是一种将应用和依赖项捆绑到它自己的独立包中的方法。应用作为流程成功运行所需的一切现在都在容器中被捕获和执行。这实现了跨环境的标准化和一致性，因为现在容器将总是预加载运行应用服务所需的所有先决条件/依赖项。现在，您可以在个人工作站上开发应用代码，然后安全地将其部署到生产级基础设施上运行。因此，人们在依赖操作系统(OS)或虚拟化软件方面面临的问题不再适用于容器基础设施(图 1-1 )。

图 1-1

Docker 建筑

Docker 消除了开发系统和产品中发布的软件之间的差异。Docker 容器在用于开发软件的相同操作系统配置中工作。

以下是 Docker 生态系统的一些组成部分(图 1-2 ):

图 1-2

Docker 管理界面(CLI 和 API)

• Docker 客户端: Docker 用户可以通过客户端与 Docker 进行交互。

• Docker 主机:Docker 主机提供了运行容器化应用的基础环境。它提供了从 Docker 守护程序、映像、容器和网络到存储的所有必要的基础架构基础组件。

• Docker 映像: Docker 映像相当于操作系统模板或虚拟机映像，主要区别在于它不打包操作系统，而是包含应用二进制文件和运行应用所需的所有依赖项。通过使用这些映像，我们可以实现跨基础设施的应用可移植性，而无需担心所使用的基础设施技术。

• 注册表:注册表用于管理 Docker 映像。注册中心主要有两种类型:公共注册中心和私有注册中心。这是 Docker 映像存储的地方，可以在容器上进行实例化。

• Docker 引擎: Docker 引擎支持开发、打包、部署和运行应用。

• Docker 守护进程: Docker 守护进程是管理 Docker 映像、容器、网络和存储卷的核心进程。

• Docker Engine REST API: 这是容器化应用用来与 Docker 守护进程交互的 API。

• Docker CLI: Docker CLI 提供了一个命令行界面，用于与 Docker 守护程序进行交互。

Kubernetes 的概论

Kubernetes 是一个开源的容器管理(编排)工具，它在容器上提供了一个抽象层，利用 REST APIs 来管理容器群。Kubernetes 本质上是可移植的，并支持在各种公共和私有云平台上运行，如物理服务器、GCP、AWS、Azure、OpenStack 或 Apache Mesos。

与 Docker 类似，Kubernetes 也遵循客户端-服务器架构。它有一个主服务器，用于管理部署了容器化应用的目标节点。它还有一个服务发现的特性。

主服务器由各种组件组成，包括 kube-apiserver、etcd 键值存储、kube-controller-manager、cloud-controller-manager、kube-scheduler 和用于 Kubernetes 服务的 DNS 服务器。节点组件包括 kubelet 和 kube-proxy(图 1-3 )。

图 1-3

不可思议的建筑

主网点

以下是主节点上的主要组件:

• etcd 集群:etcd 集群是一个分布式键值存储，用于存储 Kubernetes 集群数据(比如 pod 的数量、它们的状态、名称空间等。)、API 对象和服务发现细节。

• kube-apiserver :这个 Kubernetes API 服务器为容器管理活动提供了一个编程接口，比如使用 REST APIs 的 Pods 管理、服务和复制集/控制器。

• kube-controller-manager :用于管理控制器进程，如节点控制器(用于监控和响应节点健康状况)、复制控制器(用于维护 Pod 数量)、端点控制器(用于服务和 Pod 集成)、服务帐户和令牌控制器(用于 API/令牌访问管理)。

• 云控制器管理器:它管理与基础云提供商交互的控制器进程。

• kube-scheduler :这有助于根据资源利用率管理跨目标节点的 Pod 放置。它考虑了资源需求、硬件/软件/安全策略、相似性规范等。，然后决定运行 Pod 的最佳节点。

节点 （ W 兽人） C omponent

以下是节点(工作)组件上的主要组件:

• Kubelet :运行在 worker 节点上的代理组件。它的主要目的是确保容器在 Pod 中运行。Kubernetes 管理范围之外的任何容器都不由 Kubelet 管理。这确保了 worker 节点、Pods 及其容器处于健康状态，并向 Kubernetes 主节点报告这些指标。

• kube-proxy :运行在 worker 节点上的代理服务，用于管理 Pod 间的联网和通信。

管理库帐户

kubectl是一个用于 Kubernetes 集群管理的命令行工具，使用 kube-apiserver 公开的 API。

立方结构工作负载

Kubernetes 工作负载包括以下主要组件:

• Pod :一个或多个容器的逻辑集合，这些容器构成了一个应用，并被表示为工作节点上正在运行的进程。Pod 打包应用容器、存储、网络和运行容器所需的其他配置。pod 可以横向扩展并支持应用部署策略，如滚动更新和蓝绿色部署，旨在减少应用停机时间和升级期间的风险。

• Service :这为一个或多个由策略绑定的 pod 的集合提供了一个接口。由于 Pod 的生命周期本质上是短暂的，因此即使后端 Pod 突然死亡，服务也有助于确保应用访问无忧。

• 名称空间:名称空间是一个逻辑结构，用于在多个用户之间划分集群资源。您可以使用带有命名空间的资源配额来管理多个应用团队的资源消耗。

• 部署:部署代表一个或多个正在运行的 pod 的集合。它与部署控制器密切合作，以确保 Pod 是可用的，符合 Pod 规范中提到的用户规范。

GCP 简介

谷歌云平台 (GCP)是谷歌的公共云产品，为最终客户提供一系列 IaaS/PaaS 服务。谷歌云平台(GCP)是谷歌提供的一套云计算服务。它们运行在谷歌内部为自己的终端用户产品使用的相同基础设施上，如谷歌搜索、谷歌照片、YouTube、Gmail 等。GCP 服务定位于现代应用开发用户，并在数据存储、大数据分析、人工智能和容器化领域提供一些独特的服务。谷歌继续创新和加强其产品。

GCP 提供广泛的服务，可分为以下几个领域:计算和托管、存储、网络、大数据和机器学习。为了构建云应用，GCP 提供了各种产品。表 1-1 中显示了一些受欢迎的服务。

表 1-1

GCP 服务

|

服务

|

描述

|
| --- | --- |
| 谷歌计算引擎 | 帮助创建运行操作系统的虚拟机，并允许在云中创建不同的计算机 |
| 谷歌库比厄引擎 | 使用 Kubernetes 作为托管服务，帮助管理 Container Orchestrator 以及部署、扩展和发布 |
| 谷歌云功能 | 帮助实现事件驱动的无服务器云平台，并创建代码形式的基础设施，即由代码设计和实现的基础设施 |
| 谷歌容器注册(GCR) | Google Container Registry 在 GCP 上提供安全、私有的 Docker 映像存储。它为团队提供了一个单一的位置来管理 Docker 映像、执行漏洞分析，并通过细粒度的访问控制来决定谁可以访问什么。 |
| Google Stackdriver(现在称为 Google Operations) | 帮助公共云用户获得性能和诊断数据。Stackdriver (Google Operations)提供了对 Google 云和 AWS 云环境的支持，使其成为一个混合云解决方案。 |

容器生态系统的 GCP 容器解决方案

GCP 提供各种服务来运行容器生态系统。从提供完全托管环境的Google Cloud Run，到提供集群管理的 Kubernetes Engine 。 谷歌计算引擎 提供自助式计算基础设施。总的来说，GCP 为运行容器提供了一个理想的解决方案。GCP 还提供使用容器所需的工具，从开发到生产。

**云构建 和 容器注册表 提供 Docker 镜像存储和管理，以高安全标准和高效网络为后盾。谷歌的容器优化操作系统提供了一个轻量级、高度安全的操作系统，预装了 Docker 和 Kubernetes 运行时(图 1-4 )。

图 1-4

GCP 容器生态系统服务

表 1-2 提供了容器生态系统 GCP 服务的详细信息。

表 1-2

容器生态系统的 GCP 服务详情

|

GCP 解决方案名称

|

特征

|

用户需求

|
| --- | --- | --- |
| 库柏发动机 | 全自动容器编排，包括健康监控、节点自动扩展、升级、修复和回滚仅关注应用组件，而非虚拟机提供高度可用的异构和多区域集群 | 用户将在生产环境中获得高度管理、安全和可扩展的容器。在虚拟机池的容器上高效运行基于微服务的应用不再需要专注于管理集群软件或基础架构 |
| 计算引擎 | 促进虚拟机级别的自动扩展、自动修复、滚动更新、多区域部署和负载均衡没有容器编排。考虑将 Kubernetes 引擎用于托管 Kubernetes 的自动化容器编排。直接访问专用硬件，包括本地固态硬盘、GPU 和 TPU | 允许将容器化应用与现有 IaaS 基础设施轻松集成轻松地为每个虚拟机部署一个容器采用容器，即使您还不熟悉编排工具。准备就绪后，迁移到 Kubernetes 引擎，进行完整的编排。 |
| 云运行 | 快速自动缩放支持自定义域，将您的服务与您的域对应起来代码运行时付费。 | 没有语言障碍；在完全管理的无服务器环境中使用任何语言和任何库构建和运行公共或私有微服务 |
| App 引擎灵活环境 | 完全托管的 PaaS 服务，在一个容器中运行应用通过内置的自动扩展和负载均衡提供自动高可用性零停机升级的应用版本控制对微服务、授权、SQL 和 NoSQL 数据库、日志记录、安全扫描和内容交付网络的本机支持 | 在容器中部署应用引擎应用的定制运行时构建高度可靠且可扩展的服务应用或组件，无需处理服务器、集群或基础设施关注基础设施控制上的代码编写和开发速度 |

谷歌库比厄引擎

今天，Kubernetes 是业界领先的容器编排工具。所有主要的云提供商都提供托管 Kubernetes 服务。

谷歌向其客户提供托管的 Kubernetes 服务，称为谷歌 Kubernetes 服务、或谷歌 Kubernetes 引擎(GKE) 。GKE 帮助管理容器化的环境，这有助于开发基于微服务的应用，并使用谷歌基础设施管理和扩展客户的容器化应用。它使用 Kubernetes APIs、命令和资源来部署和管理应用、执行管理任务、设置策略以及监控部署的应用的健康状况。

当 GKE 集群运行时，它提供了 GCP 提供的高级集群管理功能的优势。其中包括

• 计算引擎实例的 GCP 负载均衡

• 节点池用于指定群集中的节点子集，以增加灵活性

• 自动扩展集群的节点实例数

• 集群节点软件的自动升级

• 节点自动修复以维护节点健康和可用性

• 使用 Stackdriver (Google operations)进行日志记录和监控，以便了解您的集群

图 1-5 显示了 GKE 组件。

图 1-5

GKE 组件

GKE 通过 Kubernetes Master 组织其平台。每个容器集群都有一个主端点，由 Kubernetes 引擎管理。主服务器提供了集群的统一视图，并且通过其可公开访问的端点，成为与集群交互的入口。

受管主节点还运行 Kubernetes API 服务器，该服务器为 REST 请求提供服务，在工作节点上安排 Pod 的创建和删除，并将 Pod 信息(比如开放的端口和位置)与服务信息同步。

比较 EKS、AKS 和 GKE

现在让我们比较一下三家云提供商提供的 Kubernetes 服务的特点:亚马逊网络服务(AWS)的亚马逊弹性 Kubernetes 服务(EKS)，微软 Azure 的 Azure Kubernetes 服务(AKS)，以及谷歌云的 GKE。

亚马逊弹性库柏服务

EKS 是 AWS 上提供的托管容器服务。它与其他 AWS 服务进行了丰富的集成，如 CI/CD 流水线、Cloudwatch 和 Cloudformation 等。由于 EKS 是基于 Kubernetes 的，所以它可以处理行业中大多数流行的用例，并作为应用的部署目标以及日志和应用性能指标的数据源。

如果你已经有了大量的 AWS 足迹，或者正在使用 Kubernetes 进行试验，或者想要将工作负载从 Kubernetes 迁移到其他云，那么 EKS 是一个不错的选择。

蓝色 Kubernetes 服务

AKS 是 Azure 提供的托管容器服务，运行在 Azure 公共云、政府云以及本地 Azure Stack 上。它与其他 Azure 服务无缝集成，并管理工作节点。它还提供了与微软其他跨平台开发工具的集成，包括 VS Code 和 DevOps(以前的 Visual Studio Team Services)。

如果你是一个微软商店，并且对另一个云没有强烈的愿望，AKS 是一个不错的选择。

谷歌库比厄引擎

GKE 是 Kubernetes 的托管服务，可在谷歌云平台上使用。GKE 为市场提供部署应用的服务，并为正常运行时间提供最高的服务级别协议(SLA)保证。它使用 Istio 服务网格和 gVisor 保护运行中的容器。它还有一个正在开发的内部产品，作为谷歌的 Anthos 产品的一部分，用于专用硬件上的混合/多云环境。

表 1-3 比较了 AK、EKS 和 GKE 的特点。

表 1-3

GKE、阿克苏和 EKS 的特点比较

|   |

竞开通讯之星

|

问

|

EKS

|
| --- | --- | --- | --- |
| 库比厄版本 | gke.27 | One point one five | One point one five |
| 多 AZ | 是 | 部分的 | 是 |
| 升级 | 自动/按需 | 按需 | 不清楚 |
| 自动缩放 | 是 | 自我部署 | 自我部署 |
| 网络策略 | 是 | 自我部署 | 自我部署 |
| 持久卷 | 是 | 是 | 是 |
| 负载均衡 | 是 | 是 | 是 |
| CLI 支持 | 部分的 | 是 | 是 |
| 服务网格 | 伊斯蒂奥 | 发展中 | 是(应用网格) |
| 角色访问控制 | 是 | 是 | 是 |
| 服从 | HIPAA、SOC、ISO、PCI DSS | HIPAA、SOC、ISO、PCI DSS | HIPAA、SOC、ISO、PCI DSS |
| 应用秘密加密 | 是 | 不 | 不 |
| 服务等级协议 | 99.5%(区域)99.95%(地区) | 99.5% | 99.9% |
| 市场 | 是 | 不 | 不 |
| 定价 | GCE 机器和其他资源的标准成本 | 节点虚拟机和其他资源的标准成本 | 每个群集 0.10 美元/小时，外加 EC2 实例和其他资源的标准成本 |

GKE 建筑

Google Kubernetes 引擎由一个集群组成，该集群至少有一个主机器和多个称为节点的工作机器。Kubernetes 系统的编排是在主机和节点机的帮助下运行的。任何 GKE 生态系统的基本单位是集群。代表在集群上运行的应用的对象如下图所示(图 1-6 )。

图 1-6

GKE 建筑

集群主机

Kubernetes 控制面板进程和 Kubernetes API 服务器、调度程序和核心资源控制器都在集群主服务器上运行。当集群被创建或删除时，GKE 管理主服务器的生命周期。升级运行在主服务器上的 Kubernetes 版本是由 GKE 根据用户的要求自动或手动完成的。

集群管理器和 Kubernetes API

与集群管理器的交互是通过 Kubernetes API 调用来执行的。主服务器通过 Kubernetes API 服务器进程处理请求。Kubernetes API 调用可以通过 gRPC/HTTP、kubectl 进行，也可以通过与云控制台中的 UI 进行交互。

节点

工作节点是由 GKE 创建的单个计算引擎虚拟机实例。一个节点运行服务来支持 Docker 容器。这些包括 Docker 运行时和 Kubernetes 节点代理(kubelet)，它与主节点通信，负责启动和运行在该节点上调度的 Docker 容器。

节点机器的类型

节点具有不同类型的标准计算引擎机器类型。默认类型是 n1-standard-1，有一个虚拟 CPU 和 3.75GB 内存。机器类型的详细信息可从以下网址获得: https://cloud.google.com/compute/docs/machine-types /。

• 节点操作系统镜像:节点运行一个专用操作系统镜像，例如 Linux RHEL、Ubuntu，用于运行容器。创建集群时，我们可以选择在节点池中使用哪种类型的操作系统映像。

• 集群类型 : GKE 提供了创建集群时可以使用的各种类型的集群。创建群集类型后，不能更改。

• 单区域集群:单区域集群有一个主节点，也称为控制面板，在单个区域中运行，管理同一区域中运行的节点上的工作负载。

• 多区域集群:这是在单个区域中运行的控制面板的单个副本，并且具有在多个区域中运行的节点。

• 区域集群:在一个给定的区域内，这些控制面板的多个副本运行在多个区域中，节点也运行在一个控制面板副本运行的每个区域上。

• 节点池:一组具有相同配置类型的节点称为节点池。池中的每个节点都有一个 Kubernetes 节点标签“cloud.google.com/gke-nodepool, ”,其值是节点池的名称。节点池可以包含一个或多个节点。创建群集时，所提供的节点数量和类型将成为默认节点池。不同大小和类型的额外自定义节点池可以添加到群集。任何给定节点池中的所有节点都彼此相同。

容器注册表

Google Cloud Container Registry 是托管 Docker 映像的私有注册表。可以通过 HTTPS 端点访问 Container Registry，您可以从任何其他系统或云或您自己的系统管理、推送和提取 Google Cloud 提供的虚拟机实例的 Docker 映像。

Cloud Container Registry 是一个高度安全的私有注册表，只对拥有有效访问权限的用户开放。它检测映像中的漏洞，并确保安全的容器映像部署。它使用最新的基于漏洞的数据库，确保映像将扫描新的恶意软件。

当您将代码提交到云源代码库、GitHub 或 Bitbucket 时，它会自动构建映像并将其推送到私有注册表中。用户可以轻松设置 CI/CD 流水线，集成到云构建或直接部署到 Google Kubernetes 引擎、App Engine、云功能或 Firebase。容器登记支持 Docker 映像清单 V2 和 OCI 映像格式。

网络

本节概述了 Google Kubernetes 引擎网络的核心概念。Kubernetes 使用声明性语言来定义应用如何部署，应用如何相互通信以及如何与 Kubernetes 平面通信，以及客户端如何访问部署的应用。

在为应用使用 Kubernetes orchestration 时，应用及其主机的网络设计是针对 pod、服务和外部客户端通信而设计的，而不是考虑主机或虚拟机是如何连接的。

Kubernetes 的高级软件定义网络(SDN)支持在同一区域集群中跨不同区域的 pod、服务和节点进行数据包路由和转发。Kubernetes 和 Google Cloud 还根据您在 Google Cloud 上的 Kubernetes 部署和集群配置的声明性模型，在每个节点上动态配置 IP 过滤规则、路由表和防火墙规则。

服务、pod、容器和节点使用 IP 地址和端口进行通信。Kubernetes 提供不同类型的负载均衡来将流量导向正确的 pod。

• ClusterIP :分配给服务的 IP 地址。在其他文档中，它可能被称为“集群 IP”该地址在服务的生命周期内是稳定的，这将在本章的“GCP 简介”一节中讨论。

• Pod IP :分配给给定 Pod 的 IP 地址。正如“GCP 简介”中所讨论的，这是短暂的

• 节点 IP :分配给给定节点的 IP 地址。

云运行

要在云中部署和运行基于容器的应用，需要能够管理服务器、网络安全和存储复杂性的服务。

Google Cloud 提供了这样一种服务，叫做 Cloud Run。它是无服务器的，使您能够运行通过 web 请求和发布/订阅事件调用的无状态容器。Cloud Run 构建在开放的 cloud native 标准之上，支持应用的可移植性。

主要特征

云运行的主要功能如下:

• 使用任何语言、二进制或库:它允许使用任何编程语言或系统库。

• 使用容器工作流和标准: Cloud Run 利用容器工作流和标准，如 Docker、容器注册表和云构建。

• 定价: GCP 为其云运行服务提供按使用付费服务。

安朵斯

Anthos 是 Google 的多云应用平台，它基于一次构建，随处运行的概念，对现有的应用进行现代化改造。

Anthos 不是一个单一的产品，而是一堆执行应用现代化、云迁移以及多云和混合云管理的多种服务。Anthos 支持内部和云环境之间的一致性，并有助于加速应用开发(图 1-7 )。

图 1-7

Anthos 组件

Anthos 的组成部分

GK 花序

安索斯 GKE 组件提供全面的容器管理，快速安装和谷歌验证升级。

Google Cloud Console 为跨内部和云环境管理集群提供了单一控制台视图。

Anthos 配置管理

这实现了快速和安全的应用部署，并允许您为应用于 Kubernetes 集群的管理策略创建一个通用配置，无论是在本地还是在云中。

Anthos 服务网格

管理复杂微服务架构的全托管服务网格。它全面简化了运营服务，从流量管理和网格遥测到保护服务之间的通信。

尽管对 Anthos 的详细讨论不在本书的范围之内，我们还是提供了对 GKE 及其组件的广泛讨论。

摘要

在这一章中，我们讨论了容器生态系统的发展，Docker 和 Kubernetes 架构，以及容器技术的优势和挑战。下一章从建立 GCP 环境的实际练习开始。**

二、在 GCP 上设置环境

这本书的第二章向你介绍了在 GCP 上设置一个环境。您还将学习如何注册一个 Google 帐户，并为 GCP 容器生态系统建立一个环境。本章涵盖以下主题:

• 注册谷歌云

• 为谷歌 GKE 设置环境

• 容器支持服务

注册谷歌云

让我们从 GCP 开始吧。第一步是注册进入 GCP。下面介绍了注册所需的步骤，主要针对首次用户。

注册该平台的首要先决条件是一个谷歌账户。GCP 使用谷歌账户进行访问管理和认证。如图 2-1 所示，在浏览器窗口输入网址 https://cloud.google.com/free# 。

图 2-1

谷歌云平台

点击免费开始按钮，将弹出以下登录屏幕(图 2-2 )。

图 2-2

GCP 登录屏幕

系统会提示您输入一个 Google 帐户。如果您没有 Google 帐户，请按照创建帐户流程创建一个。

Note

如果帐户已经登录，您将被重定向到 GCP 控制台(图 2-3 和 2-4 )。

图 2-4

GCP 项目激活

图 2-3

GCP 控制台

如果您有资格获得免费等级，系统会提示您输入帐户详情，如图 2-5 所示。

图 2-5

GCP 自由层注册，步骤 1

选择您的国家，同意服务条款，然后单击继续按钮。这将带您进入第 2 步，如图 2-6 所示，在这里您可以创建并选择您的支付模式。提供所需的账单详情；但是，请注意，除非您手动升级，否则自动借记不会发生。

图 2-6

GCP 自由层注册，步骤 2

当您创建付款模式并登录时，右侧面板会显示详细信息，如图 2-7 所示。

图 2-7

GCP 自由层信息

正如你所看到的，谷歌提供了为期 12 个月的 300 美元的免费试用信用，这不仅足以探索书中的所有练习，还可以进一步评估 GCP。一旦您指定了所有的细节，点击开始我的免费试用按钮。

完成注册需要一段时间。一旦必要的验证完成，您将被重定向到 Google 控制台，您就可以开始了。

点击虚拟机创建控制台上的创建按钮，激活将用于创建虚拟机的 GCP 计算引擎服务(图 2-8 )。

图 2-8

通过控制台为虚拟机创建激活 GCP 计算引擎

单击页面右上角的激活按钮。它会提示你升级。点击升级(图 2-9 )。

图 2-9

虚拟机创建控制台升级

根据提示刷新页面(图 2-10 )。

图 2-10

虚拟机创建控制台刷新提示

一旦激活过程完成，将显示以下屏幕(图 2-11 )。

图 2-11

激活后屏幕

为谷歌 GKE 设置环境

设置 GCP CLI

gcloud 命令行界面(CLI)是管理 GCP 的主要 CLI 工具。

Google Cloud SDK(软件开发工具包)提供了多种命令行工具来与 GCP 进行交互，即

• gcloud : GCP 的主要 CLI

• gsutil :与谷歌云存储交互的命令行界面

• bq :与 Google BigQuery 交互的命令行界面

• kubi CTL:kubi engine CLI

您可以使用 gcloud CLI 来执行许多常见的平台任务，无论是从命令行还是在脚本中，以及通过 Jenkins/Ansible 等其他自动化工具。

例如，您可以使用 it gcloud CLI 来创建和管理

• Google 计算引擎虚拟机实例和其他资源

• Google Cloud SQL 实例

• Google kuble engine cluster(Google kuble engine 群集)

• Google Cloud Dataproc 集群和作业

• Google Cloud DNS 管理的区域和记录集

• Google 云部署管理器部署

您还可以使用 gcloud CLI 部署 App Engine 应用并执行其他相关任务。gcloud CLI 是 Google Cloud SDK 的一部分。

默认情况下，SDK 仅安装一般可用性级别的 gcloud CLI 命令。名为 alpha 和 beta 的 SDK 组件提供了额外的功能。这些组件允许您使用 gcloud CLI 与 Google Cloud Bigtable、Google Cloud Dataflow 和云平台的其他部分在早于正式发布的版本级别上协同工作。

表 2-1 描述了 gcloud CLI 命令发布级别。

表 2-1

gcloud CLI 命令发布级别

|

释放水平

|

标签

|

描述

|
| --- | --- | --- |
| 一般利用率 | 没有人 | 命令被认为是完全稳定的，可用于生产。对于中断当前功能的命令，会给出预先警告，并记录在发行说明中。 |
| 贝塔 | 贝塔 | 命令在功能上是完整的，但可能仍有一些突出的问题。对这些命令的重大更改可能会事先不通知。 |
| 希腊字母的第一个字母 | 希腊字母的第一个字母 | 命令是早期版本，可能会更改，恕不另行通知。 |

安装 SDK 时，默认情况下不会安装 alpha 和 beta 组件。您必须使用 gcloud components 的install命令单独安装这些。如果您尝试运行 alpha 或 beta 命令，而相应的组件没有安装，gcloud 命令行工具会提示您安装它。

gcloud CLI 版本与 SDK 的版本号相同。目前的 SDK 版本是 278.0.0。

Note

gcloud 命令行工具在 Google Cloud Shell 中自动可用。如果您使用的是 Cloud Shell，则无需手动安装 gcloud CLI 即可使用。

GCP 云壳

Google Cloud Shell 为你提供了对托管在 GCP 上的计算资源的命令行访问，并且可以从 GCP 控制台获得。Cloud Shell 让您可以轻松管理您的云平台控制台项目和资源，而不必安装 Google Cloud SDK 和其他工具。有了 Cloud Shell，Cloud SDK gcloud 命令和其他你需要的实用工具在你需要的时候随时可用。

创建项目

项目本质上是一个容器，用于重组与特定云项目相关的所有 IT 和非 IT 资源。每个项目都由一些特定参数标识，如下所示(表 2-2 )。

表 2-2

项目参数

|

参数

|

描述

|
| --- | --- |
| 名字 | 这是用来识别和描述一个项目。该名称仅供用户参考，可随时更改。免费层访问允许创建 24 个项目。 |
| 项目标识 | 这是用于在全球范围内标识项目的唯一字符串。它是从项目名称开始创建的。可以编辑和更改项目 ID。要创建项目 ID，可以使用任何小写字母、数字和连字符。唯一的要求是该名称是唯一的。输入唯一 ID 后，就不能再更改了。 |
| 项目编号 | 这是一个由 GCP 自动生成的参数。您不能管理或更改此号码。 |

要创建新项目，请单击“创建新项目”按钮。这导致以下步骤:

1. 转到云控制台中的管理资源页面。

2. 在页面顶部的“选择组织”( Select organization)下拉列表中，选择要用来创建项目的组织。如果您是免费试用用户，请跳过这一步。

3. 单击创建项目。

图 2-12

新项目详细信息屏幕

1. 在出现的新项目窗口中，输入项目名称并选择一个计费账户(如适用)(图 2-12 )。

   请记住，项目 ID 必须有一个唯一的名称，该名称将在所有 Google Cloud 项目中使用。(上图中的项目名称已经被占用，对您不起作用。)项目名称将是 PROJECT_ID。

图 2-13

新项目视图

1. 输入完新项目的详细信息后，单击“创建”。新项目将被选中，如下图所示(图 2-13 )。

发射云壳

从左上角工具栏上的 GCP 控制台云壳图标激活谷歌云壳(图 2-14 )。

图 2-14

云壳按钮

将显示以下画面。点击继续(图 2-15 )。

图 2-15

云壳屏

点击继续按钮后，点击启动云壳按钮，启动云壳会话(图 2-16 )。

图 2-16

云壳开始屏幕

配置和连接到环境应该需要几分钟时间。上述活动是一次性的。下一次，点击外壳按钮将导致以下屏幕(图 2-17 )。

图 2-17

云壳屏

这个虚拟机装载了您需要的所有开发工具。它提供了一个持久的 5GB 主目录，运行在谷歌云上，极大地增强了网络性能和认证。你在这个实验室的大部分工作，如果不是全部的话，都可以通过简单的浏览器或谷歌 Chromebook 来完成。

一旦连接到 Cloud Shell，您应该首先检查您已经通过了身份验证，并且项目已经设置为您的 PROJECT_ID。

在 Cloud Shell 中运行以下命令，确认您已经过身份验证。

图 2-18

列出项目命令输出

• 命令 : gcloud 配置列表项目

• 输出:输出应该显示如下(图 2-18 )。

在计算引擎中创建虚拟机实例

本节解释了如何使用谷歌云控制台在计算引擎中创建 Linux VM 实例(图 2-19 )。

图 2-19

云控制台页面—虚拟机实例选项

1. 在云控制台选项上，点击虚拟机实例链接，如图 2-19 所示。

图 2-20

云控制台页面—创建虚拟机选项

1. 从云控制台选项中，点击创建按钮，创建一个新实例(图 2-20 )。

图 2-21

云控制台页面—创建实例页面

1. 在创建实例页面的引导盘部分，点击更改，开始配置引导盘(图 2-21 )。

图 2-22

配置启动盘

1. 在公共映像选项卡上，选择您首选的操作系统和版本。在这种情况下，我们选择 Debian 版本 9(图 2-22 )。

图 2-23

选择防火墙规则

1. 在防火墙部分，为您的防火墙选择所需的规则。在这种情况下，我们选择允许 HTTP 流量(图 2-23 )。

图 2-24

虚拟机实例页面状态图标

1. 单击“创建”创建实例。

   请给实例一些时间来启动。实例准备就绪后，它会在虚拟机实例页面上以绿色状态图标列出(图 2-24 )。

图 2-25

虚拟机实例仪表板

1. 在虚拟机实例列表中，在您想要连接的实例所在的行中单击 SSH(图 2-25 )。

图 2-26

虚拟机实例终端

1. 现在你有了一个与你的 Linux 实例交互的终端窗口，如图 2-26 所示。

在创建的虚拟机上设置 CLI

在本节中，我们将在上一节中创建的新虚拟机上设置 CLI。

图 2-27

软件包下载页面

• 步骤 1: 登录到前面创建的虚拟机。在 https://cloud.google.com/sdk/docs/downloads-versioned-archives 从 SDK 包中选择合适的下载，向下滚动找到需要安装的包(图 2-27 )。

图 2-28

软件包下载页面

• 右键单击突出显示的包并选择复制链接地址(图 2-28 )。

图 2-29

pwd命令的输出

• 步骤 2: 检查当前工作目录，运行 package download 命令，使用上一步复制的链接下载 SDK 包。

• 命令:pwd—检查当前工作目录

• 输出:pwd的结果显示如下(图 2-29 )。

图 2-30

wget命令的输出

• 命令 : wget https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-sdk-279.0.0-linux-x86_64.tar.gz

• 输出:wget的结果显示如下(图 2-30 )。

图 2-31

使用 ls 命令列出下载的包，输出如上

• 下载后，SDK 包可以列出如下。

• 命令: ls

• 输出:ls命令的结果显示如下(图 2-31 )。

图 2-32

解压缩包命令输出

• 步骤 3: 使用下面的命令解压 SDK 包。

• 命令: tar -xvf google-cloud-sdk-279.0.0-linux-x86_64.tar.gz

• 输出:前一条命令的结果显示如下(图 2-32 )。

图 2-33

取消文件列表输出

• 可以按如下方式列出未加灰的文件，使用

• 命令: ls –lrt

• 输出:前一条命令的结果将显示如图 2-33 所示。

图 2-36

安装 SDK 输出屏幕—续

图 2-35

安装 SDK 输出屏幕—续

图 2-34

安装 SDK 输出屏幕—续

• 步骤 4: 在同一个目录中使用以下命令安装 SDK。

• 命令: ./google-cloud-sdk/install.sh

• 输出:前一条命令的结果显示如下(图 2-34 、 2-35 、 2-36 )。

• 按 y 键。

• 第五步:安装完成后，必须初始化 gcloud 才能执行命令。

在本地计算机上配置 Google Cloud CLI

采取以下步骤来配置 Google Cloud SDK。

图 2-38

SDK 初始化输出

图 2-37

SDK 初始化

1. 使用以下命令初始化 SDK。

   命令 : gcloud init(图 2-37 )

   输出:前面命令的结果如下(图 2-38 )。

如何获取项目 ID

要获取项目 ID，返回到项目列表并复制适当的项目 ID，如图 2-39 所示。如图 2-40 所示输入项目 ID，并按下回车键继续(图 2-39 )。

图 2-40

SDK 初始化输出

图 2-39

选择一个项目屏幕

云壳连接到谷歌项目。

在 Cloud Shell 中运行以下命令，确认您已经过身份验证。

命令: gcloud config list project(图 2-43 )

图 2-41

SDK 初始化输出—续

输出:前面命令的结果如下(图 2-44 )。

图 2-44

列出项目输出屏幕

图 2-43

列表项目屏幕

图 2-42

SDK 初始化输出—续

容器支持服务

随着容器技术的兴起，出现了支持企业可以在容器上运行关键任务工作负载的生态系统的需求。容器技术的引入和微服务架构的应用需要监控解决方案。监控解决方案现在需要管理大量对象的非短暂和短暂服务的数据。从由如此多的服务组成的应用中收集数据已经变得非常复杂。对于容器服务，需要考虑以下细微差别:

• 容器的生命周期短****:如果用于托管微服务，容器会根据特定时间点的需求不断地被供应和停用。这可能会导致循环，在早上，一个容器主机集群中充满了属于工作负载 A 的微服务，而在下午，同一台主机正在为应用 b 提供服务。这意味着某台主机上的安全违规、性能低下或停机对业务的影响将会非常不同，具体取决于发生的时间。

*** 一个微服务可以被 多个应用利用:由于不同的应用经常共享相同的微服务，监控工具必须能够动态地判断微服务的哪个实例影响了哪个应用。

*   **容器的临时性质****:当基于容器映像触发新容器的组装时，必须立即提供网络连接、存储资源以及与其他所需企业服务的集成。这种动态供应会影响相关和不相关基础设施组件的性能。**

***   **更多级别需要关注**:对于 Kubernetes，企业 IT 必须在节点(主机服务器)、pod(主机集群)和单个容器级别进行监控。此外，必须在虚拟机和存储级别以及微服务级别进行监控。

*   **不同的容器管理框架**:亚马逊 EC2 容器服务运行在亚马逊自产的管理平台上，而谷歌自然支持 Kubernetes(VMware 也是)，Docker 支持 Swarm。容器监控解决方案必须意识到这些容器管理平台之间的差异。

*   **微服务变化快且频繁**:基于微服务的应用的异常检测比标准应用要困难得多，因为由微服务组成的应用处于不断变化之中。新的微服务被添加到应用中，现有的微服务以非常快的顺序更新，从而导致不同的基础架构使用模式。监控工具需要能够区分由有意更改引起的“正常”使用模式和必须解决的实际“异常”。**** 

****表 2-3 解释了在容器生态系统的多个层面收集的各种指标。

表 2-3

容器技术发展的度量分解视图

|  |

为了获得容器化应用的完整可见性，您现在必须拥有来自各种组件的数据，这些数据构成了运行容器的基础设施。这意味着您必须监控以下内容:

• 应用服务程序

• POD 和容器

• 运行容器的集群

• 服务/Pod/集群通信网络

• 运行群集的主机操作系统/机器

根据解决方案的利弊，选择正确的监控工具集当然很重要。以下是市场上可用于容器生态系统的选项(表 2-4 )。

表 2-4

容器生态系统的工具

|

功能

|

服务

|

描述

|
| --- | --- | --- |
| 监视 | Prometheus | Prometheus 是历史最悠久、最受欢迎的开源容器监控解决方案之一。这是一个云计算原生计算基金会(CNCF)项目，提供强大的查询功能、可视化和警报。 |
| 报告和仪表板 | 格拉凡娜 | Grafana 是一个流行的用于容器环境的报告仪表板工具。它能够利用来自 Prometheus 和其他来源的数据，在 Kubernetes 环境中可视化信息。 |
| 监视 | 顾问 | cAdvisor 是另一个容器资源监控工具，它工作在 worker 节点级别，而不是 Pod 级别。它能够发现工作节点上运行的所有容器，并提供关于 CPU、内存、文件系统等的指标。该解决方案不提供指标数据的长期存储，也不提供用于推动运营团队洞察的分析服务。 |
| 监视 | 希普斯特 | Heapster 在后端使用 kubelet 和 cAdvisor 聚合多个节点的监控数据。与 cAdvisor 不同，Heapster 工作在 Pod 级别，而不是工作节点级别。 |
| 监控和安全 | Sysdig 监控和保护 | Sysdig Monitor 通过跨多种容器技术和云提供从应用服务到 Pod、容器到节点级可用性、性能和故障的端到端可见性，帮助监控容器应用。此外，Sysdig 安全容器映像和集群级安全漏洞视图。 |
| 监视 | 动态跟踪 | 收购 Ruxit 后，Dynatrace 现在拥有了一套新的工具，可用于容器监控和报警。利用基于代理的方法，它可以发现和获取与容器化应用服务、pod、容器、工作节点等相关的数据。 |
| 监视 | 应用动力学 | 该应用和业务性能软件从安装在主机上的代理收集数据，并使用 Docker APIs 收集数据。 |
| 日志管理 | 流利 | 这是一个统一日志记录层的开源收集器。 |
| 监视 | 已收集 | 这是一个小守护进程，它定期收集系统信息，并提供存储和监控容器指标的机制。 |
| 监视 | 云原生 | 领先的云提供商，如 AWS (Cloudwatch)、Azure (Azure Monitor)和 Google Cloud (Stackdriver 或 Google Operations)都有自己的本地机制来监控 AWS EKS、Azure AKS 和 Google GKE 上的容器生态系统。 |
| 安全 | 水上安全 | Aqua Container Security Platform 提供精细的上下文感知安全性，同时自动化整个从映像到生产的流程，使企业能够专注于部署和运行应用。 |
| 安全 | Sysdig 安全性 | Sysdig 是一个统一的平台，提供诸如监控、故障排除和警报等服务，提供对动态分布式环境的深入了解。它捕获、关联和可视化全栈数据，并提供一个用于报告的控制面板。 |
| 安全性 | 扭锁 | Twistlock Cloud 原生网络安全平台为容器化环境提供全生命周期安全。Twistlock 有助于安全扩展和放心部署容器。 |
| 安全性和网络 | 伊斯蒂奥 | Istio 是一个开源服务网格，它透明地分层到现有的分布式应用上。它包括 API，允许它集成到任何日志平台或遥测或策略系统中。它成功且高效地运行分布式微服务架构，并提供统一方式来保护、连接和监控微服务。 |
| 注册表 | 海港 | Harbor 是一个开源的容器映像注册表，它通过基于角色的访问控制来保护映像，扫描映像中的漏洞，并将映像签名为可信。Harbor 提供合规性、性能和互操作性，有助于跨云原生计算平台(如 Kubernetes 和 Docker)一致、安全地管理映像。 |
| CI/CD | 大三角帆 | Spinnaker 是一个开源、多云、持续的交付平台，有助于快速、安全地发布软件变更，不会出现任何问题。它结合了强大而灵活的流水线管理系统，并与主要的云提供商集成。 |
| CI/CD | Jenkins | Jenkins 是一个流行的开源自动化服务器，它提供了许多插件来支持构建、部署和自动化项目构建和发布。 |
| 以下为代码 | 安塞波 | Ansible 是一个流行的基础架构代码自动化工具，基础架构和应用团队使用它来自动化任务，如供应、应用部署、安全管理等。这使得应用和 IT 团队能够提高生产力、质量和安全性，从而为企业提供服务。 |
| 以下为代码 | 仿地成形 | Terraform 是一个安全有效地构建、更改和版本控制基础设施的工具。Terraform 可以管理现有的和受欢迎的服务提供商以及定制的内部解决方案。Terraform 与云无关。配置文件描述了运行单个应用或整个数据中心所需组件的平台化。Terraform 生成一个执行计划，描述它将做什么来达到期望的状态，然后执行它来构建所描述的基础设施。随着配置的变化，Terraform 能够确定发生了什么变化，并创建可以应用的增量执行计划。Terraform 可以管理的基础设施包括低级组件，如计算实例、存储和网络，以及高级组件，如 DNS 条目、SaaS 功能等。 |
| 以下为代码 | Google 部署管理器 | 部署管理器是一个 Google 云基础设施部署服务，它自动创建和管理 Google 云资源。 |
| 建立关系网 | 科林斯饭店 | CoreDNS 是一个弹性的、松散的 DNS 服务器，可以作为 Kubernetes 集群 DNS 工作。CoreDNS 项目由 CNCF 主持。 |
| 应用编程接口管理 | 使者 | 特使在 Kubernetes 与大使一起作为 API 网关工作。Ambassador 作为一个专门的控制面板，将 Envoy 的功能作为 Kubernetes 注释公开。 |
| 以下为代码 | Helm | Kubernetes 应用可以使用 Helm 进行管理。为此，Helm 使用图表来定义应用部署细节。它有助于安装和升级复杂的应用。就版本控制、共享创建和发布而言，图表很容易管理。 |
| 安全 | 法尔科 | 这是一个开源的云原生运行时安全工具，通常用作 Kubernetes 威胁检测引擎。Falco 在运行时捕捉意外的应用行为和威胁警报。 |
| 监控、分析和报告 | 软体 | Splunk 产品有助于搜索、分析和可视化从 IT 基础设施或业务的不同组件收集的数据。它可以从应用、网站等收集数据。，一旦配置了数据源，它就会对数据流进行索引。索引数据流被解析成一系列可以进一步搜索和可视化的独立事件。 |

摘要

在这一章中，你已经看到了如何在 GCP 建立一个环境。我们还讨论了监控和管理容器生态系统所涉及的复杂性。我们讨论了用于监控和管理基于容器的应用的重要开源和企业工具。在下一章中，我们从设置 GKE 的实际练习开始，然后部署我们的第一个容器化应用。****

三、使用 Google 容器注册表的容器映像管理

在本章中，将向读者介绍谷歌容器注册(GCR)服务，他们将了解以下内容:

• Google 容器注册中心简介

• 设置 Google 容器注册表

• 将 Docker 映像推入 GCP 容器注册表

• 管理和保护 GCP 容器注册表

Google 容器注册中心简介

Container Registry 是管理 Docker 映像、执行漏洞分析以及控制哪些用户可以访问哪些映像的单一位置。GCR 为 CI/CD 和安全性提供了广泛的集成功能，从而使开发人员和管理员能够以安全的策略驱动方式轻松管理映像。它提供了在您提交代码到云资源仓库、GitHub 或 Bitbucket 时自动构建和推送映像到私有注册表的特性。

Google Container Registry 提供了在软件部署周期的早期阶段检测漏洞的功能。它可以评估容器映像对于部署是否安全。Google Container Registry 使用与二进制授权的本机集成来定义策略，并防止部署与设置的策略冲突的映像。它可以触发容器映像的自动锁定，从而禁止将有风险的映像部署到 Google Kubernetes 引擎。借助区域性私有存储库，您可以将映像存储在欧洲、亚洲或美国的计算实例附近，并访问 Google 的全球网络，以实现快速部署。以下是 GCR 的主要特征:

• 漏洞扫描:此功能支持扫描 Docker 映像容器，以识别漏洞。它可以识别 Ubuntu、Debian 和 Alpine 的软件包漏洞。

• 标记:标记映像可确保更好的可管理性。从 GCP 控制台可以轻松地添加和删除标记。

• 在代码或标签改变时构建触发器: GCR 允许在代码库的代码或标签改变时自动构建触发容器映像。此功能还提供了构建详细信息的整合视图，例如源步骤、日志和步骤。

设置 Google 容器注册表

设置 GCR 非常简单明了。以下步骤解释了如何快速设置 GCR 服务。

在第二章中，你学习了如何创建谷歌计算引擎。我们将使用同一个计算引擎实例来演示从 GCP 容器注册中心提取映像和将映像推送到该注册中心。对于本演示以及Pull和Push命令的执行，我们必须首先在计算引擎实例上安装 Docker 版本 18.03。按照以下步骤安装 Docker。

图 3-1

更新列表包命令

• 第一步:登录之前创建的虚拟机。

• 步骤 2: 运行下面的命令来更新现有的包列表。

• 命令: sudo apt update(图 3-1 )

图 3-2

更新列表包输出

• 输出:前面命令的结果如下(图 3-2 )。

图 3-3

软件包安装命令

• 第三步:安装几个先决条件包，允许apt在 HTTPS 上使用包。

• 命令: sudo apt install apt-transport-https ca-certificates curl gnupg2 software-properties-common(图 3-3 )

图 3-5

包安装输出

图 3-4

包安装输出

• 输出:前面命令的结果如下(图 3-4 和 3-5 )。

• 输入 y。

图 3-6

添加 GPG 键盘命令

• 第 4 步:将官方 Docker 存储库的 GPG 密钥添加到您的系统中。

• 命令: curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add –(图 3-6 )

图 3-7

添加 GPG 键输出

• 输出:前面命令的结果如下(图 3-7 )。

图 3-8

将 Docker 存储库添加到 ATP 命令和输出中

• 步骤 5 :将 Docker 存储库添加到 APT 源代码中。

• 命令: sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"(图 3-8 )

图 3-9

更新包命令

• 步骤 6 :用新添加的 repo 中的 Docker 包更新包数据库。

• 命令: sudo apt update(图 3-9 )

图 3-10

更新包输出

• 输出:前面命令的结果如下(图 3-10 )。

图 3-11

正在安装 Docker 策略

• 第 7 步:执行以下命令安装 Docker repo。

• 命令: apt-cache policy docker-ce

• 输出:结果如下(图 3-11 )。

图 3-12

安装 Docker 命令

• 第 8 步:最后，通过执行以下命令安装 Docker。

• 命令: sudo apt install docker-ce(图 3-12 )

图 3-13

安装 Docker 输出

• 输出:结果如图 3-13 所示。

图 3-14

安装 Docker 输出—续

• 输入 Y(图 3-14 )。

图 3-15

验证安装 Docker 命令/输出

• 步骤 9 :通过执行下面的查询，验证 Docker 已经成功安装。

• 命令/输出: sudo systemctl status docker(图 3-15 )

图 3-16

sudo特权命令

• 要在没有sudo的情况下执行 Docker 命令，请执行以下操作:

• 步骤 1 :执行以下查询。

• 命令: sudo usermod -aG docker ${USER}(图 3-16 )

图 3-17

验证 Docker 组权限

• 第二步:注销再登录，看应用效果。通过键入以下命令，确认您的用户现在已添加到 Docker 组中:

• 命令/输出: id –nG(图 3-17 )

将 Docker 映像推入 GCP 容器注册表

图 3-18

正在初始化 Google 帐户

• 第一步:使用之前创建的帐户 ID 登录。在我们的例子中，我们使用 gcptutorialmail@gmail.com 将映像推送到 GCP 注册中心。使用以下命令重新初始化，并在出现提示时输入 1 来选择配置。

• 命令/输出: gcloud init(图 3-18 )

图 3-19

正在初始化 Google 帐户

• 第二步:选择选项 2，配置账户进行图片上传操作(图 3-19 )。

图 3-21

登录代码

图 3-20

初始化 Google 帐户—续

• 第三步:输入“2”后，会要求你继续，输入“y”，在浏览器上打开屏幕显示的链接，复制验证码，粘贴到“输入验证码:”的屏幕上，你就成功登录了(图 3-20 和 3-21 )。

图 3-22

计算引擎区域

• 步骤 4: 在步骤 3 之后，系统将要求您从显示的列表中选择计算引擎区域。输入相应的数字。在我们的例子中，us-central1的数字是 8(图 3-22 )。

图 3-23

计算引擎区域—续

• 现在，将映像推入 GCP 容器注册表的 CLI 设置已经准备就绪。

• 第 5 步:在第 4 步之后，为了测试将映像推入 GCP 容器注册中心，我们将首先从 Docker Hub 下载一个示例nginx映像。使用以下命令检查下载。

• 命令: 1) docker pull nginx这将从公共 Docker Hub 中拉出映像nginx；2) docker images这将列出本地机器上存在的映像。

• 输出:前面命令的结果如下(图 3-23 )。

图 3-24

映像列表

• 步骤 6: 在步骤 5 之后，我们必须标记映像，以将其上传到容器注册表。标记后，可以使用以下第二个命令将其列出。

• 命令: 1) docker tag nginx gcr.io/flowing-garage-267211/nginx:v1这将在映像被推入 GCP 容器之前对其进行标记，该映像需要成为版本和映像。

• 2. docker images这将列出本地机器中存在的所有映像。

• 输出:前一条命令的结果如下(图 3-24 )。

图 3-25

Docker 推送映像

• 步骤 7: 在步骤 6 之后，我们现在将把映像推入容器注册中心，使用下面的命令来标记需要被版本化的映像，以便它可以被推入 GCP 容器。

• 命令: docker push gcr.io/flowing-garage-267211/nginx:v1

• 输出:前一条命令的结果如下(图 3-25 )。

图 3-26

映像导航

• 可以通过 GCP 控制台在容器注册表中查看该映像。导航到工具➤容器注册➤映像，如图 3-26 所示。

图 3-27

推送映像视图

• 点击映像链接，以下页面将显示映像列表(图 3-27 )。

图 3-28

移除映像

• 步骤 8: 在步骤 7 之后，我们将从 GCP 容器注册中心提取映像。

• 在此之前，我们将删除本地虚拟机上的可用映像。

• 命令: 1) docker images 2) docker rmi gcr.io/flowing-garage-267211/nginx:v1 3) docker images

• 输出:前面命令的结果如下(图 3-28 )。

图 3-29

拉动映像

• 步骤 9: 在步骤 8 之后，我们将使用以下命令从 GCP 容器注册中心获取映像。

• 命令: 1) docker images 2) docker pull gcr.io/flowing-garage-267211/nginx:v1 3) docker images

• 输出:下面的快照显示本地机器上没有映像。使用前面的命令，我们从 GCP 容器注册表中提取映像(图 3-29 )。

管理和保护 GCP 容器注册表

将映像复制到新注册表

让我们想象一个场景，来自另一个项目的用户需要访问我们在实践练习中使用的项目中的映像。为了演示这个用例，我们将首先使用以下步骤创建另一个项目。

图 3-30

创建新项目

• 步骤 1: 点击项目名称，如下图所示，打开选择项目窗口。单击新项目链接。输入项目名称(在本例中为“教程项目”)，然后单击 Create 按钮。弹出通知将显示消息“创建项目:教程项目”(图 3-30 )。

图 3-31

新项目列表视图

• 第二步:再次点击项目名称下拉菜单，新建的项目将出现在选择项目窗口中(图 3-31 )。

图 3-34

API 仪表板导航—续

图 3-33

API 仪表板导航—续

图 3-32

API 仪表板导航

• 步骤 3: 如果您可以访问两个注册表，那么可以使用命令行将一个映像从一个注册表复制到另一个注册表。现在尝试将项目“我的第一个项目”的容器注册表中的nginx:v1映像复制到新创建的项目“教程项目”的容器注册表中

• 要执行复制操作，您必须为新项目(教程项目)启用 API 注册表。为此，进入 API 仪表板屏幕，如图 3-32 、 3-33 和 3-34 所示。

图 3-35

API 仪表板导航—续

• 单击启用按钮。

• 现在，针对教程项目启用了 API 服务(图 3-35 )。

图 3-36

将映像复制到存储库输出

• 步骤 4: 在步骤 3 之后，运行下面的命令，将镜像复制到教程项目容器的注册表中。

• 命令: gcloud container images add-tag \gcr.io/flowing-garage-267211/nginx:v1 \gcr.io/tutorial-project-268109/nginx:v1

• 输出:结果如下所示(图 3-36 )。

图 3-38

粘贴到教程项目

图 3-37

从我的第一个项目复制

• 执行命令后，映像从一个项目复制到另一个项目。参见图 3-37 和 3-38 获取快照。

从容器注册表中删除映像

要演示从 GCP 容器注册表中删除映像，请运行以下命令。

图 3-39

映像已从注册表中删除

• 命令: gcloud container images delete gcr.io/tutorial-project-268109/nginx:v1

• 输出:结果如图 3-39 所示。

图 3-40

空白映像注册表视图

• 删除后，可以检查一下教程项目的 GCP 容器注册表会不会显示任何映像(图 3-40 )。

漏洞扫描映像

映像漏洞可能会对现有系统产生巨大影响。这可能导致整个系统故障或系统被恶意利用。GCP 的容器分析服务提供映像元数据的漏洞扫描和存储。容器分析对容器注册表中的映像存储运行扫描，并监控扫描的漏洞报告，以保持其更新。容器分析是一个两阶段的过程。

1. 每当一个新的映像被推入容器注册表时，容器分析服务就根据容器清单扫描该映像的漏洞并存储元数据。每次将映像重新上传到容器注册表中时，都会更新相同的元数据，从而跟踪映像扫描漏洞报告。这个过程被称为增量扫描。

2. 接下来，它对扫描映像的元数据进行持续监控，以检测新的漏洞。它不断检查和更新漏洞信息，创建新的事件，并删除不再有效的事件。这个过程叫做连续分析。

漏洞结果是映像的漏洞事件列表。它还包含扫描的严重级别，分为严重、高、中、低和最低。

现在让我们为上传到容器注册表中的示例应用映像设置漏洞扫描。

设置漏洞扫描

图 3-42

API 仪表板导航 API 和服务

图 3-41

API 仪表板导航

• 步骤 1: 要启用镜像的漏洞扫描，必须启用项目的容器扫描 API。遵循这些步骤(图 3-41 和 3-42 )。

图 3-43

API 仪表板—容器扫描 API

• 搜索容器扫描 API(图 3-43 )。

图 3-44

API 仪表板导航—容器扫描 API—续

• 点击启用(图 3-44 )。

图 3-45

API 仪表板导航—启用容器服务 API

• 现在，我的第一个项目启用了容器扫描 API 服务(图 3-45 )。

图 3-46

拉动 Docker 映像

• 第二步:在第一步之后，从 Docker Hub 中拉出一个应用镜像(如 wordpress)进行漏洞扫描(图 3-46 )。

图 3-52

映像漏洞详细信息

图 3-51

映像漏洞

图 3-50

映像检查

图 3-49

映像被推入存储库

图 3-48

映像标签

图 3-47

映像列表

• 步骤 4: 在步骤 3 之后，检查 GCP 控制台上的映像。你可以看到“漏洞”列出现在 wordpress 图片行中。点击“修复/全部”链接，查看图片漏洞扫描详情(图 3-50 、 3-51 、 3-52 )。

1. 在存储库中推送映像(图 3-49 )。

2. 标签映像(图 3-48 )。

• 步骤 3: 检查本地机器上的映像下载，标记映像，并将其推入容器注册表，这将自动触发容器映像扫描，如下所示:

• 命令: 1 ) docker images 2) docker tag wordpress gcr.io/flowing-garage-267211/wordpress:v1 3) docker push gcr.io/flowing-garage-267211/wordpress:v1

• 输出:

  1. 获取映像列表(图 3-47 )。

摘要

在本章中，您了解了 GCP 容器注册中心，如何设置容器注册中心，以及如何从 GCP 容器注册中心获取和推送映像。在下一章中，您将看到如何在开始应用部署之前设置 GKE 网络元素。

四、GKE 网络

本章解释了如何在 GKE 建立网络环境，还涵盖了使用各种场景的每个子组件的各种使用案例。讨论了以下主题:

• Google Kubernetes 引擎介绍(GKE)

• GKE 网络术语

• 容器之间的通信

• 同一节点上的 pod 之间的通信

• 不同节点上的 pod 之间的通信

• pod 与服务的通信

• pod 与互联网的通信(外部世界)

• 服务的负载均衡

• 从外部负载均衡器到服务的通信

• 从内部负载均衡器到服务的通信

• GKE 群组的部署

Google Kubernetes 引擎介绍(GKE)

GKE 是谷歌云平台(GCP)的平台即服务(PaaS)组件，是托管在 GCP 的 Kubernetes 的托管版本。它有助于管理部署环境，包括扩展和容器化应用。

GKE 使用 Kubernetes 开源集群管理系统。Kubernetes 层提供了管理机制，例如执行管理任务、设置策略和监控部署工作负载的健康状况。GKE 集群还用于部署和管理应用。

Google Cloud 上的 Kubernetes

GKE 为集群管理提供了各种高级功能，包括:

• 一种节点池功能，用于指定群集中的节点子集，以便于管理

• 集群节点实例的自动扩展

• 节点群集软件的自动升级

• 一个自动修复节点来维护其健康和可用性

• 使用 GCP stack driver(Google Operations)记录和监控集群可见性

GKE 集群需要至少有一个 Kubernetes 的主组件和工作组件。以下是 GKE 集群生态系统的主要组成部分:

• 集群主机:该组件运行 Kubernetes 控制面板进程，包括调度程序、API 服务器和其他控制器。集群主服务器的生命周期由 GKE 管理。

• 集群主机和 Kubernetes API: 与集群主机的任何交互都由 Kubernetes API 调用来管理，以执行只读或读/写操作。对集群主服务器的传入 API 请求通过运行在集群主服务器上的 Kubernetes API 进程进行管理。最终用户可以通过 Rest API 调用、kubectl 或 GCP 控制台触发 Kubernetes API 调用。

• 节点:Kubernetes 集群的 Worker 节点通常被称为节点。节点是由 GKE 根据用户在配置时提供的配置自动创建的单个计算引擎虚拟机实例。利用一个节点来运行由一个或多个 pod 组成的服务，以运行应用。一个节点通常包括容器运行时和 Kubernetes 节点代理(kubelet ),它与集群主节点通信以执行各种管理任务。

  • 节点机器的类型:节点有不同类型的标准计算引擎机器类型。默认类型是 n1-standard-1，有一个虚拟 CPU 和 3.75GB 内存。通过以下链接，您可以访问可用机器类型的详细信息: https://cloud.google.com/compute/docs/machine-types 。

  • 节点操作系统镜像:节点使用专用操作系统镜像，例如 Linux RHEL 和 Ubuntu，用于运行容器。创建群集时，用户可以选择在节点池中使用哪种类型的操作系统映像。

• 节点池:一组具有相同配置类型的节点。池中的每个节点都有一个 Kubernetes 节点标签cloud.google.com/gke-nodepool，它的值是节点池的名称。节点池可以包含一个或多个节点。创建集群时，可以指定节点的数量和类型，这将成为默认的节点池。我们可以向群集中添加不同大小和类型的额外自定义节点池。任何给定节点池中的所有节点都彼此相同。

• 节点映像:创建 GKE 集群或节点池时，我们必须选择在每个节点上运行的操作系统映像。GKE 为集群提供了以下节点映像选项:

  • 人的本质

  • Windows 操作系统

  • 谷歌的容器优化操作系统

  • 使用 containerd 的容器优化操作系统

  • 带有容器的 ubuntu

GKE 提供了各种类型的集群，在创建集群时可以从中进行选择。一旦创建，集群的类型就不能更改。以下是可以使用 GKE 创建的集群类型:

• 单区集群:

  单区域集群使用单个主节点，也称为控制面板，在单个区域中运行，并管理在同一区域中运行的节点上的工作负载。根据托管应用工作负载的可用性和弹性要求，在设置 GKE 集群时可以利用以下任一选项。

• 多区域集群:

  多区域群集使用在单个区域中运行的控制面板的单个副本，并且具有在多个区域中运行的节点。

• 区域集群:

  在给定区域内，在多个区域和节点中运行的控制面板的多个副本也在控制面板的副本运行的每个区域上运行。

GKE 中的网络类似于虚拟化和云环境中的网络，但是因为容器是不同的部署模型，所以底层网络元素也不同。GKE 联网的目的是确保在 Pods 中运行的各种服务之间进行通信，它还应该支持与容器生态系统之外的其他服务的连接。当我们使用 GKE 部署基于微服务的应用时，我们必须在 GCP 上规划我们的网络，以确保满足所有特定于容器的要求。用户现在必须设计 GKE 网络，重点关注 pod、服务和外部接口之间的连接。

GKE 的高级软件定义网络支持通过声明性配置管理的许多功能，包括路由、IP 过滤规则、防火墙规则等。让我们从 GKE 的一些网络概念开始。

GKE 网络术语

在讨论 GKE 的网络之前，读者应该了解用于识别 Google Kubernetes 网络组件的各种术语。

网络命名空间

网络命名空间提供与底层主机网络接口隔离的逻辑网络。网络命名空间充当网络栈的副本，并为在命名空间下运行的进程提供独立环境的假象。

虚拟以太网设备

虚拟以太网设备就像是将 Pod 连接到节点的真实以太网的隧道。该隧道的两端在节点侧由 vethX 表示，在 Pod 侧由 ethX 表示，其中 X 对应于适当位置的设备数量。

布里奇斯

网桥的工作原理是第 2 层(L2)级交换，将数据从一个 Pod 传输到集群中的另一个 Pod。网桥维护转发表，其中保存了先前获取的 MAC 地址和端口的映射，并使用 MAC 地址执行 L2 传输。

Iptables

Iptables 用于处理网络和端口转发规则集。它使用内核级的“netfilter”规则来配置 Kubernetes 服务的所有路由。

服务

服务是服务于单一目的的 pod 的集合。例如，一个应用可以有一个应用和一个 DB 层，对应于后端的多个 pod。这些 pod 将被归入不同的类别，并通过服务进行通信。

这样，如果后端发生任何 Pod 更改，应用层服务仍然能够与数据库层服务对话，因为应用环境和数据库环境之间的交互点是通过服务进行的。App-Db 交互如图 4-1 所示。

图 4-1

应用-数据库交互

多维数据集代理

Kube-proxy 是 Kubernetes 中一个重要的二进制文件，它运行在集群中的每个节点上，并构成 Kubernetes 控制面板的一部分。它负责将流量从服务路由到特定的 pod。它将服务中的所有流量分流，并将其路由到正确的节点。在 Kubernetes 版本 1.2 中，kube-proxy 现在拥有对 iptables 的权限，并且可以将 netfilter 规则插入到节点名称空间中。反过来，网络过滤器将流量重定向到服务。

HTTP(S)负载均衡器

Google Cloud 的外部 HTTP(S)负载均衡器是一个全球分布式负载均衡器，用于在互联网上公开应用。它部署在全球范围内的 Google Presence Points(pop ),为用户提供低延迟的 HTTP(S)连接。任播路由用于负载均衡器 IPs，允许互联网路由确定到其最近的 Google 负载均衡器的最低成本路径。

GKE 入口部署外部 HTTP(S)负载均衡器，为作为后端的 pod 提供本地全局负载均衡。

节点端口

节点端口服务是将外部流量直接发送到您的服务的最原始的方式。顾名思义，NodePort 在所有节点(虚拟机)上打开一个特定的端口，发送到该端口的任何流量都会被转发到该服务。

GKE IP 地址分配

GKE 分配的 IP 地址类型包括:

• 节点 IP: 分配给给定节点的 IP 地址称为节点 IP。每个节点从群集的虚拟专用云(VPC)网络接收一个 IP 地址。此 IP 地址支持与群集中其他节点的通信。这个 IP 地址也被控制组件 kubelet 和 kube-proxy 用来连接到控制面板 Kubernetes API 服务器。

该节点还接收要分配给在该节点上运行的 pod 的 IP 地址池。默认情况下，GKE 为此分配一个/24 CIDR 块。

• Pod IP: 分配给给定 Pod 的 IP 地址称为 Pod IP。该 IP 地址由该 Pod 中运行的所有容器共享，它用于将这些容器连接到集群中的其他 Pod。

• 集群 IP: 分配给服务的 IP 地址称为集群 IP。该地址是从群集的 VPC 网络分配的。Kubernetes 从集群的可用服务 IP 地址池中为每个服务分配一个稳定的 IP 地址。集群 IP 在集群中是唯一的，不会改变。仅当从群集中删除服务时，才会释放 IP 地址。

当 Pod 部署在节点上时，GKE 会在节点的 Linux 内核中为 Pod 创建一个网络名称空间。网络命名空间使用虚拟网络接口(VNI)将节点的物理网络与 Pod 连接起来。这使得通信流能够从 Pod 通过主机的物理网络。这充当在同一节点上运行的 pod 的网桥，并且还被 pod 用来向节点外发送分组。

在 Pod 中运行的所有容器都使用 Pod 的网络命名空间来访问网络。所有容器都连接到同一个网络接口。

默认情况下，每个单元都可以连接到群集中的其他单元。您可以通过配置设置对其进行限制。通过使用服务 IP 而不是 POD IP 来启用对服务的访问，因为 POD 可以被 GKE 破坏和创建。服务具有稳定的 IP 地址和端口，并提供跨 pod 的负载均衡。

Pods 和服务之间的连接由运行在每个节点上的 kube-proxy 组件管理。

容器之间的通信

在这一节中，我们将介绍容器如何在 Pod 内部相互通信。初始化时，每个 Pod 都会收到一个唯一的 IP 和网络名称空间。如前所述，pod 共享相同的名称空间，并使用 localhost 相互通信。因为名称空间是共享的，所以基于配置容器的不同端口进行通信。图 4-2 中描述了一个多容器容器。

图 4-2

多容器容器

同一节点上的 pod 之间的通信

Kubernetes 中的每个 Pod 都被分配了一个 IP 地址，Pod 之间的通信就是在这个 IP 地址上进行的。集群中的每个 Pod 都有自己的名称空间，它与节点根名称空间交互，以便与其他 Pod 通信。

每个 Pod 接收一个名为 eth0 的虚拟以太网设备。此 eth0 连接到主机节点(VM)中的虚拟以太网设备。从容器到 pod 的流量通过这个虚拟连接。

当一个 Pod 启动与另一个 Pod 的通信时，它向自己的 eth0 发出请求，eth 0 通过隧道将消息发送到机器节点的虚拟以太网设备。

现在我们知道了请求如何到达根名称空间，下一个问题是数据如何从根名称空间流向另一个 Pod。这是通过网桥实现的。

网桥的工作原理与提供 L2 级交换机并使用地址解析协议(ARP)来发现 MAC 地址的原理相同。网桥将收到的消息广播给所有连接的设备，并将做出响应的设备的 MAC 地址存储在一个表中。连接过程如下:

1. 从容器生成到达 Pod eth0 的请求。

2. 该请求通过虚拟以太网设备隧道传输到相应的虚拟 vethx 接口。

3. 从那里，请求经过一个桥，该桥维护节点内所有连接的 Pod 的记录，并将请求传输到目的地 Pod。

4. 该请求会发送到与目标 Pod 建立的虚拟以太网设备。

使用桥连接命名空间如图 4-3 所示。

图 4-3

使用桥连接命名空间

不同节点上的 pod 之间的通信

在本节中，我们将使用从“同一节点上的 pod 之间的通信”一节中获得的知识来查看消息请求如何在放置在两个不同节点上的两个不同 pod 之间流动，如下面的数据包流图所示(图 4-4 )。

图 4-4

不同节点上的 pod 之间的数据包移动

在图 4-4 中，pod1 正试图与位于不同节点上的 pod4 通信。

该请求将由 pod1 中的容器生成，它将到达 pod1 的虚拟以太网 eth0，并通过隧道到达根名称空间中存在的网桥。

网桥将根据 ARP 找到相关的目的地 Pod。请求将失败，因为目标驻留在不同的节点上。

网桥最终会将数据包发送到位于虚拟机网络接口控制器(NIC)eth 0 节点上的默认网关，数据包从这里进入跨越 GKE 集群的底层 GKE 网络。这是底层节点或虚拟机所在的网络。

默认情况下，GCP 为专用 IP 网络提供反欺骗保护，但是对于 GKE 集群中的节点，反欺骗功能被禁用，通过该功能，网络中的流量可以到达与集群关联的其他节点。

在集群虚拟机部署期间，GKE 会启用以下设置:

• 每个节点虚拟机都被配置为路由器。

• 对虚拟机禁用反欺骗保护。

• 为节点中的每个虚拟机添加一个静态路由，以便数据包从节点的 NIC eth0 通过相关路由进入 GCP 云网络。数据包到达目的节点的 eth0，然后通过网桥和虚拟以太网设备将其发送到目的 pod4。

pod 与服务的通信

Kubernetes 中的服务扮演着关键的角色，因为它们在 Pods 之上提供了一个抽象层。初始化时会向服务提供一个群集 IP。

Pod 和服务之间的通信遵循不同于 Pod-Pod 通信的方法(图 4-5 )。

图 4-5

pod 和服务之间的数据包移动

信息包沿着相同的路线(如前几节所述)到达网桥。对于 Kubernetes 中的服务级事件通信，数据包在从 eth0 进入默认网关路由之前，会通过 iptables 进行过滤，其中数据包的目的地会更改为后端的相关 Pod。

因此，通过服务，Kubernetes 提供集群负载均衡，将流量路由到连接到服务后端的各种 Pods。

pod 与互联网的通信(外部世界)

在本节中，我们将讨论 pod 与外界之间的数据流，如下图所示(图 4-6 )。

图 4-6

将数据包从 pod 路由到互联网

数据分组的路径是相当相同的，直到它到达网桥，在那里 ARP 将失败，并且数据将被发送到节点的以太网端，即 veth0。如果我们按照传统的方式将数据包从节点以太网端发送到外部世界(互联网)，数据包必然会失败，因为私有云网络内的互联网网关网络地址转换(NAT)只能理解 VM 地址。

在将数据传递到节点以太网设备之前，iptables 会执行源 NAT，并将数据包源从 Pod IP 更改为节点 VM-IP，以便网络网关能够以正确的方式对其进行处理。数据将到达互联网网关，在那里将执行另一个 NAT，以将来源从 VM-IP 更改为外部 IP，因此，数据包将到达公共互联网。相同的反向路径将有助于数据包到达目的地 Pod。在每一步都将执行 IP 拆除，其中 IP 地址将被转换，并且分组源和目的地将被改变，直到到达正确的 Pod。

服务的负载均衡

为了使服务可以从网络和/或集群外部访问，并获取服务内部的数据，GKE 使用三种类型的负载均衡器来控制访问。一个服务可以同时使用多种类型的负载均衡器。

外部负载均衡器

外部负载均衡器管理来自群集外部和 VPC 环境外部的流量，并使用一般 GCP 环境转发规则将流量路由到指定节点。通过在服务定义中将服务的“类型”字段设置为负载均衡器，可以初始化外部负载均衡器。当带有负载均衡器的服务被初始化时，GCP 云控制器启动为该服务创建负载均衡器，并返回一个外部 IP 地址，该地址可被提供给外部系统，以便通过该负载均衡器与服务进行交互。

内部负载均衡器(TCP/UDP)负载均衡器

内部负载均衡器管理来自 GKE 集群外部，但来自在 GCP 建立的虚拟云环境内部的流量。

HTTP(s)负载均衡器(在第 7 层)

这是另一种类型的外部负载均衡器，它使用 GKE 的入口资源管理服务和基于 RESTful web 服务 API 的应用之间的流量。

从外部负载均衡器到服务的通信

通过互联网从 IP 通告到外部网络的流量被转发到负载均衡器，然后被发送到连接到集群的所有节点，因为它不理解容器组件和底层网络(如服务)。

节点上的 Iptables 规则将使用 kube-proxy 在集群内设置的内部负载均衡规则，将数据包分成两部分，并将其发送到正确的目的地 Pod。图 4-7 描述了数据包如何从互联网发送到服务。

图 4-7

从互联网发送到服务的数据包

内部负载均衡器

内部负载均衡器被初始化，以便在驻留在集群外部但与集群内的服务在同一 Google cloud 网络上的应用之间提供通信流。服务定义中指定的注释和类型初始化内部负载均衡器。

内部负载均衡器从群集的 VPC 子网接收 IP 地址，而不是外部 IP 地址。VPC 网络中的应用或服务可以使用此 IP 地址与群集中的服务进行通信。

初始化内部负载均衡器的语法对应于服务定义中的以下模式。

• annotations:

  • cloud.google.com/load-balancer-type: "Internal"

• type: LoadBalancer

从内部负载均衡器到服务的通信

从内部负载均衡器到服务的通信采用以下路径。

图 4-8

从外部节点发送到服务的数据包

1. 来自驻留在 Google Cloud 环境中的源/应用的流量到达负载均衡器。

2. 作为一个 GCP 负载均衡器，它不能看到底层的 Kubernetes 组件(如服务、Pods 等)。)，内部负载均衡器上的传入流量将被发送到特定节点。

3. 当流量到达给定节点时，该节点使用其 iptables NAT 表来选择一个 Pod，即使该 Pod 在不同的节点上，并将数据包发送到目的节点，如图 4-8 所示。

HTTP(S)负载均衡器

为了允许基于 REST API 的应用与集群中的服务进行交互，使用了 HTTP(S)负载均衡器。它在网络的 HTTP/HTTPS 协议范围内工作，并向服务公开来自集群外部的 HTTP/HTTPS 协议路由。

HTTP(S)负载均衡器提供一个稳定的 IP 地址，您可以使用它将请求路由到各种后端服务。

在 GKE 集群中，通过创建 Kubernetes 入口对象来创建和配置 HTTP(S)负载均衡器。入口对象必须与一个或多个服务对象相关联，每个服务对象与一组 pod 相关联。

为了让入口对象工作，Kubernetes 主节点必须为服务分配一个端口。这样，定向到群集节点端口的任何流量都将被发送到服务。

为了公开节点端口以接受流量，入口对象由 GKE 入口控制器初始化，该控制器创建 Google Cloud HTTP(S)负载均衡器，并根据初始化的入口对象中定义的内容对其进行配置，为所有其他后端服务提供稳定的 IP 地址。

从 HTTP(S)负载均衡器到服务的通信

HTTP 负载均衡器与服务之间的通信遵循与外部负载均衡器相似的路径，但略有不同，如下所述:

图 4-9

将 HTTP/HTTPS 协议流量从外部路由到服务

• 主要区别在于，入口将允许您执行基于 URL 的服务和相关 pod 路由。

• 这里，源是试图访问基于 URL 的路径的客户端 IP，例如/dryicelabs/ *。流量将到达由 GKE 入口控制器初始化的谷歌云负载均衡器。

• 根据 GCLB 上的负载共享配置，流量将从负载均衡器(源)定向到位于负载均衡器后面的一个节点(目标)端口。

• 当我们声明一个服务定义时，我们指定一个节点端口。这将在集群中的每个节点上分配一个端口，该端口将代理对服务的请求。

• 在节点 3，iptables 拦截流量，目的地更改为 Pod3，它位于一个服务中，该服务响应正确的 NodePort 请求。

• 数据包最终将遵循内部路由方法从节点 3 到达正确的 Pod3，因为 Pod4 和 Pod5 属于侦听不同端口的服务。(参见图 4-9 。)

GKE 群组的部署

在本节中，您将学习如何使用 GCP 控制台创建 GKE 集群和配置网络选项，同时设置集群。为了满足设置集群的先决条件，请执行以下步骤。

图 4-10

库页引擎

1. 导航到谷歌云控制台中的 Kubernetes 引擎页面(图 4-10 )。

图 4-11

选择一个项目

1. 创建或选择一个项目。在我们的例子中，我们将选择先前创建的“教程项目”(图 4-11 )。

图 4-12

立方引擎 tab

1. 在 GCP 控制台中，导航至左栏中的 Kubernetes 引擎选项卡(图 4-12 )。

图 4-13

创建集群选项

1. 点击集群选项卡并选择创建集群(图 4-13 )。

集群基础

图 4-14

区域选择选项

1. 在为“群集基本信息”显示的第一个选项卡中，指定群集的名称和位置类型。

   GKE 为集群提供了两种位置类型:地带和区域。

   区域:选择区域位置类型将显示组织计算引擎中可用的区域列表(图 4-14 )。

   在位置类型中选择一个区域会将集群的组件(主节点+节点)放在一个区域环境中。

区域:区域位置类型表示集群组件将跨越多区域环境(默认情况下，区域集群创建三个主控制器，跨越三个不同的区域)。如果选中，区域位置类型将显示所有可用区域的位置(图 4-15 )。

图 4-15

区域选择选项

图 4-16

节点位置选择选项

1. 指定节点位置将节点放置在选定的位置类型中。

   通过选择多个区域可以提高可用性(图 4-16 )。

图 4-17

主版本选择选项

1. 选择群集的主版本。在主版本选择框中有两个选项:发布通道和静态版本。

   为了自动更新集群，用户可以选择发布频道。

   要手动更新集群，请选择静态版本(图 4-17 )，并在下拉框中选择适合 GKE 集群的版本。

节点池

在 GKE 中，默认情况下，将创建一个至少包含一个节点池的新群集。节点池是在该群集中创建的节点组的模板。创建群集后，可以添加和删除更多的节点池，其过程如下所述。

图 4-28

节点安全详细信息

图 4-27

网络详细信息

图 4-26

CPU 平台和 GPU 详细信息

图 4-25

机器配置详细信息

图 4-24

CPU 平台和 GPU 详细信息

图 4-23

内存优化详细信息

图 4-22

网络详细信息

• 服务账户:运行在 VM 上的应用使用服务账户调用 Google Cloud APIs。使用控制台菜单上的权限创建服务帐户，或者使用默认服务帐户(如果可用)。

• 访问范围:选择授予虚拟机的 API 访问类型和级别。默认为对存储和服务管理的只读访问权限、对云日志记录和监控的写访问权限以及对服务控制的读/写访问权限。

• 屏蔽选项:屏蔽功能包括可信的 UEFI 固件和 vTPM，并附带用于 GKE 节点的安全引导和完整性监控选项。

  • 启用完整性监控:完整性监控允许您使用云监控来监控和验证受保护节点的运行时引导完整性。

  • 启用安全启动:安全启动有助于保护您的节点免受启动级和内核级恶意软件和 rootkits 的攻击。

• 节点安全:下一个选项卡指定节点池的安全设置(图 4-28 )。

• 计算优化:如果您的工作负载需要更高的计算处理能力，请选择此选项(图 4-25 、 4-26 和 4-27 )。

• 内存优化:如果您想要内存更高的机器，请选择此选项。机器类型的选择取决于您计划在集群上运行的工作负载的类型。如果您的工作负载需要比 CPU 处理能力更高的内存，您可以选择内存优化型(图 4-23 和 4-24 )。

• 联网:(见图 4-22 。)

  • 每个节点的最大单元数:指定每个节点的最大单元数。默认值为 110。

  • 网络标签:标签代表应用于每个节点的防火墙规则。

• Machine family: We will select a general-purpose machine from the relevant tab (Figure 4-20 & Figure 4-21).

  

  图 4-21

  CPU 平台和 GPU 详细信息

  

  图 4-20

  机器配置详细信息

1. Specify the name and version of the nodes in the cluster (Figure 4-18).

   

   图 4-18

   节点池详细信息

2. 接下来的列对应于群集中的基本节点设置，即

   • 大小:集群中的节点数

   • 启用自动缩放:如果启用，该功能将动态创建或删除节点。

   • 启用自动升级:自动节点升级有助于使节点保持最新版本的 Kubernetes。

   • 启用自动修复:如果选中此设置，将监控节点，并在遇到任何错误时开始修复节点。

   • 启用激增升级:激增升级会在短时间内创建额外的节点，以减少升级造成的中断。

   • 设置:下一个选项卡对应于使用前面的节点池创建新节点时的设置。

   • Image Type: Users can select customized images from the drop-down for the created nodes (Figure 4-19).

     

     图 4-19

     映像类型下拉菜单

节点元数据

当使用现有节点池创建新节点时，将使用节点元数据设置。它包括以下设置(图 4-29 )。

图 4-29

无间隙标签

• Kubernetes 标签:这些标签应用于这个节点池中的每个 Kubernetes 节点。Kubernetes 节点标签可以在节点选择器中使用，以控制如何将工作负载调度到您的节点。

• 节点污点:这些设置将应用于该节点池中的每个 Kubernetes 节点。Kubernetes 污点可以与容忍度一起使用，以控制如何将工作负载调度到您的节点。

• GCE 实例元数据:这些项目将出现在该节点池中每个节点的计算引擎实例元数据中。

自动化

此设置为自动维护、自动扩展和自动配置设置了群集级别的标准。编辑节点池以实现自动化，例如自动扩展、自动升级和修复(图 4-30 )。

图 4-30

自动化细节

• 启用维护窗口:要指定定期维护的时间，启用维护窗口。通常，例行的 Kubernetes 引擎维护可能随时在集群上运行。

• 维护排除:为了指定不进行常规、非紧急维护的时间，最多设置三个维护排除。通常，例行的 Kubernetes 引擎维护可能随时在集群上运行。

• 启用垂直窗格自动缩放:垂直窗格自动缩放会自动分析和调整容器的 CPU 请求和内存请求。

• 启用节点自动配置:所有节点用于计算总群集资源，包括非自动扩展节点池中的节点。对所有自动扩展的节点池实施限制，包括您手动创建的节点池。

建立关系网

控制台中的网络栏将对应于 pod 中的应用如何在集群内外进行通信(图 4-31 )。

图 4-31

网络细节

第一项检查对应于环境中群集的可访问性，并提供两种选择:

• 私有集群:私有集群提供隔离节点连接互联网/外部世界的能力。私有集群中的节点没有公共 IP。

• 公共集群:公共集群中的节点将拥有与之相关联的公共 IP。

• 网络和子网:用户可以选择将托管集群的网络和子网详细信息。Kubernetes 集群所在的网络和子网决定了它能够与哪些其他计算引擎资源进行通信。

高级网络选项

图 4-32

高级网络细节

• 启用 VPC 本地流量路由(使用别名 IP):如果用户希望集群使用别名 IP 范围进行通信并将流量从一个 pod 路由到另一个 pod，则可以启用该设置，从而提供与谷歌云平台服务的更安全的本地集成(图 4-32 )。

• 自动创建二级范围:默认情况下，该设置使 Kubernetes 引擎能够管理集群使用的二级范围。

• Pod 地址范围:集群中的所有 Pod 都被分配一个该范围内的 IP 地址。输入网络范围内的一个范围。如果留空，将从网络中选取默认范围

• 每个节点的最大 Pods 数:该值用于优化将集群的 IP 地址范围划分为节点级别的子范围。

• 服务地址范围:集群服务将从这个 IP 地址范围中分配一个 IP 地址。

• 启用节点内可见性:启用节点内可见性使您的节点内 Pod 到 Pod 流量对 GCP 网络结构可见。通过此功能，您可以对节点内流量使用 VPC 流量日志记录或其他 VPC 功能。

• Enable node local DNS cache:node local DNS cache 通过在集群节点上运行 DNS 缓存代理作为 daemonSet 来提高集群 DNS 性能。此设置在 1.15 版和更高版本中可用。

• 启用 HTTP 负载均衡:需要 HTTP 负载均衡附加组件来使用带有 Kubernetes 入口的 Google 云负载均衡器。如果启用，将安装一个控制器来协调将负载均衡配置更改应用到您的 GCP 项目。

• 启用主授权网络:可以启用主授权网络来阻止不受信任的非 GCP 源 IP 通过 HTTPS 访问 Kubernetes 主服务器。

• 启用网络策略:Kubernetes 网络策略 API 允许集群管理员指定允许哪些 Pods 相互通信。

安全

默认情况下，安全性包括 IAM 处理的集群认证和 Google 管理的加密。它包括以下部件(图 4-33 )。

图 4-33

安全细节

• 启用二进制授权:二进制授权允许对部署到 Kubernetes 集群的映像进行策略控制。

• 启用屏蔽 GKE 节点:屏蔽 GKE 节点为加入集群的节点提供强加密身份。

• 启用应用层秘密加密:使用您在云 KMS 中管理的密钥保护您在 etcd 中的秘密。秘密已经在存储层加密了。

• 启用工作负载标识:这允许您从 Kubernetes 引擎工作负载安全地连接到 Google APIs。

• 启用 GKE Google Groups:GKE Google Groups 允许您将角色授予 G Suite Google Group 的所有成员。

• 启用传统授权:启用传统授权以支持现有集群或工作流的集群内权限。阻止完全的 RBAC 支持。

• 启用基本身份验证:基本身份验证允许用户使用用户名和密码向群集进行身份验证，该用户名和密码在传输时可能不保密。禁用后，您仍然可以使用客户端证书或 IAM 向集群进行身份验证。

• 发布客户端证书:客户端使用这个 base 64 编码的公共证书向集群端点进行身份验证。证书不会自动轮换。它们很难撤销。为了最大限度地提高安全性，请禁用此选项。您仍然可以使用基本身份认证(不推荐)或 IAM 向集群进行身份认证。

[计]元数据

该选项卡对应于可以添加来组织集群的数据(图 4-34 )。

图 4-34

元数据详细信息

特征

创建集群时，您可以为其添加各种功能，如监控、计量和仪表板，以维护集群(图 4-35 )。

图 4-35

功能详情

• 启用针对 Anthos 的云运行:针对 Anthos 的云运行使您能够使用云运行体验轻松地将无状态应用和功能部署到该集群。Cloud Run for Anthos 可根据请求自动管理底层资源并扩展您的应用。

• 启用 Kubernetes 引擎监控 : Kubernetes 引擎监控通过将事件、系统指标和日志汇总到一个视图中来提高可观察性。

• 启用云 TPU :这用于加速集群中的机器学习工作负载。

• Enable Kubernetes Dashboard(add-on):这是一个用于 Kubernetes 集群的 web UI。

• 启用 GKE 使用情况计量 : GKE 使用情况计量允许您查看您的集群的资源使用情况，按 Kubernetes 名称空间和标签进行分类，并将使用情况归属于有意义的实体。

• Enable Istio :这是一个服务网格，在 Kubernetes 引擎中运行的服务之间提供监控、流量控制和安全性。如果启用，Istio 组件将安装在您的集群中。

• 启用应用管理器:这是一个 GKE 控制器，用于管理应用的生命周期。

• 启用计算引擎持久磁盘 CSI 驱动程序:启用计算引擎持久磁盘 CSI 驱动程序的自动部署和管理。此功能是使用 gcePersistentDisk 树内卷插件的替代方法。

集群管理仪表板

集群管理控制面板提供了所有已创建集群的摘要列表。上面创建的集群可以从下面查看(图 4-36 )。

图 4-36

集群管理仪表板

在第五章中，我们不会删除使用前面的配置创建的集群，而是使用同一个集群来部署 sock-shop 应用。

摘要

在本章中，我们讲述了 GKE 网络的基础知识，并学习了如何根据最佳实践，使用所需的各种设置来设置 GKE 集群。在下一章中，我们将介绍 GKE 上的应用部署。

五、使用谷歌 GKE 部署容器化应用

本章向读者介绍了 Google Kubernetes 引擎(GKE)上的应用部署方法，包括以下内容:

• 介绍

• 简单的应用架构概述

• 袜子店微服务应用简介

• GKE 上的应用部署

• 删除集群

介绍

在本章中，我们将部署一个名为 sock-shop 的基于微服务架构的 web 应用。我们只是简单介绍了微服务架构及其优势，这足以帮助您理解应用的行为。

简单的应用架构概述

微服务是分布式的、松散耦合的、独立的、可部署的单元，这意味着如果任何单个服务出现故障，这不会影响其他服务。微服务通过轻量级或语言不可知的方式相互通信，例如 REST API、gRPC，或者通过排队，例如 RabbitMQ。

微服务架构的优势

微服务架构的主要优势如下:

• 简单快速的部署:与整体式应用相比，微服务通常体积较小，因此其部署要快得多，也容易得多。

• 更快的发布周期:每个微服务都是一个独立的可部署单元，这使得软件发布周期比传统应用更短，并且在部署和更新方面也支持敏捷性。

• 高可伸缩性:微服务通常是无状态的，更喜欢部署在容器上。每当对特定服务的需求增加时，增长可以很容易地扩大。

• 可访问:由于微服务通常很小，开发人员可以很容易地了解它们的功能以及如何有效地更新和增强它们，从而通过敏捷开发方法加快开发周期。

袜子店微服务应用简介

袜子商店应用是一个基于电子商务的微服务 web 应用。它是一个基于 Docker 的应用，应用的不同组件都可以被表现出来，如下架构图所示(图 5-1 )。

图 5-1

袜子商店应用架构

袜子商店应用被打包成一个 Docker 映像。它使用一个 Docker 文件，该文件包含了关于如何使用为该应用创建的基于 Kubernetes 的部署配置文件complete-demo.yaml来构建映像的指令。

Sock Shop 应用使用的与网络、持久性存储和消息队列相关的各种组件如下:

• 节点池选择:关于节点池的详细内容，请参见第 1章 4“GKE 联网”中“Google Kubernetes 引擎(GKE)简介”的相关讨论。Sock Shop 应用使用在创建 Kubernetes 集群时已经在第四章中创建的默认节点池。

• 节点选择:我们在用于在 Kubernetes 集群上部署应用的 YAML 文件的 Pod 定义中定义了节点选择。

要将窗格分配给 Kubernetes 中的节点，请使用以下命令:

• 节点选择器 : 这是通过匹配用户定义的节点标签来选择部署特定 Pod 的节点的最流行和最简单的方法。

• 节点关联:这个特性是在 Kubernetes 版本中引入的，是nodeSelector的增强版。它提供了更具表现力的语法来控制如何将 pod 部署到特定节点。

• Pod 间关联:Pod 间关联通过将 Pod 调度到已经运行特定 Pod 的节点上，而不是基于节点上的标签，来实现共存。

在我们的 Sock Shop 应用中，我们使用nodeSelector在特定的节点上部署 pod。参见下面的complete-demo.yaml文件的代码片段(图 5-2 )。

图 5-2

nodeSelector

服务

Kubernetes 中的服务是 pod 的逻辑集合/组。服务是轻量级的，所以我们可以在一个 Kubernetes 集群中拥有许多服务。每个服务都有一个选择器部分，其中包含要连接的 Pod 标签。参考下面的complete-demo.yaml文件片段，查看 Sock Shop 应用的服务定义(图 5-3 )。

图 5-3

服务选择器

以下是不同类型的 Kubernetes 服务:

图 5-4

负载均衡器前端服务类型

• NodePort: 这是每个节点上的一个静态端口，在该端口上公开了一个服务，使其可以从集群外部使用。

• ClusterIP (默认):这将在集群中的内部 IP 上公开服务，使得该服务只能从集群内部访问。

• LoadBalancer: 这会在当前的云中创建外部负载均衡器，在我们的例子中，是在 GCP 上，并为服务分配一个固定的外部 IP。

• 在我们的 Sock Shop 应用中，我们将前端服务公开为负载均衡器，并在complete-demo.yaml文件中将其定义为type:LoadBalancer。GKE 将部署一个外部网络负载均衡器，使用配置中提到的端口访问 sock shop 应用服务。

• Sock Shop 应用的其他服务在集群中作为内部服务公开，并在 GKE 集群中公开和访问(图 5-4 )。

• 持久存储数据库:以对象的形式存储持久数据。为了存储袜子商店应用的数据，我们使用 MongoDB 和 MySQL 数据库，作为 Pods 下的一个容器运行，并在 Kubernetes 集群内部公开。

• 消息队列:消息队列是一种异步的服务到服务通信，广泛应用于微服务架构中。Sock Shop 应用使用 RabbitMQ，这是一个开源的消息队列框架，作为 Pods 下的一个容器运行，也在 Kubernetes 集群内部公开。

GKE 上的应用部署

以下步骤在 GKE 集群上安装 Sock Shop 应用。

图 5-5

云壳链接

• 第一步:打开云壳。我们将使用我们在第四章第四章中创建的同一个集群“clustertutorial ”,通过使用预装了 gcloud、docker 和 kubectl 命令行工具的 Google Cloud Shell 来部署应用。

• 要打开云壳，请执行以下操作:

  • 转到谷歌云控制台。

  • 点击控制台窗口顶部的活动云壳按钮，如图 5-5 所示。

图 5-6

云外壳会话

• 云壳会话将启动，如图 5-6 所示。

图 5-10

移动代码库

图 5-9

下载代码库

图 5-8

移动到gcptutorialmail目录

图 5-7

创建gcptutorialmail目录

• 第二步:首先我们会在/home目录下创建gcptutorialmail文件夹，然后从 GitHub 克隆complete-demo.yaml文件。

• 执行以下命令在/home目录下创建gcptutorialmail。

• 命令: mkdir gcptutorialmail

• 输出:前一条命令的输出应该如图 5-7 所示。

• 第三步:通过执行以下命令移动到gcptutorialmail文件夹。

• 命令: cd /gcptutorialmail

• 输出:下面应该是前面命令的输出(图 5-8 )。

• 步骤 4: 现在，通过执行以下命令，从 Github 下载代码库。

• 命令: git clone https://github.com/dryice-devops/GCP.git

• 输出:前一条命令的结果如图 5-9 所示。

• 转到 GCP 目录，列出代码库输出，如下所示。

• 命令: cd GCP

  ll - List directory

• 输出:前一条命令的结果如图 5-10 所示。

图 5-11

连接到clustertutorial集群

• 步骤 5: 通过执行以下命令连接 GKE 集群clustertutorial。

• 命令: gcloud container clusters get-credentials clustertutorial --zone us-central1-a --project tutorial-project-268109

• 输出:前一条命令的结果如图 5-11 所示。

图 5-12

设置项目 Id

• 步骤 6: 为gcloud工具设置项目 ID。

• 命令: gcloud config set project tutorial-project-268109

• 输出:前一条命令的结果如图 5-12 所示。

图 5-13

创建名称空间

• 步骤 7: 创建一个名为 sock-shop 的名称空间，作为应用部署的占位符。

• 命令: kubectl create namespace sock-shop

• 输出:前一条命令的结果如图 5-13 所示。

图 5-14

列表命名空间

• 现在使用下面的命令检查名称空间。

• 命令: kubectl get namespace | grep sock-shop

• 输出:前一条命令的结果如图 5-14

图 5-15

列表聚类

• 现在使用下面的命令检查集群列表。

• 命令: gcloud container clusters list IP

• 输出:前一条命令的结果如图 5-15 所示。

图 5-16

获得证书

• 现在，在部署应用之前，首先需要为容器设置凭证、区域和项目。为此，请使用以下命令。

• 命令命令: gcloud container clusters get-credentials clustertutorial --zone us- central1-a --project tutorial-project-268109

• 输出:前一条命令的结果如图 5-16 所示。

• 第 8 步:部署应用。在 Kubernetes 中，pod 是最小的单位，一个应用被表示为 pod。单元也代表一个容器。部署管理应用的多个副本(称为副本),并安排它们在集群中的各个节点上运行。在我们的例子中，使用包含部署细节的complete-demo.yaml配置文件来执行部署。我们将只运行应用的一个 Pod。

complete-demo.yaml:简要说明

complete-demo.yaml文件的不同组成部分可以描述如下:

• apiVersion:定义 Kubernetes 的apiVersion，与 Kubernetes API 服务器交互。当创建一个对象时，apiVersion会根据 Kubernetes 版本的不同而不同。

• kind:定义 Kubernetes 对象的类型，如集群角色、部署、服务、pod 等。对于我们的应用，kind被定义为Deployment和Service。

• metadata:定义一个对象，如carts-db

• namespace:定义 Kubernetes 对象将创建的名称空间名称，例如 sock-shop

• replicas:复制一个 Pod

• selector:允许客户/用户识别一组对象

• template:待复制对象的定义——在其他情况下可以自己创建的对象

• containers:定义容器的特性

• Name:容器的名称

• Image:指定将使用什么 Docker 映像来创建容器。

• Ports:Docker 容器运行的端口

• env:Docker 镜像运行容器使用的变量

• securityContext:securityContext字段是一个SecurityContext对象。

为容器指定了安全设置:

• volumeMounts:这是容器中将要进行安装的路径。

• volume : 这定义了我们将要使用的卷定义。

图 5-17

部署应用的命令输出

• 步骤 9: 运行下面的命令来部署应用。

• 命令: kubectl apply –f complete-demo.yaml

• 输出:前一条命令的结果如图 5-17 所示。

在 GKE，默认情况下不能从互联网访问容器，因为它们没有外部 IP 地址。为了明确地将我们的应用暴露给来自互联网的流量，我们必须在complete-demo.yaml文件中将类型定义为LoadBalancer，如图 5-18 所示。

图 5-18

YAML 代码片段

图 5-19

列出应用部署

• 步骤 10: 通过运行以下命令来验证部署。

• 命令: kubectl get services –n sock-shop

• 输出:前一条命令的结果如图 5-19 所示。

图 5-20

部署的应用

• 步骤 10: 一旦确定了应用的外部 IP 地址，就复制该 IP 地址。将浏览器指向一个 URL(如http://35.188.192.249)，以检查您的应用是否可访问(图 5-20 )。

删除集群

现在，您已经看到了如何将应用部署到 GKE 集群上，我们可以删除应用和集群，以清理 GCP 环境，因为运行集群是有价格标签的。要执行清理活动，我们只需从 GCP 控制台删除集群，这最终也会删除应用。按照以下步骤删除集群:

图 5-21

创建列表

• 第一步:在 Kubernetes 控制台页面，点击 Kubernetes 引擎➤集群，如图 5-21 所示。

图 5-22

创建列表视图

• 第二步:集群会列出创建的集群，如图 5-22 所示。

图 5-23

创建删除

• 步骤 3: 单击集群选择，并按下行尾的删除图标。等待，因为删除集群需要一些时间(图 5-23 )。

• 如上所述，除了应用之外，还需要一些时间来删除集群和相关组件。

摘要

在本章中，您学习了如何在 GKE 集群上部署微服务应用，以及如何通过删除集群来执行清理活动。在下一章中，我们将介绍 GCP 针对 GKE 提供的安全控制。

六、GKE 安全

在本章中，您将学习保护 GKE 集群的最佳实践。将讨论以下主题:

• 谷歌云共享责任模型(GCSRM)

• 基础设施安全

• 应用开发和发布安全性

介绍

IT 安全是防止对各种资产(如应用和网络、数据以及硬件资源)进行未经授权的访问的总体策略。它还保护敏感数据，维护数据完整性，并保护组织的整个生态系统免受恶意黑客的攻击。Google Cloud 的安全性是云提供商和客户的共同责任。Google 提供了一个模型，Google Cloud Shared respons ibility Model(GCS RM ),为如何处理安全需求提供指导。

谷歌云共享责任模型(GCSRM)

GCSRM 定义了 Google 及其客户在管理各种 GCP 组件和服务的安全性方面的责任。GCSRM 取决于工作负载，从底层(即硬件)开始，覆盖从底层到应用层的所有领域。对于基础设施即服务(IaaS)层，谷歌负责提供硬件、存储和网络级别的安全性，对于软件即服务(SaaS)层，它负责除访问策略和内容之外的一切。对于 GKE 这样的平台即服务(PaaS)层，谷歌的责任介于 IaaS 和 SaaS 之间。图 6-1 显示了谷歌云的共享责任模型，并详细说明了谷歌和客户在 IaaS、PaaS 和 SaaS 方面的责任。

图 6-1

谷歌云的共享责任模式

GKE 组件属于 PaaS 类别。

以下是 GKE 的组成部分，由谷歌根据其共享责任模式进行管理(表 6-1 )。

表 6-1

Google 管理的 Kubernetes 组件

|

成分

|

描述

|
| --- | --- |
| 底层硬件\软件基础设施 | 谷歌负责硬件、固件、内核、存储、操作系统、网络等。这些组件的安全性通过数据加密、高度安全的数据中心和使用安全软件开发模式来维护。 |
| 立方分布 | Google 负责 Kubernetes 版本的补丁更新，并在共享责任模式下提供 Kubernetes 的最新上游版本。 |
| 集群节点操作系统 | 集群节点操作系统映像由 Google 管理，例如容器优化操作系统(COS)和 Ubuntu。如果用户选择自动升级选项，GKE 将代表用户执行升级。 |
| 控制面板 | 控制面板的升级和管理是谷歌的责任。这包括 Kubernetes 主虚拟机、调度程序、API 服务器、集群 CA、身份和访问管理(IAM)验证器和授权器、审计日志配置等，以及其他控制器，如复制控制器。 |

GKE 使用经过认证的 Kubernetes 版本，该版本可确保应用在本地环境和 GKE 环境之间顺利迁移，并支持客户将单个工作负载分散到多个 GKE 环境中。GKE 还负责提供 Kubernetes 版本的一致升级。

根据共享责任模型，客户的责任是管理运行工作负载的工作节点。客户还必须定义 Pod、服务和配置的部署规则，包括设置网络策略以限制 Pod 到 Pod 的流量，并定义 Pod 安全策略。客户还负责管理工作节点上部署的应用。

Google 负责开发和发布容器运行时和 Kubernetes 组件(如 kubelet 和 kube-proxy)的补丁。客户的责任是通过选择手动模式或选择自动升级选项，使用 GKE 的集群管理功能来应用这些修补程序。

worker node 自动升级选项定期向 worker node 应用更新，包括对 worker node 操作系统和 Kubernetes 组件的更新，按照最新的稳定版本。这也包括安全补丁。对于容器映像的漏洞管理，客户负责修补和加固。GKE 使用谷歌容器注册表提供了检测映像漏洞的原生功能。此外，客户还可以使用流行的第三方产品，如 Twistlock (Palo Alto)、AquaSec 和 Sysdig，来保护他们的容器映像。

基于容器的应用可能会受到错误配置和软件错误的影响。违规可能会导致对工作负载和计算资源的未经授权的访问。以下是 GCP 容器安全的分类。

• 基础设施安全

• 应用开发安全性

• 应用发布安全性

在本章中，我们将涵盖这些类别。此外，读者还将了解保护运行在 GCP 上的容器化应用、工作负载和集群的最佳实践和方法。

基础设施安全

谷歌提供了各种安全功能来保护平台。GKE 使用谷歌云的原生功能，如身份和访问管理、审计日志、应用层机密加密和工作负载身份。GCP 还利用 Kubernetes 的本地安全特性，如基于角色的访问控制(RBAC ),根据单个用户的角色来管理对网络资源的访问。

以下是 GCP 基础设施安全的类别:

• 身份和访问管理 : GKE 利用 GCP 提供的 IAM 来管理对项目级资源的访问，并使用 Kubernetes native RBAC 来管理对 Kubernetes 集群和名称空间的访问。

• 审计日志记录: GKE 捕获 Kubernetes 日志，安全管理员可以使用这些日志进行进一步分析，并针对特定的安全事件生成警报。GKE 通过云审计日志自动记录 Kubernetes 审计日志。

• 联网:为了确保点对点通信的安全，GKE 利用了网络策略。通过网络策略，用户可以控制 GKE 集群的 pod 和服务之间的通信。通过 Kubernetes 的网络策略 API，我们可以创建 Pod 级防火墙规则来控制 GKE 集群中的 Pod 和服务之间的通信。

• 此外，网络策略还有助于定义单个 GKE 集群为多个应用层提供服务的场景规则。例如，您可以创建一个网络策略来确保 web 应用中的前端服务不能与支付服务(应用层)直接通信。您还可以限制特定命名空间中的 pod 和服务访问不同命名空间中的其他 pod 或服务。

• 合规性和最低主机操作系统: GKE 支持合规性认证，包括 ISO 27001、ISO 27017、ISO 27108、HIPAA 和 PCI-DSS。客户有责任确保在 GCP 服务级别(使用控制台、gcloud shell 或 API)和应用级别实施合规性控制。

• 自动升级组件: Google 负责用最新的 Kubernetes 版本给 Kubernetes 主程序打补丁。修补/升级工作节点是用户的责任。用户可以手动应用补丁程序，也可以选择自动升级选项。在自动升级场景下，GKE 负责在操作系统层进行补丁管理。

• 加密密钥和秘密加密: GKE 支持将 GCP KMS 与 GCP 管理的密钥或客户管理的加密密钥一起用于数据加密。GCP 秘密管理器提供了存储和管理秘密的功能，如二进制 blobs 或文本字符串。GCP IAM 服务用于控制对 Secret Manager 的访问。此服务可用于保护信息，如应用所需的数据库密码、密钥或 TLS 证书。GCP 秘密管理器可用于在 GKE 集群中存储敏感数据，如密码、OAuth 令牌和 SSH 密钥。

• 集群强化:在集群安全性方面，GKE 推荐基于 CIS GKE 库本内特基准的集群强化，这是 CIS 库本内特基准的一个子集。

• 工作负载身份:容器化的应用可能使用其他 GCP 服务，例如，GCP 存储或云 SQL。为了连接这些服务，应用应该使用 GCP IAM 服务对服务进行身份验证和访问。Workload Identity 使用 Google 管理的服务帐户共享身份验证凭据，遵循应用身份验证的最小特权原则。

• 托管 SSL 证书:容器化的应用可能需要通过互联网访问，使用 HTTPS 来确保对系统的安全访问。用户可以直接从第三方供应商那里获得并管理这些证书，或者使用 Google 提供的证书，其中证书管理和更新由 Google 自己处理。

身份和访问管理

在本节中，您将了解 GCP 为保护 GKE 基础设施而提供的身份验证类型和授权选项。Google 提供了以下向 GCP 服务验证用户身份的方法:

• 谷歌登录:谷歌登录提供 Gmail 和 G Suite 账户登录 GCP 控制台。

• OAuth 2.0: GCP 支持 OAuth 2.0 协议，通过 OpenID Connect 对用户进行认证。

• Firebase 认证 : 它通过脸书、推特和谷歌账户提供用户认证。

• 用户 API: 使用 Google App Engine 内置的 Users API 服务对 Google 和 G Suite 账户进行认证。

以下是与 GKE 服务交互的渠道:

• 谷歌云平台控制台，即 web 界面

• Cloud SDK 和 Cloud Shell，它们提供了命令行界面

• 自定义应用的 REST API 接口

• Kubernetes 原生 Kubernetes 实用程序

GCP 控制台

GCP 控制台是一个基于 web 的用户界面，用于创建项目和管理 GCP 资源，例如计算资源、存储、GKE 集群等。

GCP 控制台功能

• GCP 控制台提供了一个直观的界面来管理 GCP 项目和强调服务。

• 该控制台提供了对所有 GCP 服务和 API 的轻松访问，具有特定于所有 GCP 服务和 API 的仪表板，以及对每个服务的管理资源的访问。

访问 GCP 控制台

图 6-2

谷歌云平台登录

• 第一步:要访问 GCP 控制台，请点击以下链接: https://console.cloud.google.com

• 链接会打开签到页面，如图 6-2 所示。

图 6-3

谷歌云平台密码

• 第二步:输入邮件地址，然后点击下一步按钮。

• 现在输入您的密码，点击下一步按钮，如图 6-3 所示。

图 6-4

谷歌云平台仪表板

• 成功登录后，您将看到 GCP 仪表板，从中您可以访问各种 GCP 服务，包括存储、IAM & Admin、计算引擎和 Kubernetes 引擎(图 6-4 )。

云 SDK

Cloud SDK 是 Google 为 Java、Python、GO 等流行编程语言开发的一套命令行工具。用户可以使用这些工具与存储、计算引擎、BigQuery、GKE 集群和其他 GCP 服务进行交互。拥有谷歌云账户的用户可以免费使用 Cloud SDK。

咕噜咕噜

Cloud SDK 提供了一个命令行界面，称为 gcloud shell。对于 GKE 管理，gcloud shell 可用于创建 GKE 集群，并管理 GKE 认证和 GKE 集群管理。

库布特雷

kubectl 提供了控制 Kubernetes 集群的命令。它允许部署应用、检查和管理集群资源以及查看日志。

安装云 SDK

在本节中，您将了解如何在 Red Hat 和 CentOS 中安装 Cloud SDK。Google 云计算实例已经捆绑了 Cloud SDK。如果您正在使用 Google Compute Instance，可以跳过以下步骤。

先决条件:

图 6-5

谷歌云平台创建项目

• 登录您的 Google 帐户。

• 应该为您的谷歌云项目启用计费。

• 导航到项目选择器页面，选择现有项目，或者创建一个新项目，如图 6-5 所示。

采取以下步骤在您的 Red Hat Enterprise Linux (RHEL)机器上安装 Cloud SDK(适用于不基于 GCP 的虚拟机)。

• 步骤 1: 通过执行以下代码，使用云 SDK 存储库更新yum配置。

图 6-7

gcloud init认证 URL

图 6-6

gcloud init命令的结果

• 第二步:执行以下命令安装 Cloud SDK。

• 命令: yum install google-cloud-sdk

• 步骤 3: 执行以下命令触发认证过程。

• 命令: gcloud init

• 执行前面的命令后，将显示图 6-6 所示的结果。

sudo tee -a /etc/yum.repos.d/google-cloud-sdk.repo << EOM
[google-cloud-sdk]
name=Google Cloud SDK
baseurl=https://packages.cloud.google.com/yum/repos/cloud-sdk-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg
       https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOM

• 复制身份验证 URL 并将其粘贴到您的浏览器中。浏览器页面将显示验证码。将验证码粘贴回终端，如图 6-7 所示。

• 第四步:在浏览器窗口，审核应用权限，点击接受，输入验证码后在命令行复制粘贴返回的代码。否则，代码会自动发送到命令行工具。

• 步骤 5: 选择此配置的凭证。

• 设置好凭证后，gcloud 会提示输入此配置的默认项目。从列表中选择一个项目 ID。

• Kubernetes 支持两种类型的帐户。第一种类型是用户帐户，即普通用户的帐户，它不由 Kubernetes 管理，不能通过 kubectl 命令创建或删除。第二种类型是服务帐户，由 Kubernetes 创建和管理。服务帐户只能由 Kubernetes 对象使用，例如 Pods。

• 在 GKE，谷歌管理的 Kubernetes 用户账户可以是谷歌云服务账户，也可以是谷歌账户。Kubernetes 服务账户和 Google 云服务账户本质上是不同的。Kubernetes 服务帐户属于定义它们的集群，而 Google 云服务帐户是 Google Cloud 项目本身的一部分。使用云身份和访问管理，Google 云服务帐户可以轻松获得对 GKE 集群以及 Google 云资源的访问权限。与 CIS GKE 基准测试建议 6.2.1 保持一致:“不要使用计算引擎默认服务帐户运行 GKE 集群。”

• 身份验证之后，我们必须为这些身份提供授权，以便在 Kubernetes 集群上创建、更新、读取或删除操作。

• 认证和授权的最佳实践:

  • 禁用传统授权:应该使用 RBAC 和云 IAM 来定义允许用户和服务帐户在 Kubernetes 集群上执行操作的策略。为了确保 RBAC 根据最小特权模型限制权限，我们必须禁用遗留授权。以下命令可用于在创建 Kubernetes 集群时禁用遗留授权。

• 命令: gcloud container clusters create CLUSTER_NAME -no-enable-legacy-authorization

• 禁用基本认证:基本认证通过用户名和密码对用户进行认证，这些信息以未加密的纯文本形式存储时，可能会导致暴力攻击。为了防止这种情况，必须禁用基本身份验证。从 GKE 版本 1.2 及更高版本开始，默认情况下，群集的基本身份验证处于禁用状态。

• 禁用客户端证书:对于使用 GKE 版本 1.12 及更高版本创建的集群，默认情况下禁用客户端证书颁发。

云 IAM 策略

本节将描述如何创建云访问和管理策略，以允许授权用户和服务帐户与 GKE 交互。通过云 IAM 策略，我们可以限制谁可以访问我们的项目以及他们可以执行什么操作。Cloud IAM 与 Kubernetes RBAC 合作，在项目级别为用户和服务帐户提供授权，RBAC 控制对 Kubernetes 对象或名称空间级别的访问。

云 IAM 角色的类型

GCP 提供以下类型的 IAM 角色:

• 预先限定的

• 原始的

• 习俗

预定义的 GKE 角色

GKE 提供了预定义的角色，这些角色提供了对特定谷歌云资源的访问。

以下是 GKE 的预定义角色:

• roles/container.admin

• roles/container.viewer

• roles/container.hostServiceAgentUser

• roles/container.clusterAdmin

• roles/container.clusterViewer

• roles/container.developer

要查看预定义的权限，请执行以下步骤:

图 6-8

IAM & Admin

• 第一步:点击 IAM & Admin，如图 6-8 。

图 6-9

角色

• 第二步:点击角色选项，如图 6-9 所示。

图 6-10

过滤表

• 第三步:在角色页面中，点击【过滤表】，如图 6-10 所示。

图 6-11

按类型筛选表并用于

• 第四步:现在过滤角色，如下图 6-11 :

• 类型:预定义

• 用于:Kubernetes 发动机

图 6-12

库引擎管理

• 第五步:选择任意选项，如 Kubernetes 引擎管理，如图 6-12 所示。

图 6-14

原始角色

图 6-13

库引擎管理说明

• 第六步:一旦选择了 Kubernetes 引擎管理选项，你就可以在屏幕右侧的面板中看到它的描述，如图 6-13 所示。

原始角色

原始云 IAM 角色是历史角色，为用户提供对所有 Google 云资源的全局和项目级访问。作为最佳实践，使用预定义的角色来保护项目和集群。基本角色有以下几种类型(参见图 6 14):

• 查看者:该角色授予只读权限。

• 编辑:除了修改对象状态的权限外，该角色还授予读取权限。

• 所有者:该角色允许编辑权限，具有设置计费和管理角色的额外权限，以及对项目及其资源的权限。

服务帐户用户角色

服务帐户用户角色(roles/iam.serviceAccountUser)可以分配给项目中的所有服务帐户，也可以分配给特定的服务帐户级别。在服务帐户上被授予服务帐户用户角色的用户可以使用它来间接访问该服务帐户可以访问的所有资源。例如，如果一个服务帐户被授予 Kubernetes 引擎集群管理员(roles/Kubernetes Engine Cluster Admin)角色，则在该服务帐户上被授予服务帐户用户角色(roles/iam.serviceAccountUser)的用户可以作为服务帐户来启动 GKE 集群。在这个流程中，用户模拟服务帐户，使用授予的角色和权限执行任务。

现在让我们回顾一下 GKE 在 GCP 的角色。

图 6-15

IAM & Admin

• 第一步:点击 IAM &管理区，如图 6-15 。

图 6-16

角色

• 第二步:点击角色选项，如图 6-16 所示。

图 6-17

过滤表

• 第三步:在角色页面，点击过滤表，如图 6-17 。

图 6-18

过滤表服务帐户管理选项

• 第四步:现在过滤角色，选择服务账户管理，然后选择服务账户管理选项，如图 6-18 所示。

图 6-19

服务帐户管理描述

• 第五步:选择服务账户管理选项后，您会在页面右侧的面板下看到描述和权限(图 6-19 )。

服务帐户管理权限如下:

• iam.serviceAccounts.create

• iam.serviceAccounts.delete

• iam.serviceAccounts.get

• iam.serviceAccounts.getIamPolicy

• iam.serviceAccounts.list

• iam.serviceAccounts.setIamPolicy

• iam.serviceAccounts.update

• resourcemanager.projects.get

• resourcemanager.projects.list

自定义角色

如果预定义的角色不够，我们可以定义自己的自定义角色。

基于角色的访问控制

Kubernetes 的本地 RBAC 是一种基于单个用户角色来管理集群资源访问的方法。

通过 RBAC，我们可以定义允许 Kubernetes 主体(软件、Kubernetes、用户)对 Kubernetes 实体(pod、节点)执行的操作(即获取、更新、删除)。

RBAC 用于在集群级别或在 Kubernetes 名称空间内提供对 Kubernetes 资源的访问。通过 RBAC，我们还可以控制对谷歌账户、谷歌云服务账户和 Kubernetes 服务账户的访问。

GKE 遵循 CIS GKE 基准建议 5.6.1:“使用名称空间在资源之间创建管理边界。”根据最小特权原则，建议通过创建单独的名称空间或集群，给予团队有限的访问 Kubernetes 的权限。GCP 云 IAM 和 Kubernetes RBAC 合作，以促进这一点。

Kubernetes 提供以下类型的 RBAC 权限:

• 角色和集群角色:用户或用户组的一组权限。角色始终局限于单个命名空间，而 ClusterRole 是群集范围的。

• RoleBinding 和 ClusterRoleBinding: 它们分别将角色/集群角色中定义的权限授予一个用户或一组用户。RoleBindings 绑定到某个命名空间，ClusterRoleBindings 是集群全局的。

例如，在图 6-20 中，为名称空间monitoring定义了角色，并为monitoring名称空间中的所有窗格提供了只读权限(get、watch和list)。

图 6-20

不可磨灭的作用

用户和用户组分别称为主题或主题组。现在，在创建 Role/ClusterRole 之后，我们必须在 RoleBinding/ClusterRoleBinding 中将它们分配给一个主题或一组主题。

在 GKE，受试者分为以下类型(表 6-2 ):

表 6-2

GKE 主题类型

|

学科

|

值类型

|

描述

|
| --- | --- | --- |
| 久世服务帐户 | 服务帐户 | Kubernetes 服务帐户的名称 |
| 谷歌云用户帐户 | 用户 | 谷歌云的注册电子邮件地址 |
| 云 IAM 服务帐户 | 用户 | 自动生成的云 IAM 服务帐户电子邮件地址 |
| g 套件谷歌组地址(测试版)在一个验证的领域 | 组 | 本身是 gke-security-groups@customerdomain.com 谷歌集团成员的谷歌集团的电子邮件地址 |

我们已经定义了角色绑定，如图 6-21 所示，将podreader角色授予 GKE 主体。

图 6-21

古巴人的劳力士

审核日志记录

Kubernetes 集群生成 Kubernetes 审计日志，记录所有对 GKE 集群的 API 调用。安全管理员可以进一步分析这些日志，以便进行安全审计和监控。GKE 通过云审计日志和 Stackdriver(现在叫做 Google Operations)日志自动记录 Kubernetes 审计日志。作为最佳实践，Google 在创建 GKE 集群时默认启用云操作或 Stackdriver 日志记录。

操作系统日志不同于云审计日志和 Kubernetes 审计日志。为了访问 Kubernetes worker node (VM)操作系统级日志，用户可以使用 GCP 控制台启用 Linux 审计日志记录。

以下是审计日志的类型:

• 管理员活动日志:该日志包含与 API 调用和其他管理员活动相关的日志，例如修改 GKE 配置、GKE 资源元数据等。每当用户创建任何对象或更改访问管理权限时，都会在管理活动日志下记录日志。要查看管理活动日志，用户必须具有以下 Cloud IAM 角色:日志记录/日志查看器或项目/查看器。默认情况下，管理活动日志记录是启用的，不需要额外的费用。

• 数据访问日志:该日志记录了读取 GKE 资源的配置或元数据的 API 调用的日志。数据访问日志不会将在公共共享资源上执行的数据访问操作记录为日志。要查看数据访问日志，用户必须具有以下 Cloud IAM 角色:日志记录/私有日志查看器或项目/查看器。应该明确启用数据访问日志，这是由 GCP 收费的。

通过 Google Cloud 控制台查看管理活动日志

通过执行以下步骤，您可以查看管理活动日志。

图 6-22

日志查看器选项

• 步骤 1: 按照“访问 GCP 控制台”一节所述，使用您的凭据登录 GCP 控制台页面。

• 步骤 2: 导航到日志菜单中的日志查看器页面(图 6-22 )。

图 6-23

不可分的群集日志

• 步骤 3: 在页面顶部附近，找到用于选择资源类型的下拉菜单。从下拉菜单中，选择 Kubernetes 集群，然后指定位置或选择所有位置。如果选择一个位置，则选择一个特定的群。在我们的例子中，我们选择位置 us-central1-c，并选择 clustertutorial 作为特定的集群，如图 6-23 所示。

图 6-24

Kubernetes 集群，所有日志

• 第四步:选择集群后，会看到所有日志，如图 6-24 所示。

图 6-25.1

选择活动日志

• 步骤 5: 右边的下一个菜单用于选择日志。在下拉菜单中选择活动，然后点击确定，如图 6-25.1 所示。

选择“活动”后，您将看到相关的详细信息，如图 6-25.2 所示。默认情况下，显示屏会显示所有日志级别。

图 6-25.2

Kubernetes 集群，活动日志

网络安全性

以下是网络安全的最佳实践和建议。

为 Kubernetes 主机启用授权网络

GKE 遵循 CIS GKE 基准建议 6.6.2:“优先选择 VPC 本地集群”，为 Kubernetes 主设备启用授权网络。启用 GKE Kubernetes 主机的授权网络功能有助于限制允许访问 GKE 集群的 IP 地址范围。Kubernetes 引擎通过 GCP IAM 服务使用传输层安全性(TLS)和身份验证来提供从公共互联网对 Kubernetes 主端点的安全访问。

授权网络通过将外部非 GCP 网络访问限制为一组特定的网络地址(例如，您的数据中心 IP 范围)，提供了额外的安全层。

节点防火墙

节点防火墙机制有助于在基于计算引擎实例的 GKE 节点之间实施状态防火墙规则。防火墙规则限制或允许网络流量。通过使用网络中的标记将防火墙规则应用于实例。标记网络是应用防火墙规则和路由到特定虚拟机实例的一种有用方法。在多个 VPC 网络中，标签不必是唯一的。用户可以在创建计算实例时创建网络标记，并在以后进行编辑。

以下步骤将在现有计算实例中添加一个标记:

图 6-26

虚拟机实例页面

• 步骤 1: 如本章前面所述，登录谷歌控制台。

• 第二步:导航到虚拟机实例页面，如图 6-26 所示。

图 6-27

选择虚拟机实例

• 第三步:选择一个实例，如图 6-27 所示。

图 6-28

编辑虚拟机实例

• 第四步:在虚拟机实例详细信息页面，点击编辑选项，如图 6-28 所示。

图 6-29

虚拟机实例网络标记

• 步骤 5: 在网络标签部分，指定一个或多个标签，例如 allow-traffic-9000(图 6-29 )。

图 6-30

虚拟机实例网络标记—保存

• 第六步:最后点击保存(图 6-30 )。

在 GKE，每个节点池都有自己的标签集，可用于管理防火墙规则。默认情况下，节点池的每个计算实例都有一个标记，用于标识特定的 Kubernetes 引擎集群(它属于哪个节点池)。该标签用于 Kubernetes 引擎自动创建的防火墙规则中。用户可以在创建集群或节点池时使用 gcloud 命令行中的- tags 标志创建自定义标记，如下所示。

在命令 1 中，我们创建了一个名为allow-9000-fwr 、的防火墙规则，通过在所有带有allow-9000标签的节点上指定一个 —allow 标志，允许内部负载均衡器访问端口 9000。

命令 2 应用这个防火墙规则，同时创建一个 Kubernetes 集群clustertutorial，它在- --tag标志中有一个定制的allow-9000标记，如下所示。

• 命令 1 :

• gcloud compute firewall-rules create allow-9000-fwr --target-tags allow-9000 --allow tcp:9000 \

  --network gke --source-range 130.211.0.0/22

• 命令 2:

• gcloud container clusters create clusterturorial --tags allow-9000

启用 Pods 安全通信的网络策略

GKE 遵循 CIS GKE 基准建议 6.6.7:“确保启用网络策略并进行适当设置。”默认情况下，Kubernetes 集群中的所有 pod 都可以相互通信。用户可以通过网络策略控制点对点通信。

网络策略是一种规范，规定了允许多组 pod 如何相互通信以及如何与其他网络端点通信。群集中的 Pod 使用分配给它们的 IP 地址(也称为 Pod IP 地址)通过网络进行连接。群集管理员可以通过使用网络策略来限制点对点通信。

网络策略资源使用标签来识别和选择特定的 pod，并定义规则来定义允许哪些流量进入所选的 pod。

一旦网络策略附加到 GKE 集群中用于选择特定 pod 的命名空间，它将根据网络策略接受或拒绝任何连接。

我们可以通过使用 Kubernetes NetworkPolicy API 创建 Pod 级防火墙规则来定义网络策略。这些防火墙规则决定哪些 pod 和服务可以在 GKE 集群内相互访问。

在 GKE，我们可以在创建 Kubernetes 集群时或之后启用网络策略实施。

GKE 提供了以下方式来启用网络策略实施:

• 通过gcloud工具

• 通过控制台

• 按 API

在本章中，我们将介绍两种启用网络策略实施的方法(gcloud和控制台)。

通过 gcloud 命令启用网络策略实施

通过使用–enable-network-policy标志，执行以下命令，在创建新集群时启用网络策略实施。从 Cloud SDK 运行以下命令。

• 命令:

• gcloud container clusters create cluster-name --enable-network-policy

要为现有群集启用网络策略强制，请执行以下命令。

• 命令:运行下面的gcloud命令，使用标志--update-addons=NetworkPolicy=ENABLED启用插件。

• gcloud container clusters update cluster-name --update-addons=NetworkPolicy=ENABLED

执行以下gcloud命令，在现有集群上启用网络策略强制，这反过来会重新创建集群的节点池，并启用网络策略强制。

• 命令:

• gcloud container clusters update cluster-name --enable-network-policy

通过 Google 控制台启用网络策略

图 6-31

GKE 集群

• 第一步:导航到云控制台中的 Google Kubernetes 引擎菜单，如图 6-31 所示。

图 6-32

GKE 创建分类按钮

• 第二步:点击创建集群按钮(图 6-32 )。

图 6-33

GKE 集群网络选项

• 步骤 3: 按照前面章节的说明配置集群。

• 步骤 4: 在导航窗格的集群下，点击联网(图 6-33 )。

图 6-34

GKE 群集启用网络策略选项

• 第五步:选中启用网络策略复选框(图 6-34 )。

图 6-35

GKE 集群创建选项

• 第六步:点击创建按钮，如图 6-35 所示。

通过 Google 控制台启用现有集群的网络策略实施

图 6-36

GKE 聚类编辑

• 步骤 1: 导航到云控制台中的 Google Kubernetes 引擎菜单，如前面的“通过 Google 控制台启用网络策略”一节所示。

• 步骤 2: 点击要实施网络策略的集群，点击铅笔图标旁边的编辑(图 6-36 )。

图 6-37

GKE 集群编辑下拉菜单启用选项

• 步骤 3: 从主设备的网络策略下拉菜单中选择启用(图 6-37 )。

图 6-38

GKE 集群编辑-保存

• 第四步:点击保存，集群更新后再次点击编辑(图 6-38 )。

图 6-39

启用节点的 GKE 群集网络策略下拉选项

• 步骤 5: 从节点的网络策略下拉菜单中选择启用(图 6-39 )。

• 第六步:点击保存，如图 6-38 ，第四步。

创建网络策略

为集群启用网络策略实施后，我们必须使用 Kubernetes NetworkPolicy API 定义实际的网络策略。

图 6-40 是一个在 Kubernetes 中通过 YAML 定义网络策略的例子。

图 6-40

YAML 网络策略

以下是定义网络策略的必填字段:

• apiVersion

• kind

• metadata

• spec

本书前面的章节已经解释了apiVersion、kind和metadata字段。

spec字段包含所有那些定义给定名称空间内的网络限制的设置。

podSelector选择策略适用的一组 pod。

在这个示例策略中，选择标签为role= database的 pod。如果您没有在podSelector中指定一个值，它会考虑在metadata部分下定义的指定名称空间中的所有窗格。

policyTypes定义要限制的流量类型(入站为ingress，出站为egress，或两者都有)。如果我们不指定任何策略类型，入口将始终由default设置，如果网络策略有任何出口规则，将设置egress。

ingress包括入站流量白名单规则。

此示例策略包含一个规则，该规则匹配来自以下三个来源之一的单个端口上的流量:

• ipBlock

• namespaceSelector

• podSelector

ingress允许连接到 TCP 端口 6379 上标签为role=database的default名称空间中的所有 Pod，从标签为role=frontend的default名称空间中的任何 Pod，以及从标签为project= demoproject的名称空间中的任何 Pod。

允许访问的 IP 地址在 172 . 17 . 0 . 0–172 . 17 . 0 . 255 和 172 . 17 . 2 . 0–172 . 17 . 255 . 255 范围内(即所有 172.17.0.0/16，除了 172.17.1.0/24)，如图 6-40.1 所示。

图 6-40.1

与ingress YAML 的网络策略

egress包括出站流量白名单规则。

在本例中，egress允许从标签为role=database的default名称空间中的任何 Pod 连接到 TCP 端口 5978 上的 CIDR 10.0.0.0/24，如图 6-40.2 所示。

图 6-41

loadBalancerSourceRanges

图 6-40.2

与egress YAML 的网络策略

通过负载均衡器过滤流量

GCP 提供各种类型的负载均衡器来过滤传入的流量。例如，基于 HTTP/HTTPS 的负载均衡器将终止未授权的请求，并执行上下文感知的负载均衡决策。当我们将 Kubernetes 服务类型定义为负载均衡器时，GCP 将创建一个外部网络负载均衡器，并将其与该 Kubernetes 服务连接。Kubernetes 服务与各种 pod 连接，使用它们的标签来传递请求。通过 kube-proxy，我们可以在节点级别过滤请求。您需要通过在服务中定义loadBalancerSourceRanges配置来提供 CIDR 范围，以便将 IP 地址范围列入白名单，从而获得对服务的访问。

在以下示例中，将创建一个负载均衡器，该负载均衡器只能由 IP 地址来自 130.210.207.1 和 130.210.207.2 的客户端访问，如图 6-41 所示。

在 GKE 创建一个私人 Kubernetes 集群

私有集群的 Kubernetes 节点不能从公共互联网访问。在此环境中运行的工作负载(pod 和控制器)也与公共互联网隔离。Kubernetes master 和它的节点使用 VPC 对等技术私下相互通信。私有的 Kubernetes 集群网络提供了最大的安全性，因为服务不暴露于公共互联网。

合规性和最低主机操作系统

法规遵从性由根据相关行业或机构(如医疗保健、金融、政府等)定义的一组规则、策略、规范或法律组成。GCP 产品定期接受安全性、隐私和合规性控制的独立验证、认证、合规性验证或针对标准的审计报告。

GCP 按地区提供法规遵从性，如 EMEA、美国、亚太地区，按行业或机构提供法规遵从性。

GCP 合规产品甚至超越了报告和认证。他们还向用户提供文档、指南和法律保证，以符合法律、法规和框架。Google Kubernetes 引擎合规认证包括 ISO 27001、ISO 27017、ISO 27108、HIPAA 和 PCI-DSS。

默认情况下，GKE 使用 COS 映像来配置 GKE 节点，并且它已经预装了 Docker 运行时和 cloud-init，从而确保安全快速地部署 GKE 节点。它是一个开源项目，由谷歌在 Chromium OS 下维护。Google 实现了几个安全设计原则来构建 COS。

启用 COS 提供了以下安全优势:

• 更小的攻击面: COS 占用空间更小，减少了实例的潜在攻击面。

• 锁定: COS 实例默认包含锁定的防火墙和其他安全设置。

• 内核加固: COS 为内核启用了许多安全加固特性，比如审计、内核页表隔离、IMA 等。，以实施安全策略。

• 自动更新: COS 实例配置为自动下载每周更新作为后台。要使用最新的更新，需要重新启动。

• 访问限制:默认情况下，COS 不包含任何可访问的用户帐户。它通过实例或项目元数据管理用户帐户和 SSH 密钥。从 milestone 66 及更高版本开始，它还支持通过 IAM 进行访问。禁用基于密码的登录，并且不允许 root 登录。

自动升级组件

CIS GKE 基准 6.5.3 建议用户“确保为 GKE 节点启用节点自动升级”节点自动升级使 Kubernetes 集群的节点和节点池保持最新和最稳定的 Kubernetes 版本。它还确保了新的操作系统的二进制文件，节点是固定的，并且安全问题是在没有人工干预的情况下解决的。

通过云控制台实现自动升级

要启用节点池的自动升级，请执行以下步骤:

图 6-42

启用自动升级—Kubernetes 引擎菜单

• 第一步:导航到云控制台中的 Google Kubernetes 引擎菜单，如图 6-42 所示。

图 6-43

启用自动升级

• 第二步:选择集群选项，如图 6-43 所示。

图 6-44

启用自动升级—编辑按钮

• 第三步:选择你的集群，点击集群编辑按钮(铅笔图标)，如图 6-44 所示。

图 6-45

启用自动升级—节点池

• 第四步:在节点池部分，点击相关节点池，如图 6-45 所示。

图 6-46

启用自动升级—编辑选项

• 第五步:点击编辑选项，如图 6-46 所示。

图 6-47

启用自动升级—管理

• 第六步:导航到管理区，如图 6-47 。

图 6-48

启用自动升级选项

• 第七步:选择启用自动升级选项，如图 6-48 所示。

图 6-49

启用自动升级—保存按钮

• 第八步:点击保存按钮(图 6-49 )。

图 6-50

启用自动升级选项

• 第九步:保存更改后，在节点池详细信息表单的管理部分，您会看到自动升级选项已经启用，如图 6-50 所示。

当我们使用gcloud命令创建集群时，默认情况下，节点自动升级当前处于启用状态，并且在默认情况下，节点池自动升级也处于启用状态。

启用自动节点修复

节点自动修复特性使 Kubernetes 集群中的节点保持健康和正常运行。启用自动节点修复功能有助于 GKE 定期执行群集节点的运行状况检查，并在连续运行状况检查失败时启动修复过程。

您可以通过执行gcloud命令或通过云控制台来启用自动节点修复选项。

通过 gcloud 启用自动节点修复

执行以下命令创建一个启用了autorepair的集群。

• 命令:

• gcloud container clusters create cluster-name --zone compute-zone --enable-autorepair

前面的命令在cluster-name变量中传递集群名称，在compute-zone变量中传递要创建集群的区域名称。

通过云控制台启用自动节点修复

要通过云控制台启用自动节点修复，请执行“通过云控制台启用自动升级”一节中的相同步骤，直到步骤 5，然后，对于其他更改，请执行以下步骤:

图 6-51

启用自动修复—管理

• 第一步:进入管理版块，如图 6-51 。

图 6-52

启用自动修复—保存按钮

• 第二步:点击保存按钮(图 6-52 )。

图 6-53

启用自动修复—节点池详细信息

• 第三步:保存更改后，在节点池详细信息表单的管理部分，您将会看到自动修复选项已经启用，如图 6-53 所示。

加密密钥和秘密加密

默认情况下，GKE 数据是加密的。这包括连接到 GKE 节点的磁盘和存储在控制面板数据库中的 Kubernetes secrets 对象。

GCP 还提供了两个功能，客户管理的加密密钥(CMEK)和 GKE 应用，让用户能够保护和控制 GKE 环境的加密。

工作负载身份

工作负载是定义规则的对象，根据这些规则在 Kubernetes 集群中部署 pod。在本节中，您将看到保护工作负载的最佳实践。

定义 pod 的权限和访问控制

为了集群的整体安全性，我们必须通过限制它们的特权来保护容器和容器，使得特定的容器/容器不能影响在同一集群中运行的其他容器/容器。在 GKE，通过安全性，我们可以在 Kubernetes 中定义 pod、容器和文件系统的特权和权限。

GCP 提供了三种方式来授权 Pods 访问其他谷歌云资源。

• 工作负载身份

• 节点服务帐户

• 服务帐户 JSON 密钥

CIS GKE 基准建议 6.2.2 建议使用专用的 Google 云服务帐户和工作负载身份。有关该基准的更多信息，请通过以下链接访问相关站点: https://cloud.google.com/kubernetes-engine/docs/how-to/hardening-your-cluster 。

为了以安全的方式从 GKE 集群内部访问谷歌云服务，GCP 建议使用工作负载身份特性。工作负载身份支持将 Google 服务帐户映射到 Kubernetes Pod，这有助于消除在 Pod 或集群中管理服务帐户凭证 JSON 文件的潜在过载。现在，让我们按照步骤创建一个工作负载身份，它将 Google 服务帐户与 GKE 服务帐户连接起来。

图 6-55

gcloud config set ProjectID命令

图 6-54

激活云壳图标

• 步骤 1: 通过以下链接访问网站，启用 Google Kubernetes 引擎 API:https://console.cloud.google.com/apis/library/container.googleapis.com。

• 第二步:点击谷歌云控制台最右上角的激活云壳图标，如图 6-54 所示。

• 第三步:云壳打开后，执行gcloud config命令，设置项目 ID。

• 命令:

• gcloud config set project tutorial-project-268109

在我们的例子中，tutorial-project-268109是我们的项目 ID(图 6-55)。

• 步骤 4: 执行以下命令，设置区域(参见图 6-56)。

• 命令:

• gcloud config set compute/zone us-central1-c

• 第五步:执行以下命令，对区域进行设置(图 6-57)。

• 命令:

• gcloud config set compute/region us-central1

• 第六步:点击以下链接，启用云 IAM 服务账户凭证 API:https://console.cloud.google.com/apis/api/iamcredentials.googleapis.com/。

• 步骤 7: 通过执行以下命令，创建一个启用了工作负载标识的集群。

• 命令:

• gcloud beta container clusters create cluster-name --release-channel regular \ --workload-pool=project-id.svc.id.goog

• 分别用集群名和项目 ID 替换cluster-name和project-id。

• 我们的集群名是clustertutorial，而tutorial-project-268109是我们的项目 ID。

• gcloud beta 容器集群创建clustertutorial --release-channel regular \

• --workload-pool=tutorial-project-268109.svc.id.goog

前述内容如图 6-58 所示。

图 6-56

gcloud config set compute/zone命令

图 6-68

CI/CD 中的应用开发和发布安全控制

图 6-67

验证活动服务帐户

图 6-66

验证服务帐户

图 6-65

向 Kubernetes 服务帐户添加iam.gke.io/gcp-service-account注释

图 6-64

链接 Google 和 Kubernetes 服务帐户的命令输出

图 6-63

Kubernetes 服务帐户创建的输出

图 6-62

创建名称空间以使用 Kubernetes 服务帐户

图 6-61

创建 Google 服务帐户

图 6-60

配置 kubectl

图 6-59

创建的集群

图 6-58

创建具有工作负荷标识的集群

图 6-57

gcloud config set compute/region命令

• 创建群集需要几分钟时间。等到您收到图 6-59 中突出显示的详细信息。

• 步骤 8: 执行以下命令，配置 kubectl 与集群通信(图 6-60 )。

• 命令:

• gcloud container clusters get-credentials clustertutorial

• 步骤 9: 通过执行以下命令创建 Google 服务账户(图 6-61 )。

• 命令:

• gcloud iam service-accounts create workload-service-account-name

• 步骤 10: 通过执行下面的命令，创建用于 Kubernetes 服务帐户的名称空间k8s-service-account-namespace(图 6-62 )。

• 命令:

• kubectl create namespace k8s-service-account-namespace

• 步骤 11: 通过执行以下命令创建 Kubernetes 服务帐户(k8s-service-account-name)(图 6-63 )。

• 命令:

• kubectl create serviceaccount --namespace k8s-service-account-namespace k8s-service-account-name

• k8s-service-account-namespace是在步骤 10 中创建的 Kubernetes 名称空间。

• k8s-service-account-name是 Kubernetes 服务帐户名称。

• 步骤 12: 执行以下命令，通过在两个帐户之间创建云 IAM 策略绑定，允许 Kubernetes 服务帐户映射到 Google 服务帐户。

• 命令:

• gcloud iam service-accounts add-iam-policy-binding \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount: 教程-项目-268109.svc.id.goog[k8s-服务-账户-名称空间/k8s-服务-账户-名称 ]" \ 工作负载-服务-账户-名称 @tutorial-project-268109.iam.gserviceaccount.com

• tutorial-project-268109是项目 ID。

• k8s-service-account-namespace是 Kubernetes 名称空间。

• k8s-service-account-name是 Kubernetes 服务账户。

• workload-service-account-name是 Google 服务帐户的名称。

图 6-64 显示了链接 Google 和 Kubernetes 服务帐户的命令输出。

• 步骤 13: 使用 Google 服务帐户的电子邮件地址，通过执行以下命令，将iam.gke.io/gcp-service-account= gsa-name@project-id注释添加到 Kubernetes 服务帐户中(图 6-65 )。

• 命令:

• kubectl annotate serviceaccount \ --namespace k8s-service-account-namespace \ k8s-service-account-name \iam . gke . io/GCP-service-account = workload-service-account-name @ projectid . iam . gserviceaccount . com

• 步骤 14: 通过执行以下命令，验证服务账户配置正确(图 6-66 )。

• 命令:

• kubectl run -it \--generator=run-pod/v1 \--image google/cloud-sdk:slim \--serviceaccount k8s-service-account-name \ --namespace k8s-service-account-namespace \workload-identity-test

• 下载cloud-sdk映像可能需要几分钟时间。下载完成后，交互式 shell 会自动启动。执行以下命令，验证活动的服务帐户。

• 命令:

• gcloud auth list

• 如果服务帐户配置正确，Google 服务帐户电子邮件地址将被列为活动(且唯一)身份(图 6-67 )。

托管 SSL 证书

Kubernetes 提供入口对象，将基于 HTTPS 的流量路由到运行在 GKE 集群中的应用。GKE 入口控制器创建 Google Cloud HTTP(S)负载均衡器，它可以是外部的，也可以是内部的，这取决于 Kubernetes 服务的配置。为了在负载均衡器和 Kubernetes 服务之间建立安全连接，GKE 推荐使用带有 SSL 证书的 HTTPS 负载均衡器。

GCP 支持以下类型的 SSL 证书。

• 自管理证书:自管理证书是指客户可以从任何证书颁发机构获得的证书。管理和更新自我管理的证书是客户的责任。

• Google 托管证书 : Google 托管 SSL 证书由 Google Cloud 为客户获取和管理，并自动更新。Google 管理的 SSL 证书基于客户特定的域。在写这本书的时候，所有 GKE 版本都有测试版。

应用开发和发布安全性

应用开发和发布安全大致分为三个主要阶段:

• 发展阶段

• 构建阶段

• 部署阶段

图 6-68 显示了在 GKE 的容器化应用开发和发布生命周期中执行的安全活动。

发展阶段

在开发阶段，开发人员根据业务需求开发应用代码。容器化应用的典型代码包括应用代码、单元测试代码、Docker 文件、构建基础设施的基础设施代码、测试脚本和 DevSecOps 的流水线。开发人员依靠集成开发环境(IDE)来开发源代码。IDE 提供了一个沙盒环境来开发和测试代码。一旦代码被开发出来，它就会被签入源代码管理系统。

源代码管理系统维护签入代码的版本，并用于合并和跟踪开发人员所做的代码更改。表 6-3 列出了开发阶段可用的安全控制。

表 6-3

开发阶段安全控制

|

开发阶段安全控制

|

工具/活动

|

利益

|
| --- | --- | --- |
| 集成开发环境(IDE)安全性插件 | Synk，CodeDX，Whitesource，Fortify，Sonarlint，binskim | 使用这些工具，当开发人员编写代码时，应用代码被并行扫描和分析。除了补救方法之外，开发人员还可以在 IDE 中获得关于代码缺陷的通知或建议，这有助于他们提高编码技能和代码质量。这种做法被称为左移测试。 |
| 源代码存储库安全性插件 | Gitrob，gitleaks，Google 云资源仓库 | 使用令牌或私钥与外部服务通信的应用。作为最佳实践，令牌和秘密不应该保存在源代码管理系统中。秘密和令牌应该保存在秘密保险库中，例如哈希公司的保险库或 GCP 提供的云 KMS 服务。GCP 为云资源仓库提供了内置的安全特性，以检测安全密钥，并在违反策略的情况下禁止 git 推送操作。 |

构建阶段

一旦代码被检入 SCM，通过 web hook REST API 调用 CI/CD 流水线，手工或自动触发构建阶段。在构建阶段，第一步是执行开源合规性和许可证扫描，以确定开发人员使用的开源库中的任何安全漏洞。一旦完成，按照构建工具，例如 Maven，编译代码，并执行单元测试用例。如果在构建阶段没有出现错误，静态代码分析将被启动，以发现安全漏洞，例如，使用损坏的或有风险的加密算法，应用代码中的 SQL 注入使应用容易受到攻击。检测此类漏洞的流行工具包括 SonarQube、Veracode 和 Appscan。

构建阶段的最后一步是创建称为工件的可部署单元，并存储在像 Artifactory 这样的存储库中。如果构建由于任何原因(例如，代码编译问题或单元测试失败)而失败，构建过程将停止，并向团队发送通知以纠正问题。表 6-4 列出了构建阶段可用的安全控制。

表 6-4

构建阶段安全控制

|

构建阶段安全控制

|

工具/活动

|

利益

|
| --- | --- | --- |
| 开源合规和许可 | 黑鸭白源 | 这些工具有助于识别开发人员使用的开源库中的任何安全漏洞，并确保开发人员不违反任何开源许可。 |
| 静态代码分析(SAST) | SonarQube，Veracode，Checkmarx | 静态代码分析工具根据 OWSAP 或 CVS 定义的安全规则扫描源代码和二进制文件，以检测安全漏洞，例如，使用损坏的或有风险的加密算法、SQL 注入等。，并提供解决这些问题的建议。 |
| 工件安全扫描 | 工件库工具，如 JFrog Artifactory、Nexus | 工件存储库用于存储受版本控制的二进制文件，授权用户可以基于角色进行访问。通过减少对外部存储库的依赖，这提供了改进的构建稳定性。还对存储的工件进行审计。JFrog 提供 x 射线。它扫描所有存储的工件和依赖项。这提供了前所未有的可见性，使 Xray 能够确定工件中发现的任何漏洞或问题的影响。 |

开发和发布阶段

开发和发布是最后的阶段，其中工件被部署在各种环境中，例如，开发、测试和生产。构建工件的提升取决于通过测试(功能、性能、负载和压力)和安全扫描(例如 Docker 映像和容器扫描、动态应用安全)等因素。此外，启用了安全监控，以促进安全事件检测和管理。报告和仪表板用于显示来自多个工具的集合指标，为软件开发团队创建一个监控界面。

表 6-5 列出了部署和发布中使用的安全控制。

表 6-5

部署和发布阶段安全控制

|

部署和发布阶段

|

工具/活动

|

利益

|
| --- | --- | --- |
| 容器映像安全工具 | AquaSec，TwistLock，Sysdig 安全。GCP 提供容器分析来扫描容器中的漏洞。 | 这些解决方案简化了容器强化过程，并提供了漏洞报告和建议。 |
| 容器强制策略 | 黑鸭，白源 | 这些有助于识别开发人员使用的开源库中的任何安全漏洞，并确保开发人员不违反任何开源许可。 |
| 动态应用安全测试(DAST) | Appscan，OWSAP ZAP，Fortify | DAST 分析工具试图通过 SQL 注入、跨站脚本等方式破解应用。DAST 在软件开发生命周期的早期识别漏洞。 |
| 监控、仪表板和报告 | Stackdriver(现谷歌运营)、GCP 安全指挥中心、Sysdig、Prometheus、Splunk、Kibana、Grafana、GCP 数据工作室 | 这些解决方案通过提供监控和仪表板简化了容器化应用的操作，并帮助操作团队定期维护 GKE 基础设施和部署的应用。 |
| 持续合规性和运行时安全性 | AppArmor、Seccomp、twistlock、AquaSec、Sysdig Secure | 这些解决方案对正在运行的 Docker 容器执行安全扫描，以确定安全漏洞并保护 Linux 内核免受内核级服务攻击。 |

摘要

在本章中，您了解了 GCP 为管理 GKE 的安全性而提供的各种安全性和合规性控制。您还了解了在为 GKE 平台开发应用时，如何将安全性集成到软件开发生命周期中。在下一章中，我们将了解 Grafana 仪表板和 Stackdriver(现在的 Google Operations)工具，它们可以帮助我们监控和管理我们的 GKE 基础设施。

七、使用 Stackdriver（Google Operations）和 Grafana 的 GKE 仪表板

在本章中，您将学习如何使用 Stackdriver (Google Operations)和 Grafana 为 GKE 创建仪表板。以下是涵盖的主题:

• Google Stackdriver 介绍(云运营)

• 使用 Grafana 设置 Google stack driver(Google Operations)

Google Stackdriver 简介(Google Operations)

Google stack driver(Google Operations)是一项监控服务，为 IT 团队提供关于在 GCP 和亚马逊 Web 服务(AWS)公共云上运行的应用和虚拟机(VM)的性能数据。它基于collectd，一个收集系统和应用性能指标的开源守护程序。它包括特别关注 Kubernetes 操作符和其他 Kubernetes 特性的功能，比如 CPU 和内存利用率。可以通过其基础架构、工作负载和容器来查看集群信息。

Grafana 是一个开放的观察平台，可以作为可视化层与 Google Operations 一起使用。

在这一章中，你将学习如何使用 Helm 模板安装 Grafana。我们将使用在第五章中部署在 GKE 集群上的 Sock Shop 应用，并将 Google Operations 配置为后端，Grafana 可以使用它来创建仪表板，显示关于集群和其上运行的应用的关键可观察性细节。

使用 Grafana 设置 Google stack driver(Google Operations)

在本节中，我们将使用 Helm 图表和模板在集群中的专用名称空间(在第六章中创建)中部署 Grafana。Helm 是 Kubernetes 的开源包管理器。Grafana 内置了对 Google 操作的支持(Stackdriver)。

设置环境

图 7-2

API 仪表板导航

图 7-1

API 仪表板导航

• 第一步:使用 Google Operations 的第一步是在你的项目(“教程项目”)上启用云资源管理器 API。为此，转到 API 仪表板屏幕(图 7-1 和 7-2 )。

图 7-3

云资源管理器 API

• 第二步:搜索云资源 API，点击链接上的云资源管理器 API(图 7-3 )。

图 7-4

启用云资源管理器 API

• 点击启用按钮(图 7-4 )。

图 7-5

启用的云资源管理器驱动程序

• 第三步:点击启用按钮，会出现如图 7-5 所示的页面。现在，项目已经启用了云资源管理器驱动程序。

在 GKE 集群上部署和验证应用部署

由于我们在第六章末尾删除了已部署的应用，因此重复前面的步骤来部署 Sock Shop 应用。在本节中，我们通过运行以下命令来验证 Sock Shop 应用在 GKE 集群上的部署:

图 7-6

列出应用部署

• 命令: kubectl get services –n sock-shop

• 输出:下面的输出(图 7-6 )将是执行前面命令的结果。

图 7-7

部署的应用

• 将浏览器指向这个 URL(前面截图中的http://35.188.192.249)，检查您的应用是否可访问(图 7-7 )。

部署 Grafana

在本节中，我们使用一个 Helm 图表和模板在集群中的一个专用名称空间中部署 Grafana。Helm 是 Kubernetes 的开源包管理器。

图 7-8

Helm 初始化

• 步骤 1: 执行以下命令初始化 Helm。

• 命令: helm init

• 输出:执行前面的命令后会产生下面的输出(图 7-8 )。

图 7-9

Helm repo 更新

• 步骤 2: 执行以下命令更新本地 Helm 库。

• 命令: helm repo update

• 输出:执行前面的命令后会产生下面的输出(图 7-9 )。

图 7-10

下载 Grafana

• 第三步:执行以下命令下载 Grafana。

• 命令: helm fetch stable/grafana --untar

• 输出:图 7-10 显示了前一条命令执行后的输出。

图 7-11

在 Grafana 中创建名称空间

• 步骤 4: 通过执行以下命令，创建一个专用于 Grafana 的名称空间，该名称空间将部署在同一个集群中。

• 命令: kubectl create ns grafana

• 输出:执行前面的命令后会产生下面的输出(图 7-11 )。

图 7-12

在 Grafana 中创建名称空间

• 第五步:现在我们将使用 Helm 图表来创建.yaml文件。执行以下命令:

• 命令: (1) helm template grafana –namespace grafana grafana > grafana.yaml

• 命令: (2) ll

• 运行前面的命令列出创建的grafana.yaml文件。

• 输出:图 7-12 显示了前面第一个命令的输出。

图 7-13

Grafana .yaml文件的输出

• 图 7-13 显示了执行前面第二个命令的结果输出。

图 7-14

使用 YAML 配置部署 Grafana

• 步骤 6: 现在已经创建了.yaml文件，运行下面的命令来部署 Grafana。

• 命令: kubectl apply -f grafana.yaml -n grafana

• 输出:图 7-14 显示执行前一条命令后的输出。

图 7-15

Grafana 的 pod 列表

• 步骤 7: 部署后，使用以下命令验证安装。

• 命令: kubectl get pods -n grafana

• 输出:图 7-15 显示了前一条命令的输出。

与 Grafana 装置连接

前面的步骤将在部署 Sock Shop 应用的同一个集群中执行 Grafana 的安装。以下是用于连接 Grafana 安装的步骤。

图 7-16

Grafana 安装的密钥

• 步骤 1: 要连接 Grafana，首先使用以下命令获取密码，并复制输出。

• 命令: kubectl get secret --namespace grafana release-name-grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo

• 输出:图 7-16 显示了前一条命令的输出。

图 7-17

将 Grafana Pod 详细信息设置到变量中

• 运行该命令后，下面是生成的输出示例。(在进入下一步之前，请检查您的具体设置值。)

• MWQ7yUKCKT4uSSl2eP7eOYmEOC10I5423oxdyzU9

• 步骤 2: 要在当前会话中使用 Pod 名称，使用以下命令，将 Grafana Pod 的名称捕获为变量。

• 命令: export GRAFANA_POD=$(kubectl get pods --namespace grafana -l "app=grafana,release=grafana" -o jsonpath="{.items[0].metadata.name}")

• 输出:图 7-17 显示了前面命令的输出。

图 7-18

获取 Grafana Pod 名称

• 步骤 3: 要启用对 Grafana UI 的访问，请使用 port forwarding 命令。在运行 port forwarding 命令之前，使用第一个命令获取 Grafana Pod 名称，并将该名称复制到第二个命令中。

• 命令: (1) kubectl get pods -n grafana

• 命令: (2) kubectl port-forward release-name-grafana-6bc7fbfc47-bhgtn 3000 -n grafana

• 输出:图 7-18 显示了命名 Grafana Pod 的代码输出。

图 7-19

用于访问 Grafana 的端口转发详细信息

• 图 7-19 是端口转发的输出。它将设置 Grafana 在端口 3000 上运行。

图 7-20

访问 Grafana

• 步骤 4: 将端口更改为 3000 后，现在导航到云壳中的 web 预览，以访问 UI。导航至右上角的网络预览图标➤更改港口➤ 3000(图 7-20 )。

图 7-21

Grafana 登录页

• 步骤 5: 步骤 4 将在浏览器中显示 Grafana 仪表板。输入“admin”作为用户名，并输入您在步骤 1 中生成的特定于设置的密码(下面的密码用于作者的设置)，如图 7-21 所示。

• MWQ7yUKCKT4uSSl2eP7eOYmEOC10I5423oxdyzU9

图 7-22

Grafana 主页

• 输入用户名和密码后，将显示仪表盘，如图 7-22 所示。

数据源配置

图 7-23

添加数据源图标

• 第一步:点击添加数据源图标(图 7-23 )。

图 7-24

搜索数据源

• 第二步:在搜索文本框中输入“Stack”搜索 Stackdriver (Google Operations)数据源。这将显示包括 Stackdriver (Google Operations)数据源的列表。点击选择按钮(图 7-24 )。

图 7-25

Stackdriver (Google Operations)验证屏幕

• 第三步:选择数据源后，会出现 Stackdriver (Google Operations)认证界面(图 7-25 )。

图 7-26

上传帐户密钥文件

• 第四步:在此屏幕上传可以从服务下载的服务账号密钥文件，如图 7-26 所示。

要下载服务帐户密钥文件，请执行以下步骤。

图 7-27

服务帐户

• 步骤 1: 点击 IAM &管理菜单下的服务账户链接(图 7-27 )。

图 7-28

服务帐户屏幕

• 第二步:上一步会将用户重定向到以下屏幕，该屏幕列出了该项目中创建的所有服务帐户，如图 7-28 所示。

图 7-29

创建密钥

• 第三步:点击动作栏中的三个点，点击下拉列表中的创建关键链接，如图 7-29 所示。

图 7-30

创建私钥屏幕

• 第四步:点击创建键将显示以下画面。选择 JSON 密钥类型并点击创建按钮(图 7-30 )。

图 7-31

私钥屏幕

• 第五步:创建按钮将显示以下保存在您电脑屏幕上的私钥(图 7-31 )。

图 7-32

服务密钥文件

• 第六步:文件将被保存到电脑的下载文件夹中(图 7-32 )。

图 7-33

认证保存和测试屏幕

• 从图 7-26 所示的屏幕上传该服务密钥文件。点击保存&测试按钮(图 7-33 )。

图 7-34

认证成功屏幕

• 认证成功后，将显示以下屏幕(图 7-34 )。

设置 Grafana 仪表板

以下步骤将为我们的项目设置 Grafana 仪表板。

图 7-35

Grafana 仪表板屏幕

• 第一步:点击【创建】后点击【仪表板】，如图 7-35 所示。

• 如果需要，可以从以下链接下载 Grafana 仪表板: https://grafana.com/grafana/dashboards 。

图 7-36

Grafana 仪表板新面板屏幕

• 第二步:点击仪表板，将显示以下画面。选择添加查询(图 7-36 )。

图 7-37

Grafana 新仪表板屏幕

• 步骤 3 :在新的仪表板屏幕上选择所需的服务、指标和其他设置以获取数据(图 7-37 )。

图 7-38

Grafana 仪表板查询选择屏幕

• 步骤 4: 对于我们的目的，我们选择的服务是计算，度量是 CPU 利用率(图 7-38 )。

图 7-39

与计算 CPU 利用率相关的数据

• 第五步:选择前面的选项，与计算 CPU 利用率相关的实时数据将开始出现，如图 7-39 所示。该数据可以根据需要进行定制。

图 7-40

服务和度量选择

• 步骤 6: 接下来，我们选择 Logging 作为服务，Log bytes 摄取作为度量(图 7-40 )。

图 7-41

日志相关数据

• 第七步:选择我们的选项后，与我们的日志相关的实时数据将开始出现(图 7-41 )。这可以根据需要进行定制。

摘要

在本章中，我们学习了如何设置 Grafana 和使用 Grafana 仪表板来显示 Google stack driver(Google Operations)指标。在下一章中，我们将学习使用 Sysdig 进行 GKE 监控。

八、使用 Sysdig 监控 GKE

本章为读者提供了使用 Sysdig 监控容器应用的实际操作步骤，包括以下主题:

• Sysdig 监控解决方案简介

• 容器应用监控

Sysdig 监控解决方案简介

Sysdig Monitor 是一个强大的容器监控解决方案，它提供了全面的可观察性，还通过性能和容量监控提供了额外的安全性和合规性能力(使用 Sysdig Secure)。它具有提供容器可见性和与众多平台集成的现成能力，包括 Kubernetes、Docker container、谷歌 GKE、AWS EKS 和 Azure AKS。

它以软件即服务(SaaS)和内部部署软件的形式提供。

以下是 Sysdig 监视器的主要特性:

图 8-1

Sysdig 功能架构

• 简化发现和指标收集 : Sysdig 提供动态发现应用、容器、主机、网络和自定义指标的能力，例如 Prometheus、JMX 和 statsD，以便深入了解复杂的环境。

• 可视化服务可靠性 : Sysdig 提供服务性能、容量和安全风险概况的综合概述，以帮助开发人员和开发运维团队快速发现应用问题并采取行动。

• 监控基础设施和应用:利用 it 与 Kubernetes、OpenShift、Docker、Mesos、DC/OS、AWS、Google、IBM、Azure 等全面集成的能力。，Sysdig 提供基础设施之外的可见性，让您了解应用和服务的运行情况。

• 控制面板 : Sysdig 提供现成的可定制控制面板，使您能够一目了然地了解您的基础架构、应用、合规性和指标，并让您以自己想要的方式可视化您的环境。

• 主动警报以实现更快的响应 : Sysdig 提供可配置的警报，以实现对任何情况的主动通知，包括事件、停机和异常，以帮助您在问题影响运营之前对其进行处理，如图 8-1 所示。

容器应用监控

Sysdig 通过订阅许多系统内核已经在处理和发布的跟踪点，从内核级获取监控指标。这种看到容器内部的能力被称为容器视觉。它使数据捕获成为一项非常轻量级的工作(通常占用 1–3%的 CPU 资源和 500M 的系统内存)。Sysdig 基于开源的同名 Linux 故障排除和取证项目(sysdig)。开源项目允许您查看单个主机上的每个系统调用，下至进程、参数、有效负载和连接。这些数据被动态地映射到容器、微服务、云和编排器，既强大又易于使用。

为了进一步丰富用于保护您的环境的数据，Sysdig 还将 Falco & Anchore 集成到平台中，该平台允许您针对容器映像和容器实施和执行漏洞管理和安全策略，如图 8-2 所示。

图 8-2

Sysdig 容器监控架构

在 Sysdig 中，事件首先由一个名为sysdig-probe的小驱动程序在内核中捕获，它利用了一个名为 tracepoints 的内核工具。

跟踪点使得安装一个“处理程序”成为可能，这个处理程序是从内核中的特定函数调用的。目前，Sysdig 为进入和退出时的系统调用以及进程调度事件注册跟踪点。sysdig-probe的处理程序仅限于将事件细节复制到一个共享的只读环形缓冲区，并进行编码以供以后使用。可以想象，保持处理程序简单的原因是性能，因为最初的内核执行是“冻结”的，直到处理程序返回。冻结在纳秒量级。

事件缓冲区被内存映射到用户空间，因此无需任何拷贝就可以访问它，从而最大限度地减少 CPU 使用和缓存未命中。libscap 和 libsinsp 这两个库为读取、解码和解析事件提供了支持。具体来说，libscap 提供了跟踪文件管理功能，而 libsinsp 包含了复杂的状态跟踪功能(例如，您可以使用文件名而不是 FD 号)以及过滤、事件解码、运行插件的 Lua JIT 编译器等等。

Sysdig 现在还支持 eBPF(扩展的 Berkeley 包过滤器),作为前面描述的基于内核模块的体系结构的替代方案。eBPF 是一个 Linux 本地的内核 VM，它支持对应用性能、事件可观察性和分析进行安全、低开销的跟踪。

将 ContainerVision 绑定到 eBPF 有几个动机。一种是简单地利用已经是基本操作系统一部分的成熟技术。这使得对可观察性的管理变得更加容易和顺畅。eBPF 有意义的另一个原因是容器优化操作系统的出现。这些解决方案，如来自 GCP 的 COS 和由 Red Hat 领导的 Project Atomic Host，具有不可变的基础设施方法，完全不允许内核模块。通过利用 eBPF，这些较新操作系统方法的用户实现了 Sysdig 已经用内核模块交付了一段时间的容器可观察性的相同水平，如图 8-3 所示。

图 8-3

Sysdig 容器监控架构

现在让我们申请一个 Sysdig Monitor 的评估版，看看它是如何监控容器应用的。

图 8-4

Sysdig 评估请求

• 步骤 1: 导航到 https://sysdig.com ，请求 Sysdig 的评估版本。选择产品，点击今日报名按钮，如图 8-4 所示。

图 8-6

Sysdig 评估帐户激活

图 8-5

Sysdig 评估申请表

• 第二步:填写所需信息，点击提交按钮，如图 8-5 和 8-6 所示。

图 8-7

Sysdig 评估帐户密码设置

• 第 3 步:您将通过提供的电子邮件地址收到一个激活链接。收到邮件大约需要 30 分钟到一个小时。单击电子邮件中的激活链接，完成评估访问请求。系统将提示您为 Sysdig 设置新密码。点击激活登录按钮继续，如图 8-7 所示。

图 8-8

Sysdig 评估帐户欢迎页面

• 步骤 4: 您将被提示进入 Sysdig 欢迎屏幕。点击下一步继续，如图 8-8 所示。

图 8-10

Sysdig 评估帐户 Kubernetes 集成键

图 8-9

Kubernetes 的 Sysdig 评估帐户设置

• 第五步:在下一个屏幕上选择 Kubernetes(图 8-9 )。选择后，您会看到一个按键(图 8-10 )。复制钥匙。我们将在本章后面使用它。

使用 GKE，我们现在将在 GCP 上设置一个集群，并将 Sysdig Monitor 与它集成，用于容器应用监控。对于本实验，我们将假设读者具备 GCP 的工作知识和一个 GCP 帐户。

开放端口 6443 供代理进出

由于 GKE 使用状态防火墙，我们必须主动为 Sysdig 代理打开端口 6443，用于入站和出站流量。

图 8-11

GCP 控制台防火墙规则

• 步骤 1: 打开 VPC 网络中的防火墙规则部分，为入站和出站流量创建新的规则，如图 8-11 所示。

图 8-12

GCP 防火墙规则创建

• 第二步:点击【创建防火墙规则】，创建入站规则，如图 8-12 所示。

图 8-15

入站防火墙规则创建—续

图 8-14

入站防火墙规则创建—续

图 8-13

入站防火墙规则创建

• 第 3 步:按照如下方式填写入站规则的创建防火墙规则表单:

  • 名称:给一个合适的名称

  • 日志:选择关闭选项

  • 网络:默认

  • 优先级 : 1000

  • 交通方向:入口

  • 入口用于入站流量。

  • 匹配动作:允许

  • 目标标签:提供您在集群上使用的相同目标标签。在我们这里是gke-clustertutorial-cff607d3-node。

  • 源 IP 范围 : 10.16.0.0/14(与您的集群相同)

  • 协议和端口:检查 tcp，选择端口 6443。

• 现在点击创建按钮。参见图 8-13 、 8-14 和 8-15 。

图 8-16

入站防火墙规则创建—续

• 第四步:用您给定的名称验证创建的入站防火墙规则搜索规则，如 sysdig-agent-inbound，如图 8-16 所示。

图 8-20

出站防火墙规则创建—续

图 8-19

出站防火墙规则创建—续

图 8-18

出站防火墙规则创建—续

图 8-17

出站防火墙规则创建

• 第 5 步:填写出站规则的创建防火墙规则表单，如下所示:

  • 名称:给一个合适的名称

  • 日志:选择关闭选项

  • 网络:默认

  • 优先级 : 1000

  • 交通方向:出口

  • 用于出站流量的出口

  • 匹配动作:允许

  • 目标标签:提供您在集群上使用的相同标签。在我们这里是gke-clustertutorial-cff607d3-node。

  • 目的 IP 范围 : 10.16.0.0/14

  • 协议和端口:检查 tcp，选择端口 6443。

• 现在点击创建按钮。参见图 8-17 、 8-18 和 8-19 。

• 第六步:用您给的名称验证创建的出站防火墙规则搜索规则，如 sysdig-agent-outbound，如图 8-20 所示。

在 GKE 上安装 Sysdig 代理

图 8-22

克隆 GCP 电码—续

图 8-21

克隆 GCP 密码

• 第一步:连接 GKE，打开云壳。

• 第二步:在 Prometheus 下执行以下命令，克隆 GCP，其中包含sysdig-agent-clusterrole.yaml、sysdig-agent-configmap.yaml、sysdig-agent-daemonset-v2.yaml文件:。$ git clone https://github.com/dryice-devops/GCP.git

• 输出:数字 8-21 和 8-22 显示前一条命令的输出。

图 8-23

传递 GCP·EKS 集群的价值

• 第三步:在 Sysdig 目录下，你会找到sysdig-agent-clusterrole.yaml、sysdig-agent-configmap.yaml、sysdig-agent-daemonset-v2.yaml文件。你可以从下面的 GitHub 链接中获得样例文件: https://github.com/draios/sysdig-cloud-scripts/tree/master/agent_deploy/kubernetes

• 在sysdig-agent-configmap.yaml文件中，你会发现下面这段:k8s_cluster_name。传递 GCP EKS 星团(在我们的例子中是 Prometheus)的值，如图 8-23 所示。

图 8-24

Sysdig 代理命名空间创建

• 接下来，打开sysdig-agent-daemonset-v2.yaml文件。您不必修改该文件中的任何内容。

• 步骤 4: 通过从 GCP 目录执行以下命令，为 Sysdig 代理创建一个名称空间。

• 命令命令: $ kubectl create ns sysdig-agent

• 输出:图 8-24 显示了前一条命令的输出。

图 8-25

Sysdig 代理秘密创建

• 步骤 5: 通过执行以下命令为 Sysdig 代理创建秘密。这将使用我们为 Sysdig 创建评估帐户时获得的密钥(突出显示)(在欢迎屏幕中选择 Kubernetes 时)。

• 命令 : $ kubectl create secret generic sysdig-agent --from-literal=access-key=9b63d2de-4e52-49a9-b287-ef3c3dd39934 -n sysdig-agent

• 输出:图 8-25 显示了前一条命令的输出。

图 8-26

Sysdig 代理群集角色部署

• 步骤 6: 执行以下命令，部署 Sysdig 代理集群角色。clusterrole文件与我们在前面步骤中创建的文件相同。

• 命令: $ kubectl apply -f sysdig-agent-clusterrole.yaml -n sysdig-agent

• 输出:图 8-26 显示前一条命令的输出。

图 8-27

Sysdig 命名空间的 sysdig 代理服务帐户

• 步骤 7: 执行下面的命令，在 Sysdig 代理名称空间中创建一个服务帐户。

• 命令: $ kubectl create serviceaccount sysdig-agent -n sysdig-agent

• 输出:图 8-27 显示了前一条命令的输出。

图 8-28

Sysdig 代理群集角色绑定创建

• 步骤 8: 执行以下命令，在 Sysdig 名称空间中创建集群角色绑定。

• 命令: $ kubectl create clusterrolebinding sysdig-agent --clusterrole=sysdig-agent --serviceaccount=sysdig-agent:sysdig-agent

• 输出:图 8-28 显示前一条命令的输出。

图 8-29.1

Sysdig 代理 daemonset 安装

图 8-29

Sysdig 代理配置映射创建

• 步骤 9: 执行以下命令，完成 Sysdig 代理的安装。

• 命令: $ kubectl apply -f sysdig-agent-configmap.yaml -n sysdig-agent

• 命令: $kubectl apply -f sysdig-agent-daemonset-v2.yaml -n sysdig-agent

• 输出:数字 8-29 和 8-29.1 显示前面命令的输出。

现在，我们将导航到 Sysdig 控制台，查看监控指标。

图 8-30

登入成功

• 第一步:导航到 https://sysdig.com/ ，点击登录按钮，选择显示器，如图 8-30 所示。使用注册阶段使用的用户名/密码登录。

图 8-31

Sysdig 欢迎页面

• 第二步:登录后，会看到欢迎使用 Sysdig 页面。您还会看到“您连接了 3 个代理！”通知。单击转到下一步！导航到下一个屏幕，如图 8-31 所示。

图 8-34

系统摘要设置完成—续

图 8-33

系统摘要设置完成

图 8-32

跳过 AWS 帐户

• 步骤 3: 将与 AWS 整合部分留空，点击跳过按钮，如图 8-32 所示，从而完成 Sysdig 设置(图 8-33 和 8-34 )。

现在，让我们在 Sysdig 控制台上浏览各种报告，进行容器监控。单击“下一步”按钮，您将看到一个新窗口，显示以下消息:“您的环境已准备就绪。”点击完成入职按钮，如图 8-35 所示。

图 8-35

Sysdig 主页仪表板屏幕

浏览 GKE 监控报告

要浏览 GKE 监控报表，请执行以下步骤:

图 8-36

sysdig kuble health dashboard(永久健康仪表板)

• 步骤 1: 要在 Sysdig 中查看已部署的 pod，请单击 Explore。现在，从下拉选项中选择主机&容器。在另一个节点，选择 Kubernetes 类别(默认仪表板的子类别)下的 Kubernetes Health Overview，如图 8-36 所示。

图 8-38

Sysdig Kubernetes 健康仪表板—续

图 8-37

sysdig kuble health dashboard(永久健康仪表板)

• 步骤 2: 您将发现关于整个 Kubernetes 环境的丰富指标，包括顶级名称空间(按容器)、CPU/内存/文件系统使用、网络输入/输出，如图 8-37 和 8-38 所示。

图 8-40

Sysdig 容器限值监控—续

图 8-39

Sysdig 容器限值监控

• 第三步:从页面最右侧的下拉菜单中选择容器限制，查看 CPU/内存份额和配额，如图 8-39 和 8-40 所示。

图 8-42

Sysdig 容器文件系统监控—续

图 8-41

Sysdig 容器文件系统监控

• 第四步:从页面右侧的下拉菜单中选择文件系统，查看文件系统中的可用字节数/已用字节数/索引节点数等。如图 8-41 和 8-42 所示。

图 8-45

Sysdig 容器网络监控—续

图 8-44

Sysdig 容器网络监控—续

图 8-43

Sysdig 容器网络监控

• 第五步:在下拉菜单右侧选择网络下的概览选项，查看入站网络字节、出站网络字节、总网络字节等指标，如图 8-43 、 8-44 和 8-45 所示。

现在让我们来看看容器应用指标。

图 8-47

Sysdig 容器化应用视图—续

图 8-46

Sysdig 容器化应用视图

• 步骤 1: 要查看我们的 Sock Shop 应用(在前面的章节中部署)的基于容器的信息，从下拉菜单中选择 contained Apps，然后从 weaveworksdemos 开始选择容器名称。您将能够看到 top Pods 的 CPU 利用率、内存利用率和文件系统，如图 8-46 和 8-47 所示。

图 8-50

Sysdig 部署视图—续

图 8-49

Sysdig 部署视图—续

图 8-48

Sysdig 部署视图

• 第二步:要查看部署，从下拉菜单中选择部署，选择 sock-shop，如图 8-48 、 8-49 和 8-50 。

• 在 Kubernetes 类别下选择 Kubernetes CPU 分配优化。

现在，让我们研究一下 Sysdig 提供的特定于应用层的其他指标。

图 8-54

Sysdig HTTP 监视器度量—续

图 8-53

Sysdig HTTP 监视器度量

图 8-52

Sysdig HTTP 监视器默认仪表板

图 8-51

Sysdig HTTP 监视器

• 步骤 1: 单击左侧面板中的 Explore，并从下拉菜单中选择 Hosts & Containers 选项。从右侧第二个下拉菜单中选择 HTTP。您将看到一些指标，如 HTTP 请求数、平均/最大请求时间、最慢的 URL 等。如图 8-51 、 8-52 、 8-53 、 8-54 所示。

图 8-56

Sysdig JVM 监视器度量

图 8-55

Sysdig JVM 监视器

• 步骤 2: 选择 JVM，而不是 HTTP，来查看与 JVM 相关的指标。这将显示诸如进程随时间分配的堆内存使用和垃圾收集器收集时间等指标，如图 8-55 和 8-56 所示。

图 8-58

Sysdig MongoDB 监视器指标

图 8-57

Sysdig MongoDB 监视器

• 第三步:在页面右侧的下拉菜单中选择 MongoDB (Server)而不是 JVM，查看 MongoDB 相关的指标，如创建的连接总数、MongoDB 进程使用的虚拟内存量等。如图 8-57 和 8-58 所示。

Sysdig 拓扑视图提供了一个界面，用于实时可视化应用系统中不同组件之间的交互方式。默认情况下，该界面显示选定主机的顶级进程及其与远程主机或主机组上的进程的交互。交互被描述为节点和链接。链接连接节点。节点和链接从左侧放射状扩展。以下是 Sysdig 控制台上可见的实体:

• 节点:节点是参与网络通信的实体。节点可以是进程、容器、主机或由 Sysdig 代理标识的任何标签，例如 kubernetes.pod.name。

• 链路:节点之间的网络连接称为链路。

  • 主机及其子进程(host.hostName > proc.name)充当拓扑视图的默认分组。扩展拓扑视图受到进程和连接数量的限制。Sysdig Monitor 通过识别来自系统调用数据的网络端点(IP 地址)来创建拓扑视图。

  • Explore 选项卡中的拓扑视图提供了预定义的仪表板，用于表示 CPU 使用情况、网络流量和响应时间指标。

现在让我们来探索 Sysdig 的拓扑视图。

图 8-60

Sysdig 拓扑视图 CPU 使用度量

图 8-59

Sysdig 拓扑视图 CPU 使用选项

• 步骤 1: 单击左侧面板中的 Explore，并从下拉菜单中选择 Hosts & Containers 选项。选择拓扑，然后选择 CPU 使用率。点击每个图标，通过拓扑映射按应用节点和容器深入查看 CPU 使用情况，如图 8-59 和 8-60 所示。

图 8-64

Sysdig 拓扑查看 pod 之间的网络流量

图 8-63

其他 Sysdig 拓扑查看网络流量指标

图 8-62

Sysdig 拓扑查看网络流量指标

图 8-61

Sysdig 拓扑视图网络流量选项

• 步骤 2: 从第二个下拉菜单中选择网络流量选项，而不是 CPU 使用率。您可以深入查看具体的流程。例如，我们选择了基于 Python 的盒子来显示与我们的 Sock Shop 应用相关的 Python 和 Mongo DB Pods 之间的网络流量，如图 8-61 、 8-62 、 8-63 和 8-64 所示。

传统的监控工具通常基于静态配置文件，设计用于监控机器，而不是微服务或容器。在容器世界中，事情的工作方式非常不同，因为容器可以根据应用的伸缩策略和传入流量进行伸缩。此外，容器以令人难以置信的速度被创建和销毁，从监控的角度来看，不可能跟踪这样的动态实体。

大多数现代平台系统都提供了各种各样的指标，每个指标都可以让我们了解平台的行为方式。人脑很难分析如此多的数据，并深入了解应用的运行情况。想象一下，容器平台上的一个应用被频繁使用，并产生大量关于可用性、性能、错误等各方面的指标。只要应用可用，我们就可以感觉到一切都在工作，但是我们可能会忽略某些事件，这些事件在一段时间后可能会导致系统中断或性能瓶颈。

谷歌使用黄金信号(谷歌发明的谷歌 SRE 手册中使用的术语)解决了这个问题。从与应用服务交互的系统来看，黄金信号本质上是四个指标，可以让您很好地了解应用的实际健康状况和性能。黄金信号有助于检测微服务应用的问题。这些信号是一组精简的指标，从用户或消费者的角度提供了一个广泛的服务视图，因此您可以检测可能直接影响应用行为的潜在问题。四个黄金信号是

• 延迟:延迟是您的系统为服务请求提供服务所花费的时间。这是检测性能下降问题的重要标志。

• 错误:您的服务返回的错误率是更深层次问题的一个很好的指示器。不仅要检测显式错误，还要检测隐式错误，这一点非常重要。

• 流量/连接:这是一个单位时间内你的服务使用量的指标。它可以是许多不同的值，取决于系统的性质，例如对 API 的请求数量或流媒体应用消耗的带宽。

• 饱和度:通常饱和度用最大容量的百分比来表示，但是每个系统会有不同的方式来衡量饱和度。百分比可能意味着直接从应用获得的或基于估计的用户或请求的数量。

现在让我们看看如何使用 Sysdig 查看黄金信号指标。

图 8-67

Sysdig 黄金信号指标—续

图 8-66

Sysdig 黄金信号指标

图 8-65

Sysdig 黄金信号选项

• 步骤 1: 单击左侧面板的 Explore，并从下拉菜单中选择 Services 选项。

• 第二步:从右侧第二个下拉菜单中选择 Kubernetes Service Golden Signals，如图 8-65 、 8-66 和 8-67 。

摘要

在本章中，我们提供了使用 Sysdig 进行容器应用监控的实际操作步骤。下一章将介绍使用 Prometheus 进行容器应用监控的实际操作步骤。

九、将 Prometheus 用于 GKE 监控

本章提供了指导您使用 Prometheus 进行 GKE 监控的实际操作步骤。此外，它还包括以下内容:

表 9-1

节点导出器

|

名称

|

描述

|

OS

|
| --- | --- | --- |
| 阿尔普 | 暴露来自/proc/net/arp的 ARP 统计 | Linux 操作系统 |
| 启动时间 | 暴露从kern.boottime sysctl得出的系统启动时间 | 达尔文，Dragonfly，FreeBSD，NetBSD，OpenBSD，Solaris |
| 中央处理器 | 公开 CPU 统计数据 | 达尔文，蜻蜓，FreeBSD，Linux，Solaris |
| 硬件服务 | 公开 CPU 频率统计信息 | Linux，Solaris |
| diskstats | 公开磁盘 I/O 统计信息 | 达尔文，Linux，OpenBSD |
| 文件系统 | 显示文件系统统计信息，如使用的磁盘空间 | 达尔文，蜻蜓，FreeBSD，Linux，OpenBSD |
| hwmon！hwmon | 暴露来自/sys/class/hwmon/的硬件监控和传感器数据 | Linux 操作系统 |
| 内存信息 | 公开内存统计信息 | 达尔文，蜻蜓，FreeBSD，Linux，OpenBSD |
| getclass(获取类) | 从/sys/class/net/暴露网络接口信息 | Linux 操作系统 |
| 子系统 | 显示网络接口统计信息，如传输的字节数 | 达尔文，蜻蜓，FreeBSD，Linux，OpenBSD |
| 显示网络连接 | 显示来自/proc/net/netstat的网络统计数据。这是和netstat -s一样的信息。 | Linux 操作系统 |
| 网络文件系统 | 显示来自/proc/net/rpc/nfs的 NFS 客户端统计数据。这是和nfsstat -c一样的信息。 | Linux 操作系统 |
| 服务器 | 展示来自/proc/net/rpc/nfsd的 NFS 内核服务器统计数据。这是和nfsstat -s一样的信息。 | Linux 操作系统 |
| 显示操作系统信息 | 公开 uname 系统调用提供的系统信息 | 达尔文，FreeBSD，Linux，OpenBSD |

图 9-8

配置映射 YAML 文件组件和子组件

图 9-7

为 Prometheus 创建集群角色和集群角色绑定

图 9-6.4

群集角色 YAML 文件组件和子组件

图 9-6.3

群集角色 YAML 文件组件

图 9-6.2

群集角色 YAML 文件演练

图 9-6.1

为 Prometheus 监控创建新的命名空间

图 9-6

Prometheus 监控的命名空间创建

图 9-5

验证克隆的文件

图 9-4.4

从 GitHub 克隆 Prometheus 代码

图 9-4.3

导航到prometheus目录

图 9-4.2

创建prometheus目录

图 9-4.1

移动到gcptutorialmail目录

图 9-4

创建gcptutorialmail目录

图 9-3

Prometheus 部署流程

图 9-2

YAML 文件构建块

图 9-1

Prometheus 建筑

• Prometheus 概述

• Prometheus 建筑

• Prometheus on Google Kubernetes Engine

• 在 Kubernetes 集群上设置 Prometheus

• 出口商

介绍

Prometheus 是一项监控服务，为 IT 团队提供在 GCP 和 AWS 公共云上运行的应用和虚拟机的性能数据。它包括专门针对 Kubernetes 操作符的功能和 Kubernetes 的其他特性，比如 CPU 和内存利用率。可以按基础架构、工作负载和容器查看集群信息。

在本章中，你将学习如何安装 Prometheus。我们将使用在第八章中部署在 GKE 集群上的 Sock Shop 应用，并配置 Prometheus 来监控 GKE 集群，并提取与 CPU 利用率等相关的各种矩阵。

Prometheus 概述

基于容器的技术正在影响基础设施管理服务的元素，如备份、修补、安全性、高可用性、灾难恢复等。监控就是这样一个元素，它随着容器技术的发展而突飞猛进。Prometheus 是最常作为开源监控和警报解决方案出现的容器监控工具之一。Prometheus 最初是在 SoundCloud 构思的，慢慢地，它成为了容器监控最受欢迎的工具之一。它主要是用 Go 语言编写的，并且是第一批云计算基础毕业项目之一。

Prometheus 支持基于键-值对的多维数据模型，这有助于收集作为时间序列数据的容器监控。它还提供了一种强大的查询语言，称为 Prometheus 查询语言(PromQL)。PromQL 允许实时选择和汇总时间序列数据。这些数据既可以作为图形、表格数据查看，也可以由外部系统通过 API 调用使用。Prometheus 还支持与第三方系统的各种集成，用于报告、警报、仪表板和导出器，从各种来源获取数据。

Prometheus 建筑

现在让我们看看 Prometheus 架构的核心组件。图 9-1 展示了 Prometheus 的架构及其主要组件。

Prometheus 服务器

这是一个主要的中央组件服务器，它从多个节点收集指标并将它们存储在本地。Prometheus 服务器的工作原理是抓取，即调用它被配置为监控的各种节点的指标端点。它定期收集这些指标，并将它们存储在本地。

Prometheus 服务器抓取并存储指标。这意味着您的应用必须公开一个指标可用的端点，并指示 Prometheus 服务器如何抓取它。

请注意，Prometheus 服务器使用了一个持久层，它是服务器的一部分，在文档中没有明确提到。服务器的每个节点都是自治的，不依赖于分布式存储。Prometheus 进行刮擦的时间是不确定的。因此，如果您的用例需要精确的逐秒抓取，Prometheus 可能不是一个好的选择。此外，Prometheus 毫无保留地专注于 HTTP。如果您在一个不使用 HTTP 的基于 SOAP 或基于 RPC 的整体环境中操作，您可能会遇到集成挑战。Prometheus 主要是一个拉动式系统；但是，它也提供了推送功能，这将在下一节中解释。

Prometheus 推进网关

Prometheus 直接或通过中间推送网关从仪表化的应用中抓取指标。请将此视为一种缓冲形式。它接受并存储推送的指标，并为 Prometheus 公开一个可废弃的 API。Pushgateway 支持短期作业，以防节点不公开 Prometheus 服务器可以从中收集指标的端点。它捕获数据，将数据转换为 Prometheus 数据格式，然后将数据推送到 Prometheus 服务器。

出口商

导出器运行在受监控的主机上，该主机从第三方系统(如 Linux 服务器、MySQL 守护进程等)获取现有指标。)并将它们导出到 Prometheus 中的 metric 并将数据推送到 Prometheus 服务器。

Alertmanager

Prometheus 有一个名为 Alertmanager 的警报模块，用于发送警报并将其路由到正确的接收者集成，如电子邮件、Slack 等。

网络用户界面

web UI 允许用户访问、可视化和绘制存储的数据。Prometheus 提供了自己的 UI，但是您也可以配置其他可视化工具，如 Grafana，使用 PromQL 访问 Prometheus 服务器。

关键容器监控功能

以下是 Prometheus 为容器监控提供的主要功能。

多维数据模型

该模型基于键值对，类似于 Kubernetes 本身用标签组织基础设施元数据的方式。它允许灵活和准确的时间序列数据，为其 PromQL 提供动力。

可访问格式和协议

公开 Prometheus 度量是一项非常简单的任务。指标是人类可读的，采用自我解释的格式，并使用标准的 HTTP 传输发布。您可以通过使用您的 web 浏览器来检查指标是否被正确公开。

服务发现

Prometheus 服务器负责定期抓取目标，因此应用和服务不必担心发出数据(指标是提取的，而不是推送的)。Prometheus 服务器有几种自动发现刮擦目标的方法。一些服务器可以配置为过滤和匹配容器元数据，使它们非常适合短暂的 Kubernetes 工作负载。

模块化和高度可用的组件

指标收集、警报、图形可视化等。由不同的可组合服务执行。所有这些服务都旨在支持冗余和分片。

本地查询语言支持

如概述中所述，Prometheus 提供了一种函数式查询语言 PromQL，允许用户实时选择和汇总时间序列数据。表达式的结果可以在 Prometheus 的表达式浏览器中表示为图形或表格数据，也可以由外部系统通过 HTTP API 使用。

支持仪表板和报告

Prometheus 支持与各种报告解决方案(如 Grafana 和 Splunk)集成，以获得运营使用的 Kubernetes 指标视图。这简化了用于库存管理、性能管理和事件管理的容器生态系统的操作管理任务。

Prometheus on Google Kubernetes Engine

在第八章中，在部署我们的 Sock Shop 应用时，我们使用了一个 YAML 配置文件来提供在目标/工作者节点上部署应用所需的细节。在安装 Prometheus 和 Alertmanager 之前，我们想让您了解一下 YAML 文件结构的基本知识。YAML 是一种人类可读的数据序列化语言。它通常用于配置文件和存储或传输数据的应用中。YAML 是专门为常见情况创建的，例如:

• 配置文件

• 日志文件

• 跨语言数据共享

• 复杂的数据结构

在高层次上，以下是 YAML 文件的构建块，如图 9-2 所示。

• 键值对:YAML 文件中条目的基本类型是键值对。在键和冒号之后，有一个空格，然后是值。

• 数组/列表:列表的名字下有许多条目。列表的元素以“-”开头

• 字典/地图:一种更复杂的 YAML 文件是字典或地图。

现在，Kubernetes 的资源，比如 pod、服务和部署，都是通过使用 YAML 文件来创建的。在接下来的部分中，我们将通过使用一个 YAML 文件来介绍部署资源的创建，并且将为您提供一个在其中使用的关键字段的概述。

现在让我们从设置 Prometheus 和 Alertmanager 开始。在本练习中，我们将使用第八章中设置的相同容器环境。

在 Kubernetes 集群上设置 Prometheus

让我们开始在 Kubernetes 环境中设置 Prometheus。图 9-3 概述了部署 Prometheus 时我们将遵循的任务流程。

Prometheus 部署的步骤顺序如下:

1. 我们将首先在工作项目中连接到 Cloud Shell。

2. 然后我们将从 GitHub 克隆配置文件。

3. 然后，我们将使用在 Google Cloud Shell 中预配置的 kubectl 在 GKE 集群上创建一个名称空间。

4. 我们将在 GKE 群集上创建群集角色和群集角色绑定。

5. 我们将创建配置映射，然后在 GKE 集群上使用此配置映射部署 Prometheus。

6. 然后，我们将为最终用户访问 Prometheus 创建一个服务。

7. 最后，我们将使用命令行和 web 浏览器访问测试 Prometheus 部署的状态。

在 GKE 上安装和设置 Prometheus

从 GitHub 克隆 Prometheus 代码

在从 GitHub 克隆 Prometheus 之前，首先，我们将在/home目录下创建gcptutorialmail文件夹，在gcptutorialmail下，我们将创建prometheus文件夹。这个prometheus文件夹包含了在 GKE 安装 Prometheus 所需的所有配置文件。

• 步骤 1: 执行以下命令，创建gcptutorialmail和prometheus文件夹。

• 命令:

• cd /home

• mkdir gcptutorialmail

• 输出:图 9-4 显示前一条命令的输出。

• 通过执行以下命令导航到gcptutorialmail文件夹。

• 命令:

• cd /gcptutorialmail

• 输出:图 9-4.1 显示了前一条命令的输出。

• 现在，通过执行以下命令，在gcptutorialmail下创建prometheus文件夹。

• 命令: mkdir prometheus

• 输出:图 9-4.2 显示了前一条命令的输出。

• 通过执行以下命令，导航到prometheus文件夹。

• 命令: cd /prometheus

• 输出:图 9-4.3 显示了前一条命令的输出。

• 第二步:通过执行以下命令，从 GitHub ( https://github.com/dryice-devops/gcp-prometheus.git )克隆代码。

• 命令: git clone https://github.com/dryice-devops/gcp-prometheus.git

• 输出:图 9-4.4 显示了前一条命令的输出。

• 验证克隆的文件:从 GitHub 克隆文件后，您会看到以下文件:

• clusterRole.yaml

• configMap.yaml

• prometheus-deployment.yaml

• 要验证前面的配置文件是否成功克隆到本地prometheus文件夹，请执行以下命令。

• 命令 : ll

• 输出:图 9-5 显示前一条命令的输出。

创建命名空间

要安装 Prometheus，第一步是在现有集群中创建一个单独的名称空间，用于逻辑隔离。为此，请执行以下步骤:

• 步骤 1: 在创建名称空间之前，确保使用以下命令连接到 GKE 集群名称clustertutorial。

• 命令: gcloud container clusters get-credentials clustertutorial --zone us-central1-a --project tutorial-project-268109

• 输出:图 9-6 显示前一条命令的输出。

• 步骤 2: 在 tutorial 项目的 Cloud Shell 上执行以下命令，从prometheus目录创建一个名为prometheus的新名称空间。

• 命令: kubectl create namespace prometheus

• 输出:图 9-6.1 显示了前一条命令的输出。

群集角色 YAML 文件

让我们深入到prometheus文件夹中的集群角色 YAML 文件(clusterRole.yaml)的内容，以理解该部分及其相关性。该文件有两个部分:ClusterRole和ClusterRoleBinding。

集群角色部分

apiVersion(堆叠版本)

文件的初始部分包含定义 Kubernetes API 版本的字段，通过该字段与 Kubernetes API 服务器进行交互。它通常用于创建对象。apiVersion 会有所不同，这取决于您环境中的 Kubernetes 版本。我们使用下面的 API version:ClusterRole的rbac.authorization.k8s.io/v1beta1。

种类

kind字段定义了 Kubernetes 对象的类型，例如集群角色、部署、服务、pod 等。在我们的例子中，我们使用的是ClusterRole。

元数据

此部分在文件中定义了名称子组件。name字段指定对象的名称。在我们的例子中，我们使用prometheus作为name，如图 9-6.2 所示。

规则

规则是可以在属于不同 API 组(也称为遗留组)的一组资源上执行的一组操作(动词)。在我们的例子中，我们正在创建一个规则，允许用户在节点、代理、服务、端点和属于核心(在 YAML 文件中用" "表示)、应用和扩展的 pod 上执行几个操作。API 组规则有几个子组件元素。

• resources:该字段定义了各种 Kubernetes 资源。

• verbs:该字段定义了要对资源执行的操作。

• 这是一组用户应该有权访问的部分 URL。非资源 URL 没有命名空间。此字段仅适用于从群集角色绑定引用的群集角色。规则既可以应用于 API 资源(如"pods"或"secrets")也可以应用于非资源 URL 路径(如"/api")，但不能两者都应用，如图 9-6.3 。

群集角色绑定部分

apiVersion(堆叠版本)

文件的初始部分包含定义 Kubernetes API 版本的字段，通过该字段与 Kubernetes API 服务器进行交互。它通常用于创建对象。API 版本会有所不同，这取决于您环境中的 Kubernetes 版本。对于集群角色绑定，我们使用下面的 API: rbac.authorization.k8s.io/v1beta1。

种类

Kind 字段定义 Kubernetes 对象的类型，例如集群角色、部署、服务、pod 等。在我们的例子中，我们使用 ClusterRoleBinding。

元数据

此部分在文件中定义了名称子组件。名称字段指定对象的名称。在我们的例子中，我们使用prometheus作为name。

• roleRef:在这个字段中，我们将 Prometheus 集群角色绑定到监控名称空间内 Kubernetes 提供的默认服务帐户。这一部分还包含更多的子组件。

  • apiGroup:该字段定义 rbac.authorization.k8s.io API 与 API 组交互

  • kind:该字段定义了对象类型。

  • name:集群角色的名称，如prometheus。

• Subjects:这个部分定义了必须访问 Kubernetes API 的一组用户和进程。这一部分还包含更多的子组件。

  • kind:该字段定义了服务账户的对象类型。

  • 由于每个 Kubernetes 安装都有一个名为 default 的服务帐户，它与每个正在运行的 Pod 相关联，所以我们使用相同的帐户:default。

  • namespace:该字段定义了集群角色绑定的名称空间名称，例如，monitoring(我们在“创建名称空间”一节中创建的)，如图 9-6.4 所示。

现在，我们将为 Prometheus 创建刚刚创建的集群角色和集群角色绑定。

• 步骤 1: 在prometheus文件夹下创建角色，在教程项目的云 Shell 上使用下面的命令。

• 命令:

• kubectl create -f clusterRole.yaml

• 输出:图 9-7 显示前一条命令的输出。

创建配置图

ConfigMap 将用于从映像内容和警报规则中分离任何配置工件，这些内容和规则将作为prometheus.yaml和prometheus.rules文件安装到/etc/prometheus中的 Prometheus 容器中。

• 步骤 1: 我们将使用prometheus文件夹中的配置映射 YAML 文件来创建ConfigMap。现在让我们回顾一下 YAML 文件的内容。ConfigMap合并了数据段下的prometheus.rules和prometheus.yaml文件。

• apiVersion:文件的初始部分定义了 Kubernetes 的 apiVersion 与 Kubernetes API 服务器交互的字段。它通常用于创建对象。apiVersion 会有所不同，这取决于您环境中的 Kubernetes 版本。

• kind:kind字段定义了 Kubernetes 对象的类型，如集群角色、部署、服务、pod 等。我们使用ConfigMap作为宾语。

• metadata:该部分具有在包含配置图数据的文件中定义的name子组件。

  • name : 该字段具有配置图的名称。在我们的例子中，我们使用的是prometheus-server-conf。

  • labels : 该字段定义了 ConfigMap 的标签，如prometheus-server-conf。

  • namespace : 该字段定义将在其中创建 ConfigMap 的名称空间，例如监控，如图 9-8 所示。

• data:该字段定义了prometheus.rules和prometheus.yml的内容，并在运行时将它们的信息传递给ConfigMap。

• prometheus.rules : 此部分包含用于根据各种条件(例如，内存不足、磁盘空间不足等)生成警报的警报规则。我们选择了高 Pod 内存使用率。

• prometheus.yml : Prometheus 通过一个配置文件进行配置，这个文件就是prometheus.yml。配置文件定义了与抓取作业及其实例相关的所有内容，以及要加载的规则文件。prometheus.yml包含所有有助于动态发现 Kubernetes 集群中运行的 pod 和服务的配置。以下是我们的 Prometheus 刮擦配置中的刮擦作业:

  • kubernetes-apiservers:从 API 服务器获取所有的指标。

  • kubernetes-nodes:此作业将收集所有 Kubernetes 节点指标。

  • kubernetes-pods:如果 Pod 元数据用prometheus.io/scrape和prometheus.io/port注释进行了注释，将会发现所有的 Pod 指标。

  • kubernetes-cadvisor:收集所有 cAdvisor 指标。

  • kubernetes-service-endpoints : 如果服务元数据被标注了prometheus.io/scrape和prometheus.io/port标注，那么所有的服务端点都将被废弃。它将使用黑盒监控。

• prometheus.rules:包含向预警管理器发送预警的所有预警规则。

  • global : 全局配置指定在所有其它配置环境中有效的参数。global具有各种子组件，如下所示:

    • scrape_interval:默认多长时间刮一次目标。我们选择 20 秒作为例子。

    • evaluation_interval:刮取请求超时之前的时间长度。我们选择 20 秒作为例子。

  • rule_files: This specifies a list of globs. Rules and alerts are read from all matching files that we defend under prometheus.rules and the path defined as /etc/prometheus/prometheus.rules, as shown in Figure 9-9.

    

    图 9-9

    配置映射 YAML 文件字段和子字段

• 步骤 2: 执行以下命令，从prometheus文件夹创建配置图。

• 命令: kubectl create -f config-map.yaml –n prometheus

• Output: Figure 9-10 shows the output of the preceding command.

  

  图 9-10

  为 Prometheus 创建配置图

Prometheus 部署

在为 Prometheus 部署设置了角色、配置和环境之后，执行以下步骤在 GKE 上创建的 Kubernetes 集群上安装 Prometheus。

为了在 Kubernetes 集群上部署 Prometheus，我们将使用prometheus文件夹中的prometheus-deployment.yaml文件。

我们将使用来自 Docker hub 的官方 Prometheus Docker 映像 v2.12.0。在这种配置中，Prometheus ConfigMap 挂载作为一个文件放在/etc/Prometheus中。

以下是 Prometheus 部署文件的详细信息:

• apiVersion : 该文件的开始部分定义了 Kubernetes 的 apiVersion 与 Kubernetes API 服务器交互的字段。它通常用于创建对象。apiVersion 根据您环境中的 Kubernetes 版本而有所不同。

• kind:kind字段定义了 Kubernetes 对象的类型，例如集群角色、部署、服务、pod 等。我们将该对象用作部署。

• metadata : 本节有文件中定义的名称子组件。

  • 该字段指定服务对象的名称，例如 prometheus-deployment。

  • namespace: This field specifies the namespace of the service object, e.g., monitoring, as shown in Figure 9-11.

    

    图 9-11

    Prometheus 部署 YAML 文件演练

• spec : 该字段指定服务。

  • replicas:该字段提供特定情况下可用的 pod 数量的数据。

  • selector:本节提供服务选择器的详细信息。

    • matchLabels : This is the name that will be used to match and identify the service, as shown in Figure 9-12.

      

      图 9-12

      Prometheus 部署 YAML 文件演练

• template:服务使用的端口类型

  • metadata : name将用于匹配和识别服务。
    • labels:一个键值对，附加在对象上，用于指定识别属性

      • app =键

      • prometheus-server =值

前述内容如图 9-13 所示。

图 9-38

黑盒度规

图 9-37

出口商名单

图 9-36

端口更新

图 9-35

获取黑盒导出器服务详细信息

图 9-34

安装黑盒导出器—续

图 9-33

安装黑盒导出器

图 9-32

节点度量

图 9-31

出口商名单

图 9-30

Prometheus 屏幕

图 9-29

端口转发

图 9-28

得到 Prometheus 号的名字

图 9-27

服务列表

图 9-26

节点导出器设置

图 9-25

服务列表

图 9-24

节点导出器安装—续

图 9-23

节点导出器安装

图 9-22

Prometheus 屏幕

图 9-21

Prometheus 屏幕

图 9-20

转发到端口 8080

图 9-19

端口转发运行 Prometheus

图 9-18

Prometheus 部署—续

图 9-17

Prometheus 部署

图 9-16

Prometheus 部署 YAML 文件演练—续

图 9-15

Prometheus 部署 YAML 文件演练—续

图 9-14

Prometheus 部署 YAML 文件演练—续

图 9-13

Prometheus 部署 YAML 文件演练—续

• Spec:

  • containers:容器对象的详细信息

    • name : 容器的名称

    • image : 映像配版本

    • args : 创建容器时使用的参数

      • "--config.file=/etc/prometheus/prometheus.yml"部署时要使用的文件名

      • 这决定了 Prometheus 在哪里写它的数据库

    • ports:??

      • containerport–应用监听端口如图 9-14 所示。

• 卷装载:存储卷允许将现有的存储卷装载到您的 Pod 中。创建了两个volumeMounts:prometheus-config-volume和prometheus-storage-volume。prometheus-config-volume将使用我们的配置图来管理prometheus.yml。通过prometheus-storage-volume，我们创建了一个emptyDir来存储 Prometheus 数据。

  • 名称:这是卷的名称。

  • mouthPath: 定义贴装路径，如图 9-15 所示。

• 卷(volume):这是一个包含数据的目录，运行在一个 Pod 中的所有容器都可以访问该目录中的数据，这些数据被装载到每个容器的文件系统中。它的寿命与 Pod 的寿命相同。将卷生命周期与容器生命周期分离，允许卷在容器崩溃和重新启动后继续存在。此外，卷可以由主机的文件系统或永久块存储卷支持，如 AWS EBS 或分布式文件系统。

  • name : 卷名

  • configMap : 使用 ConfigMap 的卷

    • defaultMode

    • name必须使用的配置图的定义名称。

    • name:

    • emptyDir : 当一个 Pod 被分配到一个节点时，第一次创建emptyDir卷，并且只要该 Pod 在我们用来存储 Prometheus 数据的那个节点上运行，该卷就存在，如图 9-16 所示。

按照下面的步骤，在 Kubernetes 集群上安装 Prometheus。

• 第一步:从prometheus目录执行以下命令。

• 命令: kubectl apply -f prometheus-deployment.yaml -n prometheus

• 输出:图 9-17 显示了前一条命令的输出。

要验证部署，请使用以下命令列出 Pod。

• 命令: kubectl get pods -n prometheus

• 输出:图 9-18 显示前一条命令的输出。

• 步骤 2: 要使服务能够访问 Prometheus UI，请使用带有我们之前收到的 Prometheus Pod 名称的端口转发命令。

• 命令: kubectl port-forward prometheus-deployment-78fb5694b4-m46rq 8080:9090 -n prometheus

• 输出:图 9-19 是端口转发的输出。它将设置 Grafana 在端口 9090 上运行。

• 第三步。要测试 Prometheus 部署的状态，请在将端口更改为 8080 后，转到 Cloud Shell 中的 web 预览来访问 UI。进入网页预览➤换港➤ 8080，如图 9-20 和 9-21 所示。

出口商

导出器帮助从应用/Kubernetes 服务获取状态/日志/指标，并向 Prometheus 提供数据。它们类似于市场上其他监控工具中的适配器或插件。Prometheus 提供了一份官方和外部捐助的出口商名单。让我们通过访问下面的: https://prometheus.io/docs/instrumenting/exporters/ 来探索一些对容器基础设施监控有用的方法。

节点导出器

节点导出器是一个 Prometheus 导出器，用于获取 Unix/Linux 内核公开的硬件和操作系统指标。它是用 Go 语言编写的，带有可插拔的度量收集器。收集器根据操作系统类型的使用情况而有所不同。表 9-1 提供了几个例子。

使用 Helm 图在 Prometheus 安装节点导出器

要安装节点导出器，需要 Helm 和 Helm 杆。头盔和 Helm 杆预配置了第七章的“部署 Grafana”一节中解释的云壳。

• 步骤 1: 执行以下命令来更新 Tiller 并分配一个服务帐户角色。

• 命令: helm init --service-account tiller --history-max 200 –upgrade

• 现在运行下面的命令，验证 Helm 和 Helm 杆是否运行顺畅。现在，您应该可以看到客户机和服务器的版本信息。

• 命令: helm version

• 输出:图 9-22 显示前一条命令的输出。

• 第二步:执行以下命令。它将从下面的 GitHub URL 下载导出器，并在 GKE 集群上安装节点导出器。

• https://github.com/helm/charts/tree/master/stable/prometheus-node-exporter

• 命令: helm install --name node-exporter stable/prometheus-node-exporter

• 输出:数字 9-23 和 9-24 显示前一条命令的输出。

• 步骤 3: 现在让我们使用下面的命令来验证节点导出器服务是否正在运行。

• 命令: kubectl get svc

• 输出:图 9-25 显示前一条命令的输出。

node-exporter-prometheus-node-exporter服务应该是可见的并且处于运行状态，如图 9-25 中突出显示的。还要注意服务的集群 IP，因为它将在下一步中使用。

• 步骤 6: 在 Prometheus UI 中，登录并导航到状态，然后导航到 Prometheus 上的目标，验证节点导出程序。然后执行下面的命令。

• $ kubectl port-forward prometheus-deployment-78fb5694b4-7z6dd 8080:9090 -n prometheus

• 用黄色突出显示的代码是 Prometheus 的 Pod 名称，您可以通过执行以下命令获得它。

• 命令: kubectl get pod -n prometheus

• 输出:前一条命令的输出如图 9-28 所示。

• 端口转发的输出如图 9-29 所示。

• 在浏览器中打开 Prometheus，在状态下拉菜单下进入目标，如图 9-30 所示。

• 搜索node-exporter并确认其状态为 UP，如图 9-31 所示。

• 步骤 7: 现在让我们执行一个查询，开始收集和显示节点指标。单击图表选项卡。在表达式部分(文本框)下，键入“node_load15”并点击执行按钮，如图 9-32 所示。

• kubectl delete configmaps prometheus-server-conf -n=prometheus

• kubectl create -f config-map.yaml

• kubectl delete deployment prometheus-deployment -n prometheus

• kubectl apply -f prometheus-deployment.yaml -n prometheus

• 步骤 4 :下一步是配置上一步安装的节点导出器。

• 导航到prometheus文件夹并打开config-map.yaml文件。在scarpe_config剖面下，找到job name和static_configs的job_name: node_exporter剖面和细节，如图 9-26 所示。

• job_name:该字段表示节点导出器的作业名称。我们使用值node-exporter作为job_name。

• static_configs : 这个部分有一个名为targets的小节。“目标”是指作业目标 10.81.13.221(群集 IP)和 9100，即运行节点导出的服务端口。您可以使用以下命令来验证您的集群 IP 和端口信息。

• 命令: kubectl get svc

• 输出:图 9-27 显示了前一条命令的输出。

• 步骤 5: 执行以下命令，以反映在之前步骤中对 Prometheus ConfigMap 所做的更改。

• 命令:

节点导出器主要用于监控容器基础设施的基础元素，而不是流程/服务。

黑盒导出器

黑盒导出器用于监控利用 HTTP、HTTPS(通过 HTTP 探测器)、DNS、TCP 和 ICMP 的网络端点。它用于黑盒监控场景，在这种场景中，从外部源执行对目标的监控，并且监控解决方案的主人不了解目标系统的内部结构细节。以下是配置黑盒导出器的步骤。

• 步骤 5: 从prometheus文件夹中执行以下命令，以验证 Prometheus 配置图和部署是否顺利运行。

• 命令: kubectl get all -n= prometheus

• 第六步:通过 https://8080-dot-10790352-dot-devshell.appspot.com/targets 登录 Prometheus GUI 查看blackbox_http终点，如图 9-37 所示。

• 第 7 步:单击 Prometheus GUI 中的 Graph 并执行以下查询，通过连接 Sock Shop 应用 URL 的阶段 http://34.70.226.32:80 和作业"blackbox"(图 9-38 中显示的 Sock Shop 应用 URL 在您的情况下可能会有所不同)来获得 HTTP 请求的持续时间。

• 查询:

• probe_http_duration_seconds{instance="http://34.70.226.32/",job="blackbox",phase="connect"}

• $kubectl delete configmaps prometheus-server-conf -n=prometheus

• $kubectl create -f configMap.yaml

• $kubectl delete deployment prometheus-deployment -n prometheus

• $kubectl apply -f prometheus-deployment.yaml -n prometheus

• 步骤 1: 导航到prometheus文件夹，执行下面的 Helm 命令，安装黑盒导出器。黑盒导出器内容将从以下 GitHub 网址下载: https://github.com/helm/charts/tree/master/stable/prometheus-blackbox-exporter 。

• 命令: helm install --name blackbox-exporter stable/prometheus-blackbox-exporter

• 输出:数字 9-33 和 9-34 显示前一条命令的输出。

• 步骤 2: 从prometheus文件夹中执行以下命令，获取在 Prometheus ConfigMap 文件中配置黑盒导出器所需的黑盒服务细节，例如 clusterip (10.81.9.39)和 port (9115/TCP)。

• 命令: kubectl get svc

• 输出:图 9-35 显示前一条命令的输出。

• 步骤 3: 现在让我们在 Prometheus 中通过 Blackbox exporter 配置 HTTP 探针。导航到prometheus文件夹并打开configMap.yaml。找到名为“job_name: 'blackbox'的部分，并修改以下条目:

  • job_name : 该字段表示作业的名称，在我们的例子中是blackbox。

  • metrics_path : 该字段表示用于从目标应用获取度量的 HTTP 资源路径。

  • params : 该部分下有一个名为modules的子部分。我们使用该模块进行 HTTP 200 响应监控。

  • static_configs : 这个部分有一个名为targets的小节。在targets下面提到的网址是指你要监控的应用的网址。您可以用我们在第八章中部署的 sock Shop 应用 URL 来替换它。

    • relabel_configs : 在本节中，用我们之前取的黑盒服务 IP:port 值修改replacement下的 URL 条目，例如 10.81.9.39:9115，如图 9-36 所示。

• 步骤 4: 执行以下命令，应用来自prometheus文件夹的 Prometheus 配置图和部署中的更改。

摘要

在本章中，你学会了使用 Prometheus 来监视 GKE。在下一章中，通过动手练习，您将看到如何使用基于 CI/CD 的自动化流水线来启用容器监控。

十、GKE 集群、应用和监控部署的自动化

本章提供了使用基础设施即代码(IaC)和 CI/CD 流水线来自动部署容器生态系统基础设施、应用和监控的实际操作步骤，包括以下内容:

• 清理 GKE 环境命名空间

• 安装 Jenkins

• 为 Jenkins Slave 创建服务

• GKE 供应、应用部署和 Sysdig 代理，使用 Jenkins 流水线

• 从 Jenkins 流水线中删除 GKE 集群。

介绍

随着新平台和不断变化的技术的兴起，建立基础架构并在其上部署应用变得越来越复杂和耗时。此外，使用手动方法设置应用和基础架构增加了人为错误和安全风险的可能性。此外，一旦完成了基础设施的供应和应用部署，还必须管理其他方面，如可维护性、可伸缩性、容错性能等。

IaC 或基础设施即代码的兴起使得应用服务的重建从源代码存储库、应用数据备份和混合云 IaaS 或 PaaS 资源开始。我们利用基础架构和应用组件的规范定义，以可预测的方式调配和管理我们的基础架构。这意味着一个应用，不管它的环境或者托管在哪里，都可以完全从零开始，用一个预定义的需求列表来构建。同样的代码可以在生产、试运行和本地开发环境中运行。

另一个主要好处是构建的一致性。如果您必须管理多个环境，如开发、QA、试运行、生产等。，从相同的代码基础上构建它们，确保它们都以完全相同的方式运行，并遵守相同的策略/标准集。

以下是 IaC 工具如何操作的高级视图(图 10-1 ):

图 10-1

IaC 如何工作

1. 您在文件中描述了所需的基础架构资源(例如，具有三个公共子网的虚拟网络，其中一个子网上的计算实例连接了一个数据块卷)。我们不需要描述如何创建资源，因为 IaC 解决方案管理着这种复杂性，并为开发人员或基础设施运营团队提供了一个抽象视图来关注服务定义部分。

2. IaC 工具通常会扫描描述服务定义代码，并在创建新资源之前验证资源是否已经存在。

3. 如果资源不存在，则创建它们。

4. 如果资源已经具有相同的属性，则不采取任何操作(因为您所期望的已经存在)。

5. 如果找到有差异的匹配资源，IaC 工具会认为您希望对它们进行更改，并使更改发生。

6. 在任何情况下，该工具都不会抛出错误/失败/创建意外的重复资源，因为这些操作是等幂的。

随着 DevOps 的不断发展，开发人员找到了加强 IaC 和容器集成的方法，因为它们是相辅相成的。容器将 IaC 作为核心组件合并到开发周期中。

我们可能需要配置一个容器协调器，比如 Kubernetes，以保持一定数量的映像副本运行，我们可能需要其他基础设施和资源，比如负载均衡器、DNS 条目、TLS 证书、仪表板、警报和日志记录。云中的容器化应用可能看起来像下图(图 10-2 )，其中容器映像只是整个应用的一部分。

图 10-2

容器映像之外的容器化应用组件

完整的应用通常是容器映像和包含所有这些配置的 IaC 模板的组合。该映像捆绑了应用的所有依赖项，比如系统库，所以理想情况下，它应该在开发和生产环境中完全相同地运行。但是，如果环境是手动部署的，那么由于配置的差异，同一映像可能无法跨多个环境工作。现在，为了让应用表现相同，在这些环境中使用完全相同的基础架构配置也很重要。

通过在 CI/CD 流水线中使用 IaC 解决方案，我们现在可以轻松管理基础架构和应用组件的配置和修改，而无需担心配置不匹配、安全风险、人为错误等问题。图 10-3 显示了我们发布流程的一个简化示例。

图 10-4

编排应用和 sydig 代理安装

图 10-3

CI/CD 流水线利用 IaC 自动监控容器

IaC 模板包含与容器相关的配置和底层基础设施(例如，负载均衡器)。在流水线的“构建”阶段，构建并推送容器映像，并将新容器映像的唯一 ID 作为代码模板插入到基础结构中。流水线的每个阶段，如“开发”和“生产”，然后部署相同的基础设施作为代码模板。这可确保每个环境都以可预测、标准化和加速的方式部署，并根据要求提供所有必需的控制和最佳实践。同样的概念现在可以扩展到还包括启用操作控制，如监控、安全、备份等。确保在任何环境中部署应用服务时，其所有必要的操作组件集成都可用。

在接下来的部分中，我们将带您进行一次实践练习，以使用gcloud命令行界面工具和 Jenkins。在本章的后面，我们还将介绍使用 Jenkins 的应用部署场景。

清理 GKE 环境命名空间

在我们开始之前，让我们清理一下在第九章中创造的 GKE 环境。清理之后，我们将在 Jenkins 中设置自动化流程，以创建集群、防火墙、应用部署、Sysdig 代理安装和集群删除。首先，我们将删除 GCP 现有的 GKE 集群名称clustertutorial,我们在前面章节中提到的 Sock Shop 应用，以及 Sysdig 代理，它是在前面章节中手动配置的。

登录到 GCP 控制台，导航到 Kubernetes 引擎，然后单击集群。接下来，选中集群名称的复选框:start with clustertutorial，然后点击页面顶部最右侧的 Delete 按钮，删除集群，如图 10-5 所示。

图 10-5

GKE 集群集群教程删除

环境设置

在本节中，我们将使用gcloud来创建/删除 GKE 集群和防火墙规则。Sysdig 将用于监控容器生态系统。为了协调所有这些步骤，我们将使用 Jenkins。

在安装 Jenkins(版本 2.2.4.5)之前，我们将首先在 GCP 创建一个 VM，然后在 VM 上安装 Java、kubectl 和 Docker。

图 10-6

GCP 计算引擎

• 第一步:登录 GCP 控制台，导航到计算引擎，选择虚拟机实例，如图 10-6 所示。

图 10-7

用于创建虚拟机的 GCP 虚拟机实例

• 步骤 2: 一旦虚拟机实例页面打开，点击创建实例按钮，创建一个新的虚拟机(图 10-7 )。

图 10-8

GCP 虚拟机实例创建

• 步骤 3: 选择任何合适的名称(例如，我们将我们的虚拟机命名为 devopsbox)，并选择区域 us-central1(爱荷华州)和区域 us-central 1-a(图 10-8 )。

图 10-8.2

在 GCP 创建虚拟机—续

图 10-8.1

在 GCP 创建虚拟机

• 步骤 4: 创建一个机器类型为 n1-standard-2 的虚拟机(图 10-8.1 和 10-8.2 )。

图 10-8.3

在 GCP 创建虚拟机—续

• 步骤 5: 为服务帐户选择应用引擎默认值，并选中防火墙部分中的允许 HTTP 流量。单击“create”按钮，以调配虚拟机。这将确保我们可以从外部网络访问我们的 Jenkins 实例，如图 10-8.3 所示。

图 10-8.4

在 GCP 创建虚拟机—续

• 第 6 步:一旦创建了一个新的虚拟机，你会在虚拟机实例页面看到同样的内容，如图 10-8.4 所示。

图 10-8.5

连接虚拟机

• 第七步:要连接新创建的虚拟机，点击开始，然后在浏览器窗口中选择打开，如图 10-8.5 所示。

设置停靠站

现在，我们将在 GCP 虚拟机上使用 19.03.8 版本的 Docker CE 来建立基于 Docker 的容器生态系统。

图 10-9.1

Docker 安装—续

图 10-9

Docker 设备

• 步骤 1 :通过执行以下命令来更新包。结果将如图 10-9 和 10-9.1 所示。

$ sudo apt update

图 10-9.3

Docker 安装—续

图 10-9.2

Docker 设备

• 步骤 2 :通过执行以下命令，安装其他必备包。结果将如图 10-9.2 和 10-9.3 所示。

$ sudo apt install apt-transport-https ca-certificates curl gnupg2 software-properties-common

图 10-9.4

坞站安装-contined

• 步骤 3 :通过执行以下命令，为 Docker 存储库添加一个 GPG 键。输出如图 10-9.4 所示。

$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add –

图 10-9.5

Docker 设备

• 步骤 4 :通过执行以下命令，将 Docker 存储库添加到 APT 源代码中。该命令的输出如图 10-9.5 所示。

$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"

图 10-9.6

Docker 安装—续

• 步骤 5 :通过执行以下命令，用新添加的 repo 中的 Docker 包更新包数据库。结果如图 10-9.6 所示。

$ sudo apt update

图 10-9.8

Docker 安装—续

图 10-9.7

Docker 安装—续

• 步骤 6 :执行以下命令，确保从 Docker repo 安装，而不是默认的 Debian repo。命令的结果如图 10-9.7 和 10-9.8 所示。

$ apt-cache policy docker-ce

图 10-9.10

Docker 社区版安装—续

图 10-9.9

Docker 社区版安装

• 步骤 7 :运行以下命令安装 Docker 社区版 19.03.8。结果如图 10-9.9 和 10-9.10 所示。

$ sudo apt install docker-ce

图 10-9.11

检查 Docker 安装的状态

• 步骤 8 :通过执行以下命令检查 Docker 服务的状态。该命令的结果如图 10-9.11 所示。

$ sudo systemctl status docker

图 10-9.12

Docker 安装— username增加

• 第 9 步:为了避免每次运行 Docker 命令时都键入sudo，通过执行以下命令将username添加到 Docker 组。结果如图 10-9.12 所示。

$ sudo usermod -aG docker ${USER}

图 10-9.13

验证 Docker 版本

• 第 10 步:验证更改，退出虚拟机，重新连接。

• 步骤 11 :通过执行以下命令验证 Docker 版本。结果如图 10-9.13 所示。

$ docker version

设置 kubectl

为了在 GKE 上连接和部署应用和 Sysdig 代理，必须在 VM 上安装 kubectl。

• 步骤 1 :执行以下命令安装 kubectl。

图 10-10

安装 kubectl

• 前面代码的输出如图 10-10 所示。

$ curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl

图 10-10.1

使 kubectl 可执行

• 步骤 2 :用下面的命令使 kubectl 可执行。结果如图 10-10.1 所示。

$ chmod +x ./kubectl

• 步骤 3 :用下面的命令将 kubectl 移动到 usr/local/bin。

图 10-10.2

kubectl 安装验证

• 步骤 4 :通过执行以下命令来验证 kubectl 安装。结果如图 10-10.2 所示。

$ sudo mv ./kubectl /usr/local/bin/kubectl

$ kubectl version –client

安装 Java 开发工具包(JDK)

为了配置 Jenkins 从属服务器，需要在虚拟机上安装 JDK。执行以下步骤来安装 Java 版本 1.8.0_242。

图 10-11

JDK 装置

• 步骤 1 :通过执行以下命令来更新包。结果如图 10-11 所示。

$ sudo apt-get update

图 10-11.1

JDK 装置

• 第二步:执行以下命令，安装 JDK。结果如图 10-11.1 所示。

$ sudo apt-get install default-jdk

图 10-11.2

JDK 安装—续

• 第三步:按 Y 键继续 Java 设置，如图 10-11.2 所示。

图 10-11.3

JDK 安装验证

• 步骤 4 :通过执行以下命令来验证 Java 安装。结果如图 10-11.3 所示。

$ java -version

安装 Jenkins

为了协调 GKE 配置和应用部署，我们将使用 Jenkins 版本 2.204.1。执行以下步骤来安装和配置 Jenkins。

图 10-12

Jenkins 主目录安装

• 第一步:执行下面的命令创建Jenkins_home directory。这是 Jenkins 保存其所有配置和作业的地方，在用户的主目录下(例如，/home/gcptutorial)。命令的结果如图 10-12 所示。

$ mkdir Jenkins_home

图 10-12.2

Jenkins 安装—续

图 10-12.1

Jenkins 装置

• 步骤 2 :执行以下命令安装 Jenkins。结果如图 10-12.1 和 10-12.2 所示。

$ docker run -d --name jenkins -p 8080:8080 -p 50000:50000 -v /home/gcptutorialmail/jenkins_home:/var/jenkins_home jenkins/jenkins:lts

图 10-12.3

获取 Jenkins 初始管理员密码

• 步骤 3 :执行以下命令获取 Jenkins secrets 密码。结果如图 10-12.3 所示。

$ sudo cat jenkins-data/secrets/initialAdminPassword

我们必须设置防火墙规则，以允许端口 8080 和 50000 上的访问，从而连接 Jenkins 主服务器和它的从服务器。

图 10-13

防火墙规则页面

• 步骤 1 :为 Jenkins 创建一个防火墙规则，允许虚拟机获得端口 8080 和 50000 的入站连接。进入 VPC 网络，点击防火墙规则，如图 10-13 所示。

图 10-13.1

为 Jenkins 创建防火墙规则

• 第二步:在防火墙页面点击创建防火墙规则，如图 10-13.1 所示。

图 10-14.2

为 Jenkins 创建防火墙规则—续

图 10-14.1

为 Jenkins 创建防火墙规则—续

图 10-14

为 Jenkins 创建防火墙规则—续

• 第三步:填写防火墙选项，如下:

• Name :如前所述，选择一个有意义的名字，比如 firewall-rule-devopsbox。

• 日志选项:选择关闭。

• 网络:选择默认。

• 优先级 : 1000

• 交通方向:入口

• 匹配动作:允许

• 目标:选择指定的目标标签，并将 devopsbox 作为该防火墙规则将应用的目标标签的名称。

• 源 IP 范围:前述的 0.0.0.0/0

• 协议和端口:选择指定的协议。

• 端口:选择 tcp 作为协议，上述端口 8080 和 50000。

• 点击创建按钮，如图 10-14 、 10-14.1 和 10-14.2 所示。

图 10-15

获取 Jenkins 外部 IP

• 第 4 步:要访问 Jenkins，导航至计算引擎并选择虚拟机实例。获取外部 IP，例如 34.71.75.255，并复制它。现在导航到网页浏览器中的新标签页，粘贴端口为 8080 的外部 URL(如http://34.71.75.255:8080)以打开 Jenkins 网页，如图 10-15 所示。

图 10-16

第一次访问 Jenkins 控制台

• 第五步:使用从“安装 Jenkins”部分的第三步“解锁 Jenkins”页面获取的 secrets 密码，点击继续按钮，如图 10-16 所示。

图 10-17

选择附加的 Jenkins 功能

• 第六步:点击安装建议插件选项，安装创建流水线所需的各种插件，如图 10-17 所示。

图 10-18

选择建议的 Jenkins 插件选项

• 第七步:点击继续进行，如图 10-18 。

图 10-19

Jenkins 第一个管理员用户设置

• 第八步:在弹出的表单上填写用户名、密码、全名、邮箱等详细信息，点击保存并继续，如图 10-19 所示。

图 10-20

Jenkins 实例配置页

• 第九步:点击保存完成继续，如图 10-20 。

图 10-21

Jenkins 准备好了。

• 步骤 10 :点击开始使用 Jenkins 按钮完成安装，如图 10-21 所示。

图 10-22

第一次 Jenkins 控制台

• 您将看到 Jenkins 控制台的以下屏幕(图 10-22 )。

Jenkins 从机设置

执行以下步骤来设置 Jenkins 从属可执行文件。

• 步骤 1 :通过 root 用户执行以下命令，导航到/home directory of user and create sub directory jenkins_slave，授予 700 权限。Jenkins_node directory将被 Jenkins 节点用来连接和执行命令。

图 10-22.2

设置 Jenkins 节点—续

图 10-22.1

设置 Jenkins 节点

• 步骤 2 :导航到前面步骤中用于访问 Jenkins 的 Jenkins URL。使用您在前面步骤中设置的管理员密码。导航到管理 Jenkins➤管理节点➤新节点，如图 10-22.1 和 10-22.2 所示。

$ cd ~
$ mkdir jenkins_slave
$ chmod 700 jenkins_slave

图 10-23

设置 Jenkins 节点

• 步骤 3 :使用以下值填写表格:

• 名称:使用您选择的任何名称。在我们的例子中，我们选择了前面提到的 devopsbox。

• 描述:使用任何有意义的描述，例如 devopsbox。

• :如前所述，我们输入了 1，来表示与这个 Jenkins 奴隶相关的执行者的数量。

*** 远程根目录:Jenkins slave 存储其工作空间和配置的文件夹路径。为此，我们创造了/var/Jenkins_home。

*   **标签**:使用前面提到的 devopsbox 标签。

*   **用途**:选择尽可能使用该节点。

*   **启动方式**:连接主机选择启动代理。

*   图 10-23 显示了用前面的值完成的表格。** 

**

图 10-24

验证 Jenkins 节点

• 第四步:点击保存按钮，保存配置。

• 步骤 5 :通过查看 Jenkins 控制台状态，验证代理配置成功。

• 代理已配置，但尚未与 Jenkins master 连接，如图 10-24 所示。

图 10-25

复制 Jenkins 节点的agent.jar链接 URL

• 第六步:连接 Jenkins master，点击 devopsbox 一次，打开代理页面，右键点击 agent.jar，复制链接地址，如图 10-25 所示。

图 10-27

虚拟机上 Jenkins agent.jar文件的下载完成

图 10-26

在虚拟机上下载 Jenkins agent.jar文件

• 第 7 步:现在登录虚拟机并导航到jenkins_slave目录，执行以下命令下载 Jenkins 从 jar。命令的结果如图 10-26 和 10-27 所示。

$ cd Jenkins_slave
$ wget http://35.192.203.53:8080/jnlpJars/agent.jar

图 10-28

验证虚拟机上的 Jenkins agent.jar文件

• 步骤 8 :通过执行以下命令，验证agent.jar是否下载。结果如图 10-28 所示。

$ ls -ltr

图 10-29

更改虚拟机上 Jenkins agent.jar文件的权限

• 步骤 9 :通过执行以下命令，将权限改为 700，并验证agent.jar的权限。结果如图 10-29 所示。

$ chmod 700 agent.jar
$ ls -ltr

为 Jenkins Slave 创建服务

现在，我们将创建基于 Linux 的服务，从 Jenkins 主机连接 Jenkins 从机。

图 10-31

在虚拟机上创建 Jenkins 从属服务—续

图 10-30

在虚拟机上创建 Jenkins 从属服务

• 第一步:导航到/etc/systemd/system目录，创建一个jenkinsslave.service文件。复制以下内容并保存文件，如图 10-30 和 10-31 所示。

[Unit]
Description=jenkinsslave
Wants=network-online.target
After=network-online.target
[Service]
Type=simple
ExecStart=/usr/bin/java -jar /home/gcptutorialmail/jenkins_slave/agent.jar -jnlpUrl http://35.225.33.158:8080/computer/devopsbox/slave-agent.jnlp \
-secret 24b23df5ca08cc4ece2f3a511e41ffc1c96729fc81ea8cdfb1786d6e11c47958 -workDir "/var/jenkins_home"
Restart=always
RestartSec=1
[Install]
WantedBy=multi-user.target

图 10-32

在虚拟机上创建 Jenkins 从属服务—续

• 步骤 2 :要启动服务，通过执行以下命令切换到 root 用户。前面命令的结果如图 10-32 所示。

$ sudo su –

图 10-33

在虚拟机上启动/验证 Jenkins 从属服务的状态

• 步骤 3 :执行以下命令，启动并验证服务。结果如图 10-33 所示。

$ systemctl start jenkinsslave
$ systemctl status jenkinsslave

图 10-34

从根用户虚拟机注销

• 步骤 4 :执行以下命令，退出 root 用户会话。结果如图 10-34 所示。

$ exit

图 10-35

在 Jenkins 节点页面上验证 Jenkins 代理是否已连接

• 步骤 5 :为了验证代理是否已连接并正在运行，导航到 Jenkins➤节点，然后单击 devopsbox。

• 你会看到代理已经连接，如图 10-35 所示。

GKE 供应、应用部署和 Sysdig 代理，使用 Jenkins 流水线

现在，我们将创建 Jenkins 流水线CICD-GKEProv-Sysdig来自动化以下流程。

图 10-36

创建 Jenkins 流水线

• 代码克隆:从以下 GitHub 库克隆 Sock Shop 和 Sysdig 代理部署代码: https://github.com/dryice-devops/GCP.git 。

• 创建集群:用gcloud在 GKE 创建一个 Kubernetes 集群clustertutorial。

• 创建防火墙规则:为 Sysdig 代理的端口 6443 创建一个入口/出口防火墙规则。

• 部署应用:通过 kubectl 在 EKS 上部署 Sock Shop 应用。

• 部署 Sysdig 代理:通过 kubectl 在 EKS 上部署 Sysdig 代理。

• 步骤 1 :导航至以下网址，访问 Jenkins。使用在前面步骤中设置的管理员密码。点击新建项目，如图 10-36 所示。

• URL : http://EXTERNAL_IP:8080

图 10-36.1

创建 Jenkins 流水线

• 第二步:填写表格。输入“CICD-GKEProv-Sysdig”作为项目名称，并选择 Pipeline，因为我们在 Jenkins 中使用 Pipeline 作为代码来自动化之前定义的流程。点击确定，如图 10-36.1 继续。

图 10-37

创作 Jenkins 剧本

• 第三步:点击 Pipeline，会显示一个脚本框，我们将在其中编写 Jenkins 脚本，如图 10-37 所示。

图 10-37.1

保存 Jenkins 脚本

• 第四步:将从 https://github.com/dryice-devops/GKE/blob/master/jenkinsfile-gke-creation 中取出的jenkinsfile-gke-creation文件的jenkinsfile复制到同一个脚本框中，然后点击保存按钮，如图 10-37.1 所示。

Jenkinsfile 的创建包括以下五个阶段:

1. 从 GitHub 克隆代码:在这个阶段，我们从下面的 GitHub 库克隆代码: https://github.com/dryice-devops/GCP.git 。

   The repository contains the following files:

   1. complete-demo.yaml:一个配置文件，包含 Kubernetes 上 Sock Shop 应用部署的细节，如第四章所述。

   2. sysdig-agent-clusterrole.yaml:为 Sysdig 代理创建集群角色的配置文件。这在第七章中有所涉及。

   3. sysdig-agent-configmap.yaml:为 Sysdig 代理创建 ConfigMap 的配置文件。这在第七章中有所解释。

   4. sysdig-agent-daemonset-v2.yaml:为 Sysdig 代理创建 daemonset 的配置文件，在第七章中有所说明。

2. 在 GKE 创建集群集群教程:在这个阶段，我们使用下面的命令在 GKE 通过gcloud创建三个基于节点的 Kubernetes 集群，命名为clustertutorial。

sh "gcloud container clusters create clustertutorial --num-nodes=3 --zone=us-central1-a"

图 10-37.3

Jenkins 脚本中的入站/出站防火墙规则—续

图 10-37.2

Jenkins 脚本中的入站/出站防火墙规则

1. 在 GKE 创建入站/出站防火墙:在 Jenkinsfile 配置的第三阶段，我们将使用图 10-37.2 和图 10-37.3 所示的gcloud命令为 Sysdig 代理在端口 6443 上的入站和出站连接创建有状态防火墙规则。

2. 在 GKE 集群上部署应用:在这个阶段，我们将创建sock-shop名称空间，并在 GKE 集群上部署 Sock Shop 应用，方法是使用下面的 kubectl 命令。

   sh " export KUBECONFIG=~/.kube/config &&  kubectl create namespace sock-shop "
   
   sh " export KUBECONFIG=~/.kube/config && kubectl apply -f '${WORKSPACE}/complete-demo.yaml'  "
   
   

3. 在 GKE 部署 Sysdig:在这个阶段，我们通过 kubectl 在 GKE 部署 Sysdig 代理。

   1. 通过执行以下命令来创建ns名称空间:

      sh " export KUBECONFIG=~/.kube/config && kubectl create ns sysdig-agent"

   2. 在下面的命令中，您必须根据 Sysdig 设置访问键(用黄色突出显示)来更改访问键。

      sh " export KUBECONFIG=~/.kube/config && kubectl create secret generic sysdig-agent --from-literal=access-key=effdab9c-9554-4274-9042-9e8331e1d78b -n sysdig-agent "

   3. 通过执行以下命令，为 Sysdig 代理创建一个集群角色:

      sh " export KUBECONFIG=~/.kube/config && kubectl apply -f '${WORKSPACE}/sysdig-agent-clusterrole.yaml' -n sysdig-agent "

   4. 通过执行以下命令，在 GKE 集群中为 Sysdig 代理创建一个服务帐户:

      sh " export KUBECONFIG=~/.kube/config && kubectl create serviceaccount sysdig-agent -n sysdig-agent "

   5. 定义授予集群角色中的 Sysdig 代理角色的集群角色绑定。

      sh " export KUBECONFIG=~/.kube/config && kubectl create clusterrolebinding sysdig-agent --clusterrole=sysdig-agent --serviceaccount=sysdig-agent:sysdig-agent "

   6. 使用以下命令应用sysdig-agent-configmap.yaml文件。您不必更改该文件中的任何内容。

      sh " export KUBECONFIG=~/.kube/config && kubectl apply -f '${WORKSPACE}/sysdig-agent-configmap.yaml' -n sysdig-agent"

   7. 使用以下命令应用daemonset-v2.yaml文件。您不必更改该文件中的任何内容。

      sh "export KUBECONFIG=~/.kube/config && kubectl apply -f '${WORKSPACE}/sysdig-agent-daemonset-v2.yaml' -n sysdig-agent"

图 10-38

执行 Jenkins 脚本

• 第五步:点击【立即构建】执行 Jenkins 作业，如图 10-38 所示。

图 10-39.2

查看 Jenkins 日志中的应用和 Sysdig 代理部署—续

图 10-39.1

查看 Jenkins 日志中的应用和 Sysdig 代理部署—续

图 10-39

查看 Jenkins 日志，了解应用和 Sysdig 代理的部署情况

• 步骤 6 :一旦作业成功执行，以下构建历史将以蓝色显示构建编号。如果有错误，它将是红色的。它还在阶段视图下显示了阶段。要查看日志，请单击内部版本号(#)。接下来，单击控制台输出。图 10-39 、 10-39.1 和 10-39.2 说明了上述情况。

在日志控制台中，向下滚动屏幕的四分之三，得到新创建的 EKS 节点的详细信息，如图 10-39.3 、 10-39.4 、 10-39.5 和 10-39.6 所示。

图 10-39.6

查看 Jenkins 日志中的应用和 Sysdig 代理部署—续

图 10-39.5

查看 Jenkins 日志中的应用和 Sysdig 代理部署—续

图 10-39.4

查看 Jenkins 日志中的应用和 Sysdig 代理部署—续

图 10-39.3

查看 Jenkins 日志中的应用和 Sysdig 代理部署—续

图 10-40

查看 GCP 控制台

• 第 7 步:导航到你的 GCP 账户控制台，点击计算。接下来，选择 Kubernetes 引擎，然后选择集群，如图 10-40 。

图 10-40.1

查看 GCP 控制台—续

• 您将看到 GKE clustertutorial集群处于活动状态。这是我们通过 Jenkins 和gcloud创建的同一个集群(参见图 10-40.1 )。

图 10-40.2

从 GCP 控制台获取 Sock Shop 应用的 IP 地址

• 现在点击 Services & Ingress，获取 Sock Shop 应用的 URL，如图 10-40.2 所示。

图 10-40.4

打开袜子商店应用

图 10-40.3

从 GCP 控制台获取 Sock Shop 应用的 IP 地址—续

• 导航到前端服务并复制负载均衡器类型的端点，以便打开 Sock Shop 应用，如图 10-40.3 和 10-40.4 所示。

图 10-41

查看 Sysdig 控制台

• 步骤 8 :现在让我们导航到 Sysdig 控制台，确认我们的 GKE 集群已经被添加到 Monitor 下。导航到 Sysdig 网址( https://sysdig.com/ )，用你的凭证登录，如图 10-41 所示。

图 10-42

查看 Sysdig 控制台—续

• 导航浏览➤主机和容器，然后选择按容器概述，如图 10-42 所示。

图 10-43

查看 Sysdig 控制台—续

• 现在，根据图 10-43 ，要验证 Sock Shop 应用是否已部署，请单击探索➤主机和容器➤容器限制。

图 10-44

查看 Sysdig 控制台—续

• 将指针悬停在已用 CPU 份额的图表上。您将看到袜子店容器名称(图 10-44 )。

图 10-46

查看 Sysdig 控制台—续

图 10-45

查看 Sysdig 控制台—续

• 点击➤网络➤总览，如图 10-45 和 10-46 所示。

图 10-48

查看 Sysdig 控制台—续

图 10-47

查看 Sysdig 控制台—续

• 点击浏览➤容器化应用，获取容器化应用的详细信息，如图 10-47 和 10-48 所示。

图 10-49

查看 Sysdig 控制台—续

• 选择任何以weaveworksdemos开头的容器，以获取其详细信息，例如，输入与输出网络字节、按应用/端口划分的网络字节等。(图 10-49 )。

从 Jenkins 流水线中删除 GKE 集群

为了自动化 GKE 集群的清理过程，我们将创建一个 Jenkins 流水线，使用gcloud来清理集群。

要设置流水线，请在删除 GKE 集群clustertutorial和 Sysdig 代理的入口/出口防火墙规则后执行以下步骤。

图 10-50

通过 Jenkins 清理 GKE 集群

• 第一步:打开 Jenkins(网址:http://EXTERNAL_IP:8080)点击新项目(图 10-50 )。

图 10-51

通过 Jenkins 清理 GKE 集群—续

• 步骤 2 :填写表格，输入“删除-GKE-集群”作为项目名称，并选择流水线，因为我们在 Jenkins 中使用流水线作为代码来自动执行之前定义的清理过程。接下来，点击确定按钮(图 10-51 )。

图 10-52

通过 Jenkins 清理 GKE 集群—删除clustertutorial

• 第三步:从下面的 GitHub 资源库中复制jenkinsfile-delete-gke文件中的代码: https://github.com/dryice-devops/GKE 。将文件粘贴到脚本部分，然后单击保存按钮。

• 在这个 Jenkins 文件中，我们使用gcloud命令删除名为clustertutorial的 GKE 集群以及创建的名为sysdig-agent-inbound-firewall-rule和sysdig-agent-outbound-firewall-rule的入站和出站防火墙规则，方法是执行以下命令(另请参见图 10-52 )。

• sh "echo 'Y' | gcloud container clusters delete clustertutorial --zone=us-central1-a"

• sh "gcloud compute firewall-rules delete sysdig-agent-inbound-firewall-rule"

• sh "gcloud compute firewall-rules delete sysdig-agent-outbound-firewall-rule"

图 10-53

通过 Jenkins 清理 GKE 集群—立即构建

• 第四步:点击【立即构建】执行 Jenkins 作业，如图 10-53 所示。

图 10-57

通过 Jenkins 清理 GKE 集群—控制台输出

图 10-56

通过 Jenkins 清理 GKE 集群—控制台输出

图 10-55

通过 Jenkins 清理 GKE 集群—单击内部版本号查看日志

图 10-54

通过 Jenkins 清理 GKE 集群—构建历史

• 步骤 5 :一旦作业成功执行，将显示构建历史。阶段显示在阶段视图下(图 10-54 )。要查看日志，点击内部版本号，如图 10-55 所示。点击控制台输出(图 10-56 ，输出结果如图 10-57 所示。

图 10-58

通过 Jenkins 清理 GKE 集群—与删除的防火墙规则相关的输出

• 在日志控制台中，向下滚动屏幕以获得关于被删除的集群和防火墙规则的信息(图 10-58 )。

图 10-59

清理 GCP 仪表板中的 GKE 集群

• 第 6 步:导航到你的 GCP 账户控制台，点击计算。选择 Kubernetes 引擎，然后选择集群。您将看到 GKE 集群名称clustertutorial正在被删除(图 10-59 )。

图 10-60

清理 GCP 仪表板中的 GKE 集群—续

• 等待 5-10 分钟，以完全删除集群。一旦它被删除，您将看到以下屏幕(图 10-60 )。

摘要

在本章中，我们提供了使用云原生gcloud命令行工具作为 IaC 解决方案和 Jenkins 作为 CI/CD 解决方案的步骤，以自动化容器基础设施的部署，通过 Sysdig 代理实现监控，并最终部署容器化的应用，从而得出本书的结论。我们在本书中涵盖了 GKE 生命周期管理的各个方面，并试图让有实践经验的读者理解 GKE 管理背后的核心概念，包括网络、安全、监控、自动化等。**