def loadKey(keyName, keyFile): keyValue = open(keyFile).read().strip() sshKey = digitalocean.SSHKey(token=doApiToken) sshKey.load_by_pub_key(keyValue) if not sshKey.fingerprint: print "Creating key: %s" % keyName sshKey = digitalocean.SSHKey(token=doApiToken, public_key=keyValue, name=keyName) sshKey.create() else: print "Key already exists: %s" % keyName return sshKey
def _create_ssh_keys(manager: digitalocean.Manager) -> List[digitalocean.SSHKey]: """ Upload a ssh public key to Digital Ocean, if not already loaded. If it is already loaded, then just get the id. :return: List of SSHkey objects. """ registered_keys = manager.get_all_sshkeys() ssh_keys = [] print('Registering SSH keys...') print('Known keys:') print('\n'.join([key.name for key in registered_keys])) key = DIGITAL_OCEAN_PUBLIC_KEY print(f'Checking key: {key}') with open(os.path.join(SSH_PATH, f"{key}")) as file: public_key = file.read().rstrip('\n') registered = [rkey for rkey in registered_keys if rkey.public_key == public_key] for rkey in registered_keys: if rkey.public_key == public_key: ssh_keys.append(registered[0]) print( f'SSH key {key} verified already registered as ' f'{registered[0].name}.') break else: key = digitalocean.SSHKey( name=key, public_key=public_key, token=DIGITAL_OCEAN_TOKEN, ) key.create() ssh_keys.append(key) print(f'SSH key {key} has now been registered with name {key.name}') return ssh_keys
def create_ssh_key(name: str, public_key: str) -> digitalocean.SSHKey: action_public_ssh_key_object = digitalocean.SSHKey(name=name, public_key=public_key, token=manager.token) set_api_request_retry_limits(action_public_ssh_key_object) action_public_ssh_key_object.create() return action_public_ssh_key_object
def push_ssh_key(self, ssh_key): backend_ssh_key = digitalocean.SSHKey(token=self.manager.token, name=ssh_key.name, public_key=ssh_key.public_key) backend_ssh_key.create() return backend_ssh_key
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 _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 pull_ssh_key(self, name, fingerprint): backend_ssh_key = digitalocean.SSHKey( token=self.manager.token, fingerprint=fingerprint, name=name, id=None ) backend_ssh_key.load() return backend_ssh_key
def _create_ssh_key(self): """ Creates a new SSH key """ self._ssh_key = digitalocean.SSHKey( token=settings.DIGITALOCEAN_API_TOKEN, name=settings.APP_NAME, public_key=self.public_key, ) self._ssh_key.create() return self._ssh_key
def __add_ssh_key_to_digitalocean(self): print('Adding public key {} to DigitalOcean'.format(self.keyname)) # check for existing key, and delete for key in self.manager.get_all_sshkeys(): if key.name == self.keyname: key.destroy() key = digitalocean.SSHKey(token=os.getenv('DO_TOKEN'), name=self.keyname, public_key=self.pubkey) key.create()
def create_ssh_key(self, name: str, public_key_content: str) -> str: ssh_key_data = { 'name': name, 'public_key': public_key_content } ssh_key = digitalocean.SSHKey( token=self.api_token, **ssh_key_data ) ssh_key.create() return ssh_key.id
def _generate_ssh_key(self): self._print_info('generating ssh key') self.ssh_key = paramiko.rsakey.RSAKey.generate(2048, str(uuid.uuid4())) self._print_info('create ssh key on DigitalOcean') self.digital_ocean_ssh_key = digitalocean.SSHKey( token=self.token, name=SSH_KEY_NAME, public_key='ssh-rsa {key}'.format( key=str(self.ssh_key.get_base64()))) self.digital_ocean_ssh_key.create()
def add_key(api_token): data_path = ansible_data.playbook_path() public_key = open(data_path + '/env/ssh_key.pub').read() key = digitalocean.SSHKey(token=api_token, name='VPN-Deployer', public_key=public_key) key.create() with open(data_path + '/env/ssh_key.id', 'w+') as f: f.write(str(key.id)) return key.id
def get_ssh_key_id(self, key): """ Get the DigitalOcean ID for the SSH key. If the SSH key hasn't been uploaded to DigitalOcean, upload it. """ if key.digitalocean_id: return key.digitalocean_id else: new_do_key = digitalocean.SSHKey(token=self._token, name='minecraftserver', public_key=key.public_key) new_do_key.create() key.digitalocean_id = new_do_key.id key.save(update_fields=['digitalocean_id']) return new_do_key.id
def __init__(self, username): """ Generate a keypair for the specified username. username : string >>> key = SshKeypair('Bob') >>> key.username == 'Bob' and type(key.pemFilePathnameAsStr) == str and type(key.doSshKey) == digitalocean.SSHKey True """ super(SshKeypair, self).__init__() self.writeToDisk(passPhrase="") publicKey = self.publicKeyOpensshAsBytes.decode('utf-8') self.username = username self.doSshKey = digitalocean.SSHKey() self.doSshKey.token = getApiToken() self.doSshKey.public_key = publicKey self.doSshKey.name = os.path.basename(self.pemFilePathnameAsStr) self.doSshKey.create()
def __init__(self, key_name='key'): tmp_dir = tempfile.TemporaryDirectory() self._persist_tmp_dir = tmp_dir tmp_path = Path(tmp_dir.name) prv_key_path = tmp_path / key_name self.prv_key_pathstr = prv_key_path.as_posix() cmd = [ 'ssh-keygen', '-t', 'ed25519', '-a', '123', '-f', self.prv_key_pathstr, '-C', 'VPN', '-N', '' ] subprocess.check_output(cmd) pub_key_path = tmp_path / (key_name + '.pub') pub_key_path.chmod(0o600) pub_key = pub_key_path.open().read() pub_do_key = do.SSHKey(token=token, name=key_name, public_key=pub_key) pub_do_key.create() self.pub_do_key = pub_do_key
def deploy( self, sshkey=None, region="Amsterdam 3", image="ubuntu 18.04", size_slug="s-1vcpu-2gb", delete=True, project_name=None, ): """ Deploy your Droplet to Digital Ocean Args sshkey (string): sshkey name used on digital ocean (if not set it will use the default one which already loaded) region (string): region name to deploy to image (string): Image name to be used size_slug (string): size of the droplet (s-1vcpu-2gb,s-6vcpu-16gb,gd-8vcpu-32gb) delete (bool): delete the droplet if it is already deployed on digital ocean project_name (string): project to add this droplet it. If not specified the default project will be used. """ project = None if project_name: project = self.parent.projects.get_project_exist_remote(project_name) if not project: raise j.exceptions.Input("could not find project with name:%s" % project_name) # Get ssh if not sshkey: sshkey_do = self.parent.get_default_sshkey() if not sshkey_do: # means we did not find the sshkey on digital ocean yet, need to create sshkey = self.parent.sshkey key = digitalocean.SSHKey( token=self.parent.projects.parent_instance.token, name=sshkey.name, public_key=sshkey.public_key ) key.create() sshkey_do = self.parent.get_default_sshkey() assert sshkey_do sshkey = sshkey_do.name if self.parent.droplets.check_droplet_exist_remote(self.do_name): dr0 = self.parent.droplets.get_droplet_exist_remote(self.do_name) if delete: dr0.destroy() else: sshcl = j.clients.sshclient.get(name="do_%s" % self.do_name, host=dr0.ip_address, sshkey=sshkey) return dr0, sshcl sshkey = self.parent.droplets.parent_instance.get_sshkey(sshkey) region = self.parent.droplets.parent_instance.get_region(region) imagedo = self.parent.droplets.parent_instance.get_image(image) img_slug_or_id = imagedo.slug if imagedo.slug else imagedo.id droplet = digitalocean.Droplet( token=self.parent.droplets.parent_instance.token, name=self.do_name, region=region.slug, image=img_slug_or_id, size_slug=size_slug, ssh_keys=[sshkey], backups=False, ) droplet.create() if project: project.assign_resources(["do:droplet:%s" % droplet.id])
def droplet_create( self, name="test", sshkey=None, region="Amsterdam 3", image="ubuntu 18.04", size_slug="s-1vcpu-2gb", delete=True, project_name=None, ): """ :param name: :param sshkey: :param region: :param image: :param size_slug: s-1vcpu-2gb,s-6vcpu-16gb,gd-8vcpu-32gb :param delete: :param mosh: when mosh will be used to improve ssh experience :param project_name: project to add this droplet it. If not specified the default project will be used. :return: droplet,sshclient """ project = None if project_name: project = self._project_get(project_name) if not project: raise j.exceptions.Input("could not find project with name:%s" % project_name) delete = j.data.types.bool.clean(delete) sshkey = j.data.types.string.clean(sshkey) if not sshkey: sshkey_do = self._sshkey_get_default() if not sshkey_do: sshkey_ = j.clients.sshkey.default # means we did not find the sshkey on digital ocean yet, need to create key = digitalocean.SSHKey(token=self.token_, name=sshkey_.name, public_key=sshkey_.pubkey) key.create() sshkey_do = self._sshkey_get_default() assert sshkey_do sshkey = sshkey_do.name if self.droplet_exists(name): dr0 = self._droplet_get(name=name) if delete: dr0.destroy() else: sshcl = j.clients.ssh.get(name="do_%s" % name, addr=dr0.ip_address, sshkey_name=sshkey) sshcl.save() return dr0, sshcl sshkey = self.sshkey_get(sshkey) region = self.region_get(region) imagedo = self.image_get(image) if region.slug not in imagedo.regions: j.shell() img_slug_or_id = imagedo.slug if imagedo.slug else imagedo.id droplet = digitalocean.Droplet( token=self.token_, name=name, region=region.slug, image=img_slug_or_id, size_slug=size_slug, ssh_keys=[sshkey], backups=False, ) droplet.create() # dr = self.get(name=name) # dr.do_id = droplet.id self._droplets.append(droplet) self.reset() if project: project.assign_resources(["do:droplet:%s" % droplet.id]) vm = self._vm_get(name) vm.do_id = droplet.id self.save() def actions_wait(): while True: actions = droplet.get_actions() if len(actions) == 0: return for action in actions: action.load() # Once it shows complete, droplet is up and running print(action.status) if action.status == "completed": return actions_wait() droplet.load() sshcl = j.clients.ssh.get(name="do_%s" % name, addr=droplet.ip_address, sshkey_name=sshkey.name) sshcl.save() return droplet, sshcl
'Failed to put droplet ' + str(droplet.name) + ' up. Timeout (' + str(timeout) + 'ms).', 'timeout')) token = env('DEPLOY_API_TOKEN') if token is None: raise EnvironmentError( log.err('Environment variable DEPLOY_API_TOKEN is empty.')) public_key = env('PUBLIC_KEY') if public_key is None: raise EnvironmentError( log.err('Environment variable PUBLIC_KEY is empty.')) key_name = env('KEY_NAME', public_key.split()[-1]) ssh_key = digitalocean.SSHKey(token=token).load_by_pub_key(public_key) if ssh_key is None: ssh_key = digitalocean.SSHKey(token=token) ssh_key.name = key_name ssh_key.public_key = public_key ssh_key.create() droplet_name = env('AZK_MID', 'azk-deploy') droplet_name = env('BOX_NAME', droplet_name) droplet_region = env('BOX_REGION', 'nyc3') droplet_image = env('BOX_IMAGE', 'ubuntu-14-04-x64') droplet_size = env('BOX_SIZE', '1gb') droplet_backup = True if env('BOX_BACKUP', 'false') == 'true' else None droplet_private_networking = True if env('BOX_PRIVATE_NETWORKING', 'false') == 'true' else None