# 1.安装前准备
- 电脑：mac, m1
- 虚拟机：[下载UTM](https://mac.getutm.app/)
- 安装三个节点(linux镜像版本:ubuntu-20.04.5-live-server-arm64) [下载地址](http://cdimage.ubuntu.com/ubuntu/releases/20.04/release/)
- 安装教程:[点这](https://www.cnblogs.com/eisenshu/p/17654371.html)

集群规划：
- 共3个节点: node1 node2 node3
- node1 master
- node2 worker
- node3 worker

## 1.1  基础配置
### a. 配置 root 账号
```
sudo passwd root
```
### b.设置 ssh 连接
```
vim /etc/ssh/sshd_config
```
然后设置 PermitRootLogin yes
重启sshd服务
```
sudo service ssh restart
```
启用 ssh & 设置免密登录
```
https://zhuanlan.zhihu.com/p/145763789
https://blog.csdn.net/chenxuecheng1984/article/details/115870404
```
### c.关闭防火墙
```
sudo ufw status
sudo ufw disable
```
### d.关闭 swap
k8s init的时候不允许开启swap

临时关闭
```
swapoff -a
```
永久关闭
```
vi /etc/fstab
## 注释掉最后一行 /swap.img
```
### e. 在 master(node1) 添加 hosts
注意替换自己节点对应的 ip

查询 ip 可以用 `ip -a`
```
cat >> /etc/hosts << EOF
192.168.64.5 node1
192.168.64.6 node2
192.168.64.7 node3
EOF
```
### f.时间同步
安装 ntpdate 并同步时间
```
apt update && apt install ntpdate
ntpdate cn.ntp.org.cn
``` 
### g.将桥接的IPv4流量传递到iptables的链
```
cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
vm.swappiness = 0
EOF
```
加载br_netfilter模块
```
modprobe br_netfilter
```
查看是否加载
```
lsmod | grep br_netfilter
```
```
sysctl --system  # 生效
```
### h.确保各节点MAC 地址和 product_uuid 的唯一性 
```
# 确保各节点mac地址唯一性
ifconfig -a|grep ether
# 确保各节点produce_uuid唯一性
sudo cat /sys/class/dmi/id/product_uuid #
```
## 1.2 开启ipvs（可选）

## 1.3 安装 docker
k8s支持的容器运行时有很多如docker、containerd、cri-o等等，由于现在主流还是docker，所以这里选择安装docker
```
apt-get update
apt install -y docker.io
```

# 2.k8s 安装
## 2.1 添加阿里云的YUM软件源
```
apt update && apt install apt-transport-https curl

curl -fsSL https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add -

add-apt-repository "deb [arch=arm64] https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main"
```
## 2.2 安装kubeadm、kubelet和kubectl(所有节点)
### a.选择版本，可以 apt search 一下
```
apt search kubeadm
```
这里用 1.28.2-00 版本
### b.安装命令
```
apt-get update

apt-cache madison kubelet kubectl kubeadm |grep '1.28.2-00' 

apt install -y kubelet=1.28.2-00 kubectl=1.28.2-00 kubeadm=1.28.2-00
```
### c.再次禁用 swap
```
vim /etc/default/kubelet

## 输入以下内容至 kubelet 文件
KUBELET_EXTRA_ARGS="--fail-swap-on=false"

systemctl daemon-reload && systemctl restart kubelet
```
```
sudo swapoff -a
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF

sudo sysctl --system
```
### d.修改cgroup管理器
```
vim /etc/docker/daemon.json 
```
然后将下面设置加入daemon.json文件
```
{
  "exec-opts": [
    "native.cgroupdriver=systemd"
  ]
}
```
```
systemctl restart docker

systemctl enable kubelet
```
## 2.3 初始化&加入节点
### a.部署k8s的master节点(node1)
这里的 192.168.64.2 填当前节点的ip
```
kubeadm init \
  --apiserver-advertise-address=192.168.64.2 \
  --image-repository registry.aliyuncs.com/google_containers \
  --control-plane-endpoint=192.168.64.2:6443 \
  --kubernetes-version v1.28.2 \
  --service-cidr=10.96.0.0/12 \
  --pod-network-cidr=10.244.0.0/16 \
  --upload-certs
```
参数说明：

- --image-repository：指定要使用的镜像仓库，默认为gcr.io。
- --kubernetes-version：Kubernetes程序组件的版本号，它必须与安装的kubelet程序包的版本号相同。
- --control-plane-endpoint：控制平面的固定访问端点，可以是IP地址或DNS名称，作为集群管理员与集群组件的kubeconfig配置文件的API Server的访问地址。单控制平面部署时可以不使用该选项。
- --pod-network-cidr：Pod网络的地址范围，其值为CIDR格式的网络地址，通常Flannel网络插件的默认值为10.244.0.0/16，Project Calico插件的默认值为192.168.0.0/16。
- --service-cidr：Service的网络地址范围，其值为CIDR格式的网络地址，默认为10.96.0.0/12。通常，仅Flannel一类的网络插件需要手动指定该地址。
- --apiserver-advertise-address：API Server通告给其他组件的IP地址，一般为Master节点用于集群内通信的IP地址，0.0.0.0表示节点上所有可用地址。
- --token-ttl：共享令牌的过期时长，默认为24小时，0表示永不过期。为防止不安全存储等原因导致的令牌泄露危及集群安全，建议为其设定过期时长

初始化输出日志内容如下：日志很重要
```
...
Your Kubernetes control-plane has initialized successfully!

# 通过如下配置，即可操作集群
To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

#  通过如下命令添加master节点
You can now join any number of the control-plane node running the following command on each as root:

  kubeadm join 192.168.64.5:6443 --token qv4vub.h7aov4ae3z182y99 \
	--discovery-token-ca-cert-hash sha256:f3b753e4484154f11c9105427ca614a1e07dfc8ddaa167eec86c1cfed8cbfb7e \
	--control-plane --certificate-key a6c6f91d8d2360934b884eb6a5f65d8bad3a2be25c3da0e280de7ad2225668af

# token过期，可通过如下命令生成新的token
Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
"kubeadm init phase upload-certs --upload-certs" to reload certs afterward.

# 通过如下命令，添加node节点
Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.64.5:6443 --token qv4vub.h7aov4ae3z182y99 \
	--discovery-token-ca-cert-hash sha256:f3b753e4484154f11c9105427ca614a1e07dfc8ddaa167eec86c1cfed8cbfb7e

```
根据输出提示执行对应操作即可
```
设置 master role
kubectl label node node1 node-role.kubernetes.io/master=


执行.kube配置
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

配置calico网络
curl https://projectcalico.docs.tigera.io/manifests/calico.yaml -O
kubectl apply -f calico.yaml


Systemctl restart kubelet
systemctl restart containerd
```
### b.  部署k8s的node节点(node2 node3)
这里的命令都是由前面的日志输出所生成，不要无脑填 token
```
kubeadm join 192.168.64.2:6443 --token jfik3p.hzsojd6lh0ovw6lh \
	--discovery-token-ca-cert-hash sha256:95e11cfbaa35beb5ab206c95a848eb955b0d57af0cedddcfc195b879d2552a03
```
### c. 配置命令补全
```
apt install bash-completion

# 加载bash-completion
source /etc/profile.d/bash_completion.sh

# 加载环境变量
echo "export KUBECONFIG=/root/.kube/config" >> /root/.bash_profile
echo "source <(kubectl completion bash)" >> /root/.bash_profile
source .bash_profile
source /etc/bash_completion
```
### d. 其他
如果想重新设置 node join
可以进行 reset
```
# 清除已经join的节点  
kubeadm reset
```
展示 token
```
kubeadm token list
```
查询 token对应的 hash
```
openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'
```
重新创建 token
```
kubeadm token create --print-join-command
```
重新生成 certificate-key
```
kubeadm init phase upload-certs --upload-certs
```
遇到其他问题直接使用搜索引擎

Mac使用UTM虚拟机搭建k8s集群

## 1.CAP 理论？

- C : Consistency 一致性,数据在多个副本之间似否能够保持一致的特性。

- A: Availability 可用性，系统服务必须一直处于可用状态，对每个请求总是在指定的时间返回结果。

- P:Partition tolerance 分区容错性,遇到分区网络故障时，仍能对外提供一致性和可用性的服务。

不能同时满足 3 个要求，只能满足其中的两个。


## 2.BASE 理论？

#### Basically Available(基本可用)、Soft state(软状态) 和 Eventuanlly consistent （最终一致性）3 个短语的简写。

- 基本可用：系统出现不可预知的故障时，允许损失部分可用性。

- 弱（软）状态：数据的中间状态，并认为改状态存在不会一项系统整体可用性，允许不同节点数据副本数据同步过程中的延时。

- 最终一致性：系统中所有数据副本，在一段时间的同步后，最终数据能够到一致性的状态。

## 3.什么是 ZooKeeper?

ZooKeeper 是一个开源分布式协同服务系统，Zookeeper 的设计目标是将那些复杂容易出错的分布式一致性服务封装起来，构成一个高效可用的原语集，并提供一系列简单接口给用户使用。

## 4.ZooKeeper 可以实现哪些功能？

数据发布/订阅

负载均衡

命名服务

分布式协调/通知

集群管理

Master 选举

分布式锁

分布式队列


## 5.ZooKeeper 可以保证哪些分布式一致性特性？


顺序一致性

原子性

单一视图

可靠性

实时性

## 6.ZooKeeper 的数据模型？


共享的、树形结构，由一系列的 ZNode 数据节点组成，类似文件系统(目录不能存数据）。ZNode 存有数据信息，如版本号等等。ZNode 之间的层级关系，像文件系统中的目录结构一样。并且它是将数据存在内存中，这样可以提高吞吐、减少延迟。

## 7.如何识别请求的先后顺序？
ZooKeeper 会给每个更新请求，分配一个全局唯一的递增编号（zxid)，编号的大小体现事务操作的先后顺序。

## 8.为什么叫 ZooKeeper?
ZooKeeper 最早起源于雅虎研究院的一个研究小组，在立项初期，发现很多项目都是用动物的名字来起的，当时首席科学家觉得不能再继续起动物的名字了，把它起名叫动物园管理员，正好它分布式协同服务的特性很相符，所以 ZooKeeper 诞生了。

## 9.A 是根节点，如何表达 A 子节点下的 B 节点？
```
/A/B
```

## 10.集群角色？

Leader、Follower、Observer


## 11.ZNode 的类型？
持久节点：一旦创建，除非主动移除，否则会一直保存在 ZooKeeper。

临时节点：生命周期和客户端会话绑定，会话失效，相关的临时节点被移除。

持久顺序性：同时具备顺序性。

临时顺序性：同时具备顺序性。


## 12.Stat 记录了哪些版本相关数据？
version:当前 ZNode 版本

cversion:当前 ZNode 子节点版本

aversion:当前 ZNode 的 ACL 版本

## 12.权限控制?
Access Control Lists ,ACL。类似于 UNIX 文件系统的权限控制。

## 14.ZooKeeper 定义了几种权限？
CREATE

READ

WRITE

DELETE

ADMIN

## 15.Zookeeper 专门设计的一种支持崩溃恢复的原子广 播协议是?

ZAB 

## 16.ZAB 的两种基本模式？

- 崩溃恢复：在正常情况下运行非常良好，一旦 Leader 出现崩溃或者由于网络原因导致 Leader 服务器失去了与过半 Follower 的联系，那么就会进入崩溃恢复模式。为了程序的正确运行，整个恢复过程后需要选举出一个新的 Leader,因此需要一个高效可靠的选举方法快速选举出一个 Leader。

- 消息广播：类似一个两阶段提交过程，针对客户端的事务请求， Leader 服务器会为其生成对应的事务 Proposal,并将其发送给集群中的其余所有机器，再分别收集各自的选票，最后进行事务提交。


## 17.哪些情况会导致 ZAB 进入恢复模式并选取新的 Leader?

- 启动过程或 Leader 出现网络中断、崩溃退出与重启等异常情况时。

- 当选举出新的 Leader 后，同时集群中已有过半的机器与该 Leader 服务器完成了状态同步之后,ZAB 就会退出恢复模式。


## 18.Zookeeper 默认端口？
2181


## 19.如何创建一个 ZNode?
```
create /app
-e 临时
-s 顺序

```

## 20.几种部署方式？
单机、伪集群、集群

## 21.如何查看子节点？
```
ls path [watch]
path : 节点路径

[zk: localhost:2181(CONNECTED) 5] ls /app
[book]
```

## 22.获取指定节点信息？
```
get path [watch]
[zk: localhost:2181(CONNECTED) 1] get /app
123
```

## 23.更新指定节点信息？
```
set path data [version]
[zk: localhost:2181(CONNECTED) 6] set /app 222
[zk: localhost:2181(CONNECTED) 7] get /app
222
```

## 24.删除指定节点？注意？
```
delete path [version]
[zk: localhost:2181(CONNECTED) 8] delete /app
Node not empty: /app
```
如果没有子节点，就能删除成功。如果有会提示，该节点不为空。


## 25.什么是会话 Session?

指的是客户端会话，客户端启动时，会与服务器建议 TCP 链接，连接成功后，客户端的生命周期开始，客户端和服务器通过心跳检测保持有效的的会话以及发请求并响应、监听 Watch 事件等。

## 26.在 sessionTimeout 之内的会话，因服务器压力大、网络故障或客户端主动断开情况下，之前的会话还有效吗？

有效。

## 27.Watcher 事件监听器？

ZooKeeper 允许用户在指定节点上注册 Watcher,当触发特定事件时，ZooKeeper 服务端会把相应的事件通知到相应的客户端上，属于 ZooKeeper 一个重要的特性。

## 28.Quorum?

当集群中过半 UP 状态的进程组成了进程子集后，就可以正常的消息传播了，这样的一个子集我们称为 Quorum。

## 29.同进程组的两个进程消息网络通信有哪两个特性？
- 完整性： 如果进程 a 收到进程 b 的消息 msg,那么 b 一定发送了消息 msg。

- 前置性：如果 msg1 是 msg2 的前置消息，那么当前进程务必先接收到 msg1,在接受 msg2。


## 30.ZAB 三个阶段？
- 发现   (Discovery)
- 同步  (Synchronization)
- 广播 (Broadcast) 

## 31.发现?

Follower 把自己最后的接受事务的 Proposal 值(CEPOCH(F.p)发送给 Leader。



当收到过半 Follower 的消息后，Leader 生成 NEWEPOCH(e')给这些过半的 Follower。



tips: e' = Max((CEPOCH(F.p))  + 1



Follower 收到消息后，如果自己值小于 e',则同步 e'的值，同时向 Leader 发 Ack 消息。



## 32.服务器的 3 中角色？
- Leader 角色：
- Follower 角色：
- Observer 角色：

## 33.数据发布/订阅？
发布者将数据发布到 ZooKeeper 上一个或多个节点上，订阅者从中订阅数据，从而动态获取数据的目的，实现配置信息的集中式管理和数据动态更新。

## 34.发布订阅的两种设计模式？

推(Push) :服务端主动推数据给所有定于的客户端。

拉(Pull):客户端主动发请求来获取最新数据。

## 35.ZooKeeper 用推/拉模式？
推拉结合

## 36.客户端如何获取配置信息？

启动时主动到服务端拉取信息，同时，在制定节点注册 Watcher 监听。一旦有配置变化，服务端就会实时通知订阅它的所有客户端。



ZooKeeper 面试

面试-大数据题目

# Linux查看进程号、端口号
## 1、已知程序名称查看进程号
```
ps -ef | grep 程序名称
## 或者
ps -aux | grep 程序名称
pgrep -l 程序名称
````
🐖 pgrep 是通过程序的名字来查询进程ID的工具，一般是用来判断程序是否正在运行，返回信息非常简洁。

用法：ps 参数选项 程序名

常用参数
- -l 列出程序名和进程ID；
- -o 进程起始的ID；
- -n 进程终止的ID；

## 2、端口号查看进程号（查看端口占用情况）
🐖 必须为root用户
```
lsof -i:端口号 
## 或者
netstat -ntulp |grep 端口号
```
- -t (tcp) 仅显示tcp相关选项
- -u (udp)仅显示udp相关选项
- -n 拒绝显示别名，能显示数字的全部转化为数字
- -l 仅列出在Listen(监听)的服务状态
- -p 显示建立相关链接的程序名

## 3、根据进程号查询正在运行的程序的port(端口号)
```
netstat -anop | grep pid
```

## 4、根据PID查询进程名称:
```
ll /proc/PID 
```
这样就可以定位到该运行程序的路径
🐖 注意PID替换成自己查询到的PID代号

## 5、杀死进程
```
kill -9 PID
```
## 6、查看所有用户的进程情况
```
top
```
top命令如果不加限制，默认是查看所有用户的进程情况

## 7、 查看某用户的所有进程
``` 
top -u [用户名]  
```
## 8、查看进程所属用户
```
 ps u PID 
```


linux查看进程号、端口号

docker的容器不断产生日志，如果没有日志大小限制的话，日志会越来越多导致磁盘空间不足。

# 清理Docker容器日志（治标）
如果docker容器正在运行，那么使用rm -rf方式删除日志后，通过df -h会发现磁盘空间并没有释放。原因是在Linux或者Unix系统中，通过rm -rf或者文件管理器删除文件，将会从文件系统的目录结构上解除链接（unlink）。如果文件是被打开的（有一个进程正在使用），那么进程将仍然可以读取该文件，磁盘空间也一直被占用。正确姿势是cat /dev/null > *-json.log，当然你也可以通过rm -rf删除后重启docker。接下来，提供一个日志清理脚本clean_docker_log.sh，内容如下：
```
#!/bin/sh 
  
echo "======== start clean docker containers logs ========"  
  
logs=$(find /var/lib/docker/containers/ -name *-json.log)  
  
for log in $logs  
        do  
                echo "clean logs : $log"  
                cat /dev/null > $log  
        done  

echo "======== end clean docker containers logs ========"  
```
```
chmod +x clean_docker_log.sh
```
```
./clean_docker_log.sh
```


docker容器日志清理

crontab：定时任务的守护进程，精确到分，设计秒的我们一般写脚本
```
usage:  crontab [-u user] file
        crontab [-u user] [ -e | -l | -r ]
                (default operation is replace, per 1003.2)
        -e      (edit user's crontab) [编辑定时脚本]
        -l      (list user's crontab) [查询定时脚本]
        -r      (delete user's crontab)
        -i      (prompt before deleting user's crontab)
        -s      (selinux context)
```

### crontab文件分享
```
cat /etc/crontab
```
下面是文件内容
```
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root

# For details see man 4 crontabs

# Example of job definition:
# .---------------- minute (0 - 59)
# |  .------------- hour (0 - 23)
# |  |  .---------- day of month (1 - 31)
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
# |  |  |  |  |
# *  *  *  *  * user-name  command to be executed
```
> 前四行是用来配置crond任务运行的环境变量

> 第一行SHELL变量指定了系统要使用哪个shell，这里是bash

> 第二行PATH变量指定了系统执行命令的路径

> 第三行MAILTO变量指定了crond的任务执行信息将通过电子邮件发送给root用户

> 如果MAILTO变量的值为空，则表示不发送任务执行信息给用户

> 第四行的HOME变量指定了在执行命令或者脚本时使用的主目录。

> 星号（*）：代表所有可能的值，如month字段为星号，则表示在满足其它字段的制约条件后每月都执行该命令操作。

> 逗号（,）：可以用逗号隔开的值指定一个列表范围，例如，“1,2,5,7,8,9”

> 中杠（-）：可以用整数之间的中杠表示一个整数范围，例如“2-6”表示“2,3,4,5,6”

> 正斜线（/）：可以用正斜线指定时间的间隔频率，例如“0-23/2”表示每两小时执行一次。
```
小 结：
    数字的表示最好用2为阿拉伯数字显示
    周和日最好不要同时用
    定时任务要加注解
    可以定向到日志文件或者空文件
    定时任务一定是绝对路径，且目录必须存在才能出结果
    crontab 服务一定要开启运行
```
### crontab的安装和使用
- 安装crontab：
```
yum install crontabs
```
- crontab服务操作说明：
```
/sbin/service crond start //启动服务
 
/sbin/service crond stop //关闭服务
 
/sbin/service crond restart //重启服务
 
/sbin/service crond reload //重新载入配置
```
- 查看crontab服务状态：
```
service crond status
```
- 手动启动crontab服务：
```
service crond start
```
- 查看crontab服务是否已设置为开机启动，执行命令：
```
方法一： 界面启动      ntsysv 
方法二： 加入开机自动启动：   chkconfig –level 35 crond on
```
- crontab -l查看定时任务列表

- 编辑定时任务
```
crontab –e

==》vim /var/spool/cron/root
每隔2分钟输出时间到文件


*/2 * * * * echo `date` >> $HOME>test.txt
crontab -r 删除定时任务

==> 从/var/spool/cron目录中删除用户的crontab文件
==> 如果不指定用户，则默认删除当前用户的crontab文件
 crontab –i  在删除用户的crontab文件时给确认提示
```
- 备份crontab文件
```
crontab -l > $HOME/mycron
```
- 恢复丢失的crontab文件
```
- 如果不小心误删了crontab文件，假设你在自己的$ H O M E目录下还有一个备份，那么可以将其拷贝到/var/spool/cron/<username>，其中<username>是用户名。如果由于权限问题无法完成拷贝，可以用：
crontab <filename> 其中，<filename>是你在$ H O M E目录中副本的文件名。
有些crontab的变体有些怪异，所以在使用crontab命令时要格外小心。如果遗漏了任何选项，crontab可能会打开一个空文件，或者看起来像是个空文件。这时敲delete键退出，不要按<Ctrl-D>，否则你将丢失crontab文件。
每小时执行/etc/cron.hourly目录内的脚本


0 * * * * root run-parts /etc/cron.hourly
每隔2分钟同步一次互联网时间


echo "*/2 * * * * /usr/bin/ntpstat time.windows.com >/dev/null 2>&1" >> /var/spool/cron/root

每天3-5,17-20每隔30分钟执行一次脚本


echo "*/30 [3-5],[17-20] * * * /bin/sh /home/omc/h.sh >/dev/null 2>&1" >> /var/spool/cron/root

当天23点，第二天0点到凌晨7点 每隔1分钟执行一次脚本


* 23,00-07/1 * * * /bin/sh /home/omc.h.sh

每年的4月份每周的周一到周三的11点执行脚本   


00 11 *  4 1-3 /bin/sh /home/omc/h.sh
```
### crontab的注意事项
1.注意环境变量问题
```
在crontab文件中定义多个调度任务时，需要特别注意的一个问题就是环境变量的设置

# 脚本中涉及文件路径时写全局路径；
# 脚本执行要用到java或其他环境变量时，通过source命令引入环境变量，如：
cat start_cbp.sh
#!/bin/sh
source /etc/profile
export RUN_CONF=/home/d139/conf/platform/cbp/cbp_jboss.conf
/usr/local/jboss-4.0.5/bin/run.sh -c mev &
 
# 当手动执行脚本OK，但是crontab死活不执行时。可以尝试在crontab中直接引入环境变量解决问题。
0 * * * * . /etc/profile;/bin/sh /var/www/java/audit_no_count/bin/restart_audit.sh
```
2.系统级任务调度与用户级任务调度
```
root用户的任务调度操作可以通过“crontab –uroot –e”来设置，也可以将调度任务直接写入/etc/crontab文件，需要注意的是，如果要定义一个定时重启系统的任务，就必须将任务放到/etc/crontab文件，即使在root用户下创建一个定时重启系统的任务也是无效的。
```
3.其他注意事项
```
当crontab突然失效时，可以尝试/etc/init.d/crond restart解决问题。或者查看日志看某个job有没有执行/报错tail -f /var/log/cron。
千万别乱运行crontab -r。它从Crontab目录（/var/spool/cron）中删除用户的Crontab文件。删除了该用户的所有crontab都没了。
在crontab中%是有特殊含义的，表示换行的意思。如果要用的话必须进行转义\%，如经常用的date ‘+%Y%m%d’在crontab里是不会执行的，应该换成date ‘+\%Y\%m\%d’
```
4.生产调试定时任务
```
1.增加执行任务的频率调试
2.调整系统时间调试任务，提前5分钟   -->不用于生产环境
3.通过脚本日志输出调试定时 任务
4.注意一些任务命令带来的问题        -->确保命令的正确性
```
5.crontab箴言
```
1.环境变量问题，例如crontab不能识别Java的环境变量
    crontab执行shell时，只能识别为数不多的环境变量，普通的环境变量是无法识别的，所以在编写shell时，最好使用export重新声明变量，确保脚本执行。 
2.命令的执行最好用脚本
3.脚本权限加/bin/sh，规范路径/server/scripts
4.时间变量用反斜线转义，最好用脚本
5.定时任务添加注释
6.>/dev/null 2>&1   ==>&>/dev/null,别随意打印日志文件
7.定时任务里面的程序脚本尽量用全路径
8.避免不必要的程序以及命令输出
9.定时任务之前添加注释
10.打包到文件目录的上一级
```

linux定时功能-crontab

在平时拉取镜像启动容器时，进入该容器可能想进行修改数据，但是常见的vim，wget命令未找到，此时我们需要去安装这些命令。

## 安装vi/vim
```
sudo apt-get update
sudo apt-get install vim
```

## 安装wget
```
sudo apt-get update
sudo apt-get install wget
```
安装wget之后就可以wget远程下载文件了。
比如我们有一些文件需要放进容器里，但由于某些原因无法直接传输，所以可以采用这种远程下载的方式。

Docker容器里的常用命令安装

在前面的文章中有讲到docker部署mysql并挂载，同时配置文件时默认启动了event定时功能
# 一、事件（EVENT）是干什么的
##### 自MySQL5.1.6起，增加了一个非常有特色的功能 - 事件调度器（Event Scheduler），可以用做定时执行某些特定任务（例如：删除记录、数据统计报告、数据备份等等），来取代原先只能由操作系统的计划任务来执行的工作。
##### 值得一提的是MySQL的事件调度器可以精确到每秒钟执行一个任务，而操作系统的计划任务（如：Linux的cron）只能精确到每分钟执行一次。对于一些对数据实时性要求比较高的应用（例如：股票、赔率、比分等）就非常适合。
##### 事件有时也可以称为临时触发器（temporal triggers），因为事件调度器是基于特定时间周期触发来执行某些任务，而触发器（Triggers）是基于某个表所产生的事件触发的，区别也就在这里。
# 二、开启“事件”功能
#### 使用“事件”功能之前必须确保event_scheduler已开启
## 1.查询功能是否开启
```
-- 方法一
SELECT @@event_scheduler;
-- 方法二
SHOW VARIABLES LIKE 'event%';
```
显示 “ON”说明功能已开启；如下图：
```
mysql> SELECT @@event_scheduler;
+-------------------+
| @@event_scheduler |
+-------------------+
| ON                |
+-------------------+
1 row in set (0.00 sec)

mysql> SHOW VARIABLES LIKE 'event%';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| event_scheduler | ON    |
+-----------------+-------+
1 row in set (0.00 sec)
```
## 2、开启、关闭功能命令
```
-- 开启功能命令：
SET GLOBAL event_scheduler = 1;
SET GLOBAL event_scheduler = ON;
-- 关闭功能命令：
SET GLOBAL event_scheduler = 0;
SET GLOBAL event_scheduler = OFF;
```
当然，通过命令开启当数据库重启后会自动关闭；

持久化开启方式：将event_scheduler=ON写到my.cnf配置文件中，如下图：
```
[mysqld]  
event_scheduler=ON
default-time-zone='+08:00'
```

常用的事件操作命令：
- 关闭指定事件： ALTER EVENT 事件名称 ON COMPLETION PRESERVE DISABLE;
- 开启指定事件：ALTER EVENT 事件名称 ON COMPLETION PRESERVE ENABLE;
- 查看当前事件：SHOW EVENTS ;
# 三、事件 - SQL语法创建
下面是EVENT事件创建语句，乍一看挺复杂的，让我们拆开解读一下
```
CREATE EVENT [IFNOT EXISTS] event_name
    　　 ON SCHEDULE schedule(调度时间设置)
    　　 [ON COMPLETION [NOT] PRESERVE]
    　　 [ENABLE | DISABLE | DISABLE ON SLAVE]
    　　 [COMMENT 'comment']
    　　 DO sql_statement;
```
| SQL语法 | 说明 | 
| ------ | ------ |
|DEFINER	|可选项，给指定用户使用权限|
|IF NOT EXISTS|可选项，用于判断要创建的事件是否存在|
|EVENT event_name|必选项，指定事件名称，event_name的最大长度为64个字符，如果为指定event_name，则默认为当前的MySQL用户名（不区分大小写）|
|ON SCHEDULE schedule|必选项，这里的schedule用于定义执行的时间和时间间隔，在下面我们详细讲解|
|ON COMPLETION [NOT] PRESERVE|可选项，配置事件执行完一次后的处理方式,当为on completion preserve 的时候,当event到期了,event会被disable,但是该event还是会存在当为on completion not preserve的时候,当event到期的时候,该event会被自动删除掉.|
|ENABLE、DISABLE、DISABLE ON SLAVE|可选项，用于指定事件的一种属性。ENABLE表示该事件是开启的，也就是调度器检查事件是否必选调用；DISABLE表示该事件是关闭的，也就是事件的声明存储到目录中，但是调度器不会检查它是否应该调用；DISABLE ON SLAVE表示事件在从机中是关闭的。如果不指定这三个选择中的任意一个，则在一个事件创建之后，它立即变为活动的|
|COMMENT ‘comment’|可选项，用于定义事件的注释|
|DO event_body|必选项，用于指定事件启动时所要执行的代码。可以是任何有效的SQL语句、存储过程或者一个计划执行的事件。如果包含多条语句，可以使用BEGIN…END复合结构|

schedule 调度时间配置语法：调度时间配置包括AT 和 EVERY两种
```
AT timestamp [+ INTERVAL interval] ...
  | EVERY interval
    [STARTS timestamp [+ INTERVAL interval] ...]
    [ENDS timestamp [+ INTERVAL interval] ...]


-- INTERVAL中包含的时间单位如下:
{YEAR | QUARTER | MONTH | DAY | HOUR | MINUTE |
 WEEK | SECOND | YEAR_MONTH | DAY_HOUR | DAY_MINUTE |
 DAY_SECOND | HOUR_MINUTE | HOUR_SECOND | MINUTE_SECOND}

```
## 1、创建 - 单次定时执行事件
```
AT TIMESTAMP 时间字符串 [+ INTERVAL INTERVAL]
```
- AT TIMESTAMP表示该事件只执行一次
- TIMESTAMP表示一个具体的时间点，后面可以加上一个时间间隔，表示在这个时间间隔后事件发生。
- [+ INTERVAL INTERVAL]表示延迟触发时间；

  需要注意的是，TIMESTAMP和具体字符串连用，如果不是具体字符串（如CURRENT_TIMESTAMP取当前时间等），则不加TIMESTAMP;

### 示例 1：往demo_1119表中插入一行数据，执行时间：2020-11-20 00:00:00
```
CREATE EVENT demo_event2 
ON SCHEDULE AT TIMESTAMP '2020-11-20 00:00:00' 
DO INSERT INTO `demo_1119` (`id`, `name`, `createTime`) VALUES (null, 'Anyc', NOW())

```
结果查询：
```
mysql> select * from demo_1119;
+-----+-----------+---------------------+
| id  | name      | createTime          |
+-----+-----------+---------------------+
| 145 | Anyc      | 2020-11-20 00:00:00 |
+-----+-----------+---------------------+
9 rows in set (0.00 sec)
```
### 示例 2：往demo_1119表中插入一行数据，执行时间：当前时间往后5个小时；
```
CREATE EVENT demo_event2 
ON SCHEDULE AT CURRENT_TIMESTAMP + INTERVAL 5 HOUR
DO INSERT INTO `demo_1119` (`id`, `name`, `createTime`) VALUES (null, 'Anyc', NOW())

```
## 2、创建 - 循环定时执行事件
```
EVERY INTERVAL [STARTS TIMESTAMP] [ENDS TIMESTAMP]
```
- EVERY表示循环执行该事件
- 其中STARTS子句用于指定开始时间
- ENDS子句用于指定结束时间。
### 示例 1：从当前开始，每10秒往demo_1119表中插入一行数据
```
CREATE EVENT demo_event3 
ON SCHEDULE EVERY 10 SECOND 
ON COMPLETION PRESERVE 
DO INSERT INTO `demo_1119` (`id`, `name`, `createTime`) VALUES (null, 'Anyc', NOW())
```
```
mysql> select * from demo_1119;
+-----+-----------+---------------------+
| id  | name      | createTime          |
+-----+-----------+---------------------+
| 145 |   Anyc    | 2023-04-20 11:10:39 |
| 146 |   Anyc    | 2023-04-20 11:10:49 |
| 147 |   Anyc    | 2023-04-20 11:10:59 |
| 148 |   Anyc    | 2023-04-20 11:11:09 |
| 149 |   Anyc    | 2023-04-20 11:11:19 |
| 150 |   Anyc    | 2023-04-20 11:11:29 |
| 151 |   Anyc    | 2023-04-20 11:11:39 |
+-----+-----------+---------------------+
9 rows in set (0.00 sec)

```
### 示例 2：从2020-11-20 12:00:00开始，每10分钟往demo_1119表中插入一行数据
```
CREATE EVENT demo_event4 
ON SCHEDULE EVERY 10 MINUTE STARTS '2020-11-20 12:00:00' 
ON COMPLETION PRESERVE 
DO INSERT INTO `demo_1119` (`id`, `name`, `createTime`) VALUES (null, '陈哈哈', NOW())
```
```
mysql> select * from demo_1119;
+-----+-----------+---------------------+
| id  | name      | createTime          |
+-----+-----------+---------------------+
| 152 |   Anyc    | 2023-04-20 12:00:00 |
| 153 |   Anyc    | 2023-04-20 12:10:00 |
| 154 |   Anyc    | 2023-04-20 12:20:00 |
| 155 |   Anyc    | 2023-04-20 12:30:00 |
| 156 |   Anyc    | 2023-04-20 12:40:00 |
+-----+-----------+---------------------+
5 rows in set (0.00 sec)
```
### 示例 3：从当前时间一小时后开始，每10分钟往demo_1119表中插入一行数据；已经测试过可用，我就不再贴冗余查询的数据咯~
```
CREATE EVENT demo_event5 
ON SCHEDULE EVERY 10 MINUTE STARTS CURRENT_TIMESTAMP+INTERVAL 1 HOUR 
ON COMPLETION PRESERVE 
DO INSERT INTO `demo_1119` (`id`, `name`, `createTime`) VALUES (null, 'Anyc', NOW())
```
### 示例4：从当前时间一天后开始，每1小时往demo_1119表中插入一行数据，三天后结束
```
CREATE EVENT demo_event5 
ON SCHEDULE EVERY 1 HOUR 
STARTS CURRENT_TIMESTAMP+INTERVAL 1 DAY 
ENDS CURRENT_TIMESTAMP+INTERVAL 3 DAY 
ON COMPLETION PRESERVE 
DO INSERT INTO `demo_1119` (`id`, `name`, `createTime`) VALUES (null, 'Anyc', NOW())
```
### 示例5：每天零点定时清一下demo_1119表数据
```
CREATE EVENT demo_event5 
ON SCHEDULE EVERY 1 DAY STARTS '2023-4-20 00:00:00' 
ON COMPLETION PRESERVE 
DO TRUNCATE table `demo_1119`
```
## 3、修改事件
修改事件语句跟创建语句如出一辙，语法如下：
```
ALTER EVENT event_name
    　　 [ONSCHEDULE schedule]
    　　 [old_NAME TO new_NAME]
    　　 [ON COMPLETION [NOT] PRESERVE]
    　　 [COMMENT 'comment']
    　　 [ENABLE | DISABLE]
    　　 [DO sql_statement]
```
- 关闭事件任务： ALTER EVENT 事件名称 ON COMPLETION PRESERVE DISABLE;
- 开启事件任务：ALTER EVENT 事件名称 ON COMPLETION PRESERVE ENABLE;
## 4、删除事件
```
DROP EVENT [IF EXISTS] event_name
```

## 5.自己在项目中遇到的一些例子
定时从中间数据库拿数据并推至业务数据库（全量更新）
1. demo（每18秒钟将清空表1，查询表2并插入表1）
```
CREATE EVENT full_update
ON SCHEDULE
EVERY 18 SECOND
ON COMPLETION PRESERVE
COMMENT '新增用户信息定时任务'
DO
BEGIN

    TRUNCATE TABLE ncu.xs_xsjbsj;   # 清空表

    INSERT INTO ncu.xs_xsjbsj SELECT * FROM reservation.xs_xsjbsj;   # 插入全量数据

END;
```
2. 每天凌晨三点同步b数据
```
create event full_update_b
    #每天凌晨三点同步b数据
    on schedule every 1 day starts '2016-12-30 03:00:00'
    on completion preserve enable
    comment '同步b数据'
    do
    BEGIN

    TRUNCATE TABLE db1.b;   # 清空表

    INSERT INTO db1.b SELECT * FROM db2.b;   # 插入全量数据

END;
```

3. 每天凌晨三点十分同步y数据
```
create event full_update_y
    #每天凌晨三点十分同步y数据
    on schedule every 1 day starts '2016-12-30 03:10:00'
    on completion preserve enable
    comment '同步y数据'
    do
    BEGIN

    TRUNCATE TABLE db1.y;   # 清空表

    INSERT INTO db1.y SELECT * FROM db2.y;   # 插入全量数据

END;
```
4. 每天凌晨三点二十同步j数据
```
create event full_update_j
    #每天凌晨三点二十同步j数据
    on schedule every 1 day starts '2016-12-30 03:20:00'
    on completion preserve enable
    comment '同步j数据'
    do
    BEGIN

    TRUNCATE TABLE db1.j;   # 清空表

    INSERT INTO db1.j SELECT * FROM db2.j;   # 插入全量数据

END;
```
5. 每天凌晨三点三十同步x数据
```
create event full_update_x
    #每天凌晨三点三十同步x数据
    on schedule every 1 day starts '2016-12-30 03:30:00'
    on completion preserve enable
    comment '同步x数据'
    do
    BEGIN

    TRUNCATE TABLE db1.x;   # 清空表

    INSERT INTO db1.x SELECT * FROM db2.x;   # 插入全量数据

END;
```

MySQL之event(定时任务)

Docker是我们常用的容器引擎，使用Docker来部署和管理我们的常用数据库例如MySQL和Redis是非常的方便的。不过使用Docker安装部署MySQL和Redis还是有一些需要注意的地方的。
# Docker部署MySQL
## 1.拉取MySQL镜像
使用docker pull命令即可拉取
```
docker pull mysql
```
## 2.创建数据卷
#### MySQL作为数据库，其中通常存放我们的用户数据，都是很重要的，因此在容器化部署MySQL时，将MySQL的数据文件等等持久化是非常有必要的。
#### 如果不挂载的话，容器删除数据就没了
这里我们使用具名挂载的方式挂载MySQL容器的数据卷，方便管理。
先创建三个数据卷，分别用于挂载并持久化MySQL的数据文件、配置文件和日志这三个目录：
```
docker volume create mysql-data
docker volume create mysql-config
docker volume create mysql-log
```
这样，我们就创建了三个数据卷，这三个数据卷分别被命名为mysql-data、mysql-config和mysql-log，大家也可以自行取名。





## 3.创建MySQL容器
通过以下命令创建MySQL容器
```
docker run --restart=always -d \
--name=mysql \
-v mysql-config:/etc/mysql/conf.d \
-v mysql-log:/logs \
-v mysql-data:/var/lib/mysql \
-p 3306:3306 \
-e MYSQL_ROOT_PASSWORD=123456 \
-e LANG=C.UTF-8 mysql
```
这样，就完成了MySQL容器的创建和启动，上述命令的参数意义如下：
-  -id 将MySQL容器挂在后台运行
-  --name=mysql 将容器起名为mysql，大家可以自己起名，该参数可以省略
-  -v mysql-config:/etc/mysql/conf.d 把MySQL容器中的配置文件目录挂载至上述创建的名为mysql-config的数据卷上面，还有两个-v挂载数据卷的参数同理
-  -p 3306:3306 把容器的3306端口映射到宿主机的3306端口，这样才能从外网访问这台机器上的MySQL，若你的数据库只需要从本机访问，就可以去除这个参数
-  -e MYSQL_ROOT_PASSWORD=123456 设置容器环境变量MYSQL_ROOT_PASSWORD的值为123456，这个环境变量表示MySQL的root用户的密码，一定要设置，这里设置了密码为123456，大家可以自定义
- -e LANG=C.UTF-8 设置容器的语言环境变量LANG值为C.UTF-8，这个必须要设置，否则容器内默认是英文环境，使得MySQL无法存放中文内容
## 4.修改MySQL配置文件
上述我们已经把创建了数据卷并具名挂载了容器内的MySQL配置目录，只需查看数据卷的位置并修改其中文件即可。
查看数据卷mysql-config的位置：
```
docker volume inspect mysql-config
```
然后展示如图
![](https://photo.xxpyy.top/blog/2023-04-20-5.png)

进入这个目录，可以看到里面有两个默认的MySQL配置文件，使用vim编辑即可，在里面加入自定义的配置。

![](https://photo.xxpyy.top/blog/2023-04-20-6.png)

### 这里配置一下mysql时区并开启定时任务
（为什么要开启定时任务，后面文章将会讲解mysql的定时任务，用于全量更新数据等等）
修改mysql.cnf中的配置文件
```
[mysqld]  
event_scheduler=ON
default-time-zone='+08:00'
```
编辑完成记得重启容器
```
# 上述创建时容器名为mysql，若为自定义此处换为自己的
docker restart mysql
```

# Docker部署Redis
## 1.拉取Redis镜像
使用docker pull命令即可拉取
```
docker pull redis
```
## 2.创建数据卷
#### 在容器化部署Redis时，将Redis的数据文件等等持久化也是非常有必要的。（也可以不挂载，但挂载更好）
#### 如果不挂载的话，容器删除数据就没了
接下来就是要将redis 的配置文件进行挂载，以配置文件方式启动redis 容器。（挂载：即将宿主的文件和容器内部目录相关联，相互绑定，在宿主机内修改文件的话也随之修改容器内部文件）
- 挂载 redis 的配置文件
- 挂载 redis 的持久化文件（为了数据的持久化）。
这里我们使用具名挂载的方式挂载Redis容器的数据卷，方便管理。
先创建两个数据卷，分别用于挂载并持久化Redis的数据文件、配置文件这两个目录：
```
docker volume create redis-data
docker volume create redis-config
```
这样，我们就创建了两个数据卷，这两个数据卷分别被命名为redis-data、redisl-config，大家也可以自行取名。
## 3.创建Redis容器
通过以下命令创建MySQL容器
```
docker run --restart=always \
--log-opt max-size=100m \
--log-opt max-file=2 \
-p 6379:6379 \
--name redis \
-v redis-config:/etc/redis/redis.conf \
-v redis-data:/data -d redis \
redis-server /etc/redis/redis.conf \
--appendonly yes \
--requirepass 123456
```
这样，就完成了Redis容器的创建和启动，上述命令的参数意义如下：
- --restart=always 总是开机启动
- --log是日志方面的
- -p 6379:6379 将6379端口挂载出去
- --name 给这个容器取一个名字
-  -v redis-config:/etc/redis/redis.conf 把Redis容器中的配置文件目录挂载至上述创建的名为redis-config的数据卷上面，还有一个-v挂载数据卷的参数同理
- --appendonly yes 开启redis 持久化
- --requirepass 123456 设置密码 （如果你是通过docker 容器内部连接的话，就随意，可设可不设。但是如果想向外开放的话，一定要设置）
## 4.测试
1. 通过docker ps指令查看启动状态
```
docker ps -a |grep redis # 通过docker ps指令查看启动状态，是否成功.
```
2. 进入redis容器，容器id换成自己的
```
docker exec -it 容器id /bin/bash
```
3. 进去后输入redis-cli测试连接

4. 验证密码auth 123456

## 5.配置
redis.conf
5.1、创建目录存放redis.conf文件
1. 先找到挂载文件的目录
```
docker volume inspect redis-config
```
2.cd 到redis-config挂载的目录下
```
cd /var/lib/docker/volumes/redis-config/_data
```
这个目录对应的挂载相当于容器的/etc/redis/redis.conf

3. 在该目录下存放redis.conf文件

如果没有wget，可以自己 vi redis.conf然后复制粘贴
```
wget http://download.redis.io/redis-stable/redis.conf
```
4. 文件授权
```
chmod 777 redis.conf
```
5. 修改默认配置信息
```
vi redis.conf
```
- #bind 127.0.0.1通过#注释掉，解除本地连接限制
- protected-mode no no-限制为本地访问.yes-外部访问
- daemonize yes 默认no 为不守护进程模式，修改为yes
- requirepass 123456 设置密码
- appendonly yes 持久化(可选)

配置完后，重启redis容器

#### 这里是redis.conf精简版
```
####需要修改的部分（开始）###
#客户端的最大连接数
maxclients 10000
# 密码
requirepass 123456
#最大内存，单位是 byte 位。这里是512M。
maxmemory 512MB
#淘汰策略，默认noeviction只返回错误，不会删除任何key。该策略是Redis的默认淘汰策略，一般不会选用。
maxmemory-policy volatile-ttl
#常见的几种策略：作用对象-淘汰算法 ==》 淘汰策略
#（1）淘汰算法：ttl、random、lru、lfu
#(2) 作用对象：allkeys、volatile

#端口号
port 6379
#开启保护模式
protected-mode yes
#后台运行. 这里必须填no，否则docker容器会推退出。
daemonize no
#默认的日志级别
loglevel notice
#日志文件名
logfile server_log.txt

#以后台方式运行后，进程的位置
pidfile /var/run/redis_6379.pid
#默认可以使用的数据库数量
databases 16
#### 需要修改的部分（结束）  ###


###### RDB 持久化策略 （开始） #####
#15分钟1个更新
save 900 1
#5分钟10个更新
save 300 10
# 分钟1万个更新
save 60 10000

#持久化失败后，是否继续工作，默认yes
stop-writes-on-bgsave-error yes
#是否压缩rdb文件，如果开启比较小号cpu资源
rdbcompression yes
#rdb文件保存时，是否校验错误
rdbchecksum yes
#rdb文件存放的目录
dir ./
###### RDB 持久化策略 （结束） #####


###### AOF 持久化策略 （开始） #####
#开启aof，默认是不开启的。
appendonly yes
# of文件名称
appendfilename appendonly.aof
#erverysec: 1s 刷盘一次（最常用）；always: 每次更新都刷，io次数多，性能低下；no: 不做持久化；
appendfsync everysec

#重写aof的前提条件，文件达到了64MB(默认是64MB)
auto-aof-rewrite-min-size 64mb
#文件达到了64MB,同时最近一次文件大小超出了原来的一倍，才进行aof重写
auto-aof-rewrite-percentage 100
###### AOF 持久化策略 （结束） #####

#使用 RDB、AOF混合持久化
aof-use-rdb-preamble yes


```

Docker部署MySQL和Redis并挂载

Kafka学习之路

# docker安装普通Postgres
## 拉取镜像
```shell
$ docker pull postgres
```
## 安装并运行pg
```shell
docker run --name mypostgres -d -p 5432:5432 -e POSTGRES_PASSWORD=root -e "TZ=PRC" postgres
```
- --name是指定容器名称
- -d是指定后台运行
- -p是端口映射，左边为主机端口，右边为容器端口
- -e是配置容器的环境变量，若有多个则需要多个-e
## 进入pg
```shell
docker exec -it 容器id psql -U postgres -d postgres         //-U表示账户 -d表示数据库
show time zone;     //查看时区
select now();    //查看当前时间
set time zone 'PRC' ; //设置东八区
CREATE TABLE COMPANY(
   ID SERIAL PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL,
   JOIN_DATE      DATE
);
```

# docker安装自带向量插件的Postgres
## 拉取镜像
```shell
$ docker pull ankane/pgvector
```
## 安装并运行pg
```shell
docker run --name postgres12 -e POSTGRES_PASSWORD=root -p 5433:5432 -d ankane/pgvector
```
## 创建向量拓展
### 进入容器进入pg
```shell
docker exec -it 容器id psql -U postgres -d postgres 
```
### 创建向量
```shell
CREATE EXTENSION IF NOT EXISTS vector;
```
#  PostgresSql常用命令
#### 连接数据库, 默认的用户和数据库是postgres
```shell
psql -U user -d dbname
```

#### 切换数据库,相当于mysql的use dbname
```shell
\c dbname
```
#### 列举数据库，相当于mysql的show databases
```shell
\l
```
#### 列举表，相当于mysql的show tables
```shell
\dt
```
#### 查看表结构，相当于desc tblname,show columns from tbname
```shell
\d tblname
```
#### 查看索引 
```shell
\di 
```
#### 创建（插入）数据库/表/数据/字段
创建数据库
```shell
create database [数据库名]; 
```
创建表
```
create table ([字段名1] [类型1] ;,[字段名2] [类型2],......<,primary key (字段名m,字段名n,...)>;); 
```
在表中插入数据
```
insert into 表名 ([字段名m],[字段名n],......) values ([列m的值],[列n的值],......); 
```
在已有的表里添加字段
```
alter table [表名] add column [字段名] [类型]; 
```
#### 删除数据库/表/字段/数据/用户
删除数据库
```
drop database [数据库名];  
```
删除表
```
drop table [表名]; 
```
删除表中的字段
```
alter table [表名] drop column [字段名]; 
```
删除表中某行数据
```
delete from [表名] where [该行特征]; 
```
删除用户和组
```
DROP ROLE role_name;
DROP ROLE IF EXISTS role_name;
#删除组role只会删除组的role本身，组的成员并不会被删除
```
删空整个表 
```
delete from [表名];
```
#### 重命名表/字段
重命名一个表
```
alter table [表名A] rename to [表名B]; 
```
重命名一个字段
```
alter table [表名] rename column [字段名A] to [字段名B];
``` 
#### 给一个字段设置缺省值
```
alter table [表名] alter column [字段名] set default [新的默认值];
```
#### 去除缺省值 
```
alter table [表名] alter column [字段名] drop default;
``` 
#### 修改表中的某行某列的数据
```
update [表名] set [目标字段名]=[目标值] where [该行特征]; 
```
#### 其他
- 显示 PostgreSQL 的使用和发行条款
```
\copyright     
```
- 显示或设定用户端字元编码
```
\encoding [字元编码名称]
```
- SQL 命令语法上的说明，用 * 显示全部命令
```
\h [名称]  
```
- 提示用户设定内部变数
```
\prompt [文本] 名称
```
- securely change the password for a user
```
\password [USERNAME]
```
- 退出 psql
```
\q
```
- 备份可以使用pg_dump和pg_dumpall来完成。
```
#比如备份sales数据库 
pg_dump drupal>/opt/Postgresql/backup/1.bak 
```
- 附带一些指定给postgresql用户的常用命令
默认用户
postgres安装完成后，会自动在操作系统和postgres数据库中分别创建一个名为postgres的用户以及一个同样名为postgres的数据库。
- 登录
1. 指定参数登录
```
psql -U username -d database_name -h host -W
```
参数含义: -U指定用户 -d要连接的数据库 -h要连接的主机 -W提示输入密码。

2. 切换到postgres同名用户后登录
```
su username
psql
```
当不指定参数时psql使用操作系统当前用户的用户名作为postgres的登录用户名和要连接的数据库名。所以在PostgreSQL安装完成后可以通过以上方式登录。

- 创建用户
1. 在系统命令行中使用createuser命令中创建
```
createuser username 
```
2. 在PostgresSQL命令行中使用CREATE ROLE指令创建
```
CREATE ROLE rolename;
```
3. 在PostgresSQL命令行中使用CREATE USER指令创建
```
CREATE USER username;
```
CREATE USER和CREATE ROLE的区别在于，CREATE USER指令创建的用户默认是有登录权限的，而CREATE ROLE没有。

- 指令显示用户和用户的用户属性 
```
\du 
```
- 创建用户时设定用户属性
基本语法格式
```
CREATE ROLE role_name WITH optional_permissions;
```
示例:在创建用户时设定登录权限。
```
CREATE ROLE username WITH LOGIN;
```
- 查看全部可设置的管理权限
```
\h CREATE ROLE
```
- 修改用户属性&修改权限的命令格式
```
ALTER ROLE username WITH attribute_options;
```
例如:可通过以下方式禁止用户登录
```
ALTER ROLE username WITH NOLOGIN;
```
- 设置访问权限
语法格式如下:
```
GRANT permission_type ON table_name TO role_name;
```
实例:
```
GRANT UPDATE ON demo TO demo_role;  #赋予demo_role demo表的update权限
GRANT SELECT ON ALL TABLES IN SCHEMA PUBLIC to demo_role;   #赋予demo_role所有表的SELECT权限
```
特殊符号
- ALL代表所访问权限
- PUBLIC代表所有用户
```
GRANT ALL ON demo TO demo_role;   #赋给用户所有权限
GRANT SELECT ON demo TO PUBLIC;   #将SELECT权限赋给所有用户
```
- 显示用户访问权限。
```
# \z或\dp指令
```
- 显示所有可设置的访问权限
```
\h GRANT
```
-  撤销用户访问权限
语法格式如下:
```
REVOKE permission_type ON table_name FROM user_name;
```
其中permission_type和table_name含义与GRANT指令中相同。
- 用户组
- 在postgres中用户实际上是role，同时组也是role。 包含其他role的role就是组。
- 创建组示例
```
CREATE ROLE temporary_users;
GRANT temporary_users TO demo_role;
GRANT temporary_users TO test_user;
```
- 切换ROLE
```
SET ROLE role_name;   #切换到role_name用户
RESET ROLE;   #切换回最初的role
```
- INHERIT权限：该属性使组成员拥有组的所有权限
```
ALTER ROLE test_user INHERIT;
```




Postgres从部署到命令行

# 拉取镜像
```shell
$ docker pull consul # 默认拉取latest
$ docker pull consul:1.6.1 # 拉取指定版本
```
# 安装并运行
```shell
docker run -d -p 8500:8500 --restart=always --name=consul consul:latest agent -server -bootstrap -ui -node=1 -client='0.0.0.0'
```
- agent: 表示启动 Agent 进程。
- server：表示启动 Consul Server 模式
- client：表示启动 Consul Cilent 模式。
- bootstrap：表示这个节点是 Server-Leader ，每个数据中心只能运行一台服务器。技术角度上讲 Leader 是通过 Raft 算法选举的，但是集群第一次启动时需要一个引导 Leader，在引导群集后，建议不要使用此标志。
- ui：表示启动 Web UI 管理器，默认开放端口 8500，所以上面使用 Docker 命令把 8500 端口对外开放。
- node：节点的名称，集群中必须是唯一的，默认是该节点的主机名。
- client：consul服务侦听地址，这个地址提供HTTP、DNS、RPC等服务，默认是127.0.0.1所以不对外提供服务，如果你要对外提供服务改成0.0.0.0
- join：表示加入到某一个集群中去。 如：-json=192.168.0.11。
# 关闭防火墙或开启8500端口
## 查看防火墙是否开启
```shell
$ systemctl status firewalld
```
## 开启或关闭防火墙
```shell
$ systemctl start firewalld
$ systemctl stop firewalld
```
## 查看所有开启的端口
```shell
$ firewall-cmd --list-ports
```

## 开启8500端口
```shell
$ firewall-cmd --zone=public --add-port=8500/tcp --permanent 
```
- zone #作用域
- add-port=80/tcp #添加端口，格式为：端口/通讯协议
- permanent #永久生效，没有此参数重启后失效
## 重启防火墙，使其生效
```shell
$ firewall-cmd --reload
```
## 如果是阿里云服务器，需要设置安全组
### 来到实例管理页面，点击更多，点击网络和安全组，点击安全组配置。点击添加安全组规则，端口范围改为8500。
# 测试访问
访问：hostname:8500/
1. services：放置服务
2. nodes：放置consul节点
3. key/value：放置一些配置信息
4. dc1：配置数据中心

Docker部署Consul

- for循环性能总体上比for range好
- 指针传参总体上比值传参开销要小，但是要面临着一改全改的风险，指针一旦改动，所有链路都会变化
- go redis中查询列表（lrange）和集合(smember)时，如果键不存在不会报redis nil错误，其他类型如果键不存在会报redis nil错误
- go redis sadd 切片时，类型只能是any，如果是[]int64，不能批量添加，只能一次一次加。或者将数据marshal成二进制再存redis
- go对于slice进行append追加时，如果不定义长度和容量，slcie的容量会加倍增加。默认情况下切片cap值小于1024的时候是成倍数增长的。比如有1变为2在变为4……但是超过1024后倍数会小于2倍。
- go的切片不能直接赋值，并不会改变原来的值，应该用copy复制slice

go需要注意的点

### 默认按照display_order字段倒序，相同排序按id倒序
```sql
#可以使用如下SQL语句实现：

SELECT *
FROM table_name
ORER BY display_order DESC, id DESC;


// 其中，`table_name`是要查询的表名，
// `display_order`是按照该字段倒序排序，
// `id`是按照该字段倒序排序。
// 如果`display_order`相同，则按照`id`倒序排序。

```

### 删除去重数据SQL
```sql
delete from xs_lxdj where (xh,xqdm,type,time) in (
   select * from (
   select n.xh,n.xqdm,n.type,n.time from xs_lxdj n group by n.xh,n.xqdm,n.type,n.time having count(n.id)>1
    ) a
            )
and id not in (
select * from (
select min(m.id) from xs_lxdj m group by m.xh,m.xqdm,m.type,m.time having count(m.id)>1
                                                                   ) b
)
```

SQL相关笔记

Goroutine 是 Golang 中非常有用的功能，但是在使用中我们经常碰到下面的场景：如果希望等待当前的 goroutine 执行完成，然后再接着往下执行，该怎么办？本文尝试介绍这类问题的解决方法。
# 没有等待的情况
让我们运行下面的代码，并关注输出的结果：
```
package main

import (
    "time"
    "fmt"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("hello world")
    fmt.Println("over!")
}
```
输出的结果为：over!
因为 goroutine 以非阻塞的方式执行，它们会随着程序(主线程)的结束而消亡，所以程序输出字符串 "over!" 就退出了，这可不是我们想要的结果。

# 使用 Sleep 函数等待
要解决上面的问题，最简单、直接的方式就是通过 Sleep 函数死等 goroutine 执行完成：
```
func main() {
    go say("hello world")
    time.Sleep(1000 * time.Millisecond)
    fmt.Println("over!")
}
```
运行修改后的程序，结果如下：

hello world

hello world

hello world

over!

结果符合预期，但是太 low 了，我们不知道实际执行中应该等待多长时间，所以不能接受这个方案！

# 使用 channel
通过 channel 也可以达到等待 goroutine 结束的目的，运行下面的代码：
```
func main() {
    done := make(chan bool)
    go func() {
        for i := 0; i < 3; i++ {
            time.Sleep(100 * time.Millisecond)
            fmt.Println("hello world")
        }
        done <- true
    }()

    <-done
    fmt.Println("over!")
}
```
输出的结果也是：

hello world

hello world

hello world

over!

这种方法的特点是执行多少次 done <- true 就得执行多少次 <-done，所以也不是优雅的解决方式。

# 标准答案
Golang 官方在 sync 包中提供了 WaitGroup 类型来解决这个问题。其文档描述如下：

#### A WaitGroup waits for a collection of goroutines to finish. The main goroutine calls Add to set the number of goroutines to wait for. Then each of the goroutines runs and calls Done when finished. At the same time, Wait can be used to block until all goroutines have finished.
#### 大意为：WaitGroup 用来等待单个或多个 goroutines 执行结束。在主逻辑中使用 WaitGroup 的 Add 方法设置需要等待的 goroutines 的数量。在每个 goroutine 执行的函数中，需要调用 WaitGroup 的 Done 方法。最后在主逻辑中调用 WaitGroup 的 Wait 方法进行阻塞等待，直到所有 goroutine 执行完成。

使用方法可以总结为下面几点：

- 创建一个 WaitGroup 实例，比如名称为：wg
- 调用 wg.Add(n)，其中 n 是等待的 goroutine 的数量
- 在每个 goroutine 运行的函数中执行 defer wg.Done()
- 调用 wg.Wait() 阻塞主逻辑

运行下面的代码：
```
package main

import (
    "time"
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    say2("hello", &wg)
    say2("world", &wg)
    fmt.Println("over!")
}

func say2(s string, waitGroup *sync.WaitGroup) {
    defer waitGroup.Done()

    for i := 0; i < 3; i++ {
        fmt.Println(s)
    }
}
```
输出的结果如下：

hello

hello

hello

world

world

world

over!


下面是一个稍稍真实一点的例子，检查请求网站的返回状态。如果要在收到所有的结果后进一步处理这些返回状态，就需要等待所有的请求结果返回：
```
package main

import (
    "fmt"
    "sync"
    "net/http"
)

func main() {
    var urls = []string{
        "https://www.baidu.com/",
        "https://www.cnblogs.com/",
    }

    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1)
        go fetch(url, &wg)
    }

    wg.Wait()
}

func fetch(url string, wg *sync.WaitGroup) (string, error) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println(err)
        return "", err
    }

    fmt.Println(resp.Status)
    return resp.Status, nil
}
```
运行上面的代码，输出的结果如下：

200 OK

200 OK
# context.Context
上面的场景是等待多个小任务都执行完毕之后退出。下面考虑这种场景：有一个持续性的任务，一般是常驻的不退出，比如说监控任务。但有时可能因为特殊需求，需要根据条件判断后让其退出。因为该监控任务和其他任务没有数据连接（channel之类的），但靠sync.WaitGroup是不能使其退出的。 很自然的，我们能想到应该通过一个媒介，来通知监控任务退出。全局变量可以充当这个媒介，但鉴于安全性很差，这里不予考虑（代码中一般来说不允许出现全局变量）。

## chan通知
```
func main() {
	stop := make(chan bool)

	go func() {
		for {
			select {
			case <-stop:
				fmt.Println("监控退出，停止了...")
				return
			default:
				fmt.Println("goroutine监控中...")
				time.Sleep(2 * time.Second)
			}
		}
	}()

	time.Sleep(10 * time.Second)
	fmt.Println("可以了，通知监控停止")
	stop <- true
	//为了检测监控过是否停止，如果没有监控输出，就表示停止了
	time.Sleep(5 * time.Second)
}
```
输出结果：
```
goroutine监控中...
goroutine监控中...
goroutine监控中...
goroutine监控中...
goroutine监控中...
可以了，通知监控停止
监控退出，停止了...
```
这种方式还是比较优雅的，但还是有很大的局限性。如果我们需要控制很多的goruntine结束怎么办，难道我们要搞出很多个chan？又或者子goruntine中又衍生出更多的子goruntine怎么办?如果一层层的无穷尽的 goroutine 呢？这就非常复杂了，即使我们定义很多 chan 也很难解决这个问题，因为 goroutine 的关系链就导致了这种场景非常复杂。

## 初识Context
上面说的这种场景是存在的，比如一个网络请求 Request，每个 Request 都需要开启一个 goroutine 做一些事情，这些 goroutine 又可能会开启其它的 goroutine。所以我们需要一种可以跟踪 goroutine 的方案，才可以达到控制它们的目的，这就是Go语言为我们提供的 Context，称之为上下文非常贴切，它就是 goroutine 的上下文。

### 利用context.Context重写上面示例：
```
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go func(ctx context.Context) {
		for {
			select {
			case <-ctx.Done():
				fmt.Println("监控退出，停止了...")
				return
			default:
				fmt.Println("goroutine监控中...")
				time.Sleep(2 * time.Second)
			}
		}
	}(ctx)

	time.Sleep(10 * time.Second)
	fmt.Println("可以了，通知监控停止")

	cancel()
	
	//为了检测监控过是否停止，如果没有监控输出，就表示停止了
	time.Sleep(5 * time.Second)
}
```

### Context 控制多个 goroutine
```
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go watch(ctx, "【监控1】")
	go watch(ctx, "【监控2】")
	go watch(ctx, "【监控3】")

	time.Sleep(10 * time.Second)
	fmt.Println("可以了，通知监控停止")
	cancel()
	//为了检测监控过是否停止，如果没有监控输出，就表示停止了
	time.Sleep(5 * time.Second)
}

func watch(ctx context.Context, name string) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println(name, "监控退出，停止了...")
			return
		default:
			fmt.Println(name, "goroutine监控中...")
			time.Sleep(2 * time.Second)
		}
	}
}
```



Goroutine

# nginx反向代理配置端口转发
## 下面是nginx.conf nginx配置文件
```
worker_processes auto;

 
events {
    worker_connections  1024;
}
 
 
http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
 
    sendfile        on;
    #tcp_nopush     on;
 
    #keepalive_timeout  0;
    keepalive_timeout  65;
 
    #gzip  on;
 
    client_max_body_size   20m;
    server {
        listen       80;
        server_name  xxx.cn;
   

 
     location / {
        root   /etc/nginx/reservation_fe/dist;
        index  index.html index.htm;
        }
        
        #error_page  404              /404.html;
 
        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
    
    server {
         listen 443 ssl;
         server_name xxx.cn;   #证书绑定的网站域名
         ssl_certificate  /etc/nginx/reservation_fe/ncu-serverall-20221027.crt;  #证书公钥
         ssl_certificate_key /etc/nginx/reservation_fe/ncu-private-20221027.key;    #证书私钥
         ssl_session_timeout 5m;
         ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!3DES:!aNULL:!MD5:!ADH:!RC4;
         ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
         ssl_prefer_server_ciphers on;
         

        location / {
          root   /etc/nginx/reservation_fe/dist/;
          index  index.html index.htm;
      }

        location ^~ /api/ {
         proxy_pass  http://xxx.xxx.x.xxx:8089/;  #后端
            }

    }

}


```

nginx

我们在windows和mac可能使用过clash for windows或clash，那么我们的服务器也可以使用相应的clash-linux，从而达到代理效果，这样可以不去买国外服务器了

无论是更新下载缓慢，还是从 Github clone 项目时失败，抑或是配置开发环境时久久不能成功，在 Linux 服务器上安装使用代理软件都是常见的需求。

在 Windows 中用户常使用 Clash for Windows，在 MacOS 上使用 ClashX，在 OpenWRT 上常见的是 OpenClash，借助其完善的规则分流机制，用户设置完成后无需花费太多心思去维护，可以节省大量时间和精力。

以上平台使用 UI 界面，但其实 Linux 终端也可以使用 Clash。为读者提供一条龙服务，本文将分几部分介绍 Clash for Linux 的安装、配置、自启动以及设置系统代理。


# 一、安装 Clash
#### 首先访问 Github 发布地址：[Releases · Dreamacro/clash (github.com)](https://github.com/Dreamacro/clash/releases)，下载对应 Linux 版本
#### 大多数时候下载 clash-linux-amd64-vxxxx.gz 即可。
```
# 创建一个用于存放 Clash 文件的目录

mkdir ~/Clash

# 下载文件到此处

wget https://github.com/Dreamacro/clash/releases/download/v1.10.0/clash-linux-amd64-v1.10.0.gz
```

#### 如果服务器上直接下载很慢，可以在本地下载好文件，再通过 WinSCP 之类的工具传到服务器上。

#### 这里我打包了所需要的文件(clash-linux-amd64-v1.10.0.gz和Country.mmdb)在百度网盘中，可以从这里去下载  [clash-linux](https://pan.baidu.com/s/1kqvAzGlOz4bwAIggqQV2HQ?pwd=nujm)

```
#解压文件到这个目录

gunzip clash-linux-amd64-v1.10.0.gz

#为了方便，将解压出来的文件改名为 clash

mv clash-linux-amd64-v1.10.0 clash

#添加执行权限

chmod +x clash

#运行以初始化 Clash

./clash
```

# 二、配置 Clash
#### 首次运行之后会在用户配置目录生成配置文件，产生的目录为~/.config/clash ，里面有 config.yaml 和 Country.mmdb 两个文件。
#### 不过也有可能运行过程中会报错，因为 Country.mmdb 下载不下来
#### 值得庆幸的是，已有网友共享 Country.mmdb 文件，w我已上传百度网盘备用，可访问文末链接获取。

#### 将 Country.mmdb 放入配置文件所在目录，接下来就要修改 config.yaml 文件。有些机场本身提供了 Clash 专用配置文件，可直接使用；有些则没有提供，需要自行转换后获取。将配置文件放到此目录，删除自动生成的 config.yaml，再把自己的配置文件重命名为 config.yaml 。

#### 接下来复制该目录下的 Country.mmdb 和 config.yaml 两个文件到之前创建好的 ~/.config/clash 目录下，再次运行 Clash 程序
#### 注意clash的二进制文件和配置文件不在同一个目录，那两个配置文件在~/.config/clash下，而二进制文件在你自己上传解压缩的路径下，配置好后，直接运行二进制clash即可。
#### 正常情况下就会看到它已经成功启动了。但是，还需要设置系统代理才能让流量通过 Clash。大多情况下 config.yaml 中已经写好了规则，包括 HTTP/HTTPS 代理的端口，如果不确定的话可以打开 config.yaml 查看。

#### 执行以下命令即可临时设置系统代理：
```
export http_proxy=http://127.0.0.1:7890

export https_proxy=http://127.0.0.1:7890
```
#### 当然你也可以修改系统全局变量，在/etc/profile文件中

# 三、配置clash可视化面板界面（可选步骤）
```
git clone -b gh-pages https://github.com/Dreamacro/clash-dashboard ui
```
这样就克隆 clash-dashboard 仓库的 gh-pages 分支到了 ui 文件夹。该仓库的gh-pages分支提供了clash可视化面板的前端文件。（也可以本地下载然后上传至服务器）
####  ✨上传的目录文件路径和配置文件的路径在同一级

然后配置前端路由以及访问面板的密码。即配置一下我们的 config.yaml 文件，如下：
```
port: 7890
socks-port: 7891
external-controller: :9090
external-ui: ui
secret: '123456'
```
- 这里的 port 是 http/https 代理端口
- socks-port 是 socks 流量代理端口
- external-controller 是外部控制端口，用于面板控制(前端页面的端口)
- external-ui 是本地控制页面的源码，确保localhost:external-controller/ui 页面可以控制代理。（前端面板的路由）
#### 运行clash，访问 host:port/ui 即可访问calsh的控制面板


# 四、Clash 自启动及后台运行
#### 手动运行 Clash 会发现它是在“前台”运行的，当我们退出命令，程序也就退出了。另外如果开机后总需要手动运行的话也让人觉得繁琐，最好的办法就是将 Clash 注册为服务，并设置为开机自启动。

#### 将以下脚本保存为 /etc/systemd/system/clash.service ：
```
[Unit]
Description=Clash service
After=network.target

[Service]
Type=simple
User=louis（你的用户名）
ExecStart=/home/louis/Clash/clash（Clash 程序路径）
Restart=on-failure
RestartPreventExitStatus=23

[Install]
WantedBy=multi-user.target
```

#### 使用以下命令启动服务，设置开机启动，以及检查服务状态（使用方法参考：[用 systemctl 管理服务：查看状态、启动/停止服务、开启/取消开机自启动](https://www.idcbuy.net/it/linux/981.html)）：

```
# 重载服务
sudo systemctl daemon-reload
# 开机启动
sudo systemctl enable clash
# 启动服务
sudo systemctl start clash
# 查看服务状态
sudo systemctl status clash
```

# 五、代理设置
#### Clash 已经开机自启动了，如果每次都要手动设置系统代理的话也很费时，因此建议将命令写入 Bash 配置文件中。
(写入环境变量 /etc/profile  文件也可以的)

#### 运行 vim ~/.bashrc ，在文件末尾添加：

```
export http_proxy=127.0.0.1:7890
export https_proxy=127.0.0.1:7890
```

#### 保存后运行 source ~/.bashrc 使配置生效。
之后可以重启服务器，然后运行 sudo systemctl status clash 检查 Clash 的服务状态，再访问需要代理的网站验证是否可用。




在 Linux 服务器上安装 Clash，以及开机自动启动

### 全局变量设置时区
```
func initInMain() {

	var cstZone = time.FixedZone("CST", 8*3600) // 东八

	time.Local = cstZone

}

```

Go-time

### First Last Take查询数据查不到时，gorm会报record not found错误
### 传入接收结果集的变量只能为Struct类型或Slice类型，当传入变量为Struc类型时，如果检索出来的数据为0条，会抛出ErrRecordNotFound错误，当传入变量为Slice类型时，任何条件下均不会抛出ErrRecordNotFound错误

gorm

# CSS显示指定行数文本、限制文本最大行数
## CSS显示指定行数文本
### 单行文本溢出用省略号显示：
```

overflow:hidden;

text-overflow:ellipsis;

white-space:nowrap;

```
### 多行文本溢出用省略号显示：

```

display: -webkit-box;

-webkit-box-orient: vertical;

-webkit-line-clamp: 3;

overflow: hidden;

```
##### 适用范围：
###### 因使用了WebKit的CSS扩展属性，该方法适用于WebKit浏览器及移动端；
##### 注：
###### -webkit-line-clamp用来限制在一个块元素显示的文本的行数。 为了实现该效果，它需要组合其他的WebKit属性。
###### 常见结合属性：
- display: -webkit-box; 必须结合的属性 ，将对象作为弹性伸缩盒子模型显示 。
- -webkit-box-orient 必须结合的属性 ，设置或检索伸缩盒对象的子元素的排列方式 。

## 限制文本最大行数
### 要判断行数的文本的样式：
```

text-overflow: ellipsis;

display: -webkit-box;

-webkit-box-orient: vertical; 

-webkit-line-clamp: 5; 

line-height: 20px;

max-height: 100px;

```
### 可获取到元素height和line-height的值，计算文本的行数

css相关笔记

# redis常用命令

## redis终端连接
-  redis-cli                  ping         pong
## 选择数据库 
- 选择redis的2号数据库  &emsp; (0-16) -->  select 2
## 对string的操作
### set k v &emsp;  --> 设置 key value
### get k   返回 v
### 多个设置
- mset name xxpyy age 18  

- mset k v k v
### 多个查询 &emsp; --> mget name age class
### 设置过期时间
- setex  k ex v  &emsp;  (ex-->expire到期失效)

- setex class 10 1  &emsp; (十秒钟内 class的值是1，过了10秒钟class的值为nil) 
### 追加
- append k NewValue 

- append name 123   &emsp;   ( get name-->xxpyy123 )
### 中文编码  先exit 然后 redis-cli --raw
## 对键的操作
### keys *     查询所有的键
### keys b*  查询所有b开头的键
### exists name  
- exit key  返回0即为不存在  返回1即为存在

- exists b1  

- exists b*
### 删除key 
- del name    
 
- del b1 b2 b3  &emsp;  (返回数即为删除个数)
### 设置过期时间
- expire key time

- expire age 10   &emsp; 10秒后key-value过期
### 查看key还有多久过期  --> ttl key
### 返回键的类型  --> type key 
## 对hash的操作
### 单个field设置
- hset key field value 

-  hset me name xxpyy 

- hset me age 18
### 多个field设置
- hmset key field value field value..

- hmset me name xxpyy age 18 gender male
### 查询
- hget key field  &emsp; (查询键下面的属性的值)

- hgetall key   &emsp;  (查询此key下的所有属性和值)

- hmget key filed filed ...

- hmget me name age gender

- hkeys key &emsp; (查询key下面所有的属性) &emsp;hkeys me  -->name age gender

- hvals key &emsp; (查询key下面所有的属性对应的值) &emsp; hvals me   --> xxpyy 18 male
### 删除
- hdel me gender &emsp; 删除gender属性
## 对list的操作
- lpush key value1 value2 ... &emsp; (从左插入值) &emsp; lpush c c1 c2 c3 c4

- lrange key x y &emsp;  (查询key对应的value 从x到y)  &emsp; lrange c 0 3  &emsp; --> c4 c3 c2 c1

- rpush key value1 value2.. &emsp;(从右插入值) &emsp; rpush d d1 d2 d3 d4  &emsp;lrange d 0 3 -->d1 d2 d3 d4

- lrem key x value &emsp; ( 删除list中的x个value ) &emsp; lrem c 3 a  &emsp;  --->. 删除c中的正顺序3个a

- (负号表示倒数)

- lrem key -1 value&emsp; lrem c -1 a -->删除一个c中倒数的一个a   &emsp; x表示count 和

- lrem key 0 value &emsp;  删除list中所有的指定的value &emsp;  lrem c 0 a -->删除 c中所有的a

- linsert key after oldvalue new value &emsp; 在指定的value后面插入一个value &emsp; linsert c after c1 mdb
## 对set的操作  
- [无序] 

- sadd key value1 value2 value3 ... &emsp; 虽然value有重复但真正add是没有重复的[无序] &emsp; sadd y a1 a2 a3 a4 a2 a1

- smembers key &emsp; 查询set所有value &emsp; smembers  y  &emsp; --> a3 a4 a1 a2

- srem key value  &emsp; 删除key中的一个value &emsp; srem y a1  &emsp;  -->smemebers y  &emsp; --> a3 a4 a2

- sismember key member  &emsp; 查询member元素是否是集合key的成员

## 对zset的操作 
-  [有序]  权重(分数)
- zadd key score1 value1 score2 value2.. &emsp; zadd yy 2 a1 4 a2 1 a3

- zrange key x y  &emsp; zrange yy 0 -1 &emsp;  -->查询所有的value倒序（从低到高） x y是指定范围 0 1  &emsp; -->表示第一个到第二个

- zrevrange key xy  &emsp; zrevrange yy 0-1  &emsp; -->按分数从高到低查询所有的value  &emsp;  0 -1  &emsp; -->表示从第一个到最后一个

- zrangebyscore key x y &emsp; zrangebyscores yy 2  4&emsp; 查分数是2到4的所有value值

- zscore key value1  &emsp; 查询value对应的分数 &emsp; --> zscore yy a2 &emsp; -->4
- zrem key value1  &emsp; 删除 &emsp; ->  zrem yy a1
- zremrangebyscore   &emsp; 根据权重（分数）删除value &emsp; --> zremrangebyscore yy 0 4
- zinterstore newKey numKeys key1 key2 ...   &emsp; zadd key1 1 a  &emsp;  zadd key2 3 a &emsp;  zinterstore key 2 key1 key2

- Zinterstore 命令计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination(新的zset 新的key) &emsp; -->a 4
- zincrby key incrementScore value  &emsp; zincrby yy 6 a2  &emsp; --> yy 从4变成 6 （加减score的操作）
- zcount key min max  &emsp;  zcount a2 0 -1  --> (查询key下所有member的数量)


redis相关笔记

用server部署nextjs比较好

#### 前台后台的分页
#### 前台开发自言，他说，你我板块
#### 接入qq授权登录
#### 前台添加音乐播放器
#### 前台添加点赞功能
#### 你我板块有讨论区功能，以qq头像的形式聊天，后台展示前台所有数据包括讨论区，留言，文章，点赞。有审核功能
#### 有人留言，讨论则用qq邮箱通知我，并通过审核。