Redis
O AdonisJS tem seu próprio pacote first party para trabalhar com bancos de dados Redis. Ele usa internamente ioredis, mas melhora a camada pub/sub e fornece suporte de primeira classe para gerenciamento de conexões e verificações de integridade.
O primeiro passo é instalar e configurar o pacote usando as seguintes instruções.
npm i @adonisjs/redis@7.3.4
node ace configure @adonisjs/redis
# CREATE: config/redis.ts
# CREATE: contracts/redis.ts
# UPDATE: .env
# UPDATE: tsconfig.json { types += "@adonisjs/redis" }
# UPDATE: .adonisrc.json { providers += "@adonisjs/redis" }
/**
* Certifique-se de adicionar as seguintes regras de validação ao arquivo
* `env.ts` para validar as variáveis de ambiente.
*/
export default Env.rules({
// ...regras existentes
REDIS_CONNECTION: Env.schema.enum(['local'] as const),
REDIS_HOST: Env.schema.string({ format: 'host' }),
REDIS_PORT: Env.schema.number(),
REDIS_PASSWORD: Env.schema.string.optional(),
})
- Suporte melhorado para pub/sub
- Gerenciamento de múltiplas conexões sem padrão
- Verificações de integridade integradas
Configuração
A configuração do redis é armazenada dentro do arquivo config/redis.ts
. Você pode definir uma ou mais conexões nomeadas dentro deste arquivo e seu ciclo de vida será gerenciado automaticamente para você.
import { redisConfig } from '@adonisjs/redis/build/config'
export default redisConfig({
connection: Env.get('REDIS_CONNECTION'),
connections: {
local: {
host: Env.get('REDIS_HOST'),
port: Env.get('REDIS_PORT'),
password: Env.get('REDIS_PASSWORD', ''),
db: 0,
keyPrefix: '',
},
},
})
connection
Conexão padrão a ser usada para fazer todas as consultas do redis. O valor da conexão é inferido da variável de ambiente REDIS_CONNECTION
.
connections
Uma lista de conexões disponíveis que você planeja usar em seu aplicativo. Sinta-se à vontade para adicionar/remover conexões deste objeto.
Uso
Depois que a configuração for concluída, você pode importar o módulo e executar comandos redis. Todos os métodos de ioredis são suportados como estão pelo módulo redis do AdonisJS.
import Redis from '@ioc:Adonis/Addons/Redis'
await Redis.set('foo', 'bar')
const value = await Redis.get('foo')
Você pode alternar entre conexões usando o método Redis.connection
. Criamos/gerenciamos instâncias singleton para cada conexão e as usamos durante todo o ciclo de vida do aplicativo.
import Redis from '@ioc:Adonis/Addons/Redis'
await Redis
.connection('session') // 👈 Troca de conexão
.set('foo', 'bar')
Pub/Sub
O Redis força você a manter duas conexões separadas ao usar pub/sub
, onde o assinante usa uma conexão dedicada apenas ouvindo novas mensagens.
No AdonisJS, melhoramos a API do pub/sub e gerenciamos a conexão do assinante internamente para você, para que você não precise criá-la e gerenciá-la manualmente.
Para demonstração, vamos criar um canal pub/sub para rastrear inscrições de usuários. Comece criando um novo arquivo de pré-carregamento executando o seguinte comando Ace.
node ace make:prldfile redis
# ✔ create start/redis.ts
Abra o arquivo recém-criado e cole o seguinte trecho de código dentro dele.
// start/redis.ts
import Redis from '@ioc:Adonis/Addons/Redis'
Redis.subscribe('user:signup', (user: string) => {
console.log(JSON.parse(user))
})
Em seguida, crie uma rota fictícia para publicar no canal user:signup
em cada nova solicitação HTTP.
// start/routes.ts
import Route from '@ioc:Adonis/Core/Route'
import Redis from '@ioc:Adonis/Addons/Redis'
Route.get('/signup', async () => {
await Redis.publish('user:signup', JSON.stringify({ id: 1 }))
return 'handled'
})
- O método
Redis.subscribe
escuta mensagens em um determinado canal. - O método
Redis.publish
é usado para publicar eventos em um determinado canal. - As mensagens são passadas como string, já que o Redis não suporta outros tipos de dados durante o Pub/sub.
Padrão pub/sub
O Redis também suporta pub/sub usando padrões. Em vez de subscribe
, você tem que usar o método psubscribe
.
Redis.psubscribe('user:*', (event: string, user: string) => {
console.log(event, JSON.stringify(user))
})
Verificações de integridade
O módulo Redis usa o módulo AdonisJS health check para relatar a integridade das conexões. Tudo o que você precisa fazer é habilitá-lo dentro do arquivo de configuração.
// config/redis.ts
{
local: {
host: Env.get('REDIS_HOST', '127.0.0.1') as string,
port: Env.get('REDIS_PORT', '6379') as string,
password: Env.get('REDIS_PASSWORD', '') as string,
db: 0,
keyPrefix: '',
healthCheck: true, // 👈 verificação de saúde
},
}
Agora, você pode usar o módulo health check para visualizar o status das suas conexões redis.
import Route from '@ioc:Adonis/Core/Route'
import HealthCheck from '@ioc:Adonis/Core/HealthCheck'
Route.get('health', async ({ response }) => {
const report = await HealthCheck.getReport()
return report.healthy
? response.ok(report)
: response.badRequest(report)
})
Fechando conexões
Você pode fechar as conexões redis usando um dos seguintes métodos.
quit
O método quit
fecha a conexão redis normalmente. Este método aguardará que todos os comandos enfileirados terminem.
await Redis.quit()
await Redis.connection('name').quit()
disconnect
O método disconnect
não aguarda que os comandos existentes terminem e interromperá a conexão imediatamente.
await Redis.disconnect()
await Redis.connection('name').disconnect()
quitAll
Semelhante a quit
, mas encerra todas as conexões
await Redis.quitAll()
disconnectAll
Semelhante a disconnect
, mas desconecta todas as conexões.
await Redis.disconnectAll()