<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def start_instance(self, key_name, public_key_path, private_key_path, security_group, flavor, image_id, image_userdata, username='root', node_name=None, boot_disk_size=30, storage_account_type='Standard_LRS', **extra):
 """ Start a new VM using the given properties. :param str key_name: **unused in Azure**, only present for interface compatibility :param str public_key_path: path to ssh public key to authorize on the VM (for user `username`, see below) :param str private_key_path: **unused in Azure**, only present for interface compatibility :param str security_group: network security group to attach VM to, **currently unused** :param str flavor: machine type to use for the instance :param str image_id: disk image to use for the instance; has the form *publisher/offer/sku/version* (e.g., ``canonical/ubuntuserver/16.04.0-LTS/latest``) :param str image_userdata: command to execute after startup, **currently unused** :param int boot_disk_size: size of boot disk to use; values are specified in gigabytes. :param str username: username for the given ssh key (default is ``root`` as it's always guaranteed to exist, but you probably don't want to use that) :param str storage_account_type: Type of disks to attach to the VM. For a list of valid values, see: https://docs.microsoft.com/en-us/rest/api/compute/disks/createorupdate#diskstorageaccounttypes :return: tuple[str, str] -- resource group and node name of the started VM """

        self._init_az_api()

        # Warn of unsupported parameters, if set.  We do not warn
        # about `user_key` or `private_key_path` since they come from
        # a `[login/*]` section and those can be shared across
        # different cloud providers.
        if security_group and security_group != 'default':
            warn("Setting `security_group` is currently not supported"
                 " in the Azure cloud; VMs will all be attached to"
                 " a network security group named after the cluster name.")
        if image_userdata:
            warn("Parameter `image_userdata` is currently not supported"
                 " in the Azure cloud and will be ignored.")

        # Use the cluster name to identify the Azure resource group;
        # however, `Node.cluster_name` is not passed down here so
        # extract it from the node name, which always contains it as
        # the substring before the leftmost dash (see `cluster.py`,
        # line 1182)
        cluster_name, _ = node_name.split('-', 1)
        with self.__lock:
            if cluster_name not in self._resource_groups_created:
                self._resource_client.resource_groups.create_or_update(
                    cluster_name, {'location': self.location})
                self._resource_groups_created.add(cluster_name)

        # read public SSH key
        with open(public_key_path, 'r') as public_key_file:
            public_key = public_key_file.read()

        image_publisher, image_offer, \
            image_sku, image_version = self._split_image_id(image_id)

        if not security_group:
            security_group = (cluster_name + '-secgroup')

        net_parameters = {
            'networkSecurityGroupName': {
                'value': security_group,
            },
            'subnetName':     { 'value': cluster_name },
        }
        net_name = net_parameters['subnetName']['value']
        with self.__lock:
            if net_name not in self._networks_created:
                log.debug(
                    "Creating network `%s` in Azure ...", net_name)
                oper = self._resource_client.deployments.create_or_update(
                    cluster_name, net_name, {
                        'mode':       DeploymentMode.incremental,
                        'template':   self.net_deployment_template,
                        'parameters': net_parameters,
                    })
                oper.wait()
                self._networks_created.add(net_name)
        boot_disk_size_gb = int(boot_disk_size)

        vm_parameters = {
            'adminUserName':  { 'value': username },
            'imagePublisher': { 'value': image_publisher },  # e.g., 'canonical'
            'imageOffer':     { 'value': image_offer },      # e.g., ubuntuserver
            'imageSku':       { 'value': image_sku },        # e.g., '16.04.0-LTS'
            'imageVersion':   { 'value': image_version },    # e.g., 'latest'
            'networkSecurityGroupName': {
                'value': security_group,
            },
            'sshKeyData':     { 'value': public_key },
            'storageAccountName': {
                'value': self._make_storage_account_name(
                    cluster_name, node_name)
            },
            'storageAccountType': { 'value': storage_account_type },
            'subnetName':     { 'value': cluster_name },
            'vmName':         { 'value': node_name },
            'vmSize':         { 'value': flavor },
            'bootDiskSize':   { 'value': boot_disk_size_gb}
        }
        log.debug(
            "Deploying `%s` VM template to Azure ...",
            vm_parameters['vmName']['value'])
        oper = self._resource_client.deployments.create_or_update(
            cluster_name, node_name, {
                'mode':       DeploymentMode.incremental,
                'template':   self.vm_deployment_template,
                'parameters': vm_parameters,
            })
        oper.wait()

        # the `instance_id` is a composite type since we need both the
        # resource group name and the vm name to uniquely identify a VM
        return [cluster_name, node_name]