Installieren von AGIC mithilfe einer neuen Application Gateway-Bereitstellung

In den Anweisungen in diesem Artikel wird davon ausgegangen, dass Sie den Application Gateway-Eingangsdatencontroller (AGIC) in einer Umgebung ohne bereits vorhandene Komponenten installieren möchten.

Tipp

Ziehen Sie Application Gateway für Container für Ihre Kubernetes-Eingangslösung in Betracht. Weitere Informationen finden Sie unter Schnellstart: Bereitstellen des ALB-Controllers von Application Gateway für Container.

Installieren der erforderlichen Befehlszeilentools

Es wird empfohlen, Azure Cloud Shell für alle in diesem Artikel aufgeführten Befehlszeilenvorgänge zu verwenden. Sie können Cloud Shell öffnen, indem Sie die Schaltfläche Cloud Shell starten auswählen.

Alternativ können Sie Cloud Shell über das Azure-Portal öffnen, indem Sie das zugehörige Symbol auswählen.

Ihre Cloud Shell-Instanz verfügt bereits über alle erforderlichen Tools. Wenn Sie sich für die Verwendung einer anderen Umgebung entscheiden, stellen Sie sicher, dass die folgenden Befehlszeilentools installiert sind:

az: Azure CLI: (Installationsanleitungen)
kubectl: Kubernetes-Befehlszeilentool (Installationsanleitungen)
helm: Kubernetes-Paket-Manager (Installationsanleitungen)
jq: Befehlszeilen-JSON-Prozessor (Installationsanleitungen)

Erstellen einer Identität

Führen Sie die folgenden Schritte aus, um ein Microsoft Entra-Dienstprinzipalobjekt zu erstellen.

Erstellen Sie einen Active Directory-Dienstprinzipal, der eine Rolle rollenbasierte Azure-Zugriffssteuerung (RBAC) enthält:
```
az ad sp create-for-rbac --role Contributor --scopes /subscriptions/mySubscriptionID -o json > auth.json
appId=$(jq -r ".appId" auth.json)
password=$(jq -r ".password" auth.json)
```
Notieren Sie die Werte appId und password aus der JSON-Ausgabe. Sie werden sie in den nächsten Schritten verwenden.
Verwenden Sie den appId-Wert aus der Ausgabe des vorherigen Befehls, um die id des neuen Dienstprinzipals abzurufen:
```
objectId=$(az ad sp show --id $appId --query "id" -o tsv)
```
Die Ausgabe dieses Befehls lautet objectId. Notieren Sie diesen Wert, weil Sie ihn im nächsten Schritt verwenden werden.

Erstellen Sie die Parameterdatei, die Sie in der Bereitstellung der Azure Resource Manager-Vorlage (ARM-Vorlage) verwenden werden:

cat <<EOF > parameters.json
{
  "aksServicePrincipalAppId": { "value": "$appId" },
  "aksServicePrincipalClientSecret": { "value": "$password" },
  "aksServicePrincipalObjectId": { "value": "$objectId" },
  "aksEnableRBAC": { "value": false }
}
EOF

Um einen Kubernetes RBAC-fähigen Cluster bereitzustellen, legen Sie aksEnableRBAC auf true fest.

Komponenten bereitstellen

Mit dem folgenden Verfahren werden Ihrem Abonnement diese Komponenten hinzugefügt:

Azure Kubernetes Service (AKS)
Azure Application Gateway v2
Azure Virtual Network mit zwei Subnetzen
Öffentliche IP-Adresse
Verwaltete Identität, die von Microsoft Entra Workload-ID verwendet wird.

So stellen Sie die Komponenten bereit:

Laden Sie die ARM-Vorlage herunter:

wget https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/master/deploy/azuredeploy.json -O template.json

Stellen Sie die ARM-Vorlage mithilfe der Azure CLI bereit, und ändern Sie sie nach Bedarf. Die Bereitstellung kann bis zu 5 Minuten dauern.

resourceGroupName="MyResourceGroup"
location="westus2"
deploymentName="ingress-appgw"

# create a resource group
az group create -n $resourceGroupName -l $location

# modify the template as needed
az deployment group create \
        -g $resourceGroupName \
        -n $deploymentName \
        --template-file template.json \
        --parameters parameters.json

Nachdem die Bereitstellung abgeschlossen ist, laden Sie die Bereitstellungsausgabe in eine Datei namens deployment-outputs.json herunter:
```
az deployment group show -g $resourceGroupName -n $deploymentName --query "properties.outputs" -o json > deployment-outputs.json
```

Einrichten von AGIC

Mit den Anweisungen im vorherigen Abschnitt haben Sie einen neuen AKS-Cluster und eine Application Gateway-Bereitstellung erstellt und konfiguriert. Sie können nun eine Beispiel-App und einen Eingangsdatencontroller in unserer neuen Kubernetes-Infrastruktur bereitstellen.

Einrichten von Kubernetes-Anmeldeinformationen

Für die folgenden Schritte müssen Sie den Befehl kubectl konfigurieren, den Sie zum Herstellen einer Verbindung mit Ihrem neuen Kubernetes-Cluster verwenden. In Cloud Shell ist kubectl bereits installiert. Sie verwenden az (Azure CLI) zum Abrufen von Anmeldeinformationen für Kubernetes.

Rufen Sie Anmeldeinformationen für die neu bereitgestellte AKS-Instanz ab. Weitere Informationen zu den folgenden Befehlen finden Sie unter Verwenden der Azure RBAC für Kubernetes-Autorisierung mit kubectl.

# use the deployment-outputs.json file created after deployment to get the cluster name and resource group name
aksClusterName=$(jq -r ".aksClusterName.value" deployment-outputs.json)
resourceGroupName=$(jq -r ".resourceGroupName.value" deployment-outputs.json)

az aks get-credentials --resource-group $resourceGroupName --name $aksClusterName

Installieren der Microsoft Entra Workload-ID

Die Microsoft Entra Workload-ID bietet tokenbasierten Zugriff auf Azure Resource Manager.

Die Microsoft Entra Workload-ID fügt Ihrem Kubernetes-Cluster die folgenden Komponenten hinzu:

Kubernetes benutzerdefinierte Ressourcendefinitionen (CRDs): AzureIdentity, AzureAssignedIdentity, AzureIdentityBinding
MIC-Komponente (Managed Identity Controller)
NMI-Komponente (Node Managed Identity)

Verwenden Sie einen der folgenden Befehle, um die Microsoft Entra Workload-ID auf Ihrem Cluster zu installieren:

Für Kubernetes RBAC aktivierter AKS-Cluster:

kubectl create -f https://raw.githubusercontent.com/Azure/aad-pod-identity/master/deploy/infra/deployment-rbac.yaml

Für Kubernetes RBAC deaktivierter AKS-Cluster:

kubectl create -f https://raw.githubusercontent.com/Azure/aad-pod-identity/master/deploy/infra/deployment.yaml

Fügen Sie das Helm-Repository hinzu.

Helm ist ein Paket-Manager für Kubernetes. Sie verwenden ihn, um das application-gateway-kubernetes-ingress-Paket zu installieren.

Wenn Sie Cloud Shell verwenden, müssen Sie Helm nicht installieren. Cloud Shell ist in Helm Version 3 enthalten. Führen Sie einen der folgenden Befehle aus, um das AGIC Helm-Repository hinzuzufügen:

Für Kubernetes RBAC aktivierter AKS-Cluster:

kubectl create serviceaccount --namespace kube-system tiller-sa
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller-sa
helm init --tiller-namespace kube-system --service-account tiller-sa

Für Kubernetes RBAC deaktivierter AKS-Cluster:
```
helm init
```

Installieren des Helm-Diagramms des Eingangsdatencontrollers

Verwenden Sie die zuvor von Ihnen erstellte Datei deployment-outputs.json, um die folgenden Variablen zu erstellen:

applicationGatewayName=$(jq -r ".applicationGatewayName.value" deployment-outputs.json)
resourceGroupName=$(jq -r ".resourceGroupName.value" deployment-outputs.json)
subscriptionId=$(jq -r ".subscriptionId.value" deployment-outputs.json)
identityClientId=$(jq -r ".identityClientId.value" deployment-outputs.json)
identityResourceId=$(jq -r ".identityResourceId.value" deployment-outputs.json)

Laden Sie helm-config.yaml zum Konfigurieren von AGIC herunter:

wget https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/master/docs/examples/sample-helm-config.yaml -O helm-config.yaml

Oder kopieren Sie die folgende YAML-Datei:

# This file contains the essential configs for the ingress controller helm chart

# Verbosity level of the App Gateway Ingress Controller
verbosityLevel: 3

################################################################################
# Specify which application gateway the ingress controller will manage
#
appgw:
    subscriptionId: <subscriptionId>
    resourceGroup: <resourceGroupName>
    name: <applicationGatewayName>

    # Setting appgw.shared to "true" will create an AzureIngressProhibitedTarget CRD.
    # This prohibits AGIC from applying config for any host/path.
    # Use "kubectl get AzureIngressProhibitedTargets" to view and change this.
    shared: false

################################################################################
# Specify which kubernetes namespace the ingress controller will watch
# Default value is "default"
# Leaving this variable out or setting it to blank or empty string would
# result in Ingress Controller observing all accessible namespaces.
#
# kubernetes:
#   watchNamespace: <namespace>

################################################################################
# Specify the authentication with Azure Resource Manager
#
# Two authentication methods are available:
# - Option 1: AAD-Pod-Identity (https://github.com/Azure/aad-pod-identity)
armAuth:
    type: aadPodIdentity
    identityResourceID: <identityResourceId>
    identityClientID:  <identityClientId>

## Alternatively you can use Service Principal credentials
# armAuth:
#    type: servicePrincipal
#    secretJSON: <<Generate this value with: "az ad sp create-for-rbac --subscription <subscription-uuid> --role Contributor --sdk-auth | base64 -w0" >>

################################################################################
# Specify if the cluster is Kubernetes RBAC enabled or not
rbac:
    enabled: false # true/false

# Specify aks cluster related information. THIS IS BEING DEPRECATED.
aksClusterConfiguration:
    apiServerAddress: <aks-api-server-address>

Bearbeiten Sie die neu heruntergeladene Datei helm-config.yaml, und füllen Sie die Abschnitte für appgw und armAuth aus:
```
sed -i "s|<subscriptionId>|${subscriptionId}|g" helm-config.yaml
sed -i "s|<resourceGroupName>|${resourceGroupName}|g" helm-config.yaml
sed -i "s|<applicationGatewayName>|${applicationGatewayName}|g" helm-config.yaml
sed -i "s|<identityResourceId>|${identityResourceId}|g" helm-config.yaml
sed -i "s|<identityClientId>|${identityClientId}|g" helm-config.yaml
```
Hinweis

Wenn Sie eine Bereitstellung in einer souveränen Cloud (z. B. Azure Government) ausführen, müssen Sie den Konfigurationsparameter appgw.environment hinzufügen und auf den entsprechenden Wert festlegen.

Hier sind die -Werte aufgeführt:
- verbosityLevel: Legt die Ausführlichkeitsebene der AGIC-Protokollinfrastruktur fest. Unter Protokollierungsstufe finden Sie mögliche Werte.
- appgw.environment: Legt die Cloudumgebung fest. Mögliche Werte: AZURECHINACLOUD, AZUREGERMANCLOUD, AZUREPUBLICCLOUD, AZUREUSGOVERNMENTCLOUD.
- appgw.subscriptionId: Die ID des Azure-Abonnements, in dem sich die Application Gateway-Instanz befindet. Beispiel: aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e.
- appgw.resourceGroup: Name der Azure-Ressourcengruppe, in der Sie die Application Gateway-Bereitstellung erstellt haben. Beispiel: app-gw-resource-group.
- appgw.name: Name der Application Gateway-Bereitstellung Beispiel: applicationgatewayd0f0.
- appgw.shared: Boolesche Kennzeichnung, die standardmäßig false lautet Legen Sie diese auf true fest, wenn Sie eine freigegebene Application Gateway-Bereitstellung benötigen.
- kubernetes.watchNamespace: Gibt den Namespace an, den AGIC überwachen sollte. Beim Namespacewert kann es sich um eine einzelne Zeichenfolge oder eine durch Trennzeichen getrennte Liste von Namespaces handeln.
- armAuth.type: Kann aadPodIdentity oder servicePrincipal sein.
- armAuth.identityResourceID: Die Ressourcen-ID der verwalteten Azure-Identität
- armAuth.identityClientID: Die Client-ID der Identität
- armAuth.secretJSON: Wird nur benötigt, wenn Sie einen Dienstprinzipal als Geheimnistyp auswählen (d. h. wenn Sie armAuth.type auf servicePrincipal festlegen).
Hinweis

Sie haben die Werte identityResourceID und identityClientID in den vorherigen Schritte für die Bereitstellung von Komponenten erstellt. Sie können diese Werte mit dem folgenden Befehl abrufen:
```
az identity show -g <resource-group> -n <identity-name>
```
In dem Befehl steht <resource-group> für die Ressourcengruppe Ihrer Application Gateway-Bereitstellung. Der Platzhalter <identity-name> steht für den Namen der erstellten Identität. Sie können alle Identitäten für ein bestimmtes Abonnement mithilfe von az identity list auflisten.

Installieren Sie das AGIC-Paket:

helm install agic-controller oci://mcr.microsoft.com/azure-application-gateway/charts/ingress-azure --version 1.8.1 -f helm-config.yaml

Installieren einer Beispiel-App

Nach der Installation von Application Gateway, AKS und AGIC können Sie über Azure Cloud Shell eine Beispiel-App installieren:

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: aspnetapp
  labels:
    app: aspnetapp
spec:
  containers:
  - image: "mcr.microsoft.com/dotnet/samples:aspnetapp"
    name: aspnetapp-image
    ports:
    - containerPort: 8080
      protocol: TCP

---

apiVersion: v1
kind: Service
metadata:
  name: aspnetapp
spec:
  selector:
    app: aspnetapp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

---

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aspnetapp
  annotations:
    kubernetes.io/ingress.class: azure/application-gateway
spec:
  rules:
  - http:
      paths:
      - path: /
        pathType: Exact
        backend:
          service:
            name: aspnetapp
            port:
              number: 80
        pathType: Exact
EOF

Alternativ können Sie

Laden Sie die vorherige YAML-Datei herunter:

curl https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/master/docs/examples/aspnetapp.yaml -o aspnetapp.yaml

Wenden Sie die YAML-Datei an:
```
kubectl apply -f aspnetapp.yaml
```

Weitere Beispiele zum Verfügbarmachen eines AKS-Diensts über HTTP oder HTTPS mithilfe von Application Gateway finden Sie in dieser Anleitung.
Informationen zu Application Gateway für Container finden Sie in diesem Übersichtsartikel.

Feedback

War diese Seite hilfreich?

Last updated on 2025-04-04