memcached高可用实现

脑图：

yum 安装memcache

 apt install memcached -yvim /etc/memcached.confcat /etc/memcached.conf |grep -vE  "#|^$"
-d
logfile /var/log/memcached.log
-m 64
-p 11211
-u memcache
-l 127.0.0.1
-P /var/run/memcached/memcached.pid

命令查看：

memcached -h

修改配置文件：

PORT="11211”#监听端口
USER="memcached”#启动用户
MAXCONN="1024”#最大连接数
CACHESIZE="1024”#最大使用内存
OPTIONS=””#其他选项
-l 0.0.0.0  #监听地址

重启链接验证

systemctl restart memcached
telnet 10.0.0.201 11211

memcache主从服务器搭建

主服务器需要安装：memcached，libevent，keepalived，magent 201
从服务器需要安装：memcached，libevent，keepalived:  202

#关闭防火墙规则跟防护功能等

[root@localhost ~]# iptables -F
[root@localhost ~]# setenforce 0#解压事件通知库到opt
#Memcache 用到了 libevent 这个库用于 Socket 的处理，所以还需要安装 libevent[root@master ~]# tar zxvf libevent-2.1.8-stable.tar.gz  -C /opt[root@master ~]# tar zxvf memcached-1.5.6.tar.gz -C /opt[root@master ~]# mkdir /opt/magent                                 #从服务器不需要创建
[root@master ~]# tar zxvf magent-0.5.tar.gz -C /opt/magent/

安装编译环境

yum install gcc gcc-c++ make -y
cd /opt/libevent-2.1.8-stable/./configure --prefix=/usr      #指定安装路径#编译及安装
make && make install
cd memcached-1.5.6/
./configure \
--prefix=/usr/local/memcached \
--with-libevent=/usr/local/libevent

主服务器安装magent代理

cd /opt/magent/
[root@master magent]# ls
ketama.c  ketama.h  magent.c  Makefile

修改agent配置文件

[root@master magent]# vim ketama.h
'//修改前两个如下'#ifndef SSIZE_MAX
#define SSIZE_MAX 32767..........
#endif#修改Makefile配置文件
[root@master magent]# vim Makefile
'//首行添加-lm'LIBS = -levent -lm

编译

[root@master magent]# make
gcc -Wall -O2 -g  -c -o magent.o magent.c
gcc -Wall -O2 -g  -c -o ketama.o ketama.c
gcc -Wall -O2 -g -o magent magent.o ketama.o -levent -lm
#编译后会产生magent可执行程序
[root@master magent]# ls
ketama.c  ketama.h  ketama.o  magent  magent.c  magent.o  Makefile#下载远程传输  这样从服务器就不需要修改了
[root@master magent]# yum install openssh-clients -y

从服务器配置

将magent可执行程序复制到从服务器的/usr/bin中’

[root@master magent]# scp magent root@10.0.0.202:/usr/bin/
2.3：主从服务器搭建keeplived（略，前期文章）
2.4：主服务器创建magent脚本
2.5：主从服务器启动
[root@master shell]# chmod +x magent.sh                  '//增加执行权限'
[root@master shell]# systemctl stop firewalld.service
[root@master shell]# systemctl start keepalived.service  '//启动服务 稍微有点慢'
[root@master shell]# netstat -ntap | grep 12000
tcp        0      0 10.0.0.100:12000        0.0.0.0:*               LISTEN      100623/magent

验证主从

[root@master shell]# vim /var/log/messages
搜索'//Transition to MASTER STATE'，有即成功[root@master shell]# ip addr              '//查看漂移地址是否绑定成功'
.....省略内容....
inet 10.0.0.100/32 scope global ens33
.....省略内容....#从服务器
[root@slave keepalived]# vim /var/log/messages
搜索'//Entering BACKUP STATE'，有即成功
[root@slave keepalived]# ip addr   '//查看漂移地址是否绑定成功'
...省略内容inet 10.0.0.100/32 scope global ens33'//绑定成功 '
...省略内容.....
2.7：主从服务器开启memcache并测试本地连接
-m：指定缓存   -d：指定守护进程    -p：端口号
[root@master shell]# ln -s /usr/local/memcached/bin/* /usr/local/bin/
[root@master shell]# memcached -m 512k -u root -d -l 10.0.0.201 -p 11211
[root@master shell]# netstat -ntap |grep 11211
tcp        0      0 10.0.0.201:11211         0.0.0.0:*               LISTEN      100207/memcached    '//设置从服务器'
[root@slave shell]# ln -s /usr/local/memcached/bin/* /usr/local/bin/
[root@slave shell]# memcached -m 512k -u root -d -l 10.0.0.202 -p 11211
[root@slave shell]# netstat -ntap |grep 11211
tcp        0      0 10.0.0.202:11211         0.0.0.0:*               LISTEN      22510/memcached
2.9：memcache客户端测试
[root@tom03 ~]# yum install telnet -y
#进行连接
[root@tom03 ~]# telnet 10.0.0.100 12000
Trying 10.0.0.100...
Connected to 10.0.0.100.
Escape character is '^]'.
add shuai 0 0 4     '//客户端插入并新建一个数据'
1234
STORED#返回主服务器查看是否同步数据
[root@master shell]# telnet 10.0.0.201 11211
Trying 10.0.0.201...
Connected to 10.0.0.201.
Escape character is '^]'.
get shuai                        '//查看数据'
VALUE shuai 0 4
1234
END#从服务器进行验证
[root@slave shell]# telnet 10.0.0.202 11211
Trying 10.0.0.202...
Connected to 10.0.0.202.
Escape character is '^]'.
get shuai                        '//查看数据'
VALUE shuai 0 4
1234
END
'//测试成功，主从都成功生成数据'

测试高可用集群

客户端直接访问多个 memcache 实例
优点：简单，未引入新的节点；
缺点：维护不方便，未实现集中管理；性能不满足，实例宕机后不能自动踢出（hash 到该实例的请求都要等到超时才能转到其他正常实例）。

/宕机主服务器，看从服务器是否正常使用’

[root@master shell]# systemctl stop keepalived.service       '//关闭主服务器keepalived服务'#客户端登录
[root@tom03 ~]# telnet 10.0.0.100 12000                      '//客户端登陆成功'
Trying 10.0.0.100...
Connected to 10.0.0.100.
Escape character is '^]'.
set niu 0 0 3
123
STORED'//从服务器验证'
[root@slave shell]# telnet 10.0.0.202 11211
Trying 10.0.0.202...
Connected to 10.0.0.202.
Escape character is '^]'.
get niu
VALUE niu 0 3
123
END

redis如何安全加固

口令密码登录数据库

 redis-cli -a redis -h 10.0.0.132 -p 6379

修改端口

超时即退出

限制配置文件访问权限

增加此条配置参数：普通则无法查看redis的配置文件，权限不够

禁止root用户运行

禁止redis以root权限去运行，防止被拿到权限后进行写反弹shell操作
useradd -g redis -s /sbin/nologin -M redis  # 创建redis用户，并且不可登录
chown -R redis:redis /usr/local/redis/
sudo -u redis /usr/local/bin/redis-server /usr/local/redis/redis.conf

日志审计

可以审计已经发生的操作：

redis解释rdb, aof区别，优缺点

RDB

（Redis DataBase）持久化：快速的生成重写文件，基于时间的快照，其默认只保留当前最新的一次快照，特点是比较快，缺点是可能会丢失从上次快照到当前时间点之间未做快照的数据。                                                                                                                                                                                    RDB实现的具体过程Redis从主进程先fork出一个子进程，使用写时复制机制，子进程将内存的数据保存为一个临时文件，比如dump.rdb.temp，当数据保存完成之后再将上一次保存的RDB文件替换掉，然后关闭子进程，这样可以保证每一次做RDB快照的时候保存的数据都是完整的，因为直接替换RDB文件的时候可能会出现突然新电等问题而导数RDB文件还没有保存完整就突然关机停止保存而导致数摇丢失的情况，可以手动将每次生成的RDB文件进程备份，这样可以最大化保存历史数据。
数据库保存为|RDB|数据库，还原|RDB文件###：RDB模式的优缺点：优点：
-RDB快照保存了某个时间点的数据，可以通过脚本执行bgsave（非阻塞）或者save（阻塞）命令自定义时间点备份，可以保留多个备份，当出现问题可以恢复到不同时间点的版本。
可以最大化IO的性能，因为父进程在保存RDB文件的时候唯一要做的是fork出一个子进程，然后的操作都会有这个子进程操作，父进程无需任何的1O操作
RDB在大量数据比如几个G的数据，恢复的速度比AOF的快
缺点：
-不能时时的保存数据，会丢失自上一次执行RDB备份到当前的内存数据
数据量非常大的时候，从父进程fork的时候需要一点时间，可能是毫秒或者秒或者分钟，取决于磁盘

AOF

append only file,优先级高于RDB优先级，，，，以AOF为准出现问题时，快速的载入数据，肯定是可以让你恢复数据的，
AOF：按照操作顺序依次将操作添加到指定的日志文件当中，特点是数据安全性相对较高，缺点是即使有些操作是重复的也会全部记录。
AOF和RDB一样使用了写时复制机制，AOF默认为每秒钟fsync一次，即将执行的命令保存到AOF文件当中，这样即使redis服务器发生故障的话顶多也就丢失1秒钟之内的数据，也可以设置不同的fsync策略，或者设置每次执行命令的时候执行fsync，fsync会在后台执行线程，所以主线程可以继续处理用户的正常请求而不受到写入AOF文件的### AOF模式优缺点：   1.AOF的文件大小要大于RDB格式的文件
2.根据所使用的fsync策略（fsync是同步内存中redis所有已经修改的文件到存储设备），默认是appendfsync everysec，即每秒执行一次fsync

redis数据类型解释

字符串

127.0.0.1:6379> type m43
string

列表 list

127.0.0.1：6379>LPUSH 1ist1 jack tom
（integer）
3127.0.0.1：6379>TYPE 1ist1

集合 set

创建集合

127.0.0.1:6379> SADD set1 zhangsan lisi wangwwu
(integer) 3
127.0.0.1:6379> type set1

有序集合

创建：有序集合zset1，次数1 ，版本：v1

127.0.0.1:6379> zadd zset1 1 v1
(integer) 1
127.0.0.1:6379> type zset1
zset

哈希

hash是一个string类型的field和value的映射表，hash特别适合用于存储对象，Redis中每个hash可以存储2^32-1键值对（40多亿）
生成哈希表：

127.0.0.1:6379> hset hash1 name zhangsan age 24 job IT
(integer) 3
127.0.0.1:6379> type hash1
hash

redis实现生产者消费者，发布订阅模型

生产消费者模式

队列当中的消息由不同的生产者写入也会有不同的消费者取出进行消费处理，但是一个消息一定是只能被取出一次也就是被消费一次。

生产者发布消息（另一个终端）-》消费者消费消息

201：
127.0.0.1:6379> Lpush channel1 msg1
(integer) 1
127.0.0.1:6379> Lpush channel1 msg2
(integer) 2
127.0.0.1:6379> Lpush channel1 msg3
(integer) 3
127.0.0.1:6379> Lpush channel1 msg4
(integer) 4

复制会话（模拟另一个应用程序）

查看队列所有消息

127.0.0.1:6379> lrange channel1 0  -1
1) "msg1"

消费数据：

127.0.0.1:6379> rpop channel1
"msg1"

再次复制会话模拟另一个消费数据

拿到的是空值：证明了这种模式数据只能被消费一次

如果有多个数据，就按顺序消费，同一个数据不能被消费多次否则就会出现异常，要么是多付款要么是订单重了。

发布者订阅模式

在发布者订阅者模式下，发布者将消息发布到指定的）channel（频道里面，凡是监听该channel的消费者都会收到同样的一份消息，这种模式类似于是收音机的广播模式，即凡是收听某个频道的听众都会收到主持人发布的相同的消息内容。订阅者同时消费：

数据可以被多个消费者消费，
这种模式用的不是很多，公司一般用不上，但有自己的场景：数据写入相同的三个服务器，监听，通过这种方式实现分布式的数据同步，包括跨机房，主要用于在各个服务之间做数据同步。

订阅者监听频道：

127.0.0.1:6379> SUBSCRIBE m43

复制会话，给它去发送消息：

发布消息

127.0.0.1:6379> PUBLISH m43  msg1

终端自动监听到了

在其他终端上也监听

再次发送消息

两台机器就都收到了，但终端2无法收到它启动之前的信息，所以说队列中是不保存那些历史消息的，就像听广播一样，你下午是听不到早上节目的，除非有录音和回放功能。

终端3订阅多个频道：

root@k8s-server1:~# redis-cli
127.0.0.1:6379> SUBSCRIBE m43 m44

redis使用场景

缓存

作为Key-Value形态的内存数据库，Redis 最先会被想到的应用场景便是作为数据缓存。而使用 Redis 缓存数据非常简单，只需要通过string类型将序列化后的对象存起来即可，不过也有一些需要注意的地方：
1.必须保证不同对象的 key 不会重复，并且使 key 尽量短，一般使用类名（表名）加主键拼接而成。
2.选择一个优秀的序列化方式也很重要，目的是提高序列化的效率和减少内存占用。
缓存内容与数据库的一致性，这里一般有两种做法：
1.只在数据库查询后将对象放入缓存，如果对象发生了修改或删除操作，直接清除对应缓存（或设为过期）。
2.在数据库新增和查询后将对象放入缓存，修改后更新缓存，删除后清除对应缓存（或设为过期）。

数据共享分布式

String 类型，因为 Redis 是分布式的独立服务，可以在多个应用之间共享

例如：分布式Session

<dependency> <groupId>org.springframework.session</groupId> <artifactId>spring-session-data-redis</artifactId>
</dependency>
1
2
3
4

分布式锁

如今都是分布式的环境下java自带的单体锁已经不适用的。在 Redis 2.6.12 版本开始，string的set命令增加了一些参数：

EX：设置键的过期时间（单位为秒）

PX：设置键的过期时间（单位为毫秒）

NX ：只在键不存在时，才对键进行设置操作。 SET key value NX 效果等同于 SETNX key value 。

XX ：只在键已经存在时，才对键进行设置操作。

由于这个操作是原子性的，可以简单地以此实现一个分布式的锁，例如：

set lock_key locked NX EX 1

如果这个操作返回false，说明 key 的添加不成功，也就是当前有人在占用这把锁。而如果返回true，则说明得了锁，便可以继续进行操作，并且在操作后通过del命令释放掉锁。并且即使程序因为某些原因并没有释放锁，由于设置了过期时间，该锁也会在 1 秒后自动释放，不会影响到其他程序的运行。
推荐使用 redisson 第三方库实现分布式锁。

全局ID

int类型，incrby，利用原子性

incrby userid 1000

分库分表的场景，一次性拿一段

计数器

int类型，incr方法

例如：文章的阅读量、微博点赞数、允许一定的延迟，先写入Redis再定时同步到数据库

计数功能应该是最适合 Redis 的使用场景之一了，因为它高频率读写的特征可以完全发挥 Redis 作为内存数据库的高效。在 Redis 的数据结构中，string、hash和sorted set都提供了incr方法用于原子性的自增操作，下面举例说明一下它们各自的使用场景：

如果应用需要显示每天的注册用户数，便可以使用string作为计数器，设定一个名为REGISTERED_COUNT_TODAY的 key，并在初始化时给它设置一个到凌晨 0 点的过期时间，每当用户注册成功后便使用incr命令使该 key 增长 1，同时当每天凌晨 0 点后，这个计数器都会因为 key 过期使值清零。
每条微博都有点赞数、评论数、转发数和浏览数四条属性，这时用hash进行计数会更好，将该计数器的 key 设为weibo:weibo_id，hash的 field 为like_number、comment_number、forward_number和view_number，在对应操作后通过hincrby使hash 中的 field 自增。
如果应用有一个发帖排行榜的功能，便选择sorted set吧，将集合的 key 设为POST_RANK。当用户发帖后，使用zincrby将该用户 id 的 score 增长 1。sorted set会重新进行排序，用户所在排行榜的位置也就会得到实时的更新

等等，redis的应用场景十分广泛，因为它存取速度快，支持并发数量庞大。

zabbix

zabbix 主动被动模型原理

被动模式

无论是模式还是被动模式，都是站在zabbix agent角度来说的工作模式，比如被动模式，是说zabbix agent被动的接受zabbix server周期性发送过来的数据收集指令，在被动模式之下，zabbix server会根据主机关联的模板中的监控项和数据采集间隔时间，周期性的打开随机端口并向zabbix agent服务器的10050发起tcp连接，然后发送获取监控项数据的指令，即zabbix server发送什么指令那么zabbix agent就收集什么数据，zabbix server什么时候发送zabbix agent就什么时候采集，zabbix server不发送zabbix agent就一直不响应，所以zabbix agent也不用关心其监控项和数据采集周期间隔时间。
被动模式的优点就是配置简单，安装后即可使用，因此也成为zabbix的默认工作模式，但是波动模式的最大问题就是会加大zabbix server的工作量，在数百甚至数干台服务器的环境下会导致zabbix server需要轮训向每个zabbix agent发送数据采集指令，如果zabbix server负载很高还会导致不能及时获取到最新数据，但由于无需其他复杂配置，被设置为了默认的工作方式。
被动模式端口状态：

被动模式工作流程：

主动模式

主动模式是由zabbix agent主动向zabbix server的10051端口发起tcp连接请求，因此主动模式下必须在zabbix agent配置文件中指定zabbix server的IP或者主机名（必须可以被解析为IP地址），在连接到zabbix server之前zabbix agent是不知道自己要采集那些数据以及间隔多久采集一次数据的，然后在连接到zabbix server以后获取到自己的监控项和数据采集间隔周期时间，然后再根据监控项采集数据并返回给zabbix server，在主动模式下不再需要zabbix serve向zabbix agent发起连接请求，因此主动模式在一定程度上可减轻zabbix server打开的本地随机端口和进程数，在一定程度就减轻看zabbix server的压力。

zabbix监控tomcat, redis, nginx

监控tomcat

实现lnmp/lamp以及web工具的监控（略）

实现效果：

10.0.0.203安装jdk环境 #使用openjdk

 apt install openjdk-8-jdk –y

安装tomcat、修改配置文件并运行

CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote -DJava.rmi.server.hostname=10.0.0.203 -Dcom.sun.management.jmxremote.port=12345 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false"

运行

root@k8s-server3:~# cd /apps/apache-tomcat-8.5.65/
root@k8s-server3:/apps/apache-tomcat-8.5.65# mkdir webapps/yangk
root@k8s-server3:/apps/apache-tomcat-8.5.65# vim webapps/yangk/index.html
tomcat web page
root@k8s-server3:/apps/apache-tomcat-8.5.65# /apps/apache-tomcat-8.5.65/bin/catalina.sh start

访问测试：

安装JDK，通过jconsole验证JMX数据

找到JDK安装路径：自己安装的路径：G:\Program Files\Java\jdk1.8.0_341\bin

输入ip和端口

测试OK

要装java-gateway

root@k8s-server1:~# cd /usr/local/src//zabbix-4.0.44/
root@k8s-server1:/usr/local/src/zabbix-4.0.44# ./configure --help | grep java

java-getway进行配置：

vim /apps/zabbix_server/sbin/zabbix_java/settings.sh
LISTEN_IP="0.0.0.0"
LISTEN_PORT=10052
START_POLLERS=5     #启用多少个线程
TIMEOUT=30
重启java-getway
root@k8s-server1:/usr/local/src/zabbix-4.0.44# /apps/zabbix_server/sbin/zabbix_java/shutdown.sh
root@k8s-server1:/usr/local/src/zabbix-4.0.44# /apps/zabbix_server/sbin/zabbix_java/startup.sh
查看是否有java
root@k8s-server1:/usr/local/src/zabbix-4.0.44# java –version

启动java geteway：

/apps/zabbix_server/sbin/zabbix_java/startup.sh

编辑修改zabbix_server文件：

vim /apps/zabbix_server/etc/zabbix_server.conf
JavaGateway=10.0.0.201  JavaGatewayPort=10052
StartJavaPollers=5
重启：/apps/zabbix_server/sbin/zabbix_agentd

Web界面配监控tomcat：

监控ngnix

部署nginx（略）

修改配置文件

vim /usr/local/nginx/conf/nginx.conf
添加：
location /status {stub_status on;}

重启验证


/usr/local/nginx/sbin/nginx
curl http://10.0.0.201/status

自定义Nginx监控key

UserParameter=ping[*],echo $1ping[0]                 #返回的结果都是0ping[aaa]             #返回的结果都是aaa

在被监控端web1主机创建监控key文件并重启agent

vim /usr/local/etc/zabbix_agentd.conf.d/nginx.status
UserParameter=nginx.status[*],/usr/local/bin/nginx_status.sh $1
killall zabbix_agentdzabbix_agentd

编写status脚本

vim /usr/local/bin/nginx_status.sh#!/bin/bash
case $1 in
active)curl -s http://127.0.0.1/status | awk '/Active/{print $NF}';;
waiting)curl -s http://127.0.0.1/status | awk '/Waiting/{print $NF}';;
accepts)curl -s http://127.0.0.1/status | awk 'NR==3{print $2}';;
esacchmod +x /usr/local/bin/nginx_status.sh

测试zabbix_get能否获取

zabbix_get -s 127.0.0.1 -k 'nginx.status[accepts]'
zabbix_get -s 127.0.0.1 -k 'nginx.status[waiting]'
zabbix_get -s 127.0.0.1 -k 'nginx.status[accepts]'

给目标主机创建监控项

实现zabbix集群

agent自动发现监控主机上80,22,443, 3306端口状态

service_scan.py脚本依懒 python2.7版本下的 psutil库

#!/usr/local/python27/bin/python
# author: moorewqk@163.com
#import os, sys, time
import commands
import psutil
import socket
import jsondel_list = ["rpc.statd","java"]
def Handle_Connects():rows = []lc = psutil.net_connections('inet')for c in lc:(ip, port) = c.laddrif ip == '0.0.0.0' or ip == '::':if c.type == socket.SOCK_STREAM and c.status == psutil.CONN_LISTEN:proto_s = 'tcp'#elif c.type == socket.SOCK_DGRAM:#    proto_s = 'udp'else:continuepid_s = str(c.pid) if c.pid else '(unknown)'#print pid_s,portrows.append('%s:%s'%(pid_s,port))dedup_list = {}.fromkeys(rows).keys()return dedup_listdef handler_pid(pid,port):service_dict = {}p = psutil.Process(int(pid))if p.as_dict()['name'] == 'jsvc':service_pname = p.as_dict()['environ']['HOME'].split('/')[3]service_dict['{#PNAME}'] = service_pnameservice_dict['{#PPORT}'] = portelse:service_pname = p.as_dict()['name']service_dict['{#PNAME}'] = service_pnameservice_dict['{#PPORT}'] = portreturn service_dictdef main():zb_dict = {}service_list = []result_list = []clist = []for i in Handle_Connects():pid = i.split(':')[0]port = i.split(':')[1]service_list.append(handler_pid(pid,port))for dictlist in service_list:if dictlist["{#PNAME}"] in  del_list:result_list.append(dictlist)#service_list.remove(dictlist)#print result_listfor delname in service_list:if delname not in result_list:clist.append(delname)zb_dict['data'] = clistprint json.dumps(zb_dict,sort_keys=True,indent=4)if __name__ == "__main__":main()

需要在agent端安装 python2.7版本（略）

用python2.7 安装相关的 psutil库（略）

zabbix实现邮件或微信报警

zabbix进行mysql监控

Zabbix 前端配置

创建监控用户及授权

重启 agent

systemctl restart zabbix-agent

效果：

基于zabbix api批量添加本网段所有扫描到的ping通的主机到server.

将将命名为“zabbix_host_add.xlsx”的EXCEL表，放置与脚本统一目录下，然后执行脚本“ python 脚本.py -参数”即可。

#!/usr/bin/python
#coding:utf-8import json
import urllib.request
from urllib.error import URLError
import sys,argparse
import xlrddefaultencoding = 'utf-8'
if sys.getdefaultencoding() != defaultencoding:reload(sys)sys.setdefaultencoding(defaultencoding)class zabbix_api:def __init__(self):self.url = 'http://zabbix 服务器地址/zabbix/api_jsonrpc.php' #修改URLself.header = {"Content-Type":"application/json"}def user_login(self):data = json.dumps({"jsonrpc": "2.0","method": "user.login","params": {"user": "账号","password": "**"},"id": 0})# data = urllib.parse.quote_plus(data).encode("utf-8")data = data.encode("utf-8")request = urllib.request.Request(self.url, data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except URLError as e:print ("用户认证失败，请检查 !", e.code)else:response = json.loads(result.read())result.close()self.authID = response['result']return self.authIDdef host_get(self,hostName=''):data=json.dumps({"jsonrpc": "2.0","method": "host.get","params": {"output": "extend","filter":{"host":hostName}},"auth": self.user_login(),"id": 1})data = data.encode("utf-8")request = urllib.request.Request(self.url,data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except URLError as e:if hasattr(e, 'reason'):print ('We failed to reach a server.')print ('Reason: ', e.reason)elif hasattr(e, 'code'):print ('The server could not fulfill the request.')print ('Error code: ', e.code)else:response = json.loads(result.read())#print responseresult.close()print ("主机数量: %s"%(len(response['result'])))for host in response['result']:status={"0":"OK","1":"Disabled"}available={"0":"Unknown","1":"available","2":"Unavailable"}#print hostif len(hostName)==0:print ("HostID : %s\t HostName : %s\t Status :%s \t Available :%s"%(host['hostid'],host['name'],status[host['status']],available[host['available']]))else:print ("HostID : %s\t HostName : %s\t Status :%s \t Available :%s"%(host['hostid'],host['name'],status[host['status']],available[host['available']]))return host['hostid']def hostgroup_get(self, hostgroupName=''):data = json.dumps({"jsonrpc":"2.0","method":"hostgroup.get","params":{"output": "extend","filter": {"name": hostgroupName}},"auth":self.user_login(),"id":1,})data = data.encode("utf-8")request = urllib.request.Request(self.url,data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except URLError as e:print ("Error as ", e)else:#print result.read()response = json.loads(result.read())result.close()#print response()for group in response['result']:if  len(hostgroupName)==0:print ("hostgroup:  %s \tgroupid : %s" %(group['name'],group['groupid']))else:print ("hostgroup:  %s\tgroupid : %s" %(group['name'],group['groupid']))self.hostgroupID = group['groupid']return group['groupid']def template_get(self,templateName=''):data = json.dumps({"jsonrpc":"2.0","method": "template.get","params": {"output": "extend","filter": {"name":templateName}},"auth":self.user_login(),"id":1,})data = data.encode("utf-8")request = urllib.request.Request(self.url, data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except URLError as e:print ("Error as ", e)else:response = json.loads(result.read())result.close()#print responsefor template in response['result']:if len(templateName)==0:print ("template : %s\t  id : %s" % (template['name'], template['templateid']))else:self.templateID = response['result'][0]['templateid']print ("Template Name :  %s "%templateName)return response['result'][0]['templateid']def hostgroup_create(self,hostgroupName):if self.hostgroup_get(hostgroupName):print ("hostgroup  %s is exist !"%hostgroupName)sys.exit(1)data = json.dumps({"jsonrpc": "2.0","method": "hostgroup.create","params": {"name": hostgroupName},"auth": self.user_login(),"id": 1})data = data.encode("utf-8")request=urllib.request.Request(self.url,data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except URLError as e:print ("Error as ", e)else:response = json.loads(result.read())result.close()print ("添加主机组:%s  hostgroupID : %s"%(hostgroupName,response['result']['groupids']))def host_create_andy(self,hostName,visibleName, hostip, hostgroupName, templateName):if self.host_get(hostip):print ("该主机已经添加!")sys.exit(1)group_list=[]template_list=[]for i in hostgroupName.split(','):var = {}var['groupid'] = self.hostgroup_get(i)group_list.append(var)for i in templateName.split(','):var={}var['templateid']=self.template_get(i)template_list.append(var)data = json.dumps({"jsonrpc":"2.0","method":"host.create","params":{"host": hostName,"name": visibleName,"interfaces": [{"type": 2,    #1：表示IP；2表示SNMP"main": 1,"useip": 1,"ip": hostip,"dns": "","port": "161"  #IP端口10051；SNMP端口161}],"groups": group_list,"templates": template_list,},"auth": self.user_login(),"id":1})data = data.encode("utf-8")request = urllib.request.Request(self.url, data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except URLError as e:print ("Error as ", e)else:response = json.loads(result.read())result.close()try:print ("添加主机 :%s \tid :%s" % (hostip, response['result']['hostids']))except KeyError as e:print ("信息 :%s \tid :%s" % (hostip, response['error']['data']))def host_create(self, hostip, hostgroupName, templateName):if self.host_get(hostip):print ("该主机已经添加!")sys.exit(1)group_list=[]template_list=[]for i in hostgroupName.split(','):var = {}var['groupid'] = self.hostgroup_get(i)group_list.append(var)for i in templateName.split(','):var={}var['templateid']=self.template_get(i)template_list.append(var)data = json.dumps({"jsonrpc":"2.0","method":"host.create","params":{"host": hostip,"interfaces": [{"type": 2,"main": 1,"useip": 1,"ip": hostip,"dns": "","port": "161"}],"groups": group_list,"templates": template_list,},"auth": self.user_login(),"id":1})data = data.encode("utf-8")request = urllib.request.Request(self.url, data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except URLError as e:print ("Error as ", e)else:response = json.loads(result.read())result.close()print ("添加主机 : %s \tid :%s" % (hostip, response['result']['hostids']))def host_disable(self,hostip):data=json.dumps({"jsonrpc": "2.0","method": "host.update","params": {"hostid": self.host_get(hostip),"status": 1},"auth": self.user_login(),"id": 1})data = data.encode("utf-8")request = urllib.request.Request(self.url,data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except URLError as e:print ("Error as ", e)else:response = json.loads(result.read())result.close()print ('----主机现在状态------------')print (self.host_get(hostip))def host_delete(self,hostid):hostid_list=[]#print type(hostid)for i in hostid.split(','):var = {}var['hostid'] = self.host_get(i)hostid_list.append(var)data=json.dumps({"jsonrpc": "2.0","method": "host.delete","params": hostid_list,"auth": self.user_login(),"id": 1})data = data.encode("utf-8")request = urllib.request.Request(self.url,data)for key in self.header:request.add_header(key, self.header[key])try:result = urllib.request.urlopen(request)except Exception as e:print  (e)else:result.close()print ("主机  %s  已经删除 !"%hostid)if __name__ == "__main__":zabbix=zabbix_api()parser=argparse.ArgumentParser(description='zabbix  api ',usage='%(prog)s [options]')parser.add_argument('-H','--host',nargs='?',dest='listhost',default='host',help='查询主机')parser.add_argument('-G','--group',nargs='?',dest='listgroup',default='group',help='查询主机组')parser.add_argument('-T','--template',nargs='?',dest='listtemp',default='template',help='查询模板信息')parser.add_argument('-A','--add-group',nargs=1,dest='addgroup',help='添加主机组')parser.add_argument('-C','--add-host',dest='addhost',nargs=3,metavar=('192.168.2.1', 'test01,test02', 'Template01,Template02'),help='添加主机,多个主机组或模板使用分号')parser.add_argument('-d','--disable',dest='disablehost',nargs=1,metavar=('192.168.2.1'),help='禁用主机')parser.add_argument('-L','--allin',dest='allin',nargs='?',default='allin',help='从Excel批量导入主机')parser.add_argument('-D','--delete',dest='deletehost',nargs='+',metavar=('192.168.2.1'),help='删除主机,多个主机之间用分号')parser.add_argument('-v','--version', action='version', version='%(prog)s 1.0')if len(sys.argv)==1:print (parser.print_help())else:args=parser.parse_args()if args.listhost != 'host' :if args.listhost:zabbix.host_get(args.listhost)else:zabbix.host_get()if args.listgroup !='group':if args.listgroup:zabbix.hostgroup_get(args.listgroup)else:zabbix.hostgroup_get()if args.listtemp != 'template':if args.listtemp:zabbix.template_get(args.listtemp)else:zabbix.template_get()if args.addgroup:zabbix.hostgroup_create(args.addgroup[0])if args.addhost:zabbix.host_create(args.addhost[0], args.addhost[1], args.addhost[2])if args.disablehost:zabbix.host_disable(args.disablehost)if args.deletehost:zabbix.host_delete(args.deletehost[0])if args.allin != 'allin':workbook = xlrd.open_workbook('zabbix_host_add.xlsx')     #Excel名for row in range(workbook.sheets()[0].nrows):hostname = workbook.sheets()[0].cell(row, 0).valuevisible = workbook.sheets()[0].cell(row, 1).valuehostip = workbook.sheets()[0].cell(row, 2).valuehostgroup = workbook.sheets()[0].cell(row, 3).valuehosttemp = workbook.sheets()[0].cell(row, 4).valuezabbix.host_create_andy(hostname,visible,hostip,hostgroup, hosttemp)

如果觉得对您有用，请点个赞哦♪（＾∀＾●） ↓↓↓

ubuntu18.04/centos7.9-Redis-Zabbix相关操作相关推荐

拯救者Y9000P 安装Ubuntu18.04 、Ros Melodic等相关配置过程中出现的错误及解决办法
电脑配置:拯救者Y9000P 2022 i9 3060 目录一.安装Ubuntu18.04 1.安装UltralSO时无法写入镜像文件,显示磁盘/映像空间太小 2.由于2022拯救者Y9000PBI ...
【Ubuntu18.04】实现redis+lua+nginx动态黑名单封禁
必要包整合链接 nginx+lua+redis.rar-其它文档类资源-CSDN下载 nginxLuaRedis文件.rar-其它文档类资源-CSDN下载安装必要环境 apt-get install ...
关闭ubuntu18.04软键盘及多指操作
留作记录安装网页gnome控制关闭软键盘关闭多指操作安装网页gnome控制 sudo apt-get install chrome-gnome-shell 关闭软键盘关闭软键盘. 关闭多指操 ...
ubuntu18.04管理redis
ubuntu下 redis的安装使用安装 1. 进入redis安装路径 cd ~/installed/redis-5.0.7 2. 启动redis 启动服务端 redis-server 启动客户端( ...
Ubuntu18.04 或 Windows10 配置yolov5环境并测试运行
由于linux系统上的操作大部分可以在windows上系统的cmd命令行完成,所以本博客以ubuntu18.04系统作演示,相关的命令行指令和运行效果类似,如有明显的操作不同会另行说明. 第一步配置 ...
win7+ubuntu16.04以及win10+ubuntu18.04双系统安装
win7+ubuntu16.04以及win10+ubuntu18.04双系统安装 win7+ubuntu16.04以及win10+ubuntu18.04双系统安装 2020.8.8更新 2020.7. ...
linux4k分辨率,ubuntu18.04设置支持4k分辨率
ubuntu18.10操作系统默认安装完成后是不支持4K分辨率的,所以我们在终端下使用命令实现支持4K分辨率,然后可以在Display菜单中设置为4K分辨率. 具体实现命令如下所示: guanglei ...
ubuntu18.04修改屏幕休眠时间
虚拟机下的ubuntu18.04默认在几分钟没有操作的情况下屏幕会自动锁定,这样很不方便.我们调一调屏幕休眠的时间打开设置,找到电源并点击,然后修改空白屏幕的休眠时间就好啦
联想拯救者R7000安装Ubuntu18.04
1.下载ubuntu镜像并制作U盘由于本人白嫖的师兄的U盘,因此对这个过程不太了解,可参考: Ubuntu18.04安装教程_Sunshine的博客-CSDN博客_ubuntu安装教程 2.分配硬盘 ...

ubuntu18.04/centos7.9-Redis-Zabbix相关操作

目录

REDIS

ZABBIX