gcp.compute.RegionSslCertificate

using System.Collections.Generic;
using System.IO;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var @default = new Gcp.Compute.RegionSslCertificate("default", new()
    {
        Region = "us-central1",
        NamePrefix = "my-certificate-",
        Description = "a description",
        PrivateKey = File.ReadAllText("path/to/private.key"),
        Certificate = File.ReadAllText("path/to/certificate.crt"),
    });

});

package main

import (
	"os"

	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionSslCertificate(ctx, "default", &compute.RegionSslCertificateArgs{
			Region:      pulumi.String("us-central1"),
			NamePrefix:  pulumi.String("my-certificate-"),
			Description: pulumi.String("a description"),
			PrivateKey:  readFileOrPanic("path/to/private.key"),
			Certificate: readFileOrPanic("path/to/certificate.crt"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionSslCertificate;
import com.pulumi.gcp.compute.RegionSslCertificateArgs;
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 default_ = new RegionSslCertificate("default", RegionSslCertificateArgs.builder()        
            .region("us-central1")
            .namePrefix("my-certificate-")
            .description("a description")
            .privateKey(Files.readString(Paths.get("path/to/private.key")))
            .certificate(Files.readString(Paths.get("path/to/certificate.crt")))
            .build());

    }
}

import pulumi
import pulumi_gcp as gcp

default = gcp.compute.RegionSslCertificate("default",
    region="us-central1",
    name_prefix="my-certificate-",
    description="a description",
    private_key=(lambda path: open(path).read())("path/to/private.key"),
    certificate=(lambda path: open(path).read())("path/to/certificate.crt"))

import * as pulumi from "@pulumi/pulumi";
import * as fs from "fs";
import * as gcp from "@pulumi/gcp";

const _default = new gcp.compute.RegionSslCertificate("default", {
    region: "us-central1",
    namePrefix: "my-certificate-",
    description: "a description",
    privateKey: fs.readFileSync("path/to/private.key"),
    certificate: fs.readFileSync("path/to/certificate.crt"),
});

resources:
  default:
    type: gcp:compute:RegionSslCertificate
    properties:
      region: us-central1
      namePrefix: my-certificate-
      description: a description
      privateKey:
        fn::readFile: path/to/private.key
      certificate:
        fn::readFile: path/to/certificate.crt

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Random = Pulumi.Random;

	private static string ComputeFileBase64Sha256(string path) {
		var fileData = System.Text.Encoding.UTF8.GetBytes(File.ReadAllText(path));
		var hashData = SHA256.Create().ComputeHash(fileData);
		return Convert.ToBase64String(hashData);
	}

return await Deployment.RunAsync(() => 
{
    // You may also want to control name generation explicitly:
    var @default = new Gcp.Compute.RegionSslCertificate("default", new()
    {
        Region = "us-central1",
        PrivateKey = File.ReadAllText("path/to/private.key"),
        Certificate = File.ReadAllText("path/to/certificate.crt"),
    });

    var certificate = new Random.RandomId("certificate", new()
    {
        ByteLength = 4,
        Prefix = "my-certificate-",
        Keepers = 
        {
            { "private_key", ComputeFileBase64Sha256("path/to/private.key") },
            { "certificate", ComputeFileBase64Sha256("path/to/certificate.crt") },
        },
    });

});

package main

import (
	"crypto/sha256"
	"fmt"
	"os"

	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func filebase64sha256OrPanic(path string) pulumi.StringPtrInput {
	if fileData, err := os.ReadFile(path); err == nil {
		hashedData := sha256.Sum256([]byte(fileData))
		return pulumi.String(base64.StdEncoding.EncodeToString(hashedData[:]))
	} else {
		panic(err.Error())
	}
}

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionSslCertificate(ctx, "default", &compute.RegionSslCertificateArgs{
			Region:      pulumi.String("us-central1"),
			PrivateKey:  readFileOrPanic("path/to/private.key"),
			Certificate: readFileOrPanic("path/to/certificate.crt"),
		})
		if err != nil {
			return err
		}
		_, err = random.NewRandomId(ctx, "certificate", &random.RandomIdArgs{
			ByteLength: pulumi.Int(4),
			Prefix:     pulumi.String("my-certificate-"),
			Keepers: pulumi.StringMap{
				"private_key": filebase64sha256OrPanic("path/to/private.key"),
				"certificate": filebase64sha256OrPanic("path/to/certificate.crt"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionSslCertificate;
import com.pulumi.gcp.compute.RegionSslCertificateArgs;
import com.pulumi.random.RandomId;
import com.pulumi.random.RandomIdArgs;
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 default_ = new RegionSslCertificate("default", RegionSslCertificateArgs.builder()        
            .region("us-central1")
            .privateKey(Files.readString(Paths.get("path/to/private.key")))
            .certificate(Files.readString(Paths.get("path/to/certificate.crt")))
            .build());

        var certificate = new RandomId("certificate", RandomIdArgs.builder()        
            .byteLength(4)
            .prefix("my-certificate-")
            .keepers(Map.ofEntries(
                Map.entry("private_key", computeFileBase64Sha256("path/to/private.key")),
                Map.entry("certificate", computeFileBase64Sha256("path/to/certificate.crt"))
            ))
            .build());

    }
}

import pulumi
import base64
import hashlib
import pulumi_gcp as gcp
import pulumi_random as random

def computeFilebase64sha256(path):
	fileData = open(path).read().encode()
	hashedData = hashlib.sha256(fileData.encode()).digest()
	return base64.b64encode(hashedData).decode()

# You may also want to control name generation explicitly:
default = gcp.compute.RegionSslCertificate("default",
    region="us-central1",
    private_key=(lambda path: open(path).read())("path/to/private.key"),
    certificate=(lambda path: open(path).read())("path/to/certificate.crt"))
certificate = random.RandomId("certificate",
    byte_length=4,
    prefix="my-certificate-",
    keepers={
        "private_key": computeFilebase64sha256("path/to/private.key"),
        "certificate": computeFilebase64sha256("path/to/certificate.crt"),
    })

import * as pulumi from "@pulumi/pulumi";
import * as crypto from "crypto";
import * as fs from "fs";
import * as gcp from "@pulumi/gcp";
import * as random from "@pulumi/random";

function computeFilebase64sha256(path string) string {
	const fileData = Buffer.from(fs.readFileSync(path), 'binary')
	return crypto.createHash('sha256').update(fileData).digest('hex')
}

// You may also want to control name generation explicitly:
const _default = new gcp.compute.RegionSslCertificate("default", {
    region: "us-central1",
    privateKey: fs.readFileSync("path/to/private.key"),
    certificate: fs.readFileSync("path/to/certificate.crt"),
});
const certificate = new random.RandomId("certificate", {
    byteLength: 4,
    prefix: "my-certificate-",
    keepers: {
        private_key: computeFilebase64sha256("path/to/private.key"),
        certificate: computeFilebase64sha256("path/to/certificate.crt"),
    },
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionSslCertificate;
import com.pulumi.gcp.compute.RegionSslCertificateArgs;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.gcp.compute.RegionUrlMap;
import com.pulumi.gcp.compute.RegionUrlMapArgs;
import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
import com.pulumi.gcp.compute.RegionTargetHttpsProxy;
import com.pulumi.gcp.compute.RegionTargetHttpsProxyArgs;
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 defaultRegionSslCertificate = new RegionSslCertificate("defaultRegionSslCertificate", RegionSslCertificateArgs.builder()        
            .region("us-central1")
            .namePrefix("my-certificate-")
            .privateKey(Files.readString(Paths.get("path/to/private.key")))
            .certificate(Files.readString(Paths.get("path/to/certificate.crt")))
            .build());

        var defaultRegionHealthCheck = new RegionHealthCheck("defaultRegionHealthCheck", RegionHealthCheckArgs.builder()        
            .region("us-central1")
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());

        var defaultRegionBackendService = new RegionBackendService("defaultRegionBackendService", RegionBackendServiceArgs.builder()        
            .region("us-central1")
            .protocol("HTTP")
            .loadBalancingScheme("INTERNAL_MANAGED")
            .timeoutSec(10)
            .healthChecks(defaultRegionHealthCheck.id())
            .build());

        var defaultRegionUrlMap = new RegionUrlMap("defaultRegionUrlMap", RegionUrlMapArgs.builder()        
            .region("us-central1")
            .description("a description")
            .defaultService(defaultRegionBackendService.id())
            .hostRules(RegionUrlMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(defaultRegionBackendService.id())
                .pathRules(RegionUrlMapPathMatcherPathRuleArgs.builder()
                    .paths("/*")
                    .service(defaultRegionBackendService.id())
                    .build())
                .build())
            .build());

        var defaultRegionTargetHttpsProxy = new RegionTargetHttpsProxy("defaultRegionTargetHttpsProxy", RegionTargetHttpsProxyArgs.builder()        
            .region("us-central1")
            .urlMap(defaultRegionUrlMap.id())
            .sslCertificates(defaultRegionSslCertificate.id())
            .build());

    }
}

resources:
  # Using with Region Target HTTPS Proxies
  # //
  # // SSL certificates cannot be updated after creation. In order to apply
  # // the specified configuration, the provider will destroy the existing
  # // resource and create a replacement. To effectively use an SSL
  # // certificate resource with a Target HTTPS Proxy resource, it's
  # // recommended to specify create_before_destroy in a lifecycle block.
  # // Either omit the Instance Template name attribute, specify a partial
  # // name with name_prefix, or use random_id resource. Example:
  defaultRegionSslCertificate:
    type: gcp:compute:RegionSslCertificate
    properties:
      region: us-central1
      namePrefix: my-certificate-
      privateKey:
        fn::readFile: path/to/private.key
      certificate:
        fn::readFile: path/to/certificate.crt
  defaultRegionTargetHttpsProxy:
    type: gcp:compute:RegionTargetHttpsProxy
    properties:
      region: us-central1
      urlMap: ${defaultRegionUrlMap.id}
      sslCertificates:
        - ${defaultRegionSslCertificate.id}
  defaultRegionUrlMap:
    type: gcp:compute:RegionUrlMap
    properties:
      region: us-central1
      description: a description
      defaultService: ${defaultRegionBackendService.id}
      hostRules:
        - hosts:
            - mysite.com
          pathMatcher: allpaths
      pathMatchers:
        - name: allpaths
          defaultService: ${defaultRegionBackendService.id}
          pathRules:
            - paths:
                - /*
              service: ${defaultRegionBackendService.id}
  defaultRegionBackendService:
    type: gcp:compute:RegionBackendService
    properties:
      region: us-central1
      protocol: HTTP
      loadBalancingScheme: INTERNAL_MANAGED
      timeoutSec: 10
      healthChecks:
        - ${defaultRegionHealthCheck.id}
  defaultRegionHealthCheck:
    type: gcp:compute:RegionHealthCheck
    properties:
      region: us-central1
      httpHealthCheck:
        port: 80