Szybki start: tworzenie usługi Azure Firewall z wieloma publicznymi adresami IP — Terraform

W tym szybkim poradniku użyjesz narzędzia Terraform do wdrożenia Azure Firewall z wieloma publicznymi adresami IP, korzystając z prefiksu publicznego adresu IP. Zainstalowana zapora ma zestaw reguł NAT, które umożliwiają połączenia RDP do dwóch maszyn wirtualnych z systemem Windows Server 2019.

Terraform umożliwia definiowanie, podgląd i wdrażanie infrastruktury chmurowej. Za pomocą narzędzia Terraform tworzysz pliki konfiguracji używając 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 należy utworzyć 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.

Aby uzyskać więcej informacji na temat usługi Azure Firewall z wieloma publicznymi adresami IP, zobacz Wdrażanie usługi Azure Firewall z wieloma publicznymi adresami IP przy użyciu programu Azure PowerShell.

Z tego artykułu dowiesz się, jak wykonywać następujące działania:

Tworzenie wartości losowej (do użycia w nazwie grupy zasobów) przy użyciu random_pet

Tworzenie losowego hasła dla maszyny wirtualnej z systemem Windows przy użyciu random_password

Tworzenie grupy zasobów platformy Azure przy użyciu azurerm_resource_group

Tworzenie prefiksu publicznego adresu IP platformy Azure przy użyciu azurerm_public_ip_prefix

Tworzenie publicznego adresu IP platformy Azure przy użyciu azurerm_public_ip

Tworzenie sieci wirtualnej platformy Azure przy użyciu azurerm_virtual_network

Tworzenie 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 Windows przy użyciu azurerm_windows_virtual_machine

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 tabeli tras przy użyciu azurerm_route_table

Tworzenie skojarzenia między tabelą tras a podsiecią przy użyciu — azurerm_subnet_route_table_association

Wymagania wstępne

Instalowanie i konfigurowanie programu Terraform

Implementowanie kodu narzędzia Terraform

Uwaga

Przykładowy kod tego artykułu znajduje się w repozytorium Azure Terraform GitHub. 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"
    }
  }
}

provider "azurerm" {
  features {
    virtual_machine {
      delete_os_disk_on_deletion     = true
      skip_shutdown_and_force_delete = true
    }
  }
}

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_password" "password" {
  count       = 2
  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_prefix" "pip_prefix" {
  name                = "pip-prefix"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  sku                 = "Standard"
  prefix_length       = 31
}

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

resource "azurerm_public_ip" "pip_azfw_2" {
  name                = "pip-azfw-1"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  sku                 = "Standard"
  allocation_method   = "Static"
  public_ip_prefix_id = azurerm_public_ip_prefix.pip_prefix.id
}

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" "backend_subnet" {
  name                 = "subnet-backend"
  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_network_interface" "backend_nic" {
  count               = 2
  name                = "nic-backend-${count.index + 1}"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  ip_configuration {
    name                          = "ipconfig-backend-${count.index + 1}"
    subnet_id                     = azurerm_subnet.backend_subnet.id
    private_ip_address_allocation = "Dynamic"
  }
}

resource "azurerm_network_security_group" "backend_nsg" {
  name                = "nsg-backend"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  security_rule {
    name                       = "RDP"
    priority                   = 300
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "3389"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }
}

resource "azurerm_network_interface_security_group_association" "vm_backend_nsg_association" {
  count                     = 2
  network_interface_id      = azurerm_network_interface.backend_nic[count.index].id
  network_security_group_id = azurerm_network_security_group.backend_nsg.id
}

resource "azurerm_windows_virtual_machine" "vm_backend" {
  count                 = 2
  name                  = "vm-backend-${count.index + 1}"
  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_password        = random_password.password[count.index].result
  network_interface_ids = [azurerm_network_interface.backend_nic[count.index].id]
  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }
  source_image_reference {
    publisher = "MicrosoftWindowsServer"
    offer     = "WindowsServer"
    sku       = "2019-Datacenter"
    version   = "latest"
  }
}

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" "policy_rule_collection_group" {
  name               = "RuleCollectionGroup"
  firewall_policy_id = azurerm_firewall_policy.azfw_policy.id
  priority           = 300
  application_rule_collection {
    name     = "web"
    priority = 100
    action   = "Allow"
    rule {
      name = "wan-address"
      protocols {
        type = "Http"
        port = 80
      }
      protocols {
        type = "Https"
        port = 443
      }
      destination_fqdns = ["getmywanip.com"]
      source_addresses  = ["*"]
    }
    rule {
      name = "google"
      protocols {
        type = "Http"
        port = 80
      }
      protocols {
        type = "Https"
        port = 443
      }
      destination_fqdns = ["www.google.com"]
      source_addresses  = ["10.10.1.0/24"]
    }
    rule {
      name = "wupdate"
      protocols {
        type = "Http"
        port = 80
      }
      protocols {
        type = "Https"
        port = 443
      }
      destination_fqdn_tags = ["WindowsUpdate"]
      source_addresses      = ["*"]
    }
  }
  nat_rule_collection {
    name     = "Coll-01"
    action   = "Dnat"
    priority = 200
    rule {
      name                = "rdp-01"
      protocols           = ["TCP"]
      translated_address  = "10.10.1.4"
      translated_port     = "3389"
      source_addresses    = ["*"]
      destination_address = azurerm_public_ip.pip_azfw.ip_address
      destination_ports   = ["3389"]
    }
    rule {
      name                = "rdp-02"
      protocols           = ["TCP"]
      translated_address  = "10.10.1.5"
      translated_port     = "3389"
      source_addresses    = ["*"]
      destination_address = azurerm_public_ip.pip_azfw.ip_address
      destination_ports   = ["3389"]
    }
  }
}

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
  }
  ip_configuration {
    name                 = "azfw-ipconfig-2"
    public_ip_address_id = azurerm_public_ip.pip_azfw_2.id
  }
  firewall_policy_id = azurerm_firewall_policy.azfw_policy.id
}

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                   = "azfw"
    address_prefix         = "0.0.0.0/0"
    next_hop_type          = "VirtualAppliance"
    next_hop_in_ip_address = "10.10.0.4"
  }
}

resource "azurerm_subnet_route_table_association" "jump_subnet_rt_association" {
  subnet_id      = azurerm_subnet.backend_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 "backend_admin_password" {
  sensitive = true
  value     = azurerm_windows_virtual_machine.vm_backend[*].admin_password
}

Inicjowanie narzędzia Terraform

Uruchom terraform init, aby zainicjować wdrożenie Terraform. Polecenie to pobiera dostawcę Azure wymaganego do zarządzania zasobami Azure.

terraform init -upgrade

Kluczowe punkty:

Parametr -upgrade uaktualnia niezbędne wtyczki dostawcy do najnowszej wersji zgodnej z ograniczeniami wersji konfiguracji.

Tworzenie planu wykonywania narzędzia Terraform

Uruchom terraform plan, aby utworzyć plan wykonania.

terraform plan -out main.tfplan

Kluczowe punkty:

Polecenie terraform plan tworzy plan wykonania, ale go nie wykonuje. 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 parametr -out umożliwia określenie pliku wyjściowego dla planu. Użycie parametru -out gwarantuje, że sprawdzony plan jest dokładnie tym, co jest stosowane.

Zastosowanie planu wykonawczego Terraform

Uruchom terraform apply, w celu zastosowania planu wykonania do infrastruktury chmurowej.

terraform apply main.tfplan

Kluczowe punkty:

Polecenie terraform apply w przykładzie zakłada, że wcześniej uruchomiono terraform plan -out main.tfplan.
Jeśli określono inną nazwę pliku dla parametru -out, użyj tej samej nazwy pliku w wywołaniu terraform apply.
Jeśli nie użyto parametru -out, wywołaj 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 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 terraform plan i określ flagę destroy.
```
terraform plan -destroy -out main.destroy.tfplan
```
Kluczowe punkty:
- Polecenie terraform plan tworzy plan wykonania, ale go nie wykonuje. 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 parametr -out 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 terraform apply, aby wdrożyć 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

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-04-02

Udostępnij za pomocą

Szybki start: tworzenie usługi Azure Firewall z wieloma publicznymi adresami IP — Terraform

Wymagania wstępne

Implementowanie kodu narzędzia Terraform

Inicjowanie narzędzia Terraform

Tworzenie planu wykonywania narzędzia Terraform

Zastosowanie planu wykonawczego Terraform

Weryfikowanie wyników

Czyszczenie zasobów

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

Następne kroki

Sprzężenie zwrotne

Dodatkowe zasoby