docs: def create(vm_):
      '''
      Create a single VM from a data dict
      '''
      try:
          # Check for required profile parameters before sending any API calls.
          if (vm_['profile'] and
             config.is_profile_configured(__opts__,
                                          (__active_provider_name__ or
                                           'oneandone'),
                                          vm_['profile']) is False):
              return False
      except AttributeError:
          pass
  
      data = None
      conn = get_conn()
      hdds = []
  
      # Assemble the composite server object.
      server = _get_server(vm_)
  
      if not bool(server.specs['hardware']['fixed_instance_size_id'])\
          and not bool(server.specs['server_type'] == 'baremetal'):
          # Assemble the hdds object.
          hdds = _get_hdds(vm_)
  
      __utils__['cloud.fire_event'](
          'event',
          'requesting instance',
          'salt/cloud/{0}/requesting'.format(vm_['name']),
          args={'name': vm_['name']},
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      try:
          data = conn.create_server(server=server, hdds=hdds)
  
          _wait_for_completion(conn,
                               get_wait_timeout(vm_),
                               data['id'])
      except Exception as exc:  # pylint: disable=W0703
          log.error(
              'Error creating %s on 1and1\n\n'
              'The following exception was thrown by the 1and1 library '
              'when trying to run the initial deployment: \n%s',
              vm_['name'], exc, exc_info_on_loglevel=logging.DEBUG
          )
          return False
  
      vm_['server_id'] = data['id']
      password = data['first_password']
  
      def __query_node_data(vm_, data):
          '''
          Query node data until node becomes available.
          '''
          running = False
          try:
              data = show_instance(vm_['name'], 'action')
              if not data:
                  return False
              log.debug(
                  'Loaded node data for %s:\nname: %s\nstate: %s',
                  vm_['name'],
                  pprint.pformat(data['name']),
                  data['status']['state']
              )
          except Exception as err:
              log.error(
                  'Failed to get nodes list: %s', err,
                  # Show the trackback if the debug logging level is enabled
                  exc_info_on_loglevel=logging.DEBUG
              )
              # Trigger a failure in the wait for IP function
              return False
  
          running = data['status']['state'].lower() == 'powered_on'
          if not running:
              # Still not running, trigger another iteration
              return
  
          vm_['ssh_host'] = data['ips'][0]['ip']
  
          return data
  
      try:
          data = salt.utils.cloud.wait_for_ip(
              __query_node_data,
              update_args=(vm_, data),
              timeout=config.get_cloud_config_value(
                  'wait_for_ip_timeout', vm_, __opts__, default=10 * 60),
              interval=config.get_cloud_config_value(
                  'wait_for_ip_interval', vm_, __opts__, default=10),
          )
      except (SaltCloudExecutionTimeout, SaltCloudExecutionFailure) as exc:
          try:
              # It might be already up, let's destroy it!
              destroy(vm_['name'])
          except SaltCloudSystemExit:
              pass
          finally:
              raise SaltCloudSystemExit(six.text_type(exc.message))
  
      log.debug('VM is now running')
      log.info('Created Cloud VM %s', vm_)
      log.debug('%s VM creation details:\n%s', vm_, pprint.pformat(data))
  
      __utils__['cloud.fire_event'](
          'event',
          'created instance',
          'salt/cloud/{0}/created'.format(vm_['name']),
          args={
              'name': vm_['name'],
              'profile': vm_['profile'],
              'provider': vm_['driver'],
          },
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      if 'ssh_host' in vm_:
          vm_['password'] = password
          vm_['key_filename'] = get_key_filename(vm_)
          ret = __utils__['cloud.bootstrap'](vm_, __opts__)
          ret.update(data)
          return ret
      else:
          raise SaltCloudSystemExit('A valid IP address was not found.')