def test_resize(self, resize_action_mock):
with patch(self._get_vm_client_string() +
'.begin_update') as resize_action_mock:
p = self.load_policy({
'name':
'test-azure-vm',
'resource':
'azure.vm',
'filters': [{
'type': 'value',
'key': 'name',
'op': 'eq',
'value_type': 'normalize',
'value': 'cctestvm'
}],
'actions': [{
'type': 'resize',
'vmSize': 'Standard_A2_v2'
}]
})
p.run()
expected_hardware_profile = HardwareProfile(vm_size='Standard_A2_v2')
resize_action_mock.assert_called_with(
self.fake_running_vms[0]['resourceGroup'],
self.fake_running_vms[0]['name'],
VirtualMachineUpdate(hardware_profile=expected_hardware_profile))
def create_vm_from_marketplace(self, compute_management_client,
image_offer, image_publisher, image_sku,
image_version, disk_type, vm_credentials,
computer_name, group_name, nic_id, region,
vm_name, tags, vm_size, purchase_plan,
cancellation_context):
"""
:param vm_size: (str) Azure instance type
:param compute_management_client: azure.mgmt.compute.ComputeManagementClient instance
:param image_offer: (str) image offer
:param image_publisher: (str) image publisher
:param image_sku: (str) image SKU
:param image_version: (str) image version
:param str disk_type: Disk type (HDD/SDD)
:param vm_credentials: cloudshell.cp.azure.models.vm_credentials.VMCredentials instance
:param computer_name: computer name
:param group_name: Azure resource group name (reservation id)
:param nic_id: Azure network id
:param region: Azure region
:param vm_name: name for VM
:param tags: Azure tags
:param purchase_plan: PurchasePlan
:param cancellation_context cloudshell.shell.core.driver_context.CancellationContext instance
:rtype: azure.mgmt.compute.models.VirtualMachine
"""
os_profile = self._prepare_os_profile(vm_credentials=vm_credentials,
computer_name=computer_name)
hardware_profile = HardwareProfile(vm_size=vm_size)
network_profile = NetworkProfile(
network_interfaces=[NetworkInterfaceReference(id=nic_id)])
storage_profile = StorageProfile(
os_disk=self._prepare_os_disk(disk_type),
image_reference=ImageReference(publisher=image_publisher,
offer=image_offer,
sku=image_sku,
version=image_version))
vm_plan = None
if purchase_plan is not None:
vm_plan = Plan(name=purchase_plan.name,
publisher=purchase_plan.publisher,
product=purchase_plan.product)
return self._create_vm(
compute_management_client=compute_management_client,
region=region,
group_name=group_name,
vm_name=vm_name,
hardware_profile=hardware_profile,
network_profile=network_profile,
os_profile=os_profile,
storage_profile=storage_profile,
cancellation_context=cancellation_context,
tags=tags,
vm_plan=vm_plan)
def create_vm_from_custom_image(self, compute_management_client,
image_name, image_resource_group,
disk_type, vm_credentials, computer_name,
group_name, nic_id, region, vm_name, tags,
vm_size, cancellation_context):
"""Create VM from custom image URN
:param cancellation_context:
:param str vm_size: Azure instance type
:param azure.mgmt.compute.ComputeManagementClient compute_management_client: instance
:param str image_name: Azure custom image name
:param str image_resource_group: Azure resource group
:param str disk_type: Disk type (HDD/SDD)
:param cloudshell.cp.azure.models.vm_credentials.VMCredentials vm_credentials:
:param str computer_name: computer name
:param str group_name: Azure resource group name (reservation id)
:param str nic_id: Azure network id
:param str region: Azure region
:param str vm_name: name for VM
:param tags: Azure tags
:return:
:rtype: azure.mgmt.compute.models.VirtualMachine
"""
os_profile = self._prepare_os_profile(vm_credentials=vm_credentials,
computer_name=computer_name)
hardware_profile = HardwareProfile(vm_size=vm_size)
network_profile = NetworkProfile(
network_interfaces=[NetworkInterfaceReference(id=nic_id)])
image = compute_management_client.images.get(
resource_group_name=image_resource_group, image_name=image_name)
storage_profile = StorageProfile(
os_disk=self._prepare_os_disk(disk_type),
image_reference=ImageReference(id=image.id))
return self._create_vm(
compute_management_client=compute_management_client,
region=region,
group_name=group_name,
vm_name=vm_name,
hardware_profile=hardware_profile,
network_profile=network_profile,
os_profile=os_profile,
storage_profile=storage_profile,
cancellation_context=cancellation_context,
tags=tags)
def vm_parameters(self, vhd_url, nic_id, vhd_name):
'''
:param1 vhd_url: controller vhd url
:param2 args: command line arguments
:param3 pb: testbed file details
:param4 roles: roles from testbed file - controller, se, client and server
:param5 nic_id: Azure controller NIC resource id
:param6 vhd_name: desired vhd name
'''
vm_size = self.vm_json.get('vm_size', 'Standard_F4s')
# jay-smoke-ctrl-1-osDisk-controller-18.1.1-5220.vhd
vm_name = self.vm_json.get('name')
vhd_name = vm_name + '-osDisk-' + vhd_name
self.delete_vm_vhd(vm_name=vm_name, vhd_name=vhd_name)
return VirtualMachine(
location=self.configuration.get('location'),
hardware_profile=HardwareProfile(vm_size=vm_size),
storage_profile=self.get_storage(vhd_url, vhd_name),
os_profile=self.get_os(),
network_profile=self.get_network(nic_id))
def create_virtual_machine(self, credentials, network_client, network_id,
parameters, vm_network_name):
""" Creates an Azure virtual machine using the network interface created.
Args:
credentials: A ServicePrincipalCredentials instance, that can be used to
access or create any resources.
network_client: A NetworkManagementClient instance.
network_id: The network id of the network interface created.
parameters: A dict, containing all the parameters necessary to
authenticate this user with Azure.
vm_network_name: The name of the virtual machine to use.
"""
resource_group = parameters[self.PARAM_RESOURCE_GROUP]
storage_account = parameters[self.PARAM_STORAGE_ACCOUNT]
zone = parameters[self.PARAM_ZONE]
utils.log("Creating a Virtual Machine '{}'".format(vm_network_name))
subscription_id = str(parameters[self.PARAM_SUBSCRIBER_ID])
azure_instance_type = parameters[self.PARAM_INSTANCE_TYPE]
compute_client = ComputeManagementClient(credentials, subscription_id)
auth_keys_path = self.AUTHORIZED_KEYS_FILE.format(self.ADMIN_USERNAME)
with open(auth_keys_path, 'r') as pub_ssh_key_fd:
pub_ssh_key = pub_ssh_key_fd.read()
public_keys = [SshPublicKey(path=auth_keys_path, key_data=pub_ssh_key)]
ssh_config = SshConfiguration(public_keys=public_keys)
linux_config = LinuxConfiguration(disable_password_authentication=True,
ssh=ssh_config)
os_profile = OSProfile(admin_username=self.ADMIN_USERNAME,
computer_name=vm_network_name,
linux_configuration=linux_config)
hardware_profile = HardwareProfile(vm_size=azure_instance_type)
network_profile = NetworkProfile(
network_interfaces=[NetworkInterfaceReference(id=network_id)])
virtual_hd = VirtualHardDisk(
uri='https://{0}.blob.core.windows.net/vhds/{1}.vhd'.
format(storage_account, vm_network_name))
image_hd = VirtualHardDisk(uri=parameters[self.PARAM_IMAGE_ID])
os_type = OperatingSystemTypes.linux
os_disk = OSDisk(os_type=os_type, caching=CachingTypes.read_write,
create_option=DiskCreateOptionTypes.from_image,
name=vm_network_name, vhd=virtual_hd, image=image_hd)
compute_client.virtual_machines.create_or_update(
resource_group, vm_network_name, VirtualMachine(
location=zone, os_profile=os_profile,
hardware_profile=hardware_profile,
network_profile=network_profile,
storage_profile=StorageProfile(os_disk=os_disk)))
# Sleep until an IP address gets associated with the VM.
while True:
public_ip_address = network_client.public_ip_addresses.get(resource_group,
vm_network_name)
if public_ip_address.ip_address:
utils.log('Azure VM is available at {}'.
format(public_ip_address.ip_address))
break
utils.log("Waiting {} second(s) for IP address to be available".
format(self.SLEEP_TIME))
time.sleep(self.SLEEP_TIME)
def request_instance(call=None, kwargs=None): # pylint: disable=unused-argument
'''
Request that Azure spin up a new instance
'''
global compconn # pylint: disable=global-statement,invalid-name
if not compconn:
compconn = get_conn()
vm_ = kwargs
if vm_.get('driver') is None:
vm_['driver'] = 'azurearm'
if vm_.get('location') is None:
vm_['location'] = get_location()
if vm_.get('resource_group') is None:
vm_['resource_group'] = config.get_cloud_config_value(
'resource_group', vm_, __opts__, search_global=True)
if vm_.get('name') is None:
vm_['name'] = config.get_cloud_config_value('name',
vm_,
__opts__,
search_global=True)
os_kwargs = {}
userdata = None
userdata_file = config.get_cloud_config_value('userdata_file',
vm_,
__opts__,
search_global=False,
default=None)
if userdata_file is None:
userdata = config.get_cloud_config_value('userdata',
vm_,
__opts__,
search_global=False,
default=None)
else:
if os.path.exists(userdata_file):
with salt.utils.fopen(userdata_file, 'r') as fh_:
userdata = fh_.read()
if userdata is not None:
os_kwargs['custom_data'] = base64.b64encode(userdata)
iface_data = create_interface(kwargs=vm_)
vm_['iface_id'] = iface_data['id']
disk_name = '{0}-vol0'.format(vm_['name'])
vm_username = config.get_cloud_config_value(
'ssh_username',
vm_,
__opts__,
search_global=True,
default=config.get_cloud_config_value('win_username',
vm_,
__opts__,
search_global=True))
vm_password = config.get_cloud_config_value(
'ssh_password',
vm_,
__opts__,
search_global=True,
default=config.get_cloud_config_value('win_password',
vm_,
__opts__,
search_global=True))
win_installer = config.get_cloud_config_value('win_installer',
vm_,
__opts__,
search_global=True)
if vm_['image'].startswith('http'):
# https://{storage_account}.blob.core.windows.net/{path}/{vhd}
source_image = VirtualHardDisk(uri=vm_['image'])
img_ref = None
if win_installer:
os_type = 'Windows'
else:
os_type = 'Linux'
else:
img_pub, img_off, img_sku, img_ver = vm_['image'].split('|')
source_image = None
os_type = None
img_ref = ImageReference(
publisher=img_pub,
offer=img_off,
sku=img_sku,
version=img_ver,
)
params = VirtualMachine(
name=vm_['name'],
location=vm_['location'],
plan=None,
hardware_profile=HardwareProfile(vm_size=getattr(
VirtualMachineSizeTypes, vm_['size'].lower()), ),
storage_profile=StorageProfile(
os_disk=OSDisk(
caching=CachingTypes.none,
create_option=DiskCreateOptionTypes.from_image,
name=disk_name,
vhd=VirtualHardDisk(
uri='https://{0}.blob.core.windows.net/vhds/{1}.vhd'.
format(
vm_['storage_account'],
disk_name,
), ),
os_type=os_type,
image=source_image,
),
image_reference=img_ref,
),
os_profile=OSProfile(admin_username=vm_username,
admin_password=vm_password,
computer_name=vm_['name'],
**os_kwargs),
network_profile=NetworkProfile(network_interfaces=[
NetworkInterfaceReference(vm_['iface_id']),
], ),
)
poller = compconn.virtual_machines.create_or_update(
vm_['resource_group'], vm_['name'], params)
poller.wait()
try:
return show_instance(vm_['name'], call='action')
except CloudError:
return {}
def register_image_from_snapshot(root_snapshot_id,root_device,home_snapshot_id,home_device,mi_name):
ensure_resource_group(test_group_name)
print("2 minute delay")
time.sleep(120)
ensure_virtual_network(test_group_name)
print("2 minute delay")
time.sleep(120)
nic_name="nic_"+(str(datetime.datetime.now().time())).replace(":","").replace(".","")
nic_params={'location':location,
'ipConfigurations': [
{
"name": "ipconfig1",
"properties": {
"privateIpAddressVersion": "IPv4",
"privateIPAllocationMethod": "Dynamic",
"subnet": {
"id": "/subscriptions/"+subscription_id+"/resourceGroups/"+test_group_name+"/providers/Microsoft.Network/virtualNetworks/"+test_group_name+"-vnet/subnets/default"
}
}
}
]
}
network_client.network_interfaces.begin_create_or_update(test_group_name, nic_name, nic_params)
root_snapshot = compute_client.snapshots.get(test_group_name, root_snapshot_id)
compute_client.disks.begin_create_or_update(
test_group_name,
root_device,
{
'location': location,
'creation_data': {
'create_option': DiskCreateOption.copy,
'source_resource_id': root_snapshot.id
}
}
)
home_snapshot = compute_client.snapshots.get(test_group_name, home_snapshot_id)
compute_client.disks.begin_create_or_update(
test_group_name,
home_device,
{
'location': location,
'creation_data': {
'create_option': DiskCreateOption.copy,
'source_resource_id': home_snapshot.id
}
}
)
print("5 minute delay")
time.sleep(300)
print("Create vm")
os_disk = compute_client.disks.get(test_group_name, root_device)
home_disk = compute_client.disks.get(test_group_name, home_device)
net_interface=network_client.network_interfaces.get(test_group_name,nic_name)
hp = HardwareProfile(vm_size='Standard_DS2_v2')
compute_client.virtual_machines.begin_create_or_update(
test_group_name,
mi_name,
VirtualMachine(
location=location,
name=mi_name,
hardware_profile=hp,
network_profile=NetworkProfile(
network_interfaces=[
{
'id': net_interface.id
}
],
),
storage_profile=StorageProfile(
os_disk={
'os_type': "Linux",
'name': os_disk.name,
'create_option': DiskCreateOptionTypes.attach,
'managed_disk': {
'id': os_disk.id
}
},
data_disks=[{
'lun': 0,
'name': home_disk.name,
'create_option': DiskCreateOptionTypes.attach,
'managed_disk': {
'id': home_disk.id
}
}]
),
),
)
print("2 minute delay")
time.sleep(180)
print("Create vm image")
create_image_from_vm(mi_name)
print("2 minute delay")
time.sleep(180)
# delete vm
compute_client.virtual_machines.begin_delete(test_group_name,mi_name)
print("2 minute delay")
time.sleep(180)
# delete disk
compute_client.disks.begin_delete(test_group_name,home_device)
compute_client.disks.begin_delete(test_group_name,root_device)
# delete nic
network_client.network_interfaces.begin_delete(test_group_name, nic_name)
def _process_resource(self, resource):
hardware_profile = HardwareProfile(vm_size=self.vm_size)
self.client.virtual_machines.begin_update(
resource['resourceGroup'], resource['name'],
VirtualMachineUpdate(hardware_profile=hardware_profile))
def temp_vm():
# Generate random value to avoid duplicate resource group
hash = random.getrandbits(16)
# Defining vars
base_name = 'rescue' + str(hash)
storage_name = base_name
group_name = base_name
vm_name = base_name
vnet_name = base_name
subnet_name = base_name
nic_name = base_name
os_disk_name = base_name
pub_ip_name = base_name
computer_name = base_name
admin_username='******'
admin_password='******'
region = orig_vm_location
image_publisher = 'Canonical'
image_offer = 'UbuntuServer'
image_sku = '16.04.0-LTS'
image_version = 'latest'
# Helper function to create a network interface and vnet
def create_network_interface(network_client, region, group_name, interface_name,
network_name, subnet_name, ip_name):
result = network_client.virtual_networks.create_or_update(
group_name,
network_name,
VirtualNetwork(
location=region,
address_space=AddressSpace(
address_prefixes=[
'10.1.0.0/16',
],
),
subnets=[
Subnet(
name=subnet_name,
address_prefix='10.1.0.0/24',
),
],
),
)
print('Creating Virtual Network...')
result.wait() # async operation
subnet = network_client.subnets.get(group_name, network_name, subnet_name)
result = network_client.public_ip_addresses.create_or_update(
group_name,
ip_name,
PublicIPAddress(
location=region,
public_ip_allocation_method=IPAllocationMethod.dynamic,
idle_timeout_in_minutes=4,
),
)
print('Creating Subnet...')
result.wait() # async operation
# Creating Public IP
public_ip_address = network_client.public_ip_addresses.get(group_name, ip_name)
public_ip_id = public_ip_address.id
print('Creating Public IP...')
result.wait() # async operation
result = network_client.network_interfaces.create_or_update(
group_name,
interface_name,
NetworkInterface(
location=region,
ip_configurations=[
NetworkInterfaceIPConfiguration(
name='default',
private_ip_allocation_method=IPAllocationMethod.dynamic,
subnet=subnet,
public_ip_address=PublicIPAddress(
id=public_ip_id,
),
),
],
),
)
print('Creating Network Interface...')
result.wait() # async operation
network_interface = network_client.network_interfaces.get(
group_name,
interface_name,
)
return network_interface.id
# 1. Create a resource group
print('Creating resource group ' + base_name + '...')
result = res_client.resource_groups.create_or_update(
group_name,
ResourceGroup(
location=region,
),
)
# 2. Create a storage account
print('Creating storage group ' + base_name + '...')
result = storage_client.storage_accounts.create(
group_name,
storage_name,
StorageAccountCreateParameters(
location=region,
sku=Sku(SkuName.premium_lrs),
kind=Kind.storage,
),
)
result.result()
# 3. Create the network interface using a helper function (defined below)
nic_id = create_network_interface(
network_client,
region,
group_name,
nic_name,
vnet_name,
subnet_name,
pub_ip_name,
)
# 4. Create the virtual machine
print('Creating temporary VM ' + vm_name + '...')
result = compute_client.virtual_machines.create_or_update(
group_name,
vm_name,
VirtualMachine(
location=region,
os_profile=OSProfile(
admin_username=admin_username,
admin_password=admin_password,
computer_name=computer_name,
),
hardware_profile=HardwareProfile(
vm_size='Standard_DS1_v2'
),
network_profile=NetworkProfile(
network_interfaces=[
NetworkInterfaceReference(
id=nic_id,
),
],
),
storage_profile=StorageProfile(
os_disk=OSDisk(
caching=CachingTypes.none,
create_option=DiskCreateOptionTypes.from_image,
name=os_disk_name,
vhd=VirtualHardDisk(
uri='https://{0}.blob.core.windows.net/vhds/{1}.vhd'.format(
storage_name,
os_disk_name,
),
),
),
image_reference = ImageReference(
publisher=image_publisher,
offer=image_offer,
sku=image_sku,
version=image_version,
),
),
),
)
result.wait() # async operation
# Display the public ip address
# You can now connect to the machine using SSH
public_ip_address = network_client.public_ip_addresses.get(group_name, pub_ip_name)
print('\n' + vm_name + ' has started.')
print('VM\'s public IP is {}'.format(public_ip_address.ip_address))
print('SSH Username: '******'SSH Password ' + admin_password)
print('ssh ' + admin_username + '@' + public_ip_address.ip_address)
# The process of shutting down the VM, deleting it, then removing/attaching OS disk to the temp
def disk_attach():
# Delete VM
print('Deleting VM and freeing OS disk from ' + orig_vm_name)
print('OS Disk Location ' + orig_vm_os_disk)
result = compute_client.virtual_machines.delete(sys.argv[2], orig_vm_name)
result.wait()
# Ensures no lingering lease issues
time.sleep(5)
# Attach OS disk to temporary VM
print('Attaching original OS disk to {0}'.format(vm_name))
result = compute_client.virtual_machines.create_or_update(
group_name,
vm_name,
VirtualMachine(
location=orig_vm_location,
storage_profile=StorageProfile(
data_disks=[DataDisk(
lun=0,
caching=CachingTypes.none,
create_option=DiskCreateOptionTypes.attach,
name=orig_vm_name,
vhd=VirtualHardDisk(
uri=orig_vm_os_disk
)
)]
)
)
)
result.wait()
disk_attach()