alicloud.sae.getIngresses

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";

const config = new pulumi.Config();
const name = config.get("name") || "example_value";
const _default = alicloud.getZones({
    availableResourceCreation: "VSwitch",
});
const defaultNetwork = new alicloud.vpc.Network("default", {
    name: name,
    cidrBlock: "172.16.0.0/12",
});
const defaultSwitch = new alicloud.vpc.Switch("default", {
    vpcId: defaultNetwork.id,
    cidrBlock: "172.16.0.0/21",
    zoneId: _default.then(_default => _default.zones?.[0]?.id),
    vswitchName: name,
});
const defaultLoadBalancer = new alicloud.slb.LoadBalancer("default", {
    name: name,
    specification: "slb.s2.small",
    vswitchId: defaultAlicloudVswitches.ids[0],
});
const desc = config.get("desc") || "example_value";
const namespaceId = config.get("namespaceId") || "cn-hangzhou:yourname";
const defaultNamespace = new alicloud.sae.Namespace("default", {
    namespaceId: namespaceId,
    namespaceName: name,
    namespaceDescription: desc,
});
const defaultApplication = new alicloud.sae.Application("default", {
    appDescription: "your_app_description",
    appName: "your_app_name",
    namespaceId: "your_namespace_id",
    packageUrl: "your_package_url",
    packageType: "your_package_url",
    jdk: "jdk_specifications",
    vswitchId: defaultAlicloudVswitches.ids[0],
    replicas: "your_replicas",
    cpu: "cpu_specifications",
    memory: "memory_specifications",
});
const defaultIngress = new alicloud.sae.Ingress("default", {
    slbId: defaultLoadBalancer.id,
    namespaceId: defaultNamespace.id,
    listenerPort: "your_listener_port",
    rules: [{
        appId: defaultApplication.id,
        containerPort: "your_container_port",
        domain: "your_domain",
        appName: "your_name",
        path: "your_path",
    }],
});
const defaultGetIngresses = alicloud.sae.getIngressesOutput({
    ids: [defaultIngress.id],
});
export const saeIngressId = defaultGetIngresses.ingressList[0].id;

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "example_value"
default = alicloud.get_zones(available_resource_creation="VSwitch")
default_network = alicloud.vpc.Network("default",
    name=name,
    cidr_block="172.16.0.0/12")
default_switch = alicloud.vpc.Switch("default",
    vpc_id=default_network.id,
    cidr_block="172.16.0.0/21",
    zone_id=default.zones[0].id,
    vswitch_name=name)
default_load_balancer = alicloud.slb.LoadBalancer("default",
    name=name,
    specification="slb.s2.small",
    vswitch_id=default_alicloud_vswitches["ids"][0])
desc = config.get("desc")
if desc is None:
    desc = "example_value"
namespace_id = config.get("namespaceId")
if namespace_id is None:
    namespace_id = "cn-hangzhou:yourname"
default_namespace = alicloud.sae.Namespace("default",
    namespace_id=namespace_id,
    namespace_name=name,
    namespace_description=desc)
default_application = alicloud.sae.Application("default",
    app_description="your_app_description",
    app_name="your_app_name",
    namespace_id="your_namespace_id",
    package_url="your_package_url",
    package_type="your_package_url",
    jdk="jdk_specifications",
    vswitch_id=default_alicloud_vswitches["ids"][0],
    replicas="your_replicas",
    cpu="cpu_specifications",
    memory="memory_specifications")
default_ingress = alicloud.sae.Ingress("default",
    slb_id=default_load_balancer.id,
    namespace_id=default_namespace.id,
    listener_port="your_listener_port",
    rules=[{
        "app_id": default_application.id,
        "container_port": "your_container_port",
        "domain": "your_domain",
        "app_name": "your_name",
        "path": "your_path",
    }])
default_get_ingresses = alicloud.sae.get_ingresses_output(ids=[default_ingress.id])
pulumi.export("saeIngressId", default_get_ingresses.ingress_list[0]["id"])

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/sae"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/slb"
	"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 := "example_value";
if param := cfg.Get("name"); param != ""{
name = param
}
_default, err := alicloud.GetZones(ctx, &alicloud.GetZonesArgs{
AvailableResourceCreation: pulumi.StringRef("VSwitch"),
}, nil);
if err != nil {
return err
}
defaultNetwork, err := vpc.NewNetwork(ctx, "default", &vpc.NetworkArgs{
Name: pulumi.String(name),
CidrBlock: pulumi.String("172.16.0.0/12"),
})
if err != nil {
return err
}
_, err = vpc.NewSwitch(ctx, "default", &vpc.SwitchArgs{
VpcId: defaultNetwork.ID(),
CidrBlock: pulumi.String("172.16.0.0/21"),
ZoneId: pulumi.String(_default.Zones[0].Id),
VswitchName: pulumi.String(name),
})
if err != nil {
return err
}
defaultLoadBalancer, err := slb.NewLoadBalancer(ctx, "default", &slb.LoadBalancerArgs{
Name: pulumi.String(name),
Specification: pulumi.String("slb.s2.small"),
VswitchId: pulumi.Any(defaultAlicloudVswitches.Ids[0]),
})
if err != nil {
return err
}
desc := "example_value";
if param := cfg.Get("desc"); param != ""{
desc = param
}
namespaceId := "cn-hangzhou:yourname";
if param := cfg.Get("namespaceId"); param != ""{
namespaceId = param
}
defaultNamespace, err := sae.NewNamespace(ctx, "default", &sae.NamespaceArgs{
NamespaceId: pulumi.String(namespaceId),
NamespaceName: pulumi.String(name),
NamespaceDescription: pulumi.String(desc),
})
if err != nil {
return err
}
defaultApplication, err := sae.NewApplication(ctx, "default", &sae.ApplicationArgs{
AppDescription: pulumi.String("your_app_description"),
AppName: pulumi.String("your_app_name"),
NamespaceId: pulumi.String("your_namespace_id"),
PackageUrl: pulumi.String("your_package_url"),
PackageType: pulumi.String("your_package_url"),
Jdk: pulumi.String("jdk_specifications"),
VswitchId: pulumi.Any(defaultAlicloudVswitches.Ids[0]),
Replicas: pulumi.Int("your_replicas"),
Cpu: pulumi.Int("cpu_specifications"),
Memory: pulumi.Int("memory_specifications"),
})
if err != nil {
return err
}
defaultIngress, err := sae.NewIngress(ctx, "default", &sae.IngressArgs{
SlbId: defaultLoadBalancer.ID(),
NamespaceId: defaultNamespace.ID(),
ListenerPort: pulumi.Int("your_listener_port"),
Rules: sae.IngressRuleArray{
&sae.IngressRuleArgs{
AppId: defaultApplication.ID(),
ContainerPort: pulumi.Int("your_container_port"),
Domain: pulumi.String("your_domain"),
AppName: pulumi.String("your_name"),
Path: pulumi.String("your_path"),
},
},
})
if err != nil {
return err
}
defaultGetIngresses := sae.GetIngressesOutput(ctx, sae.GetIngressesOutputArgs{
Ids: pulumi.StringArray{
defaultIngress.ID(),
},
}, nil);
ctx.Export("saeIngressId", defaultGetIngresses.ApplyT(func(defaultGetIngresses sae.GetIngressesResult) (interface{}, error) {
return defaultGetIngresses.IngressList[0].Id, nil
}).(pulumi.Interface{}Output))
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") ?? "example_value";
    var @default = AliCloud.GetZones.Invoke(new()
    {
        AvailableResourceCreation = "VSwitch",
    });

    var defaultNetwork = new AliCloud.Vpc.Network("default", new()
    {
        Name = name,
        CidrBlock = "172.16.0.0/12",
    });

    var defaultSwitch = new AliCloud.Vpc.Switch("default", new()
    {
        VpcId = defaultNetwork.Id,
        CidrBlock = "172.16.0.0/21",
        ZoneId = @default.Apply(@default => @default.Apply(getZonesResult => getZonesResult.Zones[0]?.Id)),
        VswitchName = name,
    });

    var defaultLoadBalancer = new AliCloud.Slb.LoadBalancer("default", new()
    {
        Name = name,
        Specification = "slb.s2.small",
        VswitchId = defaultAlicloudVswitches.Ids[0],
    });

    var desc = config.Get("desc") ?? "example_value";
    var namespaceId = config.Get("namespaceId") ?? "cn-hangzhou:yourname";
    var defaultNamespace = new AliCloud.Sae.Namespace("default", new()
    {
        NamespaceId = namespaceId,
        NamespaceName = name,
        NamespaceDescription = desc,
    });

    var defaultApplication = new AliCloud.Sae.Application("default", new()
    {
        AppDescription = "your_app_description",
        AppName = "your_app_name",
        NamespaceId = "your_namespace_id",
        PackageUrl = "your_package_url",
        PackageType = "your_package_url",
        Jdk = "jdk_specifications",
        VswitchId = defaultAlicloudVswitches.Ids[0],
        Replicas = "your_replicas",
        Cpu = "cpu_specifications",
        Memory = "memory_specifications",
    });

    var defaultIngress = new AliCloud.Sae.Ingress("default", new()
    {
        SlbId = defaultLoadBalancer.Id,
        NamespaceId = defaultNamespace.Id,
        ListenerPort = "your_listener_port",
        Rules = new[]
        {
            new AliCloud.Sae.Inputs.IngressRuleArgs
            {
                AppId = defaultApplication.Id,
                ContainerPort = "your_container_port",
                Domain = "your_domain",
                AppName = "your_name",
                Path = "your_path",
            },
        },
    });

    var defaultGetIngresses = AliCloud.Sae.GetIngresses.Invoke(new()
    {
        Ids = new[]
        {
            defaultIngress.Id,
        },
    });

    return new Dictionary<string, object?>
    {
        ["saeIngressId"] = defaultGetIngresses.Apply(getIngressesResult => getIngressesResult.IngressList[0].Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.AlicloudFunctions;
import com.pulumi.alicloud.inputs.GetZonesArgs;
import com.pulumi.alicloud.vpc.Network;
import com.pulumi.alicloud.vpc.NetworkArgs;
import com.pulumi.alicloud.vpc.Switch;
import com.pulumi.alicloud.vpc.SwitchArgs;
import com.pulumi.alicloud.slb.LoadBalancer;
import com.pulumi.alicloud.slb.LoadBalancerArgs;
import com.pulumi.alicloud.sae.Namespace;
import com.pulumi.alicloud.sae.NamespaceArgs;
import com.pulumi.alicloud.sae.Application;
import com.pulumi.alicloud.sae.ApplicationArgs;
import com.pulumi.alicloud.sae.Ingress;
import com.pulumi.alicloud.sae.IngressArgs;
import com.pulumi.alicloud.sae.inputs.IngressRuleArgs;
import com.pulumi.alicloud.sae.SaeFunctions;
import com.pulumi.alicloud.sae.inputs.GetIngressesArgs;
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("example_value");
        final var default = AlicloudFunctions.getZones(GetZonesArgs.builder()
            .availableResourceCreation("VSwitch")
            .build());

        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()
            .name(name)
            .cidrBlock("172.16.0.0/12")
            .build());

        var defaultSwitch = new Switch("defaultSwitch", SwitchArgs.builder()
            .vpcId(defaultNetwork.id())
            .cidrBlock("172.16.0.0/21")
            .zoneId(default_.zones()[0].id())
            .vswitchName(name)
            .build());

        var defaultLoadBalancer = new LoadBalancer("defaultLoadBalancer", LoadBalancerArgs.builder()
            .name(name)
            .specification("slb.s2.small")
            .vswitchId(defaultAlicloudVswitches.ids()[0])
            .build());

        final var desc = config.get("desc").orElse("example_value");
        final var namespaceId = config.get("namespaceId").orElse("cn-hangzhou:yourname");
        var defaultNamespace = new Namespace("defaultNamespace", NamespaceArgs.builder()
            .namespaceId(namespaceId)
            .namespaceName(name)
            .namespaceDescription(desc)
            .build());

        var defaultApplication = new Application("defaultApplication", ApplicationArgs.builder()
            .appDescription("your_app_description")
            .appName("your_app_name")
            .namespaceId("your_namespace_id")
            .packageUrl("your_package_url")
            .packageType("your_package_url")
            .jdk("jdk_specifications")
            .vswitchId(defaultAlicloudVswitches.ids()[0])
            .replicas("your_replicas")
            .cpu("cpu_specifications")
            .memory("memory_specifications")
            .build());

        var defaultIngress = new Ingress("defaultIngress", IngressArgs.builder()
            .slbId(defaultLoadBalancer.id())
            .namespaceId(defaultNamespace.id())
            .listenerPort("your_listener_port")
            .rules(IngressRuleArgs.builder()
                .appId(defaultApplication.id())
                .containerPort("your_container_port")
                .domain("your_domain")
                .appName("your_name")
                .path("your_path")
                .build())
            .build());

        final var defaultGetIngresses = SaeFunctions.getIngresses(GetIngressesArgs.builder()
            .ids(defaultIngress.id())
            .build());

        ctx.export("saeIngressId", defaultGetIngresses.applyValue(_defaultGetIngresses -> _defaultGetIngresses.ingressList()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: example_value
  desc:
    type: string
    default: example_value
  namespaceId:
    type: string
    default: cn-hangzhou:yourname
resources:
  defaultNetwork:
    type: alicloud:vpc:Network
    name: default
    properties:
      name: ${name}
      cidrBlock: 172.16.0.0/12
  defaultSwitch:
    type: alicloud:vpc:Switch
    name: default
    properties:
      vpcId: ${defaultNetwork.id}
      cidrBlock: 172.16.0.0/21
      zoneId: ${default.zones[0].id}
      vswitchName: ${name}
  defaultLoadBalancer:
    type: alicloud:slb:LoadBalancer
    name: default
    properties:
      name: ${name}
      specification: slb.s2.small
      vswitchId: ${defaultAlicloudVswitches.ids[0]}
  defaultNamespace:
    type: alicloud:sae:Namespace
    name: default
    properties:
      namespaceId: ${namespaceId}
      namespaceName: ${name}
      namespaceDescription: ${desc}
  defaultApplication:
    type: alicloud:sae:Application
    name: default
    properties:
      appDescription: your_app_description
      appName: your_app_name
      namespaceId: your_namespace_id
      packageUrl: your_package_url
      packageType: your_package_url
      jdk: jdk_specifications
      vswitchId: ${defaultAlicloudVswitches.ids[0]}
      replicas: your_replicas
      cpu: cpu_specifications
      memory: memory_specifications
  defaultIngress:
    type: alicloud:sae:Ingress
    name: default
    properties:
      slbId: ${defaultLoadBalancer.id}
      namespaceId: ${defaultNamespace.id}
      listenerPort: your_listener_port
      rules:
        - appId: ${defaultApplication.id}
          containerPort: your_container_port
          domain: your_domain
          appName: your_name
          path: your_path
variables:
  default:
    fn::invoke:
      function: alicloud:getZones
      arguments:
        availableResourceCreation: VSwitch
  defaultGetIngresses:
    fn::invoke:
      function: alicloud:sae:getIngresses
      arguments:
        ids:
          - ${defaultIngress.id}
outputs:
  saeIngressId: ${defaultGetIngresses.ingressList[0].id}

function getIngresses(args: GetIngressesArgs, opts?: InvokeOptions): Promise<GetIngressesResult>
function getIngressesOutput(args: GetIngressesOutputArgs, opts?: InvokeOptions): Output<GetIngressesResult>

def get_ingresses(enable_details: Optional[bool] = None,
                  ids: Optional[Sequence[str]] = None,
                  namespace_id: Optional[str] = None,
                  output_file: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetIngressesResult
def get_ingresses_output(enable_details: Optional[pulumi.Input[bool]] = None,
                  ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  namespace_id: Optional[pulumi.Input[str]] = None,
                  output_file: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetIngressesResult]

func GetIngresses(ctx *Context, args *GetIngressesArgs, opts ...InvokeOption) (*GetIngressesResult, error)
func GetIngressesOutput(ctx *Context, args *GetIngressesOutputArgs, opts ...InvokeOption) GetIngressesResultOutput

public static class GetIngresses 
{
    public static Task<GetIngressesResult> InvokeAsync(GetIngressesArgs args, InvokeOptions? opts = null)
    public static Output<GetIngressesResult> Invoke(GetIngressesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetIngressesResult> getIngresses(GetIngressesArgs args, InvokeOptions options)
public static Output<GetIngressesResult> getIngresses(GetIngressesArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:sae/getIngresses:getIngresses
  arguments:
    # arguments dictionary