Creare un ambiente Linux completo tramite l'interfaccia della riga di comando di Azure 1.0Create a complete Linux environment with the Azure CLI 1.0

In questo articolo viene spiegato come creare una semplice rete con un servizio di bilanciamento del carico e un paio di VM utili per lo sviluppo e per calcoli semplici.In this article, we build a simple network with a load balancer and a pair of VMs that are useful for development and simple computing. Viene presentato in dettaglio l'intero processo, comando dopo comando, fino a creare due VM Linux funzionanti e sicure a cui è possibile connettersi da qualsiasi posizione in Internet.We walk through the process command by command, until you have two working, secure Linux VMs to which you can connect from anywhere on the Internet. Si potrà quindi passare a reti e ambienti più complessi.Then you can move on to more complex networks and environments.

Durante il processo si apprenderanno informazioni sulla gerarchia delle dipendenze fornita dal modello di distribuzione di Resource Manager e sulle potenzialità che offre.Along the way, you learn about the dependency hierarchy that the Resource Manager deployment model gives you, and about how much power it provides. Dopo aver osservato come viene realizzato il sistema, è possibile ricrearlo molto più rapidamente utilizzando i modelli di Azure Resource Manager.After you see how the system is built, you can rebuild it much more quickly by using Azure Resource Manager templates. In più, dopo aver scoperto come interagiscono le parti dell'ambiente, diventa più facile creare modelli per automatizzarle.Also, after you learn how the parts of your environment fit together, creating templates to automate them becomes easier.

Nell'ambiente sono presenti:The environment contains:

  • Due VM all'interno di un set di disponibilità.Two VMs inside an availability set.
  • Un servizio di bilanciamento del carico con una regola di bilanciamento del carico sulla porta 80.A load balancer with a load-balancing rule on port 80.
  • Regole del gruppo di sicurezza di rete (NSG) per proteggere la VM dal traffico indesiderato.Network security group (NSG) rules to protect your VM from unwanted traffic.

Per creare questo ambiente personalizzato, è necessario aver installato l'interfaccia della riga di comando di Azure 1.0 in modalità Resource Manager (azure config mode arm).To create this custom environment, you need the latest Azure CLI 1.0 in Resource Manager mode (azure config mode arm). È inoltre necessario uno strumento di analisi JSON.You also need a JSON parsing tool. In questo esempio viene utilizzato jq.This example uses jq.

Versioni dell'interfaccia della riga di comando per completare l'attivitàCLI versions to complete the task

È possibile completare l'attività usando una delle versioni seguenti dell'interfaccia della riga di comando:You can complete the task using one of the following CLI versions:

Comandi rapidiQuick commands

Se si vuole eseguire rapidamente l'attività, la sezione seguente indica in dettaglio i comandi base per caricare una VM in Azure.If you need to quickly accomplish the task, the following section details the base commands to upload a VM to Azure. Altre informazioni dettagliate e il contesto per ogni passaggio sono disponibili nelle sezioni successive del documento, a partire da qui.More detailed information and context for each step can be found in the rest of the document, starting here.

Controllare di aver effettuato l'accesso tramite l'interfaccia della riga di comando di Azure 1.0 e di usare la modalità Resource Manager:Make sure that you have the Azure CLI 1.0 logged in and using Resource Manager mode:

azure config mode arm

Nell'esempio seguente sostituire i nomi dei parametri di esempio con i valori desiderati.In the following examples, replace example parameter names with your own values. I nomi dei parametri di esempio includono myResourceGroup, mystorageaccount e myVM.Example parameter names include myResourceGroup, mystorageaccount, and myVM.

Creare il gruppo di risorse.Create the resource group. Nell'esempio seguente viene creato un gruppo di risorse denominato myResourceGroup nella località westeurope:The following example creates a resource group named myResourceGroup in the westeurope location:

azure group create -n myResourceGroup -l westeurope

Verificare il gruppo di risorse utilizzando il parser JSON:Verify the resource group by using the JSON parser:

azure group show myResourceGroup --json | jq '.'

Creare l'account di archiviazione.Create the storage account. Nell'esempio seguente viene creato un nuovo account di archiviazione denominato mystorageaccount.The following example creates a storage account named mystorageaccount. Il nome dell'account di archiviazione deve essere univoco; assegnare quindi all'account il proprio nome.(The storage account name must be unique, so provide your own unique name.)

azure storage account create -g myResourceGroup -l westeurope \
  --kind Storage --sku-name GRS mystorageaccount

Verificare l'account di archiviazione utilizzando il parser JSON:Verify the storage account by using the JSON parser:

azure storage account show -g myResourceGroup mystorageaccount --json | jq '.'

Creare la rete virtuale.Create the virtual network. Nell'esempio seguente viene creata una rete virtuale chiamata myVnet:The following example creates a virtual network named myVnet:

azure network vnet create -g myResourceGroup -l westeurope\
  -n myVnet -a 192.168.0.0/16

Creare una subnet.Create a subnet. Nell'esempio seguente viene creata una subnet denominata mySubnet:The following example creates a subnet named mySubnet:

azure network vnet subnet create -g myResourceGroup \
  -e myVnet -n mySubnet -a 192.168.1.0/24

Verificare la rete virtuale e la subnet utilizzando il parser JSON:Verify the virtual network and subnet by using the JSON parser:

azure network vnet show myResourceGroup myVnet --json | jq '.'

Creare un indirizzo IP pubblico.Create a public IP. Nell'esempio seguente viene aggiunto un indirizzo IP pubblico chiamato myPublicIP con il nome DNS mypublicdns.The following example creates a public IP named myPublicIP with the DNS name of mypublicdns. Il nome DNS deve essere univoco, quindi specificare il proprio nome DNS.(The DNS name must be unique, so provide your own unique name.)

azure network public-ip create -g myResourceGroup -l westeurope \
  -n myPublicIP  -d mypublicdns -a static -i 4

Creare il servizio di bilanciamento del carico.Create the load balancer. Nell'esempio seguente viene creato un servizio di bilanciamento del carico chiamato myLoadBalancer:The following example creates a load balancer named myLoadBalancer:

azure network lb create -g myResourceGroup -l westeurope -n myLoadBalancer

Creare un pool di indirizzi IP front-end per il servizio di bilanciamento del carico e associare l'IP pubblico.Create a front-end IP pool for the load balancer, and associate the public IP. Nell'esempio seguente viene creato un pool di indirizzi IP front-end chiamato mySubnetPool:The following example creates a front-end IP pool named mySubnetPool:

azure network lb frontend-ip create -g myResourceGroup -l myLoadBalancer \
  -i myPublicIP -n myFrontEndPool

Creare un pool di indirizzi IP back-end per il servizio di bilanciamento del carico.Create the back-end IP pool for the load balancer. Nell'esempio seguente viene creato un pool di indirizzi IP back-end chiamato myBackEndPool:The following example creates a back-end IP pool named myBackEndPool:

azure network lb address-pool create -g myResourceGroup -l myLoadBalancer \
  -n myBackEndPool

Creare regole Network Address Translation (NAT) in ingresso SSH per il servizio di bilanciamento del carico.Create SSH inbound network address translation (NAT) rules for the load balancer. Nell'esempio seguente vengono create due regole per il servizio di bilanciamento del carico chiamate myLoadBalancerRuleSSH1 e myLoadBalancerRuleSSH2:The following example creates two load balancer rules, myLoadBalancerRuleSSH1 and myLoadBalancerRuleSSH2:

azure network lb inbound-nat-rule create -g myResourceGroup -l myLoadBalancer \
  -n myLoadBalancerRuleSSH1 -p tcp -f 4222 -b 22
azure network lb inbound-nat-rule create -g myResourceGroup -l myLoadBalancer \
  -n myLoadBalancerRuleSSH2 -p tcp -f 4223 -b 22

Creare le regole NAT in ingresso Web per il servizio di bilanciamento del carico.Create the web inbound NAT rules for the load balancer. Nell'esempio seguente viene creata una regola per il servizio di bilanciamento del carico denominata myLoadBalancerRuleWeb:The following example creates a load balancer rule named myLoadBalancerRuleWeb:

azure network lb rule create -g myResourceGroup -l myLoadBalancer \
  -n myLoadBalancerRuleWeb -p tcp -f 80 -b 80 \
  -t myFrontEndPool -o myBackEndPool

Creare il probe di integrità per il servizio di bilanciamento del carico.Create the load balancer health probe. Nell'esempio seguente viene creato un probe TCP chiamato myHealthProbe:The following example creates a TCP probe named myHealthProbe:

azure network lb probe create -g myResourceGroup -l myLoadBalancer \
  -n myHealthProbe -p "tcp" -i 15 -c 4

Verificare il servizio di bilanciamento del carico, il pool di indirizzi IP e le regole NAT utilizzando il parser JSON:Verify the load balancer, IP pools, and NAT rules by using the JSON parser:

azure network lb show -g myResourceGroup -n myLoadBalancer --json | jq '.'

Creare la prima scheda di interfaccia di rete.Create the first network interface card (NIC). Sostituire le sezioni #####-###-### con il proprio ID sottoscrizione di Azure.Replace the #####-###-### sections with your own Azure subscription ID. L'ID sottoscrizione è indicato nell'output di jq quando si esaminano le risorse che si sta creando.Your subscription ID is noted in the output of jq when you examine the resources you are creating. È anche possibile visualizzare l'ID sottoscrizione con azure account list.You can also view your subscription ID with azure account list.

Nell'esempio seguente viene creata una scheda di interfaccia di rete chiamata myNic1:The following example creates a NIC named myNic1:

azure network nic create -g myResourceGroup -l westeurope \
  -n myNic1 -m myVnet -k mySubnet \
  -d "/subscriptions/########-####-####-####-############/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool" \
  -e "/subscriptions/########-####-####-####-############/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH1"

Creare la seconda scheda di interfaccia di rete.Create the second NIC. Nell'esempio seguente viene creata una scheda di interfaccia di rete chiamata myNic2:The following example creates a NIC named myNic2:

azure network nic create -g myResourceGroup -l westeurope \
  -n myNic2 -m myVnet -k mySubnet \
  -d "/subscriptions/########-####-####-####-############/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool" \
  -e "/subscriptions/########-####-####-####-############/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH2"

Verificare le due schede di interfaccia di rete usando il parser JSON:Verify the two NICs by using the JSON parser:

azure network nic show myResourceGroup myNic1 --json | jq '.'
azure network nic show myResourceGroup myNic2 --json | jq '.'

Creare il gruppo di sicurezza di rete.Create the network security group. Nell'esempio seguente viene creato un gruppo di sicurezza di rete denominato myNetworkSecurityGroup:The following example creates a network security group named myNetworkSecurityGroup:

azure network nsg create -g myResourceGroup -l westeurope \
  -n myNetworkSecurityGroup

Aggiungere due regole in ingresso per il gruppo di sicurezza di rete.Add two inbound rules for the network security group. Nell'esempio seguente vengono create due regole chiamate myNetworkSecurityGroupRuleSSH e myNetworkSecurityGroupRuleHTTP:The following example creates two rules, myNetworkSecurityGroupRuleSSH and myNetworkSecurityGroupRuleHTTP:

azure network nsg rule create -p tcp -r inbound -y 1000 -u 22 -c allow \
  -g myResourceGroup -a myNetworkSecurityGroup -n myNetworkSecurityGroupRuleSSH
azure network nsg rule create -p tcp -r inbound -y 1001 -u 80 -c allow \
  -g myResourceGroup -a myNetworkSecurityGroup -n myNetworkSecurityGroupRuleHTTP

Verificare il gruppo di sicurezza di rete e le regole in ingresso usando il parser JSON:Verify the network security group and inbound rules by using the JSON parser:

azure network nsg show -g myResourceGroup -n myNetworkSecurityGroup --json | jq '.'

Associare il gruppo di sicurezza di rete alle due schede di interfaccia di rete:Bind the network security group to the two NICs:

azure network nic set -g myResourceGroup -o myNetworkSecurityGroup -n myNic1
azure network nic set -g myResourceGroup -o myNetworkSecurityGroup -n myNic2

Creare il set di disponibilità.Create the availability set. Nell'esempio seguente viene creato un set di disponibilità chiamato myAvailabilitySet:The following example creates an availability set named myAvailabilitySet:

azure availset create -g myResourceGroup -l westeurope -n myAvailabilitySet

Creare la prima VM Linux.Create the first Linux VM. Nell'esempio seguente viene creata una VM chiamata myVM1:The following example creates a VM named myVM1:

azure vm create \
    --resource-group myResourceGroup \
    --name myVM1 \
    --location westeurope \
    --os-type linux \
    --availset-name myAvailabilitySet \
    --nic-name myNic1 \
    --vnet-name myVnet \
    --vnet-subnet-name mySubnet \
    --storage-account-name mystorageaccount \
    --image-urn canonical:UbuntuServer:16.04.0-LTS:latest \
    --ssh-publickey-file ~/.ssh/id_rsa.pub \
    --admin-username azureuser

Creare la seconda VM Linux.Create the second Linux VM. Nell'esempio seguente viene creata una VM chiamata myVM2:The following example creates a VM named myVM2:

azure vm create \
    --resource-group myResourceGroup \
    --name myVM2 \
    --location westeurope \
    --os-type linux \
    --availset-name myAvailabilitySet \
    --nic-name myNic2 \
    --vnet-name myVnet \
    --vnet-subnet-name mySubnet \
    --storage-account-name mystorageaccount \
    --image-urn canonical:UbuntuServer:16.04.0-LTS:latest \
    --ssh-publickey-file ~/.ssh/id_rsa.pub \
    --admin-username azureuser

Utilizzare il parser JSON per verificare tutto ciò che è stato creato:Use the JSON parser to verify that everything that was built:

azure vm show -g myResourceGroup -n myVM1 --json | jq '.'
azure vm show -g myResourceGroup -n myVM2 --json | jq '.'

Esportare il nuovo ambiente in un modello per ricreare rapidamente nuove istanze:Export your new environment to a template to quickly re-create new instances:

azure group export myResourceGroup

Procedura dettagliataDetailed walkthrough

La procedura dettagliata seguente illustra il funzionamento di ciascun comando durante la creazione dell'ambiente.The detailed steps that follow explain what each command is doing as you build out your environment. Questi concetti torneranno utili in fase di creazione degli ambienti personalizzati per lo sviluppo o per la produzione.These concepts are helpful when you build your own custom environments for development or production.

Controllare di aver effettuato l'accesso tramite l'interfaccia della riga di comando di Azure 1.0 e di usare la modalità Resource Manager:Make sure that you have the Azure CLI 1.0 logged in and using Resource Manager mode:

azure config mode arm

Nell'esempio seguente sostituire i nomi dei parametri di esempio con i valori desiderati.In the following examples, replace example parameter names with your own values. I nomi dei parametri di esempio includono myResourceGroup, mystorageaccount e myVM.Example parameter names include myResourceGroup, mystorageaccount, and myVM.

Creare i gruppi di risorse e scegliere i percorsi di distribuzioneCreate resource groups and choose deployment locations

I gruppi di risorse di Azure sono entità di distribuzione logiche che contengono informazioni di configurazione e altri metadati per abilitare la gestione logica delle distribuzioni di risorse.Azure resource groups are logical deployment entities that contain configuration information and metadata to enable the logical management of resource deployments. Nell'esempio seguente viene creato un gruppo di risorse denominato myResourceGroup nella località westeurope:The following example creates a resource group named myResourceGroup in the westeurope location:

azure group create --name myResourceGroup --location westeurope

Output:Output:

info:    Executing command group create
+ Getting resource group myResourceGroup
+ Creating resource group myResourceGroup
info:    Created resource group myResourceGroup
data:    Id:                  /subscriptions/guid/resourceGroups/myResourceGroup
data:    Name:                myResourceGroup
data:    Location:            westeurope
data:    Provisioning State:  Succeeded
data:    Tags: null
data:
info:    group create command OK

Creare un account di archiviazioneCreate a storage account

Sono necessari account di archiviazione per i dischi della macchina virtuale e per eventuali altri dischi dati che si desidera aggiungere.You need storage accounts for your VM disks and for any additional data disks that you want to add. Si creano account di archiviazione quasi subito dopo la creazione di gruppi di risorse.You create storage accounts almost immediately after you create resource groups.

Viene usato il comando azure storage account create , passando il percorso dell'account, il gruppo di risorse che lo controlla e il tipo di supporto di archiviazione desiderato.Here we use the azure storage account create command, passing the location of the account, the resource group that controls it, and the type of storage support you want. Nell'esempio seguente viene creato un nuovo account di archiviazione denominato mystorageaccount:The following example creates a storage account named mystorageaccount:

azure storage account create \  
  --location westeurope \
  --resource-group myResourceGroup \
  --kind Storage --sku-name GRS \
  mystorageaccount

Output:Output:

info:    Executing command storage account create
+ Creating storage account
info:    storage account create command OK

Per esaminare il gruppo di risorse con il comando azure group show, usare lo strumento jq insieme all'opzione --json dell'interfaccia della riga di comando di Azure.To examine our resource group by using the azure group show command, let's use the jq tool along with the --json Azure CLI option. È possibile utilizzare jsawk o qualsiasi altra libreria di linguaggio per l'analisi del JSON.(You can use jsawk or any language library you prefer to parse the JSON.)

azure group show myResourceGroup --json | jq '.'

Output:Output:

{
  "tags": {},
  "id": "/subscriptions/guid/resourceGroups/myResourceGroup",
  "name": "myResourceGroup",
  "provisioningState": "Succeeded",
  "location": "westeurope",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "resources": [
    {
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/mystorageaccount",
      "name": "mystorageaccount",
      "type": "storageAccounts",
      "location": "westeurope",
      "tags": null
    }
  ],
  "permissions": [
    {
      "actions": [
        "*"
      ],
      "notActions": []
    }
  ]
}

Per esaminare l'account di archiviazione usando l'interfaccia della riga di comando, è necessario innanzitutto impostare le chiavi e i nomi dell'account.To investigate the storage account by using the CLI, you first need to set the account names and keys. Sostituire il nome dell'account di archiviazione nell'esempio seguente con un nome a scelta:Replace the name of the storage account in the following example with a name that you choose:

export AZURE_STORAGE_CONNECTION_STRING="$(azure storage account connectionstring show mystorageaccount --resource-group myResourceGroup --json | jq -r '.string')"

Dopodiché è possibile visualizzare facilmente le informazioni di archiviazione:Then you can view your storage information easily:

azure storage container list

Output:Output:

info:    Executing command storage container list
+ Getting storage containers
data:    Name  Public-Access  Last-Modified
data:    ----  -------------  -----------------------------
data:    vhds  Off            Sun, 27 Sep 2015 19:03:54 GMT
info:    storage container list command OK

Creare una rete virtuale e una subnetCreate a virtual network and subnet

Dopodiché è necessario creare una rete virtuale che funziona in Azure e una subnet in cui poter creare le VM.Next you're going to need to create a virtual network running in Azure and a subnet in which you can create your VMs. Nell'esempio seguente viene creata una rete virtuale chiamata myVnet con il prefisso dell'indirizzo 192.168.0.0/16:The following example creates a virtual network named myVnet with the 192.168.0.0/16 address prefix:

azure network vnet create --resource-group myResourceGroup --location westeurope \
  --name myVnet --address-prefixes 192.168.0.0/16

Output:Output:

info:    Executing command network vnet create
+ Looking up virtual network "myVnet"
+ Creating virtual network "myVnet"
+ Loading virtual network state
data:    Id                              : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet
data:    Name                            : myVnet
data:    Type                            : Microsoft.Network/virtualNetworks
data:    Location                        : westeurope
data:    ProvisioningState               : Succeeded
data:    Address prefixes:
data:      192.168.0.0/16
info:    network vnet create command OK

Anche in questo caso osservare come vengono realizzate le risorse mediante l'opzione --json di azure group show e jq.Again, let's use the --json option of azure group show and jq to see how we're building our resources. Ora sono disponibili una risorsa storageAccounts e una risorsa virtualNetworks.We now have a storageAccounts resource and a virtualNetworks resource.

azure group show myResourceGroup --json | jq '.'

Output:Output:

{
  "tags": {},
  "id": "/subscriptions/guid/resourceGroups/myResourceGroup",
  "name": "myResourceGroup",
  "provisioningState": "Succeeded",
  "location": "westeurope",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "resources": [
    {
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet",
      "name": "myVnet",
      "type": "virtualNetworks",
      "location": "westeurope",
      "tags": null
    },
    {
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/mystorageaccount",
      "name": "mystorageaccount",
      "type": "storageAccounts",
      "location": "westeurope",
      "tags": null
    }
  ],
  "permissions": [
    {
      "actions": [
        "*"
      ],
      "notActions": []
    }
  ]
}

Viene quindi creata una subnet all'interno della rete virtuale myVnet in cui vengono distribuite le VM.Now let's create a subnet in the myVnet virtual network into which the VMs are deployed. Usare il comando azure network vnet subnet create insieme alle risorse create in precedenza: il gruppo di risorse myResourceGroup e la rete virtuale myVnet.We use the azure network vnet subnet create command, along with the resources we've already created: the myResourceGroup resource group and the myVnet virtual network. Nell'esempio seguente viene aggiunta una subnet chiamata mySubnet con il prefisso dell'indirizzo della subnet 192.168.1.0/24:In the following example, we add the subnet named mySubnet with the subnet address prefix of 192.168.1.0/24:

azure network vnet subnet create --resource-group myResourceGroup \
  --vnet-name myVnet --name mySubnet --address-prefix 192.168.1.0/24

Output:Output:

info:    Executing command network vnet subnet create
+ Looking up the subnet "mySubnet"
+ Creating subnet "mySubnet"
+ Looking up the subnet "mySubnet"
data:    Id                              : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet
data:    Type                            : Microsoft.Network/virtualNetworks/subnets
data:    ProvisioningState               : Succeeded
data:    Name                            : mySubnet
data:    Address prefix                  : 192.168.1.0/24
data:
info:    network vnet subnet create command OK

Dato che la subnet è logicamente all'interno della rete virtuale, le informazioni relative alla subnet vengono cercate con un comando leggermente diverso.Because the subnet is logically inside the virtual network, we look for the subnet information with a slightly different command. Il comando usato è azure network vnet show, ma si continua a esaminare l'output JSON mediante lo strumento jq.The command we use is azure network vnet show, but we continue to examine the JSON output by using jq.

azure network vnet show myResourceGroup myVnet --json | jq '.'

Output:Output:

{
  "subnets": [
    {
      "ipConfigurations": [],
      "addressPrefix": "192.168.1.0/24",
      "provisioningState": "Succeeded",
      "name": "mySubnet",
      "etag": "W/\"974f3e2c-028e-4b35-832b-a4b16ad25eb6\"",
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"
    }
  ],
  "tags": {},
  "addressSpace": {
    "addressPrefixes": [
      "192.168.0.0/16"
    ]
  },
  "dhcpOptions": {
    "dnsServers": []
  },
  "provisioningState": "Succeeded",
  "etag": "W/\"974f3e2c-028e-4b35-832b-a4b16ad25eb6\"",
  "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet",
  "name": "myVnet",
  "location": "westeurope"
}

Creare un indirizzo IP pubblicoCreate a public IP address

A questo punto, creare l'indirizzo IP pubblico (PIP) che viene assegnato al bilanciamento del carico.Now let's create the public IP address (PIP) that we assign to your load balancer. Consente di connettersi alle VM da Internet tramite il comando azure network public-ip create .It enables you to connect to your VMs from the Internet by using the azure network public-ip create command. Dato che l'indirizzo predefinito è dinamico, si crea una voce DNS nel dominio cloudapp.azure.com usando l'opzione --domain-name-label.Because the default address is dynamic, we create a named DNS entry in the cloudapp.azure.com domain by using the --domain-name-label option. Nell'esempio seguente viene aggiunto un indirizzo IP pubblico chiamato myPublicIP con il nome DNS mypublicdns.The following example creates a public IP named myPublicIP with the DNS name of mypublicdns. Il nome DNS deve essere univoco, quindi specificare il proprio nome DNS.Because the DNS name must be unique, you provide your own unique DNS name:

azure network public-ip create --resource-group myResourceGroup \
  --location westeurope --name myPublicIP --domain-name-label mypublicdns

Output:Output:

info:    Executing command network public-ip create
+ Looking up the public ip "myPublicIP"
+ Creating public ip address "myPublicIP"
+ Looking up the public ip "myPublicIP"
data:    Id                              : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIP
data:    Name                            : myPublicIP
data:    Type                            : Microsoft.Network/publicIPAddresses
data:    Location                        : westeurope
data:    Provisioning state              : Succeeded
data:    Allocation method               : Dynamic
data:    Idle timeout                    : 4
data:    Domain name label               : mypublicdns
data:    FQDN                            : mypublicdns.westeurope.cloudapp.azure.com
info:    network public-ip create command OK

Anche l'indirizzo IP pubblico è una risorsa di primo livello che può essere visualizzata con azure group show.The public IP address is also a top-level resource, so you can see it with azure group show.

azure group show myResourceGroup --json | jq '.'

Output:Output:

{
"tags": {},
"id": "/subscriptions/guid/resourceGroups/myResourceGroup",
"name": "myResourceGroup",
"provisioningState": "Succeeded",
"location": "westeurope",
"properties": {
    "provisioningState": "Succeeded"
},
"resources": [
    {
    "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIP",
    "name": "myPublicIP",
    "type": "publicIPAddresses",
    "location": "westeurope",
    "tags": null
    },
    {
    "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet",
    "name": "myVnet",
    "type": "virtualNetworks",
    "location": "westeurope",
    "tags": null
    },
    {
    "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/mystorageaccount",
    "name": "mystorageaccount",
    "type": "storageAccounts",
    "location": "westeurope",
    "tags": null
    }
],
"permissions": [
    {
    "actions": [
        "*"
    ],
    "notActions": []
    }
]
}

È possibile esaminare altri dettagli relativi alla risorsa, incluso il nome di dominio completo (FQDN) del sottodominio, usando il comando azure network public-ip show completo.You can investigate more resource details, including the fully qualified domain name (FQDN) of the subdomain, by using the complete azure network public-ip show command. La risorsa indirizzo IP pubblico è stata allocata in modo logico, ma non è ancora stato assegnato un indirizzo specifico.The public IP address resource has been allocated logically, but a specific address has not yet been assigned. Per ottenere un indirizzo IP, sarà necessario un servizio di bilanciamento del carico, che non è ancora stato creato.To obtain an IP address, you're going to need a load balancer, which we have not yet created.

azure network public-ip show myResourceGroup myPublicIP --json | jq '.'

Output:Output:

{
"tags": {},
"publicIpAllocationMethod": "Dynamic",
"dnsSettings": {
    "domainNameLabel": "mypublicdns",
    "fqdn": "mypublicdns.westeurope.cloudapp.azure.com"
},
"idleTimeoutInMinutes": 4,
"provisioningState": "Succeeded",
"etag": "W/\"c63154b3-1130-49b9-a887-877d74d5ebc5\"",
"id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIP",
"name": "myPublicIP",
"location": "westeurope"
}

Creare un servizio di bilanciamento del carico e i pool di indirizzi IPCreate a load balancer and IP pools

Quando si crea un bilanciamento del carico, questo consente di distribuire il traffico tra più VM.When you create a load balancer, it enables you to distribute traffic across multiple VMs. Fornisce anche ridondanza all'applicazione grazie all'esecuzione di più VM che rispondono alle richieste degli utenti in caso di manutenzione o carichi elevati.It also provides redundancy to your application by running multiple VMs that respond to user requests in the event of maintenance or heavy loads. Nell'esempio seguente viene creato un servizio di bilanciamento del carico chiamato myLoadBalancer:The following example creates a load balancer named myLoadBalancer:

azure network lb create --resource-group myResourceGroup --location westeurope \
  --name myLoadBalancer

Output:Output:

info:    Executing command network lb create
+ Looking up the load balancer "myLoadBalancer"
+ Creating load balancer "myLoadBalancer"
data:    Id                              : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer
data:    Name                            : myLoadBalancer
data:    Type                            : Microsoft.Network/loadBalancers
data:    Location                        : westeurope
data:    Provisioning state              : Succeeded
info:    network lb create command OK

Il servizio di bilanciamento del carico è piuttosto vuoto, per cui si creeranno alcuni pool di indirizzi IP.Our load balancer is fairly empty, so let's create some IP pools. Si creeranno due pool di indirizzi IP per il servizio di bilanciamento del carico, uno per il front-end e uno per il back-end.We want to create two IP pools for our load balancer, one for the front end and one for the back end. Il pool di IP front-end è visibile pubblicamente.The front-end IP pool is publicly visible. Rappresenta anche il percorso a cui si assegnano i PIP creati in precedenza.It's also the location to which we assign the PIP that we created earlier. Dopodiché, si usa il pool di back-end come un percorso per le VM a cui connettersi.Then we use the back-end pool as a location for our VMs to connect to. In questo modo, il traffico può fluire attraverso il bilanciamento del carico verso le VM.That way, the traffic can flow through the load balancer to the VMs.

Prima di tutto si creerà il pool di indirizzi IP front-end.First, let's create our front-end IP pool. Nell'esempio seguente viene creato un pool di indirizzi IP front-end chiamato myFrontEndPool:The following example creates a front-end pool named myFrontEndPool:

azure network lb frontend-ip create --resource-group myResourceGroup \
  --lb-name myLoadBalancer --public-ip-name myPublicIP \
  --name myFrontEndPool

Output:Output:

info:    Executing command network lb frontend-ip create
+ Looking up the load balancer "myLoadBalancer"
+ Looking up the public ip "myPublicIP"
+ Updating load balancer "myLoadBalancer"
data:    Name                            : myFrontEndPool
data:    Provisioning state              : Succeeded
data:    Private IP allocation method    : Dynamic
data:    Public IP address id            : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIP
info:    network lb mySubnet-ip create command OK

Si noti che è stata usata l'opzione --public-ip-name per passare il valore myPublicIP creato in precedenza.Note how we used the --public-ip-name switch to pass in the myPublicIP that we created earlier. L'assegnazione dell'indirizzo IP pubblico al servizio di bilanciamento del carico consente di raggiungere le VM su Internet.Assigning the public IP address to the load balancer allows you to reach your VMs across the Internet.

Quindi si creerà il secondo pool di indirizzi IP, questa volta per il traffico back-end.Next, let's create our second IP pool, this time for our back-end traffic. Nell'esempio seguente viene creato un pool di indirizzi IP back-end chiamato myBackEndPool:The following example creates a back-end pool named myBackEndPool:

azure network lb address-pool create --resource-group myResourceGroup \
  --lb-name myLoadBalancer --name myBackEndPool

Output:Output:

info:    Executing command network lb address-pool create
+ Looking up the load balancer "myLoadBalancer"
+ Updating load balancer "myLoadBalancer"
data:    Name                            : myBackEndPool
data:    Provisioning state              : Succeeded
info:    network lb address-pool create command OK

Per vedere il servizio di bilanciamento del carico è possibile usare azure network lb show ed esaminare l'output JSON:We can see how our load balancer is doing by looking with azure network lb show and examining the JSON output:

azure network lb show myResourceGroup myLoadBalancer --json | jq '.'

Output:Output:

{
  "etag": "W/\"29c38649-77d6-43ff-ab8f-977536b0047c\"",
  "provisioningState": "Succeeded",
  "resourceGuid": "f1446acb-09ba-44d9-b8b6-849d9983dc09",
  "outboundNatRules": [],
  "inboundNatPools": [],
  "inboundNatRules": [],
  "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer",
  "name": "myLoadBalancer",
  "type": "Microsoft.Network/loadBalancers",
  "location": "westeurope",
  "mySubnetIPConfigurations": [
    {
      "etag": "W/\"29c38649-77d6-43ff-ab8f-977536b0047c\"",
      "name": "myFrontEndPool",
      "provisioningState": "Succeeded",
      "publicIPAddress": {
        "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIP"
      },
      "privateIPAllocationMethod": "Dynamic",
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/mySubnetIPConfigurations/myFrontEndPool"
    }
  ],
  "backendAddressPools": [
    {
      "etag": "W/\"29c38649-77d6-43ff-ab8f-977536b0047c\"",
      "name": "myBackEndPool",
      "provisioningState": "Succeeded",
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool"
    }
  ],
  "loadBalancingRules": [],
  "probes": []
}

Creare le regole NAT per il servizio di bilanciamento del caricoCreate load balancer NAT rules

Affinché il traffico attraversi il servizio di bilanciamento del carico, è necessario creare le regole Network Address Translation (NAT) che specificano le azioni in ingresso o in uscita.To get traffic flowing through our load balancer, we need to create network address translation (NAT) rules that specify either inbound or outbound actions. È possibile specificare il protocollo da usare, quindi eseguire il mapping delle porte esterne alle porte interne desiderate.You can specify the protocol to use, then map external ports to internal ports as desired. Per questo ambiente si creeranno alcune regole che consentono il passaggio di SSH attraverso il servizio di bilanciamento del carico fino alle VM.For our environment, let's create some rules that allow SSH through our load balancer to our VMs. Le porte TCP 4222 e 4223 vengono configurate in modo da puntare alla porta TCP 22 nelle VM, che vengono create successivamente.We set up TCP ports 4222 and 4223 to direct to TCP port 22 on our VMs (which we create later). Nell'esempio seguente viene creata una regola chiamata myLoadBalancerRuleSSH1 per eseguire il mapping della porta TCP 4222 sulla porta 22:The following example creates a rule named myLoadBalancerRuleSSH1 to map TCP port 4222 to port 22:

azure network lb inbound-nat-rule create --resource-group myResourceGroup \
  --lb-name myLoadBalancer --name myLoadBalancerRuleSSH1 \
  --protocol tcp --frontend-port 4222 --backend-port 22

Output:Output:

info:    Executing command network lb inbound-nat-rule create
+ Looking up the load balancer "myLoadBalancer"
warn:    Using default enable floating ip: false
warn:    Using default idle timeout: 4
warn:    Using default mySubnet IP configuration "myFrontEndPool"
+ Updating load balancer "myLoadBalancer"
data:    Name                            : myLoadBalancerRuleSSH1
data:    Provisioning state              : Succeeded
data:    Protocol                        : Tcp
data:    mySubnet port                   : 4222
data:    Backend port                    : 22
data:    Enable floating IP              : false
data:    Idle timeout in minutes         : 4
data:    mySubnet IP configuration id    : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/mySubnetIPConfigurations/myFrontEndPool
info:    network lb inbound-nat-rule create command OK

Ripetere la procedura per la seconda regola NAT per SSH.Repeat the procedure for your second NAT rule for SSH. Nell'esempio seguente viene creata una regola chiamata myLoadBalancerRuleSSH2 per eseguire il mapping della porta TCP 4223 sulla porta 22:The following example creates a rule named myLoadBalancerRuleSSH2 to map TCP port 4223 to port 22:

azure network lb inbound-nat-rule create --resource-group myResourceGroup \
  --lb-name myLoadBalancer --name myLoadBalancerRuleSSH2 --protocol tcp \
  --frontend-port 4223 --backend-port 22

Verrà anche creata una regola NAT per la porta TCP 80 per il traffico Web, collegando la regola ai pool di indirizzi IP.Let's also go ahead and create a NAT rule for TCP port 80 for web traffic, hooking the rule up to our IP pools. Se la regola viene associata a un pool IP, anziché essere associata singolarmente alle VM, è possibile aggiungere o rimuovere le VM dal pool di indirizzi IP.If we hook up the rule to an IP pool, instead of hooking up the rule to our VMs individually, we can add or remove VMs from the IP pool. Il servizio di bilanciamento del carico regola automaticamente il flusso del traffico.The load balancer automatically adjusts the flow of traffic. Nell'esempio seguente viene creata una regola chiamata myLoadBalancerRuleWeb per eseguire il mapping della porta TCP 80 sulla porta 80:The following example creates a rule named myLoadBalancerRuleWeb to map TCP port 80 to port 80:

azure network lb rule create --resource-group myResourceGroup \
  --lb-name myLoadBalancer --name myLoadBalancerRuleWeb --protocol tcp \
  --frontend-port 80 --backend-port 80 --frontend-ip-name myFrontEndPool \
  --backend-address-pool-name myBackEndPool

Output:Output:

info:    Executing command network lb rule create
+ Looking up the load balancer "myLoadBalancer"
warn:    Using default idle timeout: 4
warn:    Using default enable floating ip: false
warn:    Using default load distribution: Default
+ Updating load balancer "myLoadBalancer"
data:    Name                            : myLoadBalancerRuleWeb
data:    Provisioning state              : Succeeded
data:    Protocol                        : Tcp
data:    mySubnet port                   : 80
data:    Backend port                    : 80
data:    Enable floating IP              : false
data:    Load distribution               : Default
data:    Idle timeout in minutes         : 4
data:    mySubnet IP configuration id    : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/mySubnetIPConfigurations/myFrontEndPool
data:    Backend address pool id         : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool
info:    network lb rule create command OK

Creare un probe di integrità per il servizio di bilanciamento del caricoCreate a load balancer health probe

Un probe di integrità verifica periodicamente le VM che si trovano dietro il servizio di bilanciamento del carico per assicurarsi che siano operative e che rispondano alle richieste, come specificato.A health probe periodically checks on the VMs that are behind our load balancer to make sure they're operating and responding to requests as defined. In caso contrario ne viene disabilitata l'operatività per fare in modo che gli utenti non vengano indirizzati a esse.If not, they're removed from operation to ensure that users aren't being directed to them. È possibile definire controlli personalizzati per il probe di integrità, nonché gli intervalli e i valori di timeout.You can define custom checks for the health probe, along with intervals and timeout values. Per altre informazioni sui probe di integrità, vedere Probe di integrità del servizio di bilanciamento del carico.For more information about health probes, see Load Balancer probes. Nell'esempio seguente viene creato un probe di integrità TCP chiamato myHealthProbe:The following example creates a TCP health probed named myHealthProbe:

azure network lb probe create --resource-group myResourceGroup \
  --lb-name myLoadBalancer --name myHealthProbe --protocol "tcp" \
  --interval 15 --count 4

Output:Output:

info:    Executing command network lb probe create
warn:    Using default probe port: 80
+ Looking up the load balancer "myLoadBalancer"
+ Updating load balancer "myLoadBalancer"
data:    Name                            : myHealthProbe
data:    Provisioning state              : Succeeded
data:    Protocol                        : Tcp
data:    Port                            : 80
data:    Interval in seconds             : 15
data:    Number of probes                : 4
info:    network lb probe create command OK

In questo caso è stato specificato un intervallo di 15 secondi per i controlli di integrità.Here, we specified an interval of 15 seconds for our health checks. È consentito un massimo di quattro probe mancati (un minuto) prima che il bilanciamento del carico consideri l'host come non più funzionante.We can miss a maximum of four probes (one minute) before the load balancer considers that the host is no longer functioning.

Verificare il bilanciamento del caricoVerify the load balancer

La configurazione del bilanciamento del carico è completa.Now the load balancer configuration is done. Ecco i passaggi effettuati:Here are the steps you took:

  1. È stato creato un bilanciamento del carico.You created a load balancer.
  2. È stato creato un pool di indirizzi IP front-end a cui è stato assegnato un indirizzo IP pubblico.You created a front-end IP pool and assigned a public IP to it.
  3. È stato creato un pool IP back-end a cui possono connettersi le VM.You created a back-end IP pool that VMs can connect to.
  4. Sono state create le regole NAT che consentono alle macchine virtuali di usare il protocollo SSH per la gestione, oltre a una regola che consente all'app Web di usare la porta TCP 80.You created NAT rules that allow SSH to the VMs for management, along with a rule that allows TCP port 80 for our web app.
  5. È stato aggiunto un probe di integrità per verificare periodicamente lo stato delle VM.You added a health probe to periodically check the VMs. Questo probe di integrità garantisce agli utenti di accedere solo alle VM non più funzionanti o con contenuti non più disponibili.This health probe ensures that users don't try to access a VM that is no longer functioning or serving content.

Ecco il bilanciamento del carico risultante:Let's review what your load balancer looks like now:

azure network lb show --resource-group myResourceGroup \
  --name myLoadBalancer --json | jq '.'

Output:Output:

{
  "etag": "W/\"62a7c8e7-859c-48d3-8e76-5e078c5e4a02\"",
  "provisioningState": "Succeeded",
  "resourceGuid": "f1446acb-09ba-44d9-b8b6-849d9983dc09",
  "outboundNatRules": [],
  "inboundNatPools": [],
  "inboundNatRules": [
    {
      "etag": "W/\"62a7c8e7-859c-48d3-8e76-5e078c5e4a02\"",
      "name": "myLoadBalancerRuleSSH1",
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH1",
      "mySubnetIPConfiguration": {
        "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/mySubnetIPConfigurations/myFrontEndPool"
      },
      "protocol": "Tcp",
      "mySubnetPort": 4222,
      "backendPort": 22,
      "idleTimeoutInMinutes": 4,
      "enableFloatingIP": false,
      "provisioningState": "Succeeded"
    },
    {
      "etag": "W/\"62a7c8e7-859c-48d3-8e76-5e078c5e4a02\"",
      "name": "myLoadBalancerRuleSSH2",
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH2",
      "mySubnetIPConfiguration": {
        "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/mySubnetIPConfigurations/myFrontEndPool"
      },
      "protocol": "Tcp",
      "mySubnetPort": 4223,
      "backendPort": 22,
      "idleTimeoutInMinutes": 4,
      "enableFloatingIP": false,
      "provisioningState": "Succeeded"
    }
  ],
  "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer",
  "name": "myLoadBalancer",
  "type": "Microsoft.Network/loadBalancers",
  "location": "westeurope",
  "mySubnetIPConfigurations": [
    {
      "etag": "W/\"62a7c8e7-859c-48d3-8e76-5e078c5e4a02\"",
      "name": "myFrontEndPool",
      "provisioningState": "Succeeded",
      "publicIPAddress": {
        "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/publicIPAddresses/myPublicIP"
      },
      "privateIPAllocationMethod": "Dynamic",
      "loadBalancingRules": [
        {
          "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/loadBalancingRules/myLoadBalancerRuleWeb"
        }
      ],
      "inboundNatRules": [
        {
          "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH1"
        },
        {
          "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH2"
        }
      ],
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/mySubnetIPConfigurations/myFrontEndPool"
    }
  ],
  "backendAddressPools": [
    {
      "etag": "W/\"62a7c8e7-859c-48d3-8e76-5e078c5e4a02\"",
      "name": "myBackEndPool",
      "provisioningState": "Succeeded",
      "loadBalancingRules": [
        {
          "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/loadBalancingRules/myLoadBalancerRuleWeb"
        }
      ],
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool"
    }
  ],
  "loadBalancingRules": [
    {
      "etag": "W/\"62a7c8e7-859c-48d3-8e76-5e078c5e4a02\"",
      "name": "myLoadBalancerRuleWeb",
      "provisioningState": "Succeeded",
      "enableFloatingIP": false,
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/loadBalancingRules/myLoadBalancerRuleWeb",
      "mySubnetIPConfiguration": {
        "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/mySubnetIPConfigurations/myFrontEndPool"
      },
      "backendAddressPool": {
        "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool"
      },
      "protocol": "Tcp",
      "loadDistribution": "Default",
      "mySubnetPort": 80,
      "backendPort": 80,
      "idleTimeoutInMinutes": 4
    }
  ],
  "probes": [
    {
      "etag": "W/\"62a7c8e7-859c-48d3-8e76-5e078c5e4a02\"",
      "name": "myHealthProbe",
      "provisioningState": "Succeeded",
      "numberOfProbes": 4,
      "intervalInSeconds": 15,
      "port": 80,
      "protocol": "Tcp",
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/probes/myHealthProbe"
    }
  ]
}

Creare una scheda di interfaccia di rete da usare con la VM di LinuxCreate an NIC to use with the Linux VM

Le schede di interfaccia di rete sono disponibili a livello di programmazione in quanto è possibile applicare delle regole di utilizzo.NICs are programmatically available because you can apply rules to their use. È inoltre possibile averne più di una.You can also have more than one. Nel comando azure network nic create seguente la scheda di interfaccia di rete viene associata al pool di indirizzi IP back-end del carico e alla regola NAT per consentire il traffico SSH.In the following azure network nic create command, you hook up the NIC to the load back-end IP pool and associate it with the NAT rule to permit SSH traffic.

Sostituire le sezioni #####-###-### con il proprio ID sottoscrizione di Azure.Replace the #####-###-### sections with your own Azure subscription ID. L'ID sottoscrizione è indicato nell'output di jq quando si esaminano le risorse che si sta creando.Your subscription ID is noted in the output of jq when you examine the resources you are creating. È anche possibile visualizzare l'ID sottoscrizione con azure account list.You can also view your subscription ID with azure account list.

Nell'esempio seguente viene creata una scheda di interfaccia di rete chiamata myNic1:The following example creates a NIC named myNic1:

azure network nic create --resource-group myResourceGroup --location westeurope \
  --subnet-vnet-name myVnet --subnet-name mySubnet --name myNic1 \
  --lb-address-pool-ids /subscriptions/########-####-####-####-############/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool \
  --lb-inbound-nat-rule-ids /subscriptions/########-####-####-####-############/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH1

Output:Output:

info:    Executing command network nic create
+ Looking up the subnet "mySubnet"
+ Looking up the network interface "myNic1"
+ Creating network interface "myNic1"
data:    Id                              : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/myNic1
data:    Name                            : myNic1
data:    Type                            : Microsoft.Network/networkInterfaces
data:    Location                        : westeurope
data:    Provisioning state              : Succeeded
data:    Enable IP forwarding            : false
data:    IP configurations:
data:      Name                          : Nic-IP-config
data:      Provisioning state            : Succeeded
data:      Private IP address            : 192.168.1.4
data:      Private IP allocation method  : Dynamic
data:      Subnet                        : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet
data:      Load balancer backend address pools:
data:        Id                          : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool
data:      Load balancer inbound NAT rules:
data:        Id                          : /subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH1
data:
info:    network nic create command OK

È possibile visualizzare i dettagli esaminando la risorsa direttamente.You can see the details by examining the resource directly. La risorsa viene esaminata con il comando azure network nic show :You examine the resource by using the azure network nic show command:

azure network nic show myResourceGroup myNic1 --json | jq '.'

Output:Output:

{
  "etag": "W/\"fc1eaaa1-ee55-45bd-b847-5a08c7f4264a\"",
  "provisioningState": "Succeeded",
  "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/myNic1",
  "name": "myNic1",
  "type": "Microsoft.Network/networkInterfaces",
  "location": "westeurope",
  "ipConfigurations": [
    {
      "etag": "W/\"fc1eaaa1-ee55-45bd-b847-5a08c7f4264a\"",
      "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/myNic1/ipConfigurations/Nic-IP-config",
      "loadBalancerBackendAddressPools": [
        {
          "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool"
        }
      ],
      "loadBalancerInboundNatRules": [
        {
          "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH1"
        }
      ],
      "privateIPAddress": "192.168.1.4",
      "privateIPAllocationMethod": "Dynamic",
      "subnet": {
        "id": "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet"
      },
      "provisioningState": "Succeeded",
      "name": "Nic-IP-config"
    }
  ],
  "dnsSettings": {
    "appliedDnsServers": [],
    "dnsServers": []
  },
  "enableIPForwarding": false,
  "resourceGuid": "a20258b8-6361-45f6-b1b4-27ffed28798c"
}

Ora è possibile creare la seconda scheda di interfaccia di rete, collegandola di nuovo al pool IP back-end.Now we create the second NIC, hooking in to our back-end IP pool again. Questa volta la seconda regola NAT consente il traffico SSH.This time the second NAT rule permits SSH traffic. Nell'esempio seguente viene creata una scheda di interfaccia di rete chiamata myNic2:The following example creates a NIC named myNic2:

azure network nic create --resource-group myResourceGroup --location westeurope \
  --subnet-vnet-name myVnet --subnet-name mySubnet --name myNic2 \
  --lb-address-pool-ids  /subscriptions/########-####-####-####-############/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/backendAddressPools/myBackEndPool \
  --lb-inbound-nat-rule-ids /subscriptions/########-####-####-####-############/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/myLoadBalancer/inboundNatRules/myLoadBalancerRuleSSH2

Creare un gruppo di sicurezza di rete e le regole corrispondentiCreate a network security group and rules

Vengono ora creati il gruppo di sicurezza di rete e le regole in ingresso che regolano l'accesso alla scheda di interfaccia di rete.Now we create a network security group and the inbound rules that govern access to the NIC. Per una scheda di interfaccia di rete o una subnet è possibile usare un gruppo di sicurezza di rete.A network security group can be applied to a NIC or subnet. Si definiscono regole per controllare il flusso del traffico da e verso le VM.You define rules to control the flow of traffic in and out of your VMs. Nell'esempio seguente viene creato un gruppo di sicurezza di rete denominato myNetworkSecurityGroup:The following example creates a network security group named myNetworkSecurityGroup:

azure network nsg create --resource-group myResourceGroup --location westeurope \
  --name myNetworkSecurityGroup

Si aggiungerà la regola in ingresso per il gruppo di sicurezza di rete per consentire le connessioni in ingresso sulla porta 22 (per supportare SSH).Let's add the inbound rule for the NSG to allow inbound connections on port 22 (to support SSH). Nell'esempio seguente viene creata una regola denominata myNetworkSecurityGroupRuleSSH per consentire il traffico TCP sulla porta 22:The following example creates a rule named myNetworkSecurityGroupRuleSSH to allow TCP on port 22:

azure network nsg rule create --resource-group myResourceGroup \
  --nsg-name myNetworkSecurityGroup --protocol tcp --direction inbound \
  --priority 1000 --destination-port-range 22 --access allow \
  --name myNetworkSecurityGroupRuleSSH

Si aggiungerà la regola in ingresso per il gruppo di sicurezza di rete per consentire le connessioni in ingresso sulla porta 80 (per supportare il traffico Web).Now let's add the inbound rule for the NSG to allow inbound connections on port 80 (to support web traffic). Nell'esempio seguente viene creata una regola denominata myNetworkSecurityGroupRuleHTTP per consentire il traffico TCP sulla porta 80:The following example creates a rule named myNetworkSecurityGroupRuleHTTP to allow TCP on port 80:

azure network nsg rule create --resource-group myResourceGroup \
  --nsg-name myNetworkSecurityGroup --protocol tcp --direction inbound \
  --priority 1001 --destination-port-range 80 --access allow \
  --name myNetworkSecurityGroupRuleHTTP

Nota

La regola in ingresso è un filtro per le connessioni di rete in ingresso.The inbound rule is a filter for inbound network connections. In questo esempio il gruppo di sicurezza di rete viene associato alla scheda di rete virtuale delle VM, di conseguenza qualsiasi richiesta per la porta 22 viene passata alla scheda di rete nella VM.In this example, we bind the NSG to the VMs virtual NIC, which means that any request to port 22 is passed through to the NIC on our VM. Questa regola è relativa alla connessione di rete anziché all'endpoint, come invece sarebbe nelle distribuzioni classiche.This inbound rule is about a network connection, and not about an endpoint, which is what it would be about in classic deployments. Per aprire una porta, è necessario lasciare --source-port-range impostato su '*' (valore predefinito) per accettare le richieste in ingresso da qualsiasi porta richiedente.To open a port, you must leave the --source-port-range set to '*' (the default value) to accept inbound requests from any requesting port. Le porte sono solitamente dinamiche.Ports are typically dynamic.

Associare alla scheda di reteBind to the NIC

Associare il gruppo di sicurezza di rete alle schede di interfaccia di rete.Bind the NSG to the NICs. È necessario connettere le schede di interfaccia di rete al gruppo di sicurezza di rete.We need to connect our NICs with our network security group. Eseguire entrambi i comandi per collegare entrambe le schede di interfaccia di rete:Run both commands, to hook up both of our NICs:

azure network nic set --resource-group myResourceGroup --name myNic1 \
  --network-security-group-name myNetworkSecurityGroup
azure network nic set --resource-group myResourceGroup --name myNic2 \
  --network-security-group-name myNetworkSecurityGroup

Creare un set di disponibilitàCreate an availability set

I set di disponibilità agevolano la distribuzione delle VM nei domini di errore e domini di aggiornamento.Availability sets help spread your VMs across fault domains and upgrade domains. Si creerà un set di disponibilità per le VM.Let's create an availability set for your VMs. Nell'esempio seguente viene creato un set di disponibilità chiamato myAvailabilitySet:The following example creates an availability set named myAvailabilitySet:

azure availset create --resource-group myResourceGroup --location westeurope
  --name myAvailabilitySet

I domini di errore definiscono un gruppo di macchine virtuali che condividono una fonte di alimentazione e uno switch di rete comuni.Fault domains define a grouping of virtual machines that share a common power source and network switch. Per impostazione predefinita, le macchine virtuali configurate nell'ambito di un set di disponibilità vengono suddivise tra un massimo di tre domini di errore.By default, the virtual machines that are configured within your availability set are separated across up to three fault domains. L'idea è che un problema hardware in uno di questi domini di errore non abbia effetto su tutte le VM che eseguono l'app.The idea is that a hardware issue in one of these fault domains does not affect every VM that is running your app. Azure distribuisce automaticamente le VM tra i domini di errore durante il posizionamento in un set di disponibilità.Azure automatically distributes VMs across the fault domains when placing them in an availability set.

I domini di aggiornamento indicano gruppi di macchine virtuali e l'hardware fisico sottostante che possono essere riavviati nello stesso momento.Upgrade domains indicate groups of virtual machines and underlying physical hardware that can be rebooted at the same time. I domini di aggiornamento non vengono necessariamente riavviati in ordine sequenziale durante la manutenzione pianificata, ma ne viene riavviato uno solo alla volta.The order in which upgrade domains are rebooted might not be sequential during planned maintenance, but only one upgrade is rebooted at a time. D nuovo, Azure distribuisce automaticamente le VM tra i domini di aggiornamento durante il posizionamento in un sito di disponibilità.Again, Azure automatically distributes your VMs across upgrade domains when placing them in an availability site.

Per altre informazioni, leggere l'articolo relativo alla gestione della disponibilità delle VM.Read more about managing the availability of VMs.

Creare le VM di LinuxCreate the Linux VMs

Sono state create le risorse di archiviazione e di rete per supportare le VM accessibili tramite Internet.You've created the storage and network resources to support Internet-accessible VMs. Ora è possibile creare quelle VM e proteggerle con una chiave SSH priva di password.Now let's create those VMs and secure them with an SSH key that doesn't have a password. In questo caso, si vuole creare una VM Ubuntu basata sull'LTS più recente.In this case, we're going to create an Ubuntu VM based on the most recent LTS. Per trovare le informazioni sull'immagine si usa azure vm image list, come descritto nell'articolo relativo alla ricerca di immagini di VM di Azure.We locate that image information by using azure vm image list, as described in finding Azure VM images.

È stata selezionata un'immagine utilizzando il comando azure vm image list westeurope canonical | grep LTS.We selected an image by using the command azure vm image list westeurope canonical | grep LTS. In questo caso, si usa canonical:UbuntuServer:16.04.0-LTS:16.04.201608150.In this case, we use canonical:UbuntuServer:16.04.0-LTS:16.04.201608150. Per l'ultimo campo si passa a latest così che in futuro si ottenga sempre la build più recente.For the last field, we pass latest so that in the future we always get the most recent build. La stringa usata è canonical:UbuntuServer:16.04.0-LTS:16.04.201608150.(The string we use is canonical:UbuntuServer:16.04.0-LTS:16.04.201608150).

Il passaggio successivo è già noto a chiunque abbia già creato una coppia di chiavi ssh-rsa pubblica e privata in Linux o Mac usando ssh-keygen -t rsa -b 2048.This next step is familiar to anyone who has already created an ssh rsa public and private key pair on Linux or Mac by using ssh-keygen -t rsa -b 2048. Se non si dispone di alcuna coppia di chiavi del certificato nella directory ~/.ssh , è possibile crearle:If you do not have any certificate key pairs in your ~/.ssh directory, you can create them:

In alternativa, è possibile usare il metodo --admin-password per autenticare le connessioni SSH dopo aver creato la VM.Alternatively, you can use the --admin-password method to authenticate your SSH connections after the VM is created. Di solito, questo metodo risulta essere meno sicuro.This method is typically less secure.

Per creare la VM si dovranno unire tutte le risorse e le informazioni con il comando azure vm create :We create the VM by bringing all our resources and information together with the azure vm create command:

azure vm create \
  --resource-group myResourceGroup \
  --name myVM1 \
  --location westeurope \
  --os-type linux \
  --availset-name myAvailabilitySet \
  --nic-name myNic1 \
  --vnet-name myVnet \
  --vnet-subnet-name mySubnet \
  --storage-account-name mystorageaccount \
  --image-urn canonical:UbuntuServer:16.04.0-LTS:latest \
  --ssh-publickey-file ~/.ssh/id_rsa.pub \
  --admin-username azureuser

Output:Output:

info:    Executing command vm create
+ Looking up the VM "myVM1"
info:    Verifying the public key SSH file: /home/ahmet/.ssh/id_rsa.pub
info:    Using the VM Size "Standard_DS1"
info:    The [OS, Data] Disk or image configuration requires storage account
+ Looking up the storage account mystorageaccount
+ Looking up the availability set "myAvailabilitySet"
info:    Found an Availability set "myAvailabilitySet"
+ Looking up the NIC "myNic1"
info:    Found an existing NIC "myNic1"
info:    Found an IP configuration with virtual network subnet id "/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet" in the NIC "myNic1"
info:    This is an NIC without publicIP configured
info:    The storage URI 'https://mystorageaccount.blob.core.windows.net/' will be used for boot diagnostics settings, and it can be overwritten by the parameter input of '--boot-diagnostics-storage-uri'.
info:    vm create command OK

È possibile connettersi immediatamente alla VM usando le chiavi SSH predefinite.You can connect to your VM immediately by using your default SSH keys. Assicurarsi di specificare la porta appropriata poiché si passa tramite il bilanciamento del carico.Make sure that you specify the appropriate port since we're passing through the load balancer. Per la prima VM impostare la regola NAT per l'inoltro della porta 4222 alla VM.(For our first VM, we set up the NAT rule to forward port 4222 to our VM.)

ssh ops@mypublicdns.westeurope.cloudapp.azure.com -p 4222

Output:Output:

The authenticity of host '[mypublicdns.westeurope.cloudapp.azure.com]:4222 ([xx.xx.xx.xx]:4222)' can't be established.
ECDSA key fingerprint is 94:2d:d0:ce:6b:fb:7f:ad:5b:3c:78:93:75:82:12:f9.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '[mypublicdns.westeurope.cloudapp.azure.com]:4222,[xx.xx.xx.xx]:4222' (ECDSA) to the list of known hosts.
Welcome to Ubuntu 16.04.1 LTS (GNU/Linux 4.4.0-34-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

  Get cloud support with Ubuntu Advantage Cloud Guest:
    http://www.ubuntu.com/business/services/cloud

0 packages can be updated.
0 updates are security updates.

ops@myVM1:~$

Proseguire e creare la seconda VM nello stesso modo:Go ahead and create your second VM in the same manner:

azure vm create \
  --resource-group myResourceGroup \
  --name myVM2 \
  --location westeurope \
  --os-type linux \
  --availset-name myAvailabilitySet \
  --nic-name myNic2 \
  --vnet-name myVnet \
  --vnet-subnet-name mySubnet \
  --storage-account-name mystorageaccount \
  --image-urn canonical:UbuntuServer:16.04.0-LTS:latest \
  --ssh-publickey-file ~/.ssh/id_rsa.pub \
  --admin-username azureuser

Ora è possibile usare il comando azure vm show myResourceGroup myVM1 per esaminare ciò che è stato creato.And you can now use the azure vm show myResourceGroup myVM1 command to examine what you've created. A questo punto le VM Ubuntu sono in esecuzione dietro al bilanciamento del carico in Azure a cui è possibile accedere solo con la coppia di chiavi SSH, dal momento che le password sono disabilitate.At this point, you're running your Ubuntu VMs behind a load balancer in Azure that you can sign into only with your SSH key pair (because passwords are disabled). È possibile installare nginx o httpd, distribuire un'app Web e vedere il traffico passare attraverso il servizio di bilanciamento del carico e dirigersi a entrambe le VM.You can install nginx or httpd, deploy a web app, and see the traffic flow through the load balancer to both of the VMs.

azure vm show --resource-group myResourceGroup --name myVM1

Output:Output:

info:    Executing command vm show
+ Looking up the VM "TestVM1"
+ Looking up the NIC "myNic1"
data:    Id                              :/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1
data:    ProvisioningState               :Succeeded
data:    Name                            :myVM1
data:    Location                        :westeurope
data:    Type                            :Microsoft.Compute/virtualMachines
data:
data:    Hardware Profile:
data:      Size                          :Standard_DS1
data:
data:    Storage Profile:
data:      Image reference:
data:        Publisher                   :canonical
data:        Offer                       :UbuntuServer
data:        Sku                         :16.04.0-LTS
data:        Version                     :latest
data:
data:      OS Disk:
data:        OSType                      :Linux
data:        Name                        :clib45a8b650f4428a1-os-1471973896525
data:        Caching                     :ReadWrite
data:        CreateOption                :FromImage
data:        Vhd:
data:          Uri                       :https://mystorageaccount.blob.core.windows.net/vhds/clib45a8b650f4428a1-os-1471973896525.vhd
data:
data:    OS Profile:
data:      Computer Name                 :myVM1
data:      User Name                     :ops
data:      Linux Configuration:
data:        Disable Password Auth       :true
data:
data:    Network Profile:
data:      Network Interfaces:
data:        Network Interface #1:
data:          Primary                   :true
data:          MAC Address               :00-0D-3A-24-D4-AA
data:          Provisioning State        :Succeeded
data:          Name                      :LmyNic1
data:          Location                  :westeurope
data:
data:    AvailabilitySet:
data:      Id                            :/subscriptions/guid/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/myAvailabilitySet
data:
data:    Diagnostics Profile:
data:      BootDiagnostics Enabled       :true
data:      BootDiagnostics StorageUri    :https://mystorageaccount.blob.core.windows.net/
data:
data:      Diagnostics Instance View:
info:    vm show command OK

Esportare l'ambiente come modelloExport the environment as a template

Dopo aver creato questo ambiente, è possibile creare un ambiente di sviluppo aggiuntivo utilizzando gli stessi parametri oppure creare un ambiente di produzione compatibile?Now that you have built out this environment, what if you want to create an additional development environment with the same parameters, or a production environment that matches it? Azure Resource Manager utilizza i modelli JSON che definiscono tutti i parametri per l'ambiente.Resource Manager uses JSON templates that define all the parameters for your environment. È possibile creare interi ambienti facendo riferimento a questo modello JSON.You build out entire environments by referencing this JSON template. È possibile creare modelli JSON manualmente o esportare un ambiente esistente per creare il modello JSON desiderato:You can build JSON templates manually or export an existing environment to create the JSON template for you:

azure group export --name myResourceGroup

Questo comando crea il file myResourceGroup.json nella directory di lavoro corrente.This command creates the myResourceGroup.json file in your current working directory. Quando si crea un ambiente da questo modello, vengono richiesti i nomi di tutte le risorse, tra cui quelli del servizio di bilanciamento del carico, delle interfacce di rete o delle VM.When you create an environment from this template, you are prompted for all the resource names, including the names for the load balancer, network interfaces, or VMs. È possibile popolare questi nomi nel file del modello aggiungendo i parametri -p o --includeParameterDefaultValue al comando azure group export descritto in precedenza.You can populate these names in your template file by adding the -p or --includeParameterDefaultValue parameter to the azure group export command that was shown earlier. Modificare il modello JSON per specificare i nomi delle risorse, o creare un file parameters.json nel quale vengono specificati i nomi delle risorse.Edit your JSON template to specify the resource names, or create a parameters.json file that specifies the resource names.

Per creare un ambiente in base al modello:To create an environment from your template:

azure group deployment create --resource-group myNewResourceGroup \
  --template-file myResourceGroup.json

Se lo si desidera, è possibile consultare ulteriori informazioni su come eseguire la distribuzione partendo dai modelli.You might want to read more about how to deploy from templates. Ulteriori informazioni su come aggiornare gli ambienti in modo incrementale, utilizzare il file di parametri e accedere ai modelli da un unico percorso di archiviazione.Learn about how to incrementally update environments, use the parameters file, and access templates from a single storage location.

Passaggi successiviNext steps

Ora è possibile iniziare a utilizzare più componenti di rete e VM.Now you're ready to begin working with multiple networking components and VMs. È possibile utilizzare questo ambiente di esempio per compilare l'applicazione utilizzando i componenti principali presentati qui.You can use this sample environment to build out your application by using the core components introduced here.