Szybki start: tworzenie usługi Azure Firewall i grup adresów IP — Terraform

Artykuł
04/07/2024

W tym przewodniku Szybki start użyjesz narzędzia Terraform do wdrożenia usługi Azure Firewall z przykładowymi grupami adresów IP używanymi w regule sieciowej i regule aplikacji. Grupa adresów IP to zasób najwyższego poziomu, który umożliwia definiowanie i grupowanie adresów IP, zakresów i podsieci w pojedynczy obiekt. Grupa adresów IP jest przydatna do zarządzania adresami IP w regułach usługi Azure Firewall. Możesz ręcznie wprowadzić adresy IP lub zaimportować je z pliku.

Narzędzie Terraform umożliwia definiowanie, wyświetlanie wersji zapoznawczej i wdrażanie infrastruktury chmury. Za pomocą narzędzia Terraform tworzysz pliki konfiguracji przy użyciu składni HCL. Składnia listy HCL umożliwia określenie dostawcy chmury — takiego jak platforma Azure — oraz elementów tworzących infrastrukturę chmury. Po utworzeniu plików konfiguracji utworzysz plan wykonywania, który umożliwia wyświetlenie podglądu zmian infrastruktury przed ich wdrożeniem. Po zweryfikowaniu zmian należy zastosować plan wykonywania w celu wdrożenia infrastruktury.

W tym artykule omówiono sposób wykonywania następujących zadań:

Tworzenie wartości losowej (do użycia w nazwie grupy zasobów) przy użyciu random_pet
Tworzenie grupy zasobów platformy Azure przy użyciu azurerm_resource_group
Tworzenie losowego hasła dla maszyny wirtualnej z systemem Windows przy użyciu random_password
Utwórz losową wartość (do użycia jako nazwę magazynu) przy użyciu random_string
Tworzenie publicznego adresu IP platformy Azure przy użyciu azurerm_public_ip
Tworzenie konta magazynu przy użyciu azurerm_storage_account
Tworzenie zasad usługi Azure Firewall przy użyciu azurerm_firewall_policy
Tworzenie grupy kolekcji reguł zasad usługi Azure Firewall przy użyciu azurerm_firewall_policy_rule_collection_group
Tworzenie usługi Azure Firewall przy użyciu azurerm_firewall
Tworzenie grupy adresów IP platformy Azure przy użyciu azurerm_ip_group
Tworzenie sieci wirtualnej platformy Azure przy użyciu azurerm_virtual_network
Tworzenie trzech podsieci platformy Azure przy użyciu azurerm_subnet
Tworzenie interfejsu sieciowego przy użyciu azurerm_network_interface
Utwórz sieciową grupę zabezpieczeń (zawierającą listę reguł zabezpieczeń sieci) przy użyciu azurerm_network_security_group
Tworzenie skojarzenia między interfejsem sieciowym a sieciową grupą zabezpieczeń przy użyciu — azurerm_network_interface_security_group_association
Tworzenie maszyny wirtualnej z systemem Linux platformy Azure przy użyciu azurerm_linux_virtual_machine
Tworzenie tabeli tras przy użyciu azurerm_route_table
Tworzenie skojarzenia między tabelą tras a podsiecią przy użyciu — azurerm_subnet_route_table_association
Utwórz azapi_resource zasobu AzAPI.
Utwórz zasób AzAPI, aby wygenerować parę kluczy SSH przy użyciu azapi_resource_action.

Wymagania wstępne

Instalowanie i konfigurowanie narzędzia Terraform

Implementowanie kodu narzędzia Terraform

Uwaga

Przykładowy kod tego artykułu znajduje się w repozytorium GitHub programu Azure Terraform. Możesz wyświetlić plik dziennika zawierający wyniki testu z bieżących i poprzednich wersji programu Terraform.

Zobacz więcej artykułów i przykładowego kodu pokazującego, jak zarządzać zasobami platformy Azure za pomocą narzędzia Terraform

Utwórz katalog, w którym chcesz przetestować przykładowy kod narzędzia Terraform i ustawić go jako bieżący katalog.

Utwórz plik o nazwie providers.tf i wstaw następujący kod:

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
    azapi = {
      source  = "azure/azapi"
      version = "~>1.5"
    }
  }
}

provider "azurerm" {
  features {}
}

Utwórz plik o nazwie ssh.tf i wstaw następujący kod:

resource "random_pet" "ssh_key_name" {
  prefix    = "ssh"
  separator = ""
}

resource "azapi_resource_action" "ssh_public_key_gen" {
  type        = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  resource_id = azapi_resource.ssh_public_key.id
  action      = "generateKeyPair"
  method      = "POST"

  response_export_values = ["publicKey", "privateKey"]
}

resource "azapi_resource" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.ssh_key_name.id
  location  = azurerm_resource_group.rg.location
  parent_id = azurerm_resource_group.rg.id
}

output "key_data" {
  value = azapi_resource_action.ssh_public_key_gen.output.publicKey
}

Utwórz plik o nazwie main.tf i wstaw następujący kod:

resource "random_pet" "rg_name" {
  prefix = var.resource_group_name_prefix
}

resource "random_string" "storage_account_name" {
  length  = 8
  lower   = true
  numeric = false
  special = false
  upper   = false
}

resource "random_password" "password" {
  length      = 20
  min_lower   = 1
  min_upper   = 1
  min_numeric = 1
  min_special = 1
  special     = true
}

resource "azurerm_resource_group" "rg" {
  name     = random_pet.rg_name.id
  location = var.resource_group_location
}

resource "azurerm_public_ip" "pip_azfw" {
  name                = "pip-azfw"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  allocation_method   = "Static"
  sku                 = "Standard"
}

resource "azurerm_storage_account" "sa" {
  name                     = random_string.storage_account_name.result
  resource_group_name      = azurerm_resource_group.rg.name
  location                 = azurerm_resource_group.rg.location
  account_tier             = "Standard"
  account_replication_type = "LRS"
  account_kind             = "StorageV2"
}

resource "azurerm_firewall_policy" "azfw_policy" {
  name                     = "azfw-policy"
  resource_group_name      = azurerm_resource_group.rg.name
  location                 = azurerm_resource_group.rg.location
  sku                      = var.firewall_sku_tier
  threat_intelligence_mode = "Alert"
}

resource "azurerm_firewall_policy_rule_collection_group" "prcg" {
  name               = "prcg"
  firewall_policy_id = azurerm_firewall_policy.azfw_policy.id
  priority           = 300
  application_rule_collection {
    name     = "app-rule-collection-1"
    priority = 101
    action   = "Allow"
    rule {
      name = "someAppRule"
      protocols {
        type = "Https"
        port = 443
      }
      destination_fqdns = ["*bing.com"]
      source_ip_groups  = [azurerm_ip_group.ip_group_1.id]
    }
  }
  network_rule_collection {
    name     = "net-rule-collection-1"
    priority = 200
    action   = "Allow"
    rule {
      name                  = "someNetRule"
      protocols             = ["TCP", "UDP", "ICMP"]
      source_ip_groups      = [azurerm_ip_group.ip_group_1.id]
      destination_ip_groups = [azurerm_ip_group.ip_group_2.id]
      destination_ports     = ["90"]
    }
  }
}

resource "azurerm_firewall" "fw" {
  name                = "azfw"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  sku_name            = "AZFW_VNet"
  sku_tier            = var.firewall_sku_tier
  ip_configuration {
    name                 = "azfw-ipconfig"
    subnet_id            = azurerm_subnet.azfw_subnet.id
    public_ip_address_id = azurerm_public_ip.pip_azfw.id
  }
  firewall_policy_id = azurerm_firewall_policy.azfw_policy.id
}

resource "azurerm_ip_group" "ip_group_1" {
  name                = "ip-group_1"
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location
  cidrs               = ["13.73.64.64/26", "13.73.208.128/25", "52.126.194.0/23"]
}
resource "azurerm_ip_group" "ip_group_2" {
  name                = "ip_group_2"
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location
  cidrs               = ["12.0.0.0/24", "13.9.0.0/24"]
}

resource "azurerm_virtual_network" "azfw_vnet" {
  name                = "azfw-vnet"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  address_space       = ["10.10.0.0/16"]
}

resource "azurerm_subnet" "azfw_subnet" {
  name                 = "AzureFirewallSubnet"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.azfw_vnet.name
  address_prefixes     = ["10.10.0.0/26"]
}

resource "azurerm_subnet" "server_subnet" {
  name                 = "subnet-server"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.azfw_vnet.name
  address_prefixes     = ["10.10.1.0/24"]
}

resource "azurerm_subnet" "jump_subnet" {
  name                 = "subnet-jump"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.azfw_vnet.name
  address_prefixes     = ["10.10.2.0/24"]
}

resource "azurerm_public_ip" "vm_jump_pip" {
  name                = "pip-jump"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  allocation_method   = "Static"
  sku                 = "Standard"
}

resource "azurerm_network_interface" "vm_server_nic" {
  name                = "nic-server"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  ip_configuration {
    name                          = "ipconfig-workload"
    subnet_id                     = azurerm_subnet.server_subnet.id
    private_ip_address_allocation = "Dynamic"
  }
}

resource "azurerm_network_interface" "vm_jump_nic" {
  name                = "nic-jump"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  ip_configuration {
    name                          = "ipconfig-jump"
    subnet_id                     = azurerm_subnet.jump_subnet.id
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.vm_jump_pip.id
  }
}

resource "azurerm_network_security_group" "vm_server_nsg" {
  name                = "nsg-server"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
}

resource "azurerm_network_security_group" "vm_jump_nsg" {
  name                = "nsg-jump"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  security_rule {
    name                       = "Allow-SSH"
    priority                   = 1000
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "22"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }
}

resource "azurerm_network_interface_security_group_association" "vm_server_nsg_association" {
  network_interface_id      = azurerm_network_interface.vm_server_nic.id
  network_security_group_id = azurerm_network_security_group.vm_server_nsg.id
}

resource "azurerm_network_interface_security_group_association" "vm_jump_nsg_association" {
  network_interface_id      = azurerm_network_interface.vm_jump_nic.id
  network_security_group_id = azurerm_network_security_group.vm_jump_nsg.id
}

resource "azurerm_linux_virtual_machine" "vm_server" {
  name                = "server-vm"
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location
  size                = var.virtual_machine_size
  admin_username      = var.admin_username
  admin_ssh_key {
    username   = var.admin_username
    public_key = azapi_resource_action.ssh_public_key_gen.output.publicKey
  }
  network_interface_ids = [azurerm_network_interface.vm_server_nic.id]
  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }
  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }
  boot_diagnostics {
    storage_account_uri = azurerm_storage_account.sa.primary_blob_endpoint
  }
}

resource "azurerm_linux_virtual_machine" "vm_jump" {
  name                  = "jump-vm"
  resource_group_name   = azurerm_resource_group.rg.name
  location              = azurerm_resource_group.rg.location
  size                  = var.virtual_machine_size
  network_interface_ids = [azurerm_network_interface.vm_jump_nic.id]
  admin_username        = var.admin_username
  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }
  admin_ssh_key {
    username   = var.admin_username
    public_key = azapi_resource_action.ssh_public_key_gen.output.publicKey
  }
  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }
  boot_diagnostics {
    storage_account_uri = azurerm_storage_account.sa.primary_blob_endpoint
  }
  computer_name = "JumpBox"

}

resource "azurerm_route_table" "rt" {
  name                          = "rt-azfw-eus"
  location                      = azurerm_resource_group.rg.location
  resource_group_name           = azurerm_resource_group.rg.name
  disable_bgp_route_propagation = false
  route {
    name                   = "azfwDefaultRoute"
    address_prefix         = "0.0.0.0/0"
    next_hop_type          = "VirtualAppliance"
    next_hop_in_ip_address = azurerm_firewall.fw.ip_configuration[0].private_ip_address
  }
}

resource "azurerm_subnet_route_table_association" "server_subnet_rt_association" {
  subnet_id      = azurerm_subnet.server_subnet.id
  route_table_id = azurerm_route_table.rt.id
}

Utwórz plik o nazwie variables.tf i wstaw następujący kod:

variable "resource_group_location" {
  type        = string
  description = "Location for all resources."
  default     = "eastus"
}

variable "resource_group_name_prefix" {
  type        = string
  description = "Prefix for the Resource Group Name that's combined with a random id so name is unique in your Azure subcription."
  default     = "rg"
}

variable "firewall_sku_tier" {
  type        = string
  description = "Firewall SKU."
  default     = "Premium" # Valid values are Standard and Premium
  validation {
    condition     = contains(["Standard", "Premium"], var.firewall_sku_tier)
    error_message = "The SKU must be one of the following: Standard, Premium"
  }
}

variable "virtual_machine_size" {
  type        = string
  description = "Size of the virtual machine."
  default     = "Standard_D2_v3"
}

variable "admin_username" {
  type        = string
  description = "Value of the admin username."
  default     = "azureuser"
}

Utwórz plik o nazwie outputs.tf i wstaw następujący kod:

output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}

output "firewall_name" {
  value = azurerm_firewall.fw.name
}

Inicjowanie narzędzia Terraform

Uruchom narzędzie terraform init , aby zainicjować wdrożenie narzędzia Terraform. To polecenie pobiera dostawcę platformy Azure wymaganego do zarządzania zasobami platformy Azure.

terraform init -upgrade

Kluczowe punkty:

Parametr -upgrade uaktualnia niezbędne wtyczki dostawcy do najnowszej wersji, która jest zgodna z ograniczeniami wersji konfiguracji.

Tworzenie planu wykonania programu Terraform

Uruchom plan terraform, aby utworzyć plan wykonania.

terraform plan -out main.tfplan

Kluczowe punkty:

Polecenie terraform plan tworzy plan wykonania, ale nie wykonuje go. Zamiast tego określa, jakie akcje są niezbędne do utworzenia konfiguracji określonej w plikach konfiguracji. Ten wzorzec umożliwia sprawdzenie, czy plan wykonania jest zgodny z oczekiwaniami przed wprowadzeniem jakichkolwiek zmian w rzeczywistych zasobach.
Opcjonalny -out parametr umożliwia określenie pliku wyjściowego dla planu. Użycie parametru -out gwarantuje, że sprawdzony plan jest dokładnie tym, co jest stosowane.

Stosowanie planu wykonywania narzędzia Terraform

Uruchom narzędzie terraform, aby zastosować plan wykonania do infrastruktury chmury.

terraform apply main.tfplan

Kluczowe punkty:

Przykładowe terraform apply polecenie zakłada, że wcześniej uruchomiono terraform plan -out main.tfplanpolecenie .
Jeśli określono inną nazwę pliku parametru -out , użyj tej samej nazwy pliku w wywołaniu metody terraform apply.
Jeśli parametr nie został użyty, wywołaj metodę -out terraform apply bez żadnych parametrów.

Weryfikowanie wyników

Interfejs wiersza polecenia platformy Azure

Pobierz nazwę grupy zasobów platformy Azure.

resource_group_name=$(terraform output -raw resource_group_name)

Uruchom polecenie az network ip-group list , aby wyświetlić dwie nowe grupy adresów IP.
```
az network ip-group list --resource-group $resource_group_name
```

Czyszczenie zasobów

Jeśli zasoby utworzone za pomocą narzędzia Terraform nie są już potrzebne, wykonaj następujące czynności:

Uruchom plan terraform i określ flagę destroy .
```
terraform plan -destroy -out main.destroy.tfplan
```
Kluczowe punkty:
- Polecenie terraform plan tworzy plan wykonania, ale nie wykonuje go. Zamiast tego określa, jakie akcje są niezbędne do utworzenia konfiguracji określonej w plikach konfiguracji. Ten wzorzec umożliwia sprawdzenie, czy plan wykonania jest zgodny z oczekiwaniami przed wprowadzeniem jakichkolwiek zmian w rzeczywistych zasobach.
- Opcjonalny -out parametr umożliwia określenie pliku wyjściowego dla planu. Użycie parametru -out gwarantuje, że sprawdzony plan jest dokładnie tym, co jest stosowane.
Uruchom narzędzie terraform zastosuj, aby zastosować plan wykonania.
```
terraform apply main.destroy.tfplan
```

Rozwiązywanie problemów z programem Terraform na platformie Azure

Rozwiązywanie typowych problemów podczas korzystania z narzędzia Terraform na platformie Azure

Następne kroki

Samouczek: wdrażanie i konfigurowanie usługi Azure Firewall w sieci hybrydowej przy użyciu witryny Azure Portal

Udostępnij za pośrednictwem

Szybki start: tworzenie usługi Azure Firewall i grup adresów IP — Terraform

Wymagania wstępne

Implementowanie kodu narzędzia Terraform

Inicjowanie narzędzia Terraform

Tworzenie planu wykonania programu Terraform

Stosowanie planu wykonywania narzędzia Terraform

Weryfikowanie wyników

Czyszczenie zasobów

Rozwiązywanie problemów z programem Terraform na platformie Azure

Następne kroki

Opinia

Dodatkowe zasoby