def autoscale_create(client,
resource,
count,
autoscale_name=None,
resource_group_name=None,
min_count=None,
max_count=None,
location=None,
tags=None,
disabled=None,
actions=None,
email_administrator=None,
email_coadministrators=None):
from azure.mgmt.monitor.models import (AutoscaleSettingResource,
AutoscaleProfile,
AutoscaleNotification,
ScaleCapacity, EmailNotification,
WebhookNotification)
if not autoscale_name:
from msrestazure.tools import parse_resource_id
autoscale_name = parse_resource_id(resource)['name']
min_count = min_count or count
max_count = max_count or count
default_profile = AutoscaleProfile(name=DEFAULT_PROFILE_NAME,
capacity=ScaleCapacity(
default=count,
minimum=min_count,
maximum=max_count),
rules=[])
notification = AutoscaleNotification(email=EmailNotification(
custom_emails=[],
send_to_subscription_administrator=email_administrator,
send_to_subscription_co_administrators=email_coadministrators),
webhooks=[])
for action in actions or []:
if isinstance(action, EmailNotification):
for email in action.custom_emails:
notification.email.custom_emails.append(email)
elif isinstance(action, WebhookNotification):
notification.webhooks.append(action)
autoscale = AutoscaleSettingResource(
location=location,
profiles=[default_profile],
tags=tags,
notifications=[notification],
enabled=not disabled,
autoscale_setting_resource_name=autoscale_name,
target_resource_uri=resource)
if not (min_count == count and max_count == count):
logger.warning(
'Follow up with `az monitor autoscale rule create` to add scaling rules.'
)
return client.create_or_update(resource_group_name, autoscale_name,
autoscale)
def create_autoscaling_settings(ExistingVmScaleSetName, VmScaleSetID,
resourceGroupName):
NewVmScaleSetName = VmScaleSetID.split('/')[-1]
existing_asg = monitor_client.autoscale_settings.get(
resource_group_name=resourceGroupName,
autoscale_setting_name=ExistingVmScaleSetName)
rules = [
ScaleRule(
metric_trigger=MetricTrigger(
metric_name=i.metric_trigger.metric_name,
#metric_namespace=i.metric_trigger.additional_properties['metricNamespace'],
metric_resource_uri=VmScaleSetID,
time_grain=i.metric_trigger.time_grain,
statistic=i.metric_trigger.statistic,
time_window=i.metric_trigger.time_window,
time_aggregation=i.metric_trigger.time_aggregation,
operator=i.metric_trigger.operator,
threshold=i.metric_trigger.threshold
#dimensions = i.metric_trigger.additional_properties['dimensions']
),
scale_action=i.scale_action)
for i in existing_asg.profiles[0].rules
]
profile = AutoscaleProfile(name=existing_asg.profiles[0].name,
capacity=existing_asg.profiles[0].capacity,
rules=rules,
fixed_date=None,
recurrence=None)
parameters = AutoscaleSettingResource(
location=existing_asg.location,
tags=existing_asg.tags,
profiles=[profile],
notifications=existing_asg.notifications,
enabled=True,
autoscale_setting_resource_name=NewVmScaleSetName,
target_resource_uri=VmScaleSetID)
new_asg = monitor_client.autoscale_settings.create_or_update(
resource_group_name=resourceGroupName,
autoscale_setting_name=NewVmScaleSetName,
parameters=parameters)
def exec_module(self, **kwargs):
for key in list(self.module_arg_spec.keys()) + ['tags']:
setattr(self, key, kwargs[key])
results = None
changed = False
self.log('Fetching auto scale settings {0}'.format(self.name))
results = self.get_auto_scale()
if results and self.state == 'absent':
# delete
changed = True
if not self.check_mode:
self.delete_auto_scale()
elif self.state == 'present':
if not self.location:
# Set default location
resource_group = self.get_resource_group(self.resource_group)
self.location = resource_group.location
resource_id = self.target
if isinstance(self.target, dict):
resource_id = format_resource_id(
val=self.target['name'],
subscription_id=self.target.get('subscription_id')
or self.subscription_id,
namespace=self.target['namespace'],
types=self.target['types'],
resource_group=self.target.get('resource_group')
or self.resource_group)
self.target = resource_id
resource_name = self.name
def create_rule_instance(params):
rule = params.copy()
rule['metric_resource_uri'] = rule.get('metric_resource_uri',
self.target)
rule['time_grain'] = timedelta(
minutes=rule.get('time_grain', 0))
rule['time_window'] = timedelta(
minutes=rule.get('time_window', 0))
rule['cooldown'] = timedelta(minutes=rule.get('cooldown', 0))
return ScaleRule(metric_trigger=MetricTrigger(**rule),
scale_action=ScaleAction(**rule))
profiles = [
AutoscaleProfile(
name=p.get('name'),
capacity=ScaleCapacity(minimum=p.get('min_count'),
maximum=p.get('max_count'),
default=p.get('count')),
rules=[
create_rule_instance(r) for r in p.get('rules') or []
],
fixed_date=TimeWindow(
time_zone=p.get('fixed_date_timezone'),
start=p.get('fixed_date_start'),
end=p.get('fixed_date_end'))
if p.get('fixed_date_timezone') else None,
recurrence=Recurrence(
frequency=p.get('recurrence_frequency'),
schedule=(RecurrentSchedule(
time_zone=p.get('recurrence_timezone'),
days=p.get('recurrence_days'),
hours=p.get('recurrence_hours'),
minutes=p.get('recurrence_mins'))))
if p.get('recurrence_frequency')
and p['recurrence_frequency'] != 'None' else None)
for p in self.profiles or []
]
notifications = [
AutoscaleNotification(email=EmailNotification(**n),
webhooks=[
WebhookNotification(service_uri=w)
for w in n.get('webhooks') or []
]) for n in self.notifications or []
]
if not results:
# create new
changed = True
else:
# check changed
resource_name = results.autoscale_setting_resource_name or self.name
update_tags, tags = self.update_tags(results.tags)
if update_tags:
changed = True
self.tags = tags
if self.target != results.target_resource_uri:
changed = True
if self.enabled != results.enabled:
changed = True
profile_result_set = set(
[str(profile_to_dict(p)) for p in results.profiles or []])
if profile_result_set != set(
[str(profile_to_dict(p)) for p in profiles]):
changed = True
notification_result_set = set([
str(notification_to_dict(n))
for n in results.notifications or []
])
if notification_result_set != set(
[str(notification_to_dict(n)) for n in notifications]):
changed = True
if changed:
# construct the instance will be send to create_or_update api
results = AutoscaleSettingResource(
location=self.location,
tags=self.tags,
profiles=profiles,
notifications=notifications,
enabled=self.enabled,
autoscale_setting_resource_name=resource_name,
target_resource_uri=self.target)
if not self.check_mode:
results = self.create_or_update_auto_scale(results)
# results should be the dict of the instance
self.results = auto_scale_to_dict(results)
self.results['changed'] = changed
return self.results