skypilot-nightly 1.0.0.dev20250509__py3-none-any.whl → 1.0.0.dev20251107__py3-none-any.whl

sky/clouds/utils/gcp_utils.py

@@ -10,7 +10,7 @@ import dataclasses
 import json
 import time
 import typing
-from typing import List, Optional, Set
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 import cachetools
 
@@ -18,6 +18,7 @@ from sky import sky_logging
 from sky import skypilot_config
 from sky.provision.gcp import constants
 from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.utils import resources_utils
 from sky.utils import subprocess_utils
 
 if typing.TYPE_CHECKING:
@@ -36,9 +37,10 @@ def is_tpu(resources: Optional['resources_lib.Resources']) -> bool:
 def is_tpu_vm(resources: Optional['resources_lib.Resources']) -> bool:
     if not is_tpu(resources):
         return False
-    assert (resources is not None and len(resources.accelerators) == 1)
+    assert (resources is not None and resources.accelerators is not None and
+            len(resources.accelerators) == 1)
     acc, _ = list(resources.accelerators.items())[0]
-    if kubernetes_utils.is_tpu_on_gke(acc):
+    if kubernetes_utils.is_tpu_on_gke(acc, normalize=False):
         return False
     if resources.accelerator_args is None:
         return True
@@ -48,7 +50,7 @@ def is_tpu_vm(resources: Optional['resources_lib.Resources']) -> bool:
 def is_tpu_vm_pod(resources: Optional['resources_lib.Resources']) -> bool:
     if not is_tpu_vm(resources):
         return False
-    assert resources is not None
+    assert resources is not None and resources.accelerators is not None
     acc, _ = list(resources.accelerators.items())[0]
     return not acc.endswith('-8')
 
@@ -136,10 +138,16 @@ def _list_reservations_for_instance_type(
     For example, if we have a specific reservation with n1-highmem-8
     in us-central1-c. `sky launch --gpus V100` will fail.
     """
-    prioritize_reservations = skypilot_config.get_nested(
-        ('gcp', 'prioritize_reservations'), False)
-    specific_reservations = skypilot_config.get_nested(
-        ('gcp', 'specific_reservations'), [])
+    prioritize_reservations = skypilot_config.get_effective_region_config(
+        cloud='gcp',
+        region=None,
+        keys=('prioritize_reservations',),
+        default_value=False)
+    specific_reservations = skypilot_config.get_effective_region_config(
+        cloud='gcp',
+        region=None,
+        keys=('specific_reservations',),
+        default_value=[])
     if not prioritize_reservations and not specific_reservations:
         return []
     logger.debug(f'Querying GCP reservations for instance {instance_type!r}')
@@ -169,14 +177,23 @@ def _list_reservations_for_instance_type(
 
 def get_minimal_compute_permissions() -> List[str]:
     permissions = copy.copy(constants.VM_MINIMAL_PERMISSIONS)
-    if skypilot_config.get_nested(('gcp', 'vpc_name'), None) is None:
+    if skypilot_config.get_effective_region_config(
+            cloud='gcp', region=None, keys=('vpc_name',),
+            default_value=None) is None:
         # If custom VPC is not specified, permissions to modify network are
         # required to ensure SkyPilot to be able to setup the network, and
         # allow opening ports (e.g., via `resources.ports`).
         permissions += constants.FIREWALL_PERMISSIONS
 
-    if (skypilot_config.get_nested(('gcp', 'prioritize_reservations'), False) or
-            skypilot_config.get_nested(('gcp', 'specific_reservations'), [])):
+    if (skypilot_config.get_effective_region_config(
+            cloud='gcp',
+            region=None,
+            keys=('prioritize_reservations',),
+            default_value=False) or skypilot_config.get_effective_region_config(
+                cloud='gcp',
+                region=None,
+                keys=('specific_reservations',),
+                default_value=[])):
         permissions += constants.RESERVATION_PERMISSIONS
 
     permissions += constants.GCP_MINIMAL_PERMISSIONS
@@ -190,3 +207,62 @@ def get_minimal_storage_permissions() -> List[str]:
     permissions += constants.GCP_MINIMAL_PERMISSIONS
 
     return permissions
+
+
+# Get the DWS configuration for the given context in GKE.
+def get_dws_config(
+    context: str,
+    k8s_kueue_local_queue_name: Optional[str],
+    cluster_config_overrides: Optional[Dict[str, Any]] = None,
+) -> Tuple[bool, bool, Optional[int]]:
+    """Get the DWS configuration for the given context.
+
+        Args:
+            context: The context to get the DWS configuration for.
+            k8s_kueue_local_queue_name: The name of the Kueue local queue.
+            cluster_config_overrides: The cluster config overrides.
+
+        Returns:
+            A tuple of (enable_flex_start,
+                        enable_flex_start_queued_provisioning,
+                        max_run_duration_seconds).
+
+        Raises:
+            ValueError: If k8s_kueue_local_queue_name is missing to enable
+                        flex start queued provisioning for the given context.
+        """
+    dws_config = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('dws',),
+        default_value={},
+        override_configs=cluster_config_overrides)
+    if not dws_config:
+        return False, False, None
+
+    enabled = dws_config.get('enabled', False)
+    if not enabled:
+        return False, False, None
+
+    enable_flex_start = False
+    enable_flex_start_queued_provisioning = False
+    max_run_duration_seconds = None
+    # If users already use Kueue, use the flex start with queued
+    # provisioning mode.
+    if k8s_kueue_local_queue_name:
+        enable_flex_start_queued_provisioning = True
+    else:
+        enable_flex_start = True
+
+    if not enable_flex_start_queued_provisioning:
+        return (enable_flex_start, enable_flex_start_queued_provisioning,
+                max_run_duration_seconds)
+
+    # Max run duration is only used in the flex start with queued
+    # provisioning mode.
+    max_run_duration = dws_config.get('max_run_duration', None)
+    if max_run_duration:
+        max_run_duration_seconds = resources_utils.parse_time_minutes(
+            max_run_duration) * 60
+    return (enable_flex_start, enable_flex_start_queued_provisioning,
+            max_run_duration_seconds)

sky/clouds/utils/oci_utils.py

@@ -105,22 +105,34 @@ class OCIConfig:
     @classmethod
     def get_compartment(cls, region):
         # Allow task(cluster)-specific compartment/VCN parameters.
-        default_compartment_ocid = skypilot_config.get_nested(
-            ('oci', 'default', 'compartment_ocid'), None)
-        compartment = skypilot_config.get_nested(
-            ('oci', region, 'compartment_ocid'), default_compartment_ocid)
+        default_compartment_ocid = skypilot_config.get_effective_region_config(
+            cloud='oci',
+            region='default',
+            keys=('compartment_ocid',),
+            default_value=None)
+        compartment = skypilot_config.get_effective_region_config(
+            cloud='oci',
+            region=region,
+            keys=('compartment_ocid',),
+            default_value=default_compartment_ocid)
         return compartment
 
     @classmethod
     def get_vcn_ocid(cls, region):
         # Will reuse the regional VCN if specified.
-        vcn = skypilot_config.get_nested(('oci', region, 'vcn_ocid'), None)
+        vcn = skypilot_config.get_effective_region_config(cloud='oci',
+                                                          region=region,
+                                                          keys=('vcn_ocid',),
+                                                          default_value=None)
         return vcn
 
     @classmethod
     def get_vcn_subnet(cls, region):
         # Will reuse the subnet if specified.
-        vcn = skypilot_config.get_nested(('oci', region, 'vcn_subnet'), None)
+        vcn = skypilot_config.get_effective_region_config(cloud='oci',
+                                                          region=region,
+                                                          keys=('vcn_subnet',),
+                                                          default_value=None)
         return vcn
 
     @classmethod
@@ -129,16 +141,22 @@ class OCIConfig:
         # we give a choice to set the default image tag (for gpu instances) in
         # the sky's user-config file (if not specified, use the hardcode one at
         # last)
-        return skypilot_config.get_nested(('oci', 'default', 'image_tag_gpu'),
-                                          'skypilot:gpu-ubuntu-2204')
+        return skypilot_config.get_effective_region_config(
+            cloud='oci',
+            region='default',
+            keys=('image_tag_gpu',),
+            default_value='skypilot:gpu-ubuntu-2204')
 
     @classmethod
     def get_default_image_tag(cls) -> str:
         # Get the default image tag. Instead of hardcoding, we give a choice to
         # set the default image tag in the sky's user-config file. (if not
         # specified, use the hardcode one at last)
-        return skypilot_config.get_nested(
-            ('oci', 'default', 'image_tag_general'), 'skypilot:cpu-ubuntu-2204')
+        return skypilot_config.get_effective_region_config(
+            cloud='oci',
+            region='default',
+            keys=('image_tag_general',),
+            default_value='skypilot:cpu-ubuntu-2204')
 
     @classmethod
     def get_sky_user_config_file(cls) -> str:
@@ -152,16 +170,22 @@ class OCIConfig:
 
     @classmethod
     def get_profile(cls) -> str:
-        return skypilot_config.get_nested(
-            ('oci', 'default', 'oci_config_profile'), 'DEFAULT')
+        return skypilot_config.get_effective_region_config(
+            cloud='oci',
+            region='default',
+            keys=('oci_config_profile',),
+            default_value='DEFAULT')
 
     @classmethod
     def get_default_image_os(cls) -> str:
         # Get the default image OS. Instead of hardcoding, we give a choice to
         # set the default image OS type in the sky's user-config file. (if not
         # specified, use the hardcode one at last)
-        return skypilot_config.get_nested(('oci', 'default', 'image_os_type'),
-                                          'ubuntu')
+        return skypilot_config.get_effective_region_config(
+            cloud='oci',
+            region='default',
+            keys=('image_os_type',),
+            default_value='ubuntu')
 
 
 oci_config = OCIConfig()

sky/clouds/utils/scp_utils.py

@@ -184,7 +184,7 @@ class SCPClient:
 
     def create_instance(self, instance_config):
         """Launch new instances."""
-        url = f'{API_ENDPOINT}/virtual-server/v3/virtual-servers'
+        url = f'{API_ENDPOINT}/virtual-server/v4/virtual-servers'
         return self._post(url, instance_config)
 
     @_retry
@@ -226,105 +226,113 @@ class SCPClient:
         raise_scp_error(response)
         return response.json()
 
-    def create_security_group(self, zone_id, vpc, sg_name):
+    def create_security_group(self, zone_id, vpc_id, sg_name):
         url = f'{API_ENDPOINT}/security-group/v3/security-groups'
         request_body = {
             'loggable': False,
             'securityGroupName': sg_name,
             'serviceZoneId': zone_id,
-            'vpcId': vpc,
-            'securityGroupDescription': 'skypilot sg'
+            'vpcId': vpc_id,
+            'securityGroupDescription': 'sky security group'
         }
         return self._post(url, request_body)
 
-    def add_security_group_in_rule(self, sg_id):
-        url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}/rules'
-        request_body = {
-            'ruleDirection': 'IN',
-            'services': [{
-                'serviceType': 'TCP',
-                'serviceValue': '22'
-            }],
-            'sourceIpAddresses': ['0.0.0.0/0'],
-            'ruleDescription': 'skypilot ssh rule'
-        }
-        return self._post(url, request_body)
-
-    def add_security_group_out_rule(self, sg_id):
-        url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}/rules'
-        request_body = {
-            'ruleDirection': 'OUT',
-            'services': [{
-                'serviceType': 'TCP',
-                'serviceValue': '21'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '22'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '80'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '443'
-            }],
-            'destinationIpAddresses': ['0.0.0.0/0'],
-            'ruleDescription': 'skypilot out rule'
-        }
-        return self._post(url, request_body)
-
-    def add_firewall_inbound_rule(self, firewall_id, internal_ip):
-        url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
-        request_body = {
-            'sourceIpAddresses': ['0.0.0.0/0'],
-            'destinationIpAddresses': [internal_ip],
-            'services': [{
-                'serviceType': 'TCP',
-                'serviceValue': '22'
-            }],
-            'ruleDirection': 'IN',
-            'ruleAction': 'ALLOW',
-            'isRuleEnabled': True,
-            'ruleLocationType': 'FIRST',
-            'ruleDescription': 'description'
-        }
-        return self._post(url, request_body)
-
-    def add_firewall_outbound_rule(self, firewall_id, internal_ip):
-        url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
-        request_body = {
-            'sourceIpAddresses': [internal_ip],
-            'destinationIpAddresses': ['0.0.0.0/0'],
-            'services': [{
-                'serviceType': 'TCP',
-                'serviceValue': '21'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '22'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '80'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '443'
-            }],
-            'ruleDirection': 'OUT',
-            'ruleAction': 'ALLOW',
-            'isRuleEnabled': True,
-            'ruleLocationType': 'FIRST',
-            'ruleDescription': 'description'
-        }
-        return self._post(url, request_body)
+    def _security_group_rule_not_exist(self, sg_id, direction, ports):
+        response = self.get_security_group_rules(sg_id)
+        rules = []
+        for rule in response:
+            rule_direction = rule['ruleDirection']
+            if rule_direction == direction:
+                rules.append(rule)
+        for rule in rules:
+            port_list = ','.join(rule['tcpServices'])
+            port = ','.join(ports)
+            if port == port_list:
+                return False
+        return True
+
+    def add_security_group_rule(self, sg_id, direction,
+                                ports: Optional[List[str]]):
+        if ports is None:
+            if direction == 'IN':
+                ports = ['22']
+            else:
+                ports = ['21', '22', '80', '443']
+        services = []
+        for port in ports:
+            services.append({'serviceType': 'TCP', 'serviceValue': port})
+        if self._security_group_rule_not_exist(sg_id, direction, ports):
+            url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}/rules'  # pylint: disable=line-too-long
+            if direction == 'IN':
+                target_address = 'sourceIpAddresses'
+            else:
+                target_address = 'destinationIpAddresses'
+            request_body = {
+                'ruleDirection': direction,
+                'services': services,
+                target_address: ['0.0.0.0/0'],
+                'ruleDescription': 'sky security group rule'
+            }
+            return self._post(url, request_body)
+
+    def _firewall_rule_not_exist(self, firewall_id, internal_ip, direction,
+                                 ports):
+        response = self.get_firewall_rules(firewall_id)
+        rules = []
+        for rule in response:
+            if direction == 'IN':
+                if internal_ip == rule['destinationIpAddresses'][0]:
+                    rules.append(rule)
+            else:
+                if internal_ip == rule['sourceIpAddresses'][0]:
+                    rules.append(rule)
+        for rule in rules:
+            port_list = ','.join(rule['tcpServices'])
+            port = ','.join(ports)
+            if port == port_list:
+                return False
+        return True
+
+    def add_firewall_rule(self, firewall_id, internal_ip, direction, ports):
+        if ports is None:
+            if direction == 'IN':
+                ports = ['22']
+            else:
+                ports = ['21', '22', '80', '443']
+        services = []
+        for port in ports:
+            services.append({'serviceType': 'TCP', 'serviceValue': port})
+        if self._firewall_rule_not_exist(firewall_id, internal_ip, direction,
+                                         ports):
+            url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
+            if direction == 'IN':
+                source_ip = '0.0.0.0/0'
+                destination_ip = internal_ip
+            else:
+                source_ip = internal_ip
+                destination_ip = '0.0.0.0/0'
+            request_body = {
+                'sourceIpAddresses': [source_ip],
+                'destinationIpAddresses': [destination_ip],
+                'services': services,
+                'ruleDirection': direction,
+                'ruleAction': 'ALLOW',
+                'isRuleEnabled': True,
+                'ruleLocationType': 'FIRST',
+                'ruleDescription': 'sky firewall rule'
+            }
+            return self._post(url, request_body)
 
-    def terminate_instance(self, vm_id):
-        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{vm_id}'
+    def terminate_instance(self, instance_id):
+        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}'
         return self._delete(url)
 
-    def list_instances(self) -> List[dict]:
+    def get_instances(self) -> List[dict]:
         """List existing instances."""
         url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers'
         return self._get(url)
 
-    def list_catalog(self) -> Dict[str, Any]:
+    def get_catalog(self) -> Dict[str, Any]:
         """List offered instances and their availability."""
         response = requests.get(f'{API_ENDPOINT}/instance-types',
                                 headers=self.headers)
@@ -362,89 +370,134 @@ class SCPClient:
         self.headers['X-Cmp-Timestamp'] = self.timestamp
 
     def set_signature(self, method: str, url: str) -> None:
-
         self.signature = self.get_signature(url=url, method=method)
         self.headers['X-Cmp-Signature'] = self.signature
 
-    def list_nic_details(self, virtual_server_id) -> List[dict]:
-        """List existing instances."""
-        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{virtual_server_id}/nics'  # pylint: disable=line-too-long
+    def get_nic(self, instance_id) -> List[dict]:
+        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}/nics'  # pylint: disable=line-too-long
         return self._get(url)
 
-    def get_external_ip(self, virtual_server_id, ip):
-        nic_details_list = self.list_nic_details(
-            virtual_server_id=virtual_server_id)
-        for nic_details in nic_details_list:
-            if (nic_details['ip'] == ip and
-                    nic_details['subnetType'] == 'PUBLIC'):
-                return nic_details['natIp']
+    def get_external_ip(self, instance_id, ip):
+        nics = self.get_nic(instance_id=instance_id)
+        for nic in nics:
+            if (nic['ip'] == ip and nic['subnetType'] == 'PUBLIC'):
+                return nic['natIp']
         return None
 
-    def list_zones(self) -> List[dict]:
+    def get_zones(self) -> List[dict]:
         url = f'{API_ENDPOINT}/project/v3/projects/{self.project_id}/zones'
         return self._get(url)
 
-    def list_products(self, service_zone_id) -> List[dict]:
-        url = f'{API_ENDPOINT}/product/v2/zones/{service_zone_id}/products'
-        return self._get(url)
-
-    def list_product_groups(self, service_zone_id) -> List[dict]:
-        url = f'{API_ENDPOINT}/product/v2/zones/{service_zone_id}/product-groups'  # pylint: disable=line-too-long
-        return self._get(url)
-
-    def list_vpcs(self, service_zone_id) -> List[dict]:
+    def get_vpcs(self, service_zone_id) -> List[dict]:
         url = f'{API_ENDPOINT}/vpc/v2/vpcs?serviceZoneId={service_zone_id}'
         return self._get(url)
 
-    def list_subnets(self) -> List[dict]:
+    def get_subnets(self) -> List[dict]:
         url = f'{API_ENDPOINT}/subnet/v2/subnets?subnetTypes=PUBLIC'
         return self._get(url)
 
-    def del_security_group(self, sg_id):
+    def delete_security_group(self, sg_id):
         url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}'
         return self._delete(url)
 
-    def del_firwall_rules(self, firewall_id, rule_id_list):
+    def delete_firewall_rule(self, firewall_id, rule_ids):
         url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
-        request_body = {'ruleDeletionType': 'PARTIAL', 'ruleIds': rule_id_list}
+        request_body = {'ruleDeletionType': 'PARTIAL', 'ruleIds': rule_ids}
         return self._delete(url, request_body=request_body)
 
-    def list_security_groups(self, vpc_id=None, sg_name=None):
+    def get_security_groups(self, vpc_id=None, sg_name=None):
         url = f'{API_ENDPOINT}/security-group/v2/security-groups'
         parameter = []
         if vpc_id is not None:
             parameter.append('vpcId=' + vpc_id)
         if sg_name is not None:
             parameter.append('securityGroupName=' + sg_name)
-        if parameter:
+        if len(parameter) > 0:
             url = url + '?' + '&'.join(parameter)
         return self._get(url)
 
-    def list_igw(self):
+    def get_internet_gateway(self):
         url = f'{API_ENDPOINT}/internet-gateway/v2/internet-gateways'
         return self._get(url)
 
-    def get_vm_info(self, vm_id):
-        url = f'{API_ENDPOINT}/virtual-server/v3/virtual-servers/{vm_id}'
-        return self._get(url, contents_key=None)
-
-    def get_firewal_rule_info(self, firewall_id, rule_id):
+    def get_firewall_rule_info(self, firewall_id, rule_id):
         url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules/{rule_id}'  # pylint: disable=line-too-long
         return self._get(url, contents_key=None)
 
-    def list_firwalls(self):
+    def get_firewalls(self):
         url = f'{API_ENDPOINT}/firewall/v2/firewalls'
         return self._get(url)
 
-    def list_service_zone_names(self):
+    def get_service_zone_names(self):
         url = f'{API_ENDPOINT}/project/v3/projects/{self.project_id}/zones'
         zone_contents = self._get(url)
         return [content['serviceZoneName'] for content in zone_contents]
 
-    def start_instance(self, vm_id):
-        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{vm_id}/start'
+    def start_instance(self, instance_id):
+        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}/start'  # pylint: disable=line-too-long
         return self._post(url=url, request_body={})
 
-    def stop_instance(self, vm_id):
-        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{vm_id}/stop'
+    def stop_instance(self, instance_id):
+        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}/stop'  # pylint: disable=line-too-long
         return self._post(url=url, request_body={})
+
+    def get_security_group_rules(self, sg_id):
+        url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}/rules'
+        return self._get(url)
+
+    def get_firewall_rules(self, firewall_id):
+        url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
+        return self._get(url)
+
+    def get_instance_info(self, instance_id):
+        url = f'{API_ENDPOINT}/virtual-server/v3/virtual-servers/{instance_id}'
+        return self._get(url=url, contents_key=None)
+
+    def create_vpc(self, zone_id):
+        vpc_name = 'skyvpc' + zone_id[5:10]
+        request_body = {
+            'serviceZoneId': zone_id,
+            'vpcName': vpc_name,
+            'vpcDescription': 'sky vpc'
+        }
+        url = f'{API_ENDPOINT}/vpc/v3/vpcs'
+        return self._post(url, request_body)
+
+    def create_subnet(self, vpc_id, zone_id):
+        subnet_name = 'skysubnet' + zone_id[5:10]
+        request_body = {
+            'subnetCidrBlock': '192.168.0.0/24',
+            'subnetName': subnet_name,
+            'subnetType': 'PUBLIC',
+            'vpcId': vpc_id,
+            'subnetDescription': 'sky subnet'
+        }
+        url = f'{API_ENDPOINT}/subnet/v2/subnets'
+        return self._post(url, request_body)
+
+    def create_internet_gateway(self, vpc_id):
+        request_body = {
+            'firewallEnabled': True,
+            'firewallLoggable': False,
+            'internetGatewayType': 'SHARED',
+            'vpcId': vpc_id,
+            'internetGatewayDescription': 'sky internet gateway'
+        }
+        url = f'{API_ENDPOINT}/internet-gateway/v4/internet-gateways'
+        return self._post(url, request_body)
+
+    def get_vpc_info(self, vpc_id):
+        url = f'{API_ENDPOINT}/vpc/v2/vpcs/{vpc_id}'
+        return self._get(url=url, contents_key=None)
+
+    def get_subnet_info(self, subnet_id):
+        url = f'{API_ENDPOINT}/subnet/v2/subnets/{subnet_id}'
+        return self._get(url=url, contents_key=None)
+
+    def get_internet_gateway_info(self, internet_gateway_id):
+        url = f'{API_ENDPOINT}/internet-gateway/v2/internet-gateways/{internet_gateway_id}'  # pylint: disable=line-too-long
+        return self._get(url=url, contents_key=None)
+
+    def get_key_pairs(self):
+        url = f'{API_ENDPOINT}/key-pair/v1/key-pairs'
+        return self._get(url=url, contents_key=None)