def up(): manager = digitalocean.Manager(token=token) keys = manager.get_all_sshkeys() for name in ubuntu: droplet = digitalocean.Droplet( token=token, name=name, region="sfo2", image="ubuntu-18-04-x64", size_slug="s-2vcpu-2gb", ssh_keys=keys, backups=False, ) droplet.create() for name in centos: droplet = digitalocean.Droplet( token=token, name=name, region="sfo2", image="centos-7-x64", size_slug="s-2vcpu-2gb", ssh_keys=keys, backups=False, ) droplet.create()
def test_update_volumes_data(self): droplet_response = self.load_from_file('droplets/single.json') volume_response = self.load_from_file('volumes/single.json') url_droplet =self.base_url + "droplets/12345" url_volume = self.base_url + "volumes/506f78a4-e098-11e5-ad9f-000f53306ae1" responses.add(responses.GET, url_droplet, body=droplet_response, status=200, content_type='application/json') responses.add(responses.GET, url_volume, body=volume_response, status=200, content_type='application/json') droplet = digitalocean.Droplet(id='12345', token=self.token) d = droplet.load() d.update_volumes_data() self.assert_get_url_equal(responses.calls[0].request.url, url_droplet) self.assert_get_url_equal(responses.calls[1].request.url, url_volume) self.assertEqual(len(d.volumes), 1) self.assertEqual(d.volumes[0].id, '506f78a4-e098-11e5-ad9f-000f53306ae1') self.assertEqual(d.volumes[0].name, 'example') self.assertEqual(d.volumes[0].region['slug'], 'nyc1')
def create_droplet(self, droplet, backend_region_id=None, backend_image_id=None, backend_size_id=None, ssh_key_uuid=None): if ssh_key_uuid: ssh_key = SshPublicKey.objects.get(uuid=ssh_key_uuid) backend_ssh_key = self.get_or_create_ssh_key(ssh_key) droplet.key_name = ssh_key.name droplet.key_fingerprint = ssh_key.fingerprint backend_droplet = digitalocean.Droplet( token=self.manager.token, name=droplet.name, user_data=droplet.user_data, region=backend_region_id, image=backend_image_id, size_slug=backend_size_id, ssh_keys=[backend_ssh_key.id] if ssh_key_uuid else []) backend_droplet.create() action_id = backend_droplet.action_ids[-1] droplet.backend_id = backend_droplet.id droplet.save() return action_id
def create_droplet(my_token, template_id, username, tags, user_data): # type: (str, str, str, List[str], str) -> str droplet = digitalocean.Droplet(token=my_token, name='{0}.zulipdev.org'.format(username), region='nyc3', image=template_id, size_slug='2gb', user_data=user_data, tags=tags, backups=False) print("Initiating droplet creation...") droplet.create() incomplete = True while incomplete: actions = droplet.get_actions() for action in actions: action.load() print("...[{0}]: {1}".format(action.type, action.status)) if action.type == 'create' and action.status == 'completed': incomplete = False break if incomplete: time.sleep(15) print("...droplet created!") droplet.load() print("...ip address for new droplet is: {0}.".format(droplet.ip_address)) return droplet.ip_address
def create_from_snapshot(self, snapshot): account_keys = self.manager.get_all_sshkeys() config_keys = self.config.get("ssh_keys") if config_keys: keys = [ key.id for key in account_keys if key.public_key in config_keys ] else: keys = [key.id for key in account_keys] my_droplets = self.manager.get_all_droplets() for drop in my_droplets: assert drop.name != self.name, "Droplet already exists" new_droplet = digitalocean.Droplet( name=self.name, size=self.config.get("size", "s-1vcpu-1gb"), image=snapshot.id, region=self.config.get("region", "nyc3"), ssh_keys=keys, monitoring=True, token=self.token, tags=[self.name], ) print(f"Creating droplet from snapshot {snapshot.id}") new_droplet.create() self.droplet = new_droplet
def droplet_create_from_latest_snapshot(manager, api_key, image_base_name, size_slug, region): my_droplet = get_curr_droplet(manager, image_base_name) if my_droplet is None: valheim_snap = get_newest_snap(manager, image_base_name) assert valheim_snap, ( f'could not find snapshot matching {image_base_name}') print(f'No droplet running, creating one ' f'from snapshot {valheim_snap.name}') my_droplet = digitalocean.Droplet(token=api_key, name=valheim_snap.name, region=region, image=valheim_snap.id, size_slug=size_slug, backups=False, monitoring=True, ssh_keys=manager.get_all_sshkeys()) my_droplet.create() # this function is a generator of status messages, and will # raise an error if it exceeds the maximum wait time. for status_msg in wait_for_active_droplet(my_droplet): print(status_msg) else: print(f'Droplet already exists at {my_droplet.ip_address}') for status_msg in wait_for_active_droplet(my_droplet): print(status_msg) print('Droplet is ready, you can now start the valheim server.')
def test_load(self): data = self.load_from_file('droplets/single.json') responses.add(responses.GET, self.base_url + "droplets/12345", body=data, status=200, content_type='application/json') droplet = digitalocean.Droplet(id='12345', token=self.token) d = droplet.load() self.assertEqual(responses.calls[0].request.url, self.base_url + "droplets/12345") self.assertEqual(d.id, 12345) self.assertEqual(d.name, "example.com") self.assertEqual(d.memory, 512) self.assertEqual(d.vcpus, 1) self.assertEqual(d.disk, 20) self.assertEqual(d.backups, False) self.assertEqual(d.ipv6, True) self.assertEqual(d.private_networking, False) self.assertEqual(d.region['slug'], "nyc3") self.assertEqual(d.status, "active") self.assertEqual(d.image['slug'], "ubuntu-14-04-x64") self.assertEqual(d.size_slug, '512mb') self.assertEqual(d.created_at, "2014-11-14T16:36:31Z") self.assertEqual(d.ip_address, "104.131.186.241") self.assertEqual(d.ip_v6_address, "2604:A880:0800:0010:0000:0000:031D:2001") self.assertEqual(d.kernel['id'], 2233) self.assertEqual(d.features, ["ipv6", "virtio"]) self.assertEqual(d.tags, [])
def create_droplet(domain): droplet = digitalocean.Droplet( token=token, name=domain, region='nyc3', # New York 3 image=os.environ['DIGITALOCEAN_DEFAULT_IMAGE'], size_slug='512mb', # 512MB backups=False ) droplet.create() actions = droplet.get_actions() status = '' while True: for action in actions: action.load() # Once it shows complete, droplet is up and running status = action.status print('Droplet creating status .. ' + status) if status == 'completed': break if status == 'completed': break else: time.sleep(2) return droplet
def create_droplet(self, name, wait=False): # Check volumes exist volumes = self.get_data_volumes(name) if not volumes: raise RuntimeError("No volumes exist for host %s" % name) dconf = self.hosts[name] print "Creating droplet %s (region %s)" % (name, dconf['region']) droplet = digitalocean.Droplet( token = self.token, name = name, region = dconf['region'], size_slug = dconf['size'], image = dconf['image'], ssh_keys = self.ssh_keys, backups = False, ipv6 = False, private_networking = False, user_data = self.cloud_config(name), ) droplet.create() done = False while not done: actions = droplet.get_actions() for action in actions: # can we use action.wait()? action.load() # Once it shows complete, droplet is up and running print " ...%s" % action.status done = action.status == "completed" self.attach_data_volumes(droplet) print "Host %s ip address %s" % \ (name, self.get_ip_addr(name)) # Side-effect: cache IP
def create_droplet(domain): manager = digitalocean.Manager(token=token) key = manager.get_ssh_key(sshkey) droplet = digitalocean.Droplet( token=token, name=domain, region='ams2', # Amsterdam 2 image=os.environ['DIGITALOCEAN_DEFAULT_IMAGE'], slug='centos7-2gb-1468403002394', size_slug='2gb', backups=False, ssh_keys=[key]) droplet.create() actions = droplet.get_actions() status = '' while True: for action in actions: action.load() # Once it shows complete, droplet is up and running status = action.status print('Droplet creating status .. ' + status) if status == 'completed': break if status == 'completed': break else: time.sleep(2) return droplet
def _create_droplet(public_key, world_name=''): key_name = 'hungcat-mc-ctl-' + public_key[-7:] droplet_name = 'minecraft-{}'.format(world_name) manager = digitalocean.Manager(token=DIGITALOCEAN_API_TOKEN) all_droplets = manager.get_all_droplets() existing_droplets = filter(lambda droplet: droplet.name == droplet_name, all_droplets) minecraft_droplet = None if len(existing_droplets) == 0: keys = manager.get_all_sshkeys() if len(filter(lambda k: k.name == key_name, keys)) == 0: key = digitalocean.SSHKey(token=DIGITALOCEAN_API_TOKEN, name=key_name, public_key=public_key) key.create() keys.append(key) droplet = digitalocean.Droplet(token=DIGITALOCEAN_API_TOKEN, name=droplet_name, region= DIGITALOCEAN_REGION_SLUG if DIGITALOCEAN_REGION_SLUG is not None else 'sgp1', image='docker-18-04', size_slug='2gb', ssh_keys=keys, backups=False) droplet.create() minecraft_droplet = manager.get_droplet(droplet.id) else: minecraft_droplet = existing_droplets[0] return minecraft_droplet
def test_create_no_keys(self): data = self.load_from_file('droplet_actions/create.json') responses.add(responses.POST, self.base_url + "droplets", body=data, status=202, content_type='application/json') droplet = digitalocean.Droplet(name="example.com", size_slug="512mb", image="ubuntu-14-04-x64", region="nyc3", backups=True, ipv6=True, private_networking=True, user_data="Some user data.", token=self.token) droplet.create() self.assert_url_query_equal(responses.calls[0].request.url, self.base_url + "droplets") self.maxDiff = None self.assertEqual( json.loads(responses.calls[0].request.body), {u"name": u"example.com", u"region": u"nyc3", u"user_data": u"Some user data.", u"ipv6": True, u"private_networking": True, u"backups": True, u"image": u"ubuntu-14-04-x64", u"size": u"512mb", u"ssh_keys": []}) self.assertEqual(droplet.id, 3164494) self.assertEqual(droplet.action_ids, [36805096])
def _create_droplet(public_key): key_name = 'minecraft-lambda-function-' + public_key[-7:] manager = digitalocean.Manager(token=DIGITALOCEAN_API_TOKEN) all_droplets = manager.get_all_droplets() existing_droplets = filter(lambda droplet: droplet.name == "minecraft", all_droplets) minecraft_droplet = None if len(existing_droplets) == 0: keys = manager.get_all_sshkeys() if len(filter(lambda k: k.name == key_name, keys)) == 0: key = digitalocean.SSHKey(token=DIGITALOCEAN_API_TOKEN, name=key_name, public_key=public_key) key.create() keys.append(key) droplet = digitalocean.Droplet( token=DIGITALOCEAN_API_TOKEN, name="minecraft", region=DIGITALOCEAN_REGION_SLUG if DIGITALOCEAN_REGION_SLUG is not None else "sgp1", image="docker-18-04", size_slug="2gb", ssh_keys=keys, backups=False) droplet.create() minecraft_droplet = manager.get_droplet(droplet.id) else: minecraft_droplet = existing_droplets[0] return minecraft_droplet
def create_droplet(self): if frappe.db.count( "Deployer Instance") + 1 > self.deployer_config.max_instances: self.set_pull_request_status( "Maximum number of concurrently active instances reached", "error") self.destroy_instance(error=True) return self.instance_name = '-'.join([ self.application_being_tested, "PR", str(self.pull_request_number), self.instance_requested_by ]) self.get_manager() self.droplet = digitalocean.Droplet( token=get_decrypted_password("Deployer Config", self.deployer_config.name, "do_token"), name=self.instance_name, size=self.parameters.get('droplet_size'), region="blr1", ssh_keys=self.manager.get_all_sshkeys(), image=self.deployer_config.snapshot_id) self.droplet.create() while True: action = self.droplet.get_actions()[0] if (action.type, action.status) == ('create', 'completed'): break sleep(10) self.droplet = self.manager.get_droplet(self.droplet.id) self.instance_url = self.droplet.ip_address self.droplet_id = self.droplet.id self.is_active = True self.instance_created_at = frappe.utils.now() self.save(ignore_permissions=True) return True
def restore_droplet(snapshot, keys, api_key, region='nyc1', size_slug='2gb', name='starbound-server', backups=False): print "Pushing snapshot {} to a fresh droplet".format(snapshot) droplet = digitalocean.Droplet(token=api_key, name=name, ssh_keys=keys, region=region, image=snapshot, size_slug=size_slug, backups=backups) # Create the Droplet and wait for it to complete droplet.create() action = digitalocean.Action(id=droplet.action_ids[0], token=droplet.token, droplet_id=droplet.id) action.load() action.wait() created = droplet.load() print "Droplet Created at {}".format(droplet.ip_address)
def getDroplets(self, hosts): retValue = {} droplets = self.manager.get_all_droplets() for h, v in hosts.items(): if hosts[h]['enabled']: for droplet in droplets: if droplet.name == h: retValue[droplet.name] = droplet if h not in retValue: for curkey in self.manager.get_all_sshkeys(): if curkey.name == v['sshkey']: sshkey = curkey continue droplet = digitalocean.Droplet( token=self.apikey, name=h, region=v['region'], image=v['image'], size_slug=v['size_slug'], ssh_keys=[sshkey], monitoring=True, backups=False, ) retValue[h] = droplet return retValue
def create_droplet(self): if self.checking_droplet() is True: self.ip_address = self.fetching_ip_address() self.start_installation() else: self.keys = self.manager.get_all_sshkeys() print("Creating the droplet") try: droplet = digitalocean.Droplet(token=self.api_key, name=self.droplet_name, region='nyc1', # New York 2 image='centos-7-x64', # Ubuntu 14.04 x64 size_slug='512mb', ssh_keys=self.keys,# 512MB backups=False, tags=self.droplet_tag_name ) droplet.create() time.sleep(30) print("----Droplet Created--------") print('Ip_address of ' + self.droplet_name + ' Tag name is ' + self.tag + ' ' + self.fetching_ip_address()) self.droplet_tag_name.clear() self.ip_address=self.fetching_ip_address() print("-------Droplet Created---------") time.sleep(4) logging.info("Starting installation") #self.start_installation() self.start_installation()
def spinupServer(token, ssh_key, verbose): # DO NOT RUN WITHOUT MY PERMISSION, THIS IS A PAID SERVICE, always close server when done # ask DigitalOcean.com to provision a server (d for droplet) snaps = digitalocean.Manager(token = pytoken).get_my_images() d = digitalocean.Droplet(token=pytoken, name='test'+token, region= 'nyc3', image= "ubuntu-16-04-x64", #Ubuntu 16.04.1 x64 #manager = digitalocean.Manager(token = pytoken) #manager.get_all_images() size_slug='1gb', ssh_keys = [ssh_key.id], backups=True) d.create() while True: d.load() if d.ip_address!=None: print("Bucking up and starting engines...") sys.stdout.flush() break while True: if "completed" in str(d.get_actions()[0].status): break if len(snaps) != 0: d.rebuild(int(snaps[0].id)) return d
def create_droplet(branch, githash): user_data = open(startup_script).read() # use all keys registered at digitalocean keys = get_manager().get_all_sshkeys() setenvs = [] for var, value in read_environemnt().items(): assert var.replace('_', '').isalnum() export = '{var}=$(cat <<-{eof}\n{value}\n{eof}\n)'.format( value=value, var=var, eof=uuid4().hex) setenvs.append(export) user_data = expand_config_vars( user_data, { 'GITHASH': githash, 'BRANCH': branch, 'SETENVS': ' '.join(setenvs), 'STARTUP': read_startup() }) droplet = digitalocean.Droplet( token=config['DIGITAL_OCEAN_TOKEN'], name='{}{}--{}'.format(NAME_PREFIX, githash, branch), region='fra1', image='docker-20-04', size_slug='s-2vcpu-4gb', user_data=user_data, ssh_keys=keys, # Automatic conversion backups=False) droplet.create() return droplet
def create_do_droplet(config): status={"command":"create_do_droplet","status":False,"message":"FALSE","droplet":None} # Time it takes to build a Droplet time_to_build = 80 manager = digitalocean.Manager(token=config['token']) droplet = digitalocean.Droplet(token=config['token'], name=config['name'], region=config['region'], image=config['image'], size_slug=config['size'], backups=config['backups'], ipv6=config['ipv6'], ssh_keys=config['ssh_keys'], tags=config['tags'] ) try: droplet.create() except digitalocean.DataReadError as e: status['message']=e return status except digitalocean.Error as e: status['message']=e return status # Sleep for time_to_build time.sleep(time_to_build) newDroplet = manager.get_droplet(droplet.id) status['status']=True status['message']="Droplet Created" status['droplet']=newDroplet return status
def create_vpn(self, args): keys = self.manager.get_all_sshkeys() vpn_name = "vpn-{0}".format(self.date) self.vpn_user_data = self.generate_user_data( args.gmail_user, args.gmail_user_password, args.gmail_notify_email_list) vpn = digitalocean.Droplet( token=self.token, tags=[vpn_name], region=args.do_region, name=vpn_name, size_slug=args.do_size, image="ubuntu-18-04-x64", ssh_keys=keys, backups=False, ipv6=True, user_data=self.vpn_user_data, private_networking=False, ) vpn.create() print("Created VPN: {0}. Please wait for email.".format(vpn_name))
def do_newfromimage(self, image_id): if self.manager: if len(image_id) > 1: sizes = self.manager.get_all_sizes() for i, j in enumerate(sizes): print("{0} - {1}, per month: ${2}".format( i, j.slug.upper(), j.price_monthly)) print(colored("X - Exit", "red")) response = input("Choice:") if response.upper() == "X": print_log("Cancelled.", "info") try: image = self.manager.get_image(image_id) import random droplet = digitalocean.Droplet( token=self.uniqueKey, name=image.name, region=random.choice(image.regions), image=image.id, size_slug=sizes[int(response)].slug) droplet.create() print_log("Droplet creation initiated successfully!", "success") except DataReadError as err: print_log(err, "error") else: print_log("Please enter a image id!", "error") else: print_log("Login first!", "error")
def resurrect(self, size=1, image=None, ssh_keys=None): version = self.next_version_number() tag = api.Tag(token=self.token, name=self.name) tag.create() # create tag if not already created result = [] for _ in range(0, size): server = api.Droplet(token=self.token, name=f"{self.name}{version}", region='ams3', size='s-1vcpu-1gb', private_networking=True, ipv6=True, backups=False, ssh_keys=ssh_keys or settings.DO_SSH_KEYS, image=image or settings.DO_OBJECT_IMAGE # tags=[tag], ) r = server.create() if r or r is None: tag.add_droplets([str(server.id)]) result.append((server, r)) version = version + 1 return result
async def create_vm(self): self.droplet = digitalocean.Droplet( token=self.config.get("token"), name=self.name, region=self.region, image=self.image, size_slug=self.size, backups=False, user_data=self.cluster.render_cloud_init( image=self.docker_image, command=self.command, gpu_instance=self.gpu_instance, bootstrap=self.bootstrap, env_vars=self.env_vars, ), ) await self.cluster.call_async(self.droplet.create) for action in self.droplet.get_actions(): while action.status != "completed": action.load() await asyncio.sleep(0.1) while self.droplet.ip_address is None: await self.cluster.call_async(self.droplet.load) await asyncio.sleep(0.1) self.cluster._log(f"Created droplet {self.name}") return self.droplet.ip_address
def make_droplet(name, region, image, size, backups=0, ssh_key=0): token = get_token() key_list = [] if backups == 0: backups = False elif backups == 1: backups = True else: backups == False if int(ssh_key) != 0: key_list.append(int(ssh_key)) try: droplet = digitalocean.Droplet(token=token, name=name, region=region, image=image, size=size, backups=backups, ssh_keys=key_list) droplet.create() droplet = get_droplet(str(droplet).split(" ")[0]) return droplet except Exception as e: message = "Failed to create droplet, DO API responded: %s" % str( e.args) create_log(message, 3)
def startServer(self): print("starting..") # get latest snapshot, with given prefix snapshot = self.__fetchSnapshot(self.prefix) keys = self.manager.get_all_sshkeys() #print(self.manager.get_all_regions()) # create droplet based on it droplet = digitalocean.Droplet( token=self.manager.token, name=self.prefix + "DROPLET-" + self.__getTimeString(), region='fra1', # Frankfurt # https://www.digitalocean.com/community/questions/create-droplet-from-snapshot-by-rest-api image=snapshot.id, # current latest snapshot size_slug='s-2vcpu-4gb', # 1GB RAM, 1 vCPU ssh_keys=keys, # Automatic conversion backups=False) droplet.create() # delete snapshot snapshot.destroy() pass
def createServer(): print "Creating a new remote server in %s..." % (region) keys = manager.get_all_sshkeys() droplet = digitalocean.Droplet(token=apiToken, name='vpnServer', region=region, image='ubuntu-16-04-x64', size_slug='512mb', ssh_keys=keys, backups=False) droplet.create() actions = droplet.get_actions() print droplet print droplet.name print droplet.ip_address setup = False print actions for action in actions: setUp = action.wait() if setUp: droplet.load() ip_address = droplet.ip_address print "Remote server was created. IP Address: " + ip_address return ip_address else: print "Remote server could not be created." return 0
def create_srv(team_name, cloud_config="", is_admin=False, max_retries=3, current_try=1): keys = manager.get_all_sshkeys() droplet = digitalocean.Droplet( token=token, name=f"{team_name}-{random.choice(words)}", image=random.choice(possible_images), region=DEF_REGION, size_slug='512mb', user_data=cloud_config, backups=BACKUPS_ENABLED, keys=keys if is_admin else [] ) droplet.create() actions = droplet.get_actions() active = False while not active: for action in actions: action.load() if action.status == "completed": active = True time.sleep(2) if rkn_logic.is_it_blocked(droplet.ip_address): droplet.destroy() if current_try <= max_retries: return create_srv(team_name, current_try=current_try + 1) raise RecursionError('Max retries reached') return droplet
def create_droplet(my_token: str, template_id: str, name: str, tags: List[str], user_data: str) -> str: droplet = digitalocean.Droplet( token=my_token, name=name, region="nyc3", image=template_id, size_slug="s-1vcpu-2gb", user_data=user_data, tags=tags, backups=False, ) print("Initiating droplet creation...") droplet.create() incomplete = True while incomplete: actions = droplet.get_actions() for action in actions: action.load() print(f"...[{action.type}]: {action.status}") if action.type == "create" and action.status == "completed": incomplete = False break if incomplete: time.sleep(15) print("...droplet created!") droplet.load() print(f"...ip address for new droplet is: {droplet.ip_address}.") return droplet.ip_address
def drip(self, name, do_region, do_image_slug, do_size_slug, do_ssh_key_names): # FIXME: this should propably work like _manipulate_dns, recreating droplets when they exist droplet = digitalocean.Droplet( token=self.do_token, name=name, region=do_region, image=do_image_slug, size_slug=do_size_slug, backups=False, ipv6=True, private_networking=True, ssh_keys=self._get_ssh_keys_by_names(do_ssh_key_names)) self._logger.info('droplet %s: creating...', name) droplet.create() self._logger.info('droplet %s: id: %s', name, droplet.id) while not (droplet.ip_address and droplet.ip_v6_address): time.sleep(1) self._logger.info('droplet %s: waiting for ip addresses', name) droplet.load() self._logger.info('droplet %s: ips: %s, %s, %s', name, droplet.ip_address, droplet.ip_v6_address, droplet.private_ip_address.lower()) return droplet