---
title: "Como instalar e configurar Redis na VPS Ubuntu"
description: "Instale o Redis na VPS Ubuntu com senha ou ACL, acesso só local, limite de RAM, persistência RDB e AOF, e use como cache, fila e sessão da aplicação."
url: "https://streethosting.com.br/guias/vps/configurar-redis-vps-ubuntu"
category: "vps"
slug: "configurar-redis-vps-ubuntu"
datePublished: "2026-06-18"
dateModified: "2026-09-28"
author: "Equipe StreetHosting"
difficulty: "intermediario"
language: "pt-BR"
keywords:
  - "configurar redis vps ubuntu"
  - "instalar redis ubuntu servidor"
  - "redis cache vps linux"
  - "redis nodejs python ubuntu"
  - "instalar redis vps"
  - "redis acl requirepass"
  - "redis rdb aof persistencia"
---

# Redis na VPS Ubuntu: senha, memória, persistência e uso pela aplicação

Redis é um banco de dados em memória usado como cache, fila e armazenamento de sessões. Veja como instalar no Ubuntu, proteger com senha ou ACL, limitar a RAM com a política certa, escolher entre RDB e AOF e conectar a aplicação.

> **Resposta rápida**
>
> Instale com `sudo apt install redis-server`, mantenha o *bind* em `127.0.0.1` com `protected-mode` ligado e exija senha com `requirepass` ou ACL. Defina `maxmemory` com a política certa para o uso, ligue o AOF se o Redis guardar fila ou sessão e nunca exponha a porta 6379 na internet.

## O que é Redis

Redis é um banco de dados em memória, que guarda chaves e valores na RAM e responde em frações de milissegundo. Na prática, ele aparece em quatro papéis:

- **Cache:** guarda o resultado de consultas pesadas para não bater no banco principal toda vez.
- **Filas:** organiza tarefas em segundo plano, como envio de email e processamento de imagem, com bibliotecas como BullMQ, Sidekiq e Celery.
- **Sessões:** guarda o login dos usuários fora do processo da aplicação, o que permite reiniciar ou ter várias instâncias sem derrubar ninguém.
- **Tempo real:** rankings com sorted sets, contadores, limite de requisições e mensagens com Pub/Sub.

A distinção importa porque cada papel pede uma configuração diferente. Cache pode perder dados e descartar chaves quando a memória enche. Fila e sessão não podem, e essa é a origem da maioria dos problemas com Redis em produção.

## Instalar o Redis

1. Atualize os repositórios: `sudo apt update`
2. Instale o Redis: `sudo apt install -y redis-server`
3. Confirme que o serviço está ativo: `sudo systemctl status redis-server`
4. Teste a conexão: `redis-cli ping`, que deve responder PONG

O Ubuntu 24.04 instala o Redis 7.0 e o 22.04 instala o 6.0. O serviço já sobe no boot, a configuração fica em `/etc/redis/redis.conf` e os dados em */var/lib/redis*. Para uma versão mais nova, o projeto mantém um repositório apt próprio, com instruções na documentação oficial do Redis.

> **Dica**
>
> Se preferir Docker, publique a porta só no loopback: `-p 127.0.0.1:6379:6379`. Um simples *-p 6379:6379* expõe o Redis na internet, e o Docker cria regras próprias que passam por cima do UFW.

## Configurar segurança

Abra o arquivo com `sudo nano /etc/redis/redis.conf` e confira duas linhas que já vêm certas no Ubuntu:

```
bind 127.0.0.1 -::1
protected-mode yes
```

O *bind* define em quais endereços da VPS o Redis escuta; com loopback, nada de fora alcança a porta. O sinal antes do *::1* marca o IPv6 como opcional, e em versões antigas a linha aparece sem ele. O `protected-mode` é uma rede de segurança: enquanto o usuário padrão estiver sem senha, o Redis só aceita conexões locais. Mesmo assim, configure autenticação, porque qualquer processo da VPS alcança o loopback.

### Opção A: senha única com requirepass

Gere uma senha longa com `openssl rand -hex 32` e acrescente no redis.conf:

```
requirepass COLE_A_SENHA_GERADA

sudo systemctl restart redis-server
redis-cli --askpass ping
```

O Redis testa senhas muito rápido, então senha curta cai em ataque de força bruta. A de 64 caracteres hexadecimais resolve e não tem símbolos que atrapalhem na URL de conexão. O *--askpass* pede a senha sem gravar nada no histórico do shell.

### Opção B: usuários com ACL

Com ACL, cada aplicação ganha seu usuário, e dá para tirar dela comandos que nenhuma aplicação precisa. Não use junto com o requirepass; escolha um dos dois.

```
# /etc/redis/redis.conf
user default off
user admin on >SENHA_DO_ADMIN ~* &* +@all
user app on >SENHA_DA_APP ~* &* +@all -@admin -flushall -flushdb

sudo systemctl restart redis-server
redis-cli --user app --askpass ping
```

O *~** libera todas as chaves e o *&** todos os canais de Pub/Sub. O usuário *app* perde a categoria *@admin*, que inclui CONFIG, SHUTDOWN e MONITOR, e os comandos que apagam o banco inteiro. Se a aplicação tentar um deles, recebe o erro *NOPERM*. No Redis 6.0 do Ubuntu 22.04, retire o *&**, que só existe a partir do 6.2.

> **Atenção**
>
> Robôs varrem a internet atrás da porta 6379. Um Redis aberto e sem senha costuma ser usado para gravar uma chave SSH do atacante ou instalar um minerador de criptomoeda, justamente pelo comando CONFIG. Se outro servidor precisar do Redis, ligue o *bind* ao endereço de uma [VPN WireGuard](https://streethosting.com.br/guias/vps/proteger-vps-wireguard-vpn) e libere a porta só para o IP interno, com as regras do [guia de UFW](https://streethosting.com.br/guias/vps/firewall-ufw-vps-ubuntu).

## Limitar uso de RAM

Sem limite, o Redis cresce até a RAM acabar e o kernel matar algum processo, às vezes o próprio Redis, às vezes o banco principal. Defina o teto no redis.conf:

```
maxmemory 1gb
maxmemory-policy allkeys-lru
```

Deixe folga além do *maxmemory*. Para gravar o snapshot, o Redis cria um processo filho, e cada página de memória alterada durante a gravação é duplicada; com muita escrita, o consumo pode se aproximar do dobro. Pelo mesmo motivo, o log do Redis avisa quando o overcommit de memória do kernel está desligado. Corrija assim:

```
echo "vm.overcommit_memory = 1" | sudo tee /etc/sysctl.d/90-redis.conf
sudo sysctl --system
```

A política define o que acontece quando o limite é atingido:

- `noeviction`: o padrão. Não apaga nada e recusa novas escritas. É a única correta para filas e sessões; o BullMQ e o Sidekiq pedem essa política.
- `allkeys-lru`: descarta as chaves usadas há mais tempo. A escolha padrão para cache.
- `allkeys-lfu`: descarta as menos acessadas. Melhor quando poucas chaves concentram a maior parte das leituras.
- `volatile-lru`: só descarta chaves com prazo de expiração, preservando as demais.
- `volatile-ttl`: descarta primeiro as chaves que já iam expirar logo.

Com *noeviction* e memória cheia, a aplicação recebe `OOM command not allowed when used memory > 'maxmemory'`. Os bancos numerados de 0 a 15 dividem a mesma memória e a mesma política, então não separam cache de fila. Se você precisa dos dois com volume, rode duas instâncias, por exemplo uma segunda em Docker na porta 6380: uma com `allkeys-lru` para cache e outra com *noeviction* para fila e sessão.

## Persistência: RDB e AOF

Redis em memória não significa dado volátil. Há dois mecanismos para gravar em disco, e eles podem trabalhar juntos:

| Modo | Como ligar | Perda máxima em uma queda | Quando usar |
| --- | --- | --- | --- |
| Só RDB, o padrão | save 3600 1 300 100 60 10000 | Tudo desde o último snapshot, de segundos a uma hora | Cache que a aplicação consegue recriar |
| AOF com everysec | appendonly yes e appendfsync everysec | Cerca de um segundo de escritas | Filas, sessões e dados que importam |
| RDB e AOF juntos | Os dois ligados | Cerca de um segundo, com snapshot compacto para cópia | Redis que guarda dado de verdade |
| Sem persistência | save vazio e appendonly no | Tudo, a cada reinício | Cache puro, pelo menor custo de disco |

O RDB é uma fotografia completa gravada em *dump.rdb*; a regra padrão do Redis 7 grava depois de uma hora com uma alteração, cinco minutos com 100 ou um minuto com 10 mil. O AOF anota cada escrita e, com *everysec*, sincroniza o arquivo com o disco uma vez por segundo, o equilíbrio recomendado entre segurança e desempenho.

Para ligar o AOF em um Redis que já tem dados, faça em tempo de execução, como recomenda a documentação oficial, e só depois grave no arquivo. Editar o redis.conf e reiniciar pode, dependendo da versão, subir o Redis a partir de um AOF vazio:

```
redis-cli --user admin --askpass
CONFIG SET appendonly yes
INFO persistence
CONFIG REWRITE
```

Espere o *aof_rewrite_in_progress* voltar a 0 no *INFO persistence* antes do *CONFIG REWRITE*, que grava a mudança no redis.conf. Com requirepass, conecte sem o *--user admin*. Persistência não é backup: copie o *dump.rdb* para fora da VPS com regularidade, junto com os backups do resto do servidor.

## Conectar com a aplicação

Quase todos os clientes aceitam uma URL de conexão. Com requirepass, o usuário fica vazio; com ACL, vai o nome do usuário. O número no fim é o banco:

```
REDIS_URL=redis://:SENHA@127.0.0.1:6379/0        # requirepass
REDIS_URL=redis://app:SENHA@127.0.0.1:6379/0     # ACL
```

O uso mais comum como cache consulta o Redis primeiro, vai ao banco só quando a chave não existe e guarda o resultado com prazo de validade. Em Node.js com ioredis:

```
const Redis = require("ioredis");
const redis = new Redis(process.env.REDIS_URL);

async function buscarProduto(id) {
  const chave = "produto:" + id;
  const emCache = await redis.get(chave);
  if (emCache) return JSON.parse(emCache);

  const produto = await db.produtos.buscarPorId(id);
  await redis.set(chave, JSON.stringify(produto), "EX", 300);
  return produto;
}
```

O *EX 300* expira a chave em cinco minutos, e isso limita o tempo em que um dado desatualizado pode aparecer. Quando o produto mudar, apague a chave com *redis.del* para a próxima leitura buscar o valor novo.

- **Filas:** no BullMQ, a conexão do worker precisa de `maxRetriesPerRequest: null` no ioredis. No Celery, aponte *broker_url* para a URL; no Sidekiq, defina *REDIS_URL*. Os três pedem *noeviction*.
- **Laravel:** no *.env*, preencha *REDIS_HOST* e *REDIS_PASSWORD* e use `CACHE_STORE=redis`, `SESSION_DRIVER=redis` e `QUEUE_CONNECTION=redis`. Antes do Laravel 11, a variável de cache se chamava *CACHE_DRIVER*.
- **Sessões em Node.js e Python:** no Express, o pacote `connect-redis`; no Django, o backend *RedisCache* com `SESSION_ENGINE = "django.contrib.sessions.backends.cache"`.

O passo a passo de colocar a aplicação no ar, com Nginx e systemd, está no guia de [API Node.js na VPS](https://streethosting.com.br/guias/vps/hospedar-api-nodejs-vps-brasil). Se o Redis faz cache de consultas de um [PostgreSQL na mesma VPS](https://streethosting.com.br/guias/vps/instalar-postgresql-vps-ubuntu), some a RAM dos dois ao dimensionar.

## Monitorar o Redis

Conecte com `redis-cli --user admin --askpass` e use estes comandos:

- `INFO memory`: compare *used_memory_human* com *maxmemory_human* e observe o *mem_fragmentation_ratio*.
- `INFO stats`: *keyspace_hits* e *keyspace_misses* mostram se o cache acerta; *evicted_keys* subindo indica memória curta.
- `INFO persistence`: *rdb_last_bgsave_status* e *aof_last_write_status* precisam estar em ok.
- `SLOWLOG GET 10`: os comandos mais lentos recentes. Como o Redis executa um comando por vez, um comando lento atrasa todos os outros.
- `redis-cli --latency` e `redis-cli --bigkeys`: medem a latência e acham as chaves que mais ocupam memória.

Dois cuidados. Nunca rode *KEYS* em produção, porque ele varre tudo e trava o servidor; use `SCAN 0 MATCH sessao:* COUNT 100`. E use o *MONITOR* só por alguns segundos, porque ele derruba o desempenho enquanto estiver ligado. Para acompanhar CPU e RAM da VPS inteira, veja o guia de [monitoramento com htop e Netdata](https://streethosting.com.br/guias/vps/monitorar-recursos-vps-htop-netdata).

## Qual VPS usar para Redis

Na maioria dos projetos, o Redis roda na mesma VPS da aplicação, e o que ele consome é RAM. Por isso a [VPS Xeon](https://streethosting.com.br/vps/xeon), com mais memória por real, é o ponto de partida: 4 GB com 3 vCPU e 40 GB de NVMe por R$ 43,00, 8 GB com 6 vCPU por R$ 77,00 e 16 GB com 9 vCPU por R$ 145,00. Como o Redis executa os comandos em uma única thread, volumes muito altos de operações rendem mais com clock alto, e aí a VPS Ryzen 9 9950X, com até 5,7 GHz e DDR5, começa em R$ 126,00 com 4 vCPU e 8 GB.

Todas as [VPS da StreetHosting](https://streethosting.com.br/vps) ficam em São Paulo, com NVMe, AntiDDoS e acesso root. Se a memória ficar curta, o upgrade pelo painel cobra só a diferença proporcional e reinicia a VM; depois dele, aumente o *maxmemory* à mão. Para dimensionar a VPS inteira com aplicação, banco e Redis, veja [como escolher uma VPS para API](https://streethosting.com.br/guias/vps/escolher-vps-para-api).

## Perguntas frequentes

### Redis é banco de dados ou cache?

Os dois. O Redis é um banco de dados em memória que pode servir como cache, fila de tarefas, armazenamento de sessões, ranking e sistema de mensagens. A configuração muda conforme o uso: cache aceita perder dados e descartar chaves, fila e sessão não.

### O Redis perde dados quando o servidor reinicia?

Com a configuração padrão, o Redis grava snapshots RDB periódicos e perde o que mudou desde o último. Ligando o AOF com appendfsync everysec, a perda máxima cai para cerca de um segundo. Para cache puro, dá para desligar a persistência.

### Devo expor o Redis para a internet?

Não. O tráfego do Redis não é cifrado por padrão e a porta 6379 é varrida por robôs o tempo todo. Mantenha o bind em 127.0.0.1 e, se outro servidor precisar acessar, use uma VPN como WireGuard e libere a porta no firewall só para o IP interno.

### Quanto de RAM o Redis usa?

O Redis usa a RAM que os dados ocupam, sem limite, até você definir maxmemory. Configure o limite deixando folga para o sistema e para o snapshot, e escolha a política de descarte: uma do tipo LRU para cache e noeviction para filas e sessões.

### Devo usar requirepass ou ACL no Redis?

Para uma aplicação só, requirepass com uma senha longa resolve. Com mais de uma aplicação ou quando você quer impedir comandos perigosos como FLUSHALL e CONFIG no usuário da aplicação, use ACL com um usuário por aplicação e desative o usuário padrão.

## Guias relacionados

- [Como instalar PostgreSQL na VPS Ubuntu com segurança](https://streethosting.com.br/guias/vps/instalar-postgresql-vps-ubuntu.md)
- [Como hospedar aplicação Node.js em VPS no Brasil](https://streethosting.com.br/guias/vps/hospedar-api-nodejs-vps-brasil.md)
- [UFW na VPS Ubuntu: regras de firewall sem perder o SSH](https://streethosting.com.br/guias/vps/firewall-ufw-vps-ubuntu.md)
- [Como escolher VPS para API: CPU, RAM e conexões](https://streethosting.com.br/guias/vps/escolher-vps-para-api.md)
- [Como criar uma VPN com WireGuard na VPS para acesso privado](https://streethosting.com.br/guias/vps/proteger-vps-wireguard-vpn.md)

## Produtos citados

- https://streethosting.com.br/vps/xeon
- https://streethosting.com.br/vps
- https://streethosting.com.br/vps/ryzen

## Dados estruturados

```json
[
  {
    "@context": "https://schema.org",
    "@type": [
      "Article",
      "TechArticle"
    ],
    "headline": "Redis na VPS Ubuntu: senha, memória, persistência e uso pela aplicação",
    "name": "Como instalar e configurar Redis na VPS Ubuntu",
    "abstract": "Redis é um banco de dados em memória usado como cache, fila e armazenamento de sessões. Veja como instalar no Ubuntu, proteger com senha ou ACL, limitar a RAM com a política certa, escolher entre RDB e AOF e conectar a aplicação.",
    "description": "Instale o Redis na VPS Ubuntu com senha ou ACL, acesso só local, limite de RAM, persistência RDB e AOF, e use como cache, fila e sessão da aplicação.",
    "datePublished": "2026-06-18",
    "dateModified": "2026-09-28",
    "author": {
      "@type": "Organization",
      "name": "Equipe StreetHosting"
    },
    "publisher": {
      "@type": "Organization",
      "name": "StreetHosting",
      "url": "https://streethosting.com.br"
    },
    "inLanguage": "pt-BR",
    "mainEntityOfPage": {
      "@type": "WebPage",
      "@id": "https://streethosting.com.br/guias/vps/configurar-redis-vps-ubuntu"
    }
  },
  {
    "@context": "https://schema.org",
    "@type": "FAQPage",
    "mainEntity": [
      {
        "@type": "Question",
        "name": "Redis é banco de dados ou cache?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "Os dois. O Redis é um banco de dados em memória que pode servir como cache, fila de tarefas, armazenamento de sessões, ranking e sistema de mensagens. A configuração muda conforme o uso: cache aceita perder dados e descartar chaves, fila e sessão não."
        }
      },
      {
        "@type": "Question",
        "name": "O Redis perde dados quando o servidor reinicia?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "Com a configuração padrão, o Redis grava snapshots RDB periódicos e perde o que mudou desde o último. Ligando o AOF com appendfsync everysec, a perda máxima cai para cerca de um segundo. Para cache puro, dá para desligar a persistência."
        }
      },
      {
        "@type": "Question",
        "name": "Devo expor o Redis para a internet?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "Não. O tráfego do Redis não é cifrado por padrão e a porta 6379 é varrida por robôs o tempo todo. Mantenha o bind em 127.0.0.1 e, se outro servidor precisar acessar, use uma VPN como WireGuard e libere a porta no firewall só para o IP interno."
        }
      },
      {
        "@type": "Question",
        "name": "Quanto de RAM o Redis usa?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "O Redis usa a RAM que os dados ocupam, sem limite, até você definir maxmemory. Configure o limite deixando folga para o sistema e para o snapshot, e escolha a política de descarte: uma do tipo LRU para cache e noeviction para filas e sessões."
        }
      },
      {
        "@type": "Question",
        "name": "Devo usar requirepass ou ACL no Redis?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "Para uma aplicação só, requirepass com uma senha longa resolve. Com mais de uma aplicação ou quando você quer impedir comandos perigosos como FLUSHALL e CONFIG no usuário da aplicação, use ACL com um usuário por aplicação e desative o usuário padrão."
        }
      }
    ]
  }
]
```