进阶接口:查询ECS新购可用的资源实践-阿里云开发者社区

开发者社区> 弹性计算> 正文

进阶接口:查询ECS新购可用的资源实践

简介: 云服务器ECS到底哪些资源是可以使用并创建成功的呢?针对这个问题,我们来说说如何高效查询可用的资源列表。

  • 在某一地域有哪些可用区
  • 在某一可用区有哪些可用网络类型
  • 在某一可用区有哪些可用IO优化资源
  • 在某一可用区有哪些可用实例规格
  • 在某一可用区有哪些可用系统盘类型
  • 在某一可用区有哪些可用数据盘类型
  • 进阶实践——联合查询

背景

ECS服务器有哪些资源是可售卖的?如何更好的选择所需的资源?怎么查询可用的目标资源列表?怎么通过API(像ECS售卖页面一样)玩转可用资源的花样选择?

说明

接口 :DescribeAvailableResource
您可以通过DescribeAvailableResource指定不同目标资源( DestinationResource )查询不同类型的资源列表,再指定其他条件细化资源条件。目标资源( DestinationResource) 的各个可选取值有不同的逻辑与(&&)要求。在下列顺序列表中,排在越后面的参数其逻辑与(&&)苛刻程度越高。
顺序:(Zone)> IoOptimized > InstanceType > SystemDisk > DataDisk
取值示例:
若参数 DestinationResource 取值为 InstanceType,则必须传入参数 IoOptimized。
若参数 DestinationResource 取值为 SystemDisk,则必须传入参数 IoOptimized 和 InstanceType。
若参数 DestinationResource 取值为 DataDisk,则必须传入参数 IoOptimized、InstanceType 和 SystemDiskCategory。

除了您现在看到的这文章,您还可以前往:
针对ECS创建场景查询可用资源


事例

sdk使用

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

    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;
    }

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

image.png

查询可用区资源

    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"
}

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

查询可用实例规格资源

若参数 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);
    }

返回结果 statusSoldOut为实例规格售罄

{
    "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,则必须传入参数 IoOptimizedInstanceType

    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,则必须传入参数 IoOptimizedInstanceTypeSystemDiskCategory
延用上面的代码

    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);
    }

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
+ 订阅

做技术领先、性能优异、稳如磐石的弹性计算!

官方博客
官网链接