Schnellstart: Bereitstellen von Azure Firewall mit Verfügbarkeitszonen - Terraform

In dieser Schnellstartanleitung verwenden Sie Terraform, um eine Azure Firewall in drei Verfügbarkeitszonen bereitzustellen.

Terraform ermöglicht die Definition, Vorschau und Bereitstellung der Cloudinfrastruktur. Terraform ermöglicht das Erstellen von Konfigurationsdateien mit HCL-Syntax. Mit der HCL-Syntax können Sie den Cloudanbieter ( z. B. Azure ) und die Elemente angeben, aus denen Ihre Cloudinfrastruktur besteht. Nach der Erstellung Ihrer Konfigurationsdateien erstellen Sie einen Ausführungsplan, mit dem Sie eine Vorschau Ihrer Infrastrukturänderungen anzeigen können, bevor diese bereitgestellt werden. Nachdem Sie die Änderungen überprüft haben, wenden Sie den Ausführungsplan an, um die Infrastruktur bereitzustellen.

Mit der Terraform-Konfiguration wird eine Testnetzwerkumgebung mit einer Firewall erstellt. Das Netzwerk verfügt über ein virtuelles Netzwerk (VNet) mit drei Subnetzen: AzureFirewallSubnet, subnet-server und subnet-jump. Das Subnetz subnet-server und das subnet-jump-Subnetz verfügen jeweils über einen einzelnen virtuellen Windows Server-Computer mit zwei Kernen.

Die Firewall befindet sich im Subnetz AzureFirewallSubnet und verfügt über eine Anwendungsregelsammlung mit einer einzelnen Regel, die den Zugriff auf www.microsoft.com.

Eine benutzerdefinierte Route leitet den Netzwerkdatenverkehr aus dem Subnetz-Server-Subnetz durch die Firewall weiter, auf die die Firewallregeln angewendet werden.

Weitere Informationen zu Azure Firewall finden Sie unter Bereitstellen und Konfigurieren von Azure Firewall über das Azure-Portal.

In diesem Artikel erfahren Sie, wie Sie:

Erstellen eines zufälligen Werts (der im Ressourcengruppennamen verwendet wird) mithilfe von random_pet
Erstellen einer Azure-Ressourcengruppe mithilfe von azurerm_resource_group
Erstellen eines virtuellen Azure-Netzwerks mithilfe von azurerm_virtual_network
Erstellen von drei Azure-Subnetzen mit azurerm_subnet
Erstellen einer öffentlichen Azure-IP-Adresse mit azurerm_public_ip
Erstellen einer Azure-Firewallrichtlinie mithilfe von azurerm_firewall_policy
Erstellen einer Azure Firewall Policy Rule Collection Group mithilfe von azurerm_firewall_policy_rule_collection_group
Erstellen einer Azure-Firewall mit azurerm_firewall
Erstellen einer Netzwerkschnittstelle mithilfe von azurerm_network_interface
Erstellen einer Netzwerksicherheitsgruppe (zur Aufnahme einer Liste von Netzwerksicherheitsregeln) mithilfe von azurerm_network_security_group
Stellen Sie eine Zuordnung zwischen der Netzwerkschnittstelle und der Netzwerksicherheitsgruppe mithilfe von azurerm_network_interface_security_group_association her.
Erstellen einer Routentabelle mithilfe von azurerm_route_table
Erstellen einer Zuordnung zwischen der Routentabelle und dem Subnetz mithilfe von - azurerm_subnet_route_table_association
Erstellen eines zufälligen Werts (der als Speichername verwendet werden soll) mithilfe von random_string
Erstellen eines Speicherkontos mithilfe von azurerm_storage_account
Erstellen eines zufälligen Kennworts für die Windows-VM mit random_password
Erstellen eines virtuellen Azure Windows-Computers mit azurerm_windows_virtual_machine

Voraussetzungen

Installieren und Konfigurieren von Terraform

Implementieren des Terraform-Codes

Hinweis

Der Beispielcode für diesen Artikel befindet sich im Azure Terraform GitHub-Repository. Sie können die Protokolldatei anzeigen, die die Testergebnisse aus den aktuellen und früheren Versionen von Terraform enthält.

Sehen Sie sich mehr Artikel und Beispielcode an, die zeigen, wie man Terraform zur Verwaltung von Azure-Ressourcen verwendet

Erstellen Sie ein Verzeichnis, in dem der Terraform-Beispielcode getestet werden soll, und legen Sie es als aktuelles Verzeichnis fest.

Erstellen Sie eine Datei namens providers.tf, und fügen Sie den folgenden Code ein:

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

provider "azurerm" {
  features {}
}

Erstellen Sie eine Datei namens main.tf, und fügen Sie den folgenden Code ein:

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"
  zones               = ["1", "2", "3"]
}

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_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-TCP"
    priority                   = 1000
    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_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_windows_virtual_machine" "vm_server" {
  name                  = "server-vm"
  resource_group_name   = azurerm_resource_group.rg.name
  location              = azurerm_resource_group.rg.location
  computer_name         = "server"
  size                  = var.virtual_machine_size
  admin_username        = var.admin_username
  admin_password        = random_password.password.result
  network_interface_ids = [azurerm_network_interface.vm_server_nic.id]
  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
    disk_size_gb         = "128"
  }
  source_image_reference {
    publisher = "MicrosoftWindowsServer"
    offer     = "WindowsServer"
    sku       = "2019-Datacenter"
    version   = "latest"
  }
  boot_diagnostics {
    storage_account_uri = azurerm_storage_account.sa.primary_blob_endpoint
  }
}

resource "azurerm_windows_virtual_machine" "vm_jump" {
  name                  = "jump-vm"
  resource_group_name   = azurerm_resource_group.rg.name
  location              = azurerm_resource_group.rg.location
  computer_name         = "jumpbox"
  size                  = var.virtual_machine_size
  admin_username        = var.admin_username
  admin_password        = random_password.password.result
  network_interface_ids = [azurerm_network_interface.vm_jump_nic.id]
  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
    disk_size_gb         = "128"
  }
  source_image_reference {
    publisher = "MicrosoftWindowsServer"
    offer     = "WindowsServer"
    sku       = "2019-Datacenter"
    version   = "latest"
  }
  boot_diagnostics {
    storage_account_uri = azurerm_storage_account.sa.primary_blob_endpoint
  }
}

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     = "appRc1"
    priority = 101
    action   = "Allow"
    rule {
      name = "appRule1"
      protocols {
        type = "Http"
        port = 80
      }
      protocols {
        type = "Https"
        port = 443
      }
      destination_fqdns = ["www.microsoft.com"]
      source_addresses  = ["10.10.1.0/24"]
    }
  }
  network_rule_collection {
    name     = "netRc1"
    priority = 200
    action   = "Allow"
    rule {
      name                  = "netRule1"
      protocols             = ["TCP"]
      source_addresses      = ["10.10.1.0/24"]
      destination_addresses = ["*"]
      destination_ports     = ["8000", "8999"]
    }
  }
}

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
  zones               = ["1", "2", "3"]
  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_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" "jump_subnet_rt_association" {
  subnet_id      = azurerm_subnet.server_subnet.id
  route_table_id = azurerm_route_table.rt.id
}

Erstellen Sie eine Datei namens variables.tf, und fügen Sie den folgenden Code ein:

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"
}

Erstellen Sie eine Datei namens outputs.tf, und fügen Sie den folgenden Code ein:

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

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

Initialisieren Sie Terraform

Führen Sie terraform init aus, um die Terraform-Bereitstellung zu initialisieren. Dieser Befehl lädt den Azure-Anbieter herunter, der zum Verwalten Ihrer Azure-Ressourcen erforderlich ist.

terraform init -upgrade

Die wichtigsten Punkte:

Der Parameter -upgrade aktualisiert die erforderlichen Anbieter-Plug-Ins auf die neueste Version, die den Versionseinschränkungen der Konfiguration entspricht.

Erstellen eines Terraform-Ausführungsplans

Führen Sie terraform plan aus, um einen Ausführungsplan zu erstellen.

terraform plan -out main.tfplan

Die wichtigsten Punkte:

Der Befehl terraform plan erstellt einen Ausführungsplan, führt ihn aber nicht aus. Stattdessen wird bestimmt, welche Aktionen erforderlich sind, um die in Ihren Konfigurationsdateien angegebene Konfiguration zu erstellen. Mit diesem Muster können Sie überprüfen, ob der Ausführungsplan Ihren Erwartungen entspricht, bevor Sie Änderungen an tatsächlichen Ressourcen vornehmen.
Mit dem optionalen -out-Parameter können Sie eine Ausgabedatei für den Plan angeben. Durch die Verwendung des Parameters -out wird sichergestellt, dass genau der von Ihnen überprüfte Plan angewendet wird.

Anwenden eines Terraform-Ausführungsplans

Führen Sie terraform apply aus, um den Ausführungsplan auf Ihre Cloudinfrastruktur anzuwenden.

terraform apply main.tfplan

Die wichtigsten Punkte:

Der Beispielbefehl terraform apply setzt voraus, dass Sie zuvor terraform plan -out main.tfplan ausgeführt haben.
Wenn Sie einen anderen Dateinamen für den Parameter -out angegeben haben, verwenden Sie denselben Dateinamen im Aufruf von terraform apply.
Wenn Sie den Parameter -out nicht verwendet haben, rufen Sie terraform apply ohne Parameter auf.

Überprüfen der Ergebnisse

Azure CLI

Rufen Sie den Namen der Azure-Ressourcengruppe ab.

resource_group_name=$(terraform output -raw resource_group_name)

Rufen Sie den Namen der Firewall ab.

firewall_name=$(terraform output -raw firewall_name)

Führen Sie az network firewall show mit einer JMESPath-Abfrage aus, um die Verfügbarkeitszonen für die Firewall anzuzeigen.
```
az network firewall show --name $firewall_name --resource-group $resource_group_name --query "{Zones:zones"}
```

Bereinigen von Ressourcen

Wenn Sie die über Terraform erstellten Ressourcen nicht mehr benötigen, führen Sie die folgenden Schritte aus:

Führen Sie terraform plan aus, und geben Sie das Flag destroy an.
```
terraform plan -destroy -out main.destroy.tfplan
```
Die wichtigsten Punkte:
- Der Befehl terraform plan erstellt einen Ausführungsplan, führt ihn aber nicht aus. Stattdessen wird bestimmt, welche Aktionen erforderlich sind, um die in Ihren Konfigurationsdateien angegebene Konfiguration zu erstellen. Mit diesem Muster können Sie überprüfen, ob der Ausführungsplan Ihren Erwartungen entspricht, bevor Sie Änderungen an tatsächlichen Ressourcen vornehmen.
- Mit dem optionalen -out-Parameter können Sie eine Ausgabedatei für den Plan angeben. Durch die Verwendung des Parameters -out wird sichergestellt, dass genau der von Ihnen überprüfte Plan angewendet wird.
Führen Sie den Befehl terraform apply aus, um den Ausführungsplan anzuwenden.
```
terraform apply main.destroy.tfplan
```

Problembehandlung von Terraform auf Azure

Behebung häufiger Probleme bei der Verwendung von Terraform in Azure

Nächste Schritte

Als Nächstes können Sie die Azure Firewall-Protokolle überwachen.

Tutorial: Überwachen von Azure Firewall-Protokollen

Feedback

War diese Seite hilfreich?

Last updated on 2025-06-23

Freigeben über

Schnellstart: Bereitstellen von Azure Firewall mit Verfügbarkeitszonen - Terraform

Voraussetzungen

Implementieren des Terraform-Codes

Initialisieren Sie Terraform

Erstellen eines Terraform-Ausführungsplans

Anwenden eines Terraform-Ausführungsplans

Überprüfen der Ergebnisse

Bereinigen von Ressourcen

Problembehandlung von Terraform auf Azure

Nächste Schritte

Feedback

Zusätzliche Ressourcen