🚀 Launch Special: $29/mo for life --d --h --m --s Claim Your Price →
Infrastructure as Code Free

Pulumi Fundamentals

Pulumi Fundamentals teaches developers core Pulumi concepts, language support, resource providers, inputs/outputs, configuration, secrets, stack references, and component resources, enabling them to write infrastructure-as-code with familiar programming languages.

Who Should Take This

Software engineers, DevOps specialists, and cloud developers who already code in languages such as JavaScript, Python, Go, or C# and want to adopt infrastructure as code will benefit. They seek practical, hands‑on training to provision, manage, and version cloud resources using Pulumi’s programmable approach, advancing from manual scripts to scalable, maintainable infrastructure.

What's Included in AccelaStudy® AI

Adaptive Knowledge Graph
Practice Questions
Lesson Modules
Console Simulator Labs
Exam Tips & Strategy
20 Activity Formats

Course Outline

51 learning goals
1 Pulumi Core Concepts
2 topics

Projects, Stacks, and Programs

  • Describe the Pulumi project structure including Pulumi.yaml project file, stack configuration files, and the relationship between projects, stacks, and programs
  • Describe how Pulumi programs differ from declarative IaC tools by using imperative general-purpose programming languages with real control flow, loops, and conditionals
  • Implement a new Pulumi project using pulumi new with language-specific templates and configure stack settings for a development environment
  • Analyze how Pulumi's desired state model works under the hood including the resource registration process, the deployment engine, and the role of the language host runtime

State Management

  • Describe the Pulumi state model including how state tracks resource identity, properties, and dependencies and explain the available state backend options (Pulumi Cloud, S3, local file)
  • Implement self-managed state backends using S3, Azure Blob, or GCS for organizations that require full control over state storage location and encryption
  • Analyze the trade-offs between Pulumi Cloud managed state and self-managed backends in terms of operational overhead, security posture, and team collaboration features
2 Language Support and Resource Providers
2 topics

Multi-Language Support

  • Describe the supported Pulumi languages (TypeScript, Python, Go, C#, Java, YAML) and explain how the language host and gRPC protocol enable multi-language resource management
  • Implement Pulumi infrastructure programs in TypeScript using the @pulumi/aws, @pulumi/azure-native, or @pulumi/gcp packages with proper async resource creation patterns
  • Implement Pulumi infrastructure programs in Python using the pulumi_aws, pulumi_azure_native, or pulumi_gcp packages with idiomatic Python patterns for resource declaration
  • Analyze the advantages and disadvantages of each supported language for Pulumi programs considering type safety, ecosystem maturity, team expertise, and IDE tooling support
  • Implement Pulumi infrastructure programs in Go using the pulumi-aws, pulumi-azure, or pulumi-gcp SDK packages with struct-based resource configuration and error handling patterns

Resource Providers

  • Describe the Pulumi provider model and explain how native providers (azure-native, google-native) differ from bridged Terraform providers in terms of API coverage and resource support
  • Implement provider configurations with explicit credentials, default tags, and region settings and explain how multiple provider instances enable multi-region deployments
  • Implement resources using the Pulumi Registry documentation to configure cloud services including compute instances, storage, and networking with provider-specific resource types
  • Evaluate the criteria for choosing between native providers and bridged providers and analyze how provider version constraints affect resource behavior and configuration compatibility
3 Inputs, Outputs, and Resource Properties
2 topics

Inputs and Outputs System

  • Describe the Pulumi Input/Output type system and explain how Output represents values that are resolved asynchronously during resource creation and preview
  • Implement Output.apply() to transform resource outputs and chain dependent computations that execute after underlying resources are created
  • Implement pulumi.interpolate (TypeScript) or Output.concat (Python) for string interpolation with Output values without explicit apply callbacks
  • Implement Output.all() to combine multiple Output values into a single computation when resource properties from different resources must be used together
  • Analyze common pitfalls with Output values including accessing .result outside of apply callbacks, serialization limitations, and the difference between preview and actual values
  • Implement type-safe resource construction using strongly-typed Input and Output generics to catch configuration errors at compile time in TypeScript and Go programs

Resource Options

  • Describe the available resource options including dependsOn, protect, ignoreChanges, aliases, parent, provider, and deleteBeforeReplace and explain their effect on resource lifecycle
  • Implement resource options to control deployment behavior including protecting critical resources from deletion, ignoring externally managed properties, and forcing explicit dependency ordering
  • Implement resource aliases to safely rename or refactor resources without triggering deletion and recreation of the underlying infrastructure
4 Configuration, Secrets, and Stack References
2 topics

Configuration and Secrets

  • Describe the Pulumi configuration system including Pulumi..yaml files, typed configuration retrieval, and the difference between plaintext config and encrypted secrets
  • Implement configuration values using pulumi config set and retrieve them programmatically using Config.require(), Config.get(), and Config.requireSecret() in Pulumi programs
  • Implement secret management using pulumi config set --secret with the default passphrase encryption provider and explain how secrets propagate through Output values as secret outputs
  • Analyze the encryption providers available for Pulumi secrets (passphrase, AWS KMS, Azure Key Vault, GCP KMS, HashiCorp Vault) and evaluate which is appropriate for different security requirements

Stack References

  • Describe how stack references enable cross-stack resource sharing by reading stack outputs from another stack's state without direct coupling between programs
  • Implement stack references to consume outputs from infrastructure stacks in application stacks such as reading VPC IDs, subnet lists, and database endpoints across stack boundaries
  • Implement stack exports using pulumi.export() to expose resource properties as stack outputs that can be consumed by other stacks or external tooling
  • Analyze the architectural patterns for splitting infrastructure into multiple stacks and evaluate how stack granularity affects deployment speed, blast radius, and team ownership boundaries
5 Component Resources and Abstraction
1 topic

Component Resources

  • Describe how component resources differ from custom resources and explain how they serve as logical grouping containers that create multiple underlying cloud resources
  • Implement a basic component resource class that encapsulates a VPC with subnets and security groups into a reusable abstraction with typed input and output properties
  • Implement the registerOutputs method in component resources to properly expose child resource properties and enable correct dependency tracking across component boundaries
  • Analyze how component resources affect the Pulumi state tree and resource URN hierarchy and evaluate naming strategies that produce readable and maintainable resource identifiers
  • Implement component resources that accept optional configuration objects with sensible defaults to balance ease of use for common cases with flexibility for advanced customization
  • Evaluate the design principles for component resource interfaces including input validation, error messaging, and documentation patterns that make components self-documenting
6 Pulumi CLI and Workflow
2 topics

CLI Commands and Deployment

  • Describe the Pulumi deployment lifecycle commands including pulumi preview, pulumi up, pulumi destroy, and pulumi refresh and explain what each command does to state and infrastructure
  • Implement pulumi up with various flags including --yes, --skip-preview, --target, --replace, and --diff to control deployment behavior in development and production scenarios
  • Implement stack management commands including pulumi stack init, pulumi stack select, pulumi stack ls, and pulumi stack export/import for environment management
  • Analyze the preview output format and evaluate how to interpret create, update, replace, and delete operations before confirming a deployment with pulumi up
  • Implement pulumi refresh to reconcile Pulumi state with actual cloud infrastructure and explain how refresh detects drift and updates state without modifying real resources

Automation API Basics

  • Describe the Pulumi Automation API and explain how it enables programmatic infrastructure management by embedding Pulumi operations inside application code without CLI invocation
  • Implement a basic Automation API program that creates a stack, sets configuration values, runs preview and up operations, and reads stack outputs programmatically
  • Evaluate the use cases for the Automation API including self-service infrastructure portals, integration test harnesses, and GitOps controllers compared to standard CLI workflows
7 Pulumi vs Terraform Comparison
1 topic

Tool Comparison

  • Compare Pulumi's imperative programming model with Terraform's declarative HCL and analyze how each approach handles conditionals, loops, and dynamic resource generation
  • Compare state management approaches between Pulumi (Pulumi Cloud, self-managed backends) and Terraform (remote backends, state locking) and evaluate team workflow implications
  • Evaluate the testing capabilities of Pulumi using standard language test frameworks versus Terraform's testing approaches and analyze how each enables infrastructure validation
  • Analyze the organizational adoption factors for choosing between Pulumi and Terraform including team language expertise, existing toolchain integration, and community ecosystem size

Scope

Included Topics

  • Pulumi core concepts (projects, stacks, programs, state), supported programming languages (TypeScript, Python, Go, C#), resource providers and registry, inputs and outputs (apply, interpolation, lifting), stack references for cross-stack dependencies, configuration and secrets management, component resources for abstraction, Pulumi CLI commands (new, up, preview, destroy, stack), Automation API basics for programmatic infrastructure, resource options (dependsOn, protect, ignoreChanges, aliases), stack outputs and exports

Not Covered

  • Pulumi Cloud enterprise features (Deployments, Audit Logs, SCIM)
  • CrossGuard policy as code framework
  • Advanced dynamic providers
  • Pulumi Kubernetes operator
  • Migration tooling from other IaC tools
  • Advanced Automation API patterns
  • Multi-language package authoring

Ready to master Pulumi Fundamentals?

Adaptive learning that maps your knowledge and closes your gaps.

Subscribe to Access