示例#1
0
def create_autoscaling_policy(autoscale, cluster_name, opts):
    scale_up_policy = ScalingPolicy(
        name='scale_up', adjustment_type='ChangeInCapacity',
        as_name=cluster_name + "-ag", scaling_adjustment=5, cooldown=60)
    scale_down_policy = ScalingPolicy(
        name='scale_down', adjustment_type='ChangeInCapacity',
        as_name=cluster_name + "-ag", scaling_adjustment=-1, cooldown=60)
    autoscale.create_scaling_policy(scale_up_policy)
    autoscale.create_scaling_policy(scale_down_policy)
    scale_up_policy = autoscale.get_all_policies(
        as_group=cluster_name + "-ag", policy_names=['scale_up'])[0]
    scale_down_policy = autoscale.get_all_policies(
        as_group=cluster_name + "-ag", policy_names=['scale_down'])[0]
    alarm_dimensions = {"AutoScalingGroupName": cluster_name + "-ag"}
    cloudwatch = boto.ec2.cloudwatch.connect_to_region(opts.region)
    scale_up_alarm = MetricAlarm(
        name='scale_up_on_cpu', namespace='AWS/EC2',
        metric='CPUUtilization', statistic='Average',
        comparison='>', threshold='50',
        period='60', evaluation_periods=1,
        alarm_actions=[scale_up_policy.policy_arn],
        dimensions=alarm_dimensions)
    cloudwatch.create_alarm(scale_up_alarm)
    scale_down_alarm = MetricAlarm(
        name='scale_down_on_cpu', namespace='AWS/EC2',
        metric='CPUUtilization', statistic='Average',
        comparison='<', threshold='40',
        period='60', evaluation_periods=1,
        alarm_actions=[scale_down_policy.policy_arn],
        dimensions=alarm_dimensions)
    cloudwatch.create_alarm(scale_down_alarm)
示例#2
0
def scaling_policy(my_group):
    'define the scaing policy for the group'
    scale_up_policy = ScalingPolicy(name='scale_up',
                                    adjustment_type='ChangeInCapacity',
                                    as_name=my_group,
                                    scaling_adjustment=1,
                                    cooldown=180)
    scale_down_policy = ScalingPolicy(name='scale_down',
                                      adjustment_type='ChangeInCapacity',
                                      as_name=my_group,
                                      scaling_adjustment=-1,
                                      cooldown=180)

    ##########Submitting policy to AWS

    as_conn.create_scaling_policy(scale_up_policy)
    as_conn.create_scaling_policy(scale_down_policy)

    ## need to refresh scaling policy by requesting them back

    scale_up_policy = as_conn.get_all_policies(as_group=my_group,
                                               policy_names=['scale_up'])[0]
    scale_down_policy = as_conn.get_all_policies(as_group=my_group,
                                                 policy_names=['scale_down'
                                                               ])[0]

    ###CloudWatch alarms that will define when to run the Auto Scaling Policies

    alarm_dimensions = {"AutoScalingGroupName": my_group}
    #def set_metricAlarm():
    'set alarm for scaing the instances in as_group'
    scale_up_alarm = MetricAlarm(name='scale_up_on_cpu_"my_group"',
                                 namespace='AWS/EC2',
                                 metric='CPUUtilization',
                                 statistic='Average',
                                 comparison='>',
                                 threshold='70',
                                 period='300',
                                 evaluation_periods=2,
                                 alarm_actions=[scale_up_policy.policy_arn],
                                 dimensions=alarm_dimensions)

    cloudwatch.create_alarm(scale_up_alarm)

    scale_down_alarm = MetricAlarm(
        name='scale_down_on_cpu_"my_group"',
        namespace='AWS/EC2',
        metric='CPUUtilization',
        statistic='Average',
        comparison='<',
        threshold='40',
        period='300',
        evaluation_periods=2,
        alarm_actions=[scale_down_policy.policy_arn],
        dimensions=alarm_dimensions)

    cloudwatch.create_alarm(scale_down_alarm)
def main():
    parser = optparse.OptionParser('Usage: %prog <options>')
    parser.add_option('-e', '--email', dest='email',
        help='The email address to send notifications to whenever an '
             'alert is triggered.')
    parser.add_option('-n', '--name', dest='name',
        help='The name of the alarm (e.g., BillingAlarm-1000).')
    parser.add_option('-t', '--threshold', dest='threshold',
        help='The dollar amount of estimated monthly charges which, '
             'when exceeded, causes an alert to be triggered.')
    parser.add_option('-p', '--period', dest='period', default=Defaults.PREIOD,
        help='The period in seconds over which the estimated monthly '
             'charges statistic is applied.')
    (opts, args) = parser.parse_args()

    if (0 != len(args) or
        opts.email is None or
        opts.threshold is None):
        parser.print_help()
        return 1

    try:
        sns = boto.connect_sns()

        topic = sns.create_topic('BillingNotifications') \
            ['CreateTopicResponse'] \
            ['CreateTopicResult'] \
            ['TopicArn']

        res = sns.subscribe(topic, 'email', opts.email) \
            ['SubscribeResponse'] \
            ['SubscribeResult'] \
            ['SubscriptionArn']
        if res == 'pending confirmation':
            raw_input('Please confirm subscription. Press [ENTER] when done...')

        cloudwatch = boto.connect_cloudwatch()

        alarm = MetricAlarm(name=opts.name if opts.name is not None
                else 'BillingAlarm-{0}'.format(opts.threshold),
            description='Estimated Monthly Charges',
            alarm_actions=[topic],
            metric=Defaults.METRIC,
            namespace='AWS/Billing',
            statistic=Defaults.STATISTIC,
            dimensions={'Currency':'USD'},
            period=opts.period,
            evaluation_periods=1,
            threshold=int(opts.threshold),
            comparison='>=')
        cloudwatch.create_alarm(alarm)
    except Error, err:
        sys.stderr.write('[ERROR] {0}\n'.format(err))
        return 1
示例#4
0
def create_autoscalegroup_watch(conn):
    
    lc = LaunchConfiguration(name='my-launch_config', image_id='ami-2b7b2c42',
                                 key_name='key2bench',
                                 security_groups=['default'])
    conn.create_launch_configuration(lc)
    

    
    scale_up_policy = ScalingPolicy(
                name='scale_up', adjustment_type='ChangeInCapacity',
                as_name='Auto_scale_group', scaling_adjustment=1, cooldown=180)
                
    scale_down_policy = ScalingPolicy(
                name='scale_down', adjustment_type='ChangeInCapacity',
                as_name='Auto_scale_group', scaling_adjustment=-1, cooldown=180)
    
    conn.create_scaling_policy(scale_up_policy)
    conn.create_scaling_policy(scale_down_policy)
    scale_up_policy = conn.get_all_policies(
            as_group='Auto_scale_group', policy_names=['scale_up'])[0]
    scale_down_policy = conn.get_all_policies(
            as_group='Auto_scale_group', policy_names=['scale_down'])[0]
    # ======create auto scale group with configuration ======
    
    # =============  CloudWatch ====================
    cloudwatch = boto.ec2.cloudwatch.connect_to_region('us-east-1')
    
    alarm_dimensions = {"AutoScalingGroupName": 'Auto_scale_group'}
    
    scale_up_alarm = MetricAlarm(
                name='scale_up_on_cpu', namespace='AWS/EC2',
                metric='CPUUtilization', statistic='Average',
                comparison='>', threshold='80',
                period='60', evaluation_periods=5,
                alarm_actions=[scale_up_policy.policy_arn],
                dimensions=alarm_dimensions)
                
    cloudwatch.create_alarm(scale_up_alarm)
    
    scale_down_alarm = MetricAlarm(
                name='scale_down_on_cpu', namespace='AWS/EC2',
                metric='CPUUtilization', statistic='Average',
                comparison='<', threshold='20',
                period='60', evaluation_periods=5,
                alarm_actions=[scale_down_policy.policy_arn],
                dimensions=alarm_dimensions)
                
    cloudwatch.create_alarm(scale_down_alarm)
    
    conn.put_notification_configuration(ag, 'arn:aws:sns:us-east-1:233941742685:Auto_Scale_events',['autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_TERMINATE'])
示例#5
0
def create_alarm():
    conn = get_autoscale_connection()
    # create scaling policy for scaling up and down
    scale_up_policy = ScalingPolicy(
        name="scale_up", adjustment_type="ChangeInCapacity", as_name=group_name, scaling_adjustment=1, cooldown=5
    )
    scale_down_policy = ScalingPolicy(
        name="scale_down", adjustment_type="ChangeInCapacity", as_name=group_name, scaling_adjustment=-1, cooldown=5
    )
    conn.create_scaling_policy(scale_up_policy)
    conn.create_scaling_policy(scale_down_policy)

    # refresh the policy
    scale_up_policy = conn.get_all_policies(as_group=group_name, policy_names=["scale_up"])[0]
    scale_down_policy = conn.get_all_policies(as_group=group_name, policy_names=["scale_down"])[0]
    # create cloud watch to assign the policy
    cloudwatch = boto.ec2.cloudwatch.connect_to_region(
        amazon_key.REGION, aws_access_key_id=amazon_key.ACCESS_KEY, aws_secret_access_key=amazon_key.SECRET_KEY
    )

    alarm_dimensions = {"AutoScalingGroupName": group_name}

    scale_up_alarm = MetricAlarm(
        name="scale_up_on_cpu",
        namespace="AWS/EC2",
        metric="CPUUtilization",
        statistic="Average",
        comparison=">",
        threshold="60",
        period="60",
        evaluation_periods=1,
        alarm_actions=[scale_up_policy.policy_arn],
        dimensions=alarm_dimensions,
    )
    cloudwatch.create_alarm(scale_up_alarm)

    scale_down_alarm = MetricAlarm(
        name="scale_down_on_cpu",
        namespace="AWS/EC2",
        metric="CPUUtilization",
        statistic="Average",
        comparison="<",
        threshold="30",
        period="60",
        evaluation_periods=1,
        alarm_actions=[scale_down_policy.policy_arn],
        dimensions=alarm_dimensions,
    )
    cloudwatch.create_alarm(scale_down_alarm)
示例#6
0
def create_autoscaling_policy(autoscale, cluster_name, opts):
    scale_up_policy = ScalingPolicy(
        name='scale_up',
        adjustment_type='ChangeInCapacity',
        as_name=cluster_name + "-ag",
        scaling_adjustment=opts.scale_up_nodes_amount,
        cooldown=opts.scale_up_cooldown)
    scale_down_policy = ScalingPolicy(
        name='scale_down',
        adjustment_type='ChangeInCapacity',
        as_name=cluster_name + "-ag",
        scaling_adjustment=-opts.scale_down_nodes_amount,
        cooldown=opts.scale_down_cooldown)
    autoscale.create_scaling_policy(scale_up_policy)
    autoscale.create_scaling_policy(scale_down_policy)
    scale_up_policy = autoscale.get_all_policies(as_group=cluster_name + "-ag",
                                                 policy_names=['scale_up'])[0]
    scale_down_policy = autoscale.get_all_policies(
        as_group=cluster_name + "-ag", policy_names=['scale_down'])[0]
    alarm_dimensions = {"AutoScalingGroupName": cluster_name + "-ag"}
    cloudwatch = boto.ec2.cloudwatch.connect_to_region(opts.region)
    scale_up_alarm = MetricAlarm(name='scale_up_on_cpu',
                                 namespace='AWS/EC2',
                                 metric='CPUUtilization',
                                 statistic='Average',
                                 comparison='>',
                                 threshold='50',
                                 period='60',
                                 evaluation_periods=1,
                                 alarm_actions=[scale_up_policy.policy_arn],
                                 dimensions=alarm_dimensions)
    cloudwatch.create_alarm(scale_up_alarm)
    scale_down_alarm = MetricAlarm(
        name='scale_down_on_cpu',
        namespace='AWS/EC2',
        metric='CPUUtilization',
        statistic='Average',
        comparison='<',
        threshold='40',
        period='60',
        evaluation_periods=1,
        alarm_actions=[scale_down_policy.policy_arn],
        dimensions=alarm_dimensions)
    cloudwatch.create_alarm(scale_down_alarm)
示例#7
0
def scaling_policy(my_group):
	'define the scaing policy for the group'
	scale_up_policy = ScalingPolicy(name='scale_up', adjustment_type='ChangeInCapacity',
            as_name=my_group, scaling_adjustment=1, cooldown=180)
	scale_down_policy = ScalingPolicy(name='scale_down', adjustment_type='ChangeInCapacity',
            as_name=my_group, scaling_adjustment=-1, cooldown=180)

##########Submitting policy to AWS

	as_conn.create_scaling_policy(scale_up_policy)
	as_conn.create_scaling_policy(scale_down_policy)

## need to refresh scaling policy by requesting them back 

	scale_up_policy = as_conn.get_all_policies(as_group=my_group, policy_names=['scale_up'])[0]
	scale_down_policy = as_conn.get_all_policies(as_group=my_group, policy_names=['scale_down'])[0]

###CloudWatch alarms that will define when to run the Auto Scaling Policies

	alarm_dimensions = {"AutoScalingGroupName":my_group}
#def set_metricAlarm():
	'set alarm for scaing the instances in as_group'
	scale_up_alarm = MetricAlarm(
         	name='scale_up_on_cpu_"my_group"', namespace='AWS/EC2',
       		metric='CPUUtilization', statistic='Average',
            	comparison='>', threshold='70',
           	period='300', evaluation_periods=2,
            	alarm_actions=[scale_up_policy.policy_arn],
           	 dimensions=alarm_dimensions)
	
	cloudwatch.create_alarm(scale_up_alarm)

	scale_down_alarm = MetricAlarm(
            name='scale_down_on_cpu_"my_group"', namespace='AWS/EC2',
            metric='CPUUtilization', statistic='Average',
            comparison='<', threshold='40',
            period='300', evaluation_periods=2,
            alarm_actions=[scale_down_policy.policy_arn],
            dimensions=alarm_dimensions)
	
	cloudwatch.create_alarm(scale_down_alarm)
示例#8
0
            as_group=AUTO_SCALE_GROUP, policy_names=['scale_up'])[0]
scale_down_policy = conn.get_all_policies(
            as_group=AUTO_SCALE_GROUP, policy_names=['scale_down'])[0]


cloudwatch = boto.ec2.cloudwatch.connect_to_region("us-east-1", aws_access_key_id=ACCESS_KEY_ID, aws_secret_access_key=SECRET_ACCESS_KEY)
alarm_dimensions = {"AutoScalingGroupName": AUTO_SCALE_GROUP}

scale_up_alarm = MetricAlarm(
            name='scale_up_on_cpu', namespace='AWS/EC2',
            metric='CPUUtilization', statistic='Average',
            comparison='>', threshold='65',
            period='180', evaluation_periods=1,
            alarm_actions=[scale_up_policy.policy_arn],
            dimensions=alarm_dimensions)
cloudwatch.create_alarm(scale_up_alarm)

scale_down_alarm = MetricAlarm(
            name='scale_down_on_cpu', namespace='AWS/EC2',
            metric='CPUUtilization', statistic='Average',
            comparison='<', threshold='25',
            period='240', evaluation_periods=1,
            alarm_actions=[scale_down_policy.policy_arn],
            dimensions=alarm_dimensions)
cloudwatch.create_alarm(scale_down_alarm)

time.sleep(60)

i = 0
while i < 3:
  req = "http://" + load_generator.public_dns_name + "/warmup"
def create_AutoScaling():
    print "Creating AutoScaling..."
    # establish connection
    as_conn = AutoScaleConnection(AWSAccessKeyId, AWSSecretKey)
    # create launch configuration
    global lc
    lc = LaunchConfiguration(name='lc',
                             image_id=DATA_CEN_AMI,
                             key_name=ACCESS_KEY,
                             instance_monitoring=True,
                             security_groups=[SECURITY_GRP],
                             instance_type=MACHINE_TYPE)
    as_conn.create_launch_configuration(lc)

    # create tag for autoscaling group
    as_tag = Tag(key="Project",
                 value="2.2",
                 propagate_at_launch=True,
                 resource_id='my_group')

    # create aotoscaling group
    global ag
    ag = AutoScalingGroup(group_name='my_group',
                          load_balancers=['myELB'],
                          availability_zones=['us-east-1a'],
                          launch_config=lc,
                          min_size=MIN_SIZE,
                          max_size=MAX_SIZE,
                          connection=as_conn,
                          tags=[as_tag])
    # associate the autoscaling group with launch configuration
    as_conn.create_auto_scaling_group(ag)

    # build the scale policy
    scale_up_policy = ScalingPolicy(name='scale_up',
                                    adjustment_type='ChangeInCapacity',
                                    as_name='my_group',
                                    scaling_adjustment=1,
                                    cooldown=60)
    scale_down_policy = ScalingPolicy(name='scale_down',
                                      adjustment_type='ChangeInCapacity',
                                      as_name='my_group',
                                      scaling_adjustment=-1,
                                      cooldown=60)

    # register the scale policy
    as_conn.create_scaling_policy(scale_up_policy)
    as_conn.create_scaling_policy(scale_down_policy)

    # refresh the scale policy for extra information
    scale_up_policy = as_conn.get_all_policies(as_group='my_group',
                                               policy_names=['scale_up'])[0]
    scale_down_policy = as_conn.get_all_policies(as_group='my_group',
                                                 policy_names=['scale_down'
                                                               ])[0]

    # create cloudwatch alarm
    cloudwatch = CloudWatchConnection(aws_access_key_id=AWSAccessKeyId,
                                      aws_secret_access_key=AWSSecretKey,
                                      is_secure=True)
    # region='us-east-1a')

    # assocate cloudwatch with alarm
    alarm_dimensions = {"AutoScalingGroupName": 'my_group'}

    # create scale up alarm
    scale_up_alarm = MetricAlarm(name='scale_up_on_cpu',
                                 namespace='AWS/EC2',
                                 metric='CPUUtilization',
                                 statistic='Average',
                                 comparison='>',
                                 threshold='50',
                                 period='60',
                                 evaluation_periods=2,
                                 alarm_actions=[scale_up_policy.policy_arn],
                                 dimensions=alarm_dimensions)
    cloudwatch.create_alarm(scale_up_alarm)

    # create scale down alarm
    scale_down_alarm = MetricAlarm(
        name='scale_down_on_cpu',
        namespace='AWS/EC2',
        metric='CPUUtilization',
        statistic='Average',
        comparison='<',
        threshold='20',
        period='60',
        evaluation_periods=1,
        alarm_actions=[scale_down_policy.policy_arn],
        dimensions=alarm_dimensions)
    cloudwatch.create_alarm(scale_down_alarm)

    print "AutoScaling created successfully"
示例#10
0
cloudwatch = boto.ec2.cloudwatch.connect_to_region('us-east-1')
alarm_dimensions = {"AutoScalingGroupName": 'my_autoscale_group'}

scale_up_alarm = MetricAlarm(name='scale_up_on_cpu',
                             namespace='AWS/EC2',
                             metric='CPUUtilization',
                             statistic='Average',
                             comparison='>',
                             threshold='70',
                             period='60',
                             evaluation_periods=2,
                             alarm_actions=[scale_up_policy.policy_arn],
                             dimensions=alarm_dimensions)

cloudwatch.create_alarm(scale_up_alarm)

scale_down_alarm = MetricAlarm(name='scale_down_on_cpu',
                               namespace='AWS/EC2',
                               metric='CPUUtilization',
                               statistic='Average',
                               comparison='<',
                               threshold='40',
                               period='60',
                               evaluation_periods=2,
                               alarm_actions=[scale_down_policy.policy_arn],
                               dimensions=alarm_dimensions)

cloudwatch.create_alarm(scale_down_alarm)

ec2 = boto.ec2.connect_to_region('us-east-1')
def start_elb(tag, user_data, region, auto_register, as_ami, subnet_id,
              security_groups, public_ip_address, iam_role, zone_strings,
              elastic_load_balancer):
    print "Using tag \"" + tag + "\""
    conn_reg = boto.ec2.connect_to_region(region_name=region)
    # =================Construct a list of all availability zones for your region=========

    conn_elb = boto.ec2.elb.connect_to_region(region_name=region)
    conn_as = boto.ec2.autoscale.connect_to_region(region_name=region)

    # =================Create a Load Balancer=============================================
    # For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#module-boto.ec2.elb.healthcheck
    hc = HealthCheck('healthCheck',
                     interval=elastic_load_balancer['interval'],
                     target=elastic_load_balancer['health_check_target'],
                     timeout=elastic_load_balancer['timeout'])

    # ELB does not accept any special characters
    elb_tag = tag
    elb_tag = elb_tag.replace("_", "")
    elb_tag = elb_tag.replace("-", "")
    elb_tag = elb_tag.replace(".", "")

    print "ELB name: \"" + elb_tag + "\""

    # For a complete list of options see
    # http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.elb.ELBConnection.create_load_balancer
    lb = conn_elb.create_load_balancer(
        name=elb_tag + 'Elb',
        zones=None,
        subnets=subnet_id,
        security_groups=security_groups,
        listeners=elastic_load_balancer['connection_forwarding'])

    if auto_register:
        aws_library.add_instances_to_lb(tag=tag, lb=lb, region=region)

    lb.configure_health_check(hc)

    # DNS name for your new load balancer
    print "Map the CNAME of your website to: %s" % lb.dns_name

    # =================Create a Auto Scaling Group and a Launch Configuration============================================
    # For a complete list of options see
    # http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.launchconfig.LaunchConfiguration
    lc = LaunchConfiguration(name=elb_tag + "Lc",
                             image_id=as_ami['id'],
                             key_name=as_ami['access_key'],
                             security_groups=as_ami['security_groups'],
                             instance_type=as_ami['instance_type'],
                             instance_monitoring=as_ami['instance_monitoring'],
                             instance_profile_name=iam_role,
                             user_data=user_data)
    conn_as.create_launch_configuration(lc)

    # For a complete list of options see
    # http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.group.AutoScalingGroup

    ag = AutoScalingGroup(group_name=elb_tag + "Sg",
                          load_balancers=[elb_tag],
                          availability_zones=zone_strings,
                          launch_config=lc,
                          min_size=autoscaling_group['min_size'],
                          max_size=autoscaling_group['max_size'],
                          associate_public_ip_address=public_ip_address,
                          vpc_zone_identifier=subnet_id)
    conn_as.create_auto_scaling_group(ag)

    # =================Create Scaling Policies=============================================
    # Policy for scaling the number of servers up and down
    # For a complete list of options see
    # http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.policy.ScalingPolicy
    scaling_up_policy = ScalingPolicy(name=elb_tag + "webserverScaleUpPolicy",
                                      adjustment_type='ChangeInCapacity',
                                      as_name=ag.name,
                                      scaling_adjustment=1,
                                      cooldown=60)

    scaling_down_policy = ScalingPolicy(name=elb_tag +
                                        "webserverScaleDownPolicy",
                                        adjustment_type='ChangeInCapacity',
                                        as_name=ag.name,
                                        scaling_adjustment=-1,
                                        cooldown=180)

    conn_as.create_scaling_policy(scaling_up_policy)
    conn_as.create_scaling_policy(scaling_down_policy)

    scaling_up_policy = conn_as.get_all_policies(
        as_group=elb_tag + "Sg",
        policy_names=[elb_tag + "webserverScaleUpPolicy"])[0]
    scaling_down_policy = conn_as.get_all_policies(
        as_group=elb_tag + "Sg",
        policy_names=[elb_tag + "webserverScaleDownPolicy"])[0]

    cloudwatch = boto.ec2.cloudwatch.connect_to_region(region)
    alarm_dimensions = {"AutoScalingGroupName": 'my_group'}

    scale_up_alarm = MetricAlarm(name=elb_tag + 'scale_up_on_cpu',
                                 namespace='AWS/EC2',
                                 metric='CPUUtilization',
                                 statistic='Average',
                                 comparison='>',
                                 threshold='70',
                                 period='60',
                                 evaluation_periods=2,
                                 alarm_actions=[scaling_up_policy.policy_arn],
                                 dimensions=alarm_dimensions)

    scale_down_alarm = MetricAlarm(
        name=elb_tag + 'scale_down_on_cpu',
        namespace='AWS/EC2',
        metric='CPUUtilization',
        statistic='Average',
        comparison='<',
        threshold='40',
        period='60',
        evaluation_periods=2,
        alarm_actions=[scaling_down_policy.policy_arn],
        dimensions=alarm_dimensions)

    cloudwatch.create_alarm(scale_down_alarm)
    cloudwatch.create_alarm(scale_up_alarm)
示例#12
0
def main():
    parser = optparse.OptionParser('Usage: %prog [options]')
    parser.add_option('-n', '--name', dest='name',
        help='The name of this configuration (e.g., TEST).')
    parser.add_option('-i', '--image', dest='image', default=Defaults.IMAGE,
        help='The Amazon  Machine  Image (AMI) ID that will be used to launch '
             'EC2 instances. The most recent Amazon Linux AMI 2013.09.2 (ami-'
             'a43909e1) is used by default.')
    parser.add_option('-t', '--type', dest='type', default=Defaults.TYPE,
        help='The type of the Amazon EC2 instance. If not specified, micro '
             'instance (t1.micro) type will be used.')
    parser.add_option('-k', '--key', dest='key',
        help='The name of the key pair to use when creating EC2 instances. '
             'This options is required.')
    parser.add_option('-g', '--group', dest='group',
        help='Security group that will be used when creating EC2 instances. '
             'This option is required.')
    parser.add_option('-m', '--min', dest='min', default=Defaults.MIN_INSTANCES,
        help='The minimum number of EC2 instances in the auto scaling group. '
             'By default it is set to 2.')
    parser.add_option('-M', '--max', dest='max', default=Defaults.MAX_INSTANCES,
        help='The maximum size of the auto scaling group. By default it is '
             'set to 4.')
    parser.add_option('-z', '--zone', dest='zones', action='append',
        help='The availability zone for the auto scaling group. This option '
             'is required.')
    parser.add_option('-l', '--load-balancer', dest='lbs', action='append',
        help='The name of an existing AWS load balancer to use, if any.')
    parser.add_option('--min-threshold', dest='min_threshold',
        default=Defaults.MIN_THRESHOLD, help='The minimum CPU utilization '
        'threshold that triggers an alarm. This option is not required and '
        'is set to 40% by default.')
    parser.add_option('--max-threshold', dest='max_threshold',
        default=Defaults.MAX_THRESHOLD, help='The maximum CPU utilization '
        'threshold that triggers an alarm. This option is not required and '
        'is set to 60% by default.')
    parser.add_option('-a', '--adjustment', dest='adjustment',
        default=Defaults.ADJUSTMENT, help='The number of EC2 instances by '
        'which to scale up or down. This is set to 1 by default.')
    parser.add_option('-p', '--period', dest='period', default=Defaults.PERIOD,
        help='The evaluation period in seconds. This is optional and is set '
             'to 300 seconds by default.')
    (opts, args) = parser.parse_args()

    if (0 != len(args) or
        opts.name is None or
        opts.key is None or
        opts.group is None or
        opts.zones is None):
        parser.print_help()
        return 1

    try:
        c = boto.connect_autoscale()

        lc = _create_launch_configuration(c, opts)
        g = _create_autoscaling_group(c, lc, opts)

        policy_up = ScalingPolicy(name=opts.name + s.POLICY_UP_SUFFIX,
            as_name=g.name,
            scaling_adjustment=opts.adjustment,
            adjustment_type='ChangeInCapacity')
        c.create_scaling_policy(policy_up)

        cloudwatch = boto.connect_cloudwatch()

        alarm_high = MetricAlarm(name=opts.name + s.ALARM_HIGH_SUFFIX,
            alarm_actions=[policy_up],
            metric='CPUUtilization',
            namespace='AWS/EC2',
            statistic='Average',
            dimensions={'AutoScalingGroupName': g.name},
            period=opts.period,
            evaluation_periods=1,
            threshold=int(opts.max_threshold),
            comparison='>')
        cloudwatch.create_alarm(alarm_high)

        policy_down = ScalingPolicy(name=opts.name + s.POLICY_DOWN_SUFFIX,
            as_name=g.name,
            scaling_adjustment=-opts.adjustment,
            adjustment_type='ChangeInCapacity')
        autoscale.create_scaling_policy(policy_down)

        alarm_low = MetricAlarm(name=opts.name + s.ALARM_LOW_SUFFIX,
            alarm_actions=[policy_down],
            metric='CPUUtilization',
            namespace='AWS/EC2',
            statistic='Average',
            dimensions={'AutoScalingGroupName': g.name},
            period=opts.period,
            evaluation_periods=1,
            threshold=int(opts.min_threshold),
            comparison='<')
        cloudwatch.create_alarm(alarm_low)
    except Error, err:
        sys.stderr.write('[ERROR] {0}\n'.format(err))
        return 1
def start_elb(tag, user_data, region, auto_register, as_ami, subnet_id, security_groups, public_ip_address, iam_role,
              zone_strings, elastic_load_balancer):
    print "Using tag \"" + tag + "\""
    conn_reg = boto.ec2.connect_to_region(region_name=region)
    # =================Construct a list of all availability zones for your region=========

    conn_elb = boto.ec2.elb.connect_to_region(region_name=region)
    conn_as = boto.ec2.autoscale.connect_to_region(region_name=region)

    # =================Create a Load Balancer=============================================
    # For a complete list of options see http://boto.cloudhackers.com/ref/ec2.html#module-boto.ec2.elb.healthcheck
    hc = HealthCheck('healthCheck',
                     interval=elastic_load_balancer['interval'],
                     target=elastic_load_balancer['health_check_target'],
                     timeout=elastic_load_balancer['timeout'])

    # ELB does not accept any special characters
    elb_tag = tag
    elb_tag = elb_tag.replace("_", "")
    elb_tag = elb_tag.replace("-", "")
    elb_tag = elb_tag.replace(".", "")

    print "ELB name: \"" + elb_tag + "\""

    # For a complete list of options see
    # http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.elb.ELBConnection.create_load_balancer
    lb = conn_elb.create_load_balancer(name=elb_tag + 'Elb',
                                       zones=None,
                                       subnets=subnet_id,
                                       security_groups=security_groups,
                                       listeners=elastic_load_balancer['connection_forwarding'])

    if auto_register:
        aws_library.add_instances_to_lb(tag=tag, lb=lb, region=region)

    lb.configure_health_check(hc)

    # DNS name for your new load balancer
    print "Map the CNAME of your website to: %s" % lb.dns_name

    # =================Create a Auto Scaling Group and a Launch Configuration============================================
    # For a complete list of options see
    # http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.launchconfig.LaunchConfiguration
    lc = LaunchConfiguration(name=elb_tag + "Lc", image_id=as_ami['id'],
                             key_name=as_ami['access_key'],
                             security_groups=as_ami['security_groups'],
                             instance_type=as_ami['instance_type'],
                             instance_monitoring=as_ami['instance_monitoring'],
                             instance_profile_name=iam_role,
                             user_data=user_data)
    conn_as.create_launch_configuration(lc)

    # For a complete list of options see
    # http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.group.AutoScalingGroup

    ag = AutoScalingGroup(group_name=elb_tag + "Sg",
                          load_balancers=[elb_tag],
                          availability_zones=zone_strings,
                          launch_config=lc, min_size=autoscaling_group['min_size'],
                          max_size=autoscaling_group['max_size'],
                          associate_public_ip_address=public_ip_address,
                          vpc_zone_identifier=subnet_id)
    conn_as.create_auto_scaling_group(ag)

    # =================Create Scaling Policies=============================================
    # Policy for scaling the number of servers up and down
    # For a complete list of options see
    # http://boto.cloudhackers.com/ref/ec2.html#boto.ec2.autoscale.policy.ScalingPolicy
    scaling_up_policy = ScalingPolicy(name=elb_tag + "webserverScaleUpPolicy",
                                      adjustment_type='ChangeInCapacity',
                                      as_name=ag.name,
                                      scaling_adjustment=1,
                                      cooldown=60)

    scaling_down_policy = ScalingPolicy(name=elb_tag + "webserverScaleDownPolicy",
                                        adjustment_type='ChangeInCapacity',
                                        as_name=ag.name,
                                        scaling_adjustment=-1,
                                        cooldown=180)

    conn_as.create_scaling_policy(scaling_up_policy)
    conn_as.create_scaling_policy(scaling_down_policy)

    scaling_up_policy = conn_as.get_all_policies(
        as_group=elb_tag + "Sg",
        policy_names=[elb_tag + "webserverScaleUpPolicy"])[0]
    scaling_down_policy = conn_as.get_all_policies(
        as_group=elb_tag + "Sg",
        policy_names=[elb_tag + "webserverScaleDownPolicy"])[0]

    cloudwatch = boto.ec2.cloudwatch.connect_to_region(region)
    alarm_dimensions = {"AutoScalingGroupName": 'my_group'}

    scale_up_alarm = MetricAlarm(name=elb_tag + 'scale_up_on_cpu',
                                 namespace='AWS/EC2',
                                 metric='CPUUtilization',
                                 statistic='Average',
                                 comparison='>',
                                 threshold='70',
                                 period='60',
                                 evaluation_periods=2,
                                 alarm_actions=[scaling_up_policy.policy_arn],
                                 dimensions=alarm_dimensions)

    scale_down_alarm = MetricAlarm(name=elb_tag + 'scale_down_on_cpu',
                                   namespace='AWS/EC2',
                                   metric='CPUUtilization',
                                   statistic='Average',
                                   comparison='<',
                                   threshold='40',
                                   period='60',
                                   evaluation_periods=2,
                                   alarm_actions=[scaling_down_policy.policy_arn],
                                   dimensions=alarm_dimensions)

    cloudwatch.create_alarm(scale_down_alarm)
    cloudwatch.create_alarm(scale_up_alarm)
示例#14
0
def main():
    parser = optparse.OptionParser('Usage: %prog <options>')
    parser.add_option(
        '-e',
        '--email',
        dest='email',
        help='The email address to send notifications to whenever an '
        'alert is triggered.')
    parser.add_option('-n',
                      '--name',
                      dest='name',
                      help='The name of the alarm (e.g., BillingAlarm-1000).')
    parser.add_option(
        '-t',
        '--threshold',
        dest='threshold',
        help='The dollar amount of estimated monthly charges which, '
        'when exceeded, causes an alert to be triggered.')
    parser.add_option(
        '-p',
        '--period',
        dest='period',
        default=Defaults.PREIOD,
        help='The period in seconds over which the estimated monthly '
        'charges statistic is applied.')
    (opts, args) = parser.parse_args()

    if (0 != len(args) or opts.email is None or opts.threshold is None):
        parser.print_help()
        return 1

    try:
        sns = boto.connect_sns()

        topic = sns.create_topic('BillingNotifications') \
            ['CreateTopicResponse'] \
            ['CreateTopicResult'] \
            ['TopicArn']

        res = sns.subscribe(topic, 'email', opts.email) \
            ['SubscribeResponse'] \
            ['SubscribeResult'] \
            ['SubscriptionArn']
        if res == 'pending confirmation':
            raw_input(
                'Please confirm subscription. Press [ENTER] when done...')

        cloudwatch = boto.connect_cloudwatch()

        alarm = MetricAlarm(name=opts.name if opts.name is not None else
                            'BillingAlarm-{0}'.format(opts.threshold),
                            description='Estimated Monthly Charges',
                            alarm_actions=[topic],
                            metric=Defaults.METRIC,
                            namespace='AWS/Billing',
                            statistic=Defaults.STATISTIC,
                            dimensions={'Currency': 'USD'},
                            period=opts.period,
                            evaluation_periods=1,
                            threshold=int(opts.threshold),
                            comparison='>=')
        cloudwatch.create_alarm(alarm)
    except Error, err:
        sys.stderr.write('[ERROR] {0}\n'.format(err))
        return 1