Sobre o NGroups (Pré-visualização)

Os contêineres se tornaram o padrão para empacotar, implantar e gerenciar aplicativos em nuvem, e gerenciar efetivamente esses contêineres é tão crucial quanto executar os próprios aplicativos. As Instâncias de Contêiner do Azure (ACI) são um serviço de computação sem servidor flexível e escalável que permite executar aplicativos em contêineres sem gerenciar a infraestrutura.

O NGroups fornece recursos avançados para gerenciar vários grupos de contêineres relacionados. Os recursos suportados incluem:

• Manutenção de várias instâncias
• Implementar atualizações
• Alta disponibilidade através de zonas de disponibilidade (AZs)
• Suporte de identidade gerenciado
• Suporte confidencial a contêineres
• Balanceamento de carga
• Reequilíbrio de zona (Zona qualquer)

O recurso NGroups se baseia na ACI, garantindo que os grupos de contêineres sejam seguros, altamente disponíveis e suportem o conjunto de recursos da ACI.

Para obter informações sobre Instâncias de Contêiner do Azure, consulte: O que é Instâncias de Contêiner do Azure?

NGroups Arquitetura de Alto Nível

Com as Instâncias de Contêiner do Azure, os clientes precisam criar e manter cada grupo de contêineres individuais manualmente. O NGroups oferece uma solução mais fácil para criar, atualizar e gerenciar instâncias de grupo de contêineres N com uma única chamada de API.

Criar um recurso NGroups é um processo de duas etapas.

1. Crie um perfil de grupo de contêineres (CGProfile), que serve como um modelo. No CGProfile, um usuário especifica as propriedades CG que são aplicadas em todos os CGs criados pelo NGroups.

2. Crie um recurso NGroups . Você pode fornecer a contagem desejada (número de CGs necessários) e uma referência ao perfil do grupo de contêineres, juntamente com outras propriedades relevantes.

NGroups faz referência a esse Perfil de Grupo de Contêineres e, em seguida, chama APIs ACI para criar/atualizar CGs com as propriedades mencionadas no CGProfile.

Conceitos

Perfil do Grupo de Contêineres (Perfil CG)

Um aplicativo de nuvem de grande escala pode exigir que você gerencie vários grupos de contêineres. A partir de hoje, para executar vários CGs (Grupos de Contêineres), os clientes precisam fornecer propriedades relevantes, como imagens de contêiner, política de reinicialização e outras propriedades a cada vez. Isso pode resultar em limitação, esforço duplicado e sobrecarga de gerenciamento.

Para aliviar essa preocupação, a NGroups introduziu os Perfis de Grupo de Contêineres. O perfil de grupo de contêineres (CGProfile) serve como um modelo para criar grupos de contêineres com o mesmo conjunto de propriedades.

Aqui estão algumas das propriedades comuns que podem ser especificadas em um perfil de grupo de contêineres:

• osType (Exemplo: Linux, Windows)
• contentores. Nome da imagem, memória, CPU etc.
• restartPolicy
• Protocolo ipAddress e porta interna
• shutdownGracePeriod
• timeToLive

E aqui está um exemplo de perfil CG:

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

O recurso NGroups fornece uma maneira de criar e gerenciar 'n' grupos de contêineres com um rico conjunto de operações. Um recurso NGroups faz referência a um recurso de perfil de grupo de contêineres e o usa para criar instâncias N de CGs de aparência semelhante. Dentro do recurso NGroups, os clientes também podem especificar outras propriedades, incluindo, entre outras, o número de CGs, preferências de atualização (atualização manual ou contínua), balanceadores de carga, sub-redes e outras propriedades relevantes que desejam associar a CGs em um recurso NGroups.

Benefícios da referência ao perfil do grupo de contêineres

• O perfil do grupo de contêineres é um recurso separado do NGroups. Os clientes podem criar vários NGroups que podem se referir ao mesmo perfil de grupo de contêineres. Ele também garante consistência em todos os NGroups que se referem a um único perfil de grupo de contêineres e evita duplicação.

• Uma única CG ACI também pode ser criada a partir de um perfil CG. Ele permite que você passe rapidamente do protótipo para o modo de produção.

Aqui está um exemplo de um recurso NGroups com identidade gerenciada e zonas que se refere a um perfil de grupo de contêineres e cria três grupos de contêineres:

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

Destaques do recurso NGroups

• Oferece atualização manual e contínua
• Gerenciar grupos de contêineres interzonais
• Suporta identidades gerenciadas
• Adicione balanceador de carga e gateway de aplicativo para gerenciar o tráfego entre grupos de contêineres
• Gerenciar grupos de contêineres com diferentes perfis de grupos de contêineres
• Anexar e desanexar grupos de contêineres

NGroups API

NGroups faz referência a um perfil CG e adiciona outras propriedades e recursos relacionados. Exemplo:

• A contagem desejada de CGs para criar ou expandir
• A sub-rede na qual os CGs são implantados ao usar uma rede virtual
• O balanceador de carga ou gateway de aplicativo para fornecer entrada de rede para os CGs

O NGroups, por sua vez, invoca as APIs ACI ARM para criar e gerenciar cada CG. Como ele usa as mesmas APIs ARM, não há diferença entre os CGs criados pelo NGroups e os CGs criados diretamente pelo cliente. Eles têm exatamente a mesma experiência de API.

Atualizando um recurso NGroups

À medida que os requisitos mudam, precisaríamos continuar atualizando nossos NGroups e seus CGs. Existem dois modos de atualização com os quais podemos atualizar um NGroups – Manual (opção padrão) e Rolling.

Considere um exemplo básico de atualização de uma referência de perfil CG de cgprofile1 para cgprofile2:

• No modo Manual, atualizamos a referência a cgprofile2 e enviamos uma solicitação UPDATE PUT para NGroups:

NGroups armazena esta nova referência de perfil CG. Mas não atualiza CGs existentes com essa referência. Os CGs existentes estão atualmente em execução e não há impacto sobre eles. No entanto, quando NGroups é dimensionado, os CGs são criados com cgprofile2.

• Como atualizamos CGs existentes com cgprofile2?

Para atualizar CGs existentes com o novo CGProfile, emitimos um comando de atualização manual com uma lista explícita de CGs que queremos atualizar. Este comando atualiza apenas os CGs especificados em sua lista. A atualização do CG envolve chamar a API PUT CG DA ACI. Os CGs não especificados nesta lista continuam a ser executados com cgprofile1.

Esse modo nos dá flexibilidade para atualizar CGs seletivamente e fornece controle total sobre o impacto nas cargas de trabalho de produção.

No modo Contínuo , quando atualizamos a referência a cgprofile2 e emitimos um comando UPDATE NGroups, os CGs existentes são atualizados com cgprofile2. A atualização para CGs existentes acontece em pequenos lotes (e não todos de uma vez). Isso garante que haja um impacto mínimo em sua carga de trabalho, já que apenas uma pequena porcentagem de CGs pode estar indisponível durante a atualização.

Podemos configurar o tamanho do lote e outras configurações relacionadas ao modo de atualização contínua com a API NGroups.

Experimente NGroups

Pré-requisitos para trabalhar em NGroups

A versão da API atualmente suportada é 2024-09-01-preview.

1. Registe a funcionalidade Microsoft.ContainerInstace/NGroupsPreview nas suas subscrições.

2. Depois que os sinalizadores de recursos forem aplicados à assinatura, registre o provedor de Microsoft.ContainerInstance recursos em suas assinaturas.

Se esses pré-requisitos não forem atendidos, as solicitações falharão e o tipo de recurso NGroups não será reconhecido.

Exemplos de modelo ARM

Criar perfil CG: ContainerGroupProfile-Sample.json Criar NGroups zonal com CGProfile: NGroups-Zonal-Sample.json

Os clientes podem ver se um grupo de contêineres está associado a um recurso NGroups verificando a propriedade orchestratorId do grupo de contêineres na visualização JSON. O orchestratorId representa o ID de recurso ARM NGroups associado.

Manual de Instruções

Executar uma atualização contínua

Podemos usar o recurso Rolling Update para atualizar automaticamente todos os CGs para uma versão mais recente sem tempo de inatividade do NGroups. Consulte a documentação de atualização contínua: NGroups Rolling update.

Criar um NGroups Regional (zonal/não zonal)

Primeiro, crie um perfil CG. Aqui está um exemplo de perfil CG. A versão da API atualmente suportada é 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" 
    }

Em seguida, você pode criar um NGroups Zonal/Non-Zonal adicionando zonas fora das propriedades ou deixando a matriz de zonas vazia.

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

Quando NGroups é dimensionado definindo sua propriedade desiredCount, os CGs são distribuídos uniformemente em todas as zonas especificadas. Se uma zona cair, o aplicativo permanecerá disponível porque os CGs restantes de NGroups continuarão a ser executados em outras zonas.

Posso atualizar CG criado por um recurso NGroups diretamente através de APIs ACI CG?

Sim, os clientes têm a flexibilidade de atualizar grupos de contêineres (CGs) diretamente usando as APIs de Instâncias de Contêiner do Azure (ACI). Para uma compreensão mais profunda dos grupos de contêineres ACI e para explorar as opções de API relacionadas, confira este recurso: Grupos de contêineres em instâncias de contêiner do Azure

Ao criar ou atualizar grupos de contêineres, o NGroups depende das mesmas APIs ACI. Isso significa que os clientes podem usar essas APIs para atualizar grupos de contêineres específicos, conforme necessário, sem configurações extras.

Capacidades e Limitações Técnicas

• Uma vez que um recurso NGroups é criado com um conjunto de zonas (por exemplo, { "1", "2" }), as zonas não podem ser removidas. No entanto, uma nova zona pode ser adicionada à lista. Por exemplo, { "1", "2", "3" }

• Se uma zona especificada estiver inativa, a operação geral do NGroups para criar os CGs falhará. Repita a solicitação assim que a zona for reativada. Outra opção é excluir os CGs com falha.

• Durante a redução de escala, o NGroups exclui aleatoriamente instâncias, o que nem sempre mantém o spread AZ. No entanto, as operações de expansão subsequentes sempre tentam reequilibrar o spread AZ.

• A propagação AZ não é suportada com contêineres spot. Se você tiver esse requisito, entre em contato com a equipe ACI.

• Consulte também: impacto da disponibilidade devido a atualizações de infraestrutura/plataforma.

Criar NGroups CGs com um prefixo

Os clientes podem criar NGroups CGs com um prefixo em vez de apenas nomes GUID:

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

Isso pode ser útil quando você tem vários NGroups em um único grupo de recursos e deseja diferenciar CGs pertencentes a cada NGroup (por exemplo, no modo de exibição do portal do Azure). Você também pode alterá-lo para cada operação de expansão para identificar CGs que foram dimensionados juntos em uma operação.

Crie NGroups com identidades gerenciadas atribuídas pelo sistema e pelo usuário

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

Se eu excluir alguns CGs de um NGroups, o NGroups pode se reconstruir com novos CGs para manter a contagem desejada?

Sim, você pode definir a propriedade bool properties.elasticProfile.maintainDesiredCount como true.

Ele cria uma nova CG para cada CG que está sendo excluída/separada do NGroups. Ele tenta manter a propriedade desiredCount do NGroups em seu valor definido.

Isso é útil quando você deseja usar o NGroups como um pool que é reabastecido automaticamente quando você retira CGs do pool para seus cenários de carga de trabalho.

É uma propriedade bool anulável. Se você omiti-lo para chamadas NGroups PUT/update subsequentes, ele não será redefinido para false. Para redefinir, você deve defini-lo explicitamente como false. Quando é null/false, e quando um CG é excluído/desanexado do NGroups, a propriedade desiredCount para o NGroups reduz de acordo.

Como faço para obter o nome CG, NGroups ID e outros metadados propagados para baixo no contêiner?

Atualmente, expomos apenas o nome CG e o ID do orquestrador (o ID do recurso ARM). No futuro, outras propriedades relevantes poderão ser consideradas. Essas duas propriedades aparecem como variáveis de ambiente de contêiner.

Para obter essas variáveis de ambiente no contêiner, especifique estas tags no nível NGroups:

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

O NGroups entende essas tags como especiais e propaga as variáveis de ambiente necessárias para cada contêiner, conforme mostrado aqui.

Qual é o impacto da disponibilidade devido às atualizações da infraestrutura/plataforma?

Para cargas de trabalho que oferecem maior disponibilidade (por exemplo, NGroups espalhados por vários AZs), ainda há uma baixa possibilidade de CGs em mais de um AZ caírem ao mesmo tempo. Isso pode acontecer quando a infraestrutura subjacente do Azure (máquinas host, Conjuntos de Dimensionamento de Máquina Virtual, etc.) passa por uma atualização (chamada de atualização de infraestrutura ou atualização de plataforma).

Esta atualização é feita AZ por AZ com pouca coordenação automatizada entre AZs. A coordenação é controlada manualmente e o melhor esforço.

Assim, se por acaso, uma atualização de plataforma acontece simultaneamente em 2 ou mais AZs, então CGs em todos esses AZs podem estar inativos simultaneamente, causando indisponibilidade para seus NGroups.

Como usar contêineres confidenciais com NGroups

NGroups suporta grupos de contêineres ACI confidenciais. As instâncias confidenciais são definidas usando as seguintes propriedades dentro de um Perfil de Grupo de Contêineres.

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

Consulte a documentação ACI de contêineres confidenciais aqui: Tutorial: Preparar uma implantação para um contêiner confidencial em instâncias de contêiner do Azure

Exemplos

Exemplo de perfil do grupo de contêineres

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

NGroups com amostra de 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" ]
    }
  ]
}

Saiba mais tópicos relacionados

• Azure Container Instances
• NGroups Atualização Contínua
• Nós virtuais em instâncias de contêiner do Azure