Gain insights into DevOps in Azure, delve into configuration management, CI/CD, and Infrastructure as Code. Explore tools like GitHub and Kubernetes through hands-on projects to become a DevOps professional.

admintodevops.tar.gz

Username

Password

AZURE_SUBSCRIPTION_ID

AZURE_CLIENT_ID

AZURE_SECRET

AZURE_TENANT

Git_Email

Git_Name

Azure

Ansible

Chrome

vscode 

Azure-VM

Terraform

az-boards

azure-instances

azure-pipelines

Docker

This course is for anyone in IT or software engineering who wants to learn more about DevOps and, specifically, how to follow DevOps practices in Azure. Whether you’re a system administrator, engineer, developer, or IT manager, this course will help you understand what it takes to deliver more value to customers with DevOps.

You will dive into concepts like configuration management, continuous integration/continuous delivery, and Infrastructure as Code. You will learn the key tools used by DevOps professionals such as: the command line, Visual Studio Code, GitHub, Kubernetes, and more.

You will complete various projects throughout the course where each chapter’s project is designed in a step-by-step manner to walk you through using the tool just as you would in your daily life.

By the time you finish, you will have the foundations in place to become a DevOps professional.

The Complete Guide to DevOps in Azure

# Referencing variables

So far, you've learned a lot about how to *define* variables but ultimately you need to *read* them too. Reading variables is the easy part! Once you've defined a variable and have assigned it a value,  you can reference that variable's value by using an expression.

Perhaps you've created the variable called `virtualMachineName` and need to reference that variable's value inside of a configuration file. To do that, you can use an *expression*. You can see an example of the syntax to do this below.

```
resource azurerm_virtual_machine "VM" {
    name = var.virtualMachineName
}
```

# Modules

So far, you've learned about various configuration files like the main configuration file `main.tf`, an optional variable configuration, and a variable definition file (TFVARS). These three files are stored in a single directory. The directory is typically named after what the configuration as a whole is creating. For example, if the configuration creates an AzureVM, the directory might be called *AzureVM*. The directory (*AzureVM*) where the Terraform configuration files are stored is called a *[module](https://www.terraform.io/docs/modules/index.html#standard-module-structure)*.

# State file

When you run the Terraform binary, Terraform reads all configuration files inside of the current directory to figure out what to build. It evaluates all of the variables and other logic you created inside of those configuration files to create a **state**. That state then represents the values of all configuration items Terraform needs to manage infrastructure defined in the configuration files or the module.

A state file consists of all metadata for the resources that Terraform is managing. The state file contains components like the subscription ID, virtual machine name, resource group that the resources will reside in, and many others. 

Think of a Terraform state file like a bucket of products to create chocolate chip cookies. You have chocolate chips, flour, and mixing supplies, etc. Without all of those products, you can’t make chocolate chip cookies and without a Terraform state file, you can’t create or manage Azure resources.

When you run Terraform, Terraform creates a **state file** to store the current state of the resources under management called `terraform.tfstate`. A state file holds what type of resource is being created and the provider that’s being used with name, location, and so on. The state file holds *everything* Terraform needs to create or update those resources.

Learn how to read variables and understand the purpose of the module directory and state file. 