IBM Terraform Associate

Terraform knows nothing about any cloud until a provider teaches it. You install providers from the registry, pin their versions, configure several in one configuration and learn why the dependency lock file exists.

• What a provider is and how plugins load
• Finding providers in the registry
• Constraining versions in required_providers
• Using several providers in one configuration
• Provider aliases for regions and accounts
• The dependency lock file

You build A configuration that uses two providers, pinned and locked.

The same loop runs every Terraform project. You run each command by hand, read an execution plan line by line before it changes anything, and adopt the formatting and validation habits that keep a team’s code consistent.

• Initializing a working directory
• Formatting and validating configuration
• Reading an execution plan symbol by symbol
• Applying and reviewing the result
• Saved plans and why they matter
• Destroying infrastructure deliberately
• Style conventions for HCL

You build A small stack taken through init, plan, apply and destroy.

Resources are what Terraform builds, data sources are what it only reads. You write both, see how Terraform orders them from references alone, and learn when an explicit dependency is the right tool.

• Anatomy of a resource block
• Arguments, attributes and references
• Reading existing objects with data sources
• Implicit dependencies and the graph
• Explicit dependencies with depends_on
• Creating many copies with count and for_each
• Lifecycle arguments in outline

You build A configuration mixing resources and data sources, with its dependency graph explained.

Configuration that cannot be parameterized cannot be reused. You declare typed input variables with validation, set them from files and the environment, learn which value wins, and expose results through outputs and locals.

• Input variables and their types
• Lists, maps, objects, tuples and sets
• Validation rules on variables
• Setting values with tfvars and environment variables
• Variable precedence
• Outputs and local values

You build A parameterized configuration driven by a tfvars file, with validated inputs.

HCL is a small language with real expressions. You build values with conditionals and for expressions, call built-in functions, generate repeated blocks dynamically, and add conditions that stop a bad plan before it reaches a cloud.

• Conditional expressions and operators
• for expressions and splat syntax
• Common string, collection and numeric functions
• Dynamic blocks for repeated nested settings
• Preconditions and postconditions
• Check blocks for ongoing assertions
• Testing expressions in terraform console

You build A configuration that builds its resources from a data structure and rejects invalid input.

Secrets leak through variables, outputs, logs and state. You mark values sensitive, learn what that does and does not hide, and choose where secrets should live so they never reach a repository.

• What sensitive hides and what it does not
• Secrets inside the state file
• Passing secrets by environment variable
• Keeping credentials out of version control
• Pulling secrets from a secrets manager
• Sensitive outputs and their limits

You build A configuration that accepts a secret without printing it or committing it.

A module is a folder of configuration with a contract. You call modules from the registry, a local path and Git, follow how values cross module boundaries, constrain versions and write a small module of your own.

• What a module is and why it exists
• Module sources: registry, local path and Git
• Inputs, outputs and variable scope
• Pinning module versions
• Calling one module several times
• Writing a first module
• Layout of a well-formed module

You build A reusable module kept in a local path and called twice.

State is how Terraform remembers what it built. You compare local and remote backends, see why locking stops two applies colliding, and learn how drift appears when the real world stops matching the code.

• What the state file records
• Local and remote backends
• Configuring a remote backend
• State locking and stuck locks
• How drift happens
• Detecting drift with refresh-only plans
• Protecting state files

You build A configuration moved from local state to a locked remote backend.

Not everything starts in Terraform. You bring existing resources under management with import, inspect state from the command line, and switch on verbose logging when a provider or an API misbehaves.

• Importing with the CLI command and import blocks
• Writing configuration to match an import
• Listing and showing state entries
• Moving and removing state entries
• Verbose logging with TF_LOG
• Reading provider and API errors
• Replacing a broken resource

You build A hand-made resource brought under Terraform without being recreated.

HCP Terraform moves runs, state and policy off individual laptops. You create infrastructure in it, organize workspaces and projects, connect a repository, and see where governance and integrations sit in a team’s workflow.

• Workspaces, projects and organizations
• Connecting a version control repository
• Remote runs and shared state
• Variables and variable sets
• Teams, permissions and approvals
• Governance and policy in outline
• Integrations and run tasks

You build A workspace linked to a repository that plans on every change.

Build one small environment from nothing: providers, resources, variables, a module, remote state and a team workspace. Every earlier skill lands in a single piece of working code that you can explain line by line.

• Structuring the repository
• Writing and parameterizing the configuration
• Extracting a module
• Moving state to a remote backend
• Running it in a team workspace
• Explaining each design choice

You build A complete small environment, built from modules, with remote state and a team workspace.