Installare AGIC usando una nuova distribuzione di gateway applicazione

Articolo
10/17/2024

Le istruzioni in questo articolo presuppongono che si voglia installare il controller di ingresso (AGIC) gateway applicazione in un ambiente che non dispone di componenti preesistenti.

Suggerimento

Prendere in considerazione gateway applicazione per i contenitori per la soluzione di ingresso Kubernetes. Per altre informazioni, vedere Avvio rapido: Distribuire gateway applicazione per il controller ALB dei contenitori.

Installare gli strumenti da riga di comando necessari

È consigliabile usare Azure Cloud Shell per tutte le operazioni della riga di comando in questo articolo. È possibile aprire Cloud Shell selezionando il pulsante Avvia Cloud Shell .

In alternativa, aprire Cloud Shell dal portale di Azure selezionandone l'icona.

L'istanza di Cloud Shell include già tutti gli strumenti necessari. Se si sceglie di usare un altro ambiente, assicurarsi che siano installati gli strumenti da riga di comando seguenti:

az: interfaccia della riga di comando di Azure (istruzioni di installazione)
kubectl: strumento da riga di comando kubernetes (istruzioni di installazione)
helm: Gestione pacchetti Kubernetes (istruzioni di installazione)
jq: processore JSON della riga di comando (istruzioni di installazione)

Creare un'identità

Seguire questa procedura per creare un oggetto entità servizio Microsoft Entra.

Creare un'entità servizio di Active Directory, che include un ruolo controllo degli accessi in base al ruolo di 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)
```
Registrare i appId valori e password dall'output JSON. Li userai nei prossimi passaggi.
Usare il appId valore dell'output del comando precedente per ottenere l'oggetto id della nuova entità servizio:
```
objectId=$(az ad sp show --id $appId --query "id" -o tsv)
```
L'output di questo comando è objectId. Registrare questo valore perché verrà usato nel passaggio successivo.
Creare il file di parametri che verrà usato nella distribuzione del modello di Azure Resource Manager :Create the parameter file that you'll use in the Azure Resource Manager template (ARM template) deployment:
```
cat <<EOF > parameters.json
{
  "aksServicePrincipalAppId": { "value": "$appId" },
  "aksServicePrincipalClientSecret": { "value": "$password" },
  "aksServicePrincipalObjectId": { "value": "$objectId" },
  "aksEnableRBAC": { "value": false }
}
EOF
```
Per distribuire un cluster abilitato per il controllo degli accessi in base al ruolo di Kubernetes, impostare su aksEnableRBAC true.

Distribuire i componenti

La procedura seguente aggiunge questi componenti alla sottoscrizione:

Servizio Azure Kubernetes (AKS)
gateway app Azure lication v2
Azure Rete virtuale con due subnet
Indirizzo IP pubblico
Identità gestita, che verrà usata da Microsoft Entra Pod Identity.

Per distribuire i componenti:

Scaricare il modello di Resource Manager:

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

Distribuire il modello di Resource Manager usando l'interfaccia della riga di comando di Azure e modificarlo in base alle esigenze. La distribuzione potrebbe richiedere fino a 5 minuti.

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

Al termine della distribuzione, scaricare l'output della distribuzione in un file denominato deployment-outputs.json:

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

Configurare AGIC

Con le istruzioni riportate nella sezione precedente, è stato creato e configurato un nuovo cluster del servizio Azure Kubernetes e una distribuzione gateway applicazione. È ora possibile distribuire un'app di esempio e un controller di ingresso nella nuova infrastruttura Kubernetes.

Configurare le credenziali di Kubernetes

Per i passaggi seguenti, è necessario configurare il comando kubectl , che verrà usato per connettersi al nuovo cluster Kubernetes. Cloud Shell è kubectl già installato. Si userà az l'interfaccia della riga di comando di Azure per ottenere le credenziali per Kubernetes.

Ottenere le credenziali per l'istanza del servizio Azure Kubernetes appena distribuita. Per altre informazioni sui comandi seguenti, vedere Usare il controllo degli accessi in base al ruolo di Azure per l'autorizzazione kubernetes con 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

Installare l'identità pod di Microsoft Entra

Microsoft Entra Pod Identity fornisce l'accesso basato su token ad Azure Resource Manager.

Microsoft Entra Pod Identity aggiunge i componenti seguenti al cluster Kubernetes:

Definizioni di risorse personalizzate di Kubernetes :AzureIdentity, AzureAssignedIdentity,AzureIdentityBinding
Componente Controller identità gestita
Componente Identità gestita del nodo

Per installare Microsoft Entra Pod Identity nel cluster, usare uno dei comandi seguenti:

Cluster del servizio Azure Kubernetes abilitato per il controllo degli accessi in base al ruolo:

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

Cluster del servizio Azure Kubernetes disabilitato per il controllo degli accessi in base al ruolo:

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

Aggiungere il repository Helm

Helm è un gestore di pacchetti per Kubernetes. Viene usato per installare il application-gateway-kubernetes-ingress pacchetto.

Se si usa Cloud Shell, non è necessario installare Helm. Cloud Shell include Helm versione 3. Eseguire uno dei comandi seguenti per aggiungere il repository Helm AGIC:

Cluster del servizio Azure Kubernetes abilitato per il controllo degli accessi in base al ruolo:

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

Cluster del servizio Azure Kubernetes disabilitato per il controllo degli accessi in base al ruolo:
```
helm init
```

Installare il grafico Helm del controller di ingresso

Usare il deployment-outputs.json file creato in precedenza per creare le variabili seguenti:

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)

Scaricare helm-config.yaml, che configura AGIC:

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

In alternativa, copiare il file YAML seguente:

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

Modificare il file appena scaricato helm-config.yaml e compilare le sezioni per appgw e 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
```
Nota

Se si esegue la distribuzione in un cloud sovrano, ad esempio Azure per enti pubblici, è necessario aggiungere il appgw.environment parametro di configurazione e impostarlo sul valore appropriato.

Ecco i valori di :
- verbosityLevel: imposta il livello di dettaglio dell'infrastruttura di registrazione AGIC. Per i valori possibili, vedere Livelli di registrazione.
- appgw.environment: imposta l'ambiente cloud. Valori possibili: AZURECHINACLOUD, AZUREGERMANCLOUD, AZUREPUBLICCLOUD, AZUREUSGOVERNMENTCLOUD.
- appgw.subscriptionId: ID sottoscrizione di Azure in cui risiede gateway applicazione. Esempio: aaaa0000-bb11-2222-33cc-444444dddddd.
- appgw.resourceGroup: nome del gruppo di risorse di Azure in cui è stata creata la distribuzione gateway applicazione. Esempio: app-gw-resource-group.
- appgw.name: nome della distribuzione gateway applicazione. Esempio: applicationgatewayd0f0.
- appgw.shared: flag booleano che per impostazione predefinita è false. Impostarlo su true se è necessaria una distribuzione di gateway applicazione condivisa.
- kubernetes.watchNamespace: specifica lo spazio dei nomi che deve essere guardato da AGIC. Il valore dello spazio dei nomi può essere un singolo valore stringa o un elenco delimitato da virgole di spazi dei nomi.
- armAuth.type: può essere aadPodIdentity o servicePrincipal.
- armAuth.identityResourceID: ID risorsa dell'identità gestita di Azure.
- armAuth.identityClientID: ID client dell'identità.
- armAuth.secretJSON: necessario solo quando si sceglie un'entità servizio come tipo di segreto, ovvero quando si imposta su armAuth.type servicePrincipal.
Nota

I valori e identityClientID sono stati creati identityResourceID durante i passaggi precedenti per la distribuzione dei componenti. È possibile ottenerli di nuovo usando il comando seguente:
```
az identity show -g <resource-group> -n <identity-name>
```
Nel comando è <resource-group> il gruppo di risorse della distribuzione gateway applicazione. Il <identity-name> segnaposto è il nome dell'identità creata. È possibile elencare tutte le identità per una determinata sottoscrizione usando az identity list.

Installare il pacchetto AGIC:

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

Installare un'app di esempio

Dopo aver installato gateway applicazione, servizio Azure Kubernetes e AGIC, è possibile installare un'app di esempio tramite 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

In alternativa è possibile:

Scaricare il file YAML precedente:

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

Applicare il file YAML:
```
kubectl apply -f aspnetapp.yaml
```

Per altri esempi su come esporre un servizio Servizio Azure Kubernetes a Internet tramite HTTP o HTTPS tramite gateway applicazione, vedere questa guida pratica.
Per informazioni sui gateway applicazione per i contenitori, vedere questo articolo di panoramica.

Condividi tramite

Installare AGIC usando una nuova distribuzione di gateway applicazione

Installare gli strumenti da riga di comando necessari

Creare un'identità

Distribuire i componenti

Configurare AGIC

Configurare le credenziali di Kubernetes

Installare l'identità pod di Microsoft Entra

Aggiungere il repository Helm

Installare il grafico Helm del controller di ingresso

Installare un'app di esempio

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Installare AGIC usando una nuova distribuzione di gateway applicazione

Installare gli strumenti da riga di comando necessari

Creare un'identità

Distribuire i componenti

Configurare AGIC

Configurare le credenziali di Kubernetes

Installare l'identità pod di Microsoft Entra

Aggiungere il repository Helm

Installare il grafico Helm del controller di ingresso

Installare un'app di esempio

Contenuto correlato

Commenti e suggerimenti

Risorse aggiuntive