Compartir a través de

Acerca de NGroups (versión preliminar)

  • Artículo

Los contenedores se han convertido en el estándar para empaquetar, implementar y administrar aplicaciones en la nube. La administración eficaz de estos contenedores es tan crucial como la ejecución de las propias aplicaciones. Azure Container Instances (ACI) es un servicio de informática sin servidor flexible y escalable que permite ejecutar aplicaciones en contenedores sin administrar la infraestructura.

NGroups proporciona funcionalidades avanzadas para administrar varios grupos de contenedores relacionados. Entre las características admitidas se incluyen las siguientes:

  • Mantenimiento de varias instancias
  • Actualizaciones graduales
  • Alta disponibilidad a través de Availability Zones (AZ)
  • Compatibilidad con identidad administrada
  • Compatibilidad con contenedores confidenciales
  • Equilibrio de carga
  • Reequilibrio de zona (cualquier zona)

La característica NGroups se basa en ACI, lo que garantiza que los grupos de contenedores sean seguros, tengan una alta disponibilidad y admitan el conjunto de características de ACI.

Para obtener información sobre Azure Container Instances, consulte: ¿Qué es Azure Container Instances?

Arquitectura de alto nivel de NGroups

Un diagrama que muestra el flujo de trabajo de alto nivel de NGroups.

Con Azure Container Instances, los clientes deben crear y mantener manualmente cada grupo de contenedores individual. NGroups ofrece una solución más sencilla para crear, actualizar y administrar instancias de grupo de contenedores N con una sola llamada API.

La creación de un recurso NGroups es un proceso de dos pasos.

  1. Crear un Perfil de grupo de contenedores (CGProfile), que sirve como plantilla. En CGProfile, un usuario especifica las propiedades CG que se aplican en todos los CG por NGroups.

  2. Cree un recurso de NGroups. Puede proporcionar el recuento deseado (número de GG necesarios) y una referencia al perfil de grupo de contenedores junto con otras propiedades pertinentes.

NGroups hace referencia a este perfil de grupo de contenedores y luego llama a las API de ACI para crear o actualizar los CG con las propiedades mencionadas en el archivo CGProfile.

Conceptos

Perfil de grupo de contenedores (Perfil CG)

Una aplicación en la nube a gran escala puede requerir que administre varios grupos de contenedores. A partir de hoy, para ejecutar varios CG (grupos de contenedores), los clientes deben proporcionar cada vez las propiedades correspondientes como, por ejemplo, las imágenes de contenedor, la directiva de reinicio y otras propiedades. Esto puede dar lugar a una limitación, un esfuerzo duplicado y una sobrecarga de administración.

Para aliviar este problema, NGroups introdujo:el Perfil de grupo de contenedores. El perfil de grupo de contenedores (CGProfile) actúa como una plantilla para crear grupos de contenedores con el mismo conjunto de propiedades.

Estas son algunas de las propiedades comunes que se pueden especificar en un perfil de grupo de contenedores:

  • osType (ejemplo: Linux, Windows)
  • los contenedores. Nombre de imagen, memoria, CPU, etc.
  • restartPolicy
  • Protocolo ipAddress y puerto interno
  • shutdownGracePeriod
  • timeToLive

Este sería un perfil de CG de ejemplo:

{ 
    "location": "{{location}}", 
    "properties": { 
        "sku": "Standard", 
        "containers": [ 
            { 
                "name": "container1", 
                "properties": { 
                    "image": "nginx", 
                    "ports": [ 
                        { 
                            "protocol": "TCP", 
                            "port": 80 
                        } 
                    ], 
                    "resources": { 
                        "requests": { 
                            "memoryInGB": 2.0, 
                            "cpu": 1.0 
                        } 
                    } 
                } 
            } 
        ], 
        "restartPolicy": "Always", 
        "shutdownGracePeriod": "PT1H", 
        "ipAddress": { 
            "ports": [ 
                { 
                    "protocol": "TCP", 
                    "port": 80 
                } 
            ], 
            "type": "Public",
        }, 
        "timeToLive": "PT1H", 
        "osType": "Linux" 
    }     
}

NGroups

El recurso NGroups proporciona una manera de crear y administrar ‘n’ grupos de contenedores con un amplio conjunto de operaciones. Un recurso NGroups hace referencia a un recurso de perfil de grupo de contenedores y lo usa para crear N instancias de CG similares. En el recurso NGroups, los clientes también pueden especificar otras propiedades, por ejemplo, entre otras, el número de CG, las preferencias de actualización (actualización manual o gradual), los equilibradores de carga, las subredes y otras propiedades relevantes que desean asociar con los CG en un recurso NGroups.

Nota:

Es necesario crear un perfil de CG antes de crear un recurso NGroups. Como el perfil de CG es un recurso de ARM, tiene sus propias API de ARM. Es necesario crear un perfil de CG antes de crear un recurso NGroups.

Ventajas de hacer referencia al perfil de grupo de contenedores

  • El perfil de grupo de contenedores es un recurso independiente de NGroups. Los clientes pueden crear varios NGroups que pueden hacer referencia al mismo perfil de grupo de contenedores. Esto también garantiza la coherencia en todos los NGroups que hacen referencia a un mismo perfil de grupo de contenedores y evita la duplicación.

  • También se puede crear un único CG de ACI a partir de un perfil de CG. Permite pasar rápidamente del prototipo al modo de producción.

Este es un ejemplo de un recurso NGroups con identidad administrada y zonas que hace referencia a un perfil de grupo de contenedores y crea tres grupos de contenedores:

{ 
    "location": "{{location}}", 
    "properties": { 
        "elasticProfile": { 
            "desiredCount": 100 // specifies how many CGs to create
        }, 
        "containerGroupProfiles": [ 
            { 
                "resource": { 
                    "id": "/subscriptions/{{subId}}/resourceGroups/{{rgName}}/providers/Microsoft.ContainerInstance/containerGroupProfiles/{{cgProfile1}}" 
                } 
            } 
        ] 
    } 
}

Características destacadas de NGroups

  • Ofrece actualizaciones graduales y manuales
  • Administra grupos de contenedores entre zonas
  • Compatibilidad con identidades administradas
  • Agrega un equilibrador de carga y una puerta de enlace de aplicación para administrar el tráfico entre los grupos de contenedores
  • Administra los grupos de contenedores con distintos perfiles de grupo de contenedores
  • Asocia y desasocia grupos de contenedores

API de NGroups

NGroups hace referencia a un perfil de CG y agrega otras funcionalidades y propiedades relacionadas. Ejemplo:

  • Recuento deseado de CG para crear o escalar horizontalmente
  • Subred en la que se implementan los CG cuando se usa una red virtual
  • Load Balancer o Application Gateway para proporcionar entrada de los CG

A su vez, NGroups invoca las API de ARM de ACI para crear y administrar cada CG. Dado que usa las mismas API de ARM, no hay ninguna diferencia entre los CG creados por NGroups y los GG creados directamente por el cliente. Tienen exactamente la misma experiencia de API.

Actualización de un recurso de NGroups

A medida que cambian los requisitos, tenemos que actualizar nuestros NGroups y sus CG. Hay dos modos con los que podemos actualizar un NGroups: Manual (opción predeterminada) y Gradual.

Considere un ejemplo básico de actualización de una referencia de perfil de CG de cgprofile1 a cgprofile2:

  • En modo Manual, actualizamos la referencia a cgprofile2 y enviamos una solicitud UPDATE PUT a NGroups:

NGroups almacena esta nueva referencia de perfil de CG. No obstante, no actualiza los CG existentes con esta referencia. Los CG existentes se están ejecutando actualmente y no hay ningún impacto en ellos. Sin embargo, cuando NGroups se escala horizontalmente, se crean los CG con cgprofile2.

  • ¿Cómo actualizamos los CG existentes con cgprofile2?

Para actualizar los CG existentes con el nuevo CGProfile, emitimos un comando de actualización manual con una lista explícita de los CG que queremos actualizar. Este comando solo actualiza los CG especificados en su lista. La actualización de CG implica llamar a la API PUT CG de ACI. Los CG no especificados en esta lista continúan ejecutándose con cgprofile1.

Este modo nos da flexibilidad para actualizar los CG de forma selectiva y proporciona un control total sobre el impacto en las cargas de trabajo de producción.

Con el modo Gradual, cuando actualizamos la referencia a cgprofile2 y emitimos un comando UPDATE NGroups, los CG existentes se actualizan con cgprofile2. La actualización de los CG existentes se produce en lotes pequeños (y no todos a la vez). Esto garantiza que haya un impacto mínimo en la carga de trabajo, ya que solo es posible que un pequeño porcentaje de CG no esté disponible durante la actualización.

Podemos configurar el tamaño del lote y otras opciones relacionadas del modo de actualización gradual con la API de NGroups.

Probar NGroups

Requisitos previos para trabajar en NGroups

La versión de API admitida actualmente es 2024-09-01-preview.

  1. Registrar la característica Microsoft.ContainerInstace/NGroupsPreview en las suscripciones.

  2. Una vez que se aplican las marcas de características a la suscripción, registrar el proveedor de recursos Microsoft.ContainerInstance en las suscripciones.

Nota:

Use la versión de API: 2024-09-01-preview y versiones posteriores para la versión preliminar.

Sugerencia

Siga Swagger de Azure Container Instance para obtener información actualizada sobre las API de NGroups. Instancia de contenedor NGroups Swagger: 2024-11-01-preview

Si no se cumplen estos requisitos previos, las solicitudes fallan y no se reconoce el tipo de recurso NGroups.

Ejemplos de plantilla de ARM

Crear perfil de CG: ContainerGroupProfile-Sample.json Crear NGroups zonales con CGProfile: NGroups-Zonal-Sample.json

Los clientes pueden ver si un grupo de contenedores está asociado a un recurso de NGroups comprobando la propiedad orchestratorId del grupo de contenedores en la vista JSON. orchestratorId representa el identificador de recurso de ARM de NGroups asociado.

Un recorte de pantalla de un CG de NGroups de ARM de JSON mostrando la propiedad OrchestratorId.

Guía paso a paso

Realizar una actualización gradual

Podemos usar la característica Actualización gradual para actualizar automáticamente todos los CG a una versión más reciente sin ningún tiempo de inactividad de NGroups. Consulte la documentación de actualización gradual: Actualización gradual de NGroups.

Crear un grupo de NGroups regional (zonal o no zonal)

En primer lugar, cree un perfil de CG. Este sería un perfil de CG de ejemplo. La versión de API admitida actualmente es 2024-09-01-preview.

{ 
    "properties": { 
        "sku": "Standard", 
        "containers": [ 
            { 
                "name": "container1", 
                "properties": { 
                    "image": "nginx", 
                    "ports": [ 
                    { 
                        "protocol": "TCP", 
                        "port": 80 
                    }], 
                    "resources": { 
                        "requests": { 
                            "memoryInGB": 2.0, 
                            "cpu": 1.0 
                        } 
                    } 
                } 
            } 
        ], 
        "restartPolicy": "Always", 
        "shutdownGracePeriod": "PT1H", 
        "ipAddress": { 
            "ports": [ 
            { 
                "protocol": "TCP", 
                "port": 80 
            }], 
            "type": "Public"
        }, 
        "timeToLive": "PT1H", 
        "osType": "Linux" 
    }

A continuación, puede crear un NGroups Zonal o No-Zonal agregando zonas fuera de las propiedades o dejando la matriz de zonas vacía.

{ 
    "properties": { 
        "elasticProfile": { 
            "desiredCount": 5 
        }, 
        "containerGroupProfiles": [ 
            { 
                "resource": { 
                    "id": "[resourceId('Microsoft.ContainerInstance/containerGroupProfiles', parameters('cgProfileName'))]" 
                } 
            } 
        ] 
    }, 
    "zones": [ "1", "2", "3" ] 
}

Cuando NGroups se escala horizontalmente estableciendo su propiedad desiredCount, los CG se distribuyen uniformemente entre todas las zonas especificadas. Si una zona deja de funcionar, la aplicación sigue estando disponible porque los CG de NGroups restantes siguen ejecutándose en otras zonas.

¿Puedo actualizar un CG creado por un recurso NGroups directamente a través de las API de CG de ACI?

Sí, los clientes tienen la flexibilidad de actualizar los grupos de contenedores (GG) directamente mediante las API de Azure Container Instances (ACI). Para comprender mejor los grupos de contenedores de ACI y explorar las opciones de API relacionadas, consulte este recurso: Grupos de contenedores en Azure Container Instances

Al crear o actualizar grupos de contenedores, NGroups se basa en las mismas API de ACI. Esto significa que los clientes pueden usar estas API para actualizar grupos de contenedores específicos según sea necesario, sin necesidad de configuraciones adicionales.

Funcionalidades y restricciones técnicas

  • Una vez creado un recurso NGroups con un conjunto de zonas (por ejemplo, { “1”, “2” }), no se pueden quitar. Sin embargo, se puede agregar una nueva zona a la lista. Por ejemplo, { “1”, “2”, “3” }

  • Si una zona especificada no funciona, se produce un error en la operación general de NGroups para crear los CG. Vuelva a intentar la solicitud cuando la zona vuelva a estar operativa. Otra opción es eliminar los CG con errores.

  • Durante una reducción vertical, NGroups elimina aleatoriamente instancias que podrían no mantener siempre la propagación de AZ. Sin embargo, las operaciones de escalado horizontal posteriores siempre intentan reequilibrar la propagación de AZ.

  • La propagación de AZ no se admite con el contenedor de acceso puntual. Si tiene este requisito, póngase en contacto con el equipo de ACI.

  • Consulte también: impacto de la disponibilidad debido a actualizaciones de infraestructura o plataforma.

Crear NGroups CG con un prefijo

Los clientes pueden crear CG de NGroups con un prefijo en lugar de solo nombres GUID:

"properties": { 
    "elasticProfile": { 
        "desiredCount": 2,             
        "containerGroupNamingPolicy": { 
            "guidNamingPolicy": { 
                "prefix": "cg-" 
            } 
        } 
    },

Esto resulta muy útil cuando tiene varios NGroups en un único grupo de recursos y desea diferenciar los CG que pertenecen a cada NGroup (por ejemplo, en la vista de Azure Portal). También puede cambiarlo para cada operación de escalado horizontal para identificar los CG que se han escalado juntos horizontalmente en una operación.

Creación de NGroups con identidades administradas asignadas por el sistema y asignadas por el usuario

“location”: “{{location}}” 
"identity": { 
    "type": "SystemAssigned, UserAssigned", 
    "userAssignedIdentities": { 
        "/subscriptions/{{subId}}/resourceGroups/{{rgName}}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{{userAssignedIdentity1}}": {},  
        "/subscriptions/{{subId}}/resourceGroups/{{rgName}}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{{userAssignedIdentity2}}": {} 
    }

Si elimino algunos CG de un NGroups, ¿se puede recompilar el NGroups con nuevos CG para mantener el recuento deseado?

Sí, puede establecer la propiedad booleana properties.elasticProfile.maintainDesiredCount en true.

Crea un nuevo CG para cada CG que se va a eliminar/desasociar de NGroup. Intenta mantener la propiedad desiredCount de NGroups en su valor establecido.

Esto es útil cuando desea utilizar los NGroups como un grupo que se reabastece automáticamente al retirar CG del grupo para sus escenarios de carga de trabajo.

Es una propiedad bool que acepta valores NULL. Si lo omite en posteriores llamadas PUT/update de NGroups, no se restablece a false. Para restablecerla, debe establecerla explícitamente en false. Cuando es null/false, y cuando se elimina o desasocia un CG de NGroups, la propiedad desiredCount de NGroups se reduce en consecuencia.

¿Cómo obtengo el nombre de CG, el identificador de NGroups y otros metadatos propagados hacia abajo en el contenedor?

Actualmente, solo se expone el nombre de CG y el id. del orquestador (el id. de recurso de ARM). En el futuro, se considerarán otras propiedades pertinentes. Estas dos propiedades se muestran como variables de entorno de contenedor.

Para obtener estas variables de entorno en el contenedor, especifique estas etiquetas en el nivel NGroups:

tags: { 
    “metadata.container.environmentVariable.containerGroupName”: true, 
    “metadata.container.environmentVariable.orchestratorId”: true, 
    : 
    : // other NGroups tags you may have 
    : 
}

NGroups entiende estas etiquetas como especiales y propaga las variables de entorno necesarias a cada contenedor como se muestra aquí.

Recorte de pantalla de un recurso de contenedor en Azure Portal que muestra las variables de entorno que contienen las propiedades

¿Cuál es el impacto de la disponibilidad debido a actualizaciones de infraestructura/plataforma?

En el caso de las cargas de trabajo que ofrecen una mayor disponibilidad (por ejemplo, NGroups distribuidos entre varias AZ), todavía hay una baja posibilidad de que los CG en más de una AZ dejen de funcionar al mismo tiempo. Esto puede ocurrir cuando la infraestructura subyacente de Azure (máquinas host, Virtual Machine Scale Sets, etc.) pasa por una actualización (denominada actualización de infraestructura o actualización de plataforma).

Esta actualización se realiza AZ a AZ, con una coordinación no muy automatizada entre las AZ. Se realiza un seguimiento manual de la coordinación en la medida de lo posible.

Por lo tanto, si casualmente se produce una actualización de la plataforma en 2 o más AZ a la vez, los CG en estas AZ pueden dejar de funcionar simultáneamente, lo que provoca la falta de disponibilidad de los NGroups.

Cómo utilizar contenedores confidenciales con NGroups

NGroups admite grupos de contenedores de ACI confidenciales. Las instancias confidenciales se definen mediante las siguientes propiedades dentro de un perfil de grupo de contenedores.

{ 
    "location": "{{location}}", 
    "properties": { 
        "sku": "Confidential",
        "confidentialComputeProperties": { 
            "ccePolicy": "<base 64 encoded policy>" 
          }, 
        "containers": [ ... ], 
        "restartPolicy": "Always", 
        "shutdownGracePeriod": "PT1H", 
        "ipAddress": { ... }, 
        "timeToLive": "PT1H", 
        "osType": "Linux" 
    }     
}

Puede consultar la documentación de ACI de contenedores confidenciales en: Tutorial: Preparación de una implementación de un contenedor confidencial en Azure Container Instances

Ejemplos

Ejemplo de perfil de grupo de contenedores

{
    "properties": {
        "sku": "Standard",
        "containers": [
            {
                "name": "web",
                "properties": {
                    "image": "mcr.microsoft.com/azuredocs/aci-helloworld",
                    "ports": [
                        {
                            "protocol": "TCP",
                            "port": 80
                        }
                    ],
                    "targetState": "Running",
                    "resources": {
                        "requests": {
                            "memoryInGB": 1,
                            "cpu": 1
                        }
                    }
                }
            }
        ],
        "restartPolicy": "Always",
        "shutdownGracePeriod": "PT2H",
        "ipAddress": {
            "ports": [
                {
                    "protocol": "TCP",
                    "port": 80
                }
            ],
            "type": "Public"
        },
        "osType": "Linux",
        "revision": 1
    },
    "id": "/subscriptions/{{subId}}/resourceGroups/{{rgName}}/providers/Microsoft.ContainerInstance/containerGroupProfiles/{{cgProfile1}}",
    "name": "{{cgProfile1}}",
    "type": "Microsoft.ContainerInstance/containerGroupProfiles",
    "location": "{{location}}"
}

Ejemplo de NGroups con zonas

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "apiVersion": {
      "type": "string",
      "maxLength": 32
    },
    "NGroupsName": {
      "type": "string",
      "maxLength": 64
    },
    "containerGroupProfileName": {
      "type": "string",
      "maxLength": 64
    },
    "resourceTags": {
      "type": "object"
    },
    "desiredCount": {
      "type": "int"
    }
  },
  "variables": {
    "description": "This ARM template can be parameterized for a basic CRUD scenario for NGroups. It is self contained with cgProfile and NGroups resource",
    "cgProfileName": "[parameters('containerGroupProfileName')]",
    "NGroupsName": "[parameters('NGroupsName')]",
    "resourcePrefix": "[concat('/subscriptions/', subscription().subscriptionId, '/resourceGroups/', resourceGroup().name, '/providers/')]"
  },
  "resources": [
    {
      "apiVersion": "[parameters('apiVersion')]",
      "type": "Microsoft.ContainerInstance/containerGroupProfiles",
      "name": "[variables('cgProfileName')]",
      "location": "[resourceGroup().location]",
      "properties": {
        "sku": "Standard",
        "containers": [
          {
            "name": "web",
            "properties": {
              "image": "mcr.microsoft.com/azuredocs/aci-helloworld",
              "ports": [
                {
                  "protocol": "TCP",
                  "port": 80
                }
              ],
              "resources": {
                "requests": {
                  "memoryInGB": 1.0,
                  "cpu": 1.0
                }
              }
            }
          }
        ],
        "restartPolicy": "Always",
        "ipAddress": {
          "ports": [
            {
              "protocol": "TCP",
              "port": 80
            }
          ],
          "type": "Public"
        },
        "osType": "Linux"
      }
    },
    {
      "apiVersion": "[parameters('apiVersion')]",
      "type": "Microsoft.ContainerInstance/NGroups",
      "name": "[variables('NGroupsName')]",
      "tags": "[parameters('resourceTags')]",
      "location": "[resourceGroup().location]",
      "dependsOn": [
        "[concat('Microsoft.ContainerInstance/containerGroupProfiles/', variables('cgProfileName'))]"
      ],
      "identity": {
        "type": "systemAssigned"
      },
      "properties": {
        "elasticProfile": {
          "desiredCount": "[parameters('desiredCount')]",
          "maintainDesiredCount": true
        },
        "containerGroupProfiles": [
          {
            "resource": {
              "id": "[concat(variables('resourcePrefix'), 'Microsoft.ContainerInstance/containerGroupProfiles/', variables('cgProfileName'))]"
            }
          }
        ]
      },
      "zones": [ "1", "2", "3" ]
    }
  ]
}