Estratégias de escala com KEDA em suas aplicações em .NET 6.0
Olá pessoal, como vão?
Quero compartilhar com vocês uma feature muito interessante, para você usar em seus Pods de Kubernetes, o KEDA.
Significa Kubernetes Event Driven AutoScalling. Você pode direcionar o dimensionamento de qualquer contêiner Kubernetes com base no número de eventos que precisam ser processados, o que quer dizer, que você pode escalar seus pods de acordo com eventos disparados por sua aplicação.
Pense em seus microserviços, onde você tem eventos disparados de forma assíncrona pelo EventBus do Azure, e um consumidor que processará o evento.
Normalmente, podemos escalar esse Pod, caso ultrapasse 60% de memória ou 80% de CPU, por exemplo, o Kubernetes escala de forma automática, mas com o KEDA, escala de acordo com seus eventos.
No exemplo que mencionei, posso configurar da seguinte maneira:
- Quando tenham 5 mensagens na fila, a aplicação é escalada e caso tenham mais 5, ele escala mais um Pod e assim sucessivamente.
E o mais legal dele, que você pode configurar para que seu processo não fique vivo em sua infraestrutura, você pode deixar “desligado”, caso tenha alguma mensagem para ser processada, o container é ligado para processar a mensagem, depois que processou o Pod ficará novamente em off novamente.
Vamos ver a seguir como configurar o KEDA em seu cluster de Kubernetes e as configurações necessárias;
Em nosso exemplo, estou usando o AKS;
Primeiro ponto, com o cluster criado, é fazer a instalação do KEDA em seu cluster Kubernetes:
A instalação, você também acompanhar em sua documentação oficial;
No AKS, ao criar seu cluster, você tem disponível o HELM instalado, pois você precisará dele para fazer a instalação do KEDA
> helm repo add kedacore https://kedacore.github.io/charts
> helm repo update
> kubectl create namespace keda
> helm install keda kedacore/keda --namespace kedaVeja acima, que foi feito o download do pacote do KEDA em seu cluster, depois logo em seguida, foi criado um novo namespace chamado keda em seu cluster e depois a instalação do mesmo dentro do namespace;
Verifique se foi instalado corretamente, desta forma:
Depois da instalação do KEDA, vamos criar uma aplicação na qual receberá mensagem de uma fila do ServiceBus, para que possamos fazer o teste do KEDA para auto escalar essa aplicação;
Em nosso exemplo o nome da nossa fila, será: kedafila
Depois de feito a aplicação, vamos orquestrar nosso deploy para nosso cluster, com a criação de arquivos .yml para a implantação em seu cluster Kubernetes
Mas antes da criação dos arquivos, vamos criar um novo namespace em seu cluster para hospedar nossos pods;
> kubectl create namespace marraiakedaexemplo
Agora vamos criar nosso arquivo de deployment, para a realização do deploy dentro do cluster;
Veja que você necessita que a aplicação seja uma imagem de container em um ACR (Azure Container Registry), faça o build da imagem e depois realize o push da imagem em seu ACR;
Com a sua imagem em seu ACR, em seu cluster faça a implantação do deploy com esse comando:
> kubectl apply -f deployment.yml -n marraiakedaexemplo
Verifique agora em seu cluster, se o Pod está funcionando, com esse comando:
> kubectl get pod -n marraiakedaexemplo
Agora, vamos criar o arquivo de scalling, com configurações do KEDA, para quando tivermos mensagens na fila, o autoscalling aconteça para esse pod;
Veja no arquivo scalling.yml, que existem as configurações para autoscalling no objeto ScaledObject;
Percebam, que existe as propriedades minReplicaCount e maxReplicaCount, eles configuram a quantidade de réplicas mínimas e máximas que você quer colocar para essa aplicação. Neste exemplo colocamos como mínimo 0, que quando aplicarmos esse arquivo no cluster, ele modificará o deploy que fizemos anteriormente, onde existe um pod “ligado” e esse pod passará a estar “desligado”
E também no arquivo, existem as configurações da fila que o KEDA irá monitorar para essa aplicação, no objeto triggers, parâmetros como:
- queueName: Nome da fila do servicebus
- namespace: Namespece da fila do servicebus
- messageCount: Quantidade máxima de mensagens que cada pod irá suportar
Agora vamos aplicar esse arquivo em nosso cluster;
> kubectl apply -f scalling.yml -n marraiakedaexemplo
Note agora que o pod, está “desligado” com o comando:
> kubectl get pod -n marraiakedaexemplo
Para garantir, que seu autoscalling no KEDA funcionou verifique o status do mesmo com esse comando:
> kubectl get scaledobjects -n marraiaexemplokeda
Verifique se a propriedade READY está como True, isso quer dizer que está tudo certo para o autoscalling
Para realizar o teste, vamos criar uma outra aplicação para enviar mensagens para a fila, e depois verificar o autoscalling funcionando;
Execute o código,
e depois execute o comando:
> kubectl get pod -n marraiakedaexemplo
Veja que os pods estão sendo escalados de acordo com as mensagens enviadas ao ServiceBus;
E depois que as mensagens foram enviadas, você pode acompanhar que os pods começam a serem “desligados”, e quando termina de fato, todos os containers terminam seu estado;
Creio que para algumas estratégias de autoscalling, e evitar custo de processamento das aplicações em seu cluster, é uma ótima opção que você poderá usar em seu dia a dia.
Legal saber também, que ele funciona com várias tecnologias de mensageria, Kafka, RabbitMQ… deêm uma olhada na documentação, onde você poderá encontrar vários exemplos;
Segue o fonte do exemplo que usamos nesse artigo em meu github
Espero que tenham gostado, e até a próxima!
