def make_user(user, settings):
resource_group = settings["resource_group"]
storage_account = settings["storage_account"]
region = settings["region"]
# create res gr
check_output_wrapper("""
az group create \
-n "{n}" \
-l "{l}"
""".format(n=resource_group, l=region),
shell=True)
print("WARN: Add user '{0}' as contributor to '{1}' manually!".format(
user, resource_group))
# # assign user to his res gr
# check_output_wrapper(
# """
# az role assignment create \
# --assignee {user} \
# --role Contributor \
# --resource-group {rg}
# """.format(user=user, rg=resource_group),
# shell=True
# )
# create storage account
check_output_wrapper("""
az storage account create \
-l {l} \
-n {n} \
-g {g} \
--sku Standard_LRS
""".format(l=region, n=storage_account, g=resource_group),
shell=True)
# grant images access
images = [
"cluster1_image1_eastus", "cluster2_image1_eastus",
"cluster3_image1_eastus", "ubuntu_gpu_image1_eastus"
]
for image in images:
pass
# check_output_wrapper(
# """
# az role assignment create \
# --role Contributor \
# --assignee "{user}" \
# --scope "/subscriptions/{s}/resourceGroups/admin_resources/providers/Microsoft.Compute/images/{image}"
# """.format(image=image, user=user, s=get_subscription_id()),
# shell=True
# )
print("WARN: Add user '{0}' as contributor to 'admin_resources' manually!".
format(user))
print(user, "done")
def create_image(rg_name, image_name, source, region):
check_output_wrapper("""
az image create \
-g {rg_name} \
-n {image_name} \
--source "{source}" \
--os-type linux \
-l {region}
""".format(**locals()),
shell=True)
def assign_role_to_student_group(IMAGE_NAME):
# for students group
check_output_wrapper("""
az role assignment create \
--role Contributor \
--assignee "{g}" \
--scope "/subscriptions/{s}/resourceGroups/admin_resources/providers/Microsoft.Compute/images/{image}"
""".format(image=IMAGE_NAME,
g=get_ad_group_id(AD_GROUP),
s=get_subscription_id()),
shell=True)
def create_image(RG_NAME, IMAGE_NAME, SOURCE, REGION):
check_output_wrapper("""
az image create \
-g {RG_NAME} \
-n {IMAGE_NAME} \
--source "{SOURCE}" \
--os-type linux \
-l {REGION}
""".format(**locals()),
shell=True)
create_image_lock(RG_NAME, IMAGE_NAME)
assign_role_to_student_group(IMAGE_NAME)
def get_vm_status(vm_ids):
out = check_output_wrapper("""
az vm show -d --ids {0}
""".format(" ".join(vm_ids)),
shell=True)
out = json.loads(out)
return out
def get_vm_status(VM, RG):
out = check_output_wrapper("""
az vm show -d -n {0} -g {1}
""".format(VM, RG),
shell=True)
if out.strip() == "":
return None
out = json.loads(out)
power_state = out["powerState"]
return power_state
def list_orphaned_disks():
out = check_output_wrapper("""
az disk list
""",
shell=True)
if out.strip() == "":
return None
out = json.loads(out)
out = [x for x in out if x["ownerId"] is None]
out = [x["id"] for x in out]
return out
from utils import check_output_wrapper
# import pandas as pd
# pd.read_json("users.json", orient="records").to_excel("users.xlsx")
from utils import generate_pass, STUDENT_COUNT, AD_DOMAIN
users = []
for idx in range(STUDENT_COUNT):
# if (idx + 1) <= 88:
# continue
password = generate_pass()
user = "******".format(idx + 1)
out = check_output_wrapper("""
az ad user create \
--user-principal-name "{u}@{d}" \
--display-name "{u}" \
--password {p} \
--mail-nickname "{u}"
""".format(p=password, u=user, d=AD_DOMAIN),
shell=True)
out = json.loads(out)
userId = out["objectId"]
users.append([user, password, userId])
print(user, "done")
df = pd.DataFrame(users, columns=["user", "password", "userId"])
df.to_json("users.json", orient="records")
def create_image_lock(RG_NAME, IMAGE_NAME):
check_output_wrapper("""
az lock create -t CanNotDelete -n lock -g {RG_NAME} --resource-name "{IMAGE_NAME}" \
--resource-type "Microsoft.Compute/images"
""".format(**locals()),
shell=True)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import subprocess
import pandas as pd
from utils import RG_TEMPLATE, check_output_wrapper
users = pd.read_json("users.json", orient="records")
for idx, (_, row) in enumerate(users.iterrows()):
if idx < 3:
continue
row = dict(row)
user = row["user"]
resGrName = RG_TEMPLATE.format(user)
# create res gr
check_output_wrapper(
"""
az group delete \
-n "{n}" --yes --no-wait
""".format(n=resGrName),
shell=True
)
print(user, "done")
from utils import RG_TEMPLATE, STORAGE_ACCOUNT_TEMPLATE, region_by_user, check_output_wrapper
users = pd.read_json("users.json", orient="records")
for idx, (_, row) in enumerate(users.iterrows()):
# if idx + 1 <= 88:
# continue
row = dict(row)
user = row["user"]
userId = row["userId"]
rgName = RG_TEMPLATE.format(user)
region = region_by_user[user]
# create res gr
check_output_wrapper("""
az group create \
-n "{n}" \
-l "{l}"
""".format(n=rgName, l=region),
shell=True)
# assign user to his res gr
check_output_wrapper("""
az role assignment create \
--assignee {userId} \
--role Contributor \
--resource-group {rg}
""".format(userId=userId, rg=rgName),
shell=True)
# create storage account
storName = STORAGE_ACCOUNT_TEMPLATE.format(user)
check_output_wrapper("""
az storage account create \
-l {l} \
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import subprocess
import pandas as pd
from utils import AD_GROUP, get_ad_group_id, check_output_wrapper
check_output_wrapper("""
az ad group create \
--display-name {g} \
--mail-nickname {g}
""".format(g=AD_GROUP),
shell=True)
users = pd.read_json("users.json", orient="records")
group_id = get_ad_group_id(AD_GROUP)
for _, row in users.iterrows():
row = dict(row)
userId = row["userId"]
check_output_wrapper("""
az ad group member add \
--group {g} \
--member-id {u}
""".format(g=AD_GROUP, u=userId),
shell=True)
print(row["user"], "added to group")
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import subprocess
from utils import STUDENT_COUNT, AD_DOMAIN, check_output_wrapper
for idx in range(STUDENT_COUNT):
user = "******".format(idx + 1)
check_output_wrapper("""
az ad user delete \
--upn-or-object-id "{u}@{d}" \
""".format(u=user, d=AD_DOMAIN),
shell=True)
print(user, "deleted")
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import subprocess
import pandas as pd
from utils import RG_TEMPLATE, STORAGE_ACCOUNT_TEMPLATE, get_storage_key, check_output_wrapper
users = pd.read_json("users.json", orient="records")
CONTAINER = "images"
PATTERN = "ubuntugpu2.vhd"
for _, row in users.iterrows():
row = dict(row)
user = row["user"]
userId = row["userId"]
resGrName = RG_TEMPLATE.format(user)
storName = STORAGE_ACCOUNT_TEMPLATE.format(user)
userKey = get_storage_key(storName, resGrName)
check_output_wrapper("""
az storage blob delete \
--container-name {cont} \
--account-key {key} \
--account-name {acc} \
--name {fn}
""".format(cont=CONTAINER, fn=PATTERN, acc=storName, key=userKey),
shell=True)
print(user, "done")
def get_vm_list():
out = check_output_wrapper("""
az vm list
""", shell=True)
out = json.loads(out)
return out