Infrastructure as Code with Pulumi: A 3-Part Series on Mastering IaC in AWS – Part 1

Part 1: Introduction to Infrastructure as Code and Pulumi


In the tech world, we use code to build our IT infrastructure. This method is known as Infrastructure as Code (IaC), which makes setting up and managing infrastructure easier and more efficient. Whether you’re a novice developer just stepping into the vast world of IT, or a veteran techie, IaC is something that can streamline your workflows and skyrocket your productivity. Also, its a great way set yourself apart from everyone else still doing things manually.

In this series, we will delve deeper into the world of IaC, and specifically, we will explore using the exciting features of Pulumi to deploy infrastructure resources to AWS Cloud. There are a couple of other notable IAC tools such as Terraform and CloudFormation, but Pulumi will be the focus of this series. If you’re excited about building infrastructure as code, and would love to do so with a programing language such as Python, strap yourself in as we embark on this exiting learning journey.

Pulumi Basics

Choosing Your IaC Tool: Pulumi vs. the Rest

In the Infrastructure as Code (IaC) domain, several tools compete for attention. Terraform and CloudFormation are two known entities, but Pulumi is emerging as a solid alternative.

Terraform excels with its platform-agnostic approach, and CloudFormation is deeply integrated with AWS. However, Pulumi differs by supporting general-purpose programming languages such as TypeScript, Python, Go, and C#. Rather than using proprietary languages like Terraform’s HCL or CloudFormation’s JSON or YAML, Pulumi enables developers to define infrastructure with languages they’re already comfortable with.

Installing and setting up environment

In this series, we will be using Python. Feel free to use whatever language you’re most comfortable with, or follow along easily by using Python as well. You can install Pulumi and Python through a simple command-line installation, and it is available for most operating systems, including Linux, macOS, and Windows.

The procedure for installing Pulumi and Python runtime on your Operating System can be be found at Pulumi official documentation website.

After you’ve installed Pulumi, the next step is to set up your preferred cloud provider account. Since we are deploying to AWS in this series, you would need to create your AWS credentials. The procedure for creating an AWS user and Access credentials can be found on AWS documentation website and Pulumi documentation website. Once done with these steps, you’re all set to create your first Pulumi project.


In the first part of this series, we’ll locally deploy AWS resources via Pulumi using IAM credentials. This method provides a basic understanding of managing AWS infrastructure with Pulumi. However, this approach isn’t suited for large-scale deployments. Upcoming segments will introduce advanced techniques, shifting from local management to automated, secure deployments using CI/CD pipelines and AWS IAM roles. This transition ensures efficient and professional infrastructure management.


Getting Started with Pulumi in AWS

Once you have Pulumi installed and your AWS credentials configured, it’s time to create your first Pulumi project. A Pulumi project is simply a directory that contains your infrastructure code. Here are the steps to create a Pulumi project using the Python SDK on your local machine:

Choose or Create a Directory

You can either use an existing directory or create a new one. To create a new directory, navigate to your desired location and run the following commands:

mkdir pulumi-infra

mkdir pulumi-infra/basic

Now, navigate into your new directory using this command:

cd pulumi-infra/basic


Create and Initialize a New Project

Now that you’re inside your project directory, it’s time to create your new Pulumi project. To initialize a new project using the Python SDK, run the following command:

pulumi new aws-python

The pulumi new command sets up a new project using a provided template. In this case, aws-python creates a new Pulumi project set up for AWS and using Python.


Fill in Project Details

Running the pulumi new command will prompt you to provide some details about your project:

  • Project name: A unique name for your project. This could be the same as your directory name. (basic)
  • Project description: A short description of your project.
  • Stack name: The name of the stack. This is ‘dev’ by default.
  • AWS region: The AWS region where resources will be deployed, such as ‘us-east-1’.

Fill in these details as prompted. If you’d like to accept the default values, simply press enter.

Congratulations! You’ve just created your first Pulumi project using Python SDK. You should now have a directory with a Pulumi.yaml file (which contains your project’s details), a file (which contains the configuration for your ‘dev’ stack), and a file (where you’ll write your infrastructure code).


Writing a simple pulumi script that creates an S3 bucket

Now that you have created a Pulumi project, it’s time to write some infrastructure code. Let’s create a simple Pulumi script using Python SDK that will create an Amazon S3 bucket.

To get started, you’ll be working in the file, which was created when you initialized your Pulumi project.

Here’s a step-by-step guide on how to do this:

  • The first thing you need to do is import the required modules. Add these lines at the beginning of the file:
import pulumi

from pulumi_aws import s3


  • Next, use the s3.Bucket function to create a new S3 bucket:
bucket = s3.Bucket(‘my-bucket’)

This code creates an S3 bucket with a default configuration. The string ‘my-bucket’ is an identifier that will be used by Pulumi to track the bucket.


  • Finally, you’ll want to export the bucket name so it can be easily accessed:
bucket = s3.Bucket(‘my-bucket’)

This code exports the name of the bucket so you can easily access it from the Pulumi CLI or the Pulumi Console.


Putting it all together, your file should look something like this:

import pulumi

from pulumi_aws import s3

bucket = s3.Bucket(‘my-bucket’)


Congratulations, you’ve just written a Pulumi script that creates an S3 bucket!


Deploy S3 bucket to AWS account

After writing the Pulumi script for creating an S3 bucket, the next step is to deploy the bucket to your AWS account. To do this, you’ll use the Pulumi command-line interface (CLI).

Follow these steps to deploy your S3 bucket:

  • Before you make any changes to your infrastructure, it’s a good idea to preview what will happen. From the command line, within your Pulumi project directory, run:
pulumi preview

This command will display a preview of the changes that Pulumi will make to your AWS infrastructure. You should see that Pulumi is planning to create an S3 bucket.

  • If the preview looks correct, you can proceed with the deployment. To deploy the changes, run:
pulumi up

Pulumi will ask you to confirm the deployment. Type yes and press enter to proceed.

During the deployment, Pulumi will display progress information on the command line. Once the deployment is complete, you should see a message indicating that the deployment was successful.

  • To verify that the S3 bucket was created successfully, you can check your AWS console, or you can use the AWS CLI to list your S3 buckets:
aws s3 ls

You should see your new bucket listed.

Congratulations! You have successfully used Pulumi to deploy an S3 bucket to your AWS account.



In this first part of our Pulumi and Infrastructure as Code series, we’ve taken some significant strides. We’ve set up our local development environment, configured our AWS IAM user credentials, and initialized our Pulumi project using the Python SDK. But most importantly, we’ve successfully written and deployed a Pulumi script that creates an S3 bucket in our AWS account.

This hands-on experience gives you a sense of how Pulumi can programmatically create and manage cloud resources. It showcases the ease of using a familiar programming language, Python, to define and deploy infrastructure.

Preview of Part 2

In the upcoming second part of this series, we’ll dive deeper into the world of Pulumi and Infrastructure as Code. We will explore some more advanced concepts, including deploying infrastructure from a continuous integration/continuous deployment (CI/CD) pipeline and using AWS IAM roles for more secure access management.

We will also expand our infrastructure, going beyond creating a simple S3 bucket. Expect more complex architectures and a wider range of AWS services. As we transition from local, manual infrastructure management to automated, secure deployments via CI/CD, we’ll be moving closer to the practices used in professional-grade infrastructure operations. So, stay tuned, and get ready to level up your Infrastructure as Code skills with Pulumi and AWS!



Submit a Comment

Your email address will not be published. Required fields are marked *