← Voltar para o blog

Publicado em

Onde ter Redis ou Valkey gerenciado no Brasil pagando em real?

Na Zenifra, o Valkey gerenciado é compatível com clientes Redis, roda no Brasil e é cobrado em real: o Valkey Cache começa em R$ 34,90 por mês e o Valkey Queue, em R$ 44,90 por mês. O pagamento sai do crédito colocado por PIX ou boleto, ou do cartão, sem IOF de compra internacional.

Resposta curta: Valkey gerenciado no Brasil, em real

Na Zenifra, você cria um Valkey gerenciado, compatível com clientes e comandos Redis, com preço em real e infraestrutura em São Paulo. Os planos começam em R$ 34,90 por mês (Cache Starter, 512 MiB de RAM) e R$ 44,90 por mês (Queue Starter, 512 MiB de RAM e 5 GB de armazenamento persistente).

O serviço tem três perfis, escolhidos no card do Console na criação: Chave‑Valor para estado da aplicação que precisa sobreviver a reinícios, Cache para dados descartáveis em memória e Filas para tarefas assíncronas com workers. Os três aceitam cobrança por hora, mensal ou anual, exigem TLS e autenticação e entregam uma conexão no formato valkeys://. O pagamento sai do crédito da organização, que entra por PIX (a partir de R$ 5) ou boleto (a partir de R$ 30), e o cartão entra como reserva quando falta crédito.

Se você procura Redis gerenciado em São Paulo, existem outras opções: o Upstash permite escolher a região sa-east-1 (São Paulo) e a AWS oferece o ElastiCache na mesma região. Os dois cobram em dólar. Render e Railway, que muita gente usa para projetos pequenos, não têm região no Brasil. Mais abaixo, a comparação mostra preços oficiais convertidos para real com PTAX e IOF.

O que é o Valkey e qual a relação com o Redis

O Valkey é um banco de chave-valor em memória, de código aberto sob licença BSD, mantido como projeto da Linux Foundation. Segundo a página de história do próprio projeto, ele é um fork do Redis de código aberto: em 2024, a Redis Ltd. trocou a licença do Redis de BSD para duas licenças source-available (RSALv2 e SSPLv1), e um grupo de seis contribuidores ativos, um de cada empresa entre Alibaba, Amazon, Ericsson, Google, Huawei e Tencent, lançou o Valkey na Linux Foundation oito dias depois. A primeira versão foi a 7.2.5.

Do lado do Redis, a página de licenças da redis.io explica a situação atual: até a versão 7.2 o Redis segue BSD-3-Clause; a 7.4 ficou sob RSALv2 ou SSPLv1; a partir do Redis 8, o usuário pode escolher entre RSALv2, SSPLv1 e AGPLv3, sendo que só a AGPLv3 é uma licença de código aberto aprovada pela OSI. Para quem só conecta uma aplicação a um serviço gerenciado, a licença do servidor raramente muda o dia a dia. Ela pesa para quem redistribui o software ou oferece o banco como serviço.

Na prática, o que interessa ao desenvolvedor é a compatibilidade. O Valkey fala o mesmo protocolo e aceita os comandos que você já usa (GET, SET com EX, INCR, EXPIRE, listas, hashes, Streams, Pub/Sub), e clientes conhecidos como redis para Ruby e Rust, phpredis e Predis funcionam com ele. O projeto também mantém clientes próprios, como valkey-py, valkey-go, valkey-java e Valkey GLIDE. Na Zenifra, o catálogo informa o motor Valkey na linha 9.1 (versão 9.1.2 no campo version do catálogo de 06/11/2026).

Projeto e versãoLicençaFonte
Valkey (todas as versões)BSD (código aberto), projeto da Linux Foundationvalkey.io
Redis 7.2 e anterioresBSD-3-Clauseredis.io/legal/licenses
Redis Community Edition 7.4RSALv2 ou SSPLv1 (source-available)redis.io/legal/licenses
Redis Open Source 8 em dianteRSALv2, SSPLv1 ou AGPLv3, à escolha do usuárioredis.io/legal/licenses

Cache, Chave‑Valor ou Filas: qual perfil escolher (e quando usar RabbitMQ)

A pergunta que decide o perfil é o que acontece se o dado sumir. Se a aplicação consegue reconstruir o valor a partir da fonte de verdade, como o resultado de uma consulta cara ou uma página renderizada, use Cache: os dados ficam só em memória, sem armazenamento persistente e sem réplicas, e quando a memória do plano acaba as chaves menos usadas são removidas. Se o dado faz parte do estado da aplicação e precisa sobreviver a reinícios, como sessões, contadores, locks e estado compartilhado, use Chave‑Valor, que grava cada escrita em disco com AOF. Se produtores e consumidores precisam trocar trabalho com confirmação, use Filas.

Filas tem dois motores. O Valkey é o caminho curto para tarefas em segundo plano: Streams com consumer groups, confirmação por XACK e recuperação de pendências com XPENDING e XAUTOCLAIM. O RabbitMQ (versão 4.4, protocolo AMQP 0-9-1) é a escolha quando vários serviços trocam mensagens com regras de roteamento, porque oferece exchanges, routing keys, confirmação de publicação e dead-letter nativa. Os dois usam os mesmos planos e os mesmos preços. O motor é escolhido na criação e não muda depois.

A alta disponibilidade também depende do perfil. Cache é sempre instância única, em todos os planos. Chave‑Valor e Filas com Valkey têm uma primária e duas réplicas a partir do plano Basic; o Starter é instância única. No RabbitMQ, o Starter tem 1 nó com fila clássica e os planos Basic, Premium e Enterprise têm 3 nós com filas quorum por padrão. Chave‑Valor e Filas têm backup automático incluído, com restauração pelo suporte; o Cache não tem backup, porque guarda dados apenas em memória.

PerfilUse paraPersistênciaAlta disponibilidadePlanos
Valkey Cacherespostas calculadas, consultas e dados descartáveisnenhuma: só memória, com remoção das chaves menos usadasnão, instância única em todos os planoscache-starter, cache-basic, cache-premium, cache-enterprise
Valkey Chave‑Valorsessões, estado compartilhado, contadores e lockssim, AOF em disco; capacidade escolhida na criação e cobrada à parteuma primária e duas réplicas a partir do db-basicdb-starter, db-basic, db-premium, db-enterprise
Filas com Valkeytarefas assíncronas, workers e eventos persistentessim, AOF; 5 GB incluídosuma primária e duas réplicas a partir do queue-basicqueue-starter, queue-basic, queue-premium, queue-enterprise
Filas com RabbitMQmensageria entre microsserviços com roteamento e dead-lettersim, filas duráveis ou quorum3 nós com filas quorum a partir do queue-basicqueue-starter, queue-basic, queue-premium, queue-enterprise

Planos e preços do Valkey gerenciado em real

Os valores abaixo vêm do catálogo público de serviços gerenciados da Zenifra (GET https://api.zenifra.com/v1/managed-services/catalog, lido em 06/11/2026), que publica os preços em centavos de real. Os três perfis aceitam cobrança por hora, mensal ou anual. Na cobrança por hora, as horas em execução do ciclo são somadas e arredondadas para cima, para a hora cheia, e um projeto parado não gera cobrança de processamento. No contrato mensal ou anual, o valor fica fixo mesmo se você pausar o projeto.

Os planos Premium e Enterprise de cada perfil incluem métricas da instância na página do projeto. Nas Filas pagas, os 5 GB de armazenamento incluídos podem ser ampliados, com cobrança só do excedente. No Chave‑Valor, a capacidade de armazenamento é escolhida na criação e cobrada à parte, com mínimo de 1 GB no db-starter, 3 GB no db-basic, 5 GB no db-premium e 20 GB no db-enterprise, porque o armazenamento precisa ser de ao menos três vezes o limite de dados do plano para regravar os dados com segurança.

Para comparar com preço por hora de outros provedores: o Cache Starter custa R$ 0,06 por hora, o que dá R$ 43,80 em um mês de 730 horas ligado sem parar; o plano mensal, a R$ 34,90, sai mais barato para quem deixa o cache ligado o mês inteiro. A cobrança por hora compensa para ambientes de teste que ficam desligados boa parte do tempo.

PlanovCPU e RAMPersistência e HAPor horaMensalAnual
cache-starter0,5 vCPU, 512 MiBsem persistência, instância únicaR$ 0,06R$ 34,90R$ 349,00
cache-basic1 vCPU, 1 GiBsem persistência, instância únicaR$ 0,10R$ 59,90R$ 599,00
cache-premium2 vCPU, 2 GiBsem persistência, instância única, métricasR$ 0,21R$ 119,90R$ 1.199,00
cache-enterprise8 vCPU, 8 GiBsem persistência, instância única, métricasR$ 0,87R$ 499,90R$ 4.999,00
queue-starter0,5 vCPU, 512 MiB5 GB com AOF, backup a cada 24 h, instância únicaR$ 0,08R$ 44,90R$ 449,00
queue-basic1 vCPU, 1 GiB5 GB com AOF, primária e duas réplicas, backup a cada 12 hR$ 0,13R$ 74,90R$ 749,90
queue-premium2 vCPU, 2 GiB5 GB com AOF, primária e duas réplicas, métricasR$ 0,26R$ 149,90R$ 1.499,00
queue-enterprise8 vCPU, 8 GiB5 GB com AOF, primária e duas réplicas, backup a cada 8 hR$ 1,13R$ 649,90R$ 6.499,00
db-starter (Chave‑Valor)0,3 vCPU, 256 MBAOF, armazenamento à parte, instância únicaR$ 0,018R$ 11,90R$ 130,90
db-basic (Chave‑Valor)1 vCPU, 1 GBAOF, primária e duas réplicasR$ 0,076R$ 49,90R$ 548,90
db-premium (Chave‑Valor)2 vCPU, 2 GBAOF, primária e duas réplicas, métricasR$ 0,18R$ 129,90R$ 1.428,90
db-enterprise (Chave‑Valor)8 vCPU, 8 GBAOF, primária e duas réplicas, métricasR$ 0,75R$ 489,00R$ 5.388,90

O Valkey mais barato é o perfil Chave‑Valor no db-starter, a R$ 11,90 por mês mais o armazenamento, para estado que precisa sobreviver a reinícios; para cache em memória, o ponto de partida é o cache-starter, a R$ 34,90. O cadastro pede CPF ou CNPJ, celular e endereço no Brasil.

Comparação com Upstash, Redis Cloud, ElastiCache, Render e Railway

Lemos as páginas oficiais de preço de cada provedor em 06/11/2026 e convertemos os valores em dólar para real com a PTAX de venda de 05/11/2026 (R$ 5,4621) mais o IOF de 3,5% que incide em compra com cartão internacional. A exceção é a AWS: para clientes no Brasil, quem fatura é a Amazon AWS Serviços Brasil Ltda., em real, com o câmbio do dia em que a fatura é gerada e com PIS/COFINS e ISS destacados na nota; por isso, a linha do ElastiCache mostra só a conversão pela PTAX, sem IOF. Para preços por hora, consideramos um mês de 730 horas.

As comparações não são idênticas, porque cada provedor mede uma coisa. O Upstash vende por tamanho de dados (Fixed) ou por comando (Pay as You Go). O Redis Cloud e o Render vendem por memória. O ElastiCache vende por nó (instância) ou, no modo serverless, por GB-hora de dados e por unidade de processamento. A Railway cobra pelos recursos consumidos por cada serviço. A tabela alinha os planos de entrada pela memória ou pelo tamanho de dados mais próximo.

Sobre região, que importa para a latência: o Upstash lista São Paulo (sa-east-1) entre as regiões disponíveis, e o price list da AWS publica o ElastiCache em South America (São Paulo). O Render oferece Oregon, Ohio, Virgínia, Frankfurt e Singapura, e a Railway oferece US West, US East, EU West e Southeast Asia.

Provedor e planoMemória ou dadosPreço oficialEm R$ (PTAX + IOF 3,5%)Região no Brasil
Zenifra cache-starter512 MiB de RAMR$ 34,90/mêsR$ 34,90 (já em real)sim, São Paulo
Zenifra cache-basic1 GiB de RAMR$ 59,90/mêsR$ 59,90 (já em real)sim, São Paulo
Upstash Free250 MB de dados, 500 mil comandos/mêsUS$ 0R$ 0sa-east-1 disponível
Upstash Fixed 250MB250 MB de dados, 50 GB de bandaUS$ 10/mêsR$ 56,5327sa-east-1 disponível
Upstash Fixed 1GB1 GB de dados, 100 GB de bandaUS$ 20/mêsR$ 113,0655sa-east-1 disponível
Upstash Pay as You Goaté 100 GB de dadosUS$ 0,20 por 100 mil comandos; US$ 0,25/GB de armazenamento (1º GB grátis)R$ 1,1307 por 100 mil comandossa-east-1 disponível
Redis Cloud Free30 MBUS$ 0R$ 0,
Redis Cloud Essentialsa partir de 250 MBa partir de US$ 0,007/hora, total de US$ 5/mêsR$ 28,2664,
AWS ElastiCache Valkey cache.t4g.micro (sa-east-1)0,5 GiBUS$ 0,024/hora = US$ 17,52/mêsR$ 95,6960 (só PTAX; faturado em real pela AWS SBL)sim, São Paulo
AWS ElastiCache Valkey cache.t4g.small (sa-east-1)1,37 GiBUS$ 0,0488/hora = US$ 35,624/mêsR$ 194,5819 (só PTAX)sim, São Paulo
Render Key Value Free25 MB de RAMUS$ 0R$ 0não
Render Key Value 256 MB256 MB de RAM, 256 MB de discoUS$ 10/mêsR$ 56,5327não
Render Key Value 1 GB1 GB de RAM, 2,5 GB de discoUS$ 20/mêsR$ 113,0655não
Railway (cobrança por recurso)RAM a US$ 10 por GB-mês e CPU a US$ 20 por vCPU-mês, dentro da assinatura Hobby (US$ 5) ou Pro (US$ 20)256 MB de RAM = US$ 2,50/mês só de memóriaR$ 14,1332 só de memória, mais CPU e assinaturanão

Onde outra opção serve melhor: para um cache com pouco tráfego, o Pay as You Go do Upstash pode custar menos que um plano fixo, e o plano grátis do Upstash, com 250 MB de dados, atende testes e projetos pequenos. Se a sua aplicação já roda na AWS em São Paulo, o ElastiCache fica na mesma rede da aplicação e é faturado em real pela AWS SBL. Se a sua aplicação está no Render ou na Railway, o Key Value da própria plataforma fica na rede privada dela. A Zenifra ganha quando você quer preço fixo em real, PIX ou boleto, alta disponibilidade a partir do plano Basic nas Filas e no Chave‑Valor e a aplicação no mesmo Console.

Como criar no Console e conectar com Node.js ou Python

O passo a passo da documentação para um Cache: no menu, clique em Criar projeto e escolha Valkey Cache. Em Configurar Valkey, escolha o perfil e o plano. Escolha o Tipo de Pagamento (por hora, mensal ou anual) e dê um nome ao cache em Informações Básicas. Revise o Resumo de Custos e clique em Criar Serviço Gerenciado. Para Filas, o fluxo é o mesmo, com a escolha do motor (Valkey ou RabbitMQ) antes do plano. A credencial de conexão aparece uma única vez, logo após a criação, e só volta a aparecer depois de uma rotação de credencial.

A conexão tem o formato valkeys://default:SENHA@HOST:PORTA/0 e deve chegar à aplicação pela variável VALKEY_URL, guardada como variável protegida ou em um gerenciador de segredos, nunca no código. Por padrão, o endpoint é público em IPv4 e exige TLS e autenticação. Você pode desligar o acesso público no card Acesso público; aí, só aplicações e Jobs da organização conectam, pelas conexões privadas no endereço <projeto>.<id-da-organização>.zenifra.local. Algumas bibliotecas não reconhecem o esquema valkeys://; nesse caso, troque só o esquema por rediss:// e mantenha a validação do certificado e do hostname.

Em Node.js, a documentação usa o pacote iovalkey (npm install iovalkey); em Python, o valkey-py (python -m pip install valkey). Os dois exemplos abaixo, copiados da documentação, leem a VALKEY_URL, validam o esquema, ligam o TLS com verificação do hostname, gravam uma chave com expiração de 60 segundos e leem de volta. Para testar pelo terminal, use valkey-cli -u "${VALKEY_URL/valkeys:/rediss:}" --tls ping, que deve responder PONG. Abra uma conexão reutilizável por processo, não uma por comando.

  • Outros clientes listados na documentação: valkey-go (Go), valkey-java (Java), phpredis e Predis (PHP; a extensão redis já vem no runtime PHP da Zenifra), Valkey GLIDE (.NET), a gem redis (Ruby) e a crate redis (Rust). No Laravel, defina REDIS_URL com a URI do Console.
typescript
import Redis from 'iovalkey'

const rawUrl = process.env.VALKEY_URL
if (!rawUrl) throw new Error('VALKEY_URL is required')

const parsed = new URL(rawUrl)
if (parsed.protocol !== 'valkeys:') throw new Error('VALKEY_URL must use valkeys://')

const client = new Redis({
  host: parsed.hostname,
  port: Number(parsed.port),
  username: decodeURIComponent(parsed.username),
  password: decodeURIComponent(parsed.password),
  tls: { servername: parsed.hostname },
})

await client.set('healthcheck', 'ok', 'EX', 60)
console.log(await client.get('healthcheck'))
await client.quit()
python
import os
from urllib.parse import urlparse
from valkey import Valkey

raw_url = os.environ["VALKEY_URL"]
parsed = urlparse(raw_url)
if parsed.scheme != "valkeys":
    raise ValueError("VALKEY_URL must use valkeys://")

client = Valkey(
    host=parsed.hostname,
    port=parsed.port,
    username=parsed.username,
    password=parsed.password,
    db=0,
    ssl=True,
    ssl_check_hostname=True,
    decode_responses=True,
)

client.set("healthcheck", "ok", ex=60)
print(client.get("healthcheck"))
client.close()

Padrão 1: sessão e cache-aside

Sessão de usuário é estado da aplicação: se sumir, o usuário é deslogado. Por isso, a documentação indica o perfil Chave‑Valor para sessões, com chave por namespace e expiração compatível com o ciclo de autenticação, como SET session:{user-id} <json> EX 3600 para uma hora. Se você aceita que um reinício deslogue todo mundo, como em um protótipo, o Cache também serve, mas saiba que ele não tem persistência nem réplicas. Para locks curtos, use SET lock:{resource} <token-único> NX EX 30 e, ao liberar, compare o token no servidor para não remover o lock de outro worker.

Cache-aside é o padrão mais comum para o perfil Cache: leia a chave; em caso de miss, consulte a fonte de verdade; grave o resultado com TTL e, quando possível, um pequeno jitter aleatório; invalide a chave quando a fonte de verdade mudar. Os comandos são GET catalog:product:42, SET catalog:product:42 <json> EX 300 e DEL catalog:product:42. O jitter evita que milhares de chaves expirem no mesmo segundo e façam todas as requisições baterem no banco ao mesmo tempo.

A documentação lista o que não fazer: não tratar Cache como armazenamento permanente, não usar TTL infinito para dados que crescem sem limite, não usar KEYS * para limpar o cache (prefira namespaces com SCAN ou invalidação por chave) e não supor que um hit significa dado atualizado. Monitore hit rate, miss rate, latência e evictions, e trate falha do Cache como caminho normal: a aplicação consulta a origem e continua funcionando.

javascript
import Redis from 'iovalkey'
import { randomInt } from 'node:crypto'

async function loadProductFromSource() {
  return { id: 42, name: 'example' }
}

const url = new URL(process.env.VALKEY_URL ?? '')
const client = new Redis({
  host: url.hostname,
  port: Number(url.port),
  username: decodeURIComponent(url.username),
  password: decodeURIComponent(url.password),
  tls: { servername: url.hostname },
})

const key = 'catalog:product:42'
const cached = await client.get(key)
const value = cached ?? JSON.stringify(await loadProductFromSource())
if (!cached) await client.set(key, value, 'EX', 300 + randomInt(0, 30))
console.log(value)
await client.quit()

Padrão 2: rate limit e fila de jobs com Streams

Rate limit é um contador com prazo de validade. A documentação de comandos do Valkey descreve o padrão com INCR: para limitar uma API a 10 requisições por segundo por IP, crie uma chave por IP e por segundo, incremente com INCR e defina EXPIRE de 10 segundos na mesma transação (MULTI e EXEC), para que a expiração sempre acompanhe o incremento. Se o valor devolvido pelo INCR passar de 10, recuse a requisição. As chaves antigas somem sozinhas. Como o contador vale mais que o cache em si, mas pode ser perdido sem dano grave, ele cabe bem no perfil Cache; se perder os contadores em um reinício for inaceitável, use Chave‑Valor.

Para fila de jobs, a recomendação da documentação é Streams com consumer groups no perfil Filas: o produtor adiciona a tarefa com XADD, o grupo é criado uma vez com XGROUP CREATE ... MKSTREAM, o worker lê mensagens novas com XREADGROUP, processa e só então confirma com XACK. Um processo separado inspeciona XPENDING e usa XAUTOCLAIM para assumir mensagens de consumidores que pararam, e o stream é limitado com MAXLEN aproximado ou XTRIM. A entrega é at-least-once, então o processamento precisa ser idempotente: a mesma tarefa pode chegar duas vezes depois de um timeout ou de uma recuperação.

Pub/Sub funciona no serviço, mas não guarda mensagens: se o consumidor estiver desconectado, o evento se perde. Use para presença, invalidação ao vivo e notificações descartáveis. Lists com BLPOP removem o item antes do processamento; quando a perda importa, prefira BLMOVE ou Streams. Se você precisa de exchanges, routing keys ou dead-letter nativa, o motor RabbitMQ das Filas resolve isso sem estratégia própria.

text
MULTI
INCR rl:203.0.113.7:1793966400
EXPIRE rl:203.0.113.7:1793966400 10
EXEC
# se o resultado do INCR for maior que 10, responda 429
python
import os
import uuid
from urllib.parse import urlparse
from valkey import Valkey
from valkey.exceptions import ResponseError

def process_email(fields):
    print("process message", fields)

url = urlparse(os.environ["VALKEY_URL"])
client = Valkey(
    host=url.hostname, port=url.port, username=url.username, password=url.password,
    ssl=True, ssl_check_hostname=True, decode_responses=True,
)
stream = "jobs:emails"
group = "email-workers"
consumer = f"worker-{uuid.uuid4()}"

try:
    client.xgroup_create(stream, group, id="$", mkstream=True)
except ResponseError as error:
    if "BUSYGROUP" not in str(error):
        raise

client.xadd(stream, {"type": "welcome", "user_id": "42"}, maxlen=10000, approximate=True)
for _, messages in client.xreadgroup(group, consumer, {stream: ">"}, count=10, block=5000):
    for message_id, fields in messages:
        process_email(fields)
        client.xack(stream, group, message_id)

client.xtrim(stream, maxlen=10000, approximate=True)
client.close()

Latência: o que muda com o serviço no Brasil

Cache e filas são acessados muitas vezes por requisição, então a distância entre a aplicação e o serviço conta mais aqui do que em quase qualquer outro componente. Cada comando é uma ida e volta pela rede: se a página faz cinco leituras de cache em sequência, o tempo de rede aparece cinco vezes. Quando a aplicação está no Brasil e o Redis está em outro continente, cada ida e volta atravessa o oceano, e o cache que deveria acelerar a resposta pode passar a ser a parte mais lenta dela.

A regra prática é colocar o Valkey na mesma região da aplicação que o usa. Se a aplicação roda na Zenifra, o Valkey fica na mesma infraestrutura em São Paulo, e você pode desligar o acesso público para que a conexão passe só pela rede privada, no endereço interno do projeto. Se a aplicação roda na AWS em São Paulo, o ElastiCache sa-east-1 cumpre o mesmo papel. Se a aplicação está em Oregon ou Frankfurt, um Redis em São Paulo não ajuda: o que importa é a proximidade com a aplicação, não com o usuário final.

Não publicamos um número de latência aqui porque ele depende de onde a sua aplicação está, do cliente, do tamanho dos valores e do uso de pipeline. Meça no seu cenário: o valkey-cli tem a opção --latency, que mede continuamente o tempo de resposta do servidor a partir da máquina onde ele roda. Rode a medição de dentro do ambiente da aplicação, não do seu notebook, e compare com o tempo total das suas requisições. Para reduzir idas e voltas, agrupe comandos com pipeline, MGET ou MSET.

O Valkey é compatível com clientes Redis?

Sim. O Valkey fala o protocolo do Redis, e a documentação da Zenifra lista clientes compatíveis em oito linguagens, entre eles a gem redis (Ruby), a crate redis (Rust), phpredis e Predis (PHP), além dos clientes do próprio projeto, como iovalkey, valkey-py, valkey-go e valkey-java.

O único ajuste comum é o esquema da URL: a conexão da Zenifra usa valkeys://, e bibliotecas que só aceitam redis:// ou rediss:// funcionam trocando o esquema por rediss://. O TLS continua obrigatório e a validação do certificado não deve ser desligada.

Existe Redis ou Valkey gerenciado grátis no Brasil?

Entre os provedores com região em São Paulo, o Upstash tem plano grátis com 250 MB de dados e 500 mil comandos por mês, e a conta gratuita pode ter 1 banco.

Na Zenifra, o Valkey Cache começa no cache-starter, a R$ 34,90 por mês ou R$ 0,06 por hora, e o Valkey Queue no queue-starter, a R$ 44,90 por mês ou R$ 0,08 por hora. Para testes curtos, a cobrança por hora é o caminho mais barato, e o projeto parado não gera cobrança de processamento. O cadastro pede CPF ou CNPJ, celular e endereço no Brasil.

O Cache da Zenifra guarda os dados se o serviço reiniciar?

Não. O perfil Cache guarda dados só em memória, em todos os planos, sem armazenamento persistente, sem réplicas e sem backup: um reinício pode esvaziar o cache, e quando a memória acaba as chaves menos usadas são removidas.

Para dados que precisam sobreviver, use o perfil Chave‑Valor (AOF em disco, backup automático e alta disponibilidade a partir do db-basic) ou o perfil Filas para tarefas. O plano de um Cache não pode ser trocado depois da criação; para mudar, crie um novo Cache.

Posso pagar Valkey gerenciado com PIX ou boleto?

Sim. Na Zenifra, o Valkey é cobrado do crédito da organização, que você coloca por PIX a partir de R$ 5 ou boleto a partir de R$ 30; o cartão pode ficar cadastrado como reserva para quando faltar crédito.

Como o preço já é em real, não há IOF de compra internacional nem variação cambial na cobrança. Upstash, Redis Cloud, Render e Railway cobram em dólar. A AWS fatura clientes no Brasil em real pela AWS SBL, com preços definidos em dólar e convertidos no dia da fatura.

Quando Upstash, ElastiCache ou Render fazem mais sentido?

Quando a sua aplicação já está nesses provedores ou o seu padrão de uso combina com o modelo de cobrança deles. Um cache com pouco tráfego pode sair mais barato no Pay as You Go do Upstash, a US$ 0,20 por 100 mil comandos; uma aplicação na AWS em São Paulo ganha ao usar o ElastiCache na mesma rede; um serviço no Render fala com o Key Value do Render pela rede privada da plataforma.

A Zenifra faz mais sentido quando você quer preço fixo em real, pagamento por PIX ou boleto, cobrança por hora para testar, fila com Streams ou RabbitMQ no mesmo Console e a aplicação rodando no Brasil ao lado do serviço.

Criar um Valkey Cache no Console

Respeitamos sua privacidade

Usamos cookies essenciais para o funcionamento do site. Cookies de medição e marketing, como Google Ads, só serão ativados se você aceitar todos. Consulte nossa política de cookies.