Build a Component

Example: PulumiPlugin.yaml for TypeScript

runtime: nodejs

Manage dependencies

Next, we need to define our dependencies in package.json.

Example: package.json for a Pulumi Component

{
    "name": "sample-components",
    "description": "Static Page Component",
    "dependencies": {
        "@pulumi/aws": "^7.6.0",
        "@pulumi/pulumi": "^3.191.0"
    },
    "devDependencies": {
        "@types/node": "^24.0.0",
        "typescript": "^5.9.2"
    }
}

The @pulumi/pulumi SDK contains everything we need for making a component. The @pulumi/aws package is the AWS provider that we are building on top of.

TypeScript project file

We’ll also need a TypeScript project file called tsconfig.json.

{
    "compilerOptions": {
        "strict": true,
        "outDir": "bin",
        "target": "es2016",
        "module": "commonjs",
        "moduleResolution": "node",
        "sourceMap": true,
        "experimentalDecorators": true,
        "pretty": true,
        "noFallthroughCasesInSwitch": true,
        "noImplicitReturns": true,
        "forceConsistentCasingInFileNames": true
    },
    "files": [
        "index.ts",
        "StaticPage.ts"
    ]
}

Finally, install dependencies via NPM:

$ npm install

Build the component

Once dependencies are installed, build the TypeScript component:

$ npx tsc

This compiles the TypeScript files and generates the JavaScript output in the bin directory.

Example: PulumiPlugin.yaml for Python

runtime: python

Manage dependencies

Next, we need to define our dependencies in requirements.txt.

Example: requirements.txt for a Pulumi Component

pulumi>=3.191.0,<4.0
pulumi_aws>=7.6.0,<8.0

The pulumi SDK contains everything we need for making a component. The pulumi_aws package is the AWS provider that we are building on top of.

Example: PulumiPlugin.yaml for Go

runtime: go

Manage dependencies

Next, we need to define our dependencies in go.mod.

Example: go.mod for a Pulumi Component

module github.com/sample-components

go 1.25

require (
	github.com/pulumi/pulumi-aws/sdk/v7 v7.6.0
	github.com/pulumi/pulumi/sdk/v3 v3.191.0
)

The pulumi SDK contains everything we need for making a component. The pulumi-aws package is the AWS provider that we are building on top of.

Example: PulumiPlugin.yaml for C#

runtime: dotnet

Manage dependencies

Next, we need to define our dependencies in StaticPageComponent.csproj.

Example: StaticPageComponent.csproj for a Pulumi Component

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <AssemblyName>sample-components</AssemblyName>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Pulumi" Version="3.87.0" />
    <PackageReference Include="Pulumi.AWS" Version="7.*" />
    <PackageReference Include="Newtonsoft.Json" Version="13.*" />
  </ItemGroup>
</Project>

The Pulumi SDK contains everything we need for making a component. The Pulumi.Aws package is the AWS provider that we are building on top of.

Note that the AssemblyName specifies the name of the component package. This name will be important later on in the component implementation, so make sure it’s something unique and descriptive!

Example: PulumiPlugin.yaml for Java

runtime: java

Manage dependencies

Next, we need to define our dependencies and project configuration in a Maven pom.xml.

Example: pom.xml for a Pulumi Component

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.pulumi</groupId>
  <artifactId>sample-components</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <encoding>UTF-8</encoding>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
    <maven.compiler.release>11</maven.compiler.release>
    <mainClass>staticpagecomponent.App</mainClass>
    <mainArgs/>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-nop</artifactId>
      <version>2.0.17</version>
    </dependency>
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.13.1</version>
    </dependency>
    <dependency>
      <groupId>com.pulumi</groupId>
      <artifactId>pulumi</artifactId>
      <version>1.16.1</version>
    </dependency>
    <dependency>
      <groupId>com.pulumi</groupId>
      <artifactId>aws</artifactId>
      <version>(7.6.0,7.99]</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>3.0.0</version>
        <configuration>
          <mainClass>${mainClass}</mainClass>
          <commandlineArgs>${mainArgs}</commandlineArgs>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

The com.pulumi.pulumi SDK contains everything we need for making a component. The com.pulumi.aws package is the AWS provider that we are building on top of. We’ve also included a couple helper libraries like gson and slf4j-nop which are helpful for this example.

First, create the index.ts file, where we will export the component class.

Example: index.ts component export

export { StaticPage } from "./staticpage";

First, create the __main__.py file, where we will define an entry point for the component.

Example: __main__.py component entry point

from pulumi.provider.experimental import component_provider_host
from staticpage import StaticPage

if __name__ == "__main__":
    component_provider_host(name="sample-components", components=[StaticPage])

Here, the component_provider_host call invokes a Pulumi provider implementation which acts as a shim for the component. The name we pass to it will be important later on in the component implementation, so make sure it’s something unique and descriptive!

First, create the main.go file, where we will define an entry point for the component.

Example: main.go component entry point

package main

import (
	"context"
	"fmt"
	"os"

	p "github.com/pulumi/pulumi-go-provider"
	"github.com/pulumi/pulumi-go-provider/infer"
	"github.com/pulumi/pulumi/sdk/v3/go/common/tokens"
)

func main() {
	provider, err := provider()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
		os.Exit(1)
	}
	err = provider.Run(context.Background(), "sample-components", "0.1.0")

	if err != nil {
		panic(err)
	}
}

func provider() (p.Provider, error) {
	return infer.NewProviderBuilder().
		WithNamespace("example.com").
		WithComponents(
			infer.ComponentF(NewStaticPage),
		).
		WithModuleMap(map[tokens.ModuleName]tokens.ModuleName{
			"sample-components": "index",
		}).
		Build()
}

Here, the infer.NewProviderBuilder()..Build() call builds a Pulumi provider implementation which acts as a shim for the component. Then, in the main function we call provider.Run(...) to execute the provider. The name we pass to this function and to the module map (sample-components) will be important later on in the component implementation, so make sure it’s something unique and descriptive!

First, create the Program.cs file, where we will define an entry point for the component.

Example: Program.cs component entry point

using System.Threading.Tasks;

class Program
{
    public static Task Main(string []args) =>
        Pulumi.Experimental.Provider.ComponentProviderHost.Serve(args);
}

Here, the ComponentProviderHost.Serve call invokes a Pulumi provider implementation which acts as a shim for the component. Everything else about your component will be inferred by the Pulumi SDK.

First, create the src/main/java/staticpagecomponent sub-directory and in it, create the App.java file, where we will define an entry point for the component.

Example: App.java component entry point

package staticpagecomponent;

import java.io.IOException;
import com.pulumi.provider.internal.ComponentProviderHost;

public class App {
    public static void main(String[] args) throws IOException, InterruptedException {
        new ComponentProviderHost("sample-components", App.class.getPackage()).start(args);
    }
}

Here, the ComponentProviderHost.start(...) call invokes a Pulumi provider implementation which acts as a shim for the component. The name we pass to it will be important later on in the component implementation, so make sure it’s something unique and descriptive!

We also need to pass the Java package so that your component classes can be inferred by the Pulumi SDK.

Because YAML is entirely declarative, unlike in our other languages, there’s no need define an entry point.

First create a file called StaticPage.ts, and add the imports we will need:

Example: StaticPage.ts required imports

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

The @pulumi/pulumi package is the core Pulumi SDK, which provides the base classes and types needed to define components and resources. The @pulumi/aws package is the Pulumi AWS provider, which gives us the resource types we need to create AWS infrastructure.

First create a file called static_page.py, and add the imports we will need:

Example: static_page.py required dependencies

import json
from typing import Optional, TypedDict

import pulumi
from pulumi import ResourceOptions
from pulumi_aws import s3

The pulumi package is the core Pulumi SDK, which provides the base classes and types needed to define components and resources. The pulumi_aws package is the Pulumi AWS provider, which gives us the resource types we need to create AWS infrastructure.

First create a directory called staticpagecomponent and create a file called static_page.go inside it. This will be our importable Go package:

Example: staticpagecomponent/static_page.go required dependencies

package staticpagecomponent

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

The github.com/pulumi/pulumi/sdk/v3/go/pulumi package is the core Pulumi SDK, which provides the base types needed to define components and resources. The github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3 package is the Pulumi AWS provider’s S3 module, which gives us the resource types we need to create AWS infrastructure.

First create a file called StaticPage.cs, and add the imports we will need:

Example: StaticPage.cs required imports

using System;
using System.Collections.Generic;

using Pulumi;
using Pulumi.Aws.S3;
using Pulumi.Aws.S3.Inputs;

using Newtonsoft.Json;

The Pulumi namespace is the core Pulumi SDK, which provides the base classes and types needed to define components and resources. The Pulumi.Aws.S3 namespace is from the Pulumi AWS provider, which gives us the resource types we need to create AWS infrastructure.

First create a file called StaticPage.java, and add the imports we will need:

Example: StaticPage.java required imports

package myproject;

import java.util.Map;

import com.pulumi.aws.s3.BucketObject;
import com.pulumi.aws.s3.BucketObjectArgs;
import com.pulumi.aws.s3.BucketPolicy;
import com.pulumi.aws.s3.BucketPolicyArgs;
import com.pulumi.aws.s3.BucketPublicAccessBlock;
import com.pulumi.aws.s3.BucketPublicAccessBlockArgs;
import com.pulumi.aws.s3.Bucket;
import com.pulumi.aws.s3.BucketWebsiteConfiguration;
import com.pulumi.aws.s3.BucketWebsiteConfigurationArgs;
import com.pulumi.aws.s3.inputs.BucketWebsiteConfigurationIndexDocumentArgs;

import com.pulumi.core.Output;
import com.pulumi.core.Either;
import com.pulumi.core.annotations.Export;
import com.pulumi.core.annotations.Import;

import com.pulumi.resources.ComponentResource;
import com.pulumi.resources.ComponentResourceOptions;
import com.pulumi.resources.CustomResourceOptions;
import com.pulumi.resources.ResourceArgs;

The com.pulumi.resources and com.pulumi.core packages are from the core Pulumi SDK, which provide the base classes and types needed to define components and resources. The com.pulumi.aws.s3 package is from the Pulumi AWS provider, which gives us the resource types we need to create AWS infrastructure.

YAML components do not need to explicitly manage dependencies or import external libraries. The necessary packages will be resolved and automatically installed by the Pulumi engine, based on the unique resource type identifiers in the component’s sub-resources.

Example: StaticPage.ts the Component arguments implementation

export interface StaticPageArgs {
    indexContent: pulumi.Input<string>;
}

Note that argument classes must be serializable and use pulumi.Input types, rather than the language’s default types. Certain types like union types (e.g., string | number) and functions are not supported due to schema inference limitations. For details on type requirements and limitations, see Component arguments and type requirements.

Example: static_page.py the Component arguments implementation

class StaticPageArgs(TypedDict):
    index_content: pulumi.Input[str]
    """The HTML content for index.html."""

Note that argument classes must be serializable and use pulumi.Input types, rather than the language’s default types. This means certain types like union types and functions are not supported. For details on type requirements and limitations, see Component arguments and type requirements.

Python class properties are typically written in lowercase with words separated by underscores, known as snake_case, however properties in the Pulumi package schema are usually written in camelCase, where capital letters are used to separate words. To follow these conventions, the inferred schema for a component will have translated property names. In our example index_content will become indexContent in the schema. When using a component, the property names will follow the conventions of that language, for example if we use our component from TypeScript, we would refer to indexContent, but if we use it from Python, we would use index_content.

Example: static_page.go the Component arguments implementation

type StaticPageArgs struct {
	IndexContent pulumi.StringInput `pulumi:"indexContent"`
}

Note that argument classes must be serializable and use pulumi.Input types, rather than the language’s default types. This means complex or platform-specific types may not be supported. For details on type requirements and limitations, see Component arguments and type requirements.

Go struct fields are typically written in title case, with the first letter capitalized and capital letters used to separate words, however properties in the Pulumi package schema are usually written in camelCase, with the first letter in lowercase and capital letters used to separate words. To follow these conventions, the inferred schema for a component will have translated property names. In our example IndexContent will become indexContent in the schema. When using a component, the property names will follow the conventions of that language, for example if we use our component from TypeScript, we would refer to indexContent, but if we use it from Go, we would use IndexContent.

Example: StaticPage.cs the Component arguments implementation

public sealed class StaticPageArgs : ResourceArgs {
    [Input("indexContent")]
    public Input<string> IndexContent { get; set; } = null!;
}

Note that argument classes must be serializable and use Pulumi.Input types, rather than the language’s default types. This means complex or platform-specific types may not be supported. For details on type requirements and limitations, see Component arguments and type requirements.

Example: StaticPage.java the Component arguments implementation

class StaticPageArgs extends ResourceArgs {
    @Import(name = "indexContent", required = true)
    private Output<String> IndexContent;

    public Output<String> indexContent() {
        return this.IndexContent;
    }

    private StaticPageArgs() {
    }

    public StaticPageArgs(Output<String> indexContent) {
        this.IndexContent = indexContent;
    }
}

Note that argument classes must be serializable and use com.pulumi.core.Output<T> types, rather than the language’s default types. This means complex or platform-specific types may not be supported. For details on type requirements and limitations, see Component arguments and type requirements.

The @Import decorator marks this as a required input and allows use to give a name for the input that could be different from the implementation here.

In YAML, rather than defining a separate args class, the inputs are declared under the inputs key:

Example: PulumiPlugin.yaml the Component arguments implementation

    inputs:
      indexContent:
        type: string

Inputs can be any basic type (e.g. boolean, integer, string) or an array of any of those types. You can provide a default value via the default property.

Now we can implement the component itself. Components should inherit from pulumi.ComponentResource, and should accept the arguments class we just defined in the constructor. All the work for our component happens in the constructor, and outputs are returned via class properties. At the end of the process a calling self.registerOutputs signals Pulumi that the process of creating the component resource has completed.

Example: StaticPage.ts the Component implementation

export class StaticPage extends pulumi.ComponentResource {
    public readonly endpoint: pulumi.Output<string>;

    constructor(name: string, args: StaticPageArgs, opts?: pulumi.ComponentResourceOptions) {
        super("sample-components:index:StaticPage", name, args, opts);

        const bucket = new aws.s3.Bucket(`${name}-bucket`, {}, { parent: this });

        const bucketWebsite = new aws.s3.BucketWebsiteConfiguration(
            `${name}-website`,
            {
                bucket: bucket.bucket,
                indexDocument: { suffix: "index.html" },
            },
            {
                parent: this,
            },
        );

        new aws.s3.BucketObject(
            `${name}-index-object`,
            {
                bucket: bucket.bucket,
                key: "index.html",
                content: args.indexContent,
                contentType: "text/html",
            },
            {
                parent: this,
            },
        );

        const publicAccessBlock = new aws.s3.BucketPublicAccessBlock(
            `${name}-public-access-block`,
            {
                bucket: bucket.id,
                blockPublicAcls: false,
            },
            {
                parent: this,
            },
        );

        new aws.s3.BucketPolicy(
            `${name}-bucket-policy`,
            {
                bucket: bucket.id,
                policy: bucket.bucket.apply(this.allowGetObjectPolicy),
            },
            {
                parent: this,
                dependsOn: publicAccessBlock,
            },
        );

        this.endpoint = bucketWebsite.websiteEndpoint;

        this.registerOutputs({
            endpoint: bucketWebsite.websiteEndpoint,
        });

Now we can implement the component itself. Components should inherit from pulumi.ComponentResource, and should accept the arguments class we just defined in the constructor. All the work for our component happens in the constructor, and outputs are returned via class properties. At the end of the process a calling self.register_outputs signals Pulumi that the process of creating the component resource has completed.

Example: static_page.py the Component implementation

class StaticPage(pulumi.ComponentResource):
    endpoint: pulumi.Output[str]
    """The URL of the static website."""

    def __init__(self,
                 name: str,
                 args: StaticPageArgs,
                 opts: Optional[ResourceOptions] = None) -> None:

        super().__init__("sample-components:index:StaticPage", name, {}, opts)

        bucket = s3.Bucket(
            f"{name}-bucket",
            opts=ResourceOptions(parent=self))

        bucket_website = s3.BucketWebsiteConfiguration(
            f"{name}-website",
            bucket=bucket.bucket,
            index_document={"suffix": "index.html"},
            opts=ResourceOptions(parent=self))

        s3.BucketObject(
            f"{name}-index-object",
            bucket=bucket.bucket,
            key="index.html",
            content=args.get("index_content"),
            content_type="text/html",
            opts=ResourceOptions(parent=self))

        bucket_public_access_block = s3.BucketPublicAccessBlock(
            f"{name}-public-access-block",
            bucket=bucket.id,
            block_public_acls=False,
            opts=ResourceOptions(parent=self))

        s3.BucketPolicy(
            f"{name}-bucket-policy",
            bucket=bucket.bucket,
            policy=bucket.bucket.apply(_allow_getobject_policy),
            opts=ResourceOptions(parent=self, depends_on=[bucket_public_access_block]))

        self.endpoint = bucket_website.website_endpoint

        self.register_outputs({
            "endpoint": bucket_website.website_endpoint
        })

Now we can implement the component itself. Component structs should include pulumi.ResourceState and define the consumable outputs, which follow the same general rules as inputs. All the work for building our component happens in the NewStaticPage constructor.

Example: static_page.go the Component implementation

type StaticPage struct {
	pulumi.ResourceState
	Endpoint pulumi.StringOutput `pulumi:"endpoint"`
}

func NewStaticPage(ctx *pulumi.Context, name string, args *StaticPageArgs, opts ...pulumi.ResourceOption) (*StaticPage, error) {
	comp := &StaticPage{}
	err := ctx.RegisterComponentResource("sample-components:index:StaticPage", name, comp, opts...)
	if err != nil {
		return nil, err
	}

	bucket, err := s3.NewBucket(ctx, fmt.Sprintf("%s-bucket", name), &s3.BucketArgs{},
		pulumi.Parent(comp))
	if err != nil {
		return nil, err
	}

	bucketWebsite, err := s3.NewBucketWebsiteConfiguration(ctx, fmt.Sprintf("%s-website", name),
		&s3.BucketWebsiteConfigurationArgs{
			Bucket: bucket.Bucket,
			IndexDocument: s3.BucketWebsiteConfigurationIndexDocumentArgs{
				Suffix: pulumi.String("index.html"),
			},
		},
		pulumi.Parent(comp))
	if err != nil {
		return nil, err
	}

	_, err = s3.NewBucketObject(ctx, fmt.Sprintf("%s-index-object", name), &s3.BucketObjectArgs{
		Bucket:      bucket.Bucket,
		Key:         pulumi.String("index.html"),
		Content:     args.IndexContent,
		ContentType: pulumi.String("text/html"),
	}, pulumi.Parent(comp))
	if err != nil {
		return nil, err
	}

	publicAccessBlock, err := s3.NewBucketPublicAccessBlock(ctx, fmt.Sprintf("%s-public-access-block", name),
		&s3.BucketPublicAccessBlockArgs{
			Bucket:          bucket.ID(),
			BlockPublicAcls: pulumi.Bool(false),
		}, pulumi.Parent(comp))
	if err != nil {
		return nil, err
	}

	allowGetObjectPolicy := func(bucketName string) (string, error) {
		policy := map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				{
					"Effect":    "Allow",
					"Principal": "*",
					"Action":    []string{"s3:GetObject"},
					"Resource":  []string{fmt.Sprintf("arn:aws:s3:::%s/*", bucketName)},
				},
			},
		}
		policyJSON, err := json.Marshal(policy)
		if err != nil {
			return "", err
		}
		return string(policyJSON), nil
	}

	_, err = s3.NewBucketPolicy(ctx, fmt.Sprintf("%s-bucket-policy", name), &s3.BucketPolicyArgs{
		Bucket: bucket.ID(),
		Policy: bucket.Bucket.ApplyT(func(bucketName string) (string, error) {
			return allowGetObjectPolicy(bucketName)
		}).(pulumi.StringOutput),
	}, pulumi.Parent(comp), pulumi.DependsOn([]pulumi.Resource{publicAccessBlock}))
	if err != nil {
		return nil, err
	}

	comp.Endpoint = bucketWebsite.WebsiteEndpoint

	return comp, nil
}

Now we can implement the component itself. Components should inherit from Pulumi.ComponentResource, and should accept the arguments class we just defined in the constructor. All the work for our component happens in the constructor, and outputs are returned via class properties. At the end of the process a calling this.RegisterOutputs signals Pulumi that the process of creating the component resource has completed.

Example: StaticPage.cs the Component implementation

class StaticPage : ComponentResource {
    [Output("endpoint")]
    public Output<string> Endpoint { get; set; }

    public StaticPage(string name, StaticPageArgs args, ComponentResourceOptions? opts = null)
        : base("sample-components:index:StaticPage", name, args, opts)
    {
        var bucket = new Bucket($"{name}-bucket", new() { }, new() { Parent = this });

        var bucketWebsite = new BucketWebsiteConfiguration($"{name}-website", new() {
            Bucket = bucket.BucketName,
            IndexDocument = new BucketWebsiteConfigurationIndexDocumentArgs { Suffix = "index.html" },
        }, new() { Parent = this });

        var bucketObject = new BucketObject($"{name}-index-object", new BucketObjectArgs {
            Bucket = bucket.BucketName,
            Key = "index.html",
            Content = args.IndexContent,
            ContentType = "text/html",
        }, new() { Parent = this });

        var publicAccessBlock = new BucketPublicAccessBlock($"{name}-public-access-block", new() {
            Bucket = bucket.BucketName,
            BlockPublicAcls = false,
        }, new() { Parent = this });

        var bucketPolicy = new BucketPolicy($"{name}-bucket-policy", new() {
            Bucket = bucket.BucketName,
            Policy = bucket.Id.Apply(this.AllowGetObjectPolicy),
        }, new() { Parent = this, DependsOn = publicAccessBlock });

        this.Endpoint = bucketWebsite.WebsiteEndpoint;

        this.RegisterOutputs(new Dictionary<string, object?> {
            ["endpoint"] = bucketWebsite.WebsiteEndpoint
        });
    }

    private string AllowGetObjectPolicy(string bucketName) {
        return JsonConvert.SerializeObject(new {
            Version = "2012-10-17",
            Statement = new[] { new {
                Effect = "Allow",
                Principal = "*",
                Action = new[] {
                    "s3:GetObject"
                },
                Resource = new[] {
                    $"arn:aws:s3:::{bucketName}/*"
                }
            }}
        });
    }
}

Now we can implement the component itself. Components should inherit from Pulumi.ComponentResource, and should accept the arguments class we just defined in the constructor. All the work for our component happens in the constructor, and outputs are returned via class properties. At the end of the process a calling this.registerOutputs signals Pulumi that the process of creating the component resource has completed.

Example: StaticPage.java the Component implementation

class StaticPage extends ComponentResource {
    @Export(name = "endpoint", refs = { String.class }, tree = "[0]")
    public final Output<String> endpoint;

    public StaticPage(String name, StaticPageArgs args, ComponentResourceOptions opts) {
        super("sample-components:index:StaticPage", name, null, opts);

        var bucket = new Bucket(
                String.format("%s-bucket", name),
                null,
                CustomResourceOptions.builder()
                        .parent(this)
                        .build());

        var bucketWebsite = new BucketWebsiteConfiguration(
                String.format("%s-website", name),
                BucketWebsiteConfigurationArgs.builder()
                        .bucket(bucket.id())
                        .indexDocument(
                                BucketWebsiteConfigurationIndexDocumentArgs.builder()
                                        .suffix("index.html")
                                        .build())
                        .build(),
                CustomResourceOptions.builder()
                        .parent(this)
                        .build());

        var bucketObject = new BucketObject(
                String.format("%s-index-object", name),
                BucketObjectArgs.builder()
                        .bucket(bucket.bucket())
                        .key("index.html")
                        .content(args.indexContent())
                        .contentType("text/html")
                        .build(),
                CustomResourceOptions.builder()
                        .parent(this)
                        .build());

        var publicAccessBlock = new BucketPublicAccessBlock(
                String.format("%s-public-access-block", name),
                BucketPublicAccessBlockArgs.builder()
                        .bucket(bucket.id())
                        .blockPublicAcls(false)
                        .blockPublicPolicy(false)
                        .ignorePublicAcls(false)
                        .restrictPublicBuckets(false)
                        .build(),
                CustomResourceOptions.builder()
                        .parent(this)
                        .build());

        var policyJson = bucket.arn().applyValue(bucketArn ->
            "{\n" +
            "  \"Version\": \"2012-10-17\",\n" +
            "  \"Statement\": [\n" +
            "    {\n" +
            "      \"Sid\": \"PublicReadGetObject\",\n" +
            "      \"Effect\": \"Allow\",\n" +
            "      \"Principal\": \"*\",\n" +
            "      \"Action\": \"s3:GetObject\",\n" +
            "      \"Resource\": \"" + bucketArn + "/*\"\n" +
            "    }\n" +
            "  ]\n" +
            "}"
        );

        var bucketPolicy = new BucketPolicy(
                String.format("%s-bucket-policy", name),
                BucketPolicyArgs.builder()
                        .bucket(bucket.id())
                        .policy(policyJson.applyValue(Either::ofLeft))
                        .build(),
                CustomResourceOptions.builder()
                        .parent(this)
                        .dependsOn(publicAccessBlock)
                        .build());

        this.endpoint = bucketWebsite.websiteEndpoint();

        this.registerOutputs(Map.of(
                "endpoint", bucketWebsite.websiteEndpoint()));
    }
}

Now we can implement the component itself. Under the components key, create one or more component definitions. A component in YAML follows the following structure:

components:
  MyComponent:      # the component class name
    inputs:         # one or more input values
    resources:      # one or more sub-resource definitions
    variables:      # intermediate variable definitions
    outputs:        # one or more output values

Here’s the full code for our StaticPage component:

Example: PulumiPlugin.yaml the Component implementation

components:
  StaticPage:
    inputs:
      indexContent:
        type: string
    resources:
      bucket:
        type: aws:s3:Bucket
        properties: {}

      bucketWebsite:
        type: aws:s3:BucketWebsiteConfiguration
        properties:
          bucket: ${bucket.bucket}
          indexDocument:
            suffix: index.html

      bucketObject:
        type: aws:s3/bucketObject:BucketObject
        properties:
          bucket: ${bucket.bucket}
          key: index.html
          content: ${indexContent}
          contentType: text/html

      publicAccessBlock:
        type: aws:s3/bucketPublicAccessBlock:BucketPublicAccessBlock
        properties:
          bucket: ${bucket.id}
          blockPublicAcls: false
          blockPublicPolicy: false
          ignorePublicAcls: false
          restrictPublicBuckets: false

      bucketPolicy:
        type: aws:s3/bucketPolicy:BucketPolicy
        properties:
          bucket: ${bucket.id}
          policy:
            fn::toJSON:
              Version: "2012-10-17"
              Statement:
                - Effect: Allow
                  Principal: "*"
                  Action:
                    - s3:GetObject
                  Resource:
                    - arn:aws:s3:::${bucket.bucket}/*
        options:
          dependsOn:
            - ${publicAccessBlock}

    outputs:
      endpoint: ${bucketWebsite.websiteEndpoint}

Inheriting from the base class

export class StaticPage extends pulumi.ComponentResource {

Inheriting from pulumi.ComponentResource gives us some built-in behind-the-scenes behavior that allows the component state to be tracked and run within the Pulumi engine and within its host provider. It also allows the underlying library to find and infer the schema of the component.

Outputs as class properties

    public readonly endpoint: pulumi.Output<string>;

We use a class property to store the output value. Component outputs should always use pulumi.Output<T> rather than plain types. This ensures that outputs can be passed directly to other Pulumi resource inputs, which also accept pulumi.Output<T>, without any additional unwrapping or conversion.

The Component constructor

    constructor(name: string, args: StaticPageArgs, opts?: pulumi.ComponentResourceOptions) {
        super("sample-components:index:StaticPage", name, args, opts);

The constructor has a few standard arguments:

• name: The name given to an instance of this component. When writing a Pulumi program, resources are named by the end-user. Later on in the implementation we will use this base component name to uniquely name the resources it contains.
• args: This is an instance of the argument class we defined earlier, containing the inputs for our component.
• opts: This is an optional set of common resource configuration values. The ComponentResourceOptions class is part of the basic API for all Pulumi resources, and will be passed to the constructors of our sub-resources later on.

Since we’re inheriting, we also need to call the base class constructor super(...). The first parameter is the name of the resource type, which is very important to get right. The resource type name has the following format: <package-name>:index:<component-class-name>. It must match exactly. Keep this in mind if you refactor the name of your package or the component’s class name. The index portion of this type name is a required implementation detail. Otherwise, we pass the name, args, and opts values from our component constructor into the base constructor.

Creating and managing sub-resources, dependencies, and execution order

Next we implement the Bucket, BucketWebsiteConfiguration, BucketObject, BucketPublicAccessBlock and BucketPolicy sub-resources.

        const bucket = new aws.s3.Bucket(`${name}-bucket`, {}, { parent: this });

        const bucketWebsite = new aws.s3.BucketWebsiteConfiguration(
            `${name}-website`,
            {
                bucket: bucket.bucket,
                indexDocument: { suffix: "index.html" },
            },
            {
                parent: this,
            },
        );

        new aws.s3.BucketObject(
            `${name}-index-object`,
            {
                bucket: bucket.bucket,
                key: "index.html",
                content: args.indexContent,
                contentType: "text/html",
            },
            {
                parent: this,
            },
        );

        const publicAccessBlock = new aws.s3.BucketPublicAccessBlock(
            `${name}-public-access-block`,
            {
                bucket: bucket.id,
                blockPublicAcls: false,
            },

The Bucket sub-resource

The Bucket resource represents an S3 bucket, which is similar to a directory. This is our public-facing entry point for hosting website content on the internet.

Notice the use of the name parameter and format string to create a unique name for the bucket resource. Every resource must have a unique name. We will use the same pattern in all the sub-resources.

Another important implementation detail here is the opts value being passed to the sub-resource constructor. We create a new instance of ResourceOptions and pass the component instance as the parent of the Bucket resource, via parent: this in the ResourceOptions class. This is an essential step to tie the sub-resources into the dependency graph.

The BucketWebsiteConfiguration and BucketObject sub-resources

The BucketWebsiteConfiguration represents the website configuration and the BucketObject represents the contents of the file we will host as index.html.

Managing the dependency graph of your sub-resources is very important in a component!

Another point of interest here is the use of args. In the BucketObject constructor, we pass the contents of the index.html page we want to host via the args class. It’s available as a strongly typed property accessor on the args class.

The BucketPublicAccessBlock and BucketPolicy sub-resources

By default the BucketObject we created is not accessible to the public, so we need to unlock that access with the BucketPublicAccessBlock and BucketPolicy resources.

The BucketPolicy resource shows an important coding technique when implementing components: handling asynchronous output values. We use bucket.bucket.apply(...) to generate an S3 policy document using the allowGetObjectPolicy helper function. This respects the asynchronous workflow, materializing that value only after the bucket has been created. If we attempted to create a BucketPolicy before the Bucket existed, the operation would fail. That’s because the S3 policy document needs to use the bucket’s name within its definition, and we won’t know what that value is until the Bucket creation operation has completed. Using apply here will ensure that execution of the allowGetObjectPolicy function doesn’t happen until the bucket has been created successfully.

Just like in a Pulumi program, it’s important to understand and respect the asynchronous flow of resource creation within our code. The apply function encodes the dependency and required order-of-operations.

The BucketPolicy resource also shows another technique: resource dependencies. We use the dependsOn resource option to indicate that the BucketPolicy depends on the BucketPublicAccessBlock. This relationship is important to encode so that resource creation, modification, and deletion happens as expected.

Handling outputs

The last part of the constructor handles output values. First we set the endpoint class property to the website endpoint from the BucketWebsiteConfiguration class. Note that this is a pulumi.Output<string>, not a regular TypeScript string. Outputs must use pulumi.Output types.

Finally, calling this.registerOutputs signals Pulumi that the component creation process has completed.

                parent: this,
            },
        );

        new aws.s3.BucketPolicy(
            `${name}-bucket-policy`,

Helper functions

In addition to the constructor logic, we also have a helper function allowGetObjectPolicy:

Example: StaticPage.ts a helper function

                bucket: bucket.id,
                policy: bucket.bucket.apply(this.allowGetObjectPolicy),
            },
            {
                parent: this,
                dependsOn: publicAccessBlock,
            },
        );

        this.endpoint = bucketWebsite.websiteEndpoint;

        this.registerOutputs({
            endpoint: bucketWebsite.websiteEndpoint,

This function is used to create a S3 policy document, allowing public access to the objects in our bucket. It will be invoked within the context of apply(...). That means that the bucketName, which is normally a pulumi.Output<str> value, can be materialized as a normal TypeScript string, and is passed into this function that way. Note that you can’t modify the value of bucketName, but you can read the value and use it to construct the policy document. The JSON.stringify(...) function takes the object as input and returns it as a JSON formatted string.

Inheriting from the base class

class StaticPage(pulumi.ComponentResource):

Inheriting from pulumi.ComponentResource gives us some built-in behind-the-scenes behavior that allows the component state to be tracked and run within the Pulumi engine. It also allows the underlying library to find and infer the schema of the component.

Outputs as class properties

    endpoint: pulumi.Output[str]
    """The URL of the static website."""

We use a class property to store the output value. Component outputs should always use pulumi.Output[T] rather than plain types. This ensures that outputs can be passed directly to other Pulumi resource inputs, which also accept pulumi.Output[T], without any additional unwrapping or conversion.

The Component constructor

    def __init__(self,
                 name: str,
                 args: StaticPageArgs,
                 opts: Optional[ResourceOptions] = None) -> None:

        super().__init__("sample-components:index:StaticPage", name, {}, opts)

The constructor has a few standard arguments:

• name: The name given to an instance of this component. When writing a Pulumi program, resources are named by the end-user. Later on in the implementation we will use this base component name to uniquely name the resources it contains.
• args: This is an instance of the argument class we defined earlier, containing the inputs for our component.
• opts: This is an optional set of common resource configuration values. The ComponentResourceOptions class is part of the basic API for all Pulumi resources, and will be passed to the constructors of our sub-resources later on.

Since we’re inheriting, we also need to call the base class constructor super().__init__. The first parameter is the name of the resource type, which is very important to get right. The resource type name has the following format: <package-name>:index:<component-class-name>. It must match exactly. Keep this in mind if you refactor the name of your package or the component’s class name. The index portion of this type name is a required implementation detail. Otherwise, we pass the name value into the base constructor, as well as the opts value, and an empty object for the args value.

Creating and managing sub-resources, dependencies, and execution order

Next we implement the Bucket, BucketWebsiteConfiguration, BucketObject, BucketPublicAccessBlock and BucketPolicy sub-resources.

        bucket = s3.Bucket(
            f"{name}-bucket",
            opts=ResourceOptions(parent=self))

        bucket_website = s3.BucketWebsiteConfiguration(
            f"{name}-website",
            bucket=bucket.bucket,
            index_document={"suffix": "index.html"},
            opts=ResourceOptions(parent=self))

        s3.BucketObject(
            f"{name}-index-object",
            bucket=bucket.bucket,
            key="index.html",
            content=args.get("index_content"),
            content_type="text/html",
            opts=ResourceOptions(parent=self))

        bucket_public_access_block = s3.BucketPublicAccessBlock(
            f"{name}-public-access-block",
            bucket=bucket.id,
            block_public_acls=False,
            opts=ResourceOptions(parent=self))

        s3.BucketPolicy(
            f"{name}-bucket-policy",
            bucket=bucket.bucket,
            policy=bucket.bucket.apply(_allow_getobject_policy),
            opts=ResourceOptions(parent=self, depends_on=[bucket_public_access_block]))

The Bucket sub-resource

The Bucket resource represents an S3 bucket, which is similar to a directory. This is our public-facing entry point for hosting website content on the internet.

Notice the use of the name parameter and format string to create a unique name for the bucket resource. Every resource must have a unique name. We will use the same pattern in all the sub-resources.

Another important implementation detail here is the opts value being passed to the sub-resource constructor. We create a new instance of ResourceOptions and pass the component instance as the parent of the Bucket resource, via parent=self in the ResourceOptions class. This is an essential step to tie the sub-resources into the dependency graph.

The BucketWebsiteConfiguration and BucketObject sub-resources

The BucketWebsiteConfiguration represents the website configuration and the BucketObject represents the contents of the file we will host as index.html.

Managing the dependency graph of your sub-resources is very important in a component!

Another point of interest here is the use of args. In the BucketObject constructor, we pass the contents of the index.html page we want to host via the args class. Instead of using a property accessor on the args class, we use args.get(...) and pass the name of the value we want.

The BucketPublicAccessBlock and BucketPolicy sub-resources

By default the BucketObject we created is not accessible to the public, so we need to unlock that access with the BucketPublicAccessBlock and BucketPolicy resources.

The BucketPolicy resource shows an important coding technique when implementing components: handling asynchronous output values. We use bucket.bucket.[apply](https://www.pulumi.com/docs/iac/concepts/inputs-outputs/apply/)(...) to generate an S3 policy document using the _allow_getobject_policy helper function. This respects the asynchronous workflow, materializing that value only after the bucket has been created. If we attempted to create a BucketPolicy before the Bucket existed, the operation would fail. That’s because the S3 Policy document needs to use the bucket’s name within S3, and we won’t know what that value is until the Bucket creation operation has completed. Using apply here will ensure that execution of the _allow_getobject_policy function doesn’t happen until the Bucket has been created successfully.

Just like in a Pulumi program, it’s important to understand and respect the asynchronous flow of resource creation within our code. The apply function encodes the dependency and required order-of-operations.

The BucketPolicy resource also shows another technique: resource dependencies. We use the depends_on resource option to indicate that the BucketPolicy depends on the BucketPublicAccessBlock. This relationship is important to encode so that resource creation, modification, and deletion happens as expected.

Handling outputs

The last part of the constructor handles output values. First we set the endpoint class property to the end-point URL from the BucketWebsiteConfiguration class. Note that this is a pulumi.Output[str], not a regular Python string. Outputs must use pulumi.Output types.

Finally, calling self.register_outputs signals Pulumi that the component creation process has completed.

        self.endpoint = bucket_website.website_endpoint

        self.register_outputs({
            "endpoint": bucket_website.website_endpoint
        })

Helper functions

In addition to the constructor logic, we also have a helper function _allow_getobject_policy:

Example: static_page.py a helper function

def _allow_getobject_policy(bucket_name: str) -> str:
    return json.dumps({
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": "*",
                "Action": ["s3:GetObject"],
                "Resource": [
                    f"arn:aws:s3:::{bucket_name}/*",
                ],
            },
        ],
    })

This function is used to create a S3 policy document, allowing public access to the objects in our bucket. It will be invoked within the context of apply(...). That means that the bucket_name, which is normally a pulumi.Output[str] value, can be materialized as a normal Python string, and is passed into this function that way. Note that you can’t modify the value of bucket_name, but you can read the value and use it to construct the policy document. The json.dumps(...) function takes the dictionary as input and returns it as a JSON formatted string.

Defining the struct

type StaticPage struct {
	pulumi.ResourceState
	Endpoint pulumi.StringOutput `pulumi:"endpoint"`
}

The struct must embed the pulumi.ResourceState struct. This gives us some built-in behind-the-scenes behavior that allows the component state to be tracked and run within the Pulumi engine and within its host provider. It also allows the underlying library to find and infer the schema of the component.

Outputs as struct fields

	Endpoint pulumi.StringOutput `pulumi:"endpoint"`

We use a struct field to store the output value. Component outputs should always use a pulumi.*Output type (such as pulumi.StringOutput) rather than plain types. This ensures that outputs can be passed directly to other Pulumi resource inputs, which also accept these output types, without any additional unwrapping or conversion. The pulumi:"endpoint" tag defines the name of the property and allows for reflection to generate schema.

The Component constructor

func NewStaticPage(ctx *pulumi.Context, name string, args *StaticPageArgs, opts ...pulumi.ResourceOption) (*StaticPage, error) {
	comp := &StaticPage{}
	err := ctx.RegisterComponentResource("sample-components:index:StaticPage", name, comp, opts...)
	if err != nil {
		return nil, err
	}

The constructor has a few standard arguments:

• ctx: The Pulumi context, which allows for interaction w/ the Pulumi engine
• name: The name given to an instance of this component. When writing a Pulumi program, resources are named by the end-user. Later on in the implementation we will use this base component name to uniquely name the resources it contains.
• args: This is an instance of the argument class we defined earlier, containing the inputs for our component.
• opts: This is an optional set of common resource configuration values. The ComponentResourceOptions class is part of the basic API for all Pulumi resources, and will be passed to the constructors of our sub-resources later on.

The next step is to register our new component instance with Pulumi via the ctx instance. The first parameter is the name of the resource type, which is very important to get right. The resource type name has the following format: <package-name>:index:<component-class-name>. It must match exactly. Keep this in mind if you refactor the name of your package or the component’s class name. The index portion of this type name is a required implementation detail. Otherwise, we pass the name value, our component instance, as well as the opts values.

Creating and managing sub-resources, dependencies, and execution order

Next we implement the Bucket, BucketWebsiteConfiguration, BucketObject, BucketPublicAccessBlock and BucketPolicy sub-resources.

	bucket, err := s3.NewBucket(ctx, fmt.Sprintf("%s-bucket", name), &s3.BucketArgs{},
		pulumi.Parent(comp))
	if err != nil {
		return nil, err
	}

	bucketWebsite, err := s3.NewBucketWebsiteConfiguration(ctx, fmt.Sprintf("%s-website", name),
		&s3.BucketWebsiteConfigurationArgs{
			Bucket: bucket.Bucket,
			IndexDocument: s3.BucketWebsiteConfigurationIndexDocumentArgs{
				Suffix: pulumi.String("index.html"),
			},
		},
		pulumi.Parent(comp))
	if err != nil {
		return nil, err
	}

	_, err = s3.NewBucketObject(ctx, fmt.Sprintf("%s-index-object", name), &s3.BucketObjectArgs{
		Bucket:      bucket.Bucket,
		Key:         pulumi.String("index.html"),
		Content:     args.IndexContent,
		ContentType: pulumi.String("text/html"),
	}, pulumi.Parent(comp))
	if err != nil {
		return nil, err
	}

	publicAccessBlock, err := s3.NewBucketPublicAccessBlock(ctx, fmt.Sprintf("%s-public-access-block", name),
		&s3.BucketPublicAccessBlockArgs{
			Bucket:          bucket.ID(),
			BlockPublicAcls: pulumi.Bool(false),
		}, pulumi.Parent(comp))
	if err != nil {
		return nil, err
	}

	allowGetObjectPolicy := func(bucketName string) (string, error) {
		policy := map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				{
					"Effect":    "Allow",
					"Principal": "*",
					"Action":    []string{"s3:GetObject"},
					"Resource":  []string{fmt.Sprintf("arn:aws:s3:::%s/*", bucketName)},
				},
			},
		}
		policyJSON, err := json.Marshal(policy)
		if err != nil {
			return "", err
		}
		return string(policyJSON), nil
	}

	_, err = s3.NewBucketPolicy(ctx, fmt.Sprintf("%s-bucket-policy", name), &s3.BucketPolicyArgs{
		Bucket: bucket.ID(),
		Policy: bucket.Bucket.ApplyT(func(bucketName string) (string, error) {
			return allowGetObjectPolicy(bucketName)
		}).(pulumi.StringOutput),
	}, pulumi.Parent(comp), pulumi.DependsOn([]pulumi.Resource{publicAccessBlock}))
	if err != nil {
		return nil, err
	}

The Bucket sub-resource

The Bucket resource represents an S3 bucket, which is similar to a directory. This is our public-facing entry point for hosting website content on the internet.

Notice the use of the name parameter and format string to create a unique name for the bucket resource. Every resource must have a unique name. We will use the same pattern in all the sub-resources.

Another important implementation detail here is the opts value being passed to the sub-resource constructor. We use pulumi.Parent(comp) to pass the component instance as the parent of the Bucket resource. This is an essential step to tie the sub-resources into the dependency graph.

The BucketWebsiteConfiguration and BucketObject sub-resources

The BucketWebsiteConfiguration represents the website configuration and the BucketObject represents the contents of the file we will host as index.html.

Managing the dependency graph of your sub-resources is very important in a component!

Another point of interest here is the use of args. In the BucketObject constructor, we pass the contents of the index.html page we want to host via the args.IndexContent field.

The BucketPublicAccessBlock and BucketPolicy sub-resources

By default the BucketObject we created is not accessible to the public, so we need to unlock that access with the BucketPublicAccessBlock and BucketPolicy resources.

The BucketPolicy resource shows an important coding technique when implementing components: handling asynchronous output values. We use bucket.Bucket.[ApplyT](/docs/iac/concepts/inputs-outputs/apply/)(...) to generate an S3 policy document using the allowGetObjectPolicy helper function. This respects the asynchronous workflow, materializing that value only after the bucket has been created. If we attempted to create a BucketPolicy before the Bucket existed, the operation would fail. That’s because the S3 Policy document needs to use the bucket’s name within S3, and we won’t know what that value is until the Bucket creation operation has completed. Using ApplyT here will ensure that execution of the allowGetObjectPolicy function doesn’t happen until the Bucket has been created successfully.

Just like in a Pulumi program, it’s important to understand and respect the asynchronous flow of resource creation within our code. The ApplyT function encodes the dependency and required order-of-operations.

The BucketPolicy resource also shows another technique: resource dependencies. We use pulumi.DependsOn([]pulumi.Resource{publicAccessBlock}) to set the [dependsOn](/docs/iac/concepts/options/dependson/) resource option to indicate that the BucketPolicy depends on the BucketPublicAccessBlock. This relationship is important to encode so that resource creation, modification, and deletion happens as expected.

Handling outputs

The last part of the constructor handles output values. First we set the Endpoint struct field to the end-point URL from the BucketWebsiteConfiguration resource. Note that this is a pulumi.StringOutput, not a regular Go string. Outputs must use pulumi.Output types.

Finally, return the component instance.

	comp.Endpoint = bucketWebsite.WebsiteEndpoint

	return comp, nil
}

Helper functions

In addition to the resource constructor logic, we also had this inline helper function allowGetObjectPolicy:

Example: static_page.go a helper function

	allowGetObjectPolicy := func(bucketName string) (string, error) {
		policy := map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				{
					"Effect":    "Allow",
					"Principal": "*",
					"Action":    []string{"s3:GetObject"},
					"Resource":  []string{fmt.Sprintf("arn:aws:s3:::%s/*", bucketName)},
				},
			},
		}
		policyJSON, err := json.Marshal(policy)
		if err != nil {
			return "", err
		}
		return string(policyJSON), nil
	}

This function is used to create a S3 policy document, allowing public access to the objects in our bucket. It will be invoked within the context of ApplyT(...). That means that the bucketName, which is normally an asynchronous pulumi.StringOutput value, can be materialized as a normal Go string, and is passed into this function that way. Note that you can’t modify the value of bucketName, but you can read the value and use it to construct the policy document. The json.Marshal(...) function takes the map as input and returns it as a JSON formatted string.

Inheriting from the base class

class StaticPage : ComponentResource {

Inheriting from Pulumi.ComponentResource gives us some built-in behind-the-scenes behavior that allows the component state to be tracked and run within the Pulumi engine and within its host provider. It also allows the underlying library to find and infer the schema of the component.

Outputs as class properties

    [Output("endpoint")]
    public Output<string> Endpoint { get; set; }

We use a class property to store the output value. Component outputs should always use Pulumi.Output<T> rather than plain types. This ensures that outputs can be passed directly to other Pulumi resource inputs, which also accept Pulumi.Output<T>, without any additional unwrapping or conversion.

The Component constructor

    public StaticPage(string name, StaticPageArgs args, ComponentResourceOptions? opts = null)
        : base("sample-components:index:StaticPage", name, args, opts)
    {

The constructor has a few standard arguments:

• name: The name given to an instance of this component. When writing a Pulumi program, resources are named by the end-user. Later on in the implementation we will use this base component name to uniquely name the resources it contains.
• args: This is an instance of the argument class we defined earlier, containing the inputs for our component.
• opts: This is an optional set of common resource configuration values. The ComponentResourceOptions class is part of the basic API for all Pulumi resources, and will be passed to the constructors of our sub-resources later on.

Since we’re inheriting, we also need to call the base class constructor base(...). The first parameter is the name of the resource type, which is very important to get right. The resource type name has the following format: <package-name>:<module>:<component-class-name>. It must match exactly. Keep this in mind if you refactor the name of your package or the component’s class name. The module portion of this type name is always index and is a required implementation detail. Otherwise, we pass the name, args, and opts values from our component constructor into the base constructor.

Creating and managing sub-resources, dependencies, and execution order

Next we implement the Bucket, BucketWebsiteConfiguration, BucketObject, BucketPublicAccessBlock and BucketPolicy sub-resources.

        var bucket = new Bucket($"{name}-bucket", new() { }, new() { Parent = this });

        var bucketWebsite = new BucketWebsiteConfiguration($"{name}-website", new() {
            Bucket = bucket.BucketName,
            IndexDocument = new BucketWebsiteConfigurationIndexDocumentArgs { Suffix = "index.html" },
        }, new() { Parent = this });

        var bucketObject = new BucketObject($"{name}-index-object", new BucketObjectArgs {
            Bucket = bucket.BucketName,
            Key = "index.html",
            Content = args.IndexContent,
            ContentType = "text/html",
        }, new() { Parent = this });

        var publicAccessBlock = new BucketPublicAccessBlock($"{name}-public-access-block", new() {
            Bucket = bucket.BucketName,
            BlockPublicAcls = false,
        }, new() { Parent = this });

        var bucketPolicy = new BucketPolicy($"{name}-bucket-policy", new() {
            Bucket = bucket.BucketName,
            Policy = bucket.Id.Apply(this.AllowGetObjectPolicy),
        }, new() { Parent = this, DependsOn = publicAccessBlock });