Instalar um Application Gateway Ingress Controller (AGIC) usando um Application Gateway existente

Artigo
02/08/2024

O Application Gateway Ingress Controller (AGIC) é um pod dentro do cluster do Serviço Kubernetes do Azure (AKS). A AGIC monitora os recursos de Ingresso do Kubernetes e cria e aplica a configuração do Application Gateway com base no status do cluster do Kubernetes.

Gorjeta

Consulte também O que é o Application Gateway for Containers.

Destaque

Pré-requisitos
Autenticação do Azure Resource Manager (ARM)
- Opção 1: Configurar a ID de Carga de Trabalho do Microsoft Entra e criar a Identidade do Azure em ARMs
- Opção 2: Configurar uma entidade de serviço
Instale o Ingress Controller usando o Helm
Shared Application Gateway: instale o AGIC em um ambiente, onde o Application Gateway é compartilhado entre um cluster AKS e/ou outros componentes do Azure.

Pré-requisitos

Este documento pressupõe que você já tenha as seguintes ferramentas e infraestrutura instaladas:

Um cluster AKS com a CNI (Container Networking Interface) do Azure
Application Gateway v2 na mesma rede virtual que o cluster AKS
ID de carga de trabalho do Microsoft Entra configurado para o cluster AKS
Cloud Shell é o ambiente de shell do Azure, que tem az CLI kubectle helm instalado. Essas ferramentas são necessárias para comandos usados para dar suporte à configuração dessa implantação.

Faça backup da configuração do Application Gateway antes de instalar o AGIC:

No portal do Azure, navegue até sua instância do Gateway de Aplicativo.
Na seção Automação, selecione Exportar modelo e, em seguida, selecione Download.

O arquivo zip baixado contém modelos JSON, bash e scripts PowerShell que você pode usar para restaurar o App Gateway, caso seja necessário

Instalar o Helm

Helm é um gerenciador de pacotes para Kubernetes, usado para instalar o application-gateway-kubernetes-ingress pacote.

Nota

Se você usa o Cloud Shell, não precisa instalar o Helm. O Azure Cloud Shell vem com o Helm versão 3. Pule a primeira etapa e adicione o repositório AGIC Helm.

Instale o Helm e execute o seguinte para adicionar application-gateway-kubernetes-ingress o pacote helm:

Cluster AKS habilitado para RBAC do Kubernetes

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

Adicione o repositório AGIC Helm:

helm repo add application-gateway-kubernetes-ingress https://appgwingress.blob.core.windows.net/ingress-azure-helm-package/
helm repo update

Autenticação do Azure Resource Manager

O AGIC se comunica com o servidor de API do Kubernetes e o Gerenciador de Recursos do Azure. Ele requer uma identidade para acessar essas APIs.

Configurar o ID de carga de trabalho do Microsoft Entra

Microsoft Entra Workload ID é uma identidade que você atribui a uma carga de trabalho de software, para autenticar e acessar outros serviços e recursos. Essa identidade permite que seu pod AKS use essa identidade e se autentique com outros recursos do Azure. Para essa configuração, precisamos de autorização para que o pod AGIC faça solicitações HTTP ao ARM.

Use o comando Azure CLI az account set para definir uma assinatura específica como sendo a assinatura ativa atual. Em seguida, use o comando az identity create para criar uma identidade gerenciada. A identidade precisa ser criada no grupo de recursos do nó. O grupo de recursos do nó recebe um nome por padrão, como MC_myResourceGroup_myAKSCluster_eastus.
```
az account set --subscription "subscriptionID"
```
```
az identity create --name "userAssignedIdentityName" --resource-group "resourceGroupName" --location "location" --subscription "subscriptionID"
```

Para a atribuição de função, execute o seguinte comando para identificar a principalId identidade recém-criada:

$resourceGroup="resource-group-name"
$identityName="identity-name"
az identity list -g $resourceGroup --query "[?name == '$identityName'].principalId | [0]" -o tsv

Conceda ao Colaborador de identidade acesso ao seu Application Gateway. Você precisa da ID do Application Gateway, que se parece com: /subscriptions/A/resourceGroups/B/providers/Microsoft.Network/applicationGateways/C. Primeiro, obtenha a lista de IDs do Application Gateway em sua assinatura executando o seguinte comando:

az network application-gateway list --query '[].id'

Para atribuir o acesso de Colaborador de identidade, execute o seguinte comando:

$resourceGroup="resource-group-name"
$identityName="identity-Name"
# Get the Application Gateway ID
$AppGatewayID=$(az network application-gateway list --query '[].id' -o tsv)
$role="contributor"
# Get the principal ID for the User assigned identity
$principalId=$(az identity list -g $resourceGroup --query "[?name == '$identityName'].principalId | [0]" -o tsv)
az role assignment create --assignee $principalId --role $role --scope $AppGatewayID

Conceda ao Leitor de identidade acesso ao grupo de recursos do Gateway de Aplicativo. O ID do grupo de recursos tem a seguinte aparência: /subscriptions/A/resourceGroups/B. Você pode obter todos os grupos de recursos com: az group list --query '[].id'

$resourceGroup="resource-group-name"
$identityName="identity-Name"
# Get the Application Gateway resource group
$AppGatewayResourceGroup=$(az network application-gateway list --query '[].resourceGroup' -o tsv)
# Get the Application Gateway resource group ID
$AppGatewayResourceGroupID=$(az group show --name $AppGatewayResourceGroup --query id -o tsv)
$role="Reader"
# Get the principal ID for the User assigned identity
$principalId=$(az identity list -g $resourceGroup --query "[?name == '$identityName'].principalId | [0]" -o tsv)
# Assign the Reader role to the User assigned identity at the resource group scope
az role assignment create --role $role --assignee $principalId  --scope $AppGatewayResourceGroupID

Nota

Verifique se a identidade usada pela AGIC tem a permissão Microsoft.Network/virtualNetworks/subnets/join/action delegada à sub-rede onde o Application Gateway está implantado. Se uma função personalizada não estiver definida com essa permissão, você poderá usar a função interna de Colaborador de Rede , que contém a permissão Microsoft.Network/virtualNetworks/subnets/join/action .

Usando uma entidade de serviço

Também é possível fornecer acesso AGIC ao ARM usando um segredo do Kubernetes.

Crie uma entidade de serviço do Ative Directory e codifique com base64. A codificação base64 é necessária para que o blob JSON seja salvo no Kubernetes.
```
az ad sp create-for-rbac --role Contributor --sdk-auth | base64 -w0
```
Adicione o blob JSON codificado base64 ao helm-config.yaml arquivo. Mais informações sobre helm-config.yaml está na próxima seção.
```
armAuth:
    type: servicePrincipal
    secretJSON: <Base64-Encoded-Credentials>
```

Implantar o complemento Azure Application Gateway Ingress Controller

Criar um manifesto de implantação do Ingress Controller

---
# file: pet-supplies-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: pet-supplies-ingress
  annotations:
    kubernetes.io/ingress.class: azure/application-gateway

spec:
  rules:
  - http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: store-front
            port:
              number: 80
      - path: /order-service
        pathType: Prefix
        backend:
          service:
            name: order-service
            port:
              number: 3000
      - path: /product-service
        pathType: Prefix
        backend:
          service:
            name: product-service
            port:
              number: 3002

Implantar o Ingress Controller

$namespace="namespace"
$file="pet-supplies-ingress.yaml"
kubectl apply -f $file -n $namespace

Instale o Ingress Controller como um gráfico de leme

Nos primeiros passos, instalamos o Helm's Tiller no seu cluster Kubernetes. Use o Cloud Shell para instalar o pacote AGIC Helm:

Adicione o repositório de application-gateway-kubernetes-ingress leme e execute uma atualização de leme

helm repo add application-gateway-kubernetes-ingress https://appgwingress.blob.core.windows.net/ingress-azure-helm-package/
helm repo update

Baixe helm-config.yaml, que configura 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 must manage
#
appgw:
    subscriptionId: <subscriptionId>
    resourceGroup: <resourceGroupName>
    name: <applicationGatewayName>

    # Setting appgw.shared to "true" creates 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 must 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: Azure-AD-workload-identity
armAuth:
    type: workloadIdentity
    identityClientID:  <identityClientId>

## Alternatively you can use Service Principal credentials
# armAuth:
#    type: servicePrincipal
#    secretJSON: <<Generate this value with: "az ad sp create-for-rbac --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 helm-config.yaml e preencha os valores de appgw e armAuth.

Nota

O <identity-client-id> é uma propriedade do ID de carga de trabalho do Microsoft Entra que você configurou na seção anterior. Você pode recuperar essas informações executando o seguinte comando: az identity show -g <resourcegroup> -n <identity-name>, onde <resourcegroup> é o grupo de recursos que hospeda os recursos de infraestrutura relacionados ao cluster AKS, Application Gateway e identidade gerenciada.

Instale o gráfico application-gateway-kubernetes-ingress Helm com a helm-config.yaml configuração da etapa anterior

helm install -f <helm-config.yaml> application-gateway-kubernetes-ingress/ingress-azure

Como alternativa, você pode combinar o helm-config.yaml comando e o comando Helm em uma etapa:

helm install ./helm/ingress-azure \
     --name ingress-azure \
     --namespace default \
     --debug \
     --set appgw.name=applicationgatewayABCD \
     --set appgw.resourceGroup=your-resource-group \
     --set appgw.subscriptionId=subscription-uuid \
     --set appgw.shared=false \
     --set armAuth.type=servicePrincipal \
     --set armAuth.secretJSON=$(az ad sp create-for-rbac --role Contributor --sdk-auth | base64 -w0) \
     --set rbac.enabled=true \
     --set verbosityLevel=3 \
     --set kubernetes.watchNamespace=default \
     --set aksClusterConfiguration.apiServerAddress=aks-abcdefg.hcp.westus2.azmk8s.io

Verifique o log do pod recém-criado para verificar se ele foi iniciado corretamente

Consulte este guia de instruções para entender como você pode expor um serviço AKS por HTTP ou HTTPS à Internet, usando um Gateway de Aplicativo do Azure.

Gateway de aplicativo compartilhado

Por padrão, a AGIC assume a propriedade total do Application Gateway ao qual está vinculada. AGIC versão 0.8.0 e posterior pode compartilhar um único Gateway de Aplicativo com outros componentes do Azure. Por exemplo, poderíamos usar o mesmo Application Gateway para um aplicativo hospedado no Virtual Machine Scale set e um cluster AKS.

Faça backup da configuração do Application Gateway antes de habilitar essa configuração:

No portal do Azure, navegue até sua Application Gateway instância
Na seção Automação, selecione Exportar modelo e, em seguida, selecione Download.

O arquivo zip baixado contém modelos JSON, bash e scripts do PowerShell que você pode usar para restaurar o Application Gateway

Cenário de Exemplo

Vejamos um Application Gateway imaginário, que gerencia o tráfego de dois sites:

dev.contoso.com - hospedado em um novo cluster AKS, usando Application Gateway e AGIC
prod.contoso.com - hospedado em um Conjunto de Escala de Máquina Virtual do Azure

Com as configurações padrão, a AGIC assume 100% de propriedade do Application Gateway para o qual é apontado. O AGIC substitui toda a configuração do App Gateway. Se você criar manualmente um ouvinte para prod.contoso.com (no Application Gateway) sem defini-lo no Kubernetes Ingress, o AGIC excluirá a prod.contoso.com configuração em segundos.

Para instalar o AGIC e também servir prod.contoso.com a partir de nossas máquinas Virtual Machine Scale set, devemos restringir o AGIC apenas à configuração dev.contoso.com . Isso é facilitado pela instanciação do seguinte CRD:

cat <<EOF | kubectl apply -f -
apiVersion: "appgw.ingress.k8s.io/v1"
kind: AzureIngressProhibitedTarget
metadata:
  name: prod-contoso-com
spec:
  hostname: prod.contoso.com
EOF

O comando acima cria um AzureIngressProhibitedTarget objeto. Isso torna o AGIC (versão 0.8.0 e posterior) ciente da existência da configuração do Application Gateway para prod.contoso.com e instrui-o explicitamente a evitar alterar qualquer configuração relacionada a esse nome de host.

Ativar com a nova instalação AGIC

Para limitar o AGIC (versão 0.8.0 e posterior) a um subconjunto da configuração do Application Gateway, modifique o helm-config.yaml modelo. Na seção , adicione shared a appgw: chave e defina-a como true.

appgw:
    subscriptionId: <subscriptionId>    # existing field
    resourceGroup: <resourceGroupName>  # existing field
    name: <applicationGatewayName>      # existing field
    shared: true                        # <<<<< Add this field to enable shared Application Gateway >>>>>

Aplique as alterações do leme:

Verifique se o AzureIngressProhibitedTarget CRD está instalado com:

kubectl apply -f https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/7b55ad194e7582c47589eb9e78615042e00babf3/crds/AzureIngressProhibitedTarget-v1-CRD-v1.yaml

Atualizar leme:

helm upgrade \
    --recreate-pods \
    -f helm-config.yaml \
    ingress-azure application-gateway-kubernetes-ingress/ingress-azure

Como resultado, seu cluster AKS tem uma nova instância chamada AzureIngressProhibitedTargetprohibit-all-targets:

kubectl get AzureIngressProhibitedTargets prohibit-all-targets -o yaml

O objeto prohibit-all-targets, como o nome indica, proíbe a AGIC de alterar a configuração para qualquer host e caminho. A instalação do Helm com appgw.shared=true implanta o AGIC, mas não faz alterações no Application Gateway.

Ampliar permissões

Como o Helm com appgw.shared=true e o padrão prohibit-all-targets bloqueia a AGIC de aplicar uma configuração, amplie as permissões da AGIC:

Crie um novo arquivo YAML nomeado AzureIngressProhibitedTarget com o seguinte trecho contendo sua configuração específica:

cat <<EOF | kubectl apply -f -
apiVersion: "appgw.ingress.k8s.io/v1"
kind: AzureIngressProhibitedTarget
metadata:
  name: your-custom-prohibitions
spec:
  hostname: your.own-hostname.com
EOF

Somente depois de criar sua própria proibição personalizada, você pode excluir a padrão, que é muito ampla:
```
kubectl delete AzureIngressProhibitedTarget prohibit-all-targets
```

Ativar para uma instalação AGIC existente

Vamos supor que já temos um cluster AKS funcionando, Application Gateway e AGIC configurado em nosso cluster. Temos um Ingress para prod.contoso.com e estamos servindo com sucesso o tráfego para ele a partir do cluster. Queremos adicionar staging.contoso.com ao nosso Application Gateway existente, mas precisamos hospedá-lo em uma VM. Vamos reutilizar o Application Gateway existente e configurar manualmente um ouvinte e pools de back-end para staging.contoso.com. Mas ajustar manualmente a configuração do Application Gateway (usando portal, APIs ARM ou Terraform) entraria em conflito com as suposições da AGIC de propriedade total. Pouco depois de aplicarmos as alterações, a AGIC substitui-as ou elimina-as.

Podemos proibir a AGIC de fazer alterações em um subconjunto de configuração.

Crie um novo arquivo YAML nomeado AzureIngressProhibitedTarget com o seguinte trecho:

cat <<EOF | kubectl apply -f -
apiVersion: "appgw.ingress.k8s.io/v1"
kind: AzureIngressProhibitedTarget
metadata:
  name: manually-configured-staging-environment
spec:
  hostname: staging.contoso.com
EOF

Exiba o objeto recém-criado:

kubectl get AzureIngressProhibitedTargets

Modifique a configuração do Gateway de Aplicativo a partir do portal do Azure - adicione ouvintes, regras de roteamento, back-ends, etc. O novo objeto que criamos (manually-configured-staging-environment) proíbe a AGIC de substituir a configuração do Application Gateway relacionada ao staging.contoso.com.