Pulumi Blog: Sean Holung

Enhanced search & Navigation: The new Pulumi Docs experience

susan evans — Mon, 12 Jun 2023 00:00:00 +0000

Engineers spend a lot of their valuable time searching documentation for answers. At Pulumi, we believe in exceptional documentation experiences that help people using Pulumi find what they need quickly and use it successfully. Today, we are announcing a set of improved Pulumi documentation experiences that collectively make it easier than ever to discover, learn and build cloud infrastructure with Pulumi.

The improvements we’ve introduced to the Pulumi documentation experience focus on three areas - search, navigation and discoverability. Together, they help every user of the Pulumi documentation find the answers they are looking for quickly, so they can solve their infrastructure as code use case and leverage Pulumi effectively in their projects. These changes also introduce new design patterns and user experience elements across previously independent parts of the Pulumi documentation experience, creating a more cohesive developer experience.

Search

As of today, you can quickly and easily search for documentation across all of these types, and we will lead you to the documentation you are looking for to solve your problem. The new search clearly groups documentation by Docs and Packages with clear breadcrumbs to quickly get you to the right place.

We have unified navigation across both docs and packages and expect to add more content types to Pulumi Docs over the rest of the year. Enjoy easily switching between documentation types while having your left navigation and table of contents navigation remain consistent.

Discoverability

In addition to search and navigation, folks must be able to discover new content that will help them even if they don’t know that content exists. To that end, let’s showcase a few types of Pulumi documentation:

Quickstart experience

The Pulumi quickstart experience is for people new to Pulumi to get up and running quickly.

Cloud get started tutorials

The Pulumi cloud get started tutorials are for people who want a more detailed walkthrough when using Pulumi for the first time.

Concept docs

The Pulumi concept docs are where you can dive into Pulumi concepts. Learn how they work together and how to effectively use them to ship infrastructure.

Packages

The package documentation is where to find configuration and API documentation for Pulumi supported clouds, version control systems, databases, infrastructure monitoring, and networking tools. We support 119 providers today, and we add new providers every week!

Head to Pulumi docs, learn something new, and send us your feedback!

Introducing the Azure Static Website Component

Sean Holung — Tue, 11 Oct 2022 00:00:00 +0000

Deploying a static website often involves provisioning a number of pieces of infrastructure and stitching those pieces together in a way to make the site accessible to your users. A static website typically consists of HTML, CSS, and JavaScript files along with any other static assets the site might need to render such as PNG and SVG files for example. These files are then uploaded to a storage bucket where they can be served from. This post will demonstrate how to easily deploy your static website to Azure and make it available for public access.

Azure Static Website Component

Pulumi components enable us to create re-usable abstractions that can perform complex tasks all behind a simple interface the user can programmatically interact with. The Azure Static Website component looks to take all of the complexity of getting a static website deployed to Azure and simplify it down to just consuming a simple component and passing it a few input arguments. This component relieves the complexities of this process by allowing you to simply tell the component where your files are located and it will take care of all the rest.

This component does the following:

Provisions an Azure storage account
Uploads the website contents located in the specified directory
Optionally can configure a CDN, custom domain, and certs.

Using the component to deploy a static website

Let’s walk through a simple example of using this component to deploy a static website. Today, we are going to provision a storage account, upload the website contents, and wire it up to an Azure CDN.

In order to follow along with this example you will need to have the following:

Pulumi CLI installed on your machine
Access to an Azure account to provision the infrastructure
Static site to upload

See our getting started guide for information on how to configure Pulumi and Azure.

We will provision a number of pieces of infrastructure in Azure to enable serving our static website. The main ones are a Storage Account to contain all of our website files and a CDN. Let’s start by creating a new Pulumi project. First, create a new directory on your machine where the Pulumi project will live. A common pattern is to include the infrastructure configuration in a directory alongside the website you will be deploying. You can create a directory called infrastructure to house the Pulumi program or you can use another name if you prefer. This allows us to easily reference the location of the contents of your site as well as keeps your infrastructure code along-side your application. Pulumi supports multiple programming languages such as TypeScript, Python, Go, .NET, and even markup languages like YAML. Once you have created the directory, run the following command for your language of choice inside the directory:

pulumi new azure-typescript

pulumi new azure-python

pulumi new azure-csharp

pulumi new azure-go

pulumi new azure-yaml

There will be some prompts that appear asking you a few questions. Feel free to accept the defaults or change them to your desired preference. This command generated a new project and created a few files for you. You can copy the code examples below for the language you chose to use.

import * as pulumi from "@pulumi/pulumi";
import * as website from "@pulumi/azure-static-website";

const site = new website.Website("site", {
 sitePath: "../site", // replace with path containing website contents
 withCDN: true,
});

export const cdnURL = site;

import pulumi
import pulumi_azure_static_website as azure_static_website

site = azure_static_website.Website("site",
 site_path="../site", # replace with path containing website contents
 with_cdn=True)
pulumi.export("cdnURL", site.cdn_url)

using System.Collections.Generic;
using Pulumi;
using AzureStaticWebsite = Pulumi.AzureStaticWebsite;

return await Deployment.RunAsync(() =>
{
 var web = new AzureStaticWebsite.Website("web", new()
 {
 WithCDN = true,
 SitePath = "../site", // replace with path containing website contents
 });

 return new Dictionary<string, object?>
 {
 ["websiteURL"] = web.CdnURL,
 };
});

package main

import (
 "github.com/pulumi/pulumi-azure-static-website/sdk/go/azure-static-website"
 "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
 pulumi.Run(func(ctx *pulumi.Context) error {
 web, err := azure - static - website.NewWebsite(ctx, "web", &azure-static-website.WebsiteArgs{
 WithCDN: pulumi.Bool(true),
 SitePath: pulumi.String("../site"), // replace with path containing website contents
 })
 if err != nil {
 return err
 }
 ctx.Export("websiteURL", web.CdnURL)
 return nil
 })
}

name: az-website
runtime: yaml
description: A static website build with pulumi-azure-static-website.
resources:
 web:
 type: "azure-static-website:index:Website"
 properties:
 withCDN: true
 sitePath: "../site"
outputs:
 websiteURL: ${web.cdnURL}

This code creates a new instance of the Website component and sets a couple of properties. sitePath is the location where your website contents live. The sitePath specified should be the output location of your website’s build not the overall directory where your application lives. For example, if using a framework like React, the build output is usually placed in a directory called build. In addition, we set withCDN to true to let the component know that you would like to provision a CDN as well. It also exports the cdnURL property, which is the URL where the site can be accessed. That’s all that is needed and now we are ready to deploy!

You can now run pulumi up to deploy the site to Azure. This will first show a preview of the resources that will be provisioned. You can go ahead and accept by selecting yes.

In a few minutes your site will be provisioned and ready to access. Use the cdnURL that was output at the end of the provisioning to access the site!

As you can see, the Azure static website component made this task very easy. With just a few lines of code we were able to provision our site.

If you would like to learn more about Pulumi, here are some links you may find interesting:

Visit our Getting Started to quickly get up and running with Pulumi.
View the GitHub repo for the Azure static website component.
Visit our registry page to more components we have available for you to consume.
Check out our new templates that make it quick and easy to deploy common cloud architectures.

Create an AWS Static Website Fast with Angular and Pulumi

Sean Holung — Wed, 24 Aug 2022 00:00:00 +0000

In this blog post, we’re going to use some Angular framework components to assemble a static website and then use Pulumi and its AWS Static Website component to deploy it to AWS. The website is for a café called the Pulumi Café. It will contain two pages, one an About page and the other a Menu page, as well as some navigational pieces.

To follow this example, you need to have both Angular and Pulumi installed. (Here’s a link to the Pulumi installation instructions.) You’ll also need an AWS account.

What is Angular?

Angular is an open-source UI framework for building single-page client applications with HTML and TypeScript. Angular itself is written in TypeScript and its architecture follows the Model-View-Controller (MVC) design pattern.

What are Components in Angular?

In Angular, the basic building blocks of a website are called components. These are reusable structures that contain their own logic and functionality. For example, you could create a button as an Angular component and program it to have a particular look and a particular behavior. Then, you would reuse the button component wherever you need it in the website. The button could also be configurable meaning that, based on different properties, you could change its look and behavior.

A simple website, like the one we’ll be building in this post, is mainly created from a group of Angular components.

What is the AWS Static Website Component?

The AWS Static Website component from Pulumi makes it easy to deploy an AWS S3 static website and, optionally, add a CloudFront content distribution network (CDN). While you can use any of the programming languages Pulumi supports (TypeScript, JavaScript, Python, Go, .NET, Java, and YAML), we’ll be using TypeScript, since that is what the Angular framework uses.

The great advantage of the AWS Static Website component is that you can have a complete, functioning site in a few minutes. The component encapsulates all the complex logic that an AWS static website requires. Without the component, you would need to spend hours or even days writing and debugging code to get the same result.

If you’re interested in learning more about the component, read Deploy Static Websites to AWS using 10 lines of YAML.

The Angular Components

All the Angular components you need to build the website are available in the GitHub repository. The repository contains:

A component for the left navigation bar.
A component for the top navigation bar.
A component for the Home page.
A component for the Menu page.

We also use some components that come with the Angular framework.

Each of the components has a TypeScript file that contains the programming logic and an HTML file that describes how the component will render.

Building the Pulumi Café Website

Here are the instructions to build the website.

Clone the GitHub repository located here.
Run npm install to install the website’s node dependencies.

Deploy the Site with Pulumi

You’re now ready to set up Pulumi to deploy the site to AWS.

Create a directory named pulumi in the root of the project directory and then navigate to it with this command:
```
mkdir pulumi && cd pulumi
```
You’re now in the pulumi directory. Generate a Pulumi project file and create a Pulumi.yaml file with the following command. You will be asked a few questions from the prompt. Use angular-static-website for the project name and accept the suggested defaults for the remaining questions:
```
pulumi new aws-yaml
```

Modify the .yaml File

We need to add a few lines of code to the Pulumi.yaml file. In the resources section, the code references the AWS Static Website component and sets the sitePath property to the location of the dist build directory. We also want to know the URL of the site once it’s deployed. That’s what the outputs section does. The websiteURL parameter is one of the outputs that the AWS Static Website component provides. Replace the contents of Pulumi.yaml with the following code:

name: angular-static-website
runtime: yaml
description: Example of deploying Angular with Pulumi
resources:
 web:
 type: "aws-static-website:index:Website"
 properties:
 sitePath: "../dist/"
outputs:
 websiteURL: ${web.websiteURL}

The AWS Static Website component is the reason you only need a few lines of code to deploy the site. By using it, all the work of setting up AWS is done for you.

To deploy the website, type pulumi up. You’ll first see a preview of all the resources that will be created. Confirm that you want to proceed and Pulumi deploys the website to AWS.

It’s that simple. With just a few lines of code and one command you deployed your site. Navigate to the site and you’ll see the Home page for the café.

You can see the navigation components on the left-hand side. Click Menu to see the Menu page.

Manage Your Site with Pulumi

Along with making it simple to deploy your site, Pulumi also makes it easy to perform some management tasks. For example, If you want to take down the site, run pulumi destroy. You never have to worry that you’ll forget to remove some resource and continue to pay for it. Pulumi also keeps track of changes to website files, can generate resource graphs and give you complete information about the resources you’re using.

Learn More

If you want to learn more about Pulumi and the AWS Static Website component, here are a few links you might find interesting:

Along with the Deploy Static Websites to AWS using 10 lines of YAML blog post, take a look at the AWS Static Website reference page.
If you want to learn about other Pulumi components, the registry page catalogs them all.
If you want to view more examples of how to use Pulumi, go to the Pulumi examples repo.
If you want to delve deeper into Pulumi, the Getting Started guide is a good first step.
If you’re interested in learning more about Pulumi concepts, try the Concepts page.
If you want to learn more about Angular, see their Getting Started docs.

Deploy Static Websites to AWS using 10 lines of YAML

Sean Holung — Thu, 07 Jul 2022 00:00:00 +0000

The AWS Static Website component makes it easy to deploy an AWS S3 static website and, optionally, add a CloudFront content distribution network (CDN). While you can use any of the programming languages Pulumi supports (TypeScript, JavaScript, Python, Go, .NET, Java, and YAML), the component is particularly useful if you use YAML or JSON. With the AWS Static Website component, you’ll have a complete, functioning site in a few minutes. Without it, you can spend hours or even days to get the same result.

The component is designed to be simple to use and accessible to a broad range of developers. The only prerequisites are a basic knowledge of YAML or JSON, an AWS account, and an understanding of what a static website is. Even if you’re not used to thinking about infrastructure as code (IaC), you can use the component and let it handle the complexities that make setting up a website so time consuming.

You will need to have Pulumi on your machine to use the component because you run the pulumi up command to deploy the website. There’s a link to the installation instructions at the end of this article. You’ll also need an AWS account.

What the Component Does

The component deploys a static website to AWS and, optionally, a CloudFront CDN. You simply add a few lines of code, set a few configuration parameters, run pulumi up and let the component do the rest. The component sets up:

An Amazon S3 bucket
An Amazon CloudFront CDN (optional)
- An Amazon Route 53 DNS record
- An Amazon Certificate Manager SSL/TLS certificate

Some Examples

Let’s look at two examples of how to use the component. We’re going to use YAML in this post, but JSON is also supported as well.

Create a Website

This YAML code creates a basic static website.

name: react-static-website
runtime: yaml
description: Example of deploying React with Pulumi
resources:
 web:
 type: "aws-static-website:index:Website"
 properties:
 sitePath: "../my-website/build"
outputs:
 websiteURL: ${web.websiteURL}

This is the JSON equivalent of the code shown above.

{
 "name": "react-static-website",
 "runtime": "yaml",
 "description": "Example of deploying React with Pulumi",
 "resources": {
 "web": {
 "type": "aws-static-website:index:Website",
 "properties": {
 "sitePath": "../my-website/build"
 }
 }
 },
 "outputs": {
 "websiteURL": "${web.websiteURL}"
 }
}

This example code deploys a static React website but you can use the component with any other static website framework, such as Hugo. The only parameter that would change is the output directory specified in the sitePath property.

The first two lines of this example give the project a name and tell Pulumi that the code is YAML. The next line is simply a description of the project.

Next you allocate a resource. This is a Pulumi term. Resources are the fundamental units that make up your cloud infrastructure and Pulumi provides many resources that are ready for you to use. Here, you only need one: aws-static-website:Website, which is the AWS Static Website component. The resource has an input property, sitePath, which is the root directory that contains the website’s contents. Of course, you can use any path you want.

Finally, you’ll probably want to know the URL of your new site once it’s deployed. That’s what the outputs line does. websiteURL is one of the outputs that the component provides.

Get Started

To get started, go to the folder that contains your static website project. Then, follow these steps.

Create a directory named infrastructure alongside your website project directory with this command:
```
mkdir infrastructure && cd infrastructure
```
You’re now in the infrastructure directory. Generate a Pulumi.yaml file with this command:
```
pulumi new aws-yaml
```
Here’s an example of what the final directory structure looks like.
```
| react-project-dir
├── my-website
| ├── build
│ ├── index.html
│ ├── main.css
├── infrastructure
│ ├── Pulumi.yaml
```
Note: Pulumi will also add some other files to the infrastructure directory, such as a file that contains information specific to your Pulumi stack.

Copy the resources section and the outputs section from the example and add it to the end of the Pulumi.yaml file.

resources:
 web:
 type: "aws-static-website:index:Website"
 properties:
 sitePath: "../my-website/build"
outputs:
 websiteURL: ${web.websiteURL}

Deploy the Website

To deploy the website, type pulumi up. You’ll first see a preview of all the resources that will be created. You then confirm that you want to proceed and Pulumi deploys the website.

What You Gain

The entire example has 10 lines of YAML code. With this, you will get an S3 bucket provisioned with all of your website’s contents. If you looked at the preview screen when you ran pulumi up, you saw the many resources that actually had to be deployed to create the site. You never see any of that complexity. Here’s an example of what’s happening under the hood.

If you follow the View Live link, you will go to the Pulumi Service, where you can see all of the information available about a deployment and explore the resources that were deployed. For example, you can see a resource graph and a list of resources. Here’s an example of a resource graph.

After Pulumi deploys the website, it will display any outputs you specified which, in our example, is the URL of the site. as well as the number of resources created.

Input Properties

The AWS Static Website component has several input properties. Here are three of the most commonly used.

sitePath - the root directory that contains the website’s contents (required).
withCDN - sets a flag to provision a CloudFront CDN.
targetDomain - the domain that serves the content. A Route53 hosted zone must exist for this domain if you specify this option.

See the component’s reference page for the other properties this component supports.

Output Properties

The AWS Static Website component has several output properties. The one you’ll probably use the most is websiteURL, which is the URL to access the website. See the component’s reference page for the others.

Add a CloudFront CDN

To add a CloudFront CDN, you only need to add one more line of code.

name: react-static-website
runtime: yaml
description: Example of deploying React with Pulumi
resources:
 web:
 type: "aws-static-website:index:Website"
 properties:
 sitePath: "./my-website/build"
 withCDN: true
outputs:
 websiteURL: ${web.websiteURL}

All you have to do is add the line withCDN: true and the component sets up the CDN instance for you. Again, run pulumi up, confirm that you want to proceed, and Pulumi deploys the website. Here’s an example of what you’ll see.

And here’s the output.

More Pulumi Advantages

We’ve already seen how much Pulumi simplifies creating a website. Pulumi also keeps track of any changes you make to any of the website files. It makes those changes the next time you run pulumi up. Here’s an example screenshot. The changes are marked in the Plan column.

If you simply want to take an inventory of what’s changed, you can run pulumi up and not proceed with the confirmation. Alternatively, you can run pulumi preview.

If you want to take down the site, run pulumi destroy. Pulumi marks all the resources for deletion. It first previews the changes and, if you confirm, removes them from your AWS account. You don’t have to worry that you’ll forget to remove some resource and continue to pay for it. Here’s an example of what you’d see if you ran pulumi destroy on your AWS S3 static website.

Learn More

If you’re curious and want to learn more about Pulumi and the AWS Static Website component, here are a few links you might find interesting:

You can examine the GitHub repository that contains the code for the component.
If you want to quickly try out the component, this GitHub repo houses a complete React example project that you can clone.
If you want to learn about other Pulumi components, take a look at the registry page, which catalogs them all.
If you want to view more examples of how to use Pulumi, take a look at the Pulumi examples repo.
If you want to delve deeper into Pulumi, the Getting Started guide is a good first step.
If you’re interested in learning more about Pulumi concepts, try the Concepts page.

Install Pulumi

To install Pulumi for AWS, go to Before You Begin. There are instructions for macOS, Windows and Linux. You need to have an AWS account.

Auditing Your Organization's Infrastructure as Code Activity

Sean Holung — Thu, 20 Feb 2020 00:00:00 +0000

We are excited to announce the release of Audit Logs on Pulumi for Enterprise organizations. Audit logs enable you to track the activity of users within an organization. They attempt to answer what a user did, when they did it and where. They help answer these questions by recording user actions.

Pulumi’s audit logs allow you to account for the activity your users are taking within your organization. These logs are available to organizations with an Enterprise level subscription. The logs are immutable and and record all user actions. Auditing makes the activity of members in an organization attributable. The logs capture the UNIX timestamp of the event, the user who invoked the action, the event that took place, and the source IP of the call the user made.

Using Pulumi Audit Logs

Audit logs are available to organizations with an Enterprise level subscription only. If you are an organization administrator, you can view your organization’s audit logs, by selecting your organization from the organization drop down. Then click on the settings tab. On the left nav-bar you should see a tab called Audit Logs. Clicking here will allow you to view the most recent audit logs for your organization.

This will show the most recent events in descending order. You can also filter logs by a particular user by clicking on the user’s avatar. Doing so will filter out the events performed by the user you selected.

We are excited to make this feature available to our users. Get started with audit logs on Pulumi today.

Pulumi Blog: Sean Holung

Enhanced search & Navigation: The new Pulumi Docs experience

Search

Unified navigation

Discoverability

Quickstart experience

Cloud get started tutorials

Concept docs

Packages

Introducing the Azure Static Website Component

Azure Static Website Component

Using the component to deploy a static website

Create an AWS Static Website Fast with Angular and Pulumi

What is Angular?

What are Components in Angular?

What is the AWS Static Website Component?

The Angular Components

Building the Pulumi Café Website

Deploy the Site with Pulumi

Modify the .yaml File

Manage Your Site with Pulumi

Learn More

Deploy Static Websites to AWS using 10 lines of YAML

What the Component Does

Some Examples

Create a Website

Get Started

Deploy the Website

What You Gain

Input Properties

Output Properties

Add a CloudFront CDN

More Pulumi Advantages

Learn More

Install Pulumi

Auditing Your Organization's Infrastructure as Code Activity

Using Pulumi Audit Logs