def __install_k8s_hw_specs(k8s_conf, hw_type): """ Install nvidia k8s plugin so k8s pods can access NVIDIA GPUs :param k8s_conf: the snaps-kubernetes configuration dict :param hw_type: the type of HW to install :raises: Exception should snaps-kubernetes fail to deploy successfully """ logger.debug('Installing k8s [%s] plugin', hw_type) k8s_version = config_utils.get_k8s_version(k8s_conf, True) spec_url = None if hw_type == 'gpu': spec_url = consts.GPU_K8S_SPEC_URL elif hw_type == 'fpga': spec_url = consts.FPGA_K8S_SPEC_URL if spec_url and k8s_version.startswith('1.18'): logger.info('Installing k8s hardware plugin') pb_vars = { 'K8S_VERSION': config_utils.get_k8s_version(k8s_conf, True), 'K8S_PROJ_DIR': k8s_config_utils.get_project_artifact_dir(k8s_conf), 'K8S_SPEC_URL': spec_url, 'type': hw_type, 'http_proxy': k8s_config_utils.get_proxy_dict(k8s_conf)['http_proxy'], 'https_proxy': k8s_config_utils.get_proxy_dict(k8s_conf)['http_proxy'] } ansible_utils.apply_playbook(consts.SETUP_K8S_HW_PLUGIN_PB, variables=pb_vars) else: logger.info('No reason to install hardware plugins. K8s version %s', k8s_version)
def __install_kubectl(k8s_conf): """ This function is used to install kubectl at bootstrap node """ lb_ip = "127.0.0.1" lb_ips = config_utils.get_ha_lb_ips(k8s_conf) if len(lb_ips) > 0: lb_ip = lb_ips[0] logger.info("Load balancer ip %s", lb_ip) host_name, ip = config_utils.get_first_master_host(k8s_conf) ha_enabled = len(lb_ips) > 0 pb_vars = { 'ip': ip, 'host_name': host_name, 'ha_enabled': ha_enabled, 'Project_name': config_utils.get_project_name(k8s_conf), 'lb_ip': lb_ip, 'CONFIG_DEMO_FILE': consts.KUBECTL_CONF_TMPLT, 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir( k8s_conf), 'KUBERNETES_PATH': consts.NODE_K8S_PATH, } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook(consts.K8_KUBECTL_INSTALLATION, variables=pb_vars)
def create_weave_interface(k8s_conf, weave_detail): """ This function is used to create weave interace and network """ logger.info('CREATING WEAVE NETWORK') network_dict = weave_detail.get(consts.WEAVE_NET_DTLS_KEY) network_name = network_dict.get(consts.NETWORK_NAME_KEY) logger.info('Creating weave network with name - %s', network_name) pb_vars = { 'networkName': network_name, 'masterPlugin': network_dict.get(consts.MASTER_PLUGIN_KEY), 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), 'KUBESPRAY_PATH': config_utils.get_kubespray_dir(k8s_conf), # variables for weave-net.yml.j2 found in kubespray roles 'kube_pods_subnet': network_dict.get(consts.SUBNET_KEY), 'enable_network_policy': 0, 'kube_version': config_utils.get_version(k8s_conf), 'weave_kube_image_repo': 'docker.io/weaveworks/weave-kube', 'weave_kube_image_tag': '2.5.0', 'weave_npc_image_tag': '2.5.0', 'k8s_image_pull_policy': 'IfNotPresent', 'weave_npc_image_repo': 'docker.io/weaveworks/weave-npc', 'weave_password': '******' } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook( consts.K8_CONF_WEAVE_NETWORK_CREATION, consts.NODE_USER, variables=pb_vars)
def test_get_proxy_dict(self): """ Ensures proxy values are properly parsed """ proxy_dict = config_utils.get_proxy_dict(self.config) expected = self.config[consts.K8S_KEY][consts.PROXIES_KEY] self.assertEqual(expected, proxy_dict)
def __launch_sriov_network(k8s_conf, sriov_host): master_host, ip = config_utils.get_first_master_host(k8s_conf) for sriov_net in sriov_host[consts.SRIOV_NETWORKS_KEY]: dpdk_enable = config_utils.bool_val(sriov_net.get( consts.SRIOV_DPDK_ENABLE_KEY)) if dpdk_enable: logger.info('SRIOV NETWORK CREATION STARTED USING DPDK DRIVER') host_type = sriov_net.get(consts.TYPE_KEY) sriov_intf = sriov_net.get(consts.SRIOV_INTF_KEY) sriov_nw_name = sriov_net.get(consts.NETWORK_NAME_KEY) pb_vars = { 'intf': sriov_intf, 'network_name': sriov_nw_name, 'dpdk_driver': consts.DPDK_DRIVER, 'dpdk_tool': consts.DPDK_TOOL, 'node_hostname': sriov_host.get(consts.HOSTNAME_KEY), 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir( k8s_conf), } ansible_utils.apply_playbook( consts.K8_SRIOV_DPDK_CR_NW, [master_host], consts.NODE_USER, variables=pb_vars) if host_type == consts.NET_TYPE_LOCAL_TYPE: logger.info('SRIOV NETWORK CREATION STARTED USING ' 'KERNEL DRIVER WITH IPAM host-local') pb_vars = { 'host_name': master_host, 'intf': sriov_intf, 'network_name': sriov_nw_name, 'rangeStart': sriov_net.get(consts.RANGE_START_KEY), 'rangeEnd': sriov_net.get(consts.RANGE_END_KEY), 'subnet': sriov_net.get(consts.SUBNET_KEY), 'gateway': sriov_net.get(consts.GATEWAY_KEY), 'masterPlugin': sriov_net.get(consts.MASTER_PLUGIN_KEY), 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir( k8s_conf), } ansible_utils.apply_playbook( consts.K8_SRIOV_CR_NW, consts.NODE_USER, variables=pb_vars) if host_type == consts.DHCP_TYPE: logger.info( 'SRIOV NETWORK CREATION STARTED USING ' 'KERNEL DRIVER WITH IPAM host-dhcp') pb_vars = { 'intf': sriov_intf, 'network_name': sriov_nw_name, 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir( k8s_conf), } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook( consts.K8_SRIOV_DHCP_CR_NW, consts.NODE_USER, variables=pb_vars)
def validate_proxy_params(config): """ Checks the presence of proxy parameters """ logger.info("checking proxy params") proxy_params = config_utils.get_proxy_dict(config) validate_dict_data(proxy_params, consts.FTP_PROXY_KEY) validate_dict_data(proxy_params, consts.HTTP_PROXY_KEY) validate_dict_data(proxy_params, consts.HTTPS_PROXY_KEY) validate_dict_data(proxy_params, consts.NO_PROXY_KEY)
def create_flannel_interface(k8s_conf): logger.info('EXECUTING FLANNEL INTERFACE CREATION PLAY IN CREATE FUNC') pb_vars = { 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir( k8s_conf), 'KUBE_CNI_FLANNEL_RBAC_YML': consts.K8S_CNI_FLANNEL_RBAC_YML, 'KUBE_CNI_FLANNEL_YML': consts.K8S_CNI_FLANNEL_J2, } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook( consts.K8_CONF_FLANNEL_RBAC, consts.NODE_USER, variables=pb_vars) flannel_cfgs = config_utils.get_multus_cni_flannel_cfgs(k8s_conf) for flannel_cfg in flannel_cfgs: for key, flannel_details in flannel_cfg.items(): network = flannel_details.get(consts.NETWORK_KEY) cidr = flannel_details.get(consts.SUBNET_KEY) master_hosts_t3 = config_utils.get_master_nodes_ip_name_type( k8s_conf) for host_name, ip, node_type in master_hosts_t3: ansible_utils.apply_playbook( consts.K8_CONF_FLANNEL_DAEMON_AT_MASTER, [ip], consts.NODE_USER, variables={ 'network': network, 'cidr': cidr, 'KUBERNETES_PATH': consts.NODE_K8S_PATH, }) pb_vars = { 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), 'KUBERNETES_PATH': consts.NODE_K8S_PATH, 'CNI_FLANNEL_YML_J2': consts.K8S_CNI_FLANNEL_J2, 'CNI_FLANNEL_RBAC_YML': consts.K8S_CNI_FLANNEL_RBAC_YML, 'network': network, 'ip': ip, 'node_user': consts.NODE_USER, } ansible_utils.apply_playbook( consts.K8_CONF_COPY_FLANNEL_CNI, variables=pb_vars) pb_vars = { 'networkName': flannel_details.get(consts.NETWORK_NAME_KEY), 'masterPlugin': flannel_details.get(consts.MASTER_PLUGIN_KEY), 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir( k8s_conf), } ansible_utils.apply_playbook( consts.K8_CONF_FLANNEL_INTF_CREATION_AT_MASTER, consts.NODE_USER, variables=pb_vars)
def launch_crd_network(k8s_conf): """ This function is used to create crd network """ master_host_name, master_ip = config_utils.get_first_master_host(k8s_conf) logger.info('EXECUTING CRD NETWORK CREATION PLAY. Master ip - %s, ' 'Master Host Name - %s', master_ip, master_host_name) pb_vars = { 'CRD_NET_YML': consts.K8S_CRD_NET_CONF, 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook(consts.K8_CREATE_CRD_NETWORK, consts.NODE_USER, variables=pb_vars)
def __launch_ha_loadbalancer(k8s_conf): """ function used to call launch_load_balancer :param k8s_conf: the config dict object :return: """ if config_utils.get_ha_config(k8s_conf): loadbalancer_dict = config_utils.get_loadbalancer_dict(k8s_conf) lb_port = loadbalancer_dict.get("port") master_ip_list = config_utils.get_master_node_ips(k8s_conf) pb_vars = { 'MASTER_IP_LIST': str(master_ip_list), 'lb_port': lb_port, } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook( consts.K8_HA_EXT_LB, [loadbalancer_dict.get(consts.IP_KEY)], consts.NODE_USER, variables=pb_vars)
def launch_persitent_volume_kubernetes(k8s_conf): """ This function is used for deploy the persistent_volume """ vol_claims = config_utils.get_persist_vol_claims(k8s_conf) for vol_claim in vol_claims: pb_vars = { 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir( k8s_conf), 'TASK_PV_VOL_CONF': consts.K8S_VOL_PV_VOL_J2, 'TASK_PV_CLAIM_CONF': consts.K8S_VOL_PV_CLAIM_J2, 'storage_size': vol_claim[consts.STORAGE_KEY], 'claim_name': vol_claim[consts.CLAIM_NAME_KEY], } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook( consts.KUBERNETES_PERSISTENT_VOL, consts.NODE_USER, variables=pb_vars)
def create_default_network(k8s_conf): default_network = config_utils.get_default_network(k8s_conf) network_name = default_network.get(consts.NETWORK_NAME_KEY) if not network_name: raise Exception('no network name in [%s]', default_network) master_plugin = default_network.get(consts.MASTER_PLUGIN_KEY) networking_plugin = config_utils.get_networking_plugin(k8s_conf) pb_vars = { 'networkName': network_name, 'masterPlugin': master_plugin, 'networking_plugin': networking_plugin, 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook( consts.K8_CREATE_DEFAULT_NETWORK, consts.NODE_USER, variables=pb_vars)
def __config_macvlan_networks(k8s_conf): """ This method is used for create macvlan network after multus :param k8s_conf: input configuration file """ macvlan_nets = config_utils.get_multus_cni_macvlan_cfgs(k8s_conf) for mvlan_net in macvlan_nets: iface_dict = mvlan_net.get(consts.MACVLAN_NET_DTLS_KEY) macvlan_masterplugin = iface_dict.get(consts.MASTER_PLUGIN_KEY) macvlan_type = iface_dict['type'] pb_vars = { 'network_name': iface_dict.get(consts.NETWORK_NAME_KEY), 'interface_node': iface_dict.get("master"), 'subnet': iface_dict.get(consts.SUBNET_KEY), 'rangeStart': iface_dict.get("rangeStart"), 'rangeEnd': iface_dict.get("rangeEnd"), 'dst': iface_dict.get("routes_dst"), 'gateway': iface_dict.get("gateway"), 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) if macvlan_masterplugin == "true": if macvlan_type == "host-local": ansible_utils.apply_playbook( consts.K8_MACVLAN_MASTER_NETWORK_PATH, config_utils.get_node_user(k8s_conf), variables=pb_vars) elif macvlan_type == consts.DHCP_TYPE: ansible_utils.apply_playbook( consts.K8_MACVLAN_MASTER_NETWORK_DHCP_PATH, config_utils.get_node_user(k8s_conf), variables=pb_vars) elif macvlan_masterplugin == "false": if macvlan_type == "host-local": ansible_utils.apply_playbook( consts.K8_MACVLAN_NETWORK_PATH, config_utils.get_node_user(k8s_conf), variables=pb_vars) elif macvlan_type == consts.DHCP_TYPE: ansible_utils.apply_playbook( consts.K8_MACVLAN_NETWORK_DHCP_PATH, config_utils.get_node_user(k8s_conf), variables=pb_vars)
def __install_kubectl(k8s_conf): """ This function is used to install kubectl at bootstrap node """ host_name, ip = config_utils.get_first_master_host(k8s_conf) api_ip_url = config_utils.get_k8s_api_url(k8s_conf, ip) pb_vars = { 'ip': ip, 'api_ip_url': api_ip_url, 'node_user': config_utils.get_node_user(k8s_conf), 'host_name': host_name, 'Project_name': config_utils.get_project_name(k8s_conf), 'CONFIG_DEMO_FILE': consts.KUBECTL_CONF_TMPLT, 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), 'KUBERNETES_PATH': consts.NODE_K8S_PATH, } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook(consts.K8_KUBECTL_INSTALLATION, variables=pb_vars)
def launch_ceph_kubernetes(k8s_conf): """ This function is used for deploy the ceph TODO/FIXME - Ceph and should be removed and Rook/Ceph should be used """ # Setup Ceph OSD hosts ceph_osds = config_utils.get_ceph_osds(k8s_conf) for ceph_osd in ceph_osds: ip = ceph_osd[consts.IP_KEY] pb_vars = { 'osd_host_name': ceph_osd[consts.HOSTNAME_KEY], 'user_id': ceph_osd[consts.USER_KEY], 'passwd': ceph_osd[consts.PASSWORD_KEY], 'osd_ip': ip, } ansible_utils.apply_playbook(consts.INSTALL_CEPH, [ip], config_utils.get_node_user(k8s_conf), variables=pb_vars) proxy_dict = config_utils.get_proxy_dict(k8s_conf) ceph_hosts_info = config_utils.get_ceph_hosts_info(k8s_conf) ceph_master_host = ceph_hosts_info[0][0] ceph_master_ip = ceph_hosts_info[0][1] ceph_osds_info = config_utils.get_ceph_osds_info(k8s_conf) for host_name, ip, host_type in ceph_osds_info: pb_vars = { 'host_name': host_name, 'master_host_ip': ceph_master_ip, } pb_vars.update(proxy_dict) logger.info('Executing CEPH deploy play. IP - %s, ' 'Host Type - %s', ip, host_type) ansible_utils.apply_playbook(consts.CEPH_DEPLOY, [host_name], config_utils.get_node_user(k8s_conf), variables=pb_vars) ansible_utils.apply_playbook(consts.CEPH_MON, [ceph_master_ip], config_utils.get_node_user(k8s_conf), variables=proxy_dict) for ceph_host in ceph_osds: second_storage = ceph_host.get(consts.STORAGE_TYPE_KEY) if second_storage and isinstance(second_storage, list): for storage in second_storage: pb_vars = { 'host_name': ceph_host[consts.HOSTNAME_KEY], 'master_host_name': ceph_master_host, 'storage': storage, } pb_vars.update(proxy_dict) ansible_utils.apply_playbook( consts.CEPH_STORAGE_NODE, [ceph_host[consts.IP_KEY]], config_utils.get_node_user(k8s_conf), variables=pb_vars) ansible_utils.apply_playbook( consts.CEPH_STORAGE_HOST, [ceph_master_host], config_utils.get_node_user(k8s_conf), variables=pb_vars) for host_name, ip, host_type in ceph_hosts_info: pb_vars = { 'host_name': host_name, 'master_host_name': ceph_master_host, } pb_vars.update(proxy_dict) ansible_utils.apply_playbook(consts.CEPH_DEPLOY_ADMIN, [ip], config_utils.get_node_user(k8s_conf), variables=pb_vars) pb_vars = { 'master_host_name': ceph_master_host, } pb_vars.update(proxy_dict) ansible_utils.apply_playbook(consts.CEPH_MDS, [ip], config_utils.get_node_user(k8s_conf), variables=pb_vars) proxy_dict = config_utils.get_kubespray_proxy_dict(k8s_conf) pb_vars = { 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), 'CEPH_FAST_RDB_YML': consts.K8S_CEPH_RDB_J2, 'ceph_controller_ip': ceph_master_ip, } pb_vars.update(proxy_dict) ansible_utils.apply_playbook(consts.KUBERNETES_CEPH_CLASS, [ceph_master_ip], config_utils.get_node_user(k8s_conf), variables=pb_vars) ceph_claims = config_utils.get_ceph_claims(k8s_conf) for claim in ceph_claims: pb_vars = { 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), 'ceph_storage_size': claim[consts.CEPH_STORAGE_KEY], 'ceph_claim_name': claim[consts.CEPH_CLAIM_NAME_KEY], 'CEPH_VC_YML': consts.K8S_CEPH_VC_J2, } pb_vars.update(proxy_dict) ansible_utils.apply_playbook(consts.KUBERNETES_CEPH_CLAIM, variables=pb_vars)
def launch_sriov_cni_configuration(k8s_conf): """ This function is used to launch sriov cni """ logger.info('EXECUTING SRIOV CNI PLAY') networking_plugin = config_utils.get_networking_plugin(k8s_conf) dpdk_driver = 'vfio-pci' dpdk_enable = False sriov_cfgs = config_utils.get_multus_cni_sriov_cfgs(k8s_conf) for sriov_cfg in sriov_cfgs: sriov_host = sriov_cfg[consts.HOST_KEY] # for sriov_net in sriov_hosts: hostname = sriov_host[consts.HOSTNAME_KEY] for sriov_net in sriov_host[consts.SRIOV_NETWORKS_KEY]: dpdk_enable = config_utils.bool_val( sriov_net.get(consts.SRIOV_DPDK_ENABLE_KEY, None)) pb_vars = { 'host_name': hostname, 'sriov_intf': sriov_net[consts.SRIOV_INTF_KEY], 'networking_plugin': networking_plugin, 'KUBERNETES_PATH': consts.NODE_K8S_PATH, 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), } ansible_utils.apply_playbook(consts.K8_SRIOV_ENABLE, [hostname], config_utils.get_node_user(k8s_conf), variables=pb_vars) pb_vars = config_utils.get_proxy_dict(k8s_conf) pb_vars.update( {'SRC_PACKAGE_PATH': config_utils.get_artifact_dir(k8s_conf)}) ansible_utils.apply_playbook(consts.K8_SRIOV_CNI_BUILD, variables=pb_vars) logger.info('DPDK flag is %s', dpdk_enable) if dpdk_enable is True: pb_vars = config_utils.get_proxy_dict(k8s_conf) pb_vars.update( {'SRC_PACKAGE_PATH': config_utils.get_artifact_dir(k8s_conf)}) ansible_utils.apply_playbook(consts.K8_SRIOV_DPDK_CNI, variables=pb_vars) master_nodes_tuple_3 = config_utils.get_master_nodes_ip_name_type(k8s_conf) for hostname, ip, host_type in master_nodes_tuple_3: logger.info( 'INSTALLING SRIOV BIN ON MASTER. Master Host Name - %s, ' 'Master Host Type - %s', hostname, host_type) ansible_utils.apply_playbook( consts.K8_SRIOV_CNI_BIN_INST, [ip], config_utils.get_node_user(k8s_conf), variables={ 'SRC_PACKAGE_PATH': config_utils.get_artifact_dir(k8s_conf) }) if dpdk_enable is True: logger.info('INSTALLING SRIOV DPDK BIN ON MASTER') ansible_utils.apply_playbook( consts.K8_SRIOV_DPDK_CNI_BIN_INST, [ip], config_utils.get_node_user(k8s_conf), variables={ 'SRC_PACKAGE_PATH': config_utils.get_artifact_dir(k8s_conf) }) minon_ips = config_utils.get_minion_node_ips(k8s_conf) ansible_utils.apply_playbook(consts.K8_SRIOV_DPDK_CNI_BIN_INST, [minon_ips], config_utils.get_node_user(k8s_conf), variables={ 'SRC_PACKAGE_PATH': config_utils.get_artifact_dir(k8s_conf) }) if dpdk_enable is True: logger.info('INSTALLING SRIOV DPDK BIN ON WORKERS') ansible_utils.apply_playbook(consts.K8_SRIOV_DPDK_DRIVER_LOAD, [minon_ips], config_utils.get_node_user(k8s_conf), variables={'dpdk_driver': dpdk_driver}) ansible_utils.apply_playbook( consts.K8_SRIOV_DPDK_CNI_BIN_INST, [minon_ips], config_utils.get_node_user(k8s_conf), variables={ 'SRC_PACKAGE_PATH': config_utils.get_artifact_dir(k8s_conf) })
def __kubespray(k8s_conf): pb_vars = { 'KUBESPRAY_PATH': config_utils.get_kubespray_dir(k8s_conf), 'KUBESPRAY_CLUSTER_CONF': consts.KUBESPRAY_CLUSTER_CONF, 'KUBESPRAY_ALL_CONF': consts.KUBESPRAY_ALL_CONF, 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), 'kubespray_url': config_utils.get_kubespray_url(k8s_conf), 'kubespray_branch': config_utils.get_kubespray_branch(k8s_conf), } pb_vars.update(config_utils.get_proxy_dict(k8s_conf)) ansible_utils.apply_playbook(consts.K8_CLONE_CODE, variables=pb_vars) # Setup HA load balancer lb_ips = config_utils.get_ha_lb_ips(k8s_conf) lb_ip = None ha_enabled = len(lb_ips) > 0 if ha_enabled: __launch_ha_loadbalancer(k8s_conf) lb_ip = lb_ips[0] logger.info('*** EXECUTING INSTALLATION OF KUBERNETES CLUSTER ***') hosts_tuple = config_utils.get_nodes_ip_name_type(k8s_conf) all_hosts = list() all_masters = list() all_minions = list() for name, ip, node_type in hosts_tuple: all_hosts.append((name, ip)) if node_type == consts.NODE_TYPE_MASTER: all_masters.append(name) if node_type == consts.NODE_TYPE_MINION: all_minions.append(name) kubespray_proxy_val = '' kubespray_proxy_url = config_utils.get_kubespray_proxy_dict( k8s_conf)['http_proxy'] if kubespray_proxy_url and len(kubespray_proxy_url) > 10: parsed_url = urlparse(kubespray_proxy_url) kubespray_proxy_val = "{}:{}".format(parsed_url.hostname, parsed_url.port) pb_vars = { # For inventory.cfg 'PROJ_ARTIFACT_DIR': config_utils.get_project_artifact_dir(k8s_conf), 'KUBESPRAY_INV_J2': consts.KUBESPRAY_INV_J2, 'KUBESPRAY_GROUP_ALL_J2': consts.KUBESPRAY_GROUP_ALL_J2, 'all_hosts': all_hosts, 'all_masters': all_masters, 'all_minions': all_minions, # For k8s-cluster.yml 'service_subnet': config_utils.get_service_subnet(k8s_conf), 'pod_subnet': config_utils.get_pod_subnet(k8s_conf), 'networking_plugin': config_utils.get_networking_plugin(k8s_conf), 'kube_version': config_utils.get_version(k8s_conf), 'ha_enabled': ha_enabled, 'KUBESPRAY_PATH': config_utils.get_kubespray_dir(k8s_conf), 'KUBESPRAY_ALL_CONF': consts.KUBESPRAY_ALL_CONF, 'KUBERNETES_PATH': consts.NODE_K8S_PATH, 'lb_ips': lb_ips, 'lb_ip': lb_ip, # For addons.yml 'helm_enabled': config_utils.is_helm_enabled(k8s_conf), 'metrics_server_enabled': config_utils.is_metrics_server_enabled(k8s_conf), "log_level": config_utils.get_log_level(k8s_conf), "log_file_path": consts.LOG_FILE_PATH, "logging_port": config_utils.get_logging_port(k8s_conf), 'docker_version': config_utils.get_docker_version(k8s_conf), 'kubespray_http_proxy': config_utils.get_kubespray_proxy_dict(k8s_conf)['http_proxy'], 'kubespray_https_proxy': config_utils.get_kubespray_proxy_dict(k8s_conf)['https_proxy'], 'kubespray_proxy_val': kubespray_proxy_val, } ansible_utils.apply_playbook(consts.KUBERNETES_SET_LAUNCHER, variables=pb_vars) cluster_pb_vars = ANSIBLE_VERSION_DICT cluster_pb_vars.update(DOCKER_VARS_DICT) if len(config_utils.get_ha_lb_ips(k8s_conf)) > 0: cluster_pb_vars[ 'kube_apiserver_access_address'] = config_utils.get_ha_lb_ips( k8s_conf)[0] kubespray_pb = "{}/{}".format(config_utils.get_kubespray_dir(k8s_conf), consts.KUBESPRAY_CLUSTER_CREATE_PB) inv_filename = config_utils.get_kubespray_inv_file(k8s_conf) logger.info('Calling Kubespray with inventory %s', inv_filename) ansible_utils.apply_playbook( kubespray_pb, host_user=config_utils.get_node_user(k8s_conf), variables=cluster_pb_vars, inventory_file=inv_filename, become_user='******')