UPDATE e DELETE simples com MongoDB + NodeJS

Dando sequência ao CRUD com MongoDB e NodeJS, no artigo anterior foram mostrados os métodos CREATE e READ. Neste artigo, demonstrarei como fazer um UPDATE e DELETE básicos.

UPDATE

Você pode utilizar o método updateOne() para atualizar um documento na sua coleção, passando como parâmetro o objeto a ser atualizado. O segundo parâmetro é o objeto que define os novos valores do documento.

Se a consulta encontra mais de um registro, somente a primeira ocorrência será atualizada.

Para realizar este update, vamos salvar o nosso valor a ser alterado em uma variável chamada valorAntigo e, também, adicionar os novos valores em outra variável, chamada valorNovo. Feito isso, vamos passar essas duas variáveis como parâmetro do nosso método updateOne().

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db) {
    if (err) throw err;
    let dbo = db.db("mydb");
    let valorAntigo = {
        name: 'Usuario 1'
    };
    let valorNovo = { 
        $set: {
            name: 'Usuario Novo', endereco: 'Rua Nova' 
        } 
    };
    dbo.collection("clientes").updateOne(valorAntigo, valorNovo, function (err, res){
        if (err) throw err;
        console.log('Documento atualizado');
        db.close(); 
    });
});

Executando o arquivo, teremos uma mensagem no terminal, dizendo: “Documento atualizado”.

Podemos também apenas alterar um valor específico. Para isso, passamos à variável valorNovo apenas o novo valor do campo.

Você pode atualizar diversos campos utilizando o método updateMany().

Para verificar o seu documento atualizado, utilize o método find().

DELETE

Para excluirmos um documento, usamos o método deleteOne(), que especifica o documento a ser excluído. Devemos passar como parâmetro o campo do registro a ser excluído. Por exemplo, excluiremos o nosso “Usuario Novo”.

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db){
    if (err) throw err;
    let dbo = db.db('mydb');
    let excluirDocumento = { name: 'Usuario Novo' };
    dbo.collection('clientes').deleteOne(excluirDocumento, function(err, obj){
        if (err) throw err;
        console.log("1 documento deletado");
        db.close();
    });
});

E você deverá ver no seu terminal a mensagem: “1 documento deletado”.

Você pode utilizar o método deleteMany() para deletar múltiplos documentos.

Verifique, utilizando o método find(), que o seu registro está vazio.

Gostou deste artigo? Comente abaixo!

CREATE e READ simples com MongoDB + NodeJS

Neste artigo criarei um CREATE e READ básico utilizando MongoDB e Node.js. Caso você não conheça o MongoDB, recomendo a leitura deste artigo que explica como realizar as operações CREATE, READ, UPDATE e DELETE no shell do MongoDB.

O MongoDB é um NoSQL. Com o Node.js, iremos acessar o banco de dados usando o node. Crie uma pasta chamada crud_mongo e abra-a no code. Abra o terminal do code para prosseguir com o artigo.

Precisamos instalar o driver oficial do MongoDB. Utilizando o NPM, vamos baixar o pacote do Mongo.

npm install mongodb

Pronto. Agora temos o pacote instalado na nossa aplicação. Com isso, já é possível manipular bases de dados do MongoDB com o Nodejs.

CRIANDO A BASE DE DADOS

Para criar o banco de dados, vamos fazer uma requisição de um objeto MongoClient, especificando o URL de conexão com o endereço do localhost, a porta a ser utilizada e passando o nome da base de dados a ser criada.

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function(err, db){
    if (err) throw err;
    console.log("Banco de Dados criado!");
    db.close();
})

Execute o arquivo no seu servidor NodeJS. Você verá a mensagem: Banco de Dados Criado!

Observação: O banco de dados não é exatamente criado até que ele receba conteúdo. Vamos inserir conteúdo nesta base a seguir.

CRIANDO UMA COLEÇÃO

Para criar uma coleção na nossa base de dados, usaremos o método createCollection(). Neste médodo, passaremos o nome da coleção a ser criada.

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db) {
    if (err) throw err;
    let dbo = db.db("mydb");
    dbo.createCollection("clientes", function (err, res) {
        if (err) throw err;
        console.log("Coleção criada");
        db.close();
    });
});

E pronto, a nossa coleção foi criada!

INSERINDO DOCUMENTOS NA COLEÇÃO

Para inserir um documento (registro) na coleção, podemos utilizar o método insertOne() para registros simples, e insertMany() para registros múltiplos. Vamos realizar uma inserção de apenas um documento na nossa coleção:

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db) {
    if (err) throw err;
    let dbo = db.db("mydb");
    let myObj = {
        name: "Usuario 1",
        endereco: "Rua teste 1"
    };
    dbo.collection("clientes").insertOne(myObj, function (err, res) {
        if (err) throw err;
        console.log("Documento inserido");
        db.close();
    });
});

Se você tentar inserir documentos em uma coleção inexistente, o MongoDB criará a coleção automaticamente.

READ (find())

Para selecionar os dados de uma coleção no Mongo, podemos utilizar os métodos findOne() e find(), que seleciona um dado e todos os dados da coleção, respectivamente. Utilize o método toArray para retornar os elementos em um vetor.

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db) {
    if (err) throw err;
    let dbo = db.db("mydb");
    dbo.collection("clientes").find({}).toArray(function (err, result) {
        if (err) throw err;
        console.log(result);
        db.close();
    });
});

E nosso retorno será:

Com isso, já sabemos inserir e pesquisar dados no MongoDB utilizando o NodeJS.

Referência: https://www.w3schools.com/nodejs/nodejs_mongodb.asp

Até o próximo artigo pessoal!

Criando um Web Scraper com NodeJs

O Web Scraping é uma espécie de garimpo da internet. Esse “garimpo” envolve a extração de informações de determinado site. A ideia do Web Scraping é automatizar o trabalho usando bots, que coletam um maior número de dados em uma curta fração de tempo.

O processo de Web Scraping pode ser dividido em duas etapas principais:

  • Buscando o código-fonte HTML do site por meio de uma solicitação HTTP ou usando um navegador Headless;

  • Analisando os dados brutos para extrair apenas as informações de seu interesse.

Para realização deste tutorial, será necessário o Node.js na versão 8.x ou posterior e npm instalados no seu computador.

Vamos começar!

Crie uma pasta chamado scraper e inicie com o code. Abra o terminal do code e execute o comando:

npm init -y

Esse comando inicializará o projeto com um arquivo “package.json”. Deixe-o com seus padrões.

Agora, instalaremos as dependências que utilizaremos para criar o Web Scraper:

npm install axios cheerio puppeteer –save

O que cada dependência faz?

  • Axios: é um cliente HTTP baseado em Promises para Node.js;

  • Cheerio: implementação do jQuery para o Node.js. O Cheerio facilita a seleção, edição e exibição de elementos DOM;

  • Puppeteer: uma biblioteca Node.js para controlar o Chrome ou Chromium.

Web Scrap:

Para demonstrar como fazer Web Scrap em um site utilizando o Node.js, configuraremos um script para capturar algumas informações da tabela do Campeonato Carioca de 2020 (Taça Rio). Especificamente, capturaremos os principais goleadores da competição até o momento e organizaremos os dados como um JSON.

Crie um novo arquivo na sua pasta scrapper, chamado goleadorScrap.js.

1º Passo:

Faça as requisições do axios, cheerio e coloque a url em uma constante (Vamos utilizar o site do globoesporte para fazer esse Web Scrap):

const axios = require('axios');
const cheerio = require('cheerio');
const url = 'https://globoesporte.globo.com/rj/futebol/campeonato-carioca/';

Agora, precisamos utilizar o axios para realizar a leitura do nosso HTML. O axios nos traz uma longa sequência de HTML, mas como analisar esse HTML e extrair apenas os dados que queremos? Esse é o trabalho do Cheerio. Ele nos permite utilizar os métodos jQUery para analisar o HTML e extrair informações que desejamos com ele.

Abra o link e abra as ferramentas de desenvolvedor, pressionando a tecla f12 ou clicando com o botão direito do mouse e Inspecionando. Vamos trazer os dados dos artilheiros do Campeonato Carioca. Como você pode notar, o corpo da tabela possui uma div com classe chamada “ranking-item-wrapper”, que contém as informações de cada jogador. Precisamos de um vetor para armazenar essas informações. O código ficaria assim:

const axios = require('axios');
const cheerio = require('cheerio');
const url = 'https://globoesporte.globo.com/rj/futebol/campeonato-carioca/';

axios(url).then(response => {
    const html = response.data;
    const $ = cheerio.load(html);
    const tabelaStatus = $('.ranking-item-wrapper');
    const tabelaJogador = [];
}).catch(console.error);

Os dados que queremos capturar dessa tabela são:

  • Nome do jogador: criaremos uma constante chamada nomeJogador, que receberá o texto disponível na div com classe “jogador-nome”.

  • Posição do Jogador: qual a posição do jogador. Pegue a classe “jogador-posicao” e capture o seu conteúdo de texto;

  • Número de gols: a quantidade de gols que o jogador fez. Capture o conteúdo da classe “jogador-gols”;

  • Time do jogador: o time para qual o jogador pertence. Nesse atributo, precisamos capturar o texto “alt” da tag “img”, que está aninhada a uma div com classe “jogador-escudo”.

O código ficará assim:

const nomeJogador = $(this).find('.jogador-nome').text();
const posicaoJogador = $(this).find('.jogador-posicao').text();
const numeroGols = $(this).find('.jogador-gols').text();
const timeJogador = $(this).find('.jogador-escudo > img').attr('alt');

Agora, precisamos dar um push no nosso vetor. Para isso, usaremos um .each para criar um laço de repetição, colocando em cada posição do vetor, um objeto com os dados do jogador. Feito isso, mostraremos no console os dados de cada jogador!

Este é o código completo:

const axios = require('axios');
const cheerio = require('cheerio');
const url = 'https://globoesporte.globo.com/rj/futebol/campeonato-carioca/';

axios(url).then(response => {
    const html = response.data;
    const $ = cheerio.load(html);
    const tabelaStatus = $('.ranking-item-wrapper');
    const tabelaJogador = [];

    tabelaStatus.each(function(){
        const nomeJogador = $(this).find('.jogador-nome').text();
        const posicaoJogador = $(this).find('.jogador-posicao').text();
        const numeroGols = $(this).find('.jogador-gols').text();
        const timeJogador = $(this).find('.jogador-escudo > img').attr('alt');
        tabelaJogador.push({
            nomeJogador,
            posicaoJogador,
            numeroGols,
            timeJogador
        });
    });
    console.log(tabelaJogador);
}).catch(console.error);

Faça o teste! Veja o resultado no seu terminal!

Gostou deste exemplo? Comente abaixo!

Criando localhost básico para testes

Neste artigo, mostrarei como criar um localhost básico para testes rápidos, utilizando Nodejs + expressjs.
Em redes de computadores, o Localhost se refere ao computador que o está executando, funcionando basicamente como um servidor virtual. Ele também possui um endereço ip, variando de 127.0.0.0 a 127.255.255.255. Com um localhost você pode:

  • Testar Velocidade: você pode testar a velocidade de execução de equipamentos. No windows, você pode usar o comando ping localhost ou ping 127.0.0.1 no prompt de comando;
  • Testar aplicações: Assim que você utiliza o localhost, sua máquina se transforma em um servidor simulado;
  • E muito mais!

E como podemos criar um localhost para testes?

Para isso, precisaremos do Nodejs. É com ele que rodaremos JavaScript no Server-side.Você pode realizar o download em: https://nodejs.org/en/

Também utilizaremos o framework Express.js. Para realizar o download, abra o terminal e digite:

$ npm install express --save

Após isso, dê o comando:

npm start

E os arquivos package e package.json serão criados!

Crie um arquivo chamado index.js e vamos lá!

Iniciando

Para iniciar, precisamos fazer uma requisição para o módulo express que foi baixado. No seu arquivo index.js, comece com isso:

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

Criando as constantes express e app, fazemos a requisição do módulo express.

Com o módulo express, foram baixadas as dependências do módulo. Você pode verificá-las na pasta public. Com o método use, podemos utilizar diretamente os arquivos da pasta public.

app.use(express.static('./public'));

Agora que já estamos utilizando as dependências do express, podemos criar um método para escutar a porta na qual o localhost será executado. usando o app.listen(), mostraremos no console.log a porta e a url do nosso localhost:

app.listen(3000, function () {
    console.log('Porta 3000');
    console.log('link: http://localhost:3000/index.html');
});

Agora que já sabemos qual é a porta e qual a url do nosso localhost, vejamos no navegador:

Com isso, verificamos que o nosso localhost para testes está funcional!

Gostou deste artigo? Comente abaixo e mostre-nos outras alternativas de localhost!

JavaScript lidera ranking de linguagens

2020 chegou e com ele, muitas mudanças no mundo da tecnologia. Se você está curioso para saber qual pode ser o futuro do mundo da programação, veio conferir no lugar certo.

Seguindo as tendências de 2019, o ecossistema do JavaScript se manteve muito utilizado e otimizado. A cada dia que passa, mais pessoas utilizam esta poderosa linguagem com seus frameworks e bibliotecas.

Por muitos anos seguidos, o JavaScript vem sendo a linguagem de programação com maior crescimento e procura. Ela é amplamente utilizada no desenvolvimento de interfaces interativas para a Web, pois é suportada por todos os navegadores modernos. Segundo a pesquisa anual realizada pela Stack Overflow, cerca de 70% dos 72.525 desenvolvedores profissionais que participaram da pesquisa, afirmaram que utilizam JavaScript. Além disso, é um dos idiomas mais procurados, pois os entrevistados que ainda não usaram, afirmaram que querem aprendê-lo.

Pelo sétimo ano consecutivo, o JavaScript é a linguagem de programação mais utilizada, com Python seguindo de categoria.

Empresas de todo o mundo utilizam JavaScript em seus stacks de linguagens. O JavaScript é o coração de qualquer grande empresa de tecnologia, como o PayPal, que foi um dos primeiros a adotar o NodeJS, Netflix, Groupon, Walmart e LinkedIn. 16 de 25 empresas Unicórnio dos EUA mencionam o JavaScript em suas tecnologias, portanto, é improvável que o JavaScript saia do grid em um futuro próximo.

Em relação aos frameworks web, vemos que os frameworks JavaScript continuam em pleno funcionamento, com o jQuery tomando o primeiro lugar, seguido do Angular/Angular.js, React.js,

ASP.NET entre outros. Ainda vemos o Vue.js em ascensão na lista de frameworks web mais utilizados

.

Entre outros frameworks, bibliotecas e ferramentas, vemos a ascensão do Node.js, que se tornou o mais utilizado, com 50.4%, seguido de .NET e .NET Core. React Native também possui uma grande quantia de usos, com 10.8% dos entrevistados afirmando utilizá-lo

.

Referências:

Gostou desta notícia? Comente abaixo!

Criando e lendo arquivo com File System e NodeJS

O módulo File System do Node.js permite o trabalho com o sistema de arquivos do computador. Com ele, podemos criar, atualizar, ler e excluir diversos tipos de arquivos, como .txt, .html, entre outros. Neste exercício, criaremos um arquivo txt com um pequeno texto e realizar sua leitura. O conteúdo deverá ser exibido no shell do NodeJS. Vamos começar?

1º Passo:

Crie um arquivo JavaScript chamado writeFile.js. Neste arquivo você precisará:

  • Criar uma requisição para o módulo file system;
  • Criar uma variável texto que receberá o seguinte parágrafo: Este é o texto que usaremos como exemplo para salvar em nosso arquivo txt;
  • Utilizar o método writeFile para criar um arquivo chamado ‘newfile.txt’ e inserir neste arquivo o conteúdo da variável texto.

2º Passo:

Crie um arquivo JavaScript chamado readFile.js. Neste arquivo, você precisará:

  • Criar uma requisição para o módulo file system;
  • Utilizar o método readFile para leitura do conteúdo do arquivo ‘newfile.txt’. Não esqueça de adicionar o ‘utf-8’ para codificação dos caracteres;
  • Utilize o console.log para mostrar o conteúdo do nosso arquivo no terminal do NodeJS.

Sua saída deverá ser assim:

Você pode realizar o download do código fonte aqui:

[download id=”3594″]

Criando canal de mensagens com RabbitMQ e Node.js

Olá pessoal! Hoje irei mostrar como criar um canal de mensagens usando RabbitMQ e Node.js. Primeiramente, você deve tê-los instalado na sua máquina. Você pode realizar o download do RabbitMQ em: https://www.rabbitmq.com/download.html e do NodeJS em: https://nodejs.org/pt-br/download/.

Vamos começar?

Primeiramente, temos que ter em mente o conceito de fila. Caso não conheça a estrutura de dado fila, dê uma olhada neste artigo: https://www.mundojs.com.br/2019/11/01/estrutura-de-dados-com-javascript-fila/ para podermos dar sequência à este artigo.

No RabbitMQ, temos um produtor de mensagens (P) e um consumidor (C). As mensagens ficam armazenadas dentro de uma fila. No diagrama abaixo, a caixa do meio é a fila. O produtor de mensagens envia uma mensagem para a fila, e o consumidor a recebe:

Enviando:

Crie um arquivo send.js, que será o arquivo do produtor de mensagens. No nosso send.js, precisamos realizar a requisição da biblioteca amqplib. Isso pode ser feito desta maneira:

let amqp = require('amqplib/callback_api');

Em seguida, conectaremos ao servidor RabbitMQ:

amqp.connect('amqp://localhost', function(error0, connection) {
    if (error0)throw error0;
});

Agora, criaremos um canal onde reside a API para a realização das tarefas, onde devemos declarar uma fila para o envio, e também publicar uma mensagem na fila:

amqp.connect('amqp://localhost', function(error0, connection) {
    if (error0) throw error0;
    connection.createChannel(function(error1, channel) {
        if (error1) throw error1;
        
        let queue = 'hello';
        let msg = 'Olá Mundo!';

        channel.assertQueue(queue, {
            durable: false
        });
        channel.sendToQueue(queue, Buffer.from(msg));

        console.log(" [x] Enviando %s", msg);
    });
});

Agora, precisamos fechar a conexão e sair:

setTimeout(function() {
    connection.close();
    process.exit(0);
}, 500);

E o nosso código do produtor de mensagens seria mais ou menos assim:

let amqp = require('amqplib/callback_api');
amqp.connect('amqp://localhost', function(error0, connection) {
    if (error0) {
        throw error0;
    }
    connection.createChannel(function(error1, channel) {
        if (error1) throw error1;
        
        let queue = 'hello';
        let msg = 'Olá Mundo!';

        channel.assertQueue(queue, {
            durable: false
        });
        channel.sendToQueue(queue, Buffer.from(msg));

        console.log(" [x] Enviando %s", msg);
    });
    setTimeout(function() {
        connection.close();
        process.exit(0);
    }, 500);
});

Recebendo:

Agora, nosso consumidor precisa escutar as mensagens enviadas pelo arquivo send.js. O consumidor precisa ficar ativo para escutar as mensagens enviadas. Crie um arquivo chamado receive.js. Este arquivo terá a configuração parecida com o do arquivo send.js. Abrimos uma conexão, um canal e declaramos a fila que iremos consumir:

let amqp = require('amqplib/callback_api');
amqp.connect('amqp://localhost', function (error0, connection) {
    if (error0) throw error0;
    connection.createChannel(function (error1, channel) {
        if (error1) throw error1;
        let queue = 'hello';
        channel.assertQueue(queue, {
            durable: false
        });
     });
});

Queremos garantir a existência de uma fila para que o consumidor não fique iniciando antes do emissor. É exatamente isso que o channel.consume faz:

console.log(' [*] Esperando por mensagens em %s. Para sair pressione CTRL+C', queue);
channel.consume(queue, function (msg) {
    console.log(' [x] Recebida: %s', msg.content.toString());
    }, {
        noAck: true
    });

E o nosso código do consumidor ficaria assim:

let amqp = require('amqplib/callback_api');
amqp.connect('amqp://localhost', function (error0, connection) {
    if (error0) throw error0;
    connection.createChannel(function (error1, channel) {
        if (error1) throw error1;
        let queue = 'hello';
        channel.assertQueue(queue, {
            durable: false
        });
        console.log(' [*] Esperando por mensagens em %s. Para sair pressione CTRL+C', queue);
        channel.consume(queue, function (msg) {
            console.log(' [x] Recebida: %s', msg.content.toString());
        }, {
            noAck: true
        });
    });
});

Executando:

Agora, executando no terminal cada um dos arquivos, temos as seguintes saídas:

Produtor de mensagens:

Consumidor:

E assim está feito o nosso canal de emissão de mensagens!

Gostou deste artigo? Comente abaixo!

Utilizando o File System para atualizar, deletar e renomear arquivos

Dando sequência ao nosso artigo de File System do Node.js, já temos os métodos de ler e criar arquivos. Você pode conferir o artigo anterior no link:

Neste artigo, iremos mostrar os métodos:

  • Update
  • Delete
  • Rename

Vamos lá?

Update:

O file system possui os seguintes métodos:

  • fs.appendFile()
  • fs.writeFile()

O método fs.appendFile() anexa conteúdo no final do arquivo especificado:

// Primeiro criaremos uma requisição para o módulo fs
let fs = require('fs');
// Depois, especificamos o arquivo a ser atualizado
// e colocamos o conteúdo a ser anexado.
fs.appendFile('meuNovoArquivo2.txt', 'Esse é o conteúdo anexado.', function(err){
    if (err) throw err;
    console.log('Atualizado!')
})

E teremos nossa saída:

O método fs.writeFile() substitui o arquivo e conteúdo especificados:

let fs = require('fs');

// Especificamos o arquivo a ser atualizado
// e o novo conteúdo
fs.writeFile('meuNovoArquivo2.txt', 'Conteúdo atualizado', function (err){
    if (err) throw err;
    console.log('Salvo!')
})

E a nossa saída será:

Delete:

Para excluirmos um arquivo com o file system, podemos utilizar o método fs.unlink(). Veja na prática:

let fs = require('fs');

// Especificamos o nome e extensão do arquivo a ser deletado
fs.unlink('meuNovoArquivo.txt', function (err){
    if (err) throw err;
    console.log('Arquivo deletado!');
})

E pronto! O arquivo “meuNovoArquivo.txt” foi deletado!

Renomear:

Podemos utilizar o método fs.rename() para renomear um arquivo:

let fs = require('fs');

// Especificaremos o arquivo a ser renomeado
// e o novo nome
fs.rename('meuNovoArquivo2.txt', 'arquivoRenomeado.txt', function(err){
    if (err) throw err;
    console.log('Arquivo renomeado!');
})

E teremos:

E assim, terminamos os artigos obre o File System do Node.js!

Gostou? Comente abaixo!

 

Utilizando o File System para leitura e criação de arquivos

O módulo File System do Node.js permite o trabalho com o sistema de arquivos do computador. Podemos incluir o File System no nosso arquivo js utilizando o método require:

let fs = require('fs');

Para que serve o módulo File System? O que podemos fazer com ele?

  • Ler arquivos
  • Criar arquivos
  • Atualizar arquivos
  • Deletar arquivos
  • Renomear arquivos

Para ler arquivos usando o file system:

Podemos utilizar o método fs.readFile() para ler arquivos salvos no computador. Por Exemplo, podemos ter o seguinte arquivo html (que esteja localizado na mesma pasta de execução do node):

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>readFile()</title>
</head>
<body>
    <h1>Cabeçalho da página</h1>
    <p>Parágrafo da página</p>
</body>
</html>

Após isso, criemos um arquivo javascript (node) para ler o nosso arquivo html e retornar o conteúdo:

// criando uma requisição http para criação do servidor
let http = require('http');

// criando uma requisição para o módulo filesystem
let fs = require('fs');

// criando um servidor funcionando na porta 8080
// e utilizando o fs.readFile para ler o arquivo html
http.createServer(function (req,res){
    fs.readFile('index.html', function(err, data){
        res.writeHead(200, {'Content-Type': 'text/html'});
        res.write(data);
        res.end();
    });
}).listen(8080);

A nossa saída deve ser assim:

E como podemos criar arquivos com o File System?

Podemos utilizar o módulo para criar novos arquivos utilizando os métodos:

  • fs.appendFile()
  • fs.open()
  • fs.writeFile()

O método fs.appendFile() anexa o conteúdo especificado a um arquivo. Se o arquivo não existir, ele será criado. Crie um novo arquivo chamado appendFile.js e faça o seguinte:

// Crie uma requisição para o módulo file system
let fs = require('fs');

// Utilize o appendFile() para criar um novo arquivo que será anexado à sua pasta node
// onde 'meuNovoArquivo.txt será o arquivo a ser criado
// 'Eu sou o novo conteudo é o conteúdo do arquivo txt

fs.appendFile('meuNovoArquivo.txt', 'Eu sou o novo conteudo', function (err){
    // Se ocorrer um erro, especifique
    if (err) throw err;
    // Senão, logue no console = salvo!
    console.log("salvo!")
})

Perceba que o arquivo foi criado na mesma pasta de origem:

Podemos também utilizar o método fs.open() para criar um arquivo vazio:

let fs = require('fs');

// 'w' significa 'write' = escrever
fs.open('meuNovoArquivo2.txt', 'w', function (err, file){
    if (err) throw err;
    console.log("Aberto!");
});

E teremos nosso arquivo criado:

E, finalmente, o método writeFile():

O método writeFile() substitui o arquivo e conteúdo especificados, se existirem. Se o arquivo não existir, ele será criado:

let fs = require('fs');

// Substituiremos o conteúdo em meuNovoArquivo2.txt pela frase
// 'Novo conteúdo!'
fs.writeFile('meuNovoArquivo2.txt', 'Novo conteúdo!', function (err){
    if (err) throw err;
    console.log('Salvo!')
})

E esse será o resultado:

Esses são os métodos de leitura e criação de arquivos utilizando o File System do NodeJS!

Gostou deste artigo? Acompanhe os próximos artigos e comente abaixo!

Azure DevOps + Docker + Node.js

Veja nesse artigo como automatizar o processo de deploy do seu projeto utilizando Docker e o Azure DevOps.

Dando continuidade ao meu artigo anterior: publicando imagem Docker no Azure Web App for Containers em 7 passos, hoje eu irei demonstrar como automatizar o processo de deploy demonstrando no artigo anterior, utilizando o Azure DevOps.

Para os próximos passos será necessário ter uma conta no Azure. Caso você ainda não tenha uma, eu recomendo a leitura do seguinte artigo: Azure DevOps + Angular + GitHub Pages, nele eu demonstro a criação de uma nova conta e a criação de uma pipeline no Azure DevOps.

Com o passo da conta OK, a sua imagem no Docker hub (passo demonstrado no artigo anterior) e o seu projeto já publicado no Web App for Containers. Vamos agora criar a nossa pipeline no Azure DevOps. Para isso, siga os passos abaixo:

Clique em pipelines:

Criando pipeline no Azure DevOps

Em seguida clique em Create Pipeline:

Criando pipeline no Azure DevOps

Agora clique em Use the classic editor:

Selecione o local do seu repositório, para esse exemplo eu irei utilizar um projeto versionado no meu GitHubnode-azure-7-steps. Clique nos três pontos e selecione o seu projeto:

GitHub Azure DevOps

Em seguida selecione a sua branch:

Selecionando branch Azure DevOps

Agora selecione o template Docker container.

Docker no Azure DevOps

Esse template deve criar dois stepsBuild an Image para criar uma nova versão da imagem do seu projeto e Push an image, para publicar a imagem no no seu repositório de imagens, nesse artigo eu irei enviar para o Docker Hub.

Build imagem docker no Azure DevOps

Agora vamos dar permissão para pipeline subir uma nova versão da sua imagem no Docker Hub. Para isso, siga os passos abaixo:

Clique em Push an image, em Container Registry Type selecione Container Registry, em seguida selecione a sua conexão.

Caso não tenha uma conta registrada ainda, clique em + New e preenche a modal com os seus dados de acesso no Docker Hub.

Em seguida clique em Include Latest Tag:

E no nome da imagem coloque o seu usuário do dockerhub e o nome da sua imagem no passo de build e release:

Build

Release

Para verificar se tudo esta OK, clique em Save & queue e rode o processo:

build imagem doker no Azure DevOps

Quando esse processo finalizar você deve receber o resultado abaixo:

Build OK Azure DevOps

Com o processo do build OK, vamos criar a nossa release. Para isso, clique em Releases -> New pipeline e selecione o template Azure App Service deployment.

Clique em Artifacts e preencha conforme os passos abaixo:

  • Project: nome do projeto
  • Source (build pipeline): sua pipeline de build
  • Default version: versão que deve pegar
  • Source alias: nome do artefato

Criando relase node.js + docker no Azure DevOps

Agora clique em 1 job e forneça os dados do seu projeto no Azure Web App for Containers conforme lista abaixo:

  • Display name: nome da aplicação
  • Azure subscription: Subscription no Azure
  • App name: nome da sua aplicação no Azure
  • Image name: nome da imagem com o sufixo latest

Obs.: Esse sufixo garante que iremos sempre pegar a ultima versão da imagem criada.

Agora para verificar se todos passos anteriores estão OK, clique em Create release para gerar uma nova release do seu projeto:

Criando release Azure DevOps

Ao clicar em Create Release irá subir a seguinte mensagem:

Clique na sua Release para acompanhar o processo de deploy. Caso tudo esteja OK você deve receber o retorno abaixo:

Agora clique em Succeed:

Em seguida clique em Azure Wer App on Container Deploy:

E dentro do log copie a URL do seu projeto:

Agora para finalizar, cole a url no seu navegador e verifique se a ultima alteração do seu projeto esta nessa versão publicada:

Bom, a ideia desse artigo era demonstrar como automatizar o processo de deploy criado em um dos meus artigos anteriores.

Espero que tenham gostado e até um próxima artigo pessoal 😉

Confira o artigo original em: https://medium.com/xp-inc/azure-devops-docker-node-js-90cff720af22

Gostou deste artigo? Comente abaixo!