gcp.compute.SSLCertificate

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.SSLCertificate("default", new()
    {
        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/v6/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.NewSSLCertificate(ctx, "default", &compute.SSLCertificateArgs{
			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.SSLCertificate;
import com.pulumi.gcp.compute.SSLCertificateArgs;
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 SSLCertificate("default", SSLCertificateArgs.builder()        
            .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.SSLCertificate("default",
    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.SSLCertificate("default", {
    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:SSLCertificate
    properties:
      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.SSLCertificate("default", new()
    {
        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/v6/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.NewSSLCertificate(ctx, "default", &compute.SSLCertificateArgs{
			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.AnyMap{
				"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.SSLCertificate;
import com.pulumi.gcp.compute.SSLCertificateArgs;
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 SSLCertificate("default", SSLCertificateArgs.builder()        
            .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.SSLCertificate("default",
    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.SSLCertificate("default", {
    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.SSLCertificate;
import com.pulumi.gcp.compute.SSLCertificateArgs;
import com.pulumi.gcp.compute.HttpHealthCheck;
import com.pulumi.gcp.compute.HttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
import com.pulumi.gcp.compute.TargetHttpsProxy;
import com.pulumi.gcp.compute.TargetHttpsProxyArgs;
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 defaultSSLCertificate = new SSLCertificate("defaultSSLCertificate", SSLCertificateArgs.builder()        
            .namePrefix("my-certificate-")
            .privateKey(Files.readString(Paths.get("path/to/private.key")))
            .certificate(Files.readString(Paths.get("path/to/certificate.crt")))
            .build());

        var defaultHttpHealthCheck = new HttpHealthCheck("defaultHttpHealthCheck", HttpHealthCheckArgs.builder()        
            .requestPath("/")
            .checkIntervalSec(1)
            .timeoutSec(1)
            .build());

        var defaultBackendService = new BackendService("defaultBackendService", BackendServiceArgs.builder()        
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(defaultHttpHealthCheck.id())
            .build());

        var defaultURLMap = new URLMap("defaultURLMap", URLMapArgs.builder()        
            .description("a description")
            .defaultService(defaultBackendService.id())
            .hostRules(URLMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(URLMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(defaultBackendService.id())
                .pathRules(URLMapPathMatcherPathRuleArgs.builder()
                    .paths("/*")
                    .service(defaultBackendService.id())
                    .build())
                .build())
            .build());

        var defaultTargetHttpsProxy = new TargetHttpsProxy("defaultTargetHttpsProxy", TargetHttpsProxyArgs.builder()        
            .urlMap(defaultURLMap.id())
            .sslCertificates(defaultSSLCertificate.id())
            .build());

    }
}

resources:
  # Using with 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. Example:
  defaultSSLCertificate:
    type: gcp:compute:SSLCertificate
    properties:
      namePrefix: my-certificate-
      privateKey:
        fn::readFile: path/to/private.key
      certificate:
        fn::readFile: path/to/certificate.crt
  defaultTargetHttpsProxy:
    type: gcp:compute:TargetHttpsProxy
    properties:
      urlMap: ${defaultURLMap.id}
      sslCertificates:
        - ${defaultSSLCertificate.id}
  defaultURLMap:
    type: gcp:compute:URLMap
    properties:
      description: a description
      defaultService: ${defaultBackendService.id}
      hostRules:
        - hosts:
            - mysite.com
          pathMatcher: allpaths
      pathMatchers:
        - name: allpaths
          defaultService: ${defaultBackendService.id}
          pathRules:
            - paths:
                - /*
              service: ${defaultBackendService.id}
  defaultBackendService:
    type: gcp:compute:BackendService
    properties:
      portName: http
      protocol: HTTP
      timeoutSec: 10
      healthChecks:
        - ${defaultHttpHealthCheck.id}
  defaultHttpHealthCheck:
    type: gcp:compute:HttpHealthCheck
    properties:
      requestPath: /
      checkIntervalSec: 1
      timeoutSec: 1