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 'aliyun',
                                                             vm_['profile'],
                                                             vm_=vm_) is False:
              return False
      except AttributeError:
          pass
  
      __utils__['cloud.fire_event'](
          'event',
          'starting create',
          'salt/cloud/{0}/creating'.format(vm_['name']),
          args=__utils__['cloud.filter_event']('creating', vm_, ['name', 'profile', 'provider', 'driver']),
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      log.info('Creating Cloud VM %s', vm_['name'])
      kwargs = {
          'name': vm_['name'],
          'size_id': get_size(vm_),
          'image_id': get_image(vm_),
          'region_id': __get_location(vm_),
          'securitygroup_id': get_securitygroup(vm_),
      }
      if 'vswitch_id' in vm_:
          kwargs['VSwitchId'] = vm_['vswitch_id']
      if 'internet_chargetype' in vm_:
          kwargs['InternetChargeType'] = vm_['internet_chargetype']
      if 'internet_maxbandwidthin' in vm_:
          kwargs['InternetMaxBandwidthIn'] = six.text_type(vm_['internet_maxbandwidthin'])
      if 'internet_maxbandwidthout' in vm_:
          kwargs['InternetMaxBandwidthOut'] = six.text_type(vm_['internet_maxbandwidthOut'])
      if 'hostname' in vm_:
          kwargs['HostName'] = vm_['hostname']
      if 'password' in vm_:
          kwargs['Password'] = vm_['password']
      if 'instance_name' in vm_:
          kwargs['InstanceName'] = vm_['instance_name']
      if 'systemdisk_category' in vm_:
          kwargs['SystemDisk.Category'] = vm_['systemdisk_category']
  
      __utils__['cloud.fire_event'](
          'event',
          'requesting instance',
          'salt/cloud/{0}/requesting'.format(vm_['name']),
          args=__utils__['cloud.filter_event']('requesting', kwargs, list(kwargs)),
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      try:
          ret = create_node(kwargs)
      except Exception as exc:
          log.error(
              'Error creating %s on Aliyun ECS\n\n'
              'The following exception was thrown when trying to '
              'run the initial deployment: %s',
              vm_['name'], six.text_type(exc),
              # Show the traceback if the debug logging level is enabled
              exc_info_on_loglevel=logging.DEBUG
          )
          return False
      # repair ip address error and start vm
      time.sleep(8)
      params = {'Action': 'StartInstance',
                'InstanceId': ret}
      query(params)
  
      def __query_node_data(vm_name):
          data = show_instance(vm_name, call='action')
          if not data:
              # Trigger an error in the wait_for_ip function
              return False
          if data.get('PublicIpAddress', None) is not None:
              return data
  
      try:
          data = salt.utils.cloud.wait_for_ip(
              __query_node_data,
              update_args=(vm_['name'],),
              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))
  
      if data['public_ips']:
          ssh_ip = data['public_ips'][0]
      elif data['private_ips']:
          ssh_ip = data['private_ips'][0]
      else:
          log.info('No available ip:cant connect to salt')
          return False
      log.debug('VM %s is now running', ssh_ip)
      vm_['ssh_host'] = ssh_ip
  
      # The instance is booted and accessible, let's Salt it!
      ret = __utils__['cloud.bootstrap'](vm_, __opts__)
      ret.update(data)
  
      log.info('Created Cloud VM \'%s\'', vm_['name'])
      log.debug(
          '\'%s\' VM creation details:\n%s',
          vm_['name'], pprint.pformat(data)
      )
  
      __utils__['cloud.fire_event'](
          'event',
          'created instance',
          'salt/cloud/{0}/created'.format(vm_['name']),
          args=__utils__['cloud.filter_event']('created', vm_, ['name', 'profile', 'provider', 'driver']),
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      return ret