docs: def create(server_):
      '''
      Create a single BareMetal server from a data dict.
      '''
      try:
          # Check for required profile parameters before sending any API calls.
          if server_['profile'] and config.is_profile_configured(__opts__,
                                                                 __active_provider_name__ or 'scaleway',
                                                                 server_['profile'],
                                                                 vm_=server_) is False:
              return False
      except AttributeError:
          pass
  
      __utils__['cloud.fire_event'](
          'event',
          'starting create',
          'salt/cloud/{0}/creating'.format(server_['name']),
          args=__utils__['cloud.filter_event']('creating', server_, ['name', 'profile', 'provider', 'driver']),
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      log.info('Creating a BareMetal server %s', server_['name'])
  
      access_key = config.get_cloud_config_value(
          'access_key', get_configured_provider(), __opts__, search_global=False
      )
  
      commercial_type = config.get_cloud_config_value(
          'commercial_type', server_, __opts__, default='C1'
      )
  
      key_filename = config.get_cloud_config_value(
          'ssh_key_file', server_, __opts__, search_global=False, default=None
      )
  
      if key_filename is not None and not os.path.isfile(key_filename):
          raise SaltCloudConfigError(
              'The defined key_filename \'{0}\' does not exist'.format(
                  key_filename
              )
          )
  
      ssh_password = config.get_cloud_config_value(
          'ssh_password', server_, __opts__
      )
  
      kwargs = {
          'name': server_['name'],
          'organization': access_key,
          'image': get_image(server_),
          'commercial_type': commercial_type,
      }
  
      __utils__['cloud.fire_event'](
          'event',
          'requesting instance',
          'salt/cloud/{0}/requesting'.format(server_['name']),
          args={
              'kwargs': __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 Scaleway\n\n'
              'The following exception was thrown when trying to '
              'run the initial deployment: %s',
              server_['name'], exc,
              # Show the traceback if the debug logging level is enabled
              exc_info_on_loglevel=logging.DEBUG
          )
          return False
  
      def __query_node_data(server_name):
          ''' Called to check if the server has a public IP address.
          '''
          data = show_instance(server_name, 'action')
          if data and data.get('public_ip'):
              return data
          return False
  
      try:
          data = salt.utils.cloud.wait_for_ip(
              __query_node_data,
              update_args=(server_['name'],),
              timeout=config.get_cloud_config_value(
                  'wait_for_ip_timeout', server_, __opts__, default=10 * 60),
              interval=config.get_cloud_config_value(
                  'wait_for_ip_interval', server_, __opts__, default=10),
          )
      except (SaltCloudExecutionTimeout, SaltCloudExecutionFailure) as exc:
          try:
              # It might be already up, let's destroy it!
              destroy(server_['name'])
          except SaltCloudSystemExit:
              pass
          finally:
              raise SaltCloudSystemExit(six.text_type(exc))
  
      server_['ssh_host'] = data['public_ip']['address']
      server_['ssh_password'] = ssh_password
      server_['key_filename'] = key_filename
      ret = __utils__['cloud.bootstrap'](server_, __opts__)
  
      ret.update(data)
  
      log.info('Created BareMetal server \'%s\'', server_['name'])
      log.debug(
          '\'%s\' BareMetal server creation details:\n%s',
          server_['name'], pprint.pformat(data)
      )
  
      __utils__['cloud.fire_event'](
          'event',
          'created instance',
          'salt/cloud/{0}/created'.format(server_['name']),
          args=__utils__['cloud.filter_event']('created', server_, ['name', 'profile', 'provider', 'driver']),
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      return ret