Condividi tramite

Distribuire le istanze di contenitore in una rete virtuale di Azure

  • Articolo

In Rete virtuale di Azure sono disponibili funzionalità per implementare una rete sicura e privata per le risorse locali e di Azure. Grazie alla distribuzione di gruppi di contenitori in una rete virtuale di Azure, i contenitori possono comunicare in modo sicuro con altre risorse nella rete virtuale.

Questo articolo illustra come usare il comando az container create nell'interfaccia della riga di comando di Azure per distribuire gruppi di contenitori in una nuova rete virtuale o in una rete virtuale esistente.

Importante

  • Le subnet devono essere delegate prima di usare una rete virtuale
  • Prima di distribuire gruppi di contenitori nelle reti virtuali, è consigliabile controllare prima le limitazioni. Per gli scenari di rete e le limitazioni, vedere Scenari e risorse per Istanze di Azure Container.
  • La distribuzione di gruppi di contenitori in una rete virtuale è disponibile a livello generale per i contenitori Linux e Windows, nella maggior parte delle aree in cui è disponibile Istanze di Azure Container. Per informazioni dettagliate, vedere aree disponibili.

Importante

I profili di rete sono stati ritirati a partire dalla versione dell'API 2021-07-01. Se si usa questa o una versione più recente, ignorare i passaggi e le azioni correlati ai profili di rete.

Gli esempi di questo articolo sono formattati per la shell Bash. Se si preferisce un'altra shell, ad esempio PowerShell o il prompt dei comandi, modificare di conseguenza i caratteri di continuazione di riga.

Prerequisiti

Definire le variabili di ambiente

Il percorso di distribuzione automatizzato usa le variabili di ambiente e i nomi delle risorse seguenti in questa guida. Gli utenti che eseguono manualmente la guida possono usare le proprie variabili e nomi come preferito.

export RANDOM_ID="$(openssl rand -hex 3)"
export MY_RESOURCE_GROUP_NAME="myACIResourceGroup$RANDOM_ID"
export MY_VNET_NAME="aci-vnet"
export MY_SUBNET_NAME="aci-subnet"
export MY_SUBNET_ID="/subscriptions/$(az account show --query id --output tsv)/resourceGroups/$MY_RESOURCE_GROUP_NAME/providers/Microsoft.Network/virtualNetworks/$MY_VNET_NAME/subnets/$MY_SUBNET_NAME"
export MY_APP_CONTAINER_NAME="appcontainer"
export MY_COMM_CHECKER_NAME="commchecker"
export MY_YAML_APP_CONTAINER_NAME="appcontaineryaml"

Creare un gruppo di risorse

È necessario un gruppo di risorse per gestire tutte le risorse usate negli esempi seguenti. Per creare un gruppo di risorse usare az group create:

az group create --name $MY_RESOURCE_GROUP_NAME --location eastus

Un'operazione riuscita dovrebbe produrre un output simile al codice JSON seguente:

Risultati:

{
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx/resourceGroups/myACIResourceGroup123abc",
  "location": "abcdef",
  "managedBy": null,
  "name": "myACIResourceGroup123",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Eseguire una distribuzione in una nuova rete virtuale

Nota

Se si usa l'intervallo IP della subnet /29 per avere solo 3 indirizzi IP, si consiglia sempre di andare un intervallo sopra (mai sotto). Ad esempio, usare l'intervallo IP della subnet /28 per avere almeno 1 o più buffer IP per ogni gruppo di contenitori. In questo modo, è possibile evitare contenitori bloccati, non in grado di avviarsi, riavviarsi o persino di arrestare gli stati.

Per eseguire la distribuzione in una nuova rete virtuale e creare automaticamente le risorse di rete per l'utente, specificare quanto segue quando si esegue il comando az container create:

  • Nome della rete virtuale
  • Prefisso dell'indirizzo di rete virtuale in formato CIDR
  • Nome subnet
  • Prefisso dell'indirizzo della subnet in formato CIDR

I prefissi degli indirizzi della rete virtuale e della subnet specificare gli spazi degli indirizzi per la rete virtuale e per la subnet, rispettivamente. Tal valori sono rappresentati nella notazione CIDR (Classless Inter-Domain Routing), ad esempio 10.0.0.0/16. Per altre informazioni sull'uso delle subnet, vedere Aggiungere, modificare o eliminare le subnet di rete virtuale.

Dopo aver distribuito il primo gruppo di contenitori con questo metodo, è possibile eseguire la distribuzione nella stessa subnet, specificando i nomi della rete virtuale e delle subnet o il profilo di rete che Azure crea automaticamente per l'utente. Poiché Azure delega la subnet a Istanze di Azure Container, nella subnet è possibile distribuire solo gruppi di contenitori.

Esempio

Il comando az container create seguente specifica le impostazioni per una nuova rete virtuale e una nuova subnet. Specificare il nome di un gruppo di risorse creato in un'area in cui le distribuzioni di gruppi di contenitori in una rete virtuale sono disponibili. Questo comando distribuisce il contenitore aci-helloworld pubblico di Microsoft, che esegue un server Web Node.js di piccole dimensioni che gestisce una pagina Web statica. Nella sezione successiva viene distribuito un secondo gruppo di contenitori nella stessa subnet e viene testata la comunicazione tra le due istanze di contenitore.

az container create \
  --name $MY_APP_CONTAINER_NAME \
  --resource-group $MY_RESOURCE_GROUP_NAME \
  --image mcr.microsoft.com/azuredocs/aci-helloworld \
  --vnet $MY_VNET_NAME \
  --vnet-address-prefix 10.0.0.0/16 \
  --subnet $MY_SUBNET_NAME \
  --subnet-address-prefix 10.0.0.0/24

Un'operazione riuscita dovrebbe produrre un output simile al codice JSON seguente:

Risultati:

{
  "confidentialComputeProperties": null,
  "containers": [
    {
      "command": null,
      "environmentVariables": [],
      "image": "mcr.microsoft.com/azuredocs/aci-helloworld",
      "instanceView": {
        "currentState": {
          "detailStatus": "",
          "exitCode": null,
          "finishTime": null,
          "startTime": "0000-00-00T00:00:00.000000+00:00",
          "state": "Running"
        },
        "events": [
          {
            "count": 1,
            "firstTimestamp": "0000-00-00T00:00:00+00:00",
            "lastTimestamp": "0000-00-00T00:00:00+00:00",
            "message": "Successfully pulled image \"mcr.microsoft.com/azuredocs/aci-helloworld@sha256:0000000000000000000000000000000000000000000000000000000000000000\"",
            "name": "Pulled",
            "type": "Normal"
          },
          {
            "count": 1,
            "firstTimestamp": "0000-00-00T00:00:00+00:00",
            "lastTimestamp": "0000-00-00T00:00:00+00:00",
            "message": "pulling image \"mcr.microsoft.com/azuredocs/aci-helloworld@sha256:0000000000000000000000000000000000000000000000000000000000000000\"",
            "name": "Pulling",
            "type": "Normal"
          },
          {
            "count": 1,
            "firstTimestamp": "0000-00-00T00:00:00+00:00",
            "lastTimestamp": "0000-00-00T00:00:00+00:00",
            "message": "Started container",
            "name": "Started",
            "type": "Normal"
          }
        ],
        "previousState": null,
        "restartCount": 0
      },
      "livenessProbe": null,
      "name": "appcontainer",
      "ports": [
        {
          "port": 80,
          "protocol": "TCP"
        }
      ],
      "readinessProbe": null,
      "resources": {
        "limits": null,
        "requests": {
          "cpu": 1.0,
          "gpu": null,
          "memoryInGb": 1.5
        }
      },
      "securityContext": null,
      "volumeMounts": null
    }
  ],
  "diagnostics": null,
  "dnsConfig": null,
  "encryptionProperties": null,
  "extensions": null,
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx/resourceGroups/myACIResourceGroup123/providers/Microsoft.ContainerInstance/containerGroups/appcontainer",
  "identity": null,
  "imageRegistryCredentials": null,
  "initContainers": [],
  "instanceView": {
    "events": [],
    "state": "Running"
  },
  "ipAddress": {
    "autoGeneratedDomainNameLabelScope": null,
    "dnsNameLabel": null,
    "fqdn": null,
    "ip": "10.0.0.4",
    "ports": [
      {
        "port": 80,
        "protocol": "TCP"
      }
    ],
    "type": "Private"
  },
  "location": "eastus",
  "name": "appcontainer",
  "osType": "Linux",
  "priority": null,
  "provisioningState": "Succeeded",
  "resourceGroup": "myACIResourceGroup123abc",
  "restartPolicy": "Always",
  "sku": "Standard",
  "subnetIds": [
    {
      "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx/resourceGroups/myACIResourceGroup123/providers/Microsoft.Network/virtualNetworks/aci-vnet/subnets/aci-subnet",
      "name": null,
      "resourceGroup": "myACIResourceGroup123abc"
    }
  ],
  "tags": {},
  "type": "Microsoft.ContainerInstance/containerGroups",
  "volumes": null,
  "zones": null
}

Quando si esegue la distribuzione in una nuova rete virtuale usando questo metodo, la distribuzione può richiedere alcuni minuti per la creazione delle risorse di rete. Dopo la distribuzione iniziale, le distribuzioni di altri gruppi di contenitori nella stessa subnet vengono completate più rapidamente.

Eseguire una distribuzione in una rete virtuale esistente

Per distribuire un gruppo di contenitori in una rete virtuale esistente:

  1. Creare una subnet all'interno della rete virtuale esistente, usare una subnet esistente in cui sia già distribuito un gruppo di contenitori oppure usare una subnet esistente svuotata di tutte le altre risorse e configurazioni. La subnet usata per i gruppi di contenitori può includere solo gruppi di contenitori. Prima di distribuire un gruppo di contenitori in una subnet, è necessario delegare in modo esplicito la subnet prima di effettuare il provisioning. Dopo che è stata delegata, la subnet può essere usata solo per i gruppi di contenitori. Se si prova a distribuire risorse diverse da gruppi di contenitori in una subnet delegata, l'operazione ha esito negativo.
  2. Distribuire un gruppo di contenitori con il comando az container create e specificare uno degli elementi seguenti:
    • Nome della rete virtuale e della subnet
    • ID risorsa di rete virtuale e ID risorsa della subnet, che permette di usare una rete virtuale di un gruppo di risorse diverso

Eseguire la distribuzione con un file YAML

È anche possibile distribuire un gruppo di contenitori in una rete virtuale esistente usando un file YAML, un modello di Resource Manager o un altro metodo programmatico, ad esempio con Python SDK.

Ad esempio, quando si usa un file YAML, è possibile eseguire la distribuzione in una rete virtuale con una subnet delegata a Istanze di Azure Container. Specificare le proprietà seguenti:

  • ipAddress: impostazioni dell'indirizzo IP privato per il gruppo di contenitori.
    • ports: porte da aprire, se presenti.
    • protocol: protocollo (TCP o UDP) per la porta aperta.
  • subnetIds: ID risorsa delle subnet in cui eseguire la distribuzione
    • id: ID risorsa della subnet
    • name: nome della subnet

Questo YAML crea un gruppo di contenitori nella rete virtuale. Immettere il nome del gruppo di contenitori nei campi nome e l'ID subnet nel campo ID subnet. Per il nome viene usato appcontaineryaml . Se è necessario trovare l'ID subnet e non avere più accesso agli output precedenti, è possibile usare il comando az container show per visualizzarlo. Cercare il id campo in subnetIds.

apiVersion: '2021-07-01'
location: eastus
name: appcontaineryaml
properties:
  containers:
  - name: appcontaineryaml
    properties:
      image: mcr.microsoft.com/azuredocs/aci-helloworld
      ports:
      - port: 80
        protocol: TCP
      resources:
        requests:
          cpu: 1.0
          memoryInGB: 1.5
  ipAddress:
    type: Private
    ports:
    - protocol: tcp
      port: '80'
  osType: Linux
  restartPolicy: Always
  subnetIds:
    - id: <subnet_id>
      name: default
tags: null
type: Microsoft.ContainerInstance/containerGroups

Il comando Bash seguente è per il percorso di distribuzione automatizzato.

echo -e "apiVersion: '2021-07-01'\nlocation: eastus\nname: $MY_YAML_APP_CONTAINER_NAME\nproperties:\n  containers:\n  - name: $MY_YAML_APP_CONTAINER_NAME\n    properties:\n      image: mcr.microsoft.com/azuredocs/aci-helloworld\n      ports:\n      - port: 80\n        protocol: TCP\n      resources:\n        requests:\n          cpu: 1.0\n          memoryInGB: 1.5\n  ipAddress:\n    type: Private\n    ports:\n    - protocol: tcp\n      port: '80'\n  osType: Linux\n  restartPolicy: Always\n  subnetIds:\n    - id: $MY_SUBNET_ID\n      name: default\ntags: null\ntype: Microsoft.ContainerInstance/containerGroups" > container-instances-vnet.yaml

Distribuire il gruppo di contenitori con il comando az container create, specificando il nome di file YAML per il parametro --file:

az container create --resource-group $MY_RESOURCE_GROUP_NAME \
  --file container-instances-vnet.yaml

Il comando Bash seguente è per il percorso di distribuzione automatizzato.

rm container-instances-vnet.yaml

Al termine della distribuzione, eseguire il comando az container show per visualizzarne lo stato:

az container list --resource-group $MY_RESOURCE_GROUP_NAME --output table

L'output dovrebbe essere simile all'esempio seguente:

Risultati:

Name              ResourceGroup             Status     Image                                       IP:ports        Network    CPU/Memory       OsType    Location
----------------  ------------------------  ---------  ------------------------------------------  --------------  ---------  ---------------  --------  ----------
appcontainer      myACIResourceGroup123abc  Succeeded  mcr.microsoft.com/azuredocs/aci-helloworld  10.0.0.4:80,80  Private    1.0 core/1.5 gb  Linux     abcdef
appcontaineryaml  myACIResourceGroup123abc  Succeeded  mcr.microsoft.com/azuredocs/aci-helloworld  10.0.0.5:80,80  Private    1.0 core/1.5 gb  Linux     abcdef

Illustrare la comunicazione tra istanze di contenitore

Nell'esempio seguente viene distribuito un terzo gruppo di contenitori nella stessa subnet creata in precedenza. Usando un'immagine Alpine Linux, verifica la comunicazione tra se stessa e la prima istanza del contenitore.

Nota

A causa della limitazione della frequenza per il pull di immagini Docker pubbliche come quella di Alpine Linux usata qui, è possibile che venga visualizzato un errore nel formato:

(RegistryErrorResponse) Viene ricevuta una risposta di errore dal Registro di sistema Docker 'index.docker.io'. Riprovare più tardi. Codice: RegistryErrorResponse Message: viene ricevuta una risposta di errore dal Registro di sistema Docker 'index.docker.io'. Riprovare più tardi.

Il comando Bash seguente è per il percorso di distribuzione automatizzato.

echo -e "Due to rate limiting in effect for pulling public Docker images like the Alpine Linux one used here, you may receive an error in the form:\n\n(RegistryErrorResponse) An error response is received from the docker registry 'index.docker.io'. Please retry later.\nCode: RegistryErrorResponse\nMessage: An error response is received from the docker registry 'index.docker.io'. Please retry later.\n\nIf this occurs, the automated deployment will exit. You can try again or go to the end of the guide to see instructions for cleaning up your resources."

Ottenere per prima cosa l'indirizzo IP del primo gruppo di contenitori distribuito, ovvero appcontainer:

az container show --resource-group $MY_RESOURCE_GROUP_NAME \
  --name $MY_APP_CONTAINER_NAME \
  --query ipAddress.ip --output tsv

L'output visualizza l'indirizzo IP del gruppo di contenitori nella subnet privata. Ad esempio:

Risultati:

10.0.0.4

A questo punto impostare CONTAINER_GROUP_IP sull'indirizzo IP recuperato con il comando az container show ed eseguire il comando az container create seguente. Questo secondo contenitore, commchecker, esegue un'immagine basata su Alpine Linux ed esegue wget sull'indirizzo IP della subnet privata del primo gruppo di contenitori.

az container create \
  --resource-group $MY_RESOURCE_GROUP_NAME \
  --name $MY_COMM_CHECKER_NAME \
  --image alpine:3.4 \
  --command-line "wget 10.0.0.4" \
  --restart-policy never \
  --vnet $MY_VNET_NAME \
  --subnet $MY_SUBNET_NAME

Dopo aver completato la distribuzione del secondo contenitore, eseguire il pull dei log relativi in modo che sia possibile visualizzare l'output del comando wget:

az container logs --resource-group $MY_RESOURCE_GROUP_NAME --name $MY_COMM_CHECKER_NAME

Se il secondo contenitore ha comunicato correttamente con il primo, l'output è simile al seguente:

Connecting to 10.0.0.4 (10.0.0.4:80)
index.html           100% |*******************************|  1663   0:00:00 ETA

L'output del registro illustra che wget è stato in grado di connettersi e scaricare il file di indice dal primo contenitore tramite il relativo indirizzo IP privato nella subnet locale. Il traffico di rete tra i due gruppi di contenitori è rimasto nella rete virtuale.

Pulire le risorse

Se non si prevede di continuare a usare queste risorse, è possibile eliminarle per evitare addebiti di Azure. È possibile pulire tutte le risorse usate in questa guida eliminando il gruppo di risorse con il comando az group delete . Dopo l'eliminazione, tali risorse non sono recuperabili.

Passaggi successivi