Guia do Fastify: Visão geral, exemplos e alternativas

À medida que suas aplicações frontend recebem uma demanda crescente, elas precisam de backends rápidos e responsivos para oferecer a melhor experiência ao usuário. Você precisará de um framework que funcione bem com as ferramentas e frameworks frontend que você está usando.

Existem muitos frameworks de backend disponíveis para as várias linguagens de programação do lado do servidor. Se você está pensando em usar JavaScript, especialmente no frontend da sua aplicação, pode considerar usar o Fastify.

Neste guia de adoção, discutiremos algumas das razões pelas quais você deve (ou não) escolher o Fastify, as principais funcionalidades que você deve conhecer e muito mais. Também vamos comparar o Fastify com algumas alternativas populares para ajudá-lo a tomar uma decisão informada para o seu projeto.

O que é Fastify?

Fastify é um framework de Node.js de alto desempenho e código aberto para construir aplicações web eficientes e rápidas. Sua arquitetura modular é baseada em um sistema de plugins rico e fácil de integrar.

O Fastify também é compatível com frameworks e bibliotecas modernas de frontend populares, como React, Vue e Angular. Ele oferece uma excelente experiência de desenvolvimento (DX) através de validação baseada em esquemas, documentação detalhada e suporte completo ao TypeScript, o que o torna uma escolha popular para desenvolvedores no ecossistema JavaScript que precisam criar serviços de backend rápidos e confiáveis.

Os contribuidores do projeto criaram o Fastify com o objetivo de desenvolver um framework que oferecesse alta taxa de transferência e baixa latência, sendo seguro e com uma pegada mínima. Desde sua criação, o Fastify passou por várias iterações que adicionaram novas funcionalidades e melhoraram seu desempenho para acompanhar as tendências no desenvolvimento de aplicativos do lado do servidor.

O Fastify utiliza plugins para expandir sua funcionalidade principal. Você constrói sua aplicação registrando plugins que fornecem funcionalidades específicas. Esses plugins podem definir rotas, gerenciar decorações do servidor ou adicionar lógica personalizada.

Por que você deve escolher o Fastify

Como de costume, existem vários fatores a serem considerados ao escolher um framework do lado do servidor para sua aplicação. Aqui está uma visão geral dos fatores que fazem do Fastify uma excelente ferramenta:

Desempenho — O Fastify é conhecido por seu alto desempenho e é capaz de lidar com milhares de solicitações por segundo. Ele também é eficiente em termos de recursos do servidor. Você deve considerar o Fastify se estiver procurando reduzir os custos de infraestrutura e melhorar a responsividade sob carga.
Segurança — O Fastify oferece suporte a esquemas JSON para validar rotas e serializar saídas, garantindo a integridade dos dados. Ele também utiliza o Pino, um logger de baixo overhead, para minimizar os custos de log.
Facilidade de uso/DX — O Fastify é bastante expressivo em comparação com outros frameworks do lado do servidor no mercado. Ele é projetado para ser expressivo para os desenvolvedores, sem comprometer o desempenho e a segurança. Além disso, o Fastify possui um design de API intuitivo e fácil de entender, permitindo que você dedique mais tempo ao que importa: construir!
Tamanho do pacote — O foco do Fastify em minimalismo e eficiência resulta em um pacote mais enxuto em comparação com outros frameworks do lado do servidor.
Comunidade e ecossistema — Graças à grande comunidade de desenvolvedores do Fastify, ele possui um sistema de plugins muito rico que cobre diversas funcionalidades, desde cache até autenticação e integração de banco de dados. Você pode adaptar esses plugins para construir aplicações que atendam às especificações do seu projeto.
Curva de aprendizado — Assim como o próprio JavaScript, o Fastify é fácil de aprender e adotar. Seu design intuitivo também facilita a adoção por desenvolvedores de outros ecossistemas.
Documentação — O Fastify é bem documentado no Fastify.dev e no GitHub. Uma comunidade ativa de desenvolvedores utiliza, apoia e mantém a base de código e a documentação do Fastify.
Integrações/plugins — Através de seu rico ecossistema de plugins, o Fastify oferece muitas integrações e suporte para múltiplas plataformas e tecnologias, incluindo Platformatic, tRPC, Clerk, WebSockets, Prisma, e mais.

Claro, o Fastify não é perfeito. Dependendo do seu caso de uso, você pode descobrir que outros frameworks são mais adequados para o seu projeto. Confira a tabela de comparação entre o Fastify e outros frameworks populares abaixo para saber mais.

Introdução ao Fastify

Aqui está um guia rápido para começar com o Fastify, incluindo instalação, criação de uma rota e criação de um servidor.

Primeiro, certifique-se de que o Node.js esteja instalado. Você pode instalar o Fastify usando npm ou Yarn:

# NPM
npm init -y
npm install fastify

# YARN
yarn init -y
yarn add fastify

Para criar um servidor com o Fastify, crie um novo arquivo chamado server.js e adicione esta importação da biblioteca Fastify:

// Importa a biblioteca Fastify
const fastify = require('fastify')({ logger: true });

Em seguida, defina uma rota simples no diretório raiz para a qual você pode enviar solicitações:

fastify.get('/', async (request, reply) => {
  return { hello: 'world' };
});

A rota retorna um JSON com {"hello":"world"} quando você visita a URL raiz com o servidor em execução localmente na porta 3000.

Aqui está uma definição de função que inicia o servidor na porta 3000 com tratamento de erros para capturar quaisquer erros enquanto o servidor estiver em execução:

// Executa o servidor
const start = async () => {
  try {
    await fastify.listen(3000);
    fastify.log.info(`Server listening on ${fastify.server.address().port}`);
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

Por fim, chame a função start no final do arquivo:

start();

Se você estiver usando Node como eu, pode executar o servidor com este comando:

node server.js

Você pode adicionar mais rotas definindo manipuladores adicionais. Aqui está um exemplo de rota POST:

// Define uma rota POST
fastify.post('/data', async (request, reply) => {
  const { name } = request.body;
  return { hello: name };
});

Para a rota POST, você está usando a função post. A rota POST retorna o corpo da solicitação com a função request.body.

Principais funcionalidades do Fastify

O Fastify é um framework de backend robusto que pode lidar com diversas demandas. Vamos explorar algumas operações importantes que você pode realizar ao adotar o Fastify como o framework de backend da sua aplicação.

Plugins do Fastify

Os plugins são a maneira de estender a funcionalidade do Fastify. Existem muitos plugins que você pode usar para o que está construindo. Explore a página do Ecosystem e confira os mais de 296 plugins disponíveis. Se não encontrar um plugin que atenda às suas necessidades, é muito fácil criar um para seu caso de uso.

Veja como é fácil e intuitivo usar plugins no Fastify:

const fastify = require('fastify')();
const cors_plugin = require('@fastify/cors');

// Exemplo: Registrando um plugin de CORS
fastify.register(cors_plugin, {
    origin: '*'
});

O plugin @fastify/cors ajuda você a usar CORS facilmente em sua aplicação Fastify. Para utilizá-los, você precisa registrar os plugins com fastify.register.

Autenticação

Você pode implementar várias formas de autenticação e autorização com o Fastify. Aqui está um exemplo de uso de um plugin JWT para autenticação com o Fastify:

const fastify = require('fastify')();
fastify.register(require('@fastify/jwt'), {
    secret: 'supersecret'
});

// Hook de autenticação JWT
fastify.addHook('onRequest', async (request, reply) => {
    try {
        await request.jwtVerify();
    } catch (err) {
        reply.send(err);
    }
});

fastify.post('/login', async (request, reply) => {
    const token = fastify.jwt.sign({ user: 'example' });
    return { token };
});

fastify.listen({ port: 3000, host: '0.0.0.0' });

Após registrar o plugin, o programa adiciona um hook de autenticação JWT para verificar JWTs. Ao visitar a rota /login, o endpoint deve ser autenticado.

Validação

Você pode validar os dados recebidos das requisições com um esquema onde você especifica os valores requeridos. Veja como:

const fastify = require('fastify')();

fastify.post('/data', {
    schema: {
        body: {
            type: 'object',
            properties: {
                name: { type: 'string' },
                age: { type: 'integer' }
            },
            required: ['name', 'age']
        }
    }
}, async (request, reply) => {
    return { status: 'Data is valid' };
});

fastify.listen({ port: 3000, host: '0.0.0.0' });

O programa garante que as requisições POST para /data tenham um objeto JSON com duas propriedades: um name do tipo string e uma age do tipo integer. Ao receber dados válidos, o servidor responde com uma mensagem de sucesso.

Serialização

Serialização é uma operação que você realizará frequentemente se estiver usando o Fastify para construir APIs. Veja como você pode serializar dados com o Fastify:

const fastify = require('fastify')();

fastify.get('/user', {
    schema: {
        response: {
            200: {
                type: 'object',
                properties: {
                    id: { type: 'integer' },
                    name: { type: 'string' }
                }
            }
        }
    }
}, async (request, reply) => {
    return { id: 1, name: 'John Doe' };
});

fastify.listen({ port: 3000, host: '0.0.0.0' });

O programa define uma rota que responde a requisições GET no endpoint /user. Quando os clientes fazem requisições GET para o endpoint, o servidor valida a resposta e garante que a resposta tenha a estrutura esperada com as propriedades id (integer) e name (string).

Logging

O Fastify também possui funções embutidas para logging em diferentes níveis:

const fastify = require('fastify')({ logger: true });

fastify.get('/', async (request, reply) => {
    request.log.info('Hello world route called');
    return { hello: 'world' };
});

fastify.listen({ port: 3000, host: '0.0.0.0' });

O programa define um servidor web simples que responde a requisições GET no caminho raiz com a mensagem "hello world" após registrar a mensagem "Hello world route called" na saída especificada.

Adaptadores

Adaptadores facilitam o uso do Fastify em diferentes ambientes de servidor:

const fastify = require('fastify')();
const awsLambdaFastify = require('aws-lambda-fastify');

fastify.get('/', async (request, reply) => {
    return { hello: 'world' };
});

const proxy = awsLambdaFastify(fastify);
exports.handler = proxy;

O programa de exemplo acima atua como um adaptador para um aplicativo Fastify que é executado dentro do AWS Lambda. Os pacotes aws-lambda-fastify fazem a ponte para tornar o aplicativo Fastify compatível com o modelo de execução Lambda.

Manipulação de Erros

Você pode lidar com erros relacionados a requisições com manipuladores de erros no Fastify. Veja como:

const fastify = require('fastify')();

fastify.setErrorHandler((error, request, reply) => {
    reply.status(500).send({ error: 'Something went wrong!' });
});

fastify.get('/', async (request, reply) => {
    throw new Error('Oops!');
});

fastify.listen({ port: 3000, host: '0.0.0.0' });

Aqui, criamos manipuladores de erros personalizados para o aplicativo Fastify. Todos os erros não capturados, como aqueles das requisições GET para o caminho raiz, acionam o manipulador.

O manipulador envia uma mensagem de erro genérica com um código de status 500 para o cliente, mas em uma aplicação real, você provavelmente forneceria respostas de erro mais específicas.

Casos de uso do Fastify

Você pode usar o Fastify para a maioria dos casos de uso em que usaria um framework de backend, desde a construção de backends para web até APIs e aplicativos em tempo real. Vamos explorar alguns dos casos de uso mais populares do Fastify para você entender melhor como pode utilizá-lo:

Construção de APIs web de alto desempenho e microsserviços — O baixo overhead e o manuseio otimizado de requisições/respostas do Fastify são ideais para construir APIs e microsserviços eficientes e escaláveis que lidam com grandes volumes de requisições.
Desenvolvimento de aplicativos em tempo real usando WebSockets — Você pode criar aplicativos de chat, jogos e ferramentas colaborativas com o Fastify, pois há suporte integrado para WebSockets.
Construção de aplicativos web renderizados no servidor — Você pode usar o Fastify para criar aplicativos web renderizados no servidor e entregar conteúdo rapidamente para o seu público.
Manipulação eficiente de grandes volumes de tráfego — O Fastify lida bem com cargas pesadas e é muito eficiente em termos de recursos. É ótimo para construir aplicativos concorrentes se você espera um tráfego elevado no backend.
Casos de uso comerciais/práticos — A velocidade e a baixa latência do Fastify o tornam uma excelente escolha para construir APIs de alto desempenho, microsserviços e aplicativos em tempo real. Ele também pode lidar com aplicações que exigem processamento intensivo de dados, processando dados de dispositivos IoT de maneira eficiente e garantindo tempos de resposta rápidos para plataformas de comércio eletrônico de alto tráfego. O Fastify facilita a construção de protótipos e permite focar na lógica de negócios durante o desenvolvimento. Você também pode usá-lo para servir conteúdo estático e construir funções serverless.

Você pode visitar o site e os fóruns do Fastify para saber como a comunidade está usando o Fastify para diferentes casos de uso. Além disso, há várias organizações populares que já utilizam o Fastify em diversos projetos para diferentes finalidades. Você pode conferir esta página para obter uma visão abrangente das organizações que utilizam o Fastify.

Implantando seu Projeto Fastify

Você pode implantar seus projetos Fastify de várias maneiras, localmente ou em provedores de nuvem. As opções de implantação para seu projeto Fastify incluem:

Plataformas em Nuvem (PaaS) — Você pode implantar seus aplicativos Fastify em plataformas como Heroku, AWS, Google Cloud e muitas outras. Essas plataformas oferecem uma implantação fácil com pouca ou nenhuma configuração.
Containerização — Você pode usar ferramentas de containerização como Docker e Kubernetes para containerizar seu aplicativo, garantindo consistência entre ambientes e provedores de nuvem.
Servidores Virtuais Privados (VPS) — Os provedores de VPS oferecem mais controle sobre o ambiente do servidor. Você precisará gerenciar a infraestrutura do servidor por conta própria, mas ganhará mais flexibilidade.
Funções Serverless (AWS Lambda, Google Cloud Functions) — Você pode usar funções serverless para arquiteturas de microsserviços baseadas em eventos e pagar por execução, tornando-a uma opção econômica para aplicações com tráfego variável.

Melhores Práticas para Implantação

Existem algumas melhores práticas que você deve seguir ao implantar seu projeto Fastify:

Use variáveis de ambiente para armazenar dados de configuração sensíveis, como chaves de API e credenciais de banco de dados, para mantê-los fora do alcance de terceiros e acesso não autorizado.
Use gerenciadores de processos para manter seus aplicativos funcionando sem problemas, lidando com reinicializações, logs e escalabilidade sem interrupções.
Configure ferramentas de monitoramento e logging para acompanhar a saúde e os métricas de desempenho do seu aplicativo. Implemente um logging adequado para diagnosticar facilmente problemas.
Siga melhores práticas de segurança, como validação e sanitização de entradas, autenticação e autorização de usuários para proteger sua conta contra vulnerabilidades.
Use sistemas de controle de versão como o Git ativamente para manter um histórico de implantações que pode ser facilmente revertido.
Explore o uso de pipelines CICD para automatizar processos de teste e implantação para garantir consistência, dependendo da complexidade de sua aplicação.

Seguir essas práticas e usar essas opções de implantação prepara seu projeto para o sucesso.

Alternativas ao Fastify

Existem várias alternativas ao Fastify que você pode considerar para construir seus aplicativos e APIs. Cada uma dessas alternativas tem suas próprias características, vantagens e desvantagens. Aqui estão algumas opções populares:

1. Express.js

Descrição: Um dos frameworks mais populares para Node.js, conhecido por sua simplicidade e flexibilidade.
Vantagens: Grande comunidade, vasta quantidade de middleware disponível, fácil de aprender.
Desvantagens: Pode ser menos performático que outras alternativas, e a falta de algumas funcionalidades modernas por padrão pode exigir mais configuração.

2. Koa.js

Descrição: Criado pelos mesmos desenvolvedores do Express, Koa é um framework mais moderno e minimalista que utiliza async/await por padrão.
Vantagens: Design mais limpo, melhor suporte para async/await, modularidade.
Desvantagens: Menos middleware e plugins comparado ao Express, o que pode exigir mais configuração inicial.

3. Hapi.js

Descrição: Um framework para Node.js que foca em configuração e extensibilidade.
Vantagens: Boa documentação, robustez e segurança, suporte a plugins.
Desvantagens: Curva de aprendizado um pouco mais acentuada, menos popular que o Express.

4. NestJS

Descrição: Um framework para Node.js que utiliza TypeScript e é inspirado no Angular, oferecendo uma arquitetura modular e baseada em componentes.
Vantagens: Suporte a TypeScript, estrutura de código modular e escalável, integração fácil com outros frameworks e bibliotecas.
Desvantagens: Pode ser mais complexo de configurar, especialmente se você não está familiarizado com TypeScript.

5. Sails.js

Descrição: Um framework MVC para Node.js que é focado em APIs e aplicações de tempo real.
Vantagens: Conformidade com a arquitetura MVC, suporte a WebSockets, estrutura para construir APIs.
Desvantagens: Pode ser mais opinativo e menos flexível comparado a alternativas como Express.

6. LoopBack

Descrição: Um framework para Node.js que facilita a criação de APIs e o trabalho com dados.
Vantagens: Ferramentas para criação de APIs RESTful e gerenciamento de dados, suporte para conectores de banco de dados.
Desvantagens: Menos popular, o que pode significar menos suporte e recursos comunitários.

7. AdonisJS

Descrição: Um framework MVC para Node.js que oferece uma experiência mais completa e integrada para o desenvolvimento de aplicações.
Vantagens: Estrutura de aplicação bem definida, suporte integrado a várias funcionalidades, como autenticação e ORM.
Desvantagens: Pode ser considerado mais opinativo e menos flexível do que outras opções.

Cada um desses frameworks tem suas próprias características e pode ser mais adequado para diferentes tipos de projetos e necessidades. A escolha depende das especificidades do seu projeto e das suas preferências pessoais.

Conclusão

O Fastify é uma opção poderosa e moderna para desenvolvedores que buscam construir aplicações rápidas, escaláveis e seguras. Sua abordagem de baixo overhead e modularidade o torna uma excelente escolha para projetos que exigem alta performance e flexibilidade. No entanto, como com qualquer tecnologia, é importante avaliar suas necessidades específicas e comparar o Fastify com outras alternativas para garantir que você está escolhendo a ferramenta certa para seu projeto.

Sugestão de Cursos

Descubra o caminho para se tornar um especialista em programação web. Aprenda HTML, CSS, JavaScript e os principais frameworks nesta jornada emocionante. Com instrutores experientes e materiais práticos, você desenvolverá habilidades práticas para criar sites impressionantes e aplicativos interativos. Impulsione sua carreira na indústria de tecnologia e abra portas para oportunidades de emprego lucrativas. Garanta sua vaga hoje mesmo e inicie sua jornada para se tornar um desenvolvedor web de sucesso.

Método Para Aprender a Programar do Absoluto ZERO com Node.js, React e React Native.

As tecnologias ensinadas no curso são responsáveis por muitas vagas no mercado de trabalho.

Além da alta demanda, os salários vão de R$47.000,00 até R$197.000,00 anuais tendo empresas que possibilitam o trabalho remoto e até vagas Internacionais.

Para que você possa estar apto a preencher uma dessas vagas eu vou te apresentar o passo a passo para você se tornar um verdadeiro expert nessas tecnologias.

O curso te dará o passo a passo de como criar estruturar de um sistema do zero com Node.js, React e React Native.

Saiba mais sobre o curso de Node.js, React e React Native.