In dieser Schnellstartanleitung erfahren Sie, wie Sie ein NAT-Gateway mithilfe des Azure-Portals, azure CLI, PowerShell, Bicep, ARM-Vorlage und Terraform erstellen. Der NAT-Gatewaydienst bietet ausgehende Konnektivität für virtuelle Computer in Azure.
Erstellen eines NAT-Gateways
Wenn Sie die NAT-Gatewayressource und die anderen Ressourcen bereitstellen möchten, ist eine Ressourcengruppe erforderlich, die die bereitgestellten Ressourcen enthält. In den folgenden Schritten erstellen Sie eine Ressourcengruppe, eine NAT-Gatewayressource und eine öffentliche IP-Adresse. Sie können mehrere öffentliche IP-Adressressourcen und/oder Präfixes für öffentliche IP-Adressen verwenden.
Informationen zu öffentlichen IP-Präfixen und einem NAT-Gateway finden Sie unter Verwalten des NAT-Gateways.
Geben Sie am oberen Rand des Portals den Suchbegriff NAT-Gateway in das Suchfeld ein. Wählen Sie in den Suchergebnissen NAT-Gateways aus.
Wählen Sie + Erstellen aus.
Geben Sie auf der Registerkarte Grundlagen unter Gateway für die Netzwerkadressübersetzung (NAT) erstellen die folgenden Informationen ein, oder wählen Sie sie aus:
|
Einstellung |
Wert |
|
Projektdetails |
|
| Abonnement |
Wählen Sie Ihr Azure-Abonnement. |
| Ressourcengruppe |
Wählen Sie "Neu erstellen" aus.
Geben Sie test-rg ein.
Wählen Sie OK aus. |
|
Instanzdetails |
|
| Name des NAT-Gateways |
Geben Sie nat-gateway ein. |
| Region |
Wählen Sie USA, Osten 2 aus. |
| Verfügbarkeitszone |
Wählen Sie Keine Zone aus. |
| TCP-Leerlauftimeout (Minuten) |
Übernehmen Sie den Standardwert 4. |
Weitere Informationen zu Verfügbarkeitszonen und NAT-Gateways finden Sie unter NAT-Gateway und Verfügbarkeitszonen.
Wählen Sie die Registerkarte Ausgehende IP-Adresse oder unten auf der Seite die Schaltfläche Weiter: Ausgehende IP-Adresse aus.
Geben Sie auf der Registerkarte Ausgehende IP-Adresse die folgenden Informationen ein, bzw. wählen Sie sie aus:
|
Einstellung |
Wert |
| Öffentliche IP-Adressen |
Wählen Sie Neue öffentliche IP-Adresse erstellen aus.
Geben Sie für Namepublic-ip-nat ein.
Wählen Sie OK aus. |
Wählen Sie die Registerkarte Überprüfen + erstellen oder unten auf der Seite die blaue Schaltfläche Überprüfen + erstellen aus.
Wählen Sie "Erstellen" aus.
Erstellen eines virtuellen Netzwerks und eines Bastion-Hosts
Mit der folgenden Prozedur wird ein virtuelles Netzwerk mit einem Ressourcensubnetz, einem Azure Bastion-Subnetz und einem Azure Bastionhost erstellt.
Suchen Sie im Portal nach der Option Virtuelle Netzwerke und wählen Sie sie aus.
Wählen Sie auf der Seite Virtuelle Netzwerke die Option + Erstellen aus.
Geben Sie unter Virtuelles Netzwerk erstellen auf der Registerkarte Grundlagen die folgenden Informationen ein, oder wählen Sie sie aus:
| Konfiguration |
Wert |
|
Projektdetails |
|
| Abonnement |
Wählen Sie Ihr Abonnement aus. |
| Ressourcengruppe |
Wählen Sie test-rg aus. |
|
Instanzdetails |
|
| Name |
Geben Sie vnet-1 ein. |
| Region |
Wählen Sie (USA) USA, Osten 2 aus. |
Wählen Sie Weiter aus, um zur Registerkarte Sicherheit zu gelangen.
Wählen Sie auf der Registerkarte Sicherheit im Abschnitt Azure Bastion die Option Azure Bastion aktivieren aus.
Azure Bastion verwendet Ihren Browser, um mithilfe ihrer privaten IP-Adressen eine Verbindung mit VMs in Ihrem virtuellen Netzwerk über Secure Shell (SSH) oder das Remotedesktopprotokoll (RDP) herzustellen. Die VMs benötigen keine öffentlichen IP-Adressen, keine Clientsoftware und keine spezielle Konfiguration. Weitere Informationen zu Azure Bastion finden Sie unter Azure Bastion.
Hinweis
Die Stundenpreise gelten ab dem Zeitpunkt der Bereitstellung von Bastion, unabhängig von der Nutzung ausgehender Daten. Weitere Informationen dazu finden Sie unter Preise und SKUs. Wenn Sie Bastion als Teil eines Tutorials oder Tests einsetzen, empfehlen wir Ihnen, diese Ressource zu löschen, nachdem Sie diese benutzt haben.
Geben Sie in Azure Bastion die folgenden Informationen ein, oder wählen Sie sie aus:
| Konfiguration |
Wert |
| Azure Bastion-Hostname |
Geben Sie bastion ein. |
| Öffentliche Azure Bastion-IP-Adresse |
Wählen Sie Öffentliche IP-Adresse erstellen aus.
Geben Sie public-ip-bastion als Namen ein.
Wählen Sie OK aus. |
Wählen Sie Weiter aus, um zur Registerkarte IP-Adressen zu gelangen.
Wählen Sie im Feld für den Adressraum unter Subnetze das Standardsubnetz aus.
Geben Sie unter Subnetz bearbeiten die folgenden Informationen ein, oder wählen Sie sie aus:
| Konfiguration |
Wert |
| Subnetzzweck |
Übernehmen Sie den Standardwert: Standard. |
| Name |
Geben Sie subnet-1 ein. |
|
IPv4 |
|
| IPv4-Adressbereich |
Belassen Sie die Standardeinstellung 10.0.0.0/16. |
| Startadresse |
Lassen Sie den Standardwert 10.0.0.0. |
| Größe |
Übernehmen Sie den Standardwert /24 (256 Adressen). |
|
Sicherheit |
|
| NAT Gateway |
Wählen Sie nat-gateway aus. |
Wählen Sie Speichern aus.
Wählen Sie am unteren Bildschirmrand Überprüfen + erstellen aus, und wenn die Validierung erfolgreich ist, wählen Sie Erstellen aus.
Erstellen eines virtuellen Testcomputers
Mit dem folgenden Verfahren wird im virtuellen Netzwerk eine Test-VM mit dem Namen vm-1 erstellt.
Suchen Sie im Portal nach Virtuelle Computer, und klicken Sie darauf.
Wählen Sie unter VM die Option + Erstellen und dann Azure-VM aus.
Geben Sie unter Virtuellen Computer erstellen auf der Registerkarte Grundlagen die folgenden Informationen ein, oder wählen Sie sie aus:
| Konfiguration |
Wert |
|
Projektdetails |
|
| Abonnement |
Wählen Sie Ihr Abonnement aus. |
| Ressourcengruppe |
Wählen Sie test-rg aus. |
|
Instanzdetails |
|
| Name des virtuellen Computers |
Geben Sie vm-1 ein. |
| Region |
Wählen Sie USA, Osten 2 aus. |
| Verfügbarkeitsoptionen |
Wählen Sie die Option Keine Infrastrukturredundanz erforderlich aus. |
| Sicherheitstyp |
Lassen Sie die Voreinstellung auf Standard. |
| Abbildung |
Wählen Sie Ubuntu Server 22.04 LTS – x64 Gen2 aus. |
| VM-Architektur |
Lassen Sie den Standardwert x64. |
| Größe |
Wählen Sie eine Größe aus. |
|
Administratorkonto |
|
| Authentifizierungsart |
Wählen Sie Kennwort aus. |
| Nutzername |
Geben Sie azureuser ein. |
| Passwort |
Geben Sie ein Kennwort ein. |
| Kennwort bestätigen |
Geben Sie das Kennwort erneut ein. |
|
Regeln für eingehende Ports |
|
| Öffentliche Eingangsports |
Wählen Sie Keine aus. |
Wählen Sie oben auf der Seite die Registerkarte Netzwerk aus.
Geben Sie auf der Registerkarte Netzwerk die folgenden Informationen ein, bzw. wählen Sie sie aus:
| Konfiguration |
Wert |
|
Netzwerkschnittstelle |
|
| Virtuelles Netzwerk |
Wählen Sie vnet-1 aus. |
| Subnetz |
Wählen Sie Subnetz-1 (10.0.0.0/24) aus. |
| Öffentliche IP-Adresse |
Wählen Sie Keine aus. |
| NIC-Netzwerksicherheitsgruppe |
Wählen Sie "Erweitert" aus. |
| Konfigurieren von Netzwerksicherheitsgruppen |
Wählen Sie "Neu erstellen" aus.
Geben Sie nsg-1 für Name ein.
Behalten Sie für den Rest die Standards bei, und wählen Sie OK aus. |
Behalten Sie für die restlichen Einstellungen die Standards bei, und wählen Sie dann Überprüfen + erstellen aus.
Überprüfen Sie die Einstellungen, und wählen Sie Erstellen aus.
Hinweis
VMs in einem virtuellen Netzwerk mit einem Bastionhost benötigen keine öffentlichen IP-Adressen. Bastion stellt die öffentliche IP-Adresse bereit und die VMs verwenden private IP-Adressen für die Kommunikation innerhalb des Netzwerks. Sie können die öffentlichen IP-Adressen von allen VMs in von Bastion gehosteten virtuellen Netzwerken entfernen. Weitere Informationen finden Sie unter Trennen einer öffentlichen IP-Adresse von einer Azure-VM.
Hinweis
Azure stellt eine ausgehende Standardzugriffs-IP für VMs bereit, denen keine öffentliche IP-Adresse zugewiesen ist oder die sich im Backendpool eines internen grundlegenden Azure-Lastenausgleichs befinden. Der Mechanismus für Standard-IP-Adressen für den ausgehenden Zugriff stellt eine ausgehende IP-Adresse bereit, die nicht konfigurierbar ist.
Die Standard-IP-Adresse für ausgehenden Zugriff ist deaktiviert, wenn eines der folgenden Ereignisse auftritt:
- Dem virtuellen Computer wird eine öffentliche IP-Adresse zugewiesen.
- Die VM wird im Backend-Pool eines Standard-Load-Balancers platziert, mit oder ohne ausgehende Regeln.
- Dem Subnetz der VM wird eine Azure NAT Gateway-Ressource zugewiesen.
VMs, die Sie mithilfe von VM-Skalierungsgruppen im Orchestrierungsmodus „Flexibel“ erstellen, haben keinen ausgehenden Standardzugriff.
Weitere Informationen zu ausgehenden Verbindungen in Azure finden Sie unter Standardzugriff in ausgehender Richtung in Azure und Verwenden von SNAT (Source Network Address Translation) für ausgehende Verbindungen.
Erstellen einer Ressourcengruppe
Erstellen Sie mit New-AzResourceGroup eine Ressourcengruppe. Eine Azure-Ressourcengruppe ist ein logischer Container, in dem Azure-Ressourcen bereitgestellt und verwaltet werden.
Im folgenden Beispiel wird eine Ressourcengruppe mit dem Namen test-rg am Standort eastus2 erstellt:
$rsg = @{
Name = 'test-rg'
Location = 'eastus2'
}
New-AzResourceGroup @rsg
Erstellen des NAT-Gateways
In diesem Abschnitt erstellen Sie das NAT-Gateway und unterstützende Ressourcen.
## Create public IP address for NAT gateway ##
$ip = @{
Name = 'public-ip-nat'
ResourceGroupName = 'test-rg'
Location = 'eastus2'
Sku = 'Standard'
AllocationMethod = 'Static'
Zone = 1,2,3
}
$publicIP = New-AzPublicIpAddress @ip
## Create NAT gateway resource ##
$nat = @{
ResourceGroupName = 'test-rg'
Name = 'nat-gateway'
IdleTimeoutInMinutes = '10'
Sku = 'Standard'
Location = 'eastus2'
PublicIpAddress = $publicIP
}
$natGateway = New-AzNatGateway @nat
## Create subnet config and associate NAT gateway to subnet##
$subnet = @{
Name = 'subnet-1'
AddressPrefix = '10.0.0.0/24'
NatGateway = $natGateway
}
$subnetConfig = New-AzVirtualNetworkSubnetConfig @subnet
## Create Azure Bastion subnet ##
$bastsubnet = @{
Name = 'AzureBastionSubnet'
AddressPrefix = '10.0.1.0/26'
}
$bastsubnetConfig = New-AzVirtualNetworkSubnetConfig @bastsubnet
## Create the virtual network ##
$net = @{
Name = 'vnet-1'
ResourceGroupName = 'test-rg'
Location = 'eastus2'
AddressPrefix = '10.0.0.0/16'
Subnet = $subnetConfig,$bastsubnetConfig
}
$vnet = New-AzVirtualNetwork @net
## Create public IP address for bastion host ##
$ip = @{
Name = 'public-ip'
ResourceGroupName = 'test-rg'
Location = 'eastus2'
Sku = 'Standard'
AllocationMethod = 'Static'
Zone = 1,2,3
}
$publicip = New-AzPublicIpAddress @ip
## Create bastion host ##
$bastion = @{
Name = 'bastion'
ResourceGroupName = 'test-rg'
PublicIpAddressRgName = 'test-rg'
PublicIpAddressName = 'public-ip'
VirtualNetworkRgName = 'test-rg'
VirtualNetworkName = 'vnet-1'
Sku = 'Basic'
}
New-AzBastion @bastion
Die Bereitstellung des Bastionhosts kann einige Minuten dauern. Warten Sie, bis der Bastionhost bereitgestellt wurde, bevor Sie mit dem nächsten Abschnitt fortfahren.
Erstellen eines virtuellen Computers
In diesem Abschnitt erstellen Sie einen virtuellen Computer, um das NAT-Gateway zu testen und die öffentliche IP-Adresse der ausgehenden Verbindung zu überprüfen.
# Set the administrator and password for the VM ##
$cred = Get-Credential
## Place the virtual network into a variable ##
$vnet = Get-AzVirtualNetwork -Name 'vnet-1' -ResourceGroupName 'test-rg'
## Create network interface for virtual machine ##
$nic = @{
Name = "nic-1"
ResourceGroupName = 'test-rg'
Location = 'eastus2'
Subnet = $vnet.Subnets[0]
}
$nicVM = New-AzNetworkInterface @nic
## Create a virtual machine configuration ##
$vmsz = @{
VMName = 'vm-1'
VMSize = 'Standard_DS1_v2'
}
$vmos = @{
ComputerName = 'vm-1'
Credential = $cred
}
$vmimage = @{
PublisherName = 'Canonical'
Offer = '0001-com-ubuntu-server-jammy'
Skus = '22_04-lts-gen2'
Version = 'latest'
}
$vmConfig = New-AzVMConfig @vmsz `
| Set-AzVMOperatingSystem @vmos -Linux `
| Set-AzVMSourceImage @vmimage `
| Add-AzVMNetworkInterface -Id $nicVM.Id
## Create the virtual machine ##
$vm = @{
ResourceGroupName = 'test-rg'
Location = 'eastus2'
VM = $vmConfig
}
New-AzVM @vm
Warten Sie, bis die Erstellung des virtuellen Computers abgeschlossen ist, bevor Sie mit dem nächsten Abschnitt fortfahren.
Erstellen einer Ressourcengruppe
Erstellen Sie mit az group create eine Ressourcengruppe. Eine Azure-Ressourcengruppe ist ein logischer Container, in dem Azure-Ressourcen bereitgestellt und verwaltet werden.
az group create \
--name test-rg \
--location eastus2
Erstellen des NAT-Gateways
In diesem Abschnitt erstellen Sie das NAT-Gateway und unterstützende Ressourcen.
Erstellen einer öffentlichen IP-Adresse
Um auf das Internet zuzugreifen, benötigen Sie eine oder mehrere öffentliche IP-Adressen für das NAT-Gateway. Verwenden Sie az network public-ip create, um eine Ressource mit einer öffentlichen IP-Adresse zu erstellen.
az network public-ip create \
--resource-group test-rg \
--name public-ip-nat \
--sku Standard \
--allocation-method Static \
--location eastus2 \
--zone 1 2 3
Erstellen einer NAT-Gatewayressource
Erstellen Sie eine NAT-Gatewayressource mit az network nat gateway create. Das NAT-Gateway verwendet die öffentliche IP-Adresse, die im vorherigen Schritt erstellt wurde. Das Leerlauftimeout ist auf zehn Minuten festgelegt.
az network nat gateway create \
--resource-group test-rg \
--name nat-gateway \
--public-ip-addresses public-ip-nat \
--idle-timeout 10
Erstellen eines virtuellen Netzwerks und Subnetzes
Erstellen Sie ein virtuelles Netzwerk mit dem Namen vnet-1 mit einem Subnetz namens Subnetz 1 mithilfe der Az-Netzwerk-vnet-Erstellung. Der IP-Adressraum für das virtuelle Netzwerk ist 10.0.0.0/16. Das Subnetz im virtuellen Netzwerk ist 10.0.0.0/24.
az network vnet create \
--resource-group test-rg \
--name vnet-1 \
--address-prefix 10.0.0.0/16 \
--subnet-name subnet-1 \
--subnet-prefixes 10.0.0.0/24
Erstellen eines Azure Bastion-Subnetzes
Erstellen Sie ein Azure Bastion-Subnetz namens AzureBastionSubnet mithilfe von az network vnet subnet create:
az network vnet subnet create \
--name AzureBastionSubnet \
--resource-group test-rg \
--vnet-name vnet-1 \
--address-prefix 10.0.1.0/26
NAT-Gateway einem Subnetz zuordnen
Ordnen Sie das NAT-Gateway dem Subnetz mit az network vnet subnet update zu:
az network vnet subnet update \
--resource-group test-rg \
--vnet-name vnet-1 \
--name subnet-1 \
--nat-gateway nat-gateway
Erstellen einer öffentlichen IP-Adresse für Bastion-Host
Erstellen Sie eine öffentliche IP-Adresse für den Bastion-Host mit az network public-ip create:
az network public-ip create \
--resource-group test-rg \
--name public-ip \
--sku Standard \
--location eastus2 \
--zone 1 2 3
Bastion-Host erstellen
Erstellen Sie den Azure Bastion-Host mit az network bastion create:
az network bastion create \
--name bastion \
--public-ip-address public-ip \
--resource-group test-rg \
--vnet-name vnet-1 \
--location eastus2
Die Bereitstellung des Bastionhosts kann einige Minuten dauern. Warten Sie, bis der Bastionhost bereitgestellt wurde, bevor Sie mit dem nächsten Abschnitt fortfahren.
Erstellen eines virtuellen Computers
Erstellen Sie einen virtuellen Computer namens vm-1, um das NAT-Gateway zu testen und die öffentliche IP-Adresse der ausgehenden Verbindung zu überprüfen. Verwenden Sie az vm create:
az vm create \
--resource-group test-rg \
--name vm-1 \
--image Ubuntu2204 \
--admin-username azureuser \
--authentication-type password \
--public-ip-address "" \
--subnet subnet-1 \
--vnet-name vnet-1
Warten Sie, bis die Erstellung des virtuellen Computers abgeschlossen ist, bevor Sie mit dem nächsten Abschnitt fortfahren.
Eine Azure Resource Manager-Vorlage ist eine JSON (JavaScript Object Notation)-Datei, welche die Infrastruktur und die Konfiguration für Ihr Projekt definiert. Die Vorlage verwendet eine deklarative Syntax. Sie beschreiben Ihre geplante Bereitstellung, ohne die Abfolge der Programmierbefehle zu schreiben, mit denen die Bereitstellung erstellt wird.
Wenn Ihre Umgebung die Voraussetzungen erfüllt und Sie mit der Verwendung von ARM-Vorlagen vertraut sind, wählen Sie die Schaltfläche Deploy to Azure aus. Die Vorlage wird im Azure-Portal geöffnet.
Überprüfen der Vorlage
Die in dieser Schnellstartanleitung verwendete Vorlage stammt von der Seite mit den Azure-Schnellstartvorlagen.
Diese Vorlage ist für die Erstellung der folgenden Elemente konfiguriert:
Der virtuelle Ubuntu-Computer wird in einem Subnetz bereitgestellt, das der NAT-Gatewayressource zugeordnet ist.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"metadata": {
"_generator": {
"name": "bicep",
"version": "0.25.53.49325",
"templateHash": "15583664434476061565"
}
},
"parameters": {
"vmname": {
"type": "string",
"defaultValue": "vm-1",
"metadata": {
"description": "Name of the virtual machine"
}
},
"vmsize": {
"type": "string",
"defaultValue": "Standard_D2s_v3",
"metadata": {
"description": "Size of the virtual machine"
}
},
"vnetname": {
"type": "string",
"defaultValue": "vnet-1",
"metadata": {
"description": "Name of the virtual network"
}
},
"subnetname": {
"type": "string",
"defaultValue": "subnet-1",
"metadata": {
"description": "Name of the subnet for virtual network"
}
},
"vnetaddressspace": {
"type": "string",
"defaultValue": "10.0.0.0/16",
"metadata": {
"description": "Address space for virtual network"
}
},
"vnetsubnetprefix": {
"type": "string",
"defaultValue": "10.0.0.0/24",
"metadata": {
"description": "Subnet prefix for virtual network"
}
},
"natgatewayname": {
"type": "string",
"defaultValue": "nat-gateway",
"metadata": {
"description": "Name of the NAT gateway"
}
},
"networkinterfacename": {
"type": "string",
"defaultValue": "nic-1",
"metadata": {
"description": "Name of the virtual machine nic"
}
},
"publicipname": {
"type": "string",
"defaultValue": "public-ip-nat",
"metadata": {
"description": "Name of the NAT gateway public IP"
}
},
"nsgname": {
"type": "string",
"defaultValue": "nsg-1",
"metadata": {
"description": "Name of the virtual machine NSG"
}
},
"adminusername": {
"type": "string",
"metadata": {
"description": "Administrator username for virtual machine"
}
},
"adminpassword": {
"type": "securestring",
"metadata": {
"description": "Administrator password for virtual machine"
}
},
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]",
"metadata": {
"description": "Name of resource group"
}
}
},
"resources": [
{
"type": "Microsoft.Network/networkSecurityGroups",
"apiVersion": "2021-05-01",
"name": "[parameters('nsgname')]",
"location": "[parameters('location')]",
"properties": {
"securityRules": [
{
"name": "SSH",
"properties": {
"protocol": "Tcp",
"sourcePortRange": "*",
"destinationPortRange": "22",
"sourceAddressPrefix": "*",
"destinationAddressPrefix": "*",
"access": "Allow",
"priority": 300,
"direction": "Inbound"
}
}
]
}
},
{
"type": "Microsoft.Network/publicIPAddresses",
"apiVersion": "2021-05-01",
"name": "[parameters('publicipname')]",
"location": "[parameters('location')]",
"sku": {
"name": "Standard"
},
"properties": {
"publicIPAddressVersion": "IPv4",
"publicIPAllocationMethod": "Static",
"idleTimeoutInMinutes": 4
}
},
{
"type": "Microsoft.Compute/virtualMachines",
"apiVersion": "2021-11-01",
"name": "[parameters('vmname')]",
"location": "[parameters('location')]",
"properties": {
"hardwareProfile": {
"vmSize": "[parameters('vmsize')]"
},
"storageProfile": {
"imageReference": {
"publisher": "Canonical",
"offer": "0001-com-ubuntu-server-jammy",
"sku": "22_04-lts-gen2",
"version": "latest"
},
"osDisk": {
"osType": "Linux",
"name": "[format('{0}_disk1', parameters('vmname'))]",
"createOption": "FromImage",
"caching": "ReadWrite",
"managedDisk": {
"storageAccountType": "Premium_LRS"
},
"diskSizeGB": 30
}
},
"osProfile": {
"computerName": "[parameters('vmname')]",
"adminUsername": "[parameters('adminusername')]",
"adminPassword": "[parameters('adminpassword')]",
"linuxConfiguration": {
"disablePasswordAuthentication": false,
"provisionVMAgent": true
},
"allowExtensionOperations": true
},
"networkProfile": {
"networkInterfaces": [
{
"id": "[resourceId('Microsoft.Network/networkInterfaces', parameters('networkinterfacename'))]"
}
]
}
},
"dependsOn": [
"[resourceId('Microsoft.Network/networkInterfaces', parameters('networkinterfacename'))]"
]
},
{
"type": "Microsoft.Network/virtualNetworks",
"apiVersion": "2021-05-01",
"name": "[parameters('vnetname')]",
"location": "[parameters('location')]",
"properties": {
"addressSpace": {
"addressPrefixes": [
"[parameters('vnetaddressspace')]"
]
},
"subnets": [
{
"name": "[parameters('subnetname')]",
"properties": {
"addressPrefix": "[parameters('vnetsubnetprefix')]",
"natGateway": {
"id": "[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]"
},
"privateEndpointNetworkPolicies": "Enabled",
"privateLinkServiceNetworkPolicies": "Enabled"
}
}
],
"enableDdosProtection": false,
"enableVmProtection": false
},
"dependsOn": [
"[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]"
]
},
{
"type": "Microsoft.Network/natGateways",
"apiVersion": "2021-05-01",
"name": "[parameters('natgatewayname')]",
"location": "[parameters('location')]",
"sku": {
"name": "Standard"
},
"properties": {
"idleTimeoutInMinutes": 4,
"publicIpAddresses": [
{
"id": "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicipname'))]"
}
]
},
"dependsOn": [
"[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicipname'))]"
]
},
{
"type": "Microsoft.Network/virtualNetworks/subnets",
"apiVersion": "2021-05-01",
"name": "[format('{0}/{1}', parameters('vnetname'), 'subnet-1')]",
"properties": {
"addressPrefix": "[parameters('vnetsubnetprefix')]",
"natGateway": {
"id": "[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]"
},
"privateEndpointNetworkPolicies": "Enabled",
"privateLinkServiceNetworkPolicies": "Enabled"
},
"dependsOn": [
"[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]",
"[resourceId('Microsoft.Network/virtualNetworks', parameters('vnetname'))]"
]
},
{
"type": "Microsoft.Network/networkInterfaces",
"apiVersion": "2021-05-01",
"name": "[parameters('networkinterfacename')]",
"location": "[parameters('location')]",
"properties": {
"ipConfigurations": [
{
"name": "ipconfig-1",
"properties": {
"privateIPAddress": "10.0.0.4",
"privateIPAllocationMethod": "Dynamic",
"subnet": {
"id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('vnetname'), 'subnet-1')]"
},
"primary": true,
"privateIPAddressVersion": "IPv4"
}
}
],
"enableAcceleratedNetworking": false,
"enableIPForwarding": false,
"networkSecurityGroup": {
"id": "[resourceId('Microsoft.Network/networkSecurityGroups', parameters('nsgname'))]"
}
},
"dependsOn": [
"[resourceId('Microsoft.Network/networkSecurityGroups', parameters('nsgname'))]",
"[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('vnetname'), 'subnet-1')]"
]
}
],
"outputs": {
"location": {
"type": "string",
"value": "[parameters('location')]"
},
"name": {
"type": "string",
"value": "[parameters('natgatewayname')]"
},
"resourceGroupName": {
"type": "string",
"value": "[resourceGroup().name]"
},
"resourceId": {
"type": "string",
"value": "[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]"
}
}
}
In der Vorlage sind neun Azure-Ressourcen definiert:
Implementieren der Vorlage
Portal
Überprüfen der bereitgestellten Ressourcen
Melden Sie sich beim Azure-Portal an.
Wählen Sie im linken Bereich Ressourcengruppen aus.
Wählen Sie die Ressourcengruppe aus, die Sie im vorherigen Abschnitt erstellt haben. Der Ressourcengruppenname lautet standardmäßig myResourceGroupNAT.
Vergewissern Sie sich, dass die folgenden Ressourcen in der Ressourcengruppe erstellt wurden:
PowerShell
$location = Read-Host -Prompt "Enter the location (i.e. westcentralus)"
$templateUri = "https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/quickstarts/microsoft.network/nat-gateway-1-vm/azuredeploy.json"
$resourceGroupName = "myResourceGroupNAT"
New-AzResourceGroup -Name $resourceGroupName -Location $location
New-AzResourceGroupDeployment -ResourceGroupName $resourceGroupName -TemplateUri $templateUri
Azure-Befehlszeilenschnittstelle (Azure CLI)
read -p "Enter the location (i.e. westcentralus): " location
resourceGroupName="myResourceGroupNAT"
templateUri="https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/quickstarts/microsoft.network/nat-gateway-1-vm/azuredeploy.json"
az group create \
--name $resourceGroupName \
--location $location
az deployment group create \
--resource-group $resourceGroupName \
--template-uri $templateUri
Überprüfen der Bicep-Datei
Die in dieser Schnellstartanleitung verwendete Bicep-Datei stammt aus den Azure-Schnellstartvorlagen.
Diese Bicep-Datei ist für die Erstellung von Folgendem konfiguriert:
Der virtuelle Ubuntu-Computer wird in einem Subnetz bereitgestellt, das der NAT-Gatewayressource zugeordnet ist.
@description('Name of the virtual machine')
param vmname string = 'vm-1'
@description('Size of the virtual machine')
param vmsize string = 'Standard_D2s_v3'
@description('Name of the virtual network')
param vnetname string = 'vnet-1'
@description('Name of the subnet for virtual network')
param subnetname string = 'subnet-1'
@description('Address space for virtual network')
param vnetaddressspace string = '10.0.0.0/16'
@description('Subnet prefix for virtual network')
param vnetsubnetprefix string = '10.0.0.0/24'
@description('Name of the NAT gateway')
param natgatewayname string = 'nat-gateway'
@description('Name of the virtual machine nic')
param networkinterfacename string = 'nic-1'
@description('Name of the NAT gateway public IP')
param publicipname string = 'public-ip-nat'
@description('Name of the virtual machine NSG')
param nsgname string = 'nsg-1'
@description('Administrator username for virtual machine')
param adminusername string
@description('Administrator password for virtual machine')
@secure()
param adminpassword string
@description('Name of resource group')
param location string = resourceGroup().location
resource nsg 'Microsoft.Network/networkSecurityGroups@2021-05-01' = {
name: nsgname
location: location
properties: {
securityRules: [
{
name: 'SSH'
properties: {
protocol: 'Tcp'
sourcePortRange: '*'
destinationPortRange: '22'
sourceAddressPrefix: '*'
destinationAddressPrefix: '*'
access: 'Allow'
priority: 300
direction: 'Inbound'
}
}
]
}
}
resource publicip 'Microsoft.Network/publicIPAddresses@2021-05-01' = {
name: publicipname
location: location
sku: {
name: 'Standard'
}
properties: {
publicIPAddressVersion: 'IPv4'
publicIPAllocationMethod: 'Static'
idleTimeoutInMinutes: 4
}
}
resource vm 'Microsoft.Compute/virtualMachines@2021-11-01' = {
name: vmname
location: location
properties: {
hardwareProfile: {
vmSize: vmsize
}
storageProfile: {
imageReference: {
publisher: 'Canonical'
offer: '0001-com-ubuntu-server-jammy'
sku: '22_04-lts-gen2'
version: 'latest'
}
osDisk: {
osType: 'Linux'
name: '${vmname}_disk1'
createOption: 'FromImage'
caching: 'ReadWrite'
managedDisk: {
storageAccountType: 'Premium_LRS'
}
diskSizeGB: 30
}
}
osProfile: {
computerName: vmname
adminUsername: adminusername
adminPassword: adminpassword
linuxConfiguration: {
disablePasswordAuthentication: false
provisionVMAgent: true
}
allowExtensionOperations: true
}
networkProfile: {
networkInterfaces: [
{
id: networkinterface.id
}
]
}
}
}
resource vnet 'Microsoft.Network/virtualNetworks@2021-05-01' = {
name: vnetname
location: location
properties: {
addressSpace: {
addressPrefixes: [
vnetaddressspace
]
}
subnets: [
{
name: subnetname
properties: {
addressPrefix: vnetsubnetprefix
natGateway: {
id: natgateway.id
}
privateEndpointNetworkPolicies: 'Enabled'
privateLinkServiceNetworkPolicies: 'Enabled'
}
}
]
enableDdosProtection: false
enableVmProtection: false
}
}
resource natgateway 'Microsoft.Network/natGateways@2021-05-01' = {
name: natgatewayname
location: location
sku: {
name: 'Standard'
}
properties: {
idleTimeoutInMinutes: 4
publicIpAddresses: [
{
id: publicip.id
}
]
}
}
resource subnet 'Microsoft.Network/virtualNetworks/subnets@2021-05-01' = {
parent: vnet
name: 'subnet-1'
properties: {
addressPrefix: vnetsubnetprefix
natGateway: {
id: natgateway.id
}
privateEndpointNetworkPolicies: 'Enabled'
privateLinkServiceNetworkPolicies: 'Enabled'
}
}
resource networkinterface 'Microsoft.Network/networkInterfaces@2021-05-01' = {
name: networkinterfacename
location: location
properties: {
ipConfigurations: [
{
name: 'ipconfig-1'
properties: {
privateIPAddress: '10.0.0.4'
privateIPAllocationMethod: 'Dynamic'
subnet: {
id: subnet.id
}
primary: true
privateIPAddressVersion: 'IPv4'
}
}
]
enableAcceleratedNetworking: false
enableIPForwarding: false
networkSecurityGroup: {
id: nsg.id
}
}
}
output location string = location
output name string = natgateway.name
output resourceGroupName string = resourceGroup().name
output resourceId string = natgateway.id
In der Bicep-Datei sind neun Azure-Ressourcen definiert:
Bereitstellen der Bicep-Datei
Speichern Sie die Bicep-Datei als main.bicep auf Ihrem lokalen Computer.
Stellen Sie die Bicep-Datei entweder mit Azure CLI oder mit Azure PowerShell bereit.
Azure-Befehlszeilenschnittstelle (Azure CLI)
az group create --name exampleRG --location eastus
az deployment group create --resource-group exampleRG --template-file main.bicep --parameters adminusername=<admin-name>
PowerShell
New-AzResourceGroup -Name exampleRG -Location eastus
New-AzResourceGroupDeployment -ResourceGroupName exampleRG -TemplateFile ./main.bicep -adminusername "<admin-name>"
Hinweis
Ersetzen Sie <admin-name> durch den Administrator-Benutzernamen für den virtuellen Computer. Sie werden auch zur Eingabe von adminpassword aufgefordert.
Nach Abschluss der Bereitstellung sollte eine Meldung mit dem Hinweis angezeigt werden, dass die Bereitstellung erfolgreich war.
Überprüfen der bereitgestellten Ressourcen
Verwenden Sie das Azure-Portal, die Azure CLI oder Azure PowerShell, um die bereitgestellten Ressourcen in der Ressourcengruppe aufzulisten.
Azure-Befehlszeilenschnittstelle (Azure CLI)
az resource list --resource-group exampleRG
PowerShell
Get-AzResource -ResourceGroupName exampleRG
Diese Terraform-Datei stellt ein virtuelles Netzwerk, eine NAT-Gatewayressource und einen virtuellen Ubuntu-Computer bereit. Der virtuelle Ubuntu-Computer wird in einem Subnetz bereitgestellt, das der NAT-Gatewayressource zugeordnet ist.
Das Skript generiert auch einen zufälligen öffentlichen SSH-Schlüssel und ordnet ihn dem virtuellen Computer für den sicheren Zugriff zu. Der öffentliche Schlüssel wird am Ende der Skriptausführung ausgegeben.
Das Skript verwendet zusätzlich zum AzureRM-Anbieter die Anbieter Random und AzAPI. Der Zufallsanbieter wird verwendet, um einen eindeutigen Namen für die Ressourcengruppe und den SSH-Schlüssel zu generieren. Der AzAPI-Anbieter wird verwendet, um den öffentlichen SSH-Schlüssel zu generieren.
Wie bei dem öffentlichen Schlüssel werden die Namen der erstellten Ressourcengruppe, des virtuellen Netzwerks, des Subnetzs und des NAT-Gateways gedruckt, wenn das Skript ausgeführt wird.
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.
Erstellen Sie ein Verzeichnis, in dem der Terraform-Beispielcode getestet und ausgeführt werden soll, und legen Sie es als aktuelles Verzeichnis fest.
Erstellen Sie eine Datei namens main.tf, und fügen Sie den folgenden Code ein:
# Resource Group
resource "azurerm_resource_group" "rg" {
location = var.resource_group_location
name = "${random_pet.prefix.id}-rg"
}
# Virtual Network
resource "azurerm_virtual_network" "my_terraform_network" {
name = "${random_pet.prefix.id}-vnet"
address_space = ["10.0.0.0/16"]
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
}
# Subnet 1
resource "azurerm_subnet" "my_terraform_subnet_1" {
name = "subnet-1"
resource_group_name = azurerm_resource_group.rg.name
virtual_network_name = azurerm_virtual_network.my_terraform_network.name
address_prefixes = ["10.0.0.0/24"]
}
# Public IP address for NAT gateway
resource "azurerm_public_ip" "my_public_ip" {
name = "public-ip-nat"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
allocation_method = "Static"
sku = "Standard"
}
# NAT Gateway
resource "azurerm_nat_gateway" "my_nat_gateway" {
name = "nat-gateway"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
}
# Associate NAT Gateway with Public IP
resource "azurerm_nat_gateway_public_ip_association" "example" {
nat_gateway_id = azurerm_nat_gateway.my_nat_gateway.id
public_ip_address_id = azurerm_public_ip.my_public_ip.id
}
# Associate NAT Gateway with Subnet
resource "azurerm_subnet_nat_gateway_association" "example" {
subnet_id = azurerm_subnet.my_terraform_subnet_1.id
nat_gateway_id = azurerm_nat_gateway.my_nat_gateway.id
}
# Create public IP for virtual machine
resource "azurerm_public_ip" "my_public_ip_vm" {
name = "public-ip-vm"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
allocation_method = "Static"
sku = "Standard"
}
# Create Network Security Group and rule
resource "azurerm_network_security_group" "my_terraform_nsg" {
name = "nsg-1"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
security_rule {
name = "SSH"
priority = 1001
direction = "Inbound"
access = "Allow"
protocol = "Tcp"
source_port_range = "*"
destination_port_range = "22"
source_address_prefix = "*"
destination_address_prefix = "*"
}
}
# Create network interface
resource "azurerm_network_interface" "my_terraform_nic" {
name = "nic-1"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
ip_configuration {
name = "my_nic_configuration"
subnet_id = azurerm_subnet.my_terraform_subnet_1.id
private_ip_address_allocation = "Dynamic"
public_ip_address_id = azurerm_public_ip.my_public_ip_vm.id
}
}
# Connect the security group to the network interface
resource "azurerm_network_interface_security_group_association" "example" {
network_interface_id = azurerm_network_interface.my_terraform_nic.id
network_security_group_id = azurerm_network_security_group.my_terraform_nsg.id
}
# Generate random text for a unique storage account name
resource "random_id" "random_id" {
keepers = {
# Generate a new ID only when a new resource group is defined
resource_group = azurerm_resource_group.rg.name
}
byte_length = 8
}
# Create storage account for boot diagnostics
resource "azurerm_storage_account" "my_storage_account" {
name = "diag${random_id.random_id.hex}"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
account_tier = "Standard"
account_replication_type = "LRS"
}
# Create virtual machine
resource "azurerm_linux_virtual_machine" "my_terraform_vm" {
name = "vm-1"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
network_interface_ids = [azurerm_network_interface.my_terraform_nic.id]
size = "Standard_DS1_v2"
os_disk {
name = "myOsDisk"
caching = "ReadWrite"
storage_account_type = "Premium_LRS"
}
source_image_reference {
publisher = "Canonical"
offer = "0001-com-ubuntu-server-jammy"
sku = "22_04-lts-gen2"
version = "latest"
}
computer_name = "hostname"
admin_username = var.username
admin_ssh_key {
username = var.username
public_key = azapi_resource_action.ssh_public_key_gen.output.publicKey
}
boot_diagnostics {
storage_account_uri = azurerm_storage_account.my_storage_account.primary_blob_endpoint
}
}
resource "random_pet" "prefix" {
prefix = var.resource_group_name_prefix
length = 1
}
Erstellen Sie eine Datei namens outputs.tf, und fügen Sie den folgenden Code ein:
output "resource_group_name" {
description = "The name of the created resource group."
value = azurerm_resource_group.rg.name
}
output "virtual_network_name" {
description = "The name of the created virtual network."
value = azurerm_virtual_network.my_terraform_network.name
}
output "subnet_name_1" {
description = "The name of the created subnet 1."
value = azurerm_subnet.my_terraform_subnet_1.name
}
output "nat_gateway"{
description = "The name of the created NAT gateway."
value = azurerm_nat_gateway.my_nat_gateway.id
}
Erstellen Sie eine Datei namens providers.tf, und fügen Sie den folgenden Code ein:
terraform {
required_providers {
azapi = {
source = "azure/azapi"
version = "~>1.5"
}
azurerm = {
source = "hashicorp/azurerm"
version = "~>3.0"
}
random = {
source = "hashicorp/random"
version = "~>3.0"
}
}
}
provider "azurerm" {
features {}
}
Erstellen Sie eine Datei namens ssh.tf, und fügen Sie den folgenden Code ein:
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
}
Erstellen Sie eine Datei namens variables.tf, und fügen Sie den folgenden Code ein:
variable "resource_group_location" {
type = string
default = "eastus"
description = "Location of the resource group."
}
variable "resource_group_name_prefix" {
type = string
default = "rg"
description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
}
variable "username" {
type = string
description = "The username for the local account that will be created on the new VM."
default = "azureuser"
}
Führen Sie terraform init aus, um die Terraform-Bereitstellung zu initialisieren. Mit diesem Befehl wird der Azure-Anbieter heruntergeladen, 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.
Führen Sie terraform plan aus, um einen Ausführungsplan zu erstellen.
terraform plan -out main.tfplan
Die wichtigsten Punkte:
- Durch den Befehl
terraform plan wird ein Ausführungsplan erstellt, aber nicht ausgeführt. Stattdessen werden die Aktionen ermittelt, die 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 den eigentlichen Ressourcen vornehmen.
- Der optionale Parameter
-out ermöglicht die Angabe einer Ausgabedatei für den Plan. Durch die Verwendung des Parameters -out wird sichergestellt, dass genau der von Ihnen überprüfte Plan angewendet wird.
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-Befehlszeilenschnittstelle (Azure CLI)
Rufen Sie den Namen der Azure-Ressourcengruppe ab.
resource_group_name=$(terraform output -raw resource_group_name)
Rufen Sie die NAT Gateway-ID ab.
nat_gateway=$(terraform output -raw nat_gateway)
Führen Sie az network nat gateway aus , um die Details zum NAT-Gateway anzuzeigen.
az network nat gateway show \
--resource-group $resource_group_name \
--ids $nat_gateway
PowerShell
Rufen Sie den Namen der Azure-Ressourcengruppe ab.
$resource_group_name=$(terraform output -raw resource_group_name)
Rufen Sie die NAT Gateway-ID ab.
$nat_gateway=$(terraform output -raw nat_gateway)
Führen Sie Get-AzNatGateway aus, um die Details zum NAT-Gateway anzuzeigen.
$nat = @{
Name = $nat_gateway
ResourceGroupName = $resource_group_name
}
Get-AzNatGateway @nat
In diesem Abschnitt testen Sie das NAT-Gateway. Sie ermitteln zunächst die öffentliche IP-Adresse des NAT-Gateways. Anschließend stellen Sie eine Verbindung mit dem virtuellen Testcomputer her und überprüfen die ausgehende Verbindung über das NAT-Gateway.
