1. Packages
  2. Volcengine
  3. API Docs
  4. cdn
  5. Configs
Volcengine v0.0.25 published on Tuesday, Jul 2, 2024 by Volcengine

volcengine.cdn.Configs

Explore with Pulumi AI

volcengine logo
Volcengine v0.0.25 published on Tuesday, Jul 2, 2024 by Volcengine

    Use this data source to query detailed information of cdn configs

    Example Usage

    using System.Collections.Generic;
    using System.Linq;
    using System.Text.Json;
    using Pulumi;
    using Volcengine = Pulumi.Volcengine;
    
    return await Deployment.RunAsync(() => 
    {
        var fooCdnCertificate = new Volcengine.Cdn.CdnCertificate("fooCdnCertificate", new()
        {
            Certificate = "",
            PrivateKey = "",
            Desc = "tftest",
            Source = "cdn_cert_hosting",
        });
    
        var fooCdnDomain = new Volcengine.Cdn.CdnDomain("fooCdnDomain", new()
        {
            Domain = "tftest.byte-test.com",
            ServiceType = "web",
            Tags = new[]
            {
                new Volcengine.Cdn.Inputs.CdnDomainTagArgs
                {
                    Key = "tfkey1",
                    Value = "tfvalue1",
                },
                new Volcengine.Cdn.Inputs.CdnDomainTagArgs
                {
                    Key = "tfkey2",
                    Value = "tfvalue2",
                },
            },
            DomainConfig = fooCdnCertificate.Id.Apply(id => JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["OriginProtocol"] = "https",
                ["Origin"] = new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["OriginAction"] = new Dictionary<string, object?>
                        {
                            ["OriginLines"] = new[]
                            {
                                new Dictionary<string, object?>
                                {
                                    ["Address"] = "1.1.1.1",
                                    ["HttpPort"] = "80",
                                    ["HttpsPort"] = "443",
                                    ["InstanceType"] = "ip",
                                    ["OriginType"] = "primary",
                                    ["PrivateBucketAccess"] = false,
                                    ["Weight"] = "2",
                                },
                            },
                        },
                    },
                },
                ["HTTPS"] = new Dictionary<string, object?>
                {
                    ["CertInfo"] = new Dictionary<string, object?>
                    {
                        ["CertId"] = id,
                    },
                    ["DisableHttp"] = false,
                    ["HTTP2"] = true,
                    ["Switch"] = true,
                    ["Ocsp"] = false,
                    ["TlsVersion"] = new[]
                    {
                        "tlsv1.1",
                        "tlsv1.2",
                    },
                },
            })),
        });
    
        var fooConfigs = Volcengine.Cdn.Configs.Invoke(new()
        {
            Domain = fooCdnDomain.Id,
        });
    
    });
    
    package main
    
    import (
    	"encoding/json"
    
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/cdn"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		fooCdnCertificate, err := cdn.NewCdnCertificate(ctx, "fooCdnCertificate", &cdn.CdnCertificateArgs{
    			Certificate: pulumi.String(""),
    			PrivateKey:  pulumi.String(""),
    			Desc:        pulumi.String("tftest"),
    			Source:      pulumi.String("cdn_cert_hosting"),
    		})
    		if err != nil {
    			return err
    		}
    		fooCdnDomain, err := cdn.NewCdnDomain(ctx, "fooCdnDomain", &cdn.CdnDomainArgs{
    			Domain:      pulumi.String("tftest.byte-test.com"),
    			ServiceType: pulumi.String("web"),
    			Tags: cdn.CdnDomainTagArray{
    				&cdn.CdnDomainTagArgs{
    					Key:   pulumi.String("tfkey1"),
    					Value: pulumi.String("tfvalue1"),
    				},
    				&cdn.CdnDomainTagArgs{
    					Key:   pulumi.String("tfkey2"),
    					Value: pulumi.String("tfvalue2"),
    				},
    			},
    			DomainConfig: fooCdnCertificate.ID().ApplyT(func(id string) (pulumi.String, error) {
    				var _zero pulumi.String
    				tmpJSON0, err := json.Marshal(map[string]interface{}{
    					"OriginProtocol": "https",
    					"Origin": []map[string]interface{}{
    						map[string]interface{}{
    							"OriginAction": map[string]interface{}{
    								"OriginLines": []map[string]interface{}{
    									map[string]interface{}{
    										"Address":             "1.1.1.1",
    										"HttpPort":            "80",
    										"HttpsPort":           "443",
    										"InstanceType":        "ip",
    										"OriginType":          "primary",
    										"PrivateBucketAccess": false,
    										"Weight":              "2",
    									},
    								},
    							},
    						},
    					},
    					"HTTPS": map[string]interface{}{
    						"CertInfo": map[string]interface{}{
    							"CertId": id,
    						},
    						"DisableHttp": false,
    						"HTTP2":       true,
    						"Switch":      true,
    						"Ocsp":        false,
    						"TlsVersion": []string{
    							"tlsv1.1",
    							"tlsv1.2",
    						},
    					},
    				})
    				if err != nil {
    					return _zero, err
    				}
    				json0 := string(tmpJSON0)
    				return pulumi.String(json0), nil
    			}).(pulumi.StringOutput),
    		})
    		if err != nil {
    			return err
    		}
    		_ = cdn.ConfigsOutput(ctx, cdn.ConfigsOutputArgs{
    			Domain: fooCdnDomain.ID(),
    		}, nil)
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.volcengine.cdn.CdnCertificate;
    import com.pulumi.volcengine.cdn.CdnCertificateArgs;
    import com.pulumi.volcengine.cdn.CdnDomain;
    import com.pulumi.volcengine.cdn.CdnDomainArgs;
    import com.pulumi.volcengine.cdn.inputs.CdnDomainTagArgs;
    import com.pulumi.volcengine.cdn.CdnFunctions;
    import com.pulumi.volcengine.cdn.inputs.ConfigsArgs;
    import static com.pulumi.codegen.internal.Serialization.*;
    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) {
            var fooCdnCertificate = new CdnCertificate("fooCdnCertificate", CdnCertificateArgs.builder()        
                .certificate("")
                .privateKey("")
                .desc("tftest")
                .source("cdn_cert_hosting")
                .build());
    
            var fooCdnDomain = new CdnDomain("fooCdnDomain", CdnDomainArgs.builder()        
                .domain("tftest.byte-test.com")
                .serviceType("web")
                .tags(            
                    CdnDomainTagArgs.builder()
                        .key("tfkey1")
                        .value("tfvalue1")
                        .build(),
                    CdnDomainTagArgs.builder()
                        .key("tfkey2")
                        .value("tfvalue2")
                        .build())
                .domainConfig(fooCdnCertificate.id().applyValue(id -> serializeJson(
                    jsonObject(
                        jsonProperty("OriginProtocol", "https"),
                        jsonProperty("Origin", jsonArray(jsonObject(
                            jsonProperty("OriginAction", jsonObject(
                                jsonProperty("OriginLines", jsonArray(jsonObject(
                                    jsonProperty("Address", "1.1.1.1"),
                                    jsonProperty("HttpPort", "80"),
                                    jsonProperty("HttpsPort", "443"),
                                    jsonProperty("InstanceType", "ip"),
                                    jsonProperty("OriginType", "primary"),
                                    jsonProperty("PrivateBucketAccess", false),
                                    jsonProperty("Weight", "2")
                                )))
                            ))
                        ))),
                        jsonProperty("HTTPS", jsonObject(
                            jsonProperty("CertInfo", jsonObject(
                                jsonProperty("CertId", id)
                            )),
                            jsonProperty("DisableHttp", false),
                            jsonProperty("HTTP2", true),
                            jsonProperty("Switch", true),
                            jsonProperty("Ocsp", false),
                            jsonProperty("TlsVersion", jsonArray(
                                "tlsv1.1", 
                                "tlsv1.2"
                            ))
                        ))
                    ))))
                .build());
    
            final var fooConfigs = CdnFunctions.Configs(ConfigsArgs.builder()
                .domain(fooCdnDomain.id())
                .build());
    
        }
    }
    
    import pulumi
    import json
    import pulumi_volcengine as volcengine
    
    foo_cdn_certificate = volcengine.cdn.CdnCertificate("fooCdnCertificate",
        certificate="",
        private_key="",
        desc="tftest",
        source="cdn_cert_hosting")
    foo_cdn_domain = volcengine.cdn.CdnDomain("fooCdnDomain",
        domain="tftest.byte-test.com",
        service_type="web",
        tags=[
            volcengine.cdn.CdnDomainTagArgs(
                key="tfkey1",
                value="tfvalue1",
            ),
            volcengine.cdn.CdnDomainTagArgs(
                key="tfkey2",
                value="tfvalue2",
            ),
        ],
        domain_config=foo_cdn_certificate.id.apply(lambda id: json.dumps({
            "OriginProtocol": "https",
            "Origin": [{
                "OriginAction": {
                    "OriginLines": [{
                        "Address": "1.1.1.1",
                        "HttpPort": "80",
                        "HttpsPort": "443",
                        "InstanceType": "ip",
                        "OriginType": "primary",
                        "PrivateBucketAccess": False,
                        "Weight": "2",
                    }],
                },
            }],
            "HTTPS": {
                "CertInfo": {
                    "CertId": id,
                },
                "DisableHttp": False,
                "HTTP2": True,
                "Switch": True,
                "Ocsp": False,
                "TlsVersion": [
                    "tlsv1.1",
                    "tlsv1.2",
                ],
            },
        })))
    foo_configs = volcengine.cdn.configs_output(domain=foo_cdn_domain.id)
    
    import * as pulumi from "@pulumi/pulumi";
    import * as volcengine from "@pulumi/volcengine";
    import * as volcengine from "@volcengine/pulumi";
    
    const fooCdnCertificate = new volcengine.cdn.CdnCertificate("fooCdnCertificate", {
        certificate: "",
        privateKey: "",
        desc: "tftest",
        source: "cdn_cert_hosting",
    });
    const fooCdnDomain = new volcengine.cdn.CdnDomain("fooCdnDomain", {
        domain: "tftest.byte-test.com",
        serviceType: "web",
        tags: [
            {
                key: "tfkey1",
                value: "tfvalue1",
            },
            {
                key: "tfkey2",
                value: "tfvalue2",
            },
        ],
        domainConfig: fooCdnCertificate.id.apply(id => JSON.stringify({
            OriginProtocol: "https",
            Origin: [{
                OriginAction: {
                    OriginLines: [{
                        Address: "1.1.1.1",
                        HttpPort: "80",
                        HttpsPort: "443",
                        InstanceType: "ip",
                        OriginType: "primary",
                        PrivateBucketAccess: false,
                        Weight: "2",
                    }],
                },
            }],
            HTTPS: {
                CertInfo: {
                    CertId: id,
                },
                DisableHttp: false,
                HTTP2: true,
                Switch: true,
                Ocsp: false,
                TlsVersion: [
                    "tlsv1.1",
                    "tlsv1.2",
                ],
            },
        })),
    });
    const fooConfigs = volcengine.cdn.ConfigsOutput({
        domain: fooCdnDomain.id,
    });
    
    resources:
      fooCdnCertificate:
        type: volcengine:cdn:CdnCertificate
        properties:
          certificate:
          privateKey:
          desc: tftest
          source: cdn_cert_hosting
      fooCdnDomain:
        type: volcengine:cdn:CdnDomain
        properties:
          domain: tftest.byte-test.com
          serviceType: web
          tags:
            - key: tfkey1
              value: tfvalue1
            - key: tfkey2
              value: tfvalue2
          domainConfig:
            fn::toJSON:
              OriginProtocol: https
              Origin:
                - OriginAction:
                    OriginLines:
                      - Address: 1.1.1.1
                        HttpPort: '80'
                        HttpsPort: '443'
                        InstanceType: ip
                        OriginType: primary
                        PrivateBucketAccess: false
                        Weight: '2'
              HTTPS:
                CertInfo:
                  CertId: ${fooCdnCertificate.id}
                DisableHttp: false
                HTTP2: true
                Switch: true
                Ocsp: false
                TlsVersion:
                  - tlsv1.1
                  - tlsv1.2
    variables:
      fooConfigs:
        fn::invoke:
          Function: volcengine:cdn:Configs
          Arguments:
            domain: ${fooCdnDomain.id}
    

    Using Configs

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function configs(args: ConfigsArgs, opts?: InvokeOptions): Promise<ConfigsResult>
    function configsOutput(args: ConfigsOutputArgs, opts?: InvokeOptions): Output<ConfigsResult>
    def configs(domain: Optional[str] = None,
                output_file: Optional[str] = None,
                opts: Optional[InvokeOptions] = None) -> ConfigsResult
    def configs_output(domain: Optional[pulumi.Input[str]] = None,
                output_file: Optional[pulumi.Input[str]] = None,
                opts: Optional[InvokeOptions] = None) -> Output[ConfigsResult]
    func Configs(ctx *Context, args *ConfigsArgs, opts ...InvokeOption) (*ConfigsResult, error)
    func ConfigsOutput(ctx *Context, args *ConfigsOutputArgs, opts ...InvokeOption) ConfigsResultOutput
    public static class Configs 
    {
        public static Task<ConfigsResult> InvokeAsync(ConfigsArgs args, InvokeOptions? opts = null)
        public static Output<ConfigsResult> Invoke(ConfigsInvokeArgs args, InvokeOptions? opts = null)
    }
    public static CompletableFuture<ConfigsResult> configs(ConfigsArgs args, InvokeOptions options)
    // Output-based functions aren't available in Java yet
    
    fn::invoke:
      function: volcengine:cdn:Configs
      arguments:
        # arguments dictionary

    The following arguments are supported:

    Domain string
    The domain name.
    OutputFile string
    File name where to save data source results.
    Domain string
    The domain name.
    OutputFile string
    File name where to save data source results.
    domain String
    The domain name.
    outputFile String
    File name where to save data source results.
    domain string
    The domain name.
    outputFile string
    File name where to save data source results.
    domain str
    The domain name.
    output_file str
    File name where to save data source results.
    domain String
    The domain name.
    outputFile String
    File name where to save data source results.

    Configs Result

    The following output properties are available:

    Domain string
    The domain name.
    DomainConfigs List<ConfigsDomainConfig>
    The collection of query.
    Id string
    The provider-assigned unique ID for this managed resource.
    TotalCount int
    The total count of query.
    OutputFile string
    Domain string
    The domain name.
    DomainConfigs []ConfigsDomainConfig
    The collection of query.
    Id string
    The provider-assigned unique ID for this managed resource.
    TotalCount int
    The total count of query.
    OutputFile string
    domain String
    The domain name.
    domainConfigs List<ConfigsDomainConfig>
    The collection of query.
    id String
    The provider-assigned unique ID for this managed resource.
    totalCount Integer
    The total count of query.
    outputFile String
    domain string
    The domain name.
    domainConfigs ConfigsDomainConfig[]
    The collection of query.
    id string
    The provider-assigned unique ID for this managed resource.
    totalCount number
    The total count of query.
    outputFile string
    domain str
    The domain name.
    domain_configs Sequence[ConfigsDomainConfig]
    The collection of query.
    id str
    The provider-assigned unique ID for this managed resource.
    total_count int
    The total count of query.
    output_file str
    domain String
    The domain name.
    domainConfigs List<Property Map>
    The collection of query.
    id String
    The provider-assigned unique ID for this managed resource.
    totalCount Number
    The total count of query.
    outputFile String

    Supporting Types

    ConfigsDomainConfig

    Cname string
    The cname of the domain.
    CreateTime int
    The create time of the domain.
    Domain string
    The domain name.
    LockStatus string
    Indicates whether the configuration of this domain name is allowed to be changed.
    Project string
    The project name.
    ServiceRegion string
    The service region of the domain.
    ServiceType string
    The service type of the domain.
    Status string
    The status of the domain.
    UpdateTime int
    The update time of the domain.
    Cname string
    The cname of the domain.
    CreateTime int
    The create time of the domain.
    Domain string
    The domain name.
    LockStatus string
    Indicates whether the configuration of this domain name is allowed to be changed.
    Project string
    The project name.
    ServiceRegion string
    The service region of the domain.
    ServiceType string
    The service type of the domain.
    Status string
    The status of the domain.
    UpdateTime int
    The update time of the domain.
    cname String
    The cname of the domain.
    createTime Integer
    The create time of the domain.
    domain String
    The domain name.
    lockStatus String
    Indicates whether the configuration of this domain name is allowed to be changed.
    project String
    The project name.
    serviceRegion String
    The service region of the domain.
    serviceType String
    The service type of the domain.
    status String
    The status of the domain.
    updateTime Integer
    The update time of the domain.
    cname string
    The cname of the domain.
    createTime number
    The create time of the domain.
    domain string
    The domain name.
    lockStatus string
    Indicates whether the configuration of this domain name is allowed to be changed.
    project string
    The project name.
    serviceRegion string
    The service region of the domain.
    serviceType string
    The service type of the domain.
    status string
    The status of the domain.
    updateTime number
    The update time of the domain.
    cname str
    The cname of the domain.
    create_time int
    The create time of the domain.
    domain str
    The domain name.
    lock_status str
    Indicates whether the configuration of this domain name is allowed to be changed.
    project str
    The project name.
    service_region str
    The service region of the domain.
    service_type str
    The service type of the domain.
    status str
    The status of the domain.
    update_time int
    The update time of the domain.
    cname String
    The cname of the domain.
    createTime Number
    The create time of the domain.
    domain String
    The domain name.
    lockStatus String
    Indicates whether the configuration of this domain name is allowed to be changed.
    project String
    The project name.
    serviceRegion String
    The service region of the domain.
    serviceType String
    The service type of the domain.
    status String
    The status of the domain.
    updateTime Number
    The update time of the domain.

    Package Details

    Repository
    volcengine volcengine/pulumi-volcengine
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the volcengine Terraform Provider.
    volcengine logo
    Volcengine v0.0.25 published on Tuesday, Jul 2, 2024 by Volcengine