Udostępnij za pośrednictwem

Informacje o grupach NGroups (wersja zapoznawcza)

  • Artykuł

Kontenery stały się standardem tworzenia pakietów, wdrażania i zarządzania aplikacjami w chmurze oraz efektywnego zarządzania tymi kontenerami, co ma kluczowe znaczenie dla samodzielnego uruchamiania aplikacji. Azure Container Instances (ACI) to elastyczna i skalowalna bezserwerowa usługa obliczeniowa, która umożliwia uruchamianie konteneryzowanych aplikacji bez zarządzania infrastrukturą.

Grupy NGroup zapewniają zaawansowane możliwości zarządzania wieloma powiązanymi grupami kontenerów. Obsługiwane funkcje obejmują:

  • Obsługa wielu wystąpień
  • Uaktualnienia równoległe
  • Wysoka dostępność za pośrednictwem Strefy dostępności (AZ)
  • Obsługa tożsamości zarządzanej
  • Obsługa kontenerów poufnych
  • Równoważenie obciążenia
  • Ponowne równoważenie strefy (strefa dowolna)

Funkcja NGroups bazuje na usłudze ACI, zapewniając, że grupy kontenerów są bezpieczne, wysoce dostępne i obsługują zestaw funkcji usługi ACI.

Aby uzyskać informacje o usłudze Azure Container Instances, zobacz: Co to jest usługa Azure Container Instances?

Architektura wysokiego poziomu NGroups

Diagram przedstawiający przepływ pracy wysokiego poziomu NGroups.

W przypadku usługi Azure Container Instances klienci muszą ręcznie tworzyć i obsługiwać poszczególne grupy kontenerów. Grupy NGroups oferują łatwiejsze rozwiązanie do tworzenia, aktualizowania i zarządzania wystąpieniami grup kontenerów N za pomocą jednego wywołania interfejsu API.

Tworzenie zasobu NGroups jest procesem dwuetapowym.

  1. Utwórz profil grupy kontenerów (CGProfile), który służy jako szablon. W pliku CGProfile użytkownik określa właściwości CG, które są stosowane we wszystkich grupach CG utworzonych przez grupy NGroups.

  2. Utwórz zasób NGroups. Możesz podać żądaną liczbę (wymaganą liczbę CG) oraz odwołanie do profilu grupy kontenerów wraz z innymi odpowiednimi właściwościami.

Grupy NGroup odwołują się do tego profilu grupy kontenerów, a następnie wywołuje interfejsy API ACI w celu utworzenia/zaktualizowania grup CG z właściwościami wymienionymi w pliku CGProfile.

Pojęcia

Profil grupy kontenerów (profil CG)

Aplikacja w chmurze na dużą skalę może wymagać zarządzania wieloma grupami kontenerów. Od dziś w celu uruchomienia wielu grup CG (grup kontenerów) klienci muszą podać odpowiednie właściwości, takie jak obrazy kontenerów, zasady ponownego uruchamiania i inne właściwości za każdym razem. Może to spowodować ograniczenie przepustowości, zduplikowane nakłady pracy i obciążenie związane z zarządzaniem.

Aby złagodzić ten problem, grupy NGroup wprowadziły profile grup kontenerów. Profil grupy kontenerów (CGProfile) służy jako szablon do tworzenia grup kontenerów z tym samym zestawem właściwości.

Poniżej przedstawiono niektóre typowe właściwości, które można określić w profilu grupy kontenerów:

  • osType (Przykład: Linux, Windows)
  • Pojemniki. Nazwa obrazu, pamięć, procesor itp.
  • restartPolicy
  • protokół ipAddress i port wewnętrzny
  • shutdownGracePeriod
  • timeToLive

Oto przykładowy profil 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" 
    }     
}

NGrupy

Zasób NGroups umożliwia tworzenie grup kontenerów "n" i zarządzanie nimi przy użyciu bogatego zestawu operacji. Zasób NGroups odwołuje się do zasobu profilu grupy kontenerów i używa go do tworzenia N wystąpień podobnych wyglądających grup zabezpieczeń. W ramach zasobu NGroups klienci mogą również określić inne właściwości, w tym, ale nie tylko liczbę CG, preferencje aktualizacji (aktualizacja ręczna lub stopniowa), moduły równoważenia obciążenia, podsieci i inne istotne właściwości, które chcą skojarzyć z grupami CG w ramach zasobu NGroups.

Uwaga

Przed utworzeniem zasobu NGroups należy utworzyć profil CG. Ponieważ profil CG jest zasobem arm, ma własne interfejsy API arm. Przed utworzeniem zasobu NGroups należy utworzyć profil CG.

Zalety odwoływania się do profilu grupy kontenerów

  • Profil grupy kontenerów to oddzielny zasób od NGroups. Klienci mogą utworzyć wiele grup NGroup, które mogą odwoływać się do tego samego profilu grupy kontenerów. Gwarantuje również spójność we wszystkich grupach NGroup odwołujących się do jednego profilu grupy kontenerów i unika duplikowania.

  • Pojedynczy CG ACI można również utworzyć na podstawie profilu CG. Umożliwia szybkie przejście z prototypu do trybu produkcyjnego.

Oto przykład zasobu NGroups z tożsamością zarządzaną i strefami odwołującymi się do profilu grupy kontenerów i tworzy trzy grupy kontenerów:

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

Najważniejsze funkcje NGroups

  • Oferuje zarówno aktualizację kroczącą, jak i ręczną
  • Zarządzanie grupami kontenerów między strefami
  • Obsługuje tożsamości zarządzane
  • Dodawanie modułu równoważenia obciążenia i bramy aplikacji w celu zarządzania ruchem między grupami kontenerów
  • Zarządzanie grupami kontenerów przy użyciu różnych profilów grup kontenerów
  • Dołączanie i odłączanie grup kontenerów

NGroups API

NGroups odwołuje się do profilu CG i dodaje inne powiązane właściwości i możliwości. Przykład:

  • Żądana liczba grup zabezpieczeń do utworzenia lub skalowania w poziomie
  • Podsieć, w której są wdrażane sieciowe grupy zabezpieczeń podczas korzystania z sieci wirtualnej
  • Moduł równoważenia obciążenia lub usługa Application Gateway w celu zapewnienia ruchu przychodzącego sieci do sieciowych grup zabezpieczeń

Grupy NGroup z kolei wywołują interfejsy API arm ACI w celu utworzenia i zarządzania poszczególnymi grupami CG. Ponieważ używa on tych samych interfejsów API usługi ARM, nie ma różnicy między grupami CG utworzonymi przez grupy NGroups a grupami CG utworzonymi bezpośrednio przez klienta. Mają dokładnie takie samo środowisko interfejsu API.

Aktualizowanie zasobu NGroups

W miarę zmiany wymagań musimy aktualizować nasze grupy NGroup i jej grupy zabezpieczeń. Istnieją dwa tryby aktualizacji, za pomocą których można zaktualizować NGroups — Ręczne (opcja domyślna) i Rolling.

Rozważmy podstawowy przykład aktualizacji odwołania profilu CG z pliku cgprofile1 do cgprofile2:

  • W trybie ręcznym aktualizujemy odwołanie do pliku cgprofile2 i wysyłamy żądanie UPDATE PUT do NGroups:

NGroups przechowuje to nowe odwołanie do profilu CG. Jednak nie aktualizuje ona istniejących grup zabezpieczeń przy użyciu tego odwołania. Istniejące sieciowe grupy zabezpieczeń są obecnie uruchomione i nie ma na nie wpływu. Jednak gdy grupy NGroup są skalowane w poziomie, sieciowe grupy zabezpieczeń są tworzone za pomocą pliku cgprofile2.

  • Jak zaktualizować istniejące grupy CG za pomocą pliku cgprofile2?

Aby zaktualizować istniejące grupy CG przy użyciu nowego pliku CGProfile, wydamy polecenie ręcznej aktualizacji z jawną listą CG, które chcemy zaktualizować. To polecenie aktualizuje tylko sieciowe grupy zabezpieczeń określone na liście. Aktualizowanie CG obejmuje wywoływanie interfejsu API PUT CG firmy ACI. Grupy Zabezpieczeń, które nie zostały określone na tej liście, nadal działają z plikiem cgprofile1.

Ten tryb zapewnia elastyczność selektywnego aktualizowania grup zabezpieczeń i zapewnia pełną kontrolę nad wpływem obciążeń produkcyjnych.

W trybie kroczącym , gdy zaktualizujemy odwołanie do pliku cgprofile2 i wydamy polecenie UPDATE NGroups, istniejące grupy CG są aktualizowane za pomocą pliku cgprofile2. Aktualizacja istniejących grup CG odbywa się w małych partiach (a nie wszystkich jednocześnie). Gwarantuje to minimalny wpływ na obciążenie, ponieważ tylko niewielki odsetek CG może być niedostępny podczas aktualizacji.

Rozmiar partii i inne powiązane ustawienia trybu aktualizacji stopniowej można skonfigurować za pomocą interfejsu API NGroups.

Wypróbuj grupy NGroup

Wymagania wstępne dotyczące pracy w grupach NGroup

Obecnie obsługiwana wersja interfejsu API to 2024-09-01-preview.

  1. Zarejestruj funkcję Microsoft.ContainerInstace/NGroupsPreview w swoich subskrypcjach.

  2. Po zastosowaniu flag funkcji do subskrypcji zarejestruj dostawcę Microsoft.ContainerInstance zasobów w swoich subskrypcjach.

Uwaga

Użyj wersji interfejsu API — 2024-09-01-preview i nowszych wersji zapoznawczych .

Napiwek

Postępuj zgodnie z instrukcjami struktury Swagger wystąpienia kontenera platformy Azure, aby uzyskać aktualne informacje na temat interfejsów API NGroups. Kontener Instance NGroups Swagger — 2024-11-01-preview

Jeśli te wymagania wstępne nie są spełnione, żądania kończą się niepowodzeniem, a typ zasobu NGroups nie jest rozpoznawany.

Przykłady szablonów usługi ARM

Tworzenie profilu CG: ContainerGroupProfile-Sample.json tworzenie strefowych grup NGroup za pomocą pakietu CGProfile: NGroups-Zonal-Sample.json

Klienci mogą sprawdzić, czy grupa kontenerów jest skojarzona z zasobem NGroups, sprawdzając właściwość orchestratorId grupy kontenerów w widoku JSON. OrchestratorId reprezentuje skojarzony identyfikator zasobu ARM NGroups.

Zrzut ekranu przedstawiający właściwość OrchestratorId dla NGroups CG ARM JSON.

Przewodnik z instrukcjami

Przeprowadzanie aktualizacji stopniowej

Za pomocą funkcji aktualizacji stopniowej można automatycznie aktualizować wszystkie sieciowe grupy zabezpieczeń do nowszej wersji bez przestoju grup NGroup. Zobacz dokumentację aktualizacji stopniowej: NGroups Rolling update.

Tworzenie grup NGroups regionalnych (strefowych/innych niż strefowe)

Najpierw utwórz profil CG. Oto przykładowy profil CG. Obecnie obsługiwana wersja interfejsu API to 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" 
    }

Następnie możesz utworzyć strefy strefowe/inne niż Zonal NGroups, dodając strefy poza właściwościami lub pozostawiając tablicę stref pustą.

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

Gdy grupy NGroups są skalowane w poziomie przez ustawienie żądanej właściwościCount, grupy CG są dystrybuowane równomiernie we wszystkich określonych strefach. Jeśli jedna strefa ulegnie awarii, aplikacja pozostanie dostępna, ponieważ pozostałe grupy Zabezpieczeń grupy NGroup będą nadal działać w innych strefach.

Czy mogę zaktualizować CG utworzony przez zasób NGroups bezpośrednio za pośrednictwem interfejsów API CG ACI?

Tak, klienci mają elastyczność aktualizowania grup kontenerów (CG) bezpośrednio przy użyciu interfejsów API usługi Azure Container Instances (ACI). Aby lepiej zrozumieć grupy kontenerów usługi ACI i zapoznać się z powiązanymi opcjami interfejsu API, zapoznaj się z tym zasobem: Grupy kontenerów w usłudze Azure Container Instances

Podczas tworzenia lub aktualizowania grup kontenerów grupa NGroups opiera się na tych samych interfejsach API ACI. Oznacza to, że klienci mogą używać tych interfejsów API do aktualizowania określonych grup kontenerów zgodnie z potrzebami bez żadnych dodatkowych konfiguracji.

Możliwości techniczne i ograniczenia

  • Po utworzeniu zasobu NGroups z zestawem stref (na przykład { "1", "2" }), nie można usunąć stref. Do listy można jednak dodać nową strefę. Na przykład { "1", "2", "3" }

  • Jeśli określona strefa nie działa, ogólna operacja NGroups w celu utworzenia grup CG kończy się niepowodzeniem. Ponów próbę żądania po utworzeniu kopii zapasowej strefy. Inną opcją jest usunięcie nieudanych grup zabezpieczeń.

  • Podczas skalowania w dół grupy NGroup losowo usuwa wystąpienia, które mogą nie zawsze utrzymywać rozkład az. Jednak kolejne operacje skalowania w poziomie zawsze próbują ponownie zrównoważyć rozprzestrzenianie się modułu AZ.

  • Rozszerzenie AZ spread nie jest obsługiwane w przypadku kontenerów typu spot. Jeśli masz takie wymaganie, skontaktuj się z zespołem usługi ACI.

  • Zobacz również: wpływ dostępności z powodu aktualizacji infrastruktury/platformy.

Tworzenie sieciowych grup zabezpieczeń z prefiksem

Klienci mogą tworzyć sieciowe grupy Zabezpieczeń z prefiksem zamiast tylko nazw GUID:

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

Może to być przydatne w przypadku wielu grup NGroup w jednej grupie zasobów i odróżnienia grup CG należących do każdej grupy NGroup (na przykład w widoku witryny Azure Portal). Można ją również zmienić dla każdej operacji skalowania w poziomie, aby zidentyfikować grupy CG, które zostały skalowane w poziomie w jednej operacji.

Tworzenie grup NGroup z tożsamościami zarządzanymi przypisanymi przez system i przypisanymi przez użytkownika

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

Jeśli usuwam niektóre grupy CG z NGroups, czy NGroups można ponownie skompilować się z nowymi grupami CG, aby zachować żądaną liczbę?

Tak, można ustawić właściwość bool properties.elasticProfile.maintainDesiredCount na true.

Tworzy nowy CG dla każdego CG, który jest usuwany/odłączany od NGroups. Próbuje zachować właściwość desiredCount grupy NGroups na jej ustawioną wartość.

Jest to przydatne, gdy chcesz użyć grup NGroup jako puli , która jest automatycznie uzupełniana podczas pobierania grup CG z puli na potrzeby scenariuszy obciążeń.

Jest to właściwość logiczna dopuszczana do wartości null. Jeśli pominięto je w przypadku kolejnych wywołań NGroups PUT/update, nie zostanie ono zresetowane do wartości false. Aby zresetować, musisz jawnie ustawić wartość false. Jeśli ma wartość null/false, a gdy CG zostanie usunięty/odłączony od NGroups, właściwość desiredCount dla NGroups zmniejsza się odpowiednio.

Jak mogę uzyskać nazwę CG, identyfikator NGroups i inne metadane propagowane w dół do kontenera?

Obecnie uwidaczniamy tylko nazwę CG i identyfikator orkiestratora (identyfikator zasobu usługi ARM). W przyszłości można rozważyć inne istotne właściwości. Te dwie właściwości są wyświetlane jako zmienne środowiskowe kontenera.

Aby uzyskać te zmienne środowiskowe w kontenerze, określ te tagi na poziomie NGroups:

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

Grupy NGroup rozumieją te tagi jako specjalne i propagują wymagane zmienne środowiskowe do każdego kontenera, jak pokazano tutaj.

Zrzut ekranu przedstawiający zasób kontenera w witrynie Azure Portal z wyświetlonymi zmiennymi środowiskowymi zawierającymi właściwości

Jaki jest wpływ dostępności z powodu aktualizacji infrastruktury/platformy?

W przypadku obciążeń, które oferują wyższą dostępność (na przykład grupy NGroup rozłożone na wiele stref zabezpieczeń), nadal istnieje niska możliwość, że grupy CG w więcej niż jednym az spadną w tym samym czasie. Może się to zdarzyć, gdy podstawowa infrastruktura platformy Azure (maszyny hosta, zestawy skalowania maszyn wirtualnych itp.) przechodzi przez aktualizację (nazywaną aktualizacją infrastruktury lub aktualizacją platformy).

Ta aktualizacja jest wykonywana przez az az z nie dużą automatyczną koordynacją między strefami AZ. Koordynacja jest śledzona ręcznie i najlepiej.

W związku z tym, jeśli przypadek aktualizacja platformy odbywa się jednocześnie w co najmniej 2 strefach dostępności, sieci CGs w tych strefach dostępności mogą być wyłączone jednocześnie, co powoduje niedostępność dla grup NGroup.

Jak używać kontenerów poufnych w grupach NGroups

Grupy NGroups obsługują poufne grupy kontenerów ACI. Wystąpienia poufne są definiowane przy użyciu następujących właściwości w profilu grupy kontenerów.

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

Zapoznaj się z dokumentacją usługi ACI poufnych kontenerów tutaj: Samouczek: przygotowywanie wdrożenia do poufnego kontenera w usłudze Azure Container Instances

Przykłady

Przykład profilu grupy kontenerów

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

Przykład NGroups with Zones (Grupy NGroup z strefami)

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