Instale o complemento Kubernetes Event-driven Autoscaling (KEDA) usando um modelo ARM

Artigo
08/08/2024

Este artigo mostra como implantar o complemento Kubernetes Event-driven Autoscaling (KEDA) no Serviço Kubernetes do Azure (AKS) usando um modelo ARM.

Importante

A versão do Kubernetes do cluster determina qual versão do KEDA será instalada no cluster AKS. Para ver qual versão do KEDA mapeia para cada versão do AKS, consulte a coluna de complementos gerenciados pelo AKS da tabela de versões do componente Kubernetes.

Para as versões do GA Kubernetes, o AKS oferece suporte total da versão secundária KEDA correspondente na tabela. As versões de visualização do Kubernetes e o patch KEDA mais recente são parcialmente cobertos pelo suporte ao cliente com base no melhor esforço. Como tal, estas funcionalidades não se destinam a utilização em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

Nota

KEDA versão 2.15 introduz uma mudança de quebra que remove o suporte de identidade pod. Recomendamos passar para a identidade da carga de trabalho para sua autenticação se você estiver usando a identidade do pod. Embora o complemento gerenciado pelo KEDA não execute atualmente o KEDA versão 2.15, ele começará a executá-lo na versão de visualização do AKS 1.31.

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

Antes de começar

Precisa de uma subscrição do Azure. Se não tiver uma subscrição do Azure, pode criar uma conta gratuita.
Você precisa da CLI do Azure instalada.
Este artigo pressupõe que você tenha um grupo de recursos do Azure existente. Se você não tiver um grupo de recursos existente, poderá criar um usando o az group create comando.
Certifique-se de ter regras de firewall configuradas para permitir o acesso ao servidor de API do Kubernetes. Para obter mais informações, consulte Rede de saída e regras FQDN para clusters do Serviço Kubernetes do Azure (AKS).
Crie um par de chaves SSH.

Nota

Se você estiver usando o Microsoft Entra Workload ID e habilitar o KEDA antes do Workload ID, precisará reiniciar os pods do operador KEDA para que as variáveis de ambiente adequadas possam ser injetadas:

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

Criar um par de chaves SSH

Navegue para o Azure Cloud Shell.

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

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

Habilite o complemento KEDA com um modelo ARM

Implante o modelo ARM para um cluster AKS.
Selecione Editar modelo.
Habilite o complemento KEDA especificando o workloadAutoScalerProfile campo no modelo ARM, conforme mostrado no exemplo a seguir:
```
    "workloadAutoScalerProfile": {
        "keda": {
            "enabled": true
        }
    }
```
Selecione Guardar.
Atualize os valores necessários para o modelo ARM:
- Assinatura: selecione a assinatura do Azure a ser usada para a implantação.
- 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 para usar no cluster.
- Linux Admin Username: insira um nome de usuário para o cluster.
- Origem da chave pública SSH: Selecione Usar chave existente armazenada no Azure.
- Chaves de armazenamento: selecione o par de chaves que você criou anteriormente no artigo.
Selecione Rever + criar>Criar.

Conecte-se ao cluster AKS

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

Se utilizar o Azure Cloud Shell, o kubectl já está instalado. Você também pode instalá-lo localmente usando o az aks install-cli comando.

Configure kubectl para se conectar ao cluster do Kubernetes, use o comando az aks get-credentials . O exemplo a seguir obtém credenciais para o cluster AKS chamado MyAKSCluster no MyResourceGroup:

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

Exemplo de implantação

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

{
    "$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"
            }
        }
    ]
}

Comece a dimensionar aplicativos com o KEDA

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

Remover recursos

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

Próximos passos

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

Para obter informações sobre a solução de problemas do KEDA, consulte Solucionar problemas do complemento Kubernetes Event-driven Autoscaling (KEDA).

Para saber mais, consulte os documentos KEDA upstream.

Partilhar via