Tutorial: Anwendungen mit GitOps und Argo CD bereitstellen

In diesem Lernprogramm wird beschrieben, wie Sie GitOps mit Argo CD in Azure Arc-fähigen Kubernetes-Clustern oder Azure Kubernetes Service (AKS)-Clustern verwenden. GitOps mit Argo CD ist als Clustererweiterung aktiviert, mit der Sie Ihr Git-Repository als Wahrheitsquelle für die Clusterkonfiguration und Anwendungsbereitstellung verwenden können. Argo CD unterstützt auch andere gängige Dateiquellen, z. B. Helm- und Open Container Initiative (OCI)-Repositorys.

Voraussetzungen

Um Anwendungen mit GitOps bereitzustellen, benötigen Sie entweder einen Azure Arc-fähigen Kubernetes-Cluster oder einen AKS-Cluster.

Kubernetes-Cluster mit Azure Arc-Unterstützung.

• Ein verbundener Kubernetes-Cluster, der mit Azure Arc aktiviert ist und läuft.

  Erfahren Sie, wie Sie einen Kubernetes-Cluster mit Azure Arc verbinden. Wenn Sie eine Verbindung über einen ausgehenden Proxy herstellen müssen, stellen Sie sicher, dass Sie die Arc-Agents mit Proxyeinstellungen installieren.

• Lese- und Schreibberechtigungen für den Ressourcentyp Microsoft.Kubernetes/connectedClusters

Azure Kubernetes Service-Cluster

• Ein AKS-Cluster auf Basis von Managed Service Identity (MSI), der ausgeführt wird. Sie müssen den AKS-Cluster mit MSI erstellen, nicht mit Dienstprinzipalname (Service Principal Name, SPN), damit diese Erweiterung funktioniert.

  • Bei neuen AKS-Clustern, die mit az aks create erstellt werden, ist der Cluster standardmäßig MSI-basiert.
  • Um SPN-basierte Cluster in MSI zu konvertieren, führen Sie az aks update -g $RESOURCE_GROUP -n $CLUSTER_NAME --enable-managed-identity aus.
  • Weitere Informationen finden Sie unter Verwenden einer verwalteten Identität in AKS.

• Lese- und Schreibberechtigungen für den Ressourcentyp Microsoft.ContainerService/managedClusters

Für beide Clustertypen

Um die Argo CD-Erweiterung zu installieren, benötigen Sie die Rolle "Kubernetes Extension Contributor" . Nachdem Sie Argo CD bereitgestellt haben, können Sie Argo CD RBAC-Richtlinien definieren, Namespaces konfigurieren und Anwendungsprojekte erstellen, die das Argo CD-Verhalten steuern. Sie können sich auch Argo CD-Administratorrechte gewähren. Mithilfe des Argo CD-Administratorzugriffs können Sie Anwendungen in jedem konfigurierten Namespace im Cluster bereitstellen und verwalten. In der Praxis stellt der Administratorzugriff Funktionen bereit, die effektiv den Clusteradministratorberechtigungen entsprechen.

• Lese- und Schreibberechtigungen für den Ressourcentyp: Microsoft.KubernetesConfiguration/extensions

• Azure-Befehlszeilenschnittstelle ab Version 2.15. Installieren Sie die Azure CLI , oder verwenden Sie die folgenden Befehle, um auf die neueste Version zu aktualisieren:

  az version
  az upgrade
  

• Der Kubernetes-Befehlszeilenclient kubectl. kubectl ist bereits installiert, wenn Sie Azure Cloud Shell verwenden.

  kubectl lokal mithilfe des Befehls az aks install-cli installieren:

  az aks install-cli
  

• Registrierung der folgenden Azure-Ressourcenanbieter:

  az provider register --namespace Microsoft.Kubernetes
  az provider register --namespace Microsoft.ContainerService
  az provider register --namespace Microsoft.KubernetesConfiguration
  

  Die Registrierung ist ein asynchroner Prozess und sollte innerhalb von 10 Minuten abgeschlossen sein. Verwenden Sie zum Überwachen des Registrierungsprozesses den folgenden Befehl:

  az provider show -n Microsoft.KubernetesConfiguration -o table
  
  Namespace                          RegistrationPolicy    RegistrationState
  ---------------------------------  --------------------  -------------------
  Microsoft.KubernetesConfiguration  RegistrationRequired  Registered
  

• Während die Quelle in diesem Lernprogramm ein Git-Repository ist, unterstützt Argo CD andere gängige Dateiquellen wie Helm- und Open Container Initiative (OCI)-Repositorys.

Versions- und Regionsunterstützung

GitOps wird derzeit in öffentlichen Regionen unterstützt.

Netzwerkanforderungen

Die GitOps-Agents benötigen ausgehenden TCP-Datenverkehr zur Repository-Quelle über Port 22 (SSH) oder Port 443 (HTTPS), um zu funktionieren. Die Agents benötigen außerdem Zugriff auf die folgenden ausgehenden URLs:

Aktivieren der CLI-Erweiterungen

Installieren Sie die neuesten CLI-Erweiterungspakete k8s-configuration und k8s-extension:

az extension add -n k8s-configuration
az extension add -n k8s-extension

So aktualisieren Sie diese Pakete auf die neuesten Versionen

az extension update -n k8s-configuration
az extension update -n k8s-extension

Verwenden Sie den folgenden Befehl, um eine Liste aller installierten Azure CLI-Erweiterungen und deren Versionen anzuzeigen:

az extension list -o table

Experimental   ExtensionType   Name                   Path                                                       Preview   Version
-------------  --------------  -----------------      -----------------------------------------------------      --------  --------
False          whl             connectedk8s           C:\Users\somename\.azure\cliextensions\connectedk8s         False     1.10.7
False          whl             k8s-configuration      C:\Users\somename\.azure\cliextensions\k8s-configuration    False     2.2.0
False          whl             k8s-extension          C:\Users\somename\.azure\cliextensions\k8s-extension        False     1.6.4

Erstellen der Erweiterung GitOps (Argo CD) (einfache Installation)

Die GitOps Argo CD-Installation unterstützt Mehrinstanzenfähigkeit im Hochverfügbarkeitsmodus (HA) und unterstützt die Workload-Identität.

Der HA-Modus ist die Standardkonfiguration und erfordert zum Installieren des Clusters vier Knoten. Der folgende Befehl fügt --config "redis-ha.enabled=false" hinzu, um die Erweiterung auf einem einzelnen Knoten zu installieren.

Mit diesem Befehl wird die einfachste Konfiguration erstellt, indem die Argo CD-Komponenten mit clusterweitem Zugriff auf einen neuen argocd Namespace installiert werden. Der clusterweite Zugriff ermöglicht die Erkennung von Argo CD-App-Definitionen in allen Namespaces, die in der Konfiguration der Argo CD configmap im Cluster aufgeführt sind. Beispiel: namespace1,namespace2

az k8s-extension create --resource-group <resource-group> \
  --cluster-name <cluster-name> \
  --cluster-type managedClusters \
  --name argocd \
  --extension-type Microsoft.ArgoCD \
  --config "redis-ha.enabled=false" \
  --config "configs.params.application\.namespaces=namespace1,namespace2"

Dieser Installationsbefehl erstellt einen neuen <namespace> Namespace und installiert die Argo CD-Komponenten in der <namespace>. Argo CD-Anwendungsdefinitionen in dieser Konfiguration funktionieren nur im <namespace> Namespace.

Weitere Konfigurationsoptionen, z. B. Ressourcenbeschränkungen, finden Sie unter values.yaml. Verwenden Sie diese Konfigurationen beim Konfigurieren der Erweiterung in Ihrem Azure CLI-Befehl.

Erstellen einer GitOps (Argo CD) Erweiterung mit Workload Identity

Eine alternative Installationsmethode, die für die Produktionsverwendung empfohlen wird, ist die Workloadidentität. Diese Methode verwendet Microsoft Entra ID Identitäten, um sich bei Azure Ressourcen zu authentifizieren, sodass Sie keine geheimen Schlüssel oder Anmeldeinformationen in Ihrem Git-Repository verwalten müssen. Diese Installation verwendet die Workload-Identitätsauthentifizierung, die in der Version 3.0.0-rc2 oder höher von Argo CD aktiviert ist.

Der HA-Modus ist die Standardkonfiguration und erfordert zum Installieren des Clusters vier Knoten. Verwenden Sie 'redis-ha.enabled': false, um die Erweiterung auf einem einzelnen Knoten zu installieren.

Um die Erweiterung mit Workload-Identität zu erstellen, ersetzen Sie zuerst die folgenden Variablen durch Ihre eigenen Werte in dieser Bicep-Vorlage:

var clusterName = '<aks-or-arc-cluster-name>'

var workloadIdentityClientId = 'replace-me##-##-###-###'
var ssoApplicationClientId = 'replace-me##-##-###-###'

var url = 'https://<public-ip-for-argocd-ui>/'
var oidcConfig = '''
name: Azure
issuer: https://login.microsoftonline.com/<your-tenant-id>/v2.0
clientID: <same-value-as-ssoApplicationClientId>
azure:
  useWorkloadIdentity: true
requestedIDTokenClaims:
  groups:
    essential: true
requestedScopes:
  - openid
  - profile
  - email
'''

var defaultPolicy = 'role:readonly'
var policy = '''
p, role:org-admin, applications, *, */*, allow
p, role:org-admin, clusters, get, *, allow
p, role:org-admin, repositories, get, *, allow
p, role:org-admin, repositories, create, *, allow
p, role:org-admin, repositories, update, *, allow
p, role:org-admin, repositories, delete, *, allow
g, replace-me##-argocd-ui-entra-group-admin-id, role:org-admin
'''

resource cluster 'Microsoft.ContainerService/managedClusters@2024-10-01' existing = {
  name: clusterName
}

resource extension 'Microsoft.KubernetesConfiguration/extensions@2023-05-01' = {
  name: 'argocd'
  scope: cluster
  properties: {
    extensionType: 'Microsoft.ArgoCD'
    configurationSettings: {
      'redis-ha.enabled': 'true'
      'azure.workloadIdentity.enabled': 'true'
      'azure.workloadIdentity.clientId': workloadIdentityClientId
      'azure.workloadIdentity.entraSSOClientId': ssoApplicationClientId
      'configs.cm.oidc\\.config': oidcConfig
      'configs.cm.url': url
      'configs.rbac.policy\\.default': defaultPolicy
      'configs.rbac.policy\\.csv': policy
      'configs.params.application\\.namespaces': 'default, argocd'
   }
  }
}

Erstellen Sie die Bicep Vorlage mit dem folgenden Befehl:

az deployment group create --resource-group <resource-group> --template-file <bicep-file>

Weitere Konfigurationsoptionen, z. B. Ressourcenbeschränkungen, finden Sie unter values.yaml. Verwenden Sie diese Konfigurationen in der Bicep-Vorlage beim Konfigurieren der Erweiterung.

Parameter

clusterName ist der Name des AKS- oder Arc-fähigen Kubernetes-Clusters.

workloadIdentityClientId ist die Client-ID der vom Benutzer zugewiesenen verwalteten Identität, die von den Argo CD-Komponenten für die Workload-Identität verwendet wird.

ssoApplicationClientId ist die Anwendungs-ID (Client) der Microsoft Entra App-Registrierung, die für die OIDC SSO-Authentifizierung für die Argo CD UI verwendet wird. Weitere Informationen zur allgemeinen Einrichtung und Konfiguration von ssoApplicationClientId finden Sie unter Microsoft Entra ID App-Registrierungsauthentifizierung mit OIDC.

url ist die öffentliche IP der Argo CD UI. Es gibt keinen öffentlichen IP- oder Domänennamen, es sei denn, der Cluster verfügt bereits über einen kundeneigenen Eingangscontroller. Wenn ja, müssen Sie die Eingangsregel nach der Bereitstellung zur Argo CD-Benutzeroberfläche hinzufügen. Die Eingangsfunktion erfordert das Anwendungsrouting-Add-On und wird nur für AKS-Cluster unterstützt.

oidcConfig – Ersetzen Sie <your-tenant-id> durch die Mandanten-ID Ihrer Microsoft Entra-ID. Ersetzen Sie <same-value-as-ssoApplicationClientId-above> durch denselben Wert wie ssoApplicationClientId.

policy Variable sind die argocd-rbac-cm configmap Einstellungen von Argo CD. g, replace-me##-argocd-ui-entra-group-admin-id ist die Microsoft Entra-Gruppen-ID, die Administratorzugriff auf die Ui der Argo CD gewährt. Sie finden die Microsoft Entra-Gruppen-ID im Azure-Portal unter Microsoft Entra ID > Gruppen >Ihr Gruppenname> Eigenschaften. Sie können die Microsoft Entra-Benutzer-ID anstelle einer Microsoft Entra-Gruppen-ID verwenden. Sie finden die Microsoft Entra-Benutzer-ID im Azure-Portal unter Microsoft Entra ID > Benutzer >Ihr Benutzername> Eigenschaften.

Erstellen von Anmeldeinformationen für die Workloadidentität

Führen Sie die folgenden Schritte aus, um neue Anmeldeinformationen für die Workloadidentität einzurichten:

1. Rufen Sie die OIDC-Aussteller-URL für Ihren AKS-Cluster oder Arc-fähigen Kubernetes-Cluster ab.

2. Erstellen Sie eine verwaltete Identität , und notieren Sie ihre Client-ID und Mandanten-ID.

3. Richten Sie verteilte Identitätsnachweise für Ihr AKS-Cluster oder Arc-fähiges Kubernetes-Cluster ein. Beispiel:

   # For source-controller
   az identity federated-credential create \
     --name ${FEDERATED_IDENTITY_CREDENTIAL_NAME} \
     --identity-name "${USER_ASSIGNED_IDENTITY_NAME}" \
     --resource-group "${RESOURCE_GROUP}" \
     --issuer "${OIDC_ISSUER}" \
     --subject
   

4. Weisen Sie der Ressource, die der Image-Reflector-Controller argocd oder argocd-repo-server abrufen soll, die richtigen Berechtigungen für die Workload-Identität zu. Wenn Sie z. B. Azure Container Registry verwenden, stellen Sie sicher, dass entweder Container Registry Repository Reader (für ABAC-fähige Registrierungen) oder AcrPull (für Nicht-ABAC-Registrierungen) angewendet wird.

Herstellen einer Verbindung mit privaten ACR-Registrierungen oder ACR-Repositorys mithilfe der Workload-Identität

Um die private ACR-Registrierung oder ACR-Repositorys zu verwenden, befolgen Sie die Anweisungen in der offiziellen Argo CD-Dokumentation für die Verbindung mit privaten ACR-Registern. Die Schritte Bezeichnung der Pods, Erstellen von Verbundidentitätsanmeldeinformationen und Hinzufügen von Anmerkungen zu Dienstkonto in diesem Leitfaden wurden durch die Erweiterung mit der Bicep-Bereitstellung abgeschlossen und können übersprungen werden.

Migrieren von Argo CD OSS zur verwalteten Argo CD-Erweiterung

Führen Sie diese Schritte aus, um von einer selbstverwalteten Argo CD-Installation zur Azure verwalteten Argo CD-Erweiterung zu migrieren.

Migrationspfad

Verwenden Sie die folgende Sequenz, um Controllerkonflikte zu vermeiden und das Migrationsrisiko zu verringern.

1. Überprüfen Sie Ihre aktuelle Argo CD-Konfiguration und Ihren Bestand:

   • Applications
   • ApplicationSets
   • AppProjects
   • Repository-Anmeldeinformationen und -vorlagen (repocreds)
   • Cluster-Geheimnisse

2. Skalieren Sie selbstverwaltete Argo CD-Controller auf Nullreplikate, um das Verhalten von Dualcontrollern zu verhindern.

3. Installieren Sie die Argo CD-Erweiterung auf dem Cluster mithilfe von Einstellungen, die Ihrer vorhandenen Bereitstellung entsprechen.

4. Die Funktion „Anwendungen in jedem Namespace“ ermöglicht Argo CD, Ressourcen außerhalb seines Kern-Namespace zu verwalten. Wenn Ihr Cluster diese Einstellung bereits verwendet, müssen Sie Ihre Ressourcen nicht in einen neuen Namespace verschieben. Sie müssen die neue Erweiterung nur so konfigurieren, dass sie die Namespaces Ihrer vorhandenen Anwendung überwacht.

   Fall A: Wenn Sie das Feature Anwendungen in einem beliebigen Namespace bereits verwenden:

   1. Behalten Sie alle Application-, ApplicationSet- und AppProject-Ressourcen in ihren aktuellen Namespaces bei.
   2. Konfigurieren Sie die neue verwaltete Erweiterung, um diese externen Namespaces über die Einstellungen der Erweiterung zu überwachen.

   Fall B: Wenn Sie Ressourcen in den neuen Erweiterungsnamespace verschieben:

   • Migrieren Sie Anwendungen, ApplicationSets und AppProjects bei Bedarf zum Erweiterungsnamespace.

5. Migrieren Sie Repository-Anmeldedaten, Cluster-Geheimnisse und repocreds in den Erweiterungs-Namespace.

6. Überprüfen Sie, ob Anwendungen synchronisiert werden und den erwarteten fehlerfreien Zustand erreichen.

7. Entfernen Sie die alte selbstverwaltete Argo CD-Bereitstellung nach Abschluss der Überprüfung.

Die verwaltete Erweiterung verwendet dieselben Argo CD-APIs und benutzerdefinierte Ressourcendefinitionen (CRDs), sodass Sie die meisten vorhandenen Manifeste mit minimalen Änderungen wiederverwenden können.

Aktuelle Einschränkungen

• Direkte Updates für Argo CD ConfigMaps werden nicht unterstützt.
• Verwenden Sie die Erweiterungskonfigurations-API und -Einstellungen, um Änderungen der Argo CD-Konfiguration anzuwenden.

Überwachung mit Azure Managed Prometheus und Azure Managed Grafana konfigurieren

Sie können Argo CD-Metriken für Azure Managed Prometheus veröffentlichen und in Azure Managed Grafana visualisieren.

1. Aktivieren Sie Azure verwalteten Prometheus für Ihren Cluster. Siehe Aktivieren der Überwachung für Azure Kubernetes Service (AKS) Cluster.

2. Aktualisieren Sie Ihre Erweiterungskonfiguration, um Metriken und ServiceMonitors zu aktivieren.

   var clusterName = '<aks-or-arc-cluster-name>'
   
   resource cluster 'Microsoft.ContainerService/managedClusters@2024-10-01' existing = {
     name: clusterName
   }
   
   resource extension 'Microsoft.KubernetesConfiguration/extensions@2023-05-01' = {
     name: 'argocd'
     scope: cluster
     properties: {
       extensionType: 'Microsoft.ArgoCD'
       configurationSettings: {
         // Keep your existing settings and add these metrics flags.
         'controller.metrics.enabled': 'true'
         'controller.metrics.serviceMonitor.enabled': 'true'
         'server.metrics.enabled': 'true'
         'server.metrics.serviceMonitor.enabled': 'true'
         'repoServer.metrics.enabled': 'true'
         'repoServer.metrics.serviceMonitor.enabled': 'true'
         'applicationSet.metrics.enabled': 'true'
         'applicationSet.metrics.serviceMonitor.enabled': 'true'
         'apiVersionOverrides.monitoring': 'azmonitoring.coreos.com/v1'
       }
     }
   }
   

3. Importieren Sie grafana dashboard 14584 in Ihre Azure Managed Grafana Instanz.

4. Wenn Panels Keine Daten anzeigen, aktualisieren Sie die Abfragen der Panels, damit die Benennung von Jobs in Azure Managed Prometheus berücksichtigt wird.

5. Ändern Sie in den Controller-Telemetrie-Bedienfeldern (Speicherauslastung, CPU-Auslastung, Goroutines) Folgendes:

   • Von job="argocd-metrics"
   • An job=~"argocd.*-metrics"

6. Ändern Sie in den Repo-Server-Panels (Verwendeter Speicher, Goroutines):

   • Von job="argocd-repo-server"
   • An job="argocd-repo-server-metrics"

7. Speichern Sie das Dashboard, und überprüfen Sie die Erfassung von Metriken.

Aktivieren von Argo CD im Azure Portal

Sie können argo CD im Azure-Portal aktivieren, um den Anwendungsstatus und den Synchronisierungsstatus anzuzeigen und auf die Argo CD-Benutzeroberfläche zuzugreifen. Führen Sie die folgenden Schritte aus, um Argo CD im Azure-Portal zu aktivieren:

1. Wechseln Sie zum Cluster im Azure-Portal.

2. Wählen Sie im Dienstmenü unter "Einstellungen" GitOps aus.

3. Wählen Sie "Argo CD aktivieren" (Vorschau) aus.

4. Im Abschnitt "Grundlagen" :

   1. Legen Sie den Namespace fest, in dem Argo CD ausgeführt wird. Standardmäßig ist der Namensraum argocd.
   2. Aktivieren Sie bei Bedarf Redis High Availability (HA). Diese Option erfordert mindestens vier Knoten im Cluster.
   3. Fügen Sie optional zusätzliche Namespaces hinzu, die beobachtet werden sollen.
   4. Aktivieren Sie für AKS-Cluster optional einmaliges Anmelden (Single Sign-On, SSO), sodass Benutzer sich mit Microsoft Entra ID anmelden können, indem Sie eine Anwendung und eine oder mehrere Gruppen angeben, um den Zugriff auf die Argo CD-Benutzeroberfläche zu ermöglichen.
   5. Aktivieren Sie bei Bedarf die Workload-Identität, damit Argo CD sicher auf Azure-Dienste zugreifen kann, ohne Geheimnisse zu speichern. Wählen Sie dazu das Feld "Workloadidentität aktivieren" aus, und geben Sie eine verwaltete Identität und eine Azure Container Registry an, aus der Anwendungsmanifeste oder Containerartefakte abgerufen werden sollen.

   

5. Klicken Sie auf Weiter, um fortzufahren.

6. Bei AKS-Clustern, die das Anwendungsrouting-Add-On aktiviert haben, können Sie auf der Registerkarte "Ingress " eine Ingress-Ressource erstellen, um den Datenverkehr an einen Dienst weiterzuleiten. Wenn gewünscht, wählen Sie "Ingress aktivieren" aus, und geben Sie Ihren Ingress-Namen, die Zertifikatdetails und den Domänennamen ein. Klicken Sie auf Weiter, um fortzufahren.

7. Überprüfen Sie im Abschnitt "Überprüfen + Bereitstellen" Ihre Einstellungen, und wählen Sie dann "Bereitstellen" aus, um Argo CD auf Ihrem Cluster zu aktivieren.

Zugriff auf die UI von Argo CD

Wenn kein Eingangscontroller für den AKS-Cluster vorhanden ist, können Sie die Argo CD-Benutzeroberfläche direkt mit einem LoadBalancer-Dienst verfügbar machen. Der folgende Befehl macht die Argo CD UI an den Ports 80 und 443 verfügbar.

kubectl -n argocd expose service argocd-server --type LoadBalancer --name argocd-server-lb --port 80 --target-port 8080

Um über das Azure Portal auf die Argo CD-Benutzeroberfläche zuzugreifen, wechseln Sie zu Ihrem Cluster. Wählen Sie im Dienstmenü unter "Einstellungen" GitOps aus. Wählen Sie dann den Link für die Argo CD-Benutzeroberfläche aus.

Bereitstellen der Argo CD-Anwendung

Nachdem Sie die Argo CD-Erweiterung installiert haben, können Sie eine Anwendung mithilfe der Argo CD UI oder CLI bereitstellen. Im folgenden Beispiel wird kubectl apply verwendet, um AKS Store innerhalb einer Argo CD-Anwendung im Standardprojekt von Argo CD im Namespace argocd bereitzustellen.

kubectl apply -f - <<EOF
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: aks-store-demo
  namespace: argocd
spec:
  project: default
  source:
      repoURL: https://github.com/Azure-Samples/aks-store-demo.git
      targetRevision: HEAD
      path: kustomize/overlays/dev
  syncPolicy:
      automated: {}
  destination:
      namespace: argocd
      server: https://kubernetes.default.svc
EOF

Die AKS Store-Demoanwendung wird im argocd Namespace installiert. Folgen Sie diesen Anweisungen, um die Anwendungswebseite anzuzeigen. Achten Sie darauf, die IP-Adresse über http aufzurufen und nicht über https.

Aktuelen der Erweiterungskonfiguration

Argo CD configmaps können nach der Installation und anderen Erweiterungskonfigurationseinstellungen mithilfe des folgenden Befehls aktualisiert werden:

az k8s-extension update --resource-group <resource-group> \
  --cluster-name <cluster-name> \
  --cluster-type <cluster-type> \
  --name argocd \
  --config "configs.cm.url='https://<public-ip-for-argocd-ui>/auth/callback'"

Aktualisieren Sie die Argo CD configmap über die Erweiterung, sodass die Einstellungen nicht überschrieben werden. Das Anwenden der Bicep-Vorlage ist eine alternative Methode zur Verwendung von Azure CLI zum Aktualisieren der Konfiguration.

Löschen Sie die Erweiterung

Verwenden Sie die folgenden Befehle, um die Erweiterung zu löschen.

az k8s-extension delete -g <resource-group> -c <cluster-name> -n argocd -t managedClusters --yes

Nächste Schritte

• Dateiprobleme und Featureanforderungen im Azure/AKS-Repository. Achten Sie darauf, das Wort ArgoCD in die Beschreibung oder den Titel einzuschließen.
• Entdecken Sie das technische Code-Beispiel für die AKS-Plattform, das OSS Argo CD mit Backstage und Cluster API Provider for Azure (CAPZ) oder Crossplane bereitstellt.