Instalar o complemento de escalonamento automático orientado por eventos (KEDA) do Kubernetes usando um modelo do ARM

Artigo
08/08/2024

Este artigo mostra como implantar o complemento de escalonamento automático orientado por eventos (KEDA) no Serviço de Kubernetes do Azure usando um modelo do ARM.

Importante

A versão do cluster do Kubernetes determina a versão do KEDA que será instalada no cluster do AKS. Para visualizar qual versão do KEDA é mapeada para cada versão do AKS, consulte a coluna de complementos gerenciados do AKS da tabela de versão do componente do Kubernetes.

Para as versões GA do Kubernetes, o AKS dá suporte completo à versão secundária do KEDA correspondente na tabela. As versões prévias do Kubernetes e o último patch do KEDA são parcialmente cobertos pelo suporte ao cliente com base no melhor esforço. Dessa forma, esses recursos não são destinados ao uso em produção. Para obter mais informações, consulte os seguintes artigos:

Observação

A versão 2.15 do KEDA apresenta uma alteração interruptiva que remove o suporte à identidade do pod. Recomendamos passar para a identidade da carga de trabalho para sua autenticação, caso esteja usando a identidade do pod. Embora o complemento gerenciado do KEDA não execute atualmente a versão 2.15 do KEDA, ele começará a executá-lo na versão prévia 1.31 do AKS.

Para obter mais informações sobre como dimensionar seus aplicativos com segurança usando a identidade da carga de trabalho, leia nosso tutorial. Para exibir a política de alteração interruptiva/substituição do KEDA, leia a documentação oficial.

Antes de começar

É necessária uma assinatura do Azure. Caso não tenha uma assinatura do Azure, é possível criar uma conta gratuita.
Você precisa da CLI do Azure instalada.
Este artigo pressupõe que você tenha um grupo de recursos existente do Azure. Se você não tiver um grupo de recursos, poderá criar um usando o comando az group create.
Certifique-se de ter as regras de firewall configuradas para permitir o acesso ao servidor de API do Kubernetes. Para obter mais informações, confira Regras de rede de saída e FQDN para clusters do Serviço de Kubernetes do Azure (AKS)
Criar um par de chaves SSH.

Observação

Se você estiver usando a ID de carga de trabalho do Microsoft Entra e habilitar o KEDA antes da ID de carga de trabalho, será necessário reiniciar os pods do operador KEDA para que as variáveis de ambiente corretas possam ser injetadas:

Reinicie os pods executando kubectl rollout restart deployment keda-operator -n kube-system.
Obtenha os pods do operador KEDA usando kubectl get pod -n kube-system e localizando os pods que começam com keda-operator.
Verifique a injeção bem-sucedida das variáveis de ambiente executando kubectl describe pod <keda-operator-pod> -n kube-system. Em Environment, você verá os valores de AZURE_TENANT_ID, AZURE_FEDERATED_TOKEN_FILE e AZURE_AUTHORITY_HOST.

Criar um par de chaves SSH

Navegue para o Azure Cloud Shell.

Crie um par de chaves SSH usando o comando az sshkey create.

az sshkey create --name <sshkey-name> --resource-group <resource-group-name>

Habilitar o complemento KEDA com um modelo do ARM

Implante o modelo do ARM para um cluster do AKS.
Selecione Editar modelo.
Habilite o complemento KEDA especificando o campo workloadAutoScalerProfile no modelo do ARM, conforme mostrado no exemplo a seguir:
```
    "workloadAutoScalerProfile": {
        "keda": {
            "enabled": true
        }
    }
```
Selecione Salvar.
Atualize os valores necessários para o modelo do ARM:
- Assinatura: selecione a assinatura do Azure a ser usada para a implantação da zona de destino de dados.
- Grupo de recursos: selecione o grupo de recursos a ser usado para a implantação.
- Região: selecione a região a ser usada para a implantação.
- Prefixo DNS: insira um nome DNS exclusivo a ser usado para o cluster.
- Nome de usuário administrador do Linux: insira um nome de usuário para o cluster.
- Fonte de chave pública SSH: selecione Usar chave existente armazenada no Azure.
- Armazenar chaves: selecione o par de chaves que você criou anteriormente no artigo.
Selecione Examinar + criar>Criar.

Conectar-se ao cluster do AKS

Para se conectar ao cluster Kubernetes no dispositivo local, use o kubectl, o cliente de linha de comando do Kubernetes.

Se você usa o Azure Cloud Shell, o kubectl já estará instalado. Se você quiser instalá-lo localmente, use o comando az aks install-cli.

Configure o kubectl para se conectar ao cluster do Kubernetes, usando o comando az aks get-credentials. O seguinte exemplo obtém as credenciais do cluster do AKS chamado MyAKSCluster em MyResourceGroup:

az aks get-credentials --resource-group MyResourceGroup --name MyAKSCluster

Exemplo de implantação

O snippet a seguir é uma implantação de exemplo que cria um cluster com KEDA habilitado com um único pool de nós composto por três nós DS2_v5.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "resources": [
        {
            "apiVersion": "2023-03-01",
            "dependsOn": [],
            "type": "Microsoft.ContainerService/managedClusters",
            "location": "westcentralus",
            "name": "myAKSCluster",
            "properties": {
                "kubernetesVersion": "1.27",
                "enableRBAC": true,
                "dnsPrefix": "myAKSCluster",
                "agentPoolProfiles": [
                    {
                        "name": "agentpool",
                        "osDiskSizeGB": 200,
                        "count": 3,
                        "enableAutoScaling": false,
                        "vmSize": "Standard_D2S_v5",
                        "osType": "Linux",
                        "type": "VirtualMachineScaleSets",
                        "mode": "System",
                        "maxPods": 110,
                        "availabilityZones": [],
                        "nodeTaints": [],
                        "enableNodePublicIP": false
                    }
                ],
                "networkProfile": {
                    "loadBalancerSku": "standard",
                    "networkPlugin": "kubenet"
                },
                "workloadAutoScalerProfile": {
                    "keda": {
                        "enabled": true
                    }
                }
            },
            "identity": {
                "type": "SystemAssigned"
            }
        }
    ]
}

Iniciar o dimensionamento de aplicativos com o KEDA

Você pode dimensionar automaticamente seus aplicativos com o KEDA usando definições de recursos personalizados (CRDs). Para obter mais informações, confira a documentação do KEDA.

Remover recursos

Remova o grupo de recursos e todos os recursos relacionados usando o comando az group delete.
```
az group delete --name <resource-group-name>
```

Próximas etapas

Este artigo mostrou como instalar o complemento do KEDA em um cluster do AKS e verificar se ele está instalado e funcionando. Com o complemento KEDA instalado em seu cluster, você pode implantar um aplicativo de amostra para começar a dimensionar aplicativos.

Para obter informações sobre a solução de problemas do KEDA, confira Solucionar problemas do complemento KEDA (dimensionamento automático controlado por eventos do Kubernetes).

Para saber mais, veja a documentação upstream do KEDA.

Compartilhar via