Compartilhar via

Sobre NGroups (Versão prévia)

  • Artigo

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

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

  • Mantendo várias instâncias
  • Atualizações sem interrupção
  • Alta disponibilidade por meio de AZs (Zonas de Disponibilidade)
  • Suporte de identidade gerenciada
  • Suporte de contêiner confidenciais
  • Balanceamento de carga
  • Rebalanceamento de zona (qualquer zona)

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

Para obter informações sobre as Instâncias de Contêiner do Azure, confira O que são as Instâncias de Contêiner do Azure?

Arquitetura de alto nível do NGroups

Um diagrama que mostra o fluxo de trabalho de alto nível do NGroups.

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

A criação de um recurso do NGroups é um processo de duas etapas.

  1. Crie um CGProfile (Perfil de Grupo de Contêineres), que serve como um modelo. Em CGProfile, um usuário especifica as propriedades do CG que são aplicadas em todos os CGs criados por NGroups.

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

O NGroups referencia esse Perfil de Grupo de Contêineres e, em seguida, chama as APIs da ACI para criar/atualizar CGs com as propriedades mencionadas no CGProfile.

Conceitos

Perfil do Grupo de Contêineres (Perfil do CG)

Um aplicativo de nuvem em 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, a política de reinicialização e outras propriedades a cada vez. Isso pode resultar em esforço duplicado, limitação e sobrecarga de gerenciamento.

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

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

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

E aqui está um perfil CG de exemplo:

{ 
    "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 grupos de contêineres "n" com um conjunto avançado de operações. Um recurso NGroups faz referência a um recurso de perfil de grupo de contêineres e usa isso para criar instâncias N de CGs semelhantes. No recurso NGroups, os clientes também podem especificar outras propriedades, incluindo, mas não se limitando ao número de CGs, preferências de atualização (atualização manual ou sem interrupção), balanceadores de carga, sub-redes e outras propriedades relevantes que desejam associar a CGs em um recurso NGroups.

Observação

Um perfil CG precisa ser criado antes de criar um recurso NGroups. Como o perfil CG é um recurso do ARM, ele tem suas próprias APIs do ARM. Um perfil CG precisa ser criado antes de criar 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 de NGroups. Os clientes podem criar vários NGroups que podem fazer referência ao mesmo perfil de grupo de contêineres. Ele também garante a consistência em todos os NGroups que fazem referência a um único perfil de grupo de contêineres e evita a duplicação.

  • Um único CG do ACI também pode ser criado a partir de um perfil CG. Isso permite mover rapidamente do protótipo para o modo de produção.

Aqui está um exemplo de um recurso do 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

  • Atualização sem interrupção e manual
  • Gerenciamento de grupos de contêineres entre zonas
  • Dá suporte a identidades gerenciadas
  • Adição do balanceador de carga e gateway de aplicativo para gerenciar o tráfego entre grupos de contêineres
  • Gerenciamento de grupos de contêineres com diferentes perfis de grupo de contêineres
  • Anexação e desanexação de grupos de contêineres

API do NGroups

O NGroups faz referência a um perfil CG e adiciona outras propriedades e funcionalidades relacionadas. Exemplo:

  • A contagem desejada de CGs para criação ou expansão
  • A sub-rede na qual os CGs são implantados ao usar uma rede virtual
  • O Load Balancer ou o Gateway de Aplicativo para fornecer entrada de rede para os CGs

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

Atualizar um recurso do NGroups

É preciso continuar atualizando o NGroups e os CGs associados com base nas alterações de requisitos. Há duas maneiras de atualizar um NGroups: Manual (opção padrão) e Contínua.

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

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

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

  • Como atualizar os CGs existentes com cgprofile2?

Para atualizar os CGs existentes com o novo CGProfile, emitimos um comando manual update com uma lista explícita de CGs que desejamos atualizar. Esse 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 sendo executados com cgprofile1.

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

No modo Sem interrupção ao atualizar a referência para cgprofile2 e emitir um comando UPDATE do NGroups, os CGs existentes são atualizados com cgprofile2. A atualização dos CGs existentes acontece em pequenos lotes, não toda de uma vez. Isso garante que haja impacto mínimo na carga de trabalho, já que somente uma pequena porcentagem de CGs ficará indisponível durante a atualização.

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

Experimentar NGroups

Pré-requisitos para trabalhar em NGroups

A versão da API com suporte no momento é 2024-09-01-preview.

  1. Registrar o recurso Microsoft.ContainerInstace/NGroupsPreview em suas assinaturas.

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

Observação

Use api-version - 2024-09-01-preview e versões posteriores para versão prévia.

Dica

Siga o Swagger da Instância de Contêiner do Azure para obter informações atualizadas sobre APIs do NGroups. Swagger do NGroups da Instância de Contêiner - 2024-11-01-preview

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

Amostras de modelo do ARM

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

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

Uma captura de tela de um JSON do ARM do CG do NGroups exibindo a propriedade OrchestratorId.

Guia de Instruções

Realizar uma atualização contínua

Podemos usar o recurso de atualização sem interrupção para atualizar automaticamente todos os CGs para uma versão mais recente sem tempo de inatividade dos NGroups. Consulte a documentação da atualização sem interrupção: Atualização sem interrupção do NGroups.

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

Primeiro, crie um perfil de CG. Aqui está um perfil CG de exemplo. A versão da API com suporte no momento é 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 NGroups zonal/não 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 é expandido definindo sua propriedade desiredCount, os CGs são distribuídos uniformemente em todas as zonas especificadas. Se uma zona falhar, o aplicativo permanecerá disponível porque os CGs restantes de NGroups continuarão sendo executados em outras zonas.

Posso atualizar o CG criado por um recurso NGroups diretamente por meio de APIs de CG da ACI?

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

Ao criar ou atualizar grupos de contêineres, o NGroups depende das mesmas APIs de 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.

Funcionalidades técnicas e restrições

  • Depois que um recurso do 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 inoperante, a operação geral de NGroups para criar os CGs falhará. Tente novamente a solicitação depois que a cópia de backup da zona for feita. Outra opção é excluir os CGs com falha.

  • Durante a redução vertical, o NGroups exclui aleatoriamente instâncias que podem nem sempre manter o espalhamento da AZ. No entanto, as operações de expansão subsequentes sempre tentam reequilibrar o espalhamento do AZ.

  • Não há suporte para o espalhamento da AZ com Contêineres Spot. Se você tiver esse requisito, entre em contato com a equipe da ACI.

  • Consulte também: Impacto da disponibilidade devido às atualizações de infraestrutura/plataforma.

Criar CGs do NGroups com um prefixo

Os clientes podem criar CGs do NGroups 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 os CGs que foram dimensionados juntos em uma operação.

Criar 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 NGroups, o NGroups poderá se recompilar com novos CGs para manter a contagem desejada?

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

Ele cria um novo CG para cada CG que está sendo excluído/desanexado do NGroups. Ele tenta manter a propriedade desiredCount do NGroups com seu valor definido.

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

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

Como obter o nome do CG, a ID do NGroups e outros metadados propagados para o contêiner?

Atualmente, exibimos apenas o nome do CG e a ID do orquestrador (a ID do recurso do ARM). No futuro, outras propriedades relevantes podem 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 essas marcas no nível do NGroups:

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

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

Uma captura de tela de um recurso de contêiner no portal do Azure exibindo variáveis de ambiente que contêm as propriedades

Qual é o impacto da disponibilidade devido às atualizações de 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 ficarem inoperantes ao mesmo tempo. Isso pode acontecer quando a infraestrutura subjacente do Azure (máquinas host, Conjuntos de Dimensionamento de Máquinas Virtuais etc.) passa por uma atualização (chamada de atualização de infraestrutura ou atualização de plataforma).

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

Portanto, se por acaso uma atualização de plataforma ocorrer simultaneamente em 2 ou mais AZs, os CGs entre esses AZs poderão ficar inativos simultaneamente, causando indisponibilidade para seus NGroups.

Como usar contêineres confidenciais com NGroups

O NGroups dá suporte a grupos de contêineres de ACI Confidencial. Instâncias confidenciais são definidas usando as propriedades a seguir em 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 da ACI de contêineres confidenciais aqui: Tutorial: preparar uma implantação para um contêiner confidencial nas Instâncias de Contêiner do Azure

Amostras

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

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