Por que Fastify?
Fastify é um framework web moderno para Node.js que se destaca pela sua velocidade e eficiência. Diferentemente do Express, que é mais minimalista e flexível, Fastify foi construído com performance como prioridade desde o início, oferecendo suporte nativo a HTTP/2, validação de schema e logging estruturado. Se você trabalha com APIs de alta concorrência ou microsserviços, Fastify reduz latência e aumenta throughput significativamente.
A curva de aprendizado é suave porque a API é intuitiva. Em poucos minutos você consegue subir um servidor robusto. O framework também escala bem com a complexidade do projeto, desde uma simples API REST até sistemas complexos com middleware, plugins e validação rigorosa.
Instalação e Configuração Inicial
Comece instalando o Fastify e suas dependências essenciais:
npm install fastify
npm install --save-dev nodemon
Crie um arquivo server.js:
import Fastify from 'fastify';
const fastify = Fastify({
logger: true
});
fastify.get('/', async (request, reply) => {
return { message: 'Olá, Fastify!' };
});
const start = async () => {
try {
await fastify.listen({ port: 3000 });
console.log('Servidor rodando em http://localhost:3000');
} catch (err) {
fastify.log.error(err);
process.exit(1);
}
};
start();
Execute com node server.js. O logger: true ativa logs automáticos de todas as requisições, mostrando dados brutos e tempos de resposta. Use nodemon em desenvolvimento adicionando "dev": "nodemon server.js" ao package.json.
Plugins e Estrutura Modular
Fastify funciona com plugins, permitindo código modular e reutilizável. Um plugin é basicamente uma função assíncrona que recebe a instância do Fastify:
async function rotasUsuarios(fastify) {
fastify.get('/usuarios', async (request, reply) => {
return [{ id: 1, nome: 'João' }];
});
fastify.post('/usuarios', async (request, reply) => {
return { id: 2, nome: request.body.nome };
});
}
fastify.register(rotasUsuarios, { prefix: '/api' });
Agora suas rotas estão em /api/usuarios. Organize plugins em arquivos separados conforme a aplicação cresce. Isso mantém o código limpo e testável.
Validação com JSON Schema
Fundamentos do JSON Schema
JSON Schema é um padrão para descrever a estrutura e validar dados JSON. Fastify integra validação de schema automaticamente através da biblioteca ajv. Você define schemas e o Fastify valida requisições antes de chegar à sua rota.
const schemaUsuario = {
type: 'object',
required: ['nome', 'email'],
properties: {
nome: { type: 'string', minLength: 3 },
email: { type: 'string', format: 'email' },
idade: { type: 'integer', minimum: 0, maximum: 150 }
}
};
fastify.post('/usuarios', {
schema: {
body: schemaUsuario,
response: {
200: {
type: 'object',
properties: {
id: { type: 'number' },
nome: { type: 'string' }
}
}
}
}
}, async (request, reply) => {
const { nome, email } = request.body;
return { id: 1, nome };
});
Envie um POST com JSON inválido (sem nome ou com email malformado) e receberá um erro 400 automático com detalhes do que faltou. Isso economiza linhas de código e centraliza a validação.
Schema para Query Parameters e Path Parameters
A validação não é apenas para o corpo da requisição:
const schemaBusca = {
type: 'object',
properties: {
pagina: { type: 'integer', minimum: 1 },
limite: { type: 'integer', minimum: 1, maximum: 100 }
}
};
const schemaId = {
type: 'object',
required: ['id'],
properties: {
id: { type: 'string' }
}
};
fastify.get('/usuarios/:id', {
schema: {
params: schemaId,
querystring: schemaBusca
}
}, async (request, reply) => {
const { id } = request.params;
const { pagina = 1, limite = 10 } = request.query;
return { id, pagina, limite };
});
Validação de params protege contra IDs malformados. Validação de querystring garante que paginação tenha valores sensatos. Tudo automático e sem ifs aninhados.
Performance na Prática
Benchmarks Reais
Fastify historicamente processa 2-3x mais requisições por segundo que Express em benchmarks como TechEmpower. Isso vem de várias otimizações: parsing eficiente, roteamento otimizado via find-my-way e validação lazy (aplica schema apenas quando necessário).
Para medir sua aplicação, use ferramentas como autocannon:
npm install -g autocannon
autocannon http://localhost:3000 -c 100 -d 30
Isto executa 100 conexões simultâneas por 30 segundos. Você verá requisições por segundo, latência e throughput. Mesmo uma API simples em Fastify bate Express em até 40% de diferença.
Compressão e Caching
Ative compressão automática com um plugin:
import compress from '@fastify/compress';
await fastify.register(compress);
Respostas serão comprimidas com gzip automaticamente. Para cache, use headers HTTP:
fastify.get('/dados-estaticos', async (request, reply) => {
reply.header('Cache-Control', 'public, max-age=3600');
return { data: 'valor' };
});
Browsers e proxies respectarão o header, reduzindo requisições ao servidor. Combine compressão, validação eficiente e headers apropriados e você tem uma API de alta performance.
Conclusão
Fastify oferece três vantagens decisivas: performance nativa através de arquitetura otimizada, validação robusta com JSON Schema integrado eliminando validação manual, e escalabilidade via plugins mantendo código limpo mesmo em projetos complexos. Se você trabalha com APIs críticas onde latência importa, ou simplesmente quer melhores práticas desde o início, Fastify é a escolha certa. O investimento em aprender JSON Schema como forma de contrato é tempo bem gasto que se repete em todo projeto futuro.