Compartilhar via

Implantar instâncias de contêiner em uma rede virtual do Azure

  • Artigo

A Rede Virtual do Azure fornece uma rede privada segura para seus recursos locais e do Azure. Implantando grupos de contêineres em uma rede virtual do Azure, os 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 precisam ser delegadas antes de usar uma rede virtual
  • Antes de implantar grupos de contêineres em redes virtuais, sugerimos primeiro verificar a limitação. Para cenários de rede e limitações, consulte Cenários e recursos de rede virtual 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 descontinuados na versão 2021-07-01 da API. Se você estiver usando essa ou uma versão mais recente, ignore as etapas e ações relacionadas aos perfis de rede.

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

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 seguirem o guia manualmente poderão usar suas próprias variáveis e nomes de acordo com sua preferência.

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 deverá produzir uma saída semelhante ao seguinte 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 uma rede virtual nova

Observação

Se estiver usando o intervalo de IP da sub-rede /29 para ter apenas 3 endereços IP, recomendamos sempre ir para um intervalo acima (nunca abaixo). Por exemplo, use o intervalo de IP da sub-rede /28 para poder ter no mínimo 1 ou mais buffers de IP por grupo de contêineres. Ao fazer isso, você conseguirá evitar contêineres nos estados emperrado, incapaz de iniciar, reiniciar ou mesmo incapaz de parar.

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

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

Os prefixos do endereço da rede virtual e da 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 da 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 da rede virtual e da sub-rede ou o perfil de rede que o Azure cria automaticamente para você. Como o Azure delega a sub-rede para Instâncias de Contêiner do Azure, é possível implantar apenas grupos de contêineres na sub-rede.

Exemplo

O comando az container create a seguir especifica as configurações para 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. Esse comando implanta o contêiner aci-helloworld da Microsoft público, que executa um servidor da Web Node.js pequeno que atende a 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 deverá produzir uma saída semelhante ao seguinte 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 demorar alguns minutos enquanto os recursos de rede são criados. Após a implantação inicial, as implantações adicionais do grupo de contêineres para a mesma sub-rede são concluídas mais rapidamente.

Implantar em uma rede virtual existente

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

  1. Crie uma sub-rede em 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 nos grupos de contêineres poderá conter somente 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. Depois de delegada, a sub-rede pode ser usada apenas para grupos de contêineres. Se você tentar implantar recursos diferentes de grupos de contêineres em uma sub-rede delegada, a operação falhará.
  2. Implante um grupo de contêineres com az container create e especifique um dos seguintes itens:
    • 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 Resource Manager 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 para Instâncias de Contêiner do Azure. Especifique as seguintes propriedades:

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

Esse YAML cria um grupo de contêineres em sua rede virtual. Insira o nome do seu grupo de contêineres nos campos de nome e a ID da sua sub-rede no campo de ID da sub-rede. Nós usamos appcontaineryaml como nome. Se precisar encontrar sua ID de sub-rede e não tiver mais acesso a saídas anteriores, você poderá usar o comando az container show para vê-la. Procure o campo id 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 se destina ao caminho de implantação automatizado.

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 parâmetro --file:

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

O comando Bash a seguir se destina ao caminho de implantação automatizado.

rm container-instances-vnet.yaml

Após a implantação ser concluída, execute o comando az container show para exibir o respectivo status:

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

A saída deve ser semelhante à amostra 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 do Alpine Linux, verifica a comunicação entre ele mesmo e a primeira instância de contêiner.

Observação

Devido à limitação de taxa em vigor para efetuar pull de imagens públicas do Docker como a do Alpine Linux que usamos aqui, você talvez receba um erro no formulário:

(RegistryErrorResponse) Uma resposta de erro foi recebida do registro do Docker "index.docker.io". Tente novamente mais tarde. Código: Mensagem RegistryErrorResponse: Uma resposta de erro foi recebida do registro do Docker "index.docker.io". Tente novamente mais tarde.

O comando Bash a seguir se destina ao caminho de implantação automatizado.

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

Primeiramente, obtenha o endereço IP do primeiro grupo de contêineres que você implantou, 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 comando az container show e execute o seguinte comando az container create. Esse segundo contêiner, commchecker, executa uma imagem com base em Linux Alpine e executa wget em relação ao 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, extraia seus logs para que você possa ver a saída do comando wget executado por ele:

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

Se o segundo contêiner tiver se comunicado com êxito com o primeiro, a saída será 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 conseguiu se 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.

Limpar os recursos

Se você não estiver planejando continuar usando esses recursos, poderá excluí-los para evitar cobranças do Azure. Você pode limpar todos os recursos que usou neste guia ao excluir o grupo de recursos com o comando az group delete. Depois de excluídos, esses recursos são irrecuperáveis.

Próximas etapas