def allocate_public_address(self, instance_id):
""" Assign a public IP address to an ECS instance.
:param instance_id: The ID of the instance to which you want to
assign a public IP address.
:return: The assigned ip.
"""
request = AllocatePublicIpAddressRequest()
request.set_InstanceId(instance_id)
response = self._send_request(request)
if response is not None:
return response.get("IpAddress")
def allocate_public_address(self, instance_id):
status = self.get_instance_status_by_id(instance_id)
if status != ECS_STATUS_STOPPED and status != ECS_STATUS_RUNNING:
logger.warning("instance [%s] is not in [%s],current status [%s], cannot allocate_public_address",
instance_id,
",".join([ECS_STATUS_STOPPED, ECS_STATUS_RUNNING]), status)
return None
request = AllocatePublicIpAddressRequest()
request.set_InstanceId(instance_id)
response = self.execute(request)
logger.info("allocate address [%s] for [%s],", response["IpAddress"], instance_id)
return response["IpAddress"]
def _boot_image(self, zone_id, image_id, instance_type, vswitch_id,
instance_name, ssh_keyname, security_group_id):
request = CreateInstanceRequest()
request.set_ImageId(image_id)
request.set_SecurityGroupId(security_group_id)
request.set_InstanceType(instance_type)
request.set_VSwitchId(vswitch_id)
request.set_ZoneId(zone_id)
request.set_InstanceChargeType('PostPaid')
request.set_KeyPairName(ssh_keyname)
request.set_InternetMaxBandwidthOut(1)
response = self._send_request(request)
instance_id = response.get('InstanceId')
if instance_id is None:
logger.info(response)
raise Exception("Instance could not be created.")
self.instance_id = instance_id
logger.info("Instance %s created" % instance_id)
logger.info(
"Wait for the instance to appear as stopped so we can continue")
max_tries = 10
status = None
while max_tries > 0 and status != 'Stopped':
max_tries -= 1
time.sleep(5)
status = self._get_instance_status_by_id(instance_id)
if status != 'Stopped':
raise Exception("VM %s not in desired state" % instance_id)
logger.info("Allocating public ip for instance %s" % instance_id)
request = AllocatePublicIpAddressRequest()
request.set_InstanceId(instance_id)
ip_address = self._send_request(request)
logger.info("Public IP address asssigned to instance: %s" % ip_address)
logger.info(json.dumps(ip_address, indent=4))
logger.info("Starting instance %s" % instance_id)
request = StartInstanceRequest()
request.set_InstanceId(instance_id)
self._send_request(request)
# wait for instance to be started
max_tries = 60
status = "initial"
while max_tries > 0 and status != 'Running':
max_tries -= 1
time.sleep(10)
status = self._get_instance_status_by_id(instance_id)
logger.info("Status is %s" % status)
if status != 'Running':
raise Exception("Instance %s status is %s: failed to start." %
(instance_id, status))
return (instance_id, ip_address)
def allocatePublicIpAddress(InstanceId):
request = AllocatePublicIpAddressRequest()
request.set_accept_format('json')
request.set_InstanceId(InstanceId)
response = client.do_action_with_exception(request)
response = json.loads(str(response, encoding='utf-8'))
return response
def AllocatePublicIpAddress(ak, sk, region_tag, instance_id):
client = AcsClient(ak, sk, region_tag)
request = AllocatePublicIpAddressRequest()
request.set_accept_format('json')
request.set_InstanceId(instance_id)
response = client.do_action_with_exception(request)
print(str(response, encoding='utf-8'))
def Add_Ip(self, instance_id):
request = AllocatePublicIpAddressRequest()
request.set_accept_format('json')
request.add_query_param('InstanceId', instance_id)
response = self._send_request(request)
#logging.info("instance %s created task submit successfully.", instance_id)
return response
def AllocatePublicIpAddress(self, region_id, InstanceId):
"""
绑定外网IP
:param region_id: 地域
:param InstanceId: 实例ID
:return: {'IpAddress': '39.106.176.130'}
"""
client = AcsClient(self.AccessKeyId, self.AccessKeySecret, region_id)
request = AllocatePublicIpAddressRequest()
request.set_accept_format('json')
request.set_InstanceId(InstanceId)
response = client.do_action_with_exception(request)
res = json.loads(response, encoding='utf-8')
return res
def make():
security_group_dict = acdb.db.load(
"security_group_dict") # map[region_id]security_group_id
region_instance_id_list = []
# Check image id is avaliable
for node_conf in conf.config["ecs"]["node"]:
print("Get request", node_conf)
client = AcsClient(
conf.secret["aliyun"]["access_key"],
conf.secret["aliyun"]["access_secret"],
node_conf["region_id"],
)
req = DescribeImagesRequest()
req.set_Status("Available")
req.set_ImageOwnerAlias("system")
req.set_InstanceType(node_conf["instance_type"])
req.set_OSType("linux")
req.set_PageSize(100)
req.set_ActionType("CreateEcs")
res = json.loads(client.do_action_with_exception(req))
all_avaliable_image = [e["ImageId"] for e in res["Images"]["Image"]]
assert node_conf["image"] in all_avaliable_image
# Create ECS instance
for node_conf in conf.config["ecs"]["node"]:
client = AcsClient(
conf.secret["aliyun"]["access_key"],
conf.secret["aliyun"]["access_secret"],
node_conf["region_id"],
)
req = CreateInstanceRequest()
req.set_ImageId(node_conf["image"])
req.set_SecurityGroupId(security_group_dict[node_conf["region_id"]])
req.set_Password(conf.secret["aliyun"]["ecs_password"])
req.set_InstanceChargeType("PostPaid")
req.set_SystemDiskCategory("cloud_efficiency")
req.set_SystemDiskSize(c_system_disk_size)
req.set_InstanceType(node_conf["instance_type"])
req.set_InternetMaxBandwidthOut(
node_conf["internet_max_bandwidth_out"])
req.set_KeyPairName(c_keypair_name)
res = json.loads(client.do_action_with_exception(req))
instance_id = res["InstanceId"]
print("Create", node_conf["region_id"], instance_id)
region_instance_id_list.append([node_conf["region_id"], instance_id])
print("Wait")
for _ in range(1 << 32):
if sum([
e["Status"] == "Stopped" for e in info(region_instance_id_list)
]) == len(region_instance_id_list):
break
for (region_id, instance_id) in region_instance_id_list:
client = AcsClient(
conf.secret["aliyun"]["access_key"],
conf.secret["aliyun"]["access_secret"],
region_id,
)
# Allocate public ip address
req = AllocatePublicIpAddressRequest()
req.set_accept_format("json")
req.set_InstanceId(instance_id)
client.do_action_with_exception(req)
print("Allocate public ip address", region_id, instance_id)
# Start ECS instance
req = StartInstanceRequest()
req.set_accept_format("json")
req.set_InstanceId(instance_id)
res = json.loads(client.do_action_with_exception(req))
print("Start", region_id, instance_id)
print("Wait")
for _ in range(1 << 32):
if sum([
e["Status"] == "Running" for e in info(region_instance_id_list)
]) == len(region_instance_id_list):
break
# Get ECS info
acdb.db.save("instance_list", info(region_instance_id_list))
print(
f"Instance info saved at {conf.config['db']['path']}/instance_list.json"
)