IBM 后端开发（二）

使用 SQL 和数据库开发 Django 应用程序

结构化查询语言（或 SQL）是为管理关系数据库中的数据而设计的，对于处理结构化数据非常有用。
数据是用文字、数字和图片表示的事实集合。
数据库是一个数据存储库，提供添加、修改和查询数据的功能。
关系数据库将表格数据存储为相关项目的集合，列中包含项目属性。
基本 SQL 语句包括 CREATE TABLE、INSERT、SELECT、UPDATE 和 DELETE。
非关系型数据库提供了一种灵活、可扩展的数据存储和检索方法。
关系数据库是优化存储、检索和处理大量数据的理想选择。
关系数据库管理系统（RDBMS）是一种成熟且文档齐全的技术，具有灵活性、减少冗余、易于备份和灾难恢复以及符合 ACID 标准等特点。
实体-关系模型是设计关系数据库的工具。实体变为表，属性变为列。

结构化查询语言（或 SQL）用于查询和管理数据。
SQL 对于处理结构化数据或包含实体和变量之间关系的数据非常有用。
SQL SELECT 语句从关系数据库表中检索数据。
SELECT 语句是一个查询，执行该查询得到的输出是一个结果集或结果表。
SELECT 语句最简单的语法是：SELECT * from TableName
SQL INSERT 语句通过添加行将数据插入关系数据库表中。
INSERT 语句的语法是INSERT INTO TableNameColumnName VALUES (values)
对于 INSERT 语句，Values 子句中提供的值必须等于列名列表中指定的列名数。这样可以确保每一列都有一个值。
SQL UPDATE 语句用于读取和修改数据。
UPDATE 语句的语法如下： UPDATE [TableName] SET [[ColumnName]=[Value]] <WHERE [Condition]>
SQL DELETE 语句用于从表中删除数据。
DELETE 语句的语法是DELETE FROM [TableName] <Where [Condition]>
WHERE 子句指定 SQL 语句（如 SELECT、DELETE 或 UPDATE）将执行的表中记录。

SQL 和关系数据库入门

包装/方法	说明	代码示例
SELECT	根据指定列从一个或多个表中检索数据。	SELECT column1, column2 FROM table_name；
FROM	指定从中检索数据的表。	SELECT column1, column2 FROM table_name；
WHERE	根据指定条件过滤数据。	SELECT column1, column2 FROM table_name WHERE condition；
ORDER BY	根据指定列以升序或降序对结果集排序。	SELECT column1, column2 FROM table_name ORDER BY column1 ASC；
GROUP BY	根据指定列分组记录。	*SELECT column1, COUNT() FROM table_name GROUP BY column1；**
分组	根据指定条件过滤分组数据。	*SELECT column1, COUNT() FROM table_name GROUP BY column1 HAVING COUNT() > 1；*
INSERT INTO	向表中插入数据。	INSERT INTO table_name (column1, column2) VALUES (value1, value2)；
更新	根据指定条件修改表中的数据。	UPDATE table_name SET column1 = value1 WHERE condition；
DELETE FROM	根据指定条件删除表中的数据。	DELETE FROM table_name WHERE condition；
连接	根据相关列合并多个表中的记录。	SELECT column1, column2 FROM table1 JOIN table2 ON table1.column = table2.column；
内连接	只返回两个表中匹配的记录。	SELECT column1, column2 FROM table1 INNER JOIN table2 ON table1.column = table2.column；
左连接	返回左表中的所有记录和右表中的匹配记录。	SELECT column1, column2 FROM table1 LEFT JOIN table2 ON table1.column = table2.column；
右连接	返回右表中的所有记录和左表中的匹配记录。	SELECT column1, column2 FROM table1 RIGHT JOIN table2 ON table1.column = table2.column；
全连接	返回两个表中的所有记录，无论是否匹配。	SELECT column1, column2 FROM table1 FULL JOIN table2 ON table1.column = table2.column；
区分	从列中返回唯一值。	SELECT DISTINCT column1 FROM table_name；
计数	计算列中的行数或非空值。	*SELECT COUNT() FROM table_name；或SELECT COUNT(column1) FROM table_name；**
求和	计算列中数值的总和。	SELECT SUM(column1) FROM table_name；
平均值	计算列的平均值。	SELECT AVG(column1) FROM table_name；
MAX	查找列中的最大值。	SELECT MAX(column1) FROM table_name；
最小值	查找列中的最小值。	SELECT MIN(column1) FROM table_name；

CREATE、ALTER、TRUNCATE 和 DROP 定义、更改或删除数据库对象（如表）。
CREATE TABLE 语句包括定义表中列的属性，其中包括
列的名称
列的数据类型
可选值（如果需要），例如主键约束
ORDER BY 子句用于在 SQL 查询中按指定列对结果集排序。例如，"ORDER BY title "按名为 "title "的列对结果集排序。
也可以通过指明列序列号来指定列的排序。例如，"select title, pages from book ORDER BY 2 "表示排序顺序基于第二列中的值。
JOIN 操作符根据两个或多个表中某些列之间的关系，将这些表中的记录合并在一起。
被连接的表通过一个公共列建立关系，该列通常是一个表的主键，在另一个表中作为外键出现。
关系表的主键唯一标识表中的每一行。
外键是一组指向另一个实体的主键的列。
如果需要合并来自三个或更多不同表的数据，请在连接中添加新表。首先，通过匹配表 A 和表 B 的共享属性来合并它们的信息。然后，通过匹配表 B 和表 C 的共享属性来连接它们的信息。
SQL 提供多种类型的连接，如内连接（INNER JOIN）和外连接（OUTER JOIN）。您可以提取与所涉及的两个表的交集相对应的数据集，也可以选择更大的数据集。

通过 Docker、Kubernetes 和 OpenShift 介绍容器

您将学习容器的概念、功能、用例和优点。在容器新知识的基础上，您将了解 Docker 的作用，并发现 Docker 为何能赢得开发人员的青睐。您将了解什么是 Docker，熟悉 Docker 流程，并探索 Docker 的底层技术。了解开发人员和组织如何从使用 Docker 中获益，并了解哪些情况下使用 Docker 具有挑战性。接下来，学习如何使用 Dockerfile 构建容器映像，如何使用该映像创建运行中的容器，熟悉 Docker 命令行界面 (CLI)，并探索常用的 Docker 命令。您将了解 Docker 对象、Dockerfile 命令、容器映像命名，并学习 Docker 如何使用网络、存储和插件。然后，当你看到 Docker 架构组件在运行并探索使用 Docker 进行容器化时，你将吸收这些知识。在第一周结束时，你将从 Docker Hub 注册表中提取一个映像。你将使用 Docker 将映像作为容器运行，使用 Dockerfile 构建和标记映像，并将映像推送到注册表。

学习目标

构建容器镜像并将其存储在容器注册表中。
描述容器的功能、优势和用例，以及它们与虚拟机的区别。
定义 Docker 并列出一些常用的 Docker CLI 命令及其功能。
解释容器注册表的基本目的，然后描述容器注册表如何与众不同以及用户如何与之交互。
对比容器和图像。
使用 Docker 从 Docker Hub 注册表中提取映像，将映像作为容器运行，然后将映像推送到 IBM 云容器注册表。
列出 Dockerfile 中的一些常用指令，并描述如何使用 Dockerfile 构建和标记映像。
描述 Docker 架构组件并描述容器化。
解释 Docker 如何作为容器运行时工作。
描述 IBM 云容器注册中心服务。

在本课程中，您将学习如何使用当前的容器化工具和技术（如 Docker、容器注册、Kubernetes、Red Hat、OpenShift 和 Istio）构建 Cloud-native 应用程序。您还将深入了解如何在任何 Public Cloud、Private Cloud 或 Hybrid Cloud 中部署和 Scale 应用程序。

本课程所教授的技能对于软件开发、后端和 Full Stack 开发、云架构师、云系统工程师、DevOps 从业人员、站点可靠性工程师 (SRE)、云网络专家等领域的任何人都是必不可少的。

先决条件

无需事先了解容器知识。建议对云和编程概念有基本了解。

课程目标：

完成本课程后，您将能够

使用容器，学习如何在任何环境中快速移动应用程序。
使用 Docker、Kubernetes、OpenShift 和 Istio 构建云原生应用程序。
描述并利用 Kubernetes 架构来设置和使用基于整个生命周期的容器管理系统。
创建并利用 YAML 部署文件，以声明的方式配置和创建 pod、服务、ReplicaSets 等资源。

本课程共有五个 Module，如下所示。我们鼓励您每周留出几个小时的时间，以便在五周之内顺利完成所有模块。保持连贯性将最有助于您实现学习目标！

观看所有视频和阅读材料，并通过完成所有活动巩固所学知识，您将获得最大收益。

Module 1：容器和容器化

从第一周开始，学习容器的概念、Feature、Use Cases 和优势。在学习容器新知识的基础上，你将了解 Docker 的作用，并发现 Docker 为什么会成为开发者的赢家。你将了解 Docker 是什么，熟悉 Docker 流程，并探索 Docker 的底层技术。接下来，学习如何使用 Dockerfile 构建容器映像，如何使用该映像创建运行中的容器，熟悉 Docker 命令行界面 (CLI)，并探索常用的 Docker 命令。您将了解 Docker 对象、Dockerfile 命令、容器映像命名，并学习 Docker 如何使用网络、存储和插件。在第一周结束时，您将从 Docker Hub 注册表中提取一个映像。你将使用 Docker 将映像作为容器运行，使用 Dockerfile 构建和标记映像，并将映像推送到注册表。

Module 2：Kubernetes 基础知识

在本模块中，你将了解什么是容器编排。然后，探索开发人员如何使用容器编排来创建和管理复杂的容器环境开发生命周期。Kubernetes 是目前最流行的容器编排平台。您将研究 Kubernetes 的关键架构组件，包括控制平面组件和控制器。探索 Kubernetes 对象，了解 Pod、ReplicaSets 和 Deployments 等特定 Kubernetes 对象的工作原理。然后，学习开发人员如何使用 Kubernetes Command Line Interface（CLI）或 "kubectl "来操作对象、管理 Kubernetes Cluster 中的工作负载以及应用基本的 kubectl 命令。你将能区分使用命令式命令和声明式命令的利弊。在本模块结束时，你将使用 kubectl CLI 命令在实际的 Kubernetes 集群上创建资源。你将使用 Kubernetes CLI 创建一个 Kubernetes pod、创建一个 Kubernetes Deployment、创建一个 ReplicaSet，并亲眼目睹 Kubernetes 负载平衡的运行。

模块 3：使用 Kubernetes 管理应用程序

在 Modulation 3 中，你将探索 ReplicaSets、自动扩展、滚动更新、ConfigMaps、Secrets 和服务绑定，并学习如何使用这些功能来管理 Kubernetes 应用程序。您将了解 ReplicaSets 如何扩展应用程序以满足不断增长的需求，以及自动扩展如何创建基于需求的动态扩展。您将了解如何使用滚动更新来发布应用程序更新和回滚更改，而不会中断用户体验。您还将学习如何使用 ConfigMaps 和 Secrets 为您的部署提供配置变量和敏感信息，并保持代码清洁。在本模块结束时，您将扩展和更新部署在 Kubernetes 中的应用程序。

Modulation 4：Kubernetes 生态系统：OpenShift、Istio 等

在 Modulation 4 中，您将进一步了解不断发展的 Kubernetes 生态系统，并探索更多与 Kubernetes 配合使用的工具，以支持 Cloud-native 开发。您将了解 Red Hat ®OpenShift® 和 Kubernetes 之间的异同，并了解 OpenShift 架构的外观。您将了解 OpenShift 构建和 BuildConfigs 以及 OpenShift 构建策略和触发器。您还会发现 Operator 如何轻松部署整个应用程序。最后，您将了解 Istio Service Mesh 如何管理和保护应用程序服务之间的流量和通信。在本模块结束时，您将使用 oc CLI 在 OpenShift Clustering 上执行命令。您还将使用 OpenShift 的构建功能，从 Git 仓库中存储的源代码中部署应用程序。

Modulation 5：最终作业

在期末项目中，您将把本课程中学到的工具和概念付诸实践，并使用 Docker 和 Kubernetes 部署一个简单的留言簿应用程序。整个应用程序将在 OpenShift 上部署和管理。

正文：

Docker 是一个用于

开发、交付和运行容器应用程序的开放平台。

Docker 之所以受到开发人员的欢迎，是因为其简单的架构、

巨大的可扩展性以及在多个平台、环境

和地点上的可移植性。

Docker 将应用程序与基础设施（包括硬件、

操作系统和容器运行时）隔离开来。

Docker 是用 Go 编程语言编写的。

Docker 使用 Linux 内核的特性来提供其功能。

Docker 还使用命名空间来提供一个名为容器的隔离工作空间，

Docker 为每个容器创建了一组命名空间，

每个方面都在单独的命名空间中运行，访问权限仅限于该命名空间。

Docker 方法激发了更多创新，

包括诸如Docker CLI、Docker Compose和

Prometheus之类的补充工具，以及包括存储插件在内的各种插件。

使用Docker swarm或Kubernetes的编排技术，以及使用微服务和无服务器的

开发方法。

Docker 提供了以下好处。

Docker 一致且

隔离的环境可实现稳定的应用程序部署。

部署在几秒钟内完成。由@@

于 Docker 镜像很小且可重复使用，

它们可以显著加快开发过程，而且 Docker 自动化

功能有助于消除错误，简化维护周期。

Docker 支持敏捷和 CI/CD DevOps 实践。

Docker 的简单版本控制加快了测试、回滚和重新部署的速度。

Docker 可帮助对应用程序进行分段，以便于刷新、清理和修复。

开发人员协作以更快地解决问题并在需要时扩展容器，

而且 Docker 镜像独立于平台，因此它们具有很高的可移植性。

Docker 不适合具有这些品质、

需要高性能或安全性、基于 Monolith 架构、

使用丰富的 GUI 功能或执行标准桌面或有限功能的应用程序。

在这段视频中，您了解到，Docker 是一个用于开发

、交付和运行容器应用程序的开放平台。

Docker 加快了跨多个环境的部署过程。

Docker 使用命名空间技术来提供一个名为容器的隔离工作区。

Docker 为每个容器创建了一组命名空间，

每个方面都在单独的命名空间中运行，访问权限仅限于该命名空间。

Docker 支持敏捷和 CI/CD DevOps 实践。

最后，Docker 容器不太适合基于

单片架构的应用程序或需要高性能安全性的应用程序。

此图显示了正在运行的容器的开发过程。

创建和

运行容器的步骤创建 dockerfile 使用 dockerfile 创建容器镜像，并

使用容器镜像创建正在运行的容器。

使用 Dockerfile 创建正在运行的容器。

此示例 docker 文件包含来自和 CMD 的命令。F@@

rom 定义基础镜像，CMD 在终端上打印 hello world 字样。

你会注意到这个 Docker 命令使用编译命令、标签

、存储库、版本和当前目录。

运行此版本后，输出消息包括将构建上下文发送到

成功构建的 Docker Daemon<image>，该守护程序确认映像创建并

成功标记 my-app，从而确认标签。

要验证镜像的创建，请运行 docker 镜像命令。

输出显示存储库、my-app 以及标签、

v1、镜像 ID、创建日期和图像大小。

使用 run 命令创建容器。

使用容器镜像名称和标签，应用程序会打印 hello world 字样。

执行 Docker PSA 命令，

该命令显示所创建容器的详细信息。

给定适当的输入。

build 命令用于创建带有

docker 文件标签的容器镜像。

images 命令将列出所有图像、它们的存储库和

标签以及它们的大小。

run 命令根据镜像创建并运行容器。

push 命令将镜像存储在已配置的注册表中，

而 pull 命令则从配置的注册表中检索镜像。

在这段视频中，你了解到编译命令与

Dockerfile 一起使用来构建容器镜像。

运行命令与镜像一起使用来创建正在运行的容器和密钥。

Dockerfile 命令包括构建、映像、运行、拉取和推送。

Docker 文件是一个文本文件，

其中包含创建镜像所需的指令。

您可以使用

控制台或终端中的任何编辑器创建 Docker 文件。

让我们来看看

Docker 提供的几条基本指令。

Docker 文件必须始终以

定义基础镜像的 FROM 指令开头。

基础镜像通常来自公共存储库，

例如操作系统或

特定语言，如 Go 或 Node.js。

RUN 指令执行命令。

CMD 指令定义

了执行的默认命令。

一个 Docker 文件应该只有一条 CMD 指令。

如果 Docker 文件有多条 CMD 指令，则

只有最后一条 CMD 指令才会生效。

接下来，让我们了解一下 Docker 镜像。

Docker 镜像

是一个只读模板，其中包含

创建 Docker 容器的说明。

Docker 文件提供了构建镜像的指令

，每条 Docker 指令都会在

镜像中创建一个新层。

当你更改 Docker 文件并重建镜像时，

Docker 引擎只会重建更改后的层。

图像可以共享这些图层，

从而节省大量磁盘空间，

并在

发送和接收图像时节省网络带宽。

当你实例化这个镜像时，

你会得到一个正在运行的容器。

此时，可写容器层

位于只读层的顶部，

并且需要可写层，因为

容器不是像图像一样不可变的。

现在，让我们来了解一下图像是如何命名的。

镜像名称具有独特的格式

，由三部分组成

：主机名、存储库和标签。

主机名标识映像注册表。

存储库是一组相关的容器镜像

，标签提供有关

镜像的特定版本或变体的信息。

以镜像名称 docker.io/ubuntu: 18.04 为例。

主机名 docker.io

指的是 Docker Hub 注册表。

使用 Docker CLI 时，

你可以排除 docker.io 的主机名。

存储库名称 Ubuntu 表示 Ubuntu 镜像。

最后，此处显示为 18.04 的标签

代表已安装的 Ubuntu 版本。

现在，让我们来了解一下 Docker 容器。

什么是 Docker 容器？

Docker 容器是镜像的可运行实例。

你可以使用 Docker API 或 CLI 来创建

、启动、停止或删除镜像。

您可以连接到多个网络，

将存储连接到容器，

或者根据其当前状态创建新映像。

Docker 使容器

彼此之间及其主机保持良好的隔离。

使用 Docker 时，网络

有助于隔离容器通信。

默认情况下，当

容器不再存在时，数据不会保留。

Docker 客户端服务器架构提供了完整的应用程序

环境。

Docker 组件包括客户端、主机和注册表。

让我们从更高层次的角度来看看 docker 的工作原理。

首先，你将

通过 Docker 客户端使用 Docker 命令行接口或 REST API 向 Docker 主机服务器（

通常称为主机）发送指令。

Docker 主机包含名为 dockered 的守护程序。

该守护程序监听 Docker API 请求或

命令（例如 docker run），并处理这些命令。

守护程序负责构建、运行和

分发 docker 容器的繁重工作。

然后，Docker 将容器镜像存储在注册表中。

Docker 主机还包括和管理镜像、容器、

命名空间网络、存储插件和附加组件。

你可以使用 Docker 客户端与本地和

远程 docker 主机通信。

你可以在同

一个系统上运行 Docker 客户端和守护程序，或者将你的 docker 客户端连接到远程 Docker 守护程序，而且 D

ocker 守护程序还可以与其他守护程序通信来管理 docker 服务。

Docker 在注册表中存储和分发镜像。

注册表访问权限要么是公开的，例如

所有人都可以访问的 Docker hub，要么是私有的。

出于安全原因，企业通常选择使用私有注册表。

注册表位置使用第三方提供商（例如 IBM Cloud

容器注册表）托管，或者在私有数据中心或云端自托管。

接下来，让我们学习如何将图像移入注册表。

首先，开发人员使用自动化或构建

管道构建映像并将其推送到 Docker 存储这些镜像的注册表中。

然后，本地计算机、云系统和本地系统可以提取这些映像。

让我们更详细地研究一下这个过程。

以下是 Docker 架构的直观表示，

该架构由客户端、Docker 主机（包括 Docker 守护程序）

和带有其现有存储映像的注册表组成。

让我们来看看容器化过程。

以下是使用 Docker 创建容器镜像的方法。

首先，使用现有的基础镜像或 Docker 文件。

然后发出 build 命令，创建带有名称的容器镜像。

接下来，发出 push 命令将镜像存储到注册表中。

主机首先在本地检查镜像是否已经可用，

然后发出带有镜像名称的运行命令来创建容器。

如果镜像在主机中不可用，则

Docker 客户端将连接到注册表并将映像拉到主机。

然后，守护程序使用该镜像创建一个正在运行的容器。

在这段视频中，你了解到了 Docker 架构由 Docker 客户端、

一个 Docker 主机和一个注册表组成。

客户端使用命令和 REST API 与主机进行交互。

Docker 主机包括通常称为 dockerd 的守护程序。

docker 主机还管理镜像、容器、命名空间、

网络、存储、插件和插件，

容器化是构建、推送和运行镜像的过程。

创建正在运行的容器。

容器是一个软件单元，它封装了构建、运输和运行应用程序所需的一切。
容器可以降低部署时间和成本，提高利用率，实现流程自动化，并支持下一代应用程序（微服务）。主要的容器供应商包括 Docker、Podman、LXC 和 Vagrant。
Docker 是一个开放平台，用于以容器形式开发、发布和运行应用程序。
Docker 容器不适合基于单体架构的应用程序或需要高性能或安全性的应用程序。
Docker 架构由 Docker 客户端、Docker 主机和容器注册表组成。
Docker 主机包含 Dockerfiles、图像、容器、网络、存储卷等对象，以及插件和附加组件等其他对象。
Docker 使用网络来隔离容器通信。
Docker 使用卷和绑定挂载来持久化数据，即使在容器停止运行后也是如此。
插件（如存储插件）提供了连接外部存储平台的能力。

使用 Kubernetes 管理应用程序

ReplicaSet 可通过创建或删除 pod 实现扩展。
ReplicaSet 总是尝试将实际状态与所需状态相匹配。
自动扩展可根据需要在群集或节点级别以及 pod 级别进行扩展。
自动扩展器类型包括水平 pod (HPA)、垂直 pod (VPA) 和群集 (CA)。
滚动更新以受控和自动化的方式推出应用程序变更。
滚动更新和回滚可使用一次性和一次性策略执行。
配置图用于为应用程序提供变量。
保密信息用于为应用程序提供敏感信息。
将外部服务绑定到部署中会自动提供在代码中使用该服务的凭证。
绑定可管理后端服务的配置和凭证，同时保护敏感数据。

部署战略

概述

Kubernetes 部署策略定义了应用程序的生命周期，可自动实现并维护对象和应用程序的配置状态。有效的部署策略能最大限度地降低风险。

Kubernetes 部署策略用于：

部署、更新或回滚 ReplicaSets、Pod、服务和应用程序
暂停/恢复部署
手动或自动 Scale 部署

部署策略类型

以下是六种类型的部署策略：

重新创建
滚动
蓝/绿
金丝雀
A/B Testing
阴影

您既可以使用单一部署策略，也可以组合使用多种部署策略。

重新创建策略

在重新创建策略中，运行实时版本应用程序的 Pod 会同时全部关闭，然后在新创建的 Pod 上部署新版本的应用程序。

重新创建是最简单的部署策略。关闭现有部署和新部署之间的停机时间很短。

重新创建策略步骤包括

准备部署新版本的应用程序（v2）。
关闭或删除运行当前版本（v1）的所有 Pod。
创建新的（v2）Pod。

以相反的顺序完成回滚过程，用版本 1（v1）替换版本 2（v2）。

优点	缺点
设置简单	关闭和新部署之间的停机时间短
应用程序版本完全被替换

滚动（渐进）策略

在滚动策略中，每个 Pod 一次更新一个。用新的 v2 Pod 替换单个 v1 Pod。每个 v1 Pod 都以这种方式更新，直到所有 Pod 都是 v2。在滚动策略更新过程中，几乎没有停机时间，因为用户会被引导到任一版本。

滚动策略步骤包括

准备部署新版本的应用程序（v2）。
运行当前版本（v1）的一个 Pod 关闭或删除。
创建一个新的（v2）Pod，取代被删除的（v1）Pod。
重复步骤 2 和 3，直到所有（v1）Pod 都被删除并替换为（v2）Pod。

回滚过程相反，v2 Pod 被 v1 Pod 取代。

优点	缺点
设置简单	推出/回滚需要时间
适合需要处理数据再平衡的有状态应用程序	无法控制流量分布

蓝绿策略

在蓝绿策略中，蓝色环境是应用程序的实时版本。绿色环境是包含新版应用程序部署的精确副本。绿色环境经过全面测试。一旦所有更改、Bug 和问题都得到解决，用户流量就会从蓝色环境切换到绿色环境。

蓝色/绿色战略步骤包括

创建一个与当前生产环境相同的新环境。
设计新版本并对其进行全面测试，直至其可以投入生产。
将所有用户流量路由到新版本。

要执行回滚，将环境切换回来。

优点	缺点
即时推出/回滚 (无停机时间）	昂贵 (需要双倍资源）
新版本可立即提供给所有用户	在发布到生产环境之前需要进行严格的测试
	难以处理有状态的应用程序

金丝雀策略

在 "金丝雀 "策略中，新版本的应用程序将使用一小部分随机用户与当前的实时版本应用程序一起进行测试。一旦新版本的应用程序测试成功，就会向所有用户推出。

金丝雀战略步骤包括

设计新版本的应用程序。
将少量用户请求 Sample 路由到新版本。
测试效率、性能、Bug 和问题，并根据需要回滚。
一旦所有问题都得到解决，就将所有流量路由到新版本。

由于接触新版本的用户很少，因此回滚不会造成停机。

优点	缺点
便于可靠性、错误和性能监控	推出速度慢，用户可逐步访问
快速回滚

A/B 测试策略

A/B Testing 策略也称为分割测试，对应用程序的两个版本（版本 A 和版本 B）进行评估。通过 A/B Testing，每个版本都有迎合不同用户群的 Feature。您可以根据用户互动和反馈，选择最适合全球部署的版本。

A/B Testing 策略步骤包括：

通过添加大部分 UI 功能，设计一个新版本的应用程序。
根据权重、Cookie 值、查询参数、地理定位、浏览器版本、屏幕尺寸、Operator 操作系统和语言等条件，确定一小部分用户集。
将来自用户集的请求路由到新版本。
检查 Bug、效率、性能和问题。
解决所有问题后，将所有流量路由到新版本。

可以实施回滚，但停机时间会对用户造成影响。

优点	缺点
可并行运行多个版本	需要智能 Load Balancer
完全控制流量分配	难以排除特定会话的错误，必须进行分布式跟踪

影子策略

在影子策略中，应用程序的 "影子版本 "与实时版本同时部署。用户请求会同时发送到两个版本，两个版本都会处理所有请求，但影子版本不会将响应转发回用户。这样，开发人员就可以在不影响用户体验的情况下，查看影子版本使用真实数据的执行情况。

要执行回滚，请将环境切换回来。

优点	缺点
使用生产流量进行性能测试	昂贵（双倍资源）
对用户没有影响	不是真正的用户测试，可能导致对结果的误解
无停机时间	设置复杂
	需要监控两个环境

部署策略总结

部署策略	零停机时间	真实流量测试	目标用户	云成本	回滚持续时间	负面用户影响	设置复杂性
重新创建删除第 1 版，然后推出第 2 版	X	X	X	---	---	---	- - -
斜坡式第 1 版被缓慢推出的第 2 版取代	✓	X	X	---	---	---	---
蓝/绿版本 2 与版本 1 一起发布，然后流量切换到版本 2	✓	X	X	---	- - -	---	---
金丝雀版本 2 首先向部分用户发布，然后在生产准备就绪时全面推广	✓	✓	X	---	---	---	---
A/B Testing 第 2 版仅向具有特定特征的用户子集发布	✓	✓	✓	---	---	---	---
阴影版本 2 与版本 A 一起接收真实世界流量，但不响应用户	✓	✓	X	---	- - -	- - -	---

制定良好的战略：

考虑产品类型和目标受众
影子策略和金丝雀策略使用实时用户请求，而不是使用用户样本。
如果应用程序的版本需要进行细微调整或 UI 功能更改，则 A/B Testing 策略非常有用。
如果您的应用程序版本比较复杂或关键，需要在部署期间不停机的情况下进行适当监控，那么蓝/绿策略就很有用。
如果您希望零停机时间，并愿意向公众公开您的应用程序版本，那么金丝雀策略是一个不错的选择。
滚动策略会逐步部署新版本的应用程序。不会出现停机时间，而且回滚也很容易。
如果应用程序不是关键应用程序，而且用户不会受到短暂停机时间的影响，那么重新创建策略就是一个不错的选择。

Kubernetes 生态系统：OpenShift、Istio 等

OpenShift® 是专为开放式混合云打造的企业就绪 Kubernetes 容器平台。
OpenShift 更易于使用，可与 Jenkins 集成，并拥有更多服务和功能。
自定义资源定义（CRD）扩展了 Kubernetes API。
CRD 与自定义控制器配对可在 Kubernetes 中创建全新的声明式 API。
操作员使用 CRD 和自定义控制器自动执行集群任务。
构建是一个将输入转化为对象的过程。
ImageStream 是 OpenShift 中引用容器映像的抽象概念。
服务网格提供流量管理，以控制服务间的流量；提供安全性，以加密服务间的流量；提供服务行为的可观察性，以排除故障和优化应用。
Istio 是一种服务网格，支持连接、安全、执行和可观察性四个概念。它常用于微服务应用程序。
Istio 为基本服务监控需求提供服务通信指标：延迟、流量、错误和饱和度。

使用微服务和无服务器进行应用程序开发

微服务架构是一种方法，在这种方法中，单个应用程序由

许多松散耦合

且可独立部署的

较小服务组成。

这些服务通常

有自己的技术栈，包括数据库和 Data Management Model。

团队甚至可以为不同

组件选择不同的编程语言，因为它们通过 API 端点相互依赖。

Microservices 组件通过 REST API、

事件流和消息代理的组合相互通信，

它们按照业务功能进行隔离和组织，

服务之间的分隔线被称为有界上下文。

由于服务之间不存在相互依赖关系，您可以更轻松地

更新代码以添加新特性或功能，而无需触及整个应用程序。

每个团队都可以选择适合自身需求和专长的技术栈

，来构建该团队负责的组件。

而且这些组件

可以相互独立扩展，从而减少了因单一功能可能面临过多负载而不得不扩展整个应用所带来的浪费和成本

。

因此，无论您在哪里看到微服务的扩展，它通常都涉及水平扩展。

水平扩展是指通过添加更多的资源实例来扩展，

也被描述为 "向外扩展"。

通过微服务，单个服务可以单独部署和扩展。

在正确的情况下，微服务对基础设施的要求较低，

因为它们只允许对需要的组件进行 Precision Scale，

而不是单体应用中的整个应用。

调用 API 通常是一种初步建立特定服务状态的有效方法。

但是，它并不是一种特别有效的了解最新进展的方法。

此时，事件流可帮助广播状态变化，

通过引入此消息代理，有助于 Scale 微服务。

微服务有许多可用的模式，可以应对一些

更常见的挑战和机遇。

示例包括

单页应用程序（或 SPA）模式、

前端后端（或 BFF）模式、Str

angler 模式

和服务发现模式。

随着功能更强大的浏览器、更快的网络和客户端语言的融合，

许多 Web 界面开始将所有功能整合到单页应用程序中。

用户通过一个界面进入，该界面永远不会重新加载登录页面

或偏离初始体验。

这些应用程序结合使用 HTML、CSS 和 JavaScript 构建，

通过对基于 REST 的后端服务进行动态服务调用来响应用户输入

，这些服务会更新屏幕的某些部分，而不是重定向到全新的页面。

这种应用程序架构通常会简化前端

体验，但需要在后端服务上承担更多责任。

尽管单页应用程序可以很好地

提供单渠道用户体验，但它通过移动和网络等不同渠道在用户体验中提供的效果不佳。

前端模式的后端模式在用户

体验和体验所需的资源之间插入了一层。

这种设计允许在渠道之间提供定制的用户体验。

例如，在桌面上使用的应用程序与在

移动设备上使用的应用程序具有不同的屏幕尺寸、显示屏和性能限制。

BFF 模式允许开发人员

使用界面的最佳选项为每个用户界面创建和支持一种后端类型，而不是尝试支持

适用于任何接口但可能对前端性能产生负面影响的通用后端。

此图说明了前端应用程序架构后端的绝佳用例。

假设用户可以通过移动应用程序或桌面上的 Web 应用程序访问应用程序。

应用 BFF 模式时，您需要开发一个专门用于

移动体验的后端和另一个用于网络体验的后端。

每个后端都知道如何调用正确的服务并编排代码

以优化所请求频道的体验。

移动应用程序显示的数据子集可能更为有限

，屏幕大小将与 Web 体验有所不同。

每个后端都是一个微服务。

而且，与其使用单一应用程序

来检查需要哪个渠道，然后包含为该渠道做好用户体验准备的所有逻辑，不

如应用微服务架构将单一后端分

成不同的服务，以执行其特定、必要的任务。

Strangler 模式有助于分阶段管理单体应用程序的重构。这种@@

图案的隐喻名称来自于花园现象，即一棵葡萄树勒死一棵树。

想想一个使用单个 URL 构建的 Web 应用程序，这些网址在功能上映射

到业务域的不同方面。

使用 Strangler 模式，您可以使用 Web 应用程序的结构将应用程序

拆分为多个功能域，

并将这些域替换为基于微服务的新

实现，一次只能用于一个域。

这两个方面形成了单独的应用程序，它们并排存在于同一 URL 空间中。

随着时间的推移，新重构的应用程序将取代原始

应用程序，直到您最终可以关闭单体应用程序。

Strangler Pattern 包括以下步骤：

首先，转换。

这将在云平台上或现有环境中创建一个并行的新站点。

接下来，共存。

这使现有网站能够正常运行并在指定的时间内上线。

它会逐步从当前位置重定向到

新站点，以实现新实现的功能。

最后，消除。

当您从原始站点重定向流量时，这会从现有站点移除过时的功能，或者停止维护该功能。

现在，服务发现模式可以帮助应用程序和服务相互发现。

之所以需要这种模式，是因为在微服务架构中，

服务实例会随着扩展、

升级、服务故障甚至服务终止而动态变化。

负载均衡器还可以使用这种模式进行

运行状况检查，并在服务出现故障时重新平衡流量。

其他模式包括实体和聚合模式，

这可以在电子商务网站上使用，

在这种网站中，订单将是按买方分组的产品汇总。

另一个是适配器模式。

用你去另一个国家旅行时对插头适配器的看法来思考。

适配器模式的目的是帮助转换

原本不兼容的对象之间的关系。

例如，如果您已与第三方 API 集成。

在这段视频中，您了解到

微服务使

依赖支持服务的单页应用程序能够动态更新页面，前

端后端模式使用微服务更轻松地促进不同的用户体验，

您可以应用Strangler模式帮助将单

一应用程序分解为微服务，服务发现模式可以帮助应用程序和服务相互发现。

微服务反模式

虽然有很多模式可以很好地开发微服务，但同样也有很多模式会让开发团队很快陷入困境。以下是开发微服务时的一些禁忌：

不要构建微服务

微服务的第一条规则就是不要从微服务开始。当你确定单体应用程序的复杂性会对应用程序的开发和维护产生负面影响时，可以考虑将该应用程序重构为更小的服务。

当应用程序变得过于庞大，无法轻松更新和维护时，这些微服务将成为分解复杂性的理想选择，使应用程序更易于管理。

然而，在你感受到这种痛苦之前，你甚至还没有一个需要重构的单体。

不重视自动化

如果你有一个单体应用程序，你只需要部署一个软件。一旦转向微服务架构，您将拥有不止一个应用程序，每个应用程序都有不同的代码、测试和部署周期。

试图构建微服务时，如果没有

适当的自动化部署和监控，或
托管云服务来支持您现在庞大的异构基础设施

会带来很多不必要的麻烦。

因此，在构建微服务时，一定要使用 DevOps 或云服务。

不要构建纳米服务

如果过度追求微服务中的 "微"，就会很容易发现自己正在构建纳米服务！其复杂性将超过微服务架构的整体收益。

倾向于创建大型服务，并在出现以下情况时创建小型服务：

部署变更变得困难
通用数据模型变得过于复杂
加载和扩展要求不再同步并影响应用程序性能

不要变成 SOA

微服务和面向服务架构（SOA）这两个概念经常被混为一谈，因为在最基本的层面上，两者都是构建可被其他应用程序使用的可重用的独立组件。

然而，微服务是细粒度的，每个微服务都有独立的数据存储，也就是有边界的上下文。

微服务项目如果演变成 SOA 项目，很可能会不堪重负。

不要为每个服务建立网关

与其在每个服务中实施终端用户身份验证、节流、协调、转换、路由和分析，不如使用 API 网关。

API 网关是一种 API 管理工具，位于客户端和后端服务集合之间。

这将成为上述非功能性问题的核心，并避免在每项服务中重新设计这些问题。

结论

微服务的目的是解决三个最常见的挑战，即提升客户体验、灵活应对新需求，以及通过以细粒度服务的形式提供业务功能来降低成本。

但是，在这样做的同时，你应该避免上述反模式的陷阱，以免微服务对你的开发、交付和管理要求造成困扰。

现代软件开发通常提供集中托管、基于网络、软件即服务（SaaS）的应用程序
十二要素应用程序方法使开发人员能够创建更高效的 SaaS 应用程序
十二要素与软件交付生命周期的编码、部署和运行阶段相对应
微服务使每个应用组件成为自己的服务，每个服务通过 API 进行通信
微服务允许应用组件使用不同的技术栈
微服务使单个组件能够根据需求进行扩展
微服务降低了与变化相关的风险，因为组件可以独立迭代
一个服务出现故障不一定会影响其他服务
构建微服务时应避免一些反模式

REST API 在组件之间提供了灵活而统一的接口
REST API 是无状态和可扩展的
REST API 使用 HTTP 方法 POST、GET、PUT 和 DELETE 进行通信
REST 是一种定义应用程序通信方式的架构风格
API 网关是通向后端服务的大门，它还能让您在提供统一访问的同时插入其他服务
API Gateway 可让您更轻松地扩展或替换后端服务
Flask 是一个微型网络框架，用于托管 Python 网络应用程序
cURL 用于通过 URL 传输数据，可在命令行或脚本中使用
Postman 是一款简单而流行的工具，用于构建、测试和使用 API
Swagger 可帮助您记录和测试 API
OpenAPI 规范是表示 API 的标准方法

无服务器是构建和运行无需服务器管理的应用程序的概念
无服务器使用 BaaS 服务和 FaaS 平台
云提供商负责基础设施的管理和维护任务
无服务器计算的出现意味着开发团队可以专注于编写高质量的代码
无服务器具有多种优势，如内置高可用性和容错、更快的函数运行时间以及按请求付费计费等。
无服务器计算有几个限制因素，包括时间关键型应用程序无法接受的延迟、复杂的监控和调试以及无状态持久性
FaaS 是一种云计算服务，允许您在没有复杂基础设施的情况下根据事件执行代码
FaaS 是无服务器计算的一个子集，它以多种功能的形式创建应用程序；可以部署在云计算、混合云或企业内部。
无服务器堆栈由 FaaS、BaaS 和 API 网关组成
无服务器框架是一个使用 Node.js 编写的免费开源网络框架。
无服务器网络应用程序的用例包括网络应用程序、事件流、后处理和多语言系统
AWS Lambda 为您提供事件驱动和即用即付的无服务器平台
谷歌云函数（Google Cloud Functions）为您提供简化的开发人员体验，以及用于实时数据同步的 Firebase
Microsoft Azure 促进云计算和边缘计算
IBM 云函数为您提供高可用性和经济高效的计算
Knative 推动平台无关性交替

自托管微服务可能非常复杂和具有挑战性
IBM 云代码引擎是一个完全托管的平台，可以处理所有艰巨的部署工作，让开发人员专注于他们的代码
IBM 云代码引擎有三个主要用例：1) 部署应用程序，2) 构建和部署应用程序，3) 运行作业
项目是代码引擎实体（如应用程序、作业和构建）的组合
应用程序运行你的代码，以服务 HTTP 请求或创建 WebSocket 会话
构建是根据源代码创建容器映像的过程
作业运行可执行代码的一个或多个实例
容器是一个独立的可执行软件单元，与其所有依赖项打包在一起
Docker 是一种流行的容器构建和运行平台
您可以编写一个 Dockerfile 来指示 Docker 平台构建一个容器映像
容器映像构建完成后，可将其推送到容器注册表，然后根据其映像名称进行调用
您可以从推送的容器镜像或源代码库中创建云引擎应用程序
根据您的偏好，您可以选择使用 IBM Cloud Console 或 IBM Cloud CLI 来执行应用程序部署任务

Red Hat OpenShift 是一个运行容器化工作负载（如微服务）的平台。
OpenShift 就像一个 Kubernetes 发行版，OpenShift 还具有其他功能。例如，OpenShift 会创建一个 Jenkins 作业，自动将微服务构建到容器中。此外，OpenShift 还会将构建的容器推送到注册中心，并将这些容器部署到集群中。
微服务架构需要服务之间的安全性以及管理和测试服务的方法。
Istio 是一种服务网格，在与微服务一起部署时可提供流量转移、相互传输层安全和遥测功能。
经过认证的软件可以填补应用中的开发空白，使企业无需花费时间和金钱来开发新的微服务。 Red Hat Marketplace 提供了一个中心位置来试用、购买、部署和管理经过认证的 OpenShift 环境软件。

项目任务概述

您将为一个流行乐队建立一个网站。乐队的歌迷和其他用户可以在网站上执行以下操作：

查看过去活动的图片
查看流行歌曲的歌词
查看即将举行的活动列表
创建账户
登录并注册参加活动
登录并查看以往注册情况

设计步骤

为了成功完成该项目，您将采取以下步骤：

在 Flask 中创建 "获取图片"微服务
1. 将图片作为资源创建 CRUD 端点。
2. 为微服务创建健康端点。
在 Flask 中创建 "获取歌曲"微服务
1. 设置 MongoDB 数据库。
2. 实现从数据库检索歌词的服务。
3. 为微服务创建健康端点。
在 Django 中创建主应用程序
1. 创建音乐会模型。
2. 使用 Django 内置的用户模型。
3. 迁移模型以在 SQLite 数据库中创建表格。
4. 实施控制器，将数据发送到预定义模板。
部署服务和应用程序
1. 将Get Pictures部署到 IBM 代码引擎。
2. 将 GetSongs 和 MongoDB部署到 Redhat OpenShift。
3. 将主应用程序部署到 IBM Kubernetes 服务。

1.用户访问 Django 网站主页。

匿名用例

2.歌曲页面显示歌曲和歌词。

3.图片页面显示过去音乐会的图片。

管理员用例

4.让管理员用户更改音乐会日期。

登录使用案例

用户登录应用程序。
用户可以查看自己的音乐会。
用户可以预订音乐会。
用户可以删除预订。

Flask 是一个微框架，只需最少的依赖即可运行。
为了构建应用程序，Flask 具有调试服务器、路由、模板和错误处理等功能。
Flask 可以作为 Python 软件包安装，也可以通过社区扩展进行扩展。
与 Flask 相比，Django 是一个功能繁多的全栈框架。
您可以直接从环境变量、Python 文件和应用程序配置对象中设置应用程序配置。
Flask 为每次客户端调用提供一个请求和一个响应对象。
您可以从 Flask 请求中获取更多信息，例如头信息。
您可以解析请求对象，获取查询参数和正文。
在将响应发送回客户端之前，可以在 Response 对象上设置状态。
可以使用动态路由创建 RESTful 端点。
HTTP 响应需要一个状态代码来表示请求处理过程中发生的情况。
HTTP 状态代码有多个类别，分别显示成功、用户错误或服务器错误。