Instalar o AGIC usando uma nova implantação do Application Gateway

As instruções neste artigo pressupõem que você deseja instalar o Application Gateway Ingress Controller (AGIC) em um ambiente que não tenha componentes preexistentes.

Gorjeta

Considere o Application Gateway for Containers para sua solução de ingresso do Kubernetes. Para obter mais informações, consulte Guia de início rápido: implantar o Application Gateway for Containers ALB Controller.

Instalar as ferramentas de linha de comando necessárias

Recomendamos o uso do Azure Cloud Shell para todas as operações de linha de comando neste artigo. Você pode abrir o Cloud Shell selecionando o botão Launch Cloud Shell .

Como alternativa, abra o Cloud Shell no portal do Azure selecionando seu ícone.

Sua instância do Cloud Shell já tem todas as ferramentas necessárias. Se você optar por usar outro ambiente, verifique se as seguintes ferramentas de linha de comando estão instaladas:

az: CLI do Azure (instruções de instalação)
kubectl: Ferramenta de linha de comando Kubernetes (instruções de instalação)
helm: Gerenciador de pacotes Kubernetes (instruções de instalação)
jq: Processador JSON de linha de comando (instruções de instalação)

Criar uma identidade

Use as etapas a seguir para criar um objeto principal de serviço do Microsoft Entra.

Crie uma entidade de serviço do Active Directory, que inclui uma função de RBAC (controle de acesso baseado em função) do 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)
```
Registe os valores appId e password da saída JSON. Você os usará nas próximas etapas.
Use o appId valor da saída do comando anterior para obter o id da nova entidade de serviço:
```
objectId=$(az ad sp show --id $appId --query "id" -o tsv)
```
A saída deste comando é objectId. Registre esse valor, pois você o usará na próxima etapa.

Crie o arquivo de parâmetro que você usará na implantação do modelo do Azure Resource Manager (modelo ARM):

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

Para implantar um cluster habilitado para RBAC do Kubernetes, defina aksEnableRBAC como true.

Implantar componentes

O procedimento a seguir adiciona esses componentes à sua assinatura:

Serviço Kubernetes do Azure (AKS)
Azure Application Gateway v2
Rede Virtual do Azure com duas sub-redes
Endereço IP público
Identidade gerenciada, que o ID de carga de trabalho do Microsoft Entra usará.

Para implantar os componentes:

Faça o download do modelo ARM:

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

Implante o modelo ARM usando a CLI do Azure e modifique-o conforme necessário. A implantação pode levar até 5 minutos.

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

Após a conclusão da implantação, baixe a saída da implantação em um arquivo chamado deployment-outputs.json:

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

Configurar o AGIC

Com as instruções na seção anterior, você criou e configurou um novo cluster AKS e uma implantação do Application Gateway. Agora você está pronto para implantar um aplicativo de exemplo e um controlador de entrada em sua nova infraestrutura do Kubernetes.

Configurar credenciais do Kubernetes

Para as etapas a seguir, você precisa configurar o comando kubectl , que você usará para se conectar ao seu novo cluster Kubernetes. Cloud Shell já está kubectl instalado. Você usará az (CLI do Azure) para obter credenciais para o Kubernetes.

Obtenha credenciais para a sua instância AKS recentemente implementada. Para obter mais informações sobre os comandos a seguir, consulte Usar o RBAC do Azure para autorização do Kubernetes com 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

Instalar o ID de carga de trabalho do Microsoft Entra

A ID de Carga de Trabalho do Microsoft Entra fornece acesso baseado em token ao Azure Resource Manager.

O Microsoft Entra Workload ID adiciona os seguintes componentes ao cluster do Kubernetes:

Definições de recursos personalizados (CRDs) do Kubernetes: AzureIdentity, AzureAssignedIdentity,AzureIdentityBinding
Componente Managed Identity Controller (MIC)
Componente Identidade Gerenciada do Nó (NMI)

Para instalar o ID de carga de trabalho do Microsoft Entra no cluster, use um dos seguintes comandos:

Cluster AKS do Kubernetes habilitado para RBAC:

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

Cluster AKS desativado pelo RBAC do Kubernetes:

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

Adicionar o repositório Helm

Helm é um gerenciador de pacotes para o Kubernetes. Você usa-o para instalar o pacote application-gateway-kubernetes-ingress.

Se você usa o Cloud Shell, não precisa instalar o Helm. O Cloud Shell vem com o Helm versão 3. Execute um dos seguintes comandos para adicionar o repositório AGIC Helm:

Cluster AKS do Kubernetes habilitado para 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

Cluster AKS desativado pelo RBAC do Kubernetes:
```
helm init
```

Instale o Helm chart do controlador de ingress

Use o deployment-outputs.json arquivo criado anteriormente para criar as seguintes variáveis:

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)

Faça o download de helm-config.yaml, para configurar o AGIC:

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

Ou copie o seguinte arquivo 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>

Edite o arquivo recém-baixado helm-config.yaml e preencha as seções para 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 você estiver implantando em uma nuvem soberana (por exemplo, Azure Government), deverá adicionar o appgw.environment parâmetro de configuração e defini-lo com o valor apropriado.

Aqui estão os valores:
- verbosityLevel: Configura o nível de detalhe da infraestrutura de registo AGIC. Para obter os valores possíveis, consulte Níveis de registro.
- appgw.environment: Define o ambiente de nuvem. Valores possíveis: AZURECHINACLOUD, AZUREGERMANCLOUD, AZUREPUBLICCLOUD, AZUREUSGOVERNMENTCLOUD.
- appgw.subscriptionId: A ID de assinatura do Azure na qual o Application Gateway reside. Exemplo: aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e.
- appgw.resourceGroup: Nome do grupo de recursos do Azure no qual você criou a implantação do Gateway de Aplicativo. Exemplo: app-gw-resource-group.
- appgw.name: Nome da implantação do Application Gateway. Exemplo: applicationgatewayd0f0.
- appgw.shared: Sinalizador booleano cujo padrão é false. Defina-o como true se precisar de uma implantação compartilhada do Application Gateway.
- kubernetes.watchNamespace: Especifica o namespace que a AGIC deve observar. O valor do namespace pode ser um único valor de cadeia de caracteres ou uma lista de namespaces separada por vírgula.
- armAuth.type: Pode ser aadPodIdentity ou servicePrincipal.
- armAuth.identityResourceID: ID de recurso da identidade gerenciada do Azure.
- armAuth.identityClientID: ID de identidade do cliente.
- armAuth.secretJSON: Necessário somente quando escolhes um principal de serviço como o tipo secreto (isto é, quando defines armAuth.type como servicePrincipal).
Nota

Você criou os identityResourceID valores e identityClientID durante as etapas anteriores para implantar componentes. Você pode obtê-los novamente usando o seguinte comando:
```
az identity show -g <resource-group> -n <identity-name>
```
No comando, <resource-group> é o grupo de recursos da implantação do Application Gateway. O <identity-name> marcador é o nome da identidade criada. Você pode listar todas as identidades de uma assinatura específica usando az identity list.

Instale o pacote AGIC:

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

Instalar um aplicativo de exemplo

Agora que você tem o Application Gateway, AKS e AGIC instalados, você pode instalar um aplicativo de exemplo por meio do 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

Alternativamente, pode:

Baixe o arquivo YAML anterior:

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

Aplique o arquivo YAML:
```
kubectl apply -f aspnetapp.yaml
```

Para obter mais exemplos sobre como expor um serviço AKS à Internet via HTTP ou HTTPS usando o Application Gateway, consulte este guia de instruções.
Para obter informações sobre o Application Gateway for Containers, consulte este artigo de visão geral.

Feedback

Esta página foi útil?

Last updated on 2025-08-15