Terraform Variables and Functions Quiz

Values used to pass information to Terraform at runtime, defined within the configuration and supplied during execution.

Computed values within a Terraform configuration that can be referenced throughout, similar to variables in other languages.

Values that Terraform returns after deployment, defined within the configuration and dependent on referenced values.

A keyword that defines the start of a block that declares input variables.

A unique identifier assigned to an input variable, used to reference it within the configuration.

The process of supplying values to input variables when executing Terraform.

The process of transforming values within a Terraform configuration, usually using computed values and internal references.

The process of retrieving values from a deployed configuration using output variables.

A variable with no arguments within its block.

A data type argument that enforces specific data types and checks for type mismatches.

A descriptive text about the variable's purpose and expected value.

Allows setting a default value when no value is explicitly provided at runtime.

A Boolean argument that hides sensitive values from logging and output.

Refers to values from variables within the Terraform configuration. Syntax: var.variable_name

A primitive data type representing a sequence of characters.

A primitive data type representing a numerical value, either integer or decimal.

A primitive data type representing a logical value, either true or false.

A collection data type representing an ordered group of elements of the same type.

A collection data type representing an unordered group of unique elements of the same type.

A collection data type representing key-value pairs where keys are unique strings and values are of the same type.

Special data type that signifies uncertainty about the data type within a collection, allowing for various types.

Special data type representing the absence of a value.

A structural data type similar to a list but allows for mixed data types.

The type argument specifies the collection type (e.g., list, map) and the data type of its elements.

A list is an ordered collection of values that can be accessed by their index (starting from 0).

A map is a collection of key-value pairs where each key is unique and associated with a value.

A reference to a variable within a Terraform configuration, using 'var.<variable_name>' syntax.

A keyword used to define input variables within Terraform configurations.

A unique identifier assigned to a variable, used to distinguish it from other variables.

Setting a variable as sensitive prevents its value from being displayed in logs or terminal output.

A set of default values that are automatically provisioned when declaring a variable, unless a specific value is provided during configuration.

A block of code that defines input variables and their characteristics within a Terraform configuration, typically stored in a separate file named 'variables.tf'.

Terraform's built-in provider for interacting with AWS services, requiring configuration for access keys and region.

The process of replacing hard-coded values in a Terraform configuration with dynamic and reusable variable references.

The default region for AWS resources, which can be changed using variables.

The process of providing values to input variables during the execution of a Terraform configuration.

A file that contains the main configuration for your deployment, usually named 'main.tf' in Terraform projects.

A process where Terraform combines all '.tf' files located in the same directory into a single configuration.

The syntax for a Terraform local value, which references a calculated value within a configuration.

A block that defines local values in a Terraform configuration. Computed values are stored and referenced within this block.

Metadata assigned to resources that provide additional information and context. These tags are usually formatted as key-value pairs.

A specific set of tags that are considered common or standard across multiple resources in a configuration.

A value or data point that is hard-coded into a configuration, which can be replaced with variables for more flexibility.

The process of replacing hard-coded values with variables or local values, making configurations more dynamic and manageable.

A feature in Terraform that allows retrieving values from a deployed configuration, exposing information about the created resources.

The terraform fmt command updates the code to conform to HashiCorp's preferred formatting style. It ensures consistent, readable code and helps in comparing different versions.

The -check flag runs terraform fmt without actually modifying the files. It returns an error if any formatting issues are found.

The recursive flag instructs terraform fmt to format Terraform files in the current directory and all subdirectories. This is helpful when working with modules.

The terraform validate command checks the syntax and logic of the Terraform configuration, ensuring it's correct. It needs Terraform to be initialized to access provider plugins.

The terraform init command initializes Terraform, downloading and configuring necessary provider plugins for validation.

The terraform validate command checks the syntax and logic of the configuration, but doesn't verify if the deployment will succeed.

Errors in Terraform can occur due to incorrect attribute values, missing variables, or issues with provider configurations.

When running terraform validate, Terraform provides an error message indicating the specific issue and the line number where it occurred.

You can fix errors by examining the error message, correcting the code, and then re-running terraform validate to confirm the fix.

Variable values can be set through default arguments, command-line flags, or using a dedicated file.

The -var flag allows you to set a variable value directly at the command line when running terraform apply or terraform plan.

The -var-file flag allows you to specify a file containing key-value pairs for variables, which can be used when running Terraform commands.

Instead of running terraform init again after adding a variable, you can directly run terraform validate to check the configuration.

After fixing errors and successfully validating the configuration, you can proceed with terraform plan to preview changes before applying them.

When you're done, unpause the video, and we'll continue. All right, I have added those variables to my configuration. I set a default of Globomantics for the company and specified no default value for the project or for the billing code. Feel free to make any arrangements to your code to match mine. Next, we'll add those variable values to our local value of common_tags, and we can do the same thing we did before. I'll hide the File Explorer to make it easier to work with two files. We'll split the variables out to the right side so it's easier to work with and show the locals on the left side so we remember exactly what we're working with. We'll start by adding the company tag. Next, we'll add the project tag. And for this one, John had requested that the project be company name, dash the project name for the value. Now how do we go about referencing an input variable inside of a larger string? Time to introduce a bit of new syntax here called interpolation. It sounds really fancy, but it's actually quite easy. We start by adding quotes to indicate that this is going to be a string. Then we need to reference our company variable. We'll start with the dollar sign, followed by curly braces. This syntax tells Terraform that it should take whatever it finds between the curly braces, interpret the expression, and render it as a string. We want to reference our variable value for company, so that's what we'll put between the curly braces, var.company. When you hear the term interpolation, this is all we're talking about, turning a Terraform expression into a string, nothing fancy at all.

We'll start by adding quotes to indicate that this is going to be a string. Then we need to reference our company variable. We'll start with the dollar sign, followed by curly braces. This syntax tells Terraform that it should take whatever it finds between the curly braces, interpret the expression, and render it as a string.

We start by adding quotes to indicate that this is going to be a string. Then we need to reference our company variable. We'll start with the dollar sign, followed by curly braces. This syntax tells Terraform that it should take whatever it finds between the curly braces, interpret the expression, and render it as a string. We want to reference our variable value for company, so that is what we'll put between the curly braces, var.company.

Next, we're going to add a dash after the curly braces and another reference to the project value that's stored in the variable project. Now, we've created a string from our two variables that is in the form of company‑project. Lastly, let's add our billing code. And there we go. We have successfully created our common_tags local value.

The next thing to do is add this common_tags value to our main.tf file for each AWS resource that supports tags. Let's add the first one together. I'll switch over to the main.tf file and go down to our first resource, which is the aws_vpc. Within the configuration block, I'll add the tags argument. I'm going to set the tags equal to local.common_tags. The common_tags map will be submitted to the tags argument, which is expecting a data type of map, and those tag values will be applied to the VPC.

My challenge to you now is to pause the video and add this tags argument to all the other resources in our configuration that support a tags argument. The only resource that does not is the AWS route table association resource, so you can add the tags argument to all the other resources in the configuration. Pause now and resume when you're done.

Outputs are how we can get information out of Terraform. Outputs are printed out to the terminal window at the end of a configuration run. Terraform also stores output values in the state data and they are used to expose values when a configuration is placed inside a module, something we'll cover later in the course.

The syntax for an output starts with the output keyword, followed by the name label for the output.

Just like the value of a local, the value of an output can be any supported Terraform data type. You can return a simple string, a complex object, heck, you can return an entire resource with all of its attributes if you want to.

You might be tempted to skip it, but it's better to provide clarity of the purpose behind an output rather than leave it up to the user to figure out.

The sensitive argument will set an output to sensitive, meaning that the actual value will not be printed to the terminal. This is useful if you want to pass a value from one module to another and avoid having it written in clear text in the logs or the terminal.

Here's an example of an output with the name label public_dns_hostname. We're setting the value equal to the public DNS attribute of our webserver EC2 instance, using the same reference syntax we saw in the previous module. We've included a description of the output, too, for our own reference. Now, sensitive is not set, so it defaults to a value of false.

Just as we did with the locals and with the variables, let's add a file for the outputs. Within the outputs, we are going to define a single output. We'll start with the output keyword, and we'll set the name to aws_instance_public_dns. For the value, we are going to reference our EC2 instance, so let's go back into split‑screen mode here and bring up our main.tf file. We'll scroll down to the instance definition. And for that, we'll copy the type, paste it in, we'll add the name label nginx1, and we'll add the property of public_dns. Now to make this output a valid URL, let's use our powers of interpolation again. We'll put the value in quotes, add http://, and then we'll add a dollar sign followed by the curly braces.

Now to make this output a valid URL, let's use our powers of interpolation again. We'll put the value in quotes, add http://, and then we'll add a dollar sign followed by the curly braces.

And there we go. We should be able to copy and paste the output value right into a browser. I'll also add a description here of the Public DNS hostname for the EC2 instance. And there we go.