Deploy the Changes

Now let’s deploy your changes.

$ pulumi up

Pulumi will run the preview step of the update, which computes the minimally disruptive change to achieve the desired state described by the program.

Previewing update (dev):

     Type                    Name            Plan       Info
     pulumi:pulumi:Stack     quickstart-dev
 +   └─ aws:s3:BucketObject  index.html                 create

Resources:
    + 1 to create
    2 unchanged

Do you want to perform this update?
> yes
  no
  details

Choosing yes will proceed with the update and upload your index.html file to your bucket.

Do you want to perform this update? yes
Updating (dev):

     Type                     Name            Status      Info
     pulumi:pulumi:Stack      quickstart-dev
  +   └─ aws:s3:BucketObject  index.html                  created

Outputs:
    bucketName: "my-bucket-68e33ec"

Resources:
    + 1 created
    2 unchanged

Duration: 6s

Once the update has completed, you can verify the object was created in your bucket by checking the AWS Console or by running the following AWS CLI command:

$ aws s3 ls $(pulumi stack output bucketName)

$ aws s3 ls $(pulumi stack output bucketName)

$ aws s3 ls $(pulumi stack output bucket_name)

$ aws s3 ls $(pulumi stack output bucketName)

$ aws s3 ls $(pulumi stack output bucketName)

$ aws s3 ls $(pulumi stack output bucketName)

$ aws s3 ls $(pulumi stack output bucketName)

Notice that your index.html file has been added to the bucket:

2020-08-27 12:30:24         70 index.html

Now that your index.html is in your bucket, modify the program file to have the bucket serve index.html as a static website. First, set the website property on your bucket.

const bucket = new aws.s3.Bucket("my-bucket", {
    website: {
        indexDocument: "index.html",
    },
});

Next, your index.html object will need two changes: an ACL of public-read so that it can be accessed anonymously over the Internet, and a content type so that it is served as HTML:

const bucketObject = new aws.s3.BucketObject("index.html", {
    acl: "public-read",
    contentType: "text/html",
    bucket: bucket,
    source: new pulumi.asset.FileAsset("index.html"),
});

Finally, at the end of the program file, export the resulting bucket’s endpoint URL so you can easily access it:

exports.bucketEndpoint = pulumi.interpolate`http://${bucket.websiteEndpoint}`;

Now that your index.html is in your bucket, modify the program file to have the bucket serve index.html as a static website. First, set the website property on your bucket.

const bucket = new aws.s3.Bucket("my-bucket", {
    website: {
        indexDocument: "index.html",
    },
});

Next, your index.html object will need two changes: an ACL of public-read so that it can be accessed anonymously over the Internet, and a content type so that it is served as HTML:

const bucketObject = new aws.s3.BucketObject("index.html", {
    acl: "public-read",
    contentType: "text/html",
    bucket: bucket,
    source: new pulumi.asset.FileAsset("index.html")
});

Finally, at the end of the program file, export the resulting bucket’s endpoint URL so you can easily access it:

export const bucketEndpoint = pulumi.interpolate`http://${bucket.websiteEndpoint}`;

Now that your index.html is in your bucket, modify the program file to have the bucket serve index.html as a static website. First, set the website property on your bucket.

bucket = s3.Bucket('my-bucket',
    website=s3.BucketWebsiteArgs(
        index_document="index.html",
    ))

Next, your index.html object will need two changes: an ACL of public-read so that it can be accessed anonymously over the Internet, and a content type so that it is served as HTML:

bucketObject = s3.BucketObject(
    'index.html',
    acl='public-read',
    content_type='text/html',
    bucket=bucket.id,
    source=pulumi.FileAsset('index.html'),
)

Finally, at the end of the program file, export the resulting bucket’s endpoint URL so you can easily access it:

pulumi.export('bucket_endpoint', pulumi.Output.concat('http://', bucket.website_endpoint))

Now that your index.html is in your bucket, modify the program to have the bucket serve index.html as a static website. First, set the Website property on your bucket.

bucket, err := s3.NewBucket(ctx, "my-bucket", &s3.BucketArgs{
    Website: s3.BucketWebsiteArgs{
        IndexDocument: pulumi.String("index.html"),
    },
})

Next, your index.html object will need two changes: an ACL of public-read so that it can be accessed anonymously over the Internet, and a content type so that it is served as HTML:

_, err = s3.NewBucketObject(ctx, "index.html", &s3.BucketObjectArgs{
    Acl:         pulumi.String("public-read"),
    ContentType: pulumi.String("text/html"),
    Bucket:      bucket.ID(),
    Source:      pulumi.NewFileAsset("index.html"),
})

Finally, at the end of the program file, export the resulting bucket’s endpoint URL so you can easily access it:

ctx.Export("bucketEndpoint", pulumi.Sprintf("http://%s", bucket.WebsiteEndpoint))

Now that your index.html is in your bucket, modify the program to have the bucket serve index.html as a static website. First, set the Website property on your bucket.

// Add this import
using Pulumi.Aws.S3.Inputs;

var bucket = new Bucket("my-bucket", new BucketArgs
{
    Website = new BucketWebsiteArgs
    {
        IndexDocument = "index.html"
    }
});

Next, your index.html object will need two changes: an ACL of public-read so that it can be accessed anonymously over the Internet, and a content type so that it is served as HTML:

var bucketObject = new BucketObject("index.html", new BucketObjectArgs
{
    Acl = "public-read",
    ContentType = "text/html",
    Bucket = bucket.BucketName,
    Source = new FileAsset("index.html")
});

Finally, at the end of the program file, export the resulting bucket’s endpoint URL so you can easily access it:

return new Dictionary<string, object?>
{
    ["bucketName"] = bucket.Id,
    ["bucketEndpoint"] = Output.Format($"http://{bucket.WebsiteEndpoint}")
};

Now that your index.html is in your bucket, modify the program to have the bucket serve index.html as a static website.

First, add the BucketArgs and BucketWebsiteArgs classes to the list of imports.

// ...
import com.pulumi.aws.s3.BucketArgs;
import com.pulumi.aws.s3.inputs.BucketWebsiteArgs;

Next, extend the Bucket declaration to include a website property containing the filename to use as an indexDocument:

// ...
public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {

            // Create an AWS resource (S3 Bucket)
            var bucket = new Bucket("my-bucket", BucketArgs.builder()
                .website(BucketWebsiteArgs.builder()
                    .indexDocument("index.html")
                    .build()
                )
                .build()
            );

Now add two properties to the BucketObject: an ACL of public-read so that it can be accessed anonymously over the Internet, and a content type ensure it’s served as HTML:

// ...
public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            // var bucket = ...

            // Create an S3 Bucket object
            new BucketObject("index.html", BucketObjectArgs.builder()
                .bucket(bucket.getId())
                .source(new FileAsset("index.html"))
                .acl("public-read")
                .contentType("text/html")
                .build()
            );

Finally, at the end of the program file, export the resulting bucket’s endpoint URL so you can access it easily. You can do that by importing the Pulumi Output class:

// ...
import com.pulumi.core.Output;

And adding a line to read the endpoint from the Bucket instance:

// ...
public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {

            // ...
            ctx.export("bucketEndpoint", Output.format("http://%s", bucket.websiteEndpoint()));
        });

Now that your index.html is in your bucket, modify the program to have the bucket serve index.html as a static website. To do that, set the bucket’s website property, passing the filename to use as an indexDocument:

resources:
  my-bucket:
    type: aws:s3:Bucket
    properties:
      website:
        indexDocument: index.html

Now add two properties to the BucketObject: an ACL of public-read so that it can be accessed anonymously over the Internet, and a content type ensure it’s served as HTML:

resources:
  # ...
  index.html:
    type: aws:s3:BucketObject
    properties:
      bucket: ${my-bucket}
      source:
        Fn::FileAsset: ./index.html
      acl: public-read
      contentType: text/html

Finally, at the end of the file, export the resulting bucket’s endpoint URL so you can access it easily:

# ...
outputs:
  bucketName: ${my-bucket.id}
  bucketEndpoint: http://${my-bucket.websiteEndpoint}

Now update your stack to have your S3 bucket serve your index.html file as a static website.

$ pulumi up

First, you will see a preview of your changes:

Previewing update (dev):

     Type                    Name            Plan       Info
     pulumi:pulumi:Stack     quickstart-dev
 ~   ├─ aws:s3:Bucket        my-bucket           update     [diff: +website]
 ~   └─ aws:s3:BucketObject  index.html          update     [diff: ~acl,contentType]

Outputs:
  + bucketEndpoint: output<string>

Resources:
    ~ 2 to update
    1 unchanged

Do you want to perform this update?
> yes
  no
  details

Select yes to deploy both changes:

Do you want to perform this update? yes
Updating (dev):

     Type                     Name            Status      Info
     pulumi:pulumi:Stack      quickstart-dev
~   ├─ aws:s3:Bucket        my-bucket           updated     [diff: +website]
~   └─ aws:s3:BucketObject  index.html          updated     [diff: ~acl,contentType]

Outputs:
  + bucketEndpoint: "http://my-bucket-b9c2eaa.s3-website-us-east-1.amazonaws.com"
    bucketName    : "my-bucket-b9c2eaa"

Resources:
    ~ 2 updated
    1 unchanged

Duration: 12s

Finally, you can check out your new static website at the URL in the Outputs section of your update or you can make a curl request and see the contents of your index.html object printed out in your terminal.

$ curl $(pulumi stack output bucketEndpoint)

$ curl $(pulumi stack output bucketEndpoint)

$ curl $(pulumi stack output bucket_endpoint)

$ curl $(pulumi stack output bucketEndpoint)

$ curl $(pulumi stack output bucketEndpoint)

$ curl $(pulumi stack output bucketEndpoint)

$ curl $(pulumi stack output bucketEndpoint)

And you should see:

<html>
    <body>
        <h1>Hello, Pulumi!</h1>
    </body>
</html>

Next you will destroy the resources.

← Previous Step Destroy the Stack →

Deploy the Changes

On This Page