Compartir a través de

Implementación de instancias de contenedor en una red virtual de Azure

  • Artículo

Azure Virtual Network proporciona acceso de red seguro y privado a los recursos locales y de Azure. Al implementar grupos de contenedores en una red virtual de Azure, los contenedores pueden comunicarse de forma segura con otros recursos de la red virtual.

En este artículo se muestra cómo usar el comando az container create en la CLI de Azure para implementar grupos de contenedores en una red virtual nueva o existente.

Importante

  • Las subredes deben delegarse antes de usar una red virtual
  • Antes de implementar grupos de contenedores en redes virtuales, se recomienda comprobar primero la limitación. Para conocer los escenarios y las limitaciones de red, consulte Escenarios y recursos de redes virtuales para Azure Container Instances.
  • La implementación del grupo de contenedores en una red virtual está disponible con carácter general para contenedores de Linux y Windows en la mayoría de las regiones donde Azure Container Instances está disponible. Para obtener más información, consulte las regiones disponibles.

Importante

Los perfiles de red han quedado en desuso desde la versión 2021-07-01 de la API. Si usa esta versión o una versión más reciente, omita los pasos y las acciones relacionados con los perfiles de red.

Los ejemplos que aparecen en este artículo están formateados para el shell de Bash. Si prefiere otro shell como PowerShell o el símbolo del sistema, ajuste los caracteres de continuación de línea según corresponda.

Requisitos previos

Definición de las variables de entorno

La ruta de implementación automatizada usa las siguientes variables de entorno y nombres de recursos en esta guía. Los usuarios que continúan a través de la guía manualmente pueden usar sus propias variables y nombres como prefiera.

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"

Crear un grupo de recursos

Necesita un grupo de recursos para administrar todos los recursos usados en los ejemplos siguientes. Para crear un grupo de recursos, use az group create:

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

Una operación correcta debe generar una salida similar a la siguiente 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"
}

Implementación en una nueva red virtual

Nota:

Si usa el intervalo IP de subred /29 para tener solo 3 direcciones IP. se recomienda ir siempre un intervalo por encima (nunca por debajo). Por ejemplo, use el intervalo IP de subred /28 para que pueda tener al menos 1 o más búferes de IP por grupo de contenedores. Al hacerlo, puede evitar que los contenedores se bloqueen, no puedan iniciarse, reiniciarse o tampoco puedan detener los estados.

Para implementarlos en una nueva red virtual y hacer que Azure cree automáticamente los recursos de red, especifique lo siguiente al ejecutar az container create:

  • Nombre de la red virtual
  • Prefijo de dirección de red virtual en formato CIDR
  • Nombre de subred
  • Prefijo de dirección de subred en formato CIDR

Los prefijos de direcciones de subred y red virtual especifican los espacios de direcciones para la subred y la red virtual, respectivamente. Estos valores se representan en notación de Enrutamiento de interdominios sin clases (CIDR), por ejemplo 10.0.0.0/16. Para más información sobre cómo trabajar con las subredes, consulte Incorporación, cambio o eliminación de una subred de red virtual.

Cuando implemente el primer grupo de contenedores con este método, puede implementarlo en la misma subred; para ello, especifique los nombres de la red virtual y la subred, o el perfil de red que Azure crea automáticamente para usted. Dado que Azure delega la subred en Azure Container Instances, solo puede implementar grupos de contenedores en la subred.

Ejemplo

El comando az container create siguiente especifica valores para una nueva red virtual y una subred. Proporcione el nombre de un grupo de recursos creado en una región en la que haya disponibles implementaciones de grupo de contenedores en una red virtual. Este comando implementa el contenedor aci-helloworld público de Microsoft que ejecuta un pequeño servidor web de Node.js que sirve una página web estática. En la siguiente sección, implementará un segundo grupo de contenedores en la misma subred y probará la comunicación entre las dos instancias de contenedor.

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

Una operación correcta debe generar una salida similar a la siguiente 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
}

Al implementar en una nueva red virtual mediante este método, la implementación puede tardar unos minutos mientras se crean los recursos de red. Tras la implementación inicial, las implementaciones de grupos de contenedores adicionales en la misma subred se completan más rápido.

Implementación en una red virtual existente

Para implementar un grupo de contenedores en una red virtual existente:

  1. Cree una subred en la red virtual existente, use una subred existente en la que ya se haya implementado un grupo de contenedores, o bien use una subred existente vacía de todos los demás recursos y configuración. La subred que usó para los grupos de contenedores puede contener solo grupos de contenedores. Antes de implementar un grupo de contenedores en una subred, debe delegar explícitamente la subred antes del aprovisionamiento. Una vez delegada, la subred se puede usar solo para grupos de contenedores. Si intenta implementar recursos distintos de grupos de contenedores en una subred delegada, se produce un error en la operación.
  2. Implemente un grupo de contenedores con az container create y especifique uno de los siguientes:
    • Nombre de red virtual y nombre de subred
    • El identificador de recurso de red virtual y el identificador de recurso de subred, lo permite usar una red virtual desde otro grupo de recursos

Implementación mediante un archivo YAML

También puede implementar un grupo de contenedores en una red virtual existente mediante un archivo YAML, una plantilla de Resource Manager u otro método de programación como con el SDK de Python.

Por ejemplo, si usa un archivo YAML, puede realizar la implementación en una red virtual con una subred delegada en Azure Container Instances. Especifique las propiedades siguientes:

  • ipAddress: la configuración de direcciones IP privadas para el grupo de contenedores.
    • ports: los puertos que deben abrirse, si hay alguno.
    • protocol: el protocolo (TCP o UDP) para el puerto abierto.
  • subnetIds: identificadores de recursos de las subredes en las que se va a implementar
    • id: identificador de recurso de la subred
    • name: nombre de la subred

Este YAML crea un grupo de contenedores en la red virtual. Escriba el nombre del grupo de contenedores en los campos de nombre y el identificador de subred en el campo Id. de subred. Usamos appcontaineryaml para el nombre. Si necesita encontrar el identificador de subred y ya no tiene acceso a las salidas anteriores, puede usar el comando az container show para verlo. Busque el campo id en 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

El siguiente comando de Bash es para la ruta de implementación 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

Implemente el grupo de contenedores con el comando az container create y especifique el nombre del archivo YAML para el parámetro --file:

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

El siguiente comando de Bash es para la ruta de implementación automatizada.

rm container-instances-vnet.yaml

Una vez completada la implementación, ejecute el comando az container show para mostrar su estado:

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

La salida debe ser similar al ejemplo siguiente:

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

Demostración de la comunicación entre instancias de contenedor

En el ejemplo siguiente se implementa un tercer grupo de contenedores en la misma subred creada anteriormente. Con una imagen de Alpine Linux, comprueba la comunicación entre sí y la primera instancia de contenedor.

Nota:

Debido a la limitación de velocidad en vigor para extraer imágenes públicas de Docker como la instancia de Alpine Linux que se usa aquí, puede recibir un error en el formulario:

(RegistryErrorResponse) Se recibe una respuesta de error del registro de Docker "index.docker.io". Inténtelo de nuevo más tarde. Código: RegistryErrorResponse Message: se recibe una respuesta de error del registro de Docker "index.docker.io". Inténtelo de nuevo más tarde.

El siguiente comando de Bash es para la ruta de implementación 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."

En primer lugar, obtenga la dirección IP del primer grupo de contenedores que implementó, appcontainer:

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

La salida muestra la dirección IP del grupo de contenedores en la subred privada. Por ejemplo:

Resultados:

10.0.0.4

Ahora, establezca CONTAINER_GROUP_IP en la dirección IP que recuperó con el comando az container show y ejecute el siguiente comando az container create. Este segundo contenedor, commchecker, ejecuta una imagen basada en Linux de Alpine y wget con la dirección IP de la subred privada del primer grupo de contenedores.

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

Una vez completada esta segunda implementación de contenedor, extraiga sus registros para que pueda ver la salida del comando wget que ejecutó:

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

Si el segundo contenedor se comunicó correctamente con el primero, la salida es similar a la siguiente:

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

La salida del registro debe mostrar que wget fue capaz de conectarse y descargar el archivo de índice del primer contenedor usando su dirección IP privada en la subred local. El tráfico de red entre los dos grupos de contenedores permanece dentro de la red virtual.

Limpieza de recursos

Si no tiene previsto seguir usando estos recursos, puede eliminarlos para evitar cargos de Azure. Para limpiar todos los recursos que usó en esta guía, elimine el grupo de recursos con el comando az group delete. Una vez eliminado, estos recursos son irrecuperables.

Pasos siguientes