小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。

本文已参与 「掘力星计划」 ，赢取创作大礼包，挑战创作激励金。

Ctrl+l清除屏幕显示的内容

由于太孤陋寡闻，看到一个快速清屏的操作，查了下发现，Ctrl+l在终端下是快速清屏的快捷键。

Ctrl + l快速清屏，比输入 clear 命令清屏方便快捷多了。

Ctrl + l（l 为 L 键）。

除此之外，还有 history -c 命令，用于清除终端命令的所有历史记录，也可以达到清屏的效果，只不过清除的是执行过的命令的所有历史。

shell终端中常用快捷键

• ctrl + l：即 clear 命令。清除终端命令屏幕显示的内容，比如当终端命令屏显示的内容太多时，想清掉屏幕上显示的内容，就可以用clear命令或ctrl+l。（Clear screen）
• ctrl + c：终止命令的执行。（Kill foreground process）
• ctrl + d： 退出 shell，相当于 exit 命令；在输入中 ctrl + d 也表示EOF。（Terminate input, or exit shell）【当前shell行没有任何内容时，才会退出shell】
• ctrl + z：将当前进程置于后台并挂起，可使用 fg 命令还原到前台继续执行（bg 命令将一个在后台暂停的命令，变成继续执行）。（Suspend foreground process）
• ctrl + s：挂起当前shell输出。（Suspend output）
• ctrl + q：重新启用shell输出。（Resume output）
• Ctrl + o：丢弃输出。（Discard output）
• ctrl + r：从命令历史查找。
• ctrl + a：光标移到行首。
• ctrl + e：光标移到行尾。
• ctrl + u：清除光标到行首的字符 。
• ctrl + w：清除光标之前一个单词 。
• ctrl + k：清除光标到行尾的字符。
• ctrl + t：交换光标前两个字符。
• ctrl + y：粘贴前一ctrl+u类命令删除的字符。
• ctrl + p：上一条命令。
• ctrl + n：下一条命令。
• ctrl + v：输入控制字符 如ctrl+v ，会输入^M
• ctrl + f：光标后移一个字符。
• ctrl + b：光标前移一个字符。
• ctrl + h：删除光标前一个字符。

参考

linux系统清屏命令是什么，及其他一些资料

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

作者：何甜甜在吗

来源：juejin.cn/post/6913735652806754311

前段时间提交代码审核，同事提了一个代码规范缺陷：参数校验应该放在controller层。到底应该如何做参数校验呢

Controller层 VS Service层

去网上查阅了一些资料，一般推荐与业务无关的放在Controller层中进行校验，而与业务有关的放在Service层中进行校验。

那么如何将参数校验写的优雅美观呢，如果都是if - else，就感觉代码写的很low，还好有轮子可以使用

常用校验工具类

使用Hibernate Validate

引入依赖

1
2
3
4
5

xml复制代码<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>4.3.1.Final</version> 
</dependency>

常用注解说明

使用姿势

Spring Boot 基础就不介绍了，推荐下这个实战教程：
www.javastack.cn/categories/…

需要搭配在Controller中搭配@Validated或@Valid注解一起使用，@Validated和@Valid注解区别不是很大，一般情况下任选一个即可，区别如下：

虽然@Validated比@Valid更加强大，在@Valid之上提供了分组功能和验证排序功能，不过在实际项目中一直没有用到过

Hibernate-validate框架中的注解是需要加在实体中一起使用的

• 定义一个实体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

less复制代码public class DataSetSaveVO {
    //唯一标识符为空
    @NotBlank(message = "user uuid is empty")
    //用户名称只能是字母和数字
    @Pattern(regexp = "^[a-z0-9]+$", message = "user names can only be alphabetic and numeric")
    @Length(max = 48, message = "user uuid length over 48 byte")
    private String userUuid;

    //数据集名称只能是字母和数字
    @Pattern(regexp = "^[A-Za-z0-9]+$", message = "data set names can only be letters and Numbers")
    //文件名称过长
    @Length(max = 48, message = "file name too long")
    //文件名称为空
    @NotBlank(message = "file name is empty")
    private String name;

    //数据集描述最多为256字节
    @Length(max = 256, message = "data set description length over 256 byte")
    //数据集描述为空
    @NotBlank(message = "data set description is null")
    private String description;
}

说明：message字段为不符合校验规则时抛出的异常信息

• Controller层中的方法

1
2
3
4

less复制代码@PostMapping
public ResponseVO createDataSet(@Valid @RequestBody DataSetSaveVO dataSetVO) {
    return ResponseUtil.success(dataSetService.saveDataSet(dataSetVO));
}

说明：在校验的实体DataSetSaveVO旁边添加@Valid或@Validated注解

使用commons-lang3

引入依赖

1
2
3
4
5

xml复制代码<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.4</version>
</dependency>

常用方法说明

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

less复制代码//StringUtils.isEmpty
System.out.println(StringUtils.isEmpty(""));  //true
System.out.println(StringUtils.isEmpty("  "));  //false
//StringUtils.isNotEmpty
System.out.println(StringUtils.isNotEmpty(""));  //false
        
//StringUtils.isBlank
System.out.println(StringUtils.isBlank(""));  //true
System.out.println(StringUtils.isBlank(" "));  //true
//StringUtils.isNotBlank
System.out.println(StringUtils.isNotBlank(" "));  //false

List<Integer> emptyList = new ArrayList<>();
List<Integer> nullList = null;
List<Integer> notEmptyList = new ArrayList<>();
notEmptyList.add(1);

//CollectionUtils.isEmpty
System.out.println(CollectionUtils.isEmpty(emptyList));   //true
System.out.println(CollectionUtils.isEmpty(nullList));   //true
System.out.println(CollectionUtils.isEmpty(notEmptyList));   //false

//CollectionUtils.isNotEmpty
System.out.println(CollectionUtils.isNotEmpty(emptyList));   //false
System.out.println(CollectionUtils.isNotEmpty(nullList));   //false
System.out.println(CollectionUtils.isNotEmpty(notEmptyList));   //true

自定义注解

当上面的方面都无法满足校验的需求以后，可以考虑使用自定义注解。

近期热文推荐：

1.1,000+ 道 Java面试题及答案整理(2021最新版)

2.别在再满屏的 if/ else 了，试试策略模式，真香！！

3.卧槽！Java 中的 xx ≠ null 是什么新语法？

4.Spring Boot 2.5 重磅发布，黑暗模式太炸了！

5.《Java开发手册（嵩山版）》最新发布，速速下载！

觉得不错，别忘了随手点赞+转发哦！

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

本文已参与「掘力星计划」，赢取创作大礼包，挑战创作激励金。

小知识，大挑战！本文正在参与“程序员必备小知识”创作活动

点赞再看，养成习惯，微信搜索【牧小农】关注我获取更多资讯，风里雨里，小农等你，很高兴能够成为你的朋友。

什么是Kubernetes？

Kubernetes 是Google开源的分布式容器管理平台，是为了更方便的在服务器中管理我们的容器化应用。

Kubernetes 简称 K8S，为什么会有这个称号？因为K和S是 Kubernetes 首字母和尾字母，而K和S中间有八个字母，所以简称 K8S，加上 Kubernetes比较绕口，所以一般使用简称 K8S。

Kubernetes 即是一款容器编排工具，也是一个全新的基于容器技术的分布式架构方案，在基于Docker的基础上，可以提供从 创建应用>应用部署>提供服务>动态伸缩>应用更新一系列服务，提高了容器集群管理的便捷性。

K8S产生的原因

大家可以先看一下，下面一张图，里面有我们的mysql，redis，tomcat，nginx等配置信息，如果我们想要安装里面的数据，我们需要一个一个手动安装，好像也可以，反正也就一个，虽然麻烦了一点，但也不耽误。

但是随着技术的发展和业务的需要，单台服务器已经不能满足我们日常的需要了，越来越多的公司，更多需要的是集群环境和多容器部署，那么如果还是一个一个去部署，运维恐怕要疯掉了，一天啥也不干就去部署机器了，有时候，可能因为某一个环节出错，要重新，那真的是吐血。。。。。，如下图所示：

如果我想要部署，以下几台机器：

3台 - Nginx

5台 - Redis
7台 - ZooKeeper
4台 - Tomcat
6台 - MySql
5台 - JDK
10台 - 服务器

如果要一个一个去部署，人都要傻掉了，这什么时候是个头，如果是某里巴的两万台机器，是不是要当场提交辞职信，所以 K8S 就是帮助我们来做这些事情的，方便我们对容器的管理和应用的自动化部署，减少重复劳动，并且能够自动化部署应用和故障自愈。

并且如果 K8S 对于微服务有很好的支持，并且一个微服务的副本可以跟着系统的负荷变化进行调整，K8S 内在的服务弹性扩容机制也能够很好的应对突发流量。

容器编排工具对比

Docker-Compose

Docker-Compose 是用来管理容器的，类似用户容器管家，我们有N多台容器或者应用需要启动的时候，如果手动去操作，是非常耗费时间的，如果有了 Docker-Compose 只需要一个配置文件就可以帮我们搞定，但是 Docker-Compose 只能管理当前主机上的 Docker，不能去管理其他服务器上的服务。意思就是单机环境。

Docker Swarm

Docker Swarm 是由Docker 公司研发的一款用来管理集群上的Docker容器工具，弥补了 Docker-Compose 单节点的缺陷，Docker Swarm 可以帮助我们启动容器，监控容器的状态，如果容器服务挂掉会重新启动一个新的容器，保证正常的对外提供服务，也支持服务之间的负载均衡。而且这些东西 Docker-Compose是不支持的，

Kubernetes

Kubernetes 它本身的角色定位是和Docker Swarm 是一样的，也就是说他们负责的工作在容器领域来说是相同的部分，当然也要一些不一样的特点，Kubernetes 是谷歌自己的产品，经过大量的实践和宿主机的实验，非常的成熟，所以 Kubernetes 正在成为容器编排领域的领导者，其 可配置性、可靠性和社区的广大支持，从而超越了 Docker Swarm，作为谷歌的开源项目，它和整个谷歌的云平台协调工作。

K8S的职责

1. 自动化容器的部署和复制
2. 随时扩展或收缩容器规模
3. 容器分组Group，并且提供容器间的负载均衡
4. 实时监控：及时故障发现，自动替换

K8S的基本概念

在下图中，是K8S的一个集群，在这个集群中包含三台宿主机，这里的每一个方块都是我们的物理虚拟机，通过这三个物理机，我们形成了一个完整的集群，从角色划分，可以分为两种

• 一种是 Kubernetes Master主服务器，它是整个集群的管理者，它可以对整个集群的节点进行管理，通过主服务器向这些节点，发送创建容器、自动部署、自动发布等功能，并且所有来自外部的数据都会由 Kubernetes Master进行接收并进行分配。
• 还有一种就是 node节点 节点可以是一台独立的物理机也可以是一个虚拟机，在每个节点中都有一个非常重要的 K8S 独有的概念，就是我们的Pod，Pod是K8S最重要也是最基础的概念

Pod

• Pod是 Kubernetes 控制的最小单元，一个Pod就是一个进程。
• 一个Pod可以被一个容器化的环境看做应用层的“逻辑宿主机”，可以理解为容器的容器，可以包含多个“Container”;
• 一个Pod的多个容器应用通常是紧密耦合的，Pod在Node上创建、启动或销毁；
• 每个Pod里面运行着一个特殊的被称为Pause的容器，其他的容器被称为业务容器，这些业务容器共享Pause容器的网络栈和Volume挂载卷；
• Pod的内部容器网络是互通的，每个Pod都有独立的虚拟IP。
• Pod都是部署完整的应用或模块，同一个Pod容器之间只需要通过localhsot就能互相通信。
• Pod的生命周期是通过 Replication Controller 来管理的，通过模板进行定义，然后分配到一个Node上运行，在Pod锁包含容器运行结束后，Pod结束。

打一个比较形象的比喻，我们可以把Pod理解成一个豆荚，容器就是里面的豆子，是一个共生体。

Pod里面到底装的是什么？

• 在一些小公司里面，一个Pod就是一个完整的应用，里面安装着各种容器，一个Pod里面可能包含（Redis、Mysql、Tomcat等等），当把这一个Pod部署以后就相当于部署了一个完整的应用，多个Pod部署完以后就形成了一个集群，这是Pod的第一种应用方式
• 还有一种使用方式就是在Pod里面只服务一种容器，比如在一个Pod里面我只部署Tomcat

具体怎么部署Pod里面的容器，是按照我们项目的特性和资源的分配进行合理选择的。

pause容器：

Pause容器 全称infrastucture container（又叫infra）基础容器，作为init pod存在，其他pod都会从pause 容器中fork出来，这个容器对于Pod来说是必备的
一个Pod中的应用容器共享同一个资源：

1. PID命名空间：Pod中的不同应用程序可以看到其他的应用程序的进程ID
2. 网络命名空间：Pod中的多个容器能够访问同一个IP和端口范围
3. IPC命名空间：Pod的多个容器能够使用，SystemV IPC或POSIX消息队列进行通信
4. UTS命名空间：Pod中的多个容器共享一个主机名；Volumes（共享存储卷）
5. Pod中的各个容器可以访问在Pod级别定义的Volumes

在上图中如果没有pause容器，我们的Nginx和Ghost，Pod内的容器想要彼此通信的话，都需要使用自己的IP地址和端口，才可以彼此进行访问，如果有pause容器，对于整个Pod来说，我们可以看做一个整体，也就是我们的Nginx和Ghost直接使用localhost就可以进行访问了，他们唯一不同的就只是端口，这里面可能看着觉得比较简单，但其实是使用了很多网络底层的东西才实现的，感兴趣的小伙伴可以自行了解一下。

Service(服务)

在 Kubernetes 中，每个Pod都会被分配一个单独的IP地址，但是Pod和Pod之间，是无法直接进行交互的，如果想要进行网络通信，必须要通过另外一个组件才能交流，也就是我们的 Service

Service 是服务的意思，在K8S中Service主要工作就是将多个不同主机上的Pod，通过Service进行连通，让Pod和Pod之间可以正常的通信

我们可以把Service看做一个域名，而相同服务的Pod集群就是不同的ip地址，Service 是通过 Label Selector 来进行定义的。

• Service 拥有一个指定的名字，类似于域名这种，并且它还拥有一个虚拟的IP地址和端口号，只能内网进行访问，如果Service想要进行外网访问或提供外网服务，需要指定公共的IP和NodePort或者外部的负载均衡器。

使用NodePort提供外部访问，只需要在每个Node上打开一个主机的真实端口，这样就可以通过Node的客户端访问到内部的Service。

Label(标签)

Label 一般以 kv的方式附件在各种对象上，Label 是一个说明性的标签，它有着很重要的作用，我们在部署容器的时候，在哪些Pod进行操作，都需要根据Label进行查找和筛选，我们可以理解Label是每一个Pod的别名，只有取了名称，作为K8S的Master主节点才能找到对应的Pod进行操作。

Replication Controller(复制控制器)

1. 存在Master主节点上，这个兄弟的作用主要是对Pod的数量进行监控，比如我们在下面的节点中我们需要三个相同属性的Pod，但是目前只有两个，当Replication Controller看到只有两个的时候，就会自动帮助我们按照我们制定的规则创建一个额外的副本，放到我们的节点中。
2. Replication Controller还可以对Pod进行实时监控，当我们某一个Pod它失去了响应，这个Pod就会被剔除，如果我们需要，Replication Controller会自动创建一个新的
3. Kubernetes通过RC中定义的Lable筛选出对应的Pod实例，并实时监控其状态和数量，如果实例数量少于定义的副本数量（Replicas），则会根据RC中定义的Pod模板来创建一个新的Pod，然后将此Pod调度到合适的Node上启动运行，直到Pod实例数量达到预定目标。

K8S的总体架构

• Kubernetes将集群中的机器划分为一个Master节点和一群工作节点（Node）
• Master节点上运行着集群管理相关的一组进程etcd、API Server、Controller Manager、Scheduler，后三个组件构成了Kubernetes的总控中心，这些进程实现了整个集群的资源管理、Pod调度、弹性伸缩、安全控制、系统监控和纠错等管理功能，并且全都是自动完成。
• Node上运行kubelet、kube-proxy、docker三个组件，是真正支持K8S的技术方案。负责对本节点上的Pod的生命周期进行管理，以及实现服务代理的功能。

用户通过 Kubectl提交一个创建 Replication Controller请求，这个请求通过 API Server 写入 etcd 中，这个时候Controller Manager通过 API Server的监听到了创建的命名，经过它认真仔细的分析以后，发现当前集群里面居然还没有对应的Pod实例，赶紧根据Replication Controller模板定义造一个Pod对象，再通 过Api Server 写到我们 etcd 里面

到下面，如果被Scheduler发现了，好家伙不告诉我？？？，无业游民，这家伙一看就不是一个好人啊，它就会立即运行一个复杂的调度流程，为这个新的Pod选一个可以落户的Node，总算有个身份了，真是让人操心，然后通过 API Server 将这个结果也写到etcd中，随后，我们的 Node上运行的小管家Kubelet进程通过 API Server 检测到这个 新生的小宝宝——“Pod”，就会按照它，就会按照这个小宝宝的特性，启动这个Pod并任劳任怨的负责它的下半生，直到Pod的生命结束。

然后我们通过Kubectl提交一个新的映射到这个Pod的Service的创建请求，Controller Manager会通过Label标签查询到相关联的Pod实例，生成Service的Endpoints的信息，并通过 API Server 写入到etcd中，接下来，所有Node上运行的Proxy进程通过 Api Server 查询并监听Service对象与其对应的Endpoints信息，建立一个软件方式的负载均衡器来实现Service访问到后端Pod的流量转发功能。

kube-proxy： 是一个代理，充当这多主机通信的代理人，前面我们讲过Service实现了跨主机、跨容器之间的网络通信，在技术上就是通过kube-proxy来实现的，service是在逻辑上对Pod进行了分组，底层是通过kube-proxy进行通信的

kubelet： 用于执行K8S的命令，也是K8S的核心命令，用于执行K8S的相关指令，负责当前Node节点上的Pod的创建、修改、监控、删除等生命周期管理，同时Kubelet定时“上报”本Node的状态信息到API Server里

etcd： 用于持久化存储集群中所有的资源对象，API Server提供了操作 etcd的封装接口API，这些API基本上都是对资源对象的操作和监听资源变化的接口

API Server ： 提供资源对象的操作入口，其他组件都需要通过它提供操作的API来操作资源数据，通过对相关的资源数据“全量查询”+ “变化监听”，可以实时的完成相关的业务功能。

Scheduler ： 调度器，负责Pod在集群节点中的调度分配。

Controller Manager： 集群内部管理控制中心，主要是实现 Kubernetes集群的故障检测和恢复的自动化工作。比如Pod的复制和移除，Endpoints对象的创建和更新，Node的发现、管理和状态监控等等都是由 Controller Manager完成。

总结

到这里K8S的基本情况我们就讲解完毕了，有喜欢的小伙伴记得 点赞关注，相比如Docker来说K8S有着更成熟的功能，经过谷歌大量实践的产物，是一个比较成熟和完善的系统。

关于K8S大家有什么想要了解或者疑问的地方欢迎大家留言告诉我。

我是牧小农，一个卑微的打工人，如果觉得文中的内容对你有帮助，记得一键三连，你们的三连是小农最大的动力。

1

markdown复制代码	—— 怕什么真理无穷，进一步 有进一步的欢喜，大家加油~

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

• 1. 概述
• 2. 引入 Spring Security OAuth2 依赖
• 3. 配置资源服务器
• 4. 配置授权服务器
• 4.1 授权码模式
• Spring Security Setting
• 4.2 密码模式
• 4.3 简化模式
• 4.4 客户端模式
• 4.5 如何选择？
• 4.6 为什么有 Client 编号和密码
• 5. 刷新令牌
• 5.1 获取刷新令牌
• 5.2 “刷新”访问令牌
• 5.3 为什么需要有刷新令牌
• 6. 删除令牌
• 6.1 删除访问令牌
• 6.2 删除刷新令牌
• 6.3 RFC7009 - OAuth2 Token Revocation
• 7. 令牌元数据
• 666. 彩蛋

1. 概述

本文，我们来入门 Spring Security OAuth2.0 的使用。通过本文，希望你对 OAuth2.0 有一次身临其境的感受。

另外，这是一篇入门的文章，所以实际场景下，需要做一些微调。当然，需要微调的地方，笔者会在示例中说明，以免误导。

如果你是 OAuth2.0 的萌新，建议先通读阮一峰大神的 《理解OAuth 2.0》。因为，本文不会去阐述 OAuth2.0 概念部分的内容。或者，也可以看看 《OAuth 2.0最简向导》 ，比较生动形象。

阅读完本文后，你想要更加深入的理解 OAuth2.0 ，可以阅读如下两本书籍：

• 《OAuth2 in Action》 重原理
• 《OAuth2 2.0 Cookbook》 重实践，基于 Spring Security OAuth2 。

阅读完本文后，你想要了解源码，可以阅读老徐的两篇文章：

• 《Re：从零开始的Spring Security OAuth2（二）》
• 《Re：从零开始的Spring Security OAuth2（三）》

OK，一波安利之后，我们来一起进入正文。对于 Spring Security OAuth2 的配置，大体来说，就是两步：

1. 配置授权服务器( AuthorizationServer )
2. 配置资源服务器( ResourceServer )

2. 引入 Spring Security OAuth2 依赖

在 pom.xml 文件中，引入如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

xml复制代码<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>1.5.16.RELEASE</version>
 <relativePath /> <!-- lookup parent from repository -->
</parent>
<dependencies>
 <!-- for Spring MVC -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <!-- for Spring Security -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-security</artifactId>
 </dependency>
 <!-- for OAuth 2.0 -->
 <dependency>
 <groupId>org.springframework.security.oauth</groupId>
 <artifactId>spring-security-oauth2</artifactId>
 </dependency>
</dependencies>

因为，我们使用的是 SpringBoot 的版本为 1.5.16.RELEASE ，所以使用的 Spring Security 的版本为 4.2.8.RELEASE ，Spring Security OAuth2 的版本为 2.2.0.15.RELEASE 。

3. 配置资源服务器

一般情况下，资源服务器指的是，我们提供 API 的应用或服务。例如，订单服务、商品服务。考虑到让整个示例更加简单，本文先将它和授权服务器放在一个 Maven 项目中。

① 创建一个 Controller 类

1
2
3
4
5
6
7
8
9
10
11

less复制代码/**
 * 示例模块 Controller
 */
@RestController
@RequestMapping("/api/example")
public class ExampleController {
 @RequestMapping("/hello")
 public String hello() {
 return "world";
 }
}

• 非常简单，这是一个示例模块的 Controller ，提供 /api/example/hello 接口。

② 配置资源服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

scala复制代码// 资源服务配置
@Configuration
@EnableResourceServer
public class OAuth2ResourceServer extends ResourceServerConfigurerAdapter {
 @Override
 public void configure(HttpSecurity http) throws Exception {
 http.authorizeRequests()
 // 对 "/api/**" 开启认证
 .anyRequest()
 .authenticated()
 .and()
 .requestMatchers()
 .antMatchers("/api/**");
 }
}

• @Configuration 注解，保证 OAuth2ResourceServer 能够被 SpringBoot 扫描到配置。
• @EnableResourceServer 注解，开启资源服务器。
• 继承( extends ) ResourceServerConfigurerAdapter 类，并覆写 #configure(HttpSecurity http) 方法，配置对 HTTP 请求中，匹配 /api/**“ 路径，开启认证的验证。

4. 配置授权服务器

在 OAuth2.0 中，定义了四种授权模式：

• 授权码模式( authorization code )
• 密码模式( resource owner password credentials )
• 简化模式( implicit )
• 客户端模式( client credentials )

所以，笔者在 SpringBoot-Labs/lab-02 目录下，每一种方式，都提供了一个 Maven 项目示例。

4.1 授权码模式

Maven 项目结构如下：

Maven 项目结构

对应 GitHub 地址：

github.com/YunaiV/Spri…

① 配置授权服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

scala复制代码// 授权服务器配置
@Configuration
@EnableAuthorizationServer
public class OAuth2AuthorizationServer extends AuthorizationServerConfigurerAdapter {
 @Override
 public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
 clients.inMemory() // <1>
 // <2> begin ...
 .withClient("clientapp").secret("112233") // Client 账号、密码。
 .redirectUris("http://localhost:9001/callback") // 配置回调地址，选填。
 .authorizedGrantTypes("authorization_code") // 授权码模式
 .scopes("read_userinfo", "read_contacts") // 可授权的 Scope
 // <2> end ...
// .and().withClient() // 可以继续配置新的 Client // <3>
 ;
 }
}

• @Configuration 注解，保证 OAuth2AuthorizationServer 能够被 SpringBoot 扫描到配置。
• @EnableAuthorizationServer 注解，开启授权服务器。
• <1> 处，基于内存，为了方便测试。实际情况下，最好放入数据库中，方便管理。
• <2> 处，创建一个 Client 配置。
• <3> 处，可以使用 #and() 方法，继续添加另外的 Client 配置。

② 配置登陆账号

创建 application.properties 文件，并配置如下：

1
2
3

ini复制代码# Spring Security Setting
security.user.name=yunai
security.user.password=1024

• 这里配置了一个账号为 “yunai” ，密码为 “1024” 的登陆账户。
• 实际生产环境下，登陆账号的数据，肯定是放在数据库中。

③ 启动项目

1
2
3
4
5
6

typescript复制代码@SpringBootApplication
public class Application {
 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }
}

启动项目

④ 获取授权码

4.1 浏览器打开

http://localhost:8080/oauth/authorize?client\_id=clientapp&redirect\_uri=http://localhost:9001/callback&response\_type=code&scope=read\_userinfo

• client_id 参数，必传，为我们在 OAuth2AuthorizationServer 中配置的 Client 的编号。
• redirect_url 参数，可选，回调地址。当然，如果 client_id 对应的 Client 未配置 redirectUris 属性，会报错。
• response_type 参数，必传，返回结果为授权码。
• scope 参数，可选，申请授权的 Scope 。如果多个，使用逗号分隔。
• state 参数，可选，表示客户端的当前状态，可以指定任意值，认证服务器会原封不动地返回这个值。
• 未在上述 URL 中体现出来

。

4.2 浏览器打开后，效果如下：

浏览器

• 输入在 「② 配置登陆账号」 中配置的登陆账号 “yunai” / “1024” 。
• 实际生产情况下，我们以 QQ 三方登陆作为例子，如下图：

• QQ 示例

4.3 登陆成功，选择允许所有申请的 Scope ，点击【Authorize】按钮，确认授权。如下图：

Authorize

4.4 授权完成，回调 redirect_uri 地址。如下图所示：

回调地址

• code 参数，就是返回的授权码。

⑤ 获取访问令牌

1

perl复制代码curl -X POST --user clientapp:112233 http://localhost:8080/oauth/token -H "content-type: application/x-www-form-urlencoded" -d "code=UydkmV&grant_type=authorization_code&redirect_uri=http%3A%2F%2Flocalhost%3A9001%2Fcallback&scope=read_userinfo"

• –user clientapp:112233 处，填写我们在 OAuth2AuthorizationServer 中配置的 Client 的编号和密码。
• code=UydkmV 处，填写在 「④ 获取授权码」 中获取的授权码( code ) 。

返回结果示例如下：

1
2
3
4
5
6

json复制代码{
 "access_token": "e60e41f2-2ad0-4c79-97d5-49af38e5c2e8", 
 "token_type": "bearer", 
 "expires_in": 43199, 
 "scope": "read_userinfo"
}

• access_token 属性，访问令牌。非空。
• token_type 属性，令牌类型，可以是 “bearer” 或 “mac” 类型。非空。
• expires_in 属性，过期时间，单位为秒。一般情况下，非空。
• scope 属性，权限范围。如果与 Client 申请的范围一致，此项可省略。
• refresh_token 属性，刷新令牌，用来获取下一次的访问令牌。
• 在授权码模式下，允许为空。

可能有部分胖友是 Windows 电脑，可以参考 《windows（64位）下使用 curl 命令》 来安装一个 curl 命令。

当然，如果胖友使用 Postman ，可以参看如下两图：

• 图 1

• 图 2

⑥ 调用资源服务器的 API

1

bash复制代码curl -X GET http://localhost:8080/api/example/hello -H "authorization: Bearer e60e41f2-2ad0-4c79-97d5-49af38e5c2e8"

• authorization: Bearer e60e41f2-2ad0-4c79-97d5-49af38e5c2e8 处，填写指定的访问令牌类型和访问令牌。例如此处分别为，”Bearer”、”e60e41f2-2ad0-4c79-97d5-49af38e5c2e8” 。

如果胖友使用 Postman ，可以参看如下图：

• 图

4.2 密码模式

Maven 项目结构如下：

Maven 项目结构

对应 GitHub 地址：

github.com/YunaiV/Spri…

① 配置授权服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

scala复制代码// 授权服务器配置
@Configuration
@EnableAuthorizationServer
public class OAuth2AuthorizationServer extends AuthorizationServerConfigurerAdapter {
 // 用户认证
 @Autowired
 private AuthenticationManager authenticationManager;
 @Override
 public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
 endpoints.authenticationManager(authenticationManager);
 }
 @Override
 public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
 clients.inMemory()
 .withClient("clientapp").secret("112233") // Client 账号、密码。
 .authorizedGrantTypes("password") // 密码模式
 .scopes("read_userinfo", "read_contacts") // 可授权的 Scope
// .and().withClient() // 可以继续配置新的 Client
 ;
 }
}

• 配置 Client 的方式，和【授权码模式】基本一致。差别在于：
• 无需配置 redirectUris 属性，因为不需要回调地址。
• 配置授权模式为【密码模式】。
• 另外，需要引入 AuthenticationManager 来支持【密码模式】，否则会报 “Resolved [error=”unsupported_grant_type”, error_description=”Unsupported grant type: password”]” 异常。

② 配置登陆账号

和【授权码模式】一致。

③ 启动项目

和【授权码模式】一致。

④ 获取访问令牌

1

bash复制代码curl -X POST --user clientapp:112233 http://localhost:8080/oauth/token -H "accept: application/json" -H "content-type: application/x-www-form-urlencoded" -d "grant_type=password&username=yunai&password=1024&scope=read_userinfo"

• 和【授权码模式】差异比较大。
• 直接请求 oauth/token 接口，获得访问令牌。
• 请求参数带上了 username 和 password ，就用户的登陆账号和密码。
• 请求参数 grant_type 为 password ，表示【密码模式】。

返回结果示例如下：

1
2
3
4
5
6

json复制代码{
 "access_token": "68de6eb9-5672-4e47-a3e6-110404285ba9",
 "token_type": "bearer",
 "expires_in": 43199,
 "scope": "read_userinfo"
}

• 和【授权码模式】一致。

⑤ 调用资源服务器的 API

和【授权码模式】一致。

4.3 简化模式

Maven 项目结构如下：

Maven 项目结构

对应 GitHub 地址：

github.com/YunaiV/Spri…

① 配置授权服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

scala复制代码// 授权服务器配置
@Configuration
@EnableAuthorizationServer
public class OAuth2AuthorizationServer extends AuthorizationServerConfigurerAdapter {
 @Override
 public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
 clients.inMemory()
 .withClient("clientapp").secret("112233") // Client 账号、密码。
 .redirectUris("http://localhost:9001/callback") // 配置回调地址，选填。
 .authorizedGrantTypes("implicit") // 授权码模式
 .scopes("read_userinfo", "read_contacts") // 可授权的 Scope
// .and().withClient() // 可以继续配置新的 Client
 ;
 }
}

• 和【授权码模式】基本一致。差别仅仅在于：配置授权模式为【简化模式】。

FROM 《理解 OAuth 2.0》

简化模式（implicit grant type）不通过第三方应用程序的服务器，直接在浏览器中向认证服务器申请令牌，跳过了”授权码”这个步骤，因此得名。所有步骤在浏览器中完成，令牌对访问者是可见的，且客户端不需要认证。

② 配置登陆账号

和【授权码模式】一致。

③ 启动项目

和【授权码模式】一致。

④ 获取授权码

4.1 浏览器打开

http://localhost:8080/oauth/authorize?client\_id=clientapp&redirect\_uri=http://localhost:9001/callback&response\_type=implicit&scope=read\_userinfo

• 和【授权码模式】基本一致。差别仅仅在于：请求参数 response_type 为 “implicit” 简化模式。

4.2 浏览器打开后，效果如下：

浏览器

• 和【授权码模式】基本一致，输入在 「② 配置登陆账号」 中配置的登陆账号 “yunai” / “1024” 。

4.3 登陆成功，直接授权完成，回调 redirect_uri 地址。如下图所示：

浏览器

• 和【授权码模式】基本不一致的有两点：
• 登陆成功后，无需选择允许所有申请的 Scope ，直接授权完成。
• 返回的不是授权码，而是访问令牌。

总的来说，【简化模式】是【授权码模式】的简化模式。

⑤ 调用资源服务器的 API

和【授权码模式】一致。

4.4 客户端模式

Maven 项目结构如下：

Maven 项目结构

对应 GitHub 地址：

github.com/YunaiV/Spri…

① 配置授权服务器

和【密码模式】一致。

② 配置登陆账号

它无需配置登陆账号。因为它没有用户的概念，直接与授权服务器交互，通过 Client 的编号( client_id )和密码( client_secret )来保证安全性。

③ 启动项目

和【密码模式】一致。

④ 获取访问令牌

1

arduino复制代码curl -X POST "http://localhost:8080/oauth/token" --user clientapp:112233 -d "grant_type=client_credentials&scope=read_contacts"

• 和【密码模式】基本一致，差别如下：
• 请求参数无需带上了 username 和 password 。
• 请求参数 grant\_type 为 client\_credentials ，表示【密码模式】。

返回结果示例如下：

1
2
3
4
5
6

json复制代码{
 "access_token":"cb2bdfd8-18fa-4b8f-b525-10587bd672e8",
 "token_type":"bearer",
 "expires_in":43199,
 "scope":"read_contacts"
}

• 和【密码模式】一致。

⑤ 调用资源服务器的 API

和【密码模式】一致。

总的来说，【客户端模式】是【密码模式】的简化模式。

4.5 如何选择？

可能很多胖友，有跟笔者一样的困惑。下面笔者引用杨波老师的一张图，相信能解决我们的困扰。如下图所示：

FROM 《深度剖析 OAuth2 和微服务安全架构》

授权类型选择

当然，对于黄框部分，对于笔者还是比较困惑的。笔者认为，第三方的单页应用 SPA ，也是适合采用 Authorization Code Grant 授权模式的。例如，《微信网页授权》 ：

具体而言，网页授权流程分为四步：

1、引导用户进入授权页面同意授权，获取code

2、通过code换取网页授权access_token（与基础支持中的access_token不同）

3、如果需要，开发者可以刷新网页授权access_token，避免过期

4、通过网页授权access_token和openid获取用户基本信息（支持UnionID机制）

所以，笔者猜测，之所以图中画的是 Implicit Grant 的原因是，受 Google 的 《OAuth 2.0 for Client-side Web Applications》 一文中，推荐使用了 Implicit Grant 。

当然，具体使用 Implicit Grant 还是 Authorization Code Grant 授权模式，没有定论。笔者，偏向于使用 Authorization Code Grant，对于第三方客户端的场景。

4.6 为什么有 Client 编号和密码

我们看到上述四种授权模式，无论是哪一种，最终调用授权服务器时，都会传递 Client 编号和密码，这是为什么呢？通过 Client 编号和密码，授权服务器可以知道调用的来源以及正确性。这样，即使“坏人”拿到 Access Token ，但是没有 Client 编号和密码，也不能和授权服务器发生有效的交互。

5. 刷新令牌

在 「4. 配置授权服务器」 中，我们一直没有看到我们期盼的刷新令牌( refresh token )的身影。这是为什么呢？因为我们在配置 Spring Security OAuth2 并未配置，获取访问令牌的同时，获取刷新令牌。

那么，怎么配置开启获取刷新令牌的功能呢？我们来看看 「5.1 获取刷新令牌」 。

5.1 获取刷新令牌

因为【密码模式】相对简单，我们直接在原有程序上做改造。对应 GitHub 地址：

github.com/YunaiV/Spri… 。

在步骤上，如果和原有【密码模式】保持一致的地方，下文会进行省略，并标注“和原有一致”。

① 配置授权服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

scala复制代码// 授权服务器配置
@Configuration
@EnableAuthorizationServer
public class OAuth2AuthorizationServer extends AuthorizationServerConfigurerAdapter {
 // 用户认证
 @Autowired
 private AuthenticationManager authenticationManager;
 @Override
 public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
 endpoints.authenticationManager(authenticationManager);
 }
 @Override
 public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
 clients.inMemory()
 .withClient("clientapp").secret("112233") // Client 账号、密码。
 .authorizedGrantTypes("password", "refresh_token") // 密码模式 // <1>
 .scopes("read_userinfo", "read_contacts") // 可授权的 Scope
// .and().withClient() // 可以继续配置新的 Client
 ;
 }
}

• 在 <1> 处，我们很神奇的多配置了一个 “refresh_token” ，用于开启获取刷新令牌的功能。但是但是但是，OAuth2 的授权模式说好的是四种的么，怎么又出现了 “refresh_token” 这种授权模式？淡定，在 Spring Security OAtuh2 中，”refresh_token” 作为一种特殊的授权模式配置，用于开启获取刷新令牌的功能。所以，其它授权模式如果开启获取刷新令牌的功能，需要在 #authorizedGrantTypes(…) 设置时，多传入 “refresh_token” 方法参数。

② 配置登陆账号

和原有一致。

③ 启动项目

和原有一致。

④ 获取访问令牌

1

bash复制代码curl -X POST --user clientapp:112233 http://localhost:8080/oauth/token -H "accept: application/json" -H "content-type: application/x-www-form-urlencoded" -d "grant_type=password&username=yunai&password=1024&scope=read_userinfo"

• 和原有一致。

返回结果示例如下：

1
2
3
4
5
6
7

json复制代码{
 "access_token":"092a2286-04e7-4e7d-8c20-19fbe25865ff",
 "token_type":"bearer",
 "refresh_token":"afeeb083-997f-4ea8-9334-aab6c1696cca",
 "expires_in":43199,
 "scope":"read_userinfo"
}

• 在原有的基础上，多返回了 “refresh_token” 刷新令牌。美滋滋。

⑤ 调用资源服务器的 API

和原有一致。

5.2 “刷新”访问令牌

因为访问访问令牌会自动过期，通过使用刷新令牌，可以获得新的访问令牌。注意，访问令牌获取到的是新的，不是老的哈。这也是为什么，在标题上，笔者对刷新加了双引号。

1

bash复制代码curl -i -X POST -u 'clientapp:112233' http://localhost:8080/oauth/token -H "accept: application/json" -d 'grant_type=refresh_token&refresh_token=afeeb083-997f-4ea8-9334-aab6c1696cca'

• 调用接口还是 “oauth/token” ，差别在于传入的请求参数 grant_type 为 “refresh_token”，使用刷新令牌。
• 请求参数 refresh_token 为上面获取到的刷新令牌 “afeeb083-997f-4ea8-9334-aab6c1696cca” 。

返回结果示例如下：

1
2
3
4
5
6
7

json复制代码{
 "access_token":"507eb761-4b25-4159-b927-ef3eff5e7eff",
 "token_type":"bearer",
 "refresh_token":"afeeb083-997f-4ea8-9334-aab6c1696cca",
 "expires_in":43199,
 "scope":"read_userinfo"
}

• 获得的访问令牌为 “507eb761-4b25-4159-b927-ef3eff5e7eff” ，是新的。并且，过期时间也变成新的。

笔者在看 OAuth2.0 的刷新令牌时，一直有个疑惑：刷新令牌是否有过期时间？答案是，有。但是，笔者不太确定，在 Spring Security OAuth2 中，如果不设置刷新令牌的过期时间，刷新时间是否无限长？当然，这个貌似也并不重要。因为，在实际使用中，我们肯定是需要显示( 主动 )设置刷新令牌的过期时间，使用 ClientBuilder#

refreshTokenValiditySeconds(int refreshTokenValiditySeconds) 方法，示例如下：

1
2
3
4
5
6
7
8
9
10

java复制代码@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
 clients.inMemory()
 .withClient("clientapp").secret("112233") // Client 账号、密码。
 .authorizedGrantTypes("password", "refresh_token") // 密码模式
 .scopes("read_userinfo", "read_contacts") // 可授权的 Scope
 .refreshTokenValiditySeconds(1200) // 1200 秒过期
// .and().withClient() // 可以继续配置新的 Client
 ;
}

刷新令牌过期时，返回结果示例如下：

1
2
3
4

json复制代码{
 "error":"invalid_token",
 "error_description":"Invalid refresh token (expired): 7139d075-c4ea-48f0-9dbb-6f65fa6dbeb0"
}

• 如果胖友要测试这个效果，可以把刷新令牌过期时间设置为 1 秒。

5.3 为什么需要有刷新令牌

出于安全性的考虑，访问令牌的过期时间比较短，刷新令牌的过期时间比较长。这样，如果访问令牌即使被盗用走，那么在一定的时间后，访问令牌也能在较短的时间吼过期。当然，安全也是相对的，如果使用刷新令牌后，获取到新的访问令牌，访问令牌后续又可能被盗用。

另外，刷新令牌是可选项，不一定会返回。

笔者整理了下，大家常用开放平台的令牌过期时间，让大家更好的理解：

• 小米开放平台
• 《Access Token 生命周期》
• Access Token ：90 天有效期
• Refresh Token ：10 年有效期
• 微信开放平台
• 《网站应用微信登录开发指南》
• Access Token ：2 小时有效期
• Refresh Token ：未知有效期
• 腾讯开放平台
• 《获取 Access_Token》
• Access Token ：90 天有效期
• Refresh Token ：未知有效期

6. 删除令牌

实际在 OAuth2 时，有删除访问令牌和刷新令牌的需求。例如：用户登出系统。虽然说，可以通过客户端本地删除令牌的方式实现。但是，考虑到真正的彻底的实现删除令牌，必然服务端自身需要删除令牌。

在 Spring Security OAuth2 中，并没有提供内置的接口，所以需要自己去实现。笔者参看 《Spring Security OAuth2 – Simple Token Revocation》 文档，实现删除令牌的 API 接口。

因为【密码模式】相对简单，我们直接在原有程序上做改造。对应 GitHub 地址： 。注意，如下仅仅是 Demo ，实际生产环境下需要做改造。

6.1 删除访问令牌

① 新增删除访问令牌的 API 接口

1
2
3
4
5
6
7

less复制代码@Autowired
private ConsumerTokenServices tokenServices;
@RequestMapping(method = RequestMethod.POST, value = "api/access_token/revoke")
public String revokeToken(@RequestParam("token") String token) {
 tokenServices.revokeToken(token);
 return token;
}

• 使用 ConsumerTokenServices#revokeToken(String tokenValue) 方法，删除访问令牌。

注意，实际生产环境下，授权服务器和资源服务器是不在一起的，所以此处仅仅是示例。主要是为了介绍 ConsumerTokenServices#revokeToken(String tokenValue) 方法的使用。

② 访问删除访问令牌的 API 接口。

1

bash复制代码curl -X POST http://localhost:8080/api/access_token/revoke -H "authorization: Bearer 23874e0b-a1d8-4337-9551-7b9be1ebaebe" -d "token=23874e0b-a1d8-4337-9551-7b9be1ebaebe"

移除成功后，在使用当前访问令牌，就会报如下错误：

1
2
3
4

json复制代码{
 "error":"invalid_token",
 "error_description":"Invalid access token: 23874e0b-a1d8-4337-9551-7b9be1ebaebe"
}

另外，也可以参考

github.com/geektime-ge… 的实现。

6.2 删除刷新令牌

① 新增删除访问令牌的 API 接口

1
2
3
4
5
6
7

less复制代码@Autowired(required = false) // <1>
private TokenStore tokenStore;
@RequestMapping(method = RequestMethod.POST, value = "api/refresh_token/revoke")
public String revokeRefreshToken(@RequestParam("token") String token) {
 tokenStore.removeRefreshToken(new DefaultOAuth2RefreshToken(token));
 return token;
}

• <1> 处，使用了 required = false 的原因是，本示例并未显示声明 TokenStore Bean 对象交给 Spring 管理，所以无法注入。 所以 「6.2 删除刷新令牌」 是一个无法跑通的示例。
• 重点在于，调用 TokenStore#removeRefreshToken(OAuth2RefreshToken token) 方法，删除刷新令牌。

② 访问删除刷新令牌的 API 接口。

1

bash复制代码curl -X POST http://localhost:8080/api/refresh_token/revoke -H "authorization: Bearer 52e85411-ac1d-4844-bf03-cf5633e4eecd" -d "token=ead4734a-ca5c-45bf-ac25-9a92291a9fe1"

移除成功后，在使用当前刷新令牌，就会报如下错误：

1
2
3
4

json复制代码{
 "error":"invalid_token",
 "error_description":"Invalid refresh token: ead4734a-ca5c-45bf-ac25-9a92291a9fe1"
}

另外，也可以参考

github.com/geektime-ge… 的实现。

6.3 RFC7009 - OAuth2 Token Revocation

在 OAuth2 中，删除令牌，标准的说法为 OAuth2 Token 撤销，对应 RFC7009 。感兴趣的胖友，可以看看。

FROM 《OAuth2 Token 撤销（RFC7009 - OAuth2 Token Revocation）》

简单来说，这个协议规定了一个Authorization server提供一个怎样的API来供Client撤销access_token或者refresh_token。

比如Client发起一个如下的请求：

POST /revoke HTTP/1.1

Host: server.example.com

Content-Type: application/x-www-form-urlencoded

Authorization: Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW

token=45ghiukldjahdnhzdauz&token_type_hint=refresh_token

其中各项含义如下：

1. /revoke：是Authorization Server需要提供的API地址，Client使用Post方式请求这个地址。
2. Content-Type: application/x-www-form-urlencoded：固定此格式。
3. Authorization: Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW：访问受保护资源的授权凭证。
4. token：必选，可以是access_token或者refresh_token的内容。
5. token_type_hint：可选，表示token的类型，值为”access_token“或者”refresh_token”。

如果撤销成功，则返回一个HTTP status code为200的响应就可以了。

7. 令牌元数据

FROM 《OAuth2 Token 元数据（RFC7662 - OAuth2 Token Introspection）》

简单的总结来说，这个规范是为OAuth2扩展了一个API接口（Introspection Endpoint），让第三方Client可以查询上面提到的那些信息（比如，access_token是否还有效，谁颁发的，颁发给谁的，scope又哪些等等的元数据信息）。

比如Client发起一个如下的请求：

POST /introspect HTTP/1.1

Host: server.example.com

Accept: application/json

Content-Type: application/x-www-form-urlencoded

Authorization: Bearer 23410913-abewfq.123483

token=2YotnFZFEjr1zCsicMWpAA&token_type_hint=access_token

看起来和上面的撤销Token的请求差不多，其中各项含义如下：

1. /introspect：是Authorization Server需要提供的API地址，Client使用Post方式请求这个地址。
2. Accept:application/json：表示Authorization Server需要返回一个JSON格式的数据。
3. Content-Type: application/x-www-form-urlencoded：固定此格式。
4. Authorization: Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW：访问受保护资源的授权凭证。
5. token：必选，可以是access_token或者refresh_token的内容。
6. token_type_hint：可选，表示token的类型，值为”access_token“或者”refresh_token”。

如果请求成功，则会返回如下的信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

json复制代码 1 {
 2 "active": true,
 3 "client_id": "l238j323ds-23ij4",
 4 "token_type":"access_token",
 5 "username": "jdoe",
 6 "scope": "read write dolphin",
 7 "sub": "Z5O3upPC88QrAjx00dis",
 8 "aud": "https://protected.example.net/resource",
 9 "iss": "https://server.example.com/",
10 "exp": 1419356238,
11 "iat": 1419350238,
12 "nbf": 1419350238,
13 "jti": "abcdefg"
14 "extension_field": "twenty-seven"
15 }

JSON各项属性含义如下（其中有些信息是在JSON Web Token中定义的，参考链接有详细的介绍）:

1. active：必须的。表示token是否还是有效的。
2. client_id：可选的。表示token所属的Client。比如上面的在线打印并且包邮的网站。
3. token_type：可选的。表示token的类型。对应传递的token_type_hint。
4. user_name：可选的。表示token的授权者的名字。比如上面的小明。
5. scope：可选的。和上篇5.1.1 Authorization Request中的可选参数scope对应，表示授权给Client访问的范围，比如是相册，而不是小明的日志以及其他受保护资源。
6. sub：可选的。token所属的资源拥有者的唯一标识，JWT定义的。也就是小明的唯一标识符。
7. aud：可选的。token颁发给谁的，JWT定义的。
8. iss：可选的。token的颁发者，JWT定义的。
9. exp：可选的。token的过期时间，JWT定义的。
10. iat：可选的。iss颁发token的时间，JWT定义的。
11. nbf：可选的。token不会在这个时间之前被使用，JWT定义的。
12. jti：可选的。token的唯一标识，JWT定义的。
13. extension_field：可以自己扩展相关其他属性。

其中大量的信息都是可选的信息，而且可以自己扩展需要的属性信息，从这些属性中就可以解决我们上面提到的access_token对于Client不透明的问题。

我们注意到其中有很多属于JWT定义的属性，那么这个JWT是什么东西？它解决了什么问题？感兴趣的胖友，可以看看 《JSON Web Token (JWT)》 。

对于令牌元数据 API 接口的实现，笔者这里就暂时不提供。如果有需要的胖友，可以看看 TokenStore 的两个 API ：

• #readAccessToken(String tokenValue) 方法，读取指定的访问令牌的信息。
• #readRefreshToken(String tokenValue) 方法，读取指定的刷新令牌的信息。

666. 彩蛋

一万个注意，本文仅仅是 Spring Security OAuth2 的入门文章。实际生产使用时，还需要做很多事情。例如：

• 使用关系数据库，持久化存储 Client 和令牌信息。例如，使用 JdbcTokenStore 。
• 授权服务器和资源服务器分离。例如，使用 RemoteTokenServices 。
• 使用缓存服务器，提升 Client 和令牌信息的访问速度。例如，使用 RedisTokenStore 。

推荐阅读文章：

• CatalpaFlat 《Spring Security OAuth2 深入解析》
• 小东子 《Spring Security OAuth2 开发指南》
• 聊聊架构 《轻松筹 1.6 亿注册用户的 Passport 账户体系架构设计》

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

Food Truck 是一个基于 Javascript(Typescript) 开发的餐车点餐系统, 该系统包括了用户短信注册, 点餐, 下单支付*的完整流程.
将开发过程分为7个步骤, 每个步骤在 Github 的代码仓库中都有对应的分支(从 *phase/1 到 phase/7), 方便参考.

Food Truck is an online food ordering app based on Javascript(Typescript), this system covers the flow from registering, menu navigating and placing orders. I split this flow into 7 steps, each step corresponds to a branch of this repository.

• Day 1 搭建前后端项目脚手架 Building scaffolding for the back-end and the front-end projects
• Day 2 重构后端项目, 前端引入状态管理 refactoring back-end project, and introducing state management into the front-end project
• Day 3 前端的 UI 设计和开发 Designing and developing UI at the front-end
• Day 4 手机短信注册和登录 Signin / signup with OTP
• Day 5 数据库的支持 Database supporting
• Day 6 支付 Making a payment with Stripe
• Day 7 持续集成 Continuous integration and continuous deployment (CI/CD)
• 编外 Others

虽然说7天从头到尾开发一个全栈的应用有些夸张, 但是本文展示了如何运用成熟的云原生技术, 高效的搭建一个应用可能性. 这是一个针对有一定开发经验的初级教程, 所以并不会深入讨论每一个技术点, 但是会较全面的覆盖开发一个全栈应用的所有方面, 也包括持续集成(CI/CD) 方面的内容.

Although it is an exaggeration to develop a full-stack application in 7 days, but this article shows how to use mature cloud technology to build an application possibility. This is a primary tutorial for new bees with a little development experience, so it will not deep dive every technical point, but it will cover all aspects of developing a full-stack application, including continuous integration (CI/ CD).

服务端采用了 Node.js 和 Koa2 框架. 用户鉴权是基于 AWS 的 Cognito, 注册登入涉及的后台 Lambda Function 是在前端的工程里, 由 AWS Amplify 提供支持. 支付采用了 Stripe 提供的服务.

The server uses the Node.js and Koa2 frameworks. User authentication is based on Cognito of AWS, the backend Lambda Function involved in registration and login is in the front-end project and is supported by AWS Amplify. Payment uses the service provided by Stripe.

前端采用 Vue3, 考虑第三方库的兼容性问题, 没有采用 Vite 作为开发和打包工具.

The front-end uses Vue3

作为抛砖引玉, 这篇文章提供一个大家可以学习交流的起点, 有兴趣的同学欢迎加微信和笔者互相交流.

As an introduction, this article provides a starting point for everyone to learn and communicate. It is welcome to add WeChat to communicate with the author.

相关的代码仓库如下:

The relevant code repositories are as follows:

后端代码仓库 Back-end

前端代码仓库 Front-end

共享库 Shared library

代码仓库暂时不公开, 有需要交流学习的同学可以添加联系方式。

Day 1 搭建前后端项目脚手架

”工欲善其事，必先利其器“
If a worker wants to do his job well, he must first sharpen his tools

• 高效的开发环境和顺畅的持续集成流程决定了开发的效率. 在 MacOS 下建议安装 iTerm2, Oh-My-Zsh 并配置 Powerlevel10K 的 theme. 这里不详细展开这些工具的安装了, 有兴趣的同学可以上网搜一下. 这是我的开发环境.

An efficient development environment and a smooth continuous integration process guarantees the efficiency of development. Under MacOS, it is recommended to install iTerm2, Oh-My-Zsh and then configure the theme of Powerlevel10K. The installation of these tools will not be discussed here, if you are interested in these tools, you can google it. This is my development environment.

• 如果是一个团队参与一个项目的开发, 在开发时统一代码规范也是很重要的, 这个章节会重点描述 ESLint 和 Prettier 的配置来规范团队的代码.

It is very important to unify the code style during development if a team is involved in a project. This section will focus on the configuration of ESLint and Prettier to standardize the team’s code style.

从零到一创建一个后端的工程(create backend project from scratch)

1. 先在 Github 上创建一个仓库 ft-node
   create ft-node repository on Github first

• 初始化本地 git 仓库, 并推送到 Github 仓库中
  initialize the local repository, and push it onto the remote repository under Github

1
2
3
4
5
6
7

shell复制代码mkdir backend && cd backend
echo "# ft-node" >> README.md
git init
git add README.md
git commit -m "first commit"
git remote add origin git@github.com:quboqin/ft-node.git
git push -u origin main

• 添加 .gitignore
  add .gitignore file

1
2
3
4
5
6

bash复制代码# .gitignore
# Dependency directory
node_modules

# Ignore built ts files
dist

2. 初始化 npm 和 Typescript 项目
   Intialize the node.js project with npm, and configure Typescript

1
2
3
4
5
6
7
8
9
10
11
12

shell复制代码# 创建代码目录
mkdir src
# 初始化 npm 项目
npm init -y
# 在初始化 Typescript 项目前先在本地安装 typescript
npm install typescript --save-dev
# 初始化 typescript 项目
npx tsc --init --rootDir src --outDir dist \
--esModuleInterop --target esnext --lib esnext \
--module commonjs --allowJs true --noImplicitAny true \
--resolveJsonModule true --experimentalDecorators true --emitDecoratorMetadata true \
--sourceMap true --allowSyntheticDefaultImports true

3. 安装 Koa, Koa Router 和 @Koa/cors(支持跨域), 以及对应的类型依赖

1
2

shell复制代码npm i koa koa-router @koa/cors
npm i @types/koa @types/koa-router types/koa__cors --save-dev

4. 创建一个简单 Koa 服务

• 在 src 目录下创建 server.ts 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

typescript复制代码// server.ts
import Koa from 'koa'
import Router from 'koa-router'
import cors from '@koa/cors'

const app = new Koa()
const router = new Router()

app.use(cors())

router.get('/checkHealth', async (ctx) => {
  ctx.body = {
    code: 0,
    data: 'Hello World!',
  }
})

app.use(router.routes())

app.listen(3000)

console.log('Server running on port 3000')

• 测试

1
2
3

shell复制代码npx tsc
node dist/server.js
Server running on port 3000

5. 安装 ts-node 和 nodemon, Running the server with Nodemon and TS-Node, 并修改 package.json 中的脚本

1
2
3

shell复制代码npm i ts-node nodemon --save-dev
# 如果 typescript 安装在全局环境下
# npm link typescript

修改 package.json

1
2
3
4
5

json复制代码  "scripts": {
    "dev": "nodemon --watch 'src/**/*' -e ts,tsx --exec ts-node ./src/server.ts",
    "build": "rm -rf dist && tsc",
    "start": "node dist/server.js"
  },

6. 配置 ESLint 和 Prettier

Lint

• 安装 eslint 和相关依赖

1

shell复制代码npm i eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin --save-dev

• eslint: The core ESLint linting library
• @typescript-eslint/parser: The parser that will allow ESLint to lint TypeScript code
• @typescript-eslint/eslint-plugin: A plugin that contains a bunch of ESLint rules that are TypeScript specific

• 添加 .eslintrc.js 配置文件
  可以通过, 以交互的方式创建

1

shell复制代码npx eslint --init

但是建议手动在项目的 root 目录下创建这个文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

javascript复制代码// .eslintrc.js
module.exports = {
  parser: '@typescript-eslint/parser',  // Specifies the ESLint parser
  parserOptions: {
    ecmaVersion: 2020,  // Allows for the parsing of modern ECMAScript features
    sourceType: 'module', // Allows for the use of imports
  },
  extends: [
    'plugin:@typescript-eslint/recommended', // Uses the recommended rules from the @typescript-eslint/eslint-plugin
  ],
  rules: {
    // Place to specify ESLint rules. Can be used to overwrite rules specified from the extended configs
    // e.g. "@typescript-eslint/explicit-function-return-type": "off",
  },
}

• 添加 Prettier

1

shell复制代码npm i prettier eslint-config-prettier eslint-plugin-prettier --save-dev

• prettier: The core prettier library
• eslint-config-prettier: Disables ESLint rules that might conflict with prettier
• eslint-plugin-prettier: Runs prettier as an ESLint rule

In order to configure prettier, a .prettierrc.js file is required at the root project directory. Here is a sample .prettierrc.js file:

1
2
3
4
5
6
7

javascript复制代码// .prettierrc.js
module.exports = {
  tabWidth: 2,
  semi: false,
  singleQuote: true,
  trailingComma: 'all',
}

Next, the .eslintrc.js file needs to be updated:

1
2
3
4
5

javascript复制代码// eslintrc.js
extends: [
  "plugin:@typescript-eslint/recommended", // Uses the recommended rules from the @typescript-eslint/eslint-plugin
  "plugin:prettier/recommended" // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
],

• Automatically Fix Code in VS Code
  • 安装 eslint 扩展, 这里不需要安装 prettier 扩展
    并点击右下角激活 eslint 扩展
    
  • 在 VSCode 中创建 Workspace 的配置

1
2
3
4
5
6

json复制代码{
  "editor.formatOnSave": false,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": true
  },
}

• Run ESLint with the CLI
  • A useful command to add to the package.json scripts is a lint command that will run ESLint.

1
2
3
4
5

json复制代码{
  "scripts": {
    "lint": "eslint '*/**/*.{js,ts,tsx}' --quiet --fix"
  }
}

• 添加 .eslintignore

1
2
3
4

bash复制代码# don't ever lint node_modules
node_modules
# don't lint build output (make sure it's set to your correct build folder name)
dist

• Preventing ESLint and formatting errors from being committed

1

shell复制代码npm install husky lint-staged --save-dev

To ensure all files committed to git don’t have any linting or formatting errors, there is a tool called lint-staged that can be used. lint-staged allows to run linting commands on files that are staged to be committed. When lint-staged is used in combination with husky, the linting commands specified with lint-staged can be executed to staged files on pre-commit (if unfamiliar with git hooks, read about them here).

To configure lint-staged and husky, add the following configuration to the package.json file:

1
2
3
4
5
6
7
8
9
10
11
12

json复制代码{
  "husky": {
      "hooks": {
          "pre-commit": "lint-staged"
      }
  },
  "lint-staged": {
      "*.{js,ts,tsx}": [
          "eslint --fix"
      ]
  }
}

初始化 Vue3 前端

1. 通过 Vue Cli 创建前端项目

1
2
3
4
5
6

shell复制代码# 参看 vue cli 的版本
vue --version
# 更新一下最新版本
npm update -g @vue/cli
# 创建项目
vue create frontend

2. 用 Vue Cli 创建的脚手架已经配置好大部分 ESLint 和 Prettier, 这里只要统一一下前后端的 Prettier 设置

• 添加 .prettierrc.js 文件

1
2
3
4
5
6
7

javascript复制代码// .prettierrc.js
module.exports = {
  tabWidth: 2,
  semi: false,
  singleQuote: true,
  trailingComma: 'all',
}

• 同样修改 workspace 的配置

1
2
3
4
5
6

json复制代码{
  "editor.formatOnSave": false,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": true
  }
}

3. 运行 npm run lint

前端引入 Axois, 访问接口(health interface)

1. 安装 axios 模块

1

shell复制代码npm i axios --save

2. 封装 axios 模块, 设置默认 URL

1
2

typescript复制代码// src/utils/axios.ts
axios.defaults.baseURL = 'http://localhost:3000'

3. 封装 src/apis/health.ts 文件

1
2
3
4
5
6

typescript复制代码// src/apis/health.ts
import { result } from '@/utils/axios'

export function checkHealth<U>(): Promise<U | void> {
  return result('get', '/checkHealth')
}

4. 在 App.vue 中调用 checkHealth 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

vue复制代码<script lang="ts">
import { defineComponent, onMounted } from 'vue'

import { checkHealth } from '@/apis/health'

export default defineComponent({
  name: 'App',
  setup() {
    const init = async () => {
      checkHealth()
    }
    onMounted(init)
  },
})
</script>

这个阶段完成了一个最简单 APP 的前后端工程的搭建. 我这里规范了前后端的代码, 同学可以根据自己团队的代码规范添加不同的规则.

Javascript & Typescript Essential

Day 2 重构后端项目 前端引入状态管理

重构服务端

引入服务端日志库 logger 和 winston

1
2
3
4
5

shell复制代码# logger 作为记录请求的中间件
npm install koa-logger --save
npm install @types/koa-logger --save-dev
# winston 用于后端其他地方的日志记录
npm install winston --save

效果如下

引入 dotenv , 从环境变量和环境变量配置文件读取配置

1. node 的后端服务是在运行时动态加载这些环境变量的，代码里我采用了 dotenv 模块来加载环境变量

1

shell复制代码npm install dotenv --save

2. 读取环境变量

1
2
3
4
5

typescript复制代码// src/config/index.ts
import { config as dotenv } from 'dotenv'

const env = dotenv({ path: `.env.${process.env.NODE_ENV}` })
if (env.error) throw env.error

3. ** 两个注意点 **

• 如果 NODE_ENV 设置为 production, npm ci 不会安装 devDependencies 中的依赖包，如果在运行的 EC2 上编译打包，编译会报错。所以打包编译我放在了 Github Actions 的容器中了，所以避免了这个问题

We have installed all our packages using the –save-dev flag. In production, if we use npm install –production these packages will be skipped.

• 操作系统下设置的环境变量会覆盖 .env 文件中定义的环境变量, 一般会把敏感的信息, 例如密码和密钥直接定义在系统的环境变量里, 而不是放在 .env 的文件下, 这样避免将代码提交到公开的代码仓库带来安全的隐患.

4. 配置文件的加载逻辑都放到 config 目录下
   

服务端拆解 App 和 Server

1. index.ts 只保留了启动 http 服务和其他连接数据库的服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

typescript复制代码// src/index.ts
import * as http from 'http'
import app from './app'

import wsLogger from './utils/ws-logger'

async function initializeDB(): Promise<void> {
  wsLogger.info(`Connect database...`)

  return
}

async function bootstrap(port: number) {
  const HOST = '0.0.0.0'

  return http.createServer(app.callback()).listen(port, HOST)
}

try {
  ;(async function (): Promise<void> {
    await initializeDB()

    const HTTP_PORT = 3000
    await bootstrap(HTTP_PORT)

    wsLogger.info(`🚀 Server listening on port ${HTTP_PORT}!`)
  })()
} catch (error) {
  setImmediate(() => {
    wsLogger.error(
      `Unable to run the server because of the following error: ${error}`,
    )
    process.exit()
  })
}

2. app.ts 负责各种中间件的加载, 并安装 bodyParser

1
2

shell复制代码npm install koa-bodyparser --save
npm install @types/koa-bodyparser --save-dev

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

typescript复制代码// src/app.ts
import Koa from 'koa'
import cors from '@koa/cors'
import logger from 'koa-logger'
import bodyParser from 'koa-bodyparser'

import wrapperRouter from './apis'

const app = new Koa()

app.use(cors())
app.use(logger())
app.use(bodyParser())

const wpRouter = wrapperRouter()
app.use(wpRouter.routes()).use(wpRouter.allowedMethods())

export default app

搭建 RCS 模型, 将 server.ts 拆成 http 服务, Koa2 中间件和 koa-router 三个模块, 符合单一职责的设计原理

the logic should be divided into these directories and files.

• Models - The schema definition of the Model
• Routes - The API routes maps to the Controllers
• Controllers - The controllers handles all the logic behind validating request parameters, query, Sending Responses with correct codes.
• Services - The services contains the database queries and returning objects or throwing errors

1. router 拆解到 apis 目录下, 按模块提供不同的接口, 并通过动态的方式加载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

typescript复制代码// src/apis/index.ts
import * as fs from 'fs'
import * as path from 'path'
import Router from 'koa-router'

import { serverConfig } from '../config/server'
const { apiVersion } = { apiVersion: serverConfig.apiVersion }

export default function wrapperRouter(): Router {
  const router = new Router({
    prefix: `/api/${apiVersion}`,
  })

  const baseName = path.basename(__filename)

  fs.readdirSync(__dirname)
    // 过滤掉 apis 根目录下的 index.js 和 index.js.map 文件
    .filter(
      (file) =>
        file.indexOf('.') !== 0 && file !== baseName && !file.endsWith('.map'),
    )
    .forEach((file) => {
      import(path.join(__dirname, file)).then((module) => {
        router.use(module.router().routes())
      })
    })

  return router
}

2. apis 下各个子模块的拆解如下图
   

构建前端路由, 引入 Vue 3.0 的状态管理 Provide 和 Inject

用 Vue3 的 Provide 和 Inject 替代 Vuex
参考 Using provide/inject in Vue.js 3 with the Composition API

用 npm 搭建共享的 Lib, 共享数据对象(Building and publishing an npm typescript package)

参考 Step by step: Building and publishing an NPM Typescript package.

1. 创建目录

1

shell复制代码mkdir lib && cd lib

2. 初始化 git 仓库

1
2
3
4

shell复制代码git init
git checkout -b main
echo "# Building and publishing an npm typescript package" >> README.md
git add . && git commit -m "Initial commit"

3. 初始化 npm 项目

1
2
3

shell复制代码npm init -y
echo "node_modules" >> .gitignore
npm install --save-dev typescript

4. 配置 tsconfig.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

json复制代码{
  "compilerOptions": {
    "target": "es2017",
    "module": "commonjs",
    "outDir": "./lib",
    "sourceMap": true,
    "strict": true,
    "noImplicitAny": true,
    "declaration": true,
    "strictPropertyInitialization": false,
    "experimentalDecorators": true /* Enables experimental support for ES7 decorators. */,
    "emitDecoratorMetadata": true /* Enables experimental support for emitting type metadata for decorators. */
  },
  "include": ["src"],
  "exclude": ["node_modules", "**/__tests__/*"]
}

5. ignore /lib

1

shell复制代码echo "/lib" >> .gitignore

6. 配置 eslint

• 安装 eslint 和 typescript 相关依赖

1

shell复制代码npm i eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin --save-dev

• 创建 .eslintrc.js

1
2
3
4
5
6
7
8
9
10

javascript复制代码// .eslintrc.js
module.exports = {
  parser: '@typescript-eslint/parser',
  extends: ['plugin:@typescript-eslint/recommended', 'prettier/@typescript-eslint', 'plugin:prettier/recommended'],
  parserOptions: {
    ecmaVersion: 2018,
    sourceType: 'module',
  },
  rules: {},
}

• 安装 prettier

1

shell复制代码npm i prettier eslint-config-prettier eslint-plugin-prettier -D

• 创建 .prettierrc.js

1
2
3
4
5
6
7
8

javascript复制代码// .prettierrc.js
module.exports = {
  semi: false,
  trailingComma: 'all',
  singleQuote: true,
  printWidth: 120,
  tabWidth: 2,
}

• 配置 vscode workspace

1
2
3
4
5
6

json复制代码{
  "editor.formatOnSave": false,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": true
  },
}

• 添加 .eslintignore

1
2

bash复制代码node_modules
/lib

7. 配置 npm 库的输出文件

However, blacklisting files is not a good practice. Every new file/folder added to the root, needs to be added to the .npmignore file as well! Instead, you should whitelist the files /folders you want to publish. This can be done by adding the files property in package.json:

1
2
3

json复制代码  "files": [
    "lib/**/*"
  ],

8. Setup Testing with Jest

• 安装 Jest

1

shell复制代码npm install --save-dev jest ts-jest @types/jest

• Create a new file in the root and name it jestconfig.json:

1
2
3
4
5
6
7

json复制代码{
  "transform": {
    "^.+\\.(t|j)sx?$": "ts-jest"
  },
  "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
  "moduleFileExtensions": ["ts", "tsx", "js", "jsx", "json", "node"]
}

• Remove the old test script in package.json and change it to:

1

json复制代码"test": "jest --config jestconfig.json",

• 准备一个待测试的函数 index.ts

1
2

typescript复制代码// index.ts
export const Greeter = (name: string): string => `Hello ${name}`

• Write a basic test

In the src folder, add a new folder called tests and inside, add a new file with a name you like, but it has to end with test.ts, for example greeter.test.ts

1
2
3
4
5

typescript复制代码// greeter.test.ts
import { Greeter } from '../index';
test('My Greeter', () => {
  expect(Greeter('Carl')).toBe('Hello Carl');
});

then try to run

1

shell复制代码npm test

9. Use the magic scripts in NPM

• 修改脚本 package.json

1
2
3
4
5
6

json复制代码    "prepare": "npm run build",
    "prepublishOnly": "npm test && npm run lint",
    "preversion": "npm run lint",
    "version": "git add -A src",
    "postversion": "git push && git push --tags",
    "patch": "npm version patch && npm publish"

• Updating your published package version number
  To change the version number in package.json, on the command line, in the package root directory, run the following command, replacing <update_type> with one of the semantic versioning release types (patch, major, or minor):

1

shell复制代码npm version <update_type>

• Run npm publish.

10. Finishing up package.json

1
2
3

json复制代码  "description": "share library between backend and frontend",
  "main": "lib/index.js",
  "types": "lib/index.d.ts",

11. Publish you package to NPM!

• run npm login

1
2
3
4
5
6

shell复制代码╰─ npm login                                                                                                                                  ─╯
npm notice Log in on https://registry.npmjs.org/
Username: quboqin
Password: 
Email: (this IS public) qubo.qin.2018@gmail.com
Logged in as quboqin on https://registry.npmjs.org/.

12. install quboqin-lib on both sides(frontend and backend), and add test code

1

shell复制代码npm i quboqin-lib

Day 3 前端的界面设计和开发

创建数据模型, 更新 quboqin-lib

前端引入 Tailwind CSS UI 库

1. 用 Figma 设计一个 UI 的原型
   
2. 安装 Tailwind
   这是一个基于 utility-first 思想的 UI 库, 在它基础上上可以方便搭建 UI 界面, 基本不用在代码里写一行 css. 也方便后期维护
   安装中要注意 PostCSS 7 的兼容性

• 安装

1

shell复制代码npm install -D tailwindcss@npm:@tailwindcss/postcss7-compat postcss@^7 autoprefixer@^9

• Add Tailwind as a PostCSS plugin
  Add tailwindcss and autoprefixer to your PostCSS configuration.

1
2
3
4
5
6
7

javascript复制代码// postcss.config.js
module.exports = {
  plugins: {
    tailwindcss: {},
    autoprefixer: {},
  }
}

• Customize your Tailwind installation

1

shell复制代码npx tailwindcss init

• Include Tailwind in your CSS

1
2
3
4

css复制代码/* index.css */
@tailwind base;
@tailwind components;
@tailwind utilities;

then import this file in main.ts

1
2
3
4
5
6
7

typescript复制代码import { createApp } from 'vue'
import App from './App.vue'
import router from './router'

import './index.css'

createApp(App).use(router).mount('#app')

• When building for production, be sure to configure the purge option to remove any unused classes for the smallest file size:

1
2
3
4
5
6
7
8
9
10
11
12
13

javascript复制代码// tailwind.config.js
  module.exports = {
   purge: [
     './src/**/*.html',
     './src/**/*.js',
   ],
    darkMode: false, // or 'media' or 'class'
    theme: {
      extend: {},
    },
    variants: {},
    plugins: [],
  }

3. 其他组件库
   可以用 Tailwind 开发 UI 的组件, 这个工程里为了快速开发, 这里还引入了 Vant, 这是一个较早支持 Vue 3 的 UI 库

1
2

shell复制代码# Install Vant 3 for Vue 3 project
npm i vant@next -S

4. 用到了 materialdesignicons , 在 html 中添加

1

html复制代码<link href="https://cdn.jsdelivr.net/npm/@mdi/font@5.x/css/materialdesignicons.min.css" rel="stylesheet">

封装 Axios 和接口, 提供 Mock 数据

1
2
3
4
5
6

typescript复制代码// src/apis/goods.ts
import goods from '@/mock/goods.json'

export function getAllGoods(): Promise<Good[] | void> {
  return result('get', '/goods', null, goods as Good[])
}

本地支持HTTPS[Server]

1. 在项目的 root 目录下创建 local-ssl 子目录, 在 local-ssl 子目录下，新建一个配置文件 req.cnf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

ini复制代码[req]
distinguished_name = req_distinguished_name
x509_extensions = v3_req
prompt = no
[req_distinguished_name]
C = US
ST = California
L = Folsom
O = MyCompany
OU = Dev Department
CN = www.localhost.com
[v3_req]
keyUsage = critical, digitalSignature, keyAgreement
extendedKeyUsage = serverAuth
subjectAltName = @alt_names
[alt_names]
DNS.1 = www.localhost.com
DNS.2 = localhost.com
DNS.3 = localhost

2. 在 local-ssl 目录下创建本地证书和私钥

1

shell复制代码openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout cert.key -out cert.pem -config req.cnf -sha256

3. 修改 server 端代码支持本地 https

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

typescript复制代码// src/index.ts
  interface CERT_FILE {
    key: string
    cert: string
    ca?: string
  }

  const certPaths: Record<string, CERT_FILE> = {}

  certPaths[`${SERVER.LOCALHOST}`] = {
    key: './local-ssl/cert.key',
    cert: './local-ssl/cert.pem',
  }

  const httpsOptions = {
    key: fs.readFileSync(certPaths[config.serverConfig.server].key),
    cert: fs.readFileSync(certPaths[config.serverConfig.server].cert),
  }

  return https.createServer(httpsOptions, app.callback()).listen(port, HOST)

4. 启动 https 服务后，仍然报错

1
2
3
4
5
6
7

shell复制代码curl https://localhost:3000/api/v1/users
curl: (60) SSL certificate problem: unable to get local issuer certificate
More details here: https://curl.haxx.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above

在浏览器链接该 https 服务，也报错误，下载证书，双击导入密钥管理器，手动让证书受信

5. 前端接口也改成 https 访问

1
2

typescript复制代码// src/utils/axios.ts
axios.defaults.baseURL = 'https://localhost:3000/api/v1'

Day 4 手机登录和注册

用户鉴权和手机登录用到了 AWS 的 Cognito 和 Amplify 等服务

在前端工程里初始化 Amplify 和 Cognito

1. 初始化 Amplify

1

shell复制代码amplify init

默认创建了 dev 后端环境

2. 添加 Auth 服务

1

shell复制代码amplify add auth

**一定要选择 Manual Configuration **, 具体参数如下

否则 Cognito 后台配置会默认为 Username 方式鉴权, 而且无法修改

3. 添加 PreSignup 的函数[选择 Manual Configuration 可以在命令行里添加, 这步可以跳过]

1

shell复制代码amplify fucntion add

4. 更新这个四个 Lambda Functions 的逻辑
5. 推送 dev 环境

1

shell复制代码amplify push

6. 进入 AWS Console 的 Cognito, 手动绑定 PreSignup 函数[选择 Manual Configuration 在命令行里已经绑定, 这步可以跳过]
   
7. 给 CreateAuthChallenge 添加发送短信权限
   进入 Lambda 的 后台页面，找到对应环境下 dev 的 foodtruck4d6aa6e5CreateAuthChallenge 函数
   找到对应的 Role，在Role的后台添加 SNS 权限
   
8. 配置 SNS
   
9. 前端添加 Amplify 模块

• 安装依赖包

1

shell复制代码npm i aws-amplify aws-amplify-vue --save

• 初始化 Amplify 配置

1
2
3
4

typescript复制代码// main.ts
import Amplify from 'aws-amplify'
import awsconfig from './aws-exports'
Amplify.configure(awsconfig)

** 在 tsconfig.json 中添加

1

json复制代码"allowJs": true,

添加 aws-exports.d.ts

1
2
3

typescript复制代码// eslint-disable-next-line @typescript-eslint/ban-types
declare const awsmobile: {}
export default awsmobile

这两步都要, 否则打包会报以下错误

1
2
3
4
5
6
7
8

shell复制代码TS7016: Could not find a declaration file for module './aws-exports'. '/Users/qinqubo/magic/projects/full-stack/food-truck/frontend/src/aws-exports.js' implicitly has an 'any' type.
    4 |
    5 | import Amplify from 'aws-amplify'
  > 6 | import awsconfig from './aws-exports'
      |                       ^^^^^^^^^^^^^^^
    7 | Amplify.configure(awsconfig)
    8 |
    9 | import './index.css'

10. 团队其他成员如果在新的环境下开发
    clone 代码仓库后, 在项目根目录下

1

shell复制代码amplify init

Do you want to use an existing environment 选 Yes

后端工程添加 JWT 模块

1. 添加 JWT 的中间件的依赖

1
2

shell复制代码npm i jsonwebtoken jwk-to-pem --save
npm i @types/jsonwebtoken @types/jwk-to-pem --save-dev

2. 添加 JWT 中间件, 检查 cognito 的有效性

1

typescript复制代码// src/jwt/cognito.ts

3. 修改 app.ts

1
2
3
4
5
6
7
8
9

typescript复制代码// src/app.ts
const unprotectedRouter = wrapperRouter(false)
const protectedRouter = wrapperRouter(true)

app.use(unprotectedRouter.routes()).use(unprotectedRouter.allowedMethods())
app.use(jwtCognito(config.awsCognitoConfig))
app.use(protectedRouter.routes()).use(protectedRouter.allowedMethods())

export default app

4. apis 目录下分受保护的和不受保护的两类目录, 并修改路由加载逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

typescript复制代码// src/apis/index.ts
export default function wrapperRouter(isProtected: boolean): Router {
  const router = new Router({
    prefix: `/api/${apiVersion}`,
  })

  const subFolder = path.resolve(
    __dirname,
    isProtected ? './protected' : './unprotected',
  )

  // Require all the folders and create a sub-router for each feature api
  fs.readdirSync(subFolder).forEach((file) => {
    import(path.join(subFolder, file)).then((module) => {
      router.use(module.router().routes())
    })
  })

  return router
}

用 Postman 测试

1. 设置Content-Type为application/json
   
2. 设置Token
   
3. Query parameters

1
2

bash复制代码https://localhost:3000/api/v1/goods
https://localhost:3000/api/v1/users

Day 5 数据库的支持

Postgres 和数据模型

1. 在后端项目安装 postgres 相关 package

1

shell复制代码npm i typeorm reflect-metadata pg --save

2. 改造共享库

• 在共享库安装 typeorm

1

shell复制代码npm i typeorm --save

之后更新前后端的依赖

3. 在后端工程里安装 uuid

1
2

shell复制代码npm i uuid --save
npm i @types/uuid --save-dev

4. 通过 docker 连接数据库

• 添加 docker-compose.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

yaml复制代码version: '3.1'
services:
  db:
    image: postgres:10-alpine
    ports:
      - '5432:5432'
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: apidb
  admin:
    image: adminer
    restart: always
    depends_on:
      - db
    ports:
      - 8081:8080

• 添加 postgres 配置和连接代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

typescript复制代码// src/config/index.ts
export async function initializePostgres(): Promise<Connection | void> {
  if (postgresConfig) {
    try {
      return createConnection({
        type: 'postgres',
        url: postgresConfig.databaseUrl,
        ssl: postgresConfig.dbsslconn
          ? { rejectUnauthorized: false }
          : postgresConfig.dbsslconn,
        synchronize: true,
        logging: false,
        entities: postgresConfig.dbEntitiesPath,
      })
    } catch (error) {
      logger.error(error)
    }
  }
}

• 导入 goods 数据

1

shell复制代码npm run import-goods

Jest 测试服务层和数据库

1. 安装 Jest

1

shell复制代码npm i jest @types/jest ts-jest --save-dev

2. 配置 Jest

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

javascript复制代码// jest.config.js
/* eslint-disable max-len */
module.exports = {
  clearMocks: true,
  maxWorkers: 1,
  preset: 'ts-jest',
  testEnvironment: 'node',
  testMatch: [
    '**/__tests__/**/*.[jt]s?(x)',
    '!**/__tests__/coverage/**',
    '!**/__tests__/utils/**',
    '!**/__tests__/images/**',
    //   "**/?(*.)+(spec|test).[tj]s?(x)"
  ],
  globalSetup: './src/utils/jest.setup.ts',
}

1
2
3
4
5
6
7
8
9
10
11
12
13

javascript复制代码// ormconfig.js
module.exports = {
  name: 'default',
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  username: 'user',
  password: 'pass',
  database: 'test',
  logging: false,
  synchronize: true,
  entities: ['node_modules/quboqin-lib/lib/**/*.js'],
}

3. 在 src/tests 下添加两个测试用例

axois 不直接支持 URL的 Path Variable, .get(‘/:phone’, controller.getUser) 路由无法通过 axois 直接访问, 修改 getUsers, 通过 Query Parameter 提取 phone

1. Path parameters
   ** axois发出的请求不支持这种方式 **，可以在浏览器和Postman里测试这类接口

1

url复制代码https://localhost:3000/api/v1/addresses/24e583d5-c0ff-4170-8131-4c40c8b1e474

对应的route是

1
2

typescript复制代码  router
    .get('/:id', controller.getAddress)

下面的控制器里演示是如何取到参数的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

typescript复制代码  public static async getAddress(ctx: Context): Promise<void> {
    const { id } = ctx.params
    const address: Address = await postgre.getAddressById(id)

    const body = new Body()
    body.code = ERROR_CODE.NO_ERROR

    if (address) {
      body.data = address
    } else {
      body.code = ERROR_CODE.UNKNOW_ERROR
      body.message = `the card you are trying to retrieve doesn't exist in the db`
    }

    ctx.status = 200
    ctx.body = body
  }

• 如何现在Postman里测试接口

设置Content-Type为application/json

设置Token

2. Query parameters

1

bash复制代码https://localhost:3000/api/v1/addresses?phone=%2B13233013227&id=24e583d5-c0ff-4170-8131-4c40c8b1e474

3. Koa2 对应 Axios 返回的值, 以下是伪代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

typescript复制代码// Koa ctx: Context
interface ctx {
  status,
  body: {
    code,
    data,
    message
  }
}

// Axois response
interface response {
  status,
  data
}

response.data 对应 ctx.body, 所以在 Axios 获取 response 后, 是从 response.data.data 得到最终的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14

typescript复制代码function get<T, U>(path: string, params: T): Promise<U> {
  return new Promise((resolve, reject) => {
    axios
      .get(path, {
        params: params,
      })
      .then((response) => {
        resolve(response.data.data)
      })
      .catch((error) => {
        reject(error)
      })
  })
}

Day 6 手机支付

服务端的实现

1. 引入 stripe 库

1

shell复制代码npm i stripe --save

2. 配置 stripe

1
2
3
4
5
6
7
8
9
10
11

typescript复制代码// src/utils/stripe.ts
import Stripe from 'stripe'
import { config } from '../config'
import { PAYMENT_TYPE } from 'quboqin-lib/lib/card'

export const stripe = new Stripe(
  config.paymentType === PAYMENT_TYPE.STRIPE_ONLINE
    ? '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'
    : 'sk_test_DU1VhfGGYrEv5EvJS2my4yhD',
  { apiVersion: '2020-08-27' },
)

3. 在订单接口中发起支付调用

前端的实现

1. 在 html 文件里添加 stripe 全局模块

1

html复制代码    <script src="https://js.stripe.com/v3/"></script>

2. 添加 stripe 的封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

javascript复制代码// scr/utils/stripe.js

// eslint-disable-next-line no-undef
export const stripe = Stripe(
  process.env.VUE_APP_ONLINE_PAYMENT === '1'
    ? 'pk_live_51HZCSNLZTTlHwkSOdYTRnFdh0AxF7JNwXShbMrKfEPzxnXLPzGz0hXJJzKxybnWngvF89FKJRXxnr2fo8zpNlZ5700Nm864NNM'
    : 'pk_test_GrY8g9brTmOaRZ6XKks0woG0',
)

export const elements = stripe.elements()

const elementStyles = {
  base: {
    color: '#32325D',
    fontWeight: 500,
    fontFamily: 'Source Code Pro, Consolas, Menlo, monospace',
    fontSize: '16px',
    fontSmoothing: 'antialiased',

    '::placeholder': {
      color: '#CFD7DF',
    },
    ':-webkit-autofill': {
      color: '#e39f48',
    },
  },
  invalid: {
    color: '#E25950',

    '::placeholder': {
      color: '#FFCCA5',
    },
  },
}

const elementClasses = {
  focus: 'focused',
  empty: 'empty',
  invalid: 'invalid',
}

// export const cardIBan = elements.create('iban', {
//   ...{
//     style: elementStyles,
//     classes: elementClasses,
//   },
//   ...{
//     supportedCountries: ['SEPA'],
//     placeholderCountry: 'US',
//     hideIcon: true,
//   },
// })

export const cardNumber = elements.create('cardNumber', {
  style: elementStyles,
  classes: elementClasses,
})

export const cardExpiry = elements.create('cardExpiry', {
  style: elementStyles,
  classes: elementClasses,
})

export const cardCvc = elements.create('cardCvc', {
  style: elementStyles,
  classes: elementClasses,
})

3. 添加开发环境配置
   .env
   .env.development
   改造 axois 读取配置

1
2
3
4
5
6
7
8
9

typescript复制代码// src/utils/axios.ts
const port = process.env.VUE_APP_PORT
const url = process.env.VUE_APP_BASE_URL
axios.defaults.baseURL = port ? `${url}:${process.env.VUE_APP_PORT}` : `${url}`
axios.defaults.timeout = process.env.VUE_APP_TIMEOUT
  ? +process.env.VUE_APP_TIMEOUT
  : 5000
axios.defaults.headers.post['Content-Type'] =
  'application/x-www-form-urlencoded;charset=UTF-8'

4. 修改 CreditCardDetail.vue

Day 7 持续集成

前端编译环境和 Heroku, Amplify, 自建 Oracle VPS 的部署

部署到 Heroku

1. 创建 staging 和 production 两个独立的 APP
   与服务端部署不一样，两个环境都是在 Webpack 打包时注入了环境变量，两个环境都需要走 CI 的编译打包流程，所以通过 Pipeline 的 Promote 是没有意义的。我们这里创建两个独立的 APP：[staging-ft, production-ft]
2. 为每个 APP 添加编辑插件, 因为是静态部署，比 Node Server 多了一个插件

1
2

shell复制代码heroku buildpacks:add heroku/nodejs
heroku buildpacks:add https://github.com/heroku/heroku-buildpack-static

并且要添加 static.json 文件在项目的根目录下

1
2
3
4
5
6
7

json复制代码{
  "root": "dist",
  "clean_urls": true,
  "routes": {
    "/**": "index.html"
  }
}

3. 在两个 APP 的设置中绑定关联的 Github 仓库和分支
   这里的 VUE_APP_URL 是在 编译 时候，覆盖 axios 默认的 BASE_URL，指向对应的 Node Server，不同的分支也可以有不同的 Value. 与 Amplify 不同, 这里要设置 NODE_ENV=production，设置了这个后 npm ci 不会影响 install devDependencies 下的模块

通过 Amplify 部署

创建 amplify.yaml 文件，修改 build 的脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

yml复制代码version: 0.2
backend:
  phases:
    build:
      commands:
        - '# Execute Amplify CLI with the helper script'
        - amplifyPush --simple
frontend:
  phases:
    preBuild:
      commands:
        - npm ci
    build:
      commands:
        - nvm use $VERSION_NODE_10
        - node -v
        - if [ "${AWS_BRANCH}" = "aws-staging" ]; then echo "staging branch" && npm run build:staging; elif [ "${AWS_BRANCH}" = "aws-production" ]; then echo "production branch" && npm run build:production; else echo "test branch" && npm run build:mytest; fi
  artifacts:
    baseDirectory: dist
    files:
      - '**/*'
  cache:
    paths:
      - node_modules/**/*

当推送到对应的分支后，Amplify 会调用这个脚本执行编译，打包和部署

设置环境相关的变量

这里的 VUE_APP_URL 是在 编译 时候，覆盖 axios 默认的 BASE_URL，指向对应的 Node Server，不同的分支也可以有不同的 Value

• 注意不要添加 NODE_ENV=production，设置了这个后 npm ci 不会 install devDependencies 下的模块，会导致 npm run build 报错无法找到 vue-cli-service
• Vue 的 Webpack 会根据 --mode [staging | production ] 找到对应的 .env.\* 文件， 在这些中再声明 NODE_ENV=production

创建 Amplify 角色

创建 Amplify APP 时，好像没有自动创建关联的 Role, 我手动创建了一个

部署到 Oracle CentOS 8 服务器中的 Nginx 下

1. 配置 Nginx 支持单个端口对应多个二级域名的静态服务

• 编辑 /etc/nginx/nginx.conf 支持同一个端口，不同的静态服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

ini复制代码server {
    listen  80;
    server_name     test.magicefire.com;
    root            /usr/share/nginx/html/test;
    location / {}
}

server {
    listen  80;
    server_name     staging.magicefire.com;
    root            /usr/share/nginx/html/staging;
    location / {}
}

server {
    listen  80;
    server_name     production.magicefire.com;
    root            /usr/share/nginx/html/production;
    location / {}
}

建立对应的目录，在目录下放测试 html

• 修改 Cloudflare，添加三条 A 记录，支持 VPS 的 IP
  
• 通过 Let's Encrypt 修改 nginx 的 https 支持
  安装 certbot 见 Node Server 的部署

1

shell复制代码certbot -nginx

2. 在 .github/workflows 下添加 Github Actions, 编写 Github Actions 部署脚本

注意不要添加 NODE_ENV=production，设置了这个后 npm ci 不会 install devDependencies 下的模块，会导致 npm run build 报错无法找到 vue-cli-service
Vue 的 Webpack 会根据 –mode [staging | production ] 找到对应的 .env.* 文件， 在这些中再声明 NODE_ENV=production
3. 在 Github 的仓库设置中，给 Actions 用到的添加加密的 Secrets

DEPLOY_ORACLE=/usr/share/nginx/html

后端运行环境和 Heroku/EC2 部署

运行时根据环境加载配置项

1. 在 package.json 的脚本中通过 NODE_ENV 定义环境 [development, test, staging, production]
2. 安装 dotenv 模块, 该模块通过 NODE_ENV 读取工程根目录下对应的 .env.[${NODE_ENV}] 文件, 加载该环境下的环境变量
3. 按 topic[cognito, postgres, server, etc] 定义不同的配置, 并把 process.env.IS_ONLINE_PAYMENT 之类字符串形式的转成不同的变量类型
4. 可以把环境变量配置在三个不同的level

• 运行机器的 SHELL 环境变量中, 主要是定义环境的 NODE_ENV 和其他敏感的密码和密钥
• 在以 .${NODE_ENV} 结尾的 .env 文件中
• 最后汇总到 src/config 目录下按 topic 区分的配置信息
• 代码的其他地方读取的都是 src/config 下的配置信息

5. 在后端环境下设置 NODE_ENV 有一个副作用，在 Typescript 编译打包前

** 如果 NODE_ENV 设置为 production， npm ci 不会安装 devDependencies 中的依赖包，如果在运行的 EC2 上编译打包，编译会报错。所以打包编译我放在了Github Actions 的容器中了，所以避免了这个问题 **

We have installed all our packages using the –save-dev flag. In production, if we use npm install –production these packages will be skipped.

Amplify 创建线上用户库

1. 在前端，通过 Amplify 添加线上环境

1

shell复制代码amplify env add prod

2. 检查状态, 并部署到 Amplify 后台

1

shell复制代码amplify status

1

shell复制代码amplify push

进入 AWS Cognito 后台, 会增加一个线上的 UserPool

3. 添加 foodtruck2826b8ad2826b8adCreateAuthChallenge-prod 的短信权限
4. 修改线上配置文件中 AWS_COGNITO_USER_POOL_ID

1
2
3
4

arduino复制代码// .env.oracle
// .env.staging
// .env.production
AWS_COGNITO_USER_POOL_ID=ap-northeast-1_2ae9TN9FH

主要区分三个模块在不同环境的部署

• Postgres 数据库
• 支付
• 用户鉴权

修改 HTTPS 的证书加载

Heroku 部署

Heroku 是我们介绍的三种 CI/CD 流程中最简单的方式

1. 创建一条 Pipeline, 在 Pipeline 下创建 staging 和 production 两个应用
   
2. 在 APP 的设置里关联 Github 上对应的仓库和分支
   

• APP staging 选择 heroku-staging 分支
• APP production 选择 heroku-production 分支

3. 为每个 APP 添加 heroku/nodejs 编译插件

1
2

shell复制代码heroku login -i
heroku buildpacks:add heroku/nodejs -a staging-api-food-truck

4. 设置运行时的环境变量
   
   这里通过 SERVER 这个运行时的环境变量，告诉 index.ts 不要加载 https 的服务器， 而是用 http 的服务器。
   ** Heroku 的 API 网关自己已支持 https，后端起的 node server 在内网里是 http， 所以要修改代码 换成 http server，否者会报 503 错误**
5. 修改 index.ts 文件，在 Heroku 下改成 HTTP
6. APP production 一般不需要走 CI/CD 的流程，只要设置 NODE_ENV=production，然后在 APP staging 验证通过后， promote 就可以完成快速部署。
7. 查看 heroku 上的日志

1

shell复制代码heroku logs --tail -a staging-api-food-truck

AWS EC2 部署

在 AWS 上搭建环境和创建用户和角色

CodeDeploy

We’ll be using CodeDeploy for this setup so we have to create a CodeDeploy application for our project and two deployment groups for the application. One for staging and the other for production.

1. To create the api-server CodeDeploy application using AWS CLI, we run this on our terminal:

1
2
3

shell复制代码aws deploy create-application \
--application-name api-server \
--compute-platform Server

2. Before we run the cli command to create the service role, we need to create a file with IAM specifications for the role, copy the content below into it and name it code-deploy-trust.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

json复制代码{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "codedeploy.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

3. We can now create the role by running:

1
2
3

shell复制代码aws iam create-role \
--role-name CodeDeployServiceRole \
--assume-role-policy-document file://code-deploy-trust.json

4. After the role is created we attach the AWSCodeDeployRole policy to the role

1
2
3

shell复制代码aws iam attach-role-policy \
--role-name CodeDeployServiceRole \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSCodeDeployRole

5. To create a deployment group we would be needing the service role ARN.

1
2
3
4

shell复制代码aws iam get-role \
--role-name CodeDeployServiceRole \
--query "Role.Arn" \
--output text

The ARN should look something like arn:aws:iam::403593870368:role/CodeDeployServiceRole
6. Let’s go on to create a deployment group for the staging and production environments.

1
2
3
4
5

shell复制代码aws deploy create-deployment-group \
--application-name api-server \
--deployment-group-name staging \
--service-role-arn arn:aws:iam::403593870368:role/CodeDeployServiceRole \
--ec2-tag-filters Key=Name,Value=staging,Type=KEY_AND_VALUE

1
2
3
4
5

shell复制代码aws deploy create-deployment-group \
--application-name api-server \
--deployment-group-name production \
--service-role-arn arn:aws:iam::403593870368:role/CodeDeployServiceRole \
--ec2-tag-filters Key=Name,Value=production,Type=KEY_AND_VALUE

进入 Console -> Code Deploy 确认

创建 S3 Bucket

创建一个名为 node-koa2-typescript 的 S3 Bucket

1

shell复制代码aws s3api create-bucket --bucket node-koa2-typescript --region ap-northeast-1

Create and Launch EC2 instance

完整的演示，应该创建 staging 和 production 两个 EC2 实例，为了节省资源，这里只创建一个实例

1. 创建一个具有访问 S3 权限的角色 EC2RoleFetchS3
   
2. In this article, we will be selecting the Amazon Linux 2 AMI (HVM), SSD Volume Type.
   

• 绑定上面创建的角色，并确认开启80/22/3001/3002几个端口
  
• 添加 tag，key 是 Name，Value 是 production
  
• 导入用于 ssh 远程登入的公钥
  
• 通过 ssh 远程登入 EC2 实例，安装 CodeDeploy Agent
  安装步骤详见 CodeDeploy Agent

3. 通过 ssh 安装 Node.js 的运行环境

• 通过 NVM 安装 Node.js

1
2
3
4

shell复制代码curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash
source ~/.bash_profile
nvm list-remote
nvm install 14

• 安装 PM2 管理 node 的进程

1

shell复制代码npm i pm2 -g

• 在项目的根目录下创建 ecosystem.config.js 文件

1
2
3
4
5
6
7

javascript复制代码module.exports = {
  apps: [
    {
      script: './dist/index.js',
    },
  ],
}

4. 在 EC2 的实例 ec2-user 账号下设置环境变量, 编辑 ~/.bash_profile

1
2

bash复制代码export NODE_ENV=production
export SERVER=AWS

这里放置 NODE_ENV 和具有敏感信息的环境变量， 这里 SERVER=AWS 只是演示

创建用于 Github Actions 部署脚本的用户组和权限

1. 在 IAM 中创建以一个 CodeDeployGroup 用户组，并赋予 AmazonS3FullAccess and AWSCodeDeployFullAccess 权限
2. 在 CodeDeployGroup 添加一个 dev 用户，记录下 Access key ID 和 Secret access key
   

编写 Github Actions 脚本

1. 在工程的根目录下创建 .github/workflows/deploy-ec2.yaml 文件
   deploy-ec2.yaml 的作用是，当修改的代码提交到 aws-staging 或 aws-production，触发编译，打包，并上传到 S3 的 node-koa2-typescript bucket, 然后再触发 CodeDeploy 完成后续的部署。所以这个 Github Action 是属于 CI 的角色，后面的 CodeDeploy 是 CD 的角色。
2. 在 Github 该项目的设置中添加 Environment secrets, 将刚才 dev 用户的 Access key ID 和 Secret access key 添加进Environment secrets
   

添加 appspec.yml 及相关脚本

CodeDeploy 从 S3 node-koa2-typescript bucket 中获取最新的打包产物后，上传到 EC2 实例，解压到对应的目录下，这里我们指定的是 /home/ec2-user/api-server。CodeDeploy Agent 会找到该目录下的 appspec.yml 文件执行不同阶段的 Hook 脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14

yml复制代码version: 0.0
os: linux
files:
  - source: .
    destination: /home/ec2-user/api-server
hooks:
  AfterInstall:
    - location: aws-ec2-deploy-scripts/after-install.sh
      timeout: 300
      runas: ec2-user
  ApplicationStart:
    - location: aws-ec2-deploy-scripts/application-start.sh
      timeout: 300
      runas: ec2-user

aws-ec2-deploy-scripts/application-start.sh 启动了 Node.js 的服务

1
2
3
4
5

shell复制代码#!/usr/bin/env bash
source /home/ec2-user/.bash_profile
cd /home/ec2-user/api-server/
pm2 delete $NODE_ENV
pm2 start ecosystem.config.js --name $NODE_ENV

在 EC2 实例下安装免费的域名证书，步骤详见Certificate automation: Let’s Encrypt with Certbot on Amazon Linux 2

1. 去 Cloudflare 添加 A 记录指向这台 EC2 实例，指定二级域名是 aws-api
   
2. 安装配置 Apache 服务器，用于证书认证
3. Install and run Certbot

1

shell复制代码sudo certbot -d aws-api.magicefire.com

根据提示操作，最后证书生成在 /etc/letsencrypt/live/aws-api.magicefire.com/ 目录下
4. 因为我们启动 Node 服务的账号是 ec2-user， 而证书是 root 的权限创建的，所以去 /etc/letsencrypt 给 live 和 archive 两个目录添加其他用户的读取权限

1
2
3
4

shell复制代码sudo -i
cd /etc/letsencrypt
chmod -R 755 live/
chmod -R 755 archive/

5. Configure automated certificate renewal

部署和验证

1. 如果没有 aws-production 分支，先创建该分支，并切换到该分支下，合并修改的代码，推送到Github

1
2
3

shell复制代码git checkout -b aws-production
git merge main
git push orign

2. 触发 Github Actions
   
3. 编译，打包并上传到 S3 后，触发 CodeDeploy
   
4. 完成后在浏览器里检查
   
   或用 curl 在命令行下确认

1

shell复制代码curl https://aws-api.magicefire.com:3002/api/v1/health

5. 因为我们没有创建 EC2 的 staging 实例，如果推送到 aws-staging 分支，CodeDeploy 会提示以下错误
   

过程回顾

Postgres VPS 和 Heroku 部署[Server]

在 Heroku 上部署 Postgres

1. Provisioning Heroku Postgres

1
2

shell复制代码heroku addons
heroku addons:create heroku-postgresql:hobby-dev

2. Sharing Heroku Postgres between applications

1

shell复制代码heroku addons:attach my-originating-app::DATABASE --app staging-api-node-server

3. 导入商品到线上 table

1

shell复制代码npm run import-goods-heroku-postgre

在 VPS 上部署 Postgres

编外

支持 Swagger

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

背景

• 线上有N台机器配置一样，程序版本一样，但其中有一台机器会出现Content Switch上下文切换高的情况，其他机器并不会, 每台机器业务量差不多一致

相关知识点

上下文切换(context switch)

说明

• Linux 是一个多任务操作系统，它支持远大于 CPU 数量的任务同时运行
• 这些任务不是同时运行，而是系统在很短的时间内，将CPU轮流分配给它们，造成多任务同时运行的错觉
• 在每个任务运行前，CPU都需要知道任务从哪里加载、又从哪里开始运行，需要系统事先帮它设置好CPU 寄存器和程序计数器（Program Counter，PC）
  • CPU 寄存器，是 CPU 内置的容量小、但速度极快的内存
  • 程序计数器，用来存储 CPU 正在执行的指令位置、或者即将执行的下一条指令位置
  • CPU 在运行任何任务前，必须的依赖环境，叫做 CPU 上下文
• CPU 上下文切换就是先把前一个任务的 CPU 上下文（也就是 CPU 寄存器和程序计数器）保存起来
  • 然后加载新任务的上下文到这些寄存器和程序计数器，最后再跳转到程序计数器所指的新位置，运行新任务。
  • 保存下来的上下文，会存储在系统内核中，并在任务重新调度执行时再次加载进来
  • 这样能保证任务原来的状态不受影响，让任务看起来还是连续运行

场景

进程上下文切换

• Linux 按照特权等级
  • 内核空间（Ring 0）具有最高权限，可以直接访问所有资源
  • 用户空间（Ring 3）只能访问受限资源，不能直接访问内存等硬件设备，必须通过系统调用陷入到内核中，才能访问这些特权资源。
• 进程既可以在用户空间运行，也可以在内核空间中运行
  • 进程在用户空间运行时称为进程的用户态
  • 进程在内核空间运行时称为进程的内核态
  • 从用户态到内核态的转变，需要通过系统调用来完成
• 进程切换时才需要切换上下文

线程上下文切换

• 线程是调度的基本单位，而进程则是资源拥有的基本单位
• 当进程拥有多个线程时，这些线程会共享相同的虚拟内存和全局变量等资源。这些资源在上下文切换时是不需要修改的
• 线程也有自己的私有数据，比如栈和寄存器等，这些在上下文切换时也是需要保存的
• 线程的上下文切换其实就可以分为两种情况：
  • 前后两个线程属于不同进程。因为资源不共享，所以切换过程就跟进程上下文切换是一样
  • 前后两个线程属于同一个进程。因为虚拟内存是共享的，所以在切换时，虚拟内存这些资源就保持不动，只需要切换线程的私有数据、寄存器等不共享的数据
  • 虽然同为上下文切换，但同进程内的线程切换，要比多进程间的切换消耗更少的资源

中断上下文切换

• 为了快速响应硬件的事件，中断处理会打断进程的正常调度和执行，转而调用中断处理程序，响应设备事件

工具

vmstat

• vmstat 使用说明
  vmstat用于分析系统的内存使用情况，也可以分析 CPU 上下文切换和中断的次数, 正在运行和等待 CPU 的进程数过多，导致了大量的上下文切换，而上下文切换又导致了系统 CPU 的占用率升高

常用命令

1
2
3
4
5

bash复制代码# 每隔5秒输出1组数据
vmstat 5

# 格式化数据对齐
vmstat 1 3 | column -t

输出说明

• cs（context switch）是每秒上下文切换的次数
• in（interrupt）则是每秒中断的次数, 如果比较大可能有问题
• r（Running or Runnable）是就绪队列的长度，也就是正在运行和等待 CPU 的进程数, 大于CPU数, 说明有大量竞争
• b（Blocked）则是处于不可中断睡眠状态的进程数
• us（user）用户进程执行时间百分比(user time)
• sy（system）内核系统进程执行时间百分比(system time)

pidstat

• pidstat 使用说明
  pidstat用于查看每个进程的详细情况
• 安装

1

arduino复制代码apt-get install sysstat

常用命令

1
2
3
4
5
6