alicloud.apig.getServices

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const address = config.get("address") || "127.0.0.1:8080";
const address1 = config.get("address1") || "127.0.0.1:7891";
const address2 = config.get("address2") || "127.0.0.1:7890";
const defaultvpc = new alicloud.vpc.Network("defaultvpc", {
    cidrBlock: "172.32.0.0/12",
    vpcName: "zhenyuan-example",
});
const defaultvswitch = new alicloud.vpc.Switch("defaultvswitch", {
    vpcId: defaultvpc.id,
    zoneId: "cn-hangzhou-g",
    cidrBlock: "172.32.100.0/24",
    vswitchName: "zhenyuan-example",
});
const defaultFsRKYn = new alicloud.apig.Gateway("defaultFsRKYn", {
    networkAccessConfig: {
        type: "Intranet",
    },
    vswitch: {
        vswitchId: defaultvswitch.id,
        name: defaultvswitch.vswitchName,
    },
    zoneConfig: {
        selectOption: "Auto",
    },
    vpc: {
        vpcId: defaultvpc.id,
    },
    paymentType: "PayAsYouGo",
    gatewayName: "zhenyuanexample",
    spec: "apigw.small.x1",
    logConfig: {
        sls: {
            enable: false,
        },
    },
});
const defaultService = new alicloud.apig.Service("default", {
    addresses: [address],
    serviceName: "1784264568",
    sourceType: "VIP",
    gatewayId: defaultFsRKYn.id,
    namespace: "default",
});
const _default = alicloud.apig.getServicesOutput({
    ids: [defaultService.id],
    nameRegex: defaultService.serviceName,
    gatewayId: defaultFsRKYn.id,
    sourceType: "VIP",
});
export const alicloudApigServiceExampleId = _default.apply(_default => _default.services?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
address = config.get("address")
if address is None:
    address = "127.0.0.1:8080"
address1 = config.get("address1")
if address1 is None:
    address1 = "127.0.0.1:7891"
address2 = config.get("address2")
if address2 is None:
    address2 = "127.0.0.1:7890"
defaultvpc = alicloud.vpc.Network("defaultvpc",
    cidr_block="172.32.0.0/12",
    vpc_name="zhenyuan-example")
defaultvswitch = alicloud.vpc.Switch("defaultvswitch",
    vpc_id=defaultvpc.id,
    zone_id="cn-hangzhou-g",
    cidr_block="172.32.100.0/24",
    vswitch_name="zhenyuan-example")
default_fs_rk_yn = alicloud.apig.Gateway("defaultFsRKYn",
    network_access_config={
        "type": "Intranet",
    },
    vswitch={
        "vswitch_id": defaultvswitch.id,
        "name": defaultvswitch.vswitch_name,
    },
    zone_config={
        "select_option": "Auto",
    },
    vpc={
        "vpc_id": defaultvpc.id,
    },
    payment_type="PayAsYouGo",
    gateway_name="zhenyuanexample",
    spec="apigw.small.x1",
    log_config={
        "sls": {
            "enable": False,
        },
    })
default_service = alicloud.apig.Service("default",
    addresses=[address],
    service_name="1784264568",
    source_type="VIP",
    gateway_id=default_fs_rk_yn.id,
    namespace="default")
default = alicloud.apig.get_services_output(ids=[default_service.id],
    name_regex=default_service.service_name,
    gateway_id=default_fs_rk_yn.id,
    source_type="VIP")
pulumi.export("alicloudApigServiceExampleId", default.services[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/apig"
	"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
		}
		address := "127.0.0.1:8080"
		if param := cfg.Get("address"); param != "" {
			address = param
		}
		address1 := "127.0.0.1:7891"
		if param := cfg.Get("address1"); param != "" {
			address1 = param
		}
		address2 := "127.0.0.1:7890"
		if param := cfg.Get("address2"); param != "" {
			address2 = param
		}
		defaultvpc, err := vpc.NewNetwork(ctx, "defaultvpc", &vpc.NetworkArgs{
			CidrBlock: pulumi.String("172.32.0.0/12"),
			VpcName:   pulumi.String("zhenyuan-example"),
		})
		if err != nil {
			return err
		}
		defaultvswitch, err := vpc.NewSwitch(ctx, "defaultvswitch", &vpc.SwitchArgs{
			VpcId:       defaultvpc.ID().ToIDOutput().ToStringOutput(),
			ZoneId:      pulumi.String("cn-hangzhou-g"),
			CidrBlock:   pulumi.String("172.32.100.0/24"),
			VswitchName: pulumi.String("zhenyuan-example"),
		})
		if err != nil {
			return err
		}
		defaultFsRKYn, err := apig.NewGateway(ctx, "defaultFsRKYn", &apig.GatewayArgs{
			NetworkAccessConfig: &apig.GatewayNetworkAccessConfigArgs{
				Type: pulumi.String("Intranet"),
			},
			Vswitch: &apig.GatewayVswitchArgs{
				VswitchId: defaultvswitch.ID().ToIDOutput().ToStringOutput(),
				Name:      defaultvswitch.VswitchName,
			},
			ZoneConfig: &apig.GatewayZoneConfigArgs{
				SelectOption: pulumi.String("Auto"),
			},
			Vpc: &apig.GatewayVpcArgs{
				VpcId: defaultvpc.ID().ToIDOutput().ToStringOutput(),
			},
			PaymentType: pulumi.String("PayAsYouGo"),
			GatewayName: pulumi.String("zhenyuanexample"),
			Spec:        pulumi.String("apigw.small.x1"),
			LogConfig: &apig.GatewayLogConfigArgs{
				Sls: &apig.GatewayLogConfigSlsArgs{
					Enable: pulumi.Bool(false),
				},
			},
		})
		if err != nil {
			return err
		}
		defaultService, err := apig.NewService(ctx, "default", &apig.ServiceArgs{
			Addresses: pulumi.StringArray{
				pulumi.String(address),
			},
			ServiceName: pulumi.String("1784264568"),
			SourceType:  pulumi.String("VIP"),
			GatewayId:   defaultFsRKYn.ID().ToIDOutput().ToStringOutput(),
			Namespace:   pulumi.String("default"),
		})
		if err != nil {
			return err
		}
		_default := apig.GetServicesOutput(ctx, apig.GetServicesOutputArgs{
			Ids: pulumi.StringArray{
				defaultService.ID().ToIDOutput().ToStringOutput(),
			},
			NameRegex:  defaultService.ServiceName,
			GatewayId:  defaultFsRKYn.ID().ToIDOutput().ToStringOutput(),
			SourceType: pulumi.String("VIP"),
		}, nil)
		ctx.Export("alicloudApigServiceExampleId", _default.ApplyT(func(_default apig.GetServicesResult) (*string, error) {
			return _default.Services[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 address = config.Get("address") ?? "127.0.0.1:8080";
    var address1 = config.Get("address1") ?? "127.0.0.1:7891";
    var address2 = config.Get("address2") ?? "127.0.0.1:7890";
    var defaultvpc = new AliCloud.Vpc.Network("defaultvpc", new()
    {
        CidrBlock = "172.32.0.0/12",
        VpcName = "zhenyuan-example",
    });

    var defaultvswitch = new AliCloud.Vpc.Switch("defaultvswitch", new()
    {
        VpcId = defaultvpc.Id,
        ZoneId = "cn-hangzhou-g",
        CidrBlock = "172.32.100.0/24",
        VswitchName = "zhenyuan-example",
    });

    var defaultFsRKYn = new AliCloud.Apig.Gateway("defaultFsRKYn", new()
    {
        NetworkAccessConfig = new AliCloud.Apig.Inputs.GatewayNetworkAccessConfigArgs
        {
            Type = "Intranet",
        },
        Vswitch = new AliCloud.Apig.Inputs.GatewayVswitchArgs
        {
            VswitchId = defaultvswitch.Id,
            Name = defaultvswitch.VswitchName,
        },
        ZoneConfig = new AliCloud.Apig.Inputs.GatewayZoneConfigArgs
        {
            SelectOption = "Auto",
        },
        Vpc = new AliCloud.Apig.Inputs.GatewayVpcArgs
        {
            VpcId = defaultvpc.Id,
        },
        PaymentType = "PayAsYouGo",
        GatewayName = "zhenyuanexample",
        Spec = "apigw.small.x1",
        LogConfig = new AliCloud.Apig.Inputs.GatewayLogConfigArgs
        {
            Sls = new AliCloud.Apig.Inputs.GatewayLogConfigSlsArgs
            {
                Enable = false,
            },
        },
    });

    var defaultService = new AliCloud.Apig.Service("default", new()
    {
        Addresses = new[]
        {
            address,
        },
        ServiceName = "1784264568",
        SourceType = "VIP",
        GatewayId = defaultFsRKYn.Id,
        Namespace = "default",
    });

    var @default = AliCloud.Apig.GetServices.Invoke(new()
    {
        Ids = new[]
        {
            defaultService.Id,
        },
        NameRegex = defaultService.ServiceName,
        GatewayId = defaultFsRKYn.Id,
        SourceType = "VIP",
    });

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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.apig.Gateway;
import com.pulumi.alicloud.apig.GatewayArgs;
import com.pulumi.alicloud.apig.inputs.GatewayNetworkAccessConfigArgs;
import com.pulumi.alicloud.apig.inputs.GatewayVswitchArgs;
import com.pulumi.alicloud.apig.inputs.GatewayZoneConfigArgs;
import com.pulumi.alicloud.apig.inputs.GatewayVpcArgs;
import com.pulumi.alicloud.apig.inputs.GatewayLogConfigArgs;
import com.pulumi.alicloud.apig.inputs.GatewayLogConfigSlsArgs;
import com.pulumi.alicloud.apig.Service;
import com.pulumi.alicloud.apig.ServiceArgs;
import com.pulumi.alicloud.apig.ApigFunctions;
import com.pulumi.alicloud.apig.inputs.GetServicesArgs;
import java.util.ArrayList;
import java.util.Arrays;
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");
        final var address = config.get("address").orElse("127.0.0.1:8080");
        final var address1 = config.get("address1").orElse("127.0.0.1:7891");
        final var address2 = config.get("address2").orElse("127.0.0.1:7890");
        var defaultvpc = new Network("defaultvpc", NetworkArgs.builder()
            .cidrBlock("172.32.0.0/12")
            .vpcName("zhenyuan-example")
            .build());

        var defaultvswitch = new Switch("defaultvswitch", SwitchArgs.builder()
            .vpcId(defaultvpc.id())
            .zoneId("cn-hangzhou-g")
            .cidrBlock("172.32.100.0/24")
            .vswitchName("zhenyuan-example")
            .build());

        var defaultFsRKYn = new Gateway("defaultFsRKYn", GatewayArgs.builder()
            .networkAccessConfig(GatewayNetworkAccessConfigArgs.builder()
                .type("Intranet")
                .build())
            .vswitch(GatewayVswitchArgs.builder()
                .vswitchId(defaultvswitch.id())
                .name(defaultvswitch.vswitchName())
                .build())
            .zoneConfig(GatewayZoneConfigArgs.builder()
                .selectOption("Auto")
                .build())
            .vpc(GatewayVpcArgs.builder()
                .vpcId(defaultvpc.id())
                .build())
            .paymentType("PayAsYouGo")
            .gatewayName("zhenyuanexample")
            .spec("apigw.small.x1")
            .logConfig(GatewayLogConfigArgs.builder()
                .sls(GatewayLogConfigSlsArgs.builder()
                    .enable(false)
                    .build())
                .build())
            .build());

        var defaultService = new Service("defaultService", ServiceArgs.builder()
            .addresses(address)
            .serviceName("1784264568")
            .sourceType("VIP")
            .gatewayId(defaultFsRKYn.id())
            .namespace("default")
            .build());

        final var default = ApigFunctions.getServices(GetServicesArgs.builder()
            .ids(defaultService.id())
            .nameRegex(defaultService.serviceName())
            .gatewayId(defaultFsRKYn.id())
            .sourceType("VIP")
            .build());

        ctx.export("alicloudApigServiceExampleId", default_.applyValue(_default_ -> _default_.services()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
  address:
    type: string
    default: 127.0.0.1:8080
  address1:
    type: string
    default: 127.0.0.1:7891
  address2:
    type: string
    default: 127.0.0.1:7890
resources:
  defaultvpc:
    type: alicloud:vpc:Network
    properties:
      cidrBlock: 172.32.0.0/12
      vpcName: zhenyuan-example
  defaultvswitch:
    type: alicloud:vpc:Switch
    properties:
      vpcId: ${defaultvpc.id}
      zoneId: cn-hangzhou-g
      cidrBlock: 172.32.100.0/24
      vswitchName: zhenyuan-example
  defaultFsRKYn:
    type: alicloud:apig:Gateway
    properties:
      networkAccessConfig:
        type: Intranet
      vswitch:
        vswitchId: ${defaultvswitch.id}
        name: ${defaultvswitch.vswitchName}
      zoneConfig:
        selectOption: Auto
      vpc:
        vpcId: ${defaultvpc.id}
      paymentType: PayAsYouGo
      gatewayName: zhenyuanexample
      spec: apigw.small.x1
      logConfig:
        sls:
          enable: false
  defaultService:
    type: alicloud:apig:Service
    name: default
    properties:
      addresses:
        - ${address}
      serviceName: '1784264568'
      sourceType: VIP
      gatewayId: ${defaultFsRKYn.id}
      namespace: default
variables:
  default:
    fn::invoke:
      function: alicloud:apig:getServices
      arguments:
        ids:
          - ${defaultService.id}
        nameRegex: ${defaultService.serviceName}
        gatewayId: ${defaultFsRKYn.id}
        sourceType: VIP
outputs:
  alicloudApigServiceExampleId: ${default.services[0].id}

pulumi {
  required_providers {
    alicloud = {
      source = "pulumi/alicloud"
    }
  }
}

data "alicloud_apig_getservices" "default" {
  ids         = [alicloud_apig_service.default.id]
  name_regex  = alicloud_apig_service.default.service_name
  gateway_id  = alicloud_apig_gateway.defaultFsRKYn.id
  source_type = "VIP"
}

resource "alicloud_vpc_network" "defaultvpc" {
  cidr_block = "172.32.0.0/12"
  vpc_name   = "zhenyuan-example"
}
resource "alicloud_vpc_switch" "defaultvswitch" {
  vpc_id       = alicloud_vpc_network.defaultvpc.id
  zone_id      = "cn-hangzhou-g"
  cidr_block   = "172.32.100.0/24"
  vswitch_name = "zhenyuan-example"
}
resource "alicloud_apig_gateway" "defaultFsRKYn" {
  network_access_config = {
    type = "Intranet"
  }
  vswitch = {
    vswitch_id = alicloud_vpc_switch.defaultvswitch.id
    name       = alicloud_vpc_switch.defaultvswitch.vswitch_name
  }
  zone_config = {
    select_option = "Auto"
  }
  vpc = {
    vpc_id = alicloud_vpc_network.defaultvpc.id
  }
  payment_type = "PayAsYouGo"
  gateway_name = "zhenyuanexample"
  spec         = "apigw.small.x1"
  log_config = {
    sls = {
      enable = false
    }
  }
}
resource "alicloud_apig_service" "default" {
  addresses    = [var.address]
  service_name = "1784264568"
  source_type  = "VIP"
  gateway_id   = alicloud_apig_gateway.defaultFsRKYn.id
  namespace    = "default"
}
variable "name" {
  type    = string
  default = "terraform-example"
}
variable "address" {
  type    = string
  default = "127.0.0.1:8080"
}
variable "address1" {
  type    = string
  default = "127.0.0.1:7891"
}
variable "address2" {
  type    = string
  default = "127.0.0.1:7890"
}
output "alicloudApigServiceExampleId" {
  value = data.alicloud_apig_getservices.default.services[0].id
}

function getServices(args: GetServicesArgs, opts?: InvokeOptions): Promise<GetServicesResult>
function getServicesOutput(args: GetServicesOutputArgs, opts?: InvokeOutputOptions): Output<GetServicesResult>

def get_services(gateway_id: Optional[str] = None,
                 ids: Optional[Sequence[str]] = None,
                 name_regex: Optional[str] = None,
                 output_file: Optional[str] = None,
                 resource_group_id: Optional[str] = None,
                 source_type: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetServicesResult
def get_services_output(gateway_id: pulumi.Input[Optional[str]] = None,
                 ids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                 name_regex: pulumi.Input[Optional[str]] = None,
                 output_file: pulumi.Input[Optional[str]] = None,
                 resource_group_id: pulumi.Input[Optional[str]] = None,
                 source_type: pulumi.Input[Optional[str]] = None,
                 opts: Optional[InvokeOutputOptions] = None) -> Output[GetServicesResult]

func GetServices(ctx *Context, args *GetServicesArgs, opts ...InvokeOption) (*GetServicesResult, error)
func GetServicesOutput(ctx *Context, args *GetServicesOutputArgs, opts ...InvokeOption) GetServicesResultOutput

public static class GetServices 
{
    public static Task<GetServicesResult> InvokeAsync(GetServicesArgs args, InvokeOptions? opts = null)
    public static Output<GetServicesResult> Invoke(GetServicesInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetServicesResult> Invoke(GetServicesInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetServicesResult> getServices(GetServicesArgs args, InvokeOptions options)
public static Output<GetServicesResult> getServices(GetServicesArgs args, InvokeOptions options)
public static Output<GetServicesResult> getServices(GetServicesArgs args, InvokeOutputOptions options)

fn::invoke:
  function: alicloud:apig/getServices:getServices
  arguments:
    # arguments dictionary

data "alicloud_apig_get_services" "name" {
    # arguments
}