pulumi-gcp-kotlin/com.pulumi.gcp.compute.kotlin/BackendBucketArgs

BackendBucketArgs

data class BackendBucketArgs(val bucketName: Output<String>? = null, val cdnPolicy: Output<BackendBucketCdnPolicyArgs>? = null, val compressionMode: Output<String>? = null, val customResponseHeaders: Output<List<String>>? = null, val description: Output<String>? = null, val edgeSecurityPolicy: Output<String>? = null, val enableCdn: Output<Boolean>? = null, val name: Output<String>? = null, val project: Output<String>? = null) : ConvertibleToJava<BackendBucketArgs>

Backend buckets allow you to use Google Cloud Storage buckets with HTTP(S) load balancing. An HTTP(S) load balancer can direct traffic to specified URLs to a backend bucket rather than a backend service. It can send requests for static content to a Cloud Storage bucket and requests for dynamic content to a virtual machine instance. To get more information about BackendBucket, see:

Example Usage

Backend Bucket Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const imageBucket = new gcp.storage.Bucket("image_bucket", {
    name: "image-store-bucket",
    location: "EU",
});
const imageBackend = new gcp.compute.BackendBucket("image_backend", {
    name: "image-backend-bucket",
    description: "Contains beautiful images",
    bucketName: imageBucket.name,
    enableCdn: true,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
image_bucket = gcp.storage.Bucket("image_bucket",
    name="image-store-bucket",
    location="EU")
image_backend = gcp.compute.BackendBucket("image_backend",
    name="image-backend-bucket",
    description="Contains beautiful images",
    bucket_name=image_bucket.name,
    enable_cdn=True)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var imageBucket = new Gcp.Storage.Bucket("image_bucket", new()
    {
        Name = "image-store-bucket",
        Location = "EU",
    });
    var imageBackend = new Gcp.Compute.BackendBucket("image_backend", new()
    {
        Name = "image-backend-bucket",
        Description = "Contains beautiful images",
        BucketName = imageBucket.Name,
        EnableCdn = true,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		imageBucket, err := storage.NewBucket(ctx, "image_bucket", &storage.BucketArgs{
			Name:     pulumi.String("image-store-bucket"),
			Location: pulumi.String("EU"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendBucket(ctx, "image_backend", &compute.BackendBucketArgs{
			Name:        pulumi.String("image-backend-bucket"),
			Description: pulumi.String("Contains beautiful images"),
			BucketName:  imageBucket.Name,
			EnableCdn:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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 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 imageBucket = new Bucket("imageBucket", BucketArgs.builder()
            .name("image-store-bucket")
            .location("EU")
            .build());
        var imageBackend = new BackendBucket("imageBackend", BackendBucketArgs.builder()
            .name("image-backend-bucket")
            .description("Contains beautiful images")
            .bucketName(imageBucket.name())
            .enableCdn(true)
            .build());
    }
}
Content copied to clipboard
resources:
  imageBackend:
    type: gcp:compute:BackendBucket
    name: image_backend
    properties:
      name: image-backend-bucket
      description: Contains beautiful images
      bucketName: ${imageBucket.name}
      enableCdn: true
  imageBucket:
    type: gcp:storage:Bucket
    name: image_bucket
    properties:
      name: image-store-bucket
      location: EU
Content copied to clipboard

Backend Bucket Security Policy

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const imageBackendBucket = new gcp.storage.Bucket("image_backend", {
    name: "image-store-bucket",
    location: "EU",
});
const policy = new gcp.compute.SecurityPolicy("policy", {
    name: "image-store-bucket",
    description: "basic security policy",
    type: "CLOUD_ARMOR_EDGE",
});
const imageBackend = new gcp.compute.BackendBucket("image_backend", {
    name: "image-backend-bucket",
    description: "Contains beautiful images",
    bucketName: imageBackendBucket.name,
    enableCdn: true,
    edgeSecurityPolicy: policy.id,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
image_backend_bucket = gcp.storage.Bucket("image_backend",
    name="image-store-bucket",
    location="EU")
policy = gcp.compute.SecurityPolicy("policy",
    name="image-store-bucket",
    description="basic security policy",
    type="CLOUD_ARMOR_EDGE")
image_backend = gcp.compute.BackendBucket("image_backend",
    name="image-backend-bucket",
    description="Contains beautiful images",
    bucket_name=image_backend_bucket.name,
    enable_cdn=True,
    edge_security_policy=policy.id)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var imageBackendBucket = new Gcp.Storage.Bucket("image_backend", new()
    {
        Name = "image-store-bucket",
        Location = "EU",
    });
    var policy = new Gcp.Compute.SecurityPolicy("policy", new()
    {
        Name = "image-store-bucket",
        Description = "basic security policy",
        Type = "CLOUD_ARMOR_EDGE",
    });
    var imageBackend = new Gcp.Compute.BackendBucket("image_backend", new()
    {
        Name = "image-backend-bucket",
        Description = "Contains beautiful images",
        BucketName = imageBackendBucket.Name,
        EnableCdn = true,
        EdgeSecurityPolicy = policy.Id,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		imageBackendBucket, err := storage.NewBucket(ctx, "image_backend", &storage.BucketArgs{
			Name:     pulumi.String("image-store-bucket"),
			Location: pulumi.String("EU"),
		})
		if err != nil {
			return err
		}
		policy, err := compute.NewSecurityPolicy(ctx, "policy", &compute.SecurityPolicyArgs{
			Name:        pulumi.String("image-store-bucket"),
			Description: pulumi.String("basic security policy"),
			Type:        pulumi.String("CLOUD_ARMOR_EDGE"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendBucket(ctx, "image_backend", &compute.BackendBucketArgs{
			Name:               pulumi.String("image-backend-bucket"),
			Description:        pulumi.String("Contains beautiful images"),
			BucketName:         imageBackendBucket.Name,
			EnableCdn:          pulumi.Bool(true),
			EdgeSecurityPolicy: policy.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.compute.SecurityPolicy;
import com.pulumi.gcp.compute.SecurityPolicyArgs;
import com.pulumi.gcp.compute.BackendBucket;
import com.pulumi.gcp.compute.BackendBucketArgs;
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 imageBackendBucket = new Bucket("imageBackendBucket", BucketArgs.builder()
            .name("image-store-bucket")
            .location("EU")
            .build());
        var policy = new SecurityPolicy("policy", SecurityPolicyArgs.builder()
            .name("image-store-bucket")
            .description("basic security policy")
            .type("CLOUD_ARMOR_EDGE")
            .build());
        var imageBackend = new BackendBucket("imageBackend", BackendBucketArgs.builder()
            .name("image-backend-bucket")
            .description("Contains beautiful images")
            .bucketName(imageBackendBucket.name())
            .enableCdn(true)
            .edgeSecurityPolicy(policy.id())
            .build());
    }
}
Content copied to clipboard
resources:
  imageBackend:
    type: gcp:compute:BackendBucket
    name: image_backend
    properties:
      name: image-backend-bucket
      description: Contains beautiful images
      bucketName: ${imageBackendBucket.name}
      enableCdn: true
      edgeSecurityPolicy: ${policy.id}
  imageBackendBucket:
    type: gcp:storage:Bucket
    name: image_backend
    properties:
      name: image-store-bucket
      location: EU
  policy:
    type: gcp:compute:SecurityPolicy
    properties:
      name: image-store-bucket
      description: basic security policy
      type: CLOUD_ARMOR_EDGE
Content copied to clipboard

Backend Bucket Query String Whitelist

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const imageBucket = new gcp.storage.Bucket("image_bucket", {
    name: "image-backend-bucket",
    location: "EU",
});
const imageBackend = new gcp.compute.BackendBucket("image_backend", {
    name: "image-backend-bucket",
    description: "Contains beautiful images",
    bucketName: imageBucket.name,
    enableCdn: true,
    cdnPolicy: {
        cacheKeyPolicy: {
            queryStringWhitelists: ["image-version"],
        },
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
image_bucket = gcp.storage.Bucket("image_bucket",
    name="image-backend-bucket",
    location="EU")
image_backend = gcp.compute.BackendBucket("image_backend",
    name="image-backend-bucket",
    description="Contains beautiful images",
    bucket_name=image_bucket.name,
    enable_cdn=True,
    cdn_policy={
        "cache_key_policy": {
            "query_string_whitelists": ["image-version"],
        },
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var imageBucket = new Gcp.Storage.Bucket("image_bucket", new()
    {
        Name = "image-backend-bucket",
        Location = "EU",
    });
    var imageBackend = new Gcp.Compute.BackendBucket("image_backend", new()
    {
        Name = "image-backend-bucket",
        Description = "Contains beautiful images",
        BucketName = imageBucket.Name,
        EnableCdn = true,
        CdnPolicy = new Gcp.Compute.Inputs.BackendBucketCdnPolicyArgs
        {
            CacheKeyPolicy = new Gcp.Compute.Inputs.BackendBucketCdnPolicyCacheKeyPolicyArgs
            {
                QueryStringWhitelists = new[]
                {
                    "image-version",
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		imageBucket, err := storage.NewBucket(ctx, "image_bucket", &storage.BucketArgs{
			Name:     pulumi.String("image-backend-bucket"),
			Location: pulumi.String("EU"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendBucket(ctx, "image_backend", &compute.BackendBucketArgs{
			Name:        pulumi.String("image-backend-bucket"),
			Description: pulumi.String("Contains beautiful images"),
			BucketName:  imageBucket.Name,
			EnableCdn:   pulumi.Bool(true),
			CdnPolicy: &compute.BackendBucketCdnPolicyArgs{
				CacheKeyPolicy: &compute.BackendBucketCdnPolicyCacheKeyPolicyArgs{
					QueryStringWhitelists: pulumi.StringArray{
						pulumi.String("image-version"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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.inputs.BackendBucketCdnPolicyArgs;
import com.pulumi.gcp.compute.inputs.BackendBucketCdnPolicyCacheKeyPolicyArgs;
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 imageBucket = new Bucket("imageBucket", BucketArgs.builder()
            .name("image-backend-bucket")
            .location("EU")
            .build());
        var imageBackend = new BackendBucket("imageBackend", BackendBucketArgs.builder()
            .name("image-backend-bucket")
            .description("Contains beautiful images")
            .bucketName(imageBucket.name())
            .enableCdn(true)
            .cdnPolicy(BackendBucketCdnPolicyArgs.builder()
                .cacheKeyPolicy(BackendBucketCdnPolicyCacheKeyPolicyArgs.builder()
                    .queryStringWhitelists("image-version")
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  imageBackend:
    type: gcp:compute:BackendBucket
    name: image_backend
    properties:
      name: image-backend-bucket
      description: Contains beautiful images
      bucketName: ${imageBucket.name}
      enableCdn: true
      cdnPolicy:
        cacheKeyPolicy:
          queryStringWhitelists:
            - image-version
  imageBucket:
    type: gcp:storage:Bucket
    name: image_bucket
    properties:
      name: image-backend-bucket
      location: EU
Content copied to clipboard

Backend Bucket Include Http Headers

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const imageBucket = new gcp.storage.Bucket("image_bucket", {
    name: "image-backend-bucket",
    location: "EU",
});
const imageBackend = new gcp.compute.BackendBucket("image_backend", {
    name: "image-backend-bucket",
    description: "Contains beautiful images",
    bucketName: imageBucket.name,
    enableCdn: true,
    cdnPolicy: {
        cacheKeyPolicy: {
            includeHttpHeaders: ["X-My-Header-Field"],
        },
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
image_bucket = gcp.storage.Bucket("image_bucket",
    name="image-backend-bucket",
    location="EU")
image_backend = gcp.compute.BackendBucket("image_backend",
    name="image-backend-bucket",
    description="Contains beautiful images",
    bucket_name=image_bucket.name,
    enable_cdn=True,
    cdn_policy={
        "cache_key_policy": {
            "include_http_headers": ["X-My-Header-Field"],
        },
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var imageBucket = new Gcp.Storage.Bucket("image_bucket", new()
    {
        Name = "image-backend-bucket",
        Location = "EU",
    });
    var imageBackend = new Gcp.Compute.BackendBucket("image_backend", new()
    {
        Name = "image-backend-bucket",
        Description = "Contains beautiful images",
        BucketName = imageBucket.Name,
        EnableCdn = true,
        CdnPolicy = new Gcp.Compute.Inputs.BackendBucketCdnPolicyArgs
        {
            CacheKeyPolicy = new Gcp.Compute.Inputs.BackendBucketCdnPolicyCacheKeyPolicyArgs
            {
                IncludeHttpHeaders = new[]
                {
                    "X-My-Header-Field",
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		imageBucket, err := storage.NewBucket(ctx, "image_bucket", &storage.BucketArgs{
			Name:     pulumi.String("image-backend-bucket"),
			Location: pulumi.String("EU"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewBackendBucket(ctx, "image_backend", &compute.BackendBucketArgs{
			Name:        pulumi.String("image-backend-bucket"),
			Description: pulumi.String("Contains beautiful images"),
			BucketName:  imageBucket.Name,
			EnableCdn:   pulumi.Bool(true),
			CdnPolicy: &compute.BackendBucketCdnPolicyArgs{
				CacheKeyPolicy: &compute.BackendBucketCdnPolicyCacheKeyPolicyArgs{
					IncludeHttpHeaders: pulumi.StringArray{
						pulumi.String("X-My-Header-Field"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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.inputs.BackendBucketCdnPolicyArgs;
import com.pulumi.gcp.compute.inputs.BackendBucketCdnPolicyCacheKeyPolicyArgs;
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 imageBucket = new Bucket("imageBucket", BucketArgs.builder()
            .name("image-backend-bucket")
            .location("EU")
            .build());
        var imageBackend = new BackendBucket("imageBackend", BackendBucketArgs.builder()
            .name("image-backend-bucket")
            .description("Contains beautiful images")
            .bucketName(imageBucket.name())
            .enableCdn(true)
            .cdnPolicy(BackendBucketCdnPolicyArgs.builder()
                .cacheKeyPolicy(BackendBucketCdnPolicyCacheKeyPolicyArgs.builder()
                    .includeHttpHeaders("X-My-Header-Field")
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  imageBackend:
    type: gcp:compute:BackendBucket
    name: image_backend
    properties:
      name: image-backend-bucket
      description: Contains beautiful images
      bucketName: ${imageBucket.name}
      enableCdn: true
      cdnPolicy:
        cacheKeyPolicy:
          includeHttpHeaders:
            - X-My-Header-Field
  imageBucket:
    type: gcp:storage:Bucket
    name: image_bucket
    properties:
      name: image-backend-bucket
      location: EU
Content copied to clipboard

Import

BackendBucket can be imported using any of these accepted formats:

  • projects/{{project}}/global/backendBuckets/{{name}}

  • {{project}}/{{name}}

  • {{name}} When using the pulumi import command, BackendBucket can be imported using one of the formats above. For example:

$ pulumi import gcp:compute/backendBucket:BackendBucket default projects/{{project}}/global/backendBuckets/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/backendBucket:BackendBucket default {{project}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/backendBucket:BackendBucket default {{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(bucketName: Output<String>? = null, cdnPolicy: Output<BackendBucketCdnPolicyArgs>? = null, compressionMode: Output<String>? = null, customResponseHeaders: Output<List<String>>? = null, description: Output<String>? = null, edgeSecurityPolicy: Output<String>? = null, enableCdn: Output<Boolean>? = null, name: Output<String>? = null, project: Output<String>? = null)

Properties

Link copied to clipboard
val bucketName: Output<String>? = null

Cloud Storage bucket name.

Link copied to clipboard
val cdnPolicy: Output<BackendBucketCdnPolicyArgs>? = null

Cloud CDN configuration for this Backend Bucket. Structure is documented below.

Link copied to clipboard
val compressionMode: Output<String>? = null

Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. Possible values are: AUTOMATIC, DISABLED.

Link copied to clipboard
val customResponseHeaders: Output<List<String>>? = null

Headers that the HTTP/S load balancer should add to proxied responses.

Link copied to clipboard
val description: Output<String>? = null

An optional textual description of the resource; provided by the client when the resource is created.

Link copied to clipboard
val edgeSecurityPolicy: Output<String>? = null

The security policy associated with this backend bucket.

Link copied to clipboard
val enableCdn: Output<Boolean>? = null

If true, enable Cloud CDN for this BackendBucket.

Link copied to clipboard
val name: Output<String>? = null

Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.

Link copied to clipboard
val project: Output<String>? = null

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

Functions

Link copied to clipboard
open override fun toJava(): BackendBucketArgs