alicloud.vpc.getIpamIpamPoolCidrs

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default_ipam = alicloud.vpc.IpamIpam("defaultIpam", operating_region_lists=["cn-hangzhou"])
default_ipam_pool = alicloud.vpc.IpamIpamPool("defaultIpamPool",
    ipam_scope_id=default_ipam.private_default_scope_id,
    pool_region_id=default_ipam.region_id,
    ip_version="IPv4")
default_ipam_ipam_pool_cidr = alicloud.vpc.IpamIpamPoolCidr("default",
    cidr="10.0.0.0/8",
    ipam_pool_id=default_ipam_pool.id)
default = alicloud.vpc.get_ipam_ipam_pool_cidrs_output(cidr="10.0.0.0/8",
    ipam_pool_id=default_ipam_ipam_pool_cidr.ipam_pool_id)
pulumi.export("alicloudVpcIpamIpamPoolCidrExampleId", default.cidrs[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
cfg := config.New(ctx, "")
name := "terraform-example";
if param := cfg.Get("name"); param != ""{
name = param
}
defaultIpam, err := vpc.NewIpamIpam(ctx, "defaultIpam", &vpc.IpamIpamArgs{
OperatingRegionLists: pulumi.StringArray{
pulumi.String("cn-hangzhou"),
},
})
if err != nil {
return err
}
defaultIpamPool, err := vpc.NewIpamIpamPool(ctx, "defaultIpamPool", &vpc.IpamIpamPoolArgs{
IpamScopeId: defaultIpam.PrivateDefaultScopeId,
PoolRegionId: defaultIpam.RegionId,
IpVersion: pulumi.String("IPv4"),
})
if err != nil {
return err
}
defaultIpamIpamPoolCidr, err := vpc.NewIpamIpamPoolCidr(ctx, "default", &vpc.IpamIpamPoolCidrArgs{
Cidr: pulumi.String("10.0.0.0/8"),
IpamPoolId: defaultIpamPool.ID(),
})
if err != nil {
return err
}
_default := vpc.GetIpamIpamPoolCidrsOutput(ctx, vpc.GetIpamIpamPoolCidrsOutputArgs{
Cidr: pulumi.String("10.0.0.0/8"),
IpamPoolId: defaultIpamIpamPoolCidr.IpamPoolId,
}, nil);
ctx.Export("alicloudVpcIpamIpamPoolCidrExampleId", _default.ApplyT(func(_default vpc.GetIpamIpamPoolCidrsResult) (*string, error) {
return &default.Cidrs[0].Id, nil
}).(pulumi.StringPtrOutput))
return nil
})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var defaultIpam = new AliCloud.Vpc.IpamIpam("defaultIpam", new()
    {
        OperatingRegionLists = new[]
        {
            "cn-hangzhou",
        },
    });

    var defaultIpamPool = new AliCloud.Vpc.IpamIpamPool("defaultIpamPool", new()
    {
        IpamScopeId = defaultIpam.PrivateDefaultScopeId,
        PoolRegionId = defaultIpam.RegionId,
        IpVersion = "IPv4",
    });

    var defaultIpamIpamPoolCidr = new AliCloud.Vpc.IpamIpamPoolCidr("default", new()
    {
        Cidr = "10.0.0.0/8",
        IpamPoolId = defaultIpamPool.Id,
    });

    var @default = AliCloud.Vpc.GetIpamIpamPoolCidrs.Invoke(new()
    {
        Cidr = "10.0.0.0/8",
        IpamPoolId = defaultIpamIpamPoolCidr.IpamPoolId,
    });

    return new Dictionary<string, object?>
    {
        ["alicloudVpcIpamIpamPoolCidrExampleId"] = @default.Apply(@default => @default.Apply(getIpamIpamPoolCidrsResult => getIpamIpamPoolCidrsResult.Cidrs[0]?.Id)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.vpc.IpamIpam;
import com.pulumi.alicloud.vpc.IpamIpamArgs;
import com.pulumi.alicloud.vpc.IpamIpamPool;
import com.pulumi.alicloud.vpc.IpamIpamPoolArgs;
import com.pulumi.alicloud.vpc.IpamIpamPoolCidr;
import com.pulumi.alicloud.vpc.IpamIpamPoolCidrArgs;
import com.pulumi.alicloud.vpc.VpcFunctions;
import com.pulumi.alicloud.vpc.inputs.GetIpamIpamPoolCidrsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        var defaultIpam = new IpamIpam("defaultIpam", IpamIpamArgs.builder()
            .operatingRegionLists("cn-hangzhou")
            .build());

        var defaultIpamPool = new IpamIpamPool("defaultIpamPool", IpamIpamPoolArgs.builder()
            .ipamScopeId(defaultIpam.privateDefaultScopeId())
            .poolRegionId(defaultIpam.regionId())
            .ipVersion("IPv4")
            .build());

        var defaultIpamIpamPoolCidr = new IpamIpamPoolCidr("defaultIpamIpamPoolCidr", IpamIpamPoolCidrArgs.builder()
            .cidr("10.0.0.0/8")
            .ipamPoolId(defaultIpamPool.id())
            .build());

        final var default = VpcFunctions.getIpamIpamPoolCidrs(GetIpamIpamPoolCidrsArgs.builder()
            .cidr("10.0.0.0/8")
            .ipamPoolId(defaultIpamIpamPoolCidr.ipamPoolId())
            .build());

        ctx.export("alicloudVpcIpamIpamPoolCidrExampleId", default_.applyValue(default_ -> default_.cidrs()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultIpam:
    type: alicloud:vpc:IpamIpam
    properties:
      operatingRegionLists:
        - cn-hangzhou
  defaultIpamPool:
    type: alicloud:vpc:IpamIpamPool
    properties:
      ipamScopeId: ${defaultIpam.privateDefaultScopeId}
      poolRegionId: ${defaultIpam.regionId}
      ipVersion: IPv4
  defaultIpamIpamPoolCidr:
    type: alicloud:vpc:IpamIpamPoolCidr
    name: default
    properties:
      cidr: 10.0.0.0/8
      ipamPoolId: ${defaultIpamPool.id}
variables:
  default:
    fn::invoke:
      function: alicloud:vpc:getIpamIpamPoolCidrs
      arguments:
        cidr: 10.0.0.0/8
        ipamPoolId: ${defaultIpamIpamPoolCidr.ipamPoolId}
outputs:
  alicloudVpcIpamIpamPoolCidrExampleId: ${default.cidrs[0].id}

def get_ipam_ipam_pool_cidrs(cidr: Optional[str] = None,
                             ipam_pool_id: Optional[str] = None,
                             output_file: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetIpamIpamPoolCidrsResult
def get_ipam_ipam_pool_cidrs_output(cidr: Optional[pulumi.Input[str]] = None,
                             ipam_pool_id: Optional[pulumi.Input[str]] = None,
                             output_file: Optional[pulumi.Input[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[GetIpamIpamPoolCidrsResult]

func GetIpamIpamPoolCidrs(ctx *Context, args *GetIpamIpamPoolCidrsArgs, opts ...InvokeOption) (*GetIpamIpamPoolCidrsResult, error)
func GetIpamIpamPoolCidrsOutput(ctx *Context, args *GetIpamIpamPoolCidrsOutputArgs, opts ...InvokeOption) GetIpamIpamPoolCidrsResultOutput

public static class GetIpamIpamPoolCidrs 
{
    public static Task<GetIpamIpamPoolCidrsResult> InvokeAsync(GetIpamIpamPoolCidrsArgs args, InvokeOptions? opts = null)
    public static Output<GetIpamIpamPoolCidrsResult> Invoke(GetIpamIpamPoolCidrsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetIpamIpamPoolCidrsResult> getIpamIpamPoolCidrs(GetIpamIpamPoolCidrsArgs args, InvokeOptions options)
public static Output<GetIpamIpamPoolCidrsResult> getIpamIpamPoolCidrs(GetIpamIpamPoolCidrsArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:vpc/getIpamIpamPoolCidrs:getIpamIpamPoolCidrs
  arguments:
    # arguments dictionary