region

secret_key

access_key

Gain insights into Terraform’s infrastructure-as-code capabilities. Learn about setting up local files, managing remote resources, and mastering unique modules, data structures, and resource management techniques.

terraform.tar.gz

TF_VAR_YOURSECRETKEY

TF_VAR_YOURACCESSKEY

TF_VAR_region

main.sh

ch 2 p1 a-managing resources 

ch 2 p4-graph

ch 2 p2- implicit dependency

ch 2 p3- explicit dependency

ch 1 p1-a terraform resources

graph

ch 1 p1-b terraform resources

ch 1 p2-a ltthw_state

ch 1 p3-a ltthw_plan

ch 1 p4-a ltthw_output

ch 1 p5-a ltthw_destroy

ch 2 p1 b-managing resources 

ch 2 p5- importing resources

ch 3 p1- ltthw_modules

ch 3 p1-b ltthw_modules

ch 3 p2-a ltthw_variables

ch 3 p2-b ltthw_variables

ch 3 p3-b ltthw_output

ch 3 p4 ltthw_structure

ch 3 p5 a datatypes

ch 3 p5 b datatypes

ch 3 p5  datatypes-complex

ch 4 p1 ltthw_null_resources

ch 4 p2 ltthw_multiple

ch 4 p3 ltthw_backends

ch 4 p3 b ltthw_backends

exercise-ex

ex-1my_name

ex-1my_name-2

ex-3nested

ex-3nested-copy

ex-4prov -1

ex-4prov -2

exercise 2

Terraform is an infrastructure-as-code (IaC) platform that allows users to manage and integrate various external resources as united infrastructure. This is achieved by using the proprietary HashiCorp Configuration Language (HCL) or JSON.

This course is a comprehensive introduction to Terraform. It helps users build confidence through foundational understanding of Terraform’s approach to resource management and the coding environment. You’ll start with an introduction to Terraform and learn how to set up local files. You’ll then take your learning to the cloud, managing remote resources by identifying unique resources and dependencies. Next, you’ll learn the modules and data structures unique to Terraform before practicing various techniques for infrastructure management, including triggers, resource creation, and backend code.

By the end of this course, you’ll have learned to think creatively and be ready to solve production and deployment problems through Terraform.

Beginner’s Guide to Terraform

# Overview

This lesson covers different aspects of creating multiple instances of the same resource in Terraform.

In it, we’ll go over the following concepts:


- The `count` resource meta-argument.

-The splat (`[*]`) operator.

- The `for` loop in Terraform.

- The `for_each` resource meta-argument.

# Importance

These techniques and keywords are essential for a firm understanding of Terraform. This is particularly true for systems and applications that need to scale their resources. For example, we might want to create 100 AWS EC2 instances, or loop over a list of usernames creating accounts for each.

# Multiple VPCs 



We’ve created the `ltthw_multiple` directory and the `main.tf` file. In the `main.tf` file, we’ve added `provider` and `resource`.


import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

The `count` meta-argument looks like a simple variable, but it has a significant effect on the Terraform code. A meta-argument is a value that tells Terraform about the resources being created rather than the details of the resources themselves.

As you have probably guessed, setting `count` creates that number of resources. Remember that Terraform is declarative, but if we think in terms of iterative code, then this turns the code into something like a `for` loop. In this `for` loop, `count.index` can be used to refer to which iteration we’re currently on.

Also seen above is the `format` function, which allows us to format strings. If you want to learn more about it, look up the Terraform format function. In this case, the subnet for the `cidr_block` value for each of the three AWS VPCs created is provided.

Like a typical `for` loop in other programming languages, the count is zero-indexed. What values do you expect for each `cidr_block` when you apply this code?

Now plan and apply the Terraform code like so:


```
terraform plan
terraform apply -auto-approve
```
Carefully examine the output. First, we see that the resources are created in an array-like structure (`aws_vpc.aws_vpc_count[0]`, `aws_vpc.aws_vpc_count[1]`, and so on) starting from a subscript of `0`.


# The splat (`[*]`) operator

We examined the output of the `terraform plan` command to see what the `count` variable did to the resources created by Terraform.


If we want to affect the output of the module by outputting data from the created resources, there are a couple of ways to accomplish that. The first is by using the splat operator. Run the following commands:




Learn to create multiple resources in Terraform.

Create Multiple Resources

Getting Started

Local Basics

Remote Terraform

Modules and Data Structures

Intermediate Terraform Techniques

Conclusion

Create Multiple Resources