headerpic
« Hem

Infrastruktur som kod, del 1 – Terraform

Skrivet av: Andreas Andersson
November 22, 2018

Med Terraform kan du definiera och skapa distributioner för hela infrastrukturen i Azure. Du kan skapa Terraform-mallar i ett läsbart format som skapar och konfigurerar Azure-resurser på ett konsekvent och reproducerbara sätt.

I detta blogginlägg så förutsätter jag att du har Visual Studio Code, Azure Automation samt en Azure prenumeration.

Vi behöver börja med att ladda ner Terraform ifrån deras hemsida, jag kommer använda mig av Windows varianten av Terraform.

 

Terraform använder sig av ett par olika filer som vi måste skapa upp

  • tf – Här definierar vi våra resurser vi vill skapa upp.
  • tf – Vilken provider du vill använda dig av, vi kommer använda azurerm för Azure.
  • tf – Här definierar du dina variabler som vi kommer referera till i main.tf
  • tfvars – Här definierar vi innehållet i våra variabler.

Eftersom det är en bra idé att spara ner detta i någon form av källkodshantering så är det viktigt att inte spara ner provider.tf och terraform.tfvars då vi kommer ha känslig data i dessa filer.

Vi börjar med att logga in i Azure antigen med Azure CLI eller portalen då vi kommer skapa upp en Service Principal för att använda oss av under våra deployer så att vi slipper logga in varje gång då dessa uppgifter kommer sparas i provider.tf filen.

För att skapa en Service Principal kommer jag använda mig av Azure CLI i Visual Studio Code, men det går lika bra att göra det från portalen eller Cloud Shell.

Börja med att logga in till Azure med ’az login’ efter det så skapar vi en Service Principal med hjälp av detta:

az ad sp create-for-rbac --name="tfdemo" --role="Contributor" --scopes="/subscriptions<PrenummerationsID>"

 

Du kommer att få följande information tillbaka som vi kommer behöva använda oss av:

{
  "appId": "yyyyyyyy-xxxx-xxxx-xxxx-yyyyyyyyyyyy",
  "displayName": "tfdemo",
  "name": "http://tfdemo",
  "password": "yyyyyyyy-xxxx-xxxx-xxxx-yyyyyyyyyyyy",
  "tenant": "yyyyyyyy-xxxx-xxxx-xxxx-yyyyyyyyyyyy"
}

 

I Visual Studio Code (härefter VS Code) så skapa upp en mapp att jobba i och skapa sedan de tidigare nämnda filerna. Jag skulle även rekommendera att installera tillägget Terraform av Mikael Olenfalk.

Efter filerna är uppskrapade så kommer vi börja med provider.tf

Här definierar vi vilken provider vi kommer använda oss av och även uppgifterna för den Service Principal vi skapade upp tidigare.

Innehållet kommer se ut såhär då vi använder oss av azurerm samt en service principal för att göra inloggningen.

provider "azurerm" {
subscription_id = "${var.azure_subscription_id}"
client_id = "${var.azure_client_id}"
client_secret = "${var.azure_client_secret}"
tenant_id = "${var.azure_tenant_id}"
}

 

 

Som du ser kommer jag använda mig av variabler för att ha all känslig data på ett och samma ställe istället för att sprida ut det i de olika filerna vi kommer skapa upp. Dessa variabler kommer då referera till variables.tf och sedan namnet på variabeln som i sin tur kommer referera till terraform.tfvars.

I variables.tf kommer vi behöva skapa upp dessa variabler och det ser ut på följande sätt:

variable "azure_subscription_id" {
  type = "string"
}
variable "azure_client_id" {
  type = "string"
}
variable "azure_client_secret" {
  type = "string"
}
variable "azure_tenant_id" {
  type = "string"
}

Sedan i terraform.tfvars så kommer vi då sätta värdena för dessa variabler på följande sätt:

azure_subscription_id = "yyyyyyyy-xxxx-xxxx-xxxx-yyyyyyyyyyyy"
azure_client_id = "yyyyyyyy-xxxx-xxxx-xxxx-yyyyyyyyyyyy"
azure_client_secret = "yyyyyyyy-xxxx-xxxx-xxxx-yyyyyyyyyyyy"
azure_tenant_id = "yyyyyyyy-xxxx-xxxx-xxxx-yyyyyyyyyyyy"

Nu I main.tf så kommer vi definiera vilka resurser vi ska skapa upp och i detta exempel så kommer jag att skapa upp följande resurser med hjälp av Terraform:

  • azurerm_resource_group
  • azurerm_virtual_network
  • azurerm_subnet
  • azurerm_public_ip
  • azurerm_network_security_group
  • azurerm_network_interface
  • azurerm_virtual_machine

Resurserna är uppbyggda på följande sätt:

resource "azurerm_resource_group" "tfdemo" {
  name     = "tfdemo-rg"
  location = "West Europe"

  tags {
    environment = "Demo"
  }
}

Där resource väljer vilken resurs vi vill skapa upp och i detta fall är det en resursgrupp det som kommer efter det är det interna namnet som Terraform använder sig av när man refererar resurser till varandra så ifall jag kommer skapa upp alla resurser i samma region så behöver jag inte skriva ut ’West Europ’ på varje resurs utan jag kan referera till en tidigare resurs eller göra det med en variabel.

För att referera till en tidigare resurs så skriver man på följande sätt

location = "${azurerm_resource_group.tfdemo.location}"

 

Håller du in Ctrl och håller över en variabel så kan du se innehållet.

Efter vi har valt vårat interna namn så är det dags att konfigurera resursen vi vill skapa upp och i detta fall är det en resursgrupp så då kommer vi behöva ett namn och en region, vi kan även lägga till taggar

Vill du se vilka alternativ som finns för en specifik resurs så kan du hålla in Ctrl och klicka på resursnamnet (azurerm_resource_group) i Visual Studio Code, detta förutsätter att du har tillägget Terraform.

Vi kommer nu lägga på ett tillägg till den virtuella datorn för Powershell DSC och samtidigt ansluta den till Azure Automation för att automatiskt installera våra DSC script. För att göra detta behöver vi lägga till dessa variabler.

variable "azure_dsc_key" {
  type = "string"
}
variable "azure_dsc_endpoint" {
  type = "string"
}
variable "azure_dsc_config" {
  type = "string"
}
variable "azure_dsc_mode" {
  type = "string"
}

 

Och sedan fylla i informationen i terraform.tfvars

azure_dsc_config kan vara tom om man bara vill lägga till tillägget och ansluta noden till Azure Automation.

Sedan behöver vi även lägga in en resource i main.tf.

resource "azurerm_virtual_machine_extension" "tfdemo" {
  name                 = "tfdemoDSC"
  location             = "${azurerm_resource_group.tfdemo.location}"
  resource_group_name  = "${azurerm_resource_group.tfdemo.name}"
  virtual_machine_name = "${azurerm_virtual_machine.tfdemo.name}"
  publisher            = "Microsoft.Powershell"
  type                 = "DSC"
  type_handler_version = "2.76"
  depends_on           = ["azurerm_virtual_machine.tfdemo"]
  settings = <<SETTINGS
  {
    "WmfVersion": "latest",
    "ModulesUrl": "https://eus2oaasibizamarketprod1.blob.core.windows.net/automationdscpreview/RegistrationMetaConfigV2.zip",
    "ConfigurationFunction": "RegistrationMetaConfigV2.ps1\\RegistrationMetaConfigV2",
    "Privacy": {
      "DataCollection": ""
    },
      "Properties": {
        "RegistrationKey": {
          "UserName": "PLACEHOLDER_DONOTUSE",
          "Password": "PrivateSettingsRef:registrationKeyPrivate"
    },
      "RegistrationUrl": "${var.azure_dsc_endpoint}",
      "NodeConfigurationName": "${var.azure_dsc_config}",
      "ConfigurationMode": "${var.azure_dsc_mode}",
      "ConfigurationModeFrequencyMins": 15,
      "RefreshFrequencyMins": 30,
      "RebootNodeIfNeeded": false,
      "ActionAfterReboot": "continueConfiguration",
      "AllowModuleOverwrite": false
  }
}
SETTINGS
  protected_settings = <<PROTECTED_SETTINGS
  {
    "Items": {
      "registrationKeyPrivate" : "${var.azure_dsc_key}"
  }
}
  PROTECTED_SETTINGS
}

För att vi ska slippa logga in i Azure portalen för att få fram vårt IP till servern så kan vi lägga in detta så kommer vi få den informationen så fort deployen är klar.

output "IpAddress" {
  value = "${azurerm_public_ip.tfdemo.ip_address}"
}

För att få det fullständiga exemplet på att skapa upp allt som behövs för en Virtuell dator se bifogad fil och detta exempel finns i mappen Demo.

För att göra en skapa dessa resurser vi har definierat i main.tf så behöver vi nu använda oss av terraform.exe filen vi har på våran arbetsyta.

Det första vi behöver göra är att göra en terraform init vilket kommer ladda ner den  provider vi valt att använda och skapa upp och spara den i en mapp som heter .terraform i arbetsytan vi använder.

För att göra detta så använder vi oss av terraform init

Efter detta så använder vi terraform plan, där den validerar så att vi har definierat resurser som finns, om variabler vi använder innehåller någon information, vi kommer även få info om vad som skapas upp, ändras eller ska förstöras.

Efter vi har verifierat att det som skapas upp är korret så använder vi oss av terraform apply för att påbörja skapandet av resurserna och vi kommer att få verifiera igen och skriva ’yes’ ifall allt ser bra ut.

Efter detta så påbörjar den skapandet av resurserna genom att logga in med den Service Principal vi skapade upp tidigare.

Vill vi sedan ta bort alla resurser vi skapade upp använder vi oss av terraform destroy

I nästa bloggpost så kommer vi gå igenom Azure Automation DSC för att automatiskt konfigurera upp servern när den blivit skapad genom Terraform.

 

Här finns det lite demofiler att labba med: Demofiler



Inga kommentarer ännu.

Vad tycker du?

Kommentar: