Description
Terraform Course Syllabus
Introduction
Chapter Overview [preview]
Understanding Cloud Orchestration code and Terraform[preview]
Why Terraform? [preview]
Terraform Vs. Other Orchestration Tools – Why Terraform is the right choice [preview]
Core Terraform Components
Fundamental Concepts
Programming Structure
Chapter Overview [preview]
Terraform syntax : Providers
Terraform Syntax : Resources
Terraform Syntax : Variables
Terraform Syntax : Data sources
Terraform Syntax : Outputs
Connecting to Cloud using Providers[preview]
Terraform Coding Examples
Resources
Chapter Overview[preview]
Provisioning resources with Terraform
Creating and accessing compute instances
Script Executions
Chapter Overview[preview]
Obtaining variables from Terraform into external scripts
Using shell script remote executor from Terraform to configure platform on launched VMs
Deployment Automation using Terraform
Deploying Java application on VMs launched through terraform
Use of elastic ip in Terraform (or Azure Static IP if Azure is chosen)
Automation through Hosts entry modification
Using tomcat API to provision application
Managing Database using Terraform
Managing RDS ( or Azure Database for MySQL if Azure is chosen) using Terraform
Understanding RDS ( or Azure Database for MySQL if Azure is chosen)
Launching RDS DB ( or Azure Database for MySQL if Azure is chosen) Instance using Terraform
Launching Aurora DB ( or Azure CosmosDB if Azure is chosen) Instance using Terraform
Terraform Modules
Understanding the use case for modules
Create and use a module
Module Variables
Remote State
Chapter Overview[preview]
Understanding the use case for Remote State
Managing Remote State using S3 (or Azure Blob Storage if Azure if chosen)
Data Sources
Understanding and Using Data Sources
Templates
Understanding and Using Templates
Integration with Configuration Management Tools
Understanding configuration management
Integration with puppet configuration management
Jenkins Integrations
Understanding integration points between Jenkins and Terraform
Conclusions
Understanding alternatives to Terraform
Where terraform succeeds
In this course, we will start from the basics of terraform and will go to some advanced concepts, use cases of the technology
We will begin with an introduction to the origin story of cloud orchestration domain and understand terraform’s unique view point towards it. We will then break down the structure of terraform and understand the internal components of it before taking on a journey through the basic fundamental concepts introduced in terraform.
After a heavy dose of concepts, we will setup our lab environment where we will setup a terraform environment connected with an AWS cloud account (or Azure cloud account if Azure is chosen). So that we can start learning the coding techniques.
First thing to start with is definitely the syntax and structure of terraform coding. We will learn by looking at some of the examples.
We will then proceed to understand the concept of resources in terraform, and we will start writing our first resource definitions, which will provision these resources on the connected AWS (or Azure if chosen) cloud account. We will launch VMs on cloud, access them manually before tearing them down again with terraform.
Variables are important factors to create dynamic codes. Terraform supports variables and we will take a look at how to use them. We will use them to contain data and we will also use them to pass on data to external scripts.
Using terraform, we can not only launch VMs, but we can even log in to the VM through terraform and execute shell scripts to configure platforms on the VMs launched.
By this time, you would have gathered much understanding of terraform coding to start working on a project. We will take a sample java application and try to set it up as a live application on a tomcat server launched in AWS cloud through terraform. The project will take you through hands on practice on launching VMs through terraform, using elastic public ip.
After thoroughly understanding EC2 VM (or AVM for Azure) provisioning upto this point, we should now also look at some other services. We will do that by going over services like RDS and Aurora DB . Launching RDS and Aurora will be covered in the course (or Azure Database for MySQL if Azure is chosen).
Terraform modules are created for modularity & portability of code. We will take a quick look at the use cases before creating and using one. There is a term called blueprint, which is used to describe use of multiple terraform modules together. We will build a blueprint. We will also look at the use of variable overrrides when using modules.
Terraform is a desired state configuration management language. When it launches something, it stores the detailed configuration information in a state file. It is necessary to launch all lifecycle commands from the same directory where that statefile is available. While that is an easy thing to do for a single individual’s working with terraform using a single machine, that is not an ideal solution for enterprise situations where multiple people have to work together maybe due to shift based work or simply to share the amount of work. In such cases let’s say, the person who lauched a VM using terraform, works in the night shift and his machine has the state file. How will he pass on the state file to the next person who comes in morning shift? Typically there should be a shared location where he can keep the file so both of them can share it. That is what we do when we use remote state in terraform and S3 (or Azure Blob Storage) is a popular shared location option. We will see how this is achieved.
Next we will go through the concepts of data sources that terraform can use to fetch data and see how to use them.
Templates in terraform allow large information such as entire JSON files to be passed on in terraform resource parameters while making use of variables in the process. We will see some practical examples.
Terraform and Puppet are complementary to each other. We will write a code that launches VMs with Puppet bootstrapping.
To complete the overall understanding, it is important to have a clarity about position of terraform in the larger devops landscape. Which is why we will finish off the course with an integration of terraform into Jenkins pipeline.
The pipeline will use terraform to launch a VM and install middleware on it using Puppet while pushing application on it using middleware API. We will conclude with some discussion about competition to terraform in the market.
Our classes are conducted on web conferencing systems with auto cloud recording. The recordings are shared with attendees after session. The system allows our trainer to share whiteboards, share their labs with you. Our trainers can also take control of your screen if you need help and permit the same.
For attending classes, you need to have a computer and a good internet connection
If your system does not have adequate configuration (2 GB RAM, 1 CPU), then you can also ask for a lab environment. The lab environment will not cost you any extra amount.
Our conference calls can also be attended on phone through our mobile optimized app or web interface.
All class recordings will be shared on email and they will also be available on our LMS platform
Once registered, you will get access to the LMS system.
You will also get access to study materials such as source codes and presentations in LMS.
Also our LMS is populated with video series on DevOps which you can utilize for self paced learning.
We also constantly upgrade our materials to make them relevant and latest with new technologies in market.
Reviews
There are no reviews yet.