alicloud.sslcertificatesservicecertificate.Validation

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 _default = new alicloud.sslcertificatesserviceinstance.SslCertificatesServiceInstance("default", {
    productType: "cas",
    period: 12,
    pricingCycle: 2,
    instanceName: name,
    domain: "example.com",
    validationMethod: "DNS",
    parameters: [
        {
            code: "fullSpec",
            value: "ws.dv.f",
        },
        {
            code: "fullDomainCount",
            value: "1",
        },
    ],
});
const defaultApply = new alicloud.sslcertificatesservicecertificate.Apply("default", {
    instanceId: _default.id,
    domain: _default.domain,
    validationMethod: _default.validationMethod,
});
const defaultAlidnsRecord: {[key: string]: alicloud.dns.AlidnsRecord} = {};
defaultApply.domainValidationLists.apply(domainValidationLists => {
    const defaultAlidnsRecord: {[key: string]: alicloud.dns.AlidnsRecord} = {};
pulumi.all(domainValidationLists.reduce((__obj, v) => ({ ...__obj, [v.domain]: v }), {})).apply(rangeBody => {
        for (const range of Object.entries(rangeBody).sort().map(([k, v]) => ({key: k, value: v}))) {
            defaultAlidnsRecord[range.key] = new alicloud.dns.AlidnsRecord(`default-${range.key}`, {
                domainName: range.value.rootDomain,
                rr: range.value.validationKey,
                type: range.value.validationType,
                value: range.value.validationValue,
                ttl: 600,
            });
        }
    });
});
const defaultValidation = new alicloud.sslcertificatesservicecertificate.Validation("default", {
    instanceId: _default.id,
    validationRecordIds: defaultAlidnsRecord.apply(defaultAlidnsRecord => Object.values(defaultAlidnsRecord).map(r => (r.id))),
});

import pulumi
from typing import Any
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default = alicloud.sslcertificatesserviceinstance.SslCertificatesServiceInstance("default",
    product_type="cas",
    period=12,
    pricing_cycle=2,
    instance_name=name,
    domain="example.com",
    validation_method="DNS",
    parameters=[
        {
            "code": "fullSpec",
            "value": "ws.dv.f",
        },
        {
            "code": "fullDomainCount",
            "value": "1",
        },
    ])
default_apply = alicloud.sslcertificatesservicecertificate.Apply("default",
    instance_id=default.id,
    domain=default.domain,
    validation_method=default.validation_method)
default_alidns_record: dict[str, alicloud.dns.AlidnsRecord] = {}
def create_default(range_body):
    for default_alidns_record_range in [{"key": k, "value": v} for [k, v] in sorted((range_body).items())]:
        default_alidns_record[default_alidns_record_range['key']] = alicloud.dns.AlidnsRecord(f"default-{default_alidns_record_range['key']}",
            domain_name=default_alidns_record_range["value"].root_domain,
            rr=default_alidns_record_range["value"].validation_key,
            type=default_alidns_record_range["value"].validation_type,
            value=default_alidns_record_range["value"].validation_value,
            ttl=600)

default_apply.domain_validation_lists.apply(lambda resolved_outputs: create_default({v.domain: v for v in resolved_outputs['domain_validation_lists']}))
default_validation = alicloud.sslcertificatesservicecertificate.Validation("default",
    instance_id=default.id,
    validation_record_ids=default_alidns_record.apply(lambda default_alidns_record: [r.id for r in default_alidns_record.values()]))

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 @default = new AliCloud.SslCertificatesServiceInstance.SslCertificatesServiceInstance("default", new()
    {
        ProductType = "cas",
        Period = 12,
        PricingCycle = 2,
        InstanceName = name,
        Domain = "example.com",
        ValidationMethod = "DNS",
        Parameters = new[]
        {
            new AliCloud.sslCertificatesServiceInstance.Inputs.SslCertificatesServiceInstanceParameterArgs
            {
                Code = "fullSpec",
                Value = "ws.dv.f",
            },
            new AliCloud.sslCertificatesServiceInstance.Inputs.SslCertificatesServiceInstanceParameterArgs
            {
                Code = "fullDomainCount",
                Value = "1",
            },
        },
    });

    var defaultApply = new AliCloud.SslCertificatesServiceCertificate.Apply("default", new()
    {
        InstanceId = @default.Id,
        Domain = @default.Domain,
        ValidationMethod = @default.ValidationMethod,
    });

    var defaultAlidnsRecord = new List<AliCloud.Dns.AlidnsRecord>();
    domainValidationLists.Apply(rangeBody =>
    {
        foreach (var range in rangeBody.Select(pair => new { pair.Key, pair.Value }))
        {
            defaultAlidnsRecord.Add(new AliCloud.Dns.AlidnsRecord($"default-{range.Key}", new()
            {
                DomainName = range.Value.RootDomain,
                Rr = range.Value.ValidationKey,
                Type = range.Value.ValidationType,
                Value = range.Value.ValidationValue,
                Ttl = 600,
            }));
        }
        return 0;
    });
    var defaultValidation = new AliCloud.SslCertificatesServiceCertificate.Validation("default", new()
    {
        InstanceId = @default.Id,
        ValidationRecordIds = defaultAlidnsRecord.Apply(defaultAlidnsRecord => (defaultAlidnsRecord).Values.Select(r => 
        {
            return r.Id;
        }).ToList()),
    });

});

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

resource "alicloud_sslcertificatesserviceinstance_sslcertificatesserviceinstance" "default" {
  product_type      = "cas"
  period            = 12
  pricing_cycle     = 2
  instance_name     = var.name
  domain            = "example.com"
  validation_method = "DNS"
  parameters {
    code  = "fullSpec"
    value = "ws.dv.f"
  }
  parameters {
    code  = "fullDomainCount"
    value = "1"
  }
}
resource "alicloud_sslcertificatesservicecertificate_apply" "default" {
  instance_id       = alicloud_sslcertificatesserviceinstance_sslcertificatesserviceinstance.default.id
  domain            = alicloud_sslcertificatesserviceinstance_sslcertificatesserviceinstance.default.domain
  validation_method = alicloud_sslcertificatesserviceinstance_sslcertificatesserviceinstance.default.validation_method
}
resource "alicloud_dns_alidnsrecord" "default" {
  for_each    = {for v in alicloud_sslcertificatesservicecertificate_apply.default.domain_validation_lists : v.domain => v}
  domain_name = each.value.rootDomain
  rr          = each.value.validationKey
  type        = each.value.validationType
  value       = each.value.validationValue
  ttl         = 600
}
resource "alicloud_sslcertificatesservicecertificate_validation" "default" {
  instance_id           = alicloud_sslcertificatesserviceinstance_sslcertificatesserviceinstance.default.id
  validation_record_ids = [for r in alicloud_dns_alidnsrecord.default : r.id]
}
variable "name" {
  type    = string
  default = "terraform-example"
}

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

const _default = new alicloud.alb.Listener("default", {certificates: {
    certificateId: defaultAlicloudSslCertificatesServiceCertificateValidation.certIdentifier,
}});

import pulumi
import pulumi_alicloud as alicloud

default = alicloud.alb.Listener("default", certificates={
    "certificate_id": default_alicloud_ssl_certificates_service_certificate_validation["certIdentifier"],
})

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/alb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := alb.NewListener(ctx, "default", &alb.ListenerArgs{
			Certificates: &alb.ListenerCertificatesArgs{
				CertificateId: pulumi.Any(defaultAlicloudSslCertificatesServiceCertificateValidation.CertIdentifier),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @default = new AliCloud.Alb.Listener("default", new()
    {
        Certificates = new AliCloud.Alb.Inputs.ListenerCertificatesArgs
        {
            CertificateId = defaultAlicloudSslCertificatesServiceCertificateValidation.CertIdentifier,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.alb.Listener;
import com.pulumi.alicloud.alb.ListenerArgs;
import com.pulumi.alicloud.alb.inputs.ListenerCertificatesArgs;
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) {
        var default_ = new Listener("default", ListenerArgs.builder()
            .certificates(ListenerCertificatesArgs.builder()
                .certificateId(defaultAlicloudSslCertificatesServiceCertificateValidation.certIdentifier())
                .build())
            .build());

    }
}

resources:
  default:
    type: alicloud:alb:Listener
    properties:
      certificates:
        certificateId: ${defaultAlicloudSslCertificatesServiceCertificateValidation.certIdentifier}

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

resource "alicloud_alb_listener" "default" {
  certificates = {
    certificate_id = defaultAlicloudSslCertificatesServiceCertificateValidation.certIdentifier
  }
}

var validationResource = new AliCloud.SslCertificatesServiceCertificate.Validation("validationResource", new()
{
    InstanceId = "string",
    ValidationRecordIds = new[]
    {
        "string",
    },
});

example, err := sslcertificatesservicecertificate.NewValidation(ctx, "validationResource", &sslcertificatesservicecertificate.ValidationArgs{
	InstanceId: pulumi.String("string"),
	ValidationRecordIds: pulumi.StringArray{
		pulumi.String("string"),
	},
})

resource "alicloud_sslcertificatesservicecertificate_validation" "validationResource" {
  lifecycle {
    create_before_destroy = true
  }
  instance_id           = "string"
  validation_record_ids = ["string"]
}

var validationResource = new Validation("validationResource", ValidationArgs.builder()
    .instanceId("string")
    .validationRecordIds("string")
    .build());

validation_resource = alicloud.sslcertificatesservicecertificate.Validation("validationResource",
    instance_id="string",
    validation_record_ids=["string"])

const validationResource = new alicloud.sslcertificatesservicecertificate.Validation("validationResource", {
    instanceId: "string",
    validationRecordIds: ["string"],
});

type: alicloud:sslcertificatesservicecertificate:Validation
properties:
    instanceId: string
    validationRecordIds:
        - string