Deploy the Changes

Now let’s deploy your changes.

$ pulumi up

First, 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)

Notice that your index.html file has been added:

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

Now that your index.html is in your bucket, modify the program to have the bucket serve the file as a static website. First, you need to 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,
    content: fs.readFileSync("site/index.html").toString(),
});

Finally, at the bottom of your program, 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 to have the bucket serve the file as a static website. First you need to 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,
    content: fs.readFileSync("site/index.html").toString(),
});

Finally, at the bottom of your program 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 to have the bucket serve the file as a static website. First you need to 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,
    content=open('site/index.html').read(),
)

Finally, at the bottom of your program 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 the file as a static website. First you need to 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(),
    Content:     pulumi.String(string(htmlContent)),
})

Finally, at the bottom of your program 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 the file as a static website. First you need to 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,
    Content = hmtlString,
});

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

// Export the name of the bucket
this.BucketName = bucket.Id;
this.BucketEndpoint = Output.Format($"http://{bucket.WebsiteEndpoint}");

[Output] public Output<string> BucketName { get; set; }
[Output] public Output<string> BucketEndpoint { get; set; }

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)

And you should see:

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

Next you will destroy the resources.

< PREVIOUS STEP Destroy the Stack >

The Pulumi Platform

Get Started

Migrate to Pulumi

Solutions for All Teams and Engineers

Any Code

Any Cloud

Deploy the Changes

On This Page