DEV Community: jonas-elias

KEDA HTTP Add-on: Escalonamento Dinâmico por Volume de Requisições

jonas-elias — Fri, 28 Nov 2025 14:57:36 +0000

Introdução

O escalonamento tradicional baseado em CPU ou memória atende bem a diversos cenários, mas pode apresentar limitações em aplicações que sofrem bursts de requisições ou que exibem padrões de tráfego irregulares. Nesses casos, é comum que a aplicação mantenha níveis estáveis de CPU e memória ao mesmo tempo que enfrenta pressão direta no atendimento HTTP, gerando aumento de latência, formação de filas e redução de throughput antes que o autoscaler identifique a necessidade de ajuste.

O KEDA HTTP Add-on foi desenvolvido para lidar com essas situações ao permitir que o escalonamento considere o volume de requisições como métrica primária. Essa abordagem oferece uma resposta mais alinhada ao comportamento real da carga, especialmente em serviços sensíveis a variações rápidas de demanda ou que dependem de tempo de reação reduzido.

Como o Keda HTTP Add-on funciona?

O Keda HTTP Add-on é composto por quatro elementos principais, cada um com responsabilidades específicas dentro do fluxo de escalonamento baseado em requisições HTTP.

Operador – Responsável por observar eventos relacionados a HTTPScaledObjects. A partir dessas mudanças, cria, ajusta ou remove os recursos internos necessários para manter o comportamento de escalonamento.

Interceptor – Atua como ponto de entrada do tráfego HTTP. Ele recebe requisições externas, aplica o roteamento adequado e encaminha cada chamada para a aplicação interna correspondente.

Scaler – Monitora continuamente o volume de requisições pendentes associadas a uma aplicação. Com base nessa observação, reporta métricas para o KEDA utilizando o mecanismo de external scaler, permitindo que a decisão de escalonamento seja baseada diretamente no acúmulo de requisições.

KEDA – Opera como o escalador responsável por ajustar a quantidade de réplicas da aplicação HTTP. Ele utiliza os dados fornecidos pelo scaler para determinar quando aumentar ou reduzir o número de instâncias.

Como utilizar o componente?

A utilização do KEDA HTTP Add-on envolve alguns elementos dentro do ambiente Kubernetes. No contexto deste artigo, trabalharemos com o seguinte conjunto:

Aplicação PHP executando em Kubernetes
Uma aplicação HTTP, empacotada em container e implantada como um Deployment, servindo como base para observar o comportamento do escalonamento.
Deployment configurado para scale-to-zero
A configuração define que a aplicação pode ser reduzida a zero réplicas quando o tráfego estiver ocioso, permitindo observar o comportamento de inicialização sob demanda.
KEDA HTTP Add-on como ponto de interceptação
O add-on recebe o tráfego externo, gerencia a fila de requisições e garante que chamadas sejam corretamente encaminhadas ao serviço, independentemente do estado atual das réplicas.
Escalonamento orientado à demanda
Com o scaler monitorando as requisições pendentes, o KEDA ajusta o número de réplicas conforme o acúmulo ou redução do tráfego.
Atendimento de requisições mesmo com a aplicação inativa
O interceptor mantém uma fila temporária, permitindo que requisições recebam resposta mesmo quando o Deployment está em zero réplicas, enquanto o sistema inicia automaticamente novas instâncias.

Temos também alguns pré-requisitos a nível de ferramentas:

Docker (Desktop ou Engine)
Kubernetes configurado (kind ou Minikube)
Kubectl instalado
Helm instalado

Após todas instaladas e configuradas corretamente, é possível prosseguir.

1 - Criar a aplicação PHP

Crie um arquivo index.php

<?php

if ($_SERVER['REQUEST_URI'] === '/ping') {
    echo "pong";
    exit;
}

echo "Hello from PHP!";

Crie o Dockerfile:

FROM php:8.3-cli
COPY index.php /var/www/html/index.php
CMD ["php", "-S", "0.0.0.0:8080", "-t", "/var/www/html"]

Faça o build localmente:

eval $(minikube docker-env) # caso esteja utilizando o minikube
docker build -t keda-php-demo:latest .

2 - Criar o Deployment + Service

Arquivo deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: keda-php-demo
spec:
  replicas: 0
  selector:
    matchLabels:
      app: keda-php-demo
  template:
    metadata:
      labels:
        app: keda-php-demo
    spec:
      containers:
        - name: keda-php-demo
          image: keda-php-demo:latest
          imagePullPolicy: Never
          ports:
            - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: keda-php-demo
spec:
  selector:
    app: keda-php-demo
  ports:
    - port: 80
      targetPort: 8080

Aplicar:

kubectl apply -f deployment.yaml

3 - Instalar o KEDA

helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda --namespace keda --create-namespace

4 - Instalar o HTTP Add-on

helm install keda-addons-http kedacore/keda-add-ons-http \
  --namespace keda

Isso instala:

HTTP operator
Interceptor Proxy (responsável por receber requisições)
Scalers

5 - Criar o HTTPScaledObject

Arquivo http-scaledobject.yaml:

apiVersion: http.keda.sh/v1alpha1
kind: HTTPScaledObject
metadata:
  name: keda-php-demo
spec:
  hosts:
    - php-demo.local
  pathPrefixes:
    - /
  scaleTargetRef:
    name: keda-php-demo
    kind: Deployment
    apiVersion: apps/v1
    service: keda-php-demo
    port: 80
  replicas:
    min: 1
    max: 10
  scaledownPeriod: 30
  scalingMetric:
    requestRate:
      granularity: 1s
      targetValue: 10
      window: 1m

Aplicar:

kubectl apply -f http-scaledobject.yaml

6 - Testando a aplicação

Fazer port-forward do interceptor para acessar na máquina local:

kubectl port-forward svc/keda-add-ons-http-interceptor-proxy -n keda 8081:8080

Enviar requisição:

curl -H "Host: php-demo.local" http://localhost:8081/ping

Deve receber a resposta

pong

Mesmo com réplicas = 0.

O KEDA:

Intercepta a requisição
Sobe o pod automaticamente
Encaminha a requisição quando o pod está pronto
Escala conforme a fila de requisições
Derruba tudo após scaledownPeriod: 30 segundos

OBS: É recomendável manter sempre réplicas ativas em ambientes de alto volume. Caso todas as réplicas cheguem a zero, o tempo necessário para que um novo POD/máquina fique saudável pode levar o solicitante a receber um Bad Gateway, o que acaba sendo contabilizado como indisponibilidade.

Analisando o dashboard do minikube

Caso tenha optado pelo minikube, é possível observar o comportamento no dashboard através do comando:

minikube dashboard

Após isso a seguinte página com os componentes do K8S será apresentada no navegador:

Como o scaling realmente funciona?

O HTTP Add-on não escala baseado em CPU e não escala baseado em RPS (Requests por Segundo).
Ele usa o número de requisições pendentes na fila interna mantida pelo interceptor.

Esse número representa quantas requisições ainda estão esperando ser atendidas pelos pods.

O algoritmo usado é o mesmo algoritmo oficial do Kubernetes HPA, só que aplicado à métrica de requisições pendentes.

A fórmula do HPA é:

desiredReplicas = ceil(
    currentReplicas * ( pendingRequests / targetPendingRequests )
)

Onde:

pendingRequests -> tamanho da fila interna
targetPendingRequests -> quantas requisições 1 pod deve conseguir suportar sem saturar
currentReplicas -> número atual de pods
desiredReplicas -> número final de pods após cálculo

Suponha:

pendingRequests = 25
targetPendingRequests = 10
currentReplicas = 1

Aplicando a fórmula:

desiredReplicas = ceil(1 * (25 / 10))
desiredReplicas = ceil(2.5)
desiredReplicas = 3

Ou seja: 3 réplicas são necessárias para esvaziar a fila mantendo ~10 requisições por pod.

Esse comportamento é consistente, previsível e resistente a bursts.

Considerações finais

Esse setup demonstra como o KEDA HTTP Add-on permite construir serviços:

Eficientes e responsivos
Econômicos (scale-to-zero real)
Independentes de métricas como CPU e memória

Além disso, demonstra como é possível montar um ambiente completo em máquina local sem complexidade.

O único ponto de atenção é que o componente ainda está em beta release (data de publicação do artigo 11/2025), ou seja, os mantenedores não garantem um funcionamento 100% confiável em ambientes produtivos. Todavia o projeto se mostra muito promissor e logo logo (assim esperamos) estará production ready.

Referências

Gerando embeddings com PHP e ONNX

jonas-elias — Mon, 15 Jul 2024 21:13:56 +0000

IA e PHP

No campo da inteligência artificial (IA) e processamento de linguagem natural (NLP), embeddings são representações matemáticas de palavras, frases ou documentos que capturam seu significado semântico. Esses embeddings são utilizados para aplicações que incluem busca semântica, análise de sentimentos, entre outros. A criação de embeddings geralmente envolve técnicas de aprendizado de máquina que tradicionalmente são implementadas em linguagens como Python. No entanto, com a crescente popularidade da arquitetura Open Neural Network Exchange (ONNX), é possível integrar modelos pré-treinados em diferentes linguagens de programação, incluindo PHP.

Transformers PHP

Para utilização dos modelos de inteligência artificial visando a geração de embeddings no PHP, é possível utilizar a biblioteca TransformersPHP, no qual foi projetada para ser funcionalmente equivalente à biblioteca Transformers em Python, mantendo o mesmo nível de desempenho e facilidade de uso. O TransformersPHP utiliza o ONNX Runtime para executar os modelos pré-treinados.

Arquitetura Exemplo

A seguir, é possível observar visualmente o funcionamento da geração de embeddings a partir da biblioteca TransformersPHP:

Uso

Primeiramente, realize a configuração da imagem que será utilizada pelo container. Para utilização do TransformersPHP com suporte a geração de embeddings, é necessário o uso das extensões FFI e Imagick. A extensão FFI é a interface de integração entre código binário e a linguagem PHP. Já o Imagick é utilizado para o processamento dos modelos pré-treinados.

FROM php:8.3

RUN apt-get update && apt-get install -y libffi-dev \
        git \
        unzip \
        libmagickwand-dev \
        libmagickcore-dev      

RUN docker-php-ext-configure ffi --with-ffi \
    && docker-php-ext-install ffi

RUN pecl install imagick \
    && docker-php-ext-enable imagick

RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

RUN mkdir /embeddings

WORKDIR /embeddings

CMD ["/bin/bash"]

Após isso, é possível realizar a criação da imagem:

docker build -t image-php-ffi .

Seguida da execução do container:

docker run -it --rm --name container-php-ffi image-php-ffi

Dentro do container, é necessário primeiramente adicionar a dependência codewithkyrian/transformers, logo deve-se executar:

composer require codewithkyrian/transformers

Com isso, o ambiente está configurado e pronto para receber o código que fará a geração do embedding. Abaixo, é possível verificar que o código PHP faz referência ao modelo Xenova/bert-base-uncased, disponibilizado pela iniciativa Xenova, no qual oferece modelos pré-treinados a partir da arquitetura ONNX.

<?php

declare(strict_types=1);

require_once './vendor/autoload.php';

use Codewithkyrian\Transformers\Transformers;
use function Codewithkyrian\Transformers\Pipelines\pipeline;
use function Codewithkyrian\Transformers\Utils\{memoryUsage, timeUsage};

Transformers::setup()
    ->apply();

$extractor = pipeline('feature-extraction', 'Xenova/bert-base-uncased');

$embeddings = $extractor('The quick brown fox jumps over the lazy dog.', normalize: true, pooling: 'mean');

var_dump($embeddings[0]);

dd(memoryUsage(), timeUsage(milliseconds: true), count($embeddings[0]));

Realize a criação de um novo arquivo PHP, copie o código acima e após isso, execute o arquivo com php nome_arquivo.php. A primeira execução pode requerer um tempo de processamento maior por conta do download do modelo pré-treinado.

Busca Semântica

A geração de embeddings pode ser benéfica para produzir sistemas de busca ao nível semântico, como abordo mais especificamente na palestra Palestra APIs e LLMs.

Desvantagens

Utilizar PHP e a arquitetura ONNX para gerar embeddings pode apresentar algumas desvantagens. A maioria dos modelos transformers são desenvolvidos com a arquitetura PyTorch, que é fortemente integrada à linguagem Python, limitando a realização de testes e desenvolvimento em outras linguagens. A conversão de modelos PyTorch para ONNX pode ser complexa ou até inviável, dependendo do suporte e das atualizações fornecidas pelos mantenedores dos modelos.

Conclusão

Integrar IA e NLP com PHP utilizando a arquitetura ONNX é uma abordagem promissora que permite a utilização de modelos pré-treinados em uma linguagem de programação amplamente usada no desenvolvimento web. A biblioteca TransformersPHP demonstra ser uma ferramenta funcionalmente equivalente à sua contraparte em Python, permitindo a geração de embeddings com facilidade e eficiência.

Embora existam desafios, como a complexidade na conversão de modelos e a necessidade de extensões específicas, a utilização de PHP para geração de embeddings pode abrir novas oportunidades para desenvolvedores web que desejam incorporar capacidades de NLP em suas aplicações sem a necessidade de migrar para outras linguagens.

Com a evolução contínua dessas tecnologias e o aumento do suporte da comunidade, espera-se que as barreiras atuais sejam progressivamente reduzidas, tornando essa abordagem cada vez mais acessível e eficaz para diversos desenvolvedores e aplicações.

Referências

Substituindo o Redis pelo Valkey em projetos PHP/Hyperf

jonas-elias — Tue, 21 May 2024 02:12:25 +0000

Licença Redis

Recentemente, o Redis estava disponível sob a Licença Pública Geral Affero (AGPL), uma licença de código aberto que exigia que qualquer software modificado usando o Redis também fosse distribuído sob os termos da AGPL. Isso significava que qualquer empresa que construísse um produto sobre o Redis e o modificasse de alguma forma tinha a obrigação de compartilhar essas modificações com a comunidade.

O novo modelo de licenciamento do Redis baseia-se em duas novas licenças: a Redis Source Available License (RSAL) e a Redis Commons Clause. A RSAL permite o acesso ao código-fonte do Redis, mas com restrições sobre sua utilização. Já a Redis Commons Clause, uma adição à RSAL, impõe restrições adicionais, proibindo o uso comercial do software em determinados contextos, a menos que uma licença comercial seja adquirida.

Alternativas

Existem alternativas como Memcached, DynamoDB, entre outros. Todos estes mencionados podem gerar reescrita de código, dependendo do formato no qual o projeto foi escrito. Para evitar os problemas mencionados anteriormente, apresento o Valkey.

O Valkey trata-se basicamente de um fork do Redis, logo, a lógica de implementação continua a mesma. O "pulo do gato" está em relação ao tipo de licença, que permite a comercialização por estar ligada a Copyright (c) 2024-present, Valkey contributors e Copyright (c) 2006-2020, Salvatore Sanfilippo.

Implementação

Mas e agora? Como proceder em meu projeto PHP?

Irei apresentar um exemplo utilizando o framework Hyperf, mas nada impede a implementação também no Laravel, Symfony, ou qualquer outro framework que utiliza conectores Redis.

O docker-compose.yml abaixo realiza o pull da imagem valkey/valkey, possibilitando o uso no container de uma aplicação Hyperf:

version: "3"

name: redis-to-valkey

services:
  hyperf-valkey:
    build: ./
    container_name: hyperf-valkey
    ports:
      - 9501:9501
    depends_on:
      - valkey
    restart: always

  valkey:
    container_name: valkey
    image: valkey/valkey
    ports:
      - 6379:6379

O backend hyperf-valkey é construído com base no Dockerfile abaixo (instalando também a extensão interface redis-php:

FROM php:8.2

RUN apt-get update && apt-get install --no-install-recommends -y \
    wget \
    vim \
    git \
    unzip

RUN apt-get update \
    && apt-get install --no-install-recommends -y \
    libzip-dev \
    libcurl4-openssl-dev \
    libssl-dev \
    libpq-dev \
    libjpeg-dev \
    libpng-dev \
    libfreetype6-dev \
    g++ \
    libaio-dev \
    libicu-dev

RUN curl -sS https://getcomposer.org/installer | php -- \
    --install-dir=/usr/local/bin \
    --filename=composer

RUN docker-php-ext-configure gd --with-freetype=/usr/include/ --with-jpeg=/usr/include/ \
    && pecl install redis \
    && printf "no\nyes\nno\nyes\n" | pecl install swoole \
    && echo "swoole.use_shortname = Off" >> /usr/local/etc/php/conf.d/swoole.ini \
    && docker-php-ext-install \
    pcntl \
    gd \
    && docker-php-ext-enable \
    redis \
    swoole

EXPOSE 9501

Após isso, acesse o container via bash ou remote containers e crie o projeto:

composer create-project hyperf/hyperf-skeleton

No questionamento Do you want to use Redis Client?, selecione y

No arquivo .env, altere as chaves REDIS para:

REDIS_HOST=valkey
REDIS_AUTH=(null)
REDIS_PORT=6379
REDIS_DB=0

Com isso, a conexão Valkey com o projeto Hyperf já está concluída. Para utilizar a funcionalidade de cache com o Valkey, vamos acessar a IndexController.php e substituir o conteúdo existente pelo código abaixo:

<?php

declare(strict_types=1);

namespace App\Controller;

use Hyperf\Redis\Redis as Valkey;

class IndexController extends AbstractController
{
    public function __construct(protected Valkey $valkey)
    {
    }

    public function index()
    {
        $content = 'hello valkey!';
        $key = 'cache';
        $this->valkey->set($key, $content);

        return [$this->valkey->get($key)];
    }
}

Inicie a aplicação com php bin/hyperf.php start, acessando posteriormente o endereço http://127.0.0.1:9501, tendo como retorno:

Considerações

Para projetos em andamento que já estão utilizando o Redis, basta substituir o host Redis pelo serviço Valkey (via container, como exemplificado). Além disso, projetos Laravel podem seguir a mesma lógica utilizando a biblioteca predis/predis.

O ideal pela questão de nomenclaturas e responsabilidades, seria utilizar/criar pacotes específicos para o Valkey, já que provavelmente receberá modificações específicas ao longo do tempo, distanciando um pouco a equivalência com o projeto Redis. Contudo, a solução apresentada neste artigo é viável.

Referências

VueJS + Tailwind + DaisyUI = 😎🌷

jonas-elias — Mon, 20 May 2024 18:36:23 +0000

Vue é um robusto framework JavaScript dedicado à construção de interfaces de usuário interativas e dinâmicas. Esta ferramenta poderosa é construída sobre os fundamentos da web moderna: HTML, CSS e JavaScript. Com um modelo de programação declarativo e baseado em componentes, o Vue capacita os desenvolvedores a criar interfaces de usuário de qualquer complexidade de forma eficiente e organizada.

Além disso, abrange a maioria dos recursos comuns necessários no desenvolvimento de frontend. No entanto, a web é extremamente diversa - as coisas que construímos na web podem variar drasticamente em forma e escala. Com isso em mente, Vue é projetado para ser flexível e adotável incrementalmente. Dependendo do seu caso de uso, Vue pode ser utilizado de diferentes maneiras:

Aprimorando HTML estático sem um passo de compilação
Incorporando como Componentes da Web em qualquer página Aplicação de Página Única (SPA)
Fullstack / Renderização do Lado do Servidor (SSR)
Jamstack / Geração de Site Estático (SSG)
Direcionamento para desktop, mobile, WebGL e até mesmo o terminal

Para criar um novo projeto Vue, certifique-se de ter uma versão atualizada do Node.js instalada e que seu diretório de trabalho atual seja o onde pretende criar um projeto. Execute o seguinte comando em sua linha de comando:

npm create vue@latest

✔ Project name: … <your-project-name>
✔ Add TypeScript? … No
✔ Add JSX Support? … No
✔ Add Vue Router for Single Page Application development? … No
✔ Add Pinia for state management? … No
✔ Add Vitest for Unit testing? … No
✔ Add an End-to-End Testing Solution? … No
✔ Add ESLint for code quality? … Yes
✔ Add Prettier for code formatting? … No
✔ Add Vue DevTools 7 extension for debugging? (experimental) … No

Scaffolding project in ./<your-project-name>...
Done.

cd <your-project-name>
npm install
npm run dev

Com isso você já possui um projeto Vue sendo executado localmente.

O projeto pode ser integrado com Tailwind CSS, sendo
um framework CSS orientado para utilitários, repleto de classes como flex, pt-4, text-center e rotate-90, que podem ser combinadas para construir qualquer design diretamente em seu markup.

Para instalá-lo em seu projeto, basta executar a instalação das dependências abaixo:

npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p

Configure o arquivo tailwind.config.js adicionando em seu content as diretivas:

content: ["./index.html", "./src/**/*.{vue,js,ts,jsx,tsx}",],

Adicione as diretivas do tailwind no arquivo CSS carregado no componente central (ou carrego-o manualmente com as diretivas abaixo):

@tailwind base;
@tailwind components;
@tailwind utilities;

Para finalizar a configuração do projeto, vamos adicionar o plugin daisyUI - Tailwind CSS. O daisyUI adiciona nomes de classes de componentes ao Tailwind CSS para que você possa criar websites bonitos mais rapidamente.

Para adicioná-lo ao projeto, basta executar os comandos abaixo:

npm i -D daisyui@latest

E configurá-lo no arquivo tailwind.config.js:

export default {
  content: ["./index.html", "./src/**/*.{vue,js,ts,jsx,tsx}",],
  theme: {
    extend: {

    },
  },
  plugins: [require('daisyui'),],
}

Com esses passos, seu projeto Vue estará pronto para criar interfaces de usuário dinâmicas e esteticamente agradáveis de forma eficiente. A combinação do Vue com o Tailwind CSS e o daisyUI oferece uma experiência de desenvolvimento ágil e flexível, permitindo que você se concentre na criação de ótimas experiências para os usuários finais.