Python F5创建monitor、pool、node以及vs（二）

一、环境依赖
对f5进行操作，我们需要下载f5-sdk的依赖包。

f5-sdk==3.0.21
urllib3==1.25.7
# 安装命令：
pip install f5-sdk==3.0.21 urllib3==1.25.7

二、有关官方的样例介绍
f5-sdk网址

在开发的时候，由于导入的依赖是sdk，意味着我们可以直接使用里面的代码来为自己服务。
三、创建monitor、pool、vs

# -*- coding: utf-8 -*-
import json

from common.log import logger
from icontrol.exceptions import iControlUnexpectedHTTPError
from f5.bigip import ManagementRoot


class F5Manage(object):
    def __init__(self, hostname, username, password, port=None):
        self.config = None
        self.hostname = hostname
        self.username = username
        self.password = password
        self.port = port
        try:
            if port:
                self.mgmt = ManagementRoot(hostname=hostname,
                                           username=username,
                                           password=password,
                                           port=port)
            else:
                self.mgmt = ManagementRoot(hostname=hostname,
                                           username=username,
                                           password=password)
            self.result = True
        except Exception as e:
            logger.error(' F5 Client Login error: %s' % e)
            self.result = False
            self.message = u'F5 Client Login error: connection failed.'

    def deal_message(self, mes):
        if isinstance(mes, iControlUnexpectedHTTPError):
            text = json.loads(mes.response.text)
            message = text['message']
        else:
            message = mes
        return message

    def operator_member(self, member_name, operator_type=None, partition=None):
        """
        操作member
        :param member_name: member名称
        :param operator_type: 操作类型，动作： 0代表 禁用， 1代表 启用
        :param partition:
        :return:
        """
        data = {"message": None, "result": True}
        try:

            node_obj = self.mgmt.tm.ltm.nodes.node.load(name=member_name,
                                                        partition=(partition if partition else 'Common'))
            if operator_type == 0:
                node_obj.session = 'user-disabled'
                data["message"] = u'成功禁用{0}'.format(member_name)
            else:
                node_obj.session = 'user-enabled'
                data["message"] = u'成功启用{0}'.format(member_name)
            node_obj.update()
        except Exception as e:
            logger.error(u'操作member抛出error:{0}'.format(e))
            data["message"] = self.deal_message(e)
            data["result"] = False
        return data

    def operate_vs(self, vs_name, operate_type, partition=None):
        """
        操作vs
        :param vs_name: vs名称
        :param operate_type: 操作类型 1禁用 2启用
        :param partition: 区域 默认为Common
        :return:
        """
        data = {}
        try:
            vs = self.mgmt.tm.ltm.virtuals.virtual.load(
                name=vs_name,
                partition=partition
            )
            if int(operate_type) == 1:
                # 禁用
                if hasattr(vs, 'enabled'):
                    vs.disabled = True
            else:
                # 启用
                if hasattr(vs, 'disabled'):
                    vs.enabled = True

            vs.update()
            data['result'] = True
            data['message'] = 'Virtual Server operate success'
        except Exception as e:
            logger.error(u'操作vs抛出error:{0}'.format(e))
            data['result'] = False
            data['message'] = self.deal_message(e)
        return data

    def create_monitor(self, monitor_type, monitor_name, partition, interval, timeout, send, recv, recv_disable):
        """
        创建monitor
        :param monitor_type: http / tcp
        :param monitor_name:
        :param partition:
        :param interval:
        :param timeout:
        :param send:
        :param recv:
        :param recv_disable:
        :return:
        """
        data = {"message": u'monitor创建成功', "result": True}
        if not partition:
            partition = 'Common',
        try:
            if monitor_type == 'http':
                self.mgmt.tm.ltm.monitor.https.http.create(
                    name=monitor_name,
                    partition=partition,
                    interval=interval,
                    timeout=timeout,
                    send=send,
                    recv=recv,
                    recvDisable=recv_disable
                )
            elif monitor_type == 'tcp':
                self.mgmt.tm.ltm.monitor.tcps.tcp.create(
                    name=monitor_name,
                    partition=partition,
                    interval=interval,
                    timeout=timeout,
                    send=send,
                    recv=recv,
                    recvDisable=recv_disable
                )
            else:
                data = {"message": u'monitor创建失败，类型不正确', "result": False}
        except Exception as e:
            logger.error(u'创建monitor抛出error:{0}'.format(e))
            data["message"] = self.deal_message(e)
            data["result"] = False
        return data

    def create_pool(self,
                    pool_name,
                    members,
                    pool_use_monitor=None,
                    partition=None,
                    load_balancing_mode=None,
                    min_active_members=None):
        """

        :param pool_name:
        :param members: member的list内容列表
        :param pool_use_monitor:
        :param partition:
        :param load_balancing_mode:
        :param min_active_members:
        :return:
        """
        data = {"message": u'pool创建成功', "result": True}
        if not partition:
            partition = 'Common'
        if not pool_use_monitor:
            pool_use_monitor = ''
        if not load_balancing_mode:
            load_balancing_mode = 'round-robin'
        if not min_active_members:
            min_active_members = 0

        pool_obj = None
        mem_list_obj = []
        try:
            self.mgmt.tm.ltm.pools.pool.create(name=pool_name,
                                               partition=partition,
                                               monitor=pool_use_monitor,
                                               loadBalancingMode=load_balancing_mode,
                                               minActiveMembers=min_active_members
                                               )
            pool_obj = self.mgmt.tm.ltm.pools.pool.load(name=pool_name,
                                                        partition=partition)
            node_ip_list = [node_obj.address for node_obj in self.mgmt.tm.ltm.nodes.get_collection()]

            for mem in members:
                pool_obj.members_s.members.create(
                    partition=partition,
                    name=(mem["node_name"] if mem["node_name"] else mem["ip"]) + ":" + str(mem["port"]),
                    address=mem["ip"],
                    priorityGroup=mem.get('priority_group', 0)
                    )
                if mem['ip'] not in node_ip_list:
                    mem_list_obj.append(self.mgmt.tm.ltm.nodes.node.load(
                        partition=partition,
                        name=(mem["node_name"] if mem["node_name"] else mem["ip"]),
                        address=mem["ip"]))
        except Exception as e:
            logger.error(u'创建pool抛出error:{0}'.format(e))
            data["message"] = self.deal_message(e)
            data["result"] = False
            if pool_obj:
                pool_obj.delete()
            for mem_obj in mem_list_obj:
                mem_obj.delete()
        return data

    def create_vs(self, vs_name, vs_use_pool, destination_ip, destination_port, partition=None):
        """
        创建VS
        :param vs_name: vs名称
        :param partition: 区域 默认为Common
        :param vs_use_pool: pool名称
        :param destination_ip: ip地址
        :param destination_port: 端口
        :return:
        """
        data = {}
        try:
            host = '%s:%s' % (destination_ip, destination_port)
            self.mgmt.tm.ltm.virtuals.virtual.create(
                name=vs_name,
                partition=partition,
                destination=host,
                pool=vs_use_pool
            )
            data['result'] = True
            data['message'] = 'Virtual Server create success'
        except Exception as e:
            logger.error(u'创建vs抛出error:{0}'.format(e))
            data['result'] = False
            data['message'] = self.deal_message(e)
        return data

四、参数说明：
1.创建monitor

字段	类型	必选	描述
ip	str	是	f5的ip地址
username	str	是	f5用户
password	str	是	f5密码
port	int	否	端口
monitor_type	str	是	monitor类型 http tcp
monitor_name	str	是	名称
partition	str	否	partition
interval	int	否	interval
timeout	int	否	timeout
send	str	否	send
recv	str	否	recv
recv_disable	str	否	recv_disable

2.创建pool

字段	类型	必选	描述
ip	str	是	f5的ip地址
username	str	是	f5用户
password	str	是	f5密码
port	int	否	端口
pool_name	str	是	pool名称
members	list	否	member列表
pool_use_monitor	str	否	健康检测规则
partition	str	否	partition
load_balancing_mode	str	否	load_balancing_mode
min_active_members	int	否	min_active_members

members参数：

字段	类型	必选	描述
node_name	str	否	member名称
ip	str	否	ip地址
port	int	否	端口
priority_group	int	否	priority_group

3.创建vs

字段	类型	必选	描述
ip	str	是	f5的ip地址
username	str	是	f5用户
password	str	是	f5密码
port	int	否	f5端口
vs_name	str	是	vs名称
destination_ip	str	是	vs的IP地址
destination_port	str	是	vs的端口
vs_use_pool	str	否	pool名称
partition	str	否	区域

如果需要更多的参数说明，可以到官方网站查看：https://clouddocs.f5.com/api/icontrol-rest/APIRef_tm_ltm_virtual.html
其次可以通过访问：
https://xxxx/mgmt/toc