Pulumi Fundamentals
Pulumi is an infrastructure-as-code tool that defines cloud resources with familiar programming languages. It evaluates your program, compares the desired resources with a stack's recorded state, and coordinates the changes through provider plugins.
itInfrastructure and operations | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Intro
Pulumi Fundamentals
Pulumi lets you define infrastructure in a programming language. You describe cloud resources as objects in TypeScript, Python, Go, C#, Java, or YAML. Pulumi runs that program, builds a resource graph, compares it with recorded state, and asks provider plugins to make the required changes.
The code looks imperative because it uses a general-purpose language. The result is still declarative. You describe the resources you want. Pulumi decides which create, read, update, and delete operations can bring the real infrastructure to that desired state.
Why Pulumi exists
Infrastructure as code gives infrastructure the same review and version-control workflow as application code. Pulumi adds familiar language features to that model:
- Functions and loops can remove repetition.
- Classes and packages can hold reusable abstractions.
- Type systems and editor tooling can catch some mistakes before deployment.
- Test frameworks can exercise infrastructure code.
- One program can connect resources from several providers.
This approach fits teams that want infrastructure definitions to share a language and toolchain with application code. It also adds responsibility. Your infrastructure program is executable software. Dependencies, runtime failures, package versions, and code complexity all need deliberate management.
The core mental model
Five parts work together:
- Program: your source code declares resources and their relationships.
- Engine: Pulumi runs the program and builds the desired resource graph.
- Provider: a plugin translates resource operations into calls to a cloud or software service.
- Stack: an isolated, configurable instance of the program.
- Backend: the service or storage location that coordinates updates and stores each stack's state.
The engine does not infer your intent from arbitrary cloud resources. It works from your program, the selected stack's configuration, and that stack's state.
Projects and stacks
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.pulumi.com/docs/get-started/
Supports
- Pulumi as infrastructure as code using familiar programming languages
- First-project paths for major cloud and Kubernetes providers
- Relationship between Pulumi IaC and the optional Pulumi Cloud service
- https://www.pulumi.com/docs/iac/concepts/projects/
Supports
- Project folder and Pulumi.yaml identity
- Supported project runtimes
- Stack settings file naming and source-control guidance
- https://www.pulumi.com/docs/iac/concepts/stacks/
Supports
- Stack as an isolated and independently configurable program instance
- Multiple stacks per project
- Stack initialization, selection, and listing
- https://www.pulumi.com/docs/iac/concepts/inputs-outputs/
Supports
- Declarative resource graph
- Input and Output semantics
- Output-to-input dependency tracking
- Eventual values and output transformation
- Explicit dependsOn for dependencies absent from data flow
- https://www.pulumi.com/docs/iac/concepts/providers/
Supports
- Provider SDK and executable plugin roles
- Translation of resource operations to service APIs
- Default and explicit provider configuration
- Explicit providers for multiple regions or environments
- https://www.pulumi.com/docs/iac/concepts/state-and-backends/
Supports
- Per-stack state purpose
- Backend coordination and storage role
- Pulumi Cloud as the default managed backend
- Supported DIY backend classes and owner responsibilities
- Cloud credentials excluded from Pulumi state
- Secret encryption in state
- https://www.pulumi.com/docs/reference/state/
Supports
- Refresh updates state rather than program or infrastructure
- Keeping external changes requires a matching program update
- Stack state export and import as advanced operations
- https://www.pulumi.com/docs/iac/concepts/config/
Supports
- Stack-scoped configuration
- Secret configuration methods and encrypted serialization
- Configuration namespaces
- https://www.pulumi.com/docs/iac/cli/commands/pulumi_preview/
Supports
- Preview computes desired state by running the project program
- Preview compares desired allocations with existing state
- Preview shows operations without changing the stack
- https://www.pulumi.com/docs/iac/concepts/resources/options/
Supports
- Protection, aliases, explicit dependencies, ignore changes, import, parent, and provider options
- Resource options change management and lifecycle behavior
- https://www.pulumi.com/docs/iac/concepts/resources/options/aliases/
Supports
- Alias use during logical rename or parent-path refactor
- Identity preservation instead of delete and recreate
- https://www.pulumi.com/docs/iac/concepts/components/
Supports
- Components as logical groups of child resources
- Reusable interfaces and distribution approaches
- Components for organizational infrastructure patterns
- https://github.com/pulumiverse/awesome-pulumi
Supports
- Discovery of Pulumi Local, env zero, and Deskypus
- Curated Pulumi ecosystem categories
- https://docs.localstack.cloud/aws/connecting/infrastructure-as-code/pulumi/
Supports
- Pulumi Local wrapper and manual endpoint configuration
- Local AWS resource deployment through LocalStack
- https://docs.envzero.com/guides/getting-started/getting-started
Supports
- Pulumi support in the env zero infrastructure automation platform
- Managed infrastructure deployment and governance scope
- https://snapcraft.io/deskypus
Supports
- Cross-platform desktop management for Pulumi projects
