Esta introdução foi desenvolvida para desenvolvedores de software que desejam aprender o básico do Node.js e da sua arquitetura. Este tutorial lhe dará entendimento suficiente sobre todos os componentes necessários do Node.js.
Node.js é um ambiente de código aberto, multiplataforma e gratuito que executa código JavaScript fora de um navegador web. Com ele podemos construir aplicações web em geral, desde web sites até APIs e micro serviços.
Isso é possível graças a união de três componentes principais:
As aplicações Node.js são escritas em JavaScript, e podem ser executadas dentro do runtime Node.js em OS X, Microsoft Windows, e Linux.
Um ambiente de tempo de execução é o ambiente de execução fornecido a uma aplicação ou software pelo sistema operacional. Em um ambiente de tempo de execução, a aplicação pode enviar instruções ou comandos para o processador e acessar outros recursos do sistema, como a memória RAM, o que de outra forma não é possível, pois a maioria das linguagens de programação utilizadas são linguagens de alto nível.
O ambiente runtime fornece um estado para que a máquina utilizada tenha acesso a recursos como bibliotecas de software, variáveis de sistema e variáveis de ambiente, e fornece todos os serviços e suporte necessários aos processos envolvidos na execução da aplicação ou programa.
Um motor JavaScript é um programa ou um intérprete que executa o código JavaScript. Um motor JavaScript pode ser implementado como um intérprete padrão, ou compilador just-in-time que compila JavaScript para bytecode de alguma forma.
Cada grande browser tem o seu próprio motor. Você consegue ver a lista completa nesse link.
O motor que realmente nos interessa aqui é o V8, é ele que está por trás do Node js. Ele foi inicialmente projetado para aumentar o desempenho de execução do JavaScript dentro do browser.
A fim de obter velocidade, o V8 traduz o código JavaScript em código de máquina (mais eficiente), ao invés de usar um intérprete. Ele compila código JavaScript em código de máquina na execução, implementando um compilador JIT (Just-In-Time) como muitos motores JavaScript modernos fazem, como SpiderMonkey ou Rhino (Mozilla). A principal diferença aqui é que o V8 não produz bytecode ou qualquer código intermediário.
Como os próprios criadores denominam:
libuv é uma biblioteca de suporte multiplataforma com foco em I/O assíncrona. Foi desenvolvida principalmente para uso pelo Node.js.
Libuv Github
É uma biblioteca escrita em C que é usada para abstrair operações de I/O sem bloqueio, para uma interface consistente em todas as plataformas suportadas. Além disso a biblioteca conta com diversas outras características como:
Para começar a construir suas aplicações Node.js, o primeiro passo é a instalação. O framework está disponível para uma variedade de sistemas operacionais, desde Windows até Ubuntu e OS X.
Acesse o site https://nodejs.org/en/download/ e faça o download dos arquivos necessários para o seu sistema operacional. Nesse exemplo, vamos baixar os arquivos de configuração de 64 bits para Windows.
Após finalizar o download vamos ao passo para instalação. Basta clicar no ícone logo abaixo, que o processo de instalação vai começar.
A instalação é bem simples, não são muitos detalhes. A primeira tela que você vai ver, será essa da imagem abaixo, para prosseguir basta clicar no botão “Next”.
Na segunda tela, você deve aceitar os termos de licença de uso para prosseguir com a instalação.
Você pode definir um local diferente para instalação do Node js, caso seja necessário. Se não for necessário mudar o local de instalação do Node js você pode avançar essa etapa.
A a instalação do Node js vem acompanhada com com alguns outros pacotes muito importantes, como o npm(gerenciador de pacotes Javascript). Se por algum motivo você não precisar de algum desses pacotes, você pode simplesmente remover da instalação do Node js. Do contrário, deixe tudo como está e avance para a próxima etapa.
Alguns módulos npm precisam ser compilados a partir do C/C++ durante a instalação. Se você quiser ser capaz de instalar tais módulos, algumas ferramentas (Python e Visual Studio Build Tools) precisam ser instaladas.
Para o nosso tutorial, essas ferramentas não serão necessárias. Podemos avançar.
Se todas as suas configurações para instalação do Node js estiverem corretas, basta clicar em “Install“.
Agora é só aguardar a finalização da instalação do Node js.
E é isso, o Node js está pront para ser executado.
Antes de iniciar alguns exemplos de código, é importante ter uma idéia sobre a arquitetura do Node js. Neste sessão nós vamos discutir como Node Js funciona por dentro. Como Node js lida com solicitações simultâneas seguindo um modelo Single-Thread.
Talvez algumas pessoas não estejam familiarizadas com alguma das nomenclaturas, e por ser muito importante para entender a estrutura básica do Node js, vamos revisar alguns pontos principais.
Um processo é um programa em execução, ou seja, um programa em execução e é criado quando um programa inicia a execução. Um processo pode ter várias threads.
Na ciência da computação, uma thread é um pequeno conjunto de instruções projetado para ser programado e executado pela CPU, independentemente do processo pai e é normalmente uma parte do sistema operacional.
A principal diferença é que as threads dentro de um mesmo processo são executados em um espaço de memória compartilhada, enquanto os processos são executados em espaços de memória separados.
Os processos single thread executam todas as instruções em uma única seqüência. Em outras palavras, apenas um comando é processado por vez.
O oposto de processos single threads são processos multi threads. Estes processos permitem a execução de múltiplas partes de um programa ao mesmo tempo.
Uma aplicação Node js roda em uma única thread e o loop de eventos(event loop) também roda na mesma thread. Assim, podemos dizer que o Node js é single-threaded, mas existem algumas bibliotecas no Node js que não são single-threaded.
É ai que entra em cena a biblioteca libuv. Ela é responsável por lidar com tarefas relacionadas ao sistema operacional, como as tarefas baseadas em I/O assíncronos dos sistemas operacionais, redes, concorrência, etc.
Quando Node requisita a execução de processos simultâneos, a biblioteca Libuv configura um conjunto de quatro threads para realizar as operações, utilizando a potência de todos os núcleos da CPU. Considerando que a nossa máquina tenha quatro núcleos, cada thread do pool é atribuída a cada núcleo.
Isto resulta em uma thread por núcleo. Com esta configuração, todas as quatro threads executarão o seu processo em cada núcleo em paralelo.
Se quiser entender mais, visite esse artigo, que explica com ainda mais detalhes.(Em inglês)
Node.js é uma plataforma baseada em eventos. Isto significa que tudo que acontece no Node é a reação a um evento. Uma transação passando por Node atravessa uma cascata de callbacks.
Independentemente do desenvolvedor, tudo isso é tratado pela biblioteca libuv que fornece um mecanismo chamado loop de eventos.
Como citei antes, há apenas um thread que executa o código JavaScript e que é onde o loop de eventos está rodando. A execução de callbacks (saiba que todo código executado pelo do usuário em uma aplicação Node.js em execução é um callback) é feita pelo loop de evento.
A Libuv por padrão cria uma pool com quatro threads para descarregar o trabalho assíncrono. Os sistemas operacionais atuais já fornecem interfaces assíncronas para muitas tarefas de I/O.
Sempre que possível, a libuv irá utilizar essas interfaces assíncronas, evitando o uso do pool de threads. O mesmo se aplica a subsistemas de terceiros, como bancos de dados.
Em resumo: Somente se não houver outra forma, a pool de threads será utilizada para I/O assíncrona.
De uma forma simplificada o sistema node js funciona assim. De um lado temos a sua aplicação que enviando request para o seu servidor em node js, a motor V8 então traduz o código JavaScript em código de máquina, api do Node js se comunica com a biblioteca libuv que executa os processos de I/O do sistema operacional utilizando um loop de eventos, se necessário, fazendo uso da thread pool.
Módulos no Node.js são uma funcionalidade simples ou complexa organizada em um ou vários arquivos JavaScript que podem ser reutilizados em toda a aplicação Node.js.
O Node.js inclui três tipos de módulos:
Cada módulo no Node.js tem seu próprio contexto, portanto não podem interferir com outros módulos ou poluir o escopo global. Além disso, cada módulo pode ser colocado em um arquivo javascript separado em uma pasta separada.
O Node.js implementa o padrão de módulos CommonJS. O CommonJS é um grupo de voluntários que definem padrões JavaScript para servidores web, desktop e aplicativos.
O que faremos agora é criar uma pequena aplicação utilizando Node js, que vai transforma o seu computador em um servidor.
Uma vez que você tenha baixado e instalado o Node.js no seu computador, vamos tentar exibir alguma mensagem no navegador.
O primeiro passo é criar um arquivo principal, que vamos chamar de app.js. Insira o código abaixo no documento:
const http = require('http');
const hostname = '127.0.0.1';
const port = 3000;
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Debug Everything');
});
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});
Salve o arquivo em alguma pasta de fácil acesso. Depois disso, você precisa abrir uma janela do seu terminal, navegar até a pasta onde você salvou o seu arquivo e rodar o comando node app.js, você provavelmente verá uma mensagem igual a essa no seu terminal indicando que a sua aplicação está rodando na porta :3000.
$ node app.js
Server running at http://127.0.0.1:3000/
Agora, seu computador funciona como um servidor!
Se alguém tentar acessar seu computador na rota http://localhost:3000, receberá a mensagem “Debug Everything”
O Node.js tem um módulo embutido chamado HTTP, que permite ao Node.js transferir dados através do Hyper Text Transfer Protocol (HTTP).
Nós estamos incluindo o módulo HTTP, usando o método require(), na primeira linha.
const http = require('http');
Aqui estamos definindo o hostname e a porta em que o servidor vai rodar:
const hostname = '127.0.0.1';
const port = 3000;
O módulo HTTP pode criar um servidor HTTP que escuta as portas do servidor e dá uma resposta para o cliente. Podemos então usar o método createServer() para criar um servidor HTTP.
A função passada para o método http.createServer(), será executada quando alguém tentar acessar o computador na porta 3000.
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Debug Everything');
});
E na última linha, estamos usando o método listen() para começar a escutar a porta 3000 naquele hostname.
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});
A intenção de post era apresentar a você a estrutura básica do Node js, e como ele funciona por dentro.
Existem muitos assuntos que podem ser abordados quando falamos de Node js existe todo um ecosistema de módulos como o Express e AdonisJS que expandem ainda mais a capacidade do Node js, mas vamos deixar isso para futuros posts.
Espero que o conteúdo tenha sido útil. Deixe nos comentários as suas dúvidas e sugestões para o proximo post!
Até a próxima!
Top esse artigo, encontrei por acaso porém me interessou muito.........
Deixe um comentário