def createhelmincluster(iotslice, cluster, helmpath, configfile, name):
clusterhelmip = iotorchutils.getk8sclusterhelmip(cluster, configfile)
clusterhelmport = iotorchutils.getk8sclusterhelmport(cluster, configfile)
if clusterhelmip == None:
print("IP Address for cluster %s not found" % cluster)
return False
releasename = name + "-" + iotslice
chart = ChartBuilder({
'name': name,
'source': {
'type': 'directory',
'location': helmpath
}
})
t = Tiller(host=clusterhelmip, port=clusterhelmport)
t.install_release(chart.get_helm_chart(),
dry_run=False,
namespace=iotslice,
name=releasename)
return True
def install(self,
namespace,
dry_run=False,
name=None,
values=None,
wait=None):
if self.sub:
return [
c.install(namespace, dry_run, name, values[i], wait)
for i, c in enumerate(self.sub)
]
try:
chart = ChartBuilder(dict(name=self.name, source=self.source))
res = self.get_tiller().install_release(chart.get_helm_chart(),
dry_run=dry_run,
namespace=namespace,
name=name,
values=values,
wait=wait)
if not self.apply_extra_yaml(self.crd):
logger.error('Failed to apply crd %s', self.crd)
if not self.apply_extra_yaml(self.rbac):
logger.error('Failed to apply rbac %s', self.rbac)
except Exception:
raise
finally:
chart.source_cleanup()
return res
def test_get_templates(self, _0, _1):
cb = ChartBuilder({'name': '', 'source': {}})
cb.source_directory = 'test'
t = cb.get_templates()
cb._logger.warn.assert_called()
self.assertEquals(len(t), 1)
self.assertIsInstance(t[0], Template)
def getfiles(self):
chart = ChartBuilder(
{"name": self.chart_name,
"source": {
"type": self.source_type,
"location": self.source_location
}
})
return chart.get_files()
def loadChart(self):
chart = ChartBuilder(
{"name": self.chart_name,
"source": {
"type": self.source_type,
"location": self.source_location
}
})
self.setChart(chart.get_helm_chart())
def getvalues(self):
chart = ChartBuilder(
{"name": self.chart_name,
"source": {
"type": self.source_type,
"location": self.source_location
}
})
rawstring = chart.get_values()
v = str(str(rawstring).split("raw: ",1)[1][1:][:-2].replace("\\n","\n"))
ydata = yaml.safe_load(v)
return ydata
def deploy():
chart_path = from_repo('https://kubernetes-charts.storage.googleapis.com/',
'mariadb')
#print(chart_path)
chart = ChartBuilder({
'name': 'mongodb',
'source': {
'type': 'directory',
'location': '/tmp/pyhelm-dMLypC/mariadb'
}
})
tiller_ins = Tiller('10.102.187.89', '44134')
tiller_ins.install_release(chart.get_helm_chart(),
dry_run=False,
namespace='default')
return "hello kuber"
def test_unknown_type_with_parent(self):
cb = ChartBuilder({'name': 'bar',
'parent': 'foo',
'source': {'location': 'test', 'type': 'none'}})
self.assertIsNone(cb.source_directory)
cb._logger.info.assert_called()
cb._logger.exception.assert_called()
def deployTemplate(deploy_id):
obj = Deployment.objects.get(id=deploy_id)
# featureApp = obj.envTemplate.featureApp.all()
tmp_dir = "/tmp/%s" % (obj.envName)
if not os.path.exists(tmp_dir):
os.mkdir(tmp_dir)
images = obj.imageVersion.exclude(baseAppFlag=1)
for image in images:
chart_name = "%s-%s" % (obj.envName, image.chartAddress.split("/")[-1])
repo = "/".join(image.chartAddress.split("/")[0:-1])
t = Tiller(settings.TILLER_SERVER["address"], settings.TILLER_SERVER["port"])
chart = ChartBuilder(
{'name': chart_name, 'source': {'type': 'directory', 'location': "{}/helmCharts/{}/{}".format(settings.PROJECT_ROOT, repo.split("/")[-1], chart_name)}})
# chart.get_metadata()
print "{time} {fileName} {num} {func} {args} ".format(time=datetime.datetime.now(),
fileName=os.path.basename(__file__),
func=sys._getframe(
).f_code.co_name,
num=sys._getframe().f_lineno,
args="start to install {} chart in namespace {}".format(
chart_name, obj.envName))
try:
install_result = t.install_release(chart.get_helm_chart(), dry_run=False, namespace=obj.envName,
name=chart_name,
values={"service": {"type": "NodePort"}, "ingress": {"enabled": False}})
print "{time} {fileName} {num} {func} {args} ".format(time=datetime.datetime.now(),
fileName=os.path.basename(__file__),
func=sys._getframe(
).f_code.co_name,
num=sys._getframe().f_lineno,
args="result of installed chart: {}".format(
install_result))
DeployHistory.objects.create(deploy=obj, msg=str(install_result),
chartTmpDir=chart_name)
except Exception, e:
print "{time} {fileName} {num} {func} {args} ".format(time=datetime.datetime.now(),
fileName=os.path.basename(__file__),
func=sys._getframe(
).f_code.co_name,
num=sys._getframe().f_lineno,
args="failed to install helm chart {} in namespace {}, reson is {}".format(
chart_name, obj.envName, e))
return False
def test_git(self, _0):
cb = ChartBuilder({'name': 'foo',
'source': {'location': 'test',
'type': 'git',
'subpath': 'foo'}})
self.assertEqual(cb.source_directory, '/test/foo')
cb._logger.info.assert_called()
cb._logger.exception.assert_not_called()
def install_release(chart_name, repo, namespace):
"""
Installs a chart.
Args:
chart_name (str)
repo (str)
namespace (str)
Returns:
{
'release': Name of the helm release,
'status': Status of the installation
}
"""
try:
chart_path = from_repo(repo, chart_name)
except requests.RequestException as e:
log(e)
return {
'Error': 'Helm repository unreachable.',
}
chart = ChartBuilder({
'name': chart_name,
'source': {
'type': 'directory',
'location': chart_path,
},
})
try:
tiller = get_tiller()
response = tiller.install_release(chart.get_helm_chart(),
dry_run=False,
namespace=namespace)
status_code = response.release.info.status.code
return {
'release': response.release.name,
'status': response.release.info.status.Code.Name(status_code),
}
except grpc.RpcError as e:
log(e.details())
status_code = e.code()
if grpc.StatusCode.UNAVAILABLE == status_code:
return {
'Error': 'Tiller unreachable.',
}
def get_chart(self, chart_name="", type="", location=""):
chart = ChartBuilder({
"name": chart_name,
"source": {
"type": type,
"location": location
}
})
return chart
def test_source_cleanup(self, mock_repo):
ChartBuilder({
"name": "foo",
"source": {
"type": "directory",
"location": "test"
}
}).source_cleanup()
mock_repo.source_cleanup.assert_called()
def test_source_cleanup(self, mock_repo):
ChartBuilder({
'name': 'foo',
'source': {
'type': 'directory',
'location': 'test'
}
}).source_cleanup()
mock_repo.source_cleanup.assert_called()
def chart_install(chart_data):
"""Third sample asynchronous task. Install a helm chart on a host"""
chart = ChartBuilder(
{
"name": chart_data["name"],
"source": {
"type": chart_data["source_type"],
"location": chart_data["source_location"],
},
}
)
if "dry_run" in chart_data:
dry_run = True
else:
dry_run = False
tiller = get_tiller(chart_data)
return tiller.install_release(
chart.get_helm_chart(), dry_run=dry_run, namespace=chart_data["namespace"]
)
def test_get_helm_chart_exists(self, _0, _1, _2, _3, _4):
cb = ChartBuilder({'name': 'foo', 'source': {}, 'dependencies': [
{'name': 'bar', 'source': {}}
]})
cb._helm_chart = '123'
self.assertEqual(cb.get_helm_chart(), '123')
cb._helm_chart = None
cb.get_helm_chart()
cb._logger.info.assert_called()
def test_directory(self):
cb = ChartBuilder({
'name': 'foo',
'source': {
'location': 'dir',
'type': 'directory'
}
})
self.assertEqual(cb.source_directory, 'dir/')
cb._logger.info.assert_called()
cb._logger.exception.assert_not_called()
def test_directory(self):
cb = ChartBuilder({
"name": "foo",
"source": {
"location": "dir",
"type": "directory"
}
})
self.assertEqual(cb.source_directory, "dir/")
cb._logger.info.assert_called()
cb._logger.exception.assert_not_called()
def test_repo(self, _0):
cb = ChartBuilder({
"name": "foo",
"source": {
"location": "test",
"type": "repo"
}
})
self.assertEqual(cb.source_directory, "/test/")
cb._logger.info.assert_called()
cb._logger.exception.assert_not_called()
def test_unknown_type_with_parent(self):
cb = ChartBuilder({
"name": "bar",
"parent": "foo",
"source": {
"location": "test",
"type": "none"
},
})
self.assertIsNone(cb.source_directory)
cb._logger.info.assert_called()
cb._logger.exception.assert_called()
def createChart(self):
chart = ChartBuilder(
{"name": self.chart_name,
"source": {
"type": self.source_type,
"location": self.source_location
}
})
rawstring = chart.get_values()
v = str(str(rawstring).split("raw: ",1)[1][1:][:-2].replace("\\n","\n"))
ydata = yaml.safe_load(v)
# print(ydata)
ydata["host"] = "this.is.lit.local"
newyaml = yaml.safe_dump(ydata)
rawl = Config(raw=newyaml)
dependencies = []
helm_chart = Chart(
metadata=chart.get_metadata(),
templates=chart.get_templates(),
dependencies=dependencies,
values=rawl,
files=chart.get_files(),
)
self.chart = helm_chart
tiller = Tiller(self.tiller_host)
tiller.install_release(
self.chart,
dry_run=False,
namespace=self.kubernetes_namespace)
def test_get_helm_chart_exists(self, _0, _1, _2, _3, _4):
cb = ChartBuilder({
"name": "foo",
"source": {},
"dependencies": [{
"name": "bar",
"source": {}
}],
})
cb._helm_chart = "123"
self.assertEqual(cb.get_helm_chart(), "123")
cb._helm_chart = None
cb.get_helm_chart()
cb._logger.info.assert_called()
def test_no_type(self):
cb = ChartBuilder({'name': '', 'source': {}})
self.assertIsNone(cb.source_directory)
cb._logger.exception.assert_called()
def create_gcloud(num_workers, release, kubernetes_version, machine_type,
disk_size, num_cpus, num_gpus, gpu_type, zone, project,
preemptible, custom_value):
from google.cloud import container_v1
import google.auth
from googleapiclient import discovery, http
credentials, default_project = google.auth.default()
if not project:
project = default_project
# create cluster
gclient = container_v1.ClusterManagerClient()
name = '{}-{}'.format(release, num_workers)
name_path = 'projects/{}/locations/{}/'.format(project, zone)
extraargs = {}
if num_gpus > 0:
extraargs['accelerators'] = [container_v1.types.AcceleratorConfig(
accelerator_count=num_gpus, accelerator_type=gpu_type)]
# delete existing firewall, if any
firewalls = discovery.build(
'compute', 'v1', cache_discovery=False).firewalls()
existing_firewalls = firewalls.list(project=project).execute()
fw_name = '{}-firewall'.format(name)
if any(f['name'] == fw_name for f in existing_firewalls['items']):
response = {}
while not hasattr(response, 'status'):
try:
response = firewalls.delete(
project=project, firewall=fw_name).execute()
except http.HttpError as e:
if e.resp.status == 404:
response = {}
break
click.echo("Wait for firewall to be available for deletion")
sleep(5)
response = {}
while hasattr(response, 'status') and response.status < response.DONE:
response = gclient.get_operation(
None, None, None, name=response.selfLink)
sleep(1)
# create cluster
cluster = container_v1.types.Cluster(
name=name,
initial_node_count=num_workers,
node_config=container_v1.types.NodeConfig(
machine_type=machine_type,
disk_size_gb=disk_size,
preemptible=preemptible,
oauth_scopes=[
'https://www.googleapis.com/auth/devstorage.full_control',
],
**extraargs
),
addons_config=container_v1.types.AddonsConfig(
http_load_balancing=container_v1.types.HttpLoadBalancing(
disabled=True,
),
horizontal_pod_autoscaling=
container_v1.types.HorizontalPodAutoscaling(
disabled=True,
),
kubernetes_dashboard=container_v1.types.KubernetesDashboard(
disabled=True,
),
network_policy_config=container_v1.types.NetworkPolicyConfig(
disabled=False,
),
),
logging_service=None,
monitoring_service=None
)
response = gclient.create_cluster(None, None, cluster, parent=name_path)
# wait for cluster to load
while response.status < response.DONE:
response = gclient.get_operation(
None, None, None, name=name_path + '/' + response.name)
sleep(1)
if response.status != response.DONE:
raise ValueError('Cluster creation failed!')
cluster = gclient.get_cluster(
None, None, None, name=name_path + '/' + name)
auth_req = google.auth.transport.requests.Request()
credentials.refresh(auth_req)
configuration = client.Configuration()
configuration.host = f'https://{cluster.endpoint}:443'
configuration.verify_ssl = False
configuration.api_key = {'authorization': 'Bearer ' + credentials.token}
client.Configuration.set_default(configuration)
if num_gpus > 0:
with request.urlopen(GCLOUD_NVIDIA_DAEMONSET) as r:
dep = yaml.safe_load(r)
dep['spec']['selector'] = {
'matchLabels': dep['spec']['template']['metadata']['labels']
}
dep = client.ApiClient()._ApiClient__deserialize(dep, 'V1DaemonSet')
k8s_client = client.AppsV1Api()
k8s_client.create_namespaced_daemon_set('kube-system', body=dep)
# create tiller service account
client.CoreV1Api().create_namespaced_service_account(
'kube-system',
{
'apiVersion': 'v1',
'kind': 'ServiceAccount',
'metadata': {
'name': 'tiller',
'generateName': 'tiller',
'namespace': 'kube-system',
},
})
client.RbacAuthorizationV1beta1Api().create_cluster_role_binding(
{
'apiVersion': 'rbac.authorization.k8s.io/v1beta1',
'kind': 'ClusterRoleBinding',
'metadata': {
'name': 'tiller'
},
'roleRef': {
'apiGroup': 'rbac.authorization.k8s.io',
'kind': 'ClusterRole',
'name': 'cluster-admin'
},
'subjects': [
{
'kind': 'ServiceAccount',
'name': 'tiller',
'namespace': 'kube-system'
}
]
})
# deploy tiller
tiller_service = yaml.safe_load(TILLER_MANIFEST_SERVICE)
tiller_dep = yaml.safe_load(TILLER_MANIFEST_DEPLOYMENT)
client.CoreV1Api().create_namespaced_service(
'kube-system',
tiller_service)
client.ExtensionsV1beta1Api().create_namespaced_deployment(
'kube-system',
tiller_dep)
sleep(1)
pods = client.CoreV1Api().list_namespaced_pod(
namespace='kube-system',
label_selector='app=helm'
)
tiller_pod = pods.items[0]
while True:
# Wait for tiller
resp = client.CoreV1Api().read_namespaced_pod(
namespace='kube-system',
name=tiller_pod.metadata.name
)
if resp.status.phase != 'Pending':
break
sleep(5)
# kubernetes python doesn't currently support port forward
# https://github.com/kubernetes-client/python/issues/166
ports = 44134
# resp = stream(
# client.CoreV1Api().connect_get_namespaced_pod_portforward,
# name=tiller_pod.metadata.name,
# namespace=tiller_pod.metadata.namespace,
# ports=ports
# )
with subprocess.Popen([
'kubectl',
'port-forward',
'--namespace={}'.format(tiller_pod.metadata.namespace),
tiller_pod.metadata.name, '{0}:{0}'.format(ports),
'--server={}'.format(configuration.host),
'--token={}'.format(credentials.token),
'--insecure-skip-tls-verify=true']) as portforward:
sleep(5)
# install chart
tiller = Tiller('localhost')
chart = ChartBuilder(
{
'name': 'mlbench-helm',
'source': {
'type': 'git',
'location': 'https://github.com/mlbench/mlbench-helm'
}})
values = {
'limits': {
'workers': num_workers - 1,
'gpu': num_gpus,
'cpu': num_cpus
}
}
if custom_value:
# merge custom values with values
for cv in custom_value:
key, v = cv.split("=", 1)
current = values
key_path = key.split(".")
for k in key_path[:-1]:
if k not in current:
current[k] = {}
current = current[k]
current[key_path[-1]] = v
tiller.install_release(
chart.get_helm_chart(),
name=name,
wait=True,
dry_run=False,
namespace='default',
values=values)
portforward.terminate()
# open port in firewall
mlbench_client = ApiClient(in_cluster=False, load_config=False)
firewall_body = {
"name": fw_name,
"direction": "INGRESS",
"sourceRanges": "0.0.0.0/0",
"allowed": [
{"IPProtocol": "tcp", "ports": [mlbench_client.port]}
]
}
firewalls.insert(project=project, body=firewall_body).execute()
config = get_config()
config.set('general', 'provider', 'gke')
config.set('gke', 'cluster', cluster.endpoint)
write_config(config)
click.echo("MLBench successfully deployed")
def test_get_templates(self, _0, _1, _2):
t = ChartBuilder({'name': 'foo'}).get_templates()
ChartBuilder._logger.warn.assert_called()
self.assertEqual(len(t), 1)
self.assertIsInstance(t[0], Template)
def test_get_values(self, _0, _1, _2):
v = ChartBuilder({}).get_values()
self.assertIsInstance(v, Config)
def test_get_values_not_found(self, _0):
ChartBuilder({}).get_values()
ChartBuilder._logger.warn.assert_called()
def test_get_files(self, _0, _1, _2):
f = ChartBuilder({}).get_files()
self.assertEqual(len(f), 1)
self.assertIsInstance(f[0], Any)
def test_get_metadata(self, _0, _1):
m = ChartBuilder({}).get_metadata()
self.assertIsInstance(m, Metadata)
#!/usr/bin/python3
# By Tedezed
# Source: https://github.com/flaper87/pyhelm
from pyhelm.chartbuilder import ChartBuilder
from pyhelm.tiller import Tiller
import subprocess, time
tiller_host = '127.0.0.1'
mode_dry_run = False
mode_shell = True
subprocess.call('''kubectl port-forward $(kubectl get pod --all-namespaces | awk '{ print $2 }' | grep tiller) -n kube-system 44134:44134 &''', shell=mode_shell)
subprocess.call('''kubectl port-forward $(kubectl get pod --all-namespaces | awk '{ print $2 }' | grep tiller) -n kube-system 44135:44135 &''', shell=mode_shell)
time.sleep(3)
try:
tiller = Tiller(tiller_host)
chart = ChartBuilder({"name": "nginx-ingress", "source": {"type": "repo", "location": "https://kubernetes-charts.storage.googleapis.com"}})
output_install = tiller.install_release(chart.get_helm_chart(), dry_run=mode_dry_run, name="test-tiller-python2", namespace="test-tiller-python")
print(output_install)
subprocess.call('''killall kubectl''', shell=mode_shell)
print("[INFO] Success")
except Exception as e:
subprocess.call('''killall kubectl''', shell=mode_shell)
print("[ERROR] %s" % e)
# -*- coding:utf-8 -*-
#from pyhelm.repo import RepoUtils
from pyhelm.repo import from_repo
import pdb;pdb.set_trace()
from pyhelm.chartbuilder import ChartBuilder
from pyhelm.tiller import Tiller
import pdb;pdb.set_trace()
tiller_host='127.0.0.1'
tiller_port='44134'
#chart_path = RepoUtils.from_repo('https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts', 'mariadb')
chart_path = from_repo('https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts', 'mariadb')
chart = ChartBuilder({'name': 'mariadb', 'source': {'type': 'directory', 'location': chart_path}})
# 构建chart元数据
#chart = ChartBuilder({'name': 'mongodb', 'source': {'type': 'directory', 'location': '/tmp/pyhelm-kibwtj8d/mongodb'}})
#chart = ChartBuilder({'name': 'stable/mongodb', 'version':'0.4.27', 'source': {'type': 'repo', 'version': '0.4.27', 'location': 'https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'}})
# 生成tiller连接实例
tiller_ins = Tiller(tiller_host, tiller_port)
import pdb;pdb.set_trace()
# 安装 release
tiller_ins.install_release(chart.get_helm_chart(), dry_run=False, namespace='default')
# 列出 release
tiller_ins.list_releases(limit=0, status_codes=[], namespace=None)
# 删除 release
tiller_ins.uninstall_release(release_name)
# 获得 release 版本历史
tiller_ins.get_history(name, max=MAX_HISTORY)
# 回滚 release
tiller_ins.rollback_release(name, version, timeout=REQUEST_TIMEOUT)
