Compartilhar via

Instale o AGIC usando uma nova implantação do Gateway de Aplicativo

  • Artigo

As instruções nesse artigo assumem que você deseja instalar o controlador de entrada do Gateway de Aplicativo (AGIC) em um ambiente que não possui componentes preexistentes.

Dica

Considere o Gateway de Aplicativos para Contêineres como a sua solução de entrada do Kubernetes. Para obter mais informações, confira Início Rápido: Implantar o controlador ALB do Gateway de Aplicativos para Contêineres.

Instale 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 de Inicialização do Cloud Shell.

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

Ícone do Azure PowerShell no portal

Sua instância do Cloud Shell já possui todas as ferramentas necessárias. Se você optar por usar outro ambiente, certifique-se de que as seguintes ferramentas de linha de comando estejam instaladas:

Criar uma identidade

Use as seguintes etapas para criar um objeto de entidade de serviço do Microsoft Entra.

  1. Crie uma entidade de serviço do Active Directory, que inclui uma função de Controle de Acesso Baseado em Função do Azure (RBAC):

    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)

    Registre os valores appId e password da saída JSON. Você os usará nas próximas etapas.

  2. Use o valor appId 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 desse comando é objectId. Registre esse valor, pois você o usará na próxima etapa.

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

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

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

Implantar componentes

O seguinte procedimento adiciona estes componentes à sua assinatura:

Para implantar os componentes:

  1. Baixe o modelo do ARM:

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

  2. Implante o modelo do 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

  3. 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 do AKS e uma implantação do Gateway de Aplicativo. Você está pronto para implantar um aplicativo de amostra e um controlador de entrada na sua nova infraestrutura do Kubernetes.

Configurar as credenciais do Kubernetes

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

Obtenha credenciais para sua nova instância do AKS implantada. Para mais informações sobre os comandos a seguir, confira Usar o RBAC do Azure para autorização do Kubernetes com o 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 a Identidade do Pod do Microsoft Entra

Microsoft Entra Pod Identity fornece acesso baseado em token ao Azure Resource Manager.

O Microsoft Entra Pod Identity adiciona os seguintes componentes ao seu cluster do Kubernetes:

Para instalar o Microsoft Entra Pod Identity no seu cluster, use um dos seguintes comandos:

  • Cluster do AKS com RBAC do Kubernetes habilitado:

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

  • Cluster do AKS com RBAC do Kubernetes desabilitado:

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

Adicione o repositório do Helm

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

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

  • Cluster do AKS com RBAC do Kubernetes habilitado:

    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 do AKS com RBAC do Kubernetes desabilitado:

    helm init

Instale o gráfico do Helm do controlador de entrada

  1. Use o arquivo deployment-outputs.json que você criou 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)

  2. 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 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>

  3. Edite o arquivo helm-config.yaml recém-baixado 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

    Observação

    Se você estiver implantando em uma nuvem soberana (por exemplo, Azure Governamental), você deverá adicionar o parâmetro de configuração appgw.environment e defini-lo para o valor apropriado.

    Aqui estão os valores:

    • verbosityLevel: define o nível de verbosidade da infraestrutura de log do AGIC. Para obter os possíveis valores, confira Níveis de registro em log.
    • appgw.environment: Define o ambiente de nuvem. Possíveis valores : AZURECHINACLOUD, AZUREGERMANCLOUD, AZUREPUBLICCLOUD, AZUREUSGOVERNMENTCLOUD.
    • appgw.subscriptionId: A ID da assinatura do Azure em que o Gateway de Aplicativo 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 Gateway de Aplicativo. Exemplo: applicationgatewayd0f0.
    • appgw.shared: Sinalizador booliano que tem como padrão false. Defina como true se você precisar de uma implantação compartilhada do Gateway de Aplicativo.
    • kubernetes.watchNamespace: Especifica o namespace que o AGIC deve inspecionar. O valor do namespace pode ser um único valor de cadeia de caracteres ou uma lista de namespaces separada por vírgulas.
    • armAuth.type: Pode ser aadPodIdentity ou servicePrincipal.
    • armAuth.identityResourceID: ID do recurso da identidade gerenciada do Azure.
    • armAuth.identityClientID: ID do cliente da identidade.
    • armAuth.secretJSON: Necessário apenas quando você escolher uma entidade de serviço como o tipo de segredo (ou seja, quando você definir armAuth.type para servicePrincipal).

    Observação

    Você criou os valores identityResourceID 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 sua implantação do Gateway de Aplicativo. O espaço reservado <identity-name> é o nome da identidade criada. Você pode listar todas as identidades para uma assinatura específica usando az identity list.

  4. Instale o pacote AGIC:

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

Instalar um aplicativo de exemplo

Agora que você tem o Gateway de Aplicativo, AKS e AGIC instalados, você pode instalar um aplicativo de amostra 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

Como alternativa, é possível:

  • 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

Conteúdo relacionado

  • Para mais exemplos sobre como expor um serviço AKS à internet por meio de HTTP ou HTTPS usando o Gateway de Aplicativo, confira este guia de instruções.
  • Para informações sobre o Gateway de Aplicativo para Contêineres, confira este artigo de visão geral.