Terraform Crash Course - Tulsa Web Devs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "76f86798-f06d-40f5-87fa-e538c254cc55",
   "metadata": {},
   "source": [
    "# Terraform Crash Course - Tulsa Web Devs\n",
    "**Date of Event**: March 26th, 2024"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41a9e10d-354b-40af-bed8-a711423cef33",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "### IaC? Terraform?\n",
    "Infrastructure as Code (IaC) is the managing and provisioning of infrastructure through code instead of through manual processes. By using code and software to automate the infrastructure creation process, you can reduce errors in redeploying infrastructure, leverage tools like git for version control, and eliminate configuration drift. \n",
    "\n",
    "Just to note, Terraform is not the only Infrastructure as Code tool available. There are other existing tools such as Pulumi, Crossplane, Ansible, and others. All of them come with their own pros and cons. Some cloud providers have their own cloud-specific Infrastructure as Code tool. AWS has CloudFormation and Azure has Bicep (which is probably the coolest IaC tool name ever). Bt these tools only work within a specific cloud environment. If you are working with multi-cloud environments, you might be better off using an IaC tool like Ansible, Pulumi, or Terraform. \n",
    "\n",
    "### But What About Open Tofu?\n",
    "OpenTofu is a fork of Terraform project maintained by The Linux Foundations Project since HashiCorp (the creator of Terraform) switched the license of Terraform from an open-source license to a source available license. If you'd rather use OpenTofu instead of Terraform, you should be able to follow along with this tutorial. Just replace `terraform` with `tofu` when running your terminal commands."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82c844b2-94a3-4173-9d1c-58d86e871957",
   "metadata": {},
   "source": [
    "## Installing Terraform \n",
    "### MacOS\n",
    "Installing Terraform on MacOS is very simple if you have the package manager Homebrew. Install it via homebrew by using the following command:\n",
    "```\n",
    "brew tap hashicorp/tap\n",
    "brew install hashicorp/tap/terraform\n",
    "```\n",
    "\n",
    "### Windows\n",
    "Installing Terraform on Windows OS is also pretty simple if you have the package manager Chocolatey. Install it via chocolatey by using the following command:\n",
    "```\n",
    "choco install terraform\n",
    "```\n",
    "\n",
    "### Linux\n",
    "If you are using a Linux distro, follow the directions at this [link here](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli) to install.\n",
    "*Note: These directions work for those who are using a Chromebook as well. Just follow the Debian installation instructions after activating Linux mode.*\n",
    "\n",
    "You can check if the installation worked by running the `terraform -version` command in your terminal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5c0f6a5-2a38-4a43-9edb-a06e618f8466",
   "metadata": {},
   "outputs": [],
   "source": [
    "!terraform -version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60331f65-7b81-4cf0-88b8-6e67da35502b",
   "metadata": {},
   "source": [
    "## Write the Plan\n",
    "\n",
    "Before we can start deploying our infrastructure to cloud providers, we must write the plan. Every Terraform project needs to have a `main.tf` file. You can place all of your Terraform code in this file. But it is generally best practice to separate related infrastructure into separate files and within the main.tf file to only declare your required providers and backend references within the Terraform block.\n",
    "\n",
    "With this in mind, there are two important parts of the Terraform block: the `backend` and `required providers`. The backend block contains information about where the state of your infrastructure is stored. The state is a document that contains a record of what infrastructure is currently deployed. This helps us see the discrepancies between what is written in the plan and what is currently deployed. For the purpose of this tutorial, we will be using the `local` backend, which is simply a reference to a file on your local computer. Tjere are many other backends you can use to store the state of your infrastructure, including: Azure Blob Storage (azurerm), Consul Key/Value store (consul), Tencent Cloud Object Storage (cos), Google Cloud Storage (gcs), REST API Client (http), Kubernetes secret (kubernetes), Alibaba Cloud Object Storage Service (oss), Postgres database (pg), and Amazon S3 (s3). To learn more about the available backend configurations, [click here](https://developer.hashicorp.com/terraform/language/settings/backends/configuration). \n",
    "\n",
    "The provider block allows you to include modules into your project. The most common use of modules is for provisioning resources in specific cloud providers. You can find the list of available modules at [registry.terraform.io](https://registry.terraform.io/). \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9515f643-d940-4e7e-98b5-4713145cc0ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile main.tf\n",
    "terraform {\n",
    "    required_providers {\n",
    "        github = {\n",
    "            source = \"integrations/github\"\n",
    "            version = \"6.1.0\"\n",
    "        }\n",
    "    }\n",
    "\n",
    "    backend \"local\" {\n",
    "        path = \"terraform.tfstate\"\n",
    "    }\n",
    "}\n",
    "\n",
    "provider \"github\" {\n",
    "    token = var.token\n",
    "    owner = var.github_organization\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbb0faf8-1e9b-4112-9486-d070bd166af8",
   "metadata": {},
   "source": [
    "Terraform plans consist of five primary block types: `variable` blocks, `data` blocks, `resource` blocks, `local` blocks, and `output` blocks. We will explore four of the five block types in this tutorial. \n",
    "\n",
    "Variable blocks allow for you to customize the behavior of your modules without having to directly edit the plan. There are six optional parameters you can set when declaring a variable block: `type`, `description`, `default`, `validation`, `sensitive` and `nullable`.The `type` parameter indicates the type of data stored in the variable. There are six types in Terraform: `string`, `number`, `boolean`, `map` (or object), `list`, and `set`. The `description` is where you can provide a helpful description of what the variable is supposed to be for. The `default` parameter determines what the variable will be if the value is not defined elsewhere. The `validation` parameter allows you to define specific requirements a variable value must be. The `sensitive` parameter allows you to hide sensitive variables from being stored in the state. And `nullable` allows you to define whether the variable can be null or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3b295e7-cbef-48ec-8b70-da4ea8a78039",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile variables.tf\n",
    "variable \"token\" {\n",
    "    type = string\n",
    "    description = \"The Github URL Token\"\n",
    "}\n",
    "\n",
    "variable \"github_organization\" {\n",
    "    type = string\n",
    "    description = \"The name of the organization you want to make the Github Pages for\"\n",
    "}\n",
    "\n",
    "variable \"github_repository\" {\n",
    "    type = string\n",
    "    description = \"\"\n",
    "}\n",
    "\n",
    "variable \"forked_repository\" {\n",
    "    type = string\n",
    "    description = \"The name of the repository that we're forking files from\"\n",
    "    default = \"EternalLuxury/basic-html-website\"\n",
    "}\n",
    "\n",
    "variable \"favorite_number\" {\n",
    "    type = number\n",
    "    description = \"A simple variable for storing my favorite number\"\n",
    "    default = 8\n",
    "}\n",
    "\n",
    "variable \"toggle_index\" {\n",
    "    type = bool\n",
    "    description = \"Conditionally include the index file\"\n",
    "    default = true\n",
    "}\n",
    "\n",
    "variable \"additional_files\" {\n",
    "    type = list(string)\n",
    "    description = \"A list of files to include in repository\"\n",
    "    default = [\n",
    "        \"assets/css/bulma.min.css\",\n",
    "        \"assets/css/style.css\",\n",
    "        \"assets/js/jquery-3.6.0.js\",\n",
    "        \"assets/js/script.js\"\n",
    "    ]\n",
    "}\n",
    "\n",
    "variable \"example_map\" {\n",
    "    type = map\n",
    "    description = \"A list of files to include in repository\"\n",
    "    default = {\n",
    "        \"name\" = \"Nile Dixon\",\n",
    "        \"age\" = 26,\n",
    "        \"tall\" = true\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "682df628-33ce-4a86-86fb-bee2bd6dcfed",
   "metadata": {},
   "source": [
    "Data blocks are \"read-only\" resources that can pull information from a provider. The information being read into the plan can be used to help create resources or be outputs for the module. To see what information can be read, check the Terraform registry for the specific provider you're using.\n",
    "\n",
    "```\n",
    "#Example structure of data block.\n",
    "data \"type\" \"name\" {}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bfb1b16-9ced-470e-aa61-9a5a13665e6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile data.tf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b5ddfc7-2c88-46ce-9dc3-9cf6fbab72b9",
   "metadata": {},
   "source": [
    "The resource block allows you to create resources from a specific module, which will usually correspond to a resource provided by a provider downloaded from the registry. You create resources by first referencing the type and then creating a user-defined name. Resource-specific parameters are passed within the block. To see what types are available and what their required and optional parameters are, check out the Terraform registry.\n",
    "\n",
    "```\n",
    "#Example structure of resource block.\n",
    "resource \"type\" \"name\" {}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93da9b8e-7d5a-46f0-b288-da7497ad1d8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile github.tf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f474459-2c2f-411c-8c55-22d82bb9302d",
   "metadata": {},
   "source": [
    "In some cases, when a resource is created within a module, the output will sometimes need to be an input for another module. The output block allows you to pass a variable from the current module to another module. When you see values of resource blocks being accessed, it is because the module creator made those values outputs for us to import. \n",
    "\n",
    "```\n",
    "#Example structure of resource block.\n",
    "output \"name\" {}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8bb077f-fc67-4943-88b9-8d358d11d788",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile outputs.tf\n",
    "output \"url\" {\n",
    "    value = github_repository.example_repository.html_url\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64d0c683-7e0e-4fc1-a741-f1e8742c18ba",
   "metadata": {},
   "source": [
    "To help better explain when you would use certain block types, look at the following table for an OOP equivalent mapping:\n",
    "\n",
    "\n",
    "| Variable Type | OOP Equivalent |\n",
    "| -----------   | -----------    |\n",
    "| local         | private        |\n",
    "| resource      | protected      |\n",
    "| variable      | parameters     |\n",
    "| output        | super-public   |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0ce7d95-4482-4033-bdec-4be017b0e29f",
   "metadata": {},
   "source": [
    "Earlier we created a list of variable blocks. There are a few ways to change the defaults. One way is by passing the variable values into your `terraform plan` and `terraform apply` commands using the `-var` argument. Another way is by creating a JSON file containing the arguments. You would pass that JSON file into your `terraform plan` and `terraform apply` command using the `-var-file` argument. However, if your JSON file is named `variables.auto.tfvars.json`, Terraform will automatically pick it up. There is a hierarchy of the order Terraform reads variables, so just know that when storing default values and creating JSON documents for Terraform to reads as variable files.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d66ea87b-343e-422c-b200-a2d2c9de8811",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile variables.auto.tfvars.json\n",
    "{\n",
    "    \"token\" : \"\",\n",
    "    \"github_organization\" : \"\",\n",
    "    \"forked_repository\" : \"EternalLuxury/basic-html-website\",\n",
    "    \"github_repository\" : \"\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8d20262-c44c-4f2e-9c5c-df60e266de23",
   "metadata": {},
   "source": [
    "## Execute the Plan\n",
    "\n",
    "Before you push your Terraform code to a git repository or share it with others, you might want to make sure your code follows the styling guide. Terraform makes this easy with the `terraform fmt` command. Using the `-recursive` flag applies the formatting to all files in the folder and subfolder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9111dfd9-0ff1-4fb1-844a-16980e4bbec1",
   "metadata": {},
   "outputs": [],
   "source": [
    "!terraform fmt -recursive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed902520-2683-432d-853b-bc87181d6027",
   "metadata": {},
   "source": [
    "Now that your code is formatted, we're going to initialize our Terraform plan by using the `terraform init` command. Our local configuration referenced in the `main.tf` file is statically referenced in the file. If you want to dynamically inject different configurations, you would use the `-backend-config` flag. The `-backend-config` parameter could be a file path to an HCL file, or it could be a key/value pair string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b05a0f7a-40d9-4164-9834-a3bc98ba84e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "!terraform init"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71379e87-f53c-4ae5-9a3c-d486571df56a",
   "metadata": {},
   "source": [
    "After initializing the Terraform plan, you can optionally run the `terraform validate` command to check the correctness of the Terraform code. This is more than just simply checking the syntax of the code, as this command checks to see if the appropriate references exist and other code checks. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ef8fac4-0d05-4065-8e07-f5677673d620",
   "metadata": {},
   "outputs": [],
   "source": [
    "!terraform validate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3be60c18-df0c-4304-99c8-c5b7f505d727",
   "metadata": {},
   "source": [
    "After validating your Terraform code, you can optionally run the `terraform plan` command. When running this command, Terraform will compare the state of the infrastructure with the state of the plan. If a resource does not exist in the state but does in the plan, the resource will be created. If a resource does exist in the state but not in the plan, the resource will be deleted. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "086667fc-8fa9-4313-bf7d-fee70752f6e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "!terraform plan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e6f3b3a-8553-4eeb-9b4a-6d822649bb08",
   "metadata": {},
   "source": [
    "Now that the plan has passed, we can run the `terraform apply` command. This will actually deploy the changes. When running this command in the terminal, you will be asked to approve the plan changes by typing yes. You can use the `-auto-approve` flag to bypass the manual approval. But I don't recommend this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfbf5365-95ff-44c1-bded-b2b4402085d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "!terraform apply -auto-approve"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "802625e0-f150-4abc-b50a-7572f35a0804",
   "metadata": {},
   "source": [
    "We can delete everything we've made by running the `terraform destroy` command. Running this command can be helpful of clearing out an account without having to delete the code for the plan. Similar to the `terraform apply` command, it will require a confirmation if not using the `-auto-approve` flag. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04bd130e-c224-4210-95ca-082bbfe79475",
   "metadata": {},
   "outputs": [],
   "source": [
    "!terraform destroy -auto-approve"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8452cb9-4253-499a-aff5-27f79944463e",
   "metadata": {},
   "source": [
    "## Have some fun with Terraform\n",
    "\n",
    "If you are interested in experimenting with Terraform, try using the following Terraform providers. Some of the providers might interface with paid resources. Those resources are denoted below.\n",
    "\n",
    "- [AWS (Paid)](https://registry.terraform.io/providers/hashicorp/aws/latest)\n",
    "- [Azure (Paid)](https://registry.terraform.io/providers/hashicorp/azurerm/latest)\n",
    "- [Docker (Free if run locally)](https://registry.terraform.io/providers/kreuzwerker/docker/latest)\n",
    "- [GCP (Paid)](https://registry.terraform.io/providers/hashicorp/google/latest)\n",
    "- [Github (Free)](https://registry.terraform.io/providers/integrations/github/latest)\n",
    "- [Gitlab (Free)](https://registry.terraform.io/providers/gitlabhq/gitlab/latest)\n",
    "- [Heroku (Paid)](https://registry.terraform.io/providers/heroku/heroku/latest)\n",
    "- [Kubernetes (Free if run locally)](https://registry.terraform.io/providers/hashicorp/kubernetes/latest)\n",
    "- [Snowflake (Paid)](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/latest)\n",
    "- [Vercel (Paid)](https://registry.terraform.io/providers/vercel/vercel/latest)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7004832e-23a8-47dd-a360-7c9baaa71730",
   "metadata": {},
   "source": [
    "## Want to learn more about Terraform?\n",
    "If you are interested in learning more about Terraform's syntax and how it can be incorporated into your workflow, look at the following books, courses, and videos:\n",
    "- **Books**\n",
    "  - [Terraform in Action by Scott Winkler](https://www.amazon.com/Terraform-Action-Scott-Winkler/dp/1617296899/ref=asc_df_1617296899/?tag=hyprod-20&linkCode=df0&hvadid=459709175715&hvpos=&hvnetw=g&hvrand=11464051453519057678&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=1024352&hvtargid=pla-932338106285&psc=1&mcid=6da05ddb860a317eb8edc8c45b7d3955&gclid=EAIaIQobChMIqcTx_57bgwMVOyvUAR0nsgnXEAQYBSABEgJ3rvD_BwE)\n",
    "  - [Terraform: Up and Running: Writing Infrastructure as Code by Yevgeniy Brikman](https://www.amazon.com/Terraform-Running-Writing-Infrastructure-Code/dp/1098116747/ref=asc_df_1098116747/?tag=hyprod-20&linkCode=df0&hvadid=564675582183&hvpos=&hvnetw=g&hvrand=11464051453519057678&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=1024352&hvtargid=pla-1646950848405&psc=1&mcid=a915c98cefdc3e7598efec21012828c1&gclid=EAIaIQobChMIqcTx_57bgwMVOyvUAR0nsgnXEAQYASABEgJqWPD_BwE)\n",
    "- **Courses**\n",
    "  - [HashiCorp Terraform Associate Certification Course by FreeCodeCamp](https://www.youtube.com/watch?v=SPcwo0Gq9T8&pp=ygUJdGVycmFmb3Jt)\n",
    "  - [Terraform explained in 15 Minutes | Terraform Tutorial for Beginners by TechWorld with Nana](https://www.youtube.com/watch?v=l5k1ai_GBDE)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}