高效查询ECS可用资源的实践-阿里云开发者社区

摘要：创建实例总碰到没有资源，没有权限，产品限制等原因导致创建失败，到底哪些资源是可以使用并创建成功的呢？针对这个问题，我们来说说如何高效查询可用的资源列表。

在某一地域有哪些可用区

在某一可用区有哪些可用网络类型

在某一可用区有哪些可用IO优化资源

在某一可用区有哪些可用实例规格

在某一可用区有哪些可用系统盘类型

在某一可用区有哪些可用数据盘类型

您可以通过指定不同目标资源（ DestinationResource ）查询不同类型的资源列表，再指定其他条件细化查询。目标资源（ DestinationResource）的各个可选取值有不同的逻辑与（&&）要求。在下列顺序列表中，排在越后面的参数其逻辑与（&&）苛刻程度越高。
顺序：（Zone）> IoOptimized > InstanceType > SystemDisk > DataDisk
取值示例：

若参数 DestinationResource 取值为 InstanceType，则必须传入参数 IoOptimized。
若参数 DestinationResource 取值为 SystemDisk，则必须传入参数 IoOptimized 和 InstanceType。
若参数 DestinationResource 取值为 DataDisk，则必须传入参数 IoOptimized、InstanceType 和 SystemDiskCategory。

除了您现在看到的这文章，您还可以前往API文档：

DescribeAvailableResource

aliyun-java-sdk-ecs版本在4.6.3及以上。

要点概述

sdk使用

    public DescribeAvailableResourceResponse doAction(DescribeAvailableResourceRequest describe) {
        IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", product_accessKey, product_accessSecret);
        IAcsClient client = new DefaultAcsClient(profile);
        try {
            DescribeAvailableResourceResponse response = client.getAcsResponse(describe);
            System.out.println(JSON.toJSONString(response));
            return response;

        } catch (ClientException e) {
            e.printStackTrace();
        }
        return null;
    }

查询之前先确认所需资源的付费类型

查询可用区资源

    public void doDescribeAvailableZones() {
        DescribeAvailableResourceRequest describe = new DescribeAvailableResourceRequest();
        describe.setDestinationResource("Zone");
        describe.setRegionId("cn-hangzhou");
        // InstanceChargeType 默认为PostPaid
        // PrePaid：预付费，即 包年包月 ;
        // PostPaid：后付费，即 按量付费
        describe.setInstanceChargeType("PostPaid");
        // 当参数 InstanceChargeType 取值为 PostPaid 时，参数 SpotStrategy 才有效。
        // NoSpot：正常按量付费实例 ;
        // SpotWithPriceLimit：设置上限价格的竞价实例 ;
        // SpotAsPriceGo：系统自动出价，最高按量付费价格
        describe.setSpotStrategy("NoSpot");
        DescribeAvailableResourceResponse response = doAction(describe);
        if (null != response && CollectionUtils.isNotEmpty(response.getAvailableZones())) {
            List<AvailableZone> availableZones = response.getAvailableZones();
            List<String> list = new ArrayList<String>(availableZones.size());
            for (AvailableZone availableZone : availableZones) {
                if (availableZone.getStatus().equals("Available")) {
                    list.add(availableZone.getZoneId());
                }
            }
        }
    }

返回结果

{
    "availableZones": [
        {
            "availableResources": [],
            "regionId": "cn-hangzhou",
            "status": "Available",
            "zoneId": "cn-hangzhou-e"
        },
        {
            "availableResources": [],
            "regionId": "cn-hangzhou",
            "status": "Available",
            "zoneId": "cn-hangzhou-b"
        },
        {
            "availableResources": [],
            "regionId": "cn-hangzhou",
            "status": "Available",
            "zoneId": "cn-hangzhou-d"
        }
    ],
    "requestId": "0789B955-A173-4513-ADE4-80B7B4A4C921"
}

查询可用网络类型资源

    public void doDescribeAvailableNetworks() {
        DescribeAvailableResourceRequest describe = new DescribeAvailableResourceRequest();
        describe.setDestinationResource("Network");
        describe.setRegionId("cn-hangzhou");
        //不传就是查所有可用区
        describe.setZoneId("cn-hangzhou-e");
        // InstanceChargeType 默认为PostPaid
        // PrePaid：预付费，即 包年包月 ;
        // PostPaid：后付费，即 按量付费
        describe.setInstanceChargeType("PostPaid");
        // 当参数 InstanceChargeType 取值为 PostPaid 时，参数 SpotStrategy 才有效。
        // NoSpot：正常按量付费实例 ;
        // SpotWithPriceLimit：设置上限价格的竞价实例 ;
        // SpotAsPriceGo：系统自动出价，最高按量付费价格
        describe.setSpotStrategy("NoSpot");
        doAction(describe);
    }

返回结果

{
    "availableZones": [
        {
            "availableResources": [
                {
                    "supportedResources": [
                        {
                            "status": "Available",
                            "value": "classic"
                        },
                        {
                            "status": "Available",
                            "value": "vpc"
                        }
                    ],
                    "type": "Network"
                }
            ],
            "regionId": "cn-hangzhou",
            "status": "Available",
            "zoneId": "cn-hangzhou-e"
        }
    ],
    "requestId": "7A56347F-8D2E-440A-884B-1EF66654C7A8"
}

查询可用IO优化资源

没有指定付费类型，InstanceChargeType默认就是PostPaid,SpotStrategy默认为NoSpot

    public void doDescribeAvailableIoOptimizeds() {
        DescribeAvailableResourceRequest describe = new DescribeAvailableResourceRequest();
        describe.setDestinationResource("IoOptimized");
        describe.setRegionId("cn-hangzhou");
        //不传就是查所有可用区
        describe.setZoneId("cn-hangzhou-b");
        //不是必填值,根据自己需要的网络类型过滤更准确
        //describe.setNetworkCategory("Classic");
        doAction(describe);
    }

返回结果

{
    "availableZones": [
        {
            "availableResources": [
                {
                    "supportedResources": [
                        {
                            "status": "Available",
                            "value": "none"
                        },
                        {
                            "status": "Available",
                            "value": "optimized"
                        }
                    ],
                    "type": "IoOptimized"
                }
            ],
            "regionId": "cn-hangzhou",
            "status": "Available",
            "zoneId": "cn-hangzhou-b"
        }
    ],
    "requestId": "AA6CF750-E6D8-4696-BA0E-D3B7F66D127F"
}

过滤条件导致没有可用资源时返回

查询可用实例规格资源

若参数 DestinationResource 取值为 InstanceType，则必须传入参数 IoOptimized

    public void doDescribeAvailableInstanceTypes() {
        DescribeAvailableResourceRequest describe = new DescribeAvailableResourceRequest();
        describe.setDestinationResource("InstanceType");
        describe.setRegionId("cn-hangzhou");
        //不传就是查所有可用区
        describe.setZoneId("cn-hangzhou-d");
        // InstanceChargeType 默认为PostPaid
        // PrePaid：预付费，即 包年包月 ;
        // PostPaid：后付费，即 按量付费
        describe.setInstanceChargeType("PostPaid");
        // 当参数 InstanceChargeType 取值为 PostPaid 时，参数 SpotStrategy 才有效。
        // NoSpot：正常按量付费实例 ;
        // SpotWithPriceLimit：设置上限价格的竞价实例 ;
        // SpotAsPriceGo：系统自动出价，最高按量付费价格
        describe.setSpotStrategy("NoSpot");
        //必填值 none：非 I/O 优化实例 ; optimized：I/O 优化实例
        describe.setIoOptimized("optimized");

        //不是必填值,根据自己需要的网络类型过滤更准确 Vpc：专有网络 ; Classic：经典网络
        describe.setNetworkCategory("Vpc");
        doAction(describe);
    }

返回结果 status为SoldOut为实例规格售罄

{
    "availableZones": [
        {
            "availableResources": [
                {
                    "supportedResources": [
                        {
                            "status": "Available",
                            "value": "ecs.gn4-c8g1.4xlarge"
                        },
                        {
                            "status": "Available",
                            "value": "ecs.gn4-c4g1.2xlarge"
                        },
                        {
                            "status": "Available",
                            "value": "ecs.gn4.8xlarge"
                        },
                        {
                            "status": "SoldOut",
                            "value": "ecs.gn4.14xlarge"
                        },
                        {
                            "status": "Available",
                            "value": "ecs.gn4-c4g1.xlarge"
                        },
                        {
                            "status": "Available",
                            "value": "ecs.gn4-c8g1.2xlarge"
                        }
                    ],
                    "type": "InstanceType"
                }
            ],
            "regionId": "cn-hangzhou",
            "status": "Available",
            "zoneId": "cn-hangzhou-d"
        }
    ],
    "requestId": "888B31FC-269B-4024-BFDA-263C57C67B31"
}

若IoOptimized没有传入，则报错：
Code: Invalid.Param
Message: The input parameter DestinationResource that is mandatory for processing this request is not supplied.

查询可用系统盘资源

若参数 DestinationResource 取值为 SystemDisk，则必须传入参数 IoOptimized 和 InstanceType。

    public void doDescribeAvailableSystemDisks() {

        DescribeAvailableResourceRequest describe = new DescribeAvailableResourceRequest();
        describe.setDestinationResource("SystemDisk");
        describe.setRegionId("cn-hangzhou");
        //不传就是查所有可用区
        describe.setZoneId("cn-hangzhou-d");
        // InstanceChargeType 默认为PostPaid
        // PrePaid：预付费，即 包年包月 ;
        // PostPaid：后付费，即 按量付费
        describe.setInstanceChargeType("PostPaid");
        // 当参数 InstanceChargeType 取值为 PostPaid 时，参数 SpotStrategy 才有效。
        // NoSpot：正常按量付费实例 ;
        // SpotWithPriceLimit：设置上限价格的竞价实例 ;
        // SpotAsPriceGo：系统自动出价，最高按量付费价格
        describe.setSpotStrategy("NoSpot");
        //必填值 none：非 I/O 优化实例 ; optimized：I/O 优化实例
        describe.setIoOptimized("optimized");
        //必填值 实例规格
        describe.setInstanceType("ecs.gn4-c8g1.2xlarge");

        //不是必填值,根据自己需要的网络类型过滤更准确 Vpc：专有网络 ; Classic：经典网络
        describe.setNetworkCategory("Vpc");
        doAction(describe);

    }

返回结果

{
    "availableZones": [
        {
            "availableResources": [
                {
                    "supportedResources": [
                        {
                            "max": 500,
                            "min": 20,
                            "status": "Available",
                            "unit": "GB",
                            "value": "cloud_efficiency"
                        },
                        {
                            "max": 500,
                            "min": 20,
                            "status": "Available",
                            "unit": "GB",
                            "value": "cloud_ssd"
                        }
                    ],
                    "type": "SystemDisk"
                }
            ],
            "regionId": "cn-hangzhou",
            "status": "Available",
            "zoneId": "cn-hangzhou-d"
        }
    ],
    "requestId": "4063AA6A-01E1-46F0-9DB8-A74AF5FE98E6"
}

查询可用数据盘资源

若参数 DestinationResource 取值为 DataDisk，则必须传入参数 IoOptimized、InstanceType 和 SystemDiskCategory。
延用上面的代码

    public void doDescribeAvailableDataDisks() {

        DescribeAvailableResourceRequest describe = new DescribeAvailableResourceRequest();
        describe.setDestinationResource("DataDisk");
        describe.setRegionId("cn-hangzhou");
        //不传就是查所有可用区
        describe.setZoneId("cn-hangzhou-d");
        // InstanceChargeType 默认为PostPaid
        // PrePaid：预付费，即 包年包月 ;
        // PostPaid：后付费，即 按量付费
        describe.setInstanceChargeType("PostPaid");
        // 当参数 InstanceChargeType 取值为 PostPaid 时，参数 SpotStrategy 才有效。
        // NoSpot：正常按量付费实例 ;
        // SpotWithPriceLimit：设置上限价格的竞价实例 ;
        // SpotAsPriceGo：系统自动出价，最高按量付费价格
        describe.setSpotStrategy("NoSpot");
        //必填值 none：非 I/O 优化实例 ; optimized：I/O 优化实例
        describe.setIoOptimized("optimized");
        //必填值 实例规格
        describe.setInstanceType("ecs.gn4-c8g1.2xlarge");
        //必填值 系统盘类型
        describe.setSystemDiskCategory("cloud_ssd");

        //不是必填值,根据自己需要的网络类型过滤更准确 Vpc：专有网络 ; Classic：经典网络
        describe.setNetworkCategory("Vpc");
        doAction(describe);

    }

返回结果

{
    "availableZones": [
        {
            "availableResources": [
                {
                    "supportedResources": [
                        {
                            "max": 32768,
                            "min": 20,
                            "status": "Available",
                            "unit": "GB",
                            "value": "cloud_ssd"
                        },
                        {
                            "max": 2000,
                            "min": 5,
                            "status": "Available",
                            "unit": "GB",
                            "value": "cloud"
                        },
                        {
                            "max": 32768,
                            "min": 20,
                            "status": "Available",
                            "unit": "GB",
                            "value": "cloud_efficiency"
                        }
                    ],
                    "type": "DataDisk"
                }
            ],
            "regionId": "cn-hangzhou",
            "status": "Available",
            "zoneId": "cn-hangzhou-d"
        }
    ],
    "requestId": "8A43A1D2-0065-4050-AA40-C614FF94A336"
}

联合查询

     public final static String IOOPTIMIED = "IoOptimized";
    public final static String INSTANCETYPE = "InstanceType";
    public final static String SYSTEMDISK = "SystemDisk";
    public final static String DATADISK = "DataDisk";
    public final static String ZONE =  "Zone";
    public final static String NETWORK =  "Network";

    public DescribeAvailableResourceRequest doCommonRequest(DescribeAvailableResourceRequest describe) {
        if (null == describe) {
            describe = new DescribeAvailableResourceRequest();
        }
        describe.setRegionId("cn-hangzhou");
        // InstanceChargeType 默认为PostPaid
        // PrePaid：预付费，即 包年包月 ;
        // PostPaid：后付费，即 按量付费
        describe.setInstanceChargeType("PostPaid");
        // 当参数 InstanceChargeType 取值为 PostPaid 时，参数 SpotStrategy 才有效。
        // NoSpot：正常按量付费实例 ;
        // SpotWithPriceLimit：设置上限价格的竞价实例 ;
        // SpotAsPriceGo：系统自动出价，最高按量付费价格
        describe.setSpotStrategy("NoSpot");
        return describe;
    }

    public List<String> getResources(String destinationResource, DescribeAvailableResourceRequest describe) {
        describe = doCommonRequest(describe);
        if(!ZONE.equals(destinationResource)) {
            List<String> zones =  getResources(ZONE,describe);
            //取所需的可用区，这里取第一个值; 不传就是查所有可用区
            describe.setZoneId(zones.get(0));
        }
        if(!ZONE.equals(destinationResource) && !NETWORK.equals(destinationResource)){
            List<String> networks =  getResources(NETWORK,describe);
            //不是必填值,根据自己需要的网络类型过滤更准确 Vpc：专有网络 ; Classic：经典网络
            describe.setNetworkCategory(networks.get(0));
        }
        if (INSTANCETYPE.equals(destinationResource)) {
            List<String> ioOpts = getResources(IOOPTIMIED, describe);
            //取所需的IO优化资源，这里取第一个值
            describe.setIoOptimized(ioOpts.get(0));
        }
        if (SYSTEMDISK.equals(destinationResource)) {
            List<String> types = getResources(INSTANCETYPE, describe);
            //取所需的实例规格资源，这里取第一个值
            describe.setInstanceType(types.get(0));
        }
        if (DATADISK.equals(destinationResource)) {
            List<String> systemDisks = getResources(SYSTEMDISK, describe);
            //取所需的系统盘资源，这里取第一个值
            describe.setSystemDiskCategory(systemDisks.get(0));
        }
        describe.setDestinationResource(destinationResource);
        return getResponse(describe, destinationResource);
    }

    public List<String> getResponse(DescribeAvailableResourceRequest describe, String destinationResource) {
        DescribeAvailableResourceResponse response = doAction(describe);
        if (null != response && CollectionUtils.isNotEmpty(response.getAvailableZones())) {
            List<String> zones = new ArrayList<String>();
            for (AvailableZone availableZone : response.getAvailableZones()) {
                if(ZONE.equals(destinationResource)){
                    if (availableZone.getStatus().equals("Available")) {
                        zones.add(availableZone.getZoneId());
                    }
                }
                if (CollectionUtils.isNotEmpty(availableZone.getAvailableResources())) {
                    for (AvailableResource resource : availableZone.getAvailableResources()) {
                        if (resource.getType().equals(destinationResource)) {
                            if (CollectionUtils.isNotEmpty(resource.getSupportedResources())) {
                                List<String> types = new ArrayList<String>();
                                for (SupportedResource supportResource : resource.getSupportedResources()) {
                                    //只取可用资源，SoldOut为售罄
                                    if (supportResource.getStatus().equals("Available")) {
                                        types.add(supportResource.getValue());
                                    }
                                }
                                return types;
                            }
                        }
                    }
                }
            }
            if(CollectionUtils.isNotEmpty(zones)){
                return zones;
            }
        }
        return null;
    }

    //查询所需目标类型资源的值
    public void doDescribeResources(String destinationResource) {
        List<String> values = getResources(destinationResource, null);
    }

高效查询ECS可用资源的实践

DescribeAvailableResource

要点概述

sdk使用

查询之前先确认所需资源的付费类型

查询可用区资源

查询可用网络类型资源

查询可用IO优化资源

查询可用实例规格资源

查询可用系统盘资源

查询可用数据盘资源

联合查询

热门文章

最新文章

相关课程

相关电子书

相关实验场景