Desbloqueie o poder dos microsserviços Node.JS: dominando a arte

No atual cenário digital acelerado e em constante mudança, a demanda por soluções de software altamente escaláveis ​​e eficientes tem aumentado diariamente. É aqui que entram os microsserviços, um estilo arquitetônico moderno que promove o desenvolvimento de serviços pequenos, autônomos e independentes que trabalham juntos para formar uma aplicação maior.

Node.js é ideal para construir microsserviços devido ao seu modelo de E/S sem bloqueio, arquitetura orientada a eventos e design leve. Como resultado, permite que os desenvolvedores criem aplicativos de alto desempenho e em tempo real que podem ser facilmente dimensionados e permanecer resilientes diante de falhas.

Este artigo explorará as vantagens e desvantagens do Node.js para a criação de arquitetura de microsserviços e as melhores práticas para projetar essas arquiteturas, juntamente com um tutorial para ver como um microsserviço básico é implementado. Se você planeja usar microsserviços com Node.js para construir aplicativos eficientes e capazes de escalar rapidamente, este artigo é perfeito para você, então vamos direto ao assunto!

O que é Node.js?

Node.js é um ambiente de tempo de execução JavaScript de plataforma cruzada e código aberto para o desenvolvimento de aplicativos de rede e do lado do servidor. O loop de eventos no núcleo do Node.js permite gerenciar várias conexões simultâneas rapidamente, permanecendo leve e eficiente em termos de recursos.

O loop de eventos funciona ouvindo eventos que precisam ser processados, como solicitações HTTP ou dados recebidos de outros serviços, e depois executando o código relevante para processá-los. Isso torna o Node.js uma excelente escolha quando você precisa que um aplicativo responda rapidamente sem consumir um número substancial de recursos do servidor ou do sistema.

O Node também fornece APIs poderosas que permitem aos desenvolvedores criar facilmente servidores web e aplicativos em rede com apenas algumas linhas de código. Isso torna o node especialmente atraente para aplicações em tempo real, como chats, jogos online, atualizações ao vivo, etc.

Além disso, o Node.js usa práticas de programação assíncronas, o que ajuda a manter todo o aplicativo sem bloqueio. Se uma parte do aplicativo demorar mais do que o esperado, outras partes não serão afetadas.

O que é um microsserviço?

Um microsserviço é um tipo de arquitetura de software que baseia um aplicativo em uma coleção de serviços fracamente acoplados. Esses serviços individuais são construídos em torno de recursos de negócios e podem ser implantados de forma independente por meio de pipelines de implantação totalmente automatizados. Conforme pesquisa de Estatista, constatou-se que cerca de 81,5% das empresas utilizam arquitetura de microsserviços. Cada serviço é executado em seu próprio processo e se comunica com outros serviços por meio de APIs bem definidas, normalmente usando uma interface HTTP/REST para um sistema inteiro.

Microsserviços são processos pequenos e independentes que se comunicam entre si para formar aplicações complexas. Eles são frequentemente categorizados em uma arquitetura monolítica. Eles podem ser escritos em diferentes linguagens de programação e usar diferentes tecnologias de armazenamento de dados, portanto, são unidades de software altamente dissociadas e testáveis, facilitando o teste unitário.

Quando usar microsserviços Node.js?

Ao decidir se deve ou não usar o microsserviço node.js, é importante considerar todos os requisitos e arquitetura do seu aplicativo. Se você tiver um aplicativo monolítico existente que precise de melhorias de escalabilidade e desempenho, dividi-lo em serviços independentes menores poderá ser benéfico se o custo da migração for aceitável. Os microsserviços também devem ser usados ​​quando novos recursos precisam ser desenvolvidos rapidamente, mas não exigem alterações de outras partes do sistema, como webhooks, notificações ou serviços de processamento analítico. Dividindo assim os componentes do software.

Nos casos em que a baixa latência é crítica, o Node pode nem sempre ser adequado porque sua natureza de thread único significa que as tarefas com uso intensivo de CPU bloquearão todas as outras solicitações até que concluam a execução, o que pode afetar negativamente o desempenho sob condições de alta carga em comparação com arquiteturas mais tradicionais. como aplicativos Java EE ou .Net Core executados em vários threads simultaneamente.

Padrões de programação assíncronos também devem ser empregados sempre que possível nas implementações de serviço de nó, para que tarefas intensivas de E/S não bloqueiem completamente as solicitações recebidas enquanto aguardam respostas de serviços externos, como bancos de dados ou API de terceiros, etc.

No geral, o Node js provou ser útil na construção de sistemas distribuídos que exigem alto rendimento em escala e uso de recursos relativamente baixo.

No entanto, ainda existem algumas desvantagens associadas ao uso do microsserviço Node.js que também devem ser levadas em consideração antes de tomar uma decisão:

• Suporte a idiomas limitado – como o Node é construído em JavaScript, apenas desenvolvedores familiarizados com esta linguagem podem construir e manter efetivamente esses tipos de sistemas;
• Falta de maturidade – embora existam muitas estruturas em torno do desenvolvimento de nós, como ExpressJS, KoaJS, etc., muitas carecem de certos recursos encontrados em linguagens mais estabelecidas.
• Vulnerabilidades de segurança –módulos de nó tendem a ter análises de segurança limitadas em comparação com pacotes escritos em outras linguagens, o que significa que códigos maliciosos podem passar despercebidos se as verificações adequadas não forem feitas durante o desenvolvimento;
• Tratamento de erros e depuração – solucionar erros em grandes sistemas distribuídos compostos por muitos nós pequenos pode ser difícil, especialmente ao lidar com operações assíncronas em diferentes nós.

Além disso, decidir se deve ou não usar o microsserviço Node.js depende muito de seus requisitos específicos, bem como do tipo de experiência que você tem disponível entre os membros de sua equipe.

Visto que entender a melhor forma de utilizar microsserviços javascript requer alguma experiência em trabalhar com tecnologias do lado do servidor baseadas em JavaScript, como Express JS ou Koa JS etc.

Se feita corretamente, os benefícios alcançados com a utilização desta abordagem podem superar em muito quaisquer desvantagens associadas se compreender as suas limitações e implementar salvaguardas adequadas sempre que necessário.

Implementando microsserviços com Node.js

Este tutorial explora um caso de uso para criar um microsserviço de tradução de idiomas com a API do Google Translate. Também é fundamental aderir aos melhores padrões de segurança ao desenvolver um aplicativo Node.js. Portanto, quando se trata de garantir a segurança de seus aplicativos Node.js, as práticas recomendadas de segurança do Node.js podem ajudá-lo a proteger seus dados.

Contexto

A API do Google Translate é uma API robusta de tradução de idiomas que oferece tradução de texto entre idiomas em tempo real. Ele também permite que os usuários traduzam texto no site sem desenvolver recursos de tradução nativos, integrando esta API externa em um microsserviço.

Vamos começar.

Pré-requisitos

• Node.js
• Expressar
• Eixos

Etapa 1: inscreva-se em uma conta do Google Cloud

Para usar a API do Google Translate, você precisa ter uma conta do Google Cloud. Cadastre-se para uma conta gratuita em

Etapa 2: ative o Google Tradutor e obtenha a chave da API

Depois de se inscrever em uma conta do Google Cloud, você deverá ativar a API do Google Translate no Console do Google Cloud. Siga esses passos:

1. Acesse o Console do Google Cloud em

2. Selecione seu projeto ou crie um novo

3. Clique no ícone do menu de navegação (☰) e selecione APIs e serviços > Painel

4. Clique em Habilitar APIs e serviços

5. Pesquise a API do Google Translate e clique nela

6. Clique em Habilitar

7. Gere uma chave API clicando em Credenciais > Criar credenciais

8. Copie a chave API para ser usada posteriormente em nossa aplicação.

Etapa 3: crie um projeto Node.js.

Crie um novo projeto Node.js executando o seguinte comando em seu terminal.

mkdir translation-microservice
cd translation-microservice
npm init

O comando npm init é usado para inicializar um projeto Node.js.

Etapa 4: instalar dependências e revisar o arquivo JSON

Instale as dependências necessárias para o projeto executando o seguinte comando

npm install express axios

É assim que seu package.json deve ficar após a instalação das dependências. É importante revisar o arquivo JSON para garantir que tudo esteja configurado corretamente.

{
  "name": "translation-microservice",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "axios": "^1.3.4",
    "express": "^4.18.2"
  }
}

Etapa 5: configure o servidor e crie o arquivo JS

Crie um novo arquivo js chamado server.js e adicione o seguinte código:

const express = require('express');
const axios = require('axios');

const PORT = process.env.PORT    3000;

const app = express 

app.get(" (req, res) => {
   res.sendFile(__dirname + '/home.html', (err) => {
     if (err) {
       console.log(err);
       res.status(500).send('Error: Unable to load page');
     }
   });
 });

app.get('/translate', async (req, res) => {
   const { text, source, target } = req.query;

   console.log(text);
   console.log(source, target);

   const response = await axios.get(
   `
   );

   console.log(response.data.data.translations(0).translatedText)

   res.json(response.data.data.translations(0).translatedText);
});

app.listen(PORT,   => {
   console.log(`Server running on port ${PORT}`);
 });

O código acima possui duas rotas, uma para servir uma página inicial e outra para lidar com uma solicitação de tradução.

A rota de tradução usa a biblioteca Axios para fazer uma solicitação GET à API Google Cloud Translation com os parâmetros de texto, origem e idioma de destino fornecidos. O texto traduzido é então retornado no formato JSON como resposta.

Etapa 6: configurar a variável de ambiente

Crie um novo arquivo chamado .env na pasta raiz do projeto e adicione o seguinte código:

GOOGLE_API_KEY=<your_google_api_key>

Substitua pela sua chave de API externa real do Google.

Etapa 7: configurar o lado do cliente

Crie um novo arquivo chamado home.html e adicione o seguinte código

<!DOCTYPE html>
<html>
 <head>
   <title>Translate Text</title>
 </head>
 <body>
   <h1>Translate Text</h1>
   <form >
     <label for="text">Enter the text to be translated:</label><br />
     <input type="text"  name="text"><br /><br />
     <label for="from-language">Translate from:</label>
     <select  name="from-language">
       <option value="en">English</option>
       <option value="es">Spanish</option>
       <option value="fr">French</option>
       <option value="de">German</option>
       <option value="it">Italian</option>
       <option value="ja">Japanese</option>
       <option value="ko">Korean</option>
       <option value="pt">Portuguese</option>
       <option value="ru">Russian</option>
       <option value="zh">Chinese</option>
     </select><br />
     <label for="to-language">Translate to:</label>
     <select  name="to-language">
       <option value="en">English</option>
       <option value="es">Spanish</option>
       <option value="fr">French</option>
       <option value="de">German</option>
       <option value="it">Italian</option>
       <option value="ja">Japanese</option>
       <option value="ko">Korean</option>
       <option value="pt">Portuguese</option>
       <option value="ru">Russian</option>
       <option value="zh">Chinese</option>
     </select><br /><br />
     <button type="submit">Translate</button>
   </form>
   <br />
   <p>Translated Text: </p>
   <div ></div>

   <script src="
   <script>
       $(document).ready(function   {
       $('#translate-form').submit(function (event) {
           event.preventDefault ;
           var text = $('#text').val ;
           var source = $('#from-language').val ;
           var target = $('#to-language').val ;
           var url=" + text + '&source=" + source + "&target=" + target;

           $.ajax({
           url: url,
           type: "GET',
           success: function (data) {
               console.log(data);
               $('#translation').append(data);
           },
           error: function   {
               alert('Error occurred while translating the text');
           },
           });
       });
       });
   </script>
 </body>
</html>

O código acima recebe a entrada do usuário, envia um objeto de solicitação ao servidor e retorna um objeto de resposta ao texto traduzido usando a chamada AJAX. Esta servirá como a página inicial do aplicativo.

Etapa 8: inicie o servidor

Inicie o servidor executando o seguinte comando:

node server.js

Etapa 9: teste o microsserviço

Abra seu navegador e vá para

Agora teste o aplicativo inserindo o texto a ser traduzido. Você deverá ver o texto traduzido exibido na tela.

Vantagens e desvantagens do uso de microsserviços Node JS

Aqui está uma tabela que descreve algumas das vantagens e desvantagens do uso de microsserviços com Node.js.

Desenvolvimento de software com microsserviços, as alternativas

Os microsserviços permitem que as organizações dividam aplicativos monolíticos em partes menores e mais gerenciáveis ​​que podem ser desenvolvidas e implantadas de forma independente com node.js. Essa estratégia garante escalabilidade e manutenção do aplicativo. No entanto, várias alternativas de microsserviços ao Node.js oferecem benefícios semelhantes para o desenvolvimento e implantação de aplicativos.

Java

Java já existe há algum tempo e agora é uma das linguagens de programação mais utilizadas. Também inclui diversas ferramentas e estruturas que o tornam ideal para a construção de microsserviços.

Por exemplo, a estrutura Spring Boot permite que os desenvolvedores projetem rapidamente arquiteturas de microsserviços de nível de produção, oferecendo uma visão focada de como elas devem ser construídas e implementadas, diminuindo consideravelmente o tempo de desenvolvimento.

Ir

Go (também conhecido como Golang) é uma linguagem relativamente nova criada pelo Google em 2009. No entanto, sua popularidade cresceu rapidamente devido aos seus recursos simples, mas poderosos, como coleta de lixo, primitivas de simultaneidade, tempos de compilação rápidos, garantias de segurança de memória, e suporte robusto de ferramentas da comunidade.

Go facilita a gravação de programas pequenos e eficientes com o mínimo de esforço, tornando-o adequado para a criação de microsserviços leves que podem ser facilmente aumentados ou reduzidos dependendo da demanda ou necessidade. Seu baixo uso de recursos também o torna atraente ao executar um grande número de serviços em ambientes de nuvem distribuídos, essencial ao lidar com centenas ou até milhares de serviços diferentes executados simultaneamente dentro de um único sistema ou em vários nós!

Phyton

Python é outra linguagem popular amplamente usada entre profissionais experientes e amadores, graças à sua estrutura de sintaxe simples que permite a prototipagem rápida, permitindo que os desenvolvedores lancem produtos rapidamente sem ter muito conhecimento sobre convenções de codificação, etc.

Além disso, Python possui vários frameworks construídos especificamente para suportar arquiteturas orientadas a serviços, como Flask e Django. O que auxilia no roteamento de solicitações ao longo de caminhos específicos entre componentes, juntamente com a segurança adequada em qualquer padrão de design de arquitetura. Isso o torna um candidato ideal para o desenvolvimento de soluções baseadas em microsserviços.

Rubi

Ruby é frequentemente ignorado erroneamente por ser muito lento para desenvolvimento no lado do servidor. No entanto, através do uso do módulo EventMachine do Ruby, esse mito pode ser desmascarado, permitindo aos desenvolvedores compor aplicações web assíncronas de alto desempenho, capazes de lidar com grandes volumes de tráfego simultaneamente, enquanto fornecem tempos de resposta que excedem em muito as expectativas dos modelos tradicionais de 'bloqueio'.

Conclusão:

Concluindo, a construção de microsserviços com Node.js, um ambiente de desenvolvimento em tempo de execução baseado na linguagem de programação JavaScript, tem se tornado cada vez mais popular no desenvolvimento de software devido às suas inúmeras vantagens. Ao dividir uma aplicação inteira em microsserviços independentes, as equipes de desenvolvimento podem trabalhar em cada serviço separadamente, conforme detalhado na descrição do trabalho do Node. Essa abordagem facilita o dimensionamento e a manutenção do aplicativo geral.

Se você gostou deste artigo, confira nossos outros guias abaixo;

• Alterar versão do nó: um guia passo a passo
• Cache Node JS: aumentando o desempenho e a eficiência
• Desbloqueie o poder dos microsserviços Node.JS
• Desbloqueando o poder do Websocket Nodejs
• Melhores editores de texto e IDE Node JS para desenvolvimento de aplicativos