Delen via

Containerinstanties implementeren in een virtueel Azure-netwerk

  • Artikel

Azure Virtual Network biedt beveiligde, privénetwerken voor uw Azure- en on-premises resources. Door containergroepen te implementeren in een virtueel Azure-netwerk, kunnen uw containers veilig communiceren met andere resources in het virtuele netwerk.

In dit artikel wordt beschreven hoe u de opdracht az container create in de Azure CLI gebruikt om containergroepen te implementeren in een nieuw virtueel netwerk of een bestaand virtueel netwerk.

Belangrijk

  • Subnetten moeten worden gedelegeerd voordat u een virtueel netwerk gebruikt
  • Voordat u containergroepen in virtuele netwerken implementeert, raden we u aan eerst de beperking te controleren. Zie Scenario's en resources voor virtuele netwerken voor Azure Container Instances voor netwerkscenario's en -beperkingen.
  • Implementatie van containergroepen in een virtueel netwerk is algemeen beschikbaar voor Linux- en Windows-containers, in de meeste regio's waar Azure Container Instances beschikbaar is. Zie beschikbare regio's voor meer informatie.

Belangrijk

Netwerkprofielen zijn buiten gebruik gesteld vanaf de 2021-07-01 API-versie. Als u deze of een recentere versie gebruikt, negeert u alle stappen en acties met betrekking tot netwerkprofielen.

Voorbeelden in dit artikel zijn opgemaakt voor de Bash-shell. Als u de voorkeur geeft aan een andere shell, zoals PowerShell of opdrachtprompt, past u de regelvervolgtekens dienovereenkomstig aan.

Vereisten

Omgevingsvariabelen definiëren

Het geautomatiseerde implementatiepad maakt gebruik van de volgende omgevingsvariabelen en resourcenamen in deze handleiding. Gebruikers die de handleiding doorlopen, kunnen hun eigen variabelen en namen als voorkeur gebruiken.

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"

Een brongroep maken

U hebt een resourcegroep nodig om alle resources te beheren die in de volgende voorbeelden worden gebruikt. Als u een resourcegroep wilt maken, gebruikt u az group create:

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

Een geslaagde bewerking moet uitvoer produceren die vergelijkbaar is met de volgende JSON:

Resultaten:

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

Implementeren in een nieuw virtueel netwerk

Notitie

Als u subnet-IP-adresbereik /29 gebruikt om slechts drie IP-adressen te hebben. we raden u aan altijd één bereik hierboven te gaan (nooit hieronder). Gebruik bijvoorbeeld subnet-IP-bereik /28, zodat u ten minste 1 of meer IP-buffer per containergroep kunt hebben. Als u dit doet, kunt u voorkomen dat containers vastlopen, niet kunnen worden gestart, opnieuw opgestart of zelfs niet in staat zijn om statussen te stoppen.

Als u wilt implementeren in een nieuw virtueel netwerk en Azure automatisch de netwerkbronnen voor u wilt laten maken, geeft u het volgende op wanneer u az container create uitvoert:

  • Naam van virtueel netwerk
  • Adresvoorvoegsel van virtueel netwerk in CIDR-indeling
  • Subnetnaam
  • Subnetadresvoorvoegsel in CIDR-indeling

De voorvoegsels van het virtuele netwerk en subnetadres geven respectievelijk de adresruimten voor het virtuele netwerk en subnet op. Deze waarden worden bijvoorbeeld weergegeven in CIDR-notatie 10.0.0.0/16(Classless Inter-Domain Routing). Zie Een subnet van een virtueel netwerk toevoegen, wijzigen of verwijderen voor meer informatie over het werken met subnetten.

Zodra u uw eerste containergroep met deze methode hebt geïmplementeerd, kunt u deze implementeren in hetzelfde subnet door de namen van het virtuele netwerk en subnet op te geven, of door het netwerkprofiel dat automatisch voor u wordt gemaakt. Omdat Azure het subnet delegeert naar Azure Container Instances, kunt u alleen containergroepen implementeren in het subnet.

Opmerking

Met de volgende opdracht az container create worden instellingen voor een nieuw virtueel netwerk en subnet opgegeven. Geef de naam op van een resourcegroep die is gemaakt in een regio waarin containergroepimplementaties in een virtueel netwerk beschikbaar zijn. Met deze opdracht wordt de openbare Microsoft aci-helloworld-container geïmplementeerd waarop een kleine Node.js webserver wordt uitgevoerd die een statische webpagina biedt. In de volgende sectie implementeert u een tweede containergroep in hetzelfde subnet en test u de communicatie tussen de twee containerinstanties.

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

Een geslaagde bewerking moet uitvoer produceren die vergelijkbaar is met de volgende JSON:

Resultaten:

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

Wanneer u implementeert in een nieuw virtueel netwerk met behulp van deze methode, kan de implementatie enkele minuten duren terwijl de netwerkbronnen worden gemaakt. Na de eerste implementatie worden verdere implementaties van de containergroep naar hetzelfde subnet sneller voltooid.

Implementeren in bestaand virtueel netwerk

Een containergroep implementeren in een bestaand virtueel netwerk:

  1. Maak een subnet in uw bestaande virtuele netwerk, gebruik een bestaand subnet waarin een containergroep al is geïmplementeerd of gebruik een bestaand subnet dat is leeggemaakt van alle andere resources en configuratie. Het subnet dat u voor containergroepen gebruikt, kan alleen containergroepen bevatten. Voordat u een containergroep implementeert in een subnet, moet u het subnet expliciet delegeren voordat u het inricht. Zodra het subnet is gedelegeerd, kan het alleen worden gebruikt voor containergroepen. Als u andere resources dan containergroepen wilt implementeren in een gedelegeerd subnet, mislukt de bewerking.
  2. Implementeer een containergroep met az container create en geef een van de volgende op:
    • Naam van virtueel netwerk en subnetnaam
    • Resource-id en subnetresource-id van virtueel netwerk, waarmee u een virtueel netwerk uit een andere resourcegroep kunt gebruiken

Implementeren met behulp van een YAML-bestand

U kunt ook een containergroep implementeren in een bestaand virtueel netwerk met behulp van een YAML-bestand, een Resource Manager-sjabloon of een andere programmatische methode, zoals met de Python SDK.

Wanneer u bijvoorbeeld een YAML-bestand gebruikt, kunt u implementeren in een virtueel netwerk met een subnet dat is gedelegeerd aan Azure Container Instances. Geef de volgende eigenschappen op:

  • ipAddress: De privé-IP-adresinstellingen voor de containergroep.
    • ports: de poorten die moeten worden geopend, indien van toepassing.
    • protocol: het protocol (TCP of UDP) voor de geopende poort.
  • subnetIds: De resource-id's van de subnetten die moeten worden geïmplementeerd in
    • id: De resource-id van het subnet
    • name: De naam van het subnet

Met deze YAML maakt u een containergroep in uw virtuele netwerk. Voer de naam van de containergroep in de naamvelden en de subnet-id in het veld Subnet-id in. We gebruiken appcontaineryaml voor de naam. Als u de subnet-id wilt vinden en geen toegang meer hebt tot eerdere uitvoer, kunt u de opdracht az container show gebruiken om deze weer te geven. Zoek het id veld onder 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

De volgende Bash-opdracht is voor het geautomatiseerde implementatiepad.

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

Implementeer de containergroep met de opdracht az container create en geef de YAML-bestandsnaam op voor de --file parameter:

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

De volgende Bash-opdracht is voor het geautomatiseerde implementatiepad.

rm container-instances-vnet.yaml

Zodra de implementatie is voltooid, voert u de opdracht az container show uit om de status ervan weer te geven:

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

De uitvoer moet er ongeveer als volgt uitzien:

Resultaten:

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

Communicatie tussen containerinstanties demonstreren

In het volgende voorbeeld wordt een derde containergroep geïmplementeerd in hetzelfde subnet dat u eerder hebt gemaakt. Met behulp van een Alpine Linux-installatiekopieën wordt de communicatie tussen zichzelf en de eerste containerinstantie gecontroleerd.

Notitie

Als gevolg van snelheidsbeperking voor het ophalen van openbare Docker-installatiekopieën zoals alpine Linux die hier worden gebruikt, wordt mogelijk een fout weergegeven in de vorm:

(RegistryErrorResponse) Er wordt een foutbericht ontvangen van het Docker-register 'index.docker.io'. Probeer het later opnieuw. Code: RegistryErrorResponse-bericht: er wordt een foutbericht ontvangen van het Docker-register 'index.docker.io'. Probeer het later opnieuw.

De volgende Bash-opdracht is voor het geautomatiseerde implementatiepad.

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

Haal eerst het IP-adres op van de eerste containergroep die u hebt geïmplementeerd, de appcontainer:

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

In de uitvoer wordt het IP-adres van de containergroep in het privésubnet weergegeven. Voorbeeld:

Resultaten:

10.0.0.4

Stel nu in CONTAINER_GROUP_IP op het IP-adres dat u hebt opgehaald met de az container show opdracht en voer de volgende az container create opdracht uit. Met deze tweede container, commchecker, wordt een installatiekopie op basis van Alpine Linux uitgevoerd en uitgevoerd wget op basis van het privé-subnet-IP-adres van de eerste containergroep.

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

Nadat deze tweede containerimplementatie is voltooid, haalt u de logboeken op, zodat u de uitvoer kunt zien van de wget opdracht die wordt uitgevoerd:

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

Als de tweede container is gecommuniceerd met de eerste, is de uitvoer vergelijkbaar met:

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

In de logboekuitvoer moet worden aangegeven dat wget het indexbestand kan worden verbonden en gedownload uit de eerste container met behulp van het privé-IP-adres op het lokale subnet. Netwerkverkeer tussen de twee containergroepen bleef binnen het virtuele netwerk.

Resources opschonen

Als u niet van plan bent om deze resources te blijven gebruiken, kunt u ze verwijderen om Azure-kosten te voorkomen. U kunt alle resources die u in deze handleiding hebt gebruikt, opschonen door de resourcegroep te verwijderen met de opdracht az group delete . Zodra deze resources zijn verwijderd, kunnen deze resources niet meer worden hersteld.

Volgende stappen