Distribution class

Manages a Lightsail content delivery network (CDN) distribution. Use this resource to cache content at edge locations and reduce latency for users accessing your content.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.lightsail.Bucket("example", {
    name: "example-bucket",
    bundleId: "small_1_0",
});
const exampleDistribution = new aws.lightsail.Distribution("example", {
    origin: {
        name: example.name,
        regionName: example.region,
    },
    defaultCacheBehavior: {
        behavior: "cache",
    },
    cacheBehaviorSettings: {
        forwardedCookies: {
            option: "none",
        },
        forwardedHeaders: {
            option: "default",
        },
        forwardedQueryStrings: {
            option: false,
        },
        allowedHttpMethods: "GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE",
        cachedHttpMethods: "GET,HEAD",
        defaultTtl: 86400,
        maximumTtl: 31536000,
        minimumTtl: 0,
    },
    name: "example-distribution",
    bundleId: "small_1_0",
});
import pulumi
import pulumi_aws as aws

example = aws.lightsail.Bucket("example",
    name="example-bucket",
    bundle_id="small_1_0")
example_distribution = aws.lightsail.Distribution("example",
    origin={
        "name": example.name,
        "region_name": example.region,
    },
    default_cache_behavior={
        "behavior": "cache",
    },
    cache_behavior_settings={
        "forwarded_cookies": {
            "option": "none",
        },
        "forwarded_headers": {
            "option": "default",
        },
        "forwarded_query_strings": {
            "option": False,
        },
        "allowed_http_methods": "GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE",
        "cached_http_methods": "GET,HEAD",
        "default_ttl": 86400,
        "maximum_ttl": 31536000,
        "minimum_ttl": 0,
    },
    name="example-distribution",
    bundle_id="small_1_0")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.LightSail.Bucket("example", new()
    {
        Name = "example-bucket",
        BundleId = "small_1_0",
    });

    var exampleDistribution = new Aws.LightSail.Distribution("example", new()
    {
        Origin = new Aws.LightSail.Inputs.DistributionOriginArgs
        {
            Name = example.Name,
            RegionName = example.Region,
        },
        DefaultCacheBehavior = new Aws.LightSail.Inputs.DistributionDefaultCacheBehaviorArgs
        {
            Behavior = "cache",
        },
        CacheBehaviorSettings = new Aws.LightSail.Inputs.DistributionCacheBehaviorSettingsArgs
        {
            ForwardedCookies = new Aws.LightSail.Inputs.DistributionCacheBehaviorSettingsForwardedCookiesArgs
            {
                Option = "none",
            },
            ForwardedHeaders = new Aws.LightSail.Inputs.DistributionCacheBehaviorSettingsForwardedHeadersArgs
            {
                Option = "default",
            },
            ForwardedQueryStrings = new Aws.LightSail.Inputs.DistributionCacheBehaviorSettingsForwardedQueryStringsArgs
            {
                Option = false,
            },
            AllowedHttpMethods = "GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE",
            CachedHttpMethods = "GET,HEAD",
            DefaultTtl = 86400,
            MaximumTtl = 31536000,
            MinimumTtl = 0,
        },
        Name = "example-distribution",
        BundleId = "small_1_0",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lightsail"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := lightsail.NewBucket(ctx, "example", &lightsail.BucketArgs{
			Name:     pulumi.String("example-bucket"),
			BundleId: pulumi.String("small_1_0"),
		})
		if err != nil {
			return err
		}
		_, err = lightsail.NewDistribution(ctx, "example", &lightsail.DistributionArgs{
			Origin: &lightsail.DistributionOriginArgs{
				Name:       example.Name,
				RegionName: example.Region,
			},
			DefaultCacheBehavior: &lightsail.DistributionDefaultCacheBehaviorArgs{
				Behavior: pulumi.String("cache"),
			},
			CacheBehaviorSettings: &lightsail.DistributionCacheBehaviorSettingsArgs{
				ForwardedCookies: &lightsail.DistributionCacheBehaviorSettingsForwardedCookiesArgs{
					Option: pulumi.String("none"),
				},
				ForwardedHeaders: &lightsail.DistributionCacheBehaviorSettingsForwardedHeadersArgs{
					Option: pulumi.String("default"),
				},
				ForwardedQueryStrings: &lightsail.DistributionCacheBehaviorSettingsForwardedQueryStringsArgs{
					Option: pulumi.Bool(false),
				},
				AllowedHttpMethods: pulumi.String("GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE"),
				CachedHttpMethods:  pulumi.String("GET,HEAD"),
				DefaultTtl:         pulumi.Int(86400),
				MaximumTtl:         pulumi.Int(31536000),
				MinimumTtl:         pulumi.Int(0),
			},
			Name:     pulumi.String("example-distribution"),
			BundleId: pulumi.String("small_1_0"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_lightsail_bucket" "example" {
  name      = "example-bucket"
  bundle_id = "small_1_0"
}
resource "aws_lightsail_distribution" "example" {
  origin = {
    name        = aws_lightsail_bucket.example.name
    region_name = aws_lightsail_bucket.example.region
  }
  default_cache_behavior = {
    behavior = "cache"
  }
  cache_behavior_settings = {
    forwarded_cookies = {
      option = "none"
    }
    forwarded_headers = {
      option = "default"
    }
    forwarded_query_strings = {
      option = false
    }
    allowed_http_methods = "GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE"
    cached_http_methods  = "GET,HEAD"
    default_ttl          = 86400
    maximum_ttl          = 31536000
    minimum_ttl          = 0
  }
  name      = "example-distribution"
  bundle_id = "small_1_0"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lightsail.Bucket;
import com.pulumi.aws.lightsail.BucketArgs;
import com.pulumi.aws.lightsail.Distribution;
import com.pulumi.aws.lightsail.DistributionArgs;
import com.pulumi.aws.lightsail.inputs.DistributionOriginArgs;
import com.pulumi.aws.lightsail.inputs.DistributionDefaultCacheBehaviorArgs;
import com.pulumi.aws.lightsail.inputs.DistributionCacheBehaviorSettingsArgs;
import com.pulumi.aws.lightsail.inputs.DistributionCacheBehaviorSettingsForwardedCookiesArgs;
import com.pulumi.aws.lightsail.inputs.DistributionCacheBehaviorSettingsForwardedHeadersArgs;
import com.pulumi.aws.lightsail.inputs.DistributionCacheBehaviorSettingsForwardedQueryStringsArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new Bucket("example", BucketArgs.builder()
            .name("example-bucket")
            .bundleId("small_1_0")
            .build());

        var exampleDistribution = new Distribution("exampleDistribution", DistributionArgs.builder()
            .origin(DistributionOriginArgs.builder()
                .name(example.name())
                .regionName(example.region())
                .build())
            .defaultCacheBehavior(DistributionDefaultCacheBehaviorArgs.builder()
                .behavior("cache")
                .build())
            .cacheBehaviorSettings(DistributionCacheBehaviorSettingsArgs.builder()
                .forwardedCookies(DistributionCacheBehaviorSettingsForwardedCookiesArgs.builder()
                    .option("none")
                    .build())
                .forwardedHeaders(DistributionCacheBehaviorSettingsForwardedHeadersArgs.builder()
                    .option("default")
                    .build())
                .forwardedQueryStrings(DistributionCacheBehaviorSettingsForwardedQueryStringsArgs.builder()
                    .option(false)
                    .build())
                .allowedHttpMethods("GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE")
                .cachedHttpMethods("GET,HEAD")
                .defaultTtl(86400)
                .maximumTtl(31536000)
                .minimumTtl(0)
                .build())
            .name("example-distribution")
            .bundleId("small_1_0")
            .build());

    }
}
resources:
  example:
    type: aws:lightsail:Bucket
    properties:
      name: example-bucket
      bundleId: small_1_0
  exampleDistribution:
    type: aws:lightsail:Distribution
    name: example
    properties:
      origin:
        name: ${example.name}
        regionName: ${example.region}
      defaultCacheBehavior:
        behavior: cache
      cacheBehaviorSettings:
        forwardedCookies:
          option: none
        forwardedHeaders:
          option: default
        forwardedQueryStrings:
          option: false
        allowedHttpMethods: GET,HEAD,OPTIONS,PUT,PATCH,POST,DELETE
        cachedHttpMethods: GET,HEAD
        defaultTtl: 86400
        maximumTtl: 3.1536e+07
        minimumTtl: 0
      name: example-distribution
      bundleId: small_1_0

Instance Origin

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const available = aws.getAvailabilityZones({
    filters: [{
        name: "opt-in-status",
        values: ["opt-in-not-required"],
    }],
    state: "available",
});
const exampleStaticIp = new aws.lightsail.StaticIp("example", {name: "example-static-ip"});
const exampleInstance = new aws.lightsail.Instance("example", {
    name: "example-instance",
    availabilityZone: available.then(available => available.names?.[0]),
    blueprintId: "amazon_linux_2",
    bundleId: "micro_1_0",
});
const example = new aws.lightsail.StaticIpAttachment("example", {
    staticIpName: exampleStaticIp.name,
    instanceName: exampleInstance.name,
});
const exampleDistribution = new aws.lightsail.Distribution("example", {
    origin: {
        name: exampleInstance.name,
        regionName: available.then(available => available.id),
    },
    defaultCacheBehavior: {
        behavior: "cache",
    },
    name: "example-distribution",
    bundleId: "small_1_0",
}, {
    dependsOn: [example],
});
import pulumi
import pulumi_aws as aws

available = aws.get_availability_zones(filters=[{
        "name": "opt-in-status",
        "values": ["opt-in-not-required"],
    }],
    state="available")
example_static_ip = aws.lightsail.StaticIp("example", name="example-static-ip")
example_instance = aws.lightsail.Instance("example",
    name="example-instance",
    availability_zone=available.names[0],
    blueprint_id="amazon_linux_2",
    bundle_id="micro_1_0")
example = aws.lightsail.StaticIpAttachment("example",
    static_ip_name=example_static_ip.name,
    instance_name=example_instance.name)
example_distribution = aws.lightsail.Distribution("example",
    origin={
        "name": example_instance.name,
        "region_name": available.id,
    },
    default_cache_behavior={
        "behavior": "cache",
    },
    name="example-distribution",
    bundle_id="small_1_0",
    opts = pulumi.ResourceOptions(depends_on=[example]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var available = Aws.GetAvailabilityZones.Invoke(new()
    {
        Filters = new[]
        {
            new Aws.Inputs.GetAvailabilityZonesFilterInputArgs
            {
                Name = "opt-in-status",
                Values = new[]
                {
                    "opt-in-not-required",
                },
            },
        },
        State = "available",
    });

    var exampleStaticIp = new Aws.LightSail.StaticIp("example", new()
    {
        Name = "example-static-ip",
    });

    var exampleInstance = new Aws.LightSail.Instance("example", new()
    {
        Name = "example-instance",
        AvailabilityZone = available.Apply(getAvailabilityZonesResult => getAvailabilityZonesResult.Names[0]),
        BlueprintId = "amazon_linux_2",
        BundleId = "micro_1_0",
    });

    var example = new Aws.LightSail.StaticIpAttachment("example", new()
    {
        StaticIpName = exampleStaticIp.Name,
        InstanceName = exampleInstance.Name,
    });

    var exampleDistribution = new Aws.LightSail.Distribution("example", new()
    {
        Origin = new Aws.LightSail.Inputs.DistributionOriginArgs
        {
            Name = exampleInstance.Name,
            RegionName = available.Apply(getAvailabilityZonesResult => getAvailabilityZonesResult.Id),
        },
        DefaultCacheBehavior = new Aws.LightSail.Inputs.DistributionDefaultCacheBehaviorArgs
        {
            Behavior = "cache",
        },
        Name = "example-distribution",
        BundleId = "small_1_0",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            example,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lightsail"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		available, err := aws.GetAvailabilityZones(ctx, &aws.GetAvailabilityZonesArgs{
			Filters: []aws.GetAvailabilityZonesFilter{
				{
					Name: "opt-in-status",
					Values: []string{
						"opt-in-not-required",
					},
				},
			},
			State: pulumi.StringRef("available"),
		}, nil)
		if err != nil {
			return err
		}
		exampleStaticIp, err := lightsail.NewStaticIp(ctx, "example", &lightsail.StaticIpArgs{
			Name: pulumi.String("example-static-ip"),
		})
		if err != nil {
			return err
		}
		exampleInstance, err := lightsail.NewInstance(ctx, "example", &lightsail.InstanceArgs{
			Name:             pulumi.String("example-instance"),
			AvailabilityZone: pulumi.String(available.Names[0]),
			BlueprintId:      pulumi.String("amazon_linux_2"),
			BundleId:         pulumi.String("micro_1_0"),
		})
		if err != nil {
			return err
		}
		example, err := lightsail.NewStaticIpAttachment(ctx, "example", &lightsail.StaticIpAttachmentArgs{
			StaticIpName: exampleStaticIp.Name,
			InstanceName: exampleInstance.Name,
		})
		if err != nil {
			return err
		}
		_, err = lightsail.NewDistribution(ctx, "example", &lightsail.DistributionArgs{
			Origin: &lightsail.DistributionOriginArgs{
				Name:       exampleInstance.Name,
				RegionName: pulumi.String(available.Id),
			},
			DefaultCacheBehavior: &lightsail.DistributionDefaultCacheBehaviorArgs{
				Behavior: pulumi.String("cache"),
			},
			Name:     pulumi.String("example-distribution"),
			BundleId: pulumi.String("small_1_0"),
		}, pulumi.DependsOn([]pulumi.Resource{
			example,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_getavailabilityzones" "available" {
  filters {
    name   = "opt-in-status"
    values = ["opt-in-not-required"]
  }
  state = "available"
}

resource "aws_lightsail_staticipattachment" "example" {
  static_ip_name = aws_lightsail_staticip.example.name
  instance_name  = aws_lightsail_instance.example.name
}
resource "aws_lightsail_staticip" "example" {
  name = "example-static-ip"
}
resource "aws_lightsail_instance" "example" {
  name              = "example-instance"
  availability_zone = data.aws_getavailabilityzones.available.names[0]
  blueprint_id      = "amazon_linux_2"
  bundle_id         = "micro_1_0"
}
resource "aws_lightsail_distribution" "example" {
  depends_on = [aws_lightsail_staticipattachment.example]
  origin = {
    name        = aws_lightsail_instance.example.name
    region_name = data.aws_getavailabilityzones.available.id
  }
  default_cache_behavior = {
    behavior = "cache"
  }
  name      = "example-distribution"
  bundle_id = "small_1_0"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetAvailabilityZonesArgs;
import com.pulumi.aws.inputs.GetAvailabilityZonesFilterArgs;
import com.pulumi.aws.lightsail.StaticIp;
import com.pulumi.aws.lightsail.StaticIpArgs;
import com.pulumi.aws.lightsail.Instance;
import com.pulumi.aws.lightsail.InstanceArgs;
import com.pulumi.aws.lightsail.StaticIpAttachment;
import com.pulumi.aws.lightsail.StaticIpAttachmentArgs;
import com.pulumi.aws.lightsail.Distribution;
import com.pulumi.aws.lightsail.DistributionArgs;
import com.pulumi.aws.lightsail.inputs.DistributionOriginArgs;
import com.pulumi.aws.lightsail.inputs.DistributionDefaultCacheBehaviorArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        final var available = AwsFunctions.getAvailabilityZones(GetAvailabilityZonesArgs.builder()
            .filters(GetAvailabilityZonesFilterArgs.builder()
                .name("opt-in-status")
                .values("opt-in-not-required")
                .build())
            .state("available")
            .build());

        var exampleStaticIp = new StaticIp("exampleStaticIp", StaticIpArgs.builder()
            .name("example-static-ip")
            .build());

        var exampleInstance = new Instance("exampleInstance", InstanceArgs.builder()
            .name("example-instance")
            .availabilityZone(available.names()[0])
            .blueprintId("amazon_linux_2")
            .bundleId("micro_1_0")
            .build());

        var example = new StaticIpAttachment("example", StaticIpAttachmentArgs.builder()
            .staticIpName(exampleStaticIp.name())
            .instanceName(exampleInstance.name())
            .build());

        var exampleDistribution = new Distribution("exampleDistribution", DistributionArgs.builder()
            .origin(DistributionOriginArgs.builder()
                .name(exampleInstance.name())
                .regionName(available.id())
                .build())
            .defaultCacheBehavior(DistributionDefaultCacheBehaviorArgs.builder()
                .behavior("cache")
                .build())
            .name("example-distribution")
            .bundleId("small_1_0")
            .build(), CustomResourceOptions.builder()
                .dependsOn(example)
                .build());

    }
}
resources:
  example:
    type: aws:lightsail:StaticIpAttachment
    properties:
      staticIpName: ${exampleStaticIp.name}
      instanceName: ${exampleInstance.name}
  exampleStaticIp:
    type: aws:lightsail:StaticIp
    name: example
    properties:
      name: example-static-ip
  exampleInstance:
    type: aws:lightsail:Instance
    name: example
    properties:
      name: example-instance
      availabilityZone: ${available.names[0]}
      blueprintId: amazon_linux_2
      bundleId: micro_1_0
  exampleDistribution:
    type: aws:lightsail:Distribution
    name: example
    properties:
      origin:
        name: ${exampleInstance.name}
        regionName: ${available.id}
      defaultCacheBehavior:
        behavior: cache
      name: example-distribution
      bundleId: small_1_0
    options:
      dependsOn:
        - ${example}
variables:
  available:
    fn::invoke:
      function: aws:getAvailabilityZones
      arguments:
        filters:
          - name: opt-in-status
            values:
              - opt-in-not-required
        state: available

Load Balancer Origin

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const available = aws.getAvailabilityZones({
    filters: [{
        name: "opt-in-status",
        values: ["opt-in-not-required"],
    }],
    state: "available",
});
const example = new aws.lightsail.Lb("example", {
    name: "example-load-balancer",
    healthCheckPath: "/",
    instancePort: 80,
    tags: {
        foo: "bar",
    },
});
const exampleInstance = new aws.lightsail.Instance("example", {
    name: "example-instance",
    availabilityZone: available.then(available => available.names?.[0]),
    blueprintId: "amazon_linux_2",
    bundleId: "nano_3_0",
});
const exampleLbAttachment = new aws.lightsail.LbAttachment("example", {
    lbName: example.name,
    instanceName: exampleInstance.name,
});
const exampleDistribution = new aws.lightsail.Distribution("example", {
    origin: {
        name: example.name,
        regionName: available.then(available => available.id),
    },
    defaultCacheBehavior: {
        behavior: "cache",
    },
    name: "example-distribution",
    bundleId: "small_1_0",
}, {
    dependsOn: [exampleLbAttachment],
});
import pulumi
import pulumi_aws as aws

available = aws.get_availability_zones(filters=[{
        "name": "opt-in-status",
        "values": ["opt-in-not-required"],
    }],
    state="available")
example = aws.lightsail.Lb("example",
    name="example-load-balancer",
    health_check_path="/",
    instance_port=80,
    tags={
        "foo": "bar",
    })
example_instance = aws.lightsail.Instance("example",
    name="example-instance",
    availability_zone=available.names[0],
    blueprint_id="amazon_linux_2",
    bundle_id="nano_3_0")
example_lb_attachment = aws.lightsail.LbAttachment("example",
    lb_name=example.name,
    instance_name=example_instance.name)
example_distribution = aws.lightsail.Distribution("example",
    origin={
        "name": example.name,
        "region_name": available.id,
    },
    default_cache_behavior={
        "behavior": "cache",
    },
    name="example-distribution",
    bundle_id="small_1_0",
    opts = pulumi.ResourceOptions(depends_on=[example_lb_attachment]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var available = Aws.GetAvailabilityZones.Invoke(new()
    {
        Filters = new[]
        {
            new Aws.Inputs.GetAvailabilityZonesFilterInputArgs
            {
                Name = "opt-in-status",
                Values = new[]
                {
                    "opt-in-not-required",
                },
            },
        },
        State = "available",
    });

    var example = new Aws.LightSail.Lb("example", new()
    {
        Name = "example-load-balancer",
        HealthCheckPath = "/",
        InstancePort = 80,
        Tags =
        {
            { "foo", "bar" },
        },
    });

    var exampleInstance = new Aws.LightSail.Instance("example", new()
    {
        Name = "example-instance",
        AvailabilityZone = available.Apply(getAvailabilityZonesResult => getAvailabilityZonesResult.Names[0]),
        BlueprintId = "amazon_linux_2",
        BundleId = "nano_3_0",
    });

    var exampleLbAttachment = new Aws.LightSail.LbAttachment("example", new()
    {
        LbName = example.Name,
        InstanceName = exampleInstance.Name,
    });

    var exampleDistribution = new Aws.LightSail.Distribution("example", new()
    {
        Origin = new Aws.LightSail.Inputs.DistributionOriginArgs
        {
            Name = example.Name,
            RegionName = available.Apply(getAvailabilityZonesResult => getAvailabilityZonesResult.Id),
        },
        DefaultCacheBehavior = new Aws.LightSail.Inputs.DistributionDefaultCacheBehaviorArgs
        {
            Behavior = "cache",
        },
        Name = "example-distribution",
        BundleId = "small_1_0",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleLbAttachment,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lightsail"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		available, err := aws.GetAvailabilityZones(ctx, &aws.GetAvailabilityZonesArgs{
			Filters: []aws.GetAvailabilityZonesFilter{
				{
					Name: "opt-in-status",
					Values: []string{
						"opt-in-not-required",
					},
				},
			},
			State: pulumi.StringRef("available"),
		}, nil)
		if err != nil {
			return err
		}
		example, err := lightsail.NewLb(ctx, "example", &lightsail.LbArgs{
			Name:            pulumi.String("example-load-balancer"),
			HealthCheckPath: pulumi.String("/"),
			InstancePort:    pulumi.Int(80),
			Tags: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		if err != nil {
			return err
		}
		exampleInstance, err := lightsail.NewInstance(ctx, "example", &lightsail.InstanceArgs{
			Name:             pulumi.String("example-instance"),
			AvailabilityZone: pulumi.String(available.Names[0]),
			BlueprintId:      pulumi.String("amazon_linux_2"),
			BundleId:         pulumi.String("nano_3_0"),
		})
		if err != nil {
			return err
		}
		exampleLbAttachment, err := lightsail.NewLbAttachment(ctx, "example", &lightsail.LbAttachmentArgs{
			LbName:       example.Name,
			InstanceName: exampleInstance.Name,
		})
		if err != nil {
			return err
		}
		_, err = lightsail.NewDistribution(ctx, "example", &lightsail.DistributionArgs{
			Origin: &lightsail.DistributionOriginArgs{
				Name:       example.Name,
				RegionName: pulumi.String(available.Id),
			},
			DefaultCacheBehavior: &lightsail.DistributionDefaultCacheBehaviorArgs{
				Behavior: pulumi.String("cache"),
			},
			Name:     pulumi.String("example-distribution"),
			BundleId: pulumi.String("small_1_0"),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleLbAttachment,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_getavailabilityzones" "available" {
  filters {
    name   = "opt-in-status"
    values = ["opt-in-not-required"]
  }
  state = "available"
}

resource "aws_lightsail_lb" "example" {
  name              = "example-load-balancer"
  health_check_path = "/"
  instance_port     = "80"
  tags = {
    "foo" = "bar"
  }
}
resource "aws_lightsail_instance" "example" {
  name              = "example-instance"
  availability_zone = data.aws_getavailabilityzones.available.names[0]
  blueprint_id      = "amazon_linux_2"
  bundle_id         = "nano_3_0"
}
resource "aws_lightsail_lbattachment" "example" {
  lb_name       = aws_lightsail_lb.example.name
  instance_name = aws_lightsail_instance.example.name
}
resource "aws_lightsail_distribution" "example" {
  depends_on = [aws_lightsail_lbattachment.example]
  origin = {
    name        = aws_lightsail_lb.example.name
    region_name = data.aws_getavailabilityzones.available.id
  }
  default_cache_behavior = {
    behavior = "cache"
  }
  name      = "example-distribution"
  bundle_id = "small_1_0"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetAvailabilityZonesArgs;
import com.pulumi.aws.inputs.GetAvailabilityZonesFilterArgs;
import com.pulumi.aws.lightsail.Lb;
import com.pulumi.aws.lightsail.LbArgs;
import com.pulumi.aws.lightsail.Instance;
import com.pulumi.aws.lightsail.InstanceArgs;
import com.pulumi.aws.lightsail.LbAttachment;
import com.pulumi.aws.lightsail.LbAttachmentArgs;
import com.pulumi.aws.lightsail.Distribution;
import com.pulumi.aws.lightsail.DistributionArgs;
import com.pulumi.aws.lightsail.inputs.DistributionOriginArgs;
import com.pulumi.aws.lightsail.inputs.DistributionDefaultCacheBehaviorArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        final var available = AwsFunctions.getAvailabilityZones(GetAvailabilityZonesArgs.builder()
            .filters(GetAvailabilityZonesFilterArgs.builder()
                .name("opt-in-status")
                .values("opt-in-not-required")
                .build())
            .state("available")
            .build());

        var example = new Lb("example", LbArgs.builder()
            .name("example-load-balancer")
            .healthCheckPath("/")
            .instancePort(80)
            .tags(Map.of("foo", "bar"))
            .build());

        var exampleInstance = new Instance("exampleInstance", InstanceArgs.builder()
            .name("example-instance")
            .availabilityZone(available.names()[0])
            .blueprintId("amazon_linux_2")
            .bundleId("nano_3_0")
            .build());

        var exampleLbAttachment = new LbAttachment("exampleLbAttachment", LbAttachmentArgs.builder()
            .lbName(example.name())
            .instanceName(exampleInstance.name())
            .build());

        var exampleDistribution = new Distribution("exampleDistribution", DistributionArgs.builder()
            .origin(DistributionOriginArgs.builder()
                .name(example.name())
                .regionName(available.id())
                .build())
            .defaultCacheBehavior(DistributionDefaultCacheBehaviorArgs.builder()
                .behavior("cache")
                .build())
            .name("example-distribution")
            .bundleId("small_1_0")
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleLbAttachment)
                .build());

    }
}
resources:
  example:
    type: aws:lightsail:Lb
    properties:
      name: example-load-balancer
      healthCheckPath: /
      instancePort: '80'
      tags:
        foo: bar
  exampleInstance:
    type: aws:lightsail:Instance
    name: example
    properties:
      name: example-instance
      availabilityZone: ${available.names[0]}
      blueprintId: amazon_linux_2
      bundleId: nano_3_0
  exampleLbAttachment:
    type: aws:lightsail:LbAttachment
    name: example
    properties:
      lbName: ${example.name}
      instanceName: ${exampleInstance.name}
  exampleDistribution:
    type: aws:lightsail:Distribution
    name: example
    properties:
      origin:
        name: ${example.name}
        regionName: ${available.id}
      defaultCacheBehavior:
        behavior: cache
      name: example-distribution
      bundleId: small_1_0
    options:
      dependsOn:
        - ${exampleLbAttachment}
variables:
  available:
    fn::invoke:
      function: aws:getAvailabilityZones
      arguments:
        filters:
          - name: opt-in-status
            values:
              - opt-in-not-required
        state: available

Import

Using pulumi import, import Lightsail Distribution using the name. For example:

$ pulumi import aws:lightsail/distribution:Distribution example example-distribution

Constructors

Distribution(String name, {DistributionArgs? args, CustomResourceOptions? options})
Creates a new Distribution. name The Pulumi resource name. args Arguments used to configure this Distribution. The set of arguments for Distribution. options Resource options controlling this resource's behavior.
Distribution.reference(String urn)
Creates a typed reference to an existing Distribution resource.

Properties

alternativeDomainNames ↔ Output<List<String>>
Alternate domain names of the distribution.
latefinal
arn ↔ Output<String>
ARN of the distribution.
latefinal
bundleId ↔ Output<String>
Bundle ID to use for the distribution.
latefinal
cacheBehaviors ↔ Output<List<DistributionCacheBehavior>?>
Per-path cache behavior of the distribution. See below.
latefinal
cacheBehaviorSettings ↔ Output<DistributionCacheBehaviorSettings?>
Cache behavior settings of the distribution. See below.
latefinal
certificateName ↔ Output<String?>
Name of the SSL/TLS certificate attached to the distribution.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
createdAt ↔ Output<String>
Timestamp when the distribution was created.
latefinal
defaultCacheBehavior ↔ Output<DistributionDefaultCacheBehavior>
Default cache behavior of the distribution. See below.
latefinal
domainName ↔ Output<String>
Domain name of the distribution.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
ipAddressType ↔ Output<String?>
IP address type of the distribution. Valid values: dualstack, ipv4. Default: dualstack.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isEnabled ↔ Output<bool?>
Whether the distribution is enabled. Default: true.
latefinal
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
locations ↔ Output<List<DistributionLocation>>
Location of the distribution, such as the AWS Region and Availability Zone. See below.
latefinal
name ↔ Output<String>
Name of the distribution.
latefinal
origin ↔ Output<DistributionOrigin>
Origin resource of the distribution, such as a Lightsail instance, bucket, or load balancer. See below.
latefinal
originPublicDns ↔ Output<String>
Public DNS of the origin.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
resourceType ↔ Output<String>
Lightsail resource type (e.g., Distribution).
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
status ↔ Output<String>
Status of the distribution.
latefinal
supportCode ↔ Output<String>
Support code. Include this code in your email to support when you have questions about your Lightsail distribution. This code enables our support team to look up your Lightsail information more easily.
latefinal
tags ↔ Output<Map<String, String>?>
Map of tags for the Lightsail Distribution. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {DistributionState? state, CustomResourceOptions? options}) → Distribution
Gets an existing Distribution resource's state with the given name and id.