Technical requirements

If you would like to follow along with the examples in this chapter, you will require the following:

• The Pulumi CLI is required for executing commands. You can download it from https://www.pulumi.com/docs/iac/download-install/.
• Pulumi supports multiple programming languages, but for this chapter, we'll be using JavaScript/TypeScript, which requires Node.js. You can download and install it from the Node.js official site here: https://nodejs.org/.

Introduction to IaC

One of the main problems IaC solves is configuration drift. In the early days of managing infrastructure, system administrators would manually configure servers, networks, and storage. Over time, as systems were updated and maintained, the configuration of one server might start to differ from another. This inconsistency, known as configuration drift, could lead to unpredictable behavior, bugs, or failures because different servers no longer worked the same way.Before IaC, the process of managing infrastructure was also slow and prone to human error. If you needed to set up new servers, you'd do it manually, often following a checklist. But if that checklist wasn’t followed exactly or someone made a mistake, the new server might not work properly. Reproducing the exact environment became difficult, and scaling was even harder. If you needed to deploy 10 or 100 servers, you’d have to configure each one individually, which took a lot of...

Installing Pulumi and dependencies

Pulumi is an IaC tool that takes a different approach by treating infrastructure like software. This means that instead of using configuration files in a domain-specific language (DSL) like other IaC tools, you can define and manage your infrastructure using general-purpose programming languages such as JavaScript, Python, TypeScript, Go, or C#. With Pulumi, developers can use familiar coding practices, making it easier to integrate infrastructure management into the software development workflow.The concept of infrastructure as software means that you can manage cloud resources in the same way you manage software code. Just like you write code to build applications, you write code to define your infrastructure. This code can be versioned, tested, reused, and shared, just like application code. This approach brings together the worlds of software development and cloud infrastructure, allowing for more flexible and powerful management.Pulumi...

Understanding resources and stacks

When working with cloud infrastructure, resources are the basic building blocks of your system. These resources represent services such as virtual machines, databases, networking components, and storage systems. Each of these elements is critical to making your applications run efficiently and at scale in the cloud. A resource in Pulumi represents a single cloud infrastructure component. For example, an Amazon EC2 instance, an Azure Blob Storage container, or a Google Cloud SQL instance can all be treated as resources in Pulumi.Here’s an example of a simple Pulumi TypeScript code to define an Azure storage account (a storage resource):

// Create an Azure resource group
const resourceGroup = new azure.resources.ResourceGroup("testgroup");
// Create an Azure storage account
const storage = new azure.storage.StorageAccount("teststorage", {
     resourceGroupName: resourceGroup.name,
     sku: {
  ...

Pulumi state and state management

One of the core concepts when working with IaC tools such as Pulumi is state management. Pulumi tracks the state of your cloud infrastructure, which is necessary to understand what resources exist, their current configuration, and how they relate to each other. This information is crucial when making updates or destroying resources, as it allows Pulumi to know exactly what needs to be created, modified, or deleted.In Pulumi, state refers to a snapshot of the resources that have been deployed by Pulumi in a given stack. Pulumi keeps this state to ensure that it can compare the current live infrastructure with the desired infrastructure defined in your code. This state file is automatically updated whenever you make changes to your infrastructure by running commands such as pulumi up or pulumi destroy.When you run pulumi up, Pulumi takes the infrastructure configuration you've defined in code (such as creating a virtual network or a storage...

The Pulumi programming model

The Pulumi programming model revolves around using standard programming constructs such as loops, conditionals, functions, and variables to define cloud infrastructure. The benefit of using familiar languages is that you can reuse libraries, apply business logic, and manage infrastructure in a more dynamic and flexible way.At a high level, Pulumi works by taking the code you write, comparing it to the current state of your infrastructure, and then applying any necessary changes to reach the desired state. This is done through a series of steps:

1. Write infrastructure code: You define your cloud infrastructure using code in the programming language of your choice. For example, you might define virtual machines, storage accounts, databases, or networking resources.
2. Pulumi CLI: The Pulumi CLI is the command-line tool used to manage your Pulumi projects. When you run commands such as pulumi up, Pulumi takes your infrastructure...

Pulumi CLI: key commands and operations

The Pulumi CLI is an essential tool when working with Pulumi. It provides the commands needed to define, deploy, and manage your infrastructure through code. Pulumi’s CLI enables you to create, update, and destroy cloud resources, as well as manage the different stacks (environments) that you’re working with.In this section, we will explore the most important Pulumi CLI commands, how to use them, and what each one does. If you’re working with Pulumi, becoming comfortable with the CLI is crucial, as it’s where you’ll spend most of your time deploying and managing your cloud infrastructure:

• pulumi new: This command initializes a new Pulumi project. When you’re starting a new infrastructure project, this is the first command you’ll run. It sets up everything you need to begin writing code to manage your cloud resources. Here's how you can use it:

Input, output, and configuration

In Pulumi, inputs, outputs, and configuration are essential for managing cloud infrastructure. These concepts work together to allow for the dynamic handling of resources, their dependencies, and environment-specific values.

// Create a resource group
const rgroup = new azure.resources.ResourceGroup("myResourceGroup");
// Create a storage...

Summary

In this chapter, we covered essential concepts of IaC and the specific steps to get started with Pulumi. We learned how IaC solves issues such as configuration drift and manual errors by allowing infrastructure to be managed as code. The chapter outlined the installation process for Pulumi on different operating systems, followed by explanations of key topics such as resources, stacks, and state management. We also explored how Pulumi handles infrastructure changes by tracking the state and ensuring synchronization between code and the live environment. Important commands such as pulumi up and pulumi stack were discussed, helping you understand how to deploy, update, and destroy cloud resources, as well as manage multiple environments. This chapter provided a solid foundation to begin using Pulumi effectively in cloud projects.In the next chapter, you will build your first Pulumi IaC project, and you’ll be exposed to writing and organizing code, managing configurations...

Questions

1. What is configuration drift, and how does IaC help prevent it?
2. How does IaC improve the reproducibility of infrastructure setups?
3. What are some of the main benefits of using code to manage cloud infrastructure instead of manual configuration?
4. How can you verify that Pulumi was installed correctly on your machine?
5. What is a resource in Pulumi, and how is it defined using code?
6. What is the purpose of stacks in Pulumi, and how do they relate to different environments?
7. How can you set specific configuration values for different stacks in Pulumi?
8. What does Pulumi use state files for, and why are they critical to the IaC process?
9. What are the default and alternative storage options for Pulumi state?
10. What does the pulumi up command do, and how does it manage infrastructure changes?
11. How can you preview changes before deploying them in Pulumi, and why is it important?
...

Further reading

To learn more about the basics of IaC using Pulumi, you can check out this blog post on the Pulumi website: https://www.pulumi.com/what-is/what-is-infrastructure-as-code/.