def __init__(self, provider_config, cluster_name):
NodeProvider.__init__(self, provider_config, cluster_name)
kwargs = {}
if "subscription_id" in provider_config:
kwargs["subscription_id"] = provider_config["subscription_id"]
try:
self.compute_client = get_client_from_cli_profile(
client_class=ComputeManagementClient, **kwargs)
self.network_client = get_client_from_cli_profile(
client_class=NetworkManagementClient, **kwargs)
self.resource_client = get_client_from_cli_profile(
client_class=ResourceManagementClient, **kwargs)
except CLIError as e:
if str(e) != "Please run 'az login' to setup account.":
raise
else:
logger.info("CLI profile authentication failed. Trying MSI")
credentials = MSIAuthentication()
self.compute_client = ComputeManagementClient(
credentials=credentials, **kwargs)
self.network_client = NetworkManagementClient(
credentials=credentials, **kwargs)
self.resource_client = ResourceManagementClient(
credentials=credentials, **kwargs)
self.lock = RLock()
# cache node objects
self.cached_nodes = {}
def compute_client(self):
if self._compute_client is None:
with SingletonByArgsMeta.lock:
if self._compute_client is None:
self._compute_client = ComputeManagementClient(self._service_credentials, self._subscription_id)
return self._compute_client
def get_client(self, client_type):
"""
Return resource management client type based on what's requested
"""
try:
# Check to see if credentials exist before returning an azure client object
if self.credentials:
# there is probably a better whay than a big case statement
if client_type == "ComputeManagementClient":
return (ComputeManagementClient(self.credentials,
self.subscription_id))
elif client_type == "ResourceGraphClient":
return (ResourceGraphClient(self.credentials,
base_url=None))
else:
raise NotImplementedError(
"No such client type {} supported".format(client_type))
else:
raise ServicePrincipalError(
"Missing or bad credentials for tenant {}".format(
self.tenant_name))
except ServicePrincipalError as e:
raise (e)
except NotImplementedError as e:
raise (e)
except Exception as e:
raise (e)
def init_resources():
"""
Init resources
"""
global resource_client
global network_client
global compute_client
# Acquire the Azure Subscription Id
try:
azure_subscription_id = os.environ["AZURE_SUBSCRIPTION_ID"]
except KeyError:
print(
'Error: Enviroment variable "AZURE_SUBSCRIPTION_ID" does not exist'
)
sys.exit(1)
# Acquire a credential object using CLI-based authentication
credential = DefaultAzureCredential()
# Obtain the management object for resources
resource_client = ResourceManagementClient(credential,
azure_subscription_id)
# Obtain the management object for networks
network_client = NetworkManagementClient(credential, azure_subscription_id)
# Obtain the management object for virtual machines
compute_client = ComputeManagementClient(credential, azure_subscription_id)
# Provision the resource group
resource_group_result = create_resource_group(resource_client)
return resource_group_result
def handle_dead_uuid(vmss_data,uuid):
subscriptionId = vmss_data['context']['subscriptionId']
resourceGroupName = vmss_data['context']['resourceGroupName']
vmScaleSetName = vmss_data['context']['resourceName']
location = vmss_data['context']['resourceRegion']
credential = CredentialWrapper()
compute = ComputeManagementClient(credential,subscriptionId)
vmScaleSetData = get_vmss_data(compute,vmScaleSetName,resourceGroupName)
vmScaleSetTags = vmScaleSetData.tags
if vmss_data['disaster']:
correlationId = vmss_data['data']['context']['activityLog']['correlationId']
if uuid in vmScaleSetTags:
if vmScaleSetTags[uuid] == correlationId:
logging.info('No need to update dead_uuid_list Tag,As this is a Re-Run for correlationId:{}'.format(correlationId))
return True
else:
logging.info('Set Existing uuid to CorrelationID mapping ==> {}:{}'.format(uuid,correlationId))
vmScaleSetTags[uuid] = correlationId
else:
vmScaleSetTags[uuid] = correlationId
logging.info('Set uuid to CorrelationID mapping for First Time==> {}:{}'.format(uuid,correlationId))
try:
dead_uuid_list = vmScaleSetTags['dead_uuid_list']
if len(dead_uuid_list) > 0:
dead_uuid_list = dead_uuid_list.split(',')
dead_uuid_list.append(uuid)
updated_dead_uuid_list = ','.join(set(dead_uuid_list))
vmScaleSetTags['dead_uuid_list'] = updated_dead_uuid_list
else:
vmScaleSetTags['dead_uuid_list'] = uuid
except KeyError:
vmScaleSetTags['dead_uuid_list'] = uuid
logging.info('Updating Scale Set : {} with tag dead_uuid_list with value {}'.format(vmScaleSetName,vmScaleSetTags['dead_uuid_list']))
create_vmss_tag(compute,vmScaleSetName,resourceGroupName,location,vmScaleSetTags)
def create_connection_from_config():
""" Creates a new Azure api connection """
resource_client = None
compute_client = None
network_client = None
try:
os.environ['AZURE_AUTH_LOCATION']
except KeyError:
try:
subscription_id = os.environ['AZURE_SUBSCRIPTION_ID']
credentials = ServicePrincipalCredentials(
client_id=os.environ['AZURE_CLIENT_ID'],
secret=os.environ['AZURE_CLIENT_SECRET'],
tenant=os.environ['AZURE_TENANT_ID']
)
except KeyError:
sys.exit("No Azure Connection Defined")
else:
resource_client = ResourceManagementClient(credentials, subscription_id)
compute_client = ComputeManagementClient(credentials, subscription_id)
network_client = NetworkManagementClient(credentials, subscription_id)
else:
resource_client = get_client_from_auth_file(ResourceManagementClient)
compute_client = get_client_from_auth_file(ComputeManagementClient)
network_client = get_client_from_auth_file(NetworkManagementClient)
return resource_client, compute_client, network_client
def __init__(self, metadata):
self.metadata = metadata
self.credentials = get_credentials()
self.compute_client = ComputeManagementClient(self.credentials, SUBSCRIPTION_ID)
self.network_client = NetworkManagementClient(self.credentials, SUBSCRIPTION_ID)
self.dns_client = None
def get_resource_group_details(subscription_id, creds, resource_group_name):
compute_client = ComputeManagementClient(creds, subscription_id)
model = ResourceGroupDetails()
model.vms = list(compute_client.virtual_machines.list(resource_group_name))
return model
def __init__(self, azure_subscription_id, azure_tenant_id, azure_client_id,
azure_client_secret, azure_location, azure_resource_group,
azure_vmss_name):
LOGGER.debug("Provider Azure used")
if (azure_subscription_id == "" or azure_tenant_id == ""
or azure_client_id == "" or azure_client_secret == ""):
LOGGER.error(
"Missing Azure credentials. Please provide --azure-subscription-id "
"--azure-tenant-id --azure-client-id --azure-client-secret")
sys.exit(1)
if azure_location == "" or azure_resource_group == "" or azure_vmss_name == "":
LOGGER.error(
"Missing Azure Informations. Please verify --azure-location "
"--azure-resource-group --azure-vmss-name")
sys.exit(1)
subscription_id = azure_subscription_id
LOGGER.debug("Azure - Service Principal Credentials Init")
credentials = ServicePrincipalCredentials(client_id=azure_client_id,
secret=azure_client_secret,
tenant=azure_tenant_id)
LOGGER.debug("Azure - Compute Client Init")
self.compute_client = ComputeManagementClient(credentials,
subscription_id)
self.azure_location = azure_location
self.azure_resource_group = azure_resource_group
self.azure_vmss_name = azure_vmss_name
def cmc(self):
if not self._cmc:
self.rmc().providers.register('Microsoft.Compute')
self._cmc = ComputeManagementClient(self.get_mgmt_credentials())
self._cmc.long_running_operation_initial_timeout = 3
self._cmc.long_running_operation_retry_timeout = 5
return self._cmc
def __init__(self, instance_type=None, region=None):
cred_json = get_credentials_by_type(cloud_type="azure")
if len(cred_json) > 0:
credentials = cred_json[0][
'credentials'] if 'credentials' in cred_json[0] else {}
else:
raise IOError("please add credentials for %s." % "azure")
if not set(("subscription_id", "client_id", "client_secret",
"tenant_id")).issubset(credentials):
raise IOError(
"subscription_id, client_id, secret and tenant are required in credentials for %s."
% "azure")
self.instance_type = instance_type
credentials, subscription_id = get_credentials(credentials)
self.client = instance_type_class_mapping.get(self.instance_type)(
credentials, subscription_id)
self.resource_client = ResourceManagementClient(
credentials, subscription_id)
self.networkClient = NetworkManagementClient(credentials,
subscription_id)
self.compute_client = ComputeManagementClient(credentials,
subscription_id)
self.storage_client = StorageManagementClient(credentials,
subscription_id)
self.header_keys = []
self.header_titles = []
self.isJson = False
self.verbose = False
self.region = region
def terminate_instances(self, parameters):
""" Deletes the instances specified in 'parameters' running in Azure.
Args:
parameters: A dict, containing all the parameters necessary to
authenticate this user with Azure.
"""
credentials = self.open_connection(parameters)
resource_group = parameters[self.PARAM_RESOURCE_GROUP]
subscription_id = parameters[self.PARAM_SUBSCRIBER_ID]
verbose = parameters[self.PARAM_VERBOSE]
public_ips, private_ips, instance_ids = self.describe_instances(
parameters)
AppScaleLogger.verbose(
"Terminating the vm instance/s '{}'".format(instance_ids), verbose)
compute_client = ComputeManagementClient(credentials, subscription_id)
threads = []
for vm_name in instance_ids:
thread = threading.Thread(target=self.delete_virtual_machine,
args=(compute_client, resource_group,
verbose, vm_name))
thread.start()
threads.append(thread)
for x in threads:
x.join()
def __init__(self, options):
"""Needs to be initialized with options as an
instance of settings"""
self.options = options
self.credentials = ServicePrincipalCredentials(
client_id=options.client_id,
secret=options.secret,
tenant=options.tenant_id)
self.compute = ComputeManagementClient(
self.credentials, options.subscription_id)
# TODO: determine based on context information?
self.resource_group_name = options.resource_group_name
self.container_service_name = options.container_service_name
if options.context_cloud:
self.agent_pool_name = self.__get_container_service_pool(
self.__get_container_service(
self.resource_group_name, self.container_service_name),
options.context_cloud
).name
else:
self.agent_pool_name = self.__get_container_service_pool(
self.__get_container_service(
self.resource_group_name, self.container_service_name),
options.context
).name
def main(mytimer: func.TimerRequest) -> None:
utc_timestamp = datetime.datetime.utcnow().replace(
tzinfo=datetime.timezone.utc).isoformat()
if mytimer.past_due:
logging.info('The timer is past due!')
logging.info('Python timer trigger function ran at %s', utc_timestamp)
#credentials = DefaultAzureCredential()
credentials = MSIAuthentication()
compute_client = ComputeManagementClient(credentials, subscription_id)
# List VM in resource group
print('\nList VMs in resource group')
for group in groups:
for vm in compute_client.virtual_machines.list(group):
logging.info("\tVM: {}".format(vm.name))
jsonStr = json.dumps(vm.tags)
logging.info(jsonStr)
logging.info(vm.id)
temp_id_list = vm.id.split('/')
resource_group = temp_id_list[4]
statuses = compute_client.virtual_machines.instance_view(
group, vm.name).statuses
status = len(statuses) >= 2 and statuses[1]
if vm.tags is not None:
if key in vm.tags:
if key_value in vm.tags[key]:
if status and status.code == 'PowerState/running':
logging.info('This VM is running %s', vm.name)
async_vm_stop = compute_client.virtual_machines.power_off(
group, vm.name)
async_vm_stop.wait()
logging.info('Stop command executed for %s',
vm.name)
def __init__(self, config):
"""Set up platform."""
super(AzureCloudPlatform, self).__init__(config)
self.tag = '%s-%s' % (config['tag'],
datetime.now().strftime('%Y%m%d%H%M%S'))
self.storage_sku = config['storage_sku']
self.vm_size = config['vm_size']
self.location = config['region']
try:
self.credentials, self.subscription_id = self._get_credentials()
self.resource_client = ResourceManagementClient(
self.credentials, self.subscription_id)
self.compute_client = ComputeManagementClient(
self.credentials, self.subscription_id)
self.network_client = NetworkManagementClient(
self.credentials, self.subscription_id)
self.storage_client = StorageManagementClient(
self.credentials, self.subscription_id)
self.resource_group = self._create_resource_group()
self.public_ip = self._create_public_ip_address()
self.storage = self._create_storage_account(config)
self.vnet = self._create_vnet()
self.subnet = self._create_subnet()
self.nic = self._create_nic()
except CloudError:
raise RuntimeError('failed creating a resource:\n{}'.format(
traceback.format_exc()))
def __init__(self, logger, config):
self.name = 'azure'
self.location = config["location"]
self.logger = logger
self.config = config
logger.info('Connecting to Azure...')
try:
credentials = ClientSecretCredential(
client_id=config["client_id"],
client_secret=config["client_secret"],
tenant_id=config["tenant_id"])
self.compute_client = ComputeManagementClient(
credential=credentials,
subscription_id=config["subscription_id"])
self.network_client = NetworkManagementClient(
credential=credentials,
subscription_id=config["subscription_id"])
self.id = os.getpid()
logger.info('Connection Successful.')
except Exception as e:
logger.error(f'Unable to connect to Azure: {str(e)}')
self.config["username"] = "******"
self.config["password"] = "******"
self.instance_name = ""
self.public_ip = ""
def run_example():
"""Resource Group management example."""
#
# Get Subscription Information
#
subscription_id = os.environ.get(
'AZURE_SUBSCRIPTION_ID',
'11111111-1111-1111-1111-111111111111') # your Azure Subscription Id
#
# Create all clients with an Application (service principal) token provider
#
credentials = ServicePrincipalCredentials(
client_id=os.environ['AZURE_CLIENT_ID'],
secret=os.environ['AZURE_CLIENT_SECRET'],
tenant=os.environ['AZURE_TENANT_ID']
)
resource_client = ResourceManagementClient(credentials, subscription_id)
compute_client = ComputeManagementClient(credentials, subscription_id)
storage_client = StorageManagementClient(credentials, subscription_id)
network_client = NetworkManagementClient(credentials, subscription_id)
###########
# Prepare #
###########
# Create Resource group
print('\nCreate Resource Group')
resource_client.resource_groups.create_or_update(GROUP_NAME, {'location':LOCATION})
def alterVM(self, vm, radl, auth_data):
try:
group_name = vm.id.split('/')[0]
vm_name = vm.id.split('/')[1]
credentials, subscription_id = self.get_credentials(auth_data)
compute_client = ComputeManagementClient(credentials, subscription_id)
# Deallocating the VM (resize prepare)
async_vm_deallocate = compute_client.virtual_machines.deallocate(group_name, vm_name)
async_vm_deallocate.wait()
instance_type = self.get_instance_type(radl.systems[0], credentials, subscription_id)
vm_parameters = " { 'hardware_profile': { 'vm_size': %s } } " % instance_type.name
async_vm_update = compute_client.virtual_machines.create_or_update(group_name,
vm_name,
vm_parameters)
async_vm_update.wait()
# Start the VM
async_vm_start = compute_client.virtual_machines.start(group_name, vm_name)
async_vm_start.wait()
return self.updateVMInfo(vm, auth_data)
except Exception as ex:
self.log_exception("Error altering the VM")
return False, "Error altering the VM: " + str(ex)
return (True, "")
def __init__(self):
credentials = UserPassCredentials(CONF.azure.username,
CONF.azure.password)
LOG.info(_LI('Login with Azure username and password.'))
self.resource = ResourceManagementClient(credentials,
CONF.azure.subscription_id)
self.compute = ComputeManagementClient(credentials,
CONF.azure.subscription_id)
self.network = NetworkManagementClient(credentials,
CONF.azure.subscription_id)
try:
self.resource.providers.register('Microsoft.Network')
LOG.info(_LI("Register Microsoft.Network"))
self.resource.providers.register('Microsoft.Compute')
LOG.info(_LI("Register Microsoft.Compute"))
except Exception as e:
msg = six.text_type(e)
ex = exception.ProviderRegisterFailure(reason=msg)
LOG.exception(msg)
raise ex
try:
self.resource.resource_groups.create_or_update(
CONF.azure.resource_group, {'location': CONF.azure.location})
LOG.info(_LI("Create/Update Resource Group"))
except Exception as e:
msg = six.text_type(e)
ex = exception.ResourceGroupCreateFailure(reason=msg)
LOG.exception(msg)
raise ex
def _get_vm_instance_views(self, vm_index, vm, sub_index, sub):
"""Get virtual machine records with instance view details.
Arguments:
vm_index (int): Virtual machine index (for logging only).
vm (dict): Raw virtual machine record.
sub_index (int): Subscription index (for logging only).
sub (Subscription): Azure subscription object.
Yields:
dict: An Azure virtual machine record with instance view details.
"""
vm_name = vm.get('name')
_log.info('Working on VM #%d: %s; %s', vm_index, vm_name,
util.outline_az_sub(sub_index, sub, self._tenant))
try:
creds = self._credentials
sub_id = sub.get('subscription_id')
compute_client = ComputeManagementClient(creds, sub_id)
vm_id = vm.get('id')
rg_name = tools.parse_resource_id(vm_id)['resource_group']
vm_iv = compute_client.virtual_machines.instance_view(
rg_name, vm_name)
vm_iv = vm_iv.as_dict()
yield _process_vm_instance_view(vm_index, vm, vm_iv, sub_index,
sub, self._tenant)
except Exception as e:
_log.error(
'Failed to fetch vm_instance_view for VM #%d: '
'%s; %s; error: %s: %s', vm_index, vm_name,
util.outline_az_sub(sub_index, sub, self._tenant),
type(e).__name__, e)
def _init_az_api(self):
"""
Initialise client objects for talking to Azure API.
This is in a separate function so to be called by ``__init__``
and ``__setstate__``.
"""
with self.__lock:
if self._resource_client is None:
log.debug("Making Azure `ServicePrincipalcredentials` object"
" with tenant=%r, client_id=%r, secret=%r ...",
self.tenant_id, self.client_id,
('<redacted>' if self.secret else None))
credentials = ServicePrincipalCredentials(
tenant=self.tenant_id,
client_id=self.client_id,
secret=self.secret,
)
log.debug("Initializing Azure `ComputeManagementclient` ...")
self._compute_client = ComputeManagementClient(credentials, self.subscription_id)
log.debug("Initializing Azure `NetworkManagementclient` ...")
self._network_client = NetworkManagementClient(credentials, self.subscription_id)
log.debug("Initializing Azure `ResourceManagementclient` ...")
self._resource_client = ResourceManagementClient(credentials, self.subscription_id)
log.info("Azure API clients initialized.")
async def run_example():
start = time.time()
credentials, subscription_id = get_credentials()
resource_client = ResourceManagementClient(credentials, subscription_id)
compute_client = ComputeManagementClient(credentials, subscription_id)
network_client = NetworkManagementClient(credentials, subscription_id)
resource_client.resource_groups.create_or_update(GROUP_NAME,
{'location': LOCATION})
subnet = create_vnet(network_client)
with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
loop = asyncio.get_event_loop()
futures = [
loop.run_in_executor(executor, create_vm, network_client,
compute_client, subnet)
for i in range(vmnumber)
]
for vm in await asyncio.gather(*futures):
pass
end = time.time()
print('\n ' + str(vmnumber) + ' VMs created in ' + stopWatch(end - start))
def get_vm_types(project):
client = ''
location = ''
machine_types = []
try:
con = create_db_con()
subscription_id = Project.objects(name=project)[0]['subscription_id']
client_id = Project.objects(name=project)[0]['client_id']
tenant_id = Project.objects(name=project)[0]['tenant_id']
secret_id = Project.objects(name=project)[0]['secret']
location = Project.objects(name=project)[0]['location']
creds = ServicePrincipalCredentials(client_id=client_id,
secret=secret_id,
tenant=tenant_id)
client = ComputeManagementClient(creds, subscription_id)
machine_types = list_available_vm_sizes(client,
region=location,
minimum_cores=1,
minimum_memory_MB=768)
flag = True
except Exception as e:
print(repr(e))
logger("Fetching vm details failed: " + repr(e), "warning")
flag = False
con.close()
return machine_types, flag
def __init__(self, clusterName, zone, nodeStorage):
self.playbook = {
'create-cluster': 'create-azure-resourcegroup.yml',
'create': 'create-azure-vm.yml',
'delete': 'delete-azure-vm.yml',
'destroy': 'delete-azure-cluster.yml'
}
playbooks = os.path.dirname(os.path.realpath(__file__))
super(AzureProvisioner, self).__init__(playbooks, clusterName, zone,
nodeStorage)
# Fetch Azure credentials from the CLI config
# FIXME: do error checking on this
azureCredentials = ConfigParser.SafeConfigParser()
azureCredentials.read(os.path.expanduser("~/.azure/credentials"))
client_id = azureCredentials.get("default", "client_id")
secret = azureCredentials.get("default", "secret")
tenant = azureCredentials.get("default", "tenant")
subscription = azureCredentials.get("default", "subscription_id")
# Authenticate to Azure API
credentials = ServicePrincipalCredentials(client_id=client_id,
secret=secret,
tenant=tenant)
self._azureComputeClient = ComputeManagementClient(
credentials, subscription)
self._azureNetworkClient = NetworkManagementClient(
credentials, subscription)
if not clusterName:
# If no clusterName, Toil must be running on the leader.
self._readClusterSettings()
def get_resource_group_details(subscription_id, creds, resource_group_name):
storage_client = StorageManagementClient(creds, subscription_id)
resource_client = ResourceManagementClient(creds, subscription_id)
compute_client = ComputeManagementClient(creds, subscription_id)
network_client = NetworkManagementClient(creds, subscription_id)
model = ResourceGroupDetails()
model.storage_accounts = list(
storage_client.storage_accounts.list_by_resource_group(
resource_group_name))
provider = resource_client.providers.get('Microsoft.Storage')
resource_type = [
r for r in provider.resource_types
if r.resource_type == 'storageAccounts'
][0]
model.storage_accounts_locations = resource_type.locations
# TODO: make an iterate function
model.vms = list(compute_client.virtual_machines.list(resource_group_name))
model.public_ip_addresses = list(
network_client.public_ip_addresses.list(resource_group_name))
model.virtual_networks = list(
network_client.virtual_networks.list(resource_group_name))
return model
def main():
mdUrl = "http://169.254.169.254/metadata/instance/compute?api-version=2017-08-01"
header = {'Metadata': 'True'}
request = urllib2.Request(url=mdUrl, headers=header)
response = urllib2.urlopen(request)
data = response.read()
metaData = data.decode("utf-8")
vm_meta_json = json.loads(metaData)
print(vm_meta_json)
GROUP_NAME = vm_meta_json["resourceGroupName"]
VM_NAME = sys.argv[1]
sched_event_url = "http://169.254.169.254/metadata/scheduledevents?api-version=2017-08-01"
request2 = urllib2.Request(url=sched_event_url, headers=header)
response = urllib2.urlopen(request2)
sched_events_json = response.read()
print(sched_events_json)
subscription_id = os.environ.get('AZURE_SUBSCRIPTION_ID')
credentials = ServicePrincipalCredentials(
client_id=os.environ['AZURE_CLIENT_ID'],
secret=os.environ['AZURE_SECRET'],
tenant=os.environ['AZURE_TENANT'])
compute_client = ComputeManagementClient(credentials, subscription_id)
r_virtual_machine = compute_client.virtual_machines.get(
GROUP_NAME, VM_NAME)
async_vm_redeploy = compute_client.virtual_machines.redeploy(
GROUP_NAME, VM_NAME)
r_virtual_machine = async_vm_redeploy.result()
def __init__(self, metadata, region):
self.region = region
self.credentials = get_credentials()
self.compute_client = ComputeManagementClient(self.credentials,
SUBSCRIPTION_ID)
self.network_client = NetworkManagementClient(self.credentials,
SUBSCRIPTION_ID)
def __compute_mgmt_client(secrets, configuration):
with auth(secrets) as cred:
subscription_id = configuration['azure']['subscription_id']
client = ComputeManagementClient(credentials=cred,
subscription_id=subscription_id)
return client
def updateVMInfo(self, vm, auth_data):
self.log_debug("Get the VM info with the id: " + vm.id)
group_name = vm.id.split('/')[0]
vm_name = vm.id.split('/')[1]
try:
credentials, subscription_id = self.get_credentials(auth_data)
compute_client = ComputeManagementClient(credentials, subscription_id)
# Get one the virtual machine by name
virtual_machine = compute_client.virtual_machines.get(group_name, vm_name)
except Exception as ex:
if "NotFound" in str(ex):
vm.state = VirtualMachine.OFF
return (True, vm)
else:
self.log_exception("Error getting the VM info: " + vm.id)
return (False, "Error getting the VM info: " + vm.id + ". " + str(ex))
self.log_debug("VM info: " + vm.id + " obtained.")
vm.state = self.PROVISION_STATE_MAP.get(virtual_machine.provisioning_state, VirtualMachine.UNKNOWN)
self.log_debug("The VM state is: " + vm.state)
instance_type = self.get_instance_type_by_name(virtual_machine.hardware_profile.vm_size,
virtual_machine.location, credentials, subscription_id)
self.update_system_info_from_instance(vm.info.systems[0], instance_type)
# Update IP info
self.setIPs(vm, virtual_machine.network_profile, credentials, subscription_id)
return (True, vm)
def main():
vmss = sys.argv[1]
appgwy = sys.argv[2]
resource_group = sys.argv[3]
#Creating az_rollout instance.
rollout = az_rollout(tenant_id, subscription_id, vmss, resource_group, appgwy)
#Obtaining credentials.
credentials = rollout.credentials
#Creating ComputeManagementClient instance.
client_C = ComputeManagementClient(credentials, subscription_id)
#Executing policy check.
rollout.policy_check(client_C)
#Obtaining vmss running vms list.
id_list = rollout.get_vms(client_C)
#Calculating the original scale set vm capacity.
original_size = str(len(id_list))
#Getting the new scale vm capacity size by multiplying the original size by 2.
new_size = str(len(id_list) * 2)
#Executing the scale command.
rollout.scale_commnad(new_size)
#Creating NetworkManagementClient instance.
client_N = NetworkManagementClient(credentials, subscription_id)
#Executing healthcheck and returning the scale set to the original vm capacity.
rollout.health_check(client_N)
rollout.scale_commnad(original_size)
def compute_models(self):
self.log("Getting compute models")
return ComputeManagementClient.models("2017-03-30")