Linux

词汇了解

内存泄露

现象

内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存。应用程序分配某段内存后，由于设计错误，导致在释放该段内存之前就失去了对该段内存的控制，从而造成了内存的浪费。内存泄漏通常情况下只能由获得程序源代码的程序员才能分析出来。

后果

内存泄漏会因为减少可用内存的数量从而降低计算机的性能。过多的可用内存被分配掉导致全部或部分设备停止正常工作，或者应用程序崩溃。

一个短暂运行的应用程序中的内存泄漏不会导致严重后果。在应用程序结束后会释放内存

服务器

定义（服务器软、硬件）

服务器硬件

具有较高计算能力，能够提供给多个用户使用的计算机。

服务器和PC机的明显区别

PC机一个时刻内通常只为一个用户提供服务；

服务器基本24小时无休，通过终端网络给用户使用；技术更稳定，且通常多部连接在一起运作。

服务器分类

工作组级服务器、部门级服务器和企业级服务器。

服务器平台操作系统

Linux发行版

红帽企业Linux、SUSE、AIX、HP-UX、IRIX、FreeBSD、Solaris、Mac OS X Server、OpenBSD、NetBSD、和SCO OpenServer。

Microsoft Windows服务器版本

Windows NT Server、Windows 2000 Server、Windows Server 2003、Windows Server 2008、Windows Server 2012。

世纪互联

世纪互联数据中心有限公司是中国的电信中立第三方互联网基础设施服务提供商，向客户提供业界领先的服务器及网络设备托管服务、管理式网络服务、内容分发网络服务及云计算服务。

树莓派

只有信用卡大小的微型计算机，基于Linux系统。特点外表小内心大，拥有计算机的基本功能，为学习计算机编程教育而设计。

CentOS（免费且商用）

是Linux的发行版本之一，是一个安全、低维护、稳定、高预测性、高重复性的 Linux 环境。

CentOS 2014加入红帽，但是不收费

Linux命令

Linux常用快捷命令

清屏

方式一

clear

方式二

ctrl+l

查看PATH变量的值

echo $PATH 查看当前环境变量的值

which 软件名查看当前软件的环境变量

快速登录退出

ctrl+d 快速退出

ctrl+shift+r 快速登录

查看当前占用端口及程序

netstat -tunple

修改主机名

hostnamectl set-hostname 主机名

查看服务器IP地址

方式一：

ip addr

方式二：

ifconfig

常用端口

ftp:23

sftp:22

dns:53

http:80

https:443

ssh:22

连接服务器

ssh 服务器IP，默认22端口，根据提示输入root，密码。

关闭防火墙（根据情况使用）

#清空防火墙规则

iptables -F

#关闭防火墙服务

systemctl stop firewalld

#临时关闭防火墙服务

systemctl stop firewalld

#永久关闭开机自启

systemctl disable firewalld

不同Linux主机中传输文件和目录（scp）

scp是linux系统下基于ssh登陆进行安全的远程文件拷贝命令。

scp 本地文件远程用户名@远程ip:远程文件夹/

scp 本地文件远程用户名@远程ip:远程文件夹/远程文件名

-r 递归复制

-v 详细方式输出

-q 不显示传输进度条

-C 允许压缩

yum工具自动安装和源代码编译安装

解决软件依赖问题，需要yum安装以下rpm包

yum install gcc patch libffi-devel python-devel zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel openssl openssl-devel -y

yum安装

yum install 软件名

源代码编译安装（可以自定义安装）

获取软件源代码压缩包

wget 软件下载url

解压源代码压缩包

tar -xvf 软件源码包

./configure --prefix（指定路径，释放makefile编译文件）

源码的安装一般由3个步骤组成：配置(configure)、编译(make)、安装(make install)。

Configure是一个可执行脚本，它有很多选项，在待安装的源码路径下使用命令./configure –help输出详细的选项列表。

其中--prefix选项是配置安装的路径，如果不配置该选项，安装后可执行文件默认放在/usr /local/bin，库文件默认放在/usr/local/lib，配置文件默认放在/usr/local/etc，其它的资源文件放在/usr /local/share，比较凌乱。

如果配置--prefix，可以把所有资源文件放在指定的路径中，不会杂乱。用了—prefix选项的另一个好处是卸载软件或移植软件。当某个安装的软件不再需要时，只须简单的删除该安装目录，就可以把软件卸载得干干净净；移植软件只需拷贝整个目录到另外一个机器即可（相同的操作系统）。

当然要卸载程序，也可以在原来的make目录下用一次make uninstall，但前提是make文件指定过uninstall。

./configure --prefix=/安装目录/

编译并安装

使用gcc工具编译并安装

make && make install

rpm安装（不自动解析）

配置环境变量，方便调用软件（PATH）

在路径在 /etc/profile 这个文件中最后的PATH中加入上一步获取到的路径

读取文件，生效PATH

source /etc/profile

文件夹及文件的增删查改

查

查询绝对路径(pwd)

切换目录(cd)

cd ~ #当前用户所在家目录

cd / # 系统根目录

cd # 当前用户的home目录

cd ../../ #返回上上一层目录

查询文件夹及文件(ls)

-a 显示所有内容，包括隐藏内容

-g 以文件前分组目录

-i 显示索引

-p 对目录加上表示符号“/”

-R 递归显示子目录

-lh 列出信息及大小

条件查询、涉及筛选的（find、grep、管道符）

find 目录和文件

find 路径 -命令参数【输出形式】

-name 按照文件名查找文件

-perm 按照文件权限查找文件

-type 查找某一类型的文件

块设备文件

字符设备文件

管道文件

符号链接文件

普通文件

socket文件

管道符（|）

左|右

左边命令的输出会成为管道符右边命令的输入

grep

-i 忽略大小写

-n 输出行号

-v 反向选择

--color=auto 给关键词部分添加颜色

查找内容展示有条件要求的（head、tail）

head 显示文件前几行，默认10

tail 显示文件后几行，默认10

-f

持续刷新

统计目录或文件的大小(du)

du 参数文件或目录

-s 显示总计

-h 以k,m,g单位显示

增

创建文件夹（mkdir）

[root@localhost ~]# mkdir aaa #创建目录

[root@localhost ~]# mkdir {aaa,bbb,ccc} #批量创建目录

[root@localhost ~]# mkdir -m a=rw bbb #创建指定属性的目录

[root@localhost ~]# mkdir -p 111/abc #创建目录，强制创建

创建文件（touch）

-c 不创建任何文件

-t 使用格式时间替代当前时间

示例：

[root@linux ~]# touch 1.txt #创建1.txt文件

[root@linux ~]# touch -c -t 05061803 1.txt #将档案时间改为,5月6日18点3分

改

移动文件/文件夹命令

用法：mv 旧文件名新文件

或：mv 源文件目录

或：mv 目录源文件

将源文件重命名为目标文件，或将源文件移动至指定目录。

示例：

[root@localhost ~]$ mv -t ./database 1.sql #将1.sql移动到database目录下

文件/文件夹改名命令

[root@localhost ~]$ mv aaa bbb #将目录或者文件重命名,如果存在bbb目录，则是将aaa移到bbb目录下

删(rm)

-f 强制删除，忽略不存在的文件，不提示确认

-i 删除前需要确认

-d 删除空目录

-r 递归删除目录及内容

示例：

rm -rf 文件/目录

文件的读写操作

读文件（cat/vim）

cat 文件名

-A 一次性显示所有内容，且每行结束显示$

-n 显示行号

vim 文件名

-b 二进制模式

VIM编辑器的使用

查阅（vim 文件名后）

移动光标

w(e)

移动光标到下一个单词的首（尾）

移动到上一个单词的首部

0(非小数字键盘的0)，^相同作用

移动到本行最开头

移动光标到本行结尾

H、M、L

移动光标到屏幕首行、屏幕中部、屏幕尾行

gg、G

移动光标到文档首行、文档尾行

ctrl+f、ctrl+b

查找

/单词、?单词

在整篇文档中查找单词，向下、向上查找

查找光标所在单词，n向下，N向上

找到括号的另一半

:行号

快速跳转第几行

复制、删除、粘贴

yy、3yy

拷贝光标所在行、拷贝光标所在的3行

dd、5dd

删除光标所在行、删除光标所在5行

删除光标至行尾的内容

删除当前行到文档尾的内容

粘贴

删除光标所在的字符

撤销上一步操作

编辑（vim 文件名后）

插入

在当前光标处添加内容

下一行添加内容

：

结束

写入

退出

！

强制退出，无视错误

文件的快捷方式（软链接 ln）

语法：ln -s 目标文件的绝对路径快捷方式绝对路径

安全、权限及创建用户

同步服务器时间到ntp.aliyun.com

ntpdate -u ntp.aliyun.com

创建普通用户

只有root能创建用户，用户拥有UID且唯一

系统管理员UID为0

系统用户UID为1-999 Linux安装的服务程序自己创建的独有的用户

普通用户UID为1000开始由管理员创建

命令：

useradd 用户名

passwd 密码

useradd 用户名

-c

注释描述

-d

指定用户主目录

-g

指定用户组

-G

指定用户所属的附加组

-s

指定用户的登录shell

-u

指定用户号，如果同时有-o选项，则可以重复使用其他用户的标识号

userdel 用户名

-f

强制删除用户

-r

同时删除用户以及家目录

usermod 选项 用户名

选项同useradd的选项

passwd 选项 用户名

-l

锁定口令、禁用账号

-u

口令解锁

-d

使账号无口令

-f

强迫用户下次登录时修改口令

示例：

useradd -s /bin/sh -g group -G adm,root gem

此命令新建了一个用户gem,该用户的登录Shell是/bin/sh（有时要用/bin/bash),它属于group用户组，同时又属于adm和root用户组，其中group用户组是其主组。

查看用户信息（id）

用户分组

给已有用户更改分组

usermod -g 组名用户名

Linux中用户密码的破解

首先查询当前Linux系统的加密方式（MD5可以）

命令：authconfig --test | grep hashing

如果是MD5加密的，则可以按照以下步骤破解：
/etc/shadow中查看用户名和密文，格式如下：

ghostcn_z:$6$TIzxZ1p7.N6t5RVS$TEM1d5OO01t6ElyCJ62hLi9bxaJIRdnZ2auTDKeMjdBGrz.VuiW1k4M3hzd3OwTwyBf1/.QdBT/t7qhrdwBPc1::0:99999:7:::

以上的ghostcn_z为用户名，密码为$后的一串密文。冒号后为权限等，我们取到密文

找MD5解密密文即可。

别名（alias）

为使用比较危险性的命令时得到提示，防止不可挽回的损失

示例（为rm设置别名）：

#让系统显示这是删除命令，谨慎

echo 这是删除命令，谨慎

#设置rm别名

alias rm='echo 这是删除命令，谨慎'

#设置别名永久生效,写入到/etc/profile(针对登录用户的合同，设置环境变量)

vim /etc/profile #编辑文件

G 快速到达最后一行

o 当前行下一行，创建一个新行，进入编辑模式

source /etc/profile #读取文件（合同生效）

---------------

#取消别名

unalias rm

加锁（chattr）

给文件加锁，只能写数据，无法删除文件

chattr +a test.py

chattr -a test.py

权限

权限的目的

保护账户的资料

权限分类的依据身份

user/owner 文件使用者，文件拥有者

group 属组

others 不属于前两者的

用户提权（sudo）

sudo命令用来以其他身份执行命令，预设身份为root，配置方法如下：

在/etc/sudoers中设置可执行sudo命令的用户

vim /etc/sudoers 打开sudoers

在root ALL=(ALL) ALL下写入需要设置的用户，格式类似root

visudo命令（带有验证的提权）

文件与文件夹权限

权限分析

普通文件

属主的读写权限

属组的读写权限

其他用户的读权限

r read可读

w write可写、编辑、删除

x 可执行

权限与数字转化

r 4

w 2

x 1

修改权限

命令

功能

示例

chown

修改属主

chown root 1.txt

chgrp

修改属组

chgrp root 1.txt

chmod 身份参数文件

身份

参数

示例

u、g、o、a

+、-、=

chmod a +w 1.txt chmod 444 1.txt

CentOS最简安装后必做流程

必定首做-配置网络

yum install vim

以root身份登录
修改网卡配置文件

vim /etc/sysconfig/network-scripts/ifcfg-ens33

把“ONBOOT”的值修改为"yes"

reboot

安装yum install net-tools，以提供ifconfig的使用

***如果不能使用vim，就用vi。**

解决大部分程序依赖

yum源配置

yum仓库目录

/etc/yum.repos.d/

yum源配置阿里云的原因

速度快、方便使用第三方

配置阿里云的yum源步骤

阿里巴巴开源镜像站

https://opsx.alibaba.com/mirror

备份原本的yum仓库文件

cd /etc/yum.repos.d

mkdir 备份文件夹名

mv * ./备份文件夹名

下载新的阿里云的yum仓库文件

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

#-O 代表把Centos-7.repo下载到指定目录,且改名

配置额外的第三方仓库（存放互联网主流软件）

wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

virtualenvwrapper自动整合虚拟环境工具的安装

安装

pip3 install -i https://pypi.douban.com/simple virtualenvwrapper

配置文件、使开机自启

个人配置文件：~/.bash_profile

系统配置文件：/etc/profile

vim ~/.bash_profile

写入以下内容：

export WORKON_HOME=目录 #设置virtualenv的统一管理目录

export VIRTUALENVWRAPPER_VIRTUALENV_ARGS='--no-site-packages' #添加virtualenvwrapper的参数，生成干净隔绝的环境

export VIRTUALENVWRAPPER_PYTHON=/opt/python36/bin/python3 #指定python解释器

source /opt/python36/bin/virtualenvwrapper.sh #使工具生效

重新登录、查看是否加载工具

使用命令创建虚拟环境

mkvirtualenv 虚拟环境名

使用命令进入已经创建的虚拟环境

workon 查看已经创建的虚拟环境

workon 虚拟环境名

cdvirtualenv 进入已经激活的虚拟环境目录

cdsitepackages 进入虚拟环境下的第三方模块目录

deativate 退出虚拟环境

nginx的安装和启动

首先解决软件依赖

下载源码包

wget -c http://tengine.taobao.org/download/tengine-2.3.1.tar.gz

解压源码包

tar -zxvf tengine-2.3.1.tar.gz

指定目录编译并安装

./configure --prefix=/opt/tngx/ 指定安装目录

make && make install 编译和安装

nginx的操作

cd tngx/sbin

./nginx #启动

./nginx -s stop #关闭

./nginx -s reload #重新加载

nginx的配置

/opt/tngx/conf目录下的nginx.config

详解：

前面是参数后面是值红字为我添加的备注

#user nobody;

worker_processes 1; 工作进程数，可改，代表同时能进行的个数（工作进程是单线程进程， 如果Nginx正在进行CPU密集型工作（如SSL或gzipping），并且您有2个或更多CPU /核心，则可以将worker_processes设置为等于CPU或核心数。如果您提供大量静态文件并且文件的总大小大于可用内存，那么您可以增加worker_processes以充分利用磁盘带宽。）

#error_log logs/error.log; nginx的运行错误日志

#error_log logs/error.log notice;

#error_log logs/error.log info;

#error_log "pipe:rollback logs/error_log interval=1d baknum=7 maxsize=2G";

#pid logs/nginx.pid; nginx的进程id号，写入到一个文件，方便以后调用nginx的id

nginx的事件驱动连接

events {

worker_connections 1024;

}

nginx的主代码核心配置，web的配置

http {

include mime.types;

default_type application/octet-stream;

nginx的访问日志，功能参数定义

#log_format main '$remote_addr - $remote_user [$time_local] "$request" '

# '$status $body_bytes_sent "$http_referer" '

# '"$http_user_agent" "$http_x_forwarded_for"';

#access_log logs/access.log main; 日志文件，可以监测访问

#access_log "pipe:rollback logs/access_log interval=1d baknum=7 maxsize=2G" main;

sendfile on;

#tcp_nopush on;

#keepalive_timeout 0;

keepalive_timeout 65;

#gzip on; 开启网站压缩功能，在进行css、js、jpg等资源传输时进行压缩，节省带宽，加速访问

nginx的虚拟主机参数，网站的功能性参数定义

server {

listen 80; 监听端口，可自设

server_name localhost;

#charset koi8-r;

#access_log logs/host.access.log main;

#access_log "pipe:rollback logs/host.access_log interval=1d baknum=7 maxsize=2G" main;

location / {

#deny 192.168.16.0/24; 拒绝访问ip段

root html;

index index.html index.htm;

}

以下内容自设：

location / {

#deny 192.168.16.0/24; 拒绝访问ip段

root html;

index index.html index.htm; #默认访问的主页

}

location / {

#deny 192.168.16.0/24; 拒绝访问ip段

root html;

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;

}

# proxy the PHP scripts to Apache listening on 127.0.0.1:80

#location ~ .php$ {

# proxy_pass http://127.0.0.1;

# pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000

#location ~ .php$ {

# root html;

# fastcgi_pass 127.0.0.1:9000;

# fastcgi_index index.php;

# fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;

# include fastcgi_params;

# deny access to .htaccess files, if Apache's document root

# concurs with nginx's one

#location ~ /.ht {

# deny all;

}

# another virtual host using mix of IP-, name-, and port-based configuration

#server {

# listen 8000;

# listen somename:8080;

# server_name somename alias another.alias;

# location / {

# root html;

# index index.html index.htm;

# }

# HTTPS server

#server {

# listen 443 ssl;

# server_name localhost;

# ssl_certificate cert.pem;

# ssl_certificate_key cert.key;

# ssl_session_cache shared:SSL:1m;

# ssl_session_timeout 5m;

# ssl_ciphers HIGH:!aNULL:!MD5;

# ssl_prefer_server_ciphers on;

# location / {

# root html;

# index index.html index.htm;

# }

}

在虚拟环境下安装uWSGI

pip3 install -i https://pypi.douban.com/simple uwsgi

uWSGI模板

[uwsgi]

# Django-related settings

# the base directory (full path)

#项目的绝对路径,定位到nbcrm的第一层

chdir = /opt/NBcrm

# Django's wsgi file

# 找到项目第二层的wsgi文件

module = NBcrm.wsgi

# the virtualenv (full path)

# 找到虚拟环境的绝对路径

home = /root/Envs/nbcrm

# process-related settings

# master

# 主进程

master = true

# maximum number of worker processes

# 开启uwsgi的多进程数,根据cpu核数来定义

processes = 1

# the socket (use the full path to be safe

# 基于socket链接运行crm,只有与nginx结合的时候,才使用socket形式

socket = 0.0.0.0:8000

# 当你没用nginx,调试项目的时候,使用http形式

#http = 0.0.0.0:8000

# ... with appropriate permissions - may be needed

# chmod-socket = 664

# clear environment on exit

vacuum = true

#指定一个参数,日志放在哪

#如果你使用了supervisor,请注释掉下面这个参数

#守护进程在后台运行,且将日志信息,输出到uwsgi.log日志中

#daemonize = uwsgi.log

Linux目录结构

bin

存放常用命令

boot

存放启动Linux时使用的核心文件、连接文件、镜像文件

dev

存放Linux外部设备

etc

存放所有系统管理所需要的配置文件和子目录

home

用户主目录，每个用户都有以自己用户名命名的目录

lib

基本的动态连接共享库

media

挂载设备

mnt

临时挂载别的文件系统

opt

给主机额外安装软件所摆放的目录

proc

虚拟目录，是系统内存映射，可以读取和更改系统信息。***这个目录内容是在内存里***

root

系统管理员主目录

run

临时文件系统、存储系统启动后的记录，重启时应该被清空

sbin

系统管理员使用的系统管理程序

srv

存放服务启动后需要提取的信息

sys

内核文件

tmp

存放临时文件

usr

应用程序和文件存放目录

var

存放不断扩充的目录，包括日志文件

DNS工作流程

实战部署vue+django的路飞学城

1.安装python3 环境

2.安装 mysql，redis，nginx

3.部署前端

1.安装node.js的环境

2.安装依赖包

3.修改axios的发送的端口接口

4.打包

4.部署后端

1.安装virtualenv

2.创建虚拟环境

3.安装django和uwsgi，以及项目的依赖包

4.修改uwsgi的配置文件

5.通过uwsgi -ini 配置文件启动django项目

5.配置nginx

1.创建两个虚拟主机，分别监听80和8000端口

2.访问80端口是访问呢vue

3.访问8000端口是vue发起的8000端口请求，反向代理到9000的uwsgi

6.启动nginx,mysql,redis

7.通过supervisor来管理

在已经配置好自动整合虚拟环境工具、python3、nginx、配置好阿里源的虚拟机中进行以下操作

首先在/opt/目录下载好路飞学城的Django和vue代码

wget https://files.cnblogs.com/files/pyyu/luffy_boy.zip

wget https://files.cnblogs.com/files/pyyu/07-luffy_project_01.zip

因为要在服务器上编译打包vue项目，所以得安装配置node环境

wget https://nodejs.org/download/release/v8.6.0/node-v8.6.0-linux-x64.tar.gz

因为node这个包是已经编译好的软件包，所以不需要编译并安装，直接解压后在它的目录下找到bin目录下的文件，有node npm npx三个文件，配置环境变量，配置方法查上方笔记。因为个人习惯，所以将解压好的包改名为了node

测试path是否配好，查看以下命令是否报错：

node -v

npm -v

解压vue源码包，并且改名为luffy_vue，找到配置文件，更改服务器地址：

配置文件在/opt/luffy_vue/src/restful/下的api.js，批量替换api.js中的127.0.0.1:8000为服务器地址和端口，举例设置为192.168.73.132:9000

确保vue的route模式是history：

配置文件地址/opt/luffy_vue/src/router/下的index.js

// 配置路由规则

export default new Router({

linkActiveClass:'is-active',

mode: 'history',//改成history模式

安装vue模块，以及打包vue项目，生成dist静态文件夹

防止因网速导致出错，这里设置npm下载源

npm config set registry https://registry.npm.taobao.org

然后再进行以下操作

npm install

npm run build

vue代码完成后，配置nginx，找到vue项目的主页文件

nginx配置文件在/opt/tngx/conf/下的nginx.conf文件

server {

listen 80;

server_name localhost;

location / {

root /opt/s20luffy/07-luffy_project_01/dist;

index index.html index.htm;

#确保刷新不出现404

try_files $uri $uri/ /index.html;

}

error_page 500 502 503 504 /50x.html;

location = /50x.html {

root html;

}

以上黄色部分为修改部分

再添加第二个虚拟主机配置反向代理

server {

listen 9000; #vue中配置的端口

server_name localhost;

location / {

include uwsgi_params;

uwsgi_pass 127.0.0.1:9999; #指向本地django项目

}

error_page 500 502 503 504 /50x.html;

location = /50x.html {

root html;

}

后端uWSGI+Django的部署

1.解压路飞学城的django包

2.激活虚拟环境

mkvirtualenv luffy

3.安装运行路飞学城所需的环境依赖：

在虚拟环境目录下创建requirements.txt文件，内写需要的环境依赖：

certifi==2018.11.29

chardet==3.0.4

crypto==1.4.1

Django==2.1.4

django-redis==4.10.0

django-rest-framework==0.1.0

djangorestframework==3.9.0

idna==2.8

Naked==0.1.31

pycrypto==2.6.1

pytz==2018.7

PyYAML==3.13

redis==3.0.1

requests==2.21.0

shellescape==3.4.1

urllib3==1.24.1

uWSGI==2.0.17.1

批量安装：pip3 install -i https://pypi.douban.com/simple -r requirements.txt

在django项目下创建并配置uwsgi.ini文件

[uwsgi]

# Django-related settings

# the base directory (full path)

#项目的绝对路径,定位到nbcrm的第一层

chdir = /opt/luffy_boy/

# Django's wsgi file

# 找到项目第二层的wsgi文件

module = luffy_boy.wsgi

# the virtualenv (full path)

# 找到虚拟环境的绝对路径

home = /opt/XN/luffy

# process-related settings

# master

# 主进程

master = true

# maximum number of worker processes

# 开启uwsgi的多进程数,根据cpu核数来定义

processes = 1

# the socket (use the full path to be safe

# 基于socket链接运行crm,只有与nginx结合的时候,才使用socket形式

socket = 0.0.0.0:9999

# 当你没用nginx,调试项目的时候,使用http形式

#http = 0.0.0.0:8000

# ... with appropriate permissions - may be needed

# chmod-socket = 664

# clear environment on exit

vacuum = true

#指定一个参数,日志放在哪

#如果你使用了supervisor,请注释掉下面这个参数

#守护进程在后台运行,且将日志信息,输出到uwsgi.log日志中

#daemonize = uwsgi.log

启动uwsgi后端

uwsgi --ini uwsgi.ini

启动redis

才能添加购物车

最省事的安装

yum install redis -y

systemctl start redis

mysql（mariadb）+centos7+主从复制

安装

centos官方的yum源（完整）

配置如下方式

1.找到yum仓库目录,创建repo文件

touch /etc/yum.repos.d/mariadb.repo

2.写入如下内容,指定mysql官方的yum源

[mariadb]

name = MariaDB

baseurl = http://yum.mariadb.org/10.1/centos7-amd64

gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB

gpgcheck=1

3.此时yum会自动的加载这个repo文件,读取内容

4.下载mariadb数据库,服务端和客户端

yum install MariaDB-server MariaDB-client

yum源就是配置在/etc/yum.repos.d/底下的*.repo文件而已

阿里云的yum源(下载速度快、版本低、精简)

yum install mariadb-server mariadb

启动mariadb数据库

systemctl start mariadb

初始化数据库,清除匿名用户,以及test数据库,保证数据库安全,允许mysql远程登录

mysql_secure_installation

登录数据库

mysql -uroot -p

修改mariadb数据库的的中文支持

退出数据库的情况下，打开MySQL的配置文件，在/etc/my.cnf文件

配置内容如下，黄色部分为自己添加的和修改的:

#服务端的编码添加如下内容

[mysqld]

character-set-server=utf8

collation-server=utf8_general_ci

datadir=/var/lib/mysql

socket=/var/lib/mysql/mysql.sock

# Disabling symbolic-links is recommended to prevent assorted security risks

symbolic-links=0

# Settings user and group are ignored when systemd is used.

# If you need to run mysqld under a different user or group,

# customize your systemd unit file for mariadb according to the

# instructions in http://fedoraproject.org/wiki/Systemd

#客户端的编码如下

[client]

default-character-set=utf8

[mysql]

default-character-set=utf8

[mysqld_safe]

log-error=/var/log/mariadb/mariadb.log

pid-file=/var/run/mariadb/mariadb.pid

# include all files from the config directory

!includedir /etc/my.cnf.d

重启mariadb生效编码

systemctl restart mariadb

mysql远程登录的授权设置

grant all privileges on . to root@'%' identified by '123';

远程登录命令

mysql -uroot -p -h192.168.94.132

mysql的备份与恢复

备份命令

mysqldump -uroot -p --all-databases > /opt/alldb.sql

恢复命令

方式1

进入数据库后,用source命令读取sql文件

[mysql] > source /opt/alldb.sql

方式2

用登录命令导入数据

mysql -uroot -p < /opt/alldb.sql

方式3

当数据量特别大的时候,以上方式不推荐,使用第三方工具进行导入

主从复制技术

OS1:192.168.94.132(master机器)

修改mysql的配置文件,开启binlog日志功能

vim /etc/my.cnf,写入如下信息

[mysqld]

server-id=1

log-bin=s20mysql-bin

重启数据库生效binlog日志文件

systemctl restart mariadb

进入数据库，在主库上,创建一个用户,用于主从复制

create user 'zhao'@'%' identified by '123';

给这个账号,授予slave的身份

grant replication slave on . to 'zhao'@'%';

进行锁表,防止数据写入

flush table with read lock;

在数据库外，导出此时的主库数据,发送给从库,保证起点一致性

mysqldump -uroot -p --all-databases > /tmp/alldb.sql

scp /tmp/alldb.sql root@192.168.94.130:/tmp/

**当从库配置好复制之后,回到这里解锁写入数据,查看从库数据是否写入***

OS2:192.168.94.130(slave机器)

修改从库机器的配置文件,开启id,以及只读模式

vim /etc/my.cnf 如下

[mysqld]

server-id=1000

read-only=true

重启从库

systemctl restart mariadb

将主库数据导入

mysql -uroot -p < /tmp/alldb.sql

重启数据库，并重新进入数据库，一条命令,建立主从之间的复制关系

* 在主库中的数据库内输入命令show master status;查看日志文件以及pos*口\***

change master to master_host='192.168.94.132',

master_user='zhao',

master_password='123',

master_log_file='testmysql-bin.000001',

master_log_pos=465;

开启从库的slave功能

start salve;

重启主库和从库

systemctl restart mariadb

查看从库的状态,检测是否复制成功

show slave status\G

查看如下两个参数是否是yes,主从复制即为正确

Slave_IO_Running: Yes

Slave_SQL_Running: Yes

redis内存高速缓存数据库（非关系型数据库、键值对存储数据库）

特征

Redis 是一个开源（BSD许可）的、内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件

redis是c语言编写的，单线程的、支持数据持久化，是key-value类型数据库。应用在缓存，队列系统中

redis支持数据备份，也就是master-slave模式

优势

性能高，读取速度10万次每秒、写入速度8万次每秒、所有操作支持原子性，用作缓存数据库，数据放在内存中，替代某些场景下的mysql，减少与MySQL交互。

缺点

因为redis是存储在内存中的，所以断电即消失。为解决这种缺点，redis提供了持久化机制。

安装

yum安装

yum install redis -y

rpm

源码编译（卸载掉之前yum安装的redis）

卸载掉之前yum安装的redis

yum remove redis -y

下载redis的源代码包(我电脑本地有包)

wget http://download.redis.io/releases/redis-4.0.10.tar.gz

解压缩源码包
因此redis压缩包,已经提供好了makefile,只需要执行编译并安装即可，会安装在当前目录并自动配置
重新登录，检查redis环境变量是否配置成功

which redis-server

通过redis-加上tab补全查看所有命令

redis-benchmark（性能测试）、redis-check-rdb（持久化）、redis-sentinel（守护）、redis-check-aof（持久化）、redis-cli（客户端登录）、redis-server（启动服务端）

软件配置

redis-cli登录

默认直接输入redis-server可以启动服务端,默认端口6379,且没有密码

更改端口

设置密码

开启redis的安全启动模式

以上三步都在redis.conf文件中配置

bind 服务器地址 #绑定redis启动的地址，服务器地址

protected-mode yes #开启redis的安全模式,必须输入密码才可以远程登录

port 端口 #指定redis的端口

daemonize yes #让redis以守护进程方式在后台运行,不占用窗口

pidfile /var/run/redis_端口号.pid #记录redis的进程id号的文件

loglevel notice #日志运行等级：严重级别,警告级别,debug调试界别logging

requirepass 密码 #设置redis的密码

使配置生效

redis-server 配置文件名

远程登录

redis-cli -p 端口号 -h 服务器地址

auth 密码

常用redis的公共命令

keys * 查看所有key

type key 查看key类型

expire key seconds 过期时间

ttl key 查看key过期剩余时间、结果为-2表示key已经不存在了

persist 取消key的过期时间、结果为-1表示key存在，没有过期时间

exists key 判断key存在、存在返回1否则0

del keys 删除key、可以删除多个

flushall 删除所有key

dbsize 计算key的数量

string类型的操作

通过set设置的就是string类型的key -value

set key value 设置key

get key 获取key

append key value 追加string

mset key value key value … … 设置多个键值对

mget key key 获取多个键值对

del key 删除键值

incr key 递增+1

decr key 递减-1

list类型,双向队列

lpush/rpush key value value value 从列表左边/右边插

lrange key 索引索引获取一定长度的元素

ltrim key 索引索引截取一定长度列表

lpop/rpop key 删除最左边/右边一个元素

sets集合类型

sadd/srem 添加/删除元素

sismember 判断是否为set的一个元素

smembers 返回集合所有的成员

sdiff 返回一个集合和其他集合的差异

sinter 返回几个集合的交集

sunion 返回几个集合的并集

有序集合

ZADD 顺序添加

ZREVERANGE 倒叙

ZRANGE 正序

ZREM 移除

哈希数据结构

hset 设置散列值

hget 获取散列值

hmset 设置多对散列值

hmget 获取多对散列值

hsetnx 如果散列已经存在，则不设置（防止覆盖key）

hkeys 返回所有keys

hvals 返回所有values

hlen 返回散列包含域（field）的数量

hdel 删除散列指定的域（field）

hexists 判断是否存在

redis的发布订阅

PUBLISH channel名消息 #发消息的

SUBSCRIBE channel名 #接收消息的

PSUBSCRIBE channel名正则 #接收消息的

redis的数据持久化

RDB持久化

RDB持久化可以将redis在内存中的的状态保存到硬盘中，它可以手动执行save、也可以再redis.conf中配置，定期执行。

RDB持久化产生的RDB文件是一个经过压缩的二进制文件，这个文件被保存在硬盘中，redis可以通过这个文件还原数据库当时的状态。

优点

速度快，适合做备份，主从复制就是基于RDB持久化功能实现

配置

先创建持久化文件存储的文件夹

在redis.conf中修改如下参数：

daemonize yes

port 端口号

logfile /data/端口号/redis.log #日志文件

dir /data/端口号 #定义持久化文件存储位置

dbfilename 持久化文件名.rdb #rdb持久化文件

bind IP地址 #redis绑定地址

requirepass 123 #redis登录密码

save 900 1 #rdb机制每900秒有1个修改记录

save 300 10 #每300秒 10个修改记录

save 60 10000 #每60秒内 10000修改记录

使用

输完数据等待时间，或者手动输 save 命令即可

AOF持久化

AOF记录服务器执行的所有变更操作命令，并在服务器启动时，通过重新执行这些命令来还原数据集、命令全部以redis协议的格式保存，新命令追加到文件末尾。

优点

最大程度保证数据不丢

缺点

日志记录非常大

配置

配置参数：

appendonly yes

appendfsync always 总是修改类的操作

everysec 每秒做一次持久化（常用）

no 依赖于系统自带的缓存大小机制

redis.conf文件中修改以下参数：

daemonize yes

port 6380

logfile /data/6380/redis.log

dir /data/6380

dbfilename dbmp.rdb

requirepass redhat

save 900 1

save 300 10

save 60 10000

appendonly yes #开启

appendfsync everysec #每秒做一次持久化

使用

配置完成后直接使用即可

不重启redis的情况下,切换RDB中的数据到AOF中的操作

根据上面RDB配置操作配置redis服务端
基于这个文件启动redis支持RDB的数据库
操作并手动save生成RDB文件
通过登录redis输入以下两条命令切换为AOF持久化方式：

CONFIG set appendonly yes

CONFIG SET save ""

***以上仅仅是临时生效，永久生效需要修改配置文件***

redis的主从复制（基于RDB持久化功能实现）

环境准备,一个6379的redis(master),和一个6380的redis(slave)

redis-6379.conf（主）：

port 6379

daemonize yes

pidfile /data/6379/redis.pid

loglevel notice

logfile "/data/6379/redis.log"

dbfilename dump.rdb

dir /data/6379

protected-mode no

redis-6380.conf (从)：

port 6380

daemonize yes

pidfile /data/6380/redis.pid

loglevel notice

logfile "/data/6380/redis.log"

dbfilename dump.rdb

dir /data/6380

protected-mode no

slaveof 127.0.0.1 6379

分别启动2个redis实例

redis-server redis-6379.conf

redis-server redis-6380.conf

登录数据库,查看两人之间的关系

info replication

数据读写查看

在6379中是可以读写的

redis-cli -p 6379 set 键值

redis-cli -p 6380 get 键

主从复制故障恢复

主库挂了得立即恢复主库，或者将从库切换为主库，继续工作

具体实现

分别启动 6379 6380 6381 三个数据库实例,建立好主从关系
杀死6379主库,此时6380 6381 群龙无首
选择让6381为新的主库,就要去除6381的从的身份

redis-cli -p 6381 slaveof no one

#查看此时6381的身份

redis-cli -p 6381 info replication

此时将6380的主人改为6381

redis-cli -p 6380 slaveof 127.0.0.1 6381

redis哨兵,自动的主从故障切换

配置步骤

环境准备,准备3个redis数据库实例,分别是 6379 6380 6381

redis-6379.conf

port 6379

daemonize yes

logfile "6379.log"

dbfilename "dump-6379.rdb"

dir "/var/redis/data/6379"

6380

redis-6380.conf

port 6380

daemonize yes

logfile "6380.log"

dbfilename "dump-6380.rdb"

dir "/var/redis/data/6380"

slaveof 127.0.0.1 6379

6381

redis-6381.conf

port 6381

daemonize yes

logfile "6380.log"

dbfilename "dump-6380.rdb"

dir "/var/redis/data/6381"

slaveof 127.0.0.1 6379

分别启动三个redis数据库实例

redis-server redis-6379.conf

redis-server redis-6380.conf

redis-server redis-6381.conf

准备三个redis-sentinel哨兵的配置文件

redis-sentinel-26379.conf

port 26379

dir /var/redis/data/26379

logfile "26379.log"

当前Sentinel节点监控 127.0.0.1:6379 这个主节点

2代表判断主节点失败至少需要2个Sentinel节点节点同意

mymaster是主节点的别名

sentinel monitor s20master 127.0.0.1 6379 2

每个Sentinel节点都要定期PING命令来判断Redis数据节点和其余Sentinel节点是否可达，如果超过30000毫秒30s且没有回复，则判定不可达

sentinel down-after-milliseconds s20master 30000

当Sentinel节点集合对主节点故障判定达成一致时，Sentinel领导者节点会做故障转移操作，选出新的主节点，

原来的从节点会向新的主节点发起复制操作，限制每次向新的主节点发起复制操作的从节点个数为1

sentinel parallel-syncs s20master 1

故障转移超时时间为180000毫秒

sentinel failover-timeout s20master 180000

让哨兵在后台运行

daemonize yes

如下26380和26381的配置文件,仅仅是端口的不同,可以快速生成

redis-sentinel-26380.conf

redis-sentinel-26381.conf

命令：

sed "s/26379/26380/g" redis-26379.conf > redis-26380.conf

sed "s/26379/26381/g" redis-26379.conf > redis-26381.conf

分别运行三个哨兵进程

(保证sentinel的配置正确,否则,你在启动报错后,配置文件的内容发发生变化)

创建哨兵的数据文件夹

mkdir -p /var/redis/data/26380

mkdir -p /var/redis/data/26379

mkdir -p /var/redis/data/26381

分别启动三个哨兵

redis-sentinel redis-26379.conf

redis-sentinel redis-26380.conf

redis-sentinel redis-26381.conf

检查redis的哨兵状态

redis-cli -p 26379 info sentinel

#查看到如下参数,哨兵就正确了

master0:name=s20master,status=ok,address=127.0.0.1:6379,slaves=2,sentinels=3

杀死主库,检查主从状态,是否会切换

redis-cluster（集群）配置

使用情况

并发量大、数据量大应用分布式分摊集中式的压力。

集群搭建

环境准备，6个redis数据库节点、准备6个配置文件

redis-7000.conf

redis-7001.conf

redis-7002.conf

redis-7003.conf

redis-7004.conf

redis-7005. conf

每个配置文件的内容，仅仅是端口的不同

内容如下：

port 7000

daemonize yes

dir "/opt/redis/data"

logfile "7000.log"

dbfilename "dump-7000.rdb"

cluster-enabled yes #开启集群模式

cluster-config-file nodes-7000.conf #集群内部的配置文件

cluster-require-full-coverage no #redis cluster需要16384个slot都正常的时候才能对外提供服务，换句话说，只要任何一个slot异常那么整个cluster不对外提供服务。因此生产环境一般为no

启动6个redis节点

redis-server redis-7000.conf

redis-server redis-7001.conf

redis-server redis-7002.conf

redis-server redis-7003.conf

redis-server redis-7004.conf

redis-server redis-7005.conf

开启redis-cluster的集群功能以及分配redis的slot槽位，基于ruby语言的脚本工具自动分配

下载ruby的解释器

wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz

编译并安装且配置环境变量

下载ruby操作redis的模块

wget http://rubygems.org/downloads/redis-3.3.0.gem

安装ruby操作redis的模块

gem install -l redis-3.3.0.gem

一键分配redis集群的槽位

查找一下这个命令的绝对路径

find / -name redis-trib.rb

把查找到的路径拼接到create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 的前面，执行。（1代表每个主库只有1个从库）

登录数据库,查看数据写入流向

上面查到的路径拼接 add-node --slave 127.0.0.1:7003 127.0.0.1:7000

redis节点故障

可以搭配 redis-cluster+redis-sentinel ，用哨兵检测主节点状态，当主节点宕机，自动切换从节点为新的主库

原理

redis客户端任意访问一个redis实例，如果数据不在该实例中，通过重定向引导客户端访问所需要的redis实例

docker容器（软件）

优势

环境一致
启动快
占用资源少
一次封装到处运行
持续交付

消息队列rabbitmq

概念

rabbitmq是消息代理，负责接收、存储、转发数据。

消息队列是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。

作用

解耦

队列两边可扩展性强，降低了耦合度，维护成本相对降低，只需要确保遵守接口约束。

冗余（安全）

消息队列将数据持久化，直到数据被完全处理才释放，以此规避数据丢失风险。

峰值处理

消息队列能够使关键组件顶住突发的访问压力，不会因突发的超负荷请求而完全崩溃。

可恢复性

系统部分组件失效不会影响整个系统。

有序

保证数据处理的顺序性。

缓冲

有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致的情况。

异步通信

消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。

使用消息队列的情景

异步处理，应用解耦，流量削锋和消息通讯四个场景

安装

已经配置过阿里云的yum源，所以在阿里第三方epel源中有rabbitmq

yum install rabbitmq-server erlang -y

启动rabbitmq-server

systemctl start rabbitmq-server

开启后台管理界面

rabbitmq-plugins enable rabbitmq_management

根据提示重启

systemctl restart rabbitmq-server

然后进入浏览器访问服务器IP，端口为rabbitmq-server端口（一般为15672），检查是否正常启动。

创建rabbitmq的账号密码

rabbitmqctl add_user 用户名 密码

设置用户为管理员

sudo rabbitmqctl set_user_tags 用户名 administrator

设置用户有权限访问所有队列

语法： [-p <主机路径>] <用户名> <配置文件> <可写> <可读>

rabbitmqctl set_permissions -p "/" 用户名 "." "." ".*"

重启rabbitmq-server，让用户生效

systemctl restart rabbitmq-server

访问web管理界面,登录,查看队列信息

http://**服务器IP**:15672/#/queues

使用实例

用python操作rabbitmq，实现生产消费者模型

安装pika模块，模块版本需要指定，因为代码参数发生了变化

pip3 install -i https://pypi.douban.com/simple pika==0.13.1

生产者的代码

#!/usr/bin/env python3

import pika

# 创建凭证，使用rabbitmq用户密码登录

# 去邮局取邮件，必须得验证身份

credentials = pika.PlainCredentials("zhao","123")

# 新建连接，这里localhost可以更换为服务器ip

# 找到这个邮局，等于连接上服务器

connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.94.132',credentials=credentials))

# 创建频道

# 建造一个大邮箱，隶属于这家邮局的邮箱，就是个连接

channel = connection.channel()

# 声明一个队列，用于接收消息，队列名字叫“queue1”

channel.queue_declare(queue='queue1')

# 注意在rabbitmq中，消息想要发送给队列，必须经过交换(exchange)，初学可以使用空字符串交换(exchange='')，它允许我们精确的指定发送给哪个队列(routing_key=''),参数body值发送的数据

channel.basic_publish(exchange='',

routing_key='queue1',

body='这是队列queue1的消息')

print("已经发送了消息")

# 程序退出前，确保刷新网络缓冲以及消息发送给rabbitmq，需要关闭本次连接

connection.close()

消费者的代码

import pika

# 建立与rabbitmq的连接

credentials = pika.PlainCredentials("zhao","123")

connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.94.132',credentials=credentials))

channel = connection.channel()

channel.queue_declare(queue="queue1")

def callbak(ch,method,properties,body):

print("消费者接收到了数据：%r"%body.decode("utf8"))

# 有消息来临，立即执行callbak，没有消息则夯住，等待消息

channel.basic_consume(callbak,queue="queue1",no_ack=True)

# 开始消费，接收消息

channel.start_consuming()

消息确认机制的生产者代码

#!/usr/bin/env python3

import pika

# 创建凭证，使用rabbitmq用户密码登录

# 去邮局取邮件，必须得验证身份

credentials = pika.PlainCredentials("zhao","123")

# 新建连接，这里localhost可以更换为服务器ip

# 找到这个邮局，等于连接上服务器

connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.94.132',credentials=credentials))

# 创建频道

# 建造一个大邮箱，隶属于这家邮局的邮箱，就是个连接

channel = connection.channel()

# 新建一个hello队列，用于接收消息

# 这个邮箱可以收发各个班级的邮件，通过

channel.queue_declare(queue='queue2')

channel.basic_publish(exchange='',

routing_key='queue2',

body='这是queue2的消息')

print("已经发送了消息")

# 程序退出前，确保刷新网络缓冲以及消息发送给rabbitmq，需要关闭本次连接

connection.close()

消息确认机制的消费者代码

import pika

credentials = pika.PlainCredentials("zhao","123")

connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.94.132',credentials=credentials))

channel = connection.channel()

# 声明一个队列(创建一个队列)

channel.queue_declare(queue='queue2')

def callback(ch, method, properties, body):

print("消费者接受到了任务: %r" % body.decode("utf-8"))

# 我告诉rabbitmq服务端，我已经取走了消息

# 回复方式在这

ch.basic_ack(delivery_tag=method.delivery_tag)

# 关闭no_ack，代表给与服务端ack回复，确认给与回复

channel.basic_consume(callback,queue='queue2',no_ack=False)

channel.start_consuming()

支持持久化的队列和消息

生产者的代码

import pika

# 有密码

credentials = pika.PlainCredentials("zhao","123")

connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.94.132',credentials=credentials))

channel = connection.channel()

# 声明一个队列(创建一个队列)

# 默认此队列不支持持久化，如果服务挂掉，数据丢失

# durable=True 开启持久化，必须新开启一个队列，原本的队列已经不支持持久化了

'''

实现rabbitmq持久化条件

delivery_mode=2

使用durable=True声明queue是持久化

'''

channel.queue_declare(queue='queue3',durable=True)

channel.basic_publish(exchange='',

routing_key='queue3', # 消息队列名称

body='这是queue3的消息',

# 支持数据持久化

properties=pika.BasicProperties(

delivery_mode=2,#代表消息是持久的 2

)

print(“已经发送了消息”)

connection.close()

持久化的消费者代码

import pika

credentials = pika.PlainCredentials("zhao","123")

connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.94.132',credentials=credentials))

channel = connection.channel()

# 确保队列持久化

channel.queue_declare(queue='queue3',durable=True)

'''

必须确保给与服务端消息回复，代表我已经消费了数据，否则数据一直持久化，不会消失

'''

def callback(ch, method, properties, body):

print("消费者接受到了任务: %r" % body.decode("utf-8"))

# 告诉服务端，我已经取走了数据，否则数据一直存在

ch.basic_ack(delivery_tag=method.delivery_tag)

# 关闭no_ack，代表给与回复确认

channel.basic_consume(callback,queue='queue3',no_ack=False)

channel.start_consuming()

saltstack运维工具（python编写的）

概念

远程执行系统、可以进行大规模部署，也能进行小规模的系统部署。salt的设计架构适用于任意数量的服务器，从少量本地网络系统到跨越数个数据中心，拓扑架构都是c/s模型，配置简单。支持用户通过python自定义功能模块，也提供了大量的python API接口，用户可以根据需要进行简单快速的扩展。

实例

环境准备

1. 准备3台机器，配置IP地址确保可以互相通信

一个master、两个minion

配置hosts解析文件,强制进行主机名解析,加速salt的minion查找,分别在三台机器上,写入解析

vim /etc/hosts

内容添加如下：

192.168.94.130 os2

192.168.94.131 os3

192.168.94.132 os1

2. 三台都配置阿里云的源，下载saltstack软件包，注意区分服务端和客户端

在master（即OS1）上安装

yum install salt-master -y

在minion1（即OS2）上安装

yum install salt-minion -y

在minion2（即OS3）上安装

yum install salt-minion -y

3. salt-master的配置和salt-minion的配置

配置文件路径如下：

salt-master的配置文件是/etc/salt/master

salt-minion的配置文件是/etc/salt/minion

salt-master的配置文件内容如下

interface:0.0.0.0 #绑定到本地的0.0.0.0地址

publish_port:4505 #管理端口，命令发送

user:root #运行salt进程的用户

worker_threads:1 #salt运行线程数，线程越多处理速度越快，不要超过cpu个数

ret_port:4506 #执行结果返回端口

pidfile:/var/run/salt-master.pid #pid文件位置

log_file:/var/log/salt/master #日志文件地址

auto_accept:False #自动接收minion的key

salt-minion1的配置文件信息如下

master: os1 #指定mastet的通信地址,此处冒号后必须有空格

master_port: 4506

user: root

id: os2 #id用于指定minion的身份信息 ,待会可以在master上查看到的

acceptance_wait_time: 10

log_file: /var/log/salt/minion

salt-minion2的配置

master: os1 #指定mastet的通信地址,此处冒号后必须有空格

master_port: 4506

user: root

id: os3 #id用于指定minion的身份信息 ,待会可以在master上查看到的

acceptance_wait_time: 10

log_file: /var/log/salt/minion

4. 都重启了master和minion之后,查看密钥接受情况，salt通信是在minion初次启动时候,建立新的连接的

systemctl start salt-master

systemctl start salt-minion

5. 在master机器上,查看minion的密钥信息

salt-key -L #查看所有密钥

salt-key -a os2 #-a参数单独接受一个密钥信息

salt-key -A #-A 接受所有的key信息

6. 此时就可以在master上管理 minion的机器了

salt "*" test.ping #验证salt minion信息是否存活

7. 将输出的结果,转化为json信息,可以序列化后,丢给前端渲染

salt "*" test.ping --out=json

salt的命令学习

salt 核心命令

salt 目标匹配你要执行的salt模块

salt的万能模块 cmd.run 代表让minion机器去做些什么事

让机器远程返回主机名给我

salt --summary '*' cmd.run 'hostname' #参数解释 --summary显示详细信息

salt "*" cmd.run "touch /tmp/1.txt "

salt "" cmd.run "rm -rf /tmp/"

远程安装软件

第一个方法 cmd.run

salt "*" cmd.run "yum install nginx -y"

salt还提供了更专业的安装软件的命令接口 pkg.install pkg.uninstall就是在调用yum而已

#远程卸载nginx

salt '*' pkg.remove "nginx"

#salt的服务管理模块 service模块,相当于在minion机器上,执行systemctl start nginx

salt '*' service.start "nginx"

salt '*' service.stop "nginx"

salt '*' service.restart "nginx"

#远程安装nginx,并且启动的方式

salt "*" pkg.install 'nginx'

salt "*" service.start 'nginx'

salt命令的输出格式有json和yaml两种

远程安装redis,并且输出json格式

salt "*" pkg.install "redis" --out=json

salt "*" service.start 'redis' --out=json

salt "*" service.status 'redis' --out=json

yaml语法学习

yaml转化python的数据结构

yaml

first_key:

second_key:

python

用python的字典和列表表示班级男女同学分配

{

"s20":{"男同学":["丽华","小黑","老徐"],"女同学":["大宝","b哥","超哥"],"不详":["self菊"]}

}

在线yaml语法解析:http://www.bejson.com/validators/yaml_editor/

python的数据结构,转为yaml

{ s20:

{ '男同学': [ '丽华', '小黑', '老徐' ],

'女同学': [ '大宝', 'b哥', '超弟' ],

'不详': [ 'self菊', '蔡旭困' ] } }

yaml如下

"s20":

"男同学":

- "丽华"

- "小黑"

- "老徐"

"女同学":

- "大宝"

- "b哥"

- "超弟"

"不详":

- "self菊"

- "蔡旭困"

salt工具之granis静态数据采集

当minion在启动的时候,发送自己所有的数据给master

#在启动时候发给master,如果后期服务器硬件修改了,数据就是旧的了,得重启salt-minion

#列出minion服务器所有的静态数据

salt '*' grains.items #列出服务器所有的静态数据

salt '*' grains.items --out=json #输出结果为json格式,可以序列化丢给其他程序使用

#指定key value取得数据

salt 's20minion1' grains.item osrelease

PreviousPython中的网络编程 Next项目部署

Last updated 5 years ago

Was this helpful?