skypilot-nightly 1.0.0.dev20241023__tar.gz → 1.0.0.dev20241024__tar.gz

{skypilot_nightly-1.0.0.dev20241023/skypilot_nightly.egg-info → skypilot_nightly-1.0.0.dev20241024}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skypilot-nightly
-Version: 1.0.0.dev20241023
+Version: 1.0.0.dev20241024
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/sky/__init__.py

@@ -5,7 +5,7 @@ from typing import Optional
 import urllib.request
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = 'f2991b144d4b15eac55dd7f759f361b6146033b3'
+_SKYPILOT_COMMIT_SHA = 'cbf5c0022ad920edb4f41cfad65a2cf4909d5930'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20241023'
+__version__ = '1.0.0.dev20241024'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 
@@ -128,6 +128,7 @@ GCP = clouds.GCP
 Lambda = clouds.Lambda
 SCP = clouds.SCP
 Kubernetes = clouds.Kubernetes
+K8s = Kubernetes
 OCI = clouds.OCI
 Paperspace = clouds.Paperspace
 RunPod = clouds.RunPod
@@ -143,6 +144,7 @@ __all__ = [
     'GCP',
     'IBM',
     'Kubernetes',
+    'K8s',
     'Lambda',
     'OCI',
     'Paperspace',

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/sky/adaptors/azure.py

@@ -69,6 +69,17 @@ def exceptions():
     return azure_exceptions
 
 
+@functools.lru_cache()
+@common.load_lazy_modules(modules=_LAZY_MODULES)
+def azure_mgmt_models(name: str):
+    if name == 'compute':
+        from azure.mgmt.compute import models
+        return models
+    elif name == 'network':
+        from azure.mgmt.network import models
+        return models
+
+
 # We should keep the order of the decorators having 'lru_cache' followed
 # by 'load_lazy_modules' as we need to make sure a caller can call
 # 'get_client.cache_clear', which is a function provided by 'lru_cache'

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/sky/cli.py

@@ -339,7 +339,6 @@ def _get_shell_complete_args(complete_fn):
 
 
 _RELOAD_ZSH_CMD = 'source ~/.zshrc'
-_RELOAD_FISH_CMD = 'source ~/.config/fish/config.fish'
 _RELOAD_BASH_CMD = 'source ~/.bashrc'
 
 
@@ -378,7 +377,9 @@ def _install_shell_completion(ctx: click.Context, param: click.Parameter,
         cmd = '_SKY_COMPLETE=fish_source sky > \
                 ~/.config/fish/completions/sky.fish'
 
-        reload_cmd = _RELOAD_FISH_CMD
+        # Fish does not need to be reloaded and will automatically pick up
+        # completions.
+        reload_cmd = None
 
     elif value == 'zsh':
         install_cmd = f'_SKY_COMPLETE=zsh_source sky > \
@@ -398,9 +399,10 @@ def _install_shell_completion(ctx: click.Context, param: click.Parameter,
                        check=True,
                        executable=shutil.which('bash'))
         click.secho(f'Shell completion installed for {value}', fg='green')
-        click.echo(
-            'Completion will take effect once you restart the terminal: ' +
-            click.style(f'{reload_cmd}', bold=True))
+        if reload_cmd is not None:
+            click.echo(
+                'Completion will take effect once you restart the terminal: ' +
+                click.style(f'{reload_cmd}', bold=True))
     except subprocess.CalledProcessError as e:
         click.secho(f'> Installation failed with code {e.returncode}', fg='red')
     ctx.exit()
@@ -431,7 +433,9 @@ def _uninstall_shell_completion(ctx: click.Context, param: click.Parameter,
 
     elif value == 'fish':
         cmd = 'rm -f ~/.config/fish/completions/sky.fish'
-        reload_cmd = _RELOAD_FISH_CMD
+        # Fish does not need to be reloaded and will automatically pick up
+        # completions.
+        reload_cmd = None
 
     elif value == 'zsh':
         cmd = 'sed -i"" -e "/# For SkyPilot shell completion/d" ~/.zshrc && \
@@ -447,8 +451,10 @@ def _uninstall_shell_completion(ctx: click.Context, param: click.Parameter,
     try:
         subprocess.run(cmd, shell=True, check=True)
         click.secho(f'Shell completion uninstalled for {value}', fg='green')
-        click.echo('Changes will take effect once you restart the terminal: ' +
-                   click.style(f'{reload_cmd}', bold=True))
+        if reload_cmd is not None:
+            click.echo(
+                'Changes will take effect once you restart the terminal: ' +
+                click.style(f'{reload_cmd}', bold=True))
     except subprocess.CalledProcessError as e:
         click.secho(f'> Uninstallation failed with code {e.returncode}',
                     fg='red')
@@ -3056,7 +3062,8 @@ def show_gpus(
 
     # This will validate 'cloud' and raise if not found.
     cloud_obj = sky_clouds.CLOUD_REGISTRY.from_str(cloud)
-    service_catalog.validate_region_zone(region, None, clouds=cloud)
+    cloud_name = cloud_obj.canonical_name() if cloud_obj is not None else None
+    service_catalog.validate_region_zone(region, None, clouds=cloud_name)
     show_all = all
     if show_all and accelerator_str is not None:
         raise click.UsageError('--all is only allowed without a GPU name.')
@@ -3142,8 +3149,8 @@ def show_gpus(
         # Optimization - do not poll for Kubernetes API for fetching
         # common GPUs because that will be fetched later for the table after
         # common GPUs.
-        clouds_to_list = cloud
-        if cloud is None:
+        clouds_to_list = cloud_name
+        if cloud_name is None:
             clouds_to_list = [
                 c for c in service_catalog.ALL_CLOUDS if c != 'kubernetes'
             ]
@@ -3153,7 +3160,8 @@ def show_gpus(
             # Collect k8s related messages in k8s_messages and print them at end
             print_section_titles = False
             # If cloud is kubernetes, we want to show real-time capacity
-            if kubernetes_is_enabled and (cloud is None or cloud_is_kubernetes):
+            if kubernetes_is_enabled and (cloud_name is None or
+                                          cloud_is_kubernetes):
                 if region:
                     context = region
                 else:
@@ -3263,8 +3271,8 @@ def show_gpus(
                 name, quantity = accelerator_str, None
 
         print_section_titles = False
-        if (kubernetes_is_enabled and (cloud is None or cloud_is_kubernetes) and
-                not show_all):
+        if (kubernetes_is_enabled and
+            (cloud_name is None or cloud_is_kubernetes) and not show_all):
             # Print section title if not showing all and instead a specific
             # accelerator is requested
             print_section_titles = True
@@ -3336,7 +3344,7 @@ def show_gpus(
         if len(result) == 0:
             quantity_str = (f' with requested quantity {quantity}'
                             if quantity else '')
-            cloud_str = f' on {cloud_obj}.' if cloud else ' in cloud catalogs.'
+            cloud_str = f' on {cloud_obj}.' if cloud_name else ' in cloud catalogs.'
             yield f'Resources \'{name}\'{quantity_str} not found{cloud_str} '
             yield 'To show available accelerators, run: sky show-gpus --all'
             return

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/sky/clouds/cloud.py

@@ -819,6 +819,10 @@ class Cloud:
 
     # === End of image related methods ===
 
+    @classmethod
+    def canonical_name(cls) -> str:
+        return cls.__name__.lower()
+
     def __repr__(self):
         return self._REPR
 

skypilot_nightly-1.0.0.dev20241024/sky/clouds/cloud_registry.py

@@ -0,0 +1,76 @@
+"""Clouds need to be registered in CLOUD_REGISTRY to be discovered"""
+
+import typing
+from typing import Callable, Dict, List, Optional, overload, Type, Union
+
+from sky.utils import ux_utils
+
+if typing.TYPE_CHECKING:
+    from sky.clouds import cloud
+
+
+class _CloudRegistry(dict):
+    """Registry of clouds."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.aliases: Dict[str, str] = {}
+
+    def from_str(self, name: Optional[str]) -> Optional['cloud.Cloud']:
+        """Returns the cloud instance from the canonical name or alias."""
+        if name is None:
+            return None
+
+        search_name = name.lower()
+
+        if search_name in self:
+            return self[search_name]
+
+        if search_name in self.aliases:
+            return self[self.aliases[search_name]]
+
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(f'Cloud {name!r} is not a valid cloud among '
+                             f'{[*self.keys(), *self.aliases.keys()]}')
+
+    @overload
+    def register(self, cloud_cls: Type['cloud.Cloud']) -> Type['cloud.Cloud']:
+        ...
+
+    @overload
+    def register(
+        self,
+        cloud_cls: None = None,
+        aliases: Optional[List[str]] = None,
+    ) -> Callable[[Type['cloud.Cloud']], Type['cloud.Cloud']]:
+        ...
+
+    def register(
+        self,
+        cloud_cls: Optional[Type['cloud.Cloud']] = None,
+        aliases: Optional[List[str]] = None,
+    ) -> Union[Type['cloud.Cloud'], Callable[[Type['cloud.Cloud']],
+                                             Type['cloud.Cloud']]]:
+
+        def _register(cloud_cls: Type['cloud.Cloud']) -> Type['cloud.Cloud']:
+            name = cloud_cls.canonical_name()
+            assert name not in self, f'{name} already registered'
+            self[name] = cloud_cls()
+
+            for alias in aliases or []:
+                alias = alias.lower()
+                assert alias not in self.aliases, (
+                    f'alias {alias} already registered')
+                self.aliases[alias] = name
+
+            return cloud_cls
+
+        if cloud_cls is not None:
+            # invocation without parens (e.g. just `@register`)
+            return _register(cloud_cls)
+
+        # Invocation with parens (e.g. `@register(aliases=['alias'])`)
+        return _register
+
+
+CLOUD_REGISTRY: _CloudRegistry = _CloudRegistry()

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/sky/clouds/kubernetes.py

@@ -33,7 +33,7 @@ CREDENTIAL_PATH = os.environ.get('KUBECONFIG', DEFAULT_KUBECONFIG_PATH)
 _SKYPILOT_SYSTEM_NAMESPACE = 'skypilot-system'
 
 
-@clouds.CLOUD_REGISTRY.register
+@clouds.CLOUD_REGISTRY.register(aliases=['k8s'])
 class Kubernetes(clouds.Cloud):
     """Kubernetes."""
 

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/sky/provision/azure/config.py

@@ -46,6 +46,7 @@ def bootstrap_instances(
         region: str, cluster_name_on_cloud: str,
         config: common.ProvisionConfig) -> common.ProvisionConfig:
     """See sky/provision/__init__.py"""
+    # TODO: use new azure sdk instead of ARM deployment.
     del region  # unused
     provider_config = config.provider_config
     subscription_id = provider_config.get('subscription_id')

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/sky/provision/azure/instance.py

@@ -2,10 +2,8 @@
 import base64
 import copy
 import enum
-import json
 import logging
 from multiprocessing import pool
-import pathlib
 import time
 import typing
 from typing import Any, Callable, Dict, List, Optional, Tuple
@@ -23,7 +21,9 @@ from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
     from azure.mgmt import compute as azure_compute
-    from azure.mgmt import resource as azure_resource
+    from azure.mgmt import network as azure_network
+    from azure.mgmt.compute import models as azure_compute_models
+    from azure.mgmt.network import models as azure_network_models
 
 logger = sky_logging.init_logger(__name__)
 
@@ -184,14 +184,150 @@ def _get_head_instance_id(instances: List) -> Optional[str]:
     return head_instance_id
 
 
-def _create_instances(
-        compute_client: 'azure_compute.ComputeManagementClient',
-        resource_client: 'azure_resource.ResourceManagementClient',
-        cluster_name_on_cloud: str, resource_group: str,
-        provider_config: Dict[str, Any], node_config: Dict[str, Any],
-        tags: Dict[str, str], count: int) -> List:
+def _create_network_interface(
+        network_client: 'azure_network.NetworkManagementClient', vm_name: str,
+        provider_config: Dict[str,
+                              Any]) -> 'azure_network_models.NetworkInterface':
+    network = azure.azure_mgmt_models('network')
+    compute = azure.azure_mgmt_models('compute')
+    logger.info(f'Start creating network interface for {vm_name}...')
+    if provider_config.get('use_internal_ips', False):
+        name = f'{vm_name}-nic-private'
+        ip_config = network.IPConfiguration(
+            name=f'ip-config-private-{vm_name}',
+            subnet=compute.SubResource(id=provider_config['subnet']),
+            private_ip_allocation_method=network.IPAllocationMethod.DYNAMIC)
+    else:
+        name = f'{vm_name}-nic-public'
+        public_ip_address = network.PublicIPAddress(
+            location=provider_config['location'],
+            public_ip_allocation_method='Static',
+            public_ip_address_version='IPv4',
+            sku=network.PublicIPAddressSku(name='Basic', tier='Regional'))
+        ip_poller = network_client.public_ip_addresses.begin_create_or_update(
+            resource_group_name=provider_config['resource_group'],
+            public_ip_address_name=f'{vm_name}-ip',
+            parameters=public_ip_address)
+        logger.info(f'Created public IP address {ip_poller.result().name} '
+                    f'with address {ip_poller.result().ip_address}.')
+        ip_config = network.IPConfiguration(
+            name=f'ip-config-public-{vm_name}',
+            subnet=compute.SubResource(id=provider_config['subnet']),
+            private_ip_allocation_method=network.IPAllocationMethod.DYNAMIC,
+            public_ip_address=network.PublicIPAddress(id=ip_poller.result().id))
+
+    ni_poller = network_client.network_interfaces.begin_create_or_update(
+        resource_group_name=provider_config['resource_group'],
+        network_interface_name=name,
+        parameters=network.NetworkInterface(
+            location=provider_config['location'],
+            ip_configurations=[ip_config],
+            network_security_group=network.NetworkSecurityGroup(
+                id=provider_config['nsg'])))
+    logger.info(f'Created network interface {ni_poller.result().name}.')
+    return ni_poller.result()
+
+
+def _create_vm(
+        compute_client: 'azure_compute.ComputeManagementClient', vm_name: str,
+        node_tags: Dict[str, str], provider_config: Dict[str, Any],
+        node_config: Dict[str, Any],
+        network_interface_id: str) -> 'azure_compute_models.VirtualMachine':
+    compute = azure.azure_mgmt_models('compute')
+    logger.info(f'Start creating VM {vm_name}...')
+    hardware_profile = compute.HardwareProfile(
+        vm_size=node_config['azure_arm_parameters']['vmSize'])
+    network_profile = compute.NetworkProfile(network_interfaces=[
+        compute.NetworkInterfaceReference(id=network_interface_id, primary=True)
+    ])
+    public_key = node_config['azure_arm_parameters']['publicKey']
+    username = node_config['azure_arm_parameters']['adminUsername']
+    os_linux_custom_data = base64.b64encode(
+        node_config['azure_arm_parameters']['cloudInitSetupCommands'].encode(
+            'utf-8')).decode('utf-8')
+    os_profile = compute.OSProfile(
+        admin_username=username,
+        computer_name=vm_name,
+        admin_password=public_key,
+        linux_configuration=compute.LinuxConfiguration(
+            disable_password_authentication=True,
+            ssh=compute.SshConfiguration(public_keys=[
+                compute.SshPublicKey(
+                    path=f'/home/{username}/.ssh/authorized_keys',
+                    key_data=public_key)
+            ])),
+        custom_data=os_linux_custom_data)
+    community_image_id = node_config['azure_arm_parameters'].get(
+        'communityGalleryImageId', None)
+    if community_image_id is not None:
+        # Prioritize using community gallery image if specified.
+        image_reference = compute.ImageReference(
+            community_gallery_image_id=community_image_id)
+        logger.info(
+            f'Used community_image_id: {community_image_id} for VM {vm_name}.')
+    else:
+        image_reference = compute.ImageReference(
+            publisher=node_config['azure_arm_parameters']['imagePublisher'],
+            offer=node_config['azure_arm_parameters']['imageOffer'],
+            sku=node_config['azure_arm_parameters']['imageSku'],
+            version=node_config['azure_arm_parameters']['imageVersion'])
+    storage_profile = compute.StorageProfile(
+        image_reference=image_reference,
+        os_disk=compute.OSDisk(
+            create_option=compute.DiskCreateOptionTypes.FROM_IMAGE,
+            managed_disk=compute.ManagedDiskParameters(
+                storage_account_type=node_config['azure_arm_parameters']
+                ['osDiskTier']),
+            disk_size_gb=node_config['azure_arm_parameters']['osDiskSizeGB']))
+    vm_instance = compute.VirtualMachine(
+        location=provider_config['location'],
+        tags=node_tags,
+        hardware_profile=hardware_profile,
+        os_profile=os_profile,
+        storage_profile=storage_profile,
+        network_profile=network_profile,
+        identity=compute.VirtualMachineIdentity(
+            type='UserAssigned',
+            user_assigned_identities={provider_config['msi']: {}}))
+    vm_poller = compute_client.virtual_machines.begin_create_or_update(
+        resource_group_name=provider_config['resource_group'],
+        vm_name=vm_name,
+        parameters=vm_instance,
+    )
+    # poller.result() will block on async operation until it's done.
+    logger.info(f'Created VM {vm_poller.result().name}.')
+    # Configure driver extension for A10 GPUs. A10 GPUs requires a
+    # special type of drivers which is available at Microsoft HPC
+    # extension. Reference:
+    # https://forums.developer.nvidia.com/t/ubuntu-22-04-installation-driver-error-nvidia-a10/285195/2
+    # This can take more than 20mins for setting up the A10 GPUs
+    if node_config.get('need_nvidia_driver_extension', False):
+        ext_poller = compute_client.virtual_machine_extensions.\
+            begin_create_or_update(
+            resource_group_name=provider_config['resource_group'],
+            vm_name=vm_name,
+            vm_extension_name='NvidiaGpuDriverLinux',
+            extension_parameters=compute.VirtualMachineExtension(
+                location=provider_config['location'],
+                publisher='Microsoft.HpcCompute',
+                type_properties_type='NvidiaGpuDriverLinux',
+                type_handler_version='1.9',
+                auto_upgrade_minor_version=True,
+                settings='{}'))
+        logger.info(
+            f'Created VM extension {ext_poller.result().name} for VM {vm_name}.'
+        )
+    return vm_poller.result()
+
+
+def _create_instances(compute_client: 'azure_compute.ComputeManagementClient',
+                      network_client: 'azure_network.NetworkManagementClient',
+                      cluster_name_on_cloud: str, resource_group: str,
+                      provider_config: Dict[str, Any], node_config: Dict[str,
+                                                                         Any],
+                      tags: Dict[str, str], count: int) -> List:
     vm_id = uuid4().hex[:UNIQUE_ID_LEN]
-    tags = {
+    all_tags = {
         constants.TAG_RAY_CLUSTER_NAME: cluster_name_on_cloud,
         constants.TAG_SKYPILOT_CLUSTER_NAME: cluster_name_on_cloud,
         **constants.WORKER_NODE_TAGS,
@@ -199,83 +335,19 @@ def _create_instances(
         **tags,
     }
     node_tags = node_config['tags'].copy()
-    node_tags.update(tags)
-
-    # load the template file
-    current_path = pathlib.Path(__file__).parent
-    template_path = current_path.joinpath('azure-vm-template.json')
-    with open(template_path, 'r', encoding='utf-8') as template_fp:
-        template = json.load(template_fp)
-
-    vm_name = f'{cluster_name_on_cloud}-{vm_id}'
-    use_internal_ips = provider_config.get('use_internal_ips', False)
+    node_tags.update(all_tags)
 
-    template_params = node_config['azure_arm_parameters'].copy()
-    # We don't include 'head' or 'worker' in the VM name as on Azure the VM
-    # name is immutable and we may change the node type for existing VM in the
-    # multi-node cluster, due to manual termination of the head node.
-    template_params['vmName'] = vm_name
-    template_params['provisionPublicIp'] = not use_internal_ips
-    template_params['vmTags'] = node_tags
-    template_params['vmCount'] = count
-    template_params['msi'] = provider_config['msi']
-    template_params['nsg'] = provider_config['nsg']
-    template_params['subnet'] = provider_config['subnet']
-    # In Azure, cloud-init script must be encoded in base64. For more
-    # information, see:
-    # https://learn.microsoft.com/en-us/azure/virtual-machines/custom-data
-    template_params['cloudInitSetupCommands'] = (base64.b64encode(
-        template_params['cloudInitSetupCommands'].encode('utf-8')).decode(
-            'utf-8'))
+    # Create VM instances in parallel.
+    def create_single_instance(vm_i):
+        vm_name = f'{cluster_name_on_cloud}-{vm_id}-{vm_i}'
+        network_interface = _create_network_interface(network_client, vm_name,
+                                                      provider_config)
+        _create_vm(compute_client, vm_name, node_tags, provider_config,
+                   node_config, network_interface.id)
 
-    if node_config.get('need_nvidia_driver_extension', False):
-        # pylint: disable=line-too-long
-        # Configure driver extension for A10 GPUs. A10 GPUs requires a
-        # special type of drivers which is available at Microsoft HPC
-        # extension. Reference: https://forums.developer.nvidia.com/t/ubuntu-22-04-installation-driver-error-nvidia-a10/285195/2
-        for r in template['resources']:
-            if r['type'] == 'Microsoft.Compute/virtualMachines':
-                # Add a nested extension resource for A10 GPUs
-                r['resources'] = [
-                    {
-                        'type': 'extensions',
-                        'apiVersion': '2015-06-15',
-                        'location': '[variables(\'location\')]',
-                        'dependsOn': [
-                            '[concat(\'Microsoft.Compute/virtualMachines/\', parameters(\'vmName\'), copyIndex())]'
-                        ],
-                        'name': 'NvidiaGpuDriverLinux',
-                        'properties': {
-                            'publisher': 'Microsoft.HpcCompute',
-                            'type': 'NvidiaGpuDriverLinux',
-                            'typeHandlerVersion': '1.9',
-                            'autoUpgradeMinorVersion': True,
-                            'settings': {},
-                        },
-                    },
-                ]
-                break
-
-    parameters = {
-        'properties': {
-            'mode': azure.deployment_mode().incremental,
-            'template': template,
-            'parameters': {
-                key: {
-                    'value': value
-                } for key, value in template_params.items()
-            },
-        }
-    }
-
-    create_or_update = _get_azure_sdk_function(
-        client=resource_client.deployments, function_name='create_or_update')
-    create_or_update(
-        resource_group_name=resource_group,
-        deployment_name=vm_name,
-        parameters=parameters,
-    ).wait()
+    subprocess_utils.run_in_parallel(create_single_instance, range(count))
 
+    # Update disk performance tier
     performance_tier = node_config.get('disk_performance_tier', None)
     if performance_tier is not None:
         disks = compute_client.disks.list_by_resource_group(resource_group)
@@ -286,12 +358,14 @@ def _create_instances(
                 f'az disk update -n {name} -g {resource_group} '
                 f'--set tier={performance_tier}')
 
+    # Validation
     filters = {
         constants.TAG_RAY_CLUSTER_NAME: cluster_name_on_cloud,
         _TAG_SKYPILOT_VM_ID: vm_id
     }
     instances = _filter_instances(compute_client, resource_group, filters)
     assert len(instances) == count, (len(instances), count)
+
     return instances
 
 
@@ -303,7 +377,7 @@ def run_instances(region: str, cluster_name_on_cloud: str,
     resource_group = provider_config['resource_group']
     subscription_id = provider_config['subscription_id']
     compute_client = azure.get_client('compute', subscription_id)
-
+    network_client = azure.get_client('network', subscription_id)
     instances_to_resume = []
     resumed_instance_ids: List[str] = []
     created_instance_ids: List[str] = []
@@ -439,12 +513,11 @@ def run_instances(region: str, cluster_name_on_cloud: str,
     to_start_count -= len(resumed_instance_ids)
 
     if to_start_count > 0:
-        resource_client = azure.get_client('resource', subscription_id)
         logger.debug(f'run_instances: Creating {to_start_count} instances.')
         try:
             created_instances = _create_instances(
                 compute_client=compute_client,
-                resource_client=resource_client,
+                network_client=network_client,
                 cluster_name_on_cloud=cluster_name_on_cloud,
                 resource_group=resource_group,
                 provider_config=provider_config,

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/sky/templates/azure-ray.yml.j2

@@ -67,6 +67,8 @@ available_node_types:
             imageOffer: {{image_offer}}
             imageSku: "{{image_sku}}"
             imageVersion: {{image_version}}
+            # Community Gallery Image ID 
+            communityGalleryImageId: {{community_gallery_image_id}}
             osDiskSizeGB: {{disk_size}}
             osDiskTier: {{disk_tier}}
             {%- if use_spot %}

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024/skypilot_nightly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skypilot-nightly
-Version: 1.0.0.dev20241023
+Version: 1.0.0.dev20241024
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0

{skypilot_nightly-1.0.0.dev20241023 → skypilot_nightly-1.0.0.dev20241024}/skypilot_nightly.egg-info/SOURCES.txt

@@ -120,7 +120,6 @@ sky/provision/aws/instance.py
 sky/provision/aws/utils.py
 sky/provision/azure/__init__.py
 sky/provision/azure/azure-config-template.json
-sky/provision/azure/azure-vm-template.json
 sky/provision/azure/config.py
 sky/provision/azure/instance.py
 sky/provision/cudo/__init__.py

skypilot_nightly-1.0.0.dev20241024/tests/test_api.py

@@ -0,0 +1,20 @@
+import sky
+from sky.clouds.cloud import Cloud
+
+
+def test_sky_launch(enable_all_clouds):
+    task = sky.Task()
+    job_id, handle = sky.launch(task, dryrun=True)
+    assert job_id is None and handle is None
+
+
+def test_k8s_alias(enable_all_clouds):
+
+    def dryrun_task_with_cloud(cloud: Cloud):
+        task = sky.Task()
+        task.set_resources_override({'cloud': cloud})
+        sky.launch(task, dryrun=True)
+
+    dryrun_task_with_cloud(sky.K8s())
+
+    dryrun_task_with_cloud(sky.Kubernetes())