Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi IDP Pulumi Cloud Packages Tutorials
  1. Packages
  2. Edgecenter Provider
  3. API Docs
  4. ProtectionResourceAliasCertificate
edgecenter 0.9.4 published on Thursday, Aug 14, 2025 by edge-center
edge-center/terraform-provider-edgecenter

edgecenter.ProtectionResourceAliasCertificate

Explore with Pulumi AI

edgecenter logo
edgecenter 0.9.4 published on Thursday, Aug 14, 2025 by edge-center
edge-center/terraform-provider-edgecenter

    Allows to manage certificates for aliases for DDoS protection resource.

    Example Usage

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

const config = new pulumi.Config();
const cert = config.require("cert");
const privateKey = config.require("privateKey");
const protected1ExampleCom = new edgecenter.ProtectionResource("protected1ExampleCom", {tls: [
    "1.2",
    "1.3",
]});
const subdomain1 = new edgecenter.ProtectionResourceAlias("subdomain1", {resource: protected1ExampleCom.protectionResourceId});
const protectionCertCustom = new edgecenter.ProtectionResourceAliasCertificate("protectionCertCustom", {
    alias: subdomain1.protectionResourceAliasId,
    sslType: "custom",
    sslCrt: cert,
    sslKey: privateKey,
});
//
// Set LE certificate
//
const protected2ExampleCom = new edgecenter.ProtectionResource("protected2ExampleCom", {tls: [
    "1.2",
    "1.3",
]});
const subdomain2 = new edgecenter.ProtectionResourceAlias("subdomain2", {resource: protected2ExampleCom.protectionResourceId});
//
// Issuing LE certificate requires DNS record
//
const examplezone = new edgecenter.DnsZone("examplezone", {});
const protectedResourceRecord = new edgecenter.DnsZoneRecord("protectedResourceRecord", {
    zone: examplezone.name,
    domain: subdomain2.name,
    type: "A",
    ttl: 100,
    resourceRecords: [{
        content: protected2ExampleCom.ip,
    }],
});
const protectionCertLe = new edgecenter.ProtectionResourceAliasCertificate("protectionCertLe", {
    alias: edgecenter_protection_resource_alias.subdomain.id,
    sslType: "le",
}, {
    dependsOn: [protectedResourceRecord],
});

    import pulumi
import pulumi_edgecenter as edgecenter

config = pulumi.Config()
cert = config.require("cert")
private_key = config.require("privateKey")
protected1_example_com = edgecenter.ProtectionResource("protected1ExampleCom", tls=[
    "1.2",
    "1.3",
])
subdomain1 = edgecenter.ProtectionResourceAlias("subdomain1", resource=protected1_example_com.protection_resource_id)
protection_cert_custom = edgecenter.ProtectionResourceAliasCertificate("protectionCertCustom",
    alias=subdomain1.protection_resource_alias_id,
    ssl_type="custom",
    ssl_crt=cert,
    ssl_key=private_key)
#
# Set LE certificate
#
protected2_example_com = edgecenter.ProtectionResource("protected2ExampleCom", tls=[
    "1.2",
    "1.3",
])
subdomain2 = edgecenter.ProtectionResourceAlias("subdomain2", resource=protected2_example_com.protection_resource_id)
#
# Issuing LE certificate requires DNS record
#
examplezone = edgecenter.DnsZone("examplezone")
protected_resource_record = edgecenter.DnsZoneRecord("protectedResourceRecord",
    zone=examplezone.name,
    domain=subdomain2.name,
    type="A",
    ttl=100,
    resource_records=[{
        "content": protected2_example_com.ip,
    }])
protection_cert_le = edgecenter.ProtectionResourceAliasCertificate("protectionCertLe",
    alias=edgecenter_protection_resource_alias["subdomain"]["id"],
    ssl_type="le",
    opts = pulumi.ResourceOptions(depends_on=[protected_resource_record]))

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/edgecenter/edgecenter"
	"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, "")
		cert := cfg.Require("cert")
		privateKey := cfg.Require("privateKey")
		protected1ExampleCom, err := edgecenter.NewProtectionResource(ctx, "protected1ExampleCom", &edgecenter.ProtectionResourceArgs{
			Tls: pulumi.StringArray{
				pulumi.String("1.2"),
				pulumi.String("1.3"),
			},
		})
		if err != nil {
			return err
		}
		subdomain1, err := edgecenter.NewProtectionResourceAlias(ctx, "subdomain1", &edgecenter.ProtectionResourceAliasArgs{
			Resource: protected1ExampleCom.ProtectionResourceId,
		})
		if err != nil {
			return err
		}
		_, err = edgecenter.NewProtectionResourceAliasCertificate(ctx, "protectionCertCustom", &edgecenter.ProtectionResourceAliasCertificateArgs{
			Alias:   subdomain1.ProtectionResourceAliasId,
			SslType: pulumi.String("custom"),
			SslCrt:  pulumi.String(cert),
			SslKey:  pulumi.String(privateKey),
		})
		if err != nil {
			return err
		}
		protected2ExampleCom, err := edgecenter.NewProtectionResource(ctx, "protected2ExampleCom", &edgecenter.ProtectionResourceArgs{
			Tls: pulumi.StringArray{
				pulumi.String("1.2"),
				pulumi.String("1.3"),
			},
		})
		if err != nil {
			return err
		}
		subdomain2, err := edgecenter.NewProtectionResourceAlias(ctx, "subdomain2", &edgecenter.ProtectionResourceAliasArgs{
			Resource: protected2ExampleCom.ProtectionResourceId,
		})
		if err != nil {
			return err
		}
		// Issuing LE certificate requires DNS record
		examplezone, err := edgecenter.NewDnsZone(ctx, "examplezone", nil)
		if err != nil {
			return err
		}
		protectedResourceRecord, err := edgecenter.NewDnsZoneRecord(ctx, "protectedResourceRecord", &edgecenter.DnsZoneRecordArgs{
			Zone:   examplezone.Name,
			Domain: subdomain2.Name,
			Type:   pulumi.String("A"),
			Ttl:    pulumi.Float64(100),
			ResourceRecords: edgecenter.DnsZoneRecordResourceRecordArray{
				&edgecenter.DnsZoneRecordResourceRecordArgs{
					Content: protected2ExampleCom.Ip,
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = edgecenter.NewProtectionResourceAliasCertificate(ctx, "protectionCertLe", &edgecenter.ProtectionResourceAliasCertificateArgs{
			Alias:   pulumi.Any(edgecenter_protection_resource_alias.Subdomain.Id),
			SslType: pulumi.String("le"),
		}, pulumi.DependsOn([]pulumi.Resource{
			protectedResourceRecord,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var cert = config.Require("cert");
    var privateKey = config.Require("privateKey");
    var protected1ExampleCom = new Edgecenter.ProtectionResource("protected1ExampleCom", new()
    {
        Tls = new[]
        {
            "1.2",
            "1.3",
        },
    });

    var subdomain1 = new Edgecenter.ProtectionResourceAlias("subdomain1", new()
    {
        Resource = protected1ExampleCom.ProtectionResourceId,
    });

    var protectionCertCustom = new Edgecenter.ProtectionResourceAliasCertificate("protectionCertCustom", new()
    {
        Alias = subdomain1.ProtectionResourceAliasId,
        SslType = "custom",
        SslCrt = cert,
        SslKey = privateKey,
    });

    //
    // Set LE certificate
    //
    var protected2ExampleCom = new Edgecenter.ProtectionResource("protected2ExampleCom", new()
    {
        Tls = new[]
        {
            "1.2",
            "1.3",
        },
    });

    var subdomain2 = new Edgecenter.ProtectionResourceAlias("subdomain2", new()
    {
        Resource = protected2ExampleCom.ProtectionResourceId,
    });

    //
    // Issuing LE certificate requires DNS record
    //
    var examplezone = new Edgecenter.DnsZone("examplezone");

    var protectedResourceRecord = new Edgecenter.DnsZoneRecord("protectedResourceRecord", new()
    {
        Zone = examplezone.Name,
        Domain = subdomain2.Name,
        Type = "A",
        Ttl = 100,
        ResourceRecords = new[]
        {
            new Edgecenter.Inputs.DnsZoneRecordResourceRecordArgs
            {
                Content = protected2ExampleCom.Ip,
            },
        },
    });

    var protectionCertLe = new Edgecenter.ProtectionResourceAliasCertificate("protectionCertLe", new()
    {
        Alias = edgecenter_protection_resource_alias.Subdomain.Id,
        SslType = "le",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            protectedResourceRecord,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.edgecenter.ProtectionResource;
import com.pulumi.edgecenter.ProtectionResourceArgs;
import com.pulumi.edgecenter.ProtectionResourceAlias;
import com.pulumi.edgecenter.ProtectionResourceAliasArgs;
import com.pulumi.edgecenter.ProtectionResourceAliasCertificate;
import com.pulumi.edgecenter.ProtectionResourceAliasCertificateArgs;
import com.pulumi.edgecenter.DnsZone;
import com.pulumi.edgecenter.DnsZoneRecord;
import com.pulumi.edgecenter.DnsZoneRecordArgs;
import com.pulumi.edgecenter.inputs.DnsZoneRecordResourceRecordArgs;
import com.pulumi.resources.CustomResourceOptions;
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 cert = config.get("cert");
        final var privateKey = config.get("privateKey");
        var protected1ExampleCom = new ProtectionResource("protected1ExampleCom", ProtectionResourceArgs.builder()
            .tls(            
                "1.2",
                "1.3")
            .build());

        var subdomain1 = new ProtectionResourceAlias("subdomain1", ProtectionResourceAliasArgs.builder()
            .resource(protected1ExampleCom.protectionResourceId())
            .build());

        var protectionCertCustom = new ProtectionResourceAliasCertificate("protectionCertCustom", ProtectionResourceAliasCertificateArgs.builder()
            .alias(subdomain1.protectionResourceAliasId())
            .sslType("custom")
            .sslCrt(cert)
            .sslKey(privateKey)
            .build());

        //
        // Set LE certificate
        //
        var protected2ExampleCom = new ProtectionResource("protected2ExampleCom", ProtectionResourceArgs.builder()
            .tls(            
                "1.2",
                "1.3")
            .build());

        var subdomain2 = new ProtectionResourceAlias("subdomain2", ProtectionResourceAliasArgs.builder()
            .resource(protected2ExampleCom.protectionResourceId())
            .build());

        //
        // Issuing LE certificate requires DNS record
        //
        var examplezone = new DnsZone("examplezone");

        var protectedResourceRecord = new DnsZoneRecord("protectedResourceRecord", DnsZoneRecordArgs.builder()
            .zone(examplezone.name())
            .domain(subdomain2.name())
            .type("A")
            .ttl(100)
            .resourceRecords(DnsZoneRecordResourceRecordArgs.builder()
                .content(protected2ExampleCom.ip())
                .build())
            .build());

        var protectionCertLe = new ProtectionResourceAliasCertificate("protectionCertLe", ProtectionResourceAliasCertificateArgs.builder()
            .alias(edgecenter_protection_resource_alias.subdomain().id())
            .sslType("le")
            .build(), CustomResourceOptions.builder()
                .dependsOn(protectedResourceRecord)
                .build());

    }
}

    configuration:
  cert:
    type: string
  privateKey:
    type: string
resources:
  protected1ExampleCom:
    type: edgecenter:ProtectionResource
    properties:
      tls:
        - '1.2'
        - '1.3'
  subdomain1:
    type: edgecenter:ProtectionResourceAlias
    properties:
      resource: ${protected1ExampleCom.protectionResourceId}
  protectionCertCustom: #
  # Set LE certificate
  #
    type: edgecenter:ProtectionResourceAliasCertificate
    properties:
      alias: ${subdomain1.protectionResourceAliasId}
      sslType: custom
      sslCrt: ${cert}
      sslKey: ${privateKey}
  protected2ExampleCom:
    type: edgecenter:ProtectionResource
    properties:
      tls:
        - '1.2'
        - '1.3'
  subdomain2:
    type: edgecenter:ProtectionResourceAlias
    properties:
      resource: ${protected2ExampleCom.protectionResourceId}
  protectionCertLe:
    type: edgecenter:ProtectionResourceAliasCertificate
    properties:
      alias: ${edgecenter_protection_resource_alias.subdomain.id}
      sslType: le
    options:
      dependsOn:
        - ${protectedResourceRecord}
  #
  # Issuing LE certificate requires DNS record
  #
  examplezone:
    type: edgecenter:DnsZone
  protectedResourceRecord:
    type: edgecenter:DnsZoneRecord
    properties:
      zone: ${examplezone.name}
      domain: ${subdomain2.name}
      type: A
      ttl: 100
      resourceRecords:
        - content: ${protected2ExampleCom.ip}

    Create ProtectionResourceAliasCertificate Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new ProtectionResourceAliasCertificate(name: string, args: ProtectionResourceAliasCertificateArgs, opts?: CustomResourceOptions);
    @overload
def ProtectionResourceAliasCertificate(resource_name: str,
                                       args: ProtectionResourceAliasCertificateArgs,
                                       opts: Optional[ResourceOptions] = None)

@overload
def ProtectionResourceAliasCertificate(resource_name: str,
                                       opts: Optional[ResourceOptions] = None,
                                       alias: Optional[str] = None,
                                       ssl_type: Optional[str] = None,
                                       protection_resource_alias_certificate_id: Optional[str] = None,
                                       ssl_crt: Optional[str] = None,
                                       ssl_key: Optional[str] = None)
    func NewProtectionResourceAliasCertificate(ctx *Context, name string, args ProtectionResourceAliasCertificateArgs, opts ...ResourceOption) (*ProtectionResourceAliasCertificate, error)
    public ProtectionResourceAliasCertificate(string name, ProtectionResourceAliasCertificateArgs args, CustomResourceOptions? opts = null)
    public ProtectionResourceAliasCertificate(String name, ProtectionResourceAliasCertificateArgs args)
public ProtectionResourceAliasCertificate(String name, ProtectionResourceAliasCertificateArgs args, CustomResourceOptions options)

    type: edgecenter:ProtectionResourceAliasCertificate
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args ProtectionResourceAliasCertificateArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ProtectionResourceAliasCertificateArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ProtectionResourceAliasCertificateArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ProtectionResourceAliasCertificateArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ProtectionResourceAliasCertificateArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var protectionResourceAliasCertificateResource = new Edgecenter.ProtectionResourceAliasCertificate("protectionResourceAliasCertificateResource", new()
{
    Alias = "string",
    SslType = "string",
    ProtectionResourceAliasCertificateId = "string",
    SslCrt = "string",
    SslKey = "string",
});

    example, err := edgecenter.NewProtectionResourceAliasCertificate(ctx, "protectionResourceAliasCertificateResource", &edgecenter.ProtectionResourceAliasCertificateArgs{
	Alias:                                pulumi.String("string"),
	SslType:                              pulumi.String("string"),
	ProtectionResourceAliasCertificateId: pulumi.String("string"),
	SslCrt:                               pulumi.String("string"),
	SslKey:                               pulumi.String("string"),
})

    var protectionResourceAliasCertificateResource = new ProtectionResourceAliasCertificate("protectionResourceAliasCertificateResource", ProtectionResourceAliasCertificateArgs.builder()
    .alias("string")
    .sslType("string")
    .protectionResourceAliasCertificateId("string")
    .sslCrt("string")
    .sslKey("string")
    .build());

    protection_resource_alias_certificate_resource = edgecenter.ProtectionResourceAliasCertificate("protectionResourceAliasCertificateResource",
    alias="string",
    ssl_type="string",
    protection_resource_alias_certificate_id="string",
    ssl_crt="string",
    ssl_key="string")

    const protectionResourceAliasCertificateResource = new edgecenter.ProtectionResourceAliasCertificate("protectionResourceAliasCertificateResource", {
    alias: "string",
    sslType: "string",
    protectionResourceAliasCertificateId: "string",
    sslCrt: "string",
    sslKey: "string",
});

    type: edgecenter:ProtectionResourceAliasCertificate
properties:
    alias: string
    protectionResourceAliasCertificateId: string
    sslCrt: string
    sslKey: string
    sslType: string

    ProtectionResourceAliasCertificate Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The ProtectionResourceAliasCertificate resource accepts the following input properties:

    Alias string
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    SslType string
    Select the SSL certificate type. Available values are custom, le.
    ProtectionResourceAliasCertificateId string
    The ID of this resource.
    SslCrt string
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    SslKey string
    Private key of the SSL certificate.
    Alias string
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    SslType string
    Select the SSL certificate type. Available values are custom, le.
    ProtectionResourceAliasCertificateId string
    The ID of this resource.
    SslCrt string
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    SslKey string
    Private key of the SSL certificate.
    alias String
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    sslType String
    Select the SSL certificate type. Available values are custom, le.
    protectionResourceAliasCertificateId String
    The ID of this resource.
    sslCrt String
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    sslKey String
    Private key of the SSL certificate.
    alias string
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    sslType string
    Select the SSL certificate type. Available values are custom, le.
    protectionResourceAliasCertificateId string
    The ID of this resource.
    sslCrt string
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    sslKey string
    Private key of the SSL certificate.
    alias str
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    ssl_type str
    Select the SSL certificate type. Available values are custom, le.
    protection_resource_alias_certificate_id str
    The ID of this resource.
    ssl_crt str
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    ssl_key str
    Private key of the SSL certificate.
    alias String
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    sslType String
    Select the SSL certificate type. Available values are custom, le.
    protectionResourceAliasCertificateId String
    The ID of this resource.
    sslCrt String
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    sslKey String
    Private key of the SSL certificate.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ProtectionResourceAliasCertificate resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    SslExpire double
    UNIX timestamp of the SSL certificate expiration date.
    SslStatus double
    Let's Encrypt SSL certificate issuance status.
    Id string
    The provider-assigned unique ID for this managed resource.
    SslExpire float64
    UNIX timestamp of the SSL certificate expiration date.
    SslStatus float64
    Let's Encrypt SSL certificate issuance status.
    id String
    The provider-assigned unique ID for this managed resource.
    sslExpire Double
    UNIX timestamp of the SSL certificate expiration date.
    sslStatus Double
    Let's Encrypt SSL certificate issuance status.
    id string
    The provider-assigned unique ID for this managed resource.
    sslExpire number
    UNIX timestamp of the SSL certificate expiration date.
    sslStatus number
    Let's Encrypt SSL certificate issuance status.
    id str
    The provider-assigned unique ID for this managed resource.
    ssl_expire float
    UNIX timestamp of the SSL certificate expiration date.
    ssl_status float
    Let's Encrypt SSL certificate issuance status.
    id String
    The provider-assigned unique ID for this managed resource.
    sslExpire Number
    UNIX timestamp of the SSL certificate expiration date.
    sslStatus Number
    Let's Encrypt SSL certificate issuance status.

    Look up Existing ProtectionResourceAliasCertificate Resource

    Get an existing ProtectionResourceAliasCertificate resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ProtectionResourceAliasCertificateState, opts?: CustomResourceOptions): ProtectionResourceAliasCertificate
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        alias: Optional[str] = None,
        protection_resource_alias_certificate_id: Optional[str] = None,
        ssl_crt: Optional[str] = None,
        ssl_expire: Optional[float] = None,
        ssl_key: Optional[str] = None,
        ssl_status: Optional[float] = None,
        ssl_type: Optional[str] = None) -> ProtectionResourceAliasCertificate
    func GetProtectionResourceAliasCertificate(ctx *Context, name string, id IDInput, state *ProtectionResourceAliasCertificateState, opts ...ResourceOption) (*ProtectionResourceAliasCertificate, error)
    public static ProtectionResourceAliasCertificate Get(string name, Input<string> id, ProtectionResourceAliasCertificateState? state, CustomResourceOptions? opts = null)
    public static ProtectionResourceAliasCertificate get(String name, Output<String> id, ProtectionResourceAliasCertificateState state, CustomResourceOptions options)
    resources:  _:    type: edgecenter:ProtectionResourceAliasCertificate    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Alias string
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    ProtectionResourceAliasCertificateId string
    The ID of this resource.
    SslCrt string
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    SslExpire double
    UNIX timestamp of the SSL certificate expiration date.
    SslKey string
    Private key of the SSL certificate.
    SslStatus double
    Let's Encrypt SSL certificate issuance status.
    SslType string
    Select the SSL certificate type. Available values are custom, le.
    Alias string
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    ProtectionResourceAliasCertificateId string
    The ID of this resource.
    SslCrt string
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    SslExpire float64
    UNIX timestamp of the SSL certificate expiration date.
    SslKey string
    Private key of the SSL certificate.
    SslStatus float64
    Let's Encrypt SSL certificate issuance status.
    SslType string
    Select the SSL certificate type. Available values are custom, le.
    alias String
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    protectionResourceAliasCertificateId String
    The ID of this resource.
    sslCrt String
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    sslExpire Double
    UNIX timestamp of the SSL certificate expiration date.
    sslKey String
    Private key of the SSL certificate.
    sslStatus Double
    Let's Encrypt SSL certificate issuance status.
    sslType String
    Select the SSL certificate type. Available values are custom, le.
    alias string
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    protectionResourceAliasCertificateId string
    The ID of this resource.
    sslCrt string
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    sslExpire number
    UNIX timestamp of the SSL certificate expiration date.
    sslKey string
    Private key of the SSL certificate.
    sslStatus number
    Let's Encrypt SSL certificate issuance status.
    sslType string
    Select the SSL certificate type. Available values are custom, le.
    alias str
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    protection_resource_alias_certificate_id str
    The ID of this resource.
    ssl_crt str
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    ssl_expire float
    UNIX timestamp of the SSL certificate expiration date.
    ssl_key str
    Private key of the SSL certificate.
    ssl_status float
    Let's Encrypt SSL certificate issuance status.
    ssl_type str
    Select the SSL certificate type. Available values are custom, le.
    alias String
    The id of alias of DDoS protection resource. Has form <resource_id>:<alias_id>
    protectionResourceAliasCertificateId String
    The ID of this resource.
    sslCrt String
    Public part of the SSL certificate. Add all the certificate chains. Each certificate chain should be separated by \n
    sslExpire Number
    UNIX timestamp of the SSL certificate expiration date.
    sslKey String
    Private key of the SSL certificate.
    sslStatus Number
    Let's Encrypt SSL certificate issuance status.
    sslType String
    Select the SSL certificate type. Available values are custom, le.

    Import

    import using <resource_id>: format

    note: for “custom” type certificate and private key are not imported

    $ pulumi import edgecenter:index/protectionResourceAliasCertificate:ProtectionResourceAliasCertificate protection_cert_custom 12345:67

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    edgecenter edge-center/terraform-provider-edgecenter
    License
    Notes
    This Pulumi package is based on the edgecenter Terraform Provider.
    edgecenter logo
    edgecenter 0.9.4 published on Thursday, Aug 14, 2025 by edge-center
    edge-center/terraform-provider-edgecenter