fastly.TlsCertificate

import * as pulumi from "@pulumi/pulumi";
import * as fastly from "@pulumi/fastly";
import * as tls from "@pulumi/tls";

const key = new tls.index.PrivateKey("key", {algorithm: "RSA"});
const cert = new tls.index.SelfSignedCert("cert", {
    keyAlgorithm: key.algorithm,
    privateKeyPem: key.privateKeyPem,
    subject: [{
        commonName: "example.com",
    }],
    isCaCertificate: true,
    validityPeriodHours: 360,
    allowedUses: [
        "cert_signing",
        "server_auth",
    ],
    dnsNames: ["example.com"],
});
const keyTlsPrivateKey = new fastly.TlsPrivateKey("key", {
    keyPem: key.privateKeyPem,
    name: "tf-demo",
});
const example = new fastly.TlsCertificate("example", {
    name: "tf-demo",
    certificateBody: cert.certPem,
}, {
    dependsOn: [keyTlsPrivateKey],
});

import pulumi
import pulumi_fastly as fastly
import pulumi_tls as tls

key = tls.index.PrivateKey("key", algorithm=RSA)
cert = tls.index.SelfSignedCert("cert",
    key_algorithm=key.algorithm,
    private_key_pem=key.private_key_pem,
    subject=[{
        commonName: example.com,
    }],
    is_ca_certificate=True,
    validity_period_hours=360,
    allowed_uses=[
        cert_signing,
        server_auth,
    ],
    dns_names=[example.com])
key_tls_private_key = fastly.TlsPrivateKey("key",
    key_pem=key["privateKeyPem"],
    name="tf-demo")
example = fastly.TlsCertificate("example",
    name="tf-demo",
    certificate_body=cert["certPem"],
    opts = pulumi.ResourceOptions(depends_on=[key_tls_private_key]))

package main

import (
	"github.com/pulumi/pulumi-fastly/sdk/v8/go/fastly"
	"github.com/pulumi/pulumi-tls/sdk/v4/go/tls"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		key, err := tls.NewPrivateKey(ctx, "key", &tls.PrivateKeyArgs{
			Algorithm: "RSA",
		})
		if err != nil {
			return err
		}
		cert, err := tls.NewSelfSignedCert(ctx, "cert", &tls.SelfSignedCertArgs{
			KeyAlgorithm:  key.Algorithm,
			PrivateKeyPem: key.PrivateKeyPem,
			Subject: []map[string]interface{}{
				map[string]interface{}{
					"commonName": "example.com",
				},
			},
			IsCaCertificate:     true,
			ValidityPeriodHours: 360,
			AllowedUses: []string{
				"cert_signing",
				"server_auth",
			},
			DnsNames: []string{
				"example.com",
			},
		})
		if err != nil {
			return err
		}
		keyTlsPrivateKey, err := fastly.NewTlsPrivateKey(ctx, "key", &fastly.TlsPrivateKeyArgs{
			KeyPem: key.PrivateKeyPem,
			Name:   pulumi.String("tf-demo"),
		})
		if err != nil {
			return err
		}
		_, err = fastly.NewTlsCertificate(ctx, "example", &fastly.TlsCertificateArgs{
			Name:            pulumi.String("tf-demo"),
			CertificateBody: cert.CertPem,
		}, pulumi.DependsOn([]pulumi.Resource{
			keyTlsPrivateKey,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Fastly = Pulumi.Fastly;
using Tls = Pulumi.Tls;

return await Deployment.RunAsync(() => 
{
    var key = new Tls.Index.PrivateKey("key", new()
    {
        Algorithm = "RSA",
    });

    var cert = new Tls.Index.SelfSignedCert("cert", new()
    {
        KeyAlgorithm = key.Algorithm,
        PrivateKeyPem = key.PrivateKeyPem,
        Subject = new[]
        {
            
            {
                { "commonName", "example.com" },
            },
        },
        IsCaCertificate = true,
        ValidityPeriodHours = 360,
        AllowedUses = new[]
        {
            "cert_signing",
            "server_auth",
        },
        DnsNames = new[]
        {
            "example.com",
        },
    });

    var keyTlsPrivateKey = new Fastly.TlsPrivateKey("key", new()
    {
        KeyPem = key.PrivateKeyPem,
        Name = "tf-demo",
    });

    var example = new Fastly.TlsCertificate("example", new()
    {
        Name = "tf-demo",
        CertificateBody = cert.CertPem,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            keyTlsPrivateKey,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.tls.privateKey;
import com.pulumi.tls.PrivateKeyArgs;
import com.pulumi.tls.selfSignedCert;
import com.pulumi.tls.SelfSignedCertArgs;
import com.pulumi.fastly.TlsPrivateKey;
import com.pulumi.fastly.TlsPrivateKeyArgs;
import com.pulumi.fastly.TlsCertificate;
import com.pulumi.fastly.TlsCertificateArgs;
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) {
        var key = new PrivateKey("key", PrivateKeyArgs.builder()
            .algorithm("RSA")
            .build());

        var cert = new SelfSignedCert("cert", SelfSignedCertArgs.builder()
            .keyAlgorithm(key.algorithm())
            .privateKeyPem(key.privateKeyPem())
            .subject(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .isCaCertificate(true)
            .validityPeriodHours(360)
            .allowedUses(            
                "cert_signing",
                "server_auth")
            .dnsNames("example.com")
            .build());

        var keyTlsPrivateKey = new TlsPrivateKey("keyTlsPrivateKey", TlsPrivateKeyArgs.builder()
            .keyPem(key.privateKeyPem())
            .name("tf-demo")
            .build());

        var example = new TlsCertificate("example", TlsCertificateArgs.builder()
            .name("tf-demo")
            .certificateBody(cert.certPem())
            .build(), CustomResourceOptions.builder()
                .dependsOn(keyTlsPrivateKey)
                .build());

    }
}

resources:
  key:
    type: tls:privateKey
    properties:
      algorithm: RSA
  cert:
    type: tls:selfSignedCert
    properties:
      keyAlgorithm: ${key.algorithm}
      privateKeyPem: ${key.privateKeyPem}
      subject:
        - commonName: example.com
      isCaCertificate: true
      validityPeriodHours: 360
      allowedUses:
        - cert_signing
        - server_auth
      dnsNames:
        - example.com
  keyTlsPrivateKey:
    type: fastly:TlsPrivateKey
    name: key
    properties:
      keyPem: ${key.privateKeyPem}
      name: tf-demo
  example:
    type: fastly:TlsCertificate
    properties:
      name: tf-demo
      certificateBody: ${cert.certPem}
    options:
      dependson:
        - ${keyTlsPrivateKey}

var tlsCertificateResource = new Fastly.TlsCertificate("tlsCertificateResource", new()
{
    CertificateBody = "string",
    Name = "string",
});

example, err := fastly.NewTlsCertificate(ctx, "tlsCertificateResource", &fastly.TlsCertificateArgs{
	CertificateBody: pulumi.String("string"),
	Name:            pulumi.String("string"),
})

var tlsCertificateResource = new TlsCertificate("tlsCertificateResource", TlsCertificateArgs.builder()
    .certificateBody("string")
    .name("string")
    .build());

tls_certificate_resource = fastly.TlsCertificate("tlsCertificateResource",
    certificate_body="string",
    name="string")

const tlsCertificateResource = new fastly.TlsCertificate("tlsCertificateResource", {
    certificateBody: "string",
    name: "string",
});

type: fastly:TlsCertificate
properties:
    certificateBody: string
    name: string