Skip to main content
Mapagam

60 SECTIONS · 1529 TOPICS

Terraform Roadmap

  1. Installing and Configuring Terraform CLI

    1. 1. Installing Terraform
    2. Example: Installing Terraform via Official Binary (Linux)
    3. 2. Verifying Installation
    4. Example: Check Terraform version
    5. 3. Enabling Tab Completion
    6. Example: Enabling Tab Completion in Bash
    7. Example: Enabling Tab Completion in Zsh
    8. 4. Configuring CLI Settings
    9. Example: Setting CLI Config File Path
    10. Example: Disabling Plugin Caching
    11. 5. Setting Up Credentials
    12. Example: AWS Provider Configuration
    13. 6. Configuring Plugin Cache
    14. Example: Setting Plugin Cache Directory
    15. 7. Setting Environment Variables
    16. Example: Setting TF_LOG for Debugging
    17. 8. Using Terraform Wrapper Tools
    18. Example: Using tfenv to manage Terraform versions
    19. Example: Using tfswitch to switch versions
    20. 9. Configuring Credential Helpers
    21. Example: Configuring AWS Credential Helper
    22. Example: Using AWS Credential Helper in Terraform
    23. 10. Setting Provider Installation Methods
    24. Example: Automatic Provider Installation

  2. Writing Configuration Files (HCL)

    1. 1. Understanding HCL Syntax
    2. Example: Basic HCL Block
    3. Key Concepts
    4. 2. Creating Terraform Files
    5. Example: Basic Terraform Configuration File
    6. 3. Organizing Configuration Files
    7. Directory Structure Best Practices
    8. Example: Module Organization
    9. Key Principles
    10. 4. Using Comments (# single-line, /* */ multi-line)
    11. Example: Using Comments in HCL
    12. 5. Defining Resource Blocks
    13. Example: Basic Resource Block
    14. Example: Resource with Count
    15. Example: Resource with Dependencies
    16. 6. Setting Block Labels
    17. Example: Resource with Labels
    18. Example: Data Source with Labels
    19. 7. Using Arguments and Attributes (key = value)
    20. Example: Resource with Arguments and Attributes
    21. 8. Understanding Meta-Arguments
    22. Example: Using
    23. Example: Using
    24. Example: Using
    25. Example: Using
    26. 9. Formatting Code
    27. Example: Formatting with terraform fmt
    28. 10. Validating Syntax
    29. Example: Validating a Terraform Configuration
    30. 11. Using Override Files
    31. Example: Using override files for environments
    32. Example: Override variables in terraform.tfvars

  3. Managing Terraform Providers

    1. 1. Declaring Provider Blocks
    2. Example: Basic Provider Block
    3. Example: Provider with Alias
    4. 2. Configuring Provider Settings
    5. Example: Provider Configuration
    6. 3. Using Multiple Provider Instances
    7. Example: Using Different AWS Regions
    8. 4. Setting Provider Version Constraints
    9. Example: Provider Version Constraint
    10. 5. Understanding Provider Requirements
    11. Example: Declaring a Provider Requirement
    12. 6. Configuring Provider Authentication
    13. Example: AWS Provider with IAM Role
    14. Example: GitHub Provider with Token
    15. 7. Installing Providers
    16. Example: Installing AWS Provider
    17. 8. Upgrading Providers
    18. Example: Upgrading Providers
    19. Example: Specifying Provider Version Constraints
    20. Upgrade Best Practices
    21. 9. Locking Provider Versions
    22. Example: Using provider version constraints
    23. 10. Using Custom Providers
    24. Example: Using a Custom Provider
    25. 11. Configuring Provider Proxy Settings
    26. Example: Setting Proxy in Terraform Configuration

  4. Managing Input Variables

    1. 1. Declaring Input Variables
    2. Example: Declaring Variables in Terraform
    3. 2. Setting Variable Types
    4. Example: Declaring a variable with type
    5. Example: Using a list variable
    6. Example: Using a map variable
    7. 3. Defining Default Values
    8. Example: Using Default Values in a Variable Definition
    9. Example: Default Value in a Resource Block
    10. 4. Adding Variable Descriptions
    11. Example: Variable with Description
    12. 5. Validating Variable Values
    13. Example: Validating Instance Type
    14. Example: Validating Numeric Range
    15. 6. Marking Variables Sensitive
    16. Example: Declaring a Sensitive Variable
    17. 7. Setting Variables via CLI
    18. Example: Setting Variables via CLI
    19. 8. Using Variable Files
    20. Example: Using a .tfvars file
    21. Example: Using a JSON variable file
    22. 9. Using Environment Variables
    23. Example: Setting Environment Variables
    24. 10. Referencing Variables
    25. Example: Referencing Variables in Expressions
    26. 11. Setting Variable Precedence
    27. Example: Setting Variables via Environment
    28. Example: Setting Variables via CLI
    29. 12. Using Nullable Variables
    30. Example: Setting nullable variable
    31. Example: Using nullable variable in resource

  5. Managing Local Values

    1. 1. Declaring Local Values
    2. Example: Declaring a local value
    3. Example: Using a local value in a resource
    4. 2. Computing Derived Values
    5. Example: Using
    6. Example: Using
    7. 3. Referencing Local Values
    8. Example: Referencing Local Values in Variables
    9. Example: Using Local Values in Resource Configuration
    10. 4. Using Locals for DRY
    11. Example: Reusing Region in Multiple Resources
    12. 5. Combining Multiple Expressions
    13. Example: Concatenating Strings
    14. Example: Combining Lists
    15. Example: Conditional Expression with Multiple Values
    16. 6. Using Locals with Functions
    17. 7. Organizing Locals by Purpose
    18. Example: Organizing locals in modules
    19. 8. Comparing Locals vs Variables
    20. When to Use Which?
    21. 9. Using Locals in Modules
    22. Example: Defining and Using Locals in Modules
    23. 10. Referencing Locals in Outputs
    24. Example: Outputting a Local Value

  6. Defining Output Values

    1. 1. Declaring Output Values
    2. Example: Basic Output Declaration
    3. Example: Output with Description
    4. 2. Exposing Resource Attributes
    5. Example: Outputting Instance ID
    6. Example: Outputting S3 Bucket Domain Name
    7. 3. Adding Output Descriptions
    8. Example: Defining Output with Description
    9. 4. Marking Outputs Sensitive
    10. Example: Defining a Sensitive Output
    11. 5. Setting Output Dependencies
    12. Example: Defining Outputs with Dependencies
    13. 6. Viewing Output Values
    14. Example: Output Declaration
    15. Example: Viewing Outputs
    16. Example: Viewing Specific Output
    17. 7. Formatting Output
    18. Example: Using format function in output
    19. 8. Using Outputs in Parent Modules
    20. Example: Defining Output in Child Module
    21. Example: Consuming Output in Parent Module
    22. 9. Exporting State Data
    23. Example: Basic Output Definition
    24. Example: Sensitive Output
    25. 10. Using Preconditions in Outputs
    26. Example: Validating Output with Precondition

  7. Working with Resources

    1. 1. Creating Resources
    2. Example: Creating an AWS Instance
    3. 2. Referencing Resource Attributes
    4. Example: Using Resource Attributes in Variables
    5. 3. Using Resource Dependencies
    6. Example: Defining Explicit Dependencies
    7. 4. Setting Resource Timeouts
    8. Example: Setting Custom Timeouts
    9. 5. Configuring Lifecycle Rules
    10. Example: Using Lifecycle Rules
    11. 6. Preventing Resource Destruction
    12. Example: Preventing Resource Destruction
    13. 7. Ignoring Attribute Changes
    14. Example: Ignoring Attribute Changes
    15. 8. Creating Resources Before Destroying
    16. Example: Creating Resources Before Destroying
    17. 9. Replacing Matched Resources
    18. Example: Replacing Matched Resources
    19. 10. Using Resource Preconditions
    20. Example: Using Resource Preconditions
    21. 11. Using Resource Postconditions
    22. Example: Using Resource Postconditions
    23. 12. Replacing Resources
    24. Example: Replacing Resources

  8. Using Data Sources

    1. 1. Declaring Data Blocks
    2. Example: Using Data Block in Resource
    3. 2. Querying External Data
    4. Example: Fetching AWS Instance Information
    5. Example: Using Data Source in Resource Configuration
    6. Key Concepts
    7. 3. Filtering Data Source Results
    8. Example: Filtering EC2 Instances by Tag
    9. 4. Referencing Data Attributes
    10. Example: Referencing Data Attributes
    11. 5. Using Data Source Dependencies
    12. Example: Using depends_on with Data Sources
    13. 6. Reading Remote State
    14. Example: Reading remote state in Terraform
    15. 7. Using Template Data Sources
    16. Example: Using Template Data Source
    17. 8. Querying Cloud Provider APIs
    18. Example: Fetching Latest AMI ID from AWS
    19. Example: Using the Fetched AMI ID in a Resource
    20. 9. Using External Programs
    21. Example: Executing a Shell Script
    22. Example: Capturing JSON Output
    23. 10. Using Lifecycle with Data Sources
    24. Example: Preventing Destruction of Data Source
    25. 11. Combining Multiple Data Sources
    26. Example: Combining AWS AMI and VPC Data Sources

  9. Working with Complex Data Types

    1. 1. Using Lists and Tuples
    2. Example: List Operations
    3. 2. Using Maps and Objects
    4. Example: Map Usage
    5. 3. Using Sets
    6. Example: Set Operations
    7. 4. Using Nested Objects
    8. Example: Nested Object Access
    9. 5. Using Optional Object Attributes
    10. Example: Optional Attribute Handling
    11. 6. Using Type Constraints
    12. Example: Type Constraint Enforcement
    13. 7. Converting Between Types
    14. Example: Type Conversion
    15. 8. Using Structural Types
    16. Example: Structural Type Usage
    17. 9. Merging Complex Objects
    18. Example: Merging Maps
    19. 10. Flattening Nested Structures
    20. Example: Flattening Nested Lists

  10. Working with Expressions

    1. 1. Writing String Expressions
    2. Example: String Concatenation
    3. Example: String Interpolation
    4. 2. Using Arithmetic Operators (+, -, *, /)
    5. Example: Basic Arithmetic in Variables
    6. 3. Using Comparison Operators (==, !=,
    7. Example: Using Comparison Operators in Conditions
    8. 4. Using Logical Operators (&&, ||, !)
    9. Example: Combining Conditions
    10. Example: Negating Conditions
    11. 5. Using Conditional Expressions (condition ? true : false)
    12. Example: Conditional Resource Creation
    13. Example: Conditional Variable Assignment
    14. 6. Using For Expressions ([for item in list])
    15. Example: Transforming a List of Numbers
    16. Example: Building a Map from a List
    17. 7. Using Splat Expressions (resource.*.attribute)
    18. Example: Accessing Public IPs from Multiple Instances
    19. Example: Using Splat in a Variable
    20. 8. Accessing Map and Object Attributes
    21. Example: Accessing Map Attributes
    22. Example: Accessing Object Attributes with Bracket Notation
    23. 9. Using String Templates
    24. Example: Using templatefile()
    25. Example: Template file (user-data.sh.tmpl)
    26. 10. Understanding Type Constraints
    27. Example: Type Constraints in Variables
    28. Example: Type Constraints in Outputs
    29. 11. Using Null Values
    30. Example: Using null in conditional expressions

  11. Using Numeric and Type Functions

    1. 1. Using abs Function
    2. Example: Calculating Absolute Values in Variables
    3. 2. Using ceil and floor Functions
    4. Example: Rounding Numbers in Terraform
    5. Example: Using floor for Resource Counting
    6. 3. Using max and min Functions
    7. Example: Using max() and min() in a variable
    8. Example: Using max() and min() in a conditional
    9. 4. Using parseint Function
    10. Example: Parsing Integer from String
    11. Example: Parsing Binary String
    12. 5. Using pow and signum Functions
    13. 6. Using tostring Function
    14. 7. Using tonumber Function
    15. 8. Using tobool Function
    16. Example: Converting String to Boolean
    17. Example: Using in Conditionals
    18. 9. Using tolist and toset Functions
    19. 10. Using tomap Function
    20. Example: Converting a List to a Map
    21. Example: Using tomap with a Set

  12. Using String Functions

    1. 1. Using chomp and trim Functions
    2. Example: Using chomp and trim in a Terraform template
    3. 2. Using format and formatlist Functions
    4. Example: Using format Function
    5. Example: Using formatlist Function
    6. 3. Using join and split Functions
    7. Example: join Function Usage
    8. Example: split Function Usage
    9. 4. Using lower and upper Functions
    10. Example: Using lower() and upper() Functions
    11. 5. Using replace Function
    12. Example: Replace in a variable
    13. 6. Using substr Function
    14. Example: Extracting Substring
    15. Example: Using with Variables
    16. 7. Using regex and regexall Functions
    17. 8. Using startswith and endswith Functions
    18. 9. Using strrev Function
    19. Example: Reversing a String in Terraform
    20. 10. Using title Function
    21. Example: title Function Usage

  13. Using Collection Functions

    1. 1. Using concat Function
    2. Example: Concatenating Lists
    3. Example: Concatenating Lists with Different Types
    4. 2. Using contains Function
    5. 3. Using distinct Function
    6. Example: Removing Duplicates from a List
    7. 4. Using flatten Function
    8. Example: Flattening a Nested List
    9. Example: Flattening Lists with Different Types
    10. 5. Using length Function
    11. Example: Calculating List Length
    12. Example: String Length Validation
    13. 6. Using element and index Functions
    14. 7. Using keys and values Functions
    15. Example: Using keys() and values()
    16. 8. Using lookup and try Functions
    17. 9. Using merge Function
    18. Example: Merging Maps in Terraform Configuration
    19. 10. Using range Function
    20. Example: Basic usage of range function
    21. Example: Using range with custom start and step
    22. 11. Using reverse and sort Functions
    23. Example: Reversing and Sorting Lists
    24. 12. Using slice Function
    25. Example: Slicing a List

  14. Using Encoding Functions

    1. 1. Using base64encode and base64decode Functions
    2. Example: Encoding and Decoding a Secret
    3. Example: Decoding a Base64 Value
    4. 2. Using jsonencode and jsondecode Functions
    5. Example: Using jsonencode to format a map
    6. Example: Using jsondecode to parse a JSON string
    7. 3. Using yamlencode and yamldecode Functions
    8. Example: Using yamlencode to format data
    9. Example: Using yamldecode to parse data
    10. 4. Using csvdecode Function
    11. Example: Decoding CSV Data
    12. 5. Using urlencode Function
    13. Example: Encoding a URL Parameter
    14. 6. Using textencodebase64 and textdecodebase64 Functions
    15. Example: Encoding and Decoding with Base64
    16. Example: Decoding Base64 Data
    17. 7. Using base64gzip Function
    18. Example: Encoding and Decoding with base64gzip
    19. 8. Using md5 and sha256 Functions
    20. Example: Using md5() in a variable
    21. Example: Using sha256() in a resource
    22. 9. Using uuid and uuidv5 Functions
    23. 10. Using bcrypt Function
    24. Example: Hashing a Password with bcrypt

  15. Using Filesystem Functions

    1. 1. Using file Function
    2. Example: Reading a File
    3. 2. Using fileexists Function
    4. Example: Check if a file exists before reading it
    5. 3. Using fileset Function
    6. Example: Using fileset to read all .tf files in a directory
    7. 4. Using filebase64 Function
    8. Example: Reading a file and encoding it in base64
    9. 5. Using templatefile Function
    10. Example: Basic usage of templatefile
    11. Example: Template file (user-data.sh)
    12. 6. Using abspath Function
    13. Example: Resolving Relative Paths
    14. 7. Using dirname and basename Functions
    15. Example: Using dirname and basename
    16. 8. Using pathexpand Function
    17. Example: Expanding a Path with Tilde
    18. Example: Using Environment Variables
    19. 9. Using filemd5 and filesha256 Functions
    20. 10. Using templatestring Function
    21. Example: Basic Usage
    22. Example: With Numbers

  16. Using Date, Time, and Network Functions

    1. 1. Using timestamp Function
    2. Example: Using timestamp in resource naming
    3. 2. Using formatdate Function
    4. Example: Formatting Current Date
    5. Example: Formatting Specific Timestamp
    6. 3. Using timeadd Function
    7. Example: Adding one hour to a timestamp
    8. Example: Adding 30 minutes to a timestamp
    9. 4. Using timecmp Function
    10. Example: Comparing Time Values
    11. 5. Using plantimestamp Function
    12. Example: Using plantimestamp in a resource
    13. 6. Using cidrhost Function
    14. Example: Generate IP Address from CIDR Block
    15. 7. Using cidrsubnet Function
    16. Example: Basic Usage
    17. Example: Subnetting with Different Prefix Lengths
    18. 8. Using cidrnetmask Function
    19. Example: Using cidrnetmask in a Network Configuration
    20. 9. Using cidrsubnetloop Function
    21. Example: Using cidrsubnetloop to Generate Subnets
    22. 10. Using cidrcontains Function
    23. Example: Checking if an IP is within a subnet
    24. Example: Checking if a subnet is contained within another

  17. Using Advanced Functions

    1. 1. Using alltrue and anytrue Functions
    2. 2. Using can and try Functions
    3. Example: Using
    4. Example: Using
    5. 3. Using coalesce and coalescelist Functions
    6. 4. Using compact Function
    7. Example: Using compact Function
    8. Usage Summary
    9. 5. Using one Function
    10. 6. Using matchkeys Function
    11. Example: Using matchkeys to select subnet CIDR blocks
    12. 7. Using setintersection and setunion Functions
    13. Example: Using setintersection()
    14. Example: Using setunion()
    15. 8. Using setsubtract and setproduct Functions
    16. Example: Using setsubtract to filter resources
    17. Example: Using setproduct to generate combinations
    18. 9. Using sum and product Functions
    19. Example: Using sum() to calculate total resource count
    20. Example: Using product() to calculate total CPU cores
    21. 10. Using sensitive and nonsensitive Functions
    22. Example: Using sensitive and nonsensitive Functions

  18. Using Meta-Arguments

    1. 1. Using depends_on Meta-Argument
    2. Example: Using depends_on to enforce resource order
    3. 2. Using count Meta-Argument
    4. Example: Creating Multiple Instances
    5. Example: Using count with a Variable
    6. Key Points
    7. 3. Using for_each Meta-Argument
    8. Example: Creating Multiple S3 Buckets
    9. Example: Using for_each with Modules
    10. Key Points
    11. 4. Using provider Meta-Argument
    12. Example: Using provider alias
    13. 5. Using lifecycle Meta-Argument
    14. Example: Using lifecycle with prevent_destroy
    15. Example: Using lifecycle with ignore_changes
    16. 6. Understanding create_before_destroy
    17. Example: Using create_before_destroy
    18. 7. Understanding prevent_destroy
    19. Example: Using prevent_destroy
    20. 8. Understanding ignore_changes
    21. Example: ignore_changes in a resource block
    22. 9. Using precondition and postcondition
    23. Example: Using precondition and postcondition in a resource
    24. 10. Using replace_triggered_by
    25. Example: Triggering Resource Replacement

  19. Using Count Meta-Argument

    1. 1. Creating Multiple Resources
    2. Example: Creating Multiple S3 Buckets
    3. Key Points
    4. 2. Referencing Count Index
    5. Example: Using count.index in resource configuration
    6. 3. Using Conditional Resource Creation (count = condition ? 1 : 0)
    7. Example: Conditional EC2 Instance Creation
    8. 4. Accessing Count Resources
    9. Example: Accessing Count Resources in Variables
    10. 5. Understanding Count Limitations
    11. 6. Using Count with Modules
    12. Example: Creating Multiple S3 Buckets
    13. 7. Handling Count Changes
    14. Example: Changing Count Value
    15. 8. Combining Count with Conditionals
    16. Example: Conditional Resource Creation with Count
    17. Example: Using Count with Conditionals in Variables
    18. 9. Using Count with Data Sources
    19. Example: Using count with data sources
    20. Example: Using for_each with data sources
    21. 10. Converting Count to For-Each
    22. Example: Converting Count to For-Each

  20. Using For-Each Meta-Argument

    1. 1. Using For-Each with Maps
    2. Example: Creating Multiple S3 Buckets Using a Map
    3. Key Points
    4. 2. Using For-Each with Sets
    5. Example: Creating Multiple S3 Buckets Using a Set
    6. 3. Accessing Each Iterator
    7. Example: Using each.key and each.value
    8. 4. Referencing For-Each Resources
    9. Example: Referencing For-Each Resources in Expressions
    10. 5. Comparing Count vs For-Each
    11. Example: Count Usage
    12. Example: For-Each Usage
    13. When to Use Which?
    14. 6. Using For-Each with Modules
    15. Example: Using for_each with a Module
    16. Example: Module Input Variables
    17. Example: Variable Definition
    18. 7. Converting Lists to Maps
    19. Example: Converting a List to a Map
    20. 8. Handling For-Each Changes
    21. Example: Adding new elements to for_each
    22. 9. Using Dynamic Keys
    23. Example: Dynamic Keys from a Map
    24. Example: Converting Non-String Keys to Strings
    25. 10. Filtering For-Each Collections
    26. Example: Filtering with for_each

  21. Using Dynamic Blocks

    1. 1. Creating Dynamic Blocks
    2. Example: Creating Dynamic Subnets
    3. Example: Using Dynamic Blocks with Maps
    4. 2. Iterating with for_each
    5. Example: Using for_each with a resource
    6. Example: Using for_each with a module
    7. 3. Using Iterator Object
    8. Example: Using iterator object in a dynamic block
    9. Example: Custom iterator name
    10. 4. Accessing Content Block
    11. Example: Using for_each to create multiple resources
    12. Example: Using dynamic blocks with content
    13. 5. Nesting Dynamic Blocks
    14. Example: Nesting Dynamic Blocks
    15. Nesting Dynamic Blocks - Key Points
    16. 6. Using Conditional Dynamic Blocks
    17. Example: Conditional Dynamic Block with
    18. Example: Using
    19. 7. Combining Dynamic and Static Blocks
    20. Example: Combining Dynamic and Static Blocks
    21. 8. Using Dynamic Blocks for Complex Objects
    22. Example: Using Dynamic Blocks for Security Group Rules
    23. Example: Complex Nested Object with Multiple Attributes
    24. 9. Setting Custom Iterator Names
    25. Example: Custom Iterator Name
    26. 10. Using Dynamic Labels
    27. Example: Defining Dynamic Labels

  22. Using Looping Techniques

    1. 1. Using Nested For Expressions
    2. Example: Nested For Loop with Lists
    3. Example: Nested For Loop with Maps
    4. Example: Nested For Loop with Index
    5. 2. Using For-Each with Dynamic Blocks
    6. Example: Creating Multiple S3 Buckets
    7. Example: Using for_each with Dynamic Blocks
    8. 3. Filtering with For Expressions
    9. Example: Filtering Lists
    10. Example: Filtering with Index
    11. 4. Transforming Data with For
    12. Example: Using for_each to create multiple S3 buckets
    13. Example: Using for to transform a list of strings
    14. 5. Using Splat with For
    15. Example: Using Splat with For
    16. 6. Combining Count and For-Each
    17. Example: Combining Count and For-Each
    18. 7. Using For with Maps and Objects
    19. Example: Creating Multiple S3 Buckets
    20. 8. Using For with Conditional Logic
    21. Example: Using for_each with conditional logic
    22. Example: Using count with conditional logic
    23. 9. Flattening Nested Loops
    24. Example: Flattening nested loops with local values
    25. 10. Using For with Zip and Range
    26. Example: Using zipmap with range
    27. Example: Using range with for_each

  23. Working with Modules

    1. 1. Creating Module Structure
    2. Example: Basic Module Structure
    3. Example: Module with Examples and Tests
    4. 2. Calling Modules
    5. Example: Basic Module Call
    6. Example: Module with Version
    7. 3. Passing Input Variables
    8. Example: Using a local module with input variables
    9. Example: Using a remote module with version constraint
    10. 4. Setting Module Sources
    11. Example: Using a Local Module Source
    12. Example: Using a Git Module Source
    13. 5. Versioning Modules
    14. Example: Using Module Version
    15. Example: Using Git Ref
    16. Best Practices for Module Versioning
    17. 6. Accessing Module Outputs
    18. Example: Using Module Outputs in Parent Configuration
    19. 7. Using Module Dependencies
    20. Example: Module with Version Constraint
    21. 8. Publishing Modules
    22. Example: Publishing to Terraform Registry
    23. 9. Using Private Module Registry
    24. Example: Using Private Module Registry
    25. 10. Managing Module Composition
    26. Example: Using a Module with Version Constraint
    27. Best Practices for Module Composition
    28. 11. Refactoring with Modules
    29. Example: Migrating to Modules
    30. Workflow: Refactoring Process
    31. 12. Using Module Providers
    32. Example: Using Module Providers

  24. Building Reusable Modules

    1. 1. Designing Module Interfaces
    2. Example: Module Interface Design
    3. Best Practices for Module Interfaces
    4. 2. Using Variable Validation
    5. Example: Validating Input Length
    6. Example: Validating Numeric Range
    7. 3. Implementing Module Best Practices
    8. Module Best Practices Summary
    9. Example: Module with Validation
    10. Module vs. Resource
    11. Module Development Workflow
    12. 4. Documenting Modules
    13. Example: Module Documentation Structure
    14. Module Documentation Checklist
    15. 5. Using Output Descriptions
    16. Example: Defining Outputs with Descriptions
    17. 6. Handling Module Defaults
    18. Example: Setting Default Provider Configuration
    19. 7. Implementing Module Testing
    20. Example: Basic Module Test Setup
    21. Example: Test Configuration
    22. Example: Test Case Definition
    23. Testing Best Practices
    24. 8. Versioning Module Releases
    25. Example: Module Version in Registry
    26. Best Practices for Module Versioning
    27. 9. Creating Module Examples
    28. Example: Basic Module Structure
    29. 10. Publishing to Registry
    30. Example: Publishing a module to the Terraform Registry

  25. Managing Module Composition Patterns

    1. 1. Using Root Modules
    2. Example: Root Module Configuration
    3. 2. Creating Child Modules
    4. Example: Creating a child module
    5. 3. Implementing Module Nesting
    6. Example: Using Nested Modules
    7. 4. Using Module Dependencies
    8. Example: Module with Dependencies
    9. Example: Registry Module with Version
    10. 5. Sharing Data Between Modules
    11. Example: Referencing Module Outputs
    12. Example: Using Output Values in Variables
    13. 6. Implementing Module Abstraction
    14. Example: Abstracting EC2 Instance Creation
    15. 7. Creating Module Wrappers
    16. Example: Basic Module Wrapper
    17. Wrapper vs Direct Module Usage
    18. 8. Using Module Factory Patterns
    19. Example: Factory Module for EC2 Instances
    20. Example: Factory Module Implementation
    21. 9. Implementing Module Versioning Strategies
    22. Example: Using Registry Module with Version Pinning
    23. Example: Using Git Tag for Module Version
    24. 10. Managing Cross-Module State
    25. Example: Using Module Outputs

  26. Initializing Working Directories

    1. 1. Initializing Working Directory
    2. Example: Initialize a Terraform working directory
    3. Initialization Process Overview
    4. 2. Downloading Providers and Modules
    5. Example: Initializing Providers and Modules
    6. Initialization Process
    7. 3. Upgrading Providers
    8. Example: Upgrading Providers
    9. 4. Migrating State Backend
    10. Example: Migrating from local to remote backend
    11. 5. Reconfiguring Backend
    12. Example: Reconfiguring Backend
    13. 6. Specifying Plugin Directory
    14. Example: Setting Plugin Cache Directory
    15. 7. Using Backend Configuration Files
    16. Example: S3 Backend Configuration
    17. 8. Generating Lock Files
    18. Example: Lock file content
    19. Lock File Management
    20. 9. Initializing for Specific Platforms
    21. Example: Initializing Terraform on macOS
    22. 10. Handling Init Errors
    23. Example: Resolving Plugin Installation Failure

  27. Planning Infrastructure Changes

    1. 1. Creating Execution Plan
    2. Example: Creating a basic plan
    3. 2. Saving Plan Files
    4. Example: Saving a plan file
    5. 3. Reviewing Plan Output
    6. Example: Plan output format
    7. 4. Using Target Resources
    8. Example: Targeting specific resources
    9. 5. Refreshing State
    10. Example: Skipping refresh for faster plan generation
    11. 6. Generating Destroy Plan
    12. Example: Generating a destroy plan
    13. 7. Disabling Refresh
    14. 8. Setting Variable Values
    15. Example: Setting variables from command line
    16. 9. Using Variable Files
    17. Example: Using variable files
    18. 10. Generating Machine-Readable Output
    19. Example: Generating JSON plan output

  28. Applying Infrastructure Changes

    1. 1. Applying Configuration
    2. Example: Applying Configuration
    3. 2. Auto-Approving Changes
    4. Example: Enabling Auto-Approve in CI/CD
    5. 3. Applying Saved Plans
    6. Example: Applying a Saved Plan
    7. 4. Targeting Specific Resources
    8. Example: Targeting a Specific Resource
    9. Example: Targeting a Module
    10. 5. Replacing Resources
    11. Example: Replacing a Resource Safely
    12. 6. Using Parallelism
    13. Example: Limiting Parallelism
    14. 7. Applying with Variable Files
    15. Example: Using Variable Files
    16. Example: Variable File Content
    17. 8. Handling Apply Errors
    18. Example: Resource Dependency Error
    19. 9. Using Compact Warnings
    20. Example: Enabling Compact Warnings
    21. 10. Limiting Input Prompts
    22. Example: Using -auto-approve flag

  29. Destroying Infrastructure

    1. 1. Destroying All Resources
    2. Example: Destroying All Resources
    3. 2. Auto-Approving Destruction
    4. Example: Destroy with auto-approval
    5. 3. Destroying Specific Resources
    6. Example: Destroying a Specific S3 Bucket
    7. Example: Targeted Destruction Command
    8. 4. Generating Destroy Plans
    9. Example: Generating a destroy plan
    10. 5. Using Variable Files
    11. Example: Defining Variables in
    12. Example: Setting Values in
    13. Example: Using Variables in
    14. Workflow: Applying Variables from Files
    15. 6. Understanding Destroy Order
    16. Example: Destroy Order in Practice
    17. Destroy Order Workflow
    18. Key Points
    19. 7. Handling Destroy Errors
    20. Example: Resolving Dependency Conflicts
    21. 8. Using Parallelism
    22. Example: Setting max parallelism
    23. Parallelism Best Practices
    24. 9. Confirming Destruction
    25. Example: Approving Destruction
    26. 10. Preventing Accidental Destruction
    27. Example: Using -auto-approve with caution
    28. Best Practices for Safe Destruction

  30. Managing Terraform State

    1. 1. Understanding State Files
    2. Example: State file structure
    3. 2. Listing State Resources
    4. Example: Listing all resources in state
    5. Example: Listing resources with a specific state file
    6. 3. Showing Resource State
    7. Example: Displaying state for a specific resource
    8. Example: Displaying state in JSON format
    9. 4. Moving Resources
    10. Example: Moving a Resource
    11. Example: Moving a Module
    12. 5. Removing Resources
    13. Example: Removing an AWS Instance
    14. 6. Replacing Provider Addresses
    15. Example: Replacing Provider Address
    16. 7. Pulling Remote State
    17. Example: Pulling Remote State
    18. 8. Pushing Local State
    19. Example: Pushing State to S3 Backend
    20. 9. Refreshing State
    21. Example: Refreshing State
    22. 10. Backing Up State Files
    23. Example: Manual backup using terraform state pull
    24. Example: Restore state from backup
    25. 11. Recovering from State Corruption
    26. Example: Force Unlocking State
    27. Example: Reverting to Backup
    28. Recovery Steps Summary

  31. Configuring Remote Backends

    1. 1. Declaring Backend Configuration
    2. Example: Declaring a remote backend in Terraform
    3. 2. Using S3 Backend
    4. Example: S3 Backend Configuration
    5. 3. Using Azure Blob Backend
    6. Example: Basic Configuration with Access Key
    7. Example: Configuration with Azure AD Authentication
    8. 4. Using GCS Backend
    9. Example: GCS Backend Configuration
    10. 5. Configuring State Locking
    11. Example: DynamoDB State Locking Configuration
    12. 6. Migrating Backend Configuration
    13. Migration Process Overview
    14. Example: Migrating from Local to S3 Backend
    15. 7. Using HTTP Backend
    16. Example: HTTP Backend Configuration
    17. 8. Configuring Terraform Cloud Backend
    18. Example: Basic Terraform Cloud Backend Configuration
    19. 9. Setting Backend Encryption
    20. Example: S3 Backend with Encryption
    21. 10. Using Partial Backend Configuration
    22. Example: Partial Backend Configuration

  32. Implementing State Locking

    1. 1. Understanding State Locking
    2. Example: Enabling State Locking
    3. 2. Configuring Lock Mechanisms
    4. Example: S3 Backend with Locking
    5. 3. Forcing Unlock
    6. Example: Forcing Unlock
    7. When to Use Force Unlock
    8. 4. Handling Lock Conflicts
    9. Steps to Resolve Lock Conflicts
    10. 5. Using Lock Timeout
    11. Example: Setting Lock Timeout in Backend Configuration
    12. 6. Monitoring Lock Status
    13. Example: Checking Lock Status
    14. 7. Disabling Locking
    15. Example: Disabling Locking in Backend Configuration
    16. 8. Using Locks with Automation
    17. Example: Automating State Locking with Terraform Cloud
    18. Best Practices for Automation
    19. 9. Implementing Custom Locks
    20. Example: Custom Lock Implementation with HTTP
    21. 10. Troubleshooting Lock Issues
    22. Example: Force unlock a stale lock

  33. Working with Workspaces

    1. 1. Understanding Workspaces
    2. Example: Creating a new workspace
    3. 2. Listing Workspaces
    4. Example: Listing Workspaces
    5. 3. Creating Workspaces
    6. Example: Creating a New Workspace
    7. 4. Switching Workspaces
    8. Example: Switching to a workspace
    9. 5. Deleting Workspaces
    10. Example: Deleting a Workspace
    11. 6. Showing Current Workspace
    12. 7. Using Workspace in Configuration
    13. Example: Using workspace in configuration
    14. 8. Managing Workspace State
    15. Example: Creating and Switching Workspaces
    16. 9. Comparing Workspaces vs Modules
    17. Example: Workspace Variables
    18. Example: Module Usage
    19. 10. Implementing Workspace Naming Strategies
    20. Example: Workspace Naming Convention
    21. Best Practices for Workspace Naming

  34. Managing Multi-Environment Deployments

    1. 1. Using Workspaces for Environments
    2. Example: Creating and Switching Workspaces
    3. Example: Listing Workspaces
    4. 2. Using Separate Directories
    5. Example: Directory Structure
    6. Best Practices
    7. 3. Using Variable Files per Environment
    8. Example: Environment-specific variables
    9. Example: Using variable files in CLI
    10. 4. Using Remote State per Environment
    11. Example: S3 Backend Configuration
    12. Example: Environment-Specific State Keys
    13. 5. Implementing Environment-Specific Resources
    14. Example: Environment-specific S3 Bucket
    15. Example: Environment-specific EC2 Instance
    16. 6. Using Modules for Shared Code
    17. Example: Using a Module
    18. Module Best Practices
    19. 7. Managing Environment Variables
    20. Example: Setting Environment Variables
    21. Example: Using Variables in Configuration
    22. 8. Using Terraform Cloud Workspaces
    23. Example: Creating a Workspace
    24. Key Features of Workspaces
    25. 9. Implementing Promotion Workflows
    26. Example: Promotion Workflow with Environment Variables
    27. Key Considerations
    28. 10. Using GitOps for Environments
    29. Example: GitOps Workflow with Terraform
    30. GitOps Benefits

  35. Managing Dependencies

    1. 1. Using Implicit Dependencies
    2. Example: Implicit dependency via resource reference
    3. 2. Using Explicit Dependencies
    4. Example: Module with Explicit Dependencies
    5. 3. Understanding Dependency Graph
    6. Example: Explicit Dependency Declaration
    7. Dependency Resolution Workflow
    8. 4. Visualizing Dependencies
    9. Example: Dependency Graph with
    10. Example: Exporting Graph to PNG
    11. Key Features of Dependency Visualization
    12. 5. Handling Circular Dependencies
    13. Example: Circular Module Dependency
    14. Workflow to Resolve Circular Dependencies
    15. Best Practices to Avoid Circular Dependencies
    16. 6. Using Module Dependencies
    17. Example: Using a Module from the Registry
    18. Example: Using a Local Module
    19. 7. Managing Provider Dependencies
    20. Example: Using provider version constraints
    21. Example: Using multiple provider configurations
    22. 8. Ordering Resource Creation
    23. Example: Using depends_on
    24. Example: Using lifecycle preconditions
    25. 9. Using Data Source Dependencies
    26. Example: Fetching AMI ID from AWS
    27. Example: Using Data Source in Resource
    28. 10. Debugging Dependency Issues
    29. Example: Resolving Provider Version Conflicts

  36. Visualizing Terraform Graph

    1. 1. Generating Dependency Graph
    2. Example: Generating a dependency graph
    3. Example: Generating a graph with cycle detection
    4. Summary of terraform graph command
    5. 2. Exporting Graph to DOT Format
    6. Example: Exporting Graph to DOT Format
    7. Example: Visualizing DOT Graph with Graphviz
    8. 3. Rendering Graph Images
    9. Example: Render graph as PNG
    10. Example: Render graph as SVG
    11. 4. Filtering Graph by Type
    12. 5. Generating Plan Graphs
    13. Example: Generate a plan graph
    14. Example: Save plan to file and generate graph
    15. Example: Generate JSON graph output
    16. 6. Analyzing Resource Dependencies
    17. Example: Dependency Analysis with
    18. 7. Identifying Circular Dependencies
    19. Example: Direct Circular Dependency
    20. How to Identify Circular Dependencies
    21. Common Causes of Circular Dependencies
    22. Circular Dependency vs. Valid Dependency
    23. 8. Using Graph Tools
    24. Example: Generating a Graph with
    25. Example: Converting DOT to PNG
    26. Comparison: Graph Visualization Tools
    27. 9. Interpreting Graph Nodes
    28. Example: Resource Node
    29. Example: Data Source Node
    30. 10. Optimizing Graph Structure
    31. Example: Using depends_on for explicit ordering
    32. Best Practices for Graph Optimization

  37. Implementing Provisioners

    1. 1. Using Local-Exec Provisioner
    2. Example: Running a local command
    3. Example: Setting environment variables
    4. 2. Using Remote-Exec Provisioner
    5. Example: Execute a script remotely
    6. 3. Using File Provisioner
    7. Example: Copying a file to remote instance
    8. Example: Writing content directly to a file
    9. 4. Configuring Connection Blocks
    10. Example: SSH Connection Configuration
    11. 5. Setting Provisioner Timing
    12. Example: Setting provisioner timing
    13. 6. Handling Provisioner Failures
    14. Example: Using on_failure to continue on error
    15. Best Practices for Provisioner Failures
    16. 7. Using Null Resource
    17. Example: Using null_resource with local-exec provisioner
    18. 8. Using terraform_data Resource
    19. Example: Using terraform_data to trigger a refresh
    20. Example: Using terraform_data to manage a file
    21. 9. Using Time Provider
    22. Example: Using Time Provider
    23. 10. Understanding Provisioner Limitations

  38. Implementing Check Blocks

    1. 1. Declaring Check Blocks
    2. Example: Basic Check Block
    3. 2. Defining Check Assertions
    4. Example: Basic Check Assertion
    5. Example: Check with Multiple Conditions
    6. 3. Configuring Check Scoped Data Sources
    7. Example: Basic Check Block Configuration
    8. Example: Using Data Sources in Checks
    9. 4. Using Conditions in Checks
    10. Example: Conditional Check with Variables
    11. Example: Check with Resource Attributes
    12. 5. Adding Error Messages
    13. Example: Basic Error Message in Check Block
    14. 6. Running Continuous Validation
    15. Example: Continuous Validation with Terraform Cloud
    16. Key Points
    17. 7. Comparing Checks vs Preconditions
    18. Key Differences Summary
    19. 8. Handling Check Failures
    20. Example: Using assert to fail checks
    21. Check Failure Handling Summary
    22. 9. Using Checks for Drift Detection
    23. Example: Drift Detection with Check Blocks
    24. 10. Implementing Health Checks
    25. Example: Basic Health Check

  39. Importing Existing Resources

    1. 1. Importing Resources
    2. Example: Importing an AWS EC2 Instance
    3. 2. Writing Import Blocks
    4. Example: Basic Import Block
    5. 3. Using Import Address
    6. Example: Importing an AWS Instance
    7. 4. Verifying Imported State
    8. Example: Check imported resource state
    9. Verification Steps
    10. 5. Importing Multiple Resources
    11. Example: Importing Multiple Resources with a Loop
    12. 6. Generating Configuration
    13. Example: Generate configuration for an existing AWS S3 bucket
    14. Steps to Generate Configuration
    15. 7. Handling Import Errors
    16. Common Import Error Scenarios and Solutions
    17. Example: Resolving State Mismatch
    18. 8. Using For-Each with Import
    19. Example: Importing Multiple Resources with For-Each
    20. 9. Importing into Modules
    21. Example: Importing into a Module
    22. 10. Documenting Imported Resources
    23. Example: Importing and Documenting a Google Compute Instance
    24. Best Practices for Importing Resources

  40. Migrating to Terraform

    1. 1. Discovering Existing Infrastructure
    2. Example: Importing an AWS EC2 instance
    3. Workflow: Discovering and Importing Infrastructure
    4. 2. Importing Resources
    5. Example: Importing an AWS EC2 Instance
    6. 3. Generating Configuration
    7. Example: Basic Terraform Configuration
    8. 4. Using Import Blocks
    9. Example: Importing an AWS EC2 Instance
    10. 5. Validating Imported State
    11. Example: Validate imported state
    12. 6. Handling Import Conflicts
    13. Example: Resolving Duplicate Resource IDs
    14. Workflow: Resolving Import Conflicts
    15. Comparison: Import vs. Refresh
    16. 7. Migrating from CloudFormation
    17. Example: Migrating a Simple EC2 Instance
    18. Migration Steps Overview
    19. 8. Migrating from ARM Templates
    20. Example: Migrating a Resource Group
    21. Example: Migrating a Virtual Machine
    22. 9. Using Third-Party Import Tools
    23. Example: Using tfimport to import AWS resources
    24. 10. Documenting Migration Process
    25. Example: Migration Documentation Structure

  41. Refactoring Terraform Configuration

    1. 1. Renaming Resources
    2. Example: Renaming a Resource in Configuration
    3. Workflow: Renaming a Resource Safely
    4. 2. Moving Resources Between Modules
    5. Example: Moving a Resource
    6. Workflow: Migrating Resource to New Module
    7. 3. Splitting Modules
    8. Example: Splitting Resources into Modules
    9. Best Practices for Module Splitting
    10. 4. Consolidating Resources
    11. Example: Consolidating S3 Buckets with for_each
    12. Example: Consolidating EC2 Instances with count
    13. 5. Removing Unused Resources
    14. Example: Removing an unused S3 bucket
    15. 6. Updating Resource Addresses
    16. Example: Updating Resource Address in State
    17. Example: Updating Resource Address in Configuration
    18. 7. Migrating from Count to For-Each
    19. Example: Migrating from Count to For-Each
    20. 8. Replacing Deprecated Features
    21. Example: Replacing
    22. 9. Using State Commands
    23. Example: Moving a resource
    24. Example: Removing a resource from state
    25. 10. Validating Refactoring
    26. Example: Validate refactored configuration
    27. Example: Validate with specific configuration directory
    28. Comparison: Validate vs Plan

  42. Using Terraform Registry

    1. 1. Finding Provider Documentation
    2. Example: Using provider documentation in a module
    3. 2. Finding Module Documentation
    4. Example: Module Documentation URL Format
    5. 3. Publishing Public Modules
    6. Example: Publishing a Module
    7. Steps to Publish a Module
    8. 4. Versioning Published Modules
    9. Example: Module Version Constraint
    10. Example: Using Wildcard Version
    11. 5. Using Module Examples
    12. Example: Using a Public Module
    13. Example: Using a Module with Variables
    14. 6. Searching Registry
    15. Example: Search for AWS modules
    16. Example: Search with version filter
    17. 7. Viewing Module Sources
    18. Example: Viewing Module Source in Registry
    19. 8. Using Verified Modules
    20. Example: Using a Verified Module
    21. 9. Reviewing Module Downloads
    22. Example: Module Source Configuration
    23. Module Download Process
    24. 10. Contributing to Modules
    25. Example: Module structure
    26. Key Guidelines

  43. Working with JSON and YAML Configuration

    1. 1. Using JSON Configuration Files
    2. Example: Basic JSON Configuration
    3. 2. Converting HCL to JSON
    4. Example: Converting HCL to JSON
    5. 3. Using jsonencode Function
    6. Example: Encoding a Map to JSON
    7. 4. Using jsondecode Function
    8. Example: Parsing JSON String
    9. 5. Using yamlencode Function
    10. 6. Using yamldecode Function
    11. 7. Loading External JSON Files
    12. Example: Reading JSON from a file
    13. Example: Using jsondecode() in Terraform
    14. 8. Generating JSON Output
    15. Example: Exporting Outputs to JSON
    16. Example: Exporting Specific Output to JSON
    17. 9. Using JSON in Templates
    18. Example: Encoding a Map to JSON
    19. Example: Decoding JSON from a Variable
    20. 10. Validating JSON Schema
    21. Example: Validating JSON with Schema

  44. Handling Sensitive Data

    1. 1. Marking Variables Sensitive
    2. Example: Declaring a sensitive variable
    3. 2. Marking Outputs Sensitive
    4. Example: Marking an Output as Sensitive
    5. 3. Using Environment Variables
    6. Example: Setting Environment Variables
    7. 4. Storing Secrets in Vault
    8. Example: Using Vault with Terraform
    9. 5. Using Cloud Secret Managers
    10. Example: Retrieving Secret from AWS SSM Parameter Store
    11. Example: Using GCP Secret Manager
    12. 6. Encrypting State Files
    13. Example: S3 Backend with Encryption
    14. 7. Redacting Sensitive Values
    15. Example: Using sensitive flag
    16. 8. Using .gitignore for Secrets
    17. Example: .gitignore content
    18. 9. Rotating Credentials
    19. Example: Rotating AWS IAM Access Key
    20. 10. Auditing Secret Access
    21. Example: Enable Secret Access Auditing
    22. Secret Access Auditing Best Practices

  45. Debugging Terraform

    1. 1. Enabling Debug Logging
    2. Example: Setting Debug Logging
    3. 2. Setting Log Levels
    4. Example: Setting Log Level via Environment Variable
    5. Example: Setting Log Level via CLI Flag
    6. 3. Logging to File
    7. Example: Enable detailed logging to file
    8. 4. Using Terraform Console
    9. Example: Evaluating Variables
    10. Example: Evaluating Expressions
    11. 5. Testing Expressions
    12. Example: Testing Expression Evaluation
    13. 6. Validating Configuration
    14. Example: Validating a Terraform Configuration
    15. 7. Checking Formatting
    16. Example: Format Terraform files
    17. 8. Reviewing Plan Output
    18. Example: Plan Output Summary
    19. Key Elements to Review
    20. 9. Using Terraform Show
    21. Example: Displaying state in human-readable format
    22. Example: Displaying state in JSON format
    23. 10. Debugging Provider Issues
    24. Example: Provider Configuration with Debugging
    25. 11. Handling Rate Limits
    26. Example: Configuring Retry Logic in Terraform

  46. Optimizing Terraform Performance

    1. 1. Using Parallelism
    2. Example: Setting Max Parallelism in Configuration
    3. 2. Implementing Resource Targeting
    4. Example: Targeting a Specific Resource
    5. Example: Targeting Multiple Resources
    6. 3. Disabling Refresh
    7. Example: Disabling Refresh in Plan
    8. 4. Splitting Large Configurations
    9. Example: Module-Based Splitting
    10. Best Practices for Splitting Configurations
    11. 5. Using Remote State Caching
    12. Example: Configuring S3 Backend with Caching
    13. 6. Minimizing Provider API Calls
    14. Example: Reducing API Calls with Data Sources
    15. 7. Using Local Caching
    16. Example: Enabling Local Caching for Modules
    17. 8. Optimizing Module Structure
    18. Example: Efficient Module Structure
    19. Key Tips for Module Optimization
    20. 9. Reducing Plan Time
    21. Example: Using -target to reduce plan time
    22. Best Practices to Reduce Plan Time
    23. 10. Monitoring Apply Duration
    24. Example: Logging Apply Duration

  47. Testing Terraform Code

    1. 1. Using Terraform Validate
    2. Example: Running terraform validate
    3. 2. Using Terraform Test Framework
    4. Example: Basic Test Case
    5. Workflow for Writing Tests
    6. 3. Writing Unit Tests
    7. Example: Test a simple data source
    8. Example: Using test block to validate resource creation
    9. 4. Writing Integration Tests
    10. Example: Basic Integration Test Structure
    11. Best Practices for Integration Tests
    12. 5. Using Terraform Plan Tests
    13. Example: Basic Plan Test
    14. Plan Test Summary
    15. 6. Implementing Policy Tests
    16. Example: Basic Policy Test
    17. Key Concepts
    18. 7. Using Mock Providers
    19. Example: Defining a Mock Provider
    20. Example: Using Mock Resources
    21. 8. Testing Module Outputs
    22. Example: Define and Test Module Output
    23. Example: Test Output in Terraform
    24. 9. Implementing End-to-End Tests
    25. Example: Basic E2E Test Setup
    26. Workflow: E2E Test Execution
    27. 10. Automating Test Runs
    28. Example: CI/CD Pipeline with Terraform Tests
    29. Best Practices for Test Automation

  48. Implementing Security Best Practices

    1. 1. Using Least Privilege IAM
    2. Example: Define a minimal IAM role with least privilege
    3. 2. Encrypting State Files
    4. Example: S3 Backend with Encryption
    5. 3. Enabling State Locking
    6. Example: Enabling State Locking with S3 Backend
    7. 4. Validating Input Variables
    8. Example: Validating Input with Condition
    9. 5. Using Sentinel Policies
    10. Example: Basic Sentinel Policy
    11. 6. Scanning for Security Issues
    12. Example: Using tfsec to scan a Terraform configuration
    13. Example: Using Checkov to scan a directory
    14. 7. Implementing Network Restrictions
    15. Example: Allow HTTPS traffic only from a specific IP
    16. Example: Deny all outbound traffic
    17. Key Concepts
    18. 8. Using Private Module Registry
    19. Example: Using Private Module
    20. 9. Auditing Changes
    21. Example: Reviewing Terraform Plan Output
    22. Key Points for Auditing Changes
    23. 10. Implementing Drift Detection
    24. Example: Using Terraform Cloud for Drift Detection
    25. Drift Detection Summary

  49. Implementing Compliance and Governance

    1. 1. Using Sentinel Policy Language
    2. Example: Hard Constraint Policy
    3. Example: Soft Constraint Policy
    4. Sentinel Policy Components
    5. 2. Implementing OPA Policies
    6. Example: Enforcing Resource Limits with OPA
    7. 3. Enforcing Tagging Standards
    8. Example: Tagging with Terraform
    9. 4. Validating Naming Conventions
    10. Example: Naming Convention Validation
    11. 5. Implementing Cost Controls
    12. Example: Setting up a Cost Budget
    13. Key Cost Control Strategies
    14. 6. Enforcing Security Baselines
    15. Example: Using tfsec to enforce security rules
    16. Example: Enforcing AWS security baseline with checkov
    17. 7. Using Policy Sets
    18. Example: Creating a Policy Set
    19. 8. Testing Policies
    20. Example: Policy Test Structure
    21. Example: Policy Test Case
    22. Testing Policy Best Practices
    23. 9. Auditing Policy Violations
    24. Example: Enforcing Tagging Policy
    25. Policy Enforcement Summary
    26. 10. Implementing Custom Policies
    27. Example: Terraform Sentinel Policy
    28. Policy Enforcement Levels

  50. Using Terraform with CI/CD

    1. 1. Integrating with GitHub Actions
    2. Example: GitHub Actions Workflow
    3. Best Practices for CI/CD Integration
    4. 2. Integrating with GitLab CI
    5. Example: GitLab CI Pipeline Configuration
    6. 3. Integrating with Jenkins
    7. Example: Jenkins Pipeline Configuration
    8. Comparison: Jenkins vs Other CI/CD Tools
    9. 4. Integrating with Azure DevOps
    10. Example: Azure Pipeline YAML for Terraform
    11. Key Steps for Integration
    12. 5. Automating Terraform Init
    13. Example: Automating terraform init in a CI pipeline
    14. 6. Automating Plan and Apply
    15. Example: CI/CD Pipeline with Terraform Plan and Apply
    16. Best Practices for Automating Terraform Plan and Apply
    17. 7. Storing State Remotely
    18. Example: Configuring S3 Backend
    19. 8. Managing Secrets
    20. Example: Using Sensitive Variables
    21. Example: Using Environment Variables
    22. 9. Using Terraform Cloud Runs
    23. Example: Configuring Terraform Cloud Runs
    24. 10. Implementing GitOps Workflows
    25. Example: GitHub Actions Workflow
    26. Key GitOps Principles

  51. Using Terraform Cloud and Enterprise

    1. 1. Configuring Terraform Cloud Backend
    2. Example: Remote Backend Configuration
    3. 2. Creating Organizations and Workspaces
    4. Example: Creating a Workspace via API
    5. Key Concepts
    6. 3. Connecting VCS Repositories
    7. Example: GitHub App Setup
    8. 4. Configuring Remote Execution
    9. Example: Remote Execution Configuration
    10. 5. Setting Up Sentinel Policies
    11. Example: Hard-Mandatory Policy
    12. Setting Up Sentinel Policies
    13. 6. Using Private Module Registry
    14. Example: Using a Private Module
    15. 7. Managing Teams and Permissions
    16. Example: Creating a Team and Assigning Members
    17. Example: Setting Up a Workspace with Variables
    18. Key Concepts
    19. 8. Configuring Notifications
    20. Example: Slack Notification Configuration
    21. Example: Webhook Notification Configuration
    22. 9. Using Cost Estimation
    23. Example: Enabling Cost Estimation
    24. 10. Setting Up Run Triggers
    25. Example: Setting up a Workspace Trigger

  52. Using Terraform Stacks

    1. 1. Understanding Terraform Stacks
    2. Example: Basic Stack Structure
    3. Stacks vs Workspaces
    4. 2. Creating Stack Configuration
    5. Example: Stack Configuration File
    6. 3. Defining Stack Deployments
    7. Example: Defining a Stack Deployment
    8. 4. Using Orchestration Rules
    9. Example: Orchestration with depends_on
    10. 5. Managing Stack Dependencies
    11. Example: Using remote state to reference another stack
    12. 6. Using Stack Variables
    13. Example: Defining Stack Variables in HCL
    14. Example: Using Stack Variables in Resource Configuration
    15. 7. Implementing Stack Outputs
    16. Example: Defining Stack Outputs
    17. Example: Using Outputs in Parent Stacks
    18. 8. Deploying Stacks
    19. Example: Deploying a Stack
    20. Deployment Workflow
    21. 9. Managing Stack State
    22. Example: Configure S3 Backend
    23. State Management Best Practices
    24. 10. Using Stacks with Terraform Cloud
    25. Example: Enabling Stacks in Terraform Cloud
    26. Stacks with Terraform Cloud Summary

  53. Using Terraform CDK

    1. 1. Installing CDK for Terraform
    2. Example: Initialize a CDK Project
    3. 2. Creating CDKTF Projects
    4. Example: Initialize a CDKTF Project
    5. 3. Defining Infrastructure in Code
    6. Example: Defining an S3 Bucket
    7. Example: Using Parameters
    8. 4. Synthesizing Configuration
    9. Example: Synthesizing a Simple Resource
    10. Synthesis Workflow
    11. 5. Deploying with CDKTF
    12. Example: Deploying a CDKTF Stack
    13. 6. Using CDKTF Providers
    14. Example: Using AWS Provider
    15. Example: Using Multiple AWS Regions
    16. 7. Converting HCL to CDKTF
    17. Example: Converting a simple HCL resource to CDKTF
    18. 8. Managing CDKTF State
    19. Example: Setting up S3 backend for CDKTF
    20. 9. Testing CDKTF Code
    21. Example: Unit Testing with Jest
    22. Testing Best Practices
    23. 10. Integrating CDKTF with CI/CD
    24. Example: GitHub Actions Workflow
    25. Best Practices

  54. Working with AWS Provider

    1. 1. Configuring AWS Provider
    2. Example: Basic AWS Provider Configuration
    3. Example: Using Named Profile
    4. Example: Assume Role Configuration
    5. 2. Using AWS Authentication
    6. Example: Using Static Credentials
    7. Example: Using IAM Role from EC2 Instance
    8. 3. Managing AWS Resources
    9. Example: Creating an EC2 Instance
    10. Example: Creating an S3 Bucket
    11. Example: Creating an IAM Role
    12. 4. Using AWS Data Sources
    13. Example: Fetching AMI ID from a specific AMI name
    14. Example: Using availability zones to create subnets
    15. 5. Configuring Multiple Regions
    16. Example: Using Multiple Regions with Aliases
    17. 6. Using AWS Assume Role
    18. Example: Assume Role Configuration
    19. 7. Managing AWS Tags
    20. Example: Tagging an EC2 Instance
    21. Tagging Best Practices
    22. 8. Using AWS-Specific Functions
    23. Example: Using aws_ami_id in a launch configuration
    24. Example: Using aws_caller_identity to get account ID
    25. 9. Configuring S3 Backend
    26. Example: S3 Backend Configuration
    27. 10. Handling AWS API Throttling
    28. Example: Configuring Retry Settings

  55. Working with Azure Provider

    1. 1. Configuring Azure Provider
    2. Example: Basic Azure Provider Configuration
    3. 2. Using Azure Authentication
    4. Example: Service Principal with Client Secret
    5. Example: Using Azure CLI
    6. 3. Managing Azure Resources
    7. Example: Create a Resource Group
    8. Example: Create a Virtual Machine
    9. Example: Create a Storage Account
    10. 4. Using Azure Data Sources
    11. Example: Using Azure Client Config
    12. Example: Using Azure Resource Group
    13. 5. Configuring Multiple Subscriptions
    14. Example: Multiple Subscriptions Configuration
    15. Subscription Management Best Practices
    16. 6. Managing Azure Tags
    17. Example: Assigning Tags to Azure Resource
    18. Example: Using Tags in Data Sources
    19. Example: Tag Inheritance from Parent
    20. 7. Using Azure-Specific Features
    21. Example: Using Azure AD Application
    22. Example: Using Managed Identity
    23. Key Azure-Specific Features
    24. 8. Configuring Azure Blob Backend
    25. Example: Basic Azure Blob Backend Configuration
    26. Example: Using Azure AD Authentication
    27. 9. Using Azure Key Vault
    28. Example: Accessing Azure Key Vault Secret in a VM
    29. 10. Handling Azure API Limits
    30. Example: Configuring Azure Provider with Retry Logic

  56. Working with Google Cloud Provider

    1. 1. Configuring GCP Provider
    2. Example: Basic GCP Provider Configuration
    3. Example: Using Environment Variables
    4. 2. Using GCP Authentication
    5. Example: Service Account Key File Authentication
    6. Example: Using ADC with gcloud
    7. 3. Managing GCP Resources
    8. Example: Creating a Compute Instance
    9. Example: Creating a Storage Bucket
    10. 4. Using GCP Data Sources
    11. Example: Retrieve GCP Compute Image
    12. Example: Retrieve GCP Compute Network
    13. Example: Retrieve GCP Container Cluster
    14. 5. Configuring Multiple Projects
    15. Example: Multiple Projects Configuration
    16. Key Points
    17. 6. Managing GCP Labels
    18. Example: Applying Labels to GCP Compute Instance
    19. 7. Using GCP-Specific Features
    20. Example: Using GCP Service Account for Terraform
    21. 8. Configuring GCS Backend
    22. Example: GCS Backend Configuration
    23. 9. Using Google Secret Manager
    24. Example: Create a Secret
    25. Example: Add a Secret Version
    26. Example: Access Secret in a Cloud Function
    27. 10. Handling GCP API Quotas
    28. Example: Checking API Quota Usage

  57. Upgrading Terraform

    1. 1. Checking Version Compatibility
    2. Example: Checking Terraform Version
    3. 2. Upgrading Terraform Binary
    4. Example: Upgrade Terraform Binary on macOS (Homebrew)
    5. Example: Upgrade Terraform Binary on Linux (via package manager)
    6. Example: Manual Download and Install (Linux x86_64)
    7. 3. Upgrading Provider Versions
    8. Example: Updating Provider Version in Configuration
    9. Example: Migrating from Old to New Provider
    10. 4. Using Terraform Upgrade Commands
    11. Example: Upgrading Terraform version
    12. Example: Upgrading provider versions
    13. 5. Updating State Format
    14. Example: Upgrading State Format
    15. 6. Handling Breaking Changes
    16. Example: Updating Resource Schema
    17. Steps to Handle Breaking Changes
    18. 7. Testing Upgrades
    19. Example: Test Upgrade Workflow
    20. 8. Using Version Constraints
    21. Example: Using version constraints in a Terraform module
    22. 9. Managing Provider Version Locks
    23. Example: Lock File Entry
    24. Managing Provider Locks
    25. 10. Rolling Back Upgrades
    26. Example: Reverting Terraform Binary

  58. Implementing Disaster Recovery

    1. 1. Backing Up State Files
    2. Example: S3 Backend Configuration
    3. Best Practices for State Backup
    4. 2. Versioning State Files
    5. Example: Enabling Versioning in S3 Backend
    6. 3. Using Remote State Replication
    7. Example: S3 Backend with Replica Configuration
    8. 4. Implementing State Recovery
    9. Example: Recovering State from a Backup
    10. State Recovery Best Practices
    11. 5. Testing Disaster Recovery
    12. Example: Testing Recovery Procedures
    13. Recovery Testing Checklist
    14. 6. Using State File Snapshots
    15. Example: Creating a Full State Snapshot
    16. Example: Creating a Partial State Snapshot
    17. 7. Documenting Recovery Procedures
    18. Example: Recovery Procedure Documentation Structure
    19. Recovery Procedure Best Practices
    20. 8. Implementing Automated Backups
    21. Example: Scheduled Backup with CloudWatch Events
    22. Backup Strategy Summary
    23. 9. Using State Locking for DR
    24. Example: Enabling State Locking in Backend Configuration
    25. 10. Validating Restored State
    26. Example: Validate restored state with Terraform plan
    27. Validation Steps

  59. Working with Ephemeral Values

    1. 1. Understanding Ephemeral Values
    2. Example: Defining Ephemeral Values
    3. 2. Using Ephemeral Variables
    4. Example: Defining an Ephemeral Variable
    5. 3. Using Ephemeral Outputs
    6. Example: Defining an Ephemeral Output
    7. 4. Managing Ephemeral Resources
    8. Example: Using for_each with ephemeral resources
    9. Example: Using lifecycle rules to manage ephemeral resources
    10. 5. Using Ephemeral Data Sources
    11. Example: Using Ephemeral Data Source for Runtime Values
    12. 6. Handling Ephemeral Provider Configuration
    13. Example: Ephemeral Provider Configuration
    14. 7. Comparing Ephemeral vs Sensitive
    15. 8. Using Ephemeral Values in Modules
    16. Example: Defining an Ephemeral Value in a Module
    17. 9. Understanding Ephemeral Limitations
    18. 10. Implementing Ephemeral Patterns
    19. Example: Using ephemeral values in a data source
    20. Example: Using ephemeral values in a resource
    21. Key Points

  60. Implementing Common Terraform Patterns

    1. 1. Using Conditional Resource Creation
    2. Example: Conditional Resource Creation with
    3. Example: Conditional Resource Creation with
    4. 2. Implementing Resource Factories
    5. Example: Basic Resource Factory
    6. Example: Using Variables with Resource Factories
    7. Best Practices for Resource Factories
    8. 3. Creating Wrapper Modules
    9. Example: Basic Wrapper Module
    10. 4. Using Dynamic Configuration
    11. Example: Conditional Security Group Rules
    12. Example: Dynamic Variables in Modules
    13. Key Points
    14. 5. Implementing Feature Flags
    15. Example: Using Feature Flags in Module
    16. Example: Conditional Resource Creation
    17. 6. Using Null Labels Pattern
    18. Example: Conditional Resource Creation with null_resource
    19. 7. Implementing Environment Patterns
    20. Example: Environment-Specific Module Usage
    21. Best Practices for Environment Patterns
    22. 8. Using Remote State Pattern
    23. Example: S3 Backend Configuration
    24. Benefits of Remote State
    25. 9. Implementing Module Composition
    26. Example: Basic Module Composition
    27. Best Practices for Module Composition
    28. 10. Using Provider Configuration Patterns
    29. Example: Using Provider Aliases for Multi-Region Deployment