**软件版本还需要修改，仅可查看安装流程**
# kubeadm部署方式



kubeadm是官方社区推出的一个用于快速部署kubernetes集群的工具，这个工具能通过两条指令完成一饿kubernetes集群部署：

* 第一、创建一个Master节点 kubeadm init
* 第二、将node节点加入到当前集群中 $kubeadm join <Master 节点的Ip和端口>


## 1. 要求：

1. 新建3个虚拟机Ip地址，分别代表Master、node1、node2。
2. 机器配置：Centos7.x x_86_x64。硬件配置：2G或更多Ram，2个CPU或者更多GPu，硬盘30G
3. 集群中所有机器之间网络互通，可以访问外网。
4. 要禁止SWAP分区
5. 

```shell
yum install wget
```

## 2. 准备环境
![image.png](/static/img/2ec22252063ae80a75aaee2372c1c97f.image.png)

|角色|IP|
|:---|:---|
|master|192.168.1.11|
|node1|192.168.1.12|
|node2|192.168.1.13|

```shell
# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

# 关闭selinux
sed -i 's/enforcing/disabled/' /etc/selinue/config. # 永久
setenforce 0 # 临时

# 关闭swap
swapoff -a # 临时
sed -ri 's/.*swap.*/#$/' /etc/fstab   # 永久

# 根据规划设置主机名
hostnamectl set-hostname <hostname>


# 在master添加hosts
cat >> /etc/hosts <<EOF
192.168.44.141 master
192.168.44.142 node1
192.168.44.143 node2
EOF


# 将桥接的IPV4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.confg << EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
EOF
sysctl --system # 生效

# 时间同步
yum install ntpdate -y
ntpdate time.windows.com


```
> TODO 想想将以上的脚本写为shell，直接在三个服务中运行



## 3. 所有节点安装Docker/kubeadm/kubelet
Kubernetes默认CRI（容器运行时）为Docker，因此先安装Docker

### 3.1 安装Docker
```shell
wget https://mirros.aliyun.com/docker-ce/linux/centos/docker-ce.repo -o /etc/yum.repos.d/docker-ce.repo

yum -y install docker-ce-18.06.1.ce-3.e17
systemctl enable docker && systemctl start docker

docker --version

```
```shell
cat > /etc/docker/daemon.json << EOF
{
    "registry-mirrors":["https://b9pmyelo.mirror.aliyuncs.com"]
}
EOF


```
### 3.2 添加阿里云YUM软件源
```shell
cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernets]
name=Kubernets
baseurl=https://mirros.aliyun.com/kubernetes/yum/repos/kubernets-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
```

### 3.3 安装kubeadm，kubelet和kubectl
```shell
yum install -y kubelet-1.18.0 kubeadm-1.18.0 kubectl-1.18.0
systemctl enable kubelet

```
### 3.4 部署kubernets Master
在192.168.31.61（Master）执行：
```shell
kubeadm init \
--apiserver-advertises-address=192.168.44.141 \
--image-repository registry.aliyuncs.com/google_containers \
--kubernetes-version v1.18.0 \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16

```
由于默认拉取景象地址为k8s.gcr.lo国内无法访问，这里指定阿里云镜像仓库地址。
使用kubectl工具：
```shell
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf  $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

kubectl get nodes
```
### 3.5 加入kubernetes Node
在192.168.1.12/13（node）运行。
向集群添加新节点，执行在kubeadm init输出的kubeadm join明亮：
```shell
kubeadm join 192.168.1.11:6443 --token esce21.q6hetwm8si29qxwn --discovery-token-ca-cert-hash


```
默认token有效期24小时，当过期之后，该token就不可用了，这时就需要重新创建token，操作如下：
```shell
kubeadm token create --print-join-command
```

### 3.6 部署CNI网络插件
```shell
wget https://raw.githubusercontent.com/coreos/flannel/masster/Documentation/kube-flannel.yml
```
默认镜像地址无法访问，sed命令修改为docker hub镜像仓库
```shell
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

kubectl get pods -n kube-system
```

### 3.7 测试Kubernetes集群
在Kubernetes集群中创建一个pod，验证是否正常运行：
```
kubectl create deployment nginx --imgae=nginx
kubectl expose deployment nginx --port=80 --type=NodePort
kubectl get pod.svc

```
# 二进制包部署方式
[【尚硅谷】Kubernetes（k8s）入门到实战教程丨全新升级完整版](https://www.bilibili.com/video/BV1GT4y1A756/?p=9&share_source=copy_web&vd_source=ef6c842229f8fecfc4dcb8aa804c79b8)
## 1.环境搭建（同上）
## 2.操作系统初始化（同上）
## 3. 为etcd和apiserver 自签证书
### 3.1 准备cfssl证书

02  实战：k8s两种部署方式

## 1.概述和特征
### 概述
最早在2014年google开源的
主要做的是：容器化操作



传统化部署：脚本式或者安装的方式来实现
新的方式：容器化安装，带环境安装，关键技术：docker，docker一般用于单机编排

k8s：可以管理docker，进行容器化应用部署，使用k8s利于应用扩展，
    
    目标：实施让部署容器化应用更加简洁和高效
### kubernetes的设计理念
大多数用户，希望kubernetes项目带来的体验是确定的：

我有应用的容器景象，请在一个给定的集群上把应用运行起来。此外，用户还希望kubernetes提供路由网关、水平扩展、监控、备份、灾难恢复等一系列运维能力。

**这其实就是最经典的PasS项目的能力**，用户使用docker的Compose+Swarm，完全可以自己开发出这些功能。

而kubernetes项目着重解决的问题是：

### 有哪些优势？
1. 自动装箱和回滚更新
   
   自动装箱即自我部署。Kubernetes采用滚动更新策略更新应用，一次更新一个pod，当更新过程中出现问题，Kubernetes会进行回滚更新，保证升级业务不受影响
   
3. 自我修复（自愈能力）
    
    在节点产生故障时，保证预期的副本数量不会减少，在产生故障的同时，终止健康检查失败的容器并部署新的容器，保证上线服务不会中断
    
5. 水平扩展
6. 服务发现（或者叫负载均衡）：对外提供统一接口的功能

    为多个容器提供统一的访问入口（内部IP地址和一个DNS名称），使所有的容器负载均衡，集群内应用可以通过DNS名称完成互相反问。
8. 密钥和配置管理

    kubernetes允许存储和管理敏感信息，如密码、OAuth令牌和SSh密钥。用户可以部署和更新机密和应用程序配置，而无须重建容器镜像，也不会在堆栈配置中暴露机密。
10. 存储编排

    Kubernetes挂载外部存储系统，将这些存储作为集群资源的一部分来使用，增强存储使用的灵活性。

12. 弹性伸缩

    kubernetes可以使用命令或基于CPU使用情况自动快速扩容和缩容应用程序，保证在高峰期的高可用性和业务低档期回收资源，降低运行成本
14. 提供认证和授权

    控制用户是否有权限使用API进行操作，精细化权限分配
16. 资源监控
    
    工作节点纪恒Advisor资源收集工具，可以快速实现对集群资源的监控
## 2.k8s架构组件
1. Master组件：主控节点

    * apiserver：集群统一入口，以restful方式，交给etcd存储
    * scheduler：节点的调度，选择node节点应用部署
    * controller-manager：处理集群中常规后台任务，一个资源对应一个控制器
    * etcd：存储，用于保存集群中各种数据，例如状态数据等。
3. Node组件：工作节点
    
    * kuberlet；master派到node节点代表，管理本机容器
    * kube-proxy：提供网络代理，负载均衡等操作。
    * docker

## 3.k8s核心概念
### pod
* pod是k8s中最小的部署单元，一组容器的集合
* 1个pod中的容器是共享网络的
* 生命周期是短暂的，重启之后就找不到了。
* 一组pod叫做命名空间
### Controlller
* 确保预期的pod副本数量
* 无状态的应用部署：有两个节点，其中1个节点故障，其节点中的容器可以移到另一个节点中直接用。随便用
* 有状态的应用部署：需要依赖存储，网络ip要唯一。有状态是必须要在特定条件下才能用
* 确保所有的node运行同一个pod
* 一次性任务和定时任务

### Service
* 定义一组pod的访问规则


## 4. 搭建k8s集群
### 搭建k8s环境平台规划
1. 单master集群

![image.png](https://www.choumaomi.com/static/img/b0dd4ebc9786983867eaaa6bb9e8cc14.image.png)

2. 多master集群（也可以叫做：高可用集群）
![image.png](https://www.choumaomi.com/static/img/3c208e240172c45d273b2dc60cfdfb74.image.png)

### 服务器硬件配置要求
* 测试环境：

![image.png](https://www.choumaomi.com/static/img/7e7e3c271c8ebdf127142f93b76d3a1b.image.png)
* 正式环境：更高要求


### 搭建k8s集群部署方式
* kubeadm
Kubeadm是一个K8s部署工具，提供kubeadm init和kubeadm join，用于快速部署kubernetes集群


* 二进制包
从github下载发行版的二进制包，手动部署每个组件，组成Kubernetes集群。可以学习很多工作原理，有利于后期维护

01  k8s简介

## 1. 什么是restful？
    
rest全称是Representational  State Transfer  ，中文意识是表述性状态转移。作者曾在他的论文中提到：“我这篇文章的写作目的，就是想在符合架构原理的前提下，理解和评估以网络为基础的应用软件的架构设计，

得到一个功能强，性能好、适宜通信的架构”，REST指的是一组交约束条件和原则，如果一个架构符合REST的约束条件和原则，我们就称它为RESTful架构。



## 2. 理解RESTful？
    
要理解RESTFUl架构，需要理解Representational  State Transfer这个词组到底是什么意思，它的每一个词都有些什么涵义。

下面我们结合REST原则，围绕资源展开讨论，从`资源的定义`、`获取`、`表述`、`关联`、`状态变迁`等角度，列举一些关键概念并加以解释。

* 资源与URI
* 统一资源接口
* 资源的表述
* 资源的链接
* 状态的转移

### 2.1 资源与URI

REST全称是表述性状态转移，指的就是资源。任何事物，只要有被引用到的必要，它就是一个资源，资源可以是实体（例如手机号码），也可以只是一个抽象的概念（例如价值）。下面是一些资源的例子：
* 某用户的手机号码
* 某用户的个人信息
* 最多用户订购的GPRS套餐
* 两个产品之间的依赖关系
* 某用户可以办理的优惠套餐
* 某手机号码的潜在价值

要让一个资源可以被识别 ，需要一个唯一标识，在web中这个唯一标识就是URI（uniform Resource Identifier）。

urI既可以看成是资源的地址，也可以看成是资源的名称。如果某些信息没有使用URI来标识，那它就不算是一个资源，只能算是资源的一些 信息而已。

URI的设计应该遵循 `可寻址性原则，具有描述性`，需要在形式上给人以直觉上的关联。这里以GitHub网站为例，给出一些还算不错的URI：
```
* https://github.com/git
* https://github.com/git/git
* https://github.com/git/git/blob/master/block-sha1/sha1.h
* https://github.com/git/git/commit/e3af72cdafab5993d18fae056f87e1d675913d08
* https://github.com/git/git/pulls
* https://github.com/git/git/pulls?state=closed
* https://github.com/git/git/compare/master…next 
```
下面我们来看看URI设计上的一些技巧：
* 使用_或-来让URI可读性更好
* 使用/来标识资源的层级关系
* 使用?用来过滤器

很多人只是把？简单的当做是参数的传递，很容易造成URI过于复杂、难以理解。可以把？用于对资源的过滤，例如
- /git/git/pulls  用来表示git项目的所有推入请求，
- 而/pull?state=closed用来表示git项目中已经关闭的推入请求，这种url通常对应的是一些特定条件的查询结果或算法运算结果。
- ,或；用来表示同级资源的关系

### 2.2 统一资源接口
RESTful架构应该遵循统一接口规则，统一接口包含了一组受限的预定义的操作，不论什么样的资源，都是通过使用相同的接口进行资源的访问。

接口应该使用标准的HTTPs方法如Get、PUT、和post，并遵循这些方法的语义。
            
如果按照http方法的语义来暴露资源。那么接口将会拥有安全性和幂等性的特性。

例如
- Get和Head请求都是安全的，无论请求多少次，都不会改变服务器的状态。
- 而Get、Head、Put和Delete请求都是幂等的，无论对资源操作多少次，结果总是一样的，后面的请求 并不会产生比第一次更多的影响。  


下面列出了GET，DELETE，PUT和POST的典型用法:
    
    ### HTTP 方法与状态码对照

| **HTTP 方法** | **描述** | **常见状态码** | **含义** |
|---------------|----------|----------------|----------|
| **GET**       | 安全且幂等。用于获取资源。 | 200（OK） | 资源已在响应中返回。 |
|               |          | 204（No Content） | 资源无内容。 |
|               |          | 301（Moved Permanently） | 资源的 URI 已更新。 |
|               |          | 303（See Other） | 重定向到其他位置（如负载均衡）。 |
|               |          | 304（Not Modified） | 资源未更改（使用缓存）。 |
|               |          | 400（Bad Request） | 请求参数错误。 |
|               |          | 404（Not Found） | 资源不存在。 |
|               |          | 406（Not Acceptable） | 服务端不支持所请求的表示。 |
|               |          | 500（Internal Server Error） | 服务器内部错误。 |
|               |          | 503（Service Unavailable） | 服务不可用，暂时无法处理请求。 |
| **POST**      | 不安全且不幂等。用于创建资源或部分更新。 | 200（OK） | 现有资源已更改。 |
|               |          | 201（Created） | 新资源已被创建。 |
|               |          | 202（Accepted） | 请求已接受，但尚未完成（异步处理）。 |
|               |          | 301（Moved Permanently） | 资源的 URI 已更新。 |
|               |          | 303（See Other） | 重定向到其他位置。 |
|               |          | 400（Bad Request） | 请求参数错误。 |
|               |          | 404（Not Found） | 资源不存在。 |
|               |          | 406（Not Acceptable） | 服务端不支持所请求的表示。 |
|               |          | 409（Conflict） | 请求存在冲突。 |
|               |          | 412（Precondition Failed） | 前置条件失败（如乐观锁冲突）。 |
|               |          | 415（Unsupported Media Type） | 请求的媒体类型不被支持。 |
|               |          | 500（Internal Server Error） | 服务器内部错误。 |
|               |          | 503（Service Unavailable） | 服务不可用，暂时无法处理请求。 |
| **PUT**       | 不安全但幂等。用于更新资源。 | 200（OK） | 现有资源已更改。 |
|               |          | 201（Created） | 新资源已被创建。 |
|               |          | 301（Moved Permanently） | 资源的 URI 已更新。 |
|               |          | 303（See Other） | 重定向到其他位置。 |
|               |          | 400（Bad Request） | 请求参数错误。 |
|               |          | 404（Not Found） | 资源不存在。 |
|               |          | 406（Not Acceptable） | 服务端不支持所请求的表示。 |
|               |          | 409（Conflict） | 请求存在冲突。 |
|               |          | 412（Precondition Failed） | 前置条件失败（如乐观锁冲突）。 |
|               |          | 415（Unsupported Media Type） | 请求的媒体类型不被支持。 |
|               |          | 500（Internal Server Error） | 服务器内部错误。 |
|               |          | 503（Service Unavailable） | 服务不可用，暂时无法处理请求。 |
| **DELETE**    | 不安全但幂等。用于删除资源。 | 200（OK） | 资源已删除。 |
|               |          | 301（Moved Permanently） | 资源的 URI 已更新。 |
|               |          | 303（See Other） | 重定向到其他位置。 |
|               |          | 400（Bad Request） | 请求参数错误。 |
|               |          | 404（Not Found） | 资源不存在。 |
|               |          | 409（Conflict） | 请求存在冲突。 |
|               |          | 500（Internal Server Error） | 服务器内部错误。 |
|               |          | 503（Service Unavailable） | 服务不可用，暂时无法处理请求。 |
   

#### 实践中常见问题
1. `POST和PUT用于创建资源时有什么区别?`

    POST和PUT在创建资源的区别在于，所创建的资源的名称(URI)是否由客户端决定。 例如为我的博文增加一个java的分类，生成的路径就是分类名/categories/java，那么就可以采用PUT方法。
    ___
    不过很多人直接把POST、GET、PUT、DELETE直接对应上CRUD，例如在一个典型的rails实现的RESTful应用中就是这么做的。 我认为，这是因为rails默认使用服务端生成的ID作为URI的缘故，而不少人就是通过rails实践REST的，所以很容易造成这种误解。

2. `客户端不一定都支持这些HTTP方法吧?`
    
    的确有这种情况，特别是一些比较古老的基于浏览器的客户端，只能支持GET和POST两种方法。 在实践上，客户端和服务端都可能需要做一些妥协。
    ___
    例如rails框架就支持通过隐藏参数_method=DELETE来传递真实的请求方法， 而像Backbone这样的客户端MVC框架则允许传递_method传输和设置X-HTTP-Method-Override头来规避这个问题。

3. `统一接口是否意味着不能扩展带特殊语义的方法?`

    统一接口并不阻止你扩展方法，只要方法对资源的操作有着具体的、可识别的语义即可，并能够保持整个接口的统一性。 像WebDAV就对HTTP方法进行了扩展，增加了LOCK、UPLOCK等方法。而github的API则支持使用PATCH方法来进行issue的更新，
    ___
    例如: `PATCH /repos/:owner/:repo/issues/:number`。不过，需要注意的是，像PATCH这种不是HTTP标准方法的，服务端需要考虑客户端是否能够支持的问题。


4. `统一资源接口对URI有什么指导意义?`

    统一资源接口要求使用标准的HTTP方法对资源进行操作，所以URI只应该来表示资源的名称，而不应该包括资源的操作。 通俗来说，URI不应该使用动作来描述。例如，下面是一些不符合统一接口要求的URI:
    ```
    GET /getUser/1
    POST /createUser
    PUT /updateUser/1
    DELETE /deleteUser/1
    ```
5. `如果GET请求增加计数器，这是否违反安全性?`

    安全性不代表请求不产生副作用，例如像很多API开发平台，都对请求流量做限制。像github，就会限制没有认证的请求每小时只能请求60次。 
    ___
    但客户端不是为了追求副作用而发出这些GET或HEAD请求的，产生副作用是服务端“自作主张”的。 另外，服务端在设计时，也不应该让副作用太大，因为客户端认为这些请求是不会产生副作用的。
6. `直接忽视缓存可取吗?`

    即使你按各个动词的原本意图来使用它们，你仍可以轻易禁止缓存机制。 最简单的做法就是在你的HTTP响应里增加这样一个报头： Cache-control: no-cache。
    ___
    但是，同时你也对失去了高效的缓存与再验证的支持(使用Etag等机制)。 对于客户端来说，在为一个REST式服务实现程序客户端时，也应该充分利用现有的缓存机制，以免每次都重新获取表示。
7. `响应代码的处理有必要吗?`

    HTTP的响应代码可用于应付不同场合，正确使用这些状态代码意味着客户端与服务器可以在一个具备较丰富语义的层次上进行沟通。 例如，201（“Created”）响应代码表明已经创建了一个新的资源，其URI在Location响应报头里。 
    ___
    假如你不利用HTTP状态代码丰富的应用语义，那么你将错失提高重用性、增强互操作性和提升松耦合性的机会。 如果这些所谓的RESTful应用必须通过响应实体才能给出错误信息，那么SOAP就是这样的了，它就能够满足了。

## 3. 资源的表述

上面提到，客户端通过HTTP方法可以获取资源，是吧? 不，确切的说，客户端获取的只是资源的表述而已。 

资源在外界的具体呈现，可以有多种表述(或成为表现、表示)形式，在客户端和服务端之间传送的也是资源的表述，而不是资源本身。 

例如文本资源可以采用html、xml、json等格式，图片可以使用PNG或JPG展现出来。 资源的表述包括数据和描述数据的元数据，例如，HTTP头“Content-Type” 就是这样一个元数据属性。
　　

### 3.1 客户端如何知道服务端提供哪种表述形式呢?
答案是可以通过HTTP内容协商，客户端可以通过`Accept头`请求一种特定格式的表述，服务端则通过`Content-Type`告诉客户端资源的表述形式。

以github为例，请求某组织资源的json格式的表述形式:

假如github也能够支持xml格式的表述格式，那么结果就是这样的:

下面我们来看一些实践上常见的设计: 在URI里边带上版本号, 有些API在URI里边带上版本号，

例如:
```
http://api.example.com/1.0/foo
http://api.example.com/1.2/foo
http://api.example.com/2.0/foo
```

如果我们把版本号理解成资源的不同表述形式的话，就应该只是用一个URL，并通过Accept头部来区分，还是以github为例，它的Accept的完整格式是:
```
application/vnd.github[.version].param[+json]
```

对于v3版本的话，就是`Accept: application/vnd.github.v3`。对于上面的例子，同理可以使用使用下面的头部:
```
Accept: vnd.example-com.foo+json; version=1.0
Accept: vnd.example-com.foo+json; version=1.2
Accept: vnd.example-com.foo+json; version=2.0
```

### 3.2 使用URI后缀来区分表述格式
像rails框架，就支持使用/users.xml或/users.json来区分不同的格式。 这样的方式对于客户端来说，无疑是更为直观，但混淆了资源的名称和资源的表述形式。

我个人认为，还是应该优先使用内容协商来区分表述格式。
　　
### 3.3 如何处理不支持的表述格式
当服务器不支持所请求的表述格式，那么应该怎么办？

若服务器不支持，它应该返回一个`HTTP 406响应`，表示拒绝处理该请求。

## 4. 资源的链接
我们知道REST是使用标准的HTTP方法来操作资源的，但仅仅因此就理解成带CURD的Web数据库架构就太过于简单了。 

这种反模式忽略了一个核心概念：`“超媒体即应用状态引擎（hypermedia as the engine of application state）”`。 超媒体是什么? 当你浏览Web网页时，从一个连接跳到一个页面，再从另一个连接跳到另外一个页面，就是利用了超媒体的概念：`把一个个把资源链接起来`.

要达到这个目的，就要求在表述格式里边加入链接来引导客户端。在《RESTful Web Services》一书中，作者把这种具有链接的特性成为连通性。下面我们具体来看一些例子。

下面展示的是github获取某个组织下的项目列表的请求，可以看到在响应头里边增加Link头告诉客户端怎么访问下一页和最后一页的记录。 而在响应体里边，用url来链接项目所有者和项目地址。

又例如下面这个例子，创建订单后通过链接引导客户端如何去付款。


上面的例子展示了如何使用超媒体来增强资源的连通性。很多人在设计RESTful架构时，使用很多时间来寻找漂亮的URI，而忽略了超媒体。所以，应该多花一些时间来给资源的表述提供链接，而不是专注于“资源的CRUD”。

## 5. 状态的转移
有了上面的铺垫，再讨论REST里边的状态转移就会很容易理解了。 不过，我们先来讨论一下REST原则中的无状态通信原则。初看一下，好像自相矛盾了，既然无状态，何来状态转移一说?

其实，这里说的无状态通信原则，并不是说客户端应用不能有状态，而是指服务端不应该保存客户端状态。

### 5.1 应用状态与资源状态
实际上，状态应该区分`应用状态`和`资源状态`，客户端负责维护应用状态，而服务端维护资源状态。 

客户端与服务端的交互必须是无状态的，并在每一次请求中包含处理该请求所需的一切信息。 

服务端不需要在请求间保留应用状态，只有在接受到实际请求的时候，服务端才会关注应用状态。 

这种无状态通信原则，使得服务端和中介能够理解独立的请求和响应。 在多次请求中，同一客户端也不再需要依赖于同一服务器，方便实现高可扩展和高可用性的服务端。

但有时候我们会做出违反无状态通信原则的设计，例如利用Cookie跟踪某个服务端会话状态，常见的像J2EE里边的JSESSIONID。 

这意味着，浏览器随各次请求发出去的Cookie是被用于构建会话状态的。 当然，如果Cookie保存的是一些服务器不依赖于会话状态即可验证的信息（比如认证令牌），这样的Cookie也是符合REST原则的。

### 5.2 应用状态的转移
状态转移到这里已经很好理解了， “会话”状态不是作为资源状态保存在服务端的，而是被客户端作为应用状态进行跟踪的。

客户端应用状态在服务端提供的超媒体的指引下发生变迁。服务端通过超媒体告诉客户端当前状态有哪些后续状态可以进入。 这些类似“下一页”之类的链接起的就是这种推进状态的作用——指引你如何从当前状态进入下一个可能的状态。

## 6. 总结

现在广东XXX版本、XXX等项目中均使用传统的RPC、SOAP方式的Web服务，而移动南方基地XXXX项目的后台， 虽然采用了JSON格式进行交互，但还是属于RPC风格的。本文从资源的定义、获取、表述、关联、状态变迁等角度， 试图快速理解RESTful架构背后的概念。RESTful架构与传统的RPC、SOAP等方式在理念上有很大的不同，希望本文能对各位理解REST有所帮助。

restful架构

# redis的使用
Redis是机遇内存的高效的键值型非关系型数据库，存取效率极高，而且支持多种存储数据结构，使用也非常简单。



## 1. 下载reids
### 1.1 下载并配置redis数据库
[windows下载地址](https://github.com/MSOpenTech/redis/releases)
[windows安装步骤](https://www.cnblogs.com/xiaomage666/p/11528092.html)
[mac下载地址](https://www.jianshu.com/p/50694e644c25)
[centos下载地址](https://www.jianshu.com/p/50694e644c25)

## 2. Redis和StrictRedis
redis-py库提供了两大类Redis和StrictRedis来实现Redis的命令操作。
官方推荐使用StrictRedis

## 3. 连接redis
### 第一种方式
```python
from redis import StrictRedis
redis = StrictRedis(host='localhost',port=6379,db=0,password='foobared')
redis.set('name','Bob')
print(redis.get('name'))
```
运行结果如下:
```
b'Bob'
```

### 第二种方式
```python
from redis import StrictRedis, ConnectionPool
pool = ConnectionPool(host='localhost',port=6379,db=0,password='foobared')
redis = StrictRedis(connection_pool=pool)
```

### 通过url的方式来进行连接
* redis://[:password]@host:port/db
* rediss://[:password]@host:port/db
* unix://[:password]@/path/to/socket.sock?db=db
```python
url = 'redis://:foobared@localhost:6379/0'
pool = ConnectionPool.from_url(url)
redis = StrictRedis(connection_pool=pool)
```
## 4. 键操作

|  方法   | 作用  |  参数说明   | 示例  |  示例   | 示例结果  |
|  ----  | ----  | ----  | ----  |----  | ----  |
| exists(name)  | 判断一个 键是否存在 |name:键名|redis.exists('name')|是否存在这个name|True|
| delete(name)  |删除一个键值  |name:键名|redis.delete('name') | 删除这个键 |1   |
|type(name) |判断键类型  |name:键名 |redis.tyep('name')|判断name自己这个键类型| b'string'  |
|keys(pattern) |获取符合规则的键  |pattern:匹配规则|redis.keys('n*')|获取所有以n开头的键  |[b'name']| 
|randomkey() |获取随机的一个键 ||randomkey() |获取随机的一个键  |b'name'| 
|rename(src,dst)|重命名键  |src:原键名，dst:新键名| redis.rename('name','nickname')|将name重命名为nickname  |True|
|dbsize()|获取 当前数据库中键的树木 ||dbsize()|获取当前数据库中键的数目|100|
|expire(name,time)|设定键的过期时间，单位为秒  |name:键名；time:秒数|redis.expire('name',2)|将name键的国旗时间设置为2秒  |True|
|ttl(name)|获取键的过期时间，单位为秒,-1表示永不过期|name:键名|redis.ttl('name')|获取name的这个键的过期时间|-1|
|move(name,db)|将键移动到其他数据库|name:键名，db:数据库代号|move('name',2)|将name移动到2号数据库|True|
|flushdb()|删除当前选择数据库中的所有键||flushdb()|删除当前选择数据库中的所有键|True|
|flushall()|删除所有数据库中的所有键||flushall()|删除所有数据库中的所有键|True|


## 5. 字符串操作
**支持最基本的键值对形式存储**
|  方法   | 作用  |  参数说明   | 示例  |  示例   | 示例结果  |
|  ----  | ----  | ----  | ----  |----  | ----  |
|set(name,value)|给数据库中键名为name的string赋予value|name:键名,value:值|redis.set('name','Bob')|给name这个键的value赋值为Bob|True|
|get(name)|返回数据库中键名为name的string的value|name:键名|redis.get('name')|返回name这个键的value|b'Blob'|
|getset(name,value)|给数据库中键名为name的string赋予值value并返回上次的value|name:键名；value:新值|redis.getset('name','Mike')|赋值name为Mike并得到上次的value|b'Bob'|
|mget(keys,*args)|返回多个键对应的value组成的列表|keys:键名序列|redis.mget(['name','nickname'])|返回name和nickname的value|[b'Mike',b'Miker']|
|setnx(name,value)|如果不存在这个键值对，则更新value，否则不变|name:键名|redis.setnx('newname','James')|如果newname这个键不存在，则设置为James|第一次运行结果是True，第二次运行结果是False |
|setex(name,time,value)|设置可以对应的值为string类型的value，并指定此键值对应的有效期|name:键名;time:有效期;value:值|redis.setex('name',1,'James')|将name这个键的值设为James，有效期为1秒|True|
|setrange(name,offset,value)|设置追定键的value值的子字符串|name:键名;offset:偏移量;value:值|redis.set('name','Hello')redis.setrange('name',6,'World')|将name为hello字符串，并在index为6的位置补World,|11,修改后的字符串长度|
|mset(mapping)|批量赋值|mapping:字典或关键字参数|redis.mset({'name1':'Durant','name2':'James'})|将name1设为Durant，name2设为James|True|
|msetnx(mapping)|键均不存在时才批量赋值|mapping:字典或关键字参数|redis.msetnx({'name3':'Smith','name4':'Curry'})|在name3和name4均不存在的情况下才设置二者值|True|
|incr(name,amount=1)|键名为name的value增值操作，默尔恩为1，键不存在则被创建并设为amount|name:键名；amount:增长的值|redis.incr('age',1)|age对应的值增1，若不存在，则会创建并设置为-1|1，即修改后的值|
|decr(name,amount=1)|键名为name的value减值操作，默认为1，键不存在则被创建并将value设置为amount|name:键名;amount:减少的值|redis.decr('arge',1)|age对应的值减1，若不存在，则会创建并设置为-1|-1，即修改后的值|
|append(key,value)|键名为key的string的值附加value|key:键名|redis.append('nickname','OK')|向键名为nickname的值后追加ok|13，即修改后的字符串长度|
|substr(name,start,end=-1)|返回键名为name的string的字符串|name:键名;start:起始索引;end:终止索引，默认为-1，表示截取到末尾|redis.substr('name',1,4)|返回键名为name的值的字符串，截取索引为1-4的字符串|b'hello'|
|getrange(key,start,end)|获取键的value值，从startd到end的子字符串|key:键名;start:起始索引;end:终止索引|redis.getrange('name',1,4)|返回键名为name的值的字符串，截取索引为1-4的字符|b'ello'|
## 6. 列表操作
**列表内的元素可以重复，而且可以从两端存储**
|  方法   | 作用  |  参数说明   | 示例  |  示例   | 示例结果  |
|  ----  | ----  | ----  | ----  |----  | ----  |
｜rpush(name,*values)｜在键名为name的列表末尾添加值为value的元素，可以传多个｜name：键名；values:值｜redis.rpush('list',1,2,3)｜向键名为list的列表尾添加1、2、3｜3，列表大小｜
｜lpush(name,*values)｜在键名为name的列表头添加值为value的元素，可以传多个｜name:键名;values:值｜redis.lpush('list',0)｜向键名为list的列表头部添加0｜4，列表的大小｜
｜llen(name)｜返回键名为name的列表的长度｜name:键名｜redis.llen('list')｜返回键名为list的列表的长度｜4｜
｜lrange(name,start,end)｜返回键名为name的列表中start至end之间的元素｜name:键名；start:起始索引；end：终止索引｜redis.lrange('list',1,,3)｜返回起始索引为1，终止索引为3的索引范围对应的列表｜[b'3',b'2',b'1']｜
｜ltrim(name,start,end)｜截取键名为name的列表，保留索引为start到end的内容｜name:键名;start:起始索引;end:终止索引｜ltrim('list',1,3)｜保留键名为list的索引为1到3的元素｜True｜
｜lindex(name,iindex)｜返回键名为name的列表中index位置的元素｜name:键名;index:索引｜redis.lindex('list',1)｜返回键名为list的列表索引为1的元素｜‘2’｜
｜lset(name,index,value)｜给键名为name的列表中index位置的元素复制 ，越界则报错｜name:键名;index:索引位置;value:值｜redis.lset('list',1,5)｜将键名为list的列表中索引为1的赋值为5｜True｜
｜lrem(name,count,value)｜删除count个键的列表中值为value的元素｜name:键名；count:删除个数;value:值｜redis.lrem('list',2,3)｜将键名为list的列表删除2个3｜1，即删除的个数｜
｜lpop(name)｜返回并删除键名为name的列表中的首元素｜name:键名｜redis.lpop('list')｜返回并删除名为list的列表中的第一个元素｜b'5'｜
｜rpop(name)｜返回并删除键名为name的列表中的尾元素｜name:键名｜redis.rpop('list')｜返回并删除名为list的列表中的最后一个元素｜b'2'｜
｜blpop(keys,timeout=0)｜返回并删除名称在keys中的list中的首个元素，如果列表为空，则会一直阻塞等待｜keys:键名序列;timeout:超时等待时间，0为一直等待｜reds.blpop('list')｜返回并删除键名为list的列表中的第一个元素｜[b'5']｜
｜brpop(keys,timeout=0)｜返回并删除键名为name的列表中的尾元素，如果liest为空，则会一直阻塞等待｜keys:键名序列;timeout:超时等待时间，0为一直等待｜redis.brpop('list')｜返回并删除名为list的列表中的最后一个元素｜b['2']｜
｜rpoplpush(src,dst)｜返回并删除名称为src的列表的尾元素，并将该元素添加到名称为dst的列表头部｜src:源列表的键;dst:目标列表的key｜redis.rpoolpush('list','list2')｜将建名为list的列表尾元素删除并将其添加到键名为list2的列表头部，然后返回｜b'2'｜

## 7. 集合操作
**Redis提供了集合存储，集合中的元素都是不重复的**

|  方法   | 作用  |  参数说明   | 示例  |  示例   | 示例结果  |
|  ----  | ----  | ----  | ----  |----  | ----  |
|sadd(name,*values)|向键名为name的集合中添加元素|name:键名;values:值，可为多个|redis.sadd('tags','Book','Tea','Coffee')|向键名为tags的集合中添加Book、Tea、Coffee这三个内容|3，即插入的数据个数|
|srem(name,*values)|从键名为name的集合中删除元素|name:键名；values:值，可为多个|redis.srem('tags','Book')|从键名为tags的集合中删除Book|1，即删除的数据个数|
|spop(name)|随机返回并删除键名为name的集合中的一个元素|name:键名|redis.spop('tags')|从键名为tags的集合中随机删除并返回该元素|b'Tea'|
|smove(src,dst,value)|从src对应的集合中移除元素并将其添加到dst队医ing的集合中|src:源集合；dst：目标集合；value：元素值|redis.smove('tags','tags2','Coffee')|从键名为tags的集合中删除元素coffee并 将其添加到键为tag2的集合|True|
|scard(name)|返回键名为name的集合的元素的个数|name:键名|redis.scard('tags')|获取键名为tags的集合中的元素个数|3|
|sismember(name,value)|测试member是否是键名为name的集合的元素|name:键值|redis.sismember('tags','Book')|判断Book是否是键名为tags的集合元素|True|
|sinter(keys,*args)|返回所有给定的键的集合的交集|keys:键名序列|redis.sinter(['tags','tags2'])|返回键名为tags的集合和键名为 tags2的集合的交集|{b'coffee'}|
|siterstore(dst,keys,*args)|求交集并将交集保存到dst的集合中|dst:结果集合;keys:键名序列|redis.sinterstore('inttag',['tags','tags2'])|求键名为tags的集合和键名为tags2的集合的交集|{b'coffee',b'Book',b'Pen'}|
|sunion(keys,*args)|返回所有给定键的集合的并集|keys:键名序列|redis.sunion(['tags','tags2'])|返回键名为tags的集合和键名为tags2的集合的并集|{b'Cooffee',b'Book',b'Pen'}|
|sunionstore(dst,keys,*args)|求并集并将并集保存到dest的集合|dst:结果集合；keys:键名序列|redis.sunionnstore('inttag',['tags','tags2'])|求键名为tags的集合和键名为tags2的集合的并集并将其保存为inttag|3|
|sdiff(keys,*args)|返回所有给定键的集合的差集|keys:键名序列|redis.diff(['tags','tags2'])|返回键名为tags的集合和键名为tags2的集合的差集|{b'Book',b'Pen'}|
|sdiffstore(dest,keys,*args)|求差集并将差集保存到dest集合|dest:结果集合；keys：键名序列|redis.sdiffstore('inttag',['tags','tags2'])|求键名为tags的集合和键名为tags2的集合的差集并将其保存为inttag|3|
|smembers(name)|返回键名为name的集合的所有元素|name:键名|redis.smembers('tags')|返回键名为tags的集合的所有元素|{b'Pen',b'Book',b'Coffee'}|
|srandmember(name)|随机返回键名为name的集合中的一个元素，但不删除元素|name:键值|redis.srandmember('tags')|随机返回键名为tags的集合中的一个元素|Srandmember(name)
## 8. 有序集合操作
**有序集合比集合多了一个分数字段，利用它可以对集合中的数据进行排序**

|  方法   | 作用  |  参数说明   | 示例  |  示例   | 示例结果  |
|  ----  | ----  | ----  | ----  |----  | ----  |
|zadd(name,*args,**kwargs)|向键名为name的zset中添加元素member，score用于排序，如果该元素存在，则更新其顺序|name:键名；args:可变参数|redis.zadd('grade',100,'Bob',98,'Mike')|向键名为grade的zset中添加Bob（其score为100），并添加Mke(其score为98)|2，即添加的元素个数|
|zrem(name,*values)|删除键名为name的zset中的元素|name:键名;values:元素|redis.zrem('grade','Mike')|从键名为grade的zset中删除Mike|1，即删除的元素个数|
|zincrby(name,value,amount=1)|如果在键名为name的zset中已经存在元素value，则将该元素的score增加amount；否则向该集合中添加该元素，其score的值为amount|name:键名;value:元素；amount:增长的score值|redis.ziincrby('grade','Bob',-2)|键名为grade的zset中Bob的score减2|98.0,即修改后的值|
|zrank(name,value)|返回键名为name的zset中元素的排名，按score从小打到排序，即名次|name:键名；values:元素值|redis.zrank('grade','Amy')|得到键名为grade的zset中Amy的排名|1|
|zrevrank(name,value)|返回键为name的zset中元素的排名，按score从小到大排序，即名次|name：键名;values：元素值|redis.zrevrank('grade','Amy')|得到键名为grade的zset中Amy的倒数排名|2|
|zrevrange(name,start,end,withscores=False)|返回键名为name的zset(按score从大到小排序)中index从start到end的所有元素|name:键值；start：开始索引，end：结束索引；withscores:是否带score|redis.zrevrange('grade',0,3)|返回键名为grade的zset中前四名元素|[b'Bob',b'Mike',b'Amy',b'James']|
|zrangebyscore(name,min,max,start=None,num=None,num=None,withscores=False)|返回键名为name的zset中score给定区间的元素|name:键名;min：最低score;max:最高score；start:起始索引;num:个数;withscores:是否带score|redis.zrangebyscore('grade',80,95)|返回键名为grade的zset中score在80到95的元素的个数|2|
|zcount(name,min,max)|返回键名为name的zset中score在给定区间的数量|name:键名;min；最低score;max:最高score|redis.zcount('grade',80,95)|返回键名为grade的zset中score在80到95的元素个数|2|
|zcard(name)|返回键名为name的zset元素的个数|name:键名|redis.zcard('grade')|获取键名为grade的zset中元素的个数|3|
|zremrangebyrank(name,min,max)|删除键名为name的zset中排名在给定区间的元素|name:键名;min:最低位次;max:最高名次|redis.zremrangebyrank('grade',0,0)|删除键名为grade的zset中排名第一的元素|1，即删除的元素的个数|
|zremrangebyscore(name,min,max)|删除键名为name的zset中score在给定区间的元素|name：键名;min:最低score；max:最高score|redis.zremrangebyscore('grade',80,90)|删除score在80到90之间的元素|1，即删除元素的个数|
|||||||
## 9. 散列操作
**我们可以用name指定一个散列表的名称，表内存储了各个键值对**

|  方法   | 作用  |  参数说明   | 示例  |  示例   | 示例结果  |
|  ----  | ----  | ----  | ----  |----  | ----  |
|hset(name,key,value)|向键名为name的散列表中添加映射|name:键名;key:映射键名;value:映射键值|hset('price','cake',5)|向键名为price的散列表中添加映射关心，cake的值为5|1，即添加的映射的个数|
|hsetnx(name,key,value)|如果映射键名不存在，则向键名为name的散列表中添加映射|name:键名;key:映射键名;value:映射键值|hsetnx('price','book',6)|向键名为price的散列表中添加映射关系，book的值为6|1，即添加的映射个数|
|hget(name,key)|返回键名为name的散列表中key对应的值|name:键名;key:映射键名|redis.hget('price','cake')|获取键名为price的散列表中键名的cake的值|5|
|hmget(name,keys,*args)|返回键名为name的山列表中各个键名对应的值�|name:键名;keys:键名序列|redis.hmget('price',['apple','orange'])|获取键名为price的散列表中apple和orange的值|[b'3',b'7']|
|hmset(name,mapping)|返回键名为name的散列表批量添加映射|name:键名;mapping:映射字典|redis.hmset('price',{'banana':2,'pear':6})|向键名为price的散列表中批量添加映射||
|hincrby(name,key,amount=-1)|将键名为name的散列表中映射的值增加amount|name:键名;key:映射键名;amount:增长量|redis.hincrby('price','apple',3)|key为price的散列表中apple的值增加3|6，修改后的值|
|hexists(name,key)|键名为name的山列表中是否存在键名为键的映射|name:键名;key:映射键名|redis.hexists('price','banana')|键名为price的散列表中bnana的值是否存在|True|
|hdel(name,*keys)|键名为name的散列表中，删除键名为键的映射|name:键名;keys:键名序列|reds.hdel('price','banana')|从键名为price的散列表中删除键名为banana的映射|True|
|hlen(name)|从键名为name的散列表中获取映射个数|name:键名;|redis.hlen('price')|从键名为price的散列表中获取映射个数|6|
|hkeys(name)|从键名位name的散列表中获取所有映射键名|name:键名;|redis.hkeys('price')|从键名为price的散列表中获取所有映射键名|[b'cake',b'Booke',b'banana',b'pear']|
|hvals(name)|从键名为name的散列表中获取所有映射键值|name:键名;|redis.hvals('price')|从键名为price的散列表中获取所有映射键值|[b'5',b'6',b'2',b'6']|
|hgetall(name)|从键名为name的散列表中获取所有映射键值对|name:键名;|redis.hgetall('price')|从键名 为price的散列表中获取所有映射键值对|{b'cake',b'5',b'book',b'6',b'orange',b'7',b'pear',b'6'}|
## 10.RedisDump
RedisDump提供了两个可执行命令:redis-dump用于导出数据，redis-load用于导入数据.

redis的初步使用

## 题目介绍

## 个人第一次解法
```python
# coding:utf-8
# 关键点：有序数组、去0、
# 核心思路：m or n =0的就不考虑了 nums1.length = m+n nums2.length = n



def merge(nums1, m, nums2, n):
    # 思路：将nums1和nums2中的0去掉，然后合并，进行排序
    if len(nums1) != m:
        for i in range(len(nums1) - m):
            nums1.remove(0)
    if len(nums2) != n:
        for i in range(len(nums2) - n):
            nums2.remove(0)
    nums1 += nums2
    nums1.sort()


nums1 = [1, 2, 3, 0, 0, 0]
m = 3
nums2 = [2, 5, 6]
n = 3
merge(nums1, m, nums2, n)

```


## 逆向双指针
[参照链接](https://leetcode.cn/problems/merge-sorted-array/solution/he-bing-liang-ge-you-xu-shu-zu-by-leetco-rrb0/)
方法：按照链接的来写代码，不看他写好的，然后总结自己出现的问题
```python
# coding:utf-8
# 逆向双指针的解法
# 题目给出return nothing，代表着要原地修改，将空间复杂度降低为o(1)
# 原地修改时，为避免从前往后遍历导致原有数组元素被破坏掉，我们要选择从后往前遍历，

# 自己按照图谱出现问题的地方：
# 1. 边界条件考虑清楚：i和j都小于0
# 2. 临界情况，当j=-1的时候，或者i=-1，要特殊处理一下,避免出现index out of的报错
# 3. 其他按照互相比大小，然后赋值给nums1的元素
def merge(nums1, m, nums2, n):
    # 设 i为nums1的指针，指向最后一个元素，j为nums2的指针，指向最后一个元素，k指向nums1最后一个元素（0）
    i, j = m - 1, n - 1
    k = len(nums1) - 1
    while j >= 0 or i >= 0:
        if j==-1:
            nums1[k] = nums1[i]
            i -= 1
        elif i == -1:
            nums1[k] = nums2[j]
            j-=1
        elif nums1[i] >= nums2[j]:
            nums1[k] = nums1[i]
            i -= 1
        elif nums1[i] < nums2[j]:
            nums1[k] = nums2[j]
            j -= 1
        k -= 1
    print(nums1)


nums1 = [1,2,3,0,0, 0]
m = 3
nums2 = [4,5,6]
n = 3
merge(nums1, m, nums2, n)
```

## 总结
1. 循环的边界情况要考虑清楚
2. 边界的特殊情况要处理，保证程序不会出现报错，例如：index out of 的报错
3. 画图，嘴巴一边说，一边去程序移动的过程，多说几遍，多巩固自己的思路
4. 测试，debug，找出自己未能考虑到的地方
5. 原地修改的情况，在今后的算法题中可以考虑使用指针，逆向双向指针