Instalowanie programu AGIC przy użyciu nowego wdrożenia usługi Application Gateway

2025-04-09

W instrukcjach w tym artykule przyjęto założenie, że chcesz zainstalować kontroler Ingress Application Gateway (AGIC) w środowisku, które nie ma wcześniej istniejących komponentów.

Napiwek

Rozważ Application Gateway dla kontenerów jako rozwiązanie ingress dla Kubernetes. Aby uzyskać więcej informacji, zobacz Szybki start: wdrażanie usługi Application Gateway dla Kontrolera ALB do kontenerów.

Instalowanie wymaganych narzędzi wiersza polecenia

Zalecamy użycie usługi Azure Cloud Shell dla wszystkich operacji wiersza polecenia w tym artykule. Możesz otworzyć usługę Cloud Shell, wybierając przycisk Uruchom usługę Cloud Shell .

Alternatywnie otwórz usługę Cloud Shell w witrynie Azure Portal, wybierając jej ikonę.

Twoja instancja usługi Cloud Shell ma już wszystkie niezbędne narzędzia. Jeśli zdecydujesz się korzystać z innego środowiska, upewnij się, że są zainstalowane następujące narzędzia wiersza polecenia:

az: Interfejs wiersza polecenia platformy Azure (instrukcje instalacji)
kubectl: Narzędzie wiersza polecenia kubernetes (instrukcje instalacji)
helm: Menedżer pakietów Kubernetes (instrukcje instalacji)
jq: Procesor JSON wiersza polecenia (instrukcje instalacji)

Tworzenie tożsamości

Wykonaj poniższe kroki, aby utworzyć obiekt głównego użytkownika usługi Entra firmy Microsoft.

Utwórz jednostkę usługi Active Directory, która obejmuje rolę kontroli dostępu na podstawie ról (RBAC) platformy Azure:
```
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)
```
Zapisz wartości appId i password z danych wyjściowych JSON. Użyjesz ich w następnych krokach.
Użyj wartości appId z danych wyjściowych poprzedniego polecenia, aby uzyskać id nowej jednostki usługi.
```
objectId=$(az ad sp show --id $appId --query "id" -o tsv)
```
Dane wyjściowe tego polecenia to objectId. Zapisz tę wartość, ponieważ użyjesz jej w następnym kroku.

Utwórz plik parametrów, który będzie używany we wdrożeniu szablonu usługi Azure Resource Manager (szablon usługi ARM):

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

Aby wdrożyć klaster z obsługą RBAC Kubernetes, ustaw aksEnableRBAC na true.

Wdróż składniki

Poniższa procedura dodaje te składniki do subskrypcji:

Azure Kubernetes Service (AKS)
Bramka aplikacji Azure w wersji 2
Usługa Azure Virtual Network z dwiema podsieciami
Publiczny adres IP
Tożsamość zarządzana, którą będzie używała usługa Microsoft Entra Pod Identity.

Aby wdrożyć składniki:

Pobierz szablon usługi ARM:

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

Wdróż szablon usługi ARM przy użyciu interfejsu wiersza polecenia platformy Azure i zmodyfikuj go zgodnie z potrzebami. Wdrożenie może potrwać do 5 minut.

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

Po zakończeniu wdrażania pobierz dane wyjściowe wdrożenia do pliku o nazwie deployment-outputs.json:

az deployment group show -g $resourceGroupName -n $deploymentName --query "properties.outputs" -o json > deployment-outputs.json

Konfigurowanie AGIC

Zgodnie z instrukcjami w poprzedniej sekcji utworzono i skonfigurowano nowy klaster usługi AKS oraz wdrożenie usługi Application Gateway. Teraz możesz wdrożyć przykładową aplikację i kontroler wejściowy na nowej infrastrukturze Kubernetes.

Konfigurowanie poświadczeń platformy Kubernetes

Aby wykonać poniższe kroki, należy skonfigurować polecenie kubectl , którego użyjesz do nawiązania połączenia z nowym klastrem Kubernetes. Usługa Cloud Shell została kubectl już zainstalowana. Użyjesz az (interfejsu wiersza polecenia platformy Azure), aby uzyskać poświadczenia dla platformy Kubernetes.

Pobierz poświadczenia dla nowo wdrożonej instancji usługi AKS. Aby uzyskać więcej informacji na temat następujących poleceń, zobacz Używanie kontroli dostępu opartej na rolach platformy Azure dla autoryzacji na platformie Kubernetes za pomocą narzędzia 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

Instalowanie tożsamości pod firmy Microsoft Entra

Usługa Microsoft Entra Pod Identity zapewnia dostęp oparty na tokenach do usługi Azure Resource Manager.

Usługa Microsoft Entra Pod Identity dodaje następujące składniki do klastra Kubernetes:

Definicje zasobów własnych platformy Kubernetes (CRD): AzureIdentity, AzureAssignedIdentity, AzureIdentityBinding
Składnik Managed Identity Controller (MIC)
Składnik tożsamości zarządzanej węzła (NMI)

Aby zainstalować usługę Microsoft Entra Pod Identity w klastrze, użyj jednego z następujących poleceń:

Klaster usługi AKS na platformie Kubernetes z obsługą RBAC (kontroli dostępu opartej na rolach):

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

Klaster AKS na platformie Kubernetes z wyłączonym RBAC

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

Dodaj repozytorium Helm

Helm jest menedżerem pakietów dla platformy Kubernetes. Służy do instalowania pakietu application-gateway-kubernetes-ingress.

Jeśli używasz usługi Cloud Shell, nie musisz instalować programu Helm. Usługa Cloud Shell jest dostarczana z programem Helm w wersji 3. Uruchom jedno z następujących poleceń, aby dodać repozytorium AGIC Helm:

Klaster AKS platformy Kubernetes z włączonym RBAC

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

Klaster AKS platformy Kubernetes z wyłączonym RBAC.
```
helm init
```

Zainstaluj wykres Helm kontrolera wejściowego

Użyj utworzonego deployment-outputs.json wcześniej pliku, aby utworzyć następujące zmienne:

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)

Pobierz helm-config.yamlplik , który konfiguruje program AGIC:

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

Możesz też skopiować następujący plik YAML:

# 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>

Edytuj nowo pobrany helm-config.yaml plik i wypełnij sekcje dla appgw i armAuth:
```
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
```
Uwaga

Jeśli wdrażasz w suwerennej chmurze (na przykład Azure Government), musisz dodać appgw.environment parametr konfiguracji i ustawić ją na odpowiednią wartość.

Oto wartości:
- verbosityLevel: ustawia poziom szczegółowości infrastruktury rejestrowania AGIC. Aby uzyskać możliwe wartości, zobacz Poziomy rejestrowania.
- appgw.environment: Ustawia środowisko chmury. Możliwe wartości: AZURECHINACLOUD, , AZUREGERMANCLOUDAZUREPUBLICCLOUD, AZUREUSGOVERNMENTCLOUD.
- appgw.subscriptionId: identyfikator subskrypcji platformy Azure, w którym znajduje się usługa Application Gateway. Przykład: aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e.
- appgw.resourceGroup: nazwa grupy zasobów platformy Azure, w której utworzono wdrożenie usługi Application Gateway. Przykład: app-gw-resource-group.
- appgw.name: nazwa wdrożenia usługi Application Gateway. Przykład: applicationgatewayd0f0.
- appgw.shared: flaga logiczna, która jest domyślnie ustawiona na false. Ustaw ją na wartość true, jeśli potrzebujesz współdzielonego wdrożenia Application Gateway.
- kubernetes.watchNamespace: określa przestrzeń nazw, którą powinien obserwować AGIC. Wartość przestrzeni nazw może być pojedynczą wartością ciągu lub rozdzielaną przecinkami listą przestrzeni nazw.
- armAuth.type: może to być aadPodIdentity lub servicePrincipal.
- armAuth.identityResourceID: Identyfikator zasobu zarządzanej tożsamości Azure.
- armAuth.identityClientID: Identyfikator klienta tożsamości.
- armAuth.secretJSON: Wymagane tylko wtedy, gdy wybierzesz jednostkę usługi jako typ tajny (czyli po ustawieniu armAuth.type na servicePrincipal).
Uwaga

Wartości identityResourceID i identityClientID zostały utworzone podczas wcześniejszych kroków w celu wdrażania składników. Można je uzyskać ponownie za pomocą następującego polecenia:
```
az identity show -g <resource-group> -n <identity-name>
```
W poleceniu <resource-group> jest grupą zasobów wdrożenia usługi Application Gateway. Symbol zastępczy <identity-name> to nazwa utworzonej tożsamości. Możesz wyświetlić listę wszystkich tożsamości dla określonej subskrypcji przy użyciu polecenia az identity list.

Zainstaluj pakiet AGIC:

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

Instalowanie przykładowej aplikacji

Po zainstalowaniu usługi Application Gateway, AKS i AGIC możesz zainstalować przykładową aplikację za pośrednictwem usługi Azure Cloud Shell:

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

Alternatywnie możesz:

Pobierz poprzedni plik YAML:

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

Zastosuj plik YAML:
```
kubectl apply -f aspnetapp.yaml
```

Aby uzyskać więcej przykładów dotyczących uwidaczniania usługi AKS w Internecie za pośrednictwem protokołu HTTP lub HTTPS przy użyciu usługi Application Gateway, zobacz ten przewodnik z instrukcjami.
Aby uzyskać informacje o usłudze Application Gateway dla kontenerów, zobacz ten artykuł z omówieniem.