Partilhar via

Implementar instâncias de contentores numa rede virtual do Azure

  • Artigo

A Rede Virtual do Azure fornece rede segura e privada para seus recursos do Azure e locais. Ao implantar grupos de contêineres em uma rede virtual do Azure, seus contêineres podem se comunicar com segurança com outros recursos na rede virtual.

Este artigo mostra como usar o comando az container create na CLI do Azure para implantar grupos de contêineres em uma nova rede virtual ou em uma rede virtual existente.

Importante

  • As sub-redes devem ser delegadas antes de usar uma rede virtual
  • Antes de implantar grupos de contêineres em redes virtuais, sugerimos verificar a limitação primeiro. Para cenários e limitações de rede, consulte Cenários de rede virtual e recursos para instâncias de contêiner do Azure.
  • A implantação de grupo de contêineres em uma rede virtual está geralmente disponível para contêineres Linux e Windows, na maioria das regiões onde as Instâncias de Contêiner do Azure estão disponíveis. Para obter detalhes, consulte Regiões disponíveis.

Importante

Os perfis de rede foram retirados a partir da versão da 2021-07-01 API. Se estiver a utilizar esta ou uma versão mais recente, ignore quaisquer passos e ações relacionados com perfis de rede.

Os exemplos neste artigo são formatados para o shell Bash. Se preferir outro shell, como PowerShell ou Prompt de Comando, ajuste os caracteres de continuação de linha de acordo.

Pré-requisitos

Definir variáveis de ambiente

O caminho de implantação automatizado usa as seguintes variáveis de ambiente e nomes de recursos ao longo deste guia. Os usuários que passam pelo guia manualmente podem usar suas próprias variáveis e nomes, conforme preferir.

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"

Criar um grupo de recursos

Você precisa de um grupo de recursos para gerenciar todos os recursos usados nos exemplos a seguir. Para criar um grupo de recursos, use az group create:

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

Uma operação bem-sucedida deve produzir resultados semelhantes aos seguintes JSON:

Resultados:

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

Implantar em nova rede virtual

Nota

Se você estiver usando o intervalo de IP da sub-rede /29 para ter apenas 3 endereços IP. Recomendamos sempre ir um intervalo acima (nunca abaixo). Por exemplo, use o intervalo de IP da sub-rede /28 para que você possa ter pelo menos 1 ou mais buffer IP por grupo de contêineres. Ao fazer isso, você pode evitar contêineres presos, não capazes de iniciar, reiniciar ou até mesmo não capazes de parar estados.

Para implantar em uma nova rede virtual e fazer com que o Azure crie os recursos de rede para você automaticamente, especifique o seguinte ao executar az container create:

  • Nome da rede virtual
  • Prefixo de endereço de rede virtual no formato CIDR
  • Nome da sub-rede
  • Prefixo do endereço de sub-rede no formato CIDR

Os prefixos de endereço de rede virtual e sub-rede especificam os espaços de endereço para a rede virtual e a sub-rede, respectivamente. Esses valores são representados na notação CIDR (Roteamento entre Domínios sem Classe), por exemplo 10.0.0.0/16. Para obter mais informações sobre como trabalhar com sub-redes, consulte Adicionar, alterar ou excluir uma sub-rede de rede virtual.

Depois de implantar seu primeiro grupo de contêineres com esse método, você pode implantar na mesma sub-rede especificando os nomes de rede virtual e sub-rede ou o perfil de rede que o Azure cria automaticamente para você. Como o Azure delega a sub-rede às Instâncias de Contêiner do Azure, você pode implantar apenas grupos de contêineres na sub-rede.

Exemplo

O comando az container create a seguir especifica as configurações de uma nova rede virtual e sub-rede. Forneça o nome de um grupo de recursos que foi criado em uma região onde as implantações de grupo de contêineres em uma rede virtual estão disponíveis. Este comando implanta o contêiner público Microsoft aci-helloworld que executa um pequeno servidor Web Node.js que serve uma página da Web estática. Na próxima seção, você implantará um segundo grupo de contêineres na mesma sub-rede e testará a comunicação entre as duas instâncias de contêiner.

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

Uma operação bem-sucedida deve produzir resultados semelhantes aos seguintes JSON:

Resultados:

{
  "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 você implanta em uma nova rede virtual usando esse método, a implantação pode levar alguns minutos enquanto os recursos de rede são criados. Após a implantação inicial, outras implantações de grupo de contêineres na mesma sub-rede são concluídas mais rapidamente.

Implantar na rede virtual existente

Para implantar um grupo de contêineres em uma rede virtual existente:

  1. Crie uma sub-rede dentro de sua rede virtual existente, use uma sub-rede existente na qual um grupo de contêineres já esteja implantado ou use uma sub-rede existente esvaziada de todos os outros recursos e configurações. A sub-rede que você usa para grupos de contêineres pode conter apenas grupos de contêineres. Antes de implantar um grupo de contêineres em uma sub-rede, você deve delegar explicitamente a sub-rede antes do provisionamento. Uma vez delegada, a sub-rede só pode ser utilizada para grupos de contentores. Se tentar implementar recursos que não os grupos de contentores numa sub-rede delegada, a operação falha.
  2. Implante um grupo de contêineres com az container create e especifique um dos seguintes:
    • Nome da rede virtual e nome da sub-rede
    • ID de recurso de rede virtual e ID de recurso de sub-rede, que permite usar uma rede virtual de um grupo de recursos diferente

Implantar usando um arquivo YAML

Você também pode implantar um grupo de contêineres em uma rede virtual existente usando um arquivo YAML, um modelo do Gerenciador de Recursos ou outro método programático, como com o SDK do Python.

Por exemplo, ao usar um arquivo YAML, você pode implantar em uma rede virtual com uma sub-rede delegada às Instâncias de Contêiner do Azure. Especifique as seguintes propriedades:

  • ipAddress: As configurações de endereço IP privado para o grupo de contêineres.
    • ports: As portas a abrir, se houver.
    • protocol: O protocolo (TCP ou UDP) para a porta aberta.
  • subnetIds: As IDs de recursos das sub-redes a serem implantadas em
    • id: A ID do recurso da sub-rede
    • name: O nome da sub-rede

Este YAML cria um grupo de contêineres em sua rede virtual. Insira o nome do grupo de contêineres nos campos de nome e o ID da sub-rede no campo ID da sub-rede. Usamos appcontaineryaml para o nome. Se você precisar encontrar seu ID de sub-rede e não tiver mais acesso às saídas anteriores, poderá usar o comando az container show para visualizá-lo. Procure o id campo em 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

O comando Bash a seguir é para o caminho de implantação automatizada.

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

Implante o grupo de contêineres com o comando az container create , especificando o nome do arquivo YAML para o --file parâmetro:

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

O comando Bash a seguir é para o caminho de implantação automatizada.

rm container-instances-vnet.yaml

Quando a implantação for concluída, execute o comando az container show para exibir seu status:

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

A saída deve ser semelhante ao exemplo abaixo:

Resultados:

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

Demonstrar a comunicação entre instâncias de contêiner

O exemplo a seguir implanta um terceiro grupo de contêineres na mesma sub-rede criada anteriormente. Usando uma imagem Alpine Linux, ele verifica a comunicação entre si e a primeira instância de contêiner.

Nota

Devido ao limite de taxa em vigor para puxar imagens públicas do Docker como o Alpine Linux usado aqui, você pode receber um erro no formulário:

(RegistryErrorResponse) Uma resposta de erro é recebida do registro docker 'index.docker.io'. Repita mais tarde. Código: RegistryErrorResponse Mensagem: Uma resposta de erro é recebida do registro docker 'index.docker.io'. Repita mais tarde.

O comando Bash a seguir é para o caminho de implantação automatizada.

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

Primeiro, obtenha o endereço IP do primeiro grupo de contêineres implantado, o appcontainer:

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

A saída exibe o endereço IP do grupo de contêineres na sub-rede privada. Por exemplo:

Resultados:

10.0.0.4

Agora, defina CONTAINER_GROUP_IP como o IP recuperado com o az container show comando e execute o seguinte az container create comando. Este segundo contêiner, commchecker, executa uma imagem baseada em Linux Alpine e é wget executado no endereço IP da sub-rede privada do primeiro grupo de contêineres.

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

Após a conclusão dessa segunda implantação de contêiner, puxe seus logs para que você possa ver a wget saída do comando executado:

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

Se o segundo contêiner se comunicou com êxito com o primeiro, a saída é semelhante a:

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

A saída de log deve mostrar que wget foi capaz de conectar e baixar o arquivo de índice do primeiro contêiner usando seu endereço IP privado na sub-rede local. O tráfego de rede entre os dois grupos de contêineres permaneceu dentro da rede virtual.

Clean up resources (Limpar recursos)

Se não planeia continuar a utilizar estes recursos, pode eliminá-los para evitar cobranças do Azure. Você pode limpar todos os recursos usados neste guia excluindo o grupo de recursos com o comando az group delete . Uma vez excluídos, esses recursos são irrecuperáveis.

Próximos passos