Schnellstart: Bereitstellen eines Azure Nexus Kubernetes-Clusters mit Bicep

  • Stellen Sie einen Azure Nexus Kubernetes-Cluster mit Bicep bereit.

Bicep ist eine domänenspezifische Sprache (Domain-Specific Language, DSL), die eine deklarative Syntax zur Bereitstellung von Azure-Ressourcen verwendet. Sie bietet eine präzise Syntax, zuverlässige Typsicherheit und Unterstützung für die Wiederverwendung von Code. Bicep bietet die beste Entwicklungserfahrung für Ihre Infrastructure-as-Code-Lösungen in Azure.

Voraussetzungen

Wenn Sie nicht über ein Azure-Konto verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.

  • Installieren Sie die neueste Version der erforderlichen Azure CLI-Erweiterungen.

  • Dieser Artikel erfordert Version 2.61.0 oder höher der Azure CLI. Wenn Sie Azure Cloud Shell verwenden, ist die neueste Version bereits installiert.

  • Wenn Sie über mehrere Azure-Abonnements verfügen, wählen Sie die entsprechende Abonnement-ID aus, in der die Ressourcen mit dem az account Befehl in Rechnung gestellt werden sollen.

  • Die VM-SKU-Tabelle finden Sie im Referenzabschnitt für die Liste der unterstützten VM-SKUs.

  • Die unterstützten Kubernetes-Versionen finden Sie in der Liste der unterstützten Kubernetes-Versionen.

  • Erstellen Sie eine Ressourcengruppe mit dem Befehl az group create. Eine Azure-Ressourcengruppe ist eine logische Gruppe, in der Azure-Ressourcen bereitgestellt und verwaltet werden. Wenn Sie eine Ressourcengruppe erstellen, werden Sie zur Angabe eines Speicherorts aufgefordert. An diesem Speicherort werden die Metadaten Ihrer Ressourcengruppe gespeichert. Darüber hinaus werden dort die Ressourcen in Azure ausgeführt, wenn Sie während der Ressourcenerstellung keine andere Region angeben. Das folgende Beispiel erstellt eine Ressourcengruppe mit dem Namen myResourceGroup am Standort eastus.

    az group create --name myResourceGroup --location eastus

    Das folgende Ausgabebeispiel ähnelt der erfolgreichen Erstellung der Ressourcengruppe:

    {
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "eastus",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

  • Zum Bereitstellen einer Bicep-Datei oder ARM-Vorlage benötigen Sie Schreibzugriff auf die Ressourcen, die Sie bereitstellen, und Zugriff auf alle Vorgänge für den Ressourcentyp Microsoft.Resources/deployments. Um beispielsweise einen Cluster bereitzustellen, benötigen Sie Microsoft.NetworkCloud/kubernetesclusters/write und Microsoft.Resources/deployments/* Berechtigungen. Eine Liste der Rollen und Berechtigungen finden Sie in den integrierten Azure-Rollen.

  • Sie benötigen die custom location Ressourcen-ID Ihres Azure Operator Nexus-Clusters.

  • Sie müssen verschiedene Netzwerke entsprechend Ihren spezifischen Workloadanforderungen erstellen, und es ist wichtig, dass die entsprechenden IP-Adressen für Ihre Workloads verfügbar sind. Um eine reibungslose Implementierung sicherzustellen, empfiehlt es sich, die entsprechenden Supportteams zur Unterstützung zu konsultieren.

  • Für diese Schnellstartanleitung werden Grundkenntnisse in Bezug auf die Kubernetes-Konzepte vorausgesetzt. Weitere Informationen finden Sie unter Kubernetes-Kernkonzepte für Azure Kubernetes Service (AKS).

Überprüfen der Bicep-Datei

Bevor Sie die Kubernetes-Vorlage bereitstellen, überprüfen wir den Inhalt, um seine Struktur zu verstehen.

// Azure parameters

@description('The name of Nexus Kubernetes cluster')
param kubernetesClusterName string

@description('The Azure region where the cluster is to be deployed')
param location string = resourceGroup().location

@description('The custom location of the Nexus instance')
param extendedLocation string

@description('The metadata tags to be associated with the cluster resource')
param tags object = {}

@description('The username for the administrative account on the cluster')
param adminUsername string = 'azureuser'

@description('The object IDs of Azure Active Directory (AAD) groups that will have administrative access to the cluster')
param adminGroupObjectIds array = []

// Networking Parameters

@description('The Azure Resource Manager (ARM) id of the network to be used as the Container Networking Interface (CNI) network')
param cniNetworkId string

@description('The ARM id of the network to be used for cloud services network')
param cloudServicesNetworkId string

@description('The CIDR blocks used for Nexus Kubernetes PODs in the cluster')
param podCidrs array = ['10.244.0.0/16']

@description('The CIDR blocks used for k8s service in the cluster')
param serviceCidrs array = ['10.96.0.0/16']

@description('The IP address of the DNS service in the cluster')
param dnsServiceIp string = '10.96.0.10'

@description('The Layer 2 networks associated with the initial agent pool')
param agentPoolL2Networks array = []
// {
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN'
// }

@description('The Layer 3 networks associated with the initial agent pool')
param agentPoolL3Networks array = []
// {
//   ipamEnabled: 'True/False'
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN|IPVLAN'
// }

@description('The trunked networks associated with the initial agent pool')
param agentPoolTrunkedNetworks array = []
// {
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN'
// }

@description('The Layer 2 networks associated with the cluster')
param l2Networks array = []
// {
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN'
// }

@description('The Layer 3 networks associated with the cluster')
param l3Networks array = []
// {
//   ipamEnabled: 'True/False'
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN|IPVLAN'
// }

@description('The trunked networks associated with the cluster')
param trunkedNetworks array = []
// {
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN'
// }

@description('The LoadBalancer IP address pools associated with the cluster')
param ipAddressPools array = []
// {
//   addresses: [
//     'string'
//   ]
//   autoAssign: 'True/False'
//   name: 'string'
//   onlyUseHostIps: 'True/False'
// }

// Cluster Configuration Parameters

@description('The version of Kubernetes to be used in the Nexus Kubernetes cluster')
param kubernetesVersion string = 'v1.27.1'

@description('The number of control plane nodes to be deployed in the cluster')
param controlPlaneCount int = 1

@description('The zones/racks used for placement of the control plane nodes')
param controlPlaneZones array = []
// "string" Example: ["1", "2", "3"]

@description('The zones/racks used for placement of the agent pool nodes')
param agentPoolZones array = []
// "string" Example: ["1", "2", "3"]

@description('The size of the control plane nodes')
param controlPlaneVmSkuName string = 'NC_G6_28_v1'

@description('The number of worker nodes to be deployed in the initial agent pool')
param systemPoolNodeCount int = 1

@description('The size of the worker nodes')
param workerVmSkuName string = 'NC_P10_56_v1'

@description('The configurations for the initial agent pool')
param initialPoolAgentOptions object = {}
// {
//   "hugepagesCount": integer,
//   "hugepagesSize": "2M/1G"
// }

@description('The cluster wide SSH public key that will be associated with the given user for secure remote login')
param sshPublicKeys array = []
// {
//   keyData: "ssh-rsa AAAAA...."
// },
// {
//   keyData: "ssh-rsa AAAAA...."
// }

@description('The control plane SSH public key that will be associated with the given user for secure remote login')
param controlPlaneSshKeys array = []
// {
//   keyData: "ssh-rsa AAAAA...."
// },
// {
//   keyData: "ssh-rsa AAAAA...."
// }

@description('The agent pool SSH public key that will be associated with the given user for secure remote login')
param agentPoolSshKeys array = []
// {
//   keyData: "ssh-rsa AAAAA...."
// },
// {
//   keyData: "ssh-rsa AAAAA...."
// }

@description('The labels to assign to the nodes in the cluster for identification and organization')
param labels array = []
// {
//   key: 'string'
//   value: 'string'
// }
@description('The taints to apply to the nodes in the cluster to restrict which pods can be scheduled on them')
param taints array = []
// {
//   key: 'string'
//   value: 'string:NoSchedule|PreferNoSchedule|NoExecute'
// }
@description('The association of IP address pools to the communities and peers, allowing for announcement of IPs.')
param bgpAdvertisements array = []

@description('"The list of additional BgpPeer entities that the Kubernetes cluster will peer with. All peering must be explicitly defined.')
param bgpPeers array = []

@description('The indicator to specify if the load balancer peers with the network fabric.')
param fabricPeeringEnabled string = 'False'


resource kubernetescluster 'Microsoft.NetworkCloud/kubernetesClusters@2025-02-01' = {
  name: kubernetesClusterName
  location: location
  tags: tags
  extendedLocation: {
    name: extendedLocation
    type: 'CustomLocation'
  }
  properties: {
    kubernetesVersion: kubernetesVersion
    managedResourceGroupConfiguration: {
      name: '${uniqueString(resourceGroup().name)}-${kubernetesClusterName}'
      location: location
    }
    aadConfiguration: {
      adminGroupObjectIds: adminGroupObjectIds
    }
    administratorConfiguration: {
      adminUsername: adminUsername
      sshPublicKeys: empty(sshPublicKeys) ? [] : sshPublicKeys
    }
    initialAgentPoolConfigurations: [
      {
        name: '${kubernetesClusterName}-nodepool-1'
        administratorConfiguration: {
          adminUsername: adminUsername
          sshPublicKeys: empty(agentPoolSshKeys) ? [] : agentPoolSshKeys
        }
        count: systemPoolNodeCount
        vmSkuName: workerVmSkuName
        mode: 'System'
        labels: empty(labels) ? null : labels
        taints: empty(taints) ? null : taints
        agentOptions: empty(initialPoolAgentOptions) ? null : initialPoolAgentOptions
        attachedNetworkConfiguration: {
          l2Networks: empty(agentPoolL2Networks) ? null : agentPoolL2Networks
          l3Networks: empty(agentPoolL3Networks) ? null : agentPoolL3Networks
          trunkedNetworks: empty(agentPoolTrunkedNetworks) ? null : agentPoolTrunkedNetworks
        }
        availabilityZones: empty(agentPoolZones) ? null : agentPoolZones
        upgradeSettings: {
          maxSurge: '1'
        }
      }
    ]
    controlPlaneNodeConfiguration: {
      administratorConfiguration: {
        adminUsername: adminUsername
        sshPublicKeys: empty(controlPlaneSshKeys) ? [] : controlPlaneSshKeys
      }
      count: controlPlaneCount
      vmSkuName: controlPlaneVmSkuName
      availabilityZones: empty(controlPlaneZones) ? null : controlPlaneZones
    }
    networkConfiguration: {
      cniNetworkId: cniNetworkId
      cloudServicesNetworkId: cloudServicesNetworkId
      dnsServiceIp: dnsServiceIp
      podCidrs: podCidrs
      serviceCidrs: serviceCidrs
      attachedNetworkConfiguration: {
        l2Networks: empty(l2Networks) ? null : l2Networks
        l3Networks: empty(l3Networks) ? null : l3Networks
        trunkedNetworks: empty(trunkedNetworks) ? null : trunkedNetworks
      }
      bgpServiceLoadBalancerConfiguration: {
        bgpAdvertisements: empty(bgpAdvertisements) ? null : bgpAdvertisements
        bgpPeers: empty(bgpPeers) ? null : bgpPeers
        fabricPeeringEnabled: fabricPeeringEnabled
        ipAddressPools: empty(ipAddressPools) ? null : ipAddressPools
      }
    }
  }
}

Nachdem Sie die Vorlagendatei überprüft kubernetes-deploy.bicepund gespeichert haben, fahren Sie mit dem nächsten Abschnitt fort, um die Vorlage bereitzustellen.

Bereitstellen der Bicep-Datei

  1. Erstellen Sie eine Datei namens kubernetes-deploy-parameters.json , und fügen Sie die erforderlichen Parameter im JSON-Format hinzu. Sie können das folgende Beispiel als Ausgangspunkt verwenden. Ersetzen Sie die Werte durch Ihre eigenen.
{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "kubernetesClusterName":{
      "value": "myNexusK8sCluster"
    },
    "adminGroupObjectIds": {
      "value": [
        "00000000-0000-0000-0000-000000000000"
      ]
    },
    "cniNetworkId": {
      "value": "/subscriptions/<subscription_id>/resourceGroups/<resource_group>/providers/Microsoft.NetworkCloud/l3Networks/<l3Network-name>"
    },
    "cloudServicesNetworkId": {
      "value": "/subscriptions/<subscription_id>/resourceGroups/<resource_group>/providers/Microsoft.NetworkCloud/cloudServicesNetworks/<csn-name>"
    },
    "extendedLocation": {
      "value": "/subscriptions/<subscription_id>/resourceGroups/<managed_resource_group>/providers/microsoft.extendedlocation/customlocations/<custom-location-name>"
    },
    "location": {
      "value": "eastus"
    },
    "sshPublicKeys": {
      "value": [
        {
          "keyData": "ssh-rsa AAAAA...."
        },
        {
          "keyData": "ssh-rsa BBBBB...."
        }
      ]
    }
  }
}
  1. Stellen Sie die Vorlage bereit.
    az deployment group create \
      --resource-group myResourceGroup \
      --template-file kubernetes-deploy.bicep \
      --parameters @kubernetes-deploy-parameters.json

Wenn nicht genügend Kapazität zum Bereitstellen angeforderter Clusterknoten vorhanden ist, wird eine Fehlermeldung angezeigt. Diese Meldung enthält jedoch keine Details zur verfügbaren Kapazität. Es gibt an, dass die Clustererstellung aufgrund unzureichender Kapazität nicht fortgesetzt werden kann.

Hinweis

Bei der Kapazitätsberechnung wird der gesamte Plattformcluster berücksichtigt, anstatt auf einzelne Racks beschränkt zu sein. Wenn also ein Agentpool in einer Zone (in der ein Rack einer Zone entspricht) mit unzureichender Kapazität erstellt wird, aber eine andere Zone über genügend Kapazität verfügt, wird die Clustererstellung fortgesetzt, wird aber letztendlich ein Timeout ausgeführt. Dieser Ansatz zur Kapazitätsüberprüfung ist nur sinnvoll, wenn während der Erstellung des Cluster- oder Agentpools keine bestimmte Zone angegeben wird.

Überprüfen der bereitgestellten Ressourcen

Nach Abschluss der Bereitstellung können Sie die Ressourcen mithilfe der CLI oder des Azure-Portals anzeigen.

Führen Sie den folgenden Azure CLI-Befehl aus, um die Details des myNexusK8sCluster Clusters in der myResourceGroup Ressourcengruppe anzuzeigen:

az networkcloud kubernetescluster show \
  --name myNexusK8sCluster \
  --resource-group myResourceGroup

Um eine Liste der Agentpoolnamen abzurufen, die dem myNexusK8sCluster Cluster in der myResourceGroup Ressourcengruppe zugeordnet sind, können Sie außerdem den folgenden Azure CLI-Befehl verwenden.

az networkcloud kubernetescluster agentpool list \
  --kubernetes-cluster-name myNexusK8sCluster \
  --resource-group myResourceGroup \
  --output table

Herstellen einer Verbindung mit dem Cluster

Nachdem der Nexus Kubernetes-Cluster erfolgreich erstellt und mit Azure Arc verbunden wurde, können Sie mit der Clusterverbindungsfunktion problemlos eine Verbindung damit herstellen. Mithilfe von Clusterverbindungen können Sie von nahezu überall auf Ihren Cluster zugreifen und diesen verwalten, was ideal für interaktive Entwicklungs-, Debugging- und Clusterverwaltungsaufgaben ist.

Ausführlichere Informationen zu verfügbaren Optionen finden Sie unter Herstellen einer Verbindung mit einem Azure Operator Nexus Kubernetes-Cluster.

Hinweis

Wenn Sie einen Nexus Kubernetes-Cluster erstellen, erstellt Nexus automatisch eine verwaltete Ressourcengruppe, die zum Speichern der Clusterressourcen in dieser Gruppe dient, wird die mit Arc verbundene Clusterressource eingerichtet.

Um auf Ihren Cluster zuzugreifen, müssen Sie die Clusterverbindung kubeconfigeinrichten. Nachdem Sie sich bei Azure CLI mit der relevanten Microsoft Entra-Entität angemeldet haben, können Sie die kubeconfig erforderliche Kommunikation mit dem Cluster von praktisch überall aus abrufen, auch außerhalb der Firewall, die sie umgibt.

  1. Legen Sie die Variablen CLUSTER_NAME, RESOURCE_GROUP und SUBSCRIPTION_ID fest.

    CLUSTER_NAME="myNexusK8sCluster"
RESOURCE_GROUP="myResourceGroup"
SUBSCRIPTION_ID=<set the correct subscription_id>

  2. Abfrage verwalteter Ressourcengruppe mit az und Speichern in MANAGED_RESOURCE_GROUP

     az account set -s $SUBSCRIPTION_ID
 MANAGED_RESOURCE_GROUP=$(az networkcloud kubernetescluster show -n $CLUSTER_NAME -g $RESOURCE_GROUP --output tsv --query managedResourceGroupConfiguration.name)

  3. Der folgende Befehl startet einen connectedk8s-Proxy, mit dem Sie eine Verbindung mit dem Kubernetes-API-Server für den angegebenen Nexus Kubernetes-Cluster herstellen können.

    az connectedk8s proxy -n $CLUSTER_NAME  -g $MANAGED_RESOURCE_GROUP &

  4. Wird kubectl verwendet, um Anforderungen an den Cluster zu senden:

    kubectl get pods -A

    Nun sollte eine Antwort des Clusters mit der Liste aller Knoten angezeigt werden.

Hinweis

Wenn die Fehlermeldung "Fehler beim Bereitstellen des Zugriffstokens an den Client-Proxy. Verbindung mit MSI konnte nicht hergestellt werden" angezeigt wird, müssen Sie sich möglicherweise bei Azure neu authentifizieren.

Hinzufügen eines Agentpools

Der im vorherigen Schritt erstellte Cluster verfügt über einen einzelnen Knotenpool. Fügen wir nun einen zweiten Agentpool mithilfe der Bicep-Datei hinzu. Im folgenden Beispiel wird ein Agentpool mit dem Namen myNexusK8sCluster-nodepool-2erstellt:

  1. Überprüfen Sie die Vorlage.

Bevor Sie die Agentpoolvorlage hinzufügen, überprüfen wir den Inhalt, um seine Struktur zu verstehen.

// Azure Parameters
@description('The name of Nexus Kubernetes cluster')
param kubernetesClusterName string

@description('The Azure region where the cluster is to be deployed')
param location string = resourceGroup().location

@description('The custom location of the Nexus instance')
param extendedLocation string

@description('Tags to be associated with the resource')
param tags object = {}

@description('The username for the administrative account on the cluster')
param adminUsername string = 'azureuser'

@description('The agent pool SSH public key that will be associated with the given user for secure remote login')
param agentPoolSshKeys array = []
// {
//   keyData: "ssh-rsa AAAAA...."
// },
// {
//   keyData: "ssh-rsa AAAAA...."
// }

// Cluster Configuration Parameters
@description('Number of nodes in the agent pool')
param agentPoolNodeCount int = 1

@description('Agent pool name')
param agentPoolName string = 'nodepool-2'

@description('VM size of the agent nodes')
param agentVmSku string = 'NC_P10_56_v1'

@description('The zones/racks used for placement of the agent pool nodes')
param agentPoolZones array = []
// "string" Example: ["1", "2", "3"]

@description('Agent pool mode')
param agentPoolMode string = 'User'

@description('The configurations for the initial agent pool')
param agentOptions object = {}
// {
//   "hugepagesCount": integer,
//   "hugepagesSize": "2M/1G"
// }

@description('The labels to assign to the nodes in the cluster for identification and organization')
param labels array = []
// {
//   key: 'string'
//   value: 'string'
// }
@description('The taints to apply to the nodes in the cluster to restrict which pods can be scheduled on them')
param taints array = []
// {
//   key: 'string'
//   value: 'string:NoSchedule|PreferNoSchedule|NoExecute'
// }

// Networking Parameters
@description('The Layer 2 networks to connect to the agent pool')
param l2Networks array = []
// {
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN|IPVLAN'
// }

@description('The Layer 3 networks to connect to the agent pool')
param l3Networks array = []
// {
//   ipamEnabled: 'True/False'
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN|IPVLAN'
// }

@description('The trunked networks to connect to the agent pool')
param trunkedNetworks array = []
// {
//   networkId: 'string'
//   pluginType: 'SRIOV|DPDK|OSDevice|MACVLAN|IPVLAN'
// }

resource agentPools 'Microsoft.NetworkCloud/kubernetesClusters/agentPools@2025-02-01' = {
  name: '${kubernetesClusterName}/${kubernetesClusterName}-${agentPoolName}'
  location: location
  tags: tags
  extendedLocation: {
    name: extendedLocation
    type: 'CustomLocation'
  }
  properties: {
    administratorConfiguration: {
      adminUsername: adminUsername
      sshPublicKeys: empty(agentPoolSshKeys) ? null : agentPoolSshKeys
    }
    attachedNetworkConfiguration: {
      l2Networks: empty(l2Networks) ? null : l2Networks
      l3Networks: empty(l3Networks) ? null : l3Networks
      trunkedNetworks: empty(trunkedNetworks) ? null : trunkedNetworks
    }
    count: agentPoolNodeCount
    mode: agentPoolMode
    vmSkuName: agentVmSku
    labels: empty(labels) ? null : labels
    taints: empty(taints) ? null : taints
    agentOptions: empty(agentOptions) ? null : agentOptions
    availabilityZones: empty(agentPoolZones) ? null : agentPoolZones
    upgradeSettings: {
      maxSurge: '1'
    }
  }
}

Nachdem Sie die Vorlagendatei überprüft kubernetes-add-agentpool.bicepund gespeichert haben, fahren Sie mit dem nächsten Abschnitt fort, um die Vorlage bereitzustellen.

  1. Erstellen Sie eine Datei namens kubernetes-nodepool-parameters.json , und fügen Sie die erforderlichen Parameter im JSON-Format hinzu. Sie können das folgende Beispiel als Ausgangspunkt verwenden. Ersetzen Sie die Werte durch Ihre eigenen.
{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
      "kubernetesClusterName":{
        "value": "myNexusK8sCluster"
      },
      "extendedLocation": {
        "value": "/subscriptions/<subscription_id>/resourceGroups/<resource_group>/providers/microsoft.extendedlocation/customlocations/<custom-location-name>"
      }
    }
  }
  1. Stellen Sie die Vorlage bereit.
    az deployment group create \
      --resource-group myResourceGroup \
      --template-file kubernetes-add-agentpool.bicep \
      --parameters @kubernetes-nodepool-parameters.json

Hinweis

Sie können während der ersten Erstellung Ihres Clusters mehrere Agentpools selbst hinzufügen, indem Sie die anfänglichen Agentpoolkonfigurationen verwenden. Wenn Sie jedoch Agentpools nach der ersten Erstellung hinzufügen möchten, können Sie den obigen Befehl verwenden, um zusätzliche Agentpools für Ihren Nexus Kubernetes-Cluster zu erstellen.

Das folgende Ausgabebeispiel ähnelt der erfolgreichen Erstellung des Agentpools.

$ az networkcloud kubernetescluster agentpool list --kubernetes-cluster-name myNexusK8sCluster --resource-group myResourceGroup --output table
This command is experimental and under development. Reference and support levels: https://aka.ms/CLI_refstatus
Count    Location    Mode    Name                          ProvisioningState    ResourceGroup    VmSkuName
-------  ----------  ------  ----------------------------  -------------------  ---------------  -----------
1        eastus      System  myNexusK8sCluster-nodepool-1  Succeeded            myResourceGroup  NC_P10_56_v1
1        eastus      User    myNexusK8sCluster-nodepool-2  Succeeded            myResourceGroup  NC_P10_56_v1

Bereinigen von Ressourcen

Wenn sie nicht mehr benötigt wird, löschen Sie die Ressourcengruppe. Die Ressourcengruppe und alle Ressourcen in der Ressourcengruppe werden gelöscht.

Verwenden Sie den Befehl " az group delete ", um die Ressourcengruppe, den Kubernetes-Cluster und alle zugehörigen Ressourcen außer den Operator Nexus-Netzwerkressourcen zu entfernen.

az group delete --name myResourceGroup --yes --no-wait

Nächste Schritte

Sie können die CNFs jetzt entweder direkt über cluster connect oder über Azure Operator Service Manager bereitstellen.

  • Last updated on