BackendBucketSignedUrlKey

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as random from "@pulumi/random";
const urlSignature = new random.RandomId("url_signature", {byteLength: 16});
const bucket = new gcp.storage.Bucket("bucket", {
    name: "test-storage-bucket",
    location: "EU",
});
const testBackend = new gcp.compute.BackendBucket("test_backend", {
    name: "test-signed-backend-bucket",
    description: "Contains beautiful images",
    bucketName: bucket.name,
    enableCdn: true,
});
const backendKey = new gcp.compute.BackendBucketSignedUrlKey("backend_key", {
    name: "test-key",
    keyValue: urlSignature.b64Url,
    backendBucket: testBackend.name,
});

import pulumi
import pulumi_gcp as gcp
import pulumi_random as random
url_signature = random.RandomId("url_signature", byte_length=16)
bucket = gcp.storage.Bucket("bucket",
    name="test-storage-bucket",
    location="EU")
test_backend = gcp.compute.BackendBucket("test_backend",
    name="test-signed-backend-bucket",
    description="Contains beautiful images",
    bucket_name=bucket.name,
    enable_cdn=True)
backend_key = gcp.compute.BackendBucketSignedUrlKey("backend_key",
    name="test-key",
    key_value=url_signature.b64_url,
    backend_bucket=test_backend.name)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Random = Pulumi.Random;
return await Deployment.RunAsync(() =>
{
    var urlSignature = new Random.RandomId("url_signature", new()
    {
        ByteLength = 16,
    });
    var bucket = new Gcp.Storage.Bucket("bucket", new()
    {
        Name = "test-storage-bucket",
        Location = "EU",
    });
    var testBackend = new Gcp.Compute.BackendBucket("test_backend", new()
    {
        Name = "test-signed-backend-bucket",
        Description = "Contains beautiful images",
        BucketName = bucket.Name,
        EnableCdn = true,
    });
    var backendKey = new Gcp.Compute.BackendBucketSignedUrlKey("backend_key", new()
    {
        Name = "test-key",
        KeyValue = urlSignature.B64Url,
        BackendBucket = testBackend.Name,
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/storage"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		urlSignature, err := random.NewRandomId(ctx, "url_signature", &random.RandomIdArgs{
			ByteLength: pulumi.Int(16),
		})
		if err != nil {
			return err
		}
		bucket, err := storage.NewBucket(ctx, "bucket", &storage.BucketArgs{
			Name:     pulumi.String("test-storage-bucket"),
			Location: pulumi.String("EU"),
		})
		if err != nil {
			return err
		}
		testBackend, err := compute.NewBackendBucket(ctx, "test_backend", &compute.BackendBucketArgs{
			Name:        pulumi.String("test-signed-backend-bucket"),
			Description: pulumi.String("Contains beautiful images"),
			BucketName:  bucket.Name,
			EnableCdn:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendBucketSignedUrlKey(ctx, "backend_key", &compute.BackendBucketSignedUrlKeyArgs{
			Name:          pulumi.String("test-key"),
			KeyValue:      urlSignature.B64Url,
			BackendBucket: testBackend.Name,
		})
		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.random.RandomId;
import com.pulumi.random.RandomIdArgs;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.compute.BackendBucket;
import com.pulumi.gcp.compute.BackendBucketArgs;
import com.pulumi.gcp.compute.BackendBucketSignedUrlKey;
import com.pulumi.gcp.compute.BackendBucketSignedUrlKeyArgs;
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 urlSignature = new RandomId("urlSignature", RandomIdArgs.builder()
            .byteLength(16)
            .build());
        var bucket = new Bucket("bucket", BucketArgs.builder()
            .name("test-storage-bucket")
            .location("EU")
            .build());
        var testBackend = new BackendBucket("testBackend", BackendBucketArgs.builder()
            .name("test-signed-backend-bucket")
            .description("Contains beautiful images")
            .bucketName(bucket.name())
            .enableCdn(true)
            .build());
        var backendKey = new BackendBucketSignedUrlKey("backendKey", BackendBucketSignedUrlKeyArgs.builder()
            .name("test-key")
            .keyValue(urlSignature.b64Url())
            .backendBucket(testBackend.name())
            .build());
    }
}

resources:
  urlSignature:
    type: random:RandomId
    name: url_signature
    properties:
      byteLength: 16
  backendKey:
    type: gcp:compute:BackendBucketSignedUrlKey
    name: backend_key
    properties:
      name: test-key
      keyValue: ${urlSignature.b64Url}
      backendBucket: ${testBackend.name}
  testBackend:
    type: gcp:compute:BackendBucket
    name: test_backend
    properties:
      name: test-signed-backend-bucket
      description: Contains beautiful images
      bucketName: ${bucket.name}
      enableCdn: true
  bucket:
    type: gcp:storage:Bucket
    properties:
      name: test-storage-bucket
      location: EU