def delete_auto_scaling_group(name, force_delete=True):
"""Delete an auto scaling group."""
client = get_client("autoscaling")
response = client.delete_auto_scaling_group(
AutoScalingGroupName=name,
ForceDelete=True)
return response
def create_launch_configuration(
name,
ami_id,
key_name=None,
security_groups=None,
instance_type="t2.micro",
public_ip=False,
role_profile=None,
user_data=None,
user_data_file=None):
"""Create a launch configuration."""
client = get_client("autoscaling")
params = {}
params["LaunchConfigurationName"] = name
params["ImageId"] = ami_id
if key_name:
params["KeyName"] = key_name
if security_groups:
params["SecurityGroups"] = security_groups
params["InstanceType"] = instance_type
params["InstanceMonitoring"] = {"Enabled": False}
if role_profile:
params["IamInstanceProfile"] = role_profile
params["AssociatePublicIpAddress"] = public_ip
if user_data:
params["UserData"] = user_data
elif user_data_file:
params["UserData"] = get_file_contents(user_data_file)
response = client.create_launch_configuration(**params)
return response
def tag_subnet(subnet_id, tag, value):
"""Add a tag to a Subnet."""
client = get_client("ec2")
response = client.create_tags(
Resources=[subnet_id],
Tags=[{"Key": tag, "Value": value}])
return response
def tag_vpc(vpc_id, tag, value):
"""Add a tag to a VPC."""
client = get_client("ec2")
response = client.create_tags(
Resources=[vpc_id],
Tags=[{"Key": tag, "Value": value}])
return response
def create_security_group(name, vpc_id):
"""Create a security group."""
client = get_client("ec2")
response = client.create_security_group(
GroupName=name,
Description=name + " - " + vpc_id,
VpcId=vpc_id)
return response
def detach_elastic_load_balancer(
auto_scaling_group_name,
elastic_load_balancer_names):
"""Detach one or more load balancers from an auto scaling group."""
client = get_client("autoscaling")
response = client.detach_load_balancers(
AutoScalingGroupName=auto_scaling_group_name,
LoadBalancerNames=elastic_load_balancer_names)
return response
def add_outbound_rule_to_security_group(group_id, protocol, port, cidr_block):
"""Add a rule for outbound traffic to a security group."""
client = get_client("ec2")
response = client.authorize_security_group_egress(
GroupId=group_id,
IpProtocol=protocol,
FromPort=port,
ToPort=port,
CidrIp=cidr_block)
return response
def create_elastic_load_balancer(
name,
listeners,
availability_zones=None,
subnets=None,
security_groups=None):
"""Create an elastic load balancer."""
client = get_client("elb")
params = {}
params["LoadBalancerName"] = name
params["Listeners"] = listeners
if availability_zones:
params["AvailabilityZones"] = availability_zones
if subnets:
params["Subnets"] = subnets
if security_groups:
params["SecurityGroups"] = security_groups
response = client.create_load_balancer(**params)
return response
def create_auto_scaling_group(
name,
launch_configuration,
min_size,
max_size,
desired_size=None,
subnets=None):
"""Create an auto scaling group."""
client = get_client("autoscaling")
params = {}
params["AutoScalingGroupName"] = name
params["LaunchConfigurationName"] = launch_configuration
params["MinSize"] = min_size
params["MaxSize"] = max_size
if not desired_size:
desired_size = min_size
params["DesiredCapacity"] = desired_size
if subnets:
params["VPCZoneIdentifier"] = ",".join(subnets)
response = client.create_auto_scaling_group(**params)
return response
def create_instance(
ami_id,
security_group_id,
key_name=None,
instance_type="t2.micro",
user_data=None,
user_data_file=None):
"""Create an EC2 instance."""
client = get_client("ec2")
params = {}
params["ImageId"] = ami_id
params["MinCount"] = 1
params["MaxCount"] = 1
params["SecurityGroupIds"] = [security_group_id]
if key_name:
params["KeyName"] = key_name
params["InstanceType"] = instance_type
if user_data:
params["UserData"] = user_data
elif user_data_file:
params["UserData"] = get_file_contents(user_data_file)
response = client.run_instances(**params)
return response
def delete_vpc(vpc_id):
"""Delete a VPC."""
client = get_client("ec2")
response = client.delete_vpc(VpcId=vpc_id)
return response
def create_subnet(vpc_id, cidr_block):
"""Create a subnet in a VPC."""
client = get_client("ec2")
response = client.create_subnet(VpcId=vpc_id, CidrBlock=cidr_block)
return response
def get_vpcs():
"""Get info about all VPCs."""
client = get_client("ec2")
response = client.describe_vpcs()
return response
def delete_security_group(group_id):
"""Delete a security group."""
client = get_client("ec2")
response = client.delete_security_group(GroupId=group_id)
return response
def get_auto_scaling_groups():
"""Get info about all auto scaling groups."""
client = get_client("autoscaling")
response = client.describe_auto_scaling_groups()
return response
def get_security_groups():
"""Get info about all security groups."""
client = get_client("ec2")
response = client.describe_security_groups()
return response
def delete_vpc(subnet_id):
"""Delete a subnet."""
client = get_client("ec2")
response = client.delete_subnet(SubnetId=subnet_id)
return response
def get_elastic_load_balancers():
"""Get info about all elastic load balancers."""
client = get_client("elb")
response = client.describe_load_balancers()
return response
def get_launch_configurations():
"""Get info about all launch configurations."""
client = get_client("autoscaling")
response = client.describe_launch_configurations()
return response
def delete_elastic_load_balancer(name):
"""Delete an elastic load balancer."""
client = get_client("elb")
response = client.delete_load_balancer(
LoadBalancerName=name)
return response
def create_vpc(cidr_block):
"""Create a VPC."""
client = get_client("ec2")
response = client.create_vpc(CidrBlock=cidr_block)
return response
def get_instances():
"""Get info about all instances."""
client = get_client("ec2")
response = client.describe_instances()
return response
def delete_launch_configuration(name):
"""Delete a launch configuration."""
client = get_client("autoscaling")
response = client.delete_launch_configuration(
LaunchConfigurationName=name)
return response
def delete_instance(instance_id):
"""Delete an EC2 instance."""
client = get_client("ec2")
response = client.terminate_instances(InstanceIds=[instance_id])
return response
def create_keys(name):
"""Create a key pair."""
client = get_client("ec2")
response = client.create_key_pair(KeyName=name)
return response
def get_subnets():
"""Get info about all subnets."""
client = get_client("ec2")
response = client.describe_subnets()
return response
