alicloud.sslcertificatesservice.Instances

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 defaultSslCertificatesServiceInstance = new alicloud.sslcertificatesserviceinstance.SslCertificatesServiceInstance("default", {
    productType: "cas",
    period: 12,
    pricingCycle: 2,
    instanceName: name,
    parameters: [
        {
            code: "fullSpec",
            value: "ws.dv.f",
        },
        {
            code: "fullDomainCount",
            value: "1",
        },
    ],
});
const _default = alicloud.sslcertificatesservice.InstancesOutput({
    ids: [defaultSslCertificatesServiceInstance.id],
});
export const alicloudSslCertificatesServiceInstanceExampleId = _default.apply(_default => _default.instances?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default_ssl_certificates_service_instance = alicloud.sslcertificatesserviceinstance.SslCertificatesServiceInstance("default",
    product_type="cas",
    period=12,
    pricing_cycle=2,
    instance_name=name,
    parameters=[
        {
            "code": "fullSpec",
            "value": "ws.dv.f",
        },
        {
            "code": "fullDomainCount",
            "value": "1",
        },
    ])
default = alicloud.sslcertificatesservice.instances_output(ids=[default_ssl_certificates_service_instance.id])
pulumi.export("alicloudSslCertificatesServiceInstanceExampleId", default.instances[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/sslcertificatesservice"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/sslcertificatesserviceinstance"
	"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
		}
		defaultSslCertificatesServiceInstance, err := sslcertificatesserviceinstance.NewSslCertificatesServiceInstance(ctx, "default", &sslcertificatesserviceinstance.SslCertificatesServiceInstanceArgs{
			ProductType:  pulumi.String("cas"),
			Period:       pulumi.Int(12),
			PricingCycle: pulumi.Int(2),
			InstanceName: pulumi.String(name),
			Parameters: sslcertificatesserviceinstance.SslCertificatesServiceInstanceParameterArray{
				&sslcertificatesserviceinstance.SslCertificatesServiceInstanceParameterArgs{
					Code:  pulumi.String("fullSpec"),
					Value: pulumi.String("ws.dv.f"),
				},
				&sslcertificatesserviceinstance.SslCertificatesServiceInstanceParameterArgs{
					Code:  pulumi.String("fullDomainCount"),
					Value: pulumi.String("1"),
				},
			},
		})
		if err != nil {
			return err
		}
		_default := sslcertificatesservice.InstancesOutput(ctx, sslcertificatesservice.InstancesOutputArgs{
			Ids: pulumi.StringArray{
				defaultSslCertificatesServiceInstance.ID().ToIDOutput().ToStringOutput(),
			},
		}, nil)
		ctx.Export("alicloudSslCertificatesServiceInstanceExampleId", _default.ApplyT(func(_default sslcertificatesservice.InstancesResult) (*string, error) {
			return _default.Instances[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 defaultSslCertificatesServiceInstance = new AliCloud.SslCertificatesServiceInstance.SslCertificatesServiceInstance("default", new()
    {
        ProductType = "cas",
        Period = 12,
        PricingCycle = 2,
        InstanceName = name,
        Parameters = new[]
        {
            new AliCloud.sslCertificatesServiceInstance.Inputs.SslCertificatesServiceInstanceParameterArgs
            {
                Code = "fullSpec",
                Value = "ws.dv.f",
            },
            new AliCloud.sslCertificatesServiceInstance.Inputs.SslCertificatesServiceInstanceParameterArgs
            {
                Code = "fullDomainCount",
                Value = "1",
            },
        },
    });

    var @default = AliCloud.SslCertificatesService.Instances.Invoke(new()
    {
        Ids = new[]
        {
            defaultSslCertificatesServiceInstance.Id,
        },
    });

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

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.sslcertificatesserviceinstance.SslCertificatesServiceInstance;
import com.pulumi.alicloud.sslcertificatesserviceinstance.SslCertificatesServiceInstanceArgs;
import com.pulumi.alicloud.sslcertificatesserviceinstance.inputs.SslCertificatesServiceInstanceParameterArgs;
import com.pulumi.alicloud.sslcertificatesservice.SslcertificatesserviceFunctions;
import com.pulumi.alicloud.sslcertificatesservice.inputs.InstancesArgs;
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");
        var defaultSslCertificatesServiceInstance = new SslCertificatesServiceInstance("defaultSslCertificatesServiceInstance", SslCertificatesServiceInstanceArgs.builder()
            .productType("cas")
            .period(12)
            .pricingCycle(2)
            .instanceName(name)
            .parameters(            
                SslCertificatesServiceInstanceParameterArgs.builder()
                    .code("fullSpec")
                    .value("ws.dv.f")
                    .build(),
                SslCertificatesServiceInstanceParameterArgs.builder()
                    .code("fullDomainCount")
                    .value("1")
                    .build())
            .build());

        final var default = SslcertificatesserviceFunctions.Instances(InstancesArgs.builder()
            .ids(defaultSslCertificatesServiceInstance.id())
            .build());

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

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultSslCertificatesServiceInstance:
    type: alicloud:sslcertificatesserviceinstance:SslCertificatesServiceInstance
    name: default
    properties:
      productType: cas
      period: 12
      pricingCycle: 2
      instanceName: ${name}
      parameters:
        - code: fullSpec
          value: ws.dv.f
        - code: fullDomainCount
          value: '1'
variables:
  default:
    fn::invoke:
      function: alicloud:sslcertificatesservice:Instances
      arguments:
        ids:
          - ${defaultSslCertificatesServiceInstance.id}
outputs:
  alicloudSslCertificatesServiceInstanceExampleId: ${default.instances[0].id}

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

data "alicloud_sslcertificatesservice_instances" "default" {
  ids = [alicloud_sslcertificatesserviceinstance_sslcertificatesserviceinstance.default.id]
}

resource "alicloud_sslcertificatesserviceinstance_sslcertificatesserviceinstance" "default" {
  product_type  = "cas"
  period        = 12
  pricing_cycle = 2
  instance_name = var.name
  parameters {
    code  = "fullSpec"
    value = "ws.dv.f"
  }
  parameters {
    code  = "fullDomainCount"
    value = "1"
  }
}
variable "name" {
  type    = string
  default = "terraform-example"
}
output "alicloudSslCertificatesServiceInstanceExampleId" {
  value = data.alicloud_sslcertificatesservice_instances.default.instances[0].id
}

function instances(args: InstancesArgs, opts?: InvokeOptions): Promise<InstancesResult>
function instancesOutput(args: InstancesOutputArgs, opts?: InvokeOutputOptions): Output<InstancesResult>

def instances(brand: Optional[str] = None,
              certificate_status: Optional[str] = None,
              certificate_type: Optional[str] = None,
              enable_details: Optional[bool] = None,
              ids: Optional[Sequence[str]] = None,
              instance_type: Optional[str] = None,
              keyword: Optional[str] = None,
              output_file: Optional[str] = None,
              resource_group_id: Optional[str] = None,
              status: Optional[str] = None,
              opts: Optional[InvokeOptions] = None) -> InstancesResult
def instances_output(brand: pulumi.Input[Optional[str]] = None,
              certificate_status: pulumi.Input[Optional[str]] = None,
              certificate_type: pulumi.Input[Optional[str]] = None,
              enable_details: pulumi.Input[Optional[bool]] = None,
              ids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
              instance_type: pulumi.Input[Optional[str]] = None,
              keyword: pulumi.Input[Optional[str]] = None,
              output_file: pulumi.Input[Optional[str]] = None,
              resource_group_id: pulumi.Input[Optional[str]] = None,
              status: pulumi.Input[Optional[str]] = None,
              opts: Optional[InvokeOutputOptions] = None) -> Output[InstancesResult]

func Instances(ctx *Context, args *InstancesArgs, opts ...InvokeOption) (*InstancesResult, error)
func InstancesOutput(ctx *Context, args *InstancesOutputArgs, opts ...InvokeOption) InstancesResultOutput

public static class Instances 
{
    public static Task<InstancesResult> InvokeAsync(InstancesArgs args, InvokeOptions? opts = null)
    public static Output<InstancesResult> Invoke(InstancesInvokeArgs args, InvokeOptions? opts = null)
    public static Output<InstancesResult> Invoke(InstancesInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<InstancesResult> instances(InstancesArgs args, InvokeOptions options)
public static Output<InstancesResult> instances(InstancesArgs args, InvokeOptions options)
public static Output<InstancesResult> instances(InstancesArgs args, InvokeOutputOptions options)

fn::invoke:
  function: alicloud:sslcertificatesservice:Instances
  arguments:
    # arguments dictionary

data "alicloud_sslcertificatesservice_instances" "name" {
    # arguments
}