Como instalar um controlador de entrada do gateway de aplicativo (AGIC) usando um novo gateway de aplicativo

Artigo
12/22/2023

As instruções a seguir pressupõem que o controlador de entrada do gateway de aplicativo (AGIC) será instalado em um ambiente sem componentes pré-existentes.

Dica

Veja também O que é o Gateway de Aplicativo para contêineres.

Ferramentas de linha de comando necessárias

Recomendamos o uso de Azure cloud Shell para todas as operações de linha de comando abaixo. Inicie o shell de shell.azure.com ou clicando no link:

Como alternativa, inicie Cloud Shell de portal do Azure usando o seguinte ícone:

Seu Azure 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 -Kubernetes Package Manager: instruções de instalação
jq -processador JSON de linha de comando: instruções de instalação

Criar uma identidade

Siga as etapas abaixo para criar um objeto da entidade de serviço do Microsoft Entra . Registre os valores appId, password e objectId - eles serão usados nas etapas a seguir.

Criar entidade de serviço do AD (Leia mais sobre o RBAC 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)

Os appIdpassword valores e da saída JSON serão usados nas etapas a seguir

Use o appId da saída do comando anterior para obter a id nova entidade de serviço:
```
objectId=$(az ad sp show --id $appId --query "id" -o tsv)
```
A saída desse comando é objectId, que será usada no modelo de Azure Resource Manager abaixo

Crie o arquivo de parâmetro que será usado na implantação do modelo de Azure Resource Manager mais tarde.

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 o aksEnableRBAC campo como true

Implantar componentes

Esta etapa adicionará os seguintes componentes à sua assinatura:

Serviço de Kubernetes do Azure
Gateway de Aplicativo v2
Rede virtual com duas sub-redes
Endereço IP público
Identidade Gerenciada, que será usada pela Identidade de Pod do AAD

Baixe o Azure Resource Manager e modifique o modelo conforme necessário.

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

Implante o modelo do Gerenciador de Recursos do Azure usando a CLI do Azure. 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

Depois que a implantação terminar, 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 controlador de entrada do Gateway de Aplicativo do Azure

Com as instruções na seção anterior, criamos e configuramos um novo cluster do AKS e um Gateway de Aplicativo. Agora estamos prontos para implantar um aplicativo de exemplo e um controlador de entrada em nossa nova infraestrutura do Kubernetes.

Configurar as credenciais do Kubernetes

Para as etapas a seguir, precisamos configurar o comando kubectl, que será usado para se conectar ao nosso novo cluster do Kubernetes. Cloud Shell já kubectl foi instalado. Vamos usar a az CLI para obter credenciais para o Kubernetes.

Obter credenciais para o AKS recém-implantado (leia mais):

# use the deployment-outputs.json 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 a Identidade do Pod do Microsoft Entra

A Identidade de Pod do Azure Microsoft Entra fornece acesso baseado em token ao Azure Resource Manager (ARM).

Identidade de Pod do Microsoft Entra adicionará os seguintes componentes ao cluster do seu Kubernetes:

CRDs do Kubernetes: AzureIdentity, AzureAssignedIdentity, AzureIdentityBinding
Componente do MIC (Controlador de Identidades Gerenciadas)
Componente de NMI (Identidade Gerenciada do Nó)

Para instalar a Identidade do Pod do Microsoft Entra no seu cluster:

Cluster AKS habilitado para RBAC do Kubernetes

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

Cluster AKS desabilitado para RBAC do Kubernetes

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

Instalar o Helm

O Helm é um gerenciador de pacotes para Kubernetes. Vamos usá-lo para instalar o pacote application-gateway-kubernetes-ingress.

Observação

Se você usar Cloud Shell, não precisará instalar o Helm. O Azure Cloud Shell vem com o Helm versão 3. Ignore a primeira etapa e adicione apenas o repositório do Helm do AGIC.

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

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

Cluster AKS desabilitado para RBAC do Kubernetes
```
helm init
```

Adicione o repositório AGIC do Helm:

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

Instalar o Gráfico do Controlador de Entrada do Helm

Use o deployment-outputs.json arquivo criado acima e crie 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)

Baixe o arquivo helm-config.yaml, que vai 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 arquivo YAML abaixo:

# 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 acessible 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 helm-config.yaml baixado recentemente e preencha as seções 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
```
Observação

Para implantar em Nuvens Soberanas (por exemplo, Azure Governamental), o parâmetro de configuração appgw.environment deve ser adicionado e definido como o valor apropriado, conforme documentado abaixo.

Valores:
- verbosityLevel: define o nível de verbosidade da infraestrutura de log do AGIC. Consulte Níveis de registro em log para obter os valores possíveis.
- appgw.environment: define o ambiente de nuvem. Valores possíveis: AZURECHINACLOUD, AZUREGERMANCLOUD, AZUREPUBLICCLOUD, AZUREUSGOVERNMENTCLOUD
- appgw.subscriptionId: a ID da Assinatura do Azure na qual o Gateway de Aplicativo reside. Exemplo: a123b234-a3b4-557d-b2df-a0bc12de1234
- appgw.resourceGroup: nome do Grupo de Recursos do Azure no qual o Gateway de Aplicativo foi criado. Exemplo: app-gw-resource-group
- appgw.name: nome do Gateway de Aplicativo. Exemplo: applicationgatewayd0f0
- appgw.shared: esse sinalizador booliano deve ser padronizado para false. Defina como true caso precise de um Gateway de Aplicativo Compartilhado.
- kubernetes.watchNamespace: especifique o namespace que o AGIC deve observar. O namespace pode ser um único valor de cadeia de caracteres ou uma lista de namespaces separados por vírgula.
- armAuth.type: pode ser aadPodIdentity ou servicePrincipal
- armAuth.identityResourceID: ID de recurso da Identidade Gerenciada do Azure
- armAuth.identityClientID: a ID do cliente da identidade. Abaixo, veja mais informações sobre o identityClientID.
- armAuth.secretJSON: necessário somente quando o tipo de Segredo da Entidade de Serviço é escolhido (quando armAuth.type foi definido como servicePrincipal)
Observação

Os valores identityResourceID e identityClientID são criados durante as etapas Implantar Componentes e podem ser obtidos novamente usando o seguinte comando:
```
az identity show -g <resource-group> -n <identity-name>
```
<resource-group> no comando acima, está o grupo de recursos do seu gateway de aplicativo. <identity-name> é o nome da identidade criada. Todas as identidades de uma determinada assinatura podem ser listadas usando: az identity list

Instale o pacote do controlador de entrada do Gateway de Aplicativo:

helm install -f helm-config.yaml --generate-name application-gateway-kubernetes-ingress/ingress-azure

Instalar um aplicativo de exemplo

Agora que temos o Gateway de Aplicativo, o AKS e o AGIC instalados, poderamos instalar um aplicativo de exemplo usando o 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

Como alternativa, você pode:

Baixe o arquivo YAML acima:

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

Outros exemplos

Este Guia de instruções contém mais exemplos de como expor um serviço AKs via http ou HTTPS para a Internet com o gateway de aplicativo.